Documentos de Académico
Documentos de Profesional
Documentos de Cultura
DESARROLLO DE PROGRAMAS DE
CONTROL PARA EL ROBOT
TURTLEBOT SOBRE ROS (Robot
Operating System)
7 BIBLIOGRAFÍA ..........................................................................................................................41
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.
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.
6
3.1.2 Ejecución de programas
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.
3.2 Turtlebot
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.
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.
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.
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.
10
Ubuntu 10.10 (Maverick)
Se necesita añadir las llaves del repositorio para verificar que el software
descargado esta autorizado, ejecutando el siguiente comando en un terminal:
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:
Ahora ya se pueden ejecutar los comandos del entorno ROS en el terminal, los más
empleados se recogen en el anexo A.
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.
ifconfig
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
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)
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"
lsusb
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-->
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.
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:
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>
rosmake NOMBRE_PACKAGE
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:
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:
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 )
17
su sencillez. Los archivos de los programas creados se guardarán en la carpeta "src" del
package creado.
gira.cpp
ros::NodeHandle n;
geometry_msgs::Twist vel;
vel_pub_.publish(vel);
loop_rate.sleep();
}
return 0;
}
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
juguete_golpe.cpp
vel_pub_.publish(::vel);
}
else
{
ahora = ros::Time::now(); //Asignación del tiempo actual a la variable ahora
vel_pub_.publish(::vel);
loop_rate.sleep();
19
}
vel_pub_.publish(::vel);
loop_rate.sleep();
}
}
}
ros::NodeHandle n;
return 0;
}
rosbuild_add_executable(juguete_golpe src/juguete_golpe.cpp)
roscd NOMBRE_PACKAGE
make
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.
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
#endif /*__PARAM_SIGUE_ROJO_H*/
21
El código del programa, escrito en lenguaje c++, es el siguiente:
sigue_rojo.cpp
::region = ima;
uint up;
uint right;
uint down;
uint left;
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;
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;
::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];
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 (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::NodeHandle n;
23
//Suscripción del topic "camera/rgb/image_color"
return 0;
}
rosbuild_add_executable(sigue_rojo src/sigue_rojo.cpp)
roscd NOMBRE_PACKAGE
make
visulizacion.cpp
24
::region = ima;
uint up;
uint right;
uint down;
uint left;
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;
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;
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 + 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);
}
ros::NodeHandle n;
return 0;
}
26
rosbuild_add_executable(sigue_rojo src/sigue_rojo.cpp)
roscd NOMBRE_PACKAGE
make
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:
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
# 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:
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.
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.
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:
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.
turtlebot_node/gyro_scale_correction
turtlebot_node/odom_angular_scale_correction
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"/>
</launch>
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:
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:
32
crear_mapa.launch
<launch>
<include file="$(find turtlebot_bringup)/kinect.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".
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:
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.
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:
35
FIG. 4.9 COMPORTAMIENTO RECUPERACIÓN MOVE _BASE
usar_mapa.launch
<launch>
<include file="$(find turtlebot_bringup)/kinect.launch" />
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>
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.
robot.launch
<launch>
<param name="robot_description" command="$(find xacro)/xacro.py '$(find
turtlebot_description)/urdf/turtlebot.urdf.xacro'" />
38
</node>
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.
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.
7 Bibliografía
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.
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.
42
Anexo A. Comandos más empleados de ROS
Comando Descripción Uso
Comandos del sistema de archivos
rospack/rosstack Herramienta de inspección de rospack find [package]
packages/stacks
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 rosmake [package]
ROS
rosmake Compila un package ROS rosdep install [package]
roswtf Muestra errores y avisos de un sistema roswtf o roswtf [archivo]
ROS en marcha o un archivo .launch
rxdeps Muestra la estructura de un package y rxdeps [opciones]
dependencias
Comandos habituales
roscore Ejecuta los nodes master, parameter roscore
server y rosout, necesarios para la
comunicación entre nodos
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
43
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 rosservice call [servicio]
[argumentos]
dados
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 rosbag record [topic] o -a
topics
rosbag play Reproduce el contenido de un archivo rosbag play [archivo]
.bag
Comandos gráficos
rxgraph Muestra un grafico con los nodes activos y rxgraph
los topics que los conectan
rxplot Muestra los datos de uno o mas campos rxplot [topic/campo1:campo2]
de los topics gráficamente
rxbag Herramienta para visualización, inspección rxbag [archivo]
y reproducción de archivos .bag
rxconsole Herramienta para visualización y filtrado rxconsole
de mensajes publicados en rosout
Comandos transformaciones frames
tf_echo Muestra la información de transformación rosrun tf tf_echo [frame
origen] [frame destino]
entre un frame origen y un frame destino
view_frames Herramienta de generación del árbol rosrun tf view_frames
completo de transformaciones
coordinadas, en un archivo .pdf
44