0100110110110001001110010100110111000010101010111011110102                               42                                   

Automatisches Raspberry Pi Gewächshaus

Datum: 20. Okt / 2017

Quelle: https://tutorials-raspberrypi.de/automatisches-raspberry-pi-gewaechshaus-selber-bauen/

Automatisches Raspberry Pi Gewächshaus selber bauen

In immer mehr Städten geht der Trend zu biologisch oder gar selbst-angebautem Obst und Gemüse. Ein Grund, der vielleicht abschreckt, ist der zeitliche Aufwand für die Pflege der Pflanzen. Daher geht es in diesem Projekt um das Erstellen eines automatisierten Raspberry Pi Gewächshaus, welches die Arbeit auf ein Minimum reduziert.

Durch automatisches Gießen, Lüften und Belichten muss lediglich am Ende das Ernten von Hand übernommen werden. Alle Aktionen (wie das bewässern) werden dabei von Sensoren gesteuert, um ein optimales Ergebnis zu liefern. Durch den geringen Platzverbrauch (ca 1/2 m²) eignet es sich außerdem auch für den städtischen Balkon.

Einkaufsliste

Niedrig wachsende Pflanzen sind besonders für das automatische Raspberry Pi Gewächshaus geeignet.

Da das Raspberry Pi Gewächshaus möglichst autonom arbeiten soll, soll alles nötige automatisiert werden. Dazu ist natürlich einiges an Zubehör vonnöten. Für einen Balkon kann am besten jenes Zubehör genutzt werden:

Ich nutze zwei der Wasserpumpen, da ich in zwei Blumenkästen etwas gesät habe. Du kannst die Anzahl der Sensoren für die Bodenfeuchtigkeit variieren.

Natürlich kannst du die Teile auf dein Projekt anpassen. Wenn du bspw. ein größeres Frühbeet / Gewächshaus hast, so kannst du den Code unten natürlich für deine Zwecke anpassen / optimieren.

Falls du den unten gezeigten Aufbau für die Stromversorgung per GPIOs nachbauen willst, benötigst du außerdem noch dies:

Inhaltsverzeichnis:

Installation der benötigten Bibliotheken

Zu allen der benötigten Module findest du auch eigenständige Tutorials, falls du die Funktionsweise im Detail verstehen möchtest:

Am besten du nimmst ein frisch installiertes Raspbian Jessie und öffnest darauf ein Terminal (z.B. per SSH). Zunächst updaten wir alles und installieren ein paar Packages:

sudo apt-get update --yes && sudo apt-get upgrade --yes
sudo apt-get install build-essential python-dev python-pip python-smbus python-openssl git --yes

Der Vorgang kann etwas Zeit in Anspruch nehmen. Währenddessen kannst du bereits mit dem Aufbau des Frühbeet Kastens anfangen.

Gib nun sudo raspi-config ein und wähle „Interfacing Options“ -> „SPI“ und aktiviere es. Selbes machst du mit „I2C“. Starte danach neu.

Anschließend installieren wir die benötigten Bibliotheken.

  • SpiDev:
    git clone https://github.com/doceme/py-spidev
    cd py-spidev
    sudo python setup.py install
    cd ..
  • Adafruits Bibliothek für den DHT11/DHT22 (alternativ direkt aus GitHub laden):
    sudo pip install adafruit_python_dht

Stromversorgung über GPIOs

Prinzipiell hast du zwei Möglichkeiten, den Raspberry Pi mit Strom zu verbinden. Die eine Möglichkeit ist gewöhnlich über den Micro USB Port. Der Nachteil darin ist aber, dass du normalerweise zwei Steckdosen brauchst.

Daher zeige ich erst einmal, wie man den Raspberry Pi über die GPIOs mit Strom versorgt. Hierbei ist Vorsicht geboten, da eine zu hohe Spannung den Pi kaputt machen kann! Falls du dich unsicher fühlst, wähle lieber die Stromversorgung per USB Kabel.

Der L7805 Spannungsregulator (Datenblatt) kann Spannungen von 7 bis 25V auf 5V herunter regulieren. Dazu werden allerdings noch zwei Kondensatoren benötigt. Der Anschluss ist folgender:

Raspberry Pi Greenhouse L7805 SteckplatineBevor du es an den Raspberry Pi anschließt, kannst du mit einem Multimeter die Spannung nachmessen.

Details dazu können hier nachgelesen werden.

Raspberry Pi Gewächshaus – Komponenten

Vorweg gesagt: Du kannst entweder jedem einzelnen Schritt folgen und so den Programmcode erweitern, oder wie am Ende des Tutorials beschrieben, den Code auf einmal aus dem Github Repository herunterladen und danach anpassen.

Dieses Tutorial soll möglichst individualisierbar sein, da jeder andere Bedingungen vorliegen hat. Daher ist der kommende Teil in verschiedene, einzelne Abschnitte unterteilt. Falls du also bestimmte Komponenten weglassen möchtest (z.B. keine Real Time Clock oder keine Beleuchtung), so kannst du diesen Teil weglassen bzw. entsprechend anpassen.

Zunächst aber die Einstellungen der GPIOs usw. In einem neuen Ordner (mkdir Raspberry-Pi-Greenhouse && cd Raspberry-Pi-Greenhouse) erstellen wir eine neue Datei (sudo nano greenhouse.py) mit folgendem Inhalt:

 

import RPi.GPIO as GPIO

import Adafruit_DHT

from MCP3008 import MCP3008

import SDL_DS1307

import time

##################################################################

##################### CUSTOMIZEABLE SETTINGS #####################

##################################################################

SETTINGS = {

„LIGHT_GPIO“: 17, # GPIO Number (BCM) for the Relay

„LIGHT_FROM“: 10, # from which time the light can be turned on (hour)

„LIGHT_UNTIL“: 20, # until which time (hour)

„LIGHT_CHANNEL“: 0, # of MCP3008

„LIGHT_THRESHOLD“: 500, # if the analog Threshold is below any of those, the light will turn on

„DHT_GPIO“: 27, # GPIO Number (BCM) of the DHT Sensor

„DHT_SENSOR“: Adafruit_DHT.DHT22, # DHT11 or DHT22

„TEMP_THRESHOLD“: 23.0, # in Celcius. Above this value, the window will be opened by the servo

„SERVO_GPIO“: 22, # GPIO Number (BCM), which opens the window

„SERVO_OPEN_ANGLE“: 90.0, # degree, how much the servo will open the window

„PLANTS“: [

{

„NAME“: „Tomaten“,

„MOISTURE_CHANNELS“: [1, 2], # of MCP3008

„MOISTURE_THRESHOLD“: 450, # if the average analog value of all sensors is above of this threshold, the Pump will turn on

„WATER_PUMP_GPIO“: 23, # GPIO Number (BCM) for the Relais

„WATERING_TIME“: 10, # Seconds, how long the pump should be turned on

},

{

„NAME“: „Salat“,

„MOISTURE_CHANNELS“: [3, 4],

„MOISTURE_THRESHOLD“: 450,

„WATER_PUMP_GPIO“: 24,

„WATERING_TIME“: 12,

},

]

}

##################################################################

################# END OF CUSTOMIZEABLE SETTINGS ##################

##################################################################

Falls du andere GPIOs oder andere Einstellungen möchtest, kannst du dies hier anpassen.

In den folgenden Abschnitten erweitern wir die Funktionen (sofern gewünscht). Eine Belegung der GPIOs kannst du in dieser Abbildung finden.

Vorbereitung für das Raspberry Pi Gewächshaus

Bevor wir die elektronischen Komponenten anbringen, sollte das Frühbeet aufgebaut sein. Darin können (je nach Größe) 2-3 große Blumenkästen platziert werden. In diese kannst du entweder Jungpflanzen oder Samen setzen. Achte dabei auf die Hinweise auf der Verpackung.

Zusätzlich bietet es sich an, die Erde zu düngen. Wer möchte kann außerdem noch spezielle Tomaten- oder Gemüseerde nehmen, in der mehr Mineralien vorhanden sind.

Uhrzeit anpassen

Gerade wenn der Raspberry Pi außerhalb kein Internet zur Verfügung hat (oder du es ausschaltest), so ist es von Vorteil die aktuelle Zeit zu kennen.Wenn der Pi (nach einem Stromausfall oder ähnlichem) neu startet, so kennt er die aktuelle Uhrzeit und das Datum nicht. Dafür gibt es Real-Time-Clock (Echtzeituhr) Module, welche eine Batterie haben und den Zeitstempel dauerhaft speichern. Dieser Schritt ist optional und kann auch übersprungen werden, sofern dauerhaft eine Internetverbindung besteht.

Wichtig ist, dass bei den Tiny RTC (I2c modules) die beiden Widerstände (R2 und R3) mit einem Lötkolben abgemacht werden (Details hier). Normalerweise geben diese Module 5V Signale zurück, was zu viel für den Raspberry Pi ist. Alternativ kannst du einen 3.3V-5V TTL nutzen.

Fangen wir also an mit dem Anschluss:

RTC Modul

Raspberry Pi

SCL

GPIO 3 / SCL (Pin 5)

SDA

GPIO 2 / SDA (Pin 3)

VCC / 5V

5V (Pin 2 oder Pin 4)

GND

GND (Pin 6) bzw. jeder andere GND Pin

Raspberry Pi RTC Real Time Clock Aufbau

Zunächst laden wir das benötigte Skript:

wget https://raw.githubusercontent.com/tutRPi/Raspberry-Pi-Greenhouse/master/SDL_DS1307.py

Anschließend legen wir die richtige Uhrzeit und Zeitzone fest:

sudo raspi-config

Unter „Localisation Options“ kannst du deine Zeitzone festlegen. Anschließend kannst du mit date überprüfen, ob die Uhrzeit stimmt. Öffne nun die Python Konsole (sudo python) und gib folgendes ein, um die RTC Uhrzeit einzustellen:

import SDL_DS1307
ds1307 = SDL_DS1307.SDL_DS1307(1, 0x68)
ds1307.write_now()
exit()

Damit ist die aktuelle Uhrzeit gespeichert.

Jetzt können wir unser eigentliches Skript erweitern (sudo nano greenhouse.py):

 

def readTime():

try:

ds1307 = SDL_DS1307.SDL_DS1307(1, 0x68)

return ds1307.read_datetime()

except:

# alternative: return the system-time:

return datetime.datetime.utcnow()

Speichere mit STRG+O.

Helligkeit anpassen

Raspberry Pi MCP3008 Pinout

Auf der linken Seite des MCP3008 befinden sich die 8 analog auslesbaren Channels.

Damit die Pflanzen auch an bewölkten Tagen genug Licht erhalten, erweitern wir das Gewächshaus um eine helle lange LED. Du könntest auch einen (wasserfesten) LED Streifen nutzen und diesen als zusätzliche Beleuchtung nutzen. Allerdings soll die künstliche Beleuchtung nur angeschaltet werden, wenn es dunkel ist. Daher nutzen wir einen Lichtsensor, der einen analogen Helligkeitswert ausgibt, welchen wir mit einem MCP3008 ADC auslesen können.

Alternativ gibt es auch Lichtsensor Module, welche bereits einen digitalen Wert ausgeben, ob der Helligkeitswert über/unter einem Schwellwert liegt. Falls du diesen nutzen willst, so musst du den Code etwas anpassen.

Der MCP3008 IC hat 8 Eingänge, an denen analoge Signale ausgelesen werden können.  Zunächst schließen wir alles an:

RaspberryPi

MCP3008

Pin 1 (3.3V)

Pin 16 (VDD)

Pin 1 (3.3V)

Pin 15 (VREF)

Pin 6 (GND)

Pin 14 (AGND)

Pin 23 (SCLK)

Pin 13 (CLK)

Pin 21 (MISO)

Pin 12 (DOUT)

Pin 19 (MOSI)

Pin 11 (DIN)

Pin 24 (CE0)

Pin 10 (CS/SHDN)

Pin 6 (GND)

Pin 9 (DGND)

Einen der 8 Kanäle nutzen wir für den Lichtsensor (Kanal 0). Diesen schließen wir wie in der Abbildung gezeigt über einen Pull-Up Widerstand an. Weiterhin schließen wir das Relay an (VCC an 5V, GND an GND und z.B.IN1 an GPIO17). Falls du den Raspberrry Pi über den L7805 mit Strom versorgst, so kannst du die 5V Spannung auch direkt von dort nehmen.

Auf der anderen Seite des Relais kommt an den mittleren Anschluss der Pluspol der 12V Verbindung und an den unteren die Verbindung (+) zur LED. GND des LED Streifens wird ebenfalls an GND des Steckers angeschlossen.

Zunächst laden wir eine Datei mit einer Python Klasse für den MCP3008, die wir einbinden können:

wget https://raw.githubusercontent.com/tutRPi/Raspberry-Pi-Greenhouse/master/MCP3008.py

Nun erweitern wir wieder den Code:

 

def checkLight():

timestamp = readTime()

if SETTINGS[„LIGHT_FROM“] <= timestamp.hour <= SETTINGS[„LIGHT_UNTIL“]:

# check light sensors

adc = MCP3008()

# read 10 times to avoid measuring errors

value = 0

for i in range(10):

value += adc.read( channel = SETTINGS[„LIGHT_CHANNEL“] )

value /= 10.0

if value <= SETTINGS[„LIGHT_THRESHOLD“]:

# turn light on

GPIO.setup(SETTINGS[„LIGHT_GPIO“], GPIO.OUT, initial=GPIO.LOW) # Relay LOW = ON

else:

# turn light off

GPIO.setup(SETTINGS[„LIGHT_GPIO“], GPIO.OUT, initial=GPIO.HIGH)

else:

# turn light off

GPIO.setup(SETTINGS[„LIGHT_GPIO“], GPIO.OUT, initial=GPIO.HIGH)

Automatische Bewässerung

Kleine 12V Pumpe zum Bewässern der Pflanzen.

Die Bewässerung anhand der Bodenfeuchtigkeit ist das Kernelement des Gewächshaus. Dazu benötigen wir die Tauchpumpen und für jede Pumpe einen Schlauch sowie ein Relais. Die Bodenfeuchtigkeitssensoren werden über den vorher angeschlossenen MCP3008 ausgelesen.

Da diese Minipumpen ebenfalls mit 12V betrieben werden, werden ebenfalls Relais benötigt. In meinem Fall habe ich zwei Pumpen (jeweils eine pro Blumenkasten). Falls du mehr als 3 nutzt, so solltest du ein Relais Board mit mehr Kanälen wählen.

Zunächst befestigen wir den Schlauch an der Pumpe. Neben dem Frühbeet habe ich einen Eimer mit Wasser gestellt. Der Schlauch sollte lang genug sein, um von diesem Eimer bis zum Ende des Blumenkastens zu gelangen. Das Ende des Schlauches habe ich mit etwas Heißkleber abgedichtet und stattdessen alle 10-15cm kleine Löcher in den Schlauch gebohrt. Da der Druck durch die Pumpe ansteigt, sollten die Löcher nur sehr klein sein. Ich habe eine Bohrstärke von 2mm genutzt.

Anschließend habe ich den Schlauch an den Rand des Blumenkastens befestigt. Auf der jeweils anderen Seite eines Lochs habe ich einen Bodenfeuchtigkeitssensor gesetzt. Später wird die durchschnittliche Bodenfeuchtigkeit berechnet und anhand dessen entschieden, ob gegossen werden sollte, oder nicht. Die analogen Pins der Bodenfeuchte-Sensoren kommen jeweils an den MCP3008. Über einen 10k Ohm Widerstand führt jeweils außerdem eine Leiterbahn zu GND.

Falls du mehr als 7 Sensoren nutzt, benötigst du einen weiteren MCP3008 ADC (der erste Platz ist für den Lichtsensor reserviert). Außerdem wird jeder Sensor mit 3.3V des Raspberry Pi’s versorgt:

Die GPIOs, welche die Relais steuern kannst du ebenfalls in den Einstellungen am Anfang der Datei einstellen. Bei meinen beiden Pumpen sind dies GPIO 23 und 24.

Hier noch der entsprechende Code:

 

def wateringPlants():

# read moisture

adc = MCP3008()

for plantObject in SETTINGS[„PLANTS“]:

value = 0

for ch in plantObject[„MOISTURE_CHANNELS“]:

# read 10 times to avoid measuring errors

v = 0

for i in range(10):

v += adc.read( channel = ch )

v /= 10.0

value += v

value /= float(len(plantObject[„MOISTURE_CHANNELS“]))

if value > plantObject[„MOISTURE_THRESHOLD“]:

# turn pump on for some seconds

GPIO.setup(plantObject[„WATER_PUMP_GPIO“], GPIO.OUT, initial=GPIO.LOW)

time.sleep(plantObject[„WATERING_TIME“])

GPIO.output(plantObject[„WATER_PUMP_GPIO“], GPIO.HIGH)

Belüftung

Je nach Frühbeet oder Gewächshaus sind mehrere aufklappbare Fenster vorhanden. Bei einem Frühbeet sind es normalerweise nicht mehr als zwei. Um so ein Fenster zu öffnen nutze ich einen Servo, an dessen Achse ein längerer Holzstab befestigt ist. Im Anfangszustand sollte der Winkel 0° betragen. Falls du dir unsicher bist, solltest du den Servo einmalig per Skript auf 0° stellen und erst dann befestigen:

Der Servo wird an der Innenseite mit starkem doppelseitigen Klebeband angebracht.

Zur Steuerung dient der Temperaturwert innerhalb. Dafür müssen wir noch den DHT11 Temperatursensor noch an GPIO 27 anschließen, wohingegen der Servo Motor an GPIO 22 kommt. Da der Motor wahrscheinlich mehr als 3.3V braucht (siehe im Datenblatt nach, falls du unsicher bist), schließen wir diesen an die 5V Spannung an:

Ich habe den DHT Sensor einfach an dem wasserfesten Gehäuse angebracht (nächster Punkt). Um die Temperatur zu ändern, bei der die Luke geöffnet werden soll, kannst du die anfangs angelegten Einstellungen verändern.

Außerdem muss der Code natürlich noch erweitert werden:

 

def checkWindow():

# read remperature

humidity, temperature = Adafruit_DHT.read_retry(SETTINGS[„DHT_SENSOR“], SETTINGS[„DHT_GPIO“])

GPIO.setup(SETTINGS[„SERVO_GPIO“], GPIO.OUT)

pwm = GPIO.PWM(SETTINGS[„SERVO_GPIO“], 50)

if temperature > SETTINGS[„TEMP_THRESHOLD“]:

# open window

angle = float(SETTINGS[„SERVO_OPEN_ANGLE“]) / 20.0 + 2.5

pwm.start(angle)

else:

# close window

pwm.start(2.5)

# save current

time.sleep(2)

pwm.ChangeDutyCycle(0)

Falls du Probleme beim Auslesen hast („ImportError: No module named Raspberry_Pi_Driver„), hilft eventuell dieser Post. Alternativ kannst du auch GPIO 4 verwenden, welcher in meinem Aufbau noch frei ist.

Wasserfestes Gehäuse & Befestigung

Im letzten Schritt der Montage packen wir die wichtigen Steuerungselemente in ein wasserfestes Gehäuse. Hier sollte das Raspberry Pi sowie die Relais und alles weitere, was wasserempfindlich ist hinein. Ich habe an die untere Seite ein Loch gebohrt und alle Kabel, welche hinein oder hinaus müssen, dadurch geführt.

Außerdem bietet es sich an die Komponenten auf eine Lochrasterplatine zu löten, sobald alles einmal getestet wurde.

Nichtsdestotrotz sollte die Elektronik und die potentiell gefährdeten Anschlüsse vom Wasser fern gehalten werden. Am besten wählst du einen überdachten Bereich aus.

Raspberry Pi Gewächshaus in Betrieb nehmen

Nachdem wir nun alle Komponenten angeschlossen und angebracht haben, wollen wir es nun automatisch arbeiten lassen. Dazu ergänzen wir das Skript, indem wir die angelegten Funktionen der Reihe nach aufrufen:

 

if __name__ == ‚__main__‘:

try:

GPIO.setwarnings(False)

GPIO.setmode(GPIO.BCM)

# execute functions

checkLight()

wateringPlants()

checkWindow()

except:

GPIO.cleanup()

Übrigens: Falls du alle vollständigen Dateien auf einmal herunterladen möchtest, kannst du dies über meine GitHub Bibliothek:

git clone https://github.com/tutRPi/Raspberry-Pi-Greenhouse

Damit das Skript automatisch alle 10 Minuten aufgerufen wird, nutzen wir Cron:

crontab -e

Hier fügen wir am Ende eine Zeile hinzu, wodurch unser Skript alle 10 Minuten aufgerufen wird:

*/10 *    * * *   sudo python /home/pi/Raspberry-Pi-Greenhouse/greenhouse.py > /dev/null 2>&1

Mit STRG+O speichern wir und kehren mit STRG+X zurück ins Terminal.

Übrigens: Den absoluten Pfad eines Verzeichnisses findest du, indem du mit cd dorthin wechselst und anschließend pwd eingibst.

Nun musst du nichts weiter machen, als zu warten. Um Strom zu sparen, kannst du das WLAN und weitere nicht benötigte Services deaktivieren.

Mögliche Erweiterungen des Raspberry Pi Gewächshauses

Auch wenn schon einiges vorhanden ist, kann man sicherlich noch einiges mehr hinzufügen. Mir sind folgende Punkte eingefallen, wovon ich bei Bedarf auch das ein oder andere umsetzen kann. Wer weitere Ideen hat, kann gerne einen Kommentar hinterlassen.

  • Wasserfüllstand: Zwar bewässern wir die Pflanzen automatisch, allerdings muss immer noch per Hand Wasser in den Eimer nachgegossen werden. Mit einer Füllstandsmessung könnte man sich z.B. per Telegram App benachrichtigen, sobald Wasser nachgefüllt werden muss. Alternativ kann man auch eine Warnleuchte (LED) anbringen.
  • Luftfeuchte messen: Der DHT11 bzw. DHT22 Sensor kann neben der Temperatur auch die Luftfeuchtigkeit messen. Dies nutzen wir allerdings im Moment nicht. Denkbar wäre, dass man die Luftfeuchtigkeit mit Wasserspritzern auf ein bestimmtes Level bringt. Wobei dies natürlich abhängig von den Pflanzen ist.
  • Heizen: Gerade im kälteren Frühjahr oder im Herbst kann es auch mal kühler werden. Um optimale Verhältnisse für die Pflanzen zu schaffen, kann man auch die Luft im Gewächshaus heizen.
  • Aktiv kühlen: Bisher kühlen wir nur passiv (Fenster auf/zu). Durch einen Lüfter könnten wir bei hohen Temperaturen zusätzlich auch noch aktiv kühlen.
  • LCD Anzeige: Daneben könnten wir außerdem noch eine Anzeige per LCD Display bauen, sodass wir die aktuellen Daten auch auf einem Bildschirm angezeigt bekommen.

PS: Ihr seid gerne dazu eingeladen Bilder eures automatischen Raspberry Pi Gewächshauses bzw. Frühbeetes zu verlinken.


Comments are closed.