UNIVERSIDAD DE FUERZAS ARMADAS - ESPE

DEPARTAMENTO DE CIENCIAS DE LA ENERGÍA Y MECÁNICA

CARRERA DE INGENIERÍA MECATRÓNICA

ROBOTICA INDUSTRIAL

“PRÁCTICAS ROS (ROBOTIC OPERATING SYSTEM)”

NOMBRE

Chimbo Romero Jaime Roberto

08 de Noviembre del 2017

SANGOLQUÍ – ECUADOR
Contenido

1. TEMA: ......................................................................................................................................3
ROS (Robot Operating System) .........................................................................................................3
2. OBJETIVOS:............................................................................................................................3
3. INTRODUCCIÓN....................................................................................................................3
4. MARCO TEÓRICO.................................................................................................................3
4.1. ROS ...................................................................................................................................3
4.2. PYTHON...........................................................................................................................4
5. DESARROLLO ........................................................................................................................6
5.1. EJERCICIO 1...................................................................................................................6
5.1.1. DESARROLLO EJERCICIO 1 ..................................................................................6
5.2. EJERCICIO 2.................................................................................................................10
5.2.1. DESARROLLO EJERCICIO 2 ................................................................................10
5.3. EJERCICIO 3.................................................................................................................14
5.3.1. DESARROLLO EJERCICIO 3 ................................................................................14
6. CONCLUSIONES ..................................................................................................................17
7. RECOMENDACIONES ........................................................................................................17
8. BIBLIOGRAFÍA ....................................................................................................................17
1. TEMA:

ROS (Robot Operating System)

2. OBJETIVOS:
- Conocer la funcionalidad de ROS mediante la práctica e investigación para su
posterior aplicación en sistemas robóticos

- Resolver diversos problemas planteados desarrollando los algoritmos

adecuados que cumplan con los requerimientos del problema.

3. INTRODUCCIÓN
Escribir software para robots es difícil, particularmente cuando la escala y alcance
de la robótica sigue creciendo. Diferentes tipos de robots pueden tener hardware
muy variable, haciendo la reutilización del código no trivial. Además de esto, el
tamaño del código requerido puede ser desalentador, ya que puede ir de algo tan
simple como un software a nivel de controlador y continuar hasta a través de la
percepción, el razonamiento abstracto y más allá. Desde que existe este amplio
requerimiento, las arquitecturas de software de robótica deben también ser
compatibles en una integración de software a gran escala.

ROS es el producto de las concesiones y priorizaciones hechas durante su ciclo de

diseño. Su énfasis en la integración a gran escala de la investigación en robótica
será útil en una amplia variedad de situaciones a medida que los sistemas robóticos
se vuelven cada vez más complejos. [1]

4. MARCO TEÓRICO

4.1. ROS

El Robot Operating System (ROS) es un conjunto de bibliotecas de software

y herramientas que lo ayudan a crear aplicaciones de robots. Desde los
controladores hasta los algoritmos de última generación y con potentes
herramientas de desarrollo y es todo de código abierto.
 ROS (Robot Operating System) provee librerías y herramientas para ayudar a
los desarrolladores de software a crear aplicaciones para robots. ROS provee
abstracción de hardware, controladores de dispositivos, librerías, herramientas
de visualización, comunicación por mensajes, administración de paquetes.
ROS está bajo la licencia open source, BSD.

Las áreas que incluye ROS son:

Un nodo principal de coordinación.

Publicación o subscripción de flujos de datos: imágenes, estéreo, láser,
control, actuador, contacto.
Multiplexación de la información.
Creación y destrucción de nodos.
Los nodos están perfectamente distribuidos, permitiendo procesamiento
Distribuido en múltiples núcleos, multiprocesamiento, GPUs y clústeres.
Login.
Parámetros de servidor.
Testeo de sistemas.

Ilustración 1. Logotipo ROS

4.2. PYTHON

Python es un lenguaje de programación de alto nivel, interpretado y

multipropósito. Es un lenguaje de programación que permite trabajar de
manera más rápida e integrar sistemas con mayor eficiencia.
 Ilustración 2: Logotipo PYTHON

Las principales características del lenguaje son

Propósito general

Se pueden crear todo tipo de programas. No es un lenguaje creado

específicamente para la web, aunque entre sus posibilidades sí se encuentra el
desarrollo de páginas.

Multiplataforma

Hay versiones disponibles de Python en muchos sistemas informáticos

distintos. Originalmente se desarrolló para Unix, aunque cualquier sistema es
compatible con el lenguaje siempre y cuando exista un intérprete programado
para él.

Interpretado

Quiere decir que no se debe compilar el código antes de su ejecución. En

