Abo
Newsletter heise-Bot heise-Bot Push Nachrichten Push Push-Nachrichten

Kommunikation über MQTT

Für das Internet der Dinge sind systemnahe Kommunikationsprotokolle nur bedingt geeignet, weshalb hier das anwendungsnahe Protokoll MQTT betrachtet wird.

In Pocket speichern vorlesen Druckansicht 9 Kommentare lesen
Lesezeit: 20 Min.
Developer
Von
  • Dr. Michael Stal
Inhaltsverzeichnis

In der letzten Folge haben wir allgemein die Kommunikation eines Arduino über das Ethernet-Shield betrachtet, sowohl hinsichtlich der technischen Details als auch hinsichtlich der Programmierung. Für das Internet der Dinge sind systemnahe Kommunikationsprotokolle allerdings nur bedingt geeignet, weshalb diese Folge das anwendungsnahe Protokoll MQTT betrachtet.

Mit systemnahen Protokollen kommen wir nicht weit, da dort der Großteil des Programmieraufwands für die Übersetzung zwischen System- und Anwendungsebene anfällt. Zum Glück gibt es zahlreiche anwendungsnahe Alternativen. Eine davon ist MQTT.

MQTT stand einst für MQ Telemetry Transport und definiert heute einen OASIS- bzw. ISO Standard (ISO/IEC PRF 20922). Dahinter verbirgt sich eine leichtgewichtige Publish/Subscribe-Lösung, bei der Anwender Topics einrichten können, über die Clients (in der Rolle eines Publishers) Nachrichten bereitstellen und andere Clients (in der Rolle eines Subscribers) Nachrichten entnehmen. Ein Topic lässt sich als schwarzes Brett mit eindeutiger Inventarnummer interpretieren, wobei sich alle anmelden müssen, die Informationen auf dem Brett veröffentlichen wollen, ebenso diejenigen, die Nachrichten lesen wollen.

MQTT folgt dem Publish/Subscribe-Pattern

(Bild: HiveMQ.com)

Clients können auch beide Rollen besitzen. Um Art und Inhalt der Nachrichten kümmert sich MQTT nicht. Das bleibt den Anwendungen überlassen.

Die zentrale Komponente von MQTT ist ein sogenannter MQTT-Broker, der die Topics inklusive der darin enthaltenen Nachrichten verwaltet sowie den Zugriff auf die Topics regelt. Für Datensicherheit sind dort entsprechende Mechanismen vorhanden. Das gilt auch für den Quality of Service (QoS).

QoS spezifiziert die Semantik des Nachrichtentransfers.

  • Bei der der niedrigsten Stufe 0 handelt es sich im Prinzip um eine fire'n'forget-Semantik. Es gibt also keine Garantie, dass die Nachricht überhaupt ankommt.
  • Bei QoS-Level 1 ist sichergestellt, dass die Nachricht mindestens einmal in der Topic-Queue landet (At-least-once-Semantik).
  • In der höchsten Stufe 2 garantiert der Broker sogar exactly-once: die Nachricht wird also genau einmal abgelegt, nicht öfter und nicht weniger.

Je nach verwendeten Sicherheitsprotokollen, bietet ein MQTT-Broker unterschiedliche Zugriffs-Ports an. Der absolut ungesicherte Zugang geschieht in der Regel über Port 1883.

Zusammenspiel mit dem MQTT-Broker in einer IBM Bluemix Umgebung

Jede Verbindung mit einem MQTT-Broker erfolgt im Rahmen einer Session. Da im Internet Verbindungsausfälle nicht gerade selten vorkommen, können MQTT-Broker auch den Zustand von Clients persistent sichern und gegebenenfalls wieder herstellen, sobald Clients ihre ursprüngliche Session fortsetzen wollen. MQTT erlaubt aber auch, jedes Mal mit einer frischen Session zu starten.

