Monitorización de corriente de motores con pinzas CT y MQTT para detectar fallas a tiempo

La monitorización de corriente de motores convierte el cable de alimentación de cualquier motor eléctrico en un sensor de salud, sin tocar la máquina. En este tutorial colocarás una pinza CT no invasiva en un conductor del motor, medirás la corriente RMS con un ESP32, la publicarás por MQTT y ejecutarás un servicio en Python que señala sobrecargas, arranques excesivos y patrones de carga anómalos.

Por qué la corriente del motor es una señal tan útil

La corriente te dice cuánto está trabajando un motor. Como la pinza se coloca alrededor del cable dentro del tablero eléctrico, puedes instalarla en máquinas antiguas que no tienen ninguna interfaz de datos, y nunca necesitas montar nada sobre piezas giratorias.

A partir de una sola lectura de corriente por segundo puedes obtener muchísima información:

• Estado de marcha: apagado, en vacío (el motor gira sin carga) o en carga. Suele ser la forma más barata de alimentar el seguimiento de paradas de máquina.
• Sobrecarga: corriente por encima de la corriente nominal a plena carga de la placa durante más tiempo que un breve periodo de arranque.
• Deriva de la carga: una cinta transportadora que consume cada vez más corriente puede tener un rodamiento que roza, una correa desalineada o acumulación de producto. Una bomba que consume menos puede estar trabajando en seco o cavitando.
• Frecuencia de arranques: demasiados arranques por hora sobrecalientan los devanados, y un aumento repentino suele revelar un problema de control.
• Desequilibrio de fases: con una pinza por fase, las corrientes desiguales apuntan a problemas de alimentación o fallas en los devanados.

Técnicas más avanzadas, como el análisis de la firma de corriente del motor (MCSA), estudian el espectro de frecuencias de la corriente para detectar barras de rotor rotas y defectos en los rodamientos. Necesitan un muestreo mucho más rápido y hardware dedicado. Todo lo que se explica en este artículo funciona con unos pocos valores RMS por segundo y, aun así, detecta los problemas operativos más habituales.

La seguridad es lo primero

Una pinza CT es no invasiva: rodea un único conductor aislado y nunca hace contacto eléctrico. Aun así, se instala dentro de un tablero con partes energizadas. Haz que la instale un electricista cualificado con el tablero desenergizado, coloca la pinza alrededor de un solo conductor de fase (nunca del cable multipolar completo, donde los campos se anulan) y mantén el cableado de baja tensión del sensor separado del cableado de potencia.

Hardware

Elige una pinza con un rango justo por encima de la corriente a plena carga del motor para obtener la mejor resolución. Una pinza de 30 A en un motor de 3 A funcionará, pero la señal será pequeña y ruidosa.

Cableado

La pinza entrega una tensión alterna centrada en cero, mientras que el ADC del ESP32 solo lee tensiones positivas. Polarízala al centro del rango:

1. Conecta las dos resistencias de 10 kOhm en serie entre 3,3 V y GND.
2. Conecta el condensador de 10 uF del punto medio a GND.
3. Conecta un terminal de la pinza al punto medio y el otro a GPIO 34.

GPIO 34 pertenece al ADC1, que sigue funcionando mientras el Wi-Fi está activo. La guía del sensor de corriente SCT-013 con ESP32 explica con más detalle la calibración y las variantes de cableado.

Firmware: monitorización de corriente de motores en el ESP32

El sketch toma 2.000 muestras del ADC en 200 ms, lo que cubre diez ciclos de red a 50 Hz y doce a 60 Hz. Elimina la polarización de continua restando la media, calcula la tensión RMS y la convierte a amperios. Cada segundo publica la corriente y un estado sencillo.

#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;            // ajustar tras comparar con una pinza amperimétrica
const int SAMPLES = 2000;
const uint32_t SAMPLE_US = 100;     // 10 kHz, ventana de 200 ms

const float IDLE_A = 0.5f;          // por debajo de este valor el motor está apagado
const float LOADED_A = 2.0f;        // por encima de este valor el motor está en 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;  // suprimir el ruido de fondo
  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);
}

Calibra una vez con una pinza amperimétrica de confianza: haz funcionar el motor con carga estable, compara ambas lecturas y ajusta CAL a la proporción entre ellas. Después fija IDLE_A y LOADED_A observando la máquina real en vacío y en carga.

Comprueba el flujo de datos desde cualquier terminal:

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

Detectar sobrecargas y patrones anómalos

El dispositivo informa de hechos en bruto. La interpretación corresponde a un servicio que pueda ver el historial. El suscriptor en Python de abajo (paho-mqtt 2.x) implementa cuatro comprobaciones que cubren la mayoría de las necesidades prácticas:

1. Sobrecarga: corriente por encima de la nominal durante más de un periodo de gracia, lo que ignora la corriente de arranque normal.
2. Conteo de arranques: transiciones de apagado a marcha, contadas en una ventana deslizante de una hora.
3. Deriva de la carga: la media en estado de carga de los últimos diez minutos comparada con un valor normal aprendido.
4. Datos obsoletos: ningún mensaje en 30 segundos significa que el sensor o la red están caídos.

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

PREFIX = "connectmq/demo/9be2c4"
RATED_A = 8.5               # corriente a plena carga de la placa del motor
OVERLOAD_GRACE_S = 10
MAX_STARTS_PER_HOUR = 6
DRIFT_LIMIT = 0.20          # 20 % de desviación respecto al valor normal aprendido
LEARN_SAMPLES = 1800        # 30 minutos de marcha en carga

over_since = None
last_state = "off"
starts = deque()
loaded = deque(maxlen=600)  # últimos 10 minutos de muestras en 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  # volver a alertar como máximo una vez por periodo de gracia
    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()

Para la regla de sobrecarga por sí sola ni siquiera necesitas este servicio. Una regla de alerta por umbral en el portal de ConnectMQ sobre el campo current_a registrará cada cruce en el log de alertas. Reserva el servicio en Python para las comprobaciones con estado, como la deriva y el conteo de arranques.

Interpretar lo que ves

La corriente es más potente cuando se combina con otras señales. Una corriente creciente junto con una vibración creciente apunta a la mecánica, mientras que una corriente creciente con vibración normal y lecturas en aumento en la monitorización de temperatura de rodamientos acota aún más la búsqueda. El artículo sobre mantenimiento predictivo con IoT muestra cómo se combinan estas señales en una estrategia de mantenimiento.

Elegir umbrales razonables

Parte de la placa de características del motor, no de suposiciones. La corriente a plena carga es el límite superior para el funcionamiento continuo, así que la regla de sobrecarga debe usarla directamente, con un periodo de gracia lo bastante largo para cubrir la corriente de arranque normal que observes en esa máquina. Los arranques directos consumen un pico elevado durante uno o dos segundos, mientras que los arrancadores suaves y los variadores aumentan la corriente de forma gradual, así que el periodo de gracia adecuado varía según el motor.

Para la deriva, aprende la corriente normal en carga durante un periodo en el que se sepa que la máquina está sana y la mezcla de productos es la habitual. Si la línea fabrica varios productos con cargas muy distintas, aprende un valor normal por producto o receta e incluye la receta activa en el payload. De lo contrario, cada cambio de producto parecerá una anomalía y los operadores aprenderán a ignorar las alertas, lo que anula el sentido de la monitorización.

Pasar a producción

El servidor MQTT público gratuito es ideal para pruebas, pero sus topics son visibles para todo el mundo, así que no lo uses con datos de producción. Para motores reales:

• Crea un broker privado en el portal de ConnectMQ y usa el username, la password y el client ID generados.
• Cambia a TLS en el puerto 8883 con WiFiClientSecure.
• Usa topics ISA-95 como acme/plant1/packaging/line1/conveyor1/current para que los activos se agrupen de forma natural en la vista de dispositivos.
• Añade un mensaje Last Will para que un sensor muerto se notifique como desconectado de inmediato.

Un broker MQTT gestionado mantiene esa infraestructura parcheada y disponible mientras tú te centras en la analítica. Para ver cómo encaja la monitorización de corriente en una arquitectura de datos de planta completa, lee la guía de manufactura inteligente.

Monitoriza tus motores con ConnectMQ

ConnectMQ ejecuta tu broker MQTT en la nube con TLS, MQTT 5, un explorador de topics en vivo y alertas por umbral integradas en el portal. Regístrate en app.connectmq.com en el plan gratuito Serverless, sin tarjeta de crédito, y conecta hoy tu primera pinza CT.

Preguntas frecuentes

¿Qué puede detectar la monitorización de corriente de motores?

Detecta de forma fiable el estado de marcha, las sobrecargas, una frecuencia de arranques anómala, la deriva de la carga y el desequilibrio de fases. Detectar defectos en las barras del rotor o en los rodamientos a partir de la corriente requiere muestreo de alta velocidad y análisis espectral.

¿Es seguro instalar una pinza CT en un motor en marcha?

La pinza es no invasiva, pero se instala en un tablero con partes energizadas. Debe instalarla un electricista cualificado con el tablero desenergizado.

¿Con qué frecuencia debo publicar las lecturas de corriente del motor?

Una vez por segundo es un buen valor por defecto para detectar el estado y las sobrecargas. Frecuencias más lentas, como cada 10 segundos, sirven para un simple seguimiento de tendencias.

¿Por qué mi lectura muestra corriente cuando el motor está apagado?

Es el ruido de fondo del ADC. Suprime en el firmware los valores por debajo de un pequeño umbral y mantén el cableado del sensor alejado de los cables de potencia.