Manual Programacion Robobo

Manual de programación
de Robobo con Python
Octubre de 2022
Manual de programación deo con Python

Manual de programación deo con Python .............................................................................................. 1

1. | Introducción .................................................................................................................................. 8
2. | Introducción a Robobo y RoboboSim............................................................................................ 8
2.1 Robobo ................................................................................................................................... 8
2.2 RoboboSim............................................................................................................................ 10
2.2.1 Menú principal ...................................................................................................................... 11
2.2.2 Menú de selección de mundo ............................................................................................... 12
2.2.3 Menú de opciones................................................................................................................. 14
2.2.4 Entorno de simulación .......................................................................................................... 16
3. | Comenzar a programar con robobopy ........................................................................................ 17
3.1 Instalación de la librería, importación y conexión con Robobo ........................................... 17
3.2 Ventana de monitorización .................................................................................................. 19
3.3 Conexión de robobopy y RoboboSim ................................................................................... 19
3.4 Clases y enumerados requeridos ......................................................................................... 22
3.5 Modos de ejecución ............................................................................................................. 22
3.6 Método wait ......................................................................................................................... 22
3.7 Módulos habilitados y deshabilitados .................................................................................. 23
3.8 Coordenadas de la pantalla .................................................................................................. 24
3.9 Cambios persistentes ........................................................................................................... 24
4. | Métodos de actuación................................................................................................................. 25
4.1 Motores ................................................................................................................................ 25
Introducción ....................................................................................................................................... 25
Elementos de programación .............................................................................................................. 26
4.1.1 Enumerado Wheels ............................................................................................................... 26
4.1.2 Método moveWheelsByDegrees .......................................................................................... 26
4.1.3 Método moveWheelsByTime ............................................................................................... 27
4.1.4 Método moveWheels ........................................................................................................... 28
4.1.5 Método stopMotors .............................................................................................................. 28
4.1.6 Método movePanTo ............................................................................................................. 29
4.1.7 Método moveTiltTo .............................................................................................................. 30
4.2 Síntesis de voz y sonido ........................................................................................................ 31
Introducción ....................................................................................................................................... 31
2
Anexo 1
4.2.1 Enumerado Sounds ............................................................................................................... 31

4.2.2 Método sayText .................................................................................................................... 31
4.2.3 Método playNote .................................................................................................................. 32
4.2.4 Método playSound ................................................................................................................ 33
4.3 LEDs....................................................................................................................................... 34
Introducción ....................................................................................................................................... 34
4.3.1 Enumerado LED ..................................................................................................................... 34
4.3.2 Enumerado Color .................................................................................................................. 35
4.3.3 Método setLedColorTo ......................................................................................................... 35
4.4 Expresiones de Robobo ........................................................................................................ 36
Introducción ....................................................................................................................................... 36
4.4.1 Enumerado Emotions............................................................................................................ 36
4.4.2 Método setEmotionTo .......................................................................................................... 37
5. | Métodos de sensorización .......................................................................................................... 38
5.1 Batería................................................................................................................................... 38
Introducción ....................................................................................................................................... 38
5.1.1 Método readBatteryLevel ..................................................................................................... 38
5.2 Sensores infrarrojos .............................................................................................................. 39
Introducción ....................................................................................................................................... 39
5.2.1 Enumerado IR ........................................................................................................................ 39
5.2.2 Método readIRSensor ........................................................................................................... 40
5.2.3 Método readAllIRSensor ....................................................................................................... 40
5.3 Motores ................................................................................................................................ 41
Introducción ....................................................................................................................................... 41
5.3.1 Enumerado Wheels ............................................................................................................... 41
5.3.2 Método readWheelPosition.................................................................................................. 42
5.3.3 Método readWheelSpeed ..................................................................................................... 42
5.3.4 Método resetWheelEncoders() ............................................................................................ 43
5.3.5 Método readPanPosition ...................................................................................................... 44
5.3.6 Método readTiltPosition ....................................................................................................... 45
3
Anexo 1
5.4 Mensajes de estado .............................................................................................................. 46

Introducción ....................................................................................................................................... 46
5.4.1 Enumerado StatusFrequency ................................................................................................ 46
5.4.2 Método setStatusFrecuency ................................................................................................. 46
5.5 Cámara .................................................................................................................................. 47
Introducción ....................................................................................................................................... 47
5.5.1 Método setStreamFPS .......................................................................................................... 48
5.5.2 Método setCameraFPS ......................................................................................................... 48
5.5.3 Método setFrontCamera() .................................................................................................... 49
5.5.4 Método setBackCamera........................................................................................................ 50
5.5.5 Método startCamera............................................................................................................. 50
5.5.6 Método stopCamera ............................................................................................................. 51
5.5.7 Método startStream ............................................................................................................. 51
5.5.8 Método stopStream .............................................................................................................. 53
5.6 Luz ......................................................................................................................................... 53
Introducción ....................................................................................................................................... 53
5.6.1 Método readBrightnessSensor ............................................................................................. 54
5.7 Detección de blobs ............................................................................................................... 54
Introducción ....................................................................................................................................... 54
5.7.1 Clase Blob .............................................................................................................................. 54
5.7.2 Enumerado BlobColor ........................................................................................................... 55
5.7.3 Método readColorBlob ......................................................................................................... 56
5.7.4 Método setActiveBlobs ......................................................................................................... 57
5.7.5 Método readAllColorBlobs() ................................................................................................. 58
5.7.6 Método resetColorBlobs ....................................................................................................... 59
5.7.7 Método whenANewColorBlobIsDetected ............................................................................ 59
5.7.8 Método setAdvancedLostBlobParameters ........................................................................... 60
5.8 Detección facial .................................................................................................................... 61
Introducción ....................................................................................................................................... 61
5.8.1 Clase Face .............................................................................................................................. 61
4
Anexo 1
5.8.2 Método startFaceDetection() ............................................................................................... 61

5.8.3 Método stopFaceDetection .................................................................................................. 61
5.8.4 Método resetFaceSensor ...................................................................................................... 62
5.8.5 Método readFaceSensor ....................................................................................................... 62
5.8.6 Método whenAFaceIsLost..................................................................................................... 63
5.8.7 Método whenANewFaceIsDetected(callback)...................................................................... 64
5.9 Detección de objetos ............................................................................................................ 64
Introducción ....................................................................................................................................... 64
5.9.1 Clase DetectedObject............................................................................................................ 64
5.9.2 Método startObjectRecognition() ......................................................................................... 65
5.9.3 Método stopObjectRecognition() ......................................................................................... 65
5.9.4 Método readDetectedObject() ............................................................................................. 65
5.9.5 Método whenAnObjectIsDetected ....................................................................................... 66
5.10 Micrófono ............................................................................................................................. 66
Introducción ....................................................................................................................................... 66
5.10.1 Clase Note ........................................................................................................................... 67
5.10.2 Método readLastNote ......................................................................................................... 67
5.10.3 Método whenANoteIsDetected .......................................................................................... 68
5.10.4 Método readClapCounter ................................................................................................... 69
5.10.5 Método resetClapCounter .................................................................................................. 69
5.10.6 Método whenClapIsDetected ............................................................................................. 70
5.10.7 Método readNoiseLevel ...................................................................................................... 71
5.11 Sensor táctil .......................................................................................................................... 71
Introducción ....................................................................................................................................... 71
5.11.1 Clase Tap ............................................................................................................................. 72
5.11.2 Método readFlingAngle ...................................................................................................... 72
5.11.3 Método readFlingDistance.................................................................................................. 73
5.11.4 Método readFlingTime........................................................................................................ 73
5.11.5 Método resetFlingSensor() ................................................................................................. 74
5.11.6 Método whenAFlingIsDetected .......................................................................................... 75
5.11.7 Método readTapSensor ...................................................................................................... 75
5.11.8 Método resetTapSensor ..................................................................................................... 75
5
Anexo 1
5.11.9 Método whenATapIsDetected ............................................................................................ 76

5.12 Sensor de orientación ........................................................................................................... 77
Introducción ....................................................................................................................................... 77
5.12.1 Clase Orientation ................................................................................................................ 77
5.12.2 Método readOrientationSensor ......................................................................................... 77
5.13 Sensor de aceleración ........................................................................................................... 78
Introducción ....................................................................................................................................... 78
5.13.1 Clase Acceleration ............................................................................................................... 78
5.13.2 Método readAccelerationSensor ........................................................................................ 79
5.14 Detección de carriles ............................................................................................................ 79
Introducción ....................................................................................................................................... 79
5.14.1 Clase LaneBasic ................................................................................................................... 80
5.14.2 Clase LanePro ...................................................................................................................... 80
5.14.3 Método startLaneDetection ............................................................................................... 80
5.14.4 Método stopLaneDetection ................................................................................................ 80
5.14.5 Método readLaneBasic ....................................................................................................... 81
5.14.6 Método readLanePro .......................................................................................................... 81
5.14.7 Método whenALaneBasicDetected .................................................................................... 82
5.14.8 Método whenALaneProDetected ....................................................................................... 83
5.14.9 Método setLaneColorInversion .......................................................................................... 84
5.15 Detección de códigos QR ...................................................................................................... 84
Introducción ....................................................................................................................................... 84
5.15.1 Clase QRCode ...................................................................................................................... 84
5.15.2 Método startQrTracking ..................................................................................................... 85
5.15.3 Método stopQrTracking ...................................................................................................... 86
5.15.4 Método readQR .................................................................................................................. 86
5.15.5 Método whenAQRCodeIsDetected..................................................................................... 87
5.15.6 Método whenANewQRCodeIsDetected ............................................................................. 87
5.15.7 Método whenAQRCodeIsLost ............................................................................................. 88
5.16 Detección de marcadores ArUco .......................................................................................... 89
Introducción ....................................................................................................................................... 89
6
Anexo 1

5.16.1 Clase Tag ............................................................................................................................. 89
5.16.2 Método startArUcoTagDetection ....................................................................................... 90
5.16.3 Método stopArUcoTagDetection ........................................................................................ 90
5.16.4 Método readArucoTag ........................................................................................................ 91
5.16.5 Método setArucoTagSize .................................................................................................... 91
5.16.6 Método whenArucoTagIsDetected ..................................................................................... 92
5.17 Detección de líneas............................................................................................................... 93
Introducción ....................................................................................................................................... 93
5.17.1 Clase Lines ........................................................................................................................... 93
5.17.2 Método startLineDetection ................................................................................................ 93
5.17.3 Método stopLineDetection ................................................................................................. 94
5.18 Método readLine .................................................................................................................. 94
5.18.1 Método whenALineIsDetected ........................................................................................... 95
7
Anexo 1
1. | Introducción
En este manual se documenta la librería de programación robobopy para el robot Robobo. Se
considera que el usuario tiene conocimientos previos de python, por lo que no se explicarán
conceptos que se consideran básicos de programación, como variables, condicionales, bucles, listas o
funciones.
Este manual no es un tutorial y no está pensado para ser leído de forma secuencial. Sin embargo, sí
se recomienda primero leer los apartados 2 y 3 para entender algunas características generales de la
librería y del robot.
Los elementos de programación están agrupados por funcionalidad. Por ejemplo, en el apartado
Motores, se encuentra todo lo relacionado con el movimiento de Robobo. Antes de consultar cualquier
método, se recomienda leer la introducción del grupo de métodos correspondiente.
La documentación original se puede consultar en:
https://mintforpeople.github.io/robobo.py/
2. | Introducción a Robobo y RoboboSim

2.1 Robobo
Robobo es un robot real de investigación y educación compuesto por una plataforma robótica, la base
Robobo, y un smartphone que se acopla a dicha base (ver imagen izquierda en la Fig. 1). La base
constituye el cuerpo del robot, proporcionando movilidad y algunas capacidades de detección,
mientras que el smartphone es el cerebro del Robobo, proporcionando potencia de procesamiento en
bruto y capacidades de detección/actuación de alto nivel.
Tanto la base como el smartphone disponen de una serie de sensores y actuadores adecuados para el
aprendizaje en robótica inteligente, que se pueden observar en la imagen de la derecha de la Fig. 1.
Los sensores permiten recibir información del entorno (por ejemplo, medir distancias o percibir
colores) y los actuadores permiten realizar acciones (por ejemplo, moverse o hablar) en el mundo real.
Los principales sensores de Robobo (base + Smartphone) son:
● 8 sensores infrarrojos, 5 situados en la parte delantera de la base y 3 en la parte trasera. Se
utilizan para medir las distancias a objetos del entorno, como paredes u obstáculos.
● 2 codificadores de motor (encoder) en las ruedas, permiten conocer los grados de giro o la
velocidad real aplicada por el motor.
● 1 codificador de motor (encoder) en el motor PAN, para leer su posición.
● 1 codificador de motor (encoder) en el motor TILT, para leer su posición.
● Sensor de batería, permite conocer el nivel de batería del robot.
8
Anexo 1
● Cámara. Se utiliza para detectar información visual, como blobs de colores, señales de tráfico,
códigos QR, y cualquier objeto del mundo real.
● Giroscopio 3D, para conocer la orientación del robot.
● Acelerómetro 3D, para leer la aceleración del Robobo.
● Pantalla táctil para detectar contacto y gestos sobre ella.
Fig. 1. Imagen del robot Robobo (izda) y conjunto de sensores y actuadores principales (dcha)
Los principales actuadores de Robobo son:

● 2 motores en las ruedas. Cada una de las ruedas puede girar de forma independiente hacia
delante o hacia atrás. Con la combinación de distintos movimientos, es posible el movimiento
de Robobo en varias direcciones.
● 1 motor para movimiento TILT. Este motor permite realizar mover la cabeza del robot
(Smartphone) hacia delante y hacia atrás.
● 1 motor para movimiento PAN. Este motor permite que la cabeza del robot (Smartphone) gire
hacia la derecha y hacia la izquierda sin necesidad de girar las ruedas de la base.
● 7 luces LED de color, 5 ubicadas en la parte delantera de la base y 2 en la parte trasera. Cada
una de ellas se puede encender o apagar de forma independiente y mostrar el color deseado.
● Altavoz para emitir sonidos, notas musicales y síntesis de voz, es decir, para que el robot pueda
hablar y por tanto comunicarse de forma natural con las personas con las que interactúa.
9
Anexo 1
● Pantalla para mostrar imágenes, como distintas expresiones en la cara del robot.
2.2 RoboboSim
Robobo se puede programar también a través de un modelo de simulación realista, denominado

