iobroker.poolcontrol 0.2.2 → 0.3.1

package/lib/stateDefinitions/pumpStates.js

@@ -98,7 +98,7 @@ async function createPumpStates(adapter) {
     });
     await adapter.setStateAsync('pump.pump_switch', { val: false, ack: true });
 
-    // Pumpenmodus
+    // Pumpenmodus (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('pump.mode', {
         type: 'state',
         common: {
@@ -107,6 +107,7 @@ async function createPumpStates(adapter) {
             role: 'state',
             read: true,
             write: true,
+            persist: true, // NEU: dauerhaft speichern
             states: {
                 auto: 'Automatik',
                 manual: 'Manuell',
@@ -116,9 +117,14 @@ async function createPumpStates(adapter) {
         },
         native: {},
     });
-    await adapter.setStateAsync('pump.mode', { val: 'auto', ack: true });
 
-    // Sicherheitslogik im manuellen Modus
+    // Prüfen, ob bereits ein Wert vorhanden ist
+    const existingPumpMode = await adapter.getStateAsync('pump.mode');
+    if (existingPumpMode === null || existingPumpMode.val === null || existingPumpMode.val === undefined) {
+        await adapter.setStateAsync('pump.mode', { val: 'auto', ack: true });
+    }
+
+    // Sicherheitslogik im manuellen Modus (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('pump.manual_safety_enabled', {
         type: 'state',
         common: {
@@ -127,13 +133,19 @@ async function createPumpStates(adapter) {
             role: 'switch',
             read: true,
             write: true,
+            persist: true, // NEU: dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('pump.manual_safety_enabled', {
-        val: adapter.config.manual_safety_enabled ?? true,
-        ack: true,
-    });
+
+    // Prüfen, ob bereits ein persistierter Wert vorhanden ist
+    const existingSafety = await adapter.getStateAsync('pump.manual_safety_enabled');
+    if (existingSafety === null || existingSafety.val === null || existingSafety.val === undefined) {
+        await adapter.setStateAsync('pump.manual_safety_enabled', {
+            val: adapter.config.manual_safety_enabled ?? true,
+            ack: true,
+        });
+    }
 
     // Pumpenstatus (Text)
     await adapter.setObjectNotExistsAsync('pump.status', {
@@ -196,6 +208,20 @@ async function createPumpStates(adapter) {
         native: {},
     });
     await adapter.setStateAsync('pump.current_power', { val: 0, ack: true });
+
+    await adapter.setObjectNotExistsAsync('pump.reason', {
+        type: 'state',
+        common: {
+            name: 'Grund für aktuellen Pumpenstatus',
+            desc: 'Wird intern verwendet, um den Grund des aktuellen Pumpenstatus zu speichern (z. B. Rückspülen, Wartung, Nachpumpen)',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.reason', { val: '', ack: true });
 }
 
 module.exports = {

package/lib/stateDefinitions/pumpStates2.js

@@ -0,0 +1,125 @@
+'use strict';
+
+/**
+ * pumpStates2.js
+ * ----------------------------------------------------------
+ * Legt die erweiterten States für Pumpen-Livewerte an.
+ *
+ * Diese Datei ergänzt die bestehenden pumpStates.js um
+ * reelle Durchflussberechnung und Leistungsdaten.
+ *
+ * Ordnerstruktur:
+ * pump.live.*
+ *  ├── current_power_w      (W)   - aktuelle Leistung
+ *  ├── flow_current_lh      (L/h) - reell berechneter Durchfluss
+ *  ├── flow_percent         (%)   - aktuelle Auslastung
+ *  ├── last_flow_lh         (L/h) - letzter bekannter Durchfluss
+ *
+ * Alle States sind persistent und bleiben über Updates erhalten.
+ * ----------------------------------------------------------
+ * Version: 1.0.0
+ */
+
+/**
+ * Erstellt die erweiterten Pumpen-Live-States.
+ *
+ * @param {import("iobroker").Adapter} adapter - Aktive ioBroker Adapterinstanz
+ * @returns {Promise<void>}
+ */
+async function createPumpStates2(adapter) {
+    // ------------------------------------------------------
+    // Root-Kanal: pump.live
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live', {
+        type: 'channel',
+        common: {
+            name: 'Pumpen-Livewerte (aktuelle Betriebsdaten)',
+        },
+        native: {},
+    });
+
+    // ------------------------------------------------------
+    // Aktuelle Leistung (W)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live.current_power_w', {
+        type: 'state',
+        common: {
+            name: 'Aktuelle elektrische Leistung',
+            desc: 'Momentane Leistungsaufnahme der Pumpe (Watt)',
+            type: 'number',
+            role: 'value.power',
+            unit: 'W',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.live.current_power_w', { val: 0, ack: true });
+
+    // ------------------------------------------------------
+    // Reell berechneter Durchfluss (L/h)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live.flow_current_lh', {
+        type: 'state',
+        common: {
+            name: 'Aktueller reeller Durchfluss',
+            desc: 'Berechnete Umwälzleistung basierend auf aktueller Leistung',
+            type: 'number',
+            role: 'value.flow',
+            unit: 'l/h',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.live.flow_current_lh', { val: 0, ack: true });
+
+    // ------------------------------------------------------
+    // Prozentuale Auslastung (%)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live.flow_percent', {
+        type: 'state',
+        common: {
+            name: 'Aktuelle Pumpenauslastung (%)',
+            desc: 'Aktuelle Pumpenleistung in Prozent der maximalen Leistung',
+            type: 'number',
+            role: 'value.percent',
+            unit: '%',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.live.flow_percent', { val: 0, ack: true });
+
+    // ------------------------------------------------------
+    // Letzter bekannter Durchfluss (L/h)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live.last_flow_lh', {
+        type: 'state',
+        common: {
+            name: 'Letzter bekannter Durchfluss',
+            desc: 'Speichert den letzten berechneten Durchflusswert vor Pumpenstopp',
+            type: 'number',
+            role: 'value.flow',
+            unit: 'l/h',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.live.last_flow_lh', { val: 0, ack: true });
+
+    // ------------------------------------------------------
+    // Abschluss-Logeintrag
+    // ------------------------------------------------------
+    adapter.log.debug('[pumpStates2] Live-State-Definitionen erstellt oder geprüft.');
+}
+
+module.exports = {
+    createPumpStates2,
+};

package/lib/stateDefinitions/pumpStates3.js

@@ -0,0 +1,252 @@
+'use strict';
+
+/**
+ * pumpStates3.js
+ * ----------------------------------------------------------
+ * Legt die States für den Lern- und Analysebereich der Pumpe an.
+ *
+ * Ordner: pump.learning
+ * Zweck: Speicherung von Durchschnitts- und Normalwerten
+ *        zur Erkennung des typischen Pumpenverhaltens.
+ *
+ * Wird durch pumpHelper3.js verwaltet.
+ * Alle Werte sind persistent (persist: true).
+ * ----------------------------------------------------------
+ * Version: 1.0.1
+ */
+
+/**
+ * Erstellt die Lernfeld-States für Pumpenanalyse.
+ *
+ * @param {import('iobroker').Adapter} adapter – Aktive ioBroker Adapterinstanz
+ */
+async function createPumpStates3(adapter) {
+    // ------------------------------------------------------
+    // Root-Kanal: pump.learning
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.learning', {
+        type: 'channel',
+        common: {
+            name: 'Pumpen-Lernwerte (Analyse & Normalbereich)',
+        },
+        native: {},
+    });
+
+    // ------------------------------------------------------
+    // Durchschnittliche Leistungsaufnahme (W)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.learning.learned_avg_power_w', {
+        type: 'state',
+        common: {
+            name: 'Erlernter Durchschnitt der Leistungsaufnahme',
+            desc: 'Durchschnittliche Leistungsaufnahme der Pumpe über alle Lernzyklen (W)',
+            type: 'number',
+            role: 'value.power',
+            unit: 'W',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingPower = await adapter.getStateAsync('pump.learning.learned_avg_power_w');
+    if (existingPower === null || existingPower.val === null || existingPower.val === undefined) {
+        await adapter.setStateAsync('pump.learning.learned_avg_power_w', { val: 0, ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Durchschnittlicher Durchfluss (L/h)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.learning.learned_avg_flow_lh', {
+        type: 'state',
+        common: {
+            name: 'Erlernter Durchschnitt des Durchflusses',
+            desc: 'Durchschnittlicher reeller Durchfluss über alle Lernzyklen (L/h)',
+            type: 'number',
+            role: 'value.flow',
+            unit: 'l/h',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingFlow = await adapter.getStateAsync('pump.learning.learned_avg_flow_lh');
+    if (existingFlow === null || existingFlow.val === null || existingFlow.val === undefined) {
+        await adapter.setStateAsync('pump.learning.learned_avg_flow_lh', { val: 0, ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Normalbereich Leistung – Untere / Obere Grenze
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.learning.normal_range_power_low', {
+        type: 'state',
+        common: {
+            name: 'Leistungs-Normalbereich (untere Grenze)',
+            desc: 'Untergrenze des normalen Leistungsbereichs (W)',
+            type: 'number',
+            role: 'value.min',
+            unit: 'W',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingPowerLow = await adapter.getStateAsync('pump.learning.normal_range_power_low');
+    if (existingPowerLow === null || existingPowerLow.val === null || existingPowerLow.val === undefined) {
+        await adapter.setStateAsync('pump.learning.normal_range_power_low', { val: 0, ack: true });
+    }
+
+    await adapter.setObjectNotExistsAsync('pump.learning.normal_range_power_high', {
+        type: 'state',
+        common: {
+            name: 'Leistungs-Normalbereich (obere Grenze)',
+            desc: 'Obergrenze des normalen Leistungsbereichs (W)',
+            type: 'number',
+            role: 'value.max',
+            unit: 'W',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingPowerHigh = await adapter.getStateAsync('pump.learning.normal_range_power_high');
+    if (existingPowerHigh === null || existingPowerHigh.val === null || existingPowerHigh.val === undefined) {
+        await adapter.setStateAsync('pump.learning.normal_range_power_high', { val: 0, ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Normalbereich Durchfluss – Untere / Obere Grenze
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.learning.normal_range_flow_low', {
+        type: 'state',
+        common: {
+            name: 'Durchfluss-Normalbereich (untere Grenze)',
+            desc: 'Untergrenze des normalen Durchflussbereichs (L/h)',
+            type: 'number',
+            role: 'value.min',
+            unit: 'l/h',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingFlowLow = await adapter.getStateAsync('pump.learning.normal_range_flow_low');
+    if (existingFlowLow === null || existingFlowLow.val === null || existingFlowLow.val === undefined) {
+        await adapter.setStateAsync('pump.learning.normal_range_flow_low', { val: 0, ack: true });
+    }
+
+    await adapter.setObjectNotExistsAsync('pump.learning.normal_range_flow_high', {
+        type: 'state',
+        common: {
+            name: 'Durchfluss-Normalbereich (obere Grenze)',
+            desc: 'Obergrenze des normalen Durchflussbereichs (L/h)',
+            type: 'number',
+            role: 'value.max',
+            unit: 'l/h',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingFlowHigh = await adapter.getStateAsync('pump.learning.normal_range_flow_high');
+    if (existingFlowHigh === null || existingFlowHigh.val === null || existingFlowHigh.val === undefined) {
+        await adapter.setStateAsync('pump.learning.normal_range_flow_high', { val: 0, ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Abweichungen (Prozent)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.learning.deviation_power_percent', {
+        type: 'state',
+        common: {
+            name: 'Leistungsabweichung (%)',
+            desc: 'Aktuelle Abweichung der Leistungsaufnahme vom Durchschnittswert',
+            type: 'number',
+            role: 'value.percent',
+            unit: '%',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingDevPower = await adapter.getStateAsync('pump.learning.deviation_power_percent');
+    if (existingDevPower === null || existingDevPower.val === null || existingDevPower.val === undefined) {
+        await adapter.setStateAsync('pump.learning.deviation_power_percent', { val: 0, ack: true });
+    }
+
+    await adapter.setObjectNotExistsAsync('pump.learning.deviation_flow_percent', {
+        type: 'state',
+        common: {
+            name: 'Durchflussabweichung (%)',
+            desc: 'Aktuelle Abweichung des Durchflusses vom Durchschnittswert',
+            type: 'number',
+            role: 'value.percent',
+            unit: '%',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingDevFlow = await adapter.getStateAsync('pump.learning.deviation_flow_percent');
+    if (existingDevFlow === null || existingDevFlow.val === null || existingDevFlow.val === undefined) {
+        await adapter.setStateAsync('pump.learning.deviation_flow_percent', { val: 0, ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Textbewertung (Status)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.learning.status_text', {
+        type: 'state',
+        common: {
+            name: 'Statusbewertung',
+            desc: 'Textbasierte Bewertung des aktuellen Pumpenverhaltens (z. B. "im Normalbereich", "auffällig niedrig")',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingStatus = await adapter.getStateAsync('pump.learning.status_text');
+    if (existingStatus === null || existingStatus.val === null || existingStatus.val === undefined) {
+        await adapter.setStateAsync('pump.learning.status_text', { val: '', ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Anzahl Lernzyklen
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.learning.learning_cycles_total', {
+        type: 'state',
+        common: {
+            name: 'Gesamtzahl der Lernzyklen',
+            desc: 'Anzahl der Pumpenläufe, die in die Lernberechnung eingeflossen sind',
+            type: 'number',
+            role: 'value',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingCycles = await adapter.getStateAsync('pump.learning.learning_cycles_total');
+    if (existingCycles === null || existingCycles.val === null || existingCycles.val === undefined) {
+        await adapter.setStateAsync('pump.learning.learning_cycles_total', { val: 0, ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Log-Eintrag
+    // ------------------------------------------------------
+    adapter.log.debug('[pumpStates3] Lern-States erstellt oder geprüft.');
+}
+
+module.exports = {
+    createPumpStates3,
+};

package/lib/stateDefinitions/solarStates.js

@@ -14,7 +14,7 @@
  * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
  */
 async function createSolarStates(adapter) {
-    // Solarsteuerung aktiv
+    // Solarsteuerung aktiv (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('solar.solar_control_active', {
         type: 'state',
         common: {
@@ -23,15 +23,19 @@ async function createSolarStates(adapter) {
             role: 'switch',
             read: true,
             write: true,
+            persist: true, // dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('solar.solar_control_active', {
-        val: adapter.config.solar_control_active,
-        ack: true,
-    });
+    const existingSolarActive = await adapter.getStateAsync('solar.solar_control_active');
+    if (existingSolarActive === null || existingSolarActive.val === null || existingSolarActive.val === undefined) {
+        await adapter.setStateAsync('solar.solar_control_active', {
+            val: adapter.config.solar_control_active,
+            ack: true,
+        });
+    }
 
-    // Hysterese aktiv
+    // Hysterese aktiv (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('solar.hysteresis_active', {
         type: 'state',
         common: {
@@ -40,15 +44,19 @@ async function createSolarStates(adapter) {
             role: 'switch',
             read: true,
             write: true,
+            persist: true, // dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('solar.hysteresis_active', {
-        val: adapter.config.solar_hysteresis_active,
-        ack: true,
-    });
+    const existingHyst = await adapter.getStateAsync('solar.hysteresis_active');
+    if (existingHyst === null || existingHyst.val === null || existingHyst.val === undefined) {
+        await adapter.setStateAsync('solar.hysteresis_active', {
+            val: adapter.config.solar_hysteresis_active,
+            ack: true,
+        });
+    }
 
-    // Einschaltgrenze
+    // Einschaltgrenze (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('solar.temp_on', {
         type: 'state',
         common: {
@@ -58,15 +66,19 @@ async function createSolarStates(adapter) {
             unit: '°C',
             read: true,
             write: true,
+            persist: true, // dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('solar.temp_on', {
-        val: adapter.config.solar_temp_on,
-        ack: true,
-    });
+    const existingTempOn = await adapter.getStateAsync('solar.temp_on');
+    if (existingTempOn === null || existingTempOn.val === null || existingTempOn.val === undefined) {
+        await adapter.setStateAsync('solar.temp_on', {
+            val: adapter.config.solar_temp_on,
+            ack: true,
+        });
+    }
 
-    // Ausschaltgrenze
+    // Ausschaltgrenze (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('solar.temp_off', {
         type: 'state',
         common: {
@@ -76,13 +88,17 @@ async function createSolarStates(adapter) {
             unit: '°C',
             read: true,
             write: true,
+            persist: true, // dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('solar.temp_off', {
-        val: adapter.config.solar_temp_off,
-        ack: true,
-    });
+    const existingTempOff = await adapter.getStateAsync('solar.temp_off');
+    if (existingTempOff === null || existingTempOff.val === null || existingTempOff.val === undefined) {
+        await adapter.setStateAsync('solar.temp_off', {
+            val: adapter.config.solar_temp_off,
+            ack: true,
+        });
+    }
 
     // Warnung Kollektortemperatur aktiv
     await adapter.setObjectNotExistsAsync('solar.collector_warning', {
@@ -101,7 +117,7 @@ async function createSolarStates(adapter) {
         ack: true,
     });
 
-    // NEU: Warnlogik aktivieren
+    // NEU: Warnlogik aktivieren (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('solar.warn_active', {
         type: 'state',
         common: {
@@ -110,12 +126,19 @@ async function createSolarStates(adapter) {
             role: 'switch',
             read: true,
             write: true,
+            persist: true, // dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('solar.warn_active', { val: false, ack: true });
 
-    // NEU: Warnschwelle (°C)
+    // Prüfen, ob bereits ein persistierter Wert existiert
+    const existingWarnActive = await adapter.getStateAsync('solar.warn_active');
+    if (existingWarnActive === null || existingWarnActive.val === null || existingWarnActive.val === undefined) {
+        // Nur bei erstmaligem Anlegen auf false setzen
+        await adapter.setStateAsync('solar.warn_active', { val: false, ack: true });
+    }
+
+    // NEU: Warnschwelle (°C, mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('solar.warn_temp', {
         type: 'state',
         common: {
@@ -125,12 +148,16 @@ async function createSolarStates(adapter) {
             unit: '°C',
             read: true,
             write: true,
+            persist: true, // dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('solar.warn_temp', { val: 80, ack: true });
+    const existingWarnTemp = await adapter.getStateAsync('solar.warn_temp');
+    if (existingWarnTemp === null || existingWarnTemp.val === null || existingWarnTemp.val === undefined) {
+        await adapter.setStateAsync('solar.warn_temp', { val: 80, ack: true });
+    }
 
-    // NEU: Sprachausgabe bei Warnung
+    // NEU: Sprachausgabe bei Warnung (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('solar.warn_speech', {
         type: 'state',
         common: {
@@ -139,10 +166,14 @@ async function createSolarStates(adapter) {
             role: 'switch',
             read: true,
             write: true,
+            persist: true, // dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('solar.warn_speech', { val: true, ack: true });
+    const existingWarnSpeech = await adapter.getStateAsync('solar.warn_speech');
+    if (existingWarnSpeech === null || existingWarnSpeech.val === null || existingWarnSpeech.val === undefined) {
+        await adapter.setStateAsync('solar.warn_speech', { val: true, ack: true });
+    }
 }
 
 module.exports = {