[Tutorial] Haussteuerung mit dem Raspberry Pi

Eingang / Ausgang in einen Raum bemerken

Meiner Meinung nach sind Raspberry Pis der spannendste Weg, um sich mit kleinen Schaltkreisen auseinanderzusetzen. Dazu lernt man noch jede Menge Programmieren, was eigentlich nie schaden kann. Als mir aufgefallen ist, dass die meisten Haussteuerungen mit dem Raspberry Pi eigentlich immer nur über einen einzelnen Infrarot-Sensor laufen, fand ich das zu ungenau, also habe ich mir ein eigenes Prinzip ausgedacht.

Skizze

Zwei Ultraschall-Sensoren (A und B) werden 30 cm voneinander entfernt am Eingang zu dem Zimmer befestigt. Wird Sensor A zuerst “getriggert”, also merkt, dass sich etwas vor sich befindet, fragt er Senor B, ob er auch etwas gemerkt hat. Anhand der Reihenfolge, in der die Ultraschallsensoren etwas bemerkt haben, können wir feststellen, ob jemand den Raum betreten oder verlassen hat.

Was man braucht – die Materialien

einen Raspberry Pi und Stromversorgung
2 Ultraschallsensoren (z.B. die hier)
GPIO Verbindung
entweder einen Adafruit Cobbler und ein paar männliche Jumper Kabel (eher zu viele, als zu wenige – sind sehr günstig)
oder männliche und weibliche Jumper-Kabel
6 x 1kOhm Widerstände
falls Ihr Steckdosen steuern wollt: 433 MhZ Sender und Funksteckdosen

Die Verkabelung

Das Diagramm hilft Euch wahrscheinlich schon, aber ich erkläre das nochmal Schritt für Schritt. Zuerst verbindet Ihr VCC (den ersten Pin auf dem Ultraschallsensor) mit der roten “rail”. Einer der beiden 5V-Pins des Raspberry Pi’s muss auch mit dieser Linie verbunden werden.

Den TRIG-Pin (zweiter Pin auf dem Sensor) verbindet Ihr mit GPIO #5 (Pin 29) des Raspberry Pi’s. Beim ECHO-Pin ist das ein bisschen kniffliger, aber auch machbar:

Zuerst sucht Ihr Euch eine Rail aus und verbindet den ECHO-Pin damit. Nun nehmt Ihr einen 1k Ohm Widerstand und verbindet diese mit einer weiteren Rail. Nun müsst Ihr von dort eine Verbindung zu GPIO #6 (Pin 31) des Raspberry Pi’s legen, und noch zwei weitere 1k Ohm Widerstände bevor es wieder auf die blaue Erdungs-Rail geht.

Der erste Ultraschall-Sensor ist geschafft!

Jetzt müssen wir noch genau das Gleiche für den zweiten Ultraschall-Sensor machen, aber natürlich andere Pins vom Raspberry Pi nehmen.

Das sieht dann so aus:

In diesem Tutorial geht es vorwiegend um das Prinzip … – was man damit anstellt, ist jedem selbst überlassen. Ich nutze diese Steuerung, um z.B. Funksteckdosen zu steuern. Wie genau man diese anschließt und nutzt, könnt Ihr z.B. hier herausfinden.

Damit wäre die Verkabelung auch schon geschafft. Jetzt müssen wir die beiden Sensoren noch richtig positionieren. Ich empfehle, sie ca. 30 cm voneinander entfernt z.B. mit Tesa-Film zu befestigen. Bei mir sieht das Ganze dann so aus:

Julien Jaacks

Damit wäre auch schon die Befestigung und Verkabelung geschafft. Jetzt geht’s an den Code!

Das Programm

Der Code wird ausschließlich in Python geschrieben. Erstellt einen neuen Order mit dem Namen “ultrasonic”. In diesem Ordner erstellen wir eine Datei mit dem Namen ultrasonic.py, eine Python Datei. Wichtig ist, dass der Dateiname auf .py endet, um das Programm später ausführen zu können. Diese Datei könnt Ihr im Terminal per SSH oder mit einem Texteditor Eurer Wahl (Notepad, Sublime, …) öffnen und bearbeiten.

Diese Datei öffnen wir nun und importieren in den ersten Zeilen einige libraries, die wir später brauchen werden.

import RPi.GPIO as GPIO
import time
import subprocess
import os
from sys import argv

Falls Ihr keine Funksteckdose benutzt, könnt Ihr import subprocess und import os rauslassen.

Nun benutzen wir den Befehl

GPIO.setmode(GPIO.BCM)

, um das Layout des Boards an unseren Code anzupassen.

Damit wir nicht immer wieder die Nummer unserer Pins aufschreiben zu müssen, und dabei noch vermeidbare Fehler machen, setzen wir einige Variablen:

TRIG_a = 23
ECHO_a = 24
TRIG_b = 5
ECHO_b = 6

Falls Ihr nicht genau die gleichen Pins wie ich benutzt habt, müsst Ihr die Nummern natürlich anpassen.

Es kommen noch drei Variablen hinzu:

path = „/home/pi/raspberry-remote/"
led = 4

Wieder könnt Ihr die Variable path rauslassen, falls Ihr keine Funksteckdosen nutzt. Stattdessen könnt Ihr z.B. noch eine LED anschließen, und erstmal nur diese ansteuern. Bei mir ist das GPIO #4.

