hoffmation-base 0.1.14 → 0.1.18

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeAquaraVibra = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const log_service_1 = require("../../services/log-service");
+const sonos_service_1 = require("../../services/Sonos/sonos-service");
+const utils_1 = require("../../services/utils/utils");
+const polly_service_1 = require("../../services/Sonos/polly-service");
+class ZigbeeAquaraVibra extends zigbeeDevice_1.ZigbeeDevice {
+    // TODO Set Sensitivity
+    constructor(pInfo) {
+        super(pInfo, zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeAquaraVibra);
+        this.sensitivity = '';
+        this.tiltAngle = 0;
+        this.tiltAngleX = 0;
+        this.tiltAngleXAbs = 0;
+        this.tiltAngleY = 0;
+        this.tiltAngleYAbs = 0;
+        this.tiltAngleZ = 0;
+        this.tilt = false;
+        this.vibration = false;
+        this.vibrationBlockedTimeStamp = 0;
+        this._idSensitivity = '';
+        this._vibrationBlocked = false;
+        this._alarmMessage = `Alarm bei ${this.info.customName}. Ich wiederhole: Alarm bei ${this.info.customName}`;
+        polly_service_1.PollyService.preloadTTS(this._alarmMessage);
+        this._idSensitivity = `${this.info.fullID}.sensitivity`;
+    }
+    set vibrationBlocked(pVal) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `${pVal ? 'Dea' : 'A'}ktiviere Vibrationsalarm für ${this.info.customName}`);
+        if (pVal) {
+            this.vibrationBlockedTimeStamp = new Date().getTime();
+        }
+        this._vibrationBlocked = pVal;
+    }
+    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 'sensitivity':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Vibrationssensor Update für ${this.info.customName} auf Sensitivity: ${state.val}`);
+                this.tiltAngleZ = state.val;
+                break;
+            case 'tilt_angle_z':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Vibrationssensor Update für ${this.info.customName} auf Winkel Z: ${state.val}`);
+                this.tiltAngleZ = state.val;
+                break;
+            case 'tilt_angle_y':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Vibrationssensor Update für ${this.info.customName} auf Winkel Y: ${state.val}`);
+                this.tiltAngleY = state.val;
+                break;
+            case 'tilt_angle_x':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Vibrationssensor Update für ${this.info.customName} auf Winkel X: ${state.val}`);
+                this.tiltAngleX = state.val;
+                break;
+            case 'vibration':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Vibrationssensor Update für ${this.info.customName} auf Vibration erkannt: ${state.val}`);
+                this.vibration = state.val;
+                if (this.vibration) {
+                    utils_1.Utils.guardedTimeout(() => {
+                        this.alarmCheck();
+                    }, 8500, this);
+                }
+                break;
+            case 'tilt_angle_y_abs':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Vibrationssensor Update für ${this.info.customName} auf absoluten Winkel Y: ${state.val}`);
+                this.tiltAngleYAbs = state.val;
+                break;
+            case 'tilt_angle_X_abs':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Vibrationssensor Update für ${this.info.customName} auf absoluten Winkel X: ${state.val}`);
+                this.tiltAngleXAbs = state.val;
+                break;
+            case 'tilt_angle':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Vibrationssensor Update für ${this.info.customName} auf Winkel: ${state.val}`);
+                this.tiltAngle = state.val;
+                break;
+            case 'tilt':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Vibrationssensor Update für ${this.info.customName} auf Winkel: ${state.val}`);
+                this.tilt = state.val;
+                break;
+        }
+    }
+    setSensitivity(pVal) {
+        let result = 'high';
+        switch (pVal) {
+            case 0:
+                result = 'low';
+                break;
+            case 1:
+                result = 'medium';
+                break;
+        }
+        if (this._idSensitivity === '') {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine Switch 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;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Vibration Sensitivität schalten: "${this.info.customName}" Wert: ${result}`);
+        this.ioConn.setState(this._idSensitivity, result, (err) => {
+            if (err) {
+                console.log(`Stecker schalten ergab Fehler: ${err}`);
+            }
+        });
+    }
+    alarmCheck() {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Alarmcheck für ${this.info.customName} Alarmblock Wert: ${this._vibrationBlocked}`);
+        if (this._vibrationBlocked) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Fenster offen, ignoriere Vibrationsalarm bei ${this.info.customName}`);
+            return;
+        }
+        const message = this._alarmMessage;
+        sonos_service_1.SonosService.speakOnAll(message);
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, message);
+    }
+}
+exports.ZigbeeAquaraVibra = ZigbeeAquaraVibra;

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+export declare class ZigbeeAquaraWater extends ZigbeeDevice {
+    water: boolean;
+    private _roomName;
+    iAlarm: NodeJS.Timeout | undefined;
+    private _messageAlarmFirst;
+    private _messageAlarm;
+    private _messageAlarmEnd;
+    set roomName(val: string);
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    private startAlarm;
+    stopAlarm(quiet?: boolean): void;
+    private alarm;
+}

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeAquaraWater = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const log_service_1 = require("../../services/log-service");
+const sonos_service_1 = require("../../services/Sonos/sonos-service");
+const utils_1 = require("../../services/utils/utils");
+const polly_service_1 = require("../../services/Sonos/polly-service");
+class ZigbeeAquaraWater extends zigbeeDevice_1.ZigbeeDevice {
+    constructor(pInfo) {
+        super(pInfo, zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeAquaraWater);
+        this.water = false;
+        this._roomName = '';
+        this.iAlarm = undefined;
+        this._messageAlarmFirst = '';
+        this._messageAlarm = '';
+        this._messageAlarmEnd = '';
+        this._messageAlarmFirst = `${this.info.customName} erkennt Wasser. Möglicher Rohrbruch in ${this._roomName}`;
+        this._messageAlarm = `${this.info.customName} hat ausgelöst. Poolparty in ${this._roomName}`;
+        this._messageAlarmEnd = `Wasser Alarm Ende: Überflutung in ${this._roomName} zu Ende.`;
+    }
+    set roomName(val) {
+        this._roomName = val;
+        this._messageAlarmFirst = `${this.info.customName} erkennt Wasser. Möglicher Rohrbruch in ${this._roomName}`;
+        this._messageAlarm = `${this.info.customName} hat ausgelöst. Poolparty in ${this._roomName}`;
+        this._messageAlarmEnd = `Wasser Alarm Ende: Überflutung in ${this._roomName} zu Ende.`;
+        polly_service_1.PollyService.preloadTTS(this._messageAlarmFirst);
+        polly_service_1.PollyService.preloadTTS(this._messageAlarm);
+        polly_service_1.PollyService.preloadTTS(this._messageAlarmEnd);
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Water Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'detected':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Wasser Update für ${this.info.customName} auf Wasser: ${state.val}`);
+                const newVal = state.val === true;
+                if (this.water === true && !newVal) {
+                    this.stopAlarm();
+                }
+                else if (newVal) {
+                    this.startAlarm();
+                }
+                this.water = newVal;
+                break;
+        }
+    }
+    startAlarm() {
+        if (this.iAlarm !== undefined) {
+            clearInterval(this.iAlarm);
+        }
+        this.iAlarm = utils_1.Utils.guardedInterval(() => {
+            this.alarm();
+        }, 15000, this);
+        this.alarm(true);
+    }
+    stopAlarm(quiet = false) {
+        if (this.iAlarm) {
+            clearInterval(this.iAlarm);
+        }
+        if (quiet) {
+            return;
+        }
+        const message = this._messageAlarmEnd;
+        utils_1.Utils.guardedNewThread(() => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, message);
+        });
+        utils_1.Utils.guardedNewThread(() => {
+            sonos_service_1.SonosService.speakOnAll(message);
+        });
+    }
+    alarm(first = false) {
+        const message = first ? this._messageAlarmFirst : this._messageAlarm;
+        utils_1.Utils.guardedNewThread(() => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, message);
+        });
+        utils_1.Utils.guardedNewThread(() => {
+            sonos_service_1.SonosService.speakOnAll(message, 80);
+        });
+    }
+}
+exports.ZigbeeAquaraWater = ZigbeeAquaraWater;

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

@@ -0,0 +1,16 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { ActuatorSettings } from '../../../models/actuatorSettings';
+export declare class ZigbeeBlitzShp extends ZigbeeDevice {
+    steckerOn: boolean;
+    current: number;
+    energy: number;
+    loadPower: number;
+    settings: ActuatorSettings;
+    private steckerOnSwitchID;
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    setStecker(pValue: boolean): void;
+    toggleStecker(): boolean;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeBlitzShp = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const actuatorSettings_1 = require("../../../models/actuatorSettings");
+class ZigbeeBlitzShp extends zigbeeDevice_1.ZigbeeDevice {
+    constructor(pInfo) {
+        super(pInfo, zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeBlitzShp);
+        this.steckerOn = false;
+        this.current = 0;
+        this.energy = 0;
+        this.loadPower = 0;
+        this.settings = new actuatorSettings_1.ActuatorSettings();
+        this.steckerOnSwitchID = '';
+        this.steckerOnSwitchID = `${this.info.fullID}.state`;
+    }
+    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 'state':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Stecker Update für ${this.info.customName} auf ${state.val}`);
+                this.steckerOn = state.val;
+                break;
+            case 'energy':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Stecker Update für ${this.info.customName} auf Energie: ${state.val}`);
+                this.energy = state.val;
+                break;
+            case 'current':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Stecker Update für ${this.info.customName} auf Strom: ${state.val}`);
+                this.current = state.val;
+                break;
+            case 'load_power':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Stecker Update für ${this.info.customName} auf Leistungsaufnahme: ${state.val}`);
+                this.loadPower = state.val;
+                break;
+        }
+    }
+    setStecker(pValue) {
+        if (this.steckerOnSwitchID === '') {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine Switch 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;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Stecker schalten: "${this.info.customName}" Wert: ${pValue}`);
+        this.ioConn.setState(this.steckerOnSwitchID, pValue, (err) => {
+            if (err) {
+                console.log(`Stecker schalten ergab Fehler: ${err}`);
+            }
+        });
+    }
+    toggleStecker() {
+        const newVal = !this.steckerOn;
+        this.setStecker(newVal);
+        return newVal;
+    }
+}
+exports.ZigbeeBlitzShp = ZigbeeBlitzShp;

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

