Comment configurer MoveIt 2 : Un guide pratique

MoveIt 2 est la solution de référence pour la planification de mouvements dans ROS 2, permettant aux bras robotisés de planifier, exécuter et adapter des trajectoires tout en évitant les collisions. Ce guide couvre l'installation, la configuration et des cas d'usage concrets — de la planification de base au contrôle en temps réel — en utilisant MoveIt 2.8.0 (mai 2026) sur ROS 2 Jazzy.

TL;DR

• Installez MoveIt 2 via ros-jazzy-moveit ou compilez depuis la source pour une personnalisation.
• Utilisez l’Assistant de configuration MoveIt pour générer les fichiers de configuration URDF/SRDF de votre robot.
• Planifiez des mouvements avec les planificateurs OMPL (par exemple, RRTConnectkConfigDefault) et visualisez-les dans RViz.
• Activez MoveIt Servo pour un suivi de trajectoire en temps réel avec ros2_control.
• Intégrez la perception (par exemple, des flux vidéo) via les sujets ROS 2 et moveit_msgs/PlanningScene.

1. Installation et l’Assistant de Configuration MoveIt

Prérequis

• Ubuntu 24.04 (Noble Numbat) + ROS 2 Jazzy (guide d'installation).
• Python 3.10+ (nécessaire pour MoveIt 2.8.0 en raison des mises à jour de moveit_commander).
• Git et colcon (pour les compilations depuis la source).

Vérifiez votre configuration :

echo $ROS_DISTRO  # Doit afficher "jazzy"
python3 --version # Doit afficher 3.10+

Installation de MoveIt 2

Option A : Installation Binaire (Recommandée)

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

Vérifiez l'installation :

ros2 pkg prefix moveit_ros  # Doit retourner /opt/ros/jazzy

Option B : Compilation depuis la Source (Pour une Personnalisation)

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

Lancement de la Démo MoveIt

Testez avec le robot Panda (inclus dans MoveIt) :

ros2 launch moveit2_demos panda_moveit_demo.launch.py

• Résultat attendu : RViz s'ouvre avec le bras Panda et une scène de planification.
• Problème courant : Si RViz ne s'ouvre pas, installez les dépendances manquantes :

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

  Copy

2. Configuration d’un Robot (URDF/SRDF)

Étape 1 : Préparer votre fichier URDF

MoveIt nécessite un fichier URDF (description du robot) et un fichier SRDF (description sémantique du robot). Utilisez l’Assistant de Configuration MoveIt pour générer ces fichiers.

Exemple de fichier URDF (Bras Panda Simplifié)

<!-- 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>
  <!-- Ajoutez ici les articulations et liens de votre robot -->
</robot>

Étape 2 : Exécuter l’Assistant de Configuration

ros2 run moveit_setup_assistant setup_assistant

• Entrées :
  • Fichier URDF : chemin/vers/votre_robot.urdf.xacro
  • Dossier de sortie : ~/moveit2_ws/src/your_robot_moveit_config
• Sorties générées :
  • config/srdf/ (descriptions sémantiques)
  • config/joint_limits.yaml (limites des articulations)
  • launch/ (fichiers de lancement)

Étape 3 : Compilation et Chargement

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

Étape 4 : Lancer Votre Robot dans MoveIt

ros2 launch your_robot_moveit_config demo.launch.py

• Résultat attendu : RViz affiche l’arbre cinématique de votre robot et les objets de collision.

Problèmes Courants

1. Limites d’Articulations Manquantes : Si les articulations ne bougent pas, vérifiez 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. Erreurs de Maillage de Collision : Assurez-vous que toutes les balises <collision> et <visual> dans le URDF contiennent une balise <geometry> (par exemple, <mesh filename="package://meshes/panda_link.dae"/>).
3. Validation du SRDF : Exécutez :

   ros2 run srdfdom check_srdf your_robot.srdf
   

   Copy

3. Planification de Mouvements avec OMPL

Planifier une Trajectoire dans l’Espace Articulaire

Utilisez moveit_commander (Python) ou move_group (C++). Voici un exemple en Python :

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

def planifier_trajectoire_articulaire():
    rclpy.init()
    groupe = MoveGroupCommander("panda_arm")  # Nom du groupe issu du SRDF
    groupe.set_planner_id("RRTConnectkConfigDefault")  # Planificateur OMPL

    # Définir un objectif articulaire (en radians)
    objectif_articulaire = [0.0, -0.785, 0.0, -2.356, 0.0, 1.571, 0.785]
    groupe.set_joint_value_target(objectif_articulaire)

    # Planifier et exécuter
    plan = groupe.go(wait=True)
    if plan:
        print("Trajectoire exécutée avec succès !")
    else:
        print("Échec de la planification.")

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

Principaux Planificateurs OMPL dans MoveIt 2.8.0

Visualiser le Plan dans RViz

1. Ajoutez un affichage Motion Planning dans RViz.
2. Sélectionnez votre groupe (panda_arm).
3. Cliquez sur "Planifier" pour voir la trajectoire en rouge.

Problèmes Courants

1. Échec de la Planification : Si groupe.go() retourne False, essayez :
   • Un planificateur différent : groupe.set_planner_id("TRRT").
   • Ajustez max_iterations dans la configuration du planificateur :

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

     Copy
2. Collisions Auto-engendrées : Vérifiez les balises <collision> dans votre URDF. Utilisez :

   ros2 run moveit_ros_planning_interface check_collisions
   

   Copy

4. Vérification des Collisions et Scènes de Planification

Ajouter des Objets à la Scène de Planification

def ajouter_cube_a_la_scene():
    scene = groupe.get_planning_scene()
    pose_cube = geometry_msgs.msg.PoseStamped()
    pose_cube.header.frame_id = "panda_link0"
    pose_cube.pose.position.z = 0.2  # Décalage par rapport à l'effecteur final

    scene.add_box("cube1", pose_cube, (0.1, 0.1, 0.1))  # Dimensions (x, y, z)
    scene.async_update()  # Mise à jour non bloquante

Vérifier les Collisions

def verifier_collision():
    etat_collision = groupe.get_current_state()
    resultat = groupe.check_state_collision(etat_collision)
    print(f"Collision détectée : {resultat}")

Enregistrer/Charger des Scènes

# Enregistrer la scène dans un fichier
scene.export_to_xml_file("scene.xml")

# Charger la scène
scene.load_from_xml_file("scene.xml")

Problèmes Courants

1. Données de Scène Obsolètes : Appelez toujours scene.async_update() après toute modification.
2. Cadre de Référence des Objets : Assurez-vous que toutes les poses des objets sont dans un cadre valide (par exemple, panda_link0).
3. Performance : Pour de nombreux objets, utilisez scene.async_update() pour éviter les blocages.

5. Trajectoires Cartésiennes et Prise/Dépose

Planifier une Trajectoire Cartésienne

def planifier_trajectoire_cartesienne():
    groupe.set_max_velocity_scaling_factor(0.5)  # Ralentir pour plus de précision
    points_de_passe = []

    # Commencer depuis la pose actuelle
    points_de_passe.append(groupe.get_current_pose().pose)

    # Définir des points de passe intermédiaires (pose 6D : x,y,z,roulis,tangage,lacet)
    pose_cible = geometry_msgs.msg.Pose()
    pose_cible.position.x = 0.3
    pose_cible.position.y = 0.1
    pose_cible.position.z = 0.2
    pose_cible.orientation.w = 1.0
    points_de_passe.append(pose_cible)

    # Planifier et exécuter
    (plan, fraction) = groupe.compute_cartesian_path(
        points_de_passe,
        eef_step=0.01,  # Taille du pas de l'effecteur final
        jump_threshold=0.0
    )
    groupe.execute(plan)

Exemple de Prise/Dépose

def prise_depose():
    # Approcher l'objet
    groupe.set_pose_target(pose_prise)
    plan = groupe.go(wait=True)

    # Attacher l'objet (simulé)
    groupe.attach_object("cube1")

    # Se déplacer vers la pose de dépose
    groupe.set_pose_target(pose_depose)
    plan = groupe.go(wait=True)

    # Détacher l'objet
    groupe.detach_object("cube1")

Problèmes Courants

1. Incohérence des Cadres de Référence : Assurez-vous que toutes les poses sont dans le même cadre (par exemple, base_link).
2. Singularités : Les trajectoires cartésiennes peuvent échouer près des singularités. Utilisez :

   groupe.set_goal_joint_tolerance(0.001)  # Tolérance plus stricte
   

   Copy
3. Contrôle de la Pince : Pour les pinces, utilisez les interfaces ros2_control (voir Section 6).

6. MoveIt Servo pour un Contrôle en Temps Réel

MoveIt Servo permet un suivi de trajectoire en temps réel en utilisant ros2_control. Cela est crucial pour les environnements dynamiques ou les tâches à haute vitesse.

Prérequis

• Installez ros2_control et les interfaces matérielles :

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

  Copy

Configurer Servo

1. Ajouter Servo à Votre Fichier de Lancement :

   <!-- launch/servo_demo.launch.py -->
   <launch>
     <include file="$(find your_robot_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. Exécuter Servo :

   ros2 launch your_robot_moveit_config servo_demo.launch.py
   

   Copy

Envoyer des Commandes en Temps Réel

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

    # Définir un point de passe
    point_de_passe = geometry_msgs.msg.PoseStamped()
    point_de_passe.header.frame_id = "base_link"
    point_de_passe.pose.position.x = 0.4

    # Envoyer à 100Hz
    servo.send_cartesian_waypoint(point_de_passe, 0.01)  # Intervalle de 0.01s

Problèmes Courants

1. Latence : Servo nécessite un noyau temps réel pour une latence inférieure à 10 ms. Installez :

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

   Copy
2. Réglage du Contrôleur : Ajustez servo_period (valeur par défaut : 0.01s). Des valeurs plus basses augmentent le jitter.
3. Compatibilité Matérielle : Assurez-vous que les pilotes de votre robot sont compatibles avec ros2_control (par exemple, franka_ros2 pour les robots Franka).