esp32 und node-red – // · 4 esp32 und node-red auf der folgenden abbildung sehen wir den...

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


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



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



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



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.



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.



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.



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



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.



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

}



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);

}

}

}

}



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



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



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/

https://www.elektor.de/das-esp32-praxisbuch

https://nodered.org/

https://fred.sensetecnic.com/

https://www.elektor.de/iot-programmierung-mit-node-red

https://github.com/erikbartmann/ElektorESP32/tree/master/Addons/NodeRED

https://www.erik-bartmann.de/

esp32 und node-red – // · 4 esp32 und node-red auf der folgenden abbildung sehen wir den...

Documents