homebridge-midea-platform 1.2.7-beta.3 → 1.2.7

package/config.schema.json

@@ -120,7 +120,7 @@
                 },
                 "humiditySensor": {
                   "title": "Humidity Sensor",
-                  "description": "Toggles if a seperated humidity sensor is created with the accessory. This sensor can be used for automations as for some reason the internal humidity sensor is not usable for this.",
+                  "description": "Toggles if a seperated humidity sensor is created with the accessory. This sensor can be used for autmations as for some reason the internal humidity sensor is not usable for this.",
                   "type": "boolean"
                 },
                 "pumpSwitch": {
@@ -306,11 +306,6 @@
                   "title": "Comfort Mode Switch",
                   "description": "Toggles if the comfort mode switch is created with the accessory.",
                   "type": "boolean"
-                },
-                "temperatureSensor": {
-                  "title": "Indoor Temperature Sensor",
-                  "description": "Toggles if a seperated indoor temperature is created with the accessory. This sensor can be used for automations as for some reason the internal sensors are not usable for this.",
-                  "type": "boolean"
                 }
               }
             },
@@ -657,8 +652,7 @@
                 "devices[].AC_options.fanOnlyModeSwitch",
                 "devices[].AC_options.fanAccessory",
                 "devices[].AC_options.sleepModeSwitch",