realidad sí que se realiza una compilación, pero esta se realiza de manera
transparente para el programador. En ciertos casos, cuando se ejecuta por
primera vez un código, se producen unos bytecodes que se guardan en el
sistema y que sirven para acelerar la compilación implícita que realiza el
intérprete cada vez que se ejecuta el mismo código.

Interactivo

Python dispone de un intérprete por línea de comandos en el que se pueden

introducir sentencias. Cada sentencia se ejecuta y produce un resultado visible,
que puede ayudarnos a entender mejor el lenguaje y probar los resultados de
la ejecución de porciones de código rápidamente.
 Orientado a Objetos

La programación orientada a objetos está soportada en Python y ofrece en

muchos casos una manera sencilla de crear programas con componentes
reutilizables.

Funciones y librerías

Dispone de muchas funciones incorporadas en el propio lenguaje, para el

tratamiento de strings, números, archivos, etc. Además, existen muchas
librerías que podemos importar en los programas para tratar temas específicos
como la programación de ventanas o sistemas en red o cosas tan interesantes
como crear archivos comprimidos en .zip.

Sintaxis clara

Por último, destacar que Python tiene una sintaxis muy visual, gracias a una
notación identada (con márgenes) de obligado cumplimiento. En muchos
lenguajes, para separar porciones de código, se utilizan elementos como las
llaves o las palabras clave begin y end. Para separar las porciones de código
en Python se debe tabular hacia dentro, colocando un margen al código que
iría dentro de una función o un bucle. Esto ayuda a que todos los
programadores adopten unas mismas notaciones y que los programas de
cualquier persona tengan un aspecto muy similar.

5. DESARROLLO

5.1. EJERCICIO 1

Realizar un nodo que permita comunicar el joystick con el nodo turtlesim

5.1.1. DESARROLLO EJERCICIO 1

Para poder utilizar el joystick se requiere instalar el paquete joy en ros para lo cual
se ingresa el comando
sudo apt-get install ros-kinetic-joy

Procedemos a verificar que el joystick es reconocido por Ubuntu para lo cual

ingresamos el siguiente comando, se podrá observar q el dispositivo se encuentra
referido hacia js0
ls /dev/input/

Ilustración 3.Dirección del Joystick

Se verifica que el joystick este accesible para el nodo joy de ROS para lo cual se
ingresamos
ls -l /dev/input/js0

El mensaje debera ser similar al siguiente

rw-rw-XX- 1 root dialout 188, 0 2009-08-14 12:04 /dev/input/jsX

Siendo que

Si XX es rw: indica que el dispositivo se encuentra configurado

correctamente

Si XX es --: el dispositivo no se encuentra configurado correctamente

Si el dispositivo no se encuentra bien configurado procedemos a ingresar:

sudo chmod a+rw /dev/input/js0

Una vez configurado el dispositivo procedemos a crear un paquete catkin

ingresando primero a catkin_ws/src
$ cd ~/catkin_ws/src
 Ingresamos catkin_create_pkg con el nombre del paquete y las dependencias que
tendrá
$ catkin_create_pkg learning_joy rospy roscpp turtlesim joy

Nos dirigimos a catkin_ws y procedemos a colocar catkin_make creando nuestro

paquete
$ cd ~/catkin_ws/
$ catkin_make

Ingresamos a learning_joy/src para poder crear nuestro programa en python

mediante:
$ roscd learning_joy/
$ cd src
$ gedit startjoy.py

En la ilustración 4 se puede observar el archivo creado en python llamado

startjoy.py

Ilustración 4. Programa para nodo del Joystick

El archivo creado tiene la finalidad de crear un nodo que lee las entradas del joystick
desde el nodo joy, para convertirlos en comandos twist modificando el topic
turtle1/cmd_vel y permitiendo el control de turtlesim a través del joystick.
Creado el archivo lo hacemos ejecutable y procedemos a ejecutar los nodos
correspondientes al funcionamiento de turtlesim.

Primero procedemos a ejecutar el roscore y en un terminal nuevo

inicializamos el nodo joy para tener los datos de entrada del dispositivo
como se puede ver en la ilustración 5

Ilustración 5: Inicialización del nodo Joy

Consecuentemente se requiere iniciar el Turtlesim_node en un terminal nuevo

Ilustración 6: Inicialización nodo Turttlesim

Una vez inicializados los nodos de la tortuga y el joystick es necesario un nodo

que permita comunicarlos para lo cual ejecutamos el archivo startjoy.py en un
nuevo terminal permitiendo la conexión entre los nodos anteriormente
inicializados como se puede observar en la ilustración 7 el control del
turtlesim.
 Ilustración 7: Control Turtlesim con Joystick

