Outils, Launch et visualisation de ROS2

17 Outil de commande commun

17 Outil de commande commun (CLI Tools)

17.1 Outil de gestion des paquets ros2 pkg

17.1.1 ros2 pkg create

Fonction : Créer un paquet fonctionnel, qui nécessite le nom du paquet, la façon dont il est compilé, les dépendances, etc.

Format :

ros2 pkg create <package_name> --build-type <build-type> --dependencies <dependencies>

Dans la commande ros2 :

pkg : indique les fonctions associées au paquet fonctionnel ;

create : indique la création d'un paquet fonctionnel ;

Nom du paquet : obligatoire : nom du nouveau paquet fonctionnel ;

build-type : obligatoire : indique si le paquet de fonctionnalités nouvellement créé est C++ ou Python, si C++ ou C est utilisé, alors c'est ament_cmake, et si Python est utilisé, ament_python ;

Options : le paquet de fonctionnalités C++ doit contenir rclcpp, le paquet de fonctionnalités Python doit contenir rclpy, et d'autres dépendances ;

17.1.2 ros2 pkg list

Fonction : Voir la liste des paquets fonctionnels dans le système

ros2 pkg list

17.1.3 ros2 pkg executables

Fonction : Voir tous les exécutables dans un paquet

ros2 pkg executables <pkg_name>

17.2 Exécution de nœud ros2 run

Fonction : Exécuter le programme du nœud du paquet fonctionnel

ros2 run <pkg_name> <node_name>

17.3 Outils liés aux nœuds

17.3.1 ros2 node list

ros2 node list

17.3.2 ros2 node info

ros2 node info <node_name>

17.4 Outils liés aux topics

17.4.1 ros2 topic list

ros2 topic list

17.4.2 ros2 topic info

ros2 topic info <topic_name>

17.4.3 ros2 topic type

ros2 topic type <topic_name>

17.4.4 ros2 topic hz

ros2 topic hz <topic_name>

17.4.5 ros2 topic echo

ros2 topic echo <topic_name>

17.4.6 ros2 topic pub

ros2 topic pub <topic_name> <message_type> <message_content>

Exemple :

ros2 topic pub turtle1/cmd_vel geometry_msgs/msg/Twist "{linear: {x: 0.5, y: 0.0, z: 0.0}, angular: {x: 0.0, y: 0.0, z: 0.2}}"

17.5 Outils liés aux interfaces ros2

ros2 interface list
ros2 interface show <interface_name>

17.6 Outils liés aux services

ros2 service list
ros2 service call /spawn turtlesim/srv/Spawn "{x: 2, y: 2, theta: 0.2, name: 'turtle10'}"

17.7 Étapes suivantes

18 Utilisation de RViz2 - Apprendre la visualisation RViz2

2. 19 Boîte à outils Rqt - Apprendre l'outil Rqt

18 Utilisation de RViz2

18 Utilisation de RViz2 (RViz2 Vision)

18.1 Vue d'ensemble de RViz2

Rviz2 est l'outil de visualisation tridimensionnelle le plus couramment utilisé dans ROS 2 pour visualiser l'état opérationnel des systèmes robotiques. Il peut s'abonner et afficher une variété de données de topic ROS 2, telles que des nuages de points de radar laser, des cartes, des modèles robotiques (URDF), des conversions de coordonnées TF, des trajectoires de planification de chemins et des images de caméra, et aider les développeurs à vérifier rapidement si les capteurs, le positionnement, la navigation, etc. fonctionnent.

18.2 Travail préparatoire

S'il y a un vrai robot, il peut démarrer l'exercice rviz au niveau du contrôle maître du robot. S'il n'y a pas de vrai robot, nous pouvons démarrer turtlebot3 de manière réaliste avec gazebo, en imitant un radar laser, une caméra, etc., afin que les données suivantes puissent être visualisées.

Installer le paquet d'émulateur Turtlebot3

sudo apt install ros-${ROS_DISTRO}-turtlebot3*

Installation des ponts ros et gazebo

sudo apt install ros-humble-ros-gz -y

Définir la variable d'environnement turtlebot3

export TURTLEBOT3_MODEL=waffle

