Diesmal gibt es wieder kleinen Ausflug in die Bastelecke. Ich habe mir ein LED Matrix Panel mit 64×32 LEDs zugelegt und steuere es mit einem ESP8266 NodeMCU an. Aber einfach nur vordefinierte Dinge anzeigen ist ja langweilig. Also musste eine Verbindung zur Außenwelt her. Was eignet sich also besser als MQTT.

Die Hardware

Zum Einsatz kommen ein NodeMCU, ein LED Matrix Panel 64×32, ein normales 5Volt USB Netzteil, sowie viele Jumper Kabel

Das LED Panel erhältst du hier.

Im ersten Schritt muss das Panel mit dem NodeMCU verkabelt werden. Das ist etwas Fummelei. Wie das genau zu funktionieren hat, wird von Brian Lough sehr gut beschrieben. Er nutzt im Beispiel einen Wemos D1, du kannst aber problemlos einen NodeMCU ESP8266 nutzen und einfach die entsprechenden Pins nutzen. Sie sind identisch beschriftet.

Als Netzteil nutze ich ein normales 5Volt USB Netzteil. Einfach den USB Anschluss abschneiden und die Drähte über Klemmen mit Jumper Kabeln verbinden. So lässt sich das Netzteil wunderbar benutzen. Achte darauf, dass das Netzteil genug Power hat. 2,5A sollten es schon sein.

Die Programmierung der LED Matrix

Der sogenannte Sketch ist relativ einfach. In meinem Fall zeige ich die Außentemperatur an. Je nach Temperatur ändert sich die Schriftfarbe. Der Clou: Die Datenübertragung findet über MQTT stattt. So ist es problemlos möglich beliebige Daten von openHAB an die Matrix zu senden und anzeigen zu lassen. Auch mehrere Daten im Wechsel sind kein Problem.

Falls du noch nie mit dem NodeMCU gearbeitet hast und die Entwicklungsumgebung erst einrichten musst, findest du eine super Anleitung bei OpenDataLab. Hier wird dir alles Schritt für Schritt erklärt.

Der NodeMCU

Sobald das erledigt ist und du deinen NodeMCU mit der Arudino IDE programmieren kannst, können wir damit beginnen den Code für die Matrix zu programmieren.

Die benötigten Bibliotheken

Für dieses Projekt benötigen wir folgende Bibliotheken einige Bibliotheken, die, sofern noch nicht geschehen, installiert werden müssen. Das wird im Menü Sketch – Bibilothek einbinden – Bibliotheken verwalten. Es öffnet sich der Bibliotheksverwalter. Hier über die Suche die folgenden Bibliotheken suchen und installieren:

  • Ticker (sollte bereits vorinstalliert sein)
  • PxMatrix
  • ESP8266WiFi
  • PubSubClient
  • ESP8266mDNS
  • WiFiUdp

Der Code sieht folgendermaßen aus:

Die Werte für SSID und Password müssen durch die eigenen Netzwerkdaten ersetzt werden. Sollte ein eigener MQTT Broker im Einsatz sein, ist auch die entsprechende Adresse bei mqtt_server einzutragen. Solange keine sensiblen Daten übertragen werden, kann auch durchaus auf einen openMQTT Service zurückgegriffen werden. In diesem Fall muss nichts geändert werden. Wichtig: Der NodeMCU unterstützt nur das 2,4 GHz Band.

const char* ssid = „XXXXXXXXX“;
const char* password = „12345678“;
const char* mqtt_server = „broker.hivemq.com“;

Gehe weiter bis zu der Stelle, an der du die Topics abonnierst:

//MQTT TOPICS EINTRAGEN
client.subscribe(„Haus/openhab“);
client.subscribe(„Haus/Matrix/Temperatur“);
client.subscribe(„Haus/Matrix/Zeit“);

Wie du sehen kannst, gibt es bei mir 3 Topics.

Haus/openhab
Dieses Topic sorgt dafür, dass du per MQTT die Anzeige der Daten auf der Matrix aktivieren/deaktivieren kannst.

Haus/Matrix/Temperatur
Die Temperatur wird als String auf dieses Topic übertragen und vom NodeMCU empfangen.

Haus/Matrix/Zeit
Die Zeit wird als String auf dieses Topic übertragen und vom NodeMCU empfangen.

Nun springe zu folgender Stelle:

Hier tauchen die zuvor abonnierten Topics wieder auf. Solltest du andere Topics verwendet haben, musst du diese an dieser Stelle ebenfalls ändern.

Jetzt sind alle vorbereitungen abgeschlossen und wir können endlich damit beginnen die Anzeige auf der Matrix zu programmieren.

Ausgabe auf der LED Matrix programmieren

Die Ausgabe auf der Matrix wird im Loop des Sketches programmiert. Dazu springe an folgende Stelle unten im Code:

Der oben stehende Code sorgt dafür, dass Uhrzeit und Feuchtigkeit im Wechsel auf der LED Matrix angezeigt werden, bzw. der Bildschirm komplett ausgeschaltet wird.

unsigned long currentMillis = millis();
if (millis() – previousMillis >= 10000 ) {
previousMillis = currentMillis;

Dieser Teil sorgt dafür, dass der nachstehende Code innerhalb der geschweiften Klammer alle 10 Sekunden ausgeführt wird. 10000 steht für für 10 Sekunden. Hier kannst du natürlich auch längere Zeiten einstellen.

//Bildschirm 1
if (bildschirm == 1){
fragt ab, ob die Variable Bildschirm aktuell den Wert 1 hat. Das ist wichtig, damit der Text durchgewechselt werden kann.

display.fillRect(1, 0, 64, 32, myBLACK);
zeichnet ein Rechteck beginnend bei Position 1, 0 (x, y Achse) mit der Breite von 64 Pixeln und einer Höhe von 32 Pixeln. Das entspricht der Größe der Matrix. Dadurch wird eventuell zuvor stehender Text „gelöscht“

display.setTextSize(1);
setzt die Schriftgröße auf 1. Entspricht einer Höhe von 7 Pixeln.

display.setTextColor(myYELLOW);
setzt die Schriftfarbe auf Gelb.

display.setCursor(1,1);
Positioniert den Startpunkt ab dem geschrieben wird. x und y Achse.

display.print(„Zeit“);
schreibt das Wort „Zeit“

display.setTextSize(2);
setzt die Schriftgröße auf 2. Enspricht einer Höhe von 14 Pixeln

display.setTextColor(myWHITE);
setzt die Schriftfarbe auf Weiß

display.setCursor(1, 16);
Positioniert den Startpunkt ab dem geschrieben wird. x und y Achse.

display.print(zeit);
Schreibt die Variable „Zeit“, die den empfangenen MQTT Wert enthält

bildschirm = 2;
setzt die Variable bildschirm auf 2, damit der 2. Bildschirm mit der Luftfeuchtigkeit angezeigt werden kann
}

Das ganz wiederholt sich für den 2. Bildschirm.

//BILDSCHIRM AUS
else if (openhab == 0){
display.fillRect(0, 0, 64, 32, myBLACK);
}
Wenn openhab == 0, dann wird ein schwarzes Rechteck gezeichnet. Es wird also kein Text mehr angezeigt.

Damit wäre der Code für den NodeMCU fertig.

 

Werte von openHAB via MQTT  an LED Matrix senden

Jetzt müssen nur noch die entsprechenden Werte aus openHAB über MQTT an die Matrix gesendet werden. Ich setze an dieser Stelle zur Vereinfachung voraus, dass in deiner Installation bereits Items für Zeit und Feuchtigkeit existieren. Es kann sich natürlich auch um beliebig andere Werte handeln. Das Prinzip bleibt das gleiche. Zum Einsatz kommt das MQTT2 Binding in openHAB. Wie das korrekt eingerichtet wird, erfährst du hier.

Dummy Items anlegen

Um die Daten zu per MQTT zu senden, ist grundsätzlich kein weiteres Dummy Item notwendig. Allerdings werden die Daten im Normalfall in einer unpassenden Darstellung ausgeliefert. Bei der Zeit Beispielsweise wird Datum, Stunden, Minuten, Sekunden, etc. ausgegeben. Das soll für die Ausgabe natürlich etwas „aufgeräumter“ aussehen. Daher habe ich in einer dummies.items Datei folgende Dummy Items angelegt:

Diese Items können direkt in der Regel umformatiert werden, so dass die gewünschte Ausgabe herauskommt. Die Regel zu beiden Werten sehen folgendermaßen aus.

Ausgelöst wird die Regel jede Minute, damit sich die Uhrzeit auch minütlich aktualisiert.

val String Zeit_MQTT = Zeit.state.format(„%1$tH:%1$tM“)
Hier wird dem Dummy Item Zeit_MQTT der Wert des ursprünglichen Zeit Items zugewiesen – allerdings bereits formatiert. In diesem Fall entspricht es der Darstellung HH:MM.

val mqttActions = getActions(„mqtt“,“mqtt:broker:brokerhome“)
Hier ist der von dir eingerichtete MQTT Broker einzutragen, an den die Werte gesendet werden sollen. Die Anleitung findest du hier.

mqttActions.publishMQTT(„Haus/Matrix/Zeit“,Zeit_MQTT)
Hier gibst du das Topic an, an das der Wert gesendet werden soll. Dieses muss natürlich mit dem Topic übereinstimmen, welches du im NodeMCU Code hinterlegt hast.

Die Regel für das Senden der Luftfeuchtigkeit wird nur bei Änderung der Luftfeuchtigkeit ausgelöst, um nicht unnötig die gleichen Daten durch die Gegend zu schicken.

val String Feuchtigkeit_MQTT = Luftfeuchte_Schnitt.state.format(„%.1f%%“)
Auch hier wird dem Dummy Item der formatierte Wert des ursprünglichen Luftfeuchte Items übergeben. In diesem Fall wird die Luftfeuchte mit einer Nachkommastelle angezeigt.

val mqttActions = getActions(„mqtt“,“mqtt:broker:brokerhome“)
Hier ist der von dir eingerichtete MQTT Broker einzutragen, an den die Werte gesendet werden sollen. Die Anleitung findest du hier.

mqttActions.publishMQTT(„Haus/Matrix/Zeit“,Zeit_MQTT)
Hier gibst du das Topic an, an das der Wert gesendet werden soll. Dieses muss natürlich mit dem Topic übereinstimmen, welches du im NodeMCU Code hinterlegt hast.

Geschafft – Die LED Matrix erwacht

Das wars! Jetzt solltest du auf deiner LED Matrix Werte von openHAB angezeigt bekommen. Die Möglichkeiten der Darstellung sind vielfältig. Auf dem folgenden Bild kannst du eine alternative Darstellung für Zeit, Temperatur und aktuellem Stromverbrauch. Falls du etwas Ähnlichliches umgesetzt hast, oder mit Hilfe dieser Anleitung kreativ wudest, schreib mir. Ich freue mich über Leserprojekte zu berichten.

Das MQTT2 Binding ist scheinbar noch nicht ganz fehlerfrei. So kann es bei der mqttActions nach einer gewissen Zeit zu Fehlern beim Senden kommen. Das Problem ist wohl in opeHAB 2.5 behoben worden. Falls du V2.4 nutzt, solltest du auf diesen Fehler gefasst sein