Wie man MoveIt 2 einrichtet: Ein praktischer Leitfaden

MoveIt 2 ist der de-facto-Standard für Bewegungsplanung in ROS 2 und ermöglicht robotergesteuerten Armen, Trajektorien zu planen, auszuführen und dynamisch anzupassen – inklusive Kollisionsvermeidung. Dieser Leitfaden behandelt die Installation, Konfiguration und praktische Anwendungsfälle – von grundlegender Planung bis hin zur Echtzeitsteuerung – basierend auf MoveIt 2.8.0 (Mai 2026) für ROS 2 Jazzy.

TL;DR

• Installieren Sie MoveIt 2 über ros-jazzy-moveit oder bauen Sie es aus dem Quellcode für individuelle Anpassungen.
• Nutzen Sie den MoveIt Setup Assistant, um URDF-/SRDF-Konfigurationen für Ihren Roboter zu generieren.
• Planen Sie Bewegungen mit OMPL-Planern (z. B. RRTConnectkConfigDefault) und visualisieren Sie diese in RViz.
• Aktivieren Sie MoveIt Servo für Echtzeit-Trajektorienverfolgung mit ros2_control.
• Integrieren Sie Wahrnehmung (z. B. Kameradaten) über ROS 2-Topics und moveit_msgs/PlanningScene.

1. Installation und der MoveIt Setup Assistant

Voraussetzungen

• Ubuntu 24.04 (Noble Numbat) + ROS 2 Jazzy (Installationsanleitung).
• Python 3.10+ (MoveIt 2.8.0 erfordert Python 3.10+ aufgrund von Aktualisierungen in moveit_commander).
• Git und colcon (für Quellcode-Builds).

Überprüfen Sie Ihre Installation:

echo $ROS_DISTRO  # Soll "jazzy" ausgeben
python3 --version # Soll 3.10+ ausgeben

Installation von MoveIt 2

Option A: Binärinstallation (Empfohlen)

sudo apt update
sudo apt install ros-jazzy-moveit
source /opt/ros/jazzy/setup.bash

Überprüfen Sie die Installation:

ros2 pkg prefix moveit_ros  # Soll `/opt/ros/jazzy` zurückgeben

Option B: Quellcode-Build (Für Individualisierung)

mkdir -p ~/moveit2_ws/src && cd ~/moveit2_ws/src
git clone https://github.com/ros-planning/moveit2.git -b main
vcs import < moveit2/moveit2.repos
cd ~/moveit2_ws && colcon build --symlink-install
source install/setup.bash

MoveIt-Demo starten

Testen Sie mit dem Panda-Roboter (in MoveIt enthalten):

ros2 launch moveit2_demos panda_moveit_demo.launch.py

• Erwartetes Ergebnis: RViz sollte mit dem Panda-Arm und einer Planungsumgebung geöffnet werden.
• Häufiges Problem: Falls RViz nicht startet, stellen Sie sicher, dass ros-jazzy-rviz2 und ros-jazzy-ogre installiert sind:

  sudo apt install ros-jazzy-rviz2 ros-jazzy-ogre
  

  Copy

2. Konfiguration eines Roboters (URDF/SRDF)

Schritt 1: URDF vorbereiten

MoveIt benötigt eine URDF-Datei (Roboterbeschreibung) und eine SRDF-Datei (semantische Roboterbeschreibung). Nutzen Sie den MoveIt Setup Assistant, um Konfigurationen zu generieren.

Beispiel-URDF (Vereinfachter Panda-Arm)

<!-- panda.urdf.xacro -->
<robot name="panda" xmlns:xacro="http://www.ros.org/wiki/xacro">
  <link name="world"/>
  <joint name="panda_joint" type="fixed">
    <parent link="world"/>
    <child link="panda_link0"/>
  </joint>
  <!-- Fügen Sie hier die Gelenke/Verbindungen Ihres Roboters hinzu -->
</robot>

Schritt 2: Setup Assistant ausführen

ros2 run moveit_setup_assistant setup_assistant

• Eingaben:
  • URDF-Datei: pfad/zu/Ihrer_Roboter.urdf.xacro
  • Ausgabeverzeichnis: ~/moveit2_ws/src/Ihr_Roboter_moveit_config
