hoffmation-base 0.1.41-1 → 0.1.41-10

package/lib/server/devices/jsObject/jsObjectEnergyManager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsObjectEnergyManager = void 0;
 const IoBrokerBaseDevice_1 = require("../IoBrokerBaseDevice");
+const iEnergyManager_1 = require("../iEnergyManager");
 const deviceType_1 = require("../deviceType");
 const models_1 = require("../../../models");
 const services_1 = require("../../services");
@@ -9,59 +10,88 @@ const index_1 = require("../../../index");
 class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     constructor(info) {
         super(info, deviceType_1.DeviceType.JsEnergyManager);
-        this._currentProduction = -1;
-        this._excessEnergy = -1;
-        this._excessEnergyConsumerConsumption = 0;
         this._excessEnergyConsumer = [];
+        this._iCalculationInterval = null;
         this._iDatabaseLoggerInterval = null;
         this._lastPersistenceCalculation = services_1.Utils.nowMS();
+        this._powerValuePhaseA = -1;
+        this._powerValuePhaseB = -1;
+        this._powerValuePhaseC = -1;
+        this._currentProduction = -1;
+        this._excessEnergyConsumerConsumption = 0;
+        this._phaseAState = new iEnergyManager_1.PhaseState(0, 0);
+        this._phaseBState = new iEnergyManager_1.PhaseState(0, 0);
+        this._phaseCState = new iEnergyManager_1.PhaseState(0, 0);
         this.log(models_1.LogLevel.Info, `Creating Energy Manager Device`);
+        this._iCalculationInterval = services_1.Utils.guardedInterval(() => {
+            this.calculateExcessEnergy();
+        }, 5 * 1000, this);
         this._iDatabaseLoggerInterval = services_1.Utils.guardedInterval(() => {
             this.persist();
         }, 15 * 60 * 1000, this);
         this._nextPersistEntry = new index_1.EnergyCalculation(services_1.Utils.nowMS());
     }
