NodeRed mit MQTT im Revolution Pi

Auf dem RevPiDay 2018 haben wir euch unsere Erweiterung von RevPiPyLoad vorgestellt, mit der wir NodeRed auf dem Revolution Pi sehr einfach, dank MQTT, verwenden können. Hier zeigen wir euch wie es geht.

Installation der benötigten Software

Wir werden in diesem Beispiel alle Komponenten direkt auf dem Revolution Pi installieren. Der MQTT Broker und NodeRED könnten natürlich auch auf anderen Systemen im Netzwerk installiert sein, dann jeweils die Adressen von „localhost“ auf die jeweiligen Adressen der Systeme ändern.

RevPiPyLoad: System für Steuerprogramm, IO-Checks und MQTT Übertragung
mosquitto: MQTT Broker
NodeRED: Oberfläche für unsere Visualisierung / Steuerung (bereits auf dem Revolution Pi)

pi@RevPi ~/ $ sudo apt-get update

# Installieren
pi@RevPi ~/ $ sudo apt-get install revpipyload mosquitto mosquitto-clients

Vorbereitungen und Aufbau der Hardware

In unserem Beispiel verwenden wir einen Revolution Pi an dem je ein DIO und AIO Modul angehängt ist. An dem AIO haben wir zwei PT 100 Temperatursensoren angeschlossen. Das DIO Modul wurde mit drei Tastern und zwei LEDs verkabelt.

Es handelt sich um unser System, welches wir in unserer Schnellstart!-Anleitung erklären. Dort findet ihr auch Informationen für die Einrichtung von piCtory und des grafischen Tools für die Konfiguration.

RevPiPyload für MQTT konfigurieren

Die einfachste Variante der Konfiguration ist die Verwendung unseres grafischen Konfigurationstools RevPiPyControl. Bevor wir damit auf den Revolution Pi zugreifen können, muss die XML-RPC Schnittstelle in RevPiPyLoad aktiviert werden. Dies könnt ihr detailliert unter „RevPiPyLoad Installation auf den RevPi“ in unserem Schnellstart nachlesen.

Konfiguration mit RevPiPyControl

Wenn eine Verbindung per RevPiPyControl mit dem Revolution Pi hergestellt ist, öffnet man die Optionen über „PLC->PLC Optionen…“. Im unteren Teil findet man „MQTT Übertragung des Prozessabbilds“. Diese Option wird aktiviert! Über den Button „Einstellungen“ werden die MQTT Parameter konfiguriert.

Wir setzen den „Base topic“ z.B. auf „revpi8143„, das Sendeintervall auf 15 Sekunden und die Brokeradresse auf localhost (127.0.0.1)! Benutzername, Kennwort und Client ID können wir leer lassen. Diese müssen nur gesetzt werden, wenn wir einen externen Broker verwenden oder unser lokaler Mosquitto mit Benutzerauthentifizierung versehen wurde.

Wenn wir Daten sofort bei Änderung empfangen wollen, z.B. für die Echtzeitanzeige von Temperaturen, müssen wir „Exportierte Werte sofort senden, wenn diese sich ändern“ aktivieren. In unserem Beispiel unbedingt aktivieren!

Sollen Ausgänge aus NodeRed auch gesetzt werden können, aktivieren wir „MQTT erlauben, Ausgänge am Revolution Pi zu setzen„. Für unser Beispiel bitte auch diesen Wert auf aktiv setzen!

Alle Einstellungen mit den „Speichern“ Schaltflächen übernehmen. Das System wird nun gestartet und sendet alle 15 Sekunden die Werte der IOs, bei denen in piCtory der „Export“ Haken aktiv ist, an den lokalen Broker.

Konfiguration direkt am Revolution Pi

Wir können die Konfigurationsdatei von RevPiPyLoad auch direkt an unserem Revolution Pi bearbeiten und MQTT aktivieren. Dafür öffnen wir Diese in einem Texteditor:

pi@RevPi0000:~ $ sudo nano /etc/revpipyload/revpipyload.conf

In dem Editor finden wir alle MQTT Einstellungen in der [MQTT] Sektion.

Wir setzen mqtt = 1, den basetopic = revpi8143 und das sendinterval = 15. Bei der Brokeradresse verwenden wir localhost, da dieser auf unserem Revolution Pi installiert ist broker_address = localhost. Hier können wir natürlich auch einen anderen Broker angeben. username, password und client_id können leer bleiben, wenn es sich um den lokalen Broker handelt.

Außerdem benötigen wir für unser Beispiel auch send_on_events = 1

Nun mit Strg+X die Änderung speichern und das Speichern mit y bestätigen.

Der RevPiPyLoad Dienst muss nun neu gestartet werden um die Änderungen zu übernehmen.

pi@RevPi0000:~ $ sudo service revpipyload restart

Ab jetzt sendet RevPiPyLoad alle 15 Sekunden die Werte der IOs, bei denen in piCtory der „Export“ Haken aktiv ist, an den Broker.

Kleiner Test direkt am Revolution Pi

Direkt am Revolution Pi testen wir nun, ob die Werte wirklich übertragen werden. Dafür verwenden wir mosquitto_sub, welches wir mit dem Paket mosquitto-clients installierten:

pi@raspberrypi:~ $ mosquitto_sub -t "#" -v
revpi8143/io/temp_heater 215
revpi8143/io/temp_outside 227
revpi8143/io/door_corridor 0
revpi8143/io/door_workshop 0
revpi8143/io/t_flip 0
revpi8143/io/I_4 0
revpi8143/event/Core_Temperature 58
revpi8143/event/Core_Temperature 57
(...)

Bei den Einträgen mit revpi8143/io/... handelt es sich um die zyklisch übertragenen Werte. Die Einträge mit revpi8143/event/... sind die Werte der IOs, die bei Wertänderung sofort gesendet werden.

Um Events auszulösen können wir auch einen Taster an unserem Aufbau betätigen, der ein Signal auf einen Eingang gibt.

NodeRed vorbereiten

Nachdem wir die IOs per MQTT bekommen, können wir das NodeRed vom Revolution Pi konfigurieren. In unserem Beispiel soll NodeRed immer automatisch mit dem Revolution Pi starten und wir wollen neue Nodes komfortabel über „Manage palette“ installieren / updaten können.

Je nach Image Version müssen wir unterschiedliche Schritte durchführen. Bitte prüfen, welche Version auf dem RevPi Läuft:

pi@RevPi0000:~ $ cat /etc/issue
Raspbian GNU/Linux 9 \n \l \4 \6

Strech (Linux 9) Image (RevPi Connect + neuere Core 3)

# Komplettes System auf den aktuellen Stand bringen
pi@RevPi0000:~ $ sudo apt-get update
pi@RevPi0000:~ $ sudo apt-get dist-upgrade

# Für die Installation der Nodes benötigen wir npm
pi@RevPi0000:~ $ sudo apt-get install npm

# NodeRed automatisch mit Revolution Pi starten
pi@RevPi0000:~ $ sudo systemctl enable nodered

# NodeRed jetzt starten
pi@RevPi0000:~ $ sudo systemctl start nodered

Jessie (Linux 8) Image (Core 1 + ältere Core 3)

Auf dem Jessie Image müssen wir, neben den normalen Schritten, ein node-update durchführen.

# Komplettes System auf den aktuellen Stand bringen, dabei wird leider nicht
# mehr NodeRed aktualisiert und muss später von Hand aktualisiert werden!
pi@RevPi0000:~ $ sudo apt-get update
pi@RevPi0000:~ $ sudo apt-get dist-upgrade

# Für die Installation der Nodes benötigen wir npm
pi@RevPi0000:~ $ sudo apt-get install npm

# Node-Update durchfrühen um alle Funktionen nutzen zu können
pi@RevPi0000:~ $ sudo npm install -g n
pi@RevPi0000:~ $ sudo n stable

# NodeRed automatisch mit Revolution Pi starten
pi@RevPi0000:~ $ sudo systemctl enable nodered

# NodeRed jetzt starten
pi@RevPi0000:~ $ sudo systemctl start nodered

Nach dem ersten Start geben wir NodeRed etwas Zeit zum initialisieren.

Nun können wir auf unserem Rechner einen Browser öffnen und verwenden als Adresse die IP vom Revolution Pi und den Port 1880.

http://ip-adresse-revpi:1880

Für unseren Aufbau benötigen wir das „node-red-dashboard“. Dies Installieren wir durch einen Klick auf das Menü oben rechts und wählen „Manage palette“.
In dem geöffneten Dialog wechseln wir auf den Reiter „Install“ und geben „node-red-dashboard“ ein.

Nach dem Klick auf „install“ wird der Node automatisch installiert (kann etwas Zeit in Anspruch nehmen, vor allem auf einem Core 1).

Danach den Browser-Cache aktualisieren (Strg+F5) und prüfen, ob die neuen Dashboard-Nodes in der linken Liste am Ende erscheinen:

Erster Schritt: MQTT einrichten

Wir platzieren von der linken Seite aus der Kategorie „Input“ einen „mqtt“ Knoten in unseren „Flow 1“. Dann einen Doppelklick auf den neuen MQTT-Knoten und wir sehen die Einstellungen „Edit mqtt in node“.

Dort müssen wir einmalig den MQTT-Broker angeben, in dem wir auf den kleinen Stift neben „Add new mqtt-broker…“ klicken.

In dem folgenden Dialog, tragen wir lediglich unter „Server“ den Wert localhost ein. Im oberen Bereich auf „Add“ klicken und der Broker ist gespeichert.

Nun kehren wir zurück zu den Eigenschaften unseres ersten MQTT-Nodes. Dieser hat den neuen Broker automatisch übernommen und möchte einen Eintrag für „Topic“ haben. Als Topic verwenden wir nun den Wert, unter dem unser Revolution Pi Werte der IOs sendet. In unserem Beispiel ist dies „revpi8143/io/temp_heater“. Danach mit „Done“ speichern.

Dies wiederholen wir auch für den Topic „revpi8143/io/temp_outside“.

Zusatz: Erster Test mit Debug-Node

Nun wählen wir links aus der Kategorie „output“ den Node „debug“ aus, platzieren ihn in unserem „Flow 1“ und verbinden die Ausgänge von unseren MQTT-Nodes mit dem Eingang vom Debug-Node.

Endlich ist es soweit soweit: Wir klicken oben auf „Deploy“ und klicken rechts den Reiter „debug“ an. Dort werden nun alle 15 Sekunden die aktuellen Werte der IOs angehängt:

Zweiter Schritt: Kleine IoT-Lösung

Die Temperaturen wollen wir nun in °C anzeigen. Dafür müssen wir den übergebenen Wert durch 10 Teilen. Wir wählen links den Knoten „function“ aus, platzieren ihn in unserem Flow und machen einen Doppelklick darauf. Bei Name geben wir z.B. „Durch 10 Teilen“ ein und in das Feld „Function“ folgenden Quelltext:

msg.payload = msg.payload / 10;
return msg;

Mit „Done“ Speichern und die Ausgänge unserer MQTT Knoten mit dem Eingangsknoten der Funktion verbinden.

Der Ausgang unserer Funktion liefert nun als Wert die Temperatur in °C. Diesen Wert wollen wir nun visuell darstellen. Auf der Linken Seite wählen wir unter „dashboard“ den Knoten „chart“ aus und platzieren ihn in unserem Flow.

Durch einen Doppelklick auf den „chart“ Knoten öffnen sich die Einstellungen. Dort klicken wir neben „Add new ui_group“ auf den kleinen Stift und gelangen in die „Add new dashboard group config node“ Eigenschaften. Auch hier muss bei „Add new ui_tab“ auf den Stift geklickt werden um einen neuen Tab zu erzeugen.

In den „Add new dashboard tab config node“ vergeben wir den Namen „Home“ und klicken auf „Add“. Nach Zurückkehren zu „Add new dashboard group config node“ vergeben wir für die Gruppe den Namen „Zyklische Daten“. Den Wert „Width“ setzen wir auf 15 und klicken auch hier auf „Add“.

Endlich wieder im „Edit chart node“ angekommen, setzen wir den Wert für „Legend“ auf „Show“ und klicken auf „Done“.

Um all dies zu speichern klicken wir nun oben rechts auf .

Um unsere Visualisierung zu bestaunen, öffnen wir ein neuen Webbrowser und geben die Adresse von Node-Red erneut ein, hängen aber ein /ui/ dahinter.

http://ip-adresse-revpi:1880/ui/

Dritter Schritt: Erweiterung der IoT-Lösung

Da wir auch eventbasierte MQTT Nachrichten bekommen, können wir Echtzeitanzeigen in unsere Visualisierung einbetten. Wir erzeugen zwei neue MQTT Eingangsknoten mit den Topics „revpi8143/event/temp_heater“ und „revpi8143/event/temp_outside“. Den Wert für „QoS“ setzen wir auf „0“!

Für jeden dieser MQTT-Eingänge setzen wir einen separaten Funktions-Knoten mit unserer „Durch 10 teilen“ Funktion und geben den Ausgang der Funktion in einen „gauge“ Knoten, den wir links unter „dashboard“ finden.

Wenn wir einen Doppelklick auf die „gauge“ Knoten machen, wählen wir beim ersten Mal unter „Group“ „Add new ui_grop“ aus und klicken auf den kleinen Stift. Der neuen Gruppe geben wir den Namen „Echtzeit Daten“ und bestätigen die neue Gruppe mit „Add“.
Zurück im „Edit gauge node“ setzen wir noch die „Range“ auf z. B. 0 – 50. Danach diesen Dialog mit „Done“ speichern. Beim Doppelklick auf die zweite „gauge“ müssen wir lediglich unter „Group“ die neue Gruppe „Echtzeit Daten“ auswählen, die „Range“ von 0 – 50 festlegen und mit „Done“ bestätigen.

Alle Änderungen mit in NodeRed speichern und unsere erweiterte Visualisierung betrachten:

Probiert selber ein paar Einstellungen der verwendeten Knoten für die Visualisierung aus. Es kann z. B. noch ein Button hinzugefügt werden, der als Wert [] sendet und unseren Chart leert. Es sind nun alle Möglichkeiten gegeben.

Vierter Schritt: Ausgänge setzen

Wir werden mit NodeRed nun eine kleine FlipFlop Schaltung aufbauen. Dafür verwenden wir unseren Taster an Eingang „t_flip“ und unsere LED am Ausgang „led2“ vom Revolution Pi.

Für diese Funktion verwenden wir wieder einen MQTT Eingangsknoten mit dem Topic „revpi8143/event/t_flip“. Dieser wird sofort ausgelöst, wenn der Eingang „t_flip“ den Status wechselt. Den Ausgang unseres Knotens verbinden wir mit einem Funktions-Knoten, den wir links in der Auswahlliste finden.

Ein Doppelklick auf den Funktions-Knoten öffnet dessen Einstellungen. Als „Name“ vergeben wir „flipflop“ und in das Feld „Function“ tragen wir folgenden Quelltext ein:

if(msg.payload == 1){
    if (global.flipflop) {
        global.flipflop = false;
    }
    else {
        global.flipflop = true;
    }

    msg.payload = global.flipflop;
    return msg;
}

Nun verwenden wir einen neuen Knoten, den wir unter „output“ links in der Liste finden. Auch dieser heißt „mqtt“. Diesen Knoten setzen wir in unseren Flow und öffnen dessen Einstellungen mit einem Doppelklick. Als „Server“ sollte hier automatisch „localhost“ gesetzt sein und der Topic lautet hier „revpi8143/set/led2“ (wichtig ist das …/set/… im Topic). Alles mit „Done“ bestätigen.

Der Ausgang unserer Funktion wird mit dem Eingang des neuen MQTT Ausgangsknotens verbunden:

Unseren Flow mit speichern und schon kann der Taster „t_flip“ den Ausgang setzen und rücksetzen.

Extras

Wenn ein Wert zu einem bestimmten Event abgefragt werden soll (z. B. durch Klick auf einen Button), kann der MQTT Ausgangsknoten auch mit dem Topic „basetopic/get/ioname“ verwndet werden. Der Revolution Pi sendet dann sofort den Wert des Ein- oder Ausgangs per MQTT auf den Topic „basetopic/io/ioname“ zurück, welcher über MQTT Eingangsknoten empfangen werden kann.