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 :

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 :

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.cpp monolithique à cette architecture orientée objet (pattern init(), injection de dépendances, callbacks membres et contraintes spécifiques de ServeurAction) 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 :

  1. Identifier le topic concerné, l'en-tête .h, son namespace et le type de message associé.
  2. Réaliser avancer(double vitesse) et arreter() (publication effectuée dans la boucle principale).
  3. Arrêter proprement le robot lors d'un CTRL+C dans sigintHandler.
  4. Enchaîner périodiquement avancer → arrêter → reculer avec des durées multiples de la période du contrôleur.

Choix fonctionnels#

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#

Version finale#


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#

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#

Version finale#

TABDK/src/parametres.cpp
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#

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#

Version finale#

%%{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#

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#

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#
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#
Version finale#
TABDK/src/serveur_services.cpp
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 :

  1. Parcours de distance sur un axe (x0 → x1, tolérance ±0.02 m) avec correcteur proportionnel/PID.
  2. Asservissement angulaire vers theta (tolérance ±0.05 rad) en gérant l'intervalle [-π, +π] avec cal_delta_Theta.
  3. Cinématique inverse pour rallier une cible cartésienne (x, y) à partir de la distance et de atan2.
  4. Bonus (simulation) : réception interactive d'une cible via 2D Nav Goal dans RViz (/move_base_simple/goal).
Choix fonctionnels#
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#
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
TABDK/src/mouvements.cpp
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#

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#

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 :

TABDK/src/nodes/detector.cpp
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#

TABDK/srv/set_mode.srv
string mode          # "auto" ou "manual"
---
bool success
string mode_courant
TABDK/srv/global_control.srv
string command       # "play", "pause" ou "reset"
---
bool success
string mode_courant

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#

Version finale#

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#

TABDK/action/Move.action
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

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#

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#

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#

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()) :

TABDK/src/nodes/client_action.cpp
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#

tabdk.sh
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

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#

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 :

Choix fonctionnels#

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#

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
AStar-ROS/src/path_simplifier.cpp
// 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 :

  1. 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 temporaire clavier.cpp.
  2. Externalisation des couches ROS : extraction des serveurs dans serveur_services.cpp (ServeurServices) et serveur_action.cpp (ServeurAction), tandis que la logique clavier sortait complètement du contrôleur vers client_services.cpp et client_action.cpp.
  3. Séparation de la logique métier : éclatement du reste de controleur.cpp en Modes (modes.cpp, mode actif et pause) et States (states.cpp, FSM des déplacements). controleur.cpp ne 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) :

TABDK/src/controleur.cpp
#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 :

  1. Initialisation différée via init(...) : chaque classe dispose d'un constructeur par défaut neutre et d'une méthode init(...) appelée explicitement dans main() dans l'ordre topologique des dépendances (Params::load → Odometry → Mouvements → States → Modes → ServeurAction → ServeurServices).
  2. Propriété unique dans main() + injection par adresse : toutes les instances vivent sur la pile de main() (durée de vie garantie sur tout le programme). Les classes qui collaborent reçoivent leurs dépendances par référence ou pointeur dans init(...) et conservent uniquement leur adresse (Params *, Odometry *, Mouvements *, Modes *, States *). Aucune donnée n'est dupliquée : une mise à jour de odometry.position ou de mouvements.position_atteinte est immédiatement visible par States, Modes et ServeurAction.

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) :

TABDK/src/serveur_action.cpp
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;
}