Mardi soir, atelier robotique ISET Sfax. Mariem, première année génie électrique, contemple les pièces de son premier châssis 2WD étalées devant elle : deux plaques d’acrylique transparent, quatre vis interminables, deux moteurs jaunes “TT” avec leurs réducteurs en plastique, deux roues de 65 mm, une mystérieuse “roulette folle” qui ressemble à un patin à roulettes miniature. À côté, un Arduino UNO encore dans son emballage, un L298N noir avec ses dissipateurs, un capteur HC-SR04 qui ressemble à deux petits yeux, et un sachet de fils jumper colorés. Le défi : faire rouler ce tas de composants en évitant les murs, d’ici la fin de la semaine.

C’est exactement le projet qui transforme un débutant en maker. Plus visuel qu’un blinky, plus motivant qu’un capteur de température, le robot d’évitement d’obstacles enseigne en une seule construction : l’assemblage mécanique, le câblage de puissance, le pilotage PWM, la lecture de capteurs, la logique conditionnelle, l’alimentation. Tout ce qu’un futur ingénieur embarqué doit maîtriser.

Dans ce guide complet, on construit le robot ensemble, étape par étape, avec le code complet commenté en français, le câblage détaillé, le dépannage des 5 problèmes que tout débutant rencontre, et 5 upgrades pour le faire évoluer.

La liste de matériel détaillée

Voici la BOM (Bill of Materials) qu’on recommande aux étudiants venant en boutique Didactico Sfax. Comptez 90-130 DT au total selon la qualité des composants.

Châssis et mécanique

• Châssis 2WD acrylique transparent (ou aluminium) : 2 plaques superposées, perçages standardisés, 25-40 DT
• 2 moteurs DC “TT motor” jaunes avec réducteurs plastiques 1:48 : ~150 RPM à 6V, consommation 200 mA à vide, 400-600 mA en charge. 15 DT la paire
• 2 roues caoutchouc de 65 mm compatibles axes plats 5.5 mm. Incluses souvent dans le kit châssis
• 1 roulette folle (caster wheel) à l’avant ou à l’arrière pour stabiliser. Souvent en plastique avec une bille métallique
• Visserie : vis M3 longues (×4 pour empiler les niveaux), entretoises hexagonales M3×20mm, écrous

Électronique

• 1 Arduino UNO R3 (officielle ~80 DT, compatible CH340 ~30 DT). Pour débuter, la compatible suffit largement
• 1 driver moteur L298N avec dissipateur. Carte rouge classique, 6 DT
• 1 capteur ultrasonique HC-SR04 : 5 DT. Portée 2-400 cm, précision ±3 mm
• 1 servo SG90 (9g) pour orienter le HC-SR04 gauche/droite. 7 DT
• 1 support orientable pour HC-SR04 compatible servo. 4 DT (ou imprimé 3D au FabLab Sfax pour 1 DT de filament)
• 1 pack 4×AA NiMH 2000 mAh + boîtier avec interrupteur (recommandé débutant), 22 DT. Ou 2× Li-ion 18650 + porte-batterie 2S + BMS, 35 DT (autonomie 3-4× supérieure)
• Fils jumper mâle-mâle et mâle-femelle, 20 cm. Un sachet de 65 fils mixtes à 6 DT couvre largement
• 1 interrupteur à bascule miniature pour couper l’alim (4 DT), facultatif mais recommandé

Outils nécessaires

• Tournevis cruciforme PH0 et PH1
• Pince coupante fine
• Multimètre (mode tension DC et continuité)
• Ruban électrique ou gaine thermo (3 mm)
• Optionnel mais utile : fer à souder + étain pour souder les fils sur les moteurs (sinon, ils se débranchent à la première vibration)

Assemblage du châssis : 10 étapes

Les châssis acryliques arrivent avec un film de protection des deux côtés. Ne le retirez surtout pas avant la fin du montage : l’acrylique transparent se raye à la moindre vibration ou frottement contre une vis.

