0100110110110001001110010100110111000010101010111011110102                               42                                   

1St chicken dinner

Datum: 11. Mrz / 2018

… winner, winner, chicken dinner !!!!


Geringe Löhne: Norweger sperren Siemens von Aufträgen aus – Unternehmen – derStandard.at › Wirtschaft

Datum: 2. Feb / 2018

https://text.derstandard.at/2000073403760/Schlechte-Bezahlung-Norweger-sperren-Siemens-von-Auftraegen-aus


Demokratie unter Irrationalen – Republik

Datum: 18. Jan / 2018

https://www.republik.ch/2018/01/15/demokratie-unter-irrationalen


PlayerUnknown’s Battlegrounds:ReShade installieren und einstellen

Datum: 14. Jan / 2018

http://www.giga.de/spiele/playerunknowns-battlegrounds/tipps/playerunknowns-battlegrounds-reshade-installieren-und-einstellen/

——————————————


Mein Vogelhaus – RPi 2 B –DietPi

Datum: 18. Nov / 2017

dietpi-boot

… after boot

IMG_0833IMG_0790_CUTIMG_0806-CUTIMG_0821


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.


How economics became a religion | John Rapley | News | The Guardian

Datum: 16. Jul / 2017

https://www.theguardian.com/news/2017/jul/11/how-economics-became-a-religion


Nistkästen für Meise, Spatz und Co selbstgemacht

Datum: 14. Mai / 2017

Nistkästen für Meise, Spatz und Co selbstgemacht

Quelle: 

http://region-hannover.bund.net/themen_und_projekte/naturgarten/vogelfreundlicher_kleingarten/meisenkasten/

Blau- und Kohlmeisen, Sperlinge und Grauschnäpper sind Höhlenbrüter, d.h. sie brauchen einen Nistplatz, der nur durch ein Einflugloch mit einem Durchmesser von 26 bis maximal 32 mm zu erreichen ist und ihre Brut vor Wetter und Räubern schützt. Andere Vögel wie Haus- und Gartenrotschwanz sind Halbhöhlenbrüter und benötigen größere Einflugbereiche. Nachtigallen, Drosseln und Zaunkönige (siehe BUND Information zum Zaunkönig) sind hingegen Freibrüter und bauen sich aus Nistmaterial, dass sie in der Natur suchen, eigene Nester in dichten Hecken oder im Schutz vom Unterholz. Im folgenden stellen wir eine Bauanleitung für Meise und Spatzen vor, jedoch …

… ein Nistkasten allein macht noch keinen Frühling

Wer Meisen oder Sperlingen im Garten oder am Haus ein Heim schaffen möchte, sollte ihnen gleichzeitig auch einen „gedeckten Tisch“ bereiten. Denn ein Nistkasten allein hilft einem Meisenpaar mit Jungen aus Gelegen von bis zu 16 Eiern noch nicht, die Brut erfolgreich großzuziehen. Deshalb sollten in Vorgarten und Garten verschiedene heimische Gehölze gepflanzt sein und auf Exoten – wie z.B. die überall in Baumärkten angebotenen Koniferen – verzichtet werden, die keinen Lebensraum für Insekten bieten. Ein Meisenpaar mit seiner Nachkommenschaft vertilgt nämlich in einem Jahr 120 Mio. Insekteneier oder 150.000 Raupen. Das sind ca. 75 kg Insekten. Außerdem brauchen viele Vögel Samen, Körner und Wildfrüchte als Nahrung, die ihnen hiesige Blütenpflanzen, Sträucher und Bäume bieten.

Bauanleitung für einen Meisenkasten

Für den Nistkastenbau wird ausschließlich naturbelassenes Holz verwendet. Ideal ist Schalholz oder Rauspund (Fichte, Kiefer), wie es direkt bei Sägewerken oder Holzhandlungen zu beziehen ist. In Baumärkten ist 24 mm dickes Spund- oder Schalholz nicht erhältlich. Da bei diesem Material die tatsächlichen Brettbreiten vom Nennmaß abweichen können (z.B. 115 mm bei 120 Nennmaß) und außerdem noch seitlich an den Brettern Borkenpartien vorhanden sein können, sind die Brettbreiten entsprechend größer gewählt worden, um beim Zuschnitt einwandfreie Teile zu erhalten. Eine Dicke von 24 mm ist erforderlich, um die Brut vor Wind und Wetter und möglichen Frösten zu schützen. Die im Handel oft angebotenen dünnwandigen Nistkästen sind daher ungeeignet.

