@switchbot/homebridge-switchbot 2.5.0-beta.2 → 2.5.0-beta.4

package/dist/device/blindtilt.js

@@ -12,11 +12,20 @@ const super_stringify_1 = __importDefault(require("super-stringify"));
 const operators_1 = require("rxjs/operators");
 const settings_1 = require("../settings");
 const utils_1 = require("../utils");
+var BlindTiltMappingMode;
+(function (BlindTiltMappingMode) {
+    BlindTiltMappingMode["OnlyUp"] = "only_up";
+    BlindTiltMappingMode["OnlyDown"] = "only_down";
+    BlindTiltMappingMode["DownAndUp"] = "down_and_up";
+    BlindTiltMappingMode["UpAndDown"] = "up_and_down";
+    BlindTiltMappingMode["UseTiltForDirection"] = "use_tilt_for_direction";
+})(BlindTiltMappingMode || (BlindTiltMappingMode = {}));
 class BlindTilt {
     constructor(platform, accessory, device) {
         this.platform = platform;
         this.accessory = accessory;
         this.device = device;
+        this.mappingMode = BlindTiltMappingMode.OnlyUp;
         //MQTT stuff
         this.mqttClient = null;
         // Connection
@@ -29,6 +38,8 @@ class BlindTilt {
         this.config(device);
         this.setupMqtt(device);
         this.context();
+        this.mappingMode = device.blindTilt?.mappingMode ?? BlindTiltMappingMode.OnlyUp;
+        this.debugLog(`Mapping mode: ${this.mappingMode}`);
         // this is subject we use to track when we need to POST changes to the SwitchBot API
         this.doBlindTiltUpdate = new rxjs_1.Subject();
         this.blindTiltUpdateInProgress = false;
@@ -82,6 +93,7 @@ class BlindTilt {
             validValueRanges: [0, 100],
         })
             .onSet(this.TargetPositionSet.bind(this));
+        this.CurrentHorizontalTiltAngle = 90;
         this.windowCoveringService
             .getCharacteristic(this.platform.Characteristic.CurrentHorizontalTiltAngle)
             .setProps({
@@ -89,11 +101,12 @@ class BlindTilt {
             minValue: -90,
             maxValue: 90,
             validValues: [-90, 90],
-            validValueRanges: [-90, 90],
         })
             .onGet(() => {
+            // this.debugLog(`requested CurrentHorizontalTiltAngle: ${this.CurrentHorizontalTiltAngle}`);
             return this.CurrentHorizontalTiltAngle;
         });
+        this.TargetHorizontalTiltAngle = 90;
         this.windowCoveringService
             .getCharacteristic(this.platform.Characteristic.TargetHorizontalTiltAngle)
             .setProps({
@@ -101,7 +114,6 @@ class BlindTilt {
             minValue: -90,
             maxValue: 90,
             validValues: [-90, 90],
-            validValueRanges: [-90, 90],
         })
             .onSet(this.TargetHorizontalTiltAngleSet.bind(this));
         // Battery Service
@@ -201,7 +213,7 @@ class BlindTilt {
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} DECREASING PositionState: ${this.PositionState}`);
             }
             else {
-                this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} Standby, CurrentPosition: ${this.CurrentPosition}`);
+                this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} Standby2, CurrentPosition: ${this.CurrentPosition}`);
                 this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
                 this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} STOPPED PositionState: ${this.PositionState}`);
@@ -215,6 +227,57 @@ class BlindTilt {
         }
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition},` +
             ` TargetPosition: ${this.TargetPosition}, PositionState: ${this.PositionState},`);
+        if (!this.device.curtain?.hide_lightsensor) {
+            this.set_minLux = this.minLux();
+            this.set_maxLux = this.maxLux();
+            this.spaceBetweenLevels = 9;
+            // Brightness
+            switch (this.lightLevel) {
+                case 1:
+                    this.CurrentAmbientLightLevel = this.set_minLux;
+                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel}`);
+                    break;
+                case 2:
+                    this.CurrentAmbientLightLevel = (this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels;
+                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel},` +
+                        ` Calculation: ${(this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels}`);
+                    break;
+                case 3:
+                    this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 2;
+                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel}`);
+                    break;
+                case 4:
+                    this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 3;
+                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel}`);
+                    break;
+                case 5:
+                    this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 4;
+                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel}`);
+                    break;
+                case 6:
+                    this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 5;
+                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel}`);
+                    break;
+                case 7:
+                    this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 6;
+                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel}`);
+                    break;
+                case 8:
+                    this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 7;
+                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel}`);
+                    break;
+                case 9:
+                    this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 8;
+                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel}`);
+                    break;
+                case 10:
+                default:
+                    this.CurrentAmbientLightLevel = this.set_maxLux;
+                    this.debugLog();
+            }
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel},`
+                + ` CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+        }
         // Battery
         this.BatteryLevel = Number(this.battery);
         if (this.BatteryLevel < 10) {
@@ -228,16 +291,23 @@ class BlindTilt {
     }
     async openAPIparseStatus() {
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIparseStatus`);
+        const [homekitPosition, homekitTiltAngle] = this.mapDeviceValuesToHomekitValues(Number(this.slidePosition), String(this.direction));
+        this.debugLog(` device: ${this.slidePosition} => HK: ${homekitPosition}`);
+        this.CurrentPosition = homekitPosition;
         // CurrentPosition
-        this.CurrentPosition = 100 - Number(this.slidePosition);
         await this.setMinMax();
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition}`);
+        if (homekitTiltAngle) {
+            this.CurrentHorizontalTiltAngle = homekitTiltAngle;
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentHorizontalTiltAngle: ${this.CurrentHorizontalTiltAngle}`);
+        }
         if (this.setNewTarget) {
             this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Checking Status ...`);
         }
