Zum Hauptinhalt springen

KI-GESTÜTZTE DOKUMENTATION

Was möchten Sie wissen?

MQTT-Kommunikationseinrichtung

Diese Anleitung zeigt Ihnen, wie Sie die MQTT-Kommunikation zwischen Ihrer OV20i-Kamera und externen Geräten mit Node-RED konfigurieren. MQTT ermöglicht leichtgewichtige, zuverlässige Nachrichtenübermittlung für IoT-Anwendungen und Remote-Gerätekommunikation.

Wann MQTT-Kommunikation verwenden: IoT-Geräteintegration, Remote-Monitoring-Systeme, Publish/Subscribe-Nachrichtenmuster, Umgebungen mit geringer Bandbreite, verteilte Sensornetzwerke oder wenn Sie eine zuverlässige Nachrichtenzustellung mit automatischer Wiederverbindung benötigen.

Voraussetzungen​

  • OV20i-Kamerasystem eingerichtet und verbunden
  • Netzwerkverbindung zwischen Kamera und MQTT-Broker
  • Verfügbarer MQTT-Broker (lokal oder cloudbasiert)
  • Grundlegendes Verständnis der MQTT-Konzepte (Topics, Publish/Subscribe)
  • Aktives Rezept auf der Kamera konfiguriert

Übersicht MQTT-Kommunikation​

MQTT-Kernkonzepte:

  • Broker: Zentraler Server, der Nachrichten zwischen Clients weiterleitet
  • Topics: Nachrichtenkategorien (z. B. „camera/status", „commands/trigger")
  • Publish: Nachrichten an ein Topic senden
  • Subscribe: Nachrichten von einem Topic empfangen
  • QoS: Quality-of-Service-Stufen (0, 1, 2)

Schritt 1: Netzwerkkonfiguration überprüfen​

1.1 Netzwerkeinstellungen der Kamera prüfen​

  1. Navigieren Sie zu System Settings
  2. Notieren Sie die IP-Adresse der Kamera (z. B. 192.168.0.100)
  3. Überprüfen Sie die Netzwerkverbindung zum MQTT-Broker

1.2 Anforderungen an den MQTT-Broker​

Stellen Sie die Erreichbarkeit des MQTT-Brokers sicher:

  • Gleiches Netzwerk: Die Kamera muss die Broker-IP-Adresse erreichen können
  • Portzugriff: Standard-MQTT-Port 1883 (oder 8883 für TLS)
  • Authentifizierung: Benutzername/Passwort, falls vom Broker gefordert
  • Firewall: MQTT-Verkehr auf den erforderlichen Ports zulassen

1.3 Netzwerkanforderungen​

KomponenteIP-AdressePortHinweise
Kamera192.168.0.100–Muss Broker erreichen
MQTT-Broker192.168.0.2001883Standard-MQTT-Port
Client-Geräte192.168.0.xxxVariabelBeliebige abonnierende Geräte

Schritt 2: Auf Node-RED-Editor zugreifen​

2.1 Zum IO-Block navigieren​

  1. Öffnen Sie Ihr aktives Rezept im Recipe Editor
  2. Klicken Sie auf Configure IO oder wählen Sie IO Block im Breadcrumb-Menü, um den Node-RED-Editor zu öffnen

2.2 Verfügbarkeit der MQTT-Nodes prüfen​

Überprüfen Sie die Node-RED-Palette auf MQTT-Nodes:

  • mqtt in – MQTT-Topics abonnieren
  • mqtt out – An MQTT-Topics publizieren

Checkpoint: Sie sollten die MQTT-Nodes im Abschnitt „Network" des linken Bedienfelds sehen.

Schritt 3: MQTT-Broker-Verbindung konfigurieren​

3.1 MQTT-Broker-Konfiguration hinzufügen​

  1. Ziehen Sie den Node „mqtt in" auf die Arbeitsfläche (für die initiale Einrichtung)
  2. Doppelklicken Sie auf den Node, um die Konfiguration zu öffnen
  3. Klicken Sie auf das Stiftsymbol neben dem Feld Server
  4. Klicken Sie auf „Add new mqtt-broker"

3.2 Broker-Einstellungen konfigurieren​

Grundlegende Broker-Konfiguration:

EinstellungWertBeschreibung
NameCamera MQTT BrokerAussagekräftige Bezeichnung
Server192.168.0.200IP-Adresse des MQTT-Brokers
Port1883Standard-MQTT-Port
ProtocolMQTT V3.1.1Empfohlene Version
Client ID(automatisch generieren)Für automatische Vergabe leer lassen

3.3 Authentifizierungseinstellungen (falls erforderlich)​

Wenn der Broker eine Authentifizierung erfordert:

EinstellungBeschreibung
UsernameBenutzername des MQTT-Brokers
PasswordPasswort des MQTT-Brokers
Use TLSAktivieren für sichere Verbindungen (Port 8883)

3.4 Erweiterte Einstellungen​

Verbindungsoptionen:

EinstellungEmpfohlener WertBeschreibung
Keep Alive60 SekundenHeartbeat-Intervall
Clean SessionTrueBei jeder Verbindung neu starten
Auto ConnectTrueAutomatisch neu verbinden

3.5 Broker-Konfiguration speichern​

  1. Klicken Sie auf "Add", um die Broker-Einstellungen zu speichern
  2. Klicken Sie auf "Done", um die Node-Konfiguration zu schließen
  3. Die Broker-Konfiguration ist nun für alle MQTT-Nodes verfügbar

Schritt 4: MQTT-Eingang (Subscribe) konfigurieren​

4.1 MQTT-In-Node einrichten​

  1. Wählen Sie den hinzugefügten "mqtt in"-Node aus
  2. Doppelklicken Sie zur Konfiguration
  3. Abonnementeinstellungen konfigurieren:

4.2 MQTT-In-Konfiguration​

Abonnementeinstellungen:

EinstellungBeispielwertBeschreibung
ServerCamera MQTT BrokerKonfigurierten Broker auswählen
Topiccamera/commandsZu abonnierendes Topic
QoS0Qualität der Nachrichtenzustellung
Outputauto-detectNachrichtenformat
NameCommand ListenerNode-Bezeichnung

4.3 Konventionen für Topic-Benennung​

Empfohlene Topic-Struktur:

ZweckTopic-BeispielVerwendung
Commandscamera/commandsSteuerbefehle empfangen
Status requestscamera/status/requestAnfragen nach Statusinformationen
Configurationcamera/configKonfigurationsänderungen

4.4 Nachrichtenverarbeitung konfigurieren​

  1. Fügen Sie einen "debug"-Node hinzu, um eingehende Nachrichten zu überwachen
  2. Verbinden: MQTT In → Debug
  3. Konfigurieren Sie den Debug-Node, um die vollständige Nachricht anzuzeigen

Schritt 5: MQTT-Ausgang (Publish) konfigurieren​

5.1 MQTT-Out-Node hinzufügen​

  1. Ziehen Sie den "mqtt out"-Node auf die Arbeitsfläche
  2. Doppelklicken Sie zur Konfiguration
  3. Wählen Sie dieselbe Broker-Konfiguration aus

5.2 MQTT-Out-Konfiguration​

Veröffentlichungseinstellungen:

EinstellungBeispielwertBeschreibung
ServerCamera MQTT BrokerGleicher Broker wie für Eingang
Topiccamera/responsesTopic für Kamera-Antworten
QoS0Qualität der Nachrichtenzustellung
RetainFalseLetzte Nachricht nicht speichern
NameResponse PublisherNode-Bezeichnung

5.3 Struktur der Antwort-Topics​

Empfohlene Antwort-Topics:

AntworttypTopic-BeispielVerwendung
Status updatescamera/statusKamera-Statusinformationen
Resultscamera/resultsInspektionsergebnisse
Acknowledgmentscamera/ackBefehlsbestätigungen

Schritt 6: Grundlegenden Kommunikations-Flow erstellen​

6.1 Flow für ausgehende Nachrichten aufbauen​

Erstellen Sie einen Flow zum Veröffentlichen von Nachrichten von der Kamera:

  1. Fügen Sie einen "inject"-Node hinzu, um Nachrichten auszulösen
  2. Fügen Sie einen "function"-Node hinzu zur Nachrichtenformatierung
  3. Fügen Sie einen "mqtt out"-Node hinzu zum Veröffentlichen
  4. Verbinden: Inject → Function → MQTT Out

6.2 Flow für eingehende Nachrichten aufbauen​

Erstellen Sie einen separaten Flow zum Empfangen von Nachrichten:

  1. Fügen Sie einen "mqtt in"-Node hinzu zum Abonnieren
  2. Fügen Sie einen "debug"-Node hinzu zur Überwachung
  3. Verbinden: MQTT In → Debug

6.3 Inject-Node konfigurieren​

  1. Doppelklick auf Inject-Node
  2. Einstellungen konfigurieren:
    • Name: "Send Test Message"
    • Payload: Timestamp
    • Topic: (leer lassen)
  3. Auf "Done" klicken

6.4 Function-Node konfigurieren​

Einfache Nachrichtenformatierung:

// Format outgoing message
msg.topic = "camera/status";
msg.payload = "Camera online - " + new Date().toISOString();
return msg;

  1. Doppelklick auf Function-Node
  2. Code oben kopieren in den "On Message"-Tab
  3. Name: "Format Message"
  4. Auf "Done" klicken

6.5 MQTT-Out-Node konfigurieren​

  1. Doppelklick auf MQTT-Out-Node
  2. Broker auswählen: Camera MQTT Broker (zuvor konfiguriert)
  3. Topic: (leer lassen – wird vom Function-Node gesetzt)
  4. Name: "Publish Status"
  5. Auf "Done" klicken

6.6 MQTT-In-Node konfigurieren​

  1. Doppelklick auf MQTT-In-Node
  2. Broker auswählen: Camera MQTT Broker
  3. Topic: camera/commands
  4. Name: "Command Listener"
  5. Auf "Done" klicken

6.7 Debug-Node konfigurieren​

  1. Doppelklick auf Debug-Node
  2. Output: Complete msg object
  3. Name: "Incoming Messages"
  4. Auf "Done" klicken

6.8 Endgültige Flow-Struktur​

Ihr vollständiger Flow sollte wie folgt aussehen:

Ausgehend: Inject → Function → MQTT Out Eingehend: MQTT In → Debug

Schritt 7: Konfiguration bereitstellen und testen​

7.1 Flow bereitstellen​

  1. Auf "Deploy"-Button klicken (obere rechte Ecke)
  2. Erfolgsmeldung zur Bereitstellung überprüfen
  3. Node-Statusanzeigen prüfen:
    • Grüner Punkt: Mit Broker verbunden
    • Roter Punkt: Verbindung fehlgeschlagen
    • Gelber Punkt: Verbindung wird hergestellt

7.2 Interne Kommunikation testen​

MQTT-Veröffentlichung der Kamera testen:

  1. Inject-Button klicken, um Testnachricht zu senden
  2. Aktivität des MQTT-Out-Nodes überprüfen
  3. Debug-Panel prüfen, falls externe Nachrichten vorliegen

7.3 Externe Tests (optional)​

Mit externem MQTT-Client testen, um Befehle an die Kamera zu senden:

Mit Kommandozeilen-Tools:

# Send a test command to the camera
mosquitto_pub -h 192.168.0.100 -t "camera/commands" -m "test_command"

Erwartetes Ergebnis: Der Debug-Node sollte die eingehende Nachricht im Node-RED-Debug-Panel anzeigen.

7.4 Kommunikation überprüfen​

Folgende Aspekte prüfen:

TestErwartetes ErgebnisStatus
Broker-VerbindungGrüner Status an MQTT-Nodes☐
NachrichtenveröffentlichungInject löst MQTT Out erfolgreich aus☐
NachrichtenempfangDebug zeigt externe Nachrichten☐
WiederverbindungAutomatische Wiederverbindung nach Netzwerkunterbrechung☐

Schritt 8: Fehlerbehebung bei MQTT-Problemen​

8.1 Verbindungsprobleme​

ProblemSymptomeLösung
Verbindung zum Broker nicht möglichRote StatusanzeigenBroker-IP und Port prüfen
AuthentifizierungsfehlerVerbindung abgelehntBenutzername/Passwort überprüfen
Netzwerk-TimeoutsGelber VerbindungsstatusNetzwerkverbindung prüfen
Firewall blockiertKein VerbindungsversuchMQTT-Ports öffnen

8.2 Nachrichtenprobleme​

ProblemSymptomeLösung
Keine Nachrichten empfangenDebug zeigt nichts anTopic-Abonnements prüfen
Nachrichten werden nicht veröffentlichtExterne Clients sehen nichtsPublish-Topics überprüfen
NachrichtenformatfehlerParsing-FehlerEinfache Textnachrichten verwenden
Verlorene NachrichtenUnregelmäßige ZustellungBroker-Verbindung prüfen

8.3 Performance-Probleme​

ProblemSymptomeLösung
Hohe LatenzVerzögerte NachrichtenzustellungBroker-Performance prüfen
VerbindungsabbrücheHäufige NeuverbindungenKeep-Alive-Einstellungen anpassen
NachrichtenüberflutungBroker-ÜberlastungNachrichten-Throttling implementieren

8.4 Debug-Techniken​

Systematische Fehlersuche:

  1. Broker-Verbindungsstatus prüfen in Node-RED
  2. Node-RED Debug-Panel überwachen für den Nachrichtenfluss
  3. Einfache Textnachrichten verwenden vor komplexen Daten
  4. Netzwerkverbindung verifizieren mit ping
  5. Mit einfachen Topics testen vor erweiterten Flows

Erfolg! Ihre MQTT-Kommunikation ist einsatzbereit​

Ihr MQTT-Kommunikationssystem kann jetzt:

  • Sich mit MQTT-Brokern verbinden mit ordnungsgemäßer Authentifizierung
  • Topics abonnieren zum Empfangen von Befehlen und Daten
  • Nachrichten veröffentlichen für Statusaktualisierungen und Antworten
  • JSON-Nachrichtenformate verarbeiten für strukturierte Kommunikation
  • Automatisch wiederverbinden nach Netzwerkunterbrechungen
  • Mehrere QoS-Stufen unterstützen für unterschiedliche Nachrichtenprioritäten

Laufende Wartung​

Regelmäßige Systemprüfungen​

  • Broker-Verbindungsstatus überwachen in Node-RED
  • Nachrichtenzustellung verifizieren mit Testnachrichten
  • Broker-Logs prüfen auf Fehlermuster
  • Authentifizierungsdaten aktualisieren nach Bedarf

Performance-Überwachung​

  • Nachrichtenlatenz und Zustellzeiten verfolgen
  • Broker-Ressourcennutzung überwachen für Skalierbarkeit
  • Topic-Nutzungsmuster analysieren zur Optimierung
  • QoS-Einstellungen überprüfen basierend auf tatsächlichen Anforderungen

Nächste Schritte​

Nach Einrichtung der grundlegenden MQTT-Kommunikation:

  1. Spezifische Messaging-Workflows implementieren für Ihre Anwendung
  2. Topic-Hierarchien einrichten für organisierte Kommunikation
  3. Sicherheitsmaßnahmen hinzufügen wie TLS-Verschlüsselung
  4. Mit externen Systemen integrieren über etablierte MQTT-Protokolle
  5. Monitoring-Dashboards erstellen für den Systemzustand
MQTT-Flows automatisch generieren

Der Integration Builder kann vollständige MQTT-Kommunikations-Flows aus einer einfachen englischen Beschreibung generieren. Beschreiben Sie Ihr Messaging-Muster (z. B. „publish inspection results to an MQTT topic with pass/fail status and confidence scores") und erhalten Sie in Sekunden einen produktionsreifen Node-RED Flow.

🔗 Siehe auch​