Alertas de Limite MQTT: Seja Avisado Quando Valores Saírem da Faixa

Alertas de limite MQTT avisam no exato momento em que uma leitura de temperatura, pressão ou nível sai da faixa segura, sem que ninguém precise ficar olhando um dashboard. Neste tutorial você vai publicar dados de sensores realistas, criar regras de alerta por limite no portal ConnectMQ, montar um alerta equivalente no Node-RED capaz de notificar pessoas e adicionar histerese e debounce para que um valor oscilando no limite não inunde você de alertas.

Como Funcionam os Alertas de Limite MQTT

O MQTT em si não tem o conceito de alerta. Um alerta de limite é um assinante que observa um ou mais topics, extrai um valor numérico de cada payload e o compara com um limite. Quando a comparação muda de normal para anormal, ele dispara um alerta; quando volta, ele limpa o alerta. Onde esse assinante roda é a principal decisão de design:

Muitas equipes combinam as abordagens: regras no portal para visibilidade rápida, mais um alertador em Node-RED ou personalizado onde é preciso acionar alguém. Intertravamentos críticos de segurança sempre pertencem ao sistema de controle local, nunca a um alerta na nuvem.

Passo 1: Publique Dados de Sensores

Você precisa de um fluxo de números com desvios ocasionais. Este script publica temperatura e pressão de um tanque de utilidades, como os de uma planta industrial em Campinas, a cada dois segundos e, de vez em quando, sai da faixa. Instale o client com pip install "paho-mqtt>=2.0".

import json
import math
import random
import time

import paho.mqtt.client as mqtt

# Produção: seu broker ConnectMQ na porta 8883 com TLS e credenciais do portal.
# Teste rápido: o broker público na porta 1883 com um client ID único.
HOST, PORT = "broker.connectmq.com", 1883
ROOT = "connectmq/demo/a7f3q2/factory1/utilities/tank1"

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="tank1-sim-a7f3q2")
# Para o seu broker privado:
# client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="YOUR_CLIENT_ID")
# client.username_pw_set("YOUR_USERNAME", "YOUR_PASSWORD")
# client.tls_set()
# PORT = 8883
client.connect(HOST, PORT, keepalive=60)
client.loop_start()

t = 0
while True:
    temperature = 60 + 15 * math.sin(t / 30) + random.uniform(-1, 1)
    pressure = 4.0 + random.uniform(-0.2, 0.2) + (1.5 if random.random() < 0.03 else 0)
    payload = {"temperature": round(temperature, 2),
               "pressure": round(pressure, 2),
               "ts": int(time.time())}
    client.publish(f"{ROOT}/telemetry", json.dumps(payload), qos=1)
    t += 1
    time.sleep(2)

A temperatura oscila lentamente entre cerca de 45 e 75 graus, cruzando regularmente um limite de 70 graus, enquanto a pressão às vezes salta acima de 5 bar. Troque a parte a7f3q2 do topic por uma string aleatória sua, porque o servidor MQTT público é visível para todos e serve apenas para testes e protótipos, não para dados de produção.

Passo 2: Crie Regras de Alerta por Limite no Portal ConnectMQ

O portal ConnectMQ inclui regras de alerta por limite e um log de alertas, para que você acompanhe valores sem implantar mais nada. Aponte o simulador para o seu próprio broker (as linhas comentadas acima) e então:

1. Entre no portal e abra o seu broker.
2. Confirme que os dados estão chegando encontrando factory1/utilities/tank1/telemetry no explorador de topics ao vivo.
3. Crie uma regra de alerta por limite para esse topic no campo temperature, com limite superior de 70.
4. Crie uma segunda regra no campo pressure, com limite superior de 5.
5. Deixe o simulador rodando e abra o log de alertas. Em um ou dois minutos, os desvios de temperatura aparecem nos picos da senoide, e os saltos ocasionais de pressão aparecem também.

Mantenha seus payloads como JSON plano com campos numéricos, como no simulador. Valores enterrados em strings aninhadas ou enviados como "70.4 C" são muito mais difíceis de avaliar para qualquer ferramenta de alertas. O dashboard e a visão de dispositivos do portal mostram o mesmo tanque ao lado dos alertas, o que ajuda quando você precisa de contexto sobre o que mais estava acontecendo na linha.

Passo 3: Monte Alertas com Notificação no Node-RED

Quando um alerta precisa chegar a um celular, um canal de chat ou um sistema de chamados, o Node-RED é um companheiro prático para o broker. Configure um config node mqtt-broker com o host do seu broker, porta 8883 com TLS habilitado e as credenciais do portal. Depois, ligue este flow:

1. mqtt in assinando factory1/utilities/+/telemetry, com saída "a parsed JSON object".
2. Node function com a lógica de limite abaixo.
3. O node de notificação que preferir: e-mail, uma integração de chat ou uma requisição HTTP para uma ferramenta de incidentes.

// Function node do Node-RED: alerta de limite com histerese por tanque
const HIGH = 70;      // dispara quando a temperatura passa deste valor
const CLEAR = 67;     // limpa só quando cai abaixo deste valor
const tank = msg.topic.split("/")[2];
const value = Number(msg.payload.temperature);
if (Number.isNaN(value)) return null;

const key = `alarm_${tank}`;
const active = context.get(key) || false;

if (!active && value > HIGH) {
    context.set(key, true);
    msg.payload = { tank, state: "ALARM", temperature: value, limit: HIGH };
    return msg;
}
if (active && value < CLEAR) {
    context.set(key, false);
    msg.payload = { tank, state: "CLEARED", temperature: value };
    return msg;
}
return null;

Não é preciso um node de filtro depois da function, porque ela só emite uma mensagem quando o estado do alarme muda. O índice de topic [2] assume topics como factory1/utilities/tank1/telemetry; ajuste-o à sua hierarquia. Nosso tutorial de Node-RED com MQTT mostra em detalhes como instalar o Node-RED e configurar o node do broker.

Passo 4: Evite Rajadas de Alertas com Histerese e Debounce

Uma verificação ingênua de "valor maior que 70" dispara a cada mensagem enquanto o valor está alto, e liga e desliga quando o ruído empurra a leitura para lá e para cá do limite. Duas técnicas resolvem isso:

• Histerese usa limites separados para disparar e limpar (70 e 67 acima), de modo que o ruído em torno do limite não consegue alternar o estado.
• Debounce exige que a condição persista, por exemplo por três leituras consecutivas ou 30 segundos, antes de disparar o alerta. Ele filtra picos de uma única amostra causados por ruído elétrico.

O alertador em Python a seguir aplica as duas técnicas e publica o estado do alerta em um topic retido próprio, para que dashboards e outros sistemas possam assinar alertas como qualquer outro dado:

import json
import paho.mqtt.client as mqtt

HOST, PORT = "broker.connectmq.com", 1883
ROOT = "connectmq/demo/a7f3q2/factory1/utilities"
RULES = {"temperature": (70.0, 67.0), "pressure": (5.0, 4.6)}  # disparar, limpar
DEBOUNCE = 3

state = {}  # (tanque, campo) -> {"active": bool, "count": int}


def on_connect(client, userdata, flags, reason_code, properties):
    client.subscribe(f"{ROOT}/+/telemetry", qos=1)


def on_message(client, userdata, msg):
    tank = msg.topic.split("/")[-2]
    try:
        data = json.loads(msg.payload)
    except ValueError:
        return
    for field, (raise_at, clear_at) in RULES.items():
        value = data.get(field)
        if not isinstance(value, (int, float)):
            continue
        s = state.setdefault((tank, field), {"active": False, "count": 0})
        if not s["active"]:
            s["count"] = s["count"] + 1 if value > raise_at else 0
            if s["count"] >= DEBOUNCE:
                s["active"] = True
                publish_alert(client, tank, field, "ALARM", value, raise_at)
        elif value < clear_at:
            s["active"], s["count"] = False, 0
            publish_alert(client, tank, field, "CLEARED", value, clear_at)


def publish_alert(client, tank, field, status, value, limit):
    alert = {"tank": tank, "field": field, "status": status,
             "value": value, "limit": limit}
    print(alert)
    client.publish(f"{ROOT}/{tank}/alerts/{field}", json.dumps(alert),
                   qos=1, retain=True)


client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="alerter-a7f3q2")
client.on_connect = on_connect
client.on_message = on_message
client.connect(HOST, PORT, keepalive=60)
client.loop_forever()

Rode-o ao lado do simulador. Você verá um ALARM por desvio e um CLEARED quando o valor se recupera, em vez de dezenas de mensagens.

Como Escolher Bons Limites

Limites são uma decisão de processo, não de TI. Um checklist curto ajuda:

1. Parta dos limites do equipamento e das especificações do processo e defina o alerta abaixo do limite rígido, para deixar tempo de reação.
2. Use dois níveis quando fizer sentido: um aviso e um alerta crítico.
3. Coloque o limite de limpeza longe o bastante do limite de disparo para absorver o ruído normal.
4. Alerte também sobre silêncio: um sensor que para de publicar costuma ser mais perigoso que um valor alto. O topic $SYS/broker/connection/{clientId}/state na ConnectMQ, ou uma mensagem Last Will, avisa quando um dispositivo cai.
5. Revise o histórico de alertas mensalmente e aposente os alertas em que ninguém age.

Limites fixos não são a única opção. Uma regra de taxa de variação, como a temperatura subir mais de cinco graus em um minuto, muitas vezes avisa antes de um limite absoluto, porque pega uma falha de resfriamento enquanto o valor ainda está na faixa. Essas regras precisam de estado entre mensagens, então se encaixam naturalmente na function do Node-RED ou no alertador Python acima: guarde o valor anterior e o timestamp por dispositivo e compare a inclinação com o seu limite. Comece com limites simples e depois adicione regras baseadas em taxa onde o log de alertas mostrar que os desvios eram óbvios em retrospecto.

Para sinais mais amplos de saúde do broker, como contagem de conexões e taxas de mensagens, veja nosso guia de monitoramento de broker MQTT, e use o artigo sobre console de gerenciamento de broker MQTT para ver onde os alertas se encaixam entre os demais recursos do console.

Configure Alertas de Limite na ConnectMQ

Crie um broker gratuito em app.connectmq.com no plano Serverless, sem cartão de crédito, e adicione sua primeira regra de alerta por limite em minutos. A ConnectMQ oferece um broker MQTT gerenciado com log de alertas, explorador de topics e dashboard em um único portal. Para um experimento rápido antes, rode o simulador contra o servidor MQTT público (gratuito), e leia o guia de broker MQTT na nuvem quando planejar a produção.

Perguntas frequentes

Um broker MQTT consegue enviar alertas sozinho?

O protocolo MQTT não tem alertas, mas alguns brokers MQTT gerenciados os adicionam no portal. A ConnectMQ oferece regras de alerta por limite e um log de alertas; para notificações em celulares ou chat, combine-a com o Node-RED ou um pequeno serviço assinante.

O que é histerese em alertas de limite?

Significa usar um limite diferente para limpar um alerta do que para dispará-lo, por exemplo disparar acima de 70 e limpar abaixo de 67. Isso evita que um alerta fique ligando e desligando quando um valor ruidoso oscila em torno do limite.

Como alerto quando um sensor para de enviar dados?

Use uma mensagem Last Will ou o topic de estado de conexão do broker para detectar desconexões e adicione um timeout no seu alertador que dispare se nenhuma mensagem chegar dentro do intervalo esperado.

Alarmes de segurança devem depender de alertas de limite MQTT?

Não. Funções de segurança pertencem ao sistema de controle local. Alertas de limite MQTT servem para visibilidade e resposta operacional, não para intertravamentos de proteção.