hoffmation-base 0.1.39 → 0.1.41-3

package/lib/models/deviceSettings/actuatorSettings.d.ts

@@ -3,4 +3,15 @@ export declare class ActuatorSettings extends DeviceSettings {
     dawnOn: boolean;
     duskOn: boolean;
     nightOn: boolean;
+    /**
+     * Indicates if this device controls e.g. an Eltako, which has it's own Turn Off Time logic.
+     * @type {boolean}
+     */
+    isStromStoss: boolean;
+    /**
+     * If this is an Actuator controling a time based relais,
+     * this indicates the time after which we retrigger the relais.
+     * @type {number}
+     */
+    stromStossResendTime: number;
 }

package/lib/models/deviceSettings/actuatorSettings.js

@@ -8,6 +8,17 @@ class ActuatorSettings extends deviceSettings_1.DeviceSettings {
         this.dawnOn = true;
         this.duskOn = true;
         this.nightOn = true;
+        /**
+         * Indicates if this device controls e.g. an Eltako, which has it's own Turn Off Time logic.
+         * @type {boolean}
+         */
+        this.isStromStoss = false;
+        /**
+         * If this is an Actuator controling a time based relais,
+         * this indicates the time after which we retrigger the relais.
+         * @type {number}
+         */
+        this.stromStossResendTime = 180;
     }
 }
 exports.ActuatorSettings = ActuatorSettings;

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

@@ -1,6 +1,6 @@
-import { deviceConfig } from '../../models/deviceConfig';
+import { deviceConfig } from '../../models';
 import { IoBrokerBaseDevice } from './IoBrokerBaseDevice';
-import { iRoomImportEnforcer } from '../../models/rooms/iRoomImportEnforcer';
+import { iRoomImportEnforcer } from '../../models';
 import { iEnergyManager } from './iEnergyManager';
 export declare class Devices {
     static IDENTIFIER_HOMEMATIC: string;
@@ -15,8 +15,8 @@ export declare class Devices {
     }, pRoomImportEnforcer?: iRoomImportEnforcer);
     static midnightReset(): void;
     static resetPraesenzCount(): void;
-    private processZigbeeDevice;
-    private processHMIPDevice;
+    private static processZigbeeDevice;
+    private static processHMIPDevice;
     static getBatteryInfo(): string;
-    private createEnergyManager;
+    private static createEnergyManager;
 }

package/lib/server/devices/devices.js

@@ -1,46 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Devices = void 0;
-const hmIpDevice_1 = require("./hmIPDevices/hmIpDevice");
-const zigbeeDevice_1 = require("./zigbee/zigbeeDevice");
+const hmIPDevices_1 = require("./hmIPDevices");
+const zigbee_1 = require("./zigbee");
 const deviceType_1 = require("./deviceType");
-const hmIpPraezenz_1 = require("./hmIPDevices/hmIpPraezenz");
-const log_service_1 = require("../services/log-service/log-service");
+const hmIPDevices_2 = require("./hmIPDevices");
+const services_1 = require("../services");
 const DeviceInfo_1 = require("./DeviceInfo");
-const logLevel_1 = require("../../models/logLevel");
-const hmIpBewegung_1 = require("./hmIPDevices/hmIpBewegung");
-const zigbeeAquaraVibra_1 = require("./zigbee/zigbeeAquaraVibra");
-const zigbeeAquaraMotion_1 = require("./zigbee/zigbeeAquaraMotion");
-const zigbeeIkeaSteckdose_1 = require("./zigbee/zigbeeIkeaSteckdose");
-const zigbeeIlluLedRGBCCT_1 = require("./zigbee/zigbeeIlluLedRGBCCT");
-const zigbeeIlluDimmer_1 = require("./zigbee/zigbeeIlluDimmer");
-const zigbeeHeimanSmoke_1 = require("./zigbee/zigbeeHeimanSmoke");
-const zigbeeAquaraWater_1 = require("./zigbee/zigbeeAquaraWater");
-const zigbeeBlitzShp_1 = require("./zigbee/zigbeeBlitzShp");
-const zigbeeIlluLampe_1 = require("./zigbee/zigbeeIlluLampe");
-const zigbeeIlluActuator_1 = require("./zigbee/zigbeeIlluActuator");
-const hmIpLampe_1 = require("./hmIPDevices/hmIpLampe");
-const hmIpRoll_1 = require("./hmIPDevices/hmIpRoll");
-const hmIpTaster_1 = require("./hmIPDevices/hmIpTaster");
-const hmIpWippe_1 = require("./hmIPDevices/hmIpWippe");
-const hmIpGriff_1 = require("./hmIPDevices/hmIpGriff");
-const hmIpTherm_1 = require("./hmIPDevices/hmIpTherm");
-const hmIpHeizung_1 = require("./hmIPDevices/hmIpHeizung");
-const hmIpTuer_1 = require("./hmIPDevices/hmIpTuer");
-const hmIpHeizgruppe_1 = require("./hmIPDevices/hmIpHeizgruppe");
-const zigbeeIlluShutter_1 = require("./zigbee/zigbeeIlluShutter");
-const zigbeeSMaBiTMagnetContact_1 = require("./zigbee/zigbeeSMaBiTMagnetContact");
-const zigbeeSonoffMotion_1 = require("./zigbee/zigbeeSonoffMotion");
-const hmIpAccessPoint_1 = require("./hmIPDevices/hmIpAccessPoint");
-const zigbeeAqaraMagnetContact_1 = require("./zigbee/zigbeeAqaraMagnetContact");
-const zigbeeSonoffTemp_1 = require("./zigbee/zigbeeSonoffTemp");
-const zigbeeAqaraOpple3Switch_1 = require("./zigbee/zigbeeAqaraOpple3Switch");
-const jsObjectEnergyManager_1 = require("./jsObject/jsObjectEnergyManager");
+const models_1 = require("../../models");
+const hmIPDevices_3 = require("./hmIPDevices");
+const zigbee_2 = require("./zigbee");
+const zigbee_3 = require("./zigbee");
+const zigbee_4 = require("./zigbee");
+const zigbee_5 = require("./zigbee");
+const zigbee_6 = require("./zigbee");
+const zigbee_7 = require("./zigbee");
+const zigbee_8 = require("./zigbee");
+const zigbee_9 = require("./zigbee");
+const zigbee_10 = require("./zigbee");
+const zigbee_11 = require("./zigbee");
+const hmIPDevices_4 = require("./hmIPDevices");
+const hmIPDevices_5 = require("./hmIPDevices");
+const hmIPDevices_6 = require("./hmIPDevices");
+const hmIPDevices_7 = require("./hmIPDevices");
+const hmIPDevices_8 = require("./hmIPDevices");
+const hmIPDevices_9 = require("./hmIPDevices");
+const hmIPDevices_10 = require("./hmIPDevices");
+const hmIPDevices_11 = require("./hmIPDevices");
+const hmIPDevices_12 = require("./hmIPDevices");
+const zigbee_12 = require("./zigbee");
+const zigbee_13 = require("./zigbee");
+const zigbee_14 = require("./zigbee");
+const hmIPDevices_13 = require("./hmIPDevices");
+const zigbee_15 = require("./zigbee");
+const zigbee_16 = require("./zigbee");
+const zigbee_17 = require("./zigbee");
+const jsObject_1 = require("./jsObject");
 class Devices {
     constructor(pDeviceData, pRoomImportEnforcer) {
         // This forces import of rooms at correct timing, to allow devices to land in proper rooms.
         pRoomImportEnforcer === null || pRoomImportEnforcer === void 0 ? void 0 : pRoomImportEnforcer.addRoomConstructor();
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Constructing devices now`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Constructing devices now`);
         for (const cID in pDeviceData) {
             const cDevConf = pDeviceData[cID];
             if (!cDevConf.common ||
@@ -52,159 +52,159 @@ class Devices {
             }
             const cName = cDevConf.common.name;
             if (cName.indexOf('00-HmIP') === 0) {
-                this.processHMIPDevice(cDevConf);
+                Devices.processHMIPDevice(cDevConf);
             }
             else if (cName.indexOf('00-Zigbee') === 0) {
-                this.processZigbeeDevice(cDevConf);
+                Devices.processZigbeeDevice(cDevConf);
             }
             else if (cName.indexOf('00-EnergyManager') === 0) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Found Energy-Manager in Device json.`);
-                this.createEnergyManager(cDevConf);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Found Energy-Manager in Device json.`);
+                Devices.createEnergyManager(cDevConf);
             }
         }
