%---------------------------------------------------------------------
%
%                          Capítulo 3 Gazebo  https://moodle2015-16.ua.es/moodle/mod/book/view.php?id=82546&chapterid=2401
%
%---------------------------------------------------------------------

\chapter{Gazebo}

\begin{FraseCelebre}
\begin{Frase}
La computacion es el principio, el ordenador es la herramienta
\end{Frase}
\begin{Fuente}
 Robert Denning
\end{Fuente}
\end{FraseCelebre}

\begin{resumen}
En este capitulo veremos el poderoso simulador Gazebo desde los componentes principales hasta algunos de los comandos mas útiles.
\end{resumen}


%-------------------------------------------------------------------
\section{Introducción a Gazebo}
\label{cap3:sec:introduccion-a-gazebo}
%-------------------------------------------------------------------
Gazebo es un simulador 3D multi-robot, con propiedades dinámicas y cinemáticas completas. La integración entre ROS y Gazebo es proporcionada por un conjunto de plugins de Gazebo que apoyan muchos robots y sensores existentes. Debido a que los plugins presentan la misma interfaz de mensaje que el resto del ecosistema ROS, se pueden escribir nodos ROS que son compatibles con la simulación, los datos registrados y el hardware de los robots.
%-------------------------------------------------------------------
\section{Componentes Principales}
\label{cap3:sec:componentes-principales}
%-------------------------------------------------------------------

%-------------------------------------------------------------------
\section{Ejecución}
\label{cap3:sec:ejecucion}
%-------------------------------------------------------------------
\figura{Bitmap/gazebo_turtlebot}{width=.6\textwidth}{fig:gazebo_turtlebot}%
	{Vista del mundo simulado por gazebo con un robot turtlebot}%
Gazebo puede ejecutarse como simulador stand-alone, pero nosotros lo usaremos conjuntamente con ROS para poder consultar desde los nodos que creemos la información de los sensores, así como para mandarles comandos de velocidad. Para lanzar el simulador primero tenemos que arrancar en un terminal el motor de ROS:
\begin{verbatim}
roscore
\end{verbatim}
En otra terminal lanzamos el siguiente comando:
\begin{verbatim}
roslaunch turtlebot_gazebo turtlebot_empty_world.launch
\end{verbatim}

roslaunch es una herramienta que sirve para lanzar varios nodos de ROS de un paquete de forma automática y con una configuración específica impuesta por un fichero XML con extensión .launch.//
Tras ejecutar el comando se abrirá la ventana de Gazebo con un robot cargado situado en el centro del mundo (figura~\ref{fig:gazebo_turtlebot})
%-------------------------------------------------------------------
\section{Utilidades}
\label{cap3:sec:utilidades}
%-------------------------------------------------------------------
Debido a que en esta sección se da a conocer las utilidades del simulador Gazebo tomaremos como ejemplo el uso del robot Turtlebot para facilitar el entendimiendo de las funcionalidades de gazebo junto a ROS.

%-------------------------------------------------------------------
\subsection{Control de cámara}
\label{cap3:ssec:control-camara}
%-------------------------------------------------------------------
El control del punto de vista de diseño es parecido al que muestran otros programas de diseño o simulación 3D:
\begin{itemize}
\item El botón izquierdo del ratón sirve para trasladar la cámara por el mundo
\item El botón derecho o la rueda del ratón sirve para hacer zoom en la escena
\item El botón central del ratón sirve para rotar la cámara
\end{itemize}

%-------------------------------------------------------------------
\subsection{Diseño de Mundos}
\label{cap3:ssec:diseño-mundos}
%-------------------------------------------------------------------
Gazebo permite diseñar elementos con herramientas CAD, dichas herramientas son muy limitadas, pero suficientes para crear mundos sencillos. Estas herramientas están situadas en la zona superior del programa y nos permite insertar cubos, esferas y cilindros, así como distintos puntos de luz.
Las otras tres herramientas sirven para seleccionar elementos, trasladarlos y rotarlos.
Los elementos que contiene el mundo se van listando en la parte izquierda del programa, bajo la pestaña "World" y si son seleccionados permiten la edición de algunas propiedades tales como la pose o el nombre.
%-------------------------------------------------------------------
\subsection{Visualización de Sensores}
\label{cap3:ssec:visualizacion-sensores}
%-------------------------------------------------------------------
\figura{Bitmap/rviz}{width=.6\textwidth}{fig:rviz}%
	{Visualizacion en Rviz de la obtencion de datos del robot Turtlebot}%
