ROS2-tools, Launch en visualisatie

17 Gangbare commandotool

17 Gangbare commandotool (CLI Tools)

17.1 Pakketbeheertool ros2 pkg

17.1.1 ros2 pkg create

Functie: Maak een functioneel pakket, waarvoor de naam van het pakket, de manier waarop het wordt gecompileerd, de afhankelijkheden, enz. nodig zijn.

Formaat:

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

In het ros2-commando:

pkg: geeft functies aan die zijn gekoppeld aan het functionele pakket;

create: geeft het maken van een functioneel pakket aan;

Pakketnaam: vereist: naam van het nieuwe functionele pakket;

build-type: vereist: geeft aan of het nieuw aangemaakte feature-pakket C++ of Python is, indien C++ of C wordt gebruikt, dan is dit ament_cmake, en als Python wordt gebruikt, ament_python;

Opties: het C++-functiepakket moet rclcpp bevatten, het Python-functiepakket moet rclpy en andere afhankelijken bevatten;

17.1.2 ros2 pkg list

Functie: Bekijk de lijst met functionele pakketten in het systeem

ros2 pkg list

17.1.3 ros2 pkg executables

Functie: Bekijk alle uitvoerbare bestanden in een pakket

ros2 pkg executables <pkg_name>

17.2 Knooppunt uitvoeren ros2 run

Functie: Voer het knooppuntprogramma van het functionele pakket uit

ros2 run <pkg_name> <node_name>

17.3 Knooppunt-gerelateerde tools

17.3.1 ros2 node list

ros2 node list

17.3.2 ros2 node info

ros2 node info <node_name>

17.4 Topic-gerelateerde tools

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>

Voorbeeld:

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 interface-gerelateerde tools

ros2 interface list
ros2 interface show <interface_name>

17.6 Service-gerelateerde tools

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

17.7 Volgende stappen

18 RViz2 gebruiken - RViz2-visualisatie leren

2. 19 Rqt-toolbox - Rqt-tool leren

18 RViz2 gebruiken

18 RViz2-gebruik (RViz2 Vision)

18.1 RViz2-overzicht

Rviz2 is de meest gebruikte driedimensionale visualisatietool in ROS 2 om de operationele status van robotsystemen te visualiseren. Het kan een verscheidenheid aan ROS 2-topicgegevens abonneren en weergeven, zoals laser-radar-cloud, kaarten, robotmodel (URDF), TF-coördinatenconversie, padplanningstraject en camerabeelden, en helpen ontwikkelaars snel te verifiëren of sensor, positionering, navigatie, enz. werken.

18.2 Voorbereidende werkzaamheden

Als er een echte robot is, kan deze de rviz-oefening starten op de hoofdcontrole van de robot. Als er geen echte robot is, kunnen we de turtlebot3 op realistische wijze starten met gazebo, waarbij we laser-radar, camera, enz. nabootsen, zodat de volgende gegevens kunnen worden gevisualiseerd.

Tutlebot3-emulatorpakket installeren

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

Installatie van ros- en gazebo-bruggen

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

De omgevingsvariabele turtlebot3 instellen

export TURTLEBOT3_MODEL=waffle

Gazebo-simulatieomgeving starten

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

Opmerking: Jetson kan mogelijk niet starten, deze bewerking wordt uitgevoerd op X86 PC

18.3 Rviz2 starten

Start een terminal en kan worden geactiveerd met het volgende commando:

rviz2

Opmerking: Als gestart in docker, zorg ervoor dat de GUI-weergave is geopend.

18.4 Visualisatie van beeldgegevens

Klik op Add in het linker Displays-venster om het Image-weergave-item te vinden, OK om de weergavelijst toe te voegen na bevestiging, en configureer vervolgens het beeldtopic voor het weergave-item, zodat u het camerabeeld van de robot kunt zien.

Selecteer Fixed Frame naar base_footprint-coördinaten

Selecteer Camera Color Topic

Nu kunnen we de visie van de huidige simulatierobot zien in het Camera-venster.

18.5 Visualisatie van radargegevens

Klik op Add in het linker Displays-venster, selecteer LaserScan en configureer de onderwerpnaam voor het abonnement.

Topicselectie voor LaserScan

Op dit punt kunnen we de contouren van de laser-radar zien.

18.6 Visualisatie van robotmodellen

Klik op Add in het linker Displays-venster, selecteer RobotModel

Selecteer het topic voor robotDescriptionTopic

We kunnen de visualisatie van robots zien in Rviz2.

