So schreibst Du Pakete und Nodes in ROS2

Motivation

Nachdem wir in den letzten Teilen ROS 2 und die Kamera auf dem Raspberry zum Laufen gebracht haben, widmen wir uns nun der Erstellung von Paketen und Nodes.

Voraussetzungen

Build-Tool: colcon

Damit wir Pakete bauen können, benötigen wir noch ein Buildtool. In ROS 2 löst colcon catkin als Buildtool ab.
Wir installieren es mit:

sudo apt install python3-colcon-common-extensions

Damit wir Tab-Completion für colcon-Befehle erhalten, fügen wir folgende Zeile in unsere .bashrc ein:

source /usr/share/colcon_argcomplete/hook/colcon-argcomplete.bash

ROS-2-Python-Abhängigkeiten

Damit wir mit Python Nodes erstellen können, benötigen wir noch die Pakete rclpy und std_msgs

sudo apt install ros-humble-rclpy
sudo apt install ros-humble-std-msgs

Da rclpy Paket ist die Python Client Library für ROS; std-msgs hilft uns Nachrichten zwischen Nodes senden und empfangen zu können.

Eigenes Paket erstellen

Wir wollen zuerst ein einfaches Paket mit zwei Nodes schreiben, um den publish-subscriber-Mechanismus kennenzulernen:
Pakete sollten in ROS immer in einem src-Ordner liegen:

cd ~/akiro
mkdir ./src
cd ./src

Jetzt erzeugen wir ein neues Python-Paket:

ros2 pkg create my_first_package --build-type ament_python --dependencies rclpy

Sanity-Check

Auch wenn das Paket noch leer ist, sollte es bereits baubar sein:

cd ~/akiro
colcon build

Wenn keine Fehler auftreten, ist das Setup korrekt.

Nodes schreiben

Nodes sind die ausführbaren Programme in ROS 2.

Man kann damit die Komplexität reduzieren, indem man Roboterprojekte in kleine, unabhängige Prozesse aufteilt. Nodes kapseln Funktionalität und kommunizieren über klar definierte Schnittstellen.

Nodes können in verschiedenen Sprachen geschrieben werden. (Derzeit Python und C++, Rust ist auf dem Weg) Wir wählen für unsere ersten Gehversuche Python, da es einfach zu lernen ist. Wir schreiben zwei nodes: einen Publisher und einen Subscriber

Publisher

Wir wechseln in das Python-Package my_first_package

cd src/my_first_package/my_first_package

Wir erstellen eine Datei publisher.py

touch publisher.py

und fügen folgenden Code ein:

import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class MinimalPublisher(Node):

def __init__(self):
    super().__init__('minimal_publisher')
    self.publisher = self.create_publisher(String, '/topic', 10)
    timer_period = 2.0  # Sekunden
    self.timer = self.create_timer(timer_period, self.timer_callback)

def timer_callback(self):
    msg = String()
    msg.data = 'Hello, from my first ROS 2 publisher node'
    self.publisher.publish(msg)
    self.get_logger().info('Publishing: "%s"' % msg.data)


def main(args=None):
    rclpy.init(args=args)
    minimal_publisher = MinimalPublisher()
    rclpy.spin(minimal_publisher)
    minimal_publisher.destroy_node()
    rclpy.shutdown()

if name == 'main':
    main()

Was passiert hier?

• Der Node sendet alle 2 Sekunden eine String-Nachricht
• Das Topic heißt /talker_topic
• Die Queue-Größe (10) ist für einfache Tests völlig ausreichend

Subscriber

Für den Subscriber erstellen wir eine Datei subscriber.py im gleichen Ordner und fügen folgenden Code ein:

import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class MinimalSubscriber(Node):

def __init__(self):
    super().__init__('minimal_subscriber')
    self.subscription = self.create_subscription(
        String,
        '/topic',
        self.listener_callback,
        10)
    self.subscription # prevent unused variable warning

def listener_callback(self, msg):
    self.get_logger().info('I heard: "%s"' % msg.data)


def main(args=None):
    rclpy.init(args=args)
    minimal_subscriber = MinimalSubscriber()
    rclpy.spin(minimal_subscriber)
    minimal_subscriber.destroy_node()
    rclpy.shutdown()

if name == 'main':
    main()

Der Subscriber lauscht auf dem gleichen Topic und gibt empfangene Nachrichten aus.

setup.py anpassen

Damit ROS 2 unsere Nodes als Programme kennt, müssen sie in der setup.py registriert werden:

'console_scripts': [
'talker = my_first_package.publisher:main',
'listener = my_first_package.subscriber:main',
],

Paket bauen

cd ~/akiro
colcon build

Nodes starten

Im ersten Terminal kannst du nun folgendes eingeben:

source install/setup.bash
ros2 run my_first_package talker

Im zweiten Terminal:

source install/setup.bash
ros2 run my_first_package listener

Kommunikation zwischen Nodes

Publisher / Subscriber

Den Publisher / Subscriber-Mechanismus haben wir jetzt kennengelernt.
Er eignet sich für asynchrone, kontinuierliche Datenströme z. B. Kamera-Bilder, Sensordaten, Steuerbefehle

Services

sind ein weiteres Kommunikations-Protokoll in ROS nach Request / Response-Prinzip z. B. „Starte Motor“, „Setze Parameter“

Actions

eignen sich für langlaufende Aufgaben mit Feedback wie z. B. Navigation, Greifbewegungen

Kommunikation zwischen Nodes visualisieren

Um die Kommunikation zwischen den Nodes zu visualisieren, kannst du das Tool rqt_graph verwenden:

ros2 run rqt_graph rqt_graph

Hier siehst du:

• Nodes (Ovale)
• Topics (Rechtecke)
• Datenfluss zwischen Publisher und Subscriber

Fazit

Du kannst jetzt:

• ROS-2-Pakete erstellen
• Python-Nodes schreiben
• Publisher & Subscriber verbinden
• Nodes bauen und starten
• die Kommunikation visualisieren

Code

https://github.com/jboegeholz/akiro/tree/main/src/my_first_package/my_first_package