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

package/dist/device/bot.js

@@ -186,7 +186,7 @@ export class Bot extends deviceBase {
             }
             catch (e) {
                 await this.apiError(e);
-                await this.errorLog(`failed pushChanges with ${device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
+                this.errorLog(`failed pushChanges with ${device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
             this.botUpdateInProgress = false;
         });
@@ -195,40 +195,40 @@ export class Bot extends deviceBase {
      * Parse the device status from the SwitchBotBLE API
      */
     async BLEparseStatus() {
-        await this.debugLog('BLEparseStatus');
-        await this.debugLog(`(power, battery, deviceMode) = BLE:(${this.serviceData.state}, ${this.serviceData.battery}, ${this.serviceData.mode}), current:(${this.accessory.context.On}, ${this.Battery.BatteryLevel}, ${this.botMode})`);
+        this.debugLog('BLEparseStatus');
+        this.debugLog(`(power, battery, deviceMode) = BLE:(${this.serviceData.state}, ${this.serviceData.battery}, ${this.serviceData.mode}), current:(${this.accessory.context.On}, ${this.Battery.BatteryLevel}, ${this.botMode})`);
         // BLEmode (true if Switch Mode) | (false if Press Mode)
         this.On = this.serviceData.mode ? this.serviceData.state : false;
         const mode = this.serviceData.mode ? 'Switch' : 'Press';
-        await this.debugLog(`${mode} Mode, On: ${this.On}`);
+        this.debugLog(`${mode} Mode, On: ${this.On}`);
         this.accessory.context.On = this.On;
         // BatteryLevel
         this.Battery.BatteryLevel = this.serviceData.battery;
-        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
         // StatusLowBattery
         this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
             ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW
             : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
     }
     /**
      * Parse the device status from the SwitchBot OpenAPI
      */
     async openAPIparseStatus() {
-        await this.debugLog('openAPIparseStatus');
-        await this.debugLog(`(power, battery, deviceMode) = API:(${this.deviceStatus.power}, ${this.deviceStatus.battery}, ${this.botMode}), current:(${this.accessory.context.On}, ${this.Battery.BatteryLevel}, ${this.botMode})`);
+        this.debugLog('openAPIparseStatus');
+        this.debugLog(`(power, battery, deviceMode) = API:(${this.deviceStatus.power}, ${this.deviceStatus.battery}, ${this.botMode}), current:(${this.accessory.context.On}, ${this.Battery.BatteryLevel}, ${this.botMode})`);
         // On
         this.On = this.botMode === 'press' ? false : this.deviceStatus.power === 'on';
-        await this.debugLog(`On: ${this.On}`);
+        this.debugLog(`On: ${this.On}`);
         this.accessory.context.On = this.On;
         // Battery Level
         this.Battery.BatteryLevel = this.deviceStatus.battery;
-        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
         // StatusLowBattery
         this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
             ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW
             : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
         // Firmware Version
         if (this.deviceStatus.version) {
             const version = this.deviceStatus.version.toString();
@@ -241,33 +241,33 @@ export class Bot extends deviceBase {
                 .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
                 .updateValue(deviceVersion);
             this.accessory.context.version = deviceVersion;
-            await this.debugLog(`version: ${deviceVersion}`);
+            this.debugLog(`version: ${deviceVersion}`);
         }
     }
     async parseStatusWebhook() {
-        await this.debugLog('parseStatusWebhook');
-        await this.debugLog(`(power, battery, deviceMode) = Webhook:(${this.webhookContext.power}, ${this.webhookContext.battery}, ${this.webhookContext.deviceMode}), current:(${this.On}, ${this.Battery.BatteryLevel}, ${this.botMode})`);
+        this.debugLog('parseStatusWebhook');
+        this.debugLog(`(power, battery, deviceMode) = Webhook:(${this.webhookContext.power}, ${this.webhookContext.battery}, ${this.webhookContext.deviceMode}), current:(${this.On}, ${this.Battery.BatteryLevel}, ${this.botMode})`);
         // On
         this.On = this.webhookContext.power === 'on';
-        await this.debugLog(`On: ${this.On}`);
+        this.debugLog(`On: ${this.On}`);
         // BatteryLevel
         this.Battery.BatteryLevel = this.webhookContext.battery;
-        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
         // StatusLowBattery
         this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
             ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW
             : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
         // Mode
         this.botMode = this.webhookContext.deviceMode;
-        await this.debugLog(`Mode: ${this.botMode}`);
+        this.debugLog(`Mode: ${this.botMode}`);
     }
     /**
      * Asks the SwitchBot API for the latest device information
      */
     async refreshStatus() {
         if (!this.device.enableCloudService && this.OpenAPI) {
-            await this.errorLog(`refreshStatus enableCloudService: ${this.device.enableCloudService}`);
+            this.errorLog(`refreshStatus enableCloudService: ${this.device.enableCloudService}`);
         }
         else if (this.BLE) {
             await this.BLERefreshStatus();
@@ -277,11 +277,11 @@ export class Bot extends deviceBase {
         }
         else {
             await this.offlineOff();
-            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, refreshStatus will not happen.`);
+            this.debugWarnLog(`Connection Type: ${this.device.connectionType}, refreshStatus will not happen.`);
         }
     }
     async BLERefreshStatus() {
-        await this.debugLog('BLERefreshStatus');
+        this.debugLog('BLERefreshStatus');
         const switchBotBLE = await this.switchbotBLE();
         if (switchBotBLE === undefined) {
             await this.BLERefreshConnection(switchBotBLE);
@@ -298,79 +298,79 @@ export class Bot extends deviceBase {
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    await this.errorLog(`failed to get serviceData, serviceData: ${JSON.stringify(serviceData)}`);
+                    this.errorLog(`failed to get serviceData, serviceData: ${JSON.stringify(serviceData)}`);
                     await this.BLERefreshConnection(switchBotBLE);
                 }
             })();
         }
     }
     async registerPlatformBLE() {
-        await this.debugLog('registerPlatformBLE');
+        this.debugLog('registerPlatformBLE');
         if (this.config.options?.BLE) {
-            await this.debugLog('is listening to Platform BLE.');
+            this.debugLog('is listening to Platform BLE.');
             try {
                 const formattedDeviceId = formatDeviceIdAsMac(this.device.deviceId);
                 this.device.bleMac = formattedDeviceId;
-                await this.debugLog(`bleMac: ${this.device.bleMac}`);
+                this.debugLog(`bleMac: ${this.device.bleMac}`);
                 this.platform.bleEventHandler[this.device.bleMac] = async (context) => {
                     try {
-                        await this.debugLog(`received BLE: ${JSON.stringify(context)}`);
+                        this.debugLog(`received BLE: ${JSON.stringify(context)}`);
                         this.serviceData = context;
                         await this.BLEparseStatus();
                         await this.updateHomeKitCharacteristics();
                     }
                     catch (e) {
-                        await this.errorLog(`failed to handle BLE. Received: ${JSON.stringify(context)} Error: ${e.message ?? e}`);
+                        this.errorLog(`failed to handle BLE. Received: ${JSON.stringify(context)} Error: ${e.message ?? e}`);
                     }
                 };
             }
             catch (error) {
-                await this.errorLog(`failed to format device ID as MAC, Error: ${error}`);
+                this.errorLog(`failed to format device ID as MAC, Error: ${error}`);
             }
         }
         else {
-            await this.debugLog('is not listening to Platform BLE');
+            this.debugLog('is not listening to Platform BLE');
         }
     }
     async openAPIRefreshStatus() {
-        await this.debugLog('openAPIRefreshStatus');
+        this.debugLog('openAPIRefreshStatus');
         try {
-            const { body } = await this.deviceRefreshStatus();
-            const deviceStatus = await body;
-            await this.debugLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+            const response = await this.deviceRefreshStatus();
+            const deviceStatus = response.body;
+            this.debugLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
             if (await this.successfulStatusCodes(deviceStatus)) {
-                await this.debugSuccessLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                this.debugSuccessLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                 this.deviceStatus = deviceStatus.body;
                 await this.openAPIparseStatus();
                 await this.updateHomeKitCharacteristics();
             }
             else {
-                await this.debugWarnLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
-                await this.debugWarnLog(deviceStatus);
+                this.debugWarnLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                this.debugWarnLog(deviceStatus);
             }
         }
         catch (e) {
             await this.apiError(e);
-            await this.errorLog(`failed openAPIRefreshStatus with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
+            this.errorLog(`failed openAPIRefreshStatus with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
         }
     }
     async registerWebhook() {
         if (this.device.webhook) {
-            await this.debugLog('is listening webhook.');
+            this.debugLog('is listening webhook.');
             this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
                 try {
-                    await this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
+                    this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
                     this.webhookContext = context;
                     await this.parseStatusWebhook();
                     await this.updateHomeKitCharacteristics();
                 }
                 catch (e) {
-                    await this.errorLog(`failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e.message ?? e}`);
+                    this.errorLog(`failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e.message ?? e}`);
                 }
             };
         }
         else {
-            await this.debugLog('is not listening webhook.');
+            this.debugLog('is not listening webhook.');
         }
     }
     /**
@@ -382,7 +382,7 @@ export class Bot extends deviceBase {
      */
     async pushChanges() {
         if (!this.device.enableCloudService && this.OpenAPI) {
-            await this.errorLog(`pushChanges enableCloudService: ${this.device.enableCloudService}`);
+            this.errorLog(`pushChanges enableCloudService: ${this.device.enableCloudService}`);
         }
         else if (this.BLE) {
             await this.BLEpushChanges();
@@ -392,7 +392,7 @@ export class Bot extends deviceBase {
         }
         else {
             await this.offlineOff();
-            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, pushChanges will not happen.`);
+            this.debugWarnLog(`Connection Type: ${this.device.connectionType}, pushChanges will not happen.`);
         }
         // Refresh the status from the API
         interval(15000)
@@ -403,26 +403,26 @@ export class Bot extends deviceBase {
         });
     }
     async BLEpushChanges() {
-        await this.debugLog('BLEpushChanges');
+        this.debugLog('BLEpushChanges');
         if ((this.On !== this.accessory.context.On) || this.allowPush) {
-            await this.debugLog(`BLEpushChanges On: ${this.On} OnCached: ${this.accessory.context.On}`);
+            this.debugLog(`BLEpushChanges On: ${this.On} OnCached: ${this.accessory.context.On}`);
             const switchBotBLE = this.platform.switchBotBLE;
             try {
                 const formattedDeviceId = formatDeviceIdAsMac(this.device.deviceId);
                 this.device.bleMac = formattedDeviceId;
-                await this.debugLog(`bleMac: ${this.device.bleMac}`);
+                this.debugLog(`bleMac: ${this.device.bleMac}`);
                 // if (switchBotBLE !== false) {
-                await this.debugLog(`Bot Mode: ${this.botMode}`);
+                this.debugLog(`Bot Mode: ${this.botMode}`);
                 if (this.botMode === 'press') {
                     switchBotBLE
                         .discover({ model: this.device.bleModel, quick: true, id: this.device.bleMac })
                         .then(async (device_list) => {
                         const deviceList = device_list;
-                        await this.infoLog(`On: ${this.On}`);
+                        this.infoLog(`On: ${this.On}`);
                         return await deviceList[0].press();
                     })
                         .then(async () => {
-                        await this.successLog(`On: ${this.On} sent over SwitchBot BLE,  sent successfully`);
+                        this.successLog(`On: ${this.On} sent over SwitchBot BLE,  sent successfully`);
                         await this.updateHomeKitCharacteristics();
                         setTimeout(async () => {
                             this.On = false;
@@ -432,7 +432,7 @@ export class Bot extends deviceBase {
                     })
                         .catch(async (e) => {
                         await this.apiError(e);
-                        await this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
+                        this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
                         await this.BLEPushConnection();
                     });
                 }
@@ -444,7 +444,7 @@ export class Bot extends deviceBase {
                         this.infoLog(`On: ${this.On}`);
                         this.warnLog(`device_list: ${JSON.stringify(device_list)}`);
                         return await this.retryBLE({
-                            max: await this.maxRetryBLE(),
+                            max: this.maxRetryBLE(),
                             fn: async () => {
                                 if (deviceList.length > 0) {
                                     if (this.On) {
@@ -461,41 +461,41 @@ export class Bot extends deviceBase {
                         });
                     })
                         .then(async () => {
-                        await this.successLog(`On: ${this.On} sent over SwitchBot BLE,  sent successfully`);
+                        this.successLog(`On: ${this.On} sent over SwitchBot BLE,  sent successfully`);
                         await this.updateHomeKitCharacteristics();
                     })
                         .catch(async (e) => {
                         await this.apiError(e);
-                        await this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
+                        this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
                         await this.BLEPushConnection();
                     });
                 }
                 else {
-                    await this.errorLog(`Device Parameters not set for this Bot, please check the device configuration. Bot Mode: ${this.botMode}`);
+                    this.errorLog(`Device Parameters not set for this Bot, please check the device configuration. Bot Mode: ${this.botMode}`);
                 }
             }
             catch (error) {
-                await this.errorLog(`failed to format device ID as MAC, Error: ${error}`);
+                this.errorLog(`failed to format device ID as MAC, Error: ${error}`);
             }
         }
         else {
-            await this.debugLog(`No Changes (BLEpushChanges), On: ${this.On} OnCached: ${this.accessory.context.On}`);
+            this.debugLog(`No Changes (BLEpushChanges), On: ${this.On} OnCached: ${this.accessory.context.On}`);
         }
     }
     async openAPIpushChanges() {
-        await this.debugLog('openAPIpushChanges');
+        this.debugLog('openAPIpushChanges');
         if (this.multiPressCount > 0) {
-            await this.debugLog(`${this.multiPressCount} request(s) queued.`);
+            this.debugLog(`${this.multiPressCount} request(s) queued.`);
         }
         if ((this.On !== this.accessory.context.On) || this.allowPush || this.multiPressCount > 0) {
             let command = '';
             if (this.botMode === 'switch') {
                 command = this.On ? 'turnOn' : 'turnOff';
-                await this.debugLog(`Switch Mode, Command: ${command}`);
+                this.debugLog(`Switch Mode, Command: ${command}`);
             }
             else if (this.botMode === 'press' || this.botMode === 'multipress') {
                 command = 'press';
-                await this.debugLog('Press Mode');
+                this.debugLog('Press Mode');
                 this.On = false;
             }
             else {
@@ -506,13 +506,13 @@ export class Bot extends deviceBase {
                 parameter: 'default',
                 commandType: 'command',
             };
-            await this.debugLog(`SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
+            this.debugLog(`SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
-                const { body } = await this.pushChangeRequest(bodyChange);
-                const deviceStatus = await body;
-                await this.debugLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                const response = await this.pushChangeRequest(bodyChange);
+                const deviceStatus = response.body;
+                this.debugLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                 if (await this.successfulStatusCodes(deviceStatus)) {
-                    await this.debugSuccessLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                    this.debugSuccessLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
@@ -521,7 +521,7 @@ export class Bot extends deviceBase {
                 if (this.device.mode === 'multipress') {
                     this.multiPressCount--;
                     if (this.multiPressCount > 0) {
-                        await this.debugLog(`multiPressCount: ${this.multiPressCount}`);
+                        this.debugLog(`multiPressCount: ${this.multiPressCount}`);
                         this.On = true;
                         await this.openAPIpushChanges();
                     }
@@ -529,11 +529,11 @@ export class Bot extends deviceBase {
             }
             catch (e) {
                 await this.apiError(e);
-                await this.errorLog(`failed openAPIpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
+                this.errorLog(`failed openAPIpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            await this.debugLog(`No Changes (openAPIpushChanges), On: ${this.On} OnCached: ${this.accessory.context.On}`);
+            this.debugLog(`No Changes (openAPIpushChanges), On: ${this.On} OnCached: ${this.accessory.context.On}`);
         }
     }
     /**
@@ -567,29 +567,29 @@ export class Bot extends deviceBase {
      * Updates the status for each of the HomeKit Characteristics
      */
     async updateHomeKitCharacteristics() {
-        await this.debugLog('updateHomeKitCharacteristics');
+        this.debugLog('updateHomeKitCharacteristics');
         // BatteryLevel
         if (this.Battery.BatteryLevel === undefined) {
-            await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+            this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
         }
         else {
             this.accessory.context.BatteryLevel = this.Battery.BatteryLevel;
             this.Battery.Service.updateCharacteristic(this.hap.Characteristic.BatteryLevel, this.Battery.BatteryLevel);
-            await this.debugLog(`updateCharacteristic BatteryLevel: ${this.Battery.BatteryLevel}`);
+            this.debugLog(`updateCharacteristic BatteryLevel: ${this.Battery.BatteryLevel}`);
         }
         // StatusLowBattery
         if (this.Battery.StatusLowBattery === undefined) {
-            await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+            this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
         }
         else {
             this.accessory.context.StatusLowBattery = this.Battery.StatusLowBattery;
             this.Battery.Service.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, this.Battery.StatusLowBattery);
-            await this.debugLog(`updateCharacteristic StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+            this.debugLog(`updateCharacteristic StatusLowBattery: ${this.Battery.StatusLowBattery}`);
         }
         // State
         const updateCharacteristic = async (service, characteristic, value, logMessage) => {
             service.updateCharacteristic(characteristic, value);
-            await this.debugLog(logMessage);
+            this.debugLog(logMessage);
         };
         const stateActions = {
             switch: async () => this.Switch && await updateCharacteristic(this.Switch.Service, this.hap.Characteristic.On, this.On, `updateCharacteristic On: ${this.On}`),
@@ -642,7 +642,7 @@ export class Bot extends deviceBase {
                 }
             },
             outlet: async () => this.Outlet && await updateCharacteristic(this.Outlet.Service, this.hap.Characteristic.On, this.On, `updateCharacteristic On: ${this.On}`),
-            default: async () => await this.errorLog(`botDeviceType: ${this.botDeviceType}, On: ${this.On}`),
+            default: async () => this.errorLog(`botDeviceType: ${this.botDeviceType}, On: ${this.On}`),
         };
         const action = stateActions[this.botDeviceType] || stateActions.default;
         await action();
@@ -655,7 +655,7 @@ export class Bot extends deviceBase {
             Service: accessory.getService(this.hap.Service[serviceType]),
         };
         accessory.context[contextKey] = this[contextKey];
-        await this.debugWarnLog(`Removing any leftover ${contextKey} Service`);
+        this.debugWarnLog(`Removing any leftover ${contextKey} Service`);
         accessory.removeService(this[contextKey].Service);
     }
     async removeOutletService(accessory) {
@@ -692,7 +692,7 @@ export class Bot extends deviceBase {
         // Bot Device Type
         this.botDeviceType = device.type ?? 'Outlet';
         const botDeviceType = device.type ? 'Device Config' : 'Default';
-        await this.debugWarnLog(`Use ${botDeviceType} Device Type: ${this.botDeviceType}`);
+        this.debugWarnLog(`Use ${botDeviceType} Device Type: ${this.botDeviceType}`);
         // Bot Mode
         this.botMode = device.mode ?? 'switch';
         if (!device.mode) {
@@ -709,40 +709,40 @@ export class Bot extends deviceBase {
         const botModeLog = device.mode
             ? `Using Bot Mode: ${this.botMode}`
             : `No Bot Mode Set, Using default Bot Mode: ${this.botMode}`;
-        await this.debugWarnLog(botModeLog);
+        this.debugWarnLog(botModeLog);
         this.accessory.context.botMode = this.botMode;
         // Bot Double Press
         this.doublePress = device.doublePress ?? 1;
         const doublePress = device.doublePress
             ? `Using Double Press: ${this.doublePress}`
             : `No Double Press Set, Using default Double Press: ${this.doublePress}`;
-        await this.debugWarnLog(doublePress);
+        this.debugWarnLog(doublePress);
         // Bot Press PushRate
         this.pushRatePress = device.pushRatePress ?? 15;
         const pushRatePress = device.pushRatePress
             ? `Using Bot Push Rate Press: ${this.pushRatePress}`
             : `No Push Rate Press Set, Using default Push Rate Press: ${this.pushRatePress}`;
-        await this.debugWarnLog(pushRatePress);
+        this.debugWarnLog(pushRatePress);
         // Bot Allow Push
         this.allowPush = device.allowPush ?? false;
         const allowPush = device.allowPush
             ? `Using Allow Push: ${this.allowPush}`
             : `No Allow Push Set, Using default Allow Push: ${this.allowPush}`;
-        await this.debugWarnLog(allowPush);
+        this.debugWarnLog(allowPush);
         // Bot Multi Press Count
         this.multiPressCount = 0;
-        await this.debugWarnLog(`Multi Press Count: ${this.multiPressCount}`);
+        this.debugWarnLog(`Multi Press Count: ${this.multiPressCount}`);
     }
     async BLEPushConnection() {
         if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
-            await this.warnLog('Using OpenAPI Connection to Push Changes');
+            this.warnLog('Using OpenAPI Connection to Push Changes');
             await this.openAPIpushChanges();
         }
     }
     async BLERefreshConnection(switchbot) {
-        await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
+        this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
         if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
-            await this.warnLog('Using OpenAPI Connection to Refresh Status');
+            this.warnLog('Using OpenAPI Connection to Refresh Status');
             await this.openAPIRefreshStatus();
         }
     }