ROS2-Werkzeuge, Launch und Visualisierung

17 Häufiges Befehlswerkzeug

17 Häufiges Befehlswerkzeug (CLI Tools)

17.1 Paketverwaltungswerkzeug ros2 pkg

17.1.1 ros2 pkg create

Funktion: Erstellen eines Funktionspakets, das den Namen des Pakets, die Art und Weise der Kompilierung, die Abhängigkeiten usw. erfordert.

Format:

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

Im ros2-Befehl:

pkg: zeigt mit dem Funktionspaket verbundene Funktionen an;

create: zeigt die Erstellung eines Funktionspakets an;

Paketname: erforderlich: Name des neuen Funktionspakets;

build-type: erforderlich: zeigt an, ob das neu erstellte Funktionspaket C++ oder Python ist; wird C++ oder C verwendet, ist dies ament_cmake, und wird Python verwendet, ament_python;

Optionen: Das C++-Funktionspaket muss rclcpp enthalten, das Python-Funktionspaket muss rclpy und andere Abhängigkeiten enthalten;

17.1.2 ros2 pkg list

Funktion: Liste der Funktionspakete im System anzeigen

ros2 pkg list

17.1.3 ros2 pkg executables

Funktion: Alle ausführbaren Dateien in einem Paket anzeigen

ros2 pkg executables <pkg_name>

17.2 Knotenausführung ros2 run

Funktion: Ausführen des Funktionspaket-Knotenprogramms

ros2 run <pkg_name> <node_name>

17.3 Knotenbezogene Werkzeuge

17.3.1 ros2 node list

ros2 node list

17.3.2 ros2 node info

ros2 node info <node_name>

17.4 Topic-bezogene Werkzeuge

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>

Beispiel:

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 ros2 schnittstellenbezogene Werkzeuge

ros2 interface list
ros2 interface show <interface_name>

17.6 Dienstbezogene Werkzeuge

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

17.7 Nächste Schritte

18 RViz2-Verwendung - RViz2-Visualisierung lernen

2. 19 Rqt-Toolbox - Rqt-Werkzeug lernen

18 RViz2-Verwendung

18 RViz2-Verwendung (RViz2 Vision)

18.1 RViz2-Übersicht

Rviz2 ist das am häufigsten verwendete dreidimensionale Visualisierungswerkzeug in ROS 2, um den Betriebszustand von Robotersystemen zu visualisieren. Es kann eine Vielzahl von ROS 2-Topic-Daten abonnieren und anzeigen, z. B. Laser-Radar-Cloud, Karten, Robotermodell (URDF), TF-Koordinatenkonvertierung, Pfadplanungstrajektorie und Kamerabilder, und Entwickler bei der schnellen Überprüfung helfen, ob Sensor, Positionierung, Navigation usw. funktionieren.

18.2 Vorbereitende Arbeiten

Wenn ein echter Roboter vorhanden ist, kann er die rviz-Übung am Robotermastersteuerungsende starten. Wenn kein echter Roboter vorhanden ist, können wir den turtlebot3 auf reale Weise mit gazebo starten, indem wir Laser-Radar, Kamera usw. nachahmen, sodass die nächsten Daten visualisiert werden können.

Tutlebot3-Emulator-Kit installieren

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

Installation von ros- und gazebo-Brücken

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

turtlebot3-Umgebungsvariable einstellen

export TURTLEBOT3_MODEL=waffle

Gazebo-Simulationsumgebung starten

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

Hinweis: Jetson kann möglicherweise nicht starten, dieser Vorgang läuft auf einem X86-PC

18.3 Rviz2-Start

Startet ein Terminal und kann mit dem folgenden Befehl aktiviert werden:

rviz2

Hinweis: Wenn Sie es in docker starten, stellen Sie sicher, dass die GUI-Anzeige geöffnet wurde.

18.4 Visualisierung von Bilddaten

Klicken Sie im linken Displays-Fenster auf Add, um das Image-Anzeigeelement zu finden, OK, um die Anzeigeliste nach Bestätigung hinzuzufügen, und konfigurieren Sie dann das Bild-Topic für das Anzeigeelement, sodass Sie das Kamerabild des Roboters sehen können.

Wählen Sie Fixed Frame zu base_footprint-Koordinaten

Wählen Sie Camera Color Topic

Jetzt können wir die Sicht des aktuellen Simulationsroboters im Camera-Fenster sehen.

18.5 Radar-Datenvisualisierung

Klicken Sie im linken Displays-Fenster auf Add, wählen Sie Laserscan und konfigurieren Sie den Subjektnamen für das Abonnement.

Topic-Auswahl für LaserScan

An diesem Punkt können wir die Konturen des Laser-Radars sehen.

18.6 Visualisierung von Robotermodellen

Klicken Sie im linken Displays-Fenster auf Add, wählen Sie RobotModel

Wählen Sie das Topic für robotDescriptionTopic

Wir können die Visualisierung von Robotern in Rviz2 sehen.

18.7 Visualisierung anderer Daten

