Blog

Der Raspberry Pi eignet sich hervorragend für den Bereich Hausautomatisierung und Gartenautomatisierung.

Ein Einsatzszenario, dass wir hier näher durcharbeiten ist die Bewässerung des eigenen Gartens, aber auch von Gemüsebeeten oder ähnlichen.

Die Steuerung erfolgt über verschiedene Sensoren. Damit werden Pumpen angesprochen, die die Bewässerung durchführen.

Grundlage wird ein kleines Skript sein, dass Sie selbst erweitern und anpassen können.

Sie sollten bereits Erfahrung im Umgang mit Linux und der Programmiersprache Python haben.

Das wird benötigt

Komplettset

Raspberry Pi inklusive Micro SD Karte und USB Netzstecker*

Einzelkomponenten

Raspberry Pi*

SD Karte*

Netzteil*

Funksteckdosen*

433 Mhz Sender und Empfänger*

Jumper Kabel*

Breadboard*

Pflanzensensor*

Knopfbatterie*

Pumpe*

Schläuche*

* Werbung

Die obigen Links weisen auf exemplarische Produkte bei Amazon. Die von uns verwendeten Komponenten für die unteren Beispiele sind nicht mehr verfügbar.

Sie müssen bei der Bestellung darauf achten, dass die Komponenten die Sie verwenden mit einander kompatibel sind.

Vorbereitungen

Nachdem der Raspberry Pi eingerichtet wurde, muss die notwendige Software installiert werden.

Sie sollten eine neue Sitzung am Raspberry Pi immer mit

sudo apt-get update

sudo apt-get upgrade

starten. Anschließend geben Sie

sudo apt-get install python3

ein um Python3-Paket zu installieren.

Beachten Sie bitte, dass im nachfolgenden Skript alle Pfade gemäß Ihrer Spezifikationen angepasst werden müssen. Je nach verwendeter Hardware sind Änderungen notwendig. Wir bitten um Verständnis, dass wir nicht aus die unzähligen möglichen Kombinationen eingehen können und auch in dieser Sache keinen kostenlosen Support leisten können.

Achten Sie auch auf die richtigen Einschübe bei Python.

Funksteckdosen

Für die Funksteckdosen werden folgende zwei Pakete benötigt. Einmal Pip3 und einemal RPI-RF:

sudo apt-get install python3-pip

sudo pip3 install rpi-rf

Anschluss

Der Anschluss der Komponenten ist etwas heikel, da er stark davon abhängig ist, welche Komponenten Sie nutzen.

Es entsteht dabei folgendes Belegungsschema:

Funksteckdosenfernbedienung auslesen

Nachdem Sie alles verkabelt haben, können Sie sich dran setzen die Codes richtig auszulesen.

Dazu können Sie folgendes Skript verwenden:

#!/usr/bin/env python3

import argparse
import signal
import sys
import time
import logging

from rpi_rf import RFDevice

rfdevice = None

def exithandler(signal, frame):
    rfdevice.cleanup()
    sys.exit(0)