• Ausgabe: Generiert:
  • config/srdf/ (semantische Beschreibungen)
  • config/joint_limits.yaml (Gelenkbegrenzungen)
  • launch/ (Startdateien)

Schritt 3: Build und Quellcode einbinden

cd ~/moveit2_ws && colcon build --packages-select Ihr_Roboter_moveit_config
source install/setup.bash

Schritt 4: Roboter in MoveIt starten

ros2 launch Ihr_Roboter_moveit_config demo.launch.py

• Erwartetes Ergebnis: RViz mit dem kinematischen Baum Ihres Roboters und Kollisionsobjekten.

Häufige Probleme

1. Fehlende Gelenkbegrenzungen: Falls sich Gelenke nicht bewegen, überprüfen Sie joint_limits.yaml:

   joint_limits:
     panda_joint:
       has_velocity_limits: true
       max_velocity: 1.0
       has_acceleration_limits: true
       max_acceleration: 2.0
   

   Copy
2. Kollisionsmesh-Fehler: Stellen Sie sicher, dass alle <collision>- und <visual>-Tags in der URDF <geometry>-Elemente enthalten (z. B. <mesh filename="package://meshes/panda_link.dae"/>).
3. SRDF-Validierung: Führen Sie aus:

   ros2 run srdfdom check_srdf Ihr_Roboter.srdf
   

   Copy

3. Bewegungsplanung mit OMPL

Planung einer Trajektorie im Gelenkraum

Nutzen Sie moveit_commander (Python) oder move_group (C++). Hier ein Python-Beispiel:

#!/usr/bin/env python3
import rclpy
from moveit_commander import MoveGroupCommander

def plan_joint_trajectory():
    rclpy.init()
    group = MoveGroupCommander("panda_arm")  # Gruppennamen aus der SRDF
    group.set_planner_id("RRTConnectkConfigDefault")  # OMPL-Planer

    # Zielposition für Gelenke (in Radiant)
    joint_goal = [0.0, -0.785, 0.0, -2.356, 0.0, 1.571, 0.785]
    group.set_joint_value_target(joint_goal)

    # Planung und Ausführung
    plan = group.go(wait=True)
    if plan:
        print("Trajektorie erfolgreich ausgeführt!")
    else:
        print("Planung fehlgeschlagen.")

if __name__ == "__main__":
    plan_joint_trajectory()
    rclpy.shutdown()

Wichtige OMPL-Planer in MoveIt 2.8.0

Planung in RViz visualisieren

1. Fügen Sie eine Motion Planning-Ansicht in RViz hinzu.
2. Wählen Sie Ihre Gruppe (panda_arm).
3. Klicken Sie auf "Plan", um die Trajektorie in Rot anzuzeigen.

Häufige Probleme

1. Planungsfehler: Falls group.go() False zurückgibt, versuchen Sie:
   • Einen anderen Planer: group.set_planner_id("TRRT").
   • Anpassung der max_iterations in der Planer-Konfiguration:

     # config/planning_pipelines/panda.srdf
     planner_configs:
       RRTConnectkConfigDefault:
         max_iterations: 1000000
     

     Copy
2. Selbstkollisionen: Überprüfen Sie die <collision>-Tags in der URDF. Nutzen Sie:

   ros2 run moveit_ros_planning_interface check_collisions
   

   Copy

4. Kollisionsprüfung und Planungsszenarien

Objekte zum Planungsszenario hinzufügen

def add_box_to_scene():
    scene = group.get_planning_scene()
    box_pose = geometry_msgs.msg.PoseStamped()
    box_pose.header.frame_id = "panda_link0"
    box_pose.pose.position.z = 0.2  # Offset zum Endeffektor

    scene.add_box("box1", box_pose, (0.1, 0.1, 0.1))  # Abmessungen (x, y, z)
    scene.async_update()  # Nicht-blockierende Aktualisierung

Kollisionsprüfung

def check_collision():
    collision_state = group.get_current_state()
    result = group.check_state_collision(collision_state)
    print(f"Kollision erkannt: {result}")

Szenen speichern/laden

# Szene in eine Datei speichern
scene.export_to_xml_file("scene.xml")

# Szene laden
scene.load_from_xml_file("scene.xml")

Häufige Probleme

