Robot éviteur d’obstacles v2

Cette version v2 du robot éviteur d’obstacles est vendue en kit, à assembler et à câbler soi-même : une base roulante à deux roues motrices, une carte Arduino Uno R3 avec son câble USB, un capteur à ultrasons HC-SR04, un servomoteur SG90 qui porte le capteur, un shield de commande de moteurs L293D qui s’empile directement sur la carte, une plaque d’essai de 170 points, vingt fils de liaison et la visserie du châssis. Rien n’est monté, rien n’est câblé : le lot arrive en pièces, comme sur la photo. Les piles et les supports de fixation du servo et du capteur ne sont pas fournis.

Le principe du robot est simple à énoncer : il avance, mesure la distance devant lui, et se détourne quand un obstacle se présente. Ce qui distingue cette version, c’est son étage de puissance. Là où la première version confie la commande des moteurs à un module séparé qu’il faut câbler fil à fil sur la plaque d’essai, celle-ci emploie un shield qui se plante sur la carte Arduino : les deux moteurs se raccordent dans des borniers à vis, la partie électronique s’assemble en quelques minutes et l’attention se reporte entièrement sur le programme. Le revers est qu’il faut installer la bibliothèque du shield avant d’écrire la première ligne de code. Aucune notice ni vidéo n’accompagne le lot : cette fiche en tient lieu.

Ce que contient le lot

Caractéristiques techniques

Le shield, la pièce qui change tout

Un shield est une carte qui se pose sur l’Arduino comme une pièce de puzzle : ses rangées de broches femelles s’enfoncent dans celles de la carte, et les broches inutilisées ressortent au-dessus, toujours accessibles. Une fois empilé, le shield prend en charge toute la puissance : ses deux circuits L293D contiennent quatre ponts en H, c’est-à-dire de quoi faire tourner quatre moteurs dans les deux sens, ou deux moteurs pas à pas. Le robot de cette fiche n’en utilise que deux, mais la place est là.

Ce qui se passe à l’intérieur explique le mode d’emploi. Les ordres de sens ne sont pas envoyés par une broche par moteur : un registre à décalage les concentre, et quatre broches seulement dialoguent avec lui. La vitesse, elle, reste analogique, une broche par moteur. La conséquence pratique est double et se lit dans le tableau des broches : le shield réquisitionne quatre broches fixes, puis une broche de vitesse par moteur utilisé, et laisse tout le reste, entrées analogiques comprises, aux capteurs du montage. Deux moteurs, un capteur à ultrasons et un servomoteur tiennent donc ensemble sans le moindre conflit.

Un point mérite attention avant le premier essai : le cavalier d’alimentation marqué PWR, à côté du bornier. En place, il fait alimenter les moteurs par la carte Arduino elle-même. Retiré, chaque source alimente son monde : le porte-piles les moteurs, l’USB ou la prise jack la carte. C’est le montage retenu ici, parce que les appels de courant des moteurs ne viennent plus perturber le microcontrôleur. La règle qui évite la casse est de ne jamais avoir à la fois le cavalier en place et une alimentation branchée sur le bornier : les deux sources se retrouveraient en parallèle.

Assembler le kit dans le bon ordre

Chaque étape se vérifie avant que la suivante ne la rende difficile à corriger.

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, fait balayer son capteur de droite à gauche, puis repart du côté où la voie est la plus libre. Le projet réunit tout le lot : un capteur, un moteur de position, un étage de puissance et deux moteurs de traction commandés séparément.

Ce qu’il faut

Le câblage

Le choix de A0 et A1 n’est pas un hasard : les deux entrées analogiques servent ici d’entrées-sorties numériques ordinaires, ce qu’elles savent faire, et elles ne sont réclamées ni par le shield ni par le serveur de position. Le capteur se branche donc sur les broches libres, sans toucher aux broches que le shield utilise. Le câble du servo, lui, est terminé par un connecteur trois broches : il se plante dans l’un des deux en-têtes du shield, sans forcer, dans le seul sens possible.

Un moteur qui tourne à l’envers pour un ordre d’avance n’est pas un moteur défectueux : sur un moteur à courant continu, le sens dépend uniquement de l’ordre des deux fils. Il s’inverse en permutant ces deux fils dans leur bornier, moteur par moteur, alimentation coupée.

