DESARROLLO DE PROGRAMAS DE CONTROL PARA EL ROBOT

Transcripción

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
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
4
ROS ................................................................................................................................................. 6
METODOLOGÍA ................................................................................................................................... 9
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
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
3
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.
4
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.
5
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.
6
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.
7
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
8
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
9
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'
10
Ubuntu 10.10 (Maverick)
sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu maverick main" >

Ubuntu 11.04 (Natty)
sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu natty main" >

Ubuntu 11.10 (Oneiric)
sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu oneiric main" >
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
11
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
12
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
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
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:
Bus 002 Device 001:
Bus 003 Device 001:
Bus 004 Device 002:
Bus 004 Device 001:
Bus 005 Device 001:
Bus 005 Device 003:
FT232 USB-Serial (UART) IC
ID 1d6b:0002
ID 1d6b:0001
ID 1d6b:0001
ID 045e:0040
ID 1d6b:0001
ID 1d6b:0001
ID 0403:6001
<--ADAPTADOR
Linux Foundation 2.0 root hub
Microsoft Corp. Wheel Mouse Optical
Future Technology Devices International, Ltd
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.
13
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
14
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
15
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).
16
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
17
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);
topic "turtlebot_node/cmd_vel"
//Publicación del
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)
18
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 "geometry_msgs/Twist.h"
#include "turtlebot_node/TurtlebotSensorState.h"
//Librería "TurtlebotSensorState" del package
"turtlebot_node"
//Declaración de la variable global vel
double alea;
//Declaración de la variable global alea
void callback(const turtlebot_node::TurtlebotSensorState& sen)
dato recibido
{
ros::NodeHandle n;
//Función de llamada con cada
ros::Rate loop_rate(10);
ros::Time ahora;
//Publicación del
//Frecuencia de realización del bucle (10 Hz)
//Declaración de variable tipo tiempo, variable ROS
if (sen.bumps_wheeldrops == 0)
{
::vel.linear.x = 0.2;
::vel.angular.z = 0.0;
//Comprobación si ha habido señal del parachoques
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)))
retroceso después de choque
{
::vel.linear.x = -0.2;
::vel.angular.z = 0.0;
//Bucle durante 0,5 segundos,
loop_rate.sleep();
19
}
::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)))
giro de ángulo aleatorio
{
::vel.linear.x = 0.0;
::vel.angular.z = ::alea;
//Bucle durante 1,5 segundos,
loop_rate.sleep();
}
}
}
{
ros::init(argc, argv, "juguete_golpe");
//Creación del nodo "juguete_golpe"
ros::NodeHandle n;
//Publicación del
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)
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.
20
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.
120
[0]
Píxel 1
88
[1]
15
[2]
127
[3]
Píxel 2
89
[4]
11
[5]
…
Píxel 307200
240
150
66
[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
#define
#define
#define
#define
#define
li_red 100
//Límite inferior para canal rojo
ls_red 255
//Límite superior para canal rojo
li_green 0
//Límite inferior para canal verde
ls_green 30
//Límite superior para canal verde
li_blue 0
//Límite inferior para canal azul
ls_blue 50
//Límite superior para canal azul
#define tam_min 0.001
#define tam_max 0.05
#define tam_med 0.025
#define Px 0.08
#define Pz 1.2
#endif
//Porcentaje de píxeles de tonalidades rojas mínimo
//Porcentaje de píxeles de tonalidades rojas máximo
//Porcentaje de píxeles de tonalidades rojas medio
//Ganancia velocidad de avance-retroceso
//Ganancia velocidad de giro
/*__PARAM_SIGUE_ROJO_H*/
21
El código del programa, escrito en lenguaje c++, es el siguiente:
sigue_rojo.cpp
#include
#include
#include
#include
"ros/ros.h"
"sensor_msgs/Image.h"
//Librería "Image" del package "sensor_msgs"
"geometry_msgs/Twist.h"
"param_sigue_rojo.h"
//Parámetros de ajuste
sensor_msgs::Image region;
void callback(const sensor_msgs::Image& ima)
{
ros::NodeHandle n;
del topic "/cmd_vel"
uint
uint
uint
uint
uint
//Publicación
pix_r;
//Declaración de variables de almacenaje valores rgb de cada píxel
pix_g;
pix_b;
ancho = ima.step;
//Número de elementos de cada fila de la imagen
tam = ima.data.size();
//Número de elementos del array
double cont_izq = 0;
double cont_der = 0;
//Declaración e inicialización de contadores de píxeles
::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];
22
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;
}
}
}
}
for (uint i = 0; i < (tam - (ancho/2)); i = i + ancho)
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];
//Contar píxeles tonos rojos
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);
}
}
{
ros::init(argc, argv, "sigue_rojo");
//Creación del nodo "sigue_rojo"
ros::NodeHandle n;
del topic "cmd_vel"
//Publicación
ros::Subscriber image_sub_= n.subscribe("camera/rgb/image_color", 1, callback);
23
//Suscripción del topic "camera/rgb/image_color"
ros::spin();
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
archivo a compilar:
rosbuild_add_executable(sigue_rojo src/sigue_rojo.cpp)
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 "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
uint
uint
uint
uint
pix_r;
//Declaración de variables de almacenaje valores rgb de cada píxel
pix_g;
pix_b;
ancho = ima.step;
//Número de elementos de cada fila de la imagen
tam = ima.data.size();
//Número de elementos del array
24
::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))
{
}
else
//Conversión a escala de grises regiones pequeñas o píxeles
aislados
{
if (pix_r > pix_g)
{
::region.data[i +
::region.data[i +
::region.data[i +
}
else if (pix_g > pix_b)
{
::region.data[i +
j] = pix_r;
j + 1] = pix_r;
j + 2] = pix_r;
j] = pix_g;
25
::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 +
::region.data[i +
::region.data[i +
}
else if (pix_g > pix_b)
{
::region.data[i +
::region.data[i +
::region.data[i +
}
else
{
::region.data[i +
::region.data[i +
::region.data[i +
}
j] = pix_r;
j + 1] = pix_r;
j + 2] = pix_r;
j] = pix_g;
j + 1] = pix_g;
j + 2] = pix_g;
j] = pix_b;
j + 1] = pix_b;
j + 2] = pix_b;
}
}
}
for (uint i = (ancho/2)-3; i < tam; i = i + ancho)
{
for (uint j = 0; j < 6; j = j + 3)
{
}
}
//Línea negra divisoria central
rojo_pub_.publish(::region);
}
{
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();
return 0;
}
Se guardará con el nombre "visualizacion.cpp". Para compilarlo y generar el
archivo a compilar:
26
rosbuild_add_executable(sigue_rojo src/sigue_rojo.cpp)
compilará y creará el ejecutable:
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.
27
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.
28
FIG. 4.5 SIMULADOR GAZEBO CON EL MODELO DEL T URTLEBOT
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
29
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
30
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
31
"turtlebot.launch", situado en la ruta /etc/ros/electric, tal como se muestra a
continuación:
turtlebot.launch
<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:
32
crear_mapa.launch
<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
<param
<param
<param
<param
<param
<param
<param
<param
<remap
</node>
name="xmin"
name="ymin"
name="xmax"
name="ymax"
value="-1.0"/>
value="-1.0"/>
value="1.0"/>
value="1.0"/>
name="delta" value="0.05"/>
name="llsamplerange" value="0.01"/>
name="llsamplestep" value="0.01"/>
name="lasamplerange" value="0.005"/>
name="lasamplestep" value="0.005"/>
from="scan" to="$(arg scan_topic)"/>
<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" />
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
33
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
34
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.
35
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>
<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)"/>

