iobroker.poolcontrol 0.6.4 → 0.7.0

package/README.md

@@ -135,6 +135,16 @@ Neue Funktionen werden regelmäßig ergänzt – bitte den Changelog beachten.
 ## Changelog
 ### **WORK IN PROGRESS**
 
+
+## v0.7.0 (2025-11-29)
+- Einführung eines neuen Drucksensor-Systems unter `pump.pressure.*`
+- Unterstützung externer Drucksensor-ObjektID (bar-Wert aus ioBroker)
+- Trenderkennung (steigend/fallend/stabil) und gleitender Druckdurchschnitt
+- Selbstlernende Min-/Max-Druckwerte mit manuellem Reset-State
+- Neuer Diagnose-Text (`status_text_diagnostic`) mit erweiterten Analyseinformationen
+- Erweiterte Pumpenüberwachung ohne automatische Steuerlogik (rein informativ)
+
+
 ## v0.6.2 (2025-11-07)
 - Überarbeitung der Instanzübersicht mit neuen Header-Strukturen für klarere Bedienung
 - Neues Startseitenbild „Egon im Blaumann“ in der Admin-Oberfläche integriert

package/admin/jsonConfig.json

@@ -199,6 +199,48 @@
           "md": 12,
           "lg": 12,
           "xl": 12
+        },
+		        "pressure_header": {
+          "type": "header",
+          "text": "Drucksensor (Filterdruck)",
+          "size": 4,
+          "newLine": true,
+          "xs": 12,
+          "sm": 12,
+          "md": 12,
+          "lg": 12,
+          "xl": 12
+        },
+        "use_pressure_sensor": {
+          "type": "checkbox",
+          "label": "Drucksensor verwenden",
+          "default": false,
+          "xs": 12,
+          "sm": 3,
+          "md": 3,
+          "lg": 3,
+          "xl": 3,
+          "newLine": true
+        },
+        "pressure_sensor_id": {
+          "type": "objectId",
+          "label": "Objekt-ID Drucksensor (bar)",
+          "default": "",
+          "xs": 12,
+          "sm": 3,
+          "md": 3,
+          "lg": 3,
+          "xl": 3
+        },
+        "pressure_hint": {
+          "type": "staticText",
+          "text": "Hinweis: Unterstützt sowohl externe Sensoren als auch die PoolControl-Druckbox.",
+          "newLine": true,
+          "xs": 12,
+          "sm": 12,
+          "md": 12,
+          "lg": 12,
+          "xl": 12
         },
         "pump_safety_header": {
           "type": "header",

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "poolcontrol",
-    "version": "0.6.4",
+    "version": "0.7.0",
     "news": {
+       "0.7.0": {
+         "en": "Added full pressure sensor integration (pump.pressure.*), including trend detection, self-learning min/max values, diagnostic output and configurable normal pressure range. No automatic control logic – purely informative.",
+         "de": "Vollständige Drucksensor-Integration (pump.pressure.*) hinzugefügt, inklusive Trenderkennung, selbstlernenden Min-/Max-Werten, Diagnoseausgabe und einstellbarem Normaldruckbereich. Keine automatische Logik – rein informativ.",
+         "ru": "Добавлена полная интеграция датчика давления (pump.pressure.*), включая определение тренда, самообучающиеся минимальные/максимальные значения, диагностический вывод и настраиваемый диапазон нормального давления. Без автоматической логики – только информация.",
+         "pt": "Adicionada integração completa do sensor de pressão (pump.pressure.*), incluindo detecção de tendência, valores mínimos/máximos autoaprendidos, saída de diagnóstico e faixa de pressão normal configurável. Sem lógica automática – apenas informativo.",
+         "nl": "Volledige druksensorintegratie (pump.pressure.*) toegevoegd, inclusief trenddetectie, zelflerende min/max-waarden, diagnostische uitvoer en instelbaar normaaldrukbereik. Geen automatische logica – puur informatief.",
+         "fr": "Intégration complète du capteur de pression (pump.pressure.*) ajoutée, comprenant la détection de tendance, des valeurs min/max auto-apprises, une sortie de diagnostic et une plage de pression normale configurable. Aucune logique automatique – uniquement informatif.",
+         "it": "Aggiunta integrazione completa del sensore di pressione (pump.pressure.*), con rilevamento delle tendenze, valori min/max autoapprendenti, output diagnostico e intervallo di pressione normale configurabile. Nessuna logica automatica – solo informativo.",
+         "es": "Se añadió la integración completa del sensor de presión (pump.pressure.*), incluyendo detección de tendencia, valores mínimos/máximos autoaprendidos, salida de diagnóstico y rango de presión normal configurable. Sin lógica automática – solo informativo.",
+         "pl": "Dodano pełną integrację czujnika ciśnienia (pump.pressure.*), w tym wykrywanie trendów, samo uczące się wartości min/max, dane diagnostyczne oraz konfigurowalny zakres ciśnienia normalnego. Bez automatycznej logiki – wyłącznie informacyjne.",
+         "uk": "Додано повну інтеграцію датчика тиску (pump.pressure.*), включаючи визначення трендів, самонавчальні мін/макс значення, діагностичний вихід та налаштовуваний діапазон нормального тиску. Без автоматичної логіки – лише інформаційно.",
+         "zh-cn": "新增完整压力传感器集成 (pump.pressure.*)，包括趋势检测、自学习最小/最大值、诊断输出以及可配置的正常压力范围。无自动控制逻辑，仅提供信息。"
+       },
+       "0.6.5": {
+         "en": "Fix for weekly, monthly and yearly reset in consumptionHelper",
+         "de": "Fix für Wochen-, Monats- und Jahres-Reset im ConsumptionHelper",
+         "ru": "Исправление еженедельного, ежемесячного и ежегодного сброса в consumptionHelper",
+         "pt": "Correção para redefinição semanal, mensal e anual no consumptionHelper",
+         "nl": "Fix voor wekelijkse, maandelijkse en jaarlijkse reset in consumptionHelper",
+         "fr": "Correctif pour la réinitialisation hebdomadaire, mensuelle et annuelle dans consumptionHelper",
+         "it": "Correzione per il reset settimanale, mensile e annuale in consumptionHelper",
+         "es": "Corrección para el reinicio semanal, mensual y anual en consumptionHelper",
+         "pl": "Poprawka cotygodniowego, comiesięcznego i corocznego resetu w consumptionHelper",
+         "uk": "Виправлення щотижневого, щомісячного та щорічного скидання в consumptionHelper",
+         "zh-cn": "修复 consumptionHelper 中每周、每月和每年重置的问题"
+       },
        "0.6.4": {
          "en": "Fix for weekly, monthly and yearly reset in consumptionHelper",
          "de": "Fix für Wochen-, Monats- und Jahres-Reset im ConsumptionHelper",
@@ -65,32 +91,6 @@
          "pl": "Dodano pełną kontrolę fotowoltaiczną z automatycznym zarządzaniem pompą (tryb 'Automatik (PV)'). Adapter reaguje teraz na nadwyżkę PV w oparciu o konfigurowalne wartości zużycia i produkcji energii. Zawiera migrację dla istniejących instalacji. Poprawiono spójność systemu i wewnętrzne logowanie.",
          "uk": "Додано повний фотогальванічний контроль з автоматичним керуванням насосом (режим 'Automatik (PV)'). Адаптер тепер реагує на надлишок PV на основі налаштовуваних значень споживання та генерації. Включено міграцію для існуючих установок. Покращено системну узгодженість і внутрішнє журналювання.",
          "zh-cn": "新增完整的光伏控制与自动泵管理（模式“Automatik (PV)”）。适配器现在可根据可配置的家庭耗电与发电数值响应光伏盈余。包含对现有安装的迁移。改进了系统一致性和内部日志记录。"
-       },
-       "0.5.5": {
-         "en": "Fixed remaining timer recursion issue in weekly and monthly statistics to fully prevent infinite reset loops. Cleaned up jsonConfig structure and improved timer handling.",
-         "de": "Verbleibende Timer-Rekursion in Wochen- und Monatsstatistik behoben, um Endlosschleifen beim Reset endgültig zu verhindern. jsonConfig-Struktur bereinigt und Timer-Handling verbessert.",
-         "ru": "Исправлена оставшаяся рекурсия таймера в еженедельной и ежемесячной статистике для полного предотвращения бесконечных циклов сброса. Упрощена структура jsonConfig и улучшено управление таймерами.",
-         "pt": "Corrigida a recursão restante do temporizador nas estatísticas semanais e mensais para evitar completamente loops de redefinição infinitos. Estrutura jsonConfig limpa e manuseio de temporizador aprimorado.",
-         "nl": "Overgebleven timerrecursie in week- en maandstatistieken opgelost om oneindige resetlussen volledig te voorkomen. jsonConfig-structuur opgeschoond en timerafhandeling verbeterd.",
-         "fr": "Correction de la récursion restante du minuteur dans les statistiques hebdomadaires et mensuelles afin d'éviter définitivement les boucles de réinitialisation infinies. Structure jsonConfig nettoyée et gestion du minuteur améliorée.",
-         "it": "Corretta la ricorsione residua del timer nelle statistiche settimanali e mensili per prevenire completamente i loop di reset infiniti. Pulita la struttura jsonConfig e migliorata la gestione dei timer.",
-         "es": "Corregida la recursión restante del temporizador en las estadísticas semanales y mensuales para evitar completamente los bucles de reinicio infinitos. Estructura jsonConfig limpiada y manejo del temporizador mejorado.",
-         "pl": "Naprawiono pozostałą rekursję timera w statystykach tygodniowych i miesięcznych, aby całkowicie zapobiec nieskończonym pętlom resetowania. Uporządkowano strukturę jsonConfig i ulepszono obsługę timera.",
-         "uk": "Виправлено залишкову рекурсію таймера у тижневій та місячній статистиці, щоб повністю запобігти нескінченним циклам скидання. Очищено структуру jsonConfig і покращено обробку таймерів.",
-         "zh-cn": "修复了每周和每月统计中的剩余计时器递归问题，以完全防止无限重置循环。清理了 jsonConfig 结构并改进了计时器处理。"
-       },
-       "0.5.4": {
-         "en": "Fixed a rare infinite loop during weekly and monthly statistics reset that could cause Redis overload. Added timer protection and improved stability.",
-         "de": "Selten auftretende Endlosschleife beim Wochen- und Monatsreset der Statistik behoben, die zu Redis-Überlastung führen konnte. Timer-Schutz und Stabilität verbessert.",
-         "ru": "Исправлена редкая бесконечная петля при сбросе еженедельной и ежемесячной статистики, вызывавшая перегрузку Redis. Добавлена защита таймера и улучшена стабильность.",
-         "pt": "Corrigido um loop infinito raro durante a redefinição das estatísticas semanais e mensais que podia causar sobrecarga do Redis. Adicionada proteção de temporizador e melhorada a estabilidade.",
-         "nl": "Zeldzame oneindige lus opgelost tijdens de reset van wekelijkse en maandelijkse statistieken die Redis kon overbelasten. Timerbescherming en stabiliteit verbeterd.",
-         "fr": "Correction d'une boucle infinie rare lors de la réinitialisation des statistiques hebdomadaires et mensuelles pouvant provoquer une surcharge de Redis. Protection du minuteur et stabilité améliorées.",
-         "it": "Corretto un raro ciclo infinito durante il reset delle statistiche settimanali e mensili che poteva causare un sovraccarico di Redis. Migliorata la protezione del timer e la stabilità.",
-         "es": "Se corrigió un bucle infinito poco frecuente durante el reinicio de las estadísticas semanales y mensuales que podía causar sobrecarga de Redis. Protección de temporizador y estabilidad mejoradas.",
-         "pl": "Naprawiono rzadką nieskończoną pętlę podczas resetowania statystyk tygodniowych i miesięcznych, która mogła powodować przeciążenie Redis. Dodano ochronę timera i poprawiono stabilność.",
-         "uk": "Виправлено рідкісну нескінченну петлю під час скидання тижневої та місячної статистики, що могла спричинити перевантаження Redis. Додано захист таймера та покращено стабільність.",
-         "zh-cn": "修复了每周和每月统计重置期间可能导致 Redis 过载的罕见无限循环。改进了计时器保护和系统稳定性。"
        }
 	},
     "titleLang": {

package/lib/helpers/consumptionHelper.js

@@ -268,51 +268,71 @@ const consumptionHelper = {
     },
 
     // ---------------------------------------------------------
-    // 🔵 WÖCHENTLICHER RESET (Montag 00:05 Uhr)
+    // 🔵 WÖCHENTLICHER RESET (täglicher Check um 00:05 Uhr, nur Montag)
     // ---------------------------------------------------------
     _scheduleWeeklyReset() {
         const now = new Date();
         const next = new Date(now);
+        next.setHours(0, 5, 0, 0); // täglicher Check 00:05
 
-        // Montag = 1 (Sonntag = 0)
-        const day = now.getDay();
-        const daysUntilMonday = (1 - day + 7) % 7;
-
-        next.setDate(now.getDate() + daysUntilMonday);
-        next.setHours(0, 5, 0, 0);
+        // Wenn die Zeit heute schon vorbei ist → morgen 00:05
+        if (next <= now) {
+            next.setDate(next.getDate() + 1);
+        }
 
         const delay = next - now;
 
         setTimeout(async () => {
             try {
-                this.adapter.log.info('[consumptionHelper] Wochen-Reset (Montag 00:05)');
-                await this.adapter.setStateAsync('consumption.week_kwh', { val: 0, ack: true });
-                await this.adapter.setStateAsync('costs.week_eur', { val: 0, ack: true });
-                this.baselines.week = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
+                const nowCheck = new Date();
+
+                // Nur wenn heute Montag ist (0 = Sonntag, 1 = Montag)
+                if (nowCheck.getDay() === 1) {
+                    this.adapter.log.info('[consumptionHelper] Wochen-Reset (Montag 00:05)');
+                    await this.adapter.setStateAsync('consumption.week_kwh', { val: 0, ack: true });
+                    await this.adapter.setStateAsync('costs.week_eur', { val: 0, ack: true });
+                    this.baselines.week = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
+                }
             } catch (err) {
                 this.adapter.log.warn(`[consumptionHelper] Fehler beim Wochenreset: ${err.message}`);
             }
-            this._scheduleWeeklyReset(); // erneut planen
+
+            // Morgen wieder planen
+            this._scheduleWeeklyReset();
         }, delay);
     },
 
     // ---------------------------------------------------------
-    // 🔵 MONATLICHER RESET (1. des Monats 00:05 Uhr)
+    // 🔵 MONATLICHER RESET (täglicher Check um 00:05 Uhr, nur am 1.)
     // ---------------------------------------------------------
     _scheduleMonthlyReset() {
         const now = new Date();
-        const next = new Date(now.getFullYear(), now.getMonth() + 1, 1, 0, 5, 0, 0);
+        const next = new Date(now);
+        next.setHours(0, 5, 0, 0); // täglicher Check 00:05
+
+        // Wenn die Zeit heute schon vorbei ist → morgen 00:05
+        if (next <= now) {
+            next.setDate(next.getDate() + 1);
+        }
+
         const delay = next - now;
 
         setTimeout(async () => {
             try {
-                this.adapter.log.info('[consumptionHelper] Monats-Reset (1. 00:05)');
-                await this.adapter.setStateAsync('consumption.month_kwh', { val: 0, ack: true });
-                await this.adapter.setStateAsync('costs.month_eur', { val: 0, ack: true });
-                this.baselines.month = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
+                const nowCheck = new Date();
+
+                // Nur am 1. des Monats
+                if (nowCheck.getDate() === 1) {
+                    this.adapter.log.info('[consumptionHelper] Monats-Reset (1. 00:05)');
+                    await this.adapter.setStateAsync('consumption.month_kwh', { val: 0, ack: true });
+                    await this.adapter.setStateAsync('costs.month_eur', { val: 0, ack: true });
+                    this.baselines.month = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
+                }
             } catch (err) {
                 this.adapter.log.warn(`[consumptionHelper] Fehler beim Monatsreset: ${err.message}`);
             }
+
+            // Morgen wieder planen
             this._scheduleMonthlyReset();
         }, delay);
     },

package/lib/helpers/frostHelper.js

@@ -123,7 +123,7 @@ const frostHelper = {
                     val: shouldRun,
                     ack: false,
                 });
-                this.adapter.log.debug(
+                this.adapter.log.info(
                     `[frostHelper] Frostschutz → Pumpe ${shouldRun ? 'EIN' : 'AUS'} (Außen=${outside}°C, Grenze=${frostTemp}°C)`,
                 );
             }

package/lib/helpers/pumpHelper4.js

@@ -0,0 +1,362 @@
+'use strict';
+
+/**
+ * pumpHelper4.js
+ * ----------------------------------------------------------
+ * Drucksensor-Logik für Pumpenbereich
+ *
+ * Verarbeitet:
+ *   - pump.pressure.current_bar
+ *   - pump.pressure.previous_bar
+ *   - pump.pressure.status_text
+ *   - pump.pressure.last_update
+ *
+ * Liest:
+ *   - Objekt-ID des Drucksensors aus jsonConfig
+ *
+ * Version: 1.0.0
+ */
+
+const pumpHelper4 = {
+    adapter: null,
+    pressureObjectId: null,
+
+    /**
+     * Initialisiert den Helper
+     *
+     * @param {ioBroker.Adapter} adapter – aktive Adapterinstanz
+     */
+    async init(adapter) {
+        this.adapter = adapter;
+
+        this.pressureObjectId = adapter.config.pressure_sensor_oid || '';
+        adapter.log.info(`[pumpHelper4] Initialisierung gestartet (OID: ${this.pressureObjectId || 'nicht gesetzt'})`);
+
+        if (!this.pressureObjectId) {
+            adapter.log.info('[pumpHelper4] Kein Drucksensor in der Instanzkonfiguration angegeben.');
+            return;
+        }
+
+        // Drucksensor abonnieren
+        adapter.subscribeForeignStates(this.pressureObjectId);
+
+        adapter.log.info('[pumpHelper4] Erfolgreich initialisiert');
+
+        // Benutzerdefinierte Normaldruck-Werte einmalig laden
+        this.adapter.getStateAsync('pump.pressure.normal_min_bar').then(s => {
+            this.lastMin = Number(s?.val) || 0.2;
+        });
+        this.adapter.getStateAsync('pump.pressure.normal_max_bar').then(s => {
+            this.lastMax = Number(s?.val) || 0.8;
+        });
+    },
+
+    /**
+     * Verarbeitet alle relevanten State-Änderungen
+     *
+     * @param {string} id - Objekt-ID
+     * @param {ioBroker.State} state - Neuer Wert
+     */
+    async handleStateChange(id, state) {
+        if (!state) {
+            return;
+        }
+
+        // ------------------------------------------
+        // Manueller Reset des Lernsystems
+        // ------------------------------------------
+        if (id === 'poolcontrol.0.pump.pressure.learning.reset' && state.val === true) {
+            const current = await this._getNumber('pump.pressure.current_bar');
+
+            // Lernwerte zurücksetzen
+            await this.adapter.setStateAsync('pump.pressure.learning.learned_min_bar', { val: current, ack: true });
+            await this.adapter.setStateAsync('pump.pressure.learning.learned_max_bar', { val: current, ack: true });
+            await this.adapter.setStateAsync('pump.pressure.learning.avg_bar', { val: current, ack: true });
+            await this.adapter.setStateAsync('pump.pressure.learning.trend_rising', { val: 0, ack: true });
+            await this.adapter.setStateAsync('pump.pressure.learning.trend_falling', { val: 0, ack: true });
+            await this.adapter.setStateAsync('pump.pressure.learning.trend_stability', { val: 0, ack: true });
+
+            // Diagnose-Text
+            await this.adapter.setStateAsync('pump.pressure.status_text_diagnostic', {
+                val: 'Lernsystem zurückgesetzt',
+                ack: true,
+            });
+
+            // Reset-Button zurücksetzen
+            await this.adapter.setStateAsync('pump.pressure.learning.reset', {
+                val: false,
+                ack: true,
+            });
+
+            return; // WICHTIG: nichts weiter tun
+        }
+
+        // ------------------------------------------
+        // Live-Update der Min/Max-Werte
+        // ------------------------------------------
+        if (id === 'poolcontrol.0.pump.pressure.normal_min_bar') {
+            this.lastMin = Number(state.val) || 0.2;
+            this.adapter.log.debug(`[pumpHelper4] Neuer Minimaldruck übernommen: ${this.lastMin} bar`);
+            return;
+        }
+
+        if (id === 'poolcontrol.0.pump.pressure.normal_max_bar') {
+            this.lastMax = Number(state.val) || 0.8;
+            this.adapter.log.debug(`[pumpHelper4] Neuer Maximaldruck übernommen: ${this.lastMax} bar`);
+            return;
+        }
+
+        // Nicht der Drucksensor? Dann raus.
+        if (id !== this.pressureObjectId) {
+            return;
+        }
+
+        try {
+            const newBar = Number(state.val);
+
+            if (isNaN(newBar)) {
+                this.adapter.log.warn(`[pumpHelper4] Ungültiger Druckwert empfangen: ${state.val}`);
+                return;
+            }
+
+            // ------------------------------------------
+            // NEU: Pumpenschalter prüfen
+            // ------------------------------------------
+            const pumpSwitch = await this.adapter.getStateAsync('pump.pump_switch');
+            const pumpIsOn = !!pumpSwitch?.val;
+
+            // Zeitstempel immer setzen
+            const now = new Date().toISOString();
+
+            // Wenn Pumpe AUS → Status setzen und raus
+            if (!pumpIsOn) {
+                await this.adapter.setStateAsync('pump.pressure.status_text', {
+                    val: 'Pumpe aus – kein Filterdruck',
+                    ack: true,
+                });
+
+                // trotzdem current_bar und last_update aktualisieren
+                await this.adapter.setStateAsync('pump.pressure.current_bar', {
+                    val: newBar,
+                    ack: true,
+                });
+
+                await this.adapter.setStateAsync('pump.pressure.last_update', {
+                    val: now,
+                    ack: true,
+                });
+
+                return;
+            }
+
+            // Alten Wert lesen
+            const previous = await this._getNumber('pump.pressure.current_bar');
+
+            // previous_bar nur updaten, wenn alter Wert > 0
+            if (previous > 0) {
+                await this.adapter.setStateAsync('pump.pressure.previous_bar', {
+                    val: previous,
+                    ack: true,
+                });
+            }
+
+            // ------------------------------------------
+            // Trend-Erkennung
+            // ------------------------------------------
+            let rising = 0;
+            let falling = 0;
+            let stability = 0;
+
+            const diff = newBar - previous;
+
+            // Steigend
+            if (diff > 0.01) {
+                rising = Number(diff.toFixed(3));
+            }
+
+            // Fallend
+            if (diff < -0.01) {
+                falling = Number(Math.abs(diff).toFixed(3));
+            }
+
+            // Stabil
+            if (Math.abs(diff) <= 0.01) {
+                stability = 1;
+            }
+
+            // Werte setzen
+            await this.adapter.setStateAsync('pump.pressure.learning.trend_rising', {
+                val: rising,
+                ack: true,
+            });
+
+            await this.adapter.setStateAsync('pump.pressure.learning.trend_falling', {
+                val: falling,
+                ack: true,
+            });
+
+            await this.adapter.setStateAsync('pump.pressure.learning.trend_stability', {
+                val: stability,
+                ack: true,
+            });
+
+            // current_bar aktualisieren
+            await this.adapter.setStateAsync('pump.pressure.current_bar', {
+                val: newBar,
+                ack: true,
+            });
+
+            // ------------------------------------------
+            // Gleitender Druckdurchschnitt
+            // ------------------------------------------
+            const oldAvg = await this._getNumber('pump.pressure.learning.avg_bar');
+            const newAvg = oldAvg === 0 ? newBar : oldAvg * 0.9 + newBar * 0.1;
+
+            await this.adapter.setStateAsync('pump.pressure.learning.avg_bar', {
+                val: Number(newAvg.toFixed(3)),
+                ack: true,
+            });
+
+            // ------------------------------------------
+            // Learning MIN/MAX (autoadaptiv)
+            // ------------------------------------------
+            const learnedMin = await this._getNumber('pump.pressure.learning.learned_min_bar');
+            const learnedMax = await this._getNumber('pump.pressure.learning.learned_max_bar');
+
+            // Wenn noch keine Werte vorhanden
+            let newLearnedMin = learnedMin || newBar;
+            let newLearnedMax = learnedMax || newBar;
+
+            // Pumpe stabil → Min/Max leicht erweitern
+            if (newBar < newLearnedMin) {
+                newLearnedMin = newBar;
+            }
+
+            if (newBar > newLearnedMax) {
+                newLearnedMax = newBar;
+            }
+
+            await this.adapter.setStateAsync('pump.pressure.learning.learned_min_bar', {
+                val: Number(newLearnedMin.toFixed(3)),
+                ack: true,
+            });
+
+            await this.adapter.setStateAsync('pump.pressure.learning.learned_max_bar', {
+                val: Number(newLearnedMax.toFixed(3)),
+                ack: true,
+            });
+
+            // Zeitstempel schreiben
+            // const now = new Date().toISOString();
+            await this.adapter.setStateAsync('pump.pressure.last_update', {
+                val: now,
+                ack: true,
+            });
+
+            // Statustext setzen
+            const text = this._getStatusText(newBar);
+            await this.adapter.setStateAsync('pump.pressure.status_text', {
+                val: text,
+                ack: true,
+            });
+
+            // ------------------------------------------
+            // Diagnose-Text (Trend + Lernen)
+            // ------------------------------------------
+            let diagText = '';
+
+            if (!pumpIsOn) {
+                diagText = 'Pumpe aus – keine Diagnose möglich';
+            } else {
+                const trendParts = [];
+
+                if (rising > 0) {
+                    trendParts.push(`steigend (+${rising} bar)`);
+                }
+                if (falling > 0) {
+                    trendParts.push(`fallend (-${falling} bar)`);
+                }
+                if (stability === 1) {
+                    trendParts.push('stabil');
+                }
+
+                const trendText = trendParts.length > 0 ? trendParts.join(', ') : 'kein Trend erkennbar';
+
+                const avg = await this._getNumber('pump.pressure.learning.avg_bar');
+                const learnedMin = await this._getNumber('pump.pressure.learning.learned_min_bar');
+                const learnedMax = await this._getNumber('pump.pressure.learning.learned_max_bar');
+
+                diagText =
+                    `Trend: ${trendText} | ` +
+                    `Durchschnitt: ${avg.toFixed(3)} bar | ` +
+                    `Lernbereich: ${learnedMin.toFixed(3)}–${learnedMax.toFixed(3)} bar`;
+            }
+
+            // in State schreiben
+            await this.adapter.setStateAsync('pump.pressure.status_text_diagnostic', {
+                val: diagText,
+                ack: true,
+            });
+
+            this.adapter.log.debug(`[pumpHelper4] Druck aktualisiert: ${newBar} bar (vorher: ${previous} bar)`);
+        } catch (err) {
+            this.adapter.log.warn(`[pumpHelper4] Fehler bei handleStateChange: ${err.message}`);
+        }
+    },
+
+    /**
+     * Gibt einen einfachen Status basierend auf dem Druck zurück.
+     *
+     * Berücksichtigt Benutzerwerte:
+     *  - normal_min_bar
+     *  - normal_max_bar
+     *
+     * @param {number} bar - aktueller Druck in bar
+     * @returns {string} Statusmeldung
+     */
+    _getStatusText(bar) {
+        if (isNaN(bar)) {
+            return 'Ungültiger Druckwert';
+        }
+
+        const min = this.lastMin ?? 0.2;
+        const max = this.lastMax ?? 0.8;
+
+        // Zu niedrig?
+        if (bar < min) {
+            return `Druck zu niedrig (unter ${min} bar)`;
+        }
+
+        // Normalbereich?
+        if (bar >= min && bar <= max) {
+            return `Normaldruck (${min}–${max} bar)`;
+        }
+
+        // Zu hoch?
+        if (bar > max) {
+            return `Druck erhöht (über ${max} bar)`;
+        }
+
+        return 'Unbekannter Zustand';
+    },
+
+    /**
+     * Liest einen numerischen State
+     *
+     * @param {string} id - Die vollständige Objekt-ID des State, dessen numerischer Wert gelesen werden soll
+     */
+    async _getNumber(id) {
+        const state = await this.adapter.getStateAsync(id);
+        const val = Number(state?.val);
+        return isNaN(val) ? 0 : val;
+    },
+
+    /**
+     * Cleanup bei Adapter-Unload
+     */
+    cleanup() {
+        this.adapter?.log.debug('[pumpHelper4] Cleanup ausgeführt.');
+    },
+};
+
+module.exports = pumpHelper4;

package/lib/stateDefinitions/pumpStates4.js

@@ -0,0 +1,312 @@
+'use strict';
+
+/**
+ * pumpStates4.js
+ * ----------------------------------------------------------
+ * Legt die States für den Drucksensor im Pumpenbereich an.
+ *
+ * Ordnerstruktur:
+ *   pump.pressure.*
+ *
+ * Diese Datei ergänzt die bisherigen pumpStates.js,
+ * pumpStates2.js und pumpStates3.js um Drucksensor-Unterstützung.
+ *
+ * Alle States sind echte Variablen (persist = true nur falls nötig).
+ * ----------------------------------------------------------
+ * Version: 1.0.0
+ */
+
+/**
+ * Erstellt alle States für den Drucksensor im Bereich pump.pressure.
+ *
+ * @param {import('iobroker').Adapter} adapter – Aktive ioBroker Adapterinstanz
+ */
+async function createPumpStates4(adapter) {
+    adapter.log.debug('[pumpStates4] Initialisierung der Drucksensor-States gestartet.');
+
+    // ------------------------------------------------------
+    // Root-Kanal: pump.pressure
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.pressure', {
+        type: 'channel',
+        common: {
+            name: 'Pumpen-Drucksensor (Filterdruck)',
+        },
+        native: {},
+    });
+
+    // ------------------------------------------------------
+    // Aktueller Druck (bar)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.pressure.current_bar', {
+        type: 'state',
+        common: {
+            name: 'Aktueller Druck (bar)',
+            desc: 'Gemessener aktueller Filterdruck in bar',
+            type: 'number',
+            role: 'value.pressure',
+            unit: 'bar',
+            read: true,
+            write: false,
+            persist: false, // Livewert → NICHT speichern
+        },
+        native: {},
+    });
+
+    // initial setzen (überinstallationssicher)
+    const existing = await adapter.getStateAsync('pump.pressure.current_bar');
+    if (existing === null || existing === undefined) {
+        await adapter.setStateAsync('pump.pressure.current_bar', { val: 0, ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Vorheriger Druckwert (bar)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.pressure.previous_bar', {
+        type: 'state',
+        common: {
+            name: 'Vorheriger Druck (bar)',
+            desc: 'Letzter bekannter Filterdruck vor der aktuellen Messung',
+            type: 'number',
+            role: 'value.pressure',
+            unit: 'bar',
+            read: true,
+            write: false,
+            persist: false,
+        },
+        native: {},
+    });
+
+    // initial setzen (überinstallationssicher)
+    const prev = await adapter.getStateAsync('pump.pressure.previous_bar');
+    if (prev === null || prev === undefined) {
+        await adapter.setStateAsync('pump.pressure.previous_bar', { val: 0, ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Benutzerdefinierte Normaldruck-Bereiche (bar)
+    // ------------------------------------------------------
+
+    // Unterer Normaldruck-Grenzwert (bar)
+    await adapter.setObjectNotExistsAsync('pump.pressure.normal_min_bar', {
+        type: 'state',
+        common: {
+            name: 'Normaldruck MIN (bar)',
+            desc: 'Unterer Grenzwert des Normaldruck-Bereichs. Werte unterhalb gelten als zu niedrig.',
+            type: 'number',
+            role: 'level',
+            unit: 'bar',
+            read: true,
+            write: true,
+            min: 0,
+            max: 2,
+            def: 0.2,
+            persist: true,
+        },
+        native: {},
+    });
+
+    const minExisting = await adapter.getStateAsync('pump.pressure.normal_min_bar');
+    if (minExisting === null || minExisting === undefined) {
+        await adapter.setStateAsync('pump.pressure.normal_min_bar', { val: 0.2, ack: true });
+    }
+
+    // Oberer Normaldruck-Grenzwert (bar)
+    await adapter.setObjectNotExistsAsync('pump.pressure.normal_max_bar', {
+        type: 'state',
+        common: {
+            name: 'Normaldruck MAX (bar)',
+            desc: 'Oberer Grenzwert des Normaldruck-Bereichs. Werte oberhalb gelten als erhöht.',
+            type: 'number',
+            role: 'level',
+            unit: 'bar',
+            read: true,
+            write: true,
+            min: 0,
+            max: 2,
+            def: 0.8,
+            persist: true,
+        },
+        native: {},
+    });
+
+    const maxExisting = await adapter.getStateAsync('pump.pressure.normal_max_bar');
+    if (maxExisting === null || maxExisting === undefined) {
+        await adapter.setStateAsync('pump.pressure.normal_max_bar', { val: 0.8, ack: true });
+    }
+
+    // ------------------------------------------------------
+    // Optional vorbereitete States für spätere Erweiterungen
+    // ------------------------------------------------------
+
+    // Zustand / Bewertung
+    await adapter.setObjectNotExistsAsync('pump.pressure.status_text', {
+        type: 'state',
+        common: {
+            name: 'Statusmeldung',
+            desc: 'Bewertung des Drucks (z. B. Normal / Hoch / Rückspülen nötig)',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+            persist: false,
+        },
+        native: {},
+    });
+
+    // Erweiterte Diagnoseausgabe
+    await adapter.setObjectNotExistsAsync('pump.pressure.status_text_diagnostic', {
+        type: 'state',
+        common: {
+            name: 'Diagnose',
+            desc: 'Ausführliche Diagnose basierend auf Trend- und Lernwerten',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+            persist: false,
+        },
+        native: {},
+    });
+
+    // Letzte Aktualisierung
+    await adapter.setObjectNotExistsAsync('pump.pressure.last_update', {
+        type: 'state',
+        common: {
+            name: 'Letzte Aktualisierung',
+            desc: 'Zeitstempel der letzten Druckaktualisierung',
+            type: 'string',
+            role: 'date',
+            read: true,
+            write: false,
+            persist: false,
+        },
+        native: {},
+    });
+
+    // ------------------------------------------------------
+    // Lernwerte-Unterordner anlegen
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.pressure.learning', {
+        type: 'channel',
+        common: {
+            name: 'Lernwerte (Druckverhalten der Pumpe)',
+        },
+        native: {},
+    });
+
+    // Unterer Lernwert (Wohlfühl-Minimum)
+    await adapter.setObjectNotExistsAsync('pump.pressure.learning.learned_min_bar', {
+        type: 'state',
+        common: {
+            name: 'Gelerntes Minimum (bar)',
+            desc: 'Niedrigster Druck, der im stabilen Betrieb häufig auftritt',
+            type: 'number',
+            unit: 'bar',
+            role: 'value',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+
+    // Oberer Lernwert (Wohlfühl-Maximum)
+    await adapter.setObjectNotExistsAsync('pump.pressure.learning.learned_max_bar', {
+        type: 'state',
+        common: {
+            name: 'Gelerntes Maximum (bar)',
+            desc: 'Höchster Druck, der im stabilen Betrieb häufig auftritt',
+            type: 'number',
+            unit: 'bar',
+            role: 'value',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+
+    // Gleitender Mittelwert
+    await adapter.setObjectNotExistsAsync('pump.pressure.learning.avg_bar', {
+        type: 'state',
+        common: {
+            name: 'Gleitender Durchschnittsdruck (bar)',
+            desc: 'Berechneter Mittelwert der letzten Messungen',
+            type: 'number',
+            unit: 'bar',
+            role: 'value',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+
+    // Trend: Anstieg
+    await adapter.setObjectNotExistsAsync('pump.pressure.learning.trend_rising', {
+        type: 'state',
+        common: {
+            name: 'Trend Steigend (0–1)',
+            desc: 'Gibt an, wie stark der Druck steigt',
+            type: 'number',
+            role: 'indicator',
+            read: true,
+            write: true,
+            persist: false,
+        },
+        native: {},
+    });
+
+    // Trend: Abfall
+    await adapter.setObjectNotExistsAsync('pump.pressure.learning.trend_falling', {
+        type: 'state',
+        common: {
+            name: 'Trend Fallend (0–1)',
+            desc: 'Gibt an, wie stark der Druck fällt',
+            type: 'number',
+            role: 'indicator',
+            read: true,
+            write: true,
+            persist: false,
+        },
+        native: {},
+    });
+
+    // Trend: Stabilität
+    await adapter.setObjectNotExistsAsync('pump.pressure.learning.trend_stability', {
+        type: 'state',
+        common: {
+            name: 'Trend Stabilität (0–1)',
+            desc: 'Gibt an, wie stabil der Druck insgesamt ist',
+            type: 'number',
+            role: 'indicator',
+            read: true,
+            write: true,
+            persist: false,
+        },
+        native: {},
+    });
+
+    // Reset des Lernsystems
+    await adapter.setObjectNotExistsAsync('pump.pressure.learning.reset', {
+        type: 'state',
+        common: {
+            name: 'Lernsystem zurücksetzen',
+            desc: 'Setzt alle Lernwerte (Min/Max/Avg/Trend) auf den aktuellen Druck zurück',
+            type: 'boolean',
+            role: 'button',
+            read: true,
+            write: true,
+            def: false,
+            persist: false,
+        },
+        native: {},
+    });
+
+    adapter.log.debug('[pumpStates4] Drucksensor-States erfolgreich erstellt oder geprüft.');
+}
+
+module.exports = {
+    createPumpStates4,
+};

package/main.js

@@ -14,6 +14,7 @@ const statisticsHelperMonth = require('./lib/helpers/statisticsHelperMonth');
 const pumpHelper = require('./lib/helpers/pumpHelper');
 const pumpHelper2 = require('./lib/helpers/pumpHelper2');
 const pumpHelper3 = require('./lib/helpers/pumpHelper3');
+const pumpHelper4 = require('./lib/helpers/pumpHelper4');
 const speechHelper = require('./lib/helpers/speechHelper');
 const consumptionHelper = require('./lib/helpers/consumptionHelper');
 const solarHelper = require('./lib/helpers/solarHelper');
@@ -29,6 +30,7 @@ const { createTemperatureStates } = require('./lib/stateDefinitions/temperatureS
 const { createPumpStates } = require('./lib/stateDefinitions/pumpStates');
 const { createPumpStates2 } = require('./lib/stateDefinitions/pumpStates2');
 const { createPumpStates3 } = require('./lib/stateDefinitions/pumpStates3');
+const { createPumpStates4 } = require('./lib/stateDefinitions/pumpStates4');
 const { createSolarStates } = require('./lib/stateDefinitions/solarStates');
 const { createPhotovoltaicStates } = require('./lib/stateDefinitions/photovoltaicStates');
 const { createGeneralStates } = require('./lib/stateDefinitions/generalStates');
@@ -62,6 +64,7 @@ class Poolcontrol extends utils.Adapter {
         await createPumpStates(this);
         await createPumpStates2(this);
         await createPumpStates3(this);
+        await createPumpStates4(this);
 
         // --- Temperaturverwaltung ---
         await createTemperatureStates(this);
@@ -115,6 +118,7 @@ class Poolcontrol extends utils.Adapter {
         pumpHelper.init(this);
         pumpHelper2.init(this);
         pumpHelper3.init(this);
+        pumpHelper4.init(this);
         speechHelper.init(this);
         consumptionHelper.init(this);
         solarHelper.init(this);
@@ -150,6 +154,9 @@ class Poolcontrol extends utils.Adapter {
             if (pumpHelper3.cleanup) {
                 pumpHelper3.cleanup();
             }
+            if (pumpHelper4.cleanup) {
+                pumpHelper4.cleanup();
+            }
             if (speechHelper.cleanup) {
                 speechHelper.cleanup();
             }
@@ -221,6 +228,12 @@ class Poolcontrol extends utils.Adapter {
             this.log.warn(`[pumpHelper3] Fehler in handleStateChange: ${e.message}`);
         }
 
+        try {
+            pumpHelper4.handleStateChange(id, state);
+        } catch (e) {
+            this.log.warn(`[pumpHelper4] Fehler in handleStateChange: ${e.message}`);
+        }
+
         try {
             speechHelper.handleStateChange(id, state);
         } catch (e) {

package/package.json

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