hoffmation-base 3.0.3 → 3.1.0

package/lib/devices/groups/heatGroup.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeatGroup = void 0;
+const interfaces_1 = require("../../interfaces");
+const settingsObjects_1 = require("../../settingsObjects");
+const enums_1 = require("../../enums");
+const device_list_1 = require("../device-list");
+const api_1 = require("../../api");
+const utils_1 = require("../../utils");
+const command_1 = require("../../command");
+const base_group_1 = require("./base-group");
+class HeatGroup extends base_group_1.BaseGroup {
+    constructor(roomName, heaterIds, tempSensorIds, humiditySensorIds, acIds) {
+        super(roomName, enums_1.GroupType.Heating);
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.HeatGroupSettings();
+        this.deviceCluster.deviceMap.set(enums_1.DeviceClusterType.Heater, new device_list_1.DeviceList(heaterIds));
+        this.deviceCluster.deviceMap.set(enums_1.DeviceClusterType.TemperaturSensor, new device_list_1.DeviceList(tempSensorIds));
+        this.deviceCluster.deviceMap.set(enums_1.DeviceClusterType.HumiditySensor, new device_list_1.DeviceList(humiditySensorIds));
+        this.deviceCluster.deviceMap.set(enums_1.DeviceClusterType.Ac, new device_list_1.DeviceList(acIds));
+    }
+    /**
+     * Calculates the combined humidity Level in this room
+     * @returns The humidity in percent
+     */
+    get humidity() {
+        let humidity = interfaces_1.UNDEFINED_HUMIDITY_VALUE;
+        let count = 0;
+        this.getHumiditySensors().forEach((sensor) => {
+            const sensorValue = sensor.humidity;
+            if (sensorValue === interfaces_1.UNDEFINED_HUMIDITY_VALUE) {
+                return;
+            }
+            if (count === 0) {
+                count = 1;
+                humidity = sensorValue;
+                return;
+            }
+            humidity = (humidity * count + sensorValue) / ++count;
+        });
+        return humidity;
+    }
+    /**
+     * Calculates the temperature based on all available sensors.
+     * @returns The temperature in °C
+     */
+    get temperature() {
+        let temp = interfaces_1.UNDEFINED_TEMP_VALUE;
+        let count = 0;
+        const usedIds = [];
+        this.getHeater().forEach((heaterAsSensor) => {
+            usedIds.push(heaterAsSensor.id);
+            if (!heaterAsSensor.settings.useOwnTemperatureForRoomTemperature) {
+                return;
+            }
+            const sensorValue = heaterAsSensor.iTemperature;
+            if (sensorValue === interfaces_1.UNDEFINED_TEMP_VALUE) {
+                return;
+            }
+            if (count === 0) {
+                count = 1;
+                temp = sensorValue;
+                return;
+            }
+            temp = (temp * count + sensorValue) / ++count;
+        });
+        this.getTempSensors().forEach((sensor) => {
+            if (usedIds.includes(sensor.id)) {
+                // Heater which correctly implement sensor as well.
+                return;
+            }
+            const sensorValue = sensor.iTemperature;
+            if (sensorValue === interfaces_1.UNDEFINED_TEMP_VALUE) {
+                return;
+            }
+            if (count === 0) {
+                count = 1;
+                temp = sensorValue;
+                return;
+            }
+            temp = (temp * count + sensorValue) / ++count;
+        });
+        return temp;
+    }
+    get desiredTemp() {
+        if (!this.settings.automaticMode) {
+            return this.settings.manualTemperature;
+        }
+        const activeSetting = settingsObjects_1.TemperatureSettings.getActiveSetting(this.settings.automaticPoints, new Date());
+        if (!activeSetting) {
+            return this.settings.automaticFallBackTemperatur;
+        }
+        return activeSetting.temperature;
+    }
+    static getInfo() {
+        var _a, _b, _c;
+        const rooms = Array.from(api_1.API.getRooms().values()).filter((r) => {
+            return r.HeatGroup !== undefined;
+        });
+        rooms.sort((a, b) => {
+            return a.roomName.localeCompare(b.roomName);
+        });
+        const response = ['Dies sind die aktuellen Informationen der Heizungen:'];
+        response.push('Name\t\tLuft Feuchtigkeit\t\tAktuelle Temperatur\t\tSoll Temperatur\t\tVentilstellung');
+        for (const r of rooms) {
+            response.push(`${r.roomName}:\t\t${(_a = r.HeatGroup) === null || _a === void 0 ? void 0 : _a.humidity}%\t\t${(_b = r.HeatGroup) === null || _b === void 0 ? void 0 : _b.temperature}°C\t\t${(_c = r.HeatGroup) === null || _c === void 0 ? void 0 : _c.desiredTemp}°C`);
+        }
+        return response.join('\n');
+    }
+    getHeater() {
+        return this.deviceCluster.getDevicesByType(enums_1.DeviceClusterType.Heater);
+    }
+    getTempSensors() {
+        return this.deviceCluster.getDevicesByType(enums_1.DeviceClusterType.TemperaturSensor);
+    }
+    getHumiditySensors() {
+        return this.deviceCluster.getDevicesByType(enums_1.DeviceClusterType.HumiditySensor);
+    }
+    getOwnAcDevices() {
+        return this.deviceCluster.getDevicesByType(enums_1.DeviceClusterType.Ac);
+    }
+    initialize() {
+        var _a;
+        utils_1.Utils.guardedTimeout(() => {
+            this.settings.initializeFromDb(this);
+        }, 200, this);
+        this.getTempSensors().forEach((sensor) => {
+            sensor.addTempChangeCallback((_newVal) => {
+                this.recalcRoomTemperatur();
+            });
+        });
+        this.getOwnAcDevices().forEach((acDev) => {
+            acDev.room = this.getRoom();
+        });
+        (_a = this.getRoom().WindowGroup) === null || _a === void 0 ? void 0 : _a.addHandleChangeCallback((handleChangeAction) => {
+            this.getHeater().forEach((heater) => {
+                heater.onHandleChange(handleChangeAction);
+            });
+        });
+    }
+    /**
+     * Sets all ACs to new desired Value
+     * TODO: Migrate to new Command System
+     * @param newDesiredState - The new desired (on/off) state
+     * @param force - Whether this was a manual trigger, thus blocking automatic changes for 1 hour
+     */
+    setAc(newDesiredState, force = false) {
+        const devs = this.getOwnAcDevices();
+        this.log(enums_1.LogLevel.Debug, `set ${devs.length} Ac's to new State: ${newDesiredState}`);
+        for (const dev of devs) {
+            if (newDesiredState) {
+                dev.turnOn();
+                continue;
+            }
+            dev.turnOff();
+            dev.blockAutomationHandler.disableAutomatic(new command_1.BlockAutomaticCommand(force ? enums_1.CommandSource.Force : enums_1.CommandSource.Unknown, 60 * 60 * 1000));
+        }
+    }
+    deleteAutomaticPoint(name) {
+        this.settings.deleteAutomaticPoint(name, this);
+    }
+    setAutomaticPoint(setting) {
+        this.settings.setAutomaticPoint(setting, this);
+    }
+    recalcRoomTemperatur() {
+        const temp = this.temperature;
+        if (temp == interfaces_1.UNDEFINED_TEMP_VALUE) {
+            return;
+        }
+        const usedIds = [];
+        this.getHeater().forEach((heater) => {
+            usedIds.push(heater.id);
+            heater.onTemperaturChange(temp);
+        });
+        this.getTempSensors().forEach((sensor) => {
+            if (usedIds.includes(sensor.id)) {
+                return;
+            }
+            sensor.onTemperaturChange(temp);
+        });
+        this.getOwnAcDevices().forEach((ac) => {
+            ac.onTemperaturChange(temp);
+        });
+    }
+}
+exports.HeatGroup = HeatGroup;

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

@@ -0,0 +1,10 @@
+export * from './base-group';
+export { Window } from './Window';
+export * from './windowGroup';
+export * from './heatGroup';
+export * from './lightGroup';
+export * from './presenceGroup';
+export * from './smokeGroup';
+export * from './speakerGroup';
+export * from './tasterGroup';
+export * from './waterGroup';

package/lib/devices/groups/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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Window = void 0;
+__exportStar(require("./base-group"), exports);
+var Window_1 = require("./Window");
+Object.defineProperty(exports, "Window", { enumerable: true, get: function () { return Window_1.Window; } });
+__exportStar(require("./windowGroup"), exports);
+__exportStar(require("./heatGroup"), exports);
+__exportStar(require("./lightGroup"), exports);
+__exportStar(require("./presenceGroup"), exports);
+__exportStar(require("./smokeGroup"), exports);
+__exportStar(require("./speakerGroup"), exports);
+__exportStar(require("./tasterGroup"), exports);
+__exportStar(require("./waterGroup"), exports);

package/lib/devices/groups/lightGroup.d.ts

@@ -0,0 +1,40 @@
+import { iActuator, iLamp, iLightGroup } from '../../interfaces';
+import { ActuatorSetStateCommand, LampSetLightCommand, LampSetTimeBasedCommand, LedSetLightCommand, LightGroupSwitchTimeConditionalCommand, WledSetLightCommand } from '../../command';
+import { iLedRgbCct } from '../../interfaces/baseDevices/iLedRgbCct';
+import { WledDevice } from '../wledDevice';
+import { TimeCallback } from '../../models';
+import { BaseGroup } from './base-group';
+export declare class LightGroup extends BaseGroup implements iLightGroup {
+    /**
+     * Time-Callback for the sunrise light off
+     * @remark This is undefined if the light should not be turned off at sunrise or no calculation has been done yet
+     */
+    sonnenAufgangLichtCallback: TimeCallback | undefined;
+    /**
+     * Time-Callback for the sunset light on
+     * @remark This is undefined if the light should not be turned on at sunset or no calculation has been done yet
+     */
+    sonnenUntergangLichtCallback: TimeCallback | undefined;
+    private _ambientLightOn;
+    constructor(roomName: string, lampenIds?: string[], steckerIds?: string[], ledIds?: string[], wledIds?: string[]);
+    anyLightsOn(): boolean;
+    getLights(): iLamp[];
+    getLED(): iLedRgbCct[];
+    getWled(): WledDevice[];
+    getOutlets(): iActuator[];
+    getAllAsActuator(): iActuator[];
+    handleSunriseOff(): void;
+    switchAll(c: ActuatorSetStateCommand): void;
+    switchTimeConditional(c: LightGroupSwitchTimeConditionalCommand): void;
+    setAllLampen(c: LampSetLightCommand): void;
+    setAllLampenTimeBased(c: LampSetTimeBasedCommand): void;
+    setAllOutlets(c: ActuatorSetStateCommand): void;
+    setAllActuatorsTimeBased(c: LampSetTimeBasedCommand): void;
+    setAllLED(c: LedSetLightCommand): void;
+    setAllWled(c: WledSetLightCommand): void;
+    initialize(): void;
+    recalculateTimeCallbacks(): void;
+    reconfigureSunriseTimeCallback(): void;
+    reconfigureSunsetTimeCallback(): void;
+    ambientLightStartCallback(): void;
+}

