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,49 @@
+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
+  zwei parallel arbeitenden Zeicheneinheiten fast 100 KB gleichzeitig. Der interne
+  LVGL-Speicher hatte nur rund 98 KB am Stück frei; es reichte knapp nicht. Schlägt die
+  Anforderung fehl, hält LVGL per Zusicherung in einer Endlosschleife an - kein Absturz,
+  keine Meldung, das Display steht einfach. Deshalb brach der Mitschnitt ohne Fehler ab.
+- Große Glyphenpuffer liegen jetzt im externen Speicher (PSRAM, 32 MB frei). Kleine bleiben
+  im internen, der ist schneller - sonst würde jeder Text langsamer.
+- Hält LVGL künftig wegen einer verletzten Zusicherung an, sagt es das jetzt, statt stumm
+  stehen zu bleiben.
+
+Version 1.9.7:
+- Messpunkte für den Stillstand beim Wechsel in den Standby: Beide Abläufe - der Haupt- und
+  der Zeichenablauf - melden jetzt alle zwei Sekunden einen Herzschlag mit Speicherstand.
+  Bleibt nur einer von beiden aus, ist klar, welcher stehen bleibt.
+- Das Einblenden der Standby-Uhr meldet Anfang und Ende mit Dauer. Bleibt die zweite Meldung
+  aus, hängt es genau dort.
+- Jeder Helligkeitswechsel, der länger als 50 ms braucht, wird mit seiner Dauer gemeldet. Der
+  Schreibzugriff geht über denselben Bus wie der Touch - ein Verdacht für die bekannte
+  Verzögerung von ein bis zwei Sekunden.
+- Die Rückmeldung aus 1.9.5, die einen komplett ungültigen Inhaltsbereich melden sollte, ist
+  wieder entfernt. Sie konnte nie auslösen: LVGL schickt diese Meldung an das Display, nicht
+  an einzelne Elemente. Ihr Ausbleiben war also kein Beweis.
+
 Version 1.9.6:
 - Die Darstellungseinstellungen haben einen eigenen Menüpunkt „Darstellung" bekommen. Sie
   standen bisher oben auf der Info-Seite, zwischen Sachen, mit denen sie nichts zu tun

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
@@ -67,11 +80,27 @@ 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);
         s_lastBacklight = bl;
     }
 }
 