Die rivz-Standard-Plugins listen viele häufig verwendete Datenvisualisierungs-Plugins auf, die Sie zu einem oder anderen Zeitpunkt verwenden können.

18.8 Nächste Schritte

1. 19 Rqt-Toolbox - Rqt-Werkzeug lernen

2. 20 Launch-Konfiguration - Launch-Konfiguration lernen

19 Rqt-Toolbox

19 Rqt-Toolbox (Rqt Tools)

19.1 Rqt-Übersicht

rqt ist ein grafisches Qt-basiertes Werkzeugframework in ROS, das viele gängige Funktionen über Plugins in eine visuelle Schnittstelle integriert. Entwickler können das System durch Anzeigen von rqt visualisieren und debuggen, z. B. Verteilung/Abonnement von Topic, Überwachung von Knoten und Kommunikation (rqt graph), Echtzeit-Anzeige von Logs (rqt console), dynamische Referenz (rqt reconfigure) und Zeichnen von Analysedaten (rqt plot).

19.2 Installation

Die rqt-Toolbox wird normalerweise standardmäßig installiert, solange die Desktop-Version installiert ist; Wenn die Installation von ros2 keine vollständige Version der Installation ist, kann sie wie folgt installiert werden:

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

19.3 Beginn

Häufige rqt-Startbefehle sind:

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

# Method 2
ros2 run rqt_gui rqt_gui

19.4 Verwendung von Plugins

Nach dem Start von rqt können Sie die erforderlichen Plugins über Plugins hinzufügen:

Öffnen Sie ein kleines Schildkrötenbeispiel, um die Abonnements zu Knoten zu sehen:

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

19.4.1 topic-Plugins

Fügt topic-Plugins hinzu und sendet Geschwindigkeitsbefehle, um die Schildkrötenbewegung zu steuern.

19.4.2 service-Plugin

Fügt ein service-Plugin hinzu und sendet eine Anfrage, um eine Schildkröte an einem bestimmten Ort zu erstellen.

19.4.3 Parameter-Plugins

Ändert die Hintergrundfarbe des Schildkrötenformulars über das Parameter-Plugin dynamisch.

19.5 Nächste Schritte

1. 20 Launch-Konfiguration - Launch-Konfiguration lernen

Aufzeichnung und Wiedergabe - Paketaufzeichnung lernen

20 Launch-Konfiguration

20 Launch-Konfiguration (Launch Files)

20.1 Launch-Übersicht

Die Launch-Startdatei in ROS wird für die integrierte Verwaltung und Aktivierung mehrerer Knoten/Komponenten verwendet und ist im Wesentlichen ein Startskript auf Systemebene. Es kann von Python (am häufigsten), XML oder YAML vorbereitet werden und unterstützt die gleichzeitige Aktivierung mehrerer Knoten, das Setzen von Parametern, das Remapping von Topics, das Laden von Namespaces, die Konfiguration von Umgebungsvariablen und die Durchführung erweiterter logischer Steuerungen wie bedingten Start, verzögerten Start, ereignisausgelösten Start usw.

20.2 Start eines einzelnen Node-Knotens

20.2.1 Vorbereitende Kits

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

20.2.2 Neue Launch-Datei

Erstellt einen neuen launch-Ordner unter dem Funktionspaket und erstellt dann eine neue single_node_launch.py-Datei im launch-Ordner, um Folgendes zu kopieren:

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 Konfigurationsdatei setup.py

Die Launch-Datei wird oft nach LaunchName_launch.py benannt, wobei LaunchName angepasst wird und _launch.py oft als fest betrachtet wird. Sie müssen die setup.py-Datei unter dem Funktionspaket modifizieren, um das Dokument unter dem launch-Pfad hinzuzufügen, damit Sie die .py-Datei zur Ausführung kompilieren können

# 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 Funktionspaket kompilieren

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

20.2.5 Betriebsabläufe

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

20.2.6 Quellanalyse

Zugehörige Bibliothek importieren

from launch import LaunchDescription
from launch_ros.actions import Node

Definiert eine Funktion generate_launch_description und gibt eine Launch-Beschreibung zurück

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

Definiert den Rückgabewert, dass eine Variable Node als Knoten startet, ruft die Node-Funktion auf und startet zwei wichtige Parameter, type und executable.

Package: zeigt das Funktionspaket an, das den Namen des Funktionspakets repräsentiert.

Executable: zeigt die ausgeführte Prozedur, den Namen der erzwingbaren Prozedur an.

Der letzte Aufruf der LaunchDescription-Funktion erfolgt durch Eingabe des node-Parameters zur Ausführung der Rückgabe.

return LaunchDescription([node])

20.3 launch mehrerer Node-Knoten

20.3.1 Neue launch-Datei

Neue multi_node_launch.py-Datei, fügen Sie Folgendes hinzu:

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 Funktionspaket kompilieren

colcon build --packages-select learn_launch

20.3.3 Betriebsabläufe

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

Wenn das Terminal die Inhalte nicht druckt, können Sie sehen, welche Knoten aktiviert sind, um zu überprüfen, ob der Start erfolgreich war.

