DesignSpark Electrical Logolinkedin
Menu Suche
Ask a Question

Heimautomation mit Raspberry Pi 2 und Node-RED

Node-RED ist ein visuelles Tool für die Verkabelung des Internets der Dinge. Das Tool kann auf einem Raspberry Pi betrieben werden und ermöglicht das schnelle Erstellen von Prototypen für Projekte. In diesem Tutorial richten wir Node-RED zunächst auf einem Raspberry Pi 2 ein, um anschließend einen Ablauf zu entwickeln, der einen Temperatursensor ausliest und eine LightwaveRF-Netzsteckdose steuert.

title

Wir gehen davon aus, dass Ihr Pi bereits im Netzwerk eingerichtet ist und dass Sie per SSH darauf zugreifen können. 
Stellen Sie sicher, dass Sie über eine aktuelle Distribution verfügen:

$ sudo rpi-update

$ sudo reboot

Warten Sie, bis der Pi neu startet, melden Sie sich wieder an und führen Sie folgenden Befehl aus:

$ sudo apt-get update
$ sudo apt-get upgrade

Hardware

Wir werden die folgende Hardware verwenden:

Schließen Sie die Hardware an, wie im Diagramm unten gezeigt:

title

Hier schließen wir den Temperatursensor und den Funksender an den Raspberry Pi an. Stellen Sie sicher, dass alle Elemente mit Strom versorgt werden, geerdet sind, über eine Datenverbindung verfügen und an die richtigen Verbindungsstifte der GPIO-Stiftleiste des Pi angeschlossen sind. Stellen Sie außerdem sicher, dass auch der Antennendraht an das Drahtlosmodul angeschlossen ist.

LightwaveRF-Steuerung einrichten

Damit wir die Drahtlos-Netzsteckdose steuern können, müssen wir „wiringPi“ und „lightwaverf-pi“ installieren. Fangen wir mit wiringPi an:

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

Jetzt wird getestet, ob wiringPi korrekt installiert ist:

$ gpio -v
$ gpio readall

title

Als Nächstes wird lightwaverf-pi installiert:

$ git clone https://github.com/leachj/lightwaverf-pi.git
$ cd lightwaverf-pi
$ make
$ sudo make install

title

Führen Sie den Testsendebefehl aus:
$ sudo ./send 0
Die Ausführung sollte fehlerfrei erfolgen. Im nächsten Schritt prüfen wir die drahtlose Steuerung, indem wir versuchen, Pi und Netzsteckdose miteinander zu koppeln:
Stecken Sie die Netzsteckdose ein und schalten Sie sie in den Kopplungsmodus, indem Sie die Taste an der Seite gedrückt halten, bis die Kontrollleuchte orange/blau zu blinken beginnt. Übermitteln Sie als Nächstes ein EIN-Signal:
$ sudo ./send 1

Jetzt sollte die Steckdose mit dem Pi gekoppelt werden. Die Kontrollleuchte blinkt jetzt schneller und zeigt damit den erfolgreichen Abschluss an. Jetzt können Sie die Steckdose ein- und ausschalten, indem Sie die folgenden Befehle verwenden:
$ sudo ./send 1
$ sudo ./send 0

Node-RED installieren

Zunächst installieren wir Node.js (beachten Sie, dass dieser Prozess beim Pi 2 anders abläuft als bei früheren Pi-Platinen):

$ curl -sL https://deb.nodesource.com/setup | sudo bash -
$ sudo apt-get install -y build-essential python-dev python-rpi.gpio nodejs

Als Nächstes wird Node-RED installiert:
$ sudo npm install -g node-red

Starten Sie Node-RED:

$ node-red-pi --max-old-space-size=128

Damit wird der Node-RED-Server auf dem Pi gestartet. Öffnen Sie einen neuen Browser Tab und navigieren Sie zur IP-Adresse Ihres Pi, Port 1880. Daraufhin sollte die Node-RED-Umgebung geladen werden und einsatzbereit zur Verfügung stehen.

