hoffmation-base 0.0.1

package/server/devices/zigbee/ZigbeeActuator.ts

@@ -0,0 +1,113 @@
+import { ZigbeeDevice } from '/server/devices/zigbee/zigbeeDevice';
+import { DeviceInfo } from '/server/devices/DeviceInfo';
+import { ZigbeeDeviceType } from '/server/devices/zigbee/zigbeeDeviceType';
+import { ServerLogService } from '/server/services/log-service';
+import { LogLevel } from '/models/logLevel';
+import { Utils } from '/server/services/utils/utils';
+import { LampSettings } from '/models/lampSettings';
+
+export class ZigbeeActuator extends ZigbeeDevice {
+  public settings: LampSettings = new LampSettings();
+  protected readonly actuatorOnSwitchID: string;
+  protected queuedValue: boolean | null = null;
+  protected actuatorOn: boolean = false;
+  private turnOffTimeout: NodeJS.Timeout | undefined = undefined;
+  private turnOffTime: number = 0;
+
+  public constructor(pInfo: DeviceInfo, type: ZigbeeDeviceType, actuatorOnSwitchID: string) {
+    super(pInfo, type);
+    this.actuatorOnSwitchID = actuatorOnSwitchID;
+  }
+
+  public update(
+    idSplit: string[],
+    state: ioBroker.State,
+    initial: boolean = false,
+    handledByChildObject: boolean = false,
+  ): void {
+    if (!handledByChildObject) {
+      ServerLogService.writeLog(
+        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 &&
+          ServerLogService.writeLog(LogLevel.Trace, `Aktor Update für ${this.info.customName} auf ${state.val}`);
+        this.actuatorOn = state.val as boolean;
+        break;
+    }
+  }
+
+  public setActuator(pValue: boolean, timeout: number = -1, force: boolean = false): void {
+    if (this.actuatorOnSwitchID === '') {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Switch ID für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (!force && Utils.nowMS() < this.turnOffTime) {
+      ServerLogService.writeLog(
+        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) {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (!force && pValue === this.actuatorOn && this.queuedValue === null) {
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Skip actuator command for "${this.info.customName}" as it is already ${pValue}`,
+      );
+      return;
+    }
+
+    ServerLogService.writeLog(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.nowMS() + timeout;
+    this.turnOffTimeout = Utils.guardedTimeout(
+      () => {
+        ServerLogService.writeLog(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,
+    );
+  }
+
+  public toggleActuator(force: boolean = false): boolean {
+    const newVal = this.queuedValue !== null ? !this.queuedValue : !this.actuatorOn;
+    const timeout: number = newVal && force ? 30 * 60 * 1000 : -1;
+    this.setActuator(newVal, timeout, force);
+    return newVal;
+  }
+}

package/server/devices/zigbee/zigbeeAquaraVibra.ts

@@ -0,0 +1,171 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { SonosService } from '/server/services/Sonos/sonos-service';
+import { Utils } from '/server/services/utils/utils';
+import { PollyService } from '/server/services/Sonos/polly-service';
+
+export class ZigbeeAquaraVibra extends ZigbeeDevice {
+  public sensitivity: string = '';
+  public tiltAngle: number = 0;
+  public tiltAngleX: number = 0;
+  public tiltAngleXAbs: number = 0;
+  public tiltAngleY: number = 0;
+  public tiltAngleYAbs: number = 0;
+  public tiltAngleZ: number = 0;
+  public tilt: boolean = false;
+  public vibration: boolean = false;
+  public vibrationBlockedTimeStamp: number = 0;
+  private _idSensitivity: string = '';
+  private _vibrationBlocked: boolean = false;
+  private _alarmMessage: string;
+  // TODO Set Sensitivity
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, ZigbeeDeviceType.ZigbeeAquaraVibra);
+    this._alarmMessage = `Alarm bei ${this.info.customName}. Ich wiederhole: Alarm bei ${this.info.customName}`;
+    PollyService.preloadTTS(this._alarmMessage);
+    this._idSensitivity = `${this.info.fullID}.sensitivity`;
+  }
+
+  public set vibrationBlocked(pVal: boolean) {
+    ServerLogService.writeLog(
+      LogLevel.Debug,
+      `${pVal ? 'Dea' : 'A'}ktiviere Vibrationsalarm für ${this.info.customName}`,
+    );
+    if (pVal) {
+      this.vibrationBlockedTimeStamp = new Date().getTime();
+    }
+    this._vibrationBlocked = pVal;
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      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':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Vibrationssensor Update für ${this.info.customName} auf Sensitivity: ${state.val}`,
+        );
+        this.tiltAngleZ = state.val as number;
+        break;
+      case 'tilt_angle_z':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Vibrationssensor Update für ${this.info.customName} auf Winkel Z: ${state.val}`,
+        );
+        this.tiltAngleZ = state.val as number;
+        break;
+      case 'tilt_angle_y':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Vibrationssensor Update für ${this.info.customName} auf Winkel Y: ${state.val}`,
+        );
+        this.tiltAngleY = state.val as number;
+        break;
+      case 'tilt_angle_x':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Vibrationssensor Update für ${this.info.customName} auf Winkel X: ${state.val}`,
+        );
+        this.tiltAngleX = state.val as number;
+        break;
+      case 'vibration':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Vibrationssensor Update für ${this.info.customName} auf Vibration erkannt: ${state.val}`,
+        );
+        this.vibration = state.val as boolean;
+        if (this.vibration) {
+          Utils.guardedTimeout(
+            () => {
+              this.alarmCheck();
+            },
+            8500,
+            this,
+          );
+        }
+        break;
+      case 'tilt_angle_y_abs':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Vibrationssensor Update für ${this.info.customName} auf absoluten Winkel Y: ${state.val}`,
+        );
+        this.tiltAngleYAbs = state.val as number;
+        break;
+      case 'tilt_angle_X_abs':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Vibrationssensor Update für ${this.info.customName} auf absoluten Winkel X: ${state.val}`,
+        );
+        this.tiltAngleXAbs = state.val as number;
+        break;
+      case 'tilt_angle':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Vibrationssensor Update für ${this.info.customName} auf Winkel: ${state.val}`,
+        );
+        this.tiltAngle = state.val as number;
+        break;
+      case 'tilt':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Vibrationssensor Update für ${this.info.customName} auf Winkel: ${state.val}`,
+        );
+        this.tilt = state.val as boolean;
+        break;
+    }
+  }
+
+  public setSensitivity(pVal: number): void {
+    let result = 'high';
+    switch (pVal) {
+      case 0:
+        result = 'low';
+        break;
+      case 1:
+        result = 'medium';
+        break;
+    }
+    if (this._idSensitivity === '') {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Switch ID für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (!this.ioConn) {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    ServerLogService.writeLog(
+      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}`);
+      }
+    });
+  }
+
+  private alarmCheck(): void {
+    ServerLogService.writeLog(
+      LogLevel.Debug,
+      `Alarmcheck für ${this.info.customName} Alarmblock Wert: ${this._vibrationBlocked}`,
+    );
+    if (this._vibrationBlocked) {
+      ServerLogService.writeLog(LogLevel.Debug, `Fenster offen, ignoriere Vibrationsalarm bei ${this.info.customName}`);
+      return;
+    }
+
+    const message = this._alarmMessage;
+    SonosService.speakOnAll(message);
+    ServerLogService.writeLog(LogLevel.Alert, message);
+  }
+}

package/server/devices/zigbee/zigbeeAquaraWater.ts

@@ -0,0 +1,94 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { SonosService } from '/server/services/Sonos/sonos-service';
+import { Utils } from '/server/services/utils/utils';
+import { PollyService } from '/server/services/Sonos/polly-service';
+
+export class ZigbeeAquaraWater extends ZigbeeDevice {
+  public water: boolean = false;
+  private _roomName: string = '';
+  public iAlarm: NodeJS.Timeout | undefined = undefined;
+  private _messageAlarmFirst: string = '';
+  private _messageAlarm: string = '';
+  private _messageAlarmEnd: string = '';
+
+  public set roomName(val: string) {
+    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.`;
+    PollyService.preloadTTS(this._messageAlarmFirst);
+    PollyService.preloadTTS(this._messageAlarm);
+    PollyService.preloadTTS(this._messageAlarmEnd);
+  }
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, ZigbeeDeviceType.ZigbeeAquaraWater);
+    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.`;
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      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':
+        ServerLogService.writeLog(LogLevel.Debug, `Wasser Update für ${this.info.customName} auf Wasser: ${state.val}`);
+        const newVal: boolean = state.val === true;
+        if (this.water === true && !newVal) {
+          this.stopAlarm();
+        } else if (newVal) {
+          this.startAlarm();
+        }
+        this.water = newVal;
+        break;
+    }
+  }
+
+  private startAlarm(): void {
+    if (this.iAlarm !== undefined) {
+      clearInterval(this.iAlarm);
+    }
+    this.iAlarm = Utils.guardedInterval(
+      () => {
+        this.alarm();
+      },
+      15000,
+      this,
+    );
+    this.alarm(true);
+  }
+
+  public stopAlarm(quiet: boolean = false): void {
+    if (this.iAlarm) {
+      clearInterval(this.iAlarm);
+    }
+    if (quiet) {
+      return;
+    }
+    const message = this._messageAlarmEnd;
+    Utils.guardedNewThread(() => {
+      ServerLogService.writeLog(LogLevel.Alert, message);
+    });
+    Utils.guardedNewThread(() => {
+      SonosService.speakOnAll(message);
+    });
+  }
+
+  private alarm(first: boolean = false): void {
+    const message = first ? this._messageAlarmFirst : this._messageAlarm;
+    Utils.guardedNewThread(() => {
+      ServerLogService.writeLog(LogLevel.Alert, message);
+    });
+    Utils.guardedNewThread(() => {
+      SonosService.speakOnAll(message, 80);
+    });
+  }
+}

package/server/devices/zigbee/zigbeeBlitzShp.ts

@@ -0,0 +1,77 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { LampSettings } from '/models/lampSettings';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+
+export class ZigbeeBlitzShp extends ZigbeeDevice {
+  public steckerOn: boolean = false;
+  public current: number = 0;
+  public energy: number = 0;
+  public loadPower: number = 0;
+  public settings: LampSettings = new LampSettings();
+  private steckerOnSwitchID: string = '';
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, ZigbeeDeviceType.ZigbeeBlitzShp);
+    this.steckerOnSwitchID = `${this.info.fullID}.state`;
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      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':
+        ServerLogService.writeLog(LogLevel.Trace, `Stecker Update für ${this.info.customName} auf ${state.val}`);
+        this.steckerOn = state.val as boolean;
+        break;
+      case 'energy':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Stecker Update für ${this.info.customName} auf Energie: ${state.val}`,
+        );
+        this.energy = state.val as number;
+        break;
+      case 'current':
+        ServerLogService.writeLog(LogLevel.Trace, `Stecker Update für ${this.info.customName} auf Strom: ${state.val}`);
+        this.current = state.val as number;
+        break;
+      case 'load_power':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Stecker Update für ${this.info.customName} auf Leistungsaufnahme: ${state.val}`,
+        );
+        this.loadPower = state.val as number;
+        break;
+    }
+  }
+
+  public setStecker(pValue: boolean): void {
+    if (this.steckerOnSwitchID === '') {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Switch ID für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (!this.ioConn) {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    ServerLogService.writeLog(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}`);
+      }
+    });
+  }
+
+  public toggleStecker(): boolean {
+    const newVal = !this.steckerOn;
+    this.setStecker(newVal);
+    return newVal;
+  }
+}

package/server/devices/zigbee/zigbeeDevice.ts

@@ -0,0 +1,115 @@
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { LogLevel } from '/models/logLevel';
+import { ZigbeeAddDeviceItem, ZigbeeRoomSettings } from '/models/rooms/RoomSettings/zigbeeRoomSettings';
+import { ServerLogService } from '/server/services/log-service';
+import { ioBrokerBaseDevice } from '/server/devices/iIoBrokerDevice';
+import { RoomBase } from '/models/rooms/RoomBase';
+
+export class ZigbeeDevice extends ioBrokerBaseDevice {
+  private static roomSettings: { [id: string]: ZigbeeRoomSettings } = {};
+  public room: RoomBase | undefined = undefined;
+  public deviceType: ZigbeeDeviceType;
+  public available: boolean = false;
+  public linkQuality: number = 0;
+  public battery: number = -1;
+  public voltage: string = '';
+
+  public static addRoom(shortName: string, settings: ZigbeeRoomSettings): void {
+    if (this.roomSettings[shortName] !== undefined) {
+      ServerLogService.writeLog(
+        LogLevel.Alert,
+        `Es gibt bereits ein Registrat für ZigbeeRoomsettings für den Raumnamen "${shortName}"`,
+      );
+      return;
+    }
+    this.roomSettings[shortName] = settings;
+  }
+
+  public static checkMissing(): void {
+    for (const rName in this.roomSettings) {
+      this.roomSettings[rName].checkMissing();
+    }
+  }
+
+  public constructor(pInfo: DeviceInfo, pType: ZigbeeDeviceType) {
+    super(pInfo);
+    this.deviceType = pType;
+    this.addToCorrectRoom();
+  }
+
+  protected addToCorrectRoom(): void {
+    const settings: ZigbeeRoomSettings | undefined = ZigbeeDevice.roomSettings[this.info.room];
+    if (settings !== undefined) {
+      if (settings.devices[this.deviceType] === undefined) {
+        ServerLogService.missingZigbeeRoomHandling(settings.RoomName, this.deviceType);
+        return;
+      }
+      const deviceSettings: ZigbeeAddDeviceItem | undefined =
+        settings.devices[this.deviceType][this.info.deviceRoomIndex];
+      if (deviceSettings === undefined) {
+        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;
+      ServerLogService.addedZigbeeDeviceToRoom(settings.RoomName, this.deviceType, this.info.deviceRoomIndex);
+      return;
+    }
+    ServerLogService.writeLog(LogLevel.Warn, `${this.info.room} ist noch kein bekannter Raum für Zigbee Geräte`);
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false, pOverride: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.DeepTrace,
+      `Zigbee:Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
+    );
+    if (!pOverride) {
+      ServerLogService.writeLog(
+        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 as boolean;
+        if (!this.available) {
+          ServerLogService.writeLog(
+            LogLevel.Debug,
+            `Das Zigbee Gerät mit dem Namen "${this.info.customName}" ist nicht erreichbar.`,
+          );
+        }
+        break;
+      case 'battery':
+        this.battery = state.val as number;
+        if (this.battery < 20) {
+          ServerLogService.writeLog(
+            LogLevel.Alert,
+            `Das Zigbee Gerät mit dem Namen "${this.info.customName}" hat unter 20% Batterie.`,
+          );
+        }
+        break;
+
+      case 'link_quality':
+        this.linkQuality = state.val as number;
+        if (this.linkQuality < 5) {
+          ServerLogService.writeLog(
+            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 as string;
+        break;
+    }
+  }
+}

package/server/devices/zigbee/zigbeeDeviceType.ts

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

package/server/devices/zigbee/zigbeeHeimanSmoke.ts

@@ -0,0 +1,99 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { SonosService } from '/server/services/Sonos/sonos-service';
+import { RoomBase } from '/models/rooms/RoomBase';
+import { Utils } from '/server/services/utils/utils';
+import { PollyService } from '/server/services/Sonos/polly-service';
+
+export class ZigbeeHeimanSmoke extends ZigbeeDevice {
+  public smoke: boolean = false;
+  private _roomName: string = '';
+  public iAlarm: NodeJS.Timeout | undefined = undefined;
+  private _messageAlarmFirst: string = '';
+  private _messageAlarm: string = '';
+  private _messageAlarmEnd: string = '';
+
+  public set roomName(val: string) {
+    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.`;
+    PollyService.preloadTTS(this._messageAlarmFirst);
+    PollyService.preloadTTS(this._messageAlarm);
+    PollyService.preloadTTS(this._messageAlarmEnd);
+  }
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, ZigbeeDeviceType.ZigbeeHeimanSmoke);
+    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.`;
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      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':
+        ServerLogService.writeLog(LogLevel.Debug, `Smoke Update für ${this.info.customName} auf Rauch: ${state.val}`);
+        const newVal: boolean = state.val === true;
+        if (this.smoke === true && !newVal) {
+          this.stopAlarm();
+        } else if (newVal) {
+          this.startAlarm();
+        }
+        this.smoke = newVal;
+        break;
+    }
+  }
+
+  private startAlarm(): void {
+    if (this.iAlarm !== undefined) {
+      clearInterval(this.iAlarm);
+    }
+    this.iAlarm = Utils.guardedInterval(
+      () => {
+        this.alarm();
+      },
+      15000,
+      this,
+    );
+    this.alarm(true);
+  }
+
+  public stopAlarm(quiet: boolean = false): void {
+    if (this.iAlarm) {
+      clearInterval(this.iAlarm);
+    }
+    if (quiet) {
+      return;
+    }
+    const message = this._messageAlarmEnd;
+    Utils.guardedNewThread(() => {
+      ServerLogService.writeLog(LogLevel.Alert, message);
+    });
+    Utils.guardedNewThread(() => {
+      SonosService.speakOnAll(message);
+    });
+  }
+
+  private alarm(first: boolean = false): void {
+    const message = first ? this._messageAlarmFirst : this._messageAlarm;
+    Utils.guardedNewThread(() => {
+      ServerLogService.writeLog(LogLevel.Alert, message);
+    });
+    Utils.guardedNewThread(() => {
+      SonosService.speakOnAll(message, 100);
+    });
+    Utils.guardedNewThread(() => {
+      // Roll all Rollos up, to ensure free sight for firefighters
+      RoomBase.setAllRolloOfFloor(-1, 100);
+    });
+  }
+}