iobroker.poolcontrol 0.3.1 → 0.4.0-alpha.0

package/lib/helpers/statisticsHelper.js

@@ -0,0 +1,448 @@
+'use strict';
+
+/**
+ * statisticsHelper.js
+ * -------------------
+ * Vollständige Steuerung der Tagesstatistik (Temperatur)
+ * im Bereich analytics.statistics.temperature.today.*
+ *
+ * - Erstellt alle States (Überinstallationsschutz + Persistenz)
+ * - Erkennt aktive Sensoren anhand temperature.<sensor>.active
+ * - Reagiert eventbasiert auf Änderungen der Temperaturwerte
+ * - Berechnet laufend Min/Max/Durchschnitt
+ * - Aktualisiert JSON- und HTML-Ausgaben (pro Sensor & gesamt)
+ * - Führt automatisch täglichen Reset um Mitternacht durch
+ *
+ * @param {ioBroker.Adapter} adapter - Die aktuelle Adapterinstanz (this),
+ * über die alle ioBroker-Funktionen wie setStateAsync, getStateAsync usw. aufgerufen werden.
+ */
+
+const statisticsHelper = {
+    adapter: null,
+    midnightTimer: null,
+    sensors: [
+        { id: 'outside', name: 'Außentemperatur' },
+        { id: 'ground', name: 'Bodentemperatur' },
+        { id: 'surface', name: 'Pooloberfläche' },
+        { id: 'flow', name: 'Vorlauf' },
+        { id: 'return', name: 'Rücklauf' },
+        { id: 'collector', name: 'Kollektor (Solar)' },
+    ],
+
+    async init(adapter) {
+        this.adapter = adapter;
+        adapter.log.debug('statisticsHelper: Initialisierung gestartet.');
+
+        try {
+            await this._createTemperatureStatistics();
+            await this._subscribeActiveSensors();
+            await this._scheduleMidnightReset();
+            adapter.log.debug('statisticsHelper: Initialisierung abgeschlossen (Sensorüberwachung aktiv).');
+        } catch (err) {
+            adapter.log.warn(`statisticsHelper: Fehler bei Initialisierung: ${err.message}`);
+        }
+    },
+
+    /**
+     * Erstellt States, falls sie fehlen (Überinstallationsschutz)
+     */
+    async _createTemperatureStatistics() {
+        const adapter = this.adapter;
+
+        for (const sensor of this.sensors) {
+            const basePath = `analytics.statistics.temperature.today.${sensor.id}`;
+            await adapter.setObjectNotExistsAsync(basePath, {
+                type: 'channel',
+                common: { name: `${sensor.name} (Tagesstatistik)` },
+                native: {},
+            });
+
+            const activeState = `temperature.${sensor.id}.active`;
+            const isActive = (await adapter.getStateAsync(activeState))?.val === true;
+
+            const summaryJsonPath = `${basePath}.summary_json`;
+            const summaryHtmlPath = `${basePath}.summary_html`;
+
+            if (!isActive) {
+                // Leere JSONs vorbereiten, damit spätere Temperaturwerte sie befüllen können
+                await adapter.setStateAsync(summaryJsonPath, { val: '[]', ack: true });
+                await adapter.setStateAsync(summaryHtmlPath, { val: '', ack: true });
+                continue;
+            }
+
+            const stateDefs = [
+                { id: 'temp_min', def: null },
+                { id: 'temp_max', def: null },
+                { id: 'temp_min_time', def: '' },
+                { id: 'temp_max_time', def: '' },
+                { id: 'temp_avg', def: null },
+                { id: 'data_points_count', def: 0 },
+                { id: 'last_update', def: '' },
+                { id: 'summary_json', def: '' },
+                { id: 'summary_html', def: '' },
+            ];
+
+            for (const def of stateDefs) {
+                const fullPath = `${basePath}.${def.id}`;
+                const obj = await adapter.getObjectAsync(fullPath);
+                if (!obj) {
+                    await adapter.setObjectNotExistsAsync(fullPath, {
+                        type: 'state',
+                        common: {
+                            name: def.id,
+                            type: typeof def.def === 'number' ? 'number' : 'string',
+                            role: def.id.includes('time')
+                                ? 'value.time'
+                                : def.id.includes('temp')
+                                  ? 'value.temperature'
+                                  : 'value',
+                            read: true,
+                            write: false,
+                            persist: true,
+                        },
+                        native: {},
+                    });
+                }
+
+                const state = await adapter.getStateAsync(fullPath);
+                if (!state || state.val === null || state.val === undefined) {
+                    await adapter.setStateAsync(fullPath, { val: def.def, ack: true });
+                }
+            }
+        }
+
+        const outputBase = 'analytics.statistics.temperature.today.outputs';
+        await adapter.setObjectNotExistsAsync(outputBase, {
+            type: 'channel',
+            common: { name: 'Gesamtausgaben (alle Sensoren)' },
+            native: {},
+        });
+
+        const outputStates = [
+            { id: 'summary_all_json', def: '' },
+            { id: 'summary_all_html', def: '' },
+        ];
+
+        for (const out of outputStates) {
+            const fullPath = `${outputBase}.${out.id}`;
+            const obj = await adapter.getObjectAsync(fullPath);
+            if (!obj) {
+                await adapter.setObjectNotExistsAsync(fullPath, {
+                    type: 'state',
+                    common: {
+                        name: out.id,
+                        type: 'string',
+                        role: out.id.endsWith('json') ? 'json' : 'html',
+                        read: true,
+                        write: false,
+                        persist: true,
+                    },
+                    native: {},
+                });
+            }
+
+            const state = await adapter.getStateAsync(fullPath);
+            if (!state || state.val === null || state.val === undefined) {
+                await adapter.setStateAsync(fullPath, { val: out.id.endsWith('json') ? '{}' : '', ack: true });
+            }
+        }
+    },
+
+    /**
+     * Abonniert alle aktiven Temperatursensoren
+     */
+    async _subscribeActiveSensors() {
+        const adapter = this.adapter;
+        for (const sensor of this.sensors) {
+            const activeState = `temperature.${sensor.id}.active`;
+            const isActive = (await adapter.getStateAsync(activeState))?.val === true;
+            if (isActive) {
+                const stateId = `temperature.${sensor.id}.current`;
+                adapter.subscribeStates(stateId);
+            }
+        }
+
+        adapter.on('stateChange', async (id, state) => {
+            if (!state || state.ack === false) {
+                return;
+            }
+            for (const sensor of this.sensors) {
+                if (id.endsWith(`temperature.${sensor.id}.current`)) {
+                    await this._processTemperatureChange(sensor.id, state.val);
+                    break;
+                }
+            }
+        });
+    },
+
+    /**
+     * Verarbeitung einer Temperaturänderung für einen Sensor.
+     * Aktualisiert Min-, Max- und Durchschnittswerte sowie die Zusammenfassungen.
+     *
+     * @param {string} sensorId - Die ID des betroffenen Sensors (z. B. "outside" oder "flow").
+     * @param {number} newValue - Der neue gemessene Temperaturwert in °C.
+     */
+    async _processTemperatureChange(sensorId, newValue) {
+        const adapter = this.adapter;
+        const basePath = `analytics.statistics.temperature.today.${sensorId}`;
+        const now = new Date().toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' });
+
+        if (typeof newValue !== 'number') {
+            return;
+        }
+
+        // NEU: Rundung auf 1 Nachkommastelle
+        newValue = Math.round(newValue * 10) / 10;
+
+        const tempMin = (await adapter.getStateAsync(`${basePath}.temp_min`))?.val;
+        const tempMax = (await adapter.getStateAsync(`${basePath}.temp_max`))?.val;
+        const tempAvg = (await adapter.getStateAsync(`${basePath}.temp_avg`))?.val;
+        const count = (await adapter.getStateAsync(`${basePath}.data_points_count`))?.val || 0;
+
+        let newMin = tempMin;
+        let newMax = tempMax;
+        let newAvg = tempAvg;
+
+        if (tempMin === null || newValue < tempMin) {
+            newMin = newValue;
+            await adapter.setStateAsync(`${basePath}.temp_min_time`, { val: now, ack: true });
+        }
+        if (tempMax === null || newValue > tempMax) {
+            newMax = newValue;
+            await adapter.setStateAsync(`${basePath}.temp_max_time`, { val: now, ack: true });
+        }
+
+        // Durchschnitt (gleitend)
+        const newCount = count + 1;
+        newAvg = tempAvg === null ? newValue : (tempAvg * count + newValue) / newCount;
+
+        // NEU: Alle Temperaturwerte auf 1 Nachkommastelle runden
+        newMin = Math.round(newMin * 10) / 10;
+        newMax = Math.round(newMax * 10) / 10;
+        newAvg = Math.round(newAvg * 10) / 10;
+
+        await adapter.setStateAsync(`${basePath}.temp_min`, { val: newMin, ack: true });
+        await adapter.setStateAsync(`${basePath}.temp_max`, { val: newMax, ack: true });
+        await adapter.setStateAsync(`${basePath}.temp_avg`, { val: Math.round(newAvg * 100) / 100, ack: true });
+        await adapter.setStateAsync(`${basePath}.data_points_count`, { val: newCount, ack: true });
+        await adapter.setStateAsync(`${basePath}.last_update`, { val: now, ack: true });
+
+        // Summary aktualisieren
+        // NEU: Zusammenfassung mit gerundeten Werten (1 Nachkommastelle)
+        const summary = {
+            temp_min: newMin,
+            temp_max: newMax,
+            temp_avg: newAvg,
+            updated: now,
+        };
+        await adapter.setStateAsync(`${basePath}.summary_json`, { val: JSON.stringify(summary), ack: true });
+        await adapter.setStateAsync(`${basePath}.summary_html`, {
+            // NEU: HTML-Ausgabe mit gerundeten Werten
+            val: `<div><b>Min:</b> ${newMin} °C / <b>Max:</b> ${newMax} °C / <b>Ø:</b> ${newAvg} °C</div>`,
+            ack: true,
+        });
+
+        await this._updateOverallSummary();
+    },
+
+    /**
+     * Gesamt-HTML/JSON-Ausgabe aktualisieren (Endgültige Version)
+     * Liest die fertigen summary_json-Werte aller aktiven Sensoren aus
+     * und erstellt daraus eine zusammengefasste HTML- und JSON-Ausgabe.
+     */
+    async _updateOverallSummary() {
+        const adapter = this.adapter;
+        const allData = [];
+
+        try {
+            // Alle Sensoren durchlaufen
+            for (const sensor of this.sensors) {
+                // const isActive = (await adapter.getStateAsync(`temperature.${sensor.id}.active`))?.val === true;
+                // if (!isActive) continue;
+
+                // Fertige Einzel-Summary des Sensors abrufen
+                const summaryState = await adapter.getStateAsync(
+                    `analytics.statistics.temperature.today.${sensor.id}.summary_json`,
+                );
+
+                if (!summaryState || !summaryState.val) {
+                    continue;
+                }
+
+                // JSON-Inhalt parsen
+                let parsed;
+                try {
+                    parsed = JSON.parse(summaryState.val);
+                } catch {
+                    continue;
+                }
+
+                const min = parsed.temp_min;
+                const max = parsed.temp_max;
+                const avg = parsed.temp_avg;
+
+                if (min == null && max == null && avg == null) {
+                    continue;
+                }
+
+                // Werte runden
+                const rMin = typeof min === 'number' ? Math.round(min * 10) / 10 : min;
+                const rMax = typeof max === 'number' ? Math.round(max * 10) / 10 : max;
+                const rAvg = typeof avg === 'number' ? Math.round(avg * 10) / 10 : avg;
+
+                allData.push({
+                    name: sensor.name,
+                    min: rMin,
+                    max: rMax,
+                    avg: rAvg,
+                });
+            }
+
+            // Wenn noch keine Daten vorliegen → leer lassen
+            if (allData.length === 0) {
+                await adapter.setStateChangedAsync('analytics.statistics.temperature.today.outputs.summary_all_json', {
+                    val: '[]',
+                    ack: true,
+                });
+                await adapter.setStateChangedAsync('analytics.statistics.temperature.today.outputs.summary_all_html', {
+                    val: '',
+                    ack: true,
+                });
+                return;
+            }
+
+            // JSON-Ausgabe erstellen
+            const jsonOutput = JSON.stringify(allData);
+
+            // HTML-Ausgabe erstellen
+            let html = '<table style="width:100%;border-collapse:collapse;">';
+            html += '<tr><th style="text-align:left;">Sensor</th><th>Min</th><th>Max</th><th>Ø</th></tr>';
+            for (const entry of allData) {
+                html += `<tr><td>${entry.name}</td><td>${entry.min ?? '-'}</td><td>${entry.max ?? '-'}</td><td>${entry.avg ?? '-'}</td></tr>`;
+            }
+            html += '</table>';
+
+            // States setzen (auch bei gleichen Werten → Timestamp aktualisieren)
+            await adapter.setStateChangedAsync('analytics.statistics.temperature.today.outputs.summary_all_json', {
+                val: jsonOutput,
+                ack: true,
+            });
+            await adapter.setStateChangedAsync('analytics.statistics.temperature.today.outputs.summary_all_html', {
+                val: html,
+                ack: true,
+            });
+
+            adapter.log.debug('statisticsHelper: Gesamtzusammenfassung (Summary All) erfolgreich aktualisiert.');
+        } catch (err) {
+            adapter.log.warn(`statisticsHelper: Fehler bei Gesamtzusammenfassung: ${err.message}`);
+        }
+    },
+
+    /**
+     * Mitternacht-Reset planen
+     */
+    async _scheduleMidnightReset() {
+        const adapter = this.adapter;
+        if (this.midnightTimer) {
+            clearTimeout(this.midnightTimer);
+        }
+
+        const now = new Date();
+        const nextMidnight = new Date(now);
+        nextMidnight.setHours(24, 0, 5, 0);
+        const msUntilMidnight = nextMidnight.getTime() - now.getTime();
+
+        this.midnightTimer = setTimeout(async () => {
+            await this._resetDailyTemperatureStats();
+            await this._scheduleMidnightReset();
+        }, msUntilMidnight);
+
+        adapter.log.debug(
+            `statisticsHelper: Mitternacht-Reset geplant in ${Math.round(msUntilMidnight / 60000)} Minuten.`,
+        );
+    },
+
+    /**
+     * Tagesstatistik zurücksetzen
+     */
+    async _resetDailyTemperatureStats() {
+        const adapter = this.adapter;
+        adapter.log.info('statisticsHelper: Tagesstatistik wird zurückgesetzt.');
+
+        const resetDate = new Date().toISOString().slice(0, 19).replace('T', ' ');
+
+        for (const sensor of this.sensors) {
+            const basePath = `analytics.statistics.temperature.today.${sensor.id}`;
+            const activeState = `temperature.${sensor.id}.active`;
+            const isActive = (await adapter.getStateAsync(activeState))?.val === true;
+
+            const summaryJsonPath = `${basePath}.summary_json`;
+            const summaryHtmlPath = `${basePath}.summary_html`;
+
+            if (!isActive) {
+                await adapter.setStateAsync(summaryJsonPath, {
+                    val: JSON.stringify({ status: 'kein Sensor aktiv' }),
+                    ack: true,
+                });
+                await adapter.setStateAsync(summaryHtmlPath, {
+                    val: '<div style="color:gray;">kein Sensor aktiv</div>',
+                    ack: true,
+                });
+                continue;
+            }
+
+            const stateList = [
+                'temp_min',
+                'temp_max',
+                'temp_min_time',
+                'temp_max_time',
+                'temp_avg',
+                'data_points_count',
+                'last_update',
+            ];
+
+            for (const state of stateList) {
+                const fullPath = `${basePath}.${state}`;
+                let defValue = null;
+                if (state.includes('time')) {
+                    defValue = '';
+                }
+                if (state === 'data_points_count') {
+                    defValue = 0;
+                }
+                if (state === 'last_update') {
+                    defValue = resetDate;
+                }
+                await adapter.setStateAsync(fullPath, { val: defValue, ack: true });
+            }
+
+            await adapter.setStateAsync(summaryJsonPath, {
+                val: JSON.stringify({ date_reset: resetDate, status: 'Tageswerte zurückgesetzt' }),
+                ack: true,
+            });
+            await adapter.setStateAsync(summaryHtmlPath, {
+                val: `<div style="color:gray;">Tageswerte zurückgesetzt (${resetDate})</div>`,
+                ack: true,
+            });
+        }
+
+        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_json', {
+            val: '{}',
+            ack: true,
+        });
+        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_html', {
+            val: '',
+            ack: true,
+        });
+
+        adapter.log.debug('statisticsHelper: Tagesstatistik zurückgesetzt.');
+    },
+
+    cleanup() {
+        if (this.midnightTimer) {
+            clearTimeout(this.midnightTimer);
+        }
+    },
+};
+
+module.exports = statisticsHelper;

