Neutronic Massive

Neutronic Massive S.L.

Industria 4.Open
Proyecto Industria 4.Open

Nuestro proyecto, Industria 4.Open, busca llevar la visión de la Industria 4.0 al siguiente nivel al utilizar exclusivamente software libre y abierto en todos sus componentes. Nuestro objetivo es democratizar el acceso a las tecnologías avanzadas de la Industria 4.0, permitiendo que empresas de todos los tamaños y sectores puedan aprovechar sus beneficios sin restricciones ni barreras de licenciamiento.

Descubre cómo el software libre y abierto puede impulsar la automatización, la eficiencia y la personalización en tus procesos de fabricación. Explora las posibilidades de la Internet de las Cosas Industrial (IIoT), el análisis de datos en tiempo real, la inteligencia artificial y la fabricación aditiva, todo ello impulsado por tecnologías abiertas y accesibles para todos.

IIOT IIOT
microROS microRos

El internet industrial de las cosas es una parte fundamental de nuestro ecosistema. Aunque podemos integrar la mayoría de los protocolos industriales del IoT mas importantes, hemos centrado nuestro trabajo e investigación en el desarrollo de dispositivos con microROS, ROS2 para microcontroladores.

Ir a IIoT Ir a microROS
Tracker Tracker
Open-RMF

La interoperatibilidad entre flotas de robots heterogéneas la conseguimos con TRACKER, software propio que combina Open-RMF, ROS2 y FIWARE permitiendo la gestión del trafico de robots que comparten recursos como espacio, sistema de infraestructuras constructivas (puertas, elevadores, etc.) y otros sistemas de automatización dentro de la misma instalación. Todo el paquete de software se encarga también de la asignación de tareas y la resolución de conflictos entre los distintos componentes de la flota de robots.


Flota de Vehiculos Autónomos Colaborativos Open-RMF
FIWARE
El Internet del Futuro

FIWARE es una plataforma de código abierto que proporciona un conjunto de estándares y herramientas para desarrollar aplicaciones y servicios inteligentes. Al utilizar FIWARE, hemos creado una base sólida y altamente interoperable para construir soluciones de la Industria 4.0 de manera eficiente y sin preocupaciones sobre la propiedad intelectual o las limitaciones comerciales.

FIWARE en nuestro ecosistema. FIWARE
FIWARE
Industria 4.Open
Telegram

Unete a nuestro Canal de Telegram para mantenerte al día.


ROS2
Sistema Operativo para Robots

ROS2 (Robot Operating System 2) es una plataforma de desarrollo de software diseñada específicamente para robots y sistemas autónomos. Al integrar ROS2 en Industria 4.Open, aportamos una potente infraestructura para el control y la coordinación de sistemas robóticos avanzados en entornos industriales.

Ir a ROS2 en i4O Ir a Robótica Colaborativa
ROS2
NeuPal
Paletizado Colaborativo Inteligente

Plataforma software para el paletizado industrial utilizando un amplio abanico de robots colaborativos, garras, plataformas moviles, elevadores, etc. Al estar perfectamente integrado en el ecosistema "Industria 4.Open" permite una comunicación transparente con el resto de componentes del sistema.

Ir a Neupal Ir a Robótica Colaborativa
Blog
Controlando turtlesim desde FIWARE

Controlando la simulación turtlesim de ROS2 desde FIWARE

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:

Ejecutables en el paquete turtlesim

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:

Pantalla de la simulación de tortuga

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
    
Informacion del nodo 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:

Información del mensaje twist

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:

JSON de la subscripción

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.

Información de la entidad

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.

Información del tipo recién creado

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.

Pantalla de la simulación de tortuga

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

...
Ir a Blog Ir a "Controlando turtlesim desde FIWARE"
Industria 4.Open
Mentoría Gratuita

Rellena el formulario y Contáctanos para tener una sesión de mentoría gratuita con uno de nuestros expertos acerca de la Industria 4.Open.