diag(P4): Touch-Rohwerte vermessen, einheitliche Zeitbasis (1.9.10)

Auswertung des letzten Logs (lv_tick lief 2728 ms hinter millis):
Tipp erkannt 49428, Rückfrage aufgebaut 49430, Bildaufbau fertig 49746.
Also 318 ms vom erkannten Tipp bis zum fertigen Bild - die gemessene Kette
ist schnell. Der Knopfdruck im Dialog liegt bei 55638 (Bereich 645..856,
374..426), die Antwort des S3 bei 59303, also 937 ms Rundlauf.

Die Verzögerung liegt damit VOR der Erkennung. Deshalb:
- ws7_touch_get_xy() meldet den ersten verworfenen Rohwert nach Ruhe mit
  Koordinaten und zählt, wie viele bis zur akzeptierten Berührung anfallen.
- Alle Messzeilen auf millis() statt lv_tick_get(); die beiden Uhren
  auseinanderzurechnen hat das Lesen unnötig erschwert.

Beide Panel-Varianten mit arduino-cli gegengebaut.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NeFMr439WcLMdebE3kU7fS

P4_Display_Firmware/Changelog.txt

@@ -1,3 +1,24 @@
+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
+  das Dashboard sprang bei jedem Bezugsbeginn sichtbar um.
+- Die Messzeilen gingen bisher teils über die USB-Verbindung hinaus und waren im seriellen
+  Monitor gar nicht zu sehen - die Messung der Helligkeit lief damit ins Leere. Alle
+  Messzeilen laufen jetzt über denselben Weg wie die Panel-Meldungen.
+- Jede Messzeile trägt jetzt eine Zeitmarke. Nur so sind die Lücken zu sehen, in denen die
+  fünf Sekunden vergehen.
+- Der Wechsel in den und aus dem Standby wird an jeder Station vermessen: Ankunft der
+  Meldung, Warten auf die Anzeigesperre, Dauer der Aktualisierung. Ebenso der Weg vom Tippen
+  auf die Standby-Uhr bis zur fertig aufgebauten Rückfrage.
+
 Version 1.9.8:
 - Der Stillstand beim Wechsel in den Standby ist gefunden und behoben. LVGL legt für JEDE
   Textglyphe einen eigenen Zwischenpuffer an - bei der großen Uhr rund 48 KB pro Ziffer, mit

P4_Display_Firmware/P4_Display_Firmware.ino

@@ -47,10 +47,23 @@ static bool g_bootCountCleared = false;
 
 // --- Protokoll-Callbacks ---------------------------------------------------------------
 static void onState(const MachineState& st) {
+    // Vermessen: Zwischen dem Umschalten und dem sichtbaren Ergebnis vergehen rund fuenf
+    // Sekunden. Jede Station bekommt eine Zeitmarke, damit die Luecke zu sehen ist.
+    static bool s_lastStandby = false;
+    bool wechsel = (st.standbyActive != s_lastStandby);
+    s_lastStandby = st.standbyActive;
+    uint32_t t0 = millis();
+    if (wechsel) esp_rom_printf("[Zustand] %u ms: Standby jetzt %s - Meldung angekommen\n",
+                                (unsigned)t0, st.standbyActive ? "an" : "aus");
     // LVGL laeuft im realen Modus in einem eigenen Task -> UI-Zugriff sperren.
     hal_lock();
+    uint32_t t1 = millis();
     ui_update(st);
+    uint32_t t2 = millis();
     hal_unlock();
+    if (wechsel || (t2 - t0) > 200)
+        esp_rom_printf("[Zustand] %u ms: Sperre %u ms, Anzeige aktualisiert %u ms\n",
+                       (unsigned)millis(), (unsigned)(t1 - t0), (unsigned)(t2 - t1));
 
     // Display im Standby aus; ist "Uhrzeit im Standby anzeigen" aktiv, bleibt es an,
     // aber abgedunkelt (nicht blendend bei Nacht). Helligkeiten kommen von der S3
@@ -72,7 +85,8 @@ static void onState(const MachineState& st) {
         uint32_t t0 = millis();
         hal_backlight(bl);
         uint32_t dt = millis() - t0;
-        if (dt > 50) Serial.printf("[HAL] Helligkeit %d %% gesetzt, %u ms\n", bl, (unsigned)dt);
+        if (dt > 50) esp_rom_printf("[HAL] %u ms: Helligkeit %d %% gesetzt, brauchte %u ms\n",
+                                    (unsigned)millis(), bl, (unsigned)dt);
         s_lastBacklight = bl;
     }
 }
