|
|
|
@@ -1108,26 +1108,49 @@ 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.
|
|
|
|
|
// Ausschnitt der Verlaufskurve an die tatsaechlich vorhandenen Werte anpassen.
|
|
|
|
|
// Gemeinsamer Ausschnitt fuer BEIDE Verlaufskurven.
|
|
|
|
|
//
|
|
|
|
|
// Frueher spannte er sich um den SOLLWERT: sechs Grad darunter bis drei darueber. Das
|
|
|
|
|
// funktioniert nur, solange der Kessel schon nahe am Ziel ist. Heizt er noch auf oder ist
|
|
|
|
|
// er ganz aus, liegt jeder Messwert unterhalb des Fensters und wird auf den unteren Rand
|
|
|
|
|
// geklemmt - beide Kurven lagen dann flach auf derselben Hoehe und bewegten sich nicht,
|
|
|
|
|
// obwohl der eine Kessel bei 80 Grad stand und der andere bei 0.
|
|
|
|
|
static void spark_range_fit(lv_obj_t* ch, lv_chart_series_t* ser) {
|
|
|
|
|
// Zwei Anlaeufe waren vorher daneben. Erst hing der Ausschnitt am Sollwert - dann lag beim
|
|
|
|
|
// Aufheizen jeder Messwert unterhalb des Fensters und wurde auf den unteren Rand geklemmt.
|
|
|
|
|
// Danach zoomte jede Kurve auf ihre eigenen Werte - dann sass jede mittig in ihrem eigenen
|
|
|
|
|
// Fenster, und Wasser bei 70 Grad lag genauso hoch wie Dampf bei 0. Die Hoehe sagte nichts.
|
|
|
|
|
//
|
|
|
|
|
// Jetzt teilen sich beide Kurven eine Skala, die sich nach den Werten beider zusammen
|
|
|
|
|
// richtet. Damit ist die Hoehe wieder vergleichbar - der waermere Kessel liegt sichtbar
|
|
|
|
|
// hoeher -, und die Skala bleibt so eng, wie es die Daten zulassen: Stehen beide Kessel
|
|
|
|
|
// dicht beieinander, greift die Mindestspanne und schon Zehntelgrade sind zu sehen.
|
|
|
|
|
static int32_t g_sparkMin = INT32_MIN; // zuletzt gesetzter Ausschnitt, fuer beide gleich
|
|
|
|
|
static int32_t g_sparkMax = INT32_MIN;
|
|
|
|
|
|
|
|
|
|
// 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 - ein Kessel kann binnen einer Sekunde nicht um Grade einbrechen, die Delle ist also
|
|
|
|
|
// eine Stoerung der Messung, kein Vorgang an der Maschine. Fuer die Dauer des Uebergangs
|
|
|
|
|
// schreiben die Verlaufskurven deshalb den letzten Wert von vor dem Wechsel weiter. Die
|
|
|
|
|
// angezeigten Zahlen bleiben unangetastet - was gemessen wird, steht dort weiter drin.
|
|
|
|
|
#define KURVEN_SPERRE_MS 6000
|
|
|
|
|
static uint32_t g_kurvenSperreBis = 0; // millis(); bis dahin Werte halten
|
|
|
|
|
static float g_haltW = 0.0f;
|
|
|
|
|
static float g_haltD = 0.0f;
|
|
|
|
|
|
|
|
|
|
static void spark_scan(lv_obj_t* ch, lv_chart_series_t* ser, int32_t* mn, int32_t* mx) {
|
|
|
|
|
if (!ch || !ser) return;
|
|
|
|
|
int32_t* pts = lv_chart_get_y_array(ch, ser);
|
|
|
|
|
if (!pts) return;
|
|
|
|
|
uint32_t n = lv_chart_get_point_count(ch);
|
|
|
|
|
int32_t mn = INT32_MAX, mx = INT32_MIN;
|
|
|
|
|
for (uint32_t i = 0; i < n; i++) {
|
|
|
|
|
if (pts[i] == LV_CHART_POINT_NONE) continue;
|
|
|
|
|
if (pts[i] < mn) mn = pts[i];
|
|
|
|
|
if (pts[i] > mx) mx = pts[i];
|
|
|
|
|
if (pts[i] < *mn) *mn = pts[i];
|
|
|
|
|
if (pts[i] > *mx) *mx = pts[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void spark_ranges_fit() {
|
|
|
|
|
int32_t mn = INT32_MAX, mx = INT32_MIN;
|
|
|
|
|
spark_scan(g_sparkW, g_sparkSerW, &mn, &mx);
|
|
|
|
|
spark_scan(g_sparkD, g_sparkSerD, &mn, &mx);
|
|
|
|
|
if (mn > mx) return; // noch kein einziger Wert
|
|
|
|
|
if (mx - mn < DASH_SPARK_MIN_SPAN) { // ruhige Regelung: Kurve mittig halten
|
|
|
|
|
if (mx - mn < DASH_SPARK_MIN_SPAN) { // beide dicht beieinander: mittig halten
|
|
|
|
|
int32_t mitte = (mn + mx) / 2;
|
|
|
|
|
mn = mitte - DASH_SPARK_MIN_SPAN / 2;
|
|
|
|
|
mx = mitte + DASH_SPARK_MIN_SPAN / 2;
|
|
|
|
@@ -1138,17 +1161,12 @@ static void spark_range_fit(lv_obj_t* ch, lv_chart_series_t* ser) {
|
|
|
|
|
}
|
|
|
|
|
// 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.
|
|
|
|
|
// Den zuletzt gesetzten Ausschnitt merkt sich die Kurve selbst; abfragen kann man ihn
|
|
|
|
|
// bei LVGL nicht.
|
|
|
|
|
int32_t* merk = (int32_t*)lv_obj_get_user_data(ch);
|
|
|
|
|
if (merk && merk[0] == mn && merk[1] == mx) return;
|
|
|
|
|
if (!merk) {
|
|
|
|
|
merk = (int32_t*)lv_malloc(2 * sizeof(int32_t));
|
|
|
|
|
if (!merk) { lv_chart_set_range(ch, LV_CHART_AXIS_PRIMARY_Y, mn, mx); return; }
|
|
|
|
|
lv_obj_set_user_data(ch, merk);
|
|
|
|
|
}
|
|
|
|
|
merk[0] = mn; merk[1] = mx;
|
|
|
|
|
lv_chart_set_range(ch, LV_CHART_AXIS_PRIMARY_Y, mn, mx);
|
|
|
|
|
// Abfragen laesst sich der gesetzte Ausschnitt bei LVGL nicht, also wird er gemerkt.
|
|
|
|
|
if (mn == g_sparkMin && mx == g_sparkMax) return;
|
|
|
|
|
g_sparkMin = mn;
|
|
|
|
|
g_sparkMax = mx;
|
|
|
|
|
if (g_sparkW) lv_chart_set_range(g_sparkW, LV_CHART_AXIS_PRIMARY_Y, mn, mx);
|
|
|
|
|
if (g_sparkD) lv_chart_set_range(g_sparkD, LV_CHART_AXIS_PRIMARY_Y, mn, mx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static lv_obj_t* tempSpark(lv_obj_t* parent, lv_color_t col, lv_chart_series_t** ser,
|
|
|
|
@@ -1179,8 +1197,7 @@ static lv_obj_t* tempSpark(lv_obj_t* parent, lv_color_t col, lv_chart_series_t**
|
|
|
|
|
// ersten Sekundenprobe eine leere Flaeche.
|
|
|
|
|
(void)soll;
|
|
|
|
|
lv_chart_set_all_value(ch, *ser, (int32_t)(jetzt * 10.0f));
|
|
|
|
|
spark_range_fit(ch, *ser);
|
|
|
|
|
return ch;
|
|
|
|
|
return ch; // Ausschnitt setzt spark_ranges_fit(), sobald beide Kurven stehen
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Temperaturbereich gemaess aktiver Darstellung (neu) aufbauen - auch beim Umschalten
|
|
|
|
@@ -1193,6 +1210,7 @@ static void build_temp_row_content() {
|
|
|
|
|
bulbTempW = bulbTempD = nullptr;
|
|
|
|
|
g_sparkW = g_sparkD = nullptr;
|
|
|
|
|
g_sparkSerW = g_sparkSerD = nullptr;
|
|
|
|
|
g_sparkMin = g_sparkMax = INT32_MIN; // gemerkter Ausschnitt gilt fuer die alten Kurven
|
|
|
|
|
g_readyBand = g_readyBandLbl = nullptr;
|
|
|
|
|
|
|
|
|
|
const lv_color_t teal = lv_color_hex(0x80cbc4);
|
|
|
|
@@ -1221,6 +1239,7 @@ static void build_temp_row_content() {
|
|
|
|
|
lv_obj_t* cd = tempField(g_tempRow, "DAMPF", teal, &lblTempD, &lblSetD, &barDutyD,
|
|
|
|
|
1, &lv_font_maven_pro_bold_96, false, 0);
|
|
|
|
|
g_sparkD = tempSpark(cd, COL_ACCENT, &g_sparkSerD, g_state.tempD, g_state.setD);
|
|
|
|
|
spark_ranges_fit();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@@ -1719,17 +1738,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
|
|
|
|
|
// richtet sich nach den vorhandenen Werten, siehe spark_range_fit().
|
|
|
|
|
if (g_sparkSerW && g_sparkW) {
|
|
|
|
|
lv_chart_set_next_value(g_sparkW, g_sparkSerW, (int32_t)(g_state.tempW * 10.0f));
|
|
|
|
|
spark_range_fit(g_sparkW, g_sparkSerW);
|
|
|
|
|
}
|
|
|
|
|
if (g_sparkSerD && g_sparkD) {
|
|
|
|
|
lv_chart_set_next_value(g_sparkD, g_sparkSerD, (int32_t)(g_state.tempD * 10.0f));
|
|
|
|
|
spark_range_fit(g_sparkD, g_sparkSerD);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
static void build_chart(lv_obj_t* p) {
|
|
|
|
|
lv_obj_clear_flag(p, LV_OBJ_FLAG_SCROLLABLE);
|
|
|
|
@@ -1954,11 +1962,31 @@ 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.
|
|
|
|
|
// Sperrfrist nach einem Standby-Wechsel: letzten Wert halten statt der frischen Probe.
|
|
|
|
|
bool sperre = g_kurvenSperreBis != 0 && (int32_t)(millis() - g_kurvenSperreBis) < 0;
|
|
|
|
|
if (!sperre) { g_haltW = g_state.tempW; g_haltD = g_state.tempD; }
|
|
|
|
|
const float probeW = sperre ? g_haltW : g_state.tempW;
|
|
|
|
|
const float probeD = sperre ? g_haltD : g_state.tempD;
|
|
|
|
|
|
|
|
|
|
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)));
|
|
|
|
@@ -4247,6 +4275,16 @@ void ui_update(const MachineState& st) {
|
|
|
|
|
// Standby-Uhr-Overlay (Backlight wird in onState gesteuert). Uebergaenge werden weich
|
|
|
|
|
// gefadet: Einschlafen blendet die Uhr ein, Aufwecken blendet sie aus. Nur bei echtem
|
|
|
|
|
// Statuswechsel animieren (g_standbyShown), sonst nur Uhrzeit/Vordergrund aktualisieren.
|
|
|
|
|
// Standby-Wechsel merken: die Verlaufskurven halten danach kurz ihren letzten Wert,
|
|
|
|
|
// damit die Messstoerung beim Schalten der Heizungen keine Delle in die Linie zieht.
|
|
|
|
|
static bool letzterStandby = false;
|
|
|
|
|
if (st.standbyActive != letzterStandby) {
|
|
|
|
|
letzterStandby = st.standbyActive;
|
|
|
|
|
g_haltW = st.tempW;
|
|
|
|
|
g_haltD = st.tempD;
|
|
|
|
|
g_kurvenSperreBis = millis() + KURVEN_SPERRE_MS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (g_standbyScreen) {
|
|
|
|
|
bool shouldShow = st.standbyActive && st.standbyShowClock;
|
|
|
|
|
if (shouldShow) {
|
|
|
|
|
thomas