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

package/src/device/colorbulb.ts

@@ -200,7 +200,8 @@ export class ColorBulb extends deviceBase {
     this.LightBulb.Saturation = saturation;
     await this.debugLog(`Saturation: ${this.LightBulb.Saturation}`);
     // ColorTemperature
-    this.LightBulb.ColorTemperature = Math.max(Math.min(serviceData.color_temperature, 500), 140);
+    const miredColorTemperature = Math.round(1000000 / serviceData.color_temperature);
+    this.LightBulb.ColorTemperature = Math.max(Math.min(miredColorTemperature, 500), 140);
     await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
   }
 
@@ -209,35 +210,28 @@ 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, '')}`);
@@ -278,7 +272,8 @@ export class ColorBulb extends deviceBase {
     this.LightBulb.Saturation = saturation;
     await this.debugLog(`Saturation: ${this.LightBulb.Saturation}`);
     // ColorTemperature
-    this.LightBulb.ColorTemperature = context.colorTemperature;
+    const miredColorTemperature = Math.round(1000000 / context.colorTemperature);
+    this.LightBulb.ColorTemperature = Math.max(Math.min(miredColorTemperature, 500), 140);
     await this.debugLog(`ColorTemperature: ${this.LightBulb.ColorTemperature}`);
   }
 
@@ -489,6 +484,8 @@ 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) {
@@ -496,7 +493,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(this.LightBulb.ColorTemperature);
+            return await device_list[0].setColorTemperature(kelvin);
           })
           .then(async () => {
             await this.successLog(`ColorTemperature: ${this.LightBulb.ColorTemperature} sent over SwitchBot BLE,  sent successfully`);

package/src/irdevice/airconditioner.ts

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

package/src/irdevice/airpurifier.ts

@@ -23,6 +23,7 @@ export class AirPurifier extends irdeviceBase {
     RotationSpeed: CharacteristicValue;
     CurrentAirPurifierState: CharacteristicValue;
     TargetAirPurifierState: CharacteristicValue;
+    CurrentHeaterCoolerState: CharacteristicValue;
   };
 
   private TemperatureSensor: {
@@ -36,7 +37,6 @@ export class AirPurifier extends irdeviceBase {
   CurrentAPTemp!: CharacteristicValue;
   CurrentAPMode!: CharacteristicValue;
   CurrentAPFanSpeed!: CharacteristicValue;
-  CurrentHeaterCoolerState!: CharacteristicValue;
 
   // Others
   Busy: any;
@@ -64,6 +64,7 @@ export class AirPurifier extends irdeviceBase {
       RotationSpeed: accessory.context.RotationSpeed ?? 0,
       CurrentAirPurifierState: accessory.context.CurrentAirPurifierState ?? this.hap.Characteristic.CurrentAirPurifierState.INACTIVE,
       TargetAirPurifierState: accessory.context.TargetAirPurifierState ?? this.hap.Characteristic.TargetAirPurifierState.AUTO,
+      CurrentHeaterCoolerState: accessory.context.CurrentHeaterCoolerState ?? this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE,
     };
     accessory.context.AirPurifier = this.AirPurifier as object;
 
@@ -106,7 +107,7 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set Active: ${value}`);
+    await this.debugLog(`Set Active: ${value}`);
 
     this.AirPurifier.Active = value;
     if (this.AirPurifier.Active === this.hap.Characteristic.Active.ACTIVE) {
@@ -153,7 +154,7 @@ export class AirPurifier extends irdeviceBase {
    * AirPurifier:        "command"       "highSpeed"      "default"	        =        fan speed to high
    */
   async pushAirPurifierOnChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierOnChanges Active: ${this.AirPurifier.Active},`
+    await this.debugLog(`pushAirPurifierOnChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOn: ${this.disablePushOn}`);
     if (this.AirPurifier.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -168,7 +169,7 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async pushAirPurifierOffChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierOffChanges Active: ${this.AirPurifier.Active},`
+    await this.debugLog(`pushAirPurifierOffChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOff: ${this.disablePushOff}`);
     if (this.AirPurifier.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -183,11 +184,11 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async pushAirPurifierStatusChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierStatusChanges Active: ${this.AirPurifier.Active},`
+    await this.debugLog(`pushAirPurifierStatusChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     if (!this.Busy) {
       this.Busy = true;
-      this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
+      this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
     }
     clearTimeout(this.Timeout);
 
@@ -196,7 +197,7 @@ export class AirPurifier extends irdeviceBase {
   }
 
   async pushAirPurifierDetailsChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirPurifierDetailsChanges Active: ${this.AirPurifier.Active},`
+    await this.debugLog(`pushAirPurifierDetailsChanges Active: ${this.AirPurifier.Active},`
       + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     this.CurrentAPTemp = this.TemperatureSensor!.CurrentTemperature ?? 24;
     this.CurrentAPMode = this.CurrentMode ?? 1;
@@ -210,20 +211,20 @@ export class AirPurifier extends irdeviceBase {
     });
     if (this.AirPurifier.Active === 1) {
       if ((Number(this.TemperatureSensor!.CurrentTemperature) || 24) < (this.LastTemperature || 30)) {
-        this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
+        this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
       } else {
-        this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
+        this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
       }
     } else {
-      this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE;
+      this.AirPurifier.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE;
     }
     await this.pushChanges(bodyChange);
   }
 
   async pushChanges(bodyChange: any): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
+    await this.debugLog('pushChanges');
     if (this.device.connectionType === 'OpenAPI') {
-      this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+      this.infoLog(`Sending request to SwitchBot API, body: ${bodyChange},`);
       try {
         const { body, statusCode } = await this.pushChangeRequest(bodyChange);
         const deviceStatus: any = await body.json();
@@ -240,47 +241,24 @@ export class AirPurifier extends irdeviceBase {
         await this.pushChangeError(e);
       }
     } else {
-      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+      this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
     }
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
+    await this.debugLog('updateHomeKitCharacteristics');
     // Active
-    if (this.AirPurifier.Active === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.AirPurifier.Active}`);
-    } else {
-      this.accessory.context.Active = this.AirPurifier.Active;
-      this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.Active, this.AirPurifier.Active);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.AirPurifier.Active}`);
-    }
+    await this.updateCharacteristic(this.AirPurifier.Service, this.hap.Characteristic.Active,
+      this.AirPurifier.Active, 'Active');
     // CurrentAirPurifierState
-    if (this.AirPurifier.CurrentAirPurifierState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentAirPurifierState: ${this.AirPurifier.CurrentAirPurifierState}`);
-    } else {
-      this.accessory.context.CurrentAirPurifierState = this.AirPurifier.CurrentAirPurifierState;
-      this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentAirPurifierState, this.AirPurifier.CurrentAirPurifierState);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` CurrentAirPurifierState: ${this.AirPurifier.CurrentAirPurifierState}`);
-    }
+    await this.updateCharacteristic(this.AirPurifier.Service, this.hap.Characteristic.CurrentAirPurifierState,
+      this.AirPurifier.CurrentAirPurifierState, 'CurrentAirPurifierState');
     // CurrentHeaterCoolerState
-    if (this.CurrentHeaterCoolerState === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
-    } else {
-      this.accessory.context.CurrentHeaterCoolerState = this.CurrentHeaterCoolerState;
-      this.AirPurifier.Service.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
-    }
+    await this.updateCharacteristic(this.AirPurifier.Service, this.hap.Characteristic.CurrentHeaterCoolerState,
+      this.AirPurifier.CurrentHeaterCoolerState, 'CurrentHeaterCoolerState');
     // CurrentTemperature
-    if (this.TemperatureSensor.CurrentTemperature === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
-    } else {
-      this.accessory.context.CurrentTemperature = this.TemperatureSensor.CurrentTemperature;
-      this.TemperatureSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.TemperatureSensor.CurrentTemperature);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`);
-    }
+    await this.updateCharacteristic(this.TemperatureSensor.Service, this.hap.Characteristic.CurrentTemperature,
+      this.TemperatureSensor.CurrentTemperature, 'CurrentTemperature');
   }
 
   async apiError(e: any): Promise<void> {

package/src/irdevice/camera.ts

@@ -48,7 +48,7 @@ export class Camera extends irdeviceBase {
   }
 
   async OnSet(value: CharacteristicValue): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${value}`);
+    await this.debugLog(`On: ${value}`);
 
     this.Switch.On = value;
     if (this.Switch.On) {
@@ -69,7 +69,7 @@ export class Camera extends irdeviceBase {
    * Camera -        "command"       "channelSub"      "default"	        =        previous channel
    */
   async pushOnChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushOnChanges On: ${this.Switch.On},`
+    await this.debugLog(`pushOnChanges On: ${this.Switch.On},`
       + ` disablePushOn: ${this.disablePushOn}`);
     if (this.Switch.On && !this.disablePushOn) {
       const commandType: string = await this.commandType();
@@ -84,7 +84,7 @@ export class Camera extends irdeviceBase {
   }
 
   async pushOffChanges(): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushOffChanges On: ${this.Switch.On},`
+    await this.debugLog(`pushOffChanges On: ${this.Switch.On},`
       + ` disablePushOff: ${this.disablePushOff}`);
     if (!this.Switch.On && !this.disablePushOff) {
       const commandType: string = await this.commandType();
@@ -99,9 +99,9 @@ export class Camera extends irdeviceBase {
   }
 
   async pushChanges(bodyChange: any): Promise<void> {
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
+    await this.debugLog('pushChanges');
     if (this.device.connectionType === 'OpenAPI') {
-      this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+      this.infoLog(`Sending request to SwitchBot API, body: ${bodyChange},`);
       try {
         const { body, statusCode } = await this.pushChangeRequest(bodyChange);
         const deviceStatus: any = await body.json();
@@ -118,19 +118,19 @@ export class Camera extends irdeviceBase {
         await this.pushChangeError(e);
       }
     } else {
-      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+      await this.warnLog(`Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
     }
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
+    await this.debugLog('updateHomeKitCharacteristics');
     // On
     if (this.Switch.On === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.Switch.On}`);
+      await this.debugLog(`On: ${this.Switch.On}`);
     } else {
       this.accessory.context.On = this.Switch.On;
       this.Switch.Service.updateCharacteristic(this.hap.Characteristic.On, this.Switch.On);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic On: ${this.Switch.On}`);
+      await this.debugLog(`updateCharacteristic On: ${this.Switch.On}`);
     }
   }