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

package/src/device/curtain.ts

@@ -336,75 +336,48 @@ export class Curtain extends deviceBase {
       const set_maxLux = this.device.curtain?.set_maxLux ?? 6001;
       const spaceBetweenLevels = 9;
 
-      serviceData.lightLevel = 1;
       // Brightness
       switch (serviceData.lightLevel) {
         case 1:
-          this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * (serviceData.lightLevel === 1
-            ? set_minLux : 2);
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 1 LightLevel: ${serviceData.lightLevel},`
-        + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
           this.LightSensor!.CurrentAmbientLightLevel = set_minLux;
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 2 LightLevel: ${serviceData.lightLevel},`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
           break;
         case 2:
-          this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * (Number(serviceData.lightLevel) - 1);
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 1 LightLevel: ${serviceData.lightLevel},`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
           this.LightSensor!.CurrentAmbientLightLevel = (set_maxLux - set_minLux) / spaceBetweenLevels;
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 2 LightLevel: ${serviceData.lightLevel},`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 3 LightLevel: ${serviceData.lightLevel},`
-            + ` Calculation: ${(set_maxLux - set_minLux) / spaceBetweenLevels}`);
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel},`
+          + ` Calculation: ${(set_maxLux - set_minLux) / spaceBetweenLevels}`);
           break;
         case 3:
-          this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * (Number(serviceData.lightLevel) - 1);
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 1 LightLevel: ${serviceData.lightLevel},`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 2;
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 2 LightLevel: ${serviceData.lightLevel},`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
-          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
           break;
         case 4:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 3;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 5:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 4;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 6:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 5;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 7:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 6;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 8:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 7;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 9:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 8;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
-          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 10:
         default:
-          this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * (Number(serviceData.lightLevel) - 1);
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 1 LightLevel: ${serviceData.lightLevel},`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
           this.LightSensor!.CurrentAmbientLightLevel = set_maxLux;
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 2 LightLevel: ${serviceData.lightLevel},`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
           this.debugLog();
       }
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel},`
@@ -559,9 +532,8 @@ export class Curtain extends deviceBase {
         await this.statusCodes(statusCode, deviceStatus);
       }
     } catch (e: any) {
-      this.apiError(e);
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+      await this.apiError(e);
+      await this.openAPIRefreshError(e);
     }
   }
 
@@ -596,8 +568,7 @@ export class Curtain extends deviceBase {
       await this.openAPIpushChanges();
     } else {
       await this.offlineOff();
-      this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-        + ` ${this.device.connectionType}, pushChanges will not happen.`);
+      await this.pushChangeDisabled();
     }
     // Refresh the status from the API
     interval(15000)
@@ -714,26 +685,27 @@ export class Curtain extends deviceBase {
     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.HoldPosition, this.WindowCovering.HoldPosition);
 
     this.WindowCovering.TargetPosition = value;
-    if (this.device.mqttURL) {
-      this.mqttPublish('TargetPosition', this.WindowCovering.TargetPosition.toString());
-      this.mqttPublish('HoldPosition', this.WindowCovering.HoldPosition.toString()); // Convert boolean to string
-    }
+    await this.mqtt('TargetPosition', this.WindowCovering.TargetPosition);
+    await this.mqtt('HoldPosition', this.WindowCovering.HoldPosition);
+    await this.startUpdatingCurtainIfNeeded();
+  }
 
+  async startUpdatingCurtainIfNeeded() {
     await this.setMinMax();
-    if (value > this.WindowCovering.CurrentPosition) {
+    if (this.WindowCovering.TargetPosition > this.WindowCovering.CurrentPosition) {
       this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.INCREASING;
       this.setNewTarget = true;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${value},`
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.WindowCovering.TargetPosition},`
         + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
-    } else if (value < this.WindowCovering.CurrentPosition) {
+    } else if (this.WindowCovering.TargetPosition < this.WindowCovering.CurrentPosition) {
       this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.DECREASING;
       this.setNewTarget = true;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${value},`
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.WindowCovering.TargetPosition},`
         + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
     } else {
       this.WindowCovering.PositionState = this.hap.Characteristic.PositionState.STOPPED;
       this.setNewTarget = false;
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${value},`
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.WindowCovering.TargetPosition},`
         + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
     }
     this.WindowCovering.Service.setCharacteristic(this.hap.Characteristic.PositionState, this.WindowCovering.PositionState);
@@ -765,102 +737,33 @@ export class Curtain extends deviceBase {
 
   async updateHomeKitCharacteristics(): Promise<void> {
     await this.setMinMax();
-    if (this.WindowCovering.CurrentPosition === undefined || Number.isNaN(this.WindowCovering.CurrentPosition)) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
-    } else {
-      this.accessory.context.CurrentPosition = this.WindowCovering.CurrentPosition;
-      this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, Number(this.WindowCovering.CurrentPosition));
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
-      if (this.device.mqttURL) {
-        this.mqttPublish('CurrentPosition', this.WindowCovering.CurrentPosition.toString()); // Convert to string
-      }
-    }
-    if (this.WindowCovering.PositionState === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} PositionState: ${this.WindowCovering.PositionState}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('PositionState', this.WindowCovering.PositionState.toString());
-      }
-      this.accessory.context.PositionState = this.WindowCovering.PositionState;
-      this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.PositionState, Number(this.WindowCovering.PositionState));
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` PositionState: ${this.WindowCovering.PositionState}`);
-    }
-    if (this.WindowCovering.TargetPosition === undefined || Number.isNaN(this.WindowCovering.TargetPosition)) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} TargetPosition: ${this.WindowCovering.TargetPosition}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('TargetPosition', this.WindowCovering.TargetPosition.toString());
-      }
-      this.accessory.context.TargetPosition = this.WindowCovering.TargetPosition;
-      this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, Number(this.WindowCovering.TargetPosition));
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` TargetPosition: ${this.WindowCovering.TargetPosition}`);
-    }
-    if (this.WindowCovering.HoldPosition === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} HoldPosition: ${this.WindowCovering.HoldPosition}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('HoldPosition', this.WindowCovering.HoldPosition.toString());
-      }
-      this.accessory.context.HoldPosition = this.WindowCovering.HoldPosition;
-      this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.HoldPosition, this.WindowCovering.HoldPosition);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` HoldPosition: ${this.WindowCovering.HoldPosition}`);
-    }
-    if (!this.device.curtain?.hide_lightsensor) {
-      if (this.LightSensor!.CurrentAmbientLightLevel === undefined || Number.isNaN(this.LightSensor!.CurrentAmbientLightLevel)) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
-      } else {
-        if (this.device.mqttURL) {
-          this.mqttPublish('CurrentAmbientLightLevel', this.LightSensor!.CurrentAmbientLightLevel.toString());
-        }
-        this.accessory.context.CurrentAmbientLightLevel = this.LightSensor!.CurrentAmbientLightLevel;
-        this.LightSensor!.Service.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, this.LightSensor!.CurrentAmbientLightLevel);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-          + ` updateCharacteristic CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
-        if (this.device.history) {
-          this.historyService?.addEntry({
-            time: Math.round(new Date().valueOf() / 1000),
-            lux: this.LightSensor!.CurrentAmbientLightLevel,
-          });
-        }
-      }
-    }
-    if (this.Battery.BatteryLevel === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('BatteryLevel', this.Battery.BatteryLevel.toString());
-      }
-      this.accessory.context.BatteryLevel = this.Battery.BatteryLevel;
-      this.Battery.Service.updateCharacteristic(this.hap.Characteristic.BatteryLevel, this.Battery.BatteryLevel);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic BatteryLevel: ${this.Battery.BatteryLevel}`);
-    }
-    if (this.Battery.StatusLowBattery === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} StatusLowBattery: ${this.Battery.StatusLowBattery}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('StatusLowBattery', this.Battery.StatusLowBattery.toString());
-      }
-      this.accessory.context.StatusLowBattery = this.Battery.StatusLowBattery;
-      this.Battery.Service.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, this.Battery.StatusLowBattery);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
-    }
-    if (this.Battery.ChargingState === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ChargingState: ${this.Battery.ChargingState}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('ChargingState', this.Battery.ChargingState.toString());
-      }
-      this.accessory.context.ChargingState = this.Battery.ChargingState;
-      this.Battery.Service.updateCharacteristic(this.hap.Characteristic.ChargingState, this.Battery.ChargingState);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` ChargingState: ${this.Battery.ChargingState}`);
+    // CurrentPosition
+    await this.updateCharacteristic(this.WindowCovering.Service, this.hap.Characteristic.CurrentPosition,
+      this.WindowCovering.CurrentPosition, 'CurrentPosition');
+    // PositionState
+    await this.updateCharacteristic(this.WindowCovering.Service, this.hap.Characteristic.PositionState,
+      this.WindowCovering.PositionState, 'PositionState');
+    // TargetPosition
+    await this.updateCharacteristic(this.WindowCovering.Service, this.hap.Characteristic.TargetPosition,
+      this.WindowCovering.TargetPosition, 'TargetPosition');
+    // HoldPosition
+    await this.updateCharacteristic(this.WindowCovering.Service, this.hap.Characteristic.HoldPosition,
+      this.WindowCovering.HoldPosition, 'HoldPosition');
+    // CurrentAmbientLightLevel
+    if (!this.device.curtain?.hide_lightsensor && this.LightSensor?.Service) {
+      const history = { time: Math.round(new Date().valueOf() / 1000), lux: this.LightSensor.CurrentAmbientLightLevel };
+      await this.updateCharacteristic(this.LightSensor?.Service, this.hap.Characteristic.CurrentAmbientLightLevel,
+        this.LightSensor?.CurrentAmbientLightLevel, 'CurrentAmbientLightLevel', history);
     }
+    // BatteryLevel
+    await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.BatteryLevel,
+      this.Battery.BatteryLevel, 'BatteryLevel');
+    // StatusLowBattery
+    await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.StatusLowBattery,
+      this.Battery.StatusLowBattery, 'StatusLowBattery');
+    // ChargingState
+    await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.ChargingState,
+      this.Battery.ChargingState, 'ChargingState');
   }
 
   async BLEPushConnection() {

package/src/device/device.ts

@@ -11,7 +11,7 @@ import { BlindTiltMappingMode, SwitchBotModel, SwitchBotBLEModel, SwitchBotBLEMo
 
 import type { MqttClient } from 'mqtt';
 import type { SwitchBotPlatform } from '../platform.js';
-import type { API, HAP, Logging, PlatformAccessory } from 'homebridge';
+import type { API, CharacteristicValue, HAP, Logging, PlatformAccessory, Service } from 'homebridge';
 import type { ad, device, serviceData, SwitchBotPlatformConfig, devicesConfig, deviceStatus } from '../settings.js';
 
 export abstract class deviceBase {
@@ -384,6 +384,7 @@ export abstract class deviceBase {
   }
 
   async monitorAdvertisementPackets(switchbot: any) {
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Scanning for ${this.device.bleModelName} devices...`);
     await switchbot.startScan({ model: this.device.bleModel, id: this.device.bleMac });
     // Set an event handler
     let serviceData: serviceData = { model: this.device.bleModel, modelName: this.device.bleModelName } as serviceData;
@@ -423,6 +424,32 @@ export abstract class deviceBase {
     }
   }
 
+  async successfulPushChange_BLE(Characteristic: string, CharacteristicValue: CharacteristicValue, Connection: string) {
+    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} ${Characteristic}: ${CharacteristicValue}`
+      + ` sent over ${Connection}, sent successfully`);
+  }
+
+  async successfulPushChange(statusCode: any, deviceStatus: any, bodyChange: string) {
+    this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode} & deviceStatus`
+      + ` StatusCode: ${deviceStatus.statusCode}`);
+    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} request to SwitchBot API,`
+      + ` body: ${JSON.stringify(JSON.parse(bodyChange))} sent successfully`);
+  }
+
+  async failedBLEChanges(e: Error): Promise<void> {
+    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
+      + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+  }
+
+  async bodyChange(bodyChange: string, Connection: string) {
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to ${Connection}, body: ${bodyChange},`);
+  }
+
+  async pushChangeDisabled() {
+    this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
+      + ` ${this.device.connectionType}, pushChanges will not happen.`);
+  }
+
   async pushChangeRequest(bodyChange: string): Promise<{ body: any; statusCode: any; }> {
     return await request(`${Devices}/${this.device.deviceId}/commands`, {
       body: bodyChange,
@@ -431,16 +458,28 @@ export abstract class deviceBase {
     });
   }
 
-  async successfulPushChange(statusCode: any, deviceStatus: any, bodyChange: string) {
-    this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} statusCode: ${statusCode} & deviceStatus`
-      + ` StatusCode: ${deviceStatus.statusCode}`);
-    this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} request to SwitchBot API,`
-      + ` body: ${JSON.stringify(JSON.parse(bodyChange))} sent successfully`);
+  async pushChange(pushChange: string) {
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ${pushChange}`);
+  }
+
+  async pushChangeError(Change: string, e: Error) {
+    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed ${Change} with ${this.device.connectionType}`
+      + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+  }
+
+  async noChanges(Change: string, CharacteristicValue: CharacteristicValue, CharacteristicValueCached: CharacteristicValue) {
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, ${Change}: ${CharacteristicValue}, `
+      + `${Change}Cached: ${CharacteristicValueCached}`);
   }
 
   async successfulRefreshStatus(statusCode: any, deviceStatus: any) {
     this.debugSuccessLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-          + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
+      + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
+  }
+
+  async openAPIRefreshError(e: Error) {
+    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
+      + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
   }
 
   async statusCodes(statusCode: any, deviceStatus: any) {
@@ -466,6 +505,49 @@ export abstract class deviceBase {
       `${Devices}/${this.device.deviceId}/status`, { headers: this.platform.generateHeaders() });
   }
 
+  /**
+  * Update the characteristic value and log the change.
+  * params: Service, Characteristic, CharacteristicValue, CharacteristicName, history
+  * @param Service: Service
+  * @param Characteristic: Characteristic
+  * @param CharacteristicValue: CharacteristicValue | undefined
+  * @param CharacteristicName: string
+  * @param history: object
+  * @return: void
+  *
+  */
+  async updateCharacteristic(Service: Service, Characteristic: any,
+    CharacteristicValue: CharacteristicValue | undefined, CharacteristicName: string, history?: object): Promise<void> {
+    if (CharacteristicValue === undefined) {
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ${CharacteristicName}: ${CharacteristicValue}`);
+    } else {
+      await this.mqtt(CharacteristicName, CharacteristicValue);
+      if (this.device.history) {
+        this.historyService?.addEntry(history);
+      }
+      Service.updateCharacteristic(Characteristic, CharacteristicValue);
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
+        + ` ${CharacteristicName}: ${CharacteristicValue}`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} context before: ${this.accessory.context[CharacteristicName]}`);
+      this.accessory.context[CharacteristicName] = CharacteristicValue;
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} context after: ${this.accessory.context[CharacteristicName]}`);
+    }
+  }
+
+  async mqtt(CharacteristicName: string, CharacteristicValue: CharacteristicValue) {
+    if (this.device.mqttURL) {
+      this.mqttPublish(CharacteristicName, CharacteristicValue.toString());
+    }
+  }
+
+  async noChangeSet(value: CharacteristicValue, CharacteristicName: string) {
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set ${CharacteristicName}: ${value}`);
+  }
+
+  async changeSet(value: CharacteristicValue, CharacteristicName: string) {
+    this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set ${CharacteristicName}: ${value}`);
+  }
+
   async getDeviceContext(accessory: PlatformAccessory, device: device & devicesConfig): Promise<void> {
     // Set the accessory context
     switch (device.deviceType) {

package/src/device/fan.ts

@@ -265,9 +265,9 @@ export class Fan extends deviceBase {
     if (switchbot === undefined) {
       await this.BLERefreshConnection(switchbot);
     } else {
-    // Start to monitor advertisement packets
-      (async () => {
       // Start to monitor advertisement packets
+      (async () => {
+        // Start to monitor advertisement packets
         const serviceData: serviceData = await this.monitorAdvertisementPackets(switchbot);
         // Update HomeKit
         if (serviceData.model !== '' && serviceData.modelName !== '') {
@@ -295,9 +295,8 @@ export class Fan extends deviceBase {
         await this.statusCodes(statusCode, deviceStatus);
       }
     } catch (e: any) {
-      this.apiError(e);
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+      await this.apiError(e);
+      await this.openAPIRefreshError(e);
     }
   }
 
@@ -370,8 +369,7 @@ export class Fan extends deviceBase {
       await this.openAPIpushChanges();
     } else {
       await this.offlineOff();
-      this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-        + ` ${this.device.connectionType}, pushChanges will not happen.`);
+      await this.pushChangeDisabled();
     }
     // Refresh the status from the API
     interval(15000)
@@ -405,16 +403,13 @@ export class Fan extends deviceBase {
             },
           });
         })
-        .then(() => {
-          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Done.`);
-          this.successLog(`${this.device.deviceType}: ${this.accessory.displayName} `
-            + `Active: ${this.Fan.Active} sent over BLE,  sent successfully`);
-          this.Fan.Active = false;
+        .then(async () => {
+          await this.successfulPushChange_BLE('Active', this.Fan.Active, 'BLE API');
+          await this.updateHomeKitCharacteristics();
         })
         .catch(async (e: any) => {
-          this.apiError(e);
-          this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
-            + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+          await this.apiError(e);
+          await this.pushChangeError('BLEpushChanges', e);
           await this.BLEPushConnection();
         });
     } else {
@@ -451,8 +446,7 @@ export class Fan extends deviceBase {
         }
       } catch (e: any) {
         this.apiError(e);
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIpushChanges with ${this.device.connectionType}`
-          + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+        await this.pushChangeError('openAPIpushChanges', e);
       }
     } else {
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No openAPIpushChanges.`
@@ -469,14 +463,14 @@ export class Fan extends deviceBase {
   }
 
   async pushRotationSpeedChanges(): Promise<void> {
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushRotationSpeedChanges`);
+    await this.pushChange('pushRotationSpeedChanges');
     if (this.Fan.SwingMode !== this.accessory.context.SwingMode) {
       const bodyChange = JSON.stringify({
         command: 'setWindSpeed',
         parameter: `${this.Fan.RotationSpeed}`,
         commandType: 'command',
       });
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+      await this.bodyChange(bodyChange, 'SwitchBot OpenAPI');
       try {
         const { body, statusCode } = await this.pushChangeRequest(bodyChange);
         const deviceStatus: any = await body.json();
@@ -490,30 +484,23 @@ export class Fan extends deviceBase {
         }
       } catch (e: any) {
         this.apiError(e);
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushRotationSpeedChanges with ${this.device.connectionType}`
-          + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+        await this.pushChangeError('pushRotationSpeedChanges', e);
       }
     } else {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, pushRotationSpeedChanges: ${this.Fan.RotationSpeed}, `
-        + `pushRotationSpeedChangesCached: ${this.accessory.context.RotationSpeed}`);
+      await this.noChanges('RotationSpeed', this.Fan.RotationSpeed, this.accessory.context.RotationSpeed);
     }
   }
 
   async pushSwingModeChanges(): Promise<void> {
-    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} pushSwingModeChanges`);
+    await this.pushChange('pushSwingModeChanges');
     if (this.Fan.SwingMode !== this.accessory.context.SwingMode) {
-      let parameter = '';
-      if (this.Fan.SwingMode === this.hap.Characteristic.SwingMode.SWING_ENABLED) {
-        parameter = 'on';
-      } else {
-        parameter = 'off';
-      }
+      const parameter = this.Fan.SwingMode === this.hap.Characteristic.SwingMode.SWING_ENABLED ? 'on' : 'off';
       const bodyChange = JSON.stringify({
         command: 'setOscillation',
         parameter: `${parameter}`,
         commandType: 'command',
       });
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
+      await this.bodyChange(bodyChange, 'SwitchBot OpenAPI');
       try {
         const { body, statusCode } = await this.pushChangeRequest(bodyChange);
         const deviceStatus: any = await body.json();
@@ -527,12 +514,10 @@ export class Fan extends deviceBase {
         }
       } catch (e: any) {
         this.apiError(e);
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed pushSwingModeChanges with ${this.device.connectionType}`
-          + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+        await this.pushChangeError('pushSwingModeChanges', e);
       }
     } else {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, SwingMode: ${this.Fan.SwingMode}, `
-        + `SwingModeCached: ${this.accessory.context.SwingMode}`);
+      await this.noChanges('SwingMode', this.Fan.SwingMode, this.accessory.context.SwingMode);
     }
   }
 
@@ -540,10 +525,10 @@ export class Fan extends deviceBase {
    * Handle requests to set the value of the "On" characteristic
    */
   async ActiveSet(value: CharacteristicValue): Promise<void> {
-    if (this.Fan.Active === this.accessory.context.Active) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set Active: ${value}`);
+    if (this.Fan.Active !== this.accessory.context.Active) {
+      await this.changeSet(value, 'Active');
     } else {
-      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Active: ${value}`);
+      await this.noChangeSet(value, 'Active');
     }
 
     this.Fan.Active = value;
@@ -554,10 +539,10 @@ export class Fan extends deviceBase {
    * Handle requests to set the value of the "On" characteristic
    */
   async RotationSpeedSet(value: CharacteristicValue): Promise<void> {
-    if (this.Fan.RotationSpeed === this.accessory.context.RotationSpeed) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set RotationSpeed: ${value}`);
+    if (this.Fan.RotationSpeed !== this.accessory.context.RotationSpeed) {
+      await this.changeSet(value, 'RotationSpeed');
     } else {
-      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set RotationSpeed: ${value}`);
+      await this.noChangeSet(value, 'RotationSpeed');
     }
 
     this.Fan.RotationSpeed = value;
@@ -568,10 +553,10 @@ export class Fan extends deviceBase {
    * Handle requests to set the value of the "On" characteristic
    */
   async SwingModeSet(value: CharacteristicValue): Promise<void> {
-    if (this.Fan.SwingMode === this.accessory.context.SwingMode) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set SwingMode: ${value}`);
+    if (this.Fan.SwingMode !== this.accessory.context.SwingMode) {
+      await this.changeSet(value, 'SwingMode');
     } else {
-      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set SwingMode: ${value}`);
+      await this.noChangeSet(value, 'SwingMode');
     }
 
     this.Fan.SwingMode = value;
@@ -582,10 +567,10 @@ export class Fan extends deviceBase {
    * Handle requests to set the value of the "On" characteristic
    */
   async OnSet(value: CharacteristicValue): Promise<void> {
-    if (this.LightBulb.On === this.accessory.context.On) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set On: ${value}`);
+    if (this.LightBulb.On !== this.accessory.context.On) {
+      await this.changeSet(value, 'On');
     } else {
-      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set On: ${value}`);
+      await this.noChangeSet(value, 'On');
     }
 
     this.LightBulb.On = value;
@@ -596,12 +581,12 @@ export class Fan extends deviceBase {
    * Handle requests to set the value of the "Brightness" characteristic
    */
   async BrightnessSet(value: CharacteristicValue): Promise<void> {
-    if (this.LightBulb.Brightness === this.accessory.context.Brightness) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set Brightness: ${value}`);
+    if (this.LightBulb.Brightness !== this.accessory.context.Brightness) {
+      await this.changeSet(value, 'Brightness');
     } else if (this.LightBulb.On) {
-      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Brightness: ${value}`);
+      await this.changeSet(value, 'Brightness');
     } else {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Set Brightness: ${value}`);
+      await this.noChangeSet(value, 'Brightness');
     }
 
     this.LightBulb.Brightness = value;

package/src/device/hub.ts

@@ -256,9 +256,8 @@ export class Hub extends deviceBase {
         await this.statusCodes(statusCode, deviceStatus);
       }
     } catch (e: any) {
-      this.apiError(e);
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+      await this.apiError(e);
+      await this.openAPIRefreshError(e);
     }
   }
 

package/src/device/humidifier.ts

@@ -314,9 +314,8 @@ export class Humidifier extends deviceBase {
         await this.statusCodes(statusCode, deviceStatus);
       }
     } catch (e: any) {
-      this.apiError(e);
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+      await this.apiError(e);
+      await this.openAPIRefreshError(e);
     }
   }
 
@@ -356,8 +355,7 @@ export class Humidifier extends deviceBase {
       await this.openAPIpushChanges();
     } else {
       await this.offlineOff();
-      this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-        + ` ${this.device.connectionType}, pushChanges will not happen.`);
+      await this.pushChangeDisabled();
     }
     // Refresh the status from the API
     interval(15000)