iobroker.sprinklecontrol 1.0.0 → 1.0.2

package/lib/valveControl.js

@@ -5,10 +5,7 @@ const asyncTime = require('timers/promises');
 // import {setTimeout} from 'timers/promises';
 
 const myConfig = require('./myConfig.js');
-//const sleep = require('./tools.js').sleep;
-const addTime = require('./tools.js').addTime;
-const formatTime = require('./tools').formatTime;
-const findAsync = require('./tools.js').findAsync;
+const tools = require('./tools.js').tools;
 const sendMessageText = require('./sendMessageText.js');            // sendMessageText
 
 /**
@@ -34,11 +31,15 @@ let boostReady = true,
      * maximal zulässige Anzahl der eingeschalteten Ventile
      */
     maxParallel = 0,
-    /* Control of the cistern pump */
     /**
      *  Füllstand der Zisterne
      */
-    fillLevelCistern = 0;
+    fillLevelCistern = 0,
+    /**
+     * Zeitliche Bewässerungseinschränkung EIN/AUS
+     */
+    timeBasedRestrictionEn = false;
+
 const updateListMarker = {funcActive: false, newStart: false, switchingDistance: 5000, cancelSwitchingDistance: {}};
 
 /**
@@ -57,7 +58,9 @@ const updateListMarker = {funcActive: false, newStart: false, switchingDistance:
  * - ac: AbortController
  */
 
-const currentPumpUse = {enable: false, name: '', idState: '', id: '', pumpCistern: false, intBreak: false, leadTime: 0, cancelLeadTime: {}, pumpPower: 0, restFlow: 0,ac: {},controller: {}};
+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
@@ -66,7 +69,7 @@ const currentPumpUse = {enable: false, name: '', idState: '', id: '', pumpCister
  * - idState: Aktorerkennung "hm-rpc.0.MEQ1810129.1.STATE"
  * - controller: controlle von Zeiten und Abbruchsignalen
  */
-const controlVoltage ={enable: false, name: '24V', idState: undefined, ac: {}, controller: {}};
+const controlVoltage ={enable: false, name: '24V',wateringTime: 0, ac: {}, controller: {}, control: {idState: undefined, idON_TIME: undefined, idACK: undefined, maker: undefined}};
 
 /**
  *  Schaltabstand in ms
@@ -87,9 +90,26 @@ let switchingDistanceMS = 250;
  */
 
 const setValve = async (thread, val) => {
+    // beim Schalten im guten Vertrauen (Befehl ohne Antwort)
+    if (adapter.config.switchingBehavior === 'noResponse') {
+        try {
+            await adapter.setForeignStateAsync(thread.control.idState, {
+                val: val,
+                ack: false
+            });
+            thread.enable = val;
+            adapter.log.info(`setValve ${ thread.name }: ${ val }, ${ thread.wateringTime > 0 && val === true ? `${ tools.addTime(thread.wateringTime,'') }, ` : '' }`);
+            return thread.control.idState;
+        } catch (error) {
+            thread.enable = false;
+            thread.state = 'Error'
+            throw new Error(`setValve ${thread.name} error: ${error}`);
+        }
+    }
 
     const startTime = new Date();
     let result = undefined;
+    let updateStr = '';
 
     thread.ac.acSetValveCancelTimeout = new AbortController;
     /**
@@ -98,58 +118,75 @@ const setValve = async (thread, val) => {
      * @param {{val:boolean,ack:boolean}} state 
      */
     thread.controller.ackTrue = (state) => {
-        if (typeof state.val === 'boolean'
-            && state.val === val
-            && state.ack === true
+        if (
+            (thread.control.maker === 'standard') && (state?.val === val)
+            || (thread.control.maker === 'HM') && (val ? state?.val === true : state?.val === false)
+            || (thread.control.maker === 'HmIP') && (val ? state?.val === 1 : state?.val === 0)
         ) {
             adapter.log.debug(`setValve ${thread.name} => ackTrue`);
-            result = thread.idState;
-            thread.enable = val;
+            result = thread.control.idState;
+            thread.enable === val ? updateStr = ' (update)' : thread.enable = val;
             thread.ac.acSetValveCancelTimeout.abort();
         } else {
-            adapter.log.warn(`setValve ${thread.name}  => ackTrue val = ${val} state: ${JSON.stringify(state)}`);
+            adapter.log.debug(`setValve ${thread.name}  => check ackTrue! 
+                if => maker ${ thread.control.maker } === 'standard' && ${state?.val} === ${val}
+                || ${thread.control.maker} === 'HM' && ${val} ? ${state?.val} === true : ${state?.val} === false
+                || ${thread.control.maker} === 'HmIP' && ${val} ? ${state?.val} === 1 : ${state?.val} === 0}
+            `);
         }
     };
     
     //adapter.log.info(`Set Valve (async () => {...}`);
     try {
         // Ventil ansteuern
-        const _setValve = await adapter.setForeignStateAsync(thread.idState, {
+        if (thread.control.idON_TIME !== null) {
+            await adapter.setForeignStateAsync(thread.control.idON_TIME, {
+                val: val ? Math.ceil(thread.wateringTime + 5) : 0,
+                ack: false
+            });
+            await asyncTime.setTimeout(200, undefined, undefined);
+        }
+        
+        const _setValve = await adapter.setForeignStateAsync(thread.control.idState, {
             val: val,
             ack: false
         });
-        if (_setValve === thread.idState) {     // Auftrag ausgeführt
-            await asyncTime.setTimeout(10000, undefined, { signal: thread.ac.acSetValveCancelTimeout.signal });
-            const _getValve = await adapter.getForeignStateAsync(thread.idState);
-            if (_getValve && typeof _getValve.val === 'boolean'
-                && _getValve.val === val
-                && _getValve.ack === true
+        if (_setValve === thread.control.idState) {     // Auftrag ausgeführt
+            await asyncTime.setTimeout(3000, undefined, { signal: thread.ac.acSetValveCancelTimeout.signal });  // max. 3s warten auf Rückmeldung ackTrue
+            const _getValve = await adapter.getForeignStateAsync(thread.control.idState);
+            if (_getValve?.val === val
             ) {
-                thread.enable = val;
-                return thread.idState;
+                thread.enable === val ? updateStr = ' (update)' : thread.enable = val;;
+                return thread.control.idState;
             } else {
-                adapter.log.debug(`setValve ${thread.name} _getValve: ${_getValve}`);
-                throw new Error(`setForeignState not responding (ack === false)`);
+                throw new Error(` > was not switched! (${val}) Check the device! Reply: ${JSON.stringify(_getValve)}`);
             }
         } else {
-            throw new Error(`set Valve was not switched`);
+            throw new Error(` command could not be sent`);
         }
     } catch (error) {
         // thread.controller.ackTrue wurde ausgelöst
         if (error.name !== `AbortError`) {
-            await adapter.setForeignStateAsync(thread.idState, {
+            await adapter.setForeignStateAsync(thread.control.idState, {
                 val: false,
                 ack: false
             });
             thread.enable = false;
+            thread.state = 'Error'
             if (adapter.config.notificationEnabled) {
-                sendMessageText.sendMessage(`setValve ${thread.name} (${thread.idState}) ${error}`);
+                sendMessageText.sendMessage(`setValve ${thread.name} (${thread.control.idState}) ${error}`);
             }
-            throw new Error(`set Valve (${thread.idState}) ${error}`);
+            throw new Error(` > set Valve ${error}`);
         }
     } finally {
+        adapter.log.info(`setValve ${thread.name}: 
+            ${val}, 
+            ${thread.control.maker !== 'standard' ? `${thread.control.maker}, ` : ''}
+            ${ (thread.wateringTime > 0 && val === true && thread.name !== 'Cistern pump' && thread.name !== 'Main pump' && thread.name !== '24V')
+            ? `${ tools.addTime(thread.wateringTime,'') }${ updateStr }, ` : ''}
+            processing time: ${(+new Date()) - +startTime}ms
+        `);
         if (thread.ac.acSetValveCancelTimeout.aborted === false) thread.ac.acSetValveCancelTimeout.abort();
-        adapter.log.info(`setValve ${thread.name}: ${val}, ${thread.wateringTime > 0 && val === true ? `${ addTime(thread.wateringTime,'') }, ` : ''}processing time: ${(+new Date()) - +startTime}ms`);
     }
     adapter.setStateAsync(`sprinkle.${thread.name}.sprinklerState`, {
         val: thread.state,
@@ -221,6 +258,7 @@ const currentConsumption = async (write) => {
                 if (entry.state === 'wait') pumpRequired = true;   // state => wait
                 if (entry.enable === true
                     && entry.extBreak === false
+                    && timeBasedRestrictionEn === false
                 ) {
                     curFlow -= entry.pipeFlow;	// // ermitteln der RestFörderkapazität
                     parallel ++;	// Anzahl der Bewässerungsstellen um 1 erhöhen
@@ -228,7 +266,7 @@ const currentConsumption = async (write) => {
                 }
             }
         }
-
+        // bei write schreiben der aktuellen Förderleistung der Pumpe und der Anzahl der parallelen Stränge
         if (write || currentPumpUse.intBreak) {
             adapter.setStateAsync('control.parallelOfMax', {
                 val: `${parallel} : ${maxParallel}`,
@@ -291,7 +329,9 @@ const countSprinkleTime = async (entry) => {
     try {
         /* --- function beenden wenn ---*/
         if ((boostOn && !(myConfig.config[entry.sprinkleID].booster)    // boost-On && kein aktuelles Boost-Ventil
-            || entry.extBreak)                                          // extBreak aktive
+            || entry.extBreak === true                                  // extBreak aktive
+            || timeBasedRestrictionEn === true                            // zeitliche Bewässerungsbeschränkung aktiv
+        )                                          
         ) {
             return;
         }
@@ -304,7 +344,7 @@ const countSprinkleTime = async (entry) => {
                 || (myConfig.config[entry.sprinkleID].calculation.val < myConfig.config[entry.sprinkleID].calculation.maxIrrigation))		// Bodenfeuchte noch nicht erreicht? (z.B. beim Regen)
         ) {     /* Zeit läuft */
             adapter.setStateAsync(`sprinkle.${entry.name}.countdown`, {
-                val: addTime(entry.wateringTime - entry.count, ''),
+                val: tools.addTime(entry.wateringTime - entry.count, ''),
                 ack: true
             });
 
@@ -319,7 +359,7 @@ const countSprinkleTime = async (entry) => {
             if ((entry.onOffTimeOff > 0) && !(entry.count % entry.onOffTimeOn)) {
                 adapter.log.info(`Intervall-Beregnung, timeOn: ${entry.onOffTimeOn}s, count: ${entry.count}s, timeOff: ${entry.onOffTimeOff}s, count % onOffTime: ${entry.count % entry.onOffTimeOn}`);
                 const _setValveOnOff = await setValve(entry, false);
-                if (_setValveOnOff === entry.idState) {
+                if (_setValveOnOff === entry.control.idState) {
                     entry.myBreak = true;
                     /* Zustand des Ventils im Thread <<< 3 = Pause >>> (0:off; 1:wait; 2:on; 3:break; 4:Boost(on); 5:off(Boost); 6:Cistern empty; 7:extBreak) */
                     entry.state = 'break';
@@ -464,16 +504,28 @@ const updateList = async () => {
                 0;
     }
 
-    // ermitteln von curPipe und der Anzahl der parallelen Stränge
+    // ermitteln der maximalen Laufzeit aller Ventile in der threadList
+    const sumOfWateringTime = Math.ceil(threadList.reduce(
+        (sum, entry) => sum + entry.wateringTime + (switchingDistanceMS / 1000), (currentPumpUse.leadTime + switchingDistanceMS) / 1000));
+
+    // Anpassung ON_Time wenn Laufzeit zu kurz
+    const adjustment = sumOfWateringTime > controlVoltage.wateringTime   
+        && adapter.config.switchingBehavior === 'homematic' 
+        ? true 
+        : false;
+
     consumption = await currentConsumption(true);
     if (consumption.pumpRequired === true) {    // Pumpe erforderlich
 
         // Spannungsversorgung einschalten bei Leistungsanforderung
         try {
             if (adapter.config.triggerControlVoltage
-            && controlVoltage.enable === false) {
+            && controlVoltage.enable === false
+            || adjustment === true
+            ) {
+                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);
-                if (_controlVoltage === controlVoltage.idState) {
+                if (_controlVoltage === controlVoltage.control.idState) {
                     adapter.setStateAsync(`info.supplyVoltage`, {
                         val: controlVoltage.enable, 
                         ack: true
@@ -482,15 +534,18 @@ const updateList = async () => {
                 }
             }                    
         } catch (error) {
-            adapter.log.error(`Error trigger Control Voltage [${controlVoltage.idState}]: ${error}`);
+            adapter.log.error(`Error trigger Control Voltage [${controlVoltage.control.idState}]: ${error}`);
         }
            
         // Pumpe einschalten bei Leistungsanforderung
         try {
             if (adapter.config.pumpSelection !== 'noPump'
-            && currentPumpUse.enable === false) {                
+            && currentPumpUse.enable === false
+            || adjustment === true
+            ) {
+                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);
-                if (_currentPumpUse && _currentPumpUse === currentPumpUse.idState) {
+                if (_currentPumpUse && _currentPumpUse === currentPumpUse.control.idState) {
                     timerOn = false;
                     adapter.setStateAsync(currentPumpUse.id, {
                         val: currentPumpUse.enable, 
@@ -500,7 +555,7 @@ const updateList = async () => {
                 }
             }                   
         } catch (error) {
-            adapter.log.error(`Error trigger current Pump [${currentPumpUse.idState}]: ${error}`);
+            adapter.log.error(`Error trigger current Pump [${currentPumpUse.control.idState}]: ${error}`);
         }
     }
 
@@ -518,7 +573,7 @@ const updateList = async () => {
                 ) {
                     entry.state = 'wait';   //1
                     const _setValve2 = await setValve(entry, false);
-                    if (_setValve2 === entry.idState) {
+                    if (_setValve2 === entry.control.idState) {
                         consumption = await currentConsumption(true);
                         clearInterval(entry.countdown); // Zähler für Countdown, Verbrauchsmengen, usw. löschen
                         entry.countdown = null;
@@ -536,7 +591,7 @@ const updateList = async () => {
         }
     }
 
-    adapter.log.info(`curFlow: ${consumption.curFlow}, parallel: ${consumption.parallel}`);
+    adapter.log.debug(`curFlow: ${consumption.curFlow}, parallel: ${consumption.parallel}`);
     // absteigend sortieren nach der Verbrauchsmenge
     threadList.sort(mySortDescending);
 
@@ -547,6 +602,7 @@ const updateList = async () => {
             && !entry.killSprinkle                                              // && Aufgabe noch nicht erledigt
             && !entry.myBreak                                                   // && nicht in der Pause Interval-Beregnung
             && !entry.extBreak                                                  // && nicht in der externen Pause (extBreak)
+            && !timeBasedRestrictionEn                                            // && nicht in der zeitlichen Bewässerungsbeschränkung
             && (consumption.curFlow >= entry.pipeFlow)                          // && noch genügend Förderleistung der Pumpe
             && (consumption.parallel < maxParallel)                             // && maxParallel noch nicht erreicht
             && !boostOn                                                         // && Ventile nur einschalten, wenn kein Boost aktive 
@@ -557,7 +613,7 @@ const updateList = async () => {
                 timerOn === true ? await asyncTime.setTimeout(switchingDistanceMS, undefined, {signal: entry.ac.acUpdateListOn.signal}) : timerOn = true;
                 entry.state = myConfig.config[entry.sprinkleID].booster ? 'boost(on)' : 'on';    // state 4 => boost(on) : 2 => on
                 const _setValve3 = await setValve(entry, true);
-                if (_setValve3 === entry.idState) {
+                if (_setValve3 === entry.control.idState) {
                     consumption = await currentConsumption(true);
                     if (myConfig.config[entry.sprinkleID].booster) {
                         boostReady = false;
@@ -577,6 +633,7 @@ const updateList = async () => {
                     }                                    
                 } else {
                     entry.ac.acUpdateListOn.abort();
+                    entry.killSprinkle = true;
                 }
             }
         } catch (error) {   //Fehler beim Einschalten der Bewässerungsventile
@@ -595,7 +652,7 @@ const updateList = async () => {
                 ){
                     entry.state = 'off(Boost)';    //state => 5/off(boost)
                     const _setValve4 = await setValve(entry, false);
-                    if (_setValve4 === entry.idState){
+                    if (_setValve4 === entry.control.idState){
                         consumption = await currentConsumption(true);
                         clearInterval(entry.countdown);
                         entry.countdown = null;
@@ -617,7 +674,7 @@ const updateList = async () => {
         if (currentPumpUse.enable === true) {
             try {
                 const _currentPumpUse = await setValve(currentPumpUse, false);
-                if (_currentPumpUse === currentPumpUse.idState) {
+                if (_currentPumpUse === currentPumpUse.control.idState) {
                     adapter.setStateAsync(currentPumpUse.id,{
                         val: currentPumpUse.enable, 
                         ack: true
@@ -633,7 +690,7 @@ const updateList = async () => {
         if(controlVoltage.enable === true) {
             try {
                 const _controlVoltage = await setValve(controlVoltage, false);
-                if (_controlVoltage === controlVoltage.idState) {
+                if (_controlVoltage === controlVoltage.control.idState) {
                     adapter.setStateAsync(`info.supplyVoltage`, {
                         val: controlVoltage.enable, 
                         ack: true
@@ -642,7 +699,7 @@ const updateList = async () => {
 
                 }                
             } catch (error) {
-                adapter.log.error(`Error trigger Control Voltage [${controlVoltage.idState}]: ${error}`);
+                adapter.log.error(`Error trigger Control Voltage [${controlVoltage.control.idState}]: ${error}`);
             }       
         }
     }
@@ -742,7 +799,7 @@ const setActualPump = async () => {
                     if ((fillLevelCistern < parseFloat(adapter.config.triggerMinCisternLevel)) && (currentPumpUse.pumpCistern === true)) {
                     /* (Zisterne unter Minimum) && (ZisternenPumpe läuft) */
                         const _setValveCisternPumpOff = await setValve(currentPumpUse, false);  // Pumpe Zisterne Aus
-                        if (_setValveCisternPumpOff === currentPumpUse.idState) {
+                        if (_setValveCisternPumpOff === currentPumpUse.control.idState) {
                             await adapter.setStateAsync(currentPumpUse.id, {      // set State cisternPump === false
                                 val: currentPumpUse.enable, 
                                 ack: true
@@ -750,7 +807,7 @@ const setActualPump = async () => {
                         }
                         currentPumpUse.pumpCistern = false;
                         currentPumpUse.name = 'Main pump';
-                        currentPumpUse.idState = adapter.config.triggerMainPump || '';
+                        currentPumpUse.control  = { ...mainPumpControl };
                         currentPumpUse.id = 'info.mainPump';
                         currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower);
                         /* Hauptpumpe Ein */
@@ -778,7 +835,7 @@ const setActualPump = async () => {
                         currentPumpUse.pumpCistern = true;
                         currentPumpUse.name = 'Cistern pump';
                         currentPumpUse.id = 'info.cisternPump';
-                        currentPumpUse.idState = adapter.config.triggerCisternPump || '';
+                        currentPumpUse.control = { ...cisternPumpControl };
                         currentPumpUse.pumpPower = parseInt(adapter.config.triggerCisternPumpPower);
 
                     } else {
@@ -789,7 +846,7 @@ const setActualPump = async () => {
                         currentPumpUse.pumpCistern = false;
                         currentPumpUse.name = 'Main pump';
                         currentPumpUse.id = 'info.mainPump';
-                        currentPumpUse.idState = adapter.config.triggerMainPump || '';
+                        currentPumpUse.control = { ...mainPumpControl };
                         currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower);
                     }
                     adapter.setState('control.restFlow', {
@@ -829,10 +886,10 @@ function addConsumedAndTime(entry) {
         ack: true
     });
     adapter.setState(`sprinkle.${entry.name}.history.lastRunningTime`, {
-        val: addTime(entry.count, ''),
+        val: tools.addTime(entry.count, ''),
         ack: true
     });
-    const _formatTime = formatTime(entry.startTime);
+    const _formatTime = tools.formatTime(entry.startTime);
     adapter.setState(`sprinkle.${entry.name}.history.lastOn`, {
         val: _formatTime.dayTime,
         ack: true
@@ -848,7 +905,7 @@ function addConsumedAndTime(entry) {
     adapter.getState(`sprinkle.${entry.name}.history.curCalWeekRunningTime`, (err, state) => {
         if (state && state.val) {
             adapter.setState(`sprinkle.${entry.name}.history.curCalWeekRunningTime`, {
-                val: addTime(+state.val, entry.count),
+                val: tools.addTime(+state.val, entry.count),
                 ack: true
             });
         }
@@ -883,9 +940,13 @@ const valveControl = {
                         : (+adapter.config.switchingDistance)
                 );
             adapter.log.info(`switchingDistanceMS: ${switchingDistanceMS}ms`);
+
             /* Object supplyVoltage (VersorgungsSpannung) anlegen */
             if (adapter.config.triggerControlVoltage.length > 5) {
-                controlVoltage.idState = adapter.config.triggerControlVoltage; // Schaltaktor zuweisen
+
+                controlVoltage.control = await tools.idStateControl(adapter, adapter.config.triggerControlVoltage);
+                if (controlVoltage?.control?.idACK) adapter.subscribeForeignStates(controlVoltage.control.idACK);
+
                 await adapter.setObjectNotExistsAsync(`info.supplyVoltage`, {
                     type: 'state',
                     common: {
@@ -977,11 +1038,12 @@ const valveControl = {
             };
 
             switch (adapter.config.pumpSelection) {
+
                 case 'noPump': {
                     currentPumpUse.pumpCistern = false;
                     currentPumpUse.name = 'no pump';
                     currentPumpUse.intBreak = false;
-                    currentPumpUse.idState = '';
+                    currentPumpUse.control.idState = '';
                     currentPumpUse.id = '';
                     currentPumpUse.leadTime = 0;
                     currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower) || 0;
@@ -992,11 +1054,14 @@ const valveControl = {
                     if (_cisternPump) await adapter.delObjectAsync(`info.cisternPump`);
                     break;
                 }
+
                 case 'mainPump': {
+                    mainPumpControl = await tools.idStateControl(adapter, adapter.config.triggerMainPump);
+                    currentPumpUse.control = mainPumpControl;
+                    if (currentPumpUse?.control?.idACK) adapter.subscribeForeignStates(currentPumpUse.control.idACK);
                     currentPumpUse.pumpCistern = false;
                     currentPumpUse.name = 'Main pump';
                     currentPumpUse.intBreak = false;
-                    currentPumpUse.idState = adapter.config.triggerMainPump || '';
                     currentPumpUse.id = 'info.mainPump';
                     currentPumpUse.leadTime = (parseInt(adapter.config.mainPumpLeadTime) || 5) * 1000;
                     currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower) || 0;
@@ -1007,6 +1072,7 @@ const valveControl = {
                     if (_cisternPump) await adapter.delObjectAsync(`info.cisternPump`);
                     break;
                 }
+
                 case 'cistern': {
                     /*     Füllstand der Zisterne in % holen     */
                     const _actualValueLevel = await adapter.getForeignStateAsync(adapter.config.actualValueLevel);
@@ -1030,9 +1096,12 @@ const valveControl = {
                         fillLevelCistern = 0;
                         currentPumpUse.intBreak = true;
                     }
+
+                    cisternPumpControl = await tools.idStateControl(adapter, adapter.config.triggerCisternPump);
+                    currentPumpUse.control = cisternPumpControl;
+                    if (currentPumpUse?.control?.idACK) adapter.subscribeForeignStates(currentPumpUse.control.idACK);
                     currentPumpUse.pumpCistern = false;
                     currentPumpUse.name = 'Cistern pump';
-                    currentPumpUse.idState = adapter.config.triggerCisternPump || '';
                     currentPumpUse.id = 'info.cisternPump';
                     currentPumpUse.leadTime = (parseInt(adapter.config.cisternPumpLeadTime) || 5) * 1000;
                     currentPumpUse.pumpPower = parseInt(adapter.config.triggerCisternPumpPower) || 0;
@@ -1043,8 +1112,13 @@ const valveControl = {
                     if (_mainPump) await adapter.delObjectAsync(`info.mainPump`);
                     break;
                 }
+                
                 case 'pumpAndCistern': {
                     currentPumpUse.enable = false;
+                    mainPumpControl = await tools.idStateControl(adapter, adapter.config.triggerMainPump);
+                    cisternPumpControl = await tools.idStateControl(adapter, adapter.config.triggerCisternPump);
+                    if (mainPumpControl?.idACK) adapter.subscribeForeignStates(mainPumpControl.idACK);
+                    if (cisternPumpControl?.idACK) adapter.subscribeForeignStates(cisternPumpControl.idACK);
                     if (adapter.config.actualValueLevel) {
                         /*     Füllstand der Zisterne in % holen     */
                         const _actualValueLevel = await adapter.getForeignStateAsync(adapter.config.actualValueLevel);
@@ -1058,19 +1132,21 @@ const valveControl = {
                                 adapter.log.warn(`level sensor in the cistern => Wrong value: ${_actualValueLevel.val}, Type: ${typeof _actualValueLevel.val}`);
                             }
                         }
-
+                        
                         if (fillLevelCistern > parseInt(adapter.config.triggerMinCisternLevel)) {
+                            /*     Zisterne voll     */
                             currentPumpUse.pumpCistern = true;
                             currentPumpUse.name = 'Cistern pump';
-                            currentPumpUse.idState = adapter.config.triggerCisternPump || '';
+                            currentPumpUse.control = { ...cisternPumpControl };
                             currentPumpUse.id = 'info.cisternPump';
                             currentPumpUse.leadTime = (parseInt(adapter.config.cisternPumpLeadTime) || 5) * 1000;
                             currentPumpUse.pumpPower = parseInt(adapter.config.triggerCisternPumpPower) || 0;
                             currentPumpUse.restFlow = parseInt(adapter.config.triggerCisternPumpPower) || 0;
                         } else {
+                            /*     Zisterne leer     */
                             currentPumpUse.pumpCistern = false;
                             currentPumpUse.name = 'Main pump';
-                            currentPumpUse.idState = adapter.config.triggerMainPump || '';
+                            currentPumpUse.control = { ...mainPumpControl };
                             currentPumpUse.id = 'info.mainPump';
                             currentPumpUse.leadTime = (parseInt(adapter.config.mainPumpLeadTime) || 5) * 1000;
                             currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower) || 0;
@@ -1106,29 +1182,31 @@ const valveControl = {
             /* Pumpe ausschalter, wenn vorhanden */
             if (adapter.config.triggerMainPump !== '') {
                 const _triggerMainPump = await adapter.getStateAsync('adapter.config.triggerMainPump');
-                if (_triggerMainPump && _triggerMainPump.val && _triggerMainPump.val === true) {
-                    adapter.setStateAsync(adapter.config.triggerMainPump, {
+                if (_triggerMainPump?.val === true) {
+                    await adapter.setStateAsync(adapter.config.triggerMainPump, {
                         val: false,
                         ack: false
                     });
-                    adapter.setStateAsync('info.mainPump', {
+                    await adapter.setStateAsync('info.mainPump', {
                         val:false, 
                         ack:false
                     });
+                    await asyncTime.setTimeout(100, undefined, undefined); // kurze Wartezeit, damit die Hauptpumpe sicher ausschalten kann
                 }
             }
             /* Pumpe (Zisterne) ausschalter, wenn vorhanden */
             if (adapter.config.triggerCisternPump !== '') {
                 const _triggerCisternPump = await adapter.getStateAsync('adapter.config.triggerCisternPump');
-                if (_triggerCisternPump && _triggerCisternPump.val && _triggerCisternPump.val === true) {
-                    adapter.setState(adapter.config.triggerCisternPump, {
+                if (_triggerCisternPump?.val === true) {
+                    await adapter.setStateAsync(adapter.config.triggerCisternPump, {
                         val: false,
                         ack: false
                     });
-                    adapter.setStateAsync('info.cisternPump', {
+                    await adapter.setStateAsync('info.cisternPump', {
                         val:false, 
                         ack:false
                     });
+                    await asyncTime.setTimeout(100, undefined, undefined); // kurze Wartezeit, damit die Zisterne sicher ausschalten kann
                 }
             }
             /* alle Ventile (.name = "hm-rpc.0.MEQ1234567.3.STATE") in einem definierten Zustand (false) versetzen*/
@@ -1148,6 +1226,7 @@ const valveControl = {
                             val: false,
                             ack: false
                         });
+                        await asyncTime.setTimeout(100, undefined, undefined); // kurze Wartezeit, damit die Ventile sicher ausschalten können
                     }
                     /*Kontrolle Flow Pumpe > Flow Ventil*/
                     if (testMaxFlow < parseInt(res.pipeFlow)) {
@@ -1172,6 +1251,7 @@ const valveControl = {
      */
     addList: async function (sprinkleList) {
         try {
+            // kontrolle bei ausgeschalteter Pumpe, ob die Zisterne zur Bewässerung genutzt werden kann
             if (adapter.config.pumpSelection === 'pumpAndCistern'
                 && currentPumpUse.enable === false
                 && fillLevelCistern > parseFloat(adapter.config.triggerMinCisternLevel)
@@ -1193,14 +1273,24 @@ const valveControl = {
                             if (entry.wateringTime === res.wateringTime) {
                                 return;
                             }
-                            entry.wateringTime = res.wateringTime;
+                            // wenn der Sprenger aktiv ist und die Bewässerungszeit verlängert werden muss
+                            if (entry.enable === true
+                                && adapter.config.switchingBehavior === 'homematic'
+                                && entry.wateringTime < res.wateringTime
+                            ) {
+                                entry.wateringTime = res.wateringTime;
+                                const _setValve2 = await setValve(entry, true);
+                                if (_setValve2 !== entry.control.idState) throw new Error(`update ID: ${entry.name} => An error occurred while updating the irrigation time for Homematic devices. Please check the connection to the device and the configuration of the switching behavior.`);
+                            } else {
+                                entry.wateringTime = res.wateringTime;
+                                adapter.log.debug(`update ID: ${entry.name} new time: ${tools.addTime(res.wateringTime, '')}`);
+                            }
                             entry.autoOn = res.auto; // auto: = true autostart; = false Handbetrieb
                             await adapter.setStateAsync(`sprinkle.${name}.runningTime`, {
-                                val: addTime(res.wateringTime, ''),
+                                val: tools.addTime(res.wateringTime, ''),
                                 ack: true
                             });
                             addDone = true; // Sprinkle found
-                            adapter.log.debug(`update ID: ${entry.name} new time: ${addTime(res.wateringTime, '')}`);
                             break;
                         }
                     }
@@ -1214,10 +1304,11 @@ const valveControl = {
                         });
                         return;
                     }
+
                     const newThread = {};
                         newThread.sprinkleID = res.sprinkleID; // Array[0...] 
-                        newThread.name = name; // z.B "Blumenbeet" 
-                        newThread.idState = myConfig.config[res.sprinkleID].idState; // z.B. "hm-rpc.0.MEQ1810129.1.STATE" 
+                        newThread.name = name; // z.B "Blumenbeet"
+                        newThread.control = { ...myConfig.config[res.sprinkleID].control }; // {idState:, idON_TIME:, idACK:, maker:}  
                         newThread.wateringTime = res.wateringTime; // Bewässerungszeit 
                         newThread.pipeFlow = myConfig.config[res.sprinkleID].pipeFlow; // Wasserverbrauch 
                         newThread.count = 0; // Zähler im Sekundentakt 
@@ -1229,7 +1320,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 Pause 
+                        newThread.myBreak = false; // meine interne Pause 
                         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 
@@ -1241,15 +1332,16 @@ const valveControl = {
                         newThread.id = threadList.length || 0;
                     threadList.push(newThread);
                     /* Zustand des Ventils im Thread < 0 > off, <<< 1 >>> wait, < 2 > on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost), < 6 > Cistern empty, < 7 > extBreak */
-                    newThread.extBreak ? (newThread.state = 'extBreak') : (newThread.state = 'wait');
+                    newThread.extBreak ? (newThread.state = 'extBreak') : timeBasedRestrictionEn === true ? (newThread.state = 'Irrigation ban') : (newThread.state = 'wait');
                     adapter.setState(`sprinkle.${name}.sprinklerState`, {
                         val: newThread.state,
                         ack: true
                     });
                     adapter.setState(`sprinkle.${name}.runningTime`, {
-                        val: addTime(res.wateringTime, ''),
+                        val: tools.addTime(res.wateringTime, ''),
                         ack: true
                     });
+                    
                     adapter.log.debug(`ID: ${name} new order created: ${JSON.stringify(threadList[newThread.id])}`);
                 }
             }
@@ -1260,6 +1352,57 @@ const valveControl = {
 
     }, // End addList
 
+    timeBasedRestriction: async function (enable) {         //Irrigation ban => zeitliche Bewässerungsbeschränkung noch zu bearbeiten ! ! !
+        try {            
+            timeBasedRestrictionEn = enable;
+            if (threadList) {
+                if (timeBasedRestrictionEn === true) {      // zeitliche Bewässerungsbeschränkung aktiv
+                    for await (const entry of threadList) {
+                        if (entry.enable === true) {            // Ventil ist aktiv, dann Ventil ausschalten
+                            const _setValve = await setValve(entry, false);
+                            if (_setValve === entry.control.idState) {
+                                entry.state = 'Irrigation ban';
+                                clearInterval(entry.countdown);                // Timer Countdown löschen
+                                entry.countdown = null;
+                                /* Booster zurücksetzen falls aktiv*/
+                                if (myConfig.config[entry.sprinkleID].booster) {
+                                    entry.ac.acBoostOnTimer.abort(entry.extBreak);
+                                    boostReady = true;
+                                    boostOn = false;
+                                    adapter.log.debug(`ID: ${entry.name} UpdateList Sprinkle Off: boostReady = ${boostReady}`);
+                                }
+                            } else {
+                                if(!sendMessageText.onlySendError()){
+                                    sendMessageText.sendMessage(`The valve, ${entry.name}, could not be deactivated. Please turn it off manually.`);
+                                }
+                                adapter.log.warn(`The valve, ${entry.name}, could not be deactivated. Please turn it off manually.`);
+                                entry.state = 'undefined';
+                            }
+                        } else {
+                            entry.state = 'Irrigation ban';
+                        }
+                        adapter.setStateAsync(`sprinkle.${entry.name}.sprinklerState`, {
+                            val: entry.state,
+                            ack: true
+                        });
+                    }
+                } else {
+                    for await (const entry of threadList) {     // zeitliche Bewässerungsbeschränkung beendet
+                        entry.state = (entry.extBreak === true) ? 'extBreak' : 'wait';
+                        adapter.setStateAsync(`sprinkle.${entry.name}.sprinklerState`, {
+                            val: entry.state,
+                            ack: true
+                        });
+                    }
+                }
+            }
+            updateList();
+            return true;
+        } catch (error) {
+            adapter.log.warn(`TimeBasedRestriction: ${error}`);
+            return false;
+        }
+    },
     /**
      * extBreak => Spränger unterbrechen bei extBreak
      * 
@@ -1269,7 +1412,7 @@ const valveControl = {
      */
     extBreak: async function (sprinkleID, extBreak) {
         try {
-            const _found = await findAsync(threadList, async (d) => {
+            const _found = await tools.findAsync(threadList, async (d) => {
                                 return Promise.resolve (d.sprinkleID === sprinkleID);
                             });
 
@@ -1278,7 +1421,7 @@ const valveControl = {
                 if (extBreak === true) {    // extBreak aktiv
                     if (_found.enable === true) {                           // Ventil ist eingeschaltet
                         const _setValve = await setValve(_found, false);
-                        if (_setValve === _found.idState) {
+                        if (_setValve === _found.control.idState) {
                             _found.state = 'extBreak';                      // <<< 7 >>> extBreak
                             clearInterval(_found.countdown);                // Timer Countdown löschen
                             _found.countdown = null;
@@ -1304,13 +1447,22 @@ const valveControl = {
                 });
                 adapter.log.debug(`valveControl.extBreak: ${extBreak}, Name: ${_found.name}, ID: ${_found.sprinkleID}`);   // löschen
                 updateList();
-                return {val: true};
+                return {
+                    name: _found.name,
+                    val: true
+                };
             } else {
-                return {val: false};
+                return {
+                    name: null,
+                    val: false
+                };
             }
         } catch (error) {
             adapter.log.warn(`valveControl.extBreak(${sprinkleID}, ${extBreak}) => ${error}`);
-            return {val: false};
+            return {
+                name: null,
+                val: false
+            };
         }
     },
 
@@ -1352,12 +1504,12 @@ const valveControl = {
                 clearInterval(entry.countdown);
                 entry.countdown = null;
                 /* Timer abbrechen */
-                if (entry.ac.acSetValveCancelTimeout.aborted === false) entry.ac.acSetValveCancelTimeout.abort();   // setValve
-                if (entry.ac.acBoostOnTimer.aborted === false) entry.ac.acBoostOnTimer.abort();            // BoostOnTimer
-                if (entry.ac.acUpdateListPuOff.aborted === false) entry.ac.acUpdateListPuOff.abort();         // UpdateList Pumpe aus (Leistung zu gering beim Pumpenwechsel)
-                if (entry.ac.acUpdateListOn.aborted === false) entry.ac.acUpdateListOn.abort();            // UpdateList Ventile ein
-                if (entry.ac.acUpdateListBoostOn.aborted === false) entry.ac.acUpdateListBoostOn.abort();       // UpdateList Ausschalten der Ventile bei BoostOn
-                if (entry.ac.acOnOffTimeoutOff.aborted === false) entry.ac.acOnOffTimeoutOff.abort();         // OnOffTimeoutOff Ausschaltdauer bei on-off-Betrieb
+                if (entry?.ac?.acSetValveCancelTimeout?.aborted === false) entry.ac.acSetValveCancelTimeout.abort();   // setValve
+                if (entry?.ac?.acBoostOnTimer?.aborted === false) entry.ac.acBoostOnTimer.abort();            // BoostOnTimer
+                if (entry?.ac?.acUpdateListPuOff?.aborted === false) entry.ac.acUpdateListPuOff.abort();         // UpdateList Pumpe aus (Leistung zu gering beim Pumpenwechsel)
+                if (entry?.ac?.acUpdateListOn?.aborted === false) entry.ac.acUpdateListOn.abort();            // UpdateList Ventile ein
+                if (entry?.ac?.acUpdateListBoostOn?.aborted === false) entry.ac.acUpdateListBoostOn.abort();       // UpdateList Ausschalten der Ventile bei BoostOn
+                if (entry?.ac?.acOnOffTimeoutOff?.aborted === false) entry.ac.acOnOffTimeoutOff.abort();         // OnOffTimeoutOff Ausschaltdauer bei on-off-Betrieb
 
                 adapter.log.debug(`order deleted Stop all ID: ${entry.name} ( rest orders: ${threadList.length} )`);
                 threadList.pop();   // del last array