Materialbedarf

Holz: Schalung 24 mm dick, sägerau

  • Verschluss: z.B. Wechselrahmen – Feder
  • Drehbolzen: Rundstab aus Buchenholz Ø 6 mm
  • Nägel: Ø  2,2 x 55 und Ø 3 x 65 (für Dachbefestigung im Hirnholz)
  • Schraub-Ösen für Aufhängung
  • Drahtbügel – Bügel von Farbeimern – selbst gebogen

 

 
 

Materialbedarf Holz im Detail:

Schalung 24 mm dick – 200 mm breit

Rückwand:

A

275+10=285

Dach:

200+10=210

Schalung 24 mm dick – 160 mm breit

Seitenwände:

B+B

270+240+15=525

Schalung 24 mm dick – 140 mm breit

Boden 

C

120+10=130

Vorderwand

D

240+10=250

Der Zusammenbau

Der Zusammenbau sollte sehr sorgfältig erfolgen: d.h. die Einzelteile müssen exakt ausgesägt und die Hinterwand oben leicht angeschrägt werden, damit das Dach passgenau aufgenagelt werden kann.

Ggf. wird vor dem Nageln mit einem sehr feinen Bohrer vorgebohrt, um ein Aufreißen des Holzes zu vermeiden. Die Seitenteile müssen dort, wo der Buchenstab eingebracht wird, übereinander gelegt und genau an derselben Stelle (6 mm) vorgebohrt werden. Holzleim für die Buchenstäbe kommt nur in das Vorderteil. Die Vorderklappe lässt sich so gut zum jährlichen Reinigen (August/September) öffnen. Zum Schließen eignet sich eine Wechselrahmenfeder. Um den Kasten an der Hauswand oder frei hängend am Baum (damit keine Räuber an die Brut gelangen) anzubringen, wird ein ausgedienter Bügel von einem Farbeimer gleichmäßig zusammengebogen und an 2 Ösen oben an den Seitenteilen eingeschraubt. Auch hier ist eine Vorbohrung sinnvoll. Eine sehr gute Verarbeitung ist wichtig, um Zugluft im Brutraum zu verhindern und damit die Nistkästen viele Jahre halten. 


Gewächshaus mit dem Raspberry Pi automatisieren

Datum: 9. Mai / 2016
http://www.raspberry-pi-geek.de/Magazin/2014/05/Gewaechshaus-mit-dem-Raspberry-Pi-automatisieren
Der Raspberry Pi als Gärtner

Gerade im Hochsommer dürfen Gewächshäuser nicht überhitzen, weswegen sie alle über eine oder mehrere Luken auf dem Dach verfügen. Der Aufbau einer Mechanik, die die Dachfenster elektrisch öffnet, stellt jedoch keine triviale Aufgabe dar und erfordert zudem das eine oder andere teure Bauteil. Daher setzen wir zur Klimatisierung handelsübliche PC-Lüfter ein. Ob diese im rauen Klima eines Gewächshauses langfristig überleben, muss sich erst noch zeigen. Immerhin kosten uns die Lüfter keinen Cent, denn sie lagen noch in der Bastelkiste.

Zum Erfassen von Messdaten dienen einfache serielle Sensoren, die der RasPi über die GPIO-Schnittstelle ausliest. Die Lüfter steuert er über den PWM-Port des GPIO-Interfaces an. Einige Ports bereiten wir zum Schalten einfacher Verbraucher vor, etwa zum Steuern der Beleuchtung oder für Pumpen zur Bewässerung.

Als Steuersoftware verwenden wir simple PHP-Skripte. Sie schreiben die Messwerte in eine MySQL-Datenbank, sodass wir sie später grafisch aufarbeiten können. Ein Apache-Webserver fungiert als Frontend, eine Reihe von Cronjobs übernimmt das zeitgesteuerte Ausführen der Aufgaben.

Ökostrom für den RasPi

Im ersten Schritt widmen wir uns dem Thema Energieversorgung. Ein Raspberry Pi, der ja nur rund 3,5 Watt aufnimmt, müsste sich eigentlich vollständig mit Solarstrom versorgen lassen.

Mit der Sonne ist das allerdings so eine Sache: Im Sommer, bei 10 und mehr Sonnenstunden pro Tag, stellt das Versorgen eines RasPi kein Problem dar. Bei trübem Schmuddelwetter im sonnenarmen Winter sieht das schon ganz anders aus. Daher erhebt sich zwangsläufig die Frage: Wie lange soll die Steuerung des Gewächshauses komplett ohne Sonneneinstrahlung auskommen?

Unser Ansatz zur Auslegung der solargestützten Stromversorgung besteht darin, dass die Anlage auch im tiefsten Winter und bei tagelangem Regenwetter einsatzbereit bleiben muss. Zusätzlich sollen genug Energiereserven für weitere Projekte bleiben. Die von uns angenommenen Werte sind nicht in Stein gemeißelt, bei Bedarf passen Sie diese für Ihre Anlage ein wenig nach oben oder unten an.

Wir gehen davon aus, dass der Raspberry mit allen angeschlossenen Extras und Verlusten 12 Watt benötigt – vermutlich liegt der reale Wert etwas niedriger, aber mit 12 Watt lässt sich gut rechnen, weil der Akku eine Spannung von 12 Volt bereitstellt. Bei einem Strom von 1 Ampere ergibt sich also eine Leistung von 12 Watt. Die folgende Liste zeigt, dass wir mit den geschätzten 12 Watt ziemlich dicht an die realen Werte herankommen:

  • Raspberry Pi: 3,5 W
  • Lüfter (im Betrieb): 6 W
  • Verluste der Anlage: 2 bis 3 W

Generell muss man stets 20 bis 30 Prozent der Gesamtleistung einer Anlage als Verlust annehmen (Kasten "Leistungsverluste"). Zudem nimmt die Lebensdauer eines Akkus mit der Tiefe der Entladung rapide ab. Daher ist es sinnvoll, den Akku etwas größer zu dimensionieren, als es die Auslegung rein rechnerisch erfordert. Die Formel P = U*I dient zur Berechnung der Leistung (P, in Watt) aus Spannung (U, in Volt) und Strom (I, in Ampere).

Leistungsverluste

In allen Kabeln geht Leistung verloren, in unserem Fall jedoch nicht sehr viel. Die Verluste nehmen bei kleineren Leitungsquerschnitten zu.

Die Akkus tragen durch Selbstentladungen zu den Verlusten bei. Bei zu schneller oder zu tiefer Entladung entsteht am Akku zudem Abwärme.

Linear arbeitende Laderegler verbrennen regelrecht die Energie, die der Akku gerade nicht aufnehmen kann. Mit einem Mikrocontroller ausgestattete PWM-Regler arbeiten deutlich effizienter.

Auch lineare Spannungswandler erhitzen sich stark und verlieren dadurch viel Leistung. Ein Schaltregler wandelt die Leistung dagegen mit einem Wirkungsgrad um die 80 Prozent.

Aus der Zeit, die der Raspberry Pi ohne einen Sonnenstrahl auskommen soll, ergibt sich direkt die erforderliche Kapazität des Akkus. Ein 12-Volt-Akku mit 100 Ah Kapazität gibt über 100 Stunden hinweg einen Strom von 1 Ampere ab, liefert also über 100 Stunden die benötigten 12 Watt. Bei vollständiger Dunkelheit ergibt sich für das System also eine Gangreserve von mehr als vier Tagen – das sollte genügen.

Die erforderliche Leistung der Solarzelle ergibt sich aus den Sonnenstunden, die zum Laden des Akkus zur Verfügung stehen. Eine 120-Watt-Solarzelle liefert bei maximaler Sonneneinstrahlung bei 12 Volt Spannung 10 Ampere pro Stunde. Das Panel könnte also einen Akku mit 100 Ah Kapazität in knapp 10 Stunden vollständig aufladen. Mit der Formel W=P*t lässt sich die Arbeit (W, in Ah) aus Leistung (P, in Watt) und Zeit (t, in Stunden) berechnen.

Der bei Solarzellen angegebene Wert Wp beziffert die sogenannte Peak-Leistung, also die maximal erreichbare Leistung unter optimalen Bedingungen. Im Regelbetrieb fallen bis zu 20 Prozent weniger Leistung an. Allerdings muss der Laderegler den theoretischen Wert ebenfalls verkraften können.