Por el hecho de tener ROS funcionando y haber usado roslaunch para lanzar el simulador, ya tenemos publicada la información que captan los sensores en la simulación. Para visualizarla usaremos otra herramienta de ROS llamada RViz, por lo que ejecutamos en otro terminal:
\begin{verbatim}
rosrun rviz rviz
\end{verbatim}
El comando lanza el programa pero aparentemente no muestra información alguna. Esto es porque aún no estamos suscritos a ningún tópico de los del robot. Antes de suscribirnos a un tópico, vamos a configurar el marco de referencia global del visualizador, que por defecto está en \verb|map|, y lo cambiamos a \verb|odometry|. El marco fijo hace referencia a respecto a qué se va a mostrar la información en el visualizador. Si elegimos la opción \verb|camera_link| la información se representará en base a la posición de la articulación de la cámara. Si elegimos la opción \verb|camera_depth_frame| la información se representará en base a la posición del sensor de profundidad. Lo ideal es que el marco de referencia global haga referencia a un elemento que es fijo.
Ahora sí, para suscribirnos a un nodo pulsamos en el botón "Add" de la parte inferior izquierda. En la nueva ventana que se abre seleccionamos la pestaña "By topic" y elegimos uno de ellos en función de la información que queramos visualizar, por ejemplo \verb|camera/depth/image_raw/DepthCloud| y pulsamos "OK".
El visualizador mostrará la nube de puntos captada por la cámara RGB-D, que si has seguido los pasos consistirá en un cono de puntos a ras del suelo y una pared formada por uno de los lados del cubo el resultado se puede observar en la figura~\ref{fig:rviz}.
%-------------------------------------------------------------------
\subsection{Importación de modelos 3D al mundo}
\label{cap3:ssec:importacion-mundo}
%-------------------------------------------------------------------
\figura{Bitmap/circuit}{width=.6\textwidth}{fig:mundo}%
	{Visualizacion del mundo creado con dos robots}%
Lo siguiente que vamos a hacer es importar un fichero de configuración que carga el robot en un mundo que hemos diseñado con anterioridad. Como se ha explicado arriba, el paquete que necesitamos es el de \verb|turtlebot_gazebo| por lo que necesitamos ubicarlo. Para ello usamos el comando rospack
\begin{verbatim}
rospack find turtlebot_gazebo
\end{verbatim}