logging.basicConfig(level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S', format='%(asctime)-15s - [%(levelname)s] %(module)s: %(message)s', )

parser = argparse.ArgumentParser(description='Empfange einen Dezimalcode via 433/315 MHZ GPIO Gerät')
parser.add_argument('-g', dest='gpio', type=int, default=27, help="GPIO (Standard: 27)")
args = parser.parse_args()

signal.signal(signal.SIGINT, exithandler)
rfdevice = RFDevice(args.gpio)
rfdevice.enable_rx()

timestamp = None
logging.info("Warten auf GPIO Codes " + str(args.gpio))
while True:
    if rfdevice.rx_code_timestamp != timestamp:
        timestamp = rfdevice.rx_code_timestamp
        logging.info(str(rfdevice.rx_code) +" [Pulslänge " + str(rfdevice.rx_pulselength) + ", protocol " + str(rfdevice.rx_proto) + "]")
    time.sleep(0.01)
rfdevice.cleanup()

Achten Sie darauf, dass Sie die Fernbedientung wirklich sehr nahe am Empfänger halten. Drücken Sie auf der Fernbedienung nun die Taste für „AN“.

In der Konsole finden Sie nun den Code für „AN“. Schreiben Sie sich diesen Code und die Pulslänge auf. Das Skript könne Sie mit „Strg+C“ abbrechen.

Das gleiche wiederholen Sie mit der Taste für „AUS“.

Manchmal kommt es vor, dass mehrere verschiedene Zahlen als Codes angezeigt werden. In diesem Fall müssen Sie durch ausprobieren die richtigen Codes finden.

Bei mir haben sich Beispielsweise folgende Werte gebildet:

Steckdose an: 4519821, Pulslänge: 314 – 315

Steckdose aus: 4519825, Pulslänge: 314 – 315

Daraus können Sie jetzt die Skript basteln mit denen Sie die Steckdose Anschalten und Ausschalgen können.

Beispiel fürs Anschalten:

from rpi_rf import RFDevice
import RPi.GPIO as GPIO

# Steckdosenparameter
gp=17
aus = 4519821
proto = 1
puls1 = 315
puls2 = 314

# Steckdose anschalten
rfdevice = RFDevice(gp)
rfdevice.enable_tx()
rfdevice.tx_code(aus, proto, puls1)
rfdevice.tx_code(aus, proto, puls2)
rfdevice.tx_code(aus, proto, puls1)
rfdevice.tx_code(aus, proto, puls2)
rfdevice.cleanup()

Beispiel fürs Ausschalten:

from rpi_rf import RFDevice
import RPi.GPIO as GPIO

# Steckdosenparameter
gp=17
aus = 4519825
proto = 1
puls1 = 315
puls2 = 314

# Steckdose anschalten
rfdevice = RFDevice(gp)
rfdevice.enable_tx()
rfdevice.tx_code(aus, proto, puls1)
rfdevice.tx_code(aus, proto, puls2)
rfdevice.tx_code(aus, proto, puls1)
rfdevice.tx_code(aus, proto, puls2)
rfdevice.cleanup()

Pflanzensensor

Den Pflanzensensor installieren Sie gemäß der beiliegenden Anleitung.

Sie benötigen nun die Mac-Adresse des Pflanzensensors. Diese erhalten Sie, wenn Sie

sudo hcitool lescan

eingeben.

Wenn Sie mehrere Sensoren haben, werden Sie mehrere Einträge sehen. Eine MAC-Adresse hat das Format

15:C4:FA:11:25:B2

Bewässerung

Nun kümmern wir uns um das komplexeste Skript. Das Skript, dass die Bewässerung steuert.

#!/usr/bin/python3

import time
from sys import exit
import pymysql
import datetime
#Verwenden Sie bitte die Bibliothek, die für Ihren Sensor geeignet ist
from MySensors.MySensortools import MySensor
from btlewrap.bluepy import BluepyBackend
from rpi_rf import RFDevice


gp=17
an = 4519821
aus = 4519825
proto = 1
puls1 = 315
puls2 = 314

#Hier geben Sie bitte die Startzeit und die Endzeit an, in denen das Skript laufen soll
#Im unteren Beispiel zwischen 8 und 20 Uhr
startTime = 8
endTime = 20

#Wie lange soll die Pumpe laufen in Sekungen
pumpendauer = 900

#Hier definieren Sie die Zeit, die die Pumpe warten soll, nachdem Sie aktiviert wurde. Damit verhindert man das versehendliche mehrmalige aktivieren der Pumpe
wartenpumpe = 7200

#Hier definieren wir die Wartezeit bezüglich der Bodenfeuchte. Wenn der Boden noch feucht genug ist, warte xxxx Sekunden.
wartenbodenfeuchte = 7200

#Die Nachpause
wartenachts = 28800


while True:
    #Aktuelle Zeit in Stunden auslesen.
    hourNow = int(time.strftime('%H'))
    
    startZeit = int(startTime)
    endZeit = int(endTime)
    
    if (hourNow >= startZeit) and (hourNow < endZeit):
    
        sensor_beet1 = MySensortools.Connect("15:C4:FA:11:25:B2", BluepyBackend)
        time.sleep(2)

        
        name1 = "Beet 1"
        #Hier werden die Werte des Sensors ausgelesen
        feuchtigkeit = sensor_beet1.parameter_value('moisture')
        
        time.sleep(2)
            
        feucht = feuchtigkeit

        # 35 gibt den Feuchtigkeitswert an
        if (feucht < 35):
        #Hier wird die Steckdose an geschaltet.
            rfdevice = RFDevice(gp)
            rfdevice.enable_tx()
            rfdevice.tx_code(an, proto, puls1)
            rfdevice.tx_code(an, proto, puls2)
            rfdevice.tx_code(an, proto, puls1)
            rfdevice.tx_code(an, proto, puls2)
            rfdevice.cleanup()
            #Das Programm wartet und lässt die Pumpe solange wie oben angegeben laufen.
            pumpendauerinmin = pumpendauer/60
                  
            time.sleep(pumpendauer)

	#Hier wird die Steckdose aus geschaltet.
            rfdevice = RFDevice(gp)
            rfdevice.enable_tx()
            rfdevice.tx_code(aus, proto, puls1)
            rfdevice.tx_code(aus, proto, puls2)
            rfdevice.tx_code(aus, proto, puls1)
            rfdevice.tx_code(aus, proto, puls2)
            rfdevice.tx_code(aus, proto, puls1)
            rfdevice.tx_code(aus, proto, puls2)
            rfdevice.tx_code(aus, proto, puls1)
            rfdevice.tx_code(aus, proto, puls2)
            rfdevice.cleanup()
         
            time.sleep(wartenpumpe)
   
        else:
      	#Sicherheitsabschaltung. Es ist für Sie sicherer, wenn Sie an verschiedenen Stellen die Pumpe öfters einfach mal ausschalten. Bei komplexen Steuerungen kann es vor kommen, dass es nicht immer der Fall ist.
            rfdevice = RFDevice(gp)
            rfdevice.enable_tx()
            rfdevice.tx_code(aus, proto, puls1)
            rfdevice.tx_code(aus, proto, puls2)
            rfdevice.tx_code(aus, proto, puls1)
            rfdevice.tx_code(aus, proto, puls2)
            rfdevice.tx_code(aus, proto, puls1)
            rfdevice.tx_code(aus, proto, puls2)
            rfdevice.tx_code(aus, proto, puls1)
            rfdevice.tx_code(aus, proto, puls2)
            rfdevice.cleanup()

 	time.sleep(wartenbodenfeuchte)
            
   
    else:
        # Es ist Nacht, das Programm wartet die angegeben Zeit.
        time.sleep(wartenachts)

Mit dem obigen Skript lassen sich auch weitere Werte von den Sensoren auslesen, in eine Datenbank speichern, auswerten und vieles mehr. Ihrer Phantasie ist keine Grenze gesetzt.

Daten auslesen

Mit dem folgenden Skript können Sie exemplarisch die Daten des Sensors auslesen. Der von mir verwendete Sensor hat mehrere Daten, die man auswerten kann. Beispielsweise können Sie in einem Wintergarten auch auf die Temperatur hin reagieren.

#!/usr/bin/python3

import time
from sys import exit
import pymysql
import datetime
#Verwenden Sie bitte die Bibliothek, die für Ihren Sensor geeignet ist
from MySensors.MySensortools import MySensor
from btlewrap.bluepy import BluepyBackend
from rpi_rf import RFDevice


gp=17
an = 4519821
aus = 4519825
proto = 1
puls1 = 315
puls2 = 314


Datum = time.strftime("%d.%m.%Y", time.localtime())
Zeit = time.strftime("%H:%M", time.localtime())

sensor_beet = MySensortools.Connect("15:C4:FA:11:25:B2", BluepyBackend)

batteriestand_beet = sensor_beet.parameter_value('battery')
temperatur_beet = sensor_beet.parameter_value('temperature')
licht_beet = sensor_beet.parameter_value('light')
feuchtigkeit_beet = sensor_beet.parameter_value('moisture')
leitfaehigkeit_beet = sensor_beet.parameter_value('conductivity')

sensor_gewaechshaus = MySensortools.Connect("11:A4:14:3B:71:9E", BluepyBackend)

batteriestand_gewaechshaus = sensor_gewaechshaus.parameter_value('battery')
temperatur_gewaechshaus = sensor_gewaechshaus.parameter_value('temperature')
licht_gewaechshaus = sensor_gewaechshaus.parameter_value('light')
feuchtigkeit_gewaechshaus = sensor_gewaechshaus.parameter_value('moisture')
leitfaehigkeit_gewaechshaus = sensor_gewaechshaus.parameter_value('conductivity')


print("Datum:", Datum, "Zeit:", Zeit)
print("")
print("----------- Sensor: Beet -----------")
print("")
print("Baterie:",batteriestand_beet)
print("Temperatur:",temperatur_beet)
print("Licht:",licht_beet)
print("Feuchtigkeit:",feuchtigkeit_beet)
print("Leifähigkeit:",leitfaehigkeit_beet)
print("")
print("--------------------------------")
print("")
print("----------- Sensor: Gewächshaus -----------")
print("")
print("Baterie:",batteriestand_gewaechshaus)
print("Temperatur:",temperatur_gewaechshaus)
print("Licht:",licht_gewaechshaus)
print("Feuchtigkeit:",feuchtigkeit_gewaechshaus)
print("Leifähigkeit:",leitfaehigkeit_gewaechshaus)
print("")
print("--------------------------------")

Wir wünschen Ihnen viel Spaß mit dem Experimentieren und Ihrem ersten Schritt zu einem smarten Garten mit einem Bewässerungssystem.

Bitte vergessen Sie nicht die obigen Skripte entsprechend Ihrer verwendeten Raspberry Pi Version, Sensoren und sonstiger Hardware anzupassen.

Lassen Sie Ihrer Phantasie freien Lauf. Beispielsweise können Sie die gesamte Anlage autark über Photovoltaik betreiben und dazu das Wasser aus einem eigenen Brunnen ziehen.

Posten Sie uns doch in den Kommentaren, was Sie in Ihrem Garten und in Ihrer Wohnung bereits realisiert haben.

Werbung

WERBUNG