@@ -0,0 +1,20 @@
+/// <reference types="iobroker" />
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeRoomSettings } from '../../../models/rooms/RoomSettings/zigbeeRoomSettings';
+import { ioBrokerBaseDevice } from '../iIoBrokerDevice';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+export declare class ZigbeeDevice extends ioBrokerBaseDevice {
+    private static roomSettings;
+    room: RoomBase | undefined;
+    deviceType: ZigbeeDeviceType;
+    available: boolean;
+    linkQuality: number;
+    battery: number;
+    voltage: string;
+    static addRoom(shortName: string, settings: ZigbeeRoomSettings): void;
+    static checkMissing(): void;
+    constructor(pInfo: DeviceInfo, pType: ZigbeeDeviceType);
+    protected addToCorrectRoom(): void;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeDevice = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const iIoBrokerDevice_1 = require("../iIoBrokerDevice");
+class ZigbeeDevice extends iIoBrokerDevice_1.ioBrokerBaseDevice {
+    constructor(pInfo, pType) {
+        super(pInfo);
+        this.room = undefined;
+        this.available = false;
+        this.linkQuality = 0;
+        this.battery = -1;
+        this.voltage = '';
+        this.deviceType = pType;
+        this.addToCorrectRoom();
+    }
+    static addRoom(shortName, settings) {
+        if (this.roomSettings[shortName] !== undefined) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Es gibt bereits ein Registrat für ZigbeeRoomsettings für den Raumnamen "${shortName}"`);
+            return;
+        }
+        this.roomSettings[shortName] = settings;
+    }
+    static checkMissing() {
+        for (const rName in this.roomSettings) {
+            this.roomSettings[rName].checkMissing();
+        }
+    }
+    addToCorrectRoom() {
+        const settings = ZigbeeDevice.roomSettings[this.info.room];
+        if (settings !== undefined) {
+            if (settings.devices[this.deviceType] === undefined) {
+                log_service_1.ServerLogService.missingZigbeeRoomHandling(settings.RoomName, this.deviceType);
+                return;
+            }
+            const deviceSettings = settings.devices[this.deviceType][this.info.deviceRoomIndex];
+            if (deviceSettings === undefined) {
+                log_service_1.ServerLogService.missingZigbeeRoomIndexHandling(settings.RoomName, this.info.deviceRoomIndex, this.deviceType);
+                return;
+            }
+            if (deviceSettings.customName !== undefined) {
+                this.info.customName = deviceSettings.customName;
+            }
+            deviceSettings.setID(this.info.devID);
+            deviceSettings.added = true;
+            log_service_1.ServerLogService.addedZigbeeDeviceToRoom(settings.RoomName, this.deviceType, this.info.deviceRoomIndex);
+            return;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `${this.info.room} ist noch kein bekannter Raum für Zigbee Geräte`);
+    }
+    update(idSplit, state, initial = false, pOverride = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Zigbee: ${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 'available':
+                this.available = state.val;
+                if (!this.available) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Das Zigbee Gerät mit dem Namen "${this.info.customName}" ist nicht erreichbar.`);
+                }
+                break;
+            case 'battery':
+                this.battery = state.val;
+                if (this.battery < 20) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Das Zigbee Gerät mit dem Namen "${this.info.customName}" hat unter 20% Batterie.`);
+                }
+                break;
+            case 'link_quality':
+                this.linkQuality = state.val;
+                if (this.linkQuality < 5) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Das Zigbee Gerät mit dem Namen "${this.info.customName}" hat eine schlechte Verbindung (${this.linkQuality}).`);
+                }
+                break;
+            case 'voltage':
+                this.voltage = state.val;
+                break;
+        }
+    }
+}
+exports.ZigbeeDevice = ZigbeeDevice;
+ZigbeeDevice.roomSettings = {};

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

