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

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 { isBlindTiltDevice, isCurtainDevice, 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
@@ -61,7 +61,7 @@ export class SwitchBotPlatform {
     mqttClient = null;
     fakegatoAPI;
     eve;
-    webhookEventHandler = {};
+    webhookEventHandler;
     constructor(log, config, api) {
         // initialize
         this.accessories = [];
@@ -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');
-                await this.debugErrorLog(`Failed to Discover, Error: ${e}`);
+                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 || {});
-                await this.debugLog('MQTT connection has been established successfully.');
-                this.mqttClient.on('error', async (e) => {
-                    await this.errorLog(`Failed to publish MQTT messages. ${e}`);
+                this.debugLog('MQTT connection has been established successfully.');
+                this.mqttClient.on('error', (e) => {
+                    this.errorLog(`Failed to publish MQTT messages. ${e}`);
                 });
                 if (!this.config.options?.webhookURL) {
                     // receive webhook events via MQTT
-                    await this.infoLog(`Webhook is configured to be received through ${this.config.options.mqttURL}/homebridge-switchbot/webhook.`);
+                    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 {
-                            await await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
+                            this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
                             const context = JSON.parse(message.toString());
                             this.webhookEventHandler[context.deviceMac]?.(context);
                         }
                         catch (e) {
-                            await this.errorLog(`Failed to handle webhook event. Error:${e}`);
+                            this.errorLog(`Failed to handle webhook event. Error:${e}`);
                         }
                     });
                 }
             }
             catch (e) {
                 this.mqttClient = null;
-                await this.errorLog(`Failed to establish MQTT connection. ${e}`);
+                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);
-                                    await this.debugLog(`Received Webhook: ${JSON.stringify(body)}`);
+                                    this.debugLog(`Received Webhook: ${JSON.stringify(body)}`);
                                     if (this.config.options?.mqttURL) {
                                         const mac = body.context.deviceMac
                                             ?.toLowerCase()
@@ -211,9 +211,9 @@ export class SwitchBotPlatform {
                     }),
                 });
                 const response = await body.json();
-                await this.debugLog(`setupWebhook: url:${url}`);
-                await this.debugLog(`setupWebhook: body:${JSON.stringify(response)}`);
-                await this.debugLog(`setupWebhook: statusCode:${statusCode}`);
+                this.debugLog(`setupWebhook: url:${url}`);
+                this.debugLog(`setupWebhook: body:${JSON.stringify(response)}`);
+                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();
-                await this.debugLog(`updateWebhook: url:${url}`);
-                await this.debugLog(`updateWebhook: body:${JSON.stringify(response)}`);
-                await this.debugLog(`updateWebhook: statusCode:${statusCode}`);
+                this.debugLog(`updateWebhook: url:${url}`);
+                this.debugLog(`updateWebhook: body:${JSON.stringify(response)}`);
+                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();
-                await this.debugLog(`queryWebhook: body:${JSON.stringify(response)}`);
-                await this.debugLog(`queryWebhook: statusCode:${statusCode}`);
+                this.debugLog(`queryWebhook: body:${JSON.stringify(response)}`);
+                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,7 +275,9 @@ export class SwitchBotPlatform {
                         }),
                     });
                     const response = await body.json();
-                    await this.debugLog(`deleteWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`);
+                    this.debugLog(`deleteWebhook: url:${url}`);
+                    this.debugLog(`deleteWebhook: body:${JSON.stringify(response)}`);
+                    this.debugLog(`deleteWebhook: statusCode:${statusCode}`);
                     if (statusCode !== 200 || response?.statusCode !== 100) {
                         this.errorLog(`Failed to delete webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                     }
@@ -293,8 +295,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.
      */
-    async configureAccessory(accessory) {
-        await this.debugLog(`Loading accessory from cache: ${accessory.displayName}`);
+    configureAccessory(accessory) {
+        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);
     }
@@ -316,7 +318,7 @@ export class SwitchBotPlatform {
             platformConfig['pushRate'] = this.config.options.pushRate;
         }
         if (Object.entries(platformConfig).length !== 0) {
-            await this.debugWarnLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
+            this.debugWarnLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
         }
         if (this.config.options) {
             // Device Config
@@ -431,7 +433,7 @@ export class SwitchBotPlatform {
             if (pluginConfig.credentials.token) {
                 pluginConfig.credentials.openToken = undefined;
             }
-            await this.debugWarnLog(`token: ${pluginConfig.credentials.token}`);
+            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();
@@ -471,29 +473,29 @@ export class SwitchBotPlatform {
             let retryCount = 0;
             const maxRetries = this.maxRetries; // Maximum number of retries
             const delayBetweenRetries = this.delayBetweenRetries; // Delay between retries in milliseconds
-            await this.debugWarnLog(`Retry Count: ${retryCount}`);
-            await this.debugWarnLog(`Max Retries: ${maxRetries}`);
-            await this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
+            this.debugWarnLog(`Retry Count: ${retryCount}`);
+            this.debugWarnLog(`Max Retries: ${maxRetries}`);
+            this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
             while (retryCount < maxRetries) {
                 try {
                     const { body, statusCode } = await request(Devices, {
                         headers: this.generateHeaders(),
                     });
-                    await this.debugWarnLog(`statusCode: ${statusCode}`);
+                    this.debugWarnLog(`statusCode: ${statusCode}`);
                     const devicesAPI = await body.json();
-                    await this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
-                    await this.debugWarnLog(`devicesAPI Body: ${JSON.stringify(devicesAPI.body)}`);
-                    await this.debugWarnLog(`devicesAPI StatusCode: ${devicesAPI.statusCode}`);
+                    this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
+                    this.debugWarnLog(`devicesAPI Body: ${JSON.stringify(devicesAPI.body)}`);
+                    this.debugWarnLog(`devicesAPI StatusCode: ${devicesAPI.statusCode}`);
                     if ((statusCode === 200 || statusCode === 100) && (devicesAPI.statusCode === 200 || devicesAPI.statusCode === 100)) {
-                        await this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
+                        this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
                         // SwitchBot Devices
                         const deviceLists = devicesAPI.body.deviceList;
-                        await this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
-                        await this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
+                        this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
+                        this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
                         if (!this.config.options?.devices) {
-                            await this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+                            this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
                             if (deviceLists.length === 0) {
-                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
+                                this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
                             }
                             else {
                                 const devices = deviceLists.map((v) => v);
@@ -508,9 +510,9 @@ export class SwitchBotPlatform {
                             }
                         }
                         else if (this.config.credentials?.token && this.config.options.devices) {
-                            await this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+                            this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
                             if (deviceLists.length === 0) {
-                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
+                                this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
                             }
                             else {
                                 const deviceConfigs = this.config.options?.devices;
@@ -519,7 +521,7 @@ export class SwitchBotPlatform {
                                     ...itm,
                                 }));
                                 const devices = mergeBydeviceId(deviceLists, deviceConfigs);
-                                await this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+                                this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
                                 for (const device of devices) {
                                     if (!device.deviceType) {
                                         device.deviceType = device.configDeviceType;
@@ -541,12 +543,12 @@ export class SwitchBotPlatform {
                             this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
                         }
                         else {
-                            await this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+                            this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
                         }
                         // IR Devices
                         const irDeviceLists = devicesAPI.body.infraredRemoteList;
                         if (!this.config.options?.irdevices) {
-                            await this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                            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) {
@@ -555,14 +557,14 @@ export class SwitchBotPlatform {
                             }
                         }
                         else {
-                            await this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                            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);
-                            await this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
+                            this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
                             for (const device of devices) {
                                 this.createIRDevice(device);
                             }
@@ -571,7 +573,7 @@ export class SwitchBotPlatform {
                             this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
                         }
                         else {
-                            await this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+                            this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
                         }
                         break;
                     }
@@ -588,12 +590,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');
-                    await this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
+                    this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
                 }
             }
         }
         else if (!this.config.credentials?.token && this.config.options?.devices) {
-            await this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+            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) {
@@ -608,73 +610,73 @@ export class SwitchBotPlatform {
             this.errorLog('Neither SwitchBot Token or Device Config are not set.');
         }
     }
-    async createDevice(device) {
+    createDevice(device) {
         switch (device.deviceType) {
             case 'Humidifier':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createHumidifier(device);
                 break;
             case 'Hub Mini':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 break;
             case 'Hub Plus':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 break;
             case 'Hub 2':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createHub2(device);
                 break;
             case 'Bot':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createBot(device);
                 break;
             case 'Meter':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMeter(device);
                 break;
             case 'MeterPlus':
             case 'Meter Plus (JP)':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMeterPlus(device);
                 break;
             case 'WoIOSensor':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createIOSensor(device);
                 break;
             case 'Water Detector':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createWaterDetector(device);
                 break;
             case 'Motion Sensor':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMotion(device);
                 break;
             case 'Contact Sensor':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createContact(device);
                 break;
             case 'Curtain':
             case 'Curtain3':
-                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
                 this.createCurtain(device);
                 break;
             case 'Blind Tilt':
-                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
                 this.createBlindTilt(device);
                 break;
             case 'Plug':
             case 'Plug Mini (US)':
             case 'Plug Mini (JP)':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createPlug(device);
                 break;
             case 'Smart Lock':
             case 'Smart Lock Pro':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createLock(device);
                 break;
             case 'Color Bulb':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createColorBulb(device);
                 break;
             case 'K10+':
@@ -683,32 +685,32 @@ export class SwitchBotPlatform {
             case 'Robot Vacuum Cleaner S1':
             case 'Robot Vacuum Cleaner S1 Plus':
             case 'Robot Vacuum Cleaner S10':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createRobotVacuumCleaner(device);
                 break;
             case 'Ceiling Light':
             case 'Ceiling Light Pro':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createCeilingLight(device);
                 break;
             case 'Strip Light':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createStripLight(device);
                 break;
             case 'Battery Circulator Fan':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createFan(device);
                 break;
             case 'Remote':
             case 'Indoor Cam':
             case 'remote with screen+':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}, is currently not supported, device: ${JSON.stringify(device)}`);
+                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)}`);
         }
     }
-    async createIRDevice(device) {
+    createIRDevice(device) {
         if (device.connectionType === undefined) {
             device.connectionType = 'OpenAPI';
         }
@@ -725,7 +727,7 @@ export class SwitchBotPlatform {
             case 'DIY DVD':
             case 'Speaker':
             case 'DIY Speaker':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 if (device.external === undefined) {
                     device.external = true;
                     this.createTV(device);
@@ -736,45 +738,45 @@ export class SwitchBotPlatform {
                 break;
             case 'Fan':
             case 'DIY Fan':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createIRFan(device);
                 break;
             case 'Air Conditioner':
             case 'DIY Air Conditioner':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createAirConditioner(device);
                 break;
             case 'Light':
             case 'DIY Light':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createLight(device);
                 break;
             case 'Air Purifier':
             case 'DIY Air Purifier':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createAirPurifier(device);
                 break;
             case 'Water Heater':
             case 'DIY Water Heater':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createWaterHeater(device);
                 break;
             case 'Vacuum Cleaner':
             case 'DIY Vacuum Cleaner':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createVacuumCleaner(device);
                 break;
             case 'Camera':
             case 'DIY Camera':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createCamera(device);
                 break;
             case 'Others':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createOthers(device);
                 break;
             default:
-                await this.debugLog(`Unsupported Device: ${JSON.stringify(device)}`);
+                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');
         }
@@ -801,7 +803,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Humidifier(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -827,13 +829,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Humidifier(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createBot(device) {
@@ -858,7 +860,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Bot(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -885,13 +887,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Bot(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createMeter(device) {
@@ -916,7 +918,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Meter(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -942,13 +944,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Meter(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createMeterPlus(device) {
@@ -974,7 +976,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new MeterPlus(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1000,13 +1002,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new MeterPlus(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createHub2(device) {
@@ -1032,7 +1034,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Hub(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1058,13 +1060,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Hub(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createIOSensor(device) {
@@ -1089,7 +1091,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new IOSensor(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1115,13 +1117,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new IOSensor(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createWaterDetector(device) {
@@ -1146,7 +1148,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new WaterDetector(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1172,13 +1174,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new WaterDetector(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createMotion(device) {
@@ -1203,7 +1205,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Motion(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1229,13 +1231,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Motion(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createContact(device) {
@@ -1260,7 +1262,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Contact(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1286,13 +1288,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Contact(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createBlindTilt(device) {
@@ -1317,7 +1319,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new BlindTilt(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1357,13 +1359,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new BlindTilt(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createCurtain(device) {
@@ -1388,7 +1390,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Curtain(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1428,13 +1430,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Curtain(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createPlug(device) {
@@ -1459,7 +1461,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Plug(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1485,13 +1487,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Plug(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createLock(device) {
@@ -1516,7 +1518,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Lock(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1542,13 +1544,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Lock(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createColorBulb(device) {
@@ -1573,7 +1575,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new ColorBulb(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1599,13 +1601,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new ColorBulb(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createCeilingLight(device) {
@@ -1630,7 +1632,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new CeilingLight(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1656,13 +1658,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new CeilingLight(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createStripLight(device) {
@@ -1687,7 +1689,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new StripLight(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1713,13 +1715,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new StripLight(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createFan(device) {
@@ -1744,7 +1746,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Fan(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1770,13 +1772,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Fan(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createRobotVacuumCleaner(device) {
@@ -1801,7 +1803,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new RobotVacuumCleaner(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1827,13 +1829,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new RobotVacuumCleaner(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
         }
     }
     async createTV(device) {
@@ -1853,7 +1855,7 @@ export class SwitchBotPlatform {
             // create the accessory handler for the restored accessory
             // this is imported from `platformAccessory.ts`
             new TV(this, existingAccessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+            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
@@ -1875,12 +1877,12 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new TV(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createIRFan(device) {
@@ -1905,7 +1907,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new IRFan(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1931,13 +1933,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new IRFan(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createLight(device) {
@@ -1962,7 +1964,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Light(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1988,13 +1990,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Light(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createAirConditioner(device) {
@@ -2019,7 +2021,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new AirConditioner(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2045,13 +2047,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new AirConditioner(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createAirPurifier(device) {
@@ -2076,7 +2078,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new AirPurifier(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2102,13 +2104,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new AirPurifier(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createWaterHeater(device) {
@@ -2133,7 +2135,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new WaterHeater(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2159,13 +2161,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new WaterHeater(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createVacuumCleaner(device) {
@@ -2190,7 +2192,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new VacuumCleaner(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2216,13 +2218,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new VacuumCleaner(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createCamera(device) {
@@ -2247,7 +2249,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Camera(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2273,13 +2275,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Camera(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async createOthers(device) {
@@ -2304,7 +2306,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Others(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2330,13 +2332,13 @@ export class SwitchBotPlatform {
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Others(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            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 {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
         }
     }
     async registerCurtains(device) {
@@ -2349,13 +2351,12 @@ export class SwitchBotPlatform {
         }*/
         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}`);
+            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},`
+            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);
@@ -2366,42 +2367,42 @@ export class SwitchBotPlatform {
         return registerWindowCovering;
     }
     async registerWindowCovering(device) {
-        await this.debugLog(`master: ${device.master}`);
+        this.debugLog(device.master);
         let registerCurtain;
         if (device.master && device.group) {
             // OpenAPI: Master Curtains/Blind Tilt in Group
             registerCurtain = true;
-            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}`);
+            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}`);
         }
         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;
-            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: `
+            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: `
                 + `${device.curtain?.disable_group}, connectionType; ${device.connectionType}`);
-            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else if (device.master && !device.group) {
             // OpenAPI: Master Curtains/Blind Tilts not in Group
             registerCurtain = true;
-            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}`);
+            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}`);
         }
         else if (device.connectionType === 'BLE') {
             // BLE: Curtains/Blind Tilt
             registerCurtain = true;
-            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] connectionType: ${device.connectionType}, `
+            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] connectionType: ${device.connectionType}, `
                 + ` group: ${device.group}`);
-            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else {
             registerCurtain = false;
-            await this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.curtain?.disable_group},`
+            this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.curtain?.disable_group},`
                 + ` device.master: ${device.master}, device.group: ${device.group}`);
-            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}, device.connectionType: ${device.connectionType}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}, device.connectionType: ${device.connectionType}`);
         }
         return registerCurtain;
     }
@@ -2424,17 +2425,17 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
             if (registerDevice === true) {
-                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+                this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
             }
             else {
-                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+                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') {
@@ -2443,17 +2444,17 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
             if (registerDevice === true) {
-                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+                this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
             }
             else {
-                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+                this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
             }
         }
         else if (!device.hide_device && device.connectionType === 'OpenAPI') {
@@ -2462,17 +2463,17 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
             if (registerDevice === true) {
-                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+                this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
             }
             else {
-                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+                this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
             }
         }
         else if (!device.hide_device && device.connectionType === 'Disabled') {
@@ -2481,25 +2482,25 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
-            await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will continue to display in HomeKit`);
+            this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will continue to display in HomeKit`);
         }
         else if (!device.connectionType && !device.hide_device) {
             registerDevice = false;
-            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
         }
         else if (device.hide_device) {
             registerDevice = false;
-            await this.debugErrorLog(`Device: ${device.deviceName} hide_device: ${device.hide_device}, will not display in HomeKit`);
+            this.debugErrorLog(`Device: ${device.deviceName} hide_device: ${device.hide_device}, will not display in HomeKit`);
         }
         else {
             registerDevice = false;
-            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: `
+            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: `
                 + `${device.hide_device},  will not display in HomeKit`);
         }
         return registerDevice;
@@ -2511,21 +2512,21 @@ export class SwitchBotPlatform {
          * publish your TV as an external accessory.
          */
         if (device.external) {
-            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
+            this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
             this.externalAccessory(accessory);
         }
         else {
-            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+            this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
     }
     async externalOrPlatform(device, accessory) {
         if (device.external) {
-            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
-            await this.externalAccessory(accessory);
+            this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
+            this.externalAccessory(accessory);
         }
         else {
-            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+            this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
     }
@@ -2540,67 +2541,67 @@ export class SwitchBotPlatform {
     async statusCode(statusCode) {
         switch (statusCode) {
             case 151:
-                await this.errorLog(`Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: ` +
+                this.errorLog(`Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: ` +
                     'https://tinyurl.com/SwitchBotFeatureRequest');
                 break;
             case 152:
-                await this.errorLog(`Device not found, statusCode: ${statusCode}`);
+                this.errorLog(`Device not found, statusCode: ${statusCode}`);
                 break;
             case 160:
-                await this.errorLog(`Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
+                this.errorLog(`Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
                 break;
             case 161:
-                await this.errorLog(`Device is offline, statusCode: ${statusCode}`);
+                this.errorLog(`Device is offline, statusCode: ${statusCode}`);
                 break;
             case 171:
-                await this.errorLog(`is offline, statusCode: ${statusCode}`);
+                this.errorLog(`is offline, statusCode: ${statusCode}`);
                 break;
             case 190:
-                await this.errorLog(`Requests reached the daily limit, statusCode: ${statusCode}`);
+                this.errorLog(`Requests reached the daily limit, statusCode: ${statusCode}`);
                 break;
             case 100:
-                await await this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
+                this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
                 break;
             case 200:
-                await await this.debugLog(`Request successful, statusCode: ${statusCode}`);
+                this.debugLog(`Request successful, statusCode: ${statusCode}`);
                 break;
             case 400:
-                await this.errorLog('Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request '
+                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:
-                await this.errorLog('Unauthorized,	Authorization for the API is required, but the request has not been authenticated, '
+                this.errorLog('Unauthorized,	Authorization for the API is required, but the request has not been authenticated, '
                     + `statusCode: ${statusCode}`);
                 break;
             case 403:
-                await this.errorLog('Forbidden,	The request has been authenticated but does not have appropriate permissions, or a requested resource is not '
+                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:
-                await this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
+                this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
                 break;
             case 406:
-                await this.errorLog('Not Acceptable,	The client has requested a MIME type via the Accept header for a value not supported by the server, '
+                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:
-                await this.errorLog('Unsupported Media Type,	The client has defined a contentType header that is not supported by the server, '
+                this.errorLog('Unsupported Media Type,	The client has defined a contentType header that is not supported by the server, '
                     + `statusCode: ${statusCode}`);
                 break;
             case 422:
-                await this.errorLog('Unprocessable Entity,	The client has made a valid request, but the server cannot process it. This is often used for '
+                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:
-                await this.errorLog('Too Many Requests,	The client has exceeded the number of requests allowed for a given time window, '
+                this.errorLog('Too Many Requests,	The client has exceeded the number of requests allowed for a given time window, '
                     + `statusCode: ${statusCode}`);
                 break;
             case 500:
-                await this.errorLog('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare, '
+                this.errorLog('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare, '
                     + `statusCode: ${statusCode}`);
                 break;
             default:
-                await this.errorLog(`Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
+                this.errorLog(`Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
         }
     }
     async retryRequest(deviceMaxRetries, deviceDelayBetweenRetries, url, options) {
@@ -2614,14 +2615,14 @@ export class SwitchBotPlatform {
                     return { body, statusCode };
                 }
                 else {
-                    await await this.debugLog(`Received status code: ${statusCode}`);
+                    this.debugLog(`Received status code: ${statusCode}`);
                 }
             }
             catch (error) {
-                await this.errorLog(`Error making request: ${error.message}`);
+                this.errorLog(`Error making request: ${error.message}`);
             }
             retryCount++;
-            await await this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`);
+            this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`);
             await sleep(delayBetweenRetries);
         }
         return { body: null, statusCode: -1 };
@@ -2632,17 +2633,16 @@ export class SwitchBotPlatform {
         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;
-            await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}, Error: ${e}`);
+            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'));
-        await await this.debugLog(`Plugin Version: ${json.version}`);
+        this.debugLog(`Plugin Version: ${json.version}`);
         this.version = json.version;
     }
     async getPlatformConfigSettings() {
@@ -2679,7 +2679,7 @@ export class SwitchBotPlatform {
                 platformConfig.delayBetweenRetries = this.delayBetweenRetries / 1000;
             }
             if (Object.entries(platformConfig).length !== 0) {
-                await await this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
+                this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
             }
             this.platformConfig = platformConfig;
         }
@@ -2688,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;
-            await await this.debugWarnLog(`Using Config Logging: ${this.platformLogging}`);
+            this.debugWarnLog(`Using Config Logging: ${this.platformLogging}`);
         }
         else if (this.debugMode) {
             this.platformLogging = 'debugMode';
-            await await this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
         }
         else {
             this.platformLogging = 'standard';
-            await await this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
         }
     }
     /**
      * If device level logging is turned on, log to log.warn
      * Otherwise send debug logs to log.debug
      */
-    async infoLog(...log) {
-        if (await this.enablingPlatformLogging()) {
+    infoLog(...log) {
+        if (this.enablingPlatformLogging()) {
             this.log.info(String(...log));
         }
     }
-    async successLog(...log) {
-        if (await this.enablingPlatformLogging()) {
+    successLog(...log) {
+        if (this.enablingPlatformLogging()) {
             this.log.success(String(...log));
         }
     }
-    async debugSuccessLog(...log) {
-        if (await this.enablingPlatformLogging()) {
+    debugSuccessLog(...log) {
+        if (this.enablingPlatformLogging()) {
             if (this.platformLogging?.includes('debug')) {
                 this.log.success('[DEBUG]', String(...log));
             }
         }
     }
-    async warnLog(...log) {
-        if (await this.enablingPlatformLogging()) {
+    warnLog(...log) {
+        if (this.enablingPlatformLogging()) {
             this.log.warn(String(...log));
         }
     }
-    async debugWarnLog(...log) {
-        if (await this.enablingPlatformLogging()) {
+    debugWarnLog(...log) {
+        if (this.enablingPlatformLogging()) {
             if (this.platformLogging?.includes('debug')) {
                 this.log.warn('[DEBUG]', String(...log));
             }
         }
     }
-    async errorLog(...log) {
-        if (await this.enablingPlatformLogging()) {
+    errorLog(...log) {
+        if (this.enablingPlatformLogging()) {
             this.log.error(String(...log));
         }
     }
-    async debugErrorLog(...log) {
-        if (await this.enablingPlatformLogging()) {
+    debugErrorLog(...log) {
+        if (this.enablingPlatformLogging()) {
             if (this.platformLogging?.includes('debug')) {
                 this.log.error('[DEBUG]', String(...log));
             }
         }
     }
-    async debugLog(...log) {
-        if (await this.enablingPlatformLogging()) {
+    debugLog(...log) {
+        if (this.enablingPlatformLogging()) {
             if (this.platformLogging === 'debugMode') {
                 this.log.debug(String(...log));
             }
@@ -2754,7 +2754,7 @@ export class SwitchBotPlatform {
             }
         }
     }
-    async enablingPlatformLogging() {
+    enablingPlatformLogging() {
         return this.platformLogging?.includes('debug') || this.platformLogging === 'standard';
     }
 }