Zum Hauptinhalt springen

KI-GESTÜTZTE DOKUMENTATION

Was möchten Sie wissen?

Debugging von Node-RED

Diese Anleitung bietet umfassende Fehlerbehebungsverfahren für Node-RED-Probleme auf dem OV20i-Kamerasystem. Verwenden Sie sie für Reparaturen vor Ort, das Debuggen von Produktionsproblemen und die vorbeugende Wartung von Inspektionsflüssen.

warnung

Sicherheit zuerst: Informieren Sie die Produktion immer, bevor Sie Änderungen an aktiven Inspektionssystemen vornehmen. Erstellen Sie Backups, bevor Sie Flows ändern.

Notfall-Schnellbehebungsverfahren​

Kritischer Systemausfall – Sofortmaßnahmen​

SchrittAktionZeitErgebnis
1LED-Status der Kamerastromversorgung prüfen30 Sek.Hardware-Funktion verifizieren
2OV20i Node-RED aufrufen: http://camera-ip/recipes/<recipe-number>/ioblock1 Min.Editor-Zugriff bestätigen
3Nach roten Dreieck-Fehleranzeigen suchen1 Min.Fehlerhafte Nodes identifizieren
4Auf Deploy-Schaltfläche klicken (Full Deploy)30 Sek.Alle Flows zurücksetzen
5Grundlegenden Inspektionstrigger testen2 Min.Systembetrieb verifizieren

Systemwiederherstellung (Wenn der Editor nicht lädt)​

OV20i-Kameras verfügen über keinen abgesicherten Modus – ein Neustart ist die primäre Wiederherstellungsmethode:

  1. Kamera vom Strom trennen (Stromkabel für 10 Sekunden abziehen)
  2. Vollständigen Bootvorgang abwarten (alle 4 LEDs stabil – 2-3 Minuten)
  3. Node-RED des aktiven Rezepts aufrufen über rezeptspezifische URL
  4. Flow-Integrität verifizieren und notwendige Korrekturen vornehmen
  5. Änderungen bereitstellen (Deploy), um den Normalbetrieb wiederherzustellen
hinweis

URL-Format: http://<camera-ip>/recipes/<recipe-number>/ioblock

Beispiele:

  • http://192.168.0.101/recipes/20/ioblock
  • http://192.168.0.105/recipes/1/ioblock

Systematischer Debugging-Prozess​

Schritt 1: Problemumfang identifizieren​

Fragen zur Schnellbewertung​

FrageWenn JAWenn NEIN
Können Sie auf die OV20i Node-RED-Oberfläche zugreifen?Weiter zu Schritt 2Netzwerk-/Kamerastatus prüfen
Sind Flows im Editor sichtbar?Weiter zu Schritt 2Kamera neu starten und erneut versuchen
Sehen Sie Fehlerdreiecke an Nodes?Zuerst auf diese Nodes konzentrierenFlow-Ausführung prüfen
Wird die Inspektion ausgelöst?Ausgänge einzelner Nodes prüfenTrigger-Eingänge verifizieren
hinweis

Zugriffs-URL: Verwenden Sie das rezeptspezifische URL-Format: http://<camera-ip>/recipes/<recipe-number>/ioblock

Schritt 2: Debug-Überwachung aktivieren​

Debug-Nodes für die Fehlersuche hinzufügen​

  1. Platzieren Sie Debug-Nodes an wichtigen Punkten in problematischen Flows:
    • Nach Trigger-Eingängen
    • Vor und nach Logik-Nodes
    • An den finalen Ausgängen
  2. Konfigurieren Sie Debug-Nodes für maximale Informationen:
    • Output: Vollständiges Message-Objekt
    • To: Debug-Sidebar
    • Name: Beschreibende Namen (z. B. „After Classification Logic")
  3. Aktivieren Sie alle Debug-Nodes, indem Sie auf ihre Schaltflächen im Editor klicken

Verwaltung der Debug-Sidebar​

Debug-Sidebar aufrufen:

  • Klicken Sie auf den Debug-Tab (Käfer-Symbol) im rechten Bereich
  • Alte Nachrichten löschen mit dem Papierkorb-Symbol
  • Nachrichten filtern, wenn zu viele Nodes aktiv sind

Interpretation der Debug-Nachrichten:

  • Zeitstempel zeigt, wann die Nachricht aufgetreten ist
  • Node-Name zeigt, welcher Node die Nachricht erzeugt hat
  • Nachrichteninhalt zeigt Datenstruktur und Werte

Schritt 3: Flow-Ausführung verfolgen​

Nachrichtenpfad nachverfolgen​

  1. Beginnen Sie an der Triggerquelle (Inject, Timer, externer Eingang)
  2. Überprüfen Sie, ob jeder Node die erwartete Eingabe erhält
  3. Prüfen Sie die Nachrichtentransformationen bei jedem Schritt
  4. Identifizieren Sie, wo der Flow stoppt oder eine falsche Ausgabe erzeugt

Häufige Unterbrechungspunkte im Flow​

Node-TypHäufige ProblemeSchnellprüfung
Classification LogicKonfidenzschwelle nicht erreichtROI-Ausrichtung prüfen, Modell neu trainieren
Switch NodeFalsche BedingungslogikSwitch-Regeln und Nachrichteneigenschaften überprüfen
Join NodeWartet auf unvollständigen NachrichtensatzAnzahl der Nachrichtenteile prüfen
Function NodeJavaScript-FehlerBrowser-Konsole auf Fehler prüfen
HTTP RequestNetzwerkverbindungEndpoint manuell testen

Häufige Node-RED-Probleme und Lösungen​

Probleme bei der Flow-Ausführung​

Problem: Flow wird nicht ausgelöst​

Symptome:

  • Keine Nachrichten in der Debug-Seitenleiste
  • System erscheint inaktiv
  • Externe Trigger funktionieren nicht

Diagnose-Schritte:

  1. Triggerquelle prüfen: Manuelles Inject, Timer, externer Eingang
  2. Verdrahtung überprüfen: Verbindungen zwischen Nodes sicherstellen
  3. Manuellen Trigger testen: Inject-Node verwenden, um den Flow-Start zu erzwingen

Lösungen:

UrsacheLösungPrävention
Deaktivierte FlowsDeploy → Full Deploy klickenRegelmäßiges Deployment nach Änderungen
Unterbrochene VerbindungenNodes korrekt neu verdrahtenVisuelle Inspektion während der Bearbeitung
Fehlerhafte Timer-KonfigurationTiming-Einstellungen des Inject-Nodes prüfenTiming-Anforderungen dokumentieren
Externer Trigger-AusfallI/O-Verdrahtung und Signale überprüfenRegelmäßige I/O-Tests

Problem: Flows laufen, aber liefern falsche Ergebnisse​

Symptome:

  • Nachrichten fließen, aber Klassifikationen sind fehlerhaft
  • Pass/Fail-Logik funktioniert nicht korrekt
  • Inkonsistente Ergebnisse

Diagnoseprozess:

  1. Debug-Nodes hinzufügen vor und nach verdächtigen Nodes
  2. Erwarteten und tatsächlichen Nachrichteninhalt vergleichen
  3. Node-Konfigurationen prüfen auf korrekte Parameter

Lösungen:

ProblembereichPrüfungBehebung
Classification LogicROI-Ausrichtung, ModelltrainingROI neu trainieren oder anpassen
Switch-BedingungenEigenschaftsnamen und -werteSwitch-Logik korrigieren
NachrichteneigenschaftenDatentypen und -formateChange-Node zur Formatkorrektur verwenden
KontextvariablenGespeicherte Werte und GültigkeitsbereichKontextspeicher leeren/zurücksetzen

Performance-Probleme​

Problem: Langsame Flow-Ausführung​

Symptome:

  • Verzögerungen zwischen Trigger und Ausgabe
  • Inspektions-Timeouts
  • Systemverzögerung

Performance-Diagnose:

  1. Debug-Zeitstempel prüfen, um langsame Nodes zu identifizieren
  2. CPU-Auslastung am Kamerasystem überwachen
  3. Aktive Debug-Nodes zählen (nicht benötigte deaktivieren)

Optimierungsmaßnahmen:

Performance-ProblemLösungErwartete Verbesserung
Zu viele Debug-NodesNicht benötigte Debug-Nodes deaktivieren/entfernen10–20 % Geschwindigkeitszunahme
Komplexe Function-NodesJavaScript-Code optimierenVariable Verbesserung
Hochfrequente TriggerVerzögerung/Rate Limiting hinzufügenSystemüberlastung verhindern
Große NachrichtenobjekteGröße der Nachrichten-Payload reduzierenSchnellere Verarbeitung

Wartungsverfahren​

Tägliche Funktionsprüfungen​

Visuelle Ablaufprüfung (5 Minuten)​

  1. Node-RED-Editor öffnen
  2. Auf Fehleranzeigen prüfen (rote Dreiecke)
  3. Flow-Verbindungen auf Vollständigkeit überprüfen
  4. Aktuelle Debug-Meldungen auf Anomalien prüfen

Flow-Ausführungstest (10 Minuten)​

  1. Manueller Auslösetest mithilfe von Inject-Nodes
  2. Erwartete Ausgaben in der Debug-Seitenleiste verifizieren
  3. Pass/Fail-Logik mit bekannten Gut-/Schlechtteilen testen
  4. Externe Kommunikation bestätigen (PLC, Datenbanken)

Monatliche Wartungsaufgaben​

Performance-Überprüfung (15 Minuten)​

Checkliste zur Flow-Optimierung:

AufgabeAktionHinweise
Bereinigung von Debug-NodesNicht genutzte Debug-Nodes deaktivierenNur wesentliche Debug-Funktionen beibehalten
Überprüfung des Context StorageUnnötig gespeicherte Werte löschenSpeicheranhäufung vermeiden
Fehlerprotokoll-ÜberprüfungBrowser-Konsole auf Fehler prüfenWiederkehrende Probleme dokumentieren
Backup-ErstellungFlows in Backup-Datei exportierenMit Datum/Versionsinformationen ablegen

Konfigurationsvalidierung (20 Minuten)​

  1. Aktuelle Flows mit dokumentierten Standards vergleichen
  2. Alle kritischen Pfade auf angemessene Fehlerbehandlung überprüfen
  3. Fehlerwiederherstellungs-Szenarien testen
  4. Dokumentation bei Änderungen aktualisieren

Monatliche Tiefenwartung​

Umfassende Flow-Analyse (45 Minuten)​

Erfassung von Performance-Metriken:

  • Flow-Ausführungszeiten
  • Analyse der Fehlerhäufigkeit
  • Muster der Ressourcennutzung
  • Zuverlässigkeit der Kommunikation

Überprüfung der Flow-Struktur:

  • Redundante Nodes entfernen
  • Doppelte Logik konsolidieren
  • Veraltete Konfigurationen aktualisieren
  • Komplexe Function-Nodes optimieren

Backup- und Wiederherstellungstests (30 Minuten)​

  1. Vollständigen Flow-Export erstellen
  2. Importvorgang auf einem Backup-System testen
  3. Wiederherstellung des Backups auf Funktionsfähigkeit prüfen
  4. Wiederherstellungsverfahren dokumentieren

Diagnose-Tools und -Techniken​

Integrierte Node-RED-Tools​

Funktionen der Debug-Seitenleiste​

FunktionAnwendungsfallZugriffsmethode
NachrichtenfilterungFokus auf bestimmte NodesFilter-Schaltfläche in der Seitenleiste
NachrichtenverlaufLetzte 100 Nachrichten einsehenIn der Debug-Seitenleiste scrollen
Node-LokalisierungQuelle der Debug-Meldung findenNode-Name in der Nachricht anklicken
NachrichtenexportDiagnosedaten speichernNachrichteninhalt kopieren

Context Data Explorer​

Zugriff auf Context Storage:

  • OV20i Node-RED-Oberfläche öffnen (http://<camera-ip>/recipes/<recipe-number>/ioblock)
  • Zum Tab „Context Data" wechseln (rechte Seitenleiste)
  • Werte für Node-/Flow-/Global-Context anzeigen

Context-Debugging:

  • Node Context: Zustand einzelner Nodes prüfen
  • Flow Context: Gemeinsam genutzte Flow-Variablen verifizieren
  • Global Context: Systemweite Einstellungen überprüfen

Test der Netzwerkkommunikation​

Validierung von HTTP-Anfragen:

  1. Externe Tools verwenden (Postman, curl), um Endpunkte zu testen
  2. Antwortformate auf Übereinstimmung mit erwarteten Daten prüfen
  3. Fehlerbedingungen testen (Timeouts, ungültige Antworten)

Überprüfung der PLC-Kommunikation:

  1. PLC-Programmiersoftware verwenden, um die Konnektivität zu prüfen
  2. Zugriff auf Datenregister unabhängig testen
  3. Datenformatkonvertierungen validieren

Notfall-Wiederherstellungsverfahren​

Wiederherstellung bei beschädigten Flows​

Symptome einer Beschädigung:​

  • OV20i Node-RED-Oberfläche lädt keine Flows
  • Flows erscheinen nach Kameraneustart leer
  • Deployment schlägt wiederholt fehl

Wiederherstellungsschritte:​

  1. OV20i-Kamera vom Stromnetz trennen:
    • Stromversorgung für 10 Sekunden trennen
    • Auf vollständigen Bootvorgang warten (alle 4 LEDs leuchten stabil)
  2. Auf Node-RED-Oberfläche des Rezepts zugreifen:
    • Navigieren Sie zu http://<camera-ip>/recipes/<recipe-number>/ioblock
    • Bei beschädigten Flows aus Backup importieren
  3. Aus Backup wiederherstellen:
    • OV20i-Rezeptimportfunktion verwenden
    • Aktuellste Backup-Datei importieren
    • Alle Verbindungen auf Integrität prüfen
  4. Wiederherstellung validieren:
    • Alle kritischen Flows testen
    • Externe Kommunikation überprüfen
    • Konfigurationsänderungen aktualisieren

Probleme mit Systemressourcen​

Speicher-/CPU-Überlastung​

Sofortmaßnahmen:

  1. Nicht benötigte Debug-Nodes deaktivieren in OV20i Node-RED
  2. Hochfrequente Timer-Trigger entfernen
  3. Komplexe Function-Nodes vereinfachen
  4. Kamera neu starten, um alle Dienste neu zu starten

Langfristige Lösungen:

  • Flow-Design für OV20i-Hardware optimieren
  • Rate Limiting implementieren
  • Größe der Nachrichten-Payloads reduzieren
  • Wartungsfenster einplanen

Troubleshooting-Checklisten​

Checkliste vor der Wartung​

  • Produktion informieren über das Wartungsfenster
  • Aktuelles Flow-Backup erstellen
  • Aktuellen Systemzustand dokumentieren
  • Rollback-Verfahren vorbereiten
  • Backup-Wiederherstellungsprozess testen

Validierung nach der Wartung​

  • Alle Flows werden erfolgreich deployed
  • Manuelle Trigger-Tests bestanden
  • Externe Kommunikation überprüft
  • Fehleranzeigen zurückgesetzt
  • Leistung im akzeptablen Bereich
  • Dokumentation aktualisiert

Checkliste für Notfallreaktion​

  • Systemauswirkungen bewertet
  • Produktion benachrichtigt
  • Schnellbehebung versucht
  • Backup-Wiederherstellung bei Bedarf
  • Grundursache identifiziert
  • Präventivmaßnahmen umgesetzt

Dokumentation und Protokollierung​

Wartungsprotokolle​

Erforderliche Dokumentation:

  • Datum/Uhrzeit der Wartung
  • Identifizierte und behobene Probleme
  • Vorgenommene Konfigurationsänderungen
  • Erzielte Leistungsverbesserungen
  • Empfehlungen für die Zukunft

🔗 Siehe auch​

tipp

Dokumentieren Sie alle Änderungen, die während der Debugging-Sitzungen vorgenommen wurden. Dies erleichtert zukünftiges Troubleshooting und baut institutionelles Wissen für Ihr Team auf.