Jetzt müssen wir noch sagen, welche Pins INPUTs und welche Pins OUTPUTs sind.

GPIO.setup(TRIG_a, GPIO.OUT)
GPIO.setup(ECHO_a, GPIO.IN)
GPIO.setup(TRIG_b, GPIO.OUT)
GPIO.setup(ECHO_b, GPIO.IN)
GPIO.setup(led, GPIO.OUT)

Vielleicht wundert Ihr Euch, warum es überhaupt neben Strom und Erdung noch zwei weitere Pins gibt. Das hängt mit der Funktionsweise des Sensors zusammen: Es wird durch TRIG ein sehr kurzer Impuls gesendet, der 10 Nanosekunden (0,0001 Sekunde) lang ist. Diesen sendet der Sensor hinaus und misst, wie lange es dauert, bis der Impuls “zurückkommt”. Aus diesem Wert können wir die Entfernung in Zentimeter berechnen.

Wir schreiben also zwei Funktionen, eine für den Sensor A und eine für Sensor B.

def detectDistance_a():
    GPIO.output(TRIG_a, False)
    time.sleep(0.1)

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

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

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

    pulse_duration = pulse_end - pulse_start
    distance_a = pulse_duration * 17150
    distance_a = round(distance_a,2)

    return distance_a

def detectDistance_b():
    GPIO.output(TRIG_b, False)
    time.sleep(0.1)

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

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

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

    pulse_duration = pulse_end - pulse_start
    distance_b = pulse_duration * 17150
    distance_b = round(distance_b,2)

    return distance_b

Wir wollen ja wissen, wieviele Personen in einem Raum sind, um ggf. das Licht ein-/ bzw. abzuschalten. Also fragen wir erstmal, wieviele das im Moment sind:

a = raw_input("How many people are in the room?")
persons = float(a)
persons = int(float(a))

Nun haben wir die Variable “persons”, die die Anzahl der Personen im Raum enthält. Diese benutzen wir auch direkt, um das Licht ein- oder auszuschalten:

if persons > 0:
    os.chdir(path)
    subprocess.Popen("./send 001100 2 1", stdout=subprocess.PIPE, shell=True)
    GPIO.output(led, 1)
    print "Light was shut on."
else:
    os.chdir(path)
    subprocess.Popen("./send 001100 2 0", stdout=subprocess.PIPE, shell=True)
    GPIO.output(led, 0)
    print "Light was shut off.“

Jetzt folgen die Schleifen, in denen der Vergleich der beiden Werten stattfindet.

    while True:
        distance_a = detectDistance_a()
        distance_b = detectDistance_b()

Im Weiteren werden wir nicht mehr die Funktion detectDistance_a() aufrufen, indem wir sie ausschreiben, sondern ändern es zu distance_a und distance_b.

Wie ich oben schon erklärt habe, wird der Vergleich beider Werte initiiert, sobald einer der beiden Sensoren merkt, dass sich etwas nah (hier weniger als 50 cm) an ihm befindet.

if distance_a < 50:
    i = 0
    liste = []

Dazu deklarieren wir noch zwei weitere Variablen, nämlich i und dazu noch eine Liste. Die Variable “i” brauchen wir, um uns die Liste später genauer anschauen zu können.

Nun fügen wir 5 Werte in die oben erwähnte Liste ein, welche die Distanz von 5 Messungen sind.

addDistance = detectDistance_a()
addDistance = round(addDistance)
liste.append(addDistance)

Damit wir diese Liste in unserer Konsole sehen:

print liste

Jetzt müssen wir diese Liste noch auswerten.

for number in liste:

    if liste[i] < 50:
            print "Someone entered the room."
            persons = persons + 1
            if persons < 0:
                persons = 0
            if persons > 0:
                GPIO.output(led, 1)
                os.chdir(path) // Directory ändern für Licht
                subprocess.Popen("./send 001100 2 1", stdout=subprocess.PIPE, shell=True) // Licht anschalten
                print persons
                break
            elif liste[i] > 50:
                if i <= len(liste):
                    i = i + 1
                elif i > len(liste):
                    break

“for number in liste” bedeutet, dass alles, was sich in diesem for-loop befindet, so oft gemacht wird, wie “liste” Einträge hat. Damit stellen wir sicher, dass auch jeder Wert überprüft wird. Wenn der jeweilige Wert aus liste eine Distanz von weniger als 50 cm aufweist, können wir daraus schließen, dass jemand den Raum verlassen, bzw. betreten hat. Wir können nun 1 von unserer Variable “persons” abziehen bzw. addieren. Direkt im Anschluss wird das Licht aus- oder angeschaltet.

All das brauchen wir natürlich auch für die andere Reihenfolge. Dabei müssen nur einige “a”s zu “b”s verändert werden.

Den fertigen Code könnt Ihr Euch aus der Download-Box (siehe oben) herunterladen.

Das Programm könnt ihr jetzt mit dem Befehl
sudo python ultrasonic.py
ausführen.

Kommentar vom Autoren Julien

Ich hoffe das Tutorial hat Euch geholfen. Bei weiteren Fragen könnt Ihr mir gerne eine Mail an julien.jaacks@gmail.com schreiben, ich werde versuchen, so gut wie möglich zu helfen. 🙂

[Tutorial] Haussteuerung mit dem Raspberry Pi – Anleitung