hoffmation-base 0.1.10 → 0.1.14

package/.github/workflows/npm-publish.yml

@@ -31,20 +31,3 @@ jobs:
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}
-
-  publish-gpr:
-    needs: build
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: 14
-          registry-url: https://npm.pkg.github.com/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/models/{lampSettings.ts → actuatorSettings.ts}

@@ -1,4 +1,4 @@
-export class LampSettings {
+export class ActuatorSettings {
   public dawnOn: boolean = true;
   public duskOn: boolean = true;
   public nightOn: boolean = true;

package/models/rooms/RoomBase.ts

@@ -18,6 +18,7 @@ import { Persist } from '../../server/services/dbo/persist';
 import { TimeCallbackService, TimeOfDay } from '../../server/services/time-callback-service';
 import { SonosService } from '../../server/services/Sonos/sonos-service';
 import { SonosGroup } from '../../server/devices/groups/sonosGroup';
+import { ioBrokerBaseDevice } from '../../server/devices/iIoBrokerDevice';
 
 export class RoomBase {
   public static Rooms: { [name: string]: RoomBase } = {};
@@ -136,7 +137,7 @@ export class RoomBase {
     );
   }
 
-  public static startIntrusionAlarm(room: RoomBase, device: HmIPDevice): void {
+  public static startIntrusionAlarm(room: RoomBase, device: ioBrokerBaseDevice): void {
     const message: string = `!Potenzieller Eindringling! Bewegung in ${room.roomName} von ${device.info.fullName} festgestellt`;
     ServerLogService.writeLog(LogLevel.Info, message);
     if (!this.awayModeActive && !this.nightAlarmActive) {

package/models/timeCallback.ts

@@ -47,7 +47,7 @@ export class TimeCallback {
         let fixedSRDate: Date = new Date(TimeCallbackService.nextSunRise.getTime() + this.minuteOffset * 60 * 1000);
         if (this.sunTimeOffset) {
           const nextMinSR: Date = this.sunTimeOffset.getNextMinimumSunrise();
-          if (fixedSRDate.getDate() === nextMinSR.getDate()) {
+          if (nextMinSR > fixedSRDate && fixedSRDate.getDate() === nextMinSR.getDate()) {
             fixedSRDate = nextMinSR;
           }
         }
@@ -65,7 +65,7 @@ export class TimeCallback {
         let fixedSSDate: Date = new Date(TimeCallbackService.nextSunSet.getTime() + this.minuteOffset * 60 * 1000);
         if (this.sunTimeOffset) {
           const nextMaxSS: Date = this.sunTimeOffset.getNextMaximumSunset();
-          if (fixedSSDate.getDate() === nextMaxSS.getDate()) {
+          if (nextMaxSS < fixedSSDate && fixedSSDate.getDate() === nextMaxSS.getDate()) {
             fixedSSDate = nextMaxSS;
           }
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hoffmation-base",
   "description": "Base Libraries and functions for own Hoffmation projects",
-  "version": "0.1.10",
+  "version": "0.1.14",
   "main": "index.js",
   "repository": {
     "type": "git",

package/server/devices/devices.ts

@@ -28,6 +28,7 @@ import { ZigbeeBlitzShp } from './zigbee/zigbeeBlitzShp';
 import { ZigbeeIlluLampe } from './zigbee/zigbeeIlluLampe';
 import { ZigbeeIlluActuator } from './zigbee/zigbeeIlluActuator';
 import { iRoomImportEnforcer } from '../../models/rooms/iRoomImportEnforcer';
+import { ZigbeeAquaraMotion } from './zigbee/zigbeeAquaraMotion';
 
 export class Devices {
   public static hmIP: { [id: string]: HmIPDevice } = {};
@@ -106,6 +107,9 @@ export class Devices {
       case 'AquaraVibra':
         Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeAquaraVibra(zigbeeInfo);
         break;
+      case 'AquaraMotion':
+        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeAquaraMotion(zigbeeInfo);
+        break;
       case 'IkeaStecker':
         Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeIkeaSteckdose(zigbeeInfo);
         break;

package/server/devices/groups/praesenzGroup.ts

@@ -6,11 +6,16 @@ import { ServerLogService } from '../../services/log-service';
 import { LogLevel } from '../../../models/logLevel';
 import { TimeCallbackService } from '../../services/time-callback-service';
 import { Utils } from '../../services/utils/utils';
+import { ZigbeeAquaraMotion } from '../zigbee/zigbeeAquaraMotion';
 
 export class PraesenzGroup {
   private _lastMovement: Date = new Date(0);
 
-  public constructor(private _room: RoomBase, public Prasenzen: HmIpPraezenz[], public Bewegungen: HmIpBewegung[]) {
+  public constructor(
+    private _room: RoomBase,
+    public Prasenzen: HmIpPraezenz[],
+    public Bewegungen: HmIpBewegung[] | ZigbeeAquaraMotion[],
+  ) {
     for (const b of [...Prasenzen, ...Bewegungen]) {
       b.room = this._room;
     }

package/server/devices/hmIPDevices/hmIpBewegung.ts

@@ -15,7 +15,8 @@ export class HmIpBewegung extends HmIPDevice implements iIlluminationSensor {
   private _detectionsToday: number = 0;
   private _movementDetectedCallback: Array<(pValue: boolean) => void> = [];
   private static MOVEMENT_DETECTION: string = 'MOTION';
-  private static CURRENT_ILLUMINATION: string = 'CURRENT_ILLUMINATION';
+  private static ILLUMINATION_DURING_MOVEMENT: string = 'CURRENT_ILLUMINATION';
+  private static CURRENT_ILLUMINATION: string = 'ILLUMINATION';
   private initialized: boolean = false;
   private fallBackTimeout: NodeJS.Timeout | undefined;
   private _currentIllumination: number = -1;

package/server/devices/hmIPDevices/hmIpLampe.ts

@@ -3,7 +3,7 @@ import { HmIPDevice } from './hmIpDevice';
 import { HmIpDeviceType } from './hmIpDeviceType';
 import { DeviceInfo } from '../DeviceInfo';
 import { ServerLogService } from '../../services/log-service';
-import { LampSettings } from '../../../models/lampSettings';
+import { ActuatorSettings } from '../../../models/actuatorSettings';
 import { Utils } from '../../services/utils/utils';
 import { iLamp } from '../iLamp';
 
@@ -11,7 +11,7 @@ export class HmIpLampe extends HmIPDevice implements iLamp {
   public lightOn: boolean = false;
   public queuedLightValue: boolean | null = null;
   public isStromStoss: boolean = false;
-  public settings: LampSettings = new LampSettings();
+  public settings: ActuatorSettings = new ActuatorSettings();
   private lightOnSwitchID: string = '';
   private turnOffTimeout: NodeJS.Timeout | undefined = undefined;
   private turnOffTime: number = 0;

package/server/devices/hmIPDevices/hmIpPraezenz.ts

@@ -9,13 +9,14 @@ import { Utils } from '../../services/utils/utils';
 import { CurrentIlluminationDataPoint } from '../../../models/persistence/CurrentIlluminationDataPoint';
 import { iIlluminationSensor } from '../iIlluminationSensor';
 
-export class HmIpPraezenz extends HmIPDevice  implements iIlluminationSensor {
+export class HmIpPraezenz extends HmIPDevice implements iIlluminationSensor {
   public excludeFromNightAlarm: boolean = false;
   public presenceDetected: boolean = false;
   private _detectionsToday: number = 0;
   private _presenceDetectedCallback: Array<(pValue: boolean) => void> = [];
   private static PRESENCE_DETECTION: string = 'PRESENCE_DETECTION_STATE';
-  private static CURRENT_ILLUMINATION: string = 'CURRENT_ILLUMINATION';
+  private static ILLUMINATION_DURING_MOVEMENT: string = 'CURRENT_ILLUMINATION';
+  private static CURRENT_ILLUMINATION: string = 'ILLUMINATION';
   private presenceStateID: string;
   private initialized: boolean = false;
   private _currentIllumination: number = -1;

package/server/devices/iLamp.ts

@@ -1,8 +1,8 @@
 import { RoomBase } from '../../models/rooms/RoomBase';
-import { LampSettings } from '../../models/lampSettings';
+import { ActuatorSettings } from '../../models/actuatorSettings';
 
 export interface iLamp {
-  settings: LampSettings;
+  settings: ActuatorSettings;
   lightOn: boolean;
   room: RoomBase | undefined;
 

package/server/devices/zigbee/ZigbeeActuator.ts

@@ -4,10 +4,10 @@ import { DeviceInfo } from '../DeviceInfo';
 import { ZigbeeDeviceType } from './zigbeeDeviceType';
 import { ServerLogService } from '../../services/log-service';
 import { Utils } from '../../services/utils/utils';
-import { LampSettings } from '../../../models/lampSettings';
+import { ActuatorSettings as ActuatorSettings } from '../../../models/actuatorSettings';
 
 export class ZigbeeActuator extends ZigbeeDevice {
-  public settings: LampSettings = new LampSettings();
+  public settings: ActuatorSettings = new ActuatorSettings();
   protected readonly actuatorOnSwitchID: string;
   protected queuedValue: boolean | null = null;
   protected actuatorOn: boolean = false;

package/server/devices/zigbee/zigbeeAquaraMotion.ts

@@ -0,0 +1,205 @@
+import { LogLevel } from '../../../models/logLevel';
+import { ServerLogService } from '../../services/log-service';
+import { Persist } from '../../services/dbo/persist';
+import { Utils } from '../../services/utils/utils';
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { ZigbeeDeviceType } from './zigbeeDeviceType';
+import { iIlluminationSensor } from '../iIlluminationSensor';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+import { CurrentIlluminationDataPoint } from '../../../models/persistence/CurrentIlluminationDataPoint';
+import { CountToday } from '../../../models/persistence/todaysCount';
+
+export class ZigbeeAquaraMotion extends ZigbeeDevice implements iIlluminationSensor {
+  public movementDetected: boolean = false;
+  public excludeFromNightAlarm: boolean = false;
+  public room: RoomBase | undefined = undefined;
+
+  private _timeSinceLastMotion: number = 0;
+  private _illuminance: number = 0;
+  private _motionTimeout: number = 0;
+  private _detectionsToday: number = 0;
+
+  private _initialized: boolean = false;
+  private _movementDetectedCallback: Array<(pValue: boolean) => void> = [];
+  private _fallBackTimeout: NodeJS.Timeout | undefined;
+
+  private occupancyTimeoutID = `occupancy_timeout`;
+
+  // Currently measured brightness in lux
+  public get currentIllumination(): number {
+    return this._illuminance;
+  }
+
+  private set currentIllumination(value: number) {
+    this._illuminance = value;
+    Persist.persistCurrentIllumination(
+      new CurrentIlluminationDataPoint(
+        this.info.room,
+        this.info.devID,
+        value,
+        new Date(),
+        this.room?.LampenGroup.anyLightsOwn() ?? false,
+      ),
+    );
+  }
+
+  // Time since last motion in seconds
+  public get timeSinceLastMotion(): number {
+    return this._timeSinceLastMotion;
+  }
+
+  // Time after the last trigger until a motion event gets triggered again
+  public get motionTimeout(): number {
+    return this._motionTimeout;
+  }
+
+  public set motionTimeout(value: number) {
+    if (!this.ioConn) {
+      ServerLogService.writeLog(LogLevel.Error, `No connection active for "${this.info.customName}".`);
+      return;
+    }
+
+    this.ioConn.setState(this.occupancyTimeoutID, value, (err) => {
+      if (err) {
+        console.log(`Error occured while setting motion timeout: ${err}`);
+        return;
+      }
+      this._motionTimeout = value;
+    });
+  }
+
+  public get detectionsToday(): number {
+    return this._detectionsToday;
+  }
+
+  public set detectionsToday(pVal: number) {
+    const oldVal: number = this._detectionsToday;
+    this._detectionsToday = pVal;
+    Persist.persistTodayCount(this, pVal, oldVal);
+  }
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, ZigbeeDeviceType.ZigbeeAquaraMotion);
+
+    this.occupancyTimeoutID = `${this.info.fullID}.${this.occupancyTimeoutID}`;
+
+    Persist.getCount(this).then((todayCount: CountToday) => {
+      this.detectionsToday = todayCount.counter;
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Bewegungscounter "${this.info.customName}" vorinitialisiert mit ${this.detectionsToday}`,
+      );
+      this._initialized = true;
+    });
+  }
+
+  public addMovementCallback(pCallback: (pValue: boolean) => void): void {
+    this._movementDetectedCallback.push(pCallback);
+  }
+
+  public updateMovement(newState: boolean): void {
+    if (!this._initialized && newState) {
+      ServerLogService.writeLog(
+        LogLevel.Trace,
+        `Bewegung für "${this.info.customName}" erkannt aber die Initialisierung aus der DB ist noch nicht erfolgt --> verzögern`,
+      );
+      Utils.guardedTimeout(
+        () => {
+          this.updateMovement(newState);
+        },
+        1000,
+        this,
+      );
+      return;
+    }
+
+    if (newState === this.movementDetected) {
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Überspringe Bewegung für "${this.info.customName}" da bereits der Wert ${newState} vorliegt`,
+      );
+
+      if (newState) {
+        // Wenn ein Sensor sich nicht von alleine zurücksetzt, hier erzwingen.
+        this.resetFallbackTimeout();
+        this.startFallbackTimeout();
+      }
+      return;
+    }
+
+    this.resetFallbackTimeout();
+    this.movementDetected = newState;
+    ServerLogService.writeLog(LogLevel.Debug, `Neuer Bewegunsstatus Wert für "${this.info.customName}": ${newState}`);
+
+    if (newState) {
+      this.startFallbackTimeout();
+      this.detectionsToday++;
+      ServerLogService.writeLog(
+        LogLevel.Trace,
+        `Dies ist die ${this.detectionsToday} Bewegung für "${this.info.customName}"`,
+      );
+    }
+
+    for (const c of this._movementDetectedCallback) {
+      c(newState);
+    }
+  }
+
+  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 'occupancy':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Motion sensor: Update for motion state of ${this.info.customName}: ${state.val}`,
+        );
+        this.updateMovement(state.val as boolean);
+        break;
+      case 'no_motion':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Motion sensor: Update for time since last motion of ${this.info.customName}: ${state.val}`,
+        );
+        this._timeSinceLastMotion = state.val as number;
+        break;
+      case 'illumincance':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Motion sensor: Update for illuminance of ${this.info.customName}: ${state.val}`,
+        );
+        this.currentIllumination = state.val as number;
+        break;
+      case 'occupancy_timeout':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Motion sensor: Update for motion timeout of ${this.info.customName}: ${state.val}`,
+        );
+        this._illuminance = state.val as number;
+        break;
+    }
+  }
+
+  private resetFallbackTimeout(): void {
+    if (this._fallBackTimeout) {
+      ServerLogService.writeLog(LogLevel.Trace, `Fallback Timeout für "${this.info.customName}" zurücksetzen`);
+      clearTimeout(this._fallBackTimeout);
+    }
+  }
+
+  private startFallbackTimeout(): void {
+    this._fallBackTimeout = Utils.guardedTimeout(
+      () => {
+        ServerLogService.writeLog(LogLevel.Debug, `Benötige Fallback Bewegungs Reset für "${this.info.customName}"`);
+        this._fallBackTimeout = undefined;
+        this.updateMovement(false);
+      },
+      270000,
+      this,
+    );
+  }
+}

package/server/devices/zigbee/zigbeeBlitzShp.ts

@@ -3,14 +3,14 @@ import { ServerLogService } from '../../services/log-service';
 import { DeviceInfo } from '../DeviceInfo';
 import { ZigbeeDevice } from './zigbeeDevice';
 import { ZigbeeDeviceType } from './zigbeeDeviceType';
-import { LampSettings } from '../../../models/lampSettings';
+import { ActuatorSettings } from '../../../models/actuatorSettings';
 
 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();
+  public settings: ActuatorSettings = new ActuatorSettings();
   private steckerOnSwitchID: string = '';
 
   public constructor(pInfo: DeviceInfo) {

package/server/devices/zigbee/zigbeeDeviceType.ts

@@ -10,4 +10,5 @@ export enum ZigbeeDeviceType {
   ZigbeeBlitzShp = 8,
   ZigbeeIlluLampe = 9,
   ZigbeeIlluActuator = 10,
+  ZigbeeAquaraMotion = 11,
 }

package/server/services/dbo/persist.ts

@@ -11,6 +11,7 @@ import { RoomDetailInfo } from '../../../models/persistence/RoomDetailInfo';
 import { DailyMovementCount } from '../../../models/persistence/DailyMovementCount';
 import { iTemperaturDataPoint } from '../../../models/iTemperaturDataPoint';
 import { CurrentIlluminationDataPoint } from '../../../models/persistence/CurrentIlluminationDataPoint';
+import { ioBrokerBaseDevice } from '../../devices/iIoBrokerDevice';
 
 export const TemperatureHistoryCollection = new Mongo.Collection<TemperaturDataPoint>('TemperaturData');
 export const HeatGroupCollection = new Mongo.Collection<TemperaturDataPoint>('HeatGroupCollection');
@@ -56,7 +57,7 @@ export class Persist {
     });
   }
 
-  public static async getCount(device: HmIPDevice): Promise<CountToday> {
+  public static async getCount(device: ioBrokerBaseDevice): Promise<CountToday> {
     const result = new Promise<CountToday>((resolve) => {
       this.MeteorBound(() => {
         const options = {
@@ -81,7 +82,7 @@ export class Persist {
     return result;
   }
 
-  public static persistTodayCount(device: HmIPDevice, count: number, oldCount: number): void {
+  public static persistTodayCount(device: ioBrokerBaseDevice, count: number, oldCount: number): void {
     this.MeteorBound(() => {
       const result = CountTodayCollection.update(
         { deviceID: device.info.fullID },