iobroker.sprinklecontrol 1.0.6 → 1.0.8

package/lib/valveControl.js

@@ -1,7 +1,7 @@
 
 'use strict';
 
-const asyncTime = require('timers/promises');
+const asyncTime = require('node:timers/promises');
 // import {setTimeout} from 'timers/promises';
 
 const myConfig = require('./myConfig.js');
@@ -23,7 +23,19 @@ const threadList = [];
  * Ventil mit dem größten Durchfluss (pipeFlow) für die Steuerung des Druckentlastungsventils
  * - wird in der Funktion updateList() ermittelt
  */
-const pressureReliefValve = {enable: false, name: '',wateringTime: 10, ac: {}, controller: {}, control: {idState: undefined, idON_TIME: undefined, idACK: undefined, maker: undefined}};
+const pressureReliefValve = {
+    enable: false, 
+    name: '', 
+    wateringTime: 10, 
+     ac: {}, 
+     controller: {}, 
+     control: {
+        idState: undefined, 
+        idON_TIME: undefined, 
+        idACK: undefined, 
+        maker: undefined
+    }
+};
 
 /**
  *  - bereit zum Boost (true: kein Boostventil aktive; false: BoostVentil aktive)
@@ -43,14 +55,21 @@ let boostReady = true,
     fillLevelCistern = 0,
     /**
      * Zeitliche Bewässerungseinschränkung EIN/AUS
+     * z.B. Behördenvorgabe, Sommerhitze + Trockenheit, usw.
      */
     timeBasedRestrictionEn = false;
 
-const updateListMarker = {funcActive: false, newStart: false, switchingDistance: 5000, cancelSwitchingDistance: {}};
+const updateListMarker = {
+    funcActive: false, 
+    newStart: false, 
+    switchingDistance: 5000, 
+    cancelSwitchingDistance: {}
+};
 
 /**
  * aktive Pumpendaten
  * - enable: Pumpe ein/ausgeschaltet
+ * - pumpSwitching: Umschaltung aktive, während der Umschaltung von Zysterne auf Hauptpumpe bei aktiver Pumpe
  * - name: Bezeichnung der Pumpe
  * - idState: Objektname des State
  * - id: ID des States unter Objecte im ioBroker info.cisternPump || info.mainPump
@@ -64,9 +83,40 @@ const updateListMarker = {funcActive: false, newStart: false, switchingDistance:
  * - ac: AbortController
  */
 
-const currentPumpUse = {enable: false, name: '', wateringTime: 0, id: '', pumpCistern: false, intBreak: false, leadTime: 0, cancelLeadTime: {}, pumpPower: 0, restFlow: 0,ac: {},controller: {}, control: {idState: undefined, idON_TIME: undefined, idACK: undefined, maker: undefined}};
-let mainPumpControl = {idState: undefined, idON_TIME: undefined, idACK: undefined, maker: undefined};
-let cisternPumpControl = {idState: undefined, idON_TIME: undefined, idACK: undefined, maker: undefined};
+const currentPumpUse = {
+    enable: false,
+    pumpSwitching: false,
+    pumpReplacement: false,
+    name: '', 
+    wateringTime: 0, 
+    id: '', 
+    pumpCistern: false, 
+    intBreak: false, 
+    leadTime: 0, 
+    cancelLeadTime: {}, 
+    pumpPower: 0, 
+    restFlow: 0, 
+    ac: {}, 
+    controller: {}, 
+    control: {
+        idState: undefined, 
+        idON_TIME: undefined, 
+        idACK: undefined, 
+        maker: undefined
+    }
+};
+let mainPumpControl = {
+    idState: undefined, 
+    idON_TIME: undefined, 
+    idACK: undefined, 
+    maker: undefined
+};
+let cisternPumpControl = {
+    idState: undefined, 
+    idON_TIME: undefined, 
+    idACK: undefined, 
+    maker: undefined
+};
 
 /**
  *  Steuerspannung 24V
@@ -75,7 +125,55 @@ let cisternPumpControl = {idState: undefined, idON_TIME: undefined, idACK: undef
  * - idState: Aktorerkennung "hm-rpc.0.MEQ1810129.1.STATE"
  * - controller: controlle von Zeiten und Abbruchsignalen
  */
-const controlVoltage = {enable: false, name: '24V',wateringTime: 0, ac: {}, controller: {}, control: {idState: undefined, idON_TIME: undefined, idACK: undefined, maker: undefined}};
+const controlVoltage = {
+    enable: false, 
+    name: '24V', 
+    wateringTime: 0, 
+    ac: {}, 
+    controller: {}, 
+    control: {
+        idState: undefined, 
+        idON_TIME: undefined, 
+        idACK: undefined, 
+        maker: undefined
+    }
+};
+/**
+ * Sensor Druck
+ * - enable: Sensor vorhanden
+ * - active: true = Sensor aktiv, false = Sensor inaktiv
+ * - setActive(true/false): Funktion zum setzen des Sensorstatus aktiv/inaktiv
+ * - inadequatePressure: true = Nicht ausreichender Druck, false = ausreichender Druck
+ * - name: Bezeichnung Sensor Druck
+ * - value: aktueller Wert des Sensors
+ * - state: aktueller Zustand des Sensors
+ * - ac: AbortController für die Überwachung der Sensoraktivität
+ */
+const sensorPressure = {
+    enable: false,
+    active: false,
+    setActive: async(val) => {
+        try {
+            sensorPressure.active = val;
+            if (val === true && sensorPressure.enable) {
+                await valveControl.setSensorPressure(sensorPressure.value);
+            } else {
+                if (sensorPressure?.ac !== null) {
+                    await sensorPressure.ac.abort();   // AbortController zurücksetzen
+                    sensorPressure.ac = null;
+                    sensorPressure.inadequatePressure = false;   // Drucksensor deaktiviert -> Druckverhältnisse wieder in Ordnung
+                } 
+            }
+        } catch (error) {
+            adapter.log.error(`Error setting sensor pressure active ${val}: ${error}`);
+        }
+    },
+    inadequatePressure: false,
+    name: 'Sensor Pressure', 
+    value: 0, 
+    state: 0, 
+    ac: null
+};
 
 /**
  *  Schaltabstand in ms
@@ -154,7 +252,7 @@ const setValve = async (thread, val) => {
     
     //adapter.log.info(`Set Valve (async () => {...}`);
     try {
-        // Ventil ansteuern
+        // ON_Time setzen wenn angegeben, damit das Ventil nach der angegebenen Zeit automatisch ausgeschaltet wird (z.B. wenn der Ausschaltbefehl nicht ausgeführt werden kann, z.B Funkstörung)
         if (thread.control.idON_TIME !== null) {
             await adapter.setForeignStateAsync(thread.control.idON_TIME, {
                 val: val ? Math.ceil(thread.wateringTime + 5) : 0,
@@ -162,7 +260,7 @@ const setValve = async (thread, val) => {
             });
             await asyncTime.setTimeout(200, undefined, undefined);
         }
-        
+        // Ventil ansteuern
         const _setValve = await adapter.setForeignStateAsync(thread.control.idState, {
             val: val,
             ack: false
@@ -263,31 +361,36 @@ const delList = async (killList) => {
 
 /**
  * currentConsumption aktueller Verbrauch ermitteln
+ * - curFlow: aktuelle Restfördertleistung der Pumpe
+ * - parallel: aktuelle Anzahl der eingeschalteten Ventile
+ * - pumpRequired: Pumpe erforderlich (true/false)
  *
  * @param {boolean} write
  * @returns {Promise<{curFlow:number, parallel:number, pumpRequired:boolean}>}
  */
 const currentConsumption = async (write) => {
     try {
-        let curFlow = currentPumpUse.intBreak ? 0 : currentPumpUse.pumpPower, /* adapter.config.triggerMainPumpPower; */
+        let curFlow = (currentPumpUse.intBreak || sensorPressure.inadequatePressure) ? 0 : currentPumpUse.pumpPower, /* adapter.config.triggerMainPumpPower; */
             /** aktuelle Anzahl der eingeschalteten Ventile */
             parallel = 0,
             pumpRequired = false;
         adapter.log.debug(`currentConsumption curFlow: ${curFlow}, ${currentPumpUse.intBreak} => ${currentPumpUse.intBreak ? 0 : currentPumpUse.pumpPower}`);
-        if (!currentPumpUse.intBreak) {
+        //if (!currentPumpUse.intBreak
+        //    && !sensorPressure.inadequatePressure
+        //) {
         // ermitteln von curPipe und der Anzahl der parallelen Stränge
             for (const entry of threadList){
                 if (entry.state === 'wait') pumpRequired = true;   // state => wait
-                if (entry.enable === true
-                    && entry.extBreak === false
-                    && timeBasedRestrictionEn === false
+                if (entry.enable === true   // Ventil eingeschaltet
+                    && entry.extBreak === false // && nicht in der externen Pause (extBreak)
+                    && timeBasedRestrictionEn === false // && nicht in der zeitlichen Bewässerungspause
                 ) {
                     curFlow -= entry.pipeFlow;	// // ermitteln der RestFörderkapazität
                     parallel ++;	// Anzahl der Bewässerungsstellen um 1 erhöhen
                     pumpRequired = true;
                 }
             }
-        }
+        //}
         // bei write schreiben der aktuellen Förderleistung der Pumpe und der Anzahl der parallelen Stränge
         if (write || currentPumpUse.intBreak) {
             adapter.setStateAsync('control.parallelOfMax', {
@@ -456,7 +559,7 @@ const countSprinkleTime = async (entry) => {
 /**
  * Timer zum ausschalten des Boost
  * 
- * @param {*} entry 
+ * @param {object} entry 
  */
 const boostOnTimer = async (entry) => {
     entry.ac.acBoostOnTimer = new AbortController;
@@ -538,7 +641,7 @@ const updateList = async () => {
         : false;
 
     /**
-     * Druckentlastungsventil Steuerung
+     * Find das Ventil mit dem größten Durchfluss (pipeFlow) für die Steuerung des Druckentlastungsventils
      * - Wenn die Bewässerung beendet wird, soll der Druck in den Leitungen durch kurzes Öffnen eines Druckentlastungsventils abgebaut werden, 
      * um die Lebensdauer des Systems zu erhöhen. Hierzu wird das Ventil mit dem Größten Durchfluss (pipeFlow) für 10 Sekunden angesteuert.
      */
@@ -574,7 +677,7 @@ const updateList = async () => {
         try {
             if (adapter.config.triggerControlVoltage
             && controlVoltage.enable === false
-            || adjustment === true
+            || adjustment === true  // Anpassung ON_Time wenn Laufzeit zu kurz, damit die 24V Versorgung während der Laufzeit nicht ausgeschaltet wird
             ) {
                 controlVoltage.wateringTime = sumOfWateringTime > controlVoltage.wateringTime ? sumOfWateringTime + 5 : controlVoltage.wateringTime;   // Schaltzeit der 24V Versorgung entsprechend der maximalen Laufzeit aller Ventile in der threadList anpassen
                 const _controlVoltage = await setValve(controlVoltage, true);
@@ -594,7 +697,7 @@ const updateList = async () => {
         try {
             if (adapter.config.pumpSelection !== 'noPump'
             && currentPumpUse.enable === false
-            || adjustment === true
+            || adjustment === true  // Anpassung ON_Time wenn Laufzeit zu kurz, damit die Pumpe während der Laufzeit nicht ausgeschaltet wird
             ) {
                 currentPumpUse.wateringTime = sumOfWateringTime > currentPumpUse.wateringTime ? sumOfWateringTime : currentPumpUse.wateringTime;   // Schaltzeit der Pumpe entsprechend der maximalen Laufzeit aller Ventile in der threadList anpassen                
                 const _currentPumpUse = await setValve(currentPumpUse, true);
@@ -606,6 +709,7 @@ const updateList = async () => {
                     });
                     await asyncTime.setTimeout(currentPumpUse.leadTime, undefined, undefined);
                 }
+                await sensorPressure.setActive(true);  // Sensor Druck aktivieren, damit die Drucküberwachung startet
             }                   
         } catch (error) {
             adapter.log.error(`Error trigger current Pump [${currentPumpUse.control.idState}]: ${error}`);
@@ -630,7 +734,7 @@ const updateList = async () => {
                         consumption = await currentConsumption(true);
                         clearInterval(entry.countdown); // Zähler für Countdown, Verbrauchsmengen, usw. löschen
                         entry.countdown = null;
-                        adapter.log.info(`Set Valve ID: ${entry.name} Pump delivery rate too low, wait!  curFlow ${consumption.curFlow} parallel: ${consumption.parallel}`);
+                        adapter.log.warn(`Set Valve ID: ${entry.name} Pump delivery rate too low, wait!  curFlow ${consumption.curFlow} parallel: ${consumption.parallel}`);
                         await asyncTime.setTimeout(300, undefined, {signal: entry.ac.acUpdateListPuOff.signal});
                     }                    
                 }else{
@@ -725,6 +829,10 @@ const updateList = async () => {
 
         // Pumpe ausschalten
         if (currentPumpUse.enable === true) {
+            await sensorPressure.setActive(false).catch((error) => {  // Sensor Druck deaktivieren, da keine Bewässerung mehr aktiv ist
+                adapter.log.error(`Error setting sensor pressure active false: ${error}`);
+            });
+            
             try {
                 const _currentPumpUse = await setValve(currentPumpUse, false);
                 if (_currentPumpUse === currentPumpUse.control.idState) {
@@ -735,7 +843,7 @@ const updateList = async () => {
                 }
                 await asyncTime.setTimeout(switchingDistanceMS, undefined, undefined);                
             } catch (error) {
-                adapter.log.error(`Error trigger current Pump [${currentPumpUse.idState}]: ${error}`);
+                adapter.log.error(`Error trigger current Pump [${ currentPumpUse.control.idState }]: ${error}`);
             }
 
             // Druckentlastungsventil ansteuern wenn in Konfiguration aktiv
@@ -744,7 +852,6 @@ const updateList = async () => {
                 try {
                     const empty = await findPressureReliefValve();
                     const _pressureReliefIO = await pressureReliefIO();
-                    adapter.log.info(`pressureReliefIO: ${ _pressureReliefIO }, Data: ${ JSON.stringify(_pressureReliefIO) }`);
                     if (empty && _pressureReliefIO === 0) {   // Ventil gefunden und alle Ventile haben ihre Laufzeit beendet
                         pressureReliefValve.name = empty.objectName;
                         pressureReliefValve.wateringTime = 10;
@@ -817,7 +924,7 @@ const setActualPump = async () => {
                 /* Pumpe AUS => Zisternen-Bewässerung nicht aktiviert */
                 if (adapter.config.triggerCisternPump) {
                     await adapter.setStateAsync('info.cisternState', {
-                        val: `Cistern settings are not active! ${(fillLevelCistern > 0) ? (`level sensor: ${fillLevelCistern}% ${(adapter.config.triggerMinCisternLevel !== '') ? (`  ${adapter.config.triggerMinCisternLevel}%`) : ('')}`):('')}`,
+                        val: `Cistern settings are not active! ${(fillLevelCistern > 0) ? (` ${fillLevelCistern}% ${(adapter.config.triggerMinCisternLevel !== '') ? (`  ${adapter.config.triggerMinCisternLevel}%`) : ('')}`):('')}`,
                         ack: true
                     });
                 }
@@ -853,7 +960,7 @@ const setActualPump = async () => {
                 }
                 /* Info aktualisieren */
                 await adapter.setStateAsync('info.cisternState', {
-                    val: `${ (currentPumpUse.intBreak === true)  ? 'Cistern empty: ' : 'Cistern filled: ' } Cistern level: ${ fillLevelCistern } % (${ adapter.config.triggerMinCisternLevel } %)`,
+                    val: `${ (currentPumpUse.intBreak === true)  ? 'Cistern empty: ' : 'Cistern filled: ' } ${ fillLevelCistern } % (${ adapter.config.triggerMinCisternLevel } %)`,
                     ack: true
                 });
                 break;
@@ -864,6 +971,8 @@ const setActualPump = async () => {
                 /* Bewässerungspumpen aktiv */
                     if ((fillLevelCistern < parseFloat(adapter.config.triggerMinCisternLevel)) && (currentPumpUse.pumpCistern === true)) {
                     /* (Zisterne unter Minimum) && (ZisternenPumpe läuft) */
+                        currentPumpUse.pumpSwitching = true;
+                        sensorPressure.setActive(false);  // Sensor Druck deaktivieren, da die Hauptpumpe ausgeschaltet wird und somit kein Druck mehr in den Leitungen ist
                         const _setValveCisternPumpOff = await setValve(currentPumpUse, false);  // Pumpe Zisterne Aus
                         if (_setValveCisternPumpOff === currentPumpUse.control.idState) {
                             await adapter.setStateAsync(currentPumpUse.id, {      // set State cisternPump === false
@@ -880,7 +989,7 @@ const setActualPump = async () => {
                         currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower);
                         /* Hauptpumpe Ein */
                         const _setValveMainPumpOn = await setValve(currentPumpUse, true);   
-                        if (_setValveMainPumpOn === currentPumpUse.idState) {
+                        if (_setValveMainPumpOn === currentPumpUse.control.idState) {
                             await adapter.setStateAsync(currentPumpUse.id, {      // set State cisternPump === false
                                 val: currentPumpUse.enable, 
                                 ack: true
@@ -892,6 +1001,8 @@ const setActualPump = async () => {
                         if(!sendMessageText.onlySendError()){
                             sendMessageText.sendMessage('Pump change (cistern empty) Cistern pump off => main pump on');
                         }
+                        currentPumpUse.pumpSwitching = false;
+                        sensorPressure.setActive(true);   // Sensor Druck aktivieren, da die Hauptpumpe eingeschaltet wird und somit wieder Druck in den Leitungen ist
                         updateList();   // Wasserverbrauch an Pumpenleistung anpassen
                     }
                 } else {
@@ -926,7 +1037,7 @@ const setActualPump = async () => {
                 }
                 /* Info aktualisieren */
                 await adapter.setStateAsync('info.cisternState', {
-                    val: `${ (currentPumpUse.pumpCistern === false)  ? 'Cistern empty: ' : 'Cistern filled: ' } Cistern level: ${ fillLevelCistern } % (${ adapter.config.triggerMinCisternLevel } %)`,
+                    val: `${ (currentPumpUse.pumpCistern === false)  ? 'Cistern empty: ' : 'Cistern filled: ' } ${ fillLevelCistern } % (${ adapter.config.triggerMinCisternLevel } %)`,
                     ack: true
                 });
                 break;
@@ -1325,6 +1436,63 @@ const valveControl = {
                     }
                 }
             }
+
+            /**
+             * Objekt sensorPressure anlegen und abonnieren, wenn benötigt
+             */
+            
+            if (typeof adapter.config.sensorPressure === 'string' 
+                && adapter.config.sensorPressure.length > 5
+                && adapter.config.pumpSelection !== 'noPump'
+            ) {
+                const _sensorPressure = await adapter.getForeignStateAsync(adapter.config.sensorPressure);
+                if (_sensorPressure) {
+                    sensorPressure.enable = true;
+                    sensorPressure.active = false;
+                    adapter.subscribeForeignStates(adapter.config.sensorPressure);
+                    const _waterPressure = await adapter.getObjectAsync(`info.waterPressure`);
+                    if (_waterPressure) {
+                        sensorPressure.value = _sensorPressure.val;
+                    } else {
+                        await adapter.setObjectNotExistsAsync(`info.waterPressure`, {
+                            type: 'state',
+                            common: {
+                                role:  'state',
+                                name:  'Water pressure',
+                                desc:  {
+                                    en: 'Water pressure',
+                                    de: 'Wasserdruck',
+                                    ru: 'Давление воды',
+                                    pt: 'Pressão da água',
+                                    nl: 'Waterdruk',
+                                    fr: "Pression de l'eau",
+                                    it: "Pressione dell'acqua",
+                                    es: 'Presión del agua',
+                                    pl: 'Ciśnienie wody',
+                                    uk: 'Тиск води',
+                                    'zh-cn': '水压'
+                                    },
+                                type:  'string',
+                                read:  true,
+                                write: false,
+                                def:   ' --- ',
+                                unit: 'bar'
+                            },
+                            native: {},
+                        });
+                    }
+                    await adapter.setStateAsync(`info.waterPressure`, {
+                        val: `Initial ( ${ sensorPressure.value } bar )`,
+                        ack: true
+                    });
+                } else {
+                    adapter.log.warn(`The configured pressure sensor "${ adapter.config.sensorPressure }" could not be found. Please check the configuration of the pressure sensor!`);
+                }
+            } else {
+                // Wenn kein Drucksensor konfiguriert ist, wird das Objekt info.waterPressure gelöscht, damit keine falschen Werte angezeigt werden
+                const _waterPressure = await adapter.getObjectAsync(`info.waterPressure`);
+                if (_waterPressure) await adapter.delObjectAsync(`info.waterPressure`);
+            }
         } catch (error) {
             adapter.log.error(`initValveControl ERROR: ${error}`);
         }
@@ -1342,6 +1510,7 @@ const valveControl = {
      */
     addList: async function (sprinkleList) {
         try {
+            sensorPressure.inadequatePressure = false;    // Kontrolle Drucksensorwert zurücksetzen, damit die Bewässerungsbeschränkung korrekt funktioniert, wenn der Drucksensorwert während der Bewässerungsbeschränkung unter dem Minimum lag
             // kontrolle bei ausgeschalteter Pumpe, ob die Zisterne zur Bewässerung genutzt werden kann
             if (adapter.config.pumpSelection === 'pumpAndCistern'
                 && currentPumpUse.enable === false
@@ -1444,7 +1613,8 @@ const valveControl = {
     }, // End addList
 
     timeBasedRestriction: async function (enable) {         //Irrigation ban => zeitliche Bewässerungsbeschränkung noch zu bearbeiten ! ! !
-        try {            
+        try {
+            sensorPressure.inadequatePressure = false; // Kontrolle Drucksensorwert zurücksetzen, damit die Bewässerungsbeschränkung korrekt funktioniert, wenn der Drucksensorwert während der Bewässerungsbeschränkung unter dem Minimum lag
             timeBasedRestrictionEn = enable;
             if (threadList) {
                 if (timeBasedRestrictionEn === true) {      // zeitliche Bewässerungsbeschränkung aktiv
@@ -1654,8 +1824,78 @@ const valveControl = {
      */
     getIntBreakCisternPump: function () {
        return (adapter.config.pumpSelection === 'cistern') ? currentPumpUse.intBreak : false;
-    }
+    },
 
+    /**
+     * Setzt den Drucksensorwert
+     * https://blog.logrocket.com/complete-guide-abortcontroller/
+     * 
+     * @param {number} pressure
+     */
+    setSensorPressure: async function (pressure) {
+        let alteredPressure = false;    // Veränderter Druck => updateList starten um Verbrauch anzupassen / Ventile ausschalten
+        let reviews = '';
+
+        try {
+            sensorPressure.value = parseFloat(pressure).toFixed(1);
+            if (sensorPressure.active === true && adapter.config.minimumPressure > pressure) {
+                if (sensorPressure.ac === null) {
+                    sensorPressure.ac = new AbortController();
+                    await asyncTime.setTimeout(60000, undefined, { signal: sensorPressure.ac.signal });  // max. 60s warten und Drucksensorwert erneut prüfen, bevor die Pumpe ausgeschaltet wird
+                    const _currentPressure = await adapter.getForeignStateAsync(adapter.config.sensorPressure);
+                    if (_currentPressure?.val){
+                        if(typeof _currentPressure.val === 'number') {
+                            sensorPressure.value = parseFloat(_currentPressure.val).toFixed(1);
+                        }else if(typeof _currentPressure.val === 'string') {
+                            sensorPressure.value = parseFloat(_currentPressure.val).toFixed(1);
+                        }else if(typeof _currentPressure.val === 'boolean') {
+                            (_currentPressure.val === true) ? sensorPressure.value = 100 : sensorPressure.value = 0;
+                        }else{
+                            throw new Error(`setSensorPressure => Wrong value: ${ _currentPressure.val }, Type: ${ typeof _currentPressure.val }`);
+                        }
+                        if (sensorPressure.active === true
+                            && adapter.config.minimumPressure > sensorPressure.value
+                        ) {
+                            reviews = 'Not Okay'
+                            if (sensorPressure.inadequatePressure === false) {
+                                alteredPressure = true;
+                                sensorPressure.inadequatePressure = true;
+                            }
+                            adapter.log.warn(`Pressure sensor value ${ sensorPressure.value } bar is below the minimum pressure ${ adapter.config.minimumPressure } bar. The pump will be turned off to prevent damage. Please check the pressure sensor and the configuration of the minimum pressure!`);
+                            if (adapter.config.notificationEnabled) {
+                                sendMessageText.sendMessage(`Pressure sensor value ${ sensorPressure.value } bar is below the minimum pressure ${ adapter.config.minimumPressure } bar. The pump will be turned off to prevent damage. Please check the pressure sensor and the configuration of the minimum pressure!`);
+                            }
+                        } else {
+                            reviews = 'Okay';
+                        }
+                    }
+                    sensorPressure.ac = null;    // AbortController zurücksetzen
+                } else {
+                    reviews = 'I don\'t know';  // Ich weiß nicht
+                }
+            } else {
+                reviews = 'Okay'
+                if (sensorPressure?.ac !== null) {
+                    await sensorPressure.ac.abort();   // AbortController zurücksetzen
+                    sensorPressure.ac = null;
+                }   
+            }
+        } catch (error) {
+            if (error.name === 'AbortError') {
+                adapter.log.debug(`setSensorPressure(${ sensorPressure.value}): The shutdown process was aborted because the operating pressure was restored.`);
+                if (sensorPressure?.ac !== null) {
+                    sensorPressure.ac.abort();   // AbortController zurücksetzen
+                    sensorPressure.ac = null;
+                }
+            }
+        } finally {
+            await adapter.setStateAsync(`info.waterPressure`, {
+                val: `${ reviews } ( ${ sensorPressure.value } bar )`,
+                ack: true
+            });          
+            if (alteredPressure) updateList();
+        }
+    }
 };  // End valveControl
 
 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/