hoffmation-base 1.0.16 → 1.0.17

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

@@ -5,12 +5,12 @@ export declare class AcSettings extends DeviceSettings {
     maximumHours: number;
     maximumMinutes: number;
     /**
-     * The temperatur below which cooling should be stopped
+     * The temperature below which cooling should be stopped
      * @type {number}
      */
     stopCoolingTemperatur: number;
     /**
-     * The temperatur above which heating should be stopped
+     * The temperature above which heating should be stopped
      * @type {number}
      */
     stopHeatingTemperatur: number;

package/lib/models/deviceSettings/acSettings.js

@@ -10,12 +10,12 @@ class AcSettings extends deviceSettings_1.DeviceSettings {
         this.maximumHours = 24;
         this.maximumMinutes = 0;
         /**
-         * The temperatur below which cooling should be stopped
+         * The temperature below which cooling should be stopped
          * @type {number}
          */
         this.stopCoolingTemperatur = 22;
         /**
-         * The temperatur above which heating should be stopped
+         * The temperature above which heating should be stopped
          * @type {number}
          */
         this.stopHeatingTemperatur = 21.0;

package/lib/models/index.d.ts

@@ -7,5 +7,5 @@ export * from './deviceConfig';
 export * from './excessEnergyConsumerSettings';
 export * from './iTemperaturDataPoint';
 export * from './logLevel';
-export * from './temperaturSettings';
+export * from './temperatureSettings';
 export * from './timeCallback';

package/lib/models/index.js

@@ -23,5 +23,5 @@ __exportStar(require("./deviceConfig"), exports);
 __exportStar(require("./excessEnergyConsumerSettings"), exports);
 __exportStar(require("./iTemperaturDataPoint"), exports);
 __exportStar(require("./logLevel"), exports);
-__exportStar(require("./temperaturSettings"), exports);
+__exportStar(require("./temperatureSettings"), exports);
 __exportStar(require("./timeCallback"), exports);

package/lib/models/temperatureSettings.d.ts

@@ -0,0 +1,12 @@
+import { Daytime } from './daytime';
+export declare class TemperatureSettings {
+    start: Daytime;
+    end: Daytime;
+    temperature: number;
+    active: boolean;
+    constructor(start: Daytime, end: Daytime, temperature: number, active?: boolean);
+    static getActiveSetting(settings: {
+        [name: string]: TemperatureSettings;
+    }, date: Date): TemperatureSettings | undefined;
+    isNowInRange(date: Date): boolean;
+}

package/lib/models/{temperaturSettings.js → temperatureSettings.js}

@@ -1,22 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemperaturSettings = void 0;
-class TemperaturSettings {
-    constructor(start, end, temperatur, active = true) {
+exports.TemperatureSettings = void 0;
+class TemperatureSettings {
+    constructor(start, end, temperature, active = true) {
         this.start = start;
         this.end = end;
-        this.temperatur = temperatur;
+        this.temperature = temperature;
         this.active = active;
     }
-    isNowInRange(date) {
-        const now = date.getTime();
-        const todayStart = new Date(now).setHours(this.start.hour, this.start.minute);
-        if (now < todayStart) {
-            return false;
-        }
-        const todayEnd = new Date(now).setHours(this.end.hour, this.end.minute);
-        return now < todayEnd;
-    }
     static getActiveSetting(settings, date) {
         for (const name of Object.keys(settings)) {
             if (settings[name] === undefined) {
@@ -28,5 +19,14 @@ class TemperaturSettings {
             }
         }
     }
+    isNowInRange(date) {
+        const now = date.getTime();
+        const todayStart = new Date(now).setHours(this.start.hour, this.start.minute);
+        if (now < todayStart) {
+            return false;
+        }
+        const todayEnd = new Date(now).setHours(this.end.hour, this.end.minute);
+        return now < todayEnd;
+    }
 }
-exports.TemperaturSettings = TemperaturSettings;
+exports.TemperatureSettings = TemperatureSettings;

package/lib/server/devices/Heizgruppen.js

@@ -30,13 +30,13 @@ class Heizgruppen {
         response.push(`Raumname\t\tIst-Temperatur\t\tGerät`);
         for (const g of groups) {
             const heizungen = g.getBelongingHeizungen();
-            const tempProblem = [`${g.info.room}\t\t${g.iTemperatur}°C\t\t${g.info.customName}`];
+            const tempProblem = [`${g.info.room}\t\t${g.iTemperature}°C\t\t${g.info.customName}`];
             let print = false;
             for (const h of heizungen) {
-                if (h.iTemperatur !== g.iTemperatur) {
+                if (h.iTemperature !== g.iTemperature) {
                     print = true;
                 }
-                tempProblem.push(`${h.info.room}\t\t${h.iTemperatur}°C\t\t${h.info.customName}`);
+                tempProblem.push(`${h.info.room}\t\t${h.iTemperature}°C\t\t${h.info.customName}`);
             }
             if (print) {
                 response.push(tempProblem.join('\n'));

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

@@ -1,14 +1,14 @@
-import { HeaterSettings, TemperaturSettings } from '../../../models';
+import { HeaterSettings, TemperatureSettings } from '../../../models';
 import { IBaseDevice } from './iBaseDevice';
 export interface iHeater extends IBaseDevice {
     settings: HeaterSettings;
-    readonly desiredTemperatur: number;
+    readonly desiredTemperature: number;
     readonly humidity: number;
     readonly iLevel: number;
-    readonly iTemperatur: number;
+    readonly iTemperature: number;
     set seasonTurnOff(value: boolean);
     deleteAutomaticPoint(name: string): void;
-    setAutomaticPoint(name: string, setting: TemperaturSettings): void;
+    setAutomaticPoint(name: string, setting: TemperatureSettings): void;
     stopAutomaticCheck(): void;
     checkAutomaticChange(): void;
     onTemperaturChange(newTemperatur: number): void;

package/lib/server/devices/baseDeviceInterfaces/{iTemperaturSensor.d.ts → iTemperatureSensor.d.ts}

@@ -1,7 +1,7 @@
 import { IBaseDevice } from './iBaseDevice';
 export declare const UNDEFINED_TEMP_VALUE = -99;
-export interface iTemperaturSensor extends IBaseDevice {
-    iTemperatur: number;
-    sTemperatur: string;
+export interface iTemperatureSensor extends IBaseDevice {
+    iTemperature: number;
+    sTemperature: string;
     addTempChangeCallback(pCallback: (pValue: number) => void): void;
 }

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

@@ -8,5 +8,5 @@ export * from './iIlluminationSensor';
 export * from './iLamp';
 export * from './iMotionSensor';
 export * from './iShutter';
-export * from './iTemperaturSensor';
+export * from './iTemperatureSensor';
 export * from './iVibrationSensor';

package/lib/server/devices/baseDeviceInterfaces/index.js

@@ -24,5 +24,5 @@ __exportStar(require("./iIlluminationSensor"), exports);
 __exportStar(require("./iLamp"), exports);
 __exportStar(require("./iMotionSensor"), exports);
 __exportStar(require("./iShutter"), exports);
-__exportStar(require("./iTemperaturSensor"), exports);
+__exportStar(require("./iTemperatureSensor"), exports);
 __exportStar(require("./iVibrationSensor"), exports);

package/lib/server/devices/device-cluster.js

@@ -86,7 +86,7 @@ class DeviceCluster {
                 clusterTypes.push(device_cluster_type_1.DeviceClusterType.Outlets);
                 break;
             case deviceType_1.DeviceType.ZigbeeIlluActuator: // Dependent on use case
-            case deviceType_1.DeviceType.HmIpTherm: // Humidity and temperatur not yet implemented
+            case deviceType_1.DeviceType.HmIpTherm: // Humidity and temperature not yet implemented
             case deviceType_1.DeviceType.HmIpHeizung: // Setting/Controlling via HM-Ip Heizgruppe
             case deviceType_1.DeviceType.unknown:
             case deviceType_1.DeviceType.Wled: // TODO: Implement

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

@@ -1,5 +1,5 @@
 import { BaseGroup } from './base-group';
-import { iHeater, iHumiditySensor, iTemperaturSensor } from '../baseDeviceInterfaces';
+import { iHeater, iHumiditySensor, iTemperatureSensor } from '../baseDeviceInterfaces';
 import { AcDevice } from '../../services';
 export declare class HeatGroup extends BaseGroup {
     constructor(roomName: string, heaterIds: string[], tempSensorIds: string[], humiditySensorIds: string[], acIds: string[]);
@@ -16,7 +16,7 @@ export declare class HeatGroup extends BaseGroup {
     get desiredTemp(): number;
     static getInfo(): string;
     getHeater(): iHeater[];
-    getTempSensors(): iTemperaturSensor[];
+    getTempSensors(): iTemperatureSensor[];
     getHumiditySensors(): iHumiditySensor[];
     getOwnAcDevices(): AcDevice[];
     initialize(): void;

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

@@ -45,7 +45,7 @@ class HeatGroup extends base_group_1.BaseGroup {
         let temp = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         let count = 0;
         this.getTempSensors().forEach((sensor) => {
-            const sensorValue = sensor.iTemperatur;
+            const sensorValue = sensor.iTemperature;
             if (sensorValue === baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
                 return;
             }
@@ -60,7 +60,7 @@ class HeatGroup extends base_group_1.BaseGroup {
             if (!heaterAsSensor.settings.useOwnTemperatur) {
                 return;
             }
-            const sensorValue = heaterAsSensor.iTemperatur;
+            const sensorValue = heaterAsSensor.iTemperature;
             if (sensorValue === baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
                 return;
             }
@@ -79,7 +79,7 @@ class HeatGroup extends base_group_1.BaseGroup {
         }
         let value = 0;
         for (const h of this.getHeater()) {
-            value += h.desiredTemperatur;
+            value += h.desiredTemperature;
         }
         return Math.round((value / this.getHeater().length) * 10) / 10;
     }
@@ -94,7 +94,7 @@ class HeatGroup extends base_group_1.BaseGroup {
         const response = [`Dies sind die aktuellen Informationen der Heizungen:`];
         response.push(`Name\t\tLuft Feuchtigkeit\t\tAktuelle Temperatur\t\tSoll Temperatur\t\tVentilstellung`);
         for (const r of rooms) {
-            response.push(`${r.roomName}:\t\t${(_a = r.HeatGroup) === null || _a === void 0 ? void 0 : _a.humidity}%\t\t${(_b = r.HeatGroup) === null || _b === void 0 ? void 0 : _b.temperature}\t\t${(_c = r.HeatGroup) === null || _c === void 0 ? void 0 : _c.desiredTemp}°C`);
+            response.push(`${r.roomName}:\t\t${(_a = r.HeatGroup) === null || _a === void 0 ? void 0 : _a.humidity}%\t\t${(_b = r.HeatGroup) === null || _b === void 0 ? void 0 : _b.temperature}°C\t\t${(_c = r.HeatGroup) === null || _c === void 0 ? void 0 : _c.desiredTemp}°C`);
         }
         return response.join('\n');
     }

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

@@ -1,40 +1,40 @@
 /// <reference types="iobroker" />
 import { HmIPDevice } from './hmIpDevice';
 import { DeviceInfo } from '../DeviceInfo';
-import { HeaterSettings, TemperaturSettings } from '../../../models';
-import { iHeater, iHumiditySensor, iTemperaturSensor } from '../baseDeviceInterfaces';
-export declare class HmIpHeizgruppe extends HmIPDevice implements iTemperaturSensor, iHumiditySensor, iHeater {
+import { HeaterSettings, TemperatureSettings } from '../../../models';
+import { iHeater, iHumiditySensor, iTemperatureSensor } from '../baseDeviceInterfaces';
+export declare class HmIpHeizgruppe extends HmIPDevice implements iTemperatureSensor, iHumiditySensor, iHeater {
     settings: HeaterSettings;
     private _iAutomaticInterval;
     private _initialSeasonCheckDone;
     private _level;
-    private _setPointTemperaturID;
+    private _setPointTemperatureID;
     private _automaticPoints;
     private _humidityCallbacks;
-    private _temperaturCallbacks;
+    private _temperatureCallbacks;
     constructor(pInfo: DeviceInfo);
     protected _seasonTurnOff: boolean;
     get seasonTurnOff(): boolean;
     set seasonTurnOff(value: boolean);
-    private _temperatur;
-    get temperatur(): number;
-    private set temperatur(value);
+    private _temperature;
+    get temperature(): number;
+    private set temperature(value);
     private _humidity;
     get humidity(): number;
     private set humidity(value);
-    private _desiredTemperatur;
-    get desiredTemperatur(): number;
-    set desiredTemperatur(val: number);
+    private _desiredTemperature;
+    get desiredTemperature(): number;
+    set desiredTemperature(val: number);
     get sLevel(): string;
     get iLevel(): number;
-    get sTemperatur(): string;
-    get iTemperatur(): number;
+    get sTemperature(): string;
+    get iTemperature(): number;
     private _roomTemperatur;
     private set roomTemperatur(value);
     addHumidityCallback(pCallback: (pValue: number) => void): void;
     deleteAutomaticPoint(name: string): void;
     getBelongingHeizungen(): iHeater[];
-    setAutomaticPoint(name: string, setting: TemperaturSettings): void;
+    setAutomaticPoint(name: string, setting: TemperatureSettings): void;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     stopAutomaticCheck(): void;
     checkAutomaticChange(): void;

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

@@ -13,16 +13,16 @@ class HmIpHeizgruppe extends hmIpDevice_1.HmIPDevice {
         this.settings = new models_1.HeaterSettings();
         this._initialSeasonCheckDone = false;
         this._level = 0;
-        this._setPointTemperaturID = '';
+        this._setPointTemperatureID = '';
         this._automaticPoints = {};
         this._humidityCallbacks = [];
-        this._temperaturCallbacks = [];
+        this._temperatureCallbacks = [];
         this._seasonTurnOff = false;
-        this._temperatur = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._temperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         this._humidity = baseDeviceInterfaces_1.UNDEFINED_HUMIDITY_VALUE;
-        this._desiredTemperatur = 0;
+        this._desiredTemperature = 0;
         this._roomTemperatur = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
-        this._setPointTemperaturID = `${this.info.fullID}.1.SET_POINT_TEMPERATURE`;
+        this._setPointTemperatureID = `${this.info.fullID}.1.SET_POINT_TEMPERATURE`;
         this._iAutomaticInterval = services_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`, models_1.TimeCallbackType.TimeOfDay, () => {
             this.checkSeasonTurnOff();
@@ -34,21 +34,21 @@ class HmIpHeizgruppe extends hmIpDevice_1.HmIPDevice {
     set seasonTurnOff(value) {
         this._seasonTurnOff = value;
         if (value) {
-            this.setState(this._setPointTemperaturID, 5);
+            this.setState(this._setPointTemperatureID, 5);
         }
         else {
-            this.setState(this._setPointTemperaturID, this.desiredTemperatur);
+            this.setState(this._setPointTemperatureID, this.desiredTemperature);
         }
     }
-    get temperatur() {
+    get temperature() {
         if (this.settings.useOwnTemperatur) {
-            return this._temperatur;
+            return this._temperature;
         }
         return this._roomTemperatur;
     }
-    set temperatur(val) {
-        this._temperatur = val;
-        for (const cb of this._temperaturCallbacks) {
+    set temperature(val) {
+        this._temperature = val;
+        for (const cb of this._temperatureCallbacks) {
             cb(val);
         }
     }
@@ -61,11 +61,11 @@ class HmIpHeizgruppe extends hmIpDevice_1.HmIPDevice {
             cb(val);
         }
     }
-    get desiredTemperatur() {
-        return this._desiredTemperatur;
+    get desiredTemperature() {
+        return this._desiredTemperature;
     }
-    set desiredTemperatur(val) {
-        this.setState(this._setPointTemperaturID, this.seasonTurnOff ? 5 : val, () => {
+    set desiredTemperature(val) {
+        this.setState(this._setPointTemperatureID, this.seasonTurnOff ? 5 : val, () => {
             this.log(models_1.LogLevel.Info, `Changed temperature of to "${val}.`);
         }, (err) => {
             this.log(models_1.LogLevel.Error, `Temperaturänderung ergab Fehler ${err}.`);
@@ -77,11 +77,11 @@ class HmIpHeizgruppe extends hmIpDevice_1.HmIPDevice {
     get iLevel() {
         return this._level;
     }
-    get sTemperatur() {
-        return `${this.temperatur}°C`;
+    get sTemperature() {
+        return `${this.temperature}°C`;
     }
-    get iTemperatur() {
-        return this.temperatur;
+    get iTemperature() {
+        return this.temperature;
     }
     set roomTemperatur(value) {
         this._roomTemperatur = value;
@@ -129,22 +129,22 @@ class HmIpHeizgruppe extends hmIpDevice_1.HmIPDevice {
             (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.addTemperaturDataPoint(this);
             return;
         }
-        const setting = models_1.TemperaturSettings.getActiveSetting(this._automaticPoints, new Date());
+        const setting = models_1.TemperatureSettings.getActiveSetting(this._automaticPoints, new Date());
         if (setting === undefined) {
             this.log(models_1.LogLevel.Warn, `Undefined Heating Timestamp.`);
-            this.desiredTemperatur = this.settings.automaticFallBackTemperatur;
+            this.desiredTemperature = this.settings.automaticFallBackTemperatur;
             return;
         }
-        if (this._desiredTemperatur !== setting.temperatur) {
-            this.log(models_1.LogLevel.Debug, `Automatische Temperaturanpassung für ${this.info.customName} auf ${setting.temperatur}°C`);
-            this.desiredTemperatur = (_b = setting.temperatur) !== null && _b !== void 0 ? _b : this.settings.automaticFallBackTemperatur;
+        if (this._desiredTemperature !== setting.temperature) {
+            this.log(models_1.LogLevel.Debug, `Automatische Temperaturanpassung für ${this.info.customName} auf ${setting.temperature}°C`);
+            this.desiredTemperature = (_b = setting.temperature) !== null && _b !== void 0 ? _b : this.settings.automaticFallBackTemperatur;
         }
         (_c = services_1.Utils.dbo) === null || _c === void 0 ? void 0 : _c.addTemperaturDataPoint(this);
     }
     addTempChangeCallback(pCallback) {
-        this._temperaturCallbacks.push(pCallback);
-        if (this._temperatur > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
-            pCallback(this._temperatur);
+        this._temperatureCallbacks.push(pCallback);
+        if (this._temperature > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
+            pCallback(this._temperature);
         }
     }
     onTemperaturChange(newTemperatur) {
@@ -153,7 +153,7 @@ class HmIpHeizgruppe extends hmIpDevice_1.HmIPDevice {
     updateBaseInformation(name, state) {
         switch (name) {
             case 'ACTUAL_TEMPERATURE':
-                this.temperatur = state.val;
+                this.temperature = state.val;
                 break;
             case 'LEVEL':
                 this._level = state.val;
@@ -163,7 +163,7 @@ class HmIpHeizgruppe extends hmIpDevice_1.HmIPDevice {
                 break;
             case 'SET_POINT_TEMPERATURE':
                 this.log(models_1.LogLevel.DeepTrace, `Heizgruppe Update Soll-Temperatur JSON: ${JSON.stringify(state)}`);
-                this._desiredTemperatur = state.val;
+                this._desiredTemperature = state.val;
                 break;
         }
     }

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

@@ -1,37 +1,37 @@
 /// <reference types="node" />
 import { ZigbeeDevice } from './zigbeeDevice';
 import { iHeater } from '../../baseDeviceInterfaces';
-import { HeaterSettings, TemperaturSettings } from '../../../../models';
+import { HeaterSettings, TemperatureSettings } from '../../../../models';
 import { DeviceInfo } from '../../DeviceInfo';
 import { DeviceType } from '../../deviceType';
 export declare class ZigbeeHeater extends ZigbeeDevice implements iHeater {
     settings: HeaterSettings;
     protected _automaticPoints: {
-        [name: string]: TemperaturSettings;
+        [name: string]: TemperatureSettings;
     };
     protected _iAutomaticInterval: NodeJS.Timeout | undefined;
     protected _initialSeasonCheckDone: boolean;
     protected _level: number;
     protected _setPointTemperaturID: string;
     protected _temperatur: number;
+    protected _desiredTemperatur: number;
     constructor(pInfo: DeviceInfo, pType: DeviceType);
     protected _seasonTurnOff: boolean;
     get seasonTurnOff(): boolean;
     set seasonTurnOff(value: boolean);
-    protected _desiredTemperatur: number;
-    get desiredTemperatur(): number;
-    set desiredTemperatur(val: number);
+    get desiredTemperature(): number;
+    set desiredTemperature(val: number);
     protected _humidity: number;
     get humidity(): number;
     get sLevel(): string;
     get iLevel(): number;
     get sTemperatur(): string;
-    get iTemperatur(): number;
+    get iTemperature(): number;
     protected _roomTemperatur: number;
     protected set roomTemperatur(val: number);
     checkAutomaticChange(): void;
     deleteAutomaticPoint(name: string): void;
-    setAutomaticPoint(name: string, setting: TemperaturSettings): void;
+    setAutomaticPoint(name: string, setting: TemperatureSettings): void;
     stopAutomaticCheck(): void;
     onTemperaturChange(newTemperatur: number): void;
     private checkSeasonTurnOff;

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

@@ -14,8 +14,8 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
         this._level = 0;
         this._setPointTemperaturID = '';
         this._temperatur = 0;
-        this._seasonTurnOff = false;
         this._desiredTemperatur = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._seasonTurnOff = false;
         this._humidity = 0;
         this._roomTemperatur = 0;
         this._iAutomaticInterval = services_1.Utils.guardedInterval(this.checkAutomaticChange, 300000, this); // Alle 5 Minuten prüfen
@@ -29,10 +29,10 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
     set seasonTurnOff(value) {
         this._seasonTurnOff = value;
     }
-    get desiredTemperatur() {
+    get desiredTemperature() {
         return this._desiredTemperatur;
     }
-    set desiredTemperatur(val) {
+    set desiredTemperature(val) {
         this._desiredTemperatur = val;
         this.setState(this._setPointTemperaturID, val, () => {
             this.log(models_1.LogLevel.Info, `Changed temperature of to "${val}.`);
@@ -50,9 +50,9 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
         return this._level;
     }
     get sTemperatur() {
-        return `${this.iTemperatur}°C`;
+        return `${this.iTemperature}°C`;
     }
-    get iTemperatur() {
+    get iTemperature() {
         if (this.settings.useOwnTemperatur) {
             return this._temperatur;
         }
@@ -72,15 +72,15 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
             (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.addTemperaturDataPoint(this);
             return;
         }
-        const setting = models_1.TemperaturSettings.getActiveSetting(this._automaticPoints, new Date());
+        const setting = models_1.TemperatureSettings.getActiveSetting(this._automaticPoints, new Date());
         if (setting === undefined) {
             this.log(models_1.LogLevel.Warn, `Undefined Heating Timestamp.`);
-            this.desiredTemperatur = this.settings.automaticFallBackTemperatur;
+            this.desiredTemperature = this.settings.automaticFallBackTemperatur;
             return;
         }
-        if (this._desiredTemperatur !== setting.temperatur) {
-            this.log(models_1.LogLevel.Debug, `Automatische Temperaturanpassung für ${this.info.customName} auf ${setting.temperatur}°C`);
-            this.desiredTemperatur = (_b = setting.temperatur) !== null && _b !== void 0 ? _b : this.settings.automaticFallBackTemperatur;
+        if (this._desiredTemperatur !== setting.temperature) {
+            this.log(models_1.LogLevel.Debug, `Automatische Temperaturanpassung für ${this.info.customName} auf ${setting.temperature}°C`);
+            this.desiredTemperature = (_b = setting.temperature) !== null && _b !== void 0 ? _b : this.settings.automaticFallBackTemperatur;
         }
         (_c = services_1.Utils.dbo) === null || _c === void 0 ? void 0 : _c.addTemperaturDataPoint(this);
     }

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

@@ -1,18 +1,18 @@
 /// <reference types="iobroker" />
 import { ZigbeeDevice } from './BaseDevices';
-import { iHumiditySensor, iTemperaturSensor } from '../baseDeviceInterfaces';
+import { iHumiditySensor, iTemperatureSensor } from '../baseDeviceInterfaces';
 import { DeviceInfo } from '../DeviceInfo';
-export declare class ZigbeeSonoffTemp extends ZigbeeDevice implements iTemperaturSensor, iHumiditySensor {
+export declare class ZigbeeSonoffTemp extends ZigbeeDevice implements iTemperatureSensor, iHumiditySensor {
     private _humidityCallbacks;
     private _temperaturCallbacks;
     constructor(pInfo: DeviceInfo);
     private _humidity;
     get humidity(): number;
     private set humidity(value);
-    get iTemperatur(): number;
-    get sTemperatur(): string;
-    private _temperatur;
-    private set temperatur(value);
+    get iTemperature(): number;
+    get sTemperature(): string;
+    private _temperature;
+    private set temperature(value);
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     addHumidityCallback(pCallback: (pValue: number) => void): void;
     addTempChangeCallback(pCallback: (pValue: number) => void): void;

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

@@ -10,7 +10,7 @@ class ZigbeeSonoffTemp extends BaseDevices_1.ZigbeeDevice {
         this._humidityCallbacks = [];
         this._temperaturCallbacks = [];
         this._humidity = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
-        this._temperatur = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._temperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
     }
     get humidity() {
         return this._humidity;
@@ -21,14 +21,14 @@ class ZigbeeSonoffTemp extends BaseDevices_1.ZigbeeDevice {
             cb(val);
         }
     }
-    get iTemperatur() {
-        return this._temperatur;
+    get iTemperature() {
+        return this._temperature;
     }
-    get sTemperatur() {
-        return `${this._temperatur}°C`;
+    get sTemperature() {
+        return `${this._temperature}°C`;
     }
-    set temperatur(val) {
-        this._temperatur = val;
+    set temperature(val) {
+        this._temperature = val;
         for (const cb of this._temperaturCallbacks) {
             cb(val);
         }
@@ -39,8 +39,8 @@ class ZigbeeSonoffTemp extends BaseDevices_1.ZigbeeDevice {
             case 'humidity':
                 this.humidity = state.val;
                 break;
-            case 'temperatur':
-                this.temperatur = state.val;
+            case 'temperature':
+                this.temperature = state.val;
                 break;
         }
     }
@@ -52,8 +52,8 @@ class ZigbeeSonoffTemp extends BaseDevices_1.ZigbeeDevice {
     }
     addTempChangeCallback(pCallback) {
         this._temperaturCallbacks.push(pCallback);
-        if (this._temperatur > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
-            pCallback(this._temperatur);
+        if (this._temperature > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
+            pCallback(this._temperature);
         }
     }
 }

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

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

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

@@ -28,7 +28,7 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         }
         this.checkTempDiff();
     }
-    set desiredTemperatur(val) {
+    set desiredTemperature(val) {
         this._desiredTemperatur = val;
         this.checkTempDiff();
     }
@@ -73,7 +73,7 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         if (this.settings.useOwnTemperatur) {
             return;
         }
-        const desiredDiff = services_1.Utils.round(this.desiredTemperatur - this._roomTemperatur, 1);
+        const desiredDiff = services_1.Utils.round(this.desiredTemperature - this._roomTemperatur, 1);
         const currentDiff = this.tempDiff;
         const missingDiff = services_1.Utils.round(desiredDiff - currentDiff, 1);
         if (Math.abs(missingDiff) < 0.15) {
@@ -83,13 +83,13 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         this.log(models_1.LogLevel.Debug, `Calculating Tuya Valve Diff, desiredDiff "${desiredDiff}", currentDiff "${currentDiff}", missingDiff "${missingDiff}"`);
         if (Math.abs(desiredDiff) <= 9.0) {
             // Check possible with local Diff only
-            this.setTargetTemperatur(this.desiredTemperatur);
+            this.setTargetTemperatur(this.desiredTemperature);
             this.setLocalDiff(-1 * desiredDiff);
             return;
         }
         const newLocalDiff = Math.sign(desiredDiff) * -9;
         this.setLocalDiff(newLocalDiff);
-        this.setTargetTemperatur(this._localTempVal + this._roomTemperatur + newLocalDiff + this.desiredTemperatur);
+        this.setTargetTemperatur(this._localTempVal + this._roomTemperatur + newLocalDiff + this.desiredTemperature);
     }
     setLocalDiff(newLocalDiff) {
         this.log(models_1.LogLevel.Debug, `Setting new Local Calibration Diff (${newLocalDiff}) for Tuya Valve`);