Robot éviteur d’obstacles

Ce robot éviteur d’obstacles est vendu en kit, à assembler et à câbler soi-même : une base roulante à deux roues motrices, un capteur à ultrasons HC-SR04, un servomoteur SG90, une carte Arduino Uno R3 avec son câble USB, un module de commande de moteurs L298N, une plaque d’essai de 170 points, la visserie du châssis et les fils de liaison. Rien n’est monté, rien n’est câblé : le lot arrive en pièces, comme sur la photo. Les piles ne sont pas fournies.

L’objectif tient en une phrase : le robot avance et se détourne des obstacles qu’il rencontre. La difficulté du projet, et tout son intérêt, est dans la manière de voir. Un capteur à ultrasons ne mesure que dans un cône étroit ; posé fixe face à l’avant, il laisse un obstacle hors de son axe devenir invisible. C’est pour cela que le servo est fourni : il porte le capteur et le fait balayer de droite à gauche, de sorte que le robot sache non seulement qu’un mur est là, mais de quel côté la voie est libre. Le programme de cette fiche fait exactement cela. Aucune notice ni vidéo n’accompagne le lot : cette fiche en tient lieu.

Ce que contient le lot

Caractéristiques techniques

Comment le robot mesure une distance

Le capteur n’éclaire pas la scène et ne la photographie pas : il l’écoute. Son émetteur lance une salve d’ultrasons à 40 kHz, son récepteur attend l’écho renvoyé par ce qui se trouve devant. Le son parcourt environ 343 mètres par seconde dans l’air à 20 °C, soit 34,3 centimètres par milliseconde. La durée mesurée couvre l’aller et le retour : la distance en centimètres vaut donc la durée en microsecondes divisée par 58. C’est ce que fait la fonction de mesure du programme, et c’est tout ce qu’il y a à comprendre.

Trois conséquences pratiques expliquent la plupart des échecs de mise au point :

• Le cône est étroit. Le capteur ne voit que dans un angle inférieur à 15° de part et d’autre de son axe. Un pied de chaise à quarante centimètres sur la gauche du robot n’existe pas pour lui tant que le capteur regarde droit devant : d’où le servo, qui élargit le champ utile en déplaçant le regard plutôt qu’en ajoutant des capteurs.
• Certaines surfaces ne renvoient rien. Un tissu épais, un mur incliné, un objet de moins de quelques centimètres de large ou une surface molle dispersent ou absorbent les ultrasons : la mesure revient à zéro, ou annonce une distance trop grande. Un tapis et un mur de béton ne se détectent pas de la même façon, à distance égale.
• La mesure a une cadence, et deux capteurs voisins se brouillent. Compter au moins 60 ms entre deux mesures, davantage si la cible est lointaine : l’écho du tir précédent serait pris pour celui du suivant. Deux capteurs à ultrasons côte à côte qui tirent en même temps se reçoivent l’un l’autre. Le balayage du servo écarte naturellement ce risque, puisqu’il laisse plusieurs centaines de millisecondes entre deux tirs.
• Le capteur peut renvoyer le sol. Incliné vers le bas de quelques degrés, il mesure la distance au sol — quelques centimètres — et annonce un obstacle permanent. Il se monte horizontalement, à une quinzaine de centimètres au-dessus du sol, et le cône ne doit pas toucher le sol devant le robot.

Assembler le kit dans le bon ordre

L’ordre compte : chaque étape se vérifie avant que la suivante ne la rende difficile à atteindre.

Mini-projet : un robot qui balaie la voie devant lui

Objectif : le robot avance, s’arrête quand un obstacle se présente à moins de vingt-cinq centimètres, balaie la scène de droite à gauche avec le servo, puis repart dans la direction où la voie est la plus libre. C’est le projet qui réunit tout le lot : un capteur, un actionneur de position, un étage de puissance et deux moteurs commandés indépendamment.

Ce qu’il faut

Le câblage

Une remarque sur les broches, qui évite une panne difficile à comprendre : sur la carte Uno, la bibliothèque Servo occupe le compteur matériel qui produit les signaux de modulation de largeur d’impulsion sur les broches D9 et D10. Ces deux broches cessent alors de fonctionner en analogWrite. C’est la raison pour laquelle la vitesse des moteurs est ici câblée sur D6 et D5, et le servo sur D10 : un moteur branché sur D9 tournerait à pleine vitesse en permanence, quels que soient les ordres reçus.

Un moteur qui tourne à l’envers pour un ordre d’avance s’inverse en permutant ses deux fils sur sa borne de sortie. C’est la seule reprise à faire au câblage, et elle se fait moteur par moteur : rien n’impose un sens à un moteur à courant continu.