1. Déballer et identifier les deux plaques. La plaque “inférieure” reçoit les moteurs, la plaque “supérieure” l’électronique. Repérez-les par les perçages : la plaque moteurs a deux paires de trous oblongs sur les côtés.
2. Fixer les moteurs à la plaque inférieure. Utilisez les vis longues M3 fournies avec les supports moteurs métalliques (ou plastiques selon kit). Vissez fermement mais sans forcer (acrylique = fragile en serrage excessif). Vérifiez que les axes ressortent symétriquement de chaque côté.
3. Souder les fils d’alimentation sur les moteurs. Étape facultative mais qui change tout. Les bornes des TT motors sont des lamelles métalliques. Sans soudure, un fil glissé entre les lamelles tient 2 jours, puis bouge à la première vibration. Soudez deux fils de 15-20 cm (rouge et noir, repère utile) sur chaque moteur. Si vous n’avez pas de fer à souder, le FabLab Sfax met le sien à disposition gratuitement le samedi après-midi.
4. Monter les roues sur les axes. Les TT motors ont des axes plats (méplat) qui empêchent le glissement. Appuyez fermement, c’est censé être serré. Si vous devez forcer trop, vérifiez l’orientation du méplat.
5. Fixer la roulette folle. Elle se monte en général à l’arrière du châssis (côté opposé au capteur HC-SR04). Vis M3 + entretoises de 10-15 mm pour qu’elle touche bien le sol.
6. Installer les entretoises hexagonales M3×20mm aux 4 coins de la plaque inférieure. Elles serviront de supports pour la plaque supérieure.
7. Installer le boîtier de piles sous la plaque inférieure (ou entre les deux plaques), avec scotch double face fort ou ruban velcro. L’interrupteur du boîtier doit rester accessible.
8. Visser la plaque supérieure sur les entretoises.
9. Fixer l’Arduino UNO sur la plaque supérieure avec des vis M3 dans les trous de fixation de l’UNO. Si votre châssis n’a pas les bons perçages, scotch double face suffit largement.
10. Fixer le L298N à côté, et le support servo + HC-SR04 à l’avant (côté opposé à la roulette folle). Retirez maintenant le film de protection acrylique. Étape psychologiquement importante : votre robot existe.

Câblage du L298N : pont en H, alimentation, broches

Le L298N est le composant qui intimide le plus les débutants, à tort. Une fois compris, c’est une logique simple. Voici l’anatomie du module rouge classique.

Les bornes “sortie moteurs” (OUT)

• OUT1 et OUT2 : les deux fils du moteur A (peu importe lequel, on inversera dans le code si besoin)
• OUT3 et OUT4 : les deux fils du moteur B

Les bornes “alimentation” (côté gauche)

• +12V (parfois noté VS ou VCC moteur) : entrée alimentation des moteurs, accepte 7 à 35V. On y branche le + de notre pack 4×AA (6V) ou 2× 18650 (7.4V)
• GND : masse commune (à connecter à la fois au pack batterie ET à la GND de l’Arduino, sinon les signaux PWM ne sont pas référencés correctement)
• +5V : sortie 5V régulée fournie par le L298N à partir de l’alim moteurs (si le jumper “5V_EN” est en place)

Les broches de contrôle (côté droit)

• IN1, IN2 : commandent le sens de rotation du moteur A. Logique : IN1=HIGH/IN2=LOW = avant ; IN1=LOW/IN2=HIGH = arrière ; les deux LOW = stop ; les deux HIGH = stop (frein moteur)
• IN3, IN4 : idem pour moteur B
• ENA : enable moteur A. Si HIGH = moteur A actif à pleine vitesse. Si on envoie un PWM (analogWrite), on contrôle la vitesse
• ENB : enable moteur B, idem

Câblage Arduino ↔ L298N

// Schéma de connexion broches Arduino UNO -> L298N
//
// L298N IN1 <- Arduino D2  (digital, sens moteur A)
// L298N IN2 <- Arduino D3  (digital, sens moteur A)
// L298N IN3 <- Arduino D4  (digital, sens moteur B)
// L298N IN4 <- Arduino D5  (digital, sens moteur B)
// L298N ENA <- Arduino D9  (PWM, vitesse moteur A)
// L298N ENB <- Arduino D10 (PWM, vitesse moteur B)
// L298N GND -> Arduino GND (masse commune, OBLIGATOIRE)
// L298N +5V -> Arduino 5V  (si jumper 5V_EN actif, sinon NE PAS connecter)
//
// HC-SR04 :
// VCC -> Arduino 5V
// GND -> Arduino GND
// TRIG -> Arduino D7
// ECHO -> Arduino D8
//
// Servo SG90 (orientation HC-SR04) :
// Rouge -> +5V (idéalement via une alim séparée, sinon Arduino 5V acceptable)
// Marron/Noir -> GND
// Orange/Jaune (signal) -> Arduino D11

