Introducción Al Sistema Operativo Robótico: El Último Framework de Aplicación Robótica

Fuente: Toptal

Leer en el sitio original: Aquí

El Sistema Operativo Robótico (ROS) no es realmente un sistema operativo sino un framework y un set de herramientas, las cuales proveen la funcionalidad de un sistema operativo en un grupo heterogéneo de computadoras. Su utilidad no se limita a robots pero la mayoría de las herramientas que se proveen se enfocan en trabajar con hardware periférico.

ROS está dividido en más de 2000 paquetes, cada paquete tiene una funcionalidad especializada. El número de herramientas conectadas al framework son probablemente su poder mayor.

¿Por qué debería usar SO Robot?

ROS proporciona funcionalidad para abstracción de hardware, controladores de dispositivo, comunicación entre procesos en máquinas múltiples, herramientas para pruebas y visualización y mucho más.

La característica clave de ROS es la manera en cómo se ejecuta el software y cómo se comunica, ya que te permite diseñar software complejo sin saber cómo funciona cierto hardware. ROS proporciona una manera de conectar una red de procesos (nodos) con eje central. Los nodos se pueden ejecutar en dispositivos múltiples y se conectan a ese eje en varias maneras.

Las maneras principales de crear una red son proporcionar servicios requeribles, o definir conexiones de publicista o suscriptor con otros nodos. Ambos métodos comunican a través de tipos de mensajes específicos. Algunos tipos son proporcionados por los paquetes centrales pero los tipos de mensaje pueden ser definidos por paquetes individuales.

Los desarrolladores pueden armar un sistema complejo al conectar soluciones existentes para pequeños problemas. La forma como se implementa el sistema nos permite:

• Reemplazar componentes con interfaces similares sobre la marcha, quitando la necesidad de detener el sistema para varios cambios.
• Multiplexar salida de múltiples componentes a una entrada para otro componente, permitiendo la solución paralela de varios problemas.
• Conectar componentes hechos en varios idiomas de programación con tan solo implementar los conectores apropiados al sistema de mensajería, haciendo más fácil el desarrollo de software al conectar módulos existentes de varios desarrolladores.
• Crear nodos sobre una red de dispositivos sin preocuparse sobre dónde se ejecuta un código e implementar los sistemas de comunicación entre proceso (IPC) y llamada a procedimiento remoto (RPC).
• Conectar directamente a transmisiones en demanda de hardware remoto sin escribir código extra, esto al emplear los dos puntos anteriores.

Planeamos demostrar lo útil que es al desarrollar iterativamente una simple solución. Hay varias ventajas clave comparadas con otros acercamientos. ROS tiene apoyo de multiplataforma y permite conexiones entre procesos de dispositivos múltiples, a través de conexiones de pares que se manejan detrás de escena. El diseño permite apoyo para cualquier idioma al determinar las clases de comunicación C++, o desarrollar clases manualmente para la interfaz de lenguaje.

ROS está hecho por su propia comunidad. Después de varios años, dio como resultado una gran cantidad de paquetes reusables que son fáciles de integrar gracias a la arquitectura del sistema.

Acercamientos alternativos como MRPT, CARMEN, LCM, Player, Microsoft RDS y otros, proporcionan algunas de esas características pero no todas. La mayor parte del tiempo, las fallas del diseño son limitaciones de apoyo del idioma, comunicación sin optimizar entre los procesos, o la falta de apoyo para varios dispositivos, lo cual se puede decir es el problema más difícil de resolver.

¿Qué Vamos A Construir?

Ya que nuestro enfoque es el framework y no los algoritmos como tal, para problemas particulares, el problema dado será muy sencillo. Nuestra meta es construir software para una computadora que sea parte del proceso y nos permita controlar remotamente y monitorear un robot, conectado a nosotros vía Wi-Fi, usando un gamepad en nuestra computadora y una transmisión desde la cámara montada en el robot.

