MQTT no LabVIEW: bibliotecas e padrões para bancadas de teste

O LabVIEW não tem funções MQTT na paleta base, mas adicioná-las é fácil: instale uma biblioteca G, chame o paho-mqtt pelo Python Node ou rode uma pequena bridge ao lado do seu VI. A parte difícil é a arquitetura. Uma bancada que publica de dentro do loop de medição vai, cedo ou tarde, travar um teste quando a rede oscilar. Este guia compara as opções e mostra um padrão que mantém as medições determinísticas e os resultados confiáveis.

Suas opções em resumo

A opção open source mais usada é a biblioteca MQTT Client do LabVIEW Open Source Project, disponível pelo VIPM e desenvolvida no GitHub. Também existem toolkits comerciais no NI Tools Network. Todos seguem o mesmo modelo: criar um cliente, conectar, assinar, receber mensagens por um evento ou uma fila, publicar e desconectar. Os recursos mudam entre versões, então leia a descrição do pacote para saber a versão do protocolo e as opções de TLS antes de decidir.

Projete os topics primeiro

Defina um layout de topics antes de ligar qualquer fio. Para um laboratório de testes, uma subárvore por estação funciona bem:

O topic de status retido, combinado com um Last Will que publica offline, dá a cada dashboard o estado real de cada estação, mesmo depois de um travamento ou de um cabo de rede arrancado. Veja MQTT Last Will e mensagens retidas para entender como ambos se comportam. Para laboratórios maiores, valem as regras gerais de boas práticas de design de topics.

Para os payloads, monte um cluster (número de série, resultados de cada etapa, limites, pass/fail, timestamps) e converta-o com Flatten To JSON. No lado receptor, Unflatten From JSON com o mesmo tipo de cluster transforma os comandos de volta em dados tipados.

A arquitetura que não trava os testes

Nunca chame Publish dentro de um loop de medição temporizado. Um publish pode bloquear por segundos enquanto o cliente reconecta, e a temporização do seu teste vai desviar silenciosamente.

Use um layout produtor/consumidor ou Queued Message Handler:

1. Loop de medição: executa a sequência de teste e enfileira resultados e telemetria em uma fila do LabVIEW. Nunca toca na rede.
2. Loop MQTT: é dono da referência do cliente. Retira itens da fila e os publica, recebe comandos (pelo user event da biblioteca ou por um dequeue com timeout) e os repassa ao loop de medição por uma segunda fila.
3. Tratamento da conexão: o loop MQTT reconecta com back-off e assina novamente depois de cada reconexão. Resultados que chegam sem conexão ficam na fila (ou em um arquivo local) e são publicados quando a conexão volta.

Essa separação também torna a bancada testável: você pode rodar o loop de medição com o loop MQTT substituído por um stub que grava em arquivo.

Opção A: uma biblioteca G nativa

Com uma biblioteca G instalada pelo VIPM, o diagrama de blocos do loop MQTT costuma ficar assim:

1. Create/Open client: host do broker broker.connectmq.com, porta 1883 (ou 8883 com TLS), um client ID único como labview-bench01-<random>, keep-alive de 30 s.
2. Set Will: topic testmqtt/labview/bench01/status, payload offline, QoS 1, retain true.
3. Connect com usuário e senha lidos de um arquivo de configuração, nunca fixos no VI.
4. Publish online retido no topic de status e depois Subscribe em testmqtt/labview/bench01/cmd/# com QoS 1.
5. Estrutura de eventos / while loop: trate os eventos de "mensagem recebida" e retire da fila os itens de saída.
6. No desligamento: publique offline retido e então faça um Disconnect limpo (uma desconexão limpa não dispara o Will).

Se a biblioteca suporta TLS, geralmente ela usa as funções TLS nativas do LabVIEW e precisa do certificado da CA do broker. Teste o TLS primeiro a partir de um PC para que problemas de certificado não pareçam bugs do LabVIEW.

Opção B: paho-mqtt pelo Python Node

O Python Node (LabVIEW 2018+) chama funções de um módulo Python. Como uma sessão Python mantém o estado do módulo entre as chamadas, você pode guardar um cliente paho em um módulo e chamá-lo do LabVIEW como uma pequena API. Instale a biblioteca com pip install paho-mqtt no mesmo Python que o LabVIEW usa.

import queue
import uuid
import paho.mqtt.client as mqtt

_client = None
_inbox = queue.Queue()
_station = ""

def _on_connect(client, userdata, flags, reason_code, properties):
    if reason_code.is_failure:
        return
    client.publish(f"testmqtt/labview/{_station}/status", "online", qos=1, retain=True)
    client.subscribe(f"testmqtt/labview/{_station}/cmd/#", qos=1)

def _on_message(client, userdata, msg):
    _inbox.put((msg.topic, msg.payload.decode("utf-8", "replace")))

def connect(host, port, username, password, station):
    global _client, _station
    _station = station
    _client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2,
                          client_id=f"labview-{station}-{uuid.uuid4().hex[:6]}")
    if username:
        _client.username_pw_set(username, password)
    _client.will_set(f"testmqtt/labview/{station}/status", "offline", qos=1, retain=True)
    _client.on_connect = _on_connect
    _client.on_message = _on_message
    _client.reconnect_delay_set(min_delay=1, max_delay=30)
    _client.connect(host, int(port), keepalive=30)
    _client.loop_start()           # thread de rede: reconecta automaticamente
    return True

def publish(topic, payload, qos, retain):
    info = _client.publish(topic, payload, qos=int(qos), retain=bool(retain))
    return info.rc == mqtt.MQTT_ERR_SUCCESS

def poll(max_items):
    items = []
    while len(items) < int(max_items) and not _inbox.empty():
        items.append(_inbox.get_nowait())
    return items                   # lista de tuplas (topic, payload)

def disconnect():
    _client.publish(f"testmqtt/labview/{_station}/status", "offline", qos=1, retain=True).wait_for_publish(5)
    _client.disconnect()
    _client.loop_stop()
    return True

No LabVIEW:

• Open Python Session uma vez na inicialização (versão 3.x, com a mesma arquitetura do LabVIEW) e guarde a referência da sessão no shift register do loop MQTT.
• Chame connect com os dados do broker e depois poll a cada 100 ms, mais ou menos. Ligue como tipo de retorno um array de clusters de duas strings: cada tupla vira um cluster (topic, payload).
• Chame publish com a string JSON do Flatten To JSON.
• No desligamento, chame disconnect e depois Close Python Session.

O paho roda sua própria thread de rede com reconexão automática, então o lado do LabVIEW fica simples e nunca bloqueia muito tempo na rede. O mesmo módulo funciona com MQTT 5 se você passar protocol=mqtt.MQTTv5 para o cliente. Mais sobre a biblioteca em MQTT com Python.

Teste a bancada sem hardware

Antes de conectar instrumentos reais, verifique o lado MQTT de ponta a ponta. Em um terminal (ou no cliente online), acompanhe tudo o que a estação publica:

mosquitto_sub -h broker.connectmq.com -p 1883 -t 'testmqtt/labview/#' -v

Em outro, envie um comando como o MES faria:

mosquitto_pub -h broker.connectmq.com -p 1883 -q 1 \
  -t 'testmqtt/labview/bench01/cmd/start' -m '{"serial":"SN-0001","recipe":"A"}'

Você deve ver status = online e depois uma mensagem result para SN-0001. Agora mate o processo do LabVIEW (sem parada limpa): em cerca de 1,5 vez o intervalo de keep-alive, o broker publica o Will e o status muda para offline. Essa única verificação prova que seu Will, o status retido e a lógica de reconexão funcionam.

Acompanhe suas estações de teste no navegador

Para testes de regressão automatizados, roteirize os mesmos passos: publique um comando, aguarde o resultado com timeout e valide os campos. A abordagem escala para testes hardware-in-the-loop completos.

Armadilhas comuns

• Mesmo client ID em duas bancadas depois de copiar um projeto: as estações derrubam uma à outra em loop. Gere o ID a partir do nome da estação mais um sufixo aleatório.
• Publicação usada como referência de tempo: se os resultados só saem quando a rede está de pé, o log do teste e os dados MQTT não batem. Coloque o timestamp no momento da medição, não da publicação.
• Payloads enormes: formas de onda com milhões de amostras vão para arquivos ou banco de dados; publique um resumo e um link. Compare o tamanho das mensagens com os limites do broker antes de ir para produção.
• Resultados retidos: não retenha resultados por unidade, ou todo novo assinante recebe um resultado velho da última unidade. Retenha apenas estado.

LabVIEW e MQTT combinam bem quando a rede fica no próprio loop: escolha uma biblioteca que você consiga manter, defina topics e QoS logo no início, use um status retido com Last Will e teste o caminho inteiro com um cliente de linha de comando antes que a primeira unidade real chegue à bancada. Se o MATLAB faz a análise depois, veja MQTT no MATLAB.

Perguntas frequentes