feat(P4): Cold Extraction am Touch-Display + RX-Zeilenlimit-Fix (1.1.0 / S3 5.3.2)

Display-Seite der kalten Extraktion: Schalter unter "Modi" auf der Temperatur-Seite
mit Erklärzeile, eigener Slot in der Statuszeile direkt hinter der
Sicherheitsmeldung, "Cold Extraction - Heizen aus" in der Wasser-Kachel statt eines
unerreichbaren Sollwerts, unterdrückter Aufheiz-Countdown, "Vorbenetzung" als erste
Phase des kalten Bezugs, Parameter-Anzeige auf der Brew-Seite und "(kalt)"-Markierung
in der Statistik (kalte Bezüge zählen nicht in die mittlere Dauer).

Bug-Fix P4: PROTO_RX_LINE_MAX lag bei 2048 Bytes, während die State-Zeile der S3
bereits rund 2,1 KB erreicht. Mit langem Status-, Profil- oder SSID-Text lag sie
darüber — dann wurde die ganze Zeile verworfen und das Display fror auf dem letzten
Stand ein, ohne dass die Verbindung als tot erkannt wurde. Limit jetzt 4096 Bytes;
der Puffer bleibt bei 2 KB reserviert, weil der interne RAM knapp ist und eine
Arduino-String nicht ins PSRAM alloziert werden kann.

S3 5.3.2: Sperrgrund und transiente Meldung gehen als Codes (cxBlock/cxNotice) statt
als Klartext ans Display, dazu cxPreInf für die Phasenleiste. Der bis zu 110 Byte
lange Freitext hätte die State-Zeile über das Zeilenlimit gedrückt; die Texte rendert
jetzt das Display, analog zur Trennung statusKey/statusText. Auf dem OLED und in den
ack-Antworten bleibt der Klartext unverändert.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Changelog.txt

@@ -1,3 +1,93 @@
+Version 5.3.2:
+- Cold Extraction sendet den Sperrgrund jetzt als Code („cxBlock") statt als Klartext („cxMessage"),
+  dazu eine transiente Meldung als Code („cxNotice") und die Vorbenetzungsdauer („cxPreInf").
+  Hintergrund: Die State-Zeile ans Touch-Display liegt real bereits bei rund 2,1 KB, und der P4
+  verwirft eingehende Zeilen ab einer Obergrenze komplett - ein bis zu 110 Byte langer Klartext
+  hätte die Zeile über diese Grenze gedrückt und damit die ganze Telemetrie unbrauchbar gemacht.
+  Die Texte rendert jetzt das Display, analog zur bestehenden Trennung statusKey/statusText.
+- Der Klartext bleibt unverändert auf dem OLED und in den Web-/UART-Antworten (ack-message).
+
+Version 5.3.1:
+- Cold Extraction ist jetzt persistent: Der Modus wird im EEPROM gespeichert und überlebt sowohl den
+  Standby als auch einen Neustart. Zuvor wurde er beim Standby beendet und war nach dem Aufwachen aus -
+  die Maschine heizte dann erst auf, obwohl der nächste kalte Bezug einen kalten Kessel braucht, und man
+  musste auf das Abkühlen warten. Wer nur kalte Bezüge machen will, schaltet den Modus damit einmal ein
+  und wieder aus, wenn er fertig ist.
+- Der Modus fällt nur weg, wenn auf /Brew-Control die Freischaltung entzogen wird oder ein Werksreset
+  läuft. Solange er aktiv ist, heizt der Wasserkreis nicht - Dashboard, OLED („(COLD)" in der Wasserzeile)
+  und Touch-Display zeigen das durchgehend an.
+
+Version 5.3.0:
+- Neu: Cold Extraction (kalte Extraktion). Die Maschine hat keinen Bypass um den Wasserkessel, kaltes Wasser
+  kommt also nur bei kaltem Kessel am Puck an. Die Funktion wird deshalb über eine Temperaturschwelle
+  freigegeben (Standard 30 °C, einstellbar 10–40 °C) und ist praktisch aus dem kalten Zustand heraus nutzbar.
+- Solange der Modus aktiv ist, heizt der Wasserkreis nicht (SSR gesperrt, Stellgröße und damit auch die
+  dutyW-Telemetrie auf 0, I-Anteil der Wasser-PID eingefroren, Feed-Forward-Boost deaktiviert). Der
+  Dampfkreis bleibt unberührt und darf weiter heizen.
+- Die Freigabe wird vor jedem Bezug neu geprüft, nicht nur beim Aktivieren: Da der Dampfkessel weiter heizt,
+  kann der Wasserkessel über die Zeit über die Schwelle steigen. In diesem Fall wird der nächste Bezug
+  abgewiesen (Meldung auf OLED, Touch-Display und im Web-Dashboard) - ein laufender Bezug wird nie abgebrochen.
+  Hysterese von 5 °C, damit die Anzeige an der Schwelle nicht flattert; Sensorfehler sperrt die Funktion.
+- Der Fluss wird über Pumpen-Pulsung reduziert (Pulsperiode 200–5000 ms, Pumpenleistung 5–100 %), davor läuft
+  eine einstellbare Vorbenetzung mit voller Pumpenleistung. Bezugsende über Zielgewicht oder Sicherheits-Timeout;
+  Brew-by-Time/Brew-by-Weight und FlowGuard sind während einer kalten Extraktion bewusst außer Kraft (FlowGuard
+  und Cold Extraction würden sonst um denselben Pumpen-Ausgang konkurrieren).
+- Pumpenschutz: Die Steuerung zählt die kumulierte Pumpen-Einschaltzeit und legt nach der eingestellten
+  Laufzeit eine Zwangspause ein (Standard 60 s Laufzeit / 20 s Pause). Zusätzlich Stillstands-Erkennung -
+  läuft die Pumpe bei aktiver Waage 15 s ohne Zulauf, wird der Bezug beendet (dichter Puck oder ausgelöster
+  Pumpen-Thermoschutz).
+- Bedienung: Parameter auf der Seite /Brew-Control, Ein-/Ausschalten über das Web-Dashboard oder das
+  UART-Touch-Display (neue Aktionen "startColdExtraction"/"stopColdExtraction"/"toggleColdExtraction").
+  Cold Extraction ist bewusst kein Profilfeld (maschinen- und situationsabhängig, wie der Feed-Forward);
+  der Modus selbst wird nicht persistiert und ist nach einem Neustart immer aus. Standby beendet ihn.
+- Statistik: Kalte Bezüge werden im Log mit einem vierten CSV-Feld "C" gekennzeichnet, zählen in allen
+  Stückzahlen mit, gehen aber NICHT in die durchschnittliche Bezugsdauer ein (Minuten statt Sekunden würden
+  den Wert verzerren). Die Info-Seite weist die Anzahl separat aus, der Verlaufs-Download hat eine neue
+  Spalte "Art". Ältere Logzeilen bleiben unverändert lesbar.
+- Neue additive State-Felder im UART-JSON (Protokoll bleibt v2): cxEnabled, cxActive, cxShot, cxAllowed,
+  cxResting, cxMaxTemp, cxTarget, cxMaxSecs, cxMessage sowie "cx" pro Eintrag in usageStats; neuer
+  statusKey "coldextraction". Ältere Display-Firmware ignoriert die Felder.
+
+Version 5.2.0:
+- Feed-Forward bei Bezug (Störgrößenaufschaltung) für den Wasserkessel: Während eines Bezugs wird der
+  Heizung sofort ein einstellbarer Leistungs-Boost (0–100 % der Fenstergröße, 0 % = aus) aufgeschaltet,
+  statt auf den vom Sensor gemeldeten Temperaturabfall zu warten. Die PID regelt nur noch den Restfehler;
+  der Temperatur-Dip während des Shots wird deutlich kleiner. Einstellung auf der /PID-Seite
+  („Feed-Forward bei Bezug"), gespeichert im EEPROM (bewusst kein Profilfeld, da maschinenabhängig).
+- Optional: I-Anteil der Wasser-PID während des Bezugs einfrieren. Verhindert das Aufladen des
+  Integral-Anteils während des Shots und damit das Überschwingen nach Bezugsende.
+- Der Boost wirkt nur bei echten Bezügen (Hardware-Schalter oder Software-Start), nicht bei
+  Spülen/Wartungsmodus/AutoTune. Sicherheitslogik unverändert: Sensorfehler, Übertemperatur-Abschaltung
+  und „Heizen oberhalb Setpoint verhindern" haben weiterhin Vorrang; Deckelung auf die Fenstergröße.
+- Die Heizleistungs-Telemetrie (dutyW, u. a. für das Verlaufs-Chart des Touch-Displays) zeigt den
+  Boost mit an - damit ist die Wirkung direkt im Chart kalibrierbar.
+
+Version 5.1.2:
+- Profil-Seite (Web-UI): Die neue „Aktives Profil"-Anzeige stand linksbündig außerhalb des
+  Karten-Layouts. Sie nutzt jetzt den status-message-Stil der Seite (zentriert, max. 600 px,
+  dezenter Rahmen) und fügt sich damit in das bestehende Layout ein; Profilname zusätzlich fett.
+
+Version 5.1.1:
+- Aktives Profil wird jetzt geführt und angezeigt: Die Steuerung merkt sich das zuletzt geladene bzw.
+  gespeicherte Profil dauerhaft im EEPROM (überlebt Neustarts). Web-UI: Anzeige auf dem Dashboard über der
+  Profil-Auswahl sowie auf der Profil-Seite (aktives Profil zusätzlich mit grünem Punkt in der Liste).
+- „Geändert"-Erkennung: Werden nach dem Laden profil-relevante Einstellungen geändert (Solltemperaturen,
+  PID-Werte inkl. AutoTune-Ergebnis und AutoTune-Parameter, Boost, Eco, Dampfverzögerung, Fast-Heat-Up,
+  Brew-Control, Piezo), erscheint hinter dem Profilnamen „✱ (geändert)". Reine Anzeige-/Systemeinstellungen
+  (Anzeigemodus, Aufheizzeit, Licht, FlowGuard, Waage/Sensoren) lösen das bewusst nicht aus.
+- Profil löschen setzt die Anzeige zurück, wenn das gelöschte Profil das aktive war; Werksreset ebenso.
+- Neue additive State-Felder "profile" und "profDirty" im UART-JSON für das Touch-Display (Protokoll bleibt
+  kompatibel, ältere Display-Firmware ignoriert die Felder) - Grundlage für die Profil-Schnellwahl am Display.
+
+Version 5.1.0:
+- Display-Auswahl in die Web-UI (/Sensoren) verlegt: Ohne Display / OLED (SH1106, I2C) / UART-Touch-Display.
+  Der Compile-Schalter ENABLE_DISPLAY entfällt, die Einstellung wird im EEPROM gespeichert und ohne Neustart
+  übernommen. Default ist "Ohne Display", damit die Steuerung ohne angeschlossene Anzeige immer sicher startet.
+- Boot-Schutz: Vor der OLED-Initialisierung wird per I2C-Probe (0x3C) geprüft, ob das Display wirklich
+  angeschlossen ist. Ohne Antwort bleibt die Anzeige deaktiviert und die Steuerung bootet normal weiter -
+  eine falsch gesetzte Display-Einstellung kann die Maschine damit nicht mehr blockieren.
+- UART-Touch-Anbindung (Serial1) wird nur noch initialisiert und bedient, wenn "UART-Touch-Display" gewählt ist.
+
 Version 5.0.12:
 - Neues additives Feld "piState" im State-JSON für das UART-Touch-Display (0=inaktiv, 1=Pre-Infusion,
   2=Pause, 3=Hauptbezug): Die Pre-Infusion-Phasenleiste auf dem Display folgt damit quelltreu der echten

Doku/JC-Display_UART-Protokoll.md

@@ -157,6 +157,8 @@ Erzeugt von `buildTouchUartStateJson()`. Alle Felder in einem flachen JSON-Objek
 | `steamHeatDisabled` | bool | Dampfheizung per Nutzer deaktiviert |
 | `lightOn` | bool | Beleuchtung an |
 | `piezoEnabled` | bool | Piezo-Summer aktiv |
+| `profile` | string | zuletzt geladenes/gespeichertes Profil, leer = keines (additiv seit S3 5.1.1) |
+| `profDirty` | bool | profil-relevante Einstellungen seit dem Laden geändert (additiv seit S3 5.1.1) |
 | `weight` | float | aktuelles Waagengewicht (UI) |
 | `targetWeight` | float | Ziel-Gewicht (Brew-by-Weight) |
 | `scaleEnabled` | bool | Waage aktiviert |
@@ -313,6 +315,26 @@ Alle gültigen `action`-Strings aus `executeDashboardAction()` (Stand v4.8.1, Ze
 | `disableSteamHeat` | — | Dampf-Heizung abschalten |
 | `enableSteamHeat` | — | Dampf-Heizung wieder aktivieren |
 
+**Cold Extraction (kalte Extraktion, ab S3 5.3.0)**
+
+| `action` | `value` | Wirkung |
+|---|---|---|
+| `startColdExtraction` | — | Modus aktivieren (Wasserkreis heizt nicht, Dampf bleibt möglich) |
+| `stopColdExtraction` | — | Modus beenden |
+| `toggleColdExtraction` | — | Modus umschalten |
+
+Alle drei Aktionen werden abgewiesen (`ok:false` + `message`), solange die Bedingungen nicht
+erfüllt sind — Hauptfall ist ein zu warmer Wasserkessel (`cxAllowed:false`). Der Modus ist
+**persistent** (EEPROM) und überlebt Standby und Neustart; er endet nur durch explizites
+Ausschalten, durch Entzug der Freischaltung auf `/Brew-Control` oder durch einen Werksreset.
+Das P4-UI sollte `cxActive` deshalb dauerhaft sichtbar spiegeln — sonst wundert sich der
+Benutzer, warum die Maschine nicht heizt. Ein laufender Bezug wird nie abgebrochen,
+`stopColdExtraction` schlägt dann fehl.
+
+Die Parameter der kalten Extraktion (Schwelle, Vorbenetzung, Pulsperiode, Pumpenleistung,
+Zielgewicht, Timeout, Pumpenschutz) sind bewusst **nicht** über `saveBrew` erreichbar, sondern
+nur über die Web-Seite `/Brew-Control`. Das Display schaltet den Modus, konfiguriert ihn nicht.
+
 **Persistente Toggles**
 
 | `action` | `value` | Wirkung |
@@ -352,7 +374,40 @@ Aus `getTouchUartStatus()`. Für sprach-unabhängige UI-Logik/Icons auf dem P4 v
 (statt `statusText` zu parsen):
 
 `ready`, `error`, `standby`, `maintenance`, `tuning`, `brewing`, `eco`, `fastheatup`,
-`heating`, `ready_eco_pending`.
+`heating`, `ready_eco_pending`, `coldextraction` (ab S3 5.3.0).
+
+### Cold-Extraction-Felder im `state` (ab S3 5.3.0, additiv — Protokoll bleibt v2)
+
+| Feld | Typ | Bedeutung |
+|---|---|---|
+| `cxEnabled` | bool | Funktion in der Web-UI freigeschaltet (sonst Bedienelement ausblenden) |
+| `cxActive` | bool | Modus scharf: Wasserkreis heizt nicht |
+| `cxShot` | bool | Der laufende Bezug ist eine kalte Extraktion |
+| `cxAllowed` | bool | Freigabe **jetzt** (Wasserkessel kalt genug, kein Standby/Wartung/Tuning) |
+| `cxResting` | bool | Zwangspause des Pumpenschutzes läuft (Bezug läuft weiter) |
+| `cxMaxTemp` | float | Freigabeschwelle in °C (für eigene Hinweistexte am Display) |
+| `cxTarget` | float | Zielgewicht in g |
+| `cxPreInf` | float | Vorbenetzung in s (für die Phasenleiste des kalten Bezugs) |
+| `cxMaxSecs` | float | Sicherheits-Timeout des Bezugs in s |
+| `cxBlock` | uint8 | Sperrgrund (siehe unten), `0` = frei |
+| `cxNotice` | uint8 | transiente Meldung, `0` = keine (läuft nach ~6 s selbst ab) |
+
+`cxBlock`: `0` frei, `1` nicht freigeschaltet, `2` Standby, `3` Wartungsmodus,
+`4` Reinigungsassistent, `5` PID-Tuning, `6` Sensorfehler, `7` Wasserkessel zu warm.
+
+`cxNotice`: `0` keine, `1` Start abgewiesen (Grund steht in `cxBlock`), `2` Bezug wegen
+fehlenden Zulaufs beendet, `3` Umschalten während eines Bezugs abgelehnt.
+
+Bewusst **Codes statt Klartext**: Die State-Zeile muss unter dem Zeilenlimit des P4 bleiben
+(`PROTO_RX_LINE_MAX`; sie liegt real bereits bei ~2,1 KB), und die Texte gehören ins Display —
+dieselbe Trennung wie bei `statusKey`/`statusText`.
+
+Während `cxShot` folgt die Phase weiterhin `piState`: `1` = Vorbenetzung, `3` = Hauptbezug
+(gepulst). Eine Pause-Phase (`2`) gibt es bei der kalten Extraktion nicht.
+
+In der Antwort auf `getUsageStats` trägt jeder Eintrag in `shots[]` zusätzlich `cx` (bool) —
+kalte Bezüge zählen in `total`/`today`/`week` mit, sind aber in der durchschnittlichen
+Bezugsdauer der S3-Statistik ausgenommen.
 
 ---
 

JC_Display_Firmware/Changelog.txt

@@ -1,3 +1,54 @@
+Version 1.1.0:
+- Cold Extraction am Display bedienbar (braucht S3-Firmware ab 5.3.2):
+  - Neuer Schalter „Cold Extraction" auf der Seite „Temperaturen" unter „Modi", darunter eine
+    Erklärzeile mit dem aktuellen Zustand bzw. dem Sperrgrund. Schalter und Zeile bleiben
+    unsichtbar, solange die S3 die Funktion nicht freigeschaltet meldet (auch bei älterer
+    S3-Firmware, die die Felder gar nicht sendet).
+  - Einschalten ist nur bei erteilter Freigabe möglich (Wasserkessel kalt genug, kein Standby /
+    Wartung / Tuning); ausschalten immer, außer während eines laufenden kalten Bezugs. Gesendet
+    wird gezielt startColdExtraction/stopColdExtraction statt eines Toggles, damit ein
+    abgewiesener Befehl den Schalter nicht in einen nie bestätigten Zustand bringt.
+  - Statuszeile: eigener Slot direkt hinter der Sicherheitsmeldung. Zeigt dauerhaft
+    „Cold Extraction aktiv - Wasserkreis heizt nicht", bei fehlender Freigabe den Grund,
+    während der Pumpen-Zwangspause den Pumpenschutz und transient einen abgewiesenen Start
+    bzw. einen Abbruch wegen fehlenden Zulaufs.
+  - Wasser-Kachel im Dashboard zeigt bei aktivem Modus „Cold Extraction - Heizen aus" statt
+    eines Sollwerts, der nicht erreicht wird; der Aufheiz-Countdown ist dann unterdrückt.
+  - Phasenleiste und Live-Bezugsschirm benennen die erste Phase eines kalten Bezugs
+    „Vorbenetzung" (keine Pause-Phase) und zeigen die Pumpenpause an.
+  - Brew-Seite: Cold-Extraction-Parameter als Anzeige (Freigabeschwelle, Vorbenetzung,
+    Zielgewicht, Timeout) mit Hinweis, dass sie in der Web-UI eingestellt werden.
+  - Statistik-Seite: kalte Bezüge sind mit „(kalt)" markiert und gehen nicht in die mittlere
+    Bezugsdauer ein - gleiche Regel wie in der S3-Statistik.
+- Bug-Fix: Das Limit für eingehende UART-Zeilen (PROTO_RX_LINE_MAX) lag bei 2048 Bytes, während
+  die State-Zeile der S3 bereits rund 2,1 KB erreicht - mit langem Status-, Profil- oder
+  SSID-Text konnte sie darüber liegen. In dem Fall wurde die GANZE Zeile verworfen und das
+  Display fror auf dem letzten Stand ein, ohne dass die Verbindung als tot erkannt wurde.
+  Das Limit ist jetzt 4096 Bytes; der RX-Puffer selbst bleibt bei 2 KB reserviert, weil der
+  interne RAM knapp ist und eine Arduino-String nicht ins PSRAM alloziert werden kann.
+
+Version 1.0.13:
+- Profil-Schnellwahl + Anzeige des aktiven Profils (braucht S3-Firmware ab 5.1.1):
+  - Neuer Profil-Chip im Header (auf allen Seiten sichtbar): zeigt das zuletzt geladene bzw.
+    gespeicherte Profil; ein „*" hinter dem Namen bedeutet, dass seitdem profil-relevante
+    Einstellungen geändert wurden. Lange Namen werden gekürzt; ohne bekanntes Profil
+    (oder mit älterer S3-Firmware) bleibt der Chip unsichtbar.
+  - Antippen des Chips öffnet die Profil-Schnellwahl: ein Overlay mit allen gespeicherten
+    Profilen, das aktive mit Häkchen und Akzentfarbe hervorgehoben. Ein Tap lädt das Profil
+    direkt (Toast bestätigt, Chip aktualisiert sich mit dem nächsten State) — zwei Berührungen
+    vom Dashboard zum Profilwechsel statt Umweg über die Profile-Seite.
+  - Profile-Seite: das aktive Profil wird in der Liste mit Häkchen-Symbol und Akzentfarbe
+    markiert.
+
+Version 1.0.12:
+- Verlauf-Chart: Flackernde Heizleistungs-Kurven in den großen Zeitfenstern behoben. Die
+  Dezimierung pickte pro Chart-Punkt ein Einzelsample, dessen Abtast-Raster mit jedem
+  Sekundentick um eine Position wanderte — die schnell schaltende Heizleistung (PWM)
+  sprang dadurch sichtbar zwischen zwei Kurvenbildern hin und her. Jetzt wird über den
+  gesamten Zeitabschnitt eines Chart-Punkts gemittelt: das Bild steht ruhig, und die
+  Leistungs-Kurve zeigt die tatsächliche mittlere Heizleistung statt zufälliger
+  Momentwerte. Im 2-min-Fenster (1 Sample je Punkt) ändert sich nichts.
+
 Version 1.0.11:
 - Verlauf-Seite ausgebaut (nur P4, keine S3-/Protokolländerung nötig):
   - Umschaltbares Zeitfenster: Buttons „2 min / 10 min / 30 min / 60 min" in der Kopfzeile.
@@ -14,6 +65,8 @@ Version 1.0.11:
     ebenfalls P4-lokal im NVS.
   - Feinere Kurven: Die Temperatur-Historie wird jetzt in Zehntelgrad geführt und gezeichnet
     (vorher ganzzahlig gerundet) — PID-Schwingungen um ±1 °C sind damit sauber ablesbar.
+  - Die ~29 KB Historie liegen im PSRAM (heap_caps_malloc, wie die LVGL-Framebuffer) —
+    als statische Arrays sprengten sie den internen RAM (Linker: 107 % belegt).
 - Shot-Zusammenfassung: Karte auf 560 px verbreitert und Spaltenabstand zwischen
   Dauer/Gewicht/Flow deutlich vergrößert (28 px statt 10 px) — die drei Werte standen
   zu nahe beisammen und waren schlecht lesbar.

JC_Display_Firmware/config.h

@@ -65,13 +65,16 @@
 // -------------------------------------------------------------------------------------
 //  Firmware
 // -------------------------------------------------------------------------------------
-#define DISPLAY_FW_VERSION       "1.0.11"   // Firmware-Stand der P4-Display-Steuerung (Info-Seite)
+#define DISPLAY_FW_VERSION       "1.1.0"   // Firmware-Stand der P4-Display-Steuerung (Info-Seite)
 
 // -------------------------------------------------------------------------------------
 //  Protokoll
 // -------------------------------------------------------------------------------------
 #define PROTO_EXPECTED_VERSION   2      // muss zur S3-Firmware passen (TOUCH_UART_PROTOCOL_VERSION)
-#define PROTO_RX_LINE_MAX        2048   // max. eingehende Zeilenlaenge (Bytes)
+// Die State-Zeile der S3 kann mit langem Status-/Profil-/SSID-Text ueber 2 KB gehen. Wird
+// das Limit erreicht, verwirft der Client die GANZE Zeile und das Display friert auf dem
+// letzten Stand ein -> Reserve deutlich groesser als der reale Bedarf (~2,3 KB).
+#define PROTO_RX_LINE_MAX        4096   // max. eingehende Zeilenlaenge (Bytes)
 #define PROTO_HEARTBEAT_MS       5000   // Intervall fuer 'ping' (S3-Timeout = 15 s)
 #define PROTO_HELLO_RETRY_MS     2000   // erneuter 'hello'-Versuch, solange nicht verbunden
 #define PROTO_LINK_TIMEOUT_MS    8000   // ohne empfangene Nachricht -> Verbindung gilt als tot

JC_Display_Firmware/machine_state.h

@@ -50,6 +50,8 @@ struct MachineState {
     long   heatUpRemainSec = -1;         // verbleibende Sekunden bis "durchgewaermt" (-1 = aus)
     bool   lightOn = false;
     bool   piezoEnabled = false;
+    String activeProfile;          // zuletzt geladenes/gespeichertes Profil (leer = keines; seit S3 5.1.1)
+    bool   profileDirty = false;   // Einstellungen weichen seit dem Laden vom Profil ab
 
     // --- Waage ---
     float weight = 0, targetWeight = 0;
@@ -66,6 +68,23 @@ struct MachineState {
     float bbwTarget = 0, bbwOffset = 0;
     uint8_t piState = 0;           // Pre-Infusion-Phase (0=inaktiv,1=Pre-Infusion,2=Pause,3=Hauptbezug; seit S3 5.0.12)
 
+    // --- Cold Extraction (kalte Extraktion; seit S3 5.3.0) ---
+    bool  cxEnabled = false;       // Funktion auf der S3 freigeschaltet (sonst Bedienelement ausblenden)
+    bool  cxActive = false;        // Modus scharf: Wasserkreis heizt nicht (persistent, seit S3 5.3.1)
+    bool  cxShot = false;          // der laufende Bezug ist eine kalte Extraktion
+    bool  cxAllowed = false;       // Freigabe jetzt (Wasserkessel kalt genug, kein Standby/Wartung/Tuning)
+    bool  cxResting = false;       // Zwangspause des Pumpenschutzes laeuft (Bezug laeuft weiter)
+    float cxMaxTemp = 0;           // Freigabeschwelle in C
+    float cxTarget = 0;            // Zielgewicht in g
+    float cxPreInfSec = 0;         // Vorbenetzung in s (fuer die Phasenleiste des kalten Bezugs)
+    float cxMaxSecs = 0;           // Sicherheits-Timeout des Bezugs in s
+    // Sperrgrund: 0=frei, 1=nicht freigeschaltet, 2=Standby, 3=Wartung, 4=Reinigungsassistent,
+    // 5=PID-Tuning, 6=Sensorfehler, 7=Wasserkessel zu warm
+    uint8_t cxBlock = 0;
+    // Transiente Meldung: 0=keine, 1=Start abgewiesen, 2=Bezug ohne Zulauf beendet,
+    // 3=Umschalten waehrend eines Bezugs abgelehnt
+    uint8_t cxNotice = 0;
+
     // --- Gehaeusesensor ---
     bool    caseSensorEnabled = false;
     bool    caseTempDashboard = false;

JC_Display_Firmware/protocol_client.cpp

@@ -16,6 +16,10 @@ void ProtocolClient::begin() {
     DISPLAY_UART_PORT.setRxBufferSize(2048);
     DISPLAY_UART_PORT.begin(DISPLAY_UART_BAUDRATE, SERIAL_8N1,
                             DISPLAY_UART_RX_PIN, DISPLAY_UART_TX_PIN);
+    // Bewusst NICHT auf PROTO_RX_LINE_MAX (4 KB) reserviert: Der interne RAM ist knapp
+    // (statisch ~98 %), und eine Arduino-String kann nicht ins PSRAM alloziert werden.
+    // 2 KB deckt die reale State-Zeile (~2,1 KB) fast vollstaendig ab; der Rest waechst
+    // in kleinen Schritten nach. Das Limit dient nur als Obergrenze gegen Muell/Overflow.
     _rxBuf.reserve(2048);
     _lastHelloMs = 0;
     _lastHeartbeatMs = 0;
@@ -192,6 +196,8 @@ void ProtocolClient::applyState(const String& json) {
     s.heatUpRemainSec    = doc["heatUpRemainSec"]    | (long)-1;
     s.lightOn            = doc["lightOn"]            | false;
     s.piezoEnabled       = doc["piezoEnabled"]       | false;
+    s.activeProfile      = String((const char*)(doc["profile"] | ""));   // fehlt bei aelterer S3-FW -> leer
+    s.profileDirty       = doc["profDirty"]          | false;
 
     s.weight        = doc["weight"]        | s.weight;
     s.targetWeight  = doc["targetWeight"]  | s.targetWeight;
@@ -214,6 +220,19 @@ void ProtocolClient::applyState(const String& json) {
     s.bbwTarget  = doc["bbwTarget"]  | s.bbwTarget;
     s.bbwOffset  = doc["bbwOffset"]  | s.bbwOffset;
 
+    // Cold Extraction (fehlt bei S3-FW < 5.3.0 -> cxEnabled bleibt false, UI blendet alles aus)
+    s.cxEnabled  = doc["cxEnabled"]  | false;
+    s.cxActive   = doc["cxActive"]   | false;
+    s.cxShot     = doc["cxShot"]     | false;
+    s.cxAllowed  = doc["cxAllowed"]  | false;
+    s.cxResting  = doc["cxResting"]  | false;
+    s.cxMaxTemp  = doc["cxMaxTemp"]  | s.cxMaxTemp;
+    s.cxTarget   = doc["cxTarget"]   | s.cxTarget;
+    s.cxPreInfSec= doc["cxPreInf"]   | s.cxPreInfSec;
+    s.cxMaxSecs  = doc["cxMaxSecs"]  | s.cxMaxSecs;
+    s.cxBlock    = doc["cxBlock"]    | (uint8_t)0;
+    s.cxNotice   = doc["cxNotice"]   | (uint8_t)0;
+
     s.caseSensorEnabled = doc["caseSensorEnabled"] | false;
     s.caseTempDashboard = doc["caseTempDashboard"] | false;
     s.caseSensorType    = doc["caseSensorType"]    | 0;

JC_Display_Firmware/ui.cpp

@@ -17,6 +17,7 @@
 #include <Arduino.h>
 #include <ArduinoJson.h>
 #include <Preferences.h>   // Dashboard-Design P4-lokal merken (NVS)
+#include <esp_heap_caps.h> // Verlaufs-Historie im PSRAM allozieren (interner RAM ist knapp)
 #include "ui.h"
 #include "theme.h"
 #include "config.h"
@@ -64,7 +65,9 @@ static lv_obj_t* g_errIcon      = nullptr;  // Fehlersymbol im Header (rot, auf
 // Konsolidierte Statuszeile: EINE feste einzeilige Meldung statt gestapelter Einzelbanner.
 // Jeder Hinweis belegt einen Slot (Reihenfolge = Prioritaet, Rot vor Gelb vor Blau);
 // mehrere aktive Meldungen rotieren alle 4 s weich durch (siehe status_line_tick).
-enum StatusSlot { ST_SAFETY = 0, ST_DAMPF, ST_CLEAN, ST_TUNE, ST_MAINT, ST_HEAT, ST_COUNT };
+// ST_COLDEX steht direkt hinter der Sicherheitsmeldung: Solange der Modus laeuft, heizt der
+// Wasserkreis nicht - das muss der Benutzer sehen, sonst wartet er auf Temperatur, die nicht kommt.
+enum StatusSlot { ST_SAFETY = 0, ST_COLDEX, ST_DAMPF, ST_CLEAN, ST_TUNE, ST_MAINT, ST_HEAT, ST_COUNT };
 struct StatusMsg {
     bool       active = false;
     char       text[120] = "";
@@ -103,6 +106,12 @@ static lv_obj_t* bulbTempW = nullptr; static lv_obj_t* bulbTempD = nullptr;
 static lv_obj_t* g_designBtn[TD_DESIGN_COUNT] = {};                               // Umschalter auf der Info-Seite
 static lv_obj_t* g_readyPill = nullptr;     // "BEREIT"-Pille im Header (Kessel im Zielband)
 static bool      g_readyState = false;      // mit Hysterese, gegen Flackern an der Bandgrenze
+// Profil-Chip im Header (zuletzt geladenes Profil; "*" = danach geaenderte Einstellungen).
+// Antippen oeffnet die Profil-Schnellwahl (Overlay mit allen Profilen zum Direkt-Laden).
+static lv_obj_t* g_profChip = nullptr;
+static lv_obj_t* g_profPicker = nullptr;        // Schnellwahl-Overlay (Vollbild-Abdunkelung)
+static lv_obj_t* g_profPickerList = nullptr;    // Button-Liste im Overlay
+static lv_obj_t* g_profPickerInfo = nullptr;    // "Lade Profile..."-Hinweis im Overlay
 static lv_obj_t* cellShot;  static lv_obj_t* lblShotTimer; static lv_obj_t* g_bbtBar = nullptr;
 static lv_obj_t* cellSteam; static lv_obj_t* lblSteamTimer; static lv_obj_t* g_sbtBar = nullptr;
 static lv_obj_t* cellBezug; static lv_obj_t* lblBezug; static lv_obj_t* g_bbwBar = nullptr;
@@ -124,11 +133,17 @@ static lv_obj_t* g_axHi = nullptr; static lv_obj_t* g_axMid = nullptr; static lv
 static const uint16_t CHART_WIN_MIN[4] = { 2, 10, 30, 60 };   // waehlbare Fenster (Minuten)
 #define CHART_HIST_MAX 3600                                    // Historie: 60 min à 1 s
 #define CHART_HIST_NONE INT16_MIN                              // Markierung "keine Probe"
-static int16_t  g_histW[CHART_HIST_MAX];                       // Zehntelgrad
-static int16_t  g_histD[CHART_HIST_MAX];
-static int16_t  g_histC[CHART_HIST_MAX];
-static uint8_t  g_histDutyW[CHART_HIST_MAX];                   // Heizleistung (%)
-static uint8_t  g_histDutyD[CHART_HIST_MAX];
+// Die ~29 KB Historie liegen im PSRAM (heap_caps_malloc in ui_init, wie die LVGL-
+// Framebuffer) - als statische Arrays wuerden sie den knappen internen RAM sprengen
+// (Board-Limit war vor diesem Feature bereits zu ~98 % belegt).
+struct ChartHist {
+    int16_t w[CHART_HIST_MAX];       // Wasser (Zehntelgrad)
+    int16_t d[CHART_HIST_MAX];       // Dampf  (Zehntelgrad)
+    int16_t c[CHART_HIST_MAX];       // Zusatzsensor (Zehntelgrad; CHART_HIST_NONE = aus)
+    uint8_t dutyW[CHART_HIST_MAX];   // Heizleistung Wasser (%)
+    uint8_t dutyD[CHART_HIST_MAX];   // Heizleistung Dampf (%)
+};
+static ChartHist* g_hist = nullptr;
 static uint16_t g_histPos = 0, g_histFill = 0;
 static uint8_t  g_chartWin  = 0;       // Index in CHART_WIN_MIN (P4-lokal in NVS, "chartwin")
 static bool     g_chartDuty = false;   // Heizleistung als Zusatzkurven (NVS "chartduty")
@@ -192,6 +207,7 @@ static lv_obj_t* g_piRow = nullptr;                                  // Containe
 static lv_obj_t* g_piChip[3]    = { nullptr, nullptr, nullptr };     // Chip je Schritt
 static lv_obj_t* g_piChipLbl[3] = { nullptr, nullptr, nullptr };
 static bool      g_piShotMode = false;     // laufender Bezug nutzt Pre-Infusion
+static bool      g_piColdMode = false;     // laufender Bezug ist eine kalte Extraktion (andere Phasennamen)
 static uint8_t   g_piStateS3  = 0;         // Phasenstatus der S3 (0=inaktiv,1=PI,2=Pause,3=Extraktion)
 static uint32_t  g_piDurMs = 0, g_piPauseMs = 0;   // beim Bezug gelatchte Phasendauern
 static int       g_piLastPhase = -1;       // zuletzt gestylte Phase (Styles nur bei Wechsel anfassen)
@@ -206,6 +222,8 @@ static float    g_sbtTarget = 0.0f;        // Dampf-Zielzeit (s)
 
 // Temperatur
 static lv_obj_t* lblTargW; static lv_obj_t* lblTargD; static lv_obj_t* swEco; static lv_obj_t* swMaint;
+static lv_obj_t* swColdEx = nullptr;      // Cold Extraction (nur bei S3-FW >= 5.3.0 sichtbar)
+static lv_obj_t* lblColdExHint = nullptr; // Erklaerung/Sperrgrund unter dem Schalter
 static float g_targW = 0, g_targD = 0; static unsigned long g_targEditMs = 0;
 static lv_obj_t* lblHeatUp = nullptr; static int g_heatUp = 0; static unsigned long g_heatUpEditMs = 0;
 static bool        g_heatUpDirty    = false;   // ungesendete Aufheizzeit-Aenderung (entprellt senden)
@@ -232,6 +250,7 @@ static lv_obj_t* swPI;  static lv_obj_t* taPiDur; static lv_obj_t* taPiPause;
 static lv_obj_t* swBBT; static lv_obj_t* taBbtSecs;
 static lv_obj_t* swBBW; static lv_obj_t* taBbwTarget; static lv_obj_t* taBbwOffset;
 static lv_obj_t* swSBT; static lv_obj_t* taSbtSecs;
+static lv_obj_t* lblBrewColdEx = nullptr;   // Cold-Extraction-Parameter (nur Anzeige)
 
 // WiFi
 static lv_obj_t* wifiStatusLbl; static lv_obj_t* wifiHintLbl; static lv_obj_t* wifiList;
@@ -1182,6 +1201,32 @@ static lv_obj_t* build_temp_arc(lv_obj_t* parent, const char* title, lv_color_t
 
 static void eco_cb(lv_event_t* e)   { if (g_client) g_client->sendAction(sw_get((lv_obj_t*)lv_event_get_target(e)) ? "startEco" : "stopEco"); }
 static void maint_cb(lv_event_t* e) { if (g_client) g_client->sendAction("toggleMaintenance", sw_get((lv_obj_t*)lv_event_get_target(e)) ? "true" : "false"); }
+// Sperrgrund-Code der S3 (cxBlock) in Klartext. Die S3 sendet bewusst nur den Code, damit
+// die State-Zeile kurz bleibt - die Texte gehoeren ins Display (analog statusKey).
+static String coldex_block_text(uint8_t code, float maxTemp, float tempW) {
+    switch (code) {
+        case 1: return "nicht freigeschaltet";
+        case 2: return "Standby aktiv";
+        case 3: return "Wartungsmodus aktiv";
+        case 4: return "Reinigungsassistent aktiv";
+        case 5: return "PID-Tuning läuft";
+        case 6: return "Wasser-Sensor liefert keinen gültigen Wert";
+        case 7: {
+            char b[72];
+            snprintf(b, sizeof(b), "Wasserkessel zu warm (%.1f °C, benötigt < %.1f °C)",
+                     (double)tempW, (double)maxTemp);
+            return String(b);
+        }
+        default: return "";
+    }
+}
+
+// Cold Extraction: gezielt start/stop senden (nicht toggle), damit ein abgewiesener Befehl
+// den Schalter nicht in einen Zustand bringt, den die S3 nie bestaetigt.
+static void coldex_cb(lv_event_t* e) {
+    bool want = sw_get((lv_obj_t*)lv_event_get_target(e));
+    if (g_client) g_client->sendAction(want ? "startColdExtraction" : "stopColdExtraction");
+}
 
 // Stepper-Zeile: Beschriftung | [-] Wert [+]
 static lv_obj_t* build_stepper(lv_obj_t* parent, const char* label, lv_event_cb_t minus, lv_event_cb_t plus, int dec) {
@@ -1270,6 +1315,16 @@ static void build_temp(lv_obj_t* p) {
     lv_obj_add_event_cb(swEco, eco_cb, LV_EVENT_VALUE_CHANGED, nullptr);
     swMaint = add_switch(p, "Wartungsmodus");
     lv_obj_add_event_cb(swMaint, maint_cb, LV_EVENT_VALUE_CHANGED, nullptr);
+    swColdEx = add_switch(p, "Cold Extraction");
+    lv_obj_add_event_cb(swColdEx, coldex_cb, LV_EVENT_VALUE_CHANGED, nullptr);
+    lblColdExHint = lv_label_create(p);
+    lv_label_set_long_mode(lblColdExHint, LV_LABEL_LONG_WRAP);
+    lv_obj_set_width(lblColdExHint, LV_PCT(100));
+    lv_obj_set_style_text_color(lblColdExHint, COL_TEXT_DIM, 0);
+    lv_label_set_text(lblColdExHint, "");
+    // Beide Zeilen bleiben versteckt, solange die S3 die Funktion nicht freigeschaltet meldet
+    lv_obj_add_flag(lv_obj_get_parent(swColdEx), LV_OBJ_FLAG_HIDDEN);
+    lv_obj_add_flag(lblColdExHint, LV_OBJ_FLAG_HIDDEN);
 }
 
 // =====================================================================================
@@ -1471,25 +1526,44 @@ static void build_chart(lv_obj_t* p) {
 // Y-Achse ueber das sichtbare Fenster (Werte < 30 Grad = kalter/inaktiver Sensor werden
 // fuer die Skala ignoriert) und positioniert die gestrichelten Soll-Linien.
 static void chart_redraw() {
-    if (!g_chart) return;
+    if (!g_chart || !g_hist) return;
     const int stride = (int)CHART_WIN_MIN[g_chartWin] * 60 / 120;   // Sekunden je Chart-Punkt
     int32_t lo = INT32_MAX, hi = INT32_MIN;                          // Zehntelgrad
     bool anyW = false, anyD = false;
     for (int i = 0; i < 120; i++) {
-        int age = (119 - i) * stride;                                // Alter der Probe (Sekunden)
+        int ageStart = (119 - i) * stride;                           // juengstes Alter im Bucket (Sekunden)
         int32_t vW = LV_CHART_POINT_NONE, vD = LV_CHART_POINT_NONE, vC = LV_CHART_POINT_NONE;
         int32_t dW = LV_CHART_POINT_NONE, dD = LV_CHART_POINT_NONE;
-        if (age < (int)g_histFill) {
-            int idx = (int)g_histPos - 1 - age;
-            if (idx < 0) idx += CHART_HIST_MAX;
-            vW = g_histW[idx];
-            vD = g_histD[idx];
-            if (g_histC[idx] != CHART_HIST_NONE) vC = g_histC[idx];
-            dW = g_histDutyW[idx];
-            dD = g_histDutyD[idx];
-            if (vW > 300) { anyW = true; if (vW < lo) lo = vW; if (vW > hi) hi = vW; }
-            if (vD > 300) { anyD = true; if (vD < lo) lo = vD; if (vD > hi) hi = vD; }
-            if (vC != LV_CHART_POINT_NONE && vC > 300) { if (vC < lo) lo = vC; if (vC > hi) hi = vC; }
+        if (ageStart < (int)g_histFill) {
+            // Ueber den ganzen Bucket mitteln statt ein Einzelsample zu picken: das
+            // Abtast-Raster haengt an g_histPos und wandert sonst mit jedem Sekundentick,
+            // wodurch schnell schaltende Werte (Duty-PWM) sichtbar zwischen zwei
+            // Kurvenbildern hin- und herspringen. Der Mittelwert ist zudem bei der
+            // Heizleistung die ehrlichere Aussage als ein zufaelliger Momentwert.
+            int32_t sW = 0, sD = 0, sC = 0, sDW = 0, sDD = 0;
+            int nT = 0, nC = 0;
+            for (int s = 0; s < stride; s++) {
+                int age = ageStart + s;
+                if (age >= (int)g_histFill) break;
+                int idx = (int)g_histPos - 1 - age;
+                if (idx < 0) idx += CHART_HIST_MAX;
+                sW  += g_hist->w[idx];
+                sD  += g_hist->d[idx];
+                sDW += g_hist->dutyW[idx];
+                sDD += g_hist->dutyD[idx];
+                nT++;
+                if (g_hist->c[idx] != CHART_HIST_NONE) { sC += g_hist->c[idx]; nC++; }
+            }
+            if (nT > 0) {
+                vW = (sW + nT / 2) / nT;
+                vD = (sD + nT / 2) / nT;
+                dW = (sDW + nT / 2) / nT;
+                dD = (sDD + nT / 2) / nT;
+                if (nC > 0) vC = (sC + nC / 2) / nC;
+                if (vW > 300) { anyW = true; if (vW < lo) lo = vW; if (vW > hi) hi = vW; }
+                if (vD > 300) { anyD = true; if (vD < lo) lo = vD; if (vD > hi) hi = vD; }
+                if (vC != LV_CHART_POINT_NONE && vC > 300) { if (vC < lo) lo = vC; if (vC > hi) hi = vC; }
+            }
         }
         lv_chart_set_value_by_id(g_chart, g_serW, i, vW);
         lv_chart_set_value_by_id(g_chart, g_serD, i, vD);
@@ -1540,15 +1614,15 @@ static void chart_redraw() {
     lv_chart_refresh(g_chart);
 }
 static void chart_sample_cb(lv_timer_t*) {
-    if (!g_chart) return;
+    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_histW[g_histPos] = (int16_t)(g_state.tempW * 10.0f + 0.5f);
-    g_histD[g_histPos] = (int16_t)(g_state.tempD * 10.0f + 0.5f);
-    g_histC[g_histPos] = caseOn ? (int16_t)(g_state.caseTemp * 10.0f + 0.5f) : CHART_HIST_NONE;
+    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->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_histDutyW[g_histPos] = (uint8_t)(dw < 0.0f ? 0 : (dw > 100.0f ? 100 : (int)(dw + 0.5f)));
-    g_histDutyD[g_histPos] = (uint8_t)(dd < 0.0f ? 0 : (dd > 100.0f ? 100 : (int)(dd + 0.5f)));
+    g_hist->dutyW[g_histPos] = (uint8_t)(dw < 0.0f ? 0 : (dw > 100.0f ? 100 : (int)(dw + 0.5f)));
+    g_hist->dutyD[g_histPos] = (uint8_t)(dd < 0.0f ? 0 : (dd > 100.0f ? 100 : (int)(dd + 0.5f)));
     g_histPos = (uint16_t)((g_histPos + 1) % CHART_HIST_MAX);
     if (g_histFill < CHART_HIST_MAX) g_histFill++;
 
@@ -1575,7 +1649,10 @@ static void chart_sample_cb(lv_timer_t*) {
     // Countdown voll bis zum eingestellten Wert durch - auch wenn das Wasser dabei >40 Grad wird.
     {
         long rs = g_state.heatUpRemainSec;
-        if (g_state.standbyActive || rs <= 0)  g_heatUpLatched = false;   // Ende/Standby -> zuruecksetzen
+        // Bei aktiver Cold Extraction heizt der Wasserkreis nicht - ein Aufheiz-Countdown
+        // waere schlicht falsch (er liefe ab, ohne dass die Maschine warm wird).
+        if (g_state.cxActive)                  g_heatUpLatched = false;
+        else if (g_state.standbyActive || rs <= 0) g_heatUpLatched = false;   // Ende/Standby -> zuruecksetzen
         else if (g_state.tempW < 40.0f)        g_heatUpLatched = true;    // Kaltstart erkannt -> ganzen Countdown zeigen
         if (g_heatUpLatched) {
             char b[56];
@@ -1729,8 +1806,11 @@ static void brew_live_tick() {
             if (phase <= 2) {
                 uint32_t endMs = (phase == 1) ? g_piDurMs : (g_piDurMs + g_piPauseMs);
                 uint32_t remainMs = (g_shotFrozenMs < endMs) ? (endMs - g_shotFrozenMs) : 0;
-                snprintf(b, sizeof(b), "%s  -  noch %.1f s",
-                         (phase == 1) ? "Pre-Infusion" : "Pause", remainMs / 1000.0f);
+                const char* pname = (phase == 1) ? (g_piColdMode ? "Vorbenetzung" : "Pre-Infusion")
+                                                 : "Pause";
+                snprintf(b, sizeof(b), "%s  -  noch %.1f s", pname, remainMs / 1000.0f);
+            } else if (g_piColdMode && g_state.cxResting) {
+                snprintf(b, sizeof(b), "Extraktion  -  Pumpenpause");
             } else {
                 snprintf(b, sizeof(b), "Extraktion");
             }
@@ -1931,6 +2011,15 @@ static void build_brew(lv_obj_t* p) {
     swSBT      = add_switch(p, "Steam-by-Time aktiv");
     taSbtSecs  = add_num(p, "Dampf-Zielzeit (s)");
     add_save_button(p, "Brühen speichern", send_save_brew);
+    // Cold Extraction: nur Anzeige. Die Parameter liegen bewusst nur in der Web-UI der S3
+    // (maschinenabhaengig, nicht ueber saveBrew erreichbar); geschaltet wird der Modus
+    // auf der Temperatur-Seite unter "Modi".
+    lblBrewColdEx = lv_label_create(p);
+    lv_label_set_long_mode(lblBrewColdEx, LV_LABEL_LONG_WRAP);
+    lv_obj_set_width(lblBrewColdEx, LV_PCT(100));
+    lv_obj_set_style_text_color(lblBrewColdEx, COL_TEXT_DIM, 0);
+    lv_label_set_text(lblBrewColdEx, "");
+    lv_obj_add_flag(lblBrewColdEx, LV_OBJ_FLAG_HIDDEN);
 }
 
 // =====================================================================================
@@ -2349,6 +2438,112 @@ static void prof_save_cb(lv_event_t*) {
 }
 static void prof_refresh_cb(lv_event_t*) { if (g_client) g_client->sendListProfiles(); }
 
+// --- Profil-Schnellwahl: Overlay mit allen Profilen zum Direkt-Laden ------------------
+// Geoeffnet ueber den Profil-Chip im Header; ein Tap laedt das Profil sofort (die
+// Bestaetigung uebernimmt der Toast + der aktualisierte Chip aus dem naechsten State).
+static void prof_picker_close() {
+    if (!g_profPicker) return;
+    lv_obj_delete(g_profPicker);
+    g_profPicker = nullptr;
+    g_profPickerList = nullptr;
+    g_profPickerInfo = nullptr;
+}
+static void prof_picker_bg_cb(lv_event_t* e) {
+    // nur ein Tap auf die Abdunkelung selbst schliesst (Karte bubbelt nicht)
+    if (lv_event_get_target(e) == lv_event_get_current_target(e)) prof_picker_close();
+}
+static void prof_picker_close_cb(lv_event_t*) { prof_picker_close(); }
+static void prof_picker_load_cb(lv_event_t* e) {
+    lv_obj_t* btn = (lv_obj_t*)lv_event_get_current_target(e);
+    lv_obj_t* lbl = lv_obj_get_child(btn, 0);   // Kind 0 = Name (pur), Kind 1 = optionales Haekchen
+    if (!lbl || !g_client) return;
+    String name = lv_label_get_text(lbl);
+    prof_picker_close();
+    if (name == g_state.activeProfile && !g_state.profileDirty) {
+        showToast(("Profil ist bereits aktiv: " + name).c_str(), false);
+        return;
+    }
+    g_client->sendLoadProfile(name);
+    showToast(("Lade Profil: " + name).c_str(), false);
+}
+static void prof_picker_fill(const String profiles[], int count) {
+    if (!g_profPickerList) return;
+    lv_obj_clean(g_profPickerList);
+    if (g_profPickerInfo) {
+        if (count == 0) {
+            lv_label_set_text(g_profPickerInfo, "Keine Profile gespeichert.");
+            lv_obj_remove_flag(g_profPickerInfo, LV_OBJ_FLAG_HIDDEN);
+        } else {
+            lv_obj_add_flag(g_profPickerInfo, LV_OBJ_FLAG_HIDDEN);
+        }
+    }
+    for (int i = 0; i < count; i++) {
+        bool active = (profiles[i] == g_state.activeProfile);
+        lv_obj_t* b = lv_button_create(g_profPickerList);
+        lv_obj_set_width(b, LV_PCT(100));
+        lv_obj_set_style_bg_color(b, active ? COL_ACCENT : COL_CARD2, 0);
+        lv_obj_set_style_radius(b, 10, 0);
+        lv_obj_set_style_pad_ver(b, 12, 0);
+        lv_obj_set_style_pad_hor(b, 14, 0);
+        lv_obj_set_style_shadow_width(b, 0, 0);
+        lv_obj_t* l = lv_label_create(b);   // Kind 0: purer Profilname (prof_picker_load_cb liest ihn)
+        lv_label_set_text(l, profiles[i].c_str());
+        lv_obj_set_style_text_color(l, active ? lv_color_hex(0x000000) : COL_TEXT, 0);
+        lv_obj_align(l, LV_ALIGN_LEFT_MID, 0, 0);
+        if (active) {
+            lv_obj_t* chk = lv_label_create(b);
+            lv_label_set_text(chk, LV_SYMBOL_OK);
+            lv_obj_set_style_text_color(chk, lv_color_hex(0x000000), 0);
+            lv_obj_align(chk, LV_ALIGN_RIGHT_MID, 0, 0);
+        }
+        lv_obj_add_event_cb(b, prof_picker_load_cb, LV_EVENT_CLICKED, nullptr);
+    }
+}
+static void prof_picker_open() {
+    if (g_profPicker) return;
+    g_profPicker = lv_obj_create(lv_screen_active());
+    lv_obj_set_size(g_profPicker, LV_PCT(100), LV_PCT(100));
+    lv_obj_set_pos(g_profPicker, 0, 0);
+    lv_obj_set_style_bg_color(g_profPicker, lv_color_hex(0x000000), 0);
+    lv_obj_set_style_bg_opa(g_profPicker, LV_OPA_60, 0);
+    lv_obj_set_style_border_width(g_profPicker, 0, 0);
+    lv_obj_set_style_radius(g_profPicker, 0, 0);
+    lv_obj_set_style_pad_all(g_profPicker, 0, 0);
+    lv_obj_clear_flag(g_profPicker, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_add_event_cb(g_profPicker, prof_picker_bg_cb, LV_EVENT_CLICKED, nullptr);
+
+    lv_obj_t* card = th_card(g_profPicker);
+    lv_obj_set_size(card, 460, 400);
+    lv_obj_center(card);
+    lv_obj_set_flex_flow(card, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_row(card, 8, 0);
+    lv_obj_clear_flag(card, LV_OBJ_FLAG_SCROLLABLE);
+
+    lv_obj_t* hdr = row(card, nullptr);
+    lv_obj_t* t = lv_label_create(hdr);
+    lv_label_set_text(t, "Profil laden");
+    lv_obj_set_style_text_color(t, COL_ACCENT, 0);
+    lv_obj_set_style_text_font(t, &lv_font_maven_pro_18, 0);
+    lv_obj_t* x = th_button(hdr, LV_SYMBOL_CLOSE, COL_CARD2, COL_TEXT);
+    lv_obj_add_event_cb(x, prof_picker_close_cb, LV_EVENT_CLICKED, nullptr);
+
+    g_profPickerInfo = lv_label_create(card);
+    lv_label_set_text(g_profPickerInfo, "Lade Profile...");
+    lv_obj_set_style_text_color(g_profPickerInfo, COL_TEXT_DIM, 0);
+
+    g_profPickerList = lv_obj_create(card);
+    lv_obj_set_width(g_profPickerList, LV_PCT(100));
+    lv_obj_set_flex_grow(g_profPickerList, 1);
+    lv_obj_set_style_bg_opa(g_profPickerList, LV_OPA_TRANSP, 0);
+    lv_obj_set_style_border_width(g_profPickerList, 0, 0);
+    lv_obj_set_style_pad_all(g_profPickerList, 0, 0);
+    lv_obj_set_style_pad_row(g_profPickerList, 6, 0);
+    lv_obj_set_flex_flow(g_profPickerList, LV_FLEX_FLOW_COLUMN);
+
+    if (g_client) g_client->sendListProfiles();   // Antwort fuellt via ui_set_profiles/prof_picker_fill
+}
+static void prof_chip_cb(lv_event_t*) { prof_picker_open(); }
+
 static void build_profiles(lv_obj_t* p) {
     lv_obj_clear_flag(p, LV_OBJ_FLAG_SCROLLABLE);
 
@@ -2623,7 +2818,9 @@ static void pi_bar_update() {
     }
 
     // Texte: erledigte Schritte mit Haken, aktive zeitgesteuerte Phase mit Restzeit
-    static const char* piNames[3] = { "Pre-Infusion", "Pause", "Extraktion" };
+    static const char* piNamesHot[3]  = { "Pre-Infusion", "Pause", "Extraktion" };
+    static const char* piNamesCold[3] = { "Vorbenetzung", "Pause", "Extraktion" };
+    const char** piNames = g_piColdMode ? piNamesCold : piNamesHot;
     char pbuf[40];
     for (int i = 0; i < 3; i++) {
         if (!g_piChipLbl[i]) continue;
@@ -2789,6 +2986,13 @@ void ui_init(ProtocolClient* client) {
     g_client = client;
 
     // Gespeicherte Darstellungs-Einstellungen laden (P4-lokal; Design-Standard: Rundinstrumente)
+    // Verlaufs-Historie (60 min à 1 s, ~29 KB) im PSRAM anlegen - wie die LVGL-Framebuffer.
+    // Schlaegt die Allokation fehl, bleibt das Chart schlicht leer (alle Zugriffe geprueft).
+    if (!g_hist) {
+        g_hist = (ChartHist*)heap_caps_malloc(sizeof(ChartHist), MALLOC_CAP_SPIRAM);
+        if (!g_hist) g_hist = (ChartHist*)heap_caps_malloc(sizeof(ChartHist), MALLOC_CAP_8BIT);
+    }
+
     { Preferences prefs; prefs.begin("ui", false);
       g_tempDesign = prefs.getUChar("tempdsgn", TD_GAUGE);
       g_brewLiveEnabled = prefs.getBool("brewlive", true);
@@ -2826,6 +3030,22 @@ void ui_init(ProtocolClient* client) {
     lv_obj_set_flex_grow(g_hdrTitle, 1);
     lv_obj_set_style_text_font(g_hdrTitle, &lv_font_maven_pro_18, 0);
 
+    // Profil-Chip: zuletzt geladenes Profil ("*" = seitdem geaenderte Einstellungen).
+    // Antippen oeffnet die Profil-Schnellwahl. Unsichtbar, solange die S3 kein Profil meldet.
+    g_profChip = lv_label_create(header);
+    lv_label_set_text(g_profChip, "");
+    lv_obj_set_style_bg_color(g_profChip, COL_CARD2, 0);
+    lv_obj_set_style_bg_opa(g_profChip, LV_OPA_COVER, 0);
+    lv_obj_set_style_text_color(g_profChip, COL_TEXT, 0);
+    lv_obj_set_style_radius(g_profChip, 12, 0);
+    lv_obj_set_style_pad_hor(g_profChip, 10, 0);
+    lv_obj_set_style_pad_ver(g_profChip, 3, 0);
+    lv_obj_set_style_margin_right(g_profChip, 10, 0);
+    lv_obj_add_flag(g_profChip, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_set_ext_click_area(g_profChip, 8);
+    lv_obj_add_event_cb(g_profChip, prof_chip_cb, LV_EVENT_CLICKED, nullptr);
+    lv_obj_add_flag(g_profChip, LV_OBJ_FLAG_HIDDEN);
+
     g_readyPill = lv_label_create(header);   // "BEREIT": Kessel im Zielband (auf allen Seiten sichtbar)
     lv_label_set_text(g_readyPill, "BEREIT");
     lv_obj_set_style_bg_color(g_readyPill, COL_OK, 0);
@@ -3224,6 +3444,32 @@ void ui_update(const MachineState& st) {
         status_set(ST_SAFETY, false);
     }
 
+    // Cold-Extraction-Hinweis: erklaert dauerhaft, warum der Wasserkreis nicht heizt.
+    // Transiente Meldung (abgewiesener Start / Abbruch) hat Vorrang vor dem Dauerzustand.
+    if (st.cxNotice == 2) {
+        status_set(ST_COLDEX, true, LV_SYMBOL_WARNING "  Cold Extraction beendet: kein Zulauf",
+                   COL_WARN, lv_color_hex(0x000000));
+    } else if (st.cxNotice == 3) {
+        status_set(ST_COLDEX, true, "Cold Extraction: erst nach dem Bezug umschaltbar",
+                   COL_WARN, lv_color_hex(0x000000));
+    } else if (st.cxNotice == 1) {
+        String t = "Cold Extraction nicht möglich - ";
+        t += coldex_block_text(st.cxBlock, st.cxMaxTemp, st.tempW);
+        status_set(ST_COLDEX, true, t.c_str(), COL_WARN, lv_color_hex(0x000000));
+    } else if (st.cxActive && st.cxResting) {
+        status_set(ST_COLDEX, true, "Cold Extraction: Pumpenpause (Pumpenschutz)",
+                   COL_ACCENT, lv_color_hex(0x000000));
+    } else if (st.cxActive && !st.cxAllowed) {
+        String t = "Cold Extraction aktiv, Bezug gesperrt - ";
+        t += coldex_block_text(st.cxBlock, st.cxMaxTemp, st.tempW);
+        status_set(ST_COLDEX, true, t.c_str(), COL_WARN, lv_color_hex(0x000000));
+    } else if (st.cxActive) {
+        status_set(ST_COLDEX, true, "Cold Extraction aktiv - Wasserkreis heizt nicht",
+                   lv_color_hex(0x1976d2), COL_TEXT);
+    } else {
+        status_set(ST_COLDEX, false);
+    }
+
     // Dampf-Hinweis (Heizen aus hat Vorrang vor Startverzoegerung)
     if (st.steamHeatDisabled) {
         status_set(ST_DAMPF, true, "Dampf: Heizen deaktiviert", COL_DANGER, COL_TEXT);
@@ -3362,6 +3608,14 @@ void ui_update(const MachineState& st) {
             temp_progress_set(barDutyW, arcTempW, bulbTempW, 0, COL_DANGER);
         } else {
             lv_label_set_text(lblTempW, tempStr(st.tempW, 1).c_str());
+            if (st.cxActive) {
+                // Cold Extraction: der Sollwert ist bedeutungslos, es wird nicht geheizt.
+                // Statt eines Zielbands, das nie erreicht wird, den Grund anzeigen.
+                lv_obj_set_style_text_color(lblTempW, lv_color_hex(0x1976d2), 0);
+                label_set_if_changed(lblSetW, "Cold Extraction - Heizen aus");
+                lv_obj_set_style_text_color(lblSetW, lv_color_hex(0x1976d2), 0);
+                temp_progress_set(barDutyW, arcTempW, bulbTempW, 0, lv_color_hex(0x1976d2));
+            } else {
             // Ist-Wert faerbt sich weich Richtung Soll (Blau -> Gold -> Gruen im Zielband)
             lv_color_t colW = temp_state_color(st.tempW, st.setW);
             lv_obj_set_style_text_color(lblTempW, colW, 0);
@@ -3370,6 +3624,7 @@ void ui_update(const MachineState& st) {
             // Fortschritt = Ist/Soll in %, gedeckelt auf 100 (Ist >= Soll -> voll)
             int pctW = (st.setW > 0.0f) ? (int)(st.tempW / st.setW * 100.0f + 0.5f) : 0;
             temp_progress_set(barDutyW, arcTempW, bulbTempW, pctW, colW);
+            }
         }
         if (st.dampfSafetyShutdown || st.dampfSensorError) {
             lv_label_set_text(lblTempD, LV_SYMBOL_WARNING);
@@ -3404,6 +3659,24 @@ void ui_update(const MachineState& st) {
             else       ui_fade_out_hide(g_readyPill, UI_FADE_MS);
         }
     }
+    // Profil-Chip im Header: Name des zuletzt geladenen Profils, "*" wenn seitdem
+    // profil-relevante Einstellungen geaendert wurden. Lange Namen werden gekuerzt,
+    // damit der Header nicht ueberlaeuft. Leer (alte S3-FW / kein Profil) -> versteckt.
+    if (g_profChip) {
+        if (st.activeProfile.length() > 0) {
+            String t = st.activeProfile;
+            if (t.length() > 18) {
+                int cut = 17;   // nicht mitten in einem UTF-8-Mehrbyte-Zeichen (Umlaut) schneiden
+                while (cut > 0 && ((uint8_t)t[cut] & 0xC0) == 0x80) cut--;
+                t = t.substring(0, cut) + "...";
+            }
+            if (st.profileDirty) t += " *";
+            label_set_if_changed(g_profChip, t.c_str());
+            lv_obj_remove_flag(g_profChip, LV_OBJ_FLAG_HIDDEN);
+        } else {
+            lv_obj_add_flag(g_profChip, LV_OBJ_FLAG_HIDDEN);
+        }
+    }
     // Timer-Synchronisation (die laufende Anzeige macht der 100-ms-Timer dash_timers_cb)
     // Tarier-Phase vor Brew-by-Weight-Bezug -> dash_timers_cb zeigt "Tariere..." im Shot-Timer
     g_scaleTaring = st.scaleTaring;
@@ -3417,10 +3690,19 @@ void ui_update(const MachineState& st) {
         g_shotBbtMode = st.bbtEnabled && st.bbtSecs > 0.0f;   // Bezug mit Brew-by-Time?
         if (g_shotBbtMode) g_bbtTarget = st.bbtSecs;
         // Pre-Infusion-Phasenleiste: Modus, S3-Phase und Phasendauern latchen (pi_bar_update)
-        g_piShotMode = st.piEnabled;
+        // Ein kalter Bezug hat seine eigene Phasenfolge (Vorbenetzung -> Extraktion, keine
+        // Pause) und ignoriert die Pre-Infusion-Einstellungen komplett.
+        g_piColdMode = st.cxShot;
+        if (g_piColdMode) {
+            g_piShotMode = (st.cxPreInfSec > 0.0f);
+            g_piDurMs    = (uint32_t)(st.cxPreInfSec * 1000.0f);
+            g_piPauseMs  = 0;
+        } else {
+            g_piShotMode = st.piEnabled;
+            g_piDurMs    = (uint32_t)(st.piDurSecs * 1000.0f);
+            g_piPauseMs  = (uint32_t)(st.piPauseSecs * 1000.0f);
+        }
         g_piStateS3  = st.piState;
-        g_piDurMs    = (uint32_t)(st.piDurSecs * 1000.0f);
-        g_piPauseMs  = (uint32_t)(st.piPauseSecs * 1000.0f);
         // Live-Bezugsschirm einblenden (nur echte Bezuege; nicht im Reinigungsassistenten,
         // nicht im Standby und nicht, wenn der Nutzer ihn fuer diesen Bezug weggetippt hat)
         if (g_brewLiveEnabled && !g_brewLiveClosed && !g_brewLiveShown &&
@@ -3444,6 +3726,7 @@ void ui_update(const MachineState& st) {
         }
         g_shotActive = false;
         g_piShotMode = false;   // Phasenleiste ausblenden (pi_bar_update)
+        g_piColdMode = false;
         g_piStateS3  = 0;
         brew_live_hide();       // Bezug vorbei -> Overlay weich ausblenden
         g_brewLiveClosed = false;   // Wegtipp-Sperre gilt nur fuer den laufenden Bezug
@@ -3546,6 +3829,60 @@ void ui_update(const MachineState& st) {
     if (swEco)   sw_set(swEco, st.ecoActive);
     if (swMaint)  sw_set(swMaint,  st.maintenanceActive);
     if (swMaint2) sw_set(swMaint2, st.maintenanceActive);
+    if (swColdEx) {
+        // Zeile nur zeigen, wenn die S3 die Funktion freigeschaltet meldet (und sie kennt)
+        lv_obj_t* rowCx = lv_obj_get_parent(swColdEx);
+        if (st.cxEnabled) {
+            lv_obj_remove_flag(rowCx, LV_OBJ_FLAG_HIDDEN);
+            if (lblColdExHint) lv_obj_remove_flag(lblColdExHint, LV_OBJ_FLAG_HIDDEN);
+        } else {
+            lv_obj_add_flag(rowCx, LV_OBJ_FLAG_HIDDEN);
+            if (lblColdExHint) lv_obj_add_flag(lblColdExHint, LV_OBJ_FLAG_HIDDEN);
+        }
+        sw_set(swColdEx, st.cxActive);
+        // Einschalten nur bei Freigabe; Ausschalten immer - ausser waehrend eines kalten Bezugs
+        bool usable = st.cxEnabled && (st.cxActive ? !st.cxShot : st.cxAllowed);
+        if (usable) lv_obj_remove_state(swColdEx, LV_STATE_DISABLED);
+        else        lv_obj_add_state(swColdEx, LV_STATE_DISABLED);
+        if (lblColdExHint && st.cxEnabled) {
+            String hint;
+            if (st.cxActive) {
+                hint = "Wasserkreis heizt nicht (bleibt über Standby und Neustart aktiv). ";
+                if (st.cxAllowed) {
+                    char b[96];
+                    snprintf(b, sizeof(b), "Bezug regulär starten - Ziel %.0f g, max %.0f s.",
+                             (double)st.cxTarget, (double)st.cxMaxSecs);
+                    hint += b;
+                } else {
+                    hint += coldex_block_text(st.cxBlock, st.cxMaxTemp, st.tempW);
+                }
+            } else if (!st.cxAllowed) {
+                hint = coldex_block_text(st.cxBlock, st.cxMaxTemp, st.tempW);
+            } else {
+                char b[112];
+                snprintf(b, sizeof(b), "Kalte Extraktion möglich (Wasser %.1f °C < %.1f °C). "
+                                       "Solange aktiv, heizt der Wasserkreis nicht.",
+                         (double)st.tempW, (double)st.cxMaxTemp);
+                hint = b;
+            }
+            label_set_if_changed(lblColdExHint, hint.c_str());
+        }
+    }
+    if (lblBrewColdEx) {
+        if (st.cxEnabled) {
+            char b[192];
+            snprintf(b, sizeof(b),
+                     "Cold Extraction (nur Anzeige, Einstellung in der Web-UI):\n"
+                     "Freigabe < %.1f °C  |  Vorbenetzung %.0f s  |  Ziel %.0f g  |  max. %.0f s\n"
+                     "Geschaltet wird der Modus auf der Seite \"Temperaturen\" unter \"Modi\".",
+                     (double)st.cxMaxTemp, (double)st.cxPreInfSec,
+                     (double)st.cxTarget, (double)st.cxMaxSecs);
+            label_set_if_changed(lblBrewColdEx, b);
+            lv_obj_remove_flag(lblBrewColdEx, LV_OBJ_FLAG_HIDDEN);
+        } else {
+            lv_obj_add_flag(lblBrewColdEx, LV_OBJ_FLAG_HIDDEN);
+        }
+    }
 
     // Licht-Button spiegeln (gold = an)
     if (btnLight) {
@@ -3596,12 +3933,16 @@ void ui_update(const MachineState& st) {
 void ui_toast(const char* txt, bool error) { showToast(txt, error); }
 
 void ui_set_profiles(const String profiles[], int count) {
+    // Schnellwahl-Overlay (falls offen) mit derselben Antwort befuellen
+    prof_picker_fill(profiles, count);
     if (!profList) return;
     lv_obj_clean(profList);
     for (int i = 0; i < count; i++) {
-        lv_obj_t* b = lv_list_add_button(profList, LV_SYMBOL_FILE, profiles[i].c_str());
+        // aktives Profil markieren (Haekchen + Akzentfarbe statt Datei-Symbol)
+        bool active = (profiles[i] == g_state.activeProfile);
+        lv_obj_t* b = lv_list_add_button(profList, active ? LV_SYMBOL_OK : LV_SYMBOL_FILE, profiles[i].c_str());
         lv_obj_set_style_bg_color(b, COL_CARD2, 0);
-        lv_obj_set_style_text_color(b, COL_TEXT, 0);
+        lv_obj_set_style_text_color(b, active ? COL_ACCENT : COL_TEXT, 0);
         lv_obj_add_event_cb(b, prof_select_cb, LV_EVENT_CLICKED, nullptr);
     }
 }
@@ -3674,14 +4015,19 @@ void ui_set_usage_stats(const String& json) {
     String l;
     int n = 0;
     float durSum = 0.0f;
+    int nDur = 0;   // Anzahl der Bezuege, die in den Mittelwert eingehen (ohne kalte)
     for (JsonVariant v : doc["shots"].as<JsonArray>()) {
         const char* dt = v["dt"] | "";
         float d = v["d"] | 0.0f;
         float w = v["w"] | -1.0f;
+        bool cold = v["cx"] | false;   // kalte Extraktion (fehlt bei S3-FW < 5.3.0)
         if (n > 0) l += "\n";
         l += String(dt) + "   " + String(d, 1) + " s";
         if (w >= 0.0f) l += "   " + String(w, 1) + " g";
-        durSum += d;
+        if (cold) l += "   (kalt)";
+        // Minutenlange kalte Bezuege wuerden den Mittelwert unbrauchbar machen -> raus
+        // (gleiche Regel wie in der S3-Statistik)
+        if (!cold) { durSum += d; nDur++; }
         n++;
     }
 
@@ -3690,7 +4036,10 @@ void ui_set_usage_stats(const String& json) {
     s += "Diese Woche: " + String(week) + "\n";
     // total ist exakt, solange die ganze Datei ins Fenster passte (sonst Fenster-Untergrenze)
     s += "Gesamt: " + (partial ? String("min. ") : String("")) + String(total) + " Bezüge";
-    if (n > 0) s += "\nMittl. Dauer (letzte " + String(n) + "): " + String(durSum / n, 1) + " s";
+    if (nDur > 0) {
+        s += "\nMittl. Dauer (letzte " + String(nDur) + "): " + String(durSum / nDur, 1) + " s";
+        if (nDur < n) s += "  (ohne kalte)";
+    }
     label_set_if_changed(g_statSummary, s.c_str());
 
     if (g_statList) {