RoboboSim (Fig. 2). Es un simulador computacionalmente ligero y totalmente funcional, que permitirá
desarrollar los ejercicios y proyectos que se realizarán en este curso en distintos entornos.
Fig. 2. Captura de pantalla de un mundo en RoboboSim
Para instalar el simulador, basta con acceder a la wiki de Robobo y descargar la versión
correspondiente a tu sistema operativo:
https://github.com/mintforpeople/robobo-programming/wiki/Unity
Una vez descargada, simplemente debes descomprimir el archivo y guardar el programa en la
ubicación de tu ordenador que desees (no requiere instalación como tal). En ese momento podemos
ejecutar el programa, simplemente haciendo doble click sobre el archivo descomprimido.
NOTA: los usuarios de MacOS pueden recibir un mensaje de error al intentar ejecutar este archivo, que
impide abrirlo. La solución más sencilla es pulsar la tecla CTRL + botón derecho Abrir, lo cual mostrará
una ventana con la opción “Abrir”, y bastará con hacer click sobre ella. Esta acción no es necesario
repetirla.
En la próxima sección se explican los diferentes menús y opciones del RoboboSim.
10
Anexo 1
2.2.1 Menú principal
El menú principal presenta cinco botones que permiten navegar a las diferentes secciones del
simulador.
● “World Select”: Permite acceder a la selección de los diferentes mundos simulados.
● “Options”: Lleva al menú de configuración y opciones. Estas opciones alteran el
comportamiento del simulador y permiten ajustarlo a nuestras necesidades
● “Help”: Lleva a la página de ayuda del simulador.
● “About”: Proporciona información sobre la versión del simulador.
● “Exit”: Sale de la aplicación del simulador y la cierra. Este comportamiento es idéntico a usar
el botón de cerrar ventana de la barra de título del programa.
11
Anexo 1
2.2.2 Menú de selección de mundo
Este menú permite seleccionar y arrancar los diferentes mundos simulados. Existen varios mundos con
diferentes elementos como obstáculos, pelotas o señales de tráfico.
Para navegar por la lista de mundos puede usarse tanto la rueda del ratón como la barra de scroll azul
del margen derecho de la ventana. En controles táctiles, aunque también con el ratón, puede
arrastrarse la lista de mundos arriba y abajo.
El botón situado en la parte superior izquierda con el icono del proyecto Robobo permite volver al
menú principal
El botón situado en la parte inferior izquierda lleva al menú de opciones detallado previamente.
Una vez elegido un mundo, comenzará la simulación. Los mundos disponibles en “World Select” son:
● “Ball Track”. Mundo con un cilindro y una esfera verde para realizar ejercicios sencillos de
detección de blobs. Incluye comportamiento aleatorio que permite cambiar la posición de la
esfera, aunque siempre dentro del rango de visión del robot.
● “Four Walls”. Mundo sencillo donde el espacio está restringido por cuatro paredes. Incluye
comportamiento aleatorio para cambiar el tamaño y la posición de las paredes.
● “Cylinder”. Mundo sencillo con un cilindro y una esfera. Incorpora comportamiento aleatorio
para cambiar la posición del cilindro y la esfera.
12
Anexo 1
● “Four Cylinders”. Mundo sencillo con cuatro cilindros y bolas de colores que sirven de blobs.
Incorpora comportamiento aleatorio para cambiar el color de los elementos.
● “Pillars”. Mundo con 4 cilindros y un código Aruco, ideado para trabajar la navegación.
● “Avoid the Block”. Mundo de navegación infrarroja en el que se rodea un bloque de tamaño y
dimensiones variables. Incluye comportamiento aleatorio para modificar el tamaño y la
posición del bloque.
● “Maze”. Laberinto en U con un cilindro al final, pensado para guiarse por las paredes, luz, blobs
o QRs. Incluye comportamiento aleatorio para modificar la forma del laberinto, la posición
incial de Robobo y la posición del cilindro.
● “Simple maze”. Laberinto en U muy similar al anterior, pero sin cilindro. También pensado para
guiarse por las paredes, luz, blobs o QRs. Incluye comportamiento aleatorio para modificar la
forma del laberinto y la posición inicial de Robobo.
● “Test Plane”. Plano con una recta muy larga y paredes para realizar pruebas de velocidades y
sensores.
● “Slope”. Dos rampas con distintas pendientes. Incluye comportamiento aleatorio para cambiar
las pendientes.
● “Recycling”. Un mundo más complejo ya que hace uso de la detección de objetos. Hay varios
objetos y varios contenedores marcados con un QR. Incluye comportamiento aleatorio para
modificar el tipo, número y ubicación de los distintos elementos.
● “Recycling simple”. Similar al anterior, pero solo incluye un objeto de cada vez.
● “Pedestrian Road”. Carretera sencilla, que incluye un peatón cruzando el paso de cebra.
Incluye comportamiento aleatorio para modificar la posición de las personas y para hacer que
aparezcan otros Robobos en la carretera.
● “Robobo Road”. Carretera sencilla que incluye señales de límite de velocidad y otro Robobo
circulando. Incluye comportamiento aleatorio para modificar los valores de las señales y la
posición del otro Robobo.
● “Speed Road”. Carretera sencilla, que incluye señales de límite de velocidad.
● “Parking”. Incluye dos postes para aparcar el robot entre ellos utilizando la detección de QRs.
Entre los dos postes hay espacio suficiente para aparcar. Incluye comportamiento aleatorio
para cambiar la distancia de los postes; esto podría hacer que el espacio no fuese suficiente.
● “Parking - Enough”. Incluye dos postes para aparcar el robot utilizando la detección de QRs,
con espacio holgado entre ellos.
● “Parking - Narrow”. Incluye dos postes para aparcar el robot utilizando la detección de QRs,
pero los postes están demasiado juntos como para aparcar entre ellos.
● “Measure Plane”. Plano para realizar medidas con las marcas del suelo y los sensores.
13
Anexo 1
● “Aruco navigation”. Circuito con dos cilindros de colores y un código ArUco pensado para
navegación a través de los distintos elementos del entorno.
2.2.3 Menú de opciones
El menú de opciones controla el comportamiento de algunos aspectos de la simulación.

El botón “Back” nos permite regresar a la anterior ventana desde la que hayamos accedido al menú de
opciones, sea esta el menú principal o la pantalla de selección de mundos.
● “Activate Random Behaviour in Worlds”. Algunos mundos simulados cuentan con elementos
aleatorios que cambian cada vez que la simulación es reiniciada. Esto permite introducir
variaciones a la hora de probar la programación del robot sobre las versiones estáticas e
invariantes de los mundos.
○ “Ball Track”: La bola aparece en diferentes posiciones, pero siempre en el rango de
visión del robot.
○ “Four Walls”: Las paredes cambian de tamaño y posición
○ “Cylinder”: El cilindro con la esfera cambia de ubicación
○ “Four cylinders”: Los cilindros con las esferas cambian de color.
○ “Avoid the Block”: El bloque cambia de tamaño y posición.
○ “Maze”: Cambia la forma del laberinto.
○ “Simple maze”: Cambia la forma del laberinto.
14
Anexo 1
○ “Slope”: Las rampas cambian de pendiente.

○ “Recycling”: Los elementos de reciclado cambian de tipo, número y ubicación.
○ “Pedestrian Road”: Se modifica la posición del peatón y hace que puedan aparecer
otros Robobos en la carretera.
○ “Robobo Road”: Se modifican los valores de las señales y la posición del otro Robobo.
○ “Parking”: Los postes de parking cambian de posición haciendo el espacio de
aparcamiento más grande o más pequeño. Esto podría hacer que el espacio no fuese
suficiente para aparcar.
● “Phone Battery Duration (Mins)”. Debido a que el sensor de batería del teléfono se simula
mediante una descarga continua, esta opción permite ajustar el tiempo que el teléfono tardará
en descargarse completamente.
● “Horizontally Flip Front Camera”. La cámara frontal de los smartphones suele voltear las
imágenes horizontalmente (modo espejo). Esta opción permite configurar si se desean voltear
o no. Afecta al streaming de la cámara y a los módulos de detección de blobs, QR, ArUco y
objetos. El usuario debe ser consciente de si la cámara del smartphone voltea o no las
imágenes y programar en consecuencia. Activando o desactivando esta opción, un programa
puede pasar de tener un comportamiento extraño a tener el comportamiento deseado.
● “Camera Stream FPS”. Ajusta los fotogramas por segundo que produce el vídeo externo de la
cámara del teléfono, puede mejorar el rendimiento en programas que usen esta característica
en equipos menos potentes.
● “Visualize Audio as Speech Bubbles”. Permite visualizar los sonidos, notas y voces producidas
por el robot como bocadillos de texto sobre el robot para permitir trabajar con el simulador
sin sonido o para ayudar a la gente con dificultades auditivas.
● “Audio Text Speed”. Controla la velocidad a la que se produce el habla y los sonidos. Además,
modifica la velocidad a la que se muestran los bocadillos de texto configurados en la opción
anterior.
● “Artificial Voice Type”. Permite elegir la voz que utilizará Robobo al hablar, de entre las
instaladas en el equipo. Normalmente, los sistemas operativos tienen voces instaladas por
defecto; en caso de que el desplegable no muestre ninguna opción, habría que instalarlas.
15
Anexo 1
2.2.4 Entorno de simulación
La interfaz de la vista de simulación se compone de múltiples elementos controlables con ratón y

teclado.
En el entorno de simulación, la cámara se mueve con los siguientes controles:
● Click Derecho y arrastre: Rotación de la cámara sobre el robot o sobre el punto fijo deseado.
● Click Central y arrastre: En el modo de cámara no centrada sobre el robot, permite desplazar
la cámara libremente.
● Scroll con la rueda: Permite hacer zoom en la simulación, acercando o alejando la cámara
según se requiera.
Los iconos de la parte superior permiten controlar el comportamiento del simulador. Haciendo click
en ellos con el cursor se activan o se desactivan las siguientes funciones, detalladas de izquierda a
derecha:
● Atrás: Termina la simulación y vuelve a la anterior vista.

● Pausa/Play: Detiene o reanuda la simulación
16
Anexo 1
● Reinicio: Reinicia la simulación, devolviendo el robot a la posición inicial indicada en el mundo

por el icono de la flecha azul en el suelo y los diferentes elementos interactuables a su estado
y posiciones originales. Se reinician otros elementos como el estado de los motores o la
descarga de la batería.
● Centrado/Libre: Alterna el modo de control de la cámara para estar siempre ubicada sobre la
posición del robot en el mundo, siguiéndolo cuando se desplaza, o para que se quede fija en
el punto deseado, pudiendo moverla y rotarla con el ratón.
● Ojo de Robobo: Activa y desactiva la interfaz de perspectiva del robot, que nos permite ver la
cámara del teléfono y la expresión del Robobo en tiempo real, así como interactuar sobre la
cara del Robobo con el ratón, simulando toques y gestos en la pantalla del teléfono.
Cada uno de estos iconos tiene su correspondencia con una tecla del teclado:
● Escape: Equivalente a pulsar el botón “Atrás”.
● Barra Espaciadora: Equivalente a pulsar el botón “Pausa/Play”.
● Retroceso: Equivalente a pulsar el botón “Reinicio”.
● C: Equivalente a pulsar el botón “Centrado/Libre”.
● Enter/Retroceso: Equivalente a pulsar el botón “Ojo de Robobo”.
3. | Comenzar a programar con robobopy

Antes de comenzar la descripción de los métodos de Python que nos permitirán programar a Robobo,
es necesario instalar la librería correctamente, y tener claros algunos conceptos clave para realizar los
programas con éxito.
3.1 Instalación de la librería, importación y conexión con Robobo
Para poder ejecutar código en el robot, es necesario instalar la librería robobopy. Para ello utilizaremos
el gestor de paquetes de Python pip (package instaler for Python).
A continuación, se explican los pasos para instalar esta librería con pip. Para ello, usaremos la terminal
“PowerShell” de Windows:
1. Escribimos “PowerShell” en el campo de búsqueda de la barra de Windows
2. Aparecerá la opción “Windows PowerShell”. Se seleccionará esta opción.
3. A continuación, se abrirá una ventana con la terminal “Windows PowerShell”:
17
Anexo 1
4. Para instalar la librería, se ejecutará en la terminal PowerShell el comando siguiente:

C:\ pip install robobopy
NOTA: para la versión de MacOS podría ser necesario utilizar el comando pip3
Todos los programas que se desarrollen en Python para programar al robot Robobo tienen una primera
parte inicial común: importar la librería robobopy y realizar la conexión con el robot real o con el
simulador.
Siempre será necesario incluir al menos las siguientes líneas:
1. Se importa la clase Robobo de la librería robobopy.
from robobopy.Robobo import Robobo
2. Se crea un objeto de la clase Robobo, indicando la dirección IP de Robobo.

2.1 En el caso del robot físico, se pone la IP correspondiente. Por ejemplo, si la IP es 10.113.26.130
se incluye la siguiente línea.
rob = Robobo("10.113.26.150")
2.2 En el caso del simulador, lo habitual es tenerlo instalado en el mismo ordenador en el que se
realizan los programas, con lo que la dirección será “localhost”.
rob = Robobo("localhost")
3. Se establece la conexión con el simulador, a través del método “connect”:
rob.connect()
Más detalles sobre la configuración del robot Robobo en Python están desarrollados en:
18
Anexo 1
https://github.com/mintforpeople/robobo-programming/wiki/python-doc
3.2 Ventana de monitorización
Mientras se están creando programas con Robobo, puede ser necesario conocer el valor de los
sensores de cara a establecer umbrales o valores de referencia. Por este motivo, Robobo incluye una
ventana de monitorización web, que es altamente recomendable tener abierta. Para acceder a esta
ventana, basta con ir a esta url: http://monitor.theroboboproject.com/
En la página que se abre, debemos escribir, en la parte superior izquierda, la dirección IP del robot real
o bien localhost si estamos usando RoboboSim, y pulsar el botón Connect.
La ventana de monitorización mostrará los valores de los diferentes sensors en tiempo real según van
cambiando.
3.3 Conexión de robobopy y RoboboSim
Una vez instalada la aplicación, podemos comprobar su correcto funcionamiento en RoboboSim

