fix(P4): Verlaufskurven mit gemeinsamer Skala - Höhen wieder vergleichbar (1.10.1)

Nachbesserung zu 1.10.0. Dort bekam jede Kurve ihren eigenen Ausschnitt aus
ihren eigenen min/max. Bei zwei flachen Kurven (Wasser 70 °C, Dampf 0 °C)
greift beidesmal die Mindestspanne, jede Linie sitzt mittig in ihrem Fenster -
und beide liegen auf identischer Höhe. Die Skalierung war zu clever: Bewegung
wurde sichtbar, aber die Höhe verlor jede Bedeutung.

- spark_range_fit(ch, ser) ersetzt durch spark_ranges_fit(): scannt beide
  Serien, bildet einen gemeinsamen Bereich und setzt ihn auf beide Charts.
- Der gemerkte Bereich liegt jetzt in zwei Datei-Statics statt in user_data
  der Charts; das nimmt auch das nicht freigegebene lv_malloc bei jedem
  Neuaufbau der Temperaturzeile weg.
- build_temp_row_content() setzt den Merker beim Aufbau zurück und ruft
  spark_ranges_fit() erst, wenn beide Kurven stehen.

Beide Panel-Varianten mit arduino-cli gegengebaut.

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

P4_Display_Firmware/Changelog.txt

@@ -1,3 +1,42 @@
+Version 1.10.1:
+- Die beiden Verlaufskurven teilen sich jetzt eine gemeinsame Skala. In 1.10.0 zoomte jede
+  Kurve auf ihre eigenen Werte - dadurch saß jede mittig in ihrem eigenen Fenster, und
+  Wasser bei 70 Grad lag genauso hoch wie Dampf bei 0. Die Höhe sagte nichts mehr aus.
+- Die Skala richtet sich nach den Werten beider Kessel zusammen. Der wärmere Kessel liegt
+  damit sichtbar höher, und die Skala bleibt so eng, wie es die Daten zulassen: Stehen beide
+  dicht beieinander, greift die Mindestspanne von vier Grad und schon Zehntelgrade sind zu
+  erkennen.
+
+Version 1.10.0:
+- Die Verlaufskurven im Dashboard zeigen jetzt wirklich einen Verlauf. Ihr Ausschnitt hing
+  bisher am Sollwert - sechs Grad darunter bis drei darüber. Das funktioniert nur, solange
+  der Kessel schon nahe am Ziel ist. Heizte er noch auf oder war er ganz aus, lag jeder
+  Messwert unterhalb des Fensters und wurde auf den unteren Rand geklemmt: Beide Kurven lagen
+  flach auf derselben Höhe und bewegten sich nicht, obwohl der eine Kessel bei 80 Grad stand
+  und der andere bei 0. Der Ausschnitt richtet sich jetzt nach den tatsächlich vorhandenen
+  Werten, mit einer Mindestspanne von vier Grad, damit ein ruhig geregelter Kessel nicht
+  jedes Zehntelgrad zum vollen Ausschlag aufbläht.
+- Die Kurven nehmen jetzt den Platz unterhalb der Zahlen ein statt als schmaler Streifen in
+  der Mitte zu hängen: Sie beginnen weiter unten auf der Karte und sind deutlich höher.
+- Der Nachlauf beim Wischen ist zurück. Er war abgeschaltet, weil jedes Einzelbild während
+  des Schwungs den ganzen Bildschirm neu zeichnete; seit die Anzeigewerte feste Maße haben,
+  fällt das weg.
+- Die Messzeilen der Fehlersuche sind wieder entfernt. Die Messung des Bildaufbaus bleibt
+  erhalten, liegt aber hinter dem Schalter WS7_PERF_MONITOR und ist aus.
+
+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

P4_Display_Firmware/P4_Display_Firmware.ino

@@ -47,23 +47,10 @@ 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
@@ -80,27 +67,11 @@ 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;
     }
 }
 
-// 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" ||
@@ -378,7 +349,6 @@ 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

@@ -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));
 }
 
 // =====================================================================================

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

