iobroker.sprinklecontrol 0.2.10 → 0.2.13

package/main.js

@@ -1,7 +1,5 @@
 'use strict';
-/*
- info:  log aufbau main.js: #0.*
- */
+
 // Load your modules here, e.g.: => // Laden Sie Ihre Module hier, z.B.
 // const fs = require("fs");
 
@@ -29,19 +27,27 @@ const adapterName = require('./package.json').name.split('.').pop();
 let publicHolidayStr;
 /** @type {any} */
 let publicHolidayTomorrowStr;
-/* DasWetter.com */
+/* Regenvorhersage - DasWetter.com */
+/** @type {string}
+ * - Pfad zur Regenvorhersage in mm */
+let weatherForecastTodayPfadStr;
 /** @type {number}
  * - heutige Regenvorhersage in mm */
 let weatherForecastTodayNum = 0;
 /** @type {number}
  * - morgige Regenvorhersage in mm */
 let weatherForecastTomorrowNum = 0;
+/** @type {boolean}
+ * - Externer Schalter für Zusatzbewässerung */
+let addStartTimeSwitch = false;
 
 /** @type {string} */
 let startTimeStr;
 /** @type {string} */
 let sunriseStr;
 /** @type {string} */
+let sunsetStr;
+/** @type {string} */
 let goldenHourEnd;
 /** switch => sprinklecontrol.*.control.Holiday
  *  - Wenn (Holiday == true) ist, soll das Wochenendprogramm gefahren werden.
@@ -73,7 +79,13 @@ function startAdapter(options) {
     adapter = new utils.Adapter(options);
 
     // start here!
-    adapter.on('ready', () => main(adapter));
+    adapter.on('ready', () => {
+        // init createConfig
+        myConfig.createConfig(adapter);
+        // Hauptpumpe zur Bewässerung setzen
+        valveControl.initValveControl(adapter);
+        main(adapter)
+    });
 
     /**
      * +++++++++++++++++++++++++ is called when adapter shuts down +++++++++++++++++++++++++
@@ -94,6 +106,7 @@ function startAdapter(options) {
             /*Startzeiten der Timer löschen*/
             schedule.cancelJob('calcPosTimer');
             schedule.cancelJob('sprinkleStartTime');
+            schedule.cancelJob('sprinkleAddStartTime');
             /* alle Ventile und Aktoren deaktivieren */
             valveControl.clearEntireList();
 
@@ -108,7 +121,7 @@ function startAdapter(options) {
      * -------------- Antwortet bei Aufrufen von getTelegramUser von index_m ---------------
      * @param {object} obj
      */
-    adapter.on('message', (obj) => {
+    adapter.on ('message', (obj) => {
         if (obj) {
             switch (obj.command) {
                 case 'getTelegramUser':
@@ -156,14 +169,30 @@ function startAdapter(options) {
             adapter.log.debug(`state ${id} changed: ${state.val} (ack = ${state.ack})`);
 
             // wenn (Holiday == true) ist, soll das Wochenendprogramm gefahren werden.
-            if (id === adapter.namespace + '.control.Holiday') {
+            if (id === adapter.namespace + '.control.Holiday' && state.ack === false) {
                 holidayStr = state.val;
+                adapter.setState(id, {
+                    val: state.val,
+                    ack: true
+                });
                 startTimeSprinkle();
             }
+            // wenn (addStartTimeSwitch == true) wird die zusätzliche Bewässerung aktiviert
+            if (id === `${adapter.namespace}.control.addStartTimeSwitch` && typeof state.val === 'boolean' && state.ack === false) {
+                addStartTimeSwitch = state.val;
+                adapter.setState(id, {
+                    val: state.val,
+                    ack: true
+                });
+            }
             // wenn (autoOnOff == false) so werden alle Sprenger nicht mehr automatisch gestartet.
-            if (id === adapter.namespace + '.control.autoOnOff') {
+            if ((id === adapter.namespace + '.control.autoOnOff') && (state.ack === false)) {
                 autoOnOffStr = state.val;
                 adapter.log.info(`startAdapter: control.autoOnOff: ${state.val}`);
+                adapter.setState(id, {
+                    val: state.val,
+                    ack: true
+                });
                 if (!state.val) {
                     valveControl.clearEntireList();
                 }
@@ -182,11 +211,15 @@ function startAdapter(options) {
                                     sprinkleID: found.sprinkleID,
                                     wateringTime: (state.val <= 0) ? state.val : Math.round(60 * state.val)
                                 }]);
+                            adapter.setState(id, {
+                                val: state.val,
+                                ack: true
+                            });
                         }
                     }
                 }
             }
-            // wenn in der config unter methodControlSM !== 'analog' oder 'bistable' eingegeben wurde, dann Bodenfeuchte-Sensor auslesen
+            // wenn in der config unter methodControlSM!== 'analog' oder 'bistable' eingegeben wurde, dann Bodenfeuchte-Sensor auslesen
             if (myConfig.config) {
                 function filterByID(obj){
                     return (((obj.methodControlSM === 'analog') || (obj.methodControlSM === 'bistable')) && (obj.triggerSM === id));
@@ -205,13 +238,42 @@ function startAdapter(options) {
                     }
                 }
             }
-
             // wenn (...sprinkleName.autoOn == false[off])  so wird der aktuelle Sprenger [sprinkleName]
             //   bei false nicht automatisch gestartet
-            if (myConfig.config && (typeof state.val === 'boolean')) {
+            if (myConfig.config && (typeof state.val === 'boolean') && (state.ack === false)) {
                 const found = myConfig.config.find(d => d.autoOnID === id);
-                if (found && id === myConfig.config[found.sprinkleID].autoOnID) { myConfig.config[found.sprinkleID].autoOn = state.val; }
+                if (found && id === myConfig.config[found.sprinkleID].autoOnID) {
+                    myConfig.config[found.sprinkleID].autoOn = state.val;
+                    adapter.setState(id, {     // Bestätigung
+                        val: state.val,
+                        ack: true
+                    });
+                    adapter.log.info(`set ${found.objectName}.autoOn = ${state.val}, id: ${id}`);
+                    if (state.val === false) {
+                        valveControl.addList(
+                            [{
+                                auto: false,
+                                sprinkleID: found.sprinkleID,
+                                wateringTime: 0
+                            }]
+                        );
+                    }
+                }
             }
+
+            //  postponeByOneDay → um einen Tag verschieben bei fixDay (twoNd & threeRd)
+            let idSplit = id.split('.', 5);
+            if (idSplit[4] === `postponeByOneDay` && state.ack === false) {
+                const found = myConfig.config.find(d => d.objectName === idSplit[3]);
+                if (found) {
+                    myConfig.postponeByOneDay(found.sprinkleID).catch((e) => {adapter.log.warn(`postponeByOneDay: ${e}`)});
+                    adapter.setState(id, {
+                        val: false,
+                        ack: true
+                    });
+                }
+            }
+
             // Change in outside temperature → Änderung der Außentemperatur
             if (id === adapter.config.sensorOutsideTemperature) {	/*Temperatur*/
                 if (!Number.isNaN(Number.parseFloat(state.val))) {
@@ -267,7 +329,7 @@ function startAdapter(options) {
             }
             // Wettervorhersage
             if (adapter.config.weatherForecast === true) {
-                if (id === adapter.config.weatherForInstance + '.NextDaysDetailed.Location_1.Day_1.rain_value') {
+                if (id === weatherForecastTodayPfadStr) {
                     if (typeof state.val == 'string') {
                         weatherForecastTodayNum = parseFloat(state.val);
                     } else if (typeof state.val == 'number') {
@@ -320,7 +382,7 @@ async function GetSystemData() {
 
                 adapter.log.debug(`longitude: ${adapter.config.longitude} | latitude: ${adapter.config.latitude}`);
             } else {
-                adapter.log.error('system settings cannot be called up. Please check configuration!');
+                adapter.log.error('system settings cannot be called up. Please check the geo data');
             }
         } catch (err) {
             adapter.log.warn('system settings cannot be called up. Please check configuration!');
@@ -340,11 +402,12 @@ function curNextFixDay (sprinkleID, returnOn) {
     const weekDayArray = myConfig.config[sprinkleID].startFixDay;
     const objPfad = 'sprinkle.' + myConfig.config[sprinkleID].objectName;
     const weekday = ['Sun','Mon','Tue','Wed','Thur','Fri','Sat'];
+    let found = false;
     let curDay = formatTime(adapter, '', 'day');
     for ( let i=0; i<7; i++ ) {
-        curDay++;
         if (curDay > 6) {curDay = curDay - 7;}
         if (weekDayArray[curDay] === true) {
+            found = true;
             if (returnOn) {
                 return weekday[curDay];
             } else {
@@ -355,7 +418,9 @@ function curNextFixDay (sprinkleID, returnOn) {
             }
             break;
         }
+        curDay++;
     }
+    if (returnOn && found === false) {return 'off'}
 }
 
 //
@@ -364,7 +429,6 @@ function curNextFixDay (sprinkleID, returnOn) {
  * → Setzt den Status beim Start auf einen definierten Wert
  */
 function checkStates() {
-    //
     /**
      * control.Holiday
      * @param {string|null} err
@@ -381,7 +445,9 @@ function checkStates() {
      * @param {ioBroker.State|null|undefined} state
      */
     adapter.getState('control.autoOnOff', (err, state) => {
-        if (state && (state.val == null)) {
+        if (state && (typeof state.val === "boolean")) {
+            autoOnOffStr = state.val;
+        } else {
             autoOnOffStr = true;
             adapter.setState('control.autoOnOff', {
                 val: autoOnOffStr,
@@ -422,21 +488,21 @@ async function checkActualStates () {
     try {
         /**
          * switch Holiday
-         * @type {ioBroker.GetStatePromise}
-         * @private {obj} _holiday
+         * @type {ioBroker.State | null}
+         * @private
          */
         const _holiday = await adapter.getStateAsync('control.Holiday');
-            if (_holiday && _holiday.val) {
+            if (_holiday && _holiday.val && typeof _holiday.val === "boolean") {
                 holidayStr = _holiday.val;
             }
 
         /**
          * switch autoOnOff
-         * @type {ioBroker.GetStatePromise}
-         * @private {obj} _autoOnOff
+         * @type {ioBroker.State | null}
+         * @private
          */
         const _autoOnOff = await adapter.getStateAsync('control.autoOnOff');
-            if (_autoOnOff && _autoOnOff.val) {
+            if (_autoOnOff && _autoOnOff.val && typeof _autoOnOff.val === "boolean") {
                 autoOnOffStr = _autoOnOff.val;
             }
 
@@ -472,7 +538,7 @@ async function checkActualStates () {
              * @private
              */
             const _weatherForInstanceToday = await adapter.getForeignStateAsync(
-                adapter.config.weatherForInstance + '.NextDaysDetailed.Location_1.Day_1.rain_value'
+                weatherForecastTodayPfadStr
             ).catch((e) => adapter.log.warn(e));
                 if (_weatherForInstanceToday && _weatherForInstanceToday.val) {
                     if (typeof _weatherForInstanceToday.val == 'string') {
@@ -506,16 +572,41 @@ async function checkActualStates () {
                 );
             }
         }
+
+        // wenn (...sprinkleName.autoOn == false[off])  so wird der aktuelle Sprenger [sprinkleName]
+        //   bei false nicht automatisch gestartet
+        /**
+         * Abfrage von ...sprinkleName.autoOn
+         * @type {[myConfig.config]}
+         */
+        const result = myConfig.config;
+        if (result) {
+            for (const res of result) {
+                /**
+                 * Abfrage ... .autoOn beim Start
+                 * @type {ioBroker.State | void}
+                 * @private
+                 */
+                const _autoOn = await adapter.getForeignStateAsync(
+                    res.autoOnID
+                ).catch((e) => adapter.log.warn(e));
+                if (_autoOn && typeof _autoOn.val === 'boolean') {
+                    res.autoOn = _autoOn.val;
+                    if (_autoOn.val === false) {adapter.log.info(`get ${res.objectName}.autoOn = ${res.autoOn}`)}
+                }
+            }
+        }
+
         if (adapter.config.actualValueLevel){
             /**
-             * Füllstand der Zisterne in %
+             * Füllstand der Zisterne in % holen
              * @type {ioBroker.State | void}
              * @private
              */
             const _actualValueLevel = await adapter.getForeignStateAsync(
                 adapter.config.actualValueLevel
             ).catch((e) => adapter.log.warn(e));
-            if (_actualValueLevel && typeof _actualValueLevel.val !== undefined) {
+            if (_actualValueLevel && typeof parseFloat(_actualValueLevel.val) === "number") {
                 valveControl.setFillLevelCistern(parseFloat(_actualValueLevel.val));
             }
         }
@@ -528,9 +619,6 @@ async function checkActualStates () {
         const _list = await adapter.getForeignObjectsAsync(adapter.namespace + '.sprinkle.*', 'channel').catch((e) => adapter.log.warn(e));
             if (_list) {
                 ObjSprinkle = _list;
-                await createSprinklers();
-                await sleep(100);
-                startTimeSprinkle();
             }
 
     } catch (e) {
@@ -583,6 +671,7 @@ const calcPos = schedule.scheduleJob('calcPosTimer', '5 0 * * *', function() {
     // Startzeit Festlegen → verzögert wegen Daten von SunCalc
     setTimeout(() => {
         startTimeSprinkle();
+        addStartTimeSprinkle();
     },1000);
     
 });
@@ -595,11 +684,119 @@ function sunPos() {
     // format sunrise time from the Date object → Formatieren Sie die Sonnenaufgangszeit aus dem Date-Objekt
     sunriseStr = ('0' + times.sunrise.getHours()).slice(-2) + ':' + ('0' + times.sunrise.getMinutes()).slice(-2);
 
-    // format golden hour end time from the Date object => Formatiere golden hour end time aus dem Date-Objekt
+    // format golden hour end time from the Date object → Formatiere golden hour end time aus dem Date-Objekt
     goldenHourEnd = ('0' + times.goldenHourEnd.getHours()).slice(-2) + ':' + ('0' + times.goldenHourEnd.getMinutes()).slice(-2);
+
+    // format sunset time from the Date object → formatieren Sie die Sonnenuntergangszeit aus dem Date-Objekt
+    sunsetStr = sunsetStr = ('0' + times.sunset.getHours()).slice(-2) + ':' + ('0' + times.sunset.getMinutes()).slice(-2);
 	
 }
 
+function addStartTimeSprinkle() {
+    schedule.cancelJob('sprinkleAddStartTime');
+    if (adapter.config.selectAddStartTime === 'greaterETpCurrent' || adapter.config.selectAddStartTime === 'withExternalSignal') {
+        let addStartTimeSplit = adapter.config.addWateringStartTime.split(':');
+        const scheduleAddStartTime = schedule.scheduleJob('sprinkleAddStartTime', addStartTimeSplit[1] + ' ' + addStartTimeSplit[0] + ' * * *', function() {
+            // if (autoOnOff == false) => keine auto Start
+            if (!autoOnOffStr) {
+                schedule.cancelJob('sprinkleAddStartTime');
+                return;
+            }
+            if (((adapter.config.selectAddStartTime === 'greaterETpCurrent') && (adapter.config.triggerAddStartTimeETpCur < evaporation.getETpTodayNum()))
+                || (adapter.config.selectAddStartTime === 'withExternalSignal' && addStartTimeSwitch)) {
+                let messageText = '';
+
+                // Filter enabled
+                const result = myConfig.config.filter(d => d.enabled === true);
+                if (result) {
+                    /**
+                     * Array zum flüchtigen Sammeln von Bewässerungsaufgaben
+                     * @type {Array.<{auto: Boolean, sprinkleID: Number, wateringTime: Number}>}
+                     */
+                    const memAddList = [];
+
+                    /**
+                     * result Rain
+                     * - (aktuelle Wettervorhersage - Schwellwert der Regenberücksichtigung) wenn Sensor sich im Freien befindet
+                     * - (> 0) es regnet - Abbruch -
+                     * - (≤ 0) Start der Bewässerung
+                     * @param {boolean} inGreenhouse - Sensor befindet sich im Gewächshaus
+                     * @returns {number} - resultierende Regenmenge
+                     */
+                    function resRain (inGreenhouse) {
+                        return (adapter.config.weatherForecast && !inGreenhouse) ? (((+ weatherForecastTodayNum) - parseFloat(adapter.config.thresholdRain)).toFixed(1)) : 0;
+                    }
+
+                    for(const res of result) {
+                        if (res.autoOn                                  // Ventil aktiv
+                            && (res.addWateringTime > 0)                // zusätzliche Bewässerung aktiv time > 0
+                            && (resRain(res.inGreenhouse) <= 0)) {      // keine Regenvorhersage
+
+                            switch (res.methodControlSM) {
+                                case 'bistable':
+                                    if (res.soilMoisture.bool) {
+                                        messageText += `<b>${res.objectName}</b> (${res.soilMoisture.bool})\n`
+                                                    +  `   START => ${addTime(res.addWateringTime, '')}\n`;
+                                        memAddList.push({
+                                            auto: true,
+                                            sprinkleID: res.sprinkleID,
+                                            wateringTime: res.addWateringTime
+                                        });
+                                    }
+                                    break;
+                                case 'fixDay':
+                                    messageText += `<b>${res.objectName}</b>\n`
+                                                +  `   START => ${addTime(Math.round(60 * res.addWateringTime), '')}\n`;
+                                    memAddList.push({
+                                        auto: true,
+                                        sprinkleID: res.sprinkleID,
+                                        wateringTime: Math.round(60 * res.addWateringTime)
+                                    });
+                                    break;
+                                case 'calculation':
+                                    let addCountdown = res.wateringTime * (res.soilMoisture.maxIrrigation - res.soilMoisture.val) / (res.soilMoisture.maxIrrigation - res.soilMoisture.triggersIrrigation) - res.wateringTime;
+                                    adapter.log.debug(`addCountdown: ${addCountdown}, addWateringTime: ${res.addWateringTime}, if(${(addCountdown - res.addWateringTime) > 0})`);
+                                    if ((addCountdown - res.addWateringTime) > 0) {
+                                        messageText += `<b>${res.objectName}</b> ${res.soilMoisture.pct}% (${res.soilMoisture.pctTriggerIrrigation}%)\n`
+                                                     + `   START => ${addTime(Math.round(60 * addCountdown), '')}\n`;
+                                        memAddList.push({
+                                            auto: true,
+                                            sprinkleID: res.sprinkleID,
+                                            wateringTime: Math.round(60 * addCountdown)
+                                        });
+                                    }
+                                    break;
+                                case 'analog':
+                                    if (res.soilMoisture.pct < res.soilMoisture.pctAddTriggersIrrigation) {
+                                        messageText += `<b>${res.objectName}</b> ${res.soilMoisture.pct} %(${res.soilMoisture.pctAddTriggersIrrigation}%)\n`
+                                                    +  `   START => ${addTime(Math.round(60 * res.addWateringTime), '')}\n`;
+                                        memAddList.push({
+                                            auto: true,
+                                            sprinkleID: res.sprinkleID,
+                                            wateringTime: Math.round(60 * res.addWateringTime)
+                                        });
+                                    }
+                                    break;
+                            }
+                        } else {
+                            adapter.log.debug(`${res.objectName}: autoOn (${res.autoOn}) && addWateringTime (${res.addWateringTime} > 0) && resRain (${resRain(res.inGreenhouse)}) <= 0, if(${res.autoOn && (res.addWateringTime > 0) && (resRain(res.inGreenhouse) <= 0)})`);
+                        }
+                    }
+                    valveControl.addList(memAddList);
+                }
+                if(!sendMessageText.onlySendError() && messageText.length > 0){
+                    sendMessageText.sendMessage(messageText);
+                }
+            } else {
+                adapter.log.debug(`greaterETpCurrent: ${(adapter.config.selectAddStartTime === 'greaterETpCurrent')} & ${(adapter.config.triggerAddStartTimeETpCur < evaporation.getETpTodayNum())}, withExternalSignal; ${(adapter.config.selectAddStartTime === 'withExternalSignal')} & ${addStartTimeSwitch}`);
+            }
+            setTimeout(()=>{
+                    schedule.cancelJob('sprinkleAddStartTime');
+                }, 200);
+        });
+    }
+}
+
 // Determination of the irrigation time => Bestimmung der Bewässerungszeit
 function startTimeSprinkle() {
     let startTimeSplit = [];
@@ -608,9 +805,9 @@ function startTimeSprinkle() {
 
     schedule.cancelJob('sprinkleStartTime'); 
 
-    // if autoOnOff == false => keine auto Start
+    // if (autoOnOff == false) => keine auto Start
     if (!autoOnOffStr) {
-        adapter.log.info(`Sprinkle: autoOnOff == Aus( ${autoOnOffStr} )`);
+        adapter.log.info(`Sprinkle: autoOnOff == Aus ( ${autoOnOffStr} )`);
         adapter.setState('info.nextAutoStart', {
             val: 'autoOnOff = off(0)',
             ack: true
@@ -654,7 +851,7 @@ function startTimeSprinkle() {
                     break;
                 case 'livingSunrise' :			/*Startauswahl = Sonnenaufgang*/
                     infoMessage = 'Start mit Sonnenaufgang ';
-                    // format sunset/sunrise time from the Date object
+                    // format sunrise time from the Date object
                     newStartTime = addTime(sunriseStr, parseInt(adapter.config.timeShift));
                     break;
                 case 'livingGoldenHourEnd' :	/*Startauswahl = Ende der Golden Hour*/
@@ -662,9 +859,14 @@ function startTimeSprinkle() {
                     // format goldenHourEnd time from the Date object
                     newStartTime = goldenHourEnd;
                     break;
+                case 'livingSunset' :           /*Startauswahl = Sonnenuntergang*/
+                    infoMessage = 'Start mit Sonnenuntergang ';
+                    // format sunset time from the Date object
+                    newStartTime = addTime(sunsetStr, parseInt(adapter.config.timeShift));
+                    break;
             }
             // Start am Wochenende →, wenn andere Zeiten verwendet werden soll
-            if((adapter.config.publicWeekend) && ((myWeekday) === 6 || (myWeekday) === 0)){
+            if((adapter.config.publicWeekend) && ((myWeekday === 6) || (myWeekday === 0))){
                 infoMessage = 'Start am Wochenende ';
                 newStartTime = adapter.config.weekEndLiving;
             }
@@ -792,9 +994,10 @@ function startTimeSprinkle() {
                         // --- fixDay  --  Start an festen Tagen ohne Sensoren  --- //
                         //  --              Bewässerungstag erreicht                //
                         case 'fixDay':
-                            if (res.startFixDay[today]) {
-                                /* Wenn in der Config Regenvorhersage aktiviert: Startvorgang abbrechen, wenn der Regen den eingegebenen Schwellwert überschreitet. */
-                                if (resRain(false) <= 0) {
+                            /* Wenn in der Config Regenvorhersage aktiviert: Startvorgang abbrechen, wenn der Regen den eingegebenen Schwellwert überschreitet. */
+                            if (resRain(false) <= 0) {
+                                // Bewässerungstag erreicht
+                                if (res.startFixDay[today]) {
                                     const curWateringTime = Math.round(60 * res.wateringTime * evaporation.timeExtension(res.wateringAdd));
                                     memAddList.push({
                                         auto: true,
@@ -809,14 +1012,22 @@ function startTimeSprinkle() {
                                         res.startFixDay[today] = false;
                                         res.startFixDay[(+ today + 2 > 6) ? (+ today-5) : (+ today+2)] = true;
                                     }
-                                } else if (adapter.config.weatherForecast){
-                                    messageText += '   ' + '<i>' + 'Start verschoben, da heute ' + weatherForecastTodayNum + 'mm Niederschlag' + '</i> ' + '\n';
-                                    adapter.log.info(`${res.objectName}: Start verschoben, da Regenvorhersage für Heute ${weatherForecastTodayNum} mm [ ${resRain(false)} > 0 ]`);
-                                    res.startFixDay[today] = false;
-                                    res.startFixDay[(+ today + 1 > 6) ? (+ today-6) : (+ today+1)] = true;
                                 }
-                                curNextFixDay(res.sprinkleID, false);
+                            } else if (adapter.config.weatherForecast){
+                                messageText += '   ' + '<i>' + 'Start verschoben, da heute ' + weatherForecastTodayNum + 'mm Niederschlag' + '</i> ' + '\n';
+                                adapter.log.info(`${res.objectName}: Start verschoben, da Regenvorhersage für Heute ${weatherForecastTodayNum} mm [ ${resRain(false)} > 0 ]`);
+                                if ((res.startDay === 'threeRd') || (res.startDay === 'twoNd')) {
+                                    let startDay = -1;
+                                    res.startFixDay.forEach((item, index) => {if (item) {startDay = index}});
+                                    if (startDay !== -1) {
+                                        res.startFixDay[startDay] = false;
+                                        res.startFixDay[(+ startDay + 1 > 6) ? (+ startDay-6) : (+ startDay+1)] = true;
+                                    } else {
+                                        adapter.log.warn(`${res.objectName}: no start day found`)
+                                    }
+                                }
                             }
+                            curNextFixDay(res.sprinkleID, false);
                             break;
                         // ---   calculation  --  Berechnung der Bodenfeuchte  --- //
                         //  --             Bodenfeuchte zu gering              --  //
@@ -837,7 +1048,7 @@ function startTimeSprinkle() {
                                 } else if (adapter.config.weatherForecast) {
                                     /* Bewässerung unterdrückt da ausreichende Regenvorhersage */
                                     messageText += '   ' + '<i>' + 'Start verschoben, da heute ' + weatherForecastTodayNum + 'mm Niederschlag' + '</i> ' + '\n';
-                                    adapter.log.info(`${res.objectName}: Start verschoben, da Regenvorhersage für Heute ${weatherForecastTodayNum} mm [ ${res.soilMoisture.val} (${resMoisture}) <= ${res.soilMoisture.triggersIrrigation} ]`);
+                                    adapter.log.info(`${res.objectName}: Start verschoben, da Regenvorhersage für Heute ${weatherForecastTodayNum} mm [ ${res.soilMoisture.val.toFixed(1)} (${resMoisture.toFixed(1)}) <= ${res.soilMoisture.triggersIrrigation} ]`);
                                 }
                             }
                             break;
@@ -862,6 +1073,43 @@ function startTimeSprinkle() {
 
 //
 async function createSprinklers() {
+    /**Creates an Object .control.addStartTimeSwitch, when additional watering has been activated via an external signal
+     * - Erzeugt ein Object .control.addStartTimeSwitch, wenn die Zusatzbewässerung über ein externes Signal aktiviert wurde
+     * @type {{id: string, name: string} | void}
+     * @private
+     */
+    const _addStartTimeSwitch = await adapter.findForeignObjectAsync(`${adapter.namespace}.control.addStartTimeSwitch`, 'boolean').catch((e) => adapter.log.warn(`.control.addStartTimeSwitch ${e}`));
+    if (_addStartTimeSwitch.id !== `${adapter.namespace}.control.addStartTimeSwitch` && adapter.config.selectAddStartTime === 'withExternalSignal') {
+        adapter.setObjectNotExistsAsync(`${adapter.namespace}.control.addStartTimeSwitch`, {
+            'type': 'state',
+            'common': {
+                "role": "switch",
+                'name':  'additional irrigation enabled',
+                'type':  'boolean',
+                'read':  true,
+                'write': true,
+                'def': false
+            },
+            'native': {}
+        }).catch((e) => adapter.log.warn(`.control.addStartTimeSwitch ${e}`));
+    } else if (_addStartTimeSwitch.id === `${adapter.namespace}.control.addStartTimeSwitch`) {
+        if (adapter.config.selectAddStartTime !== 'withExternalSignal') {
+            adapter.delObjectAsync(`${adapter.namespace}.control.addStartTimeSwitch`).catch((e) => adapter.log.warn(`.control.addStartTimeSwitch ${e}`));
+            addStartTimeSwitch = false;
+        } else {
+            /** auslesen .control.addStartTimeSwitch.val
+             * @type {ioBroker.State | void}
+             * @private
+             */
+            const _state = await adapter.getStateAsync(`${adapter.namespace}.control.addStartTimeSwitch`).catch((e) => adapter.log.warn(`.control.addStartTimeSwitch ${e}`));
+            if (typeof _state.val === 'boolean') {
+                addStartTimeSwitch = _state.val;
+            }
+        }
+    }
+
+
+
     const result = adapter.config.events;
     if (result) {	
         for(const res of result) {
@@ -880,7 +1128,7 @@ async function createSprinklers() {
 
             let nameMetConSM, objMetConSM;
             await fillMetConSM(res);
-            function fillMetConSM(res) {
+            async function fillMetConSM(res) {
                 //adapter.log.debug(JSON.stringify(res));
                 switch (res.methodControlSM) {
                     case 'calculation':
@@ -983,7 +1231,7 @@ async function createSprinklers() {
                             'name': res.sprinkleName
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`sprinkle.${objectName} ${e}`));
+                    });
                     // Create Object for .history
                     const _historyNotExist = await adapter.setObjectNotExistsAsync('sprinkle.' + objectName + '.history', {
                         'type': 'channel',
@@ -991,7 +1239,7 @@ async function createSprinklers() {
                             'name': res.sprinkleName + ' => History'
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.history ${e}`));
+                    });
                     // Create Object for .history.curCalWeekConsumed
                     // Sprinkler consumption of the current calendar week => History - Sprinkler-Verbrauch der aktuellen Kalenderwoche (783 Liter)
                     const _curCalWeekConsumedNotExist = adapter.setObjectNotExistsAsync(objPfad + '.history.curCalWeekConsumed', {
@@ -1006,7 +1254,7 @@ async function createSprinklers() {
                             'def':   0
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.curCalWeekConsumed ${e}`));
+                    });
                     // Create Object for .history.curCalWeekRunningTime
                     // Sprinkler running time of the current calendar week => History - Sprinkler-Laufzeit der aktuellen Kalenderwoche (783 Liter)
                     const _curCalWeekRunningTimeNotExist = adapter.setObjectNotExistsAsync(objPfad + '.history.curCalWeekRunningTime', {
@@ -1020,7 +1268,7 @@ async function createSprinklers() {
                             'def':   '00:00'
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.curCalWeekRunningTime ${e}`));
+                    });
                     // Create Object for .history.lastCalWeekConsumed
                     // Sprinkler consumption of the last calendar week => History - Sprinkler-Verbrauch der letzten Kalenderwoche (783 Liter)
                     const _lastCalWeekConsumedNotExist = adapter.setObjectNotExistsAsync(objPfad + '.history.lastCalWeekConsumed', {
@@ -1035,7 +1283,7 @@ async function createSprinklers() {
                             'def':   0
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.lastCalWeekConsumed ${e}`));
+                    });
                     // Create Object for .history.lastCalWeekRunningTime
                     // Sprinkler running time of the last calendar week => History - Sprinkler-Laufzeit der letzten Kalenderwoche (783 Liter)
                     const _lastCalWeekRunningTimeNotExist = adapter.setObjectNotExistsAsync(objPfad + '.history.lastCalWeekRunningTime', {
@@ -1049,7 +1297,7 @@ async function createSprinklers() {
                             'def':   '00:00'
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.curCalWeekRunningTime ${e}`));
+                    });
                     // Create Object for .history.lastConsumed
                     // Last consumed of sprinkler => History - Letzte Verbrauchsmenge des Ventils (783 Liter)
                     const _lastConsumedNotExist = adapter.setObjectNotExistsAsync(objPfad + '.history.lastConsumed', {
@@ -1064,7 +1312,7 @@ async function createSprinklers() {
                             'def':   0
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.lastConsumed ${e}`));
+                    });
                     // Create Object for .history.lastOn
                     // Last On of sprinkler => History - Letzter Start des Ventils (30.03 06:30)
                     const _lastOnNotExist = adapter.setObjectNotExistsAsync(objPfad + '.history.lastOn', {
@@ -1078,7 +1326,7 @@ async function createSprinklers() {
                             'def':   '-'
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.lastOn ${e}`));
+                    });
                     // Create Object for .history.lastRunningTime
                     // Last running time of sprinkler => History - Letzte Laufzeit des Ventils (0 sek, 47:00 min, 1:03:45 )
                     const _lastRunningTimeNotExist = adapter.setObjectNotExistsAsync(objPfad + '.history.lastRunningTime', {
@@ -1092,24 +1340,70 @@ async function createSprinklers() {
                             'def':   '00:00'
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.lastRunningTime ${e}`));
+                    });
                     // Create Object for .autoOn
-                    const _autoOnNotExist = await adapter.setObjectNotExistsAsync(objPfad + '.autoOn', {
-                        'type': 'state',
-                        'common': {
-                            'role':  'state',
-                            'name':  objectName + ' => Switch automatic mode on / off',
-                            'type':  'boolean',
-                            'read':  true,
-                            'write': true,
-                            'def':   true
-                        },
-                        'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.autoOn ${e}`));
+                    const _autoOnNotExist = adapter.setObjectNotExistsAsync(objPfad + '.autoOn', {
+                            'type': 'state',
+                            'common': {
+                                'role':  'Switch',
+                                'name':  objectName + ' => Switch automatic mode on / off',
+                                'type':  'boolean',
+                                "states": {
+                                    "false": "off",
+                                    "true": "on"
+                                },
+                                'read':  true,
+                                'write': true,
+                                'def':   true
+                            },
+                            'native': {},
+                        }).catch((e) => adapter.log.warn(`setObjectNotExistsAsync ${objectName}.autoOn ${e}`));
                     // Create Object for .actualSoilMoisture
-                    const _actualSoilMoistureNotExist = await adapter.setObjectNotExistsAsync(objPfad + '.actualSoilMoisture',
-                        objMetConSM
-                    ).catch((e) => adapter.log.warn(`${objectName}.actualSoilMoisture ${e}`));
+                    const _actualSoilMoistureFind = await adapter.findForeignObjectAsync(`${adapter.namespace}.${objPfad}.actualSoilMoisture`, `${objMetConSM.common.type}`);
+                    if (_actualSoilMoistureFind.id !== `${adapter.namespace}.${objPfad}.actualSoilMoisture` || _actualSoilMoistureFind.name !== nameMetConSM) {
+                        await adapter.setObjectAsync(
+                            objPfad + '.actualSoilMoisture',
+                            objMetConSM
+                        ).catch((e) => adapter.log.warn(e));
+                        adapter.log.info(`sprinkleControl [sprinkle.${objectName}.actualSoilMoisture] was updated`);
+                    }
+
+                    // postponeByOneDay → um einen Tag verschieben bei fixDay (twoNd & threeRd)
+                    const _postponeByOneDay = await adapter.findForeignObjectAsync(`${adapter.namespace}.${objPfad}.postponeByOneDay`, `boolean`);
+                    if (_postponeByOneDay.id !== `${adapter.namespace}.${objPfad}.postponeByOneDay`
+                        && res.methodControlSM === "fixDay"
+                        && (res.startDay === "twoNd"
+                        || res.startDay === "threeRd")) {
+                        await adapter.setObjectNotExistsAsync(objPfad + '.postponeByOneDay', {
+                            'type': 'state',
+                            'common': {
+                                "role": 'button',
+                                "name": objectName + 'Postpone start by one day',
+                                "type": 'boolean',
+                                "read": true,
+                                "write": true,
+                                "def": false
+                            },
+                            'native': {
+                                "UNIT": "",
+                                "TAB_ORDER": 0,
+                                "OPERATIONS": 6,
+                                "FLAGS": 1,
+                                "TYPE": "ACTION",
+                                "MIN": false,
+                                "MAX": true,
+                                "DEFAULT": false
+                            }
+                        });
+                        adapter.subscribeStates(`${adapter.namespace}.${objPfad}.postponeByOneDay`);
+                    } else if (res.methodControlSM === "fixDay"
+                        && (res.startDay === "twoNd"
+                        || res.startDay === "threeRd")) {
+                        adapter.subscribeStates(`${adapter.namespace}.${objPfad}.postponeByOneDay`);
+                    } else {
+                        await adapter.delObjectAsync(`${adapter.namespace}.${objPfad}.postponeByOneDay`);                  // "sprinklecontrol.0.sprinkle.???.actualSoilMoisture"
+                    }
+
                     // Create Object for .countdown => Countdown des Ventils
                     const _countdownNotExist = adapter.setObjectNotExistsAsync(objPfad + '.countdown', {
                         'type': 'state',
@@ -1122,7 +1416,7 @@ async function createSprinklers() {
                             'def':   '-'
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.countdown ${e}`));
+                    });
                     // Create Object for .runningTime => Laufzeit des Ventils
                     const _runningTimeNotExist = await adapter.setObjectNotExistsAsync(objPfad + '.runningTime', {
                         'type': 'state',
@@ -1135,7 +1429,7 @@ async function createSprinklers() {
                             'def':   '-'
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.runningTime ${e}`));
+                    });
                     // Create Object for .sprinklerState => Zustand des Ventils im Thread
                     // <<< 1  = warten >>> ( 0:off; 1:wait; 2:on; 3:break; 4:Boost(on); 5:off(Boost) )
                     // Create .sprinklerState
@@ -1159,8 +1453,8 @@ async function createSprinklers() {
                             'write': false,
                             'def':   0
                         },
-                        'native': {}
-                    }).catch((e) => adapter.log.warn(`${objectName}.sprinklerState ${e}`));
+                        'native': {},
+                    });
                     // Create Object for triggerPoint → Schaltpunkt der Bodenfeuchte
                     const _triggerPointNotExist = await adapter.setObjectNotExistsAsync(objPfad + '.triggerPoint', {
                         'type': 'state',
@@ -1173,10 +1467,10 @@ async function createSprinklers() {
                             'def':   '-'
                         },
                         'native': {},
-                    }).catch((e) => adapter.log.warn(`${objectName}.triggerPoint ${e}`));
+                    });
                     // Object created
                     let value = true;
-                    (await Promise.all([
+                    await (await Promise.all([
                         _sprinkleNotExist,
                         _historyNotExist,
                         _curCalWeekConsumedNotExist,
@@ -1187,15 +1481,14 @@ async function createSprinklers() {
                         _lastOnNotExist,
                         _lastRunningTimeNotExist,
                         _autoOnNotExist,
-                        _actualSoilMoistureNotExist,
                         _countdownNotExist,
                         _runningTimeNotExist,
                         _sprinklerStateNotExists,
                         _triggerPointNotExist
                     ])).forEach((val) => {
-                        value += val;
+                        value &= val;
                     });
-                    if (value){
+                    if(value) {
                         adapter.log.info(`sprinkleControl [sprinkle.${objectName}] was created`);
                     }
 
@@ -1203,34 +1496,6 @@ async function createSprinklers() {
                     // +++++                            zustände der States aktualisieren                       +++++ //
                     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //
 
-                    // Abfrage, ob sich die Bewässerungsart geändert hat
-                    const _actualSoilMoistureObj = await adapter.getObjectAsync(objPfad + '.actualSoilMoisture').catch((e) => adapter.log.warn(e));
-                    if (_actualSoilMoistureObj) {
-                        if (typeof _actualSoilMoistureObj.common.name !== 'string' || _actualSoilMoistureObj.common.name !== nameMetConSM) {           //  Objekt wurde ausgelesen
-                            await adapter.setObjectAsync(
-                                objPfad + '.actualSoilMoisture',
-                                objMetConSM
-                            ).catch((e) => adapter.log.warn(e));
-                            adapter.log.info(`sprinkleControl [sprinkle.${objectName}.actualSoilMoisture] was updated`);
-
-                        }
-                    }
-                    //
-                    if (await _autoOnNotExist) {
-                        const _autoOn = await adapter.getStateAsync(objPfad + '.autoOn').catch((e) => adapter.log.warn(e));
-                        if (_autoOn && _autoOn.val) {
-                            if (typeof _autoOn.val === 'boolean' && ((new Date () - _autoOn.ts) > 60000)) {
-                                myConfig.config[j].autoOn = _autoOn.val;
-                            } else {
-                                adapter.setStateAsync(
-                                    objPfad + '.autoOn',
-                                    true,
-                                    true
-                                ).catch((e) => adapter.log.warn(`${objectName}.autoOn ${e}`));
-                                myConfig.config[j].autoOn = true;
-                            }
-                        }
-                    }
                     //
                     if(await _countdownNotExist){
                         const _countdown = await adapter.getStateAsync(objPfad + '.countdown').catch((e) => adapter.log.warn(`${objectName}.countdown ${e}`));
@@ -1315,7 +1580,7 @@ async function createSprinklers() {
                              *     false → Zweitage-modus (twoNd)
                              */
                             async function setNewDay (threeRd) {
-                                const today = formatTime(adapter,'', 'day');
+                                const today = await formatTime(adapter,'', 'day');
                                 /**
                                  *
                                  * @type {ioBroker.GetStatePromise} _actualSoilMoisture
@@ -1347,7 +1612,6 @@ async function createSprinklers() {
                             } else if (myConfig.config[j].startDay === 'twoNd') {
                                 await setNewDay(false);
                             } else if (myConfig.config[j].startDay === 'fixDay') {
-                                adapter.log.info(`set Day (fixDay): ${myConfig.config[j].objectName}`);
                                 curNextFixDay(myConfig.config[j].sprinkleID, false);
                             }
 
@@ -1387,7 +1651,7 @@ async function createSprinklers() {
                             ).catch((e) => adapter.log.warn(e));
                             break;
 
-                        }
+                    }
 
                 } catch (e) {
                     adapter.log.warn(`sprinkleControl cannot created ... Please check your sprinkleControl config: ${e}`);
@@ -1419,27 +1683,44 @@ async function createSprinklers() {
             if (fullRes.indexOf(resultID) === -1) {
                 try {
                     // object deleted
+                    /**
+                     * del when exist Object Async
+                     * @param id - the id of the object
+                     * @param type - common.type of the state
+                     * @returns {Promise<void>}
+                     */
+                    const delWhenExistObjectAsync = async (id, type) => {
+                        const _find = await adapter.findForeignObjectAsync(`${id}`, `${type}`);
+                        if (_find && _find.id === `${id}`) {
+                            await adapter.delObjectAsync(`${id}`).catch((e) => adapter.log.warn(e));  // "sprinklecontrol.0.sprinkle.???.postponeByOneDay"
+                        }
+                    }
+
                     Promise.all([
-                        adapter.delObjectAsync(resID + '.actualSoilMoisture'),	           // "sprinklecontrol.0.sprinkle.???.actualSoilMoisture"
-                        adapter.delObjectAsync(resID + '.triggerPoint'),                    // "sprinklecontrol.0.sprinkle.???.triggerPoint"
-                        adapter.delObjectAsync(resID + '.sprinklerState'),	               // "sprinklecontrol.0.sprinkle.???.sprinklerState"
-                        adapter.delObjectAsync(resID + '.runningTime'),	                   //	"sprinklecontrol.0.sprinkle.???.runningTime"
-                        adapter.delObjectAsync(resID + '.countdown'),	                   //	"sprinklecontrol.0.sprinkle.???.countdown"
-                        adapter.delObjectAsync(resID + '.autoOn'),                          // "sprinklecontrol.0.sprinkle.???.autoOn"
-                        adapter.delObjectAsync(resID + '.history.lastOn'),	               //	"sprinklecontrol.0.sprinkle.???..history.lastOn"
-                        adapter.delObjectAsync(resID + '.history.lastConsumed'),	           //	"sprinklecontrol.0.sprinkle.???..history.lastConsumed"
-                        adapter.delObjectAsync(resID + '.history.lastRunningTime'),	       // "sprinklecontrol.0.sprinkle.???.history.lastRunningTime"
-                        adapter.delObjectAsync(resID + '.history.curCalWeekConsumed'),	   //	"sprinklecontrol.0.sprinkle.???.history.curCalWeekConsumed"
-                        adapter.delObjectAsync(resID + '.history.lastCalWeekConsumed'),	   //	"sprinklecontrol.0.sprinkle.???.history.lastCalWeekConsumed"
-                        adapter.delObjectAsync(resID + '.history.curCalWeekRunningTime'),	//	"sprinklecontrol.0.sprinkle.???.history.curCalWeekRunningTime"
-                        adapter.delObjectAsync(resID + '.history.lastCalWeekRunningTime'),	//	"sprinklecontrol.0.sprinkle.???.history.lastCalWeekRunningTime"
+                        adapter.delObjectAsync(resID + '.actualSoilMoisture'),                  // "sprinklecontrol.0.sprinkle.???.actualSoilMoisture"
+                        adapter.delObjectAsync(resID + '.triggerPoint'),                        // "sprinklecontrol.0.sprinkle.???.triggerPoint"
+                        adapter.delObjectAsync(resID + '.sprinklerState'),                      // "sprinklecontrol.0.sprinkle.???.sprinklerState"
+                        adapter.delObjectAsync(resID + '.runningTime'),                         // "sprinklecontrol.0.sprinkle.???.runningTime"
+                        delWhenExistObjectAsync(`${resID}.postponeByOneDay`, `boolean`),          // "sprinklecontrol.0.sprinkle.???.postponeByOneDay" wenn vorhanden löschen
+                        adapter.delObjectAsync(resID + '.countdown'),                           // "sprinklecontrol.0.sprinkle.???.countdown"
+                        adapter.delObjectAsync(resID + '.autoOn'),                              // "sprinklecontrol.0.sprinkle.???.autoOn"
+                        adapter.delObjectAsync(resID + '.history.lastOn'),                      //  "sprinklecontrol.0.sprinkle.???.history.lastOn"
+                        adapter.delObjectAsync(resID + '.history.lastConsumed'),                //  "sprinklecontrol.0.sprinkle.???.history.lastConsumed"
+                        adapter.delObjectAsync(resID + '.history.lastRunningTime'),             //  "sprinklecontrol.0.sprinkle.???.history.lastRunningTime"
+                        adapter.delObjectAsync(resID + '.history.curCalWeekConsumed'),          //  "sprinklecontrol.0.sprinkle.???.history.curCalWeekConsumed"
+                        adapter.delObjectAsync(resID + '.history.lastCalWeekConsumed'),         //  "sprinklecontrol.0.sprinkle.???.history.lastCalWeekConsumed"
+                        adapter.delObjectAsync(resID + '.history.curCalWeekRunningTime'),       //  "sprinklecontrol.0.sprinkle.???.history.curCalWeekRunningTime"
+                        adapter.delObjectAsync(resID + '.history.lastCalWeekRunningTime')      //  "sprinklecontrol.0.sprinkle.???.history.lastCalWeekRunningTime"
+                        ]
+                    ).then(async ()=>{
                         // History - Objekt(Ordner.history) löschen
-                        await adapter.delObjectAsync(resID + '.history'),
+                        await adapter.delObjectAsync(resID + '.history');
+                    }).then(async ()=>{
                         // Objekt(Ordner) löschen
-                        await adapter.delObjectAsync(resID)
-                    ]).then((resultID)=>{
-                        adapter.log.info(`sprinkleControl [${resultID}] was deleted`);
-                    })
+                        await adapter.delObjectAsync(resID);
+                    }).then(()=>{
+                        adapter.log.info(`sprinkleControl [${resID}] was deleted`);
+                    });
                 } catch (e) {
                     adapter.log.warn(e);
                 }
@@ -1448,17 +1729,20 @@ async function createSprinklers() {
     }
 }
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 /**
  *
  * @param {number} ms  => Waiting time in ms
  * @return {Promise<unknown>}
  */
+/*
 async function sleep(ms) {
     return new Promise(async (resolve) => {
         // @ts-ignore
         timerSleep = setTimeout(async () => resolve(), ms);
     });
 }
+*/
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /**
  *
@@ -1472,31 +1756,26 @@ function main(adapter) {
 	adapter.config:
 	*/
     adapter.log.debug(`adapter.config.events: ${JSON.stringify(adapter.config.events)}`);
-
     /**
      * The adapters' config (in the instance object everything under the attribute "native") is accessible via adapter.config:
      * => Auf die Adapterkonfiguration (im Instanz objekt alles unter dem Attribut "native") kann zugegriffen werden über adapter.config:
      * @param {any} err
      * @param {any} obj
      */
-    adapter.getForeignObject('system.config', (err) => {
-        if (!err) {
-            // init createConfig
-            myConfig.createConfig(adapter);
+    adapter.getForeignObject('system.config', (err, obj) => {
+        if (obj) {
             checkStates();
         }
     });
-
-    GetSystemData().then();
+    createSprinklers().catch((e) => adapter.log.warn(e));
+    GetSystemData().catch((e) => adapter.log.warn(e));
     sendMessageText.initConfigMessage(adapter);
-
-    timer = setTimeout(function() {
-        checkActualStates().then();
-        // init evaporation
-        evaporation.initEvaporation(adapter);
-        // Hauptpumpe zur Bewässerung setzen
-        valveControl.initValveControl(adapter);
-        sunPos();
+    evaporation.initEvaporation(adapter);        // init evaporation
+    checkActualStates().catch((e) => adapter.log.warn(e));
+    sunPos();
+    timer = setTimeout(() => {
+        startTimeSprinkle();
+        addStartTimeSprinkle()
     }, 2000);
 
     /*
@@ -1518,11 +1797,17 @@ function main(adapter) {
     if (adapter.config.publicHolidays === true && (adapter.config.publicHolInstance + '.morgen.*')) {
         adapter.subscribeForeignStates(adapter.config.publicHolInstance + '.morgen.*');
     }
-    if ((adapter.config.weatherForecast === true) && (adapter.config.weatherForInstance + '.NextDaysDetailed.Location_1.Day_1.*')) {
-        adapter.subscribeForeignStates(adapter.config.weatherForInstance + '.NextDaysDetailed.Location_1.Day_1.rain_value');
-    }
-    if ((adapter.config.weatherForecast === true) && (adapter.config.weatherForInstance + '.NextDaysDetailed.Location_1.Day_2.*')) {
-        adapter.subscribeForeignStates(adapter.config.weatherForInstance + '.NextDaysDetailed.Location_1.Day_2.rain_value');
+    if (adapter.config.weatherForecast === true) {
+        if (adapter.config.weatherForecastService === 'ownDataPoint') {
+            weatherForecastTodayPfadStr = adapter.config.pathRainForecast;
+            adapter.subscribeForeignStates(weatherForecastTodayPfadStr);
+        } else if (adapter.config.weatherForecastService === 'dasWetter' && adapter.config.weatherForInstance) {
+            weatherForecastTodayPfadStr = adapter.config.weatherForInstance + '.NextDaysDetailed.Location_1.Day_1.rain_value';
+            adapter.subscribeForeignStates(weatherForecastTodayPfadStr);
+            adapter.subscribeForeignStates(adapter.config.weatherForInstance + '.NextDaysDetailed.Location_1.Day_2.rain_value');
+        } else {
+            adapter.log.warn('There is no valid data record stored in the weather forecast, please correct it!')
+        }
     }
     if (adapter.config.actualValueLevel !== '') {
         adapter.subscribeForeignStates(adapter.config.actualValueLevel);