INTRODUCCIÓN A LA PROGRAMACIÓN EN ROS

Darlin Estrada, Carlos Holguin, Edwin Ruiz

Facultad de Ingeniería, Universidad de Antioquia

Medellín - Colombia

[email protected]

[email protected]

[email protected]

RESUMEN

En el actual informe se presentan los resultados obtenidos en la segunda práctica del curso Robótica
Industrial, allí se afianzaron conceptos fundamentales de ROS que ya habían sido abordados y se
tocaron otros nuevos tales como mensajes y servicios.
Primero que todo se plantea una base teórica en la que se definen términos de vital importancia en el
manejo de ROS, luego de esto se realiza el desarrollo de la parte experimental indicando paso a paso lo
que se pide en la guía de laboratorio, adicional se adjuntan las respectivas capturas. Finalmente, a partir
de los resultados obtenidos se realiza una serie de conclusiones.

PALABRAS CLAVES
Tópico, mensaje, servicio, nodo, robótica

ABSTRACT

In the current report, the results obtained in the second practice of the Industrial Robotics
course are presented, there fundamental concepts of ROS that have already been addressed
were consolidated and other new stories such as messages and services were played.
First of all, a theoretical basis is proposed in which terms of vital importance in the
management of ROS are defined, after this the development of the experimental part is
carried out indicating step by step what is requested in the laboratory guide, additional is
attach the respective captures. Finally, based on the results obtained, a series of conclusions
is made.
 1. INTRODUCCIÓN

Actualmente, el uso de los robots ha tomado demasiada fuerza con la gran característica de que
poseen múltiples campos de aplicación y operación. Desde las industrias hasta las oficinas
podemos encontrar actividad de estos seres artificiales; sin embargo, siempre ha existido una
variable con la que los ingenieros han batallado buscando mejorar. Cómo hacer que estos
seres piensen y actúen más como humanos y no como simples máquinas. La respuesta,
mediante la programación, con un sistema operativo llamado ROS.

La programación es relevante porque hace que los robots ejecuten tareas complejas sin más
contratiempo. El problema con esto radica en la complejidad de la tarea misma, es decir
mientras más difícil y/o laboriosa fuese la actividad, la codificación es un dolor de cabeza
para el desarrollador. Eso sin contar con los múltiples problemas de compatibilidad de
hardware que siempre se llegan a encontrar cuando queremos implementar características
adicionales a nuestro robot. Con todo esto en mente, en 2007 se desarrolló en la Universidad
de Stanford el proyecto switchyard ahora conocido como ROS (Robotic Operating System).
[1]

2. MARCO TEÓRICO

Se definirán conceptos propios de ROS que serán utilizados en el desarrollo de la actual práctica.

ROS: ROS se describe como un framework (entorno de trabajo) flexible, con una amplia
variedad de herramientas, librerías y paquetes que busca la creación de software complejo
para tener robots robustos y con un comportamiento variado.

msg : los archivos msg son simples archivos de texto que describen los campos de un
mensaje ROS. Se usan para generar código fuente para mensajes en diferentes tipos de
lenguajes.

srv : un archivo srv describe un servicio. Está compuesto de dos partes: una solicitud y una
respuesta.

Ficheros ROS:
Packages: son la unidad principal de organización de software. Pueden contener procesos
ROS, librerías, datos, archivos de configuración o cualquier agrupación de información
coherente.

Manifests: archivos XML que contienen información sobre packages (información de licencia,
dependencias, etc).

Stacks: colecciones de packages relacionados que aportan funcionalidad agregada.

Stack Manifest: archivos XML que contienen información sobre stacks.

Message types: estructuras de mensajes ROS

Service types: descripciones de servicios (definición de estructuras de peticiones y

respuestas).

Conceptos estructura de ROS:

Nodes(nodos): procesos normalmente diseñados de manera modular, de modo que un

sistema está formado por diversos nodos, cada uno con una funcionalidad concreta. La
programación de nodos ROS se realiza usando librerías cliente ROS, como roscpp (C++),
rospy (Python) o roslisp (LISP).

Master: proceso con funcionalidades de registro y consulta a los nodos. Permite que estos se
encuentren y se comuniquen.