-                "devices[].AC_options.comfortModeSwitch",
-                "devices[].AC_options.temperatureSensor"
+                "devices[].AC_options.comfortModeSwitch"
               ]
             },
             {

package/dist/accessory/AirConditionerAccessory.d.ts

@@ -34,13 +34,15 @@ export default class AirConditionerAccessory extends BaseAccessory<MideaACDevice
     private sleepModeService?;
     private swingAngleService?;
     private comfortModeService?;
-    private temperatureSensorService?;
     private swingAngleMainControl;
+    private heatingThresholdTemperature;
+    private coolingThresholdTemperature;
     /*********************************************************************
      * Constructor registers all the service types with Homebridge, registers
      * a callback function with the MideaDevice class, and requests device status.
      */
     constructor(platform: MideaPlatform, accessory: MideaAccessory, device: MideaACDevice, configDev: DeviceConfig);
+    private withoutPromptTone;
     /*********************************************************************
      * Callback function called by MideaDevice whenever there is a change to
      * any attribute value.
@@ -59,11 +61,20 @@ export default class AirConditionerAccessory extends BaseAccessory<MideaACDevice
     setTargetHeaterCoolerState(value: CharacteristicValue): Promise<void>;
     getCurrentTemperature(): CharacteristicValue;
     getTargetTemperature(): CharacteristicValue;
+    setTargetTemperature(value: CharacteristicValue): Promise<void>;
+    setTargetTemperatureWithinThresholds(): Promise<void>;
+    getCoolingThresholdTemperature(): CharacteristicValue;
+    getHeatingThresholdTemperature(): CharacteristicValue;
     getFanOnlyMode(): CharacteristicValue;
     setFanOnlyMode(value: CharacteristicValue): Promise<void>;
     getFanState(): CharacteristicValue;
     setFanState(value: CharacteristicValue): Promise<void>;
-    setTargetTemperature(value: CharacteristicValue): Promise<void>;
+    setHeatingCoolingTemperatureThresholds(thresholds: {
+        heating?: number;
+        cooling?: number;
+    }): void;
+    setCoolingThresholdTemperature(value: CharacteristicValue): Promise<void>;
+    setHeatingThresholdTemperature(value: CharacteristicValue): Promise<void>;
     getSwingMode(): CharacteristicValue;
     setSwingMode(value: CharacteristicValue): Promise<void>;
     getRotationSpeed(): CharacteristicValue;

package/dist/accessory/AirConditionerAccessory.js

@@ -1,4 +1,4 @@
-import { SwingAngle, SwingMode } from '../platformUtils.js';
+import { ACMode, SwingAngle, SwingMode } from '../platformUtils.js';
 import BaseAccessory, { limitValue } from './BaseAccessory.js';
 const outDoorTemperatureSubtype = 'outdoor';
 const displaySubtype = 'display';
@@ -16,7 +16,6 @@ const rateSelectSubtype = 'rateSelect';
 const sleepModeSubtype = 'sleepMode';
 const swingAngleSubtype = 'swingAngle';
 const comfortModeSubtype = 'comfortMode';
-const temperatureSensorSubtype = 'temperatureSensor';
 export default class AirConditionerAccessory extends BaseAccessory {
     device;
     configDev;
@@ -37,8 +36,9 @@ export default class AirConditionerAccessory extends BaseAccessory {
     sleepModeService;
     swingAngleService;
     comfortModeService;
-    temperatureSensorService;
     swingAngleMainControl;
+    heatingThresholdTemperature;
+    coolingThresholdTemperature;
     /*********************************************************************
      * Constructor registers all the service types with Homebridge, registers
      * a callback function with the MideaDevice class, and requests device status.
@@ -71,8 +71,8 @@ export default class AirConditionerAccessory extends BaseAccessory {
         this.service.getCharacteristic(this.platform.Characteristic.CurrentTemperature).onGet(this.getCurrentTemperature.bind(this));
         this.service
             .getCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature)
-            .onGet(this.getTargetTemperature.bind(this))
-            .onSet(this.setTargetTemperature.bind(this))
+            .onGet(this.getCoolingThresholdTemperature.bind(this))
+            .onSet(this.setCoolingThresholdTemperature.bind(this))
             .setProps({
             minValue: this.configDev.AC_options.minTemp,
             maxValue: this.configDev.AC_options.maxTemp,
@@ -80,8 +80,8 @@ export default class AirConditionerAccessory extends BaseAccessory {
         });
         this.service
             .getCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature)
-            .onGet(this.getTargetTemperature.bind(this))
-            .onSet(this.setTargetTemperature.bind(this))
+            .onGet(this.getHeatingThresholdTemperature.bind(this))
+            .onSet(this.setHeatingThresholdTemperature.bind(this))
             .setProps({
             minValue: this.configDev.AC_options.minTemp,
             maxValue: this.configDev.AC_options.maxTemp,
@@ -254,7 +254,6 @@ export default class AirConditionerAccessory extends BaseAccessory {
         else if (this.sleepModeService) {
             this.accessory.removeService(this.sleepModeService);
         }
-        // Comfort mode accessory
         this.comfortModeService = this.accessory.getServiceById(this.platform.Service.Switch, comfortModeSubtype);
         if (this.configDev.AC_options.comfortModeSwitch) {
             this.comfortModeService ??= this.accessory.addService(this.platform.Service.Switch, undefined, comfortModeSubtype);
@@ -264,16 +263,6 @@ export default class AirConditionerAccessory extends BaseAccessory {
         else if (this.comfortModeService) {
             this.accessory.removeService(this.comfortModeService);
         }
-        // Separate temperature sensor accessory
-        this.temperatureSensorService = this.accessory.getServiceById(this.platform.Service.TemperatureSensor, temperatureSensorSubtype);
-        if (this.configDev.AC_options.temperatureSensor) {
-            this.temperatureSensorService ??= this.accessory.addService(this.platform.Service.TemperatureSensor, undefined, temperatureSensorSubtype);
-            this.handleConfiguredName(this.temperatureSensorService, temperatureSensorSubtype, 'Indoor Temperature');
-            this.temperatureSensorService.getCharacteristic(this.platform.Characteristic.CurrentTemperature).onGet(this.getCurrentTemperature.bind(this));
-        }
-        else if (this.temperatureSensorService) {
-            this.accessory.removeService(this.temperatureSensorService);
-        }
         const swingProps = this.configDev.AC_options.swing;
         this.swingAngleMainControl =
             swingProps.mode === SwingMode.VERTICAL || (swingProps.mode === SwingMode.BOTH && swingProps.angleMainControl === SwingAngle.VERTICAL)
@@ -308,8 +297,20 @@ export default class AirConditionerAccessory extends BaseAccessory {
             }
         }
         // Misc
-        this.device.attributes.PROMPT_TONE = this.configDev.AC_options.audioFeedback;
-        this.device.attributes.TEMP_FAHRENHEIT = this.configDev.AC_options.fahrenheit;
+        this.device.attributes.PROMPT_TONE = configDev.AC_options.audioFeedback;
+        this.device.attributes.TEMP_FAHRENHEIT = configDev.AC_options.fahrenheit;
+        this.heatingThresholdTemperature = accessory.context?.thresholds?.heatingTemperature ?? configDev.AC_options.minTemp;
+        this.coolingThresholdTemperature = accessory.context?.thresholds?.coolingTemperature ?? configDev.AC_options.maxTemp;
+    }
+    async withoutPromptTone(fn) {
+        const hadPromptTone = this.device.attributes.PROMPT_TONE;
+        this.device.attributes.PROMPT_TONE = false;
+        try {
+            return await fn();
+        }
+        finally {
+            this.device.attributes.PROMPT_TONE = hadPromptTone;
+        }
     }
     /*********************************************************************
      * Callback function called by MideaDevice whenever there is a change to
@@ -324,102 +325,105 @@ export default class AirConditionerAccessory extends BaseAccessory {
                     updateState = true;
                     break;
                 case 'temp_fahrenheit':
-                    this.service.getCharacteristic(this.platform.Characteristic.TemperatureDisplayUnits).updateValue(this.getTemperatureDisplayUnits());
+                    this.service.updateCharacteristic(this.platform.Characteristic.TemperatureDisplayUnits, this.getTemperatureDisplayUnits());
                     break;
                 case 'screen_display':
                 case 'screen_display_new':
-                    this.displayService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getDisplayActive());
+                    this.displayService?.updateCharacteristic(this.platform.Characteristic.On, this.getDisplayActive());
                     break;
-                case 'target_temperature':
-                    // If MODE is 4 then device is heating.  Therefore target temperature value must be heating target? Right?
-                    if (this.device.attributes.MODE === 4) {
-                        this.service.getCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature).updateValue(this.getTargetTemperature());
+                case 'target_temperature': {
+                    const target = Number(this.getTargetTemperature());
+                    /**
+                     * If the device is heating, we map the target temperature to the heating threshold, if cooling we map to the cooling
+                     * threshold and otherwise we assume an auto mode and only adjust the thresholds if the target value is outside their
+                     * range. This should only happen if the temperature is changed outside of HomeKit and in this case we collapse the
+                     * range to the target temperature set by the user.
+                     */
+                    if (this.device.attributes.MODE === ACMode.HEATING) {
+                        this.setHeatingCoolingTemperatureThresholds({ heating: target });
+                    }
+                    else if (this.device.attributes.MODE === ACMode.COOLING) {
+                        this.setHeatingCoolingTemperatureThresholds({ cooling: target });
                     }
-                    else {
-                        this.service.getCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature).updateValue(this.getTargetTemperature());
+                    else if (target < this.heatingThresholdTemperature || target > this.coolingThresholdTemperature) {
+                        this.setHeatingCoolingTemperatureThresholds({ heating: target, cooling: target });
                     }
                     updateState = true;
                     break;
-                case 'indoor_temperature': {
-                    const temperature = this.getCurrentTemperature();
-                    this.service.getCharacteristic(this.platform.Characteristic.CurrentTemperature).updateValue(temperature);
-                    this.temperatureSensorService?.getCharacteristic(this.platform.Characteristic.CurrentTemperature).updateValue(temperature);
-                    break;
                 }
+                case 'indoor_temperature':
+                    this.service.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, this.getCurrentTemperature());
+                    if (this.device.attributes.POWER && this.device.attributes.MODE === ACMode.AUTO) {
+                        await this.withoutPromptTone(this.setTargetTemperatureWithinThresholds.bind(this));
+                        updateState = true;
+                    }
+                    break;
                 case 'outdoor_temperature':
-                    this.outDoorTemperatureService?.getCharacteristic(this.platform.Characteristic.CurrentTemperature).updateValue(this.getOutdoorTemperature());
+                    this.outDoorTemperatureService?.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, this.getOutdoorTemperature());
                     break;
                 case 'fan_speed':
                     updateState = true;
                     break;
                 case 'fan_auto':
-                    this.fanService?.getCharacteristic(this.platform.Characteristic.TargetFanState).updateValue(this.getFanState());
+                    this.fanService?.updateCharacteristic(this.platform.Characteristic.TargetFanState, this.getFanState());
                     break;
                 case 'swing_vertical':
                 case 'swing_horizontal':
-                    this.service.getCharacteristic(this.platform.Characteristic.SwingMode).updateValue(this.getSwingMode());
+                    this.service.updateCharacteristic(this.platform.Characteristic.SwingMode, this.getSwingMode());
                     break;
                 case 'mode':
                     updateState = true;
                     break;
                 case 'eco_mode':
-                    this.ecoModeService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getEcoMode());
+                    this.ecoModeService?.updateCharacteristic(this.platform.Characteristic.On, this.getEcoMode());
                     break;
                 case 'indirect_wind':
-                    this.breezeAwayService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getBreezeAway());
+                    this.breezeAwayService?.updateCharacteristic(this.platform.Characteristic.On, this.getBreezeAway());
                     break;
                 case 'aux_heating':
-                    this.auxHeatingService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getAuxHeating());
+                    this.auxHeatingService?.updateCharacteristic(this.platform.Characteristic.On, this.getAuxHeating());
                     break;
                 case 'smart_eye':
-                    this.auxService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getAux());
+                    this.auxService?.updateCharacteristic(this.platform.Characteristic.On, this.getAux());
                     break;
                 case 'wind_swing_lr_angle':
                 case 'wind_swing_ud_angle':
-                    this.swingAngleService?.getCharacteristic(this.platform.Characteristic.CurrentPosition).updateValue(this.getSwingAngleCurrentPosition());
-                    this.swingAngleService?.getCharacteristic(this.platform.Characteristic.TargetPosition).updateValue(this.getSwingAngleTargetPosition());
+                    this.swingAngleService?.updateCharacteristic(this.platform.Characteristic.CurrentPosition, this.getSwingAngleCurrentPosition());
+                    this.swingAngleService?.updateCharacteristic(this.platform.Characteristic.TargetPosition, this.getSwingAngleTargetPosition());
                     if (this.configDev.AC_options.swing.mode === SwingMode.BOTH) {
-                        this.swingAngleService
-                            ?.getCharacteristic(this.platform.Characteristic.CurrentHorizontalTiltAngle)
-                            .updateValue(this.getSwingAngleCurrentHorizontalTiltAngle());
-                        this.swingAngleService
-                            ?.getCharacteristic(this.platform.Characteristic.CurrentVerticalTiltAngle)
-                            .updateValue(this.getSwingAngleCurrentVerticalTiltAngle());
-                        this.swingAngleService
-                            ?.getCharacteristic(this.platform.Characteristic.TargetHorizontalTiltAngle)
-                            .updateValue(this.getSwingAngleTargetHorizontalTiltAngle());
-                        this.swingAngleService
-                            ?.getCharacteristic(this.platform.Characteristic.TargetVerticalTiltAngle)
-                            .updateValue(this.getSwingAngleTargetVerticalTiltAngle());
+                        this.swingAngleService?.updateCharacteristic(this.platform.Characteristic.CurrentHorizontalTiltAngle, this.getSwingAngleCurrentHorizontalTiltAngle());
+                        this.swingAngleService?.updateCharacteristic(this.platform.Characteristic.CurrentVerticalTiltAngle, this.getSwingAngleCurrentVerticalTiltAngle());
+                        this.swingAngleService?.updateCharacteristic(this.platform.Characteristic.TargetHorizontalTiltAngle, this.getSwingAngleTargetHorizontalTiltAngle());
+                        this.swingAngleService?.updateCharacteristic(this.platform.Characteristic.TargetVerticalTiltAngle, this.getSwingAngleTargetVerticalTiltAngle());
                     }
                     break;
                 case 'self_clean':
                     updateState = true;
-                    this.selfCleanService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getSelfCleanState());
+                    this.selfCleanService?.updateCharacteristic(this.platform.Characteristic.On, this.getSelfCleanState());
                     break;
                 case 'ion':
-                    this.ionService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getIonState());
+                    this.ionService?.updateCharacteristic(this.platform.Characteristic.On, this.getIonState());
                     break;
                 case 'rate_select':
-                    this.rateSelectService?.getCharacteristic(this.platform.Characteristic.Brightness).updateValue(this.getRateSelect());
+                    this.rateSelectService?.updateCharacteristic(this.platform.Characteristic.Brightness, this.getRateSelect());
                     break;
                 default:
                     this.platform.log.debug(`[${this.device.name}] Attempt to set unsupported attribute ${k} to ${v}`);
             }
             if (updateState) {
-                this.service.getCharacteristic(this.platform.Characteristic.Active).updateValue(this.getActive());
-                this.service.getCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState).updateValue(this.getTargetHeaterCoolerState());
-                this.service.getCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState).updateValue(this.getCurrentHeaterCoolerState());
-                this.service.getCharacteristic(this.platform.Characteristic.RotationSpeed).updateValue(this.getRotationSpeed());
-                this.fanOnlyService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getFanOnlyMode());
-                this.fanService?.getCharacteristic(this.platform.Characteristic.Active).updateValue(this.getActive());
-                this.fanService?.getCharacteristic(this.platform.Characteristic.RotationSpeed).updateValue(this.getRotationSpeed());
-                this.dryModeService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getDryMode());
-                this.displayService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getDisplayActive());
-                this.ecoModeService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getEcoMode());
-                this.breezeAwayService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getBreezeAway());
-                this.auxService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getAux());
-                this.auxHeatingService?.getCharacteristic(this.platform.Characteristic.On).updateValue(this.getAuxHeating());
+                this.service.updateCharacteristic(this.platform.Characteristic.Active, this.getActive());
+                this.service.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, this.getTargetHeaterCoolerState());
+                this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.getCurrentHeaterCoolerState());
+                this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, this.getRotationSpeed());
+                this.fanOnlyService?.updateCharacteristic(this.platform.Characteristic.On, this.getFanOnlyMode());
+                this.fanService?.updateCharacteristic(this.platform.Characteristic.Active, this.getActive());
+                this.fanService?.updateCharacteristic(this.platform.Characteristic.RotationSpeed, this.getRotationSpeed());
+                this.dryModeService?.updateCharacteristic(this.platform.Characteristic.On, this.getDryMode());
+                this.displayService?.updateCharacteristic(this.platform.Characteristic.On, this.getDisplayActive());
+                this.ecoModeService?.updateCharacteristic(this.platform.Characteristic.On, this.getEcoMode());
+                this.breezeAwayService?.updateCharacteristic(this.platform.Characteristic.On, this.getBreezeAway());
+                this.auxService?.updateCharacteristic(this.platform.Characteristic.On, this.getAux());
+                this.auxHeatingService?.updateCharacteristic(this.platform.Characteristic.On, this.getAuxHeating());
             }
         }
     }
@@ -434,7 +438,7 @@ export default class AirConditionerAccessory extends BaseAccessory {
     async setActive(value) {
         await this.device.set_attribute({ POWER: !!value });
         this.device.attributes.SCREEN_DISPLAY = !!value;
-        this.displayService?.getCharacteristic(this.platform.Characteristic.On).updateValue(!!value);
+        this.displayService?.updateCharacteristic(this.platform.Characteristic.On, !!value);
     }
     getTemperatureDisplayUnits() {
         return this.device.attributes.TEMP_FAHRENHEIT
@@ -447,60 +451,97 @@ export default class AirConditionerAccessory extends BaseAccessory {
         });
     }
     getCurrentHeaterCoolerState() {
-        if (this.device.attributes.POWER && this.device.attributes.MODE > 0 && this.device.attributes.MODE < 5) {
-            if (this.device.attributes.TARGET_TEMPERATURE < (this.device.attributes.INDOOR_TEMPERATURE ?? 0)) {
-                if ([1, 2].includes(this.device.attributes.MODE)) {
-                    return this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
-                }
-                return this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
-            }
-            if (this.device.attributes.TARGET_TEMPERATURE === this.device.attributes.INDOOR_TEMPERATURE) {
-                return this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
-            }
-            if (this.device.attributes.MODE === 4) {
-                return this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
-            }
-            return this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
+        const { CurrentHeaterCoolerState } = this.platform.Characteristic;
+        if (!this.device.attributes.POWER || !this.device.attributes.MODE) {
+            return CurrentHeaterCoolerState.INACTIVE;
         }
-        return this.platform.Characteristic.CurrentHeaterCoolerState.INACTIVE;
+        const isPossiblyCooling = [ACMode.COOLING, ACMode.AUTO].includes(this.device.attributes.MODE);
+        const isPossiblyHeating = [ACMode.HEATING, ACMode.AUTO].includes(this.device.attributes.MODE) && this.configDev.AC_options.heatingCapable;
+        const currentTemperature = Number(this.getCurrentTemperature());
+        const heatingThresholdTemperature = Number(this.getHeatingThresholdTemperature());
+        const coolingThresholdTemperature = Number(this.getCoolingThresholdTemperature());
+        if (isPossiblyCooling && currentTemperature > coolingThresholdTemperature) {
+            return CurrentHeaterCoolerState.COOLING;
+        }
+        if (isPossiblyHeating && currentTemperature < heatingThresholdTemperature) {
+            return CurrentHeaterCoolerState.HEATING;
+        }
+        return CurrentHeaterCoolerState.IDLE;
     }
     getTargetHeaterCoolerState() {
-        if (this.device.attributes.MODE === 2) {
-            return this.platform.Characteristic.TargetHeaterCoolerState.COOL;
+        switch (this.device.attributes.MODE) {
+            case ACMode.COOLING:
+                return this.platform.Characteristic.TargetHeaterCoolerState.COOL;
+            case ACMode.HEATING:
+                return this.platform.Characteristic.TargetHeaterCoolerState.HEAT;
+            default:
+                return this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
         }
-        if (this.device.attributes.MODE === 4) {
-            return this.platform.Characteristic.TargetHeaterCoolerState.HEAT;
-        }
-        return this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
     }
     async setTargetHeaterCoolerState(value) {
         switch (value) {
             case this.platform.Characteristic.TargetHeaterCoolerState.AUTO:
-                await this.device.set_attribute({ POWER: true, MODE: 1 });
+                await this.device.set_attribute({ POWER: true, MODE: ACMode.AUTO });
                 break;
             case this.platform.Characteristic.TargetHeaterCoolerState.COOL:
-                await this.device.set_attribute({ POWER: true, MODE: 2 });
+                await this.device.set_attribute({ POWER: true, MODE: ACMode.COOLING });
                 break;
             case this.platform.Characteristic.TargetHeaterCoolerState.HEAT:
-                await this.device.set_attribute({ POWER: true, MODE: 4 });
+                await this.device.set_attribute({ POWER: true, MODE: ACMode.HEATING });
                 break;
         }
+        await this.setTargetTemperatureWithinThresholds();
     }
     getCurrentTemperature() {
         return this.device.attributes.INDOOR_TEMPERATURE ?? this.configDev.AC_options.minTemp;
     }
     getTargetTemperature() {
-        return limitValue(this.device.attributes.TARGET_TEMPERATURE, this.configDev.AC_options.minTemp, this.configDev.AC_options.maxTemp);
+        const { minTemp, maxTemp } = this.configDev.AC_options;
+        return limitValue(this.device.attributes.TARGET_TEMPERATURE, minTemp, maxTemp);
+    }
+    async setTargetTemperature(value) {
+        const { minTemp, maxTemp, tempStep } = this.configDev.AC_options;
+        const target = limitValue(Math.round(+value / tempStep) * tempStep, minTemp, maxTemp);
+        if (this.getTargetTemperature() === target)
+            return;
+        await this.device.set_target_temperature(target);
+    }
+    async setTargetTemperatureWithinThresholds() {
+        if (this.device.attributes.MODE === ACMode.COOLING) {
+            await this.setTargetTemperature(this.getCoolingThresholdTemperature());
+            return;
+        }
+        if (this.device.attributes.MODE === ACMode.HEATING) {
+            await this.setTargetTemperature(this.getHeatingThresholdTemperature());
+            return;
+        }
+        if (this.getCurrentTemperature() > this.getCoolingThresholdTemperature()) {
+            await this.setTargetTemperature(this.getCoolingThresholdTemperature());
+            return;
+        }
+        if (this.getCurrentTemperature() < this.getHeatingThresholdTemperature()) {
+            await this.setTargetTemperature(this.getHeatingThresholdTemperature());
+            return;
+        }
+        await this.setTargetTemperature(this.getCurrentTemperature());
+    }
+    getCoolingThresholdTemperature() {
+        const { minTemp, maxTemp } = this.configDev.AC_options;
+        return limitValue(this.coolingThresholdTemperature, minTemp, maxTemp);
+    }
+    getHeatingThresholdTemperature() {
+        const { minTemp, maxTemp } = this.configDev.AC_options;
+        return limitValue(this.heatingThresholdTemperature, minTemp, maxTemp);
     }
     getFanOnlyMode() {
-        return this.device.attributes.POWER === true && this.device.attributes.MODE === 5;
+        return this.device.attributes.POWER === true && this.device.attributes.MODE === ACMode.FAN_ONLY;
     }
     async setFanOnlyMode(value) {
         if (value) {
-            await this.device.set_attribute({ POWER: true, MODE: 5 });
+            await this.device.set_attribute({ POWER: true, MODE: ACMode.FAN_ONLY });
         }
         else {
-            await this.device.set_attribute({ POWER: false, MODE: 0 });
+            await this.device.set_attribute({ POWER: false, MODE: ACMode.OFF });
         }
     }
     getFanState() {
@@ -509,8 +550,30 @@ export default class AirConditionerAccessory extends BaseAccessory {
     async setFanState(value) {
         await this.device.set_fan_auto(value === this.platform.Characteristic.TargetFanState.AUTO);
     }
-    async setTargetTemperature(value) {
-        await this.device.set_target_temperature(limitValue(value, this.configDev.AC_options.minTemp, this.configDev.AC_options.maxTemp));
+    setHeatingCoolingTemperatureThresholds(thresholds) {
+        const { minTemp, maxTemp, tempStep } = this.configDev.AC_options;
+        const heating = limitValue(thresholds?.heating ?? this.heatingThresholdTemperature, minTemp, maxTemp);
+        const cooling = limitValue(thresholds?.cooling ?? this.coolingThresholdTemperature, minTemp, maxTemp);
+        if (heating === this.heatingThresholdTemperature && cooling === this.coolingThresholdTemperature)
+            return;
+        this.heatingThresholdTemperature = !thresholds?.cooling || heating < cooling ? heating : cooling - tempStep;
+        this.coolingThresholdTemperature = !thresholds?.heating || heating < cooling ? cooling : heating + tempStep;
+        this.service.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, this.getHeatingThresholdTemperature());
+        this.service.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, this.getCoolingThresholdTemperature());
+        const { context: ctx } = this.accessory;
+        ctx.thresholds ??= {};
+        this.platform.log.debug(`[${this.device.name}] Persisting updated heating and cooling thresholds`);
+        ctx.thresholds.heatingTemperature = this.heatingThresholdTemperature;
+        ctx.thresholds.coolingTemperature = this.coolingThresholdTemperature;
+        this.platform.api.updatePlatformAccessories([this.accessory]);
+    }
+    async setCoolingThresholdTemperature(value) {
+        this.setHeatingCoolingTemperatureThresholds({ cooling: Number(value) });
+        await this.setTargetTemperatureWithinThresholds();
+    }
+    async setHeatingThresholdTemperature(value) {
+        this.setHeatingCoolingTemperatureThresholds({ heating: Number(value) });
+        await this.setTargetTemperatureWithinThresholds();
     }
     getSwingMode() {
         return this.device.attributes.SWING_HORIZONTAL || this.device.attributes.SWING_VERTICAL
@@ -557,14 +620,14 @@ export default class AirConditionerAccessory extends BaseAccessory {
         await this.device.set_attribute({ INDIRECT_WIND: !!value });
     }
     getDryMode() {
-        return this.device.attributes.POWER === true && this.device.attributes.MODE === 3;
+        return this.device.attributes.POWER === true && this.device.attributes.MODE === ACMode.DRY;
     }
     async setDryMode(value) {
         if (value) {
-            await this.device.set_attribute({ POWER: true, MODE: 3 });
+            await this.device.set_attribute({ POWER: true, MODE: ACMode.DRY });
         }
         else {
-            await this.device.set_attribute({ POWER: false, MODE: 0 });
+            await this.device.set_attribute({ POWER: false, MODE: ACMode.OFF });
         }
     }
     getBoostMode() {