Sensorfusion erklärt für IoT-Entwickler

Sensorfusion ist die Technik, Messwerte mehrerer Sensoren so zu kombinieren, dass das Ergebnis genauer, stabiler oder vollständiger ist, als es ein einzelner Sensor liefern könnte. Für IoT-Entwickler macht sie oft den Unterschied zwischen einem zappeligen, driftenden Signal und einem, dem man in einem Dashboard oder Modell vertrauen kann. Dieser Artikel erklärt die wichtigsten Fusionsansätze verständlich, zeigt, wann die Fusion an der Edge und wann in der Cloud stattfinden sollte, und liefert funktionierenden ESP32- und Python-Code, der fusionierte Werte per MQTT veröffentlicht.

Warum überhaupt Sensoren kombinieren

Jeder Sensor hat Schwächen. Ein Beschleunigungssensor misst die Neigung gut, solange das Gerät ruht, wird aber durch jede Vibration gestört. Ein Gyroskop misst Drehungen gleichmäßig, doch sein integrierter Winkel driftet mit der Zeit. GPS liefert eine absolute Position, aktualisiert aber langsam und springt unter Bäumen hin und her; die Radodometrie ist gleichmäßig, sammelt jedoch Fehler an. Zwei günstige Temperaturfühler im selben Tank weichen leicht voneinander ab, und jeder hat gelegentlich Ausreißer. In der Prozessindustrie ist genau das der Alltag: Ein PT100 im Reaktor und ein günstigerer Zusatzfühler liefern gemeinsam einen belastbareren Wert als jeder für sich.

Die Fusion nutzt die Tatsache, dass diese Schwächen unterschiedlich sind. Ist ein Sensor bei hohen Frequenzen verrauscht und driftet ein anderer bei niedrigen Frequenzen, ergibt ihre Kombination ein Signal, das überall gut ist. Messen zwei Sensoren dieselbe Größe mit unabhängigem Rauschen, ist eine gewichtete Kombination präziser als jeder für sich. Und fällt ein Sensor aus, kann eine fusionierte Schätzung die Inkonsistenz erkennen, statt stillschweigend einen falschen Wert zu melden.

Drei Ebenen der Sensorfusion

Dieser Artikel konzentriert sich auf die Fusion auf niedriger Ebene, denn dort sind Filter wie Komplementär- und Kalman-Filter angesiedelt. Die Fusion auf Merkmalsebene ist der alltägliche Input von Machine-Learning-Modellen, etwa beim Machine Learning für Predictive Maintenance, wo Schwingung, Temperatur und Strom gemeinsam eine Verschlechterung offenlegen, die keine Größe allein deutlich zeigt.

Der Komplementärfilter

Der Komplementärfilter ist die einfachste brauchbare Fusionsmethode und ein guter Einstieg für Inertialsensoren. Um einen Neigungswinkel zu schätzen, integriert er die Drehrate des Gyroskops für kurzfristige Änderungen und zieht das Ergebnis sanft in Richtung des Beschleunigungswinkels, um langfristige Drift zu beseitigen:

angle = alpha * (angle + gyro_rate * dt) + (1 - alpha) * accel_angle

Mit alpha um 0,98 und einer Abtastperiode von 10 ms dominiert das Gyroskop über Sekundenbruchteile und der Beschleunigungssensor über einige Sekunden. Der Filter braucht keine Matrizen, läuft auf einem Mikrocontroller in Mikrosekunden und lässt sich leicht abstimmen: Erhöhen Sie alpha, wenn die Ausgabe verrauscht ist, und verringern Sie den Wert, wenn sie driftet.

Der Kalman-Filter

Der Kalman-Filter verallgemeinert dieselbe Idee. Er führt eine Schätzung des Zustands und seiner eigenen Unsicherheit, sagt vorher, wie sich der Zustand ändern wird, und korrigiert die Vorhersage dann mit jeder Messung. Die Korrektur wird danach gewichtet, wie sehr er der Messung im Vergleich zur Vorhersage vertraut. Ist die Messung verrauscht, stützt sich der Filter auf die Vorhersage; ist die Vorhersage unsicher, stützt er sich auf die Messung.

Für eine einzelne Größe mit zwei Sensoren ist das Kalman-Update kurz genug, um es vollständig zu lesen:

import json
import random
import time
import uuid

import paho.mqtt.client as mqtt


class Kalman1D:
    def __init__(self, x0, p0=1.0, q=0.001):
        self.x, self.p, self.q = x0, p0, q   # Schätzung, ihre Varianz, Prozessrauschen

    def predict(self):
        self.p += self.q

    def update(self, z, r):
        k = self.p / (self.p + r)            # Kalman-Verstärkung
        self.x += k * (z - self.x)
        self.p *= (1 - k)
        return self.x


BASE = f"connectmq/demo/{uuid.uuid4().hex[:8]}/tank1"
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="fusion-" + uuid.uuid4().hex[:8])
client.connect("broker.connectmq.com", 1883, keepalive=60)
client.loop_start()

kf = Kalman1D(x0=20.0)
true_temp = 20.0
R_PT100, R_NTC = 0.05 ** 2, 0.4 ** 2       # Messvarianzen aus Datenblättern oder Tests

for _ in range(300):
    true_temp += random.gauss(0, 0.02)
    pt100 = true_temp + random.gauss(0, 0.05)
    ntc = true_temp + random.gauss(0, 0.4) + (5 if random.random() < 0.02 else 0)  # gelegentlicher Ausreißer
    kf.predict()
    if abs(ntc - kf.x) < 3 * (R_NTC + kf.p) ** 0.5:  # unplausible Messwerte aussortieren
        kf.update(ntc, R_NTC)
    fused = kf.update(pt100, R_PT100)
    payload = {"ts": int(time.time() * 1000), "value": round(fused, 3), "variance": round(kf.p, 6),
               "raw": {"pt100": round(pt100, 3), "ntc": round(ntc, 3)}}
    client.publish(f"{BASE}/temperature/fused", json.dumps(payload))
    time.sleep(1)

client.loop_stop()
client.disconnect()

Installieren Sie mit pip install paho-mqtt und abonnieren Sie mit mosquitto_sub -h broker.connectmq.com -p 1883 -i fusion-watch-$RANDOM -t "connectmq/demo/+/tank1/#" -v, um den fusionierten Wert neben den Rohwerten zu sehen. Beachten Sie das Gate: Messwerte, die um mehr als drei Standardabweichungen von der aktuellen Schätzung abweichen, werden übersprungen – so verwirft der Filter die NTC-Ausreißer. Wird die Varianz zusammen mit dem Wert veröffentlicht, wissen Konsumenten, wie belastbar die Schätzung ist.

Bei mehrdimensionalen Problemen wie Position und Geschwindigkeit aus GPS und einer IMU nutzt dieselbe Struktur Matrizen, und nichtlineare Systeme verwenden den Extended oder Unscented Kalman Filter. Bibliotheken wie FilterPy in Python oder die Madgwick- und Mahony-Filter für die Orientierung ersparen Ihnen die Implementierung von Hand.

Fusion an der Edge: ESP32-Beispiel

Die Inertialfusion muss nah am Sensor laufen, weil sie schnelle, gleichmäßig getaktete Abtastwerte benötigt, oft 100 Hz oder mehr. Jeden Rohwert per MQTT zu veröffentlichen, würde Bandbreite und Batterie verschwenden und Jitter verursachen. Besser ist es, auf dem Gerät zu fusionieren und das Ergebnis mit moderater Rate zu veröffentlichen.

Dieser Sketch liest auf einem ESP32 einen MPU6050 über I2C aus, führt mit 100 Hz einen Komplementärfilter aus und veröffentlicht den fusionierten Nickwinkel zweimal pro Sekunde an broker.connectmq.com. Er verwendet die Bibliotheken Adafruit MPU6050 und PubSubClient.

#include <WiFi.h>
#include <PubSubClient.h>
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>

const char* WIFI_SSID = "YOUR_WIFI";
const char* WIFI_PASS = "YOUR_WIFI_PASSWORD";
const char* BROKER = "broker.connectmq.com";
const char* TOPIC = "connectmq/demo/imu-7f3a/arm1/pitch";

WiFiClient net;
PubSubClient mqtt(net);
Adafruit_MPU6050 mpu;

float pitch = 0.0f;
const float ALPHA = 0.98f;
unsigned long lastSample = 0, lastPublish = 0;

void connectMqtt() {
  while (!mqtt.connected()) {
    String id = "esp32-imu-" + String((uint32_t)ESP.getEfuseMac(), HEX);
    if (!mqtt.connect(id.c_str())) delay(2000);
  }
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  mqtt.setServer(BROKER, 1883);
  if (!mpu.begin()) {
    Serial.println("MPU6050 not found");
    while (true) delay(1000);
  }
  mpu.setGyroRange(MPU6050_RANGE_250_DEG);
  mpu.setFilterBandwidth(MPU6050_BAND_44_HZ);
  lastSample = micros();
}

void loop() {
  if (!mqtt.connected()) connectMqtt();
  mqtt.loop();

  if (micros() - lastSample >= 10000) {           // 100 Hz
    float dt = (micros() - lastSample) / 1e6f;
    lastSample = micros();
    sensors_event_t a, g, temp;
    mpu.getEvent(&a, &g, &temp);
    float accelPitch = atan2f(-a.acceleration.x,
                              sqrtf(a.acceleration.y * a.acceleration.y + a.acceleration.z * a.acceleration.z)) * 180.0f / PI;
    float gyroRate = g.gyro.y * 180.0f / PI;     // rad/s in Grad/s
    pitch = ALPHA * (pitch + gyroRate * dt) + (1.0f - ALPHA) * accelPitch;
  }

  if (millis() - lastPublish >= 500) {            // 2 Nachrichten pro Sekunde
    lastPublish = millis();
    char payload[64];
    snprintf(payload, sizeof(payload), "{\"pitch\":%.2f,\"unit\":\"deg\"}", pitch);
    mqtt.publish(TOPIC, payload);
  }
}

Ändern Sie das Topic-Segment imu-7f3a in einen eindeutigen Wert. Für ein Produktivgerät wechseln Sie zu WiFiClientSecure auf Port 8883 mit Ihrem ConnectMQ-Benutzernamen, Passwort und Ihrer Client-ID; das ESP32-MQTT-Tutorial beschreibt die TLS-Einrichtung im Detail.

Fusion an der Edge oder in der Cloud: die Entscheidung

1. Fusionieren Sie an der Edge, wenn sich die Sensoren auf demselben Gerät befinden, die Abtastraten hoch sind, Latenz zählt (Balancieren, Stabilisierung, Sicherheit) oder Bandbreite und Batterie begrenzt sind.
2. Fusionieren Sie in der Cloud oder auf einem Server, wenn die Sensoren auf verschiedenen Geräten sitzen, die Raten niedrig sind, Sie historischen Kontext benötigen oder den Algorithmus ohne Firmware-Update ändern möchten.
3. Veröffentlichen Sie während der Entwicklung eine Zeit lang beides: Rohwerte mit reduzierter Rate und fusionierte Werte, damit Sie den Filter an der Realität überprüfen können.
4. Versehen Sie Messwerte immer an der Quelle mit Zeitstempeln, wenn Sie über Geräte hinweg fusionieren, denn die Ankunftsreihenfolge am Broker entspricht nicht der Messreihenfolge.

Das ist derselbe Zielkonflikt, den der Artikel Was ist Edge AI behandelt: Die Berechnung wandert dorthin, wo die Daten und die Latenzanforderungen sind.

Häufige Fehler bei der Sensorfusion

• Falsche Rauschparameter. Ein Kalman-Filter ist nur so gut wie das angenommene Mess- und Prozessrauschen. Messen Sie das Rauschen anhand einer Aufzeichnung im Stillstand, statt zu raten.
• Vertauschte Achsen und Einheiten. Gyroskope liefern oft rad/s; die Achsen des Beschleunigungssensors können anders montiert sein als angenommen. Prüfen Sie die Vorzeichen, indem Sie die Platine von Hand neigen.
• Ungleichmäßiges Abtast-Timing. Filter setzen ein bekanntes dt voraus. Berechnen Sie es aus Zeitstempeln, statt einen konstanten Wert anzunehmen.
• Nicht synchronisierte Quellen. Die Fusion zweier Geräte, deren Uhren um Sekunden abweichen, erzeugt Artefakte. Synchronisieren Sie per NTP und übertragen Sie Quellzeitstempel.
• Verdeckte Sensorfehler. Die Fusion kann einen ausfallenden Sensor maskieren. Veröffentlichen Sie Rohzustandsindikatoren oder Innovationswerte, damit Fehler sichtbar bleiben – das speist auch die IoT-Anomalieerkennung.

Wohin fusionierte Daten als Nächstes gehen

Fusionierte Werte sind bessere Eingaben für Dashboards, Alarme und Modelle. In einer Fabrik gehören sie in den Unified Namespace (UNS) direkt neben die Rohsignale der Maschine, mit einer Topic-Struktur nach der ISA-95-Hierarchie, etwa acme/werk-ulm/chemie/linie-2/tank-1/temperatur/fused. So sehen MES, Historian und Predictive-Maintenance-Modelle auf einen Blick, welcher Wert gefiltert und welcher roh ist. ConnectMQ dient als verwalteter MQTT-Broker, der sie von den Geräten zu den Konsumenten transportiert: Der Live-Topic-Explorer zeigt fusionierte und Roh-Topics nebeneinander, und Schwellenwert-Alarmregeln können bei einem fusionierten Wert auslösen, etwa bei einem Neigungswinkel jenseits einer sicheren Grenze. Wie Modelle und vernetzte Geräte allgemein zusammenwirken, erfahren Sie im Leitfaden zu KI und IoT.

Mit ConnectMQ starten

Testen Sie die Beispiele zuerst mit dem öffentlichen MQTT-Broker, der für Tests und Prototypen gedacht ist, nicht für Produktionsdaten, und erstellen Sie dann unter app.connectmq.com einen kostenlosen Serverless-Broker, ganz ohne Kreditkarte, um private Zugangsdaten und TLS für Ihre Geräte zu erhalten.

Häufig gestellte Fragen

Was ist Sensorfusion im IoT?

Sensorfusion kombiniert Messwerte mehrerer Sensoren zu einer Schätzung, die genauer, stabiler oder vollständiger ist als die eines einzelnen Sensors, zum Beispiel ein driftfreier Neigungswinkel aus Beschleunigungssensor und Gyroskop.

Sollte ich einen Komplementärfilter oder einen Kalman-Filter verwenden?

Beginnen Sie bei einfachen Orientierungsaufgaben auf Mikrocontrollern mit einem Komplementärfilter. Setzen Sie einen Kalman-Filter ein, wenn Sie Sensoren mit bekannten Rauscheigenschaften kombinieren, mehrere zusammenhängende Zustände schätzen oder die Unsicherheit ausweisen müssen.

Sollte die Sensorfusion auf dem Gerät oder in der Cloud laufen?

Führen Sie sie auf dem Gerät aus, wenn die Sensoren lokal und schnell sind, denn jeden Rohwert zu senden ist teuer und verursacht Jitter. Führen Sie sie zentral aus, wenn die Sensoren auf verschiedenen Geräten sitzen oder die Aktualisierungsrate niedrig ist.

Kann ich weiterhin auf Rohdaten zugreifen, wenn ich an der Edge fusioniere?

Ja. Ein gängiges Muster ist, fusionierte Werte kontinuierlich und Rohwerte mit geringerer Rate oder auf Anforderung auf separaten Topics zu veröffentlichen. So bleibt die Bandbreite gering, und eine Überprüfung ist trotzdem möglich.