Radar de recul avec Arduino

Si on utilisait Arduino pour fabriquer un radar de recul sonore, comme sur les voitures ?

Radar de recul avec Arduino installé sur une voiture Radiocommandée

Ce projet de radar de recul repose sur l’interfaçage d’Arduino avec 2 périphériques:

  • un haut-parleur pour l’émission des bips de recul: ce sera le même haut-parleur que celui que nous avons utilisé pour le projet « Au clair de la lune avec Arduino« .
  • un capteur de proximité pour  la mesure de la distance à l’obstacle: le HC-SR04.

Le capteur HC-SR04 utilise le principe du sonar pour mesurer la distance à un objet, il est pour cela composés de 2 modules à ultrasons:

  • un premier module pour émettre des ultrasons à intervalle régulier
  • un deuxième module lui permettant de détecter le retour de ces ultrasons lorsqu’ils sont renvoyés par un obstacle.

La mesure du temps qui écoulé entre l’émission et la réception de ces ultrasons permet ensuite d’en déduire la distance à l’objet.

Le matériel nécessaire

Voici les éléments requis pour cette réalisation:

Carte Arduino UNO Rev 3 Cordon USB de type A/B Haut-parleur 8 Ohm de 50 mm
Carte Arduino UNO Câble USB 2.0 Type A/B Haut-parleur 8 Ohm
Capteur à ultrasons HC-SR04 Extension de protoypage pour Arduino
Capteur HC-SR04 Cables ProtoSchield
Résistance de 100 ohm    
Résistance 100 Ohm    

Câblage

Le câblage du haut-parleur est le même que celui décrit ici dans l’article « Au clair de la lune avec Arduino » à la différence que nous utilisons un ProtoSchield avec une mini plaque d’essai, il suffit de:

  • relier un de ses fils à la masse
  • relier le deuxième fil à une résistance de 100Ω elle même reliée la sortie digitale 8 de l’Arduino.

Le capteur HC-SR04 possède 4 broches nommées « VCC », « Trig », « Echo » et « GND » que nous câblerons de la manière suivante:

Pour l’alimentation :

  • La broche VCC du HC-SR04 est à relier au +5v de l’Arduino.
  • La broche GND du HC-SR04 est mettre à la masse de l’Arduino (GND).

Pour la mesure :

  • La broche Trig du HC-SR04 est à relier à la sortie 12 de l’Arduino, elle sert à déclencher l’émission des ultrasons.
  • La broche Echo du HC-SR04 connectée à l’entrée 11 de l’Arduino capte les ultrasons qui sont renvoyés par les objets.
Branchement d'un Haut parleur et d'un capteur HC-SR04 sur Arduino

Installation d’une bibliothèque pour le capteur HC-SR04

Nous allons utiliser la bibliothèque Arduino NewPing nommée « NewPing by Tim Eckel » dans ce projet. Je vous invite à l’installer avant de pour suivre.

Si vous souhaitez connaitre la procédure d’installation d’une bibliothèque sous Arduino, je vous invite à vous reporter au chapitre « Installation d’une bibliothèque pour l’écran OLED » de l’article « Température et humidité avec Arduino ».

Code logiciel pour la gestion du capteur HC-SR04

Comme d’habitude, nous démarrons l’écriture de notre radar de recul par l’ossature de code Arduino suivante:

// Fonction de démarrage, s'exécute une seule fois:
void setup()
{

}

// Fonction principale du programme, s'exécute en boucle:
void loop()
{

}

Nous commençons par indiquer au compilateur Arduino que nous utilisons la bibliothèque NewPing:

// Déclaration des librairies utilisées
#include <NewPing.h>

Les informations d’utilisation de la librairie NewPing sont disponibles à ce lien.

Pour initialiser cette librairie, nous appelons le constructeur NewPing en lui indiquant en paramètres les ports d’entré/sortie utilisés pour le câblage ainsi que la distance maximale de 50 centimètres que le capteur HC-SR04 est capable de gérer:

// Définition des constantes globales
#define PORT_EMETTEUR   12  // Port Arduino branché à la broche Trig du HC-SR04.
#define PORT_RECEPTEUR  11  // Port Arduino branché à la broche Echo du HC-SR04.
#define DISTANCE_MAX 50 // Distance maximale que sait gérér la capteur HC-SR04.

NewPing sonar(PORT_EMETTEUR, PORT_RECEPTEUR, DISTANCE_MAX); // Initialisation de la librairie NewPing.

Le calcul et la lecture de la distance entre le capteur et l’obstacle le plus proche s’effectuent par un simple appel à la méthode « ping_cm » de l’objet « sonar » que nous venons de déclarer précédemment. Afin de laisser le temps au capteur d’effectuer son calcul, nous utilisons la fonction « delay » pour insérer une attente de 50 millisecondes entre 2 appels à cette méthode :

// Fonction principale du programme, s'exécute en boucle:
void loop()
{
  // Variables locale de la fonction
  unsigned long DistanceLue_L;

  delay(50);  // Attente de 50ms
  DistanceLue_L = sonar.ping_cm(); // Envoi des ultrasons, écoute de leur réflexion, puis calcul de la distance en centimètres.
}

Maintenant que nous venons de stocker la valeur de la distance à l’obstacle dans  la variable « DistanceLue_L« , il nous reste à générer les bips sonores pour informer le conducteur.

Code logiciel pour la gestion des bips de recul

Avant de rentre dans le détail du code logiciel, je vais vous détailler les caractéristiques de mon radar de recul avec Arduino. Celui-ci signale au conducteur la distance à l’obstacle par des bips d’1/4 de secondes plus ou moins espacés. Lorsque l’obstacle est à la limite de détection du capteur HC-SR04 (50 cm) et au-delà, les bips sonores sont espacés d’une seconde.

Un bip par seconde en limite de détection

Plus le véhicule (et donc le capteur HC-SR04) est proche de l’obstacle, plus les bips sonores se rapprochent. Quand le capteur est à la limite de collision (5 cm), les bips sonores sont tellement proches qu’ils ne forment plus qu’un son continu:

Un son continu proche de la collision

Pour la fréquence sonore du son, j’ai choisi 784 hertz afin d’être proche du son émise par ma Renault.

Suite à ces informations, nous pouvons en déduire les constantes suivantes définissant les caractéristiques de notre radar:

#define FREQUENCE_DU_BIP 784 // Fréquence qui sera utilisée pour émettre les bips sonores
#define DUREE_BIP 250 // Définit la durée d'un bip en millisecondes
#define DISTANCE_BIP_CONTINU 5 // Définit la proximité à partir de laquelle on a un bip continu

Nous appelons « Delai_L » la variable représentant la durée (en millisecondes) entre de 2 bips sonores successifs émis.

Pour le cas d’une distance supérieure à la distance de détection du capteur HC-SR04 (50 cm) nous pouvons écrire le code suivant:

  if(DistanceLue_L == 0)
  {
     // Pas d'obstacle détecté
    Delai_L = 1000; // Par défaut un bip par seconde    
  }

Pour le cas d’une distance inférieur à la distance de proximité de collision (5cm), le code logiciel suivant s’applique :

  else if(DistanceLue_L < DISTANCE_BIP_CONTINU)
  {
     // On est proche de la collision
    Delai_L = DUREE_BIP; // bip continu    
  }

Et enfin pour une distance entre 5cm et 50cm, le rapprochement des bips sonores dépend de la distance:

  else
  {
    Delai_L = (float)DistanceLue_L * (float)(1000 - DUREE_BIP)/(float)(DISTANCE_MAX - DISTANCE_BIP_CONTINU) + DUREE_BIP;  
  }

Code logiciel complet

Après tout ces explications, voici le code logiciel complet du projet:

// Déclaration des librairies utilisées
#include <NewPing.h>