Parameter Server: almacén centralizado de datos. Es parte del máster.

Messages: datos con una estructura determinada intercambiados entre nodos.

Topics: mecanismos de difusión de mensajes. Uno o varios nodos publican mensajes en

determinado topic al que otros nodos pueden suscribirse. Permite desacoplar producción y
consumo de información. Los nodos consumidores de un topic no necesitan saber de los que
publican.

Services: mecanismos de comunicación de mensajes de tipo petición/ respuesta.

Bags: formatos para el almacenamiento y reproducción de mensajes

3. METODOLOGÍA

Ejercicio 1.

Planteamiento

Crear una red de comunicación entre 3 nodos; los cuales permitan, como primer requisito
generar un vector de 3 números agregados de manera aleatoria, que posteriormente sean
elevados al cuadrado y puedan ser visualizados, además es necesario que un nuevo nodo genere
la suma de los números que componen este último vector.

Solución

En un principio se crea la carpeta contenedora por medio del comando mkdir, después se
inicializa el espacio de trabajo haciendo uso de catkin_init_workspace, posterior a ello se
compila con el comando catkin_make.
A continuación, se muestra dicha ejecución.

Ahora, se crea un paquete que contendrá las variables de entorno a partir de la utilización del
comando catkin_create_pkg, después, se crea un archivo llamado Ejer1.msg por medio del
comando touch dentro de una carpeta llamada msg contenida dentro del mencionado paquete.
Posterior a esto, se le da permisos y se hace ejecutable a Ejer1.msg con el comando chmod a+x.
A continuación se muestra el procedimiento mencionado.

Ahora, se hacen las modificaciones pertinentes a CMakelist.txt y package.xml para permitir la

compilación y se ejecuta catkin_make para compilar.

Ya habiendo realizando todo lo anterior, se verifica si el servicio se ha generado correctamente

a partir de la utilización del comando rosmsg show, no sin antes haber ejecutado ROS por
medio de otra terminal con el comando roscore.
Posterior a la verificación, se crea un paquete en el espacio de trabajo con dependencias. Se
compila este espacio recién creado, se crea un archivo Nod1ejer1.py y se hace ejecutable. A
continuación se muestra lo expuesto anteriormente.

Se modifica el código de Nod1ejer1.py y se crea un archivo Nod2ejer1.py, el cual, al igual que

el primero, se hará ejecutable y se modifica el código contenido. Mismo procedimiento para
Nod3ejer1.py.

Posterior a ello, se ejecutan los tres nodos a partir del comando rosrun. Se obtiene, para el
primer nodo, vectores de 3 números aleatorios del 1 al 9, para el segundo nodo, vectores que
contienen el cuadrado de las componentes del anterior vector y por último, para el tercer nodo,
se obtuvo la suma de las componente del vector justamente anterior, es decir, el resultante en el
segundo nodo.

Ejercicio 2.

Planteamiento

Generar un programa que permita el ingreso de datos de personas, es decir el ingreso de su

nombre, apellido, edad, preferencias por la robótica, y preferencias por ROS; con la finalidad de
enviar este registro hacia un nodo posterior que imprima estos datos y pueda crear un archivo de
texto en base a los mismos.

Solución

Se crea un mensaje para mostrar que estará contenido en Ejer2.msg, posteriormente se crean
dos nodos, Nod1ejer2.py y Nod2ejer2.py, que serán tipo publicador y suscriptor
respectivamente. Se les hace ejecutable para
posteriormente ser codificados de manera pertinente.
Posterior a ello, se ejecuta nodo 1 y se introducirán los datos a proporcionar, ya finalizado este
proceso, se ejecuta el nodo 2 y se puede observar la impresión de los datos proporcionados
anteriormente.

Ejercicio 3.

Planteamiento

Se pretende establecer una comunicación entre servicios de ROS y primero vamos a crear un
servicio que realizará una operación de suma de dos números enteros el cual consistirá en pasar
de dos números enteros desde el cliente al servidor y éste realizará la operación de suma y
retornará el resultado correspondiente.

Solución

Se crea un servicio en ROS definiendo sus entradas y salidas de comunicación en un archivo de

