iobroker.poolcontrol 0.7.2 → 0.7.3

package/io-package.json

@@ -1,8 +1,21 @@
 {
   "common": {
     "name": "poolcontrol",
-    "version": "0.7.2",
+    "version": "0.7.3",
     "news": {
+       "0.7.3": {
+         "en": "Fix in seasonal greetings: Christmas greeting now only appears between December 20 and 27. Incorrect early activation has been corrected.",
+         "de": "Fix bei den saisonalen Grüßen: Weihnachtsgruß erscheint nun korrekt nur vom 20. bis 27. Dezember. Fehlerhafte frühzeitige Aktivierung wurde behoben.",
+         "ru": "Исправление сезонных поздравлений: Рождественское поздравление теперь отображается только с 20 по 27 декабря. Ошибочное раннее срабатывание исправлено.",
+         "pt": "Correção nos cumprimentos sazonais: A saudação de Natal agora aparece corretamente apenas entre 20 e 27 de dezembro. Ativação incorreta antecipada foi corrigida.",
+         "nl": "Fix in seizoensgroeten: Kerstgroet verschijnt nu correct alleen van 20 t/m 27 december. Onjuiste vroege activering is verholpen.",
+         "fr": "Correction des messages saisonniers : le message de Noël apparaît désormais uniquement du 20 au 27 décembre. L’activation prématurée incorrecte a été corrigée.",
+         "it": "Correzione nei saluti stagionali: l’augurio di Natale ora appare correttamente solo dal 20 al 27 dicembre. Corretto il problema dell'attivazione anticipata.",
+         "es": "Corrección en los saludos estacionales: el mensaje de Navidad ahora aparece correctamente solo del 20 al 27 de diciembre. Se corrigió la activación anticipada incorrecta.",
+         "pl": "Poprawka pozdrowień sezonowych: życzenia świąteczne pojawiają się teraz prawidłowo tylko między 20 a 27 grudnia. Błędna przedwczesna aktywacja została naprawiona.",
+         "uk": "Виправлено сезонні вітання: Різдвяне привітання тепер з’являється лише з 20 по 27 грудня. Помилкове передчасне спрацьовування виправлено.",
+         "zh-cn": "修复季节性问候：圣诞问候现在仅在 12 月 20 日至 27 日之间显示。已修复错误的提前触发问题。"
+       },
        "0.7.2": {
          "en": "Added new info system: The adapter now writes seasonal greetings and the installed adapter version to info.* states. Includes automatic daily refresh at 00:01 and full Easter date calculation.",
          "de": "Neues Info-System hinzugefügt: Der Adapter schreibt nun saisonale Grüße und die installierte Adapterversion in die info.* States. Enthält eine automatische tägliche Aktualisierung um 00:01 sowie eine vollständige Oster-Berechnung.",
@@ -80,18 +93,6 @@
          "pl": "Poprawka cotygodniowego, comiesięcznego i corocznego resetu w consumptionHelper",
          "uk": "Виправлення щотижневого, щомісячного та щорічного скидання в consumptionHelper",
          "zh-cn": "修复 consumptionHelper 中每周、每月和每年重置的问题"
-       },
-       "0.6.2": {
-         "en": "UI refinement and admin interface improvements. Added image integration ('Egon in blue overalls') for visual identification. Speech system extended with Alexa output time configuration. Cleaned and optimized jsonConfig with section headers for improved clarity.",
-         "de": "Oberflächenüberarbeitung und Verbesserungen der Admin-Ansicht. Bildintegration ('Egon im Blaumann') zur visuellen Wiedererkennung hinzugefügt. Sprachsystem um konfigurierbare Alexa-Ausgabezeiten erweitert. jsonConfig mit Abschnittsüberschriften bereinigt und übersichtlicher gestaltet.",
-         "ru": "Улучшение интерфейса и доработка административной панели. Добавлено изображение ('Эгон в синем комбинезоне') для визуальной идентификации. Расширена система речи с настройкой времени вывода Alexa. Очищена и оптимизирована jsonConfig с заголовками разделов для лучшей читаемости.",
-         "pt": "Aprimoramento da interface e melhorias na administração. Adicionada imagem ('Egon de macacão azul') para identificação visual. Sistema de fala ampliado com configuração de horários de saída Alexa. jsonConfig limpa e otimizada com cabeçalhos de seção para melhor clareza.",
-         "nl": "UI verfijnd en verbeteringen in het beheerpaneel. Afbeelding ('Egon in blauwe overall') toegevoegd voor visuele herkenning. Spraaksysteem uitgebreid met Alexa-uitvoertijdaanpassing. jsonConfig opgeschoond en overzichtelijker gemaakt met sectiekoppen.",
-         "fr": "Amélioration de l'interface utilisateur et du panneau d'administration. Image ajoutée ('Egon en bleu de travail') pour identification visuelle. Système vocal étendu avec configuration des heures de sortie Alexa. jsonConfig nettoyé et optimisé avec en-têtes de section pour plus de clarté.",
-         "it": "Raffinamento dell'interfaccia e miglioramenti al pannello di amministrazione. Aggiunta l'immagine ('Egon in tuta blu') per l'identificazione visiva. Sistema vocale ampliato con configurazione degli orari di uscita Alexa. jsonConfig ripulito e ottimizzato con intestazioni di sezione per maggiore chiarezza.",
-         "es": "Refinamiento de la interfaz y mejoras en el panel de administración. Se agregó imagen ('Egon con mono azul') para identificación visual. Sistema de voz ampliado con configuración de horarios de salida de Alexa. jsonConfig limpiado y optimizado con encabezados de sección para mayor claridad.",
-         "pl": "Udoskonalenie interfejsu i panelu administracyjnego. Dodano obraz ('Egon w niebieskim kombinezonie') dla wizualnej identyfikacji. Rozszerzono system mowy o konfigurację czasu wyjścia Alexa. Wyczyczono i zoptymalizowano jsonConfig z nagłówkami sekcji dla lepszej przejrzystości.",
-         "zh-cn": "改进了界面和管理界面。添加了图像（'蓝色工作服的Egon'）以实现视觉识别。语音系统扩展了Alexa输出时间配置。清理并优化了带有章节标题的jsonConfig，使其更清晰。"
        }
 	},
     "titleLang": {

package/lib/helpers/aiHelper.js

@@ -0,0 +1,916 @@
+'use strict';
+/* eslint-disable jsdoc/require-param-description */
+/* eslint-disable jsdoc/require-returns-description */
+
+/**
+ * aiHelper
+ * --------------------------------------------------------------
+ * Zentraler KI-Helper für PoolControl.
+ *
+ * Nutzt die States aus aiStates.js:
+ *   ai.switches.*
+ *   ai.schedule.*
+ *   ai.outputs.*
+ *
+ * Funktionen:
+ *   - Liest Geodaten aus system.config (Latitude/Longitude)
+ *   - Ruft Wetterdaten von Open-Meteo ab (bei Bedarf, max. 4x/Tag – je Modul)
+ *   - Erzeugt Textausgaben:
+ *       ai.outputs.weather_advice
+ *       ai.outputs.daily_summary
+ *       ai.outputs.pool_tips
+ *       ai.outputs.weekend_summary
+ *       ai.outputs.last_message
+ *   - Optional: legt Texte in speech.queue für Sprachausgabe
+ *
+ * Wichtige Schalter:
+ *   - ai.switches.enabled              → globaler KI-Schalter
+ *   - ai.switches.allow_speech         → Sprachausgabe erlaubt
+ *   - ai.switches.weather_advice_enabled
+ *   - ai.switches.daily_summary_enabled
+ *   - ai.switches.daily_pool_tips_enabled
+ *   - ai.switches.weekend_summary_enabled
+ *   - ai.switches.debug_mode
+ *
+ * Zeitsteuerung (HH:MM, lokal):
+ *   - ai.schedule.weather_advice_time
+ *   - ai.schedule.daily_summary_time
+ *   - ai.schedule.daily_pool_tips_time
+ *   - ai.schedule.weekend_summary_time
+ */
+
+const https = require('https');
+
+const aiHelper = {
+    adapter: null,
+    timers: [],
+    _lastScheduleValues: {}, // NEU: merkt sich letzte Zeitwerte
+    _debugMode: false,
+
+    /**
+     * Initialisiert den AI-Helper (Timer + Grundkonfiguration).
+     *
+     * @param {import('iobroker').Adapter} adapter
+     */
+    async init(adapter) {
+        this.adapter = adapter;
+        this.adapter.log.info('[aiHelper] Initialisierung gestartet');
+
+        // Ersten Settings-Load + Timeraufbau
+        await this._refreshTimers();
+
+        this.adapter.log.info('[aiHelper] Initialisierung abgeschlossen');
+    },
+
+    /**
+     * Aufräumen beim Adapter-Stop.
+     */
+    cleanup() {
+        this._clearTimers();
+        this.adapter && this.adapter.log.debug('[aiHelper] Cleanup abgeschlossen (Timer gestoppt)');
+    },
+
+    /**
+     * Reagiert auf State-Änderungen (ai.switches.*, ai.schedule.*),
+     * damit Schalter und Zeiten ohne Neustart wirksam werden.
+     *
+     * @param {string} id
+     * @param {ioBroker.State | null} state
+     */
+    async handleStateChange(id, state) {
+        if (!this.adapter) {
+            return;
+        }
+        if (!state) {
+            return;
+        }
+
+        // Änderungen vom Adapter selbst ignorieren
+        if (state.from && state.from.startsWith(`system.adapter.${this.adapter.name}.`)) {
+            return;
+        }
+
+        // ---------------------------------------------------------
+        // FIX 1: Nur AI-States weiterverarbeiten
+        // ---------------------------------------------------------
+        if (!id.includes('.ai.')) {
+            // Alle Nicht-AI-States ignorieren → verhindert Log-Flut
+            return;
+        }
+
+        // ---------------------------------------------------------
+        // FIX 2: Uhrzeitänderungen IMMER erkennen und loggen
+        // ---------------------------------------------------------
+        if (id.includes('.ai.schedule.')) {
+            const oldVal = this._lastScheduleValues[id];
+            const newVal = state.val;
+
+            this.adapter.log.info(
+                `[aiHelper] Uhrzeit geändert: ${id}: ${oldVal || '(kein vorheriger Wert)'} → ${newVal}`,
+            );
+
+            // neuen Wert speichern
+            this._lastScheduleValues[id] = newVal;
+
+            // Timer neu aufbauen
+            await this._refreshTimers();
+            return;
+        }
+
+        // ---------------------------------------------------------
+        // FIX 3: Schalteränderungen immer melden
+        // ---------------------------------------------------------
+        if (id.includes('.ai.switches.')) {
+            this.adapter.log.info(`[aiHelper] Schalter geändert: ${id} = ${state.val} – Timer werden neu aufgebaut`);
+
+            await this._refreshTimers();
+            return;
+        }
+    },
+
+    // ---------------------------------------------------------------------
+    // Timer-Verwaltung
+    // ---------------------------------------------------------------------
+
+    /**
+     * Bestehende Timer stoppen.
+     */
+    _clearTimers() {
+        for (const t of this.timers) {
+            clearInterval(t);
+        }
+        this.timers = [];
+    },
+
+    /**
+     * Liest alle relevanten States und baut die Timer neu auf.
+     */
+    async _refreshTimers() {
+        this._clearTimers();
+
+        const aiEnabled = await this._getBool('ai.switches.enabled', false);
+        this._debugMode = await this._getBool('ai.switches.debug_mode', false);
+
+        if (!aiEnabled) {
+            this.adapter.log.info('[aiHelper] KI ist deaktiviert (ai.switches.enabled = false) – keine Timer aktiv');
+            return;
+        }
+
+        this.adapter.log.info('[aiHelper] KI ist aktiv – Timer werden gesetzt');
+
+        // --- Wetterhinweise ---
+        const weatherEnabled = await this._getBool('ai.switches.weather_advice_enabled', false);
+        if (weatherEnabled) {
+            const time = await this._getTimeOrDefault('ai.schedule.weather_advice_time', '08:00');
+            this._createDailyTimer(time, async () => {
+                await this._runWeatherAdvice();
+            });
+            this.adapter.log.info(
+                `[aiHelper] Wetterhinweis-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
+            );
+        }
+
+        // --- Tägliche Zusammenfassung ---
+        const summaryEnabled = await this._getBool('ai.switches.daily_summary_enabled', false);
+        if (summaryEnabled) {
+            const time = await this._getTimeOrDefault('ai.schedule.daily_summary_time', '09:00');
+            this._createDailyTimer(time, async () => {
+                await this._runDailySummary();
+            });
+            this.adapter.log.info(
+                `[aiHelper] Daily-Summary-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
+            );
+        }
+
+        // --- Tägliche Pool-Tipps ---
+        const tipsEnabled = await this._getBool('ai.switches.daily_pool_tips_enabled', false);
+        if (tipsEnabled) {
+            const time = await this._getTimeOrDefault('ai.schedule.daily_pool_tips_time', '10:00');
+            this._createDailyTimer(time, async () => {
+                await this._runDailyPoolTips();
+            });
+            this.adapter.log.info(
+                `[aiHelper] Pool-Tipps-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
+            );
+        }
+
+        // --- Wochenend-Zusammenfassung ---
+        const weekendEnabled = await this._getBool('ai.switches.weekend_summary_enabled', false);
+        if (weekendEnabled) {
+            const time = await this._getTimeOrDefault('ai.schedule.weekend_summary_time', '18:00');
+            this._createDailyTimer(time, async () => {
+                await this._runWeekendSummary();
+            });
+            this.adapter.log.info(
+                `[aiHelper] Wochenend-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
+            );
+        }
+    },
+
+    /**
+     * Erzeugt einen täglichen Timer für HH:MM (lokale Zeit).
+     * Prüft minütlich, ob die Zeit erreicht ist.
+     *
+     * @param {{hour:number,minute:number}} timeObj
+     * @param {() => Promise<void>} callback
+     */
+    _createDailyTimer(timeObj, callback) {
+        const { hour, minute } = timeObj;
+        const timer = setInterval(async () => {
+            const now = new Date();
+
+            // --- NEU: Nachträgliche Ausführung, falls Zeit knapp verpasst wurde ---
+            const diffMinutes = now.getHours() * 60 + now.getMinutes() - (hour * 60 + minute);
+
+            if (diffMinutes > 0 && diffMinutes <= 2) {
+                try {
+                    await callback();
+                    this.adapter.log.info('[aiHelper] Zeit knapp verpasst – nachträgliche Ausführung durchgeführt');
+                } catch (err) {
+                    this.adapter.log.warn(`[aiHelper] Fehler bei nachträglicher Ausführung: ${err.message}`);
+                }
+            }
+
+            if (now.getHours() === hour && now.getMinutes() === minute) {
+                this.adapter.log.info(
+                    `[aiHelper] Timer ausgelöst: ${hour}:${String(minute).padStart(2, '0')} → Callback wird ausgeführt`,
+                ); // NEU
+
+                try {
+                    await callback();
+                } catch (err) {
+                    this.adapter.log.warn(`[aiHelper] Fehler im Timer-Callback: ${err.message}`);
+                }
+            }
+        }, 60 * 1000); // jede Minute prüfen
+
+        this.timers.push(timer);
+    },
+
+    // ---------------------------------------------------------------------
+    // Hauptfunktionen – Module
+    // ---------------------------------------------------------------------
+
+    /**
+     * 1) Wetterhinweise (ai.outputs.weather_advice)
+     */
+    async _runWeatherAdvice() {
+        try {
+            const geo = await this._loadGeoLocation();
+            if (!geo) {
+                this.adapter.log.info('[aiHelper] Wetterhinweis abgebrochen – keine Geodaten verfügbar');
+                return;
+            }
+
+            const weather = await this._fetchWeather(geo.lat, geo.lon);
+            if (!weather) {
+                this.adapter.log.info('[aiHelper] Wetterhinweis abgebrochen – keine Wetterdaten');
+                return;
+            }
+
+            const text = this._buildWeatherAdviceText(weather);
+            await this._writeOutput('weather_advice', text);
+            await this._maybeSpeak(text);
+
+            this.adapter.log.info('[aiHelper] Neuer Wetterhinweis erzeugt');
+        } catch (err) {
+            this.adapter.log.warn(`[aiHelper] Fehler bei _runWeatherAdvice(): ${err.message}`);
+        }
+    },
+
+    /**
+     * 2) Tägliche Zusammenfassung (ai.outputs.daily_summary)
+     */
+    async _runDailySummary() {
+        try {
+            const geo = await this._loadGeoLocation();
+            const weather = geo ? await this._fetchWeather(geo.lat, geo.lon) : null;
+
+            const seasonActive = await this._getBool('status.season_active', false);
+            const pumpOn = await this._getBool('pump.pump_switch', false);
+            const pumpMode = await this._getString('pump.mode', 'auto');
+            const surfaceTemp = await this._getNumber('temperature.surface.current', null);
+
+            const text = this._buildDailySummaryText({
+                weather,
+                seasonActive,
+                pumpOn,
+                pumpMode,
+                surfaceTemp,
+            });
+
+            await this._writeOutput('daily_summary', text);
+            await this._maybeSpeak(text);
+
+            this.adapter.log.info('[aiHelper] Neue Tageszusammenfassung erzeugt');
+        } catch (err) {
+            this.adapter.log.warn(`[aiHelper] Fehler bei _runDailySummary(): ${err.message}`);
+        }
+    },
+
+    /**
+     * 3) Tägliche Pool-Tipps (ai.outputs.pool_tips)
+     */
+    async _runDailyPoolTips() {
+        try {
+            const geo = await this._loadGeoLocation();
+            const weather = geo ? await this._fetchWeather(geo.lat, geo.lon) : null;
+            const seasonActive = await this._getBool('status.season_active', false);
+
+            const text = this._buildPoolTipsText(weather, seasonActive);
+
+            await this._writeOutput('pool_tips', text);
+            await this._maybeSpeak(text);
+
+            this.adapter.log.info('[aiHelper] Neue Pool-Tipps erzeugt');
+        } catch (err) {
+            this.adapter.log.warn(`[aiHelper] Fehler bei _runDailyPoolTips(): ${err.message}`);
+        }
+    },
+
+    /**
+     * 4) Wochenend-Zusammenfassung (ai.outputs.weekend_summary)
+     */
+    async _runWeekendSummary() {
+        try {
+            const now = new Date();
+            const weekday = now.getDay(); // 0=So, 1=Mo, ..., 5=Fr, 6=Sa
+
+            // Nur Freitag oder Samstag sinnvoll
+            if (weekday !== 5 && weekday !== 6) {
+                this.adapter.log.info(
+                    '[aiHelper] Wochenend-Zusammenfassung übersprungen – heute ist weder Freitag noch Samstag',
+                );
+                return;
+            }
+
+            const geo = await this._loadGeoLocation();
+            const weather = geo ? await this._fetchWeather(geo.lat, geo.lon) : null;
+            const seasonActive = await this._getBool('status.season_active', false);
+
+            const text = this._buildWeekendSummaryText(weather, seasonActive, weekday);
+
+            await this._writeOutput('weekend_summary', text);
+            await this._maybeSpeak(text);
+
+            this.adapter.log.info('[aiHelper] Neue Wochenend-Zusammenfassung erzeugt');
+        } catch (err) {
+            this.adapter.log.warn(`[aiHelper] Fehler bei _runWeekendSummary(): ${err.message}`);
+        }
+    },
+
+    // ---------------------------------------------------------------------
+    // Geodaten + Wetter
+    // ---------------------------------------------------------------------
+
+    /**
+     * Lädt Geokoordinaten aus system.config.
+     *
+     * @returns {{lat:number,lon:number}|null}
+     */
+    async _loadGeoLocation() {
+        try {
+            const latState = await this.adapter.getForeignStateAsync('system.config.latitude');
+            const lonState = await this.adapter.getForeignStateAsync('system.config.longitude');
+
+            if (!latState || !lonState || latState.val == null || lonState.val == null) {
+                this.adapter.log.warn(
+                    '[aiHelper] Geodaten in system.config nicht gesetzt – bitte im Admin konfigurieren',
+                );
+                return null;
+            }
+
+            const lat = Number(latState.val);
+            const lon = Number(lonState.val);
+
+            if (Number.isNaN(lat) || Number.isNaN(lon)) {
+                this.adapter.log.warn('[aiHelper] Geodaten ungültig – latitude/longitude sind keine Zahlen');
+                return null;
+            }
+
+            if (this._debugMode) {
+                this.adapter.log.debug(`[aiHelper] Geodaten geladen: lat=${lat}, lon=${lon}`);
+            }
+
+            return { lat, lon };
+        } catch (err) {
+            this.adapter.log.error(`[aiHelper] Fehler beim Laden der Geodaten: ${err.message}`);
+            return null;
+        }
+    },
+
+    /**
+     * Ruft Wetterdaten von Open-Meteo ab.
+     *
+     * @param {number} lat
+     * @param {number} lon
+     * @returns {Promise<any|null>}
+     */
+    async _fetchWeather(lat, lon) {
+        const url =
+            `https://api.open-meteo.com/v1/forecast` +
+            `?latitude=${encodeURIComponent(lat)}` +
+            `&longitude=${encodeURIComponent(lon)}` +
+            `&current=temperature_2m,wind_speed_10m` +
+            `&daily=temperature_2m_max,temperature_2m_min,weathercode` +
+            `&timezone=auto`;
+
+        if (this._debugMode) {
+            this.adapter.log.debug(`[aiHelper] Rufe Wetterdaten ab: ${url}`);
+        }
+
+        return new Promise(resolve => {
+            try {
+                https
+                    .get(url, res => {
+                        let data = '';
+                        res.on('data', chunk => {
+                            data += chunk;
+                        });
+                        res.on('end', () => {
+                            try {
+                                if (!data) {
+                                    this.adapter.log.warn('[aiHelper] Wetterabfrage: leere Antwort erhalten');
+                                    return resolve(null);
+                                }
+                                const json = JSON.parse(data);
+                                resolve(json);
+                            } catch (err) {
+                                this.adapter.log.warn(`[aiHelper] Fehler beim Parsen der Wetterdaten: ${err.message}`);
+                                resolve(null);
+                            }
+                        });
+                    })
+                    .on('error', err => {
+                        this.adapter.log.warn(`[aiHelper] Fehler bei Wetterabfrage: ${err.message}`);
+                        resolve(null);
+                    });
+            } catch (err) {
+                this.adapter.log.warn(`[aiHelper] Unerwarteter Fehler bei Wetterabfrage: ${err.message}`);
+                resolve(null);
+            }
+        });
+    },
+
+    // ---------------------------------------------------------------------
+    // Textgeneratoren
+    // ---------------------------------------------------------------------
+
+    /**
+     * Erzeugt einen gut lesbaren Wetterhinweis-Text.
+     *
+     * @param {any} weather
+     * @returns {string}
+     */
+    _buildWeatherAdviceText(weather) {
+        try {
+            const tmax = this._safeArrayValue(weather?.daily?.temperature_2m_max, 0);
+            const tmin = this._safeArrayValue(weather?.daily?.temperature_2m_min, 0);
+            const code = this._safeArrayValue(weather?.daily?.weathercode, 0);
+            const desc = this._describeWeatherCode(code);
+
+            let text = 'Wetterhinweis für heute: ';
+
+            if (tmax != null && tmin != null) {
+                text += `zwischen ${tmin.toFixed(1)} °C und ${tmax.toFixed(1)} °C, `;
+            } else if (tmax != null) {
+                text += `bis maximal ${tmax.toFixed(1)} °C, `;
+            }
+
+            text += desc ? `${desc}.` : 'genaue Wetterlage konnte nicht bestimmt werden.';
+
+            return text;
+        } catch {
+            return 'Wetterhinweis: Die aktuellen Wetterdaten konnten nicht ausgewertet werden.';
+        }
+    },
+
+    /**
+     * Erzeugt die Tageszusammenfassung.
+     *
+     * @param {{weather:any,seasonActive:boolean,pumpOn:boolean,pumpMode:string,surfaceTemp:number|null}} ctx
+     * @returns {string}
+     */
+    _buildDailySummaryText(ctx) {
+        const { weather, seasonActive, pumpOn, pumpMode, surfaceTemp } = ctx || {};
+
+        let parts = [];
+
+        // Saisonstatus
+        if (seasonActive) {
+            parts.push('Die Poolsaison ist aktuell AKTIV.');
+        } else {
+            parts.push('Die Poolsaison ist aktuell NICHT aktiv.');
+        }
+
+        // Pumpenstatus
+        if (pumpOn) {
+            parts.push(`Die Pumpe ist derzeit EIN (Modus: ${pumpMode || 'unbekannt'}).`);
+        } else {
+            parts.push(`Die Pumpe ist derzeit AUS (Modus: ${pumpMode || 'unbekannt'}).`);
+        }
+
+        // Temperatur
+        if (surfaceTemp != null && !Number.isNaN(surfaceTemp)) {
+            parts.push(`Die gemessene Wassertemperatur an der Oberfläche beträgt etwa ${surfaceTemp.toFixed(1)} °C.`);
+        }
+
+        // Wetterteil
+        if (weather) {
+            const tmax = this._safeArrayValue(weather?.daily?.temperature_2m_max, 0);
+            const tmin = this._safeArrayValue(weather?.daily?.temperature_2m_min, 0);
+            const code = this._safeArrayValue(weather?.daily?.weathercode, 0);
+            const desc = this._describeWeatherCode(code);
+
+            let w = 'Für heute sind ';
+            if (tmax != null && tmin != null) {
+                w += `Temperaturen zwischen ${tmin.toFixed(1)} °C und ${tmax.toFixed(1)} °C vorhergesagt`;
+            } else if (tmax != null) {
+                w += `Temperaturen bis etwa ${tmax.toFixed(1)} °C vorhergesagt`;
+            } else {
+                w += 'keine genauen Temperaturdaten verfügbar';
+            }
+
+            if (desc) {
+                w += `, bei einer Wetterlage: ${desc}.`;
+            } else {
+                w += '.';
+            }
+
+            parts.push(w);
+        } else {
+            parts.push('Aktuelle Wetterdaten stehen derzeit nicht zur Verfügung.');
+        }
+
+        return parts.join(' ');
+    },
+
+    /**
+     * Erzeugt tägliche Pool-Tipps abhängig von Wetter & Saison.
+     *
+     * @param {any} weather
+     * @param {boolean} seasonActive
+     * @returns {string}
+     */
+    _buildPoolTipsText(weather, seasonActive) {
+        if (!seasonActive) {
+            return 'Poolsaison ist aktuell nicht aktiv. Es sind keine speziellen Pool-Tipps notwendig.';
+        }
+
+        const tmax = this._safeArrayValue(weather?.daily?.temperature_2m_max, 0);
+        const code = this._safeArrayValue(weather?.daily?.weathercode, 0);
+        const desc = this._describeWeatherCode(code);
+
+        if (tmax == null) {
+            return 'Pool-Tipp: Es liegen keine Temperaturdaten vor. Bitte Poolbetrieb nach eigenem Gefühl planen.';
+        }
+
+        let text = 'Pool-Tipp für heute: ';
+
+        if (tmax >= 26) {
+            text += 'Es wird warm bis sehr warm – gutes Badewetter. ';
+            text +=
+                'Die Pumpe kann tagsüber etwas länger laufen, und die Abdeckung sollte bei Sonnenschein geöffnet werden. ';
+        } else if (tmax >= 20) {
+            text += 'Es wird mild bis angenehm. ';
+            text += 'Eine normale Umwälzzeit reicht meist aus. Abdeckung nur bei Bedarf schließen. ';
+        } else {
+            text += 'Es bleibt eher kühl. ';
+            text +=
+                'Die Umwälzzeit kann auf das Minimum reduziert werden, und eine Abdeckung hilft, Wärmeverluste zu vermeiden. ';
+        }
+
+        if (desc && /regen|schauer|gewitter|sturm/i.test(desc)) {
+            text +=
+                'Achtung: Es ist mit Regen oder stärkerem Wind zu rechnen – Abdeckung bereit halten und Zubehör sichern.';
+        } else if (desc && /sonnig|klar/i.test(desc)) {
+            text += 'Bei sonniger Witterung steigt der Chlorverbrauch – Wasserwerte im Auge behalten.';
+        }
+
+        return text;
+    },
+
+    /**
+     * Erzeugt Wochenend-Zusammenfassung (Samstag/Sonntag).
+     *
+     * @param {any} weather
+     * @param {boolean} seasonActive
+     * @param {number} weekday JS-Tag (0=So..6=Sa)
+     * @returns {string}
+     */
+    _buildWeekendSummaryText(weather, seasonActive, weekday) {
+        if (!weather) {
+            return 'Wochenendübersicht: Es stehen keine Wetterdaten zur Verfügung.';
+        }
+
+        const tmaxArr = weather?.daily?.temperature_2m_max || [];
+        const tminArr = weather?.daily?.temperature_2m_min || [];
+        const codeArr = weather?.daily?.weathercode || [];
+
+        // Indizes für Samstag/Sonntag bestimmen
+        let idxSat = null;
+        let idxSun = null;
+
+        if (weekday === 5) {
+            // Freitag → morgen Samstag, übermorgen Sonntag
+            idxSat = 1;
+            idxSun = 2;
+        } else if (weekday === 6) {
+            // Samstag → heute Samstag, morgen Sonntag
+            idxSat = 0;
+            idxSun = 1;
+        } else {
+            // Fallback: nächste zwei Tage
+            idxSat = 1;
+            idxSun = 2;
+        }
+
+        const satMax = this._safeArrayValue(tmaxArr, idxSat);
+        const satMin = this._safeArrayValue(tminArr, idxSat);
+        const satCode = this._safeArrayValue(codeArr, idxSat);
+        const satDesc = this._describeWeatherCode(satCode);
+
+        const sunMax = this._safeArrayValue(tmaxArr, idxSun);
+        const sunMin = this._safeArrayValue(tminArr, idxSun);
+        const sunCode = this._safeArrayValue(codeArr, idxSun);
+        const sunDesc = this._describeWeatherCode(sunCode);
+
+        let text = 'Wochenendübersicht: ';
+
+        text += 'Samstag: ';
+        if (satMax != null && satMin != null) {
+            text += `zwischen ${satMin.toFixed(1)} °C und ${satMax.toFixed(1)} °C`;
+        } else if (satMax != null) {
+            text += `bis etwa ${satMax.toFixed(1)} °C`;
+        } else {
+            text += 'keine Temperaturdaten';
+        }
+        if (satDesc) {
+            text += `, Wetter: ${satDesc}. `;
+        } else {
+            text += '. ';
+        }
+
+        text += 'Sonntag: ';
+        if (sunMax != null && sunMin != null) {
+            text += `zwischen ${sunMin.toFixed(1)} °C und ${sunMax.toFixed(1)} °C`;
+        } else if (sunMax != null) {
+            text += `bis etwa ${sunMax.toFixed(1)} °C`;
+        } else {
+            text += 'keine Temperaturdaten';
+        }
+        if (sunDesc) {
+            text += `, Wetter: ${sunDesc}. `;
+        } else {
+            text += '. ';
+        }
+
+        if (seasonActive) {
+            text += 'Für das Wochenende bietet sich je nach Temperaturentwicklung ein angepasster Poolbetrieb an.';
+        } else {
+            text +=
+                'Die Poolsaison ist aktuell nicht aktiv – das Wochenende eignet sich eher zur Planung oder Wartung.';
+        }
+
+        return text;
+    },
+
+    /**
+     * Konvertiert Open-Meteo weathercode in eine deutsche Beschreibung.
+     *
+     * @param {number|null} code
+     * @returns {string}
+     */
+    _describeWeatherCode(code) {
+        if (code == null || Number.isNaN(code)) {
+            return '';
+        }
+
+        // Quelle: Open-Meteo Wettercodes (vereinfachte Gruppierung)
+        if (code === 0) {
+            return 'klarer, sonniger Himmel';
+        }
+        if (code === 1) {
+            return 'überwiegend sonnig mit wenigen Wolken';
+        }
+        if (code === 2) {
+            return 'wechselhaft bewölkt';
+        }
+        if (code === 3) {
+            return 'bedeckter Himmel';
+        }
+
+        if (code === 45 || code === 48) {
+            return 'Nebel oder Hochnebel';
+        }
+
+        if (code === 51 || code === 53 || code === 55) {
+            return 'leichter bis mäßiger Nieselregen';
+        }
+        if (code === 56 || code === 57) {
+            return 'gefrierender Nieselregen';
+        }
+
+        if (code === 61 || code === 63 || code === 65) {
+            return 'leichter bis kräftiger Regen';
+        }
+        if (code === 66 || code === 67) {
+            return 'gefrierender Regen';
+        }
+
+        if (code === 71 || code === 73 || code === 75) {
+            return 'leichter bis starker Schneefall';
+        }
+        if (code === 77) {
+            return 'Schneekörner';
+        }
+
+        if (code === 80 || code === 81 || code === 82) {
+            return 'Regenschauer';
+        }
+        if (code === 85 || code === 86) {
+            return 'Schneeschauer';
+        }
+
+        if (code === 95) {
+            return 'Gewitter';
+        }
+        if (code === 96 || code === 99) {
+            return 'Gewitter mit Hagel';
+        }
+
+        return `Wettercode ${code}`;
+    },
+
+    // ---------------------------------------------------------------------
+    // State-/Hilfsfunktionen
+    // ---------------------------------------------------------------------
+
+    /**
+     * Schreibt einen AI-Output-Text.
+     *
+     * @param {string} id
+     * @param {string} text
+     */
+    async _writeOutput(id, text) {
+        if (!this.adapter) {
+            return;
+        }
+        if (!text) {
+            text = 'Keine Textausgabe verfügbar.';
+        }
+
+        try {
+            await this.adapter.setStateAsync(`ai.outputs.${id}`, { val: text, ack: true });
+            await this.adapter.setStateAsync('ai.outputs.last_message', { val: text, ack: true });
+
+            if (this._debugMode) {
+                this.adapter.log.info(`[aiHelper] Output geschrieben → ai.outputs.${id}: ${text}`);
+            }
+        } catch (err) {
+            this.adapter.log.error(`[aiHelper] Fehler beim Schreiben eines Outputs (${id}): ${err.message}`);
+        }
+    },
+
+    /**
+     * Optional: sendet Text an speech.queue, wenn erlaubt.
+     *
+     * @param {string} text
+     */
+    async _maybeSpeak(text) {
+        if (!this.adapter) {
+            return;
+        }
+        if (!text) {
+            return;
+        }
+
+        const allowSpeech = await this._getBool('ai.switches.allow_speech', false);
+        if (!allowSpeech) {
+            if (this._debugMode) {
+                this.adapter.log.debug('[aiHelper] Sprachausgabe deaktiviert (ai.switches.allow_speech = false)');
+            }
+            return;
+        }
+
+        try {
+            await this.adapter.setStateAsync('speech.queue', { val: text, ack: false });
+            this.adapter.log.info('[aiHelper] Text an speech.queue übergeben');
+        } catch (err) {
+            this.adapter.log.warn(`[aiHelper] Fehler bei Sprachausgabe: ${err.message}`);
+        }
+    },
+
+    /**
+     * Liest einen Bool-State.
+     *
+     * @param {string} id
+     * @param {boolean} fallback
+     * @returns {Promise<boolean>}
+     */
+    async _getBool(id, fallback) {
+        try {
+            const state = await this.adapter.getStateAsync(id);
+            if (!state || state.val == null) {
+                return fallback;
+            }
+            return !!state.val;
+        } catch {
+            return fallback;
+        }
+    },
+
+    /**
+     * Liest einen String-State.
+     *
+     * @param {string} id
+     * @param {string} fallback
+     * @returns {Promise<string>}
+     */
+    async _getString(id, fallback) {
+        try {
+            const state = await this.adapter.getStateAsync(id);
+            if (!state || state.val == null) {
+                return fallback;
+            }
+            return String(state.val);
+        } catch {
+            return fallback;
+        }
+    },
+
+    /**
+     * Liest einen Zahlen-State.
+     *
+     * @param {string} id
+     * @param {number|null} fallback
+     * @returns {Promise<number|null>}
+     */
+    async _getNumber(id, fallback) {
+        try {
+            const state = await this.adapter.getStateAsync(id);
+            if (!state || state.val == null) {
+                return fallback;
+            }
+            const num = Number(state.val);
+            return Number.isNaN(num) ? fallback : num;
+        } catch {
+            return fallback;
+        }
+    },
+
+    /**
+     * Liest Zeit-String HH:MM und liefert Objekt {hour,minute}.
+     *
+     * @param {string} id
+     * @param {string} def
+     * @returns {Promise<{hour:number,minute:number}>}
+     */
+    async _getTimeOrDefault(id, def) {
+        const str = await this._getString(id, def);
+
+        // NEU: Log, welche Uhrzeit der Helper tatsächlich verwendet
+        this.adapter.log.info(`[aiHelper] Uhrzeit geladen: ${id} = "${str}" (Default: ${def})`);
+
+        const match = /^(\d{1,2}):(\d{2})$/.exec(str || '');
+        let hour = 0;
+        let minute = 0;
+
+        if (!match) {
+            this.adapter.log.warn(`[aiHelper] Ungültiges Zeitformat in ${id}: "${str}" – verwende Default ${def}`);
+            const defMatch = /^(\d{1,2}):(\d{2})$/.exec(def);
+            if (defMatch) {
+                hour = Number(defMatch[1]);
+                minute = Number(defMatch[2]);
+            }
+        } else {
+            hour = Math.min(Math.max(Number(match[1]), 0), 23);
+            minute = Math.min(Math.max(Number(match[2]), 0), 59);
+        }
+
+        return { hour, minute };
+    },
+
+    /**
+     * Sicherer Zugriff auf ein Array-Element.
+     *
+     * @param {Array<number>|undefined} arr
+     * @param {number} idx
+     * @returns {number|null}
+     */
+    _safeArrayValue(arr, idx) {
+        if (!Array.isArray(arr)) {
+            return null;
+        }
+        if (idx < 0 || idx >= arr.length) {
+            return null;
+        }
+        const v = arr[idx];
+        if (v == null || Number.isNaN(Number(v))) {
+            return null;
+        }
+        return Number(v);
+    },
+};
+
+module.exports = aiHelper;

package/lib/helpers/infoHelper.js

@@ -56,7 +56,7 @@ const infoHelper = {
         let greeting = '';
 
         // Weihnachten: 20.12. – 27.12.
-        if ((month === 12 && day >= 20) || (month === 12 && day <= 27)) {
+        if (month === 12 && day >= 20 && day <= 27) {
             greeting = '🎄 PoolControl wünscht frohe Weihnachten! 🎄';
         }
 

package/lib/stateDefinitions/aiStates.js

@@ -0,0 +1,135 @@
+'use strict';
+
+/**
+ * aiStates.js
+ * ----------------------------------------------------------
+ * Definiert alle States für den KI-Bereich des PoolControl-Adapters.
+ * Struktur:
+ * ai.switches.*
+ * ai.schedule.*
+ * ai.outputs.*
+ * ----------------------------------------------------------
+ *
+ * @param {import('iobroker').Adapter} adapter - ioBroker Adapterinstanz
+ */
+
+/**
+ * Erstellt alle KI-bezogenen States (ai.*)
+ *
+ * @param {import('iobroker').Adapter} adapter - ioBroker Adapterinstanz
+ */
+async function createAiStates(adapter) {
+    adapter.log.debug('[aiStates] Initialisierung gestartet');
+
+    // Hauptordner
+    await adapter.setObjectNotExistsAsync('ai', {
+        type: 'channel',
+        common: { name: 'KI / AI-Funktionen' },
+        native: {},
+    });
+
+    // ------------------------------------------------------
+    // Unterordner: switches
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('ai.switches', {
+        type: 'channel',
+        common: { name: 'Schalter (KI-Steuerung)' },
+        native: {},
+    });
+
+    const switches = [
+        { id: 'enabled', name: 'KI aktivieren', def: false },
+        { id: 'allow_speech', name: 'Sprachausgabe durch KI erlauben', def: false },
+        { id: 'daily_summary_enabled', name: 'Tägliche Zusammenfassung aktiv', def: false },
+        { id: 'daily_pool_tips_enabled', name: 'Tägliche Pool-Tipps aktiv', def: false },
+        { id: 'weather_advice_enabled', name: 'Wetterhinweise aktiv', def: false },
+        { id: 'weekend_summary_enabled', name: 'Wochenende-Zusammenfassung aktiv', def: false },
+        { id: 'debug_mode', name: 'KI-Debugmodus', def: false },
+    ];
+
+    for (const s of switches) {
+        await adapter.setObjectNotExistsAsync(`ai.switches.${s.id}`, {
+            type: 'state',
+            common: {
+                name: s.name,
+                type: 'boolean',
+                role: 'switch',
+                read: true,
+                write: true,
+                def: s.def,
+                persist: true,
+            },
+            native: {},
+        });
+    }
+
+    // ------------------------------------------------------
+    // Unterordner: schedule
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('ai.schedule', {
+        type: 'channel',
+        common: { name: 'Zeitpläne (KI-Ausgaben)' },
+        native: {},
+    });
+
+    const schedule = [
+        { id: 'daily_summary_time', name: 'Zeit für tägliche Zusammenfassung', def: '09:00' },
+        { id: 'daily_pool_tips_time', name: 'Zeit für tägliche Pool-Tipps', def: '10:00' },
+        { id: 'weather_advice_time', name: 'Zeit für Wetterhinweise', def: '08:00' },
+        { id: 'weekend_summary_time', name: 'Zeit für Wochenend-Zusammenfassung', def: '18:00' },
+    ];
+
+    for (const t of schedule) {
+        await adapter.setObjectNotExistsAsync(`ai.schedule.${t.id}`, {
+            type: 'state',
+            common: {
+                name: t.name,
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: true,
+                def: t.def,
+                persist: true,
+            },
+            native: {},
+        });
+    }
+
+    // ------------------------------------------------------
+    // Unterordner: outputs
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('ai.outputs', {
+        type: 'channel',
+        common: { name: 'KI-Ausgaben (Texte)' },
+        native: {},
+    });
+
+    const outputs = [
+        { id: 'daily_summary', name: 'Tägliche Zusammenfassung' },
+        { id: 'pool_tips', name: 'Pool-Tipps' },
+        { id: 'weather_advice', name: 'Wetterhinweise' },
+        { id: 'weekend_summary', name: 'Wochenende-Zusammenfassung' },
+        { id: 'last_message', name: 'Letzte KI-Meldung' },
+    ];
+
+    for (const o of outputs) {
+        await adapter.setObjectNotExistsAsync(`ai.outputs.${o.id}`, {
+            type: 'state',
+            common: {
+                name: o.name,
+                type: 'string',
+                role: 'text',
+                read: true,
+                write: false,
+                persist: false,
+            },
+            native: {},
+        });
+    }
+
+    adapter.log.debug('[aiStates] Initialisierung abgeschlossen');
+}
+
+module.exports = {
+    createAiStates,
+};

package/main.js

@@ -21,6 +21,7 @@ const solarHelper = require('./lib/helpers/solarHelper');
 const frostHelper = require('./lib/helpers/frostHelper');
 const statusHelper = require('./lib/helpers/statusHelper');
 const photovoltaicHelper = require('./lib/helpers/photovoltaicHelper');
+const aiHelper = require('./lib/helpers/aiHelper');
 const controlHelper = require('./lib/helpers/controlHelper');
 const controlHelper2 = require('./lib/helpers/controlHelper2');
 const debugLogHelper = require('./lib/helpers/debugLogHelper');
@@ -44,6 +45,7 @@ const { createStatusStates } = require('./lib/stateDefinitions/statusStates');
 const { createControlStates } = require('./lib/stateDefinitions/controlStates');
 const { createDebugLogStates } = require('./lib/stateDefinitions/debugLogStates');
 const { createInfoStates } = require('./lib/stateDefinitions/infoStates');
+const { createAiStates } = require('./lib/stateDefinitions/aiStates'); // NEU: KI-States
 
 class Poolcontrol extends utils.Adapter {
     constructor(options) {
@@ -110,6 +112,9 @@ class Poolcontrol extends utils.Adapter {
         // --- Info States ---
         await createInfoStates(this);
 
+        // --- AI States ---
+        await createAiStates(this); // NEU: KI-States anlegen
+
         // --- Migration Helper zuletzt starten ---
         await migrationHelper.init(this);
 
@@ -128,6 +133,7 @@ class Poolcontrol extends utils.Adapter {
         consumptionHelper.init(this);
         solarHelper.init(this);
         photovoltaicHelper.init(this);
+		aiHelper.init(this);
         frostHelper.init(this);
         statusHelper.init(this);
         infoHelper.init(this);
@@ -186,6 +192,9 @@ class Poolcontrol extends utils.Adapter {
             }
             if (speechTextHelper.cleanup) {
                 speechTextHelper.cleanup();
+            }
+			if (aiHelper.cleanup) {
+                aiHelper.cleanup();
             }
             if (infoHelper.cleanup) {
                 infoHelper.cleanup();
@@ -257,6 +266,12 @@ class Poolcontrol extends utils.Adapter {
             photovoltaicHelper.handleStateChange(id, state);
         } catch (e) {
             this.log.warn(`[photovoltaicHelper] Fehler in handleStateChange: ${e.message}`);
+        }
+		// --- AI-Helper ---
+        try {
+            aiHelper.handleStateChange(id, state);
+        } catch (e) {
+            this.log.warn(`[main] Fehler in aiHelper.handleStateChange: ${e.message}`);
         }
         try {
             statusHelper.handleStateChange(id, state);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.poolcontrol",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Steuerung & Automatisierung für den Pool (Pumpe, Heizung, Ventile, Sensoren).",
   "author": "DasBo1975 <dasbo1975@outlook.de>",
   "homepage": "https://github.com/DasBo1975/ioBroker.poolcontrol",
@@ -28,6 +28,7 @@
     "@iobroker/adapter-dev": "^1.5.0",
     "@iobroker/eslint-config": "^2.2.0",
     "@iobroker/testing": "^5.1.1",
+    "baseline-browser-mapping": "^2.8.32",
     "eslint": "^9.36.0",
     "prettier": "^3.6.2",
     "proxyquire": "^2.1.3",