MQTT in MATLAB und Simulink: abonnieren, publizieren, Daten analysieren

MATLAB spricht mit jedem MQTT-Broker über eine einzige Funktion: mqttclient aus der Industrial Communication Toolbox. Sie verbindet sich, abonniert, publiziert und puffert eingehende Nachrichten in einer Timetable, also genau in der Form, die MATLAB für Analysen braucht. Dieses Tutorial zeigt einen kompletten Ablauf: mit dem Broker verbinden, Sensordaten sammeln, Befehle publizieren, das Ergebnis analysieren und was du in Simulink oder ohne Toolbox machst.

Was du brauchst

• MATLAB mit Industrial Communication Toolbox (die frühere OPC Toolbox, die mit R2022a MQTT-Unterstützung bekam). Prüfe das mit ver oder which mqttclient.
• Einen Broker. Die Beispiele nutzen den geteilten Test-Endpoint broker.connectmq.com (TCP 1883, TLS 8883).
• Einen zweiten Client, um den Traffic zu beobachten, etwa den Online-MQTT-Client oder mosquitto_sub.

Verwende ein eindeutiges Topic-Präfix wie testmqtt/matlab/<dein-name>/..., damit sich deine Testdaten nicht mit denen anderer Nutzer eines geteilten Brokers vermischen.

Mit dem Broker verbinden

mqttclient erwartet die Broker-Adresse mit Schema (tcp://, ssl://, ws:// oder wss://) und Optionen als Name-Wert-Argumente:

client = mqttclient("tcp://broker.connectmq.com", ...
    Port=1883, ...
    ClientID="matlab-" + string(randi(1e6)), ...
    KeepAliveDuration=seconds(60));

client.Connected   % true, wenn das CONNECT akzeptiert wurde

Bei einem Broker mit Authentifizierung liest du die Zugangsdaten aus Umgebungsvariablen, statt sie fest in ein Skript zu schreiben, das du vielleicht weitergibst:

client = mqttclient("ssl://broker.connectmq.com", ...
    Port=8883, ...
    Username=getenv("MQTT_USER"), ...
    Password=getenv("MQTT_PASS"), ...
    CARootCertificate="ca.pem");

CARootCertificate verweist auf eine PEM-Datei mit der CA, die das Zertifikat des Brokers signiert hat. Für Mutual TLS ergänzt du ClientCertificate und ClientKey. Wenn die Verbindung scheitert, prüfe die Zertifikatskette zuerst außerhalb von MATLAB; siehe MQTT-TLS-Verbindung testen.

Abonnieren: Callback oder Puffer

Es gibt zwei Wege, Nachrichten zu empfangen, und die richtige Wahl ist in MATLAB wichtiger als in anderen Sprachen.

Puffer-Modus (ohne Callback): Eingehende Nachrichten werden im Client-Objekt gespeichert. Du holst sie später mit read ab. Das ist ideal für Datenanalyse, weil du mit einem Aufruf eine Timetable bekommst:

subscribe(client, "testmqtt/matlab/sensors/+/temp", QualityOfService=1);
pause(30)                        % 30 Sekunden sammeln
msgs = read(client);             % Timetable: Time, Topic, Data
head(msgs)

Callback-Modus: Für jede Nachricht wird eine Funktion ausgeführt. Nutze ihn für Live-Reaktionen, etwa um einen Plot zu aktualisieren oder einen Alarm auszulösen:

subscribe(client, "testmqtt/matlab/alarms/#", Callback=@onAlarm);

function onAlarm(topic, data)
    fprintf("%s  %s -> %s\n", string(datetime("now")), topic, data);
end

Der Callback bekommt Topic und Payload. Halte ihn kurz: Er läuft im MATLAB-Thread, schwere Berechnungen darin verzögern also jede folgende Nachricht. Topic-Filter folgen den normalen MQTT-Regeln (+ passt auf eine Ebene, # auf den Rest); teste einen Filter mit dem Topic-Matcher gegen echte Topics, bevor du rätselst, warum nichts ankommt.

Weitere nützliche Funktionen: peek(client) zeigt die neuesten gepufferten Nachrichten, ohne sie zu entfernen, unsubscribe(client, topic) beendet ein Abonnement, flush(client) leert den Puffer und client.Subscriptions listet alle aktiven Abos.

Aus MATLAB publizieren

write sendet eine Nachricht. Kodiere strukturierte Daten mit jsonencode, damit jeder andere Client sie parsen kann:

for k = 1:60
    for id = ["s1" "s2" "s3"]
        msg = jsonencode(struct( ...
            "value", 20 + 2*randn(), ...
            "ts", posixtime(datetime("now"))));
        write(client, "testmqtt/matlab/sensors/" + id + "/temp", msg, ...
            QualityOfService=1);
    end
    pause(1)
end

Übergib Retain=true für Zustände, die spätere Subscriber sofort sehen sollen, etwa einen Sollwert oder eine Modellversion. QoS 1 garantiert eine Zustellung mindestens einmal zwischen MATLAB und Broker; die Abwägungen findest du unter MQTT-QoS-Stufen.

Beobachte das Ergebnis in einem zweiten Fenster: Öffne den Online-Client, abonniere testmqtt/matlab/#, und du solltest drei Topics sehen, die sich jede Sekunde aktualisieren.

Deine MATLAB-Nachrichten im Browser ansehen

Daten analysieren

Hier spielt MATLAB seine Stärken aus. read liefert eine Timetable, deren Variable Data die Payloads als Strings enthält. Dekodiere sie, baue eine saubere Timetable und taste sie neu ab:

msgs = read(client);

value = arrayfun(@(s) getfield(jsondecode(s), "value"), msgs.Data);
sensor = extractBetween(msgs.Topic, "sensors/", "/temp");

tt = timetable(msgs.Time, categorical(sensor), value, ...
    VariableNames=["Sensor" "Value"]);

% Minutenmittel pro Sensor
perMinute = groupsummary(timetable2table(tt), ...
    ["Sensor" "Time"], {"none" "minute"}, "mean", "Value");

% Glätten und plotten
figure; hold on
for s = categories(tt.Sensor)'
    t = tt(tt.Sensor == s{1}, :);
    plot(t.Time, smoothdata(t.Value, "movmean", 10), DisplayName=s{1});
end
legend; ylabel("Temperatur (°C)"); title("MQTT-Sensordaten")

Ein paar praktische Hinweise:

• msgs.Time ist der Zeitpunkt, an dem die Nachricht bei MATLAB ankam, nicht der Messzeitpunkt am Gerät. Wenn das Timing wichtig ist, packe einen Zeitstempel in den Payload (wie oben) und verwende diesen. Abweichende Uhren der Geräte sind eine klassische Ursache für verwirrende Plots.
• Die Dekodierung scheitert an fehlerhaftem JSON. Packe jsondecode bei echten Gerätedaten in try/catch oder filtere vorher mit startsWith(msgs.Data, "{").
• Der Puffer wächst, solange du nicht liest. Bei langen Läufen rufst du read regelmäßig auf und hängst die Daten mit writetimetable an eine Datei an, oder du speicherst von Anfang an auf der Platte (siehe MQTT in CSV loggen für dasselbe Muster in Python).

Das Payload-Design entscheidet, ob dieser Schritt einfach oder mühsam ist. Kurzes, flaches JSON mit expliziten Einheiten und Zeitstempeln ist das analysefreundlichste Format; siehe Best Practices für Payload-Design.

MQTT in Simulink

Für Modelle, die Signale mit echten Geräten austauschen sollen, bringen aktuelle Releases der Industrial Communication Toolbox die Blöcke MQTT Publish und MQTT Subscribe mit, und Hardware-Support-Packages (zum Beispiel das für Raspberry Pi) haben eigene MQTT-Blöcke für die Codegenerierung auf dem Zielsystem. Welche Blöcke und Optionen es genau gibt, hängt vom Release ab; schau also in die Blockbibliothek deiner Installation.

Typische Einsätze:

• Hardware-in-the-Loop: Ein Streckenmodell in Simulink abonniert Aktorbefehle eines echten Controllers und publiziert simulierte Sensorwerte.
• Digital-Twin-Dashboards: Ein laufendes Modell publiziert seine Zustände, damit ein Web-Dashboard sie anzeigen kann.
• Parameter-Tuning: Ein Subscriber-Block empfängt Sollwerte, die während der Simulation aus MATLAB oder einem Browser publiziert werden.

Standardmäßig läuft Simulink so schnell es kann. Wenn du es an MQTT anbindest, aktiviere Simulation Pacing (oder nutze ein Echtzeit-Target), damit das Modell den Broker nicht mit Tausenden Nachrichten pro Sekunde simulierter Zeit flutet.

Ohne Toolbox: Python aus MATLAB nutzen

Steht die Industrial Communication Toolbox nicht zur Verfügung, kann die Python-Schnittstelle von MATLAB paho-mqtt direkt aufrufen. Installiere es in der Python-Umgebung, die pyenv anzeigt (pip install paho-mqtt), und nutze die blockierenden Helfer von paho:

% Eine Nachricht publizieren
py.paho.mqtt.publish.single("testmqtt/matlab/cmd", "start", ...
    pyargs("hostname", "broker.connectmq.com", "port", int32(1883), "qos", int32(1)));

% Auf 5 Nachrichten warten und zurückgeben
msgs = py.paho.mqtt.subscribe.simple("testmqtt/matlab/sensors/#", ...
    pyargs("hostname", "broker.connectmq.com", "msg_count", int32(5)));

for k = 1:length(msgs)
    m = msgs{k};
    fprintf("%s: %s\n", string(m.topic), string(m.payload.decode()));
end

Für Skripte und Batch-Jobs reicht das. Für kontinuierliche Datenströme lässt du außerhalb von MATLAB eine kleine Bridge in Python oder Node.js laufen, die in eine Datei oder Datenbank schreibt, und analysierst diese mit MATLAB; sie übersteht MATLAB-Neustarts und hält deinen Analysecode einfach.

Fehlersuche

Zusammenfassung

mqttclient macht MATLAB zu einem vollwertigen MQTT-Client: Verbinde dich per tcp:// oder ssl://, abonniere im Puffer-Modus für Analysen oder mit Callback für Live-Reaktionen, publiziere JSON mit write und mache aus Nachrichten mit read Timetables. Prüfe Topics und Payloads mit einem zweiten Client, bevor du Analysecode schreibst, packe Gerätezeitstempel in die Payloads und verlagere langlaufende Erfassung in eine Datei oder Datenbank, sobald aus dem Experiment eine Pipeline wird. Für industrielle Architekturen rund um dieses Thema siehe MQTT in IIoT und Industrie 4.0.

Häufig gestellte Fragen