Schéma de câblage complet (ASCII)

            +--------+
            | Pack   |
            | 4x AA  |
            | (6V)   |
            +---+----+----+
                |         |
              [SW]       GND
               + |        |
           +---+--+       |
           |  +12V|       |
           |      |       |
     +-----+ L298N +------+--------------+
     |     |      |       |              |
   OUT1   OUT2   OUT3    OUT4           +5V (sortie régulée)
     |     |      |       |              |
    [Moteur A]   [Moteur B]              |
                                          |
           IN1 IN2 IN3 IN4 ENA ENB       |
            |   |   |   |   |   |        |
           D2  D3  D4  D5  D9  D10       |
            |   |   |   |   |   |        |
        +-------+-----+----+-----+----+  |
        |        Arduino UNO          |--+5V
        |                              |--GND
        +------+-----+----+------+----+
               D7    D8   D11    USB (pour upload)
               |     |    |
             TRIG  ECHO  SIGNAL
               |     |    |
            +----------+ +--------+
            | HC-SR04  | | Servo  |
            +----------+ | SG90   |
                         +--------+

Code Arduino complet et commenté

Voici le firmware complet du robot. Il pilote les moteurs, mesure la distance, et prend une décision intelligente (regarder gauche, droite, comparer, tourner du côté le plus dégagé) quand un obstacle apparaît à moins de 20 cm.

// =========================================================
// Robot Arduino 2WD - Évitement intelligent d'obstacles
// Châssis 2 moteurs DC + L298N + HC-SR04 + Servo SG90
// Auteur : Didactico - guide pédagogique 2026
// =========================================================

#include <Servo.h>

// --- Broches L298N ---
const int IN1 = 2;   // Sens moteur A
const int IN2 = 3;
const int IN3 = 4;   // Sens moteur B
const int IN4 = 5;
const int ENA = 9;   // PWM vitesse A
const int ENB = 10;  // PWM vitesse B

// --- Broches HC-SR04 ---
const int TRIG = 7;
const int ECHO = 8;

// --- Servo orientation capteur ---
Servo servoCapteur;
const int PIN_SERVO = 11;

// --- Paramètres comportement ---
const int VITESSE_NORMALE = 180;  // 0-255, 180 ≈ 70 %
const int VITESSE_VIRAGE = 200;   // un peu plus pour vaincre l'inertie
const int SEUIL_OBSTACLE_CM = 20; // distance déclenchement évitement
const int DUREE_VIRAGE_MS = 350;  // ~90° selon tes moteurs (à calibrer)

void setup() {
  Serial.begin(9600);            // pour debug via moniteur série
  
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  pinMode(ENA, OUTPUT);
  pinMode(ENB, OUTPUT);
  
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  
  servoCapteur.attach(PIN_SERVO);
  servoCapteur.write(90);        // 90° = capteur droit devant
  delay(500);
  
  Serial.println("Robot prêt - démarrage dans 3 secondes");
  delay(3000);                   // pause pour poser le robot au sol
}

void loop() {
  long distance = mesurerDistance();
  Serial.print("Distance : ");
  Serial.print(distance);
  Serial.println(" cm");
  
  if (distance > SEUIL_OBSTACLE_CM || distance == 0) {
    // 0 = mesure invalide, on continue prudemment
    avancer(VITESSE_NORMALE);
  } else {
    // Obstacle détecté : on s'arrête et on évalue les options
    stopper();
    delay(200);
    reculer(VITESSE_NORMALE);
    delay(300);
    stopper();
    
    long distGauche = regarderCote(150);  // capteur 60° à gauche
    long distDroite = regarderCote(30);   // capteur 60° à droite
    servoCapteur.write(90);               // remettre devant
    delay(200);
    
    Serial.print("Gauche=");
    Serial.print(distGauche);
    Serial.print(" / Droite=");
    Serial.println(distDroite);
    
    if (distGauche > distDroite) {
      tournerGauche(VITESSE_VIRAGE);
    } else {
      tournerDroite(VITESSE_VIRAGE);
    }
    delay(DUREE_VIRAGE_MS);
    stopper();
  }
}

// ---------- Fonctions moteur ----------
void avancer(int vitesse) {
  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);   // moteur A avant
  digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);   // moteur B avant
  analogWrite(ENA, vitesse);
  analogWrite(ENB, vitesse);
}

void reculer(int vitesse) {
  digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH);
  digitalWrite(IN3, LOW); digitalWrite(IN4, HIGH);
  analogWrite(ENA, vitesse);
  analogWrite(ENB, vitesse);
}

