Utiliser des capteurs avec le port GPIO - Partie 3

Un son est une vibration mécanique d'un fluide (tel que l'air) et qui se propage sous forme d'onde. Seules une partie des fréquences sont perceptibles par l'oreille humaine, le spectre sonore. Les sons à fréquence très basse sont appelés « infrasons » alors que les sons à très haute fréquence sont appelés « ultrasons ».

Les capteurs à ultrasons sont conçus pour détecter la proximité des objets en utilisant la réflexion des ultrasons, tout comme les radars. Le principe consiste à calculer la distance de l'obstacle à partir du temps mis par l'onde sonore pour faire le trajet aller puis le retour jusqu'au capteur après réflexion de l'onde sur l'obstacle. Les ultrasons sont principalement utilisés, car ils sont inaudibles à l'oreille humaine et sont relativement précis sur de courtes distances.

Un capteur à ultrasons simple est constitué d'un ou plusieurs émetteurs ultrasons (typiquement un haut-parleur), d'un récepteur et d'un circuit de contrôle. Le transmetteur émet un signal ultrason à haute fréquence qui sera réfléchi par tout objet solide se trouvant à proximité. Une partie du signal réfléchi est détectée par le récepteur situé sur le capteur. Le signal est alors traité par un circuit de contrôle qui va permettre de calculer la durée entre son émission et sa réception. Cette durée est utilisée, après traitement mathématique adéquat, pour calculer la distance entre le capteur à ultrasons et l'objet détecté.

Le module à ultrasons HC-SR04, utilisé pour ce tutoriel avec le Rapsberry Pi, possède quatre broches :

• une broche (Gnd), utilisée pour mettre le module à la masse (0 V) ;
• une broche de sortie (Echo), utilisée pour informer de la fin de l'émission du train d'ultrasons et de son retour après réflexion sur l'obstacle ;
• une broche d'entrée (Trig pour Trigger), utilisée pour déclencher l'émission du train d'ultrasons ;
• une broche (Vcc), utilisée pour alimenter le capteur en 5 V.

On voit sur le chronogramme constructeur ci-dessous qu'une impulsion d'une durée de 10 microsecondes envoyée sur la broche Trig déclenche l'émission d'un train d'ultrasons. La broche Echo bascule alors à l'état haut (5 V) indiquant la fin de l'émission des ultrasons. La broche Echo bascule à l'état bas (0 V) lorsque l'onde réfléchie par l'obstacle est détectée par le récepteur du module.

Notre code Python doit donc permettre de mesurer la durée du signal Echo à l'état haut et d'en déduire par le calcul la distance avec l'objet détecté.

Un pont diviseur de tension est constitué de deux résistances (R1 et R2) montées en série et connectées à une tension d'entrée (Vin), la tension de sortie (Vout) sera abaissée en fonction de la valeur des résistances utilisées. Dans notre circuit, la tension d'entrée (Vin) sera la tension de 5 V générée par la broche Echo de notre capteur et devra être abaissée jusqu'à la tension de 3,3 V (Vout).

Le schéma proposé ainsi que les équations qui suivent sont utilisés dans de nombreuses applications où une réduction de tension est nécessaire.

Si vous ne souhaitez pas approfondir davantage, utilisez une résistance de 1 kΩ et une résistance de 2 kΩ.

Comme nous connaissons les tensions d'entrée et de sortie nécessaires, nous pouvons utiliser n'importe quelle association de résistances pour parvenir au résultat.

J'ai décidé d'utiliser une résistance de 1 kΩ pour R1. En intégrant les autres valeurs dans l'équation, nous obtenons le résultat suivant :

Soit, kitxmlcodeinlinelatexdvpR2=1941finkitxmlcodeinlinelatexdvp

Nous utiliserons donc une résistance de 1 kΩ pour R1 et une résistance de 2 kΩ pour R2.

Nous allons utiliser quatre broches du Rapsberry Pi pour ce projet :

• la broche GPIO 5V (pin 2) qui sera reliée à la broche Vcc du capteur pour l'alimentation en 5 V ;
• la broche GPIO GND (0 V Ground)(pin 6) qui sera reliée à la broche Gnd du capteur pour la mise à la masse ;
• la broche GPIO 23 (pin 16), broche de sortie du GPIO qui sera reliée à l'entrée Trig du capteur ;
• la broche GPIO 24 (pin 18), broche d'entrée du GPIO qui sera reliée à la sortie Echo du capteur via le pont diviseur de tension.

Voilà, notre capteur HC-SR04 est maintenant connecté à notre Rapsberry Pi.

Maintenant que nous avons branché notre capteur à ultrasons à notre Rapsberry Pi, nous allons écrire un code en langage Python pour déterminer la distance de l'obstacle.

