iobroker.sprinklecontrol 0.2.9 → 0.2.12

package/main.js

@@ -29,19 +29,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 +81,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 +108,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 +123,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':
@@ -116,7 +131,7 @@ function startAdapter(options) {
                         err && adapter.log.error(err);
                         if (state && state.val) {
                             try {
-                                adapter.log.info('getTelegramUser:' + state.val);
+                                adapter.log.debug('getTelegramUser:' + state.val);
                                 adapter.sendTo(obj.from, obj.command, JSON.parse(state.val), obj.callback);
                             } catch (err) {
                                 err && adapter.log.error(err);
@@ -160,6 +175,11 @@ function startAdapter(options) {
                 holidayStr = state.val;
                 startTimeSprinkle();
             }
+            // wenn (addStartTimeSwitch == true) wird die zusätzliche Bewässerung aktiviert
+            if (id === `${adapter.namespace}.control.addStartTimeSwitch`
+                && typeof state.val === 'boolean') {
+                addStartTimeSwitch = state.val;
+            }
             // wenn (autoOnOff == false) so werden alle Sprenger nicht mehr automatisch gestartet.
             if (id === adapter.namespace + '.control.autoOnOff') {
                 autoOnOffStr = state.val;
@@ -205,13 +225,30 @@ 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')) {
                 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;
+                    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`) {
+                const found = myConfig.config.find(d => d.objectName === idSplit[3]);
+                if (found) {
+                    myConfig.postponeByOneDay(found.sprinkleID).catch((e) => {adapter.log.warn(`postponeByOneDay: ${e}`)});
+                }
             }
+
             // Change in outside temperature → Änderung der Außentemperatur
             if (id === adapter.config.sensorOutsideTemperature) {	/*Temperatur*/
                 if (!Number.isNaN(Number.parseFloat(state.val))) {
@@ -267,7 +304,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 +357,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!');
@@ -364,7 +401,6 @@ function curNextFixDay (sprinkleID, returnOn) {
  * → Setzt den Status beim Start auf einen definierten Wert
  */
 function checkStates() {
-    //
     /**
      * control.Holiday
      * @param {string|null} err
@@ -381,7 +417,7 @@ function checkStates() {
      * @param {ioBroker.State|null|undefined} state
      */
     adapter.getState('control.autoOnOff', (err, state) => {
-        if (state && (state.val == null)) {
+        if (state && (state.val == null) && (state.val === undefined)) {
             autoOnOffStr = true;
             adapter.setState('control.autoOnOff', {
                 val: autoOnOffStr,
@@ -422,8 +458,8 @@ 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) {
@@ -432,8 +468,8 @@ async function checkActualStates () {
 
         /**
          * switch autoOnOff
-         * @type {ioBroker.GetStatePromise}
-         * @private {obj} _autoOnOff
+         * @type {ioBroker.State | null}
+         * @private
          */
         const _autoOnOff = await adapter.getStateAsync('control.autoOnOff');
             if (_autoOnOff && _autoOnOff.val) {
@@ -472,7 +508,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 +542,40 @@ 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 (typeof _autoOn.val === 'boolean') {
+                    res.autoOn = _autoOn.val;
+                }
+            }
+        }
+
         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 +588,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 +640,7 @@ const calcPos = schedule.scheduleJob('calcPosTimer', '5 0 * * *', function() {
     // Startzeit Festlegen → verzögert wegen Daten von SunCalc
     setTimeout(() => {
         startTimeSprinkle();
+        addStartTimeSprinkle();
     },1000);
     
 });
@@ -595,11 +653,110 @@ 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() {
+    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() {
+            adapter.log.debug(`greaterETpCurrent: ${(adapter.config.selectAddStartTime === 'greaterETpCurrent')} & ${(adapter.config.triggerAddStartTimeETpCur < evaporation.getETpTodayNum())}, withExternalSignal; ${(adapter.config.selectAddStartTime === 'withExternalSignal')} & ${addStartTimeSwitch}`);
+            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) {
+                        adapter.log.debug(`${res.objectName}: ${res.autoOn}, ${res.addWateringTime}, ${resRain(res.inGreenhouse)} <= 0, if(${res.autoOn && (res.addWateringTime > 0) && (resRain(res.inGreenhouse) <= 0)})`);
+                        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;
+                            }
+                            valveControl.addList(memAddList);
+                        }
+                    }
+                    if(!sendMessageText.onlySendError() && messageText.length > 0){
+                        sendMessageText.sendMessage(messageText);
+                    }
+                }
+            }
+        });
+    }
+}
+
 // Determination of the irrigation time => Bestimmung der Bewässerungszeit
 function startTimeSprinkle() {
     let startTimeSplit = [];
@@ -610,7 +767,7 @@ function startTimeSprinkle() {
 
     // 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 +811,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,6 +819,11 @@ 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)){
@@ -792,9 +954,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 +972,14 @@ 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 ]`);
+                                res.startFixDay[today] = false;
+                                res.startFixDay[(+ today + 1 > 6) ? (+ today-6) : (+ today+1)] = true;
                             }
+                            curNextFixDay(res.sprinkleID, false);
                             break;
                         // ---   calculation  --  Berechnung der Bodenfeuchte  --- //
                         //  --             Bodenfeuchte zu gering              --  //
@@ -862,6 +1025,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 +1080,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':
@@ -953,6 +1153,22 @@ async function createSprinklers() {
                         break;
                     default:
                         adapter.log.warn(`sprinkleControl cannot created ... Please check your sprinkleControl config ${objectName} methodControl`);
+                        nameMetConSM = objectName + ' => Emergency program! start on a fixed day';
+                        objMetConSM = {
+                            'type': 'state',
+                            'common': {
+                                'role':  'state',
+                                'name':  nameMetConSM,
+                                'type':  'number',
+                                'min': 0,
+                                'max': 7,
+                                'states': {"0":"Sun", "1":"Mon", "2":"Tue", "3":"Wed", "4":"Thur", "5":"Fri", "6":"Sat", "7":"off"},
+                                'read':  true,
+                                'write': false,
+                                'def': 7
+                            },
+                            'native': {},
+                        };
                 }
             }
             // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //
@@ -967,7 +1183,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',
@@ -975,7 +1191,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', {
@@ -990,7 +1206,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', {
@@ -1004,7 +1220,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', {
@@ -1019,7 +1235,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', {
@@ -1033,7 +1249,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', {
@@ -1048,7 +1264,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', {
@@ -1062,7 +1278,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', {
@@ -1076,24 +1292,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(`set .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',
@@ -1106,7 +1368,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',
@@ -1119,7 +1381,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
@@ -1143,8 +1405,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',
@@ -1157,10 +1419,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,
@@ -1171,15 +1433,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`);
                     }
 
@@ -1187,34 +1448,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}`));
@@ -1371,7 +1604,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}`);
@@ -1404,19 +1637,19 @@ async function createSprinklers() {
                 try {
                     // object deleted
                     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"
+                        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"
                         // History - Objekt(Ordner.history) löschen
                         await adapter.delObjectAsync(resID + '.history'),
                         // Objekt(Ordner) löschen
@@ -1432,17 +1665,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);
     });
 }
+*/
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /**
  *
@@ -1456,31 +1692,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);
 
     /*
@@ -1502,11 +1733,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);