hoffmation-base 1.0.55 → 1.0.58

package/lib/liquid-pid.d.ts

@@ -0,0 +1,42 @@
+/**
+ * !!Ported from liquid pid!!!!
+ * Control the PWM relays from the temperature
+ *
+ * I'm a NodeJS guy not a scientist, so please be a careful!!!
+ * FYI: http://en.wikipedia.org/wiki/PID_controller
+ *
+ * @module controller
+ *
+ * @author https://github.com/hekike/liquid-pid
+ * @licence MIT
+ **/
+export declare class PIDController {
+    private _Tref;
+    private readonly _Pmax;
+    private _Kp;
+    private _Ki;
+    private _Kd;
+    private _P;
+    private _I;
+    private _D;
+    private readonly _MaxP;
+    private readonly _MaxI;
+    private readonly _MaxD;
+    private readonly _MaxU;
+    private _e;
+    private _U;
+    constructor(options: PIDOptions);
+    tune(Kp: number, Ki: number, Kd: number): void;
+    getRefTemperature(): number;
+    setPoint(temp: number): number;
+    calculate(actualTemperature: number): number;
+}
+export interface PIDOptions {
+    Kp?: number;
+    Ki?: number;
+    Kd?: number;
+    Pmax?: number;
+    temp?: {
+        ref: number;
+    };
+}

package/lib/liquid-pid.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PIDController = void 0;
+/**
+ * !!Ported from liquid pid!!!!
+ * Control the PWM relays from the temperature
+ *
+ * I'm a NodeJS guy not a scientist, so please be a careful!!!
+ * FYI: http://en.wikipedia.org/wiki/PID_controller
+ *
+ * @module controller
+ *
+ * @author https://github.com/hekike/liquid-pid
+ * @licence MIT
+ **/
+class PIDController {
+    constructor(options) {
+        var _a, _b, _c, _d, _f, _g;
+        this._U = null;
+        this._Tref = (_b = (_a = options.temp) === null || _a === void 0 ? void 0 : _a.ref) !== null && _b !== void 0 ? _b : 0; // Point temperature (This is the temp what you want to reach and hold) (°C)
+        this._Pmax = (_c = options.Pmax) !== null && _c !== void 0 ? _c : 4000; // Max Power, this is the maximum output of your heater (W)  (Yep, this is the output what you want)
+        //  Params of the PID controller
+        this._Kp = (_d = options.Kp) !== null && _d !== void 0 ? _d : 25; // Proportional gain, a tuning parameter
+        this._Ki = (_f = options.Ki) !== null && _f !== void 0 ? _f : 1000; // Integral gain, a tuning parameter
+        this._Kd = (_g = options.Kd) !== null && _g !== void 0 ? _g : 9; // Derivative gain, a tuning parameter
+        this._P = 0; // Proportional value ("reduces a large part of the overall error")
+        this._I = 0; // Integral value ("reduces the final error in a system")
+        this._D = 0; // Derivative value ("helps reduce overshoot and ringing", "~speed")
+        this._MaxP = 1000; // Limit the maximum value of the abs Proportional (because micro controller registers)
+        this._MaxI = 1000; // Limit the maximum value of the abs Integral (because micro controller registers)
+        this._MaxD = 1000; // Limit the maximum value of the abs Derivative (because micro controller registers)
+        this._MaxU = 1000; // Limit the maximum value of the controller output (it's not equal with our P "output")
+        // Other variables
+        this._e = 0; // Actual error
+        this._U = null; // Controller output (it's not equal with our P "output")
+    }
+    tune(Kp, Ki, Kd) {
+        if (!isNaN(Kp) || !isNaN(Ki) || !isNaN(Kd)) {
+            return;
+        }
+        this._Kp = Kp;
+        this._Ki = Ki;
+        this._Kd = Kd;
+    }
+    getRefTemperature() {
+        return this._Tref;
+    }
+    setPoint(temp) {
+        if (isNaN(temp)) {
+            return NaN;
+        }
+        this._Tref = temp;
+        return this._Tref;
+    }
+    calculate(actualTemperature) {
+        const ePrev = this._e; // Save the error for the next loop
+        this._e = this._Tref - actualTemperature; // Calculate the actual error
+        // Calculate the P
+        this._P = this._Kp * this._e;
+        if (this._P > this._MaxP) {
+            this._P = this._MaxP;
+        }
+        else if (this._P < -1 * this._MaxP) {
+            this._P = -1 * this._MaxP;
+        }
+        // Calculate the D
+        this._D = this._Kd * (this._e - ePrev);
+        if (this._D > this._MaxD) {
+            this._D = this._MaxD;
+        }
+        else if (this._D < -1 * this._MaxD) {
+            this._D = -1 * this._MaxD;
+        }
+        // Calculate the I
+        this._I += this._Ki * this._e;
+        if (this._I > this._MaxI) {
+            this._I = this._MaxI;
+        }
+        else if (this._I < -1 * this._MaxI) {
+            this._I = -1 * this._MaxI;
+        }
+        // PID algorithm
+        this._U = this._P + this._I + this._D;
+        // Some value limitation
+        if (this._U > this._MaxU) {
+            this._U = this._MaxU;
+        }
+        else if (this._U < 0) {
+            // Power cannot be a negative number
+            this._U = 0; // this means that the system can only heating
+        }
+        // Calculate the output
+        // and transform U to the [0..1] interval
+        return (this._U / 1000) * this._Pmax;
+    }
+}
+exports.PIDController = PIDController;

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

