homebridge-melcloud-control 4.3.16-beta.9 → 4.4.0-beta.0

package/CHANGELOG.md

@@ -22,6 +22,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Do not use Homebridge UI > v5.5.0 because of break config.json
 
+# [4.4.0] - (10.12.2025)
+
+## Changes
+
+- added possibility to set frost protection min/max temperaure (ATA, ATW)
+- added possibility to set overheat protection min/max temperture (ATA)
+- bump dependencies
+- cleanup
+
 # [4.3.16] - (09.12.2025)
 
 ## Changes

package/package.json

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

package/src/deviceatw.js

@@ -1054,27 +1054,95 @@ class DeviceAtw extends EventEmitter {
             }
 
             //frost protection
-            if (this.frostProtectionSupport && this.accessory.frostProtectionEnabled !== null) {
+            if (this.frostProtectionSupport && this.accessory.frostProtection.Enabled !== null) {
                 //control
                 if (this.logDebug) this.emit('debug', `Prepare frost protection control service`);
-                this.frostProtectionControlService = new Service.Switch(`${serviceName} Frost Protection`, `frostProtectionControlService${deviceId}`);
-                this.frostProtectionControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
-                this.frostProtectionControlService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Frost Protection`);
-                this.frostProtectionControlService.getCharacteristic(Characteristic.On)
+                const frostProtectionControlService = new Service.HeaterCooler(`${serviceName} Frost Protection`, `frostProtectionControlService${deviceId}`);
+                frostProtectionControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                frostProtectionControlService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Frost Protection`);
+                frostProtectionControlService.getCharacteristic(Characteristic.Active)
                     .onGet(async () => {
-                        const state = this.accessory.frostProtectionEnabled;
+                        const state = this.accessory.frostProtection.Enabled;
                         return state;
                     })
                     .onSet(async (state) => {
                         try {
-                            deviceData.FrostProtection.Enabled = state;
+                            deviceData.FrostProtection.Enabled = state ? true : false;
                             if (this.logInfo) this.emit('info', `Frost protection: ${state ? 'Enabled' : 'Disabled'}`);
                             await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'frostprotection');
                         } catch (error) {
                             if (this.logWarn) this.emit('warn', `Set frost protection error: ${error}`);
                         };
                     });
-                accessory.addService(this.frostProtectionControlService);
+                frostProtectionControlService.getCharacteristic(Characteristic.CurrentHeaterCoolerState)
+                    .onGet(async () => {
+                        const value = this.accessory.frostProtection.Active ? 2 : 1;
+                        return value;
+                    })
+                frostProtectionControlService.getCharacteristic(Characteristic.TargetHeaterCoolerState)
+                    .setProps({
+                        minValue: 0,
+                        maxValue: 0,
+                        validValues: [0]
+                    })
+                    .onGet(async () => {
+                        const value = 0
+                        return value;
+                    })
+                    .onSet(async (value) => {
+                        try {
+                            deviceData.FrostProtection.Enabled = true;
+                            if (this.logInfo) this.emit('info', `Frost protection: Enabled`);
+                            await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'frostprotection');
+                        } catch (error) {
+                            if (this.logWarn) this.emit('warn', `Set frost protection error: ${error}`);
+                        };
+                    });
+                frostProtectionControlService.getCharacteristic(Characteristic.CurrentTemperature)
+                    .onGet(async () => {
+                        const value = this.accessory.roomTemperature;
+                        return value;
+                    });
+                frostProtectionControlService.getCharacteristic(Characteristic.CoolingThresholdTemperature) //max
+                    .setProps({
+                        minValue: 6,
+                        maxValue: 16,
+                        minStep: 1
+                    })
+                    .onGet(async () => {
+                        const value = this.accessory.frostProtection.Max;
+                        return value;
+                    })
+                    .onSet(async (value) => {
+                        try {
+                            deviceData.FrostProtection.Max = value;
+                            if (this.logInfo) this.emit('info', `Set frost protection max. temperature: ${value}${this.accessory.temperatureUnit}`);
+                            await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'frostprotection');
+                        } catch (error) {
+                            if (this.logWarn) this.emit('warn', `Set frost protection max. temperature error: ${error}`);
+                        };
+                    });
+                frostProtectionControlService.getCharacteristic(Characteristic.HeatingThresholdTemperature) //min
+                    .setProps({
+                        minValue: 4,
+                        maxValue: 14,
+                        minStep: 1
+                    })
+                    .onGet(async () => {
+                        const value = this.accessory.frostProtection.Min;
+                        return value;
+                    })
+                    .onSet(async (value) => {
+                        try {
+                            deviceData.FrostProtection.Min = value;
+                            if (this.logInfo) this.emit('info', `Set frost protection min. temperature: ${value}${this.accessory.temperatureUnit}`);
+                            await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'frostprotection');
+                        } catch (error) {
+                            if (this.logWarn) this.emit('warn', `Set frost protection min. temperature error: ${error}`);
+                        };
+                    });
+                this.frostProtectionControlService = frostProtectionControlService;
+                accessory.addService(frostProtectionControlService);
 
                 if (this.logDebug) this.emit('debug', `Prepare frost protection control sensor service`);
                 this.frostProtectionControlSensorService = new Service.ContactSensor(`${serviceName} Frost Protection Control`, `frostProtectionControlSensorService${deviceId}`);
