Interfaces avancées et middleware de ROS2

10 Transformation de coordonnées TF2

10 Transformation de coordonnées TF2 (TF2 Transform)

10.1 Vue d'ensemble de TF2

10.1.1 Qu'est-ce que TF2

TF2 (Transform 2) est la bibliothèque utilisée dans ROS 2 pour gérer les changements de coordonnées. Elle suit les relations entre plusieurs systèmes de coordonnées et permet aux développeurs de convertir les données (par exemple, point, vecteur, attitude) entre différents systèmes de coordonnées.

10.1.2 Utilisation de TF2

Appliquer	Annotations
Intégration de capteurs	Convertir les données de différents capteurs au système de coordonnées unifié
Navigation	Convertir le système de coordonnées de la carte en coordonnées robotiques.
Bras mécanique	Calcule l'attitude de l'implémenteur terminal sur la base
Visualiser	Afficher correctement l'état du robot dans RViz2

10.1.3 Désignation des coordonnées

Nom	Objectif
Map	Coordonnées globales/du monde, fixes et inchangées
odom	Le système de coordonnées kilométriques pour le positionnement.
base_link	Le système de coordonnées de la base du robot.
base_footprint	Le projet de châssis du robot au sol.
Camera_link	Système de coordonnées de la caméra
Laser_link	Système de coordonnées du radar laser

23, coordonnées converties ROS2 TF2.

Introduction à TF2

Les systèmes coordonnés sont un concept très familier et un fondement important en robotique, et il y aura de nombreux systèmes de coordination dans un système robotique complet, et comment l'emplacement de ces coordonnées doit-il être géré ? ROS nous a fourni un décorateur coordonné : TF2

2. Systèmes de coordonnées dans les robots

Les coordonnées sont également importantes dans les systèmes robotiques mobiles, comme par exemple le point central d'un robot mobile est base_link, la position du radar est appelée laser_link de coordonnées du radar, où le robot se déplace, et le mètre cube s'accumule, ce qui s'appelle odom, ce qui à son tour a une erreur cumulative et une dérive, et l'emplacement absolu est appelé coordonnées de la carte Map.

Le principe de base de la fonction TF dans ROS est que ces variations mathématiques sont encapsulées, et des connaissances théoriques détaillées sont disponibles à tous dans le programme de robotique, et nous expliquons principalement comment les systèmes de gestion de coordonnées TF sont utilisés.

3 Opérations de ligne de commande TF

3.1. Installation des outils

bash

sudo apt install ros-${ROS_DISTRO}-turtle-tf2-py ros-humble-tf2-tools
sudo pip3 install transforms3d
sudo apt install ros-${ROS_DISTRO}-rqt-tf-tree

3.2. Démarrer

bash

# ros2 launch turtle_tf2_py turtle_tf2_demo.launch.py
ros2 run turtlesim turtle_teleop_key

3.3. Voir l'arbre TF

bash

ros2 run rqt_tf_tree rqt_tf_tree

3.4. Coordonnées de requête pour modifier les informations

bash

ros2 run tf2_ros tf2_echo turtle2 turtle1

3.5. Visualisation des coordonnées

bash

rviz2

4. Conversion de coordonnées statiques

4.1. Distribution des positions A à B

bash

ros2 run tf2_ros static_transform_publisher 0 0 3 0 0 3.14 A B

4.2. Interception/accès aux relations TF

bash

ros2 run tf2_ros tf2_echo A B

4.3, visualisation rivz

bash

rviz2

5. Présentation des cas

7. Nouveau paquet de fonctionnalités

bash

ros2 pkg create pkg_tf --build-type ament_python --dependencies rclpy --node-name turtle_tf_broadcaster

bash

import math
import rclpy
from rclpy.node import Node
from geometry_msgs.msg import TransformStamped
from tf2_ros import TransformBroadcaster
from turtlesim.msg import Pose

def quaternion_from_euler(roll, pitch, yaw):
  cy = math.cos(yaw * 0.5)
  sy = math.sin(yaw * 0.5)
  cp = math.cos(pitch * 0.5)
  sp = math.sin(pitch * 0.5)
  cr = math.cos(roll * 0.5)
  sr = math.sin(roll * 0.5)

  w = cr * cp * cy + sr * sp * sy
  x = sr * cp * cy - cr * sp * sy
  y = cr * sp * cy + sr * cp * sy
  z = cr * cp * sy - sr * sp * cy

  return (x, y, z, w)

