Campeonato de programación de drones
Grupo de Robótica, Universidad Rey Juan Carlos
Índice
1. Introducción
1
1.1. ¿Quiénes pueden participar? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. Entorno software
2
2.1. Simulador Gazebo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
2.2. Plataforma JdeRobot
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2.3. Interfaces JdeRobot relevantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.4. Plugins de Gazebo para el cuadricóptero . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.5. Componente introrob_py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.6. Instalación del entorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
3. Prueba: el juego del ratón y el gato con drones
10
3.1. Arquitectura software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
3.2. Configuración del entorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
4. Programando el drone gato dentro de introrob.py
13
4.1. Recogiendo imágenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
4.2. Leyendo la posición tridimensional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
4.3. Ordenando movimiento a los motores del drone . . . . . . . . . . . . . . . . . . . . . . . . .
15
4.4. Insertando tu código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
5. Evaluación, organización y premio
1.
2
16
Introducción
Los drones son robots aéreos que han ganado popularidad en los últimos años. Nacieron en el
ámbito militar y con el abaratamiento de sus costes se han abierto posibilidades de uso comercial en
1
varias aplicaciones civiles como la monitorización de infraestructuras, agricultura, vigilancia, grabación de
eventos, etc.. Son robots, y como tales, están compuestos de sensores, actuadores y procesadores en el lado
hardware. Su inteligencia sin embargo reside en su software.
Este campeonato plantea como reto la programación de un cuadricóptero (que llamaremos gato) para
una misión concreta: perseguir a otro robot aéreo (que llamaremos ratón) y mantenerse cerca de él. En
el Grupo de Robótica de la Universidad Rey Juan Carlos hemos preparado el entorno del campeonato
utilizando el simulador Gazebo y la plataforma robótica JdeRobot. JdeRobot simplifica el acceso a sensores
y actuadores y permite programar el comportamiento del gato en lenguaje Python.
1.1.
¿Quiénes pueden participar?
Cualquiera, es un campeonato abierto. Está dirigido a estudiantes universitarios de ingeniería,
principalmente a los de la Universidad Rey Juan Carlos, pero está abierto a cualquier participante.
2.
Entorno software
2.1.
Simulador Gazebo
Los simuladores en robótica son usados para crear mundos virtuales y observar cómo un robot emulado
actúa en dicho entorno. De esta forma se pueden programar aplicaciones robóticas y probarlas sin depender
de un robot físico, haciendo que las pruebas sean más baratas y menos peligrosas. Si el robot se choca
o tiene un comportamiento extraño que no se había previsto es posible reiniciar la simulación sin que el
modelo real (o las personas cercanas) haya sufrido daños. Algunos de estos simuladores representan los
mundos en 3D y recrean la física de este (gravedad, colisiones...) permitendo visualizar el movimiento del
robot en escenarios muy realistas. Motores de física comunes son ODE (Open Dynamics Engine) y Physx.
Figura 1: Humanoide de la competición VRC en Gazebo
Gazebo
1
es un simulador muy completo que se distribuye como software libre. Cuenta con modelos de
robots que pueden usarse directamente, además de incluir la posibilidad de que el usuario cree su propio
robot y entornos. Por ejemplo, un campo de fútbol de la RoboCup, un pueblo o el interior de un edificio,
todos incluyendo texturas, luces y sombras. Simula la física de los cuerpos rígidos: choques, empujes,
1 http://gazebosim.org/
2
gravedad, etc. Dispone de una amplia clase de sensores como cámaras, lásers, sensores de contacto, imu,
etc. Los algoritmos pueden aplicarse a los modelos cargando plugins, o librerías dinámicas. Muchos de
estos modelos y plugins han sido creados por la organización OSRF (Open Source Robotics Foundation),
que desarrolla y distribuye este software libre para su uso en investigación robótica.
2.2.
Plataforma JdeRobot
JdeRobot2 es una plataforma de software libre para el desarrollo de aplicaciones con robots y visión
artificial. Este proyecto ha sido desarrollado y está mantenido por el Grupo de Robótica de la Universidad
Rey Juan Carlos desde 2003.
Esta plataforma abstrae al programador del acceso a los dispositivos hardware, como la lectura de los
sensores o el envío de comandos a los motores. Principalmente está desarrollado en C y C++, aunque existen
componentes desarrollados en otros lenguajes como Java o Python. Ofrece un entorno de programación
basado en componentes donde la aplicación está formada por varios componentes y cada uno se ejecuta como
un proceso. Es distribuido y multilenguaje, los componentes interoperan entre sí a través del middleware de
comunicaciones ICE. Podemos encontrar componentes ejecutándose en distintas máquinas interoperando a
través de interfaces ICE, incluso estando escritos en lenguajes diferentes. Típicamente se crean aplicaciones
muy complejas a partir de componentes más simples que han sido desarrollados para realizar una tarea
específica.
ICE (Internet Communications Engine), es un middleware orientado a objetos que provee llamadas a
procedimientos remotos, computación grid y funcionalidad cliente/servidor desarrollada por ZeroC3 bajo
una doble licencia GNU GPL y una licencia propietaria.
JdeRobot ofrece una interfaz sencilla para la programación de sistemas de tiempo real y resuelve
problemas relacionados con la sincronización de los procesos y la adquisición de datos. JdeRobot simplifica
el acceso a los dispositivos hardware de un robot desde el componente, permitiendo obtener la lectura de un
sensor a través de una llamada a función o método. Normalmente en las aplicaciones robóticas desarrolladas
con JdeRobot, los componentes necesitan datos sensoriales y envían ordenes a los actuadores. Los datos
sensoriales llegan al componente a través de interfaces ICE. Los drivers encargados de controlar los robots
también reciben las órdenes también a través de interfaces ICE.
2 http://jderobot.org/
3 http://www.zeroc.com/
3
Figura 2: Ejemplo de componentes JdeRobot
Actualmente soporta un gran variedad de dispositivos como el robot Pioneer de MobileRobotics Inc., el
humanoide NAO de Aldebaran Robotics, el robot Kobuki de Yujin Robot, el cuadricóptero AR.Drone de
Parrot, cámaras firewire, USB e IP, los escáneres laser LMS de SICK y URG de Hokuyo, los simuladores
Stage y Gazebo, sensores de profundidad como kinect y otros dispositivos X10 de dómotica. Además, tiene
soporte para software externo como OpenGL, GTK, XForms, Player, GSL y OpenCV. Es un proyecto de
software libre licenciado como GPLv34 , y la última versión oficial es la 5.2.
2.3.
Interfaces JdeRobot relevantes
En JdeRobot cada componente ofrece o se subscribe a una o varias interfaces. Estas interfaces se definen
en un pseudolenguaje propietario de Zero-C y luego, haciendo uso de un traductor automático, se puede
obtener el código fuente correspondiente a la interface para distintos lenguajes de programación. Tras
este paso es tarea del programador definir el comportamiento de la interface. A continuación de muestran
algunas de las interfaces útilex para este campeonato, que básicamente concretan el acceso a los sensores
y actuadores a bordo del cuadricóptero.
2.3.1.
camera
Es la interface estándar para el envío y recepción de imágenes entre componentes. En el campeonato
utilizaremos la interfaz camera para obtener imágenes desde nuestro AR.Drone simulado. Su definición es
la siguiente:
#i n c l u d e <image . i c e >
module j d e r o b o t {
// S t a t i c d e s c r i p t i o n o f a camera
4 http://www.gnu.org/licenses/gpl-3.0-standalone.html
4
c l a s s CameraDescription
{
s t r i n g name ;
string shortDescription ;
s t r i n g streamingUri ;
float fdistx ;
float fdisty ;
f l o a t u0 ;
f l o a t v0 ;
f l o a t skew ;
f l o a t posx ;
f l o a t posy ;
f l o a t posz ;
f l o a t foax ;
f l o a t foay ;
f l o a t foaz ;
float roll ;
};
//Camera i n t e r f a c e
i n t e r f a c e Camera e x t e n d s Im age Pro vi der
{
idempotent C a m e r a D e s c r i p t i o n g e t C a m e r a D e s c r i p t i o n ( ) ;
i n t setCameraDescription ( CameraDescription d e s c r i p t i o n ) ;
s t r i n g st a r t C a me r a S t r ea m i n g ( ) ;
v o i d stopCameraStreaming ( ) ;
void r e s e t ( ) ;
};
} ; /∗ module ∗/
Como se aprecia en la definición, la interface camera nos permite definir una cámara y la posiblidad
de implementar de alguno de sus métodos como getCameraDescription(). Esta interface depende de la
interface image la cual almacena la información de la imagen en sí como el ancho y alto de la imagen o la
secuencia de bytes que componen la imagen.
module j d e r o b o t {
// S t a t i c d e s c r i p t i o n o f t h e image s o u r c e .
c l a s s ImageDescription
{
i n t width ; /∗ Image width [ p i x e l s ] ∗/
i n t h e i g h t ; / ∗ Image h e i g h t [ p i x e l s ] ∗/
i n t s i z e ; / ∗ Image s i z e [ b y t e s ] ∗/
s t r i n g format ; /∗ Image format s t r i n g ∗/
};
//A s i n g l e image s e r v e d a s a s e q u e n c e o f b y t e s
5
c l a s s ImageData
{
Time timeStamp ; /∗ TimeStamp o f Data ∗/
ImageDescription d e s c r i p t i o n ;
ByteSeq p i x e l D a t a ; /∗ The image data i t s e l f . ∗ /
};
/ / ! I n t e r f a c e t o t h e image consumer .
i n t e r f a c e ImageConsumer
{
/ / ! Transmits t h e data t o t h e consumer .
v o i d r e p o r t ( ImageData o b j ) ;
};
// I n t e r f a c e t o t h e image p r o v i d e r .
i n t e r f a c e Im age Pro vi der
{
// Returns t h e image s o u r c e d e s c r i p t i o n .
idempotent I m a g e D e s c r i p t i o n g e t I m a g e D e s c r i p t i o n ( ) ;
// Returns t h e l a t e s t data .
[ " amd " ] idempotent ImageData getImageData ( )
throws DataNotExistException , H a r d w a r e F a i l e d E x c e p t i o n ;
};
} ; // module
2.3.2.
Pose3D
La interface Pose3D define la posición de un objeto en el espacio 3D. Está compuesta por un cuaternión,
que expresa la orientación del objeto, y un punto 3D en coordenadas homogéneas que indica la posición
de éste en el espacio.
module j d e r o b o t {
c l a s s Pose3DData
{
float x;
float y;
float z ;
float h;
f l o a t q0 ;
f l o a t q1 ;
f l o a t q2 ;
f l o a t q3 ;
};
// I n t e r f a c e t o t h e Pose3D .
i n t e r f a c e Pose3D
6
{
idempotent Pose3DData getPose3DData ( ) ;
i n t setPose3DData ( Pose3DData data ) ;
};
} ; // module
Esta interfaz no es imprescindible en el campeonato pero está a disposición de los participantes para
conocer la posición 3D y orientación del drone en el entorno simulado. Típicamente esta información se
recopila en el robot real desde el sensor GPS y la unidad inercial IMU. Hay muchas maneras de representar
posición y orientación tridimensionales (ángulos de Euler, cuaterniones, yaw-pitch-roll, matríces, etc.), se
ha elegido ésta que tiene ventajas computacionales.
2.3.3.
cmd_vel
Con la interfaz cmd_vel podremos enviar comandos de velocidad a los componentes que la implementen,
entre ellos el driver del cuadricóptero real y el plugin del cuadricóptero en Gazebo. Es una interfaz pensada
para el manejo de robots aéreos y con ella podemos realizar translaciones y rotaciones sobre los ejes X, Y,
Z solidarios con el propio robot: X+ siempre hacia el frente del robot, Y+ hacia su izquierda y Z+ hacia
arriba en su vertical.
module j d e r o b o t {
c l a s s CMDVelData
{
f l o a t linearX ;
f l o a t linearY ;
float linearZ ;
f l o a t angularX ;
f l o a t angularY ;
f l o a t angularZ ;
};
i n t e r f a c e CMDVel{
i n t setCMDVelData ( CMDVelData data ) ;
};
} ; \ \ module
Durante la prueba se utilizará este interfaz para comandar órdenes de movimiento al AR.Drone. Cómo
estas órdenes se materializan en comandos a cada uno de los motores del cuadricóptero es un detalle de
implementación del que se encarga el driver del cuadricóptero real o el plugin de Gazebo, que ya tienen
en cuenta la dinámica de las hélices y del cuerpo para traducir esas órdenes de alto nivel a comandos
concretos a cada motor.
2.3.4.
ardrone_extra
Esta interfaz es exclusiva para el manejo de AR.Drone, nos permite realizar las maniobras básicas de
un drone como el aterrizaje y el despegue. Además, ofrece otras características específicas del AR.Drone
7
como la grabación de vídeos en una memoria USB o realizar animaciones leds.
module j d e r o b o t {
i n t e r f a c e ArDroneExtra {
v o i d toggleCam ( ) ;
void land ( ) ;
void t a k e o f f ( ) ;
void r e s e t ( ) ;
v o i d recordOnUsb ( b o o l r e c o r d ) ;
v o i d ledAnimation ( i n t type , f l o a t d u r a t i o n , f l o a t r e q ) ;
v o i d f l i g h t A n i m a t i o n ( i n t type , f l o a t d u r a t i o n ) ;
void flatTrim ( ) ;
};
};
2.4.
Plugins de Gazebo para el cuadricóptero
2.5.
Componente introrob_py
Este componente nos permite teleoperar el AR.Drone y obtener sus datos sensoriales, tanto para el
cuadricóptero real como para el simulado (dependiendo de si se conecta al driver real o al plugin en
Gazebo). También permite insertar en él el código de cada participante y ejecutarlo.
Figura 3: Esquema de introrob_py con AR.Drone real
Como muestran las Figuras 3 y 4 introrob_py es un componente JdeRobot que se suscribe a las
interfaces ofertadas tanto por ardrone_server como por el plugin equivalente en Gazebo (el que usamos
en este campeonato).
8
Figura 4: Esquema de introrob_py con AR.Drone simulado
Además de esta interconexión, introrob_py ofrece al usuario una interface gráfica para el manejo del
AR.Drone (ver Figura 5a) y la visualización de los datos sensoriales (ver Figura 5b).
(a) Teleoperación del drone
(b) Visualización de las imágenes
Figura 5: Interfaz gráfica principal de introrob_py
La Figura 6 muestra (de izquierda a derecha) el indicador de actitud (pitch y roll), la orientación del
drone (yaw), un altímetro, un indicador del porcentaje de carga de la batería y tres velocímetros que
indican la velocidad lineal en los ejes X, Y, Z.
9
Figura 6: Pestaña ’Sensors’ del componente introrob.py
El código de tu prueba se empotrará dentro de este componente, y es tu código el que tomará las
decisiones de movimiento adecuadas en función de la información sensorial. En esto reside la “inteligencia”
del cuadricóptero y que su comportamiento sea bueno o no. El componente arranca en modo teleoperación,
para que puedas gobernar el movimiento del cuadricóptero manualmente. Con el deslizador vertical se
puede subir o bajar de altura y con la cruceta hacerlo girar y/o avanzar en horizontal.
Antes de ejecutar tu algoritmo pulsa sobre el botón Play, e introrob.py entra en modo automático
invocando periódicamente a tu código inserto en MyAlgorithm.py, el método execute. Lo llama unas
10 veces por segundo, lo que permite a tu software tener el control en todo momento del movimiento
del drone.
Para terminar con la ejecución de tu algoritmo pulsa el botón Stop, que hace entrar a introrob.py
nuevamente en modo teleoperación.
2.6.
Instalación del entorno
sudo apt-get install jderobot
3.
Prueba: el juego del ratón y el gato con drones
La prueba consiste en programar en lenguaje Python la inteligencia de un drone cuadricóptero que
llamamos gato. Su objetivo es perseguir y mantenerse cerca de otro cuadricóptero similar que llamamos
ratón. El resultado esperado se puede ver en la página web del concurso5 .
El gato tiene dos cámaras (una frontal y otra ventral) y un sensor de posición 3D como equipamiento
sensorial. Sus actuadores son los motores de sus hélices. Tal y como muestra la Figura 7 el ratón es de
color rojo, para facilitar su detección en las imágenes.
5 http://jderobot.org/Programacion-de-drones#Atrapa_a_la_tortuga
10
Figura 7: Gato y ratón en el mundo 3D simulado
En la fase de competición del concurso se pondrá un ratón programado por la organización, que será el
mismo para todos los participantes. En la preparación del gato puedes conectar un introrob.py a tu ratón
y teleoperarlo, o puedes dejar al ratón quieto, o puedes programarte un comportamiento fijo.
Para participar en la prueba hay que notificarlo por correo a josemaria.plaza AT urjc.es y enviar en
los plazos previstos el código de tu drone gato, el fichero MyAlgorithm.py que se incorporará a introrob.py
para probarlo.
3.1.
Arquitectura software
Figura 8: Arquitectura software de la prueba
3.2.
Configuración del entorno
Para configurar el entorno de la prueba hay que (1) lanzar Gazebo con el fichero del mundo adecuado,
(2) ejecutar el introrob.py que gobierna el comportamiento del drone ratón y (3) arrancar el introrob.py
que gobierna el comportamiento del drone gato. Opcionalmente (4) se puede lanzar también el componente
11
árbitro que se utilizará para medir la puntuación de cada participante. Puedes lanzar el árbitro para ver
si tu gato lo está haciendo mejor o peor en las pruebas de preparación.
3.2.1.
Gazebo
Para la prueba se ha diseñado un mundo en el simulador Gazebo. En este nuevo mundo tendremos dos
robots: el cuadricóptero AR.Drone que hace de ratón (que tiene color rojo) y el cuadricóptero gato. No
hay más obstáculos en el mundo, salvo el suelo.
Para ejecutar Gazebo con este mundo realiza los siguientes pasos:
cd ~ / . gazebo / c f g / p r o g r a m a c i o n d r o n e s /
gazebo
gato_raton_1 . world
Con el comando anterior Gazebo habrá lanzado el mundo gato_raton_1.world con los plugins del gato,
el ratón y el árbitro. El plugin del gato ofrece las siguientes interfaces. En el código de introrob.py las
interfaces ya están configuradas (en la clase sensor.py) para conectarse a ellas, por lo que no es necesario
modificarlas.
camera, en el puerto 9995
navdata, en el puerto 9700
cmd_vel, en el puerto 9580
ardrone_extra, en el puerto 9701
Pose3D, en el puerto 9000
Por otro lado, el plugin de ratón oferta las siguientes interfaces:
camera, en el puerto 9996
navdata, en el puerto 9701
cmd_vel, en el puerto 9581
ardrone_extra, en el puerto 9702
Pose3D, en el puerto 9001
3.2.2.
Componente Introrob.py para el ratón
3.2.3.
Componente Introrob.py para el gato
3.2.4.
Árbitro
El árbitro consta de un plugin y un visor. Mide la distancia real instantánea entre gato y ratón y
muestra en pantalla la evolución temporal a lo largo de la duración de la manga (Figura 9). Cuando está
por debajo del umbral considerado cercano la pinta en verde y cuando está por encima, rojo. De este modo
12
mide cuántos segundos de esas ejecuciones tu gato ha estado suficientemente cerca del ratón y lo muestra
en pantalla.
Figura 9: Ejecución de la prueba: el árbitro muestra la evolución temporal de la distancia entre gato y
ratón
Figura 10: Gráfica generada con la puntuación final
4.
Programando el drone gato dentro de introrob.py
El comportamiento del cuadricóptero gato típicamente tendrá una parte perceptiva y una parte de
control. La parte de percepción recoge los datos sensoriales (la cámara principalmente) y los analiza,
extrae información de ellos. La parte de control decide qué movimiento es el adecuado y emite órdenes a
los motores del robot.
Es de naturaleza iterativa, ejecuta continuamente iteraciones y en cada una de ellas se percibe y se
13
controla.
Introrob.py se apoya en las interfaces descritas para dialogar con el simulador Gazebo. En particular
con los plugins de Gazebo que materializan los sensores y actuadores del cuadricóptero. Todo este diálogo
queda oculto al programador, que simplemente tiene unos cuantos métodos en Python como interfaz de
programación para leer los datos de la cámara, sensor de posición y motores del cuadricóptero.
4.1.
Recogiendo imágenes
Las imágenes de la cámara frontal del gato se obtienen desde la clase MyAlgorithm. La instrucción
siguiente nos devuelve la imagen de la cámara activa del drone y la almacena en la variable droneImage.
A partir de este momento, dicha variable contiene una imagen que podremos tratar como queramos. Por
ejemplo usando la biblioteca OpenCV de visión artificial.
droneImage = s e l f . s e n s o r . getImage ( )
Para esta prueba necesitaremos detectar al robot ratón. El ratón es de color rojo. Típicamente se
localiza muy bien dentro de las imágenes usando un filtro HSV convenientemente ajustado.
Figura 11: Detección del robot ratón en la imagen
4.2.
Leyendo la posición tridimensional
En el escenario del campeonato se usan dos sistema de referencia: uno absoluto y otro solidario con el
cuadricóptero. Son los que se muestran en la Figura 12.
14
Figura 12: Sistemas de referencia 3D
El seguimiento del ratón se puede abordar sin necesidad de saber la posición absoluta del drone en el
mundo. Sin embargo, puede ser útil si se quiere optimizar la búsqueda del ratón cuando no se aprecia en la
imagen. Para obtener la posición 3D se tiene el método getPose3D. Las instrucciones siguientes entregan
las coordenadas X,Y y Z del drone dentro del mundo de Gazebo.
s e l f . s e n s o r . getPose3D ( ) . x
s e l f . s e n s o r . getPose3D ( ) . y
s e l f . s e n s o r . getPose3D ( ) . z
4.3.
Ordenando movimiento a los motores del drone
La clase sensor dentro de introrob.py incluye varios métodos para interactuar con el drone y
ordenarle movimiento. En particular el método sendCMDVel() envía comandos de velocidad de traslación
y velocidades de rotación. Las velocidades de traslación siguen el sistema de referencia que se muestra en
la figura 12, solidario con el propio drone: vx de frente/atrás, vy izquierda/derecha y vz arriba/abajo. La
velocidad de yaw marca el giro alrededor de un eje vertical, perpendicular al plano del drone. El método
sendCMDVel() recibe 6 parámetros: vy, vx, vz, yaw, roll y pitch. Cada uno de los valores se debe indicar
entre -1 y 1. Los valores roll y pitch no tienen efecto en el mundo simulado de Gazebo.
Por ejemplo, el comando siguiente ordena al drone que se mueva de manera inmediata hacia delante a
una velocidad de 0.5 (a la mitad de potencia). Esta órden estará activa hasta que se le indique otra cosa.
s e l f . s e n s o r . sendCMDVel ( 0 , 0 . 5 , 0 , 0 , 0 , 0 )
El método sendCMDVel() permite comandar distintas órdenes a la vez. El comando siguiente provoca
que el drone se mueva hacia delante a una velocidad de 0.5, a la vez se traslade hacia la derecha a 0.4 y
simultáneamente se eleve en el eje Z a 0.2 y rote sobre el eje Z a una velocidad de 0.1.
s e l f . s e n s o r . sendCMDVel ( − 0 . 4 , 0 . 5 , 0 . 2 , 0 . 1 , 0 , 0 )
Finalmente, para detener el movimiento del drone se puede utilizar la siguiente instrucción.
15
s e l f . s e n s o r . sendCMDVel ( 0 , 0 , 0 , 0 , 0 , 0 )
4.4.
Insertando tu código
Para implementar el algoritmo se recomienda seguir los siguientes pasos:
1. Abre con tu entorno de programación el componente introrob.py y dirígete a la clase MyAlgorithm
que se encuentra en el fichero introrob/MyAlgorithm.py.
2. Dirígite a la definición del método execute().
3. En primer lugar se recomienda implementar un método que nos permita detectar en la imagen
obtenida del drone ratón, obteniendo su posición en píxeles. Típicamente el centro de masas de los
píxeles que superan el filtro rojo puede ser una buena aproximación del centro del robot ratón (hay
otras mejores).
4. Con el robot ratón detectado en la imagen, el siguiente paso es decidir qué movimiento es el adecuado
ordenar a los motores del gato con el método sendCMDVel(). Aquí hay muchas maneras de decidirlo:
control basado en casos, control PID, autómatas, etc.. Aquí es donde entra en juego tu habilidad.
5.
Evaluación, organización y premio
Para participar hay que programar MyAlgorithm.py adecuadamente y enviarlo a la organización por
correo electrónico antes del 24 de mayo 2015 (23:00 horas UTC) junto con los datos personales. Pasado
ese día la organización publicará en la web la lista de todos los participantes. Las finales del campeonato
tendrán lugar el 29 de mayo de 2015. Ese día se retransmitirá en streaming por YouTube la sesión final
(Q3). Si el volumen de participantes lo permite, también las sesiones eliminatorias Q1 y Q2.
La evaluación consiste en arrancar a tu robot gato en diferentes configuraciones (2 mangas) con el robot
ratón que hemos preparado y en una máquina de la organización. La máquina y el comportamiento del ratón
es exactamente el mismo para todos los participantes. En cada manga, de 2 minutos, tu robot comienza
en una posición relativa diferente respecto del ratón, deberá buscarlo y perseguirlo. El componente árbitro
mide cuántos segundos de esas ejecuciones tu gato ha estado suficientemente cerca del ratón y lo muestra
en pantalla. Esa es la puntuación. Que tu gato toque al ratón supone la descalificación en esa manga y el
participante reune 0 puntos en ella.
El campeonato está organizado en fases eliminatorias, donde tu gato se va enfrentando paulatinamente
a ratones más difíciles de seguir. Tras la primera ronda (Q1) pasan a la siguiente los mejores 20 gatos, en la
segunda (Q2) los mejores 10 y en la última (Q3) ya se deciden las posiciones definitivas en el campeonato.
Gana el campeonato aquel gato que esté cerca del ratón durante más tiempo en el acumulado de las dos
mangas de Q3.
El premio para el ganador es un cuadricóptero Ar.Drone2 de Parrot. El jurado será una comisión del
Grupo de Robótica, que podrá dejar el premio desierto si la solución no es de suficiente calidad. Sus
decisiones son inapelables.
16