definición de servicios que se llamará SumaTwoInts.srv dentro de una carpeta llamada srv
contenida en el paquete Lab2, el cual contendrá a y b (int 64) como entrada y sum (int 64) como
salida.

Posteriormente, se modifica de manera pertinente a CMakeLists.txt, agregando el nombre del

archivo de definición de servicio SumaTwoInts.srv.
Ahora, para generar los mensajes y servicio se utiliza en las dependencias, la palabra reservada
std_msgs. Luego, se compila el nuevo paquete estando dentro del espacio de trabajo.

Ahora, se verifica la correcta generación del servicio por medio del comando rossrv show, no
sin antes haber ejecutado en otra terminal el comando roscore.
A continuación se muestra lo obtenido después de esta ejecución.
Se crea el servicio servidor de ROS a través del comando node_service_server.py, después se
hace ejecutable y se introduce el código pertinente. Posterior a ello, se ejecuta el servicio
servidor, para esto, en principio ejecutamos roscore y después rosrun. A continuación se
muestra lo mencionado.

Ahora, con el fin de garantizar el funcionamiento correcto del servicio, se ejecuta el comando
rosservice list y posteriormente el comando rosservice info para mostrar la información del
servicio. Posterior a esto, se hace el llamado al servicio y se prueba su funcionamiento a través
de rosservice call y el digitalizado de dos números para ser sumados. A continuación se exhibe
la verificación, la información y el funcionamiento óptimo.

Se crea el servicio cliente node_service_cliente.py y se le introduce un código que le permite

proporcionar dos números, entre otras cosas. Se hace ejecutable dicho servicio cliente y se
ejecuta roscore.

Con el fin de confirmar si el servicio servidor está listo para realizar la suma, se ejecuta dicho
nodo por medio de rosrun, obteniendo como resultado lo siguiente.
 Ya teniendo certeza del funcionamiento de servicio servidor, se ejecuta el servicio cliente de la
misma forma que se acaba de ejecutar el servicio servidor, es decir, con rosrun y se obtiene
como resultado la respuesta de la suma de los números proporcionados a través del cliente.

Ejercicio 3.

Planteamiento
Se pretende establecer una comunicación entre ROS y un dispositivo externo, en este caso un
joystick que funcione en modo teleoperado y de esta manera poder controlar los movimientos
de la tortuga perteneciente al nodo Turtlesim.

Solución

Primero se instalan los drivers necesarios por medio del comando $sudo apt-get install ros-
kinetic-joy, el cual instala los drivers para el funcionamiento del joystick y su comunicación
con ROS.

Para la configuración, primero se conecta el joystick y se verifica su reconocimiento a través de

ls /dev/input, después se verifica si se encuentra funcionando de manera correcta a través del
comando jstest y por último se corrobora la lectura correcta de datos y se le asigna una entrada
al joy_node y se inicia para establecer la comunicación entre ros y el joystick.

A continuación se muestra la ejecución de lo anteriormente mencionado.

4. RESULTADOS

Resultados obtenidos en el ejercicio 1.

La ejecución del nodo Nod1ejer1.py, se obtuvo como resultado 3 números aleatorios del 1 al 9.
A continuación se muestra
La ejecución del nodo Nod2ejer1.py, se obtuvo como resultado el cuadrado de los vectores de 3
números resultantes del nodo 1. A continuación se muestra.

La ejecución del nodo Nod3ejer1.py, se obtuvo como resultado la suma de los vectores de 3
números resultantes del nodo 2. A continuación se muestra.

Resultados obtenidos en el ejercicio 2.

La ejecución de este primer nodo, es decir, Nod1ejer2.py, tiene como resultado el requerimiento
de ciertos datos, a continuación se muestra los datos requeridos e introducidos.

La ejecución del nodo Nod2ejer2.py, muestra los datos proporcionados en el primer nodo,
exhibiendo una comunicación entre el nodo publicador y el suscriptor.
Resultados obtenidos en el ejercicio 3.

A continuación se presenta el resultado obtenido a partir de la comunicación entre servicios de

ROS cliente y servidor, que corresponde a la suma por parte del servidor de los datos
proporcionados por el cliente.

