Eine einzelne Ubuntu-Maschine zu warten, ist noch überschaubar. Man loggt sich per SSH ein, installiert ein paar Pakete, macht ein Update – und dann läuft die Kiste wieder.

In der Robotik bleibt es aber selten bei einer Maschine. Sobald mehrere Roboter im Einsatz sind, sitzt man plötzlich vor einem kleinen Zoo aus Linux-Systemen.

Dann beginnt die klassische Runde:
SSH auf Rechner eins, Updates einspielen.
SSH auf Rechner zwei, dieselben Updates einspielen.
SSH auf Rechner drei – na, Du ahnst es schon.

Spätestens nach dem fünften Roboter merkt man: Das ist weniger Systemadministration und mehr Fleißarbeit mit Copy-Paste.

Genau hier kommt Ansible ins Spiel. Mit sogenannten Playbooks beschreibt man einfach den gewünschten Zustand der Systeme – welche Pakete installiert sein sollen, welche Konfigurationen gelten, welche Updates eingespielt werden. Ansible kümmert sich dann darum, diese Zustände automatisch auf allen Zielrechnern umzusetzen.

Gerade in Robotik-Umgebungen mit vielen verteilten Rechnern sorgt dieser Ansatz dafür, dass Wartung nicht mehr Handarbeit ist – sondern planbar, reproduzierbar und vor allem deutlich entspannter.

Ansible

Ansible wurde 2012 von Michael DeHaan entwickelt und als Open-Source-Projekt veröffentlicht. 2015 wurde das Unternehmen Ansible, Inc. von Red Hat übernommen, das wiederum seit 2019 zu IBM gehört.

Es ist ein agentenloses Automatisierungstool – das heißt, auf den Zielrechnern muss keine zusätzliche Software installiert werden. Ansible verbindet sich einfach per SSH und führt die gewünschten Aufgaben aus.

Setup

Für dieses Tutorial brauchst Du einen Ubuntu-PC und einen Raspberry Pi mit einem installierten Ubuntu. Auf deinem Control-Rechner (also deinem PC) läuft Ansible und der SSH Client, auf dem Raspberry (also dem Remote-Rechner) muss der SSH-Server aktiviert sein.

Installation

Auf deinem Control-Rechner installierst du Ansible wie folgt:

sudo apt update
sudo apt install ansible
sudo apt install sshpass

Jetzt kannst Du testen, ob die Installation geklappt hat:

ansible --version

SSH aktivieren

Damit Ansible funktioniert, muss auf dem Raspberry aka Remote-Rechner SSH eingerichtet sein.
Probier mal im Terminal deines Control-Rechners aus, dich mit dem Raspberry zu verbinden:

ssh pi@192.168.178.50

Falls das nicht klappt, musst du SSH auf dem Raspberry aktivieren. Das geht ganz einfach über die raspi-config:

sudo raspi-config

Dann navigierst du zu “Interfacing Options” -> “SSH” und aktivierst den SSH-Server.

Projektordner

Auf deinem Control-Rechner legst du dir z.B. einen Projektordner an:

mkdir ~/ansible
cd ansible
touch hosts
touch ansible.cfg
touch update_pi.yml

Die Ordnerstruktur soll nachher so aussehen:

ansible/
├── hosts
├── update_pi.yml
└── ansible.cfg

hosts-Datei anlegen

In der hosts-Datei stehen die Rechner und ihre IP-Adressen bzw. ihre A-Records.

[raspberry]
pi1 ansible_host=192.168.178.66 ansible_user=<username>

ansible.cfg

Die ansible.cfg Datei ist die Konfigurationsdatei für Ansible.
Hier kannst du verschiedene Einstellungen vornehmen, z.B. den Pfad zu deiner hosts-Datei.
Ein einfaches Beispiel sieht so aus

[defaults]
inventory = hosts

Playbooks

Playbooks sind die Ansible-Äquivalente zu Skripten, sie beschreiben die gewünschten Zustände der Zielrechner.
Ein einfaches Playbook für die Updates des Raspberrys könnte so aussehen:

update_pi.yml

---
- name: Update Raspberry Pi
  hosts: raspberry
  become: yes

  tasks:
    - name: Update apt cache
      apt:
        update_cache: yes

    - name: Upgrade all packages
      apt:
        upgrade: dist

Im Detail

Ansible starten

Wenn du diese drei Dateien anegelegt hast, kann es auch schon losgehen

ping

Der ping-Befehl ist ein Testmodul von Ansible, das überprüft, ob der Host erreichbar und ausführbar ist.
Wenn du Passwort-Login benutzt musst du Ansible sagen, dass es nach einem SSH-Passwort fragen soll:
Das -k steht für –ask-pass

ansible -i hosts raspberry -m ping -k
SSH password:

Wenn alles funktioniert, solltest du folgenden Output sehen:

pi1 | SUCCESS => {
"ansible_facts": {
"discovered_interpreter_python": "/usr/bin/python3"
},
"changed": false,
"ping": "pong"
}

Playbook starten

Jetzt zum eigentlichen Task:

ansible-playbook -i hosts update_pi.yml -k -K

Da wir sudu apt update / upgrade machen wollen, müssen wir auch das root-PW übergeben. Das machen wir mit dem Flag -K.
-K steht für –ask-become-pass, damit wird Ansible nach dem sudo-Passwort fragen.

Zertifikat-Login

Da wir aber nicht permanent die
Ansible unterstützt auch die Authentifizierung mit Zertifikaten, was sicherer ist als die Passwort-Authentifizierung.
Dazu musst du auf deinem Control-Rechner ein SSH-Schlüsselpaar generieren und den öffentlichen Schlüssel auf den
Zielrechner kopieren.

ssh-keygen -t rsa -b 4096 -C "@ansible-controller"
ssh-copy-id @192.168.178.66

Danach kannst du Ansible ohne Passwort verwenden, indem du einfach den Hostnamen angibst:

ansible-playbook -i hosts update_pi.yml -K

Weitere Beispiele

Ubuntu-Pakete installieren

Man kann natürlich auch andere Pakete installieren, z.B. git:

tasks: 
- name: Install git 
  apt: 
    name: git 
    state: present 
    update_cache: yes

Git Repository klonen

Auch das Klonen eines Git-Repositories ist mit Ansible kein Problem:

tasks: 
- name: Clone Git repo 
    git:
      repo: https://github.com/user/meinprojekt.git 
      dest: /home/pi/meinprojekt 
      version: main

Fazit

Ansible ist ein mächtiges Werkzeug, um die Wartung von Robotern zu automatisieren. Es ermöglicht dir, den Zustand deiner
Systeme zu beschreiben und automatisch umzusetzen, ohne dich manuell auf jedem Rechner einzuloggen. Gerade in Umgebungen
mit vielen verteilten Rechnern spart das enorm viel Zeit und Nerven.

The post So verwaltest du deine Roboter mit Ansible appeared first on Creatronix.

Microsoft Kinect v1 – damals für die Xbox 360 erschienen – ist eine sehr beliebte Kamera mit einem zusätzlichen Infrarot-Tiefensensor.
Sie ist in Robotikkreisen sehr beliebt, weil sich durch die Tiefeninformation und die dadurch möglichen Umrechnungen in eine Point Cloud, Greifbewegungen von Roboterarmen automatisieren lassen.

Funktionsweise

• Der IR-Projektor wirft ein bekanntes Punktmuster
• Das Muster wird auf Objekten verzerrt
• Die IR-Kamera sieht diese Verzerrung
• Aus der Abweichung vom Referenzmuster wird die Tiefe berechnet

Disclaimer

Die Kinect benötigt eine externe Stromversorgung und funktioniert nicht ausschließlich über USB.

Ich hatte mit der Verbindung zu einer Ubuntu VM mit UMT und macos kein Glück. Hier kam es permanent zu frame drops. Deswegen bezieht sich dieses Tutorial auf die Einrichtung auf einem Raspberry Pi 4 mit ROS 2 Humble.

Anschluss am Raspberry