mediante la ejecución de un programa de ejemplo simple. Antes de nada, se debe ejecutar el
simulador, y en la pantalla inicial, se accede a la selección de mundos a través del botón “World select”.
19
Anexo 1
Se elige un mundo; por ejemplo, “Four Walls”.
Al pulsar sobre la imagen en miniatura del mundo, se muestra una pantalla como la siguiente:
A continuación, creamos un archivo “prueba.py” en Visual Studio Code (u otro IDE similar) con el
siguiente contenido:
20
Anexo 1
# Importamos la librería
# Creamos una instancia de la clase Robobo con la dirección IP “localhost

# Conectamos con el simulador

rob.connect()
# Robobo se mueve en línea recta durante 4 segundos

rob.moveWheelsByTime(10, 10, 4)
# Desconectamos Robobo
rob.disconnect()
El último paso es ejecutar el ejemplo y el robot debería moverse en línea recta durante 4 segundos.
Es importante destacar que algunos módulos no están implementados en el simulador y, por lo tanto,
no se puede utilizar ninguno de sus métodos. Los módulos no implementados en el simulador son:
• Micrófono.
• Detección facial.
• Detección de líneas.
• Detección de carriles.
21
Anexo 1
La cámara del simulador siempre está activa por defecto, por lo que los métodos startCamera y
stopCamera no están implementados. Además, solo se trabaja con la cámara frontal del teléfono, por
lo que los métodos setFrontCamera y setBackCamera no están implementados.
Justo al comienzo de la ejecución de un programa en el simulador, los valores de los sensores no están
cargados todavía, por lo que hay que esperar un instante para poder leerlos. Si la primera instrucción
de un programa consiste en leer un sensor, puede devolver un valor de 0, que no se correspondería
con el valor medido en otro momento para las mismas condiciones.
Por último, el simulador puede emitir sonidos como el robot real, pero también es posible mostrar un
bocadillo con el texto que se está reproduciendo.
3.4 Clases y enumerados requeridos
En algunos casos, los parámetros que reciben los métodos o los valores que devuelven, son clases o
enumerados que se encuentran en otros módulos y por tanto tendremos que añadir un import de las
clases o enumerados que necesitemos.
En cada grupo de métodos se describen de forma detallada las clases y los enumerados necesarios
para la utilización de ese grupo de métodos.
Por ejemplo, Robobo tiene varios infrarrojos para detectar la distancia a los objetos cercanos. Estos
infrarrojos están almacenados en el enumerado IR. El Método readIRSensor sirve para leer los valores
detectados por un infrarrojo, pero es necesario especificar qué sensor infrarrojo se desea leer. Para
eso se utiliza el enumerado IR, y antes de utilizarlo es necesario añadir la siguiente línea:
from robobopy.utls.IR import IR
3.5 Modos de ejecución
Lo métodos de Robobo, permiten en la mayoría de los casos, dos modos de ejecución: bloqueante y
no bloqueante:
• Una instrucción es bloqueante cuando evita que se realice otra hasta que la instrucción en curso
termine su ejecución completamente.
• Una instrucción es no bloqueante cuando permite que se ejecute otra al mismo tiempo. Por
ejemplo: el robot avanza hacia delante (instrucción de movimiento) al mismo tiempo gira la cabeza
(instrucción de movimiento) y comunica información a través del altavoz (instrucción de
producción de sonido).
3.6 Método wait
El método wait es un método especial que hacer que Robobo espere durante el tiempo indicado antes
de ejecutar la siguiente instrucción. A lo largo de este manual se utiliza en muchos de los ejemplos.
22
Anexo 1
wait(seconds)
Pausa el programa durante el tiempo especificado. Después de ese tiempo, se ejecuta la siguiente
instrucción.
Parámetros:
• seconds (float): El tiempo en segundos. Los valores deben ser positivos.
EJEMPLO DE USO
El siguiente programa hace que Robobo se mueva en línea recta hacia delante durante dos segundos;
luego espera durante dos segundos y, por último, se vuelve a mover durante dos segundos.
from robobopy.utils.Wheels import Wheels
rob.connect()
rob.wait(2)
3.7 Módulos habilitados y deshabilitados
Un módulo agrupa un conjunto de métodos que puede utilizar Robobo. Para mejorar el rendimiento,
algunos módulos están deshabilitados por defecto. Para utilizar estos módulos, es necesario activarlos.
Después de utilizarlos, es recomendable deshabilitarlos.
Por ejemplo, la detección de ArUco está deshabilitada por defecto. Para utilizar cualquier método
relacionado con la detección de ArUcos, como el Método readArucoTag, primero es necesario habilitar
el módulo con el método startArUcoTagDetection. Después de trabajar con la detección de ArUcos, se
puede deshabilitar con el método stopArUcoTagDetection.
Los módulos habilitados por defecto son:
• Detección de caras.
• Detección de blobs.
• Detección de QRs.
Los módulos deshabilitados por defecto son:
• Stream de la cámara.
• Detección de líneas.
23
Anexo 1
• Detección de carriles.
• Reconocimiento de objetos.
• Detección de ArUcos.
3.8 Coordenadas de la pantalla
En algunos métodos se utilizan coordenadas para indicar la posición de ciertos elementos dentro de la
pantalla.
Las coordenadas de la pantalla tienen su origen en la esquina superior izquierda de la pantalla, como
se ve en la figura siguiente. El eje X sigue el borde superior de la pantalla, de izquierda a derecha. Toma
valores entre 0 y 100, siendo 0 el borde izquierdo y 100 el borde derecho de la pantalla. El eje Y sigue
el borde izquierdo de la pantalla, de arriba abajo. Toma valores entre 0 y 100, siendo 0 el borde
superior y 0 el borde inferior de la pantalla.
3.9 Cambios persistentes
Algunos métodos afectan al hardware de Robobo. Los cambios persistentes permanecen incluso
cuando el programa termina y hasta que Robobo se reinicia, momento en el que toma de nuevo todos
los valores por defecto.
Por ejemplo, la detección de ArUcos está deshabilitada por defecto y se habilita con el método
startArUcoTagDetection. A partir de ese momento, se puede utilizar cualquier método relacionado con
la detección de ArUcos, como el método readArucoTag. Aunque finalice el programa, no será necesario
habilitar de nuevo la detección de ArUcos hasta que Robobo se reinicie. Una vez reiniciado, el módulo
estará de nuevo deshabilitado.
24
Anexo 1
4. | Métodos de actuación
4.1 Motores
Introducción
Robobo tiene cuatro motores:

• Motor en la rueda izquierda para girar y desplazarse.
• Motor en la rueda derecha para girar y desplazarse.
• Motor TILT para inclinar el smartphone hacia delante y hacia detrás de forma independiente a
la posición de la base. En la imagen siguiente se muestran las diferentes posiciones del motor
tilt, que se expresan en ángulos de entre 5 y 105 grados.
• Motor PAN para el smartphone hacia la derecha y hacia la izquierda de forma independiente
a la posición de la base. La imagen siguiente muestra las diferentes posiciones del motor pan,
que se expresan en ángulos de entre –160 y 160 grados. Los valores negativos hacen que el
smartphone esté girado hacia la izquierda, mientras que los valores positivos hacen que el
smartphone esté girado hacia la derecha
25
Anexo 1
Elementos de programación
4.1.1 Enumerado Wheels
Representa la lista de ruedas de Robobo.

R: Derecha.
L: Izquierda.
Both: Ambas.
4.1.2 Método moveWheelsByDegrees
moveWheelsByDegrees (wheel, degrees, speed)
Mueve las ruedas de Robobo en función de los grados de giro especificados. Permite establecer la
velocidad y los grados de giro de la rueda derecha, la rueda izquierda o ambas.
Parámetros:
• wheel (Wheels): Rueda o ruedas a mover.
• degrees (int): Ángulo de giro medido en grados. Toma valores positivos. Hay que tener en
cuenta que una vuelta completa de la rueda son 360 grados.
• speed (int): Factor de velocidad de giro que se aplica al motor de la rueda seleccionada. El
rango de valores permitidos para la velocidad está entre -100 y 100. El valor absoluto de
100 representa la máxima velocidad que la rueda puede alcanzar, mientras que 0 representa
que la rueda no se mueve. Los valores positivos mueven la rueda hacia delante y los valores
negativos hacia atrás.
26
Anexo 1
IMPORTANTE: Este método se ejecuta siempre en modo bloqueante (ver sección sobre Modos de
ejecución).
EJEMPLO DE USO
El siguiente programa hace que Robobo se mueva en línea recta a velocidad 30 hasta que las dos
ruedas (Wheels.Both) hayan girado 360 grados. A continuación, hace que la rueda izquierda (Wheels.L)
gire 180 grados hacia atrás a velocidad 30. Por último, hace que la rueda derecha (Wheels.R) gire 180
grados hacia delante a velocidad 50.
Robobo termina en la misma posición tras ejecutar las dos últimas instrucciones, ya que una rueda gira
y la otra permanece en el sitio.

rob.connect()
rob.moveWheelsByDegrees(Wheels.BOTH, 360, 30)

rob.moveWheelsByDegrees(Wheels.L, 180, -30)
rob.moveWheelsByDegrees(Wheels.R, 180, 50)
4.1.3 Método moveWheelsByTime
moveWeelsByTime(rSpeed, lSpeed, duration, wait=True)
Mueve las ruedas de Robobo durante el tiempo especificado, cada una a la velocidad especificada.
Parámetros:
• rSpeed (int). Factor de velocidad para la rueda derecha. El rango de valores permitidos está
entre -100 y 100. El valor absoluto de 100 representa la máxima velocidad que la rueda
puede alcanzar, mientras que 0 representa que la rueda no se mueve. Los valores positivos
mueven la rueda hacia delante y los valores negativos hacia atrás.
• lSpeed (int). Factor de velocidad para la rueda izquierda. El rango de valores permitidos está
entre -100 y 100. El valor absoluto de 100 representa la máxima velocidad que la rueda
puede alcanzar, mientras que 0 representa que la rueda no se mueve. Los valores positivos
mueven la rueda hacia delante y los valores negativos hacia atrás.
• duration (float). Duración del movimiento en segundos. Se permiten valores positivos.
27
Anexo 1
• wait (boolean): Indica si este método se ejecuta en modo bloqueante o no (True: modo
bloqueante, False: modo no bloqueante).
EJEMPLO DE USO
El siguiente programa hace que las ruedas de Robobo se muevan hacia delante a la misma velocidad
durante dos segundos, durante los cuales el robot avanzará en línea recta. Luego, hace que la velocidad
de la rueda derecha sea mayor que la de la rueda izquierda durante 3 segundos, por lo que el robot
girará hacia la izquierda.
rob.connect()
rob.moveWheelsByTime(60,40,3)
4.1.4 Método moveWheels
moveWheels (rSpeed, lSpeed)
Mueve las ruedas de Robobo. Este método permite establecer la velocidad de cada rueda. El
movimiento se realizará de forma indefinida hasta que sea detenido con el método stopMotors.
Parámetros:
• rSpeed (int): Factor de velocidad de giro del motor de la rueda derecha. El rango de valores
permitidos está entre -100 y 100. El valor absoluto de 100 representa la máxima velocidad
que la rueda puede alcanzar, mientras que 0 representa que la rueda no se mueve. Los
valores positivos mueven la rueda hacia delante y los valores negativos hacia atrás.
• lSpeed (int): Factor de velocidad de giro del motor de la rueda izquierda. El rango de valores
permitidos está entre -100 y 100. El valor absoluto de 100 representa la máxima velocidad
que la rueda puede alcanzar, mientras que 0 representa que la rueda no se mueve. Los
valores positivos mueven la rueda hacia delante y los valores negativos hacia atrás.
IMPORTANTE: Este método se ejecuta siempre en modo no bloqueante (ver sección sobre Modos
de ejecución).
4.1.5 Método stopMotors
stopMotors()
28
Anexo 1
Para el movimiento de ambas ruedas.
EJEMPLO DE USO
El siguiente programa hace que Robobo se desplace en línea recta y continúa moviéndose hasta que
el valor del sensor infrarrojo central (leído con el método readIRSensor) sea mayor de 100, lo que
significa que hay un objeto cerca. Cuando esto ocurre, la función stopMotors() detiene los motores de
las ruedas:

from robobopy.utils.IR import IR
rob.connect()
rob.moveWheels(30,30)
while rob.readIRSensor(IR.FrontC) < 100:

rob.wait(0.1)
rob.stopMotors()
4.1.6 Método movePanTo
movePanTo (degrees, speed, wait=True)
Mueve el motor PAN hasta la posición deseada.

Parámetros:
• degrees (int): Posición en grados del motor PAN. El rango de valores permitidos está entre
-160 y 160.
• speed (int): Velocidad de giro del motor PAN. El rango de valores permitidos está entre 0 y
100. Cuanto mayor es la velocidad, menos tiempo tardará en alcanzar la posición objetivo.
EJEMPLO DE USO
29
Anexo 1
El siguiente programa mueve el motor PAN hasta 120º con velocidad 5. Luego, lo mueve hasta -30º
con velocidad 10.
rob.connect()
rob.movePanTo(120,5)
rob.movePanTo(-30,10)
4.1.7 Método moveTiltTo
moveTiltTo (degrees, speed, wait=True)
Mueve el motor TILT hasta la posición deseada.

Parámetros:
• degrees (int): Posición en grados del motor TILT. El rango de valores permitidos está entre
5 y 105, siendo 75 el valor central.
• speed (int): Velocidad de giro del motor TILT. El rango de valores permitidos está entre 0 y
100. Cuanto mayor es la velocidad, menos tiempo tardará en alcanzarla posición objetivo.
EJEMPLO DE USO
El siguiente programa mueve el motor TILT hasta 90º con velocidad 5. Luego, lo mueve hasta 20º· con
velocidad 10.
rob.connect()
rob.moveTiltTo(90,5)
30
Anexo 1
4.2 Síntesis de voz y sonido
Introducción
Robobo puede reproducir un texto cualquiera, un conjunto de sonidos de emoción predeterminados

