hoffmation-base 3.0.3 → 3.1.1

package/lib/devices/hmIPDevices/hmIpDevice.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIPDevice = void 0;
+const IoBrokerBaseDevice_1 = require("../IoBrokerBaseDevice");
+const enums_1 = require("../../enums");
+class HmIPDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
+    constructor(pInfo, pType) {
+        super(pInfo, pType);
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, pOverride = false) {
+        if (!pOverride) {
+            this.log(enums_1.LogLevel.Trace, `Keine Update Überschreibung :\n\tID: ${idSplit.join('.')}`);
+            this.log(enums_1.LogLevel.DeepTrace, `Data: ${JSON.stringify(state)}`);
+        }
+        this.log(enums_1.LogLevel.DeepTrace, `Base-Device Update for ${this.info.customName}("${idSplit.join('.')}", ${state}, ${initial}, ${pOverride})`);
+        const combinedStateName = `${idSplit[3]}.${idSplit[4]}`;
+        switch (combinedStateName) {
+            case '0.LOW_BAT':
+                const newBatLowVal = state.val;
+                if (newBatLowVal) {
+                    this.log(enums_1.LogLevel.Warn, '!!BATTERIE FAST LEER!!');
+                }
+                break;
+        }
+        this.stateMap.set(combinedStateName, state);
+        const individualCallbacks = this.individualStateCallbacks.get(combinedStateName);
+        if (individualCallbacks !== undefined) {
+            for (const cb of individualCallbacks) {
+                cb(state.val);
+            }
+        }
+    }
+}
+exports.HmIPDevice = HmIPDevice;

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

@@ -0,0 +1,41 @@
+import { HmIPDevice } from './hmIpDevice';
+import { iBatteryDevice, iDisposable, iHandle, iWindow } from '../../interfaces';
+import { Battery, HandleSensor } from '../sharedFunctions';
+import { HandleSettings } from '../../settingsObjects';
+import { WindowPosition } from '../../enums';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { HandleChangeAction } from '../../action';
+export declare class HmIpGriff extends HmIPDevice implements iHandle, iBatteryDevice, iDisposable {
+    /** @inheritDoc */
+    readonly battery: Battery;
+    /** @inheritDoc */
+    readonly handleSensor: HandleSensor;
+    /** @inheritDoc */
+    settings: HandleSettings;
+    /** @inheritDoc */
+    get position(): WindowPosition;
+    /** @inheritDoc */
+    get minutesOpen(): number;
+    /**
+     * Creates an instance of {@link DeviceType.HmIpGriff}.
+     * @param pInfo - Device creation information
+     */
+    constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get batteryLevel(): number;
+    get window(): iWindow | undefined;
+    /** @inheritDoc */
+    set window(value: iWindow);
+    /** @inheritDoc */
+    addOffenCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
+    addKippCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
+    addClosedCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
+    addHandleChangeCallback(cb: (handleChangeAction: HandleChangeAction) => void): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
+}