Resultados obtenidos en el ejercicio 4.

A continuación se presentan los resultados obtenidos en la comunicación entre el joystick y

ROS, haciendo uso de turtlesim. Tanto la terminal con los valores de Joy ante la interacción con
el joystick como el simulador turtlesim como respuesta a la interacción mencionada.
5. CÓDIGOS

Cuestionario

1) Para cada uno de los ejercicios anteriores realizar un análisis de los nodos con la herramienta
rqt_graph.

Ejercicio 1
 Podemos observar como el nodo Nod1ejer1 publica sus mensajes al topic1, seguidamente el
nodo Nod2ejer1 escucha los mensajes ya que está suscrito al topic1. Nod2ejer1 también publica
sus mensajes al topic2 y Nod3ejer1 está suscrito al topic2.

Ejercicio 2

Nod1ejer2 publica sus mensajes a topic y Nod2ejer2 está suscrito a los mensajes de topic.

Ejercicio 3

Para este ejercicio el nodo se ejecuta como un servicio, observamos que no se hace uso de
suscriptores, publicadores o tópicos, solo hacemos llamado del nodo servidor en otro nodo
cliente.

Ejercicio 4

El nodo joy_node publica sus mensajes al tópico Joy, el nodo Joy está suscripto al tópico Joy y
el nodo Joy publica sus mensajes al tópico turtle1/cmd_vel, donde el nodo turtlesim esta
suscrito al tópico turtle1/cmd_vel.

2) Dar un ejemplo práctico del uso de cada una de las herramientas mensajes y servicios.
Ejemplo mensajes:
Se tienen tres nodos, el primero nodo entrega información del sensor de proximidad de un robot
que se acerca a un obstáculo, el segundo nodo recibe esta información y la procesa para hacer el
cálculo de qué tan cerca está el robot del obstáculo y toma decisión de si frenar el robot o
hacerlo girar en otra dirección, además pública dependiendo de la decisión tomada información
 acerca de si detener el motor del robot o darle giro en otra dirección. El tercer nodo recibe la
información del segundo nodo y la aplica al motor directamente.
Ejemplo servidor:
Transportar datos desde un robot hacia un computador remoto.

3) Describir las ventajas y desventajas de uso de mensajes y servicios en ROS

Mensajes
Admiten diferentes tipos de datos como enteros, punto flotante, booleano, matrices y
estructuras, lo que permite una comunicación muy flexible, pero su transporte unidireccional de
muchos a muchos no es apropiado para las interacciones de solicitud / respuesta de RPC, que a
menudo se requieren en un sistema distribuido[4].

Servicios
Un cliente puede realizar una conexión persistente a un servicio, lo que permite un mayor
rendimiento a costa de una menor solidez a los cambios de proveedor de servicios[4].

4) Listar todos los comandos usados en el laboratorio y el para qué sirven.

A continuación se muestran y definen los comandos utilizados en el laboratorio

cd – Moverse entre carpetas

mkdir - Crea un nuevo subdirectorio o carpeta del sistema de archivos
catkin_make - Agrega configuraciones necesarias para el workspace y compila
catkin_init_workspace - Inicia un nuevo espacio de trabajo
catkin_create_pkg - Crea un paquete que contendrá las variables de entorno para ROS
roscd - Permite movernos directamente a los directorios de los paquetes
touch - Crea archivos
chmod - Permite cambiar los permisos de acceso de un fichero o directorio, volviendolos
ejecutables.
rosmsg show - Muestra información sobre los tipos de mensajes ROS.
roscore - Ejecuta a ROS, se pone en marcha el servidor de parámetros y rosout que es el log
donde podemos mostrar datos para depuración entre otros.
rosrun - Ejecuta la aplicaciones contenida en el paquete actual
rossrv show - Imprime el contenido del servicio, también sirve para verificar su existencia.
rosservice list - Lista los servicios activos
rosservice info - Imprime información sobre servicios
rosservice call - Hace un llamado al servicio especificado
rqt_graph - Visualiza los nodos que se están ejecutando en este momento y el paso de tópicos
entre ellos
jstest /dev/input/js2 - Es un probador de joystick, que permite ver la señales de los botones del
joystick y testear si falla alguno.

