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

package/dist/device/bot.js

@@ -3,8 +3,8 @@
  * bot.ts: @switchbot/homebridge-switchbot.
  */
 import { deviceBase } from './device.js';
-import { interval, Subject } from 'rxjs';
-import { debounceTime, skipWhile, take, tap } from 'rxjs/operators';
+import { SwitchBotBLEModel, SwitchBotBLEModelName } from 'node-switchbot';
+import { Subject, debounceTime, interval, skipWhile, take, tap } from 'rxjs';
 /**
  * Platform Accessory
  * An instance of this class is created for each accessory your platform registers
@@ -66,7 +66,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.Switch = this.Switch;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Switch`);
+            this.debugLog('Displaying as Switch');
             // Initialize Switch Characteristics
             this.Switch.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.Switch.Name)
@@ -96,7 +96,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.GarageDoor = this.GarageDoor;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Garage Door Opener`);
+            this.debugLog('Displaying as Garage Door Opener');
             // Initialize GarageDoor Characteristics
             this.GarageDoor.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.GarageDoor.Name)
@@ -131,7 +131,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.Door = this.Door;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Door`);
+            this.debugLog('Displaying as Door');
             // Initialize Door Characteristics
             this.Door.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.Door.Name)
@@ -166,7 +166,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.Window = this.Window;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Window`);
+            this.debugLog('Displaying as Window');
             // Initialize Window Characteristics
             this.Window.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.Window.Name)
@@ -201,7 +201,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.WindowCovering = this.WindowCovering;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Window Covering`);
+            this.debugLog('Displaying as Window Covering');
             // Initialize WindowCovering Characteristics
             this.WindowCovering.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.WindowCovering.Name)
@@ -236,7 +236,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.LockMechanism = this.LockMechanism;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Lock`);
+            this.debugLog('Displaying as Lock');
             // Initialize Lock Characteristics
             this.LockMechanism.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.LockMechanism.Name)
@@ -265,7 +265,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.Faucet = this.Faucet;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Faucet`);
+            this.debugLog('Displaying as Faucet');
             // Initialize Faucet Characteristics
             this.Faucet.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.Faucet.Name)
@@ -294,7 +294,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.Fan = this.Fan;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Fan`);
+            this.debugLog('Displaying as Fan');
             // Initialize Fan Characteristics
             this.Fan.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.Fan.Name)
@@ -324,7 +324,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.StatefulProgrammableSwitch = this.StatefulProgrammableSwitch;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Stateful Programmable Switch`);
+            this.debugLog('Displaying as Stateful Programmable Switch');
             // Initialize StatefulProgrammableSwitch Characteristics
             this.StatefulProgrammableSwitch.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.StatefulProgrammableSwitch.Name)
@@ -353,7 +353,7 @@ export class Bot extends deviceBase {
                 On: accessory.context.On ?? false,
             };
             accessory.context.Outlet = this.Outlet;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Displaying as Outlet`);
+            this.debugLog('Displaying as Outlet');
             // Initialize Outlet Characteristics
             this.Outlet.Service
                 .setCharacteristic(this.hap.Characteristic.Name, this.Outlet.Name)
@@ -377,14 +377,14 @@ export class Bot extends deviceBase {
         this.refreshStatus();
         // Retrieve initial values and updateHomekit
         this.updateHomeKitCharacteristics();
+        // regisiter webhook event handler
+        this.registerWebhook();
         // Start an update interval
         interval(this.deviceRefreshRate * 1000)
             .pipe(skipWhile(() => this.botUpdateInProgress))
             .subscribe(async () => {
             await this.refreshStatus();
         });
-        // regisiter webhook event handler
-        this.registerWebhook(accessory, device);
         // Watch for Bot change events
         // We put in a debounce of 1000ms so we don't make duplicate calls
         this.doBotUpdate
@@ -405,9 +405,8 @@ export class Bot extends deviceBase {
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${device.deviceType}: ${accessory.displayName} failed pushChanges with ${device.connectionType} Connection,`
-                    + ` Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushChanges with ${device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
             this.botUpdateInProgress = false;
         });
@@ -416,40 +415,33 @@ export class Bot extends deviceBase {
      * Parse the device status from the SwitchBotBLE API
      */
     async BLEparseStatus(serviceData) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEparseStatus`);
+        await this.debugLog('BLEparseStatus');
         // BLEmode (true if Switch Mode) | (false if Press Mode)
         if (serviceData.mode) {
             this.accessory.context.On = await this.getOn();
             if (this.getOn() === undefined) {
                 this.setOn(Boolean(serviceData.state));
             }
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Switch Mode,`
-                + ` mode: ${serviceData.mode}, On: ${this.accessory.context.On}`);
+            this.debugLog(`Switch Mode, mode: ${serviceData.mode}, On: ${this.accessory.context.On}`);
         }
         else {
             this.setOn(false);
             this.accessory.context.On = await this.getOn();
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Press Mode,`
-                + ` mode: ${serviceData.mode}, On: ${this.accessory.context.On}`);
+            this.debugLog(`Press Mode, mode: ${serviceData.mode}, On: ${this.accessory.context.On}`);
         }
+        // BatteryLevel
         this.Battery.BatteryLevel = Number(serviceData.battery);
-        if (this.Battery.BatteryLevel < 10) {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
-        }
-        else {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-        }
-        if (Number.isNaN(this.Battery.BatteryLevel)) {
-            this.Battery.BatteryLevel = 100;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel},`
-            + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        // StatusLowBattery
+        this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
+            ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
     }
     /**
      * Parse the device status from the SwitchBot OpenAPI
      */
     async openAPIparseStatus(deviceStatus) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIparseStatus`);
+        await this.debugLog('openAPIparseStatus');
         if (this.botMode === 'press') {
             this.setOn(false);
             this.accessory.context.On = await this.getOn();
@@ -460,25 +452,19 @@ export class Bot extends deviceBase {
                 this.setOn(false);
             }
         }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.accessory.context.On}`);
