In diesem Tutorial lernst du, wie du eine Authentifizierung integrierst, sodass deine ESP8266 einen Benutzernamen und ein Passwort benötigen, um mit dem MQTT-Broker kommunizieren zu können. Das bietet zwar immer noch keine 100% Sicherheit (falls es diese überhaupt gibt), aber wenn wir davon ausgehen, dass du keine kritischen Anwendungen mit MQTT aufbaust, sollte diese Authentifizierung schon ein großer Schritt in die richtige Richtung sein.

Konfiguration des MQTT-Brokers

Zunächst müssen wir den Mosquitto-Broker auf dem Raspberry Pi konfigurieren, um die Authentifizierung zu aktivieren.

Schritt 1: Erstellen der Passwortdatei

Hierfür verwendest du den Befehl mosquitto_passwd, um eine Passwortdatei zu erstellen und Benutzer hinzuzufügen. Gib im Terminal den folgenden Befehl ein – ersetze hierbei <username> mit einem Benutzernamen deiner Wahl:

sudo mosquitto_passwd -c /etc/mosquitto/passwd <username>

___STEADY_PAYWALL___

Anschließend wirst du aufgefordert, ein Passwort einzugeben. Dieses sollte natürlich möglichst sicher sein – Tipps für sichere Passwörter findest du z.B. auf der Webseite des BSI. Dieses Passwort wirst du später noch in den Sketches der ESP8266 benötigen.

Falls du noch einen weiteren Benutzer anlegen möchtest, ohne die Passwortdatei erneut zu erstellen, verwenden den folgenden Befehl, in dem du <username> und <password> entsprechend ersetzt:

sudo mosquitto_passwd -b /etc/mosquitto/passwd <username> <password>

Schritt 2: Konfiguration von Mosquitto

Nun widmest du dich der Konfigurationsdatei von Mosquitto, die du mit dem folgenden Befehl öffnest:

sudo nano /etc/mosquitto/mosquitto.conf

Füge am Ende der Datei die folgenden Zeilen hinzu:

allow_anonymous false
password_file /etc/mosquitto/passwd

Mit diesen beiden Zeilen deaktivierst du den anonymen Zugriff und gibst den Pfad zur Passwortdatei an.

Schritt 3: Neustart des Mosquitto-Dienstes

Sollte dein MQTT-Broker noch laufen, starte ihn mit dem folgenden Befehl neu, um deine Änderungen zu übernehmen:

sudo systemctl restart mosquitto

Konfiguration der ESP8266-Clients

Nun kommen die beiden ESP8266 dran. Hier änderst du deine Sketches, sodass sie sich mit Benutzernamen und Passwort beim Broker authentifizieren. Entscheiden sind die folgenden Änderungen. Zunächst die Integration des Benutzernamen und zugehörigen Passworts, dass du anfangs erstellt hast – hinterlege diese Informationen am Anfang des Sketchs (hinter den Infos zu WLAN und IP-Adresse des Raspberry Pis):

const char* mqtt_user = "Dein_MQTT_Benutzername";
const char* mqtt_password = "Dein_MQTT_Passwort";

Diese beiden Konstanten verwendest du anschließend, wenn der ESP8266 sich mit dem Broker verbinden möchte. Die Funktion reconnect() aus den vorherigen Teilen sieht dann folgendermaßen aus:

void reconnect() {
  while (!client.connected()) {
    Serial.print("Verbinde mit MQTT...");
    if (client.connect("ESP8266Client", mqtt_user, mqtt_password)) {
      Serial.println("verbunden");
      client.subscribe("esp8266/light");
    } else {
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" Nächster Versuch in 5 Sekunden");
      delay(5000);
    }
  }
}

Passe deine Sketches für die ESP8266 nun an und teste die Verbindung. Funktioniert alles wie vorher? Dann hast du ein MQTT-System jetzt erfolgreich abgesichert!

Für diese Lektion brauchst du folgende Teile:

• 2x ESP8266-Modul
• 1x Lichtsensor plus 10kΩ Widerstand
• 1x LED plus passendem Vorwiderstand
• Breadboards und Kabel

MQTT-Bibliotheken für Arduino

Um MQTT mit dem ESP8266 zu nutzen, verwendest du die Bibliothek PubSubClient von Nick O’Leary. Sie ist speziell für die Verwendung mit der Arduino-IDE und ESP8266 optimiert.

