Im ersten Teil dieser Serie haben Sie einen PC oder einen Raspberry Pi mit openHAB installiert. Als Basis dafür wurde openHABian ausgewählt, da die Installation auf Debian-basierten Linux Betriebssystemen recht einfach ist und die spätere Nutzung Raspberry Pi OS ähnelt. Die Installation dauert nicht lange, aber die Add-ons, die in openHAB eigentlich Bindings genannt werden, haben Sie vielleicht schon installiert. Im heutigen Teil soll ein MQTT-Broker auf dem System nachinstalliert und die entsprechenden Devices eingerichtet werden. Die Hardware soll dann zur Aufzeichnung von Umweltdaten genutzt werden. Die Kommunikation wird passwortgeschützt sein, damit die Daten nicht jeder einsehen oder überschreiben kann. Damit die Daten einem Raum zugewiesen werden können, wird ein Beispielhaus als Modell dienen.

Benötigte Hard- und Software

Für diesen Teil braucht es eine fertige Installation von openHAB. Für die Hardware, Umweltdaten durch BME280s, wird die Hardware aus Tabelle 1 benötigt. Generell sollte ihre Hardware über Zugriff auf ihr Netzwerk verfügen.

Pos	Anzahl	Bauteil	Link
1	1	D1 Mini	https://www.az-delivery.de
2	1	GY-BME280 Barometrischer Sensor	https://www.az-delivery.de

Tabelle 1: Benötigte Hardware für diesen Blogteil

Die Installation eines MQTT-Brokers

Für unser Vorhaben, die oben genannte Hardware zur Aufzeichnung von Umweltdaten zu verwenden, braucht es eine Kommunikationsschnittstelle zwischen openHAB und den Devices. Universal, gerade mit Blick auf spätere Erweiterungen, ist MQTT hier meine erste Wahl. Eine Übersicht über MQTT habe ich in einem früheren Blogbeitrag gegeben, dies kann hier nachgelesen werden. Den mosquitto-Broker werden wir nun auf dem Raspberry Pi nachinstallieren.

Sollten Sie, so wie ich, auf den Raspberry Pi via SSH zugreifen, dann benötigen Sie die folgenden Default-Logindaten:

• Benutzer: openhabian
• Password: openhabian

Alle Default-Zugänge finden Sie auf der openHAB-Seite im Bereich Passwords, siehe Abbildung 1.

Abbildung 1: Die Default-Logindaten aller Dienste

Als Nächstes installieren Sie den mosquitto-Broker mit dem Kommando aus Code 1.

sudo apt install mosquitto

Je nach Internetleitung dauert die Installation einen kurzen Moment, mittels Code 2 kann der Status erfragt werden.

sudo service mosquitto status

Im Idealfall sollte im Bereich Active der Status active (running) stehen, siehe Abbildung 2.

Abbildung 2: Status vom MQTT-Broker, hier active

Ist dies der Fall, dann ist der Broker aufgesetzt und kann so von jedem Client genutzt werden. Das birgt aber das Risiko, dass jeder mit einem Zugang zum Netzwerk und einem MQTT-Client die Daten lesen und auch verändern kann. Gerade im Bereich der Hausautomation kann das unangenehme Folgen haben, weswegen der Zugang mittels Passwort beschränkt werden sollte!

Bevor also MQTT genutzt wird, wird dieser noch etwas in der Konfiguration angepasst. Geben Sie dazu im Terminal den Befehl aus Code 3 ein.

sudo nano /etc/mosquitto/mosquitto.conf

Code 3: Befehl um die Konfiguration von MQTT zu ändern

Anschließend erweitern oder verändern Sie folgende Einträge:

per_listener_settings true
allow_anonymous false
password_file /etc/mosquitto/passwords

Danach sollte die MQTT-Konfiguration wie folgt aussehen, siehe Abbildung 3.

Abbildung 3: Erweiterung der Konfiguration zur MQTT-Absicherung

Bevor nun der Dienst neu gestartet werden kann, muss noch die Passwortdatei generiert werden! Versuchen Sie vorher den Dienst neu zu starten, wird ein Fehler auftreten und der Dienst startet nicht. Daher legen wir nun initial die Datei an, wobei wir auch gleich einen User mit eintragen, siehe Code 4.