Primero que todo, haremos que un programa simple se conecte a una simulación simple, solo para demostrar los principios básicos de ROS. Vamos a unir un gamepad a una computadora y trataremos de diseñar un buen esquema de control para pasar la entrada de gamepad a señales de control para un robot.

Los idiomas principales para escribir código ROS son C++ y Python, C++ es preferido por menor desempeño. Vamos a explicar nuestros ejemplos en Python debido a que tiene menos calificativo en el código y no hay necesidad de hacer una construcción específica.

Instalación Y Configuración

A las versiones ROS se les refiere por nombre. Hasta la fecha, el último lanzamiento es Jade Turtle, y la versión LTS es Indigo Igloo. Ir desde la versión es preferible y la compatibilidad hacia atrás no está garantizada en ROS así que todos los ejemplos serán escritos para Indigo.

ROS está disponible en varias plataformas *NIX. La versión apoyada oficialmente está en Ubuntu. Las versiones OS X, Arch Linux, Debian, Raspbian y Android son apoyadas por la comunidad.

Veremos el proceso de instalación para Ubuntu 14.04 en escritorio. Los procesos para todas las versiones apoyadas y plataformas están disponibles en la página oficial. Las máquinas virtuales con ROS ya instalado también están disponibles.

La instalación depende de la plataforma (y la mayoría de las plataformas tiene paquetes incluidos) pero la configuración del espacio de trabajo es el mismo para todas las plataformas.

Instalación En Ubuntu

ROS proporciona sus propios repositorios. El primer paso es agregarlos.

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'
sudo apt-key adv --keyserver hkp://pool.sks-keyservers.net --recv-key 0xB01FA116

sudo apt-get update

Después de eso tendrás todos los paquetes alojados para todas la versiones de ROS disponibles para tu versión Ubuntu. Por ejemplo,

Ubuntu 14.04 apoya indigo y jade.

Instalar los paquetes base en escritorio tiene una de tres opciones:

• sudo apt-get install ros-indigo-ros-base para una instalación mínima
• sudo apt-get install ros-indigo-desktop para tener la herramienta básica adicional GUI
• sudo apt-get install ros-indigo-desktop-full para tener todas las características oficiales, incluyendo varios simuladores y bibliotecas para navegación y percepción.

Para una mejor experiencia de trabajo, la opción completa es recomendada. Para instalación en dispositivos que serán utilizados solo para ejecutar nodos, la versión ase es suficiente. Pero sin importar que opción escojas, puedes instalar cualquier paquete que necesites llamado package_name al ejecutar:

sudo apt-get install ros-indigo- 

Los guiones bajos son reemplazados por guiones en el nombre final, así que stage_ros  estará en el paquete como ros-indigo-stage-ros.

El próximo paso es iniciar rosdep. Los paquetes en ROS pueden declarar de qué componentes dependen. rosdep te permite compilar esos paquetes sin depender mucho del manejo manual. Para iniciarlo, llama:

sudo rosdep init
rosdep update 

ROS tiene muchas variables ambientales usadas por sus herramientas. Con la instalación por defecto, el guión de bash para iniciarlos está localizado en /opt/ros/indigo/setup.bash. Las variables necesitan ser iniciadas dentro de cada sesión de bash, así que la mejor solución es agregarlas a ~/.bashrc.

echo "source /opt/ros/indigo/setup.bash" >> ~/.bashrc
source ~/.bashrc 

Algunos paquetes instalan dependencias externas vía rosinstall, el cual está disponible como un paquete e instalado vía sudo apt-get install python-rosinstall.

Este es el final de la instalación en Ubuntu. Lo que sigue es una pequeña introducción a instalación de espacios de trabajo.

Configuración