y algunas notas musicales. Para ello se utiliza el altavoz del Smartphone en el caso del robot real, y el
altavoz del ordenador en el caso del robot simulado.
4.2.1 Enumerado Sounds
Representa la lista de sonidos de emoción que Robobo puede reproducir.

PURR: Ronroneo.
MOAN: Queja.
ANGRY: Enfado.
APPROVE: Aprobación.
DISAPPROVE: Desaprobación.
DISCOMFORT: Incomodidad.
DOUBTFUL: Duda.
LAUGH: Risa.
LIKES: Gustar.
MUMBLE: Mascullar.
OUCH: Ay.
THINK: Pensar.
VARIOUS: Varios.
4.2.2 Método sayText
sayText (speech, wait=True)
Utiliza los altavoces del smartphone para reproducir un texto

Parámetros:
• speech (string): Texto que se reproduce.
31
Anexo 1
EJEMPLO DE USO
El siguiente programa hace que Robobo diga una frase, y tras una pausa diga otra frase.
rob.connect()
rob.sayText('Hola, soy Robobo')

rob.wait(1)
rob.sayText('¿Qué tal si le das un poco al cerebro y me programas para hacer algo útil?')
4.2.3 Método playNote
playNote (note, duration, wait=True)
Hace que Robobo toque una nota musical.

• note (int): Nota a reproducir siguiendo la notación anglosajona. Se permiten 133 posibles
notas. El siguiente esquema muestra la equivalencia en el rango de 48 a 59:
DO DO# RE RE# MI FA FA# SOL SOL# LA LA# SI

C Cs D Ds E F Fs G Gs A As B
48 49 50 51 52 53 54 55 56 57 58 59
• duration (float): Duración de la nota en segundos. Toma valores positivos.

EJEMPLO DE USO
El siguiente programa reproduce una parte de la escala musical.
32
Anexo 1
rob.connect()
nota = 52
rob.wait(1)
while (nota < 64):

rob.wait(0.1)
rob.playNote(nota,1)
nota = nota +1
4.2.4 Método playSound
playSound (sound, wait=True)
Utiliza los altavoces del smartphone para reproducir un sonido.

Parámetros:
• sound(Sounds): El sonido que se reproduce.
EJEMPLO DE USO
El siguiente programa hace que Robobo diga una frase y luego reproduzca un sonido.

from robobopy.utils.Sounds import Sounds
rob.connect()
rob. sayText('Hoy me siento feliz')

rob.playSound(Sounds.LAUGH)
33
Anexo 1
4.3 LEDs.
Introducción
Robobo tiene un conjunto de luces LED que se pueden iluminar de distintos colores para mostrar
información visual simple. La siguiente imagen muestra un esquema de su posición en el cuerpo del
robot.
4.3.1 Enumerado LED
Representa la lista de LEDs de la base de Robobo.

BackR: Trasero derecho medio.
FrontR: Frontal derecho.
FrontRE: Frontal derecho extremo.
FrontC: Frontal central.
FrontL: Frontal izquierdo medio.
FrontLL: Frontal izquierdo extremo.
BackL: Trasero izquierdo.
All: Todos.
34
Anexo 1
4.3.2 Enumerado Color
Representa la lista de colores que los LEDs de Robobo pueden mostrar.

OFF: Apagado.
WHITE: Blanco.
RED: Rojo.
BLUE: Azul.
CYAN: Cyan.
MAGENTA: Magenta.
YELLOW: Amarillo.
GREEN: Verde.
ORANGE: Naranja.
4.3.3 Método setLedColorTo
setLedColorTo (led, color)
Enciende o apaga el LED de la base que recibe como parámetro.

Parámetros:
• led (LED): Indica el led o leds sobre el que se aplicará la acción. Este parámetro es de tipo
enumerado LED.
• color (Color): Color que se aplicará al led seleccionado. Este parámetro es de tipo
enumerado Color.
EJEMPLO DE USO
El siguiente programa enciende los LEDs frontales de la base de Robobo, cada uno de un color
diferente. Se mantienen encendidos durante dos segundos (bloque wait). Después, se apagan todos.

from robobopy.utils.LED import LED
from robobopy.utils.Color import Color
rob.connect()
35
Anexo 1
rob.setLedColorTo(LED.FrontC, Color.BLUE)
rob.setLedColorTo(LED.FrontL, Color.WHITE)
rob.setLedColorTo(LED.FrontLL, Color.RED)
rob.setLedColorTo(LED.FrontR, Color.CYAN)
rob.setLedColorTo(LED.FrontRE, Color.MAGENTA)
rob.setLedColorTo(LED.FrontL, Color.YELLOW)
rob.setLedColorTo(LED.FrontR, Color.GREEN)
rob.wait(2)
rob.setLedColorTo(LED.All, Color.OFF)
4.4 Expresiones de Robobo
Introducción
Robobo puede mostrar un conjunto de expresiones predeterminadas utilizando para ello la pantalla
del Smartphone, o la propia pantalla del ordenador en el caso simulado.
4.4.1 Enumerado Emotions
Representa la lista de emociones que la cara de Robobo puede mostrar, como se ve en el ejemplo de
la imagen siguiente.
HAPPY: Feliz.
LAUGHING: Riendo.
SURPRISED: Sorprendido.
36
Anexo 1
SAD: Triste.
ANGRY: Enfadado.
NORMAL: Normal.
SLEEPING: Durmiendo.
TIRED: Cansado.
AFRAID: Asustado.
4.4.2 Método setEmotionTo
setEmotionTo (emotion)
Cambia la expresión de la cara de Robobo con el objetivo de indicar una emoción determinada.
Parámetros:
• emotion (Emotions): Emoción que se muestra en la cara (ver Enumerado Emotions).
EJEMPLO DE USO
El siguiente programa hace que el Robobo muestre cara se sorpresa cuando se encuentra con un
obstáculo. Inicialmente, se pone en movimiento hacia adelante hasta que encuentra un obstáculo
cerca con el sensor infrarrojo delantero central. En ese momento, muestra una expresión de sorpresa
(surprised), gira hacia atrás y se mueve en dirección contraria durante 2 segundos. Finalmente muestra
una expresión de sonrisa (laughing).
from robobopy.utils.Emotions import Emotions
rob.connect()
rob.setEmotionTo(Emotions.NORMAL)
rob.moveWheels(25, 25)
while (rob.readIRSensor(IR.FrontC) < 130):

rob.wait(0.1)
rob.setEmotionTo(Emotions.SURPRISED)
rob.moveWheelsByTime(-20, 20, 1)
rob.moveWheelsByTime(28, -28, 2)
rob.setEmotionTo(Emotions.LAUGHING)
37
Anexo 1
5. | Métodos de sensorización
5.1 Batería
Introducción
Tanto la base de Robobo como el smartphone utilizan una batería como fuente de energía, y es posible
conocer el nivel de cada uno de ellos
5.1.1 Método readBatteryLevel
readBatteryLevel(device)
Lee el nivel de batería de la base o del smartphone.

Parámetros:
• device (string): Dispositivo del que se desea leer la batería. Puede ser ‘base’ para la base o
‘phone’ para el smartphone.
Devuelve:
• El nivel de batería (int). Los valores están entre 0 y 100.
EJEMPLO DE USO
El siguiente programa muestra un ejemplo en el que se reproducen mediante la voz de Robobo el nivel
de batería de la base y del smartphone.
rob.connect()
rob.wait(1)
rob.sayText("El nivel de batería de la base es " + str(rob.readBatteryLevel('base')))
rob.sayText("El nivel de batería del teléfono es " + str(rob.readBatteryLevel('phone')))
38
Anexo 1
5.2 Sensores infrarrojos
Introducción
Robobo cuenta con varios infrarrojos que le permiten detectar si hay objetos cerca: cinco en la parte
delantera y tres en la parte trasera. Cuanto más altos sean los valores devueltos por un infrarrojo, más
cerca estarán los objetos de alrededor.
5.2.1 Enumerado IR
Representa la lista de infrarrojos de la base de Robobo, que se corresponden con la imagen siguiente:
BackR: ‘Back-R’. Trasero derecho.

BackC: ‘Back-C’. Trasero central.
FrontR: ‘Front-R’. Frontal derecho medio.
FrontRR: ‘Front-RR’. Frontal derecho extremo.
FrontC: ‘Front-C’. Frontal central.
FrontL: ‘Front-L’. Frontal izquierdo medio.
FrontLL: ‘Front-LL’. Frontal izquierdo extremo.
BackL: ‘Back-L’. Trasero izquierdo.
39
Anexo 1
5.2.2 Método readIRSensor
readIRSensor(id)
Lee el valor medido por el sensor infrarrojo indicado.

Parámetros:
• id (IR): El sensor del que se quiere obtener el valor. Ver Enumerado IR.
Devuelve:
• Valor medido (int). Los valores son positivos. Cuanto mayor es el valor devuelto, menor es
la distancia a la que se encuentra el objeto detectado. Este valor también depende de
condiciones ambientales, como la iluminación.
EJEMPLO DE USO
El siguiente programa hace que Robobo se mueva hacia delante hasta que encuentre un obstáculo
cercano en el sensor delantero central (el valor de 100 es orientativo, y debe ser ajustado al nivel de
luz y al tipo de objeto a detectar). Cuando eso ocurre, se mueve hacia atrás durante 1 segundo para
separase del obstáculo, luego gira en el sitio 180º aproximadamente y, finalmente, se mueve en
dirección contraria durante 2 segundos:

rob.connect()
while rob.readIRSensor(IR.FrontC) < 100:

rob.wait(0.1)
rob.moveWheelsByTime(-20,-20,1)
rob.moveWheelsByTime(28,-28,1)
5.2.3 Método readAllIRSensor
readAllIRSensor()
Lee el valor de todos los sensores infrarrojos.
40
Anexo 1
Devuelve:
• Valores medidos (dict). Es un diccionario con los valores medidos por todos los sensores
IR de la base. Las claves del diccionario son de tipo string, e indican el sensor IR
correspondiente (ver Enumerado IR). Los valores del diccionario son de tipo int e indican
el valor medido por el IR correspondiente.
EJEMPLO DE USO
El siguiente programa hace que Robobo se mueva hacia adelante hasta que encuentra un obstáculo
cercano en el sensor delantero central (el valor de 100 es orientativo, y debe ser ajustado al nivel de
luz y al tipo de objeto a detectar). Cuando eso ocurre, se para.
rob.connect()
while (rob.readAllIRSensor()==[]):
rob.wait(0.1)
while int(rob.readAllIRSensor()['Front-C']) < 100:

rob.wait(0.1)
rob.stopMotors()
5.3 Motores
Introducción
Todos los motores de Robobo incorporan un sensor (codificador de eje o encoder) que permite leer su
posición mediante los métodos descritos en este apartado.
5.3.1 Enumerado Wheels
Representa la lista de ruedas de Robobo.

R: Derecha.
L: Izquierda.
41
Anexo 1
Both: Ambas.
5.3.2 Método readWheelPosition
readWheelPosition(wheel)
Lee la posición actual de la rueda especificada.

Parámetros:
• wheel (Wheels): La rueda de la que se lee la posición (ver Enumerado Wheels). Se puede
escoger entre una de las ruedas, Wheels.L o Wheels.R.
• Devuelve:
• La posición de la rueda en grados (int).
EJEMPLO DE USO
Con este bloque podemos conocer la distancia aproximada que recorre Robobo. En este ejemplo, se
utiliza este bloque para hacer que el robot se pare cuando la rueda derecha ha dado 2 vueltas
completas (720 grados). Si conocemos la longitud de la circunferencia de la rueda, podemos
determinar fácilmente la distancia recorrida:
El siguiente programa

rob.connect()
rob.wait(1)
vueltas = rob.readWheelPosition(Wheels.R)
while (rob.readWheelPosition(Wheels.R) - vueltas > 720):

rob.wait(0,1)
rob.stopMotors()
5.3.3 Método readWheelSpeed
readWheelSpeed(wheel)
42
Anexo 1
Lee la velocidad actual de la rueda especificada.

Parámetros:
• wheel (Wheels): La rueda de la que se lee la velocidad (ver Enumerado Wheels). Se puede
escoger entre una de las ruedas, Wheels.L o Wheels.R.
Devuelve:
• La velocidad actual de la rueda (int). Valores en el rango de -100 a 100. El valor absoluto
de 100 es la velocidad máxima alcanzable, mientras que 0 significa que no hay
movimiento. Los valores positivos significan que la rueda se mueve hacia delante y los
valores negativos significan que se mueve hacia atrás.
EJEMPLO DE USO
El siguiente programa hace que Robobo avance en línea recta con una velocidad que aumenta de 10
en 10 desde 20 hasta 50 (4 veces). En cada paso del bucle, dice la velocidad real que alcanza la rueda
(se utiliza solo la rueda izquierda ya que ambas usan el mismo valor):

rob.connect()
speed = 20
for i in range(4):
rob.moveWheels(speed, speed)
rob.wait(1)
rob.sayText('Mi velocidad es' + str(rob.readWheelSpeed(Wheels.L)))
speed+= 10
rob.stopMotors()
5.3.4 Método resetWheelEncoders()
resetWheelEncoders()
Reinicia los encoders de las ruedas.
43
Anexo 1
EJEMPLO DE USO
En este ejemplo, se mueve el robot durante 5 segundos y a continuación se usa el método

readWheelPosition para leer el valor de la posición actual de la rueda derecha en voz alta. A
continuación, se usa el método resetWheelEncoders para reiniciar dicha posición y se le lee de nuevo
al usuario.

rob.connect()
rob.sayText('La posición de la rueda derecha es' + str(rob.readWheelPosition(Wheels.R)))
rob.resetWheelEncoders()
rob.wait(0.5)
rob.sayText('La posición de la rueda derecha ha sido reiniciada. La posición actual es' +
str(rob.readWheelPosition(Wheels.R)))
5.3.5 Método readPanPosition
readPanPosition()
Lee la posición actual de motor PAN.