void tournerGauche(int vitesse) {
  // moteur droit avant, moteur gauche arrière => pivot sur place
  digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH);  // A arrière
  digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);   // B avant
  analogWrite(ENA, vitesse);
  analogWrite(ENB, vitesse);
}

void tournerDroite(int vitesse) {
  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);   // A avant
  digitalWrite(IN3, LOW);  digitalWrite(IN4, HIGH);  // B arrière
  analogWrite(ENA, vitesse);
  analogWrite(ENB, vitesse);
}

void stopper() {
  digitalWrite(IN1, LOW); digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW); digitalWrite(IN4, LOW);
  analogWrite(ENA, 0);
  analogWrite(ENB, 0);
}

// ---------- Capteur ultrasonique ----------
long mesurerDistance() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  
  long duree = pulseIn(ECHO, HIGH, 30000UL); // timeout 30 ms ≈ 5 m
  if (duree == 0) return 0;                  // hors portée
  long distance = duree * 0.0343 / 2;        // vitesse son ≈ 343 m/s
  return distance;
}

long regarderCote(int angle) {
  servoCapteur.write(angle);
  delay(400);                  // laisser le temps au servo de bouger
  long d = mesurerDistance();
  return d;
}

Tests et calibration

Test 1 — Sens de rotation des moteurs

Levez le robot du sol et lancez le programme. Les deux roues doivent tourner dans le même sens (vers l’avant du robot) en phase “avancer”. Si une roue tourne à l’envers : inversez les deux fils du moteur concerné sur OUT1/OUT2 (ou OUT3/OUT4) du L298N. C’est mécaniquement plus simple que de modifier le code.

Test 2 — Vitesse égale entre les deux roues

Posez le robot sur une surface plate, faites-le avancer. S’il dérive d’un côté, c’est normal : deux moteurs DC “identiques” varient de 10-20% en vitesse réelle. Compensez en réduisant le PWM du moteur le plus rapide :

// Si le robot dérive vers la droite => le moteur gauche tourne trop vite
// On baisse un peu son PWM :
analogWrite(ENA, 180);    // moteur droit
analogWrite(ENB, 165);    // moteur gauche, réduit de 15

Test 3 — Seuil distance HC-SR04

Placez le robot face à un mur et avancez la main. Vérifiez sur le moniteur série que la distance descend bien sous 20 cm avant que le robot ne réagisse. Si les mesures sont erratiques (0 puis 200 puis 5 puis 0), le HC-SR04 peut être face à une surface absorbante (rideau, mousse, vêtement) qui ne renvoie pas l’écho. C’est une limite physique.

Test 4 — Durée du virage à 90°

Réglez DUREE_VIRAGE_MS par essais successifs. Sur la plupart des kits Didactico, 300-400 ms donnent un virage proche de 90° avec un pack 6V chargé. Avec batterie qui se vide, la durée doit augmenter (les moteurs ralentissent).

Dépannage : 5 problèmes classiques rencontrés en atelier

Problème 1 — “L’Arduino redémarre dès que les moteurs démarrent”

Cause à 90% : l’Arduino partage la même alimentation que les moteurs sans découplage. Le pic de courant moteur fait chuter la tension. Solution : ajoutez un condensateur électrolytique 470 µF entre +5V et GND, près de la broche d’alim Arduino. Et idéalement, alimentez l’Arduino par USB pendant les tests pour découpler.

Problème 2 — “Le HC-SR04 retourne toujours 0 ou des valeurs aléatoires”

Vérifications dans l’ordre : (a) TRIG sur D7, ECHO sur D8, pas inversés ; (b) VCC du HC-SR04 bien sur 5V (pas 3.3V — le HC-SR04 ne fonctionne pas en 3.3V); (c) GND commun avec Arduino ; (d) le capteur n’est pas trop proche d’une surface (zone morte 0-2 cm).

Problème 3 — “Le servo trembletoujours, le robot avance par à-coups”

Le servo SG90 tire 250 mA en mouvement, 50 mA en maintien. Si vous l’alimentez sur le 5V de l’Arduino directement, le régulateur AMS1117 sur la carte (capable de ~500 mA max) sature dès qu’un moteur tire en plus. Solution : alimentez le servo sur le 5V du L298N (qui sort directement de l’alim moteurs régulée), ou ajoutez un petit régulateur dédié.

Problème 4 — “Les moteurs sont très lents même à PWM 255”

