iobroker.sprinklecontrol 1.0.5 → 1.0.7

package/lib/valveControl.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)
@@ -46,7 +58,12 @@ let boostReady = true,
      */
     timeBasedRestrictionEn = false;
 
-const updateListMarker = {funcActive: false, newStart: false, switchingDistance: 5000, cancelSwitchingDistance: {}};
+const updateListMarker = {
+    funcActive: false, 
+    newStart: false, 
+    switchingDistance: 5000, 
+    cancelSwitchingDistance: {}
+};
 
 /**
  * aktive Pumpendaten
@@ -64,9 +81,38 @@ 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, 
+    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 +121,27 @@ 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
+    }
+};
+
+const sensorPressure = {
+    inadequatePressure: false,  // true = Nicht ausreichender Druck, false = ausreichender Druck
+    name: 'Sensor Pressure', 
+    value: 0, 
+    state: 0, 
+    ac: null
+};
 
 /**
  *  Schaltabstand in ms
@@ -154,7 +220,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 +228,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
@@ -205,16 +271,21 @@ const setValve = async (thread, val) => {
         if (thread.ac.acSetValveCancelTimeout.aborted === false) thread.ac.acSetValveCancelTimeout.abort();
     }
 
-    if (thread.name !== 'Cistern pump' && thread.name !== 'Main pump' && thread.name !== '24V' && thread.name !== 'no Pump') {
-        adapter.setStateAsync(`sprinkle.${thread.name}.sprinklerState`, {
-            val: thread.state,
-            ack: true
-        });
-        adapter.setStateAsync(`sprinkle.${thread.name}.valveOn`, {
-            val: thread.enable,
-            ack: true
-        });
+    try {
+        if (thread.name !== 'Cistern pump' && thread.name !== 'Main pump' && thread.name !== '24V' && thread.name !== 'no Pump') {
+            await adapter.setStateAsync(`sprinkle.${thread.name}.sprinklerState`, {
+                val: thread.state,
+                ack: true
+            });
+            adapter.setStateAsync(`sprinkle.${thread.name}.valveOn`, {
+                val: thread.enable,
+                ack: true
+            });
+        }
+    } catch (error) {
+        adapter.log.error(`setValve ${thread.name} => Error setting sprinklerState or valveOn: ${error}`);
     }
+
     return result;
 };
 
@@ -258,6 +329,9 @@ 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}>}
@@ -269,13 +343,15 @@ const currentConsumption = async (write) => {
             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
@@ -451,7 +527,7 @@ const countSprinkleTime = async (entry) => {
 /**
  * Timer zum ausschalten des Boost
  * 
- * @param {*} entry 
+ * @param {object} entry 
  */
 const boostOnTimer = async (entry) => {
     entry.ac.acBoostOnTimer = new AbortController;
@@ -533,7 +609,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.
      */
@@ -546,9 +622,22 @@ const updateList = async () => {
             }, myConfig.config[0]
         );
     }
-    // Implementation for pressure relief valve control
-
+    /**
+     * Druckentlastungsventil ein wenn alle Ventile ihre Laufzeit beendet haben 
+     * .killSprinkle = true
+     */
+    function pressureReliefIO() {
+        return threadList.reduce((count, entry) => {
+                return (entry.myBreak === true               // Intervall-Beregnung on
+                     && entry.killSprinkle === false         // && Aufgabe noch nicht erledigt
+                    ) ? (count + 1) : count;
+            }, 0
+        );
+    }
 
+    /**
+     * Start der Steuerung der Pumpen und Ventile
+     */ 
     consumption = await currentConsumption(true);
     if (consumption.pumpRequired === true) {    // Pumpe erforderlich
 
@@ -556,7 +645,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);
@@ -576,7 +665,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);
@@ -725,7 +814,8 @@ const updateList = async () => {
             ) {
                 try {
                     const empty = await findPressureReliefValve();
-                    if (empty) {
+                    const _pressureReliefIO = await pressureReliefIO();
+                    if (empty && _pressureReliefIO === 0) {   // Ventil gefunden und alle Ventile haben ihre Laufzeit beendet
                         pressureReliefValve.name = empty.objectName;
                         pressureReliefValve.wateringTime = 10;
                         pressureReliefValve.pipeFlow = empty.pipeFlow;
@@ -796,8 +886,8 @@ const setActualPump = async () => {
             case 'mainPump': {
                 /* Pumpe AUS => Zisternen-Bewässerung nicht aktiviert */
                 if (adapter.config.triggerCisternPump) {
-                    adapter.setState('info.cisternState', {
-                        val: `Cistern settings are not active! ${(fillLevelCistern > 0) ? (`level sensor: ${fillLevelCistern}% ${(adapter.config.triggerMinCisternLevel !== '') ? (`  ${adapter.config.triggerMinCisternLevel}%`) : ('')}`):('')}`,
+                    await adapter.setStateAsync('info.cisternState', {
+                        val: `Cistern settings are not active! ${(fillLevelCistern > 0) ? (` ${fillLevelCistern}% ${(adapter.config.triggerMinCisternLevel !== '') ? (`  ${adapter.config.triggerMinCisternLevel}%`) : ('')}`):('')}`,
                         ack: true
                     });
                 }
@@ -805,48 +895,37 @@ const setActualPump = async () => {
             }
 
             case 'cistern': {
-                if (fillLevelCistern < parseFloat(adapter.config.triggerMinCisternLevel)) {     //  (Zisterne unter Minimum)
+                //  Zisterne unter Minimum
+                if (fillLevelCistern < parseFloat(adapter.config.triggerMinCisternLevel)) {     
                     if (!currentPumpUse.intBreak) {
                         currentPumpUse.intBreak = true;
-                        adapter.log.warn('Cistern empty => irrigation no longer possible');
+                        adapter.log.info('Cistern empty => irrigation no longer possible');
                         if(!sendMessageText.onlySendError()){
                             sendMessageText.sendMessage('Cistern empty => irrigation no longer possible');  // Zisterne leer => Bewässerung nicht mehr möglich
                         }
                     }
-                    adapter.setState('info.cisternState', {
-                        val: `Cistern empty: ${fillLevelCistern} % (${adapter.config.triggerMinCisternLevel} %)`,
-                        ack: true
-                    });
                     //  Pumpe ist eingeschaltet => ausschalten
                     if (currentPumpUse.enable) {
                         await setValve(currentPumpUse, false);
                         updateList();   // Wasserverbrauch an Pumpenleistung anpassen
                     }
+                //  Zisterne über Minimum
                 } else if (fillLevelCistern > parseFloat(adapter.config.triggerOnCisternLevel)) {
                     if (currentPumpUse.intBreak) {
                         currentPumpUse.intBreak = false;
-                        adapter.log.warn('Cistern filled => irrigation can begin again');                   // Zisterne gefüllt => Bewässerung kann wieder beginnen
+                        adapter.log.info('Cistern filled => irrigation can begin again');                   // Zisterne gefüllt => Bewässerung kann wieder beginnen
                         if(!sendMessageText.onlySendError()){
                             sendMessageText.sendMessage('Cistern filled => irrigation can begin again');
                         }
                     }
-                    currentPumpUse.intBreak = false;
-                    adapter.setState('info.cisternState', {
-                        val: `Cistern filled: ${fillLevelCistern} % (${adapter.config.triggerMinCisternLevel} %)`,
-                        ack: true
-                    });
-                    updateList();   // Wasserverbrauch an Pumpenleistung anpassen
-                } else if (currentPumpUse.intBreak === true) {
-                    adapter.setState('info.cisternState', {
-                        val: `Cistern empty: ${fillLevelCistern} % (${adapter.config.triggerMinCisternLevel} %)`,
-                        ack: true
-                    });
-                } else {
-                    adapter.setState('info.cisternState', {
-                        val: `Cistern filled: ${fillLevelCistern} % (${adapter.config.triggerMinCisternLevel} %)`,
-                        ack: true
-                    });
+                    // Wasserverbrauch an Pumpenleistung anpassen
+                    updateList();
                 }
+                /* Info aktualisieren */
+                await adapter.setStateAsync('info.cisternState', {
+                    val: `${ (currentPumpUse.intBreak === true)  ? 'Cistern empty: ' : 'Cistern filled: ' } ${ fillLevelCistern } % (${ adapter.config.triggerMinCisternLevel } %)`,
+                    ack: true
+                });
                 break;
             }
 
@@ -861,6 +940,8 @@ const setActualPump = async () => {
                                 val: currentPumpUse.enable, 
                                 ack: true
                             });
+                        } else {
+                            throw new Error(`Error trigger cistern Pump off [${currentPumpUse.control.idState}]`);
                         }
                         currentPumpUse.pumpCistern = false;
                         currentPumpUse.name = 'Main pump';
@@ -874,6 +955,8 @@ const setActualPump = async () => {
                                 val: currentPumpUse.enable, 
                                 ack: true
                             });
+                        } else {
+                            throw new Error(`Error trigger main Pump on [${currentPumpUse.control.idState}]`);
                         }
                         adapter.log.info('Pump change (cistern empty) Cistern pump off => main pump on');
                         if(!sendMessageText.onlySendError()){
@@ -883,45 +966,39 @@ const setActualPump = async () => {
                     }
                 } else {
                 /* Bewässerungspumpen inaktiv */
-                    if ((fillLevelCistern > parseFloat(adapter.config.triggerOnCisternLevel)) && (adapter.config.triggerCisternPump) && (adapter.config.triggerCisternPumpPower)) {
-                    /* Zisterne voll && triggerCisternPump && triggerCisternPumpPower vorhanden*/
-                        adapter.setState('info.cisternState', {
-                            val: `Cistern filled: ${fillLevelCistern} % (${adapter.config.triggerMinCisternLevel} %)`,
-                            ack: true
-                        });
-                        currentPumpUse.pumpCistern = true;
-                        currentPumpUse.name = 'Cistern pump';
-                        currentPumpUse.id = 'info.cisternPump';
-                        currentPumpUse.control = { ...cisternPumpControl };
-                        currentPumpUse.pumpPower = parseInt(adapter.config.triggerCisternPumpPower);
-
-                    } else {
-                        adapter.setState('info.cisternState', {
-                            val: `Cistern empty: ${fillLevelCistern} % (adapter.config.triggerMinCisternLevel %)`,
-                            ack: true
-                        });
-                        currentPumpUse.pumpCistern = false;
-                        currentPumpUse.name = 'Main pump';
-                        currentPumpUse.id = 'info.mainPump';
-                        currentPumpUse.control = { ...mainPumpControl };
-                        currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower);
+                    if (fillLevelCistern > parseFloat(adapter.config.triggerOnCisternLevel)) {
+                    /* Zisterne voll */
+                        if (currentPumpUse.pumpCistern === false) {
+                            currentPumpUse.pumpCistern = true;
+                            currentPumpUse.name = 'Cistern pump';
+                            currentPumpUse.id = 'info.cisternPump';
+                            currentPumpUse.control = { ...cisternPumpControl };
+                            currentPumpUse.pumpPower = parseInt(adapter.config.triggerCisternPumpPower);
+                            await adapter.setStateAsync('control.restFlow', {
+                                val: `${currentPumpUse.pumpPower} (${currentPumpUse.pumpPower} | ${currentPumpUse.name})`,
+                                ack: true
+                            });
+                        }
+                    } else if (fillLevelCistern < parseFloat(adapter.config.triggerMinCisternLevel)) {
+                        /* Zisterne leer */
+                        if (currentPumpUse.pumpCistern === true) {
+                            currentPumpUse.pumpCistern = false;
+                            currentPumpUse.name = 'Main pump';
+                            currentPumpUse.id = 'info.mainPump';
+                            currentPumpUse.control = { ...mainPumpControl };
+                            currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower);
+                            await adapter.setStateAsync('control.restFlow', {
+                                val: `${currentPumpUse.pumpPower} (${currentPumpUse.pumpPower} | ${currentPumpUse.name})`,
+                                ack: true
+                            });                            
+                        }
                     }
-                    adapter.setState('control.restFlow', {
-                        val: `${currentPumpUse.pumpPower} (${currentPumpUse.pumpPower} | ${currentPumpUse.name})`,
-                        ack: true
-                    });
-                }
-                if (currentPumpUse.pumpCistern) {
-                    adapter.setState('info.cisternState', {
-                        val: `Cistern filled: ${fillLevelCistern} % (${adapter.config.triggerMinCisternLevel} %)`,
-                        ack: true
-                    });
-                } else {
-                    adapter.setState('info.cisternState', {
-                        val: `Cistern empty: ${fillLevelCistern} % (${adapter.config.triggerMinCisternLevel} %)`,
-                        ack: true
-                    });
                 }
+                /* Info aktualisieren */
+                await adapter.setStateAsync('info.cisternState', {
+                    val: `${ (currentPumpUse.pumpCistern === false)  ? 'Cistern empty: ' : 'Cistern filled: ' } ${ fillLevelCistern } % (${ adapter.config.triggerMinCisternLevel } %)`,
+                    ack: true
+                });
                 break;
             }
         }   
@@ -1135,8 +1212,8 @@ const valveControl = {
                     const _actualValueLevel = await adapter.getForeignStateAsync(adapter.config.actualValueLevel);
                     if (_actualValueLevel && _actualValueLevel.val) {
                         if (typeof _actualValueLevel.val === 'number') {
-                            fillLevelCistern = _actualValueLevel.val;
-                            (_actualValueLevel.val > parseInt(adapter.config.triggerMinCisternLevel)) ? currentPumpUse.intBreak = false : currentPumpUse.intBreak = true;
+                            fillLevelCistern = parseInt(_actualValueLevel.val);
+                            (fillLevelCistern > parseInt(adapter.config.triggerMinCisternLevel)) ? currentPumpUse.intBreak = false : currentPumpUse.intBreak = true;
                         } else if (typeof _actualValueLevel.val === 'boolean') {
                             if (_actualValueLevel.val) {
                                 currentPumpUse.intBreak = false;
@@ -1163,6 +1240,19 @@ const valveControl = {
                     currentPumpUse.leadTime = (parseInt(adapter.config.cisternPumpLeadTime) || 5) * 1000;
                     currentPumpUse.pumpPower = parseInt(adapter.config.triggerCisternPumpPower) || 0;
                     currentPumpUse.restFlow = parseInt(adapter.config.triggerCisternPumpPower) || 0;
+                    if (isNaN(parseInt(adapter.config.triggerMinCisternLevel)) 
+                        || (parseInt(adapter.config.triggerMinCisternLevel) <= 1) 
+                        || (parseInt(adapter.config.triggerMinCisternLevel) > 100)
+                    ) {
+                        adapter.log.error(`Pump selection "cistern" is selected, but the minimum cistern level is set to ${adapter.config.triggerMinCisternLevel}%. Please set the minimum cistern level to 1...100% or select another pump selection!`);
+                    }
+                    if (isNaN(parseInt(adapter.config.triggerOnCisternLevel)) 
+                        || (parseInt(adapter.config.triggerOnCisternLevel) <= parseInt(adapter.config.triggerMinCisternLevel))
+                        || (parseInt(adapter.config.triggerOnCisternLevel) > 100)
+                        || (parseInt(adapter.config.triggerOnCisternLevel) < 5)
+                    ) {
+                        adapter.log.error(`Pump selection "cistern" is selected, but the trigger on cistern level is set to ${adapter.config.triggerOnCisternLevel}%. Please set the trigger on cistern level to ${parseInt(adapter.config.triggerMinCisternLevel) + 5}...100% or select another pump selection!`);
+                    }
                     // @ts-ignore
                     await adapter.setObjectNotExistsAsync(`info.cisternPump`, objCisternPump);
                     const _mainPump = await adapter.getObjectAsync(`info.mainPump`);
@@ -1176,12 +1266,26 @@ const valveControl = {
                     cisternPumpControl = await tools.idStateControl(adapter, adapter.config.triggerCisternPump);
                     if (mainPumpControl?.idACK) adapter.subscribeForeignStates(mainPumpControl.idACK);
                     if (cisternPumpControl?.idACK) adapter.subscribeForeignStates(cisternPumpControl.idACK);
+                    /* Kontrolle der Konfiguration CisternLevel */
+                    if (isNaN(parseInt(adapter.config.triggerMinCisternLevel)) 
+                        || (parseInt(adapter.config.triggerMinCisternLevel) <= 1) 
+                        || (parseInt(adapter.config.triggerMinCisternLevel) > 100)
+                    ) {
+                        adapter.log.error(`Pump selection "mainpump & cistern" is selected, but the minimum cistern level is set to ${adapter.config.triggerMinCisternLevel}%. Please set the minimum cistern level to 1...100% or select another pump selection!`);
+                    }
+                    if (isNaN(parseInt(adapter.config.triggerOnCisternLevel)) 
+                        || (parseInt(adapter.config.triggerOnCisternLevel) <= parseInt(adapter.config.triggerMinCisternLevel))
+                        || (parseInt(adapter.config.triggerOnCisternLevel) > 100)
+                        || (parseInt(adapter.config.triggerOnCisternLevel) < 5)
+                    ) {
+                        adapter.log.error(`Pump selection "cistern" is selected, but the trigger on cistern level is set to ${adapter.config.triggerOnCisternLevel}%. Please set the trigger on cistern level to ${parseInt(adapter.config.triggerMinCisternLevel) + 5}...100% or select another pump selection!`);
+                    }
                     if (adapter.config.actualValueLevel) {
                         /*     Füllstand der Zisterne in % holen     */
                         const _actualValueLevel = await adapter.getForeignStateAsync(adapter.config.actualValueLevel);
-                        if (_actualValueLevel && _actualValueLevel.val) {
+                        if (_actualValueLevel?.val) {
                             if (typeof _actualValueLevel.val === 'number') {
-                                fillLevelCistern = _actualValueLevel.val;
+                                fillLevelCistern = parseInt(_actualValueLevel.val);
                             } else if (typeof _actualValueLevel.val === 'boolean') {
                                 _actualValueLevel.val ? fillLevelCistern = 100 : fillLevelCistern = 0;
                             } else {
@@ -1229,7 +1333,7 @@ const valveControl = {
                 }
             }
             /* Objekt control.restFlow befüllen */
-            adapter.setStateAsync('control.restFlow', {
+            await adapter.setStateAsync('control.restFlow', {
                 val: `${currentPumpUse.pumpPower} (${currentPumpUse.pumpPower} | ${currentPumpUse.name})`,
                 ack: true
             });
@@ -1291,6 +1395,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) {
+                    adapter.subscribeForeignStates(adapter.config.sensorPressure);
+                    const _waterPressure = await adapter.getObjectAsync(`info.waterPressure`);
+                    if (_waterPressure) {
+                        await adapter.setStateAsync(`info.waterPressure`, {
+                            val: `${ _sensorPressure.val }`,
+                            ack: true
+                        });
+                    } 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: `${ _sensorPressure.val }`,
+                            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 {
+                const _waterPressure = await adapter.getObjectAsync(`info.waterPressure`);
+                if (_waterPressure) await adapter.delObjectAsync(`info.waterPressure`);
+            }
         } catch (error) {
             adapter.log.error(`initValveControl ERROR: ${error}`);
         }
@@ -1308,6 +1469,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
@@ -1377,7 +1539,7 @@ const valveControl = {
                     /**  0:"off", 1:"wait", 2:"on", 3:"break", 4:"Boost(on)", 5:"off(Boost)", 6:"Cistern empty", 7:"extBreak" */ 
                         newThread.state = 'wait'; // zustand des Ventils Softwaremäßig 
                         newThread.enable = false; // zustand des Ventil softwaremäßig 
-                        newThread.myBreak = false; // meine interne Pause 
+                        newThread.myBreak = false; // meine interne Pause Intervallberegnung
                         newThread.extBreak = myConfig.config[res.sprinkleID].extBreak; // extBreak wird über .sprinkle.*.extBreak geschaltet 
                         newThread.killSprinkle = false; // Löschauftrag ausführen am Ende in threadList 
                         newThread.litersPerSecond = myConfig.config[res.sprinkleID].pipeFlow / 3600; // Wasserverbrauchsmenge pro Sekunde 
@@ -1410,7 +1572,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
@@ -1591,15 +1754,26 @@ const valveControl = {
      * @param {number|string|boolean} levelCistern
      */
     setFillLevelCistern: function (levelCistern) {
-        adapter.log.debug(`setFillLevelCistern: ${levelCistern}`);
+        let myFillLevelCistern = 0;
+        adapter.log.debug(`setFillLevelCistern: ${ levelCistern }`);
         if(typeof levelCistern === 'number') {
-            fillLevelCistern = levelCistern;
+            myFillLevelCistern = parseInt(levelCistern);
         }else if(typeof levelCistern === 'string') {
-            fillLevelCistern = parseFloat(levelCistern);
+            myFillLevelCistern = parseInt(levelCistern);
         }else if(typeof levelCistern === 'boolean') {
-            (levelCistern === true) ? fillLevelCistern = 100 : fillLevelCistern = 0;
+            (levelCistern === true) ? myFillLevelCistern = 100 : myFillLevelCistern = 0;
+        }
+        if(typeof myFillLevelCistern !== "number" 
+            || myFillLevelCistern < 0 
+            || myFillLevelCistern > 100
+        ) {
+            adapter.log.warn(`setFillLevelCistern (0...100% || true/false) => Wrong value: ${ levelCistern }, Type: ${ typeof levelCistern }`);
+            return;
+        }
+        if (myFillLevelCistern != fillLevelCistern) {
+            fillLevelCistern = myFillLevelCistern;
+            setActualPump();
         }
-        setActualPump();
     },   // End setFillLevelCistern
 
     /**
@@ -1609,8 +1783,72 @@ 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 (currentPumpUse.enable === 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
+                        && currentPumpUse.enable === true
+                        && adapter.config.minimumPressure > parseFloat(_currentPressure.val)
+                    ) {
+                        reviews = 'Not Okay'
+                        if (sensorPressure.inadequatePressure === false) {
+                            alteredPressure = true;
+                            sensorPressure.inadequatePressure = true;
+                        }
+                        sensorPressure.value = parseFloat(_currentPressure.val).toFixed(1);
+                        adapter.log.warn(`Pressure sensor value ${ pressure } 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 ${ pressure } 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!`);
+                        }
+                        sensorPressure.ac.abort();   // setTimeout abbrechen, da die Pumpe bereits ausgeschaltet wird
+                        sensorPressure.ac = null;    // AbortController zurücksetzen
+                    } else if (_currentPressure?.val) {
+                        reviews = 'Okay';
+                    }
+                    sensorPressure.ac = null;    // AbortController zurücksetzen
+                } else {
+                    reviews = 'I don\'t know';
+                }
+            } else if (currentPumpUse.enable === false || adapter.config.minimumPressure <= pressure) {
+                reviews = 'Okay'
+                if (sensorPressure?.ac !== null) {
+                    await sensorPressure.ac.abort();   // AbortController zurücksetzen
+                    sensorPressure.ac = null;
+                }   
+            } else {
+                reviews = 'Okay'
+            }
+        } catch (error) {
+            if (error.name === 'AbortError') {
+                adapter.log.debug(`setSensorPressure(${pressure}): 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
 
 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/