@@ -179,6 +179,9 @@ enum TempDesign { TD_GEWICHTET = 0, TD_VERLAUF, TD_FLAECHEN, TD_BAND, TD_DESIGN_
 static uint8_t   g_tempDesign = TD_BAND;
 static bool      g_tempColored = false;   // Temperaturzahl in der Zustandsfarbe statt weiss
 #define DASH_SPARK_POINTS 60           // eine Minute Verlauf, ein Punkt je Sekunde
+// Kleinster Ausschnitt der Verlaufskurve in Zehntelgrad. Ohne Untergrenze blaeht ein
+// ruhig geregelter Kessel jedes Zehntelgrad zum vollen Ausschlag auf.
+#define DASH_SPARK_MIN_SPAN 40         // 4,0 Grad
 static lv_obj_t* g_sparkW = nullptr;   // Verlaufskurven der Darstellung TD_VERLAUF
 static lv_obj_t* g_sparkD = nullptr;
 static lv_chart_series_t* g_sparkSerW = nullptr;
@@ -719,13 +722,10 @@ static void clock_size_apply() {
     if (g_standbyClock) lv_obj_set_style_text_font(g_standbyClock, clock_font(), 0);
 }
 
-static void scroll_ohne_nachlauf(lv_obj_t* o) {
-#if JC_PANEL_TYPE == WS_PANEL_7H
-    lv_obj_clear_flag(o, LV_OBJ_FLAG_SCROLL_MOMENTUM);
-#else
-    (void)o;
-#endif
-}
+// Der Nachlauf beim Wischen war auf dem Waveshare-Panel eine Zeit lang abgeschaltet, weil
+// jedes Einzelbild waehrend des Schwungs den ganzen Schirm neu zeichnete. Seit die
+// Anzeigewerte feste Masse haben, faellt das weg - das Menue laeuft mit Nachlauf fluessig.
+static void scroll_ohne_nachlauf(lv_obj_t* o) { (void)o; }
 
 static lv_obj_t* make_page(lv_obj_t* parent) {
     lv_obj_t* p = lv_obj_create(parent);
@@ -931,12 +931,7 @@ static bool wake_choice_offered() {
            (g_state.cxEnabled && g_state.cxArmable && g_state.cxAskOnWake);
 }
 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();
@@ -1113,10 +1108,66 @@ static lv_obj_t* tempField(lv_obj_t* parent, const char* title, lv_color_t accen
 // Flache Verlaufskurve unter einer Temperatur. Zeigt, ob die Regelung haelt - das ist die
 // eigentliche Frage an eine PID-Regelung, und eine Zahl kann sie grundsaetzlich nicht
 // beantworten. Gespeist wird sie aus derselben Sekundenabtastung wie die Verlaufsseite.
+// Gemeinsamer Ausschnitt fuer BEIDE Verlaufskurven.
+//
+// Zwei Anlaeufe waren vorher daneben. Erst hing der Ausschnitt am Sollwert - dann lag beim
+// Aufheizen jeder Messwert unterhalb des Fensters und wurde auf den unteren Rand geklemmt.
+// Danach zoomte jede Kurve auf ihre eigenen Werte - dann sass jede mittig in ihrem eigenen
+// Fenster, und Wasser bei 70 Grad lag genauso hoch wie Dampf bei 0. Die Hoehe sagte nichts.
+//
+// Jetzt teilen sich beide Kurven eine Skala, die sich nach den Werten beider zusammen
+// richtet. Damit ist die Hoehe wieder vergleichbar - der waermere Kessel liegt sichtbar
+// hoeher -, und die Skala bleibt so eng, wie es die Daten zulassen: Stehen beide Kessel
+// dicht beieinander, greift die Mindestspanne und schon Zehntelgrade sind zu sehen.
+static int32_t g_sparkMin = INT32_MIN;   // zuletzt gesetzter Ausschnitt, fuer beide gleich
+static int32_t g_sparkMax = INT32_MIN;
+
+static void spark_scan(lv_obj_t* ch, lv_chart_series_t* ser, int32_t* mn, int32_t* mx) {
+    if (!ch || !ser) return;
+    int32_t* pts = lv_chart_get_y_array(ch, ser);
+    if (!pts) return;
+    uint32_t n = lv_chart_get_point_count(ch);
+    for (uint32_t i = 0; i < n; i++) {
+        if (pts[i] == LV_CHART_POINT_NONE) continue;
+        if (pts[i] < *mn) *mn = pts[i];
+        if (pts[i] > *mx) *mx = pts[i];
+    }
+}
+
+static void spark_ranges_fit() {
+    int32_t mn = INT32_MAX, mx = INT32_MIN;
+    spark_scan(g_sparkW, g_sparkSerW, &mn, &mx);
+    spark_scan(g_sparkD, g_sparkSerD, &mn, &mx);
+    if (mn > mx) return;                       // noch kein einziger Wert
+    if (mx - mn < DASH_SPARK_MIN_SPAN) {       // beide dicht beieinander: mittig halten
+        int32_t mitte = (mn + mx) / 2;
+        mn = mitte - DASH_SPARK_MIN_SPAN / 2;
+        mx = mitte + DASH_SPARK_MIN_SPAN / 2;
+    } else {                                   // sonst etwas Luft nach oben und unten
+        int32_t luft = (mx - mn) / 8;
+        mn -= luft;
+        mx += luft;
+    }
+    // Nur bei echter Aenderung setzen - lv_chart_set_range macht das Diagramm sonst bei
+    // jeder Zustandsmeldung ungueltig, auch wenn sich der Ausschnitt gar nicht ruehrt.
+    // Abfragen laesst sich der gesetzte Ausschnitt bei LVGL nicht, also wird er gemerkt.
+    if (mn == g_sparkMin && mx == g_sparkMax) return;
+    g_sparkMin = mn;
+    g_sparkMax = mx;
+    if (g_sparkW) lv_chart_set_range(g_sparkW, LV_CHART_AXIS_PRIMARY_Y, mn, mx);
+    if (g_sparkD) lv_chart_set_range(g_sparkD, LV_CHART_AXIS_PRIMARY_Y, mn, mx);
+}
+
 static lv_obj_t* tempSpark(lv_obj_t* parent, lv_color_t col, lv_chart_series_t** ser,
                            float jetzt, float soll) {
     lv_obj_t* ch = lv_chart_create(parent);
-    lv_obj_set_size(ch, LV_PCT(96), 64);
+    // Die Kurve nimmt den Platz unterhalb der Zahlen ein, statt als schmaler Streifen in
+    // der Mitte zu haengen. Sie beginnt damit weiter unten auf der Karte und hat deutlich
+    // mehr Hoehe - Temperaturaenderungen sind so ueberhaupt erst zu erkennen.
+    lv_obj_set_width(ch, LV_PCT(96));
+    lv_obj_set_height(ch, LV_PCT(100));
+    lv_obj_set_flex_grow(ch, 1);
+    lv_obj_set_style_min_height(ch, 90, 0);
     lv_chart_set_type(ch, LV_CHART_TYPE_LINE);
     lv_chart_set_point_count(ch, DASH_SPARK_POINTS);
     lv_chart_set_div_line_count(ch, 0, 0);
@@ -1130,13 +1181,12 @@ static lv_obj_t* tempSpark(lv_obj_t* parent, lv_color_t col, lv_chart_series_t**
     lv_obj_clear_flag(ch, LV_OBJ_FLAG_SCROLLABLE);
     *ser = lv_chart_add_series(ch, col, LV_CHART_AXIS_PRIMARY_Y);
 
-    // Ausschnitt und Startwert sofort setzen. Ein frisch angelegtes Diagramm hat lauter
-    // "kein Wert"-Punkte und zeichnet deshalb nichts - beim Umschalten der Darstellung
-    // saehe man bis zur ersten Sekundenprobe eine leere Flaeche.
-    int32_t sollT = (int32_t)(soll * 10.0f);
-    lv_chart_set_range(ch, LV_CHART_AXIS_PRIMARY_Y, sollT - 60, sollT + 30);
+    // Startwert sofort setzen. Ein frisch angelegtes Diagramm hat lauter "kein Wert"-Punkte
+    // und zeichnet deshalb nichts - beim Umschalten der Darstellung saehe man bis zur
+    // ersten Sekundenprobe eine leere Flaeche.
+    (void)soll;
     lv_chart_set_all_value(ch, *ser, (int32_t)(jetzt * 10.0f));
-    return ch;
+    return ch;   // Ausschnitt setzt spark_ranges_fit(), sobald beide Kurven stehen
 }
 
 // Temperaturbereich gemaess aktiver Darstellung (neu) aufbauen - auch beim Umschalten
@@ -1149,6 +1199,7 @@ static void build_temp_row_content() {
     bulbTempW = bulbTempD = nullptr;
     g_sparkW = g_sparkD = nullptr;
     g_sparkSerW = g_sparkSerD = nullptr;
+    g_sparkMin = g_sparkMax = INT32_MIN;   // gemerkter Ausschnitt gilt fuer die alten Kurven
     g_readyBand = g_readyBandLbl = nullptr;
 
     const lv_color_t teal = lv_color_hex(0x80cbc4);
@@ -1177,6 +1228,7 @@ static void build_temp_row_content() {
         lv_obj_t* cd = tempField(g_tempRow, "DAMPF", teal, &lblTempD, &lblSetD, &barDutyD,
                                  1, &lv_font_maven_pro_bold_96, false, 0);
         g_sparkD = tempSpark(cd, COL_ACCENT, &g_sparkSerD, g_state.tempD, g_state.setD);
+        spark_ranges_fit();
         break;
     }
 
@@ -1676,19 +1728,13 @@ static void chart_duty_btn_cb(lv_event_t*) {
     }
     chart_redraw();
 
-    // Verlaufskurven des Dashboards (Darstellung "Verlauf") mitfuehren. Der Ausschnitt
-    // haengt am Sollwert, damit die Abweichung sichtbar wird und nicht in der Skala
-    // untergeht - eine feste Skala von 0 bis 130 Grad zeigte nur eine gerade Linie.
-    if (g_sparkSerW && g_sparkW) {
-        int32_t soll = (int32_t)(g_state.setW * 10.0f);
-        lv_chart_set_range(g_sparkW, LV_CHART_AXIS_PRIMARY_Y, soll - 60, soll + 30);
+    // Verlaufskurven des Dashboards (Darstellung "Verlauf") mitfuehren. Beide teilen sich
+    // eine Skala, siehe spark_ranges_fit().
+    if (g_sparkSerW && g_sparkW)
         lv_chart_set_next_value(g_sparkW, g_sparkSerW, (int32_t)(g_state.tempW * 10.0f));
-    }
-    if (g_sparkSerD && g_sparkD) {
-        int32_t soll = (int32_t)(g_state.setD * 10.0f);
-        lv_chart_set_range(g_sparkD, LV_CHART_AXIS_PRIMARY_Y, soll - 120, soll + 60);
+    if (g_sparkSerD && g_sparkD)
         lv_chart_set_next_value(g_sparkD, g_sparkSerD, (int32_t)(g_state.tempD * 10.0f));
-    }
+    spark_ranges_fit();   // gemeinsame Skala, damit die Hoehen vergleichbar bleiben
 }
 static void build_chart(lv_obj_t* p) {
     lv_obj_clear_flag(p, LV_OBJ_FLAG_SCROLLABLE);
@@ -3573,13 +3619,6 @@ static void refr_ready_cb(lv_event_t*) {
                        (int)g_refrArea[i].y1, (int)g_refrArea[i].y2);
 }
 
-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
@@ -4024,8 +4063,9 @@ void ui_init(ProtocolClient* client) {
     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();
-    lv_timer_create(ui_heartbeat_cb, 2000, nullptr);
+#if WS7_PERF_MONITOR
+    refr_monitor_install();   // nur zum Einmessen, siehe WS7_PERF_MONITOR
+#endif
     g_uiReady = true;
 }
 
@@ -4217,14 +4257,8 @@ 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 -