Ihr solltet die blauen USB 3.0 Ports verwenden.

Software

In diesem Tutorial werden wir

• libfreenect
• image_pipeline
• kinect_ros2

installieren

libfreenect

libfreenect ist ein Open Source Treiber für die Kinect, der auf macOS, Windows und Linux läuft.

Bauen und installieren

cd ~ 
git clone https://github.com/OpenKinect/libfreenect.git 
cd libfreenect 
mkdir build && cd build 
cmake .. -DBUILD_EXAMPLES=ON 
make 
sudo make install 
sudo ldconfig

Jetzt könnt ihr mit

freenect-camtest

ausprobieren, ob die Kinect bereits funktioniert. Es sollte “Received video frame” als Ausgabe kommen.

freenect-glview

freenect-glview ist ein weiteres Tool, um die Kinect zu testen, ihr könnt es mit:

freenect-glview

starten

Wenn der Befehl nicht gefunden wurde, müsst ihr noch die fehlende Abhängigkeit freeglut3-dev (Free OpenGL Utility Toolkit) installieren

sudo apt install freeglut3-dev

und die build-Schritte von oben wiederholen

ROS2-Anbindung

Voraussetzung ist ein funktionierender ROS-2-Workspace (~/ros2_ws) mit gesourcter Umgebung. Falls ihr das noch nicht gemacht habt, könnten euch diese Artikel helfen:
https://creatronix.de/so-installierst-du-ros-2-auf-dem-raspberry-pi-ball-chaser-mit-ros2/
https://creatronix.de/so-schreibst-du-pakete-und-nodes-in-ros/

Image Pipeline installieren

cd ~/ros2_ws/src 
git clone https://github.com/ros-perception/image_pipeline 
cd image_pipeline 
git checkout humble 
cd ~/ros2_ws 
colcon build 
source install/setup.bash

Um zu schauen, ob alles korrekt funktioniert, können wir nun in einem Terminal

ros2 run image_proc image_proc

und in einem zweiten Terminal:

ros2 run rqt_image_view rqt_image_view

ausprobieren.

Wenn ein Live-Bild in rqt_image_view erscheint, funktioniert die Image Pipeline korrekt.

rosdep initialisieren

Falls ihr bisher kein rosdep verwendet habt, müsst ihr das einmalig machen:

cd ~/ros2_ws 
sudo rosdep init 
rosdep update

kinect_ros2 installieren

Obwohl das Paket offiziell nur bis Galactic gepflegt ist, lässt es sich unter Humble aktuell problemlos aus dem Source bauen.

cd ~/ros2_ws/src 
git clone https://github.com/fadlio/kinect_ros2/tree/galactic 
cd ~/ros2_ws 
rosdep install --from-paths src --ignore-src -r -y 
colcon build
source install/setup.bash

Jetzt können die launch files gestartet werden

ros2 launch kinect_ros2 pointcloud.launch.py

Der Node kinect_ros2 publiziert jetzt die Topics /depth/image_raw und /depth/camera_info
Ihr könnt das auf der Kommandozeile mit

ros2 topic list

überprüfen.

Wir können jetzt auch die Bilder aufzeichnen und via rosbag in einem mcap speichern. Wir prüfen zuerst, ob die mcap-Erweiterung installiert ist:

ros2 bag info --storage-id mcap

Falls nicht

sudo apt install ros-humble-rosbag2-storage-mcap

Aufnehmen können wir nun mit

ros2 bag record /camera/depth/points -s mcap

Da die Datenmenge bei Bilddaten schnell sehr groß werden können, kann man mcap auch komprimiert aufzeichnen:

ros2 bag record \
/camera/depth/points \
-s mcap \
--compression-mode file \
--compression-format zstd

The post So verwendest du die Kinect unter ROS 2 appeared first on Creatronix.

Wenn du in Humble von den Vorteilen von CycloneDDS profitieren möchtest, zeige ich dir hier den Umstieg.

Was ist eine Middleware?

Eine Middleware ist eine Software-Schicht, die es Programmen ermöglicht, Daten auszutauschen, ohne direkt betriebssystem-spezifische
Funktionen nutzen zu müssen.

