@switchbot/homebridge-switchbot 3.5.0-beta.26 → 3.5.0-beta.28

package/dist/irdevice/airconditioner.js

@@ -13,15 +13,8 @@ import { Devices } from '../settings.js';
 export class AirConditioner extends irdeviceBase {
     platform;
     // Services
-    coolerService;
-    // Characteristic Values
-    Active;
-    RotationSpeed;
-    CurrentTemperature;
-    ThresholdTemperature;
-    CurrentRelativeHumidity;
-    TargetHeaterCoolerState;
-    CurrentHeaterCoolerState;
+    HeaterCooler;
+    HumiditySensor;
     // Others
     state;
     Busy;
@@ -29,9 +22,6 @@ export class AirConditioner extends irdeviceBase {
     CurrentMode;
     ValidValues;
     CurrentFanSpeed;
-    static MODE_AUTO;
-    static MODE_COOL;
-    static MODE_HEAT;
     // Config
     hide_automode;
     set_max_heat;
@@ -39,112 +29,60 @@ export class AirConditioner extends irdeviceBase {
     set_max_cool;
     set_min_cool;
     meter;
-    valid12 = [1, 2];
-    valid012 = [0, 1, 2];
     constructor(platform, accessory, device) {
         super(platform, accessory, device);
         this.platform = platform;
-        if (this.Active === undefined) {
-            this.Active = this.hap.Characteristic.Active.INACTIVE;
-        }
-        else if (this.Active) {
-            this.Active;
-        }
-        else {
-            this.Active = this.accessory.context.Active;
-        }
-        if (this.CurrentTemperature === undefined && this.accessory.context.CurrentTemperature === undefined) {
-            this.CurrentTemperature = 24;
-        }
-        else {
-            this.CurrentTemperature = this.CurrentTemperature || this.accessory.context.CurrentTemperature;
-        }
-        if (this.ThresholdTemperature === undefined && this.accessory.context.ThresholdTemperature === undefined) {
-            this.ThresholdTemperature = 24;
-        }
-        else {
-            this.ThresholdTemperature = this.ThresholdTemperature || this.accessory.context.ThresholdTemperature;
-        }
-        if (this.RotationSpeed === undefined && this.accessory.context.RotationSpeed === undefined) {
-            this.RotationSpeed = 4;
-        }
-        else {
-            this.RotationSpeed = this.RotationSpeed || this.accessory.context.RotationSpeed;
-        }
-        if (this.device.irair?.hide_automode) {
-            this.hide_automode = this.device.irair?.hide_automode;
-            this.accessory.context.hide_automode = this.hide_automode;
-        }
-        else {
-            this.hide_automode = this.device.irair?.hide_automode;
-            this.accessory.context.hide_automode = this.hide_automode;
-        }
-        if (this.device.irair?.set_max_heat) {
-            this.set_max_heat = this.device.irair?.set_max_heat;
-            this.accessory.context.set_max_heat = this.set_max_heat;
-        }
-        else {
-            this.set_max_heat = 35;
-            this.accessory.context.set_max_heat = this.set_max_heat;
-        }
-        if (this.device.irair?.set_min_heat) {
-            this.set_min_heat = this.device.irair?.set_min_heat;
-            this.accessory.context.set_min_heat = this.set_min_heat;
-        }
-        else {
-            this.set_min_heat = 0;
-            this.accessory.context.set_min_heat = this.set_min_heat;
-        }
-        if (this.device.irair?.set_max_cool) {
-            this.set_max_cool = this.device.irair?.set_max_cool;
-            this.accessory.context.set_max_cool = this.set_max_cool;
-        }
-        else {
-            this.set_max_cool = 35;
-            this.accessory.context.set_max_cool = this.set_max_cool;
-        }
-        if (this.device.irair?.set_min_cool) {
-            this.set_min_cool = this.device.irair?.set_min_cool;
-            this.accessory.context.set_min_cool = this.set_min_cool;
-        }
-        else {
-            this.set_min_cool = 0;
-            this.accessory.context.set_min_cool = this.set_min_cool;
-        }
-        if (this.meter) {
-            if (this.CurrentRelativeHumidity === undefined && this.accessory.context.CurrentRelativeHumidity === undefined) {
-                this.CurrentRelativeHumidity = 0;
-            }
-            else {
-                this.CurrentRelativeHumidity = this.CurrentRelativeHumidity || this.accessory.context.CurrentRelativeHumidity;
-            }
+        // default placeholders
+        this.getAirConditionerConfigSettings(accessory, device);
+        // Initialize HeaterCooler property
+        this.HeaterCooler = {
+            Service: accessory.getService(this.hap.Service.Switch),
+            Active: accessory.context.Active || this.hap.Characteristic.Active.INACTIVE,
+            CurrentHeaterCoolerState: accessory.context.CurrentHeaterCoolerState || this.hap.Characteristic.CurrentHeaterCoolerState.IDLE,
+            TargetHeaterCoolerState: accessory.context.TargetHeaterCoolerState || this.hap.Characteristic.TargetHeaterCoolerState.AUTO,
+            CurrentTemperature: accessory.context.CurrentTemperature || 24,
+            ThresholdTemperature: accessory.context.ThresholdTemperature || 24,
+            RotationSpeed: accessory.context.RotationSpeed || 4,
+        };
+        // Initialize HumiditySensor property
+        if (this.device.irair?.meterType && this.device.irair?.meterId) {
+            const meterUuid = this.platform.api.hap.uuid.generate(`${this.device.irair.meterId}-${this.device.irair.meterType}`);
+            this.meter = this.platform.accessories.find((accessory) => accessory.UUID === meterUuid);
+            this.HumiditySensor = {
+                Service: this.meter.getService(this.hap.Service.HumiditySensor),
+                CurrentRelativeHumidity: this.meter.context.CurrentRelativeHumidity || 0,
+            };
         }
         // get the Television service if it exists, otherwise create a new Television service
         // you can create multiple services for each accessory
-        const coolerService = `${accessory.displayName} ${device.remoteType}`;
-        (this.coolerService = accessory.getService(this.hap.Service.HeaterCooler)
-            || accessory.addService(this.hap.Service.HeaterCooler)), coolerService;
-        this.coolerService.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
+        const HeaterCoolerService = `${accessory.displayName} ${device.remoteType}`;
+        (this.HeaterCooler.Service = accessory.getService(this.hap.Service.HeaterCooler)
+            || accessory.addService(this.hap.Service.HeaterCooler)), HeaterCoolerService;
+        this.HeaterCooler.Service.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
         // handle on / off events using the Active characteristic
-        this.coolerService.getCharacteristic(this.hap.Characteristic.Active).onSet(this.ActiveSet.bind(this));
-        this.coolerService.getCharacteristic(this.hap.Characteristic.CurrentTemperature).onGet(this.CurrentTemperatureGet.bind(this));
+        this.HeaterCooler.Service.getCharacteristic(this.hap.Characteristic.Active)
+            .onSet(this.ActiveSet.bind(this));
+        this.HeaterCooler.Service.getCharacteristic(this.hap.Characteristic.CurrentTemperature)
+            .onGet(this.CurrentTemperatureGet.bind(this));
         this.ValidValues = this.hide_automode ? [1, 2] : [0, 1, 2];
         if (this.device.irair?.meterType && this.device.irair?.meterId) {
             const meterUuid = this.platform.api.hap.uuid.generate(`${this.device.irair.meterId}-${this.device.irair.meterType}`);
             this.meter = this.platform.accessories.find((accessory) => accessory.UUID === meterUuid);
         }
         if (this.meter) {
-            this.coolerService.getCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity).onGet(this.CurrentRelativeHumidityGet.bind(this));
+            this.HumiditySensor.Service.getCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity)
+                .onGet(this.CurrentRelativeHumidityGet.bind(this));
         }
-        this.coolerService
+        this.HeaterCooler.Service
             .getCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState)
             .setProps({
             validValues: this.ValidValues,
         })
             .onGet(this.TargetHeaterCoolerStateGet.bind(this))
             .onSet(this.TargetHeaterCoolerStateSet.bind(this));
-        this.coolerService.getCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState).onGet(this.CurrentHeaterCoolerStateGet.bind(this));
-        this.coolerService
+        this.HeaterCooler.Service.getCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState)
+            .onGet(this.CurrentHeaterCoolerStateGet.bind(this));
+        this.HeaterCooler.Service
             .getCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature)
             .setProps({
             minValue: this.set_min_heat,
@@ -153,7 +91,7 @@ export class AirConditioner extends irdeviceBase {
         })
             .onGet(this.ThresholdTemperatureGet.bind(this))
             .onSet(this.ThresholdTemperatureSet.bind(this));
-        this.coolerService
+        this.HeaterCooler.Service
             .getCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature)
             .setProps({
             minValue: this.set_min_cool,
@@ -162,7 +100,7 @@ export class AirConditioner extends irdeviceBase {
         })
             .onGet(this.ThresholdTemperatureGet.bind(this))
             .onSet(this.ThresholdTemperatureSet.bind(this));
-        this.coolerService
+        this.HeaterCooler.Service
             .getCharacteristic(this.hap.Characteristic.RotationSpeed)
             .setProps({
             format: 'int',
@@ -183,9 +121,9 @@ export class AirConditioner extends irdeviceBase {
      * AirConditioner:        "command"       "highSpeed"      "default"	        =        fan speed to high
      */
     async pushAirConditionerOnChanges() {
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges Active: ${this.Active},` +
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges Active: ${this.HeaterCooler.Active},` +
             ` disablePushOn: ${this.disablePushOn}`);
-        if (this.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
+        if (this.HeaterCooler.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
             const commandType = await this.commandType();
             const command = await this.commandOn();
             const bodyChange = JSON.stringify({
@@ -197,9 +135,9 @@ export class AirConditioner extends irdeviceBase {
         }
     }
     async pushAirConditionerOffChanges() {
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges Active: ${this.Active},` +
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges Active: ${this.HeaterCooler.Active},` +
             ` disablePushOff: ${this.disablePushOff}`);
-        if (this.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOff) {
+        if (this.HeaterCooler.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOff) {
             const commandType = await this.commandType();
             const command = await this.commandOff();
             const bodyChange = JSON.stringify({
@@ -211,18 +149,18 @@ export class AirConditioner extends irdeviceBase {
         }
     }
     async pushAirConditionerStatusChanges() {
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerStatusChanges Active: ${this.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;
-            this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
+            this.HeaterCooler.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
         }
         clearTimeout(this.Timeout);
         // Make a new Timeout set to go off in 1000ms (1 second)
         this.Timeout = setTimeout(this.pushAirConditionerDetailsChanges.bind(this), 1500);
     }
     async pushAirConditionerDetailsChanges() {
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerDetailsChanges Active: ${this.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) {
@@ -231,7 +169,7 @@ export class AirConditioner extends irdeviceBase {
         if (this.CurrentFanSpeed === undefined) {
             this.CurrentFanSpeed = 1;
         }
-        if (this.Active === this.hap.Characteristic.Active.ACTIVE) {
+        if (this.HeaterCooler.Active === this.hap.Characteristic.Active.ACTIVE) {
             this.state = 'on';
         }
         else {
@@ -239,11 +177,11 @@ export class AirConditioner extends irdeviceBase {
         }
         if (this.CurrentMode === 1) {
             // Remove or make configurable?
-            this.ThresholdTemperature = 25;
+            this.HeaterCooler.ThresholdTemperature = 25;
             this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentMode: ${this.CurrentMode},` +
-                ` ThresholdTemperature: ${this.ThresholdTemperature}`);
+                ` ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
         }
-        const parameter = `${this.ThresholdTemperature},${this.CurrentMode},${this.CurrentFanSpeed},${this.state}`;
+        const parameter = `${this.HeaterCooler.ThresholdTemperature},${this.CurrentMode},${this.CurrentFanSpeed},${this.state}`;
         await this.UpdateCurrentHeaterCoolerState();
         const bodyChange = JSON.stringify({
             command: 'setAll',
@@ -253,33 +191,33 @@ export class AirConditioner extends irdeviceBase {
         await this.pushChanges(bodyChange);
     }
     async UpdateCurrentHeaterCoolerState() {
-        if (this.Active === this.hap.Characteristic.Active.ACTIVE) {
-            if (this.Active === undefined) {
-                this.Active = this.hap.Characteristic.Active.INACTIVE;
+        if (this.HeaterCooler.Active === this.hap.Characteristic.Active.ACTIVE) {
+            if (this.HeaterCooler.Active === undefined) {
+                this.HeaterCooler.Active = this.hap.Characteristic.Active.INACTIVE;
             }
-            else if (this.Active) {
-                this.Active;
+            else if (this.HeaterCooler.Active) {
+                this.HeaterCooler.Active;
             }
             else {
-                this.Active = this.accessory.context.Active;
+                this.HeaterCooler.Active = this.accessory.context.Active;
             }
-            if (this.CurrentTemperature === undefined && this.accessory.context.CurrentTemperature === undefined) {
-                this.CurrentTemperature = 24;
+            if (this.HeaterCooler.CurrentTemperature === undefined && this.accessory.context.CurrentTemperature === undefined) {
+                this.HeaterCooler.CurrentTemperature = 24;
             }
             else {
-                this.CurrentTemperature = this.CurrentTemperature || this.accessory.context.CurrentTemperature;
+                this.HeaterCooler.CurrentTemperature = this.HeaterCooler.CurrentTemperature || this.accessory.context.CurrentTemperature;
             }
-            if (this.ThresholdTemperature === undefined && this.accessory.context.ThresholdTemperature === undefined) {
-                this.ThresholdTemperature = 24;
+            if (this.HeaterCooler.ThresholdTemperature === undefined && this.accessory.context.ThresholdTemperature === undefined) {
+                this.HeaterCooler.ThresholdTemperature = 24;
             }
             else {
-                this.ThresholdTemperature = this.ThresholdTemperature || this.accessory.context.ThresholdTemperature;
+                this.HeaterCooler.ThresholdTemperature = this.HeaterCooler.ThresholdTemperature || this.accessory.context.ThresholdTemperature;
             }
-            if (this.RotationSpeed === undefined && this.accessory.context.RotationSpeed === undefined) {
-                this.RotationSpeed = 4;
+            if (this.HeaterCooler.RotationSpeed === undefined && this.accessory.context.RotationSpeed === undefined) {
+                this.HeaterCooler.RotationSpeed = 4;
             }
             else {
-                this.RotationSpeed = this.RotationSpeed || this.accessory.context.RotationSpeed;
+                this.HeaterCooler.RotationSpeed = this.HeaterCooler.RotationSpeed || this.accessory.context.RotationSpeed;
             }
             if (this.device.irair?.hide_automode) {
                 this.hide_automode = this.device.irair?.hide_automode;
@@ -322,27 +260,28 @@ export class AirConditioner extends irdeviceBase {
                 this.accessory.context.set_min_cool = this.set_min_cool;
             }
             if (this.meter) {
-                if (this.CurrentRelativeHumidity === undefined && this.accessory.context.CurrentRelativeHumidity === undefined) {
-                    this.CurrentRelativeHumidity = 0;
+                if (this.HumiditySensor.CurrentRelativeHumidity === undefined && this.accessory.context.CurrentRelativeHumidity === undefined) {
+                    this.HumiditySensor.CurrentRelativeHumidity = 0;
                 }
                 else {
-                    this.CurrentRelativeHumidity = this.CurrentRelativeHumidity || this.accessory.context.CurrentRelativeHumidity;
+                    this.HumiditySensor.CurrentRelativeHumidity = this.HumiditySensor.CurrentRelativeHumidity
+                        || this.accessory.context.CurrentRelativeHumidity;
                 }
             }
-            if (this.ThresholdTemperature < this.CurrentTemperature &&
-                this.TargetHeaterCoolerState !== this.hap.Characteristic.TargetHeaterCoolerState.HEAT) {
-                this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
+            if (this.HeaterCooler.ThresholdTemperature < this.HeaterCooler.CurrentTemperature &&
+                this.HeaterCooler.TargetHeaterCoolerState !== this.hap.Characteristic.TargetHeaterCoolerState.HEAT) {
+                this.HeaterCooler.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
             }
-            else if (this.ThresholdTemperature > this.CurrentTemperature &&
-                this.TargetHeaterCoolerState !== this.hap.Characteristic.TargetHeaterCoolerState.COOL) {
-                this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
+            else if (this.HeaterCooler.ThresholdTemperature > this.HeaterCooler.CurrentTemperature &&
+                this.HeaterCooler.TargetHeaterCoolerState !== this.hap.Characteristic.TargetHeaterCoolerState.COOL) {
+                this.HeaterCooler.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
             }
             else {
-                this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
+                this.HeaterCooler.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
             }
         }
         else {
-            this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE;
+            this.HeaterCooler.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE;
         }
     }
     async pushChanges(bodyChange) {
@@ -360,7 +299,7 @@ export class AirConditioner extends irdeviceBase {
                 this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
                 this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
                 if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
+                    this.debugSuccessLog(`${this.device.remoteType}: ${this.accessory.displayName} `
                         + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
                     this.successLog(`${this.device.remoteType}: ${this.accessory.displayName} request to SwitchBot API, body: ${bodyChange} sent successfully`);
                     this.updateHomeKitCharacteristics();
@@ -390,9 +329,9 @@ export class AirConditioner extends irdeviceBase {
             this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} `
                 + `Using CurrentTemperature from ${this.meter.context.deviceType} (${this.meter.context.deviceID})`);
         }
-        this.CurrentTemperature = this.accessory.context.CurrentTemperature || 24;
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CurrentTemperature: ${this.CurrentTemperature}`);
-        return this.CurrentTemperature;
+        this.HeaterCooler.CurrentTemperature = this.accessory.context.CurrentTemperature || 24;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
+        return this.HeaterCooler.CurrentTemperature;
     }
     async CurrentRelativeHumidityGet() {
         if (this.meter?.context?.CurrentRelativeHumidity) {
@@ -400,19 +339,20 @@ export class AirConditioner extends irdeviceBase {
             this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} `
                 + `Using CurrentRelativeHumidity from ${this.meter.context.deviceType} (${this.meter.context.deviceID})`);
         }
-        this.CurrentRelativeHumidity = this.accessory.context.CurrentRelativeHumidity || 0;
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
-        return this.CurrentRelativeHumidity;
+        this.HumiditySensor.CurrentRelativeHumidity = this.accessory.context.CurrentRelativeHumidity || 0;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get`
+            + ` CurrentRelativeHumidity: ${this.HumiditySensor.CurrentRelativeHumidity}`);
+        return this.HumiditySensor.CurrentRelativeHumidity;
     }
     async RotationSpeedGet() {
         if (!this.CurrentFanSpeed || this.CurrentFanSpeed === 1) {
-            this.RotationSpeed = 4;
+            this.HeaterCooler.RotationSpeed = 4;
         }
         else {
-            this.RotationSpeed = this.CurrentFanSpeed - 1;
+            this.HeaterCooler.RotationSpeed = this.CurrentFanSpeed - 1;
         }
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get RotationSpeed: ${this.RotationSpeed}`);
-        return this.RotationSpeed;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
+        return this.HeaterCooler.RotationSpeed;
     }
     async RotationSpeedSet(value) {
         if (value === 4) {
@@ -421,16 +361,16 @@ export class AirConditioner extends irdeviceBase {
         else {
             this.CurrentFanSpeed = Number(value) + 1;
         }
-        this.RotationSpeed = value;
+        this.HeaterCooler.RotationSpeed = value;
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` +
-            `Set RotationSpeed: ${this.RotationSpeed}, CurrentFanSpeed: ${this.CurrentFanSpeed}`);
+            `Set RotationSpeed: ${this.HeaterCooler.RotationSpeed}, CurrentFanSpeed: ${this.CurrentFanSpeed}`);
         this.pushAirConditionerStatusChanges();
     }
     async ActiveSet(value) {
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set Active: ${value}`);
-        this.Active = value;
-        if (this.Active === this.hap.Characteristic.Active.ACTIVE) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges, Active: ${this.Active}`);
+        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}`);
             if (this.disablePushOn) {
                 this.pushAirConditionerStatusChanges();
             }
@@ -439,16 +379,16 @@ export class AirConditioner extends irdeviceBase {
             }
         }
         else {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.Active}`);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.HeaterCooler.Active}`);
             this.pushAirConditionerOffChanges();
         }
     }
     async TargetHeaterCoolerStateGet() {
-        const targetState = this.TargetHeaterCoolerState || this.accessory.context.TargetHeaterCoolerState;
-        this.TargetHeaterCoolerState = this.ValidValues.includes(targetState) ? targetState : this.ValidValues[0];
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get (${this.getTargetHeaterCoolerStateName()})` +
-            ` TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}, ValidValues: ${this.ValidValues},  hide_automode: ${this.hide_automode}`);
-        return this.TargetHeaterCoolerState;
+        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:`
+            + ` ${this.HeaterCooler.TargetHeaterCoolerState}, ValidValues: ${this.ValidValues},  hide_automode: ${this.hide_automode}`);
+        return this.HeaterCooler.TargetHeaterCoolerState;
     }
     async TargetHeaterCoolerStateSet(value) {
         if (!this.hide_automode && value === this.hap.Characteristic.TargetHeaterCoolerState.AUTO) {
@@ -461,37 +401,40 @@ export class AirConditioner extends irdeviceBase {
             this.TargetHeaterCoolerStateCOOL();
         }
         else {
-            this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Set TargetHeaterCoolerState: ${this.TargetHeaterCoolerState},` +
+            this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Set TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState},` +
                 ` hide_automode: ${this.hide_automode} `);
         }
         this.pushAirConditionerStatusChanges();
     }
     async TargetHeaterCoolerStateAUTO() {
-        this.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.AUTO;
+        this.HeaterCooler.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.AUTO;
         this.CurrentMode = 1;
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (AUTO) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (AUTO)`
+            + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
     }
     async TargetHeaterCoolerStateCOOL() {
-        this.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.COOL;
+        this.HeaterCooler.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.COOL;
         this.CurrentMode = 2;
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (COOL) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (COOL)`
+            + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
     }
     async TargetHeaterCoolerStateHEAT() {
-        this.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.HEAT;
+        this.HeaterCooler.TargetHeaterCoolerState = this.hap.Characteristic.TargetHeaterCoolerState.HEAT;
         this.CurrentMode = 5;
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (HEAT) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (HEAT)`
+            + ` TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
     }
     async CurrentHeaterCoolerStateGet() {
         await this.UpdateCurrentHeaterCoolerState();
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` +
-            ` Get (${this.getTargetHeaterCoolerStateName()}) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
-        return this.CurrentHeaterCoolerState;
+            ` Get (${this.getTargetHeaterCoolerStateName()}) CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
+        return this.HeaterCooler.CurrentHeaterCoolerState;
     }
     getTargetHeaterCoolerStateName() {
-        switch (this.TargetHeaterCoolerState) {
+        switch (this.HeaterCooler.TargetHeaterCoolerState) {
             case this.hap.Characteristic.TargetHeaterCoolerState.AUTO:
                 return 'AUTO';
             case this.hap.Characteristic.TargetHeaterCoolerState.HEAT:
@@ -499,36 +442,36 @@ export class AirConditioner extends irdeviceBase {
             case this.hap.Characteristic.TargetHeaterCoolerState.COOL:
                 return 'COOL';
             default:
-                return this.TargetHeaterCoolerState.toString();
+                return this.HeaterCooler.TargetHeaterCoolerState.toString();
         }
     }
     async ThresholdTemperatureGet() {
-        if (this.Active === undefined) {
-            this.Active = this.hap.Characteristic.Active.INACTIVE;
+        if (this.HeaterCooler.Active === undefined) {
+            this.HeaterCooler.Active = this.hap.Characteristic.Active.INACTIVE;
         }
-        else if (this.Active) {
-            this.Active;
+        else if (this.HeaterCooler.Active) {
+            this.HeaterCooler.Active;
         }
         else {
-            this.Active = this.accessory.context.Active;
+            this.HeaterCooler.Active = this.accessory.context.Active;
         }
-        if (this.CurrentTemperature === undefined && this.accessory.context.CurrentTemperature === undefined) {
-            this.CurrentTemperature = 24;
+        if (this.HeaterCooler.CurrentTemperature === undefined && this.accessory.context.CurrentTemperature === undefined) {
+            this.HeaterCooler.CurrentTemperature = 24;
         }
         else {
-            this.CurrentTemperature = this.CurrentTemperature || this.accessory.context.CurrentTemperature;
+            this.HeaterCooler.CurrentTemperature = this.HeaterCooler.CurrentTemperature || this.accessory.context.CurrentTemperature;
         }
-        if (this.ThresholdTemperature === undefined && this.accessory.context.ThresholdTemperature === undefined) {
-            this.ThresholdTemperature = 24;
+        if (this.HeaterCooler.ThresholdTemperature === undefined && this.accessory.context.ThresholdTemperature === undefined) {
+            this.HeaterCooler.ThresholdTemperature = 24;
         }
         else {
-            this.ThresholdTemperature = this.ThresholdTemperature || this.accessory.context.ThresholdTemperature;
+            this.HeaterCooler.ThresholdTemperature = this.HeaterCooler.ThresholdTemperature || this.accessory.context.ThresholdTemperature;
         }
-        if (this.RotationSpeed === undefined && this.accessory.context.RotationSpeed === undefined) {
-            this.RotationSpeed = 4;
+        if (this.HeaterCooler.RotationSpeed === undefined && this.accessory.context.RotationSpeed === undefined) {
+            this.HeaterCooler.RotationSpeed = 4;
         }
         else {
-            this.RotationSpeed = this.RotationSpeed || this.accessory.context.RotationSpeed;
+            this.HeaterCooler.RotationSpeed = this.HeaterCooler.RotationSpeed || this.accessory.context.RotationSpeed;
         }
         if (this.device.irair?.hide_automode) {
             this.hide_automode = this.device.irair?.hide_automode;
@@ -571,100 +514,149 @@ export class AirConditioner extends irdeviceBase {
             this.accessory.context.set_min_cool = this.set_min_cool;
         }
         if (this.meter) {
-            if (this.CurrentRelativeHumidity === undefined && this.accessory.context.CurrentRelativeHumidity === undefined) {
-                this.CurrentRelativeHumidity = 0;
+            if (this.HumiditySensor.CurrentRelativeHumidity === undefined && this.accessory.context.CurrentRelativeHumidity === undefined) {
+                this.HumiditySensor.CurrentRelativeHumidity = 0;
             }
             else {
-                this.CurrentRelativeHumidity = this.CurrentRelativeHumidity || this.accessory.context.CurrentRelativeHumidity;
+                this.HumiditySensor.CurrentRelativeHumidity = this.HumiditySensor.CurrentRelativeHumidity || this.accessory.context.CurrentRelativeHumidity;
             }
         }
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get ThresholdTemperature: ${this.ThresholdTemperature}`);
-        return this.ThresholdTemperature;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
+        return this.HeaterCooler.ThresholdTemperature;
     }
     async ThresholdTemperatureSet(value) {
-        this.ThresholdTemperature = value;
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set ThresholdTemperature: ${this.ThresholdTemperature},` +
+        this.HeaterCooler.ThresholdTemperature = value;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature},` +
             ` ThresholdTemperatureCached: ${this.accessory.context.ThresholdTemperature}`);
         this.pushAirConditionerStatusChanges();
     }
     async updateHomeKitCharacteristics() {
         // Active
-        if (this.Active === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Active}`);
+        if (this.HeaterCooler.Active === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.HeaterCooler.Active}`);
         }
         else {
-            this.accessory.context.Active = this.Active;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.Active, this.Active);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
+            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
-        if (this.RotationSpeed === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.RotationSpeed}`);
+        if (this.HeaterCooler.RotationSpeed === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.HeaterCooler.RotationSpeed}`);
         }
         else {
-            this.accessory.context.RotationSpeed = this.RotationSpeed;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.RotationSpeed, this.RotationSpeed);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.RotationSpeed}`);
+            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
-        if (this.CurrentTemperature === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
+        if (this.HeaterCooler.CurrentTemperature === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.HeaterCooler.CurrentTemperature}`);
         }
         else {
-            this.accessory.context.CurrentTemperature = this.CurrentTemperature;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.CurrentTemperature);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`);
+            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.CurrentRelativeHumidity === undefined) {
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
+            if (this.HumiditySensor.CurrentRelativeHumidity === undefined) {
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+                    + ` CurrentRelativeHumidity: ${this.HumiditySensor.CurrentRelativeHumidity}`);
             }
             else {
-                this.accessory.context.CurrentRelativeHumidity = this.CurrentRelativeHumidity;
-                this.coolerService?.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, this.CurrentRelativeHumidity);
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
+                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
-        if (this.TargetHeaterCoolerState === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+        if (this.HeaterCooler.TargetHeaterCoolerState === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.HeaterCooler.TargetHeaterCoolerState}`);
         }
         else {
-            this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerState;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState, this.TargetHeaterCoolerState);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` + ` updateCharacteristic TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+            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
-        if (this.CurrentHeaterCoolerState === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
+        if (this.HeaterCooler.CurrentHeaterCoolerState === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+                + ` CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
         }
         else {
-            this.accessory.context.CurrentHeaterCoolerState = this.CurrentHeaterCoolerState;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
+            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.CurrentHeaterCoolerState}`);
+                ` updateCharacteristic CurrentHeaterCoolerState: ${this.HeaterCooler.CurrentHeaterCoolerState}`);
         }
         // ThresholdTemperature
-        if (this.ThresholdTemperature === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ThresholdTemperature: ${this.ThresholdTemperature}`);
+        if (this.HeaterCooler.ThresholdTemperature === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ThresholdTemperature: ${this.HeaterCooler.ThresholdTemperature}`);
         }
         else {
-            this.accessory.context.ThresholdTemperature = this.ThresholdTemperature;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature, this.ThresholdTemperature);
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature, this.ThresholdTemperature);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` + ` updateCharacteristic ThresholdTemperature: ${this.ThresholdTemperature}`);
+            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 }) {
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.Active, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.RotationSpeed, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature, e);
+        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);
+        this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, e);
+        this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState, e);
+        this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, e);
+        this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature, e);
+        this.HeaterCooler.Service.updateCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature, e);
+    }
+    async getAirConditionerConfigSettings(accessory, device) {
+        if (this.device.irair?.hide_automode) {
+            this.hide_automode = device.irair?.hide_automode;
+            accessory.context.hide_automode = this.hide_automode;
+        }
+        else {
+            this.hide_automode = device.irair?.hide_automode;
+            accessory.context.hide_automode = this.hide_automode;
+        }
+        if (this.device.irair?.set_max_heat) {
+            this.set_max_heat = device.irair?.set_max_heat;
+            accessory.context.set_max_heat = this.set_max_heat;
+        }
+        else {
+            this.set_max_heat = 35;
+            accessory.context.set_max_heat = this.set_max_heat;
+        }
+        if (this.device.irair?.set_min_heat) {
+            this.set_min_heat = device.irair?.set_min_heat;
+            accessory.context.set_min_heat = this.set_min_heat;
+        }
+        else {
+            this.set_min_heat = 0;
+            accessory.context.set_min_heat = this.set_min_heat;
+        }
+        if (this.device.irair?.set_max_cool) {
+            this.set_max_cool = device.irair?.set_max_cool;
+            accessory.context.set_max_cool = this.set_max_cool;
+        }
+        else {
+            this.set_max_cool = 35;
+            accessory.context.set_max_cool = this.set_max_cool;
+        }
+        if (this.device.irair?.set_min_cool) {
+            this.set_min_cool = device.irair?.set_min_cool;
+            accessory.context.set_min_cool = this.set_min_cool;
+        }
+        else {
+            this.set_min_cool = 0;
+            accessory.context.set_min_cool = this.set_min_cool;
+        }
     }
 }
 //# sourceMappingURL=airconditioner.js.map