@@ -9,6 +9,7 @@ export declare class HeaterSettings extends DeviceSettings {
      * @type {boolean}
      */
     controlByPid: boolean;
+    controlByTempDiff: boolean;
     /**
      * Whether this device should turn off at Start of summer season and only heat in winter
      * @type {boolean}

package/lib/models/deviceSettings/heaterSettings.js

@@ -14,6 +14,7 @@ class HeaterSettings extends deviceSettings_1.DeviceSettings {
          * @type {boolean}
          */
         this.controlByPid = false;
+        this.controlByTempDiff = false;
         /**
          * Whether this device should turn off at Start of summer season and only heat in winter
          * @type {boolean}

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

@@ -4,7 +4,7 @@ import { DeviceType } from '../deviceType';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class HmIPDevice extends IoBrokerBaseDevice {
     lowBattery: boolean;
-    stateMap: Map<string, ioBroker.StateValue>;
+    stateMap: Map<string, ioBroker.State>;
     constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
 }

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

@@ -24,7 +24,7 @@ class HmIPDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
                 }
                 break;
         }
-        this.stateMap.set(combinedStateName, state.val);
+        this.stateMap.set(combinedStateName, state);
         const individualCallbacks = this.individualStateCallbacks.get(combinedStateName);
         if (individualCallbacks !== undefined) {
             for (const cb of individualCallbacks) {

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

@@ -6,7 +6,7 @@ export declare class ZigbeeDevice extends IoBrokerBaseDevice {
     available: boolean;
     linkQuality: number;
     voltage: string;
-    stateMap: Map<string, ioBroker.StateValue>;
+    stateMap: Map<string, ioBroker.State>;
     constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
 }

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

@@ -33,7 +33,7 @@ class ZigbeeDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
                 this.voltage = state.val.toString();
                 break;
         }
-        this.stateMap.set(idSplit[3], state.val);
+        this.stateMap.set(idSplit[3], state);
         const individualCallbacks = this.individualStateCallbacks.get(idSplit[3]);
         if (individualCallbacks !== undefined) {
             for (const cb of individualCallbacks) {

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

@@ -5,6 +5,7 @@ import { iBatteryDevice, iHeater } from '../../baseDeviceInterfaces';
 import { HeaterSettings, TemperatureSettings } from '../../../../models';
 import { DeviceType } from '../../deviceType';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { PIDController } from 'liquid-pid';
 export declare class ZigbeeHeater extends ZigbeeDevice implements iHeater, iBatteryDevice {
     settings: HeaterSettings;
     battery: number;
@@ -17,6 +18,7 @@ export declare class ZigbeeHeater extends ZigbeeDevice implements iHeater, iBatt
     protected _setPointTemperaturID: string;
     protected _temperatur: number;
     protected _desiredTemperatur: number;
+    protected _pidController: PIDController;
     constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
     protected _seasonTurnOff: boolean;
     get seasonTurnOff(): boolean;
@@ -37,5 +39,6 @@ export declare class ZigbeeHeater extends ZigbeeDevice implements iHeater, iBatt
     stopAutomaticCheck(): void;
     onTemperaturChange(newTemperatur: number): void;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    protected getNextPidLevel(): number;
     private checkSeasonTurnOff;
 }

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

@@ -6,6 +6,7 @@ const baseDeviceInterfaces_1 = require("../../baseDeviceInterfaces");
 const models_1 = require("../../../../models");
 const services_1 = require("../../../services");
 const DeviceCapability_1 = require("../../DeviceCapability");
+const liquid_pid_1 = require("liquid-pid");
 class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
     constructor(pInfo, pType) {
         super(pInfo, pType);
@@ -17,6 +18,16 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
         this._setPointTemperaturID = '';
         this._temperatur = 0;
         this._desiredTemperatur = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._pidController = new liquid_pid_1.PIDController({
+            temp: {
+                ref: 20, // Point temperature
+            },
+            Pmax: 100,
+            // Tune the PID Controller
+            Kp: 25,
+            Ki: 1000,
+            Kd: 9, // PID: Kd in 1/1000
+        });
         this._seasonTurnOff = false;
         this._humidity = 0;
         this._roomTemperatur = 0;
@@ -115,6 +126,15 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
         }
         super.update(idSplit, state, initial, pOverride);
     }
+    getNextPidLevel() {
+        if (this.seasonTurnOff) {
+            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})`);
+        return newValue;
+    }
     checkSeasonTurnOff() {
         const desiredState = services_1.Utils.beetweenDays(new Date(), this.settings.seasonTurnOffDay, this.settings.seasonTurnOnDay);
         if (desiredState !== this.seasonTurnOff || !this._initialSeasonCheckDone) {

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

@@ -1,9 +1,9 @@
 /// <reference types="iobroker" />
 import { ActuatorSettings, ExcessEnergyConsumerSettings } from '../../../models';
-import { ZigbeeDevice } from './BaseDevices';
+import { ZigbeeActuator } from './BaseDevices';
 import { iExcessEnergyConsumer } from '../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
-export declare class ZigbeeBlitzShp extends ZigbeeDevice implements iExcessEnergyConsumer {
+export declare class ZigbeeBlitzShp extends ZigbeeActuator implements iExcessEnergyConsumer {
     steckerOn: boolean;
     current: number;
     energy: number;
@@ -11,15 +11,12 @@ export declare class ZigbeeBlitzShp extends ZigbeeDevice implements iExcessEnerg
     settings: ActuatorSettings;
     energyConsumerSettings: ExcessEnergyConsumerSettings;
     private readonly _availableForExcessEnergy;
-    private readonly steckerOnSwitchID;
     private _activatedByExcessEnergy;
     constructor(pInfo: IoBrokerDeviceInfo);
     get currentConsumption(): number;
     get on(): boolean;
     isAvailableForExcessEnergy(): boolean;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    setStecker(pValue: boolean): void;
-    toggleStecker(): boolean;
     turnOnForExcessEnergy(): void;
     turnOffDueToMissingEnergy(): void;
     wasActivatedByExcessEnergy(): boolean;

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

@@ -5,9 +5,9 @@ const deviceType_1 = require("../deviceType");
 const models_1 = require("../../../models");
 const BaseDevices_1 = require("./BaseDevices");
 const DeviceCapability_1 = require("../DeviceCapability");
-class ZigbeeBlitzShp extends BaseDevices_1.ZigbeeDevice {
+class ZigbeeBlitzShp extends BaseDevices_1.ZigbeeActuator {
     constructor(pInfo) {
-        super(pInfo, deviceType_1.DeviceType.ZigbeeBlitzShp);
+        super(pInfo, deviceType_1.DeviceType.ZigbeeBlitzShp, `${pInfo.fullID}.state`);
         this.steckerOn = false;
         this.current = 0;
         this.energy = 0;
@@ -15,10 +15,8 @@ class ZigbeeBlitzShp extends BaseDevices_1.ZigbeeDevice {
         this.settings = new models_1.ActuatorSettings();
         this.energyConsumerSettings = new models_1.ExcessEnergyConsumerSettings();
         this._availableForExcessEnergy = true;
-        this.steckerOnSwitchID = '';
         this._activatedByExcessEnergy = false;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.excessEnergyConsumer);
-        this.steckerOnSwitchID = `${this.info.fullID}.state`;
     }
     get currentConsumption() {
         return this.loadPower;
@@ -55,30 +53,12 @@ class ZigbeeBlitzShp extends BaseDevices_1.ZigbeeDevice {
                 break;
         }
     }
-    setStecker(pValue) {
-        if (this.steckerOnSwitchID === '') {
-            this.log(models_1.LogLevel.Error, `Keine Switch ID bekannt.`);
-            return;
-        }
-        this.log(models_1.LogLevel.Debug, `Switch outlet, target Value: ${pValue}`);
-        if (!pValue) {
-            this._activatedByExcessEnergy = false;
-        }
-        this.setState(this.steckerOnSwitchID, pValue, undefined, (err) => {
-            this.log(models_1.LogLevel.Error, `Switching outlet resulted in error: ${err}`);
-        });
-    }
-    toggleStecker() {
-        const newVal = !this.steckerOn;
-        this.setStecker(newVal);
-        return newVal;
-    }
     turnOnForExcessEnergy() {
         this._activatedByExcessEnergy = true;
-        this.setStecker(true);
+        this.setActuator(true);
     }
     turnOffDueToMissingEnergy() {
-        this.setStecker(false);
+        this.setActuator(false);
     }
     wasActivatedByExcessEnergy() {
         return this._activatedByExcessEnergy;

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

@@ -8,14 +8,18 @@ export declare class ZigbeeEuroHeater extends ZigbeeHeater {
     private _localDiffTempVal;
     private _setModeId;
     private _valvePosId;
+    private _lastRecalc;
     private _mode;
+    private _recalcTimeout;
     constructor(pInfo: IoBrokerDeviceInfo);
+    get seasonTurnOff(): boolean;
     set seasonTurnOff(value: boolean);
     set roomTemperatur(value: number);
     get desiredTemperature(): number;
     set desiredTemperature(val: number);
     private get tempDiff();
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    recalcLevel(): void;
     private checkTempDiff;
     private setLocalDiff;
     private setTargetTemperatur;

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

@@ -12,12 +12,17 @@ class ZigbeeEuroHeater extends BaseDevices_1.ZigbeeHeater {
         this._targetTempVal = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         this._localTempVal = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         this._localDiffTempVal = 0;
+        this._lastRecalc = 0;
         this._mode = 1;
+        this._recalcTimeout = null;
         this._setPointTemperaturID = `${this.info.fullID}.heating_setpnt_current`;
         this._setLocalTempCalibrationId = `${this.info.fullID}.local_temp_calibration`;
         this._setModeId = `${this.info.fullID}.spz_trv_mode`;
         this._valvePosId = `${this.info.fullID}.valve_position`;
     }
+    get seasonTurnOff() {
+        return this._seasonTurnOff;
+    }
     set seasonTurnOff(value) {
         this._seasonTurnOff = value;
         if (value) {
@@ -36,17 +41,25 @@ class ZigbeeEuroHeater extends BaseDevices_1.ZigbeeHeater {
         if (this.settings.useOwnTemperatur) {
             return;
         }
-        this.checkTempDiff();
+        this.recalcLevel();
     }
     get desiredTemperature() {
         return this._desiredTemperatur;
     }
     set desiredTemperature(val) {
         this._desiredTemperatur = val;
-        this.checkTempDiff();
+        this.recalcLevel();
     }
     get tempDiff() {
-        return this._targetTempVal - (this._localTempVal + this._localDiffTempVal);
+        var _a, _b, _c, _d;
+        const tempChangeMs = (_b = (_a = this.stateMap.get('local_temp')) === null || _a === void 0 ? void 0 : _a.lc) !== null && _b !== void 0 ? _b : 0;
+        const calibChangeMs = (_d = (_c = this.stateMap.get('local_temp_calibration')) === null || _c === void 0 ? void 0 : _c.lc) !== null && _d !== void 0 ? _d : 0;
+        if (tempChangeMs < calibChangeMs) {
+            return this._targetTempVal - (this._localTempVal + this._localDiffTempVal);
+        }
+        else {
+            return this._targetTempVal - this._localTempVal;
+        }
     }
     update(idSplit, state, initial = false) {
         switch (idSplit[3]) {
@@ -82,16 +95,33 @@ class ZigbeeEuroHeater extends BaseDevices_1.ZigbeeHeater {
                 this.log(models_1.LogLevel.Trace, `Euro Valve Target_Temp Update for ${this.info.customName} to "${state.val}"`);
                 this._targetTempVal = state.val;
                 if (!initial)
-                    this.checkTempDiff();
+                    this.checkTempDiff(); // TODO: If we change it this results in an infinite loop
                 break;
         }
         super.update(idSplit, state, initial, true);
     }
-    checkTempDiff() {
-        return; // TODO: Fix this
+    recalcLevel() {
         if (this.settings.useOwnTemperatur || this.seasonTurnOff) {
             return;
         }
+        const msTilNextMinimumCheck = this._lastRecalc + 5 * 60 * 1000 - services_1.Utils.nowMS();
+        if (msTilNextMinimumCheck > 0) {
+            if (this._recalcTimeout == null) {
+                this._recalcTimeout = services_1.Utils.guardedTimeout(this.recalcLevel, msTilNextMinimumCheck, this);
+            }
+            return;
+        }
+        if (this.settings.controlByPid) {
+            this.setValve(this.getNextPidLevel());
+            return;
+        }
+        this.checkTempDiff();
+    }
+    checkTempDiff() {
+        if (!this.settings.controlByTempDiff) {
+            return;
+        }
+        this._lastRecalc = services_1.Utils.nowMS();
         const desiredDiff = services_1.Utils.round(this.desiredTemperature - this._roomTemperatur, 1);
         const currentDiff = this.tempDiff;
         const missingDiff = services_1.Utils.round(desiredDiff - currentDiff, 1);