Introduction

Le capteur de distance (aussi appelé capteur ultrason) permet de réaliser des mesures de distance. Il permet d’estimer une distance allant de 2 cm à 400 cm avec une précision de 3mm. C’est le capteur de distance le plus utilisé et le moins cher. Il en existe des bien plus précis mais aussi bien plus chers.

Vous pouvez vous en procurer ici ou bien le trouver dans ce kit.

Comment ça marche ?

Pour mesurer la distance le capteur ultrason utilise un signal envoyé depuis la borne Trigger (Trig) et reçu par la borne Echo. Le temps que met la borne Echo à recevoir le signal permet de connaître la distance entre le capteur et l’objet.

Voici le calcul de la distance faite par le capteur ultrason :  Distance = (signal reçu * vitesse du son) /2

Avec la vitesse du son dans l’air qui vaut 340 m/s.

Nous allons voir plusieurs exemples courants dans lesquels le capteur d’ultrason HC-SR04 est utilisé.

Fonctionnement du capteur de distance avec une librairie

Pour commencer à faire fonctionner le capteur, il faut installer la librairie HC-SR04 sur arduino :

Voici un premier programme permettant de mesurer la distance grâce au capteur :

#include "SR04.h" //Librairie 

// définition des broches du capteur
const int trigPin =2;
const int echoPin =3;

UltraSonicDistanceSensor distanceSensor(trigPin, echoPin); // initialisation du capteur avec les broches utilisées

void setup() {
    Serial.begin(9600) ; // Initialisation de la communication avec le moniteur série (9600 bits/s)
}
void loop() {
    // Mesure et affiche la distance en centimètre sur le port série toutes les 500 ms
    Serial.print("Distance en cm :") ;
    Serial.println(distanceSensor.measureDistanceCm()) ;
    delay (500) ;
}

Voici un schéma du câblage du capteur :

Voici le résultat que l’on peut voir sur le moniteur série

Fonctionnement du capteur de distance sans librairie

Il est possible de faire fonctionner le capteur à ultra son sans utiliser de librairie. Pour cela on va devoir nous-même calculer la durée de l’écho, c’est-à-dire le temps que met le capteur à ultrason à recevoir le faisceau. Puis nous calculerons la distance entre le capteur et l’objet.

Pour pouvoir se passer de la librairie, il y faut ajouter certains éléments dans votre programme.

Etape 1

Tout d’abord vous allez devoir démarrer un faisceau de 10 microsecondes sur la borne trig afin de démarrer le signal.

digitalWrite(trigPin, LOW);
delayMicroseconds(5);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

 

On peut voir ici que le signal est éteint puis allumé pendant 10 microsecondes puis éteint une deuxième fois.

Etape 2

On récupère le temps que met le signal à revenir au capteur : duree = pulseIn(echoPin, HIGH);

On calcule ensuite cette distance avec la formule donnée précédemment :  Distance = (signal reçu * vitesse du son) /2

Vitesse du son dans l’air : 340 m/s

On a donc : distance = durée*0.034/2 ;

Etape 3 : code final

Voici le même code qui n’utilise pas la librairie cette fois-ci :

// Définition des numéros de port
const int trigPin = 2; // Trigger (émission)
const int echoPin = 3; // Echo (réception)

// Variables utiles
long duree; // Durée de l'echo
int distance;

void setup() {
    pinMode(trigPin, OUTPUT); // Configuration du port du Trigger comme une SORTIE
    pinMode(echoPin, INPUT); // Configuration du port de l'Echo comme une ENTREE
    Serial.begin(9600) ; // Démarrage de la communication série à 9600 bits/s
}
void loop() {
    // Émission d'un signal de durée 10 microsecondes
    digitalWrite(trigPin, LOW);
    delayMicroseconds(5);
    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW);
    // Écoute de l'écho
    duree = pulseIn(echoPin, HIGH);
    // Calcul de la distance
    distance = duree*0.034/2;
    // Affichage de la distance dans le Moniteur Série
    Serial.print("Distance en cm :") ;
    Serial.println(distance) ;
    delay(500); // Délai d'attente pour éviter d'afficher trop de résultats à la seconde
}

Capteur de distance relié à une Led

Dans le programme si dessous l’intensité de la led va changer en fonction de la distance de l’obstacle.

