Sensor zur Schwingungsüberwachung: MQTT-Schwingungsmonitor für Predictive Maintenance bauen

Ein Sensor zur Schwingungsüberwachung ist das günstigste Frühwarnsystem, das Sie an einer rotierenden Maschine anbringen können. In diesem Tutorial bauen Sie einen aus einem ESP32 und einem Beschleunigungssensor, berechnen RMS, Spitzenwert und Crest-Faktor auf dem Gerät, publizieren die Ergebnisse über MQTT und lösen Alarme aus, wenn die Schwingung über eine gelernte Referenz steigt.

Warum Schwingung das erste Signal ist, das sich zu messen lohnt

Fast jeder mechanische Fehler an rotierenden Anlagen verändert zuerst das Schwingungsverhalten der Maschine, bevor sich irgendetwas anderes ändert. Unwucht, Fluchtungsfehler, lose Befestigungsschrauben, verschlissene Lager und Kavitation bringen Energie bei charakteristischen Frequenzen ein – lange bevor ein Motor auslöst oder ein Lager festgeht. Die Temperatur steigt meist später, und wenn ein Techniker das Geräusch hört, ist der Schaden oft schon weit fortgeschritten.

Deshalb steht die Schwingung im Zentrum der meisten Predictive-Maintenance-Programme. Der Überblick Predictive Maintenance mit IoT erklärt die Gesamtstrategie; dieser Artikel konzentriert sich auf den praktischen Teil: einen verlässlichen Schwingungswert von der Maschine in ein System zu bringen, das darauf reagieren kann.

Einen Spektrumanalysator brauchen Sie am ersten Tag nicht. Wer zwei oder drei einfache Kennwerte pro Maschine jede Sekunde oder jede Minute als Trend verfolgt, erkennt einen großen Teil der sich entwickelnden Fehler. Entscheidend ist Konsistenz: gleiche Messstelle, gleiche Achse, gleiche Berechnung und eine Historie zum Vergleich.

Den passenden Sensor zur Schwingungsüberwachung wählen

Das Spektrum reicht von MEMS-Hobbyboards bis zu industriellen piezoelektrischen Beschleunigungsaufnehmern. Die richtige Wahl hängt davon ab, was Sie erkennen wollen.

Für dieses Tutorial verwenden wir einen MPU6050, weil er sehr wenig kostet und alle nötigen Konzepte vermittelt. Dieselbe Firmware-Struktur gilt, wenn Sie einen besseren Beschleunigungssensor einsetzen: ein Fenster abtasten, den Gleichanteil entfernen, Merkmale berechnen, publizieren.

Die Montage ist wichtiger als der Chip

Ein auf ein dünnes Schutzblech geklebter Sensor misst das Schutzblech. Montieren Sie das Board so nah wie möglich am Lagergehäuse, auf einer steifen Fläche, mit einem Gewindebolzen, einem starken Magneten oder Industrie-Epoxidharz. Notieren Sie, welche Achse radial und welche axial zeigt, und versetzen Sie den Sensor nie, nachdem Sie eine Referenz erfasst haben – eine neue Messstelle bedeutet eine neue Referenz.

Hardware und Verdrahtung

Sie benötigen:

1. Ein ESP32-Entwicklungsboard.
2. Ein MPU6050-Breakout (GY-521 oder ähnlich).
3. Vier Jumper-Kabel und ein USB-Kabel.

Verbinden Sie VCC mit 3,3 V, GND mit GND, SDA mit GPIO 21 und SCL mit GPIO 22. Das sind die Standard-I2C-Pins der meisten ESP32-DevKit-Boards, wie in der ESP32-I2C-Referenz dokumentiert.

Was der Sensor berechnet

Rohe Beschleunigungswerte mit 800 Abtastungen pro Sekunde würden 2.400 Zahlen pro Sekunde und Maschine bedeuten. Das über MQTT zu senden ist möglich, für Trends aber selten sinnvoll. Stattdessen reduziert der ESP32 jedes Ein-Sekunden-Fenster auf wenige Merkmale:

• RMS (Effektivwert): die Gesamtenergie der Schwingung. Der mit Abstand nützlichste Trendwert.
• Spitzenwert (Peak): die größte absolute Abweichung vom Mittelwert im Fenster. Empfindlich für Stöße.
• Crest-Faktor: Spitzenwert geteilt durch RMS. Ein steigender Crest-Faktor bei stabilem RMS ist ein klassisches Frühzeichen für Lagerschäden, weil kurze Stöße den Spitzenwert erhöhen, ohne viel Energie hinzuzufügen.

Vor der Berechnung zieht die Firmware den Mittelwert jeder Achse ab. Das entfernt Erdbeschleunigung und Sensor-Offset, sodass eine stillstehende Maschine nahe null anzeigt.

Firmware: ESP32-Sensor zur Schwingungsüberwachung

Der folgende Sketch liest die MPU6050-Register direkt mit Wire aus und kommt daher ohne zusätzliche Sensorbibliothek aus. Installieren Sie PubSubClient über den Arduino Library Manager. Ersetzen Sie das zufällige Suffix 7f3a91 durch Ihr eigenes, damit Ihre Topics auf dem öffentlichen Broker nicht mit denen anderer kollidieren.

#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;               // Ein-Sekunden-Fenster
const uint32_t PERIOD_US = 1000000UL / SAMPLE_HZ;
const float LSB_PER_G = 4096.0f;       // Messbereich +/-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);  // aufwecken
  mpuWrite(0x1A, 0x01);  // DLPF ~184 Hz Beschleunigungsbandbreite
  mpuWrite(0x1C, 0x10);  // Messbereich +/-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);
}

Öffnen Sie ein Terminal und beobachten Sie, wie die Werte eintreffen:

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

Klopfen Sie neben dem Sensor auf den Tisch, und Sie sehen Spitzenwert und Crest-Faktor springen, während sich der RMS-Wert kaum bewegt. Setzen Sie den Sensor auf einen laufenden Lüfter, pendelt sich der RMS-Wert in einem stabilen Band ein. Dieses stabile Band ist Ihre Referenz.

Aus Messwerten Alarme machen

Ein fester Grenzwert aus einem Datenblatt ist ein schlechter Ausgangspunkt, denn jede Maschine hat ihren eigenen Normalzustand. Besser ist es, die Referenz für jede Anlage zu lernen und bei einem Vielfachen davon zu alarmieren. Der folgende Python-Subscriber macht genau das mit paho-mqtt 2.x. Er sammelt die ersten 300 Messwerte als Referenz und publiziert dann eine Warnung oder einen Alarm, wenn der RMS-Wert über mehrere aufeinanderfolgende Fenster das 2- oder 3-Fache dieser Referenz überschreitet.

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 = {}  # pro Anlage: samples, baseline, streak, level

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()

Drei Details machen das in der Praxis robust. Die Median-Referenz ignoriert gelegentliche Stöße während der Lernphase. Die Bedingung mehrerer aufeinanderfolgender Fenster verhindert, dass ein heruntergefallenes Werkzeug oder ein vorbeifahrender Gabelstapler jemanden alarmiert. Und der Alarm wird als Retained Message publiziert, sodass ein später verbundenes Dashboard sofort den aktuellen Alarmzustand jeder Anlage sieht.

Wenn Sie für einfache Grenzwerte keinen Code betreiben möchten: Das ConnectMQ-Portal enthält Schwellwert-Alarmregeln und ein Alarmprotokoll. Sie können eine Regel auf das RMS-Feld Ihres Schwingungs-Topics richten und jede Überschreitung im Portal sehen und den Python-Dienst für die referenzbasierte Logik behalten.

Von der Demo zur Produktion

Der öffentliche MQTT-Broker ist ideal für dieses Experiment, doch alles darauf ist für jeden lesbar, und er begrenzt Clients auf 10 Nachrichten pro Sekunde. Er ist für Tests gedacht; für echte Maschinen wechseln Sie zu einem privaten Broker:

1. Registrieren Sie sich im ConnectMQ-Portal und legen Sie einen Broker an. Sie erhalten einen generierten Benutzernamen, ein Passwort und eine Client ID.
2. Stellen Sie den ESP32 auf WiFiClientSecure an Port 8883 um und übergeben Sie die Zugangsdaten an mqtt.connect(CLIENT_ID, USER, PASS).
3. Übernehmen Sie einen Topic-Baum im ISA-95-Stil wie acme/plant1/assembly/line1/pump1/vibration, den das Portal erkennt und in seiner Geräteansicht gruppiert. Diese Hierarchie bildet den Unified Namespace (UNS), in dem Schwingungsdaten neben allen anderen Werksdaten liegen.
4. Betreiben Sie den Alarmdienst unter einem Prozessmanager, damit er automatisch neu startet.

Ein verwalteter MQTT-Broker nimmt Ihnen Patchen, Zertifikate und Kapazitätsplanung ab – wichtig, sobald Dutzende Sensoren jede Sekunde publizieren.

Checkliste zur Fehlersuche

1. Alle Messwerte sind null: Prüfen Sie die I2C-Adresse mit einem Scanner-Sketch. Manche Boards nutzen 0x69, wenn AD0 auf High liegt.
2. RMS ist bei ausgeschalteter Maschine zu hoch: elektrische Störungen oder eine lose Befestigung. Setzen Sie den Sensor neu und führen Sie das Kabel fern von Motorleistungsleitungen.
3. MQTT trennt alle paar Sekunden: Ein anderer Client nutzt dieselbe Client ID. Machen Sie sie eindeutig.
4. Werte scheinen gedeckelt: Der Sensor übersteuert. Erhöhen Sie den Messbereich von 8 g auf 16 g (0x18 in Register 0x1C und 2048 LSB pro g).
5. Hochfrequente Fehler werden übersehen: Die Bandbreite des MPU6050 ist begrenzt. Verwenden Sie für Lager und Getriebe einen industriellen Beschleunigungsaufnehmer.

Wie es weitergeht

Sobald RMS und Crest-Faktor zuverlässig fließen, ergänzen Sie ein zweites Signal. Die Kombination von Schwingung mit Motorstromüberwachung oder Lagertemperaturüberwachung trennt elektrische von mechanischen Problemen und bestätigt Alarme aus zwei unabhängigen Quellen. Wenn Sie die Daten werksweit in Kontext setzen möchten, zeigt der Smart-Manufacturing-Leitfaden, wie sich Schwingung in das größere Daten-Rückgrat einfügt.

Starten Sie die Schwingungsüberwachung mit ConnectMQ

ConnectMQ gibt jedem Sensor einen sicheren, privaten MQTT-Endpunkt mit TLS, einem Client im Browser, einem Live-Topic-Explorer und integrierten Schwellwertalarmen. Legen Sie im kostenlosen Serverless-Plan unter app.connectmq.com einen Broker an, ohne Kreditkarte, und bringen Sie Ihren Schwingungsmonitor in wenigen Minuten vom Demo-Topic in die Produktion.

Häufig gestellte Fragen

Welcher Sensor zur Schwingungsüberwachung eignet sich für ein Einsteigerprojekt?

Ein MEMS-Beschleunigungssensor wie der MPU6050 oder ADXL345 an einem ESP32 ist der einfachste Einstieg. Er ist günstig, nutzt I2C und reicht aus, um die Gesamtschwingung an Lüftern, Pumpen und Förderbändern als Trend zu verfolgen.

Sollte ich rohe Schwingungsverläufe über MQTT senden?

Für die Dauerüberwachung meist nicht. Senden Sie jede Sekunde zusammenfassende Merkmale wie RMS, Spitzenwert und Crest-Faktor und erfassen Sie kurze Rohdaten-Bursts nur, wenn Sie eine Spektralanalyse benötigen.

Wie lege ich Alarmgrenzen für Schwingungen fest?

Lernen Sie für jede Maschine eine Referenz im Normalbetrieb und alarmieren Sie bei Vielfachen davon. Verlangen Sie mehrere aufeinanderfolgende Fenster über der Grenze, um Fehlalarme zu vermeiden.

Kann ich broker.connectmq.com für echte Maschinen verwenden?

Nutzen Sie den öffentlichen MQTT-Broker nur für Tests, denn seine Topics sind für jeden lesbar. Für die Produktion legen Sie im ConnectMQ-Portal einen privaten Broker mit eigenen Zugangsdaten an.