Utilisation de Python, XML et YAML pour les fichiers de lancement ROS 2

Les fichiers de lancement ROS 2 peuvent être écrits en Python, XML et YAML. Ce guide montre comment utiliser ces différents formats pour accomplir la même tâche, ainsi qu’une discussion sur le moment d’utilisation de chaque format.

Exemples de fichiers de lancement

Vous trouverez ci-dessous un fichier de lancement implémenté en Python, XML et YAML. Chaque fichier de lancement effectue les actions suivantes :

• Configurer les arguments de ligne de commande avec les valeurs par défaut

• Inclure un autre fichier de lancement

• Inclure un autre fichier de lancement dans un autre espace de noms

• Démarrer un nœud et définir son espace de noms

• Démarrez un nœud, définissez son espace de noms et définissez les paramètres de ce nœud (à l’aide des arguments)

• Créer un nœud pour remapper les messages d’un sujet à un autre

PythonXMLYAML

# example.launch.py

import os

from ament_index_python import get_package_share_directory

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.actions import IncludeLaunchDescription
from launch.actions import GroupAction
from launch.launch_description_sources import PythonLaunchDescriptionSource
from launch.substitutions import LaunchConfiguration
from launch.substitutions import TextSubstitution
from launch_ros.actions import Node
from launch_ros.actions import PushROSNamespace


def generate_launch_description():

    # args that can be set from the command line or a default will be used
    background_r_launch_arg = DeclareLaunchArgument(
        "background_r", default_value=TextSubstitution(text="0")
    )
    background_g_launch_arg = DeclareLaunchArgument(
        "background_g", default_value=TextSubstitution(text="255")
    )
    background_b_launch_arg = DeclareLaunchArgument(
        "background_b", default_value=TextSubstitution(text="0")
    )
    chatter_ns_launch_arg = DeclareLaunchArgument(
        "chatter_ns", default_value=TextSubstitution(text="my/chatter/ns")
    )

    # include another launch file
    launch_include = IncludeLaunchDescription(
        PythonLaunchDescriptionSource(
            os.path.join(
                get_package_share_directory('demo_nodes_cpp'),
                'launch/topics/talker_listener.launch.py'))
    )
    # include another launch file in the chatter_ns namespace
    launch_include_with_namespace = GroupAction(
        actions=[
            # push_ros_namespace to set namespace of included nodes
            PushROSNamespace('chatter_ns'),
            IncludeLaunchDescription(
                PythonLaunchDescriptionSource(
                    os.path.join(
                        get_package_share_directory('demo_nodes_cpp'),
                        'launch/topics/talker_listener.launch.py'))
            ),
        ]
    )

    # start a turtlesim_node in the turtlesim1 namespace
    turtlesim_node = Node(
            package='turtlesim',
            namespace='turtlesim1',
            executable='turtlesim_node',
            name='sim'
        )

    # start another turtlesim_node in the turtlesim2 namespace
    # and use args to set parameters
    turtlesim_node_with_parameters = Node(
            package='turtlesim',
            namespace='turtlesim2',
            executable='turtlesim_node',
            name='sim',
            parameters=[{
                "background_r": LaunchConfiguration('background_r'),
                "background_g": LaunchConfiguration('background_g'),
                "background_b": LaunchConfiguration('background_b'),
            }]
        )

    # perform remap so both turtles listen to the same command topic
    forward_turtlesim_commands_to_second_turtlesim_node = Node(
            package='turtlesim',
            executable='mimic',
            name='mimic',
            remappings=[
                ('/input/pose', '/turtlesim1/turtle1/pose'),
                ('/output/cmd_vel', '/turtlesim2/turtle1/cmd_vel'),
            ]
        )

    return LaunchDescription([
        background_r_launch_arg,
        background_g_launch_arg,
        background_b_launch_arg,
        chatter_ns_launch_arg,
        launch_include,
        launch_include_with_namespace,
        turtlesim_node,
        turtlesim_node_with_parameters,
        forward_turtlesim_commands_to_second_turtlesim_node,
    ])

Utilisation des fichiers de lancement à partir de la ligne de commande

Lancement

N’importe lequel des fichiers de lancement ci-dessus peut être exécuté avec ros2 launch. Pour les essayer localement, vous pouvez soit créer un nouveau package et utiliser

ros2 launch <package_name> <launch_file_name>

ou exécutez le fichier directement en spécifiant le chemin vers le fichier de lancement

ros2 launch <path_to_launch_file>

Définition des arguments

Pour définir les arguments passés au fichier de lancement, vous devez utiliser la syntaxe key:=value. Par exemple, vous pouvez définir la valeur de background_r de la manière suivante :

ros2 launch <package_name> <launch_file_name> background_r:=255

ou alors

ros2 launch <path_to_launch_file> background_r:=255

Contrôler les tortues

Pour tester que le remappage fonctionne, vous pouvez contrôler les tortues en exécutant la commande suivante dans un autre terminal :

ros2 run turtlesim turtle_teleop_key --ros-args --remap __ns:=/turtlesim1

Python, XML ou YAML : lequel dois-je utiliser ?

Note

Les fichiers de lancement dans ROS 1 ont été écrits en XML, donc XML est peut-être le plus familier aux personnes venant de ROS 1. Pour voir ce qui a changé, vous pouvez visiter Migration des fichiers de lancement de ROS 1 vers ROS 2.

Pour la plupart des applications, le choix du format de lancement de ROS 2 dépend des préférences du développeur. Toutefois, si votre fichier de lancement nécessite une flexibilité que vous ne pouvez pas obtenir avec XML ou YAML, vous pouvez utiliser Python pour écrire votre fichier de lancement. L’utilisation de Python pour le lancement de ROS 2 est plus flexible pour les deux raisons suivantes :

• Python est un langage de script, et vous pouvez donc tirer parti du langage et de ses bibliothèques dans vos fichiers de lancement.

• ros2/launch (fonctionnalités de lancement générales) et ros2/launch_ros (fonctionnalités de lancement spécifiques à ROS 2 ) sont écrits en Python et vous avez donc un accès de niveau inférieur pour lancer des fonctionnalités qui peuvent ne pas être exposées par XML et YAML.

Cela étant dit, un fichier de lancement écrit en Python peut être plus complexe et verbeux qu’un fichier en XML ou YAML.