Merge pull request 'feat(P4): Verlaufskurven mit festem Ausgangspunkt und pulsierendem Punkt (1.11.0)' (#87) from feat/verlaufskurven-anker-und-pulspunkt into main

Der aelteste Wert einer Kurve liegt jetzt links genau auf halber Hoehe,
die Kurve waechst von dort nach oben oder unten. Der Verlauf sieht damit
bei jeder Kesseltemperatur gleich aus.

Beide Kurven behalten denselben Massstab. Die absolute Hoehe laesst sich
dadurch nicht mehr zwischen Wasser und Dampf vergleichen, der Ausschlag
aber schon.

Am juengsten Messwert sitzt ein kleiner weisser Punkt mit weichem Schein,
der langsam pulsiert. Beide Linien sind weiss.

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,182 @@
+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
+  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
+  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
+  haben. Die Info-Seite zeigt jetzt nur noch Firmware-Stände und Verbindungsdaten.
+- Die Uhr im Standby ist auf dem 7-Zoll-Panel deutlich größer geworden: Die drei Stufen
+  liegen jetzt bei 180, 270 und 360 Pixeln statt bei 120, 180 und 240. Auf dem 4,3-Zoll-
+  Panel bleiben die bisherigen Stufen, dort passen größere schlicht nicht auf den Schirm.
+
+Version 1.9.5:
+- Die festen Breiten aus 1.9.4 haben nicht gereicht: Auch die HÖHE muss festliegen. LVGL
+  prüft beim Setzen eines Textes, ob sich die Eigengröße der Beschriftung geändert haben
+  könnte - ist eines der beiden Maße frei, gilt das Layout des Elternteils als neu zu
+  berechnen, und das macht die ganze Seite ungültig. Temperaturwerte, Sollwerte, die Werte
+  der unteren Zeile und die Uhrzeit in der Kopfleiste haben jetzt feste Maße in beide
+  Richtungen.
+- Die Uhrzeit hatte denselben Effekt in der Kopfleiste: Beim Wechsel der Minute wurde die
+  Leiste samt Menü-Knopf neu berechnet. Das erklärt den Bereich „x 6..57, y 2..41", der in
+  fast jedem Durchgang auftauchte.
+- Zusätzlich meldet die Firmware jetzt, wenn der Inhaltsbereich oder die Dashboard-Seite als
+  Ganzes ungültig gemacht wird. Damit ist zu unterscheiden, ob eine einzelne Beschriftung
+  den Bildaufbau auslöst oder gleich der komplette Bereich - zwei verschiedene Ursachen mit
+  verschiedenen Gegenmitteln.
+
+Version 1.9.4:
+- Die Messung mit Koordinaten hat den Verursacher benannt: Der ungültige Bereich war
+  „x 0..1279, y 44..719" - also der gesamte Inhalt unterhalb der Kopfleiste, bei jeder
+  Zustandsmeldung.
+- Grund: Die Anzeigewerte hatten keine feste Breite. Wächst oder schrumpft eine Beschriftung
+  mit ihrem Inhalt - etwa von „92,4 °C" auf „100,1 °C" -, rechnet LVGL das Layout der
+  gesamten Seite neu und macht sie dabei komplett ungültig. Es genügt also nicht, den Text
+  nur bei echter Änderung zu setzen; er darf beim Ändern auch die Breite nicht verändern.
+- Temperaturwerte, Sollwerte und die Werte der unteren Zeile haben jetzt eine feste Breite
+  mit zentriertem Text. Sichtbar ändert sich dadurch nichts - die Werte standen ohnehin
+  mittig.
+
 Version 1.9.3:
 - Fehlerbehebung: Bei geöffnetem Menü war der Seiteninhalt dahinter verschwunden. Der
   Vorhang des Menüs war in 1.8.7 deckend gemacht worden, um Zeichenlast zu sparen - dabei

P4_Display_Firmware/P4_Display_Firmware.ino

@@ -67,7 +67,7 @@ static void onState(const MachineState& st) {
     }
     if (bl < 0) bl = 0; if (bl > 100) bl = 100;
     if (bl != s_lastBacklight) {
-        hal_backlight(bl);
+        hal_backlight(bl);   // meldet seine Dauer selbst, siehe jc_backlight_set()
         s_lastBacklight = bl;
     }
 }