Desde Groovy Galapagos, los espacios de trabajo ROS han sido manejados a través de catkin. Necesitamos definir un directorio para todos los paquetes que alojamos. Dentro del directorio creamos una carpeta src y llamamos catkin_init_workspace desde adentro. Eso creará varios links simbólicos en la versión fuente actual de ROS. El próximo paso es añadir también este espacio de trabajo a las variables de ambiente.

Para desempeñar toda esta configuración de espacio de trabajo, escoge un directorio vacío y ejecuta los siguientes comandos:

mkdir src
cd src
catkin_init_workspace
cd ..
catkin_make
echo "source $(pwd)/devel/setup.bash" >> ~/.bashrc

source ~/.bashrc

Ahora has creado un espacio de trabajo en el que puedes crear tus propios paquetes ROS.

Familiarizarse Con Las Herramientas

Crear cualquier código es un gran salto. Primero, vamos a familiarizarnos con algunos de los sistemas que se ejecutan detrás de escena. Nuestro primer paso será ejecutar el GUI básico y ver que mensajes genera.

Para ejecutar cualquier cosa en ROS, se necesita lanzar un proceso principal. Es tan fácil como abrir una nueva ventana terminal y escribir:

roscore 

En toda tu red de dispositivos conectada, roscore necesita ser ejecutado sólo una vez, en el dispositivo que alojará el eje central para enviar comunicación.

El papel principal de roscore es decirle a los nodos con que otros nodos deberían conectarse, y de qué manera (ya sea vía puerto de red o memoria compartida). La meta es permitirle a los nodos que se preocupen solo por cual data quieren conocer, en vez de a qué nodo se quieren conectar, mientras minimizan el tiempo o la banda ancha que necesitan para desempeñar toda comunicación.
rqt

Después de ejecutar roscore, podemos lanzar la herramienta GUI principal para ROS: rqt. Lo que vemos es muy decepcionante – una ventana vacía. rqt aloja una gran variedad de plugins que pueden ser configurados en cualquier configuración visual y cualquier número de vistas predefinidas.

Para empezar ejecutamos el plugin Robot Steering , escogiéndolo en Plugins > Robot Tools > Robot Steering. Lo que obtenemos es dos deslizadores, que representan la moción lineal y rotacional que queremos que tenga nuestro robot. En la parte superior del plugin, vemos una caja de texto con /cmd_vel en ella. Le podemos dar otro nombre. Representa el nombre del tema al que va dirigida la publicación. Las herramientas terminales son el mejor lugar para ver qué sucede en el fondo.

Herramientas Terminales

ROS tiene varias herramientas poderosas para inspeccionar que pasa en el sistema. La primera herramienta que vamos a introducir es rostopic, ésta nos permite inspeccionar temas a los que los nodos se pueden suscribir y publicar. Ejecutar rostopic list dará:

/cmd_vel
/rosout
/rosout_agg 

Los dos últimos temas siempre están en ejecución y están relacionados a sistemas ROS centrales. El tema /cmd_vel está siendo publicado por nuestras direcciones. Renombrar el tema en las direcciones, lo renombrará aquí también. Ahora, nos interesa que sucede dentro del tema. Ejecutar rostopic echo /cmd_vel no nos mostrará nada (a menos que juegues con los deslizadores). El proceso se ejecuta hasta que lo cancelemos. Movamos ahora el deslizador vertical a 20 m/s. Mirando al eco, podemos ver lo siguiente repetido una y otra vez:

linear:
 x: 0.2
 y: 0.0
 z: 0.0
angular:
 x: 0.0
 y: 0.0
 z: 0.0 

¿Cada cuánto hace spam este mensaje? rostopic hz /cmd_vel dice en una tasa promedio de 10 Hz. Bueno, ¿cuántos temas como éste puedo ejecutar con mi conexión lenta de Wi-Fi? rostopic bw /cmd_vel detecta un promedio de 480 B/s.

