hoffmation-base 0.1.14 → 0.1.18

package/lib/server/devices/groups/praesenzGroup.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PraesenzGroup = void 0;
+const RoomBase_1 = require("../../../models/rooms/RoomBase");
+const timeCallback_1 = require("../../../models/timeCallback");
+const log_service_1 = require("../../services/log-service");
+const logLevel_1 = require("../../../models/logLevel");
+const time_callback_service_1 = require("../../services/time-callback-service");
+const utils_1 = require("../../services/utils/utils");
+class PraesenzGroup {
+    constructor(_room, Prasenzen, Bewegungen) {
+        this._room = _room;
+        this.Prasenzen = Prasenzen;
+        this.Bewegungen = Bewegungen;
+        this._lastMovement = new Date(0);
+        for (const b of [...Prasenzen, ...Bewegungen]) {
+            b.room = this._room;
+        }
+    }
+    initCallbacks() {
+        this.Prasenzen.forEach((p) => {
+            p.addPresenceCallback((val) => {
+                if (!val) {
+                    return;
+                }
+                if (RoomBase_1.RoomBase.awayModeActive || (RoomBase_1.RoomBase.nightAlarmActive && !p.excludeFromNightAlarm)) {
+                    RoomBase_1.RoomBase.startIntrusionAlarm(this._room, p);
+                }
+                RoomBase_1.RoomBase.movementHistory.add(`${utils_1.Utils.nowString()}: Raum "${this._room.roomName}" Gerät "${p.info.fullName}"`);
+            });
+        });
+        this.Bewegungen.forEach((b) => {
+            b.addMovementCallback((val) => {
+                if (!val) {
+                    return;
+                }
+                if (RoomBase_1.RoomBase.awayModeActive || (RoomBase_1.RoomBase.nightAlarmActive && !b.excludeFromNightAlarm)) {
+                    RoomBase_1.RoomBase.startIntrusionAlarm(this._room, b);
+                }
+                RoomBase_1.RoomBase.movementHistory.add(`${utils_1.Utils.nowString()}: Raum "${this._room.roomName}" Gerät "${b.info.fullName}"`);
+            });
+        });
+        if (this._room.Einstellungen.lichtSonnenAufgangAus && this._room.Einstellungen.lampOffset) {
+            this._room.sonnenAufgangLichtCallback = new timeCallback_1.TimeCallback(`${this._room.roomName} Morgens Lampe aus`, timeCallback_1.TimeCallbackType.Sunrise, () => {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Es ist hell genug --> Schalte Lampen im ${this._room.roomName} aus`);
+                this._room.LampenGroup.switchAll(false);
+            }, this._room.Einstellungen.lampOffset.sunrise);
+            time_callback_service_1.TimeCallbackService.addCallback(this._room.sonnenAufgangLichtCallback);
+        }
+        this.addLastLeftCallback(() => {
+            this._room.LampenGroup.switchAll(false);
+        });
+        if (this._room.Einstellungen.lampenBeiBewegung) {
+            this.addFirstEnterCallback(() => {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Bewegung im Raum ${this._room.roomName} festgestellt --> Licht einschalten`);
+                this._room.setLightTimeBased();
+            });
+        }
+    }
+    presentAmount() {
+        let count = 0;
+        for (let i = 0; i < this.Prasenzen.length; i++) {
+            if (this.Prasenzen[i].presenceDetected) {
+                count++;
+            }
+        }
+        for (let i = 0; i < this.Bewegungen.length; i++) {
+            if (this.Bewegungen[i].movementDetected) {
+                count++;
+            }
+        }
+        return count;
+    }
+    anyPresent() {
+        for (let i = 0; i < this.Prasenzen.length; i++) {
+            if (this.Prasenzen[i].presenceDetected) {
+                return true;
+            }
+        }
+        for (let i = 0; i < this.Bewegungen.length; i++) {
+            if (this.Bewegungen[i].movementDetected) {
+                return true;
+            }
+        }
+        return false;
+    }
+    lastLeftCB(val, cb) {
+        if (val) {
+            return;
+        }
+        if (this.anyPresent()) {
+            return;
+        }
+        let timeAfterReset = utils_1.Utils.nowMS() - this._lastMovement.getTime() - this._room.Einstellungen.movementResetTimer * 1000;
+        if (timeAfterReset > 0) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Movement reset in ${this._room.roomName}.\nActive Motions: ${this.presentAmount()}\nTime after Last Movement including Reset: ${timeAfterReset}`);
+            cb();
+            return;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Movement reset in ${this._room.roomName} delayed.`);
+        utils_1.Utils.guardedTimeout(() => {
+            timeAfterReset =
+                utils_1.Utils.nowMS() - this._lastMovement.getTime() - this._room.Einstellungen.movementResetTimer * 1000;
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Delayed Movement reset in ${this._room.roomName}.\nActive Motions: ${this.presentAmount()}\nTime after Last Movement including Reset: ${timeAfterReset}`);
+            if (!this.anyPresent() && timeAfterReset > 0) {
+                cb();
+            }
+        }, Math.abs(timeAfterReset) + 500, this);
+    }
+    addLastLeftCallback(cb) {
+        this.Prasenzen.forEach((p) => {
+            p.addPresenceCallback((val) => {
+                this.lastLeftCB(val, cb);
+            });
+        });
+        this.Bewegungen.forEach((b) => {
+            b.addMovementCallback((val) => {
+                this.lastLeftCB(val, cb);
+            });
+        });
+    }
+    firstEnterCallback(val, cb) {
+        if (!val) {
+            return;
+        }
+        this._lastMovement = new Date();
+        if (this.presentAmount() > 1) {
+            return;
+        }
+        cb();
+    }
+    addFirstEnterCallback(cb) {
+        this.Prasenzen.forEach((p) => {
+            p.addPresenceCallback((val) => {
+                this.firstEnterCallback(val, cb);
+            });
+        });
+        this.Bewegungen.forEach((b) => {
+            b.addMovementCallback((val) => {
+                this.firstEnterCallback(val, cb);
+            });
+        });
+    }
+}
+exports.PraesenzGroup = PraesenzGroup;

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

@@ -0,0 +1,8 @@
+import { ZigbeeHeimanSmoke } from '../zigbee/zigbeeHeimanSmoke';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+export declare class SmokeGroup {
+    private _room;
+    Rauchmelder: Array<ZigbeeHeimanSmoke>;
+    constructor(_room: RoomBase, Rauchmelder: Array<ZigbeeHeimanSmoke>);
+    stopAlarm(): void;
+}

package/lib/server/devices/groups/smokeGroup.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmokeGroup = void 0;
+class SmokeGroup {
+    constructor(_room, Rauchmelder) {
+        this._room = _room;
+        this.Rauchmelder = Rauchmelder;
+        for (const s of [...this.Rauchmelder]) {
+            s.room = this._room;
+        }
+    }
+    stopAlarm() {
+        for (const d of this.Rauchmelder) {
+            d.stopAlarm(true);
+        }
+    }
+}
+exports.SmokeGroup = SmokeGroup;

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

@@ -0,0 +1,11 @@
+import { OwnSonosDevice } from '../../services/Sonos/sonos-service';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+export declare class SonosGroup {
+    private _room;
+    ownSonosDevices: OwnSonosDevice[];
+    private _playing;
+    constructor(_room: RoomBase, ownSonosDevices: OwnSonosDevice[]);
+    playRadio(radioUrl: string): void;
+    turnOff(): void;
+    trigger(track: string): void;
+}

package/lib/server/devices/groups/sonosGroup.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonosGroup = void 0;
+const utils_1 = require("../../services/utils/utils");
+const log_service_1 = require("../../services/log-service");
+const logLevel_1 = require("../../../models/logLevel");
+class SonosGroup {
+    constructor(_room, ownSonosDevices) {
+        this._room = _room;
+        this.ownSonosDevices = ownSonosDevices;
+        this._playing = false;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Added Sonos Group to ${this._room.roomName}`);
+    }
+    playRadio(radioUrl) {
+        this.ownSonosDevices.forEach((s) => {
+            utils_1.Utils.guardedTimeout(() => {
+                var _a;
+                (_a = s.device) === null || _a === void 0 ? void 0 : _a.SetAVTransportURI(radioUrl);
+            }, 1500);
+        });
+        this._playing = true;
+    }
+    turnOff() {
+        this.ownSonosDevices.forEach((s) => {
+            var _a;
+            (_a = s.device) === null || _a === void 0 ? void 0 : _a.Stop();
+        });
+        this._playing = false;
+    }
+    trigger(track) {
+        if (this._playing) {
+            this.turnOff();
+            return;
+        }
+        this.playRadio(track);
+    }
+}
+exports.SonosGroup = SonosGroup;

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

