@switchbot/homebridge-switchbot 3.5.1-beta.0 → 3.5.1-beta.10

package/dist/device/colorbulb.js

@@ -3,9 +3,9 @@
  * blindtilt.ts: @switchbot/homebridge-switchbot.
  */
 import { deviceBase } from './device.js';
-import { interval, Subject } from 'rxjs';
 import { hs2rgb, rgb2hs, m2hs } from '../utils.js';
-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
@@ -46,7 +46,7 @@ export class ColorBulb extends deviceBase {
             accessory.removeService(this.LightBulb.Service);
             this.LightBulb.Service = accessory.addService(this.hap.Service.Lightbulb);
             accessory.context.adaptiveLighting = false;
-            this.debugLog(`${device.deviceType}: ${accessory.displayName} adaptiveLighting: ${accessory.context.adaptiveLighting}`);
+            this.debugLog(`adaptiveLighting: ${accessory.context.adaptiveLighting}`);
         }
         if (this.adaptiveLightingShift !== -1) {
             this.AdaptiveLightingController = new platform.api.hap.AdaptiveLightingController(this.LightBulb.Service, {
@@ -115,14 +115,14 @@ export class ColorBulb extends deviceBase {
         this.refreshStatus();
         // Update Homekit
         this.updateHomeKitCharacteristics();
+        //regisiter webhook event handler
+        this.registerWebhook();
         // Start an update interval
         interval(this.deviceRefreshRate * 1000)
             .pipe(skipWhile(() => this.colorBulbUpdateInProgress))
             .subscribe(async () => {
             await this.refreshStatus();
         });
-        //regisiter webhook event handler
-        this.registerWebhook(accessory, device);
         // Watch for Bulb change events
         // We put in a debounce of 100ms so we don't make duplicate calls
         this.doColorBulbUpdate
@@ -134,9 +134,8 @@ export class ColorBulb extends deviceBase {
                 await this.pushChanges();
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType} Connection,`
-                    + ` Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushChanges with ${device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
             this.colorBulbUpdateInProgress = false;
         });
@@ -145,86 +144,59 @@ export class ColorBulb extends deviceBase {
      * Parse the device status from the SwitchBotBLE API
      */
     async BLEparseStatus(serviceData) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEparseStatus`);
-        // State
-        switch (serviceData.power) {
-            case true:
-                this.LightBulb.On = true;
-                break;
-            default:
-                this.LightBulb.On = false;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LightBulb.On}`);
+        await this.debugLog('BLEparseStatus');
+        // On
+        this.LightBulb.On = serviceData.power;
+        await this.debugLog(`On: ${this.LightBulb.On}`);
         // Brightness
-        this.LightBulb.Brightness = Number(serviceData.brightness);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
+        this.LightBulb.Brightness = serviceData.brightness;
+        await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
         // Color, Hue & Brightness
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} red: ${serviceData.red}`);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} green: ${serviceData.green}`);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} blue: ${serviceData.blue}`);
-        const [hue, saturation] = rgb2hs(Number(serviceData.red), Number(serviceData.green), Number(serviceData.blue));
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-            + ` hs: ${JSON.stringify(rgb2hs(Number(serviceData.red), Number(serviceData.green), Number(serviceData.blue)))}`);
+        await this.debugLog(`red: ${serviceData.red}, green: ${serviceData.green}, blue: ${serviceData.blue}`);
+        const [hue, saturation] = rgb2hs(serviceData.red, serviceData.green, serviceData.blue);
+        await this.debugLog(`hs: ${JSON.stringify(rgb2hs(serviceData.red, serviceData.green, serviceData.blue))}`);
         // Hue
         this.LightBulb.Hue = hue;
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${this.LightBulb.Hue}`);
+        await this.debugLog(`Hue: ${this.LightBulb.Hue}`);
         // Saturation
         this.LightBulb.Saturation = saturation;
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${this.LightBulb.Saturation}`);
+        await this.debugLog(`Saturation: ${this.LightBulb.Saturation}`);
         // ColorTemperature
-        if (serviceData.color_temperature) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${serviceData.color_temperature}`);
-            this.LightBulb.ColorTemperature = serviceData.color_temperature;
-            this.LightBulb.ColorTemperature = Math.max(Math.min(this.LightBulb.ColorTemperature, 500), 140);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-        }
+        this.LightBulb.ColorTemperature = Math.max(Math.min(serviceData.color_temperature, 500), 140);
+        await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
     }
     /**
      * Parse the device status from the SwitchBot OpenAPI
      */
     async openAPIparseStatus(deviceStatus) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIparseStatus`);
-        switch (deviceStatus.body.power) {
-            case 'on':
-                this.LightBulb.On = true;
-                break;
-            default:
-                this.LightBulb.On = false;
-        }
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LightBulb.On}`);
+        await this.debugLog('openAPIparseStatus');
+        // On
+        this.LightBulb.On = deviceStatus.power === 'on' ? true : false;
+        await this.debugLog(`On: ${this.LightBulb.On}`);
         // Brightness
-        this.LightBulb.Brightness = Number(deviceStatus.body.brightness);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
+        this.LightBulb.Brightness = deviceStatus.brightness;
+        await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
         // Color, Hue & Brightness
-        if (deviceStatus.body.color) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} color: ${JSON.stringify(deviceStatus.body.color)}`);
-            const [red, green, blue] = deviceStatus.body.color.split(':');
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} red: ${JSON.stringify(red)}`);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} green: ${JSON.stringify(green)}`);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} blue: ${JSON.stringify(blue)}`);
-            const [hue, saturation] = rgb2hs(Number(red), Number(green), Number(blue));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-                + ` hs: ${JSON.stringify(rgb2hs(Number(red), Number(green), Number(blue)))}`);
-            // Hue
-            this.LightBulb.Hue = hue;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${this.LightBulb.Hue}`);
-            // Saturation
-            this.LightBulb.Saturation = saturation;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${this.LightBulb.Saturation}`);
-        }
+        await this.debugLog(`color: ${JSON.stringify(deviceStatus.color)}`);
+        const [red, green, blue] = deviceStatus.color.split(':');
+        await this.debugLog(`red: ${JSON.stringify(red)}, green: ${JSON.stringify(green)}, blue: ${JSON.stringify(blue)}`);
+        const [hue, saturation] = rgb2hs(red, green, blue);
+        await this.debugLog(`hs: ${JSON.stringify(rgb2hs(red, green, blue))}`);
+        // Hue
+        this.LightBulb.Hue = hue;
+        await this.debugLog(`Hue: ${this.LightBulb.Hue}`);
+        // Saturation
+        this.LightBulb.Saturation = saturation;
+        await this.debugLog(`Saturation: ${this.LightBulb.Saturation}`);
         // ColorTemperature
-        if (!Number.isNaN(deviceStatus.body.colorTemperature)) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${deviceStatus.body.colorTemperature}`);
-            const mired = Math.round(1000000 / deviceStatus.body.colorTemperature);
-            this.LightBulb.ColorTemperature = Number(mired);
-            this.LightBulb.ColorTemperature = Math.max(Math.min(this.LightBulb.ColorTemperature, 500), 140);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-        }
+        const miredColorTemperature = Math.round(1000000 / deviceStatus.colorTemperature);
+        this.LightBulb.ColorTemperature = Math.max(Math.min(miredColorTemperature, 500), 140);
+        await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
         // 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();
+        await 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)
@@ -232,15 +204,42 @@ export class ColorBulb extends deviceBase {
                 .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
                 .updateValue(deviceVersion);
             this.accessory.context.deviceVersion = deviceVersion;
-            this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceVersion: ${this.accessory.context.deviceVersion}`);
+            await this.debugSuccessLog(`deviceVersion: ${this.accessory.context.deviceVersion}`);
         }
     }
+    async parseStatusWebhook(context) {
+        await this.debugLog('parseStatusWebhook');
+        await this.debugLog(`(powerState, brightness, color, colorTemperature) = Webhook:(${context.powerState}, ${context.brightness}, ${context.color},`
+            + ` ${context.colorTemperature}), current:(${this.LightBulb.On}, ${this.LightBulb.Brightness}, ${this.LightBulb.Hue},`
+            + ` ${this.LightBulb.Saturation}, ${this.LightBulb.ColorTemperature})`);
+        // On
+        this.LightBulb.On = context.powerState === 'ON' ? true : false;
+        await this.debugLog(`On: ${this.LightBulb.On}`);
+        // Brightness
+        this.LightBulb.Brightness = context.brightness;
+        await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
+        // Color, Hue & Brightness
+        await this.debugLog(`color: ${JSON.stringify(context.color)}`);
+        const [red, green, blue] = context.color.split(':');
+        await this.debugLog(`red: ${JSON.stringify(red)}, green: ${JSON.stringify(green)}, blue: ${JSON.stringify(blue)}`);
+        const [hue, saturation] = rgb2hs(red, green, blue);
+        await this.debugLog(`hs: ${JSON.stringify(rgb2hs(red, green, blue))}`);
+        // Hue
+        this.LightBulb.Hue = hue;
+        await this.debugLog(`Hue: ${this.LightBulb.Hue}`);
+        // Saturation
+        this.LightBulb.Saturation = saturation;
+        await this.debugLog(`Saturation: ${this.LightBulb.Saturation}`);
+        // ColorTemperature
+        this.LightBulb.ColorTemperature = context.colorTemperature;
+        await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+    }
     /**
      * 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();
@@ -250,12 +249,11 @@ export class ColorBulb 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);
@@ -266,108 +264,55 @@ export class ColorBulb extends deviceBase {
                 // Start to monitor advertisement packets
                 const serviceData = await this.monitorAdvertisementPackets(switchbot);
                 // Update HomeKit
-                if (serviceData.model !== '' && serviceData.modelName !== '') {
+                if (serviceData.model === SwitchBotBLEModel.ColorBulb && serviceData.modelName === SwitchBotBLEModelName.ColorBulb) {
                     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) {
-            this.apiError(e);
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-                + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+            await this.apiError(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 { powerState, brightness, color, colorTemperature } = context;
-                    const { On, Brightness, Hue, Saturation, ColorTemperature } = this.LightBulb;
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} ` +
-                        '(powerState, brightness, color, colorTemperature) = ' +
-                        `Webhook:(${powerState}, ${brightness}, ${color}, ${colorTemperature}), `
-                        + `current:(${On}, ${Brightness}, ${Hue}, ${Saturation}, ${ColorTemperature})`);
-                    // On
-                    this.LightBulb.On = powerState === 'ON' ? true : false;
-                    if (accessory.context.Brightness !== this.LightBulb.On) {
-                        this.infoLog(`${device.deviceType}: ${accessory.displayName} On: ${this.LightBulb.On}`);
-                    }
-                    else {
-                        this.debugLog(`${device.deviceType}: ${accessory.displayName} On: ${this.LightBulb.On}`);
-                    }
-                    // Brightness
-                    this.LightBulb.Brightness = brightness;
-                    if (accessory.context.Brightness !== this.LightBulb.Brightness) {
-                        this.infoLog(`${device.deviceType}: ${accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
-                    }
-                    else {
-                        this.debugLog(`${device.deviceType}: ${accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
-                    }
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} color: ${JSON.stringify(color)}`);
-                    const [red, green, blue] = color.split(':');
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} red: ${JSON.stringify(red)}`);
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} green: ${JSON.stringify(green)}`);
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName} blue: ${JSON.stringify(blue)}`);
-                    const [hue, saturation] = rgb2hs(Number(red), Number(green), Number(blue));
-                    this.debugLog(`${device.deviceType}: ${accessory.displayName}`
-                        + ` hs: ${JSON.stringify(rgb2hs(Number(red), Number(green), Number(blue)))}`);
-                    // Hue
-                    this.LightBulb.Hue = hue;
-                    if (accessory.context.Hue !== this.LightBulb.Hue) {
-                        this.infoLog(`${device.deviceType}: ${accessory.displayName} Hue: ${this.LightBulb.Hue}`);
-                    }
-                    else {
-                        this.debugLog(`${device.deviceType}: ${accessory.displayName} Hue: ${this.LightBulb.Hue}`);
-                    }
-                    // Saturation
-                    this.LightBulb.Saturation = saturation;
-                    if (accessory.context.Saturation !== this.LightBulb.Saturation) {
-                        this.infoLog(`${device.deviceType}: ${accessory.displayName} Saturation: ${this.LightBulb.Saturation}`);
-                    }
-                    else {
-                        this.debugLog(`${device.deviceType}: ${accessory.displayName} Saturation: ${this.LightBulb.Saturation}`);
-                    }
-                    this.LightBulb.ColorTemperature = colorTemperature;
-                    if (accessory.context.ColorTemperature !== this.LightBulb.ColorTemperature) {
-                        this.infoLog(`${device.deviceType}: ${accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-                    }
-                    else {
-                        this.debugLog(`${device.deviceType}: ${accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-                    }
-                    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.debugWarnLog(`${device.deviceType}: ${accessory.displayName} is not listening webhook.`);
+            await this.debugLog('is not listening webhook.');
         }
     }
     /**
@@ -383,18 +328,45 @@ export class ColorBulb 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();
+            if (this.LightBulb.On) {
+                // Push Brightness Update
+                await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
+                await this.BLEpushBrightnessChanges();
+                // Push ColorTemperature Update
+                await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+                await this.BLEpushColorTemperatureChanges();
+                // Push Hue & Saturation Update
+                await this.debugLog(`Hue: ${this.LightBulb.Hue}, Saturation: ${this.LightBulb.Saturation}`);
+                await this.BLEpushRGBChanges();
+            }
+            else {
+                await this.debugLog('BLE (Brightness), (ColorTemperature), (Hue), & (Saturation) changes will not happen, as the device is OFF.');
+            }
         }
         else if (this.OpenAPI && this.platform.config.credentials?.token) {
             await this.openAPIpushChanges();
+            if (this.LightBulb.On) {
+                // Push Brightness Update
+                await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
+                await this.pushBrightnessChanges();
+                // Push ColorTemperature Update
+                await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+                await this.pushColorTemperatureChanges();
+                // Push Hue & Saturation Update
+                await this.debugLog(`Hue: ${this.LightBulb.Hue}, Saturation: ${this.LightBulb.Saturation}`);
+                await this.pushHueSaturationChanges();
+            }
+            else {
+                await this.debugLog('openAPI (Brightness), (ColorTemperature), (Hue), & (Saturation) changes will not happen, as the device is OFF.');
+            }
         }
         else {
             await this.offlineOff();
-            this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-                + ` ${this.device.connectionType}, pushChanges will not happen.`);
+            await this.debugWarnLog(`Connection Type: ${this.device.connectionType}, pushChanges will not happen.`);
         }
         // Refresh the status from the API
         interval(15000)
@@ -405,242 +377,218 @@ export class ColorBulb extends deviceBase {
         });
     }
     async BLEpushChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushChanges`);
+        await this.debugLog('BLEpushChanges');
         if (this.LightBulb.On !== this.accessory.context.On) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushChanges`
-                + ` On: ${this.LightBulb.On}, OnCached: ${this.accessory.context.On}`);
-            const switchbot = await this.platform.connectBLE();
-            // Convert to BLE Address
+            await this.debugLog(`BLEpushChanges On: ${this.LightBulb.On}, OnCached: ${this.accessory.context.On}`);
+            const switchbot = await this.platform.connectBLE(this.accessory, this.device);
             await this.convertBLEAddress();
-            switchbot
-                .discover({ model: this.device.bleModel, id: this.device.bleMac })
-                .then(async (device_list) => {
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LightBulb.On}`);
-                return await this.retryBLE({
-                    max: await this.maxRetryBLE(),
-                    fn: async () => {
-                        if (this.LightBulb.On) {
-                            return await device_list[0].turnOn({ id: this.device.bleMac });
-                        }
-                        else {
-                            return await device_list[0].turnOff({ id: this.device.bleMac });
-                        }
-                    },
+            if (switchbot !== false) {
+                switchbot
+                    .discover({ model: this.device.bleModel, id: this.device.bleMac })
+                    .then(async (device_list) => {
+                    await this.infoLog(`On: ${this.LightBulb.On}`);
+                    return await this.retryBLE({
+                        max: await this.maxRetryBLE(),
+                        fn: async () => {
+                            if (this.LightBulb.On) {
+                                return await device_list[0].turnOn({ id: this.device.bleMac });
+                            }
+                            else {
+                                return await device_list[0].turnOff({ id: this.device.bleMac });
+                            }
+                        },
+                    });
+                })
+                    .then(async () => {
+                    await this.successLog(`On: ${this.LightBulb.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)}`);
+                    await this.BLEPushConnection();
                 });
-            })
-                .then(() => {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
-                this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                    + `On: ${this.LightBulb.On} sent over BLE,  sent successfully`);
-                this.LightBulb.On = false;
-            })
-                .catch(async (e) => {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
-                await this.BLEPushConnection();
-            });
-            // Push Brightness Update
-            if (this.LightBulb.On) {
-                await this.BLEpushBrightnessChanges();
             }
-            // Push ColorTemperature Update
-            if (this.LightBulb.On) {
-                await this.BLEpushColorTemperatureChanges();
-            }
-            // Push Hue & Saturation Update
-            if (this.LightBulb.On) {
-                await this.BLEpushRGBChanges();
+            else {
+                await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
+                await this.BLEPushConnection();
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No BLEpushChanges, On: ${this.LightBulb.On},`
-                + ` OnCached: ${this.accessory.context.On}`);
+            await this.debugLog(`No changes (BLEpushChanges), On: ${this.LightBulb.On}, OnCached: ${this.accessory.context.On}`);
         }
     }
     async BLEpushBrightnessChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushBrightnessChanges`);
+        await this.debugLog('BLEpushBrightnessChanges');
         if (this.LightBulb.Brightness !== this.accessory.context.Brightness) {
-            const switchbot = await this.platform.connectBLE();
-            // Convert to BLE Address
+            const switchbot = await this.platform.connectBLE(this.accessory, this.device);
             await this.convertBLEAddress();
-            switchbot
-                .discover({ model: this.device.bleModel, id: this.device.bleMac })
-                .then(async (device_list) => {
-                this.infoLog(`${this.accessory.displayName} Target Brightness: ${this.LightBulb.Brightness}`);
-                return await device_list[0].setBrightness(this.LightBulb.Brightness);
-            })
-                .then(() => {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
-                this.LightBulb.On = false;
-            })
-                .catch(async (e) => {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushBrightnessChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+            if (switchbot !== false) {
+                switchbot
+                    .discover({ model: this.device.bleModel, id: this.device.bleMac })
+                    .then(async (device_list) => {
+                    await this.infoLog(`${this.accessory.displayName} Target Brightness: ${this.LightBulb.Brightness}`);
+                    return await device_list[0].setBrightness(this.LightBulb.Brightness);
+                })
+                    .then(async () => {
+                    await this.successLog(`Brightness: ${this.LightBulb.Brightness} sent over SwitchBot BLE,  sent successfully`);
+                    await this.updateHomeKitCharacteristics();
+                })
+                    .catch(async (e) => {
+                    await this.apiError(e);
+                    await this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
+                    await this.BLEPushConnection();
+                });
+            }
+            else {
+                await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
                 await this.BLEPushConnection();
-            });
+            }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No BLEpushBrightnessChanges.`
-                + `Brightness: ${this.LightBulb.Brightness}, BrightnessCached: ${this.accessory.context.Brightness}`);
+            await this.debugLog(`No changes (BLEpushBrightnessChanges), Brightness: ${this.LightBulb.Brightness},`
+                + ` BrightnessCached: ${this.accessory.context.Brightness}`);
         }
     }
     async BLEpushColorTemperatureChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushColorTemperatureChanges`);
+        await this.debugLog('BLEpushColorTemperatureChanges');
         if (this.LightBulb.ColorTemperature !== this.accessory.context.ColorTemperature) {
-            const switchbot = await this.platform.connectBLE();
-            // Convert to BLE Address
+            const switchbot = await this.platform.connectBLE(this.accessory, this.device);
             await this.convertBLEAddress();
-            switchbot
-                .discover({ model: this.device.bleModel, id: this.device.bleMac })
-                .then(async (device_list) => {
-                this.infoLog(`${this.accessory.displayName} Target ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-                return await device_list[0].setColorTemperature(this.LightBulb.ColorTemperature);
-            })
-                .then(() => {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
-                this.LightBulb.On = false;
-            })
-                .catch(async (e) => {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushColorTemperatureChanges with `
-                    + `${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
+            if (switchbot !== false) {
+                switchbot
+                    .discover({ model: this.device.bleModel, id: this.device.bleMac })
+                    .then(async (device_list) => {
+                    await this.infoLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+                    return await device_list[0].setColorTemperature(this.LightBulb.ColorTemperature);
+                })
+                    .then(async () => {
+                    await this.successLog(`ColorTemperature: ${this.LightBulb.ColorTemperature} sent over SwitchBot BLE,  sent successfully`);
+                    await this.updateHomeKitCharacteristics();
+                })
+                    .catch(async (e) => {
+                    await this.apiError(e);
+                    await this.errorLog(`failed BLEpushRGBChanges with ${this.device.connectionType} Connection,`
+                        + ` Error Message: ${JSON.stringify(e.message)}`);
+                    await this.BLEPushConnection();
+                });
+            }
+            else {
+                await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
                 await this.BLEPushConnection();
-            });
+            }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No BLEpushColorTemperatureChanges.`
-                + `ColorTemperature: ${this.LightBulb.ColorTemperature}, ColorTemperatureCached: ${this.accessory.context.ColorTemperature}`);
+            await this.debugLog(`No changes (BLEpushColorTemperatureChanges), ColorTemperature: ${this.LightBulb.ColorTemperature},`
+                + ` ColorTemperatureCached: ${this.accessory.context.ColorTemperature}`);
         }
     }
     async BLEpushRGBChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEpushRGBChanges`);
-        if (this.LightBulb.Hue !== this.accessory.context.Hue || this.LightBulb.Saturation !== this.accessory.context.Saturation) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${JSON.stringify(this.LightBulb.Hue)}`);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${JSON.stringify(this.LightBulb.Saturation)}`);
-            const [red, green, blue] = hs2rgb(Number(this.LightBulb.Hue), Number(this.LightBulb.Saturation));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} rgb: ${JSON.stringify([red, green, blue])}`);
-            const switchbot = await this.platform.connectBLE();
-            // Convert to BLE Address
+        await this.debugLog('BLEpushRGBChanges');
+        if ((this.LightBulb.Hue !== this.accessory.context.Hue) || (this.LightBulb.Saturation !== this.accessory.context.Saturation)) {
+            await this.debugLog(`Hue: ${JSON.stringify(this.LightBulb.Hue)}, Saturation: ${JSON.stringify(this.LightBulb.Saturation)}`);
+            const [red, green, blue] = hs2rgb(this.LightBulb.Hue, this.LightBulb.Saturation);
+            await this.debugLog(`rgb: ${JSON.stringify([red, green, blue])}`);
+            const switchbot = await this.platform.connectBLE(this.accessory, this.device);
             await this.convertBLEAddress();
-            switchbot
-                .discover({ model: this.device.bleModel, id: this.device.bleMac })
-                .then(async (device_list) => {
-                this.infoLog(`${this.accessory.displayName} Target RGB: ${(this.LightBulb.Brightness, red, green, blue)}`);
-                return await device_list[0].setRGB(this.LightBulb.Brightness, red, green, blue);
-            })
-                .then(() => {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
-                this.LightBulb.On = false;
-            })
-                .catch(async (e) => {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushRGBChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+            if (switchbot !== false) {
+                switchbot
+                    .discover({ model: this.device.bleModel, id: this.device.bleMac })
+                    .then(async (device_list) => {
+                    await this.infoLog(`RGB: ${(this.LightBulb.Brightness, red, green, blue)}`);
+                    return await device_list[0].setRGB(this.LightBulb.Brightness, red, green, blue);
+                })
+                    .then(async () => {
+                    await this.successLog(`RGB: ${(this.LightBulb.Brightness, red, green, blue)} sent over SwitchBot BLE,  sent successfully`);
+                    await this.updateHomeKitCharacteristics();
+                })
+                    .catch(async (e) => {
+                    await this.apiError(e);
+                    await this.errorLog(`failed BLEpushRGBChanges with ${this.device.connectionType} Connection,`
+                        + ` Error Message: ${JSON.stringify(e.message)}`);
+                    await this.BLEPushConnection();
+                });
+            }
+            else {
+                await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
                 await this.BLEPushConnection();
-            });
+            }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No BLEpushRGBChanges. Hue: ${this.LightBulb.Hue}, HueCached: `
-                + `${this.accessory.context.Hue}, Saturation: ${this.LightBulb.Saturation}, SaturationCached: ${this.accessory.context.Saturation}`);
+            await this.debugLog(`No changes (BLEpushRGBChanges), Hue: ${this.LightBulb.Hue}, HueCached: ${this.accessory.context.Hue},`
+                + ` Saturation: ${this.LightBulb.Saturation}, SaturationCached: ${this.accessory.context.Saturation}`);
         }
     }
     async openAPIpushChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIpushChanges`);
+        await this.debugLog('openAPIpushChanges');
         if (this.LightBulb.On !== this.accessory.context.On) {
-            let command = '';
-            if (this.LightBulb.On) {
-                command = 'turnOn';
-            }
-            else {
-                command = 'turnOff';
-            }
+            const command = this.LightBulb.On ? 'turnOn' : 'turnOff';
             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},`);
+            await this.debugLog(`SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
-                    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `request to SwitchBot API, body: ${JSON.stringify(JSON.parse(bodyChange))} sent successfully`);
+                await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                    await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    this.statusCode(statusCode);
-                    this.statusCode(deviceStatus.statusCode);
+                    await this.statusCode(statusCode);
+                    await this.statusCode(deviceStatus.statusCode);
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIpushChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed openAPIpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No openAPIpushChanges,`
-                + `On: ${this.LightBulb.On}, OnCached: ${this.accessory.context.On}`);
-        }
-        // Push Hue & Saturation Update
-        if (this.LightBulb.On) {
-            await this.pushHueSaturationChanges();
-        }
-        // Push ColorTemperature Update
-        if (this.LightBulb.On) {
-            await this.pushColorTemperatureChanges();
-        }
-        // Push Brightness Update
-        if (this.LightBulb.On) {
-            await this.pushBrightnessChanges();
+            await this.debugLog(`No changes (openAPIpushChanges), On: ${this.LightBulb.On}, OnCached: ${this.accessory.context.On}`);
         }
     }
     async pushHueSaturationChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushHueSaturationChanges`);
-        if (this.LightBulb.Hue !== this.accessory.context.Hue || this.LightBulb.Saturation !== this.accessory.context.Saturation) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${JSON.stringify(this.LightBulb.Hue)}`);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${JSON.stringify(this.LightBulb.Saturation)}`);
-            const [red, green, blue] = hs2rgb(Number(this.LightBulb.Hue), Number(this.LightBulb.Saturation));
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} rgb: ${JSON.stringify([red, green, blue])}`);
+        await this.debugLog('pushHueSaturationChanges');
+        if ((this.LightBulb.Hue !== this.accessory.context.Hue) || (this.LightBulb.Saturation !== this.accessory.context.Saturation)) {
+            await this.debugLog(`Hue: ${JSON.stringify(this.LightBulb.Hue)}, Saturation: ${JSON.stringify(this.LightBulb.Saturation)}`);
+            const [red, green, blue] = hs2rgb(this.LightBulb.Hue, this.LightBulb.Saturation);
+            await this.debugLog(`rgb: ${JSON.stringify([red, green, blue])}`);
             const bodyChange = JSON.stringify({
                 command: 'setColor',
                 parameter: `${red}:${green}:${blue}`,
                 commandType: 'command',
             });
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+            await this.debugLog(`SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
-                    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `request to SwitchBot API, body: ${JSON.stringify(JSON.parse(bodyChange))} sent successfully`);
+                await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                    await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    this.statusCode(statusCode);
-                    this.statusCode(deviceStatus.statusCode);
+                    await this.statusCode(statusCode);
+                    await this.statusCode(deviceStatus.statusCode);
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushHueSaturationChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushHueSaturationChanges with ${this.device.connectionType} Connection,`
+                    + ` Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No pushHueSaturationChanges. Hue: ${this.LightBulb.Hue}, HueCached: `
-                + `${this.accessory.context.Hue}, Saturation: ${this.LightBulb.Saturation}, SaturationCached: ${this.accessory.context.Saturation}`);
+            await this.debugLog(`No changes (pushHueSaturationChanges), Hue: ${this.LightBulb.Hue}, HueCached: ${this.accessory.context.Hue},`
+                + ` Saturation: ${this.LightBulb.Saturation}, SaturationCached: ${this.accessory.context.Saturation}`);
         }
     }
     async pushColorTemperatureChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushColorTemperatureChanges`);
+        await this.debugLog('pushColorTemperatureChanges');
         if (this.LightBulb.ColorTemperature !== this.accessory.context.ColorTemperature) {
             const kelvin = Math.round(1000000 / Number(this.LightBulb.ColorTemperature));
             this.accessory.context.kelvin = kelvin;
@@ -649,77 +597,73 @@ export class ColorBulb extends deviceBase {
                 parameter: `${kelvin}`,
                 commandType: 'command',
             });
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+            await this.debugLog(`SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
-                    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `request to SwitchBot API, body: ${JSON.stringify(JSON.parse(bodyChange))} sent successfully`);
+                await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                    await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    this.statusCode(statusCode);
-                    this.statusCode(deviceStatus.statusCode);
+                    await this.statusCode(statusCode);
+                    await this.statusCode(deviceStatus.statusCode);
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushColorTemperatureChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushColorTemperatureChanges with ${this.device.connectionType} Connection,`
+                    + ` Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No pushColorTemperatureChanges.`
-                + `ColorTemperature: ${this.LightBulb.ColorTemperature}, ColorTemperatureCached: ${this.accessory.context.ColorTemperature}`);
+            await this.debugLog(`No changes (pushColorTemperatureChanges), ColorTemperature: ${this.LightBulb.ColorTemperature},`
+                + ` ColorTemperatureCached: ${this.accessory.context.ColorTemperature}`);
         }
     }
     async pushBrightnessChanges() {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushBrightnessChanges`);
+        await this.debugLog('pushBrightnessChanges');
         if (this.LightBulb.Brightness !== this.accessory.context.Brightness) {
             const bodyChange = JSON.stringify({
                 command: 'setBrightness',
                 parameter: `${this.LightBulb.Brightness}`,
                 commandType: 'command',
             });
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+            await this.debugLog(`SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
             try {
                 const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                await this.pushStatusCodes(statusCode, deviceStatus);
-                if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
-                    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-                        + `request to SwitchBot API, body: ${JSON.stringify(JSON.parse(bodyChange))} sent successfully`);
+                await this.debugLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                if (await this.successfulStatusCodes(statusCode, deviceStatus)) {
+                    await this.debugSuccessLog(`statusCode: ${statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
+                    await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    this.statusCode(statusCode);
-                    this.statusCode(deviceStatus.statusCode);
+                    await this.statusCode(statusCode);
+                    await this.statusCode(deviceStatus.statusCode);
                 }
             }
             catch (e) {
-                this.apiError(e);
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushBrightnessChanges with ${this.device.connectionType}`
-                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                await this.apiError(e);
+                await this.errorLog(`failed pushBrightnessChanges with ${this.device.connectionType} Connection,`
+                    + ` Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No pushBrightnessChanges.`
-                + `Brightness: ${this.LightBulb.Brightness}, BrightnessCached: ${this.accessory.context.Brightness}`);
+            await this.debugLog(`No changes (pushBrightnessChanges), Brightness: ${this.LightBulb.Brightness},`
+                + ` BrightnessCached: ${this.accessory.context.Brightness}`);
         }
     }
     /**
      * Handle requests to set the value of the "On" characteristic
      */
     async OnSet(value) {
-        if (this.LightBulb.On === this.accessory.context.On) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set On: ${value}`);
+        if (this.LightBulb.On !== this.accessory.context.On) {
+            await this.infoLog(`Set On: ${value}`);
         }
         else {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set On: ${value}`);
+            await this.debugLog(`No Changes, On: ${value}`);
         }
         this.LightBulb.On = value;
         this.doColorBulbUpdate.next();
@@ -728,14 +672,16 @@ export class ColorBulb extends deviceBase {
      * Handle requests to set the value of the "Brightness" characteristic
      */
     async BrightnessSet(value) {
-        if (this.LightBulb.Brightness === this.accessory.context.Brightness) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set Brightness: ${value}`);
-        }
-        else if (this.LightBulb.On) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Brightness: ${value}`);
+        if (this.LightBulb.On && (this.LightBulb.Brightness !== this.accessory.context.Brightness)) {
+            await this.infoLog(`Set Brightness: ${value}`);
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Brightness: ${value}`);
+            if (this.LightBulb.On) {
+                this.debugLog(`No Changes, Brightness: ${value}`);
+            }
+            else {
+                this.debugLog(`Brightness: ${value}, On: ${this.LightBulb.On}`);
+            }
         }
         this.LightBulb.Brightness = value;
         this.doColorBulbUpdate.next();
@@ -744,14 +690,16 @@ export class ColorBulb extends deviceBase {
      * Handle requests to set the value of the "ColorTemperature" characteristic
      */
     async ColorTemperatureSet(value) {
-        if (this.LightBulb.ColorTemperature === this.accessory.context.ColorTemperature) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set ColorTemperature: ${value}`);
-        }
-        else if (this.LightBulb.On) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set ColorTemperature: ${value}`);
+        if (this.LightBulb.On && (this.LightBulb.ColorTemperature !== this.accessory.context.ColorTemperature)) {
+            this.infoLog(`Set ColorTemperature: ${value}`);
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Set ColorTemperature: ${value}`);
+            if (this.LightBulb.On) {
+                this.debugLog(`No Changes, ColorTemperature: ${value}`);
+            }
+            else {
+                this.debugLog(`Set ColorTemperature: ${value}, On: ${this.LightBulb.On}`);
+            }
         }
         const minKelvin = 2000;
         const maxKelvin = 9000;
@@ -773,14 +721,16 @@ export class ColorBulb extends deviceBase {
      * Handle requests to set the value of the "Hue" characteristic
      */
     async HueSet(value) {
-        if (this.LightBulb.Hue === this.accessory.context.Hue) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set Hue: ${value}`);
-        }
-        else if (this.LightBulb.On) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Hue: ${value}`);
+        if (this.LightBulb.On && (this.LightBulb.Hue !== this.accessory.context.Hue)) {
+            this.infoLog(`Set Hue: ${value}`);
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Hue: ${value}`);
+            if (this.LightBulb.On) {
+                this.debugLog(`No Changes, Hue: ${value}`);
+            }
+            else {
+                this.debugLog(`Set Hue: ${value}, On: ${this.LightBulb.On}`);
+            }
         }
         this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.ColorTemperature, 140);
         this.LightBulb.Hue = value;
@@ -790,14 +740,16 @@ export class ColorBulb extends deviceBase {
      * Handle requests to set the value of the "Saturation" characteristic
      */
     async SaturationSet(value) {
-        if (this.LightBulb.Saturation === this.accessory.context.Saturation) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set Saturation: ${value}`);
-        }
-        else if (this.LightBulb.On) {
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Saturation: ${value}`);
+        if (this.LightBulb.On && (this.LightBulb.Saturation !== this.accessory.context.Saturation)) {
+            this.infoLog(`Set Saturation: ${value}`);
         }
         else {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Saturation: ${value}`);
+            if (this.LightBulb.On) {
+                this.debugLog(`No Changes, Saturation: ${value}`);
+            }
+            else {
+                this.debugLog(`Set Saturation: ${value}, On: ${this.LightBulb.On}`);
+            }
         }
         this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.ColorTemperature, 140);
         this.LightBulb.Saturation = value;
@@ -805,73 +757,35 @@ export class ColorBulb extends deviceBase {
     }
     async updateHomeKitCharacteristics() {
         // On
-        if (this.LightBulb.On === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LightBulb.On}`);
-        }
-        else {
-            this.accessory.context.On = this.LightBulb.On;
-            this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.On, this.LightBulb.On);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic On: ${this.LightBulb.On}`);
-        }
+        await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.On, this.LightBulb.On, 'On');
         // Brightness
-        if (this.LightBulb.Brightness === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
-        }
-        else {
-            this.accessory.context.Brightness = this.LightBulb.Brightness;
-            this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Brightness, this.LightBulb.Brightness);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Brightness: ${this.LightBulb.Brightness}`);
-        }
+        await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Brightness, this.LightBulb.Brightness, 'Brightness');
         // ColorTemperature
-        if (this.LightBulb.ColorTemperature === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-        }
-        else {
-            this.accessory.context.ColorTemperature = this.LightBulb.ColorTemperature;
-            this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.ColorTemperature, this.LightBulb.ColorTemperature);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-                + ` ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-        }
+        await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.ColorTemperature, this.LightBulb.ColorTemperature, 'ColorTemperature');
         // Hue
-        if (this.LightBulb.Hue === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${this.LightBulb.Hue}`);
-        }
-        else {
-            this.accessory.context.Hue = this.LightBulb.Hue;
-            this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Hue, this.LightBulb.Hue);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Hue: ${this.LightBulb.Hue}`);
-        }
+        await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Hue, this.LightBulb.Hue, 'Hue');
         // Saturation
-        if (this.LightBulb.Saturation === undefined) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${this.LightBulb.Saturation}`);
-        }
-        else {
-            this.accessory.context.Saturation = this.LightBulb.Saturation;
-            this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Saturation, this.LightBulb.Saturation);
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Saturation: ${this.LightBulb.Saturation}`);
-        }
+        await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Saturation, this.LightBulb.Saturation, 'Saturation');
     }
     async adaptiveLighting(device) {
         if (device.colorbulb?.adaptiveLightingShift) {
             this.adaptiveLightingShift = device.colorbulb.adaptiveLightingShift;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
         }
         else {
             this.adaptiveLightingShift = 0;
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} adaptiveLightingShift: ${this.adaptiveLightingShift}`);
         }
+        await this.debugLog(`adaptiveLightingShift: ${this.adaptiveLightingShift}`);
     }
     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();
         }
     }
@@ -880,7 +794,7 @@ export class ColorBulb extends deviceBase {
             this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.On, false);
         }
     }
-    apiError(e) {
+    async apiError(e) {
         this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.On, e);
         this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Hue, e);
         this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Brightness, e);