Alexander Edward Merejildo Tomalá #Matrícula 201020500Edgar Marcelo Vela Pinela #Matrícula 201021813

Integrantes

ESCUELA SUPERIOR POLITÉCNICA DEL LITORAL

10-7-2013

Facultad de Ingeniería en Electricidad y Computación

ContenidoIntroducción a Robot Operating System (ROS)...........................................................................2

Nomenclatura de ROS.................................................................................................................3

La historia de ROS........................................................................................................................4

¿Cómo funciona ROS?.................................................................................................................4

La organización general de ROS..................................................................................................5

Programación de ROS..................................................................................................................5

El sistema de archivos ROS..........................................................................................................5

Historial de las Versiones............................................................................................................7

Tortuga de caja: 1 de marzo 2010...............................................................................................7

Diamondback: 2 de marzo 2011..................................................................................................7

Electric Emys: 30 de Agosto 2011................................................................................................8

Fuerte: 23 de abril 2012..............................................................................................................8

Groovy Galápagos: 31 de diciembre 2012..................................................................................9

Instalar ROS (Robot Operating System) - Electric Emys............................................................10

ROS NXT.....................................................................................................................................13

Problemas encontrados.............................................................................................................15

CREANDO LA CARPETA OVERLAY..............................................................................................16

CREANDO PAQUETES ROS NXT.................................................................................................16

PRIMER PROGRAMA EN ROS-NXT.............................................................................................17

DESARROLLO DEL PROYECTO....................................................................................................18

Conclusiones:.............................................................................................................................21

Recomendaciones:....................................................................................................................21

1

Introducción a Robot Operating System (ROS).

Sistema Operativo Robótico (en inglés Robot Operating System, ROS) es un framework para el desarrollo de software para robots y ofrece herramientas y librerías para el desarrollo de

sistemas robóticos. A pesar de su nombre, ROS no es un sistema operativo propiamente dicho (de hecho funciona sobre Linux), sino una infraestructura de desarrollo, despliegue y ejecución de sistemas robóticos así como una gran federación de repositorio que ofrece paquetes con software de todo tipo para robots.

ROS se desarrolló originalmente en 2007 bajo el nombre de switchyard por el Laboratorio de Inteligencia Artificial de Stanford para dar soporte al proyecto del Robot con Inteligencia Artificial de Stanford (STAIR). Desde 2008, el desarrollo continúa primordialmente en Willow Garage, un instituto de investigación robótico con más de veinte instituciones colaborando en un modelo de desarrollo federado

ROS pretende dar una solución integral al problema de desarrollo de robots aportando soluciones a las áreas de:

Abstracción de Hardware (HAL) y reutilización e integración de robots y dispositivos encapsulando estos tras interfaces estables y manteniendo las diferencias en archivos de configuración.

Algoritmos de robótica con bajo acoplamiento: desde algoritmos de bajo nivel de control, cinemática, SLAM, etc. Hasta algoritmos de alto nivel como planificación o aprendizaje. También otros muchos más específicos como: lograr que el robot X coja un objeto o el robot Y se auto enchufe a la red eléctrica.

ROS provee de un mecanismo comunicaciones (middleware) distribuido entre nodos del sistema robótico. Un nodo es cualquier pieza de software del sistema (desde un algoritmo SLAM hasta un driver para el manejo de un motor). El objetivo de este sistema es doble: 1- encapsulado/abstracción/reutilización de software e 2- ubicuidad, es decir, independencia de donde este nodo está localizado (un sistema robótico puede tener muchos procesadores). Estos nodos se comunican entre ellos mediante mecanismos de paso de mensajes RPC o Publish/Subscribe, Service lookup, etc. Permite crear arquitecturas P2P de componentes robóticos distribuidos.

Simulación de sistemas robóticos en mundos virtuales con dinámicas de sólidos rígidos.

Herramientas de desarrollo, despliegue y monitorización de sistemas robóticos.

2

Nomenclatura de ROS

Al igual que cualquier otro framework, ROS posee una estructura ya definida con la que lleva a cabo su funcionalidad, y es necesario conocerla para poder trabajar de acuerdo a su ambiente.