@@ -1082,7 +1150,7 @@ class DeviceAtw extends EventEmitter {
                 this.frostProtectionControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Frost Protection Control`);
                 this.frostProtectionControlSensorService.getCharacteristic(Characteristic.ContactSensorState)
                     .onGet(async () => {
-                        const state = this.accessory.frostProtectionEnabled;
+                        const state = this.accessory.frostProtection.Enabled;
                         return state;
                     })
                 accessory.addService(this.frostProtectionControlSensorService);
@@ -1094,7 +1162,7 @@ class DeviceAtw extends EventEmitter {
                 this.frostProtectionSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Frost Protection`);
                 this.frostProtectionSensorService.getCharacteristic(Characteristic.ContactSensorState)
                     .onGet(async () => {
-                        const state = this.accessory.frostProtectionActive;
+                        const state = this.accessory.frostProtection.Active;
                         return state;
                     })
                 accessory.addService(this.frostProtectionSensorService);
@@ -1609,8 +1677,7 @@ class DeviceAtw extends EventEmitter {
                     const holidayModeActive = deviceData.HolidayMode?.Active ?? false;
 
                     //protection
-                    const frostProtectionEnabled = deviceData.FrostProtection?.Enabled;
-                    const frostProtectionActive = deviceData.FrostProtection?.Active ?? false;
+                    const frostProtection = deviceData.FrostProtection ?? {};
 
                     //device info
                     const supportsStanbyMode = deviceData.Device[supportStandbyKey];
@@ -1719,8 +1786,7 @@ class DeviceAtw extends EventEmitter {
                         temperatureUnit: TemperatureDisplayUnits[this.accountInfo.useFahrenheit ? 1 : 0],
                         isConnected: isConnected,
                         isInError: isInError,
-                        frostProtectionEnabled: frostProtectionEnabled,
-                        frostProtectionActive: frostProtectionActive,
+                        frostProtection: frostProtection,
                         scheduleEnabled: scheduleEnabled,
                         holidayModeEnabled: holidayModeEnabled,
                         holidayModeActive: holidayModeActive,
@@ -2120,10 +2186,15 @@ class DeviceAtw extends EventEmitter {
                     this.errorService?.updateCharacteristic(Characteristic.ContactSensorState, isInError);
 
                     //frost protection
-                    if (this.frostProtectionSupport && frostProtectionEnabled !== null) {
-                        this.frostProtectionControlService?.updateCharacteristic(Characteristic.On, frostProtectionEnabled);
-                        this.frostProtectionControlSensorService?.updateCharacteristic(Characteristic.ContactSensorState, frostProtectionEnabled);
-                        this.frostProtectionSensorService?.updateCharacteristic(Characteristic.ContactSensorState, frostProtectionActive);
+                    if (this.frostProtectionSupport && frostProtection.Enabled !== null) {
+                        this.frostProtectionControlService?.updateCharacteristic(Characteristic.Active, frostProtection.Enabled);
+                        this.frostProtectionControlService?.updateCharacteristic(Characteristic.CurrentHeaterCoolerState, frostProtection.Active ? 2 : 1);
+                        this.frostProtectionControlService?.updateCharacteristic(Characteristic.TargetHeaterCoolerState, frostProtection.Active ? 2 : 1);
+                        this.frostProtectionControlService?.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature);
+                        this.frostProtectionControlService?.updateCharacteristic(Characteristic.CoolingThresholdTemperature, frostProtection.Max);
+                        this.frostProtectionControlService?.updateCharacteristic(Characteristic.HeatingThresholdTemperature, frostProtection.Min);
+                        this.frostProtectionControlSensorService?.updateCharacteristic(Characteristic.ContactSensorState, frostProtection.Enabled);
+                        this.frostProtectionSensorService?.updateCharacteristic(Characteristic.ContactSensorState, frostProtection.Active);
                     }
 
                     //holiday mode

package/src/functions.js

@@ -237,6 +237,48 @@ class Functions extends EventEmitter {
             })
         );
     }
+
+    async normalizeFrostProtection(min, max) {
+        // Clamp to allowed ranges
+        min = Math.min(Math.max(min, 4), 14);
+        max = Math.min(Math.max(max, 6), 16);
+
+        // Ensure difference of at least 2 degrees
+        if (max - min < 2) {
+            // Try increasing max if possible
+            const newMax = min + 2;
+            if (newMax <= 18) {
+                max = newMax;
+            } else {
+                // Otherwise lower min
+                const newMin = max - 2;
+                min = Math.max(newMin, 4);
+            }
+        }
+
+        return { min, max };
+    }
+
+    async normalizeOverheatProtection(min, max) {
+        // Clamp to allowed ranges
+        min = Math.min(Math.max(min, 31), 38);
+        max = Math.min(Math.max(max, 33), 40);
+
+        // Ensure difference of at least 2 degrees
+        if (max - min < 2) {
+            // Try increasing max if possible
+            const newMax = min + 2;
+            if (newMax <= 18) {
+                max = newMax;
+            } else {
+                // Otherwise lower min
+                const newMin = max - 2;
+                min = Math.max(newMin, 4);
+            }
+        }
+
+        return { min, max };
+    }
 }
 
 export default Functions

package/src/melcloudata.js

@@ -240,20 +240,22 @@ class MelCloudAta extends EventEmitter {
                 case "melcloudhome":
                     switch (flag) {
                         case 'frostprotection':
+                            let { frostMin, frostMax } = await this.functions.normalizeFrostProtection(deviceData.FrostProtection.Min, deviceData.FrostProtection.Max);
                             payload = {
                                 enabled: deviceData.FrostProtection.Enabled,
-                                min: deviceData.FrostProtection.Min,
-                                max: deviceData.FrostProtection.Max,
+                                min: frostMin,
+                                max: frostMax,
                                 units: { ATA: [deviceData.DeviceID] }
                             };
                             method = 'POST';
                             path = ApiUrlsHome.PostProtectionFrost;
                             break;
                         case 'overheatprotection':
+                            let { overMin, overMax } = await this.functions.normalizeOverheatProtection(deviceData.OverheatProtection.Min, deviceData.OverheatProtection.Max);
                             payload = {
                                 enabled: deviceData.OverheatProtection.Enabled,
-                                min: deviceData.OverheatProtection.Min,
-                                max: deviceData.OverheatProtection.Max,
+                                min: overMin,
+                                max: overMax,
                                 units: { ATA: [deviceData.DeviceID] }
                             };
                             method = 'POST';