Projekt: Temperatur-Messsystem - Anzeigemodul 4


Aktuelle Module
Veraltete Module
Menübild

Symbol Status
Statusaktiv
Letzte Bearbeitung19.04.2021
Aktueller Softwarestand Node-RED Beispiel-Dateienv1.00 vom 17.04.2021
Aktueller Softwarestand ATtiny45 Nachtschaltungv1.00 vom 21.03.2021
Symbol Downloads
Verkabelungsplan und Schaltplan für Nachtschaltung
Stückliste mit Empfehlungen zur Bauteilbestellung
Beispieldateien für Node-RED v1.00 vom 17.04.2021am4-node-red-v100.zip
Software für ATtiny45 mit komplettem Quelltext in C vom 21.03.2021am4-attiny45-v100.zip
Raspberry Pi Homepage - Raspberry Pi OS with desktop (Betriebssystem für Raspberry Pi) https://www.raspberrypi.org/software/operating-systems/
Raspberry Pi Homepage - Raspberry Pi Imager (microSD-Karte für Raspberry Pi erstellen) https://www.raspberrypi.org/software/
Homepage von Win32 Disk Imager (Images auf Speicherkarten schreiben oder von Speicherkarten lesen) https://sourceforge.net/projects/win32diskimager/
Homepage von PuTTY (SSH-Client)http://www.putty.org/
Homepage von Angry IP Scanner (Netzwerk durchsuchen)https://angryip.org/
Homepage von VNC Viewer (Fernzugriff auf den Desktop des Raspberry Pi) https://www.realvnc.com/de/connect/download/viewer/
Homepage von MQTT Explorer (MQTT Nachrichten beobachten)https://mqtt-explorer.com/
Symbol Inhaltsverzeichnis
BeschreibungAllgemeine Informationen über das Anzeigemodul 4
SchaltungBeschreibung der Schaltung des Anzeigemoduls 4
HardwareBilder und Hinweise zum Aufbau des Anzeigemoduls 4
SoftwareBeschreibung der Software des Anzeigemoduls 4
InbetriebnahmeInbetriebnahme des Anzeigemoduls 4
KonfigurationKonfiguration von Node-RED und dem Node-RED-Dashboard
WartungWartungsarbeiten (Backup, Updates und Restore)
SymbolBeschreibung

Das Anzeigemodul 4 ermöglicht eine flexible Anzeige aller Sensordaten und Alarme des Temperatur-Messsystems. Außerdem können viele zusätzliche Informationen angezeigt werden, die aus anderen Quellen stammen können, z.B. Wetterdaten oder Kraftstoffpreise. Für die Anzeige wird ein 8-Zoll-HDMI-Display verwendet, welches von einem Raspberry Pi angesteuert wird. Dieses Display ist mit einem Touchscreen ausgestattet und kann somit auch zur Steuerung von weiteren Modulen verwendet werden. Alternativ ist auch ein Betrieb mit einer Display-Version ohne Touchscreen möglich. Das Anzeigemodul 4 ist über WLAN mit dem Heimnetzwerk verbunden und verwendet das MQTT-Protokoll für die Kommunikation. Eine Voraussetzung für den Betrieb des Anzeigemoduls 4 ist deshalb ein Web-Modul mit MQTT-Server. Allerdings ist es möglich, die Funktionalität des Web-Moduls in das Anzeigemodul 4 zu integrieren. Grundsätzlich wäre es auch möglich, bestimmte Zustände akustisch zu signalisieren, darauf habe ich jedoch verzichtet.

Die Basis des Anzeigemoduls 4 besteht (wie schon erwähnt) aus einem Raspberry Pi und einem direkt angeschlossenen Display. Da sich das Display leider nicht in der Helligkeit steuern lässt und auch keine Möglichkeit besteht, dieses in einen stromsparenden Standby-Modus zu bringen, sorgt eine kleine zusätzliche Schaltung für eine komplette Abschaltung des Displays bei Dunkelheit. Diese Nachtschaltung besteht aus einem ATtiny45 mit einem Fototransistor und 2 Schaltausgängen. Dabei schaltet ein Ausgang die Spannung für das Display (12V) und ein weiterer Ausgang die Spannung für den Touchscreen-Controller (5V). Letzterer arbeitet unabhängig vom Display und muss deshalb bei ausgeschaltetem Display ebenfalls deaktiviert werden. Da das Display eine Spannung von mindestens 9V benötigt, bietet es sich an, das gesamte Anzeigemodul mit 12V zu versorgen. Die Spannung für den Raspberry Pi erzeugt ein zusätzlicher Schaltregler, der hier als fertiges Modul zum Einsatz kommt.

Auf dem Raspberry Pi läuft das empfohlene Raspberry Pi OS mit Desktop. Zusätzlich wird noch Node-RED installiert, welches die über MQTT empfangenen Daten für die Anzeige aufbereitet und außerdem die über den Touchscreen ausgelösten Ereignisse über MQTT sendet. Zur Anzeige der Informationen wird der mitgelieferte Chromium-Browser verwendet, der in einem speziellen Kiosk-Modus betrieben wird. Dabei wird nur der Inhalt des Browser-Fensters angezeigt und man sieht praktisch nur noch das Node-RED-Dashboard auf dem Display. Im Prinzip handelt es sich beim Anzeigemodul 4 um einen simplen Raspberry-Pi-Rechner, dem nur noch Tastatur und Maus fehlt. Beides wird aber für die Funktion als Anzeigemodul nicht benötigt.

SymbolSchaltung

Schaltung 1

Das Bild oben zeigt alle Komponenten des Anzeigemoduls 4 und die notwendige Verkabelung. Auf der linken Seite befindet sich der Raspberry Pi, auf den eine kleine Platine aufgesteckt ist. Diese enthält die Nachtschaltung für das Display und sorgt außerdem für die Stromversorgung aller Schaltungsteile. Die 12V vom Netzteil gelangen zunächst über die Anschlüsse A1-A4 an die Platine. Über die Anschlüsse A5-A8 werden die 12V zum Eingang eines Schaltregler-Moduls weitergeleitet. Die dort erzeugten 5V gelangen dann über die Anschlüsse A9-A12 wiederum zur aufgesteckten Platine und versorgen hier den Raspberry Pi sowie die Nachtschaltung. Letztere steuert über zwei Schaltausgänge das Display und den Touchscreen-Controller. Die Anschlüsse B1-B2 führen dabei an den 12V-Stromanschluss für das Display und schalten somit die gesamte Display-Einheit ein oder aus. Beim Touchscreen-Controller passiert das gleiche, hier führen die Anschlüsse B3-B4 an den 5V-Anschluss des Controllers. An die Anschlüsse B7-B8 wird ein Fototransistor angeschlossen, welcher die Helligkeit an die Nachtschaltung übermittelt. Die verbleibenden Anschlüsse B5-B6 sind für einen Taster bestimmt, mit dem der Raspberry Pi heruntergefahren werden kann (Poweroff).

Es gibt noch 2 weitere Verbindungen, die jedoch nicht zur Platine führen und direkt am Raspberry Pi angeschlossen sind. Das ist zum einen das USB-Kabel des Touchscreen-Controllers, welches an einen beliebigen USB-Anschluss des Raspberry Pi gesteckt wird und zum anderen das HDMI-Kabel für die Display-Einheit. Das Display besteht eigentlich aus 2 Komponenten, die über ein dünnes Folienkabel direkt miteinander verbunden sind. Diese betrachte ich hier als Display-Einheit. Neben dem Strom- und dem HDMI-Anschluss ist noch der Anschluss für den Touchscreen wichtig. Dieser ist ebenfalls als dünnes Folienkabel ausgeführt und muss mit dem Touchscreen-Controller verbunden werden. Weiterhin gibt es noch eine Anschlussmöglichkeit für ein kleines Bedienteil. Dieses ermöglicht die Auswahl des Signaleinganges für das Display und einige weitere Einstellungen wie z.B. Helligkeit und Kontrast. Diese Einstellungen müssen nur einmal durchgeführt werden, so dass das Bedienteil nicht ständig angeschlossen sein muss. Alle für das Display notwendigen Spezialkabel werden übrigens mitgeliefert, müssen aber für dieses Projekt zum Teil modifiziert und gekürzt werden.

Schaltung 2

Dieses Bild zeigt die Schaltung der Aufsteck-Platine für den Raspberry Pi im Detail. Alle Ein- und Ausgänge sind hier an den beiden Stiftleisten A (J1) und B (J2) abgeschlossen. Grundsätzlich könnte man eine 2x10-polige Stiftleiste dafür verwenden, aus Platzgründen war dies jedoch nicht möglich. Die Hauptstromversorgung erfolgt über ein Steckernetzteil, welches eine Spannung von 12V über die Anschlüsse A1-A4 an die Schaltung liefert. Wegen der etwas höheren Ströme habe ich hier 2 Anschlüsse parallel geschaltet. Auch für den externen 5V-Schaltregler werden immer 2 Anschlüsse parallel geschaltet: So gelangen an A5-A8 die 12V zum Schaltregler und die erzeugten 5V kommen über A9-A12 zurück zur Schaltung. Ursprünglich sollte der 5V-Schaltregler direkt auf der Platine untergebracht werden, aber das würde wegen der relativ großen Bauteile recht eng werden, außerdem hätte man eine zusätzliche Wärmequelle am ohnehin schon recht warmen Raspberry Pi.

Die 12V werden von der Schaltung auch intern benötigt und an eine Transistor-Schaltstufe geführt, die aus den Bauteilen T1, T2 sowie R1-R3 besteht. Diese wird von der Nachtschaltung mit IC1 gesteuert und schaltet die 12V-Betriebsspannung für das Display. Das Display wird dann über die Anschlüsse B1-B2 mit Strom versorgt. Eine weitere identische Schaltstufe mit den Bauteilen T3, T4 sowie R4-R6 schaltet die 5V-Betriebsspannung für den Touchscreen-Controller. Diese wird dann an den Anschlüssen B3-B4 ausgegeben, wobei hier nur der Anschluss B3 verwendet wird.

Die Nachtschaltung besteht aus dem Mikrocontroller ATtiny45 (IC1), der über den Analogeingang PB4 (Pin 3) kontinuierlich die Helligkeit ermittelt. Dazu wird ein Fototransistor BPW42 (T5) verwendet, der an die Anschlüsse B7-B8 angeschlossen wird. Über das Trimmpoti R8 lässt sich die Nachtschaltung individuell anpassen. Bei Dunkelheit ist der Ausgang PB3 (Pin 2) auf Low-Pegel und die beiden Schaltstufen bleiben ausgeschaltet. Bei ausreichender Helligkeit schaltet PB3 auf High-Pegel und aktiviert damit die Schaltstufen. Damit bei einer Helligkeit im Grenzbereich keine ungewollten Schaltvorgänge stattfinden, wurden mehrere Maßnahmen getroffen. So werden zunächst mit dem Kondensator C3 Helligkeitsänderungen verzögert. Weiterhin liest die Software von IC1 mehrere Werte ein und bildet daraus einen Mittelwert und es wurden unterschiedliche Schwellwerte für das Ein- und Ausschalten festgelegt. So muss die Spannung an PB4 mindestens 1,1V zum Einschalten betragen, zum Ausschalten muss die Spannung den Wert von 0,9V unterschreiten. Schließlich sorgt noch ein Timer dafür, dass nach einem Schaltvorgang mindestens 30 Sekunden gewartet wird.

Übrigens, die Nachtschaltung ist nicht unbedingt erforderlich. Man kann die gesamte Schaltung weglassen (mit Ausnahme der Stromversorgung und des Reset-Tasters) und eine Art manuelle Nachtschaltung verwenden. Dazu muss eine Taste des Display-Bedienteils von außen zugänglich sein oder man schaltet einen zusätzlichen Taster parallel zum Bedienteil an. Damit ist es möglich, das Display ein- oder auszuschalten und den Stromverbrauch etwas zu reduzieren. Anstatt eines zusätzlichen Tasters kann auch eine Sensorfläche verwendet werden, die einen Schaltausgang mit offenem Kollektor oder Drain zur Verfügung stellt. Allerdings sollte man bedenken, dass nur das Display ausgeschaltet wird, der Touchscreen aber weiterhin aktiv bleibt und auf Berührungen reagiert.

Über die 40-polige Buchsenleiste J3 wird die Verbindung zum Raspberry Pi hergestellt. Über diese Leiste erfolgt auch die Stromversorgung für den Raspberry Pi. Dazu habe ich 3 Masse-Verbindungen über die Anschlüsse 6, 9 und 25 hergestellt und die 5V an die Anschlüsse 2 und 4 geführt. Weiterhin wurde noch der Anschluss 11 (GPIO 17) mit der Stiftleiste B5 verbunden. Hier kann ein Taster an B5-B6 angeschlossen werden, mit dem der Raspberry Pi bei Bedarf heruntergefahren werden kann (Poweroff). Die Nachtschaltung arbeitet übrigens vollkommen unabhängig vom Raspberry Pi und hat keine Verbindung zu diesem. Noch nicht erwähnt wurde die Stiftleiste J4, über diese kann der Mikrocontroller programmiert werden (ISP).

Der folgende Abschnitt beschreibt alle speziellen Kabelverbindungen, die für das Anzeigemodul 4 benötigt werden:

Schaltung 3 Dieses Bild zeigt das Stromversorgungskabel für das Anzeigemodul. Ich habe hier eine 4-polige Buchsenleiste über ein kurzes Kabel an 2 Schraubklemmen geführt. An diese Schraubklemmen wird später der 12V-Anschluss vom Steckernetzteil angeschlossen, nachdem das Gehäuse-Unterteil an der Wand montiert wurde. Möglich wäre hier auch ein Hohlstecker-Anschluss, der z.B. an der Gehäuse-Unterseite angebracht wird.

Schaltung 4 Dieses Bild zeigt die Kabelverbindung von der aufgesteckten Platine zum externen 5V-Schaltregler. Dieser Schaltregler ist als fertiges Modul recht günstig von verschiedenen Herstellern zu bekommen. Die Anschlussbelegung ist allerdings nicht bei allen Modulen gleich und muss dem Datenblatt entnommen werden. Bei dem von mir verwendeten Exemplar sind die Anschlüsse allerdings ordentlich beschriftet, so dass man sich sofort zurechtfindet.

Schaltung 5 Das Kabel auf diesem Bild sorgt für die Stromversorgung des Displays. Dem Display-Paket liegt ein kombiniertes Strom/Video-Kabel bei. Hier habe ich einfach die beiden Kabel abgeschnitten, so dass nur noch der 4-polige Stecker mit ungefähr 2cm langen Anschlüssen übrig bleibt. Dort wurde ein 2-poliges Litzenkabel angelötet (+12V an Pin 1, Masse an Pin 2 und 3) und mit Schrumpfschlauch fixiert. Der Videoanschluss 4 bleibt unbeschaltet, dieser wird hier nicht benötigt.

Schaltung 6 Das mitgelieferte USB-Anschlusskabel für den Touchscreen-Controller wurde ebenfalls radikal bearbeitet. Auch hier habe ich das Kabel so abgeschnitten, dass der 5-polige Stecker mit ungefähr 2cm langen Anschlüssen übrig bleibt. Das USB-Kabel wurde anschließend auf 30cm gekürzt, die Anschlüsse wieder mit dem Stecker verbunden und mit Schrumpfschlauch gesichert. Allerdings werden nur 4 Leitungen des USB-Kabels angeschlossen, der rote Anschluss von Pin 2 darf nicht mit dem USB-Kabel verbunden werden und wird über ein Litzenkabel an eine 2-polige Buchsenleiste geführt.

Schaltung 7 Dieses Bild zeigt das Anschlusskabel für den Poweroff-Taster.

Schaltung 8 Hier ist das Anschlusskabel für den Helligkeitssensor abgebildet.

Noch ein Hinweis zur Stromversorgung: Mein Anzeigemodul wurde mit einem Raspberry Pi 3 Model B Plus aufgebaut. Das dürfte der Raspberry Pi mit dem höchsten Strombedarf aus der Modellreihe 3 sein. Hier habe ich am fertigen Anzeigemodul am 12V-Anschluss folgende Stromwerte gemessen:

BedingungStrom bei 12V
Normalbetrieb bei Nacht (Display aus)0,35A (Mittelwert)
Normalbetrieb bei Tag (Display an)0,75A (Mittelwert)
Stresstest bei Tag (Display an)0,9A (Maximalwert)

Bei Verwendung eines Raspberry Pi 4 sollten sich ähnliche Werte ergeben, da sich der Energieverbrauch von Raspberry Pi 3B+ und Raspberry Pi 4 nicht wesentlich unterscheidet.
Wichtig: Bei Verwendung eines Raspberry Pi 4 ist ein anderes HDMI-Kabel (Micro-HDMI-Stecker auf Standard-HDMI-Stecker) erforderlich. Hier gibt es leider keine Empfehlung in der Stückliste.

SymbolHardware

Bild 1 Dieses Bild zeigt die Platine mit der Stromversorgung und der Nachtschaltung, welche später über die Buchsenleiste auf der linken Seite mit dem Raspberry Pi verbunden wird. Die rechte Seite ist für die Anschlüsse vorgesehen: Oben befindet sich der Anschluss A (J1) und unten der Anschluss B (J2), bei dem 4 Stifte nicht genutzt werden. Die Lücke zwischen den Stiftleisten ist notwendig, weil sich an dieser Stelle der HDMI-Anschluss das Raspberry Pi befindet und viel Platz für den großen Stecker benötigt wird. Bei Verwendung eines Raspberry Pi 4 müssen die Anschlüsse A und B möglicherweise anders platziert werden.

Alle elektronischen Bauteile auf der Platine gehören zur Nachtschaltung. Der ISP-Anschluss für den Mikrocontroller muss nicht unbedingt von außen zugänglich sein und wurde hier links neben den Mikrocontroller platziert.

Bild 2 Auf diesem Bild ist die Platine von unten zu sehen. Wie nicht anders zu erwarten, befinden sich hier viele Verbindungen mit Kupferdraht bzw. Kupferlackdraht. Das Trimmpoti für die Einstellung der Nachtschaltung musste auf dieser Platinenseite untergebracht und mit Zweikomponentenkleber befestigt werden, da auf der Bestückungsseite nicht genug Platz zur Verfügung steht. Die Position wurde so gewählt, dass die Einstellschraube später gut von der Gehäuse-Unterseite erreichbar ist. Die Anschlüsse A und B wurden beschriftet, um Verwechslungen auszuschließen. Weiterhin markiert ein schwarzer Punkt den Anschluss 1 der Stiftleisten.

Bild 3 Die meisten Komponenten des Anzeigemoduls werden in das Gehäuse-Unterteil eingebaut: der Raspberry Pi mit der aufgesteckten Platine, der 5V-Schaltregler, der Touchscreen-Controller, die Schraubanschlüsse für die 12V-Stromversorgung (hier noch nicht eingebaut) und der Poweroff-Taster. Da es innerhalb des Gehäuses recht warm wird, habe ich zur Luftzirkulation einige 6mm-Löcher am unteren und oberen Rand gebohrt. Bei einer Wandmontage sind die Löcher durch die besondere Gehäuseform relativ unauffällig.

Der Einbauplatz des Raspberry Pi ergibt sich durch seine Bauform. Die Anschlüsse oben und rechts müssen ins Gehäuse-Innere zeigen, weil hier das HDMI- und ein USB-Kabel angesteckt werden muss. Der microSD-Steckplatz zeigt nach unten, so dass durch einen passenden Ausschnitt im Gehäuse die Karte jederzeit zugänglich ist. Zur Befestigung des Raspberry Pi wurden 4 Schrauben M2,5 am Gehäuse-Unterteil angeklebt (2 kurze links und 2 lange rechts). Auf diese wurde jeweils eine Mutter geschraubt, dann der Raspberry Pi aufgesetzt und wiederum mit je einer Mutter vorsichtig festgeschraubt. Auf die längeren Schrauben rechts kommt wiederum eine Mutter, hier wird später die Platine für Stromversorgung und Nachtschaltung befestigt.

Der Touchscreen-Controller wird auf die gleiche Weise am Gehäuseboden befestigt, hier genügen 2 Schrauben M3. Auch hier befindet sich noch jeweils eine Mutter unter der Platine. Der 5V-Spannungsregler hat leider keine Befestigungslöcher, deshalb wurde er nach dem Anlöten der Kabelverbindungen einfach mit einem Powerstrip aufgeklebt. Der Poweroff-Taster wurde so in eins der Lüftungslöcher eingeklebt, dass er bündig mit dem Gehäuse abschließt.

Bild 4 Dieses Bild zeigt den Ausschnitt für die SD-Karte und den Poweroff-Taster. Ich habe hier einen Taster verwendet, der gerade vorhanden war. Die Stückliste enthält eine alternative Empfehlung. Übrigens, durch das Loch rechts neben der SD-Karte sind die beiden LEDs des Raspberry Pi zu sehen. Damit lässt sich auch bei geschlossenem Gehäuse der Status des Raspberry Pi erkennen.

Bild 5 Auf diesem Bild wurde die Platine mit den Bauteilen für Stromversorgung und Nachtschaltung auf den Raspberry Pi aufgesteckt und mit 2 Muttern gesichert. An den beiden Steckverbindern A und B sind bereits alle Komponenten des Gehäuse-Unterteils angeschlossen (12V-Stromanschluss, 5V-Schaltregler, Touchscreen-Controller und Poweroff-Taster).

Hinweis: Die verwendeten Steckverbinder J1 und J2 (A und B) sind nicht unbedingt die beste Wahl. Die Anschlüsse können leicht vertauscht und sogar verkehrt herum aufgesteckt werden. Aus diesem Grund habe ich jeden Anschluss eindeutig beschriftet.

