iobroker.poolcontrol 1.3.14 → 1.3.17

package/lib/stateDefinitions/chemistryPhStates.js

@@ -651,6 +651,220 @@ async function createChemistryPhStates(adapter) {
         persist: true,
     });
 
+    // -------------------------------------------------------------
+    // History
+    // -------------------------------------------------------------
+    await createChannel(adapter, 'chemistry.ph.history', {
+        en: 'History',
+        de: 'Historie',
+    });
+
+    await createState(adapter, 'chemistry.ph.history.samples_json', {
+        name: {
+            en: 'Samples JSON',
+            de: 'Messwerte JSON',
+        },
+        desc: {
+            en: 'Internal JSON list of valid pH samples for up to 30 days.',
+            de: 'Interne JSON-Liste gültiger pH-Messpunkte für bis zu 30 Tage.',
+        },
+        type: 'string',
+        role: 'json',
+        read: true,
+        write: false,
+        def: '[]',
+        persist: true,
+    });
+
+    await createState(adapter, 'chemistry.ph.history.samples_count', {
+        name: {
+            en: 'Samples count',
+            de: 'Anzahl Messwerte',
+        },
+        desc: {
+            en: 'Number of stored valid pH samples.',
+            de: 'Anzahl gespeicherter gültiger pH-Messpunkte.',
+        },
+        type: 'number',
+        role: 'value',
+        read: true,
+        write: false,
+        def: 0,
+        persist: true,
+    });
+
+    await createState(adapter, 'chemistry.ph.history.oldest_sample_at', {
+        name: {
+            en: 'Oldest sample time',
+            de: 'Ältester Messwert',
+        },
+        type: 'string',
+        role: 'value.time',
+        read: true,
+        write: false,
+        def: '',
+        persist: true,
+    });
+
+    await createState(adapter, 'chemistry.ph.history.newest_sample_at', {
+        name: {
+            en: 'Newest sample time',
+            de: 'Neuester Messwert',
+        },
+        type: 'string',
+        role: 'value.time',
+        read: true,
+        write: false,
+        def: '',
+        persist: true,
+    });
+
+    // -------------------------------------------------------------
+    // Trend
+    // -------------------------------------------------------------
+    await createChannel(adapter, 'chemistry.ph.trend', {
+        en: 'Trend',
+        de: 'Trend',
+    });
+
+    const phTrendStates = [
+        ['reference_24h_value', '24h reference value', '24h-Referenzwert'],
+        ['reference_7d_value', '7 day reference value', '7-Tage-Referenzwert'],
+        ['reference_30d_value', '30 day reference value', '30-Tage-Referenzwert'],
+        ['delta_24h', '24h delta', '24h-Differenz'],
+        ['delta_7d', '7 day delta', '7-Tage-Differenz'],
+        ['delta_30d', '30 day delta', '30-Tage-Differenz'],
+    ];
+
+    for (const [stateId, enName, deName] of phTrendStates) {
+        await createState(adapter, `chemistry.ph.trend.${stateId}`, {
+            name: {
+                en: enName,
+                de: deName,
+            },
+            type: 'number',
+            role: 'value',
+            read: true,
+            write: false,
+            def: 0,
+            persist: true,
+        });
+    }
+
+    const phTrendTimeStates = [
+        ['reference_24h_at', '24h reference time', 'Zeitpunkt des 24h-Referenzwerts'],
+        ['reference_7d_at', '7 day reference time', 'Zeitpunkt des 7-Tage-Referenzwerts'],
+        ['reference_30d_at', '30 day reference time', 'Zeitpunkt des 30-Tage-Referenzwerts'],
+    ];
+
+    for (const [stateId, enName, deName] of phTrendTimeStates) {
+        await createState(adapter, `chemistry.ph.trend.${stateId}`, {
+            name: {
+                en: enName,
+                de: deName,
+            },
+            type: 'string',
+            role: 'value.time',
+            read: true,
+            write: false,
+            def: '',
+            persist: true,
+        });
+    }
+
+    await createState(adapter, 'chemistry.ph.trend.direction', {
+        name: {
+            en: 'Trend direction',
+            de: 'Trendrichtung',
+        },
+        desc: {
+            en: 'Overall trend direction: stable, rising, falling or not enough data.',
+            de: 'Gesamte Trendrichtung: stabil, steigend, fallend oder noch nicht genug Daten.',
+        },
+        type: 'string',
+        role: 'text',
+        read: true,
+        write: false,
+        def: 'not_enough_data',
+        persist: true,
+    });
+
+    await createState(adapter, 'chemistry.ph.trend.status', {
+        name: {
+            en: 'Trend status',
+            de: 'Trendstatus',
+        },
+        desc: {
+            en: 'Readable status of the pH trend development.',
+            de: 'Lesbarer Status der pH-Trendentwicklung.',
+        },
+        type: 'string',
+        role: 'text',
+        read: true,
+        write: false,
+        def: 'not_enough_data',
+        persist: true,
+    });
+
+    // -------------------------------------------------------------
+    // Outputs
+    // -------------------------------------------------------------
+    await createChannel(adapter, 'chemistry.ph.outputs', {
+        en: 'Outputs',
+        de: 'Ausgaben',
+    });
+
+    await createState(adapter, 'chemistry.ph.outputs.summary_text', {
+        name: {
+            en: 'Summary text',
+            de: 'Zusammenfassung Text',
+        },
+        desc: {
+            en: 'Readable pH summary text.',
+            de: 'Lesbare pH-Zusammenfassung.',
+        },
+        type: 'string',
+        role: 'text',
+        read: true,
+        write: false,
+        def: '',
+        persist: true,
+    });
+
+    await createState(adapter, 'chemistry.ph.outputs.summary_html', {
+        name: {
+            en: 'Summary HTML',
+            de: 'Zusammenfassung HTML',
+        },
+        desc: {
+            en: 'HTML summary for VIS or widgets.',
+            de: 'HTML-Zusammenfassung für VIS oder Widgets.',
+        },
+        type: 'string',
+        role: 'html',
+        read: true,
+        write: false,
+        def: '',
+        persist: true,
+    });
+
+    await createState(adapter, 'chemistry.ph.outputs.summary_json', {
+        name: {
+            en: 'Summary JSON',
+            de: 'Zusammenfassung JSON',
+        },
+        desc: {
+            en: 'Structured pH summary as JSON.',
+            de: 'Strukturierte pH-Zusammenfassung als JSON.',
+        },
+        type: 'string',
+        role: 'json',
+        read: true,
+        write: false,
+        def: '',
+        persist: true,
+    });
+
     // -------------------------------------------------------------
     // Debug
     // -------------------------------------------------------------

package/lib/stateDefinitions/speechStates.js

@@ -285,6 +285,157 @@ async function createSpeechStates(adapter) {
 
     adapter.log.debug('[speechStates] Amazon Alexa quiet-time states checked and created.');
 
+    // ------------------------------------------------------------------
+    // FIX: Speech sources - user configurable message sources
+    // ------------------------------------------------------------------
+
+    await adapter.setObjectNotExistsAsync('speech.sources', {
+        type: 'channel',
+        common: {
+            name: {
+                en: 'Speech sources',
+                de: 'Sprachquellen',
+            },
+        },
+        native: {},
+    });
+
+    const speechSources = [
+        {
+            id: 'solar',
+            name: {
+                en: 'Solar control messages',
+                de: 'Solarsteuerung-Meldungen',
+            },
+            enabledName: {
+                en: 'Enable solar control messages',
+                de: 'Solarsteuerung-Meldungen aktivieren',
+            },
+            enabledDesc: {
+                en: 'Allows speech messages when the solar control switches the pump on or off',
+                de: 'Erlaubt Sprachmeldungen, wenn die Solarsteuerung die Pumpe ein- oder ausschaltet',
+            },
+            cooldownName: {
+                en: 'Solar message cooldown',
+                de: 'Solar-Meldungssperre',
+            },
+            cooldownDesc: {
+                en: 'Minimum time in minutes between solar control speech messages',
+                de: 'Mindestzeit in Minuten zwischen Solarsteuerung-Sprachmeldungen',
+            },
+            cooldownDefault: 30,
+        },
+        {
+            id: 'time',
+            name: {
+                en: 'Time control messages',
+                de: 'Zeitsteuerung-Meldungen',
+            },
+            enabledName: {
+                en: 'Enable time control messages',
+                de: 'Zeitsteuerung-Meldungen aktivieren',
+            },
+            enabledDesc: {
+                en: 'Allows speech messages when the time control switches the pump on or off',
+                de: 'Erlaubt Sprachmeldungen, wenn die Zeitsteuerung die Pumpe ein- oder ausschaltet',
+            },
+            cooldownName: {
+                en: 'Time control message cooldown',
+                de: 'Zeitsteuerung-Meldungssperre',
+            },
+            cooldownDesc: {
+                en: 'Minimum time in minutes between time control speech messages',
+                de: 'Mindestzeit in Minuten zwischen Zeitsteuerung-Sprachmeldungen',
+            },
+            cooldownDefault: 0,
+        },
+    ];
+
+    for (const source of speechSources) {
+        const baseId = `speech.sources.${source.id}`;
+
+        await adapter.setObjectNotExistsAsync(baseId, {
+            type: 'channel',
+            common: {
+                name: source.name,
+            },
+            native: {},
+        });
+
+        await adapter.setObjectNotExistsAsync(`${baseId}.enabled`, {
+            type: 'state',
+            common: {
+                name: source.enabledName,
+                desc: source.enabledDesc,
+                type: 'boolean',
+                role: 'switch',
+                read: true,
+                write: true,
+                def: true,
+                persist: true,
+            },
+            native: {},
+        });
+
+        const enabledState = await adapter.getStateAsync(`${baseId}.enabled`);
+        if (!enabledState || enabledState.val === null || enabledState.val === undefined) {
+            await adapter.setStateAsync(`${baseId}.enabled`, { val: true, ack: true });
+        }
+
+        await adapter.setObjectNotExistsAsync(`${baseId}.cooldown_minutes`, {
+            type: 'state',
+            common: {
+                name: source.cooldownName,
+                desc: source.cooldownDesc,
+                type: 'number',
+                role: 'level',
+                unit: 'min',
+                read: true,
+                write: true,
+                min: 0,
+                def: source.cooldownDefault,
+                persist: true,
+            },
+            native: {},
+        });
+
+        const cooldownState = await adapter.getStateAsync(`${baseId}.cooldown_minutes`);
+        if (!cooldownState || cooldownState.val === null || cooldownState.val === undefined) {
+            await adapter.setStateAsync(`${baseId}.cooldown_minutes`, {
+                val: source.cooldownDefault,
+                ack: true,
+            });
+        }
+
+        await adapter.setObjectNotExistsAsync(`${baseId}.last_sent`, {
+            type: 'state',
+            common: {
+                name: {
+                    en: 'Last message sent',
+                    de: 'Letzte gesendete Meldung',
+                },
+                desc: {
+                    en: 'Timestamp of the last speech message for this source',
+                    de: 'Zeitstempel der letzten Sprachmeldung dieser Quelle',
+                },
+                type: 'string',
+                role: 'value.time',
+                read: true,
+                write: false,
+                def: '',
+                persist: true,
+            },
+            native: {},
+        });
+
+        const lastSentState = await adapter.getStateAsync(`${baseId}.last_sent`);
+        if (!lastSentState || lastSentState.val === null || lastSentState.val === undefined) {
+            await adapter.setStateAsync(`${baseId}.last_sent`, { val: '', ack: true });
+        }
+    }
+
+    adapter.log.debug('[speechStates] Speech source states checked and created');
+
     // versteckte Dateien
 
     await adapter.setObjectNotExistsAsync('speech.solar_active', {

package/main.js

@@ -30,6 +30,7 @@ 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 chemistryOrpHelper = require('./lib/helpers/chemistryOrpHelper');
 const controlHelper = require('./lib/helpers/controlHelper');
 const controlHelper2 = require('./lib/helpers/controlHelper2');
 const debugLogHelper = require('./lib/helpers/debugLogHelper');
@@ -63,6 +64,7 @@ const { createAiStates } = require('./lib/stateDefinitions/aiStates'); // NEU: K
 const { createAiChemistryHelpStates } = require('./lib/stateDefinitions/aiChemistryHelpStates'); // NEU: KI-Chemie-Hilfe
 const { createChemistryPhStates } = require('./lib/stateDefinitions/chemistryPhStates');
 const { createChemistryTdsStates } = require('./lib/stateDefinitions/chemistryTdsStates');
+const { createChemistryOrpStates } = require('./lib/stateDefinitions/chemistryOrpStates');
 const { createHeatStates } = require('./lib/stateDefinitions/heatStates');
 const { createActuatorsStates } = require('./lib/stateDefinitions/actuatorsStates');
 const { createSolarInsightsStates } = require('./lib/stateDefinitions/solarInsightsStates');
@@ -172,6 +174,9 @@ class Poolcontrol extends utils.Adapter {
         // --- Chemistry / TDS evaluation ---
         await createChemistryTdsStates(this);
 
+        // --- Chemistry / ORP evaluation ---
+        await createChemistryOrpStates(this);
+
         // --- Zusatz-Aktoren (Beleuchtung & Zusatzpumpen) ---
         await createActuatorsStates(this);
 
@@ -202,6 +207,7 @@ class Poolcontrol extends utils.Adapter {
         aiChemistryHelpHelper.init(this);
         chemistryPhHelper.init(this);
         chemistryTdsHelper.init(this);
+        chemistryOrpHelper.init(this);
         frostHelper.init(this);
         statusHelper.init(this);
         infoHelper.init(this);
@@ -300,6 +306,9 @@ class Poolcontrol extends utils.Adapter {
             if (chemistryTdsHelper.cleanup) {
                 chemistryTdsHelper.cleanup();
             }
+            if (chemistryOrpHelper.cleanup) {
+                chemistryOrpHelper.cleanup();
+            }
             if (aiChemistryHelpHelper.cleanup) {
                 aiChemistryHelpHelper.cleanup();
             }
@@ -438,6 +447,11 @@ class Poolcontrol extends utils.Adapter {
         } catch (e) {
             this.log.warn(`[chemistryTdsHelper] Error in handleStateChange: ${e.message}`);
         }
+        try {
+            await chemistryOrpHelper.handleStateChange(id, state);
+        } catch (e) {
+            this.log.warn(`[chemistryOrpHelper] 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.14",
+  "version": "1.3.17",
   "description": "Steuerung & Automatisierung für den Pool (Pumpe, Heizung, Ventile, Sensoren).",
   "author": "DasBo1975 <dasbo1975@outlook.de>",
   "homepage": "https://github.com/DasBo1975/ioBroker.poolcontrol",