Son intensité est exprimée en pourcentage dans le tableau ci-dessous :

0%1 mètre < Distance
50 %30 centimètres < Distance < 1 mètre
75 %15 centimètres < Distance < 30 centimètres
100 %0 centimètre < Distance < 15 centimètres

Voici le programme avec la librairie :

#include "SR04.h" // Librairie 
// Définition des broches du capteur
const int trigPin = 2;
const int echoPin = 3;
const int LED=9;
UltraSonicDistanceSensor distanceSensor(trigPin, echoPin); // Initialisation du capteur avec les broches utilisées

void setup() {
    pinMode(LED, OUTPUT);
    Serial.begin(9600) ; // Initialisation de la communication avec le moniteur série à 9600 bits/s
}
void loop() {
    // Mesure et affiche la distance en centimètres sur le port série toutes les 500 ms
    Serial.print("Distance en cm :");
    Serial.println(distanceSensor.measureDistanceCm());
    if (distanceSensor.measureDistanceCm()>100){
        analogWrite(LED,0);
    }
    if (distanceSensor.measureDistanceCm()<100 and distanceSensor.measureDistanceCm()>30){
        analogWrite(LED,123);
    }
    if (distanceSensor.measureDistanceCm()<30 and distanceSensor.measureDistanceCm()>15){
        analogWrite(LED,191);
    }
    if (distanceSensor.measureDistanceCm()<15 and distanceSensor.measureDistanceCm()>0){
        analogWrite(LED,255);
    }
    delay(500); // Délai d'attente pour éviter d'afficher trop de résultats à la seconde
}

Voici le même code sans librairie :

// Définition des broches du capteur
const int trigPin = 2;
const int echoPin = 3;
const int LED=9;
// Variables utiles
long duree;
int distance;

void setup() {
    pinMode(LED, OUTPUT);
    pinMode(trigPin, OUTPUT); // Configuration du port du Trigger comme une SORTIE
    pinMode(echoPin, INPUT); // Configuration du port de l'Echo comme une ENTREE
    Serial.begin(9600) ; // Initialisation de la communication avec le moniteur série
}
void loop() {
    // Mesure et affiche la distance en centimètre sur le port série toutes les 500 ms
    digitalWrite(trigPin, LOW);
    delayMicroseconds(5);
    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW);
    // Écoute de l'écho
    duree = pulseIn(echoPin, HIGH);
    // Calcul de la distance
    distance = duree*0.034/2;
    Serial.print("Distance en cm :");
    Serial.println(distance);
    if (distance>100){
        analogWrite(LED,0);
    }
    if (distance<100 and distance>30){
        analogWrite(LED,123);
    }
    if (distance<30 and distance>15){
        analogWrite(LED,191);
    }
    if (distance<15 and distance>0){
        analogWrite(LED,255);
    }
    delay(500); // Délai d'attente pour éviter d'afficher trop de résultats à la seconde
}

Radar lumineux

Nous allons maintenant relier notre capteur ultrason à une led RGB afin de faire changer la couleur de la led quand la distance mesurée rétrécit. Le but étant de créer un petit radar qui indiquerait avec la led quand on se rapproche d’un objet ou d’un obstacle.

Voici le programme avec la librairie :

