indigo

Qué son los servicios en ROS?? Ejemplo práctico para aclarar conceptos. Si queréis info que complemente este artículo, lo podréis hacer en el siguiente enlace

ruleta_7
Diagrama de aprendizaje

Qué son los servicios en ROS ??

En entradas anteriores de este blog hemos hablado del método principal de comunicación entre nodos, el método pub/sub. Si bien este método es muy sencillo, el nodo subscriptor y el nodo publicador hacen cada uno su tarea de modo independiente, es decir, supongamos que el nodo publicador se dedica a mandar la lectura de un sensor cada cierto tiempo y lo publica en un topic determinado, este envió de información (publicación), se hará independientemente de que haya o no nodos subscriptores.

Tal y como comentamos hace dos entradas de nuestro blog, podemos pensar en la analogía de la antena y la radio. La antena nuestro publisher emitirá independientemente de que alguien tenga o no la radio encendida. Esto hace que no haya manera de pasar información a la antena para por ejemplo, cambiar de canción.

Para ello está el segundo método de paso de información , el método de los servicios. El fundamento de este método es usado a menudo hoy en día en Internet, por ejemplo pensemos en la típica pagina para saber el tiempo que va a hacer hoy.

Esta página lo primero nos va a solicitar una ubicación, una vez que se la demos, nos mostrará el tiempo en ese lugar. Esto es un servicio, un método en el que yo paso una información, que se llama «request», y el servicio nos va a proveer de una respuesta llamada «response».

En definitiva, un servicio es un tipo de comunicación de ROS en el que pasamos un mensaje y nos devuelve una respuesta.

Un ejemplo de un servicio en una aplicación robótica, puede ser el de una aplicación en el que el usuario envía el tipo de pieza que se quiere localizar, request, y el servicio devuelve la localización de ese tipo de pieza, response.


En los servicios distinguimos dos partes bien diferenciadas, por un lado está el nodo cliente, que es el nodo en el cual se realiza la petición, el nodo que envía el “request”, y el nodo servidor, que es el que realiza la operación y devuelve una respuesta, devuelva la “response”.

servicio_ros

En el caso de la analogía con una aplicación web para conocer el tiempo en un determinado lugar, el usuario mete en el nodo cliente la localización de donde quiere saber el tiempo, es decir manda la “request”, y el nodo servicio realiza las operaciones necesarias para devolver los datos del tiempo en ese lugar, devuelva la “response”.

Para que se produzca la comunicación entre nodos en los dos sentidos, del cliente al servicio y del servicio al cliente, ROS utiliza unos mensajes que irán incluidos en la carpeta srv de nuestro paquete y tendrán a su vez la terminación .srv.

Estos mensajes, imaginemos que tenemos un servicio en el que pasamos dos enteros y nos devuelve la suma de ellos, tendrán la siguiente estructura:
Int a	//request	
Int b
---
Int sum	//response

La primera parte del mensaje, la que va antes de las tres rayas, pertenece al request y la siguiente parte a la response

 

Ejemplo práctico

Creación del mensaje

Ahora vamos a explicar como crear un servicio que sumará el valor de dos enteros, para ello crearemos dos archivos, uno que será el nodo servidor y otro que será el nodo cliente. Recordamos que este ejemplo lo tenéis en nuestro Github

Pero antes de nada creamos un paquete dentro de nuestro workspace, si tienes dudas de como crear un workspace consulta esta entrada anterior.

Para crear el paquete, como también hemos visto en anteriores entradas, lo primero escribimos en la consola la ruta la carpeta src de nuestro workspace:

cd ~/catkin_ws/src

Ahora volvemos a escribir en la consola:

catkin_create_pkg test_servicios roscpp

Así creamos un paquete llamado test_servicios con dependencias a roscpp. Ahora navegamos a la ruta del paquete recién creado:

 

cd ~/catkin_ws/src/test_servicios

y creamos la carpeta srv

sudo mkdir srv

Dentro de esta carpeta crearemos un archivo, que será el mensaje que vamos a usar y le llamaremos mensaje_servicio.srv

Este archivo lo rellenaremos con el siguiente contenido:

Int a	//request	
Int b
---
Int sum	//response

La parte de arriba del mensaje pertenece al request y la de abajo después de las tres rayas al response

Para poder usar este mensaje creado por nosotros primero vamos a descomentar estas dos lineas dentro del archivo package.xml

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

Ahora en nuestro archivo CmakeLists.txt

find_package(catkin REQUIRED COMPONENTS
  	roscpp
	std_msgs
	message_generation
)
catkin_package(
  DEPENDS message_runtime
)
generate_messages(
   DEPENDENCIES
   std_msgs  # Or other packages containing msgs
 )

Ya podemos usar mensajes creados por nosotros, ahora le diremos cual es el mensaje creado por nosotros a incluir, para ello nuevamente en el archivo CmakeLists.txt de nuestro paquete, descomentamos esta parte y añadimos el nombre del mensaje creado

add_service_files(
   FILES
   mensaje_servicio.srv
 )

Ahora haremos catkin_make para generar los archivos de cabecera necesarios.

Si todo ha ido bien en la carpeta ~/catkin_ws/devel/include/nombre_de_nuestro_paquete/ se crearan los archivos de cabecera necesarios para poder incluirlos en nuestro código, en nuestro caso se ha creado el archivo mensaje_servicio.h

Así pues, ya tenemos todo listo para crear los dos nodos, el nodo servicio y el nodo cliente

Nodo servicio

Este es el nodo que realizará la operación, es el nodo que tomará la request y la transformará en una response, en nuestro caso tomará los valores de los enteros a sumar que le proporciona el cliente y hará la operación suma, devolviendo este valor suma mediante el response del mensaje que hemos creado.

Lo primero es crear un archivo que llamaremos servicio.cpp dentro de la carpeta src donde incluiremos el código del servicio, luego le diremos a nuestro paquete, a través del archivo CmakeLists.txt que queremos incluir dicho archivo en el paquete, para ello incluiremos las siguientes lineas en el archivo CmakeLists.txt, hay que tener en cuenta que se debe hacer en el lugar adecuado del archivo CmakeLists.txt (ver archivos en Github)

add_executable(suma_servicio src/servicio.cpp)
target_link_libraries(suma_servicio ${catkin_LIBRARIES})

una vez hecho esto ya podemos añadir el código al archivo servicio.cpp

#include <ros/ros.h>
#include "test_servicios/mensaje_servicio.h"

bool suma(test_servicios::mensaje_servicioRequest &req, test_servicios::mensaje_servicioResponse &res){
  res.sum = req.x + req.y;
  ROS_INFO("La suma es: %d", res.sum);
  return true;
}

int main(int argc, char **argv)
{
  ros::init(argc, argv, "nodo_suma_servicio");
  ros::NodeHandle node;

  ros::ServiceServer service = node.advertiseService("servicio_suma", suma);
  
  ros::spin();

  return 0;
}

Ahora vamos a explicar el código

#include <ros/ros.h>
#include "test_servicios/mensaje_servicio.h"

Cargamos la librería principal de ROS e incluimos la cabecera del mensaje que hemos creado.

int main(int argc, char **argv)
{
  ros::init(argc, argv, "nodo_suma_servicio");
  ros::NodeHandle node;

En la función main inicializamos el nodo, al que llamaremos «nodo_suma_servicio«

ros::ServiceServer service = node.advertiseService("servicio_suma", suma);
  
ros::spin();

Creamos el servicio, al que llamamos «servicio_suma«, e indicamos que cada vez que se llame al servicio se ejecute la función suma.

Luego añadimos el spin, qué es donde se realiza verdaderamente la llamada al servicio 

bool suma(test_servicios::mensaje_servicioRequest &req, test_servicios::mensaje_servicioResponse &res){
  res.sum = req.x + req.y;
  ROS_INFO("La suma es: %d", res.sum);
  return true;
}

La función suma, que es declarada antes del main, toma como argumentos un objeto del mensaje que hemos creado, por lo tanto este objeto tendrá sus atributos, es decir una parte request que llamaremos req y que tendrá x e y como argumentos y otra parte llamada response, que tendrá sum como argumento, en esta función definimos que sum del response es la suma de x + y del request.

Nodo cliente

Ahora crearemos el nodo cliente, que será el encargado de pasar los argumentos del request al servicio, en este caso va a pasar unos valores de x e y predeterminados para que el nodo servicio los sume.

Pero primero debemos, tal y como hemos hecho con le nodo cliente, crear un archivo en el que vamos a meter el código y decirle a nuestro paquete que lo incluya, para ello en el archivo CmakeLists.txt, este archivo será cliente.cpp

add_executable(suma_cliente src/cliente.cpp)
target_link_libraries(suma_cliente ${catkin_LIBRARIES})

una vez hecho esto ya podemos añadir el código al archivo cliente.cpp

#include <ros/ros.h>
#include "test_servicios/mensaje_servicio.h"

int main(int argc, char **argv)
{
    ros::init(argc, argv, "nodo_suma_cliente");
    ros::NodeHandle node;

    ros::ServiceClient client = node.serviceClient<test_servicios::mensaje_servicio>("servicio_suma");

    test_servicios::mensaje_servicio msj;
    msj.request.x = 3;
    msj.request.y = 4;

    client.call(msj);

    return 0;
}

vamos a explicarlo:

#include <ros/ros.h>
#include <std_msgs/String.h>

Estas dos primeras lineas igual que en el nodo servicio

int main(int argc, char **argv)
{
    ros::init(argc, argv, "nodo_suma_cliente");
    ros::NodeHandle node;

En el main vamos a crear el nodo llamado nodo_suma_cliente

ros::ServiceClient client = node.serviceClient<test_servicios::mensaje_servicio>("servicio_suma");

Creamos un cliente de servicios en el que inidcamos que el mnsaje que le vamos a asar es del tipo «test_servicios::mensaje_servicio» y le decimos que el servicio al que se debe conectar se llama «servicio_suma«

test_servicios::mensaje_servicio msj;
msj.request.x = 3;
msj.request.y = 4;

Creamos un objeto llamado msj del tipo del mensaje_servicio que hemos creado y lo rellenamos con los valores x e y a sumar 

client.call(msj);

Por último llamamos al servicio y le pasamos el objeto msj creado y rellenado anteriormente

Ahora compilamos:

$ catkin_make

Ejecutamos roscore:

$ roscore

Ejecutamos el cliente del servicio que hemos creado ahora mimso, lo haremos mediante le comando rosrun:

$ rosrun test_sevicios suma_cliente

test_servicios es el nombre del paquete y suma_cliente es el nombre que le hemos dado en CmakeLists.txt, concretamente en las líneas:

add_executable(suma_cliente src/cliente.cpp)
target_link_libraries(suma_cliente ${catkin_LIBRARIES})

Por pantalla no veremos nada, ya que no está el servidor del servicio inicializado, por lo que ejecutaremos 

$ rosrun test_sevicios suma_servico

y nuevamente:

$ rosrun test_sevicios suma_cliente

por lo que en la ventana del servicio veremos:

rosrun

Aquí acaba esta entrada sobre la comunicación usando servicios. En definitiva los servicos es un tipo de comunicación en la que un nodo servidor nos va a realizar algo tras recibir por parte de un nodo cliente unos argumentos. 

Espero que os haya sido de utilidad, hasta la próxima entrada!!

Subscríbete a nuestro blog

ROS_custom_message

10 ROS Custom Message

ROS Custom Message Fundamentos de ROS Accede a otros posts En tutoriales anteriores a la hora de la comunicación pub/sub, siempre hemos usado mensajes predefinidos

Read More »
kinetic

9 CmakeLists & Package.xml

Cmake y package.xml Fundamentos de ROS Accede a otros posts En esta breve entrada del blog, hablaremos sobre Cmake y package.xml Cmake es una herramienta

Read More »
indigo

7 Servicios

Servicios Otras entrads del blog Qué son los servicios en ROS?? Ejemplo práctico para aclarar conceptos. Si queréis info que complemente este artículo, lo podréis

Read More »

This website uses cookies to ensure you get the best experience on our website. By continuing to browse on this website, you accept the use of cookies for the above purposes.