fix(P4): Punkt sitzt wieder auf dem letzten Messwert (1.11.3)

Um den Beschnitt an der rechten Kante zu vermeiden, war der Punkt um eine
halbe Punktbreite nach innen gerueckt - die Linie schaute dadurch rechts
unter ihm hervor.

Statt den Punkt zu verschieben, laesst die Kurvenflaeche jetzt rechts
einen schmalen Rand frei. Der Platz gehoert noch zum Diagramm, wird aber
nicht mehr bezeichnet: Die Linie endet frueher, der Punkt sitzt genau auf
ihrem letzten Wert und wird nicht abgeschnitten.

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

P4_Display_Firmware/Changelog.txt

@@ -1,3 +1,113 @@
+Version 1.11.3:
+- Der Punkt sitzt wieder genau auf dem letzten Messwert, statt eine halbe Punktbreite davor.
+  Die Linie schaut damit rechts nicht mehr unter ihm hervor. Damit trotzdem nichts
+  abgeschnitten wird, lässt die Kurvenfläche rechts einen schmalen Rand frei: Der Platz
+  gehört noch zum Diagramm, wird aber nicht mehr bezeichnet.
+
+Version 1.11.2:
+- Der Punkt am Kurvenende sitzt jetzt vollständig innerhalb der Kurvenfläche, statt mittig
+  auf dem letzten Messwert und damit halb außerhalb. Rechts wird nichts mehr abgeschnitten.
+  Der Schein darf weiterhin darüber hinausreichen.
+- Der Punkt ist auf etwa zwei Drittel verkleinert.
+- Neues Pulsieren als Signalpunkt: Der Punkt selbst atmet leicht, und der Schein macht das
+  Gegenteil. Zieht der Punkt sich zusammen, geht der Schein auf; wird der Punkt wieder
+  größer, zieht der Schein sich zurück.
+
+Version 1.11.1:
+- Der Punkt am rechten Ende der Verlaufskurven war angeschnitten, und von seinem Schein war
+  nichts zu sehen: Das Diagramm beschnitt beides an seiner eigenen Kante. Punkt und Schein
+  dürfen jetzt darüber hinausreichen, das Pulsieren ist damit sichtbar. Der Schein wurde
+  zusätzlich kräftiger und der Punkt eine Spur größer.
+- Die Linien verlaufen jetzt weich statt kantig. Gemessen wird weiterhin einmal je Sekunde,
+  gezeichnet wird viermal so fein: Zwischen zwei Messwerten liegen vier Stützpunkte auf
+  einem Kosinusbogen, der an den Messpunkten waagerecht beginnt und endet. Dadurch
+  entstehen dort keine Knicke mehr. Linienenden und -ecken sind zusätzlich abgerundet.
+
+Version 1.11.0:
+- Die Verlaufskurven im Dashboard beginnen jetzt immer am selben Punkt: Der älteste Wert
+  liegt links genau auf halber Höhe, die Kurve wächst von dort nach oben oder unten. Der
+  Verlauf sieht dadurch bei jeder Kesseltemperatur gleich aus.
+- Beide Kurven behalten denselben Maßstab. Die absolute Höhe lässt sich damit nicht mehr
+  zwischen Wasser und Dampf vergleichen - der Ausschlag aber schon: Wer weiter ausschlägt,
+  hat sich auch stärker verändert.
+- Am jüngsten Messwert sitzt ein kleiner weißer Punkt mit weichem Schein, der langsam
+  pulsiert.
+- Beide Linien sind jetzt weiß. Die Farbe der Karte steckt ohnehin in der Überschrift.
+
+Version 1.10.4:
+- Die Maßnahme aus 1.10.3 machte die Delle nach dem Standby länger statt kleiner. Sie
+  hielt beim Umschalten des Standby-Merkers den zuletzt gemeldeten Wert fest - zu diesem
+  Zeitpunkt lag die gestörte Probe aber bereits an. Festgehalten wurde also ausgerechnet
+  die Delle, und das sekundenlang.
+- Statt einer Sperrfrist tragen die Verlaufskurven jetzt den mittleren Wert der letzten
+  fünf Proben ein (Median). Eine oder zwei verirrte Proben verschwinden damit vollständig,
+  unabhängig davon, wann sie auftreten - beim Standby-Ende ebenso wie beim Bezugsstart.
+- Echte Temperaturänderungen kommen unverfälscht durch, nur zwei Sekunden später. Das ist
+  die Verzögerung, um die es hier ging.
+- Die angezeigten Temperaturzahlen bleiben weiterhin ungefiltert.
+
+Version 1.10.3:
+- Direkt nach dem Aufwachen aus dem Standby zog die Wasserkurve eine kurze Delle nach
+  unten. Ursache ist die Messung, nicht der Kessel: In genau diesem Moment schalten die
+  Heizungen, und der Wassersensor hängt als NTC am ADC. Ein Kessel kann binnen einer
+  Sekunde nicht um Grade einbrechen.
+- Die Verlaufskurven halten deshalb rund um jeden Standby-Wechsel sechs Sekunden lang
+  ihren letzten Wert, statt die gestörte Probe einzutragen. Das gilt für die kleinen
+  Kurven im Dashboard und für die große Verlaufsseite.
+- Die angezeigten Temperaturzahlen bleiben unverändert: Dort steht weiter, was gemessen
+  wird.
+- Die Versionsanzeige stand seit dem Zurücknehmen von 1.6.11 auf 1.6.10 fest und wurde bei
+  keinem der folgenden Stände mitgezogen. Sie zeigt jetzt wieder den echten Stand.
+
+Version 1.10.2:
+- Die Verlaufskurven im Dashboard wurden überhaupt nicht fortgeschrieben. Der Code dafür
+  stand am Ende der Umschaltung „Heizleistung anzeigen" auf der Verlauf-Seite - also im
+  Callback eines Knopfes. Die Kurven wuchsen nur weiter, wenn jemand genau diesen Knopf
+  drückte. Sonst zeigten sie unverändert den Wert, der beim Aufbau der Darstellung gerade
+  anlag: zwei flache, gleich hohe Linien.
+- Die Fortschreibung sitzt jetzt im sekündlichen Abtaster, dort, wo auch der große Verlauf
+  seine Messwerte nimmt. Damit bewegen sich die Kurven, und die gemeinsame Skala aus 1.10.1
+  kann ihre Arbeit überhaupt erst tun.
+
+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/config.h

