iobroker.poolcontrol 0.0.7

package/lib/stateDefinitions/runtimeStates.js

@@ -0,0 +1,113 @@
+'use strict';
+
+/**
+ * Legt alle States für Laufzeit- und Umwälzwerte an:
+ * - runtime.total
+ * - runtime.today
+ * - runtime.formatted
+ * - circulation.daily_total
+ * - circulation.daily_required
+ * - circulation.daily_remaining
+ *
+ * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createRuntimeStates(adapter) {
+    // --- Kanal runtime ---
+    await adapter.setObjectNotExistsAsync('runtime', {
+        type: 'channel',
+        common: { name: 'Pumpenlaufzeit' },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('runtime.total', {
+        type: 'state',
+        common: {
+            name: 'Gesamtlaufzeit',
+            type: 'number',
+            role: 'value.time',
+            unit: 's',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('runtime.today', {
+        type: 'state',
+        common: {
+            name: 'Tageslaufzeit',
+            type: 'number',
+            role: 'value.time',
+            unit: 's',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('runtime.formatted', {
+        type: 'state',
+        common: {
+            name: 'Formatierte Laufzeit heute',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    // --- Kanal circulation ---
+    await adapter.setObjectNotExistsAsync('circulation', {
+        type: 'channel',
+        common: { name: 'Umwälzung' },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('circulation.daily_total', {
+        type: 'state',
+        common: {
+            name: 'Tägliche Umwälzmenge',
+            type: 'number',
+            role: 'value.volume',
+            unit: 'l',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('circulation.daily_required', {
+        type: 'state',
+        common: {
+            name: 'Erforderliche tägliche Umwälzmenge',
+            type: 'number',
+            role: 'value.volume',
+            unit: 'l',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('circulation.daily_required', {
+        val: 0,
+        ack: true,
+    });
+
+    await adapter.setObjectNotExistsAsync('circulation.daily_remaining', {
+        type: 'state',
+        common: {
+            name: 'Verbleibende Umwälzmenge heute',
+            type: 'number',
+            role: 'value.volume',
+            unit: 'l',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+}
+
+module.exports = {
+    createRuntimeStates,
+};

package/lib/stateDefinitions/solarStates.js

@@ -0,0 +1,150 @@
+'use strict';
+
+/**
+ * Legt alle States für die Solarverwaltung an:
+ * - solar.solar_control_active
+ * - solar.hysteresis_active
+ * - solar.temp_on (Einschaltgrenze)
+ * - solar.temp_off (Ausschaltgrenze)
+ * - solar.collector_warning (Warnung aktiv)
+ * - solar.warn_active (Warnlogik aktivieren/deaktivieren)
+ * - solar.warn_temp (Warnschwelle °C)
+ * - solar.warn_speech (Sprachausgabe bei Warnung)
+ *
+ * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createSolarStates(adapter) {
+    // Solarsteuerung aktiv
+    await adapter.setObjectNotExistsAsync('solar.solar_control_active', {
+        type: 'state',
+        common: {
+            name: 'Solarsteuerung aktivieren',
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('solar.solar_control_active', {
+        val: adapter.config.solar_control_active,
+        ack: true,
+    });
+
+    // Hysterese aktiv
+    await adapter.setObjectNotExistsAsync('solar.hysteresis_active', {
+        type: 'state',
+        common: {
+            name: 'Regelung mit Hysterese verwenden',
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('solar.hysteresis_active', {
+        val: adapter.config.solar_hysteresis_active,
+        ack: true,
+    });
+
+    // Einschaltgrenze
+    await adapter.setObjectNotExistsAsync('solar.temp_on', {
+        type: 'state',
+        common: {
+            name: 'Kollektortemperatur Einschaltgrenze (°C)',
+            type: 'number',
+            role: 'value.temperature',
+            unit: '°C',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('solar.temp_on', {
+        val: adapter.config.solar_temp_on,
+        ack: true,
+    });
+
+    // Ausschaltgrenze
+    await adapter.setObjectNotExistsAsync('solar.temp_off', {
+        type: 'state',
+        common: {
+            name: 'Kollektortemperatur Ausschaltgrenze (°C)',
+            type: 'number',
+            role: 'value.temperature',
+            unit: '°C',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('solar.temp_off', {
+        val: adapter.config.solar_temp_off,
+        ack: true,
+    });
+
+    // Warnung Kollektortemperatur aktiv
+    await adapter.setObjectNotExistsAsync('solar.collector_warning', {
+        type: 'state',
+        common: {
+            name: 'Kollektortemperatur-Warnung aktiv',
+            type: 'boolean',
+            role: 'indicator.error',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('solar.collector_warning', {
+        val: false,
+        ack: true,
+    });
+
+    // NEU: Warnlogik aktivieren
+    await adapter.setObjectNotExistsAsync('solar.warn_active', {
+        type: 'state',
+        common: {
+            name: 'Warnung Kollektortemperatur aktivieren',
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('solar.warn_active', { val: false, ack: true });
+
+    // NEU: Warnschwelle (°C)
+    await adapter.setObjectNotExistsAsync('solar.warn_temp', {
+        type: 'state',
+        common: {
+            name: 'Warnschwelle Kollektortemperatur (°C)',
+            type: 'number',
+            role: 'value.temperature',
+            unit: '°C',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('solar.warn_temp', { val: 80, ack: true });
+
+    // NEU: Sprachausgabe bei Warnung
+    await adapter.setObjectNotExistsAsync('solar.warn_speech', {
+        type: 'state',
+        common: {
+            name: 'Sprachausgabe bei Warnung aktivieren',
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('solar.warn_speech', { val: true, ack: true });
+}
+
+module.exports = {
+    createSolarStates,
+};

package/lib/stateDefinitions/speechStates.js

@@ -0,0 +1,104 @@
+'use strict';
+
+/**
+ * Legt alle States für Sprachausgaben an:
+ * - speech.active
+ * - speech.last_text
+ * - speech.start_text, speech.end_text
+ * - speech.texts.[sensor] (Temperaturtexte)
+ *
+ * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createSpeechStates(adapter) {
+    // Root-Kanal
+    await adapter.setObjectNotExistsAsync('speech', {
+        type: 'channel',
+        common: { name: 'Sprachausgaben' },
+        native: {},
+    });
+
+    // Sprachausgaben global aktiv
+    await adapter.setObjectNotExistsAsync('speech.active', {
+        type: 'state',
+        common: {
+            name: 'Sprachausgaben aktiv',
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('speech.active', {
+        val: adapter.config.speech_active ?? false,
+        ack: true,
+    });
+
+    // Letzter gesprochener Text
+    await adapter.setObjectNotExistsAsync('speech.last_text', {
+        type: 'state',
+        common: {
+            name: 'Zuletzt gesprochener Text',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('speech.last_text', { val: '', ack: true });
+
+    // Start-/Endtexte
+    await adapter.setObjectNotExistsAsync('speech.start_text', {
+        type: 'state',
+        common: {
+            name: 'Starttext',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('speech.start_text', {
+        val: 'Die Poolpumpe wurde gestartet.',
+        ack: true,
+    });
+
+    await adapter.setObjectNotExistsAsync('speech.end_text', {
+        type: 'state',
+        common: {
+            name: 'Endtext',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('speech.end_text', {
+        val: 'Die Poolpumpe wurde gestoppt.',
+        ack: true,
+    });
+
+    // Temperaturtexte (optional)
+    const sensors = ['surface', 'ground', 'flow', 'return', 'collector', 'outside'];
+    for (const key of sensors) {
+        await adapter.setObjectNotExistsAsync(`speech.texts.${key}`, {
+            type: 'state',
+            common: {
+                name: `Textausgabe Sensor ${key}`,
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: true,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync(`speech.texts.${key}`, { val: '', ack: true });
+    }
+}
+
+module.exports = {
+    createSpeechStates,
+};

package/lib/stateDefinitions/temperatureStates.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * Temperature States – vollständig gemäß jsonConfig (Temperaturverwaltung)
+ *
+ * Für jeden Sensor (surface, ground, flow, return, collector, outside):
+ *  - temperature.<sensor>_temp_active    (boolean, write: true)   -> Ja/Nein (aus UI)
+ *  - temperature.<sensor>_temp_sensor    (string,  write: false)  -> Objekt-ID (aus UI)
+ *  - temperature.<sensor>.current        (number, °C)
+ *  - temperature.<sensor>.min_today      (number, °C)
+ *  - temperature.<sensor>.max_today      (number, °C)
+ *  - temperature.<sensor>.delta_per_hour (number, °C/h)
+ *
+ * Zusätzlich:
+ *  - temperature.delta.collector_outside
+ *  - temperature.delta.surface_ground
+ *  - temperature.delta.flow_return
+ *
+ * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createTemperatureStates(adapter) {
+    // Root-Kanal (robustheitshalber explizit anlegen)
+    await adapter.setObjectNotExistsAsync('temperature', {
+        type: 'channel',
+        common: { name: 'Temperaturverwaltung' },
+        native: {},
+    });
+
+    // Kanal für Deltas
+    await adapter.setObjectNotExistsAsync('temperature.delta', {
+        type: 'channel',
+        common: { name: 'Temperatur-Differenzen' },
+        native: {},
+    });
+
+    // Hilfsfunktion: Mirror-States (Active + Sensor-ID) + Messkanal anlegen
+    async function createSensorSet(sensorKey, label) {
+        // 1) Mirror-States der Instanz-Config
+        await adapter.setObjectNotExistsAsync(`temperature.${sensorKey}_temp_active`, {
+            type: 'state',
+            common: {
+                name: `Sensor ${label} verwenden`,
+                type: 'boolean',
+                role: 'switch',
+                read: true,
+                write: true, // Ja/Nein per State toggelbar
+            },
+            native: {},
+        });
+        await adapter.setStateAsync(`temperature.${sensorKey}_temp_active`, {
+            val: !!adapter.config[`${sensorKey}_temp_active`],
+            ack: true,
+        });
+
+        await adapter.setObjectNotExistsAsync(`temperature.${sensorKey}_temp_sensor`, {
+            type: 'state',
+            common: {
+                name: `Objekt-ID Sensor ${label}`,
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false, // nur Spiegel der Config
+            },
+            native: {},
+        });
+        await adapter.setStateAsync(`temperature.${sensorKey}_temp_sensor`, {
+            val: adapter.config[`${sensorKey}_temp_sensor`] || '',
+            ack: true,
+        });
+
+        // 2) Messkanal + Werte-States
+        await adapter.setObjectNotExistsAsync(`temperature.${sensorKey}`, {
+            type: 'channel',
+            common: { name: `Sensor ${label}` },
+            native: {},
+        });
+
+        await adapter.setObjectNotExistsAsync(`temperature.${sensorKey}.current`, {
+            type: 'state',
+            common: {
+                name: `Aktueller Wert Sensor ${label}`,
+                type: 'number',
+                role: 'value.temperature',
+                unit: '°C',
+                read: true,
+                write: false,
+            },
+            native: {},
+        });
+
+        await adapter.setObjectNotExistsAsync(`temperature.${sensorKey}.min_today`, {
+            type: 'state',
+            common: {
+                name: `Tagesminimum Sensor ${label}`,
+                type: 'number',
+                role: 'value.temperature',
+                unit: '°C',
+                read: true,
+                write: false,
+            },
+            native: {},
+        });
+
+        await adapter.setObjectNotExistsAsync(`temperature.${sensorKey}.max_today`, {
+            type: 'state',
+            common: {
+                name: `Tagesmaximum Sensor ${label}`,
+                type: 'number',
+                role: 'value.temperature',
+                unit: '°C',
+                read: true,
+                write: false,
+            },
+            native: {},
+        });
+
+        await adapter.setObjectNotExistsAsync(`temperature.${sensorKey}.delta_per_hour`, {
+            type: 'state',
+            common: {
+                name: `Veränderung pro Stunde Sensor ${label}`,
+                type: 'number',
+                role: 'value.temperature',
+                unit: '°C/h',
+                read: true,
+                write: false,
+            },
+            native: {},
+        });
+    }
+
+    // Reihenfolge wie in der Instanz-Config (jsonConfig)
+    await createSensorSet('surface', 'Oberfläche');
+    await createSensorSet('ground', 'Grund');
+    await createSensorSet('flow', 'Vorlauf');
+    await createSensorSet('return', 'Rücklauf');
+    await createSensorSet('collector', 'Kollektor');
+    await createSensorSet('outside', 'Außentemperatur');
+
+    // Deltas zwischen Sensoren
+    await adapter.setObjectNotExistsAsync('temperature.delta.collector_outside', {
+        type: 'state',
+        common: {
+            name: 'Differenz Kollektor - Luft',
+            type: 'number',
+            role: 'value.temperature',
+            unit: '°C',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('temperature.delta.surface_ground', {
+        type: 'state',
+        common: {
+            name: 'Differenz Oberfläche - Grund',
+            type: 'number',
+            role: 'value.temperature',
+            unit: '°C',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('temperature.delta.flow_return', {
+        type: 'state',
+        common: {
+            name: 'Differenz Vorlauf - Rücklauf',
+            type: 'number',
+            role: 'value.temperature',
+            unit: '°C',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+}
+
+module.exports = {
+    createTemperatureStates,
+};

package/lib/stateDefinitions/timeStates.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Legt alle States für die Zeitsteuerung an:
+ * - time1_active, time1_start, time1_end, time1_day_mon ... time1_day_sun
+ * - time2_active, time2_start, time2_end, time2_day_mon ... time2_day_sun
+ * - time3_active, time3_start, time3_end, time3_day_mon ... time3_day_sun
+ *
+ * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createTimeStates(adapter) {
+    async function createTimeWindow(prefix, label) {
+        // Aktiv
+        await adapter.setObjectNotExistsAsync(`timecontrol.${prefix}_active`, {
+            type: 'state',
+            common: {
+                name: `Zeitfenster ${label} aktiv`,
+                type: 'boolean',
+                role: 'switch',
+                read: true,
+                write: true,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync(`timecontrol.${prefix}_active`, {
+            val: adapter.config[`${prefix}_active`],
+            ack: true,
+        });
+
+        // Startzeit
+        await adapter.setObjectNotExistsAsync(`timecontrol.${prefix}_start`, {
+            type: 'state',
+            common: {
+                name: `Zeitfenster ${label} Start (HH:MM)`,
+                type: 'string',
+                role: 'value.time',
+                read: true,
+                write: true,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync(`timecontrol.${prefix}_start`, {
+            val: adapter.config[`${prefix}_start`] || '00:00',
+            ack: true,
+        });
+
+        // Endzeit
+        await adapter.setObjectNotExistsAsync(`timecontrol.${prefix}_end`, {
+            type: 'state',
+            common: {
+                name: `Zeitfenster ${label} Ende (HH:MM)`,
+                type: 'string',
+                role: 'value.time',
+                read: true,
+                write: true,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync(`timecontrol.${prefix}_end`, {
+            val: adapter.config[`${prefix}_end`] || '00:00',
+            ack: true,
+        });
+
+        // Wochentage
+        const days = [
+            ['mon', 'Montag'],
+            ['tue', 'Dienstag'],
+            ['wed', 'Mittwoch'],
+            ['thu', 'Donnerstag'],
+            ['fri', 'Freitag'],
+            ['sat', 'Samstag'],
+            ['sun', 'Sonntag'],
+        ];
+
+        for (const [key, labelDay] of days) {
+            await adapter.setObjectNotExistsAsync(`timecontrol.${prefix}_day_${key}`, {
+                type: 'state',
+                common: {
+                    name: `Zeitfenster ${label} ${labelDay}`,
+                    type: 'boolean',
+                    role: 'switch',
+                    read: true,
+                    write: true,
+                },
+                native: {},
+            });
+            await adapter.setStateAsync(`timecontrol.${prefix}_day_${key}`, {
+                val: adapter.config[`${prefix}_day_${key}`],
+                ack: true,
+            });
+        }
+    }
+
+    // Zeitfenster 1 bis 3 anlegen
+    await createTimeWindow('time1', '1');
+    await createTimeWindow('time2', '2');
+    await createTimeWindow('time3', '3');
+}
+
+module.exports = {
+    createTimeStates,
+};