Su estructura está compuesta por: nodos, mensajes, tópicos, y servicios.

“Los nodos son procesos que performan computación. ROS está diseñado para ser modular a escala de grano fino: un sistema típicamente se compone de muchos nodos. El término "nodo" es intercambiable con "módulo de software." El uso de la terminología "nodo" surge de visualizaciones de sistemas basados en ROS a tiempo de ejecución: cuando muchos nodos se están ejecutando, es conveniente hacer que las comunicaciones peer-to-peer se representen por medio de un grafo, con los procesos como nodos del grafo y los enlaces peer-to-peer como arcos.

Los nodos se comunican entre sí por el paso de mensajes. Un mensaje es una estructura de datos. Los datos primitivos estándar como lo son (enteros, punto flotante, booleano, etc) son compatibles, como a su vez los arreglos de tipos primitivos y constantes. Los mensajes pueden estar compuestos por otros mensajes, y por arreglos de otros mensajes.

Un nodo envía un mensaje haciendo una publicación a un tópico determinado, el tópico tiene un identificador único de tipo String. El nodo que esté interesado en una clase de datos en particular se suscribirá al tópico correspondiente. Puede existir múltiples subscriptores y publicadores sobre un mismo tópico, y a su vez un nodo puede publicar y / o suscribirse a múltiples tópicos. En general tanto publicadores como subscriptores ignoran la existencia de su entorno.

Aunque el modelo de publicación-suscripción basado en tópicos es un paradigma de las comunicaciones flexibles, su esquema de enrutamiento ("emisión") no es apropiado para transacciones síncronas, que puede simplificar el diseño de algunos nodos. En ROS, llamamos a esto un servicio, definido por un identificador de tipo String y un par de mensajes, uno que hace el papel de solicitante y el otro de remitente. Esto es análogo a los servicios web, que están definidos por los URI y tienen documentos de solicitud y respuesta.” [1]

3

La historia de ROS

ROS es desarrollado y mantenido por una compañía californiana, Willow Garage (empresa privada que mantiene estrechos vínculos con la Universidad de Standford), formada en 2006 por Scott Hassan, uno de los primeros empleados de Google que estuvo involucrado en el desarrollo de la tecnología de ese motor de búsqueda y que también estaba detrás de Yahoo! Groups.

Willow Garage describe a sí mismo como un laboratorio de investigación y la tecnología incubadora de robótica. Se encarga del desarrollo de software y hardware con ROS, todo lo que se produce es de código abierto (licencia BDS)

La idea de la compañía es que si se quiere que los robots lleguen a los hogares, entonces la investigación tiene que ser acelerado por hardware, que proporcione bases sólidas y a la vez software que sea de código abierto.

¿Cómo funciona ROS?

Como un ejemplo de cómo funciona ROS, imagine que usted está construyendo una aplicación. Esa aplicación es inútil sin el hardware y el software - es decir, el ordenador y el sistema operativo. Antes de ROS, cada diseñador de robots e investigador de robotica pasaban una cantidad considerable de tiempo en el diseño del software integrado en un robot, así como en el hardware. Como resultado, el proceso de aplicación de decisiones robótica era increíblemente lento, y hubo un considerable re-eso de los programas, ya que estaban estrechamente relacionados con el hardware subyacente.

La idea principal es evitar la continua reinvención de la rueda, y ofrecer funcionalidades estandarizadas que realizan abstracción del hardware. Y como otros investigadores de todo el mundo están utilizando las mismas herramientas, se pueden compartir fácilmente sus desarrollos de un proyecto a otro.

4

La organización general de ROS

ROS se puede resumir en los cinco principios fundamentales siguientes:

Intercambio de archivos.- Una arquitectura peer-to-peer acoplado a un sistema de amortiguación y un sistema de búsqueda (un "maestro" en ROS), permite que cada componente pueda dialogar directamente con los demás, de forma sincrónica o asincrónica como sea necesario.

Multi-idioma: ROS es independiente del idioma, y se puede programar en varios idiomas.