@@ -126,7 +126,7 @@
 // -------------------------------------------------------------------------------------
 //  Firmware
 // -------------------------------------------------------------------------------------
-#define DISPLAY_FW_VERSION       "1.6.10"   // Firmware-Stand der P4-Display-Steuerung (Info-Seite)
+#define DISPLAY_FW_VERSION       "1.11.3"   // Firmware-Stand der P4-Display-Steuerung (Info-Seite)
 
 // -------------------------------------------------------------------------------------
 //  Protokoll

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

@@ -178,11 +178,29 @@ static void label_set_if_changed(lv_obj_t* lbl, const char* txt);   // Definitio
 enum TempDesign { TD_GEWICHTET = 0, TD_VERLAUF, TD_FLAECHEN, TD_BAND, TD_DESIGN_COUNT };
 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
+// Eine Minute Verlauf. Gemessen wird einmal je Sekunde, gezeichnet wird viermal so fein:
+// Zwischen zwei Messwerten liegen vier Stuetzpunkte auf einem Kosinusbogen. Aus dem
+// Streckenzug mit harten Ecken wird damit eine weich geschwungene Linie.
+#define SPARK_TEILUNG      4
+#define DASH_SPARK_STEP_MS 250
+#define DASH_SPARK_POINTS  (60 * SPARK_TEILUNG)
+// 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
+// Punkt am juengsten Messwert. Er pulsiert leicht und traegt einen weichen Schein - das
+// ist die einzige Stelle der Oberflaeche, an der etwas dauerhaft in Bewegung ist, und
+// deshalb bleibt er klein und langsam.
+#define SPARK_DOT_SIZE 10          // groesster Durchmesser des Punktes
+#define SPARK_DOT_MIN  7           // kleinster - dazwischen atmet er
+#define SPARK_DOT_PULS_MS 1100
 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;
 static lv_chart_series_t* g_sparkSerD = nullptr;
+static lv_obj_t* g_sparkDotW = nullptr;   // pulsierender Punkt am juengsten Messwert
+static lv_obj_t* g_sparkDotD = nullptr;
+static int32_t g_dotCxW = 0, g_dotCyW = 0;   // Mitte des Punktes in der Kurvenflaeche
+static int32_t g_dotCxD = 0, g_dotCyD = 0;
 static lv_obj_t* g_readyBand = nullptr;     // Zustandsband der Darstellung TD_BAND
 static lv_obj_t* g_readyBandLbl = nullptr;
 static lv_obj_t* g_tempRow = nullptr;       // Container; Inhalt wird je Design (neu) aufgebaut
