hoffmation-base 3.0.3 → 3.1.1

package/lib/devices/zigbee/zigbeeEuroHeater.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeEuroHeater = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const interfaces_1 = require("../../interfaces");
+const enums_1 = require("../../enums");
+const utils_1 = require("../../utils");
+class ZigbeeEuroHeater extends BaseDevices_1.ZigbeeHeater {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.ZigbeeEuroHeater);
+        this._targetTempVal = interfaces_1.UNDEFINED_TEMP_VALUE;
+        this._localDiffTempVal = 0;
+        this._lastRecalc = 0;
+        this._mode = 1;
+        this._recalcTimeout = null;
+        this._dontSendOnUnavailable = true;
+        this._setPointTemperaturID = `${this.info.fullID}.heating_setpnt_current`;
+        this._setLocalTempCalibrationId = `${this.info.fullID}.local_temp_calibration`;
+        this._setModeId = `${this.info.fullID}.spz_trv_mode`;
+        this._valvePosId = `${this.info.fullID}.valve_position`;
+        this._forcedRefreshInterval = utils_1.Utils.guardedInterval(() => {
+            this.setMode(this.settings.controlByPid || this.seasonTurnOff ? 1 : 2);
+        }, 6 * 60 * 60 * 1000, this);
+    }
+    /** @inheritDoc */
+    get seasonTurnOff() {
+        return this._seasonTurnOff;
+    }
+    /** @inheritDoc */
+    set seasonTurnOff(value) {
+        this._seasonTurnOff = value;
+        if (value) {
+            this.setMode(1);
+            this.setValve(0);
+            return;
+        }
+        this.setMode(this.settings.controlByPid ? 1 : 2);
+    }
+    /** @inheritDoc */
+    get roomTemperature() {
+        return super.roomTemperature;
+    }
+    /** @inheritDoc */
+    get desiredTemperature() {
+        return this._desiredTemperatur;
+    }
+    /** @inheritDoc */
+    set desiredTemperature(val) {
+        this._desiredTemperatur = val;
+        this.recalcLevel();
+    }
+    set roomTemperature(value) {
+        super.roomTemperature = value;
+        if (this.settings.useOwnTemperatur) {
+            return;
+        }
+        this.recalcLevel();
+    }
+    get tempDiff() {
+        var _a, _b, _c, _d;
+        const tempChangeMs = (_b = (_a = this.stateMap.get('local_temp')) === null || _a === void 0 ? void 0 : _a.lc) !== null && _b !== void 0 ? _b : 0;
+        const calibChangeMs = (_d = (_c = this.stateMap.get('local_temp_calibration')) === null || _c === void 0 ? void 0 : _c.lc) !== null && _d !== void 0 ? _d : 0;
+        if (tempChangeMs < calibChangeMs) {
+            return this._targetTempVal - (this._temperatur + this._localDiffTempVal);
+        }
+        else {
+            return this._targetTempVal - this._temperatur;
+        }
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        switch (idSplit[3]) {
+            case 'valve_position':
+                this.log(enums_1.LogLevel.Trace, `Euro Valve valve_position Update for ${this.info.customName} to "${state.val}"`);
+                this._level = state.val / 100;
+                break;
+            case 'local_temp':
+                this.log(enums_1.LogLevel.Trace, `Euro Valve Local_Temp Update for ${this.info.customName} to "${state.val}"`);
+                this._temperatur = state.val;
+                if (!initial)
+                    this.checkTempDiff();
+                break;
+            case 'local_temp_calibration':
+                this.log(enums_1.LogLevel.Trace, `Euro Valve Local_Temp_calib Update for ${this.info.customName} to "${state.val}"`);
+                this._localDiffTempVal = state.val;
+                if (!initial)
+                    this.checkTempDiff();
+                if (initial && state.val !== 0) {
+                    this.setLocalDiff(0);
+                }
+                break;
+            case 'spz_trv_mode':
+                this.log(enums_1.LogLevel.Debug, `Received Euro Valve state update for spz_trv_mode to "${state.val}"`, enums_1.LogDebugType.EuroHeaterValveLogging);
+                this._mode = state.val;
+                const desiredMode = this.settings.controlByPid ? 1 : 2;
+                if (this._mode !== desiredMode) {
+                    this.setMode(desiredMode);
+                }
+                break;
+            case 'target_temperature':
+                this.log(enums_1.LogLevel.Trace, `Euro Valve Target_Temp Update for ${this.info.customName} to "${state.val}"`);
+                this._targetTempVal = state.val;
+                if (!initial)
+                    this.checkTempDiff(); // TODO: If we change it this results in an infinite loop
+                break;
+        }
+        super.update(idSplit, state, initial, true);
+    }
+    recalcLevel() {
+        if (this.seasonTurnOff || this.settings.manualDisabled) {
+            this.setValve(0);
+            this.setMode(1);
+            return;
+        }
+        if (this.settings.useOwnTemperatur || this.seasonTurnOff) {
+            return;
+        }
+        const msTilNextMinimumCheck = this._lastRecalc + 5 * 60 * 1000 - utils_1.Utils.nowMS();
+        if (msTilNextMinimumCheck > 0) {
+            if (this._recalcTimeout == null) {
+                this._recalcTimeout = utils_1.Utils.guardedTimeout(this.recalcLevel, msTilNextMinimumCheck, this);
+            }
+            return;
+        }
+        if (this.settings.controlByPid) {
+            this.setValve(Math.max(this.getNextPidLevel(), this.settings.pidForcedMinimum));
+            return;
+        }
+        this.checkTempDiff();
+    }
+    checkTempDiff() {
+        if (!this.settings.controlByTempDiff) {
+            return;
+        }
+        this._lastRecalc = utils_1.Utils.nowMS();
+        const desiredDiff = utils_1.Utils.round(this.desiredTemperature - this.roomTemperature, 1);
+        const currentDiff = this.tempDiff;
+        const missingDiff = utils_1.Utils.round(desiredDiff - currentDiff, 1);
+        if (Math.abs(missingDiff) < 0.15) {
+            // Desired diff is already properly established
+            return;
+        }
+        this.log(enums_1.LogLevel.Debug, `Calculating Euro Valve Diff, desiredDiff "${desiredDiff}", currentDiff "${currentDiff}", missingDiff "${missingDiff}"`);
+        if (Math.abs(desiredDiff) <= 9.0) {
+            // Check possible with local Diff only
+            this.setTargetTemperatur(this.desiredTemperature);
+            this.setLocalDiff(-1 * desiredDiff);
+            return;
+        }
+        const newLocalDiff = Math.sign(desiredDiff) * -9;
+        this.setLocalDiff(newLocalDiff);
+        this.setTargetTemperatur(this._temperatur + this.roomTemperature + newLocalDiff + this.desiredTemperature);
+    }
+    setLocalDiff(newLocalDiff) {
+        this.log(enums_1.LogLevel.Debug, `Setting new Local Calibration Diff (${newLocalDiff}) for Euro Valve`);
+        this.setState(this._setLocalTempCalibrationId, newLocalDiff);
+    }
+    setTargetTemperatur(targetTemp) {
+        this.log(enums_1.LogLevel.Debug, `Setting new Target Temp (${targetTemp}) for Euro Valve`);
+        this.setState(this._setPointTemperaturID, targetTemp);
+    }
+    /** @inheritDoc */
+    dispose() {
+        clearInterval(this._forcedRefreshInterval);
+    }
+    setValve(target) {
+        if (target == this._level) {
+            return;
+        }
+        this._level = target;
+        this.log(enums_1.LogLevel.Info, `Setting Valve to new value: "${target}%"`);
+        this.setState(this._valvePosId, target);
+        utils_1.Utils.guardedTimeout(() => {
+            this.triggerDeviceQuery();
+        }, 10000, this);
+    }
+    /**
+     * Sets the mode
+     * @param targetMode - (1 = manual valve, 2 = automatic temp based)
+     */
+    setMode(targetMode) {
+        this.setState(this._setModeId, targetMode);
+        this.log(enums_1.LogLevel.Info, `Changing spz_trv_mode to ${targetMode}`, enums_1.LogDebugType.EuroHeaterValveLogging);
+        utils_1.Utils.guardedTimeout(() => {
+            this.triggerDeviceQuery();
+        }, 10000, this);
+    }
+}
+exports.ZigbeeEuroHeater = ZigbeeEuroHeater;

package/lib/devices/zigbee/zigbeeHeimanSmoke.d.ts

@@ -0,0 +1,39 @@
+import { ZigbeeDevice } from './BaseDevices';
+import { iBatteryDevice, iSmokeDetectorDevice } from '../../interfaces';
+import { Battery } from '../sharedFunctions';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class ZigbeeHeimanSmoke extends ZigbeeDevice implements iBatteryDevice, iSmokeDetectorDevice {
+    /** @inheritDoc */
+    readonly battery: Battery;
+    /**
+     * The timeout for the alarm to fire again
+     * @default undefined (no alarm active)
+     */
+    iAlarmTimeout: NodeJS.Timeout | undefined;
+    private _smoke;
+    private _messageAlarmFirst;
+    private _messageAlarm;
+    private _messageAlarmEnd;
+    private _roomName;
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeHeimanSmoke}.
+     * @param pInfo - Device creation information
+     */
+    constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get batteryLevel(): number;
+    /** @inheritDoc */
+    get smoke(): boolean;
+    /**
+     * The name of the room the device is in (Set during initialization)
+     */
+    set roomName(val: string);
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    stopAlarm(quiet?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
+    private startAlarm;
+    private alarm;
+}

package/lib/devices/zigbee/zigbeeHeimanSmoke.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeHeimanSmoke = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const sharedFunctions_1 = require("../sharedFunctions");
+const enums_1 = require("../../enums");
+const services_1 = require("../../services");
+const utils_1 = require("../../utils");
+const command_1 = require("../../command");
+const i18n_1 = require("../../i18n");
+class ZigbeeHeimanSmoke extends BaseDevices_1.ZigbeeDevice {
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeHeimanSmoke}.
+     * @param pInfo - Device creation information
+     */
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.ZigbeeHeimanSmoke);
+        /** @inheritDoc */
+        this.battery = new sharedFunctions_1.Battery(this);
+        /**
+         * The timeout for the alarm to fire again
+         * @default undefined (no alarm active)
+         */
+        this.iAlarmTimeout = undefined;
+        this._smoke = false;
+        this._messageAlarmFirst = '';
+        this._messageAlarm = '';
+        this._messageAlarmEnd = '';
+        this._roomName = '';
+        this.deviceCapabilities.push(enums_1.DeviceCapability.batteryDriven);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.smokeSensor);
+        this._messageAlarmFirst = i18n_1.Res.fireAlarmStart(this._roomName, this.info.customName);
+        this._messageAlarm = i18n_1.Res.fireAlarmRepeat(this._roomName, this.info.customName);
+        this._messageAlarmEnd = i18n_1.Res.fireAlarmEnd(this._roomName);
+    }
+    /** @inheritDoc */
+    get batteryLevel() {
+        return this.battery.level;
+    }
+    /** @inheritDoc */
+    get smoke() {
+        return this._smoke;
+    }
+    /**
+     * The name of the room the device is in (Set during initialization)
+     */
+    set roomName(val) {
+        this._roomName = val;
+        this._messageAlarmFirst = i18n_1.Res.fireAlarmStart(this._roomName, this.info.customName);
+        this._messageAlarm = i18n_1.Res.fireAlarmRepeat(this._roomName, this.info.customName);
+        this._messageAlarmEnd = i18n_1.Res.fireAlarmEnd(this._roomName);
+        services_1.PollyService.preloadTTS(this._messageAlarmFirst);
+        services_1.PollyService.preloadTTS(this._messageAlarm);
+        services_1.PollyService.preloadTTS(this._messageAlarmEnd);
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `Smoke Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'battery':
+                this.battery.level = state.val;
+                if (this.batteryLevel < 20) {
+                    this.log(enums_1.LogLevel.Warn, 'Das Zigbee Gerät hat unter 20% Batterie.');
+                }
+                break;
+            case 'smoke':
+                this.log(enums_1.LogLevel.Debug, `Smoke Update für ${this.info.customName} auf Rauch: ${state.val}`);
+                const newVal = state.val === true;
+                if (this.smoke && !newVal) {
+                    this.stopAlarm();
+                }
+                else if (newVal) {
+                    this.startAlarm();
+                }
+                this._smoke = newVal;
+                break;
+        }
+    }
+    /** @inheritDoc */
+    stopAlarm(quiet = false) {
+        if (this.iAlarmTimeout) {
+            clearInterval(this.iAlarmTimeout);
+        }
+        if (quiet) {
+            return;
+        }
+        const message = this._messageAlarmEnd;
+        utils_1.Utils.guardedNewThread(() => {
+            this.log(enums_1.LogLevel.Alert, message);
+        });
+        utils_1.Utils.guardedNewThread(() => {
+            services_1.SonosService.speakOnAll(message);
+        });
+    }
+    /** @inheritDoc */
+    dispose() {
+        if (this.iAlarmTimeout) {
+            clearInterval(this.iAlarmTimeout);
+            this.iAlarmTimeout = undefined;
+        }
+        super.dispose();
+    }
+    startAlarm() {
+        if (this.iAlarmTimeout !== undefined) {
+            clearInterval(this.iAlarmTimeout);
+        }
+        this.iAlarmTimeout = utils_1.Utils.guardedInterval(() => {
+            this.alarm();
+        }, 15000, this);
+        this.alarm(true);
+    }
+    alarm(first = false) {
+        const message = first ? this._messageAlarmFirst : this._messageAlarm;
+        utils_1.Utils.guardedNewThread(() => {
+            this.log(enums_1.LogLevel.Alert, message);
+        });
+        utils_1.Utils.guardedNewThread(() => {
+            services_1.SonosService.speakOnAll(message, 100);
+        });
+        utils_1.Utils.guardedNewThread(() => {
+            // Roll all Rollos up, to ensure free sight for firefighters
+            services_1.RoomService.setAllShutterOfFloor(new command_1.FloorSetAllShuttersCommand(enums_1.CommandSource.Force, 100, undefined, 'Fire alarm'));
+        });
+    }
+}
+exports.ZigbeeHeimanSmoke = ZigbeeHeimanSmoke;

package/lib/devices/zigbee/zigbeeIkeaShutter.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIkeaShutter = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const enums_1 = require("../../enums");
+class ZigbeeIkeaShutter extends BaseDevices_1.ZigbeeShutter {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.ZigbeeIkeaShutter);
+        this._positionStateId = `${this.info.fullID}.position`;
+        // this.presenceStateID = `${this.info.fullID}.1.${HmIpPraezenz.PRESENCE_DETECTION}`;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        switch (idSplit[3]) {
+            case 'position':
+                this.log(enums_1.LogLevel.Trace, `Shutter Update for ${this.info.customName} to "${state.val}"`);
+                this.setCurrentLevel(state.val, initial);
+                break;
+        }
+        super.update(idSplit, state, initial, true);
+    }
+    moveToPosition(pPosition) {
+        this.setState(this._positionStateId, pPosition);
+    }
+}
+exports.ZigbeeIkeaShutter = ZigbeeIkeaShutter;

package/lib/devices/zigbee/zigbeeIkeaSteckdose.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIkeaSteckdose = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const enums_1 = require("../../enums");
+class ZigbeeIkeaSteckdose extends BaseDevices_1.ZigbeeActuator {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.ZigbeeIkeaSteckdose);
+        this._actuatorOnStateIdState = `${pInfo.fullID}.state`;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `Stecker Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+    }
+}
+exports.ZigbeeIkeaSteckdose = ZigbeeIkeaSteckdose;

package/lib/devices/zigbee/zigbeeIlluActuator.d.ts

@@ -0,0 +1,7 @@
+import { ZigbeeActuator } from './BaseDevices';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { DeviceType } from '../../enums';
+export declare class ZigbeeIlluActuator extends ZigbeeActuator {
+    protected readonly _actuatorOnStateIdState: string;
+    constructor(pInfo: IoBrokerDeviceInfo, deviceType?: DeviceType);
+}

package/lib/devices/zigbee/zigbeeIlluActuator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIlluActuator = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const enums_1 = require("../../enums");
+class ZigbeeIlluActuator extends BaseDevices_1.ZigbeeActuator {
+    constructor(pInfo, deviceType = enums_1.DeviceType.ZigbeeIlluActuator) {
+        super(pInfo, deviceType);
+        this._actuatorOnStateIdState = `${pInfo.fullID}.state`;
+    }
+}
+exports.ZigbeeIlluActuator = ZigbeeIlluActuator;

package/lib/devices/zigbee/zigbeeIlluDimmer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIlluDimmer = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const enums_1 = require("../../enums");
+class ZigbeeIlluDimmer extends BaseDevices_1.ZigbeeDimmer {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.ZigbeeIlluDimmer);
+        this._stateNameBrightness = 'brightness';
+        this._stateNameState = 'state';
+        this._stateNameTransitionTime = 'transition_time';
+        this._actuatorOnStateIdState = `${this.info.fullID}.state`;
+        this._stateIdBrightness = `${this.info.fullID}.brightness`;
+        this._stateIdTransitionTime = `${this.info.fullID}.transition_time`;
+    }
+}
+exports.ZigbeeIlluDimmer = ZigbeeIlluDimmer;

package/lib/devices/zigbee/zigbeeIlluLampe.d.ts

@@ -0,0 +1,7 @@
+import { iLamp } from '../../interfaces';
+import { ZigbeeLamp } from './BaseDevices';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class ZigbeeIlluLampe extends ZigbeeLamp implements iLamp {
+    protected readonly _actuatorOnStateIdState: string;
+    constructor(pInfo: IoBrokerDeviceInfo);
+}

package/lib/devices/zigbee/zigbeeIlluLampe.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIlluLampe = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const enums_1 = require("../../enums");
+class ZigbeeIlluLampe extends BaseDevices_1.ZigbeeLamp {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.ZigbeeIlluLampe);
+        this._actuatorOnStateIdState = `${pInfo.fullID}.${this._stateNameState}`;
+    }
+}
+exports.ZigbeeIlluLampe = ZigbeeIlluLampe;

package/lib/devices/zigbee/zigbeeIlluLedRGBCCT.d.ts

@@ -0,0 +1,15 @@
+import { ZigbeeLedRGBCCT } from './BaseDevices';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class ZigbeeIlluLedRGBCCT extends ZigbeeLedRGBCCT {
+    protected readonly _stateIdBrightness: string;
+    protected readonly _stateIdColor: string;
+    protected readonly _stateIdColorTemp: string;
+    protected readonly _actuatorOnStateIdState: string;
+    protected readonly _stateIdTransitionTime: string;
+    protected readonly _stateNameBrightness: string;
+    protected readonly _stateNameState: string;
+    protected readonly _stateNameTransitionTime: string;
+    protected readonly _stateNameColor: string;
+    protected readonly _stateNameColorTemp: string;
+    constructor(pInfo: IoBrokerDeviceInfo);
+}

package/lib/devices/zigbee/zigbeeIlluLedRGBCCT.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIlluLedRGBCCT = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const enums_1 = require("../../enums");
+class ZigbeeIlluLedRGBCCT extends BaseDevices_1.ZigbeeLedRGBCCT {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.ZigbeeIlluLedRGBCCT);
+        this._stateNameBrightness = 'brightness';
+        this._stateNameState = 'state';
+        this._stateNameTransitionTime = 'transition_time';
+        this._stateNameColor = 'color';
+        this._stateNameColorTemp = 'colortemp';
+        this._stateIdBrightness = `${this.info.fullID}.brightness`;
+        this._stateIdColor = `${this.info.fullID}.color`;
+        this._stateIdColorTemp = `${this.info.fullID}.colortemp`;
+        this._actuatorOnStateIdState = `${this.info.fullID}.state`;
+        this._stateIdTransitionTime = `${this.info.fullID}.transition_time`;
+    }
+}
+exports.ZigbeeIlluLedRGBCCT = ZigbeeIlluLedRGBCCT;

package/lib/devices/zigbee/zigbeeIlluShutter.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIlluShutter = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const enums_1 = require("../../enums");
+const utils_1 = require("../../utils");
+var MovementState;
+(function (MovementState) {
+    MovementState[MovementState["Down"] = 30] = "Down";
+    MovementState[MovementState["Stop"] = 50] = "Stop";
+    MovementState[MovementState["Up"] = 70] = "Up";
+})(MovementState || (MovementState = {}));
+class ZigbeeIlluShutter extends BaseDevices_1.ZigbeeShutter {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.ZigbeeIlluShutter);
+        this._movementState = MovementState.Stop;
+        this._movementStartMs = -1;
+        this._movementStartPos = -1;
+        this._movementStateId = `${this.info.fullID}.position`;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        switch (idSplit[3]) {
+            case 'position':
+                this.log(enums_1.LogLevel.Trace, `Shutter Update for ${this.info.customName} to "${state.val}"`);
+                this.processNewMovementState(state.val);
+                break;
+        }
+        super.update(idSplit, state, initial, true);
+    }
+    moveToPosition(targetPosition) {
+        if (this._movementState !== MovementState.Stop) {
+            this.log(enums_1.LogLevel.Info, `Delaying movement command for ${this.info.customName} as it is moving to prevent actuator damage`);
+            this.changeMovementState(MovementState.Stop);
+            if (this._iMovementTimeout !== undefined) {
+                clearTimeout(this._iMovementTimeout);
+            }
+            this._iMovementTimeout = utils_1.Utils.guardedTimeout(() => {
+                this._iMovementTimeout = undefined;
+                this.moveToPosition(targetPosition);
+            }, 2000, this);
+            return;
+        }
+        this._movementStartPos = this._currentLevel;
+        if (targetPosition === 100) {
+            this.changeMovementState(MovementState.Up);
+            this.initializeMovementFinishTimeout(this.getAverageUp(), 100);
+            return;
+        }
+        if (targetPosition === 0) {
+            this.changeMovementState(MovementState.Down);
+            this.initializeMovementFinishTimeout(this.getAverageUp(), 0);
+            utils_1.Utils.guardedTimeout(() => {
+                this.changeMovementState(MovementState.Stop);
+            }, this.getAverageDown() + 1000, this);
+            return;
+        }
+        if (!this.isCalibrated()) {
+            this.log(enums_1.LogLevel.Alert, `Can't move  to position "${targetPosition}" as it is not calibrated (Move it completly up, down, up first)`);
+            return;
+        }
+        const distance = Math.abs(this._currentLevel - targetPosition);
+        const direction = this._currentLevel > targetPosition ? MovementState.Down : MovementState.Up;
+        const duration = Math.round(distance / 100) * (this._currentLevel > targetPosition ? this.getAverageDown() : this.getAverageUp());
+        this.changeMovementState(direction);
+        this.initializeMovementFinishTimeout(duration, targetPosition);
+        utils_1.Utils.guardedTimeout(() => {
+            this.changeMovementState(MovementState.Stop);
+        }, duration, this);
+    }
+    changeMovementState(direction) {
+        this.log(enums_1.LogLevel.Debug, `Set new MovementState to "${MovementState[direction]}"`);
+        if (direction !== MovementState.Stop) {
+            this._movementStartMs = utils_1.Utils.nowMS();
+        }
+        this.setState(this._movementStateId, direction, () => {
+            this._movementState = direction;
+        });
+    }
+    processNewMovementState(val) {
+        const newState = val <= 30 ? MovementState.Down : val >= 70 ? MovementState.Up : MovementState.Stop;
+        this.log(enums_1.LogLevel.Trace, `New Movementstate "${MovementState[val]}"`);
+        if (newState !== MovementState.Stop) {
+            this._movementState = newState;
+            return;
+        }
+        const timePassed = utils_1.Utils.nowMS() - this._movementStartMs;
+        const oldState = this._movementState;
+        if (this._movementStartPos === 0 && oldState === MovementState.Up && this._setLevel === 100) {
+            this.log(enums_1.LogLevel.Debug, `New Time-Until-Top measurement for ${this.info.customName}: ${timePassed}ms`);
+            this.setCurrentLevel(this._setLevel);
+            this._shutterCalibrationData.counterUp++;
+            this._shutterCalibrationData.averageUp +=
+                (timePassed - this._shutterCalibrationData.averageUp) / this._shutterCalibrationData.counterUp;
+            this.persistCalibrationData();
+            this.log(enums_1.LogLevel.Trace, `New Measurment for shutter up (${this.getAverageUp()}ms), new Average: ${this._shutterCalibrationData.averageUp}`);
+            return;
+        }
+        if (this._movementStartPos === 100 && oldState === MovementState.Down && this._setLevel === 0) {
+            this.log(enums_1.LogLevel.Debug, `New Time-Until-Bottom measurement for ${this.info.customName}: ${timePassed}ms`);
+            this.setCurrentLevel(this._setLevel);
+            this._shutterCalibrationData.counterDown++;
+            this._shutterCalibrationData.averageDown +=
+                (timePassed - this._shutterCalibrationData.averageDown) / this._shutterCalibrationData.counterDown;
+            this.persistCalibrationData();
+            this.log(enums_1.LogLevel.Trace, `New Measurment for shutter down (${this.getAverageDown()}ms), new Average: ${this._shutterCalibrationData.averageDown}`);
+            return;
+        }
+        if (!this.isCalibrated()) {
+            return;
+        }
+        if (oldState === MovementState.Down) {
+            this.setCurrentLevel(Math.min(this._currentLevel - Math.round((timePassed * 100) / this.getAverageDown()), 0));
+        }
+        else if (oldState === MovementState.Up) {
+            this.setCurrentLevel(Math.max(this._currentLevel + Math.round((timePassed * 100) / this.getAverageUp()), 100));
+        }
+    }
+}
+exports.ZigbeeIlluShutter = ZigbeeIlluShutter;

package/lib/devices/zigbee/zigbeeInnr142C.d.ts

@@ -0,0 +1,16 @@
+import { ZigbeeLedRGBCCT } from './BaseDevices';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class ZigbeeInnr142C extends ZigbeeLedRGBCCT {
+    protected readonly _stateIdBrightness: string;
+    protected readonly _stateIdColor: string;
+    protected readonly _stateIdColorTemp: string;
+    protected readonly _actuatorOnStateIdState: string;
+    protected readonly _stateIdTransitionTime: string;
+    protected readonly _stateNameBrightness: string;
+    protected readonly _stateNameState: string;
+    protected readonly _stateNameTransitionTime: string;
+    protected readonly _stateNameColor: string;
+    protected readonly _stateNameColorTemp: string;
+    protected readonly _debounceStateDelay: number;
+    constructor(pInfo: IoBrokerDeviceInfo);
+}

package/lib/devices/zigbee/zigbeeInnr142C.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeInnr142C = void 0;
+const BaseDevices_1 = require("./BaseDevices");
+const enums_1 = require("../../enums");
+class ZigbeeInnr142C extends BaseDevices_1.ZigbeeLedRGBCCT {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.ZigbeeInnr142C);
+        this._stateNameBrightness = 'brightness';
+        this._stateNameState = 'state';
+        this._stateNameTransitionTime = 'transition_time';
+        this._stateNameColor = 'color';
+        this._stateNameColorTemp = 'colortemp';
+        this._debounceStateDelay = 3500;
+        this._stateIdBrightness = `${this.info.fullID}.brightness`;
+        this._stateIdColor = `${this.info.fullID}.color`;
+        this._stateIdColorTemp = `${this.info.fullID}.colortemp`;
+        this._actuatorOnStateIdState = `${this.info.fullID}.state`;
+        this._stateIdTransitionTime = `${this.info.fullID}.transition_time`;
+    }
+}
+exports.ZigbeeInnr142C = ZigbeeInnr142C;