MQTT en MATLAB y Simulink: suscribirse, publicar y analizar datos

MATLAB puede hablar con cualquier broker MQTT con una sola función: mqttclient, parte de Industrial Communication Toolbox. Se conecta, se suscribe, publica y guarda los mensajes entrantes en un timetable, que es justo el formato que MATLAB quiere para analizar. Este tutorial recorre un flujo completo: conectarte a un broker, recopilar datos de sensores, publicar comandos, analizar el resultado y qué hacer en Simulink o si no tienes el toolbox.

Qué necesitas

• MATLAB con Industrial Communication Toolbox (el antiguo OPC Toolbox, que incorporó MQTT en R2022a). Compruébalo con ver o which mqttclient.
• Un broker. Los ejemplos usan el endpoint de pruebas compartido broker.connectmq.com (TCP 1883, TLS 8883).
• Un segundo cliente para observar el tráfico, como el cliente MQTT online o mosquitto_sub.

Usa un prefijo de topic único como testmqtt/matlab/<tu-nombre>/... para que tus datos de prueba no se mezclen con los de otros usuarios de un broker compartido.

Conectarse al broker

mqttclient recibe la dirección del broker con un esquema (tcp://, ssl://, ws:// o wss://) y las opciones como argumentos nombre-valor:

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

client.Connected   % true cuando el CONNECT fue aceptado

Para un broker con autenticación, toma las credenciales de variables de entorno en lugar de escribirlas en un script que quizá compartas:

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

CARootCertificate apunta a un archivo PEM con la CA que firmó el certificado del broker. Para TLS mutuo añade ClientCertificate y ClientKey. Si la conexión falla, verifica primero la cadena de certificados fuera de MATLAB; consulta cómo probar una conexión MQTT con TLS.

Suscribirse: callback o buffer

Hay dos maneras de recibir mensajes, y elegir la correcta importa más en MATLAB que en otros lenguajes.

Modo buffer (sin callback): guarda los mensajes entrantes dentro del objeto cliente. Los recoges después con read. Es ideal para análisis de datos porque obtienes un timetable con una sola llamada:

subscribe(client, "testmqtt/matlab/sensors/+/temp", QualityOfService=1);
pause(30)                        % recopilar durante 30 segundos
msgs = read(client);             % timetable: Time, Topic, Data
head(msgs)

Modo callback: ejecuta una función por cada mensaje. Úsalo para reacciones en vivo, como actualizar un gráfico o disparar una alarma:

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

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

El callback recibe el topic y el payload. Mantenlo corto: se ejecuta en el hilo de MATLAB, así que un cálculo pesado dentro del callback retrasa todos los mensajes siguientes. Los filtros de topic siguen las reglas normales de MQTT (+ coincide con un nivel, # con el resto); prueba un filtro contra topics reales con el topic matcher antes de preguntarte por qué no llega nada.

Otras funciones útiles: peek(client) muestra los mensajes más recientes del buffer sin eliminarlos, unsubscribe(client, topic) detiene una suscripción, flush(client) vacía el buffer y client.Subscriptions lista las suscripciones activas.

Publicar desde MATLAB

write envía un mensaje. Codifica los datos estructurados con jsonencode para que cualquier otro cliente pueda interpretarlos:

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

Pasa Retain=true para estados que los suscriptores tardíos deban ver de inmediato, como un setpoint o una versión de modelo. QoS 1 garantiza una entrega al menos una vez entre MATLAB y el broker; consulta los niveles de QoS de MQTT para ver las ventajas e inconvenientes.

Observa el resultado desde una segunda ventana: abre el cliente online, suscríbete a testmqtt/matlab/# y deberías ver tres topics actualizándose cada segundo.

Mira tus mensajes de MATLAB en el navegador

Analizar los datos

Aquí es donde MATLAB brilla. read devuelve un timetable cuya variable Data contiene los payloads como strings. Decodifícalos, construye un timetable limpio y remuestrea:

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"]);

% Media por minuto y por sensor
perMinute = groupsummary(timetable2table(tt), ...
    ["Sensor" "Time"], {"none" "minute"}, "mean", "Value");

% Suavizar y graficar
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("Temperatura (°C)"); title("Datos de sensores MQTT")

Algunas notas prácticas:

• msgs.Time es el momento en que el mensaje llegó a MATLAB, no cuando el dispositivo hizo la medición. Si el tiempo importa, incluye un timestamp en el payload (como arriba) y usa ese. La deriva de reloj entre dispositivos es una fuente clásica de gráficos confusos.
• La decodificación falla con JSON mal formado. Envuelve jsondecode en try/catch para datos reales de dispositivos, o filtra antes con startsWith(msgs.Data, "{").
• El buffer crece mientras no lees. En ejecuciones largas, llama a read periódicamente y añade los datos a un archivo con writetimetable, o guarda los datos en disco desde el principio (consulta registrar MQTT en CSV para el mismo patrón en Python).

El diseño del payload hace que este paso sea fácil o doloroso. Un JSON corto y plano, con unidades y timestamps explícitos, es el formato más cómodo para el análisis; consulta buenas prácticas de diseño de payloads.

MQTT en Simulink

Para modelos que deben intercambiar señales con dispositivos reales, las versiones recientes de Industrial Communication Toolbox incluyen los bloques MQTT Publish y MQTT Subscribe, y los paquetes de soporte de hardware (por ejemplo el de Raspberry Pi) traen sus propios bloques MQTT para generar código en el dispositivo. El conjunto exacto de bloques y opciones depende de tu versión, así que revisa la librería de bloques de tu instalación.

Usos típicos:

• Hardware-in-the-loop: un modelo de planta en Simulink se suscribe a los comandos de actuadores de un controlador real y publica valores de sensores simulados.
• Dashboards de gemelo digital: un modelo en ejecución publica sus estados para que un dashboard web los muestre.
• Ajuste de parámetros: un bloque suscriptor recibe setpoints publicados desde MATLAB o un navegador mientras corre la simulación.

Por defecto, Simulink corre tan rápido como puede. Cuando lo conectes a MQTT, activa el simulation pacing (o usa un target en tiempo real) para que el modelo no inunde el broker con miles de mensajes por segundo de tiempo simulado.

Sin el toolbox: usa Python desde MATLAB

Si no tienes Industrial Communication Toolbox, la interfaz de Python de MATLAB puede llamar directamente a paho-mqtt. Instálalo en el entorno de Python que indica pyenv (pip install paho-mqtt) y usa las funciones bloqueantes de paho:

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

% Esperar 5 mensajes y devolverlos
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

Esto sirve para scripts y trabajos por lotes. Para flujos continuos, ejecuta fuera de MATLAB un pequeño bridge en Python o Node.js que escriba en un archivo o una base de datos y analiza eso con MATLAB; sobrevive a los reinicios de MATLAB y mantiene simple tu código de análisis.

Solución de problemas

Resumen

mqttclient convierte a MATLAB en un cliente MQTT de primera: conéctate con tcp:// o ssl://, suscríbete en modo buffer para analizar o con callback para reaccionar en vivo, publica JSON con write y convierte los mensajes en timetables con read. Valida topics y payloads con un segundo cliente antes de escribir código de análisis, incluye timestamps del dispositivo en los payloads y lleva la recopilación de larga duración a un archivo o una base de datos cuando el experimento se convierta en un pipeline. Para arquitecturas industriales alrededor de esto, consulta MQTT en IIoT e Industria 4.0.

Preguntas frecuentes