-        // Battery
-        this.Battery.BatteryLevel = Number(deviceStatus.body.battery);
-        if (this.Battery.BatteryLevel < 10) {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
-        }
-        else {
-            this.Battery.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-        }
-        if (Number.isNaN(this.Battery.BatteryLevel)) {
-            this.Battery.BatteryLevel = 100;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel},`
-            + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        await this.debugLog(`On: ${this.accessory.context.On}`);
+        // Battery Level
+        this.Battery.BatteryLevel = Number(deviceStatus.battery);
+        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        // StatusLowBattery
+        this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
+            ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
         // Firmware Version
-        const version = deviceStatus.body.version?.toString();
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Firmware Version: ${version?.replace(/^V|-.*$/g, '')}`);
-        if (deviceStatus.body.version) {
-            const deviceVersion = version?.replace(/^V|-.*$/g, '') ?? '0.0.0';
+        const version = deviceStatus.version.toString();
+        this.debugLog(`Firmware Version: ${version.replace(/^V|-.*$/g, '')}`);
+        if (deviceStatus.version) {
+            const deviceVersion = version.replace(/^V|-.*$/g, '') ?? '0.0.0';
             this.accessory
                 .getService(this.hap.Service.AccessoryInformation)
                 .setCharacteristic(this.hap.Characteristic.HardwareRevision, deviceVersion)
@@ -486,15 +472,35 @@ export class Bot extends deviceBase {
                 .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
                 .updateValue(deviceVersion);
             this.accessory.context.deviceVersion = deviceVersion;
-            this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceVersion: ${this.accessory.context.deviceVersion}`);
+            await this.debugLog(`deviceVersion: ${this.accessory.context.deviceVersion}`);
         }
     }
+    async parseStatusWebhook(context) {
+        await this.debugLog('parseStatusWebhook');
+        const getOn = await this.getOn();
+        await this.debugLog(`(power, battery, deviceMode) = Webhook:(${context.power}, ${context.battery}, ${context.deviceMode}),`
+            + ` current:(${getOn}, ${this.Battery.BatteryLevel}, ${this.botMode})`);
+        // On
+        const setOn = context.power === 'on' ? true : false;
+        await this.setOn(setOn);
+        await this.debugLog(`On: ${setOn}`);
+        // BatteryLevel
+        this.Battery.BatteryLevel = context.battery;
+        await this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`);
+        // StatusLowBattery
+        this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
+            ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+        await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+        // Mode
+        this.botMode = context.deviceMode;
+        await this.debugLog(`Mode: ${this.botMode}`);
+    }
     /**
      * Asks the SwitchBot API for the latest device information
      */
     async refreshStatus() {
         if (!this.device.enableCloudService && this.OpenAPI) {
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} refreshStatus enableCloudService: ${this.device.enableCloudService}`);
+            await this.errorLog(`refreshStatus enableCloudService: ${this.device.enableCloudService}`);
         }
         else if (this.BLE) {
             await this.BLERefreshStatus();
@@ -504,12 +510,11 @@ export class Bot extends deviceBase {
         }
         else {
             await this.offlineOff();
-            this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-                + ` ${this.device.connectionType}, refreshStatus will not happen.`);
+            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, refreshStatus will not happen.`);
         }
     }
     async BLERefreshStatus() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLERefreshStatus`);
+        await this.debugLog('BLERefreshStatus');
         const switchbot = await this.switchbotBLE();
         if (switchbot === undefined) {
             await this.BLERefreshConnection(switchbot);
@@ -520,62 +525,55 @@ export class Bot extends deviceBase {
                 // Start to monitor advertisement packets
                 const serviceData = await this.monitorAdvertisementPackets(switchbot);
                 // Update HomeKit
-                if (serviceData.model !== '' && serviceData.modelName !== '') {
+                if (serviceData.model === SwitchBotBLEModel.Bot && serviceData.modelName === SwitchBotBLEModelName.Bot) {
                     await this.BLEparseStatus(serviceData);
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed to get serviceData, serviceData: ${serviceData}`);
+                    await this.errorLog(`failed to get serviceData, serviceData: ${serviceData}`);
                     await this.BLERefreshConnection(switchbot);
                 }
             })();
         }
     }
     async openAPIRefreshStatus() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