18.7 Visualisatie van andere gegevens

De rivz-standaardplugins bevatten veel veelgebruikte plugins voor gegevensvisualisatie die u op het ene of andere moment kunt gebruiken.

18.8 Volgende stappen

1. 19 Rqt-toolbox - Rqt-tool leren

2. 20 Launch-configuratie - Launch-configuratie leren

19 Rqt-toolbox

19 Rqt-toolbox (Rqt Tools)

19.1 Rqt-overzicht

rqt is een grafisch op Qt gebaseerd toolframework in ROS dat veel gangbare functies integreert in een visuele interface via plugins. De ontwikkelaars kunnen het systeem visualiseren en debuggen door rqt te bekijken, bijvoorbeeld de distributie/abonnement van Topic, het bewaken van knooppunten en communicatie (rqt graph), realtime weergave van logs (rqt console), dynamische verwijzing (rqt reconfigure) en het tekenen van analysegegevens (rqt plot).

19.2 Installatie

De rqt-toolbox wordt meestal standaard geïnstalleerd zolang de desktopversie is geïnstalleerd; Als de installatie van ros2 geen volledige versie van de installatie is, kan deze als volgt worden geïnstalleerd:

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

19.3 Begin

Veelgebruikte rqt-startopdrachten zijn:

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

# Method 2
ros2 run rqt_gui rqt_gui

19.4 Gebruik van plugins

Na het starten van rqt kunt u de gewenste plugins toevoegen via plugins:

Open een klein schildpadvoorbeeld om de abonnementen op knooppunten te bekijken:

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

19.4.1 topic-plugins

Voegt topic-plugins toe en stuurt snelheidscommando's om de schildpadbeweging te besturen.

19.4.2 service-plugin

Voegt een service-plugin toe en stuurt een verzoek om een schildpad op een bepaalde locatie te maken.

19.4.3 Parameter-plugins

Verandert de achtergrondkleur van het schildpadformulier dynamisch via de parameter-plugin.

19.5 Volgende stappen

1. 20 Launch-configuratie - Launch-configuratie leren

Opname en afspelen - pakketopname leren

20 Launch-configuratie

20 Launch-configuratie (Launch Files)

20.1 Launch-overzicht

Het Launch-startbestand in ROS wordt gebruikt voor het geïntegreerd beheer en activeren van meerdere knooppunten/componenten en is in wezen een opstartscript op systeemniveau. Het kan worden voorbereid door Python (meest gebruikelijk), XML of YAML, en ondersteunt de gelijktijdige activering van meerdere knooppunten, het instellen van parameters, het remappen van topics, het laden van naamruimtes, configuratie van omgevingsvariabelen en het uitvoeren van geavanceerdere logische besturingen, zoals voorwaardelijk opstarten, vertraagd opstarten, trigger-by-incident, enz.

20.2 Lancering van een enkel Node-knooppunt

20.2.1 Voorbereidende kits

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

20.2.2 Nieuw launch-bestand

Maakt een nieuwe launch-map onder het functionele pakket aan en maakt vervolgens een nieuw single_node_launch.py-bestand in de launch-map om het volgende te kopiëren:

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

Het launch-bestand wordt vaak vernoemd naar LaunchName_launch.py, waarbij LaunchName aangepast is en _launch.py vaak als vast wordt beschouwd. U moet het setup.py-bestand onder het functionele pakket aanpassen om het document onder het launch-pad toe te voegen, zodat u het .py-bestand voor uitvoering kunt compileren

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

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

20.2.5 Operationele procedures

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

20.2.6 Bronanalyse

Gerelateerde bibliotheek importeren

from launch import LaunchDescription
from launch_ros.actions import Node

Definieert een functie generate_launch_description en geeft een launch-beschrijving terug

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

Definieert de retourwaarde dat een variabele Node start als een knooppunt, roept de Node-functie aan en start twee belangrijke parameters, type en executable.

Package: geeft het functionele pakket aan, dat de naam van het functionele pakket vertegenwoordigt.

Executable: geeft de uitgevoerde procedure aan, de naam van de afdwingbare procedure.

De laatste oproep aan de LaunchDescription-functie is om de node-parameter in te voeren om de retour uit te voeren.

return LaunchDescription([node])

20.3 launch van meerdere Node-knooppunten

20.3.1 Nieuw launch-bestand

Nieuw multi_node_launch.py-bestand, voeg het volgende toe:

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

colcon build --packages-select learn_launch

