@switchbot/homebridge-switchbot 3.5.1-beta.2 → 3.5.1-beta.3

package/dist/device/curtain.js

@@ -3,9 +3,9 @@
  * curtain.ts: @switchbot/homebridge-switchbot.
  */
 import { hostname } from 'os';
-import { interval, Subject } from 'rxjs';
 import { deviceBase } from './device.js';
-import { debounceTime, skipWhile, take, tap } from 'rxjs/operators';
+import { SwitchBotBLEModel, SwitchBotBLEModelName } from 'node-switchbot';
+import { Subject, debounceTime, interval, skipWhile, take, tap } from 'rxjs';
 export class Curtain extends deviceBase {
     platform;
     // Services
@@ -21,8 +21,6 @@ export class Curtain extends deviceBase {
     constructor(platform, accessory, device) {
         super(platform, accessory, device);
         this.platform = platform;
-        // default placeholder
-        this.history(device);
         // this is subject we use to track when we need to POST changes to the SwitchBot API
         this.doCurtainUpdate = new Subject();
         this.curtainUpdateInProgress = false;
@@ -108,7 +106,7 @@ export class Curtain extends deviceBase {
         // Initialize LightSensor Service
         if (device.curtain?.hide_lightsensor) {
             if (this.LightSensor?.Service) {
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Removing Light Sensor Service`);
+                this.debugLog('Removing Light Sensor Service');
                 this.LightSensor.Service = this.accessory.getService(this.hap.Service.LightSensor);
                 accessory.removeService(this.LightSensor.Service);
                 accessory.context.LightSensor = {};
@@ -135,14 +133,16 @@ export class Curtain extends deviceBase {
         this.refreshStatus();
         // Update Homekit
         this.updateHomeKitCharacteristics();
+        //regisiter webhook event handler
+        this.registerWebhook();
+        // History
+        this.history();
         // Start an update interval
         interval(this.deviceRefreshRate * 1000)
             .pipe(skipWhile(() => this.curtainUpdateInProgress))
             .subscribe(async () => {
             await this.refreshStatus();
         });
-        //regisiter webhook event handler
-        this.registerWebhook(accessory, device);
         // update slide progress
         interval(this.deviceUpdateRate * 1000)
             //.pipe(skipWhile(() => this.curtainUpdateInProgress))
@@ -150,8 +150,7 @@ export class Curtain extends deviceBase {
             if (this.WindowCovering.PositionState === this.hap.Characteristic.PositionState.STOPPED) {
                 return;
             }
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Refresh Status When Moving,`
-                + ` PositionState: ${this.WindowCovering.PositionState}`);
+            await this.debugLog(`Refresh Status When Moving, PositionState: ${this.WindowCovering.PositionState}`);
             await this.refreshStatus();
         });
         // Watch for Curtain change events
@@ -165,17 +164,16 @@ export class Curtain extends deviceBase {
                 await this.pushChanges();
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType} Connection,`
-                    + ` Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushChanges with ${device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
             this.curtainUpdateInProgress = false;
         });
         // Setup EVE history features
-        this.setupHistoryService(accessory, device);
+        this.setupHistoryService();
     }
-    history(device) {
-        if (device.history === true) {
+    async history() {
+        if (this.device.history === true) {
             // initialize when this accessory is newly created.
             this.accessory.context.lastActivation = this.accessory.context.lastActivation ?? 0;
         }
@@ -187,8 +185,8 @@ export class Curtain extends deviceBase {
     /*
      * Setup EVE history features for curtain devices.
      */
-    async setupHistoryService(accessory, device) {
-        if (device.history !== true) {
+    async setupHistoryService() {
+        if (this.device.history !== true) {
             return;
         }
         const mac = this.device
@@ -230,189 +228,91 @@ export class Curtain extends deviceBase {
             time: Math.round(new Date().valueOf() / 1000),
             motion: motion,
         });
-        setTimeout(() => {
-            this.updateHistory();
+        setTimeout(async () => {
+            await this.updateHistory();
         }, 10 * 60 * 1000);
     }
     async BLEparseStatus(serviceData) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEparseStatus`);
-        this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} ${JSON.stringify(serviceData)}`);
+        await this.debugLog('BLEparseStatus');
         // CurrentPosition
-        this.WindowCovering.CurrentPosition = 100 - Number(serviceData.position);
-        await this.setMinMax();
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition ${this.WindowCovering.CurrentPosition}`);
-        if (this.setNewTarget) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Checking Status ...`);
-            await this.setMinMax();
-            if (Number(this.WindowCovering.TargetPosition) > this.WindowCovering.CurrentPosition) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Closing, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
-                this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.INCREASING;
-                this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
-                this.debugLog(`${this.device.deviceType}: ${this.WindowCovering.CurrentPosition} INCREASING`
-                    + ` PositionState: ${this.WindowCovering.PositionState}`);
-            }
-            else if (Number(this.WindowCovering.TargetPosition) < this.WindowCovering.CurrentPosition) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Opening, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
-                this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.DECREASING;
-                this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
-                this.debugLog(`${this.device.deviceType}: ${this.WindowCovering.CurrentPosition} DECREASING`
-                    + ` PositionState: ${this.WindowCovering.PositionState}`);
-            }
-            else {
-                this.debugLog(`${this.device.deviceType}: ${this.WindowCovering.CurrentPosition} Standby,`
-                    + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
-                this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.STOPPED;
-                this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
-                this.debugLog(`${this.device.deviceType}: ${this.WindowCovering.CurrentPosition} STOPPED`
-                    + ` PositionState: ${this.WindowCovering.PositionState}`);
-            }
-        }
-        else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Standby, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
-            this.WindowCovering.TargetPosition = this.WindowCovering.CurrentPosition;
-            this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.STOPPED;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Stopped`);
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.WindowCovering.CurrentPosition},`
-            + ` TargetPosition: ${this.WindowCovering.TargetPosition}, PositionState: ${this.WindowCovering.PositionState},`);
-        if (!this.device.curtain?.hide_lightsensor) {
+        this.WindowCovering.CurrentPosition = 100 - serviceData.position;
+        await this.getCurrentPostion();
+        // CurrentAmbientLightLevel
+        if (!this.device.curtain?.hide_lightsensor && this.LightSensor?.Service) {
             const set_minLux = this.device.curtain?.set_minLux ?? 1;
             const set_maxLux = this.device.curtain?.set_maxLux ?? 6001;
-            const spaceBetweenLevels = 9;
-            // Brightness
-            switch (serviceData.lightLevel) {
-                case 1:
-                    this.LightSensor.CurrentAmbientLightLevel = set_minLux;
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-                    break;
-                case 2:
-                    this.LightSensor.CurrentAmbientLightLevel = (set_maxLux - set_minLux) / spaceBetweenLevels;
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel},`
-                        + ` Calculation: ${(set_maxLux - set_minLux) / spaceBetweenLevels}`);
-                    break;
-                case 3:
-                    this.LightSensor.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 2;
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-                    break;
-                case 4:
-                    this.LightSensor.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 3;
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-                    break;
-                case 5:
-                    this.LightSensor.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 4;
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-                    break;
-                case 6:
-                    this.LightSensor.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 5;
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-                    break;
-                case 7:
-                    this.LightSensor.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 6;
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-                    break;
-                case 8:
-                    this.LightSensor.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 7;
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-                    break;
-                case 9:
-                    this.LightSensor.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 8;
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-                    break;
-                case 10:
-                default:
-                    this.LightSensor.CurrentAmbientLightLevel = set_maxLux;
-                    this.debugLog();
-            }
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel},`
+            const lightLevel = Number(serviceData.lightLevel);
+            this.LightSensor.CurrentAmbientLightLevel = await this.getLightLevel(lightLevel, set_minLux, set_maxLux, 19);
+            this.debugLog(`LightLevel: ${serviceData.lightLevel},`
                 + ` CurrentAmbientLightLevel: ${this.LightSensor.CurrentAmbientLightLevel}`);
         }
-        // Battery
+        // BatteryLevel
         this.Battery.BatteryLevel = Number(serviceData.battery);
-        if (this.Battery.BatteryLevel < 10) {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
-        }
-        else {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel},`
-            + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        // StatusLowBattery
+        this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
+            ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
     }
     async openAPIparseStatus(deviceStatus) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIparseStatus`);
+        await this.debugLog('openAPIparseStatus');
         // CurrentPosition
-        this.WindowCovering.CurrentPosition = 100 - Number(deviceStatus.body.slidePosition);
+        this.WindowCovering.CurrentPosition = 100 - deviceStatus.slidePosition;
         await this.setMinMax();
-        this.debugLog(`Curtain ${this.accessory.displayName} CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+        await this.debugLog(`Curtain ${this.accessory.displayName} CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
         if (this.setNewTarget) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Checking Status ...`);
+            await this.infoLog('Checking Status ...');
         }
-        if (this.setNewTarget && deviceStatus.body.moving) {
+        if (this.setNewTarget && deviceStatus.moving) {
             await this.setMinMax();
             if (Number(this.WindowCovering.TargetPosition) > this.WindowCovering.CurrentPosition) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Closing, CurrentPosition: ${this.WindowCovering.CurrentPosition} `);
+                await this.debugLog(`Closing, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
                 this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.INCREASING;
                 this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
-                this.debugLog(`${this.device.deviceType}: ${this.WindowCovering.CurrentPosition} INCREASING`
-                    + ` PositionState: ${this.WindowCovering.PositionState}`);
+                await this.debugLog(`Increasing, PositionState: ${this.WindowCovering.PositionState}`);
             }
             else if (Number(this.WindowCovering.TargetPosition) < this.WindowCovering.CurrentPosition) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Opening, CurrentPosition: ${this.WindowCovering.CurrentPosition} `);
+                await this.debugLog(`Opening, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
                 this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.DECREASING;
                 this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
-                this.debugLog(`${this.device.deviceType}: ${this.WindowCovering.CurrentPosition} DECREASING`
-                    + ` PositionState: ${this.WindowCovering.PositionState}`);
+                await this.debugLog(`Decreasing, PositionState: ${this.WindowCovering.PositionState}`);
             }
             else {
-                this.debugLog(`${this.device.deviceType}: ${this.WindowCovering.CurrentPosition} Standby,`
-                    + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+                await this.debugLog(`Standby, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
                 this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.STOPPED;
                 this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
-                this.debugLog(`${this.device.deviceType}: ${this.WindowCovering.CurrentPosition} STOPPED`
-                    + ` PositionState: ${this.WindowCovering.PositionState}`);
+                await this.debugLog(`Stopped, PositionState: ${this.WindowCovering.PositionState}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Standby, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+            await this.debugLog(`Standby, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
             this.WindowCovering.TargetPosition = this.WindowCovering.CurrentPosition;
             this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.STOPPED;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Stopped`);
+            await this.debugLog(`Stopped, PositionState: ${this.WindowCovering.PositionState}`);
         }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.WindowCovering.CurrentPosition},`
-            + ` TargetPosition: ${this.WindowCovering.TargetPosition}, PositionState: ${this.WindowCovering.PositionState},`);
+        await this.debugLog(`CurrentPosition: ${this.WindowCovering.CurrentPosition}, TargetPosition: ${this.WindowCovering.TargetPosition},`
+            + ` PositionState: ${this.WindowCovering.PositionState},`);
         // Brightness
-        if (!this.device.curtain?.hide_lightsensor) {
+        if (!this.device.curtain?.hide_lightsensor && this.LightSensor?.Service) {
             const set_minLux = this.device.curtain?.set_minLux ?? 1;
             const set_maxLux = this.device.curtain?.set_maxLux ?? 6001;
-            switch (deviceStatus.body.brightness) {
-                case 'bright':
-                    this.LightSensor.CurrentAmbientLightLevel = set_maxLux;
-                    this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
-                    break;
-                case 'dim':
-                default:
-                    this.LightSensor.CurrentAmbientLightLevel = set_minLux;
-            }
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
+            const lightLevel = deviceStatus.lightLevel === 'bright' ? set_maxLux : set_minLux;
+            this.LightSensor.CurrentAmbientLightLevel = await this.getLightLevel(lightLevel, set_minLux, set_maxLux, 2);
+            await this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
                 + ` CurrentAmbientLightLevel: ${this.LightSensor.CurrentAmbientLightLevel}`);
         }
         // BatteryLevel
-        this.Battery.BatteryLevel = Number(deviceStatus.body.battery);
-        if (this.Battery.BatteryLevel < 10) {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
-        }
-        else {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-        }
-        if (Number.isNaN(this.Battery.BatteryLevel)) {
-            this.Battery.BatteryLevel = 100;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel},`
-            + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        this.Battery.BatteryLevel = Number(deviceStatus.battery);
+        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        // StatusLowBattery
+        this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
+            ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
         // Firmware Version
-        const version = deviceStatus.body.version?.toString();
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Firmware Version: ${version?.replace(/^V|-.*$/g, '')}`);
-        if (deviceStatus.body.version) {
-            const deviceVersion = version?.replace(/^V|-.*$/g, '') ?? '0.0.0';
+        if (deviceStatus.version) {
+            const version = deviceStatus.version.toString();
+            await this.debugLog(`Firmware Version: ${version.replace(/^V|-.*$/g, '')}`);
+            const deviceVersion = version.replace(/^V|-.*$/g, '') ?? '0.0.0';
             this.accessory
                 .getService(this.hap.Service.AccessoryInformation)
                 .setCharacteristic(this.hap.Characteristic.HardwareRevision, deviceVersion)
@@ -420,12 +320,30 @@ export class Curtain extends deviceBase {
                 .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
                 .updateValue(deviceVersion);
             this.accessory.context.deviceVersion = deviceVersion;
-            this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceVersion: ${this.accessory.context.deviceVersion}`);
+            await this.debugSuccessLog(`deviceVersion: ${this.accessory.context.deviceVersion}`);
         }
     }
+    async parseStatusWebhook(context) {
+        await this.debugLog('parseStatusWebhook');
+        await this.debugLog(`(slidePosition, battery) = Webhook:(${context.slidePosition}, ${context.battery}),`
+            + ` current:(${this.WindowCovering.CurrentPosition}, ${this.Battery.BatteryLevel})`);
+        // CurrentPosition
+        this.WindowCovering.CurrentPosition = 100 - context.slidePosition;
+        await this.getCurrentPostion();
+        // BatteryLevel
+        this.Battery.BatteryLevel = context.battery;
+        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        // StatusLowBattery
+        this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
+            ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+    }
+    /**
+     * Asks the SwitchBot API for the latest device information
+     */
     async refreshStatus() {
         if (!this.device.enableCloudService && this.OpenAPI) {
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} refreshStatus enableCloudService: ${this.device.enableCloudService}`);
+            await this.errorLog(`refreshStatus enableCloudService: ${this.device.enableCloudService}`);
         }
         else if (this.BLE) {
             await this.BLERefreshStatus();
@@ -435,12 +353,11 @@ export class Curtain extends deviceBase {
         }
         else {
             await this.offlineOff();
-            this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-                + ` ${this.device.connectionType}, refreshStatus will not happen.`);
+            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, refreshStatus will not happen.`);
         }
     }
     async BLERefreshStatus() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLERefreshStatus`);
+        await this.debugLog('BLERefreshStatus');
         const switchbot = await this.switchbotBLE();
         if (switchbot === undefined) {
             await this.BLERefreshConnection(switchbot);
@@ -451,62 +368,64 @@ export class Curtain extends deviceBase {
                 // Start to monitor advertisement packets
                 const serviceData = await this.monitorAdvertisementPackets(switchbot);
                 // Update HomeKit
-                if (serviceData.model !== '' && serviceData.modelName !== '') {
+                if ((serviceData.model === SwitchBotBLEModel.Curtain || SwitchBotBLEModel.Curtain3)
+                    && (serviceData.modelName === SwitchBotBLEModelName.Curtain || SwitchBotBLEModelName.Curtain3)) {
                     await this.BLEparseStatus(serviceData);
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed to get serviceData, serviceData: ${serviceData}`);
+                    await this.errorLog(`failed to get serviceData, serviceData: ${serviceData}`);
                     await this.BLERefreshConnection(switchbot);
                 }
             })();
         }
     }
     async openAPIRefreshStatus() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
+        await this.debugLog('openAPIRefreshStatus');
         try {
             const { body, statusCode } = await this.deviceRefreshStatus();
             const deviceStatus = await body.json();
-            await this.refreshStatusCodes(statusCode, deviceStatus);
-            if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                await this.successfulRefreshStatus(statusCode, deviceStatus);
-                await this.openAPIparseStatus(deviceStatus);
+            await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+            ;
+            if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                await this.openAPIparseStatus(deviceStatus.body);
                 await this.updateHomeKitCharacteristics();
             }
             else {
-                await this.statusCodes(statusCode, deviceStatus);
+                await this.debugWarnLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                await this.debugWarnLog(statusCode, deviceStatus);
             }
         }
         catch (e) {
             await this.apiError(e);
-            await this.openAPIRefreshError(e);
+            await this.errorLog(`failed openAPIRefreshStatus with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
         }
     }
-    async registerWebhook(accessory, device) {
-        if (device.webhook) {
-            this.debugLog(`${device.deviceType}: ${accessory.displayName} is listening webhook.`);
-            this.platform.webhookEventHandler[device.deviceId] = async (context) => {
+    async registerWebhook() {
+        if (this.device.webhook) {
+            await this.debugLog('is listening webhook.');
+            this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
                 try {
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
-                    const { slidePosition, battery } = context;
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} ` +
-                        '(slidePosition, battery) = ' +
-                        `Webhook:(${slidePosition}, ${battery}), `
-                        + `current:(${this.WindowCovering.CurrentPosition}, ${this.Battery.BatteryLevel})`);
-                    this.WindowCovering.CurrentPosition = slidePosition;
-                    this.Battery.BatteryLevel = battery;
-                    this.updateHomeKitCharacteristics();
+                    await this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
+                    await this.parseStatusWebhook(context);
+                    await this.updateHomeKitCharacteristics();
                 }
                 catch (e) {
-                    this.errorLog(`${device.deviceType}: ${accessory.displayName} `
-                        + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+                    await this.errorLog(`failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
                 }
             };
         }
+        else {
+            await this.debugLog('is not listening webhook.');
+        }
     }
+    /**
+     * Pushes the requested changes to the SwitchBot API
+     */
     async pushChanges() {
         if (!this.device.enableCloudService && this.OpenAPI) {
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} pushChanges enableCloudService: ${this.device.enableCloudService}`);
+            await this.errorLog(`pushChanges enableCloudService: ${this.device.enableCloudService}`);
         }
         else if (this.BLE) {
             await this.BLEpushChanges();
@@ -516,7 +435,7 @@ export class Curtain extends deviceBase {
         }
         else {
             await this.offlineOff();
-            await this.pushChangeDisabled();
+            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, pushChanges will not happen.`);
         }
         // Refresh the status from the API
         interval(15000)
@@ -527,108 +446,100 @@ export class Curtain extends deviceBase {
         });
     }
     async BLEpushChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushChanges`);
+        await this.debugLog('BLEpushChanges');
         if (this.WindowCovering.TargetPosition !== this.WindowCovering.CurrentPosition) {
-            const switchbot = await this.platform.connectBLE();
-            // Convert to BLE Address
+            const switchbot = await this.platform.connectBLE(this.accessory, this.device);
             await this.convertBLEAddress();
             const { setPositionMode, Mode } = await this.setPerformance();
             const adjustedMode = setPositionMode === 1 ? 0x01 : 0xff;
-            this.debugLog(`${this.accessory.displayName} Mode: ${Mode}`);
+            await this.debugLog(`Mode: ${Mode}, setPositionMode: ${setPositionMode}`);
             if (switchbot !== false) {
-                try {
-                    const device_list = await switchbot.discover({ model: this.device.bleModel, quick: true, id: this.device.bleMac });
-                    this.infoLog(`${this.accessory.displayName} Target Position: ${this.WindowCovering.TargetPosition}`);
-                    await this.retryBLE({
+                switchbot
+                    .discover({ model: this.device.bleModel, quick: true, id: this.device.bleMac })
+                    .then(async (device_list) => {
+                    return await this.retryBLE({
                         max: await this.maxRetryBLE(),
                         fn: async () => {
-                            await device_list[0].runToPos(100 - Number(this.WindowCovering.TargetPosition), adjustedMode);
+                            return await device_list[0].runToPos(100 - Number(this.WindowCovering.TargetPosition), adjustedMode);
                         },
                     });
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
-                    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `TargetPosition: ${this.WindowCovering.TargetPosition} sent over BLE,  sent successfully`);
-                }
-                catch (e) {
-                    this.apiError(e);
-                    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
-                        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                })
+                    .then(async () => {
+                    await this.successLog(`TargetPostion: ${this.WindowCovering.TargetPosition} sent over SwitchBot BLE,  sent successfully`);
+                    await this.updateHomeKitCharacteristics();
+                })
+                    .catch(async (e) => {
+                    await this.apiError(e);
+                    await this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
                     await this.BLEPushConnection();
-                    throw new Error('Connection error');
-                }
+                });
             }
             else {
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
+                await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
                 await this.BLEPushConnection();
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No BLEpushChanges, CurrentPosition & TargetPosition Are the Same.`
-                + `  CurrentPosition: ${this.WindowCovering.CurrentPosition}, TargetPosition  ${this.WindowCovering.TargetPosition}`);
+            await this.debugLog(`No changes (BLEpushChanges), TargetPosition: ${this.WindowCovering.TargetPosition},`
+                + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
         }
     }
     async openAPIpushChanges() {
-        let command;
-        let parameter;
-        let commandType;
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIpushChanges`);
+        await this.debugLog('openAPIpushChanges');
         if (this.WindowCovering.TargetPosition !== this.WindowCovering.CurrentPosition || this.device.disableCaching) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Pushing ${this.WindowCovering.TargetPosition}`);
+            await this.debugLog(`Pushing ${this.WindowCovering.TargetPosition}`);
             const adjustedTargetPosition = 100 - Number(this.WindowCovering.TargetPosition);
             const { setPositionMode, Mode } = await this.setPerformance();
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Mode: ${Mode}`);
+            await this.debugLog(`Mode: ${Mode}, setPositionMode: ${setPositionMode}`);
             const adjustedMode = setPositionMode || 'ff';
+            let bodyChange;
             if (this.WindowCovering.HoldPosition) {
-                command = 'pause';
-                parameter = 'default';
-                commandType = 'command';
+                bodyChange = JSON.stringify({
+                    command: 'pause',
+                    parameter: 'default',
+                    commandType: 'command',
+                });
             }
             else {
-                command = 'setPosition';
-                parameter = `0,${adjustedMode},${adjustedTargetPosition}`;
-                commandType = 'command';
+                bodyChange = JSON.stringify({
+                    command: 'setPosition',
+                    parameter: `0,${adjustedMode},${adjustedTargetPosition}`,
+                    commandType: 'command',
+                });
             }
-            const bodyChange = JSON.stringify({
-                command: command,
-                parameter: parameter,
-                commandType: commandType,
-            });
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+            await this.debugLog(`SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
-                    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `request to SwitchBot API, body: ${JSON.stringify(JSON.parse(bodyChange))} sent successfully`);
+                await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                    await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    this.statusCode(statusCode);
-                    this.statusCode(deviceStatus.statusCode);
+                    await this.statusCode(statusCode);
+                    await this.statusCode(deviceStatus.statusCode);
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIpushChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed openAPIpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No OpenAPI Changes, CurrentPosition & TargetPosition Are the Same.`
-                + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}, TargetPosition  ${this.WindowCovering.TargetPosition}`);
+            await this.debugLog(`No changes (openAPIpushChanges), CurrentPosition: ${this.WindowCovering.CurrentPosition},`
+                + ` TargetPosition: ${this.WindowCovering.TargetPosition}`);
         }
     }
     /**
      * Handle requests to set the value of the "Target Position" characteristic
      */
     async TargetPositionSet(value) {
-        if (this.WindowCovering.TargetPosition === this.accessory.context.TargetPosition) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set TargetPosition: ${value}`);
+        if (this.WindowCovering.TargetPosition !== this.accessory.context.TargetPosition) {
+            await this.infoLog(`Set TargetPosition: ${value}`);
         }
         else {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set TargetPosition: ${value}`);