@@ -719,13 +737,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 +946,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 +1123,195 @@ 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_sparkMinW = INT32_MIN;   // zuletzt gesetzter Ausschnitt je Kurve
+static int32_t g_sparkMaxW = INT32_MIN;
+static int32_t g_sparkMinD = INT32_MIN;
+static int32_t g_sparkMaxD = INT32_MIN;
+
+// Kurz nach einem Standby-Wechsel sackt die Wassertemperatur fuer einen Sekundenbruchteil
+// ab. In genau diesem Moment schalten die Heizungen, und der Wassersensor ist ein NTC am
+// ADC, einmal je Regelzyklus abgetastet - ein Kessel kann binnen einer Sekunde nicht um
+// Grade einbrechen, die Delle ist also eine Stoerung der Messung, kein Vorgang an der
+// Maschine.
+//
+// In die Kurven geht deshalb nicht die frische Probe, sondern der mittlere Wert der
+// letzten fuenf (Median). Eine oder zwei verirrte Proben verschwinden damit vollstaendig,
+// waehrend echte Temperaturaenderungen unverfaelscht durchkommen - nur eben zwei Sekunden
+// spaeter. Genau diese kleine Verzoegerung ist der Preis.
+//
+// Ein erster Anlauf hielt stattdessen beim Standby-Wechsel den zuletzt gemeldeten Wert
+// fest. Das machte es schlimmer: Beim Umschalten des Merkers lag die gestoerte Probe
+// bereits an, gehalten wurde also ausgerechnet die Delle - und zwar sekundenlang.
+// Die angezeigten Zahlen bleiben unangetastet - was gemessen wird, steht dort weiter drin.
+#define KURVEN_MEDIAN 5
+static float   g_medW[KURVEN_MEDIAN];
+static float   g_medD[KURVEN_MEDIAN];
+static uint8_t g_medPos  = 0;
+static uint8_t g_medFill = 0;
+
+// Mittlerer Wert von hoechstens fuenf Proben. Bei so wenigen Werten ist Sortieren durch
+// Einfuegen das Einfachste, was die Aufgabe loest.
+static float median_von(const float* quelle, uint8_t anzahl) {
+    float f[KURVEN_MEDIAN];
+    for (uint8_t i = 0; i < anzahl; i++) {
+        float v = quelle[i];
+        int8_t j = (int8_t)i - 1;
+        while (j >= 0 && f[j] > v) { f[j + 1] = f[j]; j--; }
+        f[j + 1] = v;
+    }
+    return f[anzahl / 2];
+}
+
+// Ausschnitt einer Kurve: Der aelteste Punkt - links am Rand - liegt genau auf halber
+// Hoehe, und die Kurve waechst von dort nach oben oder unten. Das ist der ruhige Eindruck,
+// den ein Verlauf haben soll: Er beginnt immer an derselben Stelle, egal bei welcher
+// Temperatur der Kessel gerade steht.
+//
+// Beide Kurven bekommen denselben Massstab (gleiche Grad je Bildpunkt). Die absolute Hoehe
+// laesst sich damit zwar nicht mehr vergleichen - dafuer aber der Ausschlag: Eine Kurve,
+// die doppelt so weit ausschlaegt, hat sich auch doppelt so stark veraendert.
+//
+// Rueckgabe: falsch, wenn die Kurve noch keinen brauchbaren Wert hat.
+static bool spark_anker(lv_obj_t* ch, lv_chart_series_t* ser, int32_t* anker, int32_t* abweichung) {
+    if (!ch || !ser) return false;
+    int32_t* pts = lv_chart_get_y_array(ch, ser);
+    if (!pts) return false;
+    uint32_t n = lv_chart_get_point_count(ch);
+    if (n == 0) return false;
+    uint32_t erster = lv_chart_get_x_start_point(ch, ser) % n;   // aeltester Punkt im Ring
+    int32_t a = pts[erster];
+    if (a == LV_CHART_POINT_NONE) return false;
+    int32_t weit = 0;
+    for (uint32_t i = 0; i < n; i++) {
+        if (pts[i] == LV_CHART_POINT_NONE) continue;
+        int32_t d = pts[i] - a;
+        if (d < 0) d = -d;
+        if (d > weit) weit = d;
+    }
+    *anker = a;
+    *abweichung = weit;
+    return true;
+}
+
+static void spark_dot_apply(lv_obj_t* d, int32_t groesse);   // weiter unten
+
+// Punkt am juengsten Messwert an seine Stelle setzen (rechter Rand, Hoehe nach Wert).
+static void spark_dot_place(lv_obj_t* ch, lv_chart_series_t* ser, lv_obj_t* dot,
+                            int32_t mn, int32_t mx) {
+    if (!ch || !ser || !dot) return;
+    if (mx <= mn) return;
+    int32_t* pts = lv_chart_get_y_array(ch, ser);
+    uint32_t n = lv_chart_get_point_count(ch);
+    if (!pts || n == 0) return;
+    uint32_t letzter = (lv_chart_get_x_start_point(ch, ser) + n - 1) % n;   // juengster Punkt
+    int32_t v = pts[letzter];
+    if (v == LV_CHART_POINT_NONE) { lv_obj_add_flag(dot, LV_OBJ_FLAG_HIDDEN); return; }
+    int32_t w = lv_obj_get_content_width(ch);
+    int32_t h = lv_obj_get_content_height(ch);
+    if (w <= 0 || h <= 0) return;
+    // Die Mitte des Punktes sitzt genau auf dem letzten Messwert, also am rechten Rand der
+    // Kurvenflaeche. Damit seine rechte Haelfte trotzdem nicht abgeschnitten wird, laesst
+    // das Diagramm rechts einen Rand frei (siehe tempSpark) - dort steht der Punkt, ohne
+    // dass die Linie unter ihm hervorschaut.
+    int32_t r = SPARK_DOT_SIZE / 2;
+    int32_t y = h - (int32_t)(((int64_t)(v - mn) * h) / (mx - mn));
+    if (y < r) y = r;
+    if (y > h - r) y = h - r;
+    if (dot == g_sparkDotW) { g_dotCxW = w; g_dotCyW = y; }
+    else                    { g_dotCxD = w; g_dotCyD = y; }
+    spark_dot_apply(dot, lv_obj_get_width(dot));
+    lv_obj_remove_flag(dot, LV_OBJ_FLAG_HIDDEN);
+}
+
+// Gefilterte Sekundenprobe, vom Abtaster gesetzt und vom Schritt-Timer abgeholt.
+static float g_probeW = 0.0f, g_probeD = 0.0f;
+static bool  g_probeGueltig = false;
+
+static void spark_ranges_fit() {
+    int32_t aW = 0, aD = 0, dW = 0, dD = 0;
+    bool okW = spark_anker(g_sparkW, g_sparkSerW, &aW, &dW);
+    bool okD = spark_anker(g_sparkD, g_sparkSerD, &aD, &dD);
+    if (!okW && !okD) return;                  // noch kein einziger Wert
+
+    int32_t halb = (okW && dW > dD) ? dW : dD; // gemeinsamer Massstab: der groessere Ausschlag
+    if (!okW) halb = dD;
+    if (!okD) halb = dW;
+    halb += halb / 8;                          // etwas Luft, damit die Kurve nicht den Rand kuesst
+    if (halb < DASH_SPARK_MIN_SPAN / 2) halb = DASH_SPARK_MIN_SPAN / 2;
+
+    // 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 (okW) {
+        int32_t mn = aW - halb, mx = aW + halb;
+        if (mn != g_sparkMinW || mx != g_sparkMaxW) {
+            g_sparkMinW = mn; g_sparkMaxW = mx;
+            lv_chart_set_range(g_sparkW, LV_CHART_AXIS_PRIMARY_Y, mn, mx);
+        }
+        spark_dot_place(g_sparkW, g_sparkSerW, g_sparkDotW, g_sparkMinW, g_sparkMaxW);
+    }
+    if (okD) {
+        int32_t mn = aD - halb, mx = aD + halb;
+        if (mn != g_sparkMinD || mx != g_sparkMaxD) {
+            g_sparkMinD = mn; g_sparkMaxD = mx;
+            lv_chart_set_range(g_sparkD, LV_CHART_AXIS_PRIMARY_Y, mn, mx);
+        }
+        spark_dot_place(g_sparkD, g_sparkSerD, g_sparkDotD, g_sparkMinD, g_sparkMaxD);
+    }
+}
+
+// Punkt in seiner aktuellen Groesse an seine Stelle setzen. Die Mitte ist gemerkt, denn
+// beim Atmen aendert sich die Groesse - ohne Nachfuehren wanderte der Punkt davon.
+static void spark_dot_apply(lv_obj_t* d, int32_t groesse) {
+    if (!d) return;
+    const int32_t cx = (d == g_sparkDotW) ? g_dotCxW : g_dotCxD;
+    const int32_t cy = (d == g_sparkDotW) ? g_dotCyW : g_dotCyD;
+    lv_obj_set_size(d, groesse, groesse);
+    lv_obj_align(d, LV_ALIGN_TOP_LEFT, cx - groesse / 2, cy - groesse / 2);
+}
+
+// Signalpunkt: Der Punkt selbst atmet leicht, und der Schein macht genau das Gegenteil.
+// Zieht der Punkt sich zusammen, geht der Schein auf; wird der Punkt wieder gross, zieht
+// der Schein sich zurueck. Das wirkt wie ein Signal, das ausgesendet wird.
+static void spark_dot_puls_cb(void* var, int32_t v) {          // v laeuft 0 .. 100
+    lv_obj_t* d = (lv_obj_t*)var;
+    spark_dot_apply(d, SPARK_DOT_MIN + ((SPARK_DOT_SIZE - SPARK_DOT_MIN) * v) / 100);
+    lv_obj_set_style_shadow_width(d, 30 - (22 * v) / 100, 0);            // 30 .. 8
+    lv_obj_set_style_shadow_opa(d, (lv_opa_t)(200 - (150 * v) / 100), 0); // 200 .. 50
+}
+static void spark_dot_puls(lv_obj_t* dot) {
+    lv_anim_t a; lv_anim_init(&a);
+    lv_anim_set_var(&a, dot);
+    lv_anim_set_exec_cb(&a, spark_dot_puls_cb);
+    lv_anim_set_values(&a, 0, 100);
+    lv_anim_set_duration(&a, SPARK_DOT_PULS_MS);
+    lv_anim_set_playback_duration(&a, SPARK_DOT_PULS_MS);
+    lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE);
+    lv_anim_set_path_cb(&a, lv_anim_path_ease_in_out);
+    lv_anim_start(&a);
+}
+
 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** dot, 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);