Devuelve:
• La posición en grados (int): los valores devueltos están en el rango de -160 a 160.
EJEMPLO DE USO
En el siguiente programa, se mueve el motor PAN a un valor aleatorio dentro de su rango de operación
y, a continuación, se encienden los LEDs del lado de la base correspondiente al giro realizado. Por lo
tanto, este programa nos permite conocer la orientación del smartphone respecto a la base en
cualquier momento.

import random
44
Anexo 1
rob.connect()
rob.movePanTo(random.randint(-160,160), 15)
if rob.readPanPosition() < 0:
rob.setLedColorTo(LED.FrontLL, Color.CYAN)
rob.setLedColorTo(LED.FrontL, Color.CYAN)
rob.setLedColorTo(LED.BackL, Color.CYAN)
else:
rob.setLedColorTo(LED.FrontRE, Color.CYAN)
rob.setLedColorTo(LED.BackR, Color.CYAN)
5.3.6 Método readTiltPosition
readTiltPosition()
Lee la posición actual de motor TILT.

Devuelve:
• La posición en grados (int): los valores están en rango de 5 a 105.
EJEMPLO DE USO
En el siguiente programa, se mueve el motor TILT a un valor aleatorio dentro de su rango de operación
y, a continuación, se encienden los LEDs delanteros o traseros de la base en función de si el TILT está
por encima o por debajo de 90 grados. Por lo tanto, este programa nos permite conocer la orientación
del smartphone respecto a la base en cualquier momento.

import random
rob.connect()
rob.moveTiltTo(random.randint(60,108), 15)
if rob.readTiltPosition() < 90:
45
Anexo 1
rob.setLedColorTo(LED.BackL, Color.CYAN)
rob.setLedColorTo(LED.BackR, Color.CYAN)
else:
rob.setLedColorTo(LED.FrontC, Color.CYAN)
rob.setLedColorTo(LED.FrontL, Color.CYAN)
rob.setLedColorTo(LED.FrontLL, Color.CYAN)
rob.setLedColorTo(LED.FrontRE, Color.CYAN)
5.4 Mensajes de estado
Introducción
Robobo envía mensajes al dispositivo en el que se esté programando con una frecuencia determinada,
que se puede modificar para reducir el coste computacional.
5.4.1 Enumerado StatusFrequency
Representa la lista de posibles valores para establecer la frecuencia de los mensajes de estado del
robot.
Low: Baja.
Normal: Normal.
High: Alta.
Max: Máxima.
5.4.2 Método setStatusFrecuency
setStatusFrecuency(frecuency)
Establece la frecuencia de los mensajes de estado provenientes del Robobo. Los mensajes de
estado se filtran por defecto para reducir el ancho de banda. Una alta frecuencia reduce los filtros,
por lo que se envían más mensajes de estado y se usa más ancho de banda.
Parámetros:
• frecuency (StatusFrequency): La nueva frecuencia de los mensajes de estado (ver
Enumerado StatusFrequency).
46
Anexo 1
EJEMPLO DE USO
En este ejemplo, se cambia la frecuencia de los mensajes de estado a tres posibles valores: Frecuencia
baja, frecuencia media y frecuencia alta.

from robobopy.utils.StatusFrequency import StatusFrequency
rob.connect()
rob.setStatusFrequency(StatusFrequency.Low)
rob.setStatusFrequency(StatusFrequency.Normal)
rob.setStatusFrequency(StatusFrequency.High)
5.5 Cámara
Introducción
Robobo permite utilizar la cámara delantera o la cámara trasera del smartphone, pero solo una cámara
puede estar activa al mismo tiempo. Existen varios métodos que hacen uso de la información de la
cámara, la procesan, y devuelven percepciones de más alto nivel (color, QR, Aruco). Pero también es
posible acceder directamente a las imágenes que se envían por stream al ordenador, a una frecuencia
determinada (fps). Para utilizar el stream de video de la cámara es necesario descargar la siguiente
librería:
pip install robobopy_videostream

Para comprobar que todo funciona, se puede ejecutar el siguiente script:
from robobopy_videostream.RoboboVideo import RoboboVideo
import cv2
rob = Robobo("localhost") # La IP debe ser la que se muestre en el dispositivo

rob.connect()
videoStream = RoboboVideo("localhost") # La IP debe ser la que se muestre en el dispositivo

videoStream.connect()
while True:
47
Anexo 1
cv2_image = videoStream.getImage()
cv2.namedWindow('imagen', cv2.WINDOW_NORMAL)
cv2.imshow('imagen', cv2_image)
cv2.waitKey(1)
5.5.1 Método setStreamFPS
SetStreamFPS(fps)
Establece los fps (frames per second) del stream. Estos son el número de fotogramas por segundo
enviados desde el smartphone al ordenador. El valor por defecto es 60, pero el valor efectivo es
normalmente más bajo (alrededor de 20), dependiendo del smartphone. Este cambio es
persistente.
Parámetros:
• fps (int): Nuevo límite superior de los fps del stream. Toma únicamente valores positivos.
EJEMPLO DE USO
En este ejemplo, se varía el valor por defecto de 60 fotogramas por segundo a 30 haciendo uso del
método setStreamFps.
rob.connect()
rob.setStreamFps(30)
5.5.2 Método setCameraFPS
SetCameraFPS(fps)
Establece los fps (frames per second) de la cámara. Estos son el número de fotogramas por
segundo leídos por la cámara del smartphone. El valor por defecto es 60, pero el valor efectivo es
normalmente más bajo (alrededor de 20), dependiendo del smartphone. Este cambio es
persistente.
Parámetros:
48
Anexo 1
• fps (int): Nuevo límite superior de los fps del stream. Toma únicamente valores positivos.
EJEMPLO DE USO
En este ejemplo, se varía el valor por defecto de 60 de los fotogramas por segundo de la cámara del
smartphone a 20 haciendo uso del método setCameraFps.
rob.connect()
rob.setCameraFps(20)
5.5.3 Método setFrontCamera()
setFrontCamera()
Hace que Robobo utilice la cámara frontal.

Este cambio es persistente.
Este método no está implementado en el simulador.
EJEMPLO DE USO
En este ejemplo, se mueve el motor TILT para situar el smartphone de la base de forma perpendicular
al suelo y establece la cámara frontal como la cámara a utilizar.
rob = Robobo("192.168.10.1") #La IP depende del caso concreto

rob.connect()
rob.moveTiltTo(90, 20)
rob.setFrontCamera()
49
Anexo 1
5.5.4 Método setBackCamera
setBackCamera()
Hace que Robobo utilice la cámara trasera.

EJEMPLO DE USO
En este ejemplo, se mueve el motor TILT para situar el smartphone de la base de forma perpendicular
al suelo, a continuación, el Robobo se mueve durante 3 segundos, varía los fps de la cámara a 20 y
establece la cámara trasera como la cámara a utilizar.
rob = Robobo("192.168.10.1") #La IP depende del caso concreto

rob.connect()
rob.moveTiltTo(90, 20)
rob.setBackCamera()
5.5.5 Método startCamera
startCamera()
Habilita la cámara.
La cámara está deshabilitada por defecto en el robot real y habilitada por defecto en el simulador.
Advertencia: Algunos módulos dependen de la cámara, por lo que es necesario habilitarla para
hacer uso de ellos.
EJEMPLO DE USO
En el siguiente programa se habilita la cámara. Esto permitiría hacer uso del streaming.
50
Anexo 1

videoStream = RoboboVideo("192.168.1.58")
rob = Robobo("192.168.1.58")
rob.connect()
rob.startCamera()
5.5.6 Método stopCamera
stopCamera()
Deshabilita la cámara.
La cámara está deshabilitada por defecto en el robot real y habilitada por defecto en el simulador.
Advertencia: Algunos módulos dependen de la cámara, por lo que es necesario habilitarla para
hacer uso de ellos.
EJEMPLO DE USO
En el siguiente programa se deshabilita la cámara. Esto impediría hacer uso del streaming.

videoStream = RoboboVideo("192.168.1.58")
rob = Robobo("192.168.1.58")
rob.connect()
rob.stopCamera()
5.5.7 Método startStream
startStream()
Inicia el streaming de la cámara.

El streaming de la cámara está parado por defecto.
51
Anexo 1

Advertencia: Para usar correctamente esta función, es necesario descargar la librería de stream
de vídeo, como se explica en la introducción de este apartado.
EJEMPLO DE USO
En este ejemplo, se activa la cámara haciendo uso de las librerías ‘OpenCV’ y se muestra lo que el robot
está viendo en tiempo real. Para parar el streaming basta con pulsar la tecla ‘q’ en cualquier momento.

import cv2
videoStream = RoboboVideo("192.168.1.58") #Coloca aqui la IP de tu dispositivo

rob = Robobo("192.168.1.58")
rob.connect()
rob.startStream()
def main():
print("Starting test app")
videoStream.connect()
print("Showing images")
i=0
last_ts = 0
while True:
i+=1
frame, timestamp, sync_id, frame_id = videoStream.getImageWithMetadata()
if timestamp != last_ts:
print(timestamp)
print(sync_id)
print(frame_id)
cv2.imshow('smartphone camera', frame)
52
Anexo 1
last_ts = timestamp
if cv2.waitKey(1) & 0xFF == ord('q'):
videoStream.disconnect()
cv2.destroyAllwindows()
break
main()
5.5.8 Método stopStream
stopStream()
Detiene el streaming de la cámara.

El streaming de la cámara está parado por defecto.
EJEMPLO DE USO
En este ejemplo, partiendo del ejemplo anterior desactiva el streaming de la cámara.
rob.connect()
rob.stopStream()
5.6 Luz
Introducción
Robobo permite leer el nivel de luz ambiente gracias al sensor de luz del smartphone, que
normalmente está situado en la propia cámara.
53
Anexo 1
5.6.1 Método readBrightnessSensor
readBrightnessSensor()
Lee el nivel de luz ambiental del smartphone.

Devuelve:
• El nivel de brillo en lux (int). Valores positivos.
Advertencia: La luz del sensor debe no estar disponible en todos los dispositivos.
EJEMPLO DE USO
En el siguiente programa, Robobo se mueve a velocidad 20 y realiza sucesivas medidas del nivel de
brillo haciendo uso del método readBrightnessSensor mientras avanza de forma permanente.
rob.connect()
while True:
rob.wait(0.5)
print(f'\nEl valor de brillo actual es de: {rob.readBrightnessSensor()} lux')
5.7 Detección de blobs
Introducción
Robobo permite detectar blobs de distintos colores. Un blob es un área de la imagen con el mismo
color uniforme, y su detección implica un procesado interno de la imagen obtenida.
5.7.1 Clase Blob
Representa un blob detectado por Robobo. Los ejes de referencia que se utilizan son los siguientes:
54
Anexo 1
Atributos:
• color (string): El color del blob detectado.
• posx (int): Representa la localización de la pelota en el X respecto al robot. Los valores están
en el rango de 0 a 100. Ver imagen anterior.
• posy (int): Representa la posición de la pelota en el Y respecto al robot, es decir, lo cerca o
lejos que se encuentra del mismo. Los valores están en el rango de 0 a 100. Ver imagen
anterior.
• size (int): El área del blob medida en pixels, de forma que, cuanto mayor es el valor, más cerca
se encuentra el robot del blob detectado.
• frame_timestamp (long): La hora a la que el frame se comenzó a procesar.
• status_timestamp (long): La hora a la que se envió el estado.
5.7.2 Enumerado BlobColor
Representa la lista de colores que Robobo puede detectar.

RED: Rojo.
BLUE: Azul.
GREEN: Verde.
CUSTOM: Personalizado.
55
Anexo 1
5.7.3 Método readColorBlob
readColorBlob(color)
Lee el último blob del color indicado detectado.

Parámetros:
• color (BlobColor): el color del blob. Ver Enumerado BlobColor.
Devuelve:
• El blob (Blob). Ver Clase Blob.
EJEMPLO DE USO
El siguiente programa hace que Robobo diga dónde ve un objeto de color verde de forma natural para
el usuario. Así, cuando lo ve a la derecha, izquierda o en el medio, lo dice. Si no ve ningún objeto verde,
también avisa de palabra. Para ello se usa la coordenada x de la mayor área verde detectada en la
imagen.

from robobopy.utils.Color import *
rob.connect()
while True:
if rob.readColorBlob(Color.GREEN).posx > 39 and rob.readColorBlob(Color.GREEN).posx <