Was ist DDS

Data Distribution Service (DDS) ist ein Standard der Object Management Group und wurde 2004 mit der Version 1.0 veröffentlicht.

Mit ROS 2 wurde eine Middleware-Abstraktionsschicht eingeführt, die standardmäßig DDS nutzt, um Skalierbarkeit, Fehlertoleranz und Echtzeitfähigkeit zu verbessern.

FastDDS vs Cyclone DDS

Fast DDS (rmw_fastrtps_cpp) ist ab Foxy Fitzroy (2020) die standardmäßig verwendete Middleware (RMW)-Implementierung in ROS 2, was bedeutet, dass es automatisch in jeder ROS 2 Distribution (LTS und Non-LTS) enthalten ist. Die ROS-2-Community empfiehlt aber den Einsatz von Cyclone DDS aus folgenden Gründen:

• Weniger Discovery-Bugs
• Weniger „mysteriöse“ Kommunikationsprobleme
• Besseres Verhalten bei:
  • vielen Nodes
  • wechselnden Netzwerken
  • Simulation + Hardware parallel

Sehr gutes Verhalten auf:

• Embedded
• ARM
• Realtime-Systemen

Installation CycloneDDS

sudo apt install ros-<ros_distro>-rmw-cyclonedds-cpp

Für Humble:

sudo apt install ros-humble-rmw-cyclonedds-cpp

Wechseln kannst du über die Umgebungsvariable, die Du am besten direkt in deine bashrc hinzufügst:

export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp

Installation testen

In Terminal 1 startest Du einen Demo-Node:

ros2 run demo_nodes_cpp talker

In Terminal 2 rufst du den ROS-Doktor:

ros2 doctor --report

Jetzt solltest Du folgenden Output sehen:

RMW MIDDLEWARE 
middleware name : rmw_cyclonedds_cpp

Quellcode

https://github.com/eclipse-cyclonedds/cyclonedds

Weiterlesen

https://design.ros2.org/articles/ros_middleware_interface.html

The post So ersetzt Du FastDDS mit Cyclone DDS appeared first on Creatronix.

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

The post So schreibst Du Pakete und Nodes in ROS2 appeared first on Creatronix.

Nachbau eines Turtlebot als Open Source Software + Hardware Projekt

ROS 2 Basics

So installierst Du ROS 2 auf dem Raspberry Pi

So benutzt du die Kamera unter ROS2

So schreibst du Launch-Dateien für deinen Roboter

Teleop Twist Keyboard

So steuerst du deinen Roboter mit dem Gamepad

Motoren

So setzt du beim Dynamixel XL430 die ID

So steuerst Du den Dynamixel XL430 mit dem Arduino an

Ball Chaser

So verwendest du den SimpleBlobDetector von opencv

LiDaR

So verwendest Du das Slamtec Lidar in ROS

Troubleshooting / Tipps und Tricks

How to install VS Code on Ubuntu for arm64

So kontrollierst du die CPU Temperatur am Raspberry Pi

ROS2 CLI Cheat Sheet

Turtle-Nest – Diese ROS-Pakete solltest du kennen

So funktionieren Lifecycle-Nodes in ROS2

RQt – Diese ROS Pakete solltest du kennen

Code

https://github.com/jboegeholz/akiro

The post AKIRO – Roboter-Lernprojekt appeared first on Creatronix.

Wenn man Daten über eine serielle Schnittstelle zwischen z.b Raspberry Pi und einem Arduino schicken will,
ergibt es Sinn, sich über das Format Gedanken zu machen. Angenommen wir wollen einen Drehzahlwert von 60 RPM jeweils für die linke und rechte Seite übertragen.
Standardmäßig verschickt eine Bibliothek wie pyserial ASCII-Zeichen, dass heißt eine Zahl wie 60 würde als zwei Byte ASCII übertragen. Das sind doppelt so viele Daten wie benötigt würden, wenn wir die Zahl als Integer übertragen. Hier kommen structs ins Spiel.

struct for the rescue