@@ -1125,18 +1320,47 @@ static lv_obj_t* tempSpark(lv_obj_t* parent, lv_color_t col, lv_chart_series_t**
     lv_obj_set_style_bg_opa(ch, LV_OPA_TRANSP, 0);
     lv_obj_set_style_border_width(ch, 0, 0);
     lv_obj_set_style_pad_all(ch, 4, 0);
+    // Rechts etwas mehr Rand: Dort steht der Punkt auf dem letzten Messwert. Der Platz
+    // gehoert noch zum Diagramm, wird aber nicht mehr bezeichnet - deshalb ragt weder die
+    // Linie unter dem Punkt hervor noch wird der Punkt an der Kante beschnitten.
+    lv_obj_set_style_pad_right(ch, SPARK_DOT_SIZE / 2 + 3, 0);
     lv_obj_set_style_size(ch, 0, 0, LV_PART_INDICATOR);        // keine Punktmarkierungen
     lv_obj_set_style_line_width(ch, 3, LV_PART_ITEMS);
+    // Runde Enden und Ecken: An den Stuetzpunkten sitzt damit kein spitzer Winkel.
+    lv_obj_set_style_line_rounded(ch, true, LV_PART_ITEMS);
+    // Der Punkt am juengsten Messwert sitzt am rechten Rand, sein Schein reicht darueber
+    // hinaus. Ohne diese Freigabe schneidet das Diagramm beides ab - der Punkt war
+    // angeschnitten, und vom Schein war ueberhaupt nichts zu sehen.
+    lv_obj_add_flag(ch, LV_OBJ_FLAG_OVERFLOW_VISIBLE);
+    lv_obj_add_flag(parent, LV_OBJ_FLAG_OVERFLOW_VISIBLE);   // dasselbe fuer die Karte
     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);