60:
rob.sayText('Verde en el medio')
else:
if rob.readColorBlob(Color.GREEN).posx > 59 and
rob.readColorBlob(Color.GREEN).posx < 100:
rob.sayText('Verde a la izquierda'
else:
if rob.readColorBlob(Color.GREEN).posx > 1 and
rob.readColorBlob(Color.GREEN).posx < 40:
rob.sayText('Verde a la derecha')
else:
rob.sayText('No veo verde')
rob.wait(2)
56
Anexo 1
5.7.4 Método setActiveBlobs
setActiveBlobs(red,green,blue,custom)
Habilita o deshabilita el seguimiento individual de cada color. Por defecto, el seguimiento del color
verde está habilitado y los demás deshabilitados.
• red (bool): Si es “True”, habilita el seguimiento del color rojo.
• green (bool): Si es “True”, habilita el seguimiento del color verde.
• blue (bool): Si es “True”, habilita el seguimiento del color azul.

• custom (bool): Si es “True”, habilita el seguimiento del color personalizable.
Advertencia: El seguimiento de color es una tarea computacionalmente intensiva; habilitar todos
los colores a la vez puede afectar al rendimiento.
El uso del color custom en el robot real requiere la calibración de la cámara, tal y como se explica
aquí:
https://github.com/mintforpeople/robobo-programming/wiki/camera-calibration-tutorial_es
EJEMPLO DE USO
El siguiente programa configura los colores rojo y azul para la detección. A continuación, Robobo dice
si ve rojo o azul, y enciende los LEDS de la base en cada caso, al situarle delante de la cámara un objeto
de cada color. Por defecto, los LEDs de la base están en verde:

from robobopy.utils.LED import *
rob.connect()
rob.setActiveBlobs(True, False, True, False)

rob.setLedColorTo(LED.All, Color.GREEN)
while True:
if rob.readColorBlob(Color.RED).size > 0:
rob.setLedColorTo(LED.All, Color.RED)
rob.sayText('Veo rojo')
else:
if rob.readColorBlob(Color.BLUE).size > 0:
57
Anexo 1
rob.setLedColorTo(LED.All, Color.BLUE)
rob.sayText('Veo azul')
else:
if rob.readColorBlob(Color.GREEN).size > 0:
rob.setLedColorTo(LED.All, Color.GREEN)
rob.sayText('Veo verde)
rob.wait(0.5)
5.7.5 Método readAllColorBlobs()
readAllColorBlobs()
Lee los datos de todos los blobs de colores.

Devuelve:
• Diccionario con la información individual de cada blob (dict). Las claves (key) del
diccionario son de tipo BlobColor (ver Clase Blob) y contienen los posibles colores
detectados. Los valores (values) del diccionario son de tipo Blob (ver Clase Blob) y
contienen la información de cada blob.
EJEMPLO DE USO
En este ejemplo, se lee los datos del blob (diccionario), se guarda en una variable local las llaves de
este (key) y se muestra por pantalla la información recogida en estas como son el color detectado, la
posición X e Y del objeto y su área.
rob.connect()
rob.wait(1)
blobs = rob.readAllColorBlobs()
for key in blobs:

blob = blobs[key]
print(blob.color)
print(blob.posx)
print(blob.posy)
print(blob.size)
58
Anexo 1
5.7.6 Método resetColorBlobs
ResetColorBlobs()
Reinicia el detector de colores. Esto pone a 0 los atributos de los últimos blobs detectados, pero
mantiene iguales los colores habilitados y deshabilitados.
EJEMPLO DE USO
En el siguiente programa se reinician los valores leídos de color y se le indica al usuario en voz alta
dicha acción.
rob.connect()
rob.resetColorBlobs()
rob.sayText('Los valores de los colores han sido reiniciados')
5.7.7 Método whenANewColorBlobIsDetected
whenANewColorBlobIsDetected(callback)
Establece la función callback que se llama cuando se detecta un nuevo blob.

Parámetros:
• callback (fun): La función callback que será llamada.
EJEMPLO DE USO
El siguiente programa hace que Robobo diga de forma continuada el color que detecta, asumiendo
que están activados verde, rojo y azul:

def color_detected():
print(rob.readColorBlob(Color.BLUE).size)
if rob.readColorBlob(Color.GREEN).size != 0:
59
Anexo 1
rob.sayText('Estoy viendo verde')

else:
if rob.readColorBlob(Color.RED).size != 0:
rob.sayText('Estoy viendo rojo')
else:
rob.sayText('Estoy viendo azul')
rob.connect()
rob.setActiveBlobs(True, True, True, False)

rob.whenANewColorBlobIsDetected(color_detected)
# el programa se mantiene en ejecución continua

while True:
rob.wait(0.1)
5.7.8 Método setAdvancedLostBlobParameters
setAdvancedLostBlobParameters(frames =5, minarea=1000, max_count=1, epsilon=0)
Configura los parámetros avanzados para el seguimiento de blobs.

Parámetros:
• frames (int): Número de fotogramas transcurridos durante los que no se ha detectado el
blob para considerarlo perdido.
• minarea (int): Área mínima para considerar a un blob como un blob.
• max_count (int): Parámetro max_count del termcriteria.
• epsilon (int): Parámetro épsilon del termcriteria.

Advertencia: Solo utiliza esta función si sabes que estás haciendo. Una mala configuración podría
traer consecuencias inesperadas.
EJEMPLO DE USO
En este ejemplo, se varían varios hiperparámetros que definen cuando se considera que se ha perdido
un color. Entre ellos se aumenta el número de fotogramas de 5 a 10 y el área mínima para considerar
que un Blob es un Blob se reduce a la mitad (500).
60
Anexo 1
rob.connect()
rob.setAdvancedLostBlobParameters(frames= 10, minarea= 500)
5.8 Detección facial
Introducción
Robobo puede detectar caras mediante el procesado de la imagen de la cámara.

Este módulo no está implementado en el simulador.
5.8.1 Clase Face
Representa una cara detectada por Robobo usando la cámara frontal.

Atributos:
• posx (int): La coordenada x del centro de la cara detectada. Los valores están en el rango de
0 a 100.
• posy (int): La coordenada y del centro de la cara detectada. Los valores están en el rango de
0 a 100.
• distance (int): La distancia entre los ojos de la persona, medida en pixels Este valor es mayor
cuando más cerca esté la persona de la cámara. El valor es siempre positivo.
5.8.2 Método startFaceDetection()
startFaceDetection()
Habilita la detección facial.

La detección facial está habilitada por defecto.
5.8.3 Método stopFaceDetection
stopFaceDetection()
61
Anexo 1
Deshabilita la detección facial.

La detección facial está habilitada por defecto.
5.8.4 Método resetFaceSensor
resetFaceSensor()
Reinicia el sensor facial. Después de utilizar este método, y mientras no se detecte una nueva cara,
el sensor facial devolverá ‘0’ para cada atributo leído.
5.8.5 Método readFaceSensor
readFaceSensor()
Lee la última cara detectada por Robobo.

Devuelve:
• La cara (Face). Ver Clase Face.
EJEMPLO DE USO
El siguiente programa hace que Robobo diga dónde ve la cara que está detectando de forma natural
para el usuario. Así, cuando ve una cara a la derecha, izquierda o centrada, lo dice. Si no ve ninguna
cara, también avisa de palabra. Para ello, utiliza la coordenada x de la cara que detecta. Inicialmente
se activa la detección facial haciendo uso del método startFaceDetection y si se pulsa la tecla ‘q’ se
desactiva la detección facial haciendo uso del método stopFaceDetection.
rob = Robobo("10.113.26.150")
rob.connect()
rob.startFaceDetection()
while True:
if rob.readFaceSensor().posx > 40 and rob.readFaceSensor().posx < 60:
rob.sayText('Te veo centrado')
else:
62
Anexo 1

rob.sayText('Te veo a la izquierda')
else:
rob.sayText('Te veo a la derecha')
else:
rob.sayText('No te veo')
if 0xFF == ord('q'):
rob.stopFaceDetection()
rob.resetFaceSensor()
rob.wait(1)
5.8.6 Método whenAFaceIsLost
whenAFaceIsLost(callback)
Establece la función callback que se llama cuando se pierde una cara.

Parámetros:
EJEMPLO DE USO
El siguiente programa hace que Robobo diga «No te veo» de manera continua cada 2 segundos
siempre que pierda una cara.
def face_lost():
rob.sayText('No te veo')
rob.wait(2)
rob = Robobo("10.113.26.150")
rob.connect()
rob.whenAFaceIsLost(face_lost)

while True:
rob.wait(0.1)
63
Anexo 1
5.8.7 Método whenANewFaceIsDetected(callback)
whenANewFaceIsDetected(callback)
Establece la función callback que se llama cuando se detecta una nueva cara.
EJEMPLO DE USO
El siguiente programa hace que Robobo diga «te veo» de manera continua cada 2 segundos siempre
que detecte una cara.
def face_detected():
rob.sayText('Te veo')
rob.wait(2)
rob = Robobo("10.113.26.150")
rob.connect()
rob.whenANewFaceIsDetected(face_detected)

while True:
rob.wait(0.1)
5.9 Detección de objetos
Introducción
Robobo puede detectar objetos mediante el uso de la cámara y una librería externa basada en el uso
de redes de neuronas artificiales. En esta página hay más detalles sobre este método:
https://github.com/mintforpeople/robobo-programming/wiki/Real-time-object-identification
5.9.1 Clase DetectedObject
Representa un objecto detectado por Robobo.

Atributos:
64
Anexo 1
• x (int): La coordenada x del centro del “bounding box” del objeto, medido en pixels desde el
lado izquierdo de la pantalla. Es un valor positivo.
• y (int): La coordenada y del centro del “bounding box” del objeto, medido en pixels desde el
lado izquierdo de la pantalla. Es un valor positivo.
• width (int): El ancho del “bounding box” medido en pixels. Es un valor positivo.
• height (int): The alto del “bounding box” medido en pixels. Es un valor positive.
• label (string): La clase del objeto identificado.

• confidence (float): El porcentaje de confianza para la clase del objeto. Valores entre 0.5 y 1.
5.9.2 Método startObjectRecognition()
startObjectRecognition()
Habilita el reconocimiento de objetos.

El reconocimiento de objetos esta deshabilitado por defecto.
5.9.3 Método stopObjectRecognition()
stopObjectRecognition()
Deshabilita el reconocimiento de objetos.

El reconocimiento de objetos esta deshabilitado por defecto.
5.9.4 Método readDetectedObject()
readDetectedObject()
Lee el último objeto detectado por Robobo.

Devuelve:
• El objeto (DetectedObject). Ver Clase DetectedObject.
65
Anexo 1
5.9.5 Método whenAnObjectIsDetected
whenAnObjectIsDetected(callback)
Establece la función callback que se llama cuando se detecta un objeto.

EJEMPLO DE USO
El siguiente programa hace que Robobo diga qué objeto se ha detectado y con qué intervalo de
confianza.
El siguiente programa hace que Robobo active la detección de objetos haciendo uso del método
startObjectRecognition y coloque el TILT en una posición adecuada para ver lo que hay en el entorno.
Luego, hace que Robobo diga en voz alta de forma continuada la etiqueta del objeto detectado y su
confianza de detección.
rob = Robobo('localhost')
rob.connect()
rob.startObjectRecognition()
def say_object():
object = rob.readDetectedObject()
if object.label is not None:
rob.sayText(f'Se ha detectado el objeto {object.label} con una confianza del
{object.confidence}')
rob.whenAnObjectIsDetected(say_object)

while True:
rob.wait(0.1)
5.10 Micrófono
Introducción
Robobo puede identificar notas musicales, palmadas o conocer el nivel de ruido ambiente mediante el
micrófono del Smartphone. Este módulo no está implementado en el simulador.
66
Anexo 1
5.10.1 Clase Note
Representa una nota detectada por Robobo.

Atributos:
• name (string): La nota musical en formato texto, según la nomenclatura inglesa, que es:
DO DO# RE RE# MI FA FA# SOL SOL# LA LA# SI

C Cs D Ds E F Fs G Gs A As B
• duration (int): La duración de la nota en milisegundos.
5.10.2 Método readLastNote
readLastNote()
Lee la última nota detectada por el sensor de notas.

Devuelve:
• La nota (Note). Ver Clase Note.
EJEMPLO DE USO
El siguiente programa genera notas musicales desde MI hasta RE utilizando el método playNote. Luego,
esas notas se leen con el método readLastNote y se dice en voz alta la nota detectada. Al ejecutar este
programa, se puede observar como para algunas notas emitidas (sostenidas), no se dice nada.
rob = Robobo("10.113.26.150")
rob.connect()
note_to_play = 52
while True:
if note_to_play <= 64:

rob.playNote(note_to_play, 1)
note_to_play+=1
read_note = rob.readLastNote()
67
Anexo 1
if read_note == 'C':
rob.sayText('Acabo de oir un DO')
else:
if read_note == 'D':
rob.sayText('Acabo de oir un RE')
else:
if read_note == 'E':
rob.sayText('Acabo de oir un MI')
else:
if read_note == 'F':
rob.sayText('Acabo de oir un FA')
else:
if read_note == 'G':
rob.sayText('Acabo de oir un SOL')
else:
if read_note == 'A':
rob.sayText('Acabo de oir un LA')
else:
if read_note == 'B':
rob.sayText('Acabo de oir un SI')
rob.wait(1)
5.10.3 Método whenANoteIsDetected
whenANoteIsDetected(callback)
Establece la función callback que se llama cuando se detecta una nueva nota.
Parámetros:
EJEMPLO DE USO
El siguiente programa hace que Robobo diga que acaba de oír la nota Do si efectivamente esta nota
ha sonado y haciendo uso del método whenANoteIsDetected.
def fun():
if rob.readLastNote() == 'C':
rob.sayText('Acabo de oir un DO')
rob = Robobo('10.113.26.150')
rob.connect()
68
Anexo 1
rob.whenANoteIsDetected(fun)

while True:
rob.wait(0.1)
5.10.4 Método readClapCounter
readClapCounter()
Lee el número de palmadas registrado desde el último reinicio.

Devuelve:
• El número de palmadas (int).
5.10.5 Método resetClapCounter
resetClapCounter()
Reinicia el contador de palmadas.
EJEMPLO DE USO
El siguiente programa detecta cuando se realizan dos o más palmadas consecutivas (en menos de dos
segundos), lo cual hace que Robobo emita un sonido de alegría y ponga la expresión de sorpresa. Para
ello se utiliza un variable como temporizador el cual se reinicia cada 2 segundos y el método
readClapCounter. Si damos una única palmada, no ocurre nada.

from robobopy.utils.Sounds import Sounds
from robobopy.utils.Emotions import Emotions
rob = Robobo('10.113.26.150')
rob.connect()
timer = 0
while True:
if timer < 2:
if rob.readClapCounter() > 1:
69
Anexo 1
rob.playSound(Sounds.LAUGH)
rob.setEmotionTo(Emotions.SURPRISED)
rob.wait(0.5)
rob.resetClapCounter()
else:
timer = 0
rob.resetClapCounter()
rob.setEmotionTo(Emotions.NORMAL)
rob.wait(2)
timer+=1
5.10.6 Método whenClapIsDetected
whenClapDetected(callback)
Establece la función callback que se llama cuando se detecta una nueva palmada.
Parámetros:
EJEMPLO DE USO
El siguiente programa hace que Robobo se detenga y diga, «Me has mandado parar» cuando detecta
una palmada.
def clap():
rob.stopMotors()
rob.sayText('Me has mandado parar')
rob = Robobo('10.113.26.150')
rob.connect()
rob.whenClapIsDetected(clap)

while True:
rob.wait(0.1)
70
Anexo 1
5.10.7 Método readNoiseLevel
readNoiseLevel()
Lee el nivel de presión de sonido (SPL, por sus siglas en inglés), que es una medida del ruido
ambiente.
Devuelve:
• El valor de SPL en decibelios (float).
EJEMPLO DE USO
El siguiente programa hace que Robobo diga el nivel de ruido de manera continua y lo categorice en
nivel de ruido alto, medio o bajo en función de los decibelios detectados por el método readNoiseLevel.
rob = Robobo('10.113.26.150')
rob.connect()
while True:
noise_level = rob.readNoiseLevel()
rob.sayText(noise_level)
if noise_level >= 70:

rob.sayText('El nivel de ruido es muy alto')
elif noise_level >= 40 and noise_level < 70:
rob.sayText('El nivel de ruido es medio')
elif noise_level > 20 and noise_level < 40:
rob.sayText('El nivel de ruido es bajo')
else:
rob.sayText('El nivel de ruido es muy bajo')
rob.wait(1)
5.11 Sensor táctil
Introducción
Robobo puede detectar gestos en la pantalla (fling y tap) gracias al sensor táctil de la pantalla del
Smartphone. En el simulador se realizan sobre la ventana emergente inferior derecha (ver
documentación del simulador).
Los flings son deslizamientos del dedo sobre la pantalla en una dirección determinada.
71
Anexo 1
Los taps son pequeños golpes que no tienen una dirección definida.
5.11.1 Clase Tap
Representa un tap detectado en la pantalla del smartphone.

Atributos:
• x (int): La coordenada X del tap. Toma valores de entre 0 y 100.
• y (int): La coordenada Y del tap. Toma valores de entre 0 y 100.
• zone (string): Devuelve el área de la pantalla del smartphone, que puede ser uno de los
siguientes valores: ‘forehead’, ‘eye’, ‘right’, ‘left’, ‘mouth’ o ‘chin’. Estos valores están
representados en la imagen siguiente:
5.11.2 Método readFlingAngle
readFlingAngle()
Lee el último ángulo de fling detectado. Este ángulo está formado por una línea horizontal y el
primer y último punto donde el dedo toco la pantalla.
Devuelve:
• El ángulo en grados (int).
EJEMPLO DE USO
72
Anexo 1
El siguiente programa hace que Robobo muestre de forma continuada el ángulo del último fling
medido.
rob.connect()
while True:
fling_angle = rob.readFlingAngle()
print(fling_angle)
rob.wait(1)
5.11.3 Método readFlingDistance
readFlingDistance()
Lee la longitud del último fling detectado por Robobo.

Devuelve:
• La longitud en píxeles (float).
EJEMPLO DE USO
El siguiente programa hace que Robobo muestre de forma continuada la distancia del último fling
medido.
rob.connect()
while True:
fling_distance = rob.readFlingDistance()
print(fling_distance)
rob.wait(1)
5.11.4 Método readFlingTime
readFlingTime()
Lee la duración del último fling detectado por Robobo.
73
Anexo 1
Devuelve:
• La duración en milisegundos (float).
EJEMPLO DE USO
El siguiente programa hace que Robobo muestre de forma continuada la duración del último fling
medido.
rob.connect()
while True:
fling_time = rob.readFlingTime()
print(fling_time)
rob.wait(1)
5.11.5 Método resetFlingSensor()
resetFlingSensor()
Reinicia el estado del sensor Fling.
EJEMPLO DE USO
En el siguiente programa, cuando el valor del ángulo del último fling supera los 50 grados, se reinicia
el valor del sensor de flings.
rob.connect()
while True:
fling_time = rob.readFlingTime()
print(fling_time)
rob.wait(1)
74
Anexo 1
5.11.6 Método whenAFlingIsDetected
WhenAFlingIsDetected(callback)
Establece la función callback que se llama cuando se detecta un nuevo fling.

• callback (fun): La función callback a ser llamada.
EJEMPLO DE USO
El siguiente programa hace que Robobo diga el nivel de batería de la base al detectar un fling en la
pantalla.
def say_batery_level():
rob.sayText('La base tiene una bateria de' + str(rob.readBatteryLevel('base')))
rob.connect()
rob.whenAFlingIsDetected(say_batery_level)

while True:
rob.wait(0.1)
5.11.7 Método readTapSensor
readTapSensor()
Lee los datos del último tap detectado.

Devuelve:
• El tap (Tap). Ver Clase Tap.
5.11.8 Método resetTapSensor
resetTapSensor()
Reinicia el estado del sensor tap.
75
Anexo 1
EJEMPLO DE USO
El siguiente programa hace que Robobo diga «no tengo bigote» al pulsar brevemente sobre la zona de
la pantalla entre la boca y el ojo. Es necesario reiniciar el valor del sensor tap en cada iteración del
bucle porque este sensor mantiene el último valor medido.
rob.connect()
while True:
if rob.readTapSensor().x > 30 and rob.readTapSensor().x < 70:
if rob.readTapSensor().y > 50 and rob.readTapSensor().y < 60:
rob.sayText('No tengo bigote')
rob.resetTapSensor()
5.11.9 Método whenATapIsDetected
WhenATapIsDetected(callback)
Establece la función callback que se llama cuando se detecta un nuevo tap.

Parámetros:
EJEMPLO DE USO
A continuación, se muestra un programa que hace que el robot pare todos los motores al realizar un
tap sobre la pantalla.
def fun():
rob.stopMotors()
rob.connect()
76
Anexo 1
rob.whenATapIsDetected(fun)

while True:
rob.wait(0.1)
5.12 Sensor de orientación
Introducción
Robobo puede conocer su orientación gracias a los sensores de la IMU del smartphone, giroscopio,
brújala y magnetómetro.
Nota importante: no todos los modelos de Smartphone incorporan IMU
5.12.1 Clase Orientation
Representa la orientación del smartphone.

Atributos:
• yaw (float): Rotación en grados alrededor del eje Z. Los valores están en el rango de -180 a
180. El ángulo de giro yaw se consigue girando la base con los motores de las ruedas y el motor
PAN.
• pitch (float): Rotación en grados alrededor del eje Y. Los valores están en el rango de -180 a
180. El ángulo de giro pitch se consigue usando el motor TILT o moviendo el robot por una
superficie inclinada frontalmente.
• roll (float): Rotación en grados alrededor del eje X. Los valores están en el rango de -180 a 180.
El ángulo de giro roll no lo puede conseguir Robobo directamente, pero cambiará si la
superficie en la que se mueve tiene una inclinación lateral.
5.12.2 Método readOrientationSensor
readOrientationSensor()
Lee la orientación en la que se encuentra el robot.

Devuelve:
• La orientación (Orientation). Ver Clase Orientation.
Advertencia: Este sensor puede no estar disponible para todos los dispositivos.
77
Anexo 1
EJEMPLO DE USO
El siguiente programa hace que Robobo se mueva en línea recta de forma indefinida, y diga si sube o
si baja en caso de encontrarse con una inclinación en su camino. Para ello, se analiza si el
ángulo pitch está por encima de un umbral negativo o positivo:
rob.connect()
rob.resetWheelEncoders()
while True:
if rob.readOrientationSensor().pitch < -20:
rob.sayText('Subiendo')
else:
if rob.readOrientationSensor().pitch > 20:
rob.sayText('Bajando')
rob.wait(1)
5.13 Sensor de aceleración
Introducción
Robobo puede conocer su aceleración gracias al acelerómetro que suelen ocupar todos los
smartphones.
5.13.1 Clase Acceleration
Representa la aceleración a la que está sometido el robot en cada eje.

Atributos:
• x (float): aceleración en el eje X en m/s2.
• y (float): aceleración en el eje Y en m/s2.

• z (float): aceleración en el eje Z axis (m/s2).
78
Anexo 1
5.13.2 Método readAccelerationSensor
readAccelerationSensor()
Lee la aceleración a la que está sometida el robot.

Devuelve:
• La aceleración (Acceleration). Ver Clase Acceleration.
EJEMPLO DE USO
El siguiente programa hace que Robobo se mueva en línea recta de forma indefinida a velocidad 90
hasta que el sensor de aceleración lea un valor en el eje ‘Z’ superior a 5. En ese momento el robot
indicara en voz alta al usuario que se van a parar los motores y el robot se para.
rob.connect()
while True:
if rob.readAccelerationSensor().z < 5:
rob.sayText('Parando Motores')
rob.stopMotors()
break
rob.wait(0.1)
5.14 Detección de carriles
Introducción
Robobo puede detectar los carriles por los que circula utilizando la cámara del smartphone y un
algoritmo de detección explicado con detalle en esta página:
https://github.com/mintforpeople/robobo-programming/wiki/Lane-detection-library
Los carriles básicos están formados por dos líneas rectas, mientras que los carriles pro están formados
por dos polinomios de segundo grado.
79
Anexo 1
5.14.1 Clase LaneBasic
Representa un carril básico detectado por Robobo, formado por dos líneas rectas.
Atributos:
• coeffs1 (dict): Diccionario con ‘a’ y ‘b’ (ax + b), coeficientes de la línea izquierda.
• coeffs2 (dict): Diccionario con ‘a’ y ‘b’ (ax + b), coeficientes de la línea derecha.
• id (int): Número de secuencia de frame. Desde que la cámara se inicial, cada frame tiene un
número que lo identifica. El valor es siempre positivo.
5.14.2 Clase LanePro
Respresenta un carril pro detectado por Robobo, formado por dos polinomios de segundo grado.
Atributos:
• coeffs1 (dict): Diccionario con ‘a’, ‘b’ y ‘c’ (ax2 + bx + c), coeficientes de la línea izquierda.
• coeffs2 (dict): Diccionario con ‘a’, ‘b’ y ‘c’ (ax2 + bx + c), coeficientes de la línea derecha.
• minv (array): Matriz de transformación para obtener la perspectiva original.

5.14.3 Método startLaneDetection
startLaneDetection()
Habilita la detección de carriles.

La detención de carriles está deshabilitada por defecto.
5.14.4 Método stopLaneDetection
stopLaneDetection()
Deshabilita la detección de carriles.

La detención de carriles está deshabilitada por defecto.
80
Anexo 1
5.14.5 Método readLaneBasic
readLaneBasic()
Lee el último carril detectado.

Devuelve:
• El carril (LaneBasic). Ver Clase LaneBasic.
El siguiente programa hace que Robobo habilite la detección de carriles. Luego, hace que Robobo se
mueva en línea recta de forma indefinida a velocidad 20 y vaya mostrando por pantalla los coeficientes
‘a’ y ‘b’ que forman la recta de uno de los carriles básicos detectado.
rob = Robobo('10.113.26.150')
rob.connect()
rob.startLaneDetection()
while True:
lane_basic = rob.readLaneBasic()
print(f"El coeficente a del carril es: {lane_basic.coeffs1['a']}")
print(f"El coeficente b del carril es: {lane_basic.coeffs1['b']}")
rob.wait(1)
5.14.6 Método readLanePro
readLanePro()
Lee el último carril pro detectado.

Devuelve:
• El carril pro (LanePro). Ver Clase LanePro.
EJEMPLO DE USO
81
Anexo 1
El siguiente programa hace que Robobo habilite la detección de carriles. Luego, hace que se mueva en
línea recta de forma indefinida a velocidad 20 y vaya mostrando por pantalla los coeficientes ‘a’, ‘b’ y
‘c’ que forman el polinomio de grado 2 de uno de los carriles detectado.
rob = Robobo('10.113.26.150')
rob.connect()
while True:
lane_pro = rob.readLanePro()
print(f"El coeficente a del carril es: {lane_pro.coeffs1['a']}")
print(f"El coeficente b del carril es: {lane_pro.coeffs1['b']}")
print(f"El coeficente c del carril es: {lane_pro.coeffs1['c']}")
rob.wait(1)
5.14.7 Método whenALaneBasicDetected
WhenALaneBasicDetected(callback)
Establece la función callback que se llama cuando se detecta un carril básico.

Parámetros:
EJEMPLO DE USO
En el siguiente programa, cuando Robobo detecta un carril simple se llama a una función que leerá los
coeficientes ‘a’ y ‘b’ que forman la recta de una de las líneas detectada.
def fun():
lane_basic = rob.readLaneBasic()
print(f"El coeficente a del carril es: {lane_basic.coeffs1['a']}")
print(f"El coeficente b del carril es: {lane_basic.coeffs1['b']}")
rob = Robobo('10.113.26.150')
rob.connect()
82
Anexo 1
rob.whenALaneBasicDetected(fun)

while True:
rob.wait(1)
5.14.8 Método whenALaneProDetected
WhenALaneProDetected(callback)
Establece la función callback que se llama cuando se detecta un carril pro.

Parámetros:
EJEMPLO DE USO
A continuación, se muestra un programa que cuando el robot detecte un carril simple llame a una
función que leerá los coeficientes ‘a’, ‘b’ y ‘c’ que forman el polinomio de grado 2 de uno de los carriles
detectado.
def fun():
lane_pro = rob.readLanePro()
print(f"El coeficente a del carril es: {lane_pro.coeffs1['a']}")
print(f"El coeficente b del carril es: {lane_pro.coeffs1['b']}")
print(f"El coeficente c del carril es: {lane_pro.coeffs1['c']}")
rob = Robobo('10.113.26.150')
rob.connect()
rob.whenALaneProDetected(fun)

while True:
rob.wait(1)
83
Anexo 1
5.14.9 Método setLaneColorInversion
setLaneColorInversion(set_on)
Configura la inversión de color para el módulo de detección de carriles. Por lo general, se detectan
carriles claros sobre fondo oscuro, pero también es posible detectar carriles oscuros sobre fondos
claros.
Parámetros:
• set_on (bool): Booleano para elegir si se activa la inversión de color o no.
Advertencia: Solo utiliza esta función si sabes que estás haciendo. Una mala configuración podría
traer consecuencias inesperadas.
EJEMPLO DE USO
En el siguiente programa, se activa la inversión de color para leer carriles oscuros sobre fondo claro.
rob = Robobo('10.113.26.150')
rob.connect()
rob.setLaneColorInversion(True)
rob.sayText('Inversión de color activada')
5.15 Detección de códigos QR
Introducción
Robobo puede detectar y leer códigos QR mediante la cámara y un algoritmo de procesado.
5.15.1 Clase QRCode
Representa un código QR detectado por robobo, definido por tres puntos.

Atributos:
84
Anexo 1
• x (float): La coordenada X del centro del QR, medida en píxeles desde el lado izquierdo de la
pantalla. Los valores son siempre positivos.
• y (float): La coordenada Y del centro del QR, medida en píxeles desde el lado superior de la
pantalla. Los valores son siempre positivos.
• distance (int): Valor cualitativo que aumenta cuando Robobo está cerca del código QR y
disminuye cuando está lejos.
• p1 (dict): Diccionario con ‘x’ e ‘y’, coordenadas del primer punto de interés. Estas coordenadas
se miden en píxeles desde los lados izquierdo y superior de la pantalla. Los valores son siempre
positivos.
• p2 (dict): Diccionario con ‘x’ e ‘y’, coordenadas del segundo punto de interés. Estas
coordenadas se miden en píxeles desde los lados izquierdo y superior de la pantalla. Los
valores son siempre positivos.
• p3 (dict): Diccionario con ‘x’ e ‘y’, coordenadas del tercer punto de interés. Estas coordenadas
se miden en píxeles desde los lados izquierdo y superior de la pantalla. Los valores son siempre
positivos.
• id (int): Identificador del código QR.
• timestamp (int): Marca temporal del mensaje.
5.15.2 Método startQrTracking
startQrTracking()
Habilita la detección de códigos QR.

La detención de códigos QR está habilitada por defecto.
EJEMPLO DE USO
El siguiente programa hace que Robobo habilite la detección de códigos QR.

rob.connect()
rob.startQrTracking()
85
Anexo 1
5.15.3 Método stopQrTracking
stopQrTracking()
Deshabilita la detección de códigos QR.

La detención de códigos QR está habilitada por defecto.
EJEMPLO DE USO
El siguiente programa hace que Robobo deshabilite la detección de códigos QR.

rob.connect()
rob.stopQrTracking()
5.15.4 Método readQR
readQR()
Lee el último código QR detectado.

Devuelve:
• El código QR (QRCode). Ver Clase QRCode.
EJEMPLO DE USO
El siguiente programa hace que Robobo avise cuando detecta un código QR centrado (coordenada X
entre 200 y 250), indicando de palabra el identificador que contiene.
86
Anexo 1
rob.connect()
while True:
rob.wait(0.1)
if rob.readQR().x > 200 and rob.readQR().x < 250:
rob.sayText('El QR pone')
rob.sayText(rob.readQR().id)
5.15.5 Método whenAQRCodeIsDetected
WhenAQRCodeIsDetected(callback)
Establece la función callback que se llama cuando se detecta un QR.

EJEMPLO DE USO
El siguiente programa hace que Robobo pare los motores y diga el código del QR que detecta.
def fun():
rob.stopMotors()
rob.sayText('Codigo')
rob.sayText('detectado')
rob.connect()
rob.whenAQRCodeIsDetected(fun)
# El programa se mantiene en ejecución continuamente

while True:
rob.wait(1)
5.15.6 Método whenANewQRCodeIsDetected
WhenANewQRCodeIsDetected(callback)
87
Anexo 1
Establece la función callback que se llama cuando se detecta un nuevo QR. Un QR se considera
nuevo si es distinto del detectado la última vez.
EJEMPLO DE USO
El siguiente programa hace que Robobo diga el código del QR que detecta cada vez que un nuevo QR
distinto es detectado.
def fun():
rob.sayText('Un nuevo código QR detectado')
rob.wait(1)
rob.sayText('Codigo')
rob.sayText('detectado')
rob.connect()
rob.startQrTracking()
rob.whenANewQRCodeIsDetected(fun)
# el programa se mantiene en ejecución continuamente

while True:
rob.wait(0.5)
5.15.7 Método whenAQRCodeIsLost
WhenAQRCodeIsLost(callback)
Establece la función callback que se llama cuando se pierde un QR.

88
Anexo 1
EJEMPLO DE USO
El siguiente programa hace que Robobo muestre por pantalla el ID del código del QR que detecta y
que diga en voz alta que este código QR ha sido perdido cuando esto ocurra haciendo uso del método
WhenAQRCodeIsLost.
def fun():
rob.sayText('Se ha perdido el codigo QR')
rob.connect()
rob.whenAQRCodeIsLost(fun)
while True:
rob.wait(0.1)
print(rob.readQR().id)
5.16 Detección de marcadores ArUco
Introducción
Robobo puede detectar marcadores ArUco. Para conocer los detalles de este proceso, se recomienda
consultar:
https://github.com/mintforpeople/robobo-programming/wiki/ArUco-marker-detection
5.16.1 Clase Tag
Representa un tag ArUco detectado por Robobo, definido por cuatro esquinas leídas en sentido
horario.
Atributos:
• cor1 (dict): Diccionario con ‘x’ e ‘y’, coordenadas de la primera esquina.
• cor2 (dict): Diccionario con ‘x’ e ‘y’, coordenadas de la segunda esquina.
• cor3 (dict): Diccionario con ‘x’ e ‘y’, coordenadas de la tercera esquina.

• cor4 (dict): Diccionario con ‘x’ e ‘y’, coordenadas de la cuarta esquina.
• tvects (dict): Diccionario con ‘x’. ‘y’ y ‘z’, componentes del vector de traslación.
89
Anexo 1
• rvects (dict): Diccionario con ‘x’. ‘y’ y ‘z’, componentes del vector de rotación.
• id (int) Identificador del tag ArUco.
5.16.2 Método startArUcoTagDetection
startArUcoTagDetection()
Habilita la detección de ArUco.

La detención ArUco está deshabilitada por defecto.
EJEMPLO DE USO
El siguiente programa hace que Robobo habilite la detección de marcadores ArUco para poder usarla
posteriormente.
rob.connect()
rob.startArUcoTagDetection()
5.16.3 Método stopArUcoTagDetection
stopArUcoTagDetection()
Deshabilita la detección de marcadores ArUco.
La detención ArUco está deshabilitada por defecto.
EJEMPLO DE USO
El siguiente programa hace que Robobo deshabilite la lectura de marcadores ArUco. De esta forma, no
es posible usar este módulo hasta que se habilite de nuevo.
90
Anexo 1
rob.connect()
rob.stopArUcoTagDetection()
5.16.4 Método readArucoTag
readArucoTag()
Lee el último marcador ArUco detectado.

Devuelve:
• El marcador ArUco (Tag). Ver Clase Tag.
EJEMPLO DE USO
El siguiente programa hace que Robobo avise cuando lea el ID de un marcador ArUco o diga que no ha
detectado ninguno en caso contrario.
rob.connect()
while True:
rob.wait(0.1)
if rob.readArucoTag().id != '':
print(f'Aruco detectado con ID: {rob.readArucoTag().id}')
else:
print('Aruco no detectado')
5.16.5 Método setArucoTagSize
setArucoTagSize(size)
Establece la longitud del lado de la etiqueta ArUco que será detectada. Es importante que este
valor se ajuste al tamaño real de la etiqueta utilizada, ya que esto se utiliza para calcular la
distancia de Robobo a la etiqueta.
Parámetros:
• size (int): Tamaño del lado del marcador ArUco en milímetros.
91
Anexo 1
EJEMPLO DE USO
En este ejemplo, se varía el tamaño del tag detectado a 100 milímetros y acto seguido se comienza a
leer de forma indefinida el ID de ArUco detectado en voz alta.
rob.connect()
rob.setArucoTagSize(100)
while True:
rob.wait(1)
rob.sayText(f'Aruco detectado con ID: {rob.readArucoTag().id}')
5.16.6 Método whenArucoTagIsDetected
WhenArucoTagIsDetected(callback)
Establece la función callback que se llama cuando se detecta un marcador ArUco.

EJEMPLO DE USO
El siguiente programa hace que Robobo diga que ha detectado un nuevo marcador ArUco y diga en
voz alta su ID haciendo uso del método WhenArucoTagIsDetected.
def fun():
rob.sayText(f'Aruco detectado con ID: {rob.readArucoTag().id}')
rob.connect()
92
Anexo 1
rob.startArUcoTagDetection()
rob.whenArucoTagIsDetected(fun)

while True:
rob.wait(0.1)
5.17 Detección de líneas
Introducción
Robobo puede detectar líneas en la imagen. Este procesado se utiliza en la detección de carriles, pero
se proporciona por su interés práctico para otras aplicaciones.
5.17.1 Clase Lines
Representa el conjunto de líneas rectas detectadas por Robobo en un frame.

Atributos:
• lines (array): Array con n filas y 4 columnas, siendo n el número de líneas detectadas. Cada fila
tiene los valores ‘x1’, ‘y1’, ‘x2’, ‘y2’, que representan las coordenadas x e y de los puntos 1 y 2
que forman la línea detectada. Estas coordenadas son siempre valores positivos.
5.17.2 Método startLineDetection
startLineDetection()
Habilita la detección de líneas.

La detención de líneas está deshabilitada por defecto.
EJEMPLO DE USO
93
Anexo 1
El siguiente programa hace que Robobo habilite la detección de líneas para que se pueda usar
posteriormente.
rob = Robobo('10.113.26.150')
rob.connect()
rob.startLineDetection()
5.17.3 Método stopLineDetection
stopLineDetection()
Desabilita la detección de líneas.
La detención de líneas está deshabilitada por defecto.
EJEMPLO DE USO
El siguiente programa hace que Robobo deshabilite la detección de líneas. De esta forma, no es posible
usar este módulo hasta que se habilite de nuevo.
rob = Robobo('10.113.26.150')
rob.connect()
rob.stopLineDetection()
5.18 Método readLine
readLine()
Lee el último conjunto de líneas detectado.

Devuelve:
• Las líneas (Lines).
94
Anexo 1
EJEMPLO DE USO
El siguiente programa hace que Robobo busque indefinidamente líneas en el entorno. Si alguna línea
es detectada lo indicará y en caso contrario también.
rob = Robobo('10.113.26.150')
rob.connect()
while True:
rob.wait(0.1)
if rob.readLine().id != 0:
rob.sayText('Línea detectada')
else:
rob.sayText('No se ha detectado ninguna Línea')
5.18.1 Método whenALineIsDetected
WhenALineIsDetected(callback)
Establece la función callback que se llama cuando se detecta una línea.

Parámetros:
EJEMPLO DE USO
A continuación, se muestra un programa que cuando el robot detecte una línea indique en voz alta al
usuario que dicha línea ha sido detectada y cuáles son sus coordenadas.
def fun():
rob.sayText('Una linea ha sido detectada. Sus coordenadas son ')
rob.sayText(rob.readLine().lines)
rob = Robobo('10.113.26.150')
rob.connect()
rob.whenALineIsDetected(fun)
95
Anexo 1

while True:
rob.wait(0.1)
96
Anexo 1

Manual Programacion Robobo

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual Programacion Robobo

Cargado por

Copyright:

Formatos disponibles

Manual de programación

de Robobo con Python

Manual de programación deo con Python

Manual de programación deo con Python .............................................................................................. 1

4.2.1 Enumerado Sounds ............................................................................................................... 31

5.4 Mensajes de estado .............................................................................................................. 46

5.8.2 Método startFaceDetection() ............................................................................................... 61

5.11.9 Método whenATapIsDetected ............................................................................................ 76

Elementos de programación .............................................................................................................. 89

2. | Introducción a Robobo y RoboboSim

Los principales actuadores de Robobo son:

Robobo se puede programar también a través de un modelo de simulación realista, denominado

Fig. 2. Captura de pantalla de un mundo en RoboboSim

2.2.1 Menú principal

2.2.2 Menú de selección de mundo

2.2.3 Menú de opciones

El menú de opciones controla el comportamiento de algunos aspectos de la simulación.

○ “Slope”: Las rampas cambian de pendiente.

2.2.4 Entorno de simulación

La interfaz de la vista de simulación se compone de múltiples elementos controlables con ratón y

● Atrás: Termina la simulación y vuelve a la anterior vista.

● Reinicio: Reinicia la simulación, devolviendo el robot a la posición inicial indicada en el mundo

3. | Comenzar a programar con robobopy

3.1 Instalación de la librería, importación y conexión con Robobo

4. Para instalar la librería, se ejecutará en la terminal PowerShell el comando siguiente:

from robobopy.Robobo import Robobo

2. Se crea un objeto de la clase Robobo, indicando la dirección IP de Robobo.

3. Se establece la conexión con el simulador, a través del método “connect”:

3.2 Ventana de monitorización

3.3 Conexión de robobopy y RoboboSim

Una vez instalada la aplicación, podemos comprobar su correcto funcionamiento en RoboboSim

Se elige un mundo; por ejemplo, “Four Walls”.

# Creamos una instancia de la clase Robobo con la dirección IP “localhost

# Conectamos con el simulador

# Robobo se mueve en línea recta durante 4 segundos

3.4 Clases y enumerados requeridos

from robobopy.utls.IR import IR

3.5 Modos de ejecución

3.6 Método wait

3.7 Módulos habilitados y deshabilitados

3.8 Coordenadas de la pantalla

3.9 Cambios persistentes

Robobo tiene cuatro motores:

4.1.1 Enumerado Wheels

Representa la lista de ruedas de Robobo.

4.1.2 Método moveWheelsByDegrees

moveWheelsByDegrees (wheel, degrees, speed)

from robobopy.Robobo import Robobo

rob.moveWheelsByDegrees(Wheels.BOTH, 360, 30)

4.1.3 Método moveWheelsByTime

moveWeelsByTime(rSpeed, lSpeed, duration, wait=True)

4.1.4 Método moveWheels

moveWheels (rSpeed, lSpeed)

4.1.5 Método stopMotors

Para el movimiento de ambas ruedas.

from robobopy.Robobo import Robobo

while rob.readIRSensor(IR.FrontC) < 100:

4.1.6 Método movePanTo

movePanTo (degrees, speed, wait=True)

Mueve el motor PAN hasta la posición deseada.

from robobopy.Robobo import Robobo

4.1.7 Método moveTiltTo

moveTiltTo (degrees, speed, wait=True)