iobroker.poolcontrol 1.3.26 → 1.3.28

package/README.md

@@ -48,7 +48,7 @@ It provides automation for pumps, heating, solar and photovoltaic control as wel
   - Priority and block logic
   - Status section under `solar.extended.*`
 
-- **Photovoltaic Control (since v0.6.0)**
+- **Photovoltaic Control**
   - Pump control based on PV surplus and household consumption
   - Start logic using configurable surplus margins
   - Optional overrun during cloudy phases
@@ -56,7 +56,7 @@ It provides automation for pumps, heating, solar and photovoltaic control as wel
   - Supports external energy object IDs
   - Pump mode: `Automatic (PV)`
 
-- **Heating / Heat Pump Control (test phase)**
+- **Heating / Heat Pump Control**
   - Automatic control of heating rod or heat pump
   - Configurable target and safety temperatures
   - Optional pump prerun and overrun
@@ -102,7 +102,7 @@ It provides automation for pumps, heating, solar and photovoltaic control as wel
   - Automatic reset after completed backwash
   - PV integration for circulation targets
 
-- **Pressure Sensor Integration (since v0.7.x)**
+- **Pressure Sensor Integration**
   - Real-time pressure measurement
   - Trend analysis
   - Learning average values
@@ -176,6 +176,17 @@ It provides automation for pumps, heating, solar and photovoltaic control as wel
   - No chlorine control
   - No automatic dosing
 
+  **Chemistry Tools**
+  - pH Plus calculator
+  - pH Minus calculator
+  - Salt calculator
+  - Manual calculation helpers
+  - Pool volume prefill support
+  - Optional manual value override
+  - Result texts with validation and error handling
+  -No automatic chemical dosing
+  - Informational only
+
 - **AI System**
   - Weather hints (Open-Meteo)
   - Pool recommendations
@@ -252,6 +263,22 @@ New features are added regularly – please refer to the changelog.
 ---
 
 ## Changelog
+### 1.3.28 (2026-06-03)
+
+- Added configurable startup power check timeout for pump monitoring (`pump.startup_power_check_timeout_sec`).
+- Default behavior remains unchanged (5 seconds).
+- Improved compatibility with delayed power measurements from smart plugs and power meters.
+
+### 1.3.27 (2026-05-30)
+
+- Added new Chemistry Tools section
+- Added pH Plus Calculator
+- Added pH Minus Calculator
+- Added Salt Calculator
+- Added validation, result texts and error handling for all calculators
+- Added automatic pool volume prefill support
+- Expanded documentation and function overviews
+
 ### 1.3.26 (2026-05-28)
 
 - Reworked multiple warnings and review notes from official ioBroker checks
@@ -270,25 +297,6 @@ New features are added regularly – please refer to the changelog.
 - Improved README and changelog structure
 - Repository checker recommendations reviewed
 
-### 1.3.23 (2026-05-26)
-
-- Added extended temperature diagnostics for all temperature sensors:
-  - last valid value
-  - last valid value timestamp
-  - minutes since last value
-  - source status (`ok`, `warning`, `not_received`, `invalid_timestamp`)
-- Added automatic recovery mechanism for stalled temperature updates
-- Recovery runs only when a sensor enters warning state and uses cooldown protection
-- Switched temperature helper timers to ioBroker adapter timers
-- Improved visibility and troubleshooting for missing or delayed temperature updates
-
-### 1.3.22 (2026-05-24)
-
-- Improved ORP pH reference synchronization
-- ORP helper now updates pH reference independently from ORP value processing
-- Immediate update of ORP pH reference when pH enabled state or pH value changes
-- Fixed missing pH reference updates when ORP evaluation was blocked, invalid or waiting for measurement conditions
-
 ## Archived Release History
 
 For older releases and archived version history see:

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "poolcontrol",
-    "version": "1.3.26",
+    "version": "1.3.28",
     "news": {
+      "1.3.28": {
+        "en": "Added configurable startup power check timeout for pump monitoring (5-10 seconds). Improved compatibility with delayed power measurements from smart plugs and power meters.",
+        "de": "Konfigurierbares Timeout für die Leistungsprüfung nach Pumpenstart (5-10 Sekunden) hinzugefügt. Kompatibilität mit verzögert aktualisierten Leistungswerten von Smart-Steckdosen und Leistungsmessern verbessert.",
+        "ru": "Добавлен настраиваемый тайм-аут проверки мощности при запуске для мониторинга насоса (5–10 секунд). Улучшена совместимость с измерениями мощности с задержкой от интеллектуальных розеток и измерителей мощности.",
+        "pt": "Adicionado tempo limite de verificação de energia de inicialização configurável para monitoramento da bomba (5 a 10 segundos). Compatibilidade aprimorada com medições de energia atrasadas de plugues inteligentes e medidores de energia.",
+        "nl": "Configureerbare time-out voor stroomcontrole bij opstarten toegevoegd voor pompbewaking (5-10 seconden). Verbeterde compatibiliteit met vertraagde stroommetingen van slimme stekkers en stroommeters.",
+        "fr": "Ajout d'un délai d'expiration configurable pour la vérification de l'alimentation au démarrage pour la surveillance de la pompe (5 à 10 secondes). Compatibilité améliorée avec les mesures de puissance retardées des prises intelligentes et des compteurs de puissance.",
+        "it": "Aggiunto timeout configurabile del controllo dell'alimentazione all'avvio per il monitoraggio della pompa (5-10 secondi). Compatibilità migliorata con misurazioni di potenza ritardate da prese intelligenti e misuratori di potenza.",
+        "es": "Se agregó un tiempo de espera de verificación de energía de inicio configurable para el monitoreo de la bomba (5-10 segundos). Compatibilidad mejorada con mediciones de potencia retrasadas de enchufes inteligentes y medidores de potencia.",
+        "pl": "Dodano konfigurowalny limit czasu sprawdzania mocy rozruchowej dla monitorowania pompy (5-10 sekund). Poprawiona kompatybilność z opóźnionymi pomiarami mocy z inteligentnych wtyczek i mierników mocy.",
+        "uk": "Додано настроюваний тайм-аут перевірки живлення при запуску для моніторингу насоса (5-10 секунд). Покращена сумісність із затримкою вимірювання потужності від розумних розеток і лічильників.",
+        "zh-cn": "添加了用于泵监控的可配置启动电源检查超时（5-10 秒）。改进了与智能插头和功率计的延迟功率测量的兼容性。"
+      },
+      "1.3.27": {
+        "en": "Added new Chemistry Tools with pH Plus Calculator, pH Minus Calculator and Salt Calculator. Added validation, result texts, error handling and automatic pool volume prefill. Expanded documentation and function overviews.",
+        "de": "Neuen Bereich Chemistry Tools mit pH-Plus-Rechner, pH-Minus-Rechner und Salz-Rechner hinzugefügt. Validierungen, Ergebnistexte, Fehlerbehandlung und automatische Vorbelegung des Poolvolumens ergänzt. Dokumentation und Funktionsübersichten erweitert.",
+        "ru": "Добавлены новые химические инструменты с калькулятором pH плюс, калькулятором pH минус и калькулятором соли. Добавлена ​​проверка, тексты результатов, обработка ошибок и автоматическое предварительное заполнение объема пула. Расширенная документация и обзоры функций.",
+        "pt": "Adicionadas novas ferramentas de química com calculadora pH Plus, calculadora pH menos e calculadora de sal. Adicionados validação, textos de resultados, tratamento de erros e preenchimento automático do volume do pool. Documentação expandida e visões gerais de funções.",
+        "nl": "Nieuwe chemiehulpmiddelen toegevoegd met pH Plus-calculator, pH-minuscalculator en Zoutcalculator. Validatie, resultaatteksten, foutafhandeling en automatisch vooraf invullen van poolvolumes toegevoegd. Uitgebreide documentatie en functieoverzichten.",
+        "fr": "Ajout de nouveaux outils de chimie avec calculateur de pH Plus, calculateur de pH Moins et calculateur de sel. Ajout de la validation, des textes de résultats, de la gestion des erreurs et du pré-remplissage automatique du volume du pool. Documentation étendue et aperçus des fonctions.",
+        "it": "Aggiunti nuovi strumenti di chimica con calcolatore di pH più, calcolatore di pH meno e calcolatore di sale. Aggiunta convalida, testi dei risultati, gestione degli errori e precompilazione automatica del volume del pool. Documentazione estesa e panoramiche delle funzioni.",
+        "es": "Se agregaron nuevas herramientas de química con calculadora de pH Plus, calculadora de pH Minus y calculadora de sal. Se agregó validación, textos de resultados, manejo de errores y precarga automática del volumen del grupo. Documentación ampliada y descripciones generales de funciones.",
+        "pl": "Dodano nowe narzędzia chemiczne z kalkulatorem pH Plus, kalkulatorem pH Minus i kalkulatorem soli. Dodano weryfikację, teksty wyników, obsługę błędów i automatyczne wstępne wypełnianie objętości puli. Rozszerzona dokumentacja i przeglądy funkcji.",
+        "uk": "Додано нові хімічні інструменти з калькулятором pH Plus, калькулятором pH мінус і калькулятором солі. Додано перевірку, тексти результатів, обробку помилок і автоматичне попереднє заповнення обсягу пулу. Розширена документація та огляд функцій.",
+        "zh-cn": "添加了新的化学工具，包括 pH 加计算器、pH 减计算器和盐计算器。添加了验证、结果文本、错误处理和自动池容量预填充。扩展的文档和功能概述。"
+      },
       "1.3.26": {
         "en": "Reworked several warnings and review notes from official ioBroker checks. Various small improvements and internal cleanups.",
         "de": "Mehrere Warnungen und Review-Hinweise aus offiziellen ioBroker-Checks überarbeitet. Diverse kleine Verbesserungen und interne Bereinigungen.",
@@ -41,32 +67,6 @@
         "pl": "Zaktualizowane komponenty repozytorium i opiekuna: zaktualizowane zależności skryptu wydania, ulepszona struktura README/dziennika zmian i sprawdzone sugestie dotyczące sprawdzania repozytorium",
         "uk": "Оновлений репозиторій і компоненти супроводжувача: оновлені залежності сценарію випуску, покращена структура README/журналу змін і переглянуті пропозиції перевірки сховища",
         "zh-cn": "更新了存储库和维护者组件：更新了发布脚本依赖项，改进了自述文件/变更日志结构并审查了存储库检查器建议"
-      },
-      "1.3.23": {
-        "en": "Temperature diagnostics extended: Added new diagnostic states for all temperature sensors (last valid value, timestamp, minutes since last value, source status). Added self-healing/recovery mechanism for stalled or missing temperature events. Temperature helper updated to ioBroker-compliant timers.",
-        "de": "Temperaturbereich erweitert: Neue Diagnosewerte für alle Temperatursensoren ergänzt (letzter gültiger Wert, Zeitstempel, Minuten seit letztem Wert, Quellenstatus). Zusätzlich Selbstheilungs-/Recovery-Mechanismus für ausgefallene oder hängende Temperatur-Events ergänzt. Temperaturhelper auf ioBroker-konforme Timer umgestellt.",
-        "ru": "Расширенная диагностика температуры: добавлены новые диагностические состояния для всех датчиков температуры (последнее действительное значение, временная метка, минуты с момента последнего значения, состояние источника). Добавлен механизм самовосстановления/восстановления при остановке или отсутствии температурных событий. Помощник по температуре обновлен до таймеров, совместимых с ioBroker.",
-        "pt": "Diagnóstico de temperatura estendido: Adicionados novos estados de diagnóstico para todos os sensores de temperatura (último valor válido, carimbo de data/hora, minutos desde o último valor, status da fonte). Adicionado mecanismo de autocorreção/recuperação para eventos de temperatura paralisados ​​ou ausentes. Auxiliar de temperatura atualizado para temporizadores compatíveis com ioBroker.",
-        "nl": "Temperatuurdiagnostiek uitgebreid: Nieuwe diagnostische statussen toegevoegd voor alle temperatuursensoren (laatste geldige waarde, tijdstempel, minuten sinds laatste waarde, bronstatus). Zelfherstel-/herstelmechanisme toegevoegd voor vastgelopen of ontbrekende temperatuurgebeurtenissen. Temperatuurhelper bijgewerkt naar ioBroker-compatibele timers.",
-        "fr": "Diagnostics de température étendus : ajout de nouveaux états de diagnostic pour tous les capteurs de température (dernière valeur valide, horodatage, minutes depuis la dernière valeur, état de la source). Ajout d'un mécanisme d'auto-guérison/récupération pour les événements de température bloqués ou manquants. Assistant de température mis à jour avec des minuteries conformes à ioBroker.",
-        "it": "Diagnostica della temperatura estesa: aggiunti nuovi stati diagnostici per tutti i sensori di temperatura (ultimo valore valido, timestamp, minuti dall'ultimo valore, stato della sorgente). Aggiunto meccanismo di autoriparazione/recupero per eventi di temperatura bloccati o mancanti. Assistente per la temperatura aggiornato ai timer compatibili con ioBroker.",
-        "es": "Diagnóstico de temperatura extendido: se agregaron nuevos estados de diagnóstico para todos los sensores de temperatura (último valor válido, marca de tiempo, minutos desde el último valor, estado de fuente). Se agregó un mecanismo de autorreparación/recuperación para eventos de temperatura estancados o faltantes. Asistente de temperatura actualizado a temporizadores compatibles con ioBroker.",
-        "pl": "Rozszerzona diagnostyka temperatury: Dodano nowe stany diagnostyczne dla wszystkich czujników temperatury (ostatnia ważna wartość, znacznik czasu, minuty od ostatniej wartości, stan źródła). Dodano mechanizm samonaprawy/odzyskiwania w przypadku zablokowania lub braku zdarzeń związanych z temperaturą. Pomocnik temperatury zaktualizowany do timerów zgodnych z ioBroker.",
-        "uk": "Розширено діагностику температури: додано нові діагностичні стани для всіх датчиків температури (останнє дійсне значення, позначка часу, хвилини з останнього значення, статус джерела). Додано механізм самовідновлення/відновлення для зупинених або відсутніх температурних подій. Помічник температури оновлено до таймерів, сумісних із ioBroker.",
-        "zh-cn": "温度诊断扩展：为所有温度传感器添加了新的诊断状态（最后一个有效值、时间戳、自最后一个值以来的分钟数、源状态）。添加了针对停滞或丢失温度事件的自我修复/恢复机制。温度助手更新为符合 ioBroker 标准的计时器。"
-      },
-      "1.3.22": {
-        "en": "Improved ORP pH reference synchronization. The ORP helper now updates the pH reference independently from ORP value processing and immediately reflects pH state changes.",
-        "de": "ORP-pH-Referenz verbessert. Der ORP-Helper aktualisiert die pH-Referenz jetzt unabhängig von der ORP-Wertverarbeitung und übernimmt pH-Änderungen sofort.",
-        "ru": "Улучшена синхронизация эталонного значения pH ОВП. Помощник по ОВП теперь обновляет эталонное значение pH независимо от обработки значений ОВП и немедленно отражает изменения состояния pH.",
-        "pt": "Sincronização de referência de pH ORP aprimorada. O auxiliar ORP agora atualiza a referência de pH independentemente do processamento do valor ORP e reflete imediatamente as alterações do estado de pH.",
-        "nl": "Verbeterde ORP pH-referentiesynchronisatie. De ORP-helper werkt nu de pH-referentie onafhankelijk van de ORP-waardeverwerking bij en weerspiegelt onmiddellijk veranderingen in de pH-toestand.",
-        "fr": "Synchronisation améliorée de la référence ORP pH. L'assistant ORP met désormais à jour la référence pH indépendamment du traitement de la valeur ORP et reflète immédiatement les changements d'état du pH.",
-        "it": "Sincronizzazione del riferimento pH ORP migliorata. L'assistente ORP ora aggiorna il riferimento del pH indipendentemente dall'elaborazione del valore ORP e riflette immediatamente i cambiamenti dello stato del pH.",
-        "es": "Sincronización de referencia de pH ORP mejorada. El asistente de ORP ahora actualiza la referencia de pH independientemente del procesamiento del valor de ORP y refleja inmediatamente los cambios en el estado del pH.",
-        "pl": "Ulepszona synchronizacja odniesienia pH ORP. Pomocnik ORP aktualizuje teraz wartość odniesienia pH niezależnie od przetwarzania wartości ORP i natychmiast odzwierciedla zmiany stanu pH.",
-        "uk": "Покращена синхронізація еталонного pH ОВП. Помічник ОВП тепер оновлює еталонний рН незалежно від обробки значення ОВП і негайно відображає зміни стану рН.",
-        "zh-cn": "改进了 ORP pH 参考同步。 ORP 助手现在独立于 ORP 值处理更新 pH 参考值，并立即反映 pH 状态变化。"
       }
     },
     "titleLang": {

package/lib/helpers/chemistryToolsHelper.js

@@ -0,0 +1,413 @@
+'use strict';
+
+const { I18n } = require('@iobroker/adapter-core');
+
+const PH_STEP = 0.1;
+const VOLUME_REFERENCE_L = 10000;
+
+const chemistryToolsHelper = {
+    adapter: null,
+
+    /**
+     * @param {import('iobroker').Adapter} adapter - ioBroker adapter instance
+     */
+    init(adapter) {
+        this.adapter = adapter;
+
+        void this._subscribeStates();
+        void this._prefillCalculatorValues();
+
+        this.adapter.log.debug('[chemistryToolsHelper] Initialized');
+    },
+
+    async _subscribeStates() {
+        const ids = [
+            'general.pool_size',
+            'chemistry.ph.input.current_value',
+
+            'chemistry.tools.ph_plus_calculator.05_calculate',
+            'chemistry.tools.ph_plus_calculator.01_pool_volume_l',
+            'chemistry.tools.ph_plus_calculator.02_current_ph',
+            'chemistry.tools.ph_plus_calculator.03_target_ph',
+            'chemistry.tools.ph_plus_calculator.04_grams_per_10000l_01ph',
+
+            'chemistry.tools.ph_minus_calculator.05_calculate',
+            'chemistry.tools.ph_minus_calculator.01_pool_volume_l',
+            'chemistry.tools.ph_minus_calculator.02_current_ph',
+            'chemistry.tools.ph_minus_calculator.03_target_ph',
+            'chemistry.tools.ph_minus_calculator.04_grams_per_10000l_01ph',
+
+            'chemistry.tools.salt_calculator.04_calculate',
+            'chemistry.tools.salt_calculator.01_pool_volume_l',
+            'chemistry.tools.salt_calculator.02_current_salt_ppm',
+            'chemistry.tools.salt_calculator.03_target_salt_ppm',
+        ];
+
+        for (const id of ids) {
+            await this.adapter.subscribeStatesAsync(id);
+        }
+
+        this.adapter.log.debug('[chemistryToolsHelper] Own states subscribed');
+    },
+
+    /**
+     * @param {string} id - Changed state ID
+     * @param {ioBroker.State | null | undefined} state - Changed state
+     * @returns {Promise<void>}
+     */
+    async handleStateChange(id, state) {
+        if (!state) {
+            return;
+        }
+
+        try {
+            if (id.endsWith('general.pool_size') || id.endsWith('chemistry.ph.input.current_value')) {
+                await this._prefillCalculatorValues();
+                return;
+            }
+
+            if (
+                id.endsWith('chemistry.tools.ph_plus_calculator.05_calculate') &&
+                state.ack === false &&
+                state.val === true
+            ) {
+                await this._calculatePhPlus();
+                await this._setBool('chemistry.tools.ph_plus_calculator.05_calculate', false);
+                return;
+            }
+
+            if (
+                id.endsWith('chemistry.tools.ph_minus_calculator.05_calculate') &&
+                state.ack === false &&
+                state.val === true
+            ) {
+                await this._calculatePhMinus();
+                await this._setBool('chemistry.tools.ph_minus_calculator.05_calculate', false);
+            }
+
+            if (
+                id.endsWith('chemistry.tools.salt_calculator.04_calculate') &&
+                state.ack === false &&
+                state.val === true
+            ) {
+                await this._calculateSalt();
+                await this._setBool('chemistry.tools.salt_calculator.04_calculate', false);
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[chemistryToolsHelper] Error in handleStateChange: ${err.message}`);
+        }
+    },
+
+    async _prefillCalculatorValues() {
+        const poolVolume = await this._readNumber('general.pool_size');
+        const currentPh = await this._readNumber('chemistry.ph.input.current_value');
+
+        await this._prefillNumberIfEmpty('chemistry.tools.ph_plus_calculator.01_pool_volume_l', poolVolume);
+        await this._prefillNumberIfEmpty('chemistry.tools.ph_minus_calculator.01_pool_volume_l', poolVolume);
+        await this._prefillNumberIfEmpty('chemistry.tools.salt_calculator.01_pool_volume_l', poolVolume);
+
+        await this._prefillNumberIfEmpty('chemistry.tools.ph_plus_calculator.02_current_ph', currentPh);
+        await this._prefillNumberIfEmpty('chemistry.tools.ph_minus_calculator.02_current_ph', currentPh);
+    },
+
+    /**
+     * Calculates the pH Plus amount using the manufacturer dosage formula.
+     *
+     * @returns {Promise<void>}
+     */
+    async _calculatePhPlus() {
+        const base = 'chemistry.tools.ph_plus_calculator';
+
+        const poolVolume = await this._readNumber(`${base}.01_pool_volume_l`);
+        const currentPh = await this._readNumber(`${base}.02_current_ph`);
+        const targetPh = await this._readNumber(`${base}.03_target_ph`);
+        const dosageFactor = await this._readNumber(`${base}.04_grams_per_10000l_01ph`);
+
+        const validation = this._validateInputs({
+            type: 'plus',
+            poolVolume,
+            currentPh,
+            targetPh,
+            dosageFactor,
+        });
+
+        if (!validation.valid) {
+            await this._writeInvalidResult(base, validation.error);
+            return;
+        }
+
+        const resultGrams = this._calculateAmountGrams(currentPh, targetPh, poolVolume, dosageFactor);
+        const roundedGrams = Math.round(resultGrams);
+
+        const resultText =
+            `${I18n.translate('Calculated amount')}: ${roundedGrams} g pH Plus. ` +
+            `${I18n.translate('Reference value based on common manufacturer dosage.')} ` +
+            `${I18n.translate('Follow the manufacturer instructions and re-measure afterwards.')}`;
+
+        await this._writeValidResult(base, roundedGrams, resultText);
+    },
+
+    /**
+     * Calculates the pH Minus amount using the manufacturer dosage formula.
+     *
+     * @returns {Promise<void>}
+     */
+    async _calculatePhMinus() {
+        const base = 'chemistry.tools.ph_minus_calculator';
+
+        const poolVolume = await this._readNumber(`${base}.01_pool_volume_l`);
+        const currentPh = await this._readNumber(`${base}.02_current_ph`);
+        const targetPh = await this._readNumber(`${base}.03_target_ph`);
+        const dosageFactor = await this._readNumber(`${base}.04_grams_per_10000l_01ph`);
+
+        const validation = this._validateInputs({
+            type: 'minus',
+            poolVolume,
+            currentPh,
+            targetPh,
+            dosageFactor,
+        });
+
+        if (!validation.valid) {
+            await this._writeInvalidResult(base, validation.error);
+            return;
+        }
+
+        const resultGrams = this._calculateAmountGrams(currentPh, targetPh, poolVolume, dosageFactor);
+        const roundedGrams = Math.round(resultGrams);
+
+        const resultText =
+            `${I18n.translate('Calculated amount')}: ${roundedGrams} g pH Minus. ` +
+            `${I18n.translate('Reference value based on common manufacturer dosage.')} ` +
+            `${I18n.translate('Follow the manufacturer instructions and re-measure afterwards.')}`;
+
+        await this._writeValidResult(base, roundedGrams, resultText);
+    },
+
+    /**
+     * Calculates the salt amount needed to raise the salt concentration.
+     *
+     * @returns {Promise<void>} Resolves when the salt calculation result has been written.
+     */
+    async _calculateSalt() {
+        const base = 'chemistry.tools.salt_calculator';
+
+        const poolVolume = await this._readNumber(`${base}.01_pool_volume_l`);
+        const currentSalt = await this._readNumber(`${base}.02_current_salt_ppm`);
+        const targetSalt = await this._readNumber(`${base}.03_target_salt_ppm`);
+
+        if (!Number.isFinite(poolVolume) || poolVolume <= 0) {
+            await this._writeInvalidSaltResult(base, I18n.translate('Pool volume must be greater than 0 liters.'));
+            return;
+        }
+
+        if (!Number.isFinite(currentSalt) || currentSalt < 0) {
+            await this._writeInvalidSaltResult(
+                base,
+                I18n.translate('Current salt concentration must be 0 ppm or higher.'),
+            );
+            return;
+        }
+
+        if (!Number.isFinite(targetSalt) || targetSalt <= currentSalt) {
+            await this._writeInvalidSaltResult(
+                base,
+                I18n.translate('Target salt concentration must be higher than the current salt concentration.'),
+            );
+            return;
+        }
+
+        const resultKg = ((targetSalt - currentSalt) * poolVolume) / 1000000;
+        const roundedKg = Math.round(resultKg * 10) / 10;
+
+        const resultText =
+            `${I18n.translate('Calculated amount')}: ${roundedKg} kg ${I18n.translate('salt')}. ` +
+            `${I18n.translate('Reference value for raising the salt concentration in pool water.')} ` +
+            `${I18n.translate('Follow the salt system manufacturer instructions and add salt gradually.')}`;
+
+        await this._writeValidSaltResult(base, roundedKg, resultText);
+    },
+
+    /**
+     * @param {object} input - Calculator input values
+     * @param {'plus' | 'minus'} input.type - Calculator type
+     * @param {number} input.poolVolume - Pool volume in liters
+     * @param {number} input.currentPh - Current pH value
+     * @param {number} input.targetPh - Target pH value
+     * @param {number} input.dosageFactor - Dosage factor in grams per 10,000 l and 0.1 pH
+     * @returns {{ valid: boolean, error: string }} Validation result with an optional translated error message.
+     */
+    _validateInputs(input) {
+        if (!Number.isFinite(input.poolVolume) || input.poolVolume <= 0) {
+            return { valid: false, error: I18n.translate('Pool volume must be greater than 0 liters.') };
+        }
+
+        if (!Number.isFinite(input.currentPh) || input.currentPh <= 0 || input.currentPh > 14) {
+            return { valid: false, error: I18n.translate('Current pH value must be between 0 and 14.') };
+        }
+
+        if (!Number.isFinite(input.targetPh) || input.targetPh <= 0 || input.targetPh > 14) {
+            return { valid: false, error: I18n.translate('Target pH value must be between 0 and 14.') };
+        }
+
+        if (!Number.isFinite(input.dosageFactor) || input.dosageFactor <= 0) {
+            return { valid: false, error: I18n.translate('Dosage factor must be greater than 0 grams.') };
+        }
+
+        if (input.type === 'plus' && input.targetPh <= input.currentPh) {
+            return {
+                valid: false,
+                error: I18n.translate('For pH Plus, the target pH value must be higher than the current pH value.'),
+            };
+        }
+
+        if (input.type === 'minus' && input.targetPh >= input.currentPh) {
+            return {
+                valid: false,
+                error: I18n.translate('For pH Minus, the target pH value must be lower than the current pH value.'),
+            };
+        }
+
+        return { valid: true, error: '' };
+    },
+
+    /**
+     * @param {number} currentPh - Current pH value
+     * @param {number} targetPh - Target pH value
+     * @param {number} poolVolume - Pool volume in liters
+     * @param {number} dosageFactor - Dosage factor in grams per 10,000 l and 0.1 pH
+     * @returns {number} Calculated amount in grams.
+     */
+    _calculateAmountGrams(currentPh, targetPh, poolVolume, dosageFactor) {
+        const phDifference = Math.abs(targetPh - currentPh);
+        const phSteps = phDifference / PH_STEP;
+        const volumeFactor = poolVolume / VOLUME_REFERENCE_L;
+
+        return phSteps * volumeFactor * dosageFactor;
+    },
+
+    /**
+     * @param {string} base - Base state path of the calculator
+     * @param {number} grams - Calculated amount in grams
+     * @param {string} resultText - Readable result text
+     * @returns {Promise<void>}
+     */
+    async _writeValidResult(base, grams, resultText) {
+        const now = Date.now();
+
+        await this._setNumber(`${base}.10_result_grams`, grams);
+        await this._setString(`${base}.11_result_text`, resultText);
+        await this._setBool(`${base}.12_valid`, true);
+        await this._setString(`${base}.13_last_error`, '');
+        await this._setNumber(`${base}.14_last_calculated_at`, now);
+    },
+
+    /**
+     * @param {string} base - Base state path of the calculator
+     * @param {string} errorText - Validation error text
+     * @returns {Promise<void>}
+     */
+    async _writeInvalidResult(base, errorText) {
+        const now = Date.now();
+
+        await this._setNumber(`${base}.10_result_grams`, 0);
+        await this._setString(`${base}.11_result_text`, errorText);
+        await this._setBool(`${base}.12_valid`, false);
+        await this._setString(`${base}.13_last_error`, errorText);
+        await this._setNumber(`${base}.14_last_calculated_at`, now);
+    },
+
+    /**
+     * @param {string} base - Base state path of the salt calculator
+     * @param {number} kg - Calculated salt amount in kilograms
+     * @param {string} resultText - Readable result text
+     * @returns {Promise<void>} Resolves when the valid salt result states have been updated.
+     */
+    async _writeValidSaltResult(base, kg, resultText) {
+        const now = Date.now();
+
+        await this._setNumber(`${base}.10_result_kg`, kg);
+        await this._setString(`${base}.11_result_text`, resultText);
+        await this._setBool(`${base}.12_valid`, true);
+        await this._setString(`${base}.13_last_error`, '');
+        await this._setNumber(`${base}.14_last_calculated_at`, now);
+    },
+
+    /**
+     * @param {string} base - Base state path of the salt calculator
+     * @param {string} errorText - Validation error text
+     * @returns {Promise<void>} Resolves when the invalid salt result states have been updated.
+     */
+    async _writeInvalidSaltResult(base, errorText) {
+        const now = Date.now();
+
+        await this._setNumber(`${base}.10_result_kg`, 0);
+        await this._setString(`${base}.11_result_text`, errorText);
+        await this._setBool(`${base}.12_valid`, false);
+        await this._setString(`${base}.13_last_error`, errorText);
+        await this._setNumber(`${base}.14_last_calculated_at`, now);
+    },
+
+    /**
+     * @param {string} id - Target state ID
+     * @param {number} newValue - Value to write if target is empty
+     * @returns {Promise<void>}
+     */
+    async _prefillNumberIfEmpty(id, newValue) {
+        if (!Number.isFinite(newValue) || newValue <= 0) {
+            return;
+        }
+
+        const currentValue = await this._readNumber(id);
+
+        if (currentValue > 0) {
+            return;
+        }
+
+        await this._setNumber(id, newValue);
+    },
+
+    /**
+     * @param {string} id - State ID
+     * @returns {Promise<number>} Numeric state value, or 0 if the state is missing or invalid.
+     */
+    async _readNumber(id) {
+        const state = await this.adapter.getStateAsync(id);
+        const value = Number(state?.val);
+        return Number.isFinite(value) ? value : 0;
+    },
+
+    /**
+     * @param {string} id - State ID
+     * @param {string} value - Value to write
+     * @returns {Promise<void>}
+     */
+    async _setString(id, value) {
+        await this.adapter.setStateChangedAsync(id, { val: String(value ?? ''), ack: true });
+    },
+
+    /**
+     * @param {string} id - State ID
+     * @param {number} value - Value to write
+     * @returns {Promise<void>}
+     */
+    async _setNumber(id, value) {
+        const numberValue = Number(value);
+        await this.adapter.setStateChangedAsync(id, { val: Number.isFinite(numberValue) ? numberValue : 0, ack: true });
+    },
+
+    /**
+     * @param {string} id - State ID
+     * @param {boolean} value - Value to write
+     * @returns {Promise<void>}
+     */
+    async _setBool(id, value) {
+        await this.adapter.setStateChangedAsync(id, { val: !!value, ack: true });
+    },
+
+    cleanup() {
+        this.adapter = null;
+    },
+};
+
+module.exports = chemistryToolsHelper;

package/lib/helpers/pumpHelper.js

@@ -250,13 +250,24 @@ const pumpHelper = {
             const power = this._parseNumber((await this.adapter.getStateAsync('pump.current_power'))?.val);
             const maxWatt = this._parseNumber((await this.adapter.getStateAsync('pump.pump_max_watt'))?.val);
 
-            // --- NEU: Kulanzzeiten für Start/Stop ---
-            const graceOnMs = 5000; // 5 Sekunden nach Start ignorieren
+            // NEU: Konfigurierbarer Sicherheits-Timeout für Leistungsprüfung nach Pumpenstart
+            const startupPowerCheckTimeoutState = await this.adapter.getStateAsync(
+                'pump.startup_power_check_timeout_sec',
+            );
+
+            const startupPowerCheckTimeoutSec = Math.min(
+                10,
+                Math.max(5, this._parseNumber(startupPowerCheckTimeoutState?.val) || 5),
+            );
+
+            const graceOnMs = startupPowerCheckTimeoutSec * 1000;
             const graceOffMs = 5000; // 5 Sekunden nach Stop ignorieren
             const now = Date.now();
 
             if (active === true && this._lastPumpStart && now - this._lastPumpStart < graceOnMs) {
-                this.adapter.log.debug('[pumpHelper] Within start grace period – skipping error check');
+                this.adapter.log.debug(
+                    `[pumpHelper] Within start grace period (${startupPowerCheckTimeoutSec}s) – skipping error check`,
+                );
                 return;
             }
 

package/lib/i18n/de.json

@@ -327,5 +327,20 @@
   "Current ORP value": "Aktueller ORP-Wert",
   "pH reference": "pH-Referenz",
   "Status": "Status",
-  "ORP evaluation is disabled.": "ORP-Auswertung ist deaktiviert."
+  "ORP evaluation is disabled.": "ORP-Auswertung ist deaktiviert.",
+
+  "Calculated amount": "Berechnete Menge",
+  "Reference value based on common manufacturer dosage.": "Orientierungswert nach üblicher Herstellerdosierung.",
+  "Follow the manufacturer instructions and re-measure afterwards.": "Bitte Herstellerangaben beachten und anschließend erneut messen.",
+  "Pool volume must be greater than 0 liters.": "Das Poolvolumen muss größer als 0 Liter sein.",
+  "Current pH value must be between 0 and 14.": "Der aktuelle pH-Wert muss zwischen 0 und 14 liegen.",
+  "Target pH value must be between 0 and 14.": "Der Ziel-pH-Wert muss zwischen 0 und 14 liegen.",
+  "Dosage factor must be greater than 0 grams.": "Der Dosierfaktor muss größer als 0 Gramm sein.",
+  "For pH Plus, the target pH value must be higher than the current pH value.": "Für pH Plus muss der Ziel-pH-Wert höher als der aktuelle pH-Wert sein.",
+  "For pH Minus, the target pH value must be lower than the current pH value.": "Für pH Minus muss der Ziel-pH-Wert niedriger als der aktuelle pH-Wert sein.",
+  "Current salt concentration must be 0 ppm or higher.": "Die aktuelle Salzkonzentration muss 0 ppm oder höher sein.",
+  "Target salt concentration must be higher than the current salt concentration.": "Die Ziel-Salzkonzentration muss höher als die aktuelle Salzkonzentration sein.",
+  "Reference value for raising the salt concentration in pool water.": "Referenzwert für die Erhöhung der Salzkonzentration im Poolwasser.",
+  "Follow the salt system manufacturer instructions and add salt gradually.": "Bitte die Anweisungen des Salzsystem-Herstellers befolgen und das Salz allmählich hinzufügen.",
+  "salt": "Salz"
 }

package/lib/i18n/en.json

@@ -351,5 +351,23 @@
   "pH reference": "pH reference",
   "Status": "Status",
   "Recommendation": "Recommendation",
-  "ORP evaluation is disabled.": "ORP evaluation is disabled."
+  "ORP evaluation is disabled.": "ORP evaluation is disabled.",
+  
+  "Calculated amount": "Calculated amount",
+  "Reference value based on common manufacturer dosage.": "Reference value based on common manufacturer dosage.",
+  "Follow the manufacturer instructions and re-measure afterwards.": "Follow the manufacturer instructions and re-measure afterwards.",
+
+  "Pool volume must be greater than 0 liters.": "Pool volume must be greater than 0 liters.",
+  "Current pH value must be between 0 and 14.": "Current pH value must be between 0 and 14.",
+  "Target pH value must be between 0 and 14.": "Target pH value must be between 0 and 14.",
+  "Dosage factor must be greater than 0 grams.": "Dosage factor must be greater than 0 grams.",
+
+  "For pH Plus, the target pH value must be higher than the current pH value.": "For pH Plus, the target pH value must be higher than the current pH value.",
+  "For pH Minus, the target pH value must be lower than the current pH value.": "For pH Minus, the target pH value must be lower than the current pH value.",
+  "Current salt concentration must be 0 ppm or higher.": "Current salt concentration must be 0 ppm or higher.",
+
+  "Target salt concentration must be higher than the current salt concentration.": "Target salt concentration must be higher than the current salt concentration.",
+  "Reference value for raising the salt concentration in pool water.": "Reference value for raising the salt concentration in pool water.",
+  "Follow the salt system manufacturer instructions and add salt gradually.": "Follow the salt system manufacturer instructions and add salt gradually.",
+  "salt": "salt"
 }