-    /**
-     * Example:
-     * ________________________________________
-     * | ExcessEnergy | 500W  | -500W | -500W |
-     * | Production   | 1500W | 500W  | 0W    |
-     * _______________________________________
-     * | Consumption  | 1000W | 1000W | 500W  |
-     * | Injecting    | 500W  | 0W    | 0W    |
-     * | drawing      |    0W | 500W  | 500W  |
-     * | selfConsume  | 1000W | 500W  | 0W    |
-     * ________________________________________
-     **/
-    get excessEnergyConsumerConsumption() {
-        return this._excessEnergyConsumerConsumption;
-    }
-    get excessEnergy() {
-        return this._excessEnergy;
+    get currentProduction() {
+        return this._currentProduction;
     }
     get baseConsumption() {
         return this.totalConsumption - this._excessEnergyConsumerConsumption;
     }
     get totalConsumption() {
-        return this._currentProduction - this._excessEnergy;
+        return (this.phaseAState.totalConsumptionWattage +
+            this.phaseBState.totalConsumptionWattage +
+            this.phaseCState.totalConsumptionWattage);
     }
     get injectingWattage() {
-        return Math.max(this._excessEnergy, 0);
+        return this.phaseAState.injectingWattage + this.phaseBState.injectingWattage + this.phaseCState.injectingWattage;
     }
     get drawingWattage() {
-        return Math.min(this._excessEnergy, 0) * -1;
+        return this.phaseAState.drawingWattage + this.phaseBState.drawingWattage + this.phaseCState.drawingWattage;
     }
     get selfConsumingWattage() {
-        return Math.min(this.totalConsumption, this._currentProduction);
+        return (this.phaseAState.selfConsumingWattage +
+            this.phaseBState.selfConsumingWattage +
+            this.phaseCState.selfConsumingWattage);
     }
-    get currentProduction() {
-        return this._currentProduction;
+    get excessEnergy() {
+        return this._powerValuePhaseA + this._powerValuePhaseB + this._powerValuePhaseC;
+    }
+    /**
+     * Example:
+     * ________________________________________
+     * | ExcessEnergyA | 200W  |  200W | -500W |
+     * | ExcessEnergyB | 300W  |  300W | -200W |
+     * | ExcessEnergyC | 100W  | -100W | -300W |
+     * | Production P  |  500W |  500W |    0W |
+     * | Production    | 1500W | 1500W |    0W |
+     * ________________________________________
+     * | Consumption   |  900W | 1100W | 1000W |
+     * | Injecting     |  600W |  500W |    0W |
+     * | drawing       |    0W |  100W | 1000W |
+     * | selfConsume   |  900W | 1000W |    0W |
+     * ________________________________________
+     **/
+    get excessEnergyConsumerConsumption() {
+        return this._excessEnergyConsumerConsumption;
+    }
+    get phaseAState() {
+        return this._phaseAState;
+    }
+    get phaseBState() {
+        return this._phaseBState;
+    }
+    get phaseCState() {
+        return this._phaseCState;
     }
     cleanup() {
         if (this._iDatabaseLoggerInterval !== null) {
             clearInterval(this._iDatabaseLoggerInterval);
             this._iDatabaseLoggerInterval = null;
         }
+        if (this._iCalculationInterval !== null) {
+            clearInterval(this._iCalculationInterval);
+            this._iCalculationInterval = null;
+        }
     }
     addExcessConsumer(device) {
         this._excessEnergyConsumer.push(device);
@@ -72,9 +102,17 @@ class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     update(idSplit, state, initial, pOverride = false) {
         this.log(models_1.LogLevel.DeepTrace, `EnergyManager: ${initial ? 'Initial ' : ''} update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}, override: ${pOverride}`);
         switch (idSplit[3]) {
-            case 'CurrentExcessEnergy':
-                this.log(models_1.LogLevel.Trace, `Current excess energy update to ${state.val}`);
-                this.setExcessEnergy(state.val);
+            case 'CurrentExcessEnergyPhaseA':
+                this.log(models_1.LogLevel.Trace, `Current excess energyA update to ${state.val}`);
+                this._powerValuePhaseA = state.val;
+                break;
+            case 'CurrentExcessEnergyPhaseB':
+                this.log(models_1.LogLevel.Trace, `Current excess energyB update to ${state.val}`);
+                this._powerValuePhaseB = state.val;
+                break;
+            case 'CurrentExcessEnergyPhaseC':
+                this.log(models_1.LogLevel.Trace, `Current excess energyC update to ${state.val}`);
+                this._powerValuePhaseC = state.val;
                 break;
             case 'CurrentProduction':
                 this.log(models_1.LogLevel.Trace, `Current Production Update to ${state.val}`);
@@ -82,8 +120,11 @@ class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
                 break;
         }
     }
-    setExcessEnergy(val) {
-        this._excessEnergy = val;
+    calculateExcessEnergy() {
+        const phaseProduction = this._currentProduction / 3.0;
+        this._phaseAState = new iEnergyManager_1.PhaseState(this._powerValuePhaseA, phaseProduction);
+        this._phaseBState = new iEnergyManager_1.PhaseState(this._powerValuePhaseB, phaseProduction);
+        this._phaseCState = new iEnergyManager_1.PhaseState(this._powerValuePhaseC, phaseProduction);
         this.calculatePersistenceValues();
         this.recalculatePowerSharing();
     }

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

@@ -20,3 +20,4 @@ export * from './zigbeeSMaBiTMagnetContact';
 export * from './zigbeeSonoffMotion';
 export * from './zigbeeSonoffTemp';
 export * from './zigbeeSwitch';
+export * from './zigbeeUbisysShutter';

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

@@ -36,3 +36,4 @@ __exportStar(require("./zigbeeSMaBiTMagnetContact"), exports);
 __exportStar(require("./zigbeeSonoffMotion"), exports);
 __exportStar(require("./zigbeeSonoffTemp"), exports);
 __exportStar(require("./zigbeeSwitch"), exports);
+__exportStar(require("./zigbeeUbisysShutter"), exports);

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

@@ -5,8 +5,6 @@ export declare class ZigbeeIlluShutter extends ZigbeeShutter {
     private _movementStateId;
     private _movementState;
     private _movementStartMs;
-    private _msTilTop;
-    private _msTilBot;
     private _movementStartPos;
     private _iMovementTimeout;
     constructor(pInfo: DeviceInfo);

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

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeIlluShutter = void 0;
 const zigbeeShutter_1 = require("./zigbeeShutter");
 const deviceType_1 = require("../deviceType");
-const logLevel_1 = require("../../../models/logLevel");
-const utils_1 = require("../../services/utils/utils");
+const models_1 = require("../../../models");
+const services_1 = require("../../services");
 var MovementState;
 (function (MovementState) {
     MovementState[MovementState["Down"] = 30] = "Down";
@@ -16,8 +16,6 @@ class ZigbeeIlluShutter extends zigbeeShutter_1.ZigbeeShutter {
         super(pInfo, deviceType_1.DeviceType.ZigbeeIlluShutter);
         this._movementState = MovementState.Stop;
         this._movementStartMs = -1;
-        this._msTilTop = -1;
-        this._msTilBot = -1;
         this._movementStartPos = -1;
         this._movementStateId = `${this.info.fullID}.position`;
         // this.presenceStateID = `${this.info.fullID}.1.${HmIpPraezenz.PRESENCE_DETECTION}`;
@@ -25,7 +23,7 @@ class ZigbeeIlluShutter extends zigbeeShutter_1.ZigbeeShutter {
     update(idSplit, state, initial = false) {
         switch (idSplit[3]) {
             case 'position':
-                this.log(logLevel_1.LogLevel.Trace, `Shutter Update for ${this.info.customName} to "${state.val}"`);
+                this.log(models_1.LogLevel.Trace, `Shutter Update for ${this.info.customName} to "${state.val}"`);
                 this.processNewMovementState(state.val);
                 break;
         }
@@ -33,12 +31,12 @@ class ZigbeeIlluShutter extends zigbeeShutter_1.ZigbeeShutter {
     }
     moveToPosition(targetPosition) {
         if (this._movementState !== MovementState.Stop) {
-            this.log(logLevel_1.LogLevel.Info, `Delaying movement command for ${this.info.customName} as it is moving to prevent actuator damage`);
+            this.log(models_1.LogLevel.Info, `Delaying movement command for ${this.info.customName} as it is moving to prevent actuator damage`);
             this.changeMovementState(MovementState.Stop);
             if (this._iMovementTimeout !== undefined) {
                 clearTimeout(this._iMovementTimeout);
             }
-            this._iMovementTimeout = utils_1.Utils.guardedTimeout(() => {
+            this._iMovementTimeout = services_1.Utils.guardedTimeout(() => {
                 this._iMovementTimeout = undefined;
                 this.moveToPosition(targetPosition);
             }, 2000, this);
@@ -47,28 +45,34 @@ class ZigbeeIlluShutter extends zigbeeShutter_1.ZigbeeShutter {
         this._movementStartPos = this._currentLevel;
         if (targetPosition === 100) {
             this.changeMovementState(MovementState.Up);
+            this.initializeMovementFinishTimeout(this.getAverageUp(), 100);
             return;
         }
         if (targetPosition === 0) {
             this.changeMovementState(MovementState.Down);
+            this.initializeMovementFinishTimeout(this.getAverageUp(), 0);
+            services_1.Utils.guardedTimeout(() => {
+                this.changeMovementState(MovementState.Stop);
+            }, this.getAverageDown() + 1000, this);
             return;
         }
         if (!this.isCalibrated()) {
-            this.log(logLevel_1.LogLevel.Alert, `Can't move  to position "${targetPosition}" as it is not calibrated (Move it completly up, down, up first)`);
+            this.log(models_1.LogLevel.Alert, `Can't move  to position "${targetPosition}" as it is not calibrated (Move it completly up, down, up first)`);
             return;
         }
         const distance = Math.abs(this._currentLevel - targetPosition);
         const direction = this._currentLevel > targetPosition ? MovementState.Down : MovementState.Up;
-        const duration = Math.round(distance / 100) * (this._currentLevel > targetPosition ? this._msTilBot : this._msTilTop);
+        const duration = Math.round(distance / 100) * (this._currentLevel > targetPosition ? this.getAverageDown() : this.getAverageUp());
         this.changeMovementState(direction);
-        utils_1.Utils.guardedTimeout(() => {
+        this.initializeMovementFinishTimeout(duration, targetPosition);
+        services_1.Utils.guardedTimeout(() => {
             this.changeMovementState(MovementState.Stop);
         }, duration, this);
     }
     changeMovementState(direction) {
-        this.log(logLevel_1.LogLevel.Debug, `Set new MovementState to "${MovementState[direction]}"`);
+        this.log(models_1.LogLevel.Debug, `Set new MovementState to "${MovementState[direction]}"`);
         if (direction !== MovementState.Stop) {
-            this._movementStartMs = utils_1.Utils.nowMS();
+            this._movementStartMs = services_1.Utils.nowMS();
         }
         this.setState(this._movementStateId, direction, () => {
             this._movementState = direction;
@@ -76,43 +80,41 @@ class ZigbeeIlluShutter extends zigbeeShutter_1.ZigbeeShutter {
     }
     processNewMovementState(val) {
         const newState = val <= 30 ? MovementState.Down : val >= 70 ? MovementState.Up : MovementState.Stop;
-        this.log(logLevel_1.LogLevel.Trace, `New Movementstate "${MovementState[val]}"`);
+        this.log(models_1.LogLevel.Trace, `New Movementstate "${MovementState[val]}"`);
         if (newState !== MovementState.Stop) {
             this._movementState = newState;
             return;
         }
-        const timePassed = utils_1.Utils.nowMS() - this._movementStartMs;
+        const timePassed = services_1.Utils.nowMS() - this._movementStartMs;
         const oldState = this._movementState;
         if (this._movementStartPos === 0 && oldState === MovementState.Up && this._setLevel === 100) {
-            this._msTilTop = timePassed;
-            this.log(logLevel_1.LogLevel.Debug, `New Time-Until-Top measurement for ${this.info.customName}: ${timePassed}ms`);
+            this.log(models_1.LogLevel.Debug, `New Time-Until-Top measurement for ${this.info.customName}: ${timePassed}ms`);
             this.currentLevel = this._setLevel;
             this._shutterCalibrationData.counterUp++;
             this._shutterCalibrationData.averageUp +=
-                (this._msTilTop - this._shutterCalibrationData.averageUp) / this._shutterCalibrationData.counterUp;
+                (timePassed - this._shutterCalibrationData.averageUp) / this._shutterCalibrationData.counterUp;
             this.persistCalibrationData();
-            this.log(logLevel_1.LogLevel.Trace, `New Measurment for shutter up (${this._msTilTop}ms), new Average: ${this._shutterCalibrationData.averageUp}`);
+            this.log(models_1.LogLevel.Trace, `New Measurment for shutter up (${this.getAverageUp()}ms), new Average: ${this._shutterCalibrationData.averageUp}`);
             return;
         }
         if (this._movementStartPos === 100 && oldState === MovementState.Down && this._setLevel === 0) {
-            this.log(logLevel_1.LogLevel.Debug, `New Time-Until-Bottom measurement for ${this.info.customName}: ${timePassed}ms`);
-            this._msTilBot = timePassed;
+            this.log(models_1.LogLevel.Debug, `New Time-Until-Bottom measurement for ${this.info.customName}: ${timePassed}ms`);
             this.currentLevel = this._setLevel;
             this._shutterCalibrationData.counterDown++;
             this._shutterCalibrationData.averageDown +=
-                (this._msTilBot - this._shutterCalibrationData.averageDown) / this._shutterCalibrationData.counterDown;
+                (timePassed - this._shutterCalibrationData.averageDown) / this._shutterCalibrationData.counterDown;
             this.persistCalibrationData();
-            this.log(logLevel_1.LogLevel.Trace, `New Measurment for shutter down (${this._msTilBot}ms), new Average: ${this._shutterCalibrationData.averageDown}`);
+            this.log(models_1.LogLevel.Trace, `New Measurment for shutter down (${this.getAverageDown()}ms), new Average: ${this._shutterCalibrationData.averageDown}`);
             return;
         }
         if (!this.isCalibrated()) {
             return;
         }
         if (oldState === MovementState.Down) {
-            this.currentLevel = Math.min(this._currentLevel - Math.round((timePassed * 100) / this._msTilBot), 0);
+            this.currentLevel = Math.min(this._currentLevel - Math.round((timePassed * 100) / this.getAverageDown()), 0);
         }
         else if (oldState === MovementState.Up) {
-            this.currentLevel = Math.max(this._currentLevel + Math.round((timePassed * 100) / this._msTilBot), 100);
+            this.currentLevel = Math.max(this._currentLevel + Math.round((timePassed * 100) / this.getAverageUp()), 100);
         }
     }
 }

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

@@ -1,14 +1,15 @@
+/// <reference types="node" />
 /// <reference types="iobroker" />
 import { DeviceType } from '../deviceType';
 import { DeviceInfo } from '../DeviceInfo';
+import { ShutterCalibration, ShutterSettings } from '../../../models';
 import { ZigbeeDevice } from './zigbeeDevice';
 import { iShutter } from '../iShutter';
-import { Fenster } from '../groups/Fenster';
+import { Fenster } from '../groups';
 import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
-import { ShutterSettings } from '../../../models/deviceSettings/shutterSettings';
-import { ShutterCalibration } from '../../../models/persistence/ShutterCalibration';
 export declare class ZigbeeShutter extends ZigbeeDevice implements iShutter {
     settings: ShutterSettings;
+    protected _iMovementFinishTimeout: NodeJS.Timeout | null;
     get currentLevel(): number;
     set currentLevel(value: number);
     get desiredFensterLevel(): number;
@@ -28,5 +29,6 @@ export declare class ZigbeeShutter extends ZigbeeDevice implements iShutter {
     protected getAverageDown(): number;
     protected isCalibrated(): boolean;
     protected persistCalibrationData(): void;
+    protected initializeMovementFinishTimeout(duration: number, endPosition: number): void;
     toJSON(): Partial<IoBrokerBaseDevice>;
 }

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

@@ -4,29 +4,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeShutter = void 0;
-const utils_1 = require("../../services/utils/utils");
-const logLevel_1 = require("../../../models/logLevel");
+const services_1 = require("../../services");
+const models_1 = require("../../../models");
 const zigbeeDevice_1 = require("./zigbeeDevice");
-const FensterPosition_1 = require("../models/FensterPosition");
+const models_2 = require("../models");
 const lodash_1 = __importDefault(require("lodash"));
-const shutterSettings_1 = require("../../../models/deviceSettings/shutterSettings");
-const ShutterCalibration_1 = require("../../../models/persistence/ShutterCalibration");
 const index_1 = require("../../../index");
 class ZigbeeShutter extends zigbeeDevice_1.ZigbeeDevice {
     constructor(pInfo, pType) {
         super(pInfo, pType);
-        this.settings = new shutterSettings_1.ShutterSettings();
+        this.settings = new models_1.ShutterSettings();
+        this._iMovementFinishTimeout = null;
         this._currentLevel = -1;
         this._firstCommandRecieved = false;
         this._setLevel = -1;
         this._setLevelTime = -1;
-        this._shutterCalibrationData = new ShutterCalibration_1.ShutterCalibration(this.info.fullID, 0, 0, 0, 0);
+        this._shutterCalibrationData = new models_1.ShutterCalibration(this.info.fullID, 0, 0, 0, 0);
         index_1.dbo === null || index_1.dbo === void 0 ? void 0 : index_1.dbo.getShutterCalibration(this).then((calibrationData) => {
             this._shutterCalibrationData = calibrationData;
-            this.log(logLevel_1.LogLevel.DeepTrace, `ZigbeeShutter  initialized with calibration data`);
+            this.log(models_1.LogLevel.DeepTrace, `ZigbeeShutter  initialized with calibration data`);
         }).catch((err) => {
             var _a;
-            this.log(logLevel_1.LogLevel.Warn, `Failed to initialize Calibration data, err ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            this.log(models_1.LogLevel.Warn, `Failed to initialize Calibration data, err ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
         });
     }
     get currentLevel() {
@@ -36,11 +35,11 @@ class ZigbeeShutter extends zigbeeDevice_1.ZigbeeDevice {
         return this._currentLevel;
     }
     set currentLevel(value) {
-        if (value !== this._setLevel && utils_1.Utils.nowMS() - this._setLevelTime < 60 * 10000) {
+        if (value !== this._setLevel && services_1.Utils.nowMS() - this._setLevelTime < 60 * 10000) {
             value = this._setLevel;
         }
         if (value !== this._currentLevel && this._fenster) {
-            utils_1.Utils.guardedNewThread(() => {
+            services_1.Utils.guardedNewThread(() => {
                 var _a;
                 (_a = this._fenster) === null || _a === void 0 ? void 0 : _a.rolloPositionChange(value);
             }, this);
@@ -67,33 +66,33 @@ class ZigbeeShutter extends zigbeeDevice_1.ZigbeeDevice {
             this._firstCommandRecieved = true;
         }
         else if (this._firstCommandRecieved && initial) {
-            this.log(logLevel_1.LogLevel.Debug, `Skipped initial Rollo  to ${pPosition} as we recieved a command already`);
+            this.log(models_1.LogLevel.Debug, `Skipped initial Rollo  to ${pPosition} as we recieved a command already`);
             return;
         }
         if (this.currentLevel === pPosition) {
-            this.log(logLevel_1.LogLevel.Debug, `Skip Rollo command to Position ${pPosition} as this is the current one`);
+            this.log(models_1.LogLevel.Debug, `Skip Rollo command to Position ${pPosition} as this is the current one`);
             return;
         }
         if (this._fenster !== undefined) {
-            if (this._fenster.griffeInPosition(FensterPosition_1.FensterPosition.offen) > 0 && pPosition < 100) {
+            if (this._fenster.griffeInPosition(models_2.FensterPosition.offen) > 0 && pPosition < 100) {
                 if (!skipOpenWarning) {
-                    this.log(logLevel_1.LogLevel.Alert, `Fahre Rollo  nicht runter, weil das Fenster offen ist!`);
+                    this.log(models_1.LogLevel.Alert, `Fahre Rollo  nicht runter, weil das Fenster offen ist!`);
                 }
                 return;
             }
-            if (this._fenster.griffeInPosition(FensterPosition_1.FensterPosition.kipp) > 0 && pPosition < 50) {
+            if (this._fenster.griffeInPosition(models_2.FensterPosition.kipp) > 0 && pPosition < 50) {
                 pPosition = 50;
                 if (!skipOpenWarning) {
-                    this.log(logLevel_1.LogLevel.Alert, `Fahre Rollo  nicht runter, weil das Fenster auf Kipp ist!`);
+                    this.log(models_1.LogLevel.Alert, `Fahre Rollo  nicht runter, weil das Fenster auf Kipp ist!`);
                 }
             }
         }
         this._setLevel = pPosition;
-        this.log(logLevel_1.LogLevel.Debug, `Move  to position ${pPosition}`);
+        this.log(models_1.LogLevel.Debug, `Move  to position ${pPosition}`);
         this.moveToPosition(pPosition);
     }
     moveToPosition(pPosition) {
-        this.log(logLevel_1.LogLevel.Error, `Implement own moveToPosition(${pPosition}) Function`);
+        this.log(models_1.LogLevel.Error, `Implement own moveToPosition(${pPosition}) Function`);
     }
     getAverageUp() {
         if (this._shutterCalibrationData.averageUp > 0) {
@@ -102,7 +101,7 @@ class ZigbeeShutter extends zigbeeDevice_1.ZigbeeDevice {
         if (this.settings.msTilTop > 0) {
             return this.settings.msTilTop;
         }
-        return 0;
+        return 30000;
     }
     getAverageDown() {
         if (this._shutterCalibrationData.averageDown > 0) {
@@ -111,15 +110,24 @@ class ZigbeeShutter extends zigbeeDevice_1.ZigbeeDevice {
         if (this.settings.msTilBot > 0) {
             return this.settings.msTilBot;
         }
-        return 0;
+        return 30000;
     }
     isCalibrated() {
         return this.getAverageDown() > 0 && this.getAverageUp() > 0;
     }
     persistCalibrationData() {
-        this.log(logLevel_1.LogLevel.Trace, `Persiting Calibration Data. Average Up: ${this._shutterCalibrationData.averageUp}, Down: ${this._shutterCalibrationData.averageDown}`);
+        this.log(models_1.LogLevel.Trace, `Persiting Calibration Data. Average Up: ${this._shutterCalibrationData.averageUp}, Down: ${this._shutterCalibrationData.averageDown}`);
         index_1.dbo === null || index_1.dbo === void 0 ? void 0 : index_1.dbo.persistShutterCalibration(this._shutterCalibrationData);
     }
+    initializeMovementFinishTimeout(duration, endPosition) {
+        if (this._iMovementFinishTimeout !== null) {
+            clearTimeout(this._iMovementFinishTimeout);
+        }
+        this._iMovementFinishTimeout = services_1.Utils.guardedTimeout(() => {
+            this.currentLevel = endPosition;
+            this._iMovementFinishTimeout = null;
+        }, duration, this);
+    }
     toJSON() {
         return lodash_1.default.omit(super.toJSON(), ['_fenster']);
     }

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

@@ -0,0 +1,9 @@
+/// <reference types="iobroker" />
+import { ZigbeeShutter } from './zigbeeShutter';
+import { DeviceInfo } from '../DeviceInfo';
+export declare class ZigbeeUbisysShutter extends ZigbeeShutter {
+    private _positionStateId;
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    protected moveToPosition(pPosition: number): void;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeUbisysShutter = void 0;
+const zigbeeShutter_1 = require("./zigbeeShutter");
+const deviceType_1 = require("../deviceType");
+const models_1 = require("../../../models");
+class ZigbeeUbisysShutter extends zigbeeShutter_1.ZigbeeShutter {
+    constructor(pInfo) {
+        super(pInfo, deviceType_1.DeviceType.ZigbeeUbisysShutter);
+        this._positionStateId = `${this.info.fullID}.position`;
+        // this.presenceStateID = `${this.info.fullID}.1.${HmIpPraezenz.PRESENCE_DETECTION}`;
+    }
+    update(idSplit, state, initial = false) {
+        switch (idSplit[3]) {
+            case 'position':
+                this.log(models_1.LogLevel.Trace, `Shutter Update for ${this.info.customName} to "${state.val}"`);
+                this.currentLevel = state.val;
+                break;
+        }
+        super.update(idSplit, state, initial, true);
+    }
+    moveToPosition(pPosition) {
+        this.setState(this._positionStateId, pPosition);
+    }
+}
+exports.ZigbeeUbisysShutter = ZigbeeUbisysShutter;

package/lib/server/services/ShutterService.d.ts

@@ -1,5 +1,4 @@
-import { iShutter } from '../devices/iShutter';
-import { Fenster } from '../devices/groups/Fenster';
+import { Fenster, iShutter } from '../devices';
 export declare class ShutterService {
     static anyRolloDown(rollo: iShutter[]): boolean;
     static getRolladenPosition(): string;

package/lib/server/services/ShutterService.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShutterService = void 0;
-const deviceType_1 = require("../devices/deviceType");
-const devices_1 = require("../devices/devices");
-const api_service_1 = require("./api/api-service");
+const devices_1 = require("../devices");
+const api_1 = require("./api");
 class ShutterService {
     static anyRolloDown(rollo) {
         for (let i = 0; i < rollo.length; i++) {
@@ -24,7 +23,7 @@ class ShutterService {
         }
         response.push(`\nDie nächsten Zeiten zum Hochfahren:`);
         const down = [`\nDie nächsten Zeiten zum Runterfahren:`];
-        for (const r of api_service_1.API.getRooms().values()) {
+        for (const r of api_1.API.getRooms().values()) {
             if (!r.FensterGroup) {
                 continue;
             }
@@ -43,7 +42,9 @@ class ShutterService {
         const rollos = [];
         for (const dID in devices_1.Devices.alLDevices) {
             const d = devices_1.Devices.alLDevices[dID];
-            if (d.deviceType === deviceType_1.DeviceType.HmIpRoll || d.deviceType === deviceType_1.DeviceType.ZigbeeIlluShutter) {
+            if (d.deviceType === devices_1.DeviceType.HmIpRoll ||
+                d.deviceType === devices_1.DeviceType.ZigbeeIlluShutter ||
+                d.deviceType === devices_1.DeviceType.ZigbeeUbisysShutter) {
                 rollos.push(d);
             }
         }

package/lib/server/services/calendar/m/303/274ll-service.d.ts

@@ -1,6 +1,6 @@
-import { TimeCallback } from '../../../models/timeCallback';
-import { iMuellSettings } from '../../config/iConfig';
-import { OwnSonosDevice } from '../Sonos/sonos-service';
+import { TimeCallback } from '../../../models';
+import { iMuellSettings } from '../../config';
+import { OwnSonosDevice } from '../Sonos';
 import { MuellTonne } from './muell-tonne';
 export declare class MuellService {
     static alleTonnen: Array<{
@@ -13,11 +13,11 @@ export declare class MuellService {
     static brauneTonne: MuellTonne;
     static updateTimeCallback: TimeCallback;
     static checkTimeCallback: TimeCallback;
+    static months: string[];
     private static lastCheck;
     private static _calendarURL;
     private static _active;
     private static defaultSonosDevice;
-    static months: string[];
     static intialize(config: iMuellSettings, defaultSonosDevice: OwnSonosDevice | undefined): void;
     static updateCalendar(checkAfterwards?: boolean): void;
     static checkAll(pRetries?: number): void;