hoffmation-base 0.1.14 → 0.1.18

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIPDevice = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const iIoBrokerDevice_1 = require("../iIoBrokerDevice");
+class HmIPDevice extends iIoBrokerDevice_1.ioBrokerBaseDevice {
+    constructor(pInfo, pType) {
+        super(pInfo);
+        this.lowBattery = false;
+        this.room = undefined;
+        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 HmIpRoomsettings 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 = HmIPDevice.roomSettings[this.info.room];
+        if (settings !== undefined) {
+            if (settings.devices[this.deviceType] === undefined) {
+                log_service_1.ServerLogService.missingRoomHandling(settings.RoomName, this.deviceType);
+                return;
+            }
+            const deviceSettings = settings.devices[this.deviceType][this.info.deviceRoomIndex];
+            if (deviceSettings === undefined) {
+                log_service_1.ServerLogService.missingRoomIndexHandling(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.addedDeviceToRoom(settings.RoomName, this.deviceType, this.info.deviceRoomIndex);
+            return;
+        }
+        switch (this.info.room) {
+            default:
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `${this.info.room} is noch kein bekannter Raum`);
+        }
+    }
+    update(idSplit, state, initial = false, pOverride = false) {
+        if (!pOverride) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Keine Update Überschreibung für "${this.info.customName}":\n\tID: ${idSplit.join('.')}\n\tData: ${JSON.stringify(state)}`);
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Base-Device Update for ${this.info.customName}("${idSplit.join('.')}", ${state}, ${initial}, ${pOverride})`);
+        if (idSplit[3] !== '0') {
+            // Dies ist etwas Gerätespezifisches
+            return;
+        }
+        switch (idSplit[4]) {
+            case 'LOW_BAT':
+                const newBatLowVal = state.val;
+                if (newBatLowVal) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `!!BATTERIE FAST LEER!! "${this.info.customName}"`);
+                }
+                break;
+        }
+    }
+}
+exports.HmIPDevice = HmIPDevice;
+HmIPDevice.roomSettings = {};

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

@@ -0,0 +1,14 @@
+export declare enum HmIpDeviceType {
+    unknown = 0,
+    HmIpLampe = 1,
+    HmIpTaster = 2,
+    HmIpRoll = 3,
+    HmIpTherm = 4,
+    HmIpPraezenz = 5,
+    HmIpGriff = 6,
+    HmIpWippe = 7,
+    HmIpHeizung = 8,
+    HmIpTuer = 9,
+    HmIpHeizgruppe = 10,
+    HmIpBewegung = 11
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpDeviceType = void 0;
+var HmIpDeviceType;
+(function (HmIpDeviceType) {
+    HmIpDeviceType[HmIpDeviceType["unknown"] = 0] = "unknown";
+    HmIpDeviceType[HmIpDeviceType["HmIpLampe"] = 1] = "HmIpLampe";
+    HmIpDeviceType[HmIpDeviceType["HmIpTaster"] = 2] = "HmIpTaster";
+    HmIpDeviceType[HmIpDeviceType["HmIpRoll"] = 3] = "HmIpRoll";
+    HmIpDeviceType[HmIpDeviceType["HmIpTherm"] = 4] = "HmIpTherm";
+    HmIpDeviceType[HmIpDeviceType["HmIpPraezenz"] = 5] = "HmIpPraezenz";
+    HmIpDeviceType[HmIpDeviceType["HmIpGriff"] = 6] = "HmIpGriff";
+    HmIpDeviceType[HmIpDeviceType["HmIpWippe"] = 7] = "HmIpWippe";
+    HmIpDeviceType[HmIpDeviceType["HmIpHeizung"] = 8] = "HmIpHeizung";
+    HmIpDeviceType[HmIpDeviceType["HmIpTuer"] = 9] = "HmIpTuer";
+    HmIpDeviceType[HmIpDeviceType["HmIpHeizgruppe"] = 10] = "HmIpHeizgruppe";
+    HmIpDeviceType[HmIpDeviceType["HmIpBewegung"] = 11] = "HmIpBewegung";
+})(HmIpDeviceType = exports.HmIpDeviceType || (exports.HmIpDeviceType = {}));

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

@@ -0,0 +1,22 @@
+/// <reference types="iobroker" />
+import { FensterPosition } from './FensterPosition';
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+import { Fenster } from './Fenster';
+export declare class HmIpGriff extends HmIPDevice {
+    position: FensterPosition;
+    private _kippCallback;
+    private _closedCallback;
+    private _offenCallback;
+    private _iOpen;
+    private minutesOpen;
+    private _fenster;
+    private _helpingRoomTemp;
+    constructor(pInfo: DeviceInfo);
+    addOffenCallback(pCallback: (pValue: boolean) => void): void;
+    addKippCallback(pCallback: (pValue: boolean) => void): void;
+    addClosedCallback(pCallback: (pValue: boolean) => void): void;
+    set Fenster(value: Fenster);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    updatePosition(pValue: FensterPosition): void;
+}

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpGriff = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const FensterPosition_1 = require("./FensterPosition");
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const log_service_1 = require("../../services/log-service");
+const telegram_service_1 = require("../../services/Telegram/telegram-service");
+const utils_1 = require("../../services/utils/utils");
+const weather_service_1 = require("../../services/weather/weather-service");
+class HmIpGriff extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpGriff);
+        this.position = FensterPosition_1.FensterPosition.geschlossen;
+        this._kippCallback = [];
+        this._closedCallback = [];
+        this._offenCallback = [];
+        this.minutesOpen = 0;
+        this._fenster = undefined;
+        this._helpingRoomTemp = false;
+    }
+    addOffenCallback(pCallback) {
+        this._offenCallback.push(pCallback);
+    }
+    addKippCallback(pCallback) {
+        this._kippCallback.push(pCallback);
+    }
+    addClosedCallback(pCallback) {
+        this._closedCallback.push(pCallback);
+    }
+    set Fenster(value) {
+        this._fenster = value;
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Griff Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case '1':
+                if (idSplit[4] === 'STATE') {
+                    this.updatePosition(state.val);
+                }
+                break;
+        }
+    }
+    updatePosition(pValue) {
+        if (pValue === this.position) {
+            return;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Update Fenstergriff "${this.info.customName}"\nauf Position "${FensterPosition_1.FensterPosition[pValue]}"`);
+        this.position = pValue;
+        for (const c1 of this._closedCallback) {
+            c1(pValue === 0);
+        }
+        for (const c2 of this._kippCallback) {
+            c2(pValue === 1);
+        }
+        for (const c3 of this._offenCallback) {
+            c3(pValue === 2);
+        }
+        if (pValue === FensterPosition_1.FensterPosition.geschlossen) {
+            if (this._iOpen !== undefined) {
+                clearInterval(this._iOpen);
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Fenster: "${this.info.customName}" nach ${this.minutesOpen} Minuten geschlossen`);
+                this.minutesOpen = 0;
+                this._iOpen = undefined;
+            }
+            return;
+        }
+        else if (this._iOpen === undefined) {
+            this._iOpen = utils_1.Utils.guardedInterval(() => {
+                this.minutesOpen++;
+                if (this._fenster !== undefined && this._fenster.room !== undefined) {
+                    const desiredTemp = this._fenster.room.HeatGroup.desiredTemp;
+                    const currentTemp = this._fenster.room.HeatGroup.currentTemp;
+                    const outSideTemp = weather_service_1.WeatherService.getCurrentTemp();
+                    // Check if any of these values are unavailable
+                    if (desiredTemp > -99 && currentTemp > -99 && outSideTemp > -99) {
+                        const wouldHelp = (desiredTemp < currentTemp && outSideTemp < currentTemp) ||
+                            (desiredTemp > currentTemp && outSideTemp > currentTemp);
+                        if (!wouldHelp && this._helpingRoomTemp) {
+                            const info = `Das Fenster "${this.info.customName}" sollte geschlossen werden, es hilft dem Raum nicht mehr`;
+                            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, info);
+                            telegram_service_1.TelegramService.inform(info);
+                            this._helpingRoomTemp = false;
+                        }
+                        else if (wouldHelp && !this._helpingRoomTemp) {
+                            this._helpingRoomTemp = true;
+                            const info = `Das Fenster "${this.info.customName}" hilft der Innentemperatur ihr Ziel von ${desiredTemp} zu erreichen. Draußen sind es ${outSideTemp}. Du wirst informiert wenn es nicht mehr hilft.`;
+                            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, info);
+                            telegram_service_1.TelegramService.inform(info);
+                            return;
+                        }
+                        else if (wouldHelp && this._helpingRoomTemp) {
+                            return;
+                        }
+                    }
+                }
+                const message = `Fenster: "${this.info.customName}" seit ${this.minutesOpen} Minuten auf Position ${FensterPosition_1.FensterPosition[this.position]}`;
+                switch (this.minutesOpen) {
+                    case 15:
+                    case 30:
+                    case 60:
+                    case 120:
+                    case 240:
+                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, message);
+                        telegram_service_1.TelegramService.inform(message);
+                        break;
+                    default:
+                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, message);
+                        break;
+                }
+            }, 60000, this);
+        }
+    }
+}
+exports.HmIpGriff = HmIpGriff;

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

@@ -0,0 +1,34 @@
+/// <reference types="iobroker" />
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+import { TemperaturSettings } from '../../../models/temperaturSettings';
+import { HmIpHeizung } from './hmIpHeizung';
+export declare class HmIpHeizgruppe extends HmIPDevice {
+    private _automaticMode;
+    private _iAutomaticInterval;
+    private _level;
+    private _temperatur;
+    private _humidity;
+    private _desiredTemperatur;
+    private _setPointTemperaturID;
+    private _automaticFallBackTemperatur;
+    private _automaticPoints;
+    private _humidityCallbacks;
+    constructor(pInfo: DeviceInfo);
+    get sLevel(): string;
+    get iLevel(): number;
+    get sTemperatur(): string;
+    get iTemperatur(): number;
+    get desiredTemperatur(): number;
+    get humidity(): number;
+    private set humidity(value);
+    set desiredTemperatur(val: number);
+    addHumidityCallback(pCallback: (pValue: number) => void): void;
+    deleteAutomaticPoint(name: string): void;
+    getBelongingHeizungen(): HmIpHeizung[];
+    setAutomaticPoint(name: string, setting: TemperaturSettings): void;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    stopAutomaticCheck(): void;
+    private updateBaseInformation;
+    private checkAutomaticChange;
+}

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpHeizgruppe = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const log_service_1 = require("../../services/log-service");
+const persist_1 = require("../../services/dbo/persist");
+const devices_1 = require("../devices");
+const utils_1 = require("../../services/utils/utils");
+class HmIpHeizgruppe extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpHeizgruppe);
+        this._automaticMode = true;
+        this._level = 0;
+        this._temperatur = 0;
+        this._humidity = 0;
+        this._desiredTemperatur = 0;
+        this._setPointTemperaturID = '';
+        this._automaticFallBackTemperatur = 20;
+        this._automaticPoints = {};
+        this._humidityCallbacks = [];
+        this._setPointTemperaturID = `${this.info.fullID}.1.SET_POINT_TEMPERATURE`;
+        this._iAutomaticInterval = utils_1.Utils.guardedInterval(this.checkAutomaticChange, 300000, this); // Alle 5 Minuten prüfen
+    }
+    get sLevel() {
+        return `${this._level * 100}%`;
+    }
+    get iLevel() {
+        return this._level;
+    }
+    get sTemperatur() {
+        return `${this._temperatur}°C`;
+    }
+    get iTemperatur() {
+        return this._temperatur;
+    }
+    get desiredTemperatur() {
+        return this._desiredTemperatur;
+    }
+    get humidity() {
+        return this._humidity;
+    }
+    set humidity(val) {
+        this._humidity = val;
+        for (const cb of this._humidityCallbacks) {
+            cb(val);
+        }
+    }
+    set desiredTemperatur(val) {
+        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.Info, `Neue Temperatur (${val}) für "${this.info.customName}".`);
+        this.ioConn.setState(this._setPointTemperaturID, val, (err) => {
+            if (err) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Temperaturänderung für "${this.info.customName}" ergab Fehler ${err}.`);
+            }
+            else {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Temperaturänderung für "${this.info.customName}" auf ${val} erfolgreich`);
+            }
+        });
+    }
+    addHumidityCallback(pCallback) {
+        this._humidityCallbacks.push(pCallback);
+        if (this._humidity > 0) {
+            pCallback(this._humidity);
+        }
+    }
+    deleteAutomaticPoint(name) {
+        if (this._automaticPoints[name] !== undefined)
+            delete this._automaticPoints[name];
+    }
+    getBelongingHeizungen() {
+        const result = [];
+        for (const dID in devices_1.Devices.hmIP) {
+            const d = devices_1.Devices.hmIP[dID];
+            if (d.deviceType === hmIpDeviceType_1.HmIpDeviceType.HmIpHeizung && d.info.room === this.info.room) {
+                result.push(d);
+            }
+        }
+        return result;
+    }
+    setAutomaticPoint(name, setting) {
+        this._automaticPoints[name] = setting;
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Heizgruppe "${this.info.customName}" Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case '1':
+                this.updateBaseInformation(idSplit[4], state);
+                break;
+        }
+    }
+    stopAutomaticCheck() {
+        if (this._iAutomaticInterval !== undefined) {
+            clearInterval(this._iAutomaticInterval);
+            this._iAutomaticInterval = undefined;
+        }
+    }
+    updateBaseInformation(name, state) {
+        switch (name) {
+            case 'ACTUAL_TEMPERATURE':
+                this._temperatur = state.val;
+                break;
+            case 'LEVEL':
+                this._level = state.val;
+                break;
+            case 'HUMIDITY':
+                this.humidity = state.val;
+                break;
+            case 'SET_POINT_TEMPERATURE':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Heizgruppe "${this.info.customName}" Update Soll-Temperatur JSON: ${JSON.stringify(state)}`);
+                this._desiredTemperatur = state.val;
+                break;
+        }
+    }
+    checkAutomaticChange() {
+        var _a;
+        if (!this._automaticMode) {
+            persist_1.Persist.addTemperaturDataPoint(this);
+            return;
+        }
+        for (const name in this._automaticPoints) {
+            if (this._automaticPoints[name] === undefined) {
+                continue;
+            }
+            const settings = this._automaticPoints[name];
+            if (!settings.isNowInRange()) {
+                continue;
+            }
+            if (this._desiredTemperatur !== settings.temperatur) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Automatische Temperaturanpassung für ${this.info.customName} auf ${settings.temperatur}°C`);
+                this.desiredTemperatur = (_a = settings.temperatur) !== null && _a !== void 0 ? _a : this._automaticFallBackTemperatur;
+            }
+            break;
+        }
+        persist_1.Persist.addTemperaturDataPoint(this);
+    }
+}
+exports.HmIpHeizgruppe = HmIpHeizgruppe;

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

@@ -0,0 +1,15 @@
+/// <reference types="iobroker" />
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+export declare class HmIpHeizung extends HmIPDevice {
+    private _temperatur;
+    private _level;
+    private _adaptionState;
+    private _desiredTemperatur;
+    get desiredTemperatur(): number;
+    get iLevel(): number;
+    get iTemperatur(): number;
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    private updateBaseInformation;
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpHeizung = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+class HmIpHeizung extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpHeizung);
+        this._temperatur = 0;
+        this._level = 0;
+        this._desiredTemperatur = 0;
+    }
+    get desiredTemperatur() {
+        return this._desiredTemperatur;
+    }
+    get iLevel() {
+        return this._level;
+    }
+    get iTemperatur() {
+        return this._temperatur;
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Heizung "${this.info.customName}" Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case '1':
+                this.updateBaseInformation(idSplit[4], state);
+                break;
+        }
+    }
+    updateBaseInformation(name, state) {
+        switch (name) {
+            case 'ACTUAL_TEMPERATURE':
+                this._temperatur = state.val;
+                break;
+            case 'LEVEL':
+                this._level = state.val;
+                break;
+            case 'VALVE_STATE':
+                this._adaptionState = state.val;
+                if (this._adaptionState !== 4) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Adaption State für Heizung "${this.info.customName}" ungewöhnlich: ${this._adaptionState}`);
+                }
+                break;
+            case 'SET_POINT_TEMPERATURE':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Heizung "${this.info.customName}" Update Soll-Temperatur JSON: ${JSON.stringify(state)}`);
+                this._desiredTemperatur = state.val;
+                break;
+        }
+    }
+}
+exports.HmIpHeizung = HmIpHeizung;

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