Le programme

À téléverser dans l’IDE Arduino après avoir installé la bibliothèque du shield. 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 v2 : capteur a ultrasons sur servomoteur,
 * moteurs pilotes par le shield L293D empile sur la carte.
 * Carte : Arduino Uno R3 + shield moteur L293D
 * Servo : en-tete servo du shield, attache sur D10
 * HC-SR04 : TRIG sur A0, ECHO sur A1
 * Moteur gauche : bornes M1 du shield, moteur droit : bornes M2
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "AFMotor.h"
#include "Servo.h"

const byte SERVO_PIN = 10;
const byte TRIG = A0;
const byte ECHO = A1;

const byte VITESSE = 170;      // vitesse des deux 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, 90, 180};
const byte NB_ANGLES = 3;

AF_DCMotor roueGauche(1);      // moteur branche sur les bornes M1
AF_DCMotor roueDroite(2);      // moteur branche sur les bornes M2
Servo balayage;

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 arreter() {
  roueGauche.run(RELEASE);
  roueDroite.run(RELEASE);
}

void avancer() {
  roueGauche.run(FORWARD);
  roueDroite.run(FORWARD);
}

void reculer() {
  roueGauche.run(BACKWARD);
  roueDroite.run(BACKWARD);
}

void tournerGauche() {
  roueGauche.run(BACKWARD);    // roue gauche en arriere
  roueDroite.run(FORWARD);     // roue droite en avant
}

void tournerDroite() {
  roueGauche.run(FORWARD);
  roueDroite.run(BACKWARD);
}

// Balaie la scene et retient l angle ou la voie est la plus libre.
byte chercherLaVoieLibre() {
  byte meilleurAngle = 90;
  int 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);
  } else if (angle == 180) {
    tournerGauche();           // la voie libre est du cote gauche
    delay(ROTATION);
  } else {
    tournerDroite();           // la voie libre est du cote droit
    delay(ROTATION);
  }
  arreter();
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  roueGauche.setSpeed(VITESSE);
  roueDroite.setSpeed(VITESSE);
  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 tient en quatre instructions : broche de déclenchement mise au repos, impulsion de 10 µs, puis attente de l’écho. La durée lue est convertie en centimètres par une simple division.
• Les deux moteurs sont déclarés une fois pour toutes, avec leur numéro de bornier, et leur vitesse est fixée dans la phase d’initialisation. Ensuite, chaque ordre se réduit à un mot : avant, arrière, ou relâché. C’est la bibliothèque du shield qui traduit cet ordre en signaux pour les ponts en H, et c’est ce qui laisse le programme lisible.
• La commande de relâchement coupe l’alimentation du moteur et le laisse tourner librement : le robot s’arrête en roulant sur son élan. Pour peu qu’on avance par poussées brèves, comme ici, cet arrêt progressif suffit et n’use pas la mécanique, contrairement à un freinage par inversion.
• Le servo reçoit une consigne de position, pas de vitesse. La pause de 350 ms qui suit chaque consigne 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.
• Trois positions suffisent ici parce que le pivot se fait de toute façon sur place et que le robot reprend sa route après chaque décision. Ce balayage à trois arrêts décide plus vite qu’un balayage plus fin ; en contrepartie, un obstacle placé exactement entre deux positions mesurées peut passer inaperçu, et la première version du robot, qui visite cinq positions, couvre mieux l’intervalle.
• Le programme retient la plus grande des distances mesurées, pas la plus petite : la plus petite indiquerait seulement l’obstacle le plus proche, alors que c’est la direction la plus dégagée qui l’intéresse.
• Quand la mesure revient à zéro, le programme ne conclut pas « voie libre » mais « rien de détectable », et arrête le robot. Un mur très incliné, un tissu ou un objet filiforme se comportent exactement comme une absence de mesure : mieux vaut s’arrêter devant que dedans.
• Le moniteur série affiche la distance et l’angle retenu à chaque décision : tout le comportement du robot s’y lit, plus vite qu’en le regardant tourner.

La mise au point, dans cet ordre