-        if (this.setNewTarget && this.moving) {
+        this.debugLog(`runStatus: ${this.runStatus}`);
+        if (this.setNewTarget || (this.runStatus === undefined || this.runStatus !== 'static')) {
             await this.setMinMax();
-            if (this.TargetPosition > this.CurrentPosition) {
+            if (this.TargetPosition > this.CurrentPosition || (homekitTiltAngle && (this.TargetHorizontalTiltAngle !== this.CurrentHorizontalTiltAngle))) {
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Closing, CurrentPosition: ${this.CurrentPosition} `);
                 this.PositionState = this.platform.Characteristic.PositionState.INCREASING;
                 this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
@@ -250,30 +320,39 @@ class BlindTilt {
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} DECREASING PositionState: ${this.PositionState}`);
             }
             else {
-                this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} Standby, CurrentPosition: ${this.CurrentPosition}`);
+                this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} Standby because reached position,` +
+                    ` CurrentPosition: ${this.CurrentPosition}`);
                 this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
                 this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} STOPPED PositionState: ${this.PositionState}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Standby, CurrentPosition: ${this.CurrentPosition}`);
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Standby because device not moving,` +
+                ` CurrentPosition: ${this.CurrentPosition}`);
             this.TargetPosition = this.CurrentPosition;
