iobroker.poolcontrol 0.2.2 → 0.3.0

package/lib/stateDefinitions/pumpStates3.js

@@ -0,0 +1,222 @@
+'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.0
+ */
+
+/**
+ * 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: {},
+    });
+    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: {},
+    });
+    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: {},
+    });
+    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: {},
+    });
+    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: {},
+    });
+    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: {},
+    });
+    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: {},
+    });
+    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: {},
+    });
+    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: {},
+    });
+    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: {},
+    });
+    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 = {

package/lib/stateDefinitions/speechStates.js

@@ -18,7 +18,7 @@ async function createSpeechStates(adapter) {
         native: {},
     });
 
-    // Sprachausgaben global aktiv
+    // Sprachausgaben global aktiv (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('speech.active', {
         type: 'state',
         common: {
@@ -27,13 +27,19 @@ async function createSpeechStates(adapter) {
             role: 'switch',
             read: true,
             write: true,
+            persist: true, // dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('speech.active', {
-        val: adapter.config.speech_active ?? false,
-        ack: true,
-    });
+
+    // Prüfen, ob bereits ein persistierter Wert existiert
+    const existingSpeechActive = await adapter.getStateAsync('speech.active');
+    if (existingSpeechActive === null || existingSpeechActive.val === null || existingSpeechActive.val === undefined) {
+        await adapter.setStateAsync('speech.active', {
+            val: adapter.config.speech_active ?? false,
+            ack: true,
+        });
+    }
 
     // Letzter gesprochener Text
     await adapter.setObjectNotExistsAsync('speech.last_text', {
@@ -107,8 +113,9 @@ async function createSpeechStates(adapter) {
             type: 'boolean',
             role: 'indicator',
             read: true,
-            write: true,
+            write: false,
             hidden: true, // unsichtbar im Admin
+            dontShow: true,
         },
         native: {},
     });
@@ -120,8 +127,9 @@ async function createSpeechStates(adapter) {
             type: 'boolean',
             role: 'indicator',
             read: true,
-            write: true,
+            write: false,
             hidden: true, // unsichtbar im Admin
+            dontShow: true,
         },
         native: {},
     });
@@ -133,11 +141,29 @@ async function createSpeechStates(adapter) {
             type: 'boolean',
             role: 'indicator',
             read: true,
-            write: true,
+            write: false,
             hidden: true, // unsichtbar im Admin
+            dontShow: true,
         },
         native: {},
     });
+
+    // --- Sicherstellen, dass bestehende Installationen nachträglich korrigiert werden ---
+    const hiddenStates = ['speech.solar_active', 'speech.time_active', 'speech.frost_active'];
+    for (const id of hiddenStates) {
+        try {
+            await adapter.extendObjectAsync(id, {
+                common: {
+                    hidden: true,
+                    dontShow: true,
+                    write: false,
+                },
+            });
+        } catch (err) {
+            adapter.log.warn(`[speechStates] Konnte hidden-Flag für ${id} nicht setzen: ${err.message}`);
+        }
+    }
+    adapter.log.debug('[speechStates] Hidden-Flags für Solar/Time/Frost geprüft und aktualisiert');
 }
 
 module.exports = {

package/lib/stateDefinitions/statusStates.js

@@ -169,7 +169,7 @@ async function createStatusStates(adapter) {
     });
     await adapter.setStateAsync('status.system_warning_text', { val: '', ack: true });
 
-    // Saisonstatus
+    // Saisonstatus (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('status.season_active', {
         type: 'state',
         common: {
@@ -178,10 +178,16 @@ async function createStatusStates(adapter) {
             role: 'switch',
             read: true,
             write: true,
+            persist: true, // dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('status.season_active', { val: false, ack: true });
+
+    // Prüfen, ob bereits ein persistierter Wert existiert
+    const existingSeasonActive = await adapter.getStateAsync('status.season_active');
+    if (existingSeasonActive === null || existingSeasonActive.val === null || existingSeasonActive.val === undefined) {
+        await adapter.setStateAsync('status.season_active', { val: false, ack: true });
+    }
 }
 
 module.exports = {

package/main.js

@@ -9,6 +9,8 @@ const temperatureHelper = require('./lib/helpers/temperatureHelper');
 const timeHelper = require('./lib/helpers/timeHelper');
 const runtimeHelper = require('./lib/helpers/runtimeHelper');
 const pumpHelper = require('./lib/helpers/pumpHelper');
+const pumpHelper2 = require('./lib/helpers/pumpHelper2');
+const pumpHelper3 = require('./lib/helpers/pumpHelper3');
 const speechHelper = require('./lib/helpers/speechHelper');
 const consumptionHelper = require('./lib/helpers/consumptionHelper');
 const solarHelper = require('./lib/helpers/solarHelper');
@@ -18,8 +20,11 @@ const controlHelper = require('./lib/helpers/controlHelper');
 const controlHelper2 = require('./lib/helpers/controlHelper2');
 const debugLogHelper = require('./lib/helpers/debugLogHelper');
 const speechTextHelper = require('./lib/helpers/speechTextHelper');
+const migrationHelper = require('./lib/helpers/migrationHelper');
 const { createTemperatureStates } = require('./lib/stateDefinitions/temperatureStates');
 const { createPumpStates } = require('./lib/stateDefinitions/pumpStates');
+const { createPumpStates2 } = require('./lib/stateDefinitions/pumpStates2');
+const { createPumpStates3 } = require('./lib/stateDefinitions/pumpStates3');
 const { createSolarStates } = require('./lib/stateDefinitions/solarStates');
 const { createGeneralStates } = require('./lib/stateDefinitions/generalStates');
 const { createTimeStates } = require('./lib/stateDefinitions/timeStates');
@@ -49,6 +54,8 @@ class Poolcontrol extends utils.Adapter {
 
         // --- Pumpe ---
         await createPumpStates(this);
+        await createPumpStates2(this);
+        await createPumpStates3(this);
 
         // --- Temperaturverwaltung ---
         await createTemperatureStates(this);
@@ -83,11 +90,16 @@ class Poolcontrol extends utils.Adapter {
         // --- DebugLog Staets ---
         await createDebugLogStates(this);
 
+        // --- Migration Helper zuletzt starten ---
+        await migrationHelper.init(this);
+
         // --- Helper starten ---
         temperatureHelper.init(this);
         timeHelper.init(this);
         runtimeHelper.init(this);
         pumpHelper.init(this);
+        pumpHelper2.init(this);
+        pumpHelper3.init(this);
         speechHelper.init(this);
         consumptionHelper.init(this);
         solarHelper.init(this);
@@ -113,6 +125,12 @@ class Poolcontrol extends utils.Adapter {
             if (pumpHelper.cleanup) {
                 pumpHelper.cleanup();
             }
+            if (pumpHelper2.cleanup) {
+                pumpHelper2.cleanup();
+            }
+            if (pumpHelper3.cleanup) {
+                pumpHelper3.cleanup();
+            }
             if (speechHelper.cleanup) {
                 speechHelper.cleanup();
             }
@@ -173,6 +191,17 @@ class Poolcontrol extends utils.Adapter {
         } catch (e) {
             this.log.warn(`[pumpHelper] Fehler in handleStateChange: ${e.message}`);
         }
+        try {
+            pumpHelper2.handleStateChange(id, state);
+        } catch (e) {
+            this.log.warn(`[pumpHelper2] Fehler in handleStateChange: ${e.message}`);
+        }
+        try {
+            pumpHelper3.handleStateChange(id, state);
+        } catch (e) {
+            this.log.warn(`[pumpHelper3] Fehler in handleStateChange: ${e.message}`);
+        }
+
         try {
             speechHelper.handleStateChange(id, state);
         } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.poolcontrol",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Steuerung & Automatisierung für den Pool (Pumpe, Heizung, Ventile, Sensoren).",
   "author": "DasBo1975 <dasbo1975@outlook.de>",
   "homepage": "https://github.com/DasBo1975/ioBroker.poolcontrol",