Ein Gastbeitrag von Torsten Dillenburg

Als Papa eines kleinen Jungen muss man ja viel mitmachen. Ständig klaut der Sohn einem das iPad, um The Big Bang Theory zu schauen, oder er verstellt am iMac die Auflösung. Und letztens hat dann mein geliebter Filius die Küche für sich endeckt. War ja auch klar. 1. kommt da das lecker Essen her und 2. gibt es dort viele Knöpfe zu drücken. Zum Glück hat der Induktionsherd eine Kindersicherung! Aber den Tiefkühlschrank hat’s erwischt…

Ein vernünftiger Dreijähriger muss natürlich auf den leuchtend grünen Knopf drücken:

Und außerdem die Tür öffnen (diese Kraft, erstaunlich). Leider funktioniert der Temperaturalarm nur dann, wenn der Tiefkühlschrank auch eingeschaltet ist. Zugegeben, das musste ja alles mal abgetaut werden, aber doch nicht so!

Nachdem die letzten Fischstäbchen ihr Seepferdchen gemacht hatten, der Rest an brauchbaren Nahrungsmitteln verputzt und die Küche wieder trocken gelegt war stand für mich fest: Das geht so nicht weiter!

Was man zur Risikominimierung braucht

• ein Raspberry Pi Model B
• eine SD Karte (mindestens Class 10 mit 8GB)
• einen DS18B20-Temperatursensor
• einen 4,7k Ohm-Widerstand
• eine USB Tastatur
• ein Display mit HDMI oder einen DVI-Adapter für den Monitor
• ein USB-Netzteil mit 5v und 2a
• ein Micro-USB-Kabel

Optional:

• ein Breadboard mit Kabelset zum schnellen Zsammenstecken der Komponenten
• einen Adafruit Pi T-Cobbler
• einen USB-WLAN-Adapter (falls es in eurer Küche kein 100baseT Ethernet gibt)

Vorbereiten des Raspberry Pi

Wenn man alle Teile beisammen hat, geht es mit etwas Einfachem los: Das Raspberry Pi benötigt ein Betriebssystem.

Neben der offiziellen Distribution gibt es auch einige andere interessante Pakete. Ich habe mich für die Occidentalis Distrubition von adafruit entschieden. Nach dem Download müssen die Daten nur noch auf die SD-Karte für das Pi geschrieben werden.

Einspielen der Distribution

Auf dem Mac ist die Installation recht unkompliziert. Noch einfacher geht es allerdings mit dem Raspberry-PI-SD-Installer für OS X. Zunächst die ZIP-Datei von Github runterladen und dann entpacken:

Dann legen wir im Ordner noch die Image Datei der Distribution ab.

Wenn alle Downloads abgeschlossen sind geht es ins Terminal.

Erst einmal wechseln wir mit cd in unseren Ordner. Dann starten wir mit sudo ./install Occidentalis_v02.img das kleine Programm. Nach der Eingabe des Passworts werden wir von einer kleinen Übersicht über alle unsere Laufwerke begrüßt. Nun müssen wir nur unsere SD Karte auswählen.

Dann schauen wir doch erst noch mal nach der Nummer! Und geben sie ein, wenn wir sicher sind. Anschließend gibt’s zur Belohung einen Kaffee, den wir trinken, während die SD-Karte für den Start vorbereitet wird.

Der erste Start des Raspberry Pi

Nun aber ab an den Monitor, Pi anschließen und los geht’s.

Wenn die ersten Einstellungen gemacht sind, kann es weiter gehen.

Nach dem Starten werden wir ganz freundlich von der Raspi-Config begrüßt. Dort können wir nun das Keyboard-Layout und die Zeit einstellen.

Aufbau der Schaltung

Der DS18B20 (Datenblatt) ist relativ leicht an das Raspberry Pi an zu schließen. Ausgelesen wird der Sensor über den 1-Wire-Bus. Aber nicht vom Namen täuschen lassen! Wir brauchen hier drei Pins. Wenn der Sensor mit der flachen Seite zu uns auf dem Tisch liegt, sind die Beinchen von links nach rechts mit 1) Masse, 2) Signal und 3) Plus belegt. Für die ersten Tests kann man die Schaltung super auf einem Breadboard zusammenstecken. Für den Kühlschrank ist aber doch eine längere Leitung nötig. Ich habe dazu den Sensor mit einem Flachbandkabel verlötet und anschließend an Ort und Stelle deponiert.

Auslesen des Temperatur