@@ -0,0 +1,27 @@
+/// <reference types="iobroker" />
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+import { ActuatorSettings } from '../../../models/actuatorSettings';
+import { iLamp } from '../iLamp';
+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
+     */
+    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;
+}

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpLampe = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const log_service_1 = require("../../services/log-service");
+const actuatorSettings_1 = require("../../../models/actuatorSettings");
+const utils_1 = require("../../services/utils/utils");
+class HmIpLampe extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpLampe);
+        this.lightOn = false;
+        this.queuedLightValue = null;
+        this.isStromStoss = false;
+        this.settings = new actuatorSettings_1.ActuatorSettings();
+        this.lightOnSwitchID = '';
+        this.turnOffTimeout = undefined;
+        this.turnOffTime = 0;
+        this.lightOnSwitchID = `${this.info.fullID}.2.STATE`;
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Lampen Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        this.queuedLightValue = null;
+        switch (idSplit[3]) {
+            case '1':
+                if (idSplit[4] === 'STATE') {
+                    this.lightOn = state.val;
+                }
+                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
+     */
+    setLight(pValue, timeout = -1, force = false) {
+        if (!force && pValue === this.lightOn && this.queuedLightValue === null) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Skip light command for "${this.info.customName}" as it is already ${pValue}`);
+            return;
+        }
+        if (this.lightOnSwitchID === '') {
+            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;
+        }
+        if (!force && utils_1.Utils.nowMS() < this.turnOffTime) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Skip automatic command for "${this.info.customName}" to ${pValue} as it is locked until ${new Date(this.turnOffTime).toLocaleString()}`);
+            return;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Lampe schalten: "${this.info.customName}" Wert: ${pValue}`);
+        this.ioConn.setState(this.lightOnSwitchID, pValue, (err) => {
+            if (err) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
+            }
+        });
+        this.queuedLightValue = pValue;
+        if (this.isStromStoss) {
+            timeout = 5000;
+        }
+        if (this.turnOffTimeout !== undefined) {
+            clearTimeout(this.turnOffTimeout);
+            this.turnOffTimeout = undefined;
+        }
+        if (timeout < 0 || !pValue) {
+            return;
+        }
+        this.turnOffTime = utils_1.Utils.nowMS() + timeout;
+        this.turnOffTimeout = utils_1.Utils.guardedTimeout(() => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.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);
+    }
+    /**
+     * Switch the current condition of the light
+     * @param force Whether this is a forcing action skipping delays and locks
+     */
+    toggleLight(force = false) {
+        const newVal = this.queuedLightValue !== null ? !this.queuedLightValue : !this.lightOn;
+        const timeout = newVal && force ? 30 * 60 * 1000 : -1;
+        this.setLight(newVal, timeout, force);
+        return newVal;
+    }
+}
+exports.HmIpLampe = HmIpLampe;

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

@@ -0,0 +1,22 @@
+/// <reference types="iobroker" />
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+import { iIlluminationSensor } from '../iIlluminationSensor';
+export declare class HmIpPraezenz extends HmIPDevice implements iIlluminationSensor {
+    excludeFromNightAlarm: boolean;
+    presenceDetected: boolean;
+    private _detectionsToday;
+    private _presenceDetectedCallback;
+    private static PRESENCE_DETECTION;
+    private static CURRENT_ILLUMINATION;
+    private initialized;
+    private _currentIllumination;
+    get detectionsToday(): number;
+    set detectionsToday(pVal: number);
+    get currentIllumination(): number;
+    private set currentIllumination(value);
+    constructor(pInfo: DeviceInfo);
+    addPresenceCallback(pCallback: (pValue: boolean) => void): void;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    updatePresence(pVal: boolean): void;
+}