Introducción

En publicaciones previas de IcuOre, abordamos tanto la implementación como la configuración de todos los elementos necesarios para iniciar el trabajo con FIWARE y ROS2.

El objetivo principal de este artículo es demostrar cómo la combinación de ROS2 y FIWARE posibilita la interacción entre distintos sistemas y el manejo remoto de simulaciones robóticas. La simulación turtlesim se presenta como un escenario idóneo para tal propósito, dado que constituye un entorno simple pero versátil que facilita la comprensión y aplicación de los principios fundamentales en la integración de ROS2 con FIWARE.

Pasos previos

Antes de comenzar, es importante asegurarnos de que los programas que forman parte de IcuOre estén actualizados. En nuestro blog, hemos preparado una documentación detallada que explica cómo llevar a cabo la actualización de cada uno de los componentes centrales. Recomendamos encarecidamente que consulte estos recursos antes de continuar.

A continuación, desde una consola de comandos, procederemos a ejecutar Orion y MongoDB de la misma manera en la que lo hemos hecho desde el principio:

    superuser@IcuO:~$ sudo docker compose up
    

Este comando permitirá levantar los servicios de Orion Context Broker y MongoDB, que son componentes esenciales para la integración con FIWARE.

Ahora, ejecutaremos el nodo turtlesim desde otra consola, ya que la primera consola está ocupada ejecutando los programas de FIWARE en primer plano. Es importante recordar que es necesario activar el entorno de trabajo de ROS2 utilizando el comando "source":

    superuser@IcuO:~$ source /opt/ros/humble/setup.bash
    

Una vez realizado esto, repasaremos algunos comandos de ROS2 para familiarizarnos con ellos y entender qué ejecutables están disponibles en el paquete de turtlesim:

    superuser@IcuO:~$ ros2 pkg executables turtlesim
    

Este comando nos mostrará todos los ejecutables incluidos en el paquete turtlesim, como se puede apreciar en la siguiente captura de pantalla:

En nuestro caso, nos interesa ejecutar el nodo turtlesim. Sin más dilación, ejecutaremos el siguiente comando:

    superuser@IcuO:~$ ros2 run turtlesim turtlesim_node
    

De esta manera, se abrirá el simulador virtual de turtlesim y se mostrará una tortuga en el centro de la pantalla, como se puede apreciar en la siguiente captura de pantalla:

Configuración del servicio de integración

Ahora que tenemos nuestra tortuga funcionando correctamente, exploraremos los mensajes disponibles para moverla. Para ello, abriremos otra consola, ya que las dos consolas anteriores están ocupadas: una con los programas necesarios para FIWARE (a través de Docker) y la otra con el nodo turtlesim. Como siempre, cada vez que abrimos una nueva consola, debemos activar el entorno de ROS2 utilizando el comando "source":

    superuser@IcuO:~$ source /opt/ros/humble/setup.bash
    

A continuación, verificaremos los nodos activos utilizando el siguiente comando:

    superuser@IcuO:~$ ros2 node list
    

Esto nos mostrará que solo el nodo /turtlesim está activo, como era de esperar.

Ahora, obtendremos información sobre la composición de este nodo ejecutando:

    superuser@IcuO:~$ ros2 node info /turtlesim
    

En la documentación de este pequeño simulador, encontramos que el tópico /turtle1/cmd_vel se utiliza para mover la tortuga. En la captura de pantalla anterior, podemos observar que se trata de un mensaje del tipo 'geometry_msgs'. Verificaremos el formato exacto de este mensaje ejecutando el siguiente comando:

    superuser@IcuO:~$ ros2 interface show geometry_msgs/msg/Twist
    

Esto nos proporcionará información sobre el formato del mensaje, como se muestra en la siguiente figura:

Aunque este simulador es en 2D, utiliza el mensaje Twist, que normalmente se utiliza para movimientos en contextos 3D. Para nuestras pruebas, solo necesitamos utilizar el componente Vector3 'linear' con sus coordenadas x e y, y el componente 'angular' si deseamos realizar movimientos circulares.

La instalación fresca que hemos realizado del servicio de integración solo incluye el tratamiento para los mensajes estándar, por lo que ahora debemos agregar los mensajes de geometría que utilizaremos en esta prueba. Para hacer esto, seguiremos los siguientes pasos:

    superuser@IcuO:~$ cd et-is
    

    superuser@IcuO:~/et-is$ colcon build --cmake-args -DMIX_ROS2_PACKAGES="geometry_msgs"
    

Este proceso tomará algún tiempo, pero es fundamental realizarlo para poder utilizar el tópico cmd_vel y mover nuestra tortuga. Para obtener más información sobre la compilación con paquetes opcionales de ROS2 para el servicio de integración, puede ampliar sus conocimientos en el siguiente enlace: https://github.com/eProsima/ROS2-SH

Configuración del archivo YAML

El siguiente paso es ejecutar el servicio de integración para poder enviar mensajes entre el Context Broker de FIWARE y ROS2. Sin embargo, antes de hacerlo, debemos crear el archivo YAML que indicará a Integration Service cómo trabajar.

En esta publicación, utilizaremos un archivo YAML bastante básico, que iremos refinando en futuras documentaciones a medida que agreguemos otros agentes para la comunicación entre FIWARE y ROS2, así como otros entornos como MQTT, OPC UA, entre otros. A continuación, se muestra el contenido del archivo turtle.yaml que hemos colocado en el directorio ~/et-is/course:

      types: 
        idls:
          - >
            struct vector3
            {
              double x;
              double y;
              double z;
            };
            
            struct twist
            {
              vector3 linear;
              vector3 angular;
            };
            
      systems:
        ros2:
          type: ros2
          node_name: fiturtle
        fiware: 
          type: fiware
          host: "172.17.0.1"
          port: 1026
          types-from: ros2
        
      routes: 
        fiware_to_ros2: 
          from: fiware
          to: ros2
        
      topics: 
        "cmd_vel": 
          type: "twist"
          routes: fiware_to_ros2
          remap: 
            ros2: 
              type: "geometry_msgs/Twist"
              topic: "/turtle1/cmd_vel"
            fiware: 
              type: "twist"

Una vez creado el archivo, procedemos a ejecutar el servicio de integración siguiendo los siguientes pasos:

    superuser@IcuO:~$ cd et-is

    superuser@IcuO:~/et-is$ source /opt/ros/humble/setup.bash

    superuser@IcuO:~/et-is$ source install/setup.bash

    superuser@IcuO:~/et-is$ integration-service course/turtle.yaml

Si todo ha ido bien, el servicio de integración se ejecutará en primer plano y la consola utilizada mostrará los mensajes correspondientes. Necesitamos abrir otra consola para el siguiente paso.

Por otro lado, podemos comprobar que hemos creado la suscripción escribiendo la siguiente URL en la barra de navegación de cualquier navegador:

    http://172.17.0.1:1026/v2/subscriptions

Esto nos mostrará un JSON similar al siguiente:

Como se puede apreciar, Orion ha creado la suscripción que utilizaremos para mover nuestra tortuga.

Si escribimos la siguiente URL en la barra de navegación:

    http://172.17.0.1:1026/v2/entities

o:

    http://172.17.0.1:1026/v2/types

Comprobaremos que aún no hay salida alguna, ya que tanto la entidad como el tipo de datos se crearán con comandos específicos que utilizaremos para mover la tortuga.

Moviendo la tortuga

Para mover la tortuga, lo primero que haremos es crear un archivo JSON que utilizaremos junto con el comando curl para crear la entidad en FIWARE. Guardaremos el siguiente JSON en el archivo ~/et-is/course/crea_entidad.json:

{
    "id": "cmd_vel",
    "type": "twist",
    "linear": {
        "type": "struct",
        "value": {
            "x": {"type": "Double", "value": 0.0},
            "y": {"type": "Double", "value": 0.0},
            "z": {"type": "Double", "value": 0.0}
        }
    },
    "angular": {
        "type": "struct",
        "value": {
            "x": {"type": "Double", "value": 0.0},
            "y": {"type": "Double", "value": 0.0},
            "z": {"type": "Double", "value": 0.0}
        }
    }
}

A continuación, enviaremos este JSON a Orion mediante el siguiente comando:

superuser@IcuO:~$ curl -X POST 'http://172.17.0.1:1026/v2/entities' -H 'Content-Type: application/json' -d @~/et-is/course/crea_entidad.json

Podremos observar desde el navegador cómo se ha creado la entidad mediante el comando POST.

Por otro lado, también se ha creado el tipo de datos que hemos definido en el JSON de la entidad, y podremos verlo tambien en el navegador.

Una vez que hemos creado tanto la entidad como el tipo de datos, el siguiente paso será mover definitivamente la tortuga. Para esta opción, crearemos un archivo en ~/et-is/course llamado cmd_vel.json con el siguiente contenido:

{
    "linear": {
        "type": "struct",
        "value": {
            "x": {"type": "Double", "value": 2.15},
            "y": {"type": "Double", "value": 1.0},
            "z": {"type": "Double", "value": 0.0}
        }
    },
    "angular": {
        "type": "struct",
        "value": {
            "x": {"type": "Double", "value": 0.0},
            "y": {"type": "Double", "value": 0.0},
            "z": {"type": "Double", "value": 0.0}
        }
    }
}

Con el archivo creado, solo nos queda ejecutarlo utilizando la opción PUT del comando curl, como se muestra a continuación:

superuser@IcuO:~$ curl -X PUT 'http://172.17.0.1:1026/v2/entities/cmd_vel/attrs?type=twist' -H 'Content-Type: application/json' -d @~/et-is/course/cmd_vel.json

Si todo ha ido bien, la tortuga se habrá movido con un incremento de 2.15 unidades en el eje X y un incremento de 1.0 en el eje Y. Podremos apreciarlo en la pantalla del simulador Turtlesim.

Animamos al lector a que haga los cambios que considere necesarios para hacer pruebas y afianzar el conocimiento