hoffmation-base 0.1.14 → 0.1.18

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

@@ -0,0 +1,7 @@
+import { Taste } from './taste';
+export interface iTaster {
+    tasten: {
+        [id: string]: Taste;
+    };
+    getTastenAssignment(): string;
+}

package/lib/server/devices/iTaster.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,16 @@
+export * from './iLamp';
+export * from './taste';
+export * from './Griffe';
+export * from './Rollos';
+export * from './devices';
+export * from './iTaster';
+export * from './DeviceInfo';
+export * from './wledDevice';
+export * from './Heizgruppen';
+export * from './deviceUpdater';
+export * from './iDeviceUpdater';
+export * from './iIoBrokerDevice';
+export * from './iIlluminationSensor';
+export * from './groups/index';
+export * from './hmIPDevices/index';
+export * from './zigbee/index';

package/lib/server/devices/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./iLamp"), exports);
+__exportStar(require("./taste"), exports);
+__exportStar(require("./Griffe"), exports);
+__exportStar(require("./Rollos"), exports);
+__exportStar(require("./devices"), exports);
+__exportStar(require("./iTaster"), exports);
+__exportStar(require("./DeviceInfo"), exports);
+__exportStar(require("./wledDevice"), exports);
+__exportStar(require("./Heizgruppen"), exports);
+__exportStar(require("./deviceUpdater"), exports);
+__exportStar(require("./iDeviceUpdater"), exports);
+__exportStar(require("./iIoBrokerDevice"), exports);
+__exportStar(require("./iIlluminationSensor"), exports);
+__exportStar(require("./groups/index"), exports);
+__exportStar(require("./hmIPDevices/index"), exports);
+__exportStar(require("./zigbee/index"), exports);

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

@@ -0,0 +1,15 @@
+export declare class Taste {
+    updateIndex: number;
+    shortPressed: boolean;
+    longPressed: boolean;
+    private _shortCallback;
+    private _longCallback;
+    private _shortResetTimeout;
+    private _longResetTimeout;
+    constructor(updateIndex: number);
+    addShortCallback(pCallback: (pValue: boolean) => void, description?: string): void;
+    addLongCallback(pCallback: (pValue: boolean) => void, description?: string): void;
+    getDescription(): string;
+    updateShort(pValue: boolean): void;
+    updateLong(pValue: boolean): void;
+}

package/lib/server/devices/taste.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Taste = void 0;
+const utils_1 = require("../services/utils/utils");
+class Taste {
+    constructor(updateIndex) {
+        this.updateIndex = updateIndex;
+        this.shortPressed = false;
+        this.longPressed = false;
+        this._shortCallback = [];
+        this._longCallback = [];
+        this._shortResetTimeout = null;
+        this._longResetTimeout = null;
+    }
+    addShortCallback(pCallback, description = 'Not described') {
+        this._shortCallback.push({ cb: pCallback, description: description });
+    }
+    addLongCallback(pCallback, description = 'Not described') {
+        this._longCallback.push({ cb: pCallback, description: description });
+    }
+    getDescription() {
+        const description = [];
+        for (const c of this._shortCallback) {
+            description.push(`Short Press: "${c.description}"`);
+        }
+        for (const c of this._longCallback) {
+            description.push(`Long Press: "${c.description}"`);
+        }
+        return description.join('\n');
+    }
+    updateShort(pValue) {
+        if (pValue === this.shortPressed) {
+            return;
+        }
+        this.shortPressed = pValue;
+        for (const c of this._shortCallback) {
+            c.cb(pValue);
+        }
+        if (!pValue) {
+            return;
+        }
+        this._shortResetTimeout !== null && clearTimeout(this._shortResetTimeout);
+        this._shortResetTimeout = utils_1.Utils.guardedTimeout(() => {
+            this.updateShort(false);
+        }, 1000, this);
+    }
+    updateLong(pValue) {
+        if (pValue === this.longPressed) {
+            return;
+        }
+        this.longPressed = pValue;
+        for (const c of this._longCallback) {
+            c.cb(pValue);
+        }
+        if (!pValue) {
+            return;
+        }
+        this._longResetTimeout !== null && clearTimeout(this._longResetTimeout);
+        this._longResetTimeout = utils_1.Utils.guardedTimeout(() => {
+            this.updateLong(false);
+        }, 5000, this);
+    }
+}
+exports.Taste = Taste;

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

@@ -0,0 +1,38 @@
+/// <reference types="iobroker" />
+import { IOBrokerConnection } from '../ioBroker/connection';
+import { DeviceInfo } from './DeviceInfo';
+export declare class WledDevice {
+    on: boolean;
+    brightness: number;
+    linkQuality: number;
+    battery: number;
+    voltage: string;
+    private _info;
+    private _ioConnection?;
+    private _onID;
+    private _brightnessID;
+    constructor(pInfo: DeviceInfo);
+    /**
+     * Getter info
+     * @return {DeviceInfo}
+     */
+    get info(): DeviceInfo;
+    /**
+     * Setter info
+     * @param {DeviceInfo} value
+     */
+    set info(value: DeviceInfo);
+    /**
+     * Getter ioConn
+     * @return {IOBrokerConnection}
+     */
+    get ioConn(): IOBrokerConnection | undefined;
+    /**
+     * Setter ioConn
+     * @param {IOBrokerConnection} value
+     */
+    set ioConn(value: IOBrokerConnection | undefined);
+    private addToCorrectRoom;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    setLight(pValue: boolean, brightness?: number): void;
+}

package/lib/server/devices/wledDevice.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WledDevice = void 0;
+const logLevel_1 = require("../../models/logLevel");
+const log_service_1 = require("../services/log-service");
+class WledDevice {
+    constructor(pInfo) {
+        this.on = false;
+        this.brightness = -1;
+        this.linkQuality = 0;
+        this.battery = -1;
+        this.voltage = '';
+        this._info = pInfo;
+        this.addToCorrectRoom();
+        this._onID = `${this.info.fullID}.on`;
+        this._brightnessID = `${this.info.fullID}.bri`;
+    }
+    /**
+     * Getter info
+     * @return {DeviceInfo}
+     */
+    get info() {
+        return this._info;
+    }
+    /**
+     * Setter info
+     * @param {DeviceInfo} value
+     */
+    set info(value) {
+        this._info = value;
+    }
+    /**
+     * Getter ioConn
+     * @return {IOBrokerConnection}
+     */
+    get ioConn() {
+        return this._ioConnection;
+    }
+    /**
+     * Setter ioConn
+     * @param {IOBrokerConnection} value
+     */
+    set ioConn(value) {
+        this._ioConnection = value;
+    }
+    addToCorrectRoom() {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Neues Zigbee Gerät für ${this._info.room}`);
+        switch (this._info.room) {
+            case 'Wohnz':
+                // room1OGWohn.addWLED(this._info);
+                break;
+            default:
+                console.warn(`${this._info.room} ist noch kein bekannter Raum für WLED Geräte`);
+        }
+    }
+    update(idSplit, state, initial = false, pOverride = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Wled: ${initial ? 'Initiales ' : ''}Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        if (!pOverride) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Keine Update Überschreibung für "${this.info.customName}":\n\tID: ${idSplit.join('.')}\n\tData: ${JSON.stringify(state)}`);
+        }
+        switch (idSplit[3]) {
+            case 'on':
+                this.on = state.val;
+                break;
+            case 'bri':
+                this.brightness = state.val;
+                break;
+        }
+    }
+    setLight(pValue, brightness = -1) {
+        if (this._onID === '') {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine On ID für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (!this.ioConn) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (pValue && brightness === -1 && this.brightness < 10) {
+            brightness = 10;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `WLED Schalten: "${this.info.customName}" An: ${pValue}\tHelligkeit: ${brightness}%`);
+        this.ioConn.setState(this._onID, pValue, (err) => {
+            if (err) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `WLED schalten ergab Fehler: ${err}`);
+            }
+        });
+        if (brightness > -1) {
+            this.ioConn.setState(this._brightnessID, brightness, (err) => {
+                if (err) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Dimmer Helligkeit schalten ergab Fehler: ${err}`);
+                }
+            });
+        }
+    }
+}
+exports.WledDevice = WledDevice;

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

@@ -0,0 +1,17 @@
+/// <reference types="iobroker" />
+import { ZigbeeDevice } from './zigbeeDevice';
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { ActuatorSettings as ActuatorSettings } from '../../../models/actuatorSettings';
+export declare class ZigbeeActuator extends ZigbeeDevice {
+    settings: ActuatorSettings;
+    protected readonly actuatorOnSwitchID: string;
+    protected queuedValue: boolean | null;
+    protected actuatorOn: boolean;
+    private turnOffTimeout;
+    private turnOffTime;
+    constructor(pInfo: DeviceInfo, type: ZigbeeDeviceType, actuatorOnSwitchID: string);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
+    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
+    toggleActuator(force?: boolean): boolean;
+}

package/lib/server/devices/zigbee/ZigbeeActuator.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeActuator = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const log_service_1 = require("../../services/log-service");
+const utils_1 = require("../../services/utils/utils");
+const actuatorSettings_1 = require("../../../models/actuatorSettings");
+class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
+    constructor(pInfo, type, actuatorOnSwitchID) {
+        super(pInfo, type);
+        this.settings = new actuatorSettings_1.ActuatorSettings();
+        this.queuedValue = null;
+        this.actuatorOn = false;
+        this.turnOffTimeout = undefined;
+        this.turnOffTime = 0;
+        this.actuatorOnSwitchID = actuatorOnSwitchID;
+    }
+    update(idSplit, state, initial = false, handledByChildObject = false) {
+        if (!handledByChildObject) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Aktuator Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        }
+        this.queuedValue = null;
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'state':
+                !handledByChildObject &&
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Aktor Update für ${this.info.customName} auf ${state.val}`);
+                this.actuatorOn = state.val;
+                break;
+        }
+    }
+    setActuator(pValue, timeout = -1, force = false) {
+        if (this.actuatorOnSwitchID === '') {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine Switch ID für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (!force && utils_1.Utils.nowMS() < this.turnOffTime) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Skip automatic command for "${this.info.customName}" to ${pValue} as it is locked until ${new Date(this.turnOffTime).toLocaleTimeString()}`);
+            return;
+        }
+        if (!this.ioConn) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (!force && pValue === this.actuatorOn && this.queuedValue === null) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Skip actuator command for "${this.info.customName}" as it is already ${pValue}`);
+            return;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Stecker schalten: "${this.info.customName}" Wert: ${pValue}`);
+        this.ioConn.setState(this.actuatorOnSwitchID, pValue, (err) => {
+            if (err) {
+                console.log(`Stecker schalten ergab Fehler: ${err}`);
+            }
+        });
+        this.queuedValue = pValue;
+        if (this.turnOffTimeout !== undefined) {
+            clearTimeout(this.turnOffTimeout);
+            this.turnOffTimeout = undefined;
+        }
+        if (timeout < 0 || !pValue) {
+            return;
+        }
+        this.turnOffTime = utils_1.Utils.nowMS() + timeout;
+        this.turnOffTimeout = utils_1.Utils.guardedTimeout(() => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Delayed Turnoff for "${this.info.customName}" initiated`);
+            this.turnOffTimeout = undefined;
+            if (!this.room) {
+                this.setActuator(false, -1, true);
+            }
+            else {
+                this.room.setLightTimeBased(true);
+            }
+        }, timeout, this);
+    }
+    toggleActuator(force = false) {
+        const newVal = this.queuedValue !== null ? !this.queuedValue : !this.actuatorOn;
+        const timeout = newVal && force ? 30 * 60 * 1000 : -1;
+        this.setActuator(newVal, timeout, force);
+        return newVal;
+    }
+}
+exports.ZigbeeActuator = ZigbeeActuator;

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