+            if (homekitTiltAngle) {
+                this.TargetHorizontalTiltAngle = this.CurrentHorizontalTiltAngle;
+            }
             this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Stopped`);
         }
-        if (this.direction === 'Up') {
-            this.CurrentHorizontalTiltAngle = 90;
-        }
-        else if (this.direction === 'Down') {
-            this.CurrentHorizontalTiltAngle = -90;
-        }
-        else {
-            this.CurrentHorizontalTiltAngle = 0;
-        }
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition},` +
-            ` TargetPosition: ${this.TargetPosition}, PositionState: ${this.PositionState},` +
-            ` CurrentHorizontalTiltAngle: ${this.CurrentHorizontalTiltAngle}`);
+            ` TargetPosition: ${this.TargetPosition}, PositionState: ${this.PositionState},`);
+        if (!this.device.curtain?.hide_lightsensor) {
+            this.set_minLux = this.minLux();
+            this.set_maxLux = this.maxLux();
+            // Brightness
+            switch (this.brightness) {
+                case 'dim':
+                    this.CurrentAmbientLightLevel = this.set_minLux;
+                    break;
+                case 'bright':
+                default:
+                    this.CurrentAmbientLightLevel = this.set_maxLux;
+            }
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+        }
     }
     async refreshStatus() {
         if (!this.device.enableCloudService && this.OpenAPI) {
@@ -305,6 +384,7 @@ class BlindTilt {
         if (switchbot !== false) {
             switchbot
                 .startScan({
+                model: 'c',
                 id: this.device.bleMac,
             })
                 .then(async () => {
@@ -318,9 +398,11 @@ class BlindTilt {
                     this.battery = ad.serviceData.battery;
                     this.inMotion = ad.serviceData.inMotion;
                     this.position = ad.serviceData.position;
+                    this.lightLevel = ad.serviceData.lightLevel;
                     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} serviceData: ${(0, super_stringify_1.default)(ad.serviceData)}`);
                     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} calibration: ${ad.serviceData.calibration}, ` +
-                        `position: ${ad.serviceData.position}, inMotion: ${ad.serviceData.inMotion}, battery: ${ad.serviceData.battery}`);
+                        `position: ${ad.serviceData.position}, lightLevel: ${ad.serviceData.lightLevel}, battery: ${ad.serviceData.battery}, ` +
+                        `inMotion: ${ad.serviceData.inMotion}`);
                     if (this.serviceData) {
                         this.connected = true;
                         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} connected: ${this.connected}`);
@@ -382,10 +464,11 @@ class BlindTilt {
                     try {
                         this.deviceStatus = JSON.parse(rawData);
                         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} refreshStatus: ${(0, super_stringify_1.default)(this.deviceStatus)}`);
-                        this.slidePosition = this.deviceStatus.body.slidePosition; // "slidePosition": 0 = Closed Down | 100 = Closed Up | 50 = Fully Open
+                        this.slidePosition = this.deviceStatus.body.slidePosition;
+                        this.direction = this.deviceStatus.body.direction;
                         this.moving = this.deviceStatus.body.moving;
-                        this.Battery = this.deviceStatus.body.battery;
-                        this.direction = this.deviceStatus.body.direction; // "Up"/"Down"
+                        this.runStatus = this.deviceStatus.body.runStatus;
+                        this.brightness = this.deviceStatus.body.brightness;
                         this.openAPIparseStatus();
                         this.updateHomeKitCharacteristics();
                     }
@@ -438,6 +521,12 @@ class BlindTilt {
                 .join(':')
                 .toLowerCase();
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
+            this.SilentPerformance();
+            const adjustedMode = this.setPositionMode || null;
+            if (adjustedMode === null) {
+                this.Mode = 'Default Mode';
+            }
+            this.debugLog(`${this.accessory.displayName} Mode: ${this.Mode}`);
             if (switchbot !== false) {
                 switchbot
                     .discover({ model: 'c', quick: true, id: this.device.bleMac })
@@ -446,7 +535,7 @@ class BlindTilt {
                     return await this.retry({
                         max: await this.maxRetry(),
                         fn: () => {
-                            return device_list[0].runToPos(100 - Number(this.TargetPosition));
+                            return device_list[0].runToPos(100 - Number(this.TargetPosition), adjustedMode);
                         },
                     });
                 })
@@ -504,40 +593,12 @@ class BlindTilt {
                     .digest();
                 const sign = signTerm.toString('base64');
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} sign: ${sign}`);
-                this.debugLog(`Pushing ${this.TargetPosition}`);
-                let command = '';
-                let parameter = '';
-                if (this.TargetHorizontalTiltAngle === 90 && this.TargetPosition === 100) {
-                    command = 'fullyOpen';
-                    parameter = 'default';
-                }
-                else if (this.TargetHorizontalTiltAngle === -90 && this.TargetPosition === 100) {
-                    command = 'fullyOpen';
-                    parameter = 'default';
-                }
-                else if (this.TargetHorizontalTiltAngle === 90 && this.TargetPosition === 0) {
-                    command = 'closeUp';
-                    parameter = 'default';
-                }
-                else if (this.TargetHorizontalTiltAngle === -90 && this.TargetPosition === 0) {
-                    command = 'closeDown';
-                    parameter = 'default';
-                }
-                else {
-                    let direction = '';
-                    const position = this.TargetPosition;
-                    if (this.TargetHorizontalTiltAngle === 90) {
-                        direction = 'up';
-                    }
-                    else {
-                        direction = 'down';
-                    }
-                    command = 'setPosition';
-                    parameter = `${direction};${position}`;
-                }
+                const [direction, position] = this.mapHomekitValuesToDeviceValues(Number(this.TargetPosition), Number(this.TargetHorizontalTiltAngle));
+                this.debugLog(`Pushing ${this.TargetPosition} (device = ${direction};${position})`);
+                this.debugLog(`${this.accessory.displayName} Mode: ${this.Mode}`);
                 const body = (0, super_stringify_1.default)({
-                    'command': `${command}`,
-                    'parameter': `${parameter}`,
+                    'command': 'setPosition',
+                    'parameter': `${direction};${position}`,
                     'commandType': 'command',
                 });
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${body},`);
@@ -580,6 +641,23 @@ class BlindTilt {
                 + ` Connection, Error Message: ${(0, super_stringify_1.default)(e.message)}`);
         }
     }
