fix(P4): Hintergrundbeleuchtung kommt sofort - Bridge braucht zwei Latches (1.9.12)

Der Nutzer hat es im Gegenlicht gesehen: Das Bild steht nach 446 ms fertig
da, nur die Beleuchtung kommt Sekunden später. Die gesamte Suche im
Zeichenablauf lief damit am falschen Ort - die Messungen dort waren alle
unauffällig, weil dort auch nichts war.

Der Referenz-Sketch (dsi-test.ino, enableBacklight) setzt 0xAB/0xAA zweimal
mit delay(100) dazwischen, ausdrücklich "sicherheitshalber Helligkeit noch
einmal übernehmen". jc_backlight_set() schrieb die Sequenz nur einmal.

- 0xAB/0xAA werden jetzt wiederholt, Pause über WS7_BACKLIGHT_LATCH_MS (20).
- 0xAD (Freigabe) nur noch beim ersten Aufruf statt bei jeder Änderung; der
  Referenzcode setzt sie ebenfalls nur einmal, und sie erneut zu schreiben
  stößt die Helligkeitsstufe der Bridge neu an.
- jc_backlight_set() meldet seine Dauer selbst; die doppelte Messung im .ino
  entfällt.

Beide Panel-Varianten mit arduino-cli gegengebaut.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

P4_Display_Firmware/Changelog.txt

@@ -1,3 +1,37 @@
+Version 1.9.12:
+- Die Hintergrundbeleuchtung kommt beim Wechsel in den und aus dem Standby jetzt sofort.
+  Bisher stand das Bild bereits fertig da - im Gegenlicht war es zu sehen -, blieb aber
+  mehrere Sekunden dunkel. Das war die ganze gesuchte Verzögerung.
+- Ursache: Die Bridge übernimmt eine neue Helligkeit nicht zuverlässig beim ersten Mal. Der
+  Beispielcode von Waveshare setzt sie deshalb zweimal, mit einer Pause dazwischen,
+  ausdrücklich „sicherheitshalber". Genau diese Wiederholung fehlte.
+- Die Panel-Freigabe wird nur noch beim ersten Mal gesetzt. Sie erneut zu setzen, während die
+  Beleuchtung läuft, stößt die Helligkeitsstufe der Bridge neu an; der Beispielcode setzt sie
+  ebenfalls nur ein einziges Mal.
+- Jeder Helligkeitswechsel meldet jetzt seine Dauer. Bleibt die Beleuchtung wieder hinterher,
+  lässt sich die Pause zwischen den beiden Übernahmen über WS7_BACKLIGHT_LATCH_MS erhöhen.
+
+Version 1.9.11:
+- Endlose Startschleife behoben: Beleuchtung an, nie ein Bild. Der P4 startet sich nach dem
+  Einschalten absichtlich einmal neu, weil das Panel sonst schwarz bleibt. Die Absicherung
+  dagegen verließ sich darauf, dass der zweite Start kein Kaltstart mehr ist - der Chip
+  meldet aber auch nach dem selbst ausgelösten Neustart wieder einen Kaltstart. Damit griff
+  die Bedingung erneut, endlos.
+- Der Neustart wird jetzt vermerkt und beim zweiten Durchlauf erkannt, unabhängig davon, was
+  der Chip als Startgrund meldet. Beim nächsten echten Einschalten erfolgt wieder genau ein
+  Neustart.
+- Die Meldung über diesen Neustart lief bisher über die USB-Verbindung und war im seriellen
+  Monitor nicht zu sehen - deshalb war von der Schleife nichts zu erkennen. Sie läuft jetzt
+  denselben Weg wie die übrigen Panel-Meldungen.
+
+Version 1.9.10:
+- Alle Messzeilen laufen jetzt auf derselben Uhr. Die des Zeichenablaufs startete später als
+  die des Hauptablaufs; die Zeiten ließen sich nur mit Umrechnung vergleichen.
+- Der Touch meldet jetzt, wenn er Rohwerte verwirft, weil sie außerhalb des gültigen
+  Bereichs liegen, und nennt bei jeder erkannten Berührung, wie viele vorher verworfen
+  wurden. Eine Berührung, deren Rohwerte lange verworfen werden, sieht von außen genauso aus
+  wie ein Display, das nicht reagiert - das war bisher nicht zu unterscheiden.
+
 Version 1.9.9:
 - Die kleinen Kacheln unten im Dashboard behalten beim Bezug ihre Höhe. Bisher bekam die
   untere Zeile während des Bezugs deutlich mehr Platz - die Kacheln wurden enorm hoch und

P4_Display_Firmware/P4_Display_Firmware.ino

@@ -80,13 +80,7 @@ static void onState(const MachineState& st) {
     }
     if (bl < 0) bl = 0; if (bl > 100) bl = 100;
     if (bl != s_lastBacklight) {
-        // Vermessen: Rund um jeden Helligkeitswechsel hing die Bedienung bisher ein bis
-        // zwei Sekunden. Der Schreibzugriff geht ueber denselben I2C-Bus wie der Touch.
-        uint32_t t0 = millis();
-        hal_backlight(bl);
-        uint32_t dt = millis() - t0;
-        if (dt > 50) esp_rom_printf("[HAL] %u ms: Helligkeit %d %% gesetzt, brauchte %u ms\n",
-                                    (unsigned)millis(), bl, (unsigned)dt);
+        hal_backlight(bl);   // meldet seine Dauer selbst, siehe jc_backlight_set()
         s_lastBacklight = bl;
     }
 }
@@ -336,19 +330,36 @@ void setup() {
     // nicht (siehe WS7_DSI_RESTART).
     //
     // Deshalb startet der P4 sich nach einem Kaltstart genau einmal selbst neu, nachdem
-    // der erste Hochlauf durch ist. Beim zweiten Durchlauf ist der Startgrund kein
-    // Kaltstart mehr, die Bedingung greift also nicht erneut - eine Schleife ist
-    // ausgeschlossen. Kostet rund drei Sekunden, aber nur beim Einschalten.
+    // der erste Hochlauf durch ist. Kostet rund drei Sekunden, aber nur beim Einschalten.
+    //
+    // Frueher stuetzte sich die Absicherung dagegen allein auf den Startgrund: Beim zweiten
+    // Durchlauf sei es kein Kaltstart mehr, eine Schleife also ausgeschlossen. Das stimmt
+    // nicht - der Chip meldet auch nach dem selbst ausgeloesten Neustart wieder einen
+    // Kaltstart, und dann startet er endlos neu. Genau das ist aufgetreten: Beleuchtung an,
+    // nie ein Bild. Deshalb wird jetzt zusaetzlich vermerkt, dass der Neustart schon
+    // stattgefunden hat; darauf ist Verlass, unabhaengig vom gemeldeten Startgrund.
 #if (JC_PANEL_TYPE == WS_PANEL_7H) && WS7_COLD_BOOT_RESTART
     if (esp_reset_reason() == ESP_RST_POWERON) {
-        // Der Fruehstart-Zaehler wurde oben bereits erhoeht. Diesen gewollten Neustart
-        // darf er nicht mitzaehlen, sonst laeuft die Absturzsicherung nach ein paar
-        // Einschaltvorgaengen in den Update-Modus.
-        { Preferences p; p.begin("bootguard", false); p.putUShort("early", 0); p.end(); }
-        DBG_SERIAL.println(F("[Panel] Kaltstart - einmaliger Neustart fuer das Displaypanel"));
-        DBG_SERIAL.flush();
-        delay(50);
-        esp_restart();
+        Preferences p;
+        p.begin("bootguard", false);
+        bool schonNeugestartet = p.getUChar("kaltneu", 0) != 0;
+        if (schonNeugestartet) {
+            // Zweiter Durchlauf: Vermerk loeschen, damit beim naechsten echten Einschalten
+            // wieder genau ein Neustart erfolgt.
+            p.putUChar("kaltneu", 0);
+            p.end();
+            esp_rom_printf("[Panel] Neustart bereits erfolgt - Hochlauf wird fortgesetzt\n");
+        } else {
+            p.putUChar("kaltneu", 1);
+            // Der Fruehstart-Zaehler wurde oben bereits erhoeht. Diesen gewollten Neustart
+            // darf er nicht mitzaehlen, sonst laeuft die Absturzsicherung nach ein paar
+            // Einschaltvorgaengen in den Update-Modus.
+            p.putUShort("early", 0);
+            p.end();
+            esp_rom_printf("[Panel] Kaltstart - einmaliger Neustart fuer das Displaypanel\n");
+            delay(50);
+            esp_restart();
+        }
     }
 #endif
     g_client.begin();      // UART starten, hello folgt automatisch in loop()

P4_Display_Firmware/board_bringup.c

@@ -235,9 +235,34 @@ void jc_backlight_set(int percent)
     if (percent > 100) percent = 100;
     if (percent < 0) percent = 0;
     uint8_t brightness = (uint8_t)((255 * percent) / 100);
-    ws7_bridge_write(0xAD, 0x01);                    // Panel-/Backlight-Freigabe
-    ws7_bridge_write(0xAB, (uint8_t)(255 - brightness));
+    uint8_t wert = (uint8_t)(255 - brightness);
+    int64_t t0 = esp_timer_get_time();
+
+    // Die Bridge uebernimmt eine neue Helligkeit nicht zuverlaessig beim ersten Mal. Der
+    // Beispielcode von Waveshare setzt sie deshalb zweimal, mit einer Pause dazwischen,
+    // ausdruecklich "sicherheitshalber". Uns fehlte diese Wiederholung: Das Bild stand
+    // dann fertig da, blieb aber dunkel, bis die Uebernahme irgendwann doch griff - beim
+    // Ein- und Ausschalten des Standby waren das mehrere Sekunden.
+    //
+    // Die Freigabe (0xAD) bleibt beim ersten Aufruf, danach nicht mehr: Sie erneut zu
+    // setzen, waehrend die Beleuchtung laeuft, stoesst die Helligkeitsstufe der Bridge neu
+    // an - der Beispielcode setzt sie darum ebenfalls nur ein einziges Mal.
+    static bool freigegeben = false;
+    if (!freigegeben) {
+        ws7_bridge_write(0xAD, 0x01);                // Panel-/Backlight-Freigabe
+        vTaskDelay(pdMS_TO_TICKS(20));               // wie im Beispielcode: Bridge setzen lassen
+        freigegeben = true;
+    }
+
+    ws7_bridge_write(0xAB, wert);
     ws7_bridge_write(0xAA, 0x01);                    // Helligkeit uebernehmen
+    vTaskDelay(pdMS_TO_TICKS(WS7_BACKLIGHT_LATCH_MS));
+    ws7_bridge_write(0xAB, wert);                    // Wiederholung, siehe oben
+    ws7_bridge_write(0xAA, 0x01);
+
+    esp_rom_printf("[HAL] %u ms: Helligkeit %d %% gesetzt, brauchte %u ms\n",
+                   (unsigned)(esp_timer_get_time() / 1000), percent,
+                   (unsigned)((esp_timer_get_time() - t0) / 1000));
 }
 
 // =====================================================================================
@@ -310,14 +335,26 @@ static bool ws7_touch_get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y
     bool got = s_touch_get_xy_orig(tp, x, y, strength, point_num, max_point_num);
     int64_t now = esp_timer_get_time();
 
-    // Unplausible Rohwerte gelten als Aussetzer, nicht als Beruehrung.
+    // Unplausible Rohwerte gelten als Aussetzer, nicht als Beruehrung. Wie viele davon
+    // anfallen, war bisher nirgends zu sehen - eine Beruehrung, deren Rohwerte lange
+    // verworfen werden, sieht von aussen wie ein Display aus, das nicht reagiert.
+    static uint32_t s_verworfen = 0;
     if (got && *point_num > 0 &&
         (x[0] > WS7_TOUCH_RAW_X_MAX || y[0] > WS7_TOUCH_RAW_Y_MAX)) {
+        if (s_verworfen == 0)
+            esp_rom_printf("[Touch] %u ms: Rohwert verworfen (x %u, y %u liegen ausserhalb)\n",
+                           (unsigned)(now / 1000), (unsigned)x[0], (unsigned)y[0]);
+        s_verworfen++;
         got = false;
         *point_num = 0;
     }
 
     if (got && *point_num > 0) {
+        if (!s_touch_down)
+            esp_rom_printf("[Touch] %u ms: Beruehrung erkannt bei x %u, y %u; %u Rohwerte vorher verworfen\n",
+                           (unsigned)(now / 1000), (unsigned)x[0], (unsigned)y[0],
+                           (unsigned)s_verworfen);
+        s_verworfen = 0;
         s_touch_last_x = x[0];
         s_touch_last_y = y[0];
         s_touch_last_us = now;

P4_Display_Firmware/pins_config.h

@@ -182,6 +182,14 @@
 // auf I2C antwortet. Meldet sich 0x14 beim Start nicht, diesen Wert erhoehen.
 #define WS7_TOUCH_POWER_MS 120
 
+// Pause zwischen den beiden Helligkeitsuebernahmen der Bridge. Sie uebernimmt eine neue
+// Helligkeit nicht zuverlaessig beim ersten Mal; der Beispielcode von Waveshare setzt sie
+// darum zweimal. Ohne die Wiederholung stand das Bild fertig da, blieb aber dunkel - beim
+// Wechsel in den und aus dem Standby mehrere Sekunden lang. Der Beispielcode wartet 100 ms;
+// weniger genuegt hier, weil die Wiederholung ohnehin folgt. Bleibt die Beleuchtung wieder
+// hinterher, diesen Wert erhoehen.
+#define WS7_BACKLIGHT_LATCH_MS 20
+
 // Prueffarbbalken statt Oberflaeche anzeigen. Sie entstehen im DSI-Baustein selbst und
 // benutzen weder Bildspeicher noch LVGL. Damit laesst sich trennen, ob die Anzeigekette
 // bis zum Panel arbeitet (Balken sichtbar) oder nicht (schwarz). Nur zur Fehlersuche.

P4_Display_Firmware/ui.cpp

@@ -932,11 +932,11 @@ static bool wake_choice_offered() {
 }
 static void standby_screen_cb(lv_event_t*) {   // Tipp auf Standby-Uhr -> nachfragen
     // Vermessen: Vom Tippen bis zur sichtbaren Rueckfrage vergehen rund fuenf Sekunden.
-    uint32_t t0 = lv_tick_get();
+    uint32_t t0 = millis();
     esp_rom_printf("[Touch] %u ms: Tipp auf die Standby-Uhr erkannt\n", (unsigned)t0);
     wake_confirm_show();
     esp_rom_printf("[Touch] %u ms: Rueckfrage aufgebaut, brauchte %u ms\n",
-                   (unsigned)lv_tick_get(), (unsigned)(lv_tick_get() - t0));
+                   (unsigned)millis(), (unsigned)(millis() - t0));
 }
 static void wake_cancel() {                  // Abbrechen -> zurueck in die Standby-Helligkeit
     wake_timeout_stop();
@@ -3563,7 +3563,7 @@ static void refr_ready_cb(lv_event_t*) {
     uint32_t d = lv_tick_get() - g_refrStart;
     if (d < REFR_WARN_MS) return;
     unsigned pct = (unsigned)((uint64_t)g_refrPixels * 100ULL / ((uint64_t)LCD_H_RES * LCD_V_RES));
-    esp_rom_printf("[UI] %u ms: Bildaufbau %u ms, %u Bereiche, %u %% der Flaeche\n", (unsigned)lv_tick_get(),
+    esp_rom_printf("[UI] %u ms: Bildaufbau %u ms, %u Bereiche, %u %% der Flaeche\n", (unsigned)millis(),
                    (unsigned)d, (unsigned)g_refrAreas, pct);
     // Lage der Bereiche mit ausgeben. Erst daran ist zu erkennen, WELCHER Teil der
     // Oberflaeche das Neuzeichnen ausloest - die Groesse allein sagt das nicht.
@@ -3576,7 +3576,7 @@ static void refr_ready_cb(lv_event_t*) {
 static void ui_heartbeat_cb(lv_timer_t*) {
     lv_mem_monitor_t m; lv_mem_monitor(&m);
     esp_rom_printf("[UI] %u ms: Herzschlag, LVGL-Speicher frei %u von %u Byte, groesster Block %u\n",
-                   (unsigned)lv_tick_get(), (unsigned)m.free_size, (unsigned)m.total_size,
+                   (unsigned)millis(), (unsigned)m.free_size, (unsigned)m.total_size,
                    (unsigned)m.free_biggest_size);
 }
 
@@ -4220,11 +4220,11 @@ void ui_update(const MachineState& st) {
                 // Vermessen: Das Einblenden der Uhr ist der Moment, in dem das Display
                 // zuletzt stehen geblieben ist. Bleibt die zweite Zeile aus, haengt es hier.
                 esp_rom_printf("[UI] Standby-Uhr wird eingeblendet\n");
-                uint32_t t0 = lv_tick_get();
+                uint32_t t0 = millis();
                 ui_fade_in(g_standbyScreen, UI_FADE_MS);   // Einschlaf-Animation
                 g_standbyShown = true;
                 esp_rom_printf("[UI] Standby-Uhr eingeblendet, %u ms\n",
-                               (unsigned)(lv_tick_get() - t0));
+                               (unsigned)(millis() - t0));
             }
             // Frueher wurde die Uhr hier bei JEDER Zustandsmeldung nach vorn geholt. Das
             // ordnet die Ebenen neu und laesst LVGL den gesamten Bildschirm neu zeichnen -