Nach gründlicher Recherche entschieden wir uns für eine 100-Watt-Solarzelle mit einem 80 Ah starken Akku und einen einfachen PWM-Laderegler – noch kleinere Akkus und Solarzellen kosten in der Regel mehr als solche für Haus-Solaranlagen gedachte Bauelemente.

Mit diesen Bauteilen hoffen wir, die Anlage durch den Winter zu bekommen und für ein komplettes Jahr die Temperaturentwicklung aufzeichnen zu können. Sobald die Außentemperatur sinkt, sollten die Lüfter kaum mehr Energie brauchen, sodass auch bei geringer Sonneneinstrahlung die erzeugte Leistung für den Betrieb des RasPi ausreichen müsste.

WARNUNG

12 Volt stellen für den menschlichen Körper keine Gefahr dar. Lassen Sie bitte dennoch Vorsicht walten: Der Akku liefert bei einem Kurzschluss einige Hundert Ampere Strom – aus diesem Grund verfügen leistungsstarke Akkus auch immer über sehr dicke Anschlussklemmen. Die beim Kurzschluss auftretenden Stromstärken können Gabelschlüssel zum Glühen bringen, und auch das Innere des Akkus erhitzt sich im Kurzschlussfall stark. Es besteht dann die Gefahr, dass die Säure austritt oder das Gehäuse platzt. Schließen Sie den Akku daher bitte immer vorsichtig und richtig gepolt an.

Bei der Verkabelung der Solaranlage achten wir darauf, Leitungen mit einem Mindestquerschnitt von 2,5 mm2 zu verbauen. Die Belegung der Anschlüsse entnehmen wir der Anleitung des gewählten Ladereglers. Diesen schützen wir wiederum mit einem wasserdichten Gehäuse vor Regen und Unwettern.

Nachdem nun die Energieversorgung steht, bauen wir die Hardware für die Gewächshaussteuerung zusammen.

 

Gewächshaussteuerung

Damit der Raspberry durch das Klima im Gewächshaus keinen Schaden nimmt, packen wir ihn wie die Ladeelektronik in ein wasserdichtes Gehäuse. Die Handvoll Elektronikbauteile finden aufgelötet auf einer handelsüblichen Europlatine ihren Platz. Die auf der Heft-DVD enthaltenen Schaltpläne geben einen Überblick, wie alles zusammengehört.

Da die 3,3 Volt der GPIO-Schnittstelle nicht ausreichen, um die MOSFETs zum Schalten zu bewegen, bauen wir eine kleine, über Optokoppler realisierte Vorstufe ein. Diese rettet dem RasPi zudem das Leben, falls es in den Endstufen zu einer Überspannung kommen sollte. Die MOSFETs montieren wir auf Kühlkörper, da sie im PWM-Betrieb sehr viel Hitze entwickeln – im reinen Schalterbetrieb würden sie ohne eine Kühlung auskommen.

Zur einfacheren Montage im Gewächshaus führen wir alle Verbindungspunkte auf eine Klemmleiste. Die Spannungsversorgung übernimmt dann entsprechend den Ausführungen im Kasten "Aus 12 mach 5" ein DC-DC-Wandler. Abbildung 1 zeigt den nun vollständigen Aufbau unserer intelligenten Gartenhaussteuerung fertig montiert in den wasserdichten Gehäusen.

Abbildung 1: So sieht die komplett aufgebaute Platine für die Gewächshaussteuerung aus.

Aus 12 mach 5

Um aus den 12 Volt der Solaranlage die für den Raspberry Pi benötigten 5 Volt zu gewinnen, nutzen wir einen DC-DC-Konverter TSR 1-2450 der Firma Traco Power [5]. Er überzeugt durch deutlich geringere Verluste als ein linearer Spannungsregler. In unserem Fall würde ein linearer Regler mehr Leistung in Wärme verwandeln, als der RasPi zum Betrieb benötigt. Der TSR 1-2450 erzielt in unserer Schaltung einen Wirkungsgrad von über 90 Prozent und entwickelt kaum Hitze. Zum Thema Spannungsversorgung: Der Raspberry Pi lässt sich auch über Pin 2 (+5 Volt) und Pin 6 (0 Volt) der GPIO-Schnittstelle mit Spannung versorgen, dadurch entfällt das USB-Kabel.

