ROS2 geavanceerde interfaces en middleware

10 TF2 coördinatentransformatie

10 TF2 coördinatentransformatie (TF2 Transform)

10.1 TF2-overzicht

10.1.1 Wat is TF2

TF2 (Transform 2) is de bibliotheek die in ROS 2 wordt gebruikt om coördinaatveranderingen te beheren. Het volgt relaties tussen meerdere coördinatensystemen en stelt ontwikkelaars in staat om gegevens (bijv. punt, vector, houding) tussen verschillende coördinatensystemen te converteren.

10.1.2 Gebruik van TF2

Toepassen	Annotaties
Sensorintegratie	Gegevens van verschillende sensoren omzetten naar het uniforme coördinatensysteem
Navigatie	Het kaartcoördinatensysteem omzetten naar robotcoördinaten.
Mechanische arm	Berekent de houding van de eindeffector boven de basis
Visualiseren	Toon de robotstatus correct in RViz2

10.1.3 Aanduiding van coördinaten

Naam	Doel
Map	Globale/wereldcoördinaten, vast en onveranderd
odom	Het kilometerstandcoördinatensysteem voor positionering.
base_link	Het basiscoördinatensysteem van de robot.
base_footprint	Het chassisproject van de robot op de grond.
Camera_link	Cameracoördinatensysteem
Laser_link	Laserradar-coördinatensysteem

23, ROS2 TF2-coördinaten geconverteerd.

Inleiding tot TF2

Gecoördineerde systemen zijn een zeer bekend concept en een belangrijk fundament in de robotica, en er zullen veel coördinatiesystemen zijn in een volledig robotsysteem, en hoe moet de locatie van deze coördinaten worden beheerd? ROS heeft ons een gecoördineerde decorateur gegeven: TF2

2. Coördinatensystemen in robots

Coördinaten zijn even belangrijk in mobiele robotsystemen. Bijvoorbeeld het centrale punt van een mobiele robot is base_link, de positie van de radar wordt radarcoördinaten-eilanden laser_link genoemd, waar de robot beweegt, en de kubieke meter accumuleert, wat odom wordt genoemd, wat op zijn beurt cumulatieve fout en drift heeft, en de absolute locatie wordt kaartcoördinaten Map Map genoemd.

Het onderliggende principe van de TF-functie in ROS is dat deze wiskundige variaties zijn ingekapseld, en gedetailleerde theoretische kennis is voor jullie allen beschikbaar in het curriculum van de robotica, en we leggen voornamelijk uit hoe TF-coördinatenbeheersystemen worden gebruikt.

3 TF-opdrachtregelbewerkingen

3.1. Installatie van tools

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. Starten

bash

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

3.3. De TF-boom bekijken

bash

ros2 run rqt_tf_tree rqt_tf_tree

3.4. Querycoördinaten om informatie te wijzigen

bash

ros2 run tf2_ros tf2_echo turtle2 turtle1

3.5. Visualisatie van coördinaten

bash

rviz2

4. Statische coördinatenconversie

4.1. Verdeling van A naar B-posities

bash

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

4.2. Onderschepping/toegang tot TF-relaties

bash

ros2 run tf2_ros tf2_echo A B

4.3, rivz visualisatie

bash

rviz2

5. Casuspresentatie

7. Nieuw functioneel pakket

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. Configuratiebestanden bewerken

bash

import os
from glob import glob

bash

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

9. Functioneel pakket compileren

bash

colcon build --packages-select pkg_tf

Operationele procedures

bash

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

bash

ros2 run turtlesim turtle_teleop_key

Aangepast interfacebericht

11 Aangepaste interfaceberichten

In het ROS-systeem zijn de drie soorten communicatiemechanismen, Topic, Service en Action, allemaal afhankelijk van een kernconcept: communicatie-interface.

11.1 Een aangepast interfaceproces maken

De belangrijkste stappen zijn als volgt:

Functioneel pakket interface maken

.msg-bestanden, .srv-bestanden en .action-bestanden maken en bewerken

Configuratiebestand bewerken

Compileren

Test

11.2 Een aangepaste interface voor actiecommunicatie maken

11.3 Een aangepaste interface maken voor topiccommunicatie

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 Een aangepaste interface maken voor servicecommunicatie

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 Volgende stappen

1.12 Parameterservicegevallen

2.13 Metafunctiepakketten

12 Parameterservicegevallen

12 Parameterservices (Parameters)

12.1 Overzicht van parameters

In ROS-robotsystemen werken parameters als C++ globale variabelen en bieden gemakkelijke mechanismen voor het delen van gegevens voor meerdere knooppunten.

12.2 Parameters in de routine van de kleine schildpad

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 Parametergevallen

12.3.1 Nieuw functioneel pakket

bash

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

12.3.2 Coderealisatie

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 Functioneel pakket compileren

bash

colcon build --packages-select pkg_param

12.3.4 Operationele procedures

bash

# source install/setup.bash
ros2 run pkg_param param_demo

bash

ros2 param set param_declare robot_name robot

