Surveillance du courant moteur avec pinces ampèremétriques et MQTT pour détecter les défauts tôt

La surveillance du courant moteur transforme le câble d'alimentation de n'importe quel moteur électrique en capteur de santé, sans toucher à la machine elle-même. Dans ce tutoriel, vous allez placer une pince ampèremétrique (CT) non intrusive autour d'un conducteur moteur, mesurer le courant RMS avec un ESP32, le publier en MQTT et exécuter un service Python qui signale les surcharges, les démarrages excessifs et les profils de charge anormaux.

Pourquoi le courant moteur est un signal si utile

Le courant indique l'effort fourni par un moteur. Comme la pince entoure le câble dans l'armoire électrique, vous pouvez l'installer en rétrofit sur de vieilles machines dépourvues de toute interface de données, et vous n'avez jamais besoin de monter quoi que ce soit sur des pièces en rotation.

À partir d'une seule mesure de courant par seconde, on peut déduire une quantité surprenante d'informations :

• État de marche : arrêt, ralenti (moteur qui tourne sans charge) ou en charge. C'est souvent le moyen le moins coûteux d'alimenter le suivi des arrêts machines.
• Surcharge : courant supérieur à l'intensité nominale de la plaque signalétique pendant plus longtemps qu'une courte phase de démarrage.
• Dérive de charge : un convoyeur qui consomme progressivement plus de courant peut avoir un roulement qui frotte, une courroie désalignée ou une accumulation de produit. Une pompe qui consomme moins peut tourner à sec ou caviter.
• Fréquence de démarrage : trop de démarrages par heure font chauffer les enroulements, et une hausse soudaine révèle souvent un problème de commande.
• Déséquilibre de phases : avec une pince par phase, des courants inégaux indiquent des problèmes d'alimentation ou des défauts d'enroulement.

Des techniques plus avancées, comme l'analyse de la signature du courant moteur, examinent le spectre fréquentiel du courant pour détecter des barres de rotor cassées et des défauts de roulements. Elles nécessitent un échantillonnage bien plus rapide et du matériel dédié. Tout ce qui est décrit dans cet article fonctionne avec quelques valeurs RMS par seconde et détecte pourtant les problèmes d'exploitation les plus courants.

La sécurité avant tout

Une pince CT est non intrusive : elle entoure un seul conducteur isolé et n'établit jamais de contact électrique. Malgré tout, la pince est installée dans une armoire contenant des pièces sous tension. Faites-la installer par un électricien qualifié, armoire consignée, autour d'un seul conducteur de phase (jamais autour du câble multiconducteur complet, où les champs s'annulent), et séparez le câblage basse tension du capteur du câblage de puissance.

Matériel

Choisissez une pince dont le calibre est juste au-dessus du courant à pleine charge du moteur pour obtenir la meilleure résolution. Une pince de 30 A sur un moteur de 3 A fonctionnera, mais le signal sera faible et bruité.

Câblage

La pince délivre une tension alternative centrée sur zéro, alors que l'ADC de l'ESP32 ne lit que des tensions positives. Polarisez-la au milieu de la plage :

1. Reliez les deux résistances de 10 kOhm en série entre 3,3 V et GND.
2. Reliez le condensateur de 10 uF entre le point milieu et GND.
3. Reliez un fil de la pince au point milieu et l'autre à GPIO 34.

GPIO 34 appartient à l'ADC1, qui continue de fonctionner quand le Wi-Fi est actif. Le guide capteur de courant SCT-013 avec ESP32 détaille l'étalonnage et les variantes de câblage.

Firmware : surveillance du courant moteur sur l'ESP32

Le sketch échantillonne l'ADC 2 000 fois en 200 ms, ce qui couvre dix périodes secteur à 50 Hz et douze à 60 Hz. Il supprime la composante continue en soustrayant la moyenne, calcule la tension RMS et la convertit en ampères. Chaque seconde, il publie le courant et un état simple.

#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;            // à ajuster après comparaison avec une pince multimètre
const int SAMPLES = 2000;
const uint32_t SAMPLE_US = 100;     // 10 kHz, fenêtre de 200 ms

const float IDLE_A = 0.5f;          // en dessous, le moteur est à l'arrêt
const float LOADED_A = 2.0f;        // au-dessus, le moteur est en charge

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;  // supprime le plancher de bruit
  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);
}

Étalonnez une fois avec une pince multimètre de confiance : faites tourner le moteur à charge stable, comparez les deux mesures et réglez CAL sur le rapport obtenu. Réglez ensuite IDLE_A et LOADED_A en observant la machine réelle tourner à vide et en charge.

Vérifiez le flux depuis n'importe quel terminal :

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

Ces exemples utilisent broker.connectmq.com, le serveur MQTT public gratuit de ConnectMQ, idéal pour les tests et prototypes mais pas pour des données de production.

Détecter les surcharges et les profils anormaux

L'appareil rapporte des faits bruts. L'interprétation revient à un service qui a accès à l'historique. L'abonné Python ci-dessous (paho-mqtt 2.x) met en œuvre quatre contrôles qui couvrent la plupart des besoins pratiques :