Mit dem struct Modul in Python können wir Binärdaten in einem bestimmten Format packen und entpacken.

def test_struct_b():
    assert struct.pack('b', 1) == b'\x01'
    assert struct.pack('b', 127) == b'\x7f'
    assert struct.pack('b', -128) == b'\x80'

def test_unpack_b():
    packed = struct.pack('b', 127)
    unpacked = struct.unpack('b', packed)[0]
    assert unpacked == 127

Mehrere Variablen

def test_struct_bb():
    msg = struct.pack('bb', int(60), int(60))
    assert msg == b'\x3C\x3C'

Fallstricke

Damit die Empfängerseite die Daten auch wieder korrekt entpacken kann, muss natürlich das Format beachtet werden.

Achtet dementsprechend auf gute Dokumentation und versioniert idelaerweise die Dateien für die Datenübertragung in den gleichen Commits.

Datentypen

In structs können verschiedene Datentypen verwendet werden:
Tabelle der wichtigsten Datentypen:

Pretty hex

Wenn man die Darstellung der Zahlen auf der Konsole oder im Log etwas aufhübschen will:

def test_pretty_hex():
    msg = struct.pack('>I', 2864434397)
    pretty_hex = ' '.join(f'{b:02x}' for b in msg)
    assert pretty_hex == "aa bb cc dd"

The post So funktionieren structs in Python appeared first on Creatronix.

Wenn du schon einmal mehr als zwei ROS-Nodes gleichzeitig in mehreren Terminals starten musstest, ist jetzt ein guter Zeitpunkt, etwas über Launch-Dateien zu lernen.
Launch-Dateien in ROS 2 sind Python-Dateien, die die Konfiguration und das gleichzeitige Starten mehrerer Nodes strukturieren.

Voraussetzungen

Um launch files zu schreiben, benötigen wir das Paket roslaunch. Dieses installieren wir mit:

sudo apt install ros-humble-launch ros-humble-launch-ros

Einfaches Beispiel

Per Konvention liegen Launch-Dateien im launch-Ordner des jeweiligen Paketes.

cd ~/ros_ws/src/my_first_package
mkdir launch
cd launch
touch my_first.launch.py

Inhalt

Eine minimale Launch-Datei kann so aussehen:

from launch import LaunchDescription
import launch

def generate_launch_description():
    ld = LaunchDescription()
    logger = launch.logging.get_logger('my_launch_file')
    logger.info("Hello from my launch file")
    return ld

Charmant! Wir benötigen lediglich die Funktion generate_launch_description, die ein Objekt vom Typ LaunchDescription zurückgibt.

setup.py

Damit die Launch-Dateien auch aufrufbar werden, müssen sie wie Nodes im setup.py eingetragen werden.
Empfehlung: um nicht jede Launch-Datei einzeln angeben zu müssen, kann das glob-Modul verwendet werden.

import os
from glob import glob
setup(
    ..
    data_files=[
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
        (os.path.join('share', package_name, 'launch'), glob('launch/*.launch.py')),
    ],
    ..
)

Starten

Wenn wir jetzt colcon build und source install/setup.bash gemacht haben, können wir das launch file mit ros2 launch starten.

ros2 launch my_first_package my_first.launch.py 
[INFO] [launch]: All log files can be found below /home/jboegeholz/.ros/log/2025-10-01-21-03-44-500932-Ubuntu22-8545 
[INFO] [launch]: Default logging verbosity is set to INFO 
[INFO] [python_launch_file]: Hello from my launch file

Einen Node starten

Statt einen Node manuell über die CLI zu starten wie:

ros2 run demo_nodes_py talker

kannst du ihn in eine Launch-Datei integrieren.

Im Launch file müssen wir dafür 3 Dinge tun:
1. Inkludieren der Node-Klasse
2. Instantiieren eines Nodes mit dem package und executable Namen.
3. Mit der add_action-Methode den node zur LaunchDescription hinzufügen

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    ld = LaunchDescription()

    publisher_node = Node(
            package='demo_nodes_py',
            executable='talker',
            output='screen'
        )
    ld.add_action(publisher_node)
    return ld