@@ -0,0 +1,8 @@
+import { HmIpTaster } from '../hmIPDevices/hmIpTaster';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+export declare class TasterGroup {
+    private _room;
+    Taster: HmIpTaster[];
+    constructor(_room: RoomBase, Taster: HmIpTaster[]);
+    initCallbacks(): void;
+}

package/lib/server/devices/groups/tasterGroup.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TasterGroup = void 0;
+class TasterGroup {
+    constructor(_room, Taster) {
+        this._room = _room;
+        this.Taster = Taster;
+        for (const t of [...Taster]) {
+            t.room = this._room;
+        }
+    }
+    initCallbacks() {
+        this.Taster.forEach((t) => {
+            t.tasten.ObenLinks.addLongCallback((pValue) => {
+                pValue && this._room.FensterGroup.allRolloDown(false, true);
+            }, `Close all Rollos in this room`);
+            t.tasten.ObenLinks.addShortCallback((pValue) => {
+                pValue && this._room.FensterGroup.allRolloToLevel(25, true);
+            }, `Nearly closes all Rollos in this room`);
+            t.tasten.ObenRechts.addLongCallback((pValue) => {
+                if (!pValue) {
+                    return;
+                }
+                this._room.FensterGroup.allRolloUp(true);
+            }, `Open all Rollos in this room`);
+            t.tasten.ObenRechts.addShortCallback((pValue) => {
+                pValue && this._room.FensterGroup.allRolloToLevel(50, true);
+            }, `All Rollos in this room to middle`);
+            t.tasten.MitteLinks.addLongCallback((pValue) => {
+                pValue && this._room.LampenGroup.switchAll(true, true);
+            }, `Turn all Lights in this room on`);
+            t.tasten.MitteRechts.addLongCallback((pValue) => {
+                pValue && this._room.LampenGroup.switchAll(false, true);
+            }, `Turn all Lights in this room off`);
+            if (this._room.SonosGroup.ownSonosDevices.length > 0) {
+                t.tasten.UntenRechts.addLongCallback(() => {
+                    this._room.SonosGroup.trigger(this._room.Einstellungen.radioUrl);
+                });
+            }
+        });
+    }
+}
+exports.TasterGroup = TasterGroup;

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

