Utiliser des capteurs avec le port GPIO - Partie 3

Télémètre à ultrasons

Jacob Marsh

Traducteur

eric4459

Dans les tutoriels précédents, nous avons décrit la façon d'acquérir une température et la détection de mouvement par capteur infrarouge, chacun de ces dispositifs pouvant être branché directement sur les ports GPIO du Raspberry Pi.

Le télémètre à ultrasons HC-SR04 est également très simple à utiliser, cependant sa tension de sortie doit être abaissée de 5 V à 3,3 V afin de ne pas endommager le Raspberry Pi !

Dans ce tutoriel nous allons introduire quelques notions de physique et d'électronique afin d'expliquer chaque étape.

NDLR : cet article fait appel à des bases de programmation en Python, mais aussi à la mise en œuvre du port GPIO du Raspberry Pi. Si nécessaire, nous invitons le lecteur à se familiariser avec ces notions en consultant tout d'abord le tutoriel :

- Raspberry Pi - Python et le port GPIO

Les commentaires et les suggestions d'amélioration sont les bienvenus, alors, après votre lecture, n'hésitez pas. Commentez

- Titre : Utiliser des capteurs avec le port GPIO - Partie 3

- Auteur : Jacob Marsh

- Traducteur : eric4459

- Parution : 30 juillet 2015

- Public visé :

- Licence : Le contenu de cet article est rédigé par Jacob Marsh et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.

Voir également :

- Raspberry Pi - Déballage et installation

- Raspberry Pi - Python et le port GPIO

Sommaire

- I. Matériel nécessaire

- II. Les capteurs à ultrasons

- III. Le pont diviseur de tension

- IV. Préparation du montage

- V. Piloter le capteur en langage Python

- VI. Notes de la Rédaction de Developpez.com

I - Matériel nécessaire

- Un module ultrasons HC-SR04

- Une résistance de 1 kΩ

- Une résistance de 2 kΩ

- Des câbles de connexion

- Une plaquette de câblage rapide

II - Les capteurs à ultrasons

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é.

La tension de sortie délivrée par la broche Echo du module HC-SR04 est de 5 V. Or, la broche d'entrée du Rapsberry Pi est conçue pour du 3,3 V au maximum.

Afin d'éviter d'endommager le Rapsberry Pi, nous allons utiliser un pont diviseur de tension constitué de deux résistances afin d'abaisser la tension de sortie du capteur et atteindre une tension supportable par le Rapsberry Pi.

NDLR : à l'inverse, il n'est pas utile d'amplifier la tension de 3,3 V délivrée en sortie du Raspberry Pi jusqu'à 5 V vers le capteur. Le niveau de tension de 3,3 V est suffisamment élevé pour être considéré comme un état haut par le module (voir les niveaux logiques pour un signal TTL) et déclencher malgré tout l'émission d'ultrasons (trigger).

III - Le pont diviseur de tension

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Ω.

Pont diviseur de tension

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,

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

IV - Préparation du montage

Photo du montage

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.

Branchez quatre connecteurs mâle/femelle sur les broches du capteur HC-SR04 comme suit : fil rouge sur la broche Vcc, fil bleu sur la broche Trig, fil jaune sur la broche Echo, fil noir sur la broche Gnd.

Branchez le fil rouge Vcc sur la ligne d'alimentation de la plaquette (la ligne rouge verticale) et le fil noir sur la ligne de masse (la ligne bleue verticale).

Reliez la broche GPIO 5V (pin 2) à la ligne d'alimentation de la plaquette et la broche GPIO GND à la ligne de masse.

Branchez le fil bleu (Trig) à une rangée de trous libre de la plaquette et reliez cette rangée à la broche GPIO 23 (pin 16). Vous pouvez également relier directement ces éléments sans passer par la plaquette.

Branchez le fil jaune (Echo) à une rangée de trous libre de la plaquette et reliez cette rangée à une autre rangée de trous libre avec la résistance R1 (résistance de 1 kΩ).

Reliez la rangée où se trouve la résistance R1 à la ligne de masse en utilisant la résistance R2 (résistance de 2 kΩ).

Connectez la broche GPIO 24 (pin 18) à la rangée de trous qui sert de connecteur entre R1 et R2, en fait le branchement se fait entre les deux résistances.

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

V - Piloter le capteur en langage Python

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,

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

VI - Notes de la Rédaction de Developpez.com

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