Clients können zudem ihren letzten Willen spezifizieren. Das ist eine Nachricht, die der Broker an ein Topic sendet, wenn die Verbindung mit dem betreffenden Client unvorhergesehen abgebrochen wurde.

Des Weiteren gibt es die retained messages (aufbewahrte Nachrichten). Das sind Nachrichten mit gesetztem Retain-Flag. Meldet sich ein neuer Teilnehmer am Topic an, erhält er als Erstes die letzte Nachricht, die mit diesem Flag im Topic eingetroffen ist. Das gilt auch bei Abonnements mit Wildcards, die das betreffende Topic enthalten.

Mit MQTT-SN existiert eine MQTT-Lösung für das TCP/IP-freie Zigbee-Protokoll. Auch eine Implementierung von MQTT über Websockels, einer Komponente des HTML5-Standards, ist Bestandteil der Spezifikation. Dadurch ist der Einsatz von MQTT über Browser und Webserver möglich.

Der Einfachheit halber verwende ich für die nachfolgenden Beispiele ungesicherten Nachrichtenverkehr. Andernfalls würden Sie den Wald vor lauter Bäumen mehr erkennen. In der Praxis wäre das allerdings keine gute Idee.

Mosquito besticht

Um MQTT zu nutzen, benötigen Sie folglich einen Broker, der die Nachrichten von Publishern entgegennimmt und sie über das Topic an die entsprechenden Abonnenten beziehungsweise Subscriber weiterleitet. Ohne MQTT-Broker können wir erst gar nicht Nachrichten versenden oder empfangen.

Wie bei Nachrichten-Foren lassen sich auf einem MQTT-Broker sogenannte Topics einrichten, die sich letztlich wie Warteschlangen mit eindeutigem Namen verhalten, über die Teilnehmer Nachrichten hinzufügen oder entnehmen können. Bei Empfang und Versand einer Nachricht muss daher immer das gewünschte Topic angegeben sein. Topics lassen sich hierarchisch strukturieren. Ein Beispiel: 

Lieschen.Müller/Wohnung/Wohnzimmer/LEDStreifen42

Es geht um einen LED-Strip in der Wohnung von Lieschen Müller.

Gewünschte Topics abonnieren können Clients auch mit Wildcards. Zum Beispiel mit Ausdrücken wie den folgenden:

  • Lieschen.Müller/Wohnung/# => alle Topics von IoT-Geräten in Lieschen Müller's Wohnung.
  • Lieschen.Müller/Wohnung/+/Temperatur => alle Topics von Temperatursensoren in Lieschen Müller's Wohnung.
Mehr Infos

Beispiel: MQTT-Test-Broker mosquitto

Der Test-Broker ist über die Adresse test.mosquitto.org erreichbar.

Angebotene Ports sind:

  • 1883 : MQTT, unverschlüsselt
  • 8883 : MQTT, verschlüsselt
  • 8884 : MQTT, verschlüsselt, Client Zertifikat notwendig
  • 8080 : MQTT über WebSockets, unverschlüsselt
  • 8081 : MQTT über WebSockets, verschlüsselt

Die verschlüsselten Ports unterstützen TLS v1.2, v1.1 oder v1.0 mit x509-Zertifikaten und benötigen Kooperation des Clients. In allen Fällen sollten Entwickler die Trustcenter-Datei mosquitto.org.crt verwenden, um Serververbindungen zu verifizieren. Port 8884 verpflichtet Clients zur Bereitstellung eines Zertifikats, um ihre Verbindung zu authentisieren.

Zertifikate sind auf direkte Anfrage bei mosquitto.org verfügbar.

Neben kommerziellen MQTT-Broker-Lösungen wie HiveMQ gibt es auch eine kostenlose Open-Source-Lösung namens Mosquitto. Sie ist leistungsfähig, schlank, und kostenlos. Sie können natürlich alternativ einen der verfügbaren dauernd laufenden Test-MQTT-Broker im Internet benutzen (siehe separate Textbox). Allerdings ist es dann jedem möglich, Ihre Nachrichten mitzulesen.