Nachdem wir den kleinen, unschuldigen DS18B20 unter Strom gesetzt haben, müssen wir ihn nur noch davon überzeugen, mit uns zu reden. Zum Glück kann das Raspberry ja schon 1-Wire, das macht unsere Leben doch entschieden leichter.

Wir melden uns per SSH auf der Konsole an und laden die Kernel-Module. Das geht mit:

sudo modprobe w1-gpio
sudo modprobe w1-therm

Mit #1 laden wir das Modul für die IO-Verbindung, mit #2 das Modul zum Auslesen der Temperatur. Nun müssen wir uns im Filesystem nach dem IO-Stream des Sensors umsehen. Unter /sys/bus/w1/devices lassen wir uns nun mit ls alle 1-Wire Devices, jedes mit seiner ID, anzeigen.

Dann ab in den Ordner. Dort finden wir nun die Daten, die wir brauchen. Genauer gesagt den IO-Stream, der über das 1-Wire-Interface vom DS18B20 kommt. Mit more w1_slave können wir uns die Daten anzeigen lassen. Und siehe da, in der zweiten Zeile steht die Temperatur:

Verarbeiten der Daten

Nun haben wir die Temperatur schon mal im Pi, aber sich jedes Mal durch das Terminal wühlen ist schon nervig. Das geht auch einfacher. Mit Python.

Wir starten in der Shell mit python die Python-Konsole und geben Folgendes ein:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Oeffne den IO-Stream des DS18b20
tfile = open("/sys/bus/w1/devices/28-0000039a01b9/  w1_slave") 
# Den ganzen Text auslesen
text = tfile.read() 
# IO-Stream schliessen
tfile.close() 
# 2. Zeile lesen 
zeileZwei = text.split("\n")[1] 
# bei den Leerzeichen in Woerter teilen und das 10. Wort (angefangen bei Null) lesen 
temperaturdata = zeileZwei.split(" ")[9] 
# das "t=" verwerfen,  um eine Zahl zu erhalten
temperatur = float(temperaturdata[2:]) 
# durch Tausend teilen, um das Komma zu setzen 
temperatur = temperatur / 1000 
print temperatur

Dann Enter und ab dafür. Und siehe da, eine Temperatur:

Natürlich kann man das ganze auch in einen kleine Datei speichern und diese dann direkt Python zum Ausführen Vorsetzen:

Ab in die Wolke

So, nun haben wir ja die Temperatur schön ausgelesen. Aber immer nachschauen ist irgendwie blöd. Und es könnte ja auch schön bunt sein oder? Da gibt es eine Lösung:

Cosm ist aus dem Cloud-Dienst Pachube hervorgegangen und bietet Privatleuten einen Platz für die eigenen Sensordaten. Das Schöne am Dienst ist, dass es viele Anleitungen für die Einbindung der entsprechenden Geräte gibt.

Für Python bietet sich das Package eeml von Peter Vizi an. Mit diesem Package kann man mit wenigen Zeilen Code seine Daten an cosm senden.

Um das Package auf unserem Raspberry Pi zu installieren melden wir uns wieder auf der Konsole an. Dort laden wir mit

wget -O geekman-python-eeml.tar.gz https://github.com/geekman/python-eeml/tarball/master

die aktuelle Version herunter. Sobald der Download abgeschlossen ist, wird das Archiv mit

tar zxvf geekman-python-eeml.tar.gz

entpackt. Dann wechseln wir mit

cd geekman-python-eeml*

in das entstandene Verzeichnis und fügen dort mittels

sudo python setup.py install

das Package unserer Python-Installation hinzu.

Als nächsten müssen wir uns nur noch unter www.cosm.com uns ein neues Konto anlegen. Und dort die notwendigen Daten eintragen:

Sobald das geschafft ist, geht es daran einen Feed für unsere Daten einzurichten. Dazu nehmen wir die Quelle “Arduino”.

Nun noch einen Namen auswählen und evtl. ein paar Tags setzen.

Nach dem letzten Schritt gelangen wir zu einer Übersichtsseite. Dort wird neben der Feed-ID auch ein kleines Besipielprogramm angezeigt. In diesem ist bereits ein API-Key gesetzt. Beide Werte kopieren – die brauchen wir später.

Nun müssen wir unser Skript von eben noch etwas ergänzen. Zum einen benötigen wir die Packages time, os und eeml. Diese binden wir über import ein. Das #!/usr/bin/env python benötigen wir, um das Skript später direkt aus der Shell zu starten. Dann fügen wir noch ein paar Variabeln, den API-Key und die Feed-ID mit ein. Und zu guter Letzt packen wir unser Skript in eine Funktion und übermitteln via Hauptprogramm die Daten an cosm. Zum Schluss sieht das Ganze so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#!/usr/bin/env python
import time
import os
import eeml
 
