KY-050 Ultraschall-Abstandssensor

#define Echo_EingangsPin 7 // Echo Eingangs-Pin
#define Trigger_AusgangsPin 8 // Trigger Ausgangs-Pin
 
// Benoetigte Variablen werden definiert
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() {
 
 // Abstandsmessung wird mittels des 10us langen Triggersignals gestartet
 digitalWrite(Trigger_AusgangsPin, HIGH);
 delayMicroseconds(10); 
 digitalWrite(Trigger_AusgangsPin, LOW);
  
 // Nun wird am Echo-Eingang gewartet, bis das Signal aktiviert wurde
 // und danach die Zeit gemessen, wie lang es aktiviert bleibt 
 Dauer = pulseIn(Echo_EingangsPin, HIGH);
  
 // Nun wird der Abstand mittels der aufgenommenen Zeit berechnet
 Abstand = Dauer/58.2;
  
 // Überprüfung ob gemessener Wert innerhalb der zulässingen Entfernung liegt
 if (Abstand >= maximumRange || Abstand <= minimumRange)
 {
    // Falls nicht wird eine Fehlermeldung ausgegeben.
      Serial.println("Abstand außerhalb des Messbereichs");
      Serial.println("-----------------------------------");
 }  
  
 else
 {
    // Der berechnete Abstand wird in der seriellen Ausgabe ausgegeben
      Serial.print("Der Abstand betraegt:");
      Serial.print(Abstand);
      Serial.println("cm");
      Serial.println("-----------------------------------");
 }
  // Pause zwischen den einzelnen Messungen
 delay(500);
}

Dieses Modul eignet sich hervorragend zur Entfernungsmessung in einem Bereich zwischen 2 cm und 3 m. Mit einer Auflösung von etwa 3 mm können so Distanzen per Ultraschallsignal gemessen werden. Wird am Trigger-Eingang ein Signal (fallende Flanke) angelegt, so wird eine Abstandsmessung durchgeführt und am Echo-Ausgang als PWM-TTL Signal ausgegeben. Der Ultraschall-Abstandssensor eignet sich vor allem zur Hinderniserkennung, Entfernungsmessung, als Füllstandsanzeiger und für Industrieanwendungen.

Technische Daten

Messbare Distanz	2 cm — 300 cm
Messauflösung	3 mm
min. Zeit zwischen den Messungen	50 µs

Funktionsprinzip

Dieses Modul zeigt, wie mit einem Ultraschalllautsprecher und einem Mikrofon die Entfernung zu einem Objekt berührungslos gemessen werden kann. Das Prinzip beruht auf der Tatsache, dass die Schallgeschwindigkeit in der Luft bei konstanter Temperatur nahezu konstant bleibt - bei 20 °C beträgt sie 343,2 m / s.

Daraus lässt sich die Entfernungsmessung in eine Zeitmessung umwandeln, die dann leicht von Mikrocontrollern übernommen werden kann.

Der Ultraschalllautsprecher (Transducer) sendet, wenn dieser ausgelöst wird, ein maximal 200µs langes Ultraschallgeräusch aus. Dabei sendet der Ultraschalllautsprecher ein 40 kHz Signal aus. Das bedeutet, dass innerhalb der 200µs in denen der Sensor sein Ultraschallgeräusch ausgibt, 8 Perioden (Flankenwechsel) ausgegeben werden. Um auf diese 8 Perioden des 40 kHz Signales rechnerisch zu kommen, berechnet man das ganze, wie im Folgenden dargestellt ist.

Anzahl der Perioden in einer Sekunde = 40000
Zeit = 1s
Dauer einer einzelnen Periode:
1s / 40000 = 25µs

Maximale Länge des Ultraschallgeräusches = 200us
Dauer einer einzelnen Periode = 25us
Anzahl an Perioden im Ultraschallgeräusch:
200µs / 25µs = 8

Das Prinzip ist einfach gehalten, es wird ein Ultraschallgeräusch vom Lautsprecher auf dem PCB ausgegeben, welches dann von einem Objekt reflektiert und vom Mikrofon auf dem PCB aufgenommen wird. Ultraschall wird verwendet, weil dieser außerhalb des Hörbereichs des menschlichen Ohrs liegt (etwa 20Hz-22kHz).

Die Übertragung des Ultraschallsignals wird gestartet, wenn ein 10µs langes Startsignal (ActiveHigh) am "Trigger Input Pin" empfangen wird. Nach der Übertragung wird das Signal am "Echo Output Signal Pin" (ActiveHigh) aktiviert. Wird das reflektierte Signal nun wieder am Mikrofon aufgenommen, wird das Echosignal nach der Detektion wieder deaktiviert. Die Zeit zwischen Aktivierung und Deaktivierung des Echosignals kann gemessen und in die Entfernung umgerechnet werden, da dies auch der Zeit entspricht, wie lange das Ultraschallsignal benötigt, um die Strecke zwischen Lautsprecher-> reflektierende Wand -> Mikrofon in der Luft zu überwinden. Die Umrechnung erfolgt dann durch Annäherung an eine konstante Luftgeschwindigkeit - die Entfernung ist dann die Hälfte der zurückgelegten Strecke.

Pin-Belegung

Codebeispiel Raspberry Pi

Anschlussbelegung Raspberry Pi

Raspberry Pi	Sensor
5 V [Pin 2]	+V
Masse [Pin 6]	GND
-	Trigger
-	Echo

Sensor	KY-051
Trigger	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

Programmierbeispiel in der Programmiersprache Python

5V Spannungslevel, daher muss folgendes beachtet werden

Der Raspberry Pi arbeitet mit seinem ARM-Prozessorkern, anders als der auf Atmel Atmega basierende Arduino, mit 3,3 V Spannungslevel, anstatt mit 5 V. Dieser Sensor funktioniert jedoch nur mit dem höheren Spannungsleveln. Würde drn Sensor uneingeschränkt am Raspberry Pi, ohne Vorsichtsmaßnahmen, betrieben werden, so könnte dies permantente Schäden am Raspberry Pi verursachen.

Um dies zu verhindern, ist es Empfehlenswert einen sogenannten Voltage Translator dazwischenzuschalten, der die Spannungslevel entsprechend anpasst und einen sicheren Betrieb gewährleistet. Hierfür eignet sich hervorragend unser KY-051 Voltage Translator.

Das Beispielprogramm aktiviert nach o.g. Prinzip die Abstandsmessung und misst die Zeit, wie lang das Ultraschallsignal in der Luft ist. Diese Zeit wird dann für die Umrechnung des Abstands als Basis genommen - das Ergebnis wird danach in der Kosnole ausgegeben. Sollte das Signal außerhalb des Messbereichs sein, wird eine entsprechende Fehlermeldung ausgegeben.

# coding=utf-8
# Benötigte Module werden eingefügt und konfiguriert
import time
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
 
# Hier können die jeweiligen Eingangs-/Ausgangspins ausgewählt werden
Trigger_AusgangsPin = 27
Echo_EingangsPin    = 17
 
# Die Pause zwischen den einzelnen Messugnen kann hier in Sekunden eingestellt werden
sleeptime = 0.8
 
# Hier werden die Ein-/Ausgangspins konfiguriert
GPIO.setup(Trigger_AusgangsPin, GPIO.OUT)
GPIO.setup(Echo_EingangsPin, GPIO.IN)
GPIO.output(Trigger_AusgangsPin, False)
 
# Hauptprogrammschleife
try:
    while True:
        # Abstandsmessung wird mittels des 10us langen Triggersignals gestartet
        GPIO.output(Trigger_AusgangsPin, True)
        time.sleep(0.00001)
        GPIO.output(Trigger_AusgangsPin, False)
 
        # Hier wird die Stopuhr gestartet
        EinschaltZeit = time.time()
        while GPIO.input(Echo_EingangsPin) == 0:
            EinschaltZeit = time.time() # Es wird solange die aktuelle Zeit gespeichert, bis das Signal aktiviert wird
 
        while GPIO.input(Echo_EingangsPin) == 1:
            AusschaltZeit = time.time() # Es wird die letzte Zeit aufgenommen, wo noch das Signal aktiv war
 
        # Die Differenz der beiden Zeiten ergibt die gesuchte Dauer
        Dauer = AusschaltZeit - EinschaltZeit
        # Mittels dieser kann nun der Abstand auf Basis der Schallgeschwindigkeit der Abstand berechnet werden
        Abstand = (Dauer * 34300) / 2
 
        # Überprüfung, ob der gemessene Wert innerhalb der zulässigen Entfernung liegt
        if Abstand < 2 or (round(Abstand) > 300):
            # Falls nicht wird eine Fehlermeldung ausgegeben
            print("Abstand ausserhalb des Messbereich")
            print("------------------------------")
        else:
            # Der Abstand wird auf zwei Stellen hinterm Komma formatiert
            Abstand = format((Dauer * 34300) / 2, '.2f')
            # Der berechnete Abstand wird auf der Konsole ausgegeben
            print("Der Abstand betraegt:", Abstand, "cm")
            print("------------------------------")
 
        # Pause zwischen den einzelnen Messungen
        time.sleep(sleeptime)
 
# Aufraeumarbeiten nachdem das Programm beendet wurde
except KeyboardInterrupt:
    GPIO.cleanup()

Beispielprogramm Download

KY050-RPi.zip

Zu starten mit dem Befehl:

sudo python3 KY050-RPi.py

# Bibliotheken laden
from machine import Pin
import time

# Initialisierung von GPIO16 als Input und GPIO17 als Ausgang
trig = Pin(17, Pin.OUT)
echo = Pin(16, Pin.IN, Pin.PULL_DOWN)

# Endlosschleife zur Messung der Distanz
while True:
     # Abstandsmessung wird mittels des 10us langen Triggersignals gestartet
     trig.value(0)
     time.sleep(0.1)
     trig.value(1)

     # Nun wird am Echo-Eingang gewartet, bis das Signal aktiviert wurde 
     # Danach wird die Zeit gemessen, wie lang es aktiviert bleibt
     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

     # Nun wird der Abstand mittels der aufgenommenen Zeit berechnet
     distance = pulse_duration * 17165 / 1000000
     distance = round(distance, 0)

     # Serielle Ausgabe
     print ('Distance:',"{:.0f}".format(distance),'cm')
     time.sleep(1)