La sortie Echo du capteur à ultrasons sera toujours à l'état bas (0 V) à moins que son entrée Trig ait été activée, auquel cas elle passera à l'état haut 5 V (et donc 3,3 V à l'entrée du Raspberry Pi grâce à notre pont diviseur de tension).

Nous avons donc besoin de configurer une broche GPIO comme étant une sortie, pour envoyer un signal de déclenchement (trigger) au capteur, et une autre comme étant une entrée afin de pouvoir détecter tout changement d'état en provenance de la broche Echo du capteur.

Dans un premier temps il faut importer la bibliothèque Python de gestion du port GPIO, celle de gestion de l'horloge time (pour cadencer les différentes étapes à réaliser par le Raspberry Pi) et définir le système de numérotation des broches :

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

Ensuite il faut nommer la broche de sortie GPIO 23 (celle qui va envoyer un signal de déclenchement au capteur) en TRIG et la broche d'entrée GPIO 24 (qui acquerra le signal du capteur en retour) en ECHO :

TRIG = 23
ECHO = 24

Il faut maintenant afficher un message pour indiquer à l'utilisateur que le processus est en cours :

print "Distance Measurement In Progress"

Ensuite, on configure les ports du GPIO :

GPIO.setup(TRIG, GPIO.OUT)
GPIO.setup(ECHO, GPIO.IN)

Enfin, s'assurer que la broche Trig est initialement à un potentiel bas et donner au capteur quelques secondes pour s'initialiser :

GPIO.output(TRIG, False)
print "Waiting For Sensor To Settle"
time.sleep(2)

Le capteur HC-SR04 a besoin d'une impulsion de 10 µs pour activer son module, ce qui va donner l'ordre au capteur d'émettre un train d'ultrasons (8 séries à 40 kHz) et se mettre en attente du signal réfléchi par l'obstacle. Pour créer notre impulsion de déclenchement, nous devons forcer la broche Trig à un potentiel haut pendant 10 µs puis le remettre à un potentiel bas :

GPIO.output(TRIG, True)
time.sleep(0.00001)
GPIO.output(TRIG, False)

Maintenant que nous avons envoyé notre impulsion, nous devons acquérir l'état de notre broche d'entrée qui est connectée à la sortie Echo du capteur.

La broche Echo du capteur restera à un potentiel haut (5 V) pendant tout le temps que prend le signal pour aller et venir entre le capteur et l'objet détecté. Notre code doit donc permettre de mesurer la durée pendant laquelle la broche Echo reste à un potentiel haut.

Nous utiliserons une boucle while et la fonction time.time() pour horodater les différents événements qui proviennent de changement d'état d'une broche.

La première étape consiste à détecter et horodater l'instant qui précède juste le changement d'état du signal Echo de l'état bas à l'état haut. Cet instant (pulse_start) sera celui de la fin de l'émission du train d'ultrasons par le capteur.

while GPIO.input(ECHO) == 0:
    pulse_start = time.time()

Une fois le train d'ultrasons émis, la broche Echo restera à l'état haut jusqu'au retour des ultrasons réfléchis par l'obstacle. On cherche alors à détecter à nouveau le basculement du signal Echo à l'état bas. Cet instant horodaté (pulse_end) sera celui de la détection du retour des ultrasons.

while GPIO.input(ECHO) == 1:
    pulse_end = time.time()

Nous pouvons maintenant calculer la différence entre les deux instants enregistrés et en déduire la durée de l'impulsion (pulse_duration) :

pulse_duration = pulse_end - pulse_start

Connaissant la durée que le signal ultrason met pour parcourir la distance émetteur-obstacle-récepteur, nous pouvons calculer cette distance en utilisant la formule suivante :

La vitesse du son est variable, elle dépend du milieu traversé ainsi que de sa température.

Cependant, nous savons que la vitesse du son dans l'air et au niveau de la mer est de 343 m/s (34300 cm/s), nous allons donc utiliser cette valeur comme référence.

Nous devons également diviser la durée par deux, car ce que nous avons calculé plus haut est la durée que le signal ultrason met pour parcourir la distance émetteur-obstacle-récepteur, soit deux fois la distance recherchée.

Nous pouvons donc simplifier le calcul qui doit être introduit dans le code Python de la façon suivante :

Soit, kitxmlcodeinlinelatexdvpdistance=temps \times 17150finkitxmlcodeinlinelatexdvp

Dans le code Python, nous entrerons donc :

distance = pulse_duration * 17150

Nous allons maintenant arrondir notre distance à deux décimales :

distance = round(distance, 2)

Nous affichons alors la distance. Cette commande va afficher le mot « Distance : » suivi de la valeur calculée et de l'unité « cm » :

print "Distance: ", distance, " cm"

Enfin, nous remettons à zéro les broches du GPIO pour nous assurer que les entrées et sorties sont bien réinitialisées :

GPIO.cleanup()

Sauvegardez votre code en le nommant « range_sensor.py » et lancez-le en utilisant la commande suivante :

sudo python range_sensor.py

Cet article est une traduction adaptée de l'article écrit par Jacob Marsh et paru dans le n° 27 du magazine TheMagPi, sous le titre Using an HC-SR04 ultrasonic range finder.

Nous remercions les membres de la Rédaction de Developpez.com pour le travail de traduction, de relecture et d'adaptation qu'ils ont effectué, en particulier :

• eric4459
• f-leb
• deusyss
• Claude Leloup