iobroker.poolcontrol 0.2.2 → 0.3.1

package/lib/helpers/runtimeHelper.js

@@ -21,9 +21,24 @@ const runtimeHelper = {
     resetTimer: null,
     liveTimer: null, // Timer für Live-Updates
 
-    init(adapter) {
+    /**
+     * Initialisiert den Runtime-Helper.
+     * Führt eine kurze Startverzögerung ein, um sicherzustellen,
+     * dass persistente States nach einer Überinstallation korrekt geladen werden.
+     *
+     * @param {ioBroker.Adapter} adapter - Aktive ioBroker-Adapterinstanz.
+     * @returns {Promise<void>}
+     */
+    async init(adapter) {
         this.adapter = adapter;
 
+        // ------------------------------------------------------
+        // NEU: Kurze Startverzögerung, damit ioBroker persistente States
+        //      vollständig aus der Datenbank laden kann (Überinstallationsschutz)
+        // ------------------------------------------------------
+        this.adapter.log.debug('[runtimeHelper] Warte 3 Sekunden, um persistente States zu laden ...');
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
         // Pumpenschalter überwachen
         this.adapter.subscribeStates('pump.pump_switch');
 
@@ -52,6 +67,13 @@ const runtimeHelper = {
         const seasonRaw = (await this.adapter.getStateAsync('runtime.season_total'))?.val;
         const countRaw = (await this.adapter.getStateAsync('runtime.start_count_today'))?.val;
 
+        // FIX: Falls States leer oder neu angelegt sind, Warnhinweis ausgeben und Werte nicht überschreiben
+        if (!totalRaw && !seasonRaw) {
+            this.adapter.log.info(
+                '[runtimeHelper] Keine gespeicherten Laufzeiten gefunden – möglicherweise neue oder überinstallierte Instanz. Laufzeiten starten bei 0.',
+            );
+        }
+
         // >>> NEU: Formatierten Text (z. B. "3h 12m 5s") in Sekunden umwandeln
         this.runtimeTotal = this._parseFormattedTimeToSeconds(totalRaw);
         this.runtimeToday = this._parseFormattedTimeToSeconds(todayRaw);
@@ -134,18 +156,45 @@ const runtimeHelper = {
             await this.adapter.setStateAsync('runtime.season_total', { val: formattedSeason, ack: true });
             await this.adapter.setStateAsync('runtime.start_count_today', { val: this.startCountToday, ack: true });
 
-            // Umwälzmenge berechnen
-            const pumpLph = (await this.adapter.getStateAsync('pump.pump_power_lph'))?.val || 0;
+            // Poolparameter laden (vor Durchflussprüfung!)
             const poolSize = (await this.adapter.getStateAsync('general.pool_size'))?.val || 0;
             const minCirc = (await this.adapter.getStateAsync('general.min_circulation_per_day'))?.val || 1;
 
-            const dailyTotal = Math.round((effectiveToday / 3600) * pumpLph);
+            // daily_required immer direkt setzen – auch ohne Durchfluss
             const dailyRequired = Math.round(poolSize * minCirc);
+            if (dailyRequired > 0) {
+                await this.adapter.setStateAsync('circulation.daily_required', { val: dailyRequired, ack: true });
+            }
+
+            // Umwälzmenge berechnen
+            // Reeller Durchflusswert aus pump.live.flow_current_lh
+            const liveFlowLh = (await this.adapter.getStateAsync('pump.live.flow_current_lh'))?.val || 0;
+
+            if (liveFlowLh <= 0) {
+                this.adapter.log.debug('[runtimeHelper] Kein Live-Durchflusswert vorhanden, Berechnung übersprungen');
+                return;
+            }
+
+            // Berechnung der realen Tagesumwälzung (Liter)
+            const dailyTotal = Math.round((effectiveToday / 3600) * liveFlowLh);
             const dailyRemaining = Math.max(dailyRequired - dailyTotal, 0);
 
-            await this.adapter.setStateAsync('circulation.daily_total', { val: dailyTotal, ack: true });
-            await this.adapter.setStateAsync('circulation.daily_required', { val: dailyRequired, ack: true });
-            await this.adapter.setStateAsync('circulation.daily_remaining', { val: dailyRemaining, ack: true });
+            // Bestehende Werte für Total/Remaining laden
+            const oldTotal = (await this.adapter.getStateAsync('circulation.daily_total'))?.val || 0;
+            const oldRemaining = (await this.adapter.getStateAsync('circulation.daily_remaining'))?.val || 0;
+
+            // Nur schreiben, wenn tatsächlich sinnvolle Livewerte vorliegen
+            if (liveFlowLh > 0 && dailyTotal > 0) {
+                await this.adapter.setStateAsync('circulation.daily_total', { val: dailyTotal, ack: true });
+                await this.adapter.setStateAsync('circulation.daily_remaining', { val: dailyRemaining, ack: true });
+                this.adapter.log.debug(
+                    `[runtimeHelper] Circulation-Werte aktualisiert (Total=${dailyTotal}, Required=${dailyRequired}, Remaining=${dailyRemaining})`,
+                );
+            } else {
+                this.adapter.log.debug(
+                    `[runtimeHelper] Keine gültigen Live-Daten – bestehende Werte bleiben erhalten (Total=${oldTotal}, Required=${dailyRequired}, Remaining=${oldRemaining})`,
+                );
+            }
         } catch (err) {
             this.adapter.log.warn(`[runtimeHelper] Fehler beim Update der States: ${err.message}`);
         }
@@ -194,12 +243,30 @@ const runtimeHelper = {
         nextMidnight.setHours(24, 0, 0, 0);
         const msUntilMidnight = nextMidnight - now;
 
-        this.resetTimer = setTimeout(() => {
+        this.resetTimer = setTimeout(async () => {
             this.runtimeToday = 0;
             this.startCountToday = 0;
             this.lastOn = this.isRunning ? Date.now() : null;
+
+            // Laufzeiten zurücksetzen
             this._updateStates();
+
+            // --- NEU: Circulation-Werte um Mitternacht zurücksetzen ---
+            await this.adapter.setStateAsync('circulation.daily_total', { val: 0, ack: true });
+
+            // daily_required neu berechnen (optional, falls sich Poolgröße geändert hat)
+            const poolSize = (await this.adapter.getStateAsync('general.pool_size'))?.val || 0;
+            const minCirc = (await this.adapter.getStateAsync('general.min_circulation_per_day'))?.val || 1;
+            const dailyRequired = Math.round(poolSize * minCirc);
+            await this.adapter.setStateAsync('circulation.daily_required', { val: dailyRequired, ack: true });
+
+            // 👉 daily_remaining neue berechnen auf Grundlage von daily_required
+            await this.adapter.setStateAsync('circulation.daily_remaining', { val: dailyRequired, ack: true });
+
+            // Nächsten Reset planen
             this._scheduleDailyReset();
+
+            this.adapter.log.debug('[runtimeHelper] Tagesreset (Runtime + Circulation) ausgeführt.');
         }, msUntilMidnight);
     },
 

package/lib/helpers/statusHelper.js

@@ -12,6 +12,7 @@ const statusHelper = {
     adapter: null,
     midnightTimer: null,
     pumpOn: null, // interner Merker für Pumpenstatus
+    _lastSummaryUpdate: 0, // FIX: Zeitstempel für Throttle-Schutz
 
     init(adapter) {
         this.adapter = adapter;
@@ -95,8 +96,23 @@ const statusHelper = {
         await this.updateSummary();
     },
 
+    // FIX: Hilfsfunktion zur sicheren Formatierung
+    safeValue(v, digits = 1) {
+        if (v == null || isNaN(v)) {
+            return '–';
+        }
+        return Number(v).toFixed(digits);
+    },
+
     async updateSummary() {
         try {
+            // FIX: Throttle - Mehrfachupdates innerhalb 1 Sekunde vermeiden
+            if (Date.now() - this._lastSummaryUpdate < 1000) {
+                this.adapter.log.debug('[statusHelper] UpdateSummary übersprungen (Throttle)');
+                return;
+            }
+            this._lastSummaryUpdate = Date.now();
+
             // Werte laden
             const pumpStatus = (await this.adapter.getStateAsync('pump.status'))?.val || 'unbekannt';
             const pumpMode = (await this.adapter.getStateAsync('pump.mode'))?.val || 'unknown';
@@ -112,32 +128,41 @@ const statusHelper = {
             // Laufzeit formatieren
             const h = Math.floor(runtimeToday / 3600);
             const m = Math.floor((runtimeToday % 3600) / 60);
-            const runtimeFormatted = `${h}h ${m}m`;
+            const runtimeFormatted = isNaN(h) || isNaN(m) ? '0h 00m' : `${h}h ${m}m`; // FIX: Schutz gegen NaN
 
             // Umwälzungsquote
             let circulationPct = 0;
             if (dailyRequired > 0) {
                 circulationPct = Math.round((dailyTotal / dailyRequired) * 100);
             }
+            if (isNaN(circulationPct)) {
+                circulationPct = 0;
+            } // FIX: NaN-Absicherung
 
             // Text bauen
             let text = `Pumpe: ${pumpStatus}`;
             if (pumpMode && pumpMode !== 'unknown') {
                 text += ` (Modus: ${pumpMode})`;
             }
+
+            const safe = this.safeValue.bind(this); // FIX: Kurzreferenz
             if (poolTemp != null) {
-                text += `. Pool: ${poolTemp.toFixed(1)} °C`;
+                text += `. Pool: ${safe(poolTemp)} °C`;
             }
             if (collectorTemp != null) {
-                text += `, Kollektor: ${collectorTemp.toFixed(1)} °C`;
+                text += `, Kollektor: ${safe(collectorTemp)} °C`;
             }
             if (outsideTemp != null) {
-                text += `, Außentemperatur: ${outsideTemp.toFixed(1)} °C`;
+                text += `, Außentemperatur: ${safe(outsideTemp)} °C`;
             }
             text += `. Tageslaufzeit: ${runtimeFormatted} (${circulationPct}% der Soll-Umwälzung).`;
 
-            // In States schreiben
-            await this.adapter.setStateAsync('status.summary', { val: text, ack: true });
+            // In States schreiben (nur bei Änderung)
+            const current = (await this.adapter.getStateAsync('status.summary'))?.val;
+            if (current !== text) {
+                await this.adapter.setStateAsync('status.summary', { val: text, ack: true });
+            }
+
             await this.adapter.setStateAsync('status.last_summary_update', {
                 val: new Date().toISOString(),
                 ack: true,
@@ -147,10 +172,10 @@ const statusHelper = {
             const json = {
                 pump: pumpStatus,
                 mode: pumpMode,
-                pool: poolTemp,
-                collector: collectorTemp,
-                outside: outsideTemp,
-                runtime_today: runtimeToday,
+                pool: poolTemp ?? null,
+                collector: collectorTemp ?? null,
+                outside: outsideTemp ?? null,
+                runtime_today: runtimeToday ?? 0,
                 runtime_formatted: runtimeFormatted,
                 circulation_pct: circulationPct,
             };

package/lib/stateDefinitions/controlStates.js

@@ -36,7 +36,7 @@ async function createControlStates(adapter) {
             native: {},
         });
 
-        // State: control.season.active
+        // State: control.season.active (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.season.active', {
             type: 'state',
             common: {
@@ -47,15 +47,21 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: false,
+                persist: true, // dauerhaft speichern
             },
             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}`);
+        const existingSeasonActive = await adapter.getStateAsync('control.season.active');
+        if (
+            existingSeasonActive === null ||
+            existingSeasonActive.val === null ||
+            existingSeasonActive.val === undefined
+        ) {
+            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
@@ -100,7 +106,7 @@ async function createControlStates(adapter) {
         });
         await adapter.setStateAsync('control.pump.backwash_active', { val: false, ack: true });
 
-        // Rückspülungsdauer
+        // Rückspülungsdauer (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.pump.backwash_duration', {
             type: 'state',
             common: {
@@ -113,12 +119,20 @@ async function createControlStates(adapter) {
                 def: 1,
                 min: 1,
                 max: 60,
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.pump.backwash_duration', { val: 1, ack: true });
+        const existingBackwashDuration = await adapter.getStateAsync('control.pump.backwash_duration');
+        if (
+            existingBackwashDuration === null ||
+            existingBackwashDuration.val === null ||
+            existingBackwashDuration.val === undefined
+        ) {
+            await adapter.setStateAsync('control.pump.backwash_duration', { val: 1, ack: true });
+        }
 
-        // >>> NEU: Rückspülerinnerung
+        // Rückspülerinnerung aktiv (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.pump.backwash_reminder_active', {
             type: 'state',
             common: {
@@ -129,11 +143,16 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: false,
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.pump.backwash_reminder_active', { val: false, ack: true });
+        const existingBackwashRem = await adapter.getStateAsync('control.pump.backwash_reminder_active');
+        if (existingBackwashRem === null || existingBackwashRem.val === null || existingBackwashRem.val === undefined) {
+            await adapter.setStateAsync('control.pump.backwash_reminder_active', { val: false, ack: true });
+        }
 
+        // Rückspülintervall (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.pump.backwash_interval_days', {
             type: 'state',
             common: {
@@ -147,10 +166,18 @@ async function createControlStates(adapter) {
                 def: 7,
                 min: 1,
                 max: 60,
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.pump.backwash_interval_days', { val: 7, ack: true });
+        const existingBackwashInterval = await adapter.getStateAsync('control.pump.backwash_interval_days');
+        if (
+            existingBackwashInterval === null ||
+            existingBackwashInterval.val === null ||
+            existingBackwashInterval.val === undefined
+        ) {
+            await adapter.setStateAsync('control.pump.backwash_interval_days', { val: 7, ack: true });
+        }
 
         await adapter.setObjectNotExistsAsync('control.pump.backwash_last_date', {
             type: 'state',
@@ -181,7 +208,6 @@ async function createControlStates(adapter) {
         });
         await adapter.setStateAsync('control.pump.backwash_required', { val: false, ack: true });
 
-        // ---------------------------------------------------------------------
         // Wartungsmodus aktiv
         await adapter.setObjectNotExistsAsync('control.pump.maintenance_active', {
             type: 'state',
@@ -198,7 +224,7 @@ async function createControlStates(adapter) {
         });
         await adapter.setStateAsync('control.pump.maintenance_active', { val: false, ack: true });
 
-        // Benachrichtigungen aktivieren
+        // Benachrichtigungen aktivieren (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.pump.notifications_enabled', {
             type: 'state',
             common: {
@@ -209,10 +235,14 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: true,
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.pump.notifications_enabled', { val: true, ack: true });
+        const existingNoti = await adapter.getStateAsync('control.pump.notifications_enabled');
+        if (existingNoti === null || existingNoti.val === null || existingNoti.val === undefined) {
+            await adapter.setStateAsync('control.pump.notifications_enabled', { val: true, ack: true });
+        }
 
         // ---------------------------------------------------------------------
         // Channel: control.energy
@@ -252,7 +282,7 @@ async function createControlStates(adapter) {
             native: {},
         });
 
-        // State: Modus (auto/manual/notify/off)
+        // Modus der Umwälzungsprüfung
         await adapter.setObjectNotExistsAsync('control.circulation.mode', {
             type: 'state',
             common: {
@@ -263,6 +293,7 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: 'notify',
+                persist: true,
                 states: {
                     auto: 'Automatik',
                     manual: 'Manuell',
@@ -272,9 +303,14 @@ async function createControlStates(adapter) {
             },
             native: {},
         });
+        try {
+            await adapter.extendObjectAsync('control.circulation.mode', { common: { persist: true } });
+        } catch (err) {
+            adapter.log.warn(`[controlStates] persist-Flag für control.circulation.mode nicht gesetzt: ${err.message}`);
+        }
         await adapter.setStateAsync('control.circulation.mode', { val: 'notify', ack: true });
 
-        // State: Prüfzeitpunkt
+        // Prüfzeitpunkt (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.circulation.check_time', {
             type: 'state',
             common: {
@@ -285,12 +321,16 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: '18:00',
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.circulation.check_time', { val: '18:00', ack: true });
+        const existingCheckTime = await adapter.getStateAsync('control.circulation.check_time');
+        if (existingCheckTime === null || existingCheckTime.val === null || existingCheckTime.val === undefined) {
+            await adapter.setStateAsync('control.circulation.check_time', { val: '18:00', ack: true });
+        }
 
-        // State: letzter Bericht
+        // letzter Bericht
         await adapter.setObjectNotExistsAsync('control.circulation.last_report', {
             type: 'state',
             common: {
@@ -307,6 +347,30 @@ async function createControlStates(adapter) {
     } catch (err) {
         adapter.log.error(`[controlStates] Fehler beim Erstellen der Control-States: ${err.message}`);
     }
+    // ------------------------------------------------------
+    // Control – Hardware
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('control.hardware', {
+        type: 'channel',
+        common: { name: 'Hardware-Steuerung (externe Boxen)' },
+        native: {},
+    });
+
+    // TempBox aktivieren/deaktivieren
+    await adapter.setObjectNotExistsAsync('control.hardware.use_tempbox', {
+        type: 'state',
+        common: {
+            name: 'Externe Temperaturbox verwenden',
+            desc: 'Wenn aktiviert, nutzt PoolControl die Werte der externen TempBox anstelle der manuellen Temperatursensoren.',
+            type: 'boolean',
+            role: 'switch',
+            def: false,
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
 }
 
 module.exports = { createControlStates };

package/lib/stateDefinitions/hardwareStates.js

@@ -0,0 +1,184 @@
+'use strict';
+
+/**
+ * hardwareStates.js – Bereich für externe Boxen (TempBox, TasterBox usw.)
+ * Überarbeitete Version: Checkboxen & settings_enabled entfernt
+ */
+
+/**
+ * Erstellt die Objektstruktur für alle Hardware-Boxen (z. B. TempBox, TasterBox).
+ * Diese Version enthält keine Instanz-Checkboxen oder settings_enabled States mehr.
+ *
+ * @param {object} adapter - ioBroker Adapterinstanz
+ */
+async function createHardwareStates(adapter) {
+    try {
+        // ------------------------------------------------------
+        // Oberordner: Hardware
+        // ------------------------------------------------------
+        await adapter.setObjectNotExistsAsync('hardware', {
+            type: 'channel',
+            common: { name: 'Hardware-Boxen (Sensoren & externe Geräte)' },
+            native: {},
+        });
+
+        // ======================================================
+        // TEMPERATUR-BOX (ESP32)
+        // ======================================================
+        await adapter.setObjectNotExistsAsync('hardware.tempbox', {
+            type: 'channel',
+            common: { name: 'Temperatur-Box (ESP32)' },
+            native: {},
+        });
+
+        // Statusmeldung: Erkennung/Verbindung
+        await adapter.setObjectNotExistsAsync('hardware.tempbox.status_detected', {
+            type: 'state',
+            common: {
+                name: 'Box-Status',
+                desc: 'Status der automatischen Erkennung der Temperatur-Box (z. B. verbunden/nicht gefunden)',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                def: 'nicht gefunden',
+            },
+            native: {},
+        });
+
+        // LED-Status
+        await adapter.setObjectNotExistsAsync('hardware.tempbox.status_led', {
+            type: 'state',
+            common: {
+                name: 'LED-Status (TempBox)',
+                desc: 'Status der blauen LED auf der Temperatur-Box',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                def: 'unbekannt',
+            },
+            native: {},
+        });
+
+        // Firmware-Version
+        await adapter.setObjectNotExistsAsync('hardware.tempbox.fw_version', {
+            type: 'state',
+            common: {
+                name: 'Box-Firmware-Version',
+                desc: 'Firmware-Version der Temperatur-Box (ESP32)',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                def: '',
+            },
+            native: {},
+        });
+
+        // Box-ID
+        await adapter.setObjectNotExistsAsync('hardware.tempbox.box_id', {
+            type: 'state',
+            common: {
+                name: 'Box-ID (TempBox)',
+                desc: 'Eindeutige Kennung der Temperatur-Box (z. B. PC-TB-01)',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                def: '',
+            },
+            native: {},
+        });
+
+        // Sensorsystem-Status
+        await adapter.setObjectNotExistsAsync('hardware.tempbox.status_sensors', {
+            type: 'state',
+            common: {
+                name: 'Sensorsystem-Status',
+                desc: 'Meldung zum Zustand der Temperatursensoren in der TempBox',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                def: 'keine Daten',
+            },
+            native: {},
+        });
+
+        // ------------------------------------------------------
+        // TASTER-BOX (ESP32)
+        // ------------------------------------------------------
+        await adapter.setObjectNotExistsAsync('hardware.tasterbox', {
+            type: 'channel',
+            common: { name: 'Taster-Box (ESP32)' },
+            native: {},
+        });
+
+        // Statusmeldung
+        await adapter.setObjectNotExistsAsync('hardware.tasterbox.status_detected', {
+            type: 'state',
+            common: {
+                name: 'Box-Status',
+                desc: 'Status der automatischen Erkennung der Taster-Box (z. B. verbunden/nicht gefunden)',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                def: 'nicht gefunden',
+            },
+            native: {},
+        });
+
+        // Firmware-Version
+        await adapter.setObjectNotExistsAsync('hardware.tasterbox.fw_version', {
+            type: 'state',
+            common: {
+                name: 'Box-Firmware-Version',
+                desc: 'Firmware-Version der Taster-Box (ESP32)',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                def: '',
+            },
+            native: {},
+        });
+
+        // Box-ID
+        await adapter.setObjectNotExistsAsync('hardware.tasterbox.box_id', {
+            type: 'state',
+            common: {
+                name: 'Box-ID (TasterBox)',
+                desc: 'Eindeutige Kennung der Taster-Box (z. B. PC-TB-02)',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                def: '',
+            },
+            native: {},
+        });
+
+        // Status der Taster
+        await adapter.setObjectNotExistsAsync('hardware.tasterbox.status_buttons', {
+            type: 'state',
+            common: {
+                name: 'Status der Taster',
+                desc: 'Textmeldung zum Zustand der Taster (z. B. gedrückt, losgelassen, keine Verbindung)',
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                def: 'unbekannt',
+            },
+            native: {},
+        });
+
+        adapter.log.debug('[hardwareStates] Hardware-State-Struktur erfolgreich angelegt (bereinigt ohne Checkboxen).');
+    } catch (err) {
+        adapter.log.error(`[hardwareStates] Fehler beim Anlegen der Hardware-States: ${err.message}`);
+    }
+}
+
+module.exports = { createHardwareStates };