class TurtleTFBroadcaster(Node):
  def __init__(self, name):
  super().__init__(name)
  self.turtlename = self.declare_parameter('turtlename', 'turtle').value
  self.tf_broadcaster = TransformBroadcaster(self)
  self.subscription = self.create_subscription(
  Pose,
  f'/{self.turtlename}/pose',
  self.turtle_pose_callback, 1)

  def turtle_pose_callback(self, msg):
  transform = TransformStamped()
  transform.header.stamp = self.get_clock().now().to_msg()
  transform.header.frame_id = 'world'
  transform.child_frame_id = self.turtlename
  transform.transform.translation.x = msg.x
  transform.transform.translation.y = msg.y
  transform.transform.translation.z = 0.0
  q = quaternion_from_euler(0, 0, msg.theta)
  transform.transform.rotation.x = q[0]
  transform.transform.rotation.y = q[1]
  transform.transform.rotation.z = q[2]
  transform.transform.rotation.w = q[3]

  self.tf_broadcaster.sendTransform(transform)

def main(args=None):
  rclpy.init(args=args)
  node = TurtleTFBroadcaster("turtle_tf_broadcaster")
  rclpy.spin(node)
  node.destroy_node()
  rclpy.shutdown()

python

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node

def generate_launch_description():
  return LaunchDescription([
  DeclareLaunchArgument('source_frame', default_value='turtle1', description='Target frame name.'),
  Node(package='turtlesim', executable='turtlesim_node'),
  Node(package='pkg_tf', executable='turtle_tf_broadcaster',
  name='broadcaster1', parameters=[{'turtlename': 'turtle1'}]),
  Node(package='pkg_tf', executable='turtle_tf_broadcaster',
  name='broadcaster2', parameters=[{'turtlename': 'turtle2'}]),
  Node(package='pkg_tf', executable='turtle_following',
  name='listener', parameters=[{'source_frame': LaunchConfiguration('source_frame')}]),
  ])

8. Modifier les fichiers de configuration

bash

import os
from glob import glob

bash

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

9. Compilateur du paquet fonctionnel

bash

colcon build --packages-select pkg_tf

Procédures opérationnelles

bash

# source install/setup.bash
ros2 launch pkg_tf turtle_following.launch.py

bash

ros2 run turtlesim turtle_teleop_key

Message d'interface personnalisé

11 Messages d'interface personnalisés

Dans le système ROS, les trois types de mécanismes de communication, Topic, Service et Action, dépendent tous d'un concept central : l'interface de communication.

11.1 Créer un processus d'interface personnalisé

Les principales étapes sont les suivantes :

Créer un paquet fonctionnel d'interface

Créer et modifier des fichiers .msg, des fichiers .srv, des fichiers .action

Modifier le fichier de configuration

Compiler

Tester

11.2 Créer une interface personnalisée pour les communications d'action

11.3 Créer une interface personnalisée pour les communications de topic

bash

string  name
int32  age
float64  height

bash

# CMakeLists.txt
rosidl_generate_interfaces(${PROJECT_NAME}
  "action/Progress.action"
  "msg/Person.msg"
)

bash

# package.xml
<buildtool_depend>rosidl_default_generators</buildtool_depend>
<exec_depend>rosidl_default_runtime</exec_depend>
<depend>action_msgs</depend>
<member_of_group>rosidl_interface_packages</member_of_group>

bash

cd ~/workspace
colcon build --packages-select pkg_interfaces

bash

ros2 interface show pkg_interfaces/msg/Person

11.4 Créer une interface personnalisée pour les communications de service

bash

int32 num1
int32 num2
---
int32 sum

bash

rosidl_generate_interfaces(${PROJECT_NAME}
  "action/Progress.action"
  "msg/Person.msg"
  "srv/Add.srv"
)

bash

<buildtool_depend>rosidl_default_generators</buildtool_depend>
<exec_depend>rosidl_default_runtime</exec_depend>
<depend>action_msgs</depend>
<member_of_group>rosidl_interface_packages</member_of_group>