// Définition des constantes globales
#define PORT_EMETTEUR   12  // Port Arduino branché à la broche Trig du HC-SR04.
#define PORT_RECEPTEUR  11  // Port Arduino branché à la broche Echo du HC-SR04.
#define DISTANCE_MAX 50 // Distance maximale que sait gérér la capteur HC-SR04.
#define FREQUENCE_DU_BIP 784 // Fréquence qui sera utilisée pour émettre les bips sonores
#define DUREE_BIP 250 // Définit la durée d'un bip en millisecondes
#define DISTANCE_BIP_CONTINU 5 // Définit la proximité à partir de laquelle on a un bip continu

NewPing sonar(PORT_EMETTEUR, PORT_RECEPTEUR, DISTANCE_MAX); // Initialisation de la librairie NewPing.
unsigned long HeureDernierBip_G;

// Fonction de démarrage, s'exécute une seule fois:
void setup()
{
  HeureDernierBip_G = 0;
}
// Fonction principale du programme, s'exécute en boucle:
void loop()
{
  // Variables locale de la fonction
  unsigned long DistanceLue_L;
  unsigned long Delai_L;

  // Valeurs par defaut
  Delai_L = 1000; // Par défaut un bip par seconde

  delay(50);  // Attente de 50ms
  DistanceLue_L = sonar.ping_cm(); // Envoi des ultrasons, écoute de leur réflexion, puis calcul de la distance en centimètres.
  if(DistanceLue_L == 0)
  {
     // Pas d'obstacle détecté
    Delai_L = 1000; // Par défaut un bip par seconde    
  }
  else if(DistanceLue_L < DISTANCE_BIP_CONTINU)
  {
     // On est proche de la collision
    Delai_L = DUREE_BIP; // bip continu    
  }
  else
  {
    Delai_L = (float)DistanceLue_L * (float)(1000 - DUREE_BIP)/(float)(DISTANCE_MAX - DISTANCE_BIP_CONTINU) + DUREE_BIP;  
  }
  
  if(millis()> HeureDernierBip_G + Delai_L)
  {
    HeureDernierBip_G = millis();
    tone(8, FREQUENCE_DU_BIP, DUREE_BIP);
  }
}

Modification de la bibliothèque « NewPing« 

Si vous compilez le programme que nous venons d’écrire sans effectuer de modification de la bibliothèque Arduino NewPing, vous allez rencontrer l’erreur suivante:

Erreur de compilation: Multiple definition of '__vector_7'

Cette erreur de compilation nous informe que notre code logiciel tente d’utiliser 2 fois la même ressource matérielle pour effectuer 2 actions différentes, ce qui est physiquement impossible. La ressource matérielle en question est nommée « Timer2« , il s’agit d’un timer matériel 8 bits de l’Atmega328 (le microcontrôleur de la carte Arduino Uno) qui est utilisé à la fois:

  • par la la fonction « tone » afin de générer la modulation de fréquence du signal envoyé au haut-parleur,
  • par la bibliothèque NewPing pour des fonctions basées sur un mécanisme d’interruptions logicielles.

La solution que je vous propose est de supprimer l’utilisation du « Timer2 » par la bibliothèque NewPing. En effet nous n’utilisons pas les fonctions concernées.

Pour cela, naviguez vers le dossier « Documents > Arduino > libraries > NewPing > src« . Une fois dans ce dossier, ouvrez le fichier « NewPing.h » avec  un éditeur de code logiciel comme par exemple le logiciel open source « Notepad++ » disponible ici.

Une fois ce fichier ouvert, recherchez la ligne…

	#define TIMER_ENABLED true      // Set to "false" to disable the timer ISR (if getting "__vector_7" compile errors set this to false). Default=true

… et remplacez le « true » par « false« . Enregistrez votre modification et voilà, votre bibliothèque NewPing n’utilisera plus le « Timer2 ».

Vous pouvez maintenant relancer la compilation de votre programme puis le transférer dans l’Arduino. Voici le résultat:

Ce contenu a été publié dans Arduino. Vous pouvez le mettre en favoris avec ce permalien.

3 réponses à Radar de recul avec Arduino

  1. phossec dit :

    Super tu pourra le mettre sur la voiture de maman.

  2. Grognatou dit :

    T’on prochain tuto poura t’il étre sur comment
    Controler la lampe arduino grace au wifi de la carte arduino et son telephone

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *