KY-050 Capteur à ultrasons

#define Echo_EingangsPin 7
#define Trigger_AusgangsPin 8

int maximumRange = 300; 
int minimumRange = 2; 
long Abstand;
long Dauer;
 
void setup() {
 pinMode(Trigger_AusgangsPin, OUTPUT);
 pinMode(Echo_EingangsPin, INPUT);
 Serial.begin (9600);
}
 
void loop() {

 digitalWrite(Trigger_AusgangsPin, HIGH);
 delayMicroseconds(10); 
 digitalWrite(Trigger_AusgangsPin, LOW);

 Dauer = pulseIn(Echo_EingangsPin, HIGH);
  
 Abstand = Dauer/58.2;

 if (Abstand >= maximumRange || Abstand <= minimumRange)
 {
      Serial.println("Abstand außerhalb des Messbereichs");
      Serial.println("-----------------------------------");
 }  
  
 else
 {
      Serial.print("Der Abstand betraegt:");
      Serial.print(Abstand);
      Serial.println("cm");
      Serial.println("-----------------------------------");
 }
 delay(500);
}

Ce module est parfaitement adapté à la mesure de distances dans une plage comprise entre 2 cm et 3m. Avec une résolution d'environ 3 mm, il est ainsi possible de mesurer des distances par signal ultrasonique. Si un signal (front descendant) est appliqué à l'entrée de déclenchement, une mesure de distance est effectuée et transmise à la sortie d'écho sous forme de signal PWM-TTL. Le capteur de distance à ultrasons convient surtout pour la détection d'obstacles, la mesure de distance, comme indicateur de niveau et pour les applications industrielles.

Données techniques

Distance mesurable	2cm-300cm
Résolution de mesure	3mm
min. Temps entre les mesures	50µs

Principe de fonctionnement

Ce module montre comment un haut-parleur à ultrasons et un microphone peuvent être utilisés pour mesurer la distance d'un objet sans contact. Le principe repose sur le fait que la vitesse du son dans l'air reste presque constante à température constante - à 20°C, elle est de 343,2m/s. Cela signifie que la distance peut être mesurée en un temps.

Ce fait peut être utilisé pour convertir la mesure de la distance en une mesure de temps, qui peut ensuite être facilement reprise par les microcontrôleurs.

Lorsqu'il est déclenché, le haut-parleur à ultrasons (transducteur) émet un bruit ultrasonique de 200µs maximum. Le haut-parleur à ultrasons émet un signal de 40 kHz. Cela signifie que 8 périodes (changements de front) sont émises dans les 200µs pendant lesquelles le transducteur émet son bruit ultrasonique. Pour arriver mathématiquement à ces 8 périodes du signal de 40 kHz, nous le calculons comme indiqué ci-dessous.

Nombre de périodes en une seconde = 40000. Temps = 1s
Durée d'une seule période :
1s / 40000 = 25µs**

Longueur maximale du son ultrasonique = 200us
Durée d'une période unique = 25us
Nombre de périodes dans un son ultrasonique:
200µs / 25µs = 8

Le principe est simple : un son ultrasonique est émis par le haut-parleur situé sur le circuit imprimé, qui est ensuite réfléchi par un objet et capté par le microphone situé sur le circuit imprimé. Les ultrasons sont utilisés parce qu'ils se situent en dehors du champ d'audition de l'oreille humaine (environ 20Hz-22kHz).

La transmission du signal ultrasonore est lancée par la réception d'un signal de démarrage long de 10µs (ActiveHigh) sur la "Trigger Input Pin". Après la transmission, le signal est activé sur la "broche de signal de sortie de l'écho" (ActiveHigh). Si le signal réfléchi est à nouveau capté par le microphone, le signal d'écho est à nouveau désactivé après détection. Le temps entre l'activation et la désactivation du signal d'écho peut être mesuré et converti en distance, car il correspond également au temps nécessaire au signal ultrasonique pour franchir la distance entre le haut-parleur->la paroi réfléchissante ->le microphone dans l'air. La conversion se fait alors par approximation d'une vitesse d'air constante - la distance est alors par conséquent la moitié de la distance parcourue.

Affectation des broches

Exemple de code Raspberry Pi

Affectation des broches Raspberry Pi

Raspberry Pi	Capteur
5 V [Pin 2]	+V
Masse [Pin 6]	GND
-	Déclencheur
-	Echo

Capteur	KY-051
Déclencheur	B1
Echo	B2
+V	-
GND	-

Raspberry Pi	KY-051
3,3 V [Pin 1]	Vcca
5 V [Pin 4]	Vccb
GND [Pin 14]	GND
GPIO 17 [Pin 11]	A1
GPIO 27 [Pin 13]	A2

Exemple de programmation dans le langage de programmation Python

Niveau de tension de 5V, il faut donc respecter ce qui suit.

Le Raspberry Pi avec son processeur ARM, contrairement à l'Arduino basé sur Atmel Atmega, fonctionne à un niveau de tension de 3,3V au lieu de 5V - cependant, ce capteur ne fonctionne qu'au niveau de tension le plus élevé. Si vous deviez faire fonctionner le capteur sans restriction sur le Raspberry Pi sans précautions, cela pourrait causer des dommages permanents aux entrées du Raspberry Pi.

Pour de tels cas, ce kit de capteurs avec le KY-051 dispose d'un traducteur de tension qui ajuste les niveaux de tension et garantit ainsi un fonctionnement sûr. Celui-ci doit être connecté entre le Rasperry Pi et le capteur.

Pour plus d'informations, consultez la page d'information sur le KY-051.

Le programme d'exemple active la mesure de distance selon le principe ci-dessus et mesure le temps pendant lequel le signal ultrasonique reste dans l'air à l'aide d'une sorte de chronomètre. Ce chronomètre est réalisé en lisant l'heure actuelle du système à partir de time.time() au moment de l'enclenchement du signal d'écho ; la différence entre l'heure d'enclenchement et l'heure de déclenchement est le temps recherché pendant lequel le signal est en route. Ce temps est ensuite pris comme base pour la conversion de la distance - le résultat est alors édité dans la cosnole. Si le signal est en dehors de la plage de mesure, un message d'erreur correspondant est émis.

# coding=utf-8
import time
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)

Trigger_AusgangsPin = 17
Echo_EingangsPin    = 27

sleeptime = 0.8

GPIO.setup(Trigger_AusgangsPin, GPIO.OUT)
GPIO.setup(Echo_EingangsPin, GPIO.IN)
GPIO.output(Trigger_AusgangsPin, False)

try:
    while True:
        GPIO.output(Trigger_AusgangsPin, True)
        time.sleep(0.00001)
        GPIO.output(Trigger_AusgangsPin, False)

        EinschaltZeit = time.time()
        while GPIO.input(Echo_EingangsPin) == 0:
            EinschaltZeit = time.time()
 
        while GPIO.input(Echo_EingangsPin) == 1:
            AusschaltZeit = time.time()

        Dauer = AusschaltZeit - EinschaltZeit
        Abstand = (Dauer * 34300) / 2

        if Abstand < 2 or (round(Abstand) > 300):
            print("Distance hors de la plage de mesure")
            print("------------------------------")
        else:
            Abstand = format((Dauer * 34300) / 2, '.2f')
            print("La distance est de "), Abstand,("cm")
            print("------------------------------")

        time.sleep(sleeptime)

except KeyboardInterrupt:
    GPIO.cleanup()

Exemple de téléchargement de programme

KY050-RPi.zip

Pour commencer avec la commande :

sudo python3 KY050-RPi.py

# Chargement des bibliothèques
from machine import Pin
import time

# Initialisation de GPIO16 comme entrée et GPIO17 comme sortie.
trig = Pin(17, Pin.OUT)
echo = Pin(16, Pin.IN, Pin.PULL_DOWN)

# Boucle sans fin pour mesurer la distance
while True:
     # La mesure de la distance est lancée au moyen du signal de déclenchement de 10us de long.
     trig.value(0)
     time.sleep(0.1)
     trig.value(1)

     # Attente de l'entrée de l'écho jusqu'à ce que le signal soit activé. 
     # Après cela, on mesure le temps pendant lequel il reste activé.
     time.sleep_us(2)
     trig.value(0)
     while echo.value()==0:
          pulse_start = time.ticks_us()
     while echo.value()==1:
          pulse_end = time.ticks_us()
     pulse_duration = pulse_end - pulse_start

     # La distance est maintenant calculée à partir du temps enregistré.
     distance = pulse_duration * 17165 / 1000000
     distance = round(distance, 0)

     # Sortie série
     print ('Distance:',"{:.0f}".format(distance),'cm')
     time.sleep(1)