Démarrer l'environnement de simulation gazebo

# source /opt/ros/humble/setup.bash
ros2 launch turtlebot3_gazebo turtlebot3_world.launch.py

Remarque : Jetson peut ne pas pouvoir démarrer, cette opération s'exécute sur un PC X86

18.3 Démarrage de Rviz2

Démarre un terminal et peut être activé avec la commande suivante :

rviz2

Remarque : Si démarré dans docker, assurez-vous que l'affichage GUI est ouvert.

18.4 Visualisation des données d'image

Cliquez sur Add dans la fenêtre Displays gauche pour trouver l'élément d'affichage Image, OK pour ajouter la liste d'affichage après confirmation, puis configurer le topic d'image pour l'élément d'affichage, afin que vous puissiez voir l'image de la caméra du robot.

Sélectionner Fixed Frame aux coordonnées base_footprint

Sélectionner le Topic Camera Color

Maintenant, nous pouvons voir la vision du robot de simulation actuel dans la fenêtre Camera.

18.5 Visualisation des données radar

Cliquez sur Add dans la fenêtre Displays à gauche, sélectionnez Laserscan, et configurez le nom du sujet pour l'abonnement.

Sélection de topic pour LaserScan

À ce stade, nous pouvons voir les contours du radar laser.

18.6 Visualisation des modèles robotiques

Cliquez sur Add dans la fenêtre Displays gauche, sélectionnez RobotModel

Sélectionnez le topic pour robotDescriptionTopic

Nous pouvons voir la visualisation des robots dans Rviz2.

18.7 Visualisation d'autres données

Les plugins par défaut rivz listent de nombreux plugins de visualisation de données couramment utilisés que vous pouvez utiliser à un moment ou un autre.

18.8 Étapes suivantes

1. 19 Boîte à outils Rqt - Apprendre l'outil Rqt

2. 20 Configuration Launch - Apprendre la configuration Launch

19 Boîte à outils Rqt

19 Boîte à outils Rqt (Rqt Tools)

19.1 Vue d'ensemble de Rqt

rqt est un cadre d'outils graphiques basé sur Qt dans ROS qui intègre de nombreuses fonctions courantes dans une interface visuelle via des plugins. Les développeurs peuvent visualiser et déboguer le système en visualisant rqt, par exemple la distribution/abonnement de Topic, la surveillance des nœuds et des communications (rqt graph), la visualisation en temps réel des journaux (rqt console), le référencement dynamique (rqt reconfigure) et le dessin des données d'analyse (rqt plot).

19.2 Installation

La boîte à outils rqt est généralement installée par défaut tant que la version de bureau est installée ; si l'installation de ros2 n'est pas une version complète de l'installation, elle peut être installée comme suit :

sudo apt install ros-${ROS_DISTRO}-rqt*

19.3 Lancement

Les ordres de démarrage rqt courants sont :

# Method 1: run `rqt` in the terminal
rqt

# Method 2
ros2 run rqt_gui rqt_gui

19.4 Utilisation des plugins

Après le démarrage de rqt, vous pouvez ajouter les plugins requis via plugins :

Ouvrez un exemple de petite tortue pour voir les abonnements aux nœuds :

# Terminal 1:
ros2 run turtlesim turtlesim_node
# Terminal 2:
ros2 run turtlesim turtle_teleop_key
# Terminal 3:
rqt

19.4.1 Plugins topic

Ajoute des plugins de topic et envoie des commandes de vitesse pour contrôler le mouvement de la tortue.

19.4.2 Plugin de service

Ajoute un plugin de service et envoie une demande pour créer une tortue à un emplacement donné.

19.4.3 Plugins de paramètres

Modifie dynamiquement la couleur d'arrière-plan du formulaire de la tortue via le plugin de paramètres.

19.5 Étapes suivantes

1. 20 Configuration Launch - Apprendre la configuration Launch

Enregistrement et lecture - apprendre l'enregistrement de paquets

20 Configuration Launch

20 Configuration Launch (Launch Files)

20.1 Vue d'ensemble de Launch