sudo mosquitto_passwd -c /etc/mosquitto/passwords User

Tauschen Sie bei dem Kommando den User gegen einen von Ihnen gewählten Namen aus und betätigen Sie Enter. Direkt im Anschluss werden Sie nach einem Passwort gefragt und müssen dieses bestätigen, siehe Abbildung 4.

Abbildung 4: Passwortdatei mit neuem User anlegen

An der Stelle ist es wichtig, dass Sie sich das Passwort entweder merken, oder eine Passwortdatenbank verwenden. Die vergebenen Passwörter können, nicht ohne etwas Know-how, ausgelesen werden, da die Logins verschlüsselt sind!

 

Speichern Sie die Änderung ab und starten Sie den Dienst einmal komplett neu, siehe Code 5.

sudo service mosquitto stop
sudo service mosquitto reload
sudo service mosquitto start

Code 5: mosquitto stoppen und mit neuer Konfiguration wieder starten

Damit Sie weitere User hinzufügen können, weil z.B. Devices unterschiedliche User und Passwörter bekommen sollen, nutzen Sie den Befehl aus Code 6.

sudo mosquitto_passwd -b /etc/mosquitto/passwords USER PASSWORT

Code 6: Weitere MQTT-Einwahldaten hinzufügen

Wichtig hierbei ist, den User und das Passwort zu tauschen, damit Sie ihren Wünschen entsprechen.

Damit ist der MQTT-Broker eingerichtet und er kann nun für openHAB verwendet werden.

Unser Beispielhaus in openHAB erstellen

Jetzt kommt es in diesem Beitrag zum etwas praktischen Teil in openHAB. In diesem Beispiel soll ein kleines Beispielhaus erstellt werden, das wie folgt aussieht:

• Erdgeschoss
  • Küche
  • Wohnzimmer
  • Esszimmer
  • Gäste WC
  • Hauswirtschaftsraum
• Obergeschoss
  • Badezimmer
  • Waschraum
  • 2 Schlafzimmer
• Garten
  • Gartenhütte
  • Terrasse

Öffnen Sie nun die Seite von openHAB und geben Sie, falls gefordert, das vorher vergebene Adminkonto samt Passwort an. Danach wechseln Sie auf der linken Seite zu Einstellungen und Model, siehe Abbildung 5.

Abbildung 5: Seite Modell aufrufen

Diese Seite ist, wie auch in meinem Screenshot, noch leer und die benötigte Hierarchie muss nun erstellt werden. openHAB bietet ihnen dafür folgende Möglichkeiten:

• Einfügen eines Standortes: Hierbei sind Umgebungen, Stockwerke und Zimmer gemeint
• Einbinden von Ausrüstung von einem Gegenstand: Damit wird ein spezifisches Objekt erstellt,B. ein Aquarium. Es erstellt auch gleichzeitig einen sogenannten Punkt, bei denen es sich um Objekte handelt, um z.B. Messwerte anzuzeigen, oder Schalter einzubinden. Dies wird gleichzeitig mit einem verbundenen Binding verknüpft.
• Einen Punkt einem Gegenstand hinzufügen: Dabei ist, wie oben erwähnt, ein Objekt gemeint, um Messwerte, oder z.B. einen Schalter anzuzeigen. Dies wird gleichzeitig mit einem verbundenen Binding verknüpft.
• Ausrüstung hinzufügen: Ein Objekt zu einem Standort hinzufügen, der keinerlei Datenpunkte enthält
• Punkt hinzufügen: Fügt einen (Daten-)Punkt einem Standort oder einer Ausrüstung hinzu

Fangen wir also zunächst einmal an, das Beispielhaus aufzubauen, damit wir später unsere Umweltdaten hinzufügen können.

Wählen Sie auf der rechten Seite „Add location“ aus und geben die Vorgaben wie in Abbildung 6 gezeigt an.

Abbildung 6: Standort hinzufügen

An dieser Stelle sollte ich erwähnen, dass das Haus und der Garten in der späteren Hierarchie auf der selben Ebene sein werden. Leider ist gerade bei dieser Konfiguration vieles auf Englisch. Mit „Create“ wird dann der neue Standort hinzugefügt.

Nun klicken Sie auf die freie Fläche unter Haus und wählen erneut „Add location“, wichtig an der Stelle ist, dass vorher eine freie Fläche unter Haus angeklickt wurde, da sonst der neue Standort als Unterpunkt vom Haus angelegt wird. Für den Garten nutzten Sie die Vorgaben aus Abbildung 7.

Abbildung 7: Standort Garten anlegen

Danach sollten Sie zwei untereinanderstehende Standorte für unser Modellhaus haben, siehe Abbildung 8.

Abbildung 8: Anfang der Hierarchie

Im Garten, so habe ich es am Anfang festgelegt, wird es eine Terrasse und eine Gartenhütte geben. Beides gehört zum Garten, weswegen nun der „Garden“ in der Hierarchie ausgewählt und wieder ein neues Element für die Terrasse angelegt wird, siehe Abbildung 9.

Abbildung 9: Terrasse hinzufügen

Als Nächstes erfolgt die Gartenhütte, weswegen Sie zunächst wieder den „Garden“ auswählen und dann einen neuen Standort hinzufügen, siehe Abbildung 10.

Abbildung 10: Gartenhütte hinzufügen

Damit sind alle Beziehungen erst einmal gesetzt und der Außenbereich ist erstellt. Wichtig für später ist: einfaches verschieben der Standorte geht nicht. Daher müssen Sie sich im Vorfeld Gedanken über die Anordnung machen. Die Labels, die Kategorie und die semantische Klasse lassen sich später noch editieren.

Erweitern Sie nun, wie eben schon beschrieben, das Modell um die Bereiche des Hauses. Prüfen Sie selbstständig, welche Kategorien es für die einzelnen Räume gibt. Ihre Auswahl können Sie ja später noch ändern. Sind Sie mit dem Anlegen der Räume fertig, sollte das Model in etwa Abbildung 11 entsprechen.

Abbildung 11: Model mit allen Räumen

Das Binding für MQTT erstellen

Damit später auch Daten an openHAB genutzt werden können, nutzt diese Blogserie MQTT als primäre Schnittstelle. Zum Anfang wurde ein MQTT-Broker eingerichtet, aber bisher hat openHAB keinerlei Verbindung zum Broker. Im Menüband wechseln Sie nun zu Einstellungen -> Things und wählen dort das „+“ in der rechten unteren Ecke, siehe Abbildung 12.

Abbildung 12: Things-Menü öffnen

Im nächsten Menü müssen Sie nun, da im letzten Teil das MQTT Binding bei der Installation hinzugefügt wurde, das MQTT Binding auswählen, siehe Abbildung 13.

Abbildung 13: MQTT Bindung auswählen

Jetzt wählen Sie im nächsten Bereich direkt MQTT Broker aus, da erst die Verbindung zum Broker hergestellt werden muss, bevor wir auf Daten zugreifen können. Im folgenden Menü kommt es nun darauf an, ob Sie Ihren MQTT-Broker abgesichert haben, oder nicht. Ist es nur gestattet Daten mittels User und Passwort zu schreiben und lesen, so müssen Sie Show advanced auswählen, siehe Abbildung 14.

Abbildung 14: Erweiterte Einstellungen anzeigen lassen

Egal, ob Sie nun etwas besser abgesichert sind oder nicht, müssen Sie als nächstes die IP-Adresse des Brokers eintragen. Haben Sie, so wie ich in diesem Blogbeitrag bisher gezeigt, den MQTT-Broker auf dem gleichen System laufen, so können Sie als Broker Hostname/IP einfach localhost oder 127.0.0.1 eintragen.

Werden noch User und Passwort benötigt, so müssen Sie ein bisschen weiter nach unten scrollen, um dort unter Benutzername und Passwort die korrekten Daten einzutragen, siehe Abbildung 15.

Abbildung 15: User und Passwort für MQTT eintragen

Ist das erledigt, scrollen Sie noch weiter nach unten und drücken den Button Create Thing. Die Verbindung kann einen kurzen Moment dauern. Sie sollten aber schnell sehen, dass openHAB eine Verbindung zum MQTT-Broker herstellen konnte, was durch den grünen Button online ersichtlich wird, siehe Abbildung 16

Abbildung 16: Verbindung zum MQTT-Broker hergestellt

Umweltüberwachung mit dem D1 Mini und BME280

Um nun die Umweltdaten für einen Raum zu erfassen, die später dann auch in openHAB zu sehen sein sollen, braucht es für unseren Beitrag einen D1 Mini mit BME280. Da es sich hierbei in meiner Bastelkiste um Standardbauteile handelt, ist der Zusammenbau schnell getan, siehe Abbildung 17.

Abbildung 17: D1 Mini mit angeschlossenem BME280

Auch der Code dazu ist recht schnell geschrieben und liest die Umweltdaten alle 2 Sekunden vom BME280 aus. Damit nicht immer der neuste an den Broker geschrieben wird, gelten folgende Bedingungen zum Senden:

• Die Temperaturdifferenz zum neuen Wert beträgt 0,1 °C
• Die Druckdifferenz zum neuen Wert beträgt 0,5 bar
• Die Luftfeuchtigkeitsdifferenz zum neuen Wert beträgt 0,5 %

vom vorherigen Wert.

Sketch Download

//-----------------------------------------------------
// D1 Mini with BME280 to monitor temp, humi and press
// via MQTT for openHAB
// Autor:   Joern Weise
// License: GNU GPl 3.0
// Created: 02. Feb 2023
// Update:  03. Feb 2023
//-----------------------------------------------------
#include <Adafruit_BME280.h>
#include <Wire.h>
#include <PubSubClient.h> //Lib for MQTT Pub and Sub
#include <ESP8266WiFi.h>

//Define WiFi-Settings
#ifndef STASSID
#define STASSID "YOUR-SSID"       //Enter Wfi-Name
#define STAPSK "YOUR-WIFI-PASS"  //Enter Passkey
#endif

#ifndef MQTTUSER
#define MQTTUSER "YOUR-MQTT-USER" //Enter Wfi-Name
#define MQTTPASS "YOUR-MQTT-PASS"  //Enter Passkey
#endif


#define ADVANCEDIAG 0

#define I2C_SDA D2
#define I2C_SCL D1
#define NEXTUPDATE 2000
#define TEMPLIMIT 85.00

//Objects for I2C and BME
Adafruit_BME280 bmeOne;
unsigned long lastTime = 0;

const char* MQTT_BROKER = "IP-FROM-BROKER";  //Name of the mqtt broker
const char* PubTopicTempOne = "sensors/out/D1_Mini_Office/TempOne";        //Topic first temp
const char* PubTopicPresOne = "sensors/out/D1_Mini_Office/PressOne";       //Topic first pressure
const char* PubTopicHumOne =  "sensors/out/D1_Mini_Office/HumOne";         //Topic first humidity
String clientID = "D1_Mini_Office";  //Clientname for MQTT-Broker

float fLastTempOne,fLastPressOne,fLastHumOne;

//Create objects for mqtt
WiFiClient espClient;
PubSubClient mqttClient(espClient);

#define MSG_BUFFER_SIZE  (50)
char msg[MSG_BUFFER_SIZE];

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  Serial.println("BME280 test");
  Serial.println("Init both I2C-Connections");
  Wire.begin(I2C_SDA, I2C_SCL);
  Serial.println("Make first BME talking to us");
  bool bStatus;
  //Init first sensor
  bStatus = bmeOne.begin(0x76);
  if (!bStatus)
  {
    Serial.println("Could not find a valid BME280 - 1 sensor, check wiring!");
    while (1);
  }
  else
    Serial.println("Valid BME280 - 1 sensor!");
  

  writeAdvanceDiag("Init Wifi", true);
  setupWifi();
  writeAdvanceDiag("Init Wifi - DONE", true);
  writeAdvanceDiag("Set MQTT-Server", true);
  mqttClient.setServer(MQTT_BROKER,1883);
  writeAdvanceDiag("Set Callback-function", true);
  //mqttClient.setCallback(callback);
  writeAdvanceDiag("Finish setup()-Function", true);
}

void loop() {
  // put your main code here, to run repeatedly:
  float fTempOne,fPressOne,fHumOne;
  if(!mqttClient.connected())
    reconnectMQTT();
  
  mqttClient.loop();
  //Check after "NEXTUPDATE" if values has changed
  if(millis() - lastTime > NEXTUPDATE)
  {
    fTempOne = bmeOne.readTemperature(); //Get temp one
    if(fTempOne > float(TEMPLIMIT))
    {
      return;
    }
    fPressOne = bmeOne.readPressure() / 100.0F;  //Get press one
    fHumOne = bmeOne.readHumidity();
    if(fTempOne != fLastTempOne && abs(fLastTempOne - fTempOne) > 0.1)  //Check temp one changed and send
    {
      snprintf(msg,MSG_BUFFER_SIZE, String(fTempOne,1).c_str());  //Convert message to char
      mqttClient.publish(PubTopicTempOne,msg,true);  //Send to broker
      writeAdvanceDiag("Send Temp one: " + String(fTempOne,1), true);
      fLastTempOne = fTempOne;
    }
    if(fPressOne != fLastPressOne && abs(fLastPressOne - fPressOne) > 0.5)  //Check pressure one changed and send
    {
      snprintf(msg,MSG_BUFFER_SIZE, String(fPressOne,2).c_str());  //Convert message to char
      mqttClient.publish(PubTopicPresOne,msg,true);  //Send to broker
      writeAdvanceDiag("Send Press one: " + String(fPressOne,2), true);
      fLastPressOne = fPressOne;
    }
    if(fHumOne != fLastHumOne && abs(fLastHumOne - fHumOne) > 0.5)  //Check pressure one changed and send
    {
      snprintf(msg,MSG_BUFFER_SIZE, String(fHumOne,2).c_str());  //Convert message to char
      mqttClient.publish(PubTopicHumOne,msg,true);  //Send to broker
      writeAdvanceDiag("Send Hum one: " + String(fHumOne,2), true);
      fLastHumOne = fHumOne;
    }
    lastTime = millis();
  }

}

/*
* =================================================================
* Function:     callback   
* Returns:      void
* Description:  Will automatical called, if a subscribed topic
*               has a new message
* topic:        Returns the topic, from where a new msg comes from
* payload:      The message from the topic
* length:       Length of the msg, important to get conntent
* =================================================================
*/
/*
void callback(char* topic, byte* payload, unsigned int length)
{
  String stMessage = "";
  writeAdvanceDiag("Message arrived from topic: " + String(topic), true);
  writeAdvanceDiag("Message length: " + String(length), true);
  for (int i = 0; i < length; i++)
    stMessage += String((char)payload[i]);
  writeAdvanceDiag("Message is: " + stMessage, true);
  //Map value and send the mapped value to mqtt broker
  int iValue,iMapValue;
  iValue = stMessage.toInt();
  iMapValue = map(iValue,0,1024,0,255);
  snprintf(msg,MSG_BUFFER_SIZE, "%1d",iMapValue);  //Convert message to char
  writeAdvanceDiag("Send mapped PotiValue: " + String(iMapValue), true);
  mqttClient.publish(PubTopicPotiMap,msg,true);  //Send to broker
}
*/
/*
* =================================================================
* Function:     setupWifi   
* Returns:      void
* Description:  Setup wifi to connect to network
* =================================================================
*/
void setupWifi()
{
  Serial.println("Connection to: " + String(STASSID));
  WiFi.mode(WIFI_STA);
  WiFi.begin(STASSID, STAPSK);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

/*
* =================================================================
* Function:     writeAdvanceDiag   
* Returns:      void
* Description:  Writes advance msg to serial monitor, if
*               ADVANCEDIAG >= 1
* msg:          Message for the serial monitor
* newLine:      Message with linebreak (true)      
* =================================================================
*/
void writeAdvanceDiag(String msg, bool newLine)
{
  if(bool(ADVANCEDIAG)) //Check if advance diag is enabled
  {
    if(newLine)
      Serial.println(msg);
    else
      Serial.print(msg);
  }
}

/*
* =================================================================
* Function:     reconnectMQTT   
* Returns:      void
* Description:  If there is no connection to MQTT, this function is
*               called. In addition, the desired topic is registered.
* =================================================================
*/
void reconnectMQTT()
{
  while(!mqttClient.connected())
  {
    writeAdvanceDiag("Login to MQTT-Broker", true);
    if(mqttClient.connect(clientID.c_str(), MQTTUSER, MQTTPASS))
    {
      Serial.println("Connected to MQTT-Broker " +String(MQTT_BROKER));
      //writeAdvanceDiag("Subscribe topic '" + String(SUBTOPIC)+ "'", true);
      //mqttClient.subscribe(SUBTOPIC,1); //Subscibe topic "SUBTOPIC"
    }
    else
    {
      writeAdvanceDiag("Failed with rc=" +String(mqttClient.state()), true);
      Serial.println("Next MQTT-Connect in 3 sec");
      delay(3000);
    }
  }
}

Damit der Programmcode bei Ihnen funktioniert, muss er Ihrerseits noch angepasst werden. Zunächst müssen Sie das WLAN korrekt einstellen, was über die Defines STASSID und STAPSK durchgeführt wird.

Danach muss der User und das Passwort für MQTT über die Defines MQTTUSER und MQTTPASS definiert werden. Zuletzt können Sie noch die Pfade für MQTT und die eindeutige ClientID unterhalb von Definitions to publish values to broker and clientID verändern.

Sollte es Probleme geben, habe ich im Code noch eine Art Debug-Modus eingebaut, der an wichtigen Stellen Informationen auf dem seriellen Monitor ausgeben kann. Setzen Sie dazu ADVANCEDIAG von 0 auf 1 und die erweiterte Ausgabe wird angezeigt.

Um die Daten einzusehen, habe ich früher gerne MQTT.fx verwendet, doch leider ist dieses Tool mittlerweile nicht mehr kostenfrei, weswegen ich zu MQTT Explorer umgestiegen bin. Mit der aktuellen 0.4.0-beta habe ich deutlich mehr Funktionen, als zuvor MQTT.fx.

Die Umweltdaten einem Raum zuordnen

Aktuell haben wir in diesem Blogbeitrag das Model eines Hauses mit diversen Räumen kreiert und einen MQTT-Broker integriert, der uns Umweltdaten von einem D1 Mini mit BME280 liefert. Die Daten müssen nun in openHAB mit einem Raum verknüpft werden. Aktuell hat openHAB nur eine Verbindung zu dem MQTT-Broker, aber keinerlei Kenntnis über die verschiedenen Datenknoten.

Öffnen Sie, wie schon beim Hinzufügen des MQTT-Brokers, die Einstellungen und dort Things. Dort wählen Sie das blaue Plus am unteren rechten Rand aus und im Anschluss MQTT Binding, siehe Abbildung 18.

Abbildung 18: Neues MQTT Binding hinzufügen

Als Nächstes wählen Sie Generic MQTT Thing aus, siehe Abbildung 19. Diesen Punkt können Sie nur auswählen, wenn vorher ein Broker eingerichtet wurde, siehe dazu den Text von Generic MQTT Thing.

Abbildung 19: Ein generisches MQTT Thing hinzufügen

Im nächsten Dialog muss dem Thing zunächst ein eindeutiger Name zugewiesen werden, optional ein Label und für welchen Standort dieser gedacht ist, siehe Abbildung 20.

Abbildung 20: Generic MQTT Thing konfigurieren

Wichtig ist, dass Sie die Parent Bridge auf den zuvor eingerichteten MQTT Broker einstellen. Andernfalls können die Topics nicht ausgelesen werden. Drücken Sie danach auf Create Thing und in der neu geladenen Übersicht wählen Sie direkt das neu angelegt Element aus, siehe Abbildung 21.

Abbildung 21: Das neu angelegte Thing in der Übersicht auswählen

Ist das Thing geöffnet, wählen Sie den Tag Channels aus und dort den Menüpunkt Add Channel, siehe Abbildung 22.

Abbildung 22: Channel dem Thing hinzufügen

Nun müssen zunächst ein Channel-Name und ein Label vergeben werden. Es soll die Temperatur hinzugefügt werden, weswegen der Channel Identifier Temperature lauten soll. Als Label nehme ich den Standort Livingroom. Der Typ ist in diesem Fall ein Number Value, der zuvor ausgewählt werden muss, damit die weitere Konfiguration angezeigt wird. Hier tragen Sie dann den MQTT State Topic ein, siehe Abbildung 23.

Abbildung 23: Channeldaten hinzufügen

Nach dem gleichen Prinzip legen Sie für den Druck und die Luftfeuchtigkeit die Channels an. Achten Sie darauf, dass Sie den korrekt verwendeten Topic aus dem Arduinocode übernehmen, oder sich den Topic via MQTT Explorer, oder MQTT.fx noch einmal holen. Letztlich sollte die Channel-Übersicht wie Abbildung 24 aussehen.

Abbildung 24: Channels des D1 Mini

Jetzt erhält openHAB bei einer Änderung des Topics direkt eine Benachrichtigung und der Channel wird upgedatet. Final wird das Thing nun mit dem Model verknüpft. Wechseln Sie dazu ins Model und wählen dort in der Liste das Wohnzimmer aus, siehe Abbildung 25.

Abbildung 25: Dem Model Werte übergeben

Drücken Sie auf Create Points from thing und wählen Sie anschließend das Thing aus. Hier wird ein DropDown-Menü erscheinen, wo Sie eine Auswahl aller Things bekommen. Nun sehen sie, siehe Abbildung 26, alle verfügbaren Daten.

Abbildung 26: Datenpunkte des Thing

Wählen Sie alle aus und vergeben Sie die entsprechende Kategorie temperature, pressur und humidity für die einzelnen Datenpunkte. Auch das Label sollten Sie entsprechend anpassen, damit Sie nachher wissen, welcher Datenpunkt welchen Wert wiedergibt, siehe Abbildung 27.

Abbildung 27: Datenpunkte dem Wohnzimmer zugeordnet

Wollen Sie nun die Werte noch mit der Einheit erhalten, dann können Sie unter Add Metadata noch eine State Description hinzufügen.

Ich empfehle dafür:

• Pattern für Temperatur: %.1f °C
• Pattern für Druck: %.2f hPa
• Pattern für Feuchtigkeit: %.2f %%

Sie können sogar für alle drei Datenpunkte beim Anlegen der Pattern oben rechts angeben, dass die Werte nur Read only sind.

Danach sollten die Werte wie in Abbildung 28 aussehen.

Abbildung 28: Datenpunkt mit Einheit

Zusammenfassung

In diesem Beitrag haben Sie einen MQTT-Broker auf dem Raspberry Pi eingerichtet, ein Modell von einem Beispielhaus oder ihrer Wohnung erstellt und die Umweltdaten, die ein D1 Mini mit BME280 erfasst, einem Raum zugeordnet. Gerade das Hinzufügen des MQTT-Bindings ist etwas kniffelig, aber mit etwas Übung versteht man das Prinzip recht schnell. Wie schon im ersten Beitrag zu dieser Serie erwähnt, muss in openHAB jeder einzelne Schritt konfiguriert werden, was am Anfang viele Benutzer abschreckt. Ich denke in diesem Beitrag haben Sie gemerkt, was damit gemeint ist. Die Lernkurve ist steil, aber hat man den Einstieg gemeistert, so ist der weitere Weg recht einfach.

Im nächsten Beitrag werden wir uns tiefer mit den Bindings beschäftigen. Ich zeige, wie Sie ein Shelly in ihr System einbinden und eine Programmierung mit blockly erstellen. Im dann folgenden vierten und damit abschließenden Teil, wird der AZ TouchMod als Steuereinheit eingesetzt.

Da ich mittlerweile eine kleine CNC-Fräse mein Eigen nenne, finden Sie in meinem Git-Repository eine Platine für den D1 Mini mit BME280, siehe Abbildung 18.

Abbildung 29: Platine für D1 Mini mit BME280

Diese ist in TARGET 3001! erstellt worden und bekommt demnächst noch ein 3D-Druckgehäuse verpasst. Damit ist der D1 gut geschützt und es sieht nicht nach Prototyping aus.