Grundlagen des IoT: Sensoren, Konnektivität, Sicherheit und Ihr erstes Gerät

Das Internet der Dinge (IoT) verbindet physische Objekte — Sensoren und Aktoren — mit dem Internet, damit sie Daten sammeln und Aktionen auslösen können. Dieses Tutorial führt durch die zentralen Bausteine (Erfassung, Konnektivität und Sicherheit) und zeigt, wie Sie einen einfachen Wi‑Fi-Temperatur-/Feuchtesensor bauen, der an einen MQTT-Broker veröffentlicht. Unterwegs lernen Sie Best Practices und häufige Fallstricke, die von fortgeschrittenen Anwendern häufig erlebt werden.

Kernkomponenten eines IoT-Systems

Sensoren und Aktoren

• Sensoren wandeln reale Phänomene in elektrische Signale um. Häufige Beispiele: Temperatur (DHT22, BME280), Luftfeuchte, Licht (Fotodiode, LDR), Bewegung (PIR), Beschleunigung (MPU6050), Gas (MQ-135) und Näherung (Ultraschall).
• Digital vs. analog:
  • Analoge Sensoren liefern eine Spannung; diese wird per ADC abgetastet und benötigt oft eine Kalibrierung (Offset/Skalierung).
  • Digitale Sensoren (I2C/SPI/1-Wire) liefern meist kalibrierte Messwerte mit weniger Rauschen, erfordern aber die Konfiguration des Busses.
• Aktoren führen Aktionen aus: Relais (zum Schalten von Netzlasten), Motoren/Servos, LEDs/Summer, Magnetventile. Immer Isolation (Optokoppler, MOSFETs, Relais) und Freilaufschutz für induktive Lasten beachten.

Wichtige Überlegungen:

• Abtastrate: Wählen Sie sie abhängig von den Signal­dynamiken und dem Energie­budget (z. B. Temperatur 10–60 s; Vibrationen können kHz erfordern).
• Genauigkeit und Präzision: Prüfen Sie das Datenblatt des Sensors auf Toleranz, Drift und benötigte Aufwärmzeit.
• Kalibrierung: Umwelt­sensoren profitieren von einer Basis­kalibrierung (z. B. Feuchte-Offset) und gelegentlicher Neukalibrierung.

Edge-Computing: MCU vs. SBC

• Mikrocontroller (MCUs) wie ESP32, STM32, nRF52 sind stromsparend, kostengünstig und ideal für einfache Aufgaben, oft mit C/C++ oder MicroPython. Der Speicher ist begrenzt; entwerfen Sie für diese Einschränkungen.
• Einplatinenrechner (SBCs) wie Raspberry Pi laufen unter Linux und unterstützen höherstufige Sprachen (Python/Node.js), verbrauchen aber mehr Energie und benötigen länger zum Booten.

Konnektivitätsoptionen und Kompromisse

• Wi‑Fi: Hohe Durchsatzraten, weit verbreitet, moderate Reichweite, höherer Stromverbrauch. Gut für Sensoren zu Hause/Büro mit Netzanschluss oder großen Batterien.
• BLE: Sehr geringer Stromverbrauch, kurze Reichweite; ideal für Wearables oder Smartphone‑Interaktionen.
• Zigbee/Thread: Mesh-Netzwerke, niedriger Verbrauch, erfordert Koordinator; ideal für Smart-Home‑Setups.
• LoRaWAN: Sehr große Reichweite, sehr niedrige Datenrate; ausgezeichnet für entfernte Sensoren mit kleinen Nutzdaten und langer Batterielaufzeit.
• Mobilfunk (LTE‑M/NB‑IoT): Flächen­deckende Abdeckung, moderater Verbrauch; erfordert SIM, Datentarif und sorgfältiges Energiemanagement.

Entscheidungshilfen:

• Kleine Nutzlasten, seltene Übertragungen: LoRaWAN oder NB‑IoT.
• Interaktive Geräte in Gebäuden: Wi‑Fi oder Zigbee/Thread.
• Smartphone-Begleiter: BLE.

Datenmodelle und Nachrichtenformate

• JSON: Menschenlesbar; gut zum Debuggen; schwerer für eingeschränkte Links.
• CBOR/MessagePack: Binär, kompakt; besser für niedrige Bandbreite.
• Enthalten Sie essentielle Felder: device_id, timestamp (UTC epoch), Messeinheiten und Version. Beispiel JSON: {"device_id":"esp32-7afc","ts":1711048275,"temp_c":23.8,"hum_pct":43.1,"fw":"1.0.2"}

Netzwerke und IoT-Protokolle

MQTT in der Praxis

MQTT ist ein leichtgewichtiges Pub/Sub‑Protokoll, das häufig von IoT-Geräten verwendet wird.

• Komponenten: Clients (Geräte/Apps) und ein Broker (zentraler Server).
• Topics: Hierarchische Strings, z. B. building/2/floor/1/room/42/temp.
• QoS:
  • 0: höchstens einmal (schnell, kann Nachrichten verlieren).
  • 1: mindestens einmal (kann duplizieren; sorgen Sie für Idempotenz).
  • 2: genau einmal (am aufwändigsten; selten nötig auf ressourcenbeschränkten Geräten).
• Retained messages: Der Broker speichert die letzte Nachricht; nützlich für den aktuellen Zustand.
• Last Will and Testament (LWT): Der Broker veröffentlicht eine Nachricht, wenn ein Client unerwartet die Verbindung verliert.

Gutes Topic-Design:

• Verwenden Sie stabile Hierarchien, die physischen Aufbau oder Funktion widerspiegeln.
• Vermeiden Sie das Einfügen sensibler Informationen (z. B. Zugangsdaten) in Topics oder Payloads.

Wann HTTP/REST oder CoAP verwenden

• HTTP/REST: Gut für Kommando/Steuerung und gelegentliche Sensor-Posts. Schwerer als MQTT, aber allgegenwärtig.
• CoAP: Leichtgewichtiges Request/Response (auf UDP‑Basis) für eingeschränkte Geräte; unterstützt Observe (ähnlich Pub/Sub). Nützlich in stromsparenden Mesh-Netzen.

Geräteidentität und Provisioning

• Weisen Sie global eindeutige IDs zu (z. B. abgeleitet von MAC/unique_id).
• Provisionieren Sie Anmelde­daten pro Gerät (X.509‑Zertifikat oder symmetrischer Schlüssel) und speichern Sie diese sicher.
• Automatisieren Sie das Onboarding mit einem Geräte‑Register und Just‑in‑Time- oder Bulk‑Provisioning‑Workflows.

Sicherheitsgrundlagen für IoT

Sicherheit ist unverhandelbar. Bedrohungen umfassen Abhören, Geräteklonung, Botnets und Datenmanipulation.

Essentials:

• Transportsicherheit: Verwenden Sie TLS (Port 8883 für MQTT) mit Server‑Zertifikatsprüfung. Bevorzugen Sie mutual TLS (mTLS) mit Client‑Zertifikaten.
• Schlüsselverwaltung: Einzigartige Anmeldeinformationen pro Gerät; niemals gemeinsame Secrets im Firmware‑Code hinterlegen. Verwenden Sie Secure Elements (ATECC608A/TPM) oder geschützten Flash, falls verfügbar.
• Firmware‑Integrität: Aktivieren Sie Secure Boot und signieren Sie Firmware. Prüfen Sie Signaturen vor dem Anwenden von OTA‑Updates.
• Prinzip der geringsten Privilegien:
  • Broker: Verwenden Sie per‑Gerät Topics und ACLs (gerät X darf nur auf sensors/x/# publishen).
  • Cloud: Eng begrenzte IAM‑Rollen; rotieren Sie Zugangsdaten regelmäßig.
• Netzwerksegmentierung: Platzieren Sie IoT‑Geräte in isolierten VLANs; beschränken Sie ausgehende Verbindungen; deaktivieren Sie unnötige Dienste.
• Logging und Monitoring: Geräte‑Heartbeat‑Topics, LWT‑Nachrichten, Anomalieerkennung beim Publish‑Rate und Payload‑Schema.
• Datenschutz: Minimieren Sie personenbezogene Daten (PII); anonymisieren Sie, wo möglich; verschlüsseln Sie sensible Payload‑Felder Ende‑zu‑Ende, wenn erforderlich.

Häufige Fallstricke:

• Nutzung öffentlicher Test‑Broker in der Produktion.
• Überspringen der Zertifikatsprüfung, um „es zum Laufen zu bringen“.
• Statische Standardpasswörter und offene OTA‑Endpunkte.
• Kein Plan für Key‑Rotation oder Firmware‑Updates.
• OTA‑Updates ohne Rollback oder Integritätsprüfungen.

Aufbau eines einfachen Wi‑Fi‑Sensors, der per MQTT veröffentlicht

Sie bauen einen ESP32‑basierten Temperatur-/Feuchte‑Knoten, der JSON an einen MQTT‑Broker veröffentlicht, und verifizieren die Daten von Ihrem Laptop.

Hardware, die Sie benötigen

• ESP32 DevKit (oder ESP8266 NodeMCU, aber Beispiele verwenden ESP32)
• DHT22 (AM2302) Temperatur-/Feuchtesensor
• 10 kΩ Pull‑Up Widerstand (falls Ihr DHT22‑Modul keinen integriert hat)
• Steckbrett und Jumper‑Kabel
• USB‑Kabel

Optional für Produktion: BME280 (I2C, bessere Genauigkeit), Gehäuse, Konformschicht für Feuchte.

Verkabelung

• DHT22 VCC → ESP32 3.3V
• DHT22 GND → ESP32 GND
• DHT22 DATA → ESP32 GPIO4
• 10 kΩ Pull‑Up zwischen DATA und 3.3V (überspringen, wenn Ihr Modul bereits einen hat)

Firmware‑Wahl

Wir verwenden MicroPython für schnelle Iterationen. Sie können die Logik später auf Arduino/C++ mit PubSubClient übertragen.

Schritt 1: MicroPython auf den ESP32 flashen

1. Laden Sie eine aktuelle ESP32‑MicroPython‑Firmware (.bin) von micropython.org herunter.
2. Löschen und flashen Sie via esptool:
   • pip install esptool
   • Versetzen Sie den ESP32 in den Bootloader‑Modus (BOOT/EN Tasten, falls nötig).
   • Löschen: esptool.py --chip esp32 erase_flash
   • Flashen: esptool.py --chip esp32 --baud 460800 write_flash -z 0x1000 esp32-xxxx.bin

Schritt 2: Verbindung zum Board herstellen und Wi‑Fi einrichten

Verwenden Sie Thonny oder mpremote, um Dateien zu kopieren.

Erstellen Sie boot.py mit Ihren Wi‑Fi‑Zugangsdaten:

# boot.py
import network, time

def connect_wifi(ssid, password, timeout_s=15):
    wlan = network.WLAN(network.STA_IF)
    if not wlan.active():
        wlan.active(True)
    if not wlan.isconnected():
        wlan.connect(ssid, password)
        t0 = time.ticks_ms()
        while not wlan.isconnected():
            if time.ticks_diff(time.ticks_ms(), t0) > timeout_s * 1000:
                raise RuntimeError("Wi-Fi connection timeout")
            time.sleep(0.3)
    print("Wi-Fi OK, IP:", wlan.ifconfig()[0])

# Replace with your SSID/PASS
connect_wifi("YOUR_SSID", "YOUR_PASSWORD")

Kopieren Sie die Datei auf das Board:

• mpremote cp boot.py :
• Oder in Thonny boot.py auf dem Gerät öffnen und einfügen/speichern.

Schritt 3: Den MQTT‑Sensor‑Publisher schreiben

Erstellen Sie main.py:

# main.py
import time, machine, json, ubinascii
import dht
from umqtt.simple import MQTTClient

SENSOR_PIN = 4  # ESP32 GPIO4
sensor = dht.DHT22(machine.Pin(SENSOR_PIN))

CLIENT_ID = b"esp32-" + ubinascii.hexlify(machine.unique_id())
MQTT_BROKER = "test.mosquitto.org"  # For testing only (no TLS, public)
MQTT_PORT = 1883
TOPIC = b"lab/room1/env"

def connect_mqtt():
    # For TLS in production, use port=8883 and ssl=True (requires firmware with SSL)
    client = MQTTClient(CLIENT_ID, MQTT_BROKER, port=MQTT_PORT, keepalive=60)
    client.set_last_will(b"lab/room1/status", b"offline", retain=True)
    client.connect()
    client.publish(b"lab/room1/status", b"online", retain=True)
    return client

def read_sensor():
    sensor.measure()
    return sensor.temperature(), sensor.humidity()

def main():
    client = None
    while True:
        try:
            if client is None:
                client = connect_mqtt()
            t, h = read_sensor()
            payload = json.dumps({
                "device_id": CLIENT_ID.decode(),
                "ts": time.time(),
                "temp_c": t,
                "hum_pct": h
            })
            client.publish(TOPIC, payload)
            print("Published:", payload)
            # Sleep 10 seconds; for batteries, consider deep sleep
            time.sleep(10)
        except Exception as e:
            print("Error:", e)
            try:
                if client:
                    client.disconnect()
            except:
                pass
            client = None
            time.sleep(3)

main()

Hinweise:

• test.mosquitto.org ist nur für schnelle Experimente; versenden Sie keine Produktionsdaten dorthin.
• Für TLS/mTLS in der Produktion wechseln Sie zu einem privaten Broker und setzen ssl=True mit CA‑Zertifikat‑Support oder verwenden eine robuste MQTT‑Bibliothek in C++/ESP‑IDF.

Schritt 4: Ausführen und verifizieren

• Setzen Sie das Board zurück/booten Sie neu (Powercycle oder EN‑Taste).
• Auf Ihrem Laptop:
  • Abonnieren Sie das Topic: mosquitto_sub -h test.mosquitto.org -t lab/room1/env -v
  • Sie sollten alle 10 Sekunden JSON‑Nachrichten sehen.
• Plausibilitätsprüfungen:
  • Erwärmen Sie den DHT22 leicht mit der Hand; die Temperatur sollte steigen.
  • Bei Prüfungsfehlern (Checksum Errors) erhöhen Sie das Abtastintervall (DHT22 bevorzugt ≥2 s) und prüfen Sie Verkabelung/Pull‑Up.

Schritt 5: Optional — Cloud‑Dashboards

• Adafruit IO oder HiveMQ Cloud: Erstellen Sie einen Feed/Topic; richten Sie Ihr Gerät auf den Broker aus und visualisieren Sie die Werte.
• DIY‑Stack: Mosquitto + Telegraf + InfluxDB + Grafana. Transformieren Sie JSON mit Telegraf‑Prozessoren.

Energie, Zuverlässigkeit und Skalierung

• Energieplanung:
  • Verwenden Sie Deep Sleep: Auf dem ESP32 kann machine.deepsleep(ms) den Strom auf Mikroampere senken; aufwecken per Timer oder GPIO.
  • Batching von Übertragungen: Sammeln Sie Messungen und senden Sie eine Nutzlast, um Funk‑On‑Zeit zu reduzieren.
  • Wi‑Fi optimieren: Statische IP und kürzere DTIM können Verbindungszeit verbessern; beachten Sie AP‑Einstellungen.
• Zuverlässigkeit:
  • Watchdog‑Timer, um von Hängern zu erholen.
  • Idempotentes Design für QoS1‑Duplikate: Fügen Sie eine monoton wachsende Sequenznummer oder Timestamp hinzu.
  • Zeit­synchronisation: NTP beim Boot; speichern Sie einen RTC‑Offset für Offline‑Zeitstempel.
• Wartbarkeit:
  • OTA‑Updates mit signierten Images und Rollback‑Partitionen (ESP‑IDF) oder Bootloader‑Strategie.
  • Telemetrie zur Gerätegesundheit: Batterie­spannung, RSSI, Firmware‑Version.
• Datenqualität:
  • Ausreißererkennung und Plausibilitätsprüfungen (z. B. −40–85 °C für viele DHT‑Bereiche).
  • Sensoren kalibrieren und Kalibrier‑Metadaten mit Messwerten speichern.

Beste Praktiken und häufige Fallstricke

Beste Praktiken:

• Einzigartige Zugangsdaten pro Gerät; regelmäßiger Austausch.
• Least‑privilege ACLs auf Brokern und Cloud‑Ressourcen.
• Beibehalten von „status/online“ mit Retain und LWT für Flottenüberwachung.
• Versionierung des Payload‑Schemas; fügen Sie "schema":"env_v1" hinzu.
• Verwenden Sie CBOR für eingeschränkte Netze; halten Sie Payloads < 51 Bytes für LoRaWAN.
• Trennen Sie Steuerungs‑ und Telemetrie‑Topics (cmd/ und sensors/). Validieren Sie Befehle auf dem Gerät.

Zu vermeidende Fallstricke:

• Hardcodierte gemeinsame Secrets in Firmware‑Images.
• Verlassen auf öffentliche NTP‑Server ohne Fallback; behandeln Sie fehlgeschlagene Zeit­syncs.
• Übermäßiges Abtasten lauter Sensoren und Broker‑Fluten.
• Ignorieren von Brown‑Out: instabile Messwerte bei marginaler USB‑Versorgung; Kondensatoren und BOD‑Konfiguration hinzufügen.
• Lange blockierende Delays, die MQTT‑Keepalive‑Pings verhindern; verwenden Sie nicht‑blockierende Schleifen oder Timer.

Nächste Schritte

• TLS/mTLS hinzufügen: Nutzen Sie einen privaten Broker (Mosquitto mit TLS, HiveMQ, EMQX) und provisionieren Sie pro Gerät X.509‑Zertifikate.
• Skalieren: Führen Sie ein Geräte‑Register, Fleet‑Provisioning und einen Update‑Dienst (Mender, Hawkbit oder kundenspezifisch) ein.
• Fortgeschrittene Konnektivität: Probieren Sie Thread/Matter für Hausautomation oder LoRaWAN für entlegene Hütten und Farmen.
• Edge‑Intelligenz: Führen Sie leichte ML‑Modelle (TinyML) aus, um lokale Anomalien zu erkennen und nur Events zu senden.
• Produktionshärtung: Gehäuse, Konformschicht, wasserdichte Steckverbinder und Umwelttests (Temperaturzyklen, Vibration).

Wenn Sie Sensoren verstehen, die richtige Konnektivität wählen und Sicherheit von Anfang an einbauen, können Sie von einem einzelnen Steckbrett‑Prototyp zu einer robusten Flotte übergehen. Ihr einfacher MQTT‑Sensor ist die Grundlage — iterieren Sie an Energiemanagement, Zuverlässigkeit und sicherem Provisioning, um ihn produktionsreif zu machen.