iobroker.poolcontrol 1.3.9 → 1.3.11

package/lib/stateDefinitions/photovoltaicInsightsStates.js

@@ -0,0 +1,444 @@
+'use strict';
+
+/**
+ * photovoltaicInsightsStates.js
+ * -----------------------------
+ * Erstellt die States für analytics.insights.photovoltaic.
+ *
+ * Block 1:
+ *   analytics.insights.photovoltaic.inputs.*
+ *
+ * Wichtig:
+ * - Nur Analyse-States, keine Steuerlogik
+ * - Aufbau analog zu solarInsightsStates.js
+ * - EN + DE direkt enthalten
+ * - Weitere Blöcke (calculation, results, debug) folgen später schrittweise
+ */
+
+/**
+ * @param {ioBroker.Adapter} adapter - Instanz des ioBroker-Adapters
+ */
+async function createPhotovoltaicInsightsStates(adapter) {
+    adapter.log.debug('photovoltaicInsightsStates: Photovoltaic insights initialization started.');
+
+    // Oberstruktur
+    await adapter.setObjectNotExistsAsync('analytics', {
+        type: 'channel',
+        common: {
+            name: {
+                en: 'Analytics & insights (statistics, history, reports)',
+                de: 'Analysen & Statistiken (Verlauf, Berichte)',
+            },
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('analytics.insights', {
+        type: 'channel',
+        common: {
+            name: {
+                en: 'Insights & analysis',
+                de: 'Erkenntnisse & Analysen',
+            },
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync('analytics.insights.photovoltaic', {
+        type: 'channel',
+        common: {
+            name: {
+                en: 'Photovoltaic insights (analysis)',
+                de: 'Photovoltaik Insights (Analyse)',
+            },
+        },
+        native: {},
+    });
+
+    // -------------------------------------------------------------
+    // BLOCK 1: INPUTS
+    // -------------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('analytics.insights.photovoltaic.inputs', {
+        type: 'channel',
+        common: {
+            name: {
+                en: 'Inputs (PV & pump data)',
+                de: 'Eingänge (PV- & Pumpendaten)',
+            },
+        },
+        native: {},
+    });
+
+    const inputStates = [
+        {
+            id: 'pv_surplus_active',
+            name: {
+                en: 'PV surplus active',
+                de: 'PV-Überschuss aktiv',
+            },
+            desc: {
+                en: 'Shows whether photovoltaic surplus is currently active',
+                de: 'Zeigt an, ob aktuell Photovoltaik-Überschuss aktiv ist',
+            },
+            type: 'boolean',
+            role: 'indicator',
+            def: false,
+        },
+        {
+            id: 'pv_surplus_w',
+            name: {
+                en: 'PV surplus power (W)',
+                de: 'PV-Überschussleistung (W)',
+            },
+            desc: {
+                en: 'Current photovoltaic surplus power in watts used as input for the analysis',
+                de: 'Aktuelle Photovoltaik-Überschussleistung in Watt als Eingangswert für die Analyse',
+            },
+            type: 'number',
+            role: 'value.power',
+            unit: 'W',
+            def: 0,
+        },
+        {
+            id: 'pump_power_w',
+            name: {
+                en: 'Pump power (W)',
+                de: 'Pumpenleistung (W)',
+            },
+            desc: {
+                en: 'Current pump power in watts used as input for the photovoltaic analysis',
+                de: 'Aktuelle Pumpenleistung in Watt als Eingangswert für die Photovoltaik-Analyse',
+            },
+            type: 'number',
+            role: 'value.power',
+            unit: 'W',
+            def: 0,
+        },
+    ];
+
+    for (const state of inputStates) {
+        await adapter.setObjectNotExistsAsync(`analytics.insights.photovoltaic.inputs.${state.id}`, {
+            type: 'state',
+            common: {
+                name: state.name,
+                desc: state.desc,
+                type: state.type,
+                role: state.role,
+                unit: state.unit || '',
+                read: true,
+                write: false,
+                def: state.def,
+                persist: true,
+            },
+            native: {},
+        });
+    }
+
+    // -------------------------------------------------------------
+    // BLOCK 2: CALCULATION
+    // -------------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('analytics.insights.photovoltaic.calculation', {
+        type: 'channel',
+        common: {
+            name: {
+                en: 'Calculation',
+                de: 'Berechnung',
+            },
+        },
+        native: {},
+    });
+
+    const calculationStates = [
+        {
+            id: 'mode',
+            name: {
+                en: 'Calculation mode',
+                de: 'Berechnungsmodus',
+            },
+            desc: {
+                en: 'Current calculation mode for photovoltaic insights',
+                de: 'Aktueller Berechnungsmodus für die Photovoltaik-Insights',
+            },
+            type: 'string',
+            role: 'text',
+            def: '',
+        },
+        {
+            id: 'price_source',
+            name: {
+                en: 'Electricity price source',
+                de: 'Strompreisquelle',
+            },
+            desc: {
+                en: 'Source of the electricity price used for savings calculation',
+                de: 'Quelle des Strompreises für die Einsparungsberechnung',
+            },
+            type: 'string',
+            role: 'text',
+            def: '',
+        },
+        {
+            id: 'note',
+            name: {
+                en: 'Calculation note',
+                de: 'Berechnungshinweis',
+            },
+            desc: {
+                en: 'Short note about the current photovoltaic insights calculation',
+                de: 'Kurzer Hinweis zur aktuellen Photovoltaik-Insights-Berechnung',
+            },
+            type: 'string',
+            role: 'text',
+            def: '',
+        },
+    ];
+
+    for (const state of calculationStates) {
+        await adapter.setObjectNotExistsAsync(`analytics.insights.photovoltaic.calculation.${state.id}`, {
+            type: 'state',
+            common: {
+                name: state.name,
+                desc: state.desc,
+                type: state.type,
+                role: state.role,
+                read: true,
+                write: false,
+                def: state.def,
+                persist: true,
+            },
+            native: {},
+        });
+    }
+
+    // -------------------------------------------------------------
+    // BLOCK 3: RESULTS
+    // -------------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('analytics.insights.photovoltaic.results', {
+        type: 'channel',
+        common: {
+            name: {
+                en: 'Results',
+                de: 'Ergebnisse',
+            },
+        },
+        native: {},
+    });
+
+    const resultStates = [
+        {
+            id: 'active_today',
+            name: {
+                en: 'PV active today',
+                de: 'PV heute aktiv',
+            },
+            desc: {
+                en: 'Shows whether the pump was operated by photovoltaic surplus today',
+                de: 'Zeigt an, ob die Pumpe heute durch Photovoltaik-Überschuss betrieben wurde',
+            },
+            type: 'boolean',
+            role: 'indicator',
+            def: false,
+        },
+        {
+            id: 'runtime_today_min',
+            name: {
+                en: 'Runtime today',
+                de: 'Laufzeit heute',
+            },
+            desc: {
+                en: 'Pump runtime today caused by photovoltaic surplus',
+                de: 'Pumpenlaufzeit heute durch Photovoltaik-Überschuss',
+            },
+            type: 'number',
+            role: 'value',
+            unit: 'min',
+            def: 0,
+        },
+        {
+            id: 'energy_used_today_kwh',
+            name: {
+                en: 'Energy used today',
+                de: 'Genutzte Energie heute',
+            },
+            desc: {
+                en: 'Estimated pump energy used today during photovoltaic surplus operation',
+                de: 'Geschätzte Pumpenenergie heute während des PV-Überschussbetriebs',
+            },
+            type: 'number',
+            role: 'value.power.consumption',
+            unit: 'kWh',
+            def: 0,
+        },
+        {
+            id: 'savings_today_eur',
+            name: {
+                en: 'Savings today',
+                de: 'Einsparung heute',
+            },
+            desc: {
+                en: 'Estimated savings today based on photovoltaic surplus operation',
+                de: 'Geschätzte Einsparung heute durch Photovoltaik-Überschussbetrieb',
+            },
+            type: 'number',
+            role: 'value',
+            unit: '€',
+            def: 0,
+        },
+        {
+            id: 'starts_today',
+            name: {
+                en: 'Starts today',
+                de: 'Starts heute',
+            },
+            desc: {
+                en: 'Number of photovoltaic surplus pump starts today',
+                de: 'Anzahl der heutigen Pumpenstarts durch Photovoltaik-Überschuss',
+            },
+            type: 'number',
+            role: 'value',
+            def: 0,
+        },
+        {
+            id: 'summary_text',
+            name: {
+                en: 'Summary text',
+                de: 'Zusammenfassungstext',
+            },
+            desc: {
+                en: 'Short readable summary of today’s photovoltaic surplus usage',
+                de: 'Kurze lesbare Zusammenfassung der heutigen PV-Überschussnutzung',
+            },
+            type: 'string',
+            role: 'text',
+            def: '',
+        },
+        {
+            id: 'summary_json',
+            name: {
+                en: 'Summary JSON',
+                de: 'Zusammenfassung JSON',
+            },
+            desc: {
+                en: 'Structured JSON summary of today’s photovoltaic surplus usage',
+                de: 'Strukturierte JSON-Zusammenfassung der heutigen PV-Überschussnutzung',
+            },
+            type: 'string',
+            role: 'json',
+            def: '{}',
+        },
+        {
+            id: 'summary_html',
+            name: {
+                en: 'Summary HTML',
+                de: 'Zusammenfassung HTML',
+            },
+            desc: {
+                en: 'HTML summary of today’s photovoltaic surplus usage',
+                de: 'HTML-Zusammenfassung der heutigen PV-Überschussnutzung',
+            },
+            type: 'string',
+            role: 'html',
+            def: '',
+        },
+    ];
+
+    for (const state of resultStates) {
+        await adapter.setObjectNotExistsAsync(`analytics.insights.photovoltaic.results.${state.id}`, {
+            type: 'state',
+            common: {
+                name: state.name,
+                desc: state.desc,
+                type: state.type,
+                role: state.role,
+                unit: state.unit || '',
+                read: true,
+                write: false,
+                def: state.def,
+                persist: true,
+            },
+            native: {},
+        });
+    }
+
+    // -------------------------------------------------------------
+    // BLOCK 4: DEBUG
+    // -------------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('analytics.insights.photovoltaic.debug', {
+        type: 'channel',
+        common: {
+            name: {
+                en: 'Debug',
+                de: 'Debug',
+            },
+        },
+        native: {},
+    });
+
+    const debugStates = [
+        {
+            id: 'last_update',
+            name: {
+                en: 'Last update',
+                de: 'Letzte Aktualisierung',
+            },
+            desc: {
+                en: 'Timestamp of the last photovoltaic insights update',
+                de: 'Zeitstempel der letzten Photovoltaik-Insights-Aktualisierung',
+            },
+            type: 'string',
+            role: 'date',
+            def: '',
+        },
+        {
+            id: 'last_recalculation_reason',
+            name: {
+                en: 'Last recalculation reason',
+                de: 'Letzter Neuberechnungsgrund',
+            },
+            desc: {
+                en: 'Reason for the last photovoltaic insights recalculation',
+                de: 'Grund der letzten Photovoltaik-Insights-Neuberechnung',
+            },
+            type: 'string',
+            role: 'text',
+            def: '',
+        },
+        {
+            id: 'debug_text',
+            name: {
+                en: 'Debug text',
+                de: 'Debug-Text',
+            },
+            desc: {
+                en: 'Readable debug information for photovoltaic insights',
+                de: 'Lesbare Debug-Informationen für Photovoltaik-Insights',
+            },
+            type: 'string',
+            role: 'text',
+            def: '',
+        },
+    ];
+
+    for (const state of debugStates) {
+        await adapter.setObjectNotExistsAsync(`analytics.insights.photovoltaic.debug.${state.id}`, {
+            type: 'state',
+            common: {
+                name: state.name,
+                desc: state.desc,
+                type: state.type,
+                role: state.role,
+                read: true,
+                write: false,
+                def: state.def,
+                persist: true,
+            },
+            native: {},
+        });
+    }
+
+    adapter.log.debug(
+        'photovoltaicInsightsStates: Block 1 inputs, Block 2 calculation, Block 3 results and Block 4 debug created successfully.',
+    );
+}
+
+module.exports = { createPhotovoltaicInsightsStates };

package/main.js

@@ -24,9 +24,12 @@ const solarExtendedHelper = require('./lib/helpers/solarExtendedHelper'); // NEU
 const frostHelper = require('./lib/helpers/frostHelper');
 const statusHelper = require('./lib/helpers/statusHelper');
 const photovoltaicHelper = require('./lib/helpers/photovoltaicHelper');
+const photovoltaicInsightsHelper = require('./lib/helpers/photovoltaicInsightsHelper');
 const aiHelper = require('./lib/helpers/aiHelper');
 const aiForecastHelper = require('./lib/helpers/aiForecastHelper');
 const aiChemistryHelpHelper = require('./lib/helpers/aiChemistryHelpHelper');
+const chemistryPhHelper = require('./lib/helpers/chemistryPhHelper');
+const chemistryTdsHelper = require('./lib/helpers/chemistryTdsHelper');
 const controlHelper = require('./lib/helpers/controlHelper');
 const controlHelper2 = require('./lib/helpers/controlHelper2');
 const debugLogHelper = require('./lib/helpers/debugLogHelper');
@@ -58,9 +61,12 @@ const { createDebugLogStates } = require('./lib/stateDefinitions/debugLogStates'
 const { createInfoStates } = require('./lib/stateDefinitions/infoStates');
 const { createAiStates } = require('./lib/stateDefinitions/aiStates'); // NEU: KI-States
 const { createAiChemistryHelpStates } = require('./lib/stateDefinitions/aiChemistryHelpStates'); // NEU: KI-Chemie-Hilfe
+const { createChemistryPhStates } = require('./lib/stateDefinitions/chemistryPhStates');
+const { createChemistryTdsStates } = require('./lib/stateDefinitions/chemistryTdsStates');
 const { createHeatStates } = require('./lib/stateDefinitions/heatStates');
 const { createActuatorsStates } = require('./lib/stateDefinitions/actuatorsStates');
 const { createSolarInsightsStates } = require('./lib/stateDefinitions/solarInsightsStates');
+const { createPhotovoltaicInsightsStates } = require('./lib/stateDefinitions/photovoltaicInsightsStates');
 
 class Poolcontrol extends utils.Adapter {
     constructor(options) {
@@ -135,6 +141,9 @@ class Poolcontrol extends utils.Adapter {
         // --- Solar Insights / Analyse ---
         await createSolarInsightsStates(this);
 
+        // --- Photovoltaic Insights / Analyse ---
+        await createPhotovoltaicInsightsStates(this);
+
         // --- Sprachausgaben ---
         await createSpeechStates(this);
 
@@ -157,6 +166,12 @@ class Poolcontrol extends utils.Adapter {
         await createAiStates(this); // NEU: KI-States anlegen
         await createAiChemistryHelpStates(this); // NEU: KI-Chemie-Hilfe-States
 
+        // --- Chemistry / pH evaluation ---
+        await createChemistryPhStates(this);
+
+        // --- Chemistry / TDS evaluation ---
+        await createChemistryTdsStates(this);
+
         // --- Zusatz-Aktoren (Beleuchtung & Zusatzpumpen) ---
         await createActuatorsStates(this);
 
@@ -181,9 +196,12 @@ class Poolcontrol extends utils.Adapter {
         solarExtendedHelper.init(this); // NEU
         heatHelper.init(this); // ← NEU
         photovoltaicHelper.init(this);
+        photovoltaicInsightsHelper.init(this);
         aiHelper.init(this);
         aiForecastHelper.init(this);
         aiChemistryHelpHelper.init(this);
+        chemistryPhHelper.init(this);
+        chemistryTdsHelper.init(this);
         frostHelper.init(this);
         statusHelper.init(this);
         infoHelper.init(this);
@@ -270,6 +288,18 @@ class Poolcontrol extends utils.Adapter {
             if (aiForecastHelper.cleanup) {
                 aiForecastHelper.cleanup();
             }
+            if (photovoltaicHelper.cleanup) {
+                photovoltaicHelper.cleanup();
+            }
+            if (photovoltaicInsightsHelper.cleanup) {
+                photovoltaicInsightsHelper.cleanup();
+            }
+            if (chemistryPhHelper.cleanup) {
+                chemistryPhHelper.cleanup();
+            }
+            if (chemistryTdsHelper.cleanup) {
+                chemistryTdsHelper.cleanup();
+            }
             if (aiChemistryHelpHelper.cleanup) {
                 aiChemistryHelpHelper.cleanup();
             }
@@ -367,6 +397,11 @@ class Poolcontrol extends utils.Adapter {
         } catch (e) {
             this.log.warn(`[photovoltaicHelper] Error in handleStateChange: ${e.message}`);
         }
+        try {
+            photovoltaicInsightsHelper.handleStateChange(id, state);
+        } catch (e) {
+            this.log.warn(`[photovoltaicInsightsHelper] Error in handleStateChange: ${e.message}`);
+        }
         try {
             heatHelper.handleStateChange(id, state);
         } catch (e) {
@@ -393,6 +428,16 @@ class Poolcontrol extends utils.Adapter {
         } catch (e) {
             this.log.warn(`[main] Error in aiChemistryHelpHelper.handleStateChange: ${e.message}`);
         }
+        try {
+            await chemistryPhHelper.handleStateChange(id, state);
+        } catch (e) {
+            this.log.warn(`[chemistryPhHelper] Error in handleStateChange: ${e.message}`);
+        }
+        try {
+            await chemistryTdsHelper.handleStateChange(id, state);
+        } catch (e) {
+            this.log.warn(`[chemistryTdsHelper] Error in handleStateChange: ${e.message}`);
+        }
         try {
             statusHelper.handleStateChange(id, state);
         } catch (e) {

package/package.json

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