+            await this.debugLog(`No Changes, TargetPosition: ${value}`);
         }
         // Set HoldPosition to false when TargetPosition is changed
         this.WindowCovering.HoldPosition = false;
@@ -643,20 +554,17 @@ export class Curtain extends deviceBase {
         if (this.WindowCovering.TargetPosition > this.WindowCovering.CurrentPosition) {
             this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.INCREASING;
             this.setNewTarget = true;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.WindowCovering.TargetPosition},`
-                + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+            await this.debugLog(`value: ${this.WindowCovering.TargetPosition}, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
         }
         else if (this.WindowCovering.TargetPosition < this.WindowCovering.CurrentPosition) {
             this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.DECREASING;
             this.setNewTarget = true;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.WindowCovering.TargetPosition},`
-                + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+            await this.debugLog(`value: ${this.WindowCovering.TargetPosition}, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
         }
         else {
             this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.STOPPED;
             this.setNewTarget = false;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.WindowCovering.TargetPosition},`
-                + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+            await this.debugLog(`value: ${this.WindowCovering.TargetPosition}, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
         }
         this.WindowCovering.Service.setCharacteristic(this.hap.Characteristic.PositionState, this.WindowCovering.PositionState);
         this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
@@ -665,10 +573,10 @@ export class Curtain extends deviceBase {
          * The minimum time depends on the network control latency.
          */
         clearTimeout(this.setNewTargetTimer);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateRate: ${this.deviceUpdateRate}`);
+        await this.debugLog(`deviceUpdateRate: ${this.deviceUpdateRate}`);
         if (this.setNewTarget) {
-            this.setNewTargetTimer = setTimeout(() => {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} setNewTarget ${this.setNewTarget} timeout`);
+            this.setNewTargetTimer = setTimeout(async () => {
+                await this.debugLog(`setNewTarget ${this.setNewTarget} timeout`);
                 this.setNewTarget = false;
             }, this.deviceUpdateRate * 1000);
         }
