So schreibst du Launch-Dateien für deinen Roboter

Table of Contents

Motivation

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.