MQTT-Kommunikationseinrichtung

Diese Anleitung zeigt Ihnen, wie Sie die MQTT-Kommunikation zwischen Ihrer OV80i-Kamera und externen Geräten mithilfe von Node-RED konfigurieren. MQTT ermöglicht leichtgewichtiges, zuverlässiges Messaging für IoT-Anwendungen und die Kommunikation mit entfernten Geräten.

Wann MQTT-Kommunikation verwenden: Integration von IoT-Geräten, Remote-Überwachungssysteme, Publish/Subscribe-Messaging-Muster, Umgebungen mit geringer Bandbreite, verteilte Sensornetzwerke oder wenn Sie eine zuverlässige Nachrichtenübertragung mit automatischer Wiederverbindung benötigen.

Voraussetzungen

• OV80i-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

Überblick zur MQTT-Kommunikation

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 Netzwerkeinstellungen der Kamera prüfen

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

1.2 Anforderungen an den MQTT-Broker

Erreichbarkeit des MQTT-Brokers sicherstellen:

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

1.3 Netzwerkanforderungen

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

Schritt 2: Node-RED-Editor aufrufen

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 überprüfen

MQTT-Nodes in der Node-RED-Palette prüfen:

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

Checkpoint: Sie sollten die 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 Node "mqtt in" auf die Arbeitsfläche (für die Ersteinrichtung)
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:

Einstellung	Wert	Beschreibung
Name	Camera MQTT Broker	Aussagekräftige Bezeichnung
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	Benutzername des MQTT-Brokers
Password	Passwort des MQTT-Brokers
Use TLS	Aktivieren für sichere Verbindungen (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 erneut verbinden

3.5 Broker-Konfiguration speichern

1. Auf "Add" klicken, um die Broker-Einstellungen zu speichern
2. Auf "Done" klicken, um die Node-Konfiguration zu schließen
3. Broker-Konfiguration steht nun für alle MQTT-Nodes zur Verfügung

Schritt 4: MQTT-Eingang konfigurieren (Subscribe)

4.1 MQTT-In-Node einrichten

1. Die hinzugefügte "mqtt in"-Node auswählen
2. Doppelklicken zum Konfigurieren
3. Subscription-Einstellungen konfigurieren:

4.2 MQTT-In-Konfiguration

Subscription-Einstellungen:

Einstellung	Beispielwert	Beschreibung
Server	Camera MQTT Broker	Konfigurierten Broker auswählen
Topic	camera/commands	Topic, das abonniert werden soll
QoS	0	Qualität der Nachrichtenzustellung
Output	auto-detect	Nachrichtenformat
Name	Command Listener	Node-Bezeichner

4.3 Konventionen für Topic-Namen

Empfohlene Topic-Struktur:

Zweck	Topic-Beispiel	Verwendung
Commands	camera/commands	Steuerbefehle empfangen
Status requests	camera/status/request	Anfragen für Statusinformationen
Configuration	camera/config	Konfigurationsänderungen

4.4 Nachrichtenverarbeitung konfigurieren

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

Schritt 5: MQTT-Ausgang konfigurieren (Publish)

5.1 MQTT-Out-Node hinzufügen

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

5.2 MQTT-Out-Konfiguration

Publishing-Einstellungen:

Einstellung	Beispielwert	Beschreibung
Server	Camera MQTT Broker	Gleicher Broker wie beim Eingang
Topic	camera/responses	Topic für Kameraantworten
QoS	0	Qualität der Nachrichtenzustellung
Retain	False	Letzte Nachricht nicht speichern
Name	Response Publisher	Node-Bezeichner

5.3 Struktur der Antwort-Topics

Empfohlene Antwort-Topics:

Antworttyp	Topic-Beispiel	Verwendung
Status updates	camera/status	Statusinformationen der Kamera
Results	camera/results	Inspektionsergebnisse
Acknowledgments	camera/ack	Bestätigungen von Befehlen

Schritt 6: Grundlegenden Kommunikationsablauf erstellen

6.1 Ablauf für ausgehende Nachrichten erstellen

Einen Flow erstellen, um Nachrichten von der Kamera zu veröffentlichen:

1. "inject"-Node zum Auslösen von Nachrichten hinzufügen
2. "function"-Node zur Nachrichtenformatierung hinzufügen
3. "mqtt out"-Node zum Veröffentlichen hinzufügen
4. Verbinden: Inject → Function → MQTT Out

6.2 Ablauf für eingehende Nachrichten erstellen

Einen separaten Flow erstellen, um Nachrichten zu empfangen:

1. "mqtt in"-Node zum Abonnieren hinzufügen
2. "debug"-Node zur Überwachung hinzufügen
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 durch 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 bereitstellen und testen

7.1 Flow bereitstellen

1. Auf "Deploy"-Button klicken (rechts oben)
2. Erfolgsmeldung der Bereitstellung überprüfen
3. Node-Statusanzeigen prüfen:
   • Grüner Punkt: Mit Broker verbunden
   • Roter Punkt: Verbindung fehlgeschlagen
   • Gelber Punkt: Verbindung wird aufgebaut

7.2 Interne Kommunikation testen

MQTT-Veröffentlichung der Kamera testen:

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

7.3 Externer Test (Optional)

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

Mit Kommandozeilen-Tools:

# Send a test command to the camera
mosquitto_pub -h 10.250.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	☐
Nachrichtenveröffentlichung	Inject löst MQTT Out erfolgreich aus	☐
Nachrichtenempfang	Debug zeigt externe Nachrichten an	☐
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 Verbindungsstatus	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-Abonnements 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-Leistung prüfen
Verbindungsabbrüche	Häufige Wiederverbindungen	Keep-Alive-Einstellungen anpassen
Nachrichtenflut	Broker-Überlastung	Message Throttling implementieren

8.4 Debug-Techniken

Systematische Fehlersuche:

1. Broker-Verbindungsstatus prüfen in Node-RED
2. Node-RED Debug-Panel überwachen zur Nachrichtenverfolgung
3. Einfache Textnachrichten verwenden vor komplexen Daten
4. Netzwerkverbindung überprüfen mit Ping
5. Mit einfachen Topics testen vor erweiterten Flows

Erfolg! Ihre MQTT-Kommunikation ist einsatzbereit

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 überprüfen mit Testnachrichten
• Broker-Logs prüfen auf Fehlermuster
• Authentifizierungsdaten aktualisieren bei 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 organisierte Kommunikation
3. Sicherheitsmaßnahmen hinzufügen wie TLS-Verschlüsselung
4. Mit externen Systemen integrieren über etablierte MQTT-Protokolle
5. Monitoring-Dashboards erstellen zur Systemüberwachung

MQTT-Flows automatisch generieren

Der Integration Builder kann vollständige MQTT-Kommunikationsflows 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-Kommunikation einrichten
• RS-232-Kommunikation einrichten
• Mit PLC verbinden (Ethernet/IP, PROFINET)
• Node-RED Grundlagen