Zum Inhalt springen

rbdimmerESP32 Fehlerbehebungsanleitung

Aktualisiert für v2.0.0 -- enthält Korrekturen für vier Flimmerprobleme, die während der Validierung von 4-Kanal-Hardware entdeckt wurden.

Schnelle Diagnose-Checkliste

Bevor Sie sich in die detaillierte Fehlerbehebung vertiefen, arbeiten Sie diese schnelle Checkliste durch:

Grundlegende Systemprüfung

  • ESP32-Board korrekt in der IDE ausgewählt
  • ESP-IDF 5.3 oder später (bei Verwendung des ESP-IDF-Frameworks)
  • Bibliothek ordnungsgemäß installiert und eingebunden
  • Alle Verdrahtungsverbindungen sicher
  • Stromversorgung ausreichend (3,3 V, >500 mA)
  • Dimmer-Modul mit Strom versorgt und betriebsbereit
  • AC-Last mit Dimmung kompatibel
  • Sicherheitsverfahren befolgt

    • Schnelltest-Code

    Führen Sie diesen minimalen Test aus, um die grundlegende Funktionalität zu überprüfen:

    cpp
    #include 
void setup() {
    Serial.begin(115200);
    delay(2000);
    Serial.println("=== RBDimmer Quick Diagnostic ===");
    // Test 1: Library initialization
    rbdimmer_err_t err = rbdimmer_init();
    Serial.printf("1. Library Init: %s (%d)\n",
                  (err == RBDIMMER_OK) ? "OK" : "FAILED", err);
    // Test 2: Zero-cross registration
    err = rbdimmer_register_zero_cross(2, 0, 50);
    Serial.printf("2. Zero-Cross Registration: %s (%d)\n",
                  (err == RBDIMMER_OK) ? "OK" : "FAILED", err);
    // Test 3: Channel creation
    rbdimmer_channel_t* channel;
    rbdimmer_config_t config = {4, 0, 0, RBDIMMER_CURVE_LINEAR};
    err = rbdimmer_create_channel(&config, &channel);
    Serial.printf("3. Channel Creation: %s (%d)\n",
                  (err == RBDIMMER_OK) ? "OK" : "FAILED", err);
    if (err == RBDIMMER_OK) {
        Serial.println("Basic functionality working");
        Serial.println("Check hardware connections for full operation");
    } else {
        Serial.println("Basic functionality failed");
        Serial.println("Check installation and wiring");
    }
}
void loop() {
    delay(1000);
}

    Kompilierungsprobleme

    Problem: Bibliothek nicht gefunden

    Fehlermeldungen:

    plaintext
    fatal error: rbdimmerESP32.h: No such file or directory

    Lösungen:

    Arduino IDE

    1. Installation überprüfen: - Überprüfen Sie File -> Examples -> rbdimmerESP32 - Falls nicht sichtbar, Bibliothek nicht ordnungsgemäß installiert

    2. Bibliothek neu installieren: Sketch -> Include Library -> Manage Libraries Search "rbdimmerESP32" -> Install

    3. Manuelle Installationsprüfung: - Bibliothek sollte sich befinden in: ~/Documents/Arduino/libraries/rbdimmerESP32/ - Stellen Sie sicher, dass rbdimmerESP32.h sich im src/-Ordner befindet

    Problem: Kompilierungsfehler

    Fehlermeldungen:

    plaintext
    error: 'micros' was not declared in this scope
error: 'digitalRead' was not declared in this scope

    Lösungen:

    1. Überprüfen Sie die Board-Auswahl: - Muss ESP32-Board-Typ sein - Arduino IDE: Tools -> Board -> ESP32

    2. Update ESP32 Core: - Arduino IDE: Tools -> Board -> Boards Manager - Search "ESP32" -> Update to latest version - ESP-IDF users: v5.3 or later required

    3. Überprüfen Sie das Framework:

    Fehlermeldungen:

    plaintext
    error: conflicting declaration of C function

    Lösungen:

    1. Überprüfen Sie mehrfache Einbindungen: - Nur rbdimmerESP32.h einmal pro Datei einbinden - Nach Konflikten mit anderen Dimmer-Bibliotheken überprüfen

    2. Bereinigter Neubau: - Build-Ordner löschen und neu kompilieren

    Problem: Linker-Fehler

    Fehlermeldungen:

    plaintext
    undefined reference to `rbdimmer_init'

    Lösungen:

    1. ESP-IDF-Komponenten-Setup: cmake # In main/CMakeLists.txt idf_component_register( SRCS "main.c" INCLUDE_DIRS "." REQUIRES rbdimmerESP32 )

    Die Bibliothek nutzt eine modulare Architektur mit einer eigenen Kconfig-Datei. ESP-IDF nimmt automatisch die Kconfig-Optionen auf, wenn die Komponente korrekt registriert ist.

    Problem: Bibliotheks-Initialisierung schlägt fehl

    Symptoms: - rbdimmer_init() returns non-zero error code - System doesn't respond to commands

    Diagnose-Code:

    cpp
    void diagnose_init() {
    Serial.println("Diagnosing initialization...");
    rbdimmer_err_t err = rbdimmer_init();
    switch(err) {
        case RBDIMMER_OK:
            Serial.println("Initialization successful");
            break;
        case RBDIMMER_ERR_NO_MEMORY:
            Serial.println("Memory allocation failed");
            Serial.printf("Free heap: %d bytes\n", ESP.getFreeHeap());
            break;
        default:
            Serial.printf("Unknown error: %d\n", err);
    }
}

    Lösungen:

    1. Speicherprobleme: - Verfügbaren Heap-Speicher überprüfen - Andere Speichernutzung reduzieren - Heap-Größe wenn möglich erhöhen

    2. Mehrfach-Initialisierungen: - Rufen Sie rbdimmer_init() nur einmal auf - Nach doppelten Aufrufen überprüfen

    Problem: Zero-Cross-Registrierung schlägt fehl

    Fehlercodes und Lösungen:

    RBDIMMER_ERR_INVALID_ARG

    cpp
    // Check pin number validity
void check_pin_validity() {
    uint8_t test_pin = 2;
    if (test_pin >= GPIO_NUM_MAX) {
        Serial.printf("Invalid pin number: %d\n", test_pin);
    }
    // Check if pin is available
    if (test_pin == 0 || test_pin == 1 || test_pin == 3) {
        Serial.println("Warning: Using boot/serial pin");
    }
}

    Lösungen: - Verwenden Sie GPIO-Pins 2, 4, 5, 12-15, 25-27 - Vermeiden Sie Pins 0, 1, 3 (Boot/Seriell) - Vermeiden Sie Pins 6-11 (Flash-Speicher)

    RBDIMMER_ERR_ALREADY_EXIST

    cpp
    // Check for duplicate phase registration
for(int phase = 0; phase < 4; phase++) {
    rbdimmer_err_t err = rbdimmer_register_zero_cross(2+phase, phase, 0);
    if (err == RBDIMMER_ERR_ALREADY_EXIST) {
        Serial.printf("Phase %d already registered\n", phase);
    }
}

    Lösungen: - Überprüfen Sie auf doppelte rbdimmer_register_zero_cross()-Aufrufe - Verwenden Sie rbdimmer_deinit() zum Zurücksetzen, falls erforderlich

    Problem: Kanalerstellung schlägt fehl

    Diagnose-Code:

    cpp
    void diagnose_channel_creation() {
    rbdimmer_config_t config = {4, 0, 0, RBDIMMER_CURVE_LINEAR};
    rbdimmer_channel_t* channel;
    rbdimmer_err_t err = rbdimmer_create_channel(&config, &channel);
    switch(err) {
        case RBDIMMER_OK:
            Serial.println("Channel created successfully");
            break;
        case RBDIMMER_ERR_NOT_FOUND:
            Serial.printf("Phase %d not registered\n", config.phase);
            break;
        case RBDIMMER_ERR_NO_MEMORY:
            Serial.println("No memory or max channels reached");
            Serial.printf("Free heap: %d bytes\n", ESP.getFreeHeap());
            break;
        case RBDIMMER_ERR_GPIO_FAILED:
            Serial.printf("GPIO %d configuration failed\n", config.gpio_pin);
            break;
        case RBDIMMER_ERR_TIMER_FAILED:
            Serial.println("Timer allocation failed");
            break;
        default:
            Serial.printf("Unknown error: %d\n", err);
    }
}

    Lösungen:

    1. Phase nicht registriert: - Registrieren Sie zunächst den Zero-Cross-Detektor - Überprüfen Sie, ob die Phasennummer stimmt

    2. Speicherprobleme: - Maximal 8 Kanäle unterstützt - Jeder Kanal nutzt ca. 200 Bytes RAM - Speicher freigeben, falls erforderlich

    3. GPIO-Probleme: - Versuchen Sie einen anderen GPIO-Pin - Überprüfen Sie auf Pin-Konflikte mit anderem Code

    Probleme mit Hardwareverbindungen

    Problem: Keine Zero-Cross-Erkennung

    Symptome: - rbdimmer_get_frequency() gibt 0 zurück - Keine Dimm-Antwort

    Diagnose-Code:

    cpp
    void diagnose_zero_cross() {
    Serial.println("Zero-cross diagnostic starting...");
    // Test 1: Pin state monitoring
    pinMode(2, INPUT);
    Serial.println("Monitoring zero-cross pin for 10 seconds...");
    int high_count = 0, low_count = 0;
    unsigned long start_time = millis();
    while(millis() - start_time < 10000) {
        if(digitalRead(2)) {
            high_count++;
        } else {
            low_count++;
        }
        delayMicroseconds(100);
    }
    Serial.printf("High readings: %d, Low readings: %d\n", high_count, low_count);
    if(high_count == 0) {
        Serial.println("Pin always LOW - check connections");
    } else if(low_count == 0) {
        Serial.println("Pin always HIGH - check connections");
    } else {
        Serial.println("Pin changing states - wiring OK");
    }
    // Test 2: Frequency measurement
    rbdimmer_init();
    rbdimmer_register_zero_cross(2, 0, 0);
    Serial.println("Measuring frequency for 30 seconds...");
    for(int i = 0; i < 30; i++) {
        delay(1000);
        uint16_t freq = rbdimmer_get_frequency(0);
        Serial.printf("Frequency: %d Hz\n", freq);
        if(freq > 0) {
            Serial.println("Frequency detected successfully");
            break;
        }
    }
}

    Lösungen:

    1. Überprüfen Sie physische Verbindungen: - Überprüfen Sie die Zero-Cross-Ausgabe-Pin-Verbindung - Überprüfen Sie die Masseverbindung zwischen ESP32 und Dimmer-Modul - Stellen Sie sicher, dass das Dimmer-Modul mit Strom versorgt ist

    2. Testen Sie das Dimmer-Modul: - Verwenden Sie ein Multimeter zur Überprüfung der Zero-Cross-Ausgabe (DC-Spannung) - Sollte ~3,3 V Impulse mit Netzfrequenz zeigen - Wenn kein Signal vorhanden, kann das Dimmer-Modul defekt sein

    3. Versuchen Sie einen anderen Pin: cpp // Test different GPIO pins uint8_t test_pins[] = {2, 4, 5, 12, 13, 14, 15}; for(int i = 0; i < sizeof(test_pins); i++) { Serial.printf("Testing pin %d\n", test_pins[i]); // Test each pin... }

    Problem: TRIAC schaltet nicht

    Symptoms: - Load doesn't respond to dimming commands - Always full on or full off

    Diagnose-Code:

    cpp
    void diagnose_triac_control() {
    Serial.println("TRIAC control diagnostic...");
    // Test 1: GPIO output test
    pinMode(4, OUTPUT);
    Serial.println("Manual GPIO test - watch for LED/scope");
    for(int i = 0; i < 10; i++) {
        digitalWrite(4, HIGH);
        Serial.println("GPIO HIGH");
        delay(500);
        digitalWrite(4, LOW);
        Serial.println("GPIO LOW");
        delay(500);
    }
    // Test 2: Library control test
    rbdimmer_init();
    rbdimmer_register_zero_cross(2, 0, 50); // Fixed frequency for test
    rbdimmer_config_t config = {4, 0, 0, RBDIMMER_CURVE_LINEAR};
    rbdimmer_channel_t* channel;
    rbdimmer_create_channel(&config, &channel);
    Serial.println("Testing dimmer levels...");
    for(int level = 0; level <= 100; level += 25) {
        rbdimmer_set_level(channel, level);
        Serial.printf("Level: %d%%, Delay: %d us\n",
                      level, rbdimmer_get_delay(channel));
        delay(2000);
    }
}

    Lösungen:

    1. Überprüfen Sie die Gate-Steuerverbindung: - Überprüfen Sie GPIO-Pin zum Dimmer-Gate-Eingang - Stellen Sie sicher, dass die Polarität korrekt ist - Überprüfen Sie auf lockere Verbindungen

    2. Test mit LED-Anzeige: cpp // Add LED to gate control pin pinMode(4, OUTPUT); // LED should pulse with dimming

    3. Dimmer-Modul-Probleme: - Überprüfen Sie die Stromversorgung des Moduls - Überprüfen Sie, ob das Modul für 3,3 V Logik ausgelegt ist - Test mit anderem Dimmer-Modul

    Problem: Erratisches Dimm-Verhalten

    Symptome: - Inkonsistente Helligkeitsstufen - Flimmern oder Springen - Zufälliges Ein/Ausschalten

    Diagnose-Code:

    cpp
    void diagnose_stability() {
    Serial.println("Stability diagnostic...");
    rbdimmer_init();
    rbdimmer_register_zero_cross(2, 0, 0);
    rbdimmer_config_t config = {4, 0, 50, RBDIMMER_CURVE_RMS};
    rbdimmer_channel_t* channel;
    rbdimmer_create_channel(&config, &channel);
    // Monitor frequency stability
    Serial.println("Monitoring frequency stability...");
    uint16_t freq_readings[60];
    for(int i = 0; i < 60; i++) {
        delay(1000);
        freq_readings[i] = rbdimmer_get_frequency(0);
        Serial.printf("Freq[%d]: %d Hz\n", i, freq_readings[i]);
    }
    // Analyze stability
    uint16_t min_freq = 1000, max_freq = 0;
    for(int i = 0; i < 60; i++) {
        if(freq_readings[i] > 0) {
            if(freq_readings[i] < min_freq) min_freq = freq_readings[i];
            if(freq_readings[i] > max_freq) max_freq = freq_readings[i];
        }
    }
    Serial.printf("Frequency range: %d - %d Hz\n", min_freq, max_freq);
    if(max_freq - min_freq > 2) {
        Serial.println("Frequency unstable - check power quality");
    } else {
        Serial.println("Frequency stable");
    }
}

    Lösungen:

    1. Stromversorgungsprobleme: - Überprüfen Sie die Stabilität der ESP32-Stromversorgung - Verwenden Sie einen hochwertigen Stromadapter (>500 mA) - Fügen Sie Filterungskondensatoren zur Stromversorgung hinzu

    2. Elektrische Störungen: - Trennen Sie Nieder- und AC-Verdrahtung - Fügen Sie Ferritkerne an Kabeln hinzu - Verwenden Sie abgeschirmte Kabel, falls erforderlich

    3. Last-Probleme: - Test mit verschiedenen Last-Typen - Überprüfen Sie Last-Kompatibilität - Überprüfen Sie, ob Last-Strom innerhalb der Dimmer-Bewertung liegt

    4. Zero-Cross-Rauschen (v2.0.0): - Siehe Abschnitt Dimm- und Flimmerprobleme für ZC-Entprellungs-Tuning

    Leistungsprobleme

    Problem: Genauigkeit beim Timing

    Symptoms: - Dimming levels don't match expected brightness - Timing measurements show variations

    Diagnose-Code:

    cpp
    void diagnose_timing() {
    Serial.println("Timing accuracy diagnostic...");
    rbdimmer_init();
    rbdimmer_register_zero_cross(2, 0, 50);
    rbdimmer_config_t config = {4, 0, 0, RBDIMMER_CURVE_LINEAR};
    rbdimmer_channel_t* channel;
    rbdimmer_create_channel(&config, &channel);
    // Test timing at different levels
    for(int level = 10; level <= 90; level += 10) {
        rbdimmer_set_level(channel, level);
        uint32_t delay_us = rbdimmer_get_delay(channel);
        uint16_t freq = rbdimmer_get_frequency(0);
        uint32_t half_cycle_us = 1000000 / (2 * freq);
        Serial.printf("Level: %d%%, Delay: %d us, Half-cycle: %d us, Ratio: %.1f%%\n",
                      level, delay_us, half_cycle_us,
                      (float)delay_us / half_cycle_us * 100.0);
        delay(1000);
    }
}

    Lösungen:

    1. Überprüfen Sie die Systemauslastung: ```cpp void check_system_load() { unsigned long start = millis(); // Run normal operations for 10 seconds while(millis() - start < 10000) { // Your normal loop code here delay(10); }

      unsigned long actual_time = millis() - start; Serial.printf("Expected: 10000ms, Actual: %dms\n", actual_time); if(actual_time > 10100) { Serial.println("System overloaded - optimize code"); } } ```

    2. Optimieren Sie die Interrupt-Verarbeitung: - Halten Sie ISR-Code minimal - Vermeiden Sie Serial.print() in Callbacks - Verwenden Sie FreeRTOS-Warteschlangen zur Datenübertragung

    3. Überprüfen Sie die CPU-Uhr: cpp void check_cpu_clock() { Serial.printf("CPU Frequency: %d MHz\n", ESP.getCpuFreqMHz()); if(ESP.getCpuFreqMHz() < 240) { Serial.println("Consider increasing CPU frequency"); } }

    Problem: Speicherprobleme

    Symptome: - Systemabstürze oder Rückstellungen - Kanalerstellung schlägt fehl - Erratisches Verhalten

    Diagnose-Code:

    cpp
    void diagnose_memory() {
    Serial.println("Memory diagnostic...");
    Serial.printf("Free heap at start: %d bytes\n", ESP.getFreeHeap());
    Serial.printf("Minimum free heap: %d bytes\n", ESP.getMinFreeHeap());
    Serial.printf("Heap size: %d bytes\n", ESP.getHeapSize());
    rbdimmer_init();
    Serial.printf("After init: %d bytes\n", ESP.getFreeHeap());
    // Create maximum channels
    rbdimmer_register_zero_cross(2, 0, 50);
    rbdimmer_channel_t* channels[8];
    for(int i = 0; i < 8; i++) {
        rbdimmer_config_t config = {4+i, 0, 0, RBDIMMER_CURVE_LINEAR};
        rbdimmer_err_t err = rbdimmer_create_channel(&config, &channels[i]);
        if(err == RBDIMMER_OK) {
            Serial.printf("Channel %d created, Free heap: %d bytes\n",
                          i, ESP.getFreeHeap());
        } else {
            Serial.printf("Channel %d failed: %d\n", i, err);
            break;
        }
    }
    if(ESP.getFreeHeap() < 10000) {
        Serial.println("WARNING: Low memory");
    }
}

    Lösungen:

    1. Reduzieren Sie die Speichernutzung: - Begrenzen Sie die Anzahl der Kanäle - Optimieren Sie die Zeichenkettennutzung - Verwenden Sie PROGMEM für Konstanten

    2. Überprüfen Sie auf Speicherlecks: ```cpp void monitor_memory() { static unsigned long last_check = 0; static uint32_t last_free_heap = 0;

      if(millis() - last_check > 5000) { uint32_t current_heap = ESP.getFreeHeap(); Serial.printf("Heap: %d (change: %d)\n", current_heap, (int32_t)current_heap - last_free_heap);

      plaintext
      last_free_heap = current_heap;
   last_check = millis();

      } } ```

    Dimm- und Flimmerprobleme

    v2.0.0 behebt vier unterschiedliche Flimmerprobleme, die während der Validierung von 4-Kanal-Hardware entdeckt wurden. Jedes hat eine spezifische Ursache und Lösung.

    Problem: Allgemeines Flimmern bei allen Helligkeitsstufen

    Grundursache: Das TRIAC-Schalten injiziert einen Spannungsspitz auf den Zero-Cross-Optokoppler-Pin. Dieser Spike löst den ZC ISR mitten in einem Halbzyklus erneut aus, was verursacht, dass die Bibliothek ein falsches Timing berechnet und die TRIAC zu einem falschen Moment auslöst.

    Behebung (v2.0.0): Der zero_cross_isr_handler implementiert nun ein Rausch-Gate. Jede ZC-Flanke, die innerhalb von ZC_DEBOUNCE_US (Standard 3000 us) nach der vorherigen gültigen Flanke ankommt, wird verworfen. Dies eliminiert falsche Zero-Cross-Erkennungen, die durch TRIAC-Schalt-Rauschen verursacht werden.

    Tuning: Falls Sie auf elektrisch verrauschten Setups weiterhin Flimmern sehen, erhöhen Sie das Entprellungs-Fenster. Falls die automatische Frequenzerkennung langsam ist oder fehlschlägt, reduzieren Sie es.

    cpp
    // ESP-IDF: set via menuconfig -> Component config -> RBDimmer
// Or as a compile-time define:
#define CONFIG_RBDIMMER_ZC_DEBOUNCE_US 4000  // default is 3000

    Details finden Sie im Abschnitt Kconfig-Tuning .

    Problem: Flimmern bei 100% Helligkeit

    Grundursache: Bei 100% Helligkeit betrug die berechnete Verzögerung 50 us. An diesem Punkt im AC-Zyklus ist die Augenblicksspannung nur etwa 5 V -- unterhalb der TRIAC-Haltestrom-Schwelle. Darüber hinaus das Versenden eines Timer ISR von innerhalb einer GPIO ISR via esp_timer machte Verzögerungen unter 100 us unvorhersehbar.

    Behebung (v2.0.0): Zwei Änderungen: - MIN_DELAY_US wurde von 50 auf 100 us erhöht, um sicherzustellen, dass die TRIAC an einem Punkt mit ausreichend hoher AC-Spannung für zuverlässiges Halten auslöst. - Stufen bei oder über 100% werden auf LEVEL_MAX (Standard 99%) abgebildet, wodurch die problematische nahezu-Null-Verzögerung vollständig vermieden wird.

    Tuning: Passen Sie via Kconfig an, falls Ihre Hardware zuverlässig mit kürzerer Verzögerung halten kann:

    cpp
    #define CONFIG_RBDIMMER_MIN_DELAY_US 100     // default 100
#define CONFIG_RBDIMMER_LEVEL_MAX    99      // default 99

    Problem: Mehrkanal-Synchronisation -- Kanäle lösen mit verschiedenen Offsets aus

    Root cause: In v1.x, the ZC ISR processed all channels in a single loop: for each channel it reset the GPIO LOW and then armed the delay timer. Because each channel's GPIO reset happened at a slightly different time within that loop iteration, channels that should have fired simultaneously appeared offset from each other.

    Behebung (v2.0.0): Der ZC ISR nutzt nun einen Zwei-Durchlauf-Ansatz: - Durchgang 1: Setzt alle Kanal-GPIOs LOW (setzt die TRIAC-Gate-Signale zurück). - Durchgang 2: Armiert alle Verzögerungs-Timer.

    Dies stellt sicher, dass alle GPIO-Zurückstellungen so nah beieinander wie möglich geschehen, und das Timer-Armieren verflicht sich nicht mit GPIO-Operationen.

    Problem: Flimmern bei Stufen unter 3%

    Grundursache: Bei sehr niedrigen Helligkeitsstufen (unter 3%) löst die berechnete Verzögerung nahe am Ende des Halbzyklus aus, wo die AC-Spannung zu niedrig für zuverlässiges TRIAC-Halten ist. Die TRIAC hält entweder nicht oder hält intermittierend, was sichtbares Flimmern erzeugt.

    Behebung (v2.0.0): Stufen unter LEVEL_MIN (Standard 3%) geben jetzt delay=0 zurück, was den Kanal AUS schaltet, anstatt unzuverlässiges niedriges Dimmen zu versuchen.

    Tuning:

    cpp
    #define CONFIG_RBDIMMER_LEVEL_MIN 3  // default 3

    Falls Ihre Last- und TRIAC-Kombination zuverlässig bei niedrigeren Stufen halten kann, können Sie diesen Wert reduzieren.

    Problem: Keine Antwort auf Stufenänderungen

    Diagnose-Schritte:

    1. Verify Channel State: ```cpp void check_channel_state() { if(!rbdimmer_is_active(channel)) { Serial.println("Channel is inactive"); rbdimmer_set_active(channel, true); }

      uint8_t level = rbdimmer_get_level(channel); Serial.printf("Current level: %d%%\n", level);

      uint32_t delay_us = rbdimmer_get_delay(channel); Serial.printf("Current delay: %d us\n", delay_us); } ```

    2. Test Manual Level Changes: ```cpp void test_level_changes() { Serial.println("Testing level changes...");

      for(int level = 0; level <= 100; level += 10) { rbdimmer_set_level(channel, level); delay(500);

      plaintext
      uint8_t actual = rbdimmer_get_level(channel);
   if(actual != level) {
       Serial.printf("Level mismatch: set %d, got %d\n", level, actual);
   }

      } } ```

    Problem: Falsche Helligkeitsantwort

    Lösungen:

    1. Versuchen Sie verschiedene Kurven: ```cpp void test_curves() { rbdimmer_curve_t curves[] = { RBDIMMER_CURVE_LINEAR, RBDIMMER_CURVE_RMS, RBDIMMER_CURVE_LOGARITHMIC };

      const char* names[] = {"Linear", "RMS", "Logarithmic"};

      for(int i = 0; i < 3; i++) { Serial.printf("Testing %s curve...\n", names[i]); rbdimmer_set_curve(channel, curves[i]);

      plaintext
      rbdimmer_set_level(channel, 50);
   delay(2000);
   Serial.printf("Delay at 50%%: %d us\n", rbdimmer_get_delay(channel));

      } } ```

    2. Überprüfen Sie die Last-Kompatibilität: - Ohmsche Lasten: Verwenden Sie RMS-Kurve - LED-Lasten: Verwenden Sie Logarithmische Kurve - Motorlasten: Verwenden Sie Lineare Kurve

    Probleme bei der Frequenzerkennung

    Problem: Falsche Frequenzerkennung

    Diagnose-Code:

    cpp
    void diagnose_frequency_detection() {
    Serial.println("Frequency detection diagnostic...");
    rbdimmer_init();
    rbdimmer_register_zero_cross(2, 0, 0); // Auto-detect
    // Monitor detection process
    uint16_t readings[100];
    for(int i = 0; i < 100; i++) {
        delay(500);
        readings[i] = rbdimmer_get_frequency(0);
        Serial.printf("Reading %d: %d Hz\n", i, readings[i]);
        if(readings[i] > 0) {
            Serial.printf("Frequency detected at reading %d\n", i);
            break;
        }
    }
    // Analyze final frequency
    uint16_t final_freq = rbdimmer_get_frequency(0);
    if(final_freq == 50) {
        Serial.println("Detected 50Hz mains");
    } else if(final_freq == 60) {
        Serial.println("Detected 60Hz mains");
    } else if(final_freq == 0) {
        Serial.println("No frequency detected");
    } else {
        Serial.printf("Unusual frequency: %d Hz\n", final_freq);
    }
}

    Lösungen:

    1. Erzwingen Sie bekannte Frequenz: cpp // If auto-detection fails, use known frequency rbdimmer_register_zero_cross(2, 0, 50); // Force 50Hz rbdimmer_register_zero_cross(2, 0, 60); // Force 60Hz

    2. Überprüfen Sie die Zero-Cross-Signalqualität: - Signal sollte saubere digitale Impulse sein - Nach elektrischem Rauschen überprüfen - Überprüfen Sie die Spezifikationen des Dimmer-Moduls

    3. ZC-Entprellung zu aggressiv: - Falls ZC_DEBOUNCE_US zu hoch gesetzt ist, können echte ZC-Flanken verworfen werden - Bei 60-Hz-Netz beträgt der Halbzyklus ~8333 us; die Entprellung muss deutlich darunter liegen - Standard 3000 us funktioniert sowohl bei 50-Hz als auch bei 60-Hz

    Mehrkanal-Probleme

    Problem: Kanal-Interferenz

    Symptome: - Kanäle beeinflussen sich gegenseitig - Synchronisiertes Flimmern

    Diagnose-Code:

    cpp
    void diagnose_multi_channel() {
    Serial.println("Multi-channel diagnostic...");
    rbdimmer_init();
    rbdimmer_register_zero_cross(2, 0, 50);
    // Create multiple channels
    rbdimmer_channel_t* channels[4];
    uint8_t pins[] = {4, 5, 18, 19};
    for(int i = 0; i < 4; i++) {
        rbdimmer_config_t config = {pins[i], 0, 0, RBDIMMER_CURVE_LINEAR};
        rbdimmer_create_channel(&config, &channels[i]);
    }
    // Test individual control
    Serial.println("Testing individual channel control...");
    for(int ch = 0; ch < 4; ch++) {
        Serial.printf("Activating channel %d only\n", ch);
        for(int i = 0; i < 4; i++) {
            rbdimmer_set_level(channels[i], (i == ch) ? 50 : 0);
        }
        delay(2000);
    }
    // Test simultaneous control
    Serial.println("Testing simultaneous control...");
    for(int level = 0; level <= 100; level += 25) {
        for(int i = 0; i < 4; i++) {
            rbdimmer_set_level(channels[i], level);
        }
        Serial.printf("All channels set to %d%%\n", level);
        delay(1000);
    }
}

    Lösungen:

    1. Überprüfen Sie GPIO-Pin-Zuordnungen: - Stellen Sie sicher, dass jedem Kanal eindeutige Pins zugewiesen sind - Vermeiden Sie konfligierende Pin-Nutzung

    2. Kapazität der Stromversorgung: - Mehrere Kanäle erhöhen den Stromverbrauch - Verwenden Sie angemessene Stromversorgung

    3. Mehrkanal-Synchronisierungsprobleme (v2.0.0): - v2.0.0 nutzt einen Zwei-Durchlauf-ZC ISR, um inter-Kanal-Offsets zu eliminieren - Falls Kanäle noch Offsets zeigen, überprüfen Sie, dass Sie v2.0.0 ausführen - Überprüfen Sie, dass alle Kanäle auf der gleichen Phase registriert sind, falls sie ein ZC-Signal teilen

    Kconfig-Tuning

    v2.0.0 macht vier Parameter via Kconfig (ESP-IDF menuconfig) oder als Compile-Zeit-Defines für Arduino verfügbar. Diese steuern die Flimmer-Korrektionen und sollten nur geändert werden, falls die Defaults nicht zu Ihrer Hardware passen.

    ZC_DEBOUNCE_US -- Zero-Cross-Entprellungs-Fenster

    plaintext
    CONFIG_RBDIMMER_ZC_DEBOUNCE_US (default: 3000)

    Die minimale Zeit in Mikrosekunden zwischen zwei gültigen Zero-Cross-Flanken. Jede Flanke, die schneller ankommt, wird als Rauschen behandelt und verworfen.

    Wann anpassen: - Erhöhen, falls Sie weiterhin allgemeines Flimmern sehen (TRIAC-Rauschen dringt durch). Versuchen Sie 4000-5000. - Verringern, falls die automatische Frequenzerkennung unzuverlässig oder langsam ist. Nicht unter 1500 für 60-Hz-Netz. - Muss deutlich weniger sein als die halbe AC-Periode (10000 us bei 50 Hz, 8333 us bei 60 Hz).

    MIN_DELAY_US -- Minimale TRIAC-Auslöse-Verzögerung

    plaintext
    CONFIG_RBDIMMER_MIN_DELAY_US (default: 100)

    Die kürzeste erlaubte Verzögerung zwischen einem Zero-Cross-Ereignis und dem TRIAC-Gate-Impuls. Verhindert Auslösung bei nahezu-Null-AC-Spannung, wo das TRIAC-Halten unzuverlässig ist.

    Wann anpassen: - Erhöhen, falls Sie Flimmern bei hohen Helligkeitsstufen sehen. Versuchen Sie 150-200. - Verringern, nur falls Ihre TRIAC- und Last-Kombination zuverlässig bei sehr kurzen Verzögerungen hält. Nicht empfohlen unter 80.

    LEVEL_MAX -- Maximale effektive Dimm-Stufe

    plaintext
    CONFIG_RBDIMMER_LEVEL_MAX (default: 99)

    Stufen bei oder über diesem Wert werden auf diesen Prozentsatz begrenzt. Verhindert, dass die berechnete Verzögerung unter MIN_DELAY_US fällt.

    Wann anpassen: - Normalerweise bei 99 lassen. Das Setzen auf 100 deaktiviert effektiv die Max-Level-Begrenzung und kann Flimmern bei voller Helligkeit verursachen.

    LEVEL_MIN -- Minimale effektive Dimm-Stufe

    plaintext
    CONFIG_RBDIMMER_LEVEL_MIN (default: 3)

    Stufen unter diesem Wert führen dazu, dass der Kanal AUS geschaltet wird (delay=0), anstatt zu versuchen, die TRIAC nahe am Ende des Halbzyklus auszulösen.

    Wann anpassen: - Verringern, falls Ihre TRIAC- und Last-Kombination zuverlässig unter 3% dimmen kann. Testen Sie sorgfältig. - Erhöhen, falls Sie Flimmern bei niedriger Helligkeit sehen. Versuchen Sie 5.

    Parameter setzen

    ESP-IDF (menuconfig):

    plaintext
    idf.py menuconfig
-> Component config -> RBDimmer ESP32

    Arduino (Compile-Zeit-Defines):

    ini
    # platformio.ini
build_flags =
    -DCONFIG_RBDIMMER_ZC_DEBOUNCE_US=3000
    -DCONFIG_RBDIMMER_MIN_DELAY_US=100
    -DCONFIG_RBDIMMER_LEVEL_MAX=99
    -DCONFIG_RBDIMMER_LEVEL_MIN=3
    cpp
    // Or in code, before including the library header:
#define CONFIG_RBDIMMER_ZC_DEBOUNCE_US 3000
#define CONFIG_RBDIMMER_MIN_DELAY_US   100
#define CONFIG_RBDIMMER_LEVEL_MAX      99
#define CONFIG_RBDIMMER_LEVEL_MIN      3
#include

    Sicherheit und Hardwarefehler

    KRITISCH: Sicherheitsprobleme

    Sofortige Maßnahmen bei Sicherheitsproblemen:

    1. Brandgeruch oder Rauch: - Stromversorgung sofort unterbrechen - Nicht versuchen, bei eingeschalteter Stromversorgung zu diagnostizieren - Verbindungen überprüfen, wenn sicher

    2. Elektrischer Schlag: - Stromversorgung sofort unterbrechen - Überprüfen Sie auf ordnungsgemäße Isolation - Überprüfen Sie die Integrität des Dimmer-Moduls

    3. Überhitzung: - Überprüfen Sie Stromstärke-Bewertungen - Überprüfen Sie auf angemessene Kühlung - Last reduzieren, falls erforderlich

    Diagnose von Hardwarefehlern

    Systematischer Ansatz:

    1. Sichtprüfung: - Überprüfen Sie auf verbrannte Komponenten - Suchen Sie nach lockeren Verbindungen - Überprüfen Sie ordnungsgemäße Montage

    2. Elektrische Prüfung (nur Stromversorgung aus): - Durchgangsüberprüfungen - Isolationswiderstand - Komponentenwerte

    3. Ersatz-Test: - Verdächtige Komponenten austauschen - Mit bekannten guten Modulen testen - Defekte Komponenten isolieren

    Debugging-Tools und Techniken

    Serieller Monitor Debugging

    Verbesserter Debug-Ausgang:

    cpp
    #define DEBUG_LEVEL 3 // 0=none, 1=error, 2=warning, 3=info
void debug_print(int level, const char* message) {
    if(level <= DEBUG_LEVEL) {
        const char* prefixes[] = {"", "[ERROR]", "[WARN]", "[INFO]"};
        Serial.printf("%s %s\n", prefixes[level], message);
    }
}
void detailed_status() {
    debug_print(3, "=== System Status ===");
    debug_print(3, String("Free heap: " + String(ESP.getFreeHeap())).c_str());
    debug_print(3, String("CPU freq: " + String(ESP.getCpuFreqMHz()) + "MHz").c_str());
    debug_print(3, String("Frequency: " + String(rbdimmer_get_frequency(0)) + "Hz").c_str());
    if(channel) {
        debug_print(3, String("Channel level: " + String(rbdimmer_get_level(channel)) + "%").c_str());
        debug_print(3, String("Channel delay: " + String(rbdimmer_get_delay(channel)) + "us").c_str());
        debug_print(3, String("Channel active: " + String(rbdimmer_is_active(channel) ? "Yes" : "No")).c_str());
    }
}

    Oszilloskop-Analyse

    Wichtige Messungen: 1. Zero-Cross-Signal: Sollte saubere 50/60-Hz-Impulse sein 2. Gate-Steuerung: Präzises Timing relativ zu Zero-Cross 3. Last-Spannung: Phasenschnitt-Wellenform 4. Last-Strom: Sollte Spannungsmuster folgen

    Logik-Analyzer

    Für digitale Signalanalyse: - Zero-Cross-Timing - Gate-Steuerungs-Timing - Mehrkanal-Synchronisation (überprüfen Sie, dass der Zwei-Durchlauf ISR Offsets eliminiert)

    Häufig gestellte Fragen

    F: Warum flimmert mein Dimmer?

    A: v2.0.0 behebt die vier häufigsten Flimmerursachen. Überprüfen Sie, welches Muster auf Ihr Fall zutrifft: 1. Flimmern bei allen Stufen -- ZC-Rauschen vom TRIAC-Schalten. Behoben durch ZC-Entprellung. Siehe Allgemeines Flimmern. 2. Flimmern bei 100% -- TRIAC hält bei nahezu-Null-Verzögerung nicht. Behoben durch MIN_DELAY_US-Erhöhung. Siehe Flimmern bei 100%. 3. Flimmern unter 3% -- AC-Spannung zu niedrig am Ende des Halbzyklus. Behoben durch LEVEL_MIN-Abschneidung. Siehe Flimmern unter 3%. 4. Mehrkanal-Offset/Flimmern -- ISR-Schleifenordnung. Behoben durch Zwei-Durchlauf-ISR. Siehe Mehrkanal-Synchronisation.

    Falls keines davon zutrifft, überprüfen Sie auch: 5. Last-Inkompatibilität -- Versuchen Sie ohmsche Last zum Testen 6. Stromversorgungsprobleme -- Überprüfen Sie ESP32-Stromversorgungsstabilität 7. Elektrische Störungen -- Trennen Sie AC- und DC-Verdrahtung 8. Falscher Kurventyp -- Versuchen Sie verschiedene Kurveneinstellungen

    F: Kann ich dies mit LED-Leuchten verwenden?

    A: Yes, but with limitations: - Use only "dimmable" rated LED bulbs - Try RBDIMMER_CURVE_LOGARITHMIC - Some LEDs may flicker at low levels -- consider increasing LEVEL_MIN - Test compatibility first

    F: Warum schlägt die Frequenzerkennung fehl?

    A: Mögliche Gründe: 1. Kein Zero-Cross-Signal -- Überprüfen Sie Verdrahtung 2. Falsches Dimmer-Modul -- Überprüfen Sie ZC-Ausgabe 3. Elektrisches Rauschen -- Verbessern Sie Signalqualität 4. ZC-Entprellung zu aggressiv -- Versuchen Sie, ZC_DEBOUNCE_US zu reduzieren 5. Softwareproblem -- Versuchen Sie zunächst feste Frequenz

    F: Wie viele Kanäle kann ich verwenden?

    A: Technische Grenzen: - Maximal 8 Kanäle pro ESP32 - Jeder Kanal nutzt ~200 Bytes RAM - Alle Kanäle auf gleicher Phase teilen Zero-Crossing - Stromversorgung muss alle Kanäle unterstützen - v2.0.0 Zwei-Durchlauf-ISR stellt ordnungsgemäße Synchronisation über alle Kanäle sicher

    F: Ist es sicher, mit Motoren zu verwenden?

    A: Mit Vorkehrungen: - Verwenden Sie Motor-bewertete Dimmer-Module - Beachten Sie sanften Start-Anforderungen - Überwachen Sie Strom und Temperatur - Verwenden Sie angemessene Kurve (normalerweise Lineare)

    F: Kann ich 220-V-Lasten steuern?

    A: Ja, falls das Dimmer-Modul es unterstützt: - Überprüfen Sie die Spannungsbewertung des Dimmers - Verwenden Sie angemessene Sicherheitsmaßnahmen - Befolgen Sie lokale elektrische Codes - Erwägen Sie professionelle Installation

    F: Welche ESP-IDF-Version ist erforderlich?

    A: ESP-IDF 5.3 oder später ist erforderlich für v2.0.0. Die Bibliothek nutzt Kconfig zur Parameter-Konfiguration, die mit dem ESP-IDF menuconfig-System integriert. Arduino-Benutzer können Parameter stattdessen via Compile-Zeit-Defines setzen.

    Zusätzliche Hilfe erhalten

    Vor der Anfrage um Hilfe

    Bitte sammeln Sie diese Informationen:

    1. Hardware-Setup: - ESP32-Board-Typ - Dimmer-Modul-Modell - Last-Typ und Leistung - Schaltplan

    2. Software-Konfiguration: - IDE und Version - Bibliotheks-Version (v2.0.0 oder früher) - ESP-IDF-Version (falls zutreffend) - Vollständiger Code (minimales Beispiel) - Fehlermeldungen - Kconfig / Compile-Zeit-Parameter-Overrides

    3. Problembeschreibung: - Erwartetes Verhalten - Tatsächliches Verhalten - Schritte zur Reproduktion - Wann das Problem begann

    Support-Kanäle

    1. GitHub Issues: Melden Sie Fehler und Probleme
    2. Community-Forum: Diskussion und Hilfe
    3. E-Mail-Support: [email protected]
    4. Dokumentation: Vollständige Anleitungen

    Erstellung guter Fehlerbericht-Berichte

    Vorlage für Fehlerberichte:

    markdown
    ## Problem Description
Brief description of the issue
## Hardware Setup
- ESP32 Board: [e.g., ESP32 DevKit V1]
- Dimmer Module: [e.g., RobotDyn AC Light Dimmer]
- Load: [e.g., 100W incandescent bulb]
- Wiring: [pin connections]
## Software Environment
- IDE: [Arduino IDE 2.x]
- ESP32 Core / ESP-IDF: [version]
- Library Version: [2.0.0]
- Kconfig overrides: [list any non-default values]
## Expected Behavior
What should happen
## Actual Behavior
What actually happens
## Code Example
\```cpp
// Minimal code that reproduces the problem
\```
## Additional Information
- Error messages
- Serial output
- Oscilloscope traces (if available)

    Remember: Most problems have simple solutions. Work through the diagnostics systematically, and don't hesitate to ask for help with detailed information about your setup.

    Fehlerbehebungsanleitung für rbdimmerESP32 v2.0.0

    Schnelle Diagnose-Checkliste Kompilierungsprobleme Probleme mit Hardwareverbindungen Leistungsprobleme Dimm- und Flimmerprobleme Probleme bei der Frequenzerkennung Mehrkanal-Probleme Kconfig-Tuning Sicherheit und Hardwarefehler Debugging-Tools und Techniken Häufig gestellte Fragen Zusätzliche Hilfe erhalten