Lo siguiente es crear un nuevo paquete de catkin en nuestro workspace y copiar dentro todo el contenido del paquete \verb|gazebo_turtlebot|. Seguimos cambiándole el nombre del proyecto en el fichero package.xml para que cuadre con el nombre del paquete que hemos creado. Por último, copiamos dentro de la carpeta launch los ficheros que se proporcionan a continuación \verb|turtlebot_gazebo_multiple_files.tar.gz|.
Estos ficheros contienen la configuración del simulador y de algunos nodos que se lanzan conjuntamente.
\\El primer fichero \verb|create_multi_robot|.launch especifica la configuración del mundo que se va a usar. En este caso se toma como base un mundo vacío en el que se inserta el diseño del mundo, especificado en otro fichero que se proporciona race.sdf. En el siguiente bloque se incluye la configuración de los robots, que está definida en robots.launch.
Aprovechamos para cambiar las rutas del paquete por el nombre del paquete que hayamos creado en el comando find. En robots.launch se especifica la configuración de los dos robots que vamos a cargar en el simulador. En el primer bloque se definen ciertas variables como la base del robot, el conjunto de "bandejas" que forma el cuerpo del turtlebot o el tipo de cámara que monta. Por ejemplo, podemos ver que la base que usará el robot se llama kabuki, que va a usar las plataformas hexagonales, en vez de las circulares y que va a montar una cámara kinect.
El siguiente bloque carga el modelo del robot, que es el mismo para los dos. Luego hay dos bloques que definen dos robots usando el modelo anterior, pero especificando algunos parámetros únicos como el nombre o la pose inicial. En esta especificación se hace referencia al último fichero \verb|one_robot.launch| que se encarga de hacer aparecer el robot en el simulador y de cargar otros nodos relacionados con la redirección de los tópicos del robot como, por ejemplo, \verb|robot_state_publisher| que se va a encargar de exponer todos los nodos que tiene el robot, con la información de las cámaras, odometría, láser y otros.
También se especifica un nodo que simula la salida de un láser a partir de la imagen de profundidad obtenida por kinect.
Cambiamos las rutas y los nombres de los paquetes por los correctos.
El otro fichero que se proporciona, race.sdf, contiene la definición de los elementos que forman el mundo. En este caso es un mundo formado por un sol, que nos prpporciona un sistema de iluminación, un plano que hace de suelo y varios elementos con geometría tipo caja que forman el mundo. Además de las dimensiones también se especifican la pose (traslación y rotación con respecto del sistema de referencia global), algunas propiedades físicas como la inercia o la masa y otras relacionadas con la textura que va a mostrar.
Una vez explicado todo esto, procedemos a construir el paquete y a cargar el mundo y los turtlebot en el simulador con el siguiente comando:
\begin{verbatim}
catkin_make
source devel/setup.bash
roslaunch turtlebot_gazebo_multiple create_multi_robot.launch 
\end{verbatim}
Hecho lo anterior se puede obversar en la figura~\ref{fig:mundo} el mundo que consta de una serie de paredes modeladas a partir de las cajas que se veían en el fichero race.sdf ubicadas de tal manera que forman un circuito y dos turtlebots situados en la línea de salida.

%-------------------------------------------------------------------
\subsection{Comandos Útiles}
\label{cap3:ssec:comandos-utiles}
%-------------------------------------------------------------------

\subsubsection{Movimiento de un robot}

La forma de mover los robots, tanto en el mundo real como en el simulador, es enviándoles comandos de velocidad. Los robots tienen un nodo que consumen mensajes de tipo \verb|geometry_msgs/Twist| que son el tipo de mensajes para indicar precisamente eso, valores para velocidades lineales y angulares. Un mensaje de este tipo acepta como máximo 6 valores: las velocidades lineales en x, y, z y las velocidades angulares de roll, pitch y yaw. Estos valores permiten dar movimiento a robots con hasta 6 grados de libertad, pero turtlebot sólo puede moverse por el plano XY y rotar en el eje Z (yaw).
Pero antes de enviar nada es necesario averiguar qué tópico es que acepta este tipo de mensajes por lo que usamos el siguiente comando para ver qué tópicos tenemos en el sistema:
\begin{verbatim}
rostopic list
\end{verbatim}

Para obtener más información sobre algún tópico usamos el siguiente comando
\begin{verbatim}
rostopic info /robot1/commands/velocity
\end{verbatim}

El comando para empezar a mover el robot es el siguiente:
\begin{verbatim}
rostopic pub -r 10 /robot1/commands/velocity geometry_msgs/Twist '{linear: {x: 0.1}}'
\end{verbatim}
Este comando sirve para obtener información de los nodos, mostrar su feedback y para enviarles mensajes. Nosotros usaremos el modo pub (publish) para publicar mensajes de velocidad. El parámetro -r indica la frecuencia en que se envían los mensajes, en este caso 10Hz. El siguiente argumento indica el tópico donde será lanzado este mensaje. El siguiente hace referencia al tipo de mensaje, en este caso uno de tipo Twist. Y por último se indica el contenido del mensaje, en este caso velocidad lineal de 0.1 unidades (m/s).
\com{Si no se reciben mensajes de velocidad continuamente el robot se va a parar. Esto es una medida de seguridad por si pierde conectividad con el controlador para que no cause daños. }


% Variable local para emacs, para  que encuentre el fichero maestro de
% compilación y funcionen mejor algunas teclas rápidas de AucTeX
%%%
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "../Tesis.tex"
%%% End:
