ESP32 und Node-RED – https://erik-bartmann.de/
ESP32 Pico-Board
ESP32 Addon
ESP32 und
Node-RED
Vers. 1.0
© by Erik Bartmann, Juli 2018
ESP32 und Node-RED – https://erik-bartmann.de/ Seite 2
ESP32 und Node-RED
as Internet der Dinge, im
Englischen IOT - Internet-Of-
Things - genannt, ist seit kurzem in aller
Munde und steht für die Verknüpfung
von Objekten (Things) in der realen
Welt mit denen in der
virtuellen Welt (Internet).
Es soll alles mit allem in
Form einer umfassenden
Vernetzung strukturiert
sein, so dass eine
Kommunikation für den
Austausch von Daten
jeglicher Art stattfindet.
Ich möchte in diesem
Addon ein System beziehungsweise
Werkzeug vorstellen, das von IBM
entwickelt wurde sich Node-RED nennt.
Mithilfe einer grafischen Oberfläche ist
es in kürzester Zeit möglich, über
sogenannte Flows Verbindungen zu
verschiedenen Geräten oder Instanzen
herzustellen, um darüber einen
Informationsfluss beziehungsweise
Informationsaustausch
zu realisieren. Es werden
- ähnlich wie z.B. bei der
Programmiersprache
Scratch - vordefinierte
Blöcke mit hinterlegten
Funktionen zur
Verfügung gestellt, die
aus einem Vorrat sehr
einfach miteinander
kombiniert werden können. Diese
Blöcke - auch Nodes genannt - erfüllen
bestimmte Aufgaben und bilden im
Verbund die schon erwähnten Flows.
D
ESP32 und Node-RED – https://erik-bartmann.de/
3 ESP32 und Node-RED
Node-RED uf der folgenden Abbildung sehen wir einen kurzen Flow, der eine TCP-
Verbindung zu einem Device mit der IP-Adresse 192.168.178.22 über den Port
8088 etabliert.
Abbildung 1 Ein Node-RED-Flow
Diese TCP-Node auf der rechten Seite wird gespeist mit Informationen, die auf der
linken Seite über die Inject-Node geliefert wird. Wie man hier erkennen kann, handelt
es sich um eine visuelle Programmierung über vorhandene Blöcke, die aus einem
Vorrat entnommen werden. Bei der Entwicklung von Node-RED war das primäre Ziel
eine einfache Zusammenführung von Hard- bzw. Software und darüber eine
Programmierschnittstelle zur Verfügung zu stellen, damit auf sehr kurzem Wege eine
Kommunikation zwischen Webdiensten und Hardwarekomponenten verwirklicht wird.
Die große Auswahl von fertigen Nodes bietet eine sehr gute Voraussetzung zur
Erstellung übergreifender Anwendungen, die von der Ansteuerung von Hardware-Pins
bis zu High-Level-APIs reicht, wie sie z.B. bei facebook oder Twitter zum Einsatz
kommen. Die außerordentlich gute Handhabung bzw. Übersichtlichkeit und eine sehr
gute Erweiterbarkeit sorgen dafür, dass eine breite Zielgruppe angesprochen wird, die
vom Anfänger bis zum Spezialisten reicht.
Node-RED [2] ist Open-Source und basiert auf Node.js, was eine serverseitige Plattform
zur Softwareentwicklung von Netzwerkanwendungen ist. Die Bezeichnung Node-RED
klingt ein wenig wie Code-RED, was dem Projekt sicherlich einen spannenden und
aufregenden Anstrich gibt, denn wenn sich etwas in höchstem Alarmzustand befindet,
wird die Aufmerksamkeit gesteigert und volle Konzentration gefordert.
Ich verwende in diesem Addon zur Bereitstellung von Node-RED einen Raspberry Pi,
der ein kleiner und leistungsstarker Einplatinencomputer ist. Er ist sehr günstig und
kann für sehr viele Hard- bzw. Software Projekte im IOT-Umfeld zum Einsatz kommen.
Das aktuelle Modell ist der Raspberry Pi 3 bzw. 3+ der einen 1,2GHz Quard-Core
Prozessor besitzt. Es sind 1 GByte RAM vorhanden und er verfügt von Hause aus
sowohl über ein Wifi-, als auch ein Bluetooth-Modul. Natürlich ist das Ganze auch mit
einem Raspberry Pi 2, der jedoch standardmäßig nicht über Wifi und Bluetooth
verfügt, zu realisieren.
A
ESP32 und Node-RED – https://erik-bartmann.de/
4 ESP32 und Node-RED
Auf der folgenden Abbildung sehen wir den Raspberry Pi 3 mit seinen diversen
Anschlüssen.
Abbildung 2 Der Raspberry Pi 3
Wenn man sich einen schnellen und einfachen Überblick über Node-RED verschaffen
möchte, weil gerade kein Raspberry Pi zur Hand ist, dann ist das kein Problem. Auf der
Internetseite von FRED [3], was für Frontend für Node-RED steht, findet man einen
leichten Einstieg. Nach der Registrierung für die freie Version, steht Node-RED nach
kurzer Zeit zur Verfügung. Es besteht jedoch eine Einschränkung hinsichtlich der Anzahl
der zu erstellenden Nodes, was aber zu Beginn kein Problem darstellen sollte. Wer sich
im Detail mit Node-RED auseinandersetzen möchte, dem lege ich mein Node-RED-Buch
[4] ans Herz, das im Elektor-Verlag erschienen ist.
Wir steigen ein Genug der Vorrede, denn wir wollen konkret werden. In diesem Addon wollen wir
zunächst Node-RED auf dem Raspberry Pi installieren. Das erfolgt über ein Terminal-
Fenster mit der Eingabe der folgenden Zeile.
# sudo apt-get install nodered
Nach der erfolgten Installation kann Node-RED über den folgenden Befehl gestartet
werden.
# node-red-start
ESP32 und Node-RED – https://erik-bartmann.de/
5 ESP32 und Node-RED
Im Terminal-Fenster laufen jetzt einige Nachrichten durch, die für uns durchaus wichtig
sind, denn wir benötigen die IP-Adresse, über die Node-RED über das Netzwerk zu
erreichen ist. Auf der folgenden Abbildung ist ein kleiner, aber wichtiger Ausschnitt zu
erkennen.
Abbildung 3 Wichtige Informationen beim Start von Node-RED
Ich habe die vergebene IP-Adresse in rot markiert. Genau diese Zeile muss für die
Verbindung eines Web-Browsers als URL eingegeben werden. Als Browser werden
Firefox bzw. Chrome favorisiert, obwohl ich auch mit Opera keine Probleme feststellen
konnte. Nach der Eingabe der gezeigten URL - die bei jedem hinsichtlich der
vergebenen IP-Adresse natürlich anders ausschauen kann - meldet sich Node-RED.
Abbildung 4 Node-RED im Browser
ESP32 und Node-RED – https://erik-bartmann.de/
6 ESP32 und Node-RED
Da es sich um eine Client-Server-Anwendung handelt, kann der Node-RED-Server, der
sich auf dem Raspberry Pi befindet, natürlich im gesamten Netzwerk erreicht werden.
Ich habe den Zugriff über meinen Web-Browser auf meinem Windows 7 gestartet. Auf
der folgenden Abbildung sehen wir die Verbindung der beiden Instanzen. Auf der
linken Seite der Raspberry Pi mit dem installierten Node-RED-Server und auf der
rechten Seite das ESP32-Picoboard. Beide kommunizieren über eine TCP-Verbindung
miteinander.
Abbildung 5 Der Raspberry Pi und das ESP32-Picoboard im Austausch miteinander
TCP und auch das UDP sind Protokolle, die verwendet werden, um Datenpakete über
das Internet an eine IP-Adresse zu senden. Genau das machen wir in unserem Fall. Das
TCP (Transmission Control Protocol) sorgt für eine höchstmögliche Zuverlässigkeit, was
bedeutet, dass TCP dafür sorgt, dass der Empfänger die übertragenen Pakete in der
richtigen Reihenfolge und ebenfalls ohne Fehler erhält. Der Empfänger sendet
ACKnowledge an den Absender zurück, um ihm darüber mitzuteilen, dass er die Pakete
erhalten hat. Wenn der Absender innerhalb eines Timeout-Zeitraums kein
ACKnowledge erhält, sendet er die Pakete erneut an den Empfänger, bis der
Empfänger die Pakete erhalten hat, was natürlich nicht endlos erfolgt.
ESP32 und Node-RED – https://erik-bartmann.de/
7 ESP32 und Node-RED
Der Node-RED-Flow Beginnen wir ganz einfach und nehmen uns zwei Nodes aus dem Vorrat von Node-
RED. Da haben wir zum einen die Inject-Node, die z.B. eine Nachricht in den Flow
einspeist. Sie befindet sich in der Input-Palette.
Abbildung 6 Die Inject-Node
Diese Node dient also als unsere Datenquelle, die Informationen liefert. Als Empfänger
haben wir die TCP-Node, die die empfangene Nachricht aus dem Flow an ein Gerät mit
der angegebenen IP-Adresse versendet. Sie befindet sich in der Output-Palette.
Abbildung 7 Die TCP-Node
Verbinden wir beide Nodes miteinander, entsteht ein sogenannter Flow, wie er auf der
folgenden Abbildung zu sehen ist.
Sehen wir uns die Konfiguration der beiden Nodes etwas genauer an, denn ohne diese,
funktioniert die Kommunikation natürlich nicht.
ESP32 und Node-RED – https://erik-bartmann.de/
8 ESP32 und Node-RED
Die Inject-Node Die Inject-Node kann dazu verwendet werden, Informationen in den Flow
einzuspeisen. Wir werden das im einfachsten Fall manuell gestalten. Eine noch nicht
gespeicherte Node zeigt diesen Zustand optisch anhand eines kleinen blauen Kreises
an der rechten oberen Stelle, wie das auf der folgenden Abbildung zu sehen ist.
Durch einen Doppelklick darauf öffnet sich ein Dialogfenster, über das diverse
Einstellungen zur Konfiguration eingegeben werden können.
Abbildung 8 Die Konfiguration der Inject-Node
Über die Payload - also die Nutzlast, die die Nachricht beinhaltet - wird die zu
versendende Nachricht definiert, die zuvor als String (Zeichenkette) festgelegt wird. Ein
Klick auf die rote Done-Schaltfläche schließt die Konfiguration ab. Kommen wir zur
TCP-Node.
ESP32 und Node-RED – https://erik-bartmann.de/
9 ESP32 und Node-RED
Die TCP-Node Die TCP-Node versendet eine Nachricht an das angegebene Gerät mit der definierten
IP-Adresse. Diese IP-Adresse ist die des ESP32-Picoboards, die ich an dieser Stelle
vorwegnehme und ich zeige später, wie diese zu ermitteln ist. Die Ausgabe der
erforderlichen Informationen ist in der Arduino-Entwicklungsumgebung im Serial-
Monitor zu entnehmen.
Abbildung 9 Die vergebene IP-Adresse des ESP32
Die IP-Adresse lautet also 192.168.178.22 und muss in die TCP-Node eingegeben
werden. Es ist zudem zu beachten, dass der Port 8088 vergeben werden muss.
Abbildung 10 Die Konfiguration der TCP-Node
ESP32 und Node-RED – https://erik-bartmann.de/
10 ESP32 und Node-RED
Der Flow Wurden die beiden Nodes konfiguriert, können sie miteinander verbunden werden.
Eine einzelne Node stellt natürlich noch keinen Flow dar. Die einzelnen Nodes verfügen
über kleine graue Verbindungsstellen (hier rot umrandet).
Klickst man mit der Maus darauf und zieht bei gedrückter Maustaste das erscheinende
Fadenkreuz an den Verbindungspunkt der folgenden Node, die dann bei der
Annäherung orange aufleuchtet und lässt die Maustaste dort los, entsteht ein Flow,
der eine Aufgabe bzw. einen Task erfüllt.
Der Flow starten Bevor wir einen Flow nutzen können, müssen wir ihn auf dem Node-RED-Server quasi
speichern, und scharf schalten, was über die Deploy-Schaltfläche am rechten oberen
Rand erfolgt.
Um die vordefinierte Nachricht „Hallo, hier spricht Node-RED!“ einzuspeisen, die wir
bei der Konfiguration der Inject-Node vergeben haben, müssen wir auf die linke Stelle
der Inject-Node klicken.
ESP32 und Node-RED – https://erik-bartmann.de/
11 ESP32 und Node-RED
Der Empfänger Kommen wir jetzt zur Empfängerseite, denn das ESP32-Picoboard soll ja die versendete
Nachricht empfangen. Sehen wir uns dazu den Quellcode [5] genauer an. Es wird die
erforderliche Wifi-Library eingebunden, die maximale Länge an Zeichen für die
Nachricht festgelegt und die Authentifizierungsparameter User + Passwort für Wifi
definiert, die natürlich hier im Einzelfall ersetzt werden müssen. Letztendlich wird ein
Wifi-Server-Objekt definiert.
#include <WiFi.h>
#define MSG 50 // Maximale Länge der Nachricht
const char* ssid = "<SSID>";
const char* password = "<Passwort>";
WiFiServer server(8088); // Server hört auf Port 8088
Innerhalb der setup-Funktion kommt es zur Verbindungsaufnahme über das Wifi.
void setup() {
Serial.begin(9600);
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected to IP address: ");
Serial.println(WiFi.localIP());
server.begin(); // Server starten
}
ESP32 und Node-RED – https://erik-bartmann.de/
12 ESP32 und Node-RED
Der Serial-Monitor zeigt für jeden Schritt der Verbindungsaufnahme einen Punkt und
kommt es zur Herstellung einer Wifi-Verbindung, wird die vergebene IP-Adresse
angezeigt.
Abbildung 11 Die Statusmeldungen der Wifi-Verbindung
Innerhalb der loop-Funktion werden die eingehenden Nachrichten kontinuierlich
verarbeitet und zur Anzeige gebracht. Natürlich muss für eine Client-Abfrage bzw. -
bearbeitung auf der Seite des ESP32 ein entsprechender Client eingerichtet werden,
der nur dann erfolgreich arbeiten kann, wenn ein Server etabliert wurde.
void loop() {
String msg = ""; // Nachricht
// Auf einen neuen Client warten
WiFiClient client = server.available();
uint8_t data[MSG];
if (client) {
Serial.println("New client");
// Prüfen, ob Client verbunden
while (client.connected()) {
if (client.available()) {
int len = client.read(data, MSG);
if (len < MSG) data[len] = '\0';
else data[MSG] = '\0';
Serial.print("Clients message: ");
msg = (char *)data;
Serial.println(msg);
}
}
}
}
ESP32 und Node-RED – https://erik-bartmann.de/
13 ESP32 und Node-RED
Solange der Client mit dem Server verbunden ist (client.connected), werden über die
while-Schleife die Daten empfangen bzw. gelesen (client.available). Das Lesen
übernimmt die read-Methode mit der angegebenen Länge.
Wurde eine Verbindung vom Client zum Server - also von Node-RED und ESP32 -
hergestellt, erscheint eine entsprechende Meldung im Serial Monitor der Arduino-
Entwicklungsumgebung.
Abbildung 12 Ein neuer Client hat sich angemeldet
Wenn wir nun auf die Inject-Node geklickt haben, um eine Nachricht in den Flow
einzuspeisen, meldet das einerseits Node-RED am oberen Rand
ESP32 und Node-RED – https://erik-bartmann.de/
14 ESP32 und Node-RED
und andererseits natürlich auch der Serial-Monitor.
Abbildung 13 Die Nachricht von Node-RED wurde empfangen
Das sollte als kleine Einführung in Node-RED genügen. Ich komme in einem weiteren
ESP32-Addon zur einer Messwertaufnahme und Speicherung der Daten. Es wird also
wieder spannend!
Frohes Frickeln
ESP32 und Node-RED – https://erik-bartmann.de/
15 ESP32 und Node-RED
Das ESP32-Praxisbuch
[1] https://www.elektor.de/das-esp32-praxisbuch
[2] https://nodered.org/
[3] https://fred.sensetecnic.com/
[4] https://www.elektor.de/iot-programmierung-mit-node-red
[5] https://github.com/erikbartmann/ElektorESP32/tree/master/Addons/NodeRED
https://www.erik-bartmann.de/