name-Parameter

Wenn du denselben Node mehrfach starten möchtest, kannst du ihn über den Parameter name eindeutig benennen:

def generate_launch_description():
    ld = LaunchDescription()

    publisher_node_1 = Node(
            package='demo_nodes_py',
            executable='talker',
            name='noisy',
            output='screen'
        )
    publisher_node_2 = Node(
            package='demo_nodes_py',
            executable='talker',
            name='rowdy',
            output='screen'
        )
    ld.add_action(publisher_node_1)
    ld.add_action(publisher_node_2)
    return ld

ros2 launch my_first_package multiple_publisher.launch.py
[INFO] [launch]: All log files can be found below /home/jboegeholz/.ros/log/2025-10-01-21-04-35-427546-Ubuntu22-8559 
[INFO] [launch]: Default logging verbosity is set to INFO 
[INFO] [talker-1]: process started with pid [8560] 
[INFO] [talker-2]: process started with pid [8562] [talker-1] 
[INFO] [1759345476.604967867] [noisy]: Publishing: "Hello World: 0" [talker-2] 
[INFO] [1759345476.607008668] [rowdy]: Publishing: "Hello World: 0" [talker-2] 
[INFO] [1759345477.596242658] [rowdy]: Publishing: "Hello World: 1" [talker-1] 
[INFO] [1759345477.596370980] [noisy]: Publishing: "Hello World: 1" [talker-2] 

Launch-Dateien inkludieren

Du kannst Launch-Dateien modular aufbauen, indem du sie einbindest:

ld = LaunchDescription()

package_dir = get_package_share_directory('my_first_package')
publisher_launch_path = os.path.join(package_dir, 'launch', 'publisher.launch.py')
publisher_launch_description = IncludeLaunchDescription(PythonLaunchDescriptionSource(publisher_launch_path))
ld.add_action(publisher_launch_description)

Konfigurationsdateien an Nodes übergeben

Viele Nodes benötigen YAML-Konfigurationsdateien. Beispiel mit twist_mux:

def generate_launch_description():
    ld = LaunchDescription()
    package_path = get_package_share_directory('my_first_package')
    twist_mux_config_file_path = os.path.join(package_path, 'config', 'twist_mux.yaml')

    twist_mux = Node(
        package='twist_mux',
            executable='twist_mux',
                name='twist_mux',
                output='screen',
                parameters=[twist_mux_config_file_path]
            )

    ld.add_action(twist_mux)
    return ld

Shell-Kommandos

Du kannst auch Shell-Kommandos in Launch-Dateien ausführen:

from launch import LaunchDescription
from launch.actions import ExecuteProcess

def generate_launch_description():
    return LaunchDescription([
        ExecuteProcess(
            cmd=["echo", "Hello from the shell!"],
            output="screen"
        ),
    ])

Fazit

Launch-Dateien ermöglichen dir die strukturierte, wiederholbare und konfigurierbare Steuerung von ROS-2-Systemen.
Sie sind essenziell für größere Projekte – lokal wie auch in der Simulation oder auf echten Robotern.

The post So schreibst du Launch-Dateien für deinen Roboter appeared first on Creatronix.

Nodes sind in ROS die wichtigsten Bausteine, da sie Sensoren und Aktoren in der Software abstrahieren.
In ROS 1 waren Nodes einfach „da“. Sobald sie mit rosrun gestartet wurden, liefen sie. Stoppen bzw. Pausieren konnte man sie nur über Signale wie
SIGINT (STRG + C) oder SIGTSTP (STRG + Z)
In ROS 2 ermöglichen Lifecycle Nodes eine genaueer Steuerung. Man kann nun:

• Nodes nur aktivieren, wenn sie bereit sind
• Parameter vor der Aktivierung laden
• Knoten schrittweise prüfen
• Nodes ohne Neustart zurücksetzen oder neu starten

Ein Lifecycle-Node hat folgende 4 Zustände:

• Unconfigured
• Inactive
• Active
• Finalized

Zustände über CLI ändern