Installationsdateien und -hinweise für diverse Betriebssysteme finden Sie im Download-Bereich von mosquitto. Sobald mosquitto auf Ihrem Computer läuft, können Sie im nächsten Schritt dem Arduino beibringen, Nachrichten über MQTT zu senden oder zu empfangen.

Arduino Client

Das Arduino Uno Board soll nun mit Hilfe des Ethernet-Shields Verbindung zu einem MQTT-Broker aufnehmen, dort Nachrichten über "outTopic" versenden, und Nachrichten über "inTopic" empfangen. Um selbst kein MQTT-Protokoll für Arduino entwickeln zu müssen, verwenden wir die Open-Source-Lösung von Nick O'Leary. Diese ist als PubSubClient auf seiner Webseite verfügbar. Die Bibliothek plus Beispiele können Sie über GitHub herunterladen. Und wie immer gilt, dass wir die Bibliothek der Arduino-IDE über das Menü Sketch | Include Library | Add .ZIP Library bekannt machen müssen.

Im nachfolgenden Sketch habe ich mich hemmungslos bei Nick O'Leary bedient. Das Demo-Programm geht von einer statischen Adressvergabe aus. Sie können für den Arduino aber auch die dynamische Adresszuweisung über DHCP aus dem vorherigen Sketch (der letzten Folge) verwenden.

Vergessen Sie nicht bei Ausführung des Sketches den seriellen Monitor der Arduino-IDE zu öffnen, und die Übertragungsrate auf 57.600 einzustellen. Diese Baudrate gibt das Arduino-Programm in der Methode setup() vor.

#include <SPI.h>          // Serial Peripheral Interface
#include <Ethernet.h>     // Ethernet Bibliothek
#include <PubSubClient.h> // MQTT Bibliothek

// Tragen Sie hier die Parameter für Ihr Netzwerk ein:
byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
IPAddress ip(192, 168, 178, 72);
IPAddress server(192, 168, 178, 40);
/*
Die nachfolgende Methode wird aufgerufen, sobald eine Nachricht für das angegebene Topic eintrifft:
*/

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

EthernetClient ethClient;
PubSubClient client(ethClient);

void reconnect() {
  // Solange wiederholen bis Verbindung wiederhergestellt ist
  while (!client.connected()) {
    Serial.print("Versuch des MQTT Verbindungsaufbaus...");

    //Verbindungsversuch:
    if (client.connect("arduinoClient")) {
      Serial.println("Erfolgreich verbunden!");
      // Nun versendet der Arduino eine Nachricht in outTopic ...
      client.publish("outTopic","Arduino nach Hause telefonieren");

      // und meldet sich bei inTopic für eingehende Nachrichten an:
      client.subscribe("inTopic");
    } else { // Im Fehlerfall => Fehlermeldung und neuer Versuch
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" Nächster Versuch in 5 Sekunden");
      // 5 Sekunden Pause vor dem nächsten Versuch
      delay(5000);
    }
  }
}

void setup()
{
  Serial.begin(57600);
  // Broker erreichbar über ip-Adresse = server, port = 1883
  client.setServer(server, 1883); // Adresse des MQTT-Brokers
  client.setCallback(callback);   // Handler für eingehende Nachrichten
  // Ethernet-Verbindung aufbauen
  Ethernet.begin(mac, ip);
  // Kleine Pause
  delay(1500);
}

void loop()
{  
  // Solange probieren bis es klappt:
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}

Wenn Sie den oberen Sketch starten, sehen Sie ... nichts! Kein Wunder, weil wir noch keinen Kommunikationspartner entwickelt haben. Allenfalls Selbstgespräche könnte der Arduino momentan führen.