package/lib/stateDefinitions/controlStates.js

@@ -26,43 +26,6 @@ async function createControlStates(adapter) {
             native: {},
         });
 
-        // Channel: control.season
-        await adapter.setObjectNotExistsAsync('control.season', {
-            type: 'channel',
-            common: {
-                name: 'Saisonsteuerung',
-                desc: 'Steuerung der aktiven Poolsaison und saisonabhängiger Funktionen',
-            },
-            native: {},
-        });
-
-        // State: control.season.active (mit Persist-Schutz)
-        await adapter.setObjectNotExistsAsync('control.season.active', {
-            type: 'state',
-            common: {
-                name: 'Poolsaison aktiv',
-                desc: 'Zeigt an, ob die Poolsaison aktiv ist (steuerbar über VIS oder Blockly)',
-                type: 'boolean',
-                role: 'switch',
-                read: true,
-                write: true,
-                def: false,
-                persist: true, // dauerhaft speichern
-            },
-            native: {},
-        });
-
-        const existingSeasonActive = await adapter.getStateAsync('control.season.active');
-        if (
-            existingSeasonActive === null ||
-            existingSeasonActive.val === null ||
-            existingSeasonActive.val === undefined
-        ) {
-            const cfgValue = !!adapter.config.season_active;
-            await adapter.setStateAsync('control.season.active', { val: cfgValue, ack: true });
-            adapter.log.debug(`[controlStates] State control.season.active initialisiert mit Wert: ${cfgValue}`);
-        }
-
         // ---------------------------------------------------------------------
         // Channel: control.pump
         await adapter.setObjectNotExistsAsync('control.pump', {
@@ -347,30 +310,6 @@ async function createControlStates(adapter) {
     } catch (err) {
         adapter.log.error(`[controlStates] Fehler beim Erstellen der Control-States: ${err.message}`);
     }
-    // ------------------------------------------------------
-    // Control – Hardware
-    // ------------------------------------------------------
-    await adapter.setObjectNotExistsAsync('control.hardware', {
-        type: 'channel',
-        common: { name: 'Hardware-Steuerung (externe Boxen)' },
-        native: {},
-    });
-
-    // TempBox aktivieren/deaktivieren
-    await adapter.setObjectNotExistsAsync('control.hardware.use_tempbox', {
-        type: 'state',
-        common: {
-            name: 'Externe Temperaturbox verwenden',
-            desc: 'Wenn aktiviert, nutzt PoolControl die Werte der externen TempBox anstelle der manuellen Temperatursensoren.',
-            type: 'boolean',
-            role: 'switch',
-            def: false,
-            read: true,
-            write: true,
-            persist: true,
-        },
-        native: {},
-    });
 }
 
 module.exports = { createControlStates };

package/lib/stateDefinitions/pumpStates3.js

@@ -199,6 +199,28 @@ async function createPumpStates3(adapter) {
         await adapter.setStateAsync('pump.learning.deviation_flow_percent', { val: 0, ack: true });
     }
 
+    // ------------------------------------------------------
+    // Toleranzbereich für Normalbereichserkennung (%)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.learning.tolerance_percent', {
+        type: 'state',
+        common: {
+            name: 'Toleranzbereich für Normalbereichserkennung (%)',
+            desc: 'Abweichung, die noch als normal gilt, bevor eine Warnung ausgelöst wird',
+            type: 'number',
+            role: 'value.percent',
+            unit: '%',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingTolerance = await adapter.getStateAsync('pump.learning.tolerance_percent');
+    if (existingTolerance === null || existingTolerance.val === null || existingTolerance.val === undefined) {
+        await adapter.setStateAsync('pump.learning.tolerance_percent', { val: 20, ack: true });
+    }
+
     // ------------------------------------------------------
     // Textbewertung (Status)
     // ------------------------------------------------------

package/lib/stateDefinitions/runtimeStates.js

@@ -36,7 +36,10 @@ async function createRuntimeStates(adapter) {
         },
         native: {},
     });
-    await adapter.setStateAsync('runtime.total', { val: '0h 0m 0s', ack: true });
+    const existingTotal = await adapter.getStateAsync('runtime.total');
+    if (!existingTotal || existingTotal.val === null || existingTotal.val === undefined) {
+        await adapter.setStateAsync('runtime.total', { val: '0h 0m 0s', ack: true }); // FIX: Nur setzen, wenn leer
+    }
 
     // Tageslaufzeit (formatiert)
     await adapter.setObjectNotExistsAsync('runtime.today', {
@@ -51,7 +54,10 @@ async function createRuntimeStates(adapter) {
         },
         native: {},
     });
-    await adapter.setStateAsync('runtime.today', { val: '0h 0m 0s', ack: true });
+    const existingToday = await adapter.getStateAsync('runtime.today');
+    if (!existingToday || existingToday.val === null || existingToday.val === undefined) {
+        await adapter.setStateAsync('runtime.today', { val: '0h 0m 0s', ack: true }); // FIX
+    }
 
     // -------------------------------------------------------------------------
     // NEU: Pumpenstarts heute
@@ -67,7 +73,10 @@ async function createRuntimeStates(adapter) {
         },
         native: {},
     });
-    await adapter.setStateAsync('runtime.start_count_today', { val: 0, ack: true });
+    const existingStartCount = await adapter.getStateAsync('runtime.start_count_today');
+    if (!existingStartCount || existingStartCount.val === null || existingStartCount.val === undefined) {
+        await adapter.setStateAsync('runtime.start_count_today', { val: 0, ack: true }); // FIX
+    }
 
     // NEU: Aktuelle Laufzeit (seit Einschalten)
     await adapter.setObjectNotExistsAsync('runtime.current_session', {
@@ -82,7 +91,10 @@ async function createRuntimeStates(adapter) {
         },
         native: {},
     });
-    await adapter.setStateAsync('runtime.current_session', { val: '0h 0m 0s', ack: true });
+    const existingCurrent = await adapter.getStateAsync('runtime.current_session');
+    if (!existingCurrent || existingCurrent.val === null || existingCurrent.val === undefined) {
+        await adapter.setStateAsync('runtime.current_session', { val: '0h 0m 0s', ack: true }); // FIX
+    }
 
     // NEU: Gesamtlaufzeit der aktuellen Saison (formatiert)
     await adapter.setObjectNotExistsAsync('runtime.season_total', {
@@ -97,7 +109,10 @@ async function createRuntimeStates(adapter) {
         },
         native: {},
     });
-    await adapter.setStateAsync('runtime.season_total', { val: '0h 0m 0s', ack: true });
+    const existingSeason = await adapter.getStateAsync('runtime.season_total');
+    if (!existingSeason || existingSeason.val === null || existingSeason.val === undefined) {
+        await adapter.setStateAsync('runtime.season_total', { val: '0h 0m 0s', ack: true }); // FIX
+    }
 
     // -------------------------------------------------------------------------
     // --- Kanal circulation ---