-        hmIpDevice_1.HmIPDevice.checkMissing();
-        zigbeeDevice_1.ZigbeeDevice.checkMissing();
+        hmIPDevices_1.HmIPDevice.checkMissing();
+        zigbee_1.ZigbeeDevice.checkMissing();
     }
     static midnightReset() {
         // Nothing yet
     }
     static resetPraesenzCount() {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `3 Uhr Reset der Präsenzmelder`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `3 Uhr Reset der Präsenzmelder`);
         for (const dID in Devices.alLDevices) {
             const d = Devices.alLDevices[dID];
             if (d.deviceType === deviceType_1.DeviceType.HmIpPraezenz) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
                 d.detectionsToday = 0;
             }
             else if (d.deviceType === deviceType_1.DeviceType.HmIpBewegung) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
                 d.detectionsToday = 0;
             }
             else if (d.deviceType === deviceType_1.DeviceType.ZigbeeSonoffMotion || d.deviceType === deviceType_1.DeviceType.ZigbeeAquaraMotion) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
                 d.detectionsToday = 0;
             }
         }
     }
-    processZigbeeDevice(cDevConf) {
+    static processZigbeeDevice(cDevConf) {
         const zigbeeInfo = new DeviceInfo_1.DeviceInfo(cDevConf);
         const fullName = `${Devices.IDENTIFIER_ZIGBEE}-${zigbeeInfo.devID}`;
         zigbeeInfo.allDevicesKey = fullName;
         if (typeof Devices.alLDevices[fullName] !== 'undefined') {
             return;
         }
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `${zigbeeInfo.devID} with Type "${zigbeeInfo.deviceType}" doesn't exists --> create it`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `${zigbeeInfo.devID} with Type "${zigbeeInfo.deviceType}" doesn't exists --> create it`);
         let d;
         switch (zigbeeInfo.deviceType) {
             case 'AqaraMagnetContact':
-                d = new zigbeeAqaraMagnetContact_1.ZigbeeAqaraMagnetContact(zigbeeInfo);
+                d = new zigbee_15.ZigbeeAqaraMagnetContact(zigbeeInfo);
                 break;
             case 'AqaraOpple3Switch':
-                d = new zigbeeAqaraOpple3Switch_1.ZigbeeAqaraOpple3Switch(zigbeeInfo);
+                d = new zigbee_17.ZigbeeAqaraOpple3Switch(zigbeeInfo);
                 break;
             case 'AquaraMotion':
-                d = new zigbeeAquaraMotion_1.ZigbeeAquaraMotion(zigbeeInfo);
+                d = new zigbee_3.ZigbeeAquaraMotion(zigbeeInfo);
                 break;
             case 'AquaraVibra':
-                d = new zigbeeAquaraVibra_1.ZigbeeAquaraVibra(zigbeeInfo);
+                d = new zigbee_2.ZigbeeAquaraVibra(zigbeeInfo);
                 break;
             case 'AquaraWater':
-                d = new zigbeeAquaraWater_1.ZigbeeAquaraWater(zigbeeInfo);
+                d = new zigbee_8.ZigbeeAquaraWater(zigbeeInfo);
                 break;
             case 'BlitzShp':
-                d = new zigbeeBlitzShp_1.ZigbeeBlitzShp(zigbeeInfo);
+                d = new zigbee_9.ZigbeeBlitzShp(zigbeeInfo);
                 break;
             case 'HeimanSmoke':
-                d = new zigbeeHeimanSmoke_1.ZigbeeHeimanSmoke(zigbeeInfo);
+                d = new zigbee_7.ZigbeeHeimanSmoke(zigbeeInfo);
                 break;
             case 'IkeaStecker':
-                d = new zigbeeIkeaSteckdose_1.ZigbeeIkeaSteckdose(zigbeeInfo);
+                d = new zigbee_4.ZigbeeIkeaSteckdose(zigbeeInfo);
                 break;
             case 'IlluActuator':
-                d = new zigbeeIlluActuator_1.ZigbeeIlluActuator(zigbeeInfo);
+                d = new zigbee_11.ZigbeeIlluActuator(zigbeeInfo);
                 break;
             case 'IlluDimmer':
-                d = new zigbeeIlluDimmer_1.ZigbeeIlluDimmer(zigbeeInfo);
+                d = new zigbee_6.ZigbeeIlluDimmer(zigbeeInfo);
                 break;
             case 'IlluLampe':
-                d = new zigbeeIlluLampe_1.ZigbeeIlluLampe(zigbeeInfo);
+                d = new zigbee_10.ZigbeeIlluLampe(zigbeeInfo);
                 break;
             case 'IlluShutter':
-                d = new zigbeeIlluShutter_1.ZigbeeIlluShutter(zigbeeInfo);
+                d = new zigbee_12.ZigbeeIlluShutter(zigbeeInfo);
                 break;
             case 'LedRGBCCT':
-                d = new zigbeeIlluLedRGBCCT_1.ZigbeeIlluLedRGBCCT(zigbeeInfo);
+                d = new zigbee_5.ZigbeeIlluLedRGBCCT(zigbeeInfo);
                 break;
             case 'SMaBiTMagnet':
-                d = new zigbeeSMaBiTMagnetContact_1.ZigbeeSMaBiTMagnetContact(zigbeeInfo);
+                d = new zigbee_13.ZigbeeSMaBiTMagnetContact(zigbeeInfo);
                 break;
             case 'SonoffMotion':
-                d = new zigbeeSonoffMotion_1.ZigbeeSonoffMotion(zigbeeInfo);
+                d = new zigbee_14.ZigbeeSonoffMotion(zigbeeInfo);
                 break;
             case 'SonoffTemp':
-                d = new zigbeeSonoffTemp_1.ZigbeeSonoffTemp(zigbeeInfo);
+                d = new zigbee_16.ZigbeeSonoffTemp(zigbeeInfo);
                 break;
             default:
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `No zigbee Device Type for ${zigbeeInfo.deviceType} defined`);
-                d = new zigbeeDevice_1.ZigbeeDevice(zigbeeInfo, deviceType_1.DeviceType.unknown);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `No zigbee Device Type for ${zigbeeInfo.deviceType} defined`);
+                d = new zigbee_1.ZigbeeDevice(zigbeeInfo, deviceType_1.DeviceType.unknown);
         }
         Devices.alLDevices[fullName] = d;
     }