Le fichier de démarrage Launch dans ROS est utilisé pour la gestion intégrée et l'activation de plusieurs nœuds/composants et est essentiellement un script de démarrage au niveau du système. Il peut être préparé par Python (le plus couramment), XML ou YAML, prenant en charge l'activation simultanée de plusieurs nœuds, la définition de paramètres, le remappage de topics, le chargement d'espaces de noms, la configuration de variables d'environnement et la réalisation de contrôles logiques plus avancés, tels que le démarrage conditionnel, le démarrage retardé, le déclenchement par incident, etc.

20.2 Lancement d'un seul nœud Node

20.2.1 Paquets préparatoires

cd ~/workspaces/src
ros2 pkg create learn_launch --build-type ament_python

20.2.2 Nouveau fichier launch

Crée un nouveau dossier launch sous le paquet fonctionnel, puis crée un nouveau fichier single_node_launch.py dans le dossier launch pour copier ce qui suit :

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
  node = Node(
  package='pkg_helloworld_py',
  executable='helloworld',
  output='screen'
  )
  return LaunchDescription([node])

20.2.3 Fichiers de configuration setup.py

Le fichier launch est souvent nommé d'après LaunchName_launch.py, où LaunchName est personnalisé et _launch.py est souvent considéré comme fixe. Vous devez modifier le fichier setup.py sous le paquet fonctionnel pour ajouter le document sous le chemin launch afin que vous puissiez compiler le fichier .py pour exécution

# 1. Import the required header files
import os
from glob import glob

# 2. Add the `launch` path and its `launch.py` file to the `data_files` list
(os.path.join('share',package_name,'launch'),glob(os.path.join('launch','*launch.py')))

20.2.4 Compilation du paquet fonctionnel

cd ~/workspaces
colcon build --packages-select learn_launch

20.2.5 Procédures opérationnelles

# Refresh environment variables
source install/setup.bash
ros2 launch learn_launch single_node_launch.py

20.2.6 Analyse du code source

Importer la bibliothèque associée

from launch import LaunchDescription
from launch_ros.actions import Node

Définit une fonction generate_launch_description et renvoie une description launch

def generate_launch_description():
  node = Node(
  package='pkg_helloworld_py',
  executable='helloworld',
  )
  return LaunchDescription([node])

Définit la valeur de retour qu'un Node de variable démarre comme un nœud, appelle la fonction Node et démarre deux paramètres importants, type et executable.

Package : indique le paquet fonctionnel, représentant le nom du paquet fonctionnel.

Executable : indique la procédure exécutée, le nom de la procédure exécutable.

Le dernier appel à la fonction LaunchDescription est de saisir le paramètre node pour exécuter le retour.

return LaunchDescription([node])

20.3 launch de plusieurs nœuds Node

20.3.1 Nouveau fichier launch

Nouveau fichier multi_node_launch.py, ajoutez ce qui suit :

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
  publisher_node = Node(
  package='pkg_topic',
  executable='publisher_demo',
  output='screen'
  )
  subscriber_node = Node(
  package='pkg_topic',
  executable='subscriber_demo',
  output='screen'
  )
  return LaunchDescription([
  publisher_node,
  subscriber_node
  ])

20.3.2 Compilation du paquet fonctionnel

colcon build --packages-select learn_launch

20.3.3 Procédures opérationnelles

# Refresh environment variables
source install/setup.bash
ros2 launch learn_launch multi_node_launch.py

Si le terminal n'imprime pas le contenu, vous pouvez voir quels nœuds sont activés pour vérifier si le démarrage a réussi.

ros2 node list

20.3.4 Résolution de la source

C'est comme single_node_launch.py, juste un autre nœud !

20.4 Cas de remappage de topics

20.4.1 Nouveau fichier launch

Crée un nouveau fichier remap_name_launch.py sous le répertoire multi_node_launch.py, ajoutant ce qui suit :

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
  publisher_node = Node(
  package='pkg_topic',
  executable='publisher_demo',
  output='screen',
  remappings=[("/topic_demo", "/topic_update")]
  )
  return LaunchDescription([
  publisher_node
  ])

20.4.2 Compilation du paquet fonctionnel

colcon build --packages-select learn_launch