@@ -0,0 +1,14 @@
+export declare enum ZigbeeDeviceType {
+    unknown = 0,
+    ZigbeeIkeaFernbedienung = 1,
+    ZigbeeIkeaSteckdose = 2,
+    ZigbeeIlluLedRGBCCT = 3,
+    ZigbeeAquaraVibra = 4,
+    ZigbeeIlluDimmer = 5,
+    ZigbeeHeimanSmoke = 6,
+    ZigbeeAquaraWater = 7,
+    ZigbeeBlitzShp = 8,
+    ZigbeeIlluLampe = 9,
+    ZigbeeIlluActuator = 10,
+    ZigbeeAquaraMotion = 11
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeDeviceType = void 0;
+var ZigbeeDeviceType;
+(function (ZigbeeDeviceType) {
+    ZigbeeDeviceType[ZigbeeDeviceType["unknown"] = 0] = "unknown";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeIkeaFernbedienung"] = 1] = "ZigbeeIkeaFernbedienung";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeIkeaSteckdose"] = 2] = "ZigbeeIkeaSteckdose";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeIlluLedRGBCCT"] = 3] = "ZigbeeIlluLedRGBCCT";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeAquaraVibra"] = 4] = "ZigbeeAquaraVibra";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeIlluDimmer"] = 5] = "ZigbeeIlluDimmer";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeHeimanSmoke"] = 6] = "ZigbeeHeimanSmoke";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeAquaraWater"] = 7] = "ZigbeeAquaraWater";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeBlitzShp"] = 8] = "ZigbeeBlitzShp";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeIlluLampe"] = 9] = "ZigbeeIlluLampe";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeIlluActuator"] = 10] = "ZigbeeIlluActuator";
+    ZigbeeDeviceType[ZigbeeDeviceType["ZigbeeAquaraMotion"] = 11] = "ZigbeeAquaraMotion";
+})(ZigbeeDeviceType = exports.ZigbeeDeviceType || (exports.ZigbeeDeviceType = {}));

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+export declare class ZigbeeHeimanSmoke extends ZigbeeDevice {
+    smoke: boolean;
+    private _roomName;
+    iAlarm: NodeJS.Timeout | undefined;
+    private _messageAlarmFirst;
+    private _messageAlarm;
+    private _messageAlarmEnd;
+    set roomName(val: string);
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    private startAlarm;
+    stopAlarm(quiet?: boolean): void;
+    private alarm;
+}

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeHeimanSmoke = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const log_service_1 = require("../../services/log-service");
+const sonos_service_1 = require("../../services/Sonos/sonos-service");
+const RoomBase_1 = require("../../../models/rooms/RoomBase");
+const utils_1 = require("../../services/utils/utils");
+const polly_service_1 = require("../../services/Sonos/polly-service");
+class ZigbeeHeimanSmoke extends zigbeeDevice_1.ZigbeeDevice {
+    constructor(pInfo) {
+        super(pInfo, zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeHeimanSmoke);
+        this.smoke = false;
+        this._roomName = '';
+        this.iAlarm = undefined;
+        this._messageAlarmFirst = '';
+        this._messageAlarm = '';
+        this._messageAlarmEnd = '';
+        this._messageAlarmFirst = `Rauchmelder in ${this._roomName} ausgelöst. Möglicher Brand in ${this._roomName}`;
+        this._messageAlarm = `Rauchmelder in ${this._roomName} aktiv. Möglicher Brand in ${this._roomName}`;
+        this._messageAlarmEnd = `Rauchmelder Alarm Ende: Gefahr in ${this._roomName} zu Ende.`;
+    }
+    set roomName(val) {
+        this._roomName = val;
+        this._messageAlarmFirst = `Rauchmelder in ${this._roomName} ausgelöst. Möglicher Brand in ${this._roomName}`;
+        this._messageAlarm = `Rauchmelder in ${this._roomName} aktiv. Möglicher Brand in ${this._roomName}`;
+        this._messageAlarmEnd = `Rauchmelder Alarm Ende: Gefahr in ${this._roomName} zu Ende.`;
+        polly_service_1.PollyService.preloadTTS(this._messageAlarmFirst);
+        polly_service_1.PollyService.preloadTTS(this._messageAlarm);
+        polly_service_1.PollyService.preloadTTS(this._messageAlarmEnd);
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Smoke Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'smoke':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Smoke Update für ${this.info.customName} auf Rauch: ${state.val}`);
+                const newVal = state.val === true;
+                if (this.smoke === true && !newVal) {
+                    this.stopAlarm();
+                }
+                else if (newVal) {
+                    this.startAlarm();
+                }
+                this.smoke = newVal;
+                break;
+        }
+    }
+    startAlarm() {
+        if (this.iAlarm !== undefined) {
+            clearInterval(this.iAlarm);
+        }
+        this.iAlarm = utils_1.Utils.guardedInterval(() => {
+            this.alarm();
+        }, 15000, this);
+        this.alarm(true);
+    }
+    stopAlarm(quiet = false) {
+        if (this.iAlarm) {
+            clearInterval(this.iAlarm);
+        }
+        if (quiet) {
+            return;
+        }
+        const message = this._messageAlarmEnd;
+        utils_1.Utils.guardedNewThread(() => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, message);
+        });
+        utils_1.Utils.guardedNewThread(() => {
+            sonos_service_1.SonosService.speakOnAll(message);
+        });
+    }
+    alarm(first = false) {
+        const message = first ? this._messageAlarmFirst : this._messageAlarm;
+        utils_1.Utils.guardedNewThread(() => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, message);
+        });
+        utils_1.Utils.guardedNewThread(() => {
+            sonos_service_1.SonosService.speakOnAll(message, 100);
+        });
+        utils_1.Utils.guardedNewThread(() => {
+            // Roll all Rollos up, to ensure free sight for firefighters
+            RoomBase_1.RoomBase.setAllRolloOfFloor(-1, 100);
+        });
+    }
+}
+exports.ZigbeeHeimanSmoke = ZigbeeHeimanSmoke;

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

@@ -0,0 +1,10 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeActuator } from './ZigbeeActuator';
+export declare class ZigbeeIkeaSteckdose extends ZigbeeActuator {
+    get steckerOn(): boolean;
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    setStecker(pValue: boolean, timeout?: number, force?: boolean): void;
+    toggleStecker(force?: boolean): boolean;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIkeaSteckdose = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const log_service_1 = require("../../services/log-service");
+const ZigbeeActuator_1 = require("./ZigbeeActuator");
+class ZigbeeIkeaSteckdose extends ZigbeeActuator_1.ZigbeeActuator {
+    get steckerOn() {
+        return super.actuatorOn;
+    }
+    constructor(pInfo) {
+        super(pInfo, zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeIkeaSteckdose, `${pInfo.fullID}.state`);
+    }
+    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);
+    }
+    setStecker(pValue, timeout = -1, force = false) {
+        super.setActuator(pValue, timeout, force);
+    }
+    toggleStecker(force = false) {
+        return super.toggleActuator(force);
+    }
+}
+exports.ZigbeeIkeaSteckdose = ZigbeeIkeaSteckdose;

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

@@ -0,0 +1,11 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { ZigbeeActuator } from './ZigbeeActuator';
+export declare class ZigbeeIlluActuator extends ZigbeeActuator {
+    get isActuatorOn(): boolean;
+    constructor(pInfo: DeviceInfo, deviceType?: ZigbeeDeviceType);
+    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/zigbeeIlluActuator.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIlluActuator = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const log_service_1 = require("../../services/log-service");
+const ZigbeeActuator_1 = require("./ZigbeeActuator");
+class ZigbeeIlluActuator extends ZigbeeActuator_1.ZigbeeActuator {
+    get isActuatorOn() {
+        return this.actuatorOn;
+    }
+    constructor(pInfo, deviceType = zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeIlluActuator) {
+        super(pInfo, deviceType, `${pInfo.fullID}.state`);
+    }
+    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)}`);
+        }
+        super.update(idSplit, state, initial, true);
+    }
+    setActuator(pValue, timeout = -1, force = false) {
+        super.setActuator(pValue, timeout, force);
+    }
+    toggleActuator(force = false) {
+        return super.toggleActuator(force);
+    }
+}
+exports.ZigbeeIlluActuator = ZigbeeIlluActuator;

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

@@ -0,0 +1,23 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { DimmerSettings } from '../../../models/dimmerSettings';
+import { TimeOfDay } from '../../services/time-callback-service';
+import { iLamp } from '../iLamp';
+export declare class ZigbeeIlluDimmer extends ZigbeeDevice implements iLamp {
+    lightOn: boolean;
+    queuedValue: boolean | null;
+    brightness: number;
+    transitionTime: number;
+    settings: DimmerSettings;
+    private stateID;
+    private brightnessID;
+    private transitionID;
+    private turnOffTimeout;
+    private turnOffTime;
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number): void;
+    toggleLight(time?: TimeOfDay, force?: boolean): boolean;
+}