@@ -0,0 +1,8 @@
+import { ZigbeeAquaraWater } from '../zigbee/zigbeeAquaraWater';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+export declare class WaterGroup {
+    private _room;
+    WaterDetectors: Array<ZigbeeAquaraWater>;
+    constructor(_room: RoomBase, WaterDetectors: Array<ZigbeeAquaraWater>);
+    stopAlarm(): void;
+}

package/lib/server/devices/groups/waterGroup.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaterGroup = void 0;
+class WaterGroup {
+    constructor(_room, WaterDetectors) {
+        this._room = _room;
+        this.WaterDetectors = WaterDetectors;
+        for (const w of [...WaterDetectors]) {
+            w.room = this._room;
+        }
+    }
+    stopAlarm() {
+        for (const d of this.WaterDetectors) {
+            d.stopAlarm(true);
+        }
+    }
+}
+exports.WaterGroup = WaterGroup;

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

@@ -0,0 +1,22 @@
+import { ZigbeeAquaraVibra } from '../zigbee/zigbeeAquaraVibra';
+import { FensterPosition } from './FensterPosition';
+import { HmIpGriff } from './hmIpGriff';
+import { HmIpRoll } from './hmIpRoll';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+export declare class Fenster {
+    room: RoomBase;
+    griffe: HmIpGriff[];
+    vibration: ZigbeeAquaraVibra[];
+    rollo: HmIpRoll | undefined;
+    noRolloOnSunrise: boolean;
+    desiredPosition: number;
+    /**
+     * sets the desired Pos and moves rollo to this level
+     * @param {number} value
+     */
+    setDesiredPosition(value: number): void;
+    constructor(room: RoomBase, griffe: HmIpGriff[], vibration: ZigbeeAquaraVibra[], rollo?: HmIpRoll | undefined, noRolloOnSunrise?: boolean);
+    griffeInPosition(pPosition: FensterPosition): number;
+    rolloPositionChange(pValue: number): void;
+    restoreDesiredPosition(): void;
+}