Herramientas - basadas (Microkernel): En lugar de un entorno de ejecución monolítica, ROS adoptó un diseño microkernel, que utiliza un gran número de pequeñas herramientas para generar y ejecutar los diversos componentes de ROS. Cuando se refiere a sistema microkernel quiere decir que la comunicación se da usando mensajes.

Programación de ROS

La comunicación se basa en XML-RPC, ROS es independiente del lenguaje, es posible programar ROS en Python, Lisp o C + +.

El sistema de archivos ROS

Recursos de ROS están organizados en una estructura jerárquica en el disco. Dos conceptos importantes se destacan:

Nodo: Se incluye dentro de un paquete, es un proceso ejecutable. La comunican entre nodos es por medio de paso de mensajes. Un mensaje es una estructura de datos, los mensajes pueden estar compuestos por otros mensajes, y por arreglos de otros mensajes.

Package: la unidad fundamental dentro de ROS. Un paquete es un directorio que contiene los nodos, bibliotecas externas, datos, archivos de configuración y un archivo de configuración xml denominado manifest.xml.

5

PACKAGE

NodosTópicosServicios

Pila: una colección de paquetes. Ofrece un conjunto de funcionalidades como la navegación, posicionamiento, etc. Una pila es un directorio que contiene los directorios de paquetes, además de un archivo de configuración llamado stack.xml.

Repositorio: Es una colección de paquetes y pilas disponibles online.

6

PILA

PACKAGE PACKAGE

REPOSITORIO

PILA

PILAPACKAGE

PACKAGE

Historial de las Versiones

Las últimas distribuciones ROS hasta la fecha:

Tortuga de caja: 1 de marzo 2010.

Muchas de las pilas en el sistema ROS tuvieron su primera versión 1.0 con esta versión, que requiere pruebas de usuario intensivo y pruebas en robot.

Plataforma.- Dirigido principalmente a Ubuntu Hardy, pero se puede instalar en varios sistemas Linux como Debian, Red Hat y Gentoo.

Diamondback: 2 de marzo 2011.

Contiene más de cuarenta nuevas pilas de la creciente comunidad ROS y una versión estable de la Biblioteca como punto de nube. Esta versión ha sido diseñada para ser más ligero y más configurable que ROS C Turtle.

Plataforma.- Dirigido principalmente a Ubuntu Lucid, a través de comunicados Maverick pero se puede instalar en varios sistemas Linux como Debian, Red Hat y Gentoo.

7

Electric Emys: 30 de Agosto 2011.

Incluye bibliotecas estables para Arm Navigation y PLC, así como la ampliación del apoyo de ROS a muchas nuevas plataformas como Android.

Plataforma.- Dirigido principalmente a Ubuntu Lucid Natty, a través de comunicados Lucid pero se puede instalar en varios sistemas Linux como Debian, Red Hat y Gentoo.

Fuerte: 23 de abril 2012.

Es el quinto ROS, tiene importantes mejoras que lo hacen más fácil de integrar con otros marcos y herramientas de software. Esto incluye una nueva versión del sistema de compilación, la migración hacia el marco de Qt y la continua transición a las bibliotecas independientes.

Plataforma.- Dirigido principalmente a Ubuntu. Puede instalar en varios sistemas Linux como Debian, Red Hat y Gentoo.

8

Groovy Galápagos: 31 de diciembre 2012.

Proporciona bibliotecas y herramientas para ayudar a los desarrolladores de software para crear aplicaciones robóticas. El sistema se basa en switchvard.

Plataforma.- Dirigido principalmente a Ubuntu Jaunty, a través de comunicados Lucid pero se puede instalar en varios sistemas Linux como Debian, Red Hat y Gentoo.

9

Instalar ROS (Robot Operating System) - Electric Emys.

Para poder utilizar ROS junto con nuestro LEGO Mindstorms NXT es necesario tener instalado el sistema basado en Linux Ubuntu 11.10 al igual que las librerías del NXT en Python.

(VIDEO)

Primer paso. – Configurar los repositorios de Ubuntu

Se debe configurar el acceso a los repositorios restricted”, “universe”, “multiverse”. Los detalles de esta configuración se pueden encontrar en:

https://help.ubuntu.com/community/Repositories/Ubuntu

Configurar el archivo sources.list de ubuntu, necesario para aceptar los paquete Debian desde el servidor de ROS

sudo sh -c ‘echo “deb http://code.ros.org/packages/ros/ubuntu oneiric main” > /etc/apt/sources.list.d/ros-latest.list’

Configurar las claves

wget http://code.ros.org/packages/ros.key -O – | sudo apt-key add –

10

Asegurarse que Ubuntu tenga en cuenta el indexado del servidor de ROS en los repositiorios

sudo apt-get update

Elegir según las preferencias de instalación

Instación completa (recomendada) con ROS, rx, rviz, librerías, simuladores 2D/3D , ..

sudo apt-get install ros-electric-desktop-full

ROS de escritorio. Con ROS, rx, rviz y algunas librerías.

sudo apt-get install ros-electric-desktop

ROS básico. Contiene ROS y las librerías genéricas de robótica (navegación, visualización, …)

sudo apt-get install ros-electric-base

Tercer paso . – Configuración del entorno

11

Es interesante que las variables de entorno de ROS sean añadidas automáticamente a la sesión bash cada vez que un nuevo shell es lanzado. Para ello ejecutar

echo “source /opt/ros/electric/setup.bash” >> ~/.bashrc . ~/.bashrc

Si tienes varias versiones de ROS instaladas el ~/.bashrc debe solo ejecutarse el setup.bash que estas usando normalmente.

Por el contrario, si quieres ejecutar el setup directamente utiliza

source /opt/ros/electric/setup.bash

12

ROS NXT

NXT es un kit de robótica fabricado por LEGO.

La librería NXT-ROS provee útiles herramientas para la interface de los robots NXT con ROS. Usuarios de NXT pueden tomar sus modelos creados en LDS (Lego Digital Designer), y automáticamente convertirlo en un modelo compatible con ROS. Este modelo puede ser visualizado en rviz y en un futuro, se espera añadir añadir la capacidad de simular en gazebo, el simulador en 3D de ROS.

INSTALAR ROS NXT ELECTRIC

Estas instrucciones son para instalar en ROS Electric en una computadora con Ubuntu 10.04 o una versión más reciente.

(VIDEO)

Primer paso.- Configuración del computador

Antes que su computador pueda comunicarse con el brick NXT, se necesita establecer las reglas del udev.

En una terminal:

Añadir el grupo lego:

sudo groupadd lego

sudo usermod –a –G lego <username>

Ahora creamos las reglas del udev al grupo que hemos creado.

echo "BUS==\"usb\", ATTRS{idVendor}==\"0694\", GROUP=\"lego\", MODE=\"0660\"" > /tmp/70-lego.rules && sudo mv /tmp/70-lego.rules /etc/udev/rules.d/70-lego.rules

Reiniciamos el udev.

sudo restart udev

13

Cerramos el terminal y abrimos uno nuevo.

Segundo paso.- Configuramos los repositorios de Ubuntu.

En System Settings ingresamos en Software Sources. En la pestaña Ubuntu Software, buscamos el combo box Download From y seleccionamos la opción Main server. Esto nos habilitará la descarga de los archivos necesarios para ROS.

Tercer paso.- Instalar las listas source.list

Ya que tenemos instalada la version de Ubuntu 11.10 Oneiric:

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu oneiric main" > /etc/apt/sources.list.d/ros-latest.list'

Cuarto paso.- Instalamos las llaves

wget http://packages.ros.org/ros.key -O - | sudo apt-key add –

Quinto paso.- Instalamos ROS NXT

sudo apt-get update sudo apt-get install ros-electric-nxtall

14

Antes de empezar, debemos comprobar que existe comunicación entre el brick y ROS. Para probar, abrimos una terminal:

roscore

En otra terminal ingresamos uno de las dos lineas siguientes:

Para probar el sensor touch:

rosrun nxt_python touch_sensor_test.py

Para probar el sensor de color:

rosrun nxt_python color_sensor_test.py

Si al ejecutar el código del sensor touch o de color nos aparece el siguiente mensaje:

nxt.locator.BrickNotFoundError

