• Skip to main content
  • Skip to secondary menu
  • Zur Hauptsidebar springen
  • Zur Fußzeile springen
  • Alle Produkte
  • Werkzeuge
  • Basics
  • Angebote

Zukunft at home

Vernetze dein Zuhause!

  • Startseite
  • openHAB
  • Tools
  • KNX
  • Regeln
  • Alexa
  • Selbst gebaut
  • Leserprojekte
  • Shop

LED Matrix selbst programmieren und mit openHAB verknüpfen

28. Juni 2019 geschrieben von Patrick Kommentar verfassen

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

AZDelivery ⭐⭐⭐⭐⭐ NodeMCU Lua Amica Modul V2 ESP8266 ESP-12E WiFi WiFi Development Board mit...
AZDelivery ⭐⭐⭐⭐⭐ NodeMCU Lua Amica Modul V2 ESP8266 ESP-12E WiFi WiFi Development Board mit CP2102 und gratis eBook!
AZDelivery ⭐⭐⭐⭐⭐ NodeMCU Lua Amica Modul V2 ESP8266 ESP-12E WiFi WiFi Development Board mit...
6,29€
Auf Lager
3 neu ab 6,29€
Jetzt kaufen
Amazon.de
AZDelivery ⭐⭐⭐⭐⭐ 3 x 40 Stk. Jumper Wire m2m/f2m/f2f für Arduino Breadboard
AZDelivery ⭐⭐⭐⭐⭐ 3 x 40 Stk. Jumper Wire m2m/f2m/f2f für Arduino Breadboard
AZDelivery ⭐⭐⭐⭐⭐ 3 x 40 Stk. Jumper Wire m2m/f2m/f2f für Arduino Breadboard
5,49€
Auf Lager
3 neu ab 5,49€
Jetzt kaufen
Amazon.de
Rydges EU 5V 3A Micro USB Stecker Netzteil DC Adapter Strom Kabel für Raspberry Pi 3 Model B /...
Rydges EU 5V 3A Micro USB Stecker Netzteil DC Adapter Strom Kabel für Raspberry Pi 3 Model B / Raspberry Pi 2 Model B ( die ausreichende Leistungsreserve )
Rydges EU 5V 3A Micro USB Stecker Netzteil DC Adapter Strom Kabel für Raspberry Pi 3 Model B /...
Ausverkauft
Jetzt kaufen
Amazon.de
Letztes Update am 24. Februar 2021 21:58

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:

NodeMCU LED Matrix per MQTT ansteuern
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
/*******************************************************************
Daten per MQTT empfangen und über eine 64x32 LED Matrix ausgeben.
Ansprechen der LED Matrix umgesetzt von Brian Laugh
Gesamter Sketch umgesetzt von https://zukunftathome.de
*******************************************************************/
 
#include <Ticker.h>
#include <PxMatrix.h>
// The library for controlling the LED Matrix
// Needs to be manually downloaded and installed
// https://github.com/2dom/PxMatrix
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
 
 
const char* ssid = "XXXXXXXXX";
const char* password = "12345678";
const char* mqtt_server = "broker.hivemq.com";
 
unsigned long previousMillis;
 
String temperatur;
String zeit;
 
int openhab;
int bildschirm = 1;
 
 
WiFiClient espClient;
PubSubClient client(espClient);
void setup_wifi() {
  delay(100);
 
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  randomSeed(micros());
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}
 
 
Ticker display_ticker;
 
// Pins for LED MATRIX
#define P_LAT 16
#define P_A 5
#define P_B 4
#define P_C 15
#define P_OE 2
#define P_D 12
#define P_E 0
 
// PxMATRIX display(32,16,P_LAT, P_OE,P_A,P_B,P_C);
// PxMATRIX display(64,32,P_LAT, P_OE,P_A,P_B,P_C,P_D);
PxMATRIX display(64, 32, P_LAT, P_OE, P_A, P_B, P_C, P_D, P_E);
 
// Some standard colors
uint16_t myRED = display.color565(255, 0, 0);
uint16_t myGREEN = display.color565(0, 255, 0);
uint16_t myBLUE = display.color565(0, 0, 255);
uint16_t myLIGHTBLUE = display.color565(0, 153, 255);
uint16_t myWHITE = display.color565(255, 255, 255);
uint16_t myYELLOW = display.color565(255, 255, 0);
uint16_t myCYAN = display.color565(0, 255, 255);
uint16_t myMAGENTA = display.color565(255, 0, 255);
uint16_t myBLACK = display.color565(0, 0, 0);
uint16_t currentCOLOR;
 
uint16 myCOLORS[8] = {myRED, myGREEN, myBLUE, myWHITE, myYELLOW, myCYAN, myMAGENTA, myBLACK};
 
// ISR for display refresh
void display_updater()
{
  display.display(20);
}
 
 
//MQTT DATEN IN VARIABLEN SCHREIBEN
void callback(char* topic, byte* payload, unsigned int length)
{
  Serial.print("Command from MQTT broker is : [");
  Serial.print(topic);
 
  Serial.println();
  Serial.print(" publish data is:");
  display.setTextColor(myGREEN);
  
char* payload_str;
  payload_str = (char*) malloc(length + 1);
  memcpy(payload_str, payload, length);
  payload_str[length] = '\0';
  
   if(String(topic) == "Haus/openhab"){
      if(String(payload_str) == "on"){
         openhab = 1;
         }
    else if(String(payload_str) == "off"){
         openhab = 0;
         }
   }  
 
   else if(String(topic) == "Haus/Matrix/Feuchtigkeit"){
         (String)payload_str;
         temperatur = (String)payload_str;
         }
   else if(String(topic) == "Haus/Matrix/Zeit"){
         (String)payload_str;
         zeit = (String)payload_str;
         }
 
}
      
 
void reconnect() {
  
  while (!client.connected())
  {
    Serial.print("Attempting MQTT connection...");
    display.clearDisplay();
    display.drawPixel(0, 0, myRED);
    
    
    String clientId = "YOU_CHOOSE_id";
    clientId += String(random(0xffff), HEX);
 
    if (client.connect(clientId.c_str()))
    {
      Serial.println("connected");
      display.clearDisplay();
      display.drawPixel(0, 0, myGREEN);
 
      //MQTT TOPICS EINTRAGEN
      client.subscribe("Haus/openhab");
      client.subscribe("Haus/Matrix/Feuchtigkeit");
      client.subscribe("Haus/Matrix/Zeit");
      
      //VARIABLE OPENHAB BEI START AUF 1, DAMIT DIREKT DIE DATEN ANGEZEIGT WERDEN
      openhab = 1;
      
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      delay(6000);
    }
  }
}
 
 
void setup() {
  Serial.begin(9600);
  
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  
  display.begin(16);
  display.clearDisplay();
  Serial.print("Pixel draw latency in us: ");
  unsigned long start_timer = micros();
  display.drawPixel(1, 1, 0);
  unsigned long delta_timer = micros() - start_timer;
  Serial.println(delta_timer);
 
  Serial.print("Display update latency in us: ");
  start_timer = micros();
  display.display(0);
  delta_timer = micros() - start_timer;
  Serial.println(delta_timer);
 
  display_ticker.attach(0.002, display_updater);
  yield();
  display.clearDisplay();
  delay(500);
 
 
 
//OTA Programmierung, damit der NodeMCU auch per WLAN programmiert werden kann
ArduinoOTA.setHostname("LED_Matrix");
  ArduinoOTA.onStart([]() {
    Serial.println("Start");
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("\nEnd");
  });
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("Error[%u]: ", error);
    if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
    else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
    else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
    else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
    else if (error == OTA_END_ERROR) Serial.println("End Failed");
  });
  ArduinoOTA.begin();
  Serial.println("Ready");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());  
}
 
void loop() {
  if (!client.connected()) {
    reconnect();
  }
  
  client.setCallback(callback);
  client.loop();
  ArduinoOTA.handle();
 
 
 
    if (openhab == 1) {
 
    //Zeit einstellen, in der die einzelnen Screens wechseln 10000 entspricht 10 Sekunden
    unsigned long currentMillis = millis();
    if (millis() - previousMillis >= 10000 ) {
    previousMillis = currentMillis;
 
    //Bildschirm 1
    if (bildschirm == 1){      
      display.fillRect(1, 0, 64, 32, myBLACK);
      display.setTextSize(1);
      display.setTextColor(myYELLOW);
      display.setCursor(1,1);
      display.print("Zeit");
      display.setTextSize(2);
      display.setTextColor(myWHITE);
      display.setCursor(1, 16);
      display.print(zeit);
      bildschirm = 2;
    }
 
    //Bildschirm 2
    else if (bildschirm == 2){
 
      display.fillRect(1, 0, 64, 32, myBLACK);
      display.setTextSize(1);
      display.setTextColor(myYELLOW);
      display.setCursor(1,1);
      display.print("Feuchte");
      display.setTextSize(2);
      display.setTextColor(myWHITE);
      display.setCursor(1, 16);
      display.print(feuchtigkeit);
      bildschirm=1;
    }
   }
  }
}

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
   if(String(topic) == "Haus/openhab"){
      if(String(payload_str) == "on"){
         openhab = 1;
         }
    else if(String(payload_str) == "off"){
         openhab = 0;
         }
   }  
 
   else if(String(topic) == "Haus/Matrix/Feuchtigkeit"){
         (String)payload_str;
         feuchtigkeit = (String)payload_str;
         }
   else if(String(topic) == "Haus/Matrix/Zeit"){
         (String)payload_str;
         zeit = (String)payload_str;
         }

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
if (openhab == 1) {
 
    //Zeit einstellen, in der die einzelnen Screens wechseln 10000 entspricht 10 Sekunden
    unsigned long currentMillis = millis();
    if (millis() - previousMillis >= 10000 ) {
    previousMillis = currentMillis;
 
    //Bildschirm 1
    if (bildschirm == 1){      
      display.fillRect(1, 0, 64, 32, myBLACK);
      display.setTextSize(1);
      display.setTextColor(myYELLOW);
      display.setCursor(1,1);
      display.print("Zeit");
      display.setTextSize(2);
      display.setTextColor(myWHITE);
      display.setCursor(1, 16);
      display.print(zeit);
      bildschirm = 2;
    }
 
    //Bildschirm 2
    else if (bildschirm == 2){
 
      display.fillRect(1, 0, 64, 32, myBLACK);
      display.setTextSize(1);
      display.setTextColor(myYELLOW);
      display.setCursor(1,1);
      display.print("Feuchte");
      display.setTextSize(2);
      display.setTextColor(myWHITE);
      display.setCursor(1, 16);
      display.print(feuchtigkeit);
      bildschirm=1;
    }
   }
  }
  
  //BILDSCHIRM AUS
  else if (openhab == 0){
     display.fillRect(0, 0, 64, 32, myBLACK);
  }

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:

dummies.items
1
2
String Zeit_MQTT
String Feuchtigkeit_MQTT

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.

Regel Zeit per MQTT senden
1
2
3
4
5
6
7
8
rule "Zeit MQTT"
when
Time cron "0 0/1 * 1/1 * ? *"
then
val String Zeit_MQTT = Zeit.state.format("%1$tH:%1$tM")
val mqttActions = getActions("mqtt","mqtt:broker:brokerhome")
mqttActions.publishMQTT("Haus/Matrix/Zeit",Zeit_MQTT)
end

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.

Luftfeuchte per MQTT senden
1
2
3
4
5
6
7
8
rule "Luftfeuchte MQTT"
when
Item Luftfeuchte_Schnitt received update
then
val String Feuchtigkeit_MQTT = Luftfeuchte_Schnitt.state.format("%.1f%%")
val mqttActions = getActions("mqtt","mqtt:broker:brokerhome")
mqttActions.publishMQTT("Haus/Matrix/Feuchtigkeit",Feuchtigkeit_MQTT)
end

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

Kategorie: Allgemein, openHAB, Selbst gebaut Stichworte: LED, LED Matrix, Matrix, MQTT, NodeMCU

Leser-Interaktionen

Schreibe einen Kommentar Antworten abbrechen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Haupt-Sidebar

Suche

Neuigkeiten

Logitech Harmony Firmware Update sperrt lokalen Netzwerkzugriff

Logitech Harmony Hub nach Firmware Update unbrauchbar

Nach einem Firmware Update bei Logitech Harmony (Hub) kann keine Verbindung mehr mit openHAB hergestellt werden. Der Grund: Logitech hat sich dazu entschieden die, nach eigener Aussage, „nicht offiziellen“ APIs zu sperren, um die Sicherheit zu gewährleisten. Den ganzen Artikel findest du hier. Das dürfte für viele Nutzer der nicht gerade günstigen Fernbedienung für viel […]

(Sinnvolle) openHAB Regeln

Bewässerung für den Garten automatisieren

Bewässerung komplett automatisieren

In Artikel Gartenbewässerung selbst bauen und über openHAB steuern habe ich gezeigt wie du mit Hilfe eines NodeMCU und openHAB eine smarte Bewässerung realisieren kannst. Böse Zungen behaupten das Ein- und Ausschalten über das Smartphone oder den Rechner ist nicht wirklich smart 😉 Darum wird die Gartenbewässerung jetzt komplett automatisiert, so dass kein manueller Eingriff mehr notwendig […]

Leserprojekte

Leserprojekt Andy: Ultraschallsensor in alter Funksteckdose

Ultraschallsensor in Funksteckdose – Leserprojekt von Andy

Heute stelle ich euch ein Leseprojekt vor. Andy war so freundlich und hat Zukunft at home Bilder von der Umsetzung des eigenen Ultraschallsensors zukommen lassen. Der Clou: Die gesamte Ultraschallsensor Technik ist in einer alten Funksteckdose untergebracht – inklusive Netzteil. So kann die ganze Einheit in die Steckdose gesteckt werden und benötigt keine weitere Halterung […]

Top Beiträge & Seiten

Gartenbewässerung selbst bauen und über openHAB steuern
Stromzähler und aktuellen Stromverbrauch in openHAB darstellen
Raspberry Pi von SSD booten
Fernbedienung selbst bauen und per MQTT ansteuern

Neuste Kommentare

  • Harald bei Stromzähler und aktuellen Stromverbrauch in openHAB darstellen
  • Harald bei Stromzähler und aktuellen Stromverbrauch in openHAB darstellen
  • Bob Bobber bei Raspberry Pi von SSD booten

Tags

3D Druck Alexa Amazon Alexa Astro Astro Binding Automation Beleuchtung Bewässerung Binding Datenbank Diagramm Echo Entwicklung ESP8266 Fritz!Box Fritz! DECT Installation KNX Licht MQTT mySQL NodeMCU openHab openHABian Philips Hue Raspberry Raspberry Pi Regel Regeln Round Robin rrd4j SD Karte selbstgebaut Setup Smarthome Sprachsteuerung Steckdose Temperatursensor Thermostat Tools Ultraschallsensor Update Upgrade Visual Studio Code Zeitschaltuhr

Archiv

Meta

  • Anmelden
  • Feed der Einträge
  • Kommentare-Feed
  • WordPress.org

Footer

Rechtliches

  • Datenschutz
  • Impressum

Kategorien

  • Allgemein
  • Amazon Alexa
  • KNX
  • Leserprojekte
  • Neuigkeiten
  • openHAB
  • Regeln
  • Selbst gebaut
  • Smarte Beleuchtung
  • Tools
  • Facebook
  • RSS
  • Twitter

Blogstatistik

  • 324.522 Besuche
Blogverzeichnis - Bloggerei.de
Blogverzeichnis

Copyright © 2021 · Made with love by Interwebs UG · Anmelden