MQTT-Kommunikationseinrichtung

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

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

Manuelle Einrichtung überspringen

Beschreiben Sie Ihre MQTT-Integration in einfachem Englisch, und der Auto-Integration Builder generiert in Sekundenschnelle einen vollständigen Node-RED-Flow für Sie.

Voraussetzungen

• OV10i-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 Recipe auf der Kamera konfiguriert

MQTT-Kommunikationsübersicht

Wichtige MQTT-Konzepte:

• 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 Kameranetzwerkeinstellungen prüfen

1. Zu Systemeinstellungen navigieren
2. IP-Adresse der Kamera notieren (z. B. 192.168.0.100)
3. Netzwerkverbindung zum MQTT-Broker überprüfen

1.2 Anforderungen an den MQTT-Broker

Zugänglichkeit des MQTT-Brokers sicherstellen:

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

1.3 Netzwerkanforderungen

Komponente	IP-Adresse	Port	Hinweise
Kamera	192.168.0.100	N/A	Muss Broker erreichen
MQTT-Broker	192.168.0.200	1883	Standard-MQTT-Port
Client-Geräte	192.168.0.xxx	Variabel	Beliebige abonnierende Geräte

Schritt 2: Node-RED-Editor aufrufen

2.1 Zum IO-Block navigieren

1. Öffnen Sie Ihr aktives Recipe 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

Node-RED-Palette auf MQTT-Nodes prüfen:

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

Checkpoint: Sie sollten MQTT-Nodes im Bereich Network des linken Panels sehen.

Schritt 3: MQTT-Broker-Verbindung konfigurieren

3.1 MQTT-Broker-Konfiguration hinzufügen

1. Ziehen Sie den "mqtt in"-Node 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 Stift-Symbol neben dem Feld Server
4. Klicken Sie auf "Add new mqtt-broker"

3.2 Broker-Einstellungen konfigurieren

Grundlegende Broker-Konfiguration:

Einstellung	Wert	Beschreibung
Name	Camera MQTT Broker	Beschreibender Bezeichner
Server	192.168.0.200	IP-Adresse des MQTT-Brokers
Port	1883	Standard-MQTT-Port
Protocol	MQTT V3.1.1	Empfohlene Version
Client ID	(automatisch generieren)	Für automatische Vergabe leer lassen

3.3 Authentifizierungseinstellungen (falls erforderlich)

Wenn der Broker eine Authentifizierung erfordert:

Einstellung	Beschreibung
Username	MQTT-Broker-Benutzername
Password	MQTT-Broker-Passwort
Use TLS	Für sichere Verbindungen aktivieren (Port 8883)

3.4 Erweiterte Einstellungen

Verbindungsoptionen:

Einstellung	Empfohlener Wert	Beschreibung
Keep Alive	60 Sekunden	Heartbeat-Intervall
Clean Session	True	Bei jeder Verbindung neu starten
Auto Connect	True	Automatisch neu verbinden

3.5 Broker-Konfiguration speichern

1. Auf "Add" klicken, um die Broker-Einstellungen zu speichern
2. Auf "Done" klicken, um die Knotenkonfiguration zu schließen
3. Die Broker-Konfiguration ist jetzt für alle MQTT-Knoten verfügbar

Schritt 4: MQTT-Eingang konfigurieren (Subscribe)

4.1 MQTT In Node einrichten

1. Wählen Sie den hinzugefügten "mqtt in"-Knoten aus
2. Doppelklicken Sie zum Konfigurieren
3. Konfigurieren Sie die Abonnement-Einstellungen:

4.2 MQTT In Konfiguration

Abonnement-Einstellungen:

Einstellung	Beispielwert	Beschreibung
Server	Camera MQTT Broker	Konfigurierten Broker auswählen
Topic	camera/commands	Topic für das Abonnement
QoS	0	Nachrichtenzustellungsqualität
Output	auto-detect	Nachrichtenformat
Name	Command Listener	Knotenbezeichnung

4.3 Topic-Namenskonventionen

Empfohlene Topic-Struktur:

Zweck	Topic-Beispiel	Verwendung
Commands	camera/commands	Steuerbefehle empfangen
Status requests	camera/status/request	Statusinformationsanfragen
Configuration	camera/config	Konfigurationsänderungen

4.4 Nachrichtenverarbeitung konfigurieren

1. "debug"-Knoten hinzufügen, um eingehende Nachrichten zu überwachen
2. Verbinden: MQTT In → Debug
3. Debug-Knoten konfigurieren, um die vollständige Nachricht anzuzeigen

Schritt 5: MQTT-Ausgang konfigurieren (Publish)

5.1 MQTT Out Node hinzufügen

1. "mqtt out"-Knoten auf die Arbeitsfläche ziehen
2. Doppelklicken zum Konfigurieren
3. Dieselbe Broker-Konfiguration auswählen

5.2 MQTT Out Konfiguration

Veröffentlichungseinstellungen:

Einstellung	Beispielwert	Beschreibung
Server	Camera MQTT Broker	Gleicher Broker wie für Eingang
Topic	camera/responses	Topic für Kameraantworten
QoS	0	Nachrichtenzustellungsqualität
Retain	False	Letzte Nachricht nicht speichern
Name	Response Publisher	Knotenbezeichnung

5.3 Antwort-Topic-Struktur

Empfohlene Antwort-Topics:

Antworttyp	Topic-Beispiel	Verwendung
Status updates	camera/status	Kamerastatusinformationen
Results	camera/results	Inspektionsergebnisse
Acknowledgments	camera/ack	Befehlsbestätigungen

Schritt 6: Grundlegenden Kommunikationsablauf erstellen

6.1 Ausgehenden Nachrichtenfluss erstellen

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

1. "inject"-Knoten hinzufügen, um Nachrichten auszulösen
2. "function"-Knoten hinzufügen, um Nachrichten zu formatieren
3. "mqtt out"-Knoten hinzufügen, um zu veröffentlichen
4. Verbinden: Inject → Function → MQTT Out

6.2 Eingehenden Nachrichtenfluss erstellen

Erstellen Sie einen separaten Flow zum Empfangen von Nachrichten:

1. "mqtt in"-Knoten hinzufügen, um zu abonnieren
2. "debug"-Knoten hinzufügen, um Nachrichten zu überwachen
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 Tab "On Message"
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 folgendermaßen aussehen:

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

Schritt 7: Konfiguration deployen und testen

7.1 Flow deployen

1. Auf die Schaltfläche "Deploy" klicken (oben rechts)
2. Erfolgsmeldung für das Deployment überprüfen
3. Node-Statusanzeigen prüfen:
   • Grüner Punkt: Mit Broker verbunden
   • Roter Punkt: Verbindung fehlgeschlagen
   • Gelber Punkt: Verbindungsaufbau

7.2 Interne Kommunikation testen

MQTT-Publishing der Kamera testen:

1. Auf die Inject-Schaltfläche klicken, um eine Testnachricht zu senden
2. Aktivität des MQTT-Out-Nodes überprüfen
3. Debug-Panel prüfen, sofern externe Nachrichten vorliegen

7.3 Externer Test (optional)

Test mit externem MQTT-Client, 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:

Test	Erwartetes Ergebnis	Status
Broker-Verbindung	Grüner Status an MQTT-Nodes	☐
Nachrichtenversand	Inject löst MQTT Out erfolgreich aus	☐
Nachrichtenempfang	Debug zeigt externe Nachrichten	☐
Wiederverbindung	Automatische Wiederverbindung nach Netzwerkunterbrechung	☐

Schritt 8: Fehlerbehebung bei MQTT-Problemen

8.1 Verbindungsprobleme

Problem	Symptome	Lösung
Verbindung zum Broker nicht möglich	Rote Statusanzeigen	Broker-IP und Port prüfen
Authentifizierungsfehler	Verbindung abgelehnt	Benutzername/Passwort überprüfen
Netzwerk-Timeouts	Gelber Status "Connecting"	Netzwerkverbindung prüfen
Firewall blockiert	Kein Verbindungsversuch	MQTT-Ports öffnen

8.2 Nachrichtenprobleme

Problem	Symptome	Lösung
Keine Nachrichten empfangen	Debug zeigt nichts an	Topic-Subscriptions prüfen
Nachrichten werden nicht veröffentlicht	Externe Clients sehen nichts	Publish-Topics überprüfen
Fehler im Nachrichtenformat	Parsing-Fehler	Einfache Textnachrichten verwenden
Verlorene Nachrichten	Sporadische Zustellung	Broker-Verbindung prüfen

8.3 Performance-Probleme

Problem	Symptome	Lösung
Hohe Latenz	Verzögerte Nachrichtenzustellung	Broker-Performance prüfen
Verbindungsabbrüche	Häufige Wiederverbindungen	Keep-Alive-Einstellungen anpassen
Nachrichtenflut	Broker-Überlastung	Nachrichten-Throttling implementieren

8.4 Debugging-Techniken

Systematische Fehlersuche:

1. Broker-Verbindungsstatus prüfen in Node-RED
2. Node-RED Debug-Panel überwachen auf 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 bereit

Ihr MQTT-Kommunikationssystem kann nun:

• 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 der Einrichtung der grundlegenden MQTT-Kommunikation:

1. Spezifische Messaging-Workflows implementieren für Ihre Anwendung
2. Topic-Hierarchien einrichten für strukturierte 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 komplette 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

• Trigger über MQTT
• TCP-Kommunikations-Setup
• RS-232-Kommunikations-Setup
• Mit PLC verbinden (Ethernet/IP, PROFINET)
• Node-RED Grundlagen