@@ -83,7 +97,8 @@ static void main_heartbeat() {
     static uint32_t s_last = 0;
     if (millis() - s_last < 2000) return;
     s_last = millis();
-    Serial.printf("[Haupt] Herzschlag, freier Speicher %u Byte\n", (unsigned)ESP.getFreeHeap());
+    esp_rom_printf("[Haupt] %u ms: Herzschlag, freier Speicher %u Byte\n",
+                   (unsigned)millis(), (unsigned)ESP.getFreeHeap());
 }
 
 static void onAck(uint32_t id, bool ok, const String& message) {

P4_Display_Firmware/board_bringup.c

@@ -310,14 +310,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/ui.cpp

@@ -930,7 +930,14 @@ static bool wake_choice_offered() {
     return g_state.cxWakeChoice ||
            (g_state.cxEnabled && g_state.cxArmable && g_state.cxAskOnWake);
 }
-static void standby_screen_cb(lv_event_t*) { wake_confirm_show(); }   // Tipp auf Standby-Uhr -> nachfragen
+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 = 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)millis(), (unsigned)(millis() - t0));
+}
 static void wake_cancel() {                  // Abbrechen -> zurueck in die Standby-Helligkeit
     wake_timeout_stop();
     wake_confirm_hide();
@@ -3556,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] Bildaufbau %u ms, %u Bereiche, %u %% der Flaeche\n",
+    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.
@@ -3568,8 +3575,9 @@ 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] Herzschlag, LVGL-Speicher frei %u von %u Byte, groesster Block %u\n",
-                   (unsigned)m.free_size, (unsigned)m.total_size, (unsigned)m.free_biggest_size);
+    esp_rom_printf("[UI] %u ms: Herzschlag, LVGL-Speicher frei %u von %u Byte, groesster Block %u\n",
+                   (unsigned)millis(), (unsigned)m.free_size, (unsigned)m.total_size,
+                   (unsigned)m.free_biggest_size);
 }
 
 // LVGL legt fuer JEDE Textglyphe einen eigenen Zwischenpuffer an - Breite mal Hoehe, ein
@@ -4114,12 +4122,14 @@ static void dash_brew_mode(bool on) {
     if (on == g_dashBrewMode) return;          // nur bei echtem Wechsel neu anordnen
     g_dashBrewMode = on;
     if (!g_tempRow || !g_infoRow) return;
-    lv_obj_set_flex_grow(g_tempRow, on ? 1 : 3);
-    lv_obj_set_flex_grow(g_infoRow, on ? 3 : 2);
-    // Die Schrift von Shot-Timer und Waage bleibt unveraendert. Frueher wechselte sie
-    // waehrend des Bezugs auf den grossen fetten Schnitt - das wirkte gegenueber dem
-    // restlichen Dashboard zu laut. Der Bereich bekommt weiterhin mehr Platz, die Zahlen
-    // stehen dadurch freier, aber in derselben Schrift wie sonst auch.
+    // Die Zeilenhoehen bleiben unveraendert. Frueher bekam die untere Zeile waehrend des
+    // Bezugs deutlich mehr Platz - die kleinen Kacheln wurden dadurch enorm hoch und das
+    // Dashboard sprang bei jedem Bezugsbeginn sichtbar um. Der Bezug hebt sich jetzt allein
+    // ueber seine Inhalte hervor, nicht ueber die Groesse.
+    (void)on;
+    // Die Schrift von Shot-Timer und Waage bleibt ebenfalls unveraendert. Frueher wechselte
+    // sie waehrend des Bezugs auf den grossen fetten Schnitt - das wirkte gegenueber dem
+    // restlichen Dashboard zu laut.
 }
 
 static void dash_brew_mode_tick(const MachineState& st) {
@@ -4210,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 -