Un Node Subscriber Simple

El Código¶

Copia todo el código a continuación en tu archivo subscriber.py y (de nuevo) ¡asegúrate de leer las anotaciones para entender cómo funciona todo!

subscriber.py

#!/usr/bin/env python3
# A simple ROS2 Subscriber

import rclpy # (1)!
from rclpy.node import Node

from example_interfaces.msg import String

class SimpleSubscriber(Node): # (2)! 

    def __init__(self): 
        super().__init__("simple_subscriber") # (3)!

        self.my_subscriber = self.create_subscription(
            msg_type=String,
            topic="{BLANK}",
            callback=self.msg_callback,
            qos_profile=10,
        ) # (4)!

        self.get_logger().info(
            f"The '{self.get_name()}' node is initialised."
        ) # (5)!

    def msg_callback(self, topic_message: String): # (6)!
        # (7)!
        self.get_logger().info(f"The '{self.get_name()}' node heard:") 
        self.get_logger().info(f"'{topic_message.data}'")

def main(args=None): # (8)!
    rclpy.init(args=args)
    my_simple_subscriber = SimpleSubscriber()
    rclpy.spin(my_simple_subscriber)
    my_simple_subscriber.destroy_node()
    rclpy.shutdown() 

if __name__ == '__main__':
    main()

Al igual que con nuestro node publisher, necesitamos importar la biblioteca cliente rclpy y el tipo de mensaje String de la biblioteca example_interfaces.msg para escribir un Node ROS Python y usar los mensajes ROS relevantes:
Esta vez, creamos una Clase Python llamada SimpleSubscriber() en su lugar, pero que aún hereda la clase Node de rclpy como lo hicimos con el Publisher antes.
Una vez más, usando el método super() llamamos al método __init__() de la clase Node padre de la que deriva nuestra clase SimpleSubscriber, y proporcionamos un nombre para registrarlo en la red.
Ahora estamos usando el método create_subscription() aquí, que le permitirá a este node subscribirse a los mensajes en un ROS Topic. Al llamar a esto proporcionamos 4 datos clave:
1. msg_type: El tipo de mensaje que usa el topic (que podríamos obtener ejecutando el comando ros2 topic info).
  
  Sabemos (habiendo creado el publisher), que nuestro topic usa mensajes String (de example_interfaces).
2. topic: El nombre del topic al que queremos escuchar (o subscribirnos).
  
  ¡Completa el espacio en blanco!
  
  ¡Reemplaza los ?? en el código anterior con el nombre del topic al que el node publisher.py fue configurado para publicar!
3. callback: Al construir un subscriber, necesitamos una función callback, que es una función que se ejecutará cada vez que se reciba un nuevo mensaje del topic.
  
  En esta etapa, definimos cómo se llama esta función callback (self.msg_callback), y definiremos la función en sí misma más adelante dentro de la Clase.
4. qos_profile: Como antes, un tamaño de cola para limitar la cantidad de mensajes que se ponen en cola en un buffer.
Imprime un mensaje de Log en la terminal para indicar que el proceso de inicialización ha tenido lugar.
Aquí estamos definiendo qué sucederá cada vez que nuestro subscriber reciba un nuevo mensaje. Esta función callback debe tener solo un argumento (además de self), que contendrá los datos del mensaje que se han recibido:

También estamos usando una Anotación de Tipo Python aquí también, que informa al intérprete que el topic_message recibido por la función msg_callback será del tipo de datos String.

(Todo esto realmente hace es permitir que la funcionalidad de autocompletado funcione dentro de nuestro editor de texto, de modo que cada vez que queramos extraer un atributo del objeto topic_message nos dirá qué atributos existen realmente dentro del objeto.)
En este ejemplo simple, todo lo que vamos a hacer al recibir un mensaje es imprimir un par de mensajes de log en la terminal, para incluir:
1. El nombre de este node (usando el método self.get_name())
2. El mensaje que se ha recibido (topic_message.data)
El resto de esto es exactamente igual que antes con nuestro publisher.

¡No Olvides el Shebang!¶

Recuerda: no olvides el shebang, ¡es muy importante!

#!/usr/bin/env python3