hoffmation-base 2.15.10 → 2.16.1

package/lib/server/devices/IoBrokerDeviceInfo.d.ts

@@ -9,6 +9,8 @@ export declare class IoBrokerDeviceInfo extends DeviceInfo {
     channel?: number;
     valueName?: string;
     devConf: deviceConfig;
+    static idSplitter(id: string): string[];
+    private static replaceInvalidIdChars;
     /**
      * Extracts the relevant infos from the passed deviceConfig and combines them in a new Info object
      * @param {deviceConfig} pDevConf The device Config based on the extracted devices.json from ioBroker

package/lib/server/devices/IoBrokerDeviceInfo.js

@@ -7,6 +7,16 @@ exports.IoBrokerDeviceInfo = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const DeviceInfo_1 = require("./DeviceInfo");
 class IoBrokerDeviceInfo extends DeviceInfo_1.DeviceInfo {
+    static idSplitter(id) {
+        const split = id.split('.');
+        if (split[2] !== undefined) {
+            split[2] = this.replaceInvalidIdChars(split[2]);
+        }
+        return split;
+    }
+    static replaceInvalidIdChars(idPart) {
+        return idPart.replace(/[#\-]/g, '_');
+    }
     /**
      * Extracts the relevant infos from the passed deviceConfig and combines them in a new Info object
      * @param {deviceConfig} pDevConf The device Config based on the extracted devices.json from ioBroker
@@ -17,7 +27,7 @@ class IoBrokerDeviceInfo extends DeviceInfo_1.DeviceInfo {
         super();
         this.devConf = pDevConf;
         this.type = pDevConf.type;
-        const idSplit = pDevConf._id.split('.');
+        const idSplit = IoBrokerDeviceInfo.idSplitter(pDevConf._id);
         this.fullID = pDevConf._id;
         this.devID = idSplit[2];
         this.fullName = pDevConf.common.name;

package/lib/server/devices/deviceType.d.ts

@@ -36,10 +36,11 @@ export declare enum DeviceType {
     ZigbeeOsramDimmer = 222,
     ZigbeeIkeaShutter = 223,
     ZigbeeUbisysActuator = 224,
-    ZigbeeUbisysLampe = 224,
-    ZigbeeInnr142C = 225,
+    ZigbeeUbisysLampe = 225,
+    ZigbeeInnr142C = 226,
     JsEnergyManager = 301,
     RoomScene = 401,
+    ShellyTrv = 402,
     WledDevice = 1001,
     Daikin = 2001,
     Sonos = 3001,

package/lib/server/devices/deviceType.js

@@ -40,10 +40,11 @@ var DeviceType;
     DeviceType[DeviceType["ZigbeeOsramDimmer"] = 222] = "ZigbeeOsramDimmer";
     DeviceType[DeviceType["ZigbeeIkeaShutter"] = 223] = "ZigbeeIkeaShutter";
     DeviceType[DeviceType["ZigbeeUbisysActuator"] = 224] = "ZigbeeUbisysActuator";
-    DeviceType[DeviceType["ZigbeeUbisysLampe"] = 224] = "ZigbeeUbisysLampe";
-    DeviceType[DeviceType["ZigbeeInnr142C"] = 225] = "ZigbeeInnr142C";
+    DeviceType[DeviceType["ZigbeeUbisysLampe"] = 225] = "ZigbeeUbisysLampe";
+    DeviceType[DeviceType["ZigbeeInnr142C"] = 226] = "ZigbeeInnr142C";
     DeviceType[DeviceType["JsEnergyManager"] = 301] = "JsEnergyManager";
     DeviceType[DeviceType["RoomScene"] = 401] = "RoomScene";
+    DeviceType[DeviceType["ShellyTrv"] = 402] = "ShellyTrv";
     DeviceType[DeviceType["WledDevice"] = 1001] = "WledDevice";
     DeviceType[DeviceType["Daikin"] = 2001] = "Daikin";
     DeviceType[DeviceType["Sonos"] = 3001] = "Sonos";

package/lib/server/devices/deviceUpdater.js

@@ -5,12 +5,13 @@ const services_1 = require("../services");
 const models_1 = require("../../models");
 const devices_1 = require("./devices");
 const mqtt_1 = require("./mqtt");
+const IoBrokerDeviceInfo_1 = require("./IoBrokerDeviceInfo");
 class DeviceUpdater {
     constructor(pDevices) {
         this.devices = pDevices;
     }
     updateObject(pId, pObj) {
-        const idSplit = pId.split('.');
+        const idSplit = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.idSplitter(pId);
         if (idSplit.length < 2)
             return;
         if (idSplit[0] === devices_1.Devices.IDENTIFIER_HOMEMATIC) {
@@ -23,7 +24,7 @@ class DeviceUpdater {
             // Ignore null states
             return;
         }
-        const idSplit = id.split('.');
+        const idSplit = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.idSplitter(id);
         if (idSplit.length < 2)
             return;
         if (idSplit[0] == 'mqtt') {

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

@@ -5,6 +5,7 @@ import { iConfig } from '../config';
 export declare class Devices {
     static IDENTIFIER_HOMEMATIC: string;
     static IDENTIFIER_JS: string;
+    static IDENTIFIER_Shelly: string;
     static IDENTIFIER_ZIGBEE: string;
     static IDENTIFIER_WLED: string;
     static alLDevices: {
@@ -19,6 +20,7 @@ export declare class Devices {
     static midnightReset(): void;
     static resetDetectionsToday(): void;
     static getBatteryInfo(): string;
+    private static processShellyDevice;
     private static processZigbeeDevice;
     private static processWledDevice;
     private static processHMIPDevice;

package/lib/server/devices/devices.js

@@ -10,6 +10,7 @@ const IoBrokerDeviceInfo_1 = require("./IoBrokerDeviceInfo");
 const jsObject_1 = require("./jsObject");
 const wledDevice_1 = require("./wledDevice");
 const DeviceCapability_1 = require("./DeviceCapability");
+const shelly_1 = require("./shelly");
 class Devices {
     constructor(pDeviceData, pRoomImportEnforcer, config) {
         var _a;
@@ -35,6 +36,9 @@ class Devices {
             else if (cName.indexOf('00-WLED') === 0) {
                 Devices.processWledDevice(cDevConf);
             }
+            else if (cName.indexOf('00-Shelly') === 0) {
+                Devices.processShellyDevice(cDevConf);
+            }
             else if (cName.indexOf('00-EnergyManager') === 0 &&
                 cDevConf.type !== 'folder' &&
                 !((_a = config === null || config === void 0 ? void 0 : config.energyManager) === null || _a === void 0 ? void 0 : _a.disableJsEnergyManager)) {
@@ -44,6 +48,7 @@ class Devices {
         }
         hmIPDevices_1.HmIPDevice.checkMissing();
         zigbee_1.ZigbeeDevice.checkMissing();
+        shelly_1.ShellyDevice.checkMissing();
     }
     static midnightReset() {
         // Nothing yet
@@ -81,6 +86,25 @@ class Devices {
         }
         return result.join('\n');
     }
+    static processShellyDevice(cDevConf) {
+        const shellyInfo = new IoBrokerDeviceInfo_1.IoBrokerDeviceInfo(cDevConf);
+        const fullName = `${Devices.IDENTIFIER_Shelly}-${shellyInfo.devID}`;
+        shellyInfo.allDevicesKey = fullName;
+        if (typeof Devices.alLDevices[fullName] !== 'undefined') {
+            return;
+        }
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `Shelly ${shellyInfo.devID} with Type "${shellyInfo.deviceType}" doesn't exists --> create it`);
+        let d;
+        switch (shellyInfo.deviceType) {
+            case 'Trv':
+                d = new shelly_1.ShellyTrv(shellyInfo);
+                break;
+            default:
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `No shelly Device Type for ${shellyInfo.deviceType} defined`);
+                d = new shelly_1.ShellyDevice(shellyInfo, deviceType_1.DeviceType.unknown);
+        }
+        Devices.alLDevices[fullName] = d;
+    }
     static processZigbeeDevice(cDevConf) {
         const zigbeeInfo = new IoBrokerDeviceInfo_1.IoBrokerDeviceInfo(cDevConf);
         const fullName = `${Devices.IDENTIFIER_ZIGBEE}-${zigbeeInfo.devID}`;
@@ -249,6 +273,7 @@ class Devices {
 exports.Devices = Devices;
 Devices.IDENTIFIER_HOMEMATIC = 'hm-rpc';
 Devices.IDENTIFIER_JS = 'javascript';
+Devices.IDENTIFIER_Shelly = 'shelly';
 Devices.IDENTIFIER_ZIGBEE = 'zigbee';
 Devices.IDENTIFIER_WLED = 'wled';
 Devices.alLDevices = {};

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

@@ -7,6 +7,7 @@ export * from './hmIPDevices/index';
 export * from './jsObject/index';
 export * from './models/index';
 export * from './scene/index';
+export * from './shelly/index';
 export * from './zigbee/index';
 export * from './device-cluster';
 export * from './device-cluster-type';

package/lib/server/devices/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./hmIPDevices/index"), exports);
 __exportStar(require("./jsObject/index"), exports);
 __exportStar(require("./models/index"), exports);
 __exportStar(require("./scene/index"), exports);
+__exportStar(require("./shelly/index"), exports);
 __exportStar(require("./zigbee/index"), exports);
 __exportStar(require("./device-cluster"), exports);
 __exportStar(require("./device-cluster-type"), exports);

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

@@ -0,0 +1,2 @@
+export { ShellyDevice } from './shellyDevice';
+export { ShellyTrv } from './shellyTrv';

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellyTrv = exports.ShellyDevice = void 0;
+var shellyDevice_1 = require("./shellyDevice");
+Object.defineProperty(exports, "ShellyDevice", { enumerable: true, get: function () { return shellyDevice_1.ShellyDevice; } });
+var shellyTrv_1 = require("./shellyTrv");
+Object.defineProperty(exports, "ShellyTrv", { enumerable: true, get: function () { return shellyTrv_1.ShellyTrv; } });

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

@@ -0,0 +1,12 @@
+import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
+import { iDisposable } from '../../services';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { DeviceType } from '../deviceType';
+export declare class ShellyDevice extends IoBrokerBaseDevice implements iDisposable {
+    private _lastUpdate;
+    get lastUpdate(): Date;
+    stateMap: Map<string, ioBroker.State>;
+    constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellyDevice = void 0;
+const IoBrokerBaseDevice_1 = require("../IoBrokerBaseDevice");
+const models_1 = require("../../../models");
+class ShellyDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
+    get lastUpdate() {
+        return this._lastUpdate;
+    }
+    constructor(pInfo, pType) {
+        super(pInfo, pType);
+        this._lastUpdate = new Date(0);
+        this.stateMap = new Map();
+    }
+    update(idSplit, state, initial = false, pOverride = false) {
+        this.log(models_1.LogLevel.DeepTrace, `Shelly: ${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;
+        }
+        this.stateMap.set(idSplit[3], state);
+        const individualCallbacks = this.individualStateCallbacks.get(idSplit[3]);
+        if (individualCallbacks !== undefined) {
+            for (const cb of individualCallbacks) {
+                cb(state.val);
+            }
+        }
+    }
+    dispose() {
+        // Nothing yet
+    }
+}
+exports.ShellyDevice = ShellyDevice;

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

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import { ShellyDevice } from './shellyDevice';
+import { iHeater } from '../baseDeviceInterfaces';
+import { HeaterSettings } from '../../../models';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class ShellyTrv extends ShellyDevice implements iHeater {
+    settings: HeaterSettings;
+    get lastBatteryPersist(): number;
+    readonly persistHeaterInterval: NodeJS.Timeout;
+    get battery(): number;
+    private _automaticMode;
+    private _battery;
+    private _iAutomaticInterval;
+    private _initialSeasonCheckDone;
+    private _lastRecalc;
+    private _level;
+    private _recalcTimeout;
+    private _temperatur;
+    private _targetTempVal;
+    private _desiredTemperatur;
+    private _useExternalTemperatureEnabled;
+    private _pidController;
+    private _lastBatteryPersist;
+    private readonly _batteryId;
+    private readonly _setAutomaticModeId;
+    private readonly _setExternalTempId;
+    private readonly _setEnableExternalTempId;
+    private readonly _setPointTemperaturID;
+    private readonly _temperatureId;
+    private readonly _valvePosId;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    protected _seasonTurnOff: boolean;
+    get seasonTurnOff(): boolean;
+    set seasonTurnOff(value: boolean);
+    get desiredTemperature(): number;
+    set desiredTemperature(val: number);
+    protected _humidity: number;
+    get humidity(): number;
+    get sLevel(): string;
+    get iLevel(): number;
+    get sTemperatur(): string;
+    get iTemperature(): number;
+    protected _roomTemperature: number;
+    get roomTemperature(): number;
+    set roomTemperatur(val: number);
+    checkAutomaticChange(): void;
+    stopAutomaticCheck(): void;
+    onTemperaturChange(newTemperatur: number): void;
+    persistHeater(): void;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    protected getNextPidLevel(): number;
+    private checkSeasonTurnOff;
+    persistBatteryDevice(): void;
+    dispose(): void;
+    recalcLevel(): void;
+    private setMode;
+    private setExternalTemperature;
+    private setExternalTemperatureEnabled;
+    private setValve;
+}

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

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellyTrv = void 0;
+const shellyDevice_1 = require("./shellyDevice");
+const baseDeviceInterfaces_1 = require("../baseDeviceInterfaces");
+const services_1 = require("../../services");
+const models_1 = require("../../../models");
+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;
+    }
+    constructor(pInfo) {
+        super(pInfo, deviceType_1.DeviceType.ShellyTrv);
+        this.settings = new models_1.HeaterSettings();
+        this.persistHeaterInterval = services_1.Utils.guardedInterval(() => {
+            this.persistHeater();
+        }, 5 * 60 * 1000, this, false);
+        this._automaticMode = false;
+        this._battery = -99;
+        this._initialSeasonCheckDone = false;
+        this._lastRecalc = 0;
+        this._level = 0;
+        this._recalcTimeout = null;
+        this._temperatur = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._targetTempVal = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._desiredTemperatur = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._useExternalTemperatureEnabled = false;
+        this._pidController = new liquid_pid_1.PIDController({
+            temp: {
+                ref: 20, // Point temperature
+            },
+            Pmax: 100,
+            // Tune the PID Controller
+            Kp: 25,
+            Ki: 1000,
+            Kd: 9, // PID: Kd in 1/1000
+        });
+        this._lastBatteryPersist = 0;
+        this._seasonTurnOff = false;
+        this._humidity = 0;
+        this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.heater);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
+        this._batteryId = `${this.info.fullID}.bat.value`;
+        this._setAutomaticModeId = `${this.info.fullID}.tmp.automaticTemperatureControl`;
+        this._setExternalTempId = `${this.info.fullID}.ext.temperature`;
+        this._setEnableExternalTempId = `${this.info.fullID}.ext.enabled`;
+        this._setPointTemperaturID = `${this.info.fullID}.tmp.temperatureC`;
+        this._temperatureId = `${this.info.fullID}.tmp.valvePosition`;
+        this._valvePosId = `${this.info.fullID}.tmp.valvePosition`;
+        this._iAutomaticInterval = services_1.Utils.guardedInterval(this.checkAutomaticChange, 300000, this); // Alle 5 Minuten prüfen
+        services_1.TimeCallbackService.addCallback(new models_1.TimeCallback(`${this.info.fullID} Season Check`, models_1.TimeCallbackType.TimeOfDay, () => {
+            this.checkSeasonTurnOff();
+        }, 0, 2, 0));
+    }
+    get seasonTurnOff() {
+        return this._seasonTurnOff;
+    }
+    set seasonTurnOff(value) {
+        this._seasonTurnOff = value;
+        if (value) {
+            this.setMode(false);
+            this.setValve(0);
+            return;
+        }
+        this.setMode(!this.settings.controlByPid);
+    }
+    get desiredTemperature() {
+        return this._desiredTemperatur;
+    }
+    set desiredTemperature(val) {
+        this._desiredTemperatur = val;
+        if (this._targetTempVal === val) {
+            return;
+        }
+        this.setState(this._setPointTemperaturID, val, () => {
+            this.log(models_1.LogLevel.Info, `Changed temperature of to "${val}.`);
+        }, (err) => {
+            this.log(models_1.LogLevel.Error, `Temperaturänderung ergab Fehler ${err}.`);
+        });
+    }
+    get humidity() {
+        return this._humidity;
+    }
+    get sLevel() {
+        return `${this._level * 100}%`;
+    }
+    get iLevel() {
+        return this._level;
+    }
+    get sTemperatur() {
+        return `${this.iTemperature}°C`;
+    }
+    get iTemperature() {
+        if (this.settings.useOwnTemperatur) {
+            return this._temperatur;
+        }
+        else {
+            return this._roomTemperature;
+        }
+    }
+    get roomTemperature() {
+        return this._roomTemperature;
+    }
+    set roomTemperatur(val) {
+        this._roomTemperature = val;
+        if (this.settings.useOwnTemperatur) {
+            return;
+        }
+        this.setExternalTemperature(val);
+        if (this.settings.controlByPid) {
+            this.recalcLevel();
+        }
+    }
+    checkAutomaticChange() {
+        var _a, _b, _c, _d, _e, _f;
+        if (!this._initialSeasonCheckDone) {
+            this.checkSeasonTurnOff();
+        }
+        if (this.seasonTurnOff) {
+            return;
+        }
+        if (!this.settings.useOwnTemperatur && !this.settings.controlByPid) {
+            this.setExternalTemperatureEnabled(true);
+        }
+        const heatGroupSettings = (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.HeatGroup) === null || _b === void 0 ? void 0 : _b.settings;
+        if ((heatGroupSettings === null || heatGroupSettings === void 0 ? void 0 : heatGroupSettings.automaticMode) == false) {
+            this.desiredTemperature = heatGroupSettings.manualTemperature;
+            return;
+        }
+        if (!this.settings.automaticMode) {
+            return;
+        }
+        const setting = models_1.TemperatureSettings.getActiveSetting((_f = (_e = (_d = (_c = this.room) === null || _c === void 0 ? void 0 : _c.HeatGroup) === null || _d === void 0 ? void 0 : _d.settings) === null || _e === void 0 ? void 0 : _e.automaticPoints) !== null && _f !== void 0 ? _f : [], new Date());
+        if (setting === undefined) {
+            this.log(models_1.LogLevel.Warn, `Undefined Heating Timestamp.`);
+            this.desiredTemperature = this.settings.automaticFallBackTemperatur;
+            return;
+        }
+        if (this._desiredTemperatur !== setting.temperature) {
+            this.log(models_1.LogLevel.Debug, `Automatische Temperaturanpassung für ${this.info.customName} auf ${setting.temperature}°C`);
+            this.desiredTemperature = setting.temperature;
+        }
+    }
+    stopAutomaticCheck() {
+        if (this._iAutomaticInterval !== undefined) {
+            clearInterval(this._iAutomaticInterval);
+            this._iAutomaticInterval = undefined;
+        }
+    }
+    onTemperaturChange(newTemperatur) {
+        this.roomTemperatur = newTemperatur;
+    }
+    persistHeater() {
+        var _a;
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHeater(this);
+    }
+    update(idSplit, state, initial = false) {
+        const fullId = idSplit.join('.');
+        switch (fullId) {
+            case this._valvePosId:
+                this.log(models_1.LogLevel.Trace, `Valve position update for ${this.info.customName} to "${state.val}"`);
+                this._level = state.val / 100;
+                break;
+            case this._setEnableExternalTempId:
+                this._useExternalTemperatureEnabled = state.val;
+                break;
+            case this._temperatureId:
+                this._temperatur = state.val;
+                break;
+            case this._setAutomaticModeId:
+                this._automaticMode = state.val;
+                const desiredMode = !this.settings.controlByPid;
+                if (this._automaticMode !== desiredMode) {
+                    this.setMode(desiredMode);
+                }
+                break;
+            case this._setPointTemperaturID:
+                this._targetTempVal = state.val;
+                break;
+            case this._batteryId:
+                this._battery = state.val;
+                this.persistBatteryDevice();
+                if (this._battery < 20) {
+                    this.log(models_1.LogLevel.Warn, `Das Shelly Gerät hat unter 20% Batterie.`);
+                }
+                break;
+        }
+        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;
+    }
+    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;
+    }
+    dispose() {
+        if (this.persistHeaterInterval) {
+            clearInterval(this.persistHeaterInterval);
+        }
+        if (this._iAutomaticInterval) {
+            clearInterval(this._iAutomaticInterval);
+            this._iAutomaticInterval = undefined;
+        }
+        super.dispose();
+    }
+    recalcLevel() {
+        if (this.settings.useOwnTemperatur || this.seasonTurnOff || !this.settings.controlByPid) {
+            return;
+        }
+        const msTilNextMinimumCheck = this._lastRecalc + 5 * 60 * 1000 - services_1.Utils.nowMS();
+        if (msTilNextMinimumCheck > 0) {
+            if (this._recalcTimeout == null) {
+                this._recalcTimeout = services_1.Utils.guardedTimeout(this.recalcLevel, msTilNextMinimumCheck, this);
+            }
+            return;
+        }
+        this.setValve(Math.max(this.getNextPidLevel(), this.settings.pidForcedMinimum));
+    }
+    setMode(automatic) {
+        this.setState(this._setAutomaticModeId, automatic);
+    }
+    setExternalTemperature(value) {
+        this.setState(this._setExternalTempId, value);
+    }
+    setExternalTemperatureEnabled(value) {
+        if (value === this._useExternalTemperatureEnabled) {
+            return;
+        }
+        this.setState(this._setEnableExternalTempId, value);
+    }
+    setValve(target) {
+        if (target == this._level) {
+            return;
+        }
+        this._level = target;
+        this.log(models_1.LogLevel.Info, `Setting Valve to new value: "${target}%"`);
+        this.setState(this._valvePosId, target);
+    }
+}
+exports.ShellyTrv = ShellyTrv;