iobroker.poolcontrol 0.3.1 → 0.4.0

package/lib/helpers/statisticsHelper.js

@@ -0,0 +1,392 @@
+'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) {
+                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 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;
+        }
+
+        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;
+
+        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
+        const summary = {
+            temp_min: newMin,
+            temp_max: newMax,
+            temp_avg: Math.round(newAvg * 100) / 100,
+            updated: now,
+        };
+        await adapter.setStateAsync(`${basePath}.summary_json`, { val: JSON.stringify(summary), ack: true });
+        await adapter.setStateAsync(`${basePath}.summary_html`, {
+            val: `<div><b>Min:</b> ${newMin} °C / <b>Max:</b> ${newMax} °C / <b>Ø:</b> ${Math.round(newAvg * 100) / 100} °C</div>`,
+            ack: true,
+        });
+
+        await this._updateOverallSummary();
+    },
+
+    /**
+     * Gesamt-HTML/JSON-Ausgabe aktualisieren
+     */
+    async _updateOverallSummary() {
+        const adapter = this.adapter;
+        const allData = [];
+
+        for (const sensor of this.sensors) {
+            const active = (await adapter.getStateAsync(`temperature.${sensor.id}.active`))?.val === true;
+            if (!active) {
+                allData.push({ name: sensor.name, status: 'kein Sensor aktiv' });
+                continue;
+            }
+
+            const min = (await adapter.getStateAsync(`analytics.statistics.temperature.today.${sensor.id}.temp_min`))
+                ?.val;
+            const max = (await adapter.getStateAsync(`analytics.statistics.temperature.today.${sensor.id}.temp_max`))
+                ?.val;
+            const avg = (await adapter.getStateAsync(`analytics.statistics.temperature.today.${sensor.id}.temp_avg`))
+                ?.val;
+
+            allData.push({ name: sensor.name, min, max, avg });
+        }
+
+        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_json', {
+            val: JSON.stringify(allData),
+            ack: true,
+        });
+
+        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>';
+
+        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_html', {
+            val: html,
+            ack: true,
+        });
+    },
+
+    /**
+     * 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 ---

package/lib/stateDefinitions/statisticsStates.js

@@ -0,0 +1,138 @@
+'use strict';
+
+/**
+ * statisticsStates.js
+ * -------------------
+ * Erstellt alle States für die Tagesstatistik der Temperatursensoren.
+ * Struktur: analytics.statistics.temperature.today.*
+ *
+ * - Sechs Sensorbereiche (outside, ground, surface, flow, return, collector)
+ * - Je Sensor: Min/Max/Avg + Zeitstempel + JSON/HTML-Ausgabe
+ * - Zusätzlich: Gesamt-Ausgabe (summary_all_json / summary_all_html)
+ *
+ * Alle States sind persistiert, schreibgeschützt und überinstallationssicher.
+ */
+
+/**
+ * @param {ioBroker.Adapter} adapter - Instanz des ioBroker-Adapters
+ */
+async function createStatisticsStates(adapter) {
+    adapter.log.debug('statisticsStates: Initialisierung der Tagesstatistik (Temperatur) gestartet.');
+
+    // Oberstruktur
+    await adapter.setObjectNotExistsAsync('analytics', {
+        type: 'channel',
+        common: { name: 'Analysen & Auswertungen (Statistik, Historie, Berichte)' },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('analytics.statistics', {
+        type: 'channel',
+        common: { name: 'Statistische Auswertungen' },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('analytics.statistics.temperature', {
+        type: 'channel',
+        common: { name: 'Temperaturstatistik' },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('analytics.statistics.temperature.today', {
+        type: 'channel',
+        common: { name: 'Tagesstatistik (Temperaturen)' },
+        native: {},
+    });
+
+    // Definierte Sensoren
+    const 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)' },
+    ];
+
+    for (const sensor of sensors) {
+        const basePath = `analytics.statistics.temperature.today.${sensor.id}`;
+
+        await adapter.setObjectNotExistsAsync(basePath, {
+            type: 'channel',
+            common: { name: `${sensor.name} (Tagesstatistik)` },
+            native: {},
+        });
+
+        const stateDefs = [
+            { id: 'temp_min', name: 'Niedrigste Temperatur', type: 'number', role: 'value.temperature', unit: '°C' },
+            { id: 'temp_max', name: 'Höchste Temperatur', type: 'number', role: 'value.temperature', unit: '°C' },
+            { id: 'temp_min_time', name: 'Zeitpunkt Minimum', type: 'string', role: 'value.time' },
+            { id: 'temp_max_time', name: 'Zeitpunkt Maximum', type: 'string', role: 'value.time' },
+            { id: 'temp_avg', name: 'Durchschnittstemperatur', type: 'number', role: 'value.temperature', unit: '°C' },
+            { id: 'data_points_count', name: 'Anzahl Messwerte', type: 'number', role: 'value' },
+            { id: 'last_update', name: 'Letzte Aktualisierung', type: 'string', role: 'value.time' },
+            { id: 'summary_json', name: 'Tageszusammenfassung (JSON)', type: 'string', role: 'json' },
+            { id: 'summary_html', name: 'Tageszusammenfassung (HTML)', type: 'string', role: 'html' },
+        ];
+
+        for (const def of stateDefs) {
+            await adapter.setObjectNotExistsAsync(`${basePath}.${def.id}`, {
+                type: 'state',
+                common: {
+                    name: def.name,
+                    type: def.type,
+                    role: def.role,
+                    unit: def.unit || undefined,
+                    read: true,
+                    write: false,
+                    def: def.type === 'number' ? null : '',
+                    persist: true,
+                },
+                native: {},
+            });
+        }
+    }
+
+    // Gesamt-Ausgabe (Outputs)
+    const outputBase = 'analytics.statistics.temperature.today.outputs';
+    await adapter.setObjectNotExistsAsync(outputBase, {
+        type: 'channel',
+        common: { name: 'Gesamtausgaben (alle Sensoren)' },
+        native: {},
+    });
+
+    const outputs = [
+        {
+            id: 'summary_all_json',
+            name: 'Gesamtzusammenfassung aller Sensoren (JSON)',
+            role: 'json',
+        },
+        {
+            id: 'summary_all_html',
+            name: 'Gesamtzusammenfassung aller Sensoren (HTML)',
+            role: 'html',
+        },
+    ];
+
+    for (const out of outputs) {
+        await adapter.setObjectNotExistsAsync(`${outputBase}.${out.id}`, {
+            type: 'state',
+            common: {
+                name: out.name,
+                type: 'string',
+                role: out.role,
+                read: true,
+                write: false,
+                def: '',
+                persist: true,
+            },
+            native: {},
+        });
+    }
+
+    adapter.log.debug('statisticsStates: Tagesstatistik (Temperatur) erfolgreich angelegt.');
+}
+
+module.exports = {
+    createStatisticsStates,
+};