package/lib/devices/groups/lightGroup.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightGroup = void 0;
+const enums_1 = require("../../enums");
+const command_1 = require("../../command");
+const services_1 = require("../../services");
+const utils_1 = require("../../utils");
+const device_list_1 = require("../device-list");
+const models_1 = require("../../models");
+const base_group_1 = require("./base-group");
+class LightGroup extends base_group_1.BaseGroup {
+    constructor(roomName, lampenIds = [], steckerIds = [], ledIds = [], wledIds = []) {
+        super(roomName, enums_1.GroupType.Light);
+        this._ambientLightOn = false;
+        this.deviceCluster.deviceMap.set(enums_1.DeviceClusterType.Lamps, new device_list_1.DeviceList(lampenIds));
+        this.deviceCluster.deviceMap.set(enums_1.DeviceClusterType.Outlets, new device_list_1.DeviceList(steckerIds));
+        this.deviceCluster.deviceMap.set(enums_1.DeviceClusterType.LED, new device_list_1.DeviceList(ledIds));
+        this.deviceCluster.deviceMap.set(enums_1.DeviceClusterType.WLED, new device_list_1.DeviceList(wledIds));
+    }
+    anyLightsOn() {
+        return (this.getAllAsActuator().find((a) => {
+            return a.actuatorOn;
+        }) !== undefined);
+    }
+    getLights() {
+        return this.deviceCluster.getDevicesByType(enums_1.DeviceClusterType.Lamps);
+    }
+    getLED() {
+        return this.deviceCluster.getDevicesByType(enums_1.DeviceClusterType.LED);
+    }
+    getWled() {
+        return this.deviceCluster.getIoBrokerDevicesByType(enums_1.DeviceClusterType.WLED);
+    }
+    getOutlets() {
+        return this.deviceCluster.getDevicesByType(enums_1.DeviceClusterType.Outlets);
+    }
+    getAllAsActuator() {
+        const result = [];
+        result.push(...this.getLights());
+        result.push(...this.getOutlets());
+        result.push(...this.getLED());
+        result.push(...this.getWled());
+        return result;
+    }
+    handleSunriseOff() {
+        if (!this.anyLightsOn()) {
+            return;
+        }
+        this.log(enums_1.LogLevel.Info, `Es ist hell genug --> Schalte Lampen im ${this.roomName} aus`);
+        this.switchAll(new command_1.ActuatorSetStateCommand(enums_1.CommandSource.Automatic, false, 'LightGroup handleSunriseOff'));
+    }
+    switchAll(c) {
+        this.getAllAsActuator().forEach((a) => {
+            if (a.settings.includeInAmbientLight && !c.isForceAction && !c.on && this._ambientLightOn) {
+                a.log(enums_1.LogLevel.Info, `Ambient light mode is active --> Skip non force light off command in ${this.roomName}; command: ${c.logMessage}`);
+                return;
+            }
+            a.setActuator(c);
+        });
+    }
+    switchTimeConditional(c) {
+        let resultLampen = false;
+        let resultSteckdosen = false;
+        let activatedGroups = 0;
+        const command = new command_1.LampSetTimeBasedCommand(c, c.time);
+        if (this.getWled().length > 0) {
+            activatedGroups++;
+            this.log(enums_1.LogLevel.Debug, `Set Wled time based for time "${enums_1.TimeOfDay[c.time]}"`);
+            this.getWled().forEach((wled) => {
+                wled.setTimeBased(command);
+            });
+        }
+        if (this.getLED().length > 0) {
+            activatedGroups++;
+            this.log(enums_1.LogLevel.Trace, `Set LEDs time based for time "${enums_1.TimeOfDay[c.time]}"`);
+            this.getLED().forEach((s) => {
+                s.setTimeBased(command);
+            });
+        }
+        if (this.getOutlets().length > 0) {
+            activatedGroups++;
+            this.log(enums_1.LogLevel.Trace, `Set outlets time based for time "${enums_1.TimeOfDay[c.time]}"`);
+            resultSteckdosen = true;
+        }
+        if (activatedGroups === 0 || this.getRoom().settings.includeLampsInNormalMovementLightning) {
+            this.log(enums_1.LogLevel.Trace, `Set Lamps time based for time "${enums_1.TimeOfDay[c.time]}"`);
+            resultLampen = true;
+        }
+        if (resultLampen) {
+            this.setAllLampenTimeBased(new command_1.LampSetTimeBasedCommand(c, c.time));
+        }
+        else {
+            this.setAllLampen(new command_1.LampSetLightCommand(c, false));
+        }
+        if (resultSteckdosen) {
+            this.setAllActuatorsTimeBased(new command_1.LampSetTimeBasedCommand(c, c.time));
+        }
+        else {
+            this.setAllOutlets(new command_1.ActuatorSetStateCommand(c, false));
+        }
+    }
+    setAllLampen(c) {
+        this.getLights().forEach((s) => {
+            s.setLight(c);
+        });
+    }
+    setAllLampenTimeBased(c) {
+        this.getLights().forEach((s) => {
+            s.setTimeBased(c);
+        });
+    }
+    setAllOutlets(c) {
+        this.getOutlets().forEach((s) => {
+            s.setActuator(c);
+        });
+    }
+    setAllActuatorsTimeBased(c) {
+        this.getOutlets().forEach((s) => {
+            if ((c.time === enums_1.TimeOfDay.Daylight && s.settings.dayOn) ||
+                (c.time === enums_1.TimeOfDay.Night && s.settings.nightOn) ||
+                (c.time === enums_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
+                (c.time === enums_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
+                s.setActuator(new command_1.ActuatorSetStateCommand(c, true, 'LightGroup setAllActuatorsTimeBased', c.disableAutomaticCommand));
+            }
+        });
+    }
+    setAllLED(c) {
+        this.getLED().forEach((s) => {
+            s.setLight(c);
+        });
+    }
+    setAllWled(c) {
+        this.getWled().forEach((w) => {
+            w.setWled(c);
+        });
+    }
+    initialize() {
+        this.recalculateTimeCallbacks();
+    }
+    recalculateTimeCallbacks() {
+        this.reconfigureSunriseTimeCallback();
+        this.reconfigureSunsetTimeCallback();
+    }
+    reconfigureSunriseTimeCallback() {
+        const room = this.getRoom();
+        if (!room.settings.lichtSonnenAufgangAus || !room.settings.lampOffset) {
+            if (this.sonnenAufgangLichtCallback !== undefined) {
+                this.log(enums_1.LogLevel.Debug, `Remove Sunrise Lamp callback for ${this.roomName}`);
+                services_1.TimeCallbackService.removeCallback(this.sonnenAufgangLichtCallback);
+                this.sonnenAufgangLichtCallback = undefined;
+            }
+            return;
+        }
+        if (this.sonnenAufgangLichtCallback && room.settings.lampOffset) {
+            this.sonnenAufgangLichtCallback.minuteOffset = room.settings.lampOffset.sunrise;
+            this.sonnenAufgangLichtCallback.recalcNextToDo(new Date());
+        }
+        if (this.sonnenAufgangLichtCallback === undefined) {
+            this.log(enums_1.LogLevel.Debug, `Add Sunrise lamp TimeCallback for ${this.roomName}`);
+            const cb = new models_1.TimeCallback(`${this.roomName} Morgens Lampe aus`, enums_1.TimeCallbackType.Sunrise, () => {
+                this.handleSunriseOff();
+            }, this.getRoom().settings.lampOffset.sunrise);
+            this.sonnenAufgangLichtCallback = cb;
+            services_1.TimeCallbackService.addCallback(cb);
+        }
+    }
+    reconfigureSunsetTimeCallback() {
+        const room = this.getRoom();
+        if (!room.settings.ambientLightAfterSunset || !room.settings.lampOffset) {
+            if (this.sonnenUntergangLichtCallback !== undefined) {
+                this.log(enums_1.LogLevel.Debug, `Remove Sunset Lamp callback for ${this.roomName}`);
+                services_1.TimeCallbackService.removeCallback(this.sonnenUntergangLichtCallback);
+                this.sonnenUntergangLichtCallback = undefined;
+            }
+            return;
+        }
+        if (this.sonnenUntergangLichtCallback && room.settings.lampOffset) {
+            this.sonnenUntergangLichtCallback.minuteOffset = room.settings.lampOffset.sunset;
+            this.sonnenUntergangLichtCallback.recalcNextToDo(new Date());
+        }
+        if (this.sonnenUntergangLichtCallback === undefined) {
+            this.log(enums_1.LogLevel.Debug, `Add Sunset Light TimeCallback for ${this.roomName}`);
+            const cb = new models_1.TimeCallback(`${this.roomName} Ambient Light after Sunset`, enums_1.TimeCallbackType.SunSet, this.ambientLightStartCallback.bind(this), this.getRoom().settings.lampOffset.sunset);
+            this.sonnenUntergangLichtCallback = cb;
+            services_1.TimeCallbackService.addCallback(cb);
+        }
+    }
+    ambientLightStartCallback() {
+        this._ambientLightOn = true;
+        this.log(enums_1.LogLevel.Info, 'Draußen wird es dunkel --> Aktiviere Ambientenbeleuchtung');
+        this.getAllAsActuator().forEach((a) => {
+            if (a.settings.includeInAmbientLight) {
+                a.setActuator(new command_1.ActuatorSetStateCommand(enums_1.CommandSource.Automatic, true, 'Ambient Light Start Callback'));
+            }
+        });
+        utils_1.Utils.guardedTimeout(() => {
+            var _a;
+            this.log(enums_1.LogLevel.Info, 'Ambientenbeleuchtung um Mitternacht abschalten.');
+            this._ambientLightOn = false;
+            if (((_a = this.getRoom().PraesenzGroup) === null || _a === void 0 ? void 0 : _a.anyPresent(true)) !== true) {
+                this.switchAll(new command_1.ActuatorSetStateCommand(enums_1.CommandSource.Automatic, false, 'Ambient Light End Callback'));
+            }
+        }, utils_1.Utils.timeTilMidnight, this);
+    }
+}
+exports.LightGroup = LightGroup;

package/lib/devices/groups/presenceGroup.d.ts

@@ -0,0 +1,34 @@
+import { MotionSensorAction, PresenceGroupAnyMovementAction, PresenceGroupFirstEnterAction, PresenceGroupLastLeftAction } from '../../action';
+import { BaseGroup } from './base-group';
+import { iMotionSensor, iPresenceGroup } from '../../interfaces';
+export declare class PresenceGroup extends BaseGroup implements iPresenceGroup {
+    private _lastMovement;
+    private _lastLeftTimeout;
+    private _lastLeftCbs;
+    private _firstEnterCbs;
+    private _anyMovementCbs;
+    constructor(roomName: string, motionSensorIds: string[]);
+    get lastLeftDelayActive(): boolean;
+    getMotionDetector(): Array<iMotionSensor>;
+    initCallbacks(): void;
+    anyPresent(includeMovementResetDelayCheck?: boolean): boolean;
+    addLastLeftCallback(cb: (action: PresenceGroupLastLeftAction) => void): void;
+    addAnyMovementCallback(cb: (action: PresenceGroupAnyMovementAction) => void): void;
+    presentAmount(): number;
+    fireFistEnterCBs(action: MotionSensorAction): void;
+    addFirstEnterCallback(cb: (action: PresenceGroupFirstEnterAction) => void): void;
+    motionSensorOnAnyMovement(action: MotionSensorAction): void;
+    motionSensorOnLastLeft(action: MotionSensorAction): void;
+    /**
+     * Calculates whether we are after (negative if before) the time the movement
+     * reset timer should have reset the movement.
+     * @returns The time in milliseconds after the reset time.
+     */
+    getTimeAfterReset(): number;
+    /**
+     * In case of an existing delayed last left callback timeout, this removes it.
+     */
+    resetLastLeftTimeout(): void;
+    executeAnyMovementCbs(action: PresenceGroupAnyMovementAction): void;
+    executeLastLeftCbs(action: PresenceGroupLastLeftAction): void;
+}

package/lib/devices/groups/presenceGroup.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceGroup = void 0;
+const action_1 = require("../../action");
+const base_group_1 = require("./base-group");
+const enums_1 = require("../../enums");
+const device_list_1 = require("../device-list");
+const command_1 = require("../../command");
+const services_1 = require("../../services");
+const utils_1 = require("../../utils");
+class PresenceGroup extends base_group_1.BaseGroup {
+    constructor(roomName, motionSensorIds) {
+        super(roomName, enums_1.GroupType.Presence);
+        this._lastMovement = new Date(0);
+        this._lastLeftTimeout = null;
+        this._lastLeftCbs = [];
+        this._firstEnterCbs = [];
+        this._anyMovementCbs = [];
+        this.deviceCluster.deviceMap.set(enums_1.DeviceClusterType.MotionDetection, new device_list_1.DeviceList(motionSensorIds));
+    }
+    get lastLeftDelayActive() {
+        return this.getTimeAfterReset() < 0;
+    }
+    getMotionDetector() {
+        return this.deviceCluster.getDevicesByType(enums_1.DeviceClusterType.MotionDetection);
+    }
+    initCallbacks() {
+        this.getMotionDetector().forEach((b) => {
+            b.addMovementCallback((action) => {
+                if (!action.motionDetected && !this.anyPresent()) {
+                    this.motionSensorOnLastLeft(action);
+                    return;
+                }
+                if (!action.motionDetected && this.anyPresent()) {
+                    this.resetLastLeftTimeout();
+                    return;
+                }
+                // At this Point we can be certain about motion being detected.
+                this.log(enums_1.LogLevel.Debug, `New Motion detected, present Amount: ${this.presentAmount()}`, enums_1.LogDebugType.NewMovementState);
+                this.motionSensorOnAnyMovement(action);
+                if (this.presentAmount() === 1 && this._lastLeftTimeout === null) {
+                    this.fireFistEnterCBs(action);
+                }
+                this.resetLastLeftTimeout();
+            });
+        });
+        this.addLastLeftCallback((action) => {
+            var _a, _b;
+            (_a = this.getRoom().WindowGroup) === null || _a === void 0 ? void 0 : _a.changeVibrationMotionBlock(false);
+            (_b = this.getRoom().LightGroup) === null || _b === void 0 ? void 0 : _b.switchAll(new command_1.ActuatorSetStateCommand(action, false, 'Presence Group LastLeftCallback'));
+        });
+        this.addAnyMovementCallback((action) => {
+            if (!this.getRoom().settings.lampenBeiBewegung) {
+                return;
+            }
+            this.log(enums_1.LogLevel.DeepTrace, `Bewegung im Raum ${this.roomName} festgestellt --> Licht einschalten`);
+            this.getRoom().setLightTimeBased(new command_1.RoomSetLightTimeBasedCommand(action, true));
+        });
+    }
+    anyPresent(includeMovementResetDelayCheck = false) {
+        if (includeMovementResetDelayCheck && this.lastLeftDelayActive) {
+            return true;
+        }
+        return this.presentAmount() > 0;
+    }
+    addLastLeftCallback(cb) {
+        this._lastLeftCbs.push(cb);
+    }
+    addAnyMovementCallback(cb) {
+        this._anyMovementCbs.push(cb);
+    }
+    presentAmount() {
+        return this.getMotionDetector().filter((b) => b.movementDetected).length;
+    }
+    fireFistEnterCBs(action) {
+        for (const cb of this._firstEnterCbs) {
+            cb(new action_1.PresenceGroupFirstEnterAction(action));
+        }
+    }
+    addFirstEnterCallback(cb) {
+        this._firstEnterCbs.push(cb);
+    }
+    motionSensorOnAnyMovement(action) {
+        var _a;
+        this._lastMovement = new Date();
+        if (services_1.RoomService.awayModeActive || (services_1.RoomService.nightAlarmActive && !action.sensor.settings.excludeFromNightAlarm)) {
+            services_1.RoomService.startIntrusionAlarm(this.getRoom(), action.sensor);
+        }
+        if (!action.sensor.settings.seesWindow) {
+            (_a = this.getRoom().WindowGroup) === null || _a === void 0 ? void 0 : _a.changeVibrationMotionBlock(true);
+        }
+        services_1.RoomService.movementHistory.add(`${utils_1.Utils.nowString()}: Raum "${this.roomName}" Gerät "${action.sensor.info.fullName}"`);
+        this.executeAnyMovementCbs(new action_1.PresenceGroupAnyMovementAction(action));
+    }
+    motionSensorOnLastLeft(action) {
+        let timeAfterReset = this.getTimeAfterReset();
+        if (timeAfterReset > 0) {
+            this._lastLeftTimeout = null;
+            this.log(enums_1.LogLevel.Debug, `Movement reset. Active Motions: ${this.presentAmount()}\tTime after Last Movement including Reset: ${timeAfterReset}`);
+            this.executeLastLeftCbs(new action_1.PresenceGroupLastLeftAction(action));
+            return;
+        }
+        const newResetTime = new Date(utils_1.Utils.nowMS() + Math.abs(timeAfterReset));
+        this.log(enums_1.LogLevel.Debug, `Movement reset in ${this.roomName} delayed to ${newResetTime.toLocaleTimeString('de-DE')}.`);
+        this.resetLastLeftTimeout();
+        this._lastLeftTimeout = utils_1.Utils.guardedTimeout(() => {
+            this._lastLeftTimeout = null;
+            timeAfterReset = this.getTimeAfterReset();
+            const presentAmount = this.presentAmount();
+            this.log(enums_1.LogLevel.Debug, `Delayed Movement reset. Active Motions: ${presentAmount}\tTime after Last Movement including Reset: ${timeAfterReset}, action: ${action.reasonTrace}`);
+            if (presentAmount <= 0 && timeAfterReset > 0) {
+                this.executeLastLeftCbs(new action_1.PresenceGroupLastLeftAction(action));
+            }
+        }, Math.abs(timeAfterReset) + 500, this);
+    }
+    /**
+     * Calculates whether we are after (negative if before) the time the movement
+     * reset timer should have reset the movement.
+     * @returns The time in milliseconds after the reset time.
+     */
+    getTimeAfterReset() {
+        return utils_1.Utils.nowMS() - this._lastMovement.getTime() - this.getRoom().settings.movementResetTimer * 1000;
+    }
+    /**
+     * In case of an existing delayed last left callback timeout, this removes it.
+     */
+    resetLastLeftTimeout() {
+        if (this._lastLeftTimeout === null) {
+            return;
+        }
+        clearTimeout(this._lastLeftTimeout);
+        this._lastLeftTimeout = null;
+    }
+    executeAnyMovementCbs(action) {
+        for (const cb of this._anyMovementCbs) {
+            cb(action);
+        }
+    }
+    executeLastLeftCbs(action) {
+        for (const cb of this._lastLeftCbs) {
+            cb(action);
+        }
+    }
+}
+exports.PresenceGroup = PresenceGroup;

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

@@ -0,0 +1,7 @@
+import { iSmokeDetectorDevice, iSmokeGroup } from '../../interfaces';
+import { BaseGroup } from './base-group';
+export declare class SmokeGroup extends BaseGroup implements iSmokeGroup {
+    constructor(roomName: string, smokeDetectorIds: string[]);
+    getSmokeDetectors(): iSmokeDetectorDevice[];
+    stopAlarm(): void;
+}