12.4 Volgende stappen

1.13 Metafunctiepakketten

2.14 Gedistribueerde communicatie

13 Metapakket

13 Metapakketten

13.1 Samenvatting van metafunctiepakketten

13.1.1 Wat is een metafunctionele kit

bash

sudo apt install ros-humble-desktop

13.1.2 Rol van metafunctiepakketten

Doel	Annotaties
Organisaties	Groepeer gerelateerde functionele pakketten
Vereenvoudigde installatie	Installatie van meerdere pakketten tegelijk
Afhankelijkheidsbeheer	Uniform afhankelijkheidsbeheer
Documentatie	Duidelijke projectstructuur
Versiebeheer	Geharmoniseerde publicatie en beheer van versies

13.2 Implementatiegevallen

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 Volgende stappen

1.14 Gedistribueerde communicatie - gedistribueerde communicatie leren

DDS - DDS-tussenliggend leren

14 Gedistribueerde communicatie

14.1 Samenvatting van gedistribueerde communicatie

ROS2 is een krachtig framework voor gedistribueerde communicatie dat eenvoudige host-naar-host netwerkdata-interactie mogelijk maakt. De onderkant is gebaseerd op de DDS (Data Distribution Service) middleware, die communicatie beheert via de ROS_DOMAIN_ID: wanneer de knooppunten op verschillende apparaten dezelfde domein-ID instellen en in hetzelfde netwerk zijn, detecteren ze automatisch en communiceren vrij; integendeel, de ID's zijn van elkaar gescheiden.

14.1.1 Wat is gedistribueerde communicatie

ROS 2 gedistribueerde communicatie stelt meerdere computerknooppunten in staat om met elkaar te communiceren zonder centrale servers. Dit wordt bereikt via DDS (Data Distribution Service).

14.1.2 Kenmerken van gedistribueerde communicatie

Kenmerken	Annotaties
Niet-gecentraliseerd	Niet nodig, ROS Master.
Automatische detectie	Knooppunt vindt automatisch andere knooppunten op het netwerk
Cross Platform	Communicatie tussen verschillende besturingssystemen
Betrouwbare overdracht	Ondersteunt meerdere QoS-beleidsregels

14.2 ROS_DOMAIN_ID

14.2.1 Concept van domein-ID

ROS_DOMAIN_ID wordt gebruikt om verschillende ROS2-netwerken te isoleren.

14.3 Bereikt

14.3.1 Standaardprestatie

bash

ros2 run demo_nodes_py talker
ros2 run demo_nodes_py listener

14.3.2 Gedistribueerde netwerksubgroepen

bash

$ export ROS_DOMAIN_ID=<your_domain_id>

14.3.3 Geval 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

Geval 2

bash

ros2 run turtlesim turtlesim_node

bash

ros2 run turtlesim turtle_teleop_key

14.4 Aandacht

14.5 Regels voor het berekenen van DDS domein-ID-waarden (niveau-kennis)

14.6 Volgende stappen

DDS - Diepgaand leren DDS-tussenliggend

Tijdgerelateerde API - Time API leren

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

15 DDS

15 DDS (Data Distribution Service)

15.1 Overzicht van DDS

15.1.1 Wat is DDS?

DDS (Data Distribution Service) is een datacentrische publicatie-abonnement-tussenstandaard, en ROS 2 gebruikt DDS om communicatie op een lager niveau te bereiken.

15.1.2 DDS-kernfuncties

Functies	Annotaties
Detectiemechanismen	Vind automatisch DDS-deelnemers op het netwerk
Lancering/abonnement	Gegevensoverdrachtsmodus opgelost
QoS-beleid	Beschikbare servicekwaliteit
Type System	Sterk-type gegevensdefinitie
Nul kopieën	Efficiënte gegevensoverdracht

15.2 Communicatiemodellen

15.3 Toepassingen van DDS in ROS2

15.4 Kwaliteitsservicestrategie

QoS kan worden begrepen als een webgebaseerde transmissieregel: de toepassing zal het gewenste transmissiekwaliteitsgedrag verklaren, terwijl het QoS-mechanisme verantwoordelijk is voor het zoveel mogelijk voldoen aan deze vereisten.

De strategie is als volgt:

DEADLINE-strategie: geeft aan dat elke gegevenscommunicatie ten minste eenmaal moet worden voltooid binnen de voorgeschreven termijn;

HISTORY-beleid: geeft aan dat de grootte van historische datacaches beperkt is;

RELIABILITY-beleid: vertegenwoordigt een betrouwbaar patroon van gegevensoverdracht.

DURABILITY-beleid: kan worden geconfigureerd om historische gegevens te leveren voor knooppunten die laat aankomen, waardoor nieuwe knooppunten sneller in het systeem kunnen komen.

15.5. Testgevallen

Geval 1 - DDS configureren via opdrachtregel

bash

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

bash

ros2 topic echo /chatter --qos-reliability reliable

PreviousROS2-kerncommunicatie

NextROS2-tools, launch en visualisatie