package/lib/server/devices/hmIPDevices/Fenster.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fenster = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const FensterPosition_1 = require("./FensterPosition");
+const log_service_1 = require("../../services/log-service");
+const time_callback_service_1 = require("../../services/time-callback-service");
+const utils_1 = require("../../services/utils/utils");
+class Fenster {
+    constructor(room, griffe, vibration, rollo = undefined, noRolloOnSunrise = false) {
+        this.room = room;
+        this.griffe = griffe;
+        this.vibration = vibration;
+        this.rollo = rollo;
+        this.noRolloOnSunrise = noRolloOnSunrise;
+        this.desiredPosition = 0;
+        for (const griff of griffe) {
+            griff.addKippCallback((kipp) => {
+                var _a, _b;
+                if (kipp && this.griffeInPosition(FensterPosition_1.FensterPosition.offen) === 0) {
+                    this.vibration.forEach((element) => {
+                        element.vibrationBlocked = true;
+                    });
+                    const timeOfDay = time_callback_service_1.TimeCallbackService.dayType(this.room.Einstellungen.rolloOffset);
+                    if (time_callback_service_1.TimeCallbackService.darkOutsideOrNight(timeOfDay)) {
+                        (_a = this.rollo) === null || _a === void 0 ? void 0 : _a.setLevel(50);
+                    }
+                    else {
+                        (_b = this.rollo) === null || _b === void 0 ? void 0 : _b.up();
+                    }
+                }
+            });
+            griff.addOffenCallback((offen) => {
+                var _a;
+                if (offen) {
+                    this.vibration.forEach((element) => {
+                        element.vibrationBlocked = true;
+                    });
+                    (_a = this.rollo) === null || _a === void 0 ? void 0 : _a.up();
+                    return;
+                }
+            });
+            griff.addClosedCallback((geschlossen) => {
+                if (geschlossen &&
+                    this.griffeInPosition(FensterPosition_1.FensterPosition.offen) === 0 &&
+                    this.griffeInPosition(FensterPosition_1.FensterPosition.kipp) === 0) {
+                    const now = new Date().getTime();
+                    this.vibration.forEach((element) => {
+                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Starte Timeout für Vibrationsdeaktivierung für ${element.info.customName}`);
+                        utils_1.Utils.guardedTimeout(() => {
+                            if (element.vibrationBlockedTimeStamp < now) {
+                                element.vibrationBlocked = false;
+                            }
+                        }, 12000);
+                    });
+                    this.restoreDesiredPosition();
+                }
+            });
+        }
+        utils_1.Utils.guardedTimeout(() => {
+            if (this.rollo)
+                this.rollo.Fenster = this;
+            for (const g of this.griffe) {
+                g.Fenster = this;
+            }
+        }, 5, this);
+    }
+    /**
+     * sets the desired Pos and moves rollo to this level
+     * @param {number} value
+     */
+    setDesiredPosition(value) {
+        this.desiredPosition = value;
+        this.restoreDesiredPosition();
+    }
+    griffeInPosition(pPosition) {
+        let count = 0;
+        for (const griff of this.griffe) {
+            if (griff.position === pPosition) {
+                count++;
+            }
+        }
+        return count;
+    }
+    rolloPositionChange(pValue) {
+        if (!this.room) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Fenster Rollo Update, but this one is not connected to any room!`);
+            return;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Rollo Position Change in ${this.room.roomName} to ${pValue}`);
+        if (pValue === 0 || pValue === 100) {
+            this.room.setLightTimeBased(true);
+        }
+    }
+    restoreDesiredPosition() {
+        var _a;
+        (_a = this.rollo) === null || _a === void 0 ? void 0 : _a.setLevel(this.desiredPosition);
+    }
+}
+exports.Fenster = Fenster;

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

@@ -0,0 +1,5 @@
+export declare enum FensterPosition {
+    geschlossen = 0,
+    kipp = 1,
+    offen = 2
+}

package/lib/server/devices/hmIPDevices/FensterPosition.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FensterPosition = void 0;
+var FensterPosition;
+(function (FensterPosition) {
+    FensterPosition[FensterPosition["geschlossen"] = 0] = "geschlossen";
+    FensterPosition[FensterPosition["kipp"] = 1] = "kipp";
+    FensterPosition[FensterPosition["offen"] = 2] = "offen";
+})(FensterPosition = exports.FensterPosition || (exports.FensterPosition = {}));

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

@@ -0,0 +1,4 @@
+export declare enum TuerPosition {
+    geschlossen = 0,
+    offen = 1
+}

package/lib/server/devices/hmIPDevices/TuerPosition.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TuerPosition = void 0;
+var TuerPosition;
+(function (TuerPosition) {
+    TuerPosition[TuerPosition["geschlossen"] = 0] = "geschlossen";
+    TuerPosition[TuerPosition["offen"] = 1] = "offen";
+})(TuerPosition = exports.TuerPosition || (exports.TuerPosition = {}));

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

@@ -0,0 +1,25 @@
+/// <reference types="iobroker" />
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+import { iIlluminationSensor } from '../iIlluminationSensor';
+export declare class HmIpBewegung extends HmIPDevice implements iIlluminationSensor {
+    excludeFromNightAlarm: boolean;
+    movementDetected: boolean;
+    private _detectionsToday;
+    private _movementDetectedCallback;
+    private static MOVEMENT_DETECTION;
+    private static CURRENT_ILLUMINATION;
+    private initialized;
+    private fallBackTimeout;
+    private _currentIllumination;
+    get currentIllumination(): number;
+    private set currentIllumination(value);
+    get detectionsToday(): number;
+    set detectionsToday(pVal: number);
+    constructor(pInfo: DeviceInfo);
+    addMovementCallback(pCallback: (pValue: boolean) => void): void;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    updateMovement(pVal: boolean): void;
+    private resetFallbackTimeout;
+    private startFallbackTimeout;
+}

package/lib/server/devices/hmIPDevices/hmIpBewegung.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpBewegung = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const log_service_1 = require("../../services/log-service");
+const persist_1 = require("../../services/dbo/persist");
+const utils_1 = require("../../services/utils/utils");
+const CurrentIlluminationDataPoint_1 = require("../../../models/persistence/CurrentIlluminationDataPoint");
+class HmIpBewegung extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpBewegung);
+        this.excludeFromNightAlarm = false;
+        this.movementDetected = false;
+        this._detectionsToday = 0;
+        this._movementDetectedCallback = [];
+        this.initialized = false;
+        this._currentIllumination = -1;
+        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;
+        });
+    }
+    get currentIllumination() {
+        return this._currentIllumination;
+    }
+    set currentIllumination(value) {
+        var _a, _b;
+        this._currentIllumination = 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));
+    }
+    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);
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Bewegungs Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+        super.update(idSplit, state, initial, true);
+        if (idSplit[3] !== '3') {
+            // Nur die Infos in Kanal 3 sind relevant
+            return;
+        }
+        switch (idSplit[4]) {
+            case HmIpBewegung.MOVEMENT_DETECTION:
+                this.updateMovement(state.val);
+                break;
+            case HmIpBewegung.CURRENT_ILLUMINATION:
+                this.currentIllumination = state.val;
+                break;
+        }
+    }
+    updateMovement(pVal) {
+        if (!this.initialized && pVal) {
+            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(pVal);
+            }, 1000, this);
+            return;
+        }
+        if (pVal === this.movementDetected) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Überspringe Bewegung für "${this.info.customName}" da bereits der Wert ${pVal} vorliegt`);
+            if (pVal) {
+                this.resetFallbackTimeout();
+                this.startFallbackTimeout();
+            }
+            return;
+        }
+        this.resetFallbackTimeout();
+        this.movementDetected = pVal;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Neuer Bewegunsstatus Wert für "${this.info.customName}": ${pVal}`);
+        if (pVal) {
+            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(pVal);
+        }
+    }
+    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.HmIpBewegung = HmIpBewegung;
+HmIpBewegung.MOVEMENT_DETECTION = 'MOTION';
+// private static ILLUMINATION_DURING_MOVEMENT: string = 'CURRENT_ILLUMINATION';
+HmIpBewegung.CURRENT_ILLUMINATION = 'ILLUMINATION';

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

@@ -0,0 +1,19 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { HmIpRoomSettings } from '../../../models/rooms/RoomSettings/hmIPRoomSettings';
+import { ioBrokerBaseDevice } from '../iIoBrokerDevice';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+export declare class HmIPDevice extends ioBrokerBaseDevice {
+    static roomSettings: {
+        [id: string]: HmIpRoomSettings;
+    };
+    lowBattery: boolean;
+    deviceType: HmIpDeviceType;
+    room: RoomBase | undefined;
+    static addRoom(shortName: string, settings: HmIpRoomSettings): void;
+    static checkMissing(): void;
+    constructor(pInfo: DeviceInfo, pType: HmIpDeviceType);
+    protected addToCorrectRoom(): void;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+}