1. Veraltete Szenendaten: Rufen Sie immer scene.async_update() nach Änderungen auf.
2. Objektrahmen: Stellen Sie sicher, dass alle Objektposen in einem gültigen Rahmen (z. B. panda_link0) definiert sind.
3. Performance: Bei vielen Objekten nutzen Sie scene.async_update(), um Blockaden zu vermeiden.

5. Kartesische Pfade und Pick-and-Place

Planung eines kartesischen Pfads

def plan_cartesian_path():
    group.set_max_velocity_scaling_factor(0.5)  # Verlangsamung für Präzision
    waypoints = []

    # Startposition
    waypoints.append(group.get_current_pose().pose)

    # Zwischenziele definieren (6D-Pose: x,y,z,Roll,Nick,Gierwinkel)
    pose_target = geometry_msgs.msg.Pose()
    pose_target.position.x = 0.3
    pose_target.position.y = 0.1
    pose_target.position.z = 0.2
    pose_target.orientation.w = 1.0
    waypoints.append(pose_target)

    # Planung und Ausführung
    (plan, fraction) = group.compute_cartesian_path(
        waypoints,
        eef_step=0.01,  # Schrittgröße des Endeffektors
        jump_threshold=0.0
    )
    group.execute(plan)

Pick-and-Place-Beispiel

def pick_and_place():
    # Annäherung an das Objekt
    group.set_pose_target(pick_pose)
    plan = group.go(wait=True)

    # Objekt greifen (simuliert)
    group.attach_object("box1")

    # Bewegung zur Platzierposition
    group.set_pose_target(place_pose)
    plan = group.go(wait=True)

    # Objekt loslassen
    group.detach_object("box1")

Häufige Probleme

1. Rahmeninkonsistenzen: Stellen Sie sicher, dass alle Positionsdaten im gleichen Rahmen (z. B. base_link) definiert sind.
2. Singularitäten: Kartesische Pfade können in Singularitätsbereichen scheitern. Nutzen Sie:

   group.set_goal_joint_tolerance(0.001)  # Engere Toleranz
   

   Copy
3. Greifersteuerung: Für Greifer nutzen Sie ros2_control-Schnittstellen (siehe Abschnitt 6).

6. MoveIt Servo für Echtzeitsteuerung

MoveIt Servo ermöglicht die Echtzeit-Trajektorienverfolgung mit ros2_control. Dies ist entscheidend für dynamische Umgebungen oder hochgeschwindigkeitsfähige Aufgaben.

Voraussetzungen

• Installieren Sie ros2_control und Hardware-Schnittstellen:

  sudo apt install ros-jazzy-ros2-control ros-jazzy-ros2-controllers
  

  Copy

Servo-Konfiguration

1. Servo in die Startdatei einbinden:

   <!-- launch/servo_demo.launch.py -->
   <launch>
     <include file="$(find Ihr_Roboter_moveit_config)/launch/demo.launch.py"/>
     <node pkg="moveit_servo" exec="servo_node" name="servo_node">
       <param name="robot_description" type="string" command="$(param robot_description)"/>
       <param name="group_name" value="panda_arm"/>
       <param name="servo_period" value="0.01"/>  <!-- 100Hz -->
     </node>
   </launch>
   

   Copy

2. Servo starten:

   ros2 launch Ihr_Roboter_moveit_config servo_demo.launch.py
   

   Copy

Echtzeitbefehle senden

def servo_cartesian_motion():
    servo = MoveItServoCommander("panda_arm")
    servo.start()

    # Wegpunkt definieren
    waypoint = geometry_msgs.msg.PoseStamped()
    waypoint.header.frame_id = "base_link"
    waypoint.pose.position.x = 0.4

    # Befehl mit 100Hz senden
    servo.send_cartesian_waypoint(waypoint, 0.01)  # Intervall von 0.01s

Häufige Probleme

1. Latenz: Servo erfordert einen Echtzeit-Kernel für Latenzen unter 10 ms. Nutzen Sie:

   sudo apt install ros-jazzy-ros2-realtime-tools
   

   Copy
2. Reglerabstimmung: Passen Sie servo_period an (Standard: 0.01s). Niedrigere Werte können zu Jitter führen.
3. Hardwarekompatibilität: Stellen Sie sicher, dass die Treiber Ihres Roboters ros2_control unterstützen (z. B. franka_ros2 für Franka-Roboter).