@switchbot/homebridge-switchbot 0.2.0-alpha.2 → 1.0.1-beta.2

package/src/devices/humidifiers.ts

@@ -2,7 +2,8 @@ import { Service, PlatformAccessory, CharacteristicValue } from 'homebridge';
 import { SwitchBotPlatform } from '../platform';
 import { interval, Subject } from 'rxjs';
 import { debounceTime, skipWhile, tap } from 'rxjs/operators';
-import { DeviceURL, device, devicesConfig } from '../settings';
+import { DeviceURL, device, devicesConfig, serviceData, ad, deviceStatusResponse } from '../settings';
+import { AxiosResponse } from 'axios';
 
 /**
  * Platform Accessory
@@ -23,19 +24,31 @@ export class Humidifier {
   Active!: CharacteristicValue;
   WaterLevel!: CharacteristicValue;
 
-  // Others
-  deviceStatus!: any;
+  // OpenAPI
+  deviceStatus!: deviceStatusResponse;
+
+  // BLE Others
+  serviceData!: serviceData;
+  onState!: serviceData['onState'];
+  autoMode!: serviceData['autoMode'];
+  percentage!: serviceData['percentage'];
+
+  // Config
+  set_minStep?: number;
 
   // Updates
   humidifierUpdateInProgress!: boolean;
-  doHumidifierUpdate;
-  set_minStep: number | undefined;
+  doHumidifierUpdate!: Subject<void>;
 
   constructor(
     private readonly platform: SwitchBotPlatform,
     private accessory: PlatformAccessory,
     public device: device & devicesConfig,
   ) {
+    // Humidifiers Config
+    this.platform.device(`[Humidifiers Config] ble: ${device.ble}, hide_temperature: ${device.humidifier?.hide_temperature},`
+      + ` set_minStep: ${device.humidifier?.set_minStep}`);
+
     // default placeholders
     this.CurrentRelativeHumidity = 0;
     this.TargetHumidifierDehumidifierState = this.platform.Characteristic.TargetHumidifierDehumidifierState.HUMIDIFIER;
@@ -180,7 +193,11 @@ export class Humidifier {
    */
   parseStatus() {
     // Current Relative Humidity
-    this.CurrentRelativeHumidity = this.deviceStatus.body.humidity!;
+    if (this.device.ble) {
+      this.CurrentRelativeHumidity = this.percentage!;
+    } else {
+      this.CurrentRelativeHumidity = this.deviceStatus.body.humidity!;
+    }
     this.platform.debug(`Humidifier ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
     this.platform.device(JSON.stringify(this.deviceStatus.body));
     // Water Level
@@ -191,12 +208,16 @@ export class Humidifier {
     }
     this.platform.debug(`Humidifier ${this.accessory.displayName} WaterLevel: ${this.WaterLevel}`);
     // Active
-    switch (this.deviceStatus.body.power) {
-      case 'on':
-        this.Active = this.platform.Characteristic.Active.ACTIVE;
-        break;
-      default:
-        this.Active = this.platform.Characteristic.Active.INACTIVE;
+    if (this.device.ble) {
+      this.Active = this.State();
+    } else {
+      switch (this.deviceStatus.body.power) {
+        case 'on':
+          this.Active = this.platform.Characteristic.Active.ACTIVE;
+          break;
+        default:
+          this.Active = this.platform.Characteristic.Active.INACTIVE;
+      }
     }
     this.platform.debug(`Humidifier ${this.accessory.displayName} Active: ${this.Active}`);
     // Target Humidifier Dehumidifier State
@@ -226,15 +247,77 @@ export class Humidifier {
     this.platform.debug(`Humidifier ${this.accessory.displayName} CurrentHumidifierDehumidifierState: ${this.CurrentHumidifierDehumidifierState}`);
     // Current Temperature
     if (!this.device.humidifier?.hide_temperature) {
-      this.CurrentTemperature = this.deviceStatus.body.temperature;
+      this.CurrentTemperature = Number(this.deviceStatus.body.temperature);
       this.platform.debug(`Humidifier ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
     }
   }
 
+  private State(): CharacteristicValue {
+    if (this.onState) {
+      return this.platform.Characteristic.Active.ACTIVE;
+    } else {
+      return this.platform.Characteristic.Active.INACTIVE;
+    }
+  }
+
   /**
    * Asks the SwitchBot API for the latest device information
    */
   async refreshStatus() {
+    if (this.device.ble) {
+      this.platform.device('BLE');
+      await this.BLERefreshStatus();
+    } else {
+      this.platform.device('OpenAPI');
+      await this.openAPIRefreshStatus();
+    }
+  }
+
+  private connectBLE() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const Switchbot = require('node-switchbot');
+    const switchbot = new Switchbot();
+    const colon = this.device.deviceId!.match(/.{1,2}/g);
+    const bleMac = colon!.join(':'); //returns 1A:23:B4:56:78:9A;
+    this.device.bleMac = bleMac.toLowerCase();
+    this.platform.device(this.device.bleMac!);
+    return switchbot;
+  }
+
+  private async BLERefreshStatus() {
+    this.platform.device('Bot BLE Device refreshStatus');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const switchbot = this.connectBLE();
+    // Start to monitor advertisement packets
+    switchbot.startScan({
+      model: 'e',
+      id: this.device.bleMac,
+    }).then(() => {
+      // Set an event hander
+      switchbot.onadvertisement = (ad: ad) => {
+        this.serviceData = ad.serviceData;
+        this.autoMode = ad.serviceData.autoMode;
+        this.onState = ad.serviceData.onState;
+        this.percentage = ad.serviceData.percentage;
+        this.platform.device(`${this.device.bleMac}: ${JSON.stringify(ad.serviceData)}`);
+        this.platform.device(`${this.accessory.displayName}, Model: ${ad.serviceData.model}, Model Name: ${ad.serviceData.modelName},`
+          + `autoMode: ${ad.serviceData.autoMode}, onState: ${ad.serviceData.onState}, percentage: ${ad.serviceData.percentage}`);
+      };
+      // Wait 10 seconds
+      return switchbot.wait(10000);
+    }).then(() => {
+      // Stop to monitor
+      switchbot.stopScan();
+      this.parseStatus();
+      this.updateHomeKitCharacteristics();
+    }).catch(async (e: any) => {
+      this.platform.log.error(`BLE Connection Failed: ${e.message}`);
+      this.platform.log.warn('Using OpenAPI Connection');
+      await this.openAPIRefreshStatus();
+    });
+  }
+
+  private async openAPIRefreshStatus() {
     try {
       this.deviceStatus = (await this.platform.axios.get(`${DeviceURL}/${this.device.deviceId}/status`)).data;
       if (this.deviceStatus.message === 'success') {
@@ -436,7 +519,7 @@ export class Humidifier {
     }
   }
 
-  private statusCode(push: { data: { statusCode: any; }; }) {
+  private statusCode(push: AxiosResponse<{ statusCode: number; }>) {
     switch (push.data.statusCode) {
       case 151:
         this.platform.log.error('Command not supported by this device type.');

package/src/devices/indoorcam.ts

@@ -1,8 +1,9 @@
-import { Service, PlatformAccessory, CharacteristicValue, MacAddress } from 'homebridge';
+import { Service, PlatformAccessory, CharacteristicValue } from 'homebridge';
 import { SwitchBotPlatform } from '../platform';
 import { interval, Subject } from 'rxjs';
 import { debounceTime, skipWhile, tap } from 'rxjs/operators';
-import { DeviceURL, device, devicesConfig } from '../settings';
+import { DeviceURL, device, devicesConfig, switchbot, deviceStatusResponse } from '../settings';
+import { AxiosResponse } from 'axios';
 
 export class IndoorCam {
   // Services
@@ -12,26 +13,15 @@ export class IndoorCam {
   On!: CharacteristicValue;
   OutletInUse!: CharacteristicValue;
 
-  // Others
-  deviceStatus!: any;
-  switchbot!: {
-    discover: (
-      arg0:
-        {
-          duration: any;
-          model: string;
-          quick: boolean;
-          id: MacAddress;
-        }
-    ) => Promise<any>;
-    wait: (
-      arg0: number
-    ) => any;
-  };
+  // OpenAPI Others
+  deviceStatus!: deviceStatusResponse;
+
+  // BLE Others
+  switchbot!: switchbot;
 
   // Updates
   cameraUpdateInProgress!: boolean;
-  doCameraUpdate;
+  doCameraUpdate!: Subject<void>;
 
   constructor(
     private readonly platform: SwitchBotPlatform,
@@ -259,7 +249,7 @@ export class IndoorCam {
   }
 
 
-  private statusCode(push: { data: { statusCode: any; }; }) {
+  private statusCode(push: AxiosResponse<{ statusCode: number;}>) {
     switch (push.data.statusCode) {
       case 151:
         this.platform.log.error('Command not supported by this device type.');

package/src/devices/meters.ts

@@ -1,8 +1,8 @@
-import { Service, PlatformAccessory, Units, CharacteristicValue, MacAddress } from 'homebridge';
+import { Service, PlatformAccessory, Units, CharacteristicValue } from 'homebridge';
 import { SwitchBotPlatform } from '../platform';
 import { interval, Subject } from 'rxjs';
 import { skipWhile } from 'rxjs/operators';
-import { DeviceURL, device, devicesConfig } from '../settings';
+import { DeviceURL, device, devicesConfig, serviceData, ad, switchbot, deviceStatusResponse } from '../settings';
 
 /**
  * Platform Accessory
@@ -24,34 +24,30 @@ export class Meter {
   Active!: CharacteristicValue;
   WaterLevel!: CharacteristicValue;
 
-  // Others
-  deviceStatus!: any;
-  BLEtemperature!: number;
-  BLEHumidity!: number;
-  switchbot!: {
-    discover: (
-      arg0:
-        {
-          duration: any;
-          model: string;
-          quick: boolean;
-          id: MacAddress;
-        }
-    ) => Promise<any>;
-    wait: (
-      arg0: number
-    ) => any;
-  };
+  // OpenAPI Others
+  deviceStatus!: deviceStatusResponse;
+
+  // BLE Others
+  switchbot!: switchbot;
+  serviceData!: serviceData;
+  battery!: serviceData['battery'];
+  humidity!: serviceData['humidity'];
+  fahrenheit!: serviceData['fahrenheit'];
+  temperature!: serviceData['temperature'];
 
   // Updates
   meterUpdateInProgress!: boolean;
-  doMeterUpdate;
+  doMeterUpdate: Subject<void>;
 
   constructor(
     private readonly platform: SwitchBotPlatform,
     private accessory: PlatformAccessory,
     public device: device & devicesConfig,
   ) {
+    // Meter Config
+    this.platform.device(`[Meter Config] ble: ${device.ble}, unit: ${device.meter?.unit},`
+    + ` hide_temperature: ${device.meter?.hide_temperature}, hide_humidity: ${device.meter?.hide_humidity}`);
+
     // default placeholders
     this.BatteryLevel = 0;
     this.ChargingState = 2;
@@ -211,7 +207,7 @@ export class Meter {
     // Current Relative Humidity
     if (!this.device.meter?.hide_humidity) {
       if (this.device.ble) {
-        this.CurrentRelativeHumidity = this.BLEHumidity;
+        this.CurrentRelativeHumidity = Number(this.humidity);
       } else {
         this.CurrentRelativeHumidity = this.deviceStatus.body.humidity!;
       }
@@ -221,14 +217,14 @@ export class Meter {
     // Current Temperature
     if (!this.device.meter?.hide_temperature) {
       if (this.device.ble) {
-        this.CurrentTemperature = this.BLEtemperature;
+        this.CurrentTemperature = Number(this.temperature);
       } else {
         if (this.device.meter?.unit === 1) {
           this.CurrentTemperature = this.toFahrenheit(this.deviceStatus.body.temperature!);
         } else if (this.device.meter?.unit === 0) {
           this.CurrentTemperature = this.toCelsius(this.deviceStatus.body.temperature!);
         } else {
-          this.CurrentTemperature = this.deviceStatus.body.temperature;
+          this.CurrentTemperature = Number(this.deviceStatus.body.temperature);
         }
       }
       this.platform.debug(`Meter ${this.accessory.displayName} - Temperature: ${this.CurrentTemperature}°c`);
@@ -248,8 +244,7 @@ export class Meter {
     }
   }
 
-  private async BLErefreshStatus() {
-    this.platform.debug('Meter BLE Device RefreshStatus');
+  private connectBLE() {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const Switchbot = require('node-switchbot');
     const switchbot = new Switchbot();
@@ -257,49 +252,42 @@ export class Meter {
     const bleMac = colon!.join(':'); //returns 1A:23:B4:56:78:9A;
     this.device.bleMac = bleMac.toLowerCase();
     this.platform.device(this.device.bleMac!);
-    switchbot.onadvertisement = (ad: any) => {
-      this.platform.debug(JSON.stringify(ad, null, '  '));
-      this.platform.device('ad:', JSON.stringify(ad));
-      this.platform.device(`Temperature: ${ad.serviceData.temperature.c}`);
-      this.platform.device(`Humidity: ${ad.serviceData.humidity}`);
-      this.BLEtemperature = ad.serviceData.temperature.c;
-      this.BLEHumidity = ad.serviceData.humidity;
-    };
-    this.parseStatus();
-    this.updateHomeKitCharacteristics();
-    switchbot
-      .startScan({
-        id: this.device.bleMac,
-      })
-      .then(() => {
-        return switchbot.wait(this.platform.config.options!.refreshRate! * 1000);
-      })
-      .then(() => {
-        switchbot.stopScan();
-      })
-      .catch(async (error: any) => {
-        this.platform.log.error(error);
-        await this.openAPIRefreshStatus();
-      });
-    setInterval(() => {
-      this.platform.log.info('Start scan ' + this.device.deviceName + '(' + this.device.bleMac + ')');
-      switchbot
-        .startScan({
-          mode: 'T',
-          id: bleMac,
-        })
-        .then(() => {
-          return switchbot.wait(this.platform.config.options!.refreshRate! * 1000);
-        })
-        .then(() => {
-          switchbot.stopScan();
-          this.platform.log.info('Stop scan ' + this.device.deviceName + '(' + this.device.bleMac + ')');
-        })
-        .catch(async (error: any) => {
-          this.platform.log.error(error);
-          await this.openAPIRefreshStatus();
-        });
-    }, this.platform.config.options!.refreshRate! * 60000);
+    return switchbot;
+  }
+
+  private async BLErefreshStatus() {
+    this.platform.debug('Meter BLE Device RefreshStatus');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const switchbot = this.connectBLE();
+    // Start to monitor advertisement packets
+    switchbot.startScan({
+      model: 'e',
+      id: this.device.bleMac,
+    }).then(() => {
+      // Set an event hander
+      switchbot.onadvertisement = (ad: ad) => {
+        this.serviceData = ad.serviceData;
+        this.temperature = ad.serviceData.temperature;
+        this.fahrenheit = ad.serviceData.fahrenheit;
+        this.humidity = ad.serviceData.humidity;
+        this.battery = ad.serviceData.battery;
+        this.platform.device(`${this.device.bleMac}: ${JSON.stringify(ad.serviceData)}`);
+        this.platform.device(`${this.accessory.displayName}, Model: ${ad.serviceData.model}, Model Name: ${ad.serviceData.modelName},`
+           + `Temperature: ${ad.serviceData.temperature}, Fahrenheit: ${ad.serviceData.fahrenheit}, Humidity: ${ad.serviceData.humidity}`
+           + `Battery: ${ad.serviceData.battery}`);
+      };
+      // Wait 10 seconds
+      return switchbot.wait(10000);
+    }).then(() => {
+      // Stop to monitor
+      switchbot.stopScan();
+      this.parseStatus();
+      this.updateHomeKitCharacteristics();
+    }).catch(async (e: any) => {
+      this.platform.log.error(`BLE Connection Failed: ${e.message}`);
+      this.platform.log.warn('Using OpenAPI Connection');
+      await this.openAPIRefreshStatus();
+    });
   }
 
   private async openAPIRefreshStatus() {

package/src/devices/motion.ts

@@ -1,8 +1,8 @@
-import { Service, PlatformAccessory, CharacteristicValue, MacAddress } from 'homebridge';
+import { Service, PlatformAccessory, CharacteristicValue } from 'homebridge';
 import { SwitchBotPlatform } from '../platform';
 import { interval, Subject } from 'rxjs';
 import { skipWhile } from 'rxjs/operators';
-import { DeviceURL, device, devicesConfig } from '../settings';
+import { DeviceURL, device, devicesConfig, serviceData, switchbot, deviceStatusResponse } from '../settings';
 
 /**
  * Platform Accessory
@@ -12,31 +12,28 @@ import { DeviceURL, device, devicesConfig } from '../settings';
 export class Motion {
   // Services
   private service: Service;
+  private lightSensorService?: Service;
+  private batteryService?: Service;
 
   // Characteristic Values
   MotionDetected!: CharacteristicValue;
+  BatteryLevel?: CharacteristicValue;
+  StatusLowBattery?: CharacteristicValue;
+  CurrentAmbientLightLevel?: CharacteristicValue;
 
-  // Others
-  deviceStatus!: any;
-  BLEmotion!: boolean;
-  switchbot!: {
-    discover: (
-      arg0:
-        {
-          duration: any;
-          model: string;
-          quick: boolean;
-          id: MacAddress;
-        }
-    ) => Promise<any>;
-    wait: (
-      arg0: number
-    ) => any;
-  };
+  // OpenAPI Others
+  deviceStatus!: deviceStatusResponse;
+
+  // BLE Others
+  switchbot!: switchbot;
+  serviceData!: serviceData;
+  battery!: serviceData['battery'];
+  movement!: serviceData['movement'];
+  lightLevel!: serviceData['lightLevel'];
 
   // Updates
   motionUbpdateInProgress!: boolean;
-  doMotionUpdate;
+  doMotionUpdate!: Subject<void>;
 
   constructor(
     private readonly platform: SwitchBotPlatform,
@@ -77,6 +74,21 @@ export class Motion {
       accessory.getService(this.platform.Service.MotionSensor) ||
       accessory.addService(this.platform.Service.MotionSensor)), `${accessory.displayName} Motion Sensor`;
 
+    if (device.ble) {
+      (this.lightSensorService =
+        accessory.getService(this.platform.Service.LightSensor) ||
+        accessory.addService(this.platform.Service.LightSensor)), `${accessory.displayName} Light Sensor`;
+
+      this.lightSensorService.setCharacteristic(this.platform.Characteristic.Name, `${accessory.displayName} Light Sensor`);
+
+
+      (this.batteryService =
+        accessory.getService(this.platform.Service.Battery) ||
+        accessory.addService(this.platform.Service.Battery)), `${accessory.displayName} Battery`;
+
+      this.batteryService.setCharacteristic(this.platform.Characteristic.Name, `${accessory.displayName} Battery`);
+    }
+
     // To avoid "Cannot add a Service with the same UUID another Service without also defining a unique 'subtype' property." error,
     // when creating multiple services of the same type, you need to use the following syntax to specify a name and subtype id:
     // accessory.getService('NAME') ?? accessory.addService(this.platform.Service.Motion, 'NAME', 'USER_DEFINED_SUBTYPE');
@@ -116,8 +128,24 @@ export class Motion {
   }
 
   private async BLEparseStatus() {
-    this.MotionDetected = Boolean(this.BLEmotion);
+    this.MotionDetected = Boolean(this.movement);
     this.platform.debug(`${this.accessory.displayName}, MotionDetected: ${this.MotionDetected}`);
+    // Light Level
+    switch (this.lightLevel) {
+      case 'dark':
+      case 0:
+        this.CurrentAmbientLightLevel = 0.0001;
+        break;
+      default:
+        this.CurrentAmbientLightLevel = 100000;
+    }
+    // Battery
+    this.BatteryLevel = Number(this.battery);
+    if (this.BatteryLevel < 10) {
+      this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
+    } else {
+      this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+    }
   }
 
   private async openAPIparseStatus() {
@@ -131,15 +159,14 @@ export class Motion {
   async refreshStatus() {
     if (this.device.ble) {
       this.platform.device('BLE');
-      await this.BLErefreshStatus();
+      await this.BLERefreshStatus();
     } else {
       this.platform.device('OpenAPI');
       await this.openAPIRefreshStatus();
     }
   }
 
-  private async BLErefreshStatus() {
-    this.platform.debug('Motion BLE Device RefreshStatus');
+  private connectBLE() {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const Switchbot = require('node-switchbot');
     const switchbot = new Switchbot();
@@ -147,46 +174,40 @@ export class Motion {
     const bleMac = colon!.join(':'); //returns 1A:23:B4:56:78:9A;
     this.device.bleMac = bleMac.toLowerCase();
     this.platform.device(this.device.bleMac!);
-    switchbot.onadvertisement = (ad: any) => {
-      this.platform.debug(JSON.stringify(ad, null, '  '));
-      this.platform.device('ad:', JSON.stringify(ad));
-      this.BLEmotion = ad.serviceData.motion;
-    };
-    switchbot
-      .startScan({
-        id: this.device.bleMac,
-      })
-      .then(() => {
-        return switchbot.wait(this.platform.config.options!.refreshRate! * 1000);
-      })
-      .then(() => {
-        switchbot.stopScan();
-      })
-      .catch(async (error: any) => {
-        this.platform.log.error(error);
-        await this.openAPIRefreshStatus();
-      });
-    setInterval(() => {
-      this.platform.log.info('Start scan ' + this.device.deviceName + '(' + this.device.bleMac + ')');
-      switchbot
-        .startScan({
-          mode: 'S',
-          id: bleMac,
-        })
-        .then(() => {
-          return switchbot.wait(this.platform.config.options!.refreshRate! * 1000);
-        })
-        .then(() => {
-          switchbot.stopScan();
-          this.platform.log.info('Stop scan ' + this.device.deviceName + '(' + this.device.bleMac + ')');
-        })
-        .catch(async (error: any) => {
-          this.platform.log.error(error);
-          await this.openAPIRefreshStatus();
-        });
+    return switchbot;
+  }
+
+  private async BLERefreshStatus() {
+    this.platform.debug('Motion BLE Device RefreshStatus');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const switchbot = this.connectBLE();
+    // Start to monitor advertisement packets
+    switchbot.startScan({
+      model: 's',
+      id: this.device.bleMac,
+    }).then(() => {
+      // Set an event hander
+      switchbot.onadvertisement = (ad: any) => {
+        this.serviceData = ad.serviceData;
+        this.platform.device(`${this.device.bleMac}: ${JSON.stringify(ad.serviceData)}`);
+        this.movement = ad.serviceData.movement;
+        this.battery = ad.serviceData.battery;
+        this.lightLevel = ad.serviceData.lightLevel;
+        this.platform.device(`${this.accessory.displayName}, Movement: ${ad.serviceData.movement}, Light Level: ${ad.serviceData.lightLevel},`
+          + ` Battery: ${ad.serviceData.battery}`);
+      };
+      // Wait 10 seconds
+      return switchbot.wait(10000);
+    }).then(() => {
+      // Stop to monitor
+      switchbot.stopScan();
       this.parseStatus();
       this.updateHomeKitCharacteristics();
-    }, this.platform.config.options!.refreshRate! * 60000);
+    }).catch(async (e: any) => {
+      this.platform.log.error(`BLE Connection Failed: ${e.message}`);
+      this.platform.log.warn('Using OpenAPI Connection');
+      await this.openAPIRefreshStatus();
+    });
   }
 
   private async openAPIRefreshStatus() {
@@ -212,9 +233,34 @@ export class Motion {
       this.service.updateCharacteristic(this.platform.Characteristic.MotionDetected, this.MotionDetected);
       this.platform.device(`Motion ${this.accessory.displayName} updateCharacteristic MotionDetected: ${this.MotionDetected}`);
     }
+    if (this.device.ble) {
+      if (this.BatteryLevel === undefined) {
+        this.platform.debug(`Motion ${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel}`);
+      } else {
+        this.batteryService?.updateCharacteristic(this.platform.Characteristic.BatteryLevel, this.BatteryLevel);
+        this.platform.device(`Motion ${this.accessory.displayName} updateCharacteristic BatteryLevel: ${this.BatteryLevel}`);
+      }
+      if (this.StatusLowBattery === undefined) {
+        this.platform.debug(`Motion ${this.accessory.displayName} StatusLowBattery: ${this.StatusLowBattery}`);
+      } else {
+        this.batteryService?.updateCharacteristic(this.platform.Characteristic.StatusLowBattery, this.StatusLowBattery);
+        this.platform.device(`Motion ${this.accessory.displayName} updateCharacteristic StatusLowBattery: ${this.StatusLowBattery}`);
+      }
+      if (this.CurrentAmbientLightLevel === undefined) {
+        this.platform.debug(`Motion ${this.accessory.displayName} CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+      } else {
+        this.lightSensorService?.updateCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel, this.CurrentAmbientLightLevel);
+        this.platform.device(`Motion ${this.accessory.displayName} updateCharacteristic CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+      }
+    }
   }
 
   public apiError(e: any) {
     this.service.updateCharacteristic(this.platform.Characteristic.MotionDetected, e);
+    if (this.device.ble) {
+      this.batteryService?.updateCharacteristic(this.platform.Characteristic.BatteryLevel, e);
+      this.batteryService?.updateCharacteristic(this.platform.Characteristic.StatusLowBattery, e);
+      this.lightSensorService?.updateCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel, e);
+    }
   }
 }