+    /**
+     * Handle requests to set the value of the "Target Horizontal Tilt" characteristic
+     */
+    async TargetHorizontalTiltAngleSet(value) {
+        if (this.TargetHorizontalTiltAngle === this.accessory.context.TargetHorizontalTiltAngle) {
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set TargetHorizontalTiltAngle: ${value}`);
+        }
+        else {
+            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set TargetHorizontalTiltAngle: ${value}`);
+        }
+        //value = value < 0 ? -90 : 90;
+        this.TargetHorizontalTiltAngle = value;
+        if (this.device.mqttURL) {
+            this.mqttPublish('TargetHorizontalTiltAngle', this.TargetHorizontalTiltAngle);
+        }
+        this.startUpdatingBlindTiltIfNeeded();
+    }
     /**
      * Handle requests to set the value of the "Target Position" characteristic
      */
@@ -594,52 +672,28 @@ class BlindTilt {
         if (this.device.mqttURL) {
             this.mqttPublish('TargetPosition', this.TargetPosition);
         }
+        this.startUpdatingBlindTiltIfNeeded();
+    }
+    async startUpdatingBlindTiltIfNeeded() {
         await this.setMinMax();
-        if (value > this.CurrentPosition) {
+        this.debugLog('setMinMax');
+        if (this.TargetPosition > this.CurrentPosition || (this.TargetHorizontalTiltAngle !== this.CurrentHorizontalTiltAngle)) {
             this.PositionState = this.platform.Characteristic.PositionState.INCREASING;
             this.setNewTarget = true;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${value}, CurrentPosition: ${this.CurrentPosition}`);
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.CurrentPosition},` +
+                ` CurrentPosition: ${this.CurrentPosition}`);
         }
-        else if (value < this.CurrentPosition) {
+        else if (this.TargetPosition < this.CurrentPosition) {
             this.PositionState = this.platform.Characteristic.PositionState.DECREASING;
             this.setNewTarget = true;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${value}, CurrentPosition: ${this.CurrentPosition}`);
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.CurrentPosition},` +
+                ` CurrentPosition: ${this.CurrentPosition}`);
         }
         else {
             this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
             this.setNewTarget = false;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${value}, CurrentPosition: ${this.CurrentPosition}`);
-        }
-        this.windowCoveringService.setCharacteristic(this.platform.Characteristic.PositionState, this.PositionState);
-        this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
-        /**
-         * If Blind Tilt movement time is short, the moving flag from backend is always false.
-         * The minimum time depends on the network control latency.
-         */
-        clearTimeout(this.setNewTargetTimer);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateRate: ${this.updateRate}`);
-        if (this.setNewTarget) {
-            this.setNewTargetTimer = setTimeout(() => {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} setNewTarget ${this.setNewTarget} timeout`);
-                this.setNewTarget = false;
-            }, this.updateRate * 1000);
-        }
-        this.doBlindTiltUpdate.next();
-    }
-    /**
-     * Handle requests to set the value of the "Target Position" characteristic
-     */
-    async TargetHorizontalTiltAngleSet(value) {
-        if (this.TargetHorizontalTiltAngle === this.accessory.context.TargetHorizontalTiltAngle) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set TargetHorizontalTiltAngle: ${value}`);
-        }
-        else {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set TargetHorizontalTiltAngle: ${value}`);
-        }
-        this.TargetHorizontalTiltAngle = value;
-        this.accessory.context.TargetHorizontalTiltAngle = this.TargetHorizontalTiltAngle;
-        if (this.device.mqttURL) {
-            this.mqttPublish('TargetHorizontalTiltAngle', this.TargetHorizontalTiltAngle);
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.CurrentPosition},` +
+                ` CurrentPosition: ${this.CurrentPosition}`);
         }
         this.windowCoveringService.setCharacteristic(this.platform.Characteristic.PositionState, this.PositionState);
         this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
