desarrollo de programas de ontrol para … · especial de la localización de markov que emplea un...
TRANSCRIPT
Universidad de León
Escuela de Ingenierías Industrial, Informática
y Aeronáutica
Máster en Investigación en Cibernética
Trabajo Fin de Máster:
DESARROLLO DE PROGRAMAS DE
CONTROL PARA EL ROBOT
TURTLEBOT SOBRE ROS (Robot
Operating System)
Autor: Fernando Casado García
El presente trabajo “DESARROLLO DE PROGRAMAS DE CONTROL PARA EL ROBOT
TURTLEBOT SOBRE ROS (Robot Operating System)” ha sido realizado por D. FERNANDO
CASADO GARCÍA y presentado para la obtención del título de Master en investigación
en cibernética en la Escuela de Ingenierías Industrial, Informática y Aeronáutica de la
Universidad de León. Ha sido realizado bajo la tutoría del profesor Dr. VICENTE
MATELLÁN OLIVERA.
VºBº Tutor: Autor:
Dr. Vicente Matellán Olivera. D. Fernando Casado García.
León, Julio de 2012
ÍNDICE
CONTENIDO
1 OBJETIVOS, JUSTIFICACIÓN ....................................................................................................... 3
2 ESTADO DEL ARTE ..................................................................................................................... 3
3 HERRAMIENTAS Y METODOLOGÍA UTILIZADA ............................................................................ 6
3.1 ROS ................................................................................................................................................. 6
3.1.1 Estructura de archivos y comandos ...................................................................................... 6
3.1.2 Ejecución de programas........................................................................................................ 7
3.1.3 Aplicaciones .......................................................................................................................... 7
3.2 TURTLEBOT ........................................................................................................................................ 7
3.2.1 Hardware .............................................................................................................................. 8
3.2.2 Software ............................................................................................................................... 9
3.3 METODOLOGÍA ................................................................................................................................... 9
4 TRABAJO DESARROLLADO ........................................................................................................ 10
4.1 PUESTA EN MARCHA DE ROS ............................................................................................................... 10
4.1.1 Instalación y configuración ................................................................................................. 10
4.1.2 Creación de un espacio de trabajo y un package ................................................................ 14
4.2 PUESTA EN MARCHA DEL TURTLEBOT .................................................................................................... 15
4.3 PROGRAMAS DESARROLLADOS ............................................................................................................. 17
4.3.1 Vuelta al mundo ................................................................................................................. 18
4.3.2 Golpea y escapa .................................................................................................................. 19
4.3.3 Toro loco ............................................................................................................................. 21
4.4 EJECUCIÓN DE PROGRAMAS ................................................................................................................. 28
4.4.1 Simulador Gazebo ............................................................................................................... 28
4.4.2 Turtlebot ............................................................................................................................. 29
4.5 NAVEGACIÓN AUTÓNOMA USANDO LOS PACKAGES DE ROS ....................................................................... 30
4.5.1 Calibración de sensores ...................................................................................................... 31
4.5.2 Creación del mapa .............................................................................................................. 32
4.5.3 Navegación por el entorno mapeado ................................................................................. 35
5 DISCUSIÓN DEL RESULTADO ..................................................................................................... 39
6 CONCLUSIONES Y TRABAJOS FUTUROS ..................................................................................... 41
7 BIBLIOGRAFÍA .......................................................................................................................... 41
ANEXO A. COMANDOS MÁS EMPLEADOS DE ROS ....................................................................... 43
FIGURAS
FIG. 3.1 PARTES DEL TURTLEBOT .......................................................................................................................... 8
FIG. 4.1 TABLERO DE INSTRUMENTOS (DASHBOARD) DEL TURTLEBOT ........................................................................ 16
FIG. 4.2 MODOS DE OPERACIÓN DEL TURTLEBOT (DASHBOARD) ............................................................................... 17
FIG. 4.3 ENTORNO DE VISUALIZACIÓN E INTERACCIÓN RVIZ. INTERACTIVE MARKERS ...................................................... 17
FIG. 4.4 IMAGEN PROCESADA PROGRAMA TORO LOCO ............................................................................................ 28
FIG. 4.5 SIMULADOR GAZEBO CON EL MODELO DEL TURTLEBOT ............................................................................... 29
FIG. 4.6 COLOCACIÓN TURTLEBOT PARA CALIBRACIÓN ............................................................................................ 31
FIG. 4.7 MAPA 2D DE OCUPACIÓN DE REJILLA DEL LABORATORIO F6 ......................................................................... 34
FIG. 4.8 ESTRUCTURA DEL PACKAGE MOVE_BASE .................................................................................................. 35
FIG. 4.9 COMPORTAMIENTO RECUPERACIÓN MOVE_BASE ....................................................................................... 36
FIG. 4.10 INDICACIÓN INICIAL POSICIÓN ESTIMADA ................................................................................................ 37
FIG. 4.11 TRAYECTORIA SEGUIDA HASTA EL DESTINO .............................................................................................. 38
3
1 Objetivos, justificación
El objetivo del presente trabajo es conseguir que el robot Turtlebot, robot móvil con
ruedas, navegue de forma autónoma por un entorno acotado y conocido, empleando
el entorno de desarrollo para programas de control de robots ROS. Al igual que un ser
humano cuando se encuentra en una ciudad, busca referencias en el entorno que le
ayuden a localizar su situación en el plano y así planificar la ruta para alcanzar su
destino. El robot tiene que ser capaz de navegar por un entorno de trabajo utilizando
únicamente las señales de sus sensores.
También se han desarrollo una serie de programas de control para el robot
Turtlebot, los cuales siguen una progresión en dificultad, cuyo objetivo ha sido la
inmersión en este entorno de desarrollo. De los cuales destaca el que realiza el
seguimiento de objetos de tonalidad roja.
Se prevé la aparición de robots móviles para la realización de tareas domesticas en
un corto periodo de tiempo, véase como ejemplo de esta tendencia el aspirador
Roomba (1) de iRobot. Al ser dispositivos móviles deben conocer en todo momento su
situación dentro del entorno de trabajo, y detectar rápidamente los cambios en este y
adaptarse, como pueden ser la interacción con seres humanos o animales. Posibles
aplicaciones son la tele asistencia a personas mayores y labores de vigilancia.
ROS es un entorno que agiliza y facilita la tarea de diseño de programas de control
para robots, ya que proporciona una gran cantidad de paquetes que implementan
cada una de las pequeñas tareas como, captación de datos de sensores y
transformación, envió de datos a los actuadores y transformación, comunicaciones,
etc. Esto hace que el diseñador simplemente tenga que preocuparse de programar el
comportamiento del robot, en base a los sensores y actuadores con los que esta
equipado.
2 Estado del arte
La plataforma de desarrollo de software para robots ROS (2) apareció en marzo de
2010, de la mano del equipo de expertos en diseño de robots Willow Garage (3), y se
ha convertido en estos tres años en una de las más populares y empleadas, dando
4
soporte a un gran número de robots. Aunque su gran éxito radica en que se trata de
un software de código abierto con licencia BSD (Berkeley Software Distribution), en el
que participan un gran número de investigadores a través de la plataforma ROS.org.
En la actualidad se encuentra en la versión “Fuerte”, su quinta versión, hasta el
momento sólo con soporte para el desarrollo de programas para el robot PR2
(Desarrollado y comercializado por Willow Garage). Se plantea como un estándar en
programación de robots.
El problema de la localización dentro del entorno de operación es un problema
común a todos los robots móviles. Es necesario indicar que hay dos tipos de
localización, global y local:
Localización local: la posición inicial es conocida. Es necesario hacer un
seguimiento de los movimientos del robot y modificaciones según las
observaciones del entorno próximo para mantener localizado al robot.
Localización global: la posición inicial no es conocida. Hay que determinar la
posición inicial del robot dentro del mapa del entorno de trabajo según las
observaciones del entorno próximo. Esta localización también debe incluir la
localización local. El secuestro es una variación de la localización global, que
consiste en mover al robot a otra posición del entorno.
El método de localización de Markov (4) fue uno de los primeros métodos de
localización probabilística. Emplea un filtro de Bayes para estimar la posición del robot,
haciendo uso de los sensores de movimiento y del sensor de obstáculos. Estima la
posición del robot haciendo una distribución de probabilidad entre los puntos
permitidos del mapa. La localización EKF (5) (Extended Kalman Filter) es un caso
especial de la localización de Markov que emplea un filtro de Kalman.
Otra variación de la localización de Markov es empleando el filtro de Bayes discreto
o filtros de partículas sobre un entorno discreto, con un numero de valores finito. La
localización Monte Carlo (6) se ha convertido en uno de los métodos de localización
para robots móviles más empleado en la actualidad que emplea un filtro de partículas.
5
Sus resultados son buenos, en localización global y en localización local, y tiene un
menor coste computacional que los anteriores.
ROS incorpora las soluciones más populares y eficientes actuales para solventar la
localización. El método que se ha empleado es la localización adaptativa Monte Carlo
(7) (conocido por su acrónimo inglés, AMCL), un método probabilístico basado en un
filtro de partículas para la determinación de la posición del robot en el mapa del
entorno de trabajo. El método implementado es de localización local por lo que
requiere de una semilla de inicialización, la posición aproximada del robot en el
entorno de trabajo, para su correcto funcionamiento.
A la problemática de la localización del robot dentro del mapa del entorno de
trabajo, se añade la construcción del mapa. Este procedimiento se conoce como
localización y mapeado simultáneos (conocido por su acrónimo inglés, SLAM). Para la
construcción del mapa se ha empleado el método GMapping (8) que emplea un filtro
de partículas Rao-Blackwellized para reducir la incertidumbre de la localización real de
los puntos mapeados, empleando las lecturas del sensor de obstáculos y el
movimiento descrito por el robot para reducir esa incertidumbre. Permite la creación
de un mapa 2D de ocupación de rejilla, similar a un plano, en el que se incluyen todos
los obstáculos presentes en el entorno mapeado.
Cuando se escucha hablar de robots móviles, influenciados mayormente por el cine
de ciencia ficción, se asocia a robots bípedos de morfología similar a la humana. Pero
realmente estos humanoides resultan muy costosos, por lo que para investigación en
robots móviles se suelen emplear robots con ruedas, menos costosos y más fáciles de
diseñar. El Turtlebot es un claro ejemplo, se trata de un robot móvil con ruedas
enfocado a la investigación o el uso personal. Está construido a partir de un robot
móvil similar al aspirador Roomba de iRobot, al que se le ha acoplado una estructura
de soporte para una cámara Kinect y un ordenador portátil. Al estar compuesto a base
de elementos aislados de producción en serie tiene un precio bastante asequible.
6
3 Herramientas y metodología utilizada
Las herramientas utilizadas para la realización de este trabajo han sido, el entorno
de desarrollo ROS y el robot Turtlebot, ambos desarrollados por Willow Garage. En
cuanto a la metodología, esta se resume en el desarrollo de programas de control para
el robot Turtlebot, siguiendo una progresión en dificultad, con pruebas previas sobre
un simulador y prueba final sobre el robot.
3.1 ROS
El entorno de desarrollo empleado ha sido ROS, en su versión “Electric”, corriendo
en el sistema operativo Ubuntu, el único con soporte oficial. Este entorno de
desarrollo consiste en un middleware que corre en Ubuntu. Funciona, por así decirlo,
como un mediador entre nuestros programas y el resto de procesos necesarios en su
ejecución, encargándose de las comunicaciones haciendo uso de un tipo de mensaje
concreto para cada tipo de tarea.
El objetivo de este entorno es hacer completamente transparente la programación
del robot, dejando ocultos los controladores hardware, las comunicaciones, sistema de
archivos, etc. El programador solo necesita conocer el tipo de mensaje que envía o
recibe cada sensor o actuador del robot.
3.1.1 Estructura de archivos y comandos
Los programas que podemos utilizar y desarrollar se encuentran en directorios que
ROS llama packages, los cuales a su vez pueden estar agrupados, o no, en directorios
jerárquicamente superiores llamados stacks. Estos directorios contienen los archivos
de información de dependencias con otros packages, y de compilación de los
programas que contienen. Los comandos empleados son también packages del
entorno de desarrollo ROS. Los más empleados se recogen en el anexo A.
7
3.1.2 Ejecución de programas
Para la ejecución de programas1 sobre ROS es necesario tener en marcha un core, o
núcleo del sistema, que es el que gestiona la ejecución y comunicación de los
programas, denominados nodes. Estos nodes pueden publicar o estar suscritos a
mensajes, llamados topics, de otros nodes.
También existen nodes que proporcionan un servicio, y lo que reciben son
argumentos de un node cliente. Los nodes también pueden disponer de parámetros de
configuración que pueden ser modificados.
3.1.3 Aplicaciones
De las aplicaciones gráficas con las que cuenta ROS, las más importantes son el
simulador Gazebo y el entorno de visualización rviz.
Gazebo (9) permite la simulación de los programas de control en un entorno 3D, en
el que interactúa el modelo del robot con los elementos que situemos en el mundo.
Emplea archivos con formato XML para la carga del modelo del robot y del mundo.
Con ayuda de los tutoriales contenidos en el wiki de gazebosim.org se pueden crear
modelos del robot a medida o mundos que imiten el entorno real de aplicación.
El entorno de visualización rviz, permite la visualización de gran número de topics,
además de la interacción entre el robot y el entorno gráfico, como puede ser el caso de
indicar el destino al robot sobre el mapa del entorno de trabajo.
3.2 Turtlebot
El robot empleado ha sido el Turtlebot (10), desarrollado y comercializado por
Willow Garage. Se compone básicamente de, un robot iRobot Create2 que constituye
la base móvil, una cámara Microsoft Kinect, un Laptop ASUS 1215N y una estructura de
soporte y anclaje de los elementos a la base, véase ¡Error! No se encuentra el origen
e la referencia..
1 Los lenguajes de programación soportados por ROS son c++ y python, para los cuales dispone de librerías. Además de la librería OpenCV para tratamiento de imágenes. 2 Robot dedicado a fines educativos y la investigación, similar al aspirador iRobot Roomba.
8
3.2.1 Hardware
A continuación se describen cada uno de los componentes del robot Turtlebot, los
cuales parecen indicados en la Fig. 3.1.
FIG. 3.1 PARTES DEL TURTLEBOT
A. iRobot Create y placa de alimentación
El iRobot Create esta provisto de una serie de sensores integrados, odómetro,
detectores de caída, detectores de paredes y detectores de golpes. Para la
alimentación de la cámara Kinect se proporciona una placa de alimentación que
se conecta al puerto DB25 del iRobot Create, que además incorpora un
giroscopio de un eje. El conjunto, excepto el computador, se alimenta de una
batería de níquel-hidruro metálico (Ni-MH) de 3000 mAh. Para la comunicación
del iRobot Create con el computador se proporciona un adaptador serie - USB.
B. Microsoft Kinect
La cámara Kinect es el principal sensor del Turtlebot. Dispone de visión simple y
estereoscópica, así como un escáner 3D de infrarrojos. Se proporciona un cable
para su alimentación a través de la placa de alimentación y conexión al
computador.
C. ASUS 1215N Laptop
Es el cerebro del robot, se encarga de las comunicaciones, el procesamiento de
los señales de los sensores y ejecución de los programas. Cuenta con las
9
siguientes características técnicas, las cuales lo hacen un equipo óptimo para
esta aplicación, lo suficientemente pequeño y de rendimiento adecuado:
Procesador Intel® Atom™ D525 Dual Core
2 GB de memoria RAM
Procesador gráfico NVIDIA® ION™
Disco duro de 250 GB
D. Estructura de soporte de elementos
Para la sujeción del resto de elementos al iRobot Create se dispone de una
estructura de barras y plataformas circulares, similar a una estantería,
atornillada a este. La plataforma superior dispone de un patrón de
perforaciones espaciadas una pulgada para el montaje de accesorios, como un
brazo de manipulación.
3.2.2 Software
El software del que dispone el computador es el estrictamente necesario para hacer
funcionar el entorno de desarrollo ROS. La versión del sistema operativo Ubuntu es la
10.04 e incluye ROS con las herramientas y aplicaciones específicas para el Turtlebot.
La versión incluida de ROS es la “Diamondback”, pero ha sido actualizada a la versión
“Electric”.
3.3 Metodología
Se ha comenzado con una aclimatación al entorno de desarrollo ROS, usando como
apoyo los numerosos tutoriales disponibles en ROS.org. Los tutoriales siguen una
progresión adaptativa, desde un nivel cero hasta las estructuras básicas de programas.
La documentación disponible es de lo más completa y exhaustiva.
Obtenida una mínima soltura en el entorno, se ha procedido con la realización de
programas de control siguiendo una progresión en dificultad y complejidad.
Comenzando por un pequeño programa de bautismo, hacer girar en círculo al
Turtlebot, y acabando con una navegación autónoma.
Gran parte del tiempo empleado en la prueba y modificación de los programas ha
sido sobre el simulador Gazebo, lo que hace el proceso más ágil y dinámico, además se
10
elimina la dependencia energética de las baterías del computador y el iRobot Create.
Lo más recomendable es hacer las primeras pruebas sobre el simulador para evitar
posibles desperfectos al robot.
Testado el programa en el simulador se ha procedido a su ejecución en el robot
Turtlebot. El entorno de pruebas ha sido el laboratorio F6 de la Escuela de Ingenierías
Industrial e Informática de la Universidad de león, emplazamiento habitual del grupo
de robótica de esta universidad.
4 Trabajo desarrollado
Para la correcta documentación del trabajo de laboratorio, se ha realizando de
forma simultánea un artículo (11) en el wiki del grupo de robótica de la Universidad de
León, del cual se han extraído los siguientes puntos.
4.1 Puesta en marcha de ROS
El computador del robot Turtlebot, en adelante PC robot, viene con el software
necesario preinstalado, por lo que se ha centrado esta tarea en el PC estación de
trabajo, es decir, el equipo que se empleará para la simulación de los programas y el
control de ejecución de programas en el PC robot. Aunque el procedimiento sería
análogo para la instalación de ROS en otro ordenador para su uso como PC robot, con
un pequeño añadido que se indica al final de este punto.
4.1.1 Instalación y configuración
Lo primero que se necesita es un computador con el sistema operativo Ubuntu, que
es el único con soporte oficial de ROS, otros sistemas operativos para los que está
disponible sólo son experimentales.
Para instalar el entorno de desarrollo ROS para el robot Turtlebot en el PC estación
de trabajo, se necesita añadir los repositorios de ROS. Se introducirá en un terminal del
PC estación de trabajo el comando que corresponda a la versión instalada de Ubuntu:
Ubuntu 10.04 (Lucid)
sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu lucid main" >
/etc/apt/sources.list.d/ros-latest.list'
11
Ubuntu 10.10 (Maverick)
sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu maverick main" >
/etc/apt/sources.list.d/ros-latest.list'
Ubuntu 11.04 (Natty)
sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu natty main" >
/etc/apt/sources.list.d/ros-latest.list'
Ubuntu 11.10 (Oneiric)
sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu oneiric main" >
/etc/apt/sources.list.d/ros-latest.list'
Se necesita añadir las llaves del repositorio para verificar que el software
descargado esta autorizado, ejecutando el siguiente comando en un terminal:
wget http://packages.ros.org/ros.key -O - | sudo apt-key add -
Para completar la instalación de ROS solo queda ejecutar la siguiente secuencia de
comandos en un terminal:
sudo apt-get update
sudo apt-get install ros-electric-turtlebot-desktop
Para poder ejecutar los comandos del entorno ROS en el terminal, se necesita
añadir una línea al archivo de configuración del terminal (~/.bashrc), en la que se
cargue el archivo de variables de entorno de ROS. Para esto se debe ejecutar en un
terminal el siguiente comando:
echo "source /opt/ros/electric/setup.bash" >> ~/.bashrc
Ahora ya se pueden ejecutar los comandos del entorno ROS en el terminal, los más
empleados se recogen en el anexo A.
Es importante que el reloj del PC estación de trabajo se encuentre sincronizado con
el reloj del PC robot, para prevenir las posibles perdidas de red inalámbrica. Para
instalar el cliente NTP Chrony se ejecutará el siguiente comando en un terminal:
sudo apt-get install chrony
12
Lo habitual es conectar ambos equipos a una red Wi-Fi, pero puede darse que el PC
estación de trabajo no disponga de un interfaz de red inalámbrica. En este caso es
necesario poder conectarse a un puerto del router que provee la red Wi-Fi, para que
exista una ruta de acceso entre el PC estación de trabajo y el PC robot.
En ambos equipos, PC estación de trabajo y PC robot, se añadirá el
ROS_MASTER_URI en el archivo de configuración del terminal (~/.bashrc), que apunta
a la dirección IP del PC robot, que es el que ejecuta el servicio maestro. Simplemente
se debe escribir el siguiente comando en un terminal, sustituyendo
"IP_OF_TURTLEBOT", por la dirección IP asignada en la red al PC robot:
echo “export ROS_MASTER_URI=http://IP_OF_TURTLEBOT:11311” >> ~/.bashrc
También se debe asignar un nombre de equipo, tanto al PC estación de trabajo
como al PC robot. Este nombre será la dirección IP de cada equipo, que se almacenará
en el archivo de configuración del terminal (~/.bashrc). En un terminal del PC robot se
ejecutará el siguiente comando, sustituyendo "IP_OF_TURTLEBOT", por la dirección IP
asignada en la red al PC robot:
echo “export ROS_HOSTNAME=IP_OF_TURTLEBOT” >> ~/.bashrc
En un terminal del PC estación de trabajo se ejecutará el siguiente comando,
sustituyendo "IP_OF_WORKSTATION", por la dirección IP asignada en la red al PC
estación de trabajo:
echo “export ROS_HOSTNAME=IP_OF_WORKSTATION” >> ~/.bashrc
Nota: Para conocer la dirección IP, asignada en la red a un equipo, simplemente se
debe ejecutar en un terminal:
ifconfig
Que mostrará una información similar a esta:
eth0 Link encap:Ethernet direcciónHW 00:16:d4:55:85:b4
ACTIVO DIFUSIÓN MULTICAST MTU:1500 Métrica:1
Paquetes RX:0 errores:0 perdidos:0 overruns:0 frame:0
Paquetes TX:0 errores:0 perdidos:0 overruns:0 carrier:0
colisiones:0 long.colaTX:1000
Bytes RX:0 (0.0 B) TX bytes:0 (0.0 B)
Interrupción:44
13
lo Link encap:Bucle local
Direc. inet:127.0.0.1 Másc:255.0.0.0
Dirección inet6: ::1/128 Alcance:Anfitrión
ACTIVO BUCLE FUNCIONANDO MTU:16436 Métrica:1
Paquetes RX:64 errores:0 perdidos:0 overruns:0 frame:0
Paquetes TX:64 errores:0 perdidos:0 overruns:0 carrier:0
colisiones:0 long.colaTX:0
Bytes RX:5184 (5.1 KB) TX bytes:5184 (5.1 KB)
wlan0 Link encap:Ethernet direcciónHW 00:18:de:21:4b:ad
Direc. inet:192.168.1.10 Difus.:192.168.1.255 Másc:255.255.255.0
Dirección inet6: fe80::218:deff:fe21:4bad/64 Alcance:Enlace
ACTIVO DIFUSIÓN FUNCIONANDO MULTICAST MTU:1500 Métrica:1
Paquetes RX:130972 errores:0 perdidos:0 overruns:0 frame:0
Paquetes TX:87840 errores:0 perdidos:0 overruns:0 carrier:0
colisiones:0 long.colaTX:1000
Bytes RX:169415208 (169.4 MB) TX bytes:9379691 (9.3 MB)
Nota: Cuando se instale ROS en un equipo destinado a ser el PC robot, a parte de todo
lo anterior, necesitaremos crear un archivo llamado “52-turtlebot.rules” en el
directorio /etc/udev/rules.d/. Con el siguiente contenido:
52-turtlebot.rules
ATTRS{idProduct}=="XXXX",ATTRS{idVendor}=="XXXX",MODE="666",GROUP="turtlebot"
Donde las “XXXX” corresponden a la identificación del producto y del fabricante,
respectivamente, del adaptador USB de conexión con el iRobot Create. Esta
información la obtiene ejecutando el siguiente comando en un terminal, con el
adaptador conectado:
lsusb
Que mostrará una información similar a esta:
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 004 Device 002: ID 045e:0040 Microsoft Corp. Wheel Mouse Optical
Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 005 Device 003: ID 0403:6001 Future Technology Devices International, Ltd
FT232 USB-Serial (UART) IC <--ADAPTADOR USB-->
Donde “6001” corresponde a la identificación del producto y “0403” a la identificación
del fabricante.
También se debe añadir el usuario, con el que hemos instalado ROS, al grupo “dialout”,
para que tenga permisos sobre el puerto que se emplea para la comunicación con el
iRobot Create, ttyUSB0.
14
4.1.2 Creación de un espacio de trabajo y un package
Lo más cómodo para trabajar es crear un directorio propio para stacks y packages
en el PC estación de trabajo, ya que ROS tiene por defecto como directorio para stacks
y packages /opt/ros/electric/stacks. Se pueden crear los nuevos stacks o packages en
este directorio por defecto, haciendo uso de los privilegios de súper usuario, pero
queda más organizado y accesible creando uno particular.
El directorio se puede situar donde y con el nombre que se quiera. Se comenzará
creando un directorio, por ejemplo en la carpeta personal:
mkdir ~/ros_workspace
Para que el sistema también busque stacks y packages en nuestra carpeta, se debe
crear en la carpeta personal un archivo llamado "setup.sh", con el siguiente contenido:
setup.h
#!/bin/sh source /opt/ros/electric/setup.bash
export ROS_ROOT=/opt/ros/electric/ros
export PATH=$ROS_ROOT/bin:$PATH
export PYTHONPATH=$ROS_ROOT/core/roslib/src:$PYTHONPATH
export ROS_PACKAGE_PATH=~/ros_workspace:/opt/ros/electric/stacks:$ROS_PACKAGE_PATH
Se debe añadir este nuevo archivo creado al archivo de configuración del terminal
(~/.bashrc), para hacer efectiva esta modificación. Para ello se debe ejecutar el
siguiente comando en un terminal:
echo “source ~/setup.sh” >> ~/.bashrc
En el directorio de trabajo creado se creará un package, el cual va a depender de
otros packages de ROS. Las dependencias van en función del tipo de mensajes que
queremos enviar o recibir, y el lenguaje empleado en los programas. Estas
dependencias son las que marcan lo programas que se han desarrollado, por lo que las
añadiremos al crear el package que va a contener los programas. Para esto se
introducirá la siguiente secuencia de comandos en un terminal:
cd ~/ros_workspace
roscreate-pkg NOMBRE_PACKAGE std_msgs turtlebot_node geometry_msgs nav_msgs
sensor_msgs image_transport roscpp
15
También se pueden añadir dependencias a un package ya creado, simplemente se
debe editar el archivo "manifest.xml" que se encuentra dentro de la carpeta del
package creado. El contenido del archivo "manifest.xml" es similar al siguiente, las
dependencias se encuentran al final:
manifest.xml
<package>
<description brief="NOMBRE_PACKAGE">
NOMBRE_PACKAGE
</description>
<author>FeR</author>
<license>BSD</license>
<review status="unreviewed" notes=""/>
<url>http://ros.org/wiki/ NOMBRE_DEL_PACKAGE </url>
<depend package="turtlebot_node"/>
<depend package="geometry_msgs"/>
<depend package="nav_msgs"/>
<depend package="std_msgs"/>
<depend package="sensor_msgs"/>
<depend package="image_transport"/>
<depend package="roscpp"/>
</package>
Una vez creado el package, o modificadas las dependencias de un package
existente, se debe compilar para que se hagan efectivas las dependencias.
Simplemente se debe ejecutar el siguiente comando en el terminal, indicando el
nombre del package:
rosmake NOMBRE_PACKAGE
4.2 Puesta en marcha del Turtlebot
Con la red configurada, ya se puede proceder a la puesta en marcha del Turtlebot.
Se conectarán los cables USB de comunicación del robot al PC robot, se encenderá el
iRobot Create y se arrancará el PC robot.
Las operaciones sobre el PC robot se pueden hacer directamente sobre él, pero no
es la opción recomendable por comodidad de trabajo. Así que se comenzará
conectando por ssh, desde el PC estación de trabajo con el PC robot. Se ejecutará el
siguiente comando en un terminal del PC estación de trabajo, sustituyendo
"IP_OF_TURTLEBOT" por la dirección IP asignada en la red al PC robot:
ssh turtlebot@IP_OF_TURTLEBOT
16
Pedirá la contraseña asignada al PC robot. Cuando se conecte el prompt del terminal
cambiará por el del PC robot. Se puede comprobar el estado del servicio del robot,
tecleando el siguiente comando en el terminal:
sudo service turtlebot status
Devolverá un mensaje diciendo que está iniciado. El servicio se inicia siempre que
encendemos el PC robot, pero se puede detener y poner en marcha desde el terminal
con los siguientes comandos:
sudo service turtlebot stop
sudo service turtlebot start
En un terminal nuevo del PC estación de trabajo se ejecutará la aplicación del
tablero de instrumentos (dashboard) del robot. Simplemente se debe introducir este
comando en el terminal:
rosrun turtlebot_dashboard turtlebot_dashboard&
Aparecerá una pequeña ventana similar a la que aparece en la Fig. 4.1.
FIG. 4.1 TABLERO DE INSTRUMENTOS (DASHBOARD) DEL TURTLEBOT
La ventana del tablero de instrumentos consta de tres zonas bien diferenciadas:
Diagnóstico del sistema, mensajes del sistema y modo de operación.
Interruptores de los circuitos de las tres salidas digitales del iRobot Create.
Niveles de batería del iRobot Create y del PC robot.
Si todo va bien, como en la Fig. 4.2, estarán en verde los iconos de diagnostico del
sistema (llave inglesa) y mensajes del sistema (nube de llamada). El modo de operación
se debe poner en Full Mode, para poder operar el robot. En los otros modos no está
permitida la operación del robot, son el modo de recarga de la bateria (Passive Mode)
y de espera (Safety Mode).
17
FIG. 4.2 MODOS DE OPERACIÓN DEL TURTLEBOT (DASHBOARD)
También se debe activar al menos el interruptor "1", que es el que controla el
circuito de alimentación de la cámara Kinect. Ahora ya esta todo listo para comenzar a
operar con el robot. Para verlo en funcionamiento es recomendable probar alguna de
las aplicaciones de demostración, la cuales encontramos detalladas en ROS.org. En la
Fig. 4.3 se puede ver la ejecución del tele operador del Turtlebot que emplea
interactive markers.
FIG. 4.3 ENTORNO DE VISUALIZACIÓN E INTERACCIÓN RVIZ. INTERACTIVE MARKERS
4.3 Programas desarrollados
Se han desarrollado una serie de programas en lenguaje c++, progresivamente más
complejos, los cuales dejan en relieve el gran potencial de la plataforma ROS, así como
18
su sencillez. Los archivos de los programas creados se guardarán en la carpeta "src" del
package creado.
4.3.1 Vuelta al mundo
Como guiño al primer programa de iniciación a un lenguaje de programación “hola
mundo”, se ha creado “vuelta al mundo”. Este primer programa, simplemente crea el
nodo "gira" y publica el topic "cmd_vel", que hace mover el robot con una velocidad de
avance y de giro (describiendo un círculo), hasta que se reciba la señal de parada
"Ctrl+C". El programa es el siguiente:
gira.cpp
#include "ros/ros.h" //Librería de funciones del sistema ROS
#include "geometry_msgs/Twist.h" //Librería "Twist" del package "geometry_msgs"
int main(int argc, char **argv)
{
ros::init(argc, argv, "gira"); //Creación del nodo "gira"
ros::NodeHandle n;
ros::Publisher vel_pub_=n.advertise<geometry_msgs::Twist>("cmd_vel", 1); //Publicación del
topic "turtlebot_node/cmd_vel"
geometry_msgs::Twist vel;
ros::Rate loop_rate(10); //Frecuencia de realización del bucle (10 Hz)
while (ros::ok()) //Bucle mientras no se reciba "Ctrl+C"
{
vel.linear.x = 0.2; //velocidad de avance
vel.angular.z = 0.4; //velocidad de giro
vel_pub_.publish(vel);
loop_rate.sleep();
}
return 0;
}
Se guardará con el nombre "gira.cpp". Para compilarlo y generar el ejecutable se
debe añadir la siguiente línea de código al archivo "CMakeLists.txt" del package
creado, donde indicamos el nombre para el ejecutable y la ruta y nombre del archivo a
compilar:
rosbuild_add_executable(gira src/gira.cpp)
19
Para compilar el programa hay que situarse en el directorio del package.
Simplemente con ejecutar la siguiente secuencia de comandos en un terminal se
compilará y creará el ejecutable, siempre que no existan errores:
roscd NOMBRE_PACKAGE
make
4.3.2 Golpea y escapa
Este segundo programa añade la suscripción a un topic, además de la publicación. El
funcionamiento es bastante simple, comenzará a avanzar en línea recta hasta que se
detecte el accionamiento del parachoques del iRobot Create, provocado por el choque
con un objeto; en este momento realizará un pequeño retroceso y girará un ángulo, de
sentido y magnitud aleatorios, para intentar evitar el obstáculo. No se detendrá hasta
recibir la señal de parada "Ctrl+C". El código del programa, escrito en lenguaje c++, es
el siguiente:
juguete_golpe.cpp
#include "ros/ros.h" //Librería de funciones del sistema ROS
#include "geometry_msgs/Twist.h" //Librería "Twist" del package "geometry_msgs"
#include "turtlebot_node/TurtlebotSensorState.h" //Librería "TurtlebotSensorState" del package
"turtlebot_node"
geometry_msgs::Twist vel; //Declaración de la variable global vel
double alea; //Declaración de la variable global alea
void callback(const turtlebot_node::TurtlebotSensorState& sen) //Función de llamada con cada
dato recibido
{
ros::NodeHandle n;
ros::Publisher vel_pub_=n.advertise<geometry_msgs::Twist>("cmd_vel", 1); //Publicación del
topic "turtlebot_node/cmd_vel"
ros::Rate loop_rate(10); //Frecuencia de realización del bucle (10 Hz)
ros::Time ahora; //Declaración de variable tipo tiempo, variable ROS
if (sen.bumps_wheeldrops == 0) //Comprobación si ha habido señal del parachoques
{
::vel.linear.x = 0.2;
::vel.angular.z = 0.0;
vel_pub_.publish(::vel);
}
else
{
ahora = ros::Time::now(); //Asignación del tiempo actual a la variable ahora
while (ros::Time::now() < (ahora + ros::Duration(0.5))) //Bucle durante 0,5 segundos,
retroceso después de choque
{
::vel.linear.x = -0.2;
::vel.angular.z = 0.0;
vel_pub_.publish(::vel);
loop_rate.sleep();
20
}
::alea = ((rand() %40) -20)/10; //Asignación de valor aleatorio
while (::alea == 0) //Bucle mientras la variable aleatoria sea cero
{
::alea = ((rand() %40) -20)/10;
}
ahora = ros::Time::now(); //Asignación del tiempo actual a la variable ahora
while (ros::Time::now() < (ahora + ros::Duration(1.5))) //Bucle durante 1,5 segundos,
giro de ángulo aleatorio
{
::vel.linear.x = 0.0;
::vel.angular.z = ::alea;
vel_pub_.publish(::vel);
loop_rate.sleep();
}
}
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "juguete_golpe"); //Creación del nodo "juguete_golpe"
ros::NodeHandle n;
ros::Publisher vel_pub_=n.advertise<geometry_msgs::Twist>("cmd_vel", 1); //Publicación del
topic "turtlebot_node/cmd_vel"
ros::Subscriber odom_sub_= n.subscribe("turtlebot_node/sensor_state", 1, callback);
//Suscripción del topic "turtlebot_node/sensor_state"
ros::spin(); //Mantiene la suscripción al topic hasta que se reciba "Ctrl+C"
return 0;
}
Se guardará con el nombre "juguete_golpe.cpp". Para compilarlo y generar el
ejecutable se debe añadir la siguiente línea de código al archivo "CMakeLists.txt" del
package creado, donde indicamos el nombre para el ejecutable y la ruta y nombre del
archivo a compilar:
rosbuild_add_executable(juguete_golpe src/juguete_golpe.cpp)
Para compilar el programa hay que situarse en el directorio del package.
Simplemente con ejecutar la siguiente secuencia de comandos en un terminal se
compilará y creará el ejecutable, siempre que no existan errores:
roscd NOMBRE_PACKAGE
make
Nota: El modelo 3D del Turtlebot empleado en el simulador no implementa este
sensor, por lo que no será posible probar el programa en el simulador.
21
4.3.3 Toro loco
La peculiaridad de este programa es que el topic de suscripción es la imagen
obtenida por la cámara Kinect. La imagen se recibe empaquetada en un array de
"píxeles ancho x píxeles alto x 3 (componentes color RGB)" elementos, por defecto
(640 x 480 x 3) = 921600 elementos. Los píxeles se encuentran representados en sus
componentes RGB, con ese orden, comenzando en el píxel de la esquina superior
izquierda, continuando por filas hasta llegar al último píxel, esquina inferior derecha de
la imagen.
Píxel 1 Píxel 2 Píxel 307200
120 88 15 127 89 11 … 240 150 66
[0] [1] [2] [3] [4] [5] [921597] [921598] [921599]
Este tercer programa realiza el seguimiento de objetos de color rojo. Para ello
analiza cada imagen píxel a píxel, contando los píxeles del lado izquierdo y del lado
derecho. Cuando el número total de píxeles de tonalidades rojas es superior al 0,1 %,
de los píxeles totales de la imagen, e inferior al 5 %, comienza el seguimiento hasta
hacer el número de píxeles totales cercano al 2,5 % e igual a cada lado (estos valores
dependerán del tamaño del objeto). Cuando el objeto se encuentre demasiado lejos o
demasiado cerca se detendrá el seguimiento. Para facilitar la calibración cada vez que
se quiera modificar alguno de los parámetros del programa se creará un archivo .h, en
el que estarán definidas las constantes para cada parámetro, se guardará con el
nombre "param_sigue_rojo.h" y con el siguiente contenido:
param_sigue_rojo.h
#ifndef __PARAM_SIGUE_ROJO_H
#define __PARAM_SIGUE_ROJO_H
#define li_red 100 //Límite inferior para canal rojo
#define ls_red 255 //Límite superior para canal rojo
#define li_green 0 //Límite inferior para canal verde
#define ls_green 30 //Límite superior para canal verde
#define li_blue 0 //Límite inferior para canal azul
#define ls_blue 50 //Límite superior para canal azul
#define tam_min 0.001 //Porcentaje de píxeles de tonalidades rojas mínimo
#define tam_max 0.05 //Porcentaje de píxeles de tonalidades rojas máximo
#define tam_med 0.025 //Porcentaje de píxeles de tonalidades rojas medio
#define Px 0.08 //Ganancia velocidad de avance-retroceso
#define Pz 1.2 //Ganancia velocidad de giro
#endif /*__PARAM_SIGUE_ROJO_H*/
22
El código del programa, escrito en lenguaje c++, es el siguiente:
sigue_rojo.cpp
#include "ros/ros.h" //Librería de funciones del sistema ROS
#include "sensor_msgs/Image.h" //Librería "Image" del package "sensor_msgs"
#include "geometry_msgs/Twist.h" //Librería "Twist" del package "geometry_msgs"
#include "param_sigue_rojo.h" //Parámetros de ajuste
geometry_msgs::Twist vel; //Declaración de la variable global vel
sensor_msgs::Image region; //Declaración de la variable global vel
void callback(const sensor_msgs::Image& ima)
{
ros::NodeHandle n;
ros::Publisher vel_pub_=n.advertise<geometry_msgs::Twist>("cmd_vel", 1); //Publicación
del topic "/cmd_vel"
uint pix_r; //Declaración de variables de almacenaje valores rgb de cada píxel
uint pix_g;
uint pix_b;
uint ancho = ima.step; //Número de elementos de cada fila de la imagen
uint tam = ima.data.size(); //Número de elementos del array
double cont_izq = 0; //Declaración e inicialización de contadores de píxeles
double cont_der = 0;
::region = ima;
uint up;
uint right;
uint down;
uint left;
for (uint i = 0; i < tam; i = i + ancho) //Filtro de regiones pequeñas o píxeles
aislados
{
for (uint j = 0; j < ancho; j = j + 3)
{
pix_r = ima.data[i + j];
pix_g = ima.data[i + j + 1];
pix_b = ima.data[i + j + 2];
if (pix_r >= li_red && pix_r <= ls_red && pix_g >= li_green && pix_g <=
ls_green && pix_b >= li_blue && pix_b <= ls_blue)
{
up = 12;
if ((i/ancho) < 12)
{
up = (i/ancho);
}
right = 12;
if (((ancho - j)/3) < 12)
{
right = ((ancho - j)/3);
}
down = 12;
if (((tam/ancho) - (i/ancho)) < 12)
{
down = ((tam/ancho) - (i/ancho));
}
left = 12;
if ((j/3) < 12)
{
left = (j/3);
}
uint contr = 0;
for (uint k = i + j - (ancho*up) - (3*left); k <= (i + j +
(ancho*down) - (3*left)); k = k + ancho)
{
for(uint l = 0; l < ((3*left) + (3*right) +3); l = l + 3)
{
pix_r = ima.data[k + l];
23
pix_g = ima.data[k + l + 1];
pix_b = ima.data[k + l + 2];
if (pix_r >= li_red && pix_r <= ls_red && pix_g >= li_green
&& pix_g <= ls_green && pix_b >= li_blue && pix_b <= ls_blue)
{
contr++;
}
}
}
if (contr > (625*0.5))
{
::region.data[i + j] = 1;
::region.data[i + j + 1] = 1;
::region.data[i + j + 2] = 1;
}
}
}
}
for (uint i = 0; i < (tam - (ancho/2)); i = i + ancho) //Contar píxeles tonos rojos
lado izquierdo imagen
{
for (uint j = 0; j < (ancho/2); j = j + 3)
{
pix_r = ::region.data[i + j];
pix_g = ::region.data[i + j + 1];
pix_b = ::region.data[i + j + 2];
if (pix_r == 1 && pix_g == 1 && pix_b == 1)
{
cont_izq++;
}
}
}
for (uint i = (ancho/2); i < tam; i = i + ancho) //Contar píxeles tonos rojos lado
derecho imagen
{
for (uint j = 0; j < (ancho/2); j = j + 3)
{
pix_r = ::region.data[i + j];
pix_g = ::region.data[i + j + 1];
pix_b = ::region.data[i + j + 2];
if (pix_r == 1 && pix_g == 1 && pix_b == 1)
{
cont_der++;
}
}
}
double cont = cont_izq + cont_der;
if (cont > ((tam/3) * tam_min) && cont < ((tam/3) * tam_max)) //Comprobación si se está
dentro del limite inferior y superior de píxeles
{
::vel.angular.z = (cont_izq - cont_der) / (::abs(cont_izq - cont_der) * Pz);
//Velocidad de giro
::vel.linear.x = (((tam/3) * tam_med) - cont) / ((tam/3) * Px); //Velocidad de
avance-retroceso
vel_pub_.publish(vel);
}
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "sigue_rojo"); //Creación del nodo "sigue_rojo"
ros::NodeHandle n;
ros::Publisher vel_pub_=n.advertise<geometry_msgs::Twist>("cmd_vel", 1); //Publicación
del topic "cmd_vel"
ros::Subscriber image_sub_= n.subscribe("camera/rgb/image_color", 1, callback);
24
//Suscripción del topic "camera/rgb/image_color"
ros::spin(); //Mantiene la suscripción al topic hasta que se reciba "Ctrl+C"
return 0;
}
Ya que la tonalidad percibida por la cámara depende de la iluminación del recinto,
es necesaria una calibración de los límites de los canales RGB, para un correcto
funcionamiento.
Se guardará con el nombre "sigue_rojo.cpp". Para compilarlo y generar el
ejecutable se debe añadir la siguiente línea de código al archivo "CMakeLists.txt" del
package creado, donde indicamos el nombre para el ejecutable y la ruta y nombre del
archivo a compilar:
rosbuild_add_executable(sigue_rojo src/sigue_rojo.cpp)
Para compilar el programa hay que situarse en el directorio del package.
Simplemente con ejecutar la siguiente secuencia de comandos en un terminal se
compilará y creará el ejecutable, siempre que no existan errores:
roscd NOMBRE_PACKAGE
make
Además para la supervisión de las imágenes procesadas por el programa se ha
realizado otro programa que publica el topic "/camara/rojo" con la imagen modificada,
en la que los píxeles de tonalidad roja se colorean en rojo y el resto se muestra en
escala de grises, con una línea divisoria de color negro en el centro. El código del
programa, escrito en lenguaje c++, es el siguiente:
visulizacion.cpp
#include "ros/ros.h" //Librería de funciones del sistema ROS
#include "sensor_msgs/Image.h" //Librería "Image" del package "sensor_msgs"
#include "param_sigue_rojo.h" //Parámetros de ajuste
sensor_msgs::Image region; //Declaración de la variable global region
void callback(const sensor_msgs::Image& ima)
{
ros::NodeHandle n;
ros::Publisher rojo_pub_=n.advertise<sensor_msgs::Image>("camara/rojo", 1);
//Publicación del topic "camara/rojo"
uint pix_r; //Declaración de variables de almacenaje valores rgb de cada píxel
uint pix_g;
uint pix_b;
uint ancho = ima.step; //Número de elementos de cada fila de la imagen
uint tam = ima.data.size(); //Número de elementos del array
25
::region = ima;
uint up;
uint right;
uint down;
uint left;
for (uint i = 0; i < tam; i = i + ancho) //Filtro de regiones pequeñas o píxeles
aislados
{
for (uint j = 0; j < ancho; j = j + 3)
{
pix_r = ima.data[i + j];
pix_g = ima.data[i + j + 1];
pix_b = ima.data[i + j + 2];
if (pix_r >= li_red && pix_r <= ls_red && pix_g >= li_green && pix_g <=
ls_green && pix_b >= li_blue && pix_b <= ls_blue)
{
up = 12;
if ((i/ancho) < 12)
{
up = (i/ancho);
}
right = 12;
if (((ancho - j)/3) < 12)
{
right = ((ancho - j)/3);
}
down = 12;
if (((tam/ancho) - (i/ancho)) < 12)
{
down = ((tam/ancho) - (i/ancho));
}
left = 12;
if ((j/3) < 12)
{
left = (j/3);
}
uint contr = 0;
for (uint k = i + j - (ancho*up) - (3*left); k <= (i + j +
(ancho*down) - (3*left)); k = k + ancho)
{
for(uint l = 0; l < ((3*left) + (3*right) +3); l = l + 3)
{
pix_r = ima.data[k + l];
pix_g = ima.data[k + l + 1];
pix_b = ima.data[k + l + 2];
if (pix_r >= li_red && pix_r <= ls_red && pix_g >= li_green
&& pix_g <= ls_green && pix_b >= li_blue && pix_b <= ls_blue)
{
contr++;
}
}
}
if (contr > (625*0.5))
{
::region.data[i + j] = 255;
::region.data[i + j + 1] = 0;
::region.data[i + j + 2] = 0;
}
else //Conversión a escala de grises regiones pequeñas o píxeles
aislados
{
if (pix_r > pix_g)
{
::region.data[i + j] = pix_r;
::region.data[i + j + 1] = pix_r;
::region.data[i + j + 2] = pix_r;
}
else if (pix_g > pix_b)
{
::region.data[i + j] = pix_g;
26
::region.data[i + j + 1] = pix_g;
::region.data[i + j + 2] = pix_g;
}
else
{
::region.data[i + j] = pix_b;
::region.data[i + j + 1] = pix_b;
::region.data[i + j + 2] = pix_b;
}
}
}
else //Conversión a escala de grises resto píxeles
{
if (pix_r > pix_g)
{
::region.data[i + j] = pix_r;
::region.data[i + j + 1] = pix_r;
::region.data[i + j + 2] = pix_r;
}
else if (pix_g > pix_b)
{
::region.data[i + j] = pix_g;
::region.data[i + j + 1] = pix_g;
::region.data[i + j + 2] = pix_g;
}
else
{
::region.data[i + j] = pix_b;
::region.data[i + j + 1] = pix_b;
::region.data[i + j + 2] = pix_b;
}
}
}
}
for (uint i = (ancho/2)-3; i < tam; i = i + ancho) //Línea negra divisoria central
{
for (uint j = 0; j < 6; j = j + 3)
{
::region.data[i + j] = 0;
::region.data[i + j + 1] = 0;
::region.data[i + j + 2] = 0;
}
}
rojo_pub_.publish(::region);
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "visualizacion"); //Creación del nodo "visualizacion"
ros::NodeHandle n;
ros::Publisher rojo_pub_=n.advertise<sensor_msgs::Image>("camara/rojo", 1);
//Publicación del topic "camara/rojo"
ros::Subscriber image_sub_= n.subscribe("camera/rgb/image_color", 1, callback);
//Suscripción del topic "camera/rgb/image_color"
ros::spin(); //Mantiene la suscripción al topic hasta que se reciba "Ctrl+C"
return 0;
}
Se guardará con el nombre "visualizacion.cpp". Para compilarlo y generar el
ejecutable se debe añadir la siguiente línea de código al archivo "CMakeLists.txt" del
package creado, donde indicamos el nombre para el ejecutable y la ruta y nombre del
archivo a compilar:
27
rosbuild_add_executable(sigue_rojo src/sigue_rojo.cpp)
Para compilar el programa hay que situarse en el directorio del package.
Simplemente con ejecutar la siguiente secuencia de comandos en un terminal se
compilará y creará el ejecutable:
roscd NOMBRE_PACKAGE
make
Para poder ejecutar "kinect.launch", "sigue_rojo" y "visualización" de forma
simultánea se creará un launcher. Para ello crearemos dentro de la carpeta de nuestro
package una carpeta llamada "launch", dentro de la cual crearemos un archivo
llamado "rojo.launch" con el siguiente contenido:
rojo.launch
<launch>
<include file="$(find turtlebot_bringup)/kinect.launch" />
<node name="sigue_rojo" pkg="NOMBRE_PACKAGE" type="sigue_rojo" />
<node name="visualizacion" pkg=" NOMBRE_PACKAGE " type="visualizacion" />
</launch>
Para ejecutar el launcher que lanza los dos nodos, "sigue_rojo" y "visualización",
simplemente habrá que ejecutar el siguiente comando en un terminal del PC robot:
roslaunch NOMBRE_PACKAGE rojo.launch
Para poder visualizar la imagen modificada de la cámara Kinect en el PC estación de
trabajo, para la supervisión. Simplemente hay que ejecutar el siguiente comando en un
terminal:
rosrun image_view image_view image:=/camara/rojo
Las imágenes, ver Fig. 4.4, tendrán una tasa de frames baja y un retardo, teniendo
en cuenta que simplemente son para supervisión pueden valer.
28
FIG. 4.4 IMAGEN PROCESADA PROGRAMA TORO LOCO
4.4 Ejecución de programas
Lo recomendables es ejecutar los programas primero en el simulador para
salvaguardar la integridad del robot, además de ganar mucho tiempo en la depuración
del programa.
4.4.1 Simulador Gazebo
Lo primero que se debe hacer para poder arrancar el simulador es comentar las
líneas que se han añadido para la comunicación con el PC robot en el archivo
"~/.bashrc", del PC estación de trabajo, tal y como se muestra, añadiendo el símbolo
"#" al principio de la línea:
# export ROS_MASTER_URI=http://IP_OF_TURTLEBOT:11311
# export ROS_HOSTNAME=IP_OF_WORKSTATION
Se debe reiniciar la sesión de usuario para que surtan efecto los cambios. Para
ejecutar el simulador del Turtlebot simplemente se bebe ejecutar el siguiente
comando en un terminal:
roslaunch turtlebot_gazebo turtlebot_empty_world.launch
Terminada la carga aparecerá una ventana gráfica del simulador Gazebo con un
escenario vacío y el modelo 3D del robot, como se muestra en la Fig. 4.5.
29
FIG. 4.5 SIMULADOR GAZEBO CON EL MODELO DEL TURTLEBOT
Se puede cambiar el punto de vista jugando con la rueda del ratón y el botón
derecho. Además, se pueden añadir objetos 3D, como esferas, prismas y cilindros.
Para ejecutar los programas creados se introducirá el siguiente comando en un
terminal nuevo, indicando el package donde se encuentra y el nombre del ejecutable:
rosrun NOMBRE_PACKAGE NOMBRE_EJECUTABLE
Si todo ha ido bien, el modelo 3D del robot comenzara a comportarse tal y como le
indique el programa que se haya ejecutado.
4.4.2 Turtlebot
Si se han modificado las líneas para comunicación del archivo "~/.bashrc", para
ejecutar el simulador, se deben restaurar y reiniciar la sesión de usuario para que
surtan efecto los cambios.
Conectado el PC estación de trabajo al PC robot por ssh, se debe crear un espacio de
trabajo y un package, al igual que en el PC estación de trabajo. Creado el espacio de
trabajo y el package, se copiará el programa situado en el PC estación de trabajo al PC
30
robot, escribiendo la siguiente secuencia de comandos en un nuevo terminal del PC
estación de trabajo:
roscd NOMBRE_DEL_PACKAGE
cd src
scp PROGRAMA.cpp turtlebot@IP_OF_TURTLEBOT:/RUTA_PACKAGE/src/PROGRAMA.cpp
Una vez copiado el archivo del programa al PC robot, para poder ser ejecutado hay
que compilarlo. Para ejecutar el programa simplemente se debe introducir el siguiente
comando en un terminal del PC robot, tomando la precaución que el robot se
encuentre en un espacio lo bastante diáfano para evitar colisiones:
rosrun NOMBRE_PACKAGE NOMBRE_JECUTABLE
Cuando el programa que se va a ejecutar necesita de la cámara Kinect, se debe
poner en marcha esta previamente. Para poner en marcha la cámara Kinect se debe
lanzar en el PC robot el "kinect.launch", ejecutando el siguiente comando en un
terminal:
roslaunch turtlebot_bringup kinect.launch
Nota: si se encuentra conectada al robot alguna de las fuentes de alimentación, del PC
robot o del iRobot Create, este no se moverá.
4.5 Navegación autónoma usando los packages de ROS
ROS proporciona una serie de packages que nos permiten implementar una
navegación autónoma. Los datos que emplea para esto son los de los sensores
odómetro y giroscopio, para la captura de los movimientos, y la cámara Kinect, para la
detección de obstáculos. El laser es el sensor empleado habitualmente para la
detección de obstáculos. La cámara Kinect no dispone de un láser, pero si de un
escáner 3D de infrarrojos que capta la profundidad, por lo que la nube de puntos
obtenida se transforma en una señal 2D de profundidad.
Para lograr la navegación autónoma primero se debe obtener un mapa 2D de
ocupación de rejilla del entorno de trabajo, empleando un método SLAM, operando el
robot manualmente. Esto requiere la correcta calibración de sensores. Posteriormente
este mapa se emplea para la estimación de la ruta a seguir desde el punto de origen al
31
punto de destino, además de realizar de forma simultánea una localización del robot
dentro del entorno, empleando un método de localización probabilístico. Hacer que el
robot conozca su posición en el mapa es esencial para lograr la autonomía móvil.
4.5.1 Calibración de sensores
Para un correcto seguimiento del movimiento del robot se debe hacer una
calibración de su odómetro y su giroscopio, para corregir el error que puedan cometer.
Para ello colocaremos el robot frente a una pared recta, con al menos 2 metros de
superficie libre, separado unos 30 centímetros de ella, como se muestra en la Fig. 4.6.
FIG. 4.6 COLOCACIÓN TURTLEBOT PARA CALIBRACIÓN
Para ejecutar el programa de calibración simplemente se debe ejecutar el siguiente
comando en un terminal del PC robot:
roslaunch turtlebot_calibration calibrate.launch
Finalizado el proceso de calibración aparecerán los valores de corrección de escala
de los parámetros:
turtlebot_node/gyro_scale_correction
turtlebot_node/odom_angular_scale_correction
[INFO] [WallTime: 1299286750.821002] Multiply the
'turtlebot_node/gyro_scale_correction' parameter with VALOR_CALIBRACION
[INFO] [WallTime: 1299286750.822427] Multiply the
'turtlebot_node/odom_angular_scale_correction' parameter with VALOR_CALIBRACION
El nuevo valor a aplicar a los parámetros será el resultado de multiplicar el valor
antiguo, por defecto 1, por el valor obtenido en la calibración. Para aplicar este nuevo
valor a los parámetros de forma permanente se debe editar el archivo
32
"turtlebot.launch", situado en la ruta /etc/ros/electric, tal como se muestra a
continuación:
turtlebot.launch
<launch>
<!-- sample file, copy this to /etc/ros/electric/turtlebot.launch -->
<param name="turtlebot_node/gyro_scale_correction"
value="VALOR_ANTIGUO_x_VALOR_CALIBRACION"/>
<param name="turtlebot_node/odom_angular_scale_correction"
value="VALOR_ANTIGUO_x_VALOR_CALIBRACION"/>
<include file="$(find turtlebot_bringup)/minimal.launch">
<arg name="urdf_file" value="$(find xacro)/xacro.py '$(find
turtlebot_description)/urdf/turtlebot.urdf.xacro'" />
</include>
</launch>
Nota: El parámetro gyro_measurement_range tiene por defecto un valor de 150, el
valor adecuado si el Turtlebot es de Willow Garage, pero debe ser 250 si es de
Clearpath y 300 si es de iHeartEngineering (en este caso el giroscopio tiene un rango
de medida de 300). Para esto será necesario añadir otra línea al archivo
"turtlebot.launch" para establecer el valor adecuado según el modelo.
<param name="turtlebot_node/gyro_measurement_range" value="SEGÚN_MODELO"/>
Para que el cambio de valores de los parámetros sea efectivo deberemos detener, y
poner en marcha de nuevo el servicio del Turtlebot, con los siguientes comandos:
sudo service turtlebot stop
sudo service turtlebot start
Nota: También se puede hacer una modificación dinámica de estos parámetros usando
un interfaz gráfico ejecutando el siguiente comando en un terminal:
rosrun dynamic_reconfigure reconfigure_gui
4.5.2 Creación del mapa
Para la creación del mapa se usará el stack proporcionado por ROS
"slam_gmapping", que contiene el package "gmapping" que implementa un método
para SLAM. El archivo "crear_mapa.launch", que se guardará en la carpeta "launch" de
nuestro package, tendrá el siguiente contenido:
33
crear_mapa.launch
<launch>
<include file="$(find turtlebot_bringup)/kinect.launch" />
<arg name="scan_topic" default="scan" />
<node pkg="gmapping" type="slam_gmapping" name="slam_gmapping" output="screen">
<param name="odom_frame" value="odom"/>
<param name="map_update_interval" value="3.0"/>
<param name="maxUrange" value="16.0"/>
<param name="sigma" value="0.05"/>
<param name="kernelSize" value="1"/>
<param name="lstep" value="0.05"/>
<param name="astep" value="0.05"/>
<param name="iterations" value="5"/>
<param name="lsigma" value="0.075"/>
<param name="ogain" value="3.0"/>
<param name="lskip" value="0"/>
<param name="srr" value="0.01"/>
<param name="srt" value="0.02"/>
<param name="str" value="0.01"/>
<param name="stt" value="0.02"/>
<param name="linearUpdate" value="0.5"/>
<param name="angularUpdate" value="0.436"/>
<param name="temporalUpdate" value="-1.0"/>
<param name="resampleThreshold" value="0.5"/>
<param name="particles" value="80"/>
<param name="xmin" value="-1.0"/>
<param name="ymin" value="-1.0"/>
<param name="xmax" value="1.0"/>
<param name="ymax" value="1.0"/>
<param name="delta" value="0.05"/>
<param name="llsamplerange" value="0.01"/>
<param name="llsamplestep" value="0.01"/>
<param name="lasamplerange" value="0.005"/>
<param name="lasamplestep" value="0.005"/>
<remap from="scan" to="$(arg scan_topic)"/>
</node>
<node pkg="move_base" type="move_base" respawn="false" name="move_base" output="screen">
<rosparam file="$(find turtlebot_fer)/config/costmap_common_params.yaml"
command="load" ns="global_costmap" />
<rosparam file="$(find turtlebot_fer)/config/costmap_common_params.yaml"
command="load" ns="local_costmap" />
<rosparam file="$(find turtlebot_fer)/config/local_costmap_params.yaml" command="load"
/>
<rosparam file="$(find turtlebot_fer)/config/global_costmap_params.yaml"
command="load" />
<rosparam file="$(find turtlebot_fer)/config/base_local_planner_params.yaml"
command="load" />
</node>
</launch>
Nota: los archivos de configuración del package "move_base" se han obtenido del
package "turtlebot_navigation", carpeta config, y se han situado en nuestro package
en una carpeta llamada, igualmente, "config".
Para ejecutar "crear_mapa.launch", que inicia la Kinect, "slam_gmaping" y
"move_base", se debe introducir el siguiente comando en un terminal del PC robot:
roslaunch NOMBRE_PACKAGE crear_mapa.launch
34
Para el desplazamiento del Turtlebot a través del espacio a mapear se empleará el
teleoperador por teclado, ejecutando en un terminal del PC robot el siguiente
comando:
roslaunch turtlebot_teleop keyboard_teleop.launch
Nota: Para la correcta realización del mapa es necesario dar varias pasadas por el
espacio a mapear, saliendo de un punto de partida y regresando a él para cerrar el
bucle.
Para poder visualizar el proceso de creación del mapa, en un terminal del PC
estación de trabajo se ejecutará el siguiente comando, que lanza el entorno de
visualización "rviz":
rosrun rviz rviz -d `rospack find turtlebot_navigation`/nav_rviz.vcg
El resultado obtenido después de varias pasadas por el entorno a mapear es el que
se muestra en la Fig. 4.7.
FIG. 4.7 MAPA 2D DE OCUPACIÓN DE REJILLA DEL LABORATORIO F6
35
Se creará una carpeta llamada "mapas" dentro de nuestro package, donde se guardará
el mapa con el nombre "labf6" introduciendo el siguiente comando en un terminal del
PC robot:
rosrun map_server map_saver -f /RUTA_PACKAGE/mapas/labf6
4.5.3 Navegación por el entorno mapeado
Con el mapa ya creado, para que el robot se desplace por él se hará uso del stack
proporcionado por ROS "navigation", que contiene los packages "map_server", "amcl"
(adaptive Monte Carlo localization) y “move_base”. Cada uno de ellos,
respectivamente, carga el mapa creado, ejecuta el método probabilístico de
localización adaptativa Monte Carlo y planifica la ruta para ir del origen al destino
dentro del mapa evitando los obstáculos.
El package “move_base” se encarga de la planificación de rutas, navegación global,
y evitación de obstáculos, navegación local. En la Fig. 4.8 se muestra el diagrama de
bloques de la estructura de este package.
FIG. 4.8 ESTRUCTURA DEL PACKAGE MOVE_BASE
Cuando el robot se encuentra atascado el procedimiento, por defecto, que sigue
“move_base” para intentar recuperarlo es el que se muestra en la Fig. 4.9. Pudiendo
ser modificado este comportamiento en el parámetro “recovery_behaviors”, por otro
de los disponibles.
36
FIG. 4.9 COMPORTAMIENTO RECUPERACIÓN MOVE_BASE
Se creará, en la carpeta "launch" de nuestro package, el archivo
"usar_mapa.launch" con el siguiente contenido:
usar_mapa.launch
<launch>
<include file="$(find turtlebot_bringup)/kinect.launch" />
<arg name="map_file" default="$(find turtlebot_fer)/mapas/labf6.yaml"/>
<node name="map_server" pkg="map_server" type="map_server" args="$(arg map_file)" />
<arg name="use_map_topic" default="false"/>
<arg name="scan_topic" default="scan" />
<node pkg="amcl" type="amcl" name="amcl">
<param name="use_map_topic" value="$(arg use_map_topic)"/>
<!-- Publish scans from best pose at a max of 10 Hz -->
<param name="odom_model_type" value="diff"/>
<param name="odom_alpha5" value="0.1"/>
<param name="gui_publish_rate" value="10.0"/>
<param name="laser_max_beams" value="60"/>
<param name="laser_max_range" value="12.0"/>
<param name="min_particles" value="500"/>
<param name="max_particles" value="2000"/>
<param name="kld_err" value="0.05"/>
<param name="kld_z" value="0.99"/>
<param name="odom_alpha1" value="0.2"/>
<param name="odom_alpha2" value="0.2"/>
<!-- translation std dev, m -->
<param name="odom_alpha3" value="0.2"/>
<param name="odom_alpha4" value="0.2"/>
<param name="laser_z_hit" value="0.5"/>
<param name="laser_z_short" value="0.05"/>
<param name="laser_z_max" value="0.05"/>
<param name="laser_z_rand" value="0.5"/>
<param name="laser_sigma_hit" value="0.2"/>
<param name="laser_lambda_short" value="0.1"/>
<param name="laser_model_type" value="likelihood_field"/>
<!-- <param name="laser_model_type" value="beam"/> -->
<param name="laser_likelihood_max_dist" value="2.0"/>
<param name="update_min_d" value="0.25"/>
<param name="update_min_a" value="0.2"/>
<param name="odom_frame_id" value="odom"/>
<param name="resample_interval" value="1"/>
<!-- Increase tolerance because the computer can get quite busy -->
<param name="transform_tolerance" value="1.0"/>
<param name="recovery_alpha_slow" value="0.0"/>
<param name="recovery_alpha_fast" value="0.0"/>
<remap from="scan" to="$(arg scan_topic)"/>
</node>
<node pkg="move_base" type="move_base" respawn="false" name="move_base" output="screen">
<rosparam file="$(find turtlebot_fer)/config/costmap_common_params.yaml"
command="load" ns="global_costmap" />
<rosparam file="$(find turtlebot_fer)/config/costmap_common_params.yaml"
37
command="load" ns="local_costmap" />
<rosparam file="$(find turtlebot_fer)/config/local_costmap_params.yaml" command="load"
/>
<rosparam file="$(find turtlebot_fer)/config/global_costmap_params.yaml"
command="load" />
<rosparam file="$(find turtlebot_fer)/config/base_local_planner_params.yaml"
command="load" />
</node>
</launch>
Para ejecutar "usar_mapa.launch", que inicia la Kinect, "map_server", "amcl" y
"move_base", se debe introducir el siguiente comando en un terminal del PC robot:
Roslaunch NOMBRE_PACKAGE usar_mapa.launch
map_file:=/RUTA_PACKAGE/mapas/labf6.yaml
Para interactuar con el robot se debe iniciar el entrono de visualización "rviz",
ejecutando el siguiente comando en un terminal del PC estación de trabajo:
rosrun rviz rviz -d `rospack find turtlebot_navigation`/nav_rviz.vcg
Primero se deberá indicar la posición y orientación aproximada del robot dentro del
mapa, pulsando en el botón "2D Pose Estimate" y posteriormente pulsando sobre el
mapa en la posición estimada, sin soltar el botón del ratón indicar la orientación
estimada y soltar. El modelo del robot se situará ahora en esta posición, rodeado por
una nube de puntos en color rojo como se muestra en la Fig. 4.10.
FIG. 4.10 INDICACIÓN INICIAL POSICIÓN ESTIMADA
38
Para indicar el punto de destino dentro del mapa, pulsando "2D Nav Goal" y
posteriormente pulsando sobre el mapa en la posición de destino, sin soltar el botón
del ratón se indicara la orientación final. En este momento el robot comenzará a
moverse siguiendo la trayectoria calculada, línea de color verde, hasta alcanzar el
punto de destino, como se muestra en la Fig. 4.11.
FIG. 4.11 TRAYECTORIA SEGUIDA HASTA EL DESTINO
Nota: Para poder probar la navegación autónoma en el simulador es necesario añadir
la siguiente línea de código al archivo "robot.launch", situado en la ruta
opt/ros/electric/stacks/turtlebot_simulator/turtlebot_gazebo/launch:
<param name="output_frame" value="odom"/>
Esta línea deberá añadirse en la ejecución del node "robot_pose_ekf". Quedando el
archivo "robot.launch" con el siguiente contenido:
robot.launch
<launch>
<param name="robot_description" command="$(find xacro)/xacro.py '$(find
turtlebot_description)/urdf/turtlebot.urdf.xacro'" />
<node name="spawn_turtlebot_model" pkg="gazebo" type="spawn_model" args="$(optenv
ROBOT_INITIAL_POSE) -unpause -urdf -param robot_description -model turtlebot" respawn="false"
output="screen"/>
<node pkg="diagnostic_aggregator" type="aggregator_node" name="diagnostic_aggregator" >
<rosparam command="load" file="$(find turtlebot_bringup)/config/diagnostics.yaml" />
39
</node>
<node pkg="robot_state_publisher" type="state_publisher" name="robot_state_publisher"
output="screen">
<param name="publish_frequency" type="double" value="30.0" />
</node>
<!-- The odometry estimator -->
<node pkg="robot_pose_ekf" type="robot_pose_ekf" name="robot_pose_ekf">
<param name="freq" value="30.0"/>
<param name="sensor_timeout" value="1.0"/>
<param name="publish_tf" value="true"/>
<param name="odom_used" value="true"/>
<param name="imu_used" value="false"/>
<param name="vo_used" value="false"/>
<param name="output_frame" value="odom"/> <!-- NUEVA LINEA -->
</node>
<!-- throttling -->
<node pkg="nodelet" type="nodelet" name="pointcloud_throttle" args="load
pointcloud_to_laserscan/CloudThrottle openni_manager" respawn="true">
<param name="max_rate" value="20.0"/>
<remap from="cloud_in" to="/camera/depth/points"/>
<remap from="cloud_out" to="cloud_throttled"/>
</node>
<!-- Fake Laser -->
<node pkg="nodelet" type="nodelet" name="kinect_laser" args="load
pointcloud_to_laserscan/CloudToScan openni_manager" respawn="true">
<param name="output_frame_id" value="/camera_depth_frame"/>
<!-- heights are in the (optical?) frame of the kinect -->
<param name="min_height" value="-0.15"/>
<param name="max_height" value="0.15"/>
<remap from="cloud" to="/cloud_throttled"/>
</node>
<!-- Fake Laser (narrow one, for localization -->
<node pkg="nodelet" type="nodelet" name="kinect_laser_narrow" args="load
pointcloud_to_laserscan/CloudToScan openni_manager" respawn="true">
<param name="output_frame_id" value="/camera_depth_frame"/>
<!-- heights are in the (optical?) frame of the kinect -->
<param name="min_height" value="-0.025"/>
<param name="max_height" value="0.025"/>
<remap from="cloud" to="/cloud_throttled"/>
<remap from="scan" to="/narrow_scan"/>
</node>
</launch>
5 Discusión del resultado
El objetivo inicialmente planteado, la navegación autónoma del robot Turtlebot por
un entorno de trabajo empleando ROS, se ha conseguido de forma satisfactoria. Se ha
notado la gran influencia del error cometido por los sensores de medición de
desplazamiento del robot, odómetro y giroscopio, en la estimación del movimiento
dentro del entorno de trabajo, ya que un pequeño error acumulado causa gran
distorsión en la posición real. Los mecanismos de compensación de errores de los
métodos empleados en la construcción del mapa (GMapping) y en la localización
(AMCL), consiguen reducir el error de localización a unos valores tolerables.
40
Se ha realizado la experiencia de incluir un obstáculo no mapeado en el recorrido
del robot. Se han observando diferentes comportamientos en la realización del mismo
recorrido sin modificar la posición del obstáculo, debido a la estimación de la posición
del robot. La aparición de un obstáculo en la lectura del sensor puede provocar una
estimación errónea de posición, que en el peor de los casos implica el atascamiento
del robot y la ejecución de los procedimientos de recuperación. Esto mismo sucede en
un entorno de trabajo en el que pueda haber modificaciones frecuentes de posiciones
de obstáculos, entornos dinámicos. Por lo que el método empleado, AMCL, tiene la
capacidad de adaptarse a entornos dinámicos. Pero como anteriormente se ha
señalado se trata de un método de localización local, por lo que no soporta el
secuestro.
También se ha probado la navegación con personas dentro del entrono de trabajo.
Cuando estas se mantienen estáticas el comportamiento es similar a cuando se
encuentra otro tipo de obstáculos no mapeados, pero cuando estas se encuentran en
movimiento las reacciones del robot son lentas e imprecisas, pudiendo provocar la
colisión con las personas. Por lo que este método de navegación autónoma no está
adaptado a la interacción con personas.
Además se ha desarrollo un programa de control para el robot que hace el
seguimiento de objetos de una tonalidad, en concreto para su prueba se han usado
tonalidades rojas, aunque podría configurarse para otras. Este programa podría
englobarse en navegación autónoma, ya que presenta un comportamiento de
seguimiento de un objetivo. La iluminación del entorno debe ser uniforme y sin zonas
de sombra para un correcto funcionamiento. Además se debe hacer una calibración
previa de los umbrales de color, para adaptarlos a la iluminación del entorno. También
debe ajustarse el tamaño del objeto a seguir, modificando el porcentaje máximo,
medio y mínimo de píxeles en la imagen. El ajuste de la velocidad de respuesta a
valores elevados provoca la oscilación en torno al punto de equilibrio, por lo que
deberá ajustarse al valor deseado de respuesta.
Los otros dos programas desarrollados, son didácticos, su utilidad es básicamente
inexistente. El primero, simplemente, hace que el robot se desplace describiendo un
41
círculo y el segundo emula el comportamiento de un juguete móvil, se desplaza en
línea recta hasta que impacta con un obstáculo, momento en el que hace un pequeño
retroceso seguido de un giro de magnitud y sentido aleatorios.
La experiencia con el entorno de desarrollo ROS ha sido bastante satisfactoria,
dadas sus grandes posibilidades para el diseño de programas de control de robots.
Destacar además la rápida adaptación al entorno por parte del usuario, incluso si no
cuenta con experiencia previa en programación de robots, simplemente exige de
conocimientos previos de programación en lenguaje c++ o python.
6 Conclusiones y trabajos futuros
El gran problema que muestra la navegación autónoma es la localización del robot
dentro del entrono de trabajo, que con los método empleados, GMapping y AMCL,
está en esencia solventado. Pero otro problema que se observa es la aparición de
nuevos obstáculos dentro del entrono ya mapeado, sobre todo obstáculos móviles
como personas y animales, ya que la adaptación de la trayectoria es bastante lenta e
imprecisa. Además la navegación empleando los métodos citados se limita a entornos
cerrados.
Este trabajo se ha basado en la navegación empleando un mapa de rejilla de
ocupación del entorno en 2D. Una opción de futuro podría ser la creación de mapas 3D
del entorno, que proporcionaran datos más precisos del entorno, que seguramente
reduzca la incertidumbre en la localización, mejore la planificación de rutas y la
evitación de obstáculos no incluidos en el mapa, pero también incremente las
necesidades computacionales.
7 Bibliografía
1. iRobot. Roomba. , 2012 Available from:http://www.irobot.com/es/roomba_range.aspx.
2. Willow Garage. ROS. , 2012 Available from:http://www.ros.org/wiki/.
3. Willow Garage. Willow Garage. , 2012 Available from:http://www.willowgarage.com/.
42
4. SIMMONS, R. and KOENIG, S. Probabilistic Robot Navigation in Partially Observable Environments. LAWRENCE ERLBAUM ASSOCIATES LTD, 1995.
5. THRUN, S., BURGARD, W. and FOX, D. Probabilistic Robotics. MIT Press, 2005.
6. THRUN, S. Monte Carlo Pomdps. Advances in Neural Information Processing Systems, 2000, vol. 12. pp. 1064-1070.
7. FOX, D. Adapting the Sample Size in Particle Filters through KLD-Sampling. The International Journal of Robotics Research, 2003, vol. 22, no. 12. pp. 985.
8. G. GRISETTI, C. STACHNISS and W. BURGARD. GMapping. , 2006 Available from:http://openslam.org/.
9. Gazebo. Gazebo. , 2012 Available from:http://gazebosim.org/.
10. Willow Garage. Turtlebot. , 2012 Available from:http://turtlebot.com/.
11. F. CASADO GARCÍA. Fernando-TFM-ROS02. , 2012 Available from:http://robotica.unileon.es/mediawiki/index.php/Fernando-TFM-ROS02.
43
Anexo A. Comandos más empleados de ROS
Comando Descripción Uso
Comandos del sistema de archivos rospack/rosstack Herramienta de inspección de
packages/stacks
rospack find [package]
roscd Cambia directorios a un package o stack roscd [package[/subdir]]
rosls Lista el contenido de un package o stack rosls [package[/subdir]]
roscreate-pkg Crea un nuevo package ROS roscreate-pkg [nombre package]
roscreate-stack Crea un nuevo stack ROS roscreate-stack [nombre stack]
rosdep Instala las dependencias de los packages ROS
rosmake [package]
rosmake Compila un package ROS rosdep install [package]
roswtf Muestra errores y avisos de un sistema ROS en marcha o un archivo .launch
roswtf o roswtf [archivo]
rxdeps Muestra la estructura de un package y dependencias
rxdeps [opciones]
Comandos habituales roscore Ejecuta los nodes master, parameter
server y rosout, necesarios para la comunicación entre nodos
roscore
rosmsg/rossrv
rosmsg show Muestra los campos en el mensaje rosmsg show [tipo mensaje]
rosmsg users Busca archivos que usan el mensaje rosmsg users [tipo mensaje]
rosmsg md5 Muestra el md5sum del mensaje rosmsg md5 [tipo mensaje]
rosmsg package Lista todos los mensajes en un package rosmsg package [package]
rosmsg packages Lista todos los packages con mensajes rosmsg packages
rosrun Inicia un ejecutable de un package rosrun [package] [executable]
rosnode
rosnode ping Prueba la conexión a un node rosnode ping [node]
rosnode list Lista los nodes activos rosnode list
rosnode info Muestra información sobre un node rosnode info [node]
rosnode machine Lista los nodes activos en una máquina rosnode machine [máquina]
rosnode kill Detiene un node activo rosnode kill [node]
roslaunch Ejecuta un archivo .launch roslaunch [package] [archivo]
rostopic
rostopic bw Muestra el ancho de banda usado por el topic
rostopic bw [topic]
rostopic echo Muestra los mensajes del topic en pantalla rostopic echo [topic]
rostopic hz Muestra la velocidad de publicación del topic
rostopic hz [topic]
rostopic list Lista los topics activos rostopic list
rostopic pub Publica datos en un topic rostopic pub [velocidad]
[nombre topic] [tipo mensaje]
[datos]
rostopic type Muestra el tipo de topic rostopic type [topic]
rostopic find Encuentra topics por tipo rostopic find [tipo mensaje]
rosparam
rosparam set Modificar valor de un parámetro rosparam set [parámetro]
[valor]
rosparam get Obtener valor de un parámetro rosparam get [parámetro]
rosparam load Cargar parámetros de un archivo YAML rosparam load [archivo]
rosparam dump Guardar parámetros en un archivo YAML rosparam dump [archivo]
rosparam delete Borrar un parámetro rosparam delete [parámetro]
rosparam list Listar todos los parámetros rosparam list
rosservice
44
Comando Descripción Uso rosservice list Lista los servicios activos rosservice list
rosservice node Muestra el nodo que dan un servicio rosservice node [servicio]
rosservice call Llama al servicio con los argumentos dados
rosservice call [servicio]
[argumentos]
rosservice args Lista los argumentos del servicio rosservice args [servicio]
rosservice type Muestra el tipo de servicio rosservice type [servicio]
rosservice uri Muestra el servicio ROSRPC uri rosservice uri [servicio]
rosservice find Encuentra servicios por tipo rosservice find [tipo servicio]
Comandos de registro rosbag
rosbag record Guarda el contenido de uno o todos los topics
rosbag record [topic] o -a
rosbag play Reproduce el contenido de un archivo .bag
rosbag play [archivo]
Comandos gráficos rxgraph Muestra un grafico con los nodes activos y
los topics que los conectan
rxgraph
rxplot Muestra los datos de uno o mas campos de los topics gráficamente
rxplot [topic/campo1:campo2]
rxbag Herramienta para visualización, inspección y reproducción de archivos .bag
rxbag [archivo]
rxconsole Herramienta para visualización y filtrado de mensajes publicados en rosout
rxconsole
Comandos transformaciones frames tf_echo Muestra la información de transformación
entre un frame origen y un frame destino
rosrun tf tf_echo [frame
origen] [frame destino]
view_frames Herramienta de generación del árbol completo de transformaciones coordinadas, en un archivo .pdf
rosrun tf view_frames