Rapport — Projet robotique mobile et navigation autonome : Application au robot TurtleBot3#
Binôme : Benoît de Keyn & Thibault Agueh
Date : 26 novembre 2026
Introduction#
Ce rapport présente la conception, l'implémentation et la validation de notre projet de robotique mobile et navigation autonome sous ROS Noetic, appliqué au robot TurtleBot3 Burger (en simulation Gazebo et en conditions réelles dans le labyrinthe de la salle 4105).
L'objectif du projet est de bâtir progressivement une architecture logicielle complète et modulaire — regroupée dans le package TABDK puis couplée au planificateur AStar-ROS — couvrant l'ensemble de la chaîne robotique :
- le pilotage bas niveau (
/cmd_vel) et le paramétrage global via YAML ; - la gestion des modes (
manual/auto), de la pause et de la localisation odométrique (/odom) ; - l'asservissement en position et en orientation, étendu vers des déplacements fluides avant/arrière ;
- la perception 360° par LiDAR (
/scan), la visualisation dans RViz et la prévention active de collision ; - la supervision par services ROS (
/set_mode,/global_control), le suivi asynchrone de waypoints par action (/moving) et la gestion de trajectoiresnav_msgs/Path; - la cartographie SLAM (Gmapping) et la planification de chemin A* améliorée avec lissage de trajectoire.
Au-delà des exigences de l'énoncé, nous détaillons également notre démarche d'ingénierie : nos choix fonctionnels, les versions intermédiaires, les difficultés rencontrées sur simulateur et sur robot réel, ainsi que la migration d'un nœud monolithique vers une architecture orientée objet en classes.
Environnement de développement#
Pour gagner en efficacité tout au long du projet et travailler de manière fiable en binôme, nous nous sommes appuyés sur deux environnements complémentaires : la simulation en ligne TheConstructSim et un workspace VS Code automatisé couplé à GitHub pour le robot physique.
Simulation en ligne : TheConstructSim#
Pour développer à distance depuis chez nous, prototyper rapidement nos nœuds ROS et économiser la batterie du TurtleBot3 réel (dont l'autonomie en séance était limitée), nous avons utilisé la plateforme en ligne TheConstructSim. Elle fournit directement dans le navigateur un environnement prêt à l'emploi combinant un VS Code en ligne, Gazebo et RViz pour tester nos packages dans un monde virtuel.
La principale contrainte de cette plateforme était la réinitialisation des paquets non préinstallés (ros-noetic-turtlebot3-slam et ros-noetic-turtlebot3-navigation) et le bridage d'apt lié à la clé GPG ROS — problème entièrement automatisé par notre script tabdk.sh (détaillé en § 6.1).
Développement local et déploiement sur le robot : VS Code, GitHub et SSH#
Sur nos postes personnels, plutôt que d'utiliser MobaXterm — qui impose de conserver le code directement sur le robot, d'ouvrir et d'agencer manuellement plusieurs fenêtres SSH et de ressaisir régulièrement le mot de passe — nous avons privilégié un flux de travail familier et sécurisé basé sur VS Code, GitHub et GitHub Desktop. Le code reste versionné localement (collaboration propre en binôme, historique des versions, retour arrière sans risque), puis synchronisé sur le robot.
Après une première phase où il fallait recopier manuellement chaque fichier modifié vers le robot, nous avons conçu un workspace VS Code dédié (robotique.code-workspace et .vscode/) qui automatise toute la chaîne :
- Explorateur épuré : seuls nos dossiers utiles (
TABDK/puisAStar-ROS/) apparaissent directement dans VS Code, évitant de naviguer dans toute l'arborescence Ubuntu du TurtleBot3. - Synchronisation automatique à la sauvegarde (
sync_robot.ps1+ extension Run on Save) : à chaque enregistrement local, un script PowerShell (protégé par mutex) recopie en miroirTABDK/etAStar-ROS/vers~/catkin_ws/src/sur le robot viatar | ssh, sans saisie de mot de passe grâce à la clé SSH configurée parsetup.ps1. - Ouverture automatique des terminaux et de l'affichage RViz (
tasks.json+connect.ps1) : dès l'ouverture du workspace, VS Code lance le serveur X (VcXsrv pour l'affichage déporté de RViz), exécute une synchronisation initiale, démarre./run_robot.sh(roscore+ bringup) dans un terminal SSH dédié, puis ouvre un terminal SSH vierge prêt à l'emploi (avec nos alias ROS déjà chargés). - Profil de terminal SSH par défaut : tout nouveau terminal ouvert dans VS Code bascule automatiquement en session SSH (
ssh -Y) directement sur le TurtleBot3.
I. Architecture finale du projet#
Arborescence du paquet TABDK#
%%{init: {"layout": "elk"}}%%
flowchart LR
ROOT["`**TABDK/**`"]
META["`CMakeLists.txt · package.xml<br/>Compilation & dépendances`"]
D_LAUNCH["`**launch/**`"]
L_RUN["`run.launch<br/>params.yaml + 5 nœuds`"]
L_RVIZ["`rviz_tb3.launch<br/>RViz LiDAR + remote`"]
D_CONFIG["`**config/**`"]
C_PARAMS[("`params.yaml<br/>Paramètres ROS`")]
C_RVIZ[("`tb3_lidar.rviz<br/>Config RViz LiDAR`")]
D_SRV["`**srv/**`"]
S_MODE{{"`set_mode.srv<br/>/set_mode`"}}
S_CTRL{{"`global_control.srv<br/>/global_control`"}}
D_ACTION["`**action/**`"]
A_MOVE{{"`Move.action<br/>/moving`"}}
D_SRC["`**src/**`"]
N_CTRL(["`**controleur.cpp**<br/>Nœud controleur`"])
subgraph DEPS_CTRL["Dépendances de controleur.cpp"]
M_CALC(["`calculs.cpp`"])
M_PARAMS(["`parametres.cpp`"])
M_ODOM(["`odometry.cpp`"])
M_MVT(["`mouvements.cpp`"])
M_STATES(["`states.cpp`"])
M_MODES(["`modes.cpp`"])
M_ACT(["`serveur_action.cpp`"])
M_SRV(["`serveur_services.cpp`"])
end
D_NODES["`**nodes/**`"]
N_KEY(["`**keyboard_input.cpp**<br/>Nœud keyboard_input`"])
N_CSRV(["`**client_services.cpp**<br/>Nœud client_services`"])
N_CACT(["`**client_action.cpp**<br/>Nœud client_action`"])
N_DET(["`**detector.cpp**<br/>Nœud detector`"])
ROOT --> META
ROOT --> D_LAUNCH
ROOT --> D_CONFIG
ROOT --> D_SRV
ROOT --> D_ACTION
ROOT --> D_SRC
D_LAUNCH --> L_RUN
D_LAUNCH --> L_RVIZ
D_CONFIG --> C_PARAMS
D_CONFIG --> C_RVIZ
D_SRV --> S_MODE
D_SRV --> S_CTRL
D_ACTION --> A_MOVE
D_SRC --> N_CTRL
D_SRC --> D_NODES
N_CTRL -.-> M_CALC
N_CTRL -.-> M_PARAMS
N_CTRL -.-> M_ODOM
N_CTRL -.-> M_MVT
N_CTRL -.-> M_STATES
N_CTRL -.-> M_MODES
N_CTRL -.-> M_ACT
N_CTRL -.-> M_SRV
D_NODES --> N_KEY
D_NODES --> N_CSRV
D_NODES --> N_CACT
D_NODES --> N_DET
classDef pkg fill:#1d4ed8,stroke:#1e40af,stroke-width:2px,color:#ffffff
classDef dossier fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef cpp fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef autre fill:#f3e8ff,stroke:#9333ea,stroke-width:1.5px,color:#581c87
class ROOT pkg
class D_LAUNCH,D_CONFIG,D_SRV,D_ACTION,D_SRC,D_NODES dossier
class N_CTRL,M_CALC,M_PARAMS,M_ODOM,M_MVT,M_STATES,M_MODES,M_ACT,M_SRV,N_KEY,N_CSRV,N_CACT,N_DET cpp
class META,L_RUN,L_RVIZ,C_PARAMS,C_RVIZ,S_MODE,S_CTRL,A_MOVE autre
style DEPS_CTRL fill:#f3f4f6,stroke:#9ca3af,stroke-width:1.5px,color:#374151
Découpage du noeud Controleur en classes#
Classe principale et dépendances neutres#
Le fichier calculs.cpp est le seul fichier .cpp qui ne contient pas une classe mais simplement des fonctions utilitaires.
%%{init: {"layout": "elk"}}%%
classDiagram
direction TB
class Controleur["controleur.cpp"] {
Role : Point d'entree, initialisation et boucle principale
Publishers : /mode /pause /reset
Client de service : /gazebo /reset_simulation
- main()
- publishStatus()
- sigintHandler()
}
class Params["parametres.cpp"] {
Role : Chargement et conversion des parametres globaux depuis params.yaml
Parametres ROS : frequence, vitesses, gains Kp, seuils, mode par defaut, ...
- load()
- msToTicks()
- ticksToMs()
}
class Calculs["calculs.cpp"] {
Role : Fonctions de calcul purement mathématiques
}
class Odometry["odometry.cpp"]
class Mouvements["mouvements.cpp"]
class States["states.cpp"]
class Modes["modes.cpp"]
class ServeurAction["serveur_action.cpp"]
class ServeurServices["serveur_services.cpp"]
Controleur *-- ServeurAction : init ()
Controleur --> ServeurAction : step ()
Controleur *-- ServeurServices : init ()
Controleur --> ServeurServices : resetRobot ()
Controleur *-- Params : load ()
Controleur *-- Modes : init ()
Controleur *-- States : init ()
Controleur *-- Mouvements : init ()
Controleur *-- Odometry : init ()
Mouvements --> Params : vitesses / gains Kp ?<br/>seuils de precision ?
ServeurAction --> Params : conversion ms/ticks ()
States --> Params : vitesses / delais ?<br/>fonctionnalités reachPosition ?
Params ..> Calculs : conversion deg/rad ()
Mouvements ..> Calculs : conversion deg/rad ()<br/>correcteur proportionnel ()<br/>soustraction d'angles ()
style Controleur fill:#dbeafe,stroke:#1d4ed8,stroke-width:2px,color:#1e3a8a
style Params fill:#f3f4f6,stroke:#6b7280,stroke-width:1.5px,color:#1f2937
style Calculs fill:#f3f4f6,stroke:#6b7280,stroke-width:1.5px,color:#1f2937
style Odometry fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
style Mouvements fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
style States fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
style Modes fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
style ServeurAction fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
style ServeurServices fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
Interactions entre les classes du nœud Controleur#
%%{init: {"layout": "elk"}}%%
classDiagram
direction TB
class ServeurServices["serveur_services.cpp"] {
Role : Commandes synchrones et reset global du robot
Serveurs de services : /set_mode, /global_control
Publisher : /reset
Client de service : /gazebo, /reset_simulation
- resetRobot()
- setModeCallback()
- globalControlCallback()
}
class ServeurAction["serveur_action.cpp"] {
Role : Suivi des waypoints, feedback continu et annulation
Serveur d'action : /moving
- demarrer()
- step()
- execute()
- preempter()
- reset()
}
class Modes["modes.cpp"] {
Role : Gestion du mode actif et de la pause
- set_mode()
- set_pause()
}
class States["states.cpp"] {
Role : Machine a etats finis des deplacements
- updateFSMManual()
- updateFSMAuto()
- applyState()
}
class Mouvements["mouvements.cpp"] {
Role : Pilotage des moteurs et asservissement vers une cible
Publisher : /cmd_vel
- forward/backward(vitesse positive)
- pivoter(vitesse signée)
- stop()
- move(vitesses signées : angulaire + lineaire)
- reachPosition(x,y) (avec versions 'Smooth' et 'Back')
}
class Odometry["odometry.cpp"] {
Role : Suivi de la position x, y, de l'orientation theta
et de la distance parcourue / à une position
Subscriber : /odom
- distanceToPosition()
- distanceParcourue()
}
ServeurServices --> Modes : changer de mode (mode)<br/>pause () / play ()<br/>reset ()
ServeurServices --> ServeurAction : annuler goal ()<br/>redemarrer ()
ServeurAction --> Mouvements : cible atteinte ?<br/>choisir cible (x, y)<br/>arreter ()
ServeurAction --> States : activer/desactiver suivi cible ()
ServeurAction --> Modes : mode courant ?<br/>en pause ?
ServeurAction --> Odometry : position ?<br/>distance parcourue ?
Modes --> States : mettre a jour la FSM ()<br/>choisir la fn de deplacement ()<br/> arreter ()<br/>reset ()
States --> Mouvements : cible atteinte ?<br/>arreter ()<br/>executer la fn de deplacement ()<br/>reset ()
Mouvements --> Odometry : position + orientation ?<br/>distance a la cible ?
style ServeurServices fill:#dbeafe,stroke:#1d4ed8,stroke-width:1.5px,color:#1e3a8a
style ServeurAction fill:#dbeafe,stroke:#1d4ed8,stroke-width:1.5px,color:#1e3a8a
style Modes fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
style States fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
style Mouvements fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
style Odometry fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
Interaction des différents noeuds#
Les 4 nœuds du dossier TABDK/src/nodes/ complètent le nœud controleur. Leurs diagrammes d'interactions détaillés (dépendances de compilation, paramètres, topics, services et action) sont présentés et commentés dans la version finale de leurs parties respectives :
Nœud (TABDK/src/nodes/) |
Rôle principal | Schéma détaillé |
|---|---|---|
keyboard_input.cpp |
Capture clavier non-canonique → /keyboard_input |
§ 3.2 Mode navigation manuelle |
detector.cpp |
Analyse LiDAR 8 régions, marqueurs RViz & anti-collision | § 4. Perception LiDAR |
client_services.cpp |
Commandes clavier m/p/r → /set_mode & /global_control |
§ 5.1 Services |
client_action.cpp |
File de waypoints (clavier ou /robot_path) → action /moving |
§ 5.3 Gestion des trajectoires — Path |
La démarche complète de passage d'un
controleur.cppmonolithique à cette architecture orientée objet (patterninit(), injection de dépendances, callbacks membres et contraintes spécifiques deServeurAction) est détaillée en § 7. Migration architecturale.
2. Pilotage de base et paramétrage du TB3#
2.3 Pilotage de base du TB3#
Énoncé#
Ajouter dans le nœud contrôleur un publisher générant une commande en vitesse pour déplacer le robot TurtleBot3 :
- Identifier le topic concerné, l'en-tête
.h, son namespace et le type de message associé. - Réaliser
avancer(double vitesse)etarreter()(publication effectuée dans la boucle principale). - Arrêter proprement le robot lors d'un
CTRL+CdanssigintHandler. - Enchaîner périodiquement avancer → arrêter → reculer avec des durées multiples de la période du contrôleur.
Choix fonctionnels#
- Utilisation du topic
/cmd_velavec le messagegeometry_msgs::Twist(#include <geometry_msgs/Twist.h>), en pilotantlinear.x(translation) etangular.z(rotation). - Conception de primitives élémentaires (
forward,backward,pivoter,stop,move) afin de poser une couche bas niveau réutilisable dans tous les exercices suivants. - Séquencement périodique géré par une machine à états (
FORWARD→STOP→BACKWARD) cadencée parros::Rate. - Interception explicite de
SIGINT(ros::init_options::NoSigintHandler) afin de garantir l'envoi d'une vitesse nulle avant la fermeture de ROS.
Première implémentation#
Le premier package TABDK regroupait tout dans un unique fichier controleur.cpp (131 lignes) : un publisher /cmd_vel, des fonctions globales (forward, backward, stop), un compteur de ticks et une boucle while (ros::ok()). Les durées étaient initialement configurées en nombre brut de périodes (move_fwd_per: 10, move_bwd_per: 5, move_stp_per: 3).
Difficultés rencontrées#
- Arrêt incomplet dans
stop(): la première version remettait uniquementvel.linear.x = 0sans toucher àvel.angular.z. Dès l'ajout de la rotation (pivoter()), le robot continuait de tourner sur place après un arrêt ; corrigé en réinitialisant tout le message viavel = Twist(). - Arrêt lors d'un
CTRL+C: sansNoSigintHandler, ROS coupe la boucle avant que la commande d'arrêt ne soit publiée et le robot continue sur son inertie. Le passage par un drapeauarret_demandelevé parsigintHandlerpermet d'exécuter un arrêt garanti en sortie de boucle. - Dépendance des durées à la fréquence : exprimer les durées en nombre de périodes (
*_per) changeait la durée réelle des mouvements dès qu'on modifiait la fréquence de boucle ; passage à des durées en millisecondes (*_tm) converties parmsToTicks().
Version finale#
- Les primitives moteurs sont encapsulées dans la classe
Mouvements(TABDK/src/mouvements.cpp), avecstop()publiant unTwist()nul. - Le cycle périodique avancer/arrêter/reculer est conservé dans
States::updateFSMAuto()(TABDK/src/states.cpp). sigintHandler()dansTABDK/src/controleur.cpplèvearret_demande, déclenchantservices.resetRobot()puisros::shutdown()en sortie de boucle.
2.4 Paramètres de l'application#
Énoncé#
Rendre l'application générique en spécifiant des paramètres (notamment la fréquence de contrôle) au lancement des nœuds, soit via les arguments de run.launch, soit via un fichier YAML dans un sous-dossier config/, puis tester le contrôleur à différentes fréquences.
Choix fonctionnels#
- Adoption d'un fichier YAML centralisé (
TABDK/config/params.yaml) chargé sur le serveur de paramètres ROS par<rosparam command="load" file="$(find TABDK)/config/params.yaml" />danslaunch/run.launch, plutôt que de multiplier les<arg>dans le launch file. - Saisie des paramètres angulaires en degrés et des temporisations en millisecondes dans le YAML pour rester lisible lors des essais sur robot, avec conversion automatique en radians / ticks au chargement.
- Valeurs par défaut codées dans la classe
Paramsservant de filet de sécurité si une clé manque ou comporte une faute de frappe dans le YAML.
Première implémentation#
Le premier config/params.yaml ne comportait que 5 clés (frequence, linear_speed, move_fwd_per, move_bwd_per, move_stp_per), lues directement au début du main() de controleur.cpp. Par la suite, les premiers nœuds satellites (keyboard_input, detector, client_action) ont d'abord conservé leurs propres constantes codées en dur (FREQ_ACTUALISATION = 5, Rate loop_rate(5), MIN_DELAY_COLLISION = 2.0f).
Difficultés rencontrées#
- Paramètres éclatés et fréquences désynchronisées : multiplier les constantes locales dans chaque nœud empêchait de changer la fréquence globale ou les seuils de collision d'un seul geste. La classe
Paramsa donc été incluse dans l'ensemble des 5 nœuds pour unifier le chargement. - Pièges de saisie YAML et d'unités : un doublon de clé dans
params.yaml(par exempledebut_collision_facerenseigné deux fois au lieu dedebut_collision_dos) ou une confusion degrés/radians peut passer silencieusement ; les valeurs de repli deParamset la conversion centralisée dansParams::load()limitent ces risques.
Version finale#
- La classe
Params(TABDK/src/parametres.cpp) est incluse par les 5 nœuds du package (controleur,keyboard_input,client_services,client_action,detector). Params::load(nh)charge 19 paramètres (fréquence, vitesses, gainsKp_*, seuils de précision et de pivot,waypoint_step,move_smooth,move_back,default_mode, temporisations et paramètres anti-collision) et convertitprecision_angularettrigger_pivoten radians.- Les méthodes
msToTicks()etticksToMs()garantissent une base de temps homogène dans tout le contrôleur, indépendante de la fréquence choisie :
void load(NodeHandle &nh) {
nh.getParam("frequence", frequence);
// ... chargement des vitesses, gains Kp, seuils, modes et collision ...
precision_angular = deg_to_rad(precision_angular);
trigger_pivot = deg_to_rad(trigger_pivot);
}
int msToTicks(int ms) { return frequence * ms / 1000; }
double ticksToMs(std::uint64_t ticks) const { return ticks * 1000.0 / frequence; }
(Voir § 7. Migration architecturale pour le mécanisme d'inclusion #include "*.cpp" partagé entre nœuds et l'initialisation différée après ros::init().)
3. Contrôle et navigation du TB3#
3.1 Les modes de navigation#
Énoncé#
Permettre au TurtleBot3 de basculer entre mode manuel et mode navigation autonome à l'aide d'une machine à états finis (switch), avec un mode par défaut configurable au lancement de l'application.
Choix fonctionnels#
- Séparation progressive de trois concepts qui étaient initialement mêlés :
- le mode actif (
"manual"ou"auto"), stocké enstd::stringpour correspondre directement aux messages ROS sans table de conversion ; - la pause (
pause_active), traitée comme un état orthogonal afin de suspendre n'importe quel mode sans le réinitialiser ; - la FSM des déplacements (
STOP,FORWARD,BACKWARD,PIVOTER_GAUCHE,PIVOTER_DROITE,REACH_POSITION_X,REACH_ANGLE,REACH_POSITION).
- le mode actif (
- Publication continue (latched) de
/mode(std_msgs/String) et/pause(std_msgs/Bool) parcontroleur.cpppour garder tous les nœuds synchronisés.
Première implémentation#
Une enum RobotMode (AUTO, MANUAL, puis PAUSE) et une enum RobotState étaient gérées par des switch dans controleur.cpp. Les ordres issus du clavier étaient initialement stockés dans un dictionnaire dynamique std::unordered_map<string, std::variant<bool, string>> (approche inspirée de Python).
Difficultés rencontrées#
- Structure de données trop lourde : l'usage de
unordered_map<string, variant<bool, string>>imposait des extractions verbeuses (std::get<string>) et des chaînes non vérifiées à la compilation ; il a été remplacé très tôt par une structure typéestruct KeyboardInputset uneenum Direction. - Pause couplée aux directions et aux modes : dans les premières versions, mettre le robot en pause ne remettait pas la direction clavier à
NONE(le robot repartait dans l'ancienne direction à la reprise), puisPAUSEgéré comme un mode à part entière (avecprevious_mode_) compliquait les changements de mode pendant une pause. - Monolithe de plus de 700 lignes :
controleur.cppaccumulait calculs, paramètres, odométrie, clavier, FSM et mouvements. Trois refactorings successifs ont permis de passer en programmation orientée objet : extraction des modules bas niveau (calculs,parametres,odometry,mouvements), découplage de la pause, puis éclatement du cœur logique enModesetStatesavec une conventioninit()uniforme aprèsros::init()(détaillé en § 7. Migration architecturale).
Version finale#
Modes(TABDK/src/modes.cpp) valide le mode par défaut issu deparams.yaml(default_mode), gèreset_mode()/set_pause()et cadenceStatesdansstep().States(TABDK/src/states.cpp) pilote la FSM des déplacements et appelleMouvementsviaapplyState().- En version finale,
manualetautopartagent tous deux le suivi de cible (REACH_POSITION), la différence portant sur l'origine des waypoints (saisie clavier vs trajectoire/robot_path), tandis quepause_activeintercepte le cycle en amont sans altérer l'état courant :
%%{init: {"layout": "elk"}}%%
flowchart TB
STEP(["`Modes::step()`"])
CHECK_P{"`pause_active ?`"}
STOP_P["`states->stop()<br/>(état FSM conservé)`"]
FSM_STOP(["`States : STOP`"])
FSM_REACH(["`States : REACH_POSITION`"])
APPLY["`States::applyState()<br/>→ Mouvements`"]
STEP --> CHECK_P
CHECK_P -->|"oui"| STOP_P
CHECK_P -->|"non (manual ou auto)"| FSM_STOP
FSM_STOP -->|"target_active = true"| FSM_REACH
FSM_REACH -->|"position_atteinte ou !target_active"| FSM_STOP
FSM_STOP --> APPLY
FSM_REACH --> APPLY
style STEP fill:#dbeafe,stroke:#1d4ed8,stroke-width:1.5px,color:#1e3a8a
style CHECK_P fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
style STOP_P fill:#f3f4f6,stroke:#6b7280,stroke-width:1.5px,color:#1f2937
style FSM_STOP fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
style FSM_REACH fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
style APPLY fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
3.2 Mode navigation manuelle#
Énoncé#
Intégrer un nœud key_input_node.cpp pour piloter le robot au clavier (avancer, reculer, pivoter, modifier les vitesses dans les limites du TB3), puis évaluer la réactivité et minimiser les latences d'E/S.
Choix fonctionnels#
- Externalisation de la capture clavier dans un nœud séparé (
keyboard_input.cpp) pour ne jamais bloquer la boucle de commande du contrôleur surstdin. - Passage du terminal en mode non-canonique via
termios(newt.c_lflag &= ~ICANON) dansgetch()afin de capter chaque touche instantanément sans validation parEntrée, tout en restaurant les réglages d'origine (oldt) juste après lecture. - Architecture personnalisée (au-delà de l'énoncé) : plutôt que de conserver un pilotage direct en vitesse au clavier en parallèle du serveur d'action, nous avons scindé la chaîne clavier en 3 nœuds découplés et fait évoluer le mode manuel vers la saisie de waypoints virtuels. Le mode manuel réutilise ainsi exactement le même asservissement et la même sécurité anti-collision que le mode autonome.
Première implémentation#
Le nœud key_input_node.cpp publiait les codes ASCII sur /keyboard_input, lus directement par controleur.cpp pour commander FORWARD, BACKWARD, PIVOTER_GAUCHE, PIVOTER_DROITE, STOP (barre espace) et KEY_ZERO (0, remise à NONE). Lors de l'introduction des services, le nœud a brièvement été transformé en nodes/keyboard.cpp appelant directement /set_mode et /global_control.
Difficultés rencontrées#
- Arrêt des rotations et remise à zéro de la direction : sans remise à
NONEexplicite (KEY_ZEROou lors d'une pause), la dernière direction reçue restait active à chaque tick. - Conflit de responsabilités sur le clavier : dès qu'il a fallu envoyer des waypoints au clavier en mode manuel tout en gardant les raccourcis
m/p/r(services), concentrer la capture clavier et la logique applicative dans un seul nœudkeyboard.cppcréait un couplage ingérable. - Fréquence de scrutation : la fréquence d'actualisation de
keyboard_input.cppa d'abord été codée en dur à 5 Hz avant d'être raccordée àparams.frequence.
Version finale#
Le pilotage clavier repose sur 3 nœuds spécialisés (keyboard_input.cpp publie les codes bruts sur /keyboard_input) dont la répartition des commandes est la suivante :
| Touches | Nœud consommateur | Mécanisme ROS | Effet |
|---|---|---|---|
m |
client_services.cpp |
Service /set_mode |
Bascule manual ↔ auto |
p |
client_services.cpp |
Service /global_control |
Bascule pause ↔ play |
r |
client_services.cpp |
Service /global_control |
Réinitialisation globale (reset) |
↑ ↓ ← → |
client_action.cpp (mode manual) |
Variable locale waypoint_virtuel |
Déplace la cible virtuelle de ±waypoint_step en x ou y |
w |
client_action.cpp (mode manual) |
Action /moving (via trajectoire) |
Empile waypoint_virtuel dans la file de waypoints |
x |
client_action.cpp (mode manual) |
File locale trajectoire |
Vide la file de waypoints en attente |
Le nœud keyboard_input.cpp ne fait plus aucune logique métier : il lit frequence via parametres.cpp et diffuse les codes touches sur /keyboard_input aux deux nœuds consommateurs :
%%{init: {"layout": "elk"}}%%
flowchart TB
C_PARAMS[("`config/params.yaml`")]
M_PARAMS(["`src/parametres.cpp`"])
subgraph SG_KEY["Nœud keyboard_input"]
NODE(["`**nodes/keyboard_input.cpp**`"])
end
subgraph SG_CSRV["Nœud client_services"]
N_CSRV(["`nodes/client_services.cpp`"])
end
subgraph SG_CACT["Nœud client_action"]
N_CACT(["`nodes/client_action.cpp`"])
end
C_PARAMS -.->|"paramètre frequence"| M_PARAMS
M_PARAMS -.->|"#include"| NODE
NODE -->|"topic /keyboard_input<br/>(Int8)"| N_CSRV
NODE -->|"topic /keyboard_input<br/>(Int8)"| N_CACT
classDef cpp fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef autre fill:#f3e8ff,stroke:#9333ea,stroke-width:1.5px,color:#581c87
class M_PARAMS,N_CSRV,N_CACT cpp
class C_PARAMS autre
style SG_KEY fill:#dbeafe,stroke:#1d4ed8,stroke-width:2px,color:#1e3a8a
style NODE fill:#1d4ed8,stroke:#1e40af,stroke-width:2px,color:#ffffff
style SG_CSRV fill:#f3f4f6,stroke:#9ca3af,stroke-width:1.5px,color:#374151
style SG_CACT fill:#f3f4f6,stroke:#9ca3af,stroke-width:1.5px,color:#374151
3.3 Mode navigation autonome#
3.3.1 Localisation du TB3#
Énoncé#
Identifier le topic d'odométrie du TB3, son rythme et son type de message. Lire et afficher en temps réel la position (x, y) et le cap theta (via tf::getYaw sur le quaternion), puis permettre la réinitialisation sur robot réel (/reset) et en simulation (/gazebo/reset_simulation).
Choix fonctionnels#
- Abonnement à
/odom(nav_msgs/Odometry, ~30 Hz), extraction du capthetapartf::getYaw()et stockage dans ungeometry_msgs/Pose2D, complété par la vitesse instantanéegeometry_msgs/Twist. - Calcul continu de la distance cumulée
distance_parcourueet de la distance euclidienne à un pointdistanceToPosition(x, y)directement dans la classeOdometry. - Architecture personnalisée : unification du reset réel (
/reset,std_msgs/Empty) et simulé (/gazebo/reset_simulation,std_srvs/Empty) dans une procédure uniqueServeurServices::resetRobot()qui remet aussi à zéro les états internes et le serveur d'action dans un ordre précis.
Première implémentation#
Le subscriber /odom et le publisher /reset (touche r) ont d'abord été ajoutés directement dans controleur.cpp, puis extraits dans la classe Odometry lors de la mise en objets du contrôleur, avec dans un premier temps une struct Pose2D { double x, y, rotation; } définie à la main.
Difficultés rencontrées#
- Collision entre la
struct Pose2Dmaison etgeometry_msgs::Pose2D: lors de l'introduction deMove.action(qui transportegeometry_msgs/Pose2D), la structure maison entrait en conflit de nom avec le type ROS standard et imposait des conversions (pose.rotation↔position.theta). La structure locale a été supprimée au profit direct degeometry_msgs::Pose2D(position.x,position.y,position.theta). - Doute initial sur l'odométrie et nécessité d'un redémarrage matériel : pendant les premiers tests d'asservissement sur l'axe
x, nous pensions l'odométrie défaillante car les coordonnées dérivaient et/resetne semblait pas agir. Un redémarrage complet du robot a débloqué le capteur et montré que l'odométrie était finalement précise. - Repère fixe après reset et orientation par IMU : nous nous sommes longtemps demandé pourquoi le reset ne réalignait pas systématiquement l'axe
xdevant le robot lors de nos essais(x, y). Au moment du reset, l'axe+xest bien devant le TB3, mais l'orientation étant estimée par la centrale inertielle (IMU / accéléromètre-gyroscope de la carte OpenCR), cet axe reste ensuite fixe par rapport à l'environnement et ne tourne pas avec le robot si on le déplace manuellement. - Saut sur la première mesure odométrique : lors de l'ajout du cumul de distance parcourue (pour les résultats d'action), la première callback calculait la distance depuis
(0, 0)vers la position initiale du robot ; corrigé grâce au booléenposition_recue. - Tentative de correction
map → odomvia TF : lors de l'intégration avec AMCL/SLAM, nous avons tenté d'ajouter untf::TransformListenerdansodometry.cpppour projeter la pose/odomdans le repèremap(tout en continuant à intégrerdistance_parcouruedans le repèreodomcontinu pour éviter les sauts d'AMCL). Face aux instabilités de disponibilité du transform en pratique, cette modification a été annulée (revert) au profit d'une calibration propre de la carte en(0, 0). - Effet de bord du reset Gazebo sur
actionlib:/gazebo/reset_simulationremet l'horloge simulée à0, ce qui bloquait les goals d'action suivants avant l'ajout deaction_server->redemarrer().
Version finale#
Odometry(TABDK/src/odometry.cpp) exposeposition,vitesse,distanceToPosition(x, y)etdistanceParcourue().ServeurServices::resetRobot()(TABDK/src/serveur_services.cpp) exécute la réinitialisation dans un ordre critique (d'abord arrêt/préemption, puis reset de l'horloge Gazebo, puis recréation du serveur d'action, enfin diffusion de/resetaux clients) :
void resetRobot() {
action_server->reset(); // 1. préempte les goals en cours
modes->reset(); // 2. stoppe moteurs, reset mode & pause
std_srvs::Empty service;
client_reset_sim->call(service); // 3. remet la simu et /clock à 0
action_server->redemarrer(); // 4. oublie les anciens timestamps actionlib
pub_reset->publish(std_msgs::Empty()); // 5. notifie le TB3 réel et les clients ROS
}
(Voir § 7. Migration architecturale pour l'enregistrement du callback membre &Odometry::odomCallback, this et le partage d'instance par pointeur entre classes.)
3.3.2 Navigation vers un but#
Énoncé#
Mettre en place l'asservissement en position du TurtleBot3 :
- Parcours de distance sur un axe (
x0→x1, tolérance±0.02 m) avec correcteur proportionnel/PID. - Asservissement angulaire vers
theta(tolérance±0.05 rad) en gérant l'intervalle[-π, +π]aveccal_delta_Theta. - Cinématique inverse pour rallier une cible cartésienne
(x, y)à partir de la distance et deatan2. - Bonus (simulation) : réception interactive d'une cible via
2D Nav Goaldans RViz (/move_base_simple/goal).
Choix fonctionnels#
- Choix de correcteurs proportionnels saturés (
commande_proportionnelle(Kp, erreur, vitesse_max) = min(|Kp · e|, vmax)), suffisants et robustes sur le TB3 sans nécessiter de termes intégral/dérivé sensibles au bruit. - Fonctions originales créées au-delà de l'énoncé : en plus du
reachPosition(x, y)séquentiel classique, nous avons conçu deux variantes activables depuisparams.yaml(move_smooth,move_back) :reachPositionSmooth(x, y, arriere): introduit une hystérésis angulaire (pivot_en_cours). Tant que, le robot avance et corrige son cap simultanément via move(v, w)(avec zone morte). Si dépasse trigger_pivot,pivot_en_courspasse àtrueet le robot pivote sur place (avec le gain dédiéKp_pivot) jusqu'à retomber sousprecision_angular— ce qui évite les oscillations entre pivot et avance.reachPositionSmoothBack(x, y): si la cible se trouve dans le demi-plan arrière (), le robot évite un demi-tour complet en visant l'angle opposé ( , normalisé sur par cal_angle_offset) et en inversant la vitesse linéaire (-soft_linear_speed).
- Exploitation du bonus
2D Nav Goal(/move_base_simple/goal) via le nœudpath_generator(section 6.2) qui convertit le clic RViz en trajectoire/robot_path.
Première implémentation#
Les fonctions reachPositionX, reachAngle et reachPosition ont été développées et validées successivement dans controleur.cpp, puis portées dans mouvements.cpp lors du refactoring objet, où une première version de reachPositionSmooth a été expérimentée.
Difficultés rencontrées#
- Discontinuité angulaire autour de
±π: une soustraction directe faisait tourner le robot dans le mauvais sens au passage de ±180° ; résolu aveccal_delta_Thetaetcal_angle_offsetdanscalculs.cpp. - Inversion des gains, bridage cassé et instabilité près de la cible : dans les premiers tests de
reachPositionSmooth,Kp_pivotetKp_angularavaient été inversés entre le mode pivot et le mode avance simultanée, et une faute de frappe dans le bridage ternaire (linear_speed > linear_speed) empêchait la saturation de vitesse (problème éliminé définitivement en factorisant le calcul danscommande_proportionnelle()). De plus, sans arrêt prioritaire en début de fonction (if (erreur_distance < precision_linear) { stop(); return; }), le bruit deatan2à très faible distance relançait des pivots sur place. - Échec de la première marche arrière automatique : un premier essai de marche arrière dans
reachPositionSmoothtestait-90 < erreur_angle < 90sur un angle exprimé en radians et rendait la distance négative. Elle a dû être retirée temporairement avant d'être réécrite proprement dansreachPositionSmoothBack()avec un décalage d'angle deM_PIet un test> M_PI / 2. - Dérive et effet « sol glissant » en simulation : contrairement au TB3 physique dont les moteurs brident naturellement la vitesse, une consigne de vitesse maximale trop élevée dans Gazebo faisait patiner et dériver le robot, faussant la convergence de
reachPositionetreachPositionSmooth. Il a donc fallu réduire et calibrer la vitesse maximale dansconfig/params.yaml. - Prolifération d'états FSM :
states.cppdistinguait initialement trois états (REACH_POSITION,REACH_POSITION_SMOOTH,REACH_POSITION_SMOOTH_BACK) ; ils ont été simplifiés en un seul étatREACH_POSITIONaiguillé parparams->move_smoothetparams->move_back.
Version finale#
Mouvements (TABDK/src/mouvements.cpp) et calculs.cpp fournissent un asservissement fluide avant/arrière entièrement paramétrable depuis config/params.yaml. La logique de décision de reachPositionSmoothBack(x, y) se résume ainsi :
%%{init: {"layout": "elk"}}%%
flowchart TB
START(["`reachPositionSmoothBack(x, y)`"])
DIST{"`distance < precision_linear ?`"}
DONE["`stop()<br/>position_atteinte = true`"]
BACK{"`|Δθ| > π/2 ?`"}
FWD_M["`arriere = false<br/>vise θ_cible`"]
BWD_M["`arriere = true<br/>vise θ_cible + π`"]
TRIG{"`|Δθ| > trigger_pivot<br/>ou pivot_en_cours ?`"}
PIV["`pivoterVersCible(Kp_pivot, Δθ)<br/>(relâche si |Δθ| ≤ precision_angular)`"]
MOVE["`move(±v_lin, w_ang)<br/>translation + rotation simultanées`"]
START --> DIST
DIST -->|"oui"| DONE
DIST -->|"non"| BACK
BACK -->|"non"| FWD_M
BACK -->|"oui"| BWD_M
FWD_M --> TRIG
BWD_M --> TRIG
TRIG -->|"oui"| PIV
TRIG -->|"non"| MOVE
style START fill:#dbeafe,stroke:#1d4ed8,stroke-width:1.5px,color:#1e3a8a
style DONE fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
style DIST fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
style BACK fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
style TRIG fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
style PIV fill:#f3e8ff,stroke:#9333ea,stroke-width:1.5px,color:#581c87
style MOVE fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
void reachPositionSmoothBack(double x, double y) {
double erreur_angle_abs = fabs(calculerErreurAngle(x, y, false));
bool arriere = erreur_angle_abs > M_PI / 2;
reachPositionSmooth(x, y, arriere);
}
double calculerErreurAngle(double x, double y, bool arriere) {
double angle_cible = atan2(y - odom->position.y, x - odom->position.x);
if (arriere) angle_cible = cal_angle_offset(angle_cible, M_PI);
return cal_delta_Theta(angle_cible, odom->position.theta);
}
(Voir § 7. Migration architecturale pour l'injection de Params * et Odometry * dans Mouvements sans recopie d'état.)
4. Perception de l'environnement à l'aide du Lidar (Capteur de distance Laser 360 LDS-01 - LDS-02)#
Énoncé#
Créer le nœud detector.cpp abonné aux mesures LiDAR 360° (topic et type de message à identifier) : diviser l'espace autour du robot en 8 régions égales, filtrer les valeurs hors [range_min, range_max], calculer la distance minimale par région, détecter les obstacles sous un seuil et publier une visualisation RViz (visualization_msgs/MarkerArray avec code couleur rouge/vert et labels textuels, lancée via rviz_tb3.launch et config/tb3_lidar.rviz).
Choix fonctionnels#
- Abonnement à
/scan(sensor_msgs/LaserScan) et publication sur/obstacles_markers(visualization_msgs/MarkerArray, repèrebase_scan). - Découpage personnalisé centré sur les axes du robot : décalage des 8 secteurs de 45° de
OFFSET_REGIONS = -22.5°afin que la région 0 couvre exactement l'avant ([-22.5°, +22.5°]) et la région 4 exactement l'arrière ([157.5°, 202.5°]). - Visualisation géométrique dans RViz : 8 rayons gris + labels d'angles limites, un label de distance adaptatif (
cmsous 1 m,mau-delà), et une stripline (Marker::LINE_LIST) traçant pour chaque région un segment perpendiculaire à l'axe central à la distance minimale(rouge si , vert sinon), dont les extrémités sur les bords du secteur sont placées à : - Extension non demandée dans l'énoncé — anti-collision prédictif
prevent_collision(): le nœud écoute aussi/cmd_velet/pause, estime le temps avant impact dans la direction effective du déplacement (avant si, arrière si ) en retranchant le gabarit du TB3 : Si , detectormet le robot en pause via/global_control("pause"), mémorise la distance et le côté (distance_to_last_obstacle,was_obstacle_on_back), puis relance automatiquement ("play") dès que l'obstacle recule — sans jamais annuler une pause demandée manuellement par l'opérateur (robot_pause && !collision_pause).
Première implémentation#
Démarrage avec un découpage simple à partir de 0° ([0°, 45°], [45°, 90°]…), filtrage des valeurs invalides à FLT_MAX, puis ajout des marqueurs RViz (rviz_tb3.launch + config/tb3_lidar.rviz) et d'une première ébauche d'anti-collision basée uniquement sur /scan.
Difficultés rencontrées#
- Confusion radians / degrés au démarrage : la première version initialisait
int SCAN_SAMPLE = 2 * M_PI(tronqué en entier à6!) au lieu de360; corrigé avecSCAN_SAMPLE = 360etangle_deg_increment = scan->angle_increment * 180 / M_PI. - Renommages successifs du topic RViz et fréquence de rafraîchissement : le topic des marqueurs est passé de
/markersà/lidar_visualizationpuis/obstacles_markers(imposant de garderdetector.cppetconfig/tb3_lidar.rvizalignés), et la cadence initiale à 1 Hz rendait l'affichage trop saccadé avant son passage à 5 Hz puis àparams.frequence. - Région frontale à cheval sur 0° : sans le décalage de
-22.5°, un obstacle droit devant à-5°tombait dans la région 7 au lieu de la région 0. Le décalage a imposé deux ajustements :- gérer la traversée du 0° en deux boucles dans
get_minimum()lorsqueindex_fin < index_debut; - corriger un bug subtil d'affichage RViz :
(debut + fin) / 2.0donnait(337.5 + 22.5) / 2 = 180°et plaçait la barre frontale… à l'arrière du robot ! Corrigé par(debut + ANGLE_REGION / 2.0).
- gérer la traversée du 0° en deux boucles dans
- Mise au point de l'anti-collision (avant/arrière et pauses) :
- La première version appelait
playà chaque scan sans obstacle, annulant toute pause manuelle de l'opérateur ; corrigé en écoutant/pauseet en distinguantrobot_pausedecollision_pause. - En marche arrière, un bug dans
was_obstacle_on_back(jamais passé àtruelors d'une détection arrière et remis àfalsetrop tôt) créait des saccades entre pause et reprise. - Le LiDAR mesurant depuis le centre du robot, il a fallu soustraire les 12 cm de carrosserie (
debut_collision_face/debut_collision_dos) et passer les seuils (delay_collision = 500 ms) dansparams.yaml.
- La première version appelait
Version finale#
TABDK/src/nodes/detector.cpp réalise la détection sur 8 régions centrées, publie les marqueurs complets sur /obstacles_markers (visualisés via rviz_tb3.launch et tb3_lidar.rviz) et protège le robot en marche avant comme en marche arrière via le service /global_control :
void prevent_collision() {
if (robot_pause && !collision_pause) return; // respecte une pause opérateur
if (robot_pause && collision_pause) { // reprise auto dès que la voie se libère
float d = was_obstacle_on_back ? min_distances[REGION_DOS] : min_distances[REGION_FACE];
if (d > distance_to_last_obstacle) {
collision_pause = false;
callGlobalControl("play");
}
return;
}
if (linear_speed > 0.001 || linear_speed < -0.001) {
bool back = linear_speed < 0;
float d = back ? min_distances[REGION_DOS] : min_distances[REGION_FACE];
float off = back ? debut_collision_dos : debut_collision_face;
int t_ms = fabs((d - off) / linear_speed * 1000);
if (t_ms < min_delay_before_collision) {
distance_to_last_obstacle = d;
was_obstacle_on_back = back;
collision_pause = true;
callGlobalControl("pause");
}
}
}
Le diagramme ci-dessous résume l'ensemble des échanges finaux du nœud detector.cpp (paramètres YAML, LiDAR /scan, vitesse /cmd_vel, état /pause, appel au service /global_control et marqueurs RViz /obstacles_markers) :
%%{init: {"layout": "elk"}}%%
flowchart TB
C_PARAMS[("`config/params.yaml`")]
M_PARAMS(["`src/parametres.cpp`"])
S_CTRL{{"`srv/global_control.srv`"}}
LIDAR["`Robot / Gazebo (LiDAR)`"]
subgraph SG_DET["Nœud detector"]
NODE(["`**nodes/detector.cpp**`"])
end
subgraph SG_CTRL["Nœud controleur"]
N_MVT(["`src/mouvements.cpp`"])
N_CTRL(["`src/controleur.cpp`"])
N_SSRV(["`src/serveur_services.cpp`"])
end
RVIZ[("`RViz · config/tb3_lidar.rviz`")]
C_PARAMS -.->|"collision & frequence"| M_PARAMS
M_PARAMS -.->|"#include"| NODE
S_CTRL -.->|"header ROS"| NODE
LIDAR -->|"topic /scan (LaserScan)"| NODE
N_MVT -->|"topic /cmd_vel (Twist)"| NODE
N_CTRL -->|"topic /pause (Bool)"| NODE
NODE -->|"service /global_control<br/>(pause / play)"| N_SSRV
NODE -->|"topic /obstacles_markers<br/>(MarkerArray)"| RVIZ
classDef cpp fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef autre fill:#f3e8ff,stroke:#9333ea,stroke-width:1.5px,color:#581c87
classDef ext fill:#ffedd5,stroke:#ea580c,stroke-width:1.5px,color:#7c2d12
class M_PARAMS,N_MVT,N_CTRL,N_SSRV cpp
class C_PARAMS,S_CTRL,RVIZ autre
class LIDAR ext
style SG_DET fill:#dbeafe,stroke:#1d4ed8,stroke-width:2px,color:#1e3a8a
style NODE fill:#1d4ed8,stroke:#1e40af,stroke-width:2px,color:#ffffff
style SG_CTRL fill:#f3f4f6,stroke:#9ca3af,stroke-width:1.5px,color:#374151
5. Services, actions et gestion de trajectoires#
5.1 Configuration à la volée du comportement du robot — Service#
Énoncé#
Définir un service ROS personnalisé (.srv, génération dans CMakeLists.txt, compilation cm) permettant de modifier à la volée et de manière synchrone le comportement du robot dans le contrôleur, puis le tester avec rosservice call.
Choix fonctionnels#
- Écart assumé par rapport à l'énoncé : plutôt qu'un unique service
/set_behaviormêlant mode et commandes ponctuelles, séparation en deux services spécialisés afin quedetector.cpppuisse mettre le robot en pause sans connaître ni modifier le mode courant :
string mode # "auto" ou "manual"
---
bool success
string mode_courant
string command # "play", "pause" ou "reset"
---
bool success
string mode_courant
- Topics latched (
/mode,/pause) : publiés avecadvertise(..., 1, true)parcontroleur.cppafin que tout nœud démarrant après le contrôleur reçoive immédiatement le dernier état sans avoir besoin d'un service de lecture.
Première implémentation#
Déclaration des deux .srv dans CMakeLists.txt (add_service_files, generate_messages), serveurs intégrés directement dans controleur.cpp et appelés par un nœud keyboard.cpp, avec validation par rosservice call puis sur le robot réel.
Difficultés rencontrées#
- Confusion entre mode et pause : au départ,
PAUSEétait géré comme un mode danscontroleur.cpp, ce qui compliquait la reprise du mode précédent ; la pause a été découplée dans un drapeau indépendantpause_activepiloté exclusivement par/global_control. - Désynchronisation multi-clients : comme
client_services.cppbasculemanual ↔ autoetpause ↔ play, son état local devenait faux dès qu'un autre nœud (detectorou un terminal) appelait le service ; résolu par l'abonnement aux topics latched/mode,/pauseet/reset. - Découplage architecture : extraction des serveurs dans
serveur_services.cpp, séparation du client dansclient_services.cpp, et passage des modes enstd::stringpour supprimer les conversionsenum ↔ string.
Version finale#
- Côté serveur :
ServeurServices(TABDK/src/serveur_services.cpp) au sein du nœudcontroleur(voir § 7. Migration architecturale pour l'enregistrement des callbacks membres et l'injection deModesetServeurAction). - Côté client :
TABDK/src/nodes/client_services.cpp(touchesm,p,r) etTABDK/src/nodes/detector.cpp(arrêt/reprise anti-collision).
Le schéma ci-dessous illustre les dépendances de compilation (parametres.cpp, modes.cpp, headers générés depuis set_mode.srv et global_control.srv) et les échanges ROS du nœud client_services.cpp :
%%{init: {"layout": "elk"}}%%
flowchart TB
C_PARAMS[("`config/params.yaml`")]
M_PARAMS(["`src/parametres.cpp`"])
M_MODES(["`src/modes.cpp`"])
S_MODE{{"`srv/set_mode.srv`"}}
S_CTRL{{"`srv/global_control.srv`"}}
subgraph SG_KEY["Nœud keyboard_input"]
N_KEY(["`nodes/keyboard_input.cpp`"])
end
subgraph SG_CSRV["Nœud client_services"]
NODE(["`**nodes/client_services.cpp**`"])
end
subgraph SG_CTRL["Nœud controleur"]
N_CTRL(["`src/controleur.cpp`"])
N_SSRV(["`src/serveur_services.cpp`"])
end
C_PARAMS -.->|"frequence"| M_PARAMS
M_PARAMS -.->|"#include"| NODE
M_MODES -.->|"#include<br/>(AUTO / MANUAL)"| NODE
S_MODE -.->|"header ROS"| NODE
S_CTRL -.->|"header ROS"| NODE
N_KEY -->|"topic /keyboard_input"| NODE
N_CTRL -->|"topics /mode, /pause"| NODE
N_SSRV -->|"topic /reset"| NODE
NODE -->|"services /set_mode<br/>& /global_control"| N_SSRV
classDef cpp fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef autre fill:#f3e8ff,stroke:#9333ea,stroke-width:1.5px,color:#581c87
class M_PARAMS,M_MODES,N_KEY,N_CTRL,N_SSRV cpp
class C_PARAMS,S_MODE,S_CTRL autre
style SG_CSRV fill:#dbeafe,stroke:#1d4ed8,stroke-width:2px,color:#1e3a8a
style NODE fill:#1d4ed8,stroke:#1e40af,stroke-width:2px,color:#ffffff
style SG_KEY fill:#f3f4f6,stroke:#9ca3af,stroke-width:1.5px,color:#374151
style SG_CTRL fill:#f3f4f6,stroke:#9ca3af,stroke-width:1.5px,color:#374151
5.2 Navigation — Serveur d'action#
Énoncé#
Créer une action ROS (action/Move.action, compilation en deux temps dans CMakeLists.txt) pour gérer de façon asynchrone les déplacements longs du robot, puis intégrer le serveur d'action dans le contrôleur avec feedbacks réguliers (position, vitesse, distance restante…) et résultat final (distance totale parcourue, temps écoulé).
Choix fonctionnels#
- Définition dans
TABDK/action/Move.actiond'une messagerie adaptée à la simulation et au TB3 réel (le champ batterie, indisponible en simulation, est remplacé par l'étatmodeetpause) :
float64 position_x
float64 position_y
---
bool atteint
float64 temps_total # ms, hors temps de pause
float64 distance_parcourue # m
geometry_msgs/Pose2D position
---
geometry_msgs/Pose2D position
geometry_msgs/Twist vitesse
float64 distance_restante # m
float64 temps_ecoule # ms, hors temps de pause
string mode # "manual" ou "auto"
bool pause
- Serveur non-bloquant intégré à la boucle principale : plutôt qu'une boucle bloquante dans un callback d'exécution,
SimpleActionServer<MoveAction>enregistreexecute()(qui accepte le goal et fixe la cible dansMouvements) etpreempter(), tandis queServeurAction::step()est appelé à chaque tour duwhile (ok())decontroleur.cpp. - Temps de trajet hors pause :
ticks_ecoulesn'est incrémenté dansstep()que si!modes->paused(), puis converti en ms parparams->ticksToMs(). - Déport de l'affichage des logs de suivi et de bilan vers
client_action.cpppour garder la sortie du contrôleur lisible.
Première implémentation#
Validation d'un test unitaire client/serveur isolé après la compilation en deux temps (cm), puis adaptation de Move.action (ajout vitesse, mode, pause) et intégration dans le contrôleur pour piloter Mouvements sur des waypoints envoyés par client_action.
Difficultés rencontrées#
- Feedbacks reçus en retard : lors d'un reset ou d'une fin de goal, des feedbacks tardifs continuaient d'être traités côté client ; corrigé en ajoutant
goal_termine,stopTrackingGoal()etROS_INFO_THROTTLE(1.0). - Temps de trajet faussé par les pauses : mesurer le temps avec
ros::Time::now()comptabilisait les périodes de pause (opérateur ou obstacle) ; résolu en comptant uniquement les ticks de boucle où!modes->paused(), convertis en millisecondes viaticksToMs(). - Rejet de goals après reset Gazebo : après
/gazebo/reset_simulation, l'horloge simulée revient à0, maisSimpleActionServerconserve les horodatages des goals précédents et refuse les nouveaux. Résolu parServeurAction::redemarrer(), qui détruit et recrée proprement le serveur lors d'un reset global (delete server; demarrer();). - Association de
ServeurActionaux autres classes :SimpleActionServern'ayant pas de constructeur par défaut, son intégration dans l'architecture objet a imposé une allocation dynamique avec destructeur, la liaison des callbacks membres viaboost::bindet l'injection des 5 autres classes du contrôleur (détails techniques en § 7.4 Cas critique : intégration deServeurAction). - Cible résiduelle après changement de mode :
states->target_activeest remis àfalsedès qu'un goal est atteint afin qu'un changement de mode ne relance pas une ancienne cible.
Version finale#
ServeurAction (TABDK/src/serveur_action.cpp) est cadencé par controleur.cpp (step()) et dialogue sur /moving avec TABDK/src/nodes/client_action.cpp, avec gestion complète de la préemption, de la pause et du reset (le schéma complet des interactions de client_action.cpp avec le serveur d'action et /robot_path est présenté en § 5.3).
5.3 Gestion des trajectoires — Path#
Énoncé#
Faire de client_action.cpp un gestionnaire de mission abonné à un topic nav_msgs/Path : extraire les coordonnées 2D (x, y) de poses[].pose.position dans std::vector<Pose2D> trajectoire, puis envoyer les waypoints un à un au serveur d'action (trajectoire[0] puis erase(begin()) après réussite) jusqu'à vider la file.
Choix fonctionnels#
- Unification dans
client_action.cppd'une unique filestd::vector<Pose2D> trajectoirealimentée selon le mode actif :- en mode
manual: construction interactive au clavier (flèches pour déplacerwaypoint_virtuelpar pas dewaypoint_step,wpour empiler,xpour vider) ; - en mode
auto: réception d'unnav_msgs/Pathsur/robot_path(nom aligné surpath_generatorpour un branchement direct sans nœud intermédiaire), qui annule le goal en cours et remplace la file.
- en mode
- Mécanismes techniques de robustesse (hors énoncé) :
- Annulation différée :
SimpleActionClient("moving", false)partage le fil unique despinOnce()avec les callbacks clavier,/resetet/robot_path. Les callbacks ne font donc jamaiscancelGoal()directement : ils lèventannulation_demandee, consommé de manière sûre dans la boucle principale partraiterAnnulation(). - Verrou
sequence_blocked: si un waypoint échoue ou est préempté (state != SUCCEEDED), la file n'est pas dépilée aveuglément ; l'envoi est suspendu jusqu'à un/resetou une nouvelle trajectoire.
- Annulation différée :
- Filtrage strict par
/mode: les touches clavier sont ignorées en modeauto, et les trajectoires/robot_pathsont ignorées en modemanual.
Première implémentation#
Abonnement initial au topic /trajectoire (nav_msgs/Path), extraction des (x, y) dans trajectoire, envoi du premier élément (trajectoire[0]) et suppression à la validation (SUCCEEDED), avant renommage du topic en /robot_path lors du raccordement à AStar-ROS.
Difficultés rencontrées#
- Inversion du signe de
yau clavier : dans la première version des waypoints manuels, les flèches gauche et droite incrémentaientyà l'envers par rapport au repère direct de ROS (+xdevant,+yà gauche). - Annulation asynchrone depuis les callbacks : appeler
cancelGoal()directement dansresetCallbackourobotPathCallbackpouvait créer des conflits avec la bouclespinOnce(); résolu par le coupleannulation_demandee/traiterAnnulation(). - Comportement en cas d'échec de goal : l'ajout de
sequence_blockedévite d'enchaîner sur un waypoint suivant après une annulation ou un échec.
Version finale#
TABDK/src/nodes/client_action.cpp orchestre l'ensemble des missions multi-waypoints (clavier en manual, /robot_path en auto) vers l'action /moving, avec attente non-bloquante du serveur (attendreServeur()) :
if (mode_received && (mode_manual || mode_auto) && !goal_active &&
!sequence_blocked && !trajectoire.empty()) {
MoveGoal goal;
goal.position_x = trajectoire[0].x;
goal.position_y = trajectoire[0].y;
goal_termine = false;
goal_active = true;
client.sendGoal(goal, &doneCb, &activeCb, &feedbackCallback);
}
if (goal_active && client.getState().isDone()) {
goal_active = false;
if (client.getState() == SimpleClientGoalState::SUCCEEDED)
trajectoire.erase(trajectoire.begin());
else
sequence_blocked = true; // suspend la séquence en cas d'échec
}
Le diagramme ci-dessous présente la version finale complète des interactions de client_action.cpp (paramètres, inclusions parametres.cpp/calculs.cpp, header Move.action, entrées clavier et /robot_path, synchronisation /mode//reset, et dialogue bidirectionnel /moving avec serveur_action.cpp) :
%%{init: {"layout": "elk"}}%%
flowchart TB
C_PARAMS[("`config/params.yaml`")]
M_PARAMS(["`src/parametres.cpp`"])
M_CALC(["`src/calculs.cpp`"])
A_MOVE{{"`action/Move.action`"}}
subgraph SG_KEY["Nœud keyboard_input"]
N_KEY(["`nodes/keyboard_input.cpp`"])
end
subgraph SG_PG["Nœud path_generator"]
N_PG(["`AStar-ROS/src/path_generator.cpp`"])
end
subgraph SG_CACT["Nœud client_action"]
NODE(["`**nodes/client_action.cpp**`"])
end
subgraph SG_CTRL["Nœud controleur"]
N_CTRL(["`src/controleur.cpp`"])
N_SSRV(["`src/serveur_services.cpp`"])
N_SACT(["`src/serveur_action.cpp`"])
end
C_PARAMS -.->|"frequence"| M_PARAMS
C_PARAMS -.->|"waypoint_step"| NODE
M_PARAMS -.->|"#include"| NODE
M_CALC -.->|"#include<br/>(rad_to_deg)"| NODE
A_MOVE -.->|"header ROS"| NODE
N_KEY -->|"topic /keyboard_input"| NODE
N_PG -->|"topic /robot_path (Path)"| NODE
N_CTRL -->|"topic /mode"| NODE
N_SSRV -->|"topic /reset"| NODE
NODE <-->|"action /moving<br/>(goal / feedback / result)"| N_SACT
classDef cpp fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef autre fill:#f3e8ff,stroke:#9333ea,stroke-width:1.5px,color:#581c87
class M_PARAMS,M_CALC,N_KEY,N_PG,N_CTRL,N_SSRV,N_SACT cpp
class C_PARAMS,A_MOVE autre
style SG_CACT fill:#dbeafe,stroke:#1d4ed8,stroke-width:2px,color:#1e3a8a
style NODE fill:#1d4ed8,stroke:#1e40af,stroke-width:2px,color:#ffffff
style SG_KEY fill:#f3f4f6,stroke:#9ca3af,stroke-width:1.5px,color:#374151
style SG_PG fill:#f3f4f6,stroke:#9ca3af,stroke-width:1.5px,color:#374151
style SG_CTRL fill:#f3f4f6,stroke:#9ca3af,stroke-width:1.5px,color:#374151
6. Évitement d'obstacle et planification de trajectoire — SLAM#
6.1 SLAM (Cartographie et Localisation simultanées)#
Énoncé#
Cartographier l'environnement (maison Gazebo en simulation ou labyrinthe de la salle 4105 en réel) en lançant Gmapping (turtlebot3_slam.launch) et la téléopération (turtlebot3_teleop_key.launch) à faible vitesse, puis enregistrer la grille d'occupation 2D (map.pgm + map.yaml) via map_server map_saver.
Choix fonctionnels#
- Automatisation des tests et contournement de TheConstructSim (
tabdk.sh) : afin de simplifier les lancements répétitifs en simulation comme sur le robot réel, nous avons écrit le script utilitairetabdk.sh(placé à la racine du projet). Il injecte sans doublon dans~/.bash_aliasesles raccourcis de compilation et de lancement (cm,slam,teleop,robot_vide,robot_maison,astar,tabdk,tabdk_rviz), source le workspace catkin et résout un blocage propre à la plateforme de simulation TheConstructSim : les paquetsros-noetic-turtlebot3-navigationetros-noetic-turtlebot3-slamn'y étaient pas préinstallés (et devaient être réinstallés à chaque session), maisaptétait bloqué faute de clé GPG ROS valide. Le script débloqueaptvia le serveur de clés puis installe automatiquement les deux paquets :
add_alias 'alias cm="cd ~/catkin_ws && catkin_make && source devel/setup.bash && cd"'
add_alias 'alias slam="roslaunch turtlebot3_slam turtlebot3_slam.launch"'
add_alias 'alias teleop="roslaunch turtlebot3_teleop turtlebot3_teleop_key.launch"'
add_alias 'alias astar="roslaunch path_generator run.launch"'
add_alias 'alias tabdk="roslaunch TABDK run.launch"'
add_alias 'alias tabdk_rviz="roslaunch TABDK rviz_tb3.launch"'
source ~/catkin_ws/devel/setup.bash 2>/dev/null
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-key F42ED6FBAB17C654
sudo apt update
sudo apt install -y ros-noetic-turtlebot3-navigation ros-noetic-turtlebot3-slam
- Archivage des cartes directement dans
AStar-ROS/map/pour basculer simplement d'un environnement à l'autre dansAStar-ROS/launch/run.launch, complété par un outillage de synchronisation locale → SSH (sync_robot.ps1) pour déployer rapidement sur le TB3 réel.
Première implémentation#
Nous avons consacré environ 30 minutes à cartographier soigneusement un environnement personnalisé complet en simulation (map_simu_tabdk, en complément de map_tb3_house), puis nous avons réalisé la cartographie SLAM du labyrinthe physique de la salle 4105 (map_4105), suivie de la sauvegarde par map_saver.
[Capture d'écran à insérer : carte SLAM personnalisée réalisée en simulation (
map_simu_tabdk) et carte du labyrinthe physique de la salle 4105 (map_4105_00)]
Difficultés rencontrées#
- Environnement TheConstructSim bridé : impossibilité initiale d'installer
turtlebot3-slametturtlebot3-navigationviaaptà cause de la clé GPG manquante, et réinitialisation de l'environnement entre deux sessions — résolu durablement partabdk.sh. - Déformation des murs lors de rotations rapides : la téléopération trop vive induisait de la dérive odométrique et dédoublait les parois ; des déplacements lents et réguliers (environ 30 min pour la carte personnalisée en simulation) ont été indispensables pour obtenir des grilles d'occupation nettes.
- Décalage entre le repère de la carte SLAM et la position initiale du robot : si le robot n'est pas réinitialisé exactement sur son point de départ SLAM, son repère
/odomne coïncide plus avec l'origine de la carte dans RViz (point critique détaillé en § 6.2).
Version finale#
Un ensemble de cartes validées (simulation et réel) est disponible dans AStar-ROS/map/, avec map_4105_00.pgm/.yaml réalisée à partir d'un point de départ physique marqué au sol (origine (0, 0)) et sélectionnée par défaut dans AStar-ROS/launch/run.launch.
6.2 Navigation à base de SLAM#
Énoncé#
Importer et compiler AStar-ROS (roslaunch path_generator run.launch), calibrer la pose initiale dans RViz (2D Pose Estimate), spécifier la destination (2D Nav Goal) pour diffuser le chemin /robot_path (nav_msgs/Path) et le faire suivre par le contrôleur, puis améliorer la navigation pour obtenir :
- une trajectoire plus lisse ;
- la gestion d'éventuels obstacles dynamiques.
Choix fonctionnels#
- Branchement direct entre
path_generator(AStar-ROS) etclient_action(TABDK) sur/robot_path, avec une vue RViz dédiée (AStar-ROS/rviz/turtlebot3_navigation_tabdk.rviz). - Marge de sécurité statique (
ecart_obstacle) : ajout d'un paramètre YAML dansAStar-ROS/config/params.yaml(ecart_obstacle: 4cases, soit 20 cm pour une résolution de 5 cm). DansisCollision_in_OCG(), toute celluleest déclarée en collision si un carré autour d'elle touche une cellule occupée, inconnue ( ocg.data != 0) ou hors carte. - Refonte algorithmique d'A* (
a_star.cpp) : remplacement de l'implémentation d'origine (listes linéaires en+ timeout arbitraire d'1 s) par une std::priority_queueet deux tableaux platscostsetparentsindexés pary * width + x(complexité, zéro fuite mémoire, exploration complète et diagnostics explicites si départ/but bloqué). - Algorithme original de lissage optimal (
path_simplifier.cpp) : l'énoncé demandant une trajectoire plus lisse sans imposer de méthode, nous avons conçu un module dédié combinant deux briques :hasLineOfSight(start, end): supercover discret exact sur grille (arithmétique entière(1 + 2*ix)*nyvs(1 + 2*iy)*nx, sans imprécision flottante) vérifiant chaque cellule traversée — et les deux cellules latérales lorsqu'un segment passe exactement par un coin ;simplifyPath(path): parcours en largeur (BFS) sur les indices du chemin A*, reliant un pointfromà tout pointto > fromvisible en ligne droite. Le BFS garantit mathématiquement le nombre minimal de segments droits (diagonales incluses) tout en respectant partout la margeecart_obstacle.
- Sécurité face aux obstacles dynamiques : le planificateur A* ne connaissant que la carte statique, la protection temps réel est assurée par
detector.cpp(pause automatique avant impact et reprise dès libération du passage).
Première implémentation#
Import du package AStar-ROS d'origine (map_server, amcl, rviz, path_generator) et connexion de /robot_path à client_action.cpp.
Difficultés rencontrées#
- Trajectoire en escalier et collisions avec les murs : le A* fourni générait un waypoint tous les 5 cm en 4 directions et rasait les parois. Le robot s'arrêtait sans cesse et accrochait les coins. L'ajout combiné d'
ecart_obstacle, de la réécriture d'a_star.cpp(sur la brancheastar_amélioré) et depath_simplifier.cppa divisé drastiquement le nombre de waypoints et supprimé les frottements. - Décalage de position entre Gazebo et RViz en simulation : en simulation, le robot ne se trouvait pas à la même position dans son monde Gazebo que sur la carte affichée par RViz, obligeant à utiliser
2D Pose Estimateà chaque lancement pour recalibrer sa position initiale. Nous avons résolu ce problème en adaptant les coordonnées de spawn / pose initiale directement dans le fichier XML de lancement (initial_pose_x,initial_pose_y,initial_pose_adansAStar-ROS/launch/run.launch) et l'origine de la carte. - Dérive systématique sur le terrain réel (repère LiDAR/carte vs repère odométrie) : sur le labyrinthe physique, l'utilisation de
2D Pose Estimateéchouait systématiquement : le robot se décalait au fur et à mesure qu'il suivait la trajectoire issue du2D Nav Goal. Après recherche (et une tentative infructueuse d'ajouter untf::TransformListenermap → odomdansodometry.cpp, ensuite annulée parrevert), nous avons identifié que le LiDAR / RViz exprimaient la carte dans un repère différent de celui de/odomutilisé par notre contrôleur. Sur conseil de l'enseignant, la solution fiable a consisté à :- matérialiser un marquage au sol à l'emplacement exact de départ du SLAM lors de la cartographie (
map_4105_00) ; - poser le robot sur ce repère et le réinitialiser (reset complet incluant l'odométrie) pour faire coïncider exactement son repère
/odomavec l'origine(0, 0)de la carte dans RViz ; - ajuster empiriquement la position physique du robot sur le marquage — sans utiliser
2D Pose Estimate— jusqu'à obtenir un alignement parfait après reset, puis ramener les coordonnées initiales du fichier.launchXML à(0, 0, 0).
- matérialiser un marquage au sol à l'emplacement exact de départ du SLAM lors de la cartographie (
- Obstacles imprévus hors carte SLAM : un obstacle dynamique placé dans le labyrinthe reste invisible pour
path_generator; le couplage avecdetector.cpp(via/global_control) évite toute collision avant ou arrière.
Version finale#
Le pipeline complet de navigation autonome relie AStar-ROS amélioré et TABDK de la façon suivante :
%%{init: {"layout": "elk"}}%%
flowchart TB
RVIZ["`RViz : 2D Nav Goal`"]
MAP[("`map_server<br/>map_4105_00`")]
ASTAR(["`a_star.cpp<br/>A* + marge ecart_obstacle`"])
SIMP(["`path_simplifier.cpp<br/>BFS + hasLineOfSight`"])
CACT(["`client_action.cpp<br/>File de waypoints`"])
CTRL(["`controleur<br/>reachPositionSmoothBack`"])
DET(["`detector.cpp<br/>LiDAR anti-collision`"])
RVIZ -->|"/move_base_simple/goal"| ASTAR
MAP -->|"/map"| ASTAR
ASTAR -->|"chemin brut (grille)"| SIMP
SIMP -->|"/robot_path (Path simplifié)"| CACT
CACT <-->|"action /moving"| CTRL
DET -->|"service /global_control<br/>(pause / play)"| CTRL
style RVIZ fill:#f3e8ff,stroke:#9333ea,stroke-width:1.5px,color:#581c87
style MAP fill:#f3e8ff,stroke:#9333ea,stroke-width:1.5px,color:#581c87
style ASTAR fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
style SIMP fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
style CACT fill:#dbeafe,stroke:#1d4ed8,stroke-width:1.5px,color:#1e3a8a
style CTRL fill:#1d4ed8,stroke:#1e40af,stroke-width:2px,color:#ffffff
style DET fill:#ffedd5,stroke:#ea580c,stroke-width:1.5px,color:#7c2d12
// BFS sur les indices du chemin A* : trouve le nombre minimal de segments en ligne de vue
for (size_t head = 0; head < queue.size() && parent[count - 1] == count; ++head) {
size_t from = queue[head];
for (size_t to = count - 1; to > from; --to) {
if (parent[to] == count && hasLineOfSight(path[from], path[to], generator)) {
parent[to] = from;
queue.push_back(to);
if (to == count - 1) break;
}
}
}
Le robot planifie son itinéraire depuis RViz (2D Nav Goal), suit une trajectoire simplifiée et fluide sans raser les murs, et s'arrête automatiquement devant tout obstacle dynamique.
7. Migration architecturale : du monolithe controleur.cpp au système de classes#
7.1 Motivation et étapes de la migration#
Au démarrage du projet (exercices 2.3 à 3.3), tout le code était rassemblé dans un unique controleur.cpp qui a dépassé 700 lignes (variables globales, callbacks ROS, conversions mathématiques, odométrie, clavier, modes, FSM et asservissements). Dès l'ajout des services puis du serveur d'action, cette structure monolithique est devenue difficile à faire évoluer et à déboguer.
La migration vers l'architecture objet actuelle s'est effectuée en trois étapes successives :
- Extraction des briques bas niveau : création de
calculs.cpp(fonctions pures),parametres.cpp(Params),odometry.cpp(Odometry),mouvements.cpp(Mouvements) et d'un module temporaireclavier.cpp. - Externalisation des couches ROS : extraction des serveurs dans
serveur_services.cpp(ServeurServices) etserveur_action.cpp(ServeurAction), tandis que la logique clavier sortait complètement du contrôleur versclient_services.cppetclient_action.cpp. - Séparation de la logique métier : éclatement du reste de
controleur.cppenModes(modes.cpp, mode actif et pause) etStates(states.cpp, FSM des déplacements).controleur.cppne fait plus que 90 lignes : instanciation, assemblage et boucle principale.
7.2 Organisation de la compilation (#include "*.cpp" et namespaces)#
Plutôt que de multiplier les paires .h / .cpp à déclarer dans CMakeLists.txt, chaque classe réside dans un seul fichier .cpp protégé par des gardes d'inclusion (#ifndef ..._CPP / #define ..._CPP / #endif), inclus par controleur.cpp dans l'ordre strict de ses dépendances (des utilitaires jusqu'aux serveurs) :
#include "calculs.cpp"
#include "parametres.cpp"
#include "odometry.cpp"
#include "mouvements.cpp"
#include "states.cpp"
#include "modes.cpp"
#include "serveur_action.cpp"
#include "serveur_services.cpp"
Ce choix léger permet aussi aux nœuds satellites (nodes/*.cpp) de réutiliser directement parametres.cpp, calculs.cpp ou modes.cpp sans configurer de bibliothèque CMake dédiée. En contrepartie, toutes les classes d'un exécutable partagent la même unité de compilation : il a fallu nettoyer les using namespace, remplacer notre ancienne struct Pose2D maison par geometry_msgs::Pose2D pour supprimer un conflit de nom lors de l'ajout de Move.action, et importer explicitement chaque symbole (using std_msgs::Bool;, using geometry_msgs::Pose2D;).
7.3 Patron init() différé et association des classes par pointeurs#
En ROS C++, on ne peut créer de Publisher, Subscriber, ServiceServer ou SimpleActionServer qu'après ros::init() et la création du ros::NodeHandle. Plutôt que de tout passer par des constructeurs complexes, nous avons adopté deux règles uniformes :
- Initialisation différée via
init(...): chaque classe dispose d'un constructeur par défaut neutre et d'une méthodeinit(...)appelée explicitement dansmain()dans l'ordre topologique des dépendances (Params::load→Odometry→Mouvements→States→Modes→ServeurAction→ServeurServices). - Propriété unique dans
main()+ injection par adresse : toutes les instances vivent sur la pile demain()(durée de vie garantie sur tout le programme). Les classes qui collaborent reçoivent leurs dépendances par référence ou pointeur dansinit(...)et conservent uniquement leur adresse (Params *,Odometry *,Mouvements *,Modes *,States *). Aucune donnée n'est dupliquée : une mise à jour deodometry.positionou demouvements.position_atteinteest immédiatement visible parStates,ModesetServeurAction.
7.4 Cas critique : intégration de ServeurAction#
Le passage en classes a posé des contraintes spécifiques dès qu'une classe devait enregistrer des callbacks ROS — et tout particulièrement pour ServeurAction (TABDK/src/serveur_action.cpp), qui concentre le plus de dépendances (5 autres classes + NodeHandle) :
- Callbacks sur méthodes membres : une fonction globale C ne suffit plus ; il faut lier le pointeur d'instance
thisà chaque enregistrement ROS :nh.subscribe("/odom", 100, &Odometry::odomCallback, this)dansOdometry;nh.advertiseService("/set_mode", &ServeurServices::setModeCallback, this)dansServeurServices;server->registerGoalCallback(boost::bind(&ServeurAction::execute, this))etregisterPreemptCallback(boost::bind(&ServeurAction::preempter, this))dansServeurAction.
- Absence de constructeur par défaut sur
SimpleActionServer: contrairement à unPublisherouSubscriber,actionlib::SimpleActionServer<MoveAction>exige unNodeHandledès sa construction et ne peut donc pas être membre par valeur si l'on utilise le patroninit(). Nous avons dû le stocker en pointeur (Server *server = nullptr), l'allouer dynamiquement dansdemarrer()et libérer la mémoire dans le destructeur~ServeurAction(). - Bénéfice inattendu pour le reset Gazebo : cette allocation dynamique via
demarrer()a permis d'ajouter proprementredemarrer()(delete server; demarrer();), appelé parServeurServices::resetRobot()après/gazebo/reset_simulationpour purger les anciens horodatages conservés paractionlib.
void demarrer() {
server = new Server(*nh, "moving", false);
server->registerGoalCallback(boost::bind(&ServeurAction::execute, this));
server->registerPreemptCallback(boost::bind(&ServeurAction::preempter, this));
server->start();
}
void redemarrer() { // appelé par ServeurServices::resetRobot() après reset /clock
delete server;
server = nullptr;
demarrer();
}
~ServeurAction() {
if (server) delete server;
}