DEBUG = 1  # wenn 1, wird die Temperatur in der Shell angezeigt
LOGGER = 1 #
 
# COSM-Variablen; der API-Key und die FEED-ID koennen auf der COSM-Seite ausgelesen werden 
 
API_KEY = '8uFh1c7c3X3lZJsHs7Fv6a3elwmSAKxjbHJuYlJiQXE1ND0g'
FEED = 120737
API_URL = '/v2/feeds/{feednum}.xml' .format(feednum = FEED)
 
# unsere bekannte Funktion aus dem ersten Teil
def leseTemp():
        # oeffne den IO-Stream des DS18b20; bitte hier den Pfad zu eurem Sensor eingeben
        tfile = open("/sys/bus/w1/devices/28-0000039a01b9/w1_slave") 
        # den ganzen Text auslesen
        text = tfile.read() 
        # io-Stream schliessen
        tfile.close() 
        # 2. Zeile lesen
        zeileZwei = text.split("\n")[1] 
        # bei den Leerzeichen in Woerter teilen und das zehnte Wort (angefangen bei Null) lesen 
        temperaturdata = zeileZwei.split(" ")[9] 
        # das "t=" verwerfen, um eine Zahl zu erhalten
        temperatur = float(temperaturdata[2:]) 
        # durch Tausend teilen, um das Komma zu setzen 
        temperatur = temperatur / 1000 
        #print temperatur
        return temperatur
 
# Hauptprogramm
 
# Kernelmodule laden, sicher ist sicher...
os.system("sudo modprobe w1-gpio")
os.system("sudo modprobe w1-therm")
 
# Sensor auslesen  
temp0 = leseTemp()
if DEBUG:
        print "temp0:\t", temp0
        print
 
if LOGGER:
        # Feed oeffnen
        cosm = eeml.Pachube(API_URL, API_KEY)
        #Sagen wir mal Bescheid, dass da Celsius kommt
        cosm.update([eeml.Data(0, temp0, unit=eeml.Celsius())])
        # Daten uebertragen
        cosm.put()

Wir speichern das Programm in einer Datei, z.B. Thermo.py, die wir dann in der Shell mit chmod +x als ausführbar kennzeichnen. Das Skript starten wir schließlich mit sudo ./Temp.py.

Und schon haben wir unseren ersten Feed…

Nun müssen wir nur noch unsere Benachrichtigung per Twitter einbauen. Das geht ohne weiteren Code direkt auf der cosm-Seite. Dazu gehen wir auf den neuen Feed, klicken auf +Trigger und wählen Twitter:

Dann geben wir einen Schwellwert für den Trigger an:

und verknüpfen unser Twitter Konto mit dem Feed:

Ergebnis

Nun ist unser Tiefkühlschrank an Twitter angeschlossen! Auf cosm können wir die Daten einsehen und mittels Ifttt auch weiter auswerten. Auf dem gleichen Weg können wir auch noch weitere Sensoren anschließen und auswerten.

Oben sieht man die aktuelle Temperaturkurve. Bei meinem Kühltruhenprojekt habe ich das Kabel recht kurz gehalten, der Sensor liegt kurz hinter der Tür. So bekommt man immer schön mit, wenn die Tür aufgeht (sieht man oben an den Spitzen). Wer stabilere Messwerte möchte, sollte den Sensor möglichst in der Mitte positionieren.

One more thing

Bis jetzt liefert unser Skript immer nur ein Update zu cosm aus. Aber wenn wir ehrlich sind, macht eine automatische Benachrichtigung per Tweet nur halb soviel Spaß, wenn man immer manuell cosm aktualisieren muss. Daher legen wir auf dem Raspberry nun noch einen Cron Job an.

Das geht auch wieder mit der Shell. Wir öffnen mit

sudo crontab -e

den Editor für die Cronacle Tabelle ein und fügen am Ende die Zeile

*/5 * * * * sudo /home/pi/Temp.py

hinzu. Nun wird der Job alle 5 Minuten der Job ausgeführt.

Den Editor verlassen wir dann mit STRG+X und bestätigen die Änderungen mit j.

Weiterhin viel Spaß mit dem Raspberry Pi – der Modelleisenbahn des 21. Jahrhunderts!