#include "SR04.h" // Librairie
// définition des broches du capteur
const int trigPin = 2;
const int echoPin = 3;
// Initialise les pins de la led
const byte PIN_LED_R = 9;
const byte PIN_LED_G = 10;
const byte PIN_LED_B = 11;
UltraSonicDistanceSensor distanceSensor(trigPin, echoPin); // Initialise le capteur avec les broches utilisées
void setup() {
Serial.begin(9600) ; //Initialise le port série
// Initialise les broches de la led rgb
pinMode(PIN_LED_R, OUTPUT);
pinMode(PIN_LED_G, OUTPUT);
pinMode(PIN_LED_B, OUTPUT);
displayColor(0, 0, 0);
}
void displayColor(byte r, byte g, byte b) {
// Assigne l'état des broches
// Version cathode commune
//analogWrite(PIN_LED_R, r);
//analogWrite(PIN_LED_G, g);
//analogWrite(PIN_LED_B, b);
// Version anode commune
analogWrite(PIN_LED_R, ~r);
analogWrite(PIN_LED_G, ~g);
analogWrite(PIN_LED_B, ~b);
}
void loop() {
float distance_mm =(distanceSensor.measureDistanceCm()*10);
/* Affiche les résultats en mm, cm et m */
Serial.print(F("Distance: "));
Serial.print(distance_mm);
Serial.print(F("mm ("));
Serial.print(distance_mm / 10.0, 2);
Serial.print(F("cm, "));
Serial.print(distance_mm / 1000.0, 2);
Serial.println(F("m)"));
delay(500); // Délai d'attente pour éviter d'afficher trop de résultats à la seconde
if (distance_mm >= 300){displayColor(0, 255, 0);}
if (300 > distance_mm and distance_mm >= 250){
displayColor(0, 200, 0);
}
if (250 > distance_mm and distance_mm >= 200){
displayColor(0, 100, 100);
}
if (200 > distance_mm and distance_mm >= 150){
displayColor(100, 100, 0);
}
if (150 > distance_mm and distance_mm >= 100){
displayColor(200, 0, 0);
}
if (distance_mm < 100){
displayColor(255, 0, 0);
}
}

Voici le même programme associé au projet sans librairie :

// Initialise les pins de la led
const byte PIN_LED_R = 9;
const byte PIN_LED_G = 10;
const byte PIN_LED_B = 11;
// Initialisation capteur ultrason
const byte TRIGGER_PIN = 2; // Broche TRIGGER
const byte ECHO_PIN = 3 ; // Broche ECHO
/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 25000US; // délais avant annulation de mesure : 25ms car 25 ms = 25000 us
/* le nombre de microsecondes à attendre que l'impulsion démarre; la valeur par défaut est une seconde (non signé) */
// Vitesse du son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000 ;
void setup() {
Serial.begin(9600); //Initialise le port série
// Initialise les broches de la led rgb
pinMode(PIN_LED_R, OUTPUT);
pinMode(PIN_LED_G, OUTPUT);
pinMode(PIN_LED_B, OUTPUT);
displayColor(0, 0, 0);
// Initialise les broches du capteur ultrason
pinMode(TRIGGER_PIN, OUTPUT);
digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
pinMode(ECHO_PIN, INPUT);
}
void displayColor(byte r, byte g, byte b) {
// Version anode commune
analogWrite(PIN_LED_R, ~r);
analogWrite(PIN_LED_G, ~g);
analogWrite(PIN_LED_B, ~b);
}
void loop() {
/* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
digitalWrite(TRIGGER_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIGGER_PIN, LOW);
/* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
/* 3. Calcul la distance à partir du temps mesuré */
float distance_mm = measure / 2.0 * SOUND_SPEED;
/* Affiche les résultats en mm, cm et m */
Serial.print(F("Distance: "));
Serial.print(distance_mm);
Serial.print(F("mm ("));
Serial.print(distance_mm / 10.0, 2);
Serial.print(F("cm, "));
Serial.print(distance_mm / 1000.0, 2);
Serial.println(F("m)"));
/* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */
delay(500);
if (distance_mm >= 300){

displayColor(0, 255, 0);

}
if (300 > distance_mm and distance_mm >= 250){

displayColor(0, 200, 0);

}
if (250 > distance_mm and distance_mm >= 200){

displayColor(0, 100, 100);

}
if (200 > distance_mm and distance_mm >= 150){

displayColor(100, 100, 0);

}
if (150 > distance_mm and distance_mm >= 100){

displayColor(200, 0, 0);

}
if (distance_mm < 100){

displayColor(255, 0, 0);

}
}

Importation capteur hc-sr04 Fritzing

Pour pouvoir faire des schémas sur fritzing avec le capteur hc-sr04, vous devez l’importer vous-même. Pour cela vous devez télécharger le fichier .fzz sur ce lien.

Pour en savoir plus n’hésiter pas à consulter notre cours sur Fritzing.

Puis en vous rendant sur Fritzing, vous choisissez le capteur à partir des composants mine, en cliquant sur import :

Vous pouvez ensuite utiliser le capteur.

Pour aller plus loin

Il existe d’autres capteur pour mesurer la distance notamment le capteur de distance Tof qui mesure grâce à laser jusqu’à deux mètres.

De plus, il est possible de mesurer une distance dans l’eau avec un capteur ultrason étanche.