+// Herzschlag aus dem Haupt-Ablauf. Zusammen mit dem Herzschlag aus dem Zeichen-Ablauf
+// laesst sich unterscheiden, welcher der beiden stehen bleibt, wenn nichts mehr geht.
+static void main_heartbeat() {
+    static uint32_t s_last = 0;
+    if (millis() - s_last < 2000) return;
+    s_last = millis();
+    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) {
     // Automatische/Heartbeat-Acks nicht als Toast zeigen (pong, Handshake, Listen-Refresh).
     bool routine = ok && (message == "pong" || message == "hello" ||
@@ -332,6 +361,7 @@ static unsigned long s_lastDbgMs = 0;
 #endif
 
 void loop() {
+    main_heartbeat();
     g_client.loop();   // UART lesen, hello/heartbeat, state -> UI
     hal_loop();        // realer Modus: leer; Stub-Modus: lv_timer_handler()
 

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/lv_conf.h

@@ -374,8 +374,10 @@
 #define LV_USE_ASSERT_OBJ           0   /*Check the object's type and existence (e.g. not deleted). (Slow)*/
 
 /*Add a custom handler when assert happens e.g. to restart the MCU*/
-#define LV_ASSERT_HANDLER_INCLUDE <stdint.h>
-#define LV_ASSERT_HANDLER while(1);   /*Halt by default*/
+#define LV_ASSERT_HANDLER_INCLUDE <esp_rom_sys.h>
+// Frueher hielt LVGL hier stumm in einer Endlosschleife an - das Display stand, ohne dass
+// irgendwo etwas davon zu sehen war. Jetzt sagt es wenigstens, dass es angehalten hat.
+#define LV_ASSERT_HANDLER   esp_rom_printf("[LVGL] Zusicherung verletzt - Zeichenablauf haelt an\n"); while(1);
 
 /*-------------
  * Debug

P4_Display_Firmware/ui.cpp

@@ -18,6 +18,7 @@
 #include <Arduino.h>
 #include <ArduinoJson.h>
 #include <Preferences.h>   // Dashboard-Design P4-lokal merken (NVS)
+#include <esp_memory_utils.h>  // esp_ptr_external_ram(): welcher Speicher einen Puffer traegt
 #include <esp_heap_caps.h> // Verlaufs-Historie im PSRAM allozieren (interner RAM ist knapp)
 #include "ui.h"
 #include <Preferences.h>
@@ -929,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();
@@ -3555,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.
@@ -3565,12 +3573,41 @@ static void refr_ready_cb(lv_event_t*) {
                        (int)g_refrArea[i].y1, (int)g_refrArea[i].y2);
 }
 
-// Meldet, wenn ein ganzer Container ungueltig gemacht wird. Damit laesst sich unterscheiden,
-// ob eine einzelne Beschriftung den Bildaufbau ausloest oder ob gleich der komplette
-// Inhaltsbereich neu gezeichnet werden soll - zwei verschiedene Ursachen.
-static void inval_watch_cb(lv_event_t* e) {
-    const char* name = (const char*)lv_event_get_user_data(e);
-    esp_rom_printf("[UI] %s wird komplett ungueltig\n", name);
+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)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
+// Byte je Bildpunkt. Bei der grossen Standby-Uhr sind das 190 x 256 = rund 48 KB pro Ziffer,
+// und mit zwei parallel arbeitenden Zeicheneinheiten fast 100 KB gleichzeitig. Der interne
+// LVGL-Speicher fasst nur 245 KB, wovon rund 98 KB am Stueck frei sind - es reichte knapp
+// nicht. Schlaegt die Anforderung fehl, haelt LVGL per Zusicherung in einer Endlosschleife
+// an: kein Absturz, keine Meldung, das Display steht einfach. Genau das war der Stillstand
+// beim Wechsel in den Standby.
+//
+// Diese Puffer wandern daher in den externen Speicher (PSRAM, 32 MB frei). Kleine Glyphen
+// bleiben im internen Speicher, weil der schneller ist und Text sonst ueberall langsamer
+// wuerde; nur die grossen gehen nach aussen.
+#define FONT_BUF_EXTERN_AB 16384   // ab dieser Groesse in den externen Speicher
+
+static void* font_buf_malloc(size_t size, lv_color_format_t cf) {
+    LV_UNUSED(cf);
+    size += LV_DRAW_BUF_ALIGN - 1;
+    if (size >= FONT_BUF_EXTERN_AB) {
+        void* p = heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+        if (p) return p;
+    }
+    return lv_malloc(size);
+}
+
+static void font_buf_free(void* buf) {
+    // Der externe Speicher liegt ausserhalb des LVGL-Bereichs; daran ist zu erkennen,
+    // welcher der beiden Wege den Puffer vergeben hat.
+    if (esp_ptr_external_ram(buf)) heap_caps_free(buf);
+    else                           lv_free(buf);
 }
 
 static void refr_monitor_install() {
@@ -3983,9 +4020,12 @@ void ui_init(ProtocolClient* client) {
     show_page(PG_DASH);
     if (g_client) g_client->sendListProfiles();
 
+    // Glyphenpuffer umlenken, bevor der erste Text gezeichnet wird.
+    lv_draw_buf_handlers_t* fh = lv_draw_buf_get_font_handlers();
+    fh->buf_malloc_cb = font_buf_malloc;
+    fh->buf_free_cb   = font_buf_free;
     refr_monitor_install();
-    if (g_content) lv_obj_add_event_cb(g_content, inval_watch_cb, LV_EVENT_INVALIDATE_AREA, (void*)"Inhaltsbereich");
-    if (g_pages[PG_DASH]) lv_obj_add_event_cb(g_pages[PG_DASH], inval_watch_cb, LV_EVENT_INVALIDATE_AREA, (void*)"Dashboard-Seite");
+    lv_timer_create(ui_heartbeat_cb, 2000, nullptr);
     g_uiReady = true;
 }
 
@@ -4082,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) {
@@ -4175,8 +4217,14 @@ void ui_update(const MachineState& st) {
         if (shouldShow) {
             label_set_if_changed(g_standbyClock, zeit.length() ? zeit.c_str() : "--:--");
             if (!g_standbyShown) {
+                // 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 = 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)(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 -