5) Mejorar el código del nodo Joy del Joystics para del turtlesim para dar un movimiento más
fluido y veloz.
La única mejora que logramos en el código fue en el aumento de la velocidad de la tortuga, el
cual se consigue agregando un factor multiplicador en las líneas 12 y 13.
 6. CONCLUSIONES
- El uso de nodos permite una programación más modular de los robots permitiendo en
caso de errores poderlos encontrar más fácilmente, analizando cada nodo.
- Se dio un mayor entendimiento en el funcionamiento de los mensajes entre los nodos, lo
que hacen para comunicarse es que inicialmente hay un nodo que publica sus mensajes a
un topic, y para que otro nodo lea estos mensajes este debe suscribirse al mismo topic.
Además un mismo nodo puede tanto publicar como suscribirse.
- Para ejecución de las aplicaciones con nodos en ROS siempre debemos ejecutar un nodo
maestro(comando roscore), este permite a los nodos en ROS localizarse unos a otros ya
que este nodo registra todos los nodos, servicios y topics que se encuentran en
ejecución.
- Una de las principales ventajas de ROS radica en que 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. A nivel industrial esto es demasiado útil y puede
contribuir a mejorar los tiempos de ejecución de los procesos y aumentar la
productividad.

7. REFERENCIAS

[1] “ROS - ¿Un sistema operativo diseñado para robots?” Tomado de : http://www.autracen.com/ros/

[2] “Creating a ROS Package” Tomado de: http://wiki.ros.org/ROS/Tutorials/CreatingPackage

[3] Guía de laboratorio - Robótica Industrial 2020_1

[4] “Services” Tomado de: http://wiki.ros.org/Services

joy.py

#!/usr/bin/env python
import rospy
from sensor_msgs.msg import Joy
from geometry_msgs.msg import Twist
#from functool import partial

def callback(data):
global pub
 print data.axes
vel=4
msg = Twist()
msg.linear.x = data.axes[1]*vel
msg.angular.z = data.axes[0]*vel
pub.publish(msg)

def function():
global pub

rospy.init_node('Joy', anonymous=True)
pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)
rospy.Subscriber('joy', Joy, callback)

rospy.spin()
print "---0----"

if __name__ =="__main__":
try:
function()

except rospy.ROSInterruptException:
pass

Nod1ejer1.py

#!/usr/bin/env python

import rospy
from random import randint
from lab2.msg import Ejer1

def function():

pub = rospy.Publisher('topic1',Ejer1, queue_size=10)

rospy.init_node('Nod1ejer1',anonymous=True)
rate = rospy.Rate(10)

while not rospy.is_shutdown():

msg = Ejer1()
msg.ran = [randint(1,9),randint(1,9),randint(1,9)]
print msg.ran
pub.publish(msg)
rate.sleep()

if __name__ =="__main__":
try:
function()
except rospy.ROSInterruptException:
pass

Nod2ejer1.py
#!/usr/bin/env python

import rospy
from lab2.msg import Ejer1

def callback(data):

global pub
vec = []
for x in data.ran:
vec.append(x*x)
print vec
pub.publish(vec)

def function():

global pub
rospy.init_node('Nod2ejer1', anonymous=True)
rospy.Subscriber('topic1', Ejer1, callback)
 pub = rospy.Publisher('topic2', Ejer1, queue_size=10)
rospy.spin()

if __name__ =="__main__":
try:
function()
except rospy.ROSInterruptException:
pass

Nod3ejer1.py

#!/usr/bin/env python

import rospy
from lab2.msg import Ejer1

def callback(msg):
suma = 0
for x in msg.ran:
suma=suma+x
print "suma total:", str(suma)

def function():
rospy.init_node('nod3ejer1', anonymous=True)
rospy.Subscriber('topic2', Ejer1, callback)
rospy.spin()

if __name__ =="__main__":
try:
function()
except rospy.ROSInterruptException:
pass
Nod1ejer2.py
#!/usr/bin/env python
import rospy
from lab2.msg import Ejer2

def function():