-    processHMIPDevice(cDevConf) {
+    static processHMIPDevice(cDevConf) {
         const hmIPInfo = new DeviceInfo_1.DeviceInfo(cDevConf);
         const fullName = `${Devices.IDENTIFIER_HOMEMATIC}-${hmIPInfo.devID}`;
         hmIPInfo.allDevicesKey = fullName;
         if (typeof Devices.alLDevices[fullName] !== 'undefined') {
             return;
         }
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `${hmIPInfo.devID} with Type "${hmIPInfo.deviceType}" doesn't exists --> create it`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `${hmIPInfo.devID} with Type "${hmIPInfo.deviceType}" doesn't exists --> create it`);
         let d;
         switch (hmIPInfo.deviceType) {
             case 'Lampe':
-                d = new hmIpLampe_1.HmIpLampe(hmIPInfo);
+                d = new hmIPDevices_4.HmIpLampe(hmIPInfo);
                 break;
             case 'Roll':
             case 'Broll':
-                d = new hmIpRoll_1.HmIpRoll(hmIPInfo);
+                d = new hmIPDevices_5.HmIpRoll(hmIPInfo);
                 break;
             case 'Beweg':
-                d = new hmIpBewegung_1.HmIpBewegung(hmIPInfo);
+                d = new hmIPDevices_3.HmIpBewegung(hmIPInfo);
                 break;
             case 'Taster':
-                d = new hmIpTaster_1.HmIpTaster(hmIPInfo);
+                d = new hmIPDevices_6.HmIpTaster(hmIPInfo);
                 break;
             case 'Wippe':
-                d = new hmIpWippe_1.HmIpWippe(hmIPInfo);
+                d = new hmIPDevices_7.HmIpWippe(hmIPInfo);
                 break;
             case 'Praezenz':
-                d = new hmIpPraezenz_1.HmIpPraezenz(hmIPInfo);
+                d = new hmIPDevices_2.HmIpPraezenz(hmIPInfo);
                 break;
             case 'Griff':
-                d = new hmIpGriff_1.HmIpGriff(hmIPInfo);
+                d = new hmIPDevices_8.HmIpGriff(hmIPInfo);
                 break;
             case 'Thermostat':
-                d = new hmIpTherm_1.HmIpTherm(hmIPInfo);
+                d = new hmIPDevices_9.HmIpTherm(hmIPInfo);
                 break;
             case 'Heizung':
-                d = new hmIpHeizung_1.HmIpHeizung(hmIPInfo);
+                d = new hmIPDevices_10.HmIpHeizung(hmIPInfo);
                 break;
             case 'Tuer':
-                d = new hmIpTuer_1.HmIpTuer(hmIPInfo);
+                d = new hmIPDevices_11.HmIpTuer(hmIPInfo);
                 break;
             case 'HeizGr':
-                d = new hmIpHeizgruppe_1.HmIpHeizgruppe(hmIPInfo);
+                d = new hmIPDevices_12.HmIpHeizgruppe(hmIPInfo);
                 break;
             case 'AccessPoint':
-                d = new hmIpAccessPoint_1.HmIpAccessPoint(hmIPInfo);
+                d = new hmIPDevices_13.HmIpAccessPoint(hmIPInfo);
                 break;
             default:
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `No HmIP Device Type for ${hmIPInfo.deviceType} defined`);
-                d = new hmIpDevice_1.HmIPDevice(hmIPInfo, deviceType_1.DeviceType.unknown);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `No HmIP Device Type for ${hmIPInfo.deviceType} defined`);
+                d = new hmIPDevices_1.HmIPDevice(hmIPInfo, deviceType_1.DeviceType.unknown);
         }
         Devices.alLDevices[fullName] = d;
     }
     static getBatteryInfo() {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Getting Battery Info`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Getting Battery Info`);
         let data = [];
         const result = [
             `These are the battery values for each device. Device dependandt some are in volts, some in %`,
@@ -223,11 +223,11 @@ class Devices {
         }
         return result.join('\n');
     }