Es porque no hay conexión entre el brick y ROS. Por lo general, es debido a problemas de firmware no actualizado en el brick o, si se tiene una computadora con dual-boot entre Windows y Ubuntu, no están los drivers instalados.

En caso de que su máquina solo corra Ubuntu, trate reiniciando el sistema ó realizar las actualizaciones recomendadas por LINUX. Ojo, no actualizar el sistema operativo en sí, recordemos que necesitamos Ubuntu hasta la versión 11.10.

Problemas encontrados

Fue necesario actualizar el firmware del brick a una versión superior al 1.28 además los driver del mismo deber ser instalados en Windows para que el sistema operativo Ubuntu pueda reconocerlo y así poder utilizarlos con ROS. Para poder realizar el procedimiento de actualización del firmware descargue desde http://mindstorms.lego.com/en-US/News/ReadMore/Default.aspx?id=351333 el programa LEGO® MINDSTORMS® software y luego descargue el firmware 1.31 desde http://mindstorms.lego.com/en-us/Support/Files/Default.aspx Firmware. Una vez instalado el software proceda a instalar el firmware en su brick para ello es necesario además tener el cable USB.

Debido a que se instaló otro sistema operativo es necesario tener cuidado con los dispositivos instalados en Windows en especial los dispositivos bluetooth y Wireless ya que al desactivarlos desde Ubuntu no aparecerán en Windows.

15

Antes de empezar a programar nuestro robot, debemos crear un paquete, ahí colocaremos todo lo que nuestro proyecto necesita.

Si creamos el paquete como nos indica la página: http://www.ros.org/wiki/nxt_ros/Tutorials/Getting%20started no podremos crear nuestro paquete, ya que ROS-Electric se instaló en la carpeta /opt/, y esta carpeta no puede ser modificada.

Entonces, debemos crear una carpeta local de overlay en /home/ que sí podemos modificar.

CREANDO LA CARPETA OVERLAY

No debemos tratar de modificar la carpeta /opt/ros/. Crearemos una carpeta ros_overlay en /home/. Seguimos los siguientes pasos:

sudo apt-get install python-pip sudo pip install -U rosinstall source /opt/ros/electric/setup.bash rosws init ~/ros_overlay /opt/ros/electric mkdir ~/ros_overlay/sandbox source ~/ros_overlay/setup.bash rosws set ~/ros_overlay/sandbox

Abrimos ~/.bashrc y cambiamos la última línea:

source /opt/ros/electric/setup.bash

Por:

source ~/ros_overlay/setup.bash

Ya que tenemos el lugar donde trabajar, ros_overlay, ahora sí podremos crear los paquetes para los proyectos de ROS NXT. Estos los crearemos en la carpeta sandbox.

CREANDO PAQUETES ROS NXT

Para crear un paquete:

cd ~/ros_overlay/sandbox roscreate-pkg nxt_prueba rospy nxt_ros cd ~/ros_overlay/sandbox/nxt_prueba rosmake

nxt_prueba es el nombre del paquete que creamos, rospy y nxt_ros son las dependencias que nuestro paquete tiene,

Para verificar que nuestro paquete fue creado de manera correcta:

roscd nxt_prueba

roscd hace exactamente lo mismo que el comando cd pero con la particularidad que accede solamente a los paquetes de ROS.

16

PRIMER PROGRAMA EN ROS-NXT

Ya que tenemos todo lo necesario para crear nuestros proyectos y paquetes de ROS-NXT, iniciaremos con un pequeño programa, éste obtendrá el valor del sensor touch (TRUE/FALSE) y lo presentará por pantalla.

Primero, crearemos el paquete prueba_nxt:

source ~/ros_workspace/setup.bash cd ros_workspace cd sandbox roscreate-pkg prueba_nxt rospy nxt_ros cd prueba_nxt rosmake

Para comprobar que fue correctamente creado, salimos de la terminal y volvemos a abrirla:

source ~/ros_workspace/setup.bash roscd prueba_nxt

Ahora vamos al directorio del proyecto /home/ros_workspace/prueba_nxt y creamos un archivo de texto robot.yaml y otro con nombre robot.launch.

En robot.yaml irán, por así describirlo, las estructuras de los elementos que vamos a usar. En este archivo escribiremos:

nxt_robot: - type: touch frame_id: touch_frame name: my_touch_sensor port: PORT_1 desired_frequency: 20.0

En cambio, robot.launch es el encargado de ejecutar ROS-NXT. Aquí escribiremos:

<launch> <node pkg="nxt_ros" type="nxt_ros.py" name="nxt_ros"

output="screen" respawn="true"> <rosparam command="load" file="$(find

prueba_nxt)/robot.yaml" /> </node> </launch>

Lo que hace es llamar a nxt_ros.py del paquete nxt_ros, por eso al crear el paquete prueba_nxt hicimos referencia a nxt_ros.

Para probar el programa, en la terminal:

Roslaunch robot.launch

Para ver la salida del sensor touch, en otra terminal:

Rostopic echo my_touch_sensor

17

DESARROLLO DEL PROYECTO

Este proyecto está enfocado en programar un robot que evita obstáculos usando las librerías de ROS.

Para esto, primero armamos el siguiente robot:

Creamos un workspace en home /ros_workspace/. Luego creamos nuestro package para el proyecto en ~/ros_workspace/sandbox/ con nombre /proyecto_us/. Por favor seguir los pasos descritos anteriormente.

Debemos tener el archivo robot.launch en la raíz del proyecto. Éste debe lucir así:

18

Este archivo *.launch nos indica los nodos que usaremos. Algunos son ya definidos por ROS (nxt_ros) y otros serán creados por nosotros (sensor_test.py).

El código que usaremos es el siguiente:

Este programa importa el dato range de la librería nxt_msgs.msg. Este dato es de tipo float y retorna la distancia entre el sensor y el obstáculo.

Lógica del programa:

19

Si el sensor detecta un obstáculo a menos de 0.30, este girará a la derecha; caso contrario, seguirá de frente. El comando pub.publish(“l_wheel_joint”, float) es el encargado de enviar la velocidad deseada al motor izquierdo, en cambio pub.publish(“r_wheel_joint”, float) hará lo mismo pero para el motor derecho.

Luego se define a sensor_test como listener y a su suscriptor ultrasonic_sensor, que nos servirá si deseamos ver en tiempo real, por consola, el valor que retorna el sensor.

Aquí podremos ver el procedimiento para correr el programa.

20

Conclusiones:

Sin dudas, ROS es una herramienta que tiende a imponerse a nivel mundial en la programación de robots, ya que es OpenSource y tiene muchos colaboradores que siguen desarrollando librerías para las plataformas robóticas existentes, así como el uso en otros Sistemas Operativos.

ROS está basado en programación orientada a objetos, facilitando el uso y programación de los algoritmos de control de robots.

ROS utiliza lenguaje de bajo nivel, es decir, controlan directamente el hardware. ROS-NXT proporciona casi todas las herramientas necesarias para controlar el brick y

sensores compatibles con LEGO MINDSTORMS 2.0. Con un poco de imaginación se pueden desarrollar experimentos muy interesantes.

La herramienta Gazebo proporciona un entorno de simulación para probar diseños y código.

Recomendaciones:

Seguir paso a paso el proceso de instalación para evitar errores en un futuro y evitar molestas reinstalaciones.

Acoger los consejos para el correcto funcionamiento del brick NXT como:o Actualizar el firmware (posterior a v1.28)o Instalar los drivers.o Si se tiene dual-boot en el computador, conectar el brick en Windows para que

se instalen los drivers al conectarlo al puerto USB.o Cada que se intente ejecutar roslaunch asegurarse que el brick esté

encendido.o Tener cargado el brick, es decir, no dejar que se batería “muera” por

completo. Si esto sucede, cargar completamente la batería. Para los próximos cursos de Fundamentos de Robótica, dar más detalles acerca de ROS

como: creación de workspace, packages, nodes, scripts, srv, etc. Estos son componentes muy importantes para el correcto funcionamiento de ROS.

Considerar que muchos estudiantes no han programado en Python, no han usado otro sistema operativo además de Windows. Estos son algunos inconvenientes que tomaron mucho tiempo en solucionar y por ende, menos tiempo en el desarrollo del proyecto.

21