pub = rospy.Publisher('topic', Ejer2, queue_size=10)

rospy.init_node('nod1ejer2', anonymous=True)
rate = rospy.Rate(10)
 while not rospy.is_shutdown():
msg = Ejer2()
msg.nombre = raw_input("Ingrese su nombre: ")
msg.apellido = raw_input("Ingrese su apellido: ")
msg.edad = raw_input("Ingrese su edad: ")
msg.robotica = raw_input("Le gusta la robotica:")
msg.ros = raw_input("Le gusta la ROS:")
print ""
print "************************************"
print ""
#print msg
pub.publish(msg)
rate.sleep()

if __name__ =="__main__":
try:
function()
except rospy.ROSInterruptException:
pass

Nod2ejer2.py
#!/usr/bin/env python
import rospy
from lab2.msg import Ejer2
global cont
cont=1

def callback(data):
global cont
print "estudiante No. %s" %cont
print "Nombre: %s" %data.nombre
print "Apellido: %s" %data.apellido
print "Edad: %s" %data.edad
print "%s le guste la robotica" %data.robotica
print "%s le guste ROS" %data.ros
f = open ("Archivo.txt", "a")
f.write("Estudiante No. %s" %cont +'\n')
f.write("Nombre: %s " %data.nombre +'\n')
f.write("Apellidos: %s " %data.apellido +'\n')
f.write("Edad: %s " %data.edad +'\n')
f.write("Le gusta la robotica: %s " %data.robotica +'\n')
 f.write("Le gusta ROS: %s" %data.ros +'\n')
f.close()
cont= cont +1

def function():

rospy.init_node('nod2ejer2', anonymous=True)
rospy.Subscriber('topic', Ejer2, callback)
rospy.spin()

if __name__ =="__main__":

function()

node_service_cliente.py
#!/usr/bin/env python
# encoding: utf-8

import rospy
from lab2.srv import SumaTwoInts

def add_two_ints_client(x, y):

rospy.wait_for_service('suma_two_ints')
try:
#Definimos el Servicio Cliente en la variable add_two_ints
#Name Service|Clase Servicio
add_two_ints = rospy.ServiceProxy('suma_two_ints', SumaTwoInts)
resp = add_two_ints(x, y)
return resp.sum
except rospy.ServiceException as e:
print("Service call failed: %s"%e)

def nodo ():

rospy.init_node('nodo_suma_two_ints_client')
#Definimos dos variables x & y para realizar la suma de los dos números
enteros
x = 7
y = 8
print("Requesting %s+%s"%(x, y))
#Imprimimos el resultado de la operación de los dos números enteros
#La operación de suma la realizamos en la función add_two_ints_client
print("%s + %s = %s"%(x, y, add_two_ints_client(x, y)))
if __name__ == '__main__':
try:
nodo() # Llamamos a la función nodo
except rospy.ROSInterruptException:
pass

node_service_server.py
#!/usr/bin/env python
# encoding: utf-8

import rospy
from lab2.srv import SumaTwoInts, SumaTwoIntsResponse #Importamos módulos
generados por nuestro servicio

def handle_suma_two_ints(req): #Definimos para procesar la data enviada por el

Cliente
print ("Returning [%s + %s = %s]"%(req.a, req.b, (req.a + req.b)))
#Imprimimos en pantalla los valores que recibimos
return SumaTwoIntsResponse(req.a + req.b)

def nodo(): #Definimos una función nodo

rospy.init_node('nodo_suma_two_ints_server') #Inicializamos nuestro nodo y
le asignamos un nombre = nodo_suma_two_ints_server
#Declaramos nuestro Servicio Server
#Name Service|Clase Servicio|Función para procesar la data enviada por el
Cliente
s = rospy.Service('suma_two_ints', SumaTwoInts, handle_suma_two_ints)
print("Ready to add two ints.") #Imprimimos un mensaje en pantalla
rospy.spin() #Mantiene corriendo el script hasta que se pulsa Ctrl+C

if __name__ == "__main__":
try:
nodo() # Llamamos a la función nodo
except rospy.ROSInterruptException: #Check si hay una excepción Ctrl-C para
terminar la ejecución del nodo
pass