Monitoramento de corrente de motor com alicate TC e MQTT para detecção precoce de falhas

O monitoramento de corrente de motor transforma o cabo de alimentação de qualquer motor elétrico em um sensor de saúde, sem tocar na máquina. Neste tutorial você vai prender um alicate TC (transformador de corrente) não invasivo em um cabo do motor, medir a corrente RMS com um ESP32, publicá-la via MQTT e rodar um serviço em Python que sinaliza sobrecargas, excesso de partidas e padrões de carga anormais.

Por que a corrente do motor é um sinal tão útil

A corrente diz o quanto um motor está se esforçando. Como o alicate fica em volta do cabo dentro do painel elétrico, você pode instalá-lo em máquinas antigas que não têm nenhuma interface de dados e nunca precisa montar nada em partes rotativas.

A partir de uma única leitura de corrente por segundo, é possível extrair muita coisa:

• Estado de operação: desligado, em vazio (motor girando sem carga) ou com carga. Muitas vezes é a forma mais barata de alimentar o apontamento de paradas de máquina.
• Sobrecarga: corrente acima da corrente nominal de placa por mais tempo que um curto período de partida.
• Desvio de carga: uma esteira consumindo cada vez mais corrente pode ter um rolamento arrastando, uma correia desalinhada ou acúmulo de produto. Uma bomba consumindo menos pode estar trabalhando a seco ou cavitando.
• Frequência de partidas: partidas demais por hora superaquecem os enrolamentos, e um aumento repentino muitas vezes revela um problema de controle.
• Desequilíbrio de fases: com um alicate por fase, correntes diferentes apontam para problemas de alimentação ou falhas no enrolamento.

Técnicas mais avançadas, como a análise de assinatura de corrente do motor (MCSA), examinam o espectro de frequência da corrente para detectar barras do rotor quebradas e defeitos em rolamentos. Elas exigem amostragem muito mais rápida e hardware dedicado. Tudo o que está neste artigo funciona com alguns valores RMS por segundo e ainda assim detecta os problemas operacionais mais comuns.

Segurança em primeiro lugar

Um alicate TC é não invasivo: ele envolve um único condutor isolado e nunca faz contato elétrico. Mesmo assim, o alicate é instalado dentro de um painel com partes energizadas. Peça a um eletricista qualificado que o instale com o painel desenergizado, prenda o alicate em volta de um único condutor de fase (nunca no cabo multipolar inteiro, onde os campos se anulam) e mantenha a fiação de baixa tensão do sensor separada da fiação de potência.

Hardware

Escolha um alicate com capacidade logo acima da corrente nominal do motor para obter a melhor resolução. Um alicate de 30 A em um motor de 3 A funciona, mas o sinal será pequeno e ruidoso.

Ligação

O alicate fornece uma tensão alternada centrada em zero, enquanto o ADC do ESP32 só lê tensões positivas. Polarize-o no meio da faixa:

1. Ligue os dois resistores de 10 kOhm em série entre 3,3 V e GND.
2. Ligue o capacitor de 10 uF do ponto médio ao GND.
3. Ligue um terminal do alicate ao ponto médio e o outro ao GPIO 34.

O GPIO 34 pertence ao ADC1, que continua funcionando com o Wi-Fi ativo. O guia sensor de corrente SCT-013 com ESP32 aborda a calibração e variantes de ligação com mais detalhes.

Firmware: monitoramento de corrente de motor no ESP32

O sketch amostra o ADC 2.000 vezes em 200 ms, o que cobre dez ciclos da rede em 50 Hz e doze em 60 Hz (o padrão no Brasil). Ele remove a polarização DC subtraindo a média, calcula a tensão RMS e a converte em ampères. A cada segundo, publica a corrente e um estado simples.

#include <WiFi.h>
#include <PubSubClient.h>
#include <math.h>

const char* WIFI_SSID = "YOUR_WIFI";
const char* WIFI_PASS = "YOUR_WIFI_PASSWORD";
const char* MQTT_HOST = "broker.connectmq.com";
const char* CLIENT_ID = "motor-ct-9be2c4";
const char* TOPIC = "connectmq/demo/9be2c4/line1/conveyor1/current";

const int CT_PIN = 34;
const float AMPS_PER_VOLT = 30.0f;  // SCT-013-030: 1 V RMS = 30 A
const float CAL = 1.00f;            // ajuste após comparar com um alicate amperímetro
const int SAMPLES = 2000;
const uint32_t SAMPLE_US = 100;     // 10 kHz, janela de 200 ms

const float IDLE_A = 0.5f;          // abaixo disso o motor está desligado
const float LOADED_A = 2.0f;        // acima disso o motor está com carga

WiFiClient net;
PubSubClient mqtt(net);
uint16_t samples[SAMPLES];

float measureAmps() {
  uint32_t next = micros();
  for (int i = 0; i < SAMPLES; i++) {
    while ((int32_t)(micros() - next) < 0) { }
    next += SAMPLE_US;
    samples[i] = analogReadMilliVolts(CT_PIN);
  }
  double mean = 0;
  for (int i = 0; i < SAMPLES; i++) mean += samples[i];
  mean /= SAMPLES;
  double sumSq = 0;
  for (int i = 0; i < SAMPLES; i++) {
    double d = samples[i] - mean;
    sumSq += d * d;
  }
  double vrms = sqrt(sumSq / SAMPLES) / 1000.0;
  return vrms * AMPS_PER_VOLT * CAL;
}

void ensureConnected() {
  if (WiFi.status() != WL_CONNECTED) {
    WiFi.begin(WIFI_SSID, WIFI_PASS);
    while (WiFi.status() != WL_CONNECTED) delay(250);
  }
  while (!mqtt.connected()) {
    if (!mqtt.connect(CLIENT_ID)) delay(2000);
  }
}

void setup() {
  Serial.begin(115200);
  analogSetPinAttenuation(CT_PIN, ADC_11db);
  WiFi.mode(WIFI_STA);
  mqtt.setServer(MQTT_HOST, 1883);
  ensureConnected();
}

void loop() {
  ensureConnected();
  mqtt.loop();

  static uint32_t lastPub = 0;
  if (millis() - lastPub < 1000) return;
  lastPub = millis();

  float amps = measureAmps();
  if (amps < 0.1f) amps = 0;  // suprime o piso de ruído
  const char* state = amps < IDLE_A ? "off" : amps < LOADED_A ? "idle" : "loaded";

  char payload[128];
  snprintf(payload, sizeof(payload),
           "{\"current_a\":%.2f,\"state\":\"%s\",\"uptime_s\":%lu}",
           amps, state, millis() / 1000);
  mqtt.publish(TOPIC, payload);
  Serial.println(payload);
}

Calibre uma vez com um alicate amperímetro confiável: rode o motor com carga estável, compare as duas leituras e defina CAL como a razão entre elas. Depois, ajuste IDLE_A e LOADED_A observando a máquina real funcionando vazia e com carga.

Verifique o fluxo de dados em qualquer terminal conectado ao servidor MQTT público:

mosquitto_sub -h broker.connectmq.com -p 1883 -i ct-viewer-9be2c4 -t "connectmq/demo/9be2c4/#" -v

Detectando sobrecargas e padrões anormais

O dispositivo reporta fatos brutos. A interpretação fica em um serviço que enxerga o histórico. O assinante Python abaixo (paho-mqtt 2.x) implementa quatro verificações que cobrem a maior parte das necessidades práticas:

1. Sobrecarga: corrente acima da nominal de placa por mais tempo que um período de tolerância, o que ignora a corrente de partida normal.
2. Contagem de partidas: transições de desligado para em operação, contadas em uma janela móvel de uma hora.
3. Desvio de carga: a média em carga dos últimos dez minutos comparada com um valor normal aprendido.
4. Dados parados: nenhuma mensagem por 30 segundos significa que o sensor ou a rede caiu.

import json
import time
from collections import deque
import paho.mqtt.client as mqtt

PREFIX = "connectmq/demo/9be2c4"
RATED_A = 8.5               # corrente nominal de placa do motor
OVERLOAD_GRACE_S = 10
MAX_STARTS_PER_HOUR = 6
DRIFT_LIMIT = 0.20          # 20 % de desvio em relação ao normal aprendido
LEARN_SAMPLES = 1800        # 30 minutos de operação com carga

over_since = None
last_state = "off"
starts = deque()
loaded = deque(maxlen=600)  # últimos 10 minutos de amostras com carga
learn = []
normal = None
last_seen = time.time()

def alert(client, kind, detail):
    msg = {"ts": int(time.time()), "kind": kind, **detail}
    client.publish(f"{PREFIX}/line1/conveyor1/alert", json.dumps(msg), qos=1)
    print("ALERT", msg)

def on_connect(client, userdata, flags, reason_code, properties):
    client.subscribe(f"{PREFIX}/line1/conveyor1/current", qos=1)

def on_message(client, userdata, msg):
    global over_since, last_state, normal, last_seen
    d = json.loads(msg.payload)
    amps, state, now = d["current_a"], d["state"], time.time()
    last_seen = now

    if amps > RATED_A:
        over_since = over_since or now
        if now - over_since >= OVERLOAD_GRACE_S:
            alert(client, "overload", {"current_a": amps, "rated_a": RATED_A})
            over_since = now  # novo alerta no máximo uma vez por período de tolerância
    else:
        over_since = None

    if last_state == "off" and state != "off":
        starts.append(now)
    while starts and now - starts[0] > 3600:
        starts.popleft()
    if len(starts) > MAX_STARTS_PER_HOUR:
        alert(client, "frequent_starts", {"starts_last_hour": len(starts)})
        starts.clear()
    last_state = state

    if state == "loaded":
        if normal is None:
            learn.append(amps)
            if len(learn) >= LEARN_SAMPLES:
                normal = sorted(learn)[len(learn) // 2]
                print(f"learned normal loaded current: {normal:.2f} A")
        else:
            loaded.append(amps)
            if len(loaded) == loaded.maxlen:
                avg = sum(loaded) / len(loaded)
                if abs(avg - normal) / normal > DRIFT_LIMIT:
                    alert(client, "load_drift", {"avg_a": round(avg, 2), "normal_a": round(normal, 2)})
                    loaded.clear()

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="motor-analytics-9be2c4")
client.on_connect = on_connect
client.on_message = on_message
client.connect("broker.connectmq.com", 1883, keepalive=60)
client.loop_start()
while True:
    time.sleep(5)
    if time.time() - last_seen > 30:
        alert(client, "stale", {"seconds_silent": int(time.time() - last_seen)})
        last_seen = time.time()

Só para a regra de sobrecarga, você nem precisa desse serviço. Uma regra de alerta por limite no portal do ConnectMQ sobre o campo current_a registra cada ultrapassagem no log de alertas. Mantenha o serviço Python para as verificações com estado, como desvio de carga e contagem de partidas.

Interpretando o que você vê

A corrente fica mais poderosa quando combinada com outros sinais. Corrente subindo com vibração subindo aponta para a mecânica, enquanto corrente subindo com vibração normal e leituras crescentes no monitoramento de temperatura de rolamentos estreita ainda mais a busca. O artigo manutenção preditiva com IoT mostra como esses sinais se combinam em uma estratégia de manutenção, e os mesmos dados podem alimentar um gêmeo digital da linha.

Escolhendo limites sensatos

Comece pela placa do motor, não por palpites. A corrente nominal de plena carga é o limite superior para operação contínua, então a regra de sobrecarga deve usá-la diretamente, com um período de tolerância longo o bastante para cobrir a corrente de partida normal que você observa naquela máquina. Partidas diretas consomem um grande pico por um ou dois segundos, enquanto soft-starters e inversores aceleram gradualmente, então o período de tolerância certo varia de motor para motor.

Para o desvio de carga, aprenda a corrente normal em carga a partir de um período em que a máquina está comprovadamente saudável e o mix de produtos é típico. Se a linha roda vários produtos com cargas muito diferentes, aprenda um valor normal por produto ou receita e inclua a receita ativa no payload. Caso contrário, toda troca de produto vai parecer uma anomalia e os operadores vão aprender a ignorar os alertas, o que anula o propósito do monitoramento.

Indo para produção

O servidor MQTT público é ótimo para testes, mas seus topics são visíveis para todos. Para motores reais:

• Crie um broker privado no portal do ConnectMQ e use o username, o password e o client ID gerados.
• Mude para TLS na porta 8883 com WiFiClientSecure.
• Use topics ISA-95 como acme/plant1/packaging/line1/conveyor1/current para que os ativos se agrupem naturalmente na visão de dispositivos.
• Adicione uma mensagem Last Will para que um sensor morto seja reportado como offline imediatamente.

Um broker MQTT gerenciado mantém essa infraestrutura atualizada e disponível enquanto você se concentra na análise. Para ver como o monitoramento de corrente se encaixa em uma arquitetura completa de dados da planta, leia o guia de manufatura inteligente.

Monitore seus motores com o ConnectMQ

O ConnectMQ roda seu broker MQTT na nuvem com TLS, MQTT 5, explorador de topics ao vivo e alertas por limite integrados ao portal. Cadastre-se em app.connectmq.com no plano Serverless gratuito, sem cartão de crédito, e conecte hoje mesmo seu primeiro alicate TC.

Perguntas frequentes

O que o monitoramento de corrente de motor consegue detectar?

Ele detecta com confiabilidade o estado de operação, sobrecargas, frequência anormal de partidas, desvio de carga e desequilíbrio de fases. Detectar defeitos em barras do rotor ou rolamentos pela corrente exige amostragem em alta velocidade e análise espectral.

É seguro instalar um alicate TC em um motor em funcionamento?

O alicate é não invasivo, mas é instalado em um painel com partes energizadas. Um eletricista qualificado deve instalá-lo com o painel desenergizado.

Com que frequência devo publicar as leituras de corrente do motor?

Uma vez por segundo é um bom padrão para detecção de estado e de sobrecarga. Taxas mais lentas, como a cada 10 segundos, funcionam para monitoramento de tendência puro.

Por que minha leitura mostra corrente quando o motor está desligado?

Esse é o piso de ruído do ADC. Suprima valores abaixo de um pequeno limite no firmware e mantenha a fiação do sensor longe dos cabos de potência.