iobroker.sprinklecontrol 0.2.19 → 1.0.0

package/lib/valveControl.js

@@ -1,978 +1,1414 @@
-'use strict';
-
-const myConfig = require('./myConfig.js');
-const addTime = require('./tools.js').addTime;
-const formatTime = require('./tools').formatTime;
-const sendMessageText = require('./sendMessageText.js');            // sendMessageText
-
-/**
- * The adapter instance
- */
-let adapter;
-
-/**
- * Thread-list
- * → Auflistung aller aktiver Sprenger-Kreise
- */
-const threadList = [];
-
-/** bereit für Boost */
-let boostReady = true;
-/** Boost ist aktive */
-let boostOn = false;
-/** Timer für die Länge des */
-let boostListTimer;
-/** maximal zulässige Anzahl der eingeschalteten Ventile */
-let maxParallel = 0;
-/** Füllstand der Zisterne */
-let fillLevelCistern = 0;
-let statusCistern = '';
-/** Speicherort von setTimeout */
-let idValveDelayTime;
-
-const currentPumpUse = {
-    /** Pumpen aktive? */
-    enable: false,
-    /** Zisterne aktive? */
-    pumpCistern: false,
-    /** Pumpen-Bezeichnung; z.B. "hm-rpc.0.MEQ1810129.1.STATE" */
-    pumpName: '',
-    /** Pumpenleistung in l/h */
-    pumpPower: 0
-};
-
-const updateListMarker = {funcActive: false, newStart: false};
-
-/*==============================================================================================================================================*/
-/*                                                            interne Funktionen                                                                */
-/*----------------------------------------------------------------------------------------------------------------------------------------------*/
-
-/**
- * Sprinkle (sprinkleName) delete
- * → Ventil (sprinkleName) löschen
- *
- * @param killList - sprinkleName der zu löschenden Objekte
- */
-function delList (killList) {
-    for(const sprinkleName of killList) {
-        let bValveFound = false;	// Ventil gefunden
-        for(let counter = 0,                                  // Loop über das Array
-            lastArray = (threadList.length - 1);     // entsprechend der Anzahl der Eintragungen
-            counter <= lastArray;
-            counter++) {
-            const entry = threadList[counter].sprinkleName;
-            if ((sprinkleName === entry) || bValveFound) {
-                if (sprinkleName === entry) bValveFound = true;
-                if (counter !== lastArray) threadList[counter] = threadList[counter + 1];
-            }
-        }
-        /* If a valve is found, delete the last array (entry). Wenn Ventil gefunden letzten Array (Auftrag) löschen */
-        if (bValveFound) {
-            threadList.pop();
-            adapter.log.debug(`delList=> order deleted ID: ${sprinkleName} ( rest orders: ${threadList.length} )`);
-        }
-    }
-
-} // End delList
-
-/*----------------------------------------------------------------------------------------------------------------------------------------------*/
-
-/**
- * Activation of the booster (all other active valves are deactivated for the duration of the boost so that the sprinkler can be extended with the maximum possible pressure)
- * => aktivierung des Boosters (alle anderen aktiven Ventile werden für die Zeit des Boosts deaktiviert um den maximalen möglichen Druck zum Ausfahren der Sprenger zu ermöglichen)
- *
- * @param sprinkleID
- */
-function boostList (sprinkleID) {
-    boostReady = false;
-    boostOn = true;
-    for(const entry of threadList) {
-        if (entry.enabled) {
-            if (entry.sprinkleID === sprinkleID) {      // Booster
-                /* Zustand des Ventils im Thread < 0 > off, < 1 > wait, < 2 > on, < 3 > break, <<< 4 >>> Boost(on), < 5 > off(Boost) */
-                adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                    val: 4,
-                    ack: true
-                });
-                //valveState(entry, 'Boost(on)');
-                entry.times.boostTime2 = setTimeout(() => {
-                    /* Zustand des Ventils im Thread < 0 > off, < 1 > wait, <<< 2 >>> on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
-                    adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                        val: 2,
-                        ack: true
-                    });
-                    entry.times.boostTime2 = null;
-                },31000);
-            } else {    // rest der Ventile
-                // in die Zwangspause (myBreak = true)
-                entry.times.boostTime1 = setTimeout(() => {
-                    /* Zustand des Ventils im Thread < 0 > off, < 1 > wait, < 2 > on, < 3 > break, < 4 > Boost(on), <<< 5 >>> off(Boost) */
-                    adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                        val: 5,
-                        ack: true
-                    });
-                    entry.myBreak = true;
-                    // valveOnOff(entry, false, '#2.1 Set: off(Boost), ID: ');
-                    entry.times.boostTime1 = null;
-                },250);
-                // aus der Zwangspause holen (myBreak = false)
-                entry.times.boostTime2 = setTimeout(() => {
-                    /* Zustand des Ventils im Thread < 0 > off, < 1 > wait, <<< 2 >>> on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
-                    adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                        val: 2,
-                        ack: true
-                    });
-                    // valveOnOff(entry, true, '#2.2 Set: on, ID: ');
-                    entry.myBreak = false;
-                    entry.times.boostTime2 = null;
-                },31000);
-            }
-        }
-    }
-    boostListTimer = setTimeout(() => {
-        boostOn = false;
-        updateList();
-    },32000);
-} // End boostList
-
-/*----------------------------------------------------------------------------------------------------------------------------------------------*/
-
-/**
- * If boostOn is ended by entering "runningTime = 0", normal operation should be restored. (Delete timer)
- * → Wenn boostOn über die Eingabe "runningTime = 0" beendet wird, so soll zum Normalen ablauf wieder zurückgekehrt werden. (Löschen der Timer)
- *
- * @param sprinkleID
- */
-function boostKill (sprinkleID) {
-    for(const entry of threadList) {
-        if (entry.enabled) {
-            if (entry.sprinkleID === sprinkleID) {
-                /* booster wird gekillt */
-                boostOn = false;
-                if(entry.times.boostTime2) {
-                    clearTimeout(entry.times.boostTime2);
-                    entry.times.boostTime2 = null;
-                }
-            } else {
-                /* normaler weiterbetrieb für den Rest */
-                if (entry.times.boostTime1) {
-                    clearTimeout(entry.times.boostTime1);
-                    entry.times.boostTime1 = null;
-                    adapter.log.debug(`boostKill => ID: ${entry.sprinkleName} => boostTime2 (Ende) gelöscht)`);
-                }
-                if (entry.times.boostTime2) {
-                    clearTimeout(entry.times.boostTime2);
-                    entry.times.boostTime2 = null;
-                    /* Zustand des Ventils im Thread < 0 > off, < 1 > wait, <<< 2 >>> on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
-                    adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                        val: 2,
-                        ack: true
-                    });
-                    // valveOnOff(entry, true, '#2.3 Set: on, ID: ');
-                }
-            }
-        }
-    }
-} // End boostKill
-
-/*----------------------------------------------------------------------------------------------------------------------------------------------*/
-
-/**
- * Schaltintervall der Ventile, Schaltabstand ist in der Config hinterlegt
- *
- * @param delay wenn keine Zeit eingegeben ist, wird der Schaltabstand der Config verwendet
- */
-const valveDelay = (delay = parseInt(adapter.config.switchingDistance)) => {
-    return new Promise (
-        resolve => idValveDelayTime = setTimeout (resolve, delay)
-    );
-};
-
-/**
- * Ausschalten der Ventile mit Schaltabstand
- *
- * @param  threadList  Auflistung aller aktiven Sprenger-Kreise
- * @param  parallel  aktuelle Anzahl der eingeschalteten Ventile
- * @returns
- */
-const switchTheValvesOffOn = async (threadList, parallel) => {
-    /**Sammlung von.sprinkleName die am Ende von updateList gelöscht werden
-     *  @type {array} - killList
-     */
-    const killList = [];
-    for (const entry of threadList) {               // ausschalten der Ventile
-        if ((!entry.enabled                             //   Ventile ausgeschaltet z.B. Intervall-Beregnung
-            || entry.enabled && entry.myBreak           //      || in Pause z.B. Boost
-            || entry.killSprinkle)                      //      || Bewässerung erledigt
-            && entry.enabled !== entry.enabledState     //   && Ventil nicht aktuell
-        ) {
-            try {
-                adapter.setForeignStateAsync(entry.idState, {
-                    val: false,
-                    ack: false
-                });
-                entry.enabledState = entry.enabled;
-                /* Ventil aus threadList löschen → Aufgabe beendet und sind nicht in der Pause */
-                if (entry.killSprinkle) {
-                    killList.push(entry.sprinkleName);
-                }
-                adapter.log.info(`Set (${myConfig.config[entry.sprinkleID].methodControlSM}) ID: ${entry.sprinkleName}, value: ${entry.enabled}`);
-                await valveDelay ();
-            } catch (error) {
-                adapter.log.error(`Error(ID: ${entry.sprinkleName}): ${error}`);
-            }
-        }
-    }
-
-    if (currentPumpUse.pumpName !== '') {
-        await setPumpOnOff(parallel > 0);
-        await valveDelay ();
-    }
-    if (adapter.config.triggerControlVoltage) {
-        setVoltageOnOff(parallel>0);
-        await valveDelay ();
-    }
-
-    for (const entry of threadList) {                   // einschalten der Ventile
-        if (entry.enabled                                   // intern eingeschaltet
-            && !entry.myBreak                               // && keine Pause
-            && !entry.killSprinkle                          // Bewässerung noch nicht erledigt
-            && entry.enabled !== entry.enabledState         // && Ventil nicht aktuell
-        ) {
-            try {
-                adapter.setForeignState(entry.idState, {
-                    val: true,
-                    ack: false
-                });
-                entry.enabledState = entry.enabled;
-                if (myConfig.config[entry.sprinkleID].booster) {
-                    boostReady = false;
-                    adapter.log.debug(`ID: ${entry.sprinkleName}UpdateList sprinkle On: boostReady = ${boostReady}`);
-                    setTimeout(() => {
-                        boostList(entry.sprinkleID);
-                    }, 50);
-                }
-                /* Zustand des Ventils im Thread < 0 > off, < 1 > wait, <<< 2 >>> on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
-                adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                    val: 2,
-                    ack: true
-                });
-                // valveOnOff(entry, true, '#2.7 Set: on, ID: ');
-                /* countdown starten */
-                if (!entry.startTime) {
-                    entry.startTime = new Date();
-                }
-                entry.countdown = setInterval(() => {
-                    countSprinkleTime(entry);
-                }, 1000);	// 1000 = 1s
-                adapter.log.info(`Set Valve (${myConfig.config[entry.sprinkleID].methodControlSM}) ID: ${entry.sprinkleName}, value: ${entry.enabled}, duration: ${addTime(entry.wateringTime)}`);
-                await valveDelay ();                            
-            } catch (error) {
-                adapter.log.error(`Error(ID: ${entry.sprinkleName}): ${error}`);
-            }
-
-        }
-    }
-
-    delList(killList);              // erledigte Bewässerungsaufgaben aus der threadList löschen
-};
-
-/**
- * Handling von Ventilen, Zeiten, Verbrauchsmengen im 1s Takt
- *
- * @param entry
- */
-function countSprinkleTime(entry) {
-    /* --- function beenden wenn ---*/
-    if (boostOn && !(myConfig.config[entry.sprinkleID].booster)   // boost-On && kein aktuelles Boost-Ventil
-    ) {
-        return;
-    }
-    entry.count ++;
-    if ((entry.count < entry.wateringTime)	// Zeit noch nicht abgelaufen?
-        && (!entry.calcOn       // alles ausser Berechnung der Verdunstung
-            || !entry.autoOn	// Handbetrieb
-            || (myConfig.config[entry.sprinkleID].soilMoisture.val < myConfig.config[entry.sprinkleID].soilMoisture.maxIrrigation))		// Bodenfeuchte noch nicht erreicht? (z.B. beim Regen)
-    ) {     /* Zeit läuft */
-        adapter.setState(`sprinkle.${entry.sprinkleName}.countdown`, {
-            val: addTime(entry.wateringTime - entry.count),
-            ack: true
-        });
-        /* Alle 15s die Bodenfeuchte anpassen */
-        if (entry.calcOn            // Vergleich nur bei Berechnung der Verdunstung
-            && !(entry.count % 15)	// alle 15s ausführen
-        ) {
-            myConfig.addSoilMoistVal(entry.sprinkleID, entry.soilMoisture15s);
-        }
-        /* Intervall-Beregnung wenn angegeben (onOffTime > 0) */
-        if ((entry.onOffTime > 0) && !(entry.count % entry.onOffTime)) {
-            adapter.log.info(`Intervall-Beregnung, onOffTime: ${entry.onOffTime}, count: ${entry.count}`);
-            entry.enabled = false;
-            entry.myBreak = true;
-            /* Zustand des Ventils im Thread < 0 > off, < 1 > wait, < 2 > on, <<< 3 >>> break, < 4 > Boost(on), < 5 > off(Boost) */
-            adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                val: 3,
-                ack: true
-            });
-            updateList();
-            clearInterval(entry.countdown);
-            entry.onOffTimeoutOff = setTimeout(()=>{
-                entry.myBreak = false;
-                /* Zustand des Ventils im Thread < 0 > off, <<< 1 >>> wait, < 2 > on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
-                adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                    val: 1,
-                    ack: true
-                });
-                updateList();
-            },1000 * (entry.onOffTime < 600 ? 600 : entry.onOffTime));  // 600 sek Pause (10 min)
-        }
-    } else {    /* zeit abgelaufen => Ventil ausschalten */
-        /* Zustand des Ventils im Thread <<< 0 >>> off, < 1 > wait, < 2 > on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
-        entry.enabled = false;
-        adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-            val: 0,
-            ack: true
-        });
-        adapter.setState(`sprinkle.${entry.sprinkleName}.runningTime`, {
-            val: '0',
-            ack: true
-        });
-        adapter.setState(`sprinkle.${entry.sprinkleName}.countdown`, {
-            val: '0',
-            ack: true
-        });
-
-        /* Wenn in der Konfiguration Bodenfeuchte = 100% gesetzt ist und Auto-Bewässerung aktive, dann Bodenfeuchte = 100% setzen*/
-        if (entry.autoOn && entry.calcOn && myConfig.config[entry.sprinkleID].endIrrigation) {
-            myConfig.setSoilMoistPct100(entry.sprinkleID);
-        }
-        /* Verbrauchswerte in der Historie aktualisieren */
-        addConsumedAndTime(entry);
-        /* Booster zurücksetzen */
-        if (myConfig.config[entry.sprinkleID].booster) {
-            if (boostOn) {
-                boostKill(entry.sprinkleID);
-            }
-            boostReady = true;
-            adapter.log.debug(`ID: ${entry.sprinkleName} UpdateList Sprinkle Off: boostReady = ${boostReady}`);
-        }
-        /* Zeiten löschen */
-        clearInterval(entry.countdown);
-        /*clearTimeout(entry.onOffTimeoutOn);*/
-        clearTimeout(entry.onOffTimeoutOff);
-        /* Ventil aus threadList löschen → Aufgabe beendet */
-        //delList(entry.sprinkleName);
-        entry.killSprinkle = true;
-        updateList();
-    }
-}
-
-/*----------------------------------------------------------------------------------------------------------------------------------------------*/
-
-/**
- * Control of the active irrigation circuits so that the maximum pump capacity (l / h) is achieved and the maximum number of irrigation circuits is not exceeded.
- * => Steuerung der aktiven Bewässerungskreise, damit die maximale Pumpenkapazität (l / h) erreicht wird und die maximale Anzahl der Bewässerungskreise nicht überschritten wird.
- */
-function updateList () {
-    /* während des Boost eines Kreises ist ein zuschalten von Sprengern nicht möglich */
-    if (boostOn) {
-        return;
-    }
-
-    if (updateListMarker.funcActive === true) {
-        updateListMarker.newStart = true;
-        return;
-    }
-    updateListMarker.funcActive = true;
-    /** aktuelle Rest-Pumpenleistung */
-    let curFlow = currentPumpUse.pumpPower, /* adapter.config.triggerMainPumpPower; */
-        /** aktuelle Anzahl der eingeschalteten Ventile */
-        parallel = 0;
-
-    /**
-     * Sortierfunktion mySortDescending absteigende Sortierung
-     *
-     * @param a
-     * @param b
-     * @returns
-     */
-    function mySortDescending(a, b) {
-        return (a.pipeFlow > b.pipeFlow) ? -1 :
-            (a.pipeFlow < b.pipeFlow) ? 1 :
-                0;
-    }
-    /**
-     * Sortierfunktion mySortAscending aufsteigende Sortierung
-     *
-     * @param a
-     * @param b
-     * @returns
-     */
-    function mySortAscending(a, b) {
-        return (a.pipeFlow < b.pipeFlow) ? -1 :
-            (a.pipeFlow > b.pipeFlow) ? 1 :
-                0;
-    }
-
-    // ermitteln von curPipe und der anzahl der parallelen Stränge
-    for(const entry of threadList){
-        if (entry.enabled && !entry.killSprinkle) {
-            curFlow -= entry.pipeFlow;	// // ermitteln der RestFörderkapazität
-            parallel ++;	// Anzahl der Bewässerungsstellen um 1 erhöhen
-        }
-    }
-
-    if (curFlow < 0) {
-        /* - wenn beim Umschalten der Pumpen die Förderleistung zu gering → Ventile deaktivieren - */
-        // aufsteigend sortieren nach der Verbrauchsmenge
-        threadList.sort(mySortAscending);
-
-        for(const entry of threadList) {
-            if (entry.enabled                   //  eingeschaltet
-                && !entry.killSprinkle          //  && Aufgabe noch nicht erledigt
-                && (curFlow < 0)                //  && Förderleistung der Pumpe zu gering
-            ) {
-                entry.enabled = false;          // ausgeschaltet merken
-                clearInterval(entry.countdown); // Zähler für Countdown, Verbrauchsmengen, usw. löschen
-                curFlow += entry.pipeFlow;	    // ermitteln der RestFörderkapazität
-                parallel--;	                    // Anzahl der Bewässerungsstellen um 1 verringern
-                /* Zustand des Ventils im Thread < 0 > off, <<< 1 >>> wait, < 2 > on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
-                adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                    val: 1,
-                    ack: true
-                });
-                // valveOnOff(entry, false, '#2.6 Set: wait, ID: ');
-                adapter.log.info(`Set Valve ID: ${entry.sprinkleName} Pump delivery rate too low, wait!  curFlow ${curFlow} parallel: ${parallel}`);
-            }
-        }
-    }
-
-    // absteigend sortieren nach der Verbrauchsmenge
-    threadList.sort(mySortDescending);
-
-    // einschalten der Bewässerungsventile nach Verbrauchsmenge und maximaler Anzahl
-    for(const entry of threadList) {
-        // adapter.log.info(`Ventile Ein: enabled: ${!entry.enabled} && killSprinkle: ${!entry.killSprinkle} && myBreak: ${!entry.myBreak} && Flow: ${(curFlow >= entry.pipeFlow)} && ||: ${(parallel < maxParallel)} && noBoost: ${((boostReady) || !(myConfig.config[entry.sprinkleID].booster))}`);
-        if (!entry.enabled                                                      // ausgeschaltet
-            && !entry.killSprinkle                                              // && Aufgabe noch nicht erledigt
-            && !entry.myBreak                                                   // && nicht in der Pause
-            && (curFlow >= entry.pipeFlow)                                      // && noch genügend Förderleistung der Pumpe
-            && (parallel < maxParallel)                                         // && maxParallel noch nicht erreicht
-            && ((boostReady) || !(myConfig.config[entry.sprinkleID].booster))   // nur einer mit boostFunction darf aktive sein
-        ) {
-            entry.enabled = true;	// einschalten merken
-
-            curFlow -= entry.pipeFlow;	// ermitteln der RestFörderkapazität
-            parallel++;	// Anzahl der Bewässerungsstellen um 1 erhöhen
-
-        }
-    }
-
-    adapter.setState('control.parallelOfMax', {
-        val: `${parallel} : ${maxParallel}`,
-        ack: true
-    });
-    adapter.setState('control.restFlow', {
-        val: `${curFlow} (${currentPumpUse.pumpPower} ${currentPumpUse.pumpCistern ? 'Zisterne' : 'Grundwasser'})`,
-        ack: true
-    });
-
-    switchTheValvesOffOn(threadList, parallel).then(err => {
-        if (err) {
-            adapter.log.error(`Error - Set (false) err: ${err}`);
-            sendMessageText.sendMessage(`Error - Set (false) err: ${err}`);
-        }
-    });
-
-    updateListMarker.funcActive = false;
-    if (updateListMarker.newStart === true) {
-        updateListMarker.newStart = false;
-        setTimeout(updateList(), 50);
-    }
-} // End updateList
-
-/* --------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
-
-/**
- * +++++  Set the current pump for irrigation  +++++
- * → Festlegen der aktuellen Pumpe zur Bewässerung
- */
-function setActualPump () {
-    let switchOnLevelCistern = (parseFloat(adapter.config.triggerMinCisternLevel) + parseFloat(adapter.config.switchOnLevelCistern)) || 5;
-    if (switchOnLevelCistern > 100) {
-        switchOnLevelCistern = 100;
-        adapter.log.info(`Switch-on point limited to 100%`);
-    }
-    if (switchOnLevelCistern < 5) {
-        switchOnLevelCistern = 5;
-        adapter.log.info(`Switch-on point increased to 5%`);
-    }
-
-    /* Zisternen-Bewässerung Einstellung in der config (2. Pumpe) aktiviert */
-    if (adapter.config.cisternSettings === true) {
-        if (currentPumpUse.enable === true) {
-            /* Bewässerungspumpen aktiv */
-            if ((fillLevelCistern < parseFloat(adapter.config.triggerMinCisternLevel))
-                 && (currentPumpUse.pumpCistern === true)
-                ) {
-                /* (Zisterne unter Minimum) && (ZisternenPumpe läuft) */
-                adapter.setForeignState(currentPumpUse.pumpName, {
-                    val: false,
-                    ack: false
-                }); // Pumpe Zisterne Aus
-                if (currentPumpUse.pumpCistern === true && !sendMessageText.onlySendError()) {
-                        sendMessageText.sendMessage(`Pump change (cistern empty) Cistern pump off => main pump on`); 
-                }
-                currentPumpUse.pumpCistern = false;
-                currentPumpUse.pumpName = adapter.config.triggerMainPump || '';
-                currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower);
-                currentPumpUse.leadTime = parseInt(adapter.config.mainPumpLeadTime)*1000 || 1000;
-                adapter.setForeignState(currentPumpUse.pumpName, {
-                    val: true,
-                    ack: false
-                }); // Hauptpumpe Ein
-                adapter.log.info('Pump change (cistern empty) Cistern pump off => main pump on');
-                updateList();   // Wasserverbrauch an Pumpenleistung anpassen
-            }
-            if (fillLevelCistern < parseFloat(adapter.config.triggerMinCisternLevel)) {
-                statusCistern = `Cistern empty: ${fillLevelCistern} %  (${switchOnLevelCistern} %)`;
-            } else {
-                statusCistern = `Cistern filled: ${fillLevelCistern} %  (${adapter.config.triggerMinCisternLevel} %)`;
-            }
-        } else {
-            /* Bewässerungspumpen inaktiv */
-            if ((fillLevelCistern >= switchOnLevelCistern)
-                 && (adapter.config.triggerCisternPump)
-                 && (adapter.config.triggerCisternPumpPower)
-                ) {
-                /* Zisterne voll && triggerCisternPump && triggerCisternPumpPower vorhanden*/
-                statusCistern = `Cistern filled: ${fillLevelCistern} %  (${adapter.config.triggerMinCisternLevel} %)`;
-                if (currentPumpUse.pumpCistern === false
-                     && !sendMessageText.onlySendError()
-                    ) {
-                    currentPumpUse.pumpCistern = true;
-                    currentPumpUse.pumpName = adapter.config.triggerCisternPump || '';
-                    currentPumpUse.pumpPower = parseInt(adapter.config.triggerCisternPumpPower);
-                    currentPumpUse.leadTime = parseInt(adapter.config.cisternPumpLeadTime)*1000 || 1000;
-                    adapter.setState('control.restFlow', {
-                        val: `${currentPumpUse.pumpPower} (${currentPumpUse.pumpPower} Zisterne)`,
-                        ack: true
-                    });
-                    sendMessageText.sendMessage(`Cistern filled: ${fillLevelCistern} %  (${adapter.config.triggerMinCisternLevel} %)`); 
-                }
-            } else if (fillLevelCistern < parseFloat(adapter.config.triggerMinCisternLevel)) {
-                statusCistern = `Cistern empty: ${fillLevelCistern} %  (${switchOnLevelCistern} %)`;
-                currentPumpUse.pumpCistern = false;
-                currentPumpUse.pumpName = adapter.config.triggerMainPump || '';
-                currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower);
-                currentPumpUse.leadTime = parseInt(adapter.config.mainPumpLeadTime)*1000 || 1000;
-                adapter.setState('control.restFlow', {
-                    val: `${currentPumpUse.pumpPower} (${currentPumpUse.pumpPower} Grundwasser)`,
-                    ack: true
-                });
-            } else {
-                if (currentPumpUse.pumpCistern === true) {
-                    statusCistern = `Cistern filled: ${fillLevelCistern} %  (${adapter.config.triggerMinCisternLevel} %)`;  
-                } else {
-                    statusCistern = `Cistern empty: ${fillLevelCistern} %  (${switchOnLevelCistern} %)`;
-                }
-            }
-            adapter.setState('info.cisternState', {
-                val: statusCistern,
-                ack: true
-            });
-        }
-    } else {
-        /* Pumpe AUS => Zisternen-Bewässerung nicht aktiviert */
-        if (adapter.config.triggerCisternPump) {
-            statusCistern = `Cistern settings are not active!${(fillLevelCistern > 0)?(` level sensor: ${fillLevelCistern} % ${(adapter.config.triggerMinCisternLevel !== '')?(`${adapter.config.triggerMinCisternLevel} %`):('')}`):('')}`;
-            adapter.setState('info.cisternState', {
-                val: statusCistern,
-                ack: true
-            });
-        }
-    }
-}   // End setActualPump
-
-/**
- * Switching the pump on or off
- * => Ein bzw. ausschaltern der Pumpe
- * 
- * @param pumpOnOff ; Pumpe on = true
- */
-const setPumpOnOff = async (pumpOnOff) => {
-    clearTimeout(idValveDelayTime);
-    if (currentPumpUse.pumpName !== '') {
-        try {
-            const curPumpState = await adapter.getForeignStateAsync(currentPumpUse.pumpName);
-            if (curPumpState) {
-                if (pumpOnOff) {
-                    if (curPumpState.val === false) {
-                        adapter.setForeignState(currentPumpUse.pumpName, {
-                            val: true,
-                            ack: false
-                        });
-                        currentPumpUse.enable = true;
-                        adapter.log.info(`Set (pump) on, wait ${currentPumpUse.leadTime}ms`);
-                        await valveDelay(currentPumpUse.leadTime);
-                    }
-                } else {
-                    if (curPumpState.val !== false) {
-                        adapter.setForeignState(currentPumpUse.pumpName, {
-                            val: false,
-                            ack: false
-                        });
-                        currentPumpUse.enable = false;
-                        adapter.log.info('Set (pump) off');
-                    }
-                }
-            }
-        } catch (error) {
-            adapter.log.error(`triggerMainPump ${currentPumpUse.pumpName} is not available (ist nicht erreichbar): ${error}`);
-        }
-    }
-}   // End setPumpOnOff
-
-/**
- * Switching the control voltage on or off
- * => Ein bzw. ausschaltern der Steuerspannung
- *
- * @param voltageOnOff - Voltage on = true
- */
-function setVoltageOnOff(voltageOnOff) {
-    if (adapter.config.triggerControlVoltage !== '') {
-        adapter.getForeignState(adapter.config.triggerControlVoltage, (err, state) => {
-            if (state) {
-                if (voltageOnOff) {
-                    if (state.val === false) {
-                        adapter.setForeignState(adapter.config.triggerControlVoltage, {
-                            val: true,
-                            ack: false
-                        });
-                        adapter.log.info('Set (voltage) on');
-                    }
-                } else {
-                    if (state.val !== false) {
-                        adapter.setForeignState(adapter.config.triggerControlVoltage, {
-                            val: false,
-                            ack: false
-                        });
-                        adapter.log.info('Set (voltage) off');
-                    }
-                }
-            } else if (err) {
-                adapter.log.error(`triggerControlVoltage is not available (ist nicht erreichbar): ${err}`);
-            }
-        });
-    }
-}
-
-/**
- * Adding the consumption data to the history
- * => Hinzufügen der Verbrauchsdaten zur History
- *
- * @param entry - array mit den Daten des aktiven Ventils
- */
-function addConsumedAndTime(entry) {
-    adapter.setState(`sprinkle.${entry.sprinkleName}.history.lastConsumed`, {
-        val: Math.round(entry.litersPerSecond * entry.count),
-        ack: true
-    });
-    adapter.setState(`sprinkle.${entry.sprinkleName}.history.lastRunningTime`, {
-        val: addTime(entry.count),
-        ack: true
-    });
-    adapter.setState(`sprinkle.${entry.sprinkleName}.history.lastOn`, {
-        val: formatTime(adapter, entry.startTime, 'dd.mm. hh:mm'),
-        ack: true
-    });
-    adapter.getState(`sprinkle.${entry.sprinkleName}.history.curCalWeekConsumed`, (err, state) => {
-        if (state) {
-            adapter.setState(`sprinkle.${entry.sprinkleName}.history.curCalWeekConsumed`, {
-                val: (state.val) + Math.round(entry.litersPerSecond * entry.count),
-                ack: true
-            });
-        }
-    });
-    adapter.getState(`sprinkle.${entry.sprinkleName}.history.curCalWeekRunningTime`, (err, state) => {
-        if (state) {
-            adapter.setState(`sprinkle.${entry.sprinkleName}.history.curCalWeekRunningTime`, {
-                val: addTime(state.val, entry.count),
-                ack: true
-            });
-        }
-    });
-}   // End addConsumedAndTime
-
-
-/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/*                                                       externe Funktionen                                                                     */
-/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-
-/**
- * -- externe Funktionen -> initValveControl - addList - clearEntireList - setFillLevelCistern --
- *
- */
-const valveControl = {
-    /**
-     * Initialize the start configuration of ventilControl
-     * => Initialisieren Sie die Startkonfiguration von ventilControl
-     * 
-     * @param myAdapter
-     */
-    initValveControl (myAdapter) {
-        adapter = myAdapter;
-        currentPumpUse.pumpCistern = false;
-        currentPumpUse.pumpName = adapter.config.triggerMainPump || '';
-        currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower) || 0;
-        currentPumpUse.leadTime = parseInt(adapter.config.mainPumpLeadTime)*1000 || 1000;
-        maxParallel = parseInt(adapter.config.maximumParallelValves);
-        /* Objekt control.restFlow befüllen */
-        adapter.setState('control.restFlow', {
-            val: `${currentPumpUse.pumpPower} (${currentPumpUse.pumpPower} ${currentPumpUse.pumpCistern ? 'Zisterne' : 'Grundwasser'})`,
-            ack: true
-        });
-        /* Objekt control.parallelOfMax befüllen */
-        adapter.setState('control.parallelOfMax', {
-            val: `0 : ${adapter.config.maximumParallelValves}`,
-            ack: true
-        });
-        /* 24V ausschalter, wenn vorhanden */
-        if (adapter.config.triggerControlVoltage !== '') {
-            adapter.getForeignState('adapter.config.triggerControlVoltage', (err, state) => {
-                if (state && state.val === true) {
-                    adapter.setForeignState(adapter.config.triggerControlVoltage, {
-                        val: false,
-                        ack: false
-                    });
-                }
-            });
-        }
-        /* Pumpe ausschalter, wenn vorhanden */
-        if (adapter.config.triggerMainPump !== '') {
-            adapter.getForeignState('adapter.config.triggerMainPump', (err, state) => {
-                if (state && state.val === true) {
-                    adapter.setForeignState(adapter.config.triggerMainPump, {
-                        val: false,
-                        ack: false
-                    });
-                }
-            });
-        }
-        /* Pumpe (Zisterne) ausschalter, wenn vorhanden */
-        if (adapter.config.triggerCisternPump !== '') {
-            adapter.getForeignState('adapter.config.triggerCisternPump', (err, state) => {
-                if (state && state.val === true) {
-                    adapter.setForeignState(adapter.config.triggerCisternPump, {
-                        val: false,
-                        ack: false
-                    });
-                }
-            });
-        }
-        /* alle Ventile (.name = "hm-rpc.0.MEQ1234567.3.STATE") in einem definierten Zustand (false) versetzen*/
-        const result = adapter.config.events;
-        if (result) {
-            for (const res of result) {
-                adapter.getForeignState(res.name, (err, state) => {
-                    if (state && state.val === true) {
-                        adapter.setForeignState(res.name, {
-                            val: false,
-                            ack: false
-                        });
-                    }
-                });
-            }
-        }
-    },  // End initValveControl
-
-    /**
-     *  Add Sprinkle→ Sprinkle hinzufügen
-     *  
-     * @param sprinkleList
-     * @param sprinkleList[].auto - auto → Automatik == (true), Handbetrieb == (false)
-     * @param sprinkleList[].sprinkleID - sprinkleID → zugriff auf myConfig.config[sprinkleID]. xyz
-     * @param sprinkleList[].wateringTime - wateringTime → Bewässerungszeit in min
-     */
-    addList (sprinkleList) {
-        //
-        for (const res of sprinkleList) {
-            const sprinkleName = myConfig.config[res.sprinkleID].objectName;
-            /**
-             * add done
-             * → hinzufügen erledigt (Sprenger bereits aktive)
-             */
-            let addDone = false;
-            // schauen ob der Sprenger schon in der threadList ist
-            if (threadList) {
-                for (const entry of threadList) {
-                    if (entry.sprinkleID === res.sprinkleID) {
-                        if (entry.wateringTime === res.wateringTime) {
-                            // adapter.setState('sprinkle.' + sprinkleName + '.runningTime', {val: addTime(wateringTime, ''), ack: false});
-                            return;
-                        }
-                        entry.wateringTime = res.wateringTime;
-                        entry.autoOn = res.auto;      // auto: = true autostart; = false Handbetrieb
-                        adapter.setState(`sprinkle.${sprinkleName}.runningTime`, {
-                            val: addTime(res.wateringTime),
-                            ack: true
-                        });
-                        addDone = true;		// Sprinkle found
-                        adapter.log.debug(`update ID: ${entry.sprinkleName} new time: ${addTime(res.wateringTime)}`);
-                        // Wenn aktueller Spränger im BoostOn ausgeschaltet werden soll (ersten 30s)
-                        if (boostOn
-                            && myConfig.config[res.sprinkleID].booster
-                            && entry.wateringTime <= 0
-                        ) {
-                            boostKill(res.sprinkleID);
-                            boostReady = true;
-                            adapter.log.debug(`ID: ${res.sprinkleName} BoostKill Sprinkle Off: boostReady = ${boostReady}`);
-                        }
-                        break;
-                    }
-                }
-            }
-
-            if (!addDone) {
-                if (res.wateringTime <= 0) {
-                    adapter.setState(`sprinkle.${sprinkleName}.runningTime`, {
-                        val: '0',
-                        ack: true
-                    });
-                    return;
-                }
-
-                let pipeFlow = myConfig.config[res.sprinkleID].pipeFlow;
-
-                // Kontrolle des Ventilverbrauchs(muss kleiner als Pumpenleistung sein, da Ventil sonst nicht starten kann)
-                if (adapter.config.cisternSettings === true) {
-                    if ((pipeFlow > adapter.config.triggerMainPumpPower) || (pipeFlow > adapter.config.triggerCisternPumpPower)) {
-                        if (pipeFlow > adapter.config.triggerMainPumpPower) adapter.log.warn(`Emergency irrigation! ${sprinkleName}: Valve consumption > pump performance (main pump)`);
-                        if (pipeFlow > adapter.config.triggerCisternPumpPower) adapter.log.warn(`Emergency irrigation! ${sprinkleName}: Valve consumption > pump performance (cistern pump)`);
-                        pipeFlow = (adapter.config.triggerMainPumpPower < adapter.config.triggerCisternPumpPower) ? adapter.config.triggerMainPumpPower : adapter.config.triggerCisternPumpPower;                            
-                    }
-                } else {
-                    if (pipeFlow > adapter.config.triggerMainPumpPower) {
-                        adapter.log.warn(`Emergency irrigation! ${sprinkleName}: Valve consumption > pump performance (main pump)`);
-                        pipeFlow = adapter.config.triggerMainPumpPower;
-                    }
-                }
-
-                const newThread = {
-                    sprinkleID: res.sprinkleID,	// Array[0...]   
-                    sprinkleName: sprinkleName,	// z.B "Blumenbeet"   
-                    idState: myConfig.config[res.sprinkleID].idState,	// z.B. "hm-rpc.0.MEQ1810129.1.STATE"   
-                    wateringTime: res.wateringTime,  // Bewässerungszeit in s (Sekunden)  
-                    pipeFlow: pipeFlow,  // Wasserverbrauch in l/h   
-                    count: 0,                // Zähler im Sekundentakt  
-                    calcOn: (myConfig.config[res.sprinkleID].methodControlSM === 'calculation'),         //  Anpassung der Bodenfeuchte true/false  
-                    enabled: false,          // Ventil softwaremäßig ein  
-                    enabledState: false,     // Ventil hardwaremäßig ein  
-                    myBreak: false,          // meine Pause  
-                    killSprinkle: false,     // Löschauftrag ausführen am Ende in threadList   
-                    litersPerSecond: pipeFlow / 3600,    // Wasserverbrauchsmenge pro Sekunde   
-                    onOffTime: myConfig.config[res.sprinkleID].wateringInterval,  
-                    autoOn: res.auto,   
-                    soilMoisture15s: 15 * (myConfig.config[res.sprinkleID].soilMoisture.maxIrrigation - myConfig.config[res.sprinkleID].soilMoisture.triggersIrrigation)
-                                                / (60 * myConfig.config[res.sprinkleID].wateringTime),
-                    times: {
-                        boostTime1: null,  // boost start in die Zwangspause schicken in 0,25s
-                        boostTime2: null,  // boost ende aus der Zwangspause holen nach 31s
-                    },       // hinterlegen der verschiedenen Zeiten von timeout für gezieltes späteres löschen  
-                    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) */
-                adapter.setState(`sprinkle.${sprinkleName}.sprinklerState`, {
-                    val: 1,
-                    ack: true
-                });
-                adapter.setState(`sprinkle.${sprinkleName}.runningTime`, {
-                    val: addTime(res.wateringTime),
-                    ack: true
-                });
-                adapter.log.debug(`ID: ${sprinkleName} new order created: ${JSON.stringify(threadList[newThread.id])}`);
-            }
-        }
-        updateList();
-    }, // End addList
-
-    /**
-     * switch off all devices, when close the adapter
-     * => Beim Beenden des adapters alles ausschalten
-     */
-    clearEntireList () {
-        clearTimeout(idValveDelayTime);
-        setVoltageOnOff(false);
-        setPumpOnOff(false);
-        if (boostListTimer) {
-            boostReady = true;
-            boostOn = false;
-            clearTimeout(boostListTimer);
-        }
-        // let bValveFound = false;	// Ventil gefunden
-        for (let counter = threadList.length - 1;	// Loop über das Array
-            counter >= 0;
-            counter--) {
-            const entry = threadList[counter];
-            if (entry.enabledState) {
-                adapter.log.info(`Set Valve (SprinkleControl: off) ID: ${entry.sprinkleName}, value: false`);
-                adapter.setForeignState(entry.idState, {
-                    val: false,
-                    ack: false
-                });
-            }
-            /* Zustand des Ventils im Thread <<< 0 >>> off, < 1 > wait, < 2 > on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
-            adapter.setState(`sprinkle.${entry.sprinkleName}.sprinklerState`, {
-                val: 0,
-                ack: true
-            });
-            adapter.setState(`sprinkle.${entry.sprinkleName}.runningTime`, {
-                val: '0',
-                ack: true
-            });
-            adapter.setState(`sprinkle.${entry.sprinkleName}.countdown`, {
-                val: '0',
-                ack: true
-            });
-            // valveOnOff(myEntry, false, '#2.0 Set: off, ID: ');
-            /* Verbrauchswerte in der Historie aktualisieren */
-            addConsumedAndTime(entry);
-            /* del timer countdown */
-            clearInterval(entry.countdown);
-            /* del timer onOffTimeoutOff */
-            clearTimeout(entry.onOffTimeoutOff);
-            /* del timer newThread.times.boostTime1 */
-            if (entry.times.boostTime1) {
-                clearTimeout(entry.times.boostTime1);
-                entry.times.boostTime1 = null;
-            }
-            /* del timer newThread.times.boostTime2 */
-            if (entry.times.boostTime2) {
-                clearTimeout(entry.times.boostTime2);
-                entry.times.boostTime2 = null;
-            }
-            adapter.log.debug(`order deleted Stop all ID: ${entry.sprinkleName} ( rest orders: ${threadList.length} )`);
-            threadList.pop();   // del last array
-        }
-        updateList();
-    }, // End clearEntireList
-
-    /**
-     * Änderungen des Füllstands setzen + Vorrang der Pumpe setzen
-     *
-     * @param levelCistern
-     */
-    setFillLevelCistern (levelCistern) {
-        fillLevelCistern = (typeof levelCistern === 'number') ? levelCistern : 0;
-        setActualPump();
-    },   // End setFillLevelCistern
-
-    getStatusCistern () {
-        return statusCistern;
-    }
-};  // End valveControl
-
-/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-
-module.exports = valveControl;
+
+'use strict';
+
+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 sendMessageText = require('./sendMessageText.js');            // sendMessageText
+
+/**
+ * The adapter instance
+ */
+let adapter;
+
+/**
+ * Thread-list
+ * → Auflistung aller aktiver Sprenger-Kreise
+ */
+const threadList = [];
+
+/**
+ *  - bereit zum Boost (true: kein Boostventil aktive; false: BoostVentil aktive)
+ */
+let boostReady = true,
+    /**
+     * - Boost aktive
+     */
+    boostOn = false,
+    /**
+     * maximal zulässige Anzahl der eingeschalteten Ventile
+     */
+    maxParallel = 0,
+    /* Control of the cistern pump */
+    /**
+     *  Füllstand der Zisterne
+     */
+    fillLevelCistern = 0;
+const updateListMarker = {funcActive: false, newStart: false, switchingDistance: 5000, cancelSwitchingDistance: {}};
+
+/**
+ * aktive Pumpendaten
+ * - enable: Pumpe ein/ausgeschaltet
+ * - name: Bezeichnung der Pumpe
+ * - idState: Objektname des State
+ * - id: ID des States unter Objecte im ioBroker info.cisternPump || info.mainPump
+ * - intBreak: Pause (Zisterne leer)
+ * - pumpCistern: ZisternenPumpe aktiv bei Verwendung zweier Pumpen
+ * - leadTime: Vorlaufzeit
+ * - cancelLeadTime: Vorlaufzeit abbrechen
+ * - pumpPower: Maximalleistung der Pumpe
+ * - restFlow: aktuelle LeistungsReserve der Pumpe
+ * - controller: Rückmeldung ack
+ * - ac: AbortController
+ */
+
+const currentPumpUse = {enable: false, name: '', idState: '', id: '', pumpCistern: false, intBreak: false, leadTime: 0, cancelLeadTime: {}, pumpPower: 0, restFlow: 0,ac: {},controller: {}};
+
+/**
+ *  Steuerspannung 24V
+ * - enable: 24V ein/ausgeschaltet
+ * - name: Bezeichnung 24V
+ * - idState: Aktorerkennung "hm-rpc.0.MEQ1810129.1.STATE"
+ * - controller: controlle von Zeiten und Abbruchsignalen
+ */
+const controlVoltage ={enable: false, name: '24V', idState: undefined, ac: {}, controller: {}};
+
+/**
+ *  Schaltabstand in ms
+ * - Schaltabstand zwischen den Ventilen
+ * - 250 ms - 240 000 ms (4 min)
+ */
+let switchingDistanceMS = 250;
+/*==============================================================================================================================================*/
+/*                                                            interne Funktionen                                                                */
+/*----------------------------------------------------------------------------------------------------------------------------------------------*/
+
+/**
+ * Schalten der Ventile
+ * 
+ * @param {object} thread -Objekt des Ventils
+ * @param {boolean} val - neuer Zustand des Ventils
+ * @returns {Promise<string|undefined>}
+ */
+
+const setValve = async (thread, val) => {
+
+    const startTime = new Date();
+    let result = undefined;
+
+    thread.ac.acSetValveCancelTimeout = new AbortController;
+    /**
+     *  Sprinkle geschaltet
+     *
+     * @param {{val:boolean,ack:boolean}} state 
+     */
+    thread.controller.ackTrue = (state) => {
+        if (typeof state.val === 'boolean'
+            && state.val === val
+            && state.ack === true
+        ) {
+            adapter.log.debug(`setValve ${thread.name} => ackTrue`);
+            result = thread.idState;
+            thread.enable = val;
+            thread.ac.acSetValveCancelTimeout.abort();
+        } else {
+            adapter.log.warn(`setValve ${thread.name}  => ackTrue val = ${val} state: ${JSON.stringify(state)}`);
+        }
+    };
+    
+    //adapter.log.info(`Set Valve (async () => {...}`);
+    try {
+        // Ventil ansteuern
+        const _setValve = await adapter.setForeignStateAsync(thread.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
+            ) {
+                thread.enable = val;
+                return thread.idState;
+            } else {
+                adapter.log.debug(`setValve ${thread.name} _getValve: ${_getValve}`);
+                throw new Error(`setForeignState not responding (ack === false)`);
+            }
+        } else {
+            throw new Error(`set Valve was not switched`);
+        }
+    } catch (error) {
+        // thread.controller.ackTrue wurde ausgelöst
+        if (error.name !== `AbortError`) {
+            await adapter.setForeignStateAsync(thread.idState, {
+                val: false,
+                ack: false
+            });
+            thread.enable = false;
+            if (adapter.config.notificationEnabled) {
+                sendMessageText.sendMessage(`setValve ${thread.name} (${thread.idState}) ${error}`);
+            }
+            throw new Error(`set Valve (${thread.idState}) ${error}`);
+        }
+    } finally {
+        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,
+        ack: true
+    });
+    if (thread.name !== 'Cistern pump' && thread.name !== 'Main pump' && thread.name !== '24V' && thread.name !== 'no Pump') {
+        adapter.setStateAsync(`sprinkle.${thread.name}.valveOn`, {
+            val: thread.enable,
+            ack: true
+        });
+    }
+    return result;
+};
+
+/**
+ * Sprinkle (name) delete
+ * → Ventil (name) löschen
+ * 
+ * @param {Array.<{name: string}>} killList
+ * @returns {Promise}
+ */
+const delList = async (killList) => {
+    new Promise((resolve, reject) => {
+        const badList = [];
+        for (const name of killList) {
+            let bValveFound = false;	// Ventil gefunden
+            for (let counter = 0,                                  // Loop über das Array
+                lastArray = (threadList.length - 1);     // entsprechend der Anzahl der Eintragungen
+                counter <= lastArray;
+                counter++) {
+                const entry = threadList[counter].name;
+                if ((name === entry) || bValveFound) {
+                    if (name === entry) bValveFound = true;
+                    if (counter !== lastArray) threadList[counter] = threadList[counter + 1];
+                }
+            }
+            /* If a valve is found, delete the last array (entry). Wenn Ventil gefunden letzten Array (Auftrag) löschen */
+            if (bValveFound) {
+                threadList.pop();
+                adapter.log.debug(`delList => order deleted ID: ${name} ( rest orders: ${threadList.length} )`);
+            }else{
+                badList.push(name);
+            }
+        }
+        if (badList.length > 0) {
+            reject(`delList: could not find ${JSON.stringify(badList)}`);
+        } else {
+            resolve;
+        }
+    });
+};  // End delList
+
+/**
+ * currentConsumption aktueller Verbrauch ermitteln
+ *
+ * @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; */
+            /** 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) {
+        // 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
+                ) {
+                    curFlow -= entry.pipeFlow;	// // ermitteln der RestFörderkapazität
+                    parallel ++;	// Anzahl der Bewässerungsstellen um 1 erhöhen
+                    pumpRequired = true;
+                }
+            }
+        }
+
+        if (write || currentPumpUse.intBreak) {
+            adapter.setStateAsync('control.parallelOfMax', {
+                val: `${parallel} : ${maxParallel}`,
+                ack: true
+            });
+            adapter.setStateAsync('control.restFlow', {
+                val: `${curFlow} (${currentPumpUse.pumpPower} | ${currentPumpUse.name})`,
+                ack: true
+            });
+        }
+
+        return {
+            curFlow: curFlow,
+            parallel: parallel,
+            pumpRequired: pumpRequired
+        };
+        
+    } catch (error) {
+        adapter.log.error(`currentConsumption Error: ${error}`);
+        return {
+            curFlow: 0,
+            parallel: 99,
+            pumpRequired: false
+        };
+    }
+};
+
+/** Interval-Beregnung aus */
+
+const onOffTimeoutOff = async (entry) => {
+    entry.ac.acOnOffTimeoutOff = new AbortController;
+    try {
+        const res = await asyncTime.setTimeout(1000 * (entry.onOffTimeOff < 600 ? 600 : entry.onOffTimeOff),`time expired`, { signal: entry.ac.acOnOffTimeoutOff.signal });   // mindestens 600 sek Pause (10 min)
+        if (res === `time expired`) {   // Zeit abgelaufen
+            entry.myBreak = false;
+            // Zustand des Ventils im Thread < 0 > off, <<< 1 >>> wait, < 2 > on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost)
+            entry.state = 'wait';
+            adapter.setStateAsync(`sprinkle.${entry.name}.sprinklerState`, {
+                val: entry.state,     // <<< 1 >>> wait
+                ack: true
+            });
+            updateList();            
+        }
+    } catch (error) {
+        adapter.log.error(`onOffTimeoutOff error: ${error}`);
+    } finally {
+        if (entry.ac.acOnOffTimeoutOff.aborted === false) entry.ac.acOnOffTimeoutOff.abort();
+    }
+};
+/*----------------------------------------------------------------------------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------------------------------------------------------------------------*/
+
+/**
+ * Handling von Ventilen, Zeiten, Verbrauchsmengen im 1s Takt
+ * 
+ * @param {object} entry
+ */
+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
+        ) {
+            return;
+        }
+
+        entry.count ++;
+
+        if ((entry.count < entry.wateringTime)	// Zeit noch nicht abgelaufen?
+            && (!entry.calcOn       // Vergleich nur bei Berechnung der Verdunstung
+                || !entry.autoOn	// Vergleich nur bei Automatik
+                || (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, ''),
+                ack: true
+            });
+
+            /* Alle 15s die Bodenfeuchte anpassen */
+            if (entry.calcOn            // Vergleich nur bei Berechnung der Verdunstung
+                && !(entry.count % 15)	// alle 15s ausführen
+            ) {
+                myConfig.addSoilMoistVal(entry.sprinkleID, entry.soilMoisture15s);
+            }
+
+            /* Intervall-Beregnung wenn angegeben (onOffTimeOff > 0) */
+            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) {
+                    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';
+                    adapter.setStateAsync(`sprinkle.${entry.name}.sprinklerState`, {
+                        val: entry.state,
+                        ack: true
+                    });
+                    clearInterval(entry.countdown);
+                    entry.countdown = null;
+                    currentConsumption(true);
+                    onOffTimeoutOff(entry);
+                    updateList();                   
+                }
+            }
+        } else {    /* zeit abgelaufen => Ventil ausschalten */
+            /* Wenn in der Konfiguration Bodenfeuchte = 100% gesetzt ist und Auto-Bewässerung aktive, dann Bodenfeuchte = 100% setzen*/
+            if (entry.autoOn && entry.calcOn && myConfig.config[entry.sprinkleID].calculation.endIrrigation) {
+                myConfig.setSoilMoistPct100(entry.sprinkleID);
+            }
+            /* Verbrauchswerte in der Historie aktualisieren */
+            addConsumedAndTime(entry);
+            /* Booster zurücksetzen */
+            if (myConfig.config[entry.sprinkleID].booster) {
+                //if (boostOn) {boostKill(entry.sprinkleID);}
+                boostReady = true;
+                boostOn = false;
+                adapter.log.debug(`ID: ${entry.name} UpdateList Sprinkle Off: boostReady = ${boostReady}`);
+            }
+
+            const _setValve = await setValve(entry, false);
+
+            /* Zustand des Ventils im Thread <<< 0 >>> off, < 1 > wait, < 2 > on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
+            entry.state = 'off';
+            const _sprinklerState = await adapter.setStateAsync(`sprinkle.${entry.name}.sprinklerState`, {
+                val: entry.state,
+                ack: true
+            });
+            const _runningTime = adapter.setStateAsync(`sprinkle.${entry.name}.runningTime`, {
+                val: '00:00',
+                ack: true
+            });
+            const _countdown = adapter.setStateAsync(`sprinkle.${entry.name}.countdown`, {
+                val: '0',
+                ack: true
+            });
+            currentConsumption(true);
+            // currentConsumption(entry.pipeFlow, false);
+            Promise.all([
+                _setValve,
+                _sprinklerState,
+                _runningTime,
+                _countdown
+            ]).then(async () => {
+                entry.killSprinkle = true;
+                /* Zeiten löschen */
+                clearInterval(entry.countdown);
+                entry.countdown = null;
+                // entry.ac.acOnOffTimeoutOff.abort(); /// ???
+
+            }).then(()=>{
+                updateList();
+            });
+
+        }
+    } catch (error) {
+        adapter.log.error(`countSprinkleTime(${entry.name}): ${error}`);
+    }
+
+};
+
+/**
+ * Timer zum ausschalten des Boost
+ * 
+ * @param {*} entry 
+ */
+const boostOnTimer = async (entry) => {
+    entry.ac.acBoostOnTimer = new AbortController;
+    const combinedSignal = AbortSignal.any([
+        entry.ac.acBoostOnTimer.signal
+    ]);
+    try {
+        adapter.log.debug(`ID: ${entry.name} boostOnTimer time start`);
+        await asyncTime.setTimeout(30000, undefined, { signal: combinedSignal });
+        boostOn = false;
+        // Zustand des Ventils im Thread < 0 > off, < 1 > wait, <<< 2 >>> on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost)
+        entry.state = 'on';
+        adapter.setStateAsync(`sprinkle.${entry.name}.sprinklerState`, {
+            val: entry.state,
+            ack: true
+        });
+        adapter.log.debug(`ID: ${entry.name} boostOnTimer time out: boostOn = ${boostOn}`);
+        updateList();          
+    } catch (error) {
+        boostOn = false;
+        adapter.log.debug(`ID: ${entry.name} boostOnTimer time out: ERROR: ${error}`);
+        updateList();
+    }finally{
+        if (entry.ac.acBoostOnTimer.aborted === false) entry.ac.acBoostOnTimer.abort();
+    }
+};
+
+/**
+ * Control of the active irrigation circuits so that the maximum pump capacity (l / h) is achieved and the maximum number of irrigation circuits is not exceeded.
+ * => Steuerung der aktiven Bewässerungskreise, damit die maximale Pumpenkapazität (l / h) erreicht wird und die maximale Anzahl der Bewässerungskreise nicht überschritten wird.
+ */
+const updateList = async () => {
+    /* während des Boost eines Kreises ist ein Zuschalten von Sprengern nicht möglich */
+    if (boostOn) return;
+    if (updateListMarker.funcActive === true) {
+        updateListMarker.newStart = true;
+        return;
+    }
+    const killList = [];
+    let consumption = {};
+    /* (timerOn = true) => Schaltabstand zwischen den Ventilen ein */
+    let timerOn = true;
+    // let switchingDistanceOn = false;
+    updateListMarker.funcActive = true;
+
+    /**
+     * Sortierfunktion mySortDescending absteigende Sortierung
+     * 
+     * @param a
+     * @param b
+     * @returns {number}
+     */
+    function mySortDescending(a, b) {
+        return a.pipeFlow > b.pipeFlow ? -1 :
+            a.pipeFlow < b.pipeFlow ? 1 :
+                0;
+    }
+    /**
+     * Sortierfunktion mySortAscending aufsteigende Sortierung
+     * 
+     * @param a
+     * @param b
+     * @returns {number}
+     */
+    function mySortAscending(a, b) {
+        return a.pipeFlow < b.pipeFlow ? -1 :
+            a.pipeFlow > b.pipeFlow ? 1 :
+                0;
+    }
+
+    // ermitteln von curPipe und der Anzahl der parallelen Stränge
+    consumption = await currentConsumption(true);
+    if (consumption.pumpRequired === true) {    // Pumpe erforderlich
+
+        // Spannungsversorgung einschalten bei Leistungsanforderung
+        try {
+            if (adapter.config.triggerControlVoltage
+            && controlVoltage.enable === false) {
+                const _controlVoltage = await setValve(controlVoltage, true);
+                if (_controlVoltage === controlVoltage.idState) {
+                    adapter.setStateAsync(`info.supplyVoltage`, {
+                        val: controlVoltage.enable, 
+                        ack: true
+                    });
+                    await asyncTime.setTimeout(switchingDistanceMS, undefined, undefined);
+                }
+            }                    
+        } catch (error) {
+            adapter.log.error(`Error trigger Control Voltage [${controlVoltage.idState}]: ${error}`);
+        }
+           
+        // Pumpe einschalten bei Leistungsanforderung
+        try {
+            if (adapter.config.pumpSelection !== 'noPump'
+            && currentPumpUse.enable === false) {                
+                const _currentPumpUse = await setValve(currentPumpUse, true);
+                if (_currentPumpUse && _currentPumpUse === currentPumpUse.idState) {
+                    timerOn = false;
+                    adapter.setStateAsync(currentPumpUse.id, {
+                        val: currentPumpUse.enable, 
+                        ack: true
+                    });
+                    await asyncTime.setTimeout(currentPumpUse.leadTime, undefined, undefined);
+                }
+            }                   
+        } catch (error) {
+            adapter.log.error(`Error trigger current Pump [${currentPumpUse.idState}]: ${error}`);
+        }
+    }
+
+    /* - wenn beim Umschalten der Pumpen die Förderleistung zu gering → Ventile deaktivieren - */
+    if (consumption.curFlow < 0) {
+        // aufsteigend sortieren nach der Verbrauchsmenge
+        threadList.sort(mySortAscending);
+
+        for await(const entry of threadList) {
+            entry.ac.acUpdateListPuOff = new AbortController;    // acPumpeOff
+            try {
+                if (entry.enable                        //  eingeschaltet
+                && !entry.killSprinkle                  //  && Aufgabe noch nicht erledigt
+                && (consumption.curFlow < 0)            //  && Förderleistung der Pumpe zu gering
+                ) {
+                    entry.state = 'wait';   //1
+                    const _setValve2 = await setValve(entry, false);
+                    if (_setValve2 === entry.idState) {
+                        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}`);
+                        await asyncTime.setTimeout(300, undefined, {signal: entry.ac.acUpdateListPuOff.signal});
+                    }                    
+                }else{
+                    entry.ac.acUpdateListPuOff.abort();
+                }
+            } catch (error) {   // Fehler beim Reduzieren der Verbrauchsmenge
+                adapter.log.error(`Error reducing consumption amount: ${error}`);
+            } finally {
+                if (entry.ac.acUpdateListPuOff.aborted === false) entry.ac.acUpdateListPuOff.abort();
+            }
+        }
+    }
+
+    adapter.log.info(`curFlow: ${consumption.curFlow}, parallel: ${consumption.parallel}`);
+    // absteigend sortieren nach der Verbrauchsmenge
+    threadList.sort(mySortDescending);
+
+    // einschalten der Bewässerungsventile nach Verbrauchsmenge und maximaler Anzahl
+    for await(const entry of threadList) {
+        try {
+            if (!entry.enable                                                   // ausgeschaltet
+            && !entry.killSprinkle                                              // && Aufgabe noch nicht erledigt
+            && !entry.myBreak                                                   // && nicht in der Pause Interval-Beregnung
+            && !entry.extBreak                                                  // && nicht in der externen Pause (extBreak)
+            && (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 
+            && (boostReady  || !(myConfig.config[entry.sprinkleID].booster))    // && wenn kein Boostventil aktive ist => alle Ventile ein ansonsten nur Ventile ohne Boostfunktion
+            ){
+                entry.ac.acUpdateListOn = new AbortController;
+
+                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) {
+                    consumption = await currentConsumption(true);
+                    if (myConfig.config[entry.sprinkleID].booster) {
+                        boostReady = false;
+                        boostOn = true;
+                        boostOnTimer(entry);
+                        adapter.log.debug(`ID: ${entry.name} UpdateList sprinkle On: boostReady = ${boostReady}`);
+                    }
+
+                    /* countdown starten */
+                    if (!entry.startTime) {
+                        entry.startTime = new Date();
+                    }
+                    adapter.log.debug(`!entry.countdown: ${!entry.countdown}, type: ${typeof(entry.countdown)}`);
+                    if(!entry.countdown){
+                        entry.countdown = setInterval(countSprinkleTime, 1000, entry); // 1000 = 1s
+                        //entry.countdown = asyncTime.setInterval();
+                    }                                    
+                } else {
+                    entry.ac.acUpdateListOn.abort();
+                }
+            }
+        } catch (error) {   //Fehler beim Einschalten der Bewässerungsventile
+            adapter.log.error(`Error turning on irrigation valves [${entry.name}]: ${error}`);
+        }
+    }
+
+    // Ausschalten der Ventile bei boostReady
+    if (boostOn) {
+        for await(const entry of threadList){
+            entry.ac.acUpdateListBoostOn = new AbortController;
+            try {
+                if(entry.enable                                 // eingeschaltet
+                && !entry.killSprinkle
+                && !myConfig.config[entry.sprinkleID].booster
+                ){
+                    entry.state = 'off(Boost)';    //state => 5/off(boost)
+                    const _setValve4 = await setValve(entry, false);
+                    if (_setValve4 === entry.idState){
+                        consumption = await currentConsumption(true);
+                        clearInterval(entry.countdown);
+                        entry.countdown = null;
+                        await asyncTime.setTimeout(300, undefined, {signal: entry.ac.acUpdateListBoostOn.signal});    
+                    }                    
+                }    
+            } catch (error) {
+                entry.ac.acUpdateListBoostOn.abort();
+                adapter.log.error(`Error when switching off the valves with boostReady [${entry.name}]: ${error}`);
+            } finally {
+                if (entry.ac.acUpdateListBoostOn.aborted === false) entry.ac.acUpdateListBoostOn.abort();
+            }
+        }
+    }
+
+    if (consumption.parallel === 0) {    // Pumpe nicht mehr erforderlich | 0 Ventile an
+
+        // Pumpe ausschalten
+        if (currentPumpUse.enable === true) {
+            try {
+                const _currentPumpUse = await setValve(currentPumpUse, false);
+                if (_currentPumpUse === currentPumpUse.idState) {
+                    adapter.setStateAsync(currentPumpUse.id,{
+                        val: currentPumpUse.enable, 
+                        ack: true
+                    });
+                    await asyncTime.setTimeout(switchingDistanceMS, undefined, undefined);
+                }                 
+            } catch (error) {
+                adapter.log.error(`Error trigger current Pump [${currentPumpUse.idState}]: ${error}`);
+            }            
+        }
+
+        // Spannungsversorgung (24V) ausschalten
+        if(controlVoltage.enable === true) {
+            try {
+                const _controlVoltage = await setValve(controlVoltage, false);
+                if (_controlVoltage === controlVoltage.idState) {
+                    adapter.setStateAsync(`info.supplyVoltage`, {
+                        val: controlVoltage.enable, 
+                        ack: true
+                    });
+                    // await asyncTime.setTimeout(switchingDistanceMS, undefined, undefined);
+
+                }                
+            } catch (error) {
+                adapter.log.error(`Error trigger Control Voltage [${controlVoltage.idState}]: ${error}`);
+            }       
+        }
+    }
+
+    for await(const entry of threadList){
+        if(entry.killSprinkle
+            && !entry.enable
+        ){
+            killList.push(entry.name);
+        }
+    }
+
+    if (killList.length > 0) {
+        await delList(killList);      // erledigte Bewässerungsaufgaben aus der threadList löschen
+        await asyncTime.setTimeout(50,undefined,undefined);
+    }
+
+    updateListMarker.funcActive = false;
+    if (updateListMarker.newStart === true) {
+        updateListMarker.newStart = false;
+        await asyncTime.setTimeout(50,undefined,undefined);
+        updateList();
+    }
+
+}; // End updateList
+
+/* --------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
+
+/**
+ * +++++  Set the current pump for irrigation  +++++
+ * → Festlegen der aktuellen Pumpe zur Bewässerung
+ */
+const setActualPump = async () => {
+    try {
+        switch(adapter.config.pumpSelection) {
+            case 'noPump':
+            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}%`) : ('')}`):('')}`,
+                        ack: true
+                    });
+                }
+                break;
+            }
+
+            case 'cistern': {
+                if (fillLevelCistern < parseFloat(adapter.config.triggerMinCisternLevel)) {     //  (Zisterne unter Minimum)
+                    if (!currentPumpUse.intBreak) {
+                        currentPumpUse.intBreak = true;
+                        adapter.log.warn('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
+                    }
+                } 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
+                        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
+                    });
+                }
+                break;
+            }
+
+            case 'pumpAndCistern': {
+                if (currentPumpUse.enable) {
+                /* Bewässerungspumpen aktiv */
+                    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) {
+                            await adapter.setStateAsync(currentPumpUse.id, {      // set State cisternPump === false
+                                val: currentPumpUse.enable, 
+                                ack: true
+                            });
+                        }
+                        currentPumpUse.pumpCistern = false;
+                        currentPumpUse.name = 'Main pump';
+                        currentPumpUse.idState = adapter.config.triggerMainPump || '';
+                        currentPumpUse.id = 'info.mainPump';
+                        currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower);
+                        /* Hauptpumpe Ein */
+                        const _setValveMainPumpOn = await setValve(currentPumpUse, true);   
+                        if (_setValveMainPumpOn === currentPumpUse.idState) {
+                            await adapter.setStateAsync(currentPumpUse.id, {      // set State cisternPump === false
+                                val: currentPumpUse.enable, 
+                                ack: true
+                            });
+                        }
+                        adapter.log.info('Pump change (cistern empty) Cistern pump off => main pump on');
+                        if(!sendMessageText.onlySendError()){
+                            sendMessageText.sendMessage('Pump change (cistern empty) Cistern pump off => main pump on');
+                        }
+                        updateList();   // Wasserverbrauch an Pumpenleistung anpassen
+                    }
+                } 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.idState = adapter.config.triggerCisternPump || '';
+                        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.idState = adapter.config.triggerMainPump || '';
+                        currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower);
+                    }
+                    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
+                    });
+                }
+                break;
+            }
+        }   
+    } catch (error) {
+        adapter.log.error(`setActualPump ${error}`);
+    }
+};   // End setActualPump
+
+
+/**
+ * Adding the consumption data to the history
+ * => Hinzufügen der Verbrauchsdaten zur History
+ * 
+ * @param entry - array mit den Daten des aktiven Ventils
+ */
+function addConsumedAndTime(entry) {
+    adapter.setState(`sprinkle.${entry.name}.history.lastConsumed`, {
+        val: Math.round(entry.litersPerSecond * entry.count),
+        ack: true
+    });
+    adapter.setState(`sprinkle.${entry.name}.history.lastRunningTime`, {
+        val: addTime(entry.count, ''),
+        ack: true
+    });
+    const _formatTime = formatTime(entry.startTime);
+    adapter.setState(`sprinkle.${entry.name}.history.lastOn`, {
+        val: _formatTime.dayTime,
+        ack: true
+    });
+    adapter.getState(`sprinkle.${entry.name}.history.curCalWeekConsumed`, (err, state) => {
+        if (state && state.val) {
+            adapter.setState(`sprinkle.${entry.name}.history.curCalWeekConsumed`, {
+                val: (+state.val) + Math.round(entry.litersPerSecond * entry.count),
+                ack: true
+            });
+        }
+    });
+    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),
+                ack: true
+            });
+        }
+    });
+}   // End addConsumedAndTime
+
+
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*                                                       externe Funktionen                                                                     */
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+
+/**
+ * -- externe Funktionen -> initValveControl - addList - extBreak - clearEntireList - setFillLevelCistern --
+ */
+const valveControl = {
+    /**
+     * Initialize the start configuration of ventilControl
+     * => Initialisieren Sie die Startkonfiguration von ventilControl
+     * 
+     * @param {ioBroker.Adapter} myAdapter
+     */
+    initValveControl: async function (myAdapter) {
+        adapter = adapter || myAdapter;
+
+        try {
+            switchingDistanceMS = (
+                (+adapter.config.switchingDistance || 0) < 200)
+                    ? 200
+                    : (
+                    (+adapter.config.switchingDistance > 240000)
+                        ? 240000
+                        : (+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
+                await adapter.setObjectNotExistsAsync(`info.supplyVoltage`, {
+                    type: 'state',
+                    common: {
+                        role:  'switch',
+                        name:  'Supply voltage',
+                        desc:  {
+                            en: 'power supply',
+                            de: 'Stromversorgung',
+                            ru: 'источник питания',
+                            pt: 'fonte de energia',
+                            nl: 'voeding',
+                            fr: 'alimentation électrique',
+                            it: 'Alimentazione elettrica',
+                            es: 'fuente de alimentación',
+                            pl: 'zasilacz',
+                            uk: 'джерело живлення',
+                           'zh-cn': '电源'
+                        },
+                        type:  'boolean',
+                        read:  true,
+                        write: false,
+                        def:   false
+                    },
+                    native: {},
+                });
+            } else {
+                const _supplyVoltage = await adapter.getObjectAsync(`info.supplyVoltage`);
+                if (_supplyVoltage) await adapter.delObjectAsync(`info.supplyVoltage`);
+            }
+            
+    
+            /* Objekt control.parallelOfMax befüllen */
+            maxParallel = parseInt(adapter.config.maximumParallelValves);
+            adapter.setStateAsync('control.parallelOfMax', {
+                val: `0 : ${adapter.config.maximumParallelValves}`,
+                ack: true
+            });
+
+            /* Object mainPump und Cistern anlegen, wenn benötigt */
+            const objMainPump = {
+                type: 'state',
+                common: {
+                    role:  'indicator',
+                    name:  'Main pump',
+                    desc:  {
+                        en: 'Main pump',
+                        de: 'Hauptpumpe',
+                        ru: 'Главный насос',
+                        pt: 'Bomba principal',
+                        nl: 'Hoofdpomp',
+                        fr: 'Pompe principale',
+                        it: 'Pompa principale',
+                        es: 'Bomba principal',
+                        pl: 'Główna pompa',
+                        uk: 'Головний насос',
+                       'zh-cn': '主泵'
+                    },
+                    type:  'boolean',
+                    read:  true,
+                    write: false,
+                    def:   false
+                },
+                native: {},
+            };
+            const objCisternPump = {
+                type: 'state',
+                common: {
+                    role:  'indicator',
+                    name:  'Cistern pump',
+                    desc:  {
+                        en: 'Cistern pump',
+                        de: 'Zisternenpumpe',
+                        ru: 'Насос для цистерны',
+                        pt: 'Bomba da cisterna',
+                        nl: 'Cisternpomp',
+                        fr: 'Pompe de citerne',
+                        it: 'Pompa cisterna',
+                        es: 'Bomba de cisterna',
+                        pl: 'Pompa zbiornika',
+                        uk: 'Насос цистерни',
+                       'zh-cn': '水箱泵'
+                    },
+                    type:  'boolean',
+                    read:  true,
+                    write: false,
+                    def:   false
+                },
+                native: {},
+            };
+
+            switch (adapter.config.pumpSelection) {
+                case 'noPump': {
+                    currentPumpUse.pumpCistern = false;
+                    currentPumpUse.name = 'no pump';
+                    currentPumpUse.intBreak = false;
+                    currentPumpUse.idState = '';
+                    currentPumpUse.id = '';
+                    currentPumpUse.leadTime = 0;
+                    currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower) || 0;
+                    currentPumpUse.restFlow = parseInt(adapter.config.triggerMainPumpPower) || 0;
+                    const _mainPump = await adapter.getObjectAsync(`info.mainPump`);
+                    if (_mainPump) await adapter.delObjectAsync(`info.mainPump`);
+                    const _cisternPump = await adapter.getObjectAsync(`info.cisternPump`);
+                    if (_cisternPump) await adapter.delObjectAsync(`info.cisternPump`);
+                    break;
+                }
+                case 'mainPump': {
+                    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;
+                    currentPumpUse.restFlow = parseInt(adapter.config.triggerMainPumpPower) || 0;
+                    // @ts-ignore
+                    await adapter.setObjectNotExistsAsync(`info.mainPump`, objMainPump);
+                    const _cisternPump = await adapter.getObjectAsync(`info.cisternPump`);
+                    if (_cisternPump) await adapter.delObjectAsync(`info.cisternPump`);
+                    break;
+                }
+                case 'cistern': {
+                    /*     Füllstand der Zisterne in % holen     */
+                    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;
+                        } else if (typeof _actualValueLevel.val === 'boolean') {
+                            if (_actualValueLevel.val) {
+                                currentPumpUse.intBreak = false;
+                                fillLevelCistern = 100;
+                            } else {
+                                currentPumpUse.intBreak = true;
+                                fillLevelCistern = 0;
+                            }
+                        } else {
+                            adapter.log.warn(`level sensor in the cistern => Wrong value: ${_actualValueLevel.val}, Type: ${typeof _actualValueLevel.val}`);
+                        }
+                    } else {
+                        adapter.log.warn(`level sensor in the cistern => Wrong value: ${JSON.stringify(_actualValueLevel)}`);
+                        fillLevelCistern = 0;
+                        currentPumpUse.intBreak = true;
+                    }
+                    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;
+                    currentPumpUse.restFlow = parseInt(adapter.config.triggerCisternPumpPower) || 0;
+                    // @ts-ignore
+                    await adapter.setObjectNotExistsAsync(`info.cisternPump`, objCisternPump);
+                    const _mainPump = await adapter.getObjectAsync(`info.mainPump`);
+                    if (_mainPump) await adapter.delObjectAsync(`info.mainPump`);
+                    break;
+                }
+                case 'pumpAndCistern': {
+                    currentPumpUse.enable = false;
+                    if (adapter.config.actualValueLevel) {
+                        /*     Füllstand der Zisterne in % holen     */
+                        const _actualValueLevel = await adapter.getForeignStateAsync(adapter.config.actualValueLevel);
+                        if (_actualValueLevel && _actualValueLevel.val) {
+                            if (typeof _actualValueLevel.val === 'number') {
+                                fillLevelCistern = _actualValueLevel.val;
+                            } else if (typeof _actualValueLevel.val === 'boolean') {
+                                _actualValueLevel.val ? fillLevelCistern = 100 : fillLevelCistern = 0;
+                            } else {
+                                fillLevelCistern = 0;
+                                adapter.log.warn(`level sensor in the cistern => Wrong value: ${_actualValueLevel.val}, Type: ${typeof _actualValueLevel.val}`);
+                            }
+                        }
+
+                        if (fillLevelCistern > parseInt(adapter.config.triggerMinCisternLevel)) {
+                            currentPumpUse.pumpCistern = true;
+                            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;
+                            currentPumpUse.restFlow = parseInt(adapter.config.triggerCisternPumpPower) || 0;
+                        } else {
+                            currentPumpUse.pumpCistern = false;
+                            currentPumpUse.name = 'Main pump';
+                            currentPumpUse.idState = adapter.config.triggerMainPump || '';
+                            currentPumpUse.id = 'info.mainPump';
+                            currentPumpUse.leadTime = (parseInt(adapter.config.mainPumpLeadTime) || 5) * 1000;
+                            currentPumpUse.pumpPower = parseInt(adapter.config.triggerMainPumpPower) || 0;
+                            currentPumpUse.restFlow = parseInt(adapter.config.triggerMainPumpPower) || 0;
+                        }
+
+                        currentPumpUse.intBreak = false;
+                    }
+                    // @ts-ignore
+                    await adapter.setObjectNotExistsAsync(`info.mainPump`, objMainPump);
+                    // @ts-ignore
+                    await adapter.setObjectNotExistsAsync(`info.cisternPump`, objCisternPump);
+                    break;
+                }
+                default: {
+                    currentPumpUse.intBreak = true;
+                    adapter.log.error(`In the configuration, under Pump settings, select the Pump selection field.`);
+                    const _mainPump = await adapter.getObjectAsync(`info.mainPump`);
+                    if (_mainPump) await adapter.delObjectAsync(`info.mainPump`);
+                    const _cisternPump = await adapter.getObjectAsync(`info.cisternPump`);
+                    if (_cisternPump) await adapter.delObjectAsync(`info.cisternPump`);
+                    break;
+                }
+            }
+            /* Objekt control.restFlow befüllen */
+            adapter.setStateAsync('control.restFlow', {
+                val: `${currentPumpUse.pumpPower} (${currentPumpUse.pumpPower} | ${currentPumpUse.name})`,
+                ack: true
+            });
+    
+            /*Pumpe ausschalten*/
+            currentPumpUse.enable = false;
+            /* 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, {
+                        val: false,
+                        ack: false
+                    });
+                    adapter.setStateAsync('info.mainPump', {
+                        val:false, 
+                        ack:false
+                    });
+                }
+            }
+            /* 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, {
+                        val: false,
+                        ack: false
+                    });
+                    adapter.setStateAsync('info.cisternPump', {
+                        val:false, 
+                        ack:false
+                    });
+                }
+            }
+            /* alle Ventile (.name = "hm-rpc.0.MEQ1234567.3.STATE") in einem definierten Zustand (false) versetzen*/
+            const result = adapter.config.events;
+            let testMaxFlow;
+            if (adapter.config.pumpSelection === 'pumpAndCistern') {
+                testMaxFlow = (parseFloat(adapter.config.triggerCisternPumpPower) > parseFloat(adapter.config.triggerMainPumpPower)) ? parseFloat(adapter.config.triggerCisternPumpPower) : parseFloat(adapter.config.triggerMainPumpPower);
+            } else {
+                testMaxFlow = currentPumpUse.pumpPower;
+            }
+            if (result) {
+                for (const res of result) {
+                    const objectName = (res.name !== '') ? res.name.replace(/[.;, ]/g, '_') : res.name.replace(/[.;, ]/g, '_');
+                    const _valve = await adapter.getStateAsync(res.name);
+                    if (_valve?.val === true) {
+                        await adapter.setStateAsync(res.name, {
+                            val: false,
+                            ack: false
+                        });
+                    }
+                    /*Kontrolle Flow Pumpe > Flow Ventil*/
+                    if (testMaxFlow < parseInt(res.pipeFlow)) {
+                        adapter.log.warn(`The irrigation circuit ${objectName} cannot start! pipeFlow ${res.pipeFlow} > maxFlow ${testMaxFlow}! logicError in the configuration`);
+                    }
+                }
+            }
+        } catch (error) {
+            adapter.log.error(`initValveControl ERROR: ${error}`);
+        }
+
+    },  // End initValveControl
+
+    /**
+     *  Add Sprinkle
+     * → Sprinkle hinzufügen
+     * - auto → Automatik == (true), Handbetrieb == (false)
+     * - sprinkleID → zugriff auf myConfig.config[sprinkleID]. xyz
+     * - wateringTime → Bewässerungszeit in min
+     * 
+     * @param {Array.<{auto: boolean, sprinkleID: number, wateringTime: number}>} sprinkleList
+     */
+    addList: async function (sprinkleList) {
+        try {
+            if (adapter.config.pumpSelection === 'pumpAndCistern'
+                && currentPumpUse.enable === false
+                && fillLevelCistern > parseFloat(adapter.config.triggerMinCisternLevel)
+            ){
+                await setActualPump();
+            }
+            for await (const res of sprinkleList) {
+                const name = myConfig.config[res.sprinkleID].objectName;
+                /**
+                 * add done
+                 * → hinzufügen erledigt (Sprenger bereits aktive)
+                 * 
+                 */
+                let addDone = false;
+                // schauen ob der Sprenger schon in der threadList ist
+                if (threadList) {
+                    for await (const entry of threadList) {
+                        if (entry.sprinkleID === res.sprinkleID) {
+                            if (entry.wateringTime === res.wateringTime) {
+                                return;
+                            }
+                            entry.wateringTime = res.wateringTime;
+                            entry.autoOn = res.auto; // auto: = true autostart; = false Handbetrieb
+                            await adapter.setStateAsync(`sprinkle.${name}.runningTime`, {
+                                val: addTime(res.wateringTime, ''),
+                                ack: true
+                            });
+                            addDone = true; // Sprinkle found
+                            adapter.log.debug(`update ID: ${entry.name} new time: ${addTime(res.wateringTime, '')}`);
+                            break;
+                        }
+                    }
+                }
+
+                if (!addDone) {
+                    if (res.wateringTime <= 0) {
+                        adapter.setState(`sprinkle.${name}.runningTime`, {
+                            val: '00:00',
+                            ack: true
+                        });
+                        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.wateringTime = res.wateringTime; // Bewässerungszeit 
+                        newThread.pipeFlow = myConfig.config[res.sprinkleID].pipeFlow; // Wasserverbrauch 
+                        newThread.count = 0; // Zähler im Sekundentakt 
+                        newThread.calcOn = (myConfig.config[res.sprinkleID].methodControlSM === 'calculation'); //  Anpassung der Bodenfeuchte true/false
+                    if (newThread.calcOn) {
+                        newThread.soilMoisture15s = 15 * (myConfig.config[res.sprinkleID].calculation.maxIrrigation - myConfig.config[res.sprinkleID].calculation.triggersIrrigation)
+                        / (60 * myConfig.config[res.sprinkleID].wateringTime);
+                    }
+                    /**  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.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 
+                        newThread.onOffTimeOff = myConfig.config[res.sprinkleID].wateringIntervalOff; 
+                        newThread.onOffTimeOn = myConfig.config[res.sprinkleID].wateringIntervalOn; 
+                        newThread.autoOn = res.auto; 
+                        newThread.controller = {};   // controlle von Zeiten und Abbruchsignalen 
+                        newThread.ac = {};           // object zum speichern des abortController 
+                        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');
+                    adapter.setState(`sprinkle.${name}.sprinklerState`, {
+                        val: newThread.state,
+                        ack: true
+                    });
+                    adapter.setState(`sprinkle.${name}.runningTime`, {
+                        val: addTime(res.wateringTime, ''),
+                        ack: true
+                    });
+                    adapter.log.debug(`ID: ${name} new order created: ${JSON.stringify(threadList[newThread.id])}`);
+                }
+            }
+            updateList();
+        } catch (error) {
+            adapter.log.warn(`valveControl.addList: ${JSON.stringify(sprinkleList)} => ${error}`);
+        }
+
+    }, // End addList
+
+    /**
+     * extBreak => Spränger unterbrechen bei extBreak
+     * 
+     * @param {number} sprinkleID
+     * @param {boolean} extBreak
+     * @returns {Promise<{val: boolean}>} val: true/false = Ventil gefunden / nicht gefunden
+     */
+    extBreak: async function (sprinkleID, extBreak) {
+        try {
+            const _found = await findAsync(threadList, async (d) => {
+                                return Promise.resolve (d.sprinkleID === sprinkleID);
+                            });
+
+            if (_found?.sprinkleID === sprinkleID) {
+                _found.extBreak = extBreak;
+                if (extBreak === true) {    // extBreak aktiv
+                    if (_found.enable === true) {                           // Ventil ist eingeschaltet
+                        const _setValve = await setValve(_found, false);
+                        if (_setValve === _found.idState) {
+                            _found.state = 'extBreak';                      // <<< 7 >>> extBreak
+                            clearInterval(_found.countdown);                // Timer Countdown löschen
+                            _found.countdown = null;
+                            /* Booster zurücksetzen */
+                            if (myConfig.config[_found.sprinkleID].booster) {
+                                _found.ac.acBoostOnTimer.abort(extBreak);
+                                boostReady = true;
+                                boostOn = false;
+                                adapter.log.debug(`ID: ${_found.name} UpdateList Sprinkle Off: boostReady = ${boostReady}`);
+                            }
+                        }
+                    } else {                                                // Ventil ist in bereitschaft, aber extBreak wird aktiviert
+                        _found.state = 'extBreak';                          // <<< 7 >>> extBreak
+                    }
+                } else {
+                    // extBreak beendet und Zeit noch nicht abgelaufen?
+                    (_found.count < _found.wateringTime) ? (_found.state = 'wait') : (_found.state = 'off');     // (Bewässerung noch nicht erledigt) ? (< 0 > off) : (< 1 > wait)
+                }
+                /* Zustand des Ventils im Thread < 0 > off, < 1 > wait, < 2 > on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost), < 6 > Cistern empty, <<< 7 >>> extBreak */
+                await adapter.setStateAsync(`sprinkle.${_found.name}.sprinklerState`, {
+                    val: _found.state,
+                    ack: true
+                });
+                adapter.log.debug(`valveControl.extBreak: ${extBreak}, Name: ${_found.name}, ID: ${_found.sprinkleID}`);   // löschen
+                updateList();
+                return {val: true};
+            } else {
+                return {val: false};
+            }
+        } catch (error) {
+            adapter.log.warn(`valveControl.extBreak(${sprinkleID}, ${extBreak}) => ${error}`);
+            return {val: false};
+        }
+    },
+
+    /**
+     * switch off all devices, when close the adapter
+     * => Beim Beenden des adapters alles ausschalten
+     */
+    clearEntireList: async function () {
+        try {
+            await setValve(controlVoltage, false);
+            await setValve(currentPumpUse, false);
+            // let bValveFound = false;	// Ventil gefunden
+            for (let counter = threadList.length - 1;	// Loop über das Array
+                counter >= 0;
+                counter--) {
+                const entry = threadList[counter];
+                /* Zustand des Ventils im Thread <<< 0 >>> off, < 1 > wait, < 2 > on, < 3 > break, < 4 > Boost(on), < 5 > off(Boost) */
+                entry.state = 'off';    //0
+                if (entry.enable) {
+                    await setValve(entry, false);
+                    adapter.log.info(`Set Valve (SprinkleControl: off) ID: ${entry.name}, value: false`);
+                } else {
+                    adapter.setStateAsync(`sprinkle.${entry.name}.sprinklerState`, {
+                        val: entry.state,
+                        ack: true
+                    });                    
+                }
+                adapter.setStateAsync(`sprinkle.${entry.name}.runningTime`, {
+                    val: '00:00',
+                    ack: true
+                });
+                adapter.setStateAsync(`sprinkle.${entry.name}.countdown`, {
+                    val: '0',
+                    ack: true
+                });
+                /* Verbrauchswerte in der Historie aktualisieren */
+                addConsumedAndTime(entry);
+                /* del timer countdown */
+                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
+
+                adapter.log.debug(`order deleted Stop all ID: ${entry.name} ( rest orders: ${threadList.length} )`);
+                threadList.pop();   // del last array
+            }
+            boostReady = true;
+            boostOn = false;
+            const _currentConsumption = await currentConsumption(true);
+            if (_currentConsumption.parallel > 0) throw new Error(`clearEntireList: Not all valves in the list have been deleted`);        // Nicht alle Ventile in der Liste wurden gelöscht
+            return true;
+        } catch (error) {
+            if (error) {
+                adapter.log.warn(`valveControl.clearEntireList() => ${error}`);
+            }
+            return false;
+        }
+        
+    }, // End clearEntireList
+
+    /**
+     * Änderungen des Füllstands setzen + Vorrang der Pumpe setzen
+     * 
+     * @param {number|string|boolean} levelCistern
+     */
+    setFillLevelCistern: function (levelCistern) {
+        adapter.log.debug(`setFillLevelCistern: ${levelCistern}`);
+        if(typeof levelCistern === 'number') {
+            fillLevelCistern = levelCistern;
+        }else if(typeof levelCistern === 'string') {
+            fillLevelCistern = parseFloat(levelCistern);
+        }else if(typeof levelCistern === 'boolean') {
+            (levelCistern === true) ? fillLevelCistern = 100 : fillLevelCistern = 0;
+        }
+        setActualPump();
+    },   // End setFillLevelCistern
+
+    /**
+     * Abfrage von intBreak der Zisternenpumpe
+     * 
+     * @returns {boolean} intBreak
+     */
+    getIntBreakCisternPump: function () {
+       return (adapter.config.pumpSelection === 'cistern') ? currentPumpUse.intBreak : false;
+    }
+
+};  // End valveControl
+
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+
+module.exports = {
+    valveControl,
+    controlVoltage,
+    currentPumpUse,
+    threadList
+};