Wohlfühl-Ambiente mit Luftgütemessung

Mit Philips-Hue-Lampen kann man seine Wohnung für jeden Anlass stimmungsvoll beleuchten. Davon abgesehen eignen sich die Lampen mit ihren Millionen möglicher Leuchtfarben aber auch gut zur Visualisierung von Messwerten und Signalen, was wir anhand eines CO2-Sensors exemplarisch zeigen wollen.

von Markus Ulsaß

Fortgeschrittene Anwendung von Node-RED

Im ersten Teil dieses Artikels haben wir auf Seite 56 beschrieben, wie Sie einen Server mit Node.js einrichten und mit Node-RED Programme erstellen können. Zur Demonstration wurde der Status einer Philips-Hue-Leuchte abgefragt. Nur den Status einer Lampe auszulesen ist natürlich langweilig. Wie wäre es, wenn wir in Zukunft die Lampe per Farbänderung oder Aufblinken bestimmte Signale aussenden lassen, beispielsweise wenn wir eine Direktnachricht bei Twitter bekommen haben oder der Wert eines Sensors eine Schwelle überschreitet?

1 Alten Flow weiter nutzen

Wir bauen uns zunächst in den gleichen Flow, den wir im ersten Teil benutzt haben, einen weiteren inject- und debug-Node ein. Dazwischen kommt diesmal aber ein hue set-Node und links davor noch ein template-Node, den wir schon in unserem Hello World Server-Beispiel verwendet haben. Er dient dazu, ein JSON-Paket an die Lampe zu schicken. Die Nodes inject und hue set konfigurieren wir wie beim Status-Flow, dem Node debug geben wir den Namen „NodeLamp set on“. Beim template-Node geben wir

{

"on" : true

}

in das Template-Fenster ein und vergeben den Namen „Lamp on“. Außerdem können wir bei Syntax-Highlight „JSON“ im Drop-Down-Menü auswählen, was das Auffinden von Fehlern in größeren JSON-Konstrukten erleichtert. Dieses simple JSON Key/Value-Pair schaltet die Lampe ein.

2 Lampe ein- und ausschalten

Danach kopieren wir den ganzen hue set-Flow, indem wir alle Nodes mit der Maus auswählen (die Nodes bekommen dabei einen orangenen Rahmen und ein gestricheltes Rechteck erscheint um die ausgewählten Nodes), mit STRG+C kopieren und mit STRG+V darunter einsetzen.

Wir ändern den Namen des Node template in „Lamp off“ und das JSON-Konstrukt in

{

"on" : false

}

Den Namen des debug-Node ändern wir in „NodeLamp Set off“. Wir drücken den Deploy-Button und aktivieren alle drei Flows. An diesem Beispiel kann man gut sehen, dass in einem Flow die einzelnen „Unter“-Flows nebeneinander existieren können, ohne miteinander verbunden zu sein.

Durch das Drücken des linken Reiters am Node der beiden neu erzeugten inject-Nodes können wir die Lampe jetzt ein- und ausschalten und uns mit dem Status-Flow den aktuellen Zustand der Lampe anzeigen lassen.

3 Werte abfragen

Hier zeigen sich auch die Stärken dieses Systems, das auf der JavaScript-Umgebung aufbaut. Durch das einfache Verändern des Outputs des debug-Node im Status-Flow auf „msg.payload.state.on“ können wir direkt den Wert aus dem entsprechenden Key/Value-Pair auslesen. Im Falle einer ausgeschalteten Lampe bekommen wir für diese Payload dann den Wert „false“ als Ausgabe im Fenster Debug. So lassen sich aus einem anderen Flow oder einem anderen Node leicht direkt der Zustand oder alle anderen erhältlichen Werte der Lampe abfragen.

4 Konfigurations-Node

Eine Besonderheit ist bei der hueplus-Bibliothek der Konfigurations-Node, den wir uns mit einem Klick auf das Menü-Icon am oberen rechten Rand und dann durch Auswählen von View/Configuration nodes anzeigen lassen können. Im rechten Fenster erscheint dann ein neuer Karteikartenreiter, in dem die globalen und lokalen Konfigurations-Nodes eingesehen werden können. Ein Doppelklick öffnet die Einstellungen. Die Zahl rechts neben dem Symbol für den Konfigurations-Node zeigt, wie viele Nodes mit ihm verknüpft sind.

Twitter kontrolliert Hue

Eine Lampe manuell über einen Node-RED Flow an- und auszuschalten ist natürlich keine Zauberei – auch wenn wir das mit nur sehr wenig selber geschriebenem Code realisiert haben. Richtig interessant wird es aber, wenn wir diesen Vorgang automatisieren und bestimmte Ereignisse per Lichtsignal anzeigen lassen.

1 Nodes für Twitter

In der Kategorie social finden wir zwei Twitter-Nodes. Einen, um Tweets zu durchsuchen (Input) und einen, um selber etwas zu twittern (Output).

2 Neuer Flow – neues Fenster

Der neue Flow soll ein neues Fenster bekommen, was wir mit einem Klick auf das Plus-Symbol am oberen rechten Rand des mittleren Fensters erzeugen.

3 Twitter-Node konfigurieren

Wir ziehen dann den Twitter-Input-Node in den Flow-Designer (das mittlere Fenster) und doppelklicken auf das Symbol für den Node, um Einstellungen dafür vorzunehmen.

4 Einstellungen bei Twitter

Wir klicken auf den Stift rechts neben dem Feld Twitter ID und werden nach dem Bestätigen des Authenticate-Buttons im nächsten Fenster zu Twitter weitergeleitet. Dort müssen wir Node-RED autorisieren, auf unseren Twitter-Account zuzugreifen und fügen mit Add diese Autorisierung dem Einstellungsfenster hinzu. Im Feld Search wählen wir „the tweets of specific users“ aus und geben unter User „@heiseonline“ und durch ein Komma getrennt „@Make MagazinDE“ ein. Als Name vergeben wir „Twitter heise/Make“ und bestätigen alles mit Done.

5 Nachrichten über Debug bekommen

Wir schließen jetzt einen debug-Node an den Twitter-Input an und bekommen ab sofort alle Nachrichten der beiden Accounts im rechten Debug-Fenster angezeigt.

6 Flow kopieren

Wir wollen es aber nicht dabei belassen und kopieren uns aus dem zuvor erstellten Hue-Flow einen der beiden template- und NodeLamp-Nodes-Kombinationen (mit linker gedrückter Maustaste festhalten und die Auswahl um die beiden Nodes ziehen), kopieren sie mit Strg+C und platzieren sie mit Strg+V im neuen Twitter-Flow-Fenster.

7 Node mit Code füllen

Im Node template ersetzen wir den Inhalt mit dem folgenden Code, wodurch die Lampe angeschaltet wird („on“) und in einem dunklen „Twitter“-Blau („hue“) mit maximaler Sättigung („sat“) und Helligkeit („bri“) erscheinen lässt.

{

"on" : true,

"bri" : "254",

"hue" : "46920",

"sat" : "254"

}

8 Blau macht glücklich

Wir verbinden die beiden Nodes mit dem Twitter-Node indem wir einfach eine zweite Leitung aus dem Ausgangspunkt herausziehen. Wir veröffentlichen den Flow (Deploy) und ab sofort leuchtet die Lampe blau auf, wenn wir eine Nachricht empfangen. Allerdings nur einmal und die Lampe behält danach das Twitter-Blau als Lampenfarbe.

9 Lampe zurücksetzen

Das können wir natürlich ändern. Da wir den Node hue state haben, hängen wir diesen einfach an den Ausgang des Twitter-Inputs. Empfangen wir einen Tweet, wird der Status gesichert. Wir verzögern das Rücksetzen auf den ursprünglichen Status mit dem Node delay und bauen uns dann einen neuen Node template, der folgenden Inhalt bekommt:

{

"on" : {{payload.state.on}},

"bri" : "{{payload.state.bri}}",

"hue" : {{payload.state.hue}},

"sat" : {{payload.state.sat}},

"effect" : "{{payload.state.effect}}",

"xy" : [{{payload.state.xy}}],

"ct" : {{payload.state.ct}},

"alert" : "{{payload.state.alert}}",

"colormode" : "{{payload.state.colormode}}"

}

Diesen template-Node verbinden wir mit dem Eingang von hue set „NodeLamp“. Nach einer Verzögerung werden damit alle ursprünglichen Lampen-Einstellungen wieder hergestellt.

10 Neuen Node für Wiederholungen installieren

Nun fehlt uns noch die Wiederholung beim Aufleuchten in Blau. Mit den vorhandenen Nodes ist das nicht so einfach machbar, deswegen installieren wir einen neuen Node mit dem Namen „repeat“:

sudo npm install -g node-red-contrib-repeat

Wir müssen Node-RED beenden und neu starten, damit der neue Node repeat (Kategorie function) im Browser-Editor sichtbar wird.

11 Anzahl der Wiederholungen

Im Node repeat geben wir in den Einstellungen lediglich: Repetitions: 2 ein und verbinden den Ausgang mit dem Eingang des template-Node „Lamp Alert“ und den Eingang mit dem rechten delay-Node.

Unser Twitter-Input löst ab jetzt zwei Ereignisse aus. Im oberen Flow wird die Lampe auf ein dunkles Blau („hue“: „46920“) und dann mit einer Verzögerung von einer Sekunde auf ein helles Blau („hue“: „40000“)gesetzt, das Ganze wird zweimal (repeat-Node) wiederholt, sodass insgesamt dreimal das „Twitter-Signal“ aufleuchtet. Im unteren Flow werden zunächst die ursprünglichen Lampeneinstellungen gesichert und dann wird die Lampe mit einer Verzögerung von sieben Sekunden auf die vorherigen Werte zurückgesetzt.

CO2-Sensor MG811

Unterseite des verwendeten MG811-Moduls

Der MG811 ist ein elektrochemischer Sensor, den es sowohl als reinen Sensor als auch mit passendem Breakout-Board gibt, das ab etwa 60 Euro erhältlich ist. Wir beschränken uns hier auf ein fertiges Board mit Temperatursensor, je einem IC auf der Vorder- und einem auf der Rückseite und zwei Trimmpotis.

Der Sensor hat eine integrierte Heizquelle, die sehr genau mit 6 Volt (±0,1 V) betrieben werden muss. Er gibt den aktuellen CO₂-Anteil der Luft aus, die aufgrund einer chemischen Reaktion zur Veränderung der Spannung am analogen Ausgang führt. Diese sehr kleine Spannung (30–50 mV) muss mit einem Operationsverstärker verstärkt werden, damit der analoge Ausgang des angeschlossenen Mikrocontrollers sinnvoll damit umgehen kann. Es sind Module erhältlich, die eine Spannung von 0–2 V oder 0–4 V am analogen Ausgang ausgeben. Bei manchen Module ist dies per Jumper umschaltbar. Wir benötigen die Variante mit bis zu 2 V. Zusätzlich zum analogen Ausgang ist noch ein digitaler Ausgang (DOUT) vorhanden. Mit den Potis kann eine Schaltschwelle eingestellt werden, bei welcher der TTL-Ausgang umschaltet.

Aufgrund der Aufheizzeit der Sensor-Heizung und der erst allmählichen Reaktion an den Sensor-Elektroden, ist die Anlaufzeit relativ lange: es kann bis zu einer Stunde und länger dauern, bis der Sensor wieder verlässliche Werte anzeigt. Zudem verbraucht er etwa 160 mA Strom, hat eine gewisse Drift über die Zeit (etwa 100 ppm/Jahr) und ist zudem temperaturabhängig (auf den Modulen ist deshalb ein einfacher Temperatursensor zur Kompensation vorhanden).

Den Sensor muss man selber kalibrieren. Den „Nullpunkt“ (also die natürliche, niedrigste CO2-Konzentration in der Luft mit 400 ppm) erhält man, indem man ihn einfach länger an der frischen Luft lässt. Jetzt gibt der Sensor seine maximale Spannung am analogen Ausgang ab. Den Maximalpunkt (geringste Spannung) stellt die menschliche Atmung dar, die bei etwa 4 % CO₂-Anteil oder 40.000 ppm liegt. Packt man den Sensor in eine Tüte und atmet mehrfach hinein, hat man diesen Extrempunkt. Aus diesen beiden Punkten kann man dann den CO₂-Wert am analogen Eingang per Formel im Datenblatt oder per praktischem Versuch mit einem geeichten Vergleichssensor berechnen.

Wie gut ist die Luft im Büro?

Wir wollen uns nachfolgend ein Beispiel anschauen, in dem der ESP8266 Sensor-Daten an eine Webserver-Schnittstelle von Node-RED sendet, wir diese Daten weiterverarbeiten und uns daraus ein Live-Dashboard mit optischer Anzeige der Luftqualität durch die Philips Hue mit Rot oder Grün bauen.

Neben dem ESP8266 benutzen wir einen CO₂-Sensor auf Basis des MG811, der die Luftqualität anhand des aktuellen Kohlenstoffdioxid-Wertes in ppm (parts per million) übermittelt. Für unsere Node-RED Umgebung benötigen wir für das Dashboard eine weitere Bibliothek, die aus einer Reihe von Nodes für die Anzeige von Messinstrumenten, Diagrammen, Texten und anderen Elementen besteht. Mit der Bibliothek erhalten wir im linken Fenster neue Nodes in der Kategorie dashboard und im rechten Fenster einen zusätzlichen Reiter mit dem gleichen Namen.

Empfangen werden wir die Daten mit einem http Input-Node, wie wir ihn auch im „Hello World“ Server-Beispiel verwendet haben. Für die Farbsteuerung werden wir den Node switch verwenden. Die Firmware für den ESP8266 wird komplexer und es sind einige Zeilen Code zu schreiben, die für die Herstellung einer WLAN-Verbindung, einen Http-Client (der per POST die Daten als JSON-String an den Node-RED Server sendet) und das Auslesen des CO₂-Sensors sorgen.

1 Versorgung und Verbindung des MG811

Es wird eine stabile Versorgungsspannung von 6 V benötigt, die mit einem LM7806 aus 9–35 V erzeugt wird. Um die Wärme abzuführen und die benötigte Leistung bereitzustellen, wird ein IC im TO-220-Gehäuse benötigt.

2 Firmware für den ESP8266

Die Firmware für den ESP8266 können wir mit der Arduino-IDE und dem entsprechenden Plugin (https://github.com/esp8266/Arduino) programmieren. Eine Einführung in die Programmierung des Moduls mit der IDE finden Sie in der Ausgabe 6/2015.

3 WLAN-Verbindung

Zunächst binden wir die ESP8266 WiFi-Bibliothek ein und tragen die entsprechenden Daten für unser WLAN und die IP des Raspberry Pi ein und starten es in setup():

#include <ESP8266WiFi.h>

const char* ssid = "SSID"; // Eintragen der SSID

const char* password = "Pwd"; // Passwort

const char* host = "..."; // IP vom Raspberry

...

setup()

...

// WiFi Start

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED)

delay(500);

4 Senden der Daten

In loop() bauen wir die WLAN-Verbindung für unseren Client auf und senden den JSON-String mit dem aktuellen Wert per Http-POST an unseren Raspberry Pi Node-RED Server. Am Ende der Schleife machen wir eine zweisekündige Pause, bis wir den nächsten Wert senden.

// Aufbau der TCP-Verbindung mit unserem Raspberry Pi

WiFiClient client;

const int httpPort = 1880;

if (!client.connect(host, httpPort))

return;

int num = 0; // Variable für die Länge des Content-

Length wird zurückgesetzt

String var = "{\"airQuality\": {\"co2Value\": \"" +

String(valCO2) + "\"}}"; // JSON-String für den http-

POST

num = var.length(); // Variable für Content.length

// Senden des http POST zum RaspberryPi

client.println("POST /co2 HTTP/1.1");

client.println("User-Agent: ESP8266_Make");

client.println("Host: " + String(host));

client.println("Content-Type: application/json");

client.println("Content-Length: " + String(num));

client.println();

client.print(var);

client.println();

delay(10);

...

// am Ende:

delay(2000); // Wartezeit bis zum nächsten Senden

5 CO₂-Sensor auslesen und mappen

Für die Abfrage des Sensors definieren wir zunächst die Referenzwerte wie im Kasten MG811 auf Seite 71, lesen den analogen Wert aus und berechnen die CO₂-Konzentration. Da wir den am ADC gelesenen Wert mitteln wollen, brauchen wir dazu eine entsprechende globale Variable sample. In der Schleife lesen wir dann den Wert aus und glätten ihn, indem wir ihn fünfmal einlesen und dann den Wert durch die Anzahl der Lesevorgänge teilen. Dann „mappen“ wir den Wert auf unsere bei der Kalibrierung ermittelten Werte und setzen schließlich die verwendeten Variablen wieder zurück.

int sample = 0;

...

for (byte i = 0; i < 5; i++)

sample = sample + analogRead(A0);

int sample_ergebnis = sample / 5;

...

int valCO2 = map(sample_ergebnis, 987, 844, 400,

2500);

...

sample = 0;

sample_ergebnis = 0;

6 Programmcode übertragen

Jetzt spielen wir den Sketch auf unseren ESP8266 mit angeschlossenem Sensor auf. Bei den Downloads, die Sie über den Weblink zu diesem Artikel finden, stellen wir den kompletten Sourcecode bereit.

Node-RED + Dashboard

Machen wir uns nun an unsere Back- und Frontend-Kombination aus Node-RED und dem Dashboard. Mit einem Blick lässt sich erfassen, welche Luftqualität beispielsweise im Büro herrscht, und die genauen Werte können auf einem Monitor angezeigt werden.

1 Server erstellen und Debug-Ausgabe

Wir erstellen zunächst einen Server und eine Debug-Ausgabe mit nur zwei Knoten zum Testen der Hard- und Software. Dafür benutzen wir einen http Input-Node und einen debug-Node, die wir folgendermaßen konfigurieren:

http in: Method:POST; URL:/co2; Name: „Receive HTTP Request“

Debug: Output:msg.payload.airQuality.c02Value; to:debug tab; Name: bleibt leer

Nachdem wir den Flow veröffentlicht (Deploy) und die Debug-Ausgabe aktiviert haben, sollte der Wert im Debug-Fenster erscheinen. Da wir einen JSON-String im Format: {"airQuality":{"co2Value":"506"}} an den Server senden, können wir auf die einzelnen Key-/Value-Paare elegant per Punktnotation im Payload-Objekt msg.payload zugreifen. Um den Wert von co2Value zu erhalten, der zum Array airQuality gehört, fragen wir msg.payload.airQuality.co2Value ab und bekommen den aktuellen Wert. HTTP POST, womit eine Nachricht im BODY von HTML verschickt wird, erspart uns in diesem Fall das Parsen des Wertes, wie es zum Beispiel bei einem HTTP GET notwendig wäre, und lässt uns auch diesmal wieder ohne eine einzige Zeile Code auskommen, da die Vorarbeit bereits in der Firmware des ESP8266 erfolgt.

2 Weitere Bibliothek installieren

Um die Elemente des Dashboards zu nutzen, installieren wir uns die Bibliothek mit

sudo npm install -g node-red-dashboard