20.3.3 Operationele procedures

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

Als de terminal de inhoud niet afdrukt, kunt u zien welke knooppunten zijn geactiveerd om te verifiëren of het opstarten is gelukt.

ros2 node list

20.3.4 Bronoplossing

Het is als simple node_launch.py, gewoon een ander knooppunt!

20.4 Topic-remapping-cases

20.4.1 Nieuw launch-bestand

Maak een nieuw remap_name_launch.py-bestand onder de directory multi_node_launch.py, en voeg het volgende toe:

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

colcon build --packages-select learn_launch

20.4.3 Operationele procedures

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

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

Hier is om het oorspronkelijke /topic_demo topic te remixen in /topic_update.

20.5 Launch-bestand insluiten start een ander launch-bestand

20.5.1 Nieuw launch-bestand

Nieuwe include_launch.py onder de directory multi_node_launch.py, voeg het volgende toe:

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

colcon build --packages-select learn_launch

20.5.3 Operationele procedures

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

20.5.4 Bronanalyse

Het insluiten van het launch-bestand vereist het gebruik van de IncludeLaunchDescription en PythonLaunchDescriptionSource categorieën van het launch-systeem

os.path.join (get_package_share_directory('learn_launch'): neemt de positie van het functionele pakket, waarbij de naam van het functionele pakket learn_launch is;

'launch': betekent een map met launch-bestanden onder een functioneel pakket;

'/multi_node_launch.py': duidt op een /multi_node_launch.py-bestand onder de launch-map.

20.6 Voorbeelden van samengestelde launch-documenten

Deze demo laat voornamelijk zien hoe complexe launch-bestanden worden voorbereid, en de functionaliteit van het programma is te verwaarlozen.

20.6.1 Nieuw launch-bestand

Maak een nieuw complex_launch.py-bestand onder de directory multi_node_launch.py, en voeg het volgende toe:

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

colcon build --packages-select learn_launch

20.6.3 Operationele procedures

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

Twee schildpadden worden weergegeven op Jetson.

Start het toetsenbordbesturingsknooppunt en voeg een naamruimte toe (omdat we een naamruimte hebben toegevoegd bij het starten van het knooppunt in launch-bestanden)

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

Gebruik de rechter- en linkerknoppen om de beweging van schildpad 1 te besturen. Schildpad 2 is een perfecte kopie van schildpad 1.

20.6.4 Beschrijving van de procedure

Het proces bestond voornamelijk uit het starten:

Een, demo_nodes_cpp talker_lister,

2. Talker_lister-knooppunt met naamruimte

Drie, turtlesim1 is een kleine schildpad in een benoemde ruimte.

4 en Turtlesim2 zijn benoemde ruimtes voor schildpadden 2

Vijf, opnieuw vergroten zodat beide schildpadden hetzelfde commandotema kunnen horen.

20.7 xml-implementatie

20.7.1 Nieuw launch-bestand

Nieuw Complex_Launch.py-bestand onder de directory van complex_launch.xml, voeg het volgende toe:

<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-bestandsconfiguratie

Het systeem moet het gecompileerde bestand configureren en onze .xml launch-bestanden naar de install-installatiedirectory kopiëren om onze bestanden te vinden

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

20.7.3 Functioneel pakket compileren

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

20.7.4 Operationele procedures

# ros2 launch learn_launch complex_launch.xml

Twee kleine schildpadden worden verwacht, en de terminal print loginformatie.

Start het toetsenbordbesturingsknooppunt en voeg de naamruimte toe

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

20.8 Yaml-implementatie

20.8.1 Nieuw launch-bestand

Nieuw Complex_Launch.yaml-bestand onder de directory van complex_launch.py, voeg het volgende toe:

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 Configuratie

U moet het gecompileerde bestand configureren om onze .yaml-formaat launch-bestanden naar de Install-installatiedirectory te kopiëren voordat het ros-systeem onze bestanden kan vinden

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

20.8.3 Functioneel pakket compileren

colcon build --packages-select learn_launch

20.8.4 Operationele procedures

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

Start het toetsenbordbesturingsknooppunt en voeg de naamruimte toe

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

Gebruik toetsenbordbesturing om schildpad één te activeren, schildpad twee is een perfecte imitatie van schildpad één.

20.9 Volgende stappen

1.21 Opname en afspelen - pakketopname leren

2. 22 URL-modellen - robotmodellering leren

21 Opname en afspelen

21 Opname afspelen

21.1 Rosbag2-overzicht