iobroker.poolcontrol 0.1.1 → 0.2.0

package/lib/stateDefinitions/controlStates.js

@@ -0,0 +1,184 @@
+'use strict';
+
+/**
+ * controlStates
+ * - Erstellt States, die zur Laufzeit über VIS oder Blockly steuerbar sind
+ * - Erstellt zusätzlich beschriftete Channel-Struktur:
+ *     control
+ *       └─ season
+ *            └─ active
+ */
+
+/**
+ * Erstellt alle States im control-Bereich.
+ *
+ * @param {import('iobroker').Adapter} adapter - ioBroker Adapterinstanz
+ */
+async function createControlStates(adapter) {
+    try {
+        // Channel: control
+        await adapter.setObjectNotExistsAsync('control', {
+            type: 'channel',
+            common: {
+                name: 'Steuerung',
+                desc: 'Manuelle Steuerung und Laufzeitfunktionen (VIS / Blockly)',
+            },
+            native: {},
+        });
+
+        // Channel: control.season
+        await adapter.setObjectNotExistsAsync('control.season', {
+            type: 'channel',
+            common: {
+                name: 'Saisonsteuerung',
+                desc: 'Steuerung der aktiven Poolsaison und saisonabhängiger Funktionen',
+            },
+            native: {},
+        });
+
+        // State: control.season.active
+        await adapter.setObjectNotExistsAsync('control.season.active', {
+            type: 'state',
+            common: {
+                name: 'Poolsaison aktiv',
+                desc: 'Zeigt an, ob die Poolsaison aktiv ist (steuerbar über VIS oder Blockly)',
+                type: 'boolean',
+                role: 'switch',
+                read: true,
+                write: true,
+                def: false,
+            },
+            native: {},
+        });
+
+        // Initialwert aus der Instanzkonfiguration übernehmen
+        const cfgValue = !!adapter.config.season_active;
+        await adapter.setStateAsync('control.season.active', { val: cfgValue, ack: true });
+
+        adapter.log.debug(`[controlStates] State control.season.active initialisiert mit Wert: ${cfgValue}`);
+
+        // ---------------------------------------------------------------------
+        // Channel: control.pump
+        await adapter.setObjectNotExistsAsync('control.pump', {
+            type: 'channel',
+            common: {
+                name: 'Pumpensteuerung',
+                desc: 'Manuelle Aktionen wie Rückspülen oder Wartung',
+            },
+            native: {},
+        });
+
+        // Rückspülung starten
+        await adapter.setObjectNotExistsAsync('control.pump.backwash_start', {
+            type: 'state',
+            common: {
+                name: 'Rückspülung starten',
+                desc: 'Startet die Rückspülung für die eingestellte Dauer',
+                type: 'boolean',
+                role: 'button',
+                read: true,
+                write: true,
+                def: false,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('control.pump.backwash_start', { val: false, ack: true });
+
+        // Rückspülung aktiv
+        await adapter.setObjectNotExistsAsync('control.pump.backwash_active', {
+            type: 'state',
+            common: {
+                name: 'Rückspülung aktiv',
+                desc: 'Zeigt an, ob gerade eine Rückspülung läuft',
+                type: 'boolean',
+                role: 'indicator',
+                read: true,
+                write: false,
+                def: false,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('control.pump.backwash_active', { val: false, ack: true });
+
+        // Rückspülungsdauer
+        await adapter.setObjectNotExistsAsync('control.pump.backwash_duration', {
+            type: 'state',
+            common: {
+                name: 'Dauer der Rückspülung (Minuten)',
+                desc: 'Bestimmt, wie lange die Rückspülung laufen soll',
+                type: 'number',
+                role: 'level.timer',
+                read: true,
+                write: true,
+                def: 1,
+                min: 1,
+                max: 60,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('control.pump.backwash_duration', { val: 1, ack: true });
+
+        // Wartungsmodus aktiv
+        await adapter.setObjectNotExistsAsync('control.pump.maintenance_active', {
+            type: 'state',
+            common: {
+                name: 'Wartungsmodus aktiv',
+                desc: 'Deaktiviert Automatikfunktionen und lässt Pumpe manuell steuern',
+                type: 'boolean',
+                role: 'switch',
+                read: true,
+                write: true,
+                def: false,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('control.pump.maintenance_active', { val: false, ack: true });
+
+        // Benachrichtigungen aktivieren
+        await adapter.setObjectNotExistsAsync('control.pump.notifications_enabled', {
+            type: 'state',
+            common: {
+                name: 'Benachrichtigungen aktivieren',
+                desc: 'Wenn aktiviert, werden bei Rückspülung und Wartung Ansagen oder Nachrichten gesendet (E-Mail, Telegram, Alexa)',
+                type: 'boolean',
+                role: 'switch',
+                read: true,
+                write: true,
+                def: true,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('control.pump.notifications_enabled', { val: true, ack: true });
+
+        // ---------------------------------------------------------------------
+        // Channel: control.energy
+        await adapter.setObjectNotExistsAsync('control.energy', {
+            type: 'channel',
+            common: {
+                name: 'Energieverwaltung',
+                desc: 'Funktionen zur Verbrauchs- und Kostenrücksetzung',
+            },
+            native: {},
+        });
+
+        // Button: Energiezähler zurücksetzen
+        await adapter.setObjectNotExistsAsync('control.energy.reset', {
+            type: 'state',
+            common: {
+                name: 'Energiezähler zurücksetzen',
+                desc: 'Setzt alle Verbrauchs- und Kostenwerte auf 0 (Totalreset)',
+                type: 'boolean',
+                role: 'button',
+                read: true,
+                write: true,
+                def: false,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('control.energy.reset', { val: false, ack: true });
+    } catch (err) {
+        adapter.log.error(`[controlStates] Fehler beim Erstellen der Control-States: ${err.message}`);
+    }
+}
+
+module.exports = { createControlStates };

package/lib/stateDefinitions/debugLogStates.js

@@ -0,0 +1,124 @@
+'use strict';
+
+/**
+ * Legt alle States für den Diagnosebereich an:
+ * - SystemCheck.debug_logs.target_area   → überwachten Bereich auswählen
+ * - SystemCheck.debug_logs.log           → fortlaufendes Log (Text)
+ * - SystemCheck.debug_logs.clear         → löscht das Log
+ *
+ * @param {import('iobroker').Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createDebugLogStates(adapter) {
+    try {
+        // Oberordner SystemCheck (alphabetisch ganz unten)
+        await adapter.setObjectNotExistsAsync('SystemCheck', {
+            type: 'channel',
+            common: {
+                name: 'SystemCheck (Diagnose und Tools)',
+                desc: 'Enthält interne Diagnose- und Protokollierungsfunktionen des Adapters.',
+            },
+            native: {},
+        });
+
+        // Unterkanal für Debug-Logs
+        await adapter.setObjectNotExistsAsync('SystemCheck.debug_logs', {
+            type: 'channel',
+            common: {
+                name: 'Debug-Logs (Test & Diagnose)',
+                desc: 'Protokolliert auffällige oder häufige Zustandsänderungen innerhalb der Instanz.',
+            },
+            native: {},
+        });
+
+        // --- Dynamischer Scan aller Objekte der Instanz ---
+        const objects = await adapter.getObjectListAsync({
+            startkey: `${adapter.namespace}.`,
+            endkey: `${adapter.namespace}.\u9999`,
+        });
+
+        const areas = new Set();
+
+        for (const row of objects.rows) {
+            const idParts = row.id.split('.');
+            // Beispiel: poolcontrol.0.control.backwash.active
+            if (idParts.length >= 3) {
+                const base = idParts[2];
+                const sub = idParts[3];
+
+                // Nur Bereiche, keine States
+                // (also keine Objekte mit mehr als 4 Punkten oder zz_)
+                if (!base.startsWith('zz_')) {
+                    // Hauptbereiche immer aufnehmen
+                    areas.add(base);
+
+                    // Unterbereiche nur, wenn sie selbst wieder Unterpunkte haben
+                    // -> prüft, ob es States gibt, die mit base.sub beginnen
+                    const hasSubEntries = objects.rows.some(r =>
+                        r.id.startsWith(`${adapter.namespace}.${base}.${sub}.`),
+                    );
+                    if (hasSubEntries && sub && !sub.startsWith('zz_')) {
+                        areas.add(`${base}.${sub}`);
+                    }
+                }
+            }
+        }
+
+        // Alphabetisch sortieren und "none" hinzufügen
+        const availableAreas = ['none', ...Array.from(areas).sort()];
+
+        // Bereichsauswahl (target_area)
+        await adapter.setObjectNotExistsAsync('SystemCheck.debug_logs.target_area', {
+            type: 'state',
+            common: {
+                name: 'Überwachungsbereich',
+                desc: 'Wähle, welcher Bereich der Instanz überwacht werden soll (z. B. pump, solar, control.backwash).',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: true,
+                states: availableAreas.reduce((obj, v) => ((obj[v] = v), obj), {}),
+                def: 'none',
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('SystemCheck.debug_logs.target_area', { val: 'none', ack: true });
+
+        // Fortlaufendes Log
+        await adapter.setObjectNotExistsAsync('SystemCheck.debug_logs.log', {
+            type: 'state',
+            common: {
+                name: 'Debug-Logtext',
+                desc: 'Fortlaufendes Protokoll des ausgewählten Bereichs.',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('SystemCheck.debug_logs.log', { val: '', ack: true });
+
+        // Clear-Button
+        await adapter.setObjectNotExistsAsync('SystemCheck.debug_logs.clear', {
+            type: 'state',
+            common: {
+                name: 'Log löschen',
+                desc: 'Löscht das fortlaufende Log im Kanal SystemCheck.debug_logs.',
+                type: 'boolean',
+                role: 'button',
+                read: true,
+                write: true,
+                def: false,
+            },
+            native: {},
+        });
+        await adapter.setStateAsync('SystemCheck.debug_logs.clear', { val: false, ack: true });
+
+        adapter.log.debug(`[debugLogStates] Debug-Log-States erfolgreich angelegt`);
+        adapter.log.debug(`[debugLogStates] Verfügbare Bereiche: ${availableAreas.join(', ')}`);
+    } catch (err) {
+        adapter.log.error(`[debugLogStates] Fehler beim Erstellen der States: ${err.message}`);
+    }
+}
+
+module.exports = { createDebugLogStates };

package/lib/stateDefinitions/runtimeStates.js

@@ -4,7 +4,9 @@
  * Legt alle States für Laufzeit- und Umwälzwerte an:
  * - runtime.total
  * - runtime.today
- * - runtime.formatted
+ * - runtime.start_count_today
+ * - runtime.current_session
+ * - runtime.season_total
  * - circulation.daily_total
  * - circulation.daily_required
  * - circulation.daily_remaining
@@ -21,38 +23,72 @@ async function createRuntimeStates(adapter) {
         native: {},
     });
 
+    // Gesamtlaufzeit (formatiert)
     await adapter.setObjectNotExistsAsync('runtime.total', {
         type: 'state',
         common: {
-            name: 'Gesamtlaufzeit',
-            type: 'number',
-            role: 'value.time',
-            unit: 's',
+            name: 'Gesamtlaufzeit (formatiert)',
+            type: 'string',
+            role: 'text',
             read: true,
             write: false,
             persist: true,
         },
         native: {},
     });
+    await adapter.setStateAsync('runtime.total', { val: '0h 0m 0s', ack: true });
 
+    // Tageslaufzeit (formatiert)
     await adapter.setObjectNotExistsAsync('runtime.today', {
         type: 'state',
         common: {
-            name: 'Tageslaufzeit',
+            name: 'Tageslaufzeit (formatiert)',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('runtime.today', { val: '0h 0m 0s', ack: true });
+
+    // -------------------------------------------------------------------------
+    // NEU: Pumpenstarts heute
+    await adapter.setObjectNotExistsAsync('runtime.start_count_today', {
+        type: 'state',
+        common: {
+            name: 'Pumpenstarts heute',
             type: 'number',
-            role: 'value.time',
-            unit: 's',
+            role: 'value',
             read: true,
             write: false,
             persist: true,
         },
         native: {},
     });
+    await adapter.setStateAsync('runtime.start_count_today', { val: 0, ack: true });
+
+    // NEU: Aktuelle Laufzeit (seit Einschalten)
+    await adapter.setObjectNotExistsAsync('runtime.current_session', {
+        type: 'state',
+        common: {
+            name: 'Aktuelle Laufzeit (seit Einschalten)',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+            persist: false,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('runtime.current_session', { val: '0h 0m 0s', ack: true });
 
-    await adapter.setObjectNotExistsAsync('runtime.formatted', {
+    // NEU: Gesamtlaufzeit der aktuellen Saison (formatiert)
+    await adapter.setObjectNotExistsAsync('runtime.season_total', {
         type: 'state',
         common: {
-            name: 'Formatierte Laufzeit heute',
+            name: 'Gesamtlaufzeit aktuelle Saison (formatiert)',
             type: 'string',
             role: 'text',
             read: true,
@@ -61,7 +97,9 @@ async function createRuntimeStates(adapter) {
         },
         native: {},
     });
+    await adapter.setStateAsync('runtime.season_total', { val: '0h 0m 0s', ack: true });
 
+    // -------------------------------------------------------------------------
     // --- Kanal circulation ---
     await adapter.setObjectNotExistsAsync('circulation', {
         type: 'channel',

package/lib/stateDefinitions/speechStates.js

@@ -42,7 +42,7 @@ async function createSpeechStates(adapter) {
             type: 'string',
             role: 'text',
             read: true,
-            write: false,
+            write: true,
         },
         native: {},
     });
@@ -80,23 +80,6 @@ async function createSpeechStates(adapter) {
         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 = {

package/main.js

@@ -14,6 +14,8 @@ const consumptionHelper = require('./lib/helpers/consumptionHelper');
 const solarHelper = require('./lib/helpers/solarHelper');
 const frostHelper = require('./lib/helpers/frostHelper');
 const statusHelper = require('./lib/helpers/statusHelper');
+const controlHelper = require('./lib/helpers/controlHelper');
+const debugLogHelper = require('./lib/helpers/debugLogHelper');
 const { createTemperatureStates } = require('./lib/stateDefinitions/temperatureStates');
 const { createPumpStates } = require('./lib/stateDefinitions/pumpStates');
 const { createSolarStates } = require('./lib/stateDefinitions/solarStates');
@@ -23,6 +25,8 @@ const { createRuntimeStates } = require('./lib/stateDefinitions/runtimeStates');
 const { createSpeechStates } = require('./lib/stateDefinitions/speechStates');
 const { createConsumptionStates } = require('./lib/stateDefinitions/consumptionStates');
 const { createStatusStates } = require('./lib/stateDefinitions/statusStates');
+const { createControlStates } = require('./lib/stateDefinitions/controlStates');
+const { createDebugLogStates } = require('./lib/stateDefinitions/debugLogStates');
 
 class Poolcontrol extends utils.Adapter {
     constructor(options) {
@@ -71,6 +75,12 @@ class Poolcontrol extends utils.Adapter {
             ack: true,
         });
 
+        // --- Control States ---
+        await createControlStates(this);
+
+        // --- DebugLog Staets ---
+        await createDebugLogStates(this);
+
         // --- Helper starten ---
         temperatureHelper.init(this);
         timeHelper.init(this);
@@ -81,6 +91,8 @@ class Poolcontrol extends utils.Adapter {
         solarHelper.init(this);
         frostHelper.init(this);
         statusHelper.init(this);
+        controlHelper.init(this);
+        debugLogHelper.init(this);
     }
 
     onUnload(callback) {
@@ -112,6 +124,9 @@ class Poolcontrol extends utils.Adapter {
             if (statusHelper.cleanup) {
                 statusHelper.cleanup();
             }
+            if (controlHelper.cleanup) {
+                controlHelper.cleanup();
+            }
         } catch (e) {
             this.log.warn(`[onUnload] Fehler beim Cleanup: ${e.message}`);
         } finally {
@@ -163,6 +178,11 @@ class Poolcontrol extends utils.Adapter {
         } catch (e) {
             this.log.warn(`[statusHelper] Fehler in handleStateChange: ${e.message}`);
         }
+        if (id.includes('control.')) {
+            controlHelper.handleStateChange(id, state);
+        }
+
+        await debugLogHelper.handleStateChange(id, state);
     }
 }
 

package/package.json

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