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

package/src/device/ceilinglight.ts

@@ -200,13 +200,22 @@ export class CeilingLight extends deviceBase {
     // On
     this.LightBulb.On = deviceStatus.power;
     await this.debugLog(`On: ${this.LightBulb.On}`);
+
     // Brightness
     this.LightBulb.Brightness = deviceStatus.brightness;
     await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
+
     // ColorTemperature
-    const miredColorTemperature = Math.round(1000000 / deviceStatus.colorTemperature);
-    this.LightBulb.ColorTemperature = Math.max(Math.min(miredColorTemperature, 500), 140);
-    await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+    if (!Number.isNaN(deviceStatus.colorTemperature)) {
+      await this.debugLog(`OpenAPI ColorTemperature: ${deviceStatus.colorTemperature}`);
+      const mired = Math.round(1000000 / deviceStatus.colorTemperature);
+
+      this.LightBulb.ColorTemperature = Number(mired);
+
+      this.LightBulb.ColorTemperature = Math.max(Math.min(this.LightBulb.ColorTemperature, 500), 140);
+      await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+    }
+
     // Firmware Version
     const version = deviceStatus.version.toString();
     await this.debugLog(`Firmware Version: ${version.replace(/^V|-.*$/g, '')}`);
@@ -234,8 +243,7 @@ export class CeilingLight extends deviceBase {
     this.LightBulb.Brightness = context.brightness;
     await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
     // ColorTemperature
-    const miredColorTemperature = Math.round(1000000 / context.colorTemperature);
-    this.LightBulb.ColorTemperature = Math.max(Math.min(miredColorTemperature, 500), 140);
+    this.LightBulb.ColorTemperature = context.colorTemperature;
     await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
   }
 
@@ -301,7 +309,7 @@ export class CeilingLight extends deviceBase {
   async registerWebhook() {
     if (this.device.webhook) {
       await this.debugLog('is listening webhook.');
-      this.platform.webhookEventHandler[this.device.deviceId] = async (context: ceilingLightWebhookContext | ceilingLightProWebhookContext) => {
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
         try {
           await this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
           await this.parseStatusWebhook(context);
@@ -468,7 +476,7 @@ export class CeilingLight extends deviceBase {
   async pushColorTemperatureChanges(): Promise<void> {
     await this.debugLog('pushColorTemperatureChanges');
     if (this.LightBulb.ColorTemperature !== this.accessory.context.ColorTemperature) {
-      const kelvin = Math.round(1000000 * Number(this.LightBulb.ColorTemperature));
+      const kelvin = Math.round(1000000 / Number(this.LightBulb.ColorTemperature));
       this.accessory.context.kelvin = kelvin;
       const bodyChange = JSON.stringify({
         command: 'setColorTemperature',

package/src/device/colorbulb.ts

@@ -200,8 +200,7 @@ export class ColorBulb extends deviceBase {
     this.LightBulb.Saturation = saturation;
     await this.debugLog(`Saturation: ${this.LightBulb.Saturation}`);
     // ColorTemperature
-    const miredColorTemperature = Math.round(1000000 / serviceData.color_temperature);
-    this.LightBulb.ColorTemperature = Math.max(Math.min(miredColorTemperature, 500), 140);
+    this.LightBulb.ColorTemperature = Math.max(Math.min(serviceData.color_temperature, 500), 140);
     await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
   }
 
@@ -210,28 +209,35 @@ export class ColorBulb extends deviceBase {
    */
   async openAPIparseStatus(deviceStatus: colorBulbStatus): Promise<void> {
     await this.debugLog('openAPIparseStatus');
+
     // On
     this.LightBulb.On = deviceStatus.power === 'on' ? true : false;
     await this.debugLog(`On: ${this.LightBulb.On}`);
+
     // Brightness
     this.LightBulb.Brightness = deviceStatus.brightness;
     await this.debugLog(`Brightness: ${this.LightBulb.Brightness}`);
+
     // Color, Hue & Brightness
     await this.debugLog(`color: ${JSON.stringify(deviceStatus.color)}`);
     const [red, green, blue] = deviceStatus.color.split(':');
     await this.debugLog(`red: ${JSON.stringify(red)}, green: ${JSON.stringify(green)}, blue: ${JSON.stringify(blue)}`);
     const [hue, saturation] = rgb2hs(red, green, blue);
     await this.debugLog(`hs: ${JSON.stringify(rgb2hs(red, green, blue))}`);
+
     // Hue
     this.LightBulb.Hue = hue;
     await this.debugLog(`Hue: ${this.LightBulb.Hue}`);
+
     // Saturation
     this.LightBulb.Saturation = saturation;
     await this.debugLog(`Saturation: ${this.LightBulb.Saturation}`);
+
     // ColorTemperature
     const miredColorTemperature = Math.round(1000000 / deviceStatus.colorTemperature);
     this.LightBulb.ColorTemperature = Math.max(Math.min(miredColorTemperature, 500), 140);
     await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
+
     // Firmware Version
     const version = deviceStatus.version.toString();
     await this.debugLog(`Firmware Version: ${version.replace(/^V|-.*$/g, '')}`);
@@ -272,8 +278,7 @@ export class ColorBulb extends deviceBase {
     this.LightBulb.Saturation = saturation;
     await this.debugLog(`Saturation: ${this.LightBulb.Saturation}`);
     // ColorTemperature
-    const miredColorTemperature = Math.round(1000000 / context.colorTemperature);
-    this.LightBulb.ColorTemperature = Math.max(Math.min(miredColorTemperature, 500), 140);
+    this.LightBulb.ColorTemperature = context.colorTemperature;
     await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
   }
 
@@ -339,7 +344,7 @@ export class ColorBulb extends deviceBase {
   async registerWebhook() {
     if (this.device.webhook) {
       await this.debugLog('is listening webhook.');
-      this.platform.webhookEventHandler[this.device.deviceId] = async (context: colorBulbWebhookContext) => {
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
         try {
           await this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
           await this.parseStatusWebhook(context);
@@ -484,8 +489,6 @@ export class ColorBulb extends deviceBase {
   async BLEpushColorTemperatureChanges(): Promise<void> {
     await this.debugLog('BLEpushColorTemperatureChanges');
     if (this.LightBulb.ColorTemperature !== this.accessory.context.ColorTemperature) {
-      const kelvin = Math.round(1000000 / Number(this.LightBulb.ColorTemperature));
-      this.accessory.context.kelvin = kelvin;
       const switchbot = await this.platform.connectBLE(this.accessory, this.device);
       await this.convertBLEAddress();
       if (switchbot !== false) {
@@ -493,7 +496,7 @@ export class ColorBulb extends deviceBase {
           .discover({ model: this.device.bleModel, id: this.device.bleMac })
           .then(async (device_list: any) => {
             await this.infoLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-            return await device_list[0].setColorTemperature(kelvin);
+            return await device_list[0].setColorTemperature(this.LightBulb.ColorTemperature);
           })
           .then(async () => {
             await this.successLog(`ColorTemperature: ${this.LightBulb.ColorTemperature} sent over SwitchBot BLE,  sent successfully`);

package/src/device/curtain.ts

@@ -462,7 +462,7 @@ export class Curtain extends deviceBase {
   async registerWebhook() {
     if (this.device.webhook) {
       await this.debugLog('is listening webhook.');
-      this.platform.webhookEventHandler[this.device.deviceId] = async (context: curtainWebhookContext | curtain3WebhookContext) => {
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
         try {
           await this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
           await this.parseStatusWebhook(context);

package/src/device/device.ts

@@ -841,48 +841,48 @@ export abstract class deviceBase {
    */
   async infoLog(...log: any[]): Promise<void> {
     if (await this.enablingDeviceLogging()) {
-      this.log.info(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
+      this.log.info(`${this.device.deviceType}: ${this.accessory.displayName} `, String(...log));
     }
   }
 
   async successLog(...log: any[]): Promise<void> {
     if (await this.enablingDeviceLogging()) {
-      this.log.success(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
+      this.log.success(`${this.device.deviceType}: ${this.accessory.displayName} `, String(...log));
     }
   }
 
   async debugSuccessLog(...log: any[]): Promise<void> {
     if (await this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
-        this.log.success(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
+        this.log.success(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName} `, String(...log));
       }
     }
   }
 
   async warnLog(...log: any[]): Promise<void> {
     if (await this.enablingDeviceLogging()) {
-      this.log.warn(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
+      this.log.warn(`${this.device.deviceType}: ${this.accessory.displayName} `, String(...log));
     }
   }
 
   async debugWarnLog(...log: any[]): Promise<void> {
     if (await this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
-        this.log.warn(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
+        this.log.warn(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName} `, String(...log));
       }
     }
   }
 
   async errorLog(...log: any[]): Promise<void> {
     if (await this.enablingDeviceLogging()) {
-      this.log.error(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
+      this.log.error(`${this.device.deviceType}: ${this.accessory.displayName} `, String(...log));
     }
   }
 
   async debugErrorLog(...log: any[]): Promise<void> {
     if (await this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
-        this.log.error(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
+        this.log.error(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName} `, String(...log));
       }
     }
   }
@@ -890,9 +890,9 @@ export abstract class deviceBase {
   async debugLog(...log: any[]): Promise<void> {
     if (await this.enablingDeviceLogging()) {
       if (this.deviceLogging === 'debug') {
-        this.log.info(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
+        this.log.info(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName} `, String(...log));
       } else {
-        this.log.debug(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log));
+        this.log.debug(`${this.device.deviceType}: ${this.accessory.displayName} `, String(...log));
       }
     }
   }

package/src/device/fan.ts

@@ -339,7 +339,7 @@ export class Fan extends deviceBase {
   async registerWebhook() {
     if (this.device.webhook) {
       await this.debugLog('is listening webhook.');
-      this.platform.webhookEventHandler[this.device.deviceId] = async (context: batteryCirculatorFanWebhookContext) => {
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
         try {
           await this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
           await this.parseStatusWebhook(context);

package/src/device/waterdetector.ts

@@ -106,11 +106,10 @@ export class WaterDetector extends deviceBase {
     }
 
     // Retrieve initial values and updateHomekit
-    this.debugLog('retrieve initial values and Update Homekit');
     this.refreshStatus();
 
     // Retrieve initial values and updateHomekit
-    // this.updateHomeKitCharacteristics();
+    this.updateHomeKitCharacteristics();
 
     //regisiter webhook event handler
     this.registerWebhook();
@@ -119,7 +118,6 @@ export class WaterDetector extends deviceBase {
     interval(this.deviceRefreshRate * 1000)
       .pipe(skipWhile(() => this.WaterDetectorUpdateInProgress))
       .subscribe(async () => {
-        await this.debugLog(`update interval: ${this.deviceRefreshRate * 1000} seconds`);
         await this.refreshStatus();
       });
   }
@@ -147,7 +145,7 @@ export class WaterDetector extends deviceBase {
     await this.debugLog('openAPIparseStatus');
     if (!this.device.waterdetector?.hide_leak && this.LeakSensor?.Service) {
       // StatusActive
-      this.LeakSensor.StatusActive = deviceStatus.battery === 0 ? false : true;
+      this.LeakSensor.StatusActive = deviceStatus.status ? true : false;
       await this.debugLog(`StatusActive: ${this.LeakSensor.StatusActive}`);
       // LeakDetected
       this.LeakSensor.LeakDetected = deviceStatus.status;
@@ -162,7 +160,7 @@ export class WaterDetector extends deviceBase {
     await this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`);
     // FirmwareVersion
     const version = deviceStatus.version.toString();
-    await this.debugLog(`FirmwareVersion: ${version.replace(/^V|-.*$/g, '')}`);
+    await this.debugLog(`Firmware Version: ${version.replace(/^V|-.*$/g, '')}`);
     if (deviceStatus.version) {
       const deviceVersion = version.replace(/^V|-.*$/g, '') ?? '0.0.0';
       this.accessory

package/src/irdevice/airconditioner.ts

@@ -28,7 +28,6 @@ export class AirConditioner extends irdeviceBase {
   };
 
   meter?: PlatformAccessory;
-
   private HumiditySensor?: {
     Name: CharacteristicValue;
     Service: Service;
@@ -182,7 +181,7 @@ export class AirConditioner extends irdeviceBase {
    * AirConditioner:        "command"       "highSpeed"      "default"	        =        fan speed to high
    */
   async pushAirConditionerOnChanges(): Promise<void> {
-    await this.debugLog(`pushAirConditionerOnChanges Active: ${this.HeaterCooler.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges Active: ${this.HeaterCooler.Active},`
       + ` disablePushOn: ${this.disablePushOn}`);
     if (this.HeaterCooler.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -197,7 +196,7 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async pushAirConditionerOffChanges(): Promise<void> {
-    await this.debugLog(`pushAirConditionerOffChanges Active: ${this.HeaterCooler.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges Active: ${this.HeaterCooler.Active},`
       + ` disablePushOff: ${this.disablePushOff}`);
     if (this.HeaterCooler.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOff) {
       const commandType: string = await this.commandType();
@@ -212,7 +211,7 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async pushAirConditionerStatusChanges(): Promise<void> {
-    await this.debugLog(`pushAirConditionerStatusChanges Active: ${this.HeaterCooler.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerStatusChanges Active: ${this.HeaterCooler.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     if (!this.Busy) {
       this.Busy = true;
@@ -225,7 +224,7 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async pushAirConditionerDetailsChanges(): Promise<void> {
-    await this.debugLog(`pushAirConditionerDetailsChanges Active: ${this.HeaterCooler.Active},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerDetailsChanges Active: ${this.HeaterCooler.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     //await this.deviceContext();
     if (this.CurrentMode === undefined) {
@@ -242,7 +241,7 @@ export class AirConditioner extends irdeviceBase {
     if (this.CurrentMode === 1) {
       // Remove or make configurable?
       this.HeaterCooler.ThresholdTemperature = 25;
-      await this.debugLog(`CurrentMode: ${this.CurrentMode},`
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentMode: ${this.CurrentMode},`
         + ` ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
     }
     const parameter = `${this.HeaterCooler.ThresholdTemperature},${this.CurrentMode},${this.CurrentFanSpeed},${this.state}`;
@@ -345,9 +344,9 @@ export class AirConditioner extends irdeviceBase {
   }
 
   async pushChanges(bodyChange: any): Promise<void> {
-    await this.debugLog('pushChanges');
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
     if (this.device.connectionType === 'OpenAPI' && !this.disablePushDetail) {
-      await this.infoLog(`Sending request to SwitchBot API, body: ${bodyChange},`);
+      this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
       try {
         const { body, statusCode } = await this.pushChangeRequest(bodyChange);
         const deviceStatus: any = await body.json();
@@ -364,33 +363,35 @@ export class AirConditioner extends irdeviceBase {
         await this.pushChangeError(e);
       }
     } else {
-      await this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
-      await this.debugLog(`Connection Type: ${this.device.connectionType}, disablePushDetails: ${this.disablePushDetail}`);
-      await this.updateHomeKitCharacteristics();
+      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+        + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+        + ` Connection Type: ${this.device.connectionType}, disablePushDetails: ${this.disablePushDetail}`);
+      this.updateHomeKitCharacteristics();
     }
   }
 
   async CurrentTemperatureGet(): Promise<CharacteristicValue> {
     if (this.meter?.context?.CurrentTemperature) {
       this.accessory.context.CurrentTemperature = this.meter.context.CurrentTemperature;
-      await this.debugLog(''
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} `
         + `Using CurrentTemperature from ${this.meter.context.deviceType} (${this.meter.context.deviceID})`);
     }
 
     this.HeaterCooler.CurrentTemperature = this.accessory.context.CurrentTemperature || 24;
-    await this.debugLog(`Get CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
     return this.HeaterCooler.CurrentTemperature;
   }
 
   async CurrentRelativeHumidityGet(): Promise<CharacteristicValue> {
     if (this.meter?.context?.CurrentRelativeHumidity) {
       this.accessory.context.CurrentRelativeHumidity = this.meter.context.CurrentRelativeHumidity;
-      await this.debugLog(''
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} `
         + `Using CurrentRelativeHumidity from ${this.meter.context.deviceType} (${this.meter.context.deviceID})`);
     }
 
     this.HumiditySensor!.CurrentRelativeHumidity = this.accessory.context.CurrentRelativeHumidity || 0;
-    await this.debugLog('Get'
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get`
       + ` CurrentRelativeHumidity: ${this.HumiditySensor!.CurrentRelativeHumidity}`);
     return this.HumiditySensor!.CurrentRelativeHumidity as CharacteristicValue;
   }
@@ -401,7 +402,7 @@ export class AirConditioner extends irdeviceBase {
     } else {
       this.HeaterCooler.RotationSpeed = this.CurrentFanSpeed - 1;
     }
-    await this.debugLog(`Get RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
     return this.HeaterCooler.RotationSpeed;
   }
 
@@ -412,23 +413,24 @@ export class AirConditioner extends irdeviceBase {
       this.CurrentFanSpeed = Number(value) + 1;
     }
     this.HeaterCooler.RotationSpeed = value;
-    await this.debugLog(`Set RotationSpeed: ${this.HeaterCooler.RotationSpeed}, CurrentFanSpeed: ${this.CurrentFanSpeed}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+      + `Set RotationSpeed: ${this.HeaterCooler.RotationSpeed}, CurrentFanSpeed: ${this.CurrentFanSpeed}`);
     this.pushAirConditionerStatusChanges();
   }
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
-    await this.debugLog(`Set Active: ${value}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set Active: ${value}`);
 
     this.HeaterCooler.Active = value;
     if (this.HeaterCooler.Active === this.hap.Characteristic.Active.ACTIVE) {
-      await this.debugLog(`pushAirConditionerOnChanges, Active: ${this.HeaterCooler.Active}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges, Active: ${this.HeaterCooler.Active}`);
       if (this.disablePushOn) {
         this.pushAirConditionerStatusChanges();
       } else {
         this.pushAirConditionerOnChanges();
       }
     } else {
-      await this.debugLog(`pushAirConditionerOffChanges, Active: ${this.HeaterCooler.Active}`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.HeaterCooler.Active}`);
       this.pushAirConditionerOffChanges();
     }
   }
@@ -436,7 +438,7 @@ export class AirConditioner extends irdeviceBase {
   async TargetHeaterCoolerStateGet(): Promise<CharacteristicValue> {
     const targetState = this.HeaterCooler.TargetHeaterCoolerState || this.accessory.context.TargetHeaterCoolerState;
     this.HeaterCooler.TargetHeaterCoolerState = this.ValidValues.includes(targetState) ? targetState : this.ValidValues[0];
-    await this.debugLog(`Get (${this.getTargetHeaterCoolerStateName()}) TargetHeaterCoolerState:`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get (${this.getTargetHeaterCoolerStateName()}) TargetHeaterCoolerState:`
       + ` ${this.HeaterCooler.TargetHeaterCoolerState}, ValidValues: ${this.ValidValues},  hide_automode: ${this.hide_automode}`);
     return this.HeaterCooler.TargetHeaterCoolerState;
   }
@@ -449,7 +451,7 @@ export class AirConditioner extends irdeviceBase {
     } else if (value === this.hap.Characteristic.TargetHeaterCoolerState.COOL) {
       this.TargetHeaterCoolerStateCOOL();
     } else {
-      this.errorLog('Set TargetHeaterCoolerState: '
+      this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Set TargetHeaterCoolerState: `
         + `${this.HeaterCooler.TargetHeaterCoolerState}, hide_automode: ${this.hide_automode} `);
     }
     this.pushAirConditionerStatusChanges();
@@ -458,30 +460,31 @@ export class AirConditioner extends irdeviceBase {
   async TargetHeaterCoolerStateAUTO(): Promise<void> {
     this.HeaterCooler.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.AUTO;
     this.CurrentMode = 1;
-    await this.debugLog('Set (AUTO)'
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (AUTO)`
       + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
-    await this.debugLog(`Switchbot CurrentMode: ${this.CurrentMode}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
   async TargetHeaterCoolerStateCOOL(): Promise<void> {
     this.HeaterCooler.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.COOL;
     this.CurrentMode = 2;
-    await this.debugLog('Set (COOL)'
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (COOL)`
       + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
-    await this.debugLog(`Switchbot CurrentMode: ${this.CurrentMode}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
   async TargetHeaterCoolerStateHEAT(): Promise<void> {
     this.HeaterCooler.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.HEAT;
     this.CurrentMode = 5;
-    await this.debugLog('Set (HEAT)'
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (HEAT)`
       + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
-    await this.debugLog(`Switchbot CurrentMode: ${this.CurrentMode}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
   async CurrentHeaterCoolerStateGet(): Promise<CharacteristicValue> {
     await this.UpdateCurrentHeaterCoolerState();
-    await this.debugLog(`Get (${this.getTargetHeaterCoolerStateName()}) CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+      + ` Get (${this.getTargetHeaterCoolerStateName()}) CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
 
     return this.HeaterCooler.CurrentHeaterCoolerState;
   }
@@ -535,48 +538,89 @@ export class AirConditioner extends irdeviceBase {
         this.HumiditySensor!.CurrentRelativeHumidity = this.HumiditySensor!.CurrentRelativeHumidity || this.accessory.context.CurrentRelativeHumidity;
       }
     }
-    await this.debugLog(`Get ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
     return this.HeaterCooler.ThresholdTemperature;
   }
 
   async ThresholdTemperatureSet(value: CharacteristicValue): Promise<void> {
     this.HeaterCooler.ThresholdTemperature = value;
-    await this.debugLog(`Set ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature},`
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature},`
       + ` ThresholdTemperatureCached: ${this.accessory.context.ThresholdTemperature}`);
     this.pushAirConditionerStatusChanges();
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
-    await this.debugLog('updateHomeKitCharacteristics');
     // Active
-    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.Active,
-      this.HeaterCooler.Active, 'Active');
+    if (this.HeaterCooler.Active === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.HeaterCooler.Active}`);
+    } else {
+      this.accessory.context.Active = this.HeaterCooler.Active;
+      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.Active, this.HeaterCooler.Active);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.HeaterCooler.Active}`);
+    }
     // RotationSpeed
-    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.RotationSpeed,
-      this.HeaterCooler.RotationSpeed, 'RotationSpeed');
+    if (this.HeaterCooler.RotationSpeed === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
+    } else {
+      this.accessory.context.RotationSpeed = this.HeaterCooler.RotationSpeed;
+      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.RotationSpeed, this.HeaterCooler.RotationSpeed);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+        + ` RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
+    }
     // CurrentTemperature
-    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.CurrentTemperature,
-      this.HeaterCooler.CurrentTemperature, 'CurrentTemperature');
+    if (this.HeaterCooler.CurrentTemperature === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
+    } else {
+      this.accessory.context.CurrentTemperature = this.HeaterCooler.CurrentTemperature;
+      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.HeaterCooler.CurrentTemperature);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+        + ` CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
+    }
+    // CurrentRelativeHumidity
+    if (this.meter) {
+      if (this.HumiditySensor!.CurrentRelativeHumidity === undefined) {
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+          + ` CurrentRelativeHumidity: ${this.HumiditySensor!.CurrentRelativeHumidity}`);
+      } else {
+        this.accessory.context.CurrentRelativeHumidity = this.HumiditySensor!.CurrentRelativeHumidity;
+        this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity,
+          this.HumiditySensor!.CurrentRelativeHumidity);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+          + ` CurrentRelativeHumidity: ${this.HumiditySensor!.CurrentRelativeHumidity}`);
+      }
+    }
     // TargetHeaterCoolerState
-    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.TargetHeaterCoolerState,
-      this.HeaterCooler.TargetHeaterCoolerState, 'TargetHeaterCoolerState');
+    if (this.HeaterCooler.TargetHeaterCoolerState === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
+    } else {
+      this.accessory.context.TargetHeaterCoolerState = this.HeaterCooler.TargetHeaterCoolerState;
+      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState, this.HeaterCooler.TargetHeaterCoolerState);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+        + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
+    }
     // CurrentHeaterCoolerState
-    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.CurrentHeaterCoolerState,
-      this.HeaterCooler.CurrentHeaterCoolerState, 'CurrentHeaterCoolerState');
-    // HeatingThresholdTemperature
-    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.HeatingThresholdTemperature,
-      this.HeaterCooler.ThresholdTemperature, 'ThresholdTemperature');
-    // CoolingThresholdTemperature
-    await this.updateCharacteristic(this.HeaterCooler.Service, this.hap.Characteristic.CoolingThresholdTemperature,
-      this.HeaterCooler.ThresholdTemperature, 'ThresholdTemperature');
-    if (this.meter && this.HumiditySensor?.Service) {
-      // CurrentRelativeHumidity
-      await this.updateCharacteristic(this.HumiditySensor.Service, this.hap.Characteristic.CurrentRelativeHumidity,
-        this.HumiditySensor.CurrentRelativeHumidity, 'CurrentRelativeHumidity');
+    if (this.HeaterCooler.CurrentHeaterCoolerState === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+        + ` CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
+    } else {
+      this.accessory.context.CurrentHeaterCoolerState = this.HeaterCooler.CurrentHeaterCoolerState;
+      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.HeaterCooler.CurrentHeaterCoolerState);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+        + ` updateCharacteristic CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
+    }
+    // ThresholdTemperature
+    if (this.HeaterCooler.ThresholdTemperature === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
+    } else {
+      this.accessory.context.ThresholdTemperature = this.HeaterCooler.ThresholdTemperature;
+      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature, this.HeaterCooler.ThresholdTemperature);
+      this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature, this.HeaterCooler.ThresholdTemperature);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+        + ` ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
     }
   }
 
-  async apiError(e: any): Promise<void> {
+  async apiError({ e }: { e: any }): Promise<void> {
     this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.Active, e);
     this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.RotationSpeed, e);
     this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, e);