Installation der PubSubClient-Bibliothek:

1. Öffne die Arduino-IDE.
2. Gehe zu Sketch > Bibliothek einbinden > Bibliotheken verwalten (oder klicke auf den entsprechenden Button im Menü links)
3. Suche nach “PubSubClient” und installiere die neueste Version.

___STEADY_PAYWALL___

Daten an den MQTT-Broker senden

Lass uns einen ersten Sketch erstellen, der eine Verbindung zum MQTT-Broker herstellt und eine Nachricht published.

//Nachrichten an den MQTT-Broker senden

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const char* ssid = "DEIN_WLAN_SSID";
const char* password = "DEIN_WLAN_PASSWORT";
const char* mqtt_server = "IP_ADRESSE_DES_BROKERS";

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
}

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Verbinde mit ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi verbunden");
  Serial.println("IP-Adresse: ");
  Serial.println(WiFi.localIP());
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Verbinde mit MQTT...");
    if (client.connect("ESP8266Client")) {
      Serial.println("verbunden");
    } else {
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" Nächster Versuch in 5 Sekunden");
      delay(5000);
    }
  }
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  client.publish("esp8266/test", "Hallo vom ESP8266!");
  delay(5000);
}

Ersetze DEIN_WLAN_SSID, DEIN_WLAN_PASSWORT und IP_ADRESSE_DES_BROKERS durch deine eigenen Werte. Falls du die IP deines Raspberry Pis (also des laufenden Brokers) nicht kennst, gib im Terminal Folgendes ein:

hostname -I

Im Terminal siehst du dann die IP-Adresse, zum Beispiel 192.168.0.143

Das Sketch stellt eine Verbindung zum WLAN und dem MQTT-Broker her. In der loop()-Funktion wird alle 5 Sekunden eine Nachricht an das Topic esp8266/test gesendet.

Lade das Sketch auf deinen ESP8266 hoch und öffne den Seriellen Monitor. Du solltest sehen, wie der ESP8266 eine Verbindung herstellt und Nachrichten sendet.

Auf dem Raspberry Pi kannst du die Nachrichten mit mosquitto_sub empfangen. Gibt hierfür den folgenden Befehl in einem neuen Terminal-Fenster (während Mosquitto aktiv ist) ein:

mosquitto_sub -t esp8266/test

So weit, so gut. Als Nächstes testest du die andere Richtung und sendest du Nachrichten vom MQTT-Broker zum ESP8266

Daten vom MQTT-Broker empfangen

In diesem Test installierst du an deinem ESP8266 eine LED, die du vom Terminal (also vom Broker) aus an- und ausschaltest. Verbinde die LED wie folgt:

Nun lade den folgenden Sketch auf deinen ESP8266 – hinterlege jedoch zunächst wieder dein Netzwerk, Passwort und die IP-Adresse des Brokers:

//Nachrichten vom MQTT-Broker empfangen

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const char* ssid = "DEIN_WLAN_SSID";
const char* password = "DEIN_WLAN_PASSWORT";
const char* mqtt_server = "IP_ADRESSE_DES_BROKERS";

WiFiClient espClient;
PubSubClient client(espClient);

const int ledPin = D5;

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Verbinde mit ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi verbunden");
  Serial.println("IP-Adresse: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Nachricht empfangen [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();

  if ((char)payload[0] == '1') {
    digitalWrite(ledPin, HIGH);  // LED einschalten
  } else {
    digitalWrite(ledPin, LOW);  // LED ausschalten
  }
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Verbinde mit MQTT...");
    if (client.connect("ESP8266Client")) {
      Serial.println("verbunden");
      client.subscribe("esp8266/led");
    } else {
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" Nächster Versuch in 5 Sekunden");
      delay(5000);
    }
  }
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}

So funktioniert der Sketch

Interessant in diesem Sketch sind die folgenden zwei Funktionen:

• Die callback()-Funktion wird aufgerufen, wenn eine Nachricht auf einem abonnierten Topic eintrifft. Wir überprüfen den Inhalt der Nachricht und schalten die LED entsprechend ein oder aus.
• In der reconnect()-Funktion abonnieren wir das Topic “esp8266/led”, um Steuerbefehle für die LED zu empfangen.

Nachdem du den Sketch auf den ESP8266 geladen hast, kannst du die Funktion wieder im Terminal testen. Steuere dort die LED mit einem der folgenden Befehle. Ersetze IP_ADRESSE_DES_BROKERS hierbei mit der tatsächlichen IP-Adresse deines Raspberry Pi:

mosquitto_pub -h IP_ADRESSE_DES_BROKERS -t "esp8266/led" -m "1"  # LED einschalten
mosquitto_pub -h IP_ADRESSE_DES_BROKERS -t "esp8266/led" -m "0"  # LED ausschalten

Funktioniert? Dann wird es Zeit für den letzten Teil: Hier lässt du zwei ESP8266 miteinander sprechen.

Kommunikation zwischen zwei ESP8266

Bisher hast du das Terminal verwendet, um den MQTT-Broker zu bedienen, also Nachrichten an einen ESP8266 zu senden oder von dort zu empfangen. Aber eigentlich sollte der Broker seine Arbeit im Hintergrund erledigen und nur ein Postbote sein, von dem du nicht viel mitbekommst. Nun sollen also zwei ESP8266 miteinander kommunizieren: Am ersten ist ein Lichtsensor installiert, der die Lichtstärke misst. Fällt diese unter einen bestimmten Wert, sendet er eine entsprechende Nachricht an den Broker. Ein zweiter ESP8266 hat diese Nachrichten abonniert und schaltet bei Bedarf eine LED ein.

Die LED hast du ja bereits installiert. Am anderen ESP8266 verbindest du den Lichtsensor wie folgt:

Der Sketch für den Sender

Für den Sender der Nachrichten, also den ESP8266 mit dem angeschlossenen Lichtsensor benötigst du folgenden Sketch:

//Lichtstärke senden

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const char* ssid = "DEIN_WLAN_SSID";
const char* password = "DEIN_WLAN_PASSWORT";
const char* mqtt_server = "IP_ADRESSE_DES_BROKERS";

WiFiClient espClient;
PubSubClient client(espClient);

const int lightSensorPin = A0;
const int lightThreshold = 500;

void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
}

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Verbinde mit ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi verbunden");
  Serial.println("IP-Adresse: ");
  Serial.println(WiFi.localIP());
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Verbinde mit MQTT...");
    if (client.connect("ESP8266Client_Publisher")) {
      Serial.println("verbunden");
    } else {
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" Nächster Versuch in 5 Sekunden");
      delay(5000);
    }
  }
}

void loop() {
  if (client.connected()) {
    client.loop();

    int lightValue = analogRead(lightSensorPin);
    Serial.print("Lichtwert: ");
    Serial.println(lightValue);

    if (lightValue < lightThreshold) {
      client.publish("esp8266/light", "1");  // LED einschalten
      Serial.println("MQTT Message Sent: 1");
    } else {
      client.publish("esp8266/light", "0");  // LED ausschalten
      Serial.println("MQTT Message Sent: 0");
    }

    delay(5000);
  } else {
    reconnect();
  }
}

Oben im Sketch hast du (neben den obligatorischen WLAN- und Broker-Daten) die Möglichkeit, in der Konstanten lightThreshold den Schwellenwert für den Lichtsensor einzustellen. Nach dem Upload siehst du den aktuellen Wert im Seriellen Monitor. Nutze diese Informationen, um einen passenden Schwellenwert für deine Anwendung zu definieren.

Der Sender misst alle 5 Sekunden den Lichtwert und sendet dann die passende Nachricht per MQTT.

Der Sketch für den Empfänger

Nun soll dein zweiter ESP8266 mit der angeschlossenen LED auf diese Nachrichten reagieren. Lade hierfür den folgenden Sketch hoch:

//Lichtstärke empfangen

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const char* ssid = "DEIN_WLAN_SSID";
const char* password = "DEIN_WLAN_PASSWORT";
const char* mqtt_server = "IP_ADRESSE_DES_BROKERS";

WiFiClient espClient;
PubSubClient client(espClient);

const int ledPin = D5;

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Verbinde mit ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi verbunden");
  Serial.println("IP-Adresse: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Nachricht empfangen [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();

  if ((char)payload[0] == '1') {
    digitalWrite(ledPin, HIGH);  // LED einschalten
  } else {
    digitalWrite(ledPin, LOW);  // LED ausschalten
  }
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Verbinde mit MQTT...");
    if (client.connect("ESP8266Client_Receiver")) {
      Serial.println("verbunden");
      client.subscribe("esp8266/light");
    } else {
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" Nächster Versuch in 5 Sekunden");
      delay(5000);
    }
  }
}

void loop() {
  if (client.connected()) {
    client.loop();
  } else {
    reconnect();
  }
}

Dieser Sketch unterscheidet sich nur leicht von jenem, mit dem du die LED per Terminal gesteuert hast. Eine Sache ist jedoch wichtig, wenn du zwei ESP8266 miteinander über den MQTT-Broker kommunizieren lässt: Sie müssen unterschiedliche Namen haben.

Den Namen, mit dem sich dein ESP8266 beim Broker anmeldet, definierst du in der folgenden Funktion (recht weit unten im Sketch):

client.connect("ESP8266Client_Receiver")

Und das war es schon, mehr benötigst du für eine einfache Kommunikation zweier ESP8266 nicht. Teste nun alle drei Geräte (Broker, Sender und Empfänger) und schaue, ob die LED angeht, wenn das Licht ausgeht.

Was ist ein MQTT-Broker?

Ein MQTT-Broker ist das Herzstück jeder MQTT-basierten Kommunikation. Er fungiert als zentrale Vermittlungsinstanz zwischen den Geräten, die Nachrichten senden (Publisher) und denen, die Nachrichten empfangen (Subscriber). Stell dir den Broker als eine Art intelligenten Postboten vor, der Nachrichten entgegennimmt und sie an die richtigen Empfänger verteilt.

Die Aufgaben eines MQTT-Brokers

Ein MQTT-Broker hat folgende Hauptaufgaben:

1. Verbindungen annehmen: Der Broker nimmt Verbindungen von MQTT-Clients (Publisher und Subscriber) entgegen.
2. Nachrichten empfangen: Er nimmt Nachrichten von Publishern entgegen.
3. Nachrichten verteilen: Der Broker leitet die empfangenen Nachrichten an die entsprechenden Subscriber weiter.
4. Sicherheit gewährleisten: Er kümmert sich um die Authentifizierung und Autorisierung von Clients.
5. Quality of Service (QoS) sicherstellen: Der Broker sorgt dafür, dass die vereinbarten QoS-Level eingehalten werden.
6. Retained Messages verwalten: Er speichert die letzten Nachrichten für bestimmte Topics.
7. Last Will and Testament (LWT) verwalten: Der Broker sendet LWT-Nachrichten, wenn sich Clients unerwartet abmelden.

Populäre MQTT-Broker

Es gibt eine Vielzahl von MQTT-Broker-Implementierungen, sowohl Open Source als auch kommerzielle Lösungen. Hier sind einige der beliebtesten:

• Mosquitto: Ein leichtgewichtiger Open-Source-Broker, ideal für Einsteiger und kleinere Projekte.
• HiveMQ: Ein skalierbarer kommerzieller Broker mit vielen Zusatzfunktionen für unternehmenskritische IoT-Anwendungen.
• VerneMQ: Ein Open-Source-Broker.
• AWS IoT Core: Ein vollständig verwalteter Cloud-Broker von Amazon Web Services.

In diesem Kurs konzentrieren wir uns auf Mosquitto, da es sich leicht installieren und konfigurieren lässt und für die meisten Maker-Projekte völlig ausreicht.

Mosquitto auf einem Raspberry Pi einrichten

Lass uns nun Schritt für Schritt einen Mosquitto-Broker auf deinem Raspberry Pi einrichten. Wenn du keinen Raspberry Pi zur Hand hast, kannst du Mosquitto auch auf deinem PC oder Mac installieren. Die Schritte sind ähnlich, aber die genauen Befehle können je nach Betriebssystem variieren.

Schritt 1: Installation von Mosquitto

Öffne ein Terminal auf deinem Raspberry Pi und führe die folgenden Befehle aus:

sudo apt update
sudo apt install mosquitto mosquitto-clients

___STEADY_PAYWALL___

Der erste Befehl aktualisiert die Paketlisten deines Systems. Der zweite Befehl installiert den Mosquitto-Broker und die Mosquitto-Clients. Die Clients sind nützliche Kommandozeilen-Tools, die wir später zum Testen verwenden werden.

Schritt 2: Mosquitto-Dienst starten

Nach der Installation müssen wir den Mosquitto-Dienst starten:

sudo systemctl start mosquitto

Schritt 3: Status überprüfen

Um zu überprüfen, ob Mosquitto erfolgreich gestartet wurde, verwenden wir den folgenden Befehl:

sudo systemctl status mosquitto

Du solltest eine Ausgabe ähnlich der folgenden sehen:

Wenn du Active: active (running) siehst, läuft dein Mosquitto-Broker erfolgreich!

Mosquitto testen

Mosquitto bringt zwei nützliche Kommandozeilen-Tools mit:

• mosquitto_pub: Zum Veröffentlichen von Nachrichten an ein Topic
• mosquitto_sub: Zum Abonnieren von Topics und Anzeigen empfangener Nachrichten

Lass uns diese Tools nutzen, um unseren Broker zu testen.

Schritt 1: Ein Topic abonnieren

Öffne ein neues Terminal-Fenster und gib den folgenden Befehl ein:

mosquitto_sub -t test

Dieser Befehl abonniert das Topic “test”. Der Terminal bleibt nun offen und wartet auf eingehende Nachrichten.

Schritt 2: Eine Nachricht veröffentlichen

Öffne ein weiteres Terminal-Fenster und veröffentliche eine Nachricht mit folgendem Befehl:

mosquitto_pub -t test -m "Hallo MQTT!"

Dieser Befehl veröffentlicht die Nachricht “Hallo MQTT!” zum Topic “test”.

Schritt 3: Ergebnis überprüfen

Im ersten Terminal-Fenster, wo du mosquitto_sub ausgeführt hast, solltest du nun die Nachricht “Hallo MQTT!” sehen. Falls ja, hast du deinen ersten MQTT-Broker erfolgreich in Betrieb genommen und getestet.

Fazit und Ausblick

In diesem Tutorial hast du gelernt, was ein MQTT-Broker ist, welche Aufgaben er hat und wie du einen eigenen Mosquitto-Broker auf einem Raspberry Pi einrichtest. Du hast auch gelernt, wie du den Broker mit den Mosquitto-Kommandozeilen-Tools testen kannst.

Ein laufender MQTT-Broker ist die Grundlage für viele spannende IoT-Projekte. Im nächsten Teil wirst du lernen, wie du verschiedene Geräte wie den ESP8266 als MQTT-Clients einrichtest, um Daten zu senden und zu empfangen. Du wirst sehen, wie einfach es ist, mit MQTT Sensordaten zu übertragen, Geräte zu steuern und IoT-Systeme aufzubauen.

Bis dahin kannst du gerne weiter mit deinem Mosquitto-Broker experimentieren:

• Versuche, Nachrichten zu verschiedenen Topics zu senden und zu empfangen.
• Schau dir die Dokumentation von Mosquitto an, um mehr über die Konfigurationsmöglichkeiten zu erfahren.
• Überlege dir, welche Anwendungen in deinem Haushalt oder deiner Umgebung von einer MQTT-basierten Kommunikation profitieren könnten.

Viel Spaß beim Experimentieren mit deinem neuen MQTT-Broker!

In dieser Einführung klären wir zunächst, worum es sich bei MQTT überhaupt handelt und wie es grundlegend funktioniert.

Was ist MQTT?

MQTT steht für “Message Queuing Telemetry Transport”. Es handelt sich um ein leichtgewichtiges, offenes Nachrichtenprotokoll, das sich ideal für die M2M-Kommunikation (Machine-to-Machine) eignet. MQTT ermöglicht es Geräten, auf einfache und effiziente Weise Daten auszutauschen.

Das Protokoll wurde 1999 von Andy Stanford-Clark (IBM) und Arlen Nipper (Cirrus Link) entwickelt. Heute hat sich MQTT zu einem Standard im IoT-Bereich entwickelt.

MQTT bietet einige Vorteile, die es für IoT-Anwendungen besonders attraktiv machen:

• Leichtgewichtig: MQTT kommt mit minimaler Netzwerk-Bandbreite und geringen Hardwareanforderungen aus.
• Publish/Subscribe-Modell: MQTT entkoppelt Sender (Publisher) und Empfänger (Subscriber) von Nachrichten. Geräte kommunizieren nicht direkt miteinander, sondern über einen Broker.
• Skalierbarkeit: Das Protokoll ist hervorragend für große Netzwerke mit vielen Geräten geeignet.
• Zuverlässigkeit: MQTT bietet drei Quality of Service (QoS) Levels, um unterschiedliche Anforderungen zu erfüllen.
• Flexibilität: MQTT lässt sich leicht in bestehende Systeme integrieren und ist mit vielen Programmiersprachen und Plattformen kompatibel.

Wie funktioniert MQTT?

Um die Funktionsweise von MQTT zu verstehen, ist wie so oft ein Schaubild ganz hilfreich:

Dieses Schaubild zeigt ein mögliches Smart-Home-Szenario. Lass uns die einzelnen Elemente durchgehen:

1. Broker: Im Zentrum des Bildes siehst du einen grünen Kreis mit der Beschriftung “Broker”. Der Broker ist das Herzstück des MQTT-Systems und fungiert als zentraler Vermittler zwischen allen Geräten.
2. Publisher (Sender): Auf der linken Seite sind drei blaue Kreise mit Thermometer-Symbolen zu sehen. Diese stellen die Publisher dar – in diesem Fall Temperatursensoren an verschiedenen Orten:
   • Ein Sensor im Haus (home/temperature) misst 19°C
   • Ein Sensor in der Garage (garage/temperature) misst 15°C
   • Ein Sensor im Garten (garden/temperature) misst -4°C
3. Subscriber (Empfänger): Auf der rechten Seite befinden sich zwei rote Kreise mit Chip-Symbolen. Diese repräsentieren die Subscriber – Geräte, die Temperaturinformationen empfangen und verarbeiten:
   • Ein Gerät, das sich für die Haustemperatur interessiert und z.B. die Temperatur regelt.
   • Ein Gerät, das die Gartentemperatur überwacht und z.B. die Rollläden herunterlässt, um das Haus besser zu isolieren.
4. Publish-Vorgang: Die schwarzen Pfeile von den Publishern zum Broker zeigen den Publish-Vorgang. Jeder Sensor sendet seine Messwerte mit einem spezifischen Topic (z.B. “home/temperature”) an den Broker.
5. Subscribe-Vorgang: Die grauen Pfeile vom Broker zu den Subscribern zeigen den Subscribe-Vorgang. Die Subscriber teilen dem Broker mit, für welche Topics sie sich interessieren (z.B. “home/temperature” oder “garden/temperature”).
6. Nachrichtenverteilung: Die schwarzen Pfeile vom Broker zu den Subscribern zeigen, wie der Broker die empfangenen Nachrichten an die interessierten Subscriber weiterleitet.

Das Besondere an MQTT ist die Entkopplung von Sendern und Empfängern. Die Temperatursensoren (Publisher) wissen nicht, wer ihre Daten empfängt. Die Empfangsgeräte (Subscriber) wissen nicht, woher die Daten genau kommen. Alles läuft über den zentralen Broker.

Dieses System ermöglicht eine flexible und effiziente Kommunikation in IoT-Netzwerken. Neue Geräte können einfach hinzugefügt werden, indem sie sich beim Broker für die relevanten Topics registrieren, ohne dass andere Geräte angepasst werden müssen.

Topics und Topic-Hierarchie

In MQTT werden Nachrichten immer zu einem bestimmten “Topic” (Thema) veröffentlicht. Topics sind Zeichenketten, die hierarchisch aufgebaut sein können, ähnlich wie Verzeichnispfade.

Ein paar Beispiele für Topics hast du bereits im Schaubild kennengelernt:

• home/temperature
• garage/temperature
• garden/temperature

Topics werden mit Schrägstrichen (/) strukturiert. Das ermöglicht eine übersichtliche Ordnung und erleichtert das Abonnieren verwandter Themen.

Ein Subscriber kann nicht nur einzelne Topics, sondern auch ganze Topic-Zweige abonnieren. Dazu gibt es zwei Platzhalter:

• Plus (+): Ersetzt eine einzelne Hierarchieebene. Beispiel: home/+/temperature.
• Raute (#): Ersetzt beliebig viele Hierarchieebenen. Beispiel: home/#.

Quality of Service (QoS) Levels

Neben den Topics sind Quality of Service Levels ein wichtiger und interessanter Aspekt von MQTT. Unterschieden werden 3 Level, die die Zustellung und Verarbeitung von Nachrichten steuern:

QoS 0 (At most once):

• Dies ist das einfachste und schnellste Level.
• Der Sender schickt die Nachricht einmal an den Broker und vergisst sie dann.
• Der Broker leitet die Nachricht an die Subscriber weiter, ohne eine Bestätigung zu erwarten.
• Es gibt keine Garantie, dass die Nachricht ankommt.
• Verwendung: Ideal für häufig gesendete, nicht kritische Daten wie regelmäßige Sensorwerte.
• Beispiel: Ein Temperatursensor, der alle 5 Sekunden einen Wert sendet. Wenn mal ein Wert verloren geht, ist das nicht schlimm.

QoS 1 (At least once):

• Der Sender speichert die Nachricht, bis er eine Bestätigung (PUBACK) vom Broker erhält.
• Wenn keine Bestätigung kommt, sendet er die Nachricht erneut.
• Der Broker leitet die Nachricht an Subscriber weiter und erwartet ebenfalls eine Bestätigung.
• Die Nachricht kommt mindestens einmal an, kann aber auch mehrfach ankommen.
• Verwendung: Gut für wichtige Nachrichten, bei denen Duplikate kein Problem sind.
• Beispiel: Ein Schalter, der seinen Status meldet. Es ist wichtig, dass die Änderung ankommt, auch wenn sie vielleicht doppelt gemeldet wird.

QoS 2 (Exactly once):

• Das zuverlässigste, aber auch komplexeste und langsamste Level.
• Verwendet ein 4-Wege-Handshake zwischen Sender und Empfänger.
• Garantiert, dass die Nachricht genau einmal ankommt, ohne Verlust oder Duplikate.
• Verwendung: Für kritische Nachrichten, bei denen jede Nachricht wichtig ist und Duplikate Probleme verursachen würden.
• Beispiel: Finanztransaktionen oder kritische Steuerungsbefehle in industriellen Anlagen.

Die Wahl des passenden QoS-Levels hängt also von den Anforderungen deiner Anwendung ab. In vielen Fällen reicht bereits der einfachste Level QoS 0 aus.

Retained Messages und Last Will and Testament

Zuletzt noch zwei weitere nützliche MQTT-Funktionen:

Retained Messages

Stell dir einen digitalen Notizzettel vor, der an einer Pinnwand (dem Broker) hängt. Jeder, der vorbeikommt (sich subscribt), kann sofort den letzten Stand sehen, ohne warten zu müssen, bis jemand eine neue Notiz macht.

Beispiel:

• Du hast eine smarte Glühbirne im Wohnzimmer.
• Der Lichtschalter sendet eine Retained Message “AN” oder “AUS” an das Topic “haus/wohnzimmer/licht”.
• Wenn du eine neue App auf deinem Smartphone installierst und sie sich mit dem MQTT-Broker verbindet, weiß sie sofort, ob das Licht an oder aus ist, ohne auf die nächste Zustandsänderung warten zu müssen.

Last Will and Testament (LWT)

Stell dir vor, du gehst auf eine Party und sagst dem Gastgeber: “Wenn ich in der nächsten Stunde nicht wiederkomme, sag allen, ich musste plötzlich nach Hause.” Das ist im Prinzip das LWT.

Beispiel:

• Du hast einen Temperatursensor im Gewächshaus.
• Bei der Verbindung zum Broker richtet der Sensor ein LWT ein: “Gewächshaussensor offline”.
• Wenn der Sensor unerwartet die Verbindung verliert (z.B. wegen eines Stromausfalls), sendet der Broker automatisch diese Nachricht.
• So wissen alle interessierten Geräte, dass der Sensor nicht mehr aktiv ist, ohne auf ein Timeout warten zu müssen.

Das soll es zunächst mit Teil 1 der Reihe gewesen sein. Der nächste Teil beschäftigt sich mit dem Broker – dort erfährst du, wie du diesen auf einem Raspberry Pi einrichtest und wie das Senden und Abonnieren von Daten in der Praxis aussieht.