Beim Umsetzen Ihrer eigenen Anlage sind Ihren kreativen Ideen keine Grenzen gesetzt. Denken Sie jedoch auch an Triviales wie etwa einen Ein-/Ausschalter: Dieser darf nicht fehlen, da der Raspberry Pi selbst über keinen verfügt und wir den Mini-Rechner fest mit der Spannungsversorgung verbinden. Abbildung 2 zeigt die Pinouts aller verwendeten Halbleiter.

Abbildung 2: Die Pinouts helfen beim Bestücken der Platine ungemein.

Bei den Sensoren fiel die Wahl auf einen Feuchtigkeits- und Temperaturfühler des Typs DHT22 [1](entsprechend dem Schaltplan gartenhaus_2.sch auf Heft-DVD angebunden). Die Entlüftung des Gewächshauses übernehmen, wie schon erwähnt, handelsübliche PC-Lüfter. Für das Bewässern der Pflanzen sorgt eine einfache 12-Volt-Tauchpumpe aus dem Baumarkt. Während des Testbetriebs ersetzt ein Labornetzteil Akku und Solarzellen.

Nachdem damit nun die Hardware steht, kümmern wir uns im nächsten Schritt um die Software.

Einrichten der Software

Als Software-Basis dient ein aktuelles Raspbian, das wir wie üblich auf einer SD-Speicherkarte installieren. Um langfristig ausreichend Platz für Anwendungen und Daten sicherzustellen, sollte diese mindestens über eine Kapazität von 8 GByte verfügen. Nach dem Einrichten des Systems spielen wir sämtliche Updates ein und installieren einen Apache-Webserver mitsamt MySQL-Datenbank und Tools zum Kompilieren von Programmen (Listing 1). Beim Einrichten des Datenbankservers müssen Sie ein eigenes Root-Passwort für MySQL setzen – bitte merken Sie es sich gut.

Listing 1

$ sudo apt-get update && sudo apt-get dist-upgrade
$ sudo apt-get install apache2 mysql-server php5-mysql build-essential git-core

Nach der Installation der Server-Komponenten spielen wir nun die Wiring-Pi-Bibliothek [2] ein (Listing 2). Sie erlaubt das Auslesen der GPIO-Schnittstelle mit einem einfachen Kommando. Das Kompilieren der Programme nimmt auf dem nicht gerade blitzschnellen RasPi eine Weile in Anspruch. Nach Abschluss des Builds rufen Sie mit gpio readall in einem ersten Test die Daten des GPIO-Ports ab (Listing 3).

Listing 2

$ git clone git://git.drogon.net/wiringPi
$ cd wiringPi
$ ./build

Listing 3

$ gpio readall
+----------+-Rev2-+------+--------+------+-------+
| wiringPi | GPIO | Phys | Name   | Mode | Value |
+----------+------+------+--------+------+-------+
|      0   |  17  |  11  | GPIO 0 | IN   | Low   |
|      1   |  18  |  12  | GPIO 1 | IN   | Low   |
|                      [...]                     |
|     19   |  30  |   5  | GPIO10 | ALT2 | Low   |
|     20   |  31  |   6  | GPIO11 | ALT2 | Low   |
+----------+------+------+--------+------+-------+

Als Nächstes benötigen wir für den Temperatur- und Feuchtigkeitssensor DHT22 einen Treiber. Diesen ziehen wir uns aus dem Github des Entwicklers [3] und bauen ihn entsprechend Listing 4. Auch dieser Build-Prozess nimmt wieder eine längere Zeit in Anspruch. Nach dessen Ende lesen Sie die zwei verbauten DHT22-Sensoren mit loldht aus (Listing 5), wozu Sie Root-Rechte benötigen.

Listing 4

$ git clone https://github.com/technion/lol_dht22
$ cd lol_dht22
$ ./configure
$ sudo make install

Listing 5

$ sudo loldht 8
$ sudo loldht 9

An dieser Stelle definieren wir Sensor 8 schon einmal für den Innenraum des Gewächshauses und Sensor 9 als Sensor für die äußere Umgebung. Zum Steuern der Lüfter verwenden wir den PWM-Ausgang des RasPi. Dieser lässt sich zwar nicht ganz so einfach konfigurieren, das soll uns aber nicht daran hindern, es trotzdem zu probieren (Listing 6). Der Pin 12 ist für PWM-Betrieb vorgesehen.

