iobroker.poolcontrol 0.0.7

package/lib/helpers/temperatureHelper.js

@@ -0,0 +1,227 @@
+'use strict';
+
+/**
+ * temperatureHelper
+ * - Abonniert konfigurierte Temperatursensoren (Foreign States)
+ * - Schreibt aktuelle Werte:
+ *   - temperature.<sensor>.current
+ * - Berechnet Differenzen:
+ *   - temperature.delta.collector_outside = collector - outside
+ *   - temperature.delta.surface_ground    = surface - ground
+ *   - temperature.delta.flow_return       = flow - return
+ * - Tages-Min/Max je Sensor
+ * - Änderung pro Stunde (delta_per_hour)
+ */
+
+const temperatureHelper = {
+    adapter: null,
+    sensors: {}, // { collector: 'id', outside: 'id', surface: 'id', ground: 'id', flow: 'id', return: 'id' }
+    values: {}, // aktuelle Werte { collector: number, outside: number, ... }
+    minMax: {}, // { collector: { min, max }, ... }
+    history: {}, // { sensorKey: [{ ts, val }, ...] }
+    resetTimer: null,
+
+    init(adapter) {
+        this.adapter = adapter;
+        this.sensors = this._collectActiveSensors(adapter);
+
+        // Foreign-States abonnieren
+        for (const id of Object.values(this.sensors)) {
+            adapter.subscribeForeignStates(id);
+        }
+
+        // Reset um Mitternacht
+        this._scheduleDailyReset();
+
+        adapter.log.info(
+            `[temperatureHelper] Aktiv: ${
+                Object.keys(this.sensors).length
+                    ? Object.entries(this.sensors)
+                          .map(([k, v]) => `${k}=${v}`)
+                          .join(', ')
+                    : 'keine Sensoren konfiguriert'
+            }`,
+        );
+    },
+
+    _collectActiveSensors(adapter) {
+        const c = adapter.config || {};
+        const map = {};
+        if (c.collector_temp_active && c.collector_temp_sensor) {
+            map.collector = c.collector_temp_sensor;
+        }
+        if (c.outside_temp_active && c.outside_temp_sensor) {
+            map.outside = c.outside_temp_sensor;
+        }
+        if (c.surface_temp_active && c.surface_temp_sensor) {
+            map.surface = c.surface_temp_sensor;
+        }
+        if (c.ground_temp_active && c.ground_temp_sensor) {
+            map.ground = c.ground_temp_sensor;
+        }
+        if (c.flow_temp_active && c.flow_temp_sensor) {
+            map.flow = c.flow_temp_sensor;
+        }
+        if (c.return_temp_active && c.return_temp_sensor) {
+            map.return = c.return_temp_sensor;
+        }
+        return map;
+    },
+
+    async handleStateChange(id, state) {
+        if (!state || state.val === null || state.val === undefined) {
+            return;
+        }
+        const key = Object.keys(this.sensors).find(k => this.sensors[k] === id);
+        if (!key) {
+            return;
+        }
+
+        const num = Number(state.val);
+        if (!Number.isFinite(num)) {
+            return;
+        }
+
+        this.values[key] = num;
+
+        // Aktuellen Wert setzen
+        await this._setCurrentValue(key, num);
+
+        // Deltas berechnen
+        await this._maybeWriteDelta('temperature.delta.collector_outside', this.values.collector, this.values.outside);
+        await this._maybeWriteDelta('temperature.delta.surface_ground', this.values.surface, this.values.ground);
+        await this._maybeWriteDelta('temperature.delta.flow_return', this.values.flow, this.values.return);
+
+        // Min/Max aktualisieren
+        await this._updateMinMax(key, num);
+
+        // Verlauf speichern und Delta pro Stunde berechnen
+        await this._updateHistoryAndDelta(key, num);
+    },
+
+    async _setCurrentValue(key, value) {
+        try {
+            await this.adapter.setStateAsync(`temperature.${key}.current`, {
+                val: value,
+                ack: true,
+            });
+        } catch (err) {
+            this.adapter.log.warn(`[temperatureHelper] setState current ${key} fehlgeschlagen: ${err.message}`);
+        }
+    },
+
+    async _maybeWriteDelta(stateId, a, b) {
+        if (a === undefined || b === undefined) {
+            return;
+        }
+        const delta = Number((a - b).toFixed(2));
+        try {
+            await this.adapter.setStateAsync(stateId, { val: delta, ack: true });
+        } catch (err) {
+            this.adapter.log.warn(`[temperatureHelper] setState ${stateId} fehlgeschlagen: ${err.message}`);
+        }
+    },
+
+    async _updateMinMax(key, value) {
+        if (!this.minMax[key]) {
+            this.minMax[key] = { min: value, max: value };
+            await this.adapter.setStateAsync(`temperature.${key}.min_today`, {
+                val: value,
+                ack: true,
+            });
+            await this.adapter.setStateAsync(`temperature.${key}.max_today`, {
+                val: value,
+                ack: true,
+            });
+            return;
+        }
+
+        if (value < this.minMax[key].min) {
+            this.minMax[key].min = value;
+            await this.adapter.setStateAsync(`temperature.${key}.min_today`, {
+                val: value,
+                ack: true,
+            });
+        }
+        if (value > this.minMax[key].max) {
+            this.minMax[key].max = value;
+            await this.adapter.setStateAsync(`temperature.${key}.max_today`, {
+                val: value,
+                ack: true,
+            });
+        }
+    },
+
+    async _updateHistoryAndDelta(key, value) {
+        const now = Date.now();
+        if (!this.history[key]) {
+            this.history[key] = [];
+        }
+
+        // Wert speichern
+        this.history[key].push({ ts: now, val: value });
+
+        // Nur letzte 2 Stunden behalten
+        this.history[key] = this.history[key].filter(p => now - p.ts <= 2 * 3600 * 1000);
+
+        // Referenzwert von vor ~1 Stunde suchen
+        const oneHourAgo = now - 3600 * 1000;
+        const past = this.history[key].find(p => p.ts <= oneHourAgo);
+        if (past) {
+            const deltaPerHour = Number((value - past.val).toFixed(2));
+            try {
+                await this.adapter.setStateAsync(`temperature.${key}.delta_per_hour`, {
+                    val: deltaPerHour,
+                    ack: true,
+                });
+            } catch (err) {
+                this.adapter.log.warn(
+                    `[temperatureHelper] setState delta_per_hour ${key} fehlgeschlagen: ${err.message}`,
+                );
+            }
+        }
+    },
+
+    _scheduleDailyReset() {
+        // Timer berechnen: Millisekunden bis Mitternacht
+        const now = new Date();
+        const nextMidnight = new Date(now);
+        nextMidnight.setHours(24, 0, 0, 0);
+        const msUntilMidnight = nextMidnight.getTime() - now.getTime();
+
+        this.resetTimer = setTimeout(() => {
+            this._resetMinMax();
+            this._scheduleDailyReset(); // neu für nächsten Tag
+        }, msUntilMidnight);
+    },
+
+    async _resetMinMax() {
+        this.adapter.log.info('[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];
+
+            await this.adapter.setStateAsync(`temperature.${key}.min_today`, {
+                val: null,
+                ack: true,
+            });
+            await this.adapter.setStateAsync(`temperature.${key}.max_today`, {
+                val: null,
+                ack: true,
+            });
+            await this.adapter.setStateAsync(`temperature.${key}.delta_per_hour`, {
+                val: null,
+                ack: true,
+            });
+        }
+    },
+
+    cleanup() {
+        if (this.resetTimer) {
+            clearTimeout(this.resetTimer);
+            this.resetTimer = null;
+        }
+    },
+};
+
+module.exports = temperatureHelper;

package/lib/helpers/timeHelper.js

@@ -0,0 +1,88 @@
+'use strict';
+
+/**
+ * timeHelper
+ * - Überwacht Zeitfenster (time1, time2, time3)
+ * - Schaltet Pumpe, wenn Modus "time" aktiv ist
+ * - Schaltet über die reale Steckdosen-ID aus der Config
+ */
+
+const timeHelper = {
+    adapter: null,
+    checkTimer: null,
+
+    init(adapter) {
+        this.adapter = adapter;
+
+        // Minütlicher Check
+        this._scheduleCheck();
+
+        this.adapter.log.info('[timeHelper] initialisiert (Prüfung alle 60s)');
+    },
+
+    _scheduleCheck() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+        }
+        this.checkTimer = setInterval(() => this._checkWindows(), 60 * 1000);
+        // Beim Start sofort prüfen
+        this._checkWindows();
+    },
+
+    async _checkWindows() {
+        try {
+            const mode = (await this.adapter.getStateAsync('pump.mode'))?.val;
+            if (mode !== 'time') {
+                return;
+            } // nur aktiv im Zeitmodus
+
+            const pumpSwitchId = this.adapter.config.pump_switch;
+            if (!pumpSwitchId) {
+                this.adapter.log.warn('[timeHelper] Keine pump_switch (Fremd-ID) konfiguriert!');
+                return;
+            }
+
+            const now = new Date();
+            const hhmm = now.toTimeString().slice(0, 5); // "HH:MM"
+            const weekday = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'][now.getDay()];
+
+            let shouldRun = false;
+            for (let i = 1; i <= 3; i++) {
+                const active = (await this.adapter.getStateAsync(`timecontrol.time${i}_active`))?.val;
+                const start = (await this.adapter.getStateAsync(`timecontrol.time${i}_start`))?.val;
+                const end = (await this.adapter.getStateAsync(`timecontrol.time${i}_end`))?.val;
+                const dayOk = (await this.adapter.getStateAsync(`timecontrol.time${i}_day_${weekday}`))?.val;
+
+                if (active && dayOk && this._inTimeRange(hhmm, start, end)) {
+                    shouldRun = true;
+                    break;
+                }
+            }
+
+            // Pumpe über die echte Steckdosen-ID schalten
+            await this.adapter.setForeignStateAsync(pumpSwitchId, {
+                val: shouldRun,
+                ack: false,
+            });
+            this.adapter.log.debug(`[timeHelper] Pumpe ${shouldRun ? 'EIN' : 'AUS'} (${hhmm})`);
+        } catch (err) {
+            this.adapter.log.warn(`[timeHelper] Fehler im Check: ${err.message}`);
+        }
+    },
+
+    _inTimeRange(now, start, end) {
+        if (!start || !end) {
+            return false;
+        }
+        return start <= now && now < end;
+    },
+
+    cleanup() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = null;
+        }
+    },
+};
+
+module.exports = timeHelper;

package/lib/stateDefinitions/consumptionStates.js

@@ -0,0 +1,82 @@
+'use strict';
+
+/**
+ * Legt alle States für Verbrauch (kWh) und Kosten (€) an.
+ * - consumption.total_kwh
+ * - consumption.day_kwh, week_kwh, month_kwh, year_kwh
+ * - consumption.last_total_kwh (interner Baseline-Wert)
+ * - consumption.offset_kwh (interner Zählerausgleich bei Reset/Wechsel)
+ * - costs.total_eur
+ * - costs.day_eur, week_eur, month_eur, year_eur
+ *
+ * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createConsumptionStates(adapter) {
+    // --- Kanal consumption ---
+    await adapter.setObjectNotExistsAsync('consumption', {
+        type: 'channel',
+        common: { name: 'Stromverbrauch' },
+        native: {},
+    });
+
+    const consumptionStates = {
+        total_kwh: { name: 'Gesamtverbrauch', unit: 'kWh' },
+        day_kwh: { name: 'Verbrauch heute', unit: 'kWh' },
+        week_kwh: { name: 'Verbrauch diese Woche', unit: 'kWh' },
+        month_kwh: { name: 'Verbrauch dieser Monat', unit: 'kWh' },
+        year_kwh: { name: 'Verbrauch dieses Jahr', unit: 'kWh' },
+        last_total_kwh: { name: 'Letzter Zählerstand (Baseline)', unit: 'kWh' },
+        offset_kwh: { name: 'Offset kWh (interner Zählerausgleich)', unit: 'kWh' },
+    };
+
+    for (const [id, cfg] of Object.entries(consumptionStates)) {
+        await adapter.setObjectNotExistsAsync(`consumption.${id}`, {
+            type: 'state',
+            common: {
+                name: cfg.name,
+                type: 'number',
+                role: 'value.power.consumption',
+                unit: cfg.unit,
+                read: true,
+                write: false,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync(`consumption.${id}`, { val: 0, ack: true });
+    }
+
+    // --- Kanal costs ---
+    await adapter.setObjectNotExistsAsync('costs', {
+        type: 'channel',
+        common: { name: 'Kosten' },
+        native: {},
+    });
+
+    const costStates = {
+        total_eur: { name: 'Gesamtkosten', unit: '€' },
+        day_eur: { name: 'Kosten heute', unit: '€' },
+        week_eur: { name: 'Kosten diese Woche', unit: '€' },
+        month_eur: { name: 'Kosten dieser Monat', unit: '€' },
+        year_eur: { name: 'Kosten dieses Jahr', unit: '€' },
+    };
+
+    for (const [id, cfg] of Object.entries(costStates)) {
+        await adapter.setObjectNotExistsAsync(`costs.${id}`, {
+            type: 'state',
+            common: {
+                name: cfg.name,
+                type: 'number',
+                role: 'value.cost',
+                unit: cfg.unit,
+                read: true,
+                write: false,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync(`costs.${id}`, { val: 0, ack: true });
+    }
+}
+
+module.exports = {
+    createConsumptionStates,
+};

package/lib/stateDefinitions/generalStates.js

@@ -0,0 +1,68 @@
+'use strict';
+
+/**
+ * Legt alle States für die allgemeinen Einstellungen an:
+ * - pool_name
+ * - pool_size
+ * - min_circulation_per_day
+ *
+ * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createGeneralStates(adapter) {
+    // Poolname
+    await adapter.setObjectNotExistsAsync('general.pool_name', {
+        type: 'state',
+        common: {
+            name: 'Name deines Pools',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('general.pool_name', {
+        val: adapter.config.pool_name,
+        ack: true,
+    });
+
+    // Minimale Umwälzung pro Tag
+    await adapter.setObjectNotExistsAsync('general.min_circulation_per_day', {
+        type: 'state',
+        common: {
+            name: 'Min. Umwälzung pro Tag',
+            type: 'number',
+            role: 'value',
+            unit: 'x',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('general.min_circulation_per_day', {
+        val: adapter.config.min_circulation_per_day,
+        ack: true,
+    });
+
+    // Poolgröße (Liter)
+    await adapter.setObjectNotExistsAsync('general.pool_size', {
+        type: 'state',
+        common: {
+            name: 'Grösse deines Pools in Liter',
+            type: 'number',
+            role: 'value',
+            unit: 'l',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('general.pool_size', {
+        val: adapter.config.pool_size,
+        ack: true,
+    });
+}
+
+module.exports = {
+    createGeneralStates,
+};

package/lib/stateDefinitions/pumpStates.js

@@ -0,0 +1,184 @@
+'use strict';
+
+/**
+ * Legt alle States für die Pumpenverwaltung an:
+ * - pump.pump_max_watt, pump.pump_power_lph
+ * - pump.frost_protection_active, pump.frost_protection_temp
+ * - pump.pump_switch (JETZT: boolean Schalter)
+ * - pump.mode (auto/manual/off/time)
+ * - pump.manual_safety_enabled
+ * - pump.status, pump.error
+ * - pump.current_power
+ *
+ * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createPumpStates(adapter) {
+    // Max. Pumpenleistung (W)
+    await adapter.setObjectNotExistsAsync('pump.pump_max_watt', {
+        type: 'state',
+        common: {
+            name: 'Max. Pumpenleistung',
+            type: 'number',
+            role: 'value.power',
+            unit: 'W',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.pump_max_watt', {
+        val: adapter.config.pump_max_watt,
+        ack: true,
+    });
+
+    // Pumpenleistung (l/h)
+    await adapter.setObjectNotExistsAsync('pump.pump_power_lph', {
+        type: 'state',
+        common: {
+            name: 'Pumpenleistung (l/h)',
+            type: 'number',
+            role: 'value.flow',
+            unit: 'l/h',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.pump_power_lph', {
+        val: adapter.config.pump_power_lph,
+        ack: true,
+    });
+
+    // Frostschutz aktiv
+    await adapter.setObjectNotExistsAsync('pump.frost_protection_active', {
+        type: 'state',
+        common: {
+            name: 'Frostschutz aktiv',
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.frost_protection_active', {
+        val: adapter.config.frost_protection_active,
+        ack: true,
+    });
+
+    // Frostschutz-Temperatur
+    await adapter.setObjectNotExistsAsync('pump.frost_protection_temp', {
+        type: 'state',
+        common: {
+            name: 'Frostschutz-Temperatur',
+            type: 'number',
+            role: 'value.temperature',
+            unit: '°C',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.frost_protection_temp', {
+        val: adapter.config.frost_protection_temp,
+        ack: true,
+    });
+
+    // **Zentraler Pumpen-Schalter (boolean)**
+    await adapter.setObjectNotExistsAsync('pump.pump_switch', {
+        type: 'state',
+        common: {
+            name: 'Pumpe EIN/AUS',
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.pump_switch', { val: false, ack: true });
+
+    // Pumpenmodus
+    await adapter.setObjectNotExistsAsync('pump.mode', {
+        type: 'state',
+        common: {
+            name: 'Pumpenmodus',
+            type: 'string',
+            role: 'state',
+            read: true,
+            write: true,
+            states: {
+                auto: 'Automatik',
+                manual: 'Manuell',
+                off: 'Aus',
+                time: 'Zeit',
+            },
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.mode', { val: 'auto', ack: true });
+
+    // Sicherheitslogik im manuellen Modus
+    await adapter.setObjectNotExistsAsync('pump.manual_safety_enabled', {
+        type: 'state',
+        common: {
+            name: "Sicherheitsfunktionen im Modus 'Manuell' aktiv",
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.manual_safety_enabled', {
+        val: adapter.config.manual_safety_enabled ?? true,
+        ack: true,
+    });
+
+    // Pumpenstatus (Text)
+    await adapter.setObjectNotExistsAsync('pump.status', {
+        type: 'state',
+        common: {
+            name: 'Pumpenstatus',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.status', { val: 'AUS', ack: true });
+
+    // Pumpenfehler (bool)
+    await adapter.setObjectNotExistsAsync('pump.error', {
+        type: 'state',
+        common: {
+            name: 'Pumpenfehler',
+            type: 'boolean',
+            role: 'indicator.error',
+            read: true,
+            write: true, // manuell quittierbar
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.error', { val: false, ack: true });
+
+    // Aktuelle Leistung der Pumpe (W)
+    await adapter.setObjectNotExistsAsync('pump.current_power', {
+        type: 'state',
+        common: {
+            name: 'Aktuelle Leistung der Pumpe',
+            type: 'number',
+            role: 'value.power',
+            unit: 'W',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.current_power', { val: 0, ack: true });
+}
+
+module.exports = {
+    createPumpStates,
+};