20.4.3 Procédures opérationnelles

# ros2 launch learn_launch multi_node_launch.py
ros2 topic list

# Refresh the environment variables and run the remapped-topic program to observe the changes:
source install/setup.bash
ros2 launch learn_launch remap_name_launch.py
ros2 topic list

20.4.4 Analyse du code source

remappings=[("/topic_demo", "/topic_update")]

Voici pour remapper le topic original /topic_demo vers /topic_update.

20.5 Le fichier Launch intégrant démarre un autre fichier launch

20.5.1 Nouveau fichier launch

Nouveau include_launch.py sous le répertoire multi_node_launch.py, ajoutez ce qui suit :

from launch import LaunchDescription
from launch_ros.actions import Node
import os
from launch.actions import IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource
from ament_index_python.packages import get_package_share_directory

def generate_launch_description():
  hello_launch = IncludeLaunchDescription(PythonLaunchDescriptionSource(
  [os.path.join(get_package_share_directory('learn_launch'), 'launch'),
  '/multi_node_launch.py']),
  )
  return LaunchDescription([
  hello_launch
  ])

20.5.2 Compilation du paquet fonctionnel

colcon build --packages-select learn_launch

20.5.3 Procédures opérationnelles

# Refresh environment variables
source install/setup.bash
ros2 launch learn_launch include_launch.py

20.5.4 Analyse du code source

L'incorporation du fichier launch nécessite l'utilisation des catégories IncludeLaunchDescription et PythonLaunchDescriptionSource du système launch

os.path.join (get_package_share_directory('learn_launch') : prend la position du paquet fonctionnel, où le nom du paquet fonctionnel est learn_launch ;

'launch' : signifie un dossier contenant les fichiers launch sous un paquet fonctionnel ;

'/multi_node_launch.py' : désigne un fichier /multi_node_launch.py sous le dossier launch.

20.6 Exemples de fichiers launch composés

Cette démo montre principalement comment les fichiers launch complexes sont préparés, et la fonctionnalité du programme est négligeable.

20.6.1 Nouveau fichier launch

Crée un nouveau fichier complex_launch.py sous le répertoire multi_node_launch.py, ajoutant ce qui suit :

# complex_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(LaunchConfiguration('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,
  ])

20.6.2 Compilation du workspace

colcon build --packages-select learn_launch

20.6.3 Procédures opérationnelles

# source install/setup.bash
ros2 launch learn_launch complex_launch.py

Deux tortues seront affichées sur Jetson.

Démarrez le nœud de contrôle clavier et ajoutez l'espace de noms (parce que nous avons ajouté l'espace de noms lors du démarrage du nœud dans les fichiers launch)

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

Utilisez les boutons droite et gauche pour contrôler le mouvement de la tortue 1. La tortue 2 est une copie parfaite de la tortue 1.

20.6.4 Description de la procédure

Le processus consistait principalement en l'initiation :

Un, demo_nodes_cpp talker_lister,

2. Nœud talker_lister avec espace de noms

Trois, turtlesim1 est une petite tortue dans un espace nommé.

4 et Turtlesim2 sont des espaces nommés pour turtles2

Cinq, remagnify pour que les deux tortues puissent entendre le même thème de commande.

20.7 Implémentation xml

20.7.1 Nouveau fichier launch

Nouveau fichier Complex_Launch.py sous le répertoire de complex_launch.xml, ajoutez ce qui suit :