Listing 6

$ gpio mode 1 pwm
$ gpio pwm-bal
$ gpio pwmr 100000
$ gpio pwm 1 14000

Bei den von uns genutzten Lüftern ergeben sich Werte im Bereich von 14*000 bis 17*000. Diese Werte unterscheiden sich jedoch von Lüfter zu Lüfter. Probieren Sie daher am besten jetzt schon aus, wo bei den von Ihnen eingesetzten Lüftern die untere und obere Grenze liegt. Die Werte müssen Sie später in den von uns vorgestellten Skripten eintragen.

 

MySQL-Datenbank

Die durch die Sensoren erhobenen Daten sichern wir in einer MySQL-Datenbank, sodass sich diese später auch wieder einfach auswerten und grafisch aufbereiten lassen. Die Datenbank richten Sie am besten über die von uns auf der Heft-DVD mitgelieferten oder im Internet vorgehaltenen SQL-Datei datalogger.sql ein: So ersparen Sie sich viel Tipparbeit.

Listing 7

$ wget http://linux-user.de/###FIXME###/datalogger.sql
$ mysql -u root -p < datalogger.sql

Mit wget aus dem Netz geladen und per mysql ausgeführt (Listing 7), legt das SQL-Skript automatisch einen Benutzer namens datalogger mitsamt gleichnamiger Datenbank und gleichlautendem Passwort an. Parallel erzeugt es in dieser Datenbank die Tabellen datalogger und history. Beachten Sie bitte, dass mysqlnicht das Root-Passwort des Betriebssystems abruft, sondern das bei der Installation des MySQL-Servers vergebene Passwort des Root-Datenbankbenutzers. In den Tabellen protokollieren wir dann über unsere Skripte die fünf Werte zeitpunkt, sensor, temperatur, luftfeuchte und pwm.

Die beiden Tabellen datalogger und history unterscheiden sich lediglich in der letzten Spalte pwm. Diese benötigen wir nur in datalogger für den Regelalgorithmus der Lüfter. Aus der Tabelle history generieren wir Graphen mit dem Verlauf der Temperatur und Luftfeuchtigkeit – für diese benötigen wir die PWM-Daten nicht.

Apache mit PHP aufsetzen

Als Webserver unseres Gewächshauses dient Apache. Bevorzugen Sie leichtgewichtigere Server, dann greifen Sie ruhig zu Lighttpd oder Cherokee. Der Webserver muss lediglich in der Lage sein, PHP-Skripte auszuführen. Haben Sie sich an unserer Vorgabe orientiert, dann erfolgte die Installation von Apache schon zusammen mit MySQL.

Um zu prüfen, ob die Installation von Apache und PHP erfolgreich war, erzeugen Sie mit der Zeile ausListing 8 ein kleines PHP-Testskript. Über die URL http://RasPI-IP/phpinfo.php kontrollieren Sie danach die Installation. Die IP-Adresse verrät Ihnen entweder ipconfig oder zur Not die Bildschirmausgabe beim Booten des Raspbian-Systems.

Listing 8

$ echo '<?php phpinfo();?>' | sudo tee -a /var/www/phpinfo.php

 

Skripte und Cronjobs

Zum Abschluss gilt es nun, das Zusammenspiel aller Komponenten zu orchestrieren. Die Arbeit übernehmen einige durch Cronjobs getriggerte PHP-Skripte, die Sie auf der Heft-DVD finden und von dort nach/var/www/ kopieren. Alternativ holen Sie sich die Skripte per wget aus unserem Download-Bereich und entpacken sie direkt in das Datenverzeichnis des Webservers (Listing 9).

Listing 9