Eso está muy bien, pero hablamos de tipos de mensaje. Esta data es buena para un humano, pero una aplicación necesitará la data sin pulir y necesitará saber el tipo de mensaje para poder interpretar la data. El tipo de mensaje puede ser interpretado con rostopic type /cmd_vel, diciéndonos que es un geometry_msgs/Twist. Todas las herramientas terminales ROS llamadas sin ningún argumento, regresan un mensaje de ayuda estándar.

El Wiki de ROS es bueno para hacer una búsqueda web para este resultado de cadena, en una explicación Wiki para lo que contiene y cómo se estructura. Pero no tenemos que confiar en él. rosmsg es la herramienta general para tipos de mensaje. Ejecutar rosmsg show geometry_msgs/Twist regresará:

geometry_msgs/Vector3 linear
 float64 x
 float64 y
 float64 z
geometry_msgs/Vector3 angular
 float64 x
 float64 y
 float64 z 

El mensaje consiste en dos vectores 3D representando velocidad lineal y angular en un espacio 3D.

Si quieres saber a qué temas se conecta un nodo, rosnode info nos dará data detallada sobre el nodo. Las herramientas rostopic, rosmsg y rosnode son las herramientas principales para inspeccionar funcionalidad ROS sin pulir. ROS tiene mucho más GUI y herramientas terminales, pero esas están fuera del alcance en esta introducción.

Las herramientas principales para ejecutar nodo ROS son rusrun y roslaunch. rosrun puede ejecutar nodos vía rosrun , y roslaunch ejecuta nodos basado en archivos de lanzamiento, con los cuales nos familiarizaremos poco ya que son el elemento más complejo de la automación ROS.

Podemos apagar todo lo que ejecutamos para comenzar a trabajar en nuestro primer código. Para referencia futura, será obvio que ejecutar cualquier cosa relacionada con ROS requiere una instancia activa de roscore. Muchos de los problemas con los que te encuentras pueden ser resueltos al cerrar la ventana terminal en el que se ejecuta roscore y abrir una nueva para relanzarlo. Esto actualiza todas las dependencias que se necesitaban recargar, ambas en bash y en roscore.

Creando La Tele-operación Gamepad

Nuestra primera meta es imitar la funcionalidad de Robot Steering creando un nodo que publique data de geometry_msgs/Twist a /cmd_vel basado en una entrada gamepad. Nuestra primera parada es el paquete joy

El Paquete joy

El paquete joy proporciona drivers ROS genéricos para joystick y gamepads. No está incluida en la instalación por defecto, así que necesita ser instalado vía:

sudo apt-get install ros-indigo-joy 

Después de la instalación, podemos ejecutar rosrun joy joy_node. Esto nos conectará al joystick o gamepad, por defecto. Ejecutar rostopic list nos muestra que tenemos un tema llamado /joy. Escucharlo vía rostopic echo nos muestra mensajes del siguiente formato (nota que tienes que interactuar con el gamepad o joystick para que los mensajes sean publicados).

header:
 seq: 4156
 stamp:
   secs: 1450707466
   nsecs: 204517084
 frame_id: ''
axes: [0.0, 0.0, 0.0, -0.0, 0.0, 0.0, 0.0, 0.0]
buttons: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 

Puedes ignorar los encabezados por ahora. Aparte de eso tenemos axes y buttons, que explican agradablemente que representan. Al mover las axes y empujar a los buttons en el controlador, resultará en el cambio de estos números. AL usar nuestras herramientas, podemos determinar que el tipo de mensaje es sensor_msgs/Joy y el formato es:

std_msgs/Header header
 uint32 seq
 time stamp
 string frame_id
float32[] axes
int32[] buttons

Creando Nuestra Tele-Operación

El primer paso para escribir código es crear un paquete. Dentro de la carpeta src del espacio de trabajo, ejecuta:

catkin_create_pkg toptal_tutorial rospy joy geometry_msgs sensor_msgs