bash

cd ~/workspace
colcon build --packages-select pkg_interfaces
source install/setup.bash

bash

ros2 interface show pkg_interfaces/srv/Add

11.5 Étapes suivantes

1.12 Cas de service de paramètres

2.13 Paquets de méta-fonctions

12 Cas de service de paramètres

12 Services de paramètres (Parameters)

12.1 Vue d'ensemble des paramètres

Dans les systèmes robotiques ROS, les paramètres agissent comme des variables globales C++ et fournissent des mécanismes de partage de données faciles pour plusieurs nœuds.

12.2 Paramètres dans la routine de la petite tortue

bash

ros2 run turtlesim turtlesim_node
ros2 run turtlesim turtle_teleop_key

bash

ros2 param list

bash

ros2 param describe turtlesim background_b
ros2 param get turtlesim background_b
ros2 param set turtlesim background_b 10

bash

ros2 param dump turtlesim >> turtlesim.yaml
ros2 param load turtlesim turtlesim.yaml

12.3 Cas de paramètres

12.3.1 Nouveau paquet de fonctionnalités

bash

ros2 pkg create pkg_param --build-type ament_python --dependencies rclpy --node-name param_demo

12.3.2 Réalisation du code

bash

import rclpy
from rclpy.node import Node

class ParameterNode(Node):
  def __init__(self, name):
  super().__init__(name)
  self.timer = self.create_timer(2.0, self.timer_callback)
  self.declare_parameter('robot_name', 'muto')

  def timer_callback(self):
  robot_name_param = self.get_parameter('robot_name').get_parameter_value().string_value
  self.get_logger().info('Hello %s!' % robot_name_param)

def main(args=None):
  rclpy.init(args=args)
  node = ParameterNode("param_declare")
  rclpy.spin(node)
  node.destroy_node()
  rclpy.shutdown()

12.3.3 Compilateur du paquet fonctionnel

bash

colcon build --packages-select pkg_param

12.3.4 Procédures opérationnelles

bash

# source install/setup.bash
ros2 run pkg_param param_demo

bash

ros2 param set param_declare robot_name robot

12.4 Étapes suivantes

1.13 Paquets de méta-fonctions

2.14 Communication distribuée

13 Méta-paquet

13 Métapaquets

13.1 Résumé des paquets de méta-fonctions

13.1.1 Qu'est-ce qu'un kit méta-fonctionnel

bash

sudo apt install ros-humble-desktop

13.1.2 Rôle des paquets de méta-fonctions

Objectif	Annotations
Organisations	Regrouper les paquets fonctionnels connexes
Installation simplifiée	Installation de plusieurs paquets à la fois
Dépendance à la gestion	Dépendance à la gestion unifiée
Documentation	Structure du projet claire
Contrôle de version	Publication et gestion harmonisées des versions

13.2 Cas de mise en œuvre

bash

ros2 pkg create pkg_metapackage

bash

<?xml version="1.0"?>
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<package format="3">
  <name>pkg_metapackage</name>
  <version>0.0.0</version>
  <description>TODO: Package description</description>
  <maintainer email="1461190907@qq.com">root</maintainer>
  <license>TODO: License declaration</license>

  <buildtool_depend>ament_cmake</buildtool_depend>

  <exec_depend>pkg_interfaces</exec_depend>
  <exec_depend>pkg_helloworld_py</exec_depend>
  <exec_depend>pkg_topic</exec_depend>
  <exec_depend>pkg_service</exec_depend>
  <exec_depend>pkg_action</exec_depend>
  <exec_depend>pkg_param</exec_depend>

  <test_depend>ament_lint_auto</test_depend>
  <test_depend>ament_lint_common</test_depend>

  <export>
  <build_type>ament_cmake</build_type>
  </export>
</package>

bash

cmake_minimum_required(VERSION 3.5)
project(pkg_metapackage)

if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

find_package(ament_cmake REQUIRED)

ament_package()

bash

colcon build --packages-select pkg_metapackage

13.3 Étapes suivantes

1.14 Communication distribuée - apprendre les communications distribuées

DDS - Apprendre DDS intermédiaire