+        await this.debugLog('openAPIRefreshStatus');
         try {
             const { body, statusCode } = await this.deviceRefreshStatus();
             const deviceStatus = await body.json();
-            await this.refreshStatusCodes(statusCode, deviceStatus);
+            await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
             ;
-            if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                await this.successfulRefreshStatus(statusCode, deviceStatus);
-                await this.openAPIparseStatus(deviceStatus);
+            if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                await this.openAPIparseStatus(deviceStatus.body);
                 await this.updateHomeKitCharacteristics();
             }
             else {
-                await this.statusCodes(statusCode, deviceStatus);
+                await this.debugWarnLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                await this.debugWarnLog(statusCode, deviceStatus);
             }
         }
         catch (e) {
             await this.apiError(e);
-            await this.openAPIRefreshError(e);
+            await this.errorLog(`failed openAPIRefreshStatus with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
         }
     }
-    async registerWebhook(accessory, device) {
-        if (device.webhook) {
-            this.debugLog(`${device.deviceType}: ${accessory.displayName} is listening webhook.`);
-            this.platform.webhookEventHandler[device.deviceId] = async (context) => {
+    async registerWebhook() {
+        if (this.device.webhook) {
+            await this.debugLog('is listening webhook.');
+            this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
                 try {
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
-                    const { power, battery, deviceMode } = context;
-                    const { botMode } = this;
-                    const On = await this.getOn();
-                    const { BatteryLevel } = this.Battery;
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} (power, battery, deviceMode) = Webhook:(${power}, ${battery}, ${deviceMode}),`
-                        + ` current:(${On}, ${BatteryLevel}, ${botMode})`);
-                    await this.setOn(power);
-                    this.Battery.BatteryLevel = battery;
-                    this.botMode = deviceMode;
-                    this.updateHomeKitCharacteristics();
+                    await this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
+                    await this.parseStatusWebhook(context);
+                    await this.updateHomeKitCharacteristics();
                 }
                 catch (e) {
-                    this.errorLog(`${device.deviceType}: ${accessory.displayName} failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+                    await this.errorLog(`failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
                 }
             };
         }
         else {
-            this.debugLog(`${device.deviceType}: ${accessory.displayName} is not listening webhook.`);
+            await this.debugLog('is not listening webhook.');
         }
     }
     /**
@@ -587,7 +585,7 @@ export class Bot extends deviceBase {
      */
     async pushChanges() {
         if (!this.device.enableCloudService && this.OpenAPI) {
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} pushChanges enableCloudService: ${this.device.enableCloudService}`);
+            await this.errorLog(`pushChanges enableCloudService: ${this.device.enableCloudService}`);
         }
         else if (this.BLE) {
             await this.BLEpushChanges();
@@ -597,7 +595,7 @@ export class Bot extends deviceBase {
         }
         else {
             await this.offlineOff();
-            await this.pushChangeDisabled();
+            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, pushChanges will not happen.`);
         }
         // Refresh the status from the API
         interval(15000)
@@ -608,27 +606,24 @@ export class Bot extends deviceBase {
         });
     }
     async BLEpushChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushChanges`);
+        await this.debugLog('BLEpushChanges');
         const On = await this.getOn();
         if (On !== this.accessory.context.On || this.allowPush) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushChanges On: ${On} OnCached: ${this.accessory.context.On}`);
-            const switchbot = await this.platform.connectBLE();
-            // Convert to BLE Address
+            this.debugLog(`BLEpushChanges On: ${On} OnCached: ${this.accessory.context.On}`);
+            const switchbot = await this.platform.connectBLE(this.accessory, this.device);
             await this.convertBLEAddress();
             //if (switchbot !== false) {
             if (this.botMode === 'press') {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Bot Mode: ${this.botMode}`);
+                this.debugLog(`Bot Mode: ${this.botMode}`);
                 switchbot
                     .discover({ model: 'H', quick: true, id: this.device.bleMac })
                     .then(async (device_list) => {
-                    this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${On}`);
+                    this.infoLog(`On: ${On}`);
                     return await device_list[0].press({ id: this.device.bleMac });
                 })
-                    .then(() => {
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
-                    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `On: ${On} sent over BLE,  sent successfully`);
-                    this.accessory.context.On = On;
+                    .then(async () => {
+                    await this.successLog(`On: ${On} sent over SwitchBot BLE,  sent successfully`);
+                    await this.updateHomeKitCharacteristics();
                     setTimeout(() => {
                         if (this.botDeviceType === 'switch') {
                             this.Switch?.Service.getCharacteristic(this.hap.Characteristic.On).updateValue(On);
@@ -636,22 +631,21 @@ export class Bot extends deviceBase {
                         else {
                             this.Outlet?.Service.getCharacteristic(this.hap.Characteristic.On).updateValue(On);
                         }
-                        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${On}, Switch Timeout`);
+                        this.debugLog(`On: ${On}, Switch Timeout`);
                     }, 500);
                 })
                     .catch(async (e) => {
-                    this.apiError(e);
-                    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
-                        + ` Connection & botMode: ${this.botMode}, Error Message: ${JSON.stringify(e.message)}`);
+                    await this.apiError(e);
+                    await this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
                     await this.BLEPushConnection();
                 });
             }
             else if (this.botMode === 'switch') {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Press Mode: ${this.botMode}`);
+                this.debugLog(`Press Mode: ${this.botMode}`);
                 switchbot
                     .discover({ model: this.device.bleModel, quick: true, id: this.device.bleMac })
                     .then(async (device_list) => {
-                    this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${On}`);
+                    this.infoLog(`On: ${On}`);
                     return await this.retryBLE({
                         max: await this.maxRetryBLE(),
                         fn: async () => {
@@ -664,30 +658,29 @@ export class Bot extends deviceBase {
                         },
                     });
                 })
-                    .then(() => {
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
-                    this.accessory.context.On = On;
+                    .then(async () => {
+                    await this.successLog(`On: ${On} sent over SwitchBot BLE,  sent successfully`);
+                    await this.updateHomeKitCharacteristics();
                 })
                     .catch(async (e) => {
-                    this.apiError(e);
-                    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
-                        + ` Connection & botMode: ${this.botMode}, Error Message: ${JSON.stringify(e.message)}`);
+                    await this.apiError(e);
+                    await this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
                     await this.BLEPushConnection();
                 });
             }
             else {
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Bot Mode: ${this.botMode}`);
+                await this.errorLog(`Device Parameters not set for this Bot, please check the device configuration. Bot Mode: ${this.botMode}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No BLEpushChanges, On: ${On}, OnCached: ${this.accessory.context.On}`);
+            await this.debugLog(`No Changes (BLEpushChanges), On: ${On} OnCached: ${this.accessory.context.On}`);
         }
     }
     async openAPIpushChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIpushChanges`);
+        await this.debugLog('openAPIpushChanges');
         let On = await this.getOn();
         if (this.multiPressCount > 0) {
-            this.debugLog(`${this.device.deviceType}: ${this.multiPressCount} request(s) queued.`);
+            await this.debugLog(`${this.multiPressCount} request(s) queued.`);
             On = true;
         }
         if (On !== this.accessory.context.On || this.allowPush || this.multiPressCount > 0) {
@@ -695,33 +688,33 @@ export class Bot extends deviceBase {
             if (this.botMode === 'switch' && On) {
                 command = 'turnOn';
                 On = true;
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Switch Mode, Turning ${On}`);
+                await this.debugLog(`Switch Mode, Turning ${On}`);
             }
             else if (this.botMode === 'switch' && !On) {
                 command = 'turnOff';
                 On = false;
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Switch Mode, Turning ${On}`);
+                await this.debugLog(`Switch Mode, Turning ${On}`);
             }
             else if (this.botMode === 'press' || this.botMode === 'multipress') {
                 command = 'press';
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Press Mode`);
+                await this.debugLog('Press Mode');
                 On = false;
             }
             else {
-                throw new Error(`${this.device.deviceType}: ${this.accessory.displayName} Device Parameters not set for this Bot.`);
+                throw new Error('Device Parameters not set for this Bot.');
             }
             const bodyChange = JSON.stringify({
                 command: `${command}`,
                 parameter: 'default',
                 commandType: 'command',
             });
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+            this.debugLog(`Sending request to SwitchBot API, body: ${bodyChange},`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    await this.successfulPushChange(statusCode, deviceStatus, bodyChange);
+                await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                     await this.updateHomeKitCharacteristics();
                 }
                 else {
@@ -731,21 +724,19 @@ export class Bot extends deviceBase {
                 if (this.device.bot?.mode === 'multipress') {
                     this.multiPressCount--;
                     if (this.multiPressCount > 0) {
-                        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Multi Press Count: ${this.multiPressCount}`);
+                        await this.debugLog(`multiPressCount: ${this.multiPressCount}`);
                         On = true;
-                        this.openAPIpushChanges();
+                        await this.openAPIpushChanges();
                     }
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIpushChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed openAPIpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No openAPIpushChanges,`
-                + ` On: ${On}, OnCached: ${this.accessory.context.On}`);
+            await this.debugLog(`No Changes (openAPIpushChanges), On: ${On} OnCached: ${this.accessory.context.On}`);
         }
     }
     /**
@@ -754,7 +745,8 @@ export class Bot extends deviceBase {
     async OnSet(value) {
         if (this.botDeviceType === 'garagedoor') {
             if (this.GarageDoor) {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set TargetDoorState: ${value}`);
+                await this.debugLog(`Set TargetDoorState: ${value}`);
+                this.infoLog(`Set TargetDoorState: ${value}`);
                 if (value === this.hap.Characteristic.TargetDoorState.CLOSED) {
                     await this.setOn(false);
                     this.GarageDoor.On = false;
@@ -767,7 +759,7 @@ export class Bot extends deviceBase {
         }
         else if (this.botDeviceType === 'door') {
             if (this.Door) {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set TargetPosition: ${value}`);
+                await this.debugLog(`Set TargetPosition: ${value}`);
                 if (value === 0) {
                     await this.setOn(false);
                     this.Door.On = false;
@@ -780,7 +772,7 @@ export class Bot extends deviceBase {
         }
         else if (this.botDeviceType === 'window') {
             if (this.Window) {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set TargetPosition: ${value}`);
+                await this.debugLog(`Set TargetPosition: ${value}`);
                 if (value === 0) {
                     await this.setOn(false);
                     this.Window.On = false;
@@ -793,7 +785,7 @@ export class Bot extends deviceBase {
         }
         else if (this.botDeviceType === 'windowcovering') {
             if (this.WindowCovering) {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set TargetPosition: ${value}`);
+                await this.debugLog(`Set TargetPosition: ${value}`);
                 if (value === 0) {
                     await this.setOn(false);
                     this.WindowCovering.On = false;
@@ -806,7 +798,7 @@ export class Bot extends deviceBase {
         }
         else if (this.botDeviceType === 'lock') {
             if (this.LockMechanism) {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set LockTargetState: ${value}`);
+                await this.debugLog(`Set LockTargetState: ${value}`);
                 if (value === this.hap.Characteristic.LockTargetState.SECURED) {
                     await this.setOn(false);
                     this.LockMechanism.On = false;
@@ -819,7 +811,7 @@ export class Bot extends deviceBase {
         }
         else if (this.botDeviceType === 'faucet') {
             if (this.Faucet) {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Active: ${value}`);
+                await this.debugLog(`Set Active: ${value}`);
                 if (value === this.hap.Characteristic.Active.INACTIVE) {
                     await this.setOn(false);
                     this.Faucet.On = false;
@@ -832,7 +824,7 @@ export class Bot extends deviceBase {
         }
         else if (this.botDeviceType === 'stateful') {
             if (this.StatefulProgrammableSwitch) {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set ProgrammableSwitchOutputState: ${value}`);
+                await this.debugLog(`Set ProgrammableSwitchOutputState: ${value}`);
                 if (value === 0) {
                     await this.setOn(false);
                     this.StatefulProgrammableSwitch.On = false;
@@ -845,7 +837,7 @@ export class Bot extends deviceBase {
         }
         else if (this.botDeviceType === 'switch') {
             if (this.Switch) {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set ProgrammableSwitchOutputState: ${value}`);
+                await this.debugLog(`Set ProgrammableSwitchOutputState: ${value}`);
                 if (value === 0) {
                     await this.setOn(false);
                     this.Switch.On = false;
@@ -858,7 +850,7 @@ export class Bot extends deviceBase {
         }
         else {
             if (this.Outlet) {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set On: ${value}`);
+                await this.debugLog(`Set On: ${value}`);
                 await this.setOn(Boolean(value));
                 this.Outlet.On = value;
             }
@@ -866,7 +858,7 @@ export class Bot extends deviceBase {
         if (this.device.bot?.mode === 'multipress') {
             if (value === true) {
                 this.multiPressCount++;
-                this.debugLog(`${this.device.deviceType} set to Multi-Press. Multi-Press count: ${this.multiPressCount}`);
+                await this.debugLog(`multiPressCount: ${this.multiPressCount}`);
             }
         }
         this.doBotUpdate.next();
@@ -878,216 +870,203 @@ export class Bot extends deviceBase {
         // State
         if (this.botDeviceType === 'garagedoor') {
             if (this.GarageDoor?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.GarageDoor?.On}`);
+                await this.debugLog(`On: ${this.GarageDoor?.On}`);
             }
             else {
                 if (this.GarageDoor.On) {
                     this.GarageDoor.Service.updateCharacteristic(this.hap.Characteristic.TargetDoorState, this.hap.Characteristic.TargetDoorState.OPEN);
                     this.GarageDoor.Service.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, this.hap.Characteristic.CurrentDoorState.OPEN);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-                        + ` TargetDoorState: Open, CurrentDoorState: Open (${this.GarageDoor.On})`);
+                    await this.debugLog(`updateCharacteristic TargetDoorState: Open, CurrentDoorState: Open (${this.GarageDoor.On})`);
                 }
                 else {
                     this.GarageDoor.Service.updateCharacteristic(this.hap.Characteristic.TargetDoorState, this.hap.Characteristic.TargetDoorState.CLOSED);
                     this.GarageDoor.Service.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, this.hap.Characteristic.CurrentDoorState.CLOSED);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristicc`
-                        + ` TargetDoorState: Open, CurrentDoorState: Open (${this.GarageDoor.On})`);
+                    await this.debugLog(`updateCharacteristicc TargetDoorState: Open, CurrentDoorState: Open (${this.GarageDoor.On})`);
                 }
             }
             await this.setOn(Boolean(this.GarageDoor?.On));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Garage Door On: ${this.GarageDoor?.On}`);
+            await this.debugLog(`Garage Door On: ${this.GarageDoor?.On}`);
         }
         else if (this.botDeviceType === 'door') {
             if (this.Door?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.Door?.On}`);
+                await this.debugLog(`On: ${this.Door?.On}`);
             }
             else {
                 if (this.Door.On) {
                     this.Door.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, 100);
                     this.Door.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 100);
                     this.Door.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristicc`
-                        + ` TargetPosition: 100, CurrentPosition: 100 (${this.Door.On})`);
+                    await this.debugLog(`updateCharacteristicc TargetPosition: 100, CurrentPosition: 100 (${this.Door.On})`);
                 }
                 else {
                     this.Door.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, 0);
                     this.Door.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 0);
                     this.Door.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristicc`
-                        + ` TargetPosition: 0, CurrentPosition: 0 (${this.Door.On})`);
+                    await this.debugLog(`updateCharacteristicc TargetPosition: 0, CurrentPosition: 0 (${this.Door.On})`);
                 }
             }
             await this.setOn(Boolean(this.Door?.On));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Door On: ${this.Door?.On}`);
+            await this.debugLog(`Door On: ${this.Door?.On}`);
         }
         else if (this.botDeviceType === 'window') {
             if (this.Window?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.Window?.On}`);
+                await this.debugLog(`On: ${this.Window?.On}`);
             }
             else {
                 if (this.Window.On) {
                     this.Window.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, 100);
                     this.Window.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 100);
                     this.Window.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristicc`
-                        + ` TargetPosition: 100, CurrentPosition: 100 (${this.Window.On})`);
+                    await this.debugLog(`updateCharacteristicc TargetPosition: 100, CurrentPosition: 100 (${this.Window.On})`);
                 }
                 else {
                     this.Window.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, 0);
                     this.Window.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 0);
                     this.Window.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristicc`
-                        + ` TargetPosition: 0, CurrentPosition: 0 (${this.Window.On})`);
+                    await this.debugLog(`updateCharacteristicc TargetPosition: 0, CurrentPosition: 0 (${this.Window.On})`);
                 }
             }
             await this.setOn(Boolean(this.Window?.On));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Window On: ${this.Window?.On}`);
+            await this.debugLog(`Window On: ${this.Window?.On}`);
         }
         else if (this.botDeviceType === 'windowcovering') {
             if (this.WindowCovering?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.WindowCovering?.On}`);
+                await this.debugLog(`On: ${this.WindowCovering?.On}`);
             }
             else {
                 if (this.WindowCovering.On) {
                     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, 100);
                     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 100);
                     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristicc`
-                        + ` TargetPosition: 100, CurrentPosition: 100 (${this.WindowCovering.On})`);
+                    await this.debugLog(`updateCharacteristicc TargetPosition: 100, CurrentPosition: 100 (${this.WindowCovering.On})`);
                 }
                 else {
                     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, 0);
                     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, 0);
                     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.PositionState, this.hap.Characteristic.PositionState.STOPPED);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristicc`
-                        + ` TargetPosition: 0, CurrentPosition: 0 (${this.WindowCovering.On})`);
+                    await this.debugLog(`updateCharacteristicc TargetPosition: 0, CurrentPosition: 0 (${this.WindowCovering.On})`);
                 }
             }
             await this.setOn(Boolean(this.WindowCovering?.On));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Window Covering On: ${this.WindowCovering?.On}`);
+            await this.debugLog(`Window Covering On: ${this.WindowCovering?.On}`);
         }
         else if (this.botDeviceType === 'lock') {
             if (this.LockMechanism?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LockMechanism?.On}`);
+                await this.debugLog(`On: ${this.LockMechanism?.On}`);
             }
             else {
                 if (this.LockMechanism.On) {
                     this.LockMechanism.Service.updateCharacteristic(this.hap.Characteristic.LockTargetState, this.hap.Characteristic.LockTargetState.UNSECURED);
                     this.LockMechanism.Service.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.hap.Characteristic.LockCurrentState.UNSECURED);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristicc`
-                        + ` LockTargetState: UNSECURED, LockCurrentState: UNSECURED (${this.LockMechanism.On})`);
+                    await this.debugLog(`updateCharacteristicc LockTargetState: UNSECURED, LockCurrentState: UNSECURED (${this.LockMechanism.On})`);
                 }
                 else {
                     this.LockMechanism.Service.updateCharacteristic(this.hap.Characteristic.LockTargetState, this.hap.Characteristic.LockTargetState.SECURED);
                     this.LockMechanism.Service.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.hap.Characteristic.LockCurrentState.SECURED);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-                        + ` LockTargetState: SECURED, LockCurrentState: SECURED  (${this.LockMechanism.On})`);
+                    await this.debugLog(`updateCharacteristic LockTargetState: SECURED, LockCurrentState: SECURED  (${this.LockMechanism.On})`);
                 }
             }
             await this.setOn(Boolean(this.LockMechanism?.On));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Lock On: ${this.LockMechanism?.On}`);
+            await this.debugLog(`Lock On: ${this.LockMechanism?.On}`);
         }
         else if (this.botDeviceType === 'faucet') {
             if (this.Faucet?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.Faucet?.On}`);
+                await this.debugLog(`On: ${this.Faucet?.On}`);
             }
             else {
                 if (this.Faucet.On) {
                     this.Faucet.Service.updateCharacteristic(this.hap.Characteristic.Active, this.hap.Characteristic.Active.ACTIVE);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Faucet.On}`);
+                    await this.debugLog(`updateCharacteristic Active: ${this.Faucet.On}`);
                 }
                 else {
                     this.Faucet.Service.updateCharacteristic(this.hap.Characteristic.Active, this.hap.Characteristic.Active.INACTIVE);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Faucet.On}`);
+                    await this.debugLog(`updateCharacteristic Active: ${this.Faucet.On}`);
                 }
             }
             await this.setOn(Boolean(this.Faucet?.On));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Faucet On: ${this.Faucet?.On}`);
+            await this.debugLog(`Faucet On: ${this.Faucet?.On}`);
         }
         else if (this.botDeviceType === 'fan') {
             if (this.Fan?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.Fan?.On}`);
+                await this.debugLog(`On: ${this.Fan?.On}`);
             }
             else {
                 if (this.Fan.On) {
                     this.Fan.Service.updateCharacteristic(this.hap.Characteristic.On, this.Fan.On);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic On: ${this.Fan.On}`);
+                    await this.debugLog(`updateCharacteristic On: ${this.Fan.On}`);
                 }
                 else {
                     this.Fan.Service.updateCharacteristic(this.hap.Characteristic.On, this.Fan.On);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic On: ${this.Fan.On}`);
+                    await this.debugLog(`updateCharacteristic On: ${this.Fan.On}`);
                 }
             }
             await this.setOn(Boolean(this.Fan?.On));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Fan On: ${this.Fan?.On}`);
+            await this.debugLog(`Fan On: ${this.Fan?.On}`);
         }
         else if (this.botDeviceType === 'stateful') {
             if (this.StatefulProgrammableSwitch?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.StatefulProgrammableSwitch?.On}`);
+                await this.debugLog(`On: ${this.StatefulProgrammableSwitch?.On}`);
             }
             else {
                 if (this.StatefulProgrammableSwitch.On) {
                     this.StatefulProgrammableSwitch.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent, this.hap.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
                     this.StatefulProgrammableSwitch.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, 1);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-                        + ` ProgrammableSwitchEvent: SINGLE, ProgrammableSwitchOutputState: 1 (${this.StatefulProgrammableSwitch.On})`);
+                    await this.debugLog(`updateCharacteristic ProgrammableSwitchEvent: ProgrammableSwitchOutputState: (${this.StatefulProgrammableSwitch.On})`);
                 }
                 else {
                     this.StatefulProgrammableSwitch.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent, this.hap.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
                     this.StatefulProgrammableSwitch.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, 0);
-                    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-                        + ` ProgrammableSwitchEvent: SINGLE, ProgrammableSwitchOutputState: 0 (${this.StatefulProgrammableSwitch.On})`);
+                    await this.debugLog(`updateCharacteristic ProgrammableSwitchEvent: ProgrammableSwitchOutputState: (${this.StatefulProgrammableSwitch.On})`);
                 }
             }
             await this.setOn(Boolean(this.StatefulProgrammableSwitch?.On));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} StatefulProgrammableSwitch On: ${this.StatefulProgrammableSwitch?.On}`);
+            await this.debugLog(`StatefulProgrammableSwitch On: ${this.StatefulProgrammableSwitch?.On}`);
         }
         else if (this.botDeviceType === 'switch') {
             if (this.Switch?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.Switch?.On}`);
+                await this.debugLog(`On: ${this.Switch?.On}`);
             }
             else {
                 this.Switch.Service.updateCharacteristic(this.hap.Characteristic.On, this.Switch.On);
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic On: ${this.Switch.On}`);
+                await this.debugLog(`updateCharacteristic On: ${this.Switch.On}`);
             }
             await this.setOn(Boolean(this.Switch?.On));
         }
         else {
             if (this.Outlet?.On === undefined) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.Outlet?.On}`);
+                await this.debugLog(`On: ${this.Outlet?.On}`);
             }
             else {
                 this.Outlet.Service.updateCharacteristic(this.hap.Characteristic.On, this.Outlet.On);
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic On: ${this.Outlet.On}`);
+                await this.debugLog(`updateCharacteristic On: ${this.Outlet.On}`);
             }
             await this.setOn(Boolean(this.Outlet?.On));
         }
         this.accessory.context.On = await this.getOn();
         // BatteryLevel
         if (this.Battery.BatteryLevel === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel}`);
+            await 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);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic BatteryLevel: ${this.Battery.BatteryLevel}`);
+            await this.debugLog(`updateCharacteristic BatteryLevel: ${this.Battery.BatteryLevel}`);
         }
         // StatusLowBattery
         if (this.Battery.StatusLowBattery === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+            await 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);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-                + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+            await this.debugLog(`updateCharacteristic StatusLowBattery: ${this.Battery.StatusLowBattery}`);
         }
     }
     async removeOutletService(accessory) {
         // If outletService still present, then remove first
         if (this.Outlet?.Service) {
             this.Outlet.Service = this.accessory.getService(this.hap.Service.Outlet);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Outlet Service`);
+            await this.warnLog('Removing Leftover Outlet Service');
             accessory.removeService(this.Outlet.Service);
         }
     }
@@ -1095,7 +1074,7 @@ export class Bot extends deviceBase {
         // If garageDoorService still present, then remove first
         if (this.GarageDoor?.Service) {
             this.GarageDoor.Service = this.accessory.getService(this.hap.Service.GarageDoorOpener);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Garage Door Service`);
+            await this.warnLog('Removing Leftover Garage Door Service');
             accessory.removeService(this.GarageDoor.Service);
         }
     }
@@ -1103,7 +1082,7 @@ export class Bot extends deviceBase {
         // If doorService still present, then remove first
         if (this.Door?.Service) {
             this.Door.Service = this.accessory.getService(this.hap.Service.Door);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Door Service`);
+            await this.warnLog('Removing Leftover Door Service');
             accessory.removeService(this.Door.Service);
         }
     }
@@ -1111,7 +1090,7 @@ export class Bot extends deviceBase {
         // If lockService still present, then remove first
         if (this.LockMechanism?.Service) {
             this.LockMechanism.Service = this.accessory.getService(this.hap.Service.LockMechanism);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Lock Service`);
+            this.warnLog('Removing Leftover Lock Service');
             accessory.removeService(this.LockMechanism.Service);
         }
     }
@@ -1119,7 +1098,7 @@ export class Bot extends deviceBase {
         // If faucetService still present, then remove first
         if (this.Faucet?.Service) {
             this.Faucet.Service = this.accessory.getService(this.hap.Service.Faucet);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Faucet Service`);
+            await this.warnLog('Removing Leftover Faucet Service');
             accessory.removeService(this.Faucet.Service);
         }
     }
@@ -1127,7 +1106,7 @@ export class Bot extends deviceBase {
         // If fanService still present, then remove first
         if (this.Fan?.Service) {
             this.Fan.Service = this.accessory.getService(this.hap.Service.Fanv2);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Fan Service`);
+            this.warnLog('Removing Leftover Fan Service');
             accessory.removeService(this.Fan.Service);
         }
     }
@@ -1135,7 +1114,7 @@ export class Bot extends deviceBase {
         // If windowService still present, then remove first
         if (this.Window?.Service) {
             this.Window.Service = this.accessory.getService(this.hap.Service.Window);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Window Service`);
+            await this.warnLog('Removing Leftover Window Service');
             accessory.removeService(this.Window.Service);
         }
     }
@@ -1143,7 +1122,7 @@ export class Bot extends deviceBase {
         // If windowCoveringService still present, then remove first
         if (this.WindowCovering?.Service) {
             this.WindowCovering.Service = this.accessory.getService(this.hap.Service.WindowCovering);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Window Covering Service`);
+            await this.warnLog('Removing Leftover Window Covering Service');
             accessory.removeService(this.WindowCovering.Service);
         }
     }
@@ -1151,7 +1130,7 @@ export class Bot extends deviceBase {
         // If statefulProgrammableSwitchService still present, then remove first
         if (this.StatefulProgrammableSwitch?.Service) {
             this.StatefulProgrammableSwitch.Service = this.accessory.getService(this.hap.Service.StatefulProgrammableSwitch);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Stateful Programmable Switch Service`);
+            await this.warnLog('Removing Leftover Stateful Programmable Switch Service');
             accessory.removeService(this.StatefulProgrammableSwitch.Service);
         }
     }
@@ -1159,7 +1138,7 @@ export class Bot extends deviceBase {
         // If switchService still present, then remove first
         if (this.Switch?.Service) {
             this.Switch.Service = this.accessory.getService(this.hap.Service.Switch);
-            this.warnLog(`${this.device.deviceType}: ${accessory.displayName} Removing Leftover Switch Service`);
+            await this.warnLog('Removing Leftover Switch Service');
             accessory.removeService(this.Switch.Service);
         }
     }
@@ -1253,39 +1232,39 @@ export class Bot extends deviceBase {
         //Bot Device Type
         if (!device.bot?.deviceType && this.accessory.context.deviceType) {
             this.botDeviceType = this.accessory.context.deviceType;
-            this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Type: ${this.botDeviceType}, from Accessory Cache.`);
+            await this.debugWarnLog(`Using Device Type: ${this.botDeviceType}, from Accessory Cache.`);
         }
         else if (device.bot?.deviceType) {
             this.accessory.context.deviceType = device.bot.deviceType;
-            this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Accessory Cache: ${this.accessory.context.deviceType}`);
+            await this.debugWarnLog(`Accessory Cache: ${this.accessory.context.deviceType}`);
             this.botDeviceType = this.accessory.context.deviceType;
-            this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Type: ${this.botDeviceType}`);
+            await this.debugWarnLog(`Using Device Type: ${this.botDeviceType}`);
         }
         else {
             this.botDeviceType = 'outlet';
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} No Device Type Set, deviceType: ${this.device.bot?.deviceType}`);
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using default deviceType: ${this.botDeviceType}`);
+            await this.errorLog(`No Device Type Set, deviceType: ${this.device.bot?.deviceType}`);
+            await this.warnLog(`Using default deviceType: ${this.botDeviceType}`);
         }
         // Bot Mode
         if (!device.bot?.mode) {
             this.botMode = 'switch';
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} does not have bot mode set in the Plugin's SwitchBot Device Settings,`);
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} is defaulting to "${this.botMode}" mode, you may experience issues.`);
+            await this.warnLog('does not have bot mode set in the Plugin\'s SwitchBot Device Settings,');
+            await this.warnLog(`is defaulting to "${this.botMode}" mode, you may experience issues.`);
         }
         else if (device.bot?.mode === 'switch') {
             this.botMode = 'switch';
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Bot Mode: ${this.botMode}`);
+            await this.debugLog(`Using Bot Mode: ${this.botMode}`);
         }
         else if (device.bot?.mode === 'press') {
             this.botMode = 'press';
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Bot Mode: ${this.botMode}`);
+            await this.debugLog(`Using Bot Mode: ${this.botMode}`);
         }
         else if (device.bot?.mode === 'multipress') {
             this.botMode = 'multipress';
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Bot Mode: ${this.botMode}`);
+            await this.debugLog(`Using Bot Mode: ${this.botMode}`);
         }
         else {
-            throw new Error(`${this.device.deviceType}: ${this.accessory.displayName} Bot Mode: ${this.botMode}`);
+            throw new Error(`Bot Mode: ${this.botMode}`);
         }
         // Bot Double Press
         if (device.bot?.doublePress) {
@@ -1298,11 +1277,11 @@ export class Bot extends deviceBase {
         // Bot Press PushRate
         if (device?.bot?.pushRatePress) {
             this.pushRatePress = device?.bot?.pushRatePress;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Device Config Bot pushRatePress: ${this.pushRatePress}`);
+            await this.debugLog(`Using Device Config Bot pushRatePress: ${this.pushRatePress}`);
         }
         else {
             this.pushRatePress = 15;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Default Bot pushRatePress: ${this.pushRatePress}`);
+            await this.debugLog(`Using Default Bot pushRatePress: ${this.pushRatePress}`);
         }
         // Bot Allow Push
         if (device.bot?.allowPush) {
@@ -1311,21 +1290,20 @@ export class Bot extends deviceBase {
         else {
             this.allowPush = false;
         }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Allowing Push Changes: ${this.allowPush}`);
+        await this.debugLog(`Allowing Push Changes: ${this.allowPush}`);
         // Bot Multi Press Count
         this.multiPressCount = 0;
     }
     async BLEPushConnection() {
         if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+            await this.warnLog('Using OpenAPI Connection to Push Changes');
             await this.openAPIpushChanges();
         }
     }
     async BLERefreshConnection(switchbot) {
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot:`
-            + ` ${JSON.stringify(switchbot)}`);
+        await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${JSON.stringify(switchbot)}`);
         if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
+            await this.warnLog('Using OpenAPI Connection to Refresh Status');
             await this.openAPIRefreshStatus();
         }
     }