@switchbot/homebridge-switchbot 1.15.0 → 1.15.1-beta.0

package/src/device/colorbulb.ts

@@ -3,7 +3,20 @@ import { interval, Subject } from 'rxjs';
 import { SwitchBotPlatform } from '../platform';
 import { debounceTime, skipWhile, tap } from 'rxjs/operators';
 import { Service, PlatformAccessory, CharacteristicValue, ControllerConstructor, Controller, ControllerServiceMap } from 'homebridge';
-import { DeviceURL, device, devicesConfig, switchbot, deviceStatusResponse, payload, hs2rgb, rgb2hs, m2hs, deviceStatus } from '../settings';
+import {
+  DeviceURL,
+  device,
+  devicesConfig,
+  switchbot,
+  deviceStatusResponse,
+  payload,
+  hs2rgb,
+  rgb2hs,
+  m2hs,
+  deviceStatus,
+  serviceData,
+  ad,
+} from '../settings';
 import { Context } from 'vm';
 
 /**
@@ -35,10 +48,18 @@ export class ColorBulb {
   deviceStatus!: deviceStatusResponse;
 
   // BLE Others
+  connected?: boolean;
   switchbot!: switchbot;
+  address!: ad['address'];
+  SwitchToOpenAPI?: boolean;
+  serviceData!: serviceData;
+  state: serviceData['state'];
+  delay: serviceData['delay'];
+  wifiRssi: serviceData['wifiRssi'];
 
   // Config
   set_minStep?: number;
+  scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
   adaptiveLightingShift?: number;
@@ -86,7 +107,8 @@ export class ColorBulb {
       .setCharacteristic(this.platform.Characteristic.Model, 'W1401400')
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!)
       .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.FirmwareRevision(accessory, device))
-      .getCharacteristic(this.platform.Characteristic.FirmwareRevision).updateValue(this.FirmwareRevision(accessory, device));
+      .getCharacteristic(this.platform.Characteristic.FirmwareRevision)
+      .updateValue(this.FirmwareRevision(accessory, device));
 
     // get the Lightbulb service if it exists, otherwise create a new Lightbulb service
     // you can create multiple services for each accessory
@@ -212,6 +234,27 @@ export class ColorBulb {
   }
 
   async parseStatus(): Promise<void> {
+    if (this.SwitchToOpenAPI || !this.device.ble) {
+      await this.openAPIparseStatus();
+    } else {
+      await this.BLEparseStatus();
+    }
+  }
+
+  async BLEparseStatus(): Promise<void> {
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} BLE parseStatus`);
+    // State
+    switch (this.state) {
+      case 'on':
+        this.On = true;
+        break;
+      default:
+        this.On = false;
+    }
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} On: ${this.On}`);
+  }
+
+  async openAPIparseStatus() {
     switch (this.power) {
       case 'on':
         this.On = true;
@@ -234,9 +277,7 @@ export class ColorBulb {
       this.debugLog(`Color Bulb: ${this.accessory.displayName} blue: ${JSON.stringify(blue)}`);
 
       const [hue, saturation] = rgb2hs(Number(red), Number(green), Number(blue));
-      this.debugLog(
-        `Color Bulb: ${this.accessory.displayName} hs: ${JSON.stringify(rgb2hs(Number(red), Number(green), Number(blue)))}`,
-      );
+      this.debugLog(`Color Bulb: ${this.accessory.displayName} hs: ${JSON.stringify(rgb2hs(Number(red), Number(green), Number(blue)))}`);
 
       // Hue
       this.Hue = hue;
@@ -257,10 +298,126 @@ export class ColorBulb {
       this.ColorTemperature = Math.max(Math.min(this.ColorTemperature, 500), 140);
       this.debugLog(`Color Bulb: ${this.accessory.displayName} ColorTemperature: ${this.ColorTemperature}`);
     }
-
   }
 
   async refreshStatus(): Promise<void> {
+    if (this.device.ble) {
+      await this.BLERefreshStatus();
+    } else {
+      await this.openAPIRefreshStatus();
+    }
+  }
+
+  async BLERefreshStatus(): Promise<void> {
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} BLE refreshStatus`);
+    const switchbot = await this.platform.connectBLE();
+    // Convert to BLE Address
+    this.device.bleMac = this.device
+      .deviceId!.match(/.{1,2}/g)!
+      .join(':')
+      .toLowerCase();
+    this.debugLog(`Color Bulb: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
+    this.getCustomBLEAddress(switchbot);
+    // Start to monitor advertisement packets
+    if (switchbot !== false) {
+      switchbot
+        .startScan({
+          model: 'u',
+          id: this.device.bleMac,
+        })
+        .then(() => {
+          // Set an event hander
+          switchbot.onadvertisement = (ad: any) => {
+            this.address = ad.address;
+            if (this.deviceLogging.includes('debug')) {
+              this.infoLog(this.address);
+              this.infoLog(this.device.bleMac);
+              this.infoLog(`Color Bulb: ${this.accessory.displayName} BLE Address Found: ${this.address}`);
+              this.infoLog(`Color Bulb: ${this.accessory.displayName} Config BLE Address: ${this.device.bleMac}`);
+            }
+            this.serviceData = ad.serviceData;
+            this.state = ad.serviceData.state;
+            this.delay = ad.serviceData.delay;
+            //this.timer = ad.serviceData.timer;
+            //this.syncUtcTime = ad.serviceData.syncUtcTime;
+            this.wifiRssi = ad.serviceData.wifiRssi;
+            //this.overload = ad.serviceData.overload;
+            //this.currentPower = ad.serviceData.currentPower;
+            this.debugLog(`Color Bulb: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
+            this.debugLog(
+              `Color Bulb: ${this.accessory.displayName} state: ${ad.serviceData.state}, ` +
+                `delay: ${ad.serviceData.delay}, timer: ${ad.serviceData.timer}, syncUtcTime: ${ad.serviceData.syncUtcTime} ` +
+                `wifiRssi: ${ad.serviceData.wifiRssi}, overload: ${ad.serviceData.overload}, currentPower: ${ad.serviceData.currentPower}`,
+            );
+
+            if (this.serviceData) {
+              this.connected = true;
+              this.debugLog(`Color Bulb: ${this.accessory.displayName} connected: ${this.connected}`);
+            } else {
+              this.connected = false;
+              this.debugLog(`Color Bulb: ${this.accessory.displayName} connected: ${this.connected}`);
+            }
+          };
+          // Wait 2 seconds
+          return switchbot.wait(this.scanDuration * 1000);
+        })
+        .then(async () => {
+          // Stop to monitor
+          switchbot.stopScan();
+          if (this.connected) {
+            this.parseStatus();
+            this.updateHomeKitCharacteristics();
+          } else {
+            await this.BLEconnection(switchbot);
+          }
+        })
+        .catch(async (e: any) => {
+          this.errorLog(`Color Bulb: ${this.accessory.displayName} failed refreshStatus with BLE Connection`);
+          if (this.deviceLogging.includes('debug')) {
+            this.errorLog(
+              `Color Bulb: ${this.accessory.displayName} failed refreshStatus with BLE Connection,` + ` Error Message: ${JSON.stringify(e.message)}`,
+            );
+          }
+          if (this.platform.config.credentials?.openToken) {
+            this.warnLog(`Color Bulb: ${this.accessory.displayName} Using OpenAPI Connection`);
+            this.SwitchToOpenAPI = true;
+            await this.openAPIRefreshStatus();
+          }
+          this.apiError(e);
+        });
+    } else {
+      await this.BLEconnection(switchbot);
+    }
+  }
+
+  async getCustomBLEAddress(switchbot: any) {
+    if (this.device.customBLEaddress && this.deviceLogging.includes('debug')) {
+      (async () => {
+        // Start to monitor advertisement packets
+        await switchbot.startScan({
+          model: 'u',
+        });
+        // Set an event handler
+        switchbot.onadvertisement = (ad: any) => {
+          this.warnLog(JSON.stringify(ad, null, '  '));
+        };
+        await switchbot.wait(10000);
+        // Stop to monitor
+        switchbot.stopScan();
+      })();
+    }
+  }
+
+  async BLEconnection(switchbot: any): Promise<void> {
+    this.errorLog(`Color Bulb: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
+    if (this.platform.config.credentials?.openToken) {
+      this.warnLog(`Color Bulb: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.SwitchToOpenAPI = true;
+      await this.openAPIRefreshStatus();
+    }
+  }
+
+  private async openAPIRefreshStatus() {
     try {
       this.deviceStatus = (await this.platform.axios.get(`${DeviceURL}/${this.device.deviceId}/status`)).data;
       this.debugLog(`Color Bulb: ${this.accessory.displayName} refreshStatus: ${JSON.stringify(this.deviceStatus)}`);
@@ -275,8 +432,7 @@ export class ColorBulb {
       this.errorLog(`Color Bulb: ${this.accessory.displayName} failed refreshStatus with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `Color Bulb: ${this.accessory.displayName} failed refreshStatus with OpenAPI Connection,` +
-            ` Error Message: ${JSON.stringify(e.message)}`,
+          `Color Bulb: ${this.accessory.displayName} failed refreshStatus with OpenAPI Connection,` + ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
       this.apiError(e);
@@ -339,8 +495,7 @@ export class ColorBulb {
       this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
-            ` Error Message: ${JSON.stringify(e.message)}`,
+          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` + ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
       this.apiError(e);
@@ -383,8 +538,7 @@ export class ColorBulb {
       this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
-            ` Error Message: ${JSON.stringify(e.message)}`,
+          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` + ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
       this.apiError(e);
@@ -423,8 +577,7 @@ export class ColorBulb {
       this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
-            ` Error Message: ${JSON.stringify(e.message)}`,
+          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` + ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
       this.apiError(e);
@@ -452,16 +605,14 @@ export class ColorBulb {
         this.BrightnessCached = this.Brightness;
       } else {
         this.debugLog(
-          `Color Bulb: ${this.accessory.displayName} No Changes.` +
-            `Brightness: ${this.Brightness}, BrightnessCached: ${this.BrightnessCached}`,
+          `Color Bulb: ${this.accessory.displayName} No Changes.` + `Brightness: ${this.Brightness}, BrightnessCached: ${this.BrightnessCached}`,
         );
       }
     } catch (e: any) {
       this.errorLog(`Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
       if (this.deviceLogging.includes('debug')) {
         this.errorLog(
-          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` +
-            ` Error Message: ${JSON.stringify(e.message)}`,
+          `Color Bulb: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection,` + ` Error Message: ${JSON.stringify(e.message)}`,
         );
       }
       this.apiError(e);

package/src/device/contact.ts

@@ -74,7 +74,8 @@ export class Contact {
       .setCharacteristic(this.platform.Characteristic.Model, 'W1201500')
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!)
       .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.FirmwareRevision(accessory, device))
-      .getCharacteristic(this.platform.Characteristic.FirmwareRevision).updateValue(this.FirmwareRevision(accessory, device));
+      .getCharacteristic(this.platform.Characteristic.FirmwareRevision)
+      .updateValue(this.FirmwareRevision(accessory, device));
 
     // get the Contact service if it exists, otherwise create a new Contact service
     // you can create multiple services for each accessory
@@ -265,10 +266,12 @@ export class Contact {
     this.debugLog(`Contact Sensor: ${this.accessory.displayName} BLE refreshStatus`);
     const switchbot = await this.platform.connectBLE();
     // Convert to BLE Address
-    this.device.bleMac = this.device.customBLEaddress || this.device
-      .deviceId!.match(/.{1,2}/g)!
-      .join(':')
-      .toLowerCase();
+    this.device.bleMac =
+      this.device.customBLEaddress ||
+      this.device
+        .deviceId!.match(/.{1,2}/g)!
+        .join(':')
+        .toLowerCase();
     this.debugLog(`Contact Sensor: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
     this.getCustomBLEAddress(switchbot);
     // Start to monitor advertisement packets
@@ -296,7 +299,7 @@ export class Contact {
             this.debugLog(`Contact Sensor: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
             this.debugLog(
               `Contact Sensor: ${this.accessory.displayName} movement: ${ad.serviceData.movement}, doorState: ` +
-                  `${ad.serviceData.doorState}, lightLevel: ${ad.serviceData.lightLevel}, battery: ${ad.serviceData.battery}`,
+                `${ad.serviceData.doorState}, lightLevel: ${ad.serviceData.lightLevel}, battery: ${ad.serviceData.battery}`,
             );
 
             if (this.serviceData) {

package/src/device/curtain.ts

@@ -90,7 +90,8 @@ export class Curtain {
       .setCharacteristic(this.platform.Characteristic.Model, 'W0701600')
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId)
       .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.FirmwareRevision(accessory, device))
-      .getCharacteristic(this.platform.Characteristic.FirmwareRevision).updateValue(this.FirmwareRevision(accessory, device));
+      .getCharacteristic(this.platform.Characteristic.FirmwareRevision)
+      .updateValue(this.FirmwareRevision(accessory, device));
 
     // get the WindowCovering service if it exists, otherwise create a new WindowCovering service
     // you can create multiple services for each accessory
@@ -212,7 +213,10 @@ export class Curtain {
    * 'homebridge-switchbot/curtain/xx:xx:xx:xx:xx:xx'
    */
   mqttPublish(topic: string, message: any) {
-    const mac = this.device.deviceId?.toLowerCase().match(/[\s\S]{1,2}/g)?.join(':');
+    const mac = this.device.deviceId
+      ?.toLowerCase()
+      .match(/[\s\S]{1,2}/g)
+      ?.join(':');
     const options = this.device.mqttPubOptions || {};
     this.mqttClient?.publish(`homebridge-switchbot/curtain/${mac}/${topic}`, `${message}`, options);
     this.debugLog(`Meter: ${this.accessory.displayName} MQTT message: ${topic}/${message} options:${JSON.stringify(options)}`);

package/src/device/humidifier.ts

@@ -80,7 +80,8 @@ export class Humidifier {
       .setCharacteristic(this.platform.Characteristic.Model, 'W0801800')
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!)
       .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.FirmwareRevision(accessory, device))
-      .getCharacteristic(this.platform.Characteristic.FirmwareRevision).updateValue(this.FirmwareRevision(accessory, device));
+      .getCharacteristic(this.platform.Characteristic.FirmwareRevision)
+      .updateValue(this.FirmwareRevision(accessory, device));
 
     // get the service if it exists, otherwise create a new service
     // you can create multiple services for each accessory

package/src/device/lock.ts

@@ -56,7 +56,8 @@ export class Lock {
       .setCharacteristic(this.platform.Characteristic.Model, 'W1601700')
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!)
       .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.FirmwareRevision(accessory, device))
-      .getCharacteristic(this.platform.Characteristic.FirmwareRevision).updateValue(this.FirmwareRevision(accessory, device));
+      .getCharacteristic(this.platform.Characteristic.FirmwareRevision)
+      .updateValue(this.FirmwareRevision(accessory, device));
 
     // get the LockMechanism service if it exists, otherwise create a new LockMechanism service
     // you can create multiple services for each accessory
@@ -187,7 +188,7 @@ export class Lock {
 
     this.infoLog(
       `Lock: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
-      ` parameter: ${payload.parameter}, commandType: ${payload.commandType}`,
+        ` parameter: ${payload.parameter}, commandType: ${payload.commandType}`,
     );
 
     // Make the API request
@@ -254,7 +255,7 @@ export class Lock {
       case 190:
         this.errorLog(
           `Lock: ${this.accessory.displayName} Device internal error due to device states not synchronized with server,` +
-          ` Or command: ${JSON.stringify(push.data)} format is invalid`,
+            ` Or command: ${JSON.stringify(push.data)} format is invalid`,
         );
         break;
       case 100:

package/src/device/meter.ts

@@ -6,7 +6,7 @@ import { DeviceURL, device, devicesConfig, serviceData, ad, switchbot, deviceSta
 import { Context } from 'vm';
 import { MqttClient } from 'mqtt';
 import { connectAsync } from 'async-mqtt';
-import { hostname } from "os";
+import { hostname } from 'os';
 
 /**
  * Platform Accessory
@@ -56,7 +56,7 @@ export class Meter {
 
   //MQTT stuff
   mqttClient: MqttClient | null = null;
-  
+
   // EVE history service handler
   historyService: any;
 
@@ -93,7 +93,8 @@ export class Meter {
       .setCharacteristic(this.platform.Characteristic.Model, 'METERTH-S1')
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!)
       .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.FirmwareRevision(accessory, device))
-      .getCharacteristic(this.platform.Characteristic.FirmwareRevision).updateValue(this.FirmwareRevision(accessory, device));
+      .getCharacteristic(this.platform.Characteristic.FirmwareRevision)
+      .updateValue(this.FirmwareRevision(accessory, device));
 
     // Temperature Sensor Service
     if (device.meter?.hide_temperature) {
@@ -182,7 +183,10 @@ export class Meter {
    * 'homebridge-switchbot/meter/xx:xx:xx:xx:xx:xx'
    */
   mqttPublish(message: any) {
-    const mac = this.device.deviceId?.toLowerCase().match(/[\s\S]{1,2}/g)?.join(':');
+    const mac = this.device.deviceId
+      ?.toLowerCase()
+      .match(/[\s\S]{1,2}/g)
+      ?.join(':');
     const options = this.device.mqttPubOptions || {};
     this.mqttClient?.publish(`homebridge-switchbot/meter/${mac}`, `${message}`, options);
     this.debugLog(`Meter: ${this.accessory.displayName} MQTT message: ${message} options:${JSON.stringify(options)}`);
@@ -194,14 +198,14 @@ export class Meter {
   async setupMqtt(device: device & devicesConfig): Promise<void> {
     if (device.mqttURL) {
       try {
-	this.mqttClient = await connectAsync(device.mqttURL, device.mqttOptions || {});
-	this.debugLog(`Meter: ${this.accessory.displayName} MQTT connection has been established successfully.`)
-	this.mqttClient.on('error', (e: Error) => {
-	  this.errorLog(`Meter: ${this.accessory.displayName} Failed to publish MQTT messages. ${e}`)
-	});
+        this.mqttClient = await connectAsync(device.mqttURL, device.mqttOptions || {});
+        this.debugLog(`Meter: ${this.accessory.displayName} MQTT connection has been established successfully.`);
+        this.mqttClient.on('error', (e: Error) => {
+          this.errorLog(`Meter: ${this.accessory.displayName} Failed to publish MQTT messages. ${e}`);
+        });
       } catch (e) {
-	this.mqttClient = null;
-	this.errorLog(`Meter: ${this.accessory.displayName} Failed to establish MQTT connection. ${e}`)
+        this.mqttClient = null;
+        this.errorLog(`Meter: ${this.accessory.displayName} Failed to establish MQTT connection. ${e}`);
       }
     }
   }
@@ -210,15 +214,19 @@ export class Meter {
    * Setup EVE history graph feature if enabled.
    */
   async setupHistoryService(device: device & devicesConfig): Promise<void> {
-    const mac = this.device.deviceId!.match(/.{1,2}/g)!.join(':').toLowerCase();
-    this.historyService = device.history ?
-	  new this.platform.fakegatoAPI('room', this.accessory,
-	    {log: this.platform.log, storage: 'fs',
-	     filename: `${hostname().split(".")[0]}_${mac}_persist.json`
-	    }) :
-	  null;
+    const mac = this.device
+      .deviceId!.match(/.{1,2}/g)!
+      .join(':')
+      .toLowerCase();
+    this.historyService = device.history
+      ? new this.platform.fakegatoAPI('room', this.accessory, {
+        log: this.platform.log,
+        storage: 'fs',
+        filename: `${hostname().split('.')[0]}_${mac}_persist.json`,
+      })
+      : null;
   }
-    
+
   /**
    * Parse the device status from the SwitchBot api
    */
@@ -240,7 +248,7 @@ export class Meter {
     } else {
       this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
     }
-      this.debugLog(`Meter: ${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel}, StatusLowBattery: ${this.StatusLowBattery}`);
+    this.debugLog(`Meter: ${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel}, StatusLowBattery: ${this.StatusLowBattery}`);
 
     // Humidity
     if (!this.device.meter?.hide_humidity) {
@@ -314,12 +322,13 @@ export class Meter {
               this.infoLog(`Meter: ${this.accessory.displayName} BLE Address Found: ${this.address}`);
               this.infoLog(`Meter: ${this.accessory.displayName} Config BLE Address: ${this.device.bleMac}`);
             }
-	    if (ad.serviceData.humidity! > 0) {	// reject unreliable data
+            if (ad.serviceData.humidity! > 0) {
+              // reject unreliable data
               this.serviceData = ad.serviceData;
               this.temperature = ad.serviceData.temperature!.c;
               this.humidity = ad.serviceData.humidity;
               this.battery = ad.serviceData.battery;
-	    }
+            }
             this.debugLog(`Meter: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
             this.debugLog(
               `Meter: ${this.accessory.displayName} model: ${ad.serviceData.model}, modelName: ${ad.serviceData.modelName}, ` +
@@ -420,16 +429,16 @@ export class Meter {
    * Updates the status for each of the HomeKit Characteristics
    */
   async updateHomeKitCharacteristics(): Promise<void> {
-    let mqttmessage: string[] = [];
-    let entry = {time: Math.round(new Date().valueOf()/1000)};
+    const mqttmessage: string[] = [];
+    const entry = { time: Math.round(new Date().valueOf() / 1000) };
     if (!this.device.meter?.hide_humidity) {
       if (this.CurrentRelativeHumidity === undefined) {
         this.debugLog(`Meter: ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
       } else {
         this.humidityservice?.updateCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity, this.CurrentRelativeHumidity);
         this.debugLog(`Meter: ${this.accessory.displayName} updateCharacteristic CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
-	mqttmessage.push(`"humidity": ${this.CurrentRelativeHumidity}`);
-	entry["humidity"] = this.CurrentRelativeHumidity;
+        mqttmessage.push(`"humidity": ${this.CurrentRelativeHumidity}`);
+        entry['humidity'] = this.CurrentRelativeHumidity;
       }
     }
     if (!this.device.meter?.hide_temperature) {
@@ -438,8 +447,8 @@ export class Meter {
       } else {
         this.temperatureservice?.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, this.CurrentTemperature);
         this.debugLog(`Meter: ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`);
-	mqttmessage.push(`"temperature": ${this.CurrentTemperature}`);
-	entry["temp"] = this.CurrentTemperature;
+        mqttmessage.push(`"temperature": ${this.CurrentTemperature}`);
+        entry['temp'] = this.CurrentTemperature;
       }
     }
     if (this.device.ble) {
@@ -448,18 +457,19 @@ export class Meter {
       } else {
         this.batteryService?.updateCharacteristic(this.platform.Characteristic.BatteryLevel, this.BatteryLevel);
         this.debugLog(`Meter: ${this.accessory.displayName} updateCharacteristic BatteryLevel: ${this.BatteryLevel}`);
-	mqttmessage.push(`"battery": ${this.BatteryLevel}`);
+        mqttmessage.push(`"battery": ${this.BatteryLevel}`);
       }
       if (this.StatusLowBattery === undefined) {
         this.debugLog(`Meter: ${this.accessory.displayName} StatusLowBattery: ${this.StatusLowBattery}`);
       } else {
         this.batteryService?.updateCharacteristic(this.platform.Characteristic.StatusLowBattery, this.StatusLowBattery);
         this.debugLog(`Meter: ${this.accessory.displayName} updateCharacteristic StatusLowBattery: ${this.StatusLowBattery}`);
-	mqttmessage.push(`"lowBattery": ${this.StatusLowBattery}`);
+        mqttmessage.push(`"lowBattery": ${this.StatusLowBattery}`);
       }
     }
-    this.mqttPublish(`{${mqttmessage.join(',')}}`)
-    if (this.CurrentRelativeHumidity > 0) { // reject unreliable data
+    this.mqttPublish(`{${mqttmessage.join(',')}}`);
+    if (this.CurrentRelativeHumidity > 0) {
+      // reject unreliable data
       this.historyService?.addEntry(entry);
     }
   }

package/src/device/meterplus.ts

@@ -82,7 +82,8 @@ export class MeterPlus {
       .setCharacteristic(this.platform.Characteristic.Model, this.model(device))
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!)
       .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.FirmwareRevision(accessory, device))
-      .getCharacteristic(this.platform.Characteristic.FirmwareRevision).updateValue(this.FirmwareRevision(accessory, device));
+      .getCharacteristic(this.platform.Characteristic.FirmwareRevision)
+      .updateValue(this.FirmwareRevision(accessory, device));
 
     // Temperature Sensor Service
     if (device.meter?.hide_temperature) {

package/src/device/motion.ts

@@ -70,7 +70,8 @@ export class Motion {
       .setCharacteristic(this.platform.Characteristic.Model, 'W1101500')
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!)
       .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.FirmwareRevision(accessory, device))
-      .getCharacteristic(this.platform.Characteristic.FirmwareRevision).updateValue(this.FirmwareRevision(accessory, device));
+      .getCharacteristic(this.platform.Characteristic.FirmwareRevision)
+      .updateValue(this.FirmwareRevision(accessory, device));
 
     // get the Battery service if it exists, otherwise create a new Motion service
     // you can create multiple services for each accessory

package/src/device/plug.ts

@@ -21,9 +21,16 @@ export class Plug {
   // BLE Others
   connected?: boolean;
   switchbot!: switchbot;
+  address!: ad['address'];
   SwitchToOpenAPI?: boolean;
   serviceData!: serviceData;
-  address!: ad['address'];
+  state: serviceData['state'];
+  delay: serviceData['delay'];
+  timer: serviceData['timer'];
+  wifiRssi: serviceData['wifiRssi'];
+  overload: serviceData['overload'];
+  syncUtcTime: serviceData['syncUtcTime'];
+  currentPower: serviceData['currentPower'];
 
   // Config
   scanDuration!: number;
@@ -33,13 +40,6 @@ export class Plug {
   // Updates
   plugUpdateInProgress!: boolean;
   doPlugUpdate!: Subject<void>;
-  state: serviceData['state'];
-  delay: serviceData['delay'];
-  timer: serviceData['timer'];
-  syncUtcTime: serviceData['syncUtcTime'];
-  wifiRssi: serviceData['wifiRssi'];
-  overload: serviceData['overload'];
-  currentPower: serviceData['currentPower'];
 
   constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: device & devicesConfig) {
     // default placeholders
@@ -271,7 +271,7 @@ export class Plug {
   }
 
   async BLEconnection(switchbot: any): Promise<void> {
-    this.errorLog(`Plug: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchPlug: ${switchbot}`);
+    this.errorLog(`Plug: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.openToken) {
       this.warnLog(`Plug: ${this.accessory.displayName} Using OpenAPI Connection`);
       this.SwitchToOpenAPI = true;