Capteur de surveillance vibratoire : construire un moniteur de vibrations MQTT pour la maintenance prédictive

Un capteur de surveillance vibratoire est le système d'alerte précoce le moins cher que vous puissiez fixer sur une machine tournante. Dans ce tutoriel, vous allez en construire un à partir d'un ESP32 et d'un accéléromètre, calculer RMS, crête et facteur de crête sur l'appareil, publier les résultats en MQTT et déclencher des alertes lorsque les vibrations dépassent une référence apprise.

Pourquoi les vibrations sont le premier signal à mesurer

Presque tous les défauts mécaniques des équipements tournants modifient la façon dont la machine vibre avant de changer quoi que ce soit d'autre. Balourd, désalignement, boulons de fixation desserrés, roulements usés et cavitation ajoutent tous de l'énergie à des fréquences caractéristiques bien avant qu'un moteur ne disjoncte ou qu'un roulement ne se grippe. La température monte généralement plus tard et, lorsqu'un technicien entend le bruit, les dégâts sont souvent déjà bien avancés.

C'est pourquoi les vibrations sont au cœur de la plupart des programmes de maintenance prédictive. La présentation de la maintenance prédictive avec l'IoT explique la stratégie complète ; cet article se concentre sur la partie pratique : obtenir une valeur de vibration fiable sur une machine et l'acheminer vers un système capable d'agir.

Vous n'avez pas besoin d'un analyseur de spectre dès le premier jour. Suivre la tendance de deux ou trois statistiques simples par machine, chaque seconde ou chaque minute, permet de détecter une large part des défauts en développement. La clé est la constance : même point de fixation, même axe, même calcul, et un historique de comparaison.

Choisir un capteur de surveillance vibratoire

Les capteurs vont des cartes MEMS pour amateurs aux accéléromètres piézoélectriques industriels. Le bon choix dépend de ce que vous voulez détecter.

Pour ce tutoriel, nous utilisons un MPU6050 car il coûte très peu et permet d'apprendre tous les concepts nécessaires. La même structure de firmware s'applique lorsque vous passez à un meilleur accéléromètre : échantillonner une fenêtre, retirer la composante continue, calculer les caractéristiques, publier.

La fixation compte plus que la puce

Un capteur collé sur une fine tôle de protection mesure la tôle de protection. Fixez la carte aussi près que possible du palier, sur une surface rigide, avec un goujon, un aimant puissant ou une colle époxy industrielle. Notez quel axe est radial et lequel est axial, et ne déplacez jamais le capteur après avoir établi une référence, car un nouvel emplacement implique une nouvelle référence.

Matériel et câblage

Il vous faut :

1. Une carte de développement ESP32.
2. Un module MPU6050 (GY-521 ou équivalent).
3. Quatre fils de liaison et un câble USB.

Reliez VCC au 3,3 V, GND à GND, SDA au GPIO 21 et SCL au GPIO 22. Ce sont les broches I2C par défaut de la plupart des cartes ESP32 DevKit, comme l'indique la référence I2C de l'ESP32.

Ce que calcule le capteur

Une accélération brute à 800 échantillons par seconde représenterait 2 400 valeurs par seconde et par machine. Les envoyer en MQTT est possible, mais rarement utile pour un suivi de tendance. L'ESP32 réduit donc chaque fenêtre d'une seconde à quelques caractéristiques :

• RMS (valeur efficace) : l'énergie globale de la vibration. La valeur de tendance la plus utile.
• Crête : le plus grand écart absolu par rapport à la moyenne dans la fenêtre. Sensible aux chocs.
• Facteur de crête : crête divisée par RMS. Un facteur de crête qui augmente alors que le RMS reste stable est un signe précoce classique de défaut de roulement, car les chocs brefs font monter la crête sans ajouter beaucoup d'énergie.

Avant ces calculs, le firmware soustrait la moyenne de chaque axe. Cela supprime la gravité et l'offset du capteur, de sorte qu'une machine à l'arrêt affiche une valeur proche de zéro.

Firmware : capteur de surveillance vibratoire sur ESP32

Le sketch ci-dessous lit directement les registres du MPU6050 avec Wire : il ne dépend d'aucune bibliothèque de capteur supplémentaire. Installez PubSubClient depuis le gestionnaire de bibliothèques Arduino. Remplacez le suffixe aléatoire 7f3a91 par le vôtre pour que vos topics n'entrent pas en collision avec ceux d'autres utilisateurs du serveur public.

#include <WiFi.h>
#include <Wire.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 uint16_t MQTT_PORT = 1883;
const char* CLIENT_ID = "vib-sensor-7f3a91";
const char* TOPIC = "connectmq/demo/7f3a91/line1/pump1/vibration";

const uint8_t MPU_ADDR = 0x68;
const int SAMPLE_HZ = 800;
const int N = SAMPLE_HZ;               // fenêtre d'une seconde
const uint32_t PERIOD_US = 1000000UL / SAMPLE_HZ;
const float LSB_PER_G = 4096.0f;       // plage +/-8 g

WiFiClient net;
PubSubClient mqtt(net);
float bufX[N], bufY[N], bufZ[N];

void mpuWrite(uint8_t reg, uint8_t val) {
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(reg);
  Wire.write(val);
  Wire.endTransmission();
}

bool readAccel(float &x, float &y, float &z) {
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x3B);
  if (Wire.endTransmission(false) != 0) return false;
  if (Wire.requestFrom(MPU_ADDR, (uint8_t)6) != 6) return false;
  int16_t rx = (Wire.read() << 8) | Wire.read();
  int16_t ry = (Wire.read() << 8) | Wire.read();
  int16_t rz = (Wire.read() << 8) | Wire.read();
  x = rx / LSB_PER_G;
  y = ry / LSB_PER_G;
  z = rz / LSB_PER_G;
  return true;
}

void stats(const float* b, float &rms, float &peak) {
  double mean = 0;
  for (int i = 0; i < N; i++) mean += b[i];
  mean /= N;
  double sumSq = 0;
  peak = 0;
  for (int i = 0; i < N; i++) {
    double d = b[i] - mean;
    sumSq += d * d;
    if (fabs(d) > peak) peak = fabs(d);
  }
  rms = sqrt(sumSq / N);
}

void connectWifi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) delay(250);
}

void connectMqtt() {
  while (!mqtt.connected()) {
    if (!mqtt.connect(CLIENT_ID)) delay(2000);
  }
}

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  Wire.setClock(400000);
  mpuWrite(0x6B, 0x00);  // réveil
  mpuWrite(0x1A, 0x01);  // DLPF, bande passante accéléromètre ~184 Hz
  mpuWrite(0x1C, 0x10);  // pleine échelle +/-8 g
  connectWifi();
  mqtt.setServer(MQTT_HOST, MQTT_PORT);
  mqtt.setBufferSize(512);
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) connectWifi();
  if (!mqtt.connected()) connectMqtt();
  mqtt.loop();

  uint32_t next = micros();
  for (int i = 0; i < N; i++) {
    while ((int32_t)(micros() - next) < 0) { }
    next += PERIOD_US;
    if (!readAccel(bufX[i], bufY[i], bufZ[i])) {
      bufX[i] = bufY[i] = bufZ[i] = 0;
    }
  }

  float rx, px, ry, py, rz, pz;
  stats(bufX, rx, px);
  stats(bufY, ry, py);
  stats(bufZ, rz, pz);
  float rmsMax = fmaxf(rx, fmaxf(ry, rz));
  float peakMax = fmaxf(px, fmaxf(py, pz));
  float crest = rmsMax > 0.0001f ? peakMax / rmsMax : 0;

  char payload[256];
  snprintf(payload, sizeof(payload),
    "{\"rms_g\":{\"x\":%.4f,\"y\":%.4f,\"z\":%.4f},"
    "\"peak_g\":%.4f,\"crest\":%.2f,\"fs\":%d,\"n\":%d}",
    rx, ry, rz, peakMax, crest, SAMPLE_HZ, N);

  mqtt.publish(TOPIC, payload);
  Serial.println(payload);
}

Ouvrez un terminal et regardez les valeurs arriver :

mosquitto_sub -h broker.connectmq.com -p 1883 -i viewer-7f3a91 -t "connectmq/demo/7f3a91/#" -v

Tapotez la table à côté du capteur : la crête et le facteur de crête bondissent alors que le RMS bouge à peine. Posez le capteur sur un ventilateur en marche et le RMS se stabilise dans une bande régulière. Cette bande régulière est votre référence.

Transformer les mesures en alertes

Un seuil fixe copié d'une fiche technique est un mauvais point de départ, car chaque machine a sa propre normalité. Une meilleure approche consiste à apprendre la référence de chaque équipement et à alerter sur un multiple de celle-ci. L'abonné Python ci-dessous fait exactement cela avec paho-mqtt 2.x. Il collecte les 300 premières mesures comme référence, puis publie un avertissement ou une alarme lorsque le RMS dépasse 2 ou 3 fois cette référence pendant plusieurs fenêtres consécutives.

import json
import statistics
import paho.mqtt.client as mqtt

BROKER = "broker.connectmq.com"
PREFIX = "connectmq/demo/7f3a91"
BASELINE_SAMPLES = 300
WARN_FACTOR, ALARM_FACTOR = 2.0, 3.0
CONSECUTIVE = 5

state = {}  # par équipement : échantillons, référence, série, niveau

def on_connect(client, userdata, flags, reason_code, properties):
    print("connected:", reason_code)
    client.subscribe(f"{PREFIX}/+/+/vibration", qos=1)

def on_message(client, userdata, msg):
    data = json.loads(msg.payload)
    rms = max(data["rms_g"].values())
    asset = "/".join(msg.topic.split("/")[3:5])
    s = state.setdefault(asset, {"samples": [], "baseline": None, "streak": 0, "level": "ok"})

    if s["baseline"] is None:
        s["samples"].append(rms)
        if len(s["samples"]) >= BASELINE_SAMPLES:
            s["baseline"] = statistics.median(s["samples"])
            print(f"{asset} baseline RMS = {s['baseline']:.4f} g")
        return

    ratio = rms / s["baseline"]
    level = "alarm" if ratio >= ALARM_FACTOR else "warning" if ratio >= WARN_FACTOR else "ok"
    s["streak"] = s["streak"] + 1 if level != "ok" else 0

    if level != s["level"] and (level == "ok" or s["streak"] >= CONSECUTIVE):
        s["level"] = level
        alert = {"asset": asset, "level": level, "rms_g": round(rms, 4),
                 "baseline_g": round(s["baseline"], 4), "ratio": round(ratio, 2)}
        client.publish(f"{PREFIX}/{asset}/alert", json.dumps(alert), qos=1, retain=True)
        print("ALERT", alert)

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="vib-alerts-7f3a91")
client.on_connect = on_connect
client.on_message = on_message
client.connect(BROKER, 1883, keepalive=60)
client.loop_forever()

Trois détails rendent ce service robuste en pratique. La référence par médiane ignore les chocs occasionnels pendant l'apprentissage. L'exigence de fenêtres consécutives évite qu'un outil tombé ou le passage d'un chariot élévateur ne déclenche un appel d'astreinte. Et l'alerte est publiée en retained message, de sorte qu'un tableau de bord qui se connecte plus tard voit immédiatement l'état d'alarme courant de chaque équipement.

Si vous préférez ne pas exécuter de code pour des seuils simples, le portail ConnectMQ comprend des règles d'alerte à seuil et un journal des alertes. Vous pouvez appliquer une règle au champ RMS de votre topic de vibration et voir chaque dépassement dans le portail, tout en conservant le service Python pour la logique relative à la référence.

Passer de la démo à la production

Le serveur MQTT public gratuit est parfait pour cette expérience, mais tout ce qui y circule est lisible par n'importe qui, et il limite les clients à 10 messages par seconde. Pour de vraies machines, passez à un broker privé :

1. Inscrivez-vous sur le portail ConnectMQ et créez un broker. Vous recevez un nom d'utilisateur, un mot de passe et un client ID générés.
2. Passez l'ESP32 à WiFiClientSecure sur le port 8883 et transmettez les identifiants à mqtt.connect(CLIENT_ID, USER, PASS).
3. Adoptez une arborescence de topics de type ISA-95, comme acme/plant1/assembly/line1/pump1/vibration, que le portail reconnaît et regroupe dans sa vue des appareils.
4. Exécutez le service d'alerte sous un gestionnaire de processus pour qu'il redémarre automatiquement.

Un broker MQTT managé vous épargne les correctifs, les certificats et la planification de capacité, ce qui compte dès que des dizaines de capteurs publient chaque seconde.

Checklist de dépannage

1. Toutes les mesures sont à zéro : vérifiez l'adresse I2C avec un sketch de scan. Certaines cartes utilisent 0x69 lorsque AD0 est à l'état haut.
2. Le RMS semble trop élevé machine arrêtée : bruit électrique ou fixation desserrée. Refixez le capteur et éloignez le câble des conducteurs de puissance du moteur.
3. MQTT se déconnecte toutes les quelques secondes : un autre client utilise le même client ID. Rendez-le unique.
4. Les valeurs semblent plafonnées : il y a saturation. Passez la pleine échelle de 8 g à 16 g (0x18 dans le registre 0x1C, et 2048 LSB par g).
5. Les défauts haute fréquence passent inaperçus : la bande passante du MPU6050 est limitée. Utilisez un accéléromètre industriel pour les roulements et les réducteurs.

Pour aller plus loin

Une fois que le RMS et le facteur de crête remontent de façon fiable, ajoutez un second signal. Combiner les vibrations avec la surveillance du courant moteur ou la surveillance de la température des roulements permet de distinguer les problèmes électriques des problèmes mécaniques et de confirmer les alarmes par deux sources indépendantes. Lorsque vous serez prêt à replacer les données dans le contexte de toute l'usine, le guide de l'usine intelligente montre comment les vibrations s'intègrent dans la colonne vertébrale de données globale.

Commencez la surveillance vibratoire sur ConnectMQ

ConnectMQ donne à chaque capteur un endpoint MQTT privé et sécurisé avec TLS, un client dans le navigateur, un explorateur de topics en direct et des alertes à seuil intégrées. Créez un broker sur l'offre Serverless gratuite sur app.connectmq.com, sans carte bancaire, et faites passer votre moniteur de vibrations du topic de démo à la production en quelques minutes.

Questions fréquentes

Quel est le meilleur capteur de surveillance vibratoire pour un projet débutant ?

Un accéléromètre MEMS comme le MPU6050 ou l'ADXL345 sur un ESP32 est le point de départ le plus simple. Il est bon marché, utilise l'I2C et suffit pour suivre la tendance des vibrations globales sur des ventilateurs, des pompes et des convoyeurs.

Faut-il envoyer les formes d'onde brutes des vibrations en MQTT ?

En général non pour une surveillance continue. Envoyez chaque seconde des caractéristiques de synthèse comme le RMS, la crête et le facteur de crête, et ne capturez de courtes salves brutes que lorsque vous avez besoin d'une analyse spectrale.

Comment définir les seuils d'alarme vibratoire ?

Apprenez une référence pour chaque machine pendant son fonctionnement normal, puis alertez sur des multiples de cette référence. Exigez plusieurs fenêtres consécutives au-dessus de la limite pour éviter les fausses alarmes.

Puis-je utiliser broker.connectmq.com pour de vraies machines ?

Utilisez le serveur public uniquement pour les tests, car ses topics sont lisibles par tout le monde. Pour la production, créez un broker privé avec vos propres identifiants dans le portail ConnectMQ.