5.2. EJERCICIO 2

Elaborar un programa que permita la publicación de un arreglo de 3 números

randómicos que puedan ser elevados al cuadrado y sumados entre sí en 3 nodos
diferentes

5.2.1. DESARROLLO EJERCICIO 2

El primer nodo tiene como finalidad generar una matriz con 3 números randómicos
enteros para lo cual procedemos a generar un talker que permita publicar el arreglo.
Creamos un archivo.py llamado talkerd1.py en el cual formamos un arreglo numpy
con números randómicos y la publicamos en el topic matriz.
 Ilustración 8: Ejercicio 2 nodo 1

La función del segundo nodo será la de leer la matriz publicada por el primero, elevar
cada término del arreglo al cuadrado y publicar el resultado.
En la ilustración 9 se puede observar el archivo.py que permite realizar la función
requerida reconociendo el topic matriz para descomponerlo y elevar cada uno de sus
términos al cuadrado, posteriormente crea un nuevo arreglo numpy y lo pública en un
nuevo topic llamado matriz2 con los valores obtenidos por la operación
 Ilustración 9: Ejercicio 2 nodo 2

El tercer nodo se encarga de receptar la información de los términos elevados al

cuadrado y sumarlos.
En la ilustración 10 se observa el archivo.py que toma como dato el arreglo numpy
publicado en el topic matriz2, lo descompone y suma sus términos para publicar el
resultado.
 Ilustración 10: Ejercicio 2 nodo 3

En la ilustración 11 se ve el resultado de correr los nodos creados, al lado inferior

izquierdo se encuentra corriendo el primer nodo generando matrices con números
randómicos, al lado superior derecho se observa la matriz randómica generada con los
términos elevados al cuadrado y en la parte inferior derecha el resultado de la suma de
los términos de la matriz generada con el segundo nodo.
 Ilustración 11: Ejecución del ejercicio 2

5.3. EJERCICIO 3

Elaborar un programa que permita el ingreso de datos por consola y los almacene
dentro de un archivo .txt mediante la utilización de dos nodos

5.3.1. DESARROLLO EJERCICIO 3

El ejercicio se encuentra conformado por dos nodos para ingresar datos y ser
guardados en un archivo.txt
En la lustración 12 se puede observar el archivo.py en el cual creamos el primer nodo
para solicitar información al usuario mediante la consola.
Mediante un while y un condicional if se solicita dato por dato y se los va publicando
independientemente.
 Ilustración 12: Ejercicio 3 nodo 1

Se observa en la ilustración el programa que me permite leer los datos generados en

pantalla por el primer nodo para almacenarlos en el archivo InformacionAlumno.txt
con atributo “a” para seguir ingresando la información hacia abajo en el archivo .txt
mientras se sigan generando.

Ilustración 13: Ejercicio 3 nodo 2

Procedemos a correr los ejecutables conjuntamente con roscore

 Ilustración 14: Ejecución Ejercicio 3

Se puede observar el archivo InformacionAlumno.txt que se genera

automáticamente con los datos ingresados por consola.

Ilustración 15: Archivo.txt generado Ejercicio 3

6. CONCLUSIONES

Se comunicó los datos de entrada del joystick con el turtlesim mediante la

lectura del topic joy y transformando los datos mencionados a twist, dato
que puede controlar el movimiento de turtlesim.

El ejercicio número dos fue realizado mediante la utilización de librerías

como random y numpy para poder hacer uso de arreglos numpy con
números float, esto debido a la facilidad con la que se puede publicar y
suscribir este tipo de arreglos de nodo a nodo para realizar las operaciones
requeridas.

Se cumplió con el objetivo del ejercicio número 3 que gracias a la

posibilidad de crear un archivo .txt con python podemos almacenar
grandes cantidades de información ingresando datos mediante la pantalla
simplemente publcando y suscribiendo datos tomando en cuenta el tipo de
datos que se envía y recibe.

7. RECOMENDACIONES
Se debe tener especial cuidado con los archivos que se modifican dentro
de cada paquete para no tener problemas con los programas.

Tener en cuenta siempre el tipo de dato que requerimos para trabajar en

los distintos nodos, esto permitirá una comunicación más adecuada y
permitirá optimizar el código de programación.

8. BIBLIOGRAFÍA

[1] Quigley, M., Conley, K., Gerkey, B., Faust, J., Foote, T., Leibs, J., ... &
Ng, A. Y. (2009, May). ROS: an open-source Robot Operating System. In
ICRA workshop on open source software (Vol. 3, No. 3.2, p. 5).

[2] Rossum, van Guido. (2009). El tutorial de PYTHON