1. Surcharge : courant supérieur à la valeur nominale pendant plus qu'un délai de tolérance, ce qui ignore l'appel de courant normal au démarrage.
2. Comptage des démarrages : transitions de l'arrêt vers la marche, comptées sur une heure glissante.
3. Dérive de charge : la moyenne en charge sur les dix dernières minutes comparée à une valeur normale apprise.
4. Données périmées : aucun message pendant 30 secondes signifie que le capteur ou le réseau est hors service.

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

PREFIX = "connectmq/demo/9be2c4"
RATED_A = 8.5               # intensité à pleine charge de la plaque signalétique
OVERLOAD_GRACE_S = 10
MAX_STARTS_PER_HOUR = 6
DRIFT_LIMIT = 0.20          # écart de 20 % par rapport à la normale apprise
LEARN_SAMPLES = 1800        # 30 minutes de fonctionnement en charge

over_since = None
last_state = "off"
starts = deque()
loaded = deque(maxlen=600)  # 10 dernières minutes d'échantillons en charge
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  # nouvelle alerte au plus une fois par délai de tolérance
    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()

Pour la seule règle de surcharge, vous n'avez même pas besoin de ce service. Une règle d'alerte à seuil dans le portail ConnectMQ sur le champ current_a consignera chaque franchissement dans le journal des alertes. Gardez le service Python pour les contrôles avec état, comme la dérive et le comptage des démarrages.

Interpréter ce que vous observez

Le courant est le plus parlant lorsqu'il est combiné à d'autres signaux. Un courant en hausse accompagné de vibrations en hausse oriente vers la mécanique, tandis qu'un courant en hausse avec des vibrations normales et des valeurs croissantes de surveillance de la température des roulements affine encore la recherche. L'article maintenance prédictive avec l'IoT montre comment ces signaux se combinent dans une stratégie de maintenance.

Choisir des seuils pertinents

Partez de la plaque signalétique du moteur, pas d'estimations. L'intensité à pleine charge est la limite supérieure en fonctionnement continu : la règle de surcharge doit l'utiliser directement, avec un délai de tolérance assez long pour couvrir l'appel de courant normal au démarrage observé sur cette machine. Les démarrages directs provoquent un fort appel de courant pendant une ou deux secondes, alors que les démarreurs progressifs et les variateurs montent en régime graduellement ; le bon délai de tolérance diffère donc selon le moteur.

Pour la dérive, apprenez le courant normal en charge pendant une période où la machine est réputée saine et où le mix produit est typique. Si la ligne fabrique plusieurs produits aux charges très différentes, apprenez une valeur normale par produit ou par recette et incluez la recette active dans le payload. Sinon, chaque changement de produit ressemblera à une anomalie et les opérateurs apprendront à ignorer les alertes, ce qui va à l'encontre du but de la surveillance.

Passer en production

Le serveur public est parfait pour tester, mais ses topics sont visibles par tout le monde. Pour de vrais moteurs :

• Créez un broker privé dans le portail ConnectMQ et utilisez le nom d'utilisateur, le mot de passe et le client ID générés.
• Passez en TLS sur le port 8883 avec WiFiClientSecure.
• Utilisez des topics ISA-95 comme acme/plant1/packaging/line1/conveyor1/current pour que les équipements se regroupent naturellement dans la vue des appareils.
• Ajoutez un message Last Will pour qu'un capteur défaillant soit immédiatement signalé hors ligne.

Un broker MQTT managé maintient cette infrastructure à jour et disponible pendant que vous vous concentrez sur l'analyse. Pour voir comment la surveillance du courant s'intègre dans une architecture de données d'usine complète, lisez le guide de la fabrication intelligente.

Surveillez vos moteurs avec ConnectMQ

ConnectMQ fait tourner votre broker MQTT dans le cloud avec TLS, MQTT 5, un explorateur de topics en direct et des alertes à seuil intégrées au portail. Inscrivez-vous sur app.connectmq.com avec l'offre Serverless gratuite, sans carte bancaire, et connectez votre première pince CT dès aujourd'hui.

Questions fréquentes

Que peut détecter la surveillance du courant moteur ?

Elle détecte de manière fiable l'état de marche, les surcharges, une fréquence de démarrage anormale, la dérive de charge et le déséquilibre de phases. Détecter des défauts de barres de rotor ou de roulements à partir du courant nécessite un échantillonnage rapide et une analyse spectrale.

Une pince CT peut-elle être installée en toute sécurité sur un moteur en marche ?

La pince est non intrusive, mais elle s'installe dans une armoire contenant des pièces sous tension. Un électricien qualifié doit l'installer, armoire consignée.

À quelle fréquence publier les mesures de courant moteur ?

Une fois par seconde est un bon réglage par défaut pour la détection d'état et de surcharge. Des fréquences plus lentes, par exemple toutes les 10 secondes, conviennent au simple suivi de tendance.

Pourquoi ma mesure indique-t-elle du courant quand le moteur est à l'arrêt ?

C'est le plancher de bruit de l'ADC. Supprimez les valeurs inférieures à un petit seuil dans le firmware et éloignez le câblage du capteur des câbles de puissance.