hoffmation-base 1.1.18 → 1.1.20

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

@@ -1,5 +1,5 @@
-import { DeviceSettings } from './deviceSettings';
-export declare class LedSettings extends DeviceSettings {
+import { DimmerSettings } from './dimmerSettings';
+export declare class LedSettings extends DimmerSettings {
     defaultColor: string;
     dayOn: boolean;
     dayBrightness: number;

package/lib/models/deviceSettings/ledSettings.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LedSettings = void 0;
-const deviceSettings_1 = require("./deviceSettings");
-class LedSettings extends deviceSettings_1.DeviceSettings {
+const dimmerSettings_1 = require("./dimmerSettings");
+class LedSettings extends dimmerSettings_1.DimmerSettings {
     constructor() {
         super(...arguments);
         this.defaultColor = '#fbbc32';

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

@@ -23,7 +23,7 @@ class LampenGroup extends base_group_1.BaseGroup {
             }
         }
         for (i = 0; i < this.getLED().length; i++) {
-            if (this.getLED()[i].on) {
+            if (this.getLED()[i].actuatorOn) {
                 return true;
             }
         }
@@ -126,7 +126,7 @@ class LampenGroup extends base_group_1.BaseGroup {
     }
     setAllLED(pValue, brightness = -1, color = '', colortemp = -1) {
         this.getLED().forEach((s) => {
-            s.setLight(pValue, brightness, color, colortemp);
+            s.setLight(pValue, undefined, true, brightness, undefined, color, colortemp);
         });
     }
     setAllWled(pValue, brightness = -1, preset) {

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

@@ -32,9 +32,9 @@ export declare class ZigbeeHeater extends ZigbeeDevice implements iHeater, iBatt
     get iLevel(): number;
     get sTemperatur(): string;
     get iTemperature(): number;
-    protected _roomTemperatur: number;
-    set roomTemperatur(val: number);
+    protected _roomTemperature: number;
     get roomTemperature(): number;
+    set roomTemperatur(val: number);
     checkAutomaticChange(): void;
     deleteAutomaticPoint(name: string): void;
     setAutomaticPoint(name: string, setting: TemperatureSettings): void;

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

@@ -33,7 +33,7 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
         });
         this._seasonTurnOff = false;
         this._humidity = 0;
-        this._roomTemperatur = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.heater);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
         this._iAutomaticInterval = services_1.Utils.guardedInterval(this.checkAutomaticChange, 300000, this); // Alle 5 Minuten prüfen
@@ -75,14 +75,14 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
             return this._temperatur;
         }
         else {
-            return this._roomTemperatur;
+            return this._roomTemperature;
         }
     }
-    set roomTemperatur(val) {
-        this._roomTemperatur = val;
-    }
     get roomTemperature() {
-        return this._roomTemperatur;
+        return this._roomTemperature;
+    }
+    set roomTemperatur(val) {
+        this._roomTemperature = val;
     }
     checkAutomaticChange() {
         var _a, _b;
@@ -141,8 +141,8 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
             return 0;
         }
         this._pidController.setPoint(this.desiredTemperature);
-        const newValue = this._pidController.calculate(this._roomTemperatur);
-        this.log(models_1.LogLevel.Debug, `New PID Value ${newValue}% (cTemp: ${this._roomTemperatur}, dTemp: ${this.desiredTemperature})`);
+        const newValue = this._pidController.calculate(this._roomTemperature);
+        this.log(models_1.LogLevel.Debug, `New PID Value ${newValue}% (cTemp: ${this._roomTemperature}, dTemp: ${this.desiredTemperature})`);
         return newValue;
     }
     checkSeasonTurnOff() {

package/lib/server/devices/zigbee/zigbeeEuroHeater.js

@@ -32,7 +32,7 @@ class ZigbeeEuroHeater extends BaseDevices_1.ZigbeeHeater {
         this.setMode(this.settings.controlByPid ? 1 : 2);
     }
     set roomTemperatur(value) {
-        this._roomTemperatur = value;
+        this._roomTemperature = value;
         if (this.settings.controlByPid) {
             //TODO: Implement PID controlling
             return;
@@ -43,7 +43,7 @@ class ZigbeeEuroHeater extends BaseDevices_1.ZigbeeHeater {
         this.recalcLevel();
     }
     get roomTemperature() {
-        return this._roomTemperatur;
+        return this._roomTemperature;
     }
     get desiredTemperature() {
         return this._desiredTemperatur;
@@ -127,7 +127,7 @@ class ZigbeeEuroHeater extends BaseDevices_1.ZigbeeHeater {
             return;
         }
         this._lastRecalc = services_1.Utils.nowMS();
-        const desiredDiff = services_1.Utils.round(this.desiredTemperature - this._roomTemperatur, 1);
+        const desiredDiff = services_1.Utils.round(this.desiredTemperature - this._roomTemperature, 1);
         const currentDiff = this.tempDiff;
         const missingDiff = services_1.Utils.round(desiredDiff - currentDiff, 1);
         if (Math.abs(missingDiff) < 0.15) {
@@ -143,7 +143,7 @@ class ZigbeeEuroHeater extends BaseDevices_1.ZigbeeHeater {
         }
         const newLocalDiff = Math.sign(desiredDiff) * -9;
         this.setLocalDiff(newLocalDiff);
-        this.setTargetTemperatur(this._temperatur + this._roomTemperatur + newLocalDiff + this.desiredTemperature);
+        this.setTargetTemperatur(this._temperatur + this._roomTemperature + newLocalDiff + this.desiredTemperature);
     }
     setLocalDiff(newLocalDiff) {
         this.log(models_1.LogLevel.Debug, `Setting new Local Calibration Diff (${newLocalDiff}) for Euro Valve`);

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

@@ -1,5 +1,6 @@
 /// <reference types="iobroker" />
 import { DimmerSettings, TimeOfDay } from '../../../models';
+import { DeviceType } from '../deviceType';
 import { ZigbeeDevice } from './BaseDevices';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 import { iDimmableLamp } from '../baseDeviceInterfaces/iDimmableLamp';
@@ -9,13 +10,13 @@ export declare class ZigbeeIlluDimmer extends ZigbeeDevice implements iDimmableL
     brightness: number;
     transitionTime: number;
     settings: DimmerSettings;
-    private stateID;
-    private brightnessID;
-    private transitionID;
+    protected readonly stateID: string;
+    protected readonly brightnessID: string;
+    protected readonly transitionID: string;
     private _turnOffTimeout;
     private turnOffTime;
     private _lastPersist;
-    constructor(pInfo: IoBrokerDeviceInfo);
+    constructor(pInfo: IoBrokerDeviceInfo, deviceType?: DeviceType);
     get actuatorOn(): boolean;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;

package/lib/server/devices/zigbee/zigbeeIlluDimmer.js

@@ -7,8 +7,8 @@ const services_1 = require("../../services");
 const BaseDevices_1 = require("./BaseDevices");
 const DeviceCapability_1 = require("../DeviceCapability");
 class ZigbeeIlluDimmer extends BaseDevices_1.ZigbeeDevice {
-    constructor(pInfo) {
-        super(pInfo, deviceType_1.DeviceType.ZigbeeIlluDimmer);
+    constructor(pInfo, deviceType = deviceType_1.DeviceType.ZigbeeIlluDimmer) {
+        super(pInfo, deviceType);
         this.lightOn = false;
         this.queuedValue = null;
         this.brightness = 0;

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

@@ -1,21 +1,16 @@
 /// <reference types="iobroker" />
 import { LedSettings, TimeOfDay } from '../../../models';
-import { ZigbeeDevice } from './BaseDevices';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
-export declare class ZigbeeIlluLedRGBCCT extends ZigbeeDevice {
+import { ZigbeeIlluDimmer } from './zigbeeIlluDimmer';
+export declare class ZigbeeIlluLedRGBCCT extends ZigbeeIlluDimmer {
     static DEFAULT_COLOR_WARM: string;
-    on: boolean;
-    brightness: number;
     color: string;
     colortemp: number;
     settings: LedSettings;
-    private stateID;
-    private brightnessID;
     private colorID;
     private colorTempID;
     constructor(pInfo: IoBrokerDeviceInfo);
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    setTimeBased(time: TimeOfDay): void;
-    setLight(pValue: boolean, brightness?: number, color?: string, colortemp?: number): void;
-    toggleLight(): boolean;
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number, color?: string, colorTemp?: number): void;
 }

package/lib/server/devices/zigbee/zigbeeIlluLedRGBCCT.js

@@ -3,38 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeIlluLedRGBCCT = void 0;
 const deviceType_1 = require("../deviceType");
 const models_1 = require("../../../models");
-const BaseDevices_1 = require("./BaseDevices");
-class ZigbeeIlluLedRGBCCT extends BaseDevices_1.ZigbeeDevice {
+const zigbeeIlluDimmer_1 = require("./zigbeeIlluDimmer");
+class ZigbeeIlluLedRGBCCT extends zigbeeIlluDimmer_1.ZigbeeIlluDimmer {
     // private effectID: string = '';
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeIlluLedRGBCCT);
-        this.on = false;
-        this.brightness = 0;
         this.color = '#fcba32';
         this.colortemp = 500;
         this.settings = new models_1.LedSettings();
-        this.stateID = 'state';
-        this.brightnessID = 'brightness';
         this.colorID = '';
         this.colorTempID = '';
-        this.stateID = `${this.info.fullID}.state`;
-        this.brightnessID = `${this.info.fullID}.brightness`;
         this.colorID = `${this.info.fullID}.color`;
         this.colorTempID = `${this.info.fullID}.colortemp`;
         // this.effectID = `${this.info.fullID}.effect`;
     }
     update(idSplit, state, initial = false) {
         this.log(models_1.LogLevel.DeepTrace, `LED Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
-        super.update(idSplit, state, initial, true);
+        super.update(idSplit, state, initial);
         switch (idSplit[3]) {
-            case 'state':
-                this.log(models_1.LogLevel.Trace, `LED Update für ${this.info.customName} auf ${state.val}`);
-                this.on = state.val;
-                break;
-            case 'brightness':
-                this.log(models_1.LogLevel.Trace, `LED Helligkeit Update für ${this.info.customName} auf ${state.val}`);
-                this.brightness = state.val;
-                break;
             case 'color':
                 this.log(models_1.LogLevel.Trace, `LED Color Update für ${this.info.customName} auf ${state.val}`);
                 this.color = state.val;
@@ -45,31 +31,31 @@ class ZigbeeIlluLedRGBCCT extends BaseDevices_1.ZigbeeDevice {
                 break;
         }
     }
-    setTimeBased(time) {
+    setTimeBased(time, timeout = -1, force = false) {
         switch (time) {
             case models_1.TimeOfDay.Night:
                 if (this.settings.nightOn) {
-                    this.setLight(true, this.settings.nightBrightness, this.settings.nightColor, this.settings.nightColorTemp);
+                    this.setLight(true, timeout, force, this.settings.nightBrightness, undefined, this.settings.nightColor, this.settings.nightColorTemp);
                 }
                 break;
             case models_1.TimeOfDay.AfterSunset:
                 if (this.settings.duskOn) {
-                    this.setLight(true, this.settings.duskBrightness, this.settings.duskColor, this.settings.duskColorTemp);
+                    this.setLight(true, timeout, force, this.settings.duskBrightness, undefined, this.settings.duskColor, this.settings.duskColorTemp);
                 }
                 break;
             case models_1.TimeOfDay.BeforeSunrise:
                 if (this.settings.dawnOn) {
-                    this.setLight(true, this.settings.dawnBrightness, this.settings.dawnColor, this.settings.dawnColorTemp);
+                    this.setLight(true, timeout, force, this.settings.dawnBrightness, undefined, this.settings.dawnColor, this.settings.dawnColorTemp);
                 }
                 break;
             case models_1.TimeOfDay.Daylight:
                 if (this.settings.dayOn) {
-                    this.setLight(true, this.settings.dayBrightness, this.settings.dayColor, this.settings.dayColorTemp);
+                    this.setLight(true, timeout, force, this.settings.dayBrightness, undefined, this.settings.dayColor, this.settings.dayColorTemp);
                 }
                 break;
         }
     }
-    setLight(pValue, brightness = -1, color = '', colortemp = -1) {
+    setLight(pValue, timeout, force, brightness = -1, transitionTime, color = '', colorTemp = -1) {
         if (this.stateID === '') {
             this.log(models_1.LogLevel.Error, `Keine State ID bekannt.`);
             return;
@@ -81,7 +67,8 @@ class ZigbeeIlluLedRGBCCT extends BaseDevices_1.ZigbeeDevice {
         if (pValue && brightness === -1 && this.brightness < 10) {
             brightness = 10;
         }
-        this.log(models_1.LogLevel.Debug, `LED Schalten An: ${pValue}\tHelligkeit: ${brightness}%\tFarbe: "${color}"\tColorTemperatur: ${colortemp}`);
+        this.log(models_1.LogLevel.Debug, `LED Schalten An: ${pValue}\tHelligkeit: ${brightness}%\tFarbe: "${color}"\tColorTemperatur: ${colorTemp}`);
+        super.setLight(pValue, timeout, force, brightness, transitionTime);
         if (color !== '') {
             this.ioConn.setState(this.colorID, color, (err) => {
                 if (err) {
@@ -89,8 +76,8 @@ class ZigbeeIlluLedRGBCCT extends BaseDevices_1.ZigbeeDevice {
                 }
             });
         }
-        if (colortemp > -1) {
-            this.ioConn.setState(this.colorTempID, colortemp, (err) => {
+        if (colorTemp > -1) {
+            this.ioConn.setState(this.colorTempID, colorTemp, (err) => {
                 if (err) {
                     this.log(models_1.LogLevel.Error, `LED Farbwärme schalten ergab Fehler: ${err}`);
                 }
@@ -101,18 +88,6 @@ class ZigbeeIlluLedRGBCCT extends BaseDevices_1.ZigbeeDevice {
                 this.log(models_1.LogLevel.Error, `LED schalten ergab Fehler: ${err}`);
             }
         });
-        if (brightness > -1) {
-            this.ioConn.setState(this.brightnessID, brightness, (err) => {
-                if (err) {
-                    this.log(models_1.LogLevel.Error, `LED Helligkeit schalten ergab Fehler: ${err}`);
-                }
-            });
-        }
-    }
-    toggleLight() {
-        const newVal = !this.on;
-        this.setLight(newVal);
-        return newVal;
     }
 }
 exports.ZigbeeIlluLedRGBCCT = ZigbeeIlluLedRGBCCT;

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

@@ -10,8 +10,8 @@ export declare class ZigbeeTuyaValve extends ZigbeeHeater {
     private _mode;
     constructor(pInfo: IoBrokerDeviceInfo);
     set seasonTurnOff(value: boolean);
-    set roomTemperatur(value: number);
     get roomTemperatur(): number;
+    set roomTemperatur(value: number);
     set desiredTemperature(val: number);
     private get tempDiff();
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;

package/lib/server/devices/zigbee/zigbeeTuyaValve.js

@@ -21,16 +21,16 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         this._seasonTurnOff = value;
         this.setMode(value ? 'off' : 'auto');
     }
+    get roomTemperatur() {
+        return this._roomTemperature;
+    }
     set roomTemperatur(value) {
-        this._roomTemperatur = value;
+        this._roomTemperature = value;
         if (this.settings.useOwnTemperatur) {
             return;
         }
         this.checkTempDiff();
     }
-    get roomTemperatur() {
-        return this._roomTemperatur;
-    }
     set desiredTemperature(val) {
         this._desiredTemperatur = val;
         this.checkTempDiff();
@@ -76,7 +76,7 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         if (this.settings.useOwnTemperatur) {
             return;
         }
-        const desiredDiff = services_1.Utils.round(this.desiredTemperature - this._roomTemperatur, 1);
+        const desiredDiff = services_1.Utils.round(this.desiredTemperature - this._roomTemperature, 1);
         const currentDiff = this.tempDiff;
         const missingDiff = services_1.Utils.round(desiredDiff - currentDiff, 1);
         if (Math.abs(missingDiff) < 0.15) {
@@ -92,7 +92,7 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         }
         const newLocalDiff = Math.sign(desiredDiff) * -9;
         this.setLocalDiff(newLocalDiff);
-        this.setTargetTemperatur(this._localTempVal + this._roomTemperatur + newLocalDiff + this.desiredTemperature);
+        this.setTargetTemperatur(this._localTempVal + this._roomTemperature + newLocalDiff + this.desiredTemperature);
     }
     setLocalDiff(newLocalDiff) {
         this.log(models_1.LogLevel.Debug, `Setting new Local Calibration Diff (${newLocalDiff}) for Tuya Valve`);

package/lib/server/services/ac/ac-device.d.ts

@@ -14,10 +14,10 @@ export declare abstract class AcDevice implements iExcessEnergyConsumer, iRoomDe
     room: RoomBase | undefined;
     deviceCapabilities: DeviceCapability[];
     protected _info: DeviceInfo;
-    get roomTemperature(): number;
-    protected constructor(name: string, roomName: string, ip: string, acDeviceType: AcDeviceType);
     get temperature(): number;
-    private _roomTemperatur;
+    protected constructor(name: string, roomName: string, ip: string, acDeviceType: AcDeviceType);
+    private _roomTemperature;
+    get roomTemperature(): number;
     get info(): DeviceInfo;
     protected set roomTemperatur(val: number);
     set info(info: DeviceInfo);

package/lib/server/services/ac/ac-device.js

@@ -22,7 +22,7 @@ class AcDevice {
         this.energyConsumerSettings = new models_1.ExcessEnergyConsumerSettings();
         this.acSettings = new acSettings_1.AcSettings();
         this.deviceCapabilities = [DeviceCapability_1.DeviceCapability.ac];
-        this._roomTemperatur = 0;
+        this._roomTemperature = 0;
         this._activatedByExcessEnergy = false;
         this._blockAutomaticTurnOnMS = -1;
         this._info = new devices_1.DeviceInfo();
@@ -34,17 +34,17 @@ class AcDevice {
         utils_1.Utils.guardedInterval(this.persist, 15 * 60 * 1000, this, true);
         this.persistDeviceInfo();
     }
-    get roomTemperature() {
-        return this._roomTemperatur;
-    }
     get temperature() {
-        return this._roomTemperatur;
+        return this._roomTemperature;
+    }
+    get roomTemperature() {
+        return this._roomTemperature;
     }
     get info() {
         return this._info;
     }
     set roomTemperatur(val) {
-        this._roomTemperatur = val;
+        this._roomTemperature = val;
     }
     set info(info) {
         this._info = info;