@@ -307,19 +307,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/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.0"   // Firmware-Stand der P4-Display-Steuerung (Info-Seite)
 
 // -------------------------------------------------------------------------------------
 //  Protokoll

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
@@ -571,7 +573,9 @@
                                 LV_FONT_DECLARE(lv_font_maven_pro_bold_140) \
                                 LV_FONT_DECLARE(lv_font_clock_120) \
                                 LV_FONT_DECLARE(lv_font_clock_180) \
-                                LV_FONT_DECLARE(lv_font_clock_240)
+                                LV_FONT_DECLARE(lv_font_clock_240) \
+                                LV_FONT_DECLARE(lv_font_clock_270) \
+                                LV_FONT_DECLARE(lv_font_clock_360)
 
 /*Always set a default font*/
 #define LV_FONT_DEFAULT &lv_font_maven_pro_14

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

@@ -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>
@@ -127,8 +128,8 @@ static lv_obj_t* g_otaStatus = nullptr;
 static lv_obj_t* g_otaBytes  = nullptr;
 
 // Navigation
-enum { PG_DASH = 0, PG_CHART, PG_STATS, PG_TEMP, PG_BREW, PG_COLDEX, PG_SERVICE, PG_PROFILE, PG_LIGHT, PG_WIFI, PG_INFO, PG_COUNT };
-static const char* PAGE_NAMES[PG_COUNT] = { "Dashboard", "Verlauf", "Statistik", "Temperatur", "Brew-Control", "Cold Extraction", "Reinigung/Wartung", "Profile", "Licht", "WiFi", "Info" };
+enum { PG_DASH = 0, PG_CHART, PG_STATS, PG_TEMP, PG_BREW, PG_COLDEX, PG_SERVICE, PG_PROFILE, PG_LIGHT, PG_WIFI, PG_DISPLAY, PG_INFO, PG_COUNT };
+static const char* PAGE_NAMES[PG_COUNT] = { "Dashboard", "Verlauf", "Statistik", "Temperatur", "Brew-Control", "Cold Extraction", "Reinigung/Wartung", "Profile", "Licht", "WiFi", "Darstellung", "Info" };
 static lv_obj_t* g_content = nullptr;
 static lv_obj_t* g_pages[PG_COUNT] = { nullptr };
 static lv_obj_t* g_drawer = nullptr;
@@ -178,10 +179,20 @@ 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
+// 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 12
+#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 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
@@ -700,9 +711,17 @@ static lv_obj_t* g_clockSizeBtn[3] = {};
 
 static const lv_font_t* clock_font() {
     switch (g_clockSize) {
+#if JC_PANEL_TYPE == WS_PANEL_7H
+        // 7 Zoll, 1280x720: Hier war selbst die groesste Stufe noch zu klein.
+        case UHR_KLEIN:  return &lv_font_clock_180;
+        case UHR_MITTEL: return &lv_font_clock_270;
+        default:         return &lv_font_clock_360;
+#else
+        // 4,3 Zoll, 480x480: Groessere Stufen passen schlicht nicht auf das Panel.
         case UHR_KLEIN:  return &lv_font_clock_120;
         case UHR_MITTEL: return &lv_font_clock_180;
         default:         return &lv_font_clock_240;
+#endif
     }
 }
 
@@ -710,13 +729,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);
@@ -921,7 +937,9 @@ 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
+    wake_confirm_show();
+}
 static void wake_cancel() {                  // Abbrechen -> zurueck in die Standby-Helligkeit
     wake_timeout_stop();
     wake_confirm_hide();
@@ -1056,6 +1074,18 @@ static lv_obj_t* tempField(lv_obj_t* parent, const char* title, lv_color_t accen
     lv_label_set_text(*big, "--.-");
     lv_obj_set_style_text_color(*big, COL_TEXT, 0);
     lv_obj_set_style_text_font(*big, valueFont, 0);
+    // Feste Breite, Text zentriert. Waechst oder schrumpft eine Beschriftung mit ihrem
+    // Inhalt - etwa von "92,4 °C" auf "100,1 °C" -, rechnet LVGL das Flex-Layout der
+    // gesamten Seite neu und macht sie damit komplett ungueltig. Genau das war im
+    // Messprotokoll als "x 0..1279, y 44..719" zu sehen: der ganze Inhaltsbereich, bei
+    // jeder Zustandsmeldung. Mit fester Breite bleibt nur die Beschriftung selbst ungueltig.
+    lv_obj_set_width(*big, LV_PCT(100));
+    lv_obj_set_style_text_align(*big, LV_TEXT_ALIGN_CENTER, 0);
+    // Auch die HOEHE muss fest sein. LVGL prueft beim Setzen eines Textes, ob sich die
+    // Eigengroesse der Beschriftung geaendert haben koennte - ist eines der beiden Masse
+    // frei, gilt das Layout des Elternteils als neu zu berechnen, und das macht die ganze
+    // Seite ungueltig. Erst mit festen Massen bleibt nur die Beschriftung selbst ungueltig.
+    lv_obj_set_height(*big, lv_font_get_line_height(valueFont) + 6);
     // Grosse Zahlen etwas enger setzen. Bei dieser Groesse wirken die Werksabstaende
     // auseinandergezogen; ein paar Pixel weniger binden die Ziffern zu einer Zahl zusammen.
     if (valueFont == &lv_font_maven_pro_bold_140)     lv_obj_set_style_text_letter_space(*big, -3, 0);
@@ -1065,6 +1095,9 @@ static lv_obj_t* tempField(lv_obj_t* parent, const char* title, lv_color_t accen
     lv_label_set_text(*setp, "Soll --.-");
     lv_obj_set_style_text_color(*setp, COL_TEXT_DIM, 0);
     lv_obj_set_style_text_font(*setp, font_text(), 0);
+    lv_obj_set_width(*setp, LV_PCT(100));
+    lv_obj_set_style_text_align(*setp, LV_TEXT_ALIGN_CENTER, 0);
+    lv_obj_set_height(*setp, lv_font_get_line_height(font_text()) + 6);
 
     *bar = lv_bar_create(c);
     lv_obj_set_size(*bar, LV_PCT(92), 8);
@@ -1082,10 +1115,170 @@ 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;
+}
+
+// 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;
+    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;
+    lv_obj_align(dot, LV_ALIGN_TOP_LEFT, w - r, y - r);   // Mitte auf den letzten Punkt
+    lv_obj_remove_flag(dot, LV_OBJ_FLAG_HIDDEN);
+}
+
+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);
+    }
+}
+
+// Weiches Pulsieren des Punktes: Nur der Schein atmet, der Punkt selbst bleibt ruhig.
+static void spark_dot_puls_cb(void* var, int32_t v) {
+    lv_obj_t* d = (lv_obj_t*)var;
+    lv_obj_set_style_shadow_width(d, 6 + v / 5, 0);          // 6 .. 26
+    lv_obj_set_style_shadow_opa(d, (lv_opa_t)(50 + v), 0);   // 50 .. 150
+}
+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);
@@ -1099,13 +1292,30 @@ 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);
+    // 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, 10, 0);
+    lv_obj_set_style_shadow_opa(*dot, 90, 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
@@ -1118,6 +1328,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);
@@ -1142,10 +1355,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;
     }
 
@@ -1210,6 +1428,10 @@ static lv_obj_t* infoCell(lv_obj_t* parent, const char* title, lv_obj_t** val, l
     lv_obj_set_style_text_color(*val, COL_TEXT, 0);
     lv_obj_set_style_text_font(*val, font_title(), 0);
     lv_obj_set_style_text_align(*val, LV_TEXT_ALIGN_CENTER, 0);   // fuer mehrzeilige Werte
+    // Feste Masse in BEIDE Richtungen - siehe die ausfuehrliche Begruendung in tempField.
+    // Zwei Zeilen Platz, weil manche Werte zweizeilig sind ("32,4 g / 36,0 g").
+    lv_obj_set_width(*val, LV_PCT(100));
+    lv_obj_set_height(*val, lv_font_get_line_height(font_title()) * 2 + 6);
     return card;
 }
 // Tipp auf die Statuszeile: Wartung -> Serviceseite, Reinigung -> Sub-Screen,
@@ -1640,20 +1862,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);
@@ -1878,11 +2086,33 @@ static void chart_redraw() {
     lv_chart_refresh(g_chart);
 }
 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);
+
+    if (g_sparkSerW && g_sparkW)
+        lv_chart_set_next_value(g_sparkW, g_sparkSerW, (int32_t)(probeW * 10.0f));
+    if (g_sparkSerD && g_sparkD)
+        lv_chart_set_next_value(g_sparkD, g_sparkSerD, (int32_t)(probeD * 10.0f));
+    spark_ranges_fit();   // gemeinsame Skala, damit die Hoehen vergleichbar bleiben
+
     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)));
@@ -3081,8 +3311,10 @@ static void brew_live_sw_cb(lv_event_t* e) {
     { Preferences prefs; prefs.begin("ui", false); prefs.putBool("brewlive", g_brewLiveEnabled); prefs.end(); }
     if (!g_brewLiveEnabled) brew_live_hide();   // laeuft gerade ein Bezug: sofort ausblenden
 }
-static void build_info(lv_obj_t* p) {
-    section_title(p, "Darstellung");
+// Eigener Menuepunkt "Darstellung". Die Einstellungen sassen frueher oben auf der
+// Info-Seite; dort standen sie zwischen Firmware-Staenden und Verbindungsdaten,
+// mit denen sie nichts zu tun haben.
+static void build_display(lv_obj_t* p) {
     lv_obj_t* dcard = th_card(p);
     lv_obj_set_width(dcard, LV_PCT(100));
     lv_obj_set_height(dcard, LV_SIZE_CONTENT);
@@ -3135,6 +3367,9 @@ static void build_info(lv_obj_t* p) {
     sw_set(swBrewLive, g_brewLiveEnabled);
     lv_obj_add_event_cb(swBrewLive, brew_live_sw_cb, LV_EVENT_VALUE_CHANGED, nullptr);
 
+}
+
+static void build_info(lv_obj_t* p) {
     section_title(p, "Firmware-Stände & Verbindung");
 
     lv_obj_t* card = th_card(p);
@@ -3523,7 +3758,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.
@@ -3533,6 +3768,36 @@ static void refr_ready_cb(lv_event_t*) {
                        (int)g_refrArea[i].y1, (int)g_refrArea[i].y2);
 }
 
+// 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() {
     lv_display_t* d = lv_display_get_default();
     if (!d) return;
@@ -3650,6 +3915,11 @@ void ui_init(ProtocolClient* client) {
     lv_obj_set_style_text_color(g_clock, COL_TEXT, 0);
     lv_obj_set_style_pad_right(g_clock, 10, 0);
     lv_obj_set_style_text_font(g_clock, font_text(), 0);
+    // Feste Masse, sonst rechnet LVGL beim Wechsel der Minute das Layout der Kopfleiste neu
+    // und macht sie samt Menue-Knopf ungueltig (siehe tempField).
+    lv_obj_set_width(g_clock, 130);
+    lv_obj_set_height(g_clock, lv_font_get_line_height(font_text()) + 4);
+    lv_obj_set_style_text_align(g_clock, LV_TEXT_ALIGN_RIGHT, 0);
 
     g_wifiIcon = lv_label_create(header);
     lv_label_set_text(g_wifiIcon, LV_SYMBOL_WIFI);
@@ -3677,6 +3947,7 @@ void ui_init(ProtocolClient* client) {
     g_pages[PG_SERVICE] = make_page(g_content); build_service(g_pages[PG_SERVICE]);
     g_pages[PG_WIFI]    = make_page(g_content); build_wifi(g_pages[PG_WIFI]);
     g_pages[PG_PROFILE] = make_page(g_content); build_profiles(g_pages[PG_PROFILE]);
+    g_pages[PG_DISPLAY] = make_page(g_content); build_display(g_pages[PG_DISPLAY]);
     g_pages[PG_INFO]    = make_page(g_content); build_info(g_pages[PG_INFO]);
 
     // --- Schublade (Scrim + Menue-Panel) ---
@@ -3937,7 +4208,13 @@ void ui_init(ProtocolClient* client) {
     show_page(PG_DASH);
     if (g_client) g_client->sendListProfiles();
 
-    refr_monitor_install();
+    // 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;
+#if WS7_PERF_MONITOR
+    refr_monitor_install();   // nur zum Einmessen, siehe WS7_PERF_MONITOR
+#endif
     g_uiReady = true;
 }
 
@@ -4034,12 +4311,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) {