Die Zustandsübergänge lassen sich via CLI triggern.

ros2 lifecycle set /my_lifecycle_node configure 
ros2 lifecycle set /my_lifecycle_node activate 
ros2 lifecycle set /my_lifecycle_node deactivate 
ros2 lifecycle set /my_lifecycle_node shutdown

Code

Ein eigener kleiner LifecycleNode kann so implementiert werden:

import rclpy
from rclpy.lifecycle import LifecycleNode
from rclpy.lifecycle import State
from rclpy.lifecycle import TransitionCallbackReturn

class MyLifecycleNode(LifecycleNode):

    def __init__(self):
        super().__init__('my_lifecycle_node')

    def on_configure(self, state: State) -> TransitionCallbackReturn:
        self.get_logger().info('Configuring...')
        return TransitionCallbackReturn.SUCCESS

    def on_activate(self, state: State) -> TransitionCallbackReturn:
        self.get_logger().info('Activating...')
        return TransitionCallbackReturn.SUCCESS

    def on_deactivate(self, state: State) -> TransitionCallbackReturn:
        self.get_logger().info('Deactivating...')
        return TransitionCallbackReturn.SUCCESS

    def on_cleanup(self, state: State) -> TransitionCallbackReturn:
        self.get_logger().info('Cleaning up...')
        return TransitionCallbackReturn.SUCCESS

    def on_shutdown(self, state: State) -> TransitionCallbackReturn:
        self.get_logger().info('Shutting down...')
        return TransitionCallbackReturn.SUCCESS

def main(args=None):
    rclpy.init(args=args)
    node = MyLifecycleNode()
    rclpy.spin(node)
    rclpy.shutdown()

if __name__ == '__main__':
    main()

The post So funktionieren Lifecycle-Nodes in ROS2 appeared first on Creatronix.

Wenn du mit ROS2 arbeitest, wirst du früher oder später auf ein Tool namens RQt stoßen.
Der Name steht für “ROS Qt” – und genau das ist es auch: eine Qt-basierte GUI-Sammlung,
die verschiedene Werkzeuge modular integriert.
Egal ob Debugging, Visualisierung oder Testen – RQt bietet dir viele praktische Funktionen direkt per Mausklick.

Installation

Wie bei den meisten ROS-Paketen kannst du RQt unter Ubuntu über apt installieren.

sudo apt update 
sudo apt install ros-<ros2-distro>-rqt*

Ersetze mit deiner installierten ROS2-Distribution, z. B. humble, jazzy oder rolling.

RQt starten

RQt lässt sich ganz einfach starten mit:

rqt

Nach dem Start erscheint das RQt-Hauptfenster – anfangs noch leer, aber bereit für Plugins.

Konsole überwachen (Console Monitoring)

Sehr nützlich ist die integrierte Funktion, die ROS2-Konsolenausgaben zu monitoren:

Menüpunkt

Plugins -> Logging -> Console

Topic Monitor

Alle aktiven Topics in deinem ROS2-Netzwerk kannst du mit dem Topic Monitor überwachen. Damit siehst du z. B. welche Daten gerade über

self.publisher = self.create_publisher(String, "robot_news", 10)

gesendet werden.

Menüpunkt

Plugins -> Topics -> Topic Monitor

Nachrichten senden (Message Publisher)

Natürlich kannst du auch selbst Nachrichten auf ein Topic publizieren – direkt aus der GUI heraus!

Menüpunkt

Plugins -> Topics -> Message Publisher

Services aufrufen (Service Caller)

Genauso einfach wie beim Publizieren von Messages kannst du mit RQt auch ROS2-Services aufrufen.
Beispiel Service:

self.server = self.create_service(AddTwoInts, "add_two_ints", self.callback_add_two_ints)

Plugins -> Services -> Service Caller

Plugins -> Introspection -> Node Graph

Perspectives -> Create Perspective

rqt --clear-config

The post RQt – Diese ROS Pakete solltest du kennen appeared first on Creatronix.

The post So machst du deinen Line Follower schneller appeared first on Creatronix.