@@ -659,6 +713,20 @@ class BlindTilt {
     }
     async updateHomeKitCharacteristics() {
         await this.setMinMax();
+        if (this.mappingMode === BlindTiltMappingMode.UseTiltForDirection) {
+            if (this.CurrentHorizontalTiltAngle === undefined || Number.isNaN(this.CurrentHorizontalTiltAngle)) {
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentHorizontalTiltAngle: ${this.CurrentHorizontalTiltAngle}`);
+            }
+            else {
+                if (this.device.mqttURL) {
+                    this.mqttPublish('CurrentHorizontalTiltAngle', this.CurrentHorizontalTiltAngle);
+                }
+                this.accessory.context.CurrentHorizontalTiltAngle = this.CurrentHorizontalTiltAngle;
+                this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.CurrentHorizontalTiltAngle, Number(this.CurrentHorizontalTiltAngle));
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 
+        updateCharacteristic CurrentHorizontalTiltAngle: ${this.CurrentHorizontalTiltAngle}`);
+            }
+        }
         if (this.CurrentPosition === undefined || Number.isNaN(this.CurrentPosition)) {
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition}`);
         }
@@ -692,17 +760,19 @@ class BlindTilt {
             this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.TargetPosition, Number(this.TargetPosition));
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic TargetPosition: ${this.TargetPosition}`);
         }
-        if (this.TargetHorizontalTiltAngle === undefined || Number.isNaN(this.TargetHorizontalTiltAngle)) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} TargetHorizontalTiltAngle: ${this.TargetHorizontalTiltAngle}`);
-        }
-        else {
-            if (this.device.mqttURL) {
-                this.mqttPublish('TargetHorizontalTiltAngle', this.TargetHorizontalTiltAngle);
+        if (!this.device.curtain?.hide_lightsensor) {
+            if (this.CurrentAmbientLightLevel === undefined || Number.isNaN(this.CurrentAmbientLightLevel)) {
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+            }
+            else {
+                if (this.device.mqttURL) {
+                    this.mqttPublish('CurrentAmbientLightLevel', this.CurrentAmbientLightLevel);
+                }
+                this.accessory.context.CurrentAmbientLightLevel = this.CurrentAmbientLightLevel;
+                this.lightSensorService?.updateCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel, this.CurrentAmbientLightLevel);
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
+                    + ` updateCharacteristic CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
             }
-            this.accessory.context.TargetHorizontalTiltAngle = this.TargetHorizontalTiltAngle;
-            this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.TargetHorizontalTiltAngle, Number(this.TargetHorizontalTiltAngle));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-                + ` TargetHorizontalTiltAngle: ${this.TargetHorizontalTiltAngle}`);
         }
         if (this.BLE) {
             if (this.BatteryLevel === undefined) {
@@ -800,6 +870,28 @@ class BlindTilt {
             await this.openAPIRefreshStatus();
         }
     }
+    async SilentPerformance() {
+        if (this.TargetPosition > 50) {
+            if (this.device.curtain?.setOpenMode === '1') {
+                this.setPositionMode = 1;
+                this.Mode = 'Silent Mode';
+            }
+            else {
+                this.setPositionMode = 0;
+                this.Mode = 'Performance Mode';
+            }
+        }
+        else {
+            if (this.device.curtain?.setCloseMode === '1') {
+                this.setPositionMode = 1;
+                this.Mode = 'Silent Mode';
+            }
+            else {
+                this.setPositionMode = 0;
+                this.Mode = 'Performance Mode';
+            }
+        }
+    }
     async setMinMax() {
         if (this.device.curtain?.set_min) {
             if (this.CurrentPosition <= this.device.curtain?.set_min) {
@@ -811,13 +903,16 @@ class BlindTilt {
                 this.CurrentPosition = 100;
             }
         }
+        if (this.mappingMode === BlindTiltMappingMode.UseTiltForDirection) {
+            this.CurrentHorizontalTiltAngle = this.CurrentHorizontalTiltAngle < 0 ? -90 : 90;
+        }
     }
     minStep(device) {
         if (device.curtain?.set_minStep) {
             this.set_minStep = device.curtain?.set_minStep;
         }
         else {
-            this.set_minStep = 90;
+            this.set_minStep = 1;
         }
         return this.set_minStep;
     }
@@ -911,6 +1006,9 @@ class BlindTilt {
         this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.CurrentPosition, e);
         this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.PositionState, e);
         this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.TargetPosition, e);