$ wget ftp://ftp.raspi-geek.de/2014/05/raspi-greenhouse.tar.gz
$ sudo tar xzf raspi-greenhouse.tar.gz -C /var/www/
$ sudo www-data:www-dara /var/www/*.php

Die von uns entwickelten Skripte umfassen sensor.php, das jede Minute die Sensordaten ausliest und in die Datenbank schreibt. Ein zweiter Cronjob ruft alle fünf Minuten luefter.php zum Steuern der am Dach angebrachten Lüfter auf.

Der Algorithmus arbeitet nach einer recht einfachen Logik: Erreicht die Temperatur im Glashaus einen im Skript definierten maximalen Wert, starten die Lüfter auf Minimaldrehzahl. Liegt die Temperatur beim nächsten Durchlauf des Skripts immer noch zu hoch, steigern wir die Drehzahl der Lüfter. Sobald die Temperatur den unteren Grenzwert unterschreitet, stoppen wir die Lüfter komplett: Das Gewächshaus soll ja nicht unnötig auskühlen.

In luefter.php tragen Sie die PWM-Werte ein, die Sie zuvor beim Test der Lüfter ermittelt haben. Auch die kritische Temperatur, ab der die Lüfter anlaufen sollen, müssen Sie an die lokalen Gegebenheiten anpassen.

Damit die Pflanzen nicht verdursten, sorgen zwei weitere Cronjobs und die damit verbundenen Skripte für eine regelmäßige Bewässerung. Das allabendliche Ausführen von pumpean.php startet die Pumpe,pumpeaus.php stellt sie nach ein paar Minuten wieder ab. Damit unsere Greenhouse-IT nicht einfach nur stumm vor sich hin werkelt, bietet Ihnen die index.php eine Übersicht der aktuellen Klimadaten des Gewächshauses sowie eine kleine Historie mit den Daten des Vortags an.

Für Letzteres startet jede Nacht history.php durch einen letzten Cronjob. Das Skript schreibt für jede Stunde einen gemittelten Datensatz in die Datenbanktabelle history. Danach löscht es die ursprünglich minütlich gesammelten Daten. Dieses Verfahren reduziert das Datenaufkommen pro Sensor und Tag von 1440 auf 24 Datensätze, um den Speicherplatz im RasPi nicht zu überfluten.

Die genannten Cronjobs tragen Sie am besten gesammelt als raspi-greenhouse-cron unter /etc/cron.dein. Listing 10 lädt das Cron-Skript aus dem Netz, schiebt die Datei in den richtigen Ordner und macht sie ausführbar. Passen Sie die Schaltzeiten der Pumpe bitte an die Bedürfnisse Ihrer Pflanzen an. Die Wikipedia erklärt Ihnen sehr gut die Syntax eines Cronjobs [4].

Ein wenig eleganter wäre es, nicht für jeden Aufruf Root-Rechte zu nutzen, da nur loldht eine erhöhte Berechtigung erfordert. Diese Vereinfachung sei uns aber aufgrund der geringen Sicherheitsanforderungen an eine Gewächshaussteuerung vergeben.

Listing 10

$ wget ftp://ftp.raspi-geek.de/2014/05/raspi-greenhouse-cron
$ sudo mv raspi-greenhouse-cron /etc/cron.d
$ sudo chmod +x /etc/cron.d/raspi-greenhouse-cron

Ausblick

Nachdem nun Hard- und Software harmonieren und unser Raspberry Pi seinen grünen Daumen beweisen darf, machen wir uns Gedanken, in welche Richtung wir unser RasPi-Gartenhaus weiterentwickeln.

So ließe sich die Statusseite noch ein wenig schicker und informativer gestalten. Sicherlich wäre es auch keine schlechte Idee, die Drehzahl der Motoren zu überwachen und eine Warnung zu generieren, falls einer der Lüfter ausfällt. Eine Webcam könnte das Wachsen der Pflanzen von Tag zu Tag im Bild festhalten.

Ob wir den RasPi dazu bringen, Unkraut zu jäten und Schnecken zu jagen? Wer weiß – vielleicht fällt uns auch dazu etwas ein.

Infos

  1. DHT22: http://www.adafruit.com/products/385
  2. Wiring Pi: http://wiringpi.com
  3. DHT22/AM2302-Treiber: https://github.com/technion/lol_dht22
  4. Cronjobs erklärt: http://de.wikipedia.org/wiki/Cron
  5. Datenblatt TSR 1-2450: http://www.tracopower.com/datasheet_g/tsr1-d.pdf

 

http://www.raspberry-pi-geek.de/Magazin/2014/05/Gewaechshaus-mit-dem-Raspberry-Pi-automatisieren


Links e-Schrott

Datum: 5. Mai / 2016

https://reset.org/act/elektroschrott-zu-wertvoll-fuer-die-tonne

https://reset.org/knowledge/elektroschrott-e-waste

 

https://de.ifixit.com/

 

https://reset.org/wissen/cradle-cradle-recycling-rund-gemacht