Le programme

À téléverser dans l’IDE Arduino. Le robot se pose au sol après le message du moniteur série, et avance par petites poussées : il mesure à l’arrêt, ce qui évite de rater un obstacle pendant l’avance.

/*
 * Robot eviteur d obstacles : capteur a ultrasons monte sur servomoteur
 * Carte : Arduino Uno R3
 * Servo : signal sur D10
 * HC-SR04 : TRIG sur D11, ECHO sur D12
 * Moteur gauche : ENA sur D6, IN1 sur D7, IN2 sur D8
 * Moteur droit  : ENB sur D5, IN3 sur D4, IN4 sur D2
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "Servo.h"

const byte SERVO_PIN = 10;
const byte TRIG = 11;
const byte ECHO = 12;

const byte ENA = 6;
const byte IN1 = 7;
const byte IN2 = 8;
const byte ENB = 5;
const byte IN3 = 4;
const byte IN4 = 2;

const byte VITESSE = 140;      // consigne de vitesse des moteurs, de 0 a 255
const int SEUIL = 25;          // distance en centimetres qui declenche l evitage
const int ROTATION = 400;      // duree d un virage, en millisecondes
const int AVANCE = 150;        // duree d une poussee en ligne droite, en ms

// Positions du servo, en degres : 0 vise a droite, 90 droit devant, 180 a gauche.
const byte ANGLES[] = {0, 45, 90, 135, 180};
const byte NB_ANGLES = 5;

Servo balayage;
byte meilleurAngle = 90;
int meilleureDistance = 0;

int mesurerDistance() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  unsigned long duree = pulseIn(ECHO, HIGH, 25000);
  if (duree == 0) {
    return 0;                  // aucun echo : cible molle, inclinee ou hors portee
  }
  return duree / 58;           // 58 microsecondes par centimetre, aller et retour
}

void moteurGauche(byte sens, byte vitesse) {
  if (sens == 0) {
    digitalWrite(IN1, LOW);
    digitalWrite(IN2, LOW);
    analogWrite(ENA, 0);
  } else if (sens == 1) {
    digitalWrite(IN1, HIGH);
    digitalWrite(IN2, LOW);
    analogWrite(ENA, vitesse);
  } else {
    digitalWrite(IN1, LOW);
    digitalWrite(IN2, HIGH);
    analogWrite(ENA, vitesse);
  }
}

void moteurDroit(byte sens, byte vitesse) {
  if (sens == 0) {
    digitalWrite(IN3, LOW);
    digitalWrite(IN4, LOW);
    analogWrite(ENB, 0);
  } else if (sens == 1) {
    digitalWrite(IN3, HIGH);
    digitalWrite(IN4, LOW);
    analogWrite(ENB, vitesse);
  } else {
    digitalWrite(IN3, LOW);
    digitalWrite(IN4, HIGH);
    analogWrite(ENB, vitesse);
  }
}

void arreter() {
  moteurGauche(0, 0);
  moteurDroit(0, 0);
}

void avancer() {
  moteurGauche(1, VITESSE);
  moteurDroit(1, VITESSE);
}

void reculer() {
  moteurGauche(2, VITESSE);
  moteurDroit(2, VITESSE);
}

void tournerGauche() {
  moteurGauche(2, VITESSE);    // roue gauche en arriere
  moteurDroit(1, VITESSE);     // roue droite en avant
}

void tournerDroite() {
  moteurGauche(1, VITESSE);
  moteurDroit(2, VITESSE);
}

// Balaie toute la scene et retient l angle ou la voie est la plus libre.
byte chercherLaVoieLibre() {
  meilleurAngle = 90;
  meilleureDistance = 0;
  for (byte i = 0; i != NB_ANGLES; i++) {
    balayage.write(ANGLES[i]);
    delay(350);                // le temps que le servo atteigne sa position
    int d = mesurerDistance();
    if (d > meilleureDistance) {
      meilleureDistance = d;
      meilleurAngle = ANGLES[i];
    }
  }
  balayage.write(90);
  delay(300);
  return meilleurAngle;
}

void eviter() {
  arreter();
  delay(150);
  byte angle = chercherLaVoieLibre();
  Serial.print("voie la plus libre a ");
  Serial.println(angle);
  if (angle == 90) {
    reculer();                 // les deux cotes sont bouches : marche arriere
    delay(2 * ROTATION);
    arreter();
  } else if (angle > 90) {
    tournerGauche();           // la voie libre est du cote gauche
    delay(ROTATION);
    arreter();
  } else {
    tournerDroite();           // la voie libre est du cote droit
    delay(ROTATION);
    arreter();
  }
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENA, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  pinMode(ENB, OUTPUT);
  balayage.attach(SERVO_PIN);
  balayage.write(90);
  Serial.begin(9600);
  arreter();
  delay(2000);                 // le temps de poser le robot au sol
}

void loop() {
  int d = mesurerDistance();
  if (d == 0) {
    arreter();                 // rien de detectable en face : le robot s arrete
    Serial.println("aucun echo");
    delay(200);
    return;
  }
  if (d >= SEUIL) {
    avancer();
    delay(AVANCE);
    arreter();
  } else {
    Serial.print("obstacle a ");
    Serial.print(d);
    Serial.println(" cm");
    eviter();
  }
}

Comment ça marche

• La mesure se fait en quatre instructions : mise à zéro de la broche de déclenchement, impulsion de 10 µs, puis attente de l’écho. La durée lue est convertie en centimètres par la division de la fonction, et rien d’autre n’est nécessaire.
• Le servo reçoit une consigne en degrés, pas une consigne de vitesse : chaque appel à la fonction d’écriture l’envoie vers sa position et l’y laisse. La pause de 350 ms qui suit laisse au capteur le temps d’arriver avant que la mesure ne soit prise — sans elle, le robot lit la distance d’une position qu’il n’a pas encore atteinte.
• Le programme compare les cinq mesures du balayage et garde la plus grande : c’est la direction la plus dégagée. Il ne cherche pas la plus petite distance, qui indiquerait simplement l’obstacle le plus proche.
• La remise au centre avant chaque décision et après chaque balayage garantit que le robot sait dans quel sens il regarde au moment où il repart, et qu’il ne reste pas le nez de travers après un virage.
• Le pivot s’obtient en faisant tourner un moteur dans chaque sens, donc sur place autour de son centre : c’est le seul cas où le châssis à deux roues se comporte comme un quatre roues, parce que les deux roues tournent en sens opposés.
• Quand la mesure revient à zéro, la fonction ne conclut pas « voie libre » mais « rien de détectable ». Le programme arrête le robot plutôt que de foncer : un mur incliné ou un tapis se comporte exactement comme une absence de mesure, et il vaut mieux s’arrêter devant que dedans.
• Le moniteur série affiche la distance et l’angle retenu à chaque décision : c’est là que se lit tout le comportement du robot, et c’est plus rapide que de le regarder tourner.

La mise au point, dans cet ordre

1. Vérifier le sens des moteurs, roues en l’air. Téléverser, ouvrir le moniteur série à 9600 bauds, alimenter le module. Si un moteur tourne à l’envers pour l’ordre d’avance, permuter ses deux fils sur sa borne de sortie. Ne pas passer à l’étape suivante avant que les deux roues avancent ensemble.
2. Contrôler le sens du servo. Faire écrire tour à tour zéro, quatre-vingt-dix et cent quatre-vingts degrés au servo : si le capteur pointe vers la droite quand le programme croit qu’il pointe à gauche, monter le palonnier dans l’autre sens, ou permuter les deux branches du test de direction dans la fonction d’évitement.
3. Mesurer à la main devant un mur. Présenter une feuille de carton à trente centimètres et lire la valeur affichée. L’écart doit tenir dans deux ou trois centimètres. Si la valeur saute, le capteur est mal alimenté ou mal fixé — pas mal programmé.
4. Contrôler le cône et le sol. Approcher le robot d’un pied de chaise placé de biais, à vingt centimètres : le capteur ne doit le voir qu’une fois le balayage commencé. Poser ensuite le robot au sol et vérifier qu’aucune mesure ne tombe sous dix centimètres au repos, ce qui signalerait un capteur incliné qui lit le sol.
5. Régler le seuil sur le terrain. Vingt-cinq centimètres convient sur un sol plat et un robot qui avance par poussées de 150 ms. Sur un sol glissant, le robot parcourt plus de chemin pendant cette poussée : augmenter le seuil, ou réduire la durée d’avance.
6. Réduire la vitesse en cas de collisions. Un robot qui percute un obstacle sur trois a une vitesse d’approche trop grande pour sa distance de freinage : c’est la consigne de vitesse qu’on baisse, pas le seuil qu’on monte. Monter le seuil rend le robot peureux loin des murs sans le rendre plus sûr.

Variante : deux capteurs fixes plutôt qu’un balayage

Le balayage coûte du temps — plus d’une seconde entre la détection et le virage, puisque le capteur doit visiter cinq positions avant de décider. Un robot plus rapide y perd. La variante classique consiste à supprimer le servo et à poser deux capteurs à ultrasons fixes, l’un orienté vers la gauche et l’autre vers la droite : la comparaison des deux distances donne la direction libre sans aucune pièce mobile, et la décision tombe en deux mesures. En contrepartie, la largeur couverte est plus faible, les deux capteurs doivent tirer l’un après l’autre pour ne pas se brouiller, et le montage ne détecte plus rien droit devant si le robot avance vers un obstacle étroit. Le servo reste préférable quand on veut voir devant et sur les côtés avec un seul capteur : c’est aussi la version qui apprend le plus, puisqu’elle fait commander un moteur de position en même temps que deux moteurs de traction.

Questions fréquentes

Pourquoi le moteur branché sur la broche D9 tourne-t-il toujours à fond ?

Parce que la bibliothèque Servo occupe sur la carte Uno le compteur matériel qui commande les broches D9 et D10 : ces deux broches perdent la modulation de largeur d’impulsion, et un moteur qui y est branché ne reçoit plus qu’un signal plein. La vitesse des moteurs se câble sur D5 et D6, qui restent disponibles, et le servo garde D10. Si le moteur gauche tourne à fond quels que soient les ordres, chercher de ce côté avant de suspecter le module de puissance.

Le robot s’arrête au milieu d’une pièce vide en annonçant « aucun écho », est-ce un défaut ?

Non, c’est le comportement prévu, et il indique une cible que les ultrasons ne renvoient pas : un tissu épais, un mur très incliné, un objet étroit, ou une surface trop lointaine pour l’écho attendu. Faire le test avec une main ou une feuille de carton devant le capteur : si la mesure revient aussitôt, le capteur fonctionne et c’est bien la scène qui est en cause. Si la mesure ne revient jamais, vérifier le câblage des broches de déclenchement et d’écho, qui sont souvent inversées au montage.

Le servo frémit et la carte redémarre quand les moteurs démarrent

C’est un problème d’alimentation, pas de programme. Les deux moteurs appellent une pointe de courant au démarrage, qui fait chuter la tension du porte-piles et, par ricochet, celle de la carte si tout est alimenté depuis la même source. Le symptôme est net : le moniteur série réaffiche son message d’accueil à chaque démarrage des moteurs. Séparer les alimentations — porte-piles pour les moteurs, USB ou source dédiée pour la carte, masses communes — et le servo cesse de frémir. Un servo dont l’axe est bloqué mécaniquement demande à lui seul jusqu’à six cents milliampères : c’est aussi une cause possible à vérifier en le débranchant.

Faut-il souder les fils des moteurs ou du servo ?

Le câble du servo est terminé par un connecteur à trois broches, qui se plante directement sur les broches de la carte, ou dans la plaque d’essai de 170 points fournie. Les fils des moteurs, eux, sont soit déjà fixés sur leurs plots, soit livrés séparés et à souder, selon le lot : à vérifier à la réception, avant de remonter le châssis. En profiter pour repérer la couleur des fils de chaque côté — c’est ce repérage qui évite d’inverser les deux moteurs au moment du branchement sur le module.

Quelle différence avec la version v2 du robot éviteur d’obstacles ?

La mécanique, le capteur, le servo et le programme sont les mêmes. Ce qui change est l’étage de puissance : cette version-ci utilise un module L298N câblé à la main sur la plaque d’essai, et le robot éviteur d’obstacles v2 un shield de commande de moteurs qui se plante directement sur la carte Arduino, sans câblage de puissance. Le module séparé oblige à comprendre le câblage, ce qui est justement l’objet de ce kit ; le shield va plus vite et laisse moins de fils visibles. Le même programme fonctionne sur les deux, seuls les numéros de broches du module changent.

À combiner avec

Le capteur à ultrasons et le servo sont fournis, mais rien ne les assemble : c’est ce que le lot ne contient pas, et c’est ce qu’il faut prévoir pour monter la tête balayante décrite plus haut. Un support pour capteur HC-SR04 se visse sur le palonnier et reçoit le module à son empreinte, et un support de servo SG90 fixe le servo sur la platine du châssis sans perçage. Les deux pièces tiennent le capteur droit et parallèle au sol : c’est de cette rigidité que dépend la régularité des mesures, bien plus que du programme.

Si le but est d’avoir un robot complet et fonctionnel sans réunir les pièces une à une, le kit robot 4WD IR Bluetooth multi-fonctions réunit une mécanique équivalente avec sa carte de commande, ses capteurs et sa connectique. À l’inverse, pour un projet qui demande moins de mécanique, le robot suiveur de ligne se contente de deux capteurs optiques et d’une bande adhésive au sol, sans servo ni mesure de distance.

Les autres bases roulantes, capteurs de distance et servomoteurs de cette famille se trouvent dans robot et dans packs, kits et robots.