@switchbot/homebridge-switchbot 3.5.1-beta.1 → 3.5.1-beta.11

package/dist/platform.js

@@ -32,13 +32,13 @@ import { AirConditioner } from './irdevice/airconditioner.js';
 import { Buffer } from 'buffer';
 import { request } from 'undici';
 import asyncmqtt from 'async-mqtt';
-import { sleep } from './utils.js';
 import { createServer } from 'http';
 import { queueScheduler } from 'rxjs';
 import fakegato from 'fakegato-history';
 import crypto, { randomUUID } from 'crypto';
 import { readFileSync, writeFileSync } from 'fs';
 import { EveHomeKitTypes } from 'homebridge-lib/EveHomeKitTypes';
+import { isBlindTiltDevice, isCurtainDevice, sleep } from './utils.js';
 import { PLATFORM_NAME, PLUGIN_NAME, Devices, setupWebhook, updateWebhook, deleteWebhook, queryWebhook } from './settings.js';
 /**
  * HomebridgePlatform
@@ -117,7 +117,7 @@ export class SwitchBotPlatform {
             }
             catch (e) {
                 this.errorLog(`Failed to Discover, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
-                this.debugErrorLog(`Failed to Discover, Error: ${e}`);
+                await this.debugErrorLog(`Failed to Discover, Error: ${e}`);
             }
         });
         this.setupMqtt();
@@ -128,29 +128,29 @@ export class SwitchBotPlatform {
             try {
                 const { connectAsync } = asyncmqtt;
                 this.mqttClient = await connectAsync(this.config.options?.mqttURL, this.config.options.mqttOptions || {});
-                this.debugLog('MQTT connection has been established successfully.');
-                this.mqttClient.on('error', (e) => {
-                    this.errorLog(`Failed to publish MQTT messages. ${e}`);
+                await this.debugLog('MQTT connection has been established successfully.');
+                this.mqttClient.on('error', async (e) => {
+                    await this.errorLog(`Failed to publish MQTT messages. ${e}`);
                 });
                 if (!this.config.options?.webhookURL) {
                     // receive webhook events via MQTT
-                    this.infoLog(`Webhook is configured to be received through ${this.config.options.mqttURL}/homebridge-switchbot/webhook.`);
+                    await this.infoLog(`Webhook is configured to be received through ${this.config.options.mqttURL}/homebridge-switchbot/webhook.`);
                     this.mqttClient.subscribe('homebridge-switchbot/webhook/+');
                     this.mqttClient.on('message', async (topic, message) => {
                         try {
-                            this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
+                            await await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
                             const context = JSON.parse(message.toString());
-                            await this.webhookEventHandler[context.deviceMac]?.(context);
+                            this.webhookEventHandler[context.deviceMac]?.(context);
                         }
                         catch (e) {
-                            this.errorLog(`Failed to handle webhook event. Error:${e}`);
+                            await this.errorLog(`Failed to handle webhook event. Error:${e}`);
                         }
                     });
                 }
             }
             catch (e) {
                 this.mqttClient = null;
-                this.errorLog(`Failed to establish MQTT connection. ${e}`);
+                await this.errorLog(`Failed to establish MQTT connection. ${e}`);
             }
         }
     }
@@ -168,7 +168,7 @@ export class SwitchBotPlatform {
                             request.on('data', async (data) => {
                                 try {
                                     const body = JSON.parse(data);
-                                    this.debugLog(`Received Webhook: ${JSON.stringify(body)}`);
+                                    await this.debugLog(`Received Webhook: ${JSON.stringify(body)}`);
                                     if (this.config.options?.mqttURL) {
                                         const mac = body.context.deviceMac
                                             ?.toLowerCase()
@@ -177,7 +177,7 @@ export class SwitchBotPlatform {
                                         const options = this.config.options?.mqttPubOptions || {};
                                         this.mqttClient?.publish(`homebridge-switchbot/webhook/${mac}`, `${JSON.stringify(body.context)}`, options);
                                     }
-                                    await this.webhookEventHandler[body.context.deviceMac]?.(body.context);
+                                    this.webhookEventHandler[body.context.deviceMac]?.(body.context);
                                 }
                                 catch (e) {
                                     this.errorLog(`Failed to handle webhook event. Error:${e}`);
@@ -211,9 +211,9 @@ export class SwitchBotPlatform {
                     }),
                 });
                 const response = await body.json();
-                this.debugLog(`setupWebhook: url:${url}`);
-                this.debugLog(`setupWebhook: body:${JSON.stringify(response)}`);
-                this.debugLog(`setupWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`setupWebhook: url:${url}`);
+                await this.debugLog(`setupWebhook: body:${JSON.stringify(response)}`);
+                await this.debugLog(`setupWebhook: statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
                     this.errorLog(`Failed to configure webhook. Existing webhook well be overridden. HTTP:${statusCode} API:${response?.statusCode} `
                         + `message:${response?.message}`);
@@ -233,9 +233,9 @@ export class SwitchBotPlatform {
                     }),
                 });
                 const response = await body.json();
-                this.debugLog(`updateWebhook: url:${url}`);
-                this.debugLog(`updateWebhook: body:${JSON.stringify(response)}`);
-                this.debugLog(`updateWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`updateWebhook: url:${url}`);
+                await this.debugLog(`updateWebhook: body:${JSON.stringify(response)}`);
+                await this.debugLog(`updateWebhook: statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
                     this.errorLog(`Failed to update webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                 }
@@ -252,8 +252,8 @@ export class SwitchBotPlatform {
                     }),
                 });
                 const response = await body.json();
-                this.debugLog(`queryWebhook: body:${JSON.stringify(response)}`);
-                this.debugLog(`queryWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`queryWebhook: body:${JSON.stringify(response)}`);
+                await this.debugLog(`queryWebhook: statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
                     this.errorLog(`Failed to query webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                 }
@@ -275,9 +275,7 @@ export class SwitchBotPlatform {
                         }),
                     });
                     const response = await body.json();
-                    this.debugLog(`deleteWebhook: url:${url}`);
-                    this.debugLog(`deleteWebhook: body:${JSON.stringify(response)}`);
-                    this.debugLog(`deleteWebhook: statusCode:${statusCode}`);
+                    await this.debugLog(`deleteWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`);
                     if (statusCode !== 200 || response?.statusCode !== 100) {
                         this.errorLog(`Failed to delete webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                     }
@@ -295,8 +293,8 @@ export class SwitchBotPlatform {
      * This function is invoked when homebridge restores cached accessories from disk at startup.
      * It should be used to setup event handlers for characteristics and update respective values.
      */
-    configureAccessory(accessory) {
-        this.debugLog(`Loading accessory from cache: ${accessory.displayName}`);
+    async configureAccessory(accessory) {
+        await this.debugLog(`Loading accessory from cache: ${accessory.displayName}`);
         // add the restored accessory to the accessories cache so we can track if it has already been registered
         this.accessories.push(accessory);
     }
@@ -318,7 +316,7 @@ export class SwitchBotPlatform {
             platformConfig['pushRate'] = this.config.options.pushRate;
         }
         if (Object.entries(platformConfig).length !== 0) {
-            this.debugWarnLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
+            await this.debugWarnLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
         }
         if (this.config.options) {
             // Device Config
@@ -433,7 +431,7 @@ export class SwitchBotPlatform {
             if (pluginConfig.credentials.token) {
                 pluginConfig.credentials.openToken = undefined;
             }
-            this.debugWarnLog(`token: ${pluginConfig.credentials.token}`);
+            await this.debugWarnLog(`token: ${pluginConfig.credentials.token}`);
             // save the config, ensuring we maintain pretty json
             writeFileSync(this.api.user.configPath(), JSON.stringify(currentConfig, null, 4));
             this.verifyConfig();
@@ -473,29 +471,29 @@ export class SwitchBotPlatform {
             let retryCount = 0;
             const maxRetries = this.maxRetries; // Maximum number of retries
             const delayBetweenRetries = this.delayBetweenRetries; // Delay between retries in milliseconds
-            this.debugWarnLog(`Retry Count: ${retryCount}`);
-            this.debugWarnLog(`Max Retries: ${maxRetries}`);
-            this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
+            await this.debugWarnLog(`Retry Count: ${retryCount}`);
+            await this.debugWarnLog(`Max Retries: ${maxRetries}`);
+            await this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
             while (retryCount < maxRetries) {
                 try {
                     const { body, statusCode } = await request(Devices, {
                         headers: this.generateHeaders(),
                     });
-                    this.debugWarnLog(`statusCode: ${statusCode}`);
+                    await this.debugWarnLog(`statusCode: ${statusCode}`);
                     const devicesAPI = await body.json();
-                    this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
-                    this.debugWarnLog(`devicesAPI Body: ${JSON.stringify(devicesAPI.body)}`);
-                    this.debugWarnLog(`devicesAPI StatusCode: ${devicesAPI.statusCode}`);
+                    await this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
+                    await this.debugWarnLog(`devicesAPI Body: ${JSON.stringify(devicesAPI.body)}`);
+                    await this.debugWarnLog(`devicesAPI StatusCode: ${devicesAPI.statusCode}`);
                     if ((statusCode === 200 || statusCode === 100) && (devicesAPI.statusCode === 200 || devicesAPI.statusCode === 100)) {
-                        this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
+                        await this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
                         // SwitchBot Devices
                         const deviceLists = devicesAPI.body.deviceList;
-                        this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
-                        this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
+                        await this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
+                        await this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
                         if (!this.config.options?.devices) {
-                            this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+                            await this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
                             if (deviceLists.length === 0) {
-                                this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
+                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
                             }
                             else {
                                 const devices = deviceLists.map((v) => v);
@@ -510,9 +508,9 @@ export class SwitchBotPlatform {
                             }
                         }
                         else if (this.config.credentials?.token && this.config.options.devices) {
-                            this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+                            await this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
                             if (deviceLists.length === 0) {
-                                this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
+                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
                             }
                             else {
                                 const deviceConfigs = this.config.options?.devices;
@@ -521,7 +519,7 @@ export class SwitchBotPlatform {
                                     ...itm,
                                 }));
                                 const devices = mergeBydeviceId(deviceLists, deviceConfigs);
-                                this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+                                await this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
                                 for (const device of devices) {
                                     if (!device.deviceType) {
                                         device.deviceType = device.configDeviceType;
@@ -543,12 +541,12 @@ export class SwitchBotPlatform {
                             this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
                         }
                         else {
-                            this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+                            await this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
                         }
                         // IR Devices
                         const irDeviceLists = devicesAPI.body.infraredRemoteList;
                         if (!this.config.options?.irdevices) {
-                            this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                            await this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
                             const devices = irDeviceLists.map((v) => v);
                             for (const device of devices) {
                                 if (device.remoteType) {
@@ -557,14 +555,14 @@ export class SwitchBotPlatform {
                             }
                         }
                         else {
-                            this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                            await this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
                             const irDeviceConfig = this.config.options?.irdevices;
                             const mergeIRBydeviceId = (a1, a2) => a1.map((itm) => ({
                                 ...a2.find((item) => item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item),
                                 ...itm,
                             }));
                             const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
-                            this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
+                            await this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
                             for (const device of devices) {
                                 this.createIRDevice(device);
                             }
@@ -573,7 +571,7 @@ export class SwitchBotPlatform {
                             this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
                         }
                         else {
-                            this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+                            await this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
                         }
                         break;
                     }
@@ -590,12 +588,12 @@ export class SwitchBotPlatform {
                 catch (e) {
                     retryCount++;
                     this.debugErrorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
-                    this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
+                    await this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
                 }
             }
         }
         else if (!this.config.credentials?.token && this.config.options?.devices) {
-            this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+            await this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
             const deviceConfigs = this.config.options?.devices;
             const devices = deviceConfigs.map((v) => v);
             for (const device of devices) {
@@ -610,73 +608,73 @@ export class SwitchBotPlatform {
             this.errorLog('Neither SwitchBot Token or Device Config are not set.');
         }
     }
-    createDevice(device) {
+    async createDevice(device) {
         switch (device.deviceType) {
             case 'Humidifier':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createHumidifier(device);
                 break;
             case 'Hub Mini':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 break;
             case 'Hub Plus':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 break;
             case 'Hub 2':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createHub2(device);
                 break;
             case 'Bot':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createBot(device);
                 break;
             case 'Meter':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMeter(device);
                 break;
             case 'MeterPlus':
             case 'Meter Plus (JP)':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMeterPlus(device);
                 break;
             case 'WoIOSensor':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createIOSensor(device);
                 break;
             case 'Water Detector':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createWaterDetector(device);
                 break;
             case 'Motion Sensor':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMotion(device);
                 break;
             case 'Contact Sensor':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createContact(device);
                 break;
             case 'Curtain':
             case 'Curtain3':
-                this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
                 this.createCurtain(device);
                 break;
             case 'Blind Tilt':
-                this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
                 this.createBlindTilt(device);
                 break;
             case 'Plug':
             case 'Plug Mini (US)':
             case 'Plug Mini (JP)':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createPlug(device);
                 break;
             case 'Smart Lock':
             case 'Smart Lock Pro':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createLock(device);
                 break;
             case 'Color Bulb':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createColorBulb(device);
                 break;
             case 'K10+':
@@ -685,32 +683,32 @@ export class SwitchBotPlatform {
             case 'Robot Vacuum Cleaner S1':
             case 'Robot Vacuum Cleaner S1 Plus':
             case 'Robot Vacuum Cleaner S10':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createRobotVacuumCleaner(device);
                 break;
             case 'Ceiling Light':
             case 'Ceiling Light Pro':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createCeilingLight(device);
                 break;
             case 'Strip Light':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createStripLight(device);
                 break;
             case 'Battery Circulator Fan':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createFan(device);
                 break;
             case 'Remote':
             case 'Indoor Cam':
             case 'remote with screen+':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}, is currently not supported, device: ${JSON.stringify(device)}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}, is currently not supported, device: ${JSON.stringify(device)}`);
                 break;
             default:
                 this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`, +`Submit Feature Requests Here: https://tinyurl.com/SwitchBotFeatureRequest, device: ${JSON.stringify(device)}`);
         }
     }
-    createIRDevice(device) {
+    async createIRDevice(device) {
         if (device.connectionType === undefined) {
             device.connectionType = 'OpenAPI';
         }
@@ -727,7 +725,7 @@ export class SwitchBotPlatform {
             case 'DIY DVD':
             case 'Speaker':
             case 'DIY Speaker':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 if (device.external === undefined) {
                     device.external = true;
                     this.createTV(device);
@@ -738,45 +736,45 @@ export class SwitchBotPlatform {
                 break;
             case 'Fan':
             case 'DIY Fan':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createIRFan(device);
                 break;
             case 'Air Conditioner':
             case 'DIY Air Conditioner':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createAirConditioner(device);
                 break;
             case 'Light':
             case 'DIY Light':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createLight(device);
                 break;
             case 'Air Purifier':
             case 'DIY Air Purifier':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createAirPurifier(device);
                 break;
             case 'Water Heater':
             case 'DIY Water Heater':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createWaterHeater(device);
                 break;
             case 'Vacuum Cleaner':
             case 'DIY Vacuum Cleaner':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createVacuumCleaner(device);
                 break;
             case 'Camera':
             case 'DIY Camera':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createCamera(device);
                 break;
             case 'Others':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createOthers(device);
                 break;
             default:
-                this.debugLog(`Unsupported Device: ${JSON.stringify(device)}`);
+                await this.debugLog(`Unsupported Device: ${JSON.stringify(device)}`);
                 this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.remoteType}, is currently not supported.`);
                 this.warnLog('Submit Feature Requests Here: ' + 'https://tinyurl.com/SwitchBotFeatureRequest');
         }
@@ -803,7 +801,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Humidifier(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -829,13 +827,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Humidifier(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createBot(device) {
@@ -860,7 +858,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Bot(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -887,13 +885,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Bot(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createMeter(device) {
@@ -918,7 +916,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Meter(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -944,13 +942,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Meter(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createMeterPlus(device) {
@@ -976,7 +974,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new MeterPlus(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1002,13 +1000,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new MeterPlus(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createHub2(device) {
@@ -1034,7 +1032,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Hub(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1060,13 +1058,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Hub(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createIOSensor(device) {
@@ -1091,7 +1089,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new IOSensor(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1117,13 +1115,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new IOSensor(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createWaterDetector(device) {
@@ -1148,7 +1146,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new WaterDetector(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1174,13 +1172,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new WaterDetector(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createMotion(device) {
@@ -1205,7 +1203,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Motion(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1231,13 +1229,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Motion(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createContact(device) {
@@ -1262,7 +1260,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Contact(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1288,13 +1286,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Contact(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createBlindTilt(device) {
@@ -1319,7 +1317,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new BlindTilt(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1330,16 +1328,18 @@ export class SwitchBotPlatform {
             if (!device.external) {
                 this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             }
-            if (device.group && !device.curtain?.disable_group) {
-                this.debugLog('Your Curtains are grouped, ' +
-                    `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
-            }
-            else {
-                if (device.master) {
-                    this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+            if (isBlindTiltDevice(device)) {
+                if (device.group && !device.curtain?.disable_group) {
+                    this.debugLog('Your Curtains are grouped, ' +
+                        `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
                 else {
-                    this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    if (device.master) {
+                        this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    }
+                    else {
+                        this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    }
                 }
             }
             // create a new accessory
@@ -1357,13 +1357,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new BlindTilt(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createCurtain(device) {
@@ -1388,7 +1388,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Curtain(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1399,16 +1399,18 @@ export class SwitchBotPlatform {
             if (!device.external) {
                 this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
             }
-            if (device.group && !device.curtain?.disable_group) {
-                this.debugLog('Your Curtains are grouped, ' +
-                    `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
-            }
-            else {
-                if (device.master) {
-                    this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+            if (isCurtainDevice(device)) {
+                if (device.group && !device.curtain?.disable_group) {
+                    this.debugLog('Your Curtains are grouped, ' +
+                        `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
                 }
                 else {
-                    this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    if (device.master) {
+                        this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    }
+                    else {
+                        this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                    }
                 }
             }
             // create a new accessory
@@ -1426,13 +1428,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Curtain(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createPlug(device) {
@@ -1457,7 +1459,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Plug(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1483,13 +1485,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Plug(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createLock(device) {
@@ -1514,7 +1516,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Lock(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1540,13 +1542,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Lock(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createColorBulb(device) {
@@ -1571,7 +1573,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new ColorBulb(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1597,13 +1599,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new ColorBulb(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createCeilingLight(device) {
@@ -1628,7 +1630,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new CeilingLight(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1654,13 +1656,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new CeilingLight(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createStripLight(device) {
@@ -1685,7 +1687,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new StripLight(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1711,13 +1713,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new StripLight(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createFan(device) {
@@ -1742,7 +1744,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Fan(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1768,13 +1770,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Fan(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createRobotVacuumCleaner(device) {
@@ -1799,7 +1801,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new RobotVacuumCleaner(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1825,13 +1827,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new RobotVacuumCleaner(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createTV(device) {
@@ -1844,9 +1846,6 @@ export class SwitchBotPlatform {
             existingAccessory.context.model = device.remoteType;
             existingAccessory.context.deviceID = device.deviceId;
             existingAccessory.displayName = device.configDeviceName || device.deviceName;
-            if (device.version && !device.firmware) {
-                existingAccessory.context.version = device.version;
-            }
             existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
             this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
             existingAccessory.context.connectionType = device.connectionType;
@@ -1854,7 +1853,7 @@ export class SwitchBotPlatform {
             // create the accessory handler for the restored accessory
             // this is imported from `platformAccessory.ts`
             new TV(this, existingAccessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // the accessory does not yet exist, so we need to create it
@@ -1876,12 +1875,12 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new TV(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createIRFan(device) {
@@ -1906,7 +1905,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new IRFan(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1932,13 +1931,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new IRFan(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createLight(device) {
@@ -1963,7 +1962,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Light(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1989,13 +1988,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Light(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createAirConditioner(device) {
@@ -2020,7 +2019,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new AirConditioner(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2046,13 +2045,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new AirConditioner(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createAirPurifier(device) {
@@ -2077,7 +2076,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new AirPurifier(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2103,13 +2102,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new AirPurifier(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createWaterHeater(device) {
@@ -2134,7 +2133,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new WaterHeater(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2160,13 +2159,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new WaterHeater(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createVacuumCleaner(device) {
@@ -2191,7 +2190,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new VacuumCleaner(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2217,13 +2216,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new VacuumCleaner(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createCamera(device) {
@@ -2248,7 +2247,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Camera(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2274,13 +2273,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Camera(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createOthers(device) {
@@ -2305,7 +2304,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Others(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2331,61 +2330,78 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Others(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async registerCurtains(device) {
-        switch (device.deviceType) {
-            case 'Curtain':
-            case 'Curtain3':
-                this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds}, master: `
-                    + `${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group}, connectionType: ${device.connectionType}`);
-                break;
-            default:
-                this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, blindTiltDevicesIds: ${device.blindTiltDevicesIds}, master:`
-                    + ` ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group}, connectionType: ${device.connectionType}`);
+        /*function isCurtainDevice(device: device & devicesConfig): device is (curtain | curtain3) & devicesConfig {
+          return device.deviceType === 'Curtain' || device.deviceType === 'Curtain3';
+        }
+    
+        function isBlindTiltDevice(device: device & devicesConfig): device is blindTilt & devicesConfig {
+          return device.deviceType === 'Blind Tilt';
+        }*/
+        let registerWindowCovering;
+        if (isCurtainDevice(device)) {
+            await this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds},`
+                + ` master: ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group},`
+                + ` connectionType: ${device.connectionType}`);
+            registerWindowCovering = await this.registerWindowCovering(device);
+        }
+        else if (isBlindTiltDevice(device)) {
+            await this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, blindTiltDevicesIds: ${device.blindTiltDevicesIds},`
+                + ` master: ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group},`
+                + ` connectionType: ${device.connectionType}`);
+            registerWindowCovering = await this.registerWindowCovering(device);
+        }
+        else {
+            registerWindowCovering = false;
         }
+        return registerWindowCovering;
+    }
+    async registerWindowCovering(device) {
+        await this.debugLog(`master: ${device.master}`);
         let registerCurtain;
         if (device.master && device.group) {
             // OpenAPI: Master Curtains/Blind Tilt in Group
             registerCurtain = true;
-            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, device.group: ${device.group}`
-                + ` connectionType; ${device.connectionType}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master},`
+                + ` device.group: ${device.group} connectionType; ${device.connectionType}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else if (!device.master && device.curtain?.disable_group) {
             //!device.group && device.connectionType === 'BLE'
             // OpenAPI: Non-Master Curtains/Blind Tilts that has Disable Grouping Checked
             registerCurtain = true;
-            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: `
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: `
                 + `${device.curtain?.disable_group}, connectionType; ${device.connectionType}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else if (device.master && !device.group) {
             // OpenAPI: Master Curtains/Blind Tilts not in Group
             registerCurtain = true;
-            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, device.group: ${device.group}`
-                + ` connectionType; ${device.connectionType}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master},`
+                + ` device.group: ${device.group} connectionType; ${device.connectionType}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else if (device.connectionType === 'BLE') {
             // BLE: Curtains/Blind Tilt
             registerCurtain = true;
-            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] connectionType: ${device.connectionType}, `
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] connectionType: ${device.connectionType}, `
                 + ` group: ${device.group}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else {
             registerCurtain = false;
-            this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.curtain?.disable_group},`
+            await this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.curtain?.disable_group},`
                 + ` device.master: ${device.master}, device.group: ${device.group}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}, device.connectionType: ${device.connectionType}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}, device.connectionType: ${device.connectionType}`);
         }
         return registerCurtain;
     }
@@ -2408,17 +2424,17 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
             if (registerDevice === true) {
-                this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
             }
             else {
-                this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
             }
         }
         else if (!device.hide_device && device.deviceId && device.configDeviceType && device.configDeviceName && device.connectionType === 'BLE') {
@@ -2427,17 +2443,17 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
             if (registerDevice === true) {
-                this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
             }
             else {
-                this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
             }
         }
         else if (!device.hide_device && device.connectionType === 'OpenAPI') {
@@ -2446,17 +2462,17 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
             if (registerDevice === true) {
-                this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
             }
             else {
-                this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
             }
         }
         else if (!device.hide_device && device.connectionType === 'Disabled') {
@@ -2465,25 +2481,25 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
-            this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will continue to display in HomeKit`);
+            await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will continue to display in HomeKit`);
         }
         else if (!device.connectionType && !device.hide_device) {
             registerDevice = false;
-            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
         }
         else if (device.hide_device) {
             registerDevice = false;
-            this.debugErrorLog(`Device: ${device.deviceName} hide_device: ${device.hide_device}, will not display in HomeKit`);
+            await this.debugErrorLog(`Device: ${device.deviceName} hide_device: ${device.hide_device}, will not display in HomeKit`);
         }
         else {
             registerDevice = false;
-            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: `
+            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: `
                 + `${device.hide_device},  will not display in HomeKit`);
         }
         return registerDevice;
@@ -2495,21 +2511,21 @@ export class SwitchBotPlatform {
          * publish your TV as an external accessory.
          */
         if (device.external) {
-            this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
+            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
             this.externalAccessory(accessory);
         }
         else {
-            this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
     }
     async externalOrPlatform(device, accessory) {
         if (device.external) {
-            this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
-            this.externalAccessory(accessory);
+            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
+            await this.externalAccessory(accessory);
         }
         else {
-            this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
     }
@@ -2524,67 +2540,67 @@ export class SwitchBotPlatform {
     async statusCode(statusCode) {
         switch (statusCode) {
             case 151:
-                this.errorLog(`Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: ` +
+                await this.errorLog(`Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: ` +
                     'https://tinyurl.com/SwitchBotFeatureRequest');
                 break;
             case 152:
-                this.errorLog(`Device not found, statusCode: ${statusCode}`);
+                await this.errorLog(`Device not found, statusCode: ${statusCode}`);
                 break;
             case 160:
-                this.errorLog(`Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
+                await this.errorLog(`Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
                 break;
             case 161:
-                this.errorLog(`Device is offline, statusCode: ${statusCode}`);
+                await this.errorLog(`Device is offline, statusCode: ${statusCode}`);
                 break;
             case 171:
-                this.errorLog(`is offline, statusCode: ${statusCode}`);
+                await this.errorLog(`is offline, statusCode: ${statusCode}`);
                 break;
             case 190:
-                this.errorLog(`Requests reached the daily limit, statusCode: ${statusCode}`);
+                await this.errorLog(`Requests reached the daily limit, statusCode: ${statusCode}`);
                 break;
             case 100:
-                this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
+                await await this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
                 break;
             case 200:
-                this.debugLog(`Request successful, statusCode: ${statusCode}`);
+                await await this.debugLog(`Request successful, statusCode: ${statusCode}`);
                 break;
             case 400:
-                this.errorLog('Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request '
+                await this.errorLog('Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request '
                     + `payload, statusCode: ${statusCode}`);
                 break;
             case 401:
-                this.errorLog('Unauthorized,	Authorization for the API is required, but the request has not been authenticated, '
+                await this.errorLog('Unauthorized,	Authorization for the API is required, but the request has not been authenticated, '
                     + `statusCode: ${statusCode}`);
                 break;
             case 403:
-                this.errorLog('Forbidden,	The request has been authenticated but does not have appropriate permissions, or a requested resource is not '
+                await this.errorLog('Forbidden,	The request has been authenticated but does not have appropriate permissions, or a requested resource is not '
                     + `found, statusCode: ${statusCode}`);
                 break;
             case 404:
-                this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
+                await this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
                 break;
             case 406:
-                this.errorLog('Not Acceptable,	The client has requested a MIME type via the Accept header for a value not supported by the server, '
+                await this.errorLog('Not Acceptable,	The client has requested a MIME type via the Accept header for a value not supported by the server, '
                     + `statusCode: ${statusCode}`);
                 break;
             case 415:
-                this.errorLog('Unsupported Media Type,	The client has defined a contentType header that is not supported by the server, '
+                await this.errorLog('Unsupported Media Type,	The client has defined a contentType header that is not supported by the server, '
                     + `statusCode: ${statusCode}`);
                 break;
             case 422:
-                this.errorLog('Unprocessable Entity,	The client has made a valid request, but the server cannot process it. This is often used for '
+                await this.errorLog('Unprocessable Entity,	The client has made a valid request, but the server cannot process it. This is often used for '
                     + `APIs for which certain limits have been exceeded, statusCode: ${statusCode}`);
                 break;
             case 429:
-                this.errorLog('Too Many Requests,	The client has exceeded the number of requests allowed for a given time window, '
+                await this.errorLog('Too Many Requests,	The client has exceeded the number of requests allowed for a given time window, '
                     + `statusCode: ${statusCode}`);
                 break;
             case 500:
-                this.errorLog('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare, '
+                await this.errorLog('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare, '
                     + `statusCode: ${statusCode}`);
                 break;
             default:
-                this.errorLog(`Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
+                await this.errorLog(`Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
         }
     }
     async retryRequest(deviceMaxRetries, deviceDelayBetweenRetries, url, options) {
@@ -2598,34 +2614,35 @@ export class SwitchBotPlatform {
                     return { body, statusCode };
                 }
                 else {
-                    this.debugLog(`Received status code: ${statusCode}`);
+                    await await this.debugLog(`Received status code: ${statusCode}`);
                 }
             }
             catch (error) {
-                this.errorLog(`Error making request: ${error.message}`);
+                await this.errorLog(`Error making request: ${error.message}`);
             }
             retryCount++;
-            this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`);
+            await await this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`);
             await sleep(delayBetweenRetries);
         }
         return { body: null, statusCode: -1 };
     }
     // BLE Connection
-    async connectBLE() {
+    async connectBLE(accessory, device) {
         let switchbot;
         try {
             const SwitchBot = (await import('node-switchbot')).SwitchBot;
             queueScheduler.schedule(() => (switchbot = new SwitchBot()));
+            await await this.debugLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}`);
         }
         catch (e) {
             switchbot = false;
-            this.errorLog(`Was 'node-switchbot' found: ${switchbot}, Error: ${e}`);
+            await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}, Error: ${e}`);
         }
         return switchbot;
     }
     async getVersion() {
         const json = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
-        this.debugLog(`Plugin Version: ${json.version}`);
+        await await this.debugLog(`Plugin Version: ${json.version}`);
         this.version = json.version;
     }
     async getPlatformConfigSettings() {
@@ -2662,7 +2679,7 @@ export class SwitchBotPlatform {
                 platformConfig.delayBetweenRetries = this.delayBetweenRetries / 1000;
             }
             if (Object.entries(platformConfig).length !== 0) {
-                this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
+                await await this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
             }
             this.platformConfig = platformConfig;
         }
@@ -2671,64 +2688,64 @@ export class SwitchBotPlatform {
         this.debugMode = process.argv.includes('-D') || process.argv.includes('--debug');
         if (this.config.options?.logging === 'debug' || this.config.options?.logging === 'standard' || this.config.options?.logging === 'none') {
             this.platformLogging = this.config.options.logging;
-            this.debugWarnLog(`Using Config Logging: ${this.platformLogging}`);
+            await await this.debugWarnLog(`Using Config Logging: ${this.platformLogging}`);
         }
         else if (this.debugMode) {
             this.platformLogging = 'debugMode';
-            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+            await await this.debugWarnLog(`Using ${this.platformLogging} Logging`);
         }
         else {
             this.platformLogging = 'standard';
-            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+            await await this.debugWarnLog(`Using ${this.platformLogging} Logging`);
         }
     }
     /**
      * If device level logging is turned on, log to log.warn
      * Otherwise send debug logs to log.debug
      */
-    infoLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async infoLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             this.log.info(String(...log));
         }
     }
-    successLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async successLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             this.log.success(String(...log));
         }
     }
-    debugSuccessLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async debugSuccessLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             if (this.platformLogging?.includes('debug')) {
                 this.log.success('[DEBUG]', String(...log));
             }
         }
     }
-    warnLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async warnLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             this.log.warn(String(...log));
         }
     }
-    debugWarnLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async debugWarnLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             if (this.platformLogging?.includes('debug')) {
                 this.log.warn('[DEBUG]', String(...log));
             }
         }
     }
-    errorLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async errorLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             this.log.error(String(...log));
         }
     }
-    debugErrorLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async debugErrorLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             if (this.platformLogging?.includes('debug')) {
                 this.log.error('[DEBUG]', String(...log));
             }
         }
     }
-    debugLog(...log) {
-        if (this.enablingPlatformLogging()) {
+    async debugLog(...log) {
+        if (await this.enablingPlatformLogging()) {
             if (this.platformLogging === 'debugMode') {
                 this.log.debug(String(...log));
             }
@@ -2737,7 +2754,7 @@ export class SwitchBotPlatform {
             }
         }
     }
-    enablingPlatformLogging() {
+    async enablingPlatformLogging() {
         return this.platformLogging?.includes('debug') || this.platformLogging === 'standard';
     }
 }