@@ -678,7 +586,7 @@ export class Curtain extends deviceBase {
      * Handle requests to set the value of the "Target Position" characteristic
      */
     async HoldPositionSet(value) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} HoldPosition: ${value}`);
+        this.debugLog(`HoldPosition: ${value}`);
         this.WindowCovering.HoldPosition = value;
         this.doCurtainUpdate.next();
     }
@@ -706,17 +614,14 @@ export class Curtain extends deviceBase {
     }
     async BLEPushConnection() {
         if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+            await this.warnLog('Using OpenAPI Connection to Push Changes');
             await this.openAPIpushChanges();
         }
     }
     async BLERefreshConnection(switchbot) {
-        if (switchbot !== undefined) {
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot:`
-                + ` ${JSON.stringify(switchbot)}`);
-        }
+        await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${JSON.stringify(switchbot)}`);
         if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
+            await this.warnLog('Using OpenAPI Connection to Refresh Status');
             await this.openAPIRefreshStatus();
         }
     }
@@ -753,6 +658,40 @@ export class Curtain extends deviceBase {
         }
         return { setPositionMode, Mode };
     }
+    async getCurrentPostion() {
+        await this.setMinMax();
+        await this.debugLog(`CurrentPosition ${this.WindowCovering.CurrentPosition}`);
+        if (this.setNewTarget) {
+            this.infoLog('Checking Status ...');
+            await this.setMinMax();
+            if (this.WindowCovering.TargetPosition > this.WindowCovering.CurrentPosition) {
+                await this.debugLog(`Closing, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+                this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.INCREASING;
+                this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
+                await this.debugLog(`Increasing, PositionState: ${this.WindowCovering.PositionState}`);
+            }
+            else if (this.WindowCovering.TargetPosition < this.WindowCovering.CurrentPosition) {
+                await this.debugLog(`Opening, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+                this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.DECREASING;
+                this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
+                await this.debugLog(`Decreasing, PositionState: ${this.WindowCovering.PositionState}`);
+            }
+            else {
+                await this.debugLog(`Standby, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+                this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.STOPPED;
+                this.WindowCovering.Service.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.WindowCovering.PositionState);
+                await this.debugLog(`Stopped, PositionState: ${this.WindowCovering.PositionState}`);
+            }
+        }
+        else {
+            await this.debugLog(`Standby, CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
+            this.WindowCovering.TargetPosition = this.WindowCovering.CurrentPosition;
+            this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.STOPPED;
+            await this.debugLog(`Stopped, PositionState: ${this.WindowCovering.PositionState}`);
+        }
+        await this.debugLog(`CurrentPosition: ${this.WindowCovering.CurrentPosition}, TargetPosition: ${this.WindowCovering.TargetPosition},`
+            + ` PositionState: ${this.WindowCovering.PositionState},`);
+    }
     async setMinMax() {
         if (this.device.curtain?.set_min) {
             if (Number(this.WindowCovering.CurrentPosition) <= this.device.curtain?.set_min) {
@@ -784,7 +723,7 @@ export class Curtain extends deviceBase {
         this.Battery.Service.updateCharacteristic(this.hap.Characteristic.BatteryLevel, e);
         this.Battery.Service.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, e);
         this.Battery.Service.updateCharacteristic(this.hap.Characteristic.ChargingState, e);
-        if (!this.device.curtain?.hide_lightsensor) {
+        if (!this.device.curtain?.hide_lightsensor && this.LightSensor?.Service) {
             this.LightSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, e);
             this.LightSensor.Service.updateCharacteristic(this.hap.Characteristic.StatusActive, e);
         }