¿Qué es?
Realmente no es un sistema operativo, sino que son unos paquetes que se instalan sobre Linux que nos permitirán desarrollar software en diferentes lenguajes de programación, como Python o C++.
¿Para que sirve?
ROS está "renaciendo" ahora como una de las herramientas más útiles para el control de robots, ya que proporcionan abstracción de hardware. Es decir, no es necesario realizar drivers para compatibilizar nuestro robot con el hardware externo, sino que toda esta parte ya está hecha en ROS y solo debemos implementarla sobre nuestro proyecto.Por otro lado, toda la parte de comunicaciones, visualizadores, simuladores y demás útiles también están ya hechas y solo debemos usar el código que se nos proporciona.
En mi opinión, ROS es un instrumento que pronto va a ser establecido como genérico para la gran mayoría de los sistemas embebidos y, aunque es un mundo que aun está por descubrir, ya se puede encontrar una gran comunidad de desarrollo de fondo.
Gran parte de este boom que acaba de surgir viene dado por la ya conocida Raspberry PI, que ha introducido a usuarios apasionados por la electrónica al mundo de los procesos embebidos. En los siguientes posts mostraré que hay un mundo más allá de la Raspberry y su gran comunidad.
¿Cómo funciona?
Cada uno de los nodos tienen la capacidad de PUBLICAR la información que deseen, así como de SUSCRIBIRSE a los mensajes de otros nodos.
Todo esta red de nodos está gobernada por un nodo núcleo llamado ROSCORE, que se representa en la imagen anterior como rosout.
Por ejemplo, en la imagen anterior, shadowhand es un nodo que publica cuatro tipos de mensajes:
- srh/position/joint_states
- diagnostics
- srh/target/joint_states
- rosout (que este es invisible para nosotros y es publicado para ser controlador por el core de ROS)
A estos mensajes publicados se suscriben otros nodos que entrarán en una interrupción o CALLBACK cuando se publique un mensaje.
¿Cómo se instala?
Gracias a que ROS proporciona los fuentes del código, es posible descargarlos y compilarlos, haciéndolos de esta forma compatibles en la plataforma que estemos trabajando, como microcontroladores ARM.
Esto no es del todo tan sencillo como descargar, make y sudo make install,...ya que hay gran cantidad de librerías de las que dependen cada uno de los paquetes de ROS y lo más probable es que no estén disponibles para arquitecturas ARM.
Actualmente ROS se encuentra en la versión GROOVY y, aunque hace poco ha salido la llamada HYDROS, yo me encuentro trabajando con la anterior llamada FUERTE. Las principales diferencias entre ellas es la forma de crear proyectos, espacios de trabajo, y algunos cambios que en mi opinión resultan poco relevantes y modifican la jerarquía y el orden de los paquetes para hacer que nos liemos todos un poco más cada vez que cambiemos de versión.
Yo me encuentro con ROS FUERTE y GROOVY instalado sobre una placa con un ARM QuadCore Exynos de la que hablaré más tarde. En las siguientes entradas iré explicando como llegué a conseguirlo y la cantidad de cambios sobre el código fuente que hay que hacer.
Por ahora dejo los links más relevantes de instalación.
Groovy http://www.ros.org/wiki/groovy/Installation
- From source: http://www.ros.org/wiki/groovy/Installation/Source
Fuerte http://www.ros.org/wiki/fuerte/Installation
- From source: http://www.ros.org/wiki/fuerte/Installation/Ubuntu/Source
¿Cómo se usa?
Antes de nada recomiendo seguir los tutoriales paso a paso para comprender bien la jerarquía de archivos, creación de paquetes e intercambio de mensajes. También aconsejo empezar con la versión ROS Fuerte por resultar más sencilla e intuitiva la parte de crear un workspace y empezar a hacer proyectos nuevos, ya que todo se hace por línea de comandos. (Usad ROSBUILD en vez de CATKIN, a mí me resultó más sencillo)
http://www.ros.org/wiki/ROS/Tutorials
Hasta el tutorial 17, estaréis utilizando la linea de comandos para ejecutar nodos ya hechos y usando las herramientas que proporciona ROS para la gestión de los mismos. Un poco pesado, la verdad, y alguno podréis hasta saltároslo, pero ayuda y posteriormente os tendréis que ir familiarizando con estas líneas de ejecución.
No pretendo realizar una traducción de todo el tutorial, sino que lo que quiero mostrar es que el funcionamiento básico de ROS es sencillo y puede ser programado por cualquiera con nociones básicas de desarrollo en C++.
Ahora quiero explicar la base de un NODO PUBLICADOR en ROS
int main(int argc, char **argv)
{
// Se inicializa el nodo pasándole los parámetros introducidos por
// línea de comandos y el nombre del nodo.
ros::init(argc, argv, "talker");
// Se crea una variable del tipo NodeHandle que nos permitirá manejar
// los publicadores y suscriptores
ros::NodeHandle n;
// Se crea un tipo publicador y el tipo de mensaje que manejará.
// En este caso será un tipo string. Se crea poniéndole un nombre con
// el que será publicado.
ros::Publisher chatter_pub = n.advertise<std_msgs::string>("chatter", 1000);
// Pasamos a un bucle infinito mientras ROS esté activo y no reciba
// una señal de cierre (CTRL + C en la consola)
while (ros::ok())
{
std_msgs::String msg;
// Creamos el mensaje
std::stringstream ss;
ss << "hello world " << count;
msg.data = ss.str();
// Mostramos en pantalla el mensaje
ROS_INFO("%s", msg.data.c_str());
// Publicamos el mensaje
chatter_pub.publish(msg);
}
return 0;
}
Si hemos configurado correctamente el espacio de trabajo y hemos creado el proyecto correctamente, podremos ejecutar dicho nodo mediante ROSRUN (teniendo previamente ejecutado el ROSCORE).[ ...Seguiré explicando con imágenes y más ejemplos... Pero por ahora ya podéis intentar instalar ROS y empezar con los tutoriales ]
No hay comentarios:
Publicar un comentario