14 Communication distribuée

14 Communications distribuées

14.1 Résumé des communications distribuées

ROS2 est un puissant cadre de communications distribuées qui permet une interaction facile des données réseau entre hôtes. Le bas est basé sur le middleware DDS (Data Distribution Service), qui gère les communications via ROS_DOMAIN_ID : lorsque les nœuds sur différents périphériques définissent le même ID de domaine et sont sur le même réseau, ils détectent et communiquent automatiquement librement ; au contraire, les ID sont séparés les uns des autres.

14.1.1 Qu'est-ce que les communications distribuées

ROS 2 distributed communications permet à plusieurs nœuds informatiques de communiquer entre eux sans serveurs centraux. Ceci est réalisé via DDS (Data Distribution Service).

14.1.2 Caractéristiques des communications distribuées

Caractéristiques	Annotations
Décentralisé	Pas besoin, ROS Master.
Auto-découverte	Le nœud trouve automatiquement d'autres nœuds sur le réseau
Multiplateforme	Communications entre différents systèmes d'exploitation
Transmission fiable	Prend en charge plusieurs politiques QoS

14.2 ROS_DOMAIN_ID

14.2.1 Concept d'ID de domaine

ROS_DOMAIN_ID est utilisé pour isoler différents réseaux ROS2.

14.3 Réalisé

14.3.1 Réalisation par défaut

bash

ros2 run demo_nodes_py talker
ros2 run demo_nodes_py listener

14.3.2 Sous-groupes de réseaux distributifs

bash

$ export ROS_DOMAIN_ID=<your_domain_id>

14.3.3 Cas 1

bash

echo "export ROS_DOMAIN_ID=6" >> ~/.bashrc
source ~/.bashrc
ros2 run demo_nodes_py talker

bash

echo "export ROS_DOMAIN_ID=6" >> ~/.bashrc
source ~/.bashrc
ros2 run demo_nodes_py listener

Cas 2

bash

ros2 run turtlesim turtlesim_node

bash

ros2 run turtlesim turtle_teleop_key

14.4 Attention

14.5 Règles pour calculer les valeurs d'ID de domaine DDS (connaissance de niveau)

14.6 Étapes suivantes

DDS - Apprendre en profondeur DDS intermédiaire

API liée au temps - Apprendre Time API

https://fast-dds.docs.eprosima.com/en/latest/

15 DDS

15 DDS (Data Distribution Service)

15.1 Vue d'ensemble de DDS

15.1.1 Qu'est-ce que DDS ?

DDS (Data Distribution Service) est une norme de middleware de publication-abonnement centrée sur les données, et ROS 2 utilise DDS pour réaliser des communications de niveau inférieur.

15.1.2 Fonctions principales DDS

Fonctions	Annotations
Mécanismes de découverte	Trouver automatiquement les participants DDS sur le réseau
Lancement/abonnement	Mode de transfert de données résolu
Politique QoS	Qualité des services disponibles
Système de types	Définition des données de type fort
Zéro copie	Transfert de données efficace

15.2 Modèles de communications

15.3 Applications de DDS dans ROS2

15.4 Stratégie de services de qualité

QoS peut être compris comme une règle de transmission basée sur le web : l'application déclarera son comportement de qualité de transmission souhaité, tandis que le mécanisme QoS est responsable de répondre à ces exigences dans la mesure du possible.

La stratégie est la suivante :

Stratégie DEADLINE : indique que chaque communication de données doit être complétée au moins une fois dans le délai prescrit ;

Politique HISTORY : indique des limites de taille sur les caches de données historiques ;

Politique RELIABILITY : représente un modèle fiable de transmission de données.

Politique DURABILITY : peut être configurée pour fournir des données historiques aux nœuds qui arrivent en retard, permettant aux nouveaux nœuds d'entrer plus rapidement dans le système.

15.5. Cas de test

Cas 1 - Configurer DDS par ligne d'ordre

bash

ros2 topic pub /chatter std_msgs/msg/Int32 "data: 66" --qos-reliability best_effort

bash

ros2 topic echo /chatter --qos-reliability reliable

PreviousCommunication principale de ROS2

NextOutils ROS2, Launch et visualisation