iobroker.poolcontrol 1.3.13 → 1.3.15

package/README.md

@@ -188,6 +188,31 @@ New features are added regularly – please refer to the changelog.
 ---
 
 ## Changelog
+### 1.3.15 (2026-05-08)
+
+- Added speech source cooldown handling for solar and time announcements
+- Added configurable `speech.sources.*` states for source-based speech control
+- Reduced excessive solar speech notifications during unstable weather conditions
+- Added persistent numeric runtime second states:
+  - `runtime.total_seconds`
+  - `runtime.today_seconds`
+  - `runtime.current_session_seconds`
+  - `runtime.season_total_seconds`
+- Improved runtime restore handling using numeric fallback logic
+- Fixed live runtime display consistency for total, today and season runtimes
+- Improved season runtime handling using `status.season_active`
+- Converted runtime helper timers to ioBroker adapter timer methods
+- Improved runtime timer cleanup and reset protection
+- Improved speech logging for skipped and cooldown-limited announcements
+
+### 1.3.14 (2026-05-08)
+
+- Improved runtime handling and persistence
+- Fixed season runtime calculation using the correct season state
+- Unified live runtime calculations for total, today and season values
+- Added numeric runtime second states for robust persistence and recovery
+- Converted runtime timers to adapter-managed timers for improved ioBroker compatibility
+
 ### 1.3.13 (2026-05-08)
 - (copilot) Adapter requires node.js >= 22 now
 - Fixed invalid `common.installedFrom` entry in `io-package.json`
@@ -262,48 +287,6 @@ New features are added regularly – please refer to the changelog.
     - improves separation of solar control modes
     - stabilizes speech output behavior
 
-### 1.3.10 (2026-05-01)
-
-New: Photovoltaic Insights
-- Introduced a new analytics module `analytics.insights.photovoltaic`
-- Tracks PV-based pump runtime, energy usage and estimated savings
-- New helper: `photovoltaicInsightsHelper`
-- New states: inputs, calculation, results, debug
-- Includes summary outputs (text, JSON, HTML)
-- Fully integrated with i18n translations
-
-Improvement: Active Helper Handling
-- Added consistent `pump.active_helper` ownership handling for:
-  - photovoltaicHelper
-  - solarHelper
-  - solarExtendedHelper
-- Each helper now:
-  - sets its own identifier when controlling the pump
-  - releases it when stopping
-  - does not override other active helpers
-- Ensures correct priority handling and prevents conflicts
-
-Improvement: PV Runtime Evaluation
-- Photovoltaic runtime is now only counted when:
-  - PV surplus is active
-  - AND photovoltaicHelper actually owns the pump
-- Enables accurate runtime, energy and savings calculation
-
-Fix: PV Circulation Logic
-- Fixed issue where pump stopped despite `photovoltaic.ignore_on_circulation = false`
-- Circulation check is now only applied when explicitly enabled
-
-### 1.3.9 (2026-04-24)
-
-- Fix: solarLogbookHelper no longer creates duplicate or unnecessary log entries (improved filtering & throttling logic)
-- Fix: Removed obsolete "no runtime today" entries once solar has actually run
-- Fix: Improved handling of weather summary text to avoid broken or cut-off sentences
-- Fix: solarLogbookHelper now updates `last_entry_time` only when a real log entry is written
-- Fix: solarInsightsHelper runtime calculation improved (no incorrect time accumulation on state changes)
-- Fix: solarInsightsHelper now correctly tracks previous solar state for more accurate active time calculation
-- Fix: Added missing `debug.last_update` update on successful calculation
-- Improvement: General stability and plausibility improvements in solar insights and logbook processing
-
 ## Support
 - [ioBroker Forum](https://forum.iobroker.net/)  
 - [GitHub Issues](https://github.com/DasBo1975/ioBroker.poolcontrol/issues)

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "poolcontrol",
-    "version": "1.3.13",
+    "version": "1.3.15",
     "news": {
+      "1.3.15": {
+        "en": "Added speech source cooldown handling, improved solar/time speech control, added persistent runtime second states, improved runtime restore logic and converted runtime timers to ioBroker adapter timers.",
+        "de": "Sprachquellen mit Cooldown-Steuerung ergänzt, Solar-/Zeit-Sprachsteuerung verbessert, persistente Runtime-Sekundenstates hinzugefügt, Runtime-Wiederherstellung verbessert und Runtime-Timer auf ioBroker-Adapter-Timer umgestellt.",
+        "ru": "Добавлена ​​обработка перезарядки источника речи, улучшено управление речью по солнечной энергии и времени, добавлены постоянные секунды времени выполнения, улучшена логика восстановления времени выполнения и преобразованы таймеры времени выполнения в таймеры адаптера ioBroker.",
+        "pt": "Adicionado tratamento de resfriamento da fonte de fala, controle de fala solar/tempo aprimorado, segundos estados de tempo de execução persistentes adicionados, lógica de restauração de tempo de execução aprimorada e temporizadores de tempo de execução convertidos em temporizadores de adaptador ioBroker.",
+        "nl": "Afkoeling van spraakbronnen toegevoegd, verbeterde spraakcontrole op zonne-energie/tijd, persistente tweede runtime-statussen toegevoegd, verbeterde runtime-herstellogica en geconverteerde runtime-timers naar ioBroker-adaptertimers.",
+        "fr": "Ajout de la gestion du temps de recharge de la source vocale, du contrôle vocal solaire/temporel amélioré, ajout des seconds états d'exécution persistants, amélioration de la logique de restauration de l'exécution et conversion des minuteries d'exécution en minuteries d'adaptateur ioBroker.",
+        "it": "Aggiunta la gestione del raffreddamento della sorgente vocale, controllo vocale solare/ora migliorato, aggiunti secondi stati di runtime persistenti, logica di ripristino del runtime migliorata e timer di runtime convertiti in timer dell'adattatore ioBroker.",
+        "es": "Se agregó manejo de enfriamiento de la fuente de voz, control de voz solar/tiempo mejorado, se agregaron segundos estados de tiempo de ejecución persistentes, lógica de restauración de tiempo de ejecución mejorada y temporizadores de tiempo de ejecución convertidos en temporizadores de adaptador ioBroker.",
+        "pl": "Dodano obsługę schładzania źródła mowy, ulepszoną kontrolę mowy w czasie słonecznym/czasem, dodano trwałe drugie stany czasu wykonania, ulepszoną logikę przywracania w czasie wykonywania i przekonwertowano liczniki czasu działania na liczniki czasu adaptera ioBroker.",
+        "uk": "Додано обробку перезарядки джерела мовлення, покращено керування мовленням із сонячними променями/часом, додано постійні другі стани під час виконання, покращено логіку відновлення під час виконання та перетворено таймери часу виконання на таймери адаптера ioBroker.",
+        "zh-cn": "添加了语音源冷却处理、改进了太阳/时间语音控制、添加了持久运行时第二状态、改进了运行时恢复逻辑并将运行时计时器转换为 ioBroker 适配器计时器。"
+      },
+      "1.3.14": {
+        "en": "Improved runtime handling and persistence. Fixed season runtime calculation to use the correct season state, improved live runtime updates, added robust numeric runtime second states for safer persistence and recovery, and converted runtime timers to adapter-managed timers for better ioBroker compatibility.",
+        "de": "Laufzeit-Handling und Persistenz verbessert. Saisonlaufzeit nutzt jetzt den korrekten Saison-Status, Live-Laufzeiten wurden vereinheitlicht, robuste Sekunden-States fuer Laufzeiten zur sicheren Wiederherstellung hinzugefuegt und Runtime-Timer auf adapterverwaltete Timer fuer bessere ioBroker-Kompatibilitaet umgestellt.",
+        "ru": "Улучшена обработка и сохранение во время выполнения. Исправлен расчет времени выполнения сезона для использования правильного состояния сезона, улучшены обновления времени выполнения в режиме реального времени, добавлены надежные числовые значения второго состояния времени выполнения для более безопасного сохранения и восстановления, а также преобразованы таймеры времени выполнения в таймеры, управляемые адаптером, для лучшей совместимости с ioBroker.",
+        "pt": "Melhor manipulação e persistência do tempo de execução. Cálculo de tempo de execução de temporada corrigido para usar o estado de temporada correto, atualizações de tempo de execução ao vivo aprimoradas, segundos estados de tempo de execução numéricos robustos adicionados para persistência e recuperação mais seguras e temporizadores de tempo de execução convertidos em temporizadores gerenciados por adaptador para melhor compatibilidade com ioBroker.",
+        "nl": "Verbeterde runtime-afhandeling en persistentie. Vaste seizoensruntimeberekening om de juiste seizoensstatus te gebruiken, verbeterde live runtime-updates, robuuste numerieke runtime-secondestatussen toegevoegd voor veiliger persistentie en herstel, en geconverteerde runtime-timers naar door adapter beheerde timers voor betere ioBroker-compatibiliteit.",
+        "fr": "Gestion de l'exécution et persistance améliorées. Correction du calcul de la durée d'exécution de la saison pour utiliser l'état de saison correct, mises à jour d'exécution en direct améliorées, ajout de seconds états d'exécution numériques robustes pour une persistance et une récupération plus sûres, et conversion des minuteries d'exécution en minuteries gérées par l'adaptateur pour une meilleure compatibilité ioBroker.",
+        "it": "Gestione e persistenza del runtime migliorate. Risolto il problema con il calcolo del runtime della stagione per utilizzare lo stato della stagione corretto, aggiornamenti migliorati del runtime in tempo reale, aggiunti robusti secondi stati di runtime numerici per persistenza e ripristino più sicuri e timer di runtime convertiti in timer gestiti dall'adattatore per una migliore compatibilità con ioBroker.",
+        "es": "Manejo y persistencia del tiempo de ejecución mejorados. Se corrigió el cálculo del tiempo de ejecución de la temporada para usar el estado correcto de la temporada, se mejoraron las actualizaciones del tiempo de ejecución en vivo, se agregaron segundos estados de tiempo de ejecución numéricos sólidos para una persistencia y recuperación más seguras y se convirtieron los temporizadores de tiempo de ejecución en temporizadores administrados por adaptador para una mejor compatibilidad con ioBroker.",
+        "pl": "Poprawiona obsługa i trwałość środowiska wykonawczego. Naprawiono obliczanie czasu wykonania sezonu w celu wykorzystania prawidłowego stanu sezonu, ulepszono aktualizacje czasu działania na żywo, dodano solidne numeryczne drugie stany czasu działania dla bezpieczniejszej trwałości i odzyskiwania oraz przekonwertowano liczniki czasu działania na zegary zarządzane przez adapter dla lepszej kompatybilności z ioBroker.",
+        "uk": "Покращена обробка та збереження часу виконання. Виправлено розрахунок часу виконання сезону для використання правильного стану сезону, покращено поточні оновлення середовища виконання, додано надійні численні секунди часу виконання для безпечнішого збереження та відновлення, а також перетворено таймери часу виконання на таймери, керовані адаптером, для кращої сумісності з ioBroker.",
+        "zh-cn": "改进了运行时处理和持久性。修复了季节运行时计算以使用正确的季节状态，改进了实时运行时更新，添加了强大的数字运行时第二状态以实现更安全的持久性和恢复，并将运行时计时器转换为适配器管理的计时器以实现更好的 ioBroker 兼容性。"
+      },
       "1.3.13": {
         "en": "Added German and English function overview documentation. Fixed invalid common.installedFrom entry in io-package.json.",
         "de": "Deutsche und englische Funktionsübersicht ergänzt. Ungültigen common.installedFrom-Eintrag in der io-package.json korrigiert.",
@@ -41,32 +67,6 @@
         "pl": "Nowość: Dodano moduł oceny pH (chemistry.ph) z ręcznym i zewnętrznym wprowadzaniem danych, walidacją, obsługą miejsca pomiaru i zaleceniami. Nowość: Dodano moduł oceny TDS (chemistry.tds) z analizą trendów (24h, 7d, 30d), śledzeniem referencji i wynikami podsumowującymi (tekst/JSON/HTML). Poprawka: rozwiązano problem z przełączaniem mowy słonecznej między trybem standardowym i rozszerzonym. solarExtendedHelper nie zastępuje już mowy.solar_active w trybie standardowym.",
         "uk": "Нове: додано модуль оцінки pH (chemistry.ph) із ручним і зовнішнім введенням, перевіркою, обробкою місця вимірювання та рекомендаціями. Нове: додано модуль оцінки TDS (chemistry.tds) з ​​аналізом тенденцій (24 години, 7 днів, 30 днів), відстеженням посилань і підсумковими виходами (текст/JSON/HTML). Виправлення: вирішено проблему перемикання сонячної мови між стандартним і розширеним режимами. solarExtendedHelper більше не перезаписує speak.solar_active у стандартному режимі.",
         "zh-cn": "新增内容：添加了 pH 评估模块 (chemistry.ph)，具有手动和外部输入、验证、测量位置处理和建议。新增内容：添加了 TDS 评估模块 (chemistry.tds)，具有趋势分析（24 小时、7 天、30 天）、参考跟踪和摘要输出（文本/JSON/HTML）。修复：解决了标准模式和扩展模式之间的太阳能语音切换问题。在标准模式下，solarExtendedHelper 不再覆盖pepe.solar_active。"
-      },
-      "1.3.10": {
-        "en": "Added photovoltaic insights (runtime, energy, savings) with new analytics states and helper. Improved active_helper ownership handling across photovoltaic, solar and extended solar helpers. Fixed PV circulation logic when ignore_on_circulation is disabled.",
-        "de": "Photovoltaik-Einblicke (Laufzeit, Energie, Einsparungen) mit neuen Analysezuständen und Hilfsfunktionen hinzugefügt. Verbesserte Handhabung des Active_Helper-Besitzes für Photovoltaik-, Solar- und erweiterte Solar-Helfer. Die PV-Zirkulationslogik wurde korrigiert, wenn „ignore_on_circulation“ deaktiviert ist.",
-        "ru": "Добавлены данные по фотоэлектрической энергии (время работы, энергия, экономия) с новыми аналитическими состояниями и помощником. Улучшено управление владением active_helper для фотоэлектрических, солнечных и расширенных солнечных помощников. Исправлена ​​логика циркуляции PV, когда ignore_on_circulation отключен.",
-        "pt": "Adicionados insights fotovoltaicos (tempo de execução, energia, economia) com novos estados analíticos e auxiliares. Melhor gerenciamento de propriedade de active_helper em ajudantes fotovoltaicos, solares e solares estendidos. Lógica de circulação fotovoltaica corrigida quando ignore_on_circulation está desativado.",
-        "nl": "Fotovoltaïsche inzichten toegevoegd (runtime, energie, besparingen) met nieuwe analysestatussen en helper. Verbeterde afhandeling van active_helper-eigendom voor fotovoltaïsche, zonne-energie en uitgebreide zonne-helpers. Vaste PV-circulatielogica wanneer negeer_on_circulatie is uitgeschakeld.",
-        "fr": "Ajout d'informations photovoltaïques (durée de fonctionnement, énergie, économies) avec de nouveaux états d'analyse et une nouvelle aide. Amélioration de la gestion de la propriété active_helper pour les assistants photovoltaïques, solaires et solaires étendus. Correction de la logique de circulation PV lorsque ignore_on_circulation est désactivé.",
-        "it": "Aggiunti approfondimenti sul fotovoltaico (autonomia, energia, risparmio) con nuovi stati di analisi e supporto. Migliorata la gestione della proprietà di active_helper tra gli helper fotovoltaici, solari e solari estesi. Risolta la logica di circolazione FV quando ignore_on_circulation è disabilitato.",
-        "es": "Se agregaron conocimientos fotovoltaicos (tiempo de ejecución, energía, ahorros) con nuevos estados analíticos y ayuda. Se mejoró el manejo de la propiedad de active_helper en los asistentes fotovoltaicos, solares y solares extendidos. Se corrigió la lógica de circulación de PV cuando ignore_on_circulation estaba deshabilitado.",
-        "pl": "Dodano statystyki fotowoltaiczne (czas pracy, energia, oszczędności) z nowymi stanami analitycznymi i pomocą. Ulepszona obsługa własności active_helper w przypadku fotowoltaiki, energii słonecznej i rozszerzonych pomocników energii słonecznej. Naprawiono logikę cyrkulacji PV, gdy ignorowanie_cyrkulacji jest wyłączone.",
-        "uk": "Додано статистику фотоелектричної системи (час роботи, енергія, економія) з новими аналітичними станами та помічником. Покращено керування правами власності active_helper на фотоелектричні, сонячні та розширені сонячні помічники. Виправлена ​​логіка циркуляції PV, коли ignore_on_circulation вимкнено.",
-        "zh-cn": "通过新的分析状态和帮助器添加了光伏见解（运行时间、能源、节省）。改进了跨光伏、太阳能和扩展太阳能助手的 active_helper 所有权处理。修复了禁用ignore_on_circulation时的PV循环逻辑。"
-      },
-      "1.3.9": {
-        "en": "Fix solar logbook duplication and invalid entries, improve log stability and weather text handling; fix solar insights runtime calculation and debug timestamp update.",
-        "de": "Behebung von doppelten und ungültigen Solar-Logbuch-Einträgen, Verbesserung der Log-Stabilität und Wettertext-Verarbeitung; Korrektur der Laufzeitberechnung im Solar-Insights-Bereich sowie Aktualisierung des Debug-Zeitstempels.",
-        "ru": "Исправьте дублирование журнала солнечной энергии и неверные записи, улучшите стабильность журнала и обработку текста о погоде; исправить расчет времени выполнения Solar Insights и обновить временную метку отладки.",
-        "pt": "Corrija a duplicação do diário de bordo solar e entradas inválidas, melhore a estabilidade do registro e o manuseio de textos meteorológicos; corrigir o cálculo do tempo de execução do Solar Insights e depurar a atualização do carimbo de data/hora.",
-        "nl": "Herstel het dupliceren van zonnelogboeken en ongeldige vermeldingen, verbeter de logstabiliteit en de verwerking van weerteksten; runtimeberekening van zonne-inzichten repareren en tijdstempelupdate debuggen.",
-        "fr": "Corrigez la duplication du journal solaire et les entrées invalides, améliorez la stabilité du journal et la gestion des textes météorologiques ; correction du calcul d'exécution des informations solaires et de la mise à jour de l'horodatage de débogage.",
-        "it": "Correggere la duplicazione del registro solare e le voci non valide, migliorare la stabilità del registro e la gestione del testo meteorologico; correggere il calcolo del runtime di Solar Insights e l'aggiornamento del timestamp di debug.",
-        "es": "Corrija la duplicación del libro de registro solar y las entradas no válidas, mejore la estabilidad del registro y el manejo de textos meteorológicos; corrige el cálculo del tiempo de ejecución de Solar Insights y la actualización de la marca de tiempo de depuración.",
-        "pl": "Napraw duplikację dziennika słonecznego i nieprawidłowe wpisy, popraw stabilność dziennika i obsługę tekstu pogodowego; napraw obliczenia czasu działania Solar Insights i aktualizację znacznika czasu debugowania.",
-        "uk": "Виправте дублювання сонячного журналу та недійсні записи, покращте стабільність журналу та обробку тексту погоди; виправити розрахунок часу виконання solar insights і налагодити оновлення часових позначок.",
-        "zh-cn": "修复太阳能日志重复和无效条目，提高日志稳定性和天气文本处理；修复 Solar Insights 运行时计算和调试时间戳更新。"
       }
     },
     "titleLang": {

package/lib/helpers/runtimeHelper.js

@@ -18,6 +18,7 @@ const runtimeHelper = {
     runtimeToday: 0, // Tageszeit (s)
     runtimeSeason: 0, // Laufzeit der aktuellen Saison (s)
     startCountToday: 0, // Anzahl Starts heute
+    restoreTimer: null, // FIX: ioBroker timer for delayed restore
     resetTimer: null,
     liveTimer: null, // Timer für Live-Updates
 
@@ -37,7 +38,12 @@ const runtimeHelper = {
         //      vollständig aus der Datenbank laden kann (Überinstallationsschutz)
         // ------------------------------------------------------
         this.adapter.log.debug('[runtimeHelper] Waiting 3 seconds to load persistent states ...');
-        await new Promise(resolve => setTimeout(resolve, 3000));
+        await new Promise(resolve => {
+            this.restoreTimer = this.adapter.setTimeout(() => {
+                this.restoreTimer = null;
+                resolve();
+            }, 3000);
+        });
 
         // Pumpenschalter überwachen
         this.adapter.subscribeStates('pump.pump_switch');
@@ -65,21 +71,24 @@ const runtimeHelper = {
         const totalRaw = (await this.adapter.getStateAsync('runtime.total'))?.val;
         const todayRaw = (await this.adapter.getStateAsync('runtime.today'))?.val;
         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] No saved runtimes found – possibly a new or reinstalled instance. Runtimes start at 0.',
-            );
-        }
+        const totalSecondsRaw = (await this.adapter.getStateAsync('runtime.total_seconds'))?.val;
+        const todaySecondsRaw = (await this.adapter.getStateAsync('runtime.today_seconds'))?.val;
+        const seasonSecondsRaw = (await this.adapter.getStateAsync('runtime.season_total_seconds'))?.val;
+
+        const countRaw = (await this.adapter.getStateAsync('runtime.start_count_today'))?.val;
 
-        // >>> NEU: Formatierten Text (z. B. "3h 12m 5s") in Sekunden umwandeln
-        this.runtimeTotal = this._parseFormattedTimeToSeconds(totalRaw);
-        this.runtimeToday = this._parseFormattedTimeToSeconds(todayRaw);
-        this.runtimeSeason = this._parseFormattedTimeToSeconds(seasonRaw);
+        // FIX: Restore prefers robust numeric seconds states and falls back to formatted legacy text states.
+        this.runtimeTotal = this._restoreRuntimeValue(totalSecondsRaw, totalRaw, 'runtime.total');
+        this.runtimeToday = this._restoreRuntimeValue(todaySecondsRaw, todayRaw, 'runtime.today');
+        this.runtimeSeason = this._restoreRuntimeValue(seasonSecondsRaw, seasonRaw, 'runtime.season_total');
         this.startCountToday = Number(countRaw) || 0;
 
+        await this.adapter.setStateAsync('runtime.total_seconds', { val: this.runtimeTotal, ack: true });
+        await this.adapter.setStateAsync('runtime.today_seconds', { val: this.runtimeToday, ack: true });
+        await this.adapter.setStateAsync('runtime.season_total_seconds', { val: this.runtimeSeason, ack: true });
+        await this.adapter.setStateAsync('runtime.current_session_seconds', { val: 0, ack: true });
+
         // Falls Pumpe gerade läuft → Status wiederherstellen
         const active = !!(await this.adapter.getStateAsync('pump.pump_switch'))?.val;
         if (active) {
@@ -132,8 +141,8 @@ const runtimeHelper = {
                     this.runtimeToday += delta;
                     this.runtimeTotal += delta;
 
-                    // Saisonlaufzeit nur zählen, wenn aktiv
-                    const seasonActive = !!(await this.adapter.getStateAsync('control.season.active'))?.val;
+                    // FIX: Use the actual season state used by the adapter; keep legacy fallback if it exists.
+                    const seasonActive = await this._isSeasonActive();
                     if (seasonActive) {
                         this.runtimeSeason += delta;
                     }
@@ -167,20 +176,27 @@ const runtimeHelper = {
     async _updateStates() {
         try {
             // Falls Pumpe läuft → temporäre Laufzeit seit lastOn einrechnen
+            const seasonActive = await this._isSeasonActive();
+            let effectiveTotal = this.runtimeTotal;
             let effectiveToday = this.runtimeToday;
             let effectiveSeason = this.runtimeSeason;
             let currentSessionSeconds = 0;
 
             if (this.isRunning && this.lastOn) {
                 const delta = Math.floor((Date.now() - this.lastOn) / 1000);
+                // FIX: Show the currently running session consistently in total and today.
+                effectiveTotal += delta;
                 effectiveToday += delta;
-                effectiveSeason += delta;
+                // FIX: Only show the running session in season_total while the same season status is active.
+                if (seasonActive) {
+                    effectiveSeason += delta;
+                }
                 currentSessionSeconds = delta;
             }
 
             // Formatiert schreiben
             const formattedToday = this._formatTime(effectiveToday);
-            const formattedTotal = this._formatTime(this.runtimeTotal);
+            const formattedTotal = this._formatTime(effectiveTotal);
             const formattedSeason = this._formatTime(effectiveSeason);
             const formattedCurrent = this._formatTime(currentSessionSeconds);
 
@@ -188,6 +204,16 @@ const runtimeHelper = {
             await this.adapter.setStateAsync('runtime.today', { val: formattedToday, ack: true });
             await this.adapter.setStateAsync('runtime.current_session', { val: formattedCurrent, ack: true });
             await this.adapter.setStateAsync('runtime.season_total', { val: formattedSeason, ack: true });
+
+            // FIX: Write robust numeric seconds states in parallel to existing formatted text states.
+            await this.adapter.setStateAsync('runtime.total_seconds', { val: effectiveTotal, ack: true });
+            await this.adapter.setStateAsync('runtime.today_seconds', { val: effectiveToday, ack: true });
+            await this.adapter.setStateAsync('runtime.current_session_seconds', {
+                val: currentSessionSeconds,
+                ack: true,
+            });
+            await this.adapter.setStateAsync('runtime.season_total_seconds', { val: effectiveSeason, ack: true });
+
             await this.adapter.setStateAsync('runtime.start_count_today', { val: this.startCountToday, ack: true });
 
             // Poolparameter laden (vor Durchflussprüfung!)
@@ -242,6 +268,38 @@ const runtimeHelper = {
         return `${h}h ${m}m ${s}s`;
     },
 
+    _restoreRuntimeValue(secondsRaw, formattedRaw, stateName) {
+        const seconds = Number(secondsRaw);
+        if (Number.isFinite(seconds) && seconds > 0) {
+            return Math.floor(seconds);
+        }
+
+        const parsed = this._parseFormattedTimeToSeconds(formattedRaw);
+        if (parsed > 0) {
+            return parsed;
+        }
+
+        if (formattedRaw && String(formattedRaw).trim() !== '0h 0m 0s') {
+            this.adapter.log.warn(
+                `[runtimeHelper] Could not restore ${stateName} from value "${formattedRaw}". Keeping runtime at 0.`,
+            );
+        }
+
+        return 0;
+    },
+
+    async _isSeasonActive() {
+        // FIX: status.season_active is the canonical season state used by the adapter.
+        const statusSeason = await this.adapter.getStateAsync('status.season_active');
+        if (statusSeason && statusSeason.val !== null && statusSeason.val !== undefined) {
+            return !!statusSeason.val;
+        }
+
+        // FIX: Keep a backward-compatible fallback for installations that still provide this legacy state.
+        const controlSeason = await this.adapter.getStateAsync('control.season.active');
+        return !!controlSeason?.val;
+    },
+
     // >>> NEU: formatierten Text (z. B. "3h 12m 5s") in Sekunden zurückrechnen
     _parseFormattedTimeToSeconds(value) {
         if (typeof value === 'number' && Number.isFinite(value)) {
@@ -272,18 +330,22 @@ const runtimeHelper = {
     },
 
     _scheduleDailyReset() {
+        if (this.resetTimer) {
+            this.adapter.clearTimeout(this.resetTimer);
+            this.resetTimer = null;
+        }
         const now = new Date();
         const nextMidnight = new Date(now);
         nextMidnight.setHours(24, 0, 0, 0);
         const msUntilMidnight = nextMidnight - now;
 
-        this.resetTimer = setTimeout(async () => {
+        this.resetTimer = this.adapter.setTimeout(async () => {
             this.runtimeToday = 0;
             this.startCountToday = 0;
             this.lastOn = this.isRunning ? Date.now() : null;
 
             // Laufzeiten zurücksetzen
-            this._updateStates();
+            await this._updateStates();
 
             // --- NEU: Circulation-Werte um Mitternacht zurücksetzen ---
             await this.adapter.setStateAsync('circulation.daily_total', { val: 0, ack: true });
@@ -313,25 +375,31 @@ const runtimeHelper = {
 
     _startLiveTimer() {
         if (this.liveTimer) {
-            clearInterval(this.liveTimer);
+            this.adapter.clearInterval(this.liveTimer);
         }
-        this.liveTimer = setInterval(() => this._updateStates(), 10 * 1000);
+        this.liveTimer = this.adapter.setInterval(() => this._updateStates(), 10 * 1000);
         this.adapter.log.debug('[runtimeHelper] Live timer started (updates every 10 seconds)');
     },
 
     _stopLiveTimer() {
         if (this.liveTimer) {
-            clearInterval(this.liveTimer);
+            this.adapter.clearInterval(this.liveTimer);
             this.liveTimer = null;
             this.adapter.log.debug('[runtimeHelper] Live timer stopped');
         }
     },
 
     cleanup() {
+        if (this.restoreTimer) {
+            this.adapter.clearTimeout(this.restoreTimer);
+            this.restoreTimer = null;
+        }
+
         if (this.resetTimer) {
-            clearTimeout(this.resetTimer);
+            this.adapter.clearTimeout(this.resetTimer);
             this.resetTimer = null;
         }
+
         this._stopLiveTimer();
     },
 };

package/lib/helpers/speechTextHelper.js

@@ -77,6 +77,14 @@ const speechTextHelper = {
             if (id.endsWith('solar.collector_warning')) {
                 const val = !!state.val;
 
+                const warnSpeech = !!(await this.adapter.getStateAsync('solar.warn_speech'))?.val;
+                if (!warnSpeech) {
+                    this.adapter.log.debug(
+                        '[speechTextHelper] Solar warning speech skipped (solar.warn_speech=false).',
+                    );
+                    return;
+                }
+
                 if (val) {
                     // Neue Warnung aktiv
                     const collectorTemp = Number(
@@ -100,6 +108,8 @@ const speechTextHelper = {
             // --- NEU: Reaktion auf Solarsteuerung ---
             if (id.endsWith('speech.solar_active')) {
                 const val = !!state.val;
+                const canSpeak = await this._canSendFromSource('solar');
+
                 // Pumpenstatus aktualisieren, damit auch im VIS korrekt sichtbar
                 if (val) {
                     await this.adapter.setStateAsync('pump.status', {
@@ -114,12 +124,20 @@ const speechTextHelper = {
                 }
                 if (val) {
                     const text = 'Die Poolpumpe wurde durch die Solarsteuerung eingeschaltet.';
-                    await this._sendSpeech(text);
-                    this.adapter.log.debug('[speechTextHelper] Solar control activated → announcement sent.');
+                    const sent = await this._sendSpeechFromSource('solar', text, canSpeak);
+                    this.adapter.log.debug(
+                        sent
+                            ? '[speechTextHelper] Solar control activated → announcement sent.'
+                            : '[speechTextHelper] Solar control activated → announcement skipped.',
+                    );
                 } else {
                     const text = 'Solarsteuerung beendet – Poolpumpe ausgeschaltet.';
-                    await this._sendSpeech(text);
-                    this.adapter.log.debug('[speechTextHelper] Solar control deactivated → announcement sent.');
+                    const sent = await this._sendSpeechFromSource('solar', text, canSpeak);
+                    this.adapter.log.debug(
+                        sent
+                            ? '[speechTextHelper] Solar control deactivated → announcement sent.'
+                            : '[speechTextHelper] Solar control deactivated → announcement skipped.',
+                    );
                 }
                 return;
             }
@@ -127,6 +145,7 @@ const speechTextHelper = {
             // --- NEU: Reaktion auf Zeitsteuerung ---
             if (id.endsWith('speech.time_active')) {
                 const val = !!state.val;
+                const canSpeak = await this._canSendFromSource('time');
 
                 // Pumpenstatus mitpflegen
                 if (val) {
@@ -135,16 +154,24 @@ const speechTextHelper = {
                         ack: true,
                     });
                     const text = 'Die Poolpumpe wurde durch die Zeitsteuerung eingeschaltet.';
-                    await this._sendSpeech(text);
-                    this.adapter.log.debug('[speechTextHelper] Time control activated → announcement sent.');
+                    const sent = await this._sendSpeechFromSource('time', text, canSpeak);
+                    this.adapter.log.debug(
+                        sent
+                            ? '[speechTextHelper] Time control activated → announcement sent.'
+                            : '[speechTextHelper] Time control activated → announcement skipped.',
+                    );
                 } else {
                     await this.adapter.setStateAsync('pump.status', {
                         val: 'AUS (Zeitsteuerung beendet)',
                         ack: true,
                     });
                     const text = 'Zeitsteuerung beendet – Poolpumpe ausgeschaltet.';
-                    await this._sendSpeech(text);
-                    this.adapter.log.debug('[speechTextHelper] Time control deactivated → announcement sent.');
+                    const sent = await this._sendSpeechFromSource('time', text, canSpeak);
+                    this.adapter.log.debug(
+                        sent
+                            ? '[speechTextHelper] Time control deactivated → announcement sent.'
+                            : '[speechTextHelper] Time control deactivated → announcement skipped.',
+                    );
                 }
                 return;
             }
@@ -155,6 +182,54 @@ const speechTextHelper = {
         }
     },
 
+    async _canSendFromSource(source) {
+        const enabled = !!(await this.adapter.getStateAsync(`speech.sources.${source}.enabled`))?.val;
+        if (!enabled) {
+            this.adapter.log.debug(`[speechTextHelper] Speech source "${source}" is disabled.`);
+            return false;
+        }
+
+        const cooldownMinutes = Number(
+            (await this.adapter.getStateAsync(`speech.sources.${source}.cooldown_minutes`))?.val || 0,
+        );
+        if (cooldownMinutes <= 0) {
+            return true;
+        }
+
+        const lastSentRaw = (await this.adapter.getStateAsync(`speech.sources.${source}.last_sent`))?.val;
+        const lastSentTs = Date.parse(String(lastSentRaw || ''));
+
+        if (!Number.isFinite(lastSentTs)) {
+            return true;
+        }
+
+        const elapsedMs = Date.now() - lastSentTs;
+        const cooldownMs = cooldownMinutes * 60 * 1000;
+
+        if (elapsedMs < cooldownMs) {
+            this.adapter.log.debug(
+                `[speechTextHelper] Speech source "${source}" skipped by cooldown (${cooldownMinutes} min).`,
+            );
+            return false;
+        }
+
+        return true;
+    },
+
+    async _sendSpeechFromSource(source, text, canSpeak) {
+        if (!canSpeak) {
+            return false;
+        }
+
+        await this._sendSpeech(text);
+        await this.adapter.setStateAsync(`speech.sources.${source}.last_sent`, {
+            val: new Date().toISOString(),
+            ack: true,
+        });
+
+        return true;
+    },
+
     /**
      * Sendet Text an speech.queue.
      *

package/lib/stateDefinitions/runtimeStates.js

@@ -3,10 +3,14 @@
 /**
  * Legt alle States für Laufzeit- und Umwälzwerte an:
  * - runtime.total
+ * - runtime.total_seconds
  * - runtime.today
+ * - runtime.today_seconds
  * - runtime.start_count_today
  * - runtime.current_session
+ * - runtime.current_session_seconds
  * - runtime.season_total
+ * - runtime.season_total_seconds
  * - circulation.daily_total
  * - circulation.daily_required
  * - circulation.daily_remaining
@@ -53,6 +57,32 @@ async function createRuntimeStates(adapter) {
         await adapter.setStateAsync('runtime.total', { val: '0h 0m 0s', ack: true }); // FIX: Nur setzen, wenn leer
     }
 
+    // FIX: Gesamtlaufzeit als robuster Rohwert in Sekunden
+    await adapter.setObjectNotExistsAsync('runtime.total_seconds', {
+        type: 'state',
+        common: {
+            name: {
+                en: 'Total runtime (seconds)',
+                de: 'Gesamtlaufzeit (Sekunden)',
+            },
+            desc: {
+                en: 'Total pump runtime as raw value in seconds',
+                de: 'Gesamtlaufzeit der Pumpe als Rohwert in Sekunden',
+            },
+            type: 'number',
+            role: 'value',
+            unit: 's',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingTotalSeconds = await adapter.getStateAsync('runtime.total_seconds');
+    if (!existingTotalSeconds || existingTotalSeconds.val === null || existingTotalSeconds.val === undefined) {
+        await adapter.setStateAsync('runtime.total_seconds', { val: 0, ack: true });
+    }
+
     // Tageslaufzeit (formatiert)
     await adapter.setObjectNotExistsAsync('runtime.today', {
         type: 'state',
@@ -78,6 +108,32 @@ async function createRuntimeStates(adapter) {
         await adapter.setStateAsync('runtime.today', { val: '0h 0m 0s', ack: true }); // FIX
     }
 
+    // FIX: Tageslaufzeit als robuster Rohwert in Sekunden
+    await adapter.setObjectNotExistsAsync('runtime.today_seconds', {
+        type: 'state',
+        common: {
+            name: {
+                en: 'Today runtime (seconds)',
+                de: 'Heutige Laufzeit (Sekunden)',
+            },
+            desc: {
+                en: 'Pump runtime for today as raw value in seconds',
+                de: 'Heutige Laufzeit der Pumpe als Rohwert in Sekunden',
+            },
+            type: 'number',
+            role: 'value',
+            unit: 's',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingTodaySeconds = await adapter.getStateAsync('runtime.today_seconds');
+    if (!existingTodaySeconds || existingTodaySeconds.val === null || existingTodaySeconds.val === undefined) {
+        await adapter.setStateAsync('runtime.today_seconds', { val: 0, ack: true });
+    }
+
     // -------------------------------------------------------------------------
     // NEU: Pumpenstarts heute
     await adapter.setObjectNotExistsAsync('runtime.start_count_today', {
@@ -129,6 +185,32 @@ async function createRuntimeStates(adapter) {
         await adapter.setStateAsync('runtime.current_session', { val: '0h 0m 0s', ack: true }); // FIX
     }
 
+    // FIX: Aktuelle Session als robuster Rohwert in Sekunden
+    await adapter.setObjectNotExistsAsync('runtime.current_session_seconds', {
+        type: 'state',
+        common: {
+            name: {
+                en: 'Current runtime (seconds)',
+                de: 'Aktuelle Laufzeit (Sekunden)',
+            },
+            desc: {
+                en: 'Current pump runtime since switch-on as raw value in seconds',
+                de: 'Aktuelle Laufzeit seit dem Einschalten der Pumpe als Rohwert in Sekunden',
+            },
+            type: 'number',
+            role: 'value',
+            unit: 's',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingCurrentSeconds = await adapter.getStateAsync('runtime.current_session_seconds');
+    if (!existingCurrentSeconds || existingCurrentSeconds.val === null || existingCurrentSeconds.val === undefined) {
+        await adapter.setStateAsync('runtime.current_session_seconds', { val: 0, ack: true });
+    }
+
     // NEU: Gesamtlaufzeit der aktuellen Saison (formatiert)
     await adapter.setObjectNotExistsAsync('runtime.season_total', {
         type: 'state',
@@ -154,6 +236,32 @@ async function createRuntimeStates(adapter) {
         await adapter.setStateAsync('runtime.season_total', { val: '0h 0m 0s', ack: true }); // FIX
     }
 
+    // FIX: Saisonlaufzeit als robuster Rohwert in Sekunden
+    await adapter.setObjectNotExistsAsync('runtime.season_total_seconds', {
+        type: 'state',
+        common: {
+            name: {
+                en: 'Season runtime (seconds)',
+                de: 'Saisonlaufzeit (Sekunden)',
+            },
+            desc: {
+                en: 'Pump runtime for the current season as raw value in seconds',
+                de: 'Laufzeit der Pumpe fuer die aktuelle Saison als Rohwert in Sekunden',
+            },
+            type: 'number',
+            role: 'value',
+            unit: 's',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingSeasonSeconds = await adapter.getStateAsync('runtime.season_total_seconds');
+    if (!existingSeasonSeconds || existingSeasonSeconds.val === null || existingSeasonSeconds.val === undefined) {
+        await adapter.setStateAsync('runtime.season_total_seconds', { val: 0, ack: true });
+    }
+
     // -------------------------------------------------------------------------
     // --- Kanal circulation ---
     await adapter.setObjectNotExistsAsync('circulation', {

package/lib/stateDefinitions/speechStates.js

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

package/package.json

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