homebridge-melcloud-control 3.3.4 → 3.3.8

package/CHANGELOG.md

@@ -16,6 +16,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - do not configure it manually, always using Config UI X
   - required Homebridge v2.0.0 and above
 
+## [3.3.5] - (15.09.2024)
+
+## Changes
+
+- fix[#162](https://github.com/grzegorz914/homebridge-melcloud-control/issues/162)
+- cleanup
+
 ## [3.3.3] - (13.09.2024)
 
 ## Changes

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "MELCloud Control",
   "name": "homebridge-melcloud-control",
-  "version": "3.3.4",
+  "version": "3.3.8",
   "description": "Homebridge plugin to control Mitsubishi Air Conditioner, Heat Pump and Energy Recovery Ventilation.",
   "license": "MIT",
   "author": "grzegorz914",

package/src/constants.json

@@ -78,6 +78,7 @@
             "3",
             "4",
             "5",
+            "6",
             "SWING"
         ],
         "FanSpeed": [
@@ -90,6 +91,17 @@
             "VERY STRONG",
             "OFF"
         ],
+        "CurrentOperationModeHeatherCooler": [
+            "INACTIVE",
+            "IDLE",
+            "HEATING",
+            "COOLING"
+        ],
+        "CurrentOperationModeThermostat": [
+            "INACTIVE",
+            "HEATING",
+            "COOLING"
+        ],
         "EffectiveFlags": {
             "Power": 1,
             "OperationMode": 2,
@@ -285,4 +297,4 @@
         "Quest": 3,
         "Owner": 4
     }
-}
+}

package/src/deviceata.js