@@ -0,0 +1,13 @@
+export * from './zigbeeDevice';
+export * from './ZigbeeActuator';
+export * from './zigbeeBlitzShp';
+export * from './zigbeeIlluLampe';
+export * from './zigbeeDeviceType';
+export * from './zigbeeIlluDimmer';
+export * from './zigbeeAquaraVibra';
+export * from './zigbeeAquaraWater';
+export * from './zigbeeHeimanSmoke';
+export * from './zigbeeAquaraMotion';
+export * from './zigbeeIlluActuator';
+export * from './zigbeeIkeaSteckdose';
+export * from './zigbeeIlluLedRGBCCT';

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

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./zigbeeDevice"), exports);
+__exportStar(require("./ZigbeeActuator"), exports);
+__exportStar(require("./zigbeeBlitzShp"), exports);
+__exportStar(require("./zigbeeIlluLampe"), exports);
+__exportStar(require("./zigbeeDeviceType"), exports);
+__exportStar(require("./zigbeeIlluDimmer"), exports);
+__exportStar(require("./zigbeeAquaraVibra"), exports);
+__exportStar(require("./zigbeeAquaraWater"), exports);
+__exportStar(require("./zigbeeHeimanSmoke"), exports);
+__exportStar(require("./zigbeeAquaraMotion"), exports);
+__exportStar(require("./zigbeeIlluActuator"), exports);
+__exportStar(require("./zigbeeIkeaSteckdose"), exports);
+__exportStar(require("./zigbeeIlluLedRGBCCT"), exports);

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

