Le capteur à ultrasons

De même que nous ne percevons pas toutes les fréquences de la lumière, nous ne percevons pas toutes les fréquences du son. Le spectre audible de fréquences (que l'humain peut percevoir) s'étend conventionnellement entre 20Hz et 20KHz. Comme pour la lumière, cela peut varier d'un individu à l'autre.

En revanche, le son ne se déplace pas à la même vitesse que la lumière :

Vitesse de la lumière : 299 792 458 m/s (mètre par seconde) dans le vide (c'est à dire sans matière) ;
Vitesse du son : Le son se propage obligatoirement dans la matière (donc pas de son dans le vide) et sa vitesse dépend de la matière en question. La vitesse du son dans l'air est d'environ 340 m/s (mètre par seconde).

Le capteur à ultrason simple permet, comme un micro, de capter des sons. Sauf qu'il ne capte que les ultrasons, c'est-à-dire les sons situés au-delà des 20KHz (précisément de 20 KHz à 10 MHz).

Le SRF05 contient à la fois un capteur et un émetteur à ultrasons.

Voici une petite photo de présentation :

SRF05 : émetteur et récepteur à ultrasons. — SRF05 : émetteur et récepteur à ultrasons

Vous l'aurez compris, il s'agit d'un module tout prêt qui contient de l'électronique (avec un microcontroleur PIC16F630) qui va communiquer avec l'Arduino.

Voici un lien vers la Notice du SRF05 afin de voir comment connecter correctement le SRF05 et comprendre son fonctionnement.

On y lit plusieurs choses :

Le SRF05 mesure des échos entre 3cm et 4m de distance.
La mesure ne peut se faire que toutes les 50ms.
Le meilleur cône d'écoute de l'écho est de 30° (soit -15° et +15° en face du capteur) mais il peut capter correctement jusqu'à un cône de 60°. Non Lukas, le cône d'écoute n'est pas l'appareil que votre grand oncle se met dans l'oreille pour mieux entendre ! Il s'agit de la zone en face du capteur qui peut recevoir l'écho...
Il peut être connecté de deux façons différentes : soit avec une patte pour l'émission et une patte pour la réception, soit avec une seule patte pour l'émission et la réception.

Nous utiliserons dans l'exemple la connexion avec une seule patte (émission/réception). Voici le schéma :

Connexion du SRF05 avec une patte pour envoi et réception (attention à l'orientation)

Comment le capteur à ultrasons mesure-t-il la distance des échos de sons ?

Le principe est assez simple :

L'Arduino demande (par programmation) au SRF05 de procéder à la mesure. Cette demande se fait en envoyant un signal haut (HIGH) pendant 10 microsondes au SRF05. Puis on attend le retour en comptant le temps qui passe (en microsecondes).
Le SRF05 envoie un "beep" ultrasons (à la fréquence de 40KHz) et attend l'écho. C'est-à-dire qu'il attend que le son rebondisse sur quelque obstacle et lui revienne.
Dès que le son est capté en retour, il en informe l'Arduino en lui renvoyant un signal HAUT.
L'Arduino(par programmation) exploite ensuite les données du temps entre envoi et réception.

Mais comment peut-on savoir comment transformer du temps en distance ?

Il suffit de faire un calcul mathématique...

Le temps parcours 340 mètres en 1 seconde, soit 34000 cm en 1 seconde, soit 34000 cm en 1000000 microsecondes.

Vous suivez ? Ce ne sont que des conversions, attendez la suite...

Avec une règle de trois on cherche le temps mis pour parcourir 1 cm :

temps=1000000*1/34000=29 et des poussières. Donc le son met environ 29µs (microsecondes) pour parcourir 1cm.

Le capteur envoie le son qui rencontre un obstacle et qui rebondit. Donc il va parcourir la même distance à l'aller qu'au retour. Si l'objet est à 1 cm, le son va donc mettre 29µs pour aller jusqu'à l'obstacle, puis 29µs pour revenir, soit 58µs.

Pour obtenir la distance par rapport au temps mesuré entre "beep" et "écho", il suffit donc de diviser le temps en microseconde par 58 et on obtient la bonne distance !

(Bon, je double la moyenne de celui ou celle qui arrive à faire comprendre ça à Lukas en moins d'une semaine, parce que je n'ai pas l'impression que mon "beep" a fait écho chez lui...)

Voici maintenant le code commenté pour mesurer une distance avec le capteur ultrasons SRF05. Vous verrez que je ne me contente pas d'une mesure, mais d'une moyenne sur 10 mesures. Cela ralentit la fréquence des mesures mais en augmente la fiabilité.

// SRF05 connecté en mode un seul pin (émission/réception)

int pinSRF = 7; //pin digital pour l'envoi et la réception des signaux

int vSon=59; //valeur de temps en µs d'un aller retour du son sur 1cm

void setup() {

Serial.begin(9600); //on initialise la communication série

}

//boucle principale

void loop() {

int distance=mesureDistance(); //on récupère la valeur de distance grâce à la fonction créee plus bas

Serial.println(distance); // on affiche la distance en cm

}

//fonction de mesure de distance avec SRF05

int mesureDistance() {

unsigned long mesure = 0; // variable de mesure

unsigned long cumul = 0; //variable pour la moyenne

for (int t = 0; t < 10; t++) { // boucle pour effectuer 10 mesures

pinMode (pinSRF, OUTPUT); //on prépare le pin pour envoyer le signal

digitalWrite(pinSRF, LOW); //on commence à l'état bas

delayMicroseconds(2); //on attend que le signal soit clair

digitalWrite(pinSRF, HIGH);//mise à l'état haut

delayMicroseconds(10); //pendant 10 µs

digitalWrite(pinSRF, LOW); //mise à l'état bas

pinMode(pinSRF, INPUT); //on prépare le pin pour recevoir un état

mesure = pulseIn(pinSRF, HIGH); // fonction pulseIn qui attend un état haut et renvoie le temps d'attente

cumul+=mesure; //on cumule les mesures

delay(50); //attente obligatoire entre deux mesures

}

mesure=cumul/10; //on calcule la moyenne des mesures

mesure=mesure/vSon;//on transforme en cm

return mesure; //on renvoie la mesure au programme principal

}

Le type unsigned long permet de stocker de entiers entre 0 et 4 294 967 295. C'est plus sûr lorsque vous utilisez des nombres qui peuvent grandir rapidement, sinon vos données seront fausses (dépassement de mémoire).

La fonction pulseIn(pin,ETAT) est une fonction bien pratique que propose le langage Arduino. Elle compte le temps en microseconde entre le moment où on appelle cette fonction et le moment où le pin passe à l'état indiqué. On peut appeler cette fonction avec l'état d'attente d'un signal haut (HIGH) ou bas (LOW). Dans le programme nous attendons un signal haut.

La fonction delayMicroseconds() permet d'attendre non pas en millisecondes mais en microsecondes.

Quand utiliser un capteur à ultrasons ?

L'application la plus utilisée est la détection d'obstacle à distance par des robots mobiles. On peut adapter la vitesse du robot par rapport à la détection, l'arrêter si l'objet est trop proche, et lui faire chercher un direction "libre" avant de le faire repartir.

On peut très bien imaginer un appareil de mesure de volume (avec un stockage des données de distance sur trois dimensions). Ou un stabilisateur d'altitude (dans une mesure de 4m maximum) pour un objet volant.

Je vais m'arrêter ici pour les capteurs, non pas parce qu'on a fait le tour, mais juste parce que nous avons vu différentes façons de recevoir des données d'un capteur (tout-ou-rien, valeur de tension et signaux). Dans la grande majorité des cas, vous trouverez les informations nécessaires à l'utilisation d'un capteur sur les forums et sur les notices (datasheet ou notice du fabriquant).