Trois causes possibles : (a) tension batterie trop basse (4× AA déchargées = 4.4V au lieu de 6V), changez ou rechargez ; (b) le L298N perd 1.5-2V dans ses transistors internes (limitation physique des BJT), donc à 6V d’entrée, les moteurs voient 4V seulement — d’où l’intérêt de passer à 7.4V (2× 18650) ; (c) le moteur est mécaniquement bloqué (frottement entre roue et châssis).

Problème 5 — “Le robot tourne, mais pas droit après le virage”

Le robot a un “mémoire mécanique” très approximative. Sans encodeurs, impossible de garantir un virage exactement à 90°. Solutions : (a) calibrer DUREE_VIRAGE_MS à votre robot et alimentation précis ; (b) accepter l’imprécision et laisser l’évitement faire son travail à la prochaine collision ; (c) upgrade vers encodeurs (voir section suivante).

5 upgrades pour faire évoluer votre robot

Upgrade 1 — Commande Bluetooth via HC-05 et app smartphone

Ajoutez un module HC-05 (8 DT) sur les broches RX/TX de l’Arduino. Installez l’app gratuite “Arduino Bluetooth Controller” ou “Bluetooth RC Car” sur Android. Ajoutez quelques lignes pour lire les commandes ‘F’, ‘B’, ‘L’, ‘R’, ‘S’ depuis Serial.read() et déclencher les fonctions correspondantes. Vous transformez le robot autonome en voiture télécommandée pour 8 DT et 20 lignes de code. Très utile pour démos en cours à l’ENIT ou en projet de fin d’année à l’ISBS.

Upgrade 2 — Suiveur de ligne 3 capteurs IR

Fixez sous le châssis (à 1 cm du sol) un module “3-channel line follower TCRT5000” (10 DT). Trois capteurs IR détectent le contraste noir/blanc d’une bande adhésive au sol. Code : si capteur central voit la ligne = avancer ; si capteur gauche seul voit la ligne = corriger à gauche ; etc. Permet de programmer un robot suiveur de circuit, défi classique des compétitions FabLab Sfax et Maker Faire Tunis.

Upgrade 3 — Vision avec ESP32-CAM streaming Wi-Fi

Remplacez (ou complétez) l’Arduino UNO par un module ESP32-CAM (40 DT). Il diffuse une vidéo en direct sur Wi-Fi, accessible depuis un navigateur ou une app. Avec OpenCV côté serveur, vous pouvez faire de la détection d’objets, de la reconnaissance de couleurs, du suivi de cible — niveau projet de fin d’études INSAT ou ENSI.

Upgrade 4 — Encodeurs incrémentaux pour odométrie

Ajoutez des disques encodeurs sur les axes moteurs et deux capteurs optiques fourchus (15 DT la paire). Chaque trou détecté = X mm parcourus. Vous obtenez la distance réelle parcourue et la vitesse instantanée de chaque roue. Permet de programmer des trajets précis (“avancer de 50 cm puis tourner 90°”) sans timing approximatif, et d’asservir la vitesse.

Upgrade 5 — PID controller pour ligne droite parfaite

Combinez encodeurs + algorithme PID (Proportional-Integral-Derivative). Vous mesurez en temps réel l’écart de vitesse entre les deux roues, et vous ajustez les PWM en permanence pour le ramener à zéro. Le robot avance alors absolument droit, même sur sol incliné, même avec des moteurs déséquilibrés. Sujet phare des cours d’automatique en 3ème année à l’ENIT et l’ENSI.

FAQ — Questions fréquentes

Conclusion : votre premier pas dans la robotique embarquée

Construire un robot d’évitement d’obstacles, c’est bien plus qu’un projet du dimanche : c’est apprendre par la pratique tous les fondamentaux de l’électronique embarquée. Une fois ce robot fonctionnel, vous avez les bases pour vous lancer dans des projets de drone, de voiture autonome, de bras robotique, ou de domotique. À Didactico Sfax, on voit chaque année des étudiants ENIT et INSAT démarrer ainsi, puis présenter trois ans plus tard des projets de fin d’études impressionnants — souvent dérivés directement de ce premier robot.

Pour aller plus loin, lisez notre guide Comment Choisir le Bon Capteur Arduino qui détaille les capteurs alternatifs (LiDAR, infrarouge, lidar 360°) pour faire évoluer la perception de votre robot. Et notre guide Alimentations 2026 pour passer aux batteries Li-ion 18650 et gagner en autonomie. Bonne construction — et n’hésitez pas à venir présenter votre robot au comptoir Didactico Sfax, on adore voir vos créations !