title

Jetzt werden wir einen neuen Knoten hinzufügen, um uns den Temperatursensor DS18B20 im Rahmen von Node-RED zunutze zu machen. Zwei Kernel-Module werden für den ordnungsgemäßen Betrieb benötigt. Diese Module laden wir als erste:

$ sudo modprobe w1-gpio
$ sudo modprobe w1-therm

Zwar ist es relativ einfach, diese Module von Hand zu laden, aber wir werden sie so konfigurieren, dass sie beim Hochfahren automatisch geladen werden. Dafür bearbeiten wir die Datei „/etc/modules“:

$ sudo nano /etc/modules

indem wir die Namen der Module jeweils in einer eigenen Zeile hinzufügen:

title

Jetzt installieren wir einen Knoten, um Daten vom Modul DS18B20 einzulesen:

$ cd /usr/lib/node_modules/node-red
$ sudo npm install node-red-contrib-ds18b20 --save

Im nächsten Schritt fügen wir der Datei „/boot/config.txt“ eine Zeile hinzu:

$ sudo nano /boot/config.txt

Fügen Sie am Ende der Datei die folgende Zeile ein:

dtoverlay=w1-gpio,gpiopin=4

Speichern und schließen Sie die Datei. Führen Sie anschließend einen Neustart durch und melden Sie sich wieder bei Ihrem Pi an.
Als Nächstes prüfen wir, ob der Temperatursensor ordnungsgemäß mit dem Pi verbunden ist und ob Daten abgerufen werden können:

$ cd /sys/bus/w1/devices
$ ls

title

Sie sollten in etwa die obige Meldung zu sehen bekommen. Der Sensor wird hier als 28-000006439bd5 angezeigt. Wechseln Sie ins Verzeichnis des Sensors:

$ cd 
z. B.
$ cd 28-000006439bd5

Der Sensor schreibt Daten in die Datei „w1_slave“. In diese Datei können wir hineinschauen, um festzustellen, ob irgendwelche Daten vorhanden sind:

$ cat w1_slave

Es sollten zwei Zeilen angezeigt werden. Wenn ja, ist der Sensor mit dem Pi verbunden und übermittelt ihm Daten.

Einen Node-RED-Ablauf erstellen

Überprüfen Sie, ob der Sensorknoten korrekt installiert ist, damit wir innerhalb von Node-RED auf unsere Temperaturdaten zugreifen können:

$ node-red-pi

title

Öffnen Sie Ihren Webbrowser und navigieren Sie zur IP-Adresse Ihres Pi, Port 1880. Der neue Knoten „ds18b20“ sollte ziemlich weit unten im linken Menü angezeigt werden. Ziehen Sie den Knoten in den Arbeitsbereich. Wir müssen den Knoten konfigurieren und ihm sagen, welche Sensor-ID zu verwenden ist. Dafür klicken wir zunächst doppelt auf den Knoten, um ein Fenster zum Bearbeiten zu öffnen. Die Geräte-ID sollten Sie auf der ersten Dropdown-Registerkarte auswählen können. Beachten Sie, dass Sie auch das Zeitintervall zwischen den Temperaturauslesungen ändern können – vorgegeben ist eine Minute. Sie müssen warten, bis das Zeitintervall abgelaufen ist, bevor die erste Nachricht in der Debug-Konsole eintrifft. Aus diesem Grund möchten Sie das Intervall während der Testphase möglicherweise auf 0,1 absenken. 

Ziehen Sie einen debug-Knoten in den Arbeitsbereich und verbinden Sie die beiden Knoten miteinander. Wenn im Rahmen des Node-RED-Arbeitsbereichs mehrere Knoten miteinander verbunden sind, sprechen wir von einem Ablauf (Flow). Bevor der Ablauf auf dem Server aktiv werden kann, müssen wir ihn zunächst bereitstellen. Klicken Sie auf die Schaltfläche „Deploy“ (Bereitstellen) rechts oben im Arbeitsbereich, um den Ablauf bereitzustellen. Wenn Sie irgendwelche Änderungen vornehmen, müssen sie die Bereitstellung wiederholen, damit die Änderungen im Ablauf auf dem Server wirksam werden.

title

Nachdem wir jetzt einen grundlegenden Ablauf unter Verwendung des Sensors geprüft haben, können wir einen komplexeren Ablauf entwickeln, der Folgendes leisten wird:

  • Temperatur vom Sensor auslesen
  • Entscheiden, ob es kalt genug ist, um die Steckdose (für die Heizung) einzuschalten
  • Entscheiden, ob es der richtige Tag ist, um die Steckdose einzuschalten
  • Entscheiden, ob es die richtige Tageszeit ist, um die Steckdose einzuschalten
  • Die Steckdose ein- oder ausschalten

Zum Lieferumfang von Node-RED gehören zahlreiche nützliche Knoten. Einer der davon ist der debug-Knoten, den wir oben bereits verwendet haben. Außerdem werden wir den inject-Knoten (Einspeisen) verwenden, der uns beim Testen hilft. Damit haben wir die Möglichkeit, Nachrichten-Nutzdaten zu senden, indem wir einfach auf eine Schaltfläche des Knotens klicken. Das bedeutet, Sie müssen nicht auf zeitabhängige Daten warten, um Ihren Code zu testen. 

Wir werden einen Funktionsknoten einsetzen, um unsere Logik für die Entscheidung zu implementieren, ob die Steckdose ein- oder ausgeschaltet werden soll. 

Schließlich verwenden wir auch den exec-Knoten (Ausführen), der uns die Möglichkeit verschafft, aus Node-RED heraus Shell-Befehle ausführen zu lassen. Diesen Knoten werden wir verwenden, um den Sendebefehl auszuführen, den wir bereits für die Steuerung der Drahtlos-Steckdose benutzt haben. 

Ziehen Sie einen exec-Knoten in den Arbeitsbereich und klicken Sie ihn doppelt an, damit das Bearbeitungsfenster geöffnet wird. Tragen Sie Folgendes in das Feld „Command“ (Befehl) ein: 

sudo //send 
z. B.
sudo /home/pi/SW/lightwaverf-pi/send

title

Tragen Sie Text in das Feld „Name“ ein (wir haben „switchExec“ verwendet). Wenn Sie Ihre Knoten benennen, hilft das der Lesbarkeit, besonders bei umfangreicheren und komplexeren Abläufen. Dieser exec-Knoten wird jetzt jedes Mal, wenn der Knoten eine eingehende Nachricht verzeichnet, versuchen, den festgelegten Befehl auszuführen. Wir können die zusätzlichen Befehlsargumente mit den Nachrichten-Nutzdaten senden. Beachten Sie, dass unser Befehl nicht wie zuvor ein Argument „0“ oder „1“ enthält. Der Grund dafür ist, dass wir diese Argumente in unserem Ablauf an den exec-Knoten übermitteln werden.

Nachher werden wir dafür sorgen, dass unser Funktionsknoten diese Aufgabe übernimmt, aber vorerst können wir inject-Knoten verwenden, um festzustellen, ob der exec-Knoten ordnungsgemäß funktioniert. Ziehen Sie zwei inject-Knoten in den Arbeitsbereich. Doppelklicken Sie nacheinander auf beide, um jeweils sicherzustellen, dass der „Payload“-Typ (Nutzdaten) „string“ (Zeichenkette) ist und dass einer eine 0 und der andere eine 1 im Feld „Payload“ enthält. 