1. Installer la bibliothèque du shield. Chercher Adafruit Motor Shield dans le gestionnaire de bibliothèques de l’IDE et installer la version 1. La version 2 correspond à un autre shield, à transistors, et ne commande pas celui-ci : c’est la cause de compilation la plus fréquente.
2. Vérifier le sens des moteurs, roues en l’air. Téléverser, ouvrir le moniteur série à 9600 bauds, alimenter le bornier. Si un moteur tourne à l’envers pour l’ordre d’avance, permuter ses deux fils dans son bornier. Ne pas passer à l’étape suivante avant que les deux roues avancent ensemble.
3. 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 à droite quand le programme croit qu’il pointe à gauche, remonter le palonnier dans l’autre sens.
4. 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. Une valeur qui saute indique une alimentation ou une fixation en cause, pas un défaut de programme.
5. Contrôler le cône et le sol. Poser le robot au sol et vérifier qu’aucune mesure ne tombe sous dix centimètres au repos : ce serait un capteur incliné qui lit le sol devant lui.
6. Régler le seuil sur le terrain. Vingt-cinq centimètres conviennent sur un sol plat avec des poussées de 150 ms. Sur un sol glissant, le robot parcourt plus de chemin pendant la même poussée : augmenter le seuil, ou raccourcir l’avance.

Variante : le capteur fixe, sans servo

Le servo ne sert qu’à élargir le champ de vision. Si on ne l’utilise pas encore, le montage fonctionne sans lui : le capteur se fixe droit devant, et le programme remplace le balayage par une marche arrière suivie d’un pivot d’une durée fixe, par exemple en tournant toujours du même côté. Le robot devient un « anti-collision » pur, qui avance, s’arrête, recule et repart de biais. Il perd la notion de direction libre, mais il fonctionne dès la première heure de montage, sans aucun support mécanique à prévoir, et le programme reste le même pour tout le reste.

Questions fréquentes

Le programme refuse de compiler, que faire ?

Le message d’erreur porte presque toujours sur le fichier d’en-tête de la bibliothèque du shield, absent de l’installation. Ouvrir le gestionnaire de bibliothèques de l’IDE Arduino, chercher Adafruit Motor Shield et installer la version 1 : la version 2 correspond à un autre shield et donne exactement le même refus. Après installation, fermer et rouvrir l’IDE pour qu’il prenne la bibliothèque en compte.

Les moteurs ne tournent pas, ou sifflent sans bouger

Trois causes couvrent la quasi-totalité des cas : le bornier d’alimentation des moteurs est vide ou sa polarité est inversée, la masse commune entre le porte-piles et la carte n’est pas reliée, ou les piles sont en fin de vie. Un moteur branché deux secondes directement sur une pile permet de trancher : s’il tourne, le défaut est côté montage ; sinon il est côté moteur. Un moteur qui siffle sans tourner indique presque toujours une tension trop basse.

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 ; si la carte et les moteurs partagent la même source, la tension chute et le microcontrôleur redémarre — le moniteur série réaffiche son message d’accueil à chaque démarrage des moteurs, ce qui ne trompe pas. Garder le cavalier d’alimentation retiré et alimenter la carte de son côté règle le problème dans la plupart des cas. Un servo dont l’axe est bloqué mécaniquement demande à lui seul jusqu’à six cents milliampères : c’est une seconde cause à écarter en le débranchant.

Quelle différence avec la version précédente du robot éviteur d’obstacles ?

La mécanique est la même : même châssis à deux roues, même capteur, même servo, même logique de programme. Ce qui change est la façon de commander les moteurs. La première version emploie un module L298N câblé à la main sur la plaque d’essai : chaque entrée de direction rejoint une broche de la carte, le montage se dépanne facilement parce que tout est visible, et le module encaisse un courant plus élevé. Cette version-ci emploie un shield qui s’empile, ne réquisitionne que quatre broches fixes, accepte jusqu’à quatre moteurs et ne demande aucun câblage de puissance — en échange, il faut installer sa bibliothèque et accepter un courant admissible plus limité, six cents milliampères par pont au lieu de deux ampères.

À combiner avec

Le capteur 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. Ces deux pièces tiennent le capteur droit et parallèle au sol : de cette rigidité dépend la régularité des mesures, bien plus que du programme.

Pour 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 pilotes de moteurs de cette famille se trouvent dans robot et dans moteurs et drivers.