hoffmation-base 3.0.3 → 3.1.0

package/lib/devices/zigbee/BaseDevices/zigbeeDevice.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeDevice = void 0;
+const IoBrokerBaseDevice_1 = require("../../IoBrokerBaseDevice");
+const utils_1 = require("../../../utils");
+const enums_1 = require("../../../enums");
+class ZigbeeDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
+    get available() {
+        return this._available;
+    }
+    get linkQuality() {
+        return this._linkQuality;
+    }
+    get lastUpdate() {
+        return this._lastUpdate;
+    }
+    constructor(pInfo, pType) {
+        super(pInfo, pType);
+        this._available = false;
+        this._dontSendOnUnavailable = false;
+        this._linkQuality = 0;
+        this._persistZigbeeInterval = utils_1.Utils.guardedInterval(() => {
+            this.persistZigbeeDevice();
+        }, 15 * 60 * 1000, this, false);
+        this._lastUpdate = new Date(0);
+        this._deviceQueryId = `${this.info.fullID}.device_query`;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, pOverride = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `Zigbee: ${initial ? 'Initiales ' : ''}Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        if (!pOverride) {
+            this.log(enums_1.LogLevel.Warn, `Keine Update Überschreibung:\n\tID: ${idSplit.join('.')}\n\tData: ${JSON.stringify(state)}`);
+        }
+        const stateLastUpdate = new Date(state.ts);
+        if (stateLastUpdate > this._lastUpdate) {
+            this._lastUpdate = stateLastUpdate;
+        }
+        switch (idSplit[3]) {
+            case 'available':
+                const newAvailability = state.val;
+                if (this._available && !newAvailability) {
+                    this.log(enums_1.LogLevel.Debug, 'Device became unavailable.');
+                }
+                this._available = newAvailability;
+                break;
+            case 'link_quality':
+                const newValue = state.val;
+                if (this._linkQuality > 5 && newValue <= 5) {
+                    this.log(enums_1.LogLevel.Debug, `The link-quality dropped to a critical level: ${newValue}`);
+                }
+                this._linkQuality = state.val;
+                break;
+        }
+        this.stateMap.set(idSplit[3], state);
+        const individualCallbacks = this.individualStateCallbacks.get(idSplit[3]);
+        if (individualCallbacks !== undefined) {
+            for (const cb of individualCallbacks) {
+                cb(state.val);
+            }
+        }
+    }
+    triggerDeviceQuery() {
+        this.log(enums_1.LogLevel.Info, 'Triggering Device Query');
+        this.setState(this._deviceQueryId, true);
+    }
+    /** @inheritDoc */
+    dispose() {
+        clearInterval(this._persistZigbeeInterval);
+    }
+    persistZigbeeDevice() {
+        var _a;
+        (_a = this.dbo) === null || _a === void 0 ? void 0 : _a.persistZigbeeDevice(this);
+    }
+    /** @inheritDoc */
+    setState(pointId, state, onSuccess = undefined, onError = undefined) {
+        if (this._dontSendOnUnavailable && !this._available) {
+            this.log(enums_1.LogLevel.Warn, `Device unavailable --> Not changing ${pointId} to ${state}`);
+            return;
+        }
+        super.setState(pointId, state, onSuccess, onError);
+    }
+}
+exports.ZigbeeDevice = ZigbeeDevice;

package/lib/devices/zigbee/BaseDevices/zigbeeDimmer.d.ts

@@ -0,0 +1,26 @@
+import { DimmerSetLightCommand, LampSetTimeBasedCommand } from '../../../command';
+import { ZigbeeLamp } from './zigbeeLamp';
+import { iDimmableLamp, iTemporaryDisableAutomatic } from '../../../interfaces';
+import { DimmerSettings } from '../../../settingsObjects';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { DeviceType } from '../../../enums';
+export declare abstract class ZigbeeDimmer extends ZigbeeLamp implements iDimmableLamp, iTemporaryDisableAutomatic {
+    /** @inheritDoc */
+    settings: DimmerSettings;
+    protected abstract readonly _stateIdBrightness: string;
+    protected abstract readonly _stateIdTransitionTime: string;
+    protected abstract readonly _stateNameBrightness: string;
+    protected abstract readonly _stateNameTransitionTime: string;
+    protected _brightness: number;
+    protected _transitionTime: number;
+    protected constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    /** @inheritDoc */
+    get brightness(): number;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    setTimeBased(c: LampSetTimeBasedCommand): void;
+    /** @inheritDoc */
+    setLight(c: DimmerSetLightCommand): void;
+    private setBrightnessState;
+}

package/lib/devices/zigbee/BaseDevices/zigbeeDimmer.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeDimmer = void 0;
+const command_1 = require("../../../command");
+const zigbeeLamp_1 = require("./zigbeeLamp");
+const settingsObjects_1 = require("../../../settingsObjects");
+const enums_1 = require("../../../enums");
+const sharedFunctions_1 = require("../../sharedFunctions");
+const utils_1 = require("../../../utils");
+const settings_service_1 = require("../../../settings-service");
+class ZigbeeDimmer extends zigbeeLamp_1.ZigbeeLamp {
+    constructor(pInfo, deviceType) {
+        super(pInfo, deviceType);
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.DimmerSettings();
+        this._brightness = 0;
+        this._transitionTime = 0;
+        this.deviceCapabilities.push(enums_1.DeviceCapability.dimmablelamp);
+    }
+    /** @inheritDoc */
+    get brightness() {
+        return this._brightness;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.queuedValue = null;
+        this.log(enums_1.LogLevel.DeepTrace, `Dimmer Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case this._stateNameBrightness:
+                this.log(enums_1.LogLevel.Trace, `Dimmer Helligkeit Update für ${this.info.customName} auf ${state.val}`);
+                this._brightness = state.val;
+                this.persist();
+                break;
+            case this._stateNameTransitionTime:
+                this.log(enums_1.LogLevel.Trace, `Dimmer Transition Time Update für ${this.info.customName} auf ${state.val}`);
+                this._transitionTime = state.val;
+                break;
+        }
+    }
+    /** @inheritDoc */
+    setTimeBased(c) {
+        this.setLight(this.settings.buildDimmerSetLightCommand(c));
+    }
+    /** @inheritDoc */
+    setLight(c) {
+        var _a;
+        if (this._actuatorOnStateIdState === '') {
+            this.log(enums_1.LogLevel.Error, 'Keine State ID bekannt.');
+            return;
+        }
+        if (!this.ioConn) {
+            this.log(enums_1.LogLevel.Error, 'Keine Connection bekannt.');
+            return;
+        }
+        const dontBlock = sharedFunctions_1.LampUtils.checkUnBlock(this, c);
+        if (sharedFunctions_1.LampUtils.checkBlockActive(this, c)) {
+            return;
+        }
+        if (c.isAutomaticAction) {
+            // Preserve the target state for the automatic handler, as
+            this.targetAutomaticState = c.on;
+        }
+        if (sharedFunctions_1.LampUtils.canDimmerChangeBeSkipped(this, c)) {
+            return;
+        }
+        if (c.transitionTime > -1) {
+            this.setState(this._stateIdTransitionTime, c.transitionTime);
+        }
+        if (c.on && c.brightness <= 0 && this.brightness < 10) {
+            c.brightness = 10;
+        }
+        if (!dontBlock && c.disableAutomaticCommand !== null) {
+            if (c.disableAutomaticCommand === undefined && c.isForceAction) {
+                c.disableAutomaticCommand = this.settings.buildBlockAutomaticCommand(c);
+            }
+            if (c.disableAutomaticCommand) {
+                this.blockAutomationHandler.disableAutomatic(c.disableAutomaticCommand);
+            }
+        }
+        if (((_a = settings_service_1.SettingsService.settings.ioBroker) === null || _a === void 0 ? void 0 : _a.useZigbee2mqtt) && !c.on) {
+            // With zigbee2mqtt to turn on only setting brighness>0 is needed, so we need state only for turning off
+            this.writeActuatorStateToDevice(new command_1.ActuatorWriteStateToDeviceCommand(c, c.on));
+            this.queuedValue = c.on;
+            return;
+        }
+        this.log(enums_1.LogLevel.Debug, c.logMessage, enums_1.LogDebugType.SetActuator);
+        if (c.brightness >= this.settings.turnOnThreshhold) {
+            this.setBrightnessState(c.brightness);
+            return;
+        }
+        this.setBrightnessState(this.settings.turnOnThreshhold, () => {
+            utils_1.Utils.guardedTimeout(() => {
+                this.log(enums_1.LogLevel.Info, `Delayed reduced brightness on ${this.info.customName} to ${c.brightness} for command: ${c.logMessage}`);
+                this.setBrightnessState(c.brightness);
+            }, 1000, this);
+        });
+    }
+    setBrightnessState(brightness, onSuccess) {
+        this.setState(this._stateIdBrightness, Math.max(0, Math.min(brightness, 100)), onSuccess);
+    }
+}
+exports.ZigbeeDimmer = ZigbeeDimmer;

package/lib/devices/zigbee/BaseDevices/zigbeeHeater.d.ts

@@ -0,0 +1,67 @@
+import { iBatteryDevice, iHeater } from '../../../interfaces';
+import { HeaterSettings } from '../../../settingsObjects';
+import { Battery, TemperatureSensor } from '../../sharedFunctions';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { DeviceType } from '../../../enums';
+import { PIDController } from '../../../liquid-pid';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { HandleChangeAction, TemperatureSensorChangeAction } from '../../../action';
+export declare class ZigbeeHeater extends ZigbeeDevice implements iHeater, iBatteryDevice {
+    /** @inheritDoc */
+    readonly battery: Battery;
+    /** @inheritDoc */
+    readonly persistHeaterInterval: NodeJS.Timeout;
+    /** @inheritDoc */
+    temperatureSensor: TemperatureSensor;
+    /** @inheritDoc */
+    settings: HeaterSettings;
+    protected _battery: number;
+    protected _iAutomaticInterval: NodeJS.Timeout | undefined;
+    protected _initialSeasonCheckDone: boolean;
+    protected _level: number;
+    protected _setPointTemperaturID: string;
+    protected _setWindowOpenID: string;
+    protected _temperatur: number;
+    protected _desiredTemperatur: number;
+    protected _pidController: PIDController;
+    protected _seasonTurnOff: boolean;
+    protected _windowOpen: boolean;
+    constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    /** @inheritDoc */
+    get batteryLevel(): number;
+    /** @inheritDoc */
+    get windowOpen(): boolean;
+    /** @inheritDoc */
+    get seasonTurnOff(): boolean;
+    /** @inheritDoc */
+    set seasonTurnOff(value: boolean);
+    /** @inheritDoc */
+    get desiredTemperature(): number;
+    /** @inheritDoc */
+    set desiredTemperature(val: number);
+    get sLevel(): string;
+    /** @inheritDoc */
+    get iLevel(): number;
+    /** @inheritDoc */
+    get iTemperature(): number;
+    /** @inheritDoc */
+    get sTemperature(): string;
+    /** @inheritDoc */
+    get roomTemperature(): number;
+    protected set roomTemperature(val: number);
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback: (action: TemperatureSensorChangeAction) => void): void;
+    /** @inheritDoc */
+    checkAutomaticChange(): void;
+    onHandleChange(_action: HandleChangeAction): void;
+    /** @inheritDoc */
+    onTemperaturChange(newTemperatur: number): void;
+    persistHeater(): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
+    protected getNextPidLevel(): number;
+    private checkSeasonTurnOff;
+    private onWindowOpenChange;
+}

package/lib/devices/zigbee/BaseDevices/zigbeeHeater.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeHeater = void 0;
+const interfaces_1 = require("../../../interfaces");
+const settingsObjects_1 = require("../../../settingsObjects");
+const sharedFunctions_1 = require("../../sharedFunctions");
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const utils_1 = require("../../../utils");
+const enums_1 = require("../../../enums");
+const liquid_pid_1 = require("../../../liquid-pid");
+const services_1 = require("../../../services");
+const models_1 = require("../../../models");
+class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
+    constructor(pInfo, pType) {
+        super(pInfo, pType);
+        /** @inheritDoc */
+        this.battery = new sharedFunctions_1.Battery(this);
+        /** @inheritDoc */
+        this.persistHeaterInterval = utils_1.Utils.guardedInterval(() => {
+            this.persistHeater();
+        }, 5 * 60 * 1000, this, false);
+        /** @inheritDoc */
+        this.temperatureSensor = new sharedFunctions_1.TemperatureSensor(this);
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.HeaterSettings();
+        this._battery = -99;
+        this._initialSeasonCheckDone = false;
+        this._level = 0;
+        this._setPointTemperaturID = '';
+        this._setWindowOpenID = '';
+        this._temperatur = interfaces_1.UNDEFINED_TEMP_VALUE;
+        this._desiredTemperatur = interfaces_1.UNDEFINED_TEMP_VALUE;
+        this._pidController = new liquid_pid_1.PIDController({
+            temp: {
+                ref: 20, // Point temperature
+            },
+            Pmax: 100, // Max power (output),
+            // Tune the PID Controller
+            Kp: 25, // PID: Kp in 1/1000
+            Ki: 1000, // PID: Ki in 1/1000
+            Kd: 9, // PID: Kd in 1/1000
+        });
+        this._seasonTurnOff = false;
+        this._windowOpen = false;
+        this.deviceCapabilities.push(enums_1.DeviceCapability.heater);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.temperatureSensor);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.batteryDriven);
+        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 batteryLevel() {
+        return this.battery.level;
+    }
+    /** @inheritDoc */
+    get windowOpen() {
+        return this._windowOpen;
+    }
+    /** @inheritDoc */
+    get seasonTurnOff() {
+        return this._seasonTurnOff;
+    }
+    /** @inheritDoc */
+    set seasonTurnOff(value) {
+        this._seasonTurnOff = value;
+    }
+    /** @inheritDoc */
+    get desiredTemperature() {
+        return this._desiredTemperatur;
+    }
+    /** @inheritDoc */
+    set desiredTemperature(val) {
+        this._desiredTemperatur = val;
+        this.setState(this._setPointTemperaturID, 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 iTemperature() {
+        if (this.settings.useOwnTemperatureForRoomTemperature) {
+            return this.temperatureSensor.temperature;
+        }
+        else {
+            return this.roomTemperature;
+        }
+    }
+    /** @inheritDoc */
+    get sTemperature() {
+        return `${this.iTemperature}°C`;
+    }
+    /** @inheritDoc */
+    get roomTemperature() {
+        return this.temperatureSensor.roomTemperature;
+    }
+    set roomTemperature(val) {
+        this.temperatureSensor.roomTemperature = val;
+    }
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback) {
+        this.temperatureSensor.addTempChangeCallback(pCallback);
+    }
+    /** @inheritDoc */
+    checkAutomaticChange() {
+        var _a;
+        if (!this._initialSeasonCheckDone) {
+            this.checkSeasonTurnOff();
+        }
+        const heatGroup = this.room.HeatGroup;
+        if (this.seasonTurnOff || this.settings.manualDisabled) {
+            this.desiredTemperature = 0;
+            return;
+        }
+        if (!this.settings.automaticMode || this.seasonTurnOff || ((_a = heatGroup === null || heatGroup === void 0 ? void 0 : heatGroup.settings) === null || _a === void 0 ? void 0 : _a.automaticMode) === false) {
+            return;
+        }
+        if (heatGroup === undefined) {
+            this.log(enums_1.LogLevel.Warn, `Heat-Group is undefined for ${this.info.customName}.`);
+            return;
+        }
+        const targetTemperature = heatGroup.desiredTemp;
+        if (this._desiredTemperatur !== targetTemperature) {
+            this.log(enums_1.LogLevel.Debug, `Automatische Temperaturanpassung für ${this.info.customName} auf ${targetTemperature}°C`);
+            this.desiredTemperature = targetTemperature;
+        }
+    }
+    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 */
+    onTemperaturChange(newTemperatur) {
+        this.roomTemperature = newTemperatur;
+    }
+    persistHeater() {
+        var _a;
+        (_a = this.dbo) === null || _a === void 0 ? void 0 : _a.persistHeater(this);
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, pOverride = false) {
+        switch (idSplit[3]) {
+            case 'battery':
+                this.battery.level = state.val;
+                if (this.batteryLevel < 20) {
+                    this.log(enums_1.LogLevel.Warn, 'Das Zigbee Gerät hat unter 20% Batterie.');
+                }
+                break;
+        }
+        super.update(idSplit, state, initial, pOverride);
+    }
+    /** @inheritDoc */
+    dispose() {
+        if (this.persistHeaterInterval) {
+            clearInterval(this.persistHeaterInterval);
+        }
+        if (this._iAutomaticInterval) {
+            clearInterval(this._iAutomaticInterval);
+            this._iAutomaticInterval = undefined;
+        }
+        super.dispose();
+    }
+    getNextPidLevel() {
+        if (this.seasonTurnOff || this.roomTemperature < 0) {
+            return 0;
+        }
+        this._pidController.setPoint(this.desiredTemperature);
+        const newValue = this._pidController.calculate(this.roomTemperature);
+        this.log(enums_1.LogLevel.Debug, `New PID Value ${newValue}% (cTemp: ${this.roomTemperature}, dTemp: ${this.desiredTemperature})`);
+        return newValue;
+    }
+    checkSeasonTurnOff() {
+        const desiredState = utils_1.Utils.beetweenDays(new Date(), this.settings.seasonTurnOffDay, this.settings.seasonTurnOnDay);
+        if (desiredState !== this.seasonTurnOff || !this._initialSeasonCheckDone) {
+            this.log(enums_1.LogLevel.Info, `Switching Seasonal Heating --> New seasonTurnOff: ${desiredState}`);
+            this.seasonTurnOff = desiredState;
+        }
+        this._initialSeasonCheckDone = true;
+    }
+    onWindowOpenChange(pValue) {
+        if (!this._setWindowOpenID) {
+            return;
+        }
+        this.setState(this._setWindowOpenID, pValue);
+    }
+}
+exports.ZigbeeHeater = ZigbeeHeater;

package/lib/devices/zigbee/BaseDevices/zigbeeLamp.d.ts

@@ -0,0 +1,16 @@
+import { ZigbeeActuator } from './ZigbeeActuator';
+import { iLamp, iTemporaryDisableAutomatic } from '../../../interfaces';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { DeviceType } from '../../../enums';
+import { LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../command';
+export declare abstract class ZigbeeLamp extends ZigbeeActuator implements iLamp, iTemporaryDisableAutomatic {
+    constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
+    /** @inheritDoc */
+    setTimeBased(c: LampSetTimeBasedCommand): void;
+    /** @inheritdoc */
+    setLight(c: LampSetLightCommand): void;
+    /** @inheritDoc */
+    toggleLight(c: LampToggleLightCommand): boolean;
+}

package/lib/devices/zigbee/BaseDevices/zigbeeLamp.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeLamp = void 0;
+const ZigbeeActuator_1 = require("./ZigbeeActuator");
+const enums_1 = require("../../../enums");
+const sharedFunctions_1 = require("../../sharedFunctions");
+class ZigbeeLamp extends ZigbeeActuator_1.ZigbeeActuator {
+    constructor(pInfo, deviceType) {
+        super(pInfo, deviceType);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.lamp);
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, handledByChildObject = false) {
+        if (!handledByChildObject) {
+            this.log(enums_1.LogLevel.DeepTrace, `Lamp Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        }
+        this.queuedValue = null;
+        this.log(enums_1.LogLevel.DeepTrace, `Lamp Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+    }
+    /** @inheritDoc */
+    setTimeBased(c) {
+        sharedFunctions_1.LampUtils.setTimeBased(this, c);
+    }
+    /** @inheritdoc */
+    setLight(c) {
+        super.setActuator(c);
+    }
+    /** @inheritDoc */
+    toggleLight(c) {
+        return sharedFunctions_1.LampUtils.toggleLight(this, c);
+    }
+}
+exports.ZigbeeLamp = ZigbeeLamp;

package/lib/devices/zigbee/BaseDevices/zigbeeLedRGBCCT.d.ts

@@ -0,0 +1,29 @@
+import { ZigbeeDimmer } from './zigbeeDimmer';
+import { iLedRgbCct } from '../../../interfaces/baseDevices/iLedRgbCct';
+import { LedSettings } from '../../../settingsObjects';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { DeviceType } from '../../../enums';
+import { ActuatorSetStateCommand, LampSetTimeBasedCommand, LedSetLightCommand } from '../../../command';
+export declare abstract class ZigbeeLedRGBCCT extends ZigbeeDimmer implements iLedRgbCct {
+    /** @inheritDoc */
+    settings: LedSettings;
+    protected abstract readonly _stateIdColor: string;
+    protected abstract readonly _stateIdColorTemp: string;
+    protected abstract readonly _stateNameColor: string;
+    protected abstract readonly _stateNameColorTemp: string;
+    protected constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    protected _color: string;
+    /** @inheritDoc */
+    get color(): string;
+    protected _colortemp: number;
+    /** @inheritDoc */
+    get colortemp(): number;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    setTimeBased(c: LampSetTimeBasedCommand): void;
+    /** @inheritDoc */
+    setActuator(c: ActuatorSetStateCommand): void;
+    /** @inheritDoc */
+    setLight(c: LedSetLightCommand): void;
+}

package/lib/devices/zigbee/BaseDevices/zigbeeLedRGBCCT.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeLedRGBCCT = void 0;
+const zigbeeDimmer_1 = require("./zigbeeDimmer");
+const settingsObjects_1 = require("../../../settingsObjects");
+const enums_1 = require("../../../enums");
+const command_1 = require("../../../command");
+const utils_1 = require("../../../utils");
+class ZigbeeLedRGBCCT extends zigbeeDimmer_1.ZigbeeDimmer {
+    constructor(pInfo, deviceType) {
+        super(pInfo, deviceType);
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.LedSettings();
+        this._color = '#fcba32';
+        this._colortemp = 500;
+        this.deviceCapabilities.push(enums_1.DeviceCapability.ledLamp);
+        // this.effectID = `${this.info.fullID}.effect`;
+    }
+    /** @inheritDoc */
+    get color() {
+        return this._color;
+    }
+    /** @inheritDoc */
+    get colortemp() {
+        return this._colortemp;
+    }
+    // private effectID: string = '';
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `LED Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial);
+        switch (idSplit[3]) {
+            case this._stateNameColor:
+                this.log(enums_1.LogLevel.Trace, `LED Color Update für ${this.info.customName} auf ${state.val}`);
+                this._color = state.val;
+                break;
+            case this._stateNameColorTemp:
+                this.log(enums_1.LogLevel.Trace, `LED Color Temp Update für ${this.info.customName} auf ${state.val}`);
+                this._colortemp = state.val;
+                break;
+        }
+    }
+    /** @inheritDoc */
+    setTimeBased(c) {
+        this.setLight(this.settings.buildLedSetLightCommand(c));
+    }
+    /** @inheritDoc */
+    setActuator(c) {
+        this.setLight(new command_1.LedSetLightCommand(c, c.on, '', c.disableAutomaticCommand));
+    }
+    /** @inheritDoc */
+    setLight(c) {
+        if (this._actuatorOnStateIdState === '') {
+            this.log(enums_1.LogLevel.Error, 'Keine State ID bekannt.');
+            return;
+        }
+        if (!this.ioConn) {
+            this.log(enums_1.LogLevel.Error, 'Keine Connection bekannt.');
+            return;
+        }
+        if (c.on && c.brightness === -1 && this.brightness < 10) {
+            c.brightness = 10;
+        }
+        super.setLight(c);
+        const formattedColor = utils_1.Utils.formatHex(c.color);
+        if (formattedColor !== null && c.on && (c.color !== this.color || c.isForceAction)) {
+            this.setState(this._stateIdColor, formattedColor);
+        }
+        if (c.colorTemp > -1 && c.on && (c.colorTemp !== this.colortemp || c.isForceAction)) {
+            this.setState(this._stateIdColorTemp, c.colorTemp);
+        }
+    }
+}
+exports.ZigbeeLedRGBCCT = ZigbeeLedRGBCCT;

package/lib/devices/zigbee/BaseDevices/zigbeeMagnetContact.d.ts

@@ -0,0 +1,32 @@
+import { ZigbeeDevice } from './zigbeeDevice';
+import { iBatteryDevice, iMagnetSensor } from '../../../interfaces';
+import { Battery } from '../../sharedFunctions';
+import { DeviceType, MagnetPosition } from '../../../enums';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+export declare class ZigbeeMagnetContact extends ZigbeeDevice implements iBatteryDevice, iMagnetSensor {
+    /** @inheritDoc */
+    readonly battery: Battery;
+    /** @inheritDoc */
+    position: MagnetPosition;
+    /** @inheritDoc */
+    telegramOnOpen: boolean;
+    /** @inheritDoc */
+    speakOnOpen: boolean;
+    protected _battery: number;
+    private _closedCallback;
+    private _openCallback;
+    private _iOpenTimeout;
+    private minutesOpen;
+    constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    /** @inheritDoc */
+    get batteryLevel(): number;
+    /** @inheritDoc */
+    addOpenCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
+    addClosedCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverrride?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
+    protected updatePosition(pValue: MagnetPosition): void;
+}