@@ -0,0 +1,31 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { iIlluminationSensor } from '../iIlluminationSensor';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+export declare class ZigbeeAquaraMotion extends ZigbeeDevice implements iIlluminationSensor {
+    movementDetected: boolean;
+    excludeFromNightAlarm: boolean;
+    room: RoomBase | undefined;
+    private _timeSinceLastMotion;
+    private _illuminance;
+    private _motionTimeout;
+    private _detectionsToday;
+    private _initialized;
+    private _movementDetectedCallback;
+    private _fallBackTimeout;
+    private occupancyTimeoutID;
+    get currentIllumination(): number;
+    private set currentIllumination(value);
+    get timeSinceLastMotion(): number;
+    get motionTimeout(): number;
+    set motionTimeout(value: number);
+    get detectionsToday(): number;
+    set detectionsToday(pVal: number);
+    constructor(pInfo: DeviceInfo);
+    addMovementCallback(pCallback: (pValue: boolean) => void): void;
+    updateMovement(newState: boolean): void;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    private resetFallbackTimeout;
+    private startFallbackTimeout;
+}

package/lib/server/devices/zigbee/zigbeeAquaraMotion.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeAquaraMotion = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const persist_1 = require("../../services/dbo/persist");
+const utils_1 = require("../../services/utils/utils");
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const CurrentIlluminationDataPoint_1 = require("../../../models/persistence/CurrentIlluminationDataPoint");
+class ZigbeeAquaraMotion extends zigbeeDevice_1.ZigbeeDevice {
+    constructor(pInfo) {
+        super(pInfo, zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeAquaraMotion);
+        this.movementDetected = false;
+        this.excludeFromNightAlarm = false;
+        this.room = undefined;
+        this._timeSinceLastMotion = 0;
+        this._illuminance = 0;
+        this._motionTimeout = 0;
+        this._detectionsToday = 0;
+        this._initialized = false;
+        this._movementDetectedCallback = [];
+        this.occupancyTimeoutID = `occupancy_timeout`;
+        this.occupancyTimeoutID = `${this.info.fullID}.${this.occupancyTimeoutID}`;
+        persist_1.Persist.getCount(this).then((todayCount) => {
+            this.detectionsToday = todayCount.counter;
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Bewegungscounter "${this.info.customName}" vorinitialisiert mit ${this.detectionsToday}`);
+            this._initialized = true;
+        });
+    }
+    // Currently measured brightness in lux
+    get currentIllumination() {
+        return this._illuminance;
+    }
+    set currentIllumination(value) {
+        var _a, _b;
+        this._illuminance = value;
+        persist_1.Persist.persistCurrentIllumination(new CurrentIlluminationDataPoint_1.CurrentIlluminationDataPoint(this.info.room, this.info.devID, value, new Date(), (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.LampenGroup.anyLightsOwn()) !== null && _b !== void 0 ? _b : false));
+    }
+    // Time since last motion in seconds
+    get timeSinceLastMotion() {
+        return this._timeSinceLastMotion;
+    }
+    // Time after the last trigger until a motion event gets triggered again
+    get motionTimeout() {
+        return this._motionTimeout;
+    }
+    set motionTimeout(value) {
+        if (!this.ioConn) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `No connection active for "${this.info.customName}".`);
+            return;
+        }
+        this.ioConn.setState(this.occupancyTimeoutID, value, (err) => {
+            if (err) {
+                console.log(`Error occured while setting motion timeout: ${err}`);
+                return;
+            }
+            this._motionTimeout = value;
+        });
+    }
+    get detectionsToday() {
+        return this._detectionsToday;
+    }
+    set detectionsToday(pVal) {
+        const oldVal = this._detectionsToday;
+        this._detectionsToday = pVal;
+        persist_1.Persist.persistTodayCount(this, pVal, oldVal);
+    }
+    addMovementCallback(pCallback) {
+        this._movementDetectedCallback.push(pCallback);
+    }
+    updateMovement(newState) {
+        if (!this._initialized && newState) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Bewegung für "${this.info.customName}" erkannt aber die Initialisierung aus der DB ist noch nicht erfolgt --> verzögern`);
+            utils_1.Utils.guardedTimeout(() => {
+                this.updateMovement(newState);
+            }, 1000, this);
+            return;
+        }
+        if (newState === this.movementDetected) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Überspringe Bewegung für "${this.info.customName}" da bereits der Wert ${newState} vorliegt`);
+            if (newState) {
+                // Wenn ein Sensor sich nicht von alleine zurücksetzt, hier erzwingen.
+                this.resetFallbackTimeout();
+                this.startFallbackTimeout();
+            }
+            return;
+        }
+        this.resetFallbackTimeout();
+        this.movementDetected = newState;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Neuer Bewegunsstatus Wert für "${this.info.customName}": ${newState}`);
+        if (newState) {
+            this.startFallbackTimeout();
+            this.detectionsToday++;
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Dies ist die ${this.detectionsToday} Bewegung für "${this.info.customName}"`);
+        }
+        for (const c of this._movementDetectedCallback) {
+            c(newState);
+        }
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Stecker Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'occupancy':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Motion sensor: Update for motion state of ${this.info.customName}: ${state.val}`);
+                this.updateMovement(state.val);
+                break;
+            case 'no_motion':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Motion sensor: Update for time since last motion of ${this.info.customName}: ${state.val}`);
+                this._timeSinceLastMotion = state.val;
+                break;
+            case 'illumincance':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Motion sensor: Update for illuminance of ${this.info.customName}: ${state.val}`);
+                this.currentIllumination = state.val;
+                break;
+            case 'occupancy_timeout':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Motion sensor: Update for motion timeout of ${this.info.customName}: ${state.val}`);
+                this._illuminance = state.val;
+                break;
+        }
+    }
+    resetFallbackTimeout() {
+        if (this._fallBackTimeout) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Fallback Timeout für "${this.info.customName}" zurücksetzen`);
+            clearTimeout(this._fallBackTimeout);
+        }
+    }
+    startFallbackTimeout() {
+        this._fallBackTimeout = utils_1.Utils.guardedTimeout(() => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Benötige Fallback Bewegungs Reset für "${this.info.customName}"`);
+            this._fallBackTimeout = undefined;
+            this.updateMovement(false);
+        }, 270000, this);
+    }
+}
+exports.ZigbeeAquaraMotion = ZigbeeAquaraMotion;

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

@@ -0,0 +1,23 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+export declare class ZigbeeAquaraVibra extends ZigbeeDevice {
+    sensitivity: string;
+    tiltAngle: number;
+    tiltAngleX: number;
+    tiltAngleXAbs: number;
+    tiltAngleY: number;
+    tiltAngleYAbs: number;
+    tiltAngleZ: number;
+    tilt: boolean;
+    vibration: boolean;
+    vibrationBlockedTimeStamp: number;
+    private _idSensitivity;
+    private _vibrationBlocked;
+    private _alarmMessage;
+    constructor(pInfo: DeviceInfo);
+    set vibrationBlocked(pVal: boolean);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    setSensitivity(pVal: number): void;
+    private alarmCheck;
+}