ros2 node list

20.3.4 Quellauflösung

Es ist wie single_node_launch.py, nur ein anderer Knoten!

20.4 Topic-Remapping-Fälle

20.4.1 Neue launch-Datei

Erstellen Sie eine neue remap_name_launch.py-Datei im Verzeichnis multi_node_launch.py und fügen Sie Folgendes hinzu:

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 Funktionspaket kompilieren

colcon build --packages-select learn_launch

20.4.3 Betriebsabläufe

# 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 Quellanalyse

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

Hier wird das ursprüngliche /topic_demo-Topic in /topic_update remappiert.

20.5 Launch-Datei-Einbettung startet eine andere launch-Datei

20.5.1 Neue launch-Datei

Neue include_launch.py unter dem Verzeichnis multi_node_launch.py, fügen Sie Folgendes hinzu:

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 Funktionspaket kompilieren

colcon build --packages-select learn_launch

20.5.3 Betriebsabläufe

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

20.5.4 Quellanalyse

Das Einbetten der launch-Datei erfordert die Verwendung der IncludeLaunchDescription- und PythonLaunchDescriptionSource-Kategorien des launch-Systems

os.path.join (get_package_share_directory('learn_launch'): nimmt die Position des Funktionspakets an, wobei der Name des Funktionspakets learn_launch ist;

'launch': bedeutet einen Ordner, der launch-Dateien unter einem Funktionspaket enthält;

'/multi_node_launch.py': bezeichnet eine /multi_node_launch.py-Datei unter dem launch-Ordner.

20.6 Beispiele für zusammengesetzte launch-Dokumente

Diese Demo zeigt hauptsächlich, wie komplexe launch-Dateien vorbereitet werden, und die Funktionalität des Programms ist vernachlässigbar.

20.6.1 Neue launch-Datei

Erstellen Sie eine neue complex_launch.py-Datei im Verzeichnis multi_node_launch.py und fügen Sie Folgendes hinzu:

# 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 Workspace-Kompilierung

colcon build --packages-select learn_launch

20.6.3 Betriebsabläufe

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

Auf Jetson werden zwei Schildkröten angezeigt.

Starten Sie den Tastatursteuerungsknoten und fügen Sie den Namensraum hinzu (weil wir den Namensraum hinzugefügt haben, als wir den Knoten in den launch-Dateien gestartet haben)

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

Verwenden Sie die rechten und linken Tasten, um die Schildkröte 1-Bewegung zu steuern. Schildkröte 2 ist eine perfekte Kopie der Schildkröte 1.

20.6.4 Beschreibung des Vorgangs

Der Prozess bestand hauptsächlich aus dem Starten von:

Eins, demo_nodes_cpp talker_listener,

2. talker_listener-Knoten mit Namensraum

Drei, turtlesim1 ist eine kleine Schildkröte in einem benannten Raum.

4 und Turtlesim2 sind benannte Räume für Schildkröten 2

Fünf, neu vergrößern, damit beide Schildkröten dasselbe Befehlsthema hören können.

20.7 xml-Implementierung

20.7.1 Neue launch-Datei

Neue Complex_Launch.py-Datei im Verzeichnis von complex_launch.xml, fügen Sie Folgendes hinzu:

<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 setup.py-Datei-Konfiguration

Das System muss die kompilierte Datei konfigurieren und unsere .xml launch-Dateien in das Installationsverzeichnis install kopieren, um unsere Dateien zu finden

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

20.7.3 Funktionspaket kompilieren

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

20.7.4 Betriebsabläufe

# ros2 launch learn_launch complex_launch.xml

Es werden zwei kleine Schildkröten erwartet, und das Terminal druckt Log-Informationen.

Starten Sie den Tastatursteuerungsknoten und fügen Sie einen Namensraum hinzu

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

20.8 Yaml-Implementierung

20.8.1 Neue launch-Datei

Neue Complex_Launch.yaml-Datei im Verzeichnis von complex_launch.py, fügen Sie Folgendes hinzu:

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 Konfiguration

Sie müssen die kompilierte Datei konfigurieren, um unsere .yaml-Format-Launch-Dateien in das Install-Installationsverzeichnis zu kopieren, bevor das ros-System unsere Dateien finden kann

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

20.8.3 Funktionspaket kompilieren

colcon build --packages-select learn_launch

20.8.4 Betriebsabläufe

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

Starten Sie den Tastatursteuerungsknoten und fügen Sie einen Namensraum hinzu

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

Verwenden Sie die Tastatursteuerung, um Schildkröte eins zu aktivieren, Schildkröte zwei ist eine perfekte Nachahmung von Schildkröte eins.

20.9 Nächste Schritte

1.21 Aufzeichnung und Wiedergabe - Paketaufzeichnung lernen

2. 22 URL-Modelle - Robotermodellierung lernen

21 Aufzeichnung und Wiedergabe

21 Aufzeichnung Wiedergabe

21.1 Rosbag2-Übersicht