[ ](mailto:melia.tafat@etu.sorbonne-universite.fr)
- Projet effectué du 12 février 2026 au 28mai 2026.
- POLYTECH Sorbonne ROB 3 2025-2026.
#### **Contexte et objectifs :**
Dans le cadre de notre projet de Robotique de troisième année, nous avons du concevoir un robot capable de saisir un objet appelé totem et le déplacer de manière autonome au sein d'une arène de jeu.
L'enjeu majeur de ce projet est l'intégration de plusieurs domaines de l'ingénierie:
**Conception Mécanique** : L'architecture du robot repose sur un châssis simple conçu à l'aide de croquis à la main ainsi que de SolidWorks.
**Électronique**: afin de gérer la distribution d'énergie par une batterie 12V, la communication par bus CAN entre les composants, ainsi que l'utilisation des capteurs à ultrason à l'aide de ARDUINO MEGA.
**Informatique**: L'intelligence du robot est pilotée par un programme ARDUINO. Ce code, en langage C++,permet de gérer la navigation autonome, la détection du totem et l'exécution des trajectoires. Il assure également le traitement des données capteurs et la commande précise des moteurs KTECH et Dynamixel.
#### **Matériel à disposition :**
- une pince 3551
- deux moteurs KTECH MS4015-V3
- un moteur Dynamixel
- deux petites roues et une roue pivotante ( de caddie)
- une carte Arduino MEGA, un shield SEED et un shield Dynamixel
- deux capteurs à distance ultrasons HC-SR04
- une batterie RS PRO 12V 1,2Ah
**Répartition des tâches :**
Après s'être familiarisés avec le sujet, on se répartit les taches de la manière suivante :
- Chef de projet: Maxime CARLIER
- Responsable du pôle électronique: Raul ABI KHALIL
- Responsables du pôle informatique: Hind BENRADJA et Melia TAFAT
- Responsable du pôle mécanique: Lucas BRUGNONE
- Responsables du Wiki: Hind BENRADJA et Melia TAFAT
**Diagramme de GANTT du projet:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/capture-decran-2026-05-28-a-00-58-00.png)
#### **Codes du projets:**
**[Ktech\_motor.cpp](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1865)**
**[Ktech\_motor.h](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1867)**
**[robot\_ROB3\_complet.ino](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1866)**
**Pôle mécanique :**
Différentes solutions ont été envisagées mais on opte, dans un premier temps, pour la solution suivante:
[  ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/aFtimage.png)
**Figure 1:** Modélisation de la première solution
On modélise un châssis avec des emplacements définis pour chaque composant, et on décide d'adopter pour une structure en escalier afin de fixer la roue pilotante à l'extrémité la plus haute, étant donné le fait qu'elle soit plus volumineuse que les autres roue, et de placer la pince sur une cale située à l'autre extrémité. Le mouvement de celle-ci sera piloté par un système de pont levis qui consiste à lever la cale à l'aide d'une corde qui s'enroulera.
Cependant, après réflexion, on se rend compte que cette première solution était inutilement complexe et présentait quelques inconvénients, comme le fait que la pince soit trop haute. On décide alors d'opter pour une solution plus simple qui est la suivante :[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/u9Uimage.png)
**Le châssis**
Un châssis rectangulaire (figure 2) a été dimensionné de sorte à ce que tous les composants puissent être placés dessus sans encombrer la maquette. La roue libre a été placée à l'arrière du robot et les deux roues motrices à l'avant, afin que le centre de rotation, lorsque le robot tourne sur lui-même, soit le plus proche possible de la pince. Cela permet d'avoir des mouvements plus précis lors des rotations.
Quatre trous ont été prévus afin de pouvoir fixer les supports de la carte Arduino et ceux de la batterie sur le châssis.
Une ouverture rectangulaire verticale a également été ajoutée afin de permettre le passage du câblage de la maquette et d’éviter que les fils gênent les différents éléments mécaniques.
À l’avant du robot, deux fentes horizontales identiques servent à fixer les supports des roues motrices. Une autre fente horizontale, plus fine cette fois, permet la fixation du capteur à ultrasons utilisé pour détecter le mur situé à droite du robot.
Enfin, huit petits trous ont été prévus afin de fixer le support du moteur contrôlant la pince et ainsi assurer un maintien stable de celle-ci sur le robot.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/capture-decran-2026-05-28-a-01-19-50.png)
**Figure 2:** Esquisse du châssis
Concernant les fixations des roues motrices (figure 3), celles-ci viennent s’encastrer dans le châssis par le dessus grâce aux encoches prévues sur leur partie supérieure. Ces encoches ont été dimensionnées légèrement plus larges que les ouvertures du châssis afin d’obtenir un assemblage serré et d’assurer une bonne tenue de l’ensemble.
Un trou rectangulaire vertical central a également été prévu afin d’accueillir le support du capteur utilisé pour détecter les obstacles situés à l’avant de la maquette, notamment les murs et le totem. En plus de maintenir le capteur, cette pièce permet aussi de garder un bon écartement entre les deux supports de roues, ce qui limite les déformations du châssis et le rend plus rigide.
Enfin, quatre trous ont été ajoutés afin de permettre la fixation des moteurs des roues motrices. Ces fixations permettent de maintenir correctement les moteurs et d’assurer un bon alignement du système moteur.
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/641image.png)
**Figure 3:** Fixation des roues motrices
**La pince**
Pour pouvoir attraper le totem, la pince qui nous a été fournie va être utilisée. Afin de lui permettre de se lever verticalement et d’atteindre la partie la plus fine du totem, le couple délivré par le moteur sera exploité. À ce moteur est fixée une pièce réalisée en impression 3D (1), qui sera utilisée comme bras de levage. Cette pièce est ensuite reliée à une petite planche, appelée “planche à pivot” (2), capable d’effectuer une rotation verticale afin d’orienter correctement la pince vers la zone fine du totem. Enfin, une encoche dans la planche à pivot est prévue, afin d’y encastrer un support qui permettra par la suite d'y visser solidement la pince grâce à deux trous de fixation.
[  ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/JFjimage.png)
**Figure 4:** Mécanisme de la pince
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/ULyimage.png)
**Les capteurs**
Les deux capteurs sont disposés de la manière suivante : le premier capteur est placé sur le côté du robot afin de mesurer la distance par rapport au mur et ainsi permettre au robot de se repérer dans son environnement, tandis que le second capteur est situé sous le châssis afin de détecter le totem, mais également les obstacles ou murs présents devant le robot. Afin de maintenir ces capteurs en place, deux supports sont conçus (figure 4). Chacun d'entre eux possède un emplacement adapté aux deux capteurs optiques ainsi que des trous de vissage permettant de les fixer solidement. Concernant le support du capteur situé sous le châssis, deux encoches sont crées afin qu’il puisse s’encastrer entre les deux planches maintenant les moteurs des roues, cela permet d’assurer une fixation plus stable du support sur le robot. Enfin, pour le support du capteur latéral, une seule encoche a été ajoutée à sa base afin qu’il puisse s’encastrer directement dans le châssis.
[  ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/zxgimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/7Qjimage.png)
**Figure 5:** Modélisation des supports de capteur
Finalement, lors du montage sur leurs supports, on constate que les capteurs ne sont pas totalement plats et présentent un relief entre les deux capteurs optiques. Ne disposant pas de vis suffisamment longues et adaptées au diamètre des trous de fixation pour compenser cette surépaisseur, on décide de modifier légèrement les supports en ponçant la zone située entre les deux capteurs optiques afin de laisser passer ce relief (figure 6).
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/Fslimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/OtQimage.png)
**Figure 6:** Design final des supports de capteur
**Pôle électronique :**
Pour le pôle électronique, le début du projet n'était pas très actif. Lors de la première séance on a juste vérifier que tout le matériel étaient fonctionnel et marchait correctement. En réalisant ces testes, on remarque qu'il manque un fil pour relier le servomoteur dynamixel à l'arduino MEGA.
Lors de la deuxième séance on décide donc de nous même assemblé ce fil en soudant deux fils qui sont liés à différents embout compatible à l'Arduino d'un coté et au dynamixel de l'autre. Pour cela on utilise, un fer à souder pour faire chauffer de l'éteint entre les câbles que l'on souhaite souder. Une fois que l'éteint c'est faufilé entre les fils qu'on souhaite souder, on laisse refroidir pendant un instant, on aplatit la zone soudé avec une pince à tête plate et on couvre la zone par de la gaine thermo rétractable que l'on vient chauffer avec un pistolet à air chaud.
Le produit final donnera quelque chose comme cela:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/da2eb33f-376d-4b1f-818d-efa031ef259a.JPG)
**Figure 7:** Cable reliant le Shield Dynamixel et le servomoteur Dynamixel
Plus tard dans le projet, après que la modélisation du châssis soit terminé, on assemble donc tout les câbles et réalisons toutes les connections sur les différent port. (Voir les instructions de câblage un peu plus bas.) Nous avons essayé de câbler le montage d'une manière propre.
**Câblage du Robot:**
| **Elément** | **Pin**
|
| Capteurs US droit (latéral) | VCC : 5V, GND : GND, TRIG : PIN 22, ECHO : PIN 23
|
| Capteur US avant | VCC : 5V, GND : GND , TRIG : PIN 42 , ECHO : PIN 43
|
| Servomoteur Dynamixel | Brancher d'un côté sur le dynamixel et de l'autre sur le Shield dynamixel (Voir figure ??)
|
| Moteur Ktech | Fils rouges : 12V de la batterie, Fils noirs : Masse de la batterie, Fils bleus: Sur le bornier du Shield CAN (côté gauche), Fils jaunes : Sur le bornier du Shield CAN (côté droit).
|
| Pince | Fil Rouge : 5V, Fil Noir : GND, Fil Blanc : PIN 6, Fil Vert : PIN ANALOG A15
|
| Cable UART-USB pour recevoir des informations sur le système en temps réel | Fil Noir : GND , Fil Orange : PIN 7, Fil Jaune : PIN 8, BAUD RATE : 115200 (Dans le terminal Arduino\*)
|
On a aussi décidé de rajouté un interrupteur sur la batterie afin de sécuriser le montage et de faciliter le téléversement des programme lorsque le système est totalement monté. Pour installer cet interrupteur, on a juste branché sur le fil rouge du distributeur au différent bornier connecté sur la batterie l'interrupteur.
**\*: Pour observer les information dans le terminal Arduino, il faut ouvrir un moniteur serial sur un nouveau programme Arduino, le connecté au port du câble USB-UART et réglé la vitesse de transmission à 115200 bauds.**
**Pôle informatique :**
On réalise tout d'abord un organigramme afin de structurer la logique de l'algorithme avant de passer à la programmation.
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/Y3iimage.png)
**Figure 8:** Organigramme du fonctionnement du robot
Pour réaliser la boucle correspondante, on code dans un premier temps les fonctions suivantes :
**Initialisation**
**verifierEtatInitial()** Séquence de vérification au démarrage : lève le bras, ouvre la pince, puis lit la position analogique de la pince (pin A15) pour confirmer que les actionneurs répondent correctement.
**setup()** Fonction Arduino standard exécutée une seule fois au démarrage. initialise le port série, les capteurs ultrason, le servomoteur de la pince, le bus CAN, le servomoteur Dynamixel en mode position, et les moteurs KTech. Effectue un reset des encodeurs en fin d'initialisation.
**Conversion**
**deg\_to\_m(float deg)**: Convertit un angle en degrés (rotation d'un moteur) en distance linéaire en mètres, en utilisant le rayon de la roue.
**Cinématique**
**MotorSpeed(float v\_translation, float v\_rotation):** Calcule et envoie les commandes de vitesse aux deux moteurs KTech via le bus CAN. Prend en entré une vitesse de translation (m/s) et une vitesse de rotation (rad/s), et applique le modèle cinématique d'un robot pour convertir ces consignes en RPM pour chaque roue.
**stopMotors()**: Envoie une commande de vitesse nulle aux deux moteurs pour arrêter immédiatement le robot.
**Capteurs Ultrasons**
**fonction lire\_distance (int pinTrig, int pinEcho)** : qui reçoit en entrée les numéros des broches du capteur. Elle sert à mesurer la distance séparant le robot d’un obstacle en calculant le temps de vol d'une onde sonore. Le code commande d'abord au capteur d'émettre un son (via la broche *Trigger*), puis met le programme brièvement en pause pour mesurer le temps de propagation de l'écho reçu (via la broche *Echo*). Enfin, elle réalise un calcul mathématique simple pour convertir cette durée en centimètres (en utilisant la vitesse du son) et envoie le résultat final sous forme de nombre décimal au programme principal, permettant au robot de décider s'il doit s'arrêter ou continuer sa route.
**distanceValide(float d) :** Vérifie qu'une mesure de distance est dans une plage physiquement cohérente (entre 2 et 900cm). Retourne 'True' si la valeur est dans l'intervalle, 'False' sinon.
**Actionneurs**
**controlePince(bool ouvrir)** : qui, comme son nom l'indique, sert à ouvrir ou fermer la pince du robot afin d'attraper et relâcher le totem. La fonction reçoit en entrée un choix logique (*true* pour ouvrir, *false* pour fermer): si la condition est vraie, elle envoie un signal électrique spécifique (PWM de 500) sur la broche de la pince pour l'ouvrir au maximum ; si elle est fausse, elle envoie un signal différent (PWM de 950) pour la fermer. Enfin, on intègre une courte pause (*delay*), qui laisse le temps mécanique au servomoteur de finaliser son mouvement afin d'éviter de perturber les autres commandes électriques du robot.
**baisserBras():** Envoie au servomoteur Dynamixel la consigne de postion basse (DXL\_POS\_BAS) pour abaisser le bras du robot. On attend 1500ms pour la fin du mouvement.
**leverBras():** Envoie au servomoteur Dynamixel la consigne de position haute (DXL\_POS\_HAUT) pour lever le bras. Attend 1500ms pour la fin du mouvement.
**Odométrie**
**reset\_encodeurs():** Lit l'état actuel des deux moteurs et sauvegarde leurs positions angulaires comme référence zéro. Toutes les mesures de déplacement ultérieures seront calculées relativement à ce point de départ.
**lire\_d0\_d1(float &d0, float &d1) :** Lit les positions courantes des deux moteurs et calcule les distances parcourues en mètres par chaque roue depuis le dernier reset, en tenant compte du sens de rotation.
**mesurer\_distance\_parcourue():** Retourne la distance linéaire moyenne parcourue par le robot (moyenne des deux roues) depuis le dernier reset des encodeurs, en mètres. Affiche également les valeurs individuelles sur le port série.
**Suivi de Mur**
**avancerSuiviMur():** Fait avancer le robot en corrigeant sa trajectoire pour maintenir une distance par rapport au mur droit (DIST\_MUR\_CIBLE), à l'aide d'un correcteur proportionnel (gain KP\_MUR). La vitesse d'avance est réduite si l'erreur latérale est trop grande. Doit être appelée en boucle.
**Déplacements par odométrie**
**avancerDistancePrecise(float distCible\_m)** Fait avancer le robot en ligne droite sur une distance précise en mètres, mesurée par odométrie. S'arrête dès que la distance cible est atteinte.
**reculerDistancePrecise(float distCible\_m)** Fait reculer le robot sur une distance précise en mètres, mesurée par odométrie. S'arrêete dès que la distance cible est atteinte.
**avancerDistanceSuiviMur(float distCible\_m)** Fait avancer le robot sur une distance précise en mètre tout en maintenant me suivi du mur droit.
**Rotations par odométrie**
**tournerDroite90()** Effectueune rotation de 90° vers la droite sur place, en contrôlant l'angle par odométrie. Pour compenser le glissement des roues on a rajouté un coefficient empirique de 0.83.
**tournerGauche90()** Effectueune rotation de 90° vers la gauche sur place, en contrôlant l'angle par odométrie. Pour compenser le glissement des roues on a rajouté un coefficient empirique de 0.83.
Ainsi, on réussit à obtenir un robot fonctionnel, conforme aux attentes, comme en témoigne cette vidéo : [vidéo robot fonctionnel](https://drive.google.com/file/d/1M_Iu5rXr3HK9zu05pScoAy84JGMlHxM9/view?usp=share_link)
# Projet Rob3 - Cléo, Léon, Adam, Anass, Valentin, Marianne
#### **Objectif Général**
Durant ce projet, nous souhaitons réaliser un robot muni d'une pince capable de se déplacer dans une arène en partant d'une position fixe pour aller chercher un totem dont la position est approximativement connue et venir le redéposer à un autre endroit de l'arène.
Lien vers l’énoncé détaillé: [https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1660](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1660)
#### **Liens utiles (codes, pieces, vidéos...)**
**Codes pour l'utilisation du robot:**
[Ktech\_motor.cpp](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1861)
[Ktech\_motor.h](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1862)
[ProjetRob.ino](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1863)
**Pièces utilisées:**
[fixation\_roue.SLDPRT](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1868)
[Pieces\_capteurs.SLDPRT](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1869)
[support\_batterie.SLDPRT](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1870)
[piece\_pince.SLDPRT](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1871)
[bati.SLDPRT](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1872)
#### **Planning**
Afin d'avoir un planning structuré et facile à suivre, nous avons mis en place un diagramme de Gantt où vous pouvez voir les tâches précises qui composent chaque pôle, qui a participé à ces tâches et sur combien de séances elles sont étalées.
[Lien vers le Diagramme de Gantt](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1763)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/screenshot-2026-05-21-at-09-48-38.png)
#### **Séance 1 *12/02/2026***
Dans le cadre de notre première séance, on s'est familiarisé avec le projet. On a réparti les rôles pour une résolution ordonnée du problème :
Chef de projet : Cléo SAUVENAY,
Responsable du Wiki : Marianne RODRIGUEZ,
Responsable informatique : Valentin BOUR et Léon CHERPITEL,
Responsable mécanique : Adam ABDENNADHER,
Responsable électronique : Anass CHHIBI,
#####
**Pôle Mécanique**
**Travail réalisé (ADAM, MARIANNE et VALENTIN):** La modélisation du robot commence par un châssis triangulaire à deux angles tronqués, permettant de fixer les moteurs des roues sur des plaques perpendiculaires et la roue folle à la pointe. Une tige assure l'alignement des roues, bien qu'elle puisse être absente ou ajustée dans le modèle final pour permettre la rotation.
Dans ce premier modèle la pince fonctionne via un système pignon-crémaillère : une plaque dentée coulisse dans une encoche et s'engrène avec une roue dentée entraînée par le moteur, assurant le mouvement vertical.
Enfin, deux capteurs de distance sont prévus : un sur le côté pour surveiller la trajectoire par rapport aux murs, et un au-dessus de la pince pour détecter la distance avec le totem.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-7200.png)
Schéma du châssis, du système pignon-crémaillère et du montage des roues sous le châssis.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/img-7201.jpeg)
Schéma dimensionné avec placement des différents composants (carte Arduino, batterie, etc.)
**Travail pour la prochaine séance :** Un premier prototype en papier reprenant les dimensions complètes du robot.
##### **Pôle Informatique**
**Travail pour la prochaine séance :** Se familiariser avec la documentation et réfléchir à des structures de programmes.
##### **Pôle Électronique**
**Travail réalisé (ANASS et CLÉO):** On a vérifié, comme demandé par les enseignants, le bon fonctionnement de tout l'équipement électrique durant les 2 premières heures, en suivant les instructions du PDF fourni par les référents. Lors de la dernière heure, nous avons discuté de la direction que le groupe allait prendre concernant le robot ainsi que de l'organisation du projet.
#### **Séance 2 *29/03/2026***
##### **Pôle Mécanique**
**Travail réalisé (ADAM et MARIANNE):** Durant cette séance, nous avons reconsidéré le modèle défini lors de la séance précédente. Nous nous sommes rendu compte que le système pignon-crémaillère prévu pour manipuler la pince était trop complexe à mettre en œuvre. Nous avons donc décidé de changer de stratégie et d'opter pour un bras de type levier avec la pince à son extrémité. Nous avons ensuite réfléchi aux pièces nécessaires pour ce nouveau système :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/img-7596.jpeg)
Schéma du montage de la pince et de son encastrement dans le châssis
C'est ainsi que nous avons commencé la modélisation du bras (fixé au moteur et auquel la pince est attachée) ainsi que du support permettant de fixer le moteur au châssis sur SolidWorks, afin de pouvoir ensuite l'imprimer en 3D.
**(CLÉO):** En même temps, nous avons commencé à nous familiariser avec la découpeuse laser dans le but de déterminer les bonnes cotes au cas où nous devrions faire des encastrements. Pour avoir un trou de 3 mm, il faut mettre 2,8 sur SolidWorks, et pour avoir un bon encastrement, il faut faire 3,02, donc une différence de 0,22.
##### **Pôle Informatique**
**Objectif de la séance :** Définir l'architecture générale du programme de navigation du robot.
**Travail réalisé (Anass, Léon, Valentin):** L'équipe informatique s'est réunie pour établir les grandes lignes du programme, en se concentrant sur trois fonctions centrales : le suivi de mur (longer un obstacle de manière stable), l'atteinte du totem (guider le robot jusqu'à la cible) et le retour au point de dépôt.
Les primitives de déplacement ont également été définies : déplacement en ligne droite, rotation sur place ou en arc, correction de trajectoire, ainsi que la récupération et le dépôt du totem.
Pour chaque fonction, un organigramme a été réalisé afin de modéliser la logique de contrôle, permettant de :
- visualiser clairement les séquences d'opérations ;
- identifier les conditions et branchements nécessaires ;
- préparer une base solide pour l'implémentation.
**Algorithme de déplacement du robot**
1. Avancer de X cm puis tourner à 90° droite
Fin : mouvement / rotation des roues = terminé
2. Avancer en gardant une distance à droite de 30 cm
Fin : distance avant = X cm
3. Tourner à 90° gauche
Fin : mouvement / rotation des roues = terminé
4. Avancer en gardant une distance à droite de 30 cm
Fin : distance avant = X2 cm
5. → Répéter l'étape 2
6. → Répéter l'étape 3
7. → Répéter l'étape 2
8. → Répéter l'étape 3
9. Avancer en gardant une distance à droite de 30 cm
Fin : nb de tours de roue atteint
10. Lâcher le totem
*Paramètres* : X = distance avec le mur en face, X2 = distance avec le totem.
##### **Pôle Électronique**
**Travail réalisé (Anass et Léon):** Concernant le pôle électronique, nous avons connecté deux câbles entre l’Arduino et le contrôleur moteur en les soudant, puis en les sécurisant avec une gaine thermorétractable. Nous avons ensuite ajouté un bornier afin de simplifier et d’optimiser les branchements. Enfin, le câblage des moteurs vers l’Arduino a été réalisé.
#### **Séance 3 *2/04/2026***
##### **Pole Mécanique:**
**Travail réalisé (Cléo):** Modélisation du châssis sur SolidWorks avec les trous prévus pour le placement des composants, le passage et la gestion des câbles. Découpe au laser dans une plaque de MDF 6 mm. Après test d'alignement, plusieurs ajustements ont été identifiés : augmenter légèrement le diamètre des trous pour les vis M3 fixant la carte Arduino, réduire l'écart entre les deux trous centraux, positionner les trous de fixation du moteur du bras en diagonale plutôt qu'en ligne afin d'éliminer le jeu, et ajouter des trous supplémentaires pour le passage de serre-câbles.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/Zuximage.png)
Photo du premier châssis
**(Adam):** Durant cette séance, on a retravaillé la pièce permettant d'actionner la pince, qu'il a fallu re-modéliser après avoir constaté un problème de dimensionnement sur le premier essai. La pièce finale est la suivante :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/fp0image.png)
Après impression, nous avons pu monter la pince, le moteur ainsi que l'ensemble des fixations.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/img-7845.jpeg)
Pour finir nous avons réfléchi au montage des roues et à comment garantir leur parallélisme cela dans le but de pouvoir les monter la séance prochaine.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/img-7846.jpeg)
Schéma du montage des roues et de leur fixation
##### **Pôle Électronique et Informatique**
**Travail réalisé (Anass, Léon, Valentin):** Lors de cette séance, les pôles informatique et électronique se sont concentrés sur des tests de déplacement du robot, en s'appuyant sur un code d'exemple permettant de contrôler les roues selon trois modes : avancer, reculer et tourner. Ce code s'est avéré fonctionnel et les trois actions ont été exécutées avec succès.
Cependant, deux problèmes sont apparus : la pince effectuait des mouvements non prévus, puis en tentant de changer de port, l'alimentation de la carte Arduino a été court-circuitée. Une grande partie de la séance a donc été consacrée à identifier les composants défectueux et ceux encore fonctionnels (capteurs et moteurs KTECH).
**Travail pour la prochaine séance :** Pour la prochaine séance, l'objectif est de réimplémenter le code sur une nouvelle carte Arduino afin de retrouver les mouvements de base du robot, puis d'intégrer la détection des capteurs.
#### **Séance 4 *16/04/2026***
##### **Pole Mécanique**
**Travail réalisé (Cléo, Adam et Marianne):** Durant cette séance, le pôle mécanique a poursuivi le développement du châssis et l'intégration des différents composants du robot.
Les pièces de fixation des roues ainsi que celles dédiées aux capteurs infrarouges ont été conçues, modélisées puis découpées dans des plaques de MDF 6 mm. Ce premier montage complet a permis d'identifier plusieurs conflits entre certaines pièces, dont le plus critique était le défaut de parallélisme des deux roues motrices. Le châssis a donc été retravaillé pour corriger ces problèmes, et une nouvelle version a pu être découpée.
Dans un second temps, les pièces relatives aux capteurs et au positionnement de la batterie ont été modélisées et découpées. Il a été décidé de placer les capteurs sous le châssis afin d'optimiser leur efficacité. La batterie, quant à elle, est posée directement sur le châssis et maintenue en position par quatre cales encastrées, assurant un maintien solide sans fixation supplémentaire.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/batterie.jpeg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/capteur.jpeg)
Pièce pour positionnement batterie (gauche) et pièce pour fixer capteurs (droite)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/T2yimg-7847.jpeg)
Première version montée du robot
##### **Pôle Électronique et Informatique**
**Travail réalisé (Anass, Léon, Valentin) :** Durant cette séance, le pôle informatique a travaillé sur deux axes principaux : le contrôle des actionneurs et l'exploitation des données capteurs.
Un premier programme a été développé pour piloter les déplacements du robot via un Arduino communiquant avec deux moteurs par bus CAN. Le démarrage est déclenché par un bouton-poussoir sur la pin 2, géré par interruption matérielle, ce qui permet au programme d'attendre sans bloquer la boucle principale. Plusieurs primitives de mouvement ont été implémentées — avancer, tourner à droite et à gauche — et validées par une séquence de test en boucle infinie, sans anomalie observée.
Pour estimer sa position et son orientation, le robot lit en continu l'angle de rotation de chaque roue depuis les moteurs. À chaque cycle, la variation d'angle est convertie en distance parcourue grâce au périmètre de roue (diamètre 50 mm, soit environ 157 mm) : la moyenne des deux roues donne la distance avancée, la différence donne la rotation. Ces valeurs mettent à jour les variables odom\_x\_mm, odom\_y\_mm et odom\_theta, et pilotent les fonctions moveForward\_mm() et rotate\_deg() jusqu'à ce que l'objectif soit atteint.
Deux capteurs ultrasons HC-SR04 ont ensuite été intégrés : un capteur avant (pins 22/23) pour détecter les obstacles, et un capteur droit (pins 42/43) pour mesurer la distance au mur latéral. En l'absence d'écho dans un délai de 30 ms, la distance est fixée à 999 cm. Sur cette base, un programme d'asservissement a été développé pour maintenir le robot à distance constante du mur, selon une logique bang-bang : en dessous de 10 cm, la roue gauche ralentit ; au-dessus de 15 cm, c'est la roue droite ; entre les deux, les deux roues avancent à vitesse normale. Le longeage s'arrête dès que le capteur avant détecte un obstacle plus proche que le seuil mesuré en début de phase.
Enfin, deux tests ont été conduits : le premier validait les fonctions de mouvement seules afin de vérifier l'odométrie et le bus CAN ; le second ajoutait les capteurs et la logique de longeage, avec un affichage en temps réel des distances dans le moniteur série (AVANT: xx cm | DROITE: xx cm), ce qui a permis de valider les seuils de correction avant de lancer le robot.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/whatsapp-image-2026-04-16-at-11-56-00.jpeg)
Schéma du fonctionnement du programme
#### **Séance supplémentaire du *20/05/2026***
Afin de rattraper le retard accumulé et de rester dans les temps pour les tests et le développement du code, une séance supplémentaire a été organisée.
Durant celle-ci, nous avons démonté la première version du robot pour le remonter dans le nouveau châssis, mieux dimensionné. Cette opération a nécessité de rallonger et de souder plusieurs câbles, entraînant ainsi une refonte partielle du câblage. Une fois le montage finalisé, nous avons pu tester le code général du robot simulant son parcours dans l'arène.
#### **Séance 5 du *21/05/2026***
Lors de cette dernière séance au Fablab, nous avons travaillé sur les derniers détails du robot.
Il a fallu démonter les roues afin d'installer une tige reliant les deux côtés, dans le but d'éviter qu'elles se courbent sous le poids important exercé sur le châssis. Nous avons également revu toute la connectivité du robot afin de vérifier que tous les branchements étaient corrects.
Ensuite, nous avons pu poursuivre les tests du code. Chaque fonction a été testée séparément : les déplacements, les rotations à 90 degrés, l'avancement, l'arrêt du robot, ainsi que le levage et l'abaissement de la pince, sans oublier son ouverture et sa fermeture.
Il a fallu faire particulièrement attention au calibrage des capteurs, ce qui a nécessité plusieurs essais avant d'obtenir des mesures fiables. Nous avons également dû prendre en compte le fait que les deux roues ne tournaient pas dans le même sens : pour faire avancer le robot correctement, il fallait donc leur appliquer des vitesses opposées.
#### ***Séance supplémentaire du 27 et 28 05/2026***
Durant ces deux séances supplémentaires avant la présentation finale, nous avons effectué les dernières touches du code.
Nous avons d'abord calibré les capteurs afin de savoir quand le robot doit tourner aux différentes étapes du parcours. Un problème est apparu : la pince était détectée par le capteur en position basse, rendant toute reconnaissance impossible dans cette configuration. Nous avons donc modifié le code pour qu'à chaque phase de reconnaissance, la pince soit automatiquement levée.
Malgré un code qui fonctionnait auparavant, nous avons eu des problèmes avec la configuration des roues, nous avons donc tout redéfini. Nous avons également mis en place le suivi de mur avec un correcteur proportionnel afin de maintenir la pince à 30 cm du mur latéral, et refait un câblage propre et organisé.
Durant les tests, nous nous sommes rendu compte que serrer ou desserrer la pince causait un reset de l'Arduino, nous avons donc dû la débrancher. Trouver les bonnes valeurs du correcteur a nécessité plusieurs tests, mais nous avons fini par obtenir quelque chose de cohérent.
Finalement, pour le dépôt de l'objet à la bonne distance du mur du fond, la stratégie retenue est de mesurer le temps pour aller jusqu'au totem, terminer la traversée, puis refaire ce même temps en sens inverse.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8178.jpeg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8179.jpeg)
Robot version finale
Vidéo du robot en mouvement : [Video\_Robot.mp4](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1864)
---
# StarBot - Groupe 6 - Bastien, Carl, Joyce, Jasmine, Virgile, Elias
## **Projet ROB3 2025-2026**
## **STARBOT**
#### Bastien, Carl, Joyce, Jasmine, Virgile, Elias
#### **Informations**
- CHEF DE PROJET: Bastien Derrouet
- RESPONSABLES INFORMATIQUES: Virgile Gablain, Joyce Diab
- RESPONSABLES MECANIQUES : Carl-Jocelyn Plakoo, Elias Denis, Jasmine Kasmi
- RESPONSABLE ELECTRONIQUE : Bastien Derrouet
- RESPONSABLE WIKI : tout le monde.
#### **Contexte**
Il s'agit de concevoir et fabriquer un robot capable de réaliser l'exercice défini dans le cahier des charges disponible dans ce document : [Projet de robotique ROB3 - 2026.pdf](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1658)
En résumé, le robot doit déplacer un objet d’une position initiale vers une position finale au sein d’une arène. Il doit intégrer un chariot mobile, un bras à un degré de liberté et une pince montée à l’avant.
#### **Matériel**
Un kit composé principalement de :
• Une pince 3551 fournie en kit, avec un servo moteur intégré.
• Deux moteurs KTECH MS4015-V3 contrôlables en vitesse et intégrant une mesure de
position.
• Un moteur Dynamixel série AX
• Deux roues Pleine Guitel Hervieu Ø 50mm destinées à être motorisée et une roue
pivotante Guitel Hervieu, Ø 50mm.
• Une carte Arduino MEGA + un shield Arduino pour la communication via un bus CAN avec
les moteurs KTECH + un shield Dynamixel
• Deux capteurs de distance à ultrasons HC-SR04
• Une batterie RS PRO 12V 1.2Ah. Un kit de connexion permettant d’alimenter l’Arduino
avec la batterie
Dans le FABLAB Sorbonne Université, sont également disponibles :
\- Des planches de médium, 300mmx600mm ép. 6mm ou 3mm, découpables au
LASER dans le FABLAB.
\- Des petits composants électroniques et mécaniques standard.
\- Du filament pour les imprimantes 3D du FABLAB.
### I - Déroulé des séances
#### I.1 - 19 Février 2026 - Séance 1
##### **Objectif de la séance**
- Tester le kit fourni afin de voir les problèmes potentiels
- Créer la page wiki
- Organisation de l'équipe
- Choisir les rôles
- Discuter de la conception mécanique
Lors de la première séance, une présentation du projet nous a été donnée, ainsi qu’une introduction à l’environnement de travail (Fablab) et aux machines associées.
Suite à cela, nous avons pris connaissance du cahier des charges afin d’organiser au mieux le travail en équipe. Ci-après sont présentées les différentes tâches réalisées ainsi que les personnes associées à chacune d’elles.
##### **Réflexion Mécanique (Carl - Jasmine - Elias)**
Dans cette partie, nous vous présenterons la réflexion que nous avons menée pour arriver au design final de notre robot.
Concernant le chariot, au vu des éléments disponibles, le choix s’est porté sur une configuration avec deux roues motrices à l’arrière et une roue folle à l’avant, fixées sous une plaque en bois dont la géométrie sera optimisée ultérieurement. Le bras et la pince étant situés à l’avant, l’électronique et la batterie sont positionnées vers le centre afin d’assurer une répartition équilibrée des masses, notamment grâce au poids des moteurs arrière. Les capteurs ultrason sont placés à l’avant et sur le côté droit de la plaque, permettant au robot d’affiner son positionnement en mesurant à la fois la distance au totem et aux parois latérales.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/OSEimage.png)
Concernant le bras robotisé, plusieurs architectures ont été étudiées. Un premier concept à liaison glissière verticale s’est révélé inadapté en raison de la garde au sol du châssis, empêchant l’accès à un objet situé en dessous. Une solution combinant liaison glissière et pivot a permis d’introduire une cinématique de basculement pour abaisser l’effecteur, mais elle nécessitait plusieurs actionneurs, incompatibles avec la contrainte de trois moteurs dont deux dédiés à la locomotion.
Une solution de préhension passive de type fourche a été écartée car non conforme au cahier des charges. L’architecture retenue repose donc sur une liaison pivot unique motorisée, offrant un compromis entre simplicité et efficacité. Le bras est monté sur un support surélevé dimensionné selon la hauteur du totem, avec une longueur adaptée pour garantir une amplitude suffisante.
La pince est fixée en liaison encastrement unilatérale, suffisante mécaniquement et plus simple à intégrer. L’ensemble est assemblé par liaisons vissées assurant rigidité et le caractère démontable, avec un usage ponctuel de collage pour les interfaces bois sur bois.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/zXdimage.png)
Une fois que ce design a été validé par toute l'équipe nous avons réfléchis à des solutions pour les autres problèmes qui se posent.
- La roue libre a une hauteur plus grande que les roue motrices. Pour pallier ce problème nous avons pensé a fixer les moteurs sur une plaque qu'on fixera au châssis. Ainsi, en réglant la hauteur de la plaque on compense la hauteur de la roue libre.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/9p5image.png)
- La position de l'ultrason peut être problématique dans certains cas. En effet, l'ultrason posé à l'avant du robot pourra être bloqué par la pince et le totem au moment de la récupération ce qui empêcherait de pouvoir faire les calculs de position pour le chemin retour. Nous avons conclus que le robot pourrait soulever le totem assez haut pour ne pas obstruer le champs d'action des capteurs.
- La longueur du bras ne doit pas être si longue qu'elle perde de sa rigidité et subisse des déformations lors du déplacement.
##### **Test du kit (Joyce - Bastien)**
Cette partie avait pour but de tester le kit fourni au début du projet afin de s'assurer que chacun des composants fonctionnait de la bonne façon.
##### **Câblage du kit**
Grâce à la documentation qui nous a été fournie, nous avons pu suivre étape par étape le branchement que vous retrouvez sur la figure ci-après :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/bKTwhatsapp-image-2026-02-19-at-17-28-20-1.jpeg)
Figure 4 : Câblage Kit de démarrage
Sur la câble ci-dessus, nous avons branché chaque composant nécessaire au projet final (Capteurs ultrasons, Pince, Moteur Dynamixel, Shields arduino). Il est important de voir que l'alimentation 12V est le câble noir situé en haut à gauche de la figure 4.
Après avoir recopié le code qui permet de tester chaque élément du kit, nous avons pu observer le bon fonctionnement de chaque élément. Voir les figure ci-après (VIDEO ???)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/whatsapp-image-2026-02-19-at-17-28-20-2.jpeg)
Figure 5 : Illustration du bon fonctionnement des équipements du Kit (pince ouverte, moteur en rotation)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/whatsapp-image-2026-02-19-at-17-28-20-3.jpeg)
Figure 6 : Illustration du bon fonctionnement des équipements du Kit (pince fermée, moteurs en rotation)
##### **Problème rencontrés**
Lors du câblage de l'alimentation 12V avec les moteurs Dynamixel, il nous est apparu que les leds des moteurs - normalement vertes - restées ici éteintes. Nous avons alors décidé de prendre un multimètre et de tester la tension au borne de la batterie. Nous avons relevée une tension de 5V ce qui révèle une batterie défectueuse ou déchargée.
Nous avons alors prix une alimentation symétrique 12V avec des cordons d'alimentation dénudés afin de correctement les brancher aux moteurs.
#### I.2 - 5 mars 2026 - Séance 2
##### **Objectif de la séance**
- Etablir un diagramme de gantt
- Réaliser l'algorigramme du code
- Dimensionner les pièces du robots
##### **Réalisations durant la séance 2**
Dans un premier temps, la réalisation du diagramme de gant est important l'organisation de l'équipe
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/ahRimage.png)
##### **Algorigramme de la partie informatique**
Avant de réaliser le code nous avons imaginer l'algorigramme de la fonction principale pour poser notre stratégie de programmation.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/qyfimage.png)
##### **Dimensionnement:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/RTkimage.png)
Compte tenu des dimensions et des masses des différents composants, la disposition sur le chariot ainsi que ses dimensions ont été optimisées afin d’assurer stabilité et efficacité. La batterie, élément le plus lourd, est positionnée au centre de la plaque afin de garantir une bonne répartition des masses et d’éviter un basculement vers l’avant, qui compliquerait la saisie du totem, ou vers l’arrière, qui nuirait à la mobilité.
La pince doit disposer d’un espace de travail dégagé afin de maximiser son amplitude de mouvement sans interférence avec le chariot. Ainsi, le moteur est positionné en porte-à-faux, avec une partie suspendue dans le vide, et orienté de sorte que l’axe médian de la pince coïncide avec celui du chariot. Par ailleurs, une géométrie crénelée a été intégrée sur la plaque afin de permettre la fixation des supports de roues.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/DOIimage.png)
Les plaques de fixation des moteurs ont été conçues pour compenser la différence de hauteur entre la roue folle et les roues motrices. Une modélisation sous SOLIDWORKS a permis de valider qu’une hauteur d’environ 43 mm entre la plaque et l’axe des roues motrices assure un contact correct avec le sol. Ces plaques intègrent également des perçages adaptés aux moteurs (quatre trous espacés de 20 mm) ainsi qu’un logement destiné à accueillir une équerre (4 mm × 3 mm), améliorant la rigidité et la stabilité de l’assemblage avec le chariot.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/Xn2image.png)
Dimensions de l'équerre:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/tbjimage.png)
##### **Programmation**
**Fonctions clé :**
Le code du robot a été structuré de manière modulaire, en transposant directement la stratégie de notre algorigramme en fonctions spécifiques pour séparer la locomotion, la détection et la préhension.
- **La Détection (`lireCapteursUS`) :** Cette fonction gère l'envoi des impulsions ultrasoniques et calcule la distance en centimètres grâce au temps de retour de l'écho. C'est elle qui conditionne les arrêts du robot lorsqu'il s'approche d'un obstacle ou du totem:[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/EDQimage.png)
- **La Prise (`grab` et `drop`) :** Elles encadrent la séquence de récupération et de dépose. Pour respecter les spécificités matérielles, la vitesse de déplacement du bras est bridée à 11,1 tr/min (consigne `MOVING_SPEED` à 100). L'actionnement de la pince est géré par des seuils PWM stricts (50 pour une ouverture complète, 245 pour la fermeture maximale) encadrés par des temporisations de sécurité pour éviter les blocages matériels :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/pIximage.png)
- **La Rotation (`turn`) :** Pour assurer des virages précis à 90°, nous avons opté pour une approche par odométrie plutôt qu'une simple temporisation. La fonction fait tourner les deux roues motrices en sens inverse et lit en temps réel leur position en degrés. Les moteurs se coupent de manière autonome dès que l'angle cible du châssis est atteint :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/sans-titre.png)
**Boucle principale : **
La fonction principale suit de façon séquentielle la stratégie établie dans notre algorigramme. Voici les grandes étapes de la mission :
1. **Approche :** Le robot tourne à 90° et avance jusqu'à ce que le capteur avant détecte un obstacle à 30 cm.
2. **Recherche du totem :** Il pivote de nouveau à -90° et avance vers l'objet. Une variable (`trackerDistanceA1`) compte les itérations de cette phase pour mémoriser la distance parcourue.
3. **Saisie :** Le robot s'arrête et exécute la fonction `grab()` pour soulever le totem.
4. **Retour :** Il effectue les rotations inverses et avance pendant une durée proportionnelle à `trackerDistanceA1` pour revenir à sa zone de départ.
5. **Dépôt :** Le robot s'arrête et exécute la fonction `drop()` pour relâcher le totem.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/tWYimage.png)
##### **Objectif prochaine séance (Toute l'équipe)**
Après avoir mis en commun le travail avec l'ensemble de l'équipe nous avons décidé des réalisation nécessaire lors de la prochaine séance.
1- Faire le découpage des pièces
2- Algorigrammes sous fonction
3- Commencer la programmation
#### I.3 - 26 mars et 9 avril 2026 - Séances 3 et 4
##### **Objectif de la séances**
- Modéliser les différentes pièces
- Assembler le robot sur SolidWorks
- Assembler le robot
- Revoir la programmation
- Choisir les rôles
- Discuter de la conception mécanique
##### **Modélisation sur Solidworks**
La séance 3 a été consacrée à l'élaboration des pièces sur SolidWorks. Cette phase nous a permis de mieux nous rendre compte des dimensions réelles. Nous soulignerons que nous aurions dû passer beaucoup plus tôt à cette étape. En effet, les cotations prévisionnelles, notamment sur le châssis, se sont avérées inadaptées à la géométrie réelle.
Voici le robot.
Des trous de 6 mm ont été placés un peu partout pour pouvoir faire traverser les câbles. Des trous de 3 mm seront utilisés pour fixer la batterie au châssis grâce à des zips.
Focus sur les moyens de fixation des moteurs et des ultrasons ainsi que les équerres
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/3Fyimage.png)[(fixation moteur)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/5yeimage.png)
La fixation pour les ultrasons :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/ultra.png)
L'équerre pour stabiliser les fixations moteurs :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/7O1image.png)
Pour garantir un emboîtement sans jeu des tenons et mortaises (6 mm et 3 mm), nous avons dû réduire les dimensions des ouvertures de 0,2 mm. Cette correction est en accord avec les conclusions d'autres groupes, obtenues suite à l'étude des incertitudes liées à l'utilisation de la machine de découpe.
Voici le bras qui lie moteur et pince
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/4Lbimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/U6limage.png)
Enfin, voici le chassis et ses dimensions.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/6Msimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/2hPimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/vAAimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/7r2image.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/1ucimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/g45image.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/pRbimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/S7qimage.png)
La séance 4 à quant à elle, a permis de découper, grace à la découpeuse laser Trotec Speedy 100 fournie au fablab, les éléments modélisés sur SolidWorks. Il s'est avéré que malgré les ajustements, une des fixation pour ultrason ne rentrait pas, de justesse, dans le châssis. Ainsi, nous avons décidé de limer la pièce pour éviter de réimprimer une pièce ou de perdre du temps à revoir les cotes sur SolidWorks. Mis à part les capteurs ultrasons qui ont été placé sur leur fixation à l'aide de ruban velcro auto-adhésif, le reste a été fixé à l'aide de vis.
#####
#### I.4 - Séance 5 du 7 mai 2026
##### **Réalisations durant la séance**
La première partie de la séance à été consacrée au montage du robot
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img20260507122825.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/1779968980641.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-20260507-123507.jpg)
### I.5 - Séances additionnelles
#### 1. Amélioration du design
Lors de tests afin de finaliser le code, les roues arrières ont commencées à s'affaisser, même avec le renfort des équerres. Il a alors fallu repenser à une solution pour renforcer le châssis. Il a alors fallu ajouter 2 barres et rajouter un trou sur les fixations moteur.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/capture-decran-2026-05-28-112822.png)
#### 2. Amélioration algorithmique
Nous avons dû implémenter quelque changement d'algorithme dans le code afin de le faire fonctionner :
- Refonte de la fonction de rotation :
La fonction précédente était trop complexe et ne pouvait pas fonctionner étant donné que nous ne pouvions pas lire les valeurs de rotation des moteurs. Nous avons donc implémenté une fonction plus simple utilisant un timer s'adaptant à l'angle et à la vitesse cherché.
```c++
void turn(float degreeRot, float vitesseVoulue) {
if (degreeRot == 0.0) {
KTMOTORS[idMoteurDroite].sendVelocityCommand((long int)0.0, CAN);
KTMOTORS[idMoteurGauche].sendVelocityCommand((long int)0.0, CAN);
return;
}
if( degreeRot < 0){
KTMOTORS[idMoteurDroite].sendVelocityCommand(-vitesseVoulue, CAN);
KTMOTORS[idMoteurGauche].sendVelocityCommand(-vitesseVoulue, CAN);
} else {
KTMOTORS[idMoteurDroite].sendVelocityCommand(vitesseVoulue, CAN);
KTMOTORS[idMoteurGauche].sendVelocityCommand(vitesseVoulue, CAN);
}
degreeRot = fabs(degreeRot);
delay(1000 * CoeffRotation/2 * degreeRot/vitesseVoulue);
KTMOTORS[idMoteurDroite].sendVelocityCommand((long int)0.0, CAN);
KTMOTORS[idMoteurGauche].sendVelocityCommand((long int)0.0, CAN);
}
```
- Rajout d'un correcteur proportionnel :
Afin de garantir l'alignement du robot avec le totem, nous avons rajouté une simple fonction qui utilise un correcteur proportionel avec un KP valant 1,2, cette fonction est toujours réappelé dans des boucles while afin de garantir la mise à jour constante de la trajectoire
```c++
void avancePID() {
float dist_actuelle = distanceUS[idCapteurDroite];
float err_dist = dist_actuelle - ValeurAsservissement;
float Corr = KP * err_dist;
KTMOTORS[idMoteurDroite].sendVelocityCommand(-vitesseDegreeSec + Corr, CAN);
KTMOTORS[idMoteurGauche].sendVelocityCommand((vitesseDegreeSec + Corr), CAN);
}
```
- Changement de la détection et mémorisation de la position du totem :
Afin d'améliorer la robustesse de la détection et livraison du totem nous avons choisit de stocker en mémoire la position des capteurs lors de sa récupération au lieu de stocker le temps qu'il a fallu au robot pour le trouver.
- Ajustement sur la logique principale :
Afin de permettre au robot de tourner librement lors de la première rotation, nous avons rajouté une phase d'avancement direct au tout début du programme. Nous avons aussi rajouté une condition faisant que le robot baisse son bras un peu avant d'atteindre le totem afin d'éviter une collision sort de l'abaissement.
- Suppression des fonctions grab() et drop() :
La pince étant hors service, nous l'avons complétement deconnecté et nous avons choisit de remplacé les fonctions grab() et drop() par de simples mouvements de bras dans le code principale, vu que nous n'avions pas à nous préoccuper de la pince, des fonctions spécifique n'était plus vraiment nécessaires.
### II- NOTICE DE FABRICATION TECHNIQUE — STARBOT
#### 1. Objectif du Robot
Le robot doit être capable de se déplacer de manière autonome dans une arène de 1,98 m par 1,22 m. Sa mission consiste à détecter, saisir, soulever, transporter et redéposer un totem d'une hauteur totale de 100 mm présentant la géométrie suivante :
- **Base (Bas) :** Parallélépipède à base carrée de 30 mm de côté et 50 mm de hauteur.
- **Zone de préhension (Milieu) :** Parallélépipède de 30 mm de hauteur et de section carrée étroite de 10 mm de côté. La pince doit obligatoirement enserrer l'objet à cet endroit précis.
- **Sommet (Haut) :** Cube d'arête de 30 mm
#### 2. Usinage et découpe Laser au Fablab
Toutes les pièces de structure sont découpées dans les planches de médium à l'aide d'une découpeuse laser (type Trotec Speedy 100).
**Règle de cotation critique :** Lors de votre dessin sur SolidWorks, appliquez une **correction de -0,2 mm** sur toutes les encoches de tenons et mortaises afin de compenser le trait de coupe du laser et obtenir un emboîtement parfait sans aucun jeu mécanique.
##### A. Le Châssis Principal
- **Cotes globales :** Dessinez une plaque rectangulaire de 250 mm de longueur sur 170 mm de largeur.
- **Usinages intégrés :**
- À l'arrière, dessinez une géométrie crénelée spécifique (encoches de fixation) pour y emboîter les plaques supports des roues motrices.
- Percez une série de trous de diamètre de 6 mm répartis sur la plaque pour faire transiter proprement les câbles électriques entre le dessus et le dessous du robot.
- Percez des orifices de diamètre de 3 mm disposés autour de l'emplacement central pour brider la batterie.
##### B. Les Plaques Verticales de Fixation Moteur
- **Compensation de hauteur :** La roue folle avant possède une hauteur totale supérieure à celle des roues motrices de diamètre de 50 mm. Créez des flasques supports en bois pour les moteurs arrière garantissant une hauteur exacte de 43 mm entre la surface du châssis et l'axe central des roues motrices. Cela assure l'horizontalité parfaite du robot et un contact optimal de toutes les roues avec le sol.
- **Perçages :** Prévoyez 4 trous espacés de 20 mm ajustés au gabarit des moteurs KTECH et un logement pour l'équerre de renfort.
##### C. Le Bras et son Support Surélevé
- Modélisez un bras en bois allongé de 80 mm de long faisant l'interface rigide entre le moyeu du moteur Dynamixel et la base de la pince.
- Dessinez un support avant surélevé pour le moteur Dynamixel, dimensionné par rapport à la hauteur de la zone amincie du totem (50 mm à 80 mm du sol).
#### 4. Assemblage mécanique étape par étape
##### Étape 1 : Le Train de roues
1. Assemblez les plaques de support moteur arrière dans les crénelages du châssis. Insérez les équerres dans leurs fentes pour rigidifier l'angle, vissez l'ensemble et appliquez de la colle bois-sur-bois pour figer la liaison.
2. Fixez les deux moteurs KTECH MS4015-V3 sur ces plaques à l'aide de vis. Installez les deux roues pleines de diamètre 50 mm sur leurs axes respectifs.
3. Retournez le châssis et vissez la roue pivotante folle sous la partie avant.
##### Étape 2 : Le Bloc de préhension (Bras et pince)
1. Vissez le support surélevé sur la partie avant supérieure du châssis.
2. Fixez le moteur Dynamixel sur ce support en configuration porte-à-faux (suspendu dans le vide vers l'avant). Alignez-le de manière à ce que l'axe médian de la pince coïncide parfaitement avec l'axe de symétrie longitudinal du robot afin de garantir la stabilité de la charge.
3. Montez le bras en bois de 80 mm sur l'axe du moteur Dynamixel (liaison pivot).
4. Fixez à l'extrémité libre du bras la pince 3551 par liaison encastrement rigide à l'aide de vis standard.
##### Étape 3 : Implantation électronique et équilibrage des masses
1. Centrage du bloc lourd : Installez la batterie RS PRO (l'élément le plus lourd du système) au centre géométrique exact de la plaque du châssis. Utilisez des colliers de serrage en plastique (zips) insérés dans les trous de diamètre de 3 mm pour la brider. Cette disposition centrale évite au robot de basculer vers l'avant lors de la charge du totem ou vers l'arrière lors des phases de pivot et d'accélération.
2. Fixez la carte Arduino MEGA munie de ses shields juste à côté ou au-dessus du bloc batterie.
##### Étape 4 : Installation des capteurs de distance
1. Installez un support de capteur à ultrasons orienté vers l'avant et un second orienté vers le côté droit du robot.
2. *Ajustement d'atelier :* Si les pièces en bois découpées au laser forcent lors du montage des capteurs, utilisez une lime de précision pour ajuster délicatement l'épaisseur du bois.
3. Fixez les deux modules HC-SR04 sur leurs supports à l'aide de ruban velcro auto-adhésif pour pouvoir ajuster l'orientation des pings ou démonter rapidement les capteurs.
#### 5. Câblage électronique matériel.
##### A. Empilement des cartes (Shields)
1. Prenez la carte Arduino MEGA.
2. Enfichez le shield SEED (Communication CAN) directement sur les broches supérieures de l'Arduino MEGA.
3. Enfichez le shield DYNAMIXEL par-dessus le shield SEED en alignant soigneusement les broches pour ne pas les tordre.
##### B. Connexion des actionneurs
1. Moteurs de propulsion KTECH : Utilisez les câbles à 6 fils fournis. Branchez le connecteur blanc sur le corps du moteur. De l'autre côté (fils dénudés sur une longueur suffisante), raccordez les fils de signal sur le bornier à vis bleu du shield CAN :
- Reliez le fil bleu (CAN) sur le contact le plus extérieur (à gauche).
- Reliez le fil jaune (CAN) sur le contact le plus intérieur (à droite).
2. Moteur de bras Dynamixel : Utilisez le câble noir à 3 fils muni de connecteurs blancs aux deux extrémités. Reliez-le entre le moteur et l’une des trois embases blanches disponibles sur le shield Dynamixel (ce câble véhicule simultanément la puissance et les signaux de commande).
3. Servomoteur de la pince 3551 : Raccordez les 4 fils sortants de la pince sur le shield Dynamixel/Arduino :
- Fil Rouge (Alimentation +) = Borne +5V de l'Arduino.
- Fil Noir (Alimentation -) = Borne GND de l'Arduino.
- Fil Blanc (Signal Commande) = Sortie digitale PIN 9 de l'Arduino.
- Fil Vert (Retour de position analogique)= Entrée analogique A15 de l'Arduino.
##### C. Connexion des capteurs ultrasons (HC-SR04)
Raccordez les capteurs sur la longue barrette arrière de l'Arduino MEGA contenant les entrées/sorties logiques allant de 22 à 53 :
- Alimentations communes : Connectez le *VCC* de chaque capteur sur le +5V de l'Arduino et le *GND* sur le GND de l'Arduino.
- Capteur 1 (Avant) : Connectez la broche *Trig* sur la PIN 22 et la broche *Echo* sur la PIN 23.
- Capteur 2 (Droit) : Connectez la broche *Trig* sur la PIN 42 et la broche *Echo* sur la PIN 43.
##### D. Alimentation de puissance principale
1. Munissez-vous du bornier à vis d'alimentation amovible sans qu'il soit encore inséré sur la carte pour éviter les courts-circuits accidentels.
2. Raccordez les fils de distribution sur ce bornier :
- Sur la borne positive : Branchez le fil rouge (+12V) provenant de la batterie RS PRO, ainsi que les deux fils rouges de puissance de chaque moteur KTECH (soit un total de 3 fils de puissance rouges connectés ensemble).
- Sur la borne négative : Branchez le fil noir (0V) provenant de la batterie RS PRO, ainsi que les deux fils noirs de puissance de chaque moteur KTECH (soit un total de 3 fils noirs connectés ensemble).
3. Une fois les fils fermement serrés et vérifiés dans le bornier amovible, insérez-le dans la prise d'alimentation dédiée des shields.
4. Vérification de sécurité au multimètre : En cas de non-fonctionnement général (par exemple, si les LED témoins vertes du moteur Dynamixel restent éteintes lors de la mise sous tension), placez les pointes de touche d'un multimètre réglé en mode voltmètre directement aux bornes de la batterie. Une batterie opérationnelle doit afficher une tension proche de 12V. Si la mesure indique une chute aux alentours de 5V ou moins, la batterie est déchargée et doit être immédiatement mise en charge.
# Groupe 4 : Baptiste, Nolann, Lounis, Harshanaa, Louisa, Lilian
### **Projet ROB3 2025-2026**
#### **INFORMATIONS**
- Chef de projet : Louisa
- Responsable du Wiki : Baptiste
- Responsable informatique : Lilian
- Responsable mécanique : Nolann
- Responsable électronique : Harshanaa
- Joker(remplace ou aide un responsable si celui ci est malade, absent ou temporairement inapte à réaliser une tâche) : Lounis
#### Contexte :
Créer un robot capable de se déplacer dans un périmètre défini afin d’attraper un objet à l’aide d’une pince et de le déposer à une autre position. Voir [Sujet du projet](https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2025-2026/page/le-sujet-du-projet).
#### Liste du matériel
- 2 moteurs KTECH
- 1 moteur dynamique
- 1 pince 3551
- 2 capteurs à ultrasons
- 1 câble USB pour télécharger les programmes Arduino
- 1 convertisseur UART-USB pour communiquer avec le PC
- 1 carte Arduino Mega avec 2 shields enfichés
#### **1ère séance (19/02/2026) : **
##### I) Discussion des méthodes (mécanique) - (tout le monde)
Lors de cette toute première séance nous avons dans un premier temps établi les objectifs nécessaires pour réaliser le robot. Pour cela nous avons discuté et réfléchi sur la schématisation d'un premier modèle.
Le matériel disponible pour l’évolution et les interactions de notre robot dans l’espace est composé de deux-roues que l’on peut motoriser à l’aide de deux moteurs, d’une roue folle, d’un troisième moteur, d’une pince et de deux capteurs à ultrasons.
Ces deux capteurs peuvent nous permettre à la fois de situer le robot dans l’arène en mesurant la distance qui le sépare des barrières et de calculer la distance qui sépare le robot du totem à déplacer.
Pour ce faire, nous avons trouvé judicieux de placer un capteur sur le côté droit de notre robot pour mesurer la distance le séparant de la paroi de l'arène, et l’autre à l'avant du robot pour mesurer la distance le séparant du totem ou de la paroi frontale.
Pour avoir une idée de la forme de notre châssis, nous nous sommes d’abord intéressés à la fixation des deux-roues mobiles et de leurs moteurs propres.
Les moteurs ont pratiquement le même diamètre que les roues et nous avons estimé qu’il serait compliqué de les fixer sur le châssis sans que ce dernier ne touche le sol. Nous avons donc opté pour un châssis qui se situerait au-dessus des moteurs et des roues (ceux-ci fixés en dessous) et qui porterait la batterie et les autres composants électroniques.
Cela implique d’avoir un châssis avec une hauteur d’environ 7 cm par rapport au sol, ce qui est déjà un peu plus haut que la partie du totem utile à la prise. Nous avons donc cherché une solution qui permettrait de positionner la pince du robot plus bas que le châssis. Pour répondre à cette contrainte, l'objectif était de concevoir un bloc avant superposé. Un troisième moteur, placé à l'arrière, commande la rotation du bras pour lever ou baisser la pince. Celle-ci effectue ses mouvements verticaux au-dessus du capteur à ultrasons frontal, qui reste ainsi fixe et positionné au plus près du sol pour ne pas gêner la saisie du totem.
Dans cette configuration, il n’y avait pas de place pour fixer la roue folle à l’avant du châssis donc nous avons décidé de la fixer à l’arrière. Puisqu’un dessin vaut mieux que 1000 mots, voici la première représentation de notre robot :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/Mq6image.png)
Pour l’instant, nous avons imaginé le châssis et les pièces liant le troisième moteur et la pince construits avec des planches de médium que l’on peut découper au laser.
##### II) Vérifications des composants électroniques et programme - (Harshanaa et Lilian)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/bOkwhatsapp-image-2026-02-19-at-12-38-31.jpeg)
En parallèle de la discussion sur notre modèle, on a commencé par vérifier le bon fonctionnement de tous les capteurs et des moteurs utilisés dans le projet. Pour ce faire on a utilisé un programme test.
**Description du programme de test utilisé**
Ce programme Arduino permet de contrôler un petit système robotique composé de deux moteurs KTECH (pour le déplacement), d’un moteur Dynamixel, d’un servo moteur qui commande une pince et de deux capteurs à ultrasons qui renvoient la distance qui les sépare d'un potentiel obstacle.
Au démarrage, le programme initialise les communications avec les moteurs et prépare les capteurs. Ensuite, dans la boucle principale, le robot mesure en permanence la distance des obstacles grâce aux capteurs à ultrasons.
Le fonctionnement du robot alterne toutes les deux secondes, dans un cycle total de quatre secondes :
- Pendant les deux premières secondes, les deux moteurs KTECH tournent vers l’avant et la pince s’ouvre.
- Pendant les deux secondes suivantes, les moteurs tournent en arrière et la pince se ferme.
Les capteurs à ultrasons permettent d’arrêter les moteurs ou la pince : si un obstacle est détecté à moins de 8 cm, les moteurs s’arrêtent ou la pince cesse de fermer/s’ouvrir selon le capteur qui détecte l’obstacle (les deux capteurs ont des rôles différents).
**Objectif de ce test :**
- **Vérifier l'intégrité du matériel** : S'assurer qu'aucun composant (cartes Arduino, shields, moteurs, capteurs, pince) n'est défectueux.
- **Valider le câblage** : Tester si toutes les connexions électriques (bus CAN, alimentation 12V et 5V, signaux des capteurs, UART) sont correctes et sécurisées.
- **Configurer l'environnement de développement :** Installer correctement l'IDE Arduino, les bibliothèques spécifiques.
- **Comprendre l'architecture de communication :** Le programme utilise la voie de communication UART-USB (via le convertisseur) plutôt que le câble USB standard de l'Arduino, car le shield Dynamixel parasite cette dernière. Cela permet d'apprendre à dialoguer avec la carte en mode autonome.
- **Se familiariser avec la programmation** : Le code fourni sert de base de travail et d'exemple.
- **Observer le comportement attendu** : Le programme example.ino a une logique simple (ouverture/fermeture de la pince, rotation des moteurs, réaction aux obstacles).
Le respect de ce comportement par le robot valide le bon fonctionnement global du système. Cela confirme que les moteurs KTECH reçoivent leurs commandes de vitesse via le CAN, que le moteur Dynamixel répond aux consignes de position, que les capteurs à ultrasons renvoient des informations correctes et que la pince est convenablement alimentée et commandée.
#### **2ème séance (05/03/2026) : **
##### I) Organisation de la séance
Entre-temps, Louisa a créé un espace de travail commun sur ClickUp afin que l’on puisse mieux s’organiser grâce à la création d’un Gantt et regrouper toutes les informations importantes.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/capture-decran-2026-05-28-185412.png)
Voici le lien vers notre [Gant sur ClickUp](https://sharing.clickup.com/90152441724/g/h/2kyr25vw-615/40f66ccb3c8ca3e)
Durant cette deuxième séance, nous nous sommes réparti le travail de cette manière :
· **Partie mécanique :** détermination du modèle des dimensions précises de chaque pièce composant le châssis
- Baptiste
- Nolann
- Lounis
· ** ****Electronique/informatique :** Tests de composants, étude des capteurs à ultrasons et développement de la logique du code
- Louisa
- Harshanaa
- Lilian
##### II) Partie mécanique : Schéma et dimensions précises du châssis - (tout le monde)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/schema-projetrob3-2.png)
Schéma du prototype du robot
Pour déterminer toutes les dimensions nécessaires à la conception de notre châssis, nous nous sommes basés sur les dimensions renseignées sur les fiches techniques des composants à notre disposition. Nous avons trouvé ses fiches techniques sur Internet et le wiki.
**Support des moteurs des roues (n°1)**
Tout d’abord, nous nous sommes rendu compte que les pièces que nous avions imaginé pour soutenir les moteurs des roues, allaient soutenir en réalité la partie du moteur qui tourne. C’est très dérangeant car cela aurait entraîné des frottements et gêné la rotation des roues. Nous avons donc décidé de les supprimer. Les moteurs seront donc seulement fixés sur une pièce en bois à l’aide de 4 vis. Voilà une représentation de cette pièce :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/OHMimage.png)
Cette pièce sera fixée sous la base du châssis à l’aide de créneaux et de colle si besoin. (Le bas de la pièce est à 10mm du sol)
**Dimensionnement de la base (n°2)**
Ensuite, il a fallu décider de la disposition des différents composants tels que la batterie, la carte Arduino, le moteur restant et les capteurs pour dimensionner la base du châssis.
On choisit finalement les dimensions représentées sur ce schéma :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/Anfimage.png)
**Fixation de la pince (n°3)**
Nous avons ensuite dimensionné les pièces qui relient le moteur à la pince :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/MOXimage.png)
Il s’agit de deux pièces en bois que l’on fixerait ensemble soit en les vissant, soit en les collant.
Leur épaisseur n’est pas précisée sur ce schéma mais elle est de 6 mm chacune afin que l’on ait une épaisseur d’au moins 1,2 cm afin d’y fixer la pince qui présente cet écartement à l’endroit prévu pour sa fixation.
Finalement, lorsque l’on regroupe toutes les informations, on obtient ce schéma :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/XnHimage.png)
**Dimensionnement des créneaux :**
Pour dimensionner les créneaux nous avions dû avoir besoin de connaître la dimension des créneaux et des trous pour que ces derniers puissent former une liaison encastrement. Grâce aux tests effectués par le groupe de Valentine, nous avions conclu qu'une largeur de 0.2 mm plus grande que le trou était nécessaire pour avoir une liaison encastrement qui ne bouge pas.
Nous avions donc fait des créneaux de 6.2 mm de largeur espacés de 6 mm entre eux.
Dans le châssis, les trous (censés accueillir les créneaux) font donc 6 mm de longueur et de largeur tandis que les pleins séparant les trous font 0.2 mm de plus de longueur.
Nous avons répété ce principe pour tous les créneaux.
##### III) Partie Electronique et Informatique - (Lounis)
Lounis a également fabriqué le câble qui permet de brancher le servo-moteur à la carte Arduino grâce à du soudage. En effet, on a commencé avec deux câbles à 3 fils chacun qu'on cherche à souder entre eux pour faire un seul câble. On place d'abord les gaines thermo rétractables sur la fin de chaque fil (pour un seul câble), ensuite on va chercher à souder les trois fils de chaque câble avec les 3 fils de l'autre câble de façon à ce que la face de l'embout en plastique d'un des câbles soit du côté métallique et que l'embout en plastique de l'autre câble soit du côté non métallique et que le fil de droite d'un câble corresponde au fil de droite de l'autre câble dans cette même position pour éviter une torsion des câbles lors du branchement. On les soude ensuite dans cette même position de façon à ce que les fils préalablement dénudés de cuivre ou autre métal conducteur s'entortillent autour du métal conducteur de l'autre fil (celui qu'on veut souder de sorte à respecter la position expliquée avant), puis on chauffe le métal à souder qu'on laisse couler à l'intérieur de l'entortillage des deux fils, de sorte à ce que, lorsque le métal refroidit, les fils de métal conducteur soient soudés entre eux. Puis une fois cette étape terminée pour tous les fils, on chauffe la gaine thermo rétractable à l'endroit du soudage et on répète l'opération pour les 3 fils.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/m95image.png)
#### 3ème séance (26/03/2026) :
##### I) Finalisation de la conception mécanique - (Lounis, Nolann, Baptiste)
**a) Finalisation du dimensionnement**
**Supports des capteurs (n°4)**
Pour le maintien des capteurs à une hauteur de 40mm du sol, nous avons décidé de réaliser 2 fois la même pièce pour le capteur du côté et celui de devant. Cette pièce étant accrochée au bord du châssis avec des encoches.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/D7Kimage.png)
**Support du moteur du support de pince (n°5)**
Le moteur déplaçant la pince est fixé de manière similaire aux moteurs des roues. Sa pièce de support étant accrochée à la base par le dessus avec des encoches.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/20260326-124845.jpg)
**b) Modélisation CAO**
À partir des schémas côtés, nous avons utiliser le logiciel SolidWorks pour modéliser toutes nos pièces en 3D. Cette étape est nécessaire pour passer à la création des fichiers pour la découpe laser.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/bras-robot.png)
##### II) Test des composants et de l'arène - (Louisa, Harshanaa)
##### Conditions expérimentales
***1er expérimentation : ***
***[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/20260326-103813.jpg)***
Première expérimentation sur l'étude des capteurs
L'analyse du comportement des capteurs montre qu'ils sont peu sensibles au bruit ambiant et aux mouvements environnants. Bien que des erreurs de mesure apparaissent ponctuellement lors du déplacement du robot ou en présence d'obstacles parasites proches, comme des membres de personnes ou autres, le signal se restabilise très rapidement. Cependant nous avons identifiées plusieurs contraintes techniques majeures :
- **Seuils de détection :** Un objet est considéré comme trop proche s'il se situe à moins de 4 cm du capteur, et hors de portée au-delà de 135 cm.
- **Sensibilité aux obstacles fins :** Les composants ne parviennent pas à détecter les structures de faible épaisseur
- **Orientation émetteur/récepteur :** Le positionnement physique du capteur influe directement sur la qualité de la réception ; une mauvaise orientation empêche une captation correcte du signal
Nous avons donc plusieurs points à prendre en compte suite à ce premier essaie. Sur le plan mécanique, le positionnement des capteurs sera très important afin de garantir la qualité et la fiabilité du signal. Côté programmation, nous devrons faire attention aux seuils de proximité pour éviter que le robot ne s'approche trop du totem; cette contrainte logicielle pourra néanmoins être compensée par l'ajustement mécanique de la pince et de son socle.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/3uqimage.png)
Seconde expérimentation sur l'étude des capteurs - arène
Lors des essais menés dans l'arène, les composants ont été positionnés de manière précise : le capteur a été placé à 19,5 cm du bord en longueur et à 25,5 cm en largeur, tandis que le totem se situait à 13,2 cm en longueur et 30 cm en largeur. Pour garantir la rigueur des résultats, une correction d'environ 6,5 cm a été intégrée aux calculs afin de prendre en compte l'épaisseur du dispositif de mesure.
Les tests de détection mettent en évidence une excellente stabilité face aux parois de l'arène, avec une distance mesurée constante entre 176 et 180 cm. En revanche, la détection du totem dépend fortement de son orientation. Lorsqu'il est mal aligné, le signal rebondit de manière défavorable et le capteur cible le mur du fond (affichant 179 à 180 cm) au lieu de l'objet.
Dans son comportement en général, le capteur se montre peu sensible aux bruits et aux mouvements environnants. Bien que des erreurs de mesure apparaissent ponctuellement lors des déplacements ou en présence d'obstacles très proches, le signal bénéficie d'une re stabilisation rapide après perturbation.
##### III) Développement informatique - (Lilian)
##### a) logigramme et logique de programmation
**Organisation générale**
- Gestion des déplacements
- Gestion de la rotation
- Gestion du bras et de la pince
Ces fonctions sont coordonnées par une logique principale qui enchaîne les actions en fonction des objectifs et des données des capteurs.
##### Logique de fonctionnement
**Déplacement**
- Le robot avance à vitesse constante
- Deux modes possibles
- pendant une durée donnée
- jusqu’à atteindre une distance mesurée par le capteur
- Utilisation des capteurs pour ajuster la trajectoire si nécessaire
**Rotation**
- Le robot doit pouvoir effectuer une rotation de 90° à gauche ou à droite
- La rotation peut être réalisée
- soit par temporisation (moins précis)
- soit en utilisant les capteurs pour corriger l’angle
- Une correction peut être appliquée pour compenser les erreurs liées au sol ou aux moteurs
**Manipulation (bras + pince)**
- Séquence de prise
- fermer la pince
- lever le bras
- Séquence de dépôt
- baisser le bras
- ouvrir la pince
- Respect strict de l’ordre des actions
##### **Logigramme**
Début
→ Initialisation
→ Avancer
→ Vérifier distance (capteur)
→ Si condition atteinte
→ Arrêt
→ Avancer vers objectif
→ Action bras/pince
→ Fin ou boucle
##### b) schéma du trajet du robot
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/E87image.png)
##### IV) Bilan séance
**Bilan**
Cette troisième séance a permis de finaliser notre préparation théorique, avançant sur la partie mécanique avec la modélisation sur SolidWorks, la partie électronique avec les différents tests sur les capteurs et la partie sur la logique informatique du robot en établissant son logigramme et le squelette du programme Arduino. Cette séance nous permet donc d'aborder les premières étapes sur la phase de montage et les premiers essais pratiques.
**Objectif prochaine séance**
- Découpe des pièces du châssis
- Commencer montage mécanique
- Essais programme
#### **4ème séance**
##### I) Partie mécanique
Après avoir finalisé la modélisation des pièces sur SolidWorks car il nous manquait certaines mesures et fait des tests de découpe avec la découpeuse laser Trotec Speedy 100, nous avons découper les différentes pièces qui composent le châssis et tout s’est emboité à merveille !
Voici notre bébé :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/LH5image.png)
Ne pas faire attention aux énormes vis qui traversent les roues et leur moteur, il s’agit d’un bug d’affichage.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/whatsapp-image-2026-05-28-at-20-24-25.jpeg)
Photo du châssis après la découpe
Nous avons tout de même relevé un petit problème : les pièces supports des capteurs à ultrason sont encastrées dans le châssis à l’aide de créneaux, mais contrairement aux autres pièces, sur les bords du robot. Les trous accueillant les créneaux ne sont pas fermés et les pièces peuvent donc plus facilement bouger car rien ne les retient vers l’extérieur. Le serrage ne suffit malheureusement pas à maintenir les supports si on les pousse doucement.
Il nous faudra trouver une solution avant la prochaine séance.
##### **Séance 5 :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/whatsapp-image-2026-05-28-at-20-24-54.jpeg)
**1) Fixation du support des capteurs:**
Afin d’empêcher les supports des capteurs de bouger, nous avons décidé de coller des bâtonnets sur les côtés de notre châssis, au niveau des encoches prévues pour installer les pièces supportant les capteurs. Il n’y a désormais plus de problème de mouvement des supports ni des capteurs. Cette solution a permis de renforcer le serrage déjà assuré par nos encoches lors de la mise en place des supports de capteurs.
**2) Mise en plase de la batterie:**
La batterie est le composant le plus lourd de notre robot. Nous avons choisi de la placer à un endroit stratégique afin de faciliter le câblage, tout en assurant une bonne répartition de la masse pour garantir l’équilibre du robot. Cet emplacement permet également de retirer et de remettre facilement la batterie pour la recharger.
De plus, afin d’éviter qu’elle ne bouge pendant les déplacements du robot, nous avons utilisé du scratch. Nous avons collé une bande de scratch sur le châssis ainsi qu’une autre sur la batterie, ce qui permet de la maintenir solidement en place.
**3) Ajout d'un interrupteur:**
Nous avons ajouté un interrupteur afin de contrôler l’alimentation de la batterie de notre robot. Cela nous permet d’allumer ou d’éteindre facilement le système sans avoir à débrancher les câbles à chaque utilisation. Cette solution rend le robot plus pratique et plus rapide à utiliser.
L’interrupteur améliore également la sécurité du montage, car il permet de couper rapidement l’alimentation en cas de problème ou lors des manipulations du robot. Nous avons placé cet interrupteur à un endroit facilement accessible.
**4) Fixation des capteurqs sur leur support:**
L’objectif de base était de fixer les capteurs sur le support en bois à l’aide de vis. Cependant, il a été difficile de trouver des vis suffisamment petites, fines et longues permettant de fixer les capteurs sans risquer de les abîmer. Nous avons donc choisi de les fixer à l’aide de serre-câbles, comme on peut le voir sur l’image.
Nous avons utilisé deux serre-câbles par capteur afin de les maintenir solidement en place et de les serrer suffisamment pour éviter tout mouvement. Cela permet également de conserver un bon alignement des capteurs et d’éviter qu’ils ne se déplacent ou ne s’inclinent, ce qui pourrait fausser les mesures et modifier l’angle de détection du capteur.
**5) Test fonctionnement des moteurs:**
Après avoir enfin terminé l’assemblage du robot, nous avons procédé à plusieurs vérifications afin de nous assurer que les moteurs fonctionnaient correctement. Nous avons notamment testé si les roues tournaient correctement pour permettre au robot d’avancer, ainsi que le mécanisme de la pince pour vérifier qu’elle pouvait se lever, s’ouvrir et se fermer correctement.
Le test de la pince était celui qui nous inquiétait le plus, car une mauvaise gestion du moteur pouvait entraîner un mouvement trop important de la pince, risquant ainsi de heurter le capteur situé juste en dessous et de l’endommager. Nous avons donc décidé de tester le code sans monter la pince sur le châssis dans un premier temps. Cela nous a permis de vérifier que le moteur tournait selon l’angle attendu et que la pince s’ouvrait et se fermait correctement avant de l’assembler définitivement sur le robot.
##### **Séances supplémentaire**
Les dernières séances ont été principalement consacrées à la résolution de dysfonctionnements complexes lors des phases de navigation et d'approche du totem.
Dans un premier temps, d'importantes déviations de trajectoire ont été constatées : le robot ne parvenait pas à avancer en ligne droite. De plus, lors des phases de pivot, le capteur à ultrasons latéral transmettait des données erronées, laissant croire au programme que le robot était trop proche des parois de l'arène. En tentant de corriger sa position pour revenir à la distance de consigne (30 cm), le robot finissait par dévier totalement de sa course pour aller percuter le mur latéral.
Les premières investigations se sont orientées vers un mauvais calibrage du correcteur proportionnel implanté dans le code. Cependant, après des analyses approfondies, l'origine du problème s'est révélée être d'ordre électrique et non logiciel. En effet, la pince exigeait une tension de démarrage et un courant trop élevés lors des sollicitations. Cette forte demande énergétique créait une chute de tension généralisée, privant les autres composants et capteurs d'une alimentation stable.
Une fois la pince débranchée pour les tests de validation, le comportement global du robot s'est nettement amélioré et l'algorithme de navigation a pu s'exécuter correctement.
Il nous a ensuite suffit de calibrer les distances que les capteurs devaient mesurer afin de préciser la trajectoire et atteindre les positions souhaitées. Nous y sommes arrivés après de nombreux tests, de même pour calibré le gain de notre correcteur pour faire avancer notre robot à exactement 30cm du bord.
Les prochaines étapes consisteront à optimiser la distribution de puissance pour isoler l'alimentation de la pince.
### Conclusion :
Ce projet de robotique ROB3 (2025-2026) a permis de mener à bien l'intégralité du cycle de conception d'un système mécatronique autonome, depuis l'analyse du cahier des charges jusqu'à la phase d'assemblage et de test en conditions réelles.
L’objectif initial, qui consistait à réaliser un robot mobile capable de naviguer dans une arène pour saisir et déplacer un totem, a nécessité une synergie constante entre les pôles mécanique, électronique et informatique.
Sur le plan technique, plusieurs défis majeurs ont été surmontés :
- **En mécanique :** Le passage de la modélisation théorique sur SolidWorks à la fabrication par découpe laser a imposé une gestion rigoureuse des tolérances d'emboîtement. L'équipe a également su faire preuve de réactivité en ajustant l'architecture pour éliminer le jeu mécanique des supports de capteurs et en sécurisant la fixation de la pince.
- **En électronique et informatique :** La phase de caractérisation a mis en évidence les limites physiques des capteurs à ultrasons, notamment leur sensibilité à l'angle d'incidence du totem. Ces contraintes expérimentales ont été intégrées avec succès dans l'algorithme de commande sur Arduino Mega afin d'optimiser les trajectoires et de sécuriser les mouvements verticaux du bras motorisé.
Au-delà des résultats techniques, cette expérience a constitué un excellent exercice de gestion de projet. L'utilisation d'outils de planification comme le diagramme de Gantt sur ClickUp, associée à une répartition claire des rôles (incluant un poste clé de "Joker" pour pallier les imprévus), a garanti le respect des échéances et la cohésion de l'équipe.
### **Notices :**
##### ***Toi aussi tu veux créer ton propre robot autonome ? Pas de panique ! Voici une notice de fin qui t'expliquera les étapes importante pour concevoir et réaliser ton robot mobile !*
##### **1. Liste du matériel à rassembler**
##### Composants Électroniques & Actionneurs
- **1 Carte Arduino Mega** équipée de 2 shields d'extension superposés.
- **2 Moteurs KTECH** (pour la propulsion des deux roues motrices).
- **1 Roue folle** (placée à l'arrière pour servir d'appui et assurer l'équilibre).
- **1 Moteur Dynamixel** (qui gère la rotation et le levage du bras de la pince).
- **1 Pince servo-motorisée (Modèle 3551)** pour attraper le totem.
- **2 Capteurs à ultrasons** (pour mesurer les distances à l'avant et sur le côté droit).
- **1 Batterie 12V** (alimentation générale) associée à un **interrupteur mécanique**.
- **1 Convertisseur UART-USB** (indispensable pour communiquer avec le PC de manière autonome, car le shield Dynamixel crée des interférences sur le port USB standard de l'Arduino).
##### Matériaux & Consommables
- Des planches de bois médium (MDF) d'une épaisseur de **6 mm**.
- De la gaine thermorétractable et du fil d'étain (pour les soudures).
- Des colliers serre-câbles en plastique (type Rislan), du ruban adhésif auto-agrippant (scratch) et de la colle à bois.
##### **2. Conception & Fabrication Mécanique (CAO & Découpe laser)**
##### Étape 2.1 : Dimensionnement et architecture du châssis
1. **Géométrie de la base :** Dessiner une base rectangulaire de 250 mm de longueur par 150 mm de largeur.
2. **Garde au sol :** Positionner la plateforme du châssis *au-dessus* des blocs moteurs afin d'obtenir un plateau situé à environ **7 cm du sol**. Cela offre l'espace nécessaire pour loger la batterie et l'électronique de manière stable sur le dessus.
3. **Bloc Avant Superposé :** À l'avant du robot, implanter les composants de bas en haut :
- Le capteur à ultrasons frontal (au plus près du sol, à environ 2 à 4 cm).
- La pince, qui doit effectuer ses mouvements juste au-dessus du capteur.
- Le moteur Dynamixel de levage fixé juste derrière la pince.
4. **Roue arrière :** Fixer la roue folle tout à l'arrière sous le châssis, l'espace avant étant totalement occupé par le bloc de préhension.
##### Étape 2.2 : Règle d'assemblage par créneaux (Tolérances d'encastrement)
Pour assembler les plaques de bois MDF par emboîtement sans qu'elles ne bougent, applique la règle expérimentale suivante lors du dessin des pièces :
- Les trous (mortaises) sur le châssis doivent mesurer exactement **6,0 mm × 6,0 mm**.
- Les créneaux (tenons) des pièces de support doivent être tracés à **6,2 mm de largeur**.
- *Note technique :* Cette différence de **+0,2 mm** compense l'épaisseur de matière brûlée par le faisceau de la découpeuse laser (le trait de coupe) et assure un assemblage serré très robuste.
##### Étape 2.3 : Modélisation et Découpe
1. Modélise l'ensemble des pièces sur un logiciel de CAO (comme **SolidWorks**) en respectant les cotes définies.
2. Exporte les dessins au format vectoriel et découper les plaques de MDF de 6 mm sur une découpeuse laser.
##### **3. Électronique & Câblage**
##### Étape 3.1 : Soudure de la rallonge de la pince
Si ton câble de servo-moteur de la pince est trop court pour atteindre la carte électronique, il faut que tu fabriques une rallonge propre :
1. Prendre deux nappes de 3 fils et dénuder les fils métalliques aux extrémités.
2. Glisse un morceau de **gaine thermo rétractable** sur chaque fil avant de les assembler.
3. Entortille les fils conducteurs en respectant scrupuleusement les correspondances (Alimentation, Masse, Signal) pour éviter tout court-circuit.
4. Réalise une soudure à l'étain propre, faire glisser la gaine isolante sur la soudure et la chauffer doucement pour fixer le tout.
##### Étape 3.2 : Implantation et sécurisation des composants
1. **Fixation des capteurs :** Ne pas visser les capteurs à ultrasons directement avec des vis métalliques sous peine de fendre leur circuit imprimé. Fixer chaque module sur sa platine en bois à l'aide de **deux colliers serre-câbles**. Cela maintient parfaitement l'alignement optique.
2. **Verrouillage des supports :** Les supports des capteurs étant situés sur les bords extérieurs du châssis, coller de petits bâtonnets de bois contre les encoches. Cela condamne l'ouverture vers l'extérieur et élimine tout jeu mécanique.
3. **Fixation batterie :** Fixer la batterie (le composant le plus lourd) au centre arrière du robot à l'aide de bandes de scratch adhésives. Elle restera stable lors des accélérations tout en étant facile à retirer pour la recharge.
4. **Circuit de puissance :** Brancher l'interrupteur en série sur le câble d'alimentation positif (+) reliant la batterie à la carte de puissance pour pouvoir couper l'énergie instantanément en cas de bug.
##### Étape 3.3 : Schéma visuel du câblage complet
Voici un schéma visuel du câblage complet du kit ROB3 et les points à retenir:
- Ordre impératif : toujours couper l'alimentation avant de brancher/débrancher quoi que ce soit, et débrancher aussi le câble USB du PC (il alimente aussi).
- Bus CAN (fils bleu + jaune) : les deux moteurs KTECH se branchent en parallèle sur le bornier bleu du shield CAN — fil bleu sur le contact extérieur (CANH), fil jaune sur le contact intérieur (CANL). Bien dénuder les câbles suffisamment pour qu'ils touchent le fond du bornier.
- Pince 3551 — 4 fils distincts : rouge (+5V), noir (GND), vert (retour position → A15), blanc (commande servo → PIN 9), tous accessibles via le shield Dynamixel.
- Capteurs ultrason : se branchent sur le connecteur d'E/S logiques 22–53 de l'Arduino MEGA. Capteur 1 sur PIN 22/23, capteur 2 sur PIN 42/43.
- Interrupteurs du shield Dynamixel : sur "Upload" + "Off" pour téléverser le programme, puis sur "Dynamixel" + "On" pour l'utilisation normale. Ne pas oublier le reset Arduino après.
- Convertisseur UART-USB : sert uniquement pour le moniteur série (Serial.println remplacé par PC\_SERIAL.println), ne pas brancher le fil rouge.
##### **4. Caractérisation des Capteurs & Logique Informatique**
##### 4.1 : Composer avec les limites physiques des Ultrasons
Les phases de tests mettent en avant plusieurs critères importants à intégrer dans ton code final. Puisque ton robot va devoir pivoter et avancer sans foncer dans les murs, tu dois connaître les limites réelles de tes composants dans leur futur environnement.
1. **Prépare le terrain :** Place ton capteur à l'extrémité de ta zone de roulement, à sa hauteur finale (fixé sur le robot ou sur un support à la même hauteur). Munis toi d'un mètre ruban pour vérifier les vraies distances.
2. **Mesure la zone à vide :** Fais un premier relevé face au point le plus éloigné de ta zone (le mur opposé). Intègre une correction d'environ 6,5 cm dans tes calculs pour compenser l'épaisseur physique du capteur lui-même. Si le mur est par exemple à 180 cm et que ton capteur affiche entre 176 et 180 cm, la détection est correcte.
3. **Détermine la zone aveugle et la portée maximale :** Approche un obstacle de plus en plus près du capteur. Tu vas remarquer qu'en dessous d'une certaine distance le capteur ne capte plus rien (c'est sa zone aveugle). Recule le ensuite au maximum : tu verras que ses mesures commencent à devenir complètement instables. Ta zone de roulement utile pour les obstacles se situe donc entre ces deux bornes.
4. **Teste la sensibilité à l'alignement :** Place ton objet au milieu de ta zone de roulement et tourne le légèrement de biais. Regarde ce qu'affiche le capteur : si le signal ricoche sur les côtés du totem et se perd, ton capteur va t'afficher la distance du mur du fond au lieu de celle de ton objet
##### Étape 4.2 : Structure de l'algorithme (Arduino)
Voici l'organigramme du programme Arduino :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/Sj5image.png)
##### Conclusion
Si tu as bien suivi toutes ces étapes, ça devrait fonctionner comme ça l'a été pour nous. Félicitations !
La réalisation de ce robot autonome t'aura conduit à traverser toutes les étapes fondamentales d'un projet de robotique mobile : conception mécanique sous CAO, découpe laser, câblage électronique, caractérisation de capteurs, et programmation embarquée sur Arduino.
Chaque phase a ses pièges propres — les tolérances d'assemblage à respecter au millimètre, les soudures à soigner pour éviter tout court-circuit, les zones aveugles des ultrasons à intégrer dans la logique du programme, autant de défis qui vont te forcer à croiser les savoirs de plusieurs disciplines.
Le résultat est un robot capable de se repérer dans son environnement et de saisir un objet de manière autonome. C'est une base solide à partir de laquelle de nombreuses améliorations sont envisageables : ajout d'une communication Bluetooth ou Wi-Fi pour le piloter à distance, remplacement des capteurs ultrasoniques par des lidars pour une cartographie plus précise, ou encore amélioration de l'algorithme de préhension pour s'adapter à des objets de formes variées.
Au-delà du robot lui-même, ce projet t'aura appris à transformer une idée en objet fonctionnel en passant par toutes les étapes d'un cycle de développement réel.
##### Résultat final
Voici la vidéo finale de notre robot : [video\_finale](https://1drv.ms/v/c/ec60f9ad3f8edb24/IQB-e5tubFcOQp7oUknZ_tw7ASQaWoWUczw-ToMD8qyxPcM?e=rXHTC4 "Video_finale_du _robot")
Voici nos fichiers Solidworks pour la conception de notre robot :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/YfEdownload.svg)
![]()![]()
# Groupe 5 - Lawny, Clovis, Pauline, Ludovic, Marin et Valentine
#### **Informations**
- CHEF DE PROJET: Lawny ICHANE
- RESPONSABLE INFORMATIQUE: Ludovic MAILLERE ludovic.maillere@etu.sorbonne-universite.fr
- RESPONSABLE MECANIQUE : Clovis FRESCURA clovis.frescura@etu.sorbonne-universite.fr
- RESPONSABLE ELECTRONIQUE : Marin GUENON--MONIER marin.guenon--monier@etu.sorbonne-universite.fr
- Pauline ROUGEAU,
- RESPONSABLE WIKI Valentine MIGUEL, valentine.miguel@etu.sorbonne-universite.fr
Du 19/02 au 29/05/2026
#### **Contexte**
Cette documentation présente notre solution pour concevoir et fabriquer un robot capable de réaliser un exercice défini dans le cahier des charges disponible dans ce document : [Projet de robotique ROB3 - 2026.pdf](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1658)
En résumé, la tâche consiste à déplacer un objet depuis sa configuration initiale vers une configuration finale, à l’intérieur d’une arène.
#### **Rendu final**
Ci dessous une idée du rendu du projet
[rendu\_final.mp4](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1876)
#### **Matériel**
Un kit composé principalement de :
\- Une pince 3551 fournie en kit, avec un servo moteur intégré.
\- Deux moteurs KTECH MS4015-V3 contrôlables en vitesse et intégrant une mesure
de position (prévus pour les roues)
\- Un moteur Dynamixel commandable en position (prévu pour le bras)
\- Deux roues Pleine Guitel Hervieu Ø 50mm destinées à être motorisée et une
roue pivotante Guitel Hervieu, Ø 50mm.
\- Un carte Arduino MEGA + un shield SEED pour la communication via un bus
CAN avec les moteurs + un shield DYNAMIXEL
\- Deux capteurs de distance à ultrasons HC-SR04
\- Une batterie RS PRO 12V 1.2Ah. Un kit de connexion permettant d’alimenter
l’Arduino avec la batterie.
Dans le FABLAB Sorbonne Université, sont également disponibles :
\- Des planches de médium, 300mmx600mm ép. 6mm ou 3mm, découpables au
LASER dans le FABLAB.
\- Des petits composants électroniques et mécaniques standard.
\- Du filament pour les imprimantes 3D du FABLAB.
##### **Machines utilisées**
- Découpeuse laser Trotec Speedy 100
- Imprimante 3D Prusa
##### **Codes du Projet : **
**[projetrob\_arduinoAcc.ino](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1874)**
**[Ktech\_motor.cpp](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1873)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1875)**
**[Ktech\_motor.h](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1875)**
#### **Journal de bord**
##### **Séance du 19/02/2026**
##### Reflexion générale
Au cours de cette première séance nous avons découvert le projet et son cahier des charges. Nous avons notamment réfléchi à une solution mécanique pour attraper le totem qui soit la plus simple possible. Nous nous sommes arrêtés sur une solution reposant sur une pince dont le rôle sera de se fermer autour de l'objet puis de le soulever par une simple inclinaison vers le haut, permise par le moteur Dynamixel commandable en position auquel la pince sera liée.
##### Partie mécanique ( Lawny et Clovis )
Une réflexion a été faite sur le chassis et l'emplacement des composants du robot dans ce chassis. Plusieurs solutions sont présentées ci dessous. Ces chassis sont sujets à être de nouveau modifiés par la suite car ils ne prennent pas encore en considération les dimensions des composants ni les méthodes de fixation. Ils nous permettent toutefois d'avoir une vision générale de l'apparence du robot ainsi que des composants à intégrer au chassis.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/croquis-robot-seance1.jpeg)
##### Partie électronique (Marin)
Nous nous sommes assurés que le matériel fourni était fonctionnel en suivant les instructions données dans les consignes du projet.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/Re6image.png)[test composants video.mp4](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1877)
##### Partie organisation ( Pauline, Ludovic et Valentine )
En parallèle, le reste des membres du groupe se sont chargés de l'organisation. Ludovic et Pauline ont crée un diagramme de Gantt et Valentine s'est chargée de remplir cette page de documentation.
Voici le diagramme de Gantt initial:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/V6ximage.png)
##### Bilan et objectifs lors la prochaine séance:
Comme prévu, nous avons lors de cette première séance testé les composants électroniques et nous nous sommes mis d'accord sur une solution mécanique générale (idée de bras de levier). Des premiers croquis ont été faits mais pas finalisés, nous comptons revenir sur cette partie lors de la prochaine séance. Concernant la partie informatique, nous nous y sommes pas penchés assez longtemps pour s'arrêter sur une idée. Au cours de la prochaine séance, nous avons pour objectifs d'accomplir les missions suivantes:
**Mécanique ( Lawny, Clovis et Valentine )**: Commencer le dimensionnement du châssis, la modélisation Solidworks et faire des croquis de la solution.
**Informatique ( Pauline et Ludovic ):** Faire un organigramme
**Electronique ( Marin )**: Regarder comment se pilotent les composants à notre disposition. Par exemple, trouver comment ouvrir la pince, comment récupérer les données du capteur à ultrasons...
**Tâches diverses ( Valentine )**: Apprendre à utiliser la découpeuse laser et trouver les réglages permettant un ajustement serré entre deux pièces.
##### **Séance du 05/03/2026**
Le diagramme de Gantt n'a pas évolué depuis la dernière séance
##### Partie mécanique ( Lawny, Clovis et Valentine ):
Pour concevoir le châssis, du robot, nous nous sommes appuyés sur un travail en duo entre Lawny et Clovis. Le duo se mettait d'accord sur une solution ( par exemple le choix de faire des assemblages par tenons et mortaises ) et ensuite Lawny modélise sur Solidworks, appuyé des mesures de dimensionnement de Clovis ( par exemple, longueur du tenon) Au cours de cette séance, le duo a réussi à concevoir un début de châssis pouvant accueillir les roues du robot.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/capture-decran-2026-03-26-111246.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/1JPimage.png)
Un travail a été fait concernant l'assemblage des planches par tenons et mortaises en utilisant la fonction de SolidWorks. L'équipe a rencontré quelques problèmes en utilisant cette fonction. Aussi, il a fallu faire attention à que le châssis ne touche pas le sol.
Concernant le croquis, on a finalement décidé de ne pas perdre de temps à faire un croquis détaillé à la main avec les dimensions de chaque composant car on avait à disposition les pièces en taille réelle dans SolidWorks ce qui nous a particulièrement été utile. On a donc conçu nos pièces autour de ces composants existants.
##### Tâches diverses: Découpeuse Laser et premiers assembages ( Valentine )
Nous nous sommes intéressés en parallèle à la découpeuse laser. L’objectif était notamment de déterminer les réglages nécessaires pour que l’assemblage par tenons et mortaises soit suffisamment précis et serré, afin que les pièces restent solidaires par la suite. A l'issu de la séance, un premier test a pu être réalisé.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/img-9645.jpg)
Pour ce premier test, nous avions choisi un jeu de 0.0 mm entre les tenons et mortaises. L'ajustement est glissant alors que nous souhaitions davantage un ajustement serré afin que les pièces tiennent entre elles. Il faudra donc tester avec d'autres dimensions pour trouver le réglage parfait. C'est un travail qui pourra être continué sur la prochaine séance.
On a également commencé à assembler ce qui pouvait déjà être assemblé. Nous avons ainsi lié chacun des 2 moteurs aux roues arrières, essentiellement à l’aide de vis, et par l’intermédiaire de 2 pièces imprimées en 3D qui ont pour rôle d’assurer le bon guidage.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/assmeblage-roue-photo.jpg)
##### Code (Ludovic et Pauline) :
L'objectif était de trouver comment on allait contrôler les moteurs avec les contraintes imposées. Pour ce faire, on a commencé par dessiner des schémas et écrire étape par étape les mouvements qu'on voulait faire. Ensuite, on a réalisé un organigramme pour organiser nos idées et faciliter le codage ultérieur, qu'on a presque terminé.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/7TSimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/flowchart-1.jpeg) [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/wmUimage.png)
##### Partie électronique (Marin):
En première partie, j'ai soudé le fil du moteur dynamixel. Puis je me suis attelé à comprendre le fonctionnement de l'Arduino pour piloter les différents composants (pinces, capteurs us, moteurs, etc..).
##### Bilan et objectifs lors la prochaine séance:
Les parties informatique et électronique avancent globalement comme prévu. Concernant la partie mécanique, nous nous sommes finalement toujours pas attardé au croquis, on envisage de s'en occuper à la prochaine séance maintenant que plusieurs idées ont été modélisées sur Solidworks. Nous avons été ralenti à cause de la conception des assemblages tenons et mortaises sur Solidworks mais restons dans les temps. Une bonne base pour le robot a été modélisée. De premiers tests à la découpeuse laser ont été réalisés mais ils devront être finalisés à la prochaine séance.
Ci dessous nos objectifs pour la prochaine séance
**Mécanique ( Lawny, Clovis et Valentine )**: Continuer la modélisation du châssis en y assemblant la roue folle, les capteurs ultrasons et la carte Arduino. Faire un croquis de notre solution mécanique finale.
**Informatique ( Pauline et Ludovic ):** Finir l'organigramme et coder les fonctions principales.
**Electronique ( Marin )**: Etudier le fonctionnement des composants en utilisant le convertisseur UART-USB.
**Tâches diverses ( Valentine )** : Trouver les réglages parfaits pour un assemblage serré à la découpeuse laser.
##### **Séance du 26/03/2026**
Ci dessous le diagramme de Gantt mis à jour ( report d'une semaine de la mission "Croquis" )
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/5fzimage.png)
##### Partie code (Ludovic et Pauline) :
L'organigramme étant fini, on a fait tout l'algorithme avec une logique d'état différent du robot grâce a un switch case, ensuite séparer en un maximum de sous fonctions différente pour épurer la loop.
voici un extrait :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/lkkimage.png)
##### Partie électronique (Marin):
J'ai fini d'étudier le fonctionnement des différents composants du robot en utilisant le convertisseur UART-USB.
##### Partie mécanique (Clovis, Lawny et Valentine):
La conception Solidworks avance dans les temps. La modélisation du châssis a été terminée. Il ne reste plus qu'à modéliser le bras de levier entre le moteur Dynamixel et la pince. ( Clovis et Lawny )
En parallèle, nous nous sommes occupés de construire un croquis de notre solution à l'état actuel pour poser toutes les idées qui ont été conçues sur Solidworks. (Valentine) Ce croquis nous a aussi servi pour réfléchir à la façon dont nous souhaitions lier la pince au moteur Dynamixel, lui même fixé au chassis. Nous avons conçu une première version de ce bras. Il ne s'agit pas d'une version finale.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/ElZcroquis-robot-procreate.png)
##### Tests découpeuses laser (Valentine):
Nous avons finalisé les tests à la découpeuse laser débutés à la dernière séance.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/img-9645-1.jpg)
Nous avons cette fois ci décidé de faire des tests avec 0.1mm et 0.2mm de serrage. La solution 0.1mm permet un léger serrage alors que la solution 0.2mm permet un meilleur serrage. Le désassemblage des pièces reste en revanche possible en les tournant un peu ce qui signifie qu'il y a peut-être encore un meilleure réglage pour permettre aux pièces de se solidariser de manière plus forte. Pour notre cas, la solution à 0.2mm nous suffit.
##### Bilan et objectifs lors la prochaine séance:
Nous avançons globalement dans les temps par rapport à notre diagramme de Gantt. La conception mécanique devrait toucher le bout d'ici la prochaine séance tout comme le code.
**Mécanique ( Lawny, Clovis et Valentine )**: Concevoir le bras de liaison entre le moteur Dynamixel et la pince. Finir la conception mécanique et la valider en vue de l'étape de fabrication. Vérifier que les câblages et fixation entre chaque pièce soient réalisables. Découper les premières pièces.
**Informatique et électronique ( Pauline, Ludovic et Marin ):** Compiler et tester le code avec les différents moteurs et les capteurs.
##### **Séance du 9/04/2026**
Le diagramme de Gantt n'a pas évolué depuis la dernière séance
##### Partie mécanique (Clovis, Lawny et Valentine):
Le bras entre la pince et le moteur Dynamixel a pu être modélisé.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/zLGimage.png)
Nous nous sommes arrêtés sur une solution plus simple que présentée dans le croquis de la dernière séance. La solution finale est fabricable en une pièce par découpeuse laser. Nous avons directement pu fabriquer cette pièce et faire l'assemblage avec le moteur Dynamixel d'un côté et la pince de l'autre en s'aidant de boulons. Cela nous a permis de commencer à faire des tests côté électronique.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/A0Wimg-9740.jpg)
Remarque : Cette pièce était légèrement trop longue pour être assemblée correctement. Par soucis d'économie de matériau, nous avons décidé de couper la partie qui dérangeait à l'aide d'une pince coupante.
En parallèle, nous avons vérifié toute notre solution 3D pour s'assurer que les câblages et fixations entre chaque pièce soient réalisables. Nous avons décidé de rajouter des ouvertures pour faire passer les fils et des équerres pour solidifier le châssis. Aussi, avec concertation avec l'équipe informatique, nous avons réalisé que placer les deux capteurs ultrasons à l'avant du robot n'était pas optimal. Nous en avons donc déplacer un sur le côté droit du robot.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/5zMimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/FiXimage.png)
Nous étions bien rendus pour passer à l'étape de découpe mais avons été bloqués par la partie serrage de 0.2mm avec Solidworks. En effet, nous avions eu du mal à comprendre comment rentrer cette donnée avec la fonction tenons et mortaises et n'avons pas réussi à résoudre le problème à temps pour découper nos pièces. Puisque nous souhaitions rester dans les temps, nous avons décidé de nous retrouver au Fablab une après-midi en semaine dans le but de découper les pièces.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/oPAimg-9785.jpg)
La base a pu être construite. Il reste quelques pièces à découper puis on pourra assembler toutes les composants.
Partie code (Ludovic et Pauline) :
Nous avons pris en compte des difficultés en raison des incertitudes des capteurs et des moteurs. De ce fait, nous avons décider de mettre un des capteurs sur l'un des côtés du robot. Afin de vérifier que le robot avance bien droit, nous avons utilisé ce capteur pour faire une fonction permettant de corriger la direction du robot en fonction de sa distance avec le mur latéral. De plus, on a commencer la prise en compte des valeurs d'incertitude des capteurs, en mesurant à une distance connue, pour adapter notre code à celles-ci.
Nous nous sommes réparties les différentes sous fonctions à faire :
Ludovic : mes\_us (prendre la distance des capteurs des ultrasons), leve\_totem, baisse\_totem et gérer pince,
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/m5Iimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/aH6image.png)
Pauline : tourn\_90hor() et tourn\_90antihor() (tourner le robot de 90 degrés vers la droite ou vers la gauche)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/U61image.png)
##### Partie électronique (Marin) :
Une fois le moteur Dynamixel, le bras et la pince assemblés, nous avons pu faire les premiers tests vérifiant que la pince arrivait à attraper le totem correctement et à le soulever et le reposer sans le faire tomber. Les tests ont été réalisés avec succès.
##### Bilan et objectifs lors la prochaine séance:
L'équipe mécanique avance dans les temps par rapport au diagramme de Gantt. En revanche, l'équipe informatique a pris du retard suite au déplacement d'un capteur ultrasons ce qui a pour effet de changer une partie de la logique du code. Les tests sur les capteurs n'ont pas pu être faits à cette séance et devront être faits à la prochaine. Le robot devrait être finit d'être assemblé dans les premières heures de la séance pour permettre à l'équipe informatique de tester le code en condition réelle.
**Mécanique ( Lawny, Clovis et Valentine )**: Finir l'assemblage du robot en découpant les dernières pièces puis en assemblant tous les composants.
**Informatique et électronique ( Pauline et Ludovic et Marin ):** Tester le code sur le robot.
##### **Séance du 07/05/2026**
Ci dessous le diagramme de Gantt mis à jour depuis la dernière séance ( décalage d'une semaine de la mission "Code complet" et "Tests sur les capteurs" )
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/rUIimage.png)
##### Partie mécanique (Clovis, Lawny et Valentine):
Du côté mécanique, nous avons finit l'assemblage du robot en ajoutant au châssis la carte Arduino, la batterie, les roues, la pince et le support de l'interrupteur.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/GJIimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/EUjimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-0025.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-0024.jpg)
##### Partie électronique (Marin):
Nous avons câbler tous les composants. Nous avons décidé de rajouter un interrupteur sur la batterie pour éviter qu'elle ne se décharge trop vite.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-0028.jpg)
On a également réfléchi à une solution qui ferait respecter la consigne du cahier des charges qui impose de démarrer le robot en cliquant sur un bouton poussoir. La solution retenue est d'utiliser le bouton reset de la carte Arduino.
##### Partie codage (Ludovic et Pauline):
Asservissement **:** Développement de la fonction mot\_avance intégrant un correcteur proportionnel Kp=2.5. Le robot lit la distance latérale via le capteurs à ultrason mit sur le coté et ajuste dynamiquement la vitesse des roues pour rester parallèle au mur. Nous avons fait des tests sur cette fonction et le correcteur semble avoir été bien choisi.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/tgwimage.png)
Avec des tests nous avons constater qu'en s'arrêtant à 30 cm du mur frontal, le robot se retrouvait beaucoup trop loin du mur latéral après son virage à 90°. L'axe de rotation (les roues) n'est pas au centre du robot. Lors du pivot sur place, l'avant décrit un grand arc de cercle, ce qui fausse la distance finale par rapport au mur. Pour remédier à cela, nous levons la pince *avant* la manœuvre pour raccourcir l'avant du robot et éviter la collision, et faisons une modification de la consigne d'arrêt frontal à 10 cm (au lieu de 30 cm). Ainsi, après avoir pivoté de 90° sur son axe décalé, le flanc du robot se retrouve environ à la distance de 30 cm pour continuer à longer le mur.
##### Partie mécanique rendu finale (Lawny, Clovis et Valentine ) :
Pour finir voici notre robot finale :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-1537.jpeg)
Bilan et objectifs lors des prochaines séances :
Nous arrivons ici à la dernière séance officielle au fablab. En revanche, alors que nous souhaitions valider le code, cette séance a particulièrement été ralentie par divers problèmes électroniques qui ont empêché l'équipe informatique de correctement tester son programme. Nous programmons donc à ce point d'autres séances jusqu'à que le code soit fonctionnel.
##### **Séances supplémentaires du 20, 22, 26 et 27/05/2026**
Bien que notre avancée semblait très correcte par rapport à notre diagramme de Gantt, 4 séances supplémentaires ont du être prises pour finaliser notre robot. En effet, la partie électronique et informatique nous ont causé plusieurs problèmes longs à résoudre. D'abord, nous avons eu beaucoup de mal à faire réagir le robot comme nous le souhaitions. Pour un même code, son déplacement était parfois radicalement différent. Plus tard, nous sommes restés bloqués à une étape où les moteurs ne voulaient plus répondre. Nous avons également réaliser que notre pince ne pouvait plus être contrôlée.
Quelques modifications et optimisations du code ont été faites : Calibration de la rotation **:** L'angle mathématique théorique ne fonctionnait pas parfaitement. Nous avons donc ajouter un coefficient (ratio passé de 90 à 86) pour obtenir des virages à 90° parfaits. Ajout de pauses stratégiques (delay(2000) avant et après les manipulations du totem pour permettre au châssis de se stabiliser. Au démarrage (Case 1), le robot s'arrêtait quasi instantanément ou tournait sans raison, croyant avoir déjà atteint sa cible, alors que le mur frontal était pourtant à plus d'un mètre de distance. Ne pouvant pas nous fier au capteur dans cette zone précise, nous avons appliqué le principe de la commande en "boucle ouverte". Nous avons désactivé la fonction mot\_avance(qui dépend des ultrasons) pour la remplacer par un dégagement temporel aveugle. L'utilisation d'un timer non-bloquant avec millis() force le robot à avancer pendant 6,5 secondes, lui garantissant de s'extraire de cette zone instable en toute sécurité avant de redonner la parole aux capteurs pour le reste du parcours.
Face à ces divers problèmes, nous avons pris du temps pour vérifier le câblage et pour valider chaque étape du parcours une par une. Concernant la pince qui ne pouvait plus être contrôlée, nous avons constaté que le totem pouvait toujours être attrapé en gardant la pince à une certaine ouverture. En revanche, cela nous a demandé d'adapter le code afin qui soit encore plus précis pour être sur que le robot arrive en face du totem.
Nous avons également profité de ces séances supplémentaires pour avoir un câblage plus propre en regroupant les câbles ensemble par du scotch d'électricien et des serre-câbles. Aussi, à force de déplacer le robot, certaines pièces du robot se sont désemboîtées, ce qui nous à amené à les fixer avec de la colle à bois.
Après plusieurs heures passées à corriger ces divers problèmes inattendus, nous sommes arrivés à notre but. Voici une vidéo du robot en fonctionnement en vitesse x10. En effet, le robot est en réalité temps et cela est imposé par notre correcteur de suivi de mur : si le robot est trop rapide, la correction ne se fait pas correctement.
[rendu\_final.mp4](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1876)
##### **Améliorations possibles**
Si nous devions refaire ce projet, il y a des choses que l'on ferait différemment. D'abord, nous avons réalisé que les tenons et mortaises ont une bien meilleure rigidité si les mortaises trouaient complétement la planche et non présentes sur le côté de la planche comme nous l'avons fait. En conséquence, nous avons choisi de mettre de la colle à bois pour rigidifier la liaison sous la contrainte de l'économie de matériau. Aussi, nous avons choisi de mettre la batterie perpendiculairement à la carte Arduino ce qui nous fait un robot inutilement long. Cela a eu pour conséquence de nous empêcher de faire tourner le robot à exactement 30cm du mur et nous a forcé à poser une vitesse de déplacement lente au robot pour permettre au correcteur de corriger correctement la distance latérale au mur du robot.
Cela reste des petits ajustements qui n'empêchent pas notre robot de fonctionner.
##### **Séance du 29/05/2026**
Dernier cours, démonstrations du projet et démontage du robot.