+    // Punkt am juengsten Messwert, mit weichem Schein. Er haengt als eigenes Element im
+    // Diagramm; gesetzt wird seine Stelle in spark_dot_place, sobald der Ausschnitt steht.
+    *dot = lv_obj_create(ch);
+    lv_obj_remove_style_all(*dot);
+    lv_obj_set_size(*dot, SPARK_DOT_SIZE, SPARK_DOT_SIZE);
+    lv_obj_set_style_radius(*dot, LV_RADIUS_CIRCLE, 0);
+    lv_obj_set_style_bg_color(*dot, lv_color_white(), 0);
+    lv_obj_set_style_bg_opa(*dot, LV_OPA_COVER, 0);
+    lv_obj_set_style_shadow_color(*dot, lv_color_white(), 0);
+    lv_obj_set_style_shadow_width(*dot, 18, 0);
+    lv_obj_set_style_shadow_opa(*dot, 130, 0);
+    lv_obj_set_style_shadow_spread(*dot, 1, 0);
+    lv_obj_remove_flag(*dot, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_remove_flag(*dot, LV_OBJ_FLAG_SCROLLABLE);
+    // Bis die erste Stelle berechnet ist, bleibt er verborgen - sonst blitzte er kurz
+    // in der linken oberen Ecke auf.
+    lv_obj_add_flag(*dot, LV_OBJ_FLAG_HIDDEN);
+    spark_dot_puls(*dot);
+
+    // 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 +1373,9 @@ static void build_temp_row_content() {
     bulbTempW = bulbTempD = nullptr;
     g_sparkW = g_sparkD = nullptr;
     g_sparkSerW = g_sparkSerD = nullptr;
+    g_sparkDotW = g_sparkDotD = nullptr;
+    g_sparkMinW = g_sparkMaxW = INT32_MIN;   // gemerkter Ausschnitt gilt fuer die alten Kurven
+    g_sparkMinD = g_sparkMaxD = INT32_MIN;
     g_readyBand = g_readyBandLbl = nullptr;
 
     const lv_color_t teal = lv_color_hex(0x80cbc4);
@@ -1173,10 +1400,15 @@ static void build_temp_row_content() {
     case TD_VERLAUF: {
         lv_obj_t* cw = tempField(g_tempRow, "WASSER", COL_ACCENT, &lblTempW, &lblSetW, &barDutyW,
                                  1, &lv_font_maven_pro_bold_96, false, 0);
-        g_sparkW = tempSpark(cw, COL_OK, &g_sparkSerW, g_state.tempW, g_state.setW);
+        // Beide Linien weiss: Die Farbe der Karte steckt schon in der Ueberschrift, und
+        // zwei verschiedenfarbige Linien nebeneinander wirken unruhiger als eine Sprache.
+        g_sparkW = tempSpark(cw, lv_color_white(), &g_sparkSerW, &g_sparkDotW,
+                             g_state.tempW, g_state.setW);
         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);
+        g_sparkD = tempSpark(cd, lv_color_white(), &g_sparkSerD, &g_sparkDotD,
+                             g_state.tempD, g_state.setD);
+        spark_ranges_fit();
         break;
     }
 
@@ -1675,20 +1907,6 @@ static void chart_duty_btn_cb(lv_event_t*) {
         else             lv_obj_add_flag(g_legDuty, LV_OBJ_FLAG_HIDDEN);
     }
     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);
-        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);
-        lv_chart_set_next_value(g_sparkD, g_sparkSerD, (int32_t)(g_state.tempD * 10.0f));
-    }
 }
 static void build_chart(lv_obj_t* p) {
     lv_obj_clear_flag(p, LV_OBJ_FLAG_SCROLLABLE);
@@ -1912,12 +2130,64 @@ static void chart_redraw() {
     }
     lv_chart_refresh(g_chart);
 }
+// Vier Stuetzpunkte je Messwert. Der Weg von der vorigen zur neuen Probe wird nicht
+// geradlinig genommen, sondern auf einem Kosinusbogen: Er beginnt und endet waagerecht,
+// weshalb an den Messpunkten kein Knick entsteht. Genau das macht den runden Eindruck.
+static void spark_step_cb(lv_timer_t*) {
+    if (!g_probeGueltig) return;
+    if (!g_sparkW && !g_sparkD) return;      // andere Darstellung: nichts zu tun
+
+    static float   vonW = 0.0f, zielW = 0.0f, vonD = 0.0f, zielD = 0.0f;
+    static bool    beginn = true;
+    static uint8_t schritt = SPARK_TEILUNG;
+
+    if (beginn) { vonW = zielW = g_probeW; vonD = zielD = g_probeD; beginn = false; }
+    if (schritt >= SPARK_TEILUNG) {           // neue Probe uebernehmen
+        vonW = zielW; zielW = g_probeW;
+        vonD = zielD; zielD = g_probeD;
+        schritt = 0;
+    }
+    schritt++;
+    const float t = (float)schritt / (float)SPARK_TEILUNG;
+    const float f = 0.5f - 0.5f * cosf(3.14159265f * t);
+
+    if (g_sparkSerW && g_sparkW)
+        lv_chart_set_next_value(g_sparkW, g_sparkSerW,
+                                (int32_t)((vonW + (zielW - vonW) * f) * 10.0f));
+    if (g_sparkSerD && g_sparkD)
+        lv_chart_set_next_value(g_sparkD, g_sparkSerD,
+                                (int32_t)((vonD + (zielD - vonD) * f) * 10.0f));
+    spark_ranges_fit();   // gemeinsamer Massstab, Punkt am juengsten Wert nachfuehren
+}
+
 static void chart_sample_cb(lv_timer_t*) {
+    // Verlaufskurven des Dashboards (Darstellung "Verlauf") fortschreiben. Das stand
+    // frueher am Ende von chart_duty_btn_cb - also im Callback eines Knopfes auf der
+    // Verlauf-SEITE. Die Kurven wurden dadurch nur fortgeschrieben, wenn jemand genau
+    // diesen Knopf drueckte; sonst zeigten sie unveraendert den Wert, der beim Aufbau
+    // der Darstellung gerade anlag. Beide Linien lagen deshalb flach und identisch.
+    //
+    // Bewusst vor dem Ausstieg unten: Die Kurven im Dashboard haengen nicht daran, ob
+    // die Verlauf-Seite mit ihrem grossen Diagramm schon aufgebaut ist.
+    // Frische Probe einreihen, in die Kurven geht der mittlere der letzten fuenf Werte.
+    g_medW[g_medPos] = g_state.tempW;
+    g_medD[g_medPos] = g_state.tempD;
+    g_medPos = (uint8_t)((g_medPos + 1) % KURVEN_MEDIAN);
+    if (g_medFill < KURVEN_MEDIAN) g_medFill++;
+    const float probeW = median_von(g_medW, g_medFill);
+    const float probeD = median_von(g_medD, g_medFill);
+
+    // In die Kurven geschrieben wird nicht hier, sondern viermal je Sekunde im
+    // Schritt-Timer - dazwischen liegen die Stuetzpunkte des Kosinusbogens.
+    g_probeW = probeW;
+    g_probeD = probeD;
+    g_probeGueltig = true;
+
     if (!g_chart || !g_hist) return;
     // 1-s-Probe in die 60-min-Historie (Ringpuffer); Anzeige zeichnet chart_redraw
     bool caseOn = g_state.caseSensorEnabled && g_state.hasCaseTemp;
-    g_hist->w[g_histPos] = (int16_t)(g_state.tempW * 10.0f + 0.5f);
-    g_hist->d[g_histPos] = (int16_t)(g_state.tempD * 10.0f + 0.5f);
+    g_hist->w[g_histPos] = (int16_t)(probeW * 10.0f + 0.5f);
+    g_hist->d[g_histPos] = (int16_t)(probeD * 10.0f + 0.5f);
     g_hist->c[g_histPos] = caseOn ? (int16_t)(g_state.caseTemp * 10.0f + 0.5f) : CHART_HIST_NONE;
     float dw = g_state.dutyW, dd = g_state.dutyD;
     g_hist->dutyW[g_histPos] = (uint8_t)(dw < 0.0f ? 0 : (dw > 100.0f ? 100 : (int)(dw + 0.5f)));
@@ -3573,13 +3843,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
@@ -4016,6 +4279,7 @@ void ui_init(ProtocolClient* client) {
     lv_timer_create(dash_timers_cb, 100, nullptr);    // Timer-Anzeige fortlaufend aktualisieren
     lv_timer_create(eco_case_timer_cb, 5000, nullptr); // Eco/Gehaeuse alle 5 s wechseln
     lv_timer_create(chart_sample_cb, 1000, nullptr);   // Verlauf jede Sekunde abtasten
+    lv_timer_create(spark_step_cb, DASH_SPARK_STEP_MS, nullptr);   // Kurven weich fortschreiben
 
     show_page(PG_DASH);
     if (g_client) g_client->sendListProfiles();
@@ -4024,8 +4288,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 +4482,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 -