homebridge-melcloud-control 4.3.16-beta.0 → 4.3.16-beta.10

package/CHANGELOG.md

@@ -22,6 +22,24 @@ 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
+
+- stability and performance improvements
+- moved MQTT to v5
+- bump dependencies
+- cleanup
+
 # [4.3.11] - (07.12.2025)
 
 ## Changes

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "MELCloud Control",
   "name": "homebridge-melcloud-control",
-  "version": "4.3.16-beta.0",
+  "version": "4.3.16-beta.10",
   "description": "Homebridge plugin to control Mitsubishi Air Conditioner, Heat Pump and Energy Recovery Ventilation.",
   "license": "MIT",
   "author": "grzegorz914",
@@ -36,10 +36,10 @@
   },
   "dependencies": {
     "@homebridge/plugin-ui-utils": "^2.1.2",
-    "async-mqtt": "^2.6.3",
+    "mqtt": "^5.14.1",
     "axios": "^1.13.2",
     "express": "^5.2.1",
-    "puppeteer": "^24.32.0",
+    "puppeteer": "^24.32.1",
     "ws": "^8.18.3"
   },
   "keywords": [

package/src/deviceata.js

@@ -113,34 +113,31 @@ class DeviceAta extends EventEmitter {
         const restFulEnabled = this.restFul.enable || false;
         if (restFulEnabled) {
             try {
-
-                if (!this.restFulConnected) {
-                    this.restFul1 = new RestFul({
-                        port: this.restFul.port,
-                        logWarn: this.logWarn,
-                        logDebug: this.logDebug
+                this.restFul1 = new RestFul({
+                    port: this.restFul.port,
+                    logWarn: this.logWarn,
+                    logDebug: this.logDebug
+                })
+                    .on('connected', (message) => {
+                        this.restFulConnected = true;
+                        this.emit('success', message);
                     })
-                        .on('connected', (message) => {
-                            this.restFulConnected = true;
-                            this.emit('success', message);
-                        })
-                        .on('set', async (key, value) => {
-                            try {
-                                await this.setOverExternalIntegration('RESTFul', this.deviceData, key, value);
-                            } catch (error) {
-                                this.emit('warn', error);
-                            };
-                        })
-                        .on('debug', (debug) => {
-                            this.emit('debug', debug);
-                        })
-                        .on('warn', (warn) => {
-                            this.emit('warn', warn);
-                        })
-                        .on('error', (error) => {
-                            this.emit('error', error);
-                        });
-                }
+                    .on('set', async (key, value) => {
+                        try {
+                            await this.setOverExternalIntegration('RESTFul', this.deviceData, key, value);
+                        } catch (error) {
+                            this.emit('warn', error);
+                        };
+                    })
+                    .on('debug', (debug) => {
+                        this.emit('debug', debug);
+                    })
+                    .on('warn', (warn) => {
+                        this.emit('warn', warn);
+                    })
+                    .on('error', (error) => {
+                        this.emit('error', error);
+                    });
             } catch (error) {
                 if (this.logWarn) this.emit('warn', `RESTFul integration start error: ${error}`);
             };
@@ -150,41 +147,39 @@ class DeviceAta extends EventEmitter {
         const mqttEnabled = this.mqtt.enable || false;
         if (mqttEnabled) {
             try {
-                if (!this.mqttConnected) {
-                    this.mqtt1 = new Mqtt({
-                        host: this.mqtt.host,
-                        port: this.mqtt.port || 1883,
-                        clientId: this.mqtt.clientId ? `melcloud_${this.mqtt.clientId}_${Math.random().toString(16).slice(3)}` : `melcloud_${Math.random().toString(16).slice(3)}`,
-                        prefix: this.mqtt.prefix ? `melcloud/${this.mqtt.prefix}/${this.deviceTypeString}/${this.deviceName}` : `melcloud/${this.deviceTypeString}/${this.deviceName}`,
-                        user: this.mqtt.auth?.user,
-                        passwd: this.mqtt.auth?.passwd,
-                        logWarn: this.logWarn,
-                        logDebug: this.logDebug
+                this.mqtt1 = new Mqtt({
+                    host: this.mqtt.host,
+                    port: this.mqtt.port || 1883,
+                    clientId: this.mqtt.clientId ? `melcloud_${this.mqtt.clientId}_${Math.random().toString(16).slice(3)}` : `melcloud_${Math.random().toString(16).slice(3)}`,
+                    prefix: this.mqtt.prefix ? `melcloud/${this.mqtt.prefix}/${this.deviceTypeString}/${this.deviceName}` : `melcloud/${this.deviceTypeString}/${this.deviceName}`,
+                    user: this.mqtt.auth?.user,
+                    passwd: this.mqtt.auth?.passwd,
+                    logWarn: this.logWarn,
+                    logDebug: this.logDebug
+                })
+                    .on('connected', (message) => {
+                        this.mqttConnected = true;
+                        this.emit('success', message);
                     })
-                        .on('connected', (message) => {
-                            this.mqttConnected = true;
-                            this.emit('success', message);
-                        })
-                        .on('subscribed', (message) => {
-                            this.emit('success', message);
-                        })
-                        .on('set', async (key, value) => {
-                            try {
-                                await this.setOverExternalIntegration('MQTT', this.deviceData, key, value);
-                            } catch (error) {
-                                this.emit('warn', error);
-                            };
-                        })
-                        .on('debug', (debug) => {
-                            this.emit('debug', debug);
-                        })
-                        .on('warn', (warn) => {
-                            this.emit('warn', warn);
-                        })
-                        .on('error', (error) => {
-                            this.emit('error', error);
-                        });
-                }
+                    .on('subscribed', (message) => {
+                        this.emit('success', message);
+                    })
+                    .on('set', async (key, value) => {
+                        try {
+                            await this.setOverExternalIntegration('MQTT', this.deviceData, key, value);
+                        } catch (error) {
+                            this.emit('warn', error);
+                        };
+                    })
+                    .on('debug', (debug) => {
+                        this.emit('debug', debug);
+                    })
+                    .on('warn', (warn) => {
+                        this.emit('warn', warn);
+                    })
+                    .on('error', (error) => {
+                        this.emit('error', error);
+                    });
             } catch (error) {
                 if (this.logWarn) this.emit('warn', `MQTT integration start error: ${error}`);
             };
@@ -702,27 +697,95 @@ class DeviceAta 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}`);
@@ -730,7 +793,7 @@ class DeviceAta 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);
@@ -742,34 +805,102 @@ class DeviceAta 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);
             }
 
             //overheat protection
-            if (this.overheatProtectionSupport && this.accessory.overheatProtectionEnabled !== null) {
+            if (this.overheatProtectionSupport && this.accessory.overheatProtection.Enabled !== null) {
                 //control
                 if (this.logDebug) this.emit('debug', `Prepare overheat protection control service`);
-                this.overheatProtectionControlService = new Service.Switch(`${serviceName} Overheat Protection`, `overheatProtectionControlService${deviceId}`);
-                this.overheatProtectionControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
-                this.overheatProtectionControlService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Overheat Protection`);
-                this.overheatProtectionControlService.getCharacteristic(Characteristic.On)
+                const overheatProtectionControlService = new Service.HeaterCooler(`${serviceName} Overheat Protection`, `overheatProtectionControlService${deviceId}`);
+                overheatProtectionControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                overheatProtectionControlService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Overheat Protection`);
+                overheatProtectionControlService.getCharacteristic(Characteristic.Active)
                     .onGet(async () => {
-                        const state = this.accessory.overheatProtectionEnabled;
+                        const state = this.accessory.overheatProtection.Enabled;
                         return state;
                     })
                     .onSet(async (state) => {
                         try {
-                            deviceData.OverheatProtection.Enabled = state;
+                            deviceData.OverheatProtection.Enabled = state ? true : false;
                             if (this.logInfo) this.emit('info', `Overheat protection: ${state ? 'Enabled' : 'Disabled'}`);
                             await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'overheatprotection');
                         } catch (error) {
                             if (this.logWarn) this.emit('warn', `Set overheat protection error: ${error}`);
                         };
                     });
-                accessory.addService(this.overheatProtectionControlService);
+                overheatProtectionControlService.getCharacteristic(Characteristic.CurrentHeaterCoolerState)
+                    .onGet(async () => {
+                        const value = this.accessory.overheatProtection.Active ? 2 : 1;
+                        return value;
+                    })
+                overheatProtectionControlService.getCharacteristic(Characteristic.TargetHeaterCoolerState)
+                    .setProps({
+                        minValue: 0,
+                        maxValue: 0,
+                        validValues: [0]
+                    })
+                    .onGet(async () => {
+                        const value = 0
+                        return value;
+                    })
+                    .onSet(async (value) => {
+                        try {
+                            deviceData.OverheatProtection.Enabled = true;
+                            if (this.logInfo) this.emit('info', `Set overheat protection: Enabled`);
+                            await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'overheatprotection');
+                        } catch (error) {
+                            if (this.logWarn) this.emit('warn', `Set overheat protection error: ${error}`);
+                        };
+                    });
+                overheatProtectionControlService.getCharacteristic(Characteristic.CurrentTemperature)
+                    .onGet(async () => {
+                        const value = this.accessory.roomTemperature;
+                        return value;
+                    });
+                overheatProtectionControlService.getCharacteristic(Characteristic.CoolingThresholdTemperature) //max
+                    .setProps({
+                        minValue: 33,
+                        maxValue: 40,
+                        minStep: 1
+                    })
+                    .onGet(async () => {
+                        const value = this.accessory.overheatProtection.Max;
+                        return value;
+                    })
+                    .onSet(async (value) => {
+                        try {
+                            deviceData.OverheatProtection.Max = value;
+                            if (this.logInfo) this.emit('info', `Set overheat protection max. temperature: ${value}${this.accessory.temperatureUnit}`);
+                            await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'overheatprotection');
+                        } catch (error) {
+                            if (this.logWarn) this.emit('warn', `Set overheat protection max. temperature error: ${error}`);
+                        };
+                    });
+                overheatProtectionControlService.getCharacteristic(Characteristic.HeatingThresholdTemperature) //min
+                    .setProps({
+                        minValue: 31,
+                        maxValue: 38,
+                        minStep: 1
+                    })
+                    .onGet(async () => {
+                        const value = this.accessory.overheatProtection.Min;
+                        return value;
+                    })
+                    .onSet(async (value) => {
+                        try {
+                            deviceData.OverheatProtection.Min = value;
+                            if (this.logInfo) this.emit('info', `Set overheat protection min. temperature: ${value}${this.accessory.temperatureUnit}`);
+                            await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'overheatprotection');
+                        } catch (error) {
+                            if (this.logWarn) this.emit('warn', `Set overheat protection min. temperature error: ${error}`);
+                        };
+                    });
+                this.overheatProtectionControlService = overheatProtectionControlService;
+                accessory.addService(overheatProtectionControlService);
 
                 if (this.logDebug) this.emit('debug', `Prepare overheat protection control sensor service`);
                 this.overheatProtectionControlSensorService = new Service.ContactSensor(`${serviceName} Overheat Protection Control`, `overheatProtectionControlSensorService${deviceId}`);
@@ -777,7 +908,7 @@ class DeviceAta extends EventEmitter {
                 this.overheatProtectionControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Overheat Protection Control`);
                 this.overheatProtectionControlSensorService.getCharacteristic(Characteristic.ContactSensorState)
                     .onGet(async () => {
-                        const state = this.accessory.overheatProtectionEnabled;
+                        const state = this.accessory.overheatProtection.Enabled;
                         return state;
                     })
                 accessory.addService(this.overheatProtectionControlSensorService);
@@ -788,7 +919,7 @@ class DeviceAta extends EventEmitter {
                 this.overheatProtectionSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Overheat Protection`);
                 this.overheatProtectionSensorService.getCharacteristic(Characteristic.ContactSensorState)
                     .onGet(async () => {
-                        const state = this.accessory.overheatProtectionActive;
+                        const state = this.accessory.overheatProtection.Active;
                         return state;
                     })
                 accessory.addService(this.overheatProtectionSensorService);
@@ -1374,10 +1505,8 @@ class DeviceAta extends EventEmitter {
                     const holidayModeActive = deviceData.HolidayMode?.Active ?? false;
 
                     //protection
-                    const frostProtectionEnabled = deviceData.FrostProtection?.Enabled;
-                    const frostProtectionActive = deviceData.FrostProtection?.Active ?? false;
-                    const overheatProtectionEnabled = deviceData.OverheatProtection?.Enabled;
-                    const overheatProtectionActive = deviceData.OverheatProtection?.Active ?? false;
+                    const frostProtection = deviceData.FrostProtection ?? {};
+                    const overheatProtection = deviceData.OverheatProtection ?? {};
 
                     //device control
                     const hideVaneControls = deviceData.HideVaneControls ?? false;
@@ -1470,10 +1599,8 @@ class DeviceAta extends EventEmitter {
                         temperatureUnit: TemperatureDisplayUnits[this.accountInfo.useFahrenheit ? 1 : 0],
                         isConnected: isConnected,
                         isInError: isInError,
-                        frostProtectionEnabled: frostProtectionEnabled,
-                        frostProtectionActive: frostProtectionActive,
-                        overheatProtectionEnabled: overheatProtectionEnabled,
-                        overheatProtectionActive: overheatProtectionActive,
+                        frostProtection: frostProtection,
+                        overheatProtection: overheatProtection,
                         holidayModeEnabled: holidayModeEnabled,
                         holidayModeActive: holidayModeActive,
                         scheduleEnabled: scheduleEnabled
@@ -1572,42 +1699,34 @@ class DeviceAta extends EventEmitter {
                                     obj.currentOperationMode = roomTemperature > setTemperature ? 0 : 1;
                                     obj.targetOperationMode = 1;
                                     break;
-
                                 case 2: // DRY
                                     obj.currentOperationMode = 0;
                                     obj.targetOperationMode = resolveTargetOperation1(2, obj);
                                     break;
-
                                 case 3: // COOL
                                     obj.currentOperationMode = roomTemperature < setTemperature ? 0 : 2;
                                     obj.targetOperationMode = 2;
                                     break;
-
                                 case 7: // FAN
                                     obj.currentOperationMode = 0;
                                     obj.targetOperationMode = resolveTargetOperation1(3, obj);
                                     break;
-
                                 case 8: // AUTO
                                     obj.currentOperationMode = roomTemperature < setTemperature ? 1 : roomTemperature > setTemperature ? 2 : 0;
                                     obj.targetOperationMode = 3;
                                     break;
-
                                 case 9: // ISEE HEAT
                                     obj.currentOperationMode = roomTemperature > setTemperature ? 0 : 1;
                                     obj.targetOperationMode = 1;
                                     break;
-
                                 case 10: // ISEE DRY
                                     obj.currentOperationMode = 0;
                                     obj.targetOperationMode = resolveTargetOperation1(2, obj);
                                     break;
-
                                 case 11: // ISEE COOL
                                     obj.currentOperationMode = roomTemperature < setTemperature ? 0 : 2;
                                     obj.targetOperationMode = 2;
                                     break;
-
                                 default:
                                     if (this.logWarn) this.emit('warn', `Unknown operating mode: ${operationMode}`);
                                     break;
@@ -1645,17 +1764,27 @@ class DeviceAta 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);
                     }
 
                     //overheat protection
-                    if (this.overheatProtectionSupport && overheatProtectionEnabled !== null) {
-                        this.overheatProtectionControlService?.updateCharacteristic(Characteristic.On, overheatProtectionEnabled);
-                        this.overheatProtectionControlSensorService?.updateCharacteristic(Characteristic.ContactSensorState, overheatProtectionEnabled);
-                        this.overheatProtectionSensorService?.updateCharacteristic(Characteristic.ContactSensorState, overheatProtectionActive);
+                    if (this.overheatProtectionSupport && overheatProtection.Enabled !== null) {
+                        this.overheatProtectionControlService?.updateCharacteristic(Characteristic.Active, overheatProtection.Enabled);
+                        this.overheatProtectionControlService?.updateCharacteristic(Characteristic.CurrentHeaterCoolerState, overheatProtection.Active ? 2 : 1);
+                        this.overheatProtectionControlService?.updateCharacteristic(Characteristic.TargetHeaterCoolerState, overheatProtection.Active ? 2 : 1);
+                        this.overheatProtectionControlService?.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature);
+                        this.overheatProtectionControlService?.updateCharacteristic(Characteristic.CoolingThresholdTemperature, overheatProtection.Max);
+                        this.overheatProtectionControlService?.updateCharacteristic(Characteristic.HeatingThresholdTemperature, overheatProtection.Min);
+                        this.overheatProtectionControlSensorService?.updateCharacteristic(Characteristic.ContactSensorState, overheatProtection.Enabled);
+                        this.overheatProtectionSensorService?.updateCharacteristic(Characteristic.ContactSensorState, overheatProtection.Active);
                     }
 
                     //holiday mode