hoffmation-base 3.0.0-alpha.8 → 3.0.0-alpha.81

package/lib/server/devices/shelly/shellyTrv.d.ts

@@ -1,14 +1,14 @@
-/// <reference types="node" />
 import { ShellyDevice } from './shellyDevice';
-import { iHeater } from '../baseDeviceInterfaces';
-import { HeaterSettings } from '../../../models';
+import { iBatteryDevice, iHeater } from '../baseDeviceInterfaces';
+import { BatteryLevelChangeAction, HeaterSettings } from '../../../models';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
-export declare class ShellyTrv extends ShellyDevice implements iHeater {
+export declare class ShellyTrv extends ShellyDevice implements iHeater, iBatteryDevice {
+    /** @inheritDoc */
     settings: HeaterSettings;
-    get lastBatteryPersist(): number;
+    /** @inheritDoc */
     readonly persistHeaterInterval: NodeJS.Timeout;
-    get battery(): number;
-    get minimumLevel(): number;
+    protected _seasonTurnOff: boolean;
+    protected _roomTemperature: number;
     private _automaticMode;
     private _battery;
     private _iAutomaticInterval;
@@ -29,34 +29,53 @@ export declare class ShellyTrv extends ShellyDevice implements iHeater {
     private readonly _setEnableExternalTempId;
     private readonly _setPointTemperaturID;
     private readonly _valvePosId;
+    private _lastBatteryLevel;
+    private _batteryLevelCallbacks;
     constructor(pInfo: IoBrokerDeviceInfo);
-    protected _seasonTurnOff: boolean;
+    /** @inheritDoc */
+    get lastBatteryPersist(): number;
+    /** @inheritDoc */
+    get battery(): number;
+    get minimumLevel(): number;
+    /** @inheritDoc */
     get seasonTurnOff(): boolean;
+    /** @inheritDoc */
     set seasonTurnOff(value: boolean);
+    /** @inheritDoc */
     get desiredTemperature(): number;
+    /** @inheritDoc */
     set desiredTemperature(val: number);
-    protected _humidity: number;
-    get humidity(): number;
-    get sLevel(): string;
+    /** @inheritDoc */
     get iLevel(): number;
-    get sTemperatur(): string;
+    /** @inheritDoc */
     get iTemperature(): number;
-    protected _roomTemperature: number;
+    /** @inheritDoc */
     get roomTemperature(): number;
-    set roomTemperatur(val: number);
+    private set roomTemperatur(value);
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
+    /** @inheritDoc */
     checkAutomaticChange(): void;
-    stopAutomaticCheck(): void;
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
     persistHeater(): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    protected getNextPidLevel(): number;
-    private checkSeasonTurnOff;
+    /** @inheritDoc */
     persistBatteryDevice(): void;
+    /** @inheritDoc */
     dispose(): void;
-    recalcLevel(): void;
+    protected getNextPidLevel(): number;
+    private checkSeasonTurnOff;
+    private recalcLevel;
     private setMode;
     private setExternalTemperature;
     private setExternalTemperatureEnabled;
     private setValve;
     private setMinimumLevel;
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    private checkForBatteryChange;
 }

package/lib/server/devices/shelly/shellyTrv.js

@@ -9,21 +9,16 @@ const liquid_pid_1 = require("../../../liquid-pid");
 const deviceType_1 = require("../deviceType");
 const DeviceCapability_1 = require("../DeviceCapability");
 class ShellyTrv extends shellyDevice_1.ShellyDevice {
-    get lastBatteryPersist() {
-        return this._lastBatteryPersist;
-    }
-    get battery() {
-        return this._battery;
-    }
-    get minimumLevel() {
-        return this._minimumValveLevel;
-    }
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ShellyTrv);
+        /** @inheritDoc */
         this.settings = new models_1.HeaterSettings();
+        /** @inheritDoc */
         this.persistHeaterInterval = services_1.Utils.guardedInterval(() => {
             this.persistHeater();
         }, 5 * 60 * 1000, this, false);
+        this._seasonTurnOff = false;
+        this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         this._automaticMode = false;
         this._battery = -99;
         this._initialSeasonCheckDone = false;
@@ -46,9 +41,8 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             Kd: 9, // PID: Kd in 1/1000
         });
         this._lastBatteryPersist = 0;
-        this._seasonTurnOff = false;
-        this._humidity = 0;
-        this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._lastBatteryLevel = -1;
+        this._batteryLevelCallbacks = [];
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.heater);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
         this._setAutomaticModeId = `${this.info.fullID}.tmp.automaticTemperatureControl`;
@@ -62,9 +56,22 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             this.checkSeasonTurnOff();
         }, 0, 2, 0));
     }
+    /** @inheritDoc */
+    get lastBatteryPersist() {
+        return this._lastBatteryPersist;
+    }
+    /** @inheritDoc */
+    get battery() {
+        return this._battery;
+    }
+    get minimumLevel() {
+        return this._minimumValveLevel;
+    }
+    /** @inheritDoc */
     get seasonTurnOff() {
         return this._seasonTurnOff;
     }
+    /** @inheritDoc */
     set seasonTurnOff(value) {
         this._seasonTurnOff = value;
         if (value) {
@@ -74,9 +81,11 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
         }
         this.setMode(!this.settings.controlByPid);
     }
+    /** @inheritDoc */
     get desiredTemperature() {
         return this._desiredTemperatur;
     }
+    /** @inheritDoc */
     set desiredTemperature(val) {
         this._desiredTemperatur = val;
         if (this._targetTempVal === val) {
@@ -88,18 +97,11 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             this.log(models_1.LogLevel.Error, `Temperaturänderung ergab Fehler ${err}.`);
         });
     }
-    get humidity() {
-        return this._humidity;
-    }
-    get sLevel() {
-        return `${this._level * 100}%`;
-    }
+    /** @inheritDoc */
     get iLevel() {
         return this._level;
     }
-    get sTemperatur() {
-        return `${this.iTemperature}°C`;
-    }
+    /** @inheritDoc */
     get iTemperature() {
         if (this.settings.useOwnTemperatur) {
             return this._temperatur;
@@ -108,6 +110,7 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             return this._roomTemperature;
         }
     }
+    /** @inheritDoc */
     get roomTemperature() {
         return this._roomTemperature;
     }
@@ -121,6 +124,11 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             this.recalcLevel();
         }
     }
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback) {
+        this._batteryLevelCallbacks.push(pCallback);
+    }
+    /** @inheritDoc */
     checkAutomaticChange() {
         var _a;
         if (!this._initialSeasonCheckDone) {
@@ -156,19 +164,16 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             this.desiredTemperature = targetTemperature;
         }
     }
-    stopAutomaticCheck() {
-        if (this._iAutomaticInterval !== undefined) {
-            clearInterval(this._iAutomaticInterval);
-            this._iAutomaticInterval = undefined;
-        }
-    }
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur) {
         this.roomTemperatur = newTemperatur;
     }
+    /** @inheritDoc */
     persistHeater() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHeater(this);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         if (idSplit[3] === 'tmp' && idSplit[4] === 'valvePosition') {
             this.log(models_1.LogLevel.Trace, `Valve position update for ${this.info.customName} to "${state.val}"`);
@@ -195,30 +200,15 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
         }
         else if (idSplit[3] === 'bat' && idSplit[4] === 'value') {
             this._battery = state.val;
+            this.checkForBatteryChange();
             this.persistBatteryDevice();
             if (this._battery < 20) {
-                this.log(models_1.LogLevel.Warn, `Das Shelly Gerät hat unter 20% Batterie.`);
+                this.log(models_1.LogLevel.Warn, 'Das Shelly Gerät hat unter 20% Batterie.');
             }
         }
         super.update(idSplit, state, initial, true);
     }
-    getNextPidLevel() {
-        if (this.seasonTurnOff || this._roomTemperature < 0) {
-            return 0;
-        }
-        this._pidController.setPoint(this.desiredTemperature);
-        const newValue = this._pidController.calculate(this._roomTemperature);
-        this.log(models_1.LogLevel.Debug, `New PID Value ${newValue}% (cTemp: ${this._roomTemperature}, dTemp: ${this.desiredTemperature})`);
-        return newValue;
-    }
-    checkSeasonTurnOff() {
-        const desiredState = services_1.Utils.beetweenDays(new Date(), this.settings.seasonTurnOffDay, this.settings.seasonTurnOnDay);
-        if (desiredState !== this.seasonTurnOff || !this._initialSeasonCheckDone) {
-            this.log(models_1.LogLevel.Info, `Switching Seasonal Heating --> New seasonTurnOff: ${desiredState}`);
-            this.seasonTurnOff = desiredState;
-        }
-        this._initialSeasonCheckDone = true;
-    }
+    /** @inheritDoc */
     persistBatteryDevice() {
         var _a;
         const now = services_1.Utils.nowMS();
@@ -228,6 +218,7 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
         this._lastBatteryPersist = now;
     }
+    /** @inheritDoc */
     dispose() {
         if (this.persistHeaterInterval) {
             clearInterval(this.persistHeaterInterval);
@@ -238,6 +229,23 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
         }
         super.dispose();
     }
+    getNextPidLevel() {
+        if (this.seasonTurnOff || this._roomTemperature < 0) {
+            return 0;
+        }
+        this._pidController.setPoint(this.desiredTemperature);
+        const newValue = this._pidController.calculate(this._roomTemperature);
+        this.log(models_1.LogLevel.Debug, `New PID Value ${newValue}% (cTemp: ${this._roomTemperature}, dTemp: ${this.desiredTemperature})`);
+        return newValue;
+    }
+    checkSeasonTurnOff() {
+        const desiredState = services_1.Utils.beetweenDays(new Date(), this.settings.seasonTurnOffDay, this.settings.seasonTurnOnDay);
+        if (desiredState !== this.seasonTurnOff || !this._initialSeasonCheckDone) {
+            this.log(models_1.LogLevel.Info, `Switching Seasonal Heating --> New seasonTurnOff: ${desiredState}`);
+            this.seasonTurnOff = desiredState;
+        }
+        this._initialSeasonCheckDone = true;
+    }
     recalcLevel() {
         if (this.settings.useOwnTemperatur || this.seasonTurnOff || !this.settings.controlByPid) {
             return;
@@ -274,5 +282,18 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
     setMinimumLevel(pidForcedMinimum) {
         this.setState(this._minumumLevelId, pidForcedMinimum);
     }
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    checkForBatteryChange() {
+        const newLevel = this.battery;
+        if (newLevel == -1 || newLevel == this._lastBatteryLevel) {
+            return;
+        }
+        for (const cb of this._batteryLevelCallbacks) {
+            cb(new models_1.BatteryLevelChangeAction(this));
+        }
+        this._lastBatteryLevel = newLevel;
+    }
 }
 exports.ShellyTrv = ShellyTrv;

package/lib/server/devices/smartGarden/index.d.ts

@@ -0,0 +1,6 @@
+export * from './smartGardenService';
+export * from './smartGardenDeviceRegistrationInfo';
+export * from './smartGardenDevice';
+export * from './smartGardenSensor';
+export * from './smartGardenMower';
+export * from './smartGardenValve';

package/lib/server/devices/smartGarden/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./smartGardenService"), exports);
+__exportStar(require("./smartGardenDeviceRegistrationInfo"), exports);
+__exportStar(require("./smartGardenDevice"), exports);
+__exportStar(require("./smartGardenSensor"), exports);
+__exportStar(require("./smartGardenMower"), exports);
+__exportStar(require("./smartGardenValve"), exports);

package/lib/server/devices/smartGarden/smartGardenDevice.d.ts

@@ -0,0 +1,33 @@
+import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
+import { iDisposable } from '../../services';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { DeviceType } from '../deviceType';
+import { BatteryLevelChangeAction } from '../../../models';
+import { iBatteryDevice } from '../baseDeviceInterfaces';
+export declare class SmartGardenDevice extends IoBrokerBaseDevice implements iDisposable, iBatteryDevice {
+    protected _criticalBatteryLevel: number;
+    protected readonly _deviceSerial: string;
+    private _lastUpdate;
+    private _lastBatteryLevel;
+    private _batteryLevelCallbacks;
+    private _lastBatteryPersist;
+    private _battery;
+    constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    /** @inheritDoc */
+    get lastBatteryPersist(): number;
+    /** @inheritDoc */
+    get battery(): number;
+    get lastUpdate(): Date;
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    /** @inheritDoc */
+    persistBatteryDevice(): void;
+    /** @inheritDoc */
+    dispose(): void;
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    private checkForBatteryChange;
+}

package/lib/server/devices/smartGarden/smartGardenDevice.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartGardenDevice = void 0;
+const IoBrokerBaseDevice_1 = require("../IoBrokerBaseDevice");
+const services_1 = require("../../services");
+const models_1 = require("../../../models");
+const DeviceCapability_1 = require("../DeviceCapability");
+class SmartGardenDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
+    constructor(pInfo, pType) {
+        super(pInfo, pType);
+        this._criticalBatteryLevel = 20;
+        this._lastUpdate = new Date(0);
+        this._lastBatteryLevel = -1;
+        this._batteryLevelCallbacks = [];
+        this._lastBatteryPersist = 0;
+        this._battery = -99;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
+        this._deviceSerial = pInfo.devID.replace('DEVICE_', '');
+    }
+    /** @inheritDoc */
+    get lastBatteryPersist() {
+        return this._lastBatteryPersist;
+    }
+    /** @inheritDoc */
+    get battery() {
+        return this._battery;
+    }
+    get lastUpdate() {
+        return this._lastUpdate;
+    }
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback) {
+        this._batteryLevelCallbacks.push(pCallback);
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, pOverride = false) {
+        this.log(models_1.LogLevel.DeepTrace, `Smartgarden: ${initial ? 'Initiales ' : ''}Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        if (!pOverride) {
+            this.log(models_1.LogLevel.Warn, `Keine Update Überschreibung:\n\tID: ${idSplit.join('.')}\n\tData: ${JSON.stringify(state)}`);
+        }
+        const stateLastUpdate = new Date(state.ts);
+        if (stateLastUpdate > this._lastUpdate) {
+            this._lastUpdate = stateLastUpdate;
+        }
+        if (idSplit.length < 6) {
+            return;
+        }
+        const folder = idSplit[4];
+        const stateName = idSplit[5];
+        if (folder.indexOf('SERVICE_COMMON') === 0) {
+            switch (stateName) {
+                case 'batteryLevel_value':
+                    this._battery = state.val;
+                    this.checkForBatteryChange();
+                    this.persistBatteryDevice();
+                    if (this._battery < this._criticalBatteryLevel) {
+                        this.log(models_1.LogLevel.Warn, 'This SmartGarden device reached critical battery level.');
+                    }
+                    break;
+            }
+        }
+        this.stateMap.set(idSplit[5], state);
+        const individualCallbacks = this.individualStateCallbacks.get(idSplit[5]);
+        if (individualCallbacks !== undefined) {
+            for (const cb of individualCallbacks) {
+                cb(state.val);
+            }
+        }
+    }
+    /** @inheritDoc */
+    persistBatteryDevice() {
+        var _a;
+        const now = services_1.Utils.nowMS();
+        if (this._lastBatteryPersist + 60000 > now) {
+            return;
+        }
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
+        this._lastBatteryPersist = now;
+    }
+    /** @inheritDoc */
+    dispose() {
+        // Nothing yet
+    }
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    checkForBatteryChange() {
+        const newLevel = this.battery;
+        if (newLevel == -1 || newLevel == this._lastBatteryLevel) {
+            return;
+        }
+        for (const cb of this._batteryLevelCallbacks) {
+            cb(new models_1.BatteryLevelChangeAction(this));
+        }
+        this._lastBatteryLevel = newLevel;
+    }
+}
+exports.SmartGardenDevice = SmartGardenDevice;

package/lib/server/devices/smartGarden/smartGardenDeviceRegistrationInfo.d.ts

@@ -0,0 +1,9 @@
+import { DeviceType } from '../deviceType';
+export declare class SmartGardenDeviceRegistrationInfo {
+    readonly deviceType: DeviceType;
+    readonly deviceId: string;
+    readonly deviceName: string;
+    readonly room: string;
+    readonly roomIndex: number;
+    constructor(deviceType: DeviceType, deviceId: string, deviceName: string, room: string, roomIndex: number);
+}

package/lib/server/devices/smartGarden/smartGardenDeviceRegistrationInfo.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartGardenDeviceRegistrationInfo = void 0;
+class SmartGardenDeviceRegistrationInfo {
+    constructor(deviceType, deviceId, deviceName, room, roomIndex) {
+        this.deviceType = deviceType;
+        this.deviceId = deviceId;
+        this.deviceName = deviceName;
+        this.room = room;
+        this.roomIndex = roomIndex;
+    }
+}
+exports.SmartGardenDeviceRegistrationInfo = SmartGardenDeviceRegistrationInfo;

package/lib/server/devices/smartGarden/smartGardenMower.d.ts

@@ -0,0 +1,35 @@
+import { SmartGardenDevice } from './smartGardenDevice';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { iActuator } from '../baseDeviceInterfaces';
+import { BlockAutomaticHandler } from '../../services/blockAutomaticHandler';
+import { ActuatorSetStateCommand, ActuatorSettings, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, RestoreTargetAutomaticValueCommand } from '../../../models';
+export declare class SmartGardenMower extends SmartGardenDevice implements iActuator {
+    /** @inheritDoc */
+    readonly blockAutomationHandler: BlockAutomaticHandler;
+    /** @inheritDoc */
+    targetAutomaticState: boolean;
+    /** @inheritDoc */
+    settings: ActuatorSettings;
+    /** @inheritDoc */
+    queuedValue: boolean | null;
+    private _lastPersist;
+    private readonly _activityControlStateId;
+    private _actuatorOn;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get actuatorOn(): boolean;
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    setActuator(command: ActuatorSetStateCommand): void;
+    /** @inheritDoc */
+    persist(): void;
+    /** @inheritDoc */
+    toggleActuator(command: ActuatorToggleCommand): boolean;
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
+    private park;
+    private mov;
+}

package/lib/server/devices/smartGarden/smartGardenMower.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartGardenMower = void 0;
+const smartGardenDevice_1 = require("./smartGardenDevice");
+const deviceType_1 = require("../deviceType");
+const DeviceCapability_1 = require("../DeviceCapability");
+const blockAutomaticHandler_1 = require("../../services/blockAutomaticHandler");
+const models_1 = require("../../../models");
+const sharedFunctions_1 = require("../sharedFunctions");
+const services_1 = require("../../services");
+class SmartGardenMower extends smartGardenDevice_1.SmartGardenDevice {
+    constructor(pInfo) {
+        super(pInfo, deviceType_1.DeviceType.SmartGardenMower);
+        /** @inheritDoc */
+        this.targetAutomaticState = false;
+        /** @inheritDoc */
+        this.settings = new models_1.ActuatorSettings();
+        /** @inheritDoc */
+        this.queuedValue = null;
+        this._lastPersist = 0;
+        this._actuatorOn = false;
+        this._activityControlStateId = `${pInfo.fullID}.SERVICE_MOWER_${this._deviceSerial}.activity_control_i`;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.actuator);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.blockAutomatic);
+        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
+    }
+    /** @inheritDoc */
+    get actuatorOn() {
+        return this._actuatorOn;
+    }
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c) {
+        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState));
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.queuedValue = null;
+        super.update(idSplit, state, initial, true);
+        if (idSplit.length < 6) {
+            return;
+        }
+        const folder = idSplit[4];
+        const stateName = idSplit[5];
+        if (folder.indexOf('SERVICE_MOWER') === 0) {
+            switch (stateName) {
+                case 'activity_mowing_i':
+                    this._actuatorOn = state.val;
+                    this.persist();
+                    break;
+            }
+        }
+    }
+    /** @inheritDoc */
+    setActuator(command) {
+        if (this._activityControlStateId === '') {
+            this.log(models_1.LogLevel.Error, 'Keine Switch ID bekannt.');
+            return;
+        }
+        sharedFunctions_1.LampUtils.setActuator(this, command);
+    }
+    /** @inheritDoc */
+    persist() {
+        var _a;
+        const now = services_1.Utils.nowMS();
+        if (this._lastPersist + 1000 > now) {
+            return;
+        }
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+        this._lastPersist = now;
+    }
+    /** @inheritDoc */
+    toggleActuator(command) {
+        const newVal = this.queuedValue !== null ? !this.queuedValue : !this._actuatorOn;
+        const setStateCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, command);
+        this.setActuator(setStateCommand);
+        return newVal;
+    }
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c) {
+        if (!c.stateValue) {
+            this.park();
+            return;
+        }
+        // TODO: Add settings for duration
+        this.mov(4 * 60 * 60);
+    }
+    park(pauseGardenaPlan = true) {
+        if (pauseGardenaPlan) {
+            this.log(models_1.LogLevel.Info, 'Pausing Gardena Plan');
+            this.setState(this._activityControlStateId, 'PARK_UNTIL_FURTHER_NOTICE', undefined, (err) => {
+                this.log(models_1.LogLevel.Error, `Pausing gardena mower resulted in error: ${err}`);
+            });
+            return;
+        }
+        this.log(models_1.LogLevel.Info, 'Pausing until next task');
+        this.setState(this._activityControlStateId, 'PARK_UNTIL_NEXT_TASK', undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Pausing gardena mower resulted in error: ${err}`);
+        });
+    }
+    mov(durationInSeconds) {
+        this.log(models_1.LogLevel.Info, `Start moving for ${durationInSeconds} seconds`);
+        this.setState(this._activityControlStateId, durationInSeconds.toString(10), undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Starting gardena mower resulted in error: ${err}`);
+        });
+    }
+}
+exports.SmartGardenMower = SmartGardenMower;

package/lib/server/devices/smartGarden/smartGardenSensor.d.ts

@@ -0,0 +1,42 @@
+import { iHumiditySensor, iTemperatureSensor } from '../baseDeviceInterfaces';
+import { SmartGardenDevice } from './smartGardenDevice';
+import { HumiditySensorChangeAction, TemperatureSensorChangeAction } from '../../../models';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class SmartGardenSensor extends SmartGardenDevice implements iHumiditySensor, iTemperatureSensor {
+    /** @inheritDoc */
+    readonly persistHumiditySensorInterval: NodeJS.Timeout;
+    /** @inheritDoc */
+    readonly persistTemperatureSensorInterval: NodeJS.Timeout;
+    private _humidityCallbacks;
+    private _humidity;
+    private _roomTemperature;
+    private _temperature;
+    private _temperaturCallbacks;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get roomTemperature(): number;
+    /** @inheritDoc */
+    set roomTemperature(value: number);
+    /** @inheritDoc */
+    get humidity(): number;
+    private set humidity(value);
+    /** @inheritDoc */
+    get iTemperature(): number;
+    /** @inheritDoc */
+    get sTemperature(): string;
+    private set temperature(value);
+    /** @inheritDoc */
+    addHumidityCallback(pCallback: (action: HumiditySensorChangeAction) => void): void;
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback: (action: TemperatureSensorChangeAction) => void): void;
+    /** @inheritDoc */
+    onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
+    persistHumiditySensor(): void;
+    /** @inheritDoc */
+    persistTemperaturSensor(): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
+}