Verbinden Sie den Ausgang beider inject-Knoten mit dem exec-Knoten und den exec-Ausgang oben mit dem debug-Knoten und führen Sie den Ablauf aus. Wenn Sie jetzt auf die Schaltfläche eines der inject-Knoten klicken, sollte zu sehen sein, dass der exec-Knoten in der Debug-Konsole die Meldung „sending command“ (Befehl wird gesendet) schreibt. Sie sollten ebenfalls feststellen können, dass Ihre Netzsteckdose entsprechend Ihrer Klicks ein- bzw. ausgeschaltet wird. Beachten Sie, dass sie die Steckdose möglichst nicht in schneller Folge ein- und ausschalten sollten, weil das zu Schäden führen könnte. 

Nachdem jetzt die Drahtlossteuerung funktioniert, können wir unseren Ablauf ausbauen und unserem Funktionsknoten eigenen Code hinzufügen. Ziehen Sie einen Funktionsknoten (function) in den Arbeitsbereich und verkabeln Sie alles, wie unten angezeigt.

Doppelklicken Sie auf Ihren Funktionsknoten und fügen Sie folgenden Code ein:

//Netzsteckdosensteuerung nach Tag, Uhrzeit und Temperatur

//create date object
var d = new Date();
var day = d.getDay();
var hour = d.getHours();
var DAY = day;
var HOUR = hour;

//Zeile für die Aufnahme von Zahlen zu Testzwecken
//var day = parseInt(msg.payload);

// Wert für var DAY je nach Tag auf 0 oder 1 setzen – wir wollen Montag bis Freitag:
if (day >= 1 && day <= 5) {
  DAY = 1;
}
else{
DAY = 0;
}

// Wert für var HOUR je nach Uhrzeit auf 0 oder 1 ändern – wir wollen 0700–1800
if (hour >= 7 && hour <= 17) {
  HOUR = 1;
}
else{
HOUR = 0;
}

// Nutzdaten als 0 oder 1 je nach HOUR, DAY sowie temp/msg.payload festlegen – wir wollen Tag/Uhrzeit wie oben aufgeführt und eine Temperatureinstellung von 23 Grad Celsius
if (HOUR == 1 && DAY == 1 && msg.payload <= 23) {
  msg.payload = 1;
}
else{
msg.payload = 0;
}

return msg;



title

Stellen Sie den Ablauf bereit. Jetzt verfügen Sie über eine Netzsteckdose, die je nach der von Ihrem Pi gelesenen Temperatur ein- und ausgeschaltet wird. Eine letzte Sache wollen wir jetzt noch tun, nämlich Node-RED so konfigurieren, dass es beim Start ausgeführt wird. Dafür verwenden wir PM2 – einen Prozessmanager für Node.js:

$ sudo npm install -g pm2

Stellen Sie fest, wo auf Ihrem Pi „node-red“ installiert ist:

$ which node-red
$ pm2 start /node-red --node-args="max-old-space-size=128" -- -v

Damit wird Node-RED im Hintergrund gestartet.

title

Sie können den Status von PM2 mithilfe verschiedener Methoden überprüfen:

$ pm2 status
$ pm2 info node-red
$ pm2 logs node-red

Legen Sie jetzt fest, dass PM2 beim Hochfahren gestartet werden soll:

$ pm2 startup

Starten Sie neu und überprüfen Sie, ob alles funktioniert. Node-RED sollte gemäß der Konfiguration starten und den Ablauf ausführen.

Der Funktionsknoten kann nach Ihren Maßgaben geändert werden. Experimentieren Sie ruhig mit verschiedenen Werten oder unterschiedlichen Bedingungen. Es gibt auch weitere Ausgabeknoten, die Sie einfach hinzufügen könnten, zum Beispiel einen Twitter-Knoten, den Sie verwenden könnten, um sich benachrichtigen zu lassen, wenn eine Steckdose ein- oder ausgeschaltet wird.

maker, hacker, doer

13 Mar 2015, 11:07

Kommentare