Bild 6 Die Innenseite des Gehäuse-Oberteils wird fast komplett vom Display ausgefüllt. Bevor das Display ins Gehäuse eingesetzt und befestigt wird, sollte die Controller-Platine mit dem Display mechanisch und elektrisch verbunden werden. Ich habe dafür 4 M3-Schrauben und jeweils eine Mutter an die Rückseite des Displays geklebt. Anschließend wurde die Controller-Platine aufgesetzt und wiederum mit 4 Muttern festgeschraubt. Man sollte unbedingt kontrollieren, dass die Platine (insbesondere die Anschlüsse der DVI- und VGA-Buchse) genügend Abstand zum Display haben und gegebenenfalls etwas isolierendes unterlegen. Die optimale Position der Platine ergibt sich übrigens durch das Folienkabel auf der einen und durch den HDMI-Winkel-Adapter auf der anderen Seite. Hinweis: Möglicherweise erlischt bei dieser Art der Befestigung die Garantie für das Display-Set.

Das Bedienteil wird eigentlich nur einmal zur Einstellung des Displays benötigt. Aus diesem Grund habe ich es mit einem Powerstrip auf die Display-Rückseite geklebt. Falls man auf die Nachtschaltung verzichten und stattdessen das Display manuell schalten möchte, dann gibt es 2 Möglichkeiten: Entweder baut man das Bedienteil so ein, dass die Taster von außen zugänglich sind (hier bietet sich die Unterseite des Gehäuses an) oder man lötet 2 Drähte an die Anschlüsse des Power-Tasters und führt diese an einen zugänglichen Taster bzw. verbindet diese mit einem Berührungssensor.

Vor dem Einbau der Display-Einheit wurde entlang des Gehäuseausschnitts (hier nicht sichtbar) 1mm-Moosgummi aufgeklebt. An der Unterseite ist der Abstand zwischen Gehäuse und Display etwas größer, hier besteht der Moosgummi-Rand aus 2 Schichten. Nachdem das Display optimal im Gehäuse-Oberteil lag, habe ich es unten mit 2 kleinen Holzklötzen und oben mit 2 Plastikstreifen festgeklebt. Die Klebestelle ist dabei nur am Gehäuse, nicht am Display selbst. Zur Not lassen sich diese Halterungen vorsichtig wieder ausbrechen, ohne dass Display und Gehäuse dabei Schaden nehmen.

Zu erwähnen wäre noch das schmale Folienkabel für den Touchscreen, das hier mit dem Verbindungskabel zum Touchscreen-Controller verbunden wurde. Damit das empfindliche Folienkabel nicht beschädigt wird, habe ich das Verbindungskabel mit etwas Kleber am linken Holzklotz fixiert. Ganz oben links befindet sich noch der Fototransistor für die Nachtschaltung. Für diesen wurde zunächst ein 3mm Loch gebohrt und anschließend der Fototransistor eingeklebt.

Nach dem Zusammenbau des Anzeigemoduls fiel mir auf, dass das Licht der Display-Beleuchtung an den Seiten des Metallrahmens austritt und somit auch durch die oberen Lüftungslöcher zu sehen ist. Hier habe ich später noch einige Moosgummi-Stücke auf den oberen Rand aufgeklebt.

Bild 7 Dieses Bild zeigt die beiden Folienkabel noch einmal im Detail. Beide Kabel sind sehr empfindlich und sollten sehr vorsichtig behandelt werden. Während das Folienkabel zum Display nur in eine Richtung in den Steckverbinder passt, lässt sich das Touchscreen-Kabel auch verkehrt herum anschließen. In einem solchen Fall geht nichts kaputt, nur der Touchscreen funktioniert möglicherweise nicht richtig. Bei der Inbetriebnahme kann man das aber erkennen und gegebenenfalls korrigieren.

Bild 8 Für den Fototransistor sollte man eine Stelle wählen, die das Licht im Raum gut erfasst. Bei meinem Anzeigemodul ist diese Stelle oben rechts.

Bild 9 Dieses Bild zeigt die vollständige Verkabelung zwischen den beiden Gehäuseteilen. Das sieht ziemlich schlimm aus, lässt sich aber nicht wirklich vereinfachen. Im nächsten Schritt werden die Gehäuseteile zusammengefügt, wobei man gut aufpassen muss, dass keine Kabel geknickt oder eingeklemmt werden. Ansonsten steht innerhalb des Gehäuses genug Platz für die Kabel zur Verfügung.

Beim „Verheiraten“ der Gehäuseteile legt man diese einfach übereinander, wobei das Oberteil etwa 5mm tiefer liegen muss. Danach sollte man über die Schlitze und Lüftungslöcher noch einmal den Innenraum kontrollieren und wenn alles ordentlich verstaut ist, schiebt man das Oberteil nach oben und das Gehäuse fügt sich zusammen. Wenn das Gehäuse später an der Wand montiert ist, werden von unten zwei der beiliegenden Schrauben eingedreht.

Bild 10 Hier wurde das Anzeigemodul 4 komplett zusammengebaut und an der Wand montiert. Leider ist das Foto nicht besonders gut gelungen. In der Realität sieht das Display besser aus und die Farben sind kräftiger.

SymbolSoftware

Dieser Abschnitt beschreibt in Kurzform die verwendeten Software-Komponenten des Raspberry Pi und die Funktion der Mikrocontroller-Software.

Symbol Software des Raspberry Pi

Die Software des Anzeigemoduls besteht aus fertigen Anwendungen, die zum Teil für die Verwendung als Anzeigemodul konfiguriert werden müssen. Die Basis-Komponente ist das Betriebssystem Linux, welches hier in der Variante Raspberry Pi OS with desktop verwendet wird. Dieses umfasst einen grafischen Desktop und eine Auswahl an Software-Paketen. Für die Erfassung und Aufbereitung der anzuzeigenden Daten wird zusätzlich die Software Node-RED installiert. Diese ermöglicht die flexible Gestaltung der Anzeige durch fertige Funktionselemente (Nodes), die auf einfache Weise virtuell zusammengeschaltet werden können. Dabei stehen zur Darstellung von Sensorwerten und anderen Informationen verschiedene Anzeigeelemente und Diagramme zur Verfügung. Als letzte größere Software-Komponente wird noch ein Web-Browser benötigt, der die von Node-RED generierten Informationen anzeigt. Hier bietet sich der bereits installierte Chromium-Browser an. Dieser wird in einem speziellen Modus betrieben, der Titel- sowie Menü-Leisten ausblendet und nur den Fensterinhalt darstellt (Kiosk-Modus). Ein kleines, aber trotzdem nützliches Programm soll auch noch erwähnt werden: unclutter kümmert sich um den Mauspfeil und blendet diesen nach einigen Sekunden aus, wenn keine Eingabe erfolgt. Damit besteht das angezeigte Bild nur noch aus dem Node-RED-Dashboard und es ist nicht als Browserfenster zu erkennen. Wenn das Anzeigemodul 4 zur Steuerung anderer Komponenten verwendet werden soll, dann kann eine Touchscreen-Eingabe konfiguriert werden. Diese erfordert zusätzlich eine Art Treiber-Software und das Programm xinput-calibrator zum komfortablen Testen und Kalibrieren des Touchscreens.

Da das hier verwendete Raspberry Pi OS with desktop schon einen großen Teil der benötigten Programme mitbringt und auch kaum spezielle Programme benötigt werden, ist die Inbetriebnahme nicht so aufwändig wie beispielsweise beim Web-Modul. Allerdings startet Node-RED zunächst mit einer leeren Konfiguration. Um das Node-RED-Dashboard mit Leben zu füllen, muss jeder selbst tätig werden und die gewünschten Anzeigen erstellen. Im Abschnitt Konfiguration beschreibe ich mit einigen Beispielen viele Elemente (Nodes), die ich für mein Projekt verwendet habe. Diese dürfen gern für das eigene Projekt verwendet und angepasst werden.

Übrigens: Das Anzeigemodul 4 kann nur zusammen mit einem bereits vorhandenen Web-Modul betrieben werden, da es auf dessen MQTT-Server zugreift. Grundsätzlich kann man den MQTT-Server mosquitto auch auf dem Anzeigemodul 4 installieren, allerdings sollte man das Anzeigemodul dann besser über LAN mit dem Heimnetz verbinden.

Nochmal übrigens: Obwohl auf dem Web-Modul bereits Node-RED verwendet wird, benutzt das Anzeigemodul eine eigene Node-RED-Installation. Damit lässt sich ein spezielles Dashboard erstellen, welches auf Menüs verzichtet und für das Anzeigemodul 4 optimiert werden kann.

Symbol Software des Mikrocontrollers

Die Nachtschaltung des Anzeigemoduls 4 wird von einem Mikrocontroller ATtiny45 gesteuert. Die Software dafür wurde in C geschrieben und ist relativ einfach aufgebaut. Nach der Initialisierung der IO-Ports, eines Timers und des AD-Wandlers startet das Hauptprogramm. Dieses arbeitet in einer endlosen Schleife und berechnet zunächst einen Mittelwert aus den letzten 16 Helligkeitswerten. Anschließend wird in 2 Vergleichen geprüft, ob der Schwellwert zum Ein- oder Ausschalten über- bzw. unterschritten wurde. Zusätzlich wird durch Prüfen des aktuellen Status festgestellt, ob überhaupt eine Umschaltung erforderlich ist. Außerdem wird noch ein Sperrzeit-Zähler geprüft und gegebenenfalls mit dem Schaltvorgang gewartet. Sind alle Bedingungen zum Umschalten erfüllt, dann wird der Schaltausgang PB3 entsprechend umgeschaltet und der Sperrzeit-Zähler neu gestartet.

Neben der Hauptprogrammschleife läuft ein Timer im Hintergrund und löst jede Millisekunde einen Interrupt aus. Dabei wird ein Millisekunden-Zähler erhöht und nach 1000 Durchläufen der erwähnte Sperrzeit-Zähler bearbeitet. Weiterhin wird alle 10 Interrupts der AD-Wandler zur Messung der Helligkeit gelesen und fortlaufend in einem Feld mit 16 Plätzen gespeichert. Dieses Feld nutzt das Hauptprogramm zur Ermittlung eines Mittelwertes.

Der Aufwand mit den unterschiedlichen Schwellwerten und dem Sperrzeit-Zähler hat folgenden Hintergrund: Es sollen unnötige Schaltvorgänge verhindert und somit die Display-Einheit geschont werden. Diese benötigt ungefähr 15 Sekunden für den Einschaltvorgang und in diesem Zeitraum sollte keine Abschaltung erfolgen. In der Nachtschaltung sind folgende Regeln festgelegt: Beim Systemstart wird die Display-Einheit und auch der Touchscreen-Controller unabhängig von der Helligkeit eingeschaltet und für 90 Sekunden gesperrt. Erst danach beginnt die Nachtschaltung mit der Arbeit. Diese überwacht die Helligkeit und startet zeitgleich bei jedem Ein- oder Ausschaltvorgang eine Sperre von 30 Sekunden. Erst nach Ablauf des Sperrzeit-Zählers sind dann weitere Schaltvorgänge möglich.

SymbolInbetriebnahme

Für den Aufbau des Anzeigemoduls 4 müssen einige Kabel der Display-Einheit modifiziert werden. Da dies möglicherweise mit einem Garantieverlust verbunden ist, sollte die erste Inbetriebnahme mit den unveränderten Originalteilen erfolgen. Dazu wird zunächst das Display zusammengefügt: Auf das Display-Panel (mit dem „Gesicht“ nach unten) wird ein Stück Pappe zur Isolierung und dann die Controller-Platine gelegt. Danach kann das Folienkabel vorsichtig verbunden werden. Anschließend werden alle anderen Kabel angeschlossen: Strom/Video-Kabel, Bedienteil, HDMI-Kabel und Touchscreen-Kabel. Jetzt kann man die gesamte Einheit vorsichtig umdrehen. Als nächstes wird das HDMI-Kabel und das USB-Kabel des Touchscreen-Controllers mit dem Raspberry Pi verbunden. Weiterhin wird vorübergehend ein passendes Raspberry-Pi-Netzteil benötigt und ebenfalls angeschlossen (mit Micro-USB-Anschluss für Raspberry Pi 3 oder mit USB-C-Anschluss für Raspberry Pi 4). Noch nicht benötigt werden die Aufsteckplatine für Stromversorgung und Nachtschaltung sowie der 5V-Schaltregler.

Mit diesem provisorischen Test-Aufbau sollte die gesamte Raspberry-Pi-Software installiert werden. Damit kann man prüfen, ob alle Komponenten der Display-Einheit inklusive Touchscreen funktionieren und der Raspberry Pi wird dabei natürlich auch getestet. Wenn alles wie gewünscht funktioniert, kann die Platine für die Stromversorgung und Nachtschaltung aufgebaut werden. Die Platine ist übrigens auch dann notwendig, wenn man keine Nachtschaltung verwenden möchte. In diesem Fall werden nur die Steckverbinder J1-J3 aufgelötet und die notwendigen Drahtverbindungen für die 12V und 5V hergestellt. Nach Fertigstellung der Platine (egal ob mit Nachtschaltung oder ohne) muss diese zunächst ohne Verbindung zum Raspberry Pi und auch ohne Mikrocontroller in Betrieb genommen werden. Dazu wird der 5V-Schaltregler und das 12V-Netzteil an den Steckverbinder A (J1) angeschlossen und das Netzteil eingeschaltet. Auf der Platine wird nun zunächst die Spannung vom Netzteil (12V) kontrolliert und anschließend die vom Schaltregler gelieferte Spannung. Diese sollte über das Trimmpoti auf dem Schaltregler auf 5,1V eingestellt werden.

Die Spannung vom Netzteil wird nun wieder ausgeschaltet, der Mikrocontroller aufgesteckt und ein AVR-Programmiergerät an J4 angeschlossen. Die Platine bleibt dabei weiterhin vom Raspberry Pi getrennt. Anschließend wird das Programmiergerät mit einem PC verbunden und die Stromversorgung eingeschaltet. Das Paket am4-attiny45-v100.zip enhält den kompletten Quelltext in C und auch die fertige Hex-Datei für den Mikrocontroller. Letztere ist im Verzeichnis Nachtschaltung/Nachtschaltung/Release/ als Nachtschaltung.hex zu finden. Diese Datei muss in den Flash-Speicher des Mikrocontrollers übertragen werden. Weiterhin ist noch die richtige Einstellung der Fuse-Bits notwendig. Für beide Tätigkeiten empfehle ich das Programmiergerät mySmartUSB light. Eine Anleitung dafür findet man auf der Seite AVR-Programmierung.

Fuse-Bits Dieses Bild zeigt die optimale Einstellung der Fuse-Bits im Microchip Studio 7 (das frühere Atmel Studio 7), welches ich für die Erstellung der Software verwendet habe. Wird eine andere Software wie z.B. das myAVR ProgTool verwendet, dann kann die richtige Einstellung über die folgenden 3 Bytes festgelegt werden:

EXTENDED = 0xFF
HIGH = 0xDC
LOW = 0x62

War die Übertragung der Hex-Datei und die Einstellung der Fuse-Bits erfolgreich, dann wird die Stromversorgung wieder ausgeschaltet und das Programmiergerät entfernt. Die Platine ist jetzt fertig und kann auf den Raspberry Pi aufgesteckt werden. Jetzt ist ein guter Zeitpunkt zur Herstellung der noch fehlenden Kabel und auch zur Modifizierung des Kabels für die Display-Stromversorgung und des USB-Kabels für den Touchscreen-Controller. Anschließend kann das gesamte Anzeigemodul 4 verkabelt werden und nach einem finalen Funktionstest können alle Komponenten ins Gehäuse eingebaut werden.

Die folgende Anleitung beschreibt die Inbetriebnahme des Raspberry Pi sowie die Installation und Konfiguration der notwendigen Software-Komponenten. Ich habe diese Anleitung (so wie bei den anderen Raspberry-Pi-Projekten auch) in mehrere Schritte unterteilt. Beim Abarbeiten sollte erst dann mit dem nächsten Schritt begonnen werden, wenn der vorherige erfolgreich abgeschlossen wurde. Grundsätzlich ist sorgfältiges Arbeiten notwendig, insbesondere dann, wenn Systemdateien bearbeitet werden müssen. Ein kleiner Fehler kann durchaus dazu führen, dass das System nicht mehr richtig funktioniert oder gar nicht mehr startet. Es empfiehlt sich, die teilweise recht langen Kommandozeilen in die Zwischenablage zu kopieren und dann im Terminalfenster einzufügen. Wichtig: Immer nur eine Zeile kopieren und erst nach dem erfolgreichen Ausführen eines Kommandos die nächste Zeile holen. Nur beim Bearbeiten von Dateien können mehrere Zeilen gleichzeitig in den Editor übertragen werden. Falls trotz aller Vorsicht das System Probleme macht, dann sollte man nicht lange nach dem Fehler suchen und einfach noch mal von vorn beginnen.

Ich gehe davon aus, dass ein Windows-PC zur Verfügung steht, mit dem die vorbereitenden Arbeiten durchgeführt werden. Diese Arbeiten können selbstverständlich auch mit Linux erledigt werden, diesen Weg habe ich aber nicht getestet. Weiterhin werden alle Einstellungen für eine deutsche Sprachversion beschrieben. Soll ein Anzeigemodul in einer anderen Sprachversion installiert werden, dann sind abweichende Eingaben erforderlich. Die Beschreibung ist an vielen Stellen sehr knapp gehalten, da der Text sonst zu umfangreich geworden wäre. Bei einigen Schritten habe ich die verwendeten Quellen angegeben. Einige weitere Informationen über den Raspberry Pi, Linux, Perl, HTML, PHP, JavaScript und Node-RED habe ich auf der Seite Links, Software zusammengestellt.

Wichtig: Bitte niemals den Raspberry Pi einfach ausschalten, sondern immer über das Kommando sudo poweroff herunterfahren. Kurze Zeit später blinkt die grüne LED 10 mal und anschließend kann der Strom sicher abgeschaltet werden. Zwar überlebt die Linux-Installation in den meisten Fällen eine Stromunterbrechung, aber es besteht immer die Gefahr, dass Dateien irreparabel beschädigt werden. Übrigens, wenn das Anzeigemodul fertig konfiguriert ist, dann kann durch Drücken des Poweroff-Tasters für 2 Sekunden das System heruntergefahren werden.

Symbol Schritt 1 - Betriebssystem vorbereiten

Für die Inbetriebnahme eines neuen Anzeigemoduls ist zunächst ein Betriebssystem für den Raspberry Pi notwendig. Dieses kann man als Image-Datei downloaden und mit einer geeigneten Software auf eine microSD-Karte schreiben. Diese Karte wird dann in den Raspberry Pi gesteckt und dient sozusagen als Festplatte. Als Betriebssystem hat sich das von der Raspberry Pi Foundation empfohlene Linux-System Raspberry Pi OS bewährt. Von den angebotenen 3 Versionen wird hier die Standard-Version verwendet. Diese beinhaltet einen grafischen Desktop und eine Auswahl an vorinstallierten Software-Paketen. Die microSD-Karte sollte mindestens 8GB groß sein. Da die kleineren Speichergrößen allmählich vom Markt verschwinden und 16GB-Karten deutlich günstiger geworden sind, sollte man eine solche verwenden. Bei der Wahl der Geschwindigkeitsklasse empfehle ich eine Class-10-Karte. Falls der verwendete Kartenleser des PCs keinen microSD-Steckplatz besitzt, dann wird noch ein Adapter auf Standard-SD benötigt.

Vorab noch ein wichtiger Hinweis: Es kann passieren, dass Windows 10 beim Einlegen oder Erzeugen einer SD-Karte mit Linux-System das Formatieren oder Reparieren des Datenträgers anbietet. Diese Fenster bitte immer mit der Option Abbrechen schließen.

Nachfolgend stelle ich 2 Programme vor, mit denen die SD-Karte für den Raspberry Pi vorbereitet werden kann. Beide Programme sind nicht ganz ungefährlich und überschreiben gnadenlos alle Daten auf dem ausgewählten Datenträger. Damit kein falscher Datenträger gelöscht wird, sollte man vor dem Programmstart nur die für den Raspberry Pi bestimmte SD-Karte anschließen und alle nicht benötigten Wechseldatenträger vom PC entfernen. So steht den Programmen nur noch unsere SD-Karte als Ziel zur Verfügung und die Gefahr ist gebannt. Beide Programme haben übrigens eine ähnliche Funktionalität. Benötigt wird nur eins von beiden, aber es spricht auch nichts dagegen, beide zu installieren.

Raspberry Pi Imager Das nebenstehende Bild zeigt den Raspberry Pi Imager bei der Arbeit. Dieser wird von der Raspberry Pi Foundation angeboten (https://www.raspberrypi.org/software/) und hat den Vorteil, dass man das benötigte Betriebssystem einfach aus einem Menü auswählen kann. Der Imager lädt dann automatisch die aktuelle Version vom Server und schreibt diese auf die SD-Karte. Die Auswahl des Systems erfolgt über einen Klick auf den linken Button OS wählen. Hier wählt man den obersten Eintrag Raspberry Pi OS (32-bit) aus. Über den mittleren Button SD-Karte wählen wird nun das Laufwerk ausgewählt, in dem die SD-Karte steckt. Wenn man sich absolut sicher ist, dass alle Einstellungen passen, wird der Button Schreiben geklickt. Jetzt startet der Imager den Download und schreibt gleichzeitig das Image auf die Karte. Im Anschluss daran wird noch eine Verifizierung durchgeführt, dabei wird die Karte ausgelesen und mit dem Image verglichen.

Der gesamte Vorgang kann recht lange dauern und man hat den Eindruck, der Schreibvorgang ist ungewöhnlich langsam. Das liegt daran, dass im Hintergrund noch der Download läuft und nur die bereits empfangenen Daten geschrieben werden können. Das ist also völlig normal. Wenn der Imager mit seiner Arbeit fertig ist, erscheint eine Erfolgsmeldung. Die SD-Karte kann nun entnommen werden, da sie automatisch vom System abgemeldet wurde. Danach sollte sie jedoch wieder gesteckt werden, da noch 2 Dateien ergänzt werden müssen. Die weitere Beschreibung folgt etwas weiter unten bei WLAN und SSH aktivieren.

Win32 Disk Imager Vor der Entwicklung des Raspberry Pi Imagers wurde der Win32 Disk Imager zur Erstellung von SD-Karten empfohlen und dieser ist noch immer eine gute Alternative. Bevor dieser seine Arbeit wie im nebenstehenden Bild erledigen kann, muss zunächst die gewünschte Image-Datei beschafft werden. Dazu wird die Download-Seite der Raspberry Pi Foundation aufgesucht und die aktuelle Version von Raspberry Pi OS with desktop als Zip-Datei geladen und entpackt. Nach dem Start des Imagers kann man bei Image File über das kleine Ordner-Symbol das Image auswählen und im Feld Device sollte der Laufwerks-Buchstabe unserer SD-Karte stehen. Wenn man sich bei der Auswahl absolut sicher ist, dann wird über den Button Write der Schreibvorgang gestartet. Das dauert einige Minuten und wenn alles geklappt hat, erscheint eine Erfolgsmeldung. Die SD-Karte muss noch am PC angeschlossen bleiben, denn es müssen noch 2 Dateien auf die Karte geschrieben werden.

Übrigens, der Win32 Disk Imager ist auch später noch sehr nützlich, denn man kann damit auch SD-Karten auslesen und somit jederzeit ein komplettes Backup vom System anfertigen und bei Bedarf auch wieder auf die Karte zurückschreiben. Weitere Informationen sind im Abschnitt Wartung zu finden.

WLAN und SSH aktivieren: Die gesamte Software-Installation auf dem Raspberry Pi soll ohne Eingabegeräte (Tastatur und Maus) erfolgen. Dafür ist es notwendig, den SSH-Dienst auf dem Raspberry Pi zu aktivieren. Außerdem müssen wir dem System die WLAN-Zugangsdaten mitteilen, damit sich dieses sofort beim ersten Start mit unserem WLAN verbinden kann. Das bereits verwendete Paket am4-attiny45-v100.zip enthält neben der Mikrocontroller-Software auch ein Verzeichnis mit 2 Dateien, die auf die SD-Karte kopiert werden müssen:

Raspberry Pi\sshDiese Datei dient zur Aktivierung der SSH-Funktion.
Raspberry Pi\wpa_supplicant.confDiese Datei enthält die Zugangsdaten für das WLAN (SSID und Passwort).

Unter Windows ist ein kleiner Bereich der SD-Karte als Laufwerk sichtbar und hier sind bereits einige Systemdateien zu sehen. Dort kopieren wir die beiden Dateien hin. Während bei der Datei ssh kein weiterer Handlungsbedarf besteht, muss die Datei wpa_supplicant.conf auf der Speicherkarte noch bearbeitet werden (z.B. mit dem Editor von Windows). Hier müssen die Beispiel-Einträge der folgenden beiden Zeilen mit den richtigen Zugangsdaten für das WLAN ausgefüllt werden (bitte nicht die Anführungszeichen entfernen):

ssid="Mein_WLAN"
psk="Mein_WLAN_Passwort"

Nach dem Speichern der geänderten wpa_supplicant.conf wird die nun fertige SD-Karte über die „Auswerfen“-Funktion auf der Windows-Taskleiste vom System abgemeldet und in den Raspberry Pi gesteckt. Jetzt wird die Stromversorgung des Anzeigemoduls eingeschaltet und der Raspberry Pi sollte booten, was man durch das angeschlossene Display gut beobachten kann, allerdings erst nach ungefähr 15 Sekunden. Solange benötigt das Display für seinen Startvorgang. Der erste Start des Linux-Systems dauert etwas länger, anschließend sollte aber der Linux-Desktop und ein Fenster mit einem Warnhinweis erscheinen. Das Bild ist noch nicht optimal, weil die Display-Auflösung nicht stimmt und der Touchscreen hat auch noch keine Funktion. Wichtig ist das WLAN-Symbol auf der Titelzeile oben rechts, dieses muss dauerhaft aktiv sein.

Symbol Schritt 2 - Verbindung mit dem Raspberry Pi herstellen

Das Raspberry Pi OS ist so konfiguriert, dass der Raspberry Pi über DHCP vom Router des Heimnetzwerks eine IP-Adresse zugewiesen bekommt. Diese Adresse muss jetzt ermittelt werden und dafür kann man sich entweder in den Router einloggen oder das Freeware-Programm Angry IP Scanner verwenden, welches alle Geräte im Heimnetz anzeigt. Jetzt wird noch ein SSH-Client auf dem PC benötigt, damit wir eine Verbindung zum Raspberry Pi aufbauen können. Ich habe mich hier für das Freeware-Programm PuTTY entschieden. Die Bedienung ist auch nicht kompliziert: In das Feld Host Name kommt die ermittelte IP-Adresse des Raspberry Pi, als Beispiel verwende ich hier 192.168.1.14 und im Feld Port steht schon die richtige Nummer 22. Mit einem Klick auf Open wird die Verbindung aufgebaut. Zunächst erscheint jedoch eine Sicherheitswarnung. PuTTY speichert von jedem Server eine Art Fingerabdruck und prüft diesen bei jedem Verbindungsaufbau. So kann man vor dem Login erkennen, ob man mit dem richtigen Server verbunden ist. Von unserem Raspberry Pi liegt dieser Fingerabdruck noch nicht vor und wir haben jetzt die Möglichkeit, mit einem Klick auf Ja den Fingerabdruck zu speichern. Jetzt erscheint die folgende Eingabezeile:

login as: _

Hier geben wir den Benutzernamen pi ein. Anschließend erscheint eine Passwortabfrage, die in unserem Beispiel so aussehen würde:

pi@192.168.1.14's password: _

Hier geben wir das voreingestellte Passwort raspberry ein. Wenn alles geklappt hat, dann erscheinen einige Informationen und zum Schluss der folgende Eingabe-Prompt:

pi@raspberrypi:~ $ _

Sollte PuTTY keine Verbindung zum Raspberry Pi herstellen können, dann kann man zunächst an der Windows-Kommandozeile (cmd.exe) einen Ping versuchen:

ping 192.168.1.14

Damit lässt sich prüfen, ob eine Netzwerkverbindung zur angegebenen IP-Adresse vorhanden ist. Wenn die IP-Adresse richtig ist und der Ping funktioniert, die SSH-Verbindung jedoch nicht, dann wurde offensichtlich der SSH-Server auf dem Raspberry Pi nicht aktiviert. In diesem Fall sollte man den Raspberry Pi wieder ausschalten und nochmals mit dem Schritt 1 beginnen.

Wenn alles geklappt hat, dann kann man noch etwas an der Optik von PuTTY arbeiten. Dazu klickt man auf das kleine Symbol links oben auf der Titelzeile und wählt die Option Change Settings... aus. Hier habe ich in der Kategorie Window die vorgegebene Fenstergröße von 80x24 auf 120x32 vergrößert, damit mehr Informationen im Terminalfenster zu sehen sind. Auch der Zeichensatz ist nicht optimal, diesen kann man in der Kategorie Window - Appearance und Change... ändern, z.B. auf Consolas, 12-point. Alle Einstellungen lassen sich natürlich auch speichern, dies erfolgt in der Kategorie Session. Hier gibt man einen passenden Namen in das Feld Saved Sessions ein und klickt auf Save. Mit Apply wird das Einstellungsfenster wieder geschlossen und zum Terminalfenster zurückgekehrt. Wird PuTTY später erneut gestartet, dann lässt sich die soeben gespeicherte Session durch einen Doppelklick auf den Namen wieder aufrufen.

Symbol Schritt 3 - Betriebssystem konfigurieren

Nachdem PuTTY nun optimal eingerichtet ist, werden wir mit dessen Hilfe das Raspberry Pi OS konfigurieren. Dafür werden Kommandos verwendet, die direkt am Eingabe-Prompt eingegeben werden müssen. Diese Kommandos können durchaus recht lang sein und da bietet es sich an, diese hier im Browser zu markieren und in die Zwischenablage zu kopieren. Im Terminalfenster von PuTTY kann man dann den Inhalt der Zwischenablage mit der rechten Maustaste an der aktuellen Cursor-Position einfügen. Alle Eingaben am Prompt werden außerdem vom Raspberry Pi OS in einer Historie gespeichert. Mit den Pfeiltasten nach oben und unten kann man durch diese Historie blättern und so ein bestimmtes Kommando nochmals an den Eingabe-Prompt holen. Weiterhin beherrscht Linux eine sehr gute Autovervollständigung, die man mit der Tabulator-Taste auslösen kann. Kommandos, Verzeichnisnamen und teilweise auch Parameter werden dann ergänzt, soweit dies möglich ist.

Wir geben nun das erste Kommando ein oder kopieren es über die Zwischenablage ins Terminalfenster:

sudo raspi-config

Damit wird das Programm raspi-config gestartet, welches eine menügeführte Einstellung vieler Systemfunktionen ermöglicht. Einige Einstellungen erfordern erweiterte Rechte, diese werden mit dem vorangestellten sudo gewährt. Ist das Programm gestartet, dann werden hauptsächlich die Pfeiltasten, die Tabulator-Taste und Enter verwendet. Los geht's:

Damit sind die wichtigsten Systemeinstellungen für das Anzeigemodul 4 erledigt. Wir wechseln nun mit Tab auf Finish und drücken Enter. Danach erscheint ein Fenster, in dem ein Reboot angeboten wird, dieses bestätigen wir mit Yes und Enter. Der Raspberry Pi startet nun neu und trennt dabei die SSH-Verbindung. PuTTY zeigt diesen Zustand mit einer Fehlermeldung an. Wir warten nun, bis der Desktop (der jetzt sauber mit der richtigen Auflösung dargestellt werden sollte) wieder erscheint und bauen die Verbindung wieder auf. Dazu quittieren wir die Fehlermeldung von PuTTY und klicken anschließend auf das kleine Symbol links oben auf der Titelzeile. In dem nun erscheinenden Menü wählen wir Restart Session aus. Es folgt nun wieder die Abfrage von Benutzername und Passwort, wobei ab jetzt das neue Passwort verwendet werden muss. Sollte an dieser Stelle die Verbindung nicht wieder hergestellt werden können, dann hilft ein Blick auf das Display: Das WLAN-Symbol muss dauerhaft aktiv sein und die IP-Adresse im Welcome-Fenster sollte kontrolliert werden. Hat sich diese geändert, dann muss man PuTTY beenden, neu starten und eine Verbindung zur neuen IP-Adresse herstellen.

Symbol Schritt 4 - Netzwerk konfigurieren (optional)

Grundsätzlich ist das Netzwerk des Raspberry Pi bereits konfiguriert und zwar so, dass der Raspberry Pi beim Systemstart vom Router des Heimnetzwerks über DHCP eine IP-Adresse zugewiesen bekommt (dynamische IP-Adresse). Das hat leider den Nachteil, dass die IP-Adresse nicht vorhersehbar ist und sich auch jederzeit ändern kann. Zwar erkennen viele Router-Modelle den Raspberry Pi nach einem Neustart wieder und vergeben die gleiche IP-Adresse, trotzdem bietet eine statische Adresse einige Vorteile. So ist das zukünftige Anzeigemodul immer unter der gleichen IP-Adresse erreichbar und diese Adresse können wir in gewissen Grenzen selbst festlegen.

Zur Vergabe einer statischen Adresse sind 3 Parameter notwendig: die IP-Adresse, die Subnetz-Maske und das Gateway. Mit dem folgenden Kommando kann man sich einige Parameter des Netzwerks anschauen:

netstat -rn

Unsere Beispiel-Konfiguration würde dann folgendes Bild ergeben:

Kernel-IP-Routentabelle
Ziel            Router          Genmask         Flags   MSS Fenster irtt Iface
0.0.0.0         192.168.1.1     0.0.0.0         UG        0 0          0 eth0
192.168.1.0     0.0.0.0         255.255.255.0   U         0 0          0 eth0

Das sind typische Werte in einem Heimnetz und hier kann man bereits zwei Parameter entnehmen: Die Subnetz-Maske ist 255.255.255.0 und das Gateway (Adresse des Routers) 192.168.1.1. Nun muss noch die IP-Adresse festgelegt werden, wobei die ersten 3 Teile mehr oder weniger vom Router vorgegeben sind (192.168.1). Den 4. Teil der Adresse können wir aber selbst bestimmen und hier ist es wichtig, dass dieser nicht bereits von einem anderen Gerät im Netz verwendet wird und auch nicht im DHCP-Bereich des Routers liegt. Diese Informationen kann man normalerweise aus dem Router auslesen. Meist sind die Adressen ab 201 frei und so verwende ich bei der folgenden Konfiguration beispielhaft die IP-Adresse 192.168.1.224.

Um eine statische IP-Adresse festzulegen, ist das Bearbeiten einer Konfigurationsdatei des Linux-Systems erforderlich. Hier bietet sich der vorinstallierte Texteditor nano an. Dieser ist nicht schwer zu bedienen, allerdings sind die Funktionen für den Windows-Benutzer etwas ungewohnt. Aber so viele Funktionen muss man sich gar nicht merken, wichtig ist Strg-S zum Speichern einer Datei und Strg-X zum Beenden des Editors. Mit dem folgenden Kommando wird der Texteditor mit erweiterten Rechten gestartet und die zu bearbeitende Konfigurationsdatei geöffnet:

sudo nano /etc/dhcpcd.conf

Wir bewegen nun mit den Pfeiltasten den Cursor an das Ende der Datei und fügen die folgenden Zeilen ein (ich benutze hier die Daten von unserem Beispiel). In diesem Fall können übrigens alle 4 Zeilen markiert und in einem Durchgang in das Terminalfenster kopiert werden. Zur Erinnerung: das Einfügen in PuTTY erfolgt mit der rechten Maustaste.

interface wlan0
  static ip_address=192.168.1.224/24
  static routers=192.168.1.1
  static domain_name_servers=192.168.1.1

Jetzt müssen die Adressen noch an das eigene Netzwerk angepasst werden. In der zweiten Zeile wird die gewünschte IP-Adresse des Raspberry Pi angegeben. Der Wert hinter dem Schrägstrich entspricht unserer Subnetz-Maske in einer anderen Schreibweise. Schreibt man die Subnetz-Maske 255.255.255.0 binär, dann sieht das so aus: 11111111.11111111.11111111.00000000. In der alternativen Schreibweise wird einfach die Anzahl der Einsen angegeben, in diesem Fall 24. Die Adressen in Zeile 3 und 4 sind normalerweise identisch und entsprechen der IP-Adresse des Routers. Mit der bereits erwähnten Tastenkombination Strg-S wird die Datei gespeichert und der Editor mit Strg-X wieder verlassen. Die einfachste Möglichkeit zur Aktivierung der neuen Netzwerk-Konfiguration ist ein Neustart. Dazu verwenden wir das folgende Kommando:

sudo reboot

Dabei verliert PuTTY wieder die Verbindung. Da sich nun die IP-Adresse des Raspberry Pi geändert hat, bestätigen wir die Fehlermeldung und beenden PuTTY. Nun starten wir PuTTY neu, klicken in der Liste der Saved Sessions auf unsere gespeicherte Einstellung und anschließend auf den Button Load. Im Feld Host Name tragen wir nun die neue IP-Adresse ein (in unserem Beispiel wäre das die 192.168.1.224) und klicken anschließend auf den Button Save. Damit haben wir die gespeicherte Einstellung auf den aktuellen Stand gebracht und können diese nun mit einem Doppelklick auf unseren Eintrag in den Saved Sessions starten. Wenn alles geklappt hat, dann erscheint zunächst wieder der Hinweis auf den Fingerabdruck, der wiederum mit Ja gespeichert wird und wir können uns erneut einloggen.

Symbol Schritt 5 - Betriebssystem updaten

Jetzt ist ein guter Zeitpunkt, das Betriebssystem auf den neuesten Stand zu bringen. Dafür geben wir das folgende Kommando ein:

sudo apt-get update

Das Raspberry Pi OS stellt nun Verbindungen zu mehreren Servern her und holt aktuelle Paketlisten. Kurz gesagt, es werden Informationen zu den aktuellen Softwareständen geholt.
Mit dem nächsten Kommando werden alle installierten Pakete aufgelistet, die nicht auf dem neuesten Stand sind. Es erscheint noch eine Sicherheitsabfrage, die mit Enter bestätigt werden muss:

sudo apt-get upgrade

Das Upgrade-Kommando kann einige Zeit in Anspruch nehmen. Es ist möglich, dass während der Installationen Textfenster mit Informationen erscheinen und auf eine Bestätigung warten - dies kann man mit der Taste Q erledigen. Oft werden beim Update auch Systemdateien erneuert, deshalb empfiehlt sich ein Neustart des Raspberry Pi OS nach erfolgreichem Update. Zuvor soll aber noch der Einrichtungsassistent des Desktops deaktiviert werden, da bereits alle Einstellungen durchgeführt worden sind:

sudo rm /etc/xdg/autostart/piwiz.desktop

Jetzt kann das System neu gestartet werden:

sudo reboot

Auch hier geht wieder die Verbindung zum Raspberry Pi verloren. Sobald der Desktop wieder auf dem Display des Raspberry Pi erscheint und eine aktive Netzwerkverbindung besteht, wird ganz links in der Titelzeile von PuTTY auf das kleine Symbol geklickt und im Menü wählen wir Restart Session aus. Jetzt sollte wieder ein Login möglich sein.

Symbol Schritt 6 - Node-RED installieren

Node-RED bildet die Basis für die spätere Funktion als Anzeigemodul. Über einen grafischen Editor können hier verschiedene Funktionselemente (die so genannten Nodes) platziert und mit anderen Nodes verbunden werden. Damit lassen sich nicht nur Daten lesen, verarbeiten und visualisieren - es können auch Entscheidungen getroffen und Schaltvorgänge ausgelöst werden. Ein wichtiger Teil von Node-RED ist das Node-RED-Dashboard, welches über verschiedene Anzeigeelemente verfügt, die eine grafische Darstellung von Sensorwerten und anderer Informationen ermöglicht. Weiterhin können auch Eingabeelemente verwendet werden, die über den Touchscreen Aktionen auslösen können.

Die Installation von Node-RED ist teilweise etwas ungewöhnlich, wird aber so von den Entwicklern empfohlen. Das folgende Kommando installiert Node-RED und weitere Komponenten wie node.js und npm direkt von der Entwickler-Seite:

bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)

Anschließend erscheint ein Text und 2 Abfragen, die jeweils mit y und Enter bestätigt werden müssen. Die Installation nimmt einige Zeit in Anspruch.

Das Node-RED-Dashboard ist kein Bestandteil der Basis-Installation von Node-RED und wird folgendermaßen installiert:

cd ~/.node-red
npm i node-red-dashboard

Während der Installation erscheinen unter Umständen einige Warnmeldungen, die man ignorieren kann. Jetzt sind alle benötigten Komponenten vorhanden und Node-RED kann nun als Systemdienst eingerichtet und gestartet werden:

sudo systemctl enable nodered
sudo systemctl start nodered

In der Grundeinstellung verwaltet Node-RED alle Daten im RAM. Das bedeutet, dass grafische Kurvenverläufe und zwischengespeicherte Werte bei einem Neustart von Node-RED verloren gehen. Zumindest die zwischengespeicherten Werte einzelner Nodes (wie z.B. Minimal- und Maximalwerte) können relativ einfach dauerhaft im Dateisystem gespeichert werden. Um diese Option zu aktivieren, muss die Einstellungsdatei von Node-RED bearbeitet werden:

cd ~/.node-red
nano -c settings.js

Beim Aufruf des Editors habe ich hier die Option -c hinzugefügt. Diese bewirkt, dass im unteren Bereich des Editors eine zusätzliche Zeile erscheint, in der die aktuell bearbeitete Zeilennummer angezeigt wird. Im nachfolgenden Text gebe ich die Zeilennummer an, wo der zu bearbeitende Textabschnitt beginnt und da ist die Anzeige der Zeilennummer sehr hilfreich. Allerdings ist es möglich, dass sich die Position in der Datei bei neueren Versionen von Node-RED minimal verschiebt, trotzdem hat man einen guten Richtwert.

In Zeile 252 beginnt der Abschnitt Context Storage und hier entfernen wir in den Zeilen 257-261 die beiden Schrägstriche am Zeilenanfang. Das Ergebnis muss dann so aussehen:

    // Context Storage
    // The following property can be used to enable context storage. The configuration
    // provided here will enable file-based context that flushes to disk every 30 seconds.
    // Refer to the documentation for further options: https://nodered.org/docs/api/context/
    //
    contextStorage: {
        default: {
            module:"localfilesystem"
        },
    },

Hier muss man sehr sorgfältig arbeiten: Es dürfen nur die beiden Schrägstriche entfernt werden - alles andere wie z.B. Klammern und Kommas müssen erhalten bleiben. Die Datei wird nun mit den bekannten Tastenkombinationen Strg-S und Strg-X gespeichert. Dann ist es erforderlich, Node-RED neu zu starten:

sudo systemctl restart nodered

Jetzt ist ein guter Zeitpunkt für einen Test. Node-RED wird über eine Web-Oberfläche bedient, nutzt aber anstatt des Standard-Ports 80 den Port 1880. Zum Start öffnen wir einen Web-Browser (oder ein neues Browser-Tab) auf dem PC und geben folgendes in die Adresszeile ein (ich benutze die beispielhafte IP-Adresse unseres Anzeigemoduls):

http://192.168.1.224:1880 - Das Ergebnis sieht dann ungefähr so aus:

Node-RED Start

Sollte der Bildschirm leer bleiben, dann bitte kontrollieren, ob vielleicht ein Script- oder Werbe-Blocker aktiv ist. Node-RED verwendet JavaScript und das muss auf der IP-Adresse unseres Anzeigemoduls erlaubt sein.

Auf dieser Oberfläche werden später die so genannten Flows erstellt. Dies erfolgt über Funktionselemente (Nodes), die von der linken Seite auf die Fläche in der Mitte gezogen und dann sinnvoll miteinander verknüpft werden. Wie das genau funktioniert und wie Sensordaten, Alarme und andere Informationen verarbeitet werden können, wird im Abschnitt Konfiguration beschrieben. Die vom Flow erzeugten Ausgaben werden dann auf dem Dashboard sichtbar, welches auf dem gleichen Port 1880 über den Zusatz /ui aufgerufen werden kann. Auch das wollen wir testen: http://192.168.1.224:1880/ui - Da wir noch keinen Flow erstellt haben, wird das folgende Bild angezeigt:

Node-RED-Dashboard Start

Symbol Schritt 7 - Passwortschutz für Node-RED einrichten (optional)

Node-RED bietet die Möglichkeit, den Node-RED-Editor und auch das Dashboard mit einem Passwortschutz abzusichern. Beim Dashboard ist das allerdings wenig sinnvoll, denn das soll ja bei einem Anzeigemoduls ständig sichtbar sein. Anders sieht das beim Editor aus. Hier möchte man vielleicht verhindern, dass der Flow von jedem Netzwerk-Teilnehmer verändert werden kann. Node-RED speichert Benutzernamen und Passwörter in einer Konfigurationsdatei, wobei die Passwörter als Hash-Wert abgelegt werden. Für die Berechnung des Hash-Wertes wird noch ein Programm benötigt, welches folgendermaßen installiert wird:

cd ~/.node-red
sudo npm install -g node-red-admin

Bitte nicht über die vielen Fehlermeldungen wundern, das benötigte Programm wird trotzdem funktionieren. Für die beispielhafte Einrichtung eines Passwortschutzes verwende ich hier das Passwort Geheim. Zum Erzeugen eines Hash-Wertes ist folgender Programmaufruf notwendig:

node-red-admin hash-pw

Nach der blinden Eingabe des Passwortes Geheim wird z.B. folgender Hash-Wert angezeigt:

$2a$08$TNtza9nkVUAYpWWlEPpin.fZc2bmeq9ujLWOUXX3psvyPumewRhDu

Dieser Wert ist übrigens niemals gleich, passt aber immer zum eingegebenen Passwort. Den Hashwert übertragen wir sinnvollerweise in die Zwischenablage und fügen ihn dann in die Konfigurationsdatei von Node-RED ein. Dazu wird die Konfigurationsdatei folgendermaßen geöffnet, wobei jetzt ausnahmsweise die Kommandos manuell getippt werden müssen, damit unser Hashwert in der Zwischenablage bleibt:

cd ~/.node-red
nano -c settings.js

Auch hier wurde beim Aufruf des Editors die Option -c hinzugefügt, um die aktuelle Zeilennummer anzuzeigen. In Zeile 112 beginnt der Abschnitt Securing Node-RED und hier entfernen wir in den Zeilen 116-123 die beiden Schrägstriche am Zeilenanfang. Anschließend fügen wir den zuvor ermittelten Hash-Wert in die Passwort-Zeile 120 ein. Der gesamte Abschnitt sollte dann mit meinem Beispiel-Passwort-Hash so aussehen:

    // Securing Node-RED
    // -----------------
    // To password protect the Node-RED editor and admin API, the following
    // property can be used. See http://nodered.org/docs/security.html for details.
    adminAuth: {
        type: "credentials",
        users: [{
            username: "admin",
            password: "$2a$08$TNtza9nkVUAYpWWlEPpin.fZc2bmeq9ujLWOUXX3psvyPumewRhDu",
            permissions: "*"
        }]
    },

Und auch hier wieder darauf achten, dass nur die beiden Schrägstriche entfernt werden und alles andere wie z.B. Klammern und Kommas erhalten bleibt. Als Benutzername ist hier in Zeile 122 admin vorgegeben. Diesen Namen kann man übernehmen oder durch einen anderen Namen ersetzen. Die Datei wird nun mit den bekannten Tastenkombinationen Strg-S und Strg-X gespeichert. Dann ist es erforderlich, Node-RED neu zu starten:

sudo systemctl restart nodered

Wenn der Node-RED-Editor (beispielhaft http://192.168.1.224:1880) erneut aufgerufen wird, dann erscheint jetzt ein Eingabefenster für Name und Passwort. Nach erfolgreichem Login kann der Editor verwendet werden. Wird der Editor nicht mehr benötigt, dann sollte ein Logout erfolgen. Anderenfalls bleibt der Zugang weiterhin offen und wird erst nach sehr langer Zeit wieder gesperrt. Zum Logout wird oben rechts auf das kleine Männchen zwischen dem Übernahme (deploy)-Button und dem Menü-Symbol geklickt.

Symbol Schritt 8 - VNC-Verbindung einrichten

An dieser Stelle ist die Installation eines Programms auf dem PC notwendig. Der VNC Viewer stellt eine Verbindung zu unserem Anzeigemodul 4 her und holt den Linux-Desktop auf den PC. Außerdem nutzt er die Eingabegeräte des PCs zur Fernsteuerung des Linux-Desktops. Diese Fernsteuerung wird für die nachfolgende Kalibrierung des Touchscreens benötigt und kann auch später bei Konfigurationsarbeiten noch sehr nützlich sein, wenn das Anzeigemodul z.B. in einem anderen Raum installiert ist und das Display folglich nicht sichtbar ist. Ich habe übrigens den VNC Viewer genutzt, um die Display-Screenshots für diese Seite zu erstellen.

Über die Download-Seite von RealVNC kann die für den PC geeignete Version geladen und anschließend installiert werden. Nach dem Start erscheint ein relativ schlichtes Programmfenster mit einem Eingabefeld. In dieses Feld geben wir nun die IP-Adresse des Anzeigemoduls ein, z.B. 192.168.1.224. Nach einer kurzen Wartezeit erscheint eine Warnmeldung. Der VNC Viewer prüft beim Verbindungsaufbau den Fingerabdruck des Servers und warnt, wenn dieser nicht stimmt oder noch nicht vorhanden ist. Beim ersten Verbindungsaufbau kann man diese Warnung mit dem Button Zulassen bestätigen. Anschließend erscheint ein Authentifizierungs-Fenster, in dem ein Benutzername und ein Kennwort abgefragt wird. Hier geben wir die SSH-Zugangsdaten ein, die auch für PuTTY verwendet werden und danach sollte das Bild vom Display des Anzeigemoduls zu sehen sein.

VNC Desktop

In diesem Bild sieht man den oberen Teil des Desktops mit der Menü-Leiste. Über Maus und Tastatur des PCs kann jetzt der Desktop normal bedient werden. Bewegt man die Maus auf den mittleren oberen Rand des Desktop-Fensters, dann öffnet sich ein zusätzliches Menü, welches auch auf dem Bild zu sehen ist. Dieses Menü ermöglicht weitere Einstellungen und mit dem Kreuz-Symbol auf der rechten Seite kann die VNC-Verbindung auch wieder beendet werden. Im Programmfenster des VNC Viewers findet man jetzt ein verkleinertes Bild von unserem Anzeigemodul mit der IP-Adresse. Hier werden alle Verbindungen abgelegt und können über einen Doppelklick erneut hergestellt werden. Dabei ist dann nur noch die Eingabe des Kennwortes notwendig.

Noch ein kleiner Tipp: Damit das Erstellen von Screenshots gelingt, müssen bei laufender Verbindung über das zusätzliche Menü zwei Einstellungen geändert werden. Dazu wird über das Zahnrad-Symbol (Eigenschaften) zum Tab Optionen gewechselt und hier die Bildqualität auf Hoch gesetzt und ganz unten der Haken bei der Option Sondertasten direkt an VNC Server übergeben entfernt.

Symbol Schritt 9 - Touchscreen konfigurieren (optional)

Für diesen Schritt ist es zwingend erforderlich, dass der Touchscreen vollständig verkabelt ist. Der Touchscreen-Controller muss dazu sowohl mit dem Touchscreen-Anschluss des Displays als auch mit einem USB-Anschluss des Raspberry Pi verbunden sein. Über das nachfolgende Kommando kann man zunächst prüfen, ob der Touchscreen-Controller vom System erkannt wurde:

lsusb

Dabei werden mehrere Geräte aufgelistet, wobei das nachfolgende unbedingt in der Liste erscheinen muss:

Bus 001 Device 004: ID 0eef:0001 D-WAV Scientific Co., Ltd eGalax TouchScreen

Die Werte bei Bus und Device können abweichen, der Rest sollte jedoch übereinstimmen. Für den nächsten Test kann man auf das Display tippen und dabei den Touchscreen-Controller beobachten, hier sollte bei jeder Berührung eine grüne LED aufleuchten. Es handelt sich hier übrigens um einen Touchscreen der älteren Generation, bei dem man etwas fester drücken muss. Falls die LED nicht reagiert, ist möglicherweise das 4-polige Kabel verkehrt herum am Touchscreen angeschlossen. Nach dem erfolgreichen Funktionstest ist die Installation von 2 Programmen für die Funktion und Kalibrierung des Touchscreens notwendig:

sudo apt-get install xserver-xorg-input-evdev xinput-calibrator

Nun wird eine Datei zum Bearbeiten geöffnet:

sudo nano /etc/X11/xorg.conf

Die nachfolgenden Konfigurationsdaten werden jetzt komplett markiert und in die Datei kopiert. Falls die Datei bereits Informationen enthält, dann werden die Konfigurationsdaten an das Dateiende angefügt:

Section "InputClass"
  Identifier "evdev tablet catchall"
  MatchIsTablet "on"
  MatchDevicePath "/dev/input/event*"
  Driver "evdev"
EndSection

Mit den bekannten Tastenkombinationen Strg-S und Strg-X wird die Datei gespeichert und der Editor wieder beendet. Jetzt ist mal wieder ein Neustart des Systems notwendig:

sudo reboot

Nachdem der Desktop wieder sichtbar ist, kann man gleich mal den Touchscreen ausprobieren. Der Mauspfeil sollte jetzt den Display-Berührungen folgen, allerdings stimmen die Positionen noch nicht überein. Bei dieser Art Touchscreen ist noch eine Kalibrierung notwendig. Dazu brauchen wir gleichzeitig eine SSH- und eine VNC-Verbindung zum Anzeigemodul. Zunächst stellen wir mit PuTTY die unterbrochene SSH-Verbindung wieder her. Außerdem starten wir den VNC-Viewer und bauen die zuvor eingerichtete VNC-Verbindung wieder auf.

Stylus Für den Kalibrierungsvorgang eignet sich am besten ein Stift von einem alten Touchscreen-Organizer. Alternativ kann man einen weichen Plastikgegenstand mit einer abgerundeten Spitze verwenden. Der Stift wird auch nur zur Kalibrierung benötigt, für die spätere Bedienung genügt ein Finger. Liegt ein passender Stift bereit, dann starten wir jetzt das Kalibrierungsprogramm über die VNC-Verbindung. Dazu klicken wir oben links auf das Raspberry-Symbol und erreichen hier über die Menü-Option Einstellungen das Programm Touchscreen Kalibrieren.

Sobald das Kalibrierungsprogramm läuft, gehen wir mit dem Stift zum Touchscreen-Display und tippen damit so genau wie möglich nacheinander auf die 4 angezeigten Kalibrierungspunkte. Die Zeit für diesen Vorgang ist begrenzt, also nicht zu lange warten. Anschließend öffnet sich auf dem Desktop ein Textfenster mit einigen Informationen und den ermittelten Kalibrierungsdaten. Dieses bitte nicht schließen, das wird noch gebraucht. Die Kalibrierung wird sofort wirksam und kann gleich mit dem Stift (oder dem Finger) getestet werden. Man kann diesen Vorgang übrigens jederzeit wiederholen, in dem man das Ergebnis-Fenster schließt und das Kalibrierungsprogramm erneut startet. Das Ergebnis-Fenster der letzten Kalibrierung sollte aber geöffnet bleiben.

Kann man mit der Kalibrierung leben (in den Randbereichen wird es nie ganz perfekt), dann werden wir jetzt die Kalibrierungsdaten speichern, denn diese gehen bei einem Neustart verloren. Dazu nehmen wir jetzt die SSH-Verbindung (PuTTY) und legen eine neue Datei an:

sudo nano /etc/X11/xorg.conf.d/99-calibration.conf

Jetzt geht es mit der VNC-Verbindung weiter: Hier markieren wir die Kalibrierungsdaten im Ergebnis-Fenster von der Zeile Section bis zur Zeile EndSection und bringen diese mit einem Linksklick in die Zwischenablage. Auf meinem Anzeigemodul sehen diese Daten beispielsweise so aus:

Section "InputClass"
	Identifier	"calibration"
	MatchProduct	"eGalax Inc. Touch Touchscreen"
	Option	"Calibration"	"46 1979 69 1976"
	Option	"SwapAxes"	"0"
EndSection

Jetzt wechseln wir wieder zu PuTTY und fügen diese Informationen mit einem Rechtsklick in das vorbereitete Editor-Fenster ein. Anschließend speichern wir die Datei mit den bekannten Tastenkombinationen. Die VNC-Verbindung kann nun getrennt werden, die wird vorerst nicht mehr benötigt.

Bei der etwas kniffligen Touchscreen-Einrichtung war übrigens diese Seite sehr hilfreich: https://www.msdigital.de/entries/2020.02.13,RPi - eGalax Touchscreen with Raspberry,raspberrypi,linux.md

Symbol Schritt 10 - unclutter installieren

Das Programm unclutter hat eine einfache, aber durchaus wichtige Funktion: Es soll den Mauszeiger ausblenden, denn dieser stört später die Dashboard-Anzeige. Der Mauszeiger verschwindet übrigens nicht für immer. Bei einer Bedienung z.B. über den Touchscreen wird der Mauszeiger für einige Sekunden sichtbar und dann wieder ausgeblendet. Die Installation von unclutter erfolgt folgendermaßen:

sudo apt-get install unclutter

unclutter wird beim nächsten Reboot automatisch gestartet. Ein Neustart lohnt sich aber dafür nicht, zumal das Programm erst später benötigt wird.

Symbol Schritt 11 - Autostart für das Node-RED-Dashboard einrichten

In diesem letzten Schritt wird dafür gesorgt, dass automatisch ein Web-Browser gestartet und das Node-RED-Dashboard angezeigt wird. Hier hat es sich bewährt, eine kleine Verzögerung einzubauen, weil Node-RED etwas Zeit zum Starten braucht und der Web-Browser diese Zeit abwarten sollte. Eine weitere Besonderheit ist, dass der Browser im Kiosk-Modus gestartet wird. Damit ist nur noch das reine Node-RED-Dashboard zu sehen und alle Fensterrahmen und Titelleisten werden ausgeblendet.

Zuerst erstellen wir ein kurzes Start-Programm für den Web-Browser Chromium:

sudo nano /usr/local/bin/start_chromium.sh

In diese Datei kopieren wir den folgenden Inhalt:

#!/bin/bash
sleep 20
chromium-browser http://localhost:1880/ui --kiosk

Nach dem Speichern der Datei und dem Beenden des Editors wird diese Datei jetzt ausführbar gemacht:

sudo chmod +x /usr/local/bin/start_chromium.sh

Als nächstes müssen wir den automatischen Start im Desktop organisieren. Dazu wird die folgende Datei im Editor geöffnet:

sudo nano /etc/xdg/lxsession/LXDE-pi/autostart

Hier bewegen wir den Cursor an das Ende der Datei und fügen die folgende Zeile hinzu:

@start_chromium.sh

nach dem Speichern der geänderten Datei und dem Beenden des Editors ist jetzt ein guter Zeitpunkt für einen Neustart des Systems:

sudo reboot

Jetzt sollte folgendes passieren: Der Desktop wird ganz normal gestartet und ungefähr 30 Sekunden später wird der Web-Browser aktiv und das Bild vom Node-RED-Dashboard auf dem Display sichtbar. Da noch kein Flow erstellt wurde, ist nur ein entsprechender Hinweis zu sehen. Weiterhin sollte der Mauszeiger inaktiv bleiben und nur beim Berühren des Displays kurz erscheinen.

Bei der Einrichtung des Autostarts war folgende Quelle sehr hilfreich: https://www.raspberrypi-spy.co.uk/2014/05/how-to-autostart-apps-in-rasbian-lxde-desktop/.
Die Verwendung des Kiosk-Modus ist hier gut beschrieben: https://dominik.debastiani.ch/2019/01/18/raspberry-pi-als-kiosk-pc-mit-browser/.

Damit ist die Inbetriebnahme des Anzeigemoduls abgeschlossen.

SymbolKonfiguration

Zuerst eine schlechte Nachricht: Bei diesem Projekt gibt es keine fertige Konfiguration zum Download. Jedes Temperatur-Messsystem ist anders aufgebaut und jeder hat andere Vorstellungen von den Elementen, die auf dem Display angezeigt werden sollen. Aus diesem Grund will ich versuchen, die Bedienung von Node-RED mithilfe einiger Beispiele zu beschreiben. Die Beispiele können gern für die eigene Konfiguration angepasst und erweitert werden. Damit sollte es jedem möglich sein, das Anzeigemodul nach eigenen Wünschen zu gestalten.

Zur Konfiguration von Node-RED wird auf dem PC ein Web-Browser geöffnet und die IP-Adresse des Anzeigemoduls eingegeben. Zusätzlich muss noch die Portnummer 1880 ergänzt werden, so dass sich z.B. folgende Adresse ergibt: 192.168.1.224:1880. Anschließend sollte (gegebenenfalls nach einer Passwort-Abfrage) der Node-RED-Editor im Browserfenster erscheinen. Das Ergebnis unserer Arbeit sehen wir dann als Node-RED-Dashboard auf dem Display des Anzeigemoduls. Alternativ kann man eine VNC-Verbindung zum Anzeigemodul herstellen und den Display-Inhalt auf den PC holen. Diese Option ist auf jeden Fall nützlich, wenn das Anzeigemodul z.B. in einem anderen Raum installiert und das Display nicht sichtbar ist.

Node-RED Start

Der Node-RED-Editor besteht hauptsächlich aus 3 Teilen: Auf der linken Seite befindet sich eine Liste mit Elementen, die bestimmte Funktionen erfüllen (Nodes). Nodes können einfach mit der Maus auf den mittleren Teil (Flow) gezogen und dort mit anderen Nodes verknüpft werden. Der rechte Teil (Info) dient zur Konfiguration und Information und hier sind ganz oben mehrere nebeneinander liegende Symbole zu sehen. Diese haben folgende Bedeutung:

Symbolzeigt Informationen über das gerade ausgewählte Element an
Symbolzeigt Hilfetexte zum gerade ausgewählten Element an
Symbolzeigt Debug-Informationen und Fehlermeldungen an
Symbolzeigt eine Übersicht über die verwendeten Nodes an
Symbolzeigt Context-Daten (gespeicherte Werte) an
Symbolführt zur Grundkonfiguration des Dashboards

Sollten nicht alle beschriebenen Symbole sichtbar sein, dann kann man auf den kleinen Pfeil rechts neben den Symbolen klicken. Es öffnet sich dann ein Menü, in dem alle Symbole mit einer kurzen Beschreibung erscheinen und direkt aufgerufen werden können.

Ganz oben rechts in der Titelzeile von Node-RED sind noch 3 wichtige Funktionen untergebracht:

SymbolDieser Button hat eine wichtige Funktion: Hier wird der aktuelle Flow geprüft und anschließend aktiviert. Bei einem leeren Flow oder direkt nach einer Aktivierung ist der Button inaktiv und das Symbol wird dunkel dargestellt. Nach einer Änderung im Flow wird er wieder aktiv. Der kleine Pfeil rechts ermöglicht eine weitere Unterauswahl, die vorerst nicht verändert werden muss.
SymbolDieses Symbol erscheint nur, wenn der Passwortschutz des Node-RED-Editors aktiv ist. Über dieses Symbol kann der Benutzer gewechselt oder ein Logout durchgeführt werden.
SymbolÜber dieses Symbol wird das Hauptmenü von Node-RED aufgerufen.

Für den Einstieg in Node-RED und die Erstellung eines eigenen Flows habe ich einige Beispiel-Flows zusammengestellt. Diese stehen als Paket am4-node-red-v100.zip zum Download bereit. Die weitere Beschreibung ist in mehrere Abschnitte unterteilt: Diese befassen sich jeweils mit einem Beispiel-Flow, ein weiterer Abschnitt soll noch einige weitere Informationen vermitteln. Die Beispiel-Flows bauen übrigens aufeinander auf. Wurde ein Node oder eine spezielle Einstellung bereits ausführlich beschrieben, dann wird das nicht wiederholt. Für Neueinsteiger ist es also sinnvoll, alle Beispiele nacheinander auszuprobieren. Ich hoffe, die Beschreibungen sind ausführlich genug, damit der Einstieg gelingt. Wer bereits Erfahrungen mit Node-RED und dem Dashboard hat, kann sicher einige Bereiche überspringen. Die nachfolgende Tabelle zeigt eine Übersicht über alle Abschnitte:

Flow 1 (Systeminformationen)Dieser Flow enthält einige Grundeinstellungen für das Node-RED-Dashbord und bietet außerdem folgende Funktionen:
• Steuerung der Poweroff-Funktion des Anzeigemoduls
• Anzeige der Systemauslastung
• Anzeige des Online-Status
• Anzeige der Uhrzeit
• Anzeige des Datums
Flow2 (Sensorwert)Dieser Flow demonstriert den Empfang von Sensordaten über MQTT und die Darstellung als Anzeigeinstrument.
Flow3 (Sensordiagramm)Dieser Flow demonstriert den Empfang von Sensordaten über MQTT und deren Anzeige als Diagramm.
Flow4 (Groß-Min-Max-Anzeige)Dieser Flow demonstriert die Großanzeige eines Sensorwertes und die Ermittlung von Minimal- und Maximal-Wert.
Flow5 (Alarmanzeige)Dieser Flow demonstriert die Anzeige eines Alarms vom Temperatur-Messsystem.
Flow6 (Wetterdaten)Dieser Flow demonstriert den Empfang von Wetterdaten und die Anzeigemöglichkeiten.
Flow7 (Kraftstoffpreise)Dieser Flow demonstriert den Empfang und die Anzeige von Kraftstoffpreisen.
Weitere InformationenHier stehen weitere Informationen über Node-RED.

Symbol Flow 1 - Systeminformationen (Flow1-Systeminformationen.json)

Damit dieser erste Flow funktioniert, müssen zunächst 2 weitere Nodes installiert werden, die nicht in der Grundausstattung von Node-RED enthalten sind. Dazu klicken wir im Node-RED-Editor oben rechts auf das Menü-Symbol und wählen die Option Palette verwalten. Es erscheint eine Übersicht über die bereits installierten Nodes. Hier wechseln wir jetzt zum Tab Installieren. Dort gibt es ein Suchfeld und hier geben wir artless ein, anschließend sollte der Node node-red-contrib-ui-artless-gauge in der Trefferliste erscheinen. Mit einem Klick auf den kleinen Button Installieren auf der rechten Seite erscheint zunächst ein Hinweisfenster. Hier hat man die Möglichkeit, den Vorgang abzubrechen, weitere Informationen zu holen oder eben mit einem Klick auf installieren den Installationsvorgang zu starten. Das dauert einige Sekunden und anschließend wird kurz eine Erfolgsmeldung angezeigt.

Auf die gleiche Weise wird der zweite Node installiert. Zuerst geben wir isonline ins Suchfeld ein und der Node node-red-contrib-isonline sollte in der Trefferliste erscheinen. Auch hier klicken wir auf den kleinen Button Installieren auf der rechten Seite und auch dieser führt wieder auf ein Hinweisfenster. In diesem erfolgt jetzt ein Klick auf installieren und nach einigen Sekunden sollte die erfolgreiche Installation bestätigt werden. Über den Button Schließen kann das Fenster nun wieder geschlossen werden. Übrigens, manche Nodes erfordern nach der Installation einen Neustart von Node-RED. Bei diesen beiden Nodes ist das jedoch nicht erforderlich.

Node-RED bietet die Möglichkeit, komplette Flows oder auch Teile eines Flows zu exportieren und auch wieder zu importieren. Für unseren ersten Flow nutzen wir die Import-Funktion. Dabei wird zunächst mit einem Klick auf das Menü-Symbol das Hauptmenü geöffnet und die Funktion Import ausgewählt. Es erscheint ein Fenster, in dem bereits die richtige Option Zwischenablage ausgewählt ist. Mit einem Klick auf das Feld select a file to import öffnet sich ein Dialog-Fenster, in dem die zu importierende Datei Flow1-Systeminformationen.json ausgewählt wird. Dabei wird deren Inhalt im Import-Fenster angezeigt. Es handelt sich hier um lesbaren Text, der in einer kompakten Struktur gespeichert ist (JSON-Format). Mit einem Klick auf Import werden dann die Daten geladen.

Node-RED Import Beim ersten Import nach einer Neuinstallation von Node-RED werden alle Daten ohne Nachfrage übernommen. Wenn allerdings bereits ein Flow existiert, dann kann es beim Import Konflikte geben und es erscheint eine Warnung wie im nebenstehenden Bild. Hier empfiehlt es sich, die Option Zeige Nodes... auszuwählen. Es öffnet sich dann ein Fenster, in dem die zu importierenden Nodes ausgewählt werden können, wobei das System bereits eine passende Vorauswahl anbietet.

Nach dem Import sollte das Editor-Fenster ungefähr so aussehen:

Flow 1 Bild 1

Die Bearbeitung von Flows im Node-RED-Editor läuft immer nach dem gleichen Muster ab: Zunächst wird ein Flow erstellt oder importiert und man erhält dabei ein Bild wie oben. An jedem Node ist ein blauer Punkt zu erkennen, welcher darauf hinweist, dass Änderungen am Node vorliegen, die noch nicht gespeichert worden sind. Manche Nodes können auch ein rotes Dreieck anzeigen, welches auf eine fehlende oder unvollständige Konfiguration hinweist. Wenn man auf das Display des Anzeigemoduls schaut, dann sieht man übrigens immer noch das leere Dashboard. An dieser Stelle kommt der große Button Übernahme (deploy) zum Einsatz. Ein Klick auf diesen bewirkt folgendes: Der aktuelle Flow im Editor wird geprüft, gespeichert und anschließend aktiviert. Nach einer kurzen Bearbeitungszeit verschwinden alle blauen Punkte im Node-RED-Editor und es erscheint der Hinweis Erfolgreich implementiert. Schaut man jetzt auf das Display des Anzeigemoduls, dann erscheint dort das nachfolgende Bild:

Flow 1 Bild 2

Der Übernahme (deploy)-Button wird nach dieser Aktion inaktiv und das bleibt er auch, bis erneut Änderungen am Flow vorgenommen werden. Dann erscheinen wieder blaue Markierungen an den jeweils bearbeiteten Nodes. Der bisher aktive Flow (und somit auch das Bild auf dem Anzeigemodul) arbeitet unabhängig von den Änderungen ganz normal weiter. Bis man irgendwann wieder auf den Button Übernahme (deploy) klickt. Dann wird wiederum der Flow im Editor geprüft, gespeichert und aktiviert, die blauen Punkte verschwinden an den Nodes und das Display des Anzeigemoduls zeigt das Bild, was vom geänderten Flow generiert wird.

Man darf an dieser Stelle gern mittels Doppelklick auf einen Node dessen Konfiguration anschauen und auch damit experimentieren. Und nicht vergessen, dass Änderungen erst mit einem Klick auf den Übernahme (deploy)-Button aktiviert werden. Es ist übrigens nicht schlimm, wenn man am Anfang nicht alles versteht. Vieles wird klar, wenn man sich etwas länger mit Node-RED beschäftigt. Zur Beschreibung der Funktionen habe ich den ersten Flow in mehrere logische Teile zerlegt. Ich beginne mit dem relativ einfachen unteren Teil.

• Poweroff-Funktion

Flow 1 Bild 3

Dieser Teil des Flows überwacht den Poweroff-Taster und bei einem Tastendruck von mindestens 2 Sekunden wird das Kommando sudo poweroff an das System gesendet, um den Raspberry Pi herunterzufahren. Die 3 verwendeten Nodes haben dabei folgende Funktion:

Node: rpi gpio in
Name: R-Taster

Mit diesem Node kann ein GPIO-Anschluss des Raspberry Pi als Eingang konfiguriert werden. Bei jeder Status-Änderung an diesem Eingang wird dann eine Nachricht an weitere Nodes gesendet, die dann entsprechende Aktionen auslösen können. Bei diesem Node wurde zunächst der Anschluss GPIO 17 (Pin 11) ausgewählt, an dem unser Poweroff-Taster angeschlossen ist. Weiterhin wurde der Pull-up-Widerstand aktiviert, so dass bei offenem Eingang (Taster nicht gedrückt) ein High-Pegel anliegt. Die Entprellzeit (Debounce) wurde auf 2000ms festgelegt, somit muss der angeschlossene Taster mindestens 2 Sekunden lang den Eingang auf Low-Pegel halten, um eine Nachricht auszusenden. Nachrichten in Node-RED bestehen übrigens meist aus den beiden Elementen Topic (Thema) und Payload (Nutzlast, Inhalt). Bei diesem Node wird als Topic der Text pi/11 und als Payload der aktuelle Zustand 0 oder 1 gesendet. Übrigens, der aktuelle Zustand des GPIO-Anschlusses wird immer direkt unter dem Node angezeigt.

Node: function
Name: Auswertung

Flow 1 Bild 4 Nicht alle vom rpi gpio in-Node generierten Nachrichten sollen eine Aktion auslösen, sondern nur die mit einem Payload 0. Deshalb wurde dieser function-Node eingefügt, welcher mit einem kleinen JavaScript-Programm den Payload prüft. Das Programm ist relativ simpel: Es vergleicht den Payload mit 0 und wenn die Bedingung erfüllt ist, wird die Nachricht unverändert an weitere Nodes gesendet. Anderenfalls wird das Sende-Kommando nicht ausgeführt und das Programm ohne weitere Aktionen beendet.

Node: exec
Name: Ausschalten

Dieser Node ist dafür gedacht, System-Funktionen aufzurufen, wenn eine Nachricht empfangen wird. Wenn in unserem Flow als Folge eines Tastendrucks eine Nachricht vom vorherigen function-Node eintrifft, dann führt der exec-Node daraufhin das Kommando sudo poweroff aus. Weiterhin wird das Ergebnis des Kommandos als Nachricht an weitere Nodes gesendet, allerdings wird das hier nicht genutzt und sinnvoll wäre das ohnehin nicht, da das System sofort herunterfahren wird.

• Datum und Uhrzeit anzeigen

Flow 1 Bild 5

Der nächste Flow-Teil ermittelt die aktuelle Uhrzeit sowie das aktuelle Datum und stellt beides auf dem Dashboard dar. Die hier verwendeten 5 Nodes haben folgende Funktion:

Node: inject
Name: 1 min ↻

Dieser Node hat die Aufgabe, zu bestimmten Zeitpunkten oder in bestimmten Zeitintervallen eine Nachricht an weitere Nodes zu senden. Hier ist der Node so konfiguriert, dass zunächst 0,1 Sekunden nach dem Start von Node-RED und anschließend zyklisch zu jeder vollen Minute eine Nachricht generiert wird. Die erzeugten Nachrichten verwenden hier das Topic start und als Payload die aktuelle Zeit.

Node: function
Name: Zeit

Flow 1 Bild 6 Dieser Node wertet die vom inject-Node empfangenen Nachrichten und deren Zeitinformation aus. Auch hier wird wieder ein JavaScript-Programm verwendet. Zunächst wird aus dem Payload der Stunden und Minutenwert ermittelt. Bei den Minuten wird zusätzlich geprüft, ob der Wert einstellig ist und gegebenenfalls eine Null vorangestellt. Die Stunden können auch einstellig sein. Zum Schluss werden die Einzelkomponenten mit einem Doppelpunkt zusammengefügt und als Payload zum nächsten Node gesendet.

Node: function
Name: Datum

Flow 1 Bild 7 Auch dieser Node wertet die vom inject-Node empfangenen Nachrichten und deren Zeitinformation mit einem JavaScript-Programm aus. Damit das Datum mit Wochentagen und Monaten im Textformat angezeigt werden kann, werden zunächst 2 Listen mit den Namen erstellt. Anschließend werden alle benötigten Elemente aus der Zeitinformation im Payload ermittelt und zu einem String in der Form Mittwoch, 31. Mär 2021 zusammengesetzt. Zum Schluss wird dieser als Payload zum nächsten Node gesendet.

Node: text
Name: Zeit / Datum

Mit diesen beiden Nodes, die speziell für Text-Elemente gedacht sind, werden die von den function-Nodes übermittelten Zeit-Nachrichten auf das Dashboard gebracht. Beide sind bis auf eine Einstellung identisch konfiguriert. Um zu verstehen, wie das Dashboard funktioniert, sind hier etwas mehr Informationen notwendig. Ich möchte hier mit 2 Begriffen beginnen, die beim Dashboard wichtig sind und bei jedem Dashboard-Element konfiguriert werden müssen:

GroupJedes Element auf dem Node-RED-Dashboard muss einer Group (Gruppe) zugeordnet werden. Eine Group kann mehrere Elemente enthalten und stellt diese gemeinsam mit einem Rahmen dar. Dabei wird die nutzbare Breite in den Einstellungen der Group vorgegeben. Bei der Darstellung der Elemente wird zunächst versucht, diese nebeneinander anzuordnen und falls der Platz nicht ausreicht, kommen weitere Elemente darunter. Für alle Größenangaben bei den Elementen und Groups werden Rastereinheiten angegeben, wobei eine Rastereinheit 48x48 Pixel auf dem Dashboard belegt.
TabMehrere Groups wiederum können auf Tabs zusammengefasst werden. Ein Tab belegt immer die gesamte Display-Fläche und auch hier werden zunächst die Groups nebeneinander angeordnet und wenn der Platz nicht mehr ausreicht, kommen weitere Groups darunter. Grundsätzlich können mehrere Tabs angelegt werden, zwischen denen man über ein Menü wechseln kann. Unser Anzeigemodul soll viele Informationen auf einen Blick liefern, aus diesem Grund verwende ich nur ein Tab und verzichte auf das Menü.

Flow 1 Bild 8 Bei unserem text-Node Zeit findet man in den Einstellungen die Angaben Group [Haus] Zeit und Größe Auto. Das bedeutet: Unser Anzeigeelement befindet sich in der Group Zeit und diese Group ist wiederum Bestandteil des Tabs Haus, welches beim Anzeigemodul der gesamten Display-Fläche entspricht. Klickt man auf das Stift-Symbol neben dem Feld Group [Haus] Zeit, dann gelangt man in die Einstellungen der Group. Hier lässt sich der Name und außerdem die Größe der Group (hier 2 Rastereinheiten) anpassen. Weiterhin kann man hier die Tab-Zuordnung ändern und einen Gruppennamen aktivieren. Letzterer erzeugt eine Überschrift für die Group, benötigt dann aber mehr Platz auf dem Dashboard.

Zwei wichtige Einstellungen beim text-Node sind die Felder Label und Value Format. Diese bestimmen, welche Informationen in der Anzeige erscheinen sollen. Während das Label-Feld nicht genutzt wird und für einen festen Text gedacht ist, enthält das Value Format-Feld etwas mehr Informationen. Hier wird der übermittelte Payload in ein HTML-Konstrukt eingebettet, der die Schrifteinstellungen (Farbe und Größe) festlegt.

Flow 1 Bild 9 Beim text-Node Datum findet man grundsätzlich die gleichen Einstellungen vor. Das Feld Group ist hier als einzige Ausnahme abweichend mit [Haus] Datum konfiguriert, so dass sich die Datum-Anzeige in einer eigenen Group befindet.

• Systemauslastung anzeigen

Flow 1 Bild 10

Der oben abgebildete Flow-Teil hat die Aufgabe, alle 30 Sekunden die Systemauslastung und die CPU-Temperatur des Raspberry Pi zu ermitteln und anschließend mit 2 Anzeigeelementen auf dem Dashboard darzustellen. Auch hier soll die Funktion der beteiligten Nodes beschrieben werden:

Node: inject
Name: 30 sek ↻

Dieser Node hat wieder die Aufgabe, in bestimmten Zeitintervallen eine Nachricht an weitere Nodes zu senden, in diesem Fall 3 Sekunden nach dem Start von Node-RED und anschließend alle 30 Sekunden. Als Topic wird hier der Text Last und als Payload die aktuelle Zeit festgelegt.

Node: exec
Name: Last lesen

Dieser Node führt das Kommando cat /proc/loadavg aus und nach der Ausführung steht das Ergebnis am Ausgang 1 für weitere Nodes zur Verfügung. Die Ausgänge 2 und 3 werden hier übrigens nicht genutzt, diese sind dafür gedacht, Fehlermeldungen und Ergebnis-Codes weiterzugeben. Wichtig zu wissen: der exec-Node wertet das Topic der eingehenden Nachricht nicht aus, verwendet es jedoch für alle ausgehenden Nachrichten. Damit haben die Nachrichten dieses Nodes das vom ursprünglichen inject-Node übermittelte Topic Last und als Payload die Informationen über die Systemauslastung des Raspberry Pi.

Node: exec
Name: Temp lesen

Dieser Node funktioniert grundsätzlich genauso wie Last lesen, nur das Kommando ist ein anderes: vcgencmd measure_temp. Auch hier wird das Ergebnis des Kommandos als Nachricht am Ausgang 1 an weitere Nodes ausgegeben.

Node: change
Name: Topic

Dieser Node hat die Aufgabe, Eigenschaften von Nachrichten zu ergänzen, zu ändern oder zu löschen. In diesem Fall sollen alle eingehenden Nachrichten das Topic Temp erhalten und sofort weitergesendet werden.

Node: function
Name: Auswertung

Flow 1 Bild 11 Dieser Node empfängt die Nachrichten der beiden exec-Nodes. Allerdings befinden sich die gewünschten Werte für Auslastung und Temperatur in einer Textzeile und müssen dort herausgefiltert werden. Dafür wird wieder ein function-Node gewählt und ein kleines JavaScript-Programm muss diese Arbeit erledigen. Dazu muss das Programm zunächst Nachrichten aus 2 Quellen auswerten, die benötigten Werte extrahieren und so zusammenfassen, dass die nachfolgenden Nodes damit etwas anfangen können. Das Problem dabei ist: Das Programm läuft beim Empfang einer Nachricht genau einmal durch und kennt in diesem Moment auch nur die Informationen aus dieser Nachricht. Hier kommen aber abwechselnd Nachrichten aus 2 Quellen und um diese Informationen zu verbinden, müssen Werte zwischengespeichert werden. Für solche Fälle bietet Node-RED den so genannten Context-Speicher an.

Ich habe das Programm nun so organisiert, dass beim Empfang einer Nachricht vom exec-Node Temp lesen die übermittelte Temperatur im Context-Speicher abgelegt wird und keine weiteren Aktionen stattfinden. Kommt eine Nachricht vom exec-Node Last lesen, dann wird zunächst der Lastwert aus der Nachricht gelesen und zusätzlich der Temperaturwert aus dem Context-Speicher geholt und beide Werte können nun gleichzeitig verwendet werden.

Im Detail funktioniert das so, dass zunächst bei jeder empfangenen Nachricht der Context-Speicherplatz temp ausgelesen wird. Falls beim ersten Start noch kein Wert vorliegt, wird dieser Wert auf 0 gesetzt. Jetzt erfolgt die Prüfung des Topic und bei einer Temperatur-Nachricht wird aus dem empfangenen String im Payload (z.B. temp=52.1'C) der Temperaturwert entnommen. Anschließend kommt dieser als Zahlenwert in den Context-Speicher und das Programm ist an dieser Stelle beendet. Wurde eine Last-Nachricht empfangen, dann wird aus deren Payload (z.B. 0.56 0.57 0.60 1/295 2127) der erste Wert entnommen. Im nächsten Schritt wird der ursprüngliche Payload entfernt, dann aus dem Last- sowie dem Temperaturwert eine neue Nachricht zusammengesetzt und schließlich an weitere Nodes gesendet.

Node: artless gauge
Name: System 1

Flow 1 Bild 12 Mit diesem Node wird die ermittelte Systemlast auf dem Dashboard angezeigt. Der hier verwendete artless-gauge-Node bietet viele Konfigurationsmöglichkeiten: So kann man neben der obligatorischen Group- und Größen-Einstellung die Form (rund oder gerade) festlegen, ein Icon definieren oder farbige Bereiche einrichten. Die hier verwendete gerade Form hat den Vorteil, dass man mehrere dieser Anzeigen untereinander anordnen und somit verschiedene Werte direkt miteinander vergleichen kann. Dieser Node befindet sich in der Group [Haus] System 1 mit einer Breite von 6 Rastereinheiten und der Node selbst wurde auf 6x1 Rastereinheiten konfiguriert.

Neben dem Anfangs- und Endwert lassen sich auch nahezu beliebige Zwischenwerte festlegen. Für jeden Bereich kann eine Farbe definiert werden und die Anzeige wechselt dann in die eingestellte Farbe, wenn der übermittelte Wert diesen Bereich erreicht. Unsere Anzeige ist so konfiguriert, dass Auslastungswerte im Bereich 0-2 Grün dargestellt werden, Werte im Bereich 2-3 Gelb und Werte über 3 Rot. Weitere Einstellungen können gern ausprobiert werden.

Node: artless gauge
Name: System 2

Flow 1 Bild 13 Mit diesem Node werden die beiden ermittelten Werte für Systemlast und CPU-Temperatur auf dem Dashboard zur Anzeige gebracht. Hier wird der gleiche artless gauge-Node wie eben verwendet, allerdings in der runden Form. Diese bietet eine Besonderheit: Es können 2 Werte gleichzeitig dargestellt werden. Der Auslastungswert im Payload erscheint hier als große Zahl und der Temperaturwert im Secondary als etwas kleinerer Wert darunter. Dieser Node befindet sich in der Group [Haus] System 2 mit einer Breite von 2 Rastereinheiten und der Node selbst wurde auf 2x2 Rastereinheiten konfiguriert, was der kleinsten Einstellung für diese Anzeigeform entspricht.

• Online-Status anzeigen

Flow 1 Bild 14

Dieser Flow-Teil hat die Aufgabe, alle 30 Sekunden den Online-Status zu ermitteln und diesen durch ein farbiges Symbol auf dem Dashboard anzuzeigen. Die beteiligten Nodes haben dabei folgende Funktion:

Node: inject
Name: 30 sek ↻

Dieser Node wird bereits von der Systemauslastung verwendet und ist dort beschrieben worden. Hier wird der Ausgang einfach mit einem weiteren Node verbunden.

Node: is online
Name: Online

Dieser Node prüft beim Empfang einer Nachricht, ob ein ausgewählter Server erreichbar ist und gibt das Ergebnis im Payload als true (Server ist online) oder false (Server ist nicht erreichbar) aus. Bei diesem Flow habe ich keinen Server eingetragen, in diesem Fall wird ein Ping an google.com gesendet, um den Online-Status zu ermitteln. Hier empfehle ich, im Einstellungs-Feld URL die IP-Adresse des MQTT-Servers einzutragen, z.B. 192.168.1.222. Damit kann man jederzeit sehen, ob die MQTT-Verbindung funktioniert.

Node: function
Name: Auswertung

Flow 1 Bild 15 Dieser Node empfängt den Online-Status und steuert mithilfe eines JavaScript-Programms die Ausgabe eines farbigen Symbols auf dem Dashboard. Dieses Programm prüft zunächst, ob der Wert im Payload auf true gesetzt ist. In diesem Fall wird eine zweite Nachricht mit dem Text stop im Payload erstellt, außerdem wird einer Variable der Text green zugewiesen. Falls die Bedingung nicht erfüllt war (else-Zweig), dann wird ebenfalls eine zweite Nachricht erstellt, allerdings mit dem Payload start und die Variable bekommt den Text red zugewiesen. Zum Schluss werden 2 Nachrichten gleichzeitig ausgegeben: Eine mit dem Farbtext aus der Variable als Payload am Ausgang 1 und eine mit dem Payload start oder stop am Ausgang 2.

Node: delay
Name: 1 sek

Dieser Node tut eigentlich nichts weiter, als jede eingehende Nachricht um eine Sekunde verzögert wieder auszusenden. Das erscheint zunächst wenig sinnvoll, aber nach der Beschreibung der restlichen Nodes wird es vielleicht klar: Beim Online-Statuswechsel auf true muss noch der letzte Blinkzyklus abgewartet werden und erst dann darf die Nachricht mit dem Farbwert green den letzten Node erreichen.

Node: trigger
Name: Blinken 1

Dieser Node ist so konfiguriert, dass er bei einer eingehenden Nachricht sofort eine Nachricht mit dem Payload 1 aussendet und dies anschließend jede Sekunde wiederholt. Das passiert so lange, bis eine Nachricht mit dem Payload stop empfangen wird.

Node: trigger
Name: Blinken 2

Dieser Node ist vom gleichen Typ wie Blinken 1, hat aber eine andere Konfiguration. Hier wird beim Empfang einer Nachricht sofort eine neue Nachricht mit dem Payload red ausgesendet und genau 500ms später eine weitere Nachricht mit dem Payload black. Wird wiederum eine Nachricht empfangen, dann beginnt der Vorgang erneut. Mit dem regelmäßigen Anstoß vom Node Blinken 1 im Sekundentakt erzeugt der Node Blinken 2 ein Blinksignal zwischen Rot und Schwarz.

Node: template
Name: Netzwerk

Flow 1 Bild 16 Mit einem template-Node hat man die Möglichkeit, selbst ein Anzeigeelement für das Dashboard zu bauen. Hier habe ich das genutzt, um ein WLAN-Symbol in der Größe 1x1 darzustellen, welches den Status der Online-Verbindung mit einer passenden Farbe anzeigt. Der template-Node besteht hier im Prinzip nur aus einem HTML-DIV-Tag, in dem ein fertiges Symbol dargestellt wird. Zwei zusätzliche Angaben sorgen dafür, dass das Symbol in der Mitte der Group [Haus] Netz erscheint, die übrigens eine Breite von einer Rastereinheit hat. Das Symbol Wifi stammt aus der freien Bibliothek Angular Material Icons und kann relativ einfach in die HTML-Struktur eingebunden werden. Dabei wird die im Payload übermittelte Farbe verwendet.

Flow 1 Bild 17 Flow 1 Bild 18 Abhängig von den vorherigen Nodes wird das Symbol dauerhaft Grün oder Rot blinkend dargestellt. Übrigens, ich habe diese Anzeige aus einem bestimmten Grund realisiert: Mein Anzeigemodul verliert gelegentlich kurz die Verbindung zum WLAN. Das passiert zwar nur ungefähr 1-2 mal täglich und das auch nur für wenige Sekunden. Allerdings benötigt Node-RED manchmal bis zu 3 Minuten, um die Verbindung zum MQTT-Server wieder aufzubauen und genau dieser Zustand soll signalisiert werden.

• Einstellungen definieren

Flow 1 Bild 19

Dieser Teil des Flows hat eine spezielle Aufgabe:

Flow 1 Bild 20 Hier werden keine Nachrichten bearbeitet und es findet auch kein Informationsfluss statt. Stattdessen wird der Inhalt dieses Nodes in die HTML-Struktur des Node-RED-Dashboards eingebaut. Das ermöglicht das Gestalten von Dashboard-Elementen durch andere Farben oder Schriften.

Grundsätzlich stehen 2 verschiedene Möglichkeiten zur Verfügung, mit denen man die Anzeigeelemente auf dem Dashboard beeinflussen kann. Die Zeilen 2-5 zeigen die Möglichkeit, alle Elemente eines bestimmten Node-Typs gleichermaßen zu ändern. So wird hier die Schriftgröße für alle artless gauge-Nodes auf 18 Pixel festgelegt. Die vom System vorgegebene Schrift ist etwas kleiner und mit der Änderung ergibt sich eine bessere Lesbarkeit.

Eine andere Möglichkeit demonstrieren die Zeilen 6-10. Diese definieren einen ganz neuen Schriftstil mit dem Namen text-datefont, der eine Schriftgröße von 23 Pixel sowie eine hellblaue Farbe festlegt. Diese Zeilen bewirken erst dann eine Änderung auf dem Dashboard, wenn bestimmte Anzeigeelemente von dieser Definition Gebrauch machen. Bei unserem Flow betrifft das die text-Nodes, für die Zeit und das Datum. Diese verwenden im Feld Value format unter anderem das Konstrukt class="text-datefont" und binden damit unseren vordefinierten Schriftstil ein.

Symbol Flow 2 - Empfang und Anzeige eines Sensorwertes (Flow2-Sensorwert.json)

Flow 2 Bild 1 Beim Import dieses Flows erscheint ein Hinweisfenster, welches am Anfang dieses Kapitels bereits erwähnt wurde. Es gibt hier einen Konflikt, weil im zu importierenden Flow ein Element enthalten ist, welches bereits im System existiert (Tab Haus). An dieser Stelle sollte man die Option Zeige Nodes... auswählen. Anschließend öffnet sich eine Liste mit einer Vorauswahl, die man direkt über den Button Importiere Auswahl übernehmen kann. Jetzt wird man beim Bewegen der Maus feststellen, dass die importierten Nodes an der Maus „hängen“. Damit lassen sich die Nodes an eine günstige Stelle schieben und durch einen Links-Klick ablegen. Nach der Platzierung der neuen Elemente zeigt sich folgendes Bild:

Flow 2 Bild 2

Dieser Flow demonstriert den Empfang eines Sensorwertes von einem MQTT-Server und die Anzeige dieses Wertes als virtuelles Instrument. An dieser Stelle noch einige Informationen über MQTT: Ein MQTT-Server ist ein Nachrichtenverteiler. Jedes Gerät, welches Informationen bereitstellt, kann sich mit dem MQTT-Server verbinden und seine Daten unter einem bestimmten Thema (Topic) auf dem Server ablegen. Andere Geräte können sich diese Informationen holen, in dem sie sich ebenfalls mit dem MQTT-Server verbinden und die gewünschten Topics abonnieren. Immer wenn neue Informationen auf dem Server eintreffen, denn werden diese sofort an alle Abonnenten verteilt. Beim Temperatur-Messsystem befindet sich der MQTT-Server mosquitto auf dem Web-Modul.

Node: mqtt in
Name: Wohnz T

Über diesen Node wird eine Verbindung zu einem MQTT-Server hergestellt und der Empfang eines bestimmten MQTT-Topic eingerichtet. Immer wenn neue Informationen vom Server empfangen werden, wird eine Nachricht mit dem gewählten Topic und den Daten als Payload zu weiteren Nodes gesendet. Auffällig ist das rote Dreieck am Node, dieses weist auf eine unvollständige Konfiguration hin. Deshalb sollte zuerst mit einem Doppelklick auf diesen Node dessen Einstellungen kontrolliert werden. Hier wird die fehlende Einstellung rot umrahmt hervorgehoben: Server Neuen mqtt-broker hinzufügen ... Unsere Node-RED-Installation hatte bisher noch keinen Kontakt zu einem MQTT-Server (auch MQTT-Broker genannt) und deshalb muss dieser erst mal eingerichtet werden.

Mit einem Klick auf das Stift-Symbol rechts neben Neuen mqtt-broker hinzufügen ... erscheint ein neues Fenster, in dem die Eigenschaften unseres MQTT-Servers festgelegt werden müssen. Hier brauchen wir nur 2 Felder zu beachten: Zum einen muss im Feld Name ein Name für den Server festgelegt werden, z.B. MeinMQTT und zum anderen muss in das Feld Server die IP-Adresse des Web-Moduls (wo sich normalerweise der MQTT-Server befindet) eingetragen werden, z.B. 192.168.1.222. Mit einem Klick auf den Button Hinzufügen wird der Server erstellt und das Fenster kann wieder geschlossen werden. Diese Aktion ist übrigens nur einmal erforderlich. Bei der Einrichtung weiterer MQTT-Nodes steht dieser Server bereits im Auswahlmenü.

Nach der Konfiguration des MQTT-Servers befinden wir uns wieder in den Einstellungen des mqtt in-Nodes. Hier muss jetzt noch das Feld Topic auf das eigene System angepasst werden. Ich habe hier beispielhaft Haus/EG/Wohnzimmer/Temperatur (Temperatur-Sensor im Wohnzimmer) verwendet. Sind alle Einstellungen korrekt, dann kann über den Button Fertig die neue Einstellung gespeichert werden. Jetzt sollte das rote Dreieck am Node verschwunden sein und mit einem Klick auf Übernahme (deploy) kann man den Flow jetzt starten. Dabei sollte folgendes auf dem Display des Anzeigemoduls zu sehen sein:

Flow 2 Bild 3

Das Gesamtbild mag noch nicht überzeugen (die Optimierung kommt später), dafür sind jetzt 2 neue Anzeigeelemente hinzugekommen:

Node: artless gauge
Name: Wohnz Anzeige 1

Dieser Node-Typ wurde bereits für die Anzeige der Systemauslastung verwendet und im Flow 1 beschrieben. Hier wurde die runde Variante mit einer Größe von 2x2 Rastereinheiten verwendet.

Node: gauge
Name: Wohnz Anzeige 2

Der hier verwendete Node gehört zur Grundausstattung des Node-RED-Dashboard. Dieser bietet nicht so viele Einstellmöglichkeiten wie der etwas neuere artless gauge-Node, kann aber für bestimmte Anwendungen die bessere Alternative sein. So gibt es hier zwar keine geraden Anzeigen, dafür aber 4 verschiedene runde Varianten. Ich habe hier das Standard-Gauge mit einer Größe von 3x2 Rastereinheiten gewählt.

Ich habe absichtlich den gleichen Sensorwert an beide gauge-Nodes ausgegeben, damit man die beiden Node-Typen direkt vergleichen kann. Für beide Nodes wurde übrigens die gemeinsam genutzte Group [Haus] Sensoren verwendet. Dabei wurde die Option Gruppenname anzeigen aktiviert, um auch das mal zu demonstrieren.

Node: ui control / change
Name: Start / Schriftgrößen

Beim gauge-Node ist es möglich (jedoch nicht unbedingt erforderlich) die Schriftgrößen in der Anzeige zu ändern (Name, Istwert, Minimal- und Maximalwert). Dafür sind diese beiden Nodes zuständig. Zunächst sendet ui control beim Systemstart und auch beim Start des Web-Browsers im Anzeigemodul eine Control-Nachricht aus. Diese wird vom nachfolgenden change-Node durch insgesamt 4 Steuernachrichten ersetzt und diese wiederum werden zum gauge gesendet. Dieser setzt dann die Schriftgrößen entsprechend. Falls man mehrere gauge-Nodes verwendet, dann sollte der Ausgang des change-Nodes Schriftgrößen mit allen gauges verbunden werden, damit diese Nodes identisch aussehen.

Symbol Flow 3 - Anzeige eines Diagramms mit Sensorwerten (Flow3-Sensordiagramm.json)

Auch in diesem Flow ist ein Element enthalten, welches bereits im System existiert (Tab Haus). Also auch hier im Hinweisfenster die Option Zeige Nodes... auswählen und über den Button Importiere Auswahl importieren. Nach der Platzierung der neuen Elemente im Editor-Fenster zeigt sich folgendes Bild:

Flow 3 Bild 1

Bei diesem Flow wird ebenfalls ein Sensorwert von einem MQTT-Server empfangen. Allerdings erfolgt keine direkte Anzeige des aktuellen Wertes, stattdessen werden Daten über einen längeren Zeitraum gesammelt und als Diagramm dargestellt. Die verwendeten Nodes haben folgende Funktion:

Node: mqtt in
Name: Außen T

Über diesen Node wird eine Verbindung zu einem MQTT-Server hergestellt und der Empfang eines bestimmten MQTT-Topic eingerichtet. Auch bei diesem Node zeigt das rote Dreieck an, dass die Konfiguration nicht vollständig ist. Ein Doppelklick auf diesen Node zeigt die fehlende Einstellung rot umrahmt an: Server Neuen mqtt-broker hinzufügen ... Da im vorherigen Beispiel bereits ein MQTT-Server eingerichtet wurde, ist es jetzt einfacher: Man kann nun einfach in das Feld klicken und den bereits eingerichteten MQTT-Server auswählen, z.B. MeinMQTT. Außerdem muss noch das Feld Topic auf das eigene System angepasst werden. Ich habe hier beispielhaft Haus/Aussen/Umgebung/Temperatur verwendet, unter diesem Topic wird auf meinem System die Außentemperatur übermittelt. Sind alle Einstellungen korrekt, dann kann über den Button Fertig die neue Einstellung gespeichert werden. Das rote Dreieck am Node sollte nun verschwunden sein und mit einem Klick auf Übernahme (deploy) kann man den Flow jetzt starten. Dabei sollte das Bild nach einer Laufzeit von 5 Minuten so aussehen:

Flow 3 Bild 2

Node: delay
Name: alle 5min

Grundsätzlich könnte man die vom mqtt in-Node empfangen Daten direkt zum Diagramm senden. Allerdings würden dann unter Umständen einige 1000 Datensätze im Diagramm landen, die viele Ressourcen benötigen und die Performance negativ beeinflussen. In der Praxis hat es sich bewährt, den Datenstrom zu reduzieren und z.B. nur alle 5 Minuten einen Wert an das Diagramm zu übergeben. Rein rechnerisch besteht das Diagramm dann nur noch aus 288 Datensätzen, die das System weniger belasten, aber trotzdem noch eine detaillierte Kurve erzeugen. Um einen Datenstrom zu bremsen, gibt es den delay-Node. Diesen habe ich so konfiguriert, dass alle 5 Minuten der gerade aktuelle Sensorwert weitergegeben wird. Alle in der Zwischenzeit eintreffenden Daten werden verworfen.

Node: chart
Name: Außen T Diagramm

Dieser Node ist für die Erstellung des Diagramms zuständig. Hier stehen viele Konfigurationsmöglichkeiten zur Verfügung: So kann aus 6 verschiedenen Diagrammtypen gewählt werden, der Zeitraum lässt sich festlegen, es lässt sich eine Legende aktivieren und es können auch mehrere Kurven gleichzeitig in unterschiedlichen Farben dargestellt werden. Für ein Diagramm muss man etwas mehr Platz auf dem Dashboard einplanen. In diesem Beispiel habe ich zunächst die Group Diagramme angelegt und diese auf eine Breite von 9 Rastereinheiten gesetzt. Der chart-Node selbst verwendet die Größeneinstellung Auto. Somit ist das Diagramm ebenfalls 9 Rastereinheiten breit und die Höhe bestimmt Node-RED selbst. Weitere Einstellungen möchte ich an dieser Stelle nicht beschreiben, hier darf man gern experimentieren.

Beim Start des Flows wird das Diagramm erst sichtbar, wenn der chart-Node mindestens einen Sensorwert empfangen hat. Nach dem Empfang des zweiten Wertes (nach 5 Minuten) wird dann auch eine Kurve dargestellt. Nach einer Laufzeit von mindestens 24 Stunden ergibt sich dann ein Diagramm wie in den nächsten Bildern. Übrigens, die Werte im Diagramm werden nicht gespeichert. Bei einem Neustart von Node-RED gehen alle Daten verloren und das Diagramm wird mit aktuellen Werten neu aufgebaut. Weiterhin gibt es noch eine schöne Funktion im Diagramm: Wenn man in den Bereich der Kurve auf das Display tippt, dann sieht man in einem kleinen Fenster die Uhrzeit, das Topic und den Sensorwert zu diesem Zeitpunkt. Man muss danach allerdings auf eine andere Stelle tippen, damit dieses Fenster wieder verschwindet.

Symbol Flow 4 - Großanzeige sowie Minimum und Maximum eines Sensorwertes (Flow4-Groß-Min-Max-Anzeige.json)

Auch in diesem Flow ist ein Element enthalten, welches bereits im System existiert (Tab Haus). Also auch hier im Hinweisfenster die Option Zeige Nodes... auswählen und über den Button Importiere Auswahl importieren. Nach der Platzierung der neuen Elemente im Editor-Fenster zeigt sich folgendes Bild:

Flow 4 Bild 1

Bei diesem Flow soll wieder ein Sensorwert von einem MQTT-Server empfangen werden. Ich habe mich hier für die Außentemperatur entschieden, die bereits im vorherigen Flow3-Sensordiagramm.json verwendet wird. Dabei ist es sinnvoll, alle Daten vom bereits vorhandenen mqtt in-Node Außen T zusätzlich an die neu importierten Nodes weiterzugeben. Man sollte also die neuen Nodes so im vorhandenen Flow platzieren und verbinden, dass sich folgendes Bild ergibt:

Flow 4 Bild 2

Jetzt ist der Flow komplett und kann mit einem Klick auf Übernahme (deploy) aktiviert werden. Dabei erscheint ein neuer Block mit 3 Werten auf dem Display des Anzeigemoduls, die beim Empfang des ersten Wertes zunächst identische Daten anzeigen. Nach einer längeren Laufzeit kann es ungefähr so aussehen wie im nächsten Bild:

Flow 4 Bild 3

Der neue Flow-Teil übernimmt die Außentemperatur, die bereits das Diagramm mit Daten versorgt, und erzeugt 3 neue Anzeigen: Der in großen Ziffern dargestellte Wert entspricht der aktuellen Temperatur, der kleinere Wert mit dem Pfeil nach oben ist der Maximalwert des Tages und der Wert mit dem Pfeil nach unten der Minimalwert der Nacht. Die Nodes im Flow haben dabei folgende Funktion:

Node: function
Name: Auswertung

Flow 4 Bild 4 Dieser Node ist nicht unbedingt notwendig. Ich fand es jedoch schön, die Farbe für die nachfolgende Großanzeige abhängig von der Temperatur zu gestalten und dies erfolgt mit einem kleinen JavaScript-Programm. Dieses legt zunächst die Farbe Orange fest. Im nächsten Schritt wird der empfangene Sensorwert in eine Zahl umgewandelt. Ist der Temperaturwert unter 0°C, dann wird die Farbe in einen leichten Blauton geändert, bei einem Temperaturwert über 28°C wird die Farbe auf Rot gesetzt.

Node: text
Name: Außen T groß

Dieser Node-Typ wurde bereits für die Anzeige des Datums und der Uhrzeit verwendet. Hier ist die Konfiguration ähnlich, es wurde allerdings eine andere Schriftgröße verwendet. Dieser text-Node befindet sich in der neuen Group [Haus] Groß-Min-Max, für die eine Breite von 6 Rastereinheiten festgelegt wurde. Der text-Node selbst belegt 4x2 Rastereinheiten.

Node: function
Name: Maxwert / Minwert

Flow 4 Bild 5 Beide Nodes machen vom Context-Speicher Gebrauch, der bereits bei der Ermittlung der Systemauslastung und CPU-Temperatur verwendet und beschrieben wurde. Hier ist das Programm für den Maximalwert abgebildet und dieses beginnt beim Empfang einer Nachricht mit dem Lesen des gespeicherten Maximalwertes. Ist noch kein Maximalwert vorhanden, dann wird der Startwert -50 verwendet. Anschließend erfolgt eine Prüfung, ob eine Reset-Nachricht empfangen wurde. In diesem speziellen Fall, der nur einmal am Tag auftritt, wird der Maximalwert auf -50 zurückgesetzt und gespeichert. Außerdem wird der Payload gelöscht und somit die Anzeige auf dem nachfolgenden Node geleert.

Beim Empfang einer normalen Nachricht (else-Zweig) erfolgt zunächst die Umwandlung des Payload in eine Zahl. Diese kann nun mit dem bisherigen Maximalwert verglichen werden und falls der Sensorwert größer ist, wird dieser als neuer Maximalwert gesetzt und gespeichert. Weiterhin wird dieser Wert mit einer festen Nachkommastelle versehen und wieder ausgesendet.

Der function-Node Minwert ist grundsätzlich identisch aufgebaut. Hier wird allerdings vom Startwert 100 ausgegangen und die Logik ist natürlich umgekehrt.

Node: inject
Name: 08:00 ↻ / 20:00 ↻

Dieser Node-Typ wurde bereits an anderer Stelle verwendet und hier sind die Nodes so konfiguriert, dass jeden Tag um 08:00 Uhr bzw 20:00 Uhr eine Nachricht gesendet wird. Die Nachricht um 08:00 Uhr wird im function-Node Maxwert ausgewertet und bewirkt das Löschen des Maximalwertes. Für die Löschung des Minimalwertes ist die Nachricht um 20:00 Uhr zuständig.

Node: text
Name: Außen T Max / Außen T Min

Diese Nodes sind ähnlich konfiguriert wie der text-Node Außen T groß, nutzen aber eine andere Schriftgröße und verwenden außerdem das Einstellungs-Feld Label. Dieses nutze ich hier für die Anzeige eines Symbols in Form eines Pfeils. Die Größe der beiden Nodes ist auf 2x1 Rastereinheiten festgelegt und diese befinden sich gemeinsam mit Außen T groß in der Group [Haus] Groß-Min-Max.

Node: template
Name: Schriftstile 2

Auch dieser Node-Typ sollte bereits bekannt sein. Hier werden die Schriftgrößen für die 3 text-Nodes festgelegt, eine sehr große Schrift für die Großanzeige sowie eine kleinere für die Minimal- und Maximalwerte sowie die Pfeilsymbole. Die Größen wurden übrigens so bemessen, dass auch noch ein Minuszeichen vor dem Wert Platz hat.

Symbol Flow 5 - Anzeige eines Alarms vom Temperatur-Messsystem (Flow5-Alarmanzeige.json)

Auch in diesem Flow ist ein Element enthalten, welches bereits im System existiert (Tab Haus). Also auch hier im Hinweisfenster die Option Zeige Nodes... auswählen und über den Button Importiere Auswahl importieren. Nach der Platzierung der neuen Elemente im Editor-Fenster zeigt sich folgendes Bild:

Flow 5 Bild 1

Bei diesem Flow wird der Status eines Alarms vom Temperatur-Messsystem empfangen und ausgewertet. Neben dem aktuellen Alarmstatus wird die Zeit des letzten Alarms ermittelt und zusammen mit der Anzahl der Alarme übersichtlich angezeigt. Die verwendeten Nodes haben folgende Funktion:

mqtt in Briefka A

Über diesen Node wird wiederum eine Verbindung zu einem MQTT-Server hergestellt und der Empfang eines bestimmten MQTT-Topic eingerichtet. Auch bei diesem Node zeigt das rote Dreieck an, dass die Konfiguration nicht vollständig ist. Ein Doppelklick auf diesen Node zeigt die fehlende Einstellung rot umrahmt an: Server Neuen mqtt-broker hinzufügen ... Da bereits ein MQTT-Server eingerichtet wurde, kann dieser durch einen Klick in des Feld einfach ausgewählt werden, z.B. MeinMQTT. Außerdem muss noch das Feld Topic auf das eigene System angepasst werden. Ich habe hier beispielhaft Haus/EG/Briefkasten/Status verwendet, unter diesem Topic wird auf meinem System die Öffnung und Schließung des Briefkastens übermittelt. Nach dem Speichern sollte das rote Dreieck am Node verschwunden sein und mit einem Klick auf Übernahme (deploy) kann man den Flow jetzt starten. Auf dem Display des Anzeigemoduls erscheint nun ein neuer Block mit dem Alarm:

Flow 5 Bild 2

Node: function
Name: Auswertung

Flow 5 Bild 3 Dieser Node wertet die empfangenen Alarm-Nachrichten aus und steuert die nachfolgende Anzeige. Ich habe hier nur den Kopfteil des Programms abgebildet, der insofern wichtig ist, weil hier persönliche Einstellungen vorgenommen werden können. So kann man in den Zeilen 1 und 2 die Werte festlegen, die in den MQTT-Nachrichten erwartet werden. Weiterhin lassen sich über die Zeilen 3 und 4 die anzuzeigenden Texte für den jeweiligen Alarmstatus definieren. Schließlich können in den Zeilen 5-7 noch 3 Farbwerte für die verschiedenen Anzeigen konfiguriert werden.

Das eigentliche Programm beginnt in Zeile 9 mit dem Laden von 3 Werten aus dem Context-Speicher (letzter Alarmstatus, Alarmzähler und letzte Alarmauslösung) und der Voreinstellung von Text und Farbe. Wird eine Alarmnachricht mit einem geänderten Status empfangen, dann werden bei Alarmauslösung die Werte für Text und Farbe geändert, der Alarmzähler erhöht und die aktuelle Zeit ermittelt. Diese Daten werden für die nachfolgende Anzeige noch etwas aufbereitet. Ein besonderer Fall ist der Empfang einer Steuernachricht um 0:01 Uhr, diese bewirkt das Löschen des Alarmzählers und der letzten Alarmzeit. Damit beginnt zum Tageswechsel eine neue Zählung.

Node: inject
Name: 0:01 ↻

Dieser bereits bekannte Node sendet in dieser Konfiguration jeden Tag um 0:01 Uhr eine Nachricht zum nachfolgenden function-Node und bewirkt damit eine Rücksetzung des Alarmzählers und der Zeit des letzen Alarms.

Node: template
Name: Briefk Alarm Anzeige

Flow 5 Bild 4 Für die Anzeige von Alarmen habe ich mit diesem template-Node selbst eine passende Anzeige gebaut. Diese hat grundsätzlich die Form einer Tabelle, die aus 2 Zeilen und 2 Spalten besteht. Die beiden linken Spalten haben einen festen Text. Auf der rechten Seite werden in beiden Zeilen Farbe und Text aus der Nachricht entnommen und für die Anzeige verwendet.

Flow 5 Bild 5 Dieses Bild ist zu sehen, wenn der Briefkastendeckel geöffnet, also der Alarm ausgelöst wird. Der rote Text weist hier auf den von der Normalität abweichenden Zustand hin. Darunter steht die Zeit der Auslösung und in Klammern die Anzahl der Alarme an diesem Tag.

Flow 5 Bild 6 In diesem Bild ist der Alarm wieder in den Ruhezustand zurückgekehrt. An der Zeit und dem Zähler ist aber weiterhin zu erkennen, dass der Alarm einmal ausgelöst wurde. Der weiter oben beschriebene inject-Node sorgt zum Tageswechsel für die Löschung der Zeit und des Zählers.

Node: template
Name: Formate

Obwohl dieser Node vom gleichen Typ ist wie der soeben beschriebene Briefk Alarm Anzeige, so hat er doch eine andere Funktion. Hier werden keine Informationen direkt auf dem Dashboard ausgegeben, allerdings CSS-Einstellungen für die Anzeigen festgelegt. Diese werden übrigens nicht nur für die Alarme verwendet, sondern auch für die weiter unten beschriebenen Kraftstoffpreise. Somit haben alle Anzeigen, die die Einstellungen dieses template-Nodes verwenden, ein identisches Layout.

Symbol Flow 6 - Empfang und Anzeige von Wetterdaten (Flow6-Wetterdaten1.json und Flow6-Wetterdaten2.json)

Bei diesem (und auch dem nachfolgenden) Flow gibt es eine Besonderheit. Hier werden Informationen aus dem Internet abgefragt, aufbereitet und angezeigt. Dabei sollte man die Aufgaben etwas aufteilen:

Diese Teilung hat den großen Vorteil, dass nur eine zyklische Abfrage beim Wetterdienst notwendig ist und alle Geräte im Haus auf diese Daten zugreifen können. Weiterhin zeigen dadurch alle Geräte identische Informationen an. Technisch gesehen spricht natürlich nichts dagegen, alle Aufgaben auf dem Anzeigemodul auszuführen. Dazu gibt es weiter unten mehr Informationen.

• Teilaufgabe 1: Wetterdaten abfragen und über MQTT verteilen (Flow6-Wetterdaten1.json)

Wichtig: Die folgenden Schritte werden auf dem Web-Modul ausgeführt. Hier muss zunächst ein zusätzlicher Node installiert werden. Allerdings sollte man vorher kontrollieren, ob dieser Node nicht vielleicht schon vorhanden ist. Dazu klicken wir im Node-RED-Editor oben rechts auf das Menü-Symbol und wählen die Option Palette verwalten. Es erscheint eine Übersicht über die bereits installierten Nodes und sollte hier node-red-node-openweathermap in der Liste erscheinen, kann die nachfolgende Installation übersprungen werden. Anderenfalls wechseln wir jetzt zum Tab Installieren. Dort gibt es ein Suchfeld und hier geben wir openweathermap ein, anschließend sollte der Node node-red-node-openweathermap in der Trefferliste erscheinen. Mit einem Klick auf den kleinen Button Installieren auf der rechten Seite erscheint zunächst ein Hinweisfenster. Hier hat man die Möglichkeit, den Vorgang abzubrechen, weitere Informationen zu holen oder eben mit einem Klick auf installieren den Installationsvorgang zu starten. Das dauert einige Sekunden und anschließend wird kurz eine Erfolgsmeldung angezeigt.

Jetzt sind alle Voraussetzungen erfüllt und der Flow Flow6-Wetterdaten1.json kann importiert werden. Auch hier könnte ein Hinweisfenster erscheinen, wenn node-red-node-openweathermap bereits installiert war und dieser außerdem im Flow verwendet wird. In diesem Fall sollte die Option Zeige Nodes... im Hinweisfenster ausgewählt und nur der Node Wetter senden markiert werden. Anschließend erfolgt der Import über den Button Importiere Auswahl und nach der Platzierung der neuen Elemente im Editor-Fenster zeigt sich folgendes Bild:

Flow 6 Bild 1

Falls nur der mqtt out-Node Wetter senden importiert wurde, dann sollte dieser jetzt mit dem Ausgang des bereits vorhandenen Wetter-Node verbunden werden. Hier ist dann auch keine weitere Konfiguration des Wetter-Nodes notwendig. Ansonsten hat dieser Flow-Teil die Aufgabe, alle 2 Minuten den Wetterdienst abzufragen und die übermittelten Informationen zum MQTT-Server zu senden. Die Nodes haben hier folgende Funktion:

Node: inject
Name: 2 min ↻

Dieser bereits bekannte Node sendet in dieser Konfiguration 1 Sekunde nach dem Flow-Start und anschließend alle 2 Minuten eine Nachricht zum nachfolgenden openweathermap-Node und startet damit eine Abfrage des Wetterdienstes.

Node: openweathermap
Name: Wetter

Dieser Node hat die Aufgabe, eine Anfrage an den Wetterdienst OpenWeatherMap.org zu senden und die aktuellen Wetterinformationen für einen bestimmten Ort abzufragen. Obwohl für die Konfiguration nur 2 Angaben erforderlich sind, ist der Aufwand etwas größer:

API KeyHier muss der aus 32 Hex-Zeichen bestehende API-Key von OpenWeatherMap eingetragen werden. Dafür ist eine Registrierung bei https://openweathermap.org/price erforderlich. Hier wählt man die Free-Version, die für unsere Zwecke völlig ausreichend ist.
OrtHier wird der Ort eingetragen. OpenWeatherMap kennt allerdings nicht jeden Ort, deshalb sollte man bei kleineren Orten auf der Web-Seite https://openweathermap.org/ prüfen, ob der gewünschte Ort verfügbar ist. Falls der Ortsname Umlaute enthält, dann sollte man zuerst die Schreibweise mit Umlauten probieren und im Fehlerfall den Namen mit umschriebenen Umlauten eingeben. Alternativ kann man den Ort auf Koordinaten umschalten und die GPS-Koordinaten eingeben.

Übrigens, falls man die Dienste von OpenWeatherMap.org bereits nutzt, dann kann man den vorhandenen Account nutzen und dessen API-Key verwenden oder einfach einen weiteren Key generieren.

Node: mqtt out
Name: Wetter senden

Bei diesem Node ist ein rotes Dreieck zu erkennen, was wieder auf eine unvollständige Konfiguration hinweist. In den Einstellungen ist dann rot umrahmt die entscheidende Option Server Neuen mqtt-broker hinzufügen ... zu erkennen. Hier muss mit einem Klick in das Feld der bereits vorhandene MQTT-Server ausgewählt werden. Weiterhin ist es erforderlich, das Feld Topic an das eigene System anzupassen. Ich habe hier Haus/Info/Wetter/aktuell eingetragen, über dieses Topic werden auf meinem System die aktuellen Wetterinformationen verteilt.

Nachdem die Konfiguration nun vollständig ist, kann der Flow mit einem Klick auf Übernahme (deploy) gestartet werden. Wenn alles passt, dann werden jetzt alle 2 Minuten die aktuellen Wetterinformationen im JSON-Format zum MQTT-Server gesendet. Allerdings hat man an dieser Stelle keine Möglichkeit, die ordnungsgemäße Funktion des Wetterdatenempfangs zu prüfen. Hier gibt es 2 Empfehlungen:

Jetzt geht es auf dem Anzeigemodul 4 weiter und da sollen nun die Wetterinformationen empfangen und dargestellt werden.

• Teilaufgabe 2: Wetterdaten über MQTT empfangen und anzeigen (Flow6-Wetterdaten2.json)

Wichtig: Die folgenden Schritte werden wieder auf dem Anzeigemodul ausgeführt. Hier kann jetzt die Datei Flow6-Wetterdaten2.json importiert werden. Dabei wird wieder ein Hinweis erscheinen, da in diesem Flow ein Element enthalten ist, welches bereits im System existiert (Tab Haus). Also auch hier wieder im Hinweisfenster die Option Zeige Nodes... auswählen und die Vorauswahl über den Button Importiere Auswahl importieren. Nach der Platzierung der neuen Elemente im Editor-Fenster zeigt sich folgendes Bild:

Flow 6 Bild 2

Bei diesem Flow werden die zuvor im Web-Modul geholten und über MQTT gesendeten Wetterinformationen vom MQTT-Server empfangen und die Wetterlage sowie die Winddaten in Form eines Textfeldes angezeigt. Zusätzlich erscheint die Windrichtung in einem runden Anzeigeelement. Die hier verwendeten Nodes haben folgende Funktion:

Node: mqtt in
Name: Wetter

Über diesen Node wird wiederum eine Verbindung zu einem MQTT-Server hergestellt und der Empfang eines bestimmten MQTT-Topic eingerichtet. Auch bei diesem Node zeigt das rote Dreieck an, dass die Konfiguration unvollständig ist. Ein Doppelklick auf diesen Node zeigt die fehlende Einstellung rot umrahmt an: Server Neuen mqtt-broker hinzufügen ... Da bereits ein MQTT-Server eingerichtet wurde, kann dieser einfach über einen Klick in das Feld ausgewählt werden, z.B. MeinMQTT. Außerdem muss noch das Feld Topic auf das eigene System angepasst werden. Ich habe hier beispielhaft Haus/Info/Wetter/aktuell verwendet, unter diesem Topic werden auf meinem System (wie schon erwähnt) die aktuellen Wetterinformationen übermittelt. Nach dem Speichern sollte das rote Dreieck am Node verschwunden sein und mit einem Klick auf Übernahme (deploy) kann man den Flow jetzt starten. Auf dem Display des Anzeigemoduls erscheinen 2 neue Anzeigen, eine mit dem aktuellen Wettertext und eine weitere mit der Windrichtung:

Flow 6 Bild 3

Node: function
Name: Auswertung

Dieser Node holt sich aus dem JSON-Paket mit den Wetterinformationen die Wetterlage, die Windgeschwindigkeit und die Windrichtung und baut daraus einen String für den nachfolgenden Node. Die Wetterlage bzw. Wetterbeschreibung ist bereits als Klartext in den Wetterinformationen enthalten, die restlichen Daten müssen umgerechnet und umgeformt werden. So wird die Windgeschwindigkeit in m/s übermittelt und diese muss in km/h umgerechnet werden. Die Windrichtung, die in Grad übermittelt wird, wandelt das Programm in die Himmelsrichtung um und verwendet zur Darstellung ein passendes Pfeilsymbol. Das Programm wertet nur einen kleinen Teil der verfügbaren Informationen aus. Insgesamt stehen folgende Daten zur Verfügung:

Node: text
Name: Wetter

Dieser Node bringt die vom vorherigen Node generierten Wetterdaten auf das Dashboard. Die Konfiguration ist ähnlich wie den bereits beschriebenen Nodes für die Anzeige der Zeit und des Datums. Davon abweichend ist die Einstellung der Group. Hier wird eine eigene Group mit dem Namen [Haus] Wetter mit einer Breite von 12 Rastereinheiten verwendet. Der text-Node selbst ist auf die Größe von 12x1 Rastereinheiten gesetzt. Damit steht genug Platz zur Verfügung, falls der Wettertext etwas länger ist.

Node: function
Name: Windrichtung

Dieser Node holt sich aus dem JSON-Paket mit den Wetterinformationen nur die Windrichtung und rechnet diese etwas um. Üblicherweise geben Wetterdienste die Richtung an, aus der der Wind herkommt. Ich addiere hier 180 Grad und das ergibt die Richtung, wo der Wind hinweht. Der nachfolgende Node zeigt also die reale Windrichtung an.

Node: gauge
Name: Wind

Dieser Node-Typ kam bereits für die Anzeige eines Sensorwertes zum Einsatz. Hier wird allerdings die Darstellung Compass verwendet, die ein kreisrundes Anzeigeelement erzeugt. Die Größe ist hier auf 3x3 Rastereinheiten eingestellt und für die Anzeige wurde die Group [Haus] Wind mit einer Breite von 3 Rastereinheiten angelegt.

Übrigens, falls man die Verarbeitung der Wetterdaten vollständig auf dem Anzeigemodul einrichten möchte, dann müssen beide Teil-Flows (Flow6-Wetterdaten1.json und Flow6-Wetterdaten2.json) auf dem Anzeigemodul importiert und anschließend folgendermaßen verbunden werden:

Flow 6 Bild 4

Symbol Flow 7 - Empfang und Anzeige von Kraftstoffpreisen (Flow7-Kraftstoffpreise1.json und Flow7-Kraftstoffpreise2.json)

Auch bei diesem Flow gibt es eine Besonderheit. Hier werden Informationen aus dem Internet abgefragt, aufbereitet und angezeigt und diese Aufgaben sollten aufgeteilt werden:

Auch hier hat diese Teilung den großen Vorteil, dass nur eine zyklische Abfrage beim Dienstleister notwendig ist und alle Geräte im Haus auf diese Daten zugreifen können. Weiterhin zeigen dadurch alle Geräte identische Informationen an. Technisch gesehen spricht natürlich nichts dagegen, alle Aufgaben auf dem Anzeigemodul auszuführen. Dazu gibt es weiter unten mehr Informationen.

• Teilaufgabe 1: Kraftstoffpreise abfragen und über MQTT verteilen (Flow7-Kraftstoffpreise1.json)

Wichtig: Die folgenden Schritte werden auf dem Web-Modul ausgeführt. Hier muss zunächst ein zusätzlicher Node installiert werden. Dazu klicken wir im Node-RED-Editor oben rechts auf das Menü-Symbol und wählen die Option Palette verwalten. Hier wechseln wir jetzt zum Tab Installieren und geben in das Suchfeld tanker ein, anschließend sollte der Node node-red-contrib-tankerkoenig-api in der Trefferliste erscheinen. Mit einem Klick auf den kleinen Button Installieren auf der rechten Seite erscheint zunächst ein Hinweisfenster. Hier hat man die Möglichkeit, den Vorgang abzubrechen, weitere Informationen zu holen oder eben mit einem Klick auf installieren den Installationsvorgang zu starten. Das dauert einige Sekunden und anschließend wird kurz eine Erfolgsmeldung angezeigt.

Noch eine wichtige Information vorab: Unter dem Namen Tankerkönig wird eine kostenlose Abfrage von Kraftstoffpreisen angeboten. Daran sind einige Bedingungen geknüpft: Es ist eine Registrierung erforderlich und man bekommt dann einen API-Key zugewiesen. Damit sind dann Abfragen möglich, die aber nicht häufiger als alle 5 Minuten stattfinden dürfen. Letzteres ist unbedingt zu beachten, da es sonst zur Sperrung des API-Keys kommen kann. Bei Node-RED gibt es noch die Besonderheit, dass jede Übernahme (deploy)-Aktion zur einer erneuten Abfrage führt. Hier muss man bei Arbeiten am Flow etwas aufpassen und gegebenenfalls den Tankerkönig-Node vorübergehend deaktivieren.

Jetzt sind alle Voraussetzungen erfüllt und der Flow Flow7-Kraftstoffpreise1.json kann importiert werden. Hier sollte normalerweise kein Konflikt auftreten und nach der Platzierung der neuen Elemente im Editor-Fenster zeigt sich folgendes Bild:

Flow 7 Bild 1

Die Nodes haben hier folgende Funktion:

Node: Tankerkönig Prices (Interval)
Name: Tanken

Dieser Node hat die Aufgabe, eine Anfrage an Tankerkönig zu senden und die aktuellen Kraftstoffpreise von ausgewählten Tankstellen abzufragen. Hier ist wieder ein rotes Dreieck zu erkennen, die Konfiguration muss also noch vervollständigt werden:

AccountHier muss neben dem Eingabefeld auf das Stiftsymbol geklickt und ein neuer Eintrag angelegt werden. Dazu ist eine Registrierung auf der Seite https://creativecommons.tankerkoenig.de (Unterseite API-KEY) erforderlich.
TypeHier wird die Kraftstoffsorte ausgewählt.
StationsIn diese Liste müssen die gewünschten Tankstellen eingetragen werden. Dazu ist neben einem frei wählbaren Namen die so genannte Station-ID erforderlich. Diese kann über die Seite https://creativecommons.tankerkoenig.de/TankstellenFinder/index.html ermittelt werden. Die Bedienung der Seite ist etwas ungewöhnlich, Hilfe bekommt man über das Symbol am unteren Bildrand.

Node: mqtt out
Name: Tanken senden

Auch bei diesem Node wird durch ein rotes Dreieck auf eine unvollständige Konfiguration hingewiesen. Auch hier ist zunächst der bereits vorhandene MQTT-Server auszuwählen. Weiterhin ist es erforderlich, das Feld Topic an das eigene System anzupassen. Ich habe hier Haus/Info/Tanken/Preise eingetragen, über dieses Topic werden auf meinem System die Kraftstoffpreise verteilt. Eine weitere Einstellung ist vielleicht noch interessant: Retain ist hier auf Wahr gesetzt. Das bewirkt, dass die letzte Nachricht auf dem MQTT-Server zwischengespeichert wird. Wenn sich nun ein neues Gerät mit dem MQTT-Server verbindet und die Kraftstoffpreise abonniert, dann wird sofort diese zwischengespeicherte Nachricht zugestellt und es muss nicht auf das nächste Intervall gewartet werden.

Nachdem die Konfiguration nun vollständig ist, kann der Flow mit einem Klick auf Übernahme (deploy) gestartet werden. Wenn alles passt, dann werden jetzt im eingestellten Intervall die aktuellen Kraftstoffpreise im JSON-Format zum MQTT-Server gesendet. Ähnlich wie beim Wetter hat man an dieser Stelle keine Möglichkeit, die ordnungsgemäße Funktion des Datenempfangs zu prüfen. Aber auch hier gibt es 2 Empfehlungen:

Jetzt geht es auf dem Anzeigemodul 4 weiter und da sollen nun die Wetterinformationen empfangen und dargestellt werden.

• Teilaufgabe 2: Kraftstoffpreise über MQTT empfangen und anzeigen (Flow7-Kraftstoffpreise2.json)

Wichtig: Die folgenden Schritte werden wieder auf dem Anzeigemodul ausgeführt. Hier kann jetzt die Datei Flow7-Kraftstoffpreise2.json importiert werden. Dabei wird wieder ein Hinweis erscheinen, da in diesem Flow ein Element enthalten ist, welches bereits im System existiert (Tab Haus). Also auch hier wieder im Hinweisfenster die Option Zeige Nodes... auswählen und die Vorauswahl über den Button Importiere Auswahl importieren. Nach der Platzierung der neuen Elemente im Editor-Fenster zeigt sich folgendes Bild:

Flow 7 Bild 2

Bei diesem Flow werden die zuvor im Web-Modul geholten und über MQTT gesendeten Kraftstoffpreise vom MQTT-Server empfangen und in einem Textfeld angezeigt. Die hier verwendeten Nodes haben folgende Funktion:

Node: mqtt in
Name: Tanken

Über diesen Node wird wiederum eine Verbindung zu einem MQTT-Server hergestellt und der Empfang eines bestimmten MQTT-Topic eingerichtet. Auch bei diesem Node zeigt das rote Dreieck an, dass die Konfiguration unvollständig ist. Ein Doppelklick auf diesen Node zeigt die fehlende Einstellung rot umrahmt an: Server Neuen mqtt-broker hinzufügen ... Da bereits ein MQTT-Server eingerichtet wurde, kann dieser einfach über einen Klick in das Feld ausgewählt werden, z.B. MeinMQTT. Außerdem muss noch das Feld Topic auf das eigene System angepasst werden. Ich habe hier beispielhaft Haus/Info/Tanken/Preise verwendet, unter diesem Topic werden auf meinem System (wie schon erwähnt) die aktuellen Kraftstoffpreise übermittelt. Nach dem Speichern sollte das rote Dreieck am Node verschwunden sein und mit einem Klick auf Übernahme (deploy) kann man den Flow jetzt starten. Auf dem Display des Anzeigemoduls erscheint nun zusätzlich eine unauffällige Anzeige mit den Kraftstoffpreisen:

Flow 7 Bild 3

Node: function
Name: Auswertung

Flow 7 Bild 4 Dieser Node ermittelt zunächst aus dem JSON-Paket mit den Kraftstoffpreisen die Anzahl der übermittelten Tankstellen-Datensätze. Anschließend werden alle Datensätze geprüft: Ist eine Tankstelle gerade geöffnet, dann wird der Preis auf 2 Nachkommastellen gekürzt (die typische 9 an der dritten Stelle wird dabei aufgerundet), ein €-Zeichen angehängt und dieses Konstrukt als zusätzliches Element in den Payload eingefügt. Bei geschlossener Tankstelle wird alternativ die Zeichenkette (zu) verwendet.

Node: template
Name: Kraftstoff

Flow 7 Bild 5 Dieser Node bringt die vom vorherigen Node übermittelten Tankstellennamen und Kraftstoffpreise auf das Dashboard. Dafür habe ich selbst eine passende Anzeige gebastelt, wobei diese ähnlich aufgebaut wurde wie die etwas weiter oben beschriebene Alarm-Anzeige. Auch hier wurde eine Tabelle mit 2 Spalten als Basis verwendet, wobei die linke Seite zusammengefasst und mit einem festen Tanksäulen-Symbol belegt wurde. Die rechten beiden Zeilen zeigen dann die Namen und Preise aus den ersten beiden Datensätzen an. Das Anzeigefeld hat hier eine Größe von 6x1 Rastereinheiten und wurde in der Group [Haus] Kraftstoff untergebracht, die auf eine Breite von 6 Rastereinheiten eingestellt ist.

Übrigens, falls man mehr als 2 Tankstellen anzeigen möchte, dann kopiert man einfach diesen Node durch Markieren und anschließendes Drücken von Strg-C und Strg-V). Danach verbindet man den neuen Node zusätzlich mit dem Ausgang des function-Node Auswertung. In den Einstellungen ändert man nun die in eckigen Klammern stehenden Index-Werte von [0] in [2] bzw. von [1] in [3] (ist jeweils zweimal notwendig). Das bewirkt, dass ein neues Anzeigeelement erzeugt wird, welches die Datensätze 3 und 4 anzeigt. Dieses befindet sich dann ebenfalls in der Group [Haus] Kraftstoff und wird direkt unter dem bereits vorhandenen Anzeigeelement angeordnet.

Hinweis: Sollte die Anzeige nicht so aussehen wie im Screenshot weiter oben, dann könnte das daran liegen, dass der Flow 5 (Anzeige eines Alarms vom Temperatur-Messsystem) nicht importiert wurde. Hier ist ein Node enthalten, der auch für die Anzeige der Kraftstoffpreise notwendig ist. Auch wenn die Alarm-Anzeige nicht benötigt wird, sollte man jetzt die Datei Flow5-Alarmanzeige.json importieren und bei der Auswahl der zu importierenden Nodes nur den template-Node Formate übernehmen.

Übrigens, falls man die Verarbeitung der Kraftstoffpreise vollständig auf dem Anzeigemodul einrichten möchte, dann müssen beide Teil-Flows (Flow7-Kraftstoffpreise1.json und Flow7-Kraftstoffpreise2.json) auf dem Anzeigemodul importiert und anschließend folgendermaßen verbunden werden:

Flow 7 Bild 6

Symbol Weitere Informationen

Wenn alle Beispiel-Flows importiert worden sind, dann bekommt man schon eine Menge Informationen angezeigt. Aber: Diese sind mehr oder weniger chaotisch auf dem Display angeordnet. Hier muss also etwas Ordnung geschaffen werden. Der Node-RED-Editor bietet im Info-Bereich auf der rechten Seite 6 Auswahlmöglichkeiten an. Je nach Bildschirmgröße werden meist 5 davon als kleine Symbole und daneben ein kleiner Pfeil angezeigt. Über diesen Pfeil lässt sich ein Menü öffnen, wo dann alle 6 Möglichkeiten aufgelistet werden. Wir benötigen jetzt das Dashboard, welches im Menü an der letzten Stelle steht.

Weiteres Bild 1 Nach Auswahl der Menü-Option Dashboard gelangt man in die Einstellungen des Dashboards. Diese gliedert sich in die 3 Untermenüs Layout, Site und Theme. An dieser Stelle ist das bereits ausgewählte Untermenü Layout interessant: Hier bekommt man eine strukturierte Liste mit allen eingerichteten Tabs, Groups und Links angezeigt (Links wurden allerdings hier nicht verwendet). Auf dem Bild ist ein Teil der Struktur zu sehen, die sich aus unseren Beispiel-Flows ergibt. Ganz oben ist das Tab Haus und innerhalb dieses Tabs findet man die Groups System 1, Datum, Zeit usw. Wiederum innerhalb der Groups sind die verschiedenen Anzeigeelemente angeordnet.

Diese Liste ist nicht einfach nur eine Übersicht, hier lässt sich auch die Reihenfolge aller Komponenten ändern. So kann man beispielsweise eine Group mit der Maus greifen und an eine andere Position verschieben. Ebenso lässt sich ein Anzeigeelement aufnehmen und an eine andere Stelle innerhalb einer Group oder sogar in eine andere Group verschieben. Bei letzteren Verschiebungen muss man ein wenig auf die eingestellten Größen achten und diese gegebenenfalls korrigieren. Auch das ist hier einfach möglich: Wenn die Maus über ein Element bewegt wird, erscheint ein Button Bearbeiten und je nach Element weitere Buttons.

Noch einige Empfehlungen zur Größe von Groups und Elementen: Das Display des Anzeigemoduls 4 kann vom Dashboard mit 18x14 Rastereinheiten belegt werden. Hier bietet es sich an, für Groups eine Breite von 6, 9 oder 12 Rastereinheiten festzulegen. Damit lassen sich diese Groups recht gut nebeneinander anordnen (3x6, 2x9 oder 6+12). Für die Anzeigeelemente haben sich Größen von 6x1 für lineare und 2x2 für runde Skalen (Artless Gauge) bewährt, damit passen diese perfekt in eine Group mit 6 Rastereinheiten (1x linear oder 3x rund). Bei den Standard-Gauges ergeben 3x2 oder 3x3 eine gute Anzeige, somit passen 2 davon in eine Group mit 6 Rastereinheiten. Alarme und Info-Elemente sind mit 6x1 ebenfalls gut zu kombinieren. Diagramme kann man auf einer Fläche von 6x3 Rastereinheiten unterbringen, aber das wird dann recht klein. Hier passt eine Größe von 9x5 besser.

Alle Elemente bieten bei der Einstellung der Größe auch die Option Auto an. Diese kann man z.B. gut bei Text-Anzeigen, den linearen Skalen und bei Diagrammen anwenden. Dabei wird das Element immer genau so breit dargestellt wie die Group, in dem sich das Element befindet. Späteres Verschieben von Elementen in andere Groups oder Größenänderungen von Groups sind dann etwas einfacher.

Mit einigen Verschiebungen, wenigen Größenanpassungen und dem Weglassen der linearen Skala für die Systemauslastung kann man unser Testflow-Projekt etwas übersichtlicher gestalten:

Weiteres Bild 2

Weiteres Bild 3 Dieses Bild zeigt nochmals den oberen Teil der Menü-Option Dashboard. Das hier ausgewählte Untermenü Site ermöglicht grundsätzliche Einstellungen des Node-RED-Dashboards. So kann man hier einen Titel für das Dashboard festlegen, die Menüfunktion beeinflussen (die hier allerdings nicht genutzt wird) und weiter unten auch die Größe der Rastereinheiten und die Abstände zwischen den Elementen bestimmen. Damit lässt sich die Anzeige ein wenig optimieren: Ich habe auf meinem Anzeigemodul die voreingestellte 1x1 Widget-Größe von Horizontal 48 auf 50 geändert. Das hat den Effekt, dass die Ränder links und rechts auf dem Display nicht so groß sind. Die beiden nachfolgenden Bilder zeigen den oberen Teil des Displays zunächst mit der Voreinstellung 48 und darunter mit 50.

Weiteres Bild 4

Weiteres Bild 5

Alternativ kann man auch mit den Abständen experimentieren. Eine Änderung bei den vertikalen Werten ist übrigens nicht notwendig, hier sind die Ränder optimal.

Über das dritte Untermenü Theme der Dashboard-Einstellungen kann man auf die Farben Einfluss nehmen. Zur Auswahl stehen neben den beiden festen Stilen Hell (Standard) und Dunkel ein benutzerdefinierter Stil zur Verfügung. Letzterer erlaubt mehr Einstellungen und zusätzlich auch die Speicherung von mehreren Stilen in einer internen Bibliothek. Für die Beispiel-Flows habe ich übrigens den Stil Dunkel verwendet.

Hier sind noch einige Tipps für die Arbeit mit dem Node-RED-Editor. Viele bekannte Tastenkombinationen können auch bei Node-RED verwendet werden:

Klick auf NodeNode wird markiert
Klick auf Node mit gedrückter Strg-TasteNode wird zusätzlich markiert
Strg-Amarkiert alle Nodes im aktuellen Editor-Tab
Strg-Calle markierten Nodes werden in eine interne Zwischenablage kopiert
Strg-Xalle markierten Nodes werden in eine interne Zwischenablage verschoben
Strg-Vder Inhalt der internen Zwischenablage wird eingefügt
Entfalle markierten Nodes werden gelöscht

Beim Kopieren und Verschieben von Nodes werden auch alle Einstellungen der Nodes übertragen. Beim Löschen von Nodes verschwindet der Node mit allen Einstellungen vom Editor-Feld. Übergeordnete Einstellungen wie z.B. der MQTT-Server sowie gewählte Groups und Tabs bleiben erhalten, auch wenn sie nicht mehr genutzt werden. Node-RED gibt beim Klick auf Übernahme (deploy) einen Hinweis aus, wenn nicht verwendete Nodes vorhanden sind und ein Link führt zur Auflistung dieser Elemente. Diese kann man dann mit den Tastenkombinationen aus der Tabelle löschen. Fast alle Elemente haben außerdem eine Löschfunktion oben links, wenn man das Element mit einem Doppelklick öffnet. Das funktioniert übrigens auch bei Editor-Tabs, die man dann einfach umbenennen oder löschen kann.

Alle beschriebenen Beispiel-Flows können und dürfen selbstverständlich nach Belieben kombiniert, erweitert oder auch wieder gelöscht werden. Alle Datenquellen, die kontinuierliche Werte liefern, bieten sich auch für eine Darstellung als Diagramm an. Das kann man z.B. bei vielen Wetterdaten und auch bei Kraftstoffpreisen anwenden. Ich habe bei meinem Anzeigemodul auch noch weitere Elemente realisiert, die ich aber in diesem Rahmen nicht beschreiben werde. Für deren Realisierung sind spezielle Voraussetzungen erforderlich, die zum Teil einen recht hohen Aufwand erfordern:

Der nachfolgende Screenshot zeigt das Display meines Anzeigemoduls zum Zeitpunkt der Texterstellung:

Weiteres Bild 6

SymbolWartung

Bei jedem Computersystem wird empfohlen, regelmäßig Daten zu sichern und Updates durchzuführen. Mit einer Datensicherung erspart man sich die komplette Inbetriebnahme und Konfiguration bei einem Systemausfall. Ich empfehle die regelmäßige Abarbeitung der folgenden Schritte.

Symbol Schritt 1 - Daten sichern (Backup)

Eine Datensicherung des gesamten Systems ist am einfachsten, wenn man die SD-Karte aus dem Raspberry Pi entnimmt, diese in einem PC Sektor für Sektor ausliest und das Ergebnis als Image-Datei speichert. In einem Notfall kann man auf die gleiche Weise das Image wieder auf die SD-Karte schreiben und bekommt damit exakt den gleichen Zustand wie beim Erstellen des Backups. Zum Entnehmen der Karte muss zunächst das System heruntergefahren und abgeschaltet werden. Dazu ist der Poweroff-Taster vorgesehen und muss dafür mindestens 2 Sekunden lang gedrückt werden. Alternativ kann man natürlich auch eine SSH-Verbindung zum Anzeigemodul, z.B. mit PuTTY herstellen und folgendes Kommando eingeben:

sudo poweroff

In jedem Fall sollte man abwarten, bis der Raspberry Pi vollständig heruntergefahren ist, was man daran erkennt, dass die grüne LED 10 mal blinkt. Falls die LEDs des Raspberry Pi nicht sichtbar sind, dann sollte man das Display beobachten und noch eine angemessene Zeit (30 Sekunden) warten, bevor man das Anzeigemodul abschaltet. Jetzt kann man die SD-Karte gefahrlos entnehmen und über einen Kartenleser an einen PC anschließen. Vermutlich wird sich Windows jetzt melden und die SD-Karte formatieren oder reparieren wollen. Ein solcher Hinweis muss unbedingt über die Option Abbrechen abgelehnt werden.

Win32 Disk Imager lesen Für die weitere Arbeit wird der Win32 Disk Imager benötigt. Im Feld Image File wird über das kleine Symbol ein Name und ein Speicherort für das Backup-Image ausgewählt bzw. eingegeben. Im Feld Device wählen wir einen der beiden Laufwerks-Buchstaben der SD-Karte (Windows 10 erkennt 2 Partitionen auf der SD-Karte). Nun wird auf den Button Read geklickt und der Lese-Vorgang beginnt, der je nach Speichergröße der Karte einige Zeit dauern kann. Das nebenstehende Bild zeigt den Win32 Disk Imager beim Lesevorgang. Nach Bestätigung der Erfolgsmeldung kann das Programm beendet und die SD-Karte über die „Auswerfen“-Funktion auf der Windows-Taskleiste vom System abgemeldet werden. Die SD-Karte kommt nun wieder in den Raspberry Pi und die Stromversorgung wird eingeschaltet. Nach ungefähr 90 Sekunden sollte unser Anzeigemodul dann wieder vollständig aktiv sein.

Die erzeugte Image-Datei sollte gut aufgehoben werden, mit dieser lässt sich das Anzeigemodul jederzeit wiederherstellen. Wie das funktioniert, beschreibe ich im Schritt 4 dieser Anleitung.

Symbol Schritt 2 - System updaten

Um das Raspberry Pi OS und die installierte Software auf den aktuellen Stand zu bringen, ist eine SSH-Verbindung (z.B. mit PuTTY) zum Anzeigemodul notwendig. Anschließend werden 2 Kommandos verwendet, die vielleicht noch von der Inbetriebnahme bekannt sind. Über das erste Kommando stellt das Raspberry Pi OS Verbindungen zu mehreren Servern her und holt sich Informationen über die aktuellen Softwarestände:

sudo apt-get update

Mit dem zweiten Kommando werden zunächst alle installierten Pakete aufgelistet, die nicht auf dem neuesten Stand sind. Nach der Bestätigung einer Sicherheitsabfrage mit Enter beginnt der Update-Vorgang:

sudo apt-get upgrade

Dieses Kommando kann einige Zeit in Anspruch nehmen. Es ist möglich, dass während der Installation Textfenster mit Informationen erscheinen und auf eine Bestätigung warten - dies kann man mit der Taste Q erledigen. Oft werden beim Update auch Systemdateien erneuert, deshalb empfiehlt sich ein Neustart des Raspberry Pi OS nach erfolgreichem Update:

sudo reboot

Dabei verliert PuTTY die SSH-Verbindung zum Anzeigemodul. Nach einer Wartezeit von ungefähr 45 Sekunden kann man sich mit einem Klick auf das kleine Symbol links auf der Titelzeile von PuTTY und der Auswahl der Option Restart Session wieder einloggen.

Symbol Schritt 3 - Node-RED updaten

Das Update von Schritt 2 hat leider keinen Einfluss auf Node-RED. Das liegt daran, dass Node-RED direkt von der Entwickler-Seite installiert wurde, um eine möglichst aktuelle Version zu bekommen. Updates müssen deshalb ebenfalls über diesen Weg installiert werden und dafür wird das gleiche Kommando wie bei der Installation verwendet:

bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)

Anschließend erscheint ein Text und 2 Abfragen, die jeweils mit Y und Enter bestätigt werden müssen. Auch dieses Update nimmt etwas mehr Zeit in Anspruch. Nicht wundern: Während des Update-Vorgangs wird Node-RED angehalten und das führt zu einer Fehlermeldung auf dem Display.

Auch das Update für das Node-RED-Dashboard erfolgt über Kommandos:

cd ~/.node-red
npm i node-red-dashboard

Nach der Update-Prozedur muss Node-RED jetzt wieder gestartet werden:

sudo systemctl start nodered

Nach einer Wartezeit von 10-15 Sekunden sollte auf dem Display wieder das Node-RED-Dashboard erscheinen. Hier kommt es gelegentlich vor, dass der Inhalt nicht ganz so aussieht wie erwartet. Das ist nicht schlimm und wird nach dem finalen Neustart wieder gut. Zunächst starten wir den Node-RED-Editor über einen Web-Browser. Mit einem Klick auf das Menü-Symbol wird das Hauptmenü geöffnet und die Funktion Palette verwalten ausgewählt. Es erscheint nun ein Fenster, in dem alle installierten Nodes mit der aktuellen Software-Version aufgelistet werden. Rechts neben jedem Node sind verschiedene Optionen sichtbar und hier sollte man auf Hinweise wie z.B. Aktualisierung auf 0.2.7 achten. Mit einem Klick auf das Update-Feld erscheint eine Sicherheitsabfrage und nach deren Bestätigung wird das Update gestartet. Oft erscheint anschließend ein Hinweisfenster, welches auf einen notwendigen Neustart von Node-RED hinweist. Das tun wir auch zum Schluss, zunächst sollten aber alle anstehenden Updates durchgeführt werden. Wenn alles erledigt ist, empfiehlt sich ein Neustart des gesamten Systems. Dieser wird wieder über die SSH-Verbindung ausgelöst:

sudo reboot

Nach ungefähr 90 Sekunden erscheint dann wieder das Dashboard auf dem Display des Anzeigemoduls und sollte auch wieder ordentlich aussehen. Übrigens, auch das Node-RED-Dashboard erscheint im Menü Palette verwalten und kann grundsätzlich auch hier geupdatet werden. Allerdings findet man es oft im Status In Gebrauch vor und ein Update ist dann nicht möglich.

Nachdem man sich davon überzeugt hat, dass alles wieder funktioniert, können die Wartungsarbeiten abgeschlossen werden.

Symbol Schritt 4 - Daten wiederherstellen (Restore) (im Notfall)

Sollte aus irgendeinem Grund das Betriebssystem oder eine installierte Software nicht mehr funktionieren, dann lässt sich über ein Restore in relativ kurzer Zeit das System wieder herstellen. Das geht allerdings nur, wenn vor nicht all zu langer Zeit der Schritt 1 der Wartungsempfehlungen durchgeführt wurde und ein Backup-Image vorliegt. Ist ein Restore erforderlich, dann kann man den Raspberry Pi direkt ausschalten, die SD-Karte entnehmen und an einen PC anschließen. Vermutlich wird sich Windows jetzt melden und die SD-Karte formatieren oder reparieren wollen, diesen Hinweis bitte über Abbrechen bestätigen.

Für die weitere Arbeit wird der Win32 Disk Imager benötigt. Im Feld Image File wird über das kleine Symbol das Backup-Image ausgewählt, welches auf die SD-Karte geschrieben werden soll. Im Feld Device wählen wir den ersten Laufwerks-Buchstaben, welcher der SD-Karte zugewiesen wurde. Hier muss man sehr sorgfältig auswählen, damit nicht ein falsches Laufwerk überschrieben wird. Wenn man absolut sicher ist, wird auf den Button Write geklickt und die anschließende Sicherheitsabfrage bestätigt. Danach beginnt der Schreibvorgang, der abhängig von der Speicherkapazität und Qualität der SD-Karte einige Zeit dauern kann. Nach Bestätigung der Erfolgsmeldung kann das Programm wieder beendet und die SD-Karte über die „Auswerfen“-Funktion auf der Windows-Taskleiste vom System abgemeldet werden. Die SD-Karte kommt nun wieder in den (noch ausgeschalteten) Raspberry Pi und die Stromversorgung wird eingeschaltet. Nach ungefähr 90 Sekunden sollte unser Anzeigemodul wieder aktiv sein und sich genau in dem Zustand wie vor dem Anlegen des Backups befinden.

Noch ein Hinweis zur SD-Karte: Soll das Backup-Image nicht auf die originale SD-Karte zurückgeschrieben werden, dann kann es passieren, dass der Win32 Disk Imager das Schreiben verweigert, obwohl eine Karte gleicher Größe verwendet wird. Leider unterscheiden sich scheinbar gleich große Karten von verschiedenen Herstellern geringfügig in der Anzahl der Sektoren, so dass eine Partition nicht geschrieben werden kann, wenn die neue Karte auch nur um einen Sektor kleiner ist. Die einfachste Lösung ist in diesem Fall, eine Karte mit höherer Speicherkapazität zu verwenden, also z.B. die ursprüngliche 8GB-Karte durch eine 16GB-Karte zu ersetzen.