Aquí enunciamos el nombre del paquete que estamos creando, seguido de paquetes de los cuales planeamos depender. No te preocupes, las dependencias pueden ser actualizadas manualmente, más tarde.

Ahora tenemos una carpeta toptal_tutorial. Dentro de la carpeta, crea una carpeta llamada scripts que contendrá todos nuestros guiones Python.

Creemos un archivo llamado teleop.py, y dentro de él tendremos:

#!/usr/bin/env python
 
import rospy
from sensor_msgs.msg import Joy
 
def joy_callback(data):
   print data
 
def main():
   rospy.init_node('teleop')
   rospy.Subscriber('joy', Joy, joy_callback)
 
   while not rospy.is_shutdown():
       pass
 
if __name__ == '__main__':
   main() 

También necesitamos fijar chmod +x teleop.py así el guión es ejecutable. Ejecutar rosrun joy joy_node en un terminal y rosrun toptal_tutorial teleop.py en otro, dará como resultado que la salida del terminal teleop.py se llene con mensajes Joy.

Examinemos qué hace el código.

Primero, importamos rospy, el cual aloja la biblioteca para interactuar con el framework ROS. Cada paquete que define mensajes tiene un sub-paquete msg con definiciones de mensaje. 

Estamos importando Joy para manejar la entrada. No hay necesidad de importar tipos de mensaje incrustados (cómo Headerde std_msgs.msg eso está en el mensaje Joy) a menos que queramos mencionarlos específicamente.

Nuestro primer paso es inicializar un nodo con un nombre específico (en este caso, lo llamamos “teleop”). Después de eso, creamos un suscriptor que se suscribe al tipo de tema “joy” sensor_msgs.msg.Joy, y eso maneja cada mensaje al llamar la función joy_callback. Las retrollamadas reciben un parámetro, la data del mensaje. Acceder a miembros de la data es simple. Si quisiéramos imprimir el estado del primer axis, si recordamos el tipo de mensaje, llamaríamos a print data.axes[0], y sería un flotador. El nudo al final de los nudos, hasta que ROS se apaga.

Nuestro próximo paso sería manejar nuestra data de alguna manera. Deberíamos crear un mensaje Twist que cambia, dependiendo de la entrada y luego lo publicaríamos en el tema cmd_vel.

#!/usr/bin/env python
 
import rospy
from sensor_msgs.msg import Joy
from geometry_msgs.msg import Twist  # new
from functools import partial  # new
 
def joy_callback(pub, data):  # modified
   cmd_vel = Twist()  # new
   cmd_vel.linear.x = data.axes[1]  # new
   cmd_vel.angular.z = data.axes[0]  # new
   pub.publish(cmd_vel)  # new
 
def main():
   rospy.init_node('teleop')
   pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000)  # new
   rospy.Subscriber('joy', Joy, partial(joy_callback, pub))  # modified
 
   while not rospy.is_shutdown():
       pass
 
if __name__ == '__main__':
   main() 

Primero agregamos el mensaje Twist, y agregamos apoyo para argumentos funcionales con ataduras vía functools.partial. Creamos un publicista, pub, que publica a cmd_vel un mensaje tipo Twist. Atamos ese publicista a la retrollamada y hacemos que publique un mensaje Twist en cada entrada con las velocidades siendo representadas por las primeras dos axes. Este código hace lo que se espera de él, y podemos ver la salida resultante vía rostopic echo /cmd_vel.

Aún tenemos un problema. El tema /joy puede publicar grandes velocidades. Si monitoreamos el rostopic hz /cmd_vel y movemos el stick analógico en círculos podremos ver muchos mensajes. Esto resultará no sólo en un gran número de comunicaciones sino que también los procesos que reciben estos mensajes tienen que procesar cada uno de ellos; no hay necesidad de publicar tantos datos tan frecuentemente, y en realidad es mejor publicar a una velocidad estable de 10 Hz. Podemos obtener esto con el siguiente código.

#!/usr/bin/env python
 
