Tutorial: Player/Stage/Gazebo
De Asociación de Robotica y Domótica de España (A.R.D.E.)
Tabla de contenidos |
Introducción a Player/Stage/Gazebo
¿Para qué un simulador?
La robótica es un campo que genera un gran interés, sin embargo, la inversión que hay que hacer para acceder al hardware resulta prohibitivo en ocasiones. La simulación por ordenador es una alternativa válida y de bajo coste para los que consideran el esfuerzo económico un impedimento. No sólo eso, a pesar de que el coste sea un motivo más que suficiente para interesarse por la simulación por ordenador, hay razones adicionales que motivan a interesarse por esta:
- Movilidad: Surge la posibilidad de estar sentado bajo un árbol mientras se desarrolla el software de control de un grupo de 10 robots autónomos que se mueven por una planta de doscientos metros cuadrados.
- Adaptabilidad: Las modificaciones aplicadas al robot o a su entorno tampoco implican coste alguno.
- Gestión de recursos: Un simulador, usado junto con una capa de abstracción al hardware, permite desarrollar software para un robot que existe pero al que no se tiene acceso en un determinado momento. Esto es especialmente útil cuando hay varios desarrolladores y un único robot.
- Prototipado: Mediante la simulación, es posible implementar el software de un robot antes de que éste haya sido construido. Esto es útil para realizar cualquier tipo de prueba antes de que el robot se construya.
- Reusabilidad: Dado que el uso de simuladores suele ir de la mano de algún tipo de capa de abstracción, el código generado puede ser compartido con otras personas.
- Control del tiempo: Algunos simuladores permiten parar, o acelerar el tiempo (positiva o negativamente) de la simulación. Esto puede ser útil para inspeccionar el estado de los robots en cierto momento o para hacer pruebas de durabilidad.
El texto cubrirá los requisitos instalacion y uso de dos simuladores (Stage y Gazebo), y de la capa de abstracción Player (quizás también alguna otra como Orca o RoboComp).
¿Stage o Gazebo?
Stage es la opción apropiada para la mayoría de los usuarios y debería ser la elegida por defecto a no ser que se necesite:
- física realista 3D.
- aplicar algoritmos de visión por ordenador.
- implementar hardware complejo.
Stage es un simulador 2D relativamente sencillo que puede funcionar en cualquier ordenador moderno, pero a la vez es potente y cubre las necesidades de la mayoría de los usuarios que no necesitan simular cámaras. Muchas veces se usa para simular grupos relativamente grandes de robots simultaneamente. Gazebo es un simulador 3D menos maduro que Stage, sin embargo es más realista y completo. Debido a la gran cantidad de mejoras añadidas en la última versión de Gazebo, es la versión que usaremos en el tutorial a pesar de estar en fase beta.
Requisitos de instalación
Stage es muy ligero y no requiere hardware especial, cualquier ordenador de principios de siglo valdrá. Sin embargo, Gazebo, debido a su condición de simulador 3D con física realista, es mucho más exigente. Es necesario contar con aceleración gráfica 3D para que funcione correctamente. En cuanto al sistema operativo, Stage y Gazebo están diseñados para ser usados en sistemas Unix (particularmente GNU/Linux, pero tanto Stage como Gazebo funcionan también en Mac OS). A pesar de ello, varios usuarios de Stage han conseguido ponerlo en marcha en Windows. En este tutorial supondremos que estamos usando la distribución GNU/Linux Ubuntu Intrepid (aunque la mayoría de lo aquí expuesto pueda ser aplicado sin problemas a cualquier otra distribución basada en Debian).
Capas de abstracción
El concepto de capa de abstracción es ampliamente usado en muchos campos, no sólo en la robótica o la informática, sino en todos los campos del conocimiento. Es un recurso que consiste en describir un fenómeno, teoría, o sistema, mediante una representación que evite entrar en detalles. En el contexto en el que nos encontramos, además del uso común (facilitar la tarea de comprension a los humanos), también se usa para facilitar la tarea a los programas. Se lleva usando mucho tiempo en los sistemas operativos de los ordenadores. Veamos un ejemplo en el ámbito de los sistemas operativos, cuando se pretende que algún subsistema del sistema operativo funcione bien usando diferentes componentes hardware. ¿Qué pasaría si el subsistema se tuviese que adaptarse a todo el hardware disponibe? Lo que pasaría es que el sistema se tendría que adaptar a todas las peculiaridades para ser compatible. Esta situación es la más común en el desarrollo de software de control para robots: suele estar hecho a medida para el robot en el que funciona.
A pesar de que esta sea la opción más común, no significa ni que sea la mejor, ni que no se pueda evitar. De hecho, la situación comienza a cambiar. La opción opuesta es usar una capa de abstracción de hardware. Así, el software no se hace compatible con todo el hardware, sino con un hardware genérico virtual (inexistente por regla general) y por cada hardware real se crea un adaptador al genérico. El software relativo a ese hardware genérico es lo que se denomina capa de abstracción.
Stage
Como se introdujo, Stage es un simulador 2D relativamente sencillo que puede funcionar en cualquier ordenador moderno, pero que a la vez es potente y cubre las necesidades de la mayoría de los usuarios que no necesitan simular cámaras. Su principal limitación es que al ser 2D no simula cámaras, por lo que quien quiera que su robot vea deberá usar Gazebo. Sin embargo, su limitación de 2D permite también que este simulador pueda funcionar en casi cualquier máquina. Es recomendable, siempre que no sea totamente obligatorio el uso de cámaras, comenzar con Stage y hacer que el robot base su comportamiento en las lecturas del laser y posteriormente pasar a Gazebo sólo cuando estemos seguros de que necesitamos algo más (dado que muy comúnmente no suele hacer falta más). Gracias a sus bajos requisitos de hardware, muchas veces se usa Stage para simular grupos relativamente grandes de robots simultaneamente. Generalmente los robots en Stage se programan mediante el interfaz de Player.
Enlace a un video: aquí.
Instalación
La instalación de Stage y de Player se puede automatizar gracias al sistema de empaquetado de Ubuntu. Para instalarlo sólo es necesario instalar los paquetes stage, robot-player, libplayercore2-dev y libplayerc2-dev, bien usando alguna herramientra gráfica de instalación de paquetes como adept, como por consola mediante el comando 'sudo aptitude install stage robot-player libplayercore2-dev libplayerc2-dev'. Para solventar un pequeño bug también deberemos bajar el siguiente rgb.txt y guardarlo en /usr/X11R6/lib/X11/rgb.txt.
Para comprobar que todo está bien ejecutamos lo siguiente: robot-player /usr/share/stage/worlds/simple.cfg. Si sale algo parecido a la imagen de abajo es que todo ha ido bien. Esto invoca a Player y éste, a su vez, a Stage. Quizás sea buen momento para hacerse familiar con el interfaz.
Programa de ejemplo
No hay forma más entretenida de aprender que con ejemplos. Por ello, el tutorial se basa en un ejemplo para explicar cómo usar la librería de acceso al simulador. Antes de pegar el código del ejemplo veamos primero la forma de compilarlo y usarlo. Para que el ejemplo funcione tenemos que tener Player/Stage funcionando, para esto llevaremos a cabo el mismo paso que se dió al final de la instalación para comprobar que la instalación es correcta:
robot-player /usr/share/stage/worlds/simple.cfg
Con esto habremos ejecutado el servidor de Player, que arranca automáticamente Stage.
Para compilar el ejemplo se ejecutará:
gcc -I/usr/include/player-2.0/ andaypara.c -lplayerc -o andaypara
Para ejecutarlo y ver el robot en funcinamiento hay que tener el simulador arrancado. Ejecutaremos:
./andaypara
Ambos comandos se han de ejecutar en el directorio donde se haya guardado el fichero de ejemplo. En la compilación se genera un fichero ejecutable llamado andaypara que es el que luego ejecutamos. Si se ejecuta y miramos la ventana de Stage se verá como el robot se mueve hasta estar cerca de chocar. Si se desea volver a probar una vez se haya parado el robot, se puede cerrar y arrancar Stage de nuevo o mover el robot con el ratón.
El código, que se debe guardar en un fichero llamado andaypara.c:
/*
* Fichero andaypara.c
* Descripcion: Primer ejemplo del tutorial
* Autor: Richard Vaughan, Luis J. Manso
* Licencia: GPL v2
*
*/
#include <stdio.h>
#include <string.h>
#include <libplayerc/playerc.h>
int main(int argc, const char **argv) {
// Declaramos las estructuras necesarias:
// - ''client'' es nuestro "proxy" a Player
// - ''position'' se puede ver como un interfaz de acceso a la base
// - ''laser'' se puede ver como un interfaz de acceso al laser
playerc_client_t *client;
playerc_position2d_t *position;
playerc_laser_t *laser;
// Conectamos al servidor de Player:
// - Normalmente Player se ejecuta en el mismo ordenador, 'localhost'
// - Normalmente Player se ejecuta en el puerto 6665
printf( "Conectando al servidor de Player...\n");
client = playerc_client_create(NULL, "localhost", 6665);
if (playerc_client_connect(client) != 0) return -1;
printf("Conectado.\n");
// Nos conectamos al laser
printf("Arrancando el laser...\n");
laser = playerc_laser_create(client, 0);
if (playerc_laser_subscribe(laser, PLAYER_OPEN_MODE)) return -1;
printf("Laser ok.\n");
// Nos conectamos a la base
printf("Arrancando la base...\n");
position = playerc_position2d_create(client, 0);
if (playerc_position2d_subscribe(position, PLAYER_OPEN_MODE)) return -1;
printf("Base ok.\n");
// Una vez está todo conectado ponemos el robot a moverse.
// Se usa así: playerc_position2d_set_cmd_vel(position, velocidad_avance, velocidad_lado, giro, activo)
printf("Puesta en marcha\n");
if (playerc_position2d_set_cmd_vel(position, 0.2, 0, 0, 1) != 0) return -1;
// Hacemos una primera lectura de los datos del robot.
playerc_client_read(client);
// Hasta que se vaya a chocar el robot sigue hacia alante.
// Comprobamos esto leyendo la muestra central de las laser->scan_count que tiene el laser
int libre=1;
while (libre) {
// Actualizamos los datos del robot
playerc_client_read(client);
// Si la lectura del laser del medio (scan_count/2) es menor de un metro es que nos vamos a chocar pronto.
if (laser->ranges[laser->scan_count/2] < 1.) {
printf("Paro. Distancia=%f.\n", laser->ranges[laser->scan_count/2]);
playerc_position2d_set_cmd_vel(position, 0, 0, 0, 1);
libre = 0;
} else {
printf("Distancia: %f\n", laser->ranges[laser->scan_count/2]);
}
printf("\nCoordenadas : %f %f %f\n", position->px, position->py, position->pa);
usleep(500000);
}
printf("Cerrando la base...\n");
playerc_position2d_unsubscribe(position);
playerc_position2d_destroy(position);
printf("Base cerrada.\n");
printf("Cerrando el laser...\n");
playerc_laser_unsubscribe(laser);
playerc_laser_destroy(laser);
printf("Laser cerrado");
printf("Desconectando de Player...\n");
playerc_client_disconnect(client);
playerc_client_destroy(client);
printf("Desconectado.");
return 0;
}
El ejemplo está hecho para Player 2.0.*. Si Player/Stage ha sido instalado desde el código fuente (en vez de por paquetes) y se ha elegido una versión de la rama 2.1.*, el código del ejemplo se tendrá que adaptar ligeramente para que compile.
Es evidente que el ejemplo no cubre todos los interfaces soportados por Player/Stage, sólo cubre la base y el laser. Para encontrar más información sobre el control de otros dispositivos es conveniente echar un vistazo a la documentación de la librería libplayerc (C). La librería libplayerc (la que usa el ejemplo) puede ser usada desde C y C++. Además de esta, se puede usar libplayerc++ (sólo para C++) o libplayerc_py (para Python).
Gazebo
Gazebo es un simulador 3D menos maduro que Stage, sin embargo es más realista y completo. Al ser un simulador 3D sí es posible simular cámaras. Además, derivado de lo mismo, no sólo simula terrenos planos, sino que se pueden simular todo tipo de terrenos 3D. Gazebo suele ser usado sin Player, pero es posible hacerlo de esta manera.
Instalación
La instalación de Gazebo es considerablemente más compleja que la de Stage o Player. Lo que hay a continuación es tan sólo un esbozo de lo que podría ser algo útil. De momento sólo cubre la instalación del simulador. Antes de ponerse manos a la obra hay que comprobar que el sistema tiene la aceleración gráfica activada. Una forma divertida de comprobarlo es así (si salen dibujitos es que está funcionando):
sudo aptitude install xmoto
xmoto
Con el fin de dar estructura al proceso de instalación, se ha dividido en varios pasos: "Preparación", "Descarga y compilación", "Instalación propiamente dicha" y "Comprobación".
Preparación
Gazebo no está disponible como paquete en Ubuntu, por ello hay que compilarlo a mano e instalarlo luego. Algunas de las librerías de software que requiere están disponibles como paquetes y otras no. En esta sección instalaremos las librerías requeridas y prepararemos algunos otros parámetros del sistema operativo.
Variables de entorno
Para empezar, hay que añadir las siguientes lineas al fichero ~/.bashrc, es decir, /home/USUARIO/.bashrc:
export PATH=/usr/local/bin:$PATH
export CPATH=/usr/local/include:$CPATH
export LIBRARY_PATH=/usr/local/lib:$LIBRARY_PATH
export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH
Paquetes precompilados
La mayoría de las librerías necesitadas por el simulador están disponibles como paquetes de software. Ejecutando lo siguiente quedarán instaladas:
sudo aptitude install subversion cmake libxml2-dev pkg-config build-essential
sudo aptitude install libzzip-dev libxt-dev libxaw7-dev libxxf86vm-dev libboost1.35-dev
sudo aptitude install libxrandr-dev libfreeimage-dev nvidia-cg-toolkit
sudo aptitude install libfreetype6-dev freeglut-dev libfltk1.1-dev wget
sudo aptitude install libavformat-dev libffmpegthumbnailer-dev libopenal-dev
ODE
Una de las dos librerías que necesita Gazebo es ODE, una librería de simulación de cuerpos rígidos (el corazón de Gazebo). Para instalara:
export CFLAGS=$CFLAGS -fPIC
export CXXFLAGS=$CXXFLAGS -fPIC
wget http://kent.dl.sourceforge.net/sourceforge/opende/ode-0.11.1.tar.bz2
tar xvjf ode-0.11.1.tar.bz2
cd ode-0.11.1
./configure
sudo make install
OGRE
La otra librería necesaria es Ogre, una librería gráfica basada en OpenGL necesaria para el interfaz. Para instalarla:
wget http://heanet.dl.sourceforge.net/sourceforge/ogre/ogre-v1-6-4.tar.bz2
tar xvjf ogre-v1-6-4.tar.bz2
cd ogre
./configure
make -j 2
suo make install
La llamada a 'make' está optimizada para ordenadores de dos núcleos, se debería sustituir el 2 por el número en concreto de núcleos que tenga el ordenador.
Descarga y compilación
Para descargar el software del repositorio ded subversion se ha de ejecutar el siguiente comando, que dejará un directorio llamado gazebo con el código fuente y algunos modelos predefinidos:
svn co https://playerstage.svn.sourceforge.net/svnroot/playerstage/code/gazebo/trunk gazebo
Para compilarlo:
export CFLAGS=$CFLAGS -fPIC
export CXXFLAGS=$CXXFLAGS -fPIC
cmake .
make
Si ocurre algún error debido a que no encuentra algún fichero llamado av*.h, hay que probarlo otra vez tras ejecutar lo siguiente:
sudo ln -s /usr/include/ffmpeg/ /usr/include/libavformat
sudo ln -s /usr/include/ffmpeg/ /usr/include/libavcodec
Instalación propiamente dicha
En función del sistema el siguiente comando dará un error. De ser así sólo hay que ejecutarlo otra vez:
sudo make install
Con lo siguiente habilitamos la ruta /usr/local/lib para las librerías (Gazebo dejará en esa ruta sus propias librerías). Es importante poner dos signos de mayor ('>>') en vez e uno ('>'):
sudo bash
echo /usr/local/lib >> /etc/ld.so.conf
ldconfig
exit
Comprobación
Para comprobar que la instalación ha sido satisfactoria hay que ejecutar el siguiente comando:
gazebo /usr/local/share/gazebo/worlds/stereocamera.world
La imagen que se ve a continuación es lo que se debería ver al ejecutar el comando. Esto es, la vista subjetiva desde la cámara del robot. Además de esta vista, se puede cambiar a otra general y moverse por el mundo usando el ratón, los cursores y las teclas de subir y bajar página.
Ejemplo
Pendiente.
Enlaces externos
Wiki Gazebo - Instalación (en)