@@ -36,7 +36,6 @@ class DeviceAta extends EventEmitter {
         this.deviceTypeText = deviceTypeText;
         this.devicesFile = devicesFile;
         this.refreshInterval = refreshInterval;
-        this.useFahrenheit = useFahrenheit;
         this.startPrepareAccessory = true;
         this.displayDeviceInfo = true;
 
@@ -97,6 +96,8 @@ class DeviceAta extends EventEmitter {
         this.accessory.currentOperationMode = 0;
         this.accessory.targetOperationMode = 0;
         this.accessory.fanSpeed = 0;
+        this.accessory.useFahrenheit = useFahrenheit ? 1 : 0;
+        this.accessory.temperatureUnit = CONSTANTS.TemperatureDisplayUnits[this.accessory.useFahrenheit];
     };
 
     async start() {
@@ -210,7 +211,6 @@ class DeviceAta extends EventEmitter {
                 })
                 .on('deviceState', async (deviceData) => {
                     //device info
-                    const displayMode = this.displayMode;
                     const hasAutomaticFanSpeed = deviceData.Device.HasAutomaticFanSpeed ?? false;
                     const airDirectionFunction = deviceData.Device.AirDirectionFunction ?? false;
                     const hasOutdoorTemperature = deviceData.Device.HasOutdoorTemperature ?? false;
@@ -223,16 +223,12 @@ class DeviceAta extends EventEmitter {
                     const modelSupportsAuto1 = deviceData.Device.ModelSupportsAuto ?? false;
                     const modelSupportsAuto = this.autoDryFanMode >= 1 && modelSupportsAuto1;
                     const modelSupportsDry = deviceData.Device.ModelSupportsDry ?? false;
-                    const temperatureIncrement = deviceData.Device.TemperatureIncrement ?? 1;
-                    const outdoorTemperature = deviceData.Device.OutdoorTemperature;
-                    const temperatureUnit = CONSTANTS.TemperatureDisplayUnits[this.useFahrenheit];
 
                     //presets
                     const presetsOnServer = deviceData.Presets ?? [];
 
                     //device state
                     const power = deviceData.Device.Power ?? false;
-                    const offline = deviceData.Device.Offline ?? false;
                     const inStandbyMode = deviceData.Device.InStandbyMode ?? false;
                     const roomTemperature = deviceData.Device.RoomTemperature;
                     const setTemperature = deviceData.Device.SetTemperature;
@@ -242,42 +238,42 @@ class DeviceAta extends EventEmitter {
                     const operationMode = deviceData.Device.OperationMode;
                     const vaneHorizontalDirection = deviceData.Device.VaneHorizontalDirection;
                     const vaneVerticalDirection = deviceData.Device.VaneVerticalDirection;
-                    const hideVaneControls = deviceData.Device.HideVaneControls;
-                    const hideDryModeControl = deviceData.Device.HideDryModeControl;
+                    const hideVaneControls = deviceData.Device.HideVaneControls ?? false;
+                    const hideDryModeControl = deviceData.Device.HideDryModeControl ?? false;
                     const prohibitSetTemperature = deviceData.Device.ProhibitSetTemperature ?? false;
                     const prohibitOperationMode = deviceData.Device.ProhibitOperationMode ?? false;
                     const prohibitPower = deviceData.Device.ProhibitPower ?? false;
+                    const temperatureIncrement = deviceData.Device.TemperatureIncrement ?? 1;
+                    const outdoorTemperature = deviceData.Device.OutdoorTemperature;
 
                     //accessory
-                    this.accessory.presetsOnServer = presetsOnServer;
+                    this.accessory.modelSupportsHeat = modelSupportsHeat;
+                    this.accessory.modelSupportsDry = modelSupportsDry;
+                    this.accessory.modelSupportsCool = modelSupportsCool;
+                    this.accessory.modelSupportsAuto = modelSupportsAuto;
+                    this.accessory.modelSupportsFanSpeed = modelSupportsFanSpeed;
+                    this.accessory.hasAutomaticFanSpeed = hasAutomaticFanSpeed;
+                    this.accessory.hasOutdoorTemperature = hasOutdoorTemperature;
+                    this.accessory.numberOfFanSpeeds = numberOfFanSpeeds;
+                    this.accessory.swingFunction = swingFunction;
+
+                    this.accessory.presets = presetsOnServer;
+
                     this.accessory.power = power ? 1 : 0;
-                    this.accessory.offline = offline ?? false;
+                    this.accessory.inStandbyMode = inStandbyMode;
+                    this.accessory.operationMode = operationMode;
+                    this.accessory.setTemperature = setTemperature;
                     this.accessory.roomTemperature = roomTemperature;
                     this.accessory.outdoorTemperature = outdoorTemperature;
-                    this.accessory.setTemperature = setTemperature;
                     this.accessory.defaultHeatingSetTemperature = defaultHeatingSetTemperature;
                     this.accessory.defaultCoolingSetTemperature = defaultCoolingSetTemperature;
                     this.accessory.fanSpeed = fanSpeed;
-                    this.accessory.vaneHorizontal = vaneHorizontalDirection;
-                    this.accessory.vaneVertical = vaneVerticalDirection;
                     this.accessory.swingMode = swingFunction && vaneHorizontalDirection === 12 && vaneVerticalDirection === 7 ? 1 : 0;
                     this.accessory.lockPhysicalControl = prohibitSetTemperature && prohibitOperationMode && prohibitPower ? 1 : 0;
                     this.accessory.temperatureIncrement = temperatureIncrement;
-                    this.accessory.useFahrenheit = this.useFahrenheit;
-                    this.accessory.temperatureUnit = temperatureUnit;
-                    this.accessory.hasAutomaticFanSpeed = hasAutomaticFanSpeed;
-                    this.accessory.airDirectionFunction = airDirectionFunction;
-                    this.accessory.hasOutdoorTemperature = hasOutdoorTemperature;
-                    this.accessory.swingFunction = swingFunction;
-                    this.accessory.numberOfFanSpeeds = numberOfFanSpeeds;
-                    this.accessory.modelSupportsHeat = modelSupportsHeat;
-                    this.accessory.modelSupportsCool = modelSupportsCool;
-                    this.accessory.modelSupportsAuto = modelSupportsAuto;
-                    this.accessory.modelSupportsFanSpeed = modelSupportsFanSpeed;
-                    this.accessory.modelSupportsDry = modelSupportsDry;
 
                     //operating mode
-                    switch (displayMode) {
+                    switch (this.displayMode) {
                         case 1: //Heater Cooler
                             //operating mode 0, HEAT, DRY, COOL, 4, 5, 6, FAN, AUTO, ISEE HEAT, ISEE DRY, ISEE COOL
                             switch (power) {
@@ -302,7 +298,20 @@ class DeviceAta extends EventEmitter {
                                                     this.accessory.targetOperationMode = this.autoDryFanMode === 3 ? 0 : this.heatDryFanMode === 3 ? 1 : this.coolDryFanMode === 3 ? 2 : this.accessory.targetOperationMode;
                                                     break;
                                                 case 8: //AUTO
-                                                    this.accessory.currentOperationMode = roomTemperature > defaultHeatingSetTemperature && roomTemperature < defaultCoolingSetTemperature ? 1 : roomTemperature <= defaultHeatingSetTemperature ? 2 : roomTemperature >= defaultCoolingSetTemperature ? 3 : 0;
+                                                    const curentModeInAuto = roomTemperature < defaultHeatingSetTemperature ? 'HEATING' : roomTemperature > defaultCoolingSetTemperature ? 'COOLING' : '';
+                                                    switch (curentModeInAuto) {
+                                                        case 'HEATING': //HEATING
+                                                            const heatingToFan = roomTemperature > defaultHeatingSetTemperature + 1;
+                                                            this.accessory.currentOperationMode = heatingToFan ? 1 : 2;
+                                                            break;
+                                                        case 'COOLING': //COOLING
+                                                            const coolingToFan = roomTemperature < defaultCoolingSetTemperature - 1;
+                                                            this.accessory.currentOperationMode = coolingToFan ? 1 : 3;
+                                                            break;
+                                                        default: //FAN
+                                                            this.accessory.currentOperationMode = roomTemperature <= defaultHeatingSetTemperature ? 2 : roomTemperature >= defaultCoolingSetTemperature ? 3 : 1;
+                                                            break;
+                                                    };
                                                     this.accessory.targetOperationMode = 0;
                                                     break;
                                                 case 9: //ISEE HEAT
@@ -365,14 +374,14 @@ class DeviceAta extends EventEmitter {
                             //update characteristics
                             if (this.melCloudService) {
                                 this.melCloudService
-                                    .updateCharacteristic(Characteristic.Active, this.accessory.power)
+                                    .updateCharacteristic(Characteristic.Active, power ? 1 : 0)
                                     .updateCharacteristic(Characteristic.CurrentHeaterCoolerState, this.accessory.currentOperationMode)
                                     .updateCharacteristic(Characteristic.TargetHeaterCoolerState, this.accessory.targetOperationMode)
                                     .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
                                     .updateCharacteristic(Characteristic.LockPhysicalControls, this.accessory.lockPhysicalControl)
                                     .updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
-                                const updateDefHeat = modelSupportsAuto && modelSupportsHeat ? this.melCloudService.updateCharacteristic(Characteristic.HeatingThresholdTemperature, defaultHeatingSetTemperature) : false;
-                                const updateDefCool = modelSupportsAuto && modelSupportsCool ? this.melCloudService.updateCharacteristic(Characteristic.CoolingThresholdTemperature, defaultCoolingSetTemperature) : false;
+                                const updateDefHeat = modelSupportsHeat ? this.melCloudService.updateCharacteristic(Characteristic.HeatingThresholdTemperature, operationMode === 8 ? defaultHeatingSetTemperature : setTemperature) : false;
+                                const updateDefCool = modelSupportsCool ? this.melCloudService.updateCharacteristic(Characteristic.CoolingThresholdTemperature, operationMode === 8 ? defaultCoolingSetTemperature : setTemperature) : false;
                                 const updateRS = modelSupportsFanSpeed ? this.melCloudService.updateCharacteristic(Characteristic.RotationSpeed, this.accessory.fanSpeed) : false;
                                 const updateSM = swingFunction ? this.melCloudService.updateCharacteristic(Characteristic.SwingMode, this.accessory.swingMode) : false;
                             };
@@ -384,7 +393,7 @@ class DeviceAta extends EventEmitter {
                                         case true:
                                             switch (operationMode) {
                                                 case 1: //HEAT
-                                                    this.accessory.currentOperationMode = 1; //OFF, HEAT, COOL
+                                                    this.accessory.currentOperationMode = 1; //OFF, HEATING, COOLING
                                                     this.accessory.targetOperationMode = 1; //OFF, HEAT, COOL, AUTO
                                                     break;
                                                 case 2: //DRY
@@ -400,7 +409,20 @@ class DeviceAta extends EventEmitter {
                                                     this.accessory.targetOperationMode = this.autoDryFanMode === 3 ? 3 : this.heatDryFanMode === 3 ? 1 : this.coolDryFanMode === 3 ? 2 : this.accessory.targetOperationMode;
                                                     break;
                                                 case 8: //AUTO
-                                                    this.accessory.currentOperationMode = roomTemperature > defaultHeatingSetTemperature && roomTemperature < defaultCoolingSetTemperature ? this.accessory.currentOperationMode : roomTemperature <= defaultHeatingSetTemperature ? 1 : roomTemperature >= defaultCoolingSetTemperature ? 2 : 0;
+                                                    const curentModeInAuto = roomTemperature < defaultHeatingSetTemperature ? 'HEATING' : roomTemperature > defaultCoolingSetTemperature ? 'COOLING' : '';
+                                                    switch (curentModeInAuto) {
+                                                        case 'HEATING': //HEATING
+                                                            const heatingToFan = roomTemperature > defaultHeatingSetTemperature + 1;
+                                                            this.accessory.currentOperationMode = heatingToFan ? 0 : 1;
+                                                            break;
+                                                        case 'COOLING': //COOLING
+                                                            const coolingToFan = roomTemperature < defaultCoolingSetTemperature - 1;
+                                                            this.accessory.currentOperationMode = cooling ? 0 : 2;
+                                                            break;
+                                                        default: //FAN
+                                                            this.accessory.currentOperationMode = roomTemperature <= defaultHeatingSetTemperature ? 1 : roomTemperature >= defaultCoolingSetTemperature ? 2 : 0;
+                                                            break;
+                                                    };
                                                     this.accessory.targetOperationMode = 3;
                                                     break;
                                                 case 9: //ISEE HEAT
@@ -422,12 +444,10 @@ class DeviceAta extends EventEmitter {
                                             break;
                                         case false:
                                             this.accessory.currentOperationMode = 0;
-                                            this.accessory.targetOperationMode = 0;
                                             break;
                                     };
                                 case false:
                                     this.accessory.currentOperationMode = 0;
-                                    this.accessory.targetOperationMode = 0;
                                     break;
                             };
                             this.accessory.operationModeSetPropsMinValue = 0
@@ -608,17 +628,18 @@ class DeviceAta extends EventEmitter {
                     //log current state
                     if (!this.disableLogInfo) {
                         this.emit('message', `Power: ${power ? 'ON' : 'OFF'}`);
-                        this.emit('message', `Operation mode: ${CONSTANTS.AirConditioner.DriveMode[operationMode]}`);
-                        this.emit('message', `Room temperature: ${roomTemperature}${temperatureUnit}`);
-                        const info = hasOutdoorTemperature && this.accessory.outdoorTemperature !== null ? this.emit('message', `Outdoor temperature: ${outdoorTemperature}${temperatureUnit}`) : false;
-                        const info0 = operationMode !== 8 ? this.emit('message', `Target temperature: ${setTemperature}${temperatureUnit}`) : false;
-                        const info1 = operationMode === 8 && modelSupportsAuto && modelSupportsHeat ? this.emit('message', `Heating threshold temperature: ${defaultHeatingSetTemperature}${temperatureUnit}`) : false;
-                        const info2 = operationMode === 8 && modelSupportsAuto && modelSupportsCool ? this.emit('message', `Cooling threshold temperature: ${defaultCoolingSetTemperature}${temperatureUnit}`) : false;
+                        this.emit('message', `Target operation mode: ${CONSTANTS.AirConditioner.DriveMode[operationMode]}`);
+                        this.emit('message', `Current operation mode: ${this.displayMode === 1 ? CONSTANTS.AirConditioner.CurrentOperationModeHeatherCooler[this.accessory.currentOperationMode] : CONSTANTS.AirConditioner.CurrentOperationModeThermostat[this.accessory.currentOperationMode]}`);
+                        this.emit('message', `Room temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
+                        const info = hasOutdoorTemperature && deviceData.Device.OutdoorTemperature !== null ? this.emit('message', `Outdoor temperature: ${outdoorTemperature}${this.accessory.temperatureUnit}`) : false;
+                        const info0 = operationMode !== 8 ? this.emit('message', `Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`) : false;
+                        const info1 = operationMode === 8 && modelSupportsHeat ? this.emit('message', `Heating threshold temperature: ${defaultHeatingSetTemperature}${this.accessory.temperatureUnit}`) : false;
+                        const info2 = operationMode === 8 && modelSupportsCool ? this.emit('message', `Cooling threshold temperature: ${defaultCoolingSetTemperature}${this.accessory.temperatureUnit}`) : false;
                         const info3 = modelSupportsFanSpeed ? this.emit('message', `Fan speed mode: ${CONSTANTS.AirConditioner.FanSpeed[fanSpeed]}`) : false;
                         const info4 = vaneHorizontalDirection !== null ? this.emit('message', `Vane horizontal: ${CONSTANTS.AirConditioner.HorizontalVane[vaneHorizontalDirection]}`) : false;
                         const info5 = vaneVerticalDirection !== null ? this.emit('message', `Vane vertical: ${CONSTANTS.AirConditioner.VerticalVane[vaneVerticalDirection]}`) : false;
-                        const info6 = swingFunction ? this.emit('message', `Vane swing mode: ${CONSTANTS.AirConditioner.AirDirection[this.accessory.swingMode ? 6 : 0]}`) : false;
-                        this.emit('message', `Temperature display unit: ${temperatureUnit}`);
+                        const info6 = swingFunction ? this.emit('message', `Air direction: ${CONSTANTS.AirConditioner.AirDirection[this.accessory.swingMode ? 7 : 0]}`) : false;
+                        this.emit('message', `Temperature display unit: ${this.accessory.temperatureUnit}`);
                         this.emit('message', `Lock physical controls: ${this.accessory.lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
                     };
 
@@ -626,7 +647,6 @@ class DeviceAta extends EventEmitter {
                     if (!this.startPrepareAccessory) {
                         return;
                     }
-
                     try {
                         const accessory = await this.prepareAccessory(this.accountInfo, deviceData, this.deviceId, this.deviceTypeText, this.deviceName, this.accountName);
                         this.emit('publishAccessory', accessory);
@@ -742,6 +762,20 @@ class DeviceAta extends EventEmitter {
     //prepare accessory
     async prepareAccessory(accountInfo, deviceData, deviceId, deviceTypeText, deviceName, accountName) {
         try {
+            const modelSupportsHeat = this.accessory.modelSupportsHeat;
+            const modelSupportsDry = this.accessory.modelSupportsDry;
+            const modelSupportsCool = this.accessory.modelSupportsCool;
+            const modelSupportsAuto = this.accessory.modelSupportsAuto;
+            const modelSupportsFanSpeed = this.accessory.modelSupportsFanSpeed;
+            const hasAutomaticFanSpeed = this.accessory.hasAutomaticFanSpeed;
+            const hasOutdoorTemperature = this.accessory.hasOutdoorTemperature;
+            const numberOfFanSpeeds = this.accessory.numberOfFanSpeeds;
+            const swingFunction = this.accessory.swingFunction;
+            const presetsOnServer = this.accessory.presets;
+            const autoDryFanMode = [this.accessory.operationMode, 8, modelSupportsDry ? 2 : 8, 7][this.autoDryFanMode]; //NONE, AUTO - 8, DRY - 2, FAN - 7
+            const heatDryFanMode = [this.accessory.operationMode, 1, modelSupportsDry ? 2 : 1, 7][this.heatDryFanMode]; //NONE, HEAT - 1, DRY - 2, FAN - 7
+            const coolDryFanMode = [this.accessory.operationMode, 3, modelSupportsDry ? 2 : 3, 7][this.coolDryFanMode]; //NONE, COOL - 3, DRY - 2, FAN - 7
+
             //accessory
             const debug = this.enableDebugMode ? this.emit('debug', `Prepare accessory`) : false;
             const accessoryName = deviceName;
@@ -758,25 +792,8 @@ class DeviceAta extends EventEmitter {
                 .setCharacteristic(Characteristic.FirmwareRevision, this.firmwareRevision);
 
             //melcloud services
-            const displayMode = this.displayMode;
-            const temperatureSensor = this.temperatureSensor;
-            const temperatureSensorOutdoor = this.temperatureSensorOutdoor;
-            const hasAutomaticFanSpeed = this.accessory.hasAutomaticFanSpeed;
-            const modelSupportsHeat = this.accessory.modelSupportsHeat;
-            const modelSupportsCool = this.accessory.modelSupportsCool;
-            const modelSupportsAuto = this.accessory.modelSupportsAuto;
-            const modelSupportsFanSpeed = this.accessory.modelSupportsFanSpeed;
-            const modelSupportsDry = this.accessory.modelSupportsDry;
-            const numberOfFanSpeeds = this.accessory.numberOfFanSpeeds;
-            const swingFunction = this.accessory.swingFunction;
-            const hasOutdoorTemperature = this.accessory.hasOutdoorTemperature;
-            const presetsOnServer = this.accessory.presetsOnServer;
-            const autoDryFanMode = [deviceData.Device.OperationMode, 8, modelSupportsDry ? 2 : 8, 7][this.autoDryFanMode]; //NONE, AUTO - 8, DRY - 2, FAN - 7
-            const heatDryFanMode = [deviceData.Device.OperationMode, 1, modelSupportsDry ? 2 : 1, 7][this.heatDryFanMode]; //NONE, HEAT - 1, DRY - 2, FAN - 7
-            const coolDryFanMode = [deviceData.Device.OperationMode, 3, modelSupportsDry ? 2 : 3, 7][this.coolDryFanMode]; //NONE, COOL - 3, DRY - 2, FAN - 7
             const serviceName = `${deviceTypeText} ${accessoryName}`;
-
-            switch (displayMode) {
+            switch (this.displayMode) {
                 case 1: //Heater Cooler
                     const debug = this.enableDebugMode ? this.emit('debug', `Prepare heater/cooler service`) : false;
                     this.melCloudService = new Service.HeaterCooler(serviceName, `HeaterCooler ${deviceId}`);
@@ -815,18 +832,16 @@ class DeviceAta extends EventEmitter {
                                 switch (value) {
                                     case 0: //AUTO - AUTO
                                         deviceData.Device.OperationMode = autoDryFanMode;
-                                        deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.OperationMode;
                                         break;
                                     case 1: //HEAT - HEAT
                                         deviceData.Device.OperationMode = heatDryFanMode;
-                                        deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.OperationMode;
                                         break;
                                     case 2: //COOL - COOL
                                         deviceData.Device.OperationMode = coolDryFanMode;
-                                        deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.OperationMode;
                                         break;
                                 };
 
+                                deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.OperationMode;
                                 await this.melCloudAta.send(deviceData);
                                 const operationModeText = CONSTANTS.AirConditioner.DriveMode[deviceData.Device.OperationMode];
                                 const info = this.disableLogInfo ? false : this.emit('message', `Set operation mode: ${operationModeText}`);
@@ -887,7 +902,7 @@ class DeviceAta extends EventEmitter {
                     if (swingFunction) {
                         this.melCloudService.getCharacteristic(Characteristic.SwingMode)
                             .onGet(async () => {
-                                //Vane Horizontal: Auto, 1, 2, 3, 4, 5, 12 = Swing //Vertical: Auto, 1, 2, 3, 4, 5, 7 = Swing
+                                //Vane Horizontal: Auto, 1, 2, 3, 4, 5, 6, 12 = Swing //Vertical: Auto, 1, 2, 3, 4, 5, 7 = Swing
                                 const value = this.accessory.swingMode;
                                 return value;
                             })
@@ -897,53 +912,68 @@ class DeviceAta extends EventEmitter {
                                     deviceData.Device.VaneVertical = value ? 7 : 0;
                                     deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.VaneHorizontal + CONSTANTS.AirConditioner.EffectiveFlags.VaneVertical;
                                     await this.melCloudAta.send(deviceData);
-                                    const info = this.disableLogInfo ? false : this.emit('message', `Set vane swing mode: ${CONSTANTS.AirConditioner.AirDirection[value ? 6 : 0]}`);
+                                    const info = this.disableLogInfo ? false : this.emit('message', `Set air direction mode: ${CONSTANTS.AirConditioner.AirDirection[value ? 7 : 0]}`);
                                 } catch (error) {
                                     this.emit('warn', `Set vane swing mode error: ${error}`);
                                 };
                             });
                     };
-                    if (modelSupportsAuto && modelSupportsHeat) {
-                        this.melCloudService.getCharacteristic(Characteristic.HeatingThresholdTemperature)
+                    if (modelSupportsCool) {
+                        this.melCloudService.getCharacteristic(Characteristic.CoolingThresholdTemperature)
                             .setProps({
-                                minValue: 10,
+                                minValue: 16,
                                 maxValue: 31,
                                 minStep: this.accessory.temperatureIncrement
                             })
                             .onGet(async () => {
-                                const value = this.accessory.defaultHeatingSetTemperature;
+                                const value = this.accessory.operationMode === 8 ? this.accessory.defaultCoolingSetTemperature : this.accessory.setTemperature;
                                 return value;
                             })
                             .onSet(async (value) => {
                                 try {
-                                    deviceData.Device.DefaultHeatingSetTemperature = value;
+                                    switch (this.accessory.operationMode) {
+                                        case 8: //AUTO - AUTO
+                                            deviceData.Device.DefaultCoolingSetTemperature = value;
+                                            break;
+                                        default:
+                                            deviceData.Device.SetTemperature = value;
+                                            break
+                                    };
                                     deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.SetTemperature;
                                     await this.melCloudAta.send(deviceData);
-                                    const info = this.disableLogInfo ? false : this.emit('message', `Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
+                                    const info = this.disableLogInfo ? false : this.emit('message', `Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
                                 } catch (error) {
-                                    this.emit('warn', `Set heating threshold temperature error: ${error}`);
+                                    this.emit('warn', `Set cooling threshold temperature error: ${error}`);
                                 };
                             });
                     };
-                    if (modelSupportsAuto && modelSupportsCool) {
-                        this.melCloudService.getCharacteristic(Characteristic.CoolingThresholdTemperature)
+                    if (modelSupportsHeat) {
+                        this.melCloudService.getCharacteristic(Characteristic.HeatingThresholdTemperature)
                             .setProps({
-                                minValue: 16,
+                                minValue: 10,
                                 maxValue: 31,
                                 minStep: this.accessory.temperatureIncrement
                             })
                             .onGet(async () => {
-                                const value = this.accessory.defaultCoolingSetTemperature;
+                                const value = this.accessory.operationMode === 8 ? this.accessory.defaultHeatingSetTemperature : this.accessory.setTemperature;
                                 return value;
                             })
                             .onSet(async (value) => {
                                 try {
-                                    deviceData.Device.DefaultCoolingSetTemperature = value;
+                                    switch (this.accessory.operationMode) {
+                                        case 8: //AUTO - AUTO
+                                            deviceData.Device.DefaultHeatingSetTemperature = value;
+                                            break;
+                                        default:
+                                            deviceData.Device.SetTemperature = value;
+                                            break
+                                    };
+
                                     deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.SetTemperature;
                                     await this.melCloudAta.send(deviceData);
-                                    const info = this.disableLogInfo ? false : this.emit('message', `Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
+                                    const info = this.disableLogInfo ? false : this.emit('message', `Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
                                 } catch (error) {
-                                    this.emit('warn', `Set cooling threshold temperature error: ${error}`);
+                                    this.emit('warn', `Set heating threshold temperature error: ${error}`);
                                 };
                             });
                     };
@@ -972,7 +1002,7 @@ class DeviceAta extends EventEmitter {
                         })
                         .onSet(async (value) => {
                             try {
-                                accountInfo.UseFahrenheit = value ? true : false;
+                                accountInfo.UseFahrenheit = [false, true][value];
                                 await this.melCloud.send(accountInfo);
                                 const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${CONSTANTS.TemperatureDisplayUnits[value]}`);
                             } catch (error) {
@@ -1055,49 +1085,51 @@ class DeviceAta extends EventEmitter {
                                 this.emit('warn', `Set temperature error: ${error}`);
                             };
                         });
-                    if (modelSupportsAuto && modelSupportsHeat) {
-                        this.melCloudService.getCharacteristic(Characteristic.HeatingThresholdTemperature)
-                            .setProps({
-                                minValue: 10,
-                                maxValue: 31,
-                                minStep: this.accessory.temperatureIncrement
-                            })
-                            .onGet(async () => {
-                                const value = this.accessory.defaultHeatingSetTemperature;
-                                return value;
-                            })
-                            .onSet(async (value) => {
-                                try {
-                                    deviceData.Device.DefaultHeatingSetTemperature = value;
-                                    deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.SetTemperature;
-                                    await this.melCloudAta.send(deviceData);
-                                    const info = this.disableLogInfo ? false : this.emit('message', `Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
-                                } catch (error) {
-                                    this.emit('warn', `Set heating threshold temperature error: ${error}`);
-                                };
-                            });
-                    };
-                    if (modelSupportsAuto && modelSupportsCool) {
-                        this.melCloudService.getCharacteristic(Characteristic.CoolingThresholdTemperature)
-                            .setProps({
-                                minValue: 16,
-                                maxValue: 31,
-                                minStep: this.accessory.temperatureIncrement
-                            })
-                            .onGet(async () => {
-                                const value = this.accessory.defaultCoolingSetTemperature;
-                                return value;
-                            })
-                            .onSet(async (value) => {
-                                try {
-                                    deviceData.Device.DefaultCoolingSetTemperature = value;
-                                    deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.SetTemperature;
-                                    await this.melCloudAta.send(deviceData);
-                                    const info = this.disableLogInfo ? false : this.emit('message', `Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
-                                } catch (error) {
-                                    this.emit('warn', `Set cooling threshold temperature error: ${error}`);
-                                };
-                            });
+                    if (modelSupportsAuto) {
+                        if (modelSupportsHeat) {
+                            this.melCloudService.getCharacteristic(Characteristic.HeatingThresholdTemperature)
+                                .setProps({
+                                    minValue: 10,
+                                    maxValue: 31,
+                                    minStep: this.accessory.temperatureIncrement
+                                })
+                                .onGet(async () => {
+                                    const value = this.accessory.defaultHeatingSetTemperature;
+                                    return value;
+                                })
+                                .onSet(async (value) => {
+                                    try {
+                                        deviceData.Device.DefaultHeatingSetTemperature = value;
+                                        deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.SetTemperature;
+                                        await this.melCloudAta.send(deviceData);
+                                        const info = this.disableLogInfo ? false : this.emit('message', `Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
+                                    } catch (error) {
+                                        this.emit('warn', `Set heating threshold temperature error: ${error}`);
+                                    };
+                                });
+                        };
+                        if (modelSupportsCool) {
+                            this.melCloudService.getCharacteristic(Characteristic.CoolingThresholdTemperature)
+                                .setProps({
+                                    minValue: 16,
+                                    maxValue: 31,
+                                    minStep: this.accessory.temperatureIncrement
+                                })
+                                .onGet(async () => {
+                                    const value = this.accessory.defaultCoolingSetTemperature;
+                                    return value;
+                                })
+                                .onSet(async (value) => {
+                                    try {
+                                        deviceData.Device.DefaultCoolingSetTemperature = value;
+                                        deviceData.Device.EffectiveFlags = CONSTANTS.AirConditioner.EffectiveFlags.SetTemperature;
+                                        await this.melCloudAta.send(deviceData);
+                                        const info = this.disableLogInfo ? false : this.emit('message', `Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
+                                    } catch (error) {
+                                        this.emit('warn', `Set cooling threshold temperature error: ${error}`);
+                                    };
+                                });
+                        };
                     };
                     this.melCloudService.getCharacteristic(Characteristic.TemperatureDisplayUnits)
                         .onGet(async () => {
@@ -1106,7 +1138,7 @@ class DeviceAta extends EventEmitter {
                         })
                         .onSet(async (value) => {
                             try {
-                                accountInfo.UseFahrenheit = value ? true : false;
+                                accountInfo.UseFahrenheit = [false, true][value];
                                 await this.melCloud.send(accountInfo);
                                 const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${CONSTANTS.TemperatureDisplayUnits[value]}`);
                             } catch (error) {
@@ -1118,7 +1150,7 @@ class DeviceAta extends EventEmitter {
             };
 
             //temperature sensor services
-            if (temperatureSensor && this.accessory.roomTemperature !== null) {
+            if (this.temperatureSensor && this.accessory.roomTemperature !== null) {
                 const debug = this.enableDebugMode ? this.emit('debug', `Prepare room temperature sensor service`) : false;
                 this.roomTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Room`, `Room Temperature Sensor ${deviceId}`);
                 this.roomTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
@@ -1136,7 +1168,7 @@ class DeviceAta extends EventEmitter {
                 accessory.addService(this.roomTemperatureSensorService);
             };
 
-            if (temperatureSensorOutdoor && hasOutdoorTemperature && this.accessory.outdoorTemperature !== null) {
+            if (this.temperatureSensorOutdoor && hasOutdoorTemperature && this.accessory.outdoorTemperature !== null) {
                 const debug = this.enableDebugMode ? this.emit('debug', `Prepare outdoor temperature sensor service`) : false;
                 this.outdoorTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Outdoor`, `Outdoor Temperature Sensor ${deviceId}`);
                 this.outdoorTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);