Dann starten wir die Node-RED Anwendung neu, da sonst die Dashboard-Elemente nicht im linken Fenster mit den Nodes erscheinen.

3 Funktions-Knoten

Da wir für die Chart-Elemente auf den CO₂-Wert zugreifen wollen, müssen wir uns mit einem function-Node behelfen, der diese Variable weiter sendet. Wir hängen an den Node function einen debug-Node und überprüfen die Ausgabe. Name: „Extract CO2-Value“ und bei Function:

msg =

{

"payload" : msg.payload.airQuality.co2Value

};

msg;

4 Ein Diagramm erzeugen

Wir ziehen nun einen chart-Node aus der Kategorie dashboard in unseren Flow, verbinden ihn mit dem zuvor erstellten und konfigurieren ihn folgendermaßen:

Group: Luftqualität [Home] (muss mit dem Stift-Symbol im neu erscheinenden Fenster chart/Edit dashboard group node erzeugt werden); Label: „CO2 in ppm“; Y-Axis min: 400; Y-Axis max: 2000; Name: „CO2-Chart“

Alle anderen Werte bleiben unverändert. Nachdem wir den Flow veröffentlicht haben, gehen wir im rechten Fenster auf den Reiter dashboard und klicken neben dem Feld Title auf das Symbol mit dem Pfeil, der aus dem Quadrat heraus zeigt. Daraufhin öffnet sich ein Browser-Fenster und unser Dashboard mit dem Chart wird angezeigt.

5 Zeigerinstrument einrichten

Wir ziehen noch einen Node gauge und einen text in den Flow und verbinden sie ebenfalls mit dem function-Node „Extract CO2-Value“.

Gauge: Label: „ppm“; Range min: 400; Range max: 2000; Name: „CO2-Gauge“

Text: Label: „ppm“; Name: „CO2-Text“

Im rechten Fenster im Reiter dashboard sehen wir die einzelnen Dashboard-Elemente und können sie per Drag and Drop anordnen.

6 Eine Entscheidung treffen

Kommen wir nun zu unserer Philips-Hue-Anbindung. Beim CO₂-Wert gibt es eine gewisse Wohlfühlschwelle („Pettenkofer-Wert“), die bei 1.000 ppm CO₂ in der Luft liegt. Ist der Wert unterhalb oder gleich dieser Schwelle soll unsere Philips-Hue-Lampe grün leuchten ansonsten per rotem Licht auf Frischluftbedarf hinweisen. Wir ziehen uns dazu einen switch-Node in den Flow und tragen bei Name „Decide Lamp Status“ ein.

7 Bedingung festlegen

Im Fenster unter Property wählen wir im linken Drop-Down-Menü Kleiner-Gleich („<=“), daneben „09 number“ und geben den Wert „1000“ ein. Dann klicken wir unten auf +add, und wählen für die neu erschienene Zeile Größer („>“), wieder „09 number“ und geben „1000“ ein.

8 Die Lampe rot oder grün leuchten lassen

Wir kopieren uns aus dem Twitter-Beispiel eine Kombination aus den Nodes template und hue set und setzen diese zwei Mal in unseren Flow ein. Beim oberen template-Node ändern wir den Namen in „CO2 Ok Lamp Green“ und setzen den Wert für hue auf „25500“ (Grün), den unteren benennen wir ihn „CO2 Alert Lamp Red“ und setzen den Wert bei hue auf „0“ (Rot). Am Ende verbinden wir die Nodes mit dem switch-Node und veröffentlichen den Flow.

9 Twitter-Nachrichten sind blau

In Kombination mit dem Twitter-Flow leuchtet die Lampe jetzt grün, wenn die Luft in Ordnung ist, rot wenn das Fenster geöffnet werden muss und blinkt blau sobald eine Twitter-Nachricht eingeht. Dazu haben wir ein schickes Dashboard, welches per Browser beispielsweise auch auf dem Handy abrufbar ist. Natürlich könnte man noch die Twitter-Nachrichten auch in das Dashboard per text-Node integrieren. —fls