<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="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_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"/>

<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">
command="load" ns="global_costmap" />
36
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
37
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" />
38
</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>

<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"/> 
</node>

<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>

<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"/>

<param name="min_height" value="-0.15"/>
<param name="max_height" value="0.15"/>
<remap from="cloud" to="/cloud_throttled"/>
</node>

<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"/>

<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.
39
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
40
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/.
41
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.
42
Anexo A.
Comando
Comandos más empleados de ROS
Descripción
Uso
Comandos del sistema de archivos
rospack/rosstack
roscd
rosls
roscreate-pkg
roscreate-stack
rosdep
rosmake
roswtf
rxdeps
Herramienta
de
inspección
de
packages/stacks
Cambia directorios a un package o stack
Lista el contenido de un package o stack
Crea un nuevo package ROS
Crea un nuevo stack ROS
Instala las dependencias de los packages
ROS
Compila un package ROS
Muestra errores y avisos de un sistema
ROS en marcha o un archivo .launch
Muestra la estructura de un package y
dependencias
rospack find [package]
roscd [package[/subdir]]
rosls [package[/subdir]]
roscreate-pkg [nombre package]
roscreate-stack [nombre stack]
rosmake [package]
rosdep install [package]
roswtf o roswtf [archivo]
rxdeps [opciones]
Comandos habituales
roscore
Ejecuta los nodes master, parameter
server y rosout, necesarios para la
comunicación entre nodos
roscore
rosmsg show [tipo mensaje]
rosmsg packages
Muestra los campos en el mensaje
Busca archivos que usan el mensaje
Muestra el md5sum del mensaje
Lista todos los mensajes en un package
Lista todos los packages con mensajes
rosrun
Inicia un ejecutable de un package
rosrun [package] [executable]
Prueba la conexión a un node
Lista los nodes activos
Muestra información sobre un node
Lista los nodes activos en una máquina
Detiene un node activo
Ejecuta un archivo .launch
rosnode ping [node]
Muestra el ancho de banda usado por el
topic
Muestra los mensajes del topic en pantalla
Muestra la velocidad de publicación del
topic
Lista los topics activos
Publica datos en un topic
rostopic bw [topic]
rosmsg/rossrv
rosmsg show
rosmsg users
rosmsg md5
rosmsg package
rosnode
rosnode ping
rosnode list
rosnode info
rosnode machine
rosnode kill
roslaunch
rostopic
rostopic bw
rostopic echo
rostopic hz
rostopic list
rostopic pub
rostopic type
rostopic find
Muestra el tipo de topic
Encuentra topics por tipo
rosparam
rosparam set
Modificar valor de un parámetro
rosparam get
rosparam load
rosparam dump
rosparam delete
rosparam list
Obtener valor de un parámetro
Cargar parámetros de un archivo YAML
Guardar parámetros en un archivo YAML
Borrar un parámetro
Listar todos los parámetros
rosmsg users [tipo mensaje]
rosmsg md5 [tipo mensaje]
rosmsg package [package]
rosmsg packages
rosnode list
rosnode info [node]
rosnode machine [máquina]
rosnode kill [node]
roslaunch [package] [archivo]
rostopic echo [topic]
rostopic hz [topic]
rostopic list
rostopic
pub
[velocidad]
[nombre topic] [tipo mensaje]
[datos]
rostopic type [topic]
rostopic find [tipo mensaje]
rosparam
set
[parámetro]
[valor]
rosparam get [parámetro]
rosparam load [archivo]
rosparam dump [archivo]
rosparam delete [parámetro]
rosparam list
rosservice
43
Comando
rosservice list
rosservice node
rosservice call
rosservice args
rosservice type
rosservice uri
rosservice find
Descripción
Lista los servicios activos
Muestra el nodo que dan un servicio
Llama al servicio con los argumentos
dados
Lista los argumentos del servicio
Muestra el tipo de servicio
Muestra el servicio ROSRPC uri
Encuentra servicios por tipo
Uso
rosservice list
rosservice node [servicio]
rosservice
[argumentos]
call
[servicio]
rosservice args [servicio]
rosservice type [servicio]
rosservice uri [servicio]
rosservice find [tipo servicio]
Comandos de registro
rosbag
rosbag record
rosbag play
Guarda el contenido de uno o todos los
topics
Reproduce el contenido de un archivo
.bag
rosbag record [topic] o -a
rosbag play [archivo]
Comandos gráficos
rxgraph
rxplot
rxbag
rxconsole
Muestra un grafico con los nodes activos y
los topics que los conectan
Muestra los datos de uno o mas campos
de los topics gráficamente
Herramienta para visualización, inspección
y reproducción de archivos .bag
Herramienta para visualización y filtrado
de mensajes publicados en rosout
rxgraph
rxplot [topic/campo1:campo2]
rxbag [archivo]
rxconsole
Comandos transformaciones frames
tf_echo
view_frames
Muestra la información de transformación
entre un frame origen y un frame destino
Herramienta de generación del árbol
completo
de
transformaciones
coordinadas, en un archivo .pdf
rosrun
tf
tf_echo
origen] [frame destino]
[frame
rosrun tf view_frames
44

DESARROLLO DE PROGRAMAS DE CONTROL PARA EL ROBOT

Transcripción

Documentos relacionados

summit-x - Robotnik

¿Sabes que... hacer y qué no en un accidente?