Zum Hauptinhalt springen

KI-GESTÜTZTE DOKUMENTATION

Was möchten Sie wissen?

TCP-Kommunikationseinrichtung

Diese Anleitung zeigt Ihnen, wie Sie die TCP-Kommunikation zwischen Ihrer OV20i-Kamera und externen Geräten mit Node-RED konfigurieren. Verwenden Sie die TCP-Kommunikation für den Echtzeit-Datenaustausch, die Fernsteuerung oder die Integration mit benutzerdefinierten Anwendungen und Systemen.

Video-Anleitung

Sehen Sie sich dieses Thema in Aktion an: Auto-Integration Builder

Wann TCP-Kommunikation verwenden: Echtzeit-Datenstreaming, Integration benutzerdefinierter Anwendungen, bidirektionale Kommunikation mit externen Systemen, hochfrequenter Datenaustausch oder wenn HTTP/REST-APIs nicht geeignet sind.

Voraussetzungen​

  • OV20i-Kamerasystem eingerichtet und angeschlossen
  • Zielgerät/-system mit TCP-Kommunikationsfähigkeit
  • Netzwerkverbindung zwischen Kamera und Zielgerät
  • Grundlegendes Verständnis von IP-Adressen und Portnummern
  • Aktives Rezept konfiguriert (Bildgebungs- und Inspektionseinrichtung abgeschlossen)

Schritt 1: Netzwerkkonfiguration überprüfen​

1.1 IP-Adresse der Kamera prüfen​

  1. Zu Systemeinstellungen navigieren
  2. IP-Adresse der Kamera notieren (z. B. 192.168.0.100)
  3. Subnetzmaske und Netzwerkkonfiguration überprüfen

1.2 Netzwerk des Zielgeräts bestätigen​

Netzwerkkompatibilität sicherstellen:

  • Gleiches Subnetz: Kamera und Zielgerät müssen sich im selben Netzwerkbereich befinden
  • Zugängliche Ports: Ports des Zielgeräts dürfen nicht durch Firewalls blockiert sein
  • Netzwerkverbindung: Wenn möglich mit Ping-Befehl testen

1.3 Netzwerkanforderungen​

AnforderungKameraZielgerätHinweise
IP-Bereich192.168.0.100192.168.0.xxxMuss gleiches Subnetz sein
Subnetzmaske255.255.255.0255.255.255.0Standardkonfiguration
Port-Zugriff49155 (Beispiel)49155 (Beispiel)Reservierte Ports vermeiden
FirewallTCP-Verkehr erlaubenTCP-Verkehr erlaubenBeide Richtungen

Schritt 2: Zugriff auf den Node-RED-Editor​

2.1 Zum IO-Block navigieren​

  1. Klicken Sie auf „IO Block" im Brotkrumen-Menü des Rezepts, ODER
  2. Wählen Sie „Configure I/O" im Recipe Editor

2.2 Node-RED-Editor öffnen​

  1. Klicken Sie auf Configure IO, um den Node-RED-Flow-Editor zu öffnen
  2. Überprüfen Sie, ob die Node-RED-Oberfläche ordnungsgemäß geladen wird

Prüfpunkt: Sie sollten den Node-RED-Flow-Editor mit der Node-Palette auf der linken Seite sehen.

Schritt 3: TCP-Eingang konfigurieren (Daten empfangen)​

3.1 TCP-Eingangsknoten hinzufügen​

  1. Suchen Sie den Knoten „tcp in" im linken Bereich (Abschnitt Network)
  2. Ziehen Sie den Knoten „tcp in" auf die Flow-Arbeitsfläche
  3. Doppelklicken Sie auf den Knoten, um ihn zu konfigurieren

3.2 TCP-Eingangseinstellungen konfigurieren​

Knotenkonfiguration:

EinstellungWertBeschreibung
TypeListen onKamera agiert als Server
Port49155Port, auf dem die Kamera lauscht
Data modeStreamKontinuierlicher Datenfluss
Data typeUTF8Textbasierte Kommunikation
Topic(optional)Nachrichtenkategorisierung

3.3 Konfigurationsschritte für TCP-Eingang​

  1. Server-Konfiguration:
    • Wählen Sie „Listen on port" (Servermodus)
    • Geben Sie die Portnummer ein (z. B. 49155)
  2. Datenverarbeitung:
    • Data mode: Wählen Sie „Stream" für kontinuierliche Daten
    • Data type: Wählen Sie „UTF8" für Text oder „Buffer" für Binärdaten
  3. Erweiterte Einstellungen:
    • New line character: Leer lassen, sofern kein spezifisches Trennzeichen erforderlich ist
    • Topic: Optionaler Bezeichner für das Message-Routing
  4. Klicken Sie auf Done, um die Konfiguration zu speichern

3.4 Richtlinien zur Portauswahl​

PortbereichVerwendungEmpfehlung
1-1023SystemreserviertVermeiden
1024-49151Registrierte PortsVerfügbarkeit prüfen
49152-65535Dynamisch/privatEmpfohlen

Schritt 4: TCP-Ausgang konfigurieren (Daten senden)​

4.1 TCP-Ausgangsknoten hinzufügen​

  1. "tcp out"-Knoten suchen im linken Bereich (Sektion Network)
  2. "tcp out"-Knoten ziehen auf die Flow-Arbeitsfläche
  3. Doppelklick auf den Knoten zur Konfiguration

image.png

4.2 TCP-Ausgangseinstellungen konfigurieren​

Knotenkonfiguration:

EinstellungWertBeschreibung
TypeConnect toKamera fungiert als Client
Host192.168.0.200IP-Adresse des Zielgeräts
Port49155Port des Zielgeräts
ModeClientAusgehende Verbindung

4.3 Konfigurationsschritte für TCP-Ausgang​

  1. Verbindungseinstellungen:
    • Type: "Connect to" auswählen (Client-Modus)
    • Host: IP-Adresse des Zielgeräts eingeben
    • Port: Portnummer des Zielgeräts eingeben
  2. Verbindungsoptionen:
    • Mode: Auf "Client" belassen
    • End connection: Je nach Anwendungsfall konfigurieren
  3. Datenformat:
    • Base64: Für Textdaten normalerweise deaktiviert
    • TLS: Nur aktivieren, wenn eine sichere Verbindung erforderlich ist
  4. Auf Done klicken, um die Konfiguration zu speichern

Schritt 5: Kommunikationsfluss erstellen​

5.1 Vollständigen Flow aufbauen​

Erstellen Sie einen Flow, der TCP-Daten sowohl senden als auch empfangen kann:

  1. Fügen Sie diese Knoten zu Ihrer Arbeitsfläche hinzu:
    • Inject-Knoten (zum Auslösen von Nachrichten)
    • Function-Knoten (zur Nachrichtenverarbeitung)
    • TCP Out-Knoten (zum Senden von Daten)
    • TCP In-Knoten (zum Empfangen von Daten)
    • Debug-Knoten (zur Überwachung)

5.2 Inject-Knoten konfigurieren​

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

5.3 Function-Knoten konfigurieren​

Der Function-Knoten formatiert Ihre ausgehende Nachricht:

msg.payload = "Hello from OV20i camera";
return msg;

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

5.4 Verbindungen verdrahten​

Verbinden Sie die Knoten in dieser Reihenfolge:

Ausgehender Flow:

  • Inject → Function → TCP Out
  • Function → Debug (zur Anzeige ausgehender Nachrichten)

Eingehender Flow:

  • TCP In → Debug (zur Anzeige eingehender Nachrichten)

5.5 Vollständige Flow-Struktur​

Ihr fertiger Flow sollte folgendes enthalten:

  • Inject verbunden mit Function
  • Function verbunden mit TCP Out und Debug
  • TCP In verbunden mit einem separaten Debug-Knoten

Ergebnis: Sie können Nachrichten durch Klicken auf den Inject-Button senden und sowohl ausgehende als auch eingehende Nachrichten im Debug-Panel anzeigen.

Schritt 6: Nachrichtenformat konfigurieren​

6.1 Nachrichtenformat definieren​

Halten Sie die Nachrichtenstruktur einfach:

NachrichtentypFormatBeispiel
Einfacher TextReine Zeichenkette"Hello from camera"
StatusmeldungenText mit Informationen"STATUS: READY"
DatenwerteSchlüssel-Wert-Format"TEMPERATURE: 25.5"

6.2 Beispiele für benutzerdefinierte Nachrichten​

Sie können den Function-Node für verschiedene Nachrichtentypen anpassen:

Einfache Statusnachricht:

msg.payload = "Camera Ready";
return msg;

Zeitstempel-Nachricht:

msg.payload = "Time: " + new Date().toLocaleString();
return msg;

Daten mit Werten:

msg.payload = "INSPECTION_COUNT: 42";
return msg;

Schritt 7: Konfiguration bereitstellen und testen​

7.1 Node-RED Flow bereitstellen​

  1. Klicken Sie auf die Schaltfläche Deploy (obere rechte Ecke)
  2. Bestätigen Sie die Erfolgsmeldung der Bereitstellung
  3. Überprüfen Sie die Statusanzeigen der Nodes:
    • Grüner Punkt: Erfolgreich verbunden
    • Roter Punkt: Verbindungsfehler
    • Gelber Punkt: Verbindungsaufbau läuft

7.2 TCP-Kommunikation testen​

7.2.1 Grundlegender Verbindungstest​

Mit Kommandozeilen-Tools:

# Test TCP connection (Linux/Mac)
telnet [camera-ip] [port]
# Example: telnet 192.168.0.100 49155

# Test with netcat
nc [camera-ip] [port]
# Example: nc 192.168.0.100 49155

Windows PowerShell:

Test-NetConnection -ComputerName 192.168.0.100 -Port 49155

7.2.2 Testnachrichten senden​

  1. Mit dem TCP-Port der Kamera verbinden
  2. Testbefehle senden:
    • "STATUS" → Sollte eine Statusantwort empfangen
    • "TRIGGER" → Sollte eine Inspektion auslösen
    • "INVALID" → Sollte einen unbekannten Befehl verarbeiten

7.2.3 Debug-Ausgabe überwachen​

  1. Öffnen Sie das Node-RED Debug-Panel (rechte Seitenleiste)
  2. Senden Sie Testnachrichten über TCP
  3. Überprüfen Sie, ob die Debug-Ausgabe Folgendes anzeigt:
    • Eingehende Nachrichten
    • Verarbeitungsergebnisse
    • Ausgehende Antworten

7.3 Validierungs-Checkliste​

TestErwartetes ErgebnisStatus
TCP-VerbindungErfolgreiche Verbindung zum Kameraport☐
NachrichtenempfangDebug zeigt eingehende Nachrichten☐
NachrichtenverarbeitungFunction-Node verarbeitet korrekt☐
AntwortversandZielgerät empfängt Antworten☐
FehlerbehandlungUngültige Nachrichten werden ordnungsgemäß behandelt☐

Schritt 8: Integration in das Inspektionssystem​

8.1 Verbindung mit Inspektionstriggern​

TCP-Kommunikation mit dem Inspektions-Workflow verknüpfen:

  1. Fügen Sie den Node "All Block Outputs" hinzu (falls nicht bereits vorhanden)
  2. Verbinden Sie die Inspektionsergebnisse mit dem TCP-Ausgang
  3. Formatieren Sie die Inspektionsdaten für die TCP-Übertragung

8.2 Integration von Inspektionsdaten​

Function-Node zur Verarbeitung von Inspektionsergebnissen:

// Get inspection results from All Block Outputs
const results = msg.payload;

// Extract key information
const inspectionSummary = {
    result: results.pass ? "PASS" : "FAIL",
    timestamp: new Date().toISOString(),
    processing_time: results.processing_time,
    roi_count: results.roi_results ? results.roi_results.length : 0
};

// Format for TCP transmission
msg.payload = JSON.stringify(inspectionSummary);
return msg;

8.3 Bidirektionale Steuerung​

Fernsteuerung über TCP ermöglichen:

// Handle remote commands
const command = msg.payload.toString().toUpperCase();

switch(command) {
    case "START_INSPECTION":
        // Trigger inspection sequence
        global.set("trigger_inspection", true);
        msg.payload = "INSPECTION_STARTED";
        break;

    case "STOP_INSPECTION":
        // Stop inspection sequence
        global.set("trigger_inspection", false);
        msg.payload = "INSPECTION_STOPPED";
        break;

    case "CHANGE_RECIPE":
        // Recipe change logic
        msg.payload = "RECIPE_CHANGED";
        break;
}

return msg;

Schritt 9: Fehlerbehebung bei häufigen Problemen​

9.1 Verbindungsprobleme​

ProblemSymptomeLösung
Keine Verbindung möglichRote StatusanzeigeIP-Adresse und Port prüfen
VerbindungsabbrücheSporadisch gelber StatusNetzwerkstabilität überprüfen
Timeout-FehlerVerzögerte AntwortenTimeout-Einstellungen anpassen
Port-KonflikteVerbindung abgelehntAndere Portnummer verwenden

9.2 Probleme bei der Datenübertragung​

ProblemSymptomeLösung
Keine Daten empfangenDebug zeigt leere NachrichtenEinstellungen zum Datenformat prüfen
Beschädigte DatenUnleserlicher Text im DebugKodierung überprüfen (UTF8/Buffer)
NachrichtenverlustFehlende NachrichtenNetzwerkstabilität überprüfen
Probleme bei großen NachrichtenAbgeschnittene DatenKürzere Nachrichten verwenden

9.3 Debug-Techniken​

Systematische Fehlerbehebung:

  1. Debug-Nodes aktivieren bei jedem Schritt
  2. Node-RED-Logs überwachen auf Fehler
  3. Zuerst mit einfachen TCP-Clients testen
  4. Netzwerkverbindung mit Ping überprüfen

Erfolgreich! Ihre TCP-Kommunikation ist einsatzbereit​

Ihr TCP-Kommunikationssystem kann jetzt:

  • Daten senden und empfangen zwischen Kamera und externen Geräten
  • Einfache Nachrichten verarbeiten für die grundlegende Kommunikation
  • Datenfluss überwachen mit Debug-Nodes
  • Grundlegende Netzwerkkommunikation handhaben für Ihre Anwendungen

Laufende Wartung​

Regelmäßige Systemprüfungen​

  • Verbindungsstabilität überwachen über die Zeit
  • Datenübertragung überprüfen auf konsistente Funktion
  • Debug-Logs prüfen auf Fehlermuster
  • Kommunikation testen nach Netzwerkänderungen

Nächste Schritte​

Nach der Einrichtung der grundlegenden TCP-Kommunikation:

  1. Mit Ihren externen Systemen testen über die etablierte Verbindung
  2. Nachrichtenformate anpassen an Ihre spezifischen Anforderungen
  3. Komplexere Logik hinzufügen, wenn Ihre Anforderungen wachsen
  4. Andere Kommunikationsmethoden in Betracht ziehen, falls TCP nicht alle Anforderungen erfüllt

🔗 Siehe auch​

Für Anwendungen mit hohem Datendurchsatz:​

  1. Nachrichtenhäufigkeit reduzieren
  2. Mehrere Nachrichten bündeln
  3. Binärformat für große Daten verwenden
  4. Komprimierung implementieren

Debug-Techniken​

Systematische Fehlerbehebung:

  1. Debug-Nodes aktivieren bei jedem Schritt
  2. Node-RED-Logs überwachen auf Fehler
  3. Netzwerk-Monitoring-Tools verwenden (Wireshark)
  4. Zuerst mit einfachen TCP-Clients testen

Erfolgreich! Ihre TCP-Kommunikation ist einsatzbereit​

Ihr TCP-Kommunikationssystem kann jetzt:

  • Daten senden und empfangen zwischen Kamera und externen Geräten
  • Befehle verarbeiten für die Fernsteuerung
  • Inspektionsergebnisse übertragen in Echtzeit
  • Fehler zuverlässig handhaben mit ordnungsgemäßer Fehlerbehandlung
  • In Produktionssysteme integrieren für automatisierte Workflows

Laufende Wartung​

Regelmäßige Systemprüfungen​

  • Verbindungsstabilität überwachen über längere Zeiträume
  • Datenintegrität in der Produktion überprüfen
  • Sicherheitskonfigurationen aktualisieren bei Bedarf
  • Leistung optimieren basierend auf Nutzungsmustern

Leistungsüberwachung​

  • Nachrichtendurchsatz und Latenz erfassen
  • Fehlerraten und Verbindungsausfälle überwachen
  • Datenmuster analysieren, um Optimierungspotenziale zu erkennen

Nächste Schritte​

Nach der Einrichtung der TCP-Kommunikation:

  1. Integrieren Sie Ihre externen Systeme über das eingerichtete Protokoll
  2. Implementieren Sie eine umfassende Fehlerbehandlung für den Produktivbetrieb
  3. Richten Sie Logging und Monitoring zur Überwachung des Systemzustands ein
  4. Erwägen Sie Sicherheitserweiterungen für den Produktiveinsatz

🔗 Siehe auch​