<launch>

  <!-- args that can be set from the command line or a default will be used -->
  <arg name="background_r" default="0"/>
  <arg name="background_g" default="255"/>
  <arg name="background_b" default="0"/>
  <arg name="chatter_ns" default="my/chatter/ns"/>

  <!-- include another launch file -->
  <include file="$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener.launch.py"/>
  <!-- include another launch file in the chatter_ns namespace-->
  <group>
  <!-- push-ros-namespace to set namespace of included nodes -->
  <push-ros-namespace namespace="$(var chatter_ns)"/>
  <include file="$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener.launch.py"/>
  </group>

  <!-- start a turtlesim_node in the turtlesim1 namespace -->
  <node pkg="turtlesim" exec="turtlesim_node" name="sim" namespace="turtlesim1"/>
  <!-- start another turtlesim_node in the turtlesim2 namespace
  and use args to set parameters -->
  <node pkg="turtlesim" exec="turtlesim_node" name="sim" namespace="turtlesim2">
  <param name="background_r" value="$(var background_r)"/>
  <param name="background_g" value="$(var background_g)"/>
  <param name="background_b" value="$(var background_b)"/>
  </node>
  <!-- perform remap so both turtles listen to the same command topic -->
  <node pkg="turtlesim" exec="mimic" name="mimic">
  <remap from="/input/pose" to="/turtlesim1/turtle1/pose"/>
  <remap from="/output/cmd_vel" to="/turtlesim2/turtle1/cmd_vel"/>
  </node>
</launch>

20.7.2 Configuration du fichier setup.py

Le système doit configurer le fichier compilé et copier nos fichiers launch .xml vers le répertoire d'installation install pour trouver nos fichiers

(os.path.join('share',package_name,'launch'),glob(os.path.join('launch','*launch.xml'))),

20.7.3 Compilation du paquet fonctionnel

cd ~/workspaces
colcon build --packages-select learn_launch

20.7.4 Procédures opérationnelles

# ros2 launch learn_launch complex_launch.xml

Deux petites tortues sont attendues, et le terminal imprime des informations de journal.

Démarrez le nœud de contrôle clavier et ajoutez l'espace de noms

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

20.8 Implémentation Yaml

20.8.1 Nouveau fichier launch

Nouveau fichier Complex_Launch.yaml sous le répertoire de complex_launch.py, ajoutez ce qui suit :

launch:

# args that can be set from the command line or a default will be used
- arg:
  name: "background_r"
  default: "0"
- arg:
  name: "background_g"
  default: "255"
- arg:
  name: "background_b"
  default: "0"
- arg:
  name: "chatter_ns"
  default: "my/chatter/ns"


# include another launch file
- include:
  file: "$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener.launch.py"

# include another launch file in the chatter_ns namespace
- group:
  - push-ros-namespace:
  namespace: "$(var chatter_ns)"
  - include:
  file: "$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener.launch.py"

# start a turtlesim_node in the turtlesim1 namespace
- node:
  pkg: "turtlesim"
  exec: "turtlesim_node"
  name: "sim"
  namespace: "turtlesim1"

# start another turtlesim_node in the turtlesim2 namespace and use args to set parameters
- node:
  pkg: "turtlesim"
  exec: "turtlesim_node"
  name: "sim"
  namespace: "turtlesim2"
  param:
  -
  name: "background_r"
  value: "$(var background_r)"
  -
  name: "background_g"
  value: "$(var background_g)"
  -
  name: "background_b"
  value: "$(var background_b)"

# perform remap so both turtles listen to the same command topic
- node:
  pkg: "turtlesim"
  exec: "mimic"
  name: "mimic"
  remap:
  -
  from: "/input/pose"
  to: "/turtlesim1/turtle1/pose"
  -
  from: "/output/cmd_vel"
  to: "/turtlesim2/turtle1/cmd_vel"

20.8.2 Configuration

Vous devez configurer le fichier compilé pour copier nos fichiers launch au format .yaml dans le répertoire d'installation Install avant que le système ros puisse trouver nos fichiers

(os.path.join('share',package_name,'launch'),glob(os.path.join('launch','*launch.yaml'))),

20.8.3 Compilation du paquet fonctionnel

colcon build --packages-select learn_launch

20.8.4 Procédures opérationnelles

# Refresh environment variables
source install/setup.bash
ros2 launch learn_launch complex_launch.yaml

Démarrez le nœud de contrôle clavier et ajoutez l'espace de noms

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

Utilisation du contrôle clavier pour activer la tortue un, la tortue deux est une imitation parfaite de la tortue un.

20.9 Étapes suivantes

1.21 Enregistrement et lecture - apprendre l'enregistrement de paquets

2. 22 Modèles URL - apprendre la modélisation robotique

21 Enregistrement et lecture

21 Lecture d'enregistrement

21.1 Vue d'ensemble de Rosbag2