+        if (!this.device.curtain?.hide_lightsensor) {
+            this.lightSensorService?.updateCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel, e);
+        }
         if (this.BLE) {
             this.batteryService?.updateCharacteristic(this.platform.Characteristic.BatteryLevel, e);
             this.batteryService?.updateCharacteristic(this.platform.Characteristic.StatusLowBattery, e);
@@ -947,12 +1045,6 @@ class BlindTilt {
         else {
             this.TargetPosition = this.accessory.context.TargetPosition;
         }
-        if (this.TargetHorizontalTiltAngle === undefined) {
-            this.TargetHorizontalTiltAngle = 0;
-        }
-        else {
-            this.TargetHorizontalTiltAngle = this.accessory.context.TargetHorizontalTiltAngle;
-        }
         if (this.PositionState === undefined) {
             this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
         }
@@ -960,6 +1052,120 @@ class BlindTilt {
             this.PositionState = this.accessory.context.PositionState;
         }
     }
+    /**
+     * Maps device values to homekit values
+     *
+     * @param devicePosition the position as reported by the devide
+     * @param direction the direction as reported by the device
+     * @returns [homekit position, homekit tiltAngle]
+     */
+    mapDeviceValuesToHomekitValues(devicePosition, deviceDirection) {
+        // device position 0 => closed down
+        // device position 50 => open
+        // device position 100 => closed up
+        // homekit position 0 =>  closed
+        // homekit position 100 => open
+        deviceDirection;
+        switch (this.mappingMode) {
+            case BlindTiltMappingMode.OnlyUp:
+                // we only close upwards, so we see anything that is tilted downwards(<50) as open
+                if (devicePosition < 50) {
+                    return [100, undefined]; // fully open in homekit
+                }
+                else {
+                    // we range from 50->100, with 100 being closed, so map to homekit by scaling to 0..100 and then reversing
+                    return [100 - (devicePosition - 50) * 2, undefined];
+                }
+            case BlindTiltMappingMode.OnlyDown:
+                // we only close downwards, so we see anything that is tilted upwards(>50) as upwards
+                if (devicePosition > 50) {
+                    return [100, undefined]; // fully open in homekit
+                }
+                else {
+                    // we range from 0..50 so scale to homekit and then reverse
+                    return [devicePosition * 2, undefined];
+                }
+            case BlindTiltMappingMode.DownAndUp:
+                // we close both ways with closed downwards being 0 in homekit and closed upwards in homekit being 100. Open is 50 in homekit
+                return [devicePosition, undefined];
+            case BlindTiltMappingMode.UpAndDown:
+                // we close both ways with closed downwards being 1000 in homekit and closed upwards in homekit being 0. Open is 50 in homekit.,
+                // so we reverse the value
+                return [100 - devicePosition, undefined];
+            case BlindTiltMappingMode.UseTiltForDirection:
+                // we use tilt for direction, so being closed downwards is 0 in homekit with -90 tilt, while being closed upwards is 0 with 90 tilt.
+                if (devicePosition <= 50) {
+                    // downwards tilted, so we range from 0..50, with 0 being closed and 50 being open, so scale.
+                    return [devicePosition * 2, -90];
+                }
+                else {
+                    // upwards tilted, so we range from 50..100, with 50 being open and 100 being closed, so scale and rever
+                    return [100 - (devicePosition - 50) * 2, 90];
+                }
+        }
+    }
+    /**
+     * Maps homekit values to device values
+     *
+     * @param homekitPosition the position as reported by homekit
+     * @param homekitTiltAngle? the tilt angle as reported by homekit
+     * @returns [device position, device direction]
+     */
+    mapHomekitValuesToDeviceValues(homekitPosition, homekitTiltAngle) {
+        // homekit position 0 =>  closed
+        // homekit position 100 => open
+        // device position [up, 0] = closed upwards
+        // device position [down, 0] = closed downwards
+        // device position [up, 100] = open
+        // device position [down, 100] = open
+        switch (this.mappingMode) {
+            case BlindTiltMappingMode.OnlyUp:
+                // invert
+                return ['up', homekitPosition];
+            case BlindTiltMappingMode.OnlyDown:
+                // invert
+                return ['down', homekitPosition];
+            case BlindTiltMappingMode.DownAndUp:
+                // homekit 0 = downwards closed,
+                // homekit 50 = open,
+                // homekit 100 = upwards closed
+                if (homekitPosition <= 50) {
+                    // homekit 0..50 -> device 100..0 so scale and invert
+                    return ['down', 100 - homekitPosition * 2];
+                }
+                else {
+                    // homekit 50..100 -> device 0..100, so rebase, scale and invert
+                    return ['up', (homekitPosition - 50) * 2];
+                }
+            case BlindTiltMappingMode.UpAndDown:
+                // homekit 0 = upwards closed,
+                // homekit 50 = open,
+                // homekit 100 = upwards closed
+                if (homekitPosition <= 50) {
+                    // homekit 0..50 -> device 0..100 so scale and invert
+                    return ['up', homekitPosition * 2];
+                }
+                else {
+                    // homekit 50..100 -> device 100...0 so scale
+                    return ['down', 100 - homekitPosition * 2];
+                }
+            case BlindTiltMappingMode.UseTiltForDirection:
+                // tilt -90, homekit 0 = closed downwards
+                // tilt -90, homekit 100 = open
+                // tilt 90, homekit 0 = closed upwards
+                // tilt 90, homekit 100 = open
+                if (homekitTiltAngle <= 0) {
+                    // downwards
+                    // homekit 0..100 -> device 0..100, so invert
+                    return ['down', homekitPosition];
+                }
+                else {
+                    // upwards
+                    // homekit 0..100 -> device 0..100, so invert
+                    return ['up,', homekitPosition];
+                }
+        }
+    }
     async refreshRate(device) {
         // refreshRate
         if (device.refreshRate) {
@@ -971,19 +1177,19 @@ class BlindTilt {
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Platform Config refreshRate: ${this.deviceRefreshRate}`);
         }
         // updateRate
-        if (device?.curtain?.updateRate) {
-            this.updateRate = device?.curtain?.updateRate;
+        if (device?.blindTilt?.updateRate) {
+            this.updateRate = device?.blindTilt?.updateRate;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Config Blind Tilt updateRate: ${this.updateRate}`);
         }
         else {
-            this.updateRate = 7;
+            this.updateRate = 2;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Default Blind Tilt updateRate: ${this.updateRate}`);
         }
     }
     async config(device) {
         let config = {};
-        if (device.curtain) {
-            config = device.curtain;
+        if (device.blindTilt) {
+            config = device.blindTilt;
         }
         if (device.connectionType !== undefined) {
             config['connectionType'] = device.connectionType;
@@ -1006,6 +1212,12 @@ class BlindTilt {
         if (device.maxRetry !== undefined) {
             config['maxRetry'] = device.maxRetry;
         }
+        if (device.blindTilt?.mappingMode === undefined) {
+            config['mappingMode'] = BlindTiltMappingMode.OnlyUp;
+        }
+        else {
+            config['mappingMode'] = device.blindTilt?.mappingMode;
+        }
         if (Object.entries(config).length !== 0) {
             this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Config: ${(0, super_stringify_1.default)(config)}`);
         }