package/lib/devices/hmIPDevices/hmIpGriff.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpGriff = void 0;
+const hmIpDevice_1 = require("./hmIpDevice");
+const sharedFunctions_1 = require("../sharedFunctions");
+const settingsObjects_1 = require("../../settingsObjects");
+const enums_1 = require("../../enums");
+class HmIpGriff extends hmIpDevice_1.HmIPDevice {
+    /** @inheritDoc */
+    get position() {
+        return this.handleSensor.position;
+    }
+    /** @inheritDoc */
+    get minutesOpen() {
+        return this.handleSensor.minutesOpen;
+    }
+    /**
+     * Creates an instance of {@link DeviceType.HmIpGriff}.
+     * @param pInfo - Device creation information
+     */
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.HmIpGriff);
+        /** @inheritDoc */
+        this.battery = new sharedFunctions_1.Battery(this);
+        /** @inheritDoc */
+        this.handleSensor = new sharedFunctions_1.HandleSensor(this);
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.HandleSettings();
+        this.deviceCapabilities.push(enums_1.DeviceCapability.handleSensor);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.batteryDriven);
+    }
+    /** @inheritDoc */
+    get batteryLevel() {
+        return this.battery.level;
+    }
+    get window() {
+        return this.handleSensor.window;
+    }
+    /** @inheritDoc */
+    set window(value) {
+        this.handleSensor.window = value;
+    }
+    /** @inheritDoc */
+    addOffenCallback(pCallback) {
+        this.handleSensor.addOffenCallback(pCallback);
+    }
+    /** @inheritDoc */
+    addKippCallback(pCallback) {
+        this.handleSensor.addKippCallback(pCallback);
+    }
+    /** @inheritDoc */
+    addClosedCallback(pCallback) {
+        this.handleSensor.addClosedCallback(pCallback);
+    }
+    /** @inheritDoc */
+    addHandleChangeCallback(cb) {
+        this.handleSensor.addHandleChangeCallback(cb);
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `Griff Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case '0':
+                switch (idSplit[4]) {
+                    case 'OPERATING_VOLTAGE':
+                        this.battery.level = 100 * ((state.val - 0.9) / 0.6);
+                        break;
+                }
+                break;
+            case '1':
+                switch (idSplit[4]) {
+                    case 'STATE':
+                        this.handleSensor.updatePosition(state.val);
+                        break;
+                    case 'OPERATING_VOLTAGE':
+                        this.battery.level = 100 * ((state.val - 0.9) / 0.6);
+                        break;
+                }
+                break;
+        }
+    }
+    /** @inheritDoc */
+    dispose() {
+        this.handleSensor.dispose();
+    }
+}
+exports.HmIpGriff = HmIpGriff;

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

@@ -0,0 +1,68 @@
+import { HmIPDevice } from './hmIpDevice';
+import { iDisposable, iHeater, iHumidityCollector, iHumiditySensor, iTemperatureCollector } from '../../interfaces';
+import { TemperatureSensor } from '../sharedFunctions';
+import { HeaterSettings } from '../../settingsObjects';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { HandleChangeAction, HumiditySensorChangeAction, TemperatureSensorChangeAction } from '../../action';
+export declare class HmIpHeizgruppe extends HmIPDevice implements iTemperatureCollector, iHumidityCollector, iHeater, iDisposable {
+    /** @inheritDoc */
+    readonly persistHeaterInterval: NodeJS.Timeout;
+    /** @inheritDoc */
+    temperatureSensor: TemperatureSensor;
+    /** @inheritDoc */
+    humiditySensor: iHumiditySensor;
+    /** @inheritDoc */
+    settings: HeaterSettings;
+    private readonly _setWindowOpenID;
+    private _iAutomaticInterval;
+    private _initialSeasonCheckDone;
+    private _level;
+    private _setPointTemperatureID;
+    private _windowOpen;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    protected _seasonTurnOff: boolean;
+    /** @inheritDoc */
+    get seasonTurnOff(): boolean;
+    /** @inheritDoc */
+    set seasonTurnOff(value: boolean);
+    get temperature(): number;
+    /** @inheritDoc */
+    get humidity(): number;
+    private _desiredTemperature;
+    /** @inheritDoc */
+    get desiredTemperature(): number;
+    /** @inheritDoc */
+    set desiredTemperature(val: number);
+    get sLevel(): string;
+    /** @inheritDoc */
+    get iLevel(): number;
+    /** @inheritDoc */
+    get sTemperature(): string;
+    /** @inheritDoc */
+    get iTemperature(): number;
+    /** @inheritDoc */
+    get roomTemperature(): number;
+    /** @inheritDoc */
+    get windowOpen(): boolean;
+    /** @inheritDoc */
+    addHumidityCallback(pCallback: (action: HumiditySensorChangeAction) => void): void;
+    getBelongingHeizungen(): iHeater[];
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    checkAutomaticChange(): void;
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback: (action: TemperatureSensorChangeAction) => void): void;
+    /** @inheritDoc */
+    onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
+    persistTemperaturSensor(): void;
+    /** @inheritDoc */
+    persistHeater(): void;
+    onHandleChange(_action: HandleChangeAction): void;
+    /** @inheritDoc */
+    dispose(): void;
+    private checkSeasonTurnOff;
+    private onWindowOpenChange;
+    private updateBaseInformation;
+}

package/lib/devices/hmIPDevices/hmIpHeizgruppe.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpHeizgruppe = void 0;
+const hmIpDevice_1 = require("./hmIpDevice");
+const utils_1 = require("../../utils");
+const sharedFunctions_1 = require("../sharedFunctions");
+const settingsObjects_1 = require("../../settingsObjects");
+const enums_1 = require("../../enums");
+const services_1 = require("../../services");
+const models_1 = require("../../models");
+class HmIpHeizgruppe extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.HmIpHeizgruppe);
+        /** @inheritDoc */
+        this.persistHeaterInterval = utils_1.Utils.guardedInterval(() => {
+            this.persistHeater();
+        }, 5 * 60 * 1000, this, false);
+        /** @inheritDoc */
+        this.temperatureSensor = new sharedFunctions_1.TemperatureSensor(this);
+        /** @inheritDoc */
+        this.humiditySensor = new sharedFunctions_1.HumiditySensor(this);
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.HeaterSettings();
+        this._setWindowOpenID = '';
+        this._initialSeasonCheckDone = false;
+        this._level = 0;
+        this._setPointTemperatureID = '';
+        this._windowOpen = false;
+        this._seasonTurnOff = false;
+        this._desiredTemperature = 0;
+        this.deviceCapabilities.push(enums_1.DeviceCapability.temperatureSensor);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.humiditySensor);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.heater);
+        this._setPointTemperatureID = `${this.info.fullID}.1.SET_POINT_TEMPERATURE`;
+        this._iAutomaticInterval = utils_1.Utils.guardedInterval(this.checkAutomaticChange, 300000, this); // Alle 5 Minuten prüfen
+        services_1.TimeCallbackService.addCallback(new models_1.TimeCallback(`${this.info.fullID} Season Check`, enums_1.TimeCallbackType.TimeOfDay, () => {
+            this.checkSeasonTurnOff();
+        }, 0, 2, 0));
+    }
+    /** @inheritDoc */
+    get seasonTurnOff() {
+        return this._seasonTurnOff;
+    }
+    /** @inheritDoc */
+    set seasonTurnOff(value) {
+        this._seasonTurnOff = value;
+        if (value) {
+            this.setState(this._setPointTemperatureID, 5);
+        }
+        else {
+            this.setState(this._setPointTemperatureID, this.desiredTemperature);
+        }
+    }
+    get temperature() {
+        if (this.settings.useOwnTemperatur) {
+            return this.temperatureSensor.temperature;
+        }
+        return this.roomTemperature;
+    }
+    /** @inheritDoc */
+    get humidity() {
+        return this.humiditySensor.humidity;
+    }
+    /** @inheritDoc */
+    get desiredTemperature() {
+        return this._desiredTemperature;
+    }
+    /** @inheritDoc */
+    set desiredTemperature(val) {
+        this.setState(this._setPointTemperatureID, this.seasonTurnOff ? 5 : val, () => {
+            this.log(enums_1.LogLevel.Info, `Changed temperature of to "${val}.`);
+        }, (err) => {
+            this.log(enums_1.LogLevel.Error, `Temperaturänderung ergab Fehler ${err}.`);
+        });
+    }
+    get sLevel() {
+        return `${this._level * 100}%`;
+    }
+    /** @inheritDoc */
+    get iLevel() {
+        return this._level;
+    }
+    /** @inheritDoc */
+    get sTemperature() {
+        return `${this.temperature}°C`;
+    }
+    /** @inheritDoc */
+    get iTemperature() {
+        return this.temperature;
+    }
+    /** @inheritDoc */
+    get roomTemperature() {
+        return this.temperatureSensor.roomTemperature;
+    }
+    /** @inheritDoc */
+    get windowOpen() {
+        return this._windowOpen;
+    }
+    /** @inheritDoc */
+    addHumidityCallback(pCallback) {
+        this.humiditySensor.addHumidityCallback(pCallback);
+    }
+    getBelongingHeizungen() {
+        return this.room.deviceCluster.getDevicesByType(enums_1.DeviceClusterType.Heater);
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `Heizgruppe 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;
+        }
+    }
+    /** @inheritDoc */
+    checkAutomaticChange() {
+        var _a, _b, _c, _d;
+        if (!this._initialSeasonCheckDone) {
+            this.checkSeasonTurnOff();
+        }
+        if (this.seasonTurnOff || this.settings.manualDisabled) {
+            this.seasonTurnOff = true;
+            return;
+        }
+        const heatGroupSettings = (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.HeatGroup) === null || _b === void 0 ? void 0 : _b.settings;
+        if (!this.settings.automaticMode || this.seasonTurnOff || (heatGroupSettings === null || heatGroupSettings === void 0 ? void 0 : heatGroupSettings.automaticMode) === false) {
+            return;
+        }
+        const targetTemp = (_d = (_c = this.room.HeatGroup) === null || _c === void 0 ? void 0 : _c.desiredTemp) !== null && _d !== void 0 ? _d : 20;
+        if (this._desiredTemperature !== targetTemp) {
+            this.log(enums_1.LogLevel.Debug, `Automatische Temperaturanpassung für ${this.info.customName} auf ${targetTemp}°C`);
+            this.desiredTemperature = targetTemp;
+        }
+    }
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback) {
+        this.temperatureSensor.addTempChangeCallback(pCallback);
+    }
+    /** @inheritDoc */
+    onTemperaturChange(newTemperatur) {
+        this.temperatureSensor.roomTemperature = newTemperatur;
+    }
+    /** @inheritDoc */
+    persistTemperaturSensor() {
+        var _a;
+        (_a = this.dbo) === null || _a === void 0 ? void 0 : _a.persistTemperatureSensor(this);
+    }
+    /** @inheritDoc */
+    persistHeater() {
+        var _a;
+        (_a = this.dbo) === null || _a === void 0 ? void 0 : _a.persistHeater(this);
+    }
+    onHandleChange(_action) {
+        var _a;
+        if (this.room.WindowGroup === undefined) {
+            return;
+        }
+        const newState = (_a = this.room.WindowGroup) === null || _a === void 0 ? void 0 : _a.anyWindowOpen;
+        if (newState === this._windowOpen) {
+            return;
+        }
+        this._windowOpen = newState;
+        this.onWindowOpenChange(this._windowOpen);
+    }
+    /** @inheritDoc */
+    dispose() {
+        this.temperatureSensor.dispose();
+        this.humiditySensor.dispose();
+        if (this.persistHeaterInterval) {
+            clearInterval(this.persistHeaterInterval);
+        }
+        if (this._iAutomaticInterval) {
+            clearInterval(this._iAutomaticInterval);
+            this._iAutomaticInterval = undefined;
+        }
+    }
+    checkSeasonTurnOff() {
+        const isSummer = utils_1.Utils.beetweenDays(new Date(), this.settings.seasonTurnOffDay, this.settings.seasonTurnOnDay);
+        if (isSummer !== this.seasonTurnOff || !this._initialSeasonCheckDone) {
+            this.log(enums_1.LogLevel.Info, `Switching Seasonal Heating --> New seasonTurnOff: ${isSummer}`);
+            this.seasonTurnOff = isSummer;
+        }
+        this._initialSeasonCheckDone = true;
+    }
+    onWindowOpenChange(pValue) {
+        if (!this._setWindowOpenID) {
+            return;
+        }
+        this.setState(this._setWindowOpenID, pValue);
+    }
+    updateBaseInformation(name, state) {
+        switch (name) {
+            case 'ACTUAL_TEMPERATURE':
+                this.temperatureSensor.temperature = state.val;
+                break;
+            case 'LEVEL':
+                this._level = state.val;
+                break;
+            case 'HUMIDITY':
+                this.humiditySensor.humidity = state.val;
+                break;
+            case 'SET_POINT_TEMPERATURE':
+                this.log(enums_1.LogLevel.DeepTrace, `Heizgruppe Update Soll-Temperatur JSON: ${JSON.stringify(state)}`);
+                this._desiredTemperature = state.val;
+                break;
+        }
+    }
+}
+exports.HmIpHeizgruppe = HmIpHeizgruppe;

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

@@ -0,0 +1,20 @@
+import { HmIPDevice } from './hmIpDevice';
+import { iBatteryDevice } from '../../interfaces';
+import { Battery } from '../sharedFunctions';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class HmIpHeizung extends HmIPDevice implements iBatteryDevice {
+    /** @inheritDoc */
+    readonly battery: Battery;
+    private _temperatur;
+    private _level;
+    private _adaptionState;
+    private _desiredTemperatur;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    get batteryLevel(): number;
+    get desiredTemperatur(): number;
+    get iLevel(): number;
+    get iTemperatur(): number;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    private updateBaseInformation;
+}

package/lib/devices/hmIPDevices/hmIpHeizung.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpHeizung = void 0;
+const hmIpDevice_1 = require("./hmIpDevice");
+const sharedFunctions_1 = require("../sharedFunctions");
+const enums_1 = require("../../enums");
+var HmIpHeizungAdaptionStates;
+(function (HmIpHeizungAdaptionStates) {
+    HmIpHeizungAdaptionStates[HmIpHeizungAdaptionStates["StateNotAvailable"] = 0] = "StateNotAvailable";
+    HmIpHeizungAdaptionStates[HmIpHeizungAdaptionStates["RunToStart"] = 1] = "RunToStart";
+    HmIpHeizungAdaptionStates[HmIpHeizungAdaptionStates["WaitForAdaption"] = 2] = "WaitForAdaption";
+    HmIpHeizungAdaptionStates[HmIpHeizungAdaptionStates["AdaptionInProgress"] = 3] = "AdaptionInProgress";
+    HmIpHeizungAdaptionStates[HmIpHeizungAdaptionStates["AdaptionDone"] = 4] = "AdaptionDone";
+    HmIpHeizungAdaptionStates[HmIpHeizungAdaptionStates["TooTight"] = 5] = "TooTight";
+    HmIpHeizungAdaptionStates[HmIpHeizungAdaptionStates["AdjustmentTooBig"] = 6] = "AdjustmentTooBig";
+    HmIpHeizungAdaptionStates[HmIpHeizungAdaptionStates["AdjustmentTooSmall"] = 7] = "AdjustmentTooSmall";
+    HmIpHeizungAdaptionStates[HmIpHeizungAdaptionStates["ErrorPosition"] = 8] = "ErrorPosition";
+})(HmIpHeizungAdaptionStates || (HmIpHeizungAdaptionStates = {}));
+class HmIpHeizung extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.HmIpHeizung);
+        /** @inheritDoc */
+        this.battery = new sharedFunctions_1.Battery(this);
+        this._temperatur = 0;
+        this._level = 0;
+        this._desiredTemperatur = 0;
+        this.deviceCapabilities.push(enums_1.DeviceCapability.batteryDriven);
+    }
+    get batteryLevel() {
+        return this.battery.level;
+    }
+    get desiredTemperatur() {
+        return this._desiredTemperatur;
+    }
+    get iLevel() {
+        return this._level;
+    }
+    get iTemperatur() {
+        return this._temperatur;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `Heizung Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case '0':
+                switch (idSplit[4]) {
+                    case 'OPERATING_VOLTAGE':
+                        this.battery.level = 100 * ((state.val - 1.8) / 1.2);
+                        break;
+                }
+                break;
+            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 !== HmIpHeizungAdaptionStates.AdaptionInProgress &&
+                    this._adaptionState !== HmIpHeizungAdaptionStates.AdaptionDone) {
+                    this.log(enums_1.LogLevel.Alert, `Akward adaption state: ${HmIpHeizungAdaptionStates[this._adaptionState]}`);
+                }
+                break;
+            case 'SET_POINT_TEMPERATURE':
+                this.log(enums_1.LogLevel.Trace, `Heizung Update Soll-Temperatur JSON: ${JSON.stringify(state)}`);
+                this._desiredTemperatur = state.val;
+                break;
+        }
+    }
+}
+exports.HmIpHeizung = HmIpHeizung;

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

@@ -0,0 +1,32 @@
+import { ActuatorSetStateCommand, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand, RestoreTargetAutomaticValueCommand } from '../../command';
+import { HmIPDevice } from './hmIpDevice';
+import { iLamp, iTemporaryDisableAutomatic } from '../../interfaces';
+import { ActuatorSettings } from '../../settingsObjects';
+import { BlockAutomaticHandler } from '../../services';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class HmIpLampe extends HmIPDevice implements iLamp, iTemporaryDisableAutomatic {
+    /** @inheritDoc */
+    private _actuatorOn;
+    /** @inheritDoc */
+    settings: ActuatorSettings;
+    private lightOnSwitchID;
+    /** @inheritDoc */
+    readonly blockAutomationHandler: BlockAutomaticHandler;
+    /** @inheritDoc */
+    queuedValue: boolean | null;
+    /** @inheritDoc */
+    targetAutomaticState: boolean;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    get actuatorOn(): boolean;
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    setActuator(command: ActuatorSetStateCommand): void;
+    toggleActuator(c: ActuatorToggleCommand): boolean;
+    /** @inheritdoc */
+    setLight(c: LampSetLightCommand): void;
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
+    toggleLight(c: LampToggleLightCommand): boolean;
+    setTimeBased(c: LampSetTimeBasedCommand): void;
+    persist(): void;
+}

package/lib/devices/hmIPDevices/hmIpLampe.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpLampe = void 0;
+const command_1 = require("../../command");
+const hmIpDevice_1 = require("./hmIpDevice");
+const settingsObjects_1 = require("../../settingsObjects");
+const services_1 = require("../../services");
+const enums_1 = require("../../enums");
+const sharedFunctions_1 = require("../sharedFunctions");
+class HmIpLampe extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, enums_1.DeviceType.HmIpLampe);
+        /** @inheritDoc */
+        this._actuatorOn = false;
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.ActuatorSettings();
+        this.lightOnSwitchID = '';
+        /** @inheritDoc */
+        this.queuedValue = null;
+        /** @inheritDoc */
+        this.targetAutomaticState = false;
+        this.deviceCapabilities.push(enums_1.DeviceCapability.lamp);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.blockAutomatic);
+        this.lightOnSwitchID = `${this.info.fullID}.2.STATE`;
+        this.blockAutomationHandler = new services_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
+    }
+    get actuatorOn() {
+        return this._actuatorOn;
+    }
+    restoreTargetAutomaticValue(c) {
+        this.setLight(new command_1.LampSetLightCommand(c, this.targetAutomaticState));
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `Lampen Update : ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        this.queuedValue = null;
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case '1':
+                if (idSplit[4] === 'STATE') {
+                    this._actuatorOn = state.val;
+                    this.persist();
+                }
+                break;
+        }
+    }
+    setActuator(command) {
+        this.setLight(command);
+    }
+    toggleActuator(c) {
+        const setActuatorCommand = new command_1.ActuatorSetStateCommand(c, this.queuedValue !== null ? !this.queuedValue : !this.actuatorOn, 'Due to ActuatorToggle', c.isForceAction ? undefined : null);
+        this.setActuator(setActuatorCommand);
+        return setActuatorCommand.on;
+    }
+    /** @inheritdoc */
+    setLight(c) {
+        if (this.lightOnSwitchID === '') {
+            this.log(enums_1.LogLevel.Error, 'Keine Switch ID bekannt.');
+            return;
+        }
+        sharedFunctions_1.LampUtils.setActuator(this, c);
+    }
+    writeActuatorStateToDevice(c) {
+        this.log(enums_1.LogLevel.Debug, c.logMessage, enums_1.LogDebugType.SetActuator);
+        this.setState(this.lightOnSwitchID, c.stateValue, undefined, (err) => {
+            this.log(enums_1.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
+        });
+    }
+    toggleLight(c) {
+        return sharedFunctions_1.LampUtils.toggleLight(this, c);
+    }
+    setTimeBased(c) {
+        sharedFunctions_1.LampUtils.setTimeBased(this, c);
+    }
+    persist() {
+        var _a;
+        (_a = this.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+    }
+}
+exports.HmIpLampe = HmIpLampe;