Um das Ganze erst einmal ohne ein eigenes Programm zu testen, gibt es diverse MQTT-Test-Clients. Ich habe mich zu diesem Zweck für den Client MQTT.fx entschieden. Die Downloads für Windows, OS X, Linux finden Sie auf dieser Seite.

Sobald nach Installation und Programmstart das Fenster von MQTT.fx erscheint, geben Sie den gewünschten MQTT-Broker ein, mit dem Sie arbeiten möchten, in unserem Fall also den lokalen Mosquitto-Broker. MQTT.fx bietet Ihnen automatisch die Option "local mosquitto" an, sodass Sie nur noch auf connect klicken müssen.

MQTT.fx, Arduino, und Mosquitto in Aktion

In der Menüleiste von MQTT.fx können Sie sich zunächst über den Menüpunkt Broker Status Daten zur Verbindung mit dem MQTT-Broker abonnieren, sich über den Menüpunkt Subscribe für Nachrichten aus bestimmten Topics anmelden, oder über den Menüpunkt Publish Nachrichten in Topics publizieren. Zur Eingabe von Topic-Name und Nachricht nutzen Sie die jeweiligen Textfelder der Applikation. Publizieren Sie also entweder in inTopic, um Nachrichten an Arduino zu senden. Oder melden Sie sich für den Nachrichtenempfang über outTopic an, damit Ihnen der Arduino auch seinerseits Nachrichten senden kann.

JavaScript is calling

Unser erster selbst geschriebener MQTT-Client verwendet als Basis JavaScript. Ein entsprechendes Paket mqtt für Node.js existiert bereits. Wie immer, installieren wir zunächst die MQTT-Unterstützung über den Node Package Manager.

npm install mqtt --save

Auf diese Weise haben wir die schwerste Hürde bereits überwunden. Nun können wir damit beginnen, Nachrichten mit dem Arduino-Board auszutauschen. Ein einfaches Skript zeigt, wie leicht dies vonstatten geht:

var mqtt    = require('mqtt');
var client  = mqtt.connect('mqtt://localhost:1883');

// Verbindung zum Broker aufbauen:  
client.on('connect', function () {
      // Nachrichten aus outTopic abonnieren:
      client.subscribe('outTopic'); 
      // Nachrichten auf inTopic publizieren:
      client.publish('inTopic', 'Hallo Arduino, hier ist JavaScript!');
  });

// client.on enthält eine Ereignisbehandlung für eingehende Nachrichten:
client.on('message', function (topic, message) {  
  // Eingegangene Nachricht auslesen: 
  console.log(message.toString());
  client.end(); // Verbindung kappen
});

Wie Sie erkennen, ist die Kommunikation zwischen JavaScript und Arduino über MQTT kein großes Problem, weswegen wir uns der nächsten, etwas schwereren Hürde zuwenden können.

An dieser Stelle möchte ich ein etwas aufwendigeres MQTT-Projekt illustrieren. Die Idee ist recht einfach: Ein Java-Programm ermittelt die Anzahl der noch ungelesenen Mails in meiner Inbox. Diese Zahl meldet es über MQTT an den Arduino weiter. Der dort ablaufende Sketch empfängt die Nachricht und

  • lässt für 3 Sekunden eine grüne LED leuchten, wenn es keine ungelesenen Nachrichten gibt, oder
  • eine rote LED so oft blinken, wie es ungelesene Nachrichten gibt.

Alle Nachrichten sollen dafür über das Topic inTopic versandt beziehungsweise von dort durch den Arduino empfangen werden.

Als MQTT-Broker kommt wiederum mosquitto zum Einsatz. Sie sollten erneut MQTT.fx als Testplattform benutzen, um Ihren Sketch oder das Java-Programm zu testen.

Der Code leitet sich im Wesentlichen aus dem Code ab, den wir bereits weiter oben zum Kodieren eines Arduino-MQTT-Clients benutzt haben. Die Unterschiede sind mit Fettdruck hervorgehoben und kommentiert.

#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>

// Wir schließen eine grüne LED an Digital-Pin 6
// und eine rote LED an Digital-Pin 7 an.
const int greenLED = 6;
const int redLED = 7;

// Passen Sie die folgenden Werte an Ihre eigene Systemumgebung an:
byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
IPAddress ip(192, 168, 178, 72);
IPAddress server(192, 168, 178, 40);

// Die nachfolgende Methode wird aufgerufen, 
// sobald eine Nachricht  für das angegebene Topic eintrifft

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Nachricht eingetroffen [");
  Serial.print(topic);
  Serial.print("]: ");
    for (int i=0;i<length;i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
  
  // Zusätzlich zur Ausgabe über den seriellen Monitor
  // konvertieren wir die Nachricht in eine Zeichenkette
  // und anschließend in eine Ganzzahl:
  char *buffer = (char *) malloc(length);
  strcpy(buffer, (char *)payload);
  int blinks = String(buffer).toInt();


  // Kam als Wert 0, gibt es keine ungelesenen Nachrichten
  // => Wir lassen die grüne LED für 3 Sekunden leuchten:
  if (blinks == 0) {
    digitalWrite(redLED, LOW);
    digitalWrite(greenLED, HIGH);
    delay(3000);
    digitalWrite(greenLED, LOW);
  }
  // Kam als Wert > 0, soll die rote LED so oft blinken
  // wie es ungelesene Nachrichten gibt:
  else {
    digitalWrite(greenLED, LOW);
    for (int i = 0; i < blinks; i++) {
      digitalWrite(redLED, HIGH);
      delay(1000);
      digitalWrite(redLED, LOW);
      delay(1000);
    }
  }
}

EthernetClient ethClient;
PubSubClient client(ethClient);

void reconnect() {
  // Solange wiederholen bis Verbindung wiederhergestellt ist
  while (!client.connected()) {
    Serial.print("Versuch des MQTT Verbindungsaufbaus...");
    //Versuch die Verbindung aufzunehmen
    if (client.connect("arduinoClient")) {
      Serial.println("Erfolgreich verbunden!");
      // Nun versendet der Arduino eine Nachricht in outTopic ...
      client.publish("outTopic","Arduino nach Haue telefonieren");
      // und meldet sich für bei inTopic für eingehende Nachrichten an
      client.subscribe("inTopic");
    } else {
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" Nächster Versuch in 5 Sekunden");
      // 5 Sekunden Pause vor dem nächsten Versuch
      delay(5000);
    }
  }
}

void setup()
{
  pinMode(redLED, OUTPUT); // rote LED
  pinMode(greenLED, OUTPUT); // grüne LED
  Serial.begin(57600);
  // Broker = ip-Adresse= ip und port = 1883
  client.setServer(server, 1883);
  client.setCallback(callback);

  Ethernet.begin(mac, ip);
  // Kleine Pause
  delay(1500);
}

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

Laden Sie diesen Sketch auf den Arduino. Sie können mit MQTT.fx "fingierte" Nachrichten an den Arduino verschicken. Nicht vergessen: Der Sketch erwartet eine ganze Zahl >= 0.

Java als MQTT Client

Um einen MQTT-fähigen Java-Client zu erstellen, brauchen wir eine entsprechende Bibliothek. Die bekannteste Lösung heißt Paho, ist ein Eclipse-Incubator-Projekt und stellt Clients für alle möglichen Plattformen und Programmiersprachen zur Verfügung. Auch die bereits vorgestellte JavaScript-Erweiterung für Node.js stammt aus dieser Quelle.

Um Paho für Java zu verwenden, benötigen Sie die JAR-Bibliothek 

org.eclipse.paho.client.mqtt<version>-<paho version>.<paho unterversion>.jar

Binden Sie die Bibliothek als externes JAR in Ihren Java Build Path ein. Sie können gerne den Code mit Maven generieren. Bequemer ist der Download des Binarys aus dem Release-Repository.

Der Client verbindet sich mit dem MQTT-Broker, der an der Adresse tcp://localhost:1883 auf Verbindungswünsche wartet. Wir geben dem Client den Namen arduinoSample. Die Variable persistence kann Informationen zwischenspeichern, um bei Verbindungsabbrüchen wieder auf einem alten Zustand aufsetzen zu können. Allerdings bewirkt die Konfigurationsoption connOpts.setCleanSession(true), dass wir an jedem Programmstart mit einer frischen Session arbeiten.

Im Aufruf UnreadMessages.getNoOfUnreadMessages("Inbox") greifen wir auf die Mailbox-Klasse zu und erhalten die Zahl ungelesener Nachrichten zurück. Dazu später mehr.

Da wir als Quality-Of-Service-Parameter in message.setQos(qos) den Wert qos = 2 verwenden, wollen wir sicherstellen, dass die Nachricht exakt einmal in dem Topic ankommt.

Wir öffnen daraufhin die Verbindung und setzen unsere Nachricht zusammen. Daran anschließend versendet das Programm die Nachricht (sampleClient.publish(topic, message)) und kappt die Verbindung zum Broker (sampleClient.disconnect()).

Hat alles geklappt, müsste die Nachricht jetzt vom Arduino in Empfang genommen werden.

package de.stal.mqttdemo;

import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;

public class MqttPublishSample {

    public static void main(String[] args) {

        String topic        = "inTopic";
        int qos             = 2;
        String broker       = "tcp://localhost:1883";
        String clientId     = "arduinoSample";
        String msg = "";
        MemoryPersistence persistence = new MemoryPersistence();

        try {
            // Daten der Verbindung spezifizieren:
            MqttClient javaClient                                                             = new MqttClient(broker, clientId, persistence);
            // Konfiguration vornehmen:
            MqttConnectOptions connOpts = new MqttConnectOptions();
            connOpts.setCleanSession(true);
            System.out.println("Verbindungsaufbau zum MQTT-Broker: " + broker);
            // Verbinden:
            javaClient.connect(connOpts);
            System.out.println("Verbindungsaufbau erfolgreich!");
            // Hier erfolgt der Zugriff auf die Inbox:
            msg += UnreadMessages.getNoOfUnreadMessages("Inbox");
            System.out.println("Neue Nachricht in topic schreiben: "+ msg);
            // und hier wird die Nachricht zusammengesetzt:
            MqttMessage message = new MqttMessage(msg.getBytes());
            message.setQos(qos);
            // Publizieren der Nachricht:
            javaClient.publish(topic, message);
            System.out.println("Message published");
            // und Verbindung kappen:
            javaClient.disconnect();
            System.out.println("Verbindung geschlossen!");
            System.exit(0); // Erfolg!!
       } 
       catch(MqttException me) {
            System.out.println("reason "+me.getReasonCode());
            System.out.println("msg "+me.getMessage());
            System.out.println("loc "+me.getLocalizedMessage());
            System.out.println("cause "+me.getCause());
            System.out.println("excep "+me);
            me.printStackTrace();
        }
    }
}

Mailzugriff in Java

Aus Platzgründen kann ich nicht alle Details adressieren, wie über Java ein Zugriff auf die eigene Mailbox erfolgt. Den folgenden Code habe ich aus einer eigenen Anwendung extrahiert. Um ihn zu kompilieren, benötigen Sie die externe JavaMail-Bibliothek, die sie von dieser Seite herunterladen können. Auch diese JAR-Bibliothek gehört in den Java Build Path.

package de.stal.mqttdemo;

import java.util.Properties;
import javax.mail.Folder;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.Session;
import javax.mail.Store;

public class UnreadMessages {

  public static int getNoOfUnreadMessages(String folderName) {
      // Setzen Sie hier die Daten Ihres Providers ein:
      String host = "imap.gmail.com"; 
      // An dieser Stelle brauchen Sie Ihren Benutzernamen (meistens 
      // mit der email-Adresse identisch:
      String username = "vorname.nachname@gmail.com";
      // und hier geben Sie Ihr Passwort ein:
      String password = "passwort";
      Folder folder = null;
      Store store = null;
 
      int count = 0; // Nachrichtenzähler

      // Ich benutze imap zum Zugriff
      Properties props = System.getProperties();
      props.setProperty("mail.store.protocol", "imaps");
      try {
        Session session = Session.getDefaultInstance(props, null);
        // Session und Mailbox-Zugriff kreieren:
        store = session.getStore("imaps");
        store.connect(host, username, password);
        // Auf den Ordner folderName zugreifen: 
        folder = (Folder) store.getFolder(folderName);
        if(!folder.isOpen())
            folder.open(Folder.READ_WRITE);
        // Zahl der ungelesenen Nachrichten ermitteln:
        count = folder.getUnreadMessageCount();
     
      } catch (NoSuchProviderException exc) {
        exc.printStackTrace();
        System.exit(1);
      } catch (MessagingException exc) {
        exc.printStackTrace();
        System.exit(2);
      }  catch (Exception exc) {
    exc.printStackTrace();
      System.exit(2);
  }  finally  {
     try {
      if (folder != null && folder.isOpen()) { folder.close(true); }
      if (store != null) { store.close(); }
     }
     catch(MessagingException exc) {
         exc.printStackTrace();
         System.exit(2); // Fehlermeldung
     }
   }
   // Ermittelte Zahl ungelesener Nachrichten zurückgeben:
   return count;
  }
}

Der Beispielcode beendet sich nach einem Durchlauf. Sie können den Code auch so umstellen, dass das Programm alle n Sekunden die Mailbox abruft und die Information über MQTT an den Arduino-Sketch weiterleitet.

Das Programm ist übrigens eine gute psychologische Hilfe, um festzustellen, wie der Eingang von Mails zu ständigen Unterbrechungen Ihres Arbeitsablaufs führen kann.

MQTT-Alternativen

Für IoT-Entwickler steht natürlich nicht nur MQTT zur Auswahl. Daneben existieren einige weitere Alternativen:

  • Das Constrained Application Protocol der IETF spezifiziert eine Untermenge von REST. Zugriffe auf IoT-Geräte und ihre Dienste erfolgen bei dem anwendungsspezifischen Protokoll über Ressourcen (URIs). Mit CoAP beschäftigt sich diese Serie in einer späteren Folge.
  • XMPP als Extensible Messaging and Presence Protocol definiert nachrichtenbasierte Kommunikation auf Grundlage von XML. Momentan hält sich die Bedeutung dieses Standards für IoT jedoch in Grenzen.
  • Das gilt auch für AMQP (Advanced Messaging Queueing Protocol), das eine plattformneutrale Message-Queueing-Middleware offeriert. Auch AMQP hat zurzeit in Sachen IoT keine relevante Verbreitung.

Wir haben in dieser und der letzten Folge eine ganze Menge über Internet-Kommunikation mit IoT-Geräten kennengelernt. Die Möglichkeiten sind vielfältig und reichen vom Betrieb eines Mini-Webservers auf dem Mikrocontroller bis hin zu leichtgewichtiger Publish/Subscribe-Kommunikation mit MQTT. Welche Technologie Sie in der Praxis verwenden, hängt ganz von den eigenen Anforderungen und Vorlieben ab.

Standards wie MQTT sind allerdings klar im Vorteil, da sie in der Regel eine große Menge verfügbarer Implementierungen bieten, und insbesondere auch sethr heterogene Landschaften unterstützen.

Mehr Infos

Was bisher geschah:

()

Spiele

Alle Angebote
Newsletter heise-Bot heise-Bot Push Nachrichten Push Push-Nachrichten