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

package/dist/device/device.js

@@ -6,7 +6,8 @@ import { hostname } from 'os';
 import { request } from 'undici';
 import asyncmqtt from 'async-mqtt';
 import { Devices } from '../settings.js';
-import { BlindTiltMappingMode, SwitchBotModel, SwitchBotBLEModel, SwitchBotBLEModelName, sleep } from '../utils.js';
+import { BlindTiltMappingMode, sleep } from '../utils.js';
+import { SwitchBotModel, SwitchBotBLEModel, SwitchBotBLEModelName, SwitchBotBLEModelFriendlyName } from 'node-switchbot';
 export class deviceBase {
     platform;
     accessory;
@@ -47,11 +48,11 @@ export class deviceBase {
         this.OpenAPI = this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'BLE/OpenAPI';
         this.getDeviceLogSettings(accessory, device);
         this.getDeviceRateSettings(accessory, device);
-        this.getDeviceRetry(accessory, device);
+        this.getDeviceRetry(device);
         this.getDeviceConfigSettings(accessory, device);
         this.getDeviceContext(accessory, device);
-        this.setupMqtt(accessory, device);
-        this.scan(accessory, device);
+        this.getDeviceScanDuration(accessory, device);
+        this.setupMqtt(device);
         // Set accessory information
         accessory
             .getService(this.hap.Service.AccessoryInformation)
@@ -66,82 +67,81 @@ export class deviceBase {
     async getDeviceLogSettings(accessory, device) {
         if (this.platform.debugMode) {
             this.deviceLogging = accessory.context.logging = 'debugMode';
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
+            this.debugWarnLog(`Using Debug Mode Logging: ${this.deviceLogging}`);
         }
         else if (device.logging) {
             this.deviceLogging = accessory.context.logging = device.logging;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
+            this.debugWarnLog(`Using Device Config Logging: ${this.deviceLogging}`);
         }
         else if (this.config.logging) {
             this.deviceLogging = accessory.context.logging = this.config.logging;
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
+            this.debugWarnLog(`Using Platform Config Logging: ${this.deviceLogging}`);
         }
         else {
             this.deviceLogging = accessory.context.logging = 'standard';
-            this.debugWarnLog(`${this.device.deviceType}: ${accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
+            this.debugWarnLog(`Logging Not Set, Using: ${this.deviceLogging}`);
         }
     }
     async getDeviceRateSettings(accessory, device) {
         // refreshRate
         if (device.refreshRate) {
             this.deviceRefreshRate = device.refreshRate;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Device Config refreshRate: ${this.deviceRefreshRate}`);
+            this.debugLog(`Using Device Config refreshRate: ${this.deviceRefreshRate}`);
         }
         else if (this.config.options?.refreshRate) {
             this.deviceRefreshRate = this.config.options.refreshRate;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Platform Config refreshRate: ${this.deviceRefreshRate}`);
+            this.debugLog(`Using Platform Config refreshRate: ${this.deviceRefreshRate}`);
         }
         else {
             this.deviceRefreshRate = 5;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Default refreshRate: ${this.deviceRefreshRate}`);
+            this.debugLog(`Using Default refreshRate: ${this.deviceRefreshRate}`);
         }
         accessory.context.deviceRefreshRate = this.deviceRefreshRate;
         // updateRate
         if (device.updateRate) {
             this.deviceUpdateRate = device.updateRate;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Device Config updateRate: ${this.deviceUpdateRate}`);
+            this.debugLog(`Using Device Config updateRate: ${this.deviceUpdateRate}`);
         }
         else if (this.config.options?.updateRate) {
             this.deviceUpdateRate = this.config.options.updateRate;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Platform Config updateRate: ${this.deviceUpdateRate}`);
+            this.debugLog(`Using Platform Config updateRate: ${this.deviceUpdateRate}`);
         }
         else {
             this.deviceUpdateRate = 5;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Default updateRate: ${this.deviceUpdateRate}`);
+            this.debugLog(`Using Default updateRate: ${this.deviceUpdateRate}`);
         }
         accessory.context.deviceUpdateRate = this.deviceUpdateRate;
         // pushRate
         if (device.pushRate) {
             this.devicePushRate = device.pushRate;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Device Config pushRate: ${this.deviceUpdateRate}`);
+            this.debugLog(`Using Device Config pushRate: ${this.deviceUpdateRate}`);
         }
         else if (this.config.options?.pushRate) {
             this.devicePushRate = this.config.options.pushRate;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Platform Config pushRate: ${this.deviceUpdateRate}`);
+            this.debugLog(`Using Platform Config pushRate: ${this.deviceUpdateRate}`);
         }
         else {
             this.devicePushRate = 1;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Default pushRate: ${this.deviceUpdateRate}`);
+            this.debugLog(`Using Default pushRate: ${this.deviceUpdateRate}`);
         }
         accessory.context.devicePushRate = this.devicePushRate;
     }
-    async getDeviceRetry(accessory, device) {
+    async getDeviceRetry(device) {
         if (device.maxRetries) {
             this.deviceMaxRetries = device.maxRetries;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Device Max Retries: ${this.deviceMaxRetries}`);
+            this.debugLog(`Using Device Max Retries: ${this.deviceMaxRetries}`);
         }
         else {
             this.deviceMaxRetries = 5; // Maximum number of retries
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Max Retries Not Set, Using: ${this.deviceMaxRetries}`);
+            this.debugLog(`Max Retries Not Set, Using: ${this.deviceMaxRetries}`);
         }
         if (device.delayBetweenRetries) {
             this.deviceDelayBetweenRetries = device.delayBetweenRetries * 1000;
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Device Delay Between Retries: ${this.deviceDelayBetweenRetries}`);
+            this.debugLog(`Using Device Delay Between Retries: ${this.deviceDelayBetweenRetries}`);
         }
         else {
             this.deviceDelayBetweenRetries = 3000; // Delay between retries in milliseconds
-            this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Delay Between Retries Not Set,`
-                + ` Using: ${this.deviceDelayBetweenRetries}`);
+            this.debugLog(`Delay Between Retries Not Set, Using: ${this.deviceDelayBetweenRetries}`);
         }
     }
     async retryBLE({ max, fn }) {
@@ -149,8 +149,8 @@ export class deviceBase {
             if (max === 0) {
                 throw e;
             }
-            this.infoLog(e);
-            this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Retrying`);
+            await this.warnLog(e);
+            await this.infoLog('Retrying');
             await sleep(1000);
             return this.retryBLE({ max: max - 1, fn });
         });
@@ -163,20 +163,19 @@ export class deviceBase {
             return 5;
         }
     }
-    async scan(accessory, device) {
+    async getDeviceScanDuration(accessory, device) {
         if (device.scanDuration) {
             if (this.deviceUpdateRate > device.scanDuration) {
                 this.scanDuration = this.deviceUpdateRate;
                 if (this.BLE) {
-                    this.warnLog(`${this.device.deviceType}: `
-                        + `${accessory.displayName} scanDuration is less than updateRate, overriding scanDuration with updateRate`);
+                    this.warnLog('scanDuration is less than updateRate, overriding scanDuration with updateRate');
                 }
             }
             else {
                 this.scanDuration = accessory.context.scanDuration = device.scanDuration;
             }
             if (this.BLE) {
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Device Config scanDuration: ${this.scanDuration}`);
+                this.debugLog(`Using Device Config scanDuration: ${this.scanDuration}`);
             }
         }
         else {
@@ -187,7 +186,7 @@ export class deviceBase {
                 this.scanDuration = accessory.context.scanDuration = 1;
             }
             if (this.BLE) {
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Using Default scanDuration: ${this.scanDuration}`);
+                this.debugLog(`Using Default scanDuration: ${this.scanDuration}`);
             }
         }
     }
@@ -294,14 +293,43 @@ export class deviceBase {
         }
         const config = Object.assign({}, deviceConfig, botConfig, curtainConfig, waterdetectorConfig, striplightConfig, plugConfig, iosensorConfig, meterConfig, humidifierConfig, hubConfig, lockConfig, ceilinglightConfig, colorbulbConfig, contactConfig, motionConfig, blindTiltConfig);
         if (Object.entries(config).length !== 0) {
-            this.debugSuccessLog(`${this.device.deviceType}: ${accessory.displayName} Config: ${JSON.stringify(config)}`);
+            this.debugSuccessLog(`Config: ${JSON.stringify(config)}`);
         }
     }
+    /**
+     * Get the current ambient light level based on the light level, set_minLux, set_maxLux, and spaceBetweenLevels.
+     * @param lightLevel: number
+     * @param set_minLux: number
+     * @param set_maxLux: number
+     * @param spaceBetweenLevels: number
+     * @returns CurrentAmbientLightLevel
+     */
+    async getLightLevel(lightLevel, set_minLux, set_maxLux, spaceBetweenLevels) {
+        const numberOfLevels = spaceBetweenLevels + 1;
+        this.debugLog(`LightLevel: ${lightLevel}, set_minLux: ${set_minLux}, set_maxLux: ${set_maxLux}, spaceBetweenLevels: ${spaceBetweenLevels},`
+            + ` numberOfLevels: ${numberOfLevels}`);
+        let CurrentAmbientLightLevel;
+        switch (lightLevel) {
+            case 1:
+                CurrentAmbientLightLevel = set_minLux;
+                this.debugLog(`LightLevel: ${lightLevel}, set_minLux: ${set_minLux}`);
+                break;
+            case numberOfLevels:
+                CurrentAmbientLightLevel = set_maxLux;
+                this.debugLog(`LightLevel: ${lightLevel}, set_maxLux: ${set_maxLux}`);
+                break;
+            default:
+                CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * (Number(lightLevel) - 1);
+                this.debugLog(`LightLevel: ${lightLevel}`);
+        }
+        this.debugLog(`CurrentAmbientLightLevel: ${CurrentAmbientLightLevel}`);
+        return CurrentAmbientLightLevel;
+    }
     /*
      * Publish MQTT message for topics of
      * 'homebridge-switchbot/${this.device.deviceType}/xx:xx:xx:xx:xx:xx'
      */
-    mqttPublish(message, topic) {
+    async mqttPublish(message, topic) {
         const mac = this.device.deviceId
             ?.toLowerCase()
             .match(/[\s\S]{1,2}/g)
@@ -318,25 +346,24 @@ export class deviceBase {
             mqttMessageTopic = '';
         }
         this.mqttClient?.publish(`homebridge-switchbot/${this.device.deviceType}/${mac}${mqttTopic}`, `${message}`, options);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-            + ` MQTT message: ${mqttMessageTopic}${message} options:${JSON.stringify(options)}`);
+        this.debugLog(`MQTT message: ${mqttMessageTopic}${message} options:${JSON.stringify(options)}`);
     }
     /*
      * Setup MQTT hadler if URL is specified.
      */
-    async setupMqtt(accessory, device) {
+    async setupMqtt(device) {
         if (device.mqttURL) {
             try {
                 const { connectAsync } = asyncmqtt;
                 this.mqttClient = await connectAsync(device.mqttURL, device.mqttOptions || {});
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} MQTT connection has been established successfully.`);
+                this.debugLog('MQTT connection has been established successfully.');
                 this.mqttClient.on('error', (e) => {
-                    this.errorLog(`${this.device.deviceType}: ${accessory.displayName} Failed to publish MQTT messages. ${e}`);
+                    this.errorLog(`Failed to publish MQTT messages. ${e}`);
                 });
             }
             catch (e) {
                 this.mqttClient = null;
-                this.errorLog(`${this.device.deviceType}: ${accessory.displayName} Failed to establish MQTT connection. ${e}`);
+                this.errorLog(`Failed to establish MQTT connection. ${e}`);
             }
         }
     }
@@ -357,7 +384,7 @@ export class deviceBase {
             : null;
     }
     async switchbotBLE() {
-        const switchbot = await this.platform.connectBLE();
+        const switchbot = await this.platform.connectBLE(this.accessory, this.device);
         // Convert to BLE Address
         await this.convertBLEAddress();
         await this.getCustomBLEAddress(switchbot);
@@ -368,23 +395,24 @@ export class deviceBase {
             .deviceId.match(/.{1,2}/g)
             .join(':')
             .toLowerCase();
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
+        this.debugLog(`BLE Address: ${this.device.bleMac}`);
     }
     async monitorAdvertisementPackets(switchbot) {
+        this.debugLog(`Scanning for ${this.device.bleModelName} devices...`);
         await switchbot.startScan({ model: this.device.bleModel, id: this.device.bleMac });
         // Set an event handler
         let serviceData = { model: this.device.bleModel, modelName: this.device.bleModelName };
         switchbot.onadvertisement = async (ad) => {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} ad: ${JSON.stringify(ad, null, '  ')}`);
+            this.warnLog(`ad: ${JSON.stringify(ad, null, '  ')}`);
             if (this.device.bleMac === ad.address && ad.serviceData.model === this.device.bleModel) {
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ${JSON.stringify(ad, null, '  ')}`);
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} address: ${ad.address}, model: ${ad.serviceData.model}`);
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
+                this.debugLog(`${JSON.stringify(ad, null, '  ')}`);
+                this.debugLog(`address: ${ad.address}, model: ${ad.serviceData.model}`);
+                this.debugLog(`serviceData: ${JSON.stringify(ad.serviceData)}`);
                 serviceData = ad.serviceData;
             }
             else {
                 serviceData = { model: '', modelName: '' };
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
+                this.debugLog(`serviceData: ${JSON.stringify(ad.serviceData)}`);
             }
         };
         // Wait 10 seconds
@@ -395,13 +423,13 @@ export class deviceBase {
     }
     async getCustomBLEAddress(switchbot) {
         if (this.device.customBLEaddress && this.deviceLogging.includes('debug')) {
-            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} customBLEaddress: ${this.device.customBLEaddress}`);
+            this.debugLog(`customBLEaddress: ${this.device.customBLEaddress}`);
             (async () => {
                 // Start to monitor advertisement packets
                 await switchbot.startScan({ model: this.device.bleModel });
                 // Set an event handler
                 switchbot.onadvertisement = async (ad) => {
-                    this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} ad: ${JSON.stringify(ad, null, '  ')}`);
+                    this.warnLog(`ad: ${JSON.stringify(ad, null, '  ')}`);
                 };
                 await sleep(10000);
                 // Stop to monitor
@@ -416,33 +444,43 @@ export class deviceBase {
             headers: this.platform.generateHeaders(),
         });
     }
-    async successfulPushChange(statusCode, deviceStatus, bodyChange) {
-        this.debugSuccessLog(`${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`);
-    }
-    async successfulRefreshStatus(statusCode, deviceStatus) {
-        this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-            + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
-    }
-    async statusCodes(statusCode, deviceStatus) {
-        this.statusCode(statusCode);
-        this.statusCode(deviceStatus.statusCode);
+    async deviceRefreshStatus() {
+        return await this.platform.retryRequest(this.deviceMaxRetries, this.deviceDelayBetweenRetries, `${Devices}/${this.device.deviceId}/status`, { headers: this.platform.generateHeaders() });
     }
-    async refreshStatusCodes(statusCode, deviceStatus) {
-        this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
-        this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
-        this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
+    async successfulStatusCodes(statusCode, deviceStatus) {
+        return (statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100);
     }
-    async pushStatusCodes(statusCode, deviceStatus) {
-        this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
-        this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
-        this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus body: ${JSON.stringify(deviceStatus.body)}`);
-        this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
+    /**
+    * Update the characteristic value and log the change.
+    *
+    * @param Service: Service
+    * @param Characteristic: Characteristic
+    * @param CharacteristicValue: CharacteristicValue | undefined
+    * @param CharacteristicName: string
+    * @param history: object
+    * @return: void
+    *
+    */
+    async updateCharacteristic(Service, Characteristic, CharacteristicValue, CharacteristicName, history) {
+        if (CharacteristicValue === undefined) {
+            this.debugLog(`${CharacteristicName}: ${CharacteristicValue}`);
+        }
+        else {
+            await this.mqtt(CharacteristicName, CharacteristicValue);
+            if (this.device.history) {
+                this.historyService?.addEntry(history);
+            }
+            Service.updateCharacteristic(Characteristic, CharacteristicValue);
+            this.debugLog(`updateCharacteristic ${CharacteristicName}: ${CharacteristicValue}`);
+            this.debugWarnLog(`context before: ${this.accessory.context[CharacteristicName]}`);
+            this.accessory.context[CharacteristicName] = CharacteristicValue;
+            this.debugWarnLog(`context after: ${this.accessory.context[CharacteristicName]}`);
+        }
     }
-    async deviceRefreshStatus() {
-        return await this.platform.retryRequest(this.deviceMaxRetries, this.deviceDelayBetweenRetries, `${Devices}/${this.device.deviceId}/status`, { headers: this.platform.generateHeaders() });
+    async mqtt(CharacteristicName, CharacteristicValue) {
+        if (this.device.mqttURL) {
+            this.mqttPublish(CharacteristicName, CharacteristicValue.toString());
+        }
     }
     async getDeviceContext(accessory, device) {
         // Set the accessory context
@@ -451,236 +489,241 @@ export class deviceBase {
                 device.model = SwitchBotModel.Humidifier;
                 device.bleModel = SwitchBotBLEModel.Humidifier;
                 device.bleModelName = SwitchBotBLEModelName.Humidifier;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Humidifier;
                 break;
             case 'Hub Mini':
                 device.model = SwitchBotModel.HubMini;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'Hub Plus':
                 device.model = SwitchBotModel.HubPlus;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'Hub 2':
                 device.model = SwitchBotModel.Hub2;
                 device.bleModel = SwitchBotBLEModel.Hub2;
                 device.bleModelName = SwitchBotBLEModelName.Hub2;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Hub2;
                 break;
             case 'Bot':
                 device.model = SwitchBotModel.Bot;
                 device.bleModel = SwitchBotBLEModel.Bot;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Bot;
                 break;
             case 'Meter':
                 device.model = SwitchBotModel.Meter;
                 device.bleModel = SwitchBotBLEModel.Meter;
                 device.bleModelName = SwitchBotBLEModelName.Meter;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Meter;
                 break;
             case 'MeterPlus':
                 device.model = SwitchBotModel.MeterPlusUS;
                 device.bleModel = SwitchBotBLEModel.MeterPlus;
                 device.bleModelName = SwitchBotBLEModelName.MeterPlus;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.MeterPlus;
                 break;
             case 'Meter Plus (JP)':
                 device.model = SwitchBotModel.MeterPlusJP;
                 device.bleModel = SwitchBotBLEModel.MeterPlus;
                 device.bleModelName = SwitchBotBLEModelName.MeterPlus;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.MeterPlus;
                 break;
             case 'WoIOSensor':
                 device.model = SwitchBotModel.OutdoorMeter;
                 device.bleModel = SwitchBotBLEModel.OutdoorMeter;
                 device.bleModelName = SwitchBotBLEModelName.OutdoorMeter;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.OutdoorMeter;
                 break;
             case 'Water Detector':
                 device.model = SwitchBotModel.WaterDetector;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'Motion Sensor':
                 device.model = SwitchBotModel.MotionSensor;
                 device.bleModel = SwitchBotBLEModel.MotionSensor;
                 device.bleModelName = SwitchBotBLEModelName.MotionSensor;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.MotionSensor;
                 break;
             case 'Contact Sensor':
                 device.model = SwitchBotModel.ContactSensor;
                 device.bleModel = SwitchBotBLEModel.ContactSensor;
                 device.bleModelName = SwitchBotBLEModelName.ContactSensor;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.ContactSensor;
                 break;
             case 'Curtain':
                 device.model = SwitchBotModel.Curtain;
                 device.bleModel = SwitchBotBLEModel.Curtain;
                 device.bleModelName = SwitchBotBLEModelName.Curtain;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Curtain;
                 break;
             case 'Curtain3':
                 device.model = SwitchBotModel.Curtain3;
                 device.bleModel = SwitchBotBLEModel.Curtain3;
                 device.bleModelName = SwitchBotBLEModelName.Curtain3;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Curtain3;
                 break;
             case 'Blind Tilt':
                 device.model = SwitchBotModel.BlindTilt;
                 device.bleModel = SwitchBotBLEModel.BlindTilt;
                 device.bleModelName = SwitchBotBLEModelName.BlindTilt;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.BlindTilt;
                 break;
             case 'Plug':
                 device.model = SwitchBotModel.Plug;
                 device.bleModel = SwitchBotBLEModel.PlugMiniUS;
                 device.bleModelName = SwitchBotBLEModelName.PlugMini;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.PlugMini;
                 break;
             case 'Plug Mini (US)':
                 device.model = SwitchBotModel.PlugMiniUS;
                 device.bleModel = SwitchBotBLEModel.PlugMiniUS;
                 device.bleModelName = SwitchBotBLEModelName.PlugMini;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.PlugMini;
                 break;
             case 'Plug Mini (JP)':
                 device.model = SwitchBotModel.PlugMiniJP;
                 device.bleModel = SwitchBotBLEModel.PlugMiniJP;
                 device.bleModelName = SwitchBotBLEModelName.PlugMini;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.PlugMini;
                 break;
             case 'Smart Lock':
                 device.model = SwitchBotModel.Lock;
                 device.bleModel = SwitchBotBLEModel.Lock;
                 device.bleModelName = SwitchBotBLEModelName.Lock;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Lock;
                 break;
             case 'Smart Lock Pro':
                 device.model = SwitchBotModel.LockPro;
-                device.bleModel = SwitchBotBLEModel.Lock;
-                device.bleModelName = SwitchBotBLEModelName.Lock;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModel = SwitchBotBLEModel.LockPro;
+                device.bleModelName = SwitchBotBLEModelName.LockPro;
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.LockPro;
                 break;
             case 'Color Bulb':
                 device.model = SwitchBotModel.ColorBulb;
                 device.bleModel = SwitchBotBLEModel.ColorBulb;
                 device.bleModelName = SwitchBotBLEModelName.ColorBulb;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.ColorBulb;
                 break;
             case 'K10+':
                 device.model = SwitchBotModel.K10;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'WoSweeper':
                 device.model = SwitchBotModel.WoSweeper;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'WoSweeperMini':
                 device.model = SwitchBotModel.WoSweeperMini;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'Robot Vacuum Cleaner S1':
                 device.model = SwitchBotModel.RobotVacuumCleanerS1;
                 device.bleModel = SwitchBotBLEModel.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'Robot Vacuum Cleaner S1 Plus':
                 device.model = SwitchBotModel.RobotVacuumCleanerS1Plus;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'Robot Vacuum Cleaner S10':
                 device.model = SwitchBotModel.RobotVacuumCleanerS10;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'Ceiling Light':
                 device.model = SwitchBotModel.CeilingLight;
                 device.bleModel = SwitchBotBLEModel.CeilingLight;
-                device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelName = SwitchBotBLEModelName.CeilingLight;
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.CeilingLight;
                 break;
             case 'Ceiling Light Pro':
                 device.model = SwitchBotModel.CeilingLightPro;
                 device.bleModel = SwitchBotBLEModel.CeilingLightPro;
-                device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelName = SwitchBotBLEModelName.CeilingLightPro;
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.CeilingLightPro;
                 break;
             case 'Strip Light':
                 device.model = SwitchBotModel.StripLight;
                 device.bleModel = SwitchBotBLEModel.StripLight;
                 device.bleModelName = SwitchBotBLEModelName.StripLight;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.StripLight;
                 break;
             case 'Indoor Cam':
                 device.model = SwitchBotModel.IndoorCam;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'Remote':
                 device.model = SwitchBotModel.Remote;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'remote with screen+':
                 device.model = SwitchBotModel.UniversalRemote;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             case 'Battery Circulator Fan':
                 device.model = SwitchBotModel.BatteryCirculatorFan;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
                 break;
             default:
                 device.model = SwitchBotModel.Unknown;
                 device.bleModel = SwitchBotBLEModel.Unknown;
                 device.bleModelName = SwitchBotBLEModelName.Unknown;
-                this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Model: ${device.model}, BLE Model: ${device.bleModel}`);
+                device.bleModelFriednlyName = SwitchBotBLEModelFriendlyName.Unknown;
         }
+        this.debugLog(`Model: ${device.model}, BLE Model: ${device.bleModel}, BLE Model Name: ${device.bleModelName}, `
+            + `BLE Model Friendly Name: ${device.bleModelFriednlyName}`);
         accessory.context.model = device.model;
+        accessory.context.bleModel = device.bleModel;
+        accessory.context.bleModelName = device.bleModelName;
+        accessory.context.bleModelFriednlyName = device.bleModelFriednlyName;
         // Firmware Version
         let deviceFirmwareVersion;
         if (device.firmware) {
             deviceFirmwareVersion = device.firmware;
-            this.debugSuccessLog(`${device.deviceType}: ${accessory.displayName} 1 FirmwareRevision: ${device.firmware}`);
+            this.debugSuccessLog(`1 FirmwareRevision: ${device.firmware}`);
         }
         else if (device.version) {
-            deviceFirmwareVersion = device.version;
-            this.debugSuccessLog(`${device.deviceType}: ${accessory.displayName} 2 FirmwareRevision: ${device.version}`);
+            deviceFirmwareVersion = JSON.stringify(device.version);
+            this.debugSuccessLog(`2 FirmwareRevision: ${device.version}`);
         }
         else if (accessory.context.deviceVersion) {
             deviceFirmwareVersion = accessory.context.deviceVersion;
-            this.debugSuccessLog(`${device.deviceType}: ${accessory.displayName} 3 FirmwareRevision: ${accessory.context.deviceVersion}`);
+            this.debugSuccessLog(`3 FirmwareRevision: ${accessory.context.deviceVersion}`);
         }
         else {
             deviceFirmwareVersion = this.platform.version ?? '0.0.0';
             if (this.platform.version) {
-                this.debugSuccessLog(`${device.deviceType}: ${accessory.displayName} 4 FirmwareRevision: ${this.platform.version}`);
+                this.debugSuccessLog(`4 FirmwareRevision: ${this.platform.version}`);
             }
             else {
-                this.debugSuccessLog(`${device.deviceType}: ${accessory.displayName} 5 FirmwareRevision: ${deviceFirmwareVersion}`);
+                this.debugSuccessLog(`5 FirmwareRevision: ${deviceFirmwareVersion}`);
             }
         }
         const version = deviceFirmwareVersion.toString();
-        this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Firmware Version: ${version?.replace(/^V|-.*$/g, '')}`);
+        this.debugLog(`Firmware Version: ${version.replace(/^V|-.*$/g, '')}`);
         let deviceVersion;
         if (version?.includes('.') === false) {
             const replace = version?.replace(/^V|-.*$/g, '');
@@ -689,7 +732,7 @@ export class deviceBase {
             deviceVersion = validVersion ?? '0.0.0';
         }
         else {
-            deviceVersion = version?.replace(/^V|-.*$/g, '') ?? '0.0.0';
+            deviceVersion = version.replace(/^V|-.*$/g, '') ?? '0.0.0';
         }
         accessory
             .getService(this.hap.Service.AccessoryInformation)
@@ -699,147 +742,135 @@ export class deviceBase {
             .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
             .updateValue(deviceVersion);
         accessory.context.deviceVersion = deviceVersion;
-        this.debugSuccessLog(`${device.deviceType}: ${accessory.displayName} deviceVersion: ${accessory.context.deviceVersion}`);
+        this.debugSuccessLog(`deviceVersion: ${accessory.context.deviceVersion}`);
     }
     async statusCode(statusCode) {
         if (statusCode === 171) {
             const previousStatusCode = statusCode;
             if (this.device.hubDeviceId === this.device.deviceId) {
                 statusCode = 161;
-                this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${previousStatusCode} is now statusCode: `
-                    + `${statusCode}, because the hubDeviceId: ${this.device.hubDeviceId} is set to the same as the deviceId: `
-                    + `${this.device.deviceId}, meaning the device is it's own hub.`);
             }
             if (this.device.hubDeviceId === '000000000000') {
                 statusCode = 161;
-                this.debugErrorLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${previousStatusCode} is now statusCode: `
-                    + `${statusCode}, because the hubDeviceId: ${this.device.hubDeviceId} is set to the same as the deviceId: `
-                    + `${this.device.deviceId}, meaning the device is it's own hub.`);
             }
+            this.debugErrorLog(`statusCode: ${previousStatusCode} is now statusCode: ${statusCode}, because the hubDeviceId: ${this.device.hubDeviceId}`
+                + ` is set to the same as the deviceId: ${this.device.deviceId}, meaning the device is it's own hub.`);
         }
         switch (statusCode) {
             case 151:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Command not supported by this deviceType, statusCode: ${statusCode}`);
+                this.errorLog(`Command not supported by this deviceType, statusCode: ${statusCode}`);
                 break;
             case 152:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Device not found, statusCode: ${statusCode}`);
+                this.errorLog(`Device not found, statusCode: ${statusCode}`);
                 break;
             case 160:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Command is not supported, statusCode: ${statusCode}`);
+                this.errorLog(`Command is not supported, statusCode: ${statusCode}`);
                 break;
             case 161:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Device is offline, statusCode: ${statusCode}`);
+                this.errorLog(`Device is offline, statusCode: ${statusCode}`);
                 break;
             case 171:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Hub Device is offline, statusCode: ${statusCode}. `
-                    + `Hub: ${this.device.hubDeviceId}`);
+                this.errorLog(`Hub Device is offline, statusCode: ${statusCode}. Hub: ${this.device.hubDeviceId}`);
                 break;
             case 190:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Device internal error due to device states not synchronized with`
-                    + ` server, Or command format is invalid, statusCode: ${statusCode}`);
+                this.errorLog('Device internal error due to device states not synchronized with server, or command format is invalid,'
+                    + ` statusCode: ${statusCode}`);
                 break;
             case 100:
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Command successfully sent, statusCode: ${statusCode}`);
+                this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
                 break;
             case 200:
-                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Request successful, statusCode: ${statusCode}`);
+                this.debugLog(`Request successful, statusCode: ${statusCode}`);
                 break;
             case 400:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Bad Request, The client has issued an invalid request. `
-                    + `This is commonly used to specify validation errors in a request payload, statusCode: ${statusCode}`);
+                this.errorLog(`Bad Request, an invalid payload request, statusCode: ${statusCode}`);
                 break;
             case 401:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Unauthorized,	Authorization for the API is required, `
-                    + `but the request has not been authenticated, statusCode: ${statusCode}`);
+                this.errorLog(`Unauthorized, Authorization for the API is required, but the request has not been authenticated, statusCode: ${statusCode}`);
                 break;
             case 403:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Forbidden,	The request has been authenticated but does not `
-                    + `have appropriate permissions, or a requested resource is not found, statusCode: ${statusCode}`);
+                this.errorLog('Forbidden,	The request has been authenticated but does not have appropriate permissions,'
+                    + ` or a requested resource is not found, statusCode: ${statusCode}`);
                 break;
             case 404:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Not Found,	Specifies the requested path does not exist, `
-                    + `statusCode: ${statusCode}`);
+                this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
                 break;
             case 406:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Not Acceptable,	The client has requested a MIME type via `
-                    + `the Accept header for a value not supported by the server, statusCode: ${statusCode}`);
+                this.errorLog('Not Acceptable, a MIME type has been requested via the Accept header for a value not supported by the server,'
+                    + ` statusCode: ${statusCode}`);
                 break;
             case 415:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Unsupported Media Type,	The client has defined a contentType `
-                    + `header that is not supported by the server, statusCode: ${statusCode}`);
+                this.errorLog(`Unsupported Media Type, a contentType header has been defined that is not supported by the server, statusCode: ${statusCode}`);
                 break;
             case 422:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Unprocessable Entity,	The client has made a valid request, `
-                    + `but the server cannot process it. This is often used for APIs for which certain limits have been exceeded, statusCode: ${statusCode}`);
+                this.errorLog('Unprocessable Entity, a valid request has been made, but the server cannot process it. '
+                    + `This is often used for APIs for which certain limits have been exceeded, statusCode: ${statusCode}`);
                 break;
             case 429:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Too Many Requests,	The client has exceeded the number of `
-                    + `requests allowed for a given time window, statusCode: ${statusCode}`);
+                this.errorLog(`Too Many Requests,	exceeded the number of requests allowed for a given time window, statusCode: ${statusCode}`);
                 break;
             case 500:
-                this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Internal Server Error,	An unexpected error on the SmartThings `
-                    + `servers has occurred. These errors should be rare, statusCode: ${statusCode}`);
+                this.errorLog(`Internal Server Error,	An unexpected error occurred. These errors should be rare, statusCode: ${statusCode}`);
                 break;
             default:
-                this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Unknown statusCode: `
-                    + `${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
+                this.infoLog(`Unknown statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
         }
     }
     /**
      * Logging for Device
      */
-    infoLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.log.info(String(...log));
+    async infoLog(...log) {
+        if (await this.enablingDeviceLogging()) {
+            this.log.info(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
         }
     }
-    successLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.log.success(String(...log));
+    async successLog(...log) {
+        if (await this.enablingDeviceLogging()) {
+            this.log.success(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
         }
     }
-    debugSuccessLog(...log) {
-        if (this.enablingDeviceLogging()) {
+    async debugSuccessLog(...log) {
+        if (await this.enablingDeviceLogging()) {
             if (this.deviceLogging?.includes('debug')) {
-                this.log.success('[DEBUG]', String(...log));
+                this.log.success(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
             }
         }
     }
-    warnLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.log.warn(String(...log));
+    async warnLog(...log) {
+        if (await this.enablingDeviceLogging()) {
+            this.log.warn(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
         }
     }
-    debugWarnLog(...log) {
-        if (this.enablingDeviceLogging()) {
+    async debugWarnLog(...log) {
+        if (await this.enablingDeviceLogging()) {
             if (this.deviceLogging?.includes('debug')) {
-                this.log.warn('[DEBUG]', String(...log));
+                this.log.warn(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
             }
         }
     }
-    errorLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.log.error(String(...log));
+    async errorLog(...log) {
+        if (await this.enablingDeviceLogging()) {
+            this.log.error(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
         }
     }
-    debugErrorLog(...log) {
-        if (this.enablingDeviceLogging()) {
+    async debugErrorLog(...log) {
+        if (await this.enablingDeviceLogging()) {
             if (this.deviceLogging?.includes('debug')) {
-                this.log.error('[DEBUG]', String(...log));
+                this.log.error(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
             }
         }
     }
-    debugLog(...log) {
-        if (this.enablingDeviceLogging()) {
+    async debugLog(...log) {
+        if (await this.enablingDeviceLogging()) {
             if (this.deviceLogging === 'debug') {
-                this.log.info('[DEBUG]', String(...log));
+                this.log.info(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
             }
             else {
-                this.log.debug(String(...log));
+                this.log.debug(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
             }
         }
     }
-    enablingDeviceLogging() {
+    async enablingDeviceLogging() {
         return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
     }
 }