-    createEnergyManager(cDevConf) {
+    static createEnergyManager(cDevConf) {
         const devInfo = new DeviceInfo_1.DeviceInfo(cDevConf, true);
         const fullName = `${Devices.IDENTIFIER_JS}-${devInfo.devID}`;
         devInfo.allDevicesKey = fullName;
-        Devices.energymanager = new jsObjectEnergyManager_1.JsObjectEnergyManager(devInfo);
+        Devices.energymanager = new jsObject_1.JsObjectEnergyManager(devInfo);
         Devices.alLDevices[fullName] = Devices.energymanager;
     }
 }

package/lib/server/devices/groups/lampenGroup.d.ts

@@ -1,6 +1,6 @@
-import { ZigbeeIkeaSteckdose } from '../zigbee/zigbeeIkeaSteckdose';
-import { TimeOfDay } from '../../services/time-callback-service';
-import { ZigbeeIlluLedRGBCCT } from '../zigbee/zigbeeIlluLedRGBCCT';
+import { ZigbeeIkeaSteckdose } from '../zigbee';
+import { TimeOfDay } from '../../services';
+import { ZigbeeIlluLedRGBCCT } from '../zigbee';
 import { BaseGroup } from './base-group';
 import { iLamp } from '../iLamp';
 export declare class LampenGroup extends BaseGroup {

package/lib/server/devices/groups/lampenGroup.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LampenGroup = void 0;
-const time_callback_service_1 = require("../../services/time-callback-service");
+const services_1 = require("../../services");
 const base_group_1 = require("./base-group");
 const group_type_1 = require("./group-type");
 const device_cluster_type_1 = require("../device-cluster-type");
 const device_list_1 = require("../device-list");
-const logLevel_1 = require("../../../models/logLevel");
+const models_1 = require("../../../models");
 class LampenGroup extends base_group_1.BaseGroup {
     constructor(roomName, lampenIds = [], steckerIds = [], ledIds = []) {
         super(roomName, group_type_1.GroupType.Light);
@@ -50,21 +50,21 @@ class LampenGroup extends base_group_1.BaseGroup {
         });
     }
     switchTimeConditional(time) {
-        const darkOutside = time_callback_service_1.TimeCallbackService.darkOutsideOrNight(time);
+        const darkOutside = services_1.TimeCallbackService.darkOutsideOrNight(time);
         let resultLampen = false;
         let resultSteckdosen = false;
         if (this.getLED().length > 0) {
-            this.log(logLevel_1.LogLevel.Trace, `Set LEDs time based for time "${time_callback_service_1.TimeOfDay[time]}"`);
+            this.log(models_1.LogLevel.Trace, `Set LEDs time based for time "${services_1.TimeOfDay[time]}"`);
             this.getLED().forEach((s) => {
                 s.setTimeBased(time);
             });
         }
         else if (this.getStecker().length > 0) {
-            this.log(logLevel_1.LogLevel.Trace, `Set outlets time based for time "${time_callback_service_1.TimeOfDay[time]}"`);
+            this.log(models_1.LogLevel.Trace, `Set outlets time based for time "${services_1.TimeOfDay[time]}"`);
             resultSteckdosen = darkOutside;
         }
         else {
-            this.log(logLevel_1.LogLevel.Trace, `Set Lamps time based for time "${time_callback_service_1.TimeOfDay[time]}"`);
+            this.log(models_1.LogLevel.Trace, `Set Lamps time based for time "${services_1.TimeOfDay[time]}"`);
             resultLampen = darkOutside;
         }
         this.setAllLampen(resultLampen, time);
@@ -74,12 +74,12 @@ class LampenGroup extends base_group_1.BaseGroup {
         this.getLampen().forEach((s) => {
             if (!pValue ||
                 time === undefined ||
-                (time === time_callback_service_1.TimeOfDay.Night && s.settings.nightOn) ||
-                (time === time_callback_service_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
-                (time === time_callback_service_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
+                (time === services_1.TimeOfDay.Night && s.settings.nightOn) ||
+                (time === services_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
+                (time === services_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
                 const timeout = pValue && force ? 30 * 60 * 1000 : -1;
                 if (pValue && time !== undefined) {
-                    s.setTimeBased(time);
+                    s.setTimeBased(time, timeout, force);
                 }
                 else {
                     s.setLight(pValue, timeout, force);
@@ -91,9 +91,9 @@ class LampenGroup extends base_group_1.BaseGroup {
         this.getStecker().forEach((s) => {
             if (!pValue ||
                 time === undefined ||
-                (time === time_callback_service_1.TimeOfDay.Night && s.settings.nightOn) ||
-                (time === time_callback_service_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
-                (time === time_callback_service_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
+                (time === services_1.TimeOfDay.Night && s.settings.nightOn) ||
+                (time === services_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
+                (time === services_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
                 const timeout = pValue && force ? 30 * 60 * 1000 : -1;
                 s.setStecker(pValue, timeout, force);
             }

package/lib/server/devices/hmIPDevices/hmIpLampe.d.ts

@@ -1,29 +1,20 @@
 /// <reference types="iobroker" />
 import { HmIPDevice } from './hmIpDevice';
-import { ActuatorSettings } from '../../../models/deviceSettings/actuatorSettings';
+import { ActuatorSettings } from '../../../models';
 import { DeviceInfo } from '../DeviceInfo';
 import { iLamp } from '../iLamp';
-import { TimeOfDay } from '../../services/time-callback-service';
+import { TimeOfDay } from '../../services';
 export declare class HmIpLampe extends HmIPDevice implements iLamp {
     lightOn: boolean;
     queuedLightValue: boolean | null;
-    isStromStoss: boolean;
     settings: ActuatorSettings;
     private lightOnSwitchID;
     private _turnOffTimeout;
     private turnOffTime;
     constructor(pInfo: DeviceInfo);
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    /**
-     * This function thats the light to a specific value
-     * @param pValue The desired value
-     * @param timeout A chosen Timeout after which the light should be reset
-     */
+    /** @inheritdoc */
     setLight(pValue: boolean, timeout?: number, force?: boolean): void;
-    /**
-     * Switch the current condition of the light
-     * @param force Whether this is a forcing action skipping delays and locks
-     */
-    toggleLight(force?: boolean): boolean;
-    setTimeBased(time: TimeOfDay): void;
+    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
 }

package/lib/server/devices/hmIPDevices/hmIpLampe.js

@@ -3,24 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HmIpLampe = void 0;
 const hmIpDevice_1 = require("./hmIpDevice");
 const deviceType_1 = require("../deviceType");
-const utils_1 = require("../../services/utils/utils");
-const actuatorSettings_1 = require("../../../models/deviceSettings/actuatorSettings");
-const logLevel_1 = require("../../../models/logLevel");
-const time_callback_service_1 = require("../../services/time-callback-service");
+const services_1 = require("../../services");
+const models_1 = require("../../../models");
+const models_2 = require("../../../models");
+const services_2 = require("../../services");
 class HmIpLampe extends hmIpDevice_1.HmIPDevice {
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.HmIpLampe);
         this.lightOn = false;
         this.queuedLightValue = null;
-        this.isStromStoss = false;
-        this.settings = new actuatorSettings_1.ActuatorSettings();
+        this.settings = new models_1.ActuatorSettings();
         this.lightOnSwitchID = '';
         this._turnOffTimeout = undefined;
         this.turnOffTime = 0;
         this.lightOnSwitchID = `${this.info.fullID}.2.STATE`;
     }
     update(idSplit, state, initial = false) {
-        this.log(logLevel_1.LogLevel.DeepTrace, `Lampen Update : ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        this.log(models_2.LogLevel.DeepTrace, `Lampen Update : ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         super.update(idSplit, state, initial, true);
         this.queuedLightValue = null;
         switch (idSplit[3]) {
@@ -31,31 +30,33 @@ class HmIpLampe extends hmIpDevice_1.HmIPDevice {
                 break;
         }
     }
-    /**
-     * This function thats the light to a specific value
-     * @param pValue The desired value
-     * @param timeout A chosen Timeout after which the light should be reset
-     */
+    /** @inheritdoc */
     setLight(pValue, timeout = -1, force = false) {
         if (!force && pValue === this.lightOn && this.queuedLightValue === null) {
-            this.log(logLevel_1.LogLevel.DeepTrace, `Skip light command as it is already ${pValue}`);
+            this.log(models_2.LogLevel.DeepTrace, `Skip light command as it is already ${pValue}`);
             return;
         }
         if (this.lightOnSwitchID === '') {
-            this.log(logLevel_1.LogLevel.Error, `Keine Switch ID bekannt.`);
+            this.log(models_2.LogLevel.Error, `Keine Switch ID bekannt.`);
             return;
         }
-        if (!force && utils_1.Utils.nowMS() < this.turnOffTime) {
-            this.log(logLevel_1.LogLevel.Debug, `Skip automatic command to ${pValue} as it is locked until ${new Date(this.turnOffTime).toLocaleString()}`);
+        if (!force && services_1.Utils.nowMS() < this.turnOffTime) {
+            this.log(models_2.LogLevel.Debug, `Skip automatic command to ${pValue} as it is locked until ${new Date(this.turnOffTime).toLocaleString()}`);
             return;
         }
-        this.log(logLevel_1.LogLevel.Debug, `Lampe schalten Wert: ${pValue}`);
+        this.log(models_2.LogLevel.Debug, `Lampe schalten Wert: ${pValue}`);
         this.setState(this.lightOnSwitchID, pValue, undefined, (err) => {
-            this.log(logLevel_1.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
+            this.log(models_2.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
         });
         this.queuedLightValue = pValue;
-        if (this.isStromStoss) {
-            timeout = 5000;
+        if (this.settings.isStromStoss) {
+            timeout = 3000;
+            services_1.Utils.guardedTimeout(() => {
+                var _a;
+                if (this.room && ((_a = this.room.PraesenzGroup) === null || _a === void 0 ? void 0 : _a.anyPresent())) {
+                    this.setLight(true, -1, true);
+                }
+            }, this.settings.stromStossResendTime * 1000, this);
         }
         if (this._turnOffTimeout !== undefined) {
             clearTimeout(this._turnOffTimeout);
@@ -64,9 +65,9 @@ class HmIpLampe extends hmIpDevice_1.HmIPDevice {
         if (timeout < 0 || !pValue) {
             return;
         }
-        this.turnOffTime = utils_1.Utils.nowMS() + timeout;
-        this._turnOffTimeout = utils_1.Utils.guardedTimeout(() => {
-            this.log(logLevel_1.LogLevel.Debug, `Delayed Turnoff initiated`);
+        this.turnOffTime = services_1.Utils.nowMS() + timeout;
+        this._turnOffTimeout = services_1.Utils.guardedTimeout(() => {
+            this.log(models_2.LogLevel.Debug, `Delayed Turnoff initiated`);
             this._turnOffTimeout = undefined;
             if (!this.room) {
                 this.setLight(false, -1, true);
@@ -76,21 +77,25 @@ class HmIpLampe extends hmIpDevice_1.HmIPDevice {
             }
         }, timeout, this);
     }
-    /**
-     * Switch the current condition of the light
-     * @param force Whether this is a forcing action skipping delays and locks
-     */
-    toggleLight(force = false) {
+    toggleLight(time, force = false, calculateTime = false) {
+        var _a;
         const newVal = this.queuedLightValue !== null ? !this.queuedLightValue : !this.lightOn;
         const timeout = newVal && force ? 30 * 60 * 1000 : -1;
+        if (newVal && time === undefined && calculateTime && this.room !== undefined) {
+            time = services_2.TimeCallbackService.dayType((_a = this.room) === null || _a === void 0 ? void 0 : _a.settings.lampOffset);
+        }
+        if (newVal && time !== undefined) {
+            this.setTimeBased(time, timeout, force);
+            return true;
+        }
         this.setLight(newVal, timeout, force);
         return newVal;
     }
-    setTimeBased(time) {
-        if ((time === time_callback_service_1.TimeOfDay.Night && this.settings.nightOn) ||
-            (time === time_callback_service_1.TimeOfDay.BeforeSunrise && this.settings.dawnOn) ||
-            (time === time_callback_service_1.TimeOfDay.AfterSunset && this.settings.duskOn)) {
-            this.setLight(true);
+    setTimeBased(time, timeout = -1, force = false) {
+        if ((time === services_2.TimeOfDay.Night && this.settings.nightOn) ||
+            (time === services_2.TimeOfDay.BeforeSunrise && this.settings.dawnOn) ||
+            (time === services_2.TimeOfDay.AfterSunset && this.settings.duskOn)) {
+            this.setLight(true, timeout, force);
         }
     }
 }

package/lib/server/devices/iEnergyManager.d.ts

@@ -1,11 +1,30 @@
 import { IoBrokerBaseDevice } from './IoBrokerBaseDevice';
 import { iExcessEnergyConsumer } from './iExcessEnergyConsumer';
+export declare class PhaseState {
+    private readonly _meterValue;
+    private readonly _production;
+    get selfConsumingWattage(): number;
+    get drawingWattage(): number;
+    get injectingWattage(): number;
+    get totalConsumptionWattage(): number;
+    private readonly _injectingWattage;
+    private readonly _drawingWattage;
+    private readonly _selfConsumingWattage;
+    private readonly _totalConsumption;
+    constructor(_meterValue: number, _production: number);
+}
 export interface iEnergyManager extends IoBrokerBaseDevice {
     baseConsumption: number;
     currentProduction: number;
     excessEnergy: number;
     excessEnergyConsumerConsumption: number;
     totalConsumption: number;
+    drawingWattage: number;
+    selfConsumingWattage: number;
+    injectingWattage: number;
+    phaseAState: PhaseState;
+    phaseBState: PhaseState;
+    phaseCState: PhaseState;
     addExcessConsumer(device: iExcessEnergyConsumer): void;
     recalculatePowerSharing(): void;
     cleanup(): void;