hoffmation-base 0.0.1

package/server/devices/zigbee/zigbeeIkeaSteckdose.ts

@@ -0,0 +1,31 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { ZigbeeActuator } from '/server/devices/zigbee/ZigbeeActuator';
+
+export class ZigbeeIkeaSteckdose extends ZigbeeActuator {
+  public get steckerOn(): boolean {
+    return super.actuatorOn;
+  }
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, ZigbeeDeviceType.ZigbeeIkeaSteckdose, `${pInfo.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);
+  }
+
+  public setStecker(pValue: boolean, timeout: number = -1, force: boolean = false): void {
+    super.setActuator(pValue, timeout, force);
+  }
+
+  public toggleStecker(force: boolean = false): boolean {
+    return super.toggleActuator(force);
+  }
+}

package/server/devices/zigbee/zigbeeIlluActuator.ts

@@ -0,0 +1,37 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { ZigbeeActuator } from '/server/devices/zigbee/ZigbeeActuator';
+
+export class ZigbeeIlluActuator extends ZigbeeActuator {
+  public get isActuatorOn(): boolean {
+    return this.actuatorOn;
+  }
+  public constructor(pInfo: DeviceInfo, deviceType: ZigbeeDeviceType = ZigbeeDeviceType.ZigbeeIlluActuator) {
+    super(pInfo, deviceType, `${pInfo.fullID}.state`);
+  }
+
+  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)}`,
+      );
+    }
+    super.update(idSplit, state, initial, true);
+  }
+
+  public setActuator(pValue: boolean, timeout: number = -1, force: boolean = false): void {
+    super.setActuator(pValue, timeout, force);
+  }
+
+  public toggleActuator(force: boolean = false): boolean {
+    return super.toggleActuator(force);
+  }
+}

package/server/devices/zigbee/zigbeeIlluDimmer.ts

@@ -0,0 +1,165 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { DimmerSettings } from '/models/dimmerSettings';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { TimeOfDay } from '/server/services/time-callback-service';
+import { Utils } from '/server/services/utils/utils';
+
+export class ZigbeeIlluDimmer extends ZigbeeDevice {
+  public on: boolean = false;
+  public queuedValue: boolean | null = null;
+  public brightness: number = 0;
+  public transitionTime: number = 0;
+  public settings: DimmerSettings = new DimmerSettings();
+  private stateID: string = 'state';
+  private brightnessID: string = 'brightness';
+  private transitionID: string = 'transition_time';
+  private turnOffTimeout: NodeJS.Timeout | undefined = undefined;
+  private turnOffTime: number = 0;
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, ZigbeeDeviceType.ZigbeeIlluDimmer);
+    this.stateID = `${this.info.fullID}.state`;
+    this.brightnessID = `${this.info.fullID}.brightness`;
+    this.transitionID = `${this.info.fullID}.transition_time`;
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    this.queuedValue = null;
+    ServerLogService.writeLog(
+      LogLevel.DeepTrace,
+      `Dimmer 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, `Dimmer Update für ${this.info.customName} auf ${state.val}`);
+        this.on = state.val as boolean;
+        break;
+      case 'brightness':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Dimmer Helligkeit Update für ${this.info.customName} auf ${state.val}`,
+        );
+        this.brightness = state.val as number;
+        break;
+      case 'transition_time':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Dimmer Transition Time Update für ${this.info.customName} auf ${state.val}`,
+        );
+        this.transitionTime = state.val as number;
+        break;
+    }
+  }
+
+  public setTimeBased(time: TimeOfDay, timeout: number = -1, force: boolean = false): void {
+    switch (time) {
+      case TimeOfDay.Night:
+        this.setLight(true, timeout, force, 50);
+        break;
+      case TimeOfDay.AfterSunset:
+      case TimeOfDay.BeforeSunrise:
+        this.setLight(true, timeout, force, 75);
+        break;
+      case TimeOfDay.Daylight:
+        this.setLight(true, timeout, force, 100);
+        break;
+    }
+  }
+
+  public setLight(
+    pValue: boolean,
+    timeout: number = -1,
+    force: boolean = false,
+    brightness: number = -1,
+    transitionTime: number = -1,
+  ): void {
+    if (this.stateID === '') {
+      ServerLogService.writeLog(LogLevel.Error, `Keine State ID für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (!this.ioConn) {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (transitionTime > -1) {
+      this.ioConn.setState(this.transitionID, transitionTime, (err) => {
+        if (err) {
+          ServerLogService.writeLog(LogLevel.Error, `Dimmer TransitionTime schalten ergab Fehler: ${err}`);
+        }
+      });
+    }
+
+    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 (pValue && brightness === -1 && this.brightness < 10) {
+      brightness = 10;
+    }
+    ServerLogService.writeLog(
+      LogLevel.Debug,
+      `Dimmer Schalten: "${this.info.customName}" An: ${pValue}\tHelligkeit: ${brightness}%`,
+    );
+
+    this.ioConn.setState(this.stateID, pValue, (err) => {
+      if (err) {
+        ServerLogService.writeLog(LogLevel.Error, `Dimmer schalten ergab Fehler: ${err}`);
+      }
+    });
+    this.queuedValue = pValue;
+
+    if (brightness > -1) {
+      this.ioConn.setState(this.brightnessID, brightness, (err) => {
+        if (err) {
+          ServerLogService.writeLog(LogLevel.Error, `Dimmer Helligkeit schalten ergab Fehler: ${err}`);
+        }
+      });
+    }
+    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.setLight(false, -1, true);
+        } else {
+          this.room.setLightTimeBased(true);
+        }
+      },
+      timeout,
+      this,
+    );
+  }
+
+  public toggleLight(time?: TimeOfDay, force: boolean = false): boolean {
+    const newVal = this.queuedValue !== null ? !this.queuedValue : !this.on;
+    const timeout: number = newVal && force ? 30 * 60 * 1000 : -1;
+    if (newVal && time !== undefined) {
+      this.setTimeBased(time, timeout, force);
+      return true;
+    }
+    this.setLight(newVal, timeout, force);
+    return newVal;
+  }
+}

package/server/devices/zigbee/zigbeeIlluLampe.ts

@@ -0,0 +1,33 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { ZigbeeIlluActuator } from '/server/devices/zigbee/zigbeeIlluActuator';
+
+export class ZigbeeIlluLampe extends ZigbeeIlluActuator {
+  public get lampOn(): boolean {
+    return super.actuatorOn;
+  }
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, ZigbeeDeviceType.ZigbeeIlluLampe);
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    super.update(idSplit, state, initial, true);
+    switch (idSplit[3]) {
+      case 'state':
+        ServerLogService.writeLog(LogLevel.Trace, `Lampen Update für ${this.info.customName} auf ${state.val}`);
+        break;
+    }
+  }
+
+  public setLight(pValue: boolean, timeout: number = -1, force: boolean = false): void {
+    ServerLogService.writeLog(LogLevel.Debug, `Lampenaktor schalten: "${this.info.customName}" Wert: ${pValue}`);
+    super.setActuator(pValue, timeout, force);
+  }
+
+  public toggleLight(force: boolean = false): boolean {
+    return super.toggleActuator(force);
+  }
+}

package/server/devices/zigbee/zigbeeIlluLedRGBCCT.ts

@@ -0,0 +1,137 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { LedSettings } from '/models/ledSettings';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { TimeOfDay } from '/server/services/time-callback-service';
+
+export class ZigbeeIlluLedRGBCCT extends ZigbeeDevice {
+  public static DEFAULT_COLOR_WARM: string = '#f2b200';
+  public on: boolean = false;
+  public brightness: number = 0;
+  public color: string = '#fcba32';
+  public colortemp: number = 500;
+  public settings: LedSettings = new LedSettings();
+  private stateID: string = 'state';
+  private brightnessID: string = 'brightness';
+  private colorID: string = '';
+  private colorTempID: string = '';
+  private effectID: string = '';
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, ZigbeeDeviceType.ZigbeeIlluLedRGBCCT);
+    this.stateID = `${this.info.fullID}.state`;
+    this.brightnessID = `${this.info.fullID}.brightness`;
+    this.colorID = `${this.info.fullID}.color`;
+    this.colorTempID = `${this.info.fullID}.colortemp`;
+    this.effectID = `${this.info.fullID}.effect`;
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.DeepTrace,
+      `LED 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, `LED Update für ${this.info.customName} auf ${state.val}`);
+        this.on = state.val as boolean;
+        break;
+      case 'brightness':
+        ServerLogService.writeLog(LogLevel.Trace, `LED Helligkeit Update für ${this.info.customName} auf ${state.val}`);
+        this.brightness = state.val as number;
+        break;
+      case 'color':
+        ServerLogService.writeLog(LogLevel.Trace, `LED Color Update für ${this.info.customName} auf ${state.val}`);
+        this.color = state.val as string;
+        break;
+      case 'colortemp':
+        ServerLogService.writeLog(LogLevel.Trace, `LED Color Update für ${this.info.customName} auf ${state.val}`);
+        this.colortemp = state.val as number;
+        break;
+    }
+  }
+
+  public setTimeBased(time: TimeOfDay): void {
+    switch (time) {
+      case TimeOfDay.Night:
+        if (this.settings.nightOn) {
+          this.setLight(true, this.settings.nightBrightness, this.settings.nightColor, this.settings.nightColorTemp);
+        }
+        break;
+      case TimeOfDay.AfterSunset:
+        if (this.settings.duskOn) {
+          this.setLight(true, this.settings.duskBrightness, this.settings.duskColor, this.settings.duskColorTemp);
+        }
+        break;
+      case TimeOfDay.BeforeSunrise:
+        if (this.settings.dawnOn) {
+          this.setLight(true, this.settings.dawnBrightness, this.settings.dawnColor, this.settings.dawnColorTemp);
+        }
+        break;
+      case TimeOfDay.Daylight:
+        if (this.settings.dayOn) {
+          this.setLight(true, this.settings.dayBrightness, this.settings.dayColor, this.settings.dayColorTemp);
+        }
+        break;
+    }
+  }
+
+  public setLight(pValue: boolean, brightness: number = -1, color: string = '', colortemp: number = -1): void {
+    if (this.stateID === '') {
+      ServerLogService.writeLog(LogLevel.Error, `Keine State ID für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (!this.ioConn) {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (pValue && brightness === -1 && this.brightness < 10) {
+      brightness = 10;
+    }
+    ServerLogService.writeLog(
+      LogLevel.Debug,
+      `LED Schalten: "${this.info.customName}" An: ${pValue}\tHelligkeit: ${brightness}%\tFarbe: "${color}"\tColorTemperatur: ${colortemp}`,
+    );
+
+    if (color !== '') {
+      this.ioConn.setState(this.colorID, color, (err) => {
+        if (err) {
+          ServerLogService.writeLog(LogLevel.Error, `LED Farbe schalten ergab Fehler: ${err}`);
+        }
+      });
+    }
+
+    if (colortemp > -1) {
+      this.ioConn.setState(this.colorTempID, colortemp, (err) => {
+        if (err) {
+          ServerLogService.writeLog(LogLevel.Error, `LED Farbwärme schalten ergab Fehler: ${err}`);
+        }
+      });
+    }
+
+    this.ioConn.setState(this.stateID, pValue, (err) => {
+      if (err) {
+        ServerLogService.writeLog(LogLevel.Error, `LED schalten ergab Fehler: ${err}`);
+      }
+    });
+
+    if (brightness > -1) {
+      this.ioConn.setState(this.brightnessID, brightness, (err) => {
+        if (err) {
+          ServerLogService.writeLog(LogLevel.Error, `LED Helligkeit schalten ergab Fehler: ${err}`);
+        }
+      });
+    }
+  }
+
+  public toggleLight(): boolean {
+    const newVal = !this.on;
+    this.setLight(newVal);
+    return newVal;
+  }
+}