iobroker.poolcontrol 0.2.0 → 0.2.1

package/lib/helpers/runtimeHelper.js

@@ -7,6 +7,7 @@
  * - Schreibt Werte in die States (Objekte werden in runtimeStates.js angelegt)
  * - Nutzt den zentralen Boolean pump.pump_switch
  * - NEU: zählt Starts, aktuelle Laufzeit, Saisonlaufzeit
+ * - NEU: stellt formatiert gespeicherte Laufzeiten nach Neustart korrekt wieder her
  */
 
 const runtimeHelper = {
@@ -35,13 +36,13 @@ const runtimeHelper = {
                 // Erst nach Restore einmal berechnen
                 this._updateStates();
 
-                this.adapter.log.info('[runtimeHelper] initialisiert (mit Restore)');
+                this.adapter.log.debug('[runtimeHelper] initialisiert (mit Restore)');
             })
             .catch(err => {
                 this.adapter.log.warn(`[runtimeHelper] Restore fehlgeschlagen: ${err.message}`);
                 this._scheduleDailyReset();
                 this._updateStates();
-                this.adapter.log.info('[runtimeHelper] initialisiert (ohne Restore)');
+                this.adapter.log.debug('[runtimeHelper] initialisiert (ohne Restore)');
             });
     },
 
@@ -51,10 +52,10 @@ const runtimeHelper = {
         const seasonRaw = (await this.adapter.getStateAsync('runtime.season_total'))?.val;
         const countRaw = (await this.adapter.getStateAsync('runtime.start_count_today'))?.val;
 
-        // Alle formatierten Werte werden intern wieder auf 0 gesetzt, Laufzeiten starten neu
-        this.runtimeTotal = Number(totalRaw) || 0;
-        this.runtimeToday = Number(todayRaw) || 0;
-        this.runtimeSeason = Number(seasonRaw) || 0;
+        // >>> NEU: Formatierten Text (z. B. "3h 12m 5s") in Sekunden umwandeln
+        this.runtimeTotal = this._parseFormattedTimeToSeconds(totalRaw);
+        this.runtimeToday = this._parseFormattedTimeToSeconds(todayRaw);
+        this.runtimeSeason = this._parseFormattedTimeToSeconds(seasonRaw);
         this.startCountToday = Number(countRaw) || 0;
 
         // Falls Pumpe gerade läuft → Status wiederherstellen
@@ -158,6 +159,35 @@ const runtimeHelper = {
         return `${h}h ${m}m ${s}s`;
     },
 
+    // >>> NEU: formatierten Text (z. B. "3h 12m 5s") in Sekunden zurückrechnen
+    _parseFormattedTimeToSeconds(value) {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        } // bereits Sekunden
+        const str = String(value ?? '').trim();
+        if (!str) {
+            return 0;
+        }
+
+        let h = 0,
+            m = 0,
+            s = 0;
+        const mh = str.match(/(\d+)\s*h/);
+        if (mh) {
+            h = parseInt(mh[1], 10);
+        }
+        const mm = str.match(/(\d+)\s*m/);
+        if (mm) {
+            m = parseInt(mm[1], 10);
+        }
+        const ms = str.match(/(\d+)\s*s/);
+        if (ms) {
+            s = parseInt(ms[1], 10);
+        }
+
+        return h * 3600 + m * 60 + s;
+    },
+
     _scheduleDailyReset() {
         const now = new Date();
         const nextMidnight = new Date(now);

package/lib/helpers/solarHelper.js

@@ -18,7 +18,7 @@ const solarHelper = {
         // Minütlicher Check
         this._scheduleCheck();
 
-        this.adapter.log.info('[solarHelper] initialisiert (Prüfung alle 60s)');
+        this.adapter.log.debug('[solarHelper] initialisiert (Prüfung alle 60s)');
     },
 
     _scheduleCheck() {
@@ -32,6 +32,13 @@ const solarHelper = {
 
     async _checkSolar() {
         try {
+            // --- NEU: Vorrangprüfung durch ControlHelper ---
+            const pumpStatus = (await this.adapter.getStateAsync('pump.status'))?.val || '';
+            if (pumpStatus.includes('controlHelper')) {
+                this.adapter.log.debug('[solarHelper] Vorrang durch ControlHelper aktiv – Solarregelung pausiert.');
+                return;
+            }
+
             // --- NEU: Saisonstatus ---
             const season = (await this.adapter.getStateAsync('status.season_active'))?.val;
 
@@ -47,8 +54,8 @@ const solarHelper = {
             const hysteresis = (await this.adapter.getStateAsync('solar.hysteresis_active'))?.val;
 
             // Temperaturen laden
-            const collector = (await this.adapter.getStateAsync('temperature.collector.current'))?.val;
-            const pool = (await this.adapter.getStateAsync('temperature.surface.current'))?.val; // Oberfläche = Pooltemp
+            const collector = Number((await this.adapter.getStateAsync('temperature.collector.current'))?.val);
+            const pool = Number((await this.adapter.getStateAsync('temperature.surface.current'))?.val); // Oberfläche = Pooltemp
 
             if (collector == null || pool == null) {
                 this.adapter.log.debug('[solarHelper] Keine gültigen Temperaturen verfügbar');
@@ -75,11 +82,21 @@ const solarHelper = {
                     // z. B. Ausschaltgrenze etwas absenken
                 }
 
+                // --- NEU: Sprachvariable für Solarsteuerung setzen ---
+                const oldVal = (await this.adapter.getStateAsync('speech.solar_active'))?.val;
+                if (oldVal !== shouldRun) {
+                    await this.adapter.setStateChangedAsync('speech.solar_active', {
+                        val: shouldRun,
+                        ack: true,
+                    });
+                }
+
                 // ZENTRAL: Pumpe über Bool-Schalter setzen
-                await this.adapter.setStateAsync('pump.pump_switch', {
+                await this.adapter.setStateChangedAsync('pump.pump_switch', {
                     val: shouldRun,
                     ack: false,
                 });
+
                 this.adapter.log.debug(
                     `[solarHelper] Solarregelung → Pumpe ${shouldRun ? 'EIN' : 'AUS'} (Collector=${collector}°C, Pool=${pool}°C, Delta=${delta}°C)`,
                 );
@@ -99,7 +116,10 @@ const solarHelper = {
             const warnActive = (await this.adapter.getStateAsync('solar.warn_active'))?.val;
             if (warnActive) {
                 const warnTemp = Number((await this.adapter.getStateAsync('solar.warn_temp'))?.val) || 0;
+
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 const speechEnabled = (await this.adapter.getStateAsync('solar.warn_speech'))?.val;
+
                 const currentWarning = (await this.adapter.getStateAsync('solar.collector_warning'))?.val || false;
 
                 // Neue Warnung, wenn Collector >= warnTemp
@@ -112,13 +132,17 @@ const solarHelper = {
                         `[solarHelper] WARNUNG: Kollektortemperatur ${collector}°C >= ${warnTemp}°C!`,
                     );
 
-                    // Sprachausgabe bei Aktivierung
-                    if (speechEnabled) {
-                        await this.adapter.setStateAsync('speech.last_text', {
-                            val: `Warnung: Kollektortemperatur ${collector} Grad erreicht.`,
-                            ack: true,
-                        });
-                    }
+                    /*
+                     * Deaktiviert, ersetzt durch SpeechTextHelper
+                     *
+                     * // Sprachausgabe bei Aktivierung
+                     * if (speechEnabled) {
+                     *    await this.adapter.setStateAsync('speech.last_text', {
+                     *        val: `Warnung: Kollektortemperatur ${collector} Grad erreicht.`,
+                     *        ack: true,
+                     *     });
+                     * }
+                     */
                 }
 
                 // Warnung zurücksetzen, wenn Collector <= 90 % von warnTemp
@@ -127,7 +151,7 @@ const solarHelper = {
                         val: false,
                         ack: true,
                     });
-                    this.adapter.log.info(
+                    this.adapter.log.debug(
                         `[solarHelper] Kollektorwarnung zurückgesetzt: ${collector}°C <= ${warnTemp * 0.9}°C`,
                     );
                 }

package/lib/helpers/speechHelper.js

@@ -21,11 +21,10 @@ const speechHelper = {
         this.adapter.subscribeStates('pump.error'); // Fehleransagen
         this.adapter.subscribeStates('temperature.*.current'); // Temp-Trigger
         this.adapter.subscribeStates('pump.pump_switch'); // wichtig für Flankenerkennung
-
-        // NEU: auch speech.last_text überwachen (z. B. von controlHelper gesendet)
         this.adapter.subscribeStates('speech.last_text');
+        this.adapter.subscribeStates('speech.queue'); // <<< NEU: zentrale Nachrichtenwarteschlange
 
-        this.adapter.log.info('[speechHelper] initialisiert');
+        this.adapter.log.debug('[speechHelper] initialisiert');
     },
 
     async handleStateChange(id, state) {
@@ -39,6 +38,16 @@ const speechHelper = {
             return;
         }
 
+        // NEU: Nachricht aus zentraler speech.queue
+        if (id.endsWith('speech.queue') && state.ack === false) {
+            const txt = String(state.val || '').trim();
+            if (txt) {
+                await this._speak(txt);
+                await this.adapter.setStateAsync('speech.queue', { val: '', ack: true });
+            }
+            return;
+        }
+
         // NEU: Direktnachricht von controlHelper über speech.last_text
         if (id.endsWith('speech.last_text') && state.ack === false) {
             const txt = String(state.val || '').trim();
@@ -57,48 +66,67 @@ const speechHelper = {
             return;
         }
 
-        // === Pumpenstart / -stop nur bei Zustandswechsel ===
-        if (id.endsWith('pump.pump_switch')) {
-            const newVal = !!state.val;
-
-            // Nur wenn sich der Zustand wirklich geändert hat
-            if (this.lastPumpState !== newVal) {
-                this.lastPumpState = newVal;
-
-                if (newVal) {
-                    const txt =
-                        (await this.adapter.getStateAsync('speech.start_text'))?.val ||
-                        'Die Poolpumpe wurde gestartet.';
-                    await this._speak(txt);
-                } else {
-                    const txt =
-                        (await this.adapter.getStateAsync('speech.end_text'))?.val || 'Die Poolpumpe wurde gestoppt.';
-                    await this._speak(txt);
-                }
-            } else {
-                this.adapter.log.debug('[speechHelper] Ignoriere Pumpenmeldung – kein Zustandswechsel.');
-            }
+        /*
+         *
+         * Deaktiviert, ersetzt durch speechTextHelper
+         *
+         * // === Pumpenstart / -stop nur bei Zustandswechsel ===
+         * if (id.endsWith('pump.pump_switch')) {
+         *     const newVal = !!state.val;
+         *
+         *     // Nur wenn sich der Zustand wirklich geändert hat
+         *     if (this.lastPumpState !== newVal) {
+         *         this.lastPumpState = newVal;
+         *
+         *         if (newVal) {
+         *             const txt =
+         *                 (await this.adapter.getStateAsync('speech.start_text'))?.val ||
+         *                 'Die Poolpumpe wurde gestartet.';
+         *             await this._speak(txt);
+         *         } else {
+         *             const txt =
+         *                 (await this.adapter.getStateAsync('speech.end_text'))?.val || 'Die Poolpumpe wurde gestoppt.';
+         *             await this._speak(txt);
+         *         }
+         *     } else {
+         *         this.adapter.log.debug('[speechHelper] Ignoriere Pumpenmeldung – kein Zustandswechsel.');
+         *     }
+         *     return;
+         * }
+         */
+
+        // Nur Pool-Oberflächentemperatur berücksichtigen
+        if (!id.includes('temperature.surface')) {
             return;
         }
 
-        // Temperatur-Trigger: über Config-Schwelle
-        if (id.includes('.temperature.') && id.endsWith('.current')) {
-            const threshold = this.adapter.config.speech_temp_threshold || 0;
-            const val = Number(state.val);
-            if (val >= threshold && threshold > 0) {
-                const now = Date.now();
-                const last = this.lastTempNotify[id] || 0;
-
-                // Nur einmal pro Stunde pro Sensor
-                if (now - last > 60 * 60 * 1000) {
-                    await this._speak(`Der Pool hat ${val} Grad erreicht.`);
-                    this.lastTempNotify[id] = now;
-                } else {
-                    this.adapter.log.debug(`[speechHelper] Temperaturansage für ${id} unterdrückt (Cooldown aktiv).`);
-                }
+        const threshold = this.adapter.config.speech_temp_threshold || 0;
+        const val = Number(state.val);
+
+        if (val >= threshold && threshold > 0) {
+            const now = Date.now();
+            const lastInfo = this.lastTempNotify[id] || { time: 0, temp: 0, date: null };
+
+            const lastDate = lastInfo.date;
+            const today = new Date().toDateString();
+            const tempDiff = Math.abs(val - lastInfo.temp);
+
+            // Prüfen: neuer Tag oder Temperatur mindestens +2°C höher
+            const isNewDay = lastDate !== today;
+            const significantChange = tempDiff >= 2;
+
+            if (isNewDay || significantChange) {
+                await this._speak(`Der Pool hat jetzt ${val} Grad erreicht.`);
+                this.lastTempNotify[id] = { time: now, temp: val, date: today };
+            } else {
+                this.adapter.log.debug(
+                    `[speechHelper] Temperaturansage unterdrückt (tempDiff=${tempDiff.toFixed(
+                        1,
+                    )}°C, letzter Wert=${lastInfo.temp}°C).`,
+                );
             }
-            return;
         }
+        return;
     },
 
     async _speak(text) {

package/lib/helpers/speechTextHelper.js

@@ -0,0 +1,184 @@
+'use strict';
+
+/**
+ * speechTextHelper
+ * - Erzeugt situationsabhängige Sprachtexte (z. B. Zeitmodus, Solar, PV, Wartung usw.)
+ * - Sendet fertige Texte an speech.queue (ack: false)
+ * - Beeinflusst keine Steuerlogik und keine anderen Helper
+ * - Wird nach und nach um Textbausteine erweitert (Schritt-für-Schritt pro Datei)
+ *
+ * @module speechTextHelper
+ * @version 1.0.3
+ */
+
+const speechTextHelper = {
+    // @type {ioBroker.Adapter}
+    adapter: null,
+
+    /**
+     * Initialisiert den Helper und abonniert relevante States.
+     *
+     * @param {ioBroker.Adapter} adapter - ioBroker Adapterinstanz
+     */
+    init(adapter) {
+        this.adapter = adapter;
+
+        // Relevante States abonnieren (Pumpenlogik + Status)
+        this.adapter.subscribeStates('pump.pump_switch');
+        this.adapter.subscribeStates('pump.mode');
+        this.adapter.subscribeStates('pump.reason');
+        this.adapter.subscribeStates('pump.status'); // zentrale Statusüberwachung
+
+        // --- NEU: Solar-Warnung überwachen ---
+        this.adapter.subscribeStates('solar.collector_warning');
+
+        // --- NEU: Solarsteuerung überwachen ---
+        this.adapter.subscribeStates('speech.solar_active');
+
+        // --- NEU: Zeitsteuerung überwachen ---
+        this.adapter.subscribeStates('speech.time_active');
+
+        // Später erweiterbar:
+        // this.adapter.subscribeStates('solar.solar_control_active');
+        // this.adapter.subscribeStates('control.pump.backwash_active');
+
+        this.adapter.log.debug(
+            '[speechTextHelper] initialisiert (Grundstruktur aktiv, inkl. Solar-Warnung, keine weiteren Textlogiken)',
+        );
+    },
+
+    /**
+     * Reagiert auf State-Änderungen.
+     * Hier werden nach und nach die jeweiligen Textausgaben ergänzt.
+     *
+     * @param {string} id - Objekt-ID des geänderten States
+     * @param {ioBroker.State} state - Neuer Statewert
+     */
+    async handleStateChange(id, state) {
+        try {
+            if (!state) {
+                return;
+            }
+
+            // --- Pumpenstatusänderung ---
+            if (id.endsWith('pump.status')) {
+                const status = String(state.val || '').toLowerCase();
+                this.adapter.log.silly(`[speechTextHelper] Pumpenstatus geändert: ${status}`);
+                return;
+            }
+
+            // --- Pumpenereignisse ---
+            if (id.endsWith('pump.pump_switch') || id.endsWith('pump.mode') || id.endsWith('pump.reason')) {
+                this.adapter.log.silly(`[speechTextHelper] Pumpen-Event erkannt: ${id} = ${state.val}`);
+                return;
+            }
+
+            // --- NEU: Solar-Warnung ---
+            if (id.endsWith('solar.collector_warning')) {
+                const val = !!state.val;
+
+                if (val) {
+                    // Neue Warnung aktiv
+                    const collectorTemp = Number(
+                        (await this.adapter.getStateAsync('temperature.collector.current'))?.val,
+                    );
+                    const warnTemp = Number((await this.adapter.getStateAsync('solar.warn_temp'))?.val);
+                    const text = `Warnung: Kollektortemperatur ${collectorTemp} Grad erreicht (Warnschwelle ${warnTemp}°C).`;
+                    await this._sendSpeech(text);
+                    this.adapter.log.debug(`[speechTextHelper] Solar-Warnung gesendet: ${text}`);
+                } else {
+                    // Warnung aufgehoben
+                    const text = 'Kollektorwarnung aufgehoben.';
+                    await this._sendSpeech(text);
+                    this.adapter.log.debug('[speechTextHelper] Solar-Warnung aufgehoben.');
+                }
+
+                // ersetzt SolarHelper Textausgabe
+                return;
+            }
+
+            // --- NEU: Reaktion auf Solarsteuerung ---
+            if (id.endsWith('speech.solar_active')) {
+                const val = !!state.val;
+                // Pumpenstatus aktualisieren, damit auch im VIS korrekt sichtbar
+                if (val) {
+                    await this.adapter.setStateAsync('pump.status', {
+                        val: 'EIN (Solarsteuerung)',
+                        ack: true,
+                    });
+                } else {
+                    await this.adapter.setStateAsync('pump.status', {
+                        val: 'AUS (Solarsteuerung beendet)',
+                        ack: true,
+                    });
+                }
+                if (val) {
+                    const text = 'Die Poolpumpe wurde durch die Solarsteuerung eingeschaltet.';
+                    await this._sendSpeech(text);
+                    this.adapter.log.debug('[speechTextHelper] Solarsteuerung aktiviert → Ansage gesendet.');
+                } else {
+                    const text = 'Solarsteuerung beendet – Poolpumpe ausgeschaltet.';
+                    await this._sendSpeech(text);
+                    this.adapter.log.debug('[speechTextHelper] Solarsteuerung deaktiviert → Ansage gesendet.');
+                }
+                return;
+            }
+
+            // --- NEU: Reaktion auf Zeitsteuerung ---
+            if (id.endsWith('speech.time_active')) {
+                const val = !!state.val;
+
+                // Pumpenstatus mitpflegen
+                if (val) {
+                    await this.adapter.setStateAsync('pump.status', {
+                        val: 'EIN (Zeitsteuerung)',
+                        ack: true,
+                    });
+                    const text = 'Die Poolpumpe wurde durch die Zeitsteuerung eingeschaltet.';
+                    await this._sendSpeech(text);
+                    this.adapter.log.debug('[speechTextHelper] Zeitsteuerung aktiviert → Ansage gesendet.');
+                } else {
+                    await this.adapter.setStateAsync('pump.status', {
+                        val: 'AUS (Zeitsteuerung beendet)',
+                        ack: true,
+                    });
+                    const text = 'Zeitsteuerung beendet – Poolpumpe ausgeschaltet.';
+                    await this._sendSpeech(text);
+                    this.adapter.log.debug('[speechTextHelper] Zeitsteuerung deaktiviert → Ansage gesendet.');
+                }
+                return;
+            }
+
+            // Weitere Blöcke (z. B. Zeitmodus, Wartung usw.) folgen später hier
+        } catch (err) {
+            this.adapter.log.warn(`[speechTextHelper] Fehler bei handleStateChange: ${err.message}`);
+        }
+    },
+
+    /**
+     * Sendet Text an speech.queue.
+     *
+     * @param {string} text - Der zu sendende Text
+     */
+    async _sendSpeech(text) {
+        if (!text) {
+            return;
+        }
+        try {
+            await this.adapter.setStateAsync('speech.queue', { val: text, ack: false });
+            this.adapter.log.debug(`[speechTextHelper] Text gesendet: ${text}`);
+        } catch (err) {
+            this.adapter.log.warn(`[speechTextHelper] Fehler beim Senden an speech.queue: ${err.message}`);
+        }
+    },
+
+    /**
+     * Aufräumen (z. B. Timer beenden)
+     */
+    cleanup() {
+        // Aktuell keine Ressourcen
+        this.adapter.log.debug('[speechTextHelper] cleanup ausgeführt');
+    },
+};
+
+module.exports = speechTextHelper;

package/lib/helpers/statusHelper.js

@@ -52,7 +52,7 @@ const statusHelper = {
         // Mitternacht-Reset einplanen
         this.scheduleMidnightReset();
 
-        this.adapter.log.info('[statusHelper] initialisiert');
+        this.adapter.log.debug('[statusHelper] initialisiert');
     },
 
     async handleStateChange(id, state) {
@@ -209,7 +209,7 @@ const statusHelper = {
         try {
             await this.adapter.setStateAsync('status.pump_today_count', { val: 0, ack: true });
             await this.adapter.setStateAsync('status.pump_was_on_today', { val: false, ack: true });
-            this.adapter.log.info('[statusHelper] Tagesreset durchgeführt');
+            this.adapter.log.debug('[statusHelper] Tagesreset durchgeführt');
         } catch (err) {
             this.adapter.log.warn(`[statusHelper] Fehler beim Tagesreset: ${err.message}`);
         }

package/lib/helpers/temperatureHelper.js

@@ -67,7 +67,7 @@ const temperatureHelper = {
         // Reset um Mitternacht
         this._scheduleDailyReset();
 
-        adapter.log.info(
+        adapter.log.debug(
             `[temperatureHelper] Aktiv: ${
                 Object.keys(this.sensors).length
                     ? Object.entries(this.sensors)
@@ -230,7 +230,7 @@ const temperatureHelper = {
     },
 
     async _resetMinMax() {
-        this.adapter.log.info('[temperatureHelper] Setze Tages-Min/Max zurück');
+        this.adapter.log.debug('[temperatureHelper] Setze Tages-Min/Max zurück');
         for (const key of Object.keys(this.sensors)) {
             // Bugfix: statt leeres Objekt → löschen, damit Neu-Init greift
             delete this.minMax[key];

package/lib/helpers/timeHelper.js

@@ -17,7 +17,7 @@ const timeHelper = {
         // Minütlicher Check
         this._scheduleCheck();
 
-        this.adapter.log.info('[timeHelper] initialisiert (Prüfung alle 60s)');
+        this.adapter.log.debug('[timeHelper] initialisiert (Prüfung alle 60s)');
     },
 
     _scheduleCheck() {
@@ -59,6 +59,15 @@ const timeHelper = {
                 }
             }
 
+            // --- NEU: Sprachsignal für Zeitsteuerung setzen ---
+            const oldVal = (await this.adapter.getStateAsync('speech.time_active'))?.val;
+            if (oldVal !== shouldRun) {
+                await this.adapter.setStateAsync('speech.time_active', {
+                    val: shouldRun,
+                    ack: true,
+                });
+            }
+
             // Pumpe über die echte Steckdosen-ID schalten
             await this.adapter.setForeignStateAsync(pumpSwitchId, {
                 val: shouldRun,

package/lib/stateDefinitions/controlStates.js

@@ -176,6 +176,70 @@ async function createControlStates(adapter) {
             native: {},
         });
         await adapter.setStateAsync('control.energy.reset', { val: false, ack: true });
+
+        // ---------------------------------------------------------------------
+        // Channel: control.circulation
+        await adapter.setObjectNotExistsAsync('control.circulation', {
+            type: 'channel',
+            common: {
+                name: 'Tagesumwälzungs-Steuerung',
+                desc: 'Automatische oder manuelle Prüfung der täglichen Umwälzmenge',
+            },
+            native: {},
+        });
+
+        // State: Modus (auto/manual/notify/off)
+        await adapter.setObjectNotExistsAsync('control.circulation.mode', {
+            type: 'state',
+            common: {
+                name: 'Modus der Umwälzungsprüfung',
+                desc: 'Legt fest, ob und wie die Tagesumwälzung geprüft und ggf. nachgepumpt wird',
+                type: 'string',
+                role: 'value',
+                read: true,
+                write: true,
+                def: 'notify',
+                states: {
+                    auto: 'Automatik',
+                    manual: 'Manuell',
+                    notify: 'Nur benachrichtigen',
+                    off: 'Aus',
+                },
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('control.circulation.mode', { val: 'notify', ack: true });
+
+        // State: Prüfzeitpunkt
+        await adapter.setObjectNotExistsAsync('control.circulation.check_time', {
+            type: 'state',
+            common: {
+                name: 'Prüfzeitpunkt für Tagesumwälzung',
+                desc: 'Uhrzeit, zu der täglich die Tagesumwälzung geprüft und ggf. gemeldet wird (Format HH:MM)',
+                type: 'string',
+                role: 'value.time',
+                read: true,
+                write: true,
+                def: '18:00',
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('control.circulation.check_time', { val: '18:00', ack: true });
+
+        // State: letzter Bericht
+        await adapter.setObjectNotExistsAsync('control.circulation.last_report', {
+            type: 'state',
+            common: {
+                name: 'Letzter Bericht zur Tagesumwälzung',
+                desc: 'Zeitstempel des letzten automatisch erzeugten Umwälzungs-Reports',
+                type: 'string',
+                role: 'date',
+                read: true,
+                write: false,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('control.circulation.last_report', { val: '', ack: true });
     } catch (err) {
         adapter.log.error(`[controlStates] Fehler beim Erstellen der Control-States: ${err.message}`);
     }

package/lib/stateDefinitions/runtimeStates.js

@@ -78,7 +78,7 @@ async function createRuntimeStates(adapter) {
             role: 'text',
             read: true,
             write: false,
-            persist: false,
+            persist: true,
         },
         native: {},
     });