RoboLymix · INSAT — Plan Complet

Pourquoi ces composants ?

• ESP32 DevKitC 30-pin : c'est le cerveau du robot. Il a le Wi-Fi, le Bluetooth, assez de GPIO pour tout connecter, et 2 cœurs pour gérer les encodeurs en temps réel. Le modèle 30-pin (pas 38-pin) car il rentre mieux dans notre châssis 150mm.
• L298N : pont H double — il permet de contrôler 2 groupes de moteurs (gauche et droit) en vitesse et en direction. Il supporte jusqu'à 2A par canal, parfait pour nos JGB37-520.
• VL53L0X (×4) : capteurs laser Time-of-Flight. Ils mesurent la distance aux murs avec une précision de ~3mm sur 0-120cm. On en met 4 : devant, gauche, droite, arrière.
• MPU9250 GY-91 : 9 axes (gyroscope + accéléromètre + magnétomètre). Le gyroscope corrige les dérives de cap pendant les virages, et le magnétomètre donne un cap absolu.

Où acheter en Tunisie ?

• Local (rapide, plus cher) : Sattari Electronics (Tunis Médina), ElectroPlanet, des boutiques à Sousse/Sfax. Prix ~40-60% plus cher qu'AliExpress.
• AliExpress (lent, pas cher) : cherche "ESP32 DevKitC V2", "L298N module", "VL53L0X GY-530", "MPU9250 GY-91". Commande ASAP car 15-30 jours de livraison.

Vérification à la réception

• ESP32 : brancher en USB → doit apparaître comme port COM/serial
• L298N : vérifier les 2 jumpers ENA/ENB sont présents (on les retirera plus tard)
• VL53L0X : 6 pins visibles (VCC, GND, SDA, SCL, GPIO1, XSHUT)
• MPU9250 : puce marquée "InvenSense MPU-9250" — attention aux faux MPU6500 vendus comme MPU9250

Pourquoi le JGB37-520 ?

• Ratio 30:1 : bon compromis vitesse/couple. ~300 RPM à vide → assez rapide pour le speed run, assez de couple pour démarrer/tourner sans patiner.
• Encodeur Hall intégré : 11 impulsions par tour moteur × 30 (ratio) = 330 impulsions par tour de roue. Ça donne la précision nécessaire pour le PID et la navigation cellule par cellule.
• 12V nominal : correspond à notre pack 3S (11.1-12.6V).

Ce qu'il faut vérifier à la commande

• Commande exactement 30:1 ratio (pas 100:1 ni 10:1)
• Version avec encodeur (6 fils : 2 rouges/noirs pour le moteur + 4 pour l'encodeur)
• Axe de 6mm de diamètre (pour les roues)

Les roues

• Ø65mm en caoutchouc, trou central 6mm
• Assez petites pour rester sous la limite de hauteur du labyrinthe
• Le caoutchouc donne une bonne adhérence sur MDF/bois (surface typique RoboCup)

Pourquoi 3S (3 cellules en série) ?

• 3 × 3.7V = 11.1V nominal (range 9.9V-12.6V)
• Les moteurs JGB37-520 sont optimaux à 12V
• Le L298N a besoin de 7-12V pour fonctionner
• Le LM2596 step-down convertit 12V → 5V pour l'ESP32

Le LM2596

• Module step-down (buck converter) réglable
• Entrée : 12V du pack → Sortie : 5.0V exactement (réglable via vis)
• L'ESP32 VIN accepte 5V — NE PAS envoyer 12V dessus !
• Le module a une LED de fonctionnement et un potentiomètre bleu à tourner

Perfboard vs Stripboard

• Perfboard (pastilles individuelles) : chaque trou est isolé — TU choisis les connexions avec du fil/soudure. C'est ce qu'on utilise.
• Stripboard (bandes de cuivre) : les trous sont connectés en lignes. Plus facile mais moins flexible. PAS adapté à notre layout.

Rôle de chaque composant passif

• 2× résistances 4.7kΩ : pull-up pour le bus I2C (SDA et SCL). Sans elles, les capteurs ToF et le MPU9250 ne communiquent pas avec l'ESP32.
• 1× condensateur 100µF 16V (électrolytique) : filtrage du rail 12V. Absorbe les pics de courant quand les moteurs démarrent/s'arrêtent.
• 3× condensateur 100nF (céramique) : découplage haute fréquence sur chaque rail (3.3V, 5V, 12V). Élimine le bruit électrique qui perturbe les capteurs.

Connecteurs (rend le robot 10× plus facile)

• 4× bornier à vis 2 pôles (5.08mm) : pour les entrées/sorties d'alimentation (12V IN, 12V OUT, 5V IN, 5V OUT). Tu visses les fils au lieu de les souder — beaucoup plus facile à modifier et debugger.
• 5× JST-XH 4-pin (header PCB) : pour les 4 capteurs ToF + le MPU9250. Tu soudes le header au perfboard, puis tu branches/débranches les capteurs avec un câble JST. Plus besoin de souder les capteurs directement !
• 4× JST-XH 3-pin (header PCB) : pour les 4 encodeurs moteur. Même principe plug-and-play.

Kit soudure minimum

• Fer à souder 30-60W (pointe fine ~1mm)
• Fil d'étain 0.6-0.8mm (avec flux intégré)
• Éponge ou laine de laiton pour nettoyer la panne
• Optionnel mais utile : troisième main / support, pompe à dessouder

Pourquoi chaque item ?

• Fil 22AWG : assez épais pour le courant moteur (~2A), assez fin pour passer dans les fentes du châssis. Rouge = VCC, Noir = GND.
• Jumper M-F (mâle-femelle) : pour connecter l'ESP32 (broches mâles) au perfboard et aux capteurs. 30 pièces car on a beaucoup de connexions.
• Jumper M-M : pour les connexions entre modules (L298N → perfboard, etc.)
• Serre-câbles : organisation des câbles — un robot propre = moins de bugs et plus facile à debugger.
• Foam tape 3M : fixation des composants légers (LM2596) qui n'ont pas de trous de vis.
• Velcro : fixation de la batterie — permet de la retirer facilement pour la charger.
• Loctite bleu (243) : frein-filet pour les vis moteur — empêche les vis de se desserrer avec les vibrations. BLEU pas rouge ! (Le rouge est permanent.)
• Entretoises M3 nylon : séparent les étages du châssis. Nylon = isolant et léger.

Paramètres d'impression recommandés

• Matériau : PLA (facile à imprimer, rigide, pas cher)
• Épaisseur de couche : 0.2mm (bon compromis vitesse/qualité)
• Remplissage (infill) : 30% (assez solide sans être trop lourd)
• Parois : 3 périmètres minimum (solidité des trous de vis)
• Support : non nécessaire (les plateaux sont plats)
• Temps estimé : F1 ~3-4h, F2 ~3h, F3 ~2h

Si tu n'as pas d'imprimante 3D

• FabLab INSAT : vérifie si le fablab a une imprimante disponible
• Alternative MDF/acrylique : tu peux découper les plateaux en MDF 3mm avec une scie à chantourner. Dessine les dimensions sur papier, colle sur le MDF, et découpe. Plus long mais ça marche.
• Services en ligne : il y a des services d'impression 3D en Tunisie (cherche sur Facebook/Instagram)

Le Floor 1 — l'étage puissance

• C'est la base du robot — tout le poids repose dessus
• Dimensions exactes : 150×150mm, épaisseur 3mm
• 4 encoches de 42×25mm aux coins pour les moteurs JGB37-520
• Les moteurs dépassent par les côtés — c'est normal, les arbres sortent pour les roues

Éléments à intégrer dans l'impression

• 4 trous M3 pour les entretoises vers Floor 2 (positions : 20mm du bord, en rectangle)
• Fente centrale (~10×30mm) pour passer les câbles vers Floor 2
• Trou interrupteur au bord arrière (diamètre selon ton interrupteur, ~12mm typique)
• 4 paires de trous M3 pour fixer les moteurs dans les encoches (2 vis par moteur)

Composants qui vont sur Floor 1

• L298N : centre-avant (fixé par vis M3 sur rondelles nylon isolantes)
• Batterie 3S : centre-arrière (fixée par Velcro pour retrait facile)
• LM2596 : arrière centre-droit (fixé par foam tape)
• Interrupteur : bord arrière (clipsé ou vissé)

Le Floor 2 — l'étage cerveau

• Même dimensions que F1 : 150×150mm, épaisseur 3mm
• Suspendu à 30mm au-dessus de F1 par les entretoises M3×30mm
• C'est ici que se trouve toute l'intelligence : ESP32 + perfboard + MPU9250

Deux jeux de trous

• 4 trous M3 "bas" : s'alignent avec les entretoises de F1 (mêmes positions)
• 4 trous M3 "haut" : pour les entretoises M3×20mm vers F3 (positions différentes, plus proches du centre-avant car F3 est plus petit)

Fente câbles

• Fente vers le bas (vers F1) : passage des câbles moteurs, encodeurs, alimentation
• Les capteurs ToF et la LED sont directement sur Floor 2 — pas besoin de fente vers F3

Composants sur Floor 2

• ESP32 : côté avant, port USB accessible par le bord pour programmer
• Perfboard 90×70mm : au centre, contient les rails d'alimentation, résistances I2C, condensateurs
• MPU9250 : soudé au centre du perfboard (position idéale = centre de rotation du robot)

Le Floor 3 — couvercle de protection

• Même dimensions que F1 et F2 : 150×150mm, épaisseur 3mm
• Suspendu à 20mm au-dessus de F2 par les entretoises M3×20mm
• Hauteur totale du robot ~92mm — les capteurs ToF sur F2 sont à ~69mm du sol
• Pas de composants électroniques — c'est une plaque de protection pure

Ouvertures pour les faisceaux ToF

• Ouverture avant : 20×12mm au centre du bord avant — alignée avec le ToF Front sur F2
• Ouverture gauche : 12×20mm au centre du bord gauche — alignée avec le ToF Left sur F2
• Ouverture droite : 12×20mm au centre du bord droit — alignée avec le ToF Right sur F2
• Les ouvertures doivent être parfaitement alignées avec les capteurs sur Floor 2 — pose F3 sur F2 avant d'assembler pour vérifier

Trou LED + trous M3

• Trou LED Ø5mm : centre du bord arrière — laisse passer la lumière de la LED sur F2
• 4 trous M3 : aux 4 coins intérieurs, pour les vis des entretoises F2→F3

Ordre de montage (important !)

• 1. Moteurs en premier : vis M3×8 + une goutte de Loctite bleu sur chaque vis. Laisse sécher 10 min avant de manipuler.
• 2. L298N : centre-avant. Utilise des rondelles nylon entre le L298N et le PLA — le radiateur du L298N peut chauffer et déformer le plastique.
• 3. Batterie : centre-arrière sur Velcro. Le poids de la batterie au centre aide la stabilité.
• 4. LM2596 : arrière centre-droit sur foam tape. NE PAS le connecter à l'ESP32 avant d'avoir réglé la tension !
• 5. Interrupteur : bord arrière. En série sur le fil positif de la batterie.
• 6. Entretoises : 4× M3×30mm dans les trous dédiés, serrées à la main (pas trop fort sur le PLA).

Procédure de test étape par étape

• 1. Batterie chargée à fond (chaque cellule ~4.1-4.2V)
• 2. Multimètre en mode tension DC (V=)
• 3. Interrupteur ON
• 4. Mesure aux bornes du L298N (12V / GND) : tu dois lire 11.1-12.6V
• 5. Mesure en sortie du LM2596 (OUT+ / OUT-) : tu dois lire 5.0V ±0.1V

Régler le LM2596

• Il y a un petit potentiomètre bleu sur le module
• Tourne avec un tournevis cruciforme TOUT PETIT (2mm)
• Sens horaire = tension monte, sens anti-horaire = tension baisse
• Ajuste LENTEMENT en mesurant en continu avec le multimètre
• Objectif : 5.00V exactement

Si quelque chose ne marche pas

• 0V partout : interrupteur mal câblé ou batterie déchargée
• 12V OK mais pas de 5V : LM2596 mal connecté (vérifie IN+ et IN-)
• Tension instable : mauvais contact sur les fils — resserre les bornes

Montage Floor 2

• 1. Pose Floor 2 sur les 4 entretoises M3×30mm de Floor 1
• 2. Fixe avec des écrous M3 nylon (serrage à la main, pas trop fort)
• 3. Monte l'ESP32 côté avant — le port USB doit être accessible par le bord pour programmer sans démonter
• 4. Fixe le perfboard au centre (foam tape ou vis M2 si tu as des trous prévus)
• 5. Le MPU9250 est déjà soudé au centre du perfboard
• 6. Clipse les 4 VL53L0X dans leurs clips sur Floor 2 : Front (centre bord avant), Left (centre bord gauche), Right (centre bord droit), Rear (centre bord arrière)
• 7. Place la LED dans son trou au bord arrière de Floor 2

Montage Floor 3 (couvercle)

• 8. Visse 4 entretoises M3×20mm sur Floor 2 (trous "haut")
• 9. Pose Floor 3 (couvercle) et vérifie que les 4 ouvertures sont alignées avec les capteurs ToF sur Floor 2
• 10. Fixe avec écrous M3 nylon

Montage des roues

• L'arbre moteur fait 6mm de diamètre avec un méplat (un côté est plat)
• Les roues ont un trou hexagonal ou avec méplat qui s'emboîte sur l'arbre
• Pousse fermement — elles doivent être bien ajustées (pas de jeu)
• Si elles glissent : une goutte de colle cyanoacrylate (super glue) sur l'arbre

Vérifications

• Rotation libre : tourne chaque roue à la main — elle doit tourner sans résistance excessive
• Pas de frottement : les roues ne doivent pas toucher le châssis (Floor 1) en tournant
• Alignement : les 4 roues doivent toucher le sol en même temps quand tu poses le robot. Si le robot "boite", un moteur est peut-être mal aligné.
• Adhérence : pose le robot sur la surface prévue (bois/MDF). Les roues ne doivent pas patiner quand tu pousses le robot latéralement.

Layout des 4 rails

• Rangée 1 (R1) — 3.3V : fil de cuivre nu soudé sur toute la longueur (cols 1-18). C'est la sortie 3.3V du régulateur interne de l'ESP32.
• Rangée 2 gauche (R2, cols 1-9) — 12V : entrée directe de la batterie 3S via l'interrupteur. Alimente le L298N.
• Rangée 2 droite (R2, cols 11-18) — 5V : sortie du LM2596. Alimente l'ESP32 VIN et les encodeurs.
• Rangée 12 (R12) — GND : masse commune, toute la longueur. TOUT se rejoint ici.

Pourquoi la colonne 10 est vide ?

• C'est le séparateur physique entre le 12V et le 5V sur le rail R2
• Si tu poses de la soudure sur col 10 par accident, tu connectes 12V au 5V → l'ESP32 reçoit 12V et meurt instantanément
• Vérifie visuellement au multimètre (mode continuité) qu'il n'y a PAS de contact entre col 9 et col 11 du rail R2

Technique de soudure des rails

• Coupe un fil de cuivre nu de la bonne longueur
• Plie les extrémités à 90° pour le maintenir en place dans les trous
• Soude chaque pastille individuellement — le fil doit être bien en contact avec chaque pad
• Vérifie la continuité après chaque rail avec le multimètre (bip entre col 1 et col 18)

Borniers à vis (TB1-TB4)

• TB1 (12V IN) : entrée 12V depuis l'interrupteur → connecté au rail 12V (R2 cols 1-9)
• TB2 (5V IN) : entrée 5V depuis le LM2596 → connecté au rail 5V (R2 cols 11-18)
• TB3 (Moteurs A) : sortie vers moteurs gauches depuis le L298N
• TB4 (Moteurs B) : sortie vers moteurs droits depuis le L298N

Connecteurs JST-XH 4-pin (J1-J4)

• J1 (ToF Front) : VCC, GND, SDA, XSHUT (GPIO15)
• J2 (ToF Left) : VCC, GND, SDA, XSHUT (GPIO4)
• J3 (ToF Right) : VCC, GND, SDA, XSHUT (GPIO5)
• J4 (ToF Rear) : VCC, GND, SDA, XSHUT (GPIO16)
• J4 (MPU9250) : VCC, GND, SDA, SCL — si le MPU9250 est sur un breakout séparé

Connecteurs JST-XH 3-pin (J5-J8)

• J5-J8 (Encodeurs) : VCC (5V), GND, Signal — un par moteur

Ordre de soudure recommandé

• 1. Borniers à vis en premier (plus grands, positionnement critique)
• 2. JST-XH 4-pin ensuite
• 3. JST-XH 3-pin en dernier

Pourquoi des connecteurs ?

• Permet de débrancher/rebrancher les capteurs et moteurs sans dessouder
• Les JST-XH sont détrompés — impossible de les brancher à l'envers
• Les borniers à vis supportent les fils épais de puissance (moteurs, batterie)
• Si un capteur est défectueux, tu le remplaces en 5 secondes

Pourquoi des pull-up I2C ?

• Le bus I2C fonctionne en "open-drain" : les appareils tirent la ligne vers le bas (0V) pour envoyer un '0', et la relâchent pour envoyer un '1'
• Sans résistance pull-up, quand la ligne est relâchée, elle "flotte" — ni 0V ni 3.3V → le signal est illisible
• Les résistances 4.7kΩ tirent les lignes SDA et SCL vers 3.3V quand personne ne parle → signal propre
• On met UNE paire pour tout le bus : les 3 ToF + le MPU9250 partagent les mêmes pull-ups

Valeur 4.7kΩ — pourquoi ?

• Trop faible (1kΩ) : consomme trop de courant et les capteurs peinent à tirer vers le bas
• Trop élevée (10kΩ) : le signal monte trop lentement, erreurs de communication à haute fréquence
• 4.7kΩ : valeur standard recommandée pour I2C à 100-400kHz avec 4 appareils sur le bus

Rôle de chaque condensateur

• C1 (100µF électrolytique) : sur le rail 12V. Absorbe les pics de courant quand les moteurs démarrent/freinent. Sans lui, la tension chute brièvement et l'ESP32 peut redémarrer.
• C2 (100nF céramique) : sur le rail 5V. Filtrage haute fréquence — élimine le bruit du LM2596 (convertisseur à découpage).
• C3 (100nF céramique) : sur le rail 3.3V. Protège les capteurs I2C du bruit électrique des moteurs.

Polarité — ATTENTION

• C1 (100µF) : cylindre métallique avec une bande blanche sur un côté. La bande = côté NÉGATIF (−). Le côté sans bande = POSITIF (+). Le + va vers le rail 12V, le − vers GND.
• C2, C3 (100nF) : petits condensateurs céramiques (jaune/marron, plats). PAS de polarité — tu peux les souder dans n'importe quel sens.

Pourquoi au centre ?

• Le MPU9250 mesure les accélérations et rotations. S'il est excentré, les virages créent des accélérations centrifuges parasites qui faussent les mesures.
• Au centre du perfboard ≈ au centre de rotation du robot (quand le robot tourne sur lui-même).

Connexions du module GY-91

• VCC → rail 3.3V (le module a son propre régulateur si tu le branches en 5V, mais 3.3V direct est plus propre)
• GND → rail GND
• SDA → GPIO21 de l'ESP32 (même bus I2C que les ToF)
• SCL → GPIO22 de l'ESP32 (même bus I2C que les ToF)
• AD0 → GND (fixe l'adresse I2C à 0x68). Si AD0 = 3.3V, l'adresse devient 0x69.

Vérification après soudure

• Vérifie la continuité VCC↔rail 3.3V et GND↔rail GND
• Vérifie qu'il n'y a PAS de court-circuit entre VCC et GND (résistance > 1kΩ)
• Le module ne chauffe pas quand alimenté (sinon → court-circuit !)

Checklist de test (mode continuité = bip)

• ✅ Rail 3.3V : touche col 1 et col 18 de R1 → doit bipper (circuit continu)
• ✅ Rail GND : touche col 1 et col 18 de R12 → doit bipper
• ✅ Rail 12V : touche col 1 et col 9 de R2 → doit bipper
• ✅ Rail 5V : touche col 11 et col 18 de R2 → doit bipper
• ❌ 12V vs 5V : touche col 9 et col 11 de R2 → NE DOIT PAS bipper
• ❌ 3.3V vs GND : touche R1 et R12 → ne doit pas bipper (sauf si les résistances/condensateurs créent une résistance faible — dans ce cas, vérifie en mode résistance : doit être > 1kΩ)
• ❌ 12V vs GND : ne doit pas bipper
• ❌ 5V vs GND : ne doit pas bipper

Problèmes courants

• Bip inattendu entre rails : pont de soudure (trop de soudure a débordé entre 2 pastilles adjacentes). Solution : dessouder avec une tresse à dessouder ou une pompe.
• Pas de bip sur un rail : soudure froide (le fil n'est pas bien connecté à une pastille). Solution : rechauffe la jointure et ajoute un peu de soudure.

Test sous tension — premier allumage

• 1. Connecte les fils d'alimentation du perfboard : 12V IN, 5V IN, GND
• 2. NE connecte PAS encore l'ESP32 ni les capteurs
• 3. Allume l'interrupteur
• 4. Mesure immédiatement chaque rail avec le multimètre

Valeurs attendues

• Rail 12V : 11.1-12.6V (dépend de la charge de la batterie)
• Rail 5V : 4.9-5.1V (ajusté par le LM2596)
• Rail 3.3V : 0V pour l'instant (le 3.3V vient du régulateur de l'ESP32, qui n'est pas encore branché)
• Rail GND : 0V partout (c'est la référence)

Après avoir branché l'ESP32

• L'ESP32 reçoit le 5V sur VIN et génère du 3.3V sur sa pin 3V3
• Ce 3.3V alimente le rail 3.3V du perfboard via un fil
• Après branchement de l'ESP32 : le rail 3.3V doit lire ~3.3V

Schéma de la chaîne d'alimentation

• Batterie 3S (3×18650) → Interrupteur (ON/OFF) → Rail 12V du perfboard
• Du rail 12V → LM2596 IN+/IN− → LM2596 convertit → LM2596 OUT+/OUT− → Rail 5V du perfboard
• Du rail 5V → ESP32 VIN + ESP32 GND
• L'ESP32 génère le 3.3V interne → fil de ESP32 3V3 → Rail 3.3V du perfboard

Fils recommandés

• Batterie → interrupteur → 12V : fil 22AWG rouge (courant ~2A max)
• GND : fil 22AWG noir
• 5V et 3.3V : jumper wires suffisent (courant <500mA)

Pourquoi en parallèle ?

• On a 4 moteurs mais seulement 2 canaux sur le L298N
• Les 2 moteurs gauche (M1 avant + M3 arrière) sont câblés en parallèle sur OUT1/OUT2
• Les 2 moteurs droite (M2 avant + M4 arrière) sont câblés en parallèle sur OUT3/OUT4
• En parallèle = même tension, courant doublé. Le L298N supporte 2A par canal, et chaque moteur tire ~300mA → total ~600mA, largement OK.

Table des pins GPIO → L298N

• GPIO14 → ENA (PWM vitesse gauche, 0-255)
• GPIO32 → ENB (PWM vitesse droite, 0-255)
• GPIO26 → IN1 (direction gauche +)
• GPIO27 → IN2 (direction gauche −)
• GPIO25 → IN3 (direction droite +)
• GPIO33 → IN4 (direction droite −)

Comment savoir si un côté tourne à l'envers ?

• Flashe un simple test qui fait tourner les 2 côtés "en avant"
• Si un côté tourne à l'envers → inverse les 2 fils moteur de ce côté sur les bornes du L298N (par ex. échange OUT1 et OUT2)
• Alternative logicielle : inverse IN1/IN2 dans config.h

Les 6 fils de chaque moteur JGB37-520

• 2 fils moteur (rouge/noir ou sans couleur) → vont au L298N (étape précédente)
• 4 fils encodeur : VCC (rouge), GND (noir), Signal A (jaune/vert), Signal B (blanc/bleu)
• On utilise SEULEMENT le Signal A — pas besoin du Signal B pour notre application (on compte juste les impulsions, pas le sens de rotation)

Pourquoi GPIO34, 35, 36, 39 ?

• Ces 4 pins sont "input-only" sur l'ESP32 — elles ne peuvent pas servir comme sorties
• Parfait pour les encodeurs : on ne fait que LIRE les impulsions
• Ces pins n'ont PAS de résistance pull-up interne, mais les encodeurs Hall ont leurs propres pull-ups → pas de problème
• Le code utilise des interruptions (attachInterrupt) sur ces pins pour compter chaque impulsion

Alimentation des encodeurs

• VCC encodeur → 5V (pas 3.3V ! Les encodeurs Hall du JGB37-520 fonctionnent en 5V)
• GND encodeur → GND commun
• Le signal de sortie est en 5V, mais l'ESP32 tolère 3.6V max... en pratique, ça marche car le signal Hall est souvent autour de 3.3V. Si problème : ajoute un diviseur de tension.

Pourquoi 5 fils par ToF ?

• VCC → 3.3V (les VL53L0X fonctionnent en 2.8-3.3V)
• GND → masse commune
• SDA → GPIO21 (bus I2C partagé avec les 2 autres ToF et le MPU9250)
• SCL → GPIO22 (bus I2C partagé)
• XSHUT → pin unique par capteur (permet de les allumer un par un pour changer leur adresse I2C)

Le mécanisme XSHUT

• Par défaut, tous les VL53L0X ont l'adresse I2C 0x29 → conflit si on les branche tous en même temps
• Au démarrage, le code met tous les XSHUT à LOW (tous éteints)
• Puis il allume le capteur Front (XSHUT HIGH), lui change l'adresse à 0x30
• Puis allume Left, adresse → 0x31
• Puis allume Right, adresse → 0x32
• Puis allume Rear, adresse → 0x33
• Maintenant les 4 capteurs ont des adresses différentes et fonctionnent sur le même bus

Table XSHUT

• Front : XSHUT = GPIO15, adresse finale = 0x30
• Left : XSHUT = GPIO4, adresse finale = 0x31
• Right : XSHUT = GPIO5, adresse finale = 0x32
• Rear : XSHUT = GPIO16, adresse finale = 0x33

Câblage de la LED

• GPIO2 → résistance 220Ω → anode (+, patte longue) de la LED → cathode (−, patte courte) → GND
• La résistance 220Ω limite le courant à ~10mA (suffisant pour être visible, sans griller la LED ni surcharger le GPIO)
• GPIO2 est aussi la LED interne de l'ESP32 — quand tu allumes GPIO2, la LED du robot ET la LED de l'ESP32 s'allument en même temps

Organisation des câbles

• Regroupe les câbles par fonction : alimentation (rouge/noir), I2C (jaune/blanc), encodeurs, etc.
• Attache avec des serre-câbles tous les 3-4cm
• Route les câbles le long des bords du châssis, pas au centre
• Zone interdite : devant chaque capteur ToF, un cône de 25° doit être dégagé. Aucun câble ne doit passer dans ce cône, sinon le capteur lit le câble au lieu du mur !

Test AVANT d'allumer (robot éteint)

• Mode continuité sur chaque fil : touche les 2 extrémités → doit bipper
• Vérifie qu'aucun fil n'est en court-circuit avec un voisin
• Vérifie que VCC (n'importe quel rail) n'est PAS en court avec GND
• Secoue doucement le robot : aucun fil ne doit se débrancher

Premier allumage complet

• 1. Interrupteur ON
• 2. La LED du LM2596 s'allume (vert/rouge selon modèle)
• 3. La LED bleue de l'ESP32 clignote brièvement (boot)
• 4. Si rien ne se passe : vérifie l'interrupteur, puis le 5V, puis le câble VIN/GND de l'ESP32

Signes de problème

• Odeur de brûlé : ÉTEINS IMMÉDIATEMENT. Court-circuit quelque part.
• Un composant chauffe : court-circuit ou mauvais branchement. Les composants doivent rester tièdes au toucher, jamais chauds.
• ESP32 redémarre en boucle : pas assez de courant (LM2596 mal réglé) ou court-circuit sur un GPIO.

Installation étape par étape

• 1. Télécharge Arduino IDE 2.x depuis arduino.cc/en/software
• 2. File → Preferences → "Additional boards manager URLs" → ajoute : https://dl.espressif.com/dl/package_esp32_index.json
• 3. Tools → Board → Boards Manager → cherche "esp32" → installe "ESP32 by Espressif Systems" (version 2.x)
• 4. Tools → Board → sélectionne "ESP32 Dev Module"
• 5. Tools → Port → sélectionne le port COM de ton ESP32 (branche-le en USB pour le voir apparaître)

Librairies à installer

• Sketch → Include Library → Manage Libraries → cherche et installe :
  • Adafruit_VL53L0X (par Adafruit) — gestion des capteurs ToF
  • Wire — déjà incluse dans l'ESP32 core, pas besoin d'installer
  • MPU9250_WE (par Wolfgang Ewald) — pour le MPU9250 (étape 30)

Test rapide

• File → Examples → WiFi → WiFiScan → Upload → Serial Monitor à 115200 → tu dois voir les réseaux WiFi autour de toi
• Si ça marche = l'ESP32 est bien reconnu et tu peux flasher du code

Structure du projet

• Crée un dossier maze_robot_v3/ sur ton PC
• TOUS les fichiers doivent être dans le MÊME dossier (Arduino IDE l'exige)
• Le dossier DOIT avoir le même nom que le fichier .ino (maze_robot_v3)

Rôle de chaque fichier

• maze_robot_v3.ino : fichier principal — machine à états (EXPLORE → RETURN → DONE), setup(), loop()
• config.h : toutes les constantes : pins GPIO, vitesses, taille des cellules, seuils. C'est LE fichier à modifier pour calibrer.
• motors.h : contrôle des moteurs, PID, ISR des encodeurs. Fonctions : driveForward(), turnLeft(), turnRight()
• sensors.h : initialisation et lecture des 4 VL53L0X, séquençage XSHUT, retry en cas d'erreur
• flood_fill.h : algorithme BFS, carte des murs, calcul du chemin optimal, gestion des impasses
• movement.h : commandes de haut niveau — avancer d'une cellule, tourner de 90°, correction de trajectoire

Le sketch I2C Scanner

• Cherche "I2C Scanner Arduino" sur Google — c'est un sketch standard de ~30 lignes
• Il parcourt toutes les adresses I2C de 0x01 à 0x7F et affiche celles qui répondent
• C'est le MEILLEUR outil de debug pour vérifier que tous tes capteurs sont bien câblés

Ce que tu dois voir dans le Serial Monitor

• 0x29 → un VL53L0X (adresse par défaut — normal si tu n'as pas encore changé les adresses)
• OU si le code d'init ToF a déjà tourné : 0x30, 0x31, 0x32, 0x33
• 0x68 → MPU9250
• Tu dois voir 5 adresses au total (4 ToF + 1 MPU9250)

Si un capteur manque

• Vérifie le câble SDA (GPIO21) et SCL (GPIO22) du capteur absent
• Vérifie VCC et GND
• Pour les ToF : vérifie le câble XSHUT — si XSHUT est à LOW (déconnecté/flottant), le capteur est éteint
• Essaie de connecter le capteur seul (déconnecte les autres) pour isoler le problème

Procédure de flash

• 1. Ouvre maze_robot_v3.ino dans Arduino IDE
• 2. Vérifie : Board = "ESP32 Dev Module", Port = ton port COM
• 3. Clique "Verify" (✓) — doit compiler sans erreur
• 4. Clique "Upload" (→) — attend le transfert
• 5. Ouvre le Serial Monitor (loupe en haut à droite), régle sur 115200 baud
• 6. Appuie sur le bouton RESET de l'ESP32 (ou débranche/rebranche)

Messages attendus au boot

• [INIT] Configuring ToF sensors...
• [INIT] ToF Front OK at 0x30
• [INIT] ToF Left OK at 0x31
• [INIT] ToF Right OK at 0x32
• [INIT] ToF Rear OK at 0x33
• [INIT] Encoders ready
• [INIT] Flood fill grid initialized (16x16)
• [READY] Waiting for start...

Erreurs courantes

• "Failed to connect to ESP32" : tiens le bouton BOOT enfoncé pendant l'upload
• "Compilation error: sensors.h not found" : tous les fichiers .h doivent être dans le même dossier que le .ino
• "ToF init failed" : problème I2C — reviens à l'étape 27

Flood Fill en 4 phrases

• 1. Le labyrinthe est une grille (16×16 cellules typiquement). Le but est au centre (cellules 7,7 / 7,8 / 8,7 / 8,8).
• 2. On remplit la grille avec des "distances" : le centre = 0, ses voisins = 1, les voisins des voisins = 2, etc. C'est un BFS (Breadth-First Search).
• 3. Le robot est dans une cellule. Il regarde ses voisins accessibles (pas de mur entre eux) et choisit celui avec la PLUS PETITE valeur.
• 4. À chaque mouvement, le robot découvre de nouveaux murs → il met à jour la carte → il recalcule le flood fill → il choisit la prochaine cellule.

Deux phases du robot

• EXPLORE : le robot explore le labyrinthe, cartographie les murs, et se dirige vers le centre. Vitesse lente (SPEED_EXPLORE = 160).
• RETURN : une fois au centre, le robot connaît la carte. Il revient au départ en suivant le chemin optimal, à vitesse rapide (SPEED_RETURN = 220).

Gestion des impasses (deadlock)

• Si le robot est entouré de cellules avec des valeurs ≥ sa propre valeur, il est dans une impasse
• Le code détecte ça et force un demi-tour (180°)
• Le flood fill est recalculé avec les nouveaux murs → le robot trouve un autre chemin

Pourquoi le gyroscope est important ?

• Les encodeurs comptent les tours de roue → ils mesurent la distance
• Mais quand le robot tourne de 90°, les encodeurs ne sont pas très précis (le sol peut être glissant, les roues patinent légèrement)
• Le gyroscope mesure la vitesse angulaire → il sait EXACTEMENT combien de degrés le robot a tourné
• En combinant encodeurs + gyroscope, les virages sont beaucoup plus précis

Ce qu'il faut modifier dans le code

• config.h : ajouter les constantes MPU9250 (adresse I2C, offsets de calibration)
• sensors.h : ajouter l'initialisation du MPU9250 et la lecture gyro/magnéto
• movement.h : dans turnLeft() et turnRight(), utiliser le gyroscope pour vérifier que le virage fait exactement 90°
• Logique : au lieu de tourner "tant que les encodeurs n'ont pas compté 277 pulses", tourner "tant que le gyroscope n'a pas mesuré 90°"

Librairie recommandée

• MPU9250_WE par Wolfgang Ewald — simple, bien documentée, fonctionne avec l'ESP32
• Installation : Arduino IDE → Library Manager → "MPU9250_WE" → Install
• Exemples inclus : MPU9250_acceleration, MPU9250_gyroscope, MPU9250_magnetometer

Méthode de calibration

• 1. Marque un point de départ sur le sol (ruban adhésif)
• 2. Marque un point à exactement 1000mm (1 mètre) — mesure avec un mètre ruban
• 3. Écris un petit sketch qui fait avancer le robot tout droit et affiche le compteur d'encodeur dans le Serial Monitor
• 4. Place le robot au départ, lance-le, arrête-le quand il atteint la marque des 1000mm
• 5. Note le nombre de pulses affiché. Fais-le 3 fois et prends la moyenne.
• 6. PULSES_PER_MM = moyenne_pulses / 1000

Calcul théorique vs réel

• Théorie : roue Ø65mm → périmètre = π × 65 = 204.2mm → 330 pulses/tour → 330/204.2 = 1.62 pulses/mm
• Mais config.h dit 2.94 — la différence vient du ratio exact du réducteur et de la taille réelle de la roue (les roues chinoises ne font pas exactement 65mm)
• C'est pour ça qu'il FAUT mesurer sur le robot réel, pas se fier au calcul théorique

Méthode de calibration des virages

• 1. Place le robot sur une surface plane, marque la direction avec du ruban adhésif
• 2. Écris un sketch qui fait 4 rotations de 90° à droite (avec la valeur actuelle de TURN_PULSES_90 = 277)
• 3. Si après 4 virages le robot regarde dans la même direction qu'au départ → 277 est bon !
• 4. S'il a fait PLUS que 360° (il pointe au-delà) : diminue la valeur
• 5. S'il a fait MOINS que 360° : augmente la valeur

Formule d'ajustement

• Mesure l'angle réel fait après 4 virages (avec un rapporteur ou une appli téléphone)
• new_value = old_value × 360 / measured_angle
• Exemple : 4 virages = 350° au lieu de 360° → new = 277 × 360/350 = 285

Procédure de test

• 1. Écris un sketch qui affiche les 3 distances ToF dans le Serial Monitor (toutes les 200ms)
• 2. Place un livre/carton plat devant le capteur Front
• 3. Mesure la distance avec un mètre ruban : 100mm, 200mm, 300mm, 500mm
• 4. Compare avec la lecture du capteur — l'erreur doit être < 10mm
• 5. Répète pour les capteurs Left et Right

WALL_THRESHOLD_MM

• C'est la distance en dessous de laquelle le robot considère qu'il y a un mur
• Valeur par défaut : 100mm
• Si ton labyrinthe a des cellules de 180mm : le mur le plus proche est à ~90mm du centre de la cellule (180/2)
• Mets le seuil à mi-chemin entre "mur" et "pas de mur" : ~120-150mm est souvent bon

Problèmes courants

• Lecture 0mm en permanence : capteur pas initialisé (revois l'étape 27)
• Lectures très variables (±50mm) : surface réfléchissante ou câble parasite dans le cône de détection
• Erreur systématique (toujours +30mm par ex.) : le capteur mesure depuis la puce, pas depuis le bord du PCB → normal, tiens-en compte dans le seuil

C'est quoi un PID ?

• P (Proportionnel) : corrige l'erreur actuelle. Si le robot dévie à droite de 10mm → il tourne à gauche proportionnellement. KP = intensité de la correction.
• I (Intégral) : corrige l'erreur accumulée. Si le robot dérive lentement dans un sens → l'erreur s'accumule → la correction augmente. KI = vitesse de correction de la dérive.
• D (Dérivé) : freine la correction. Empêche le robot de sur-corriger et d'osciller. KD = amortissement.

Méthode de réglage (Ziegler-Nichols simplifiée)

• 1. Mets KI=0, KD=0. Commence avec KP=1.0
• 2. Lance le robot en ligne droite sur 2 mètres
• 3. S'il dévie sans corriger → augmente KP (essaie 2.0, 3.0, etc.)
• 4. S'il oscille (zigzag gauche-droite) → KP est trop fort, réduis-le
• 5. Quand KP est bon (corrige sans trop osciller), ajoute KD=0.5
• 6. Augmente KD jusqu'à ce que les oscillations disparaissent
• 7. Si le robot dérive lentement d'un côté, ajoute un petit KI (0.01-0.1)

Calibration du gyroscope

• Le gyroscope a un "drift" (dérive) — même immobile, il lit un petit angle qui n'est pas zéro
• La calibration mesure ce drift pendant 3 secondes (robot immobile) et le soustrait des lectures futures
• Procédure : pose le robot sur une surface PARFAITEMENT plane, ne le touche pas, lance la calibration
• Les offsets sont stockés en mémoire (config.h ou EEPROM)

Calibration du magnétomètre

• Le magnétomètre est perturbé par les moteurs, les fils, et les objets métalliques autour
• La calibration "hard iron" corrige ce biais
• Procédure : lance le mode calibration, puis tourne le robot LENTEMENT sur 360° (complet) dans les 2 sens
• Le code enregistre les valeurs min/max du champ magnétique et calcule les offsets

Vérification

• Après calibration, le gyroscope doit lire ~0°/s quand le robot est immobile
• Le magnétomètre doit donner un cap stable (ex: 45° = nord-est) quand le robot est immobile
• Tourne le robot de 90° → le cap doit changer de ~90° (ex: 45° → 135°)

Qu'est-ce que CELL_SIZE_MM ?

• Le labyrinthe RoboCup est divisé en cellules carrées
• Chaque cellule fait 180mm × 180mm (standard RoboCup Junior)
• Quand le robot "avance d'une cellule", il doit parcourir exactement cette distance
• Si CELL_SIZE_MM est trop grand : le robot dépasse la cellule → se retrouve dans la suivante → la carte est fausse
• Si trop petit : le robot s'arrête trop tôt → il croit être dans une cellule alors qu'il est entre deux

Comment mesurer

• Si tu as accès à un vrai labyrinthe RoboCup : mesure la distance entre 2 murs parallèles adjacents (distance intérieure)
• Si tu construis ton propre labyrinthe en carton : choisis 180mm et construis en conséquence
• Mets la valeur exacte dans config.h : #define CELL_SIZE_MM 180

Impact sur le code

• Le nombre de pulses pour avancer d'une cellule = CELL_SIZE_MM × PULSES_PER_MM
• Avec les valeurs par défaut : 180 × 2.94 = 529 pulses par cellule
• C'est pour ça que la calibration de PULSES_PER_MM (étape 31) doit être faite AVANT

Construire un mini-labyrinthe de test

• Matériau : carton épais (boîtes de pizza, carton d'emballage) ou MDF 3mm
• Dimensions : 4×4 cellules = 720mm × 720mm (si cellules de 180mm)
• Hauteur des murs : 50mm minimum (standard RoboCup)
• Épaisseur des murs : ~12mm (collé sur le sol ou maintenu avec du ruban)
• Sol : surface lisse et plate (table, panneau MDF)

Premier test — par étapes

• Test 1 — Ligne droite : un couloir de 4 cellules sans virage. Le robot doit avancer de 4 cellules sans toucher les murs.
• Test 2 — Un virage : un couloir avec un virage à droite. Le robot doit détecter le mur, tourner, et continuer.
• Test 3 — Impasse : un cul-de-sac. Le robot doit faire demi-tour.
• Test 4 — Labyrinthe complet : le labyrinthe 4×4 avec le centre à atteindre.

Quoi surveiller

• Le robot se centre bien dans chaque cellule ?
• Les virages sont bien à 90° (pas 85° ou 95°) ?
• Il détecte les murs des 3 côtés correctement ?
• Il ne se coince pas dans les coins ?

Ce que le robot doit faire

• Phase EXPLORE : le robot part du coin (0,0), explore méthodiquement le labyrinthe en utilisant Flood Fill, et se dirige vers le centre (cellules 1,1 / 1,2 / 2,1 / 2,2 dans un 4×4)
• À chaque cellule, il lit les 4 capteurs ToF, met à jour la carte des murs, recalcule le Flood Fill, et avance vers la cellule avec la valeur la plus basse
• Phase RETURN : une fois au centre, le robot connaît le chemin optimal. Il revient au départ en suivant ce chemin à vitesse rapide.

Vérification via Serial Monitor

• Le code affiche la carte du labyrinthe dans le Serial Monitor
• Vérifie que les murs détectés correspondent à la réalité
• Vérifie que les valeurs Flood Fill sont cohérentes (le centre = 0, les cellules éloignées = valeurs plus grandes)
• Si le robot se trompe de mur : problème de seuil ToF (étape 33) ou capteur mal orienté

Problèmes courants

• Le robot tourne en boucle : un mur n'est pas détecté → le Flood Fill envoie le robot dans une boucle. Baisse WALL_THRESHOLD_MM.
• Le robot détecte des murs fantômes : un câble est dans le cône ToF, ou le seuil est trop haut.
• Le robot se décale progressivement : PULSES_PER_MM ou CELL_SIZE_MM n'est pas bien calibré.

Le speed run — comment ça marche

• Pendant l'exploration, le robot a cartographié tout le labyrinthe
• Il connaît maintenant le chemin le plus court du départ au centre
• Le speed run = suivre ce chemin à vitesse maximale, sans explorer
• SPEED_RETURN = 220 (sur 255 max) — c'est rapide mais stable

Optimisations possibles

• Augmenter SPEED_RETURN : teste 230, 240, 250. Plus c'est rapide, plus le PID doit être bien calibré.
• Réduire le temps de virage : un virage rapide gagne du temps mais risque de faire patiner les roues
• Smooth turns : au lieu de s'arrêter → tourner → repartir, le robot peut tourner en roulant (arc de cercle). Plus complexe mais beaucoup plus rapide.

Scoring RoboCup

• Au tournoi, tu as plusieurs essais (runs) dans un temps limité
• Le premier run = exploration (lent, ~2-3 min pour un labyrinthe 16×16)
• Les runs suivants = speed runs (rapide, ~20-40 secondes si bien calibré)
• Le meilleur temps est gardé → optimise le speed run !

Estimation théorique

• 3× 18650 3400mAh en série = 3400mAh à 11.1V
• Consommation totale : 4 moteurs (~300mA) + ESP32 (~150mA) + capteurs (~50mA) = ~500mA en moyenne
• Autonomie théorique : 3400 / 500 = ~6.8 heures
• En pratique : les pics de courant (démarrages moteur), les pertes dans le LM2596, et la décharge non-linéaire réduisent à ~3-4 heures
• C'est LARGEMENT assez pour un tournoi (10-15 min de runs au total)

Quand s'inquiéter

• Si l'autonomie est < 30 min : vérifie qu'il n'y a pas de court-circuit ou de composant qui chauffe
• Si l'ESP32 redémarre en boucle vers la fin : la tension batterie est trop basse pour le LM2596 → charge les batteries
• Si les moteurs ralentissent progressivement : normal, la tension batterie baisse. Recharge quand la tension descend sous ~10V pour ne pas endommager les cellules.

Checklist mécanique

• ☐ Toutes les vis serrées (vérifie avec un tournevis, pas à la main)
• ☐ Loctite bleu sur les vis moteur (vérifie qu'elles n'ont pas bougé)
• ☐ Roues bien fixées, pas de jeu sur les arbres moteur
• ☐ Câbles bien rangés et attachés (serre-câbles)
• ☐ Aucun câble dans le cône des capteurs ToF
• ☐ Entretoises bien serrées, aucun étage qui bouge

Checklist électrique

• ☐ 3 batteries chargées à fond (4.2V chacune, 12.6V total)
• ☐ LM2596 toujours réglé à 5.0V (peut dériver avec la chaleur)
• ☐ Tous les capteurs répondent (I2C scan : 4 appareils)
• ☐ LED fonctionne
• ☐ Moteurs tournent dans le bon sens

Checklist logicielle

• ☐ Code FINAL flashé (pas un sketch de test !)
• ☐ Mode debug désactivé (sinon le robot est plus lent à cause des prints Serial)
• ☐ Valeurs calibrées (PULSES_PER_MM, TURN_PULSES_90, CELL_SIZE_MM, PID, seuils ToF)
• ☐ Un dernier test complet (exploration + speed run) la veille du tournoi

Dans le sac pour le tournoi

• ☐ Le robot (évidemment)
• ☐ Câble micro-USB (pour reprogrammer sur place)
• ☐ PC portable avec Arduino IDE + le code
• ☐ Chargeur de batteries 18650
• ☐ Multimètre
• ☐ Petit tournevis cruciforme + plat
• ☐ Serre-câbles de rechange
• ☐ Foam tape de rechange
• ☐ Batterie externe (pour charger le PC)