import rospy
from sensor_msgs.msg import Joy
from geometry_msgs.msg import Twist
from functools import partial
 
def joy_callback(cmd_vel, data):  # modified
   cmd_vel.linear.x = data.axes[1]
   cmd_vel.angular.z = data.axes[0]
   # moved pub.publish(cmd_vel) to main loop
 
def main():
   rospy.init_node('teleop')
 
   cmd_vel = Twist()  # new
 
   pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000)
   rospy.Subscriber('joy', Joy, partial(joy_callback, cmd_vel))  # modified
 
   rate = rospy.Rate(10)  # new
   while not rospy.is_shutdown():
       pub.publish(cmd_vel)  # new
       rate.sleep()  # new
 
if __name__ == '__main__':
   main() 

Modificamos la retrollamada para recibir el objeto mutable Twist y modificarlo dentro del bucle. La función sleep de rospy.Rate mantiene una frecuencia de salida estable.

El código final resultará en el tema /cmd_vel obteniendo velocidades de comando de 10 Hz, así imitando la salida del plugin Robot Steering rqt

Ejecutando Un Sistema Simulado
Simulando El Mundo

Nuestra primera meta es crear un entorno en el que podamos simular el escenario que queremos lograr. El nodo stageros dentro del paquete stage_ros nos permitirá ejecutar un robot en una etapa 2D definida por una imagen. Existe toda una síntesis descrita en el paquete stage_ros para archivos mundiales y como generarlos. Esto es bastante sencillo pero fuera de nuestro alcance. Por suerte, el paquete viene con varios demos mundiales. Primero vayamos al directorio de los archivos por ejecución:

roscd stage_ros
cd world

Dentro de la carpeta existen varios archivos. Ejecutemos uno.

rosrun stage_ros stageros willow-erratic.world 

Se crearon varios temas. El significado de cada uno de ellos también se documenta con el paquete. Lo importante es que tiene cmd_vel.

Dentro de la etapa que se muestra hay un cuadro azul, este representa el robot que tu controlas. Al usar nuestro código o Robot Steering podemos controlar este robot. ¡Inténtalo!

Configurando Nuestro Sistema Mediante Archivos De Lanzamiento

Primero creamos una carpeta launch o lanzamiento dentro de nuestro paquete y dentro de esta crea un archivo llamado teleop.launch. La estructura final de la carpeta debería verse así:

toptal_tutorial/
├── CMakeLists.txt
├── launch
│   └── teleop.launch
├── package.xml
├── scripts
│   └── teleop.py
└── src 

Dentro del archivo teleop.launch definiremos varios nodos y sus interconexiones.

<launch>
 <arg name="world_file" default="$(find stage_ros)/world/willow-four-erratics-multisensor.world" />
 <node pkg="stage_ros" type="stageros" name="simulated_world" args="$(arg world_file)"></node>
 <group ns="robot_0">
   <node pkg="joy" type="joy_node" name="joy_input"></node>
   <node pkg="toptal_tutorial" type="teleop.py" name="joy_convert"></node>
 </group>
</launch> 

El nuevo mundo consiste en 4 robots y cada uno de sus temas tiene un prefijo denominado robot_. Así, el robot número 0 tiene un tema de velocidad de comando llamado robot_0/cmd_vel. Es por esto que ponemos nuestro control dentro del espacio de nombre denominado robot_0 y así ajustaremos sus nombres a la nueva forma. De esta forma puedes pensar en los nombres de los temas como carpetas en un sistema de archivo.

Para ejecutar archivos de lanzamiento no se necesita roscore. De cierto modo, roscore es solo un caso especial de un archivo de lanzamiento que no hace nada. Si llegara a faltar un roscore solo el primer archive de lanzamiento iniciado ejecutará un núcleo, mientras que el resto se conectará a este. Ahora ejecutaremos el lanzamiento con:

roslaunch toptal_tutorial teleop.launch

Si todo está en orden esto resultará en un simulador con 4 robots, donde cada uno es controlado con el gamepad o joystick. Este mundo tiene mucho más contenido que el anterior. Cada uno de los cuatro robots tiene lo siguiente:

/robot_/base_pose_ground_truth
/robot_/base_scan_0
/robot_/base_scan_1
/robot_/camera_info_0
/robot_/camera_info_1
/robot_/cmd_vel
/robot_/depth_0
/robot_/depth_1
/robot_/image_0
/robot_/image_1
/robot_/odom

Reemplazamos con 0, 1, 2, o 3. Y con esto llegamos a nuestro último tema.

Visualizando Nuestros Datos Con rqt

Anteriormente no profundizamos en rqt pero es la herramienta perfecta para visualizar datos más complejos. Puedes experimentar con todos los temas pero nos enfocaremos en los temas image_0, image_1, depth_0, y depth_1.

Al ejecutar rqt removemos todos los plugins abiertos. Ahora abriremos 4 visualizadores de imagen (Plugins > Visualización > Vista Imagen) y los pondremos en una cuadrícula de 2x2. Para finalizar, en la esquina superior izquierda de cada una de las vistas escogeremos uno de los cuatro temas establecidos para robot_0.

Lo que obtenemos es visión estéreo con percepción profunda con cámaras de baja resolución. Ten en cuenta que podríamos haber obtenido este resultado sin nuestro sistema de entrada. Si sólo ejecutáramos esto (desde dentro de la carpeta stage_ros/world):

rosrun stage_ros stageros willow-four-erratics-multisensor.world 

Y añadimos el plugin Robot Steering con un tema llamado /robot_0/cmd_vel podríamos haber tenido el mismo resultado si los controles estuvieran en la pantalla.

Aplicando Los Resultados En Un Sistema Real

Muchos hardware soportan completamente ROS, en muchas ocasiones gracias a terceros. Muchas plataformas de robot tienen drivers que generan este tipo de mensajes y ROS tiene nodos que activan la webcam y publican un feed de imágenes.

Mientras que el último resultado fue una simulación de lo que queremos lograr; lo mismo se puede lograr con las siguientes modificaciones:

• Instala ROS en la computadora de abordo de tu robot 
• Crea un archivo de lanzamiento para la computadora de abordo que conecta ROS a la plataforma subyacente y todos los sensores de alto nivel como cámaras, alcance del láser y otros. Los nodos necesarios ya pueden existir o pueden ser implementados al crear un editor/suscriptor para ROS de un lado y un driver para comunicaciones seriales del otro. 
• Haz que el archivo de lanzamiento se ejecute en el inicio
• En tu computadora remota agrega export ROS_MASTER_URI=http://:11311/ a tu inicio en Bash, así la computadora remota buscará en ese host y puerto
• Inicia rqt y/o cualquier script para monitorear y controlar el robot

Al final solo se debe exportar el entorno de variable adecuado en el dispositivo remoto y de resto todo se hace solo. Ejecutar ROS en el agrupamiento de una computadora solo necesita un paso para estar listo en cada máquina.

Conclusión

Hemos demostrado cómo, con cada código, por pequeño sea, puedes tener un sistema complejo de variables que puedes manipular como quieras. El sencillo sistema editor/suscriptor te permite un desarrollo de software rápido que procesa datos en un agrupamiento de computadoras, al tiempo que te deja estar tranquilo para que no te preocupes por la implementación subyacente de ciertos elementos.

Mientras nosotros usamos un simulador sencillo, otros simuladores más complejos como gazebo (el cual se incluye en la versión de escritorio completa) te permiten crear mundos 3D con sensores físicos y complejos Y te da una experiencia de los resultados finales y del producto antes que se desarrolle.

Esta introducción fue algo básica pero se espera que te sientas más interesado en trabajar con este framework tan versátil.