Ultraschallsensor-Modul HC-SR04 mit Raspberry Pi Schnittstelle

Der preiswerte HC-SR04 Sensor besteht aus einem Ultraschall-Sender und einem Empfänger. Er funktioniert nach dem Prinzip Zeit-Distanzmessung, in dem er eine Reihe von Ultraschallwellen sendet und die Zeit bis zum Wiederempfang der reflektierten Wellen misst. Daraus können Aussagen über die Entfernung des reflektierenden Objekts gemacht werden.

Schnittstelle von Ultraschallsensor HC-SR04 und Raspberry Pi

Im Folgenden ist die Schnittstelle mit Raspberry Pi schematisch dargestellt.

Abbildung 1: HC-SR04 und Raspberry Pi Schnitstellenschema

Das Ultraschall-Sensor-Modul ist eine analoges Modul, siehe Datenblatt. Es wird zuerst für min. $10us$ Spannung an Trigger gelegt. Danach sendet er über Transmitter acht Rechteck-Zyklen Ultraschall-Wellen mit $40Hz$ . Ab dieser Zeit schaltet er den Ausgang (Echo) ein und wartet auf die reflektierten Wellen. Sobald die Welle wieder am Receiver gehört wird, schaltet er den Echo wieder aus.

Elektronik

Die Eingangs- sowie Ausgangsspanunng von HC-SR04 beträgt $5V$ . Die Input Pins von Raspberry Pi können eine maximale Spannung von $3,3V$ erfassen. Daher muss die Ausgangsspannung mit einem Spannungsteiler reduziert werden.

Eine weitere Beschränkung ist der Strom, den Raspberry Pi aufnehmen soll. Der „Sink“ soll üblicherweise nicht höher als $0.5mA$ betragen. Das muss bei der Widerstandsauswahl berücksichtigt werden. Die Widerstände der Spannungsteiler können nach

(1) $\begin{equation*} \frac{U_E}{U_A}=\frac{R_1+R_2}{R_2} \end{equation*}$

berechnet werden. Daraus ergibt sich das Verhältnis zwischen den Widerständen als

(2) $\begin{equation*} \frac{R_1}{R_2}=\frac{1,7}{3,3}\text{.} \end{equation*}$

Wenn der Pulldown-Widerstand $R_2$ als $10k\Omega$ gewählt wird, soll demnach der Pullup-Widerstand $R_1=5,\overline{15}k\Omega$ betragen. Der Spannungsteiler mit handelsüblichen $10k$ und $5k1$ Widerständen gibt in Praxis mit Verlustwiderständen am Echo eine Ausgangsspanung von $3,25V$ . Das ist in dem sicheren Bereich der empfohlenen Eingangsspannung für Raspberry Pi.

Datenverarbeitung mit Python

Der Ablauf des Algorithmus ist, dass zuerst kurz einen Impuls an Trigger gegeben und unmittelbar danach die Zeit gemessen wird, in der am Ausgang (Echo) Spannung liegt. Da diese Zeitmessung analog erfolgen und ausgewertet werden muss, läuft das Programm, das einen Ultraschallmodul auswertet in Schleife. Daher muss die Auswertung des Ultraschalls in einem parallelen Prozess oder Thread laufen und zwar es muss für jeden Ultraschall-Sensor ein eigener Prozess laufen. Im Folgenden wird dazu ein Python-Programmcode beigefügt, in dem beliebig viele Ultraschallmodule durch Multithreading parallel ausgewertet werden und mit dem Hauptalgorithmus kommunizieren können.

#!/usr/bin/env python
# vim: set fileencoding=UTF-8 :

#Libraries
import RPi.GPIO as GPIO
from datetime import datetime
import time
import numpy as np
import multiprocessing as mp
import ctypes
from l_config import config

class us_asynch:
    def __init__(self):
        #self.config=l_config.config
        self.settle_time=0.1
        self.wave_time=0.01
        manager = mp.Manager()
        self.distance=[manager.list() for i in range(len(config.us.pins))]
        
    def start(self,f=False):    
        self.p=[mp.Process(target=self.us, args=[i,self.distance[i]]) for i in range(len(config.us.pins))]
        
        for p_i in self.p:
            p_i.start()
            #p_i.join()

    def kill(self):
        for p_i in self.p:
            p_i.terminate()
    
    def us(self,sensor,shared):  
        p_trigger=config.us.pins[sensor][0]
        p_echo=config.us.pins[sensor][1]
        #start = datetime.now()    
        # Set pins as output and input
        GPIO.setup(p_trigger,GPIO.OUT)  # Trigger
        GPIO.setup(p_echo,GPIO.IN)      # Echo

        while True:
            # Set trigger to False (Low)
            GPIO.output(p_trigger, False)
            
            # Allow module to settle
            time.sleep(self.settle_time)
    
            GPIO.output(p_trigger, True)
            time.sleep(self.wave_time)
            GPIO.output(p_trigger, False)
            
            start = datetime.now()
            em=start
            #print "Triggering"
            while GPIO.input(p_echo)==0:
                #print GPIO.input(p_echo)
                start = datetime.now()
                if ((start-em).seconds+(start-em).microseconds/1E6)>1:
                    print "No response!"
                    break
            
            #print "Expecting Input"
            while GPIO.input(p_echo)==1:
                stop = datetime.now()

            delta = stop - start
            s = delta.seconds + delta.microseconds / 1E6
            # Distance pulse travelled in that time is time
            # multiplied by the speed of sound (cm/s)
            distance = s * 343.20/2.            
            #Correlation
            #distance=distance-0
            shared[:]=[distance]

#!/usr/bin/env python

# vim: set fileencoding=UTF-8 :

#Libraries

import RPi.GPIO as GPIO

from datetime import datetime

import time

import numpy as np

import multiprocessing as mp

import ctypes

from l_config import config

class us_asynch:

def __init__(self):

#self.config=l_config.config

self.settle_time=0.1

self.wave_time=0.01

manager = mp.Manager()

self.distance=[manager.list() for i in range(len(config.us.pins))]

def start(self,f=False):

self.p=[mp.Process(target=self.us, args=[i,self.distance[i]]) for i in range(len(config.us.pins))]

for p_i in self.p:

p_i.start()

#p_i.join()

def kill(self):

for p_i in self.p:

p_i.terminate()

def us(self,sensor,shared):

p_trigger=config.us.pins[sensor][0]

p_echo=config.us.pins[sensor][1]

#start = datetime.now()

# Set pins as output and input

GPIO.setup(p_trigger,GPIO.OUT) # Trigger

GPIO.setup(p_echo,GPIO.IN) # Echo

while True:

# Set trigger to False (Low)

GPIO.output(p_trigger, False)

# Allow module to settle

time.sleep(self.settle_time)

GPIO.output(p_trigger, True)

time.sleep(self.wave_time)

GPIO.output(p_trigger, False)

start = datetime.now()

em=start

#print "Triggering"

while GPIO.input(p_echo)==0:

#print GPIO.input(p_echo)

start = datetime.now()

if ((start-em).seconds+(start-em).microseconds/1E6)>1:

print "No response!"

break

#print "Expecting Input"

while GPIO.input(p_echo)==1:

stop = datetime.now()

delta = stop - start

s = delta.seconds + delta.microseconds / 1E6

# Distance pulse travelled in that time is time

# multiplied by the speed of sound (cm/s)

distance = s * 343.20/2.

#Correlation

#distance=distance-0

shared[:]=[distance]

Im Datenblatt von HC-SR04 wird eine Leerlaufzeit (Settle time) von min. $60ms$ empfohlen. Die Leerlaufzeit zwischen den Zyklen variiert je nach Anwendung und Messbereich. Die empfohlene Zeit von $60ms$ hat sich bei der Raumerfassung als zu niedrig herausgestellt, da die Wellen bei Distanzen über $3m$ nachhallen und die Receiver störanfälliger werden. Als akzeptabel haben sich die Leerlaufzeiten von ab $300ms$ herausgestellt. Dieser Umstand reduziert die Abtastfrequenz drastisch.

Hingegen spielt die Triggerzeit wenig Rolle bei der Anwendung mit Raspberry Pi, da der Prozessdauer des sequentiellen Ein- und Ausschaltens des Trigger-Pin schon länger als die erforderliche Trigger dauert. Im vorliegenden Fall ist die Sleep-Time für das Triggern überflüssig und könnte übersprungen werden.

Die Raum-Mapping mittels Ultraschallsensoren HC-SR04 ist in diesem Teil vorgestellt.

Can Kosar