homebridge-melcloud-control 4.1.3-beta.2 → 4.1.3-beta.21

package/src/deviceata.js

@@ -29,11 +29,10 @@ class DeviceAta extends EventEmitter {
         this.displayType = device.displayType;
         this.temperatureSensor = device.temperatureSensor || false;
         this.temperatureOutdoorSensor = device.temperatureOutdoorSensor || false;
-        this.frostProtectionSensor = device.frostProtectionSensor || false;
-        this.overheatProtectionSensor = device.overheatProtectionSensor || false;
-        this.holidayModeSensor = device.holidayModeSensor || false;
-        this.scheduleSensor = device.scheduleSensor || false;
         this.errorSensor = device.errorSensor || false;
+        this.frostProtectionSupport = device.frostProtectionSupport || false;
+        this.overheatProtectionSupport = device.overheatProtectionSupport || false;
+        this.holidayModeSupport = device.holidayModeSupport || false;
         this.heatDryFanMode = device.heatDryFanMode || 1; //NONE, HEAT, DRY, FAN
         this.coolDryFanMode = device.coolDryFanMode || 1; //NONE, COOL, DRY, FAN
         this.autoDryFanMode = device.autoDryFanMode || 1; //NONE, AUTO, DRY, FAN
@@ -65,8 +64,8 @@ class DeviceAta extends EventEmitter {
         //schedules configured
         for (const schedule of this.schedules) {
             schedule.name = schedule.name || 'Schedule'
-            schedule.serviceType = [null, Service.Outlet, Service.Switch, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor][schedule.displayType];
-            schedule.characteristicType = [null, Characteristic.On, Characteristic.On, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState][schedule.displayType];
+            schedule.serviceType = [null, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor][schedule.displayType];
+            schedule.characteristicType = [null, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState][schedule.displayType];
             schedule.state = false;
         }
 
@@ -619,12 +618,59 @@ class DeviceAta extends EventEmitter {
                 accessory.addService(this.outdoorTemperatureSensorService);
             };
 
-            //frost protection sensor
-            if (this.frostProtectionSensor && this.accessory.frostProtectionEnabled) {
+            //error sensor
+            if (this.errorSensor && this.accessory.isInError !== null) {
+                if (this.logDebug) this.emit('debug', `Prepare error service`);
+                this.errorService = new Service.ContactSensor(`${serviceName} Error`, `Error Sensor ${deviceId}`);
+                this.errorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                this.errorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Error`);
+                this.errorService.getCharacteristic(Characteristic.ContactSensorState)
+                    .onGet(async () => {
+                        const state = this.accessory.isInError;
+                        return state;
+                    })
+                accessory.addService(this.errorService);
+            }
+
+            //frost protection
+            if (this.frostProtectionSupport && this.accessory.frostProtectionEnabled !== 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)
+                    .onGet(async () => {
+                        const state = this.accessory.frostProtectionEnabled;
+                        return state;
+                    })
+                    .onSet(async (state) => {
+                        try {
+                            deviceData.FrostProtection.Enabled = state;
+                            await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'frostprotection');
+                            if (this.logInfo) this.emit('info', `Frost protection: ${state ? 'Enabled' : 'Disabled'}`);
+                        } catch (error) {
+                            if (this.logWarn) this.emit('warn', `Set frost protection error: ${error}`);
+                        };
+                    });
+                accessory.addService(this.frostProtectionControlService);
+
+                if (this.logDebug) this.emit('debug', `Prepare frost protection control sensor service`);
+                this.frostProtectionControlSensorService = new Service.ContactSensor(`${serviceName} Frost Protection Control`, `frostProtectionControlSensorService${deviceId}`);
+                this.frostProtectionControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                this.frostProtectionControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Frost Protection Control`);
+                this.frostProtectionControlSensorService.getCharacteristic(Characteristic.ContactSensorState)
+                    .onGet(async () => {
+                        const state = this.accessory.frostProtectionEnabled;
+                        return state;
+                    })
+                accessory.addService(this.frostProtectionControlSensorService);
+
+                //sensor
                 if (this.logDebug) this.emit('debug', `Prepare frost protection service`);
-                this.frostProtectionSensorService = new Service.ContactSensor(`${serviceName} Frost Protection`, `Frost Protection Sensor ${deviceId}`);
+                this.frostProtectionSensorService = new Service.ContactSensor(`${serviceName} Frost Protection`, `frostProtectionSensorService${deviceId}`);
                 this.frostProtectionSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
-                this.frostProtectionSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Frost Protection`);
+                this.frostProtectionSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Frost Protection State`);
                 this.frostProtectionSensorService.getCharacteristic(Characteristic.ContactSensorState)
                     .onGet(async () => {
                         const state = this.accessory.frostProtectionActive;
@@ -633,12 +679,44 @@ class DeviceAta extends EventEmitter {
                 accessory.addService(this.frostProtectionSensorService);
             }
 
-            //overheat sensor
-            if (this.overheatProtectionSensor && this.accessory.overheatProtectionEnabled !== null) {
-                if (this.logDebug) this.emit('debug', `Prepare overheat protection service`);
-                this.overheatProtectionSensorService = new Service.ContactSensor(`${serviceName} Overheat Protection`, `Overheat Protection Sensor ${deviceId}`);
+            //overheat protection
+            if (this.overheatProtectionSupport && this.accessory.overheatProtectionEnabled !== 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)
+                    .onGet(async () => {
+                        const state = this.accessory.overheatProtectionEnabled;
+                        return state;
+                    })
+                    .onSet(async (state) => {
+                        try {
+                            deviceData.OverheatProtection.Enabled = state;
+                            await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'overheatprotection');
+                            if (this.logInfo) this.emit('info', `Overheat protection: ${state ? 'Enabled' : 'Disabled'}`);
+                        } catch (error) {
+                            if (this.logWarn) this.emit('warn', `Set overheat protection error: ${error}`);
+                        };
+                    });
+                accessory.addService(this.overheatProtectionControlService);
+
+                if (this.logDebug) this.emit('debug', `Prepare overheat protection control sensor service`);
+                this.overheatProtectionControlSensorService = new Service.ContactSensor(`${serviceName} Overheat Protection Control`, `overheatProtectionControlSensorService${deviceId}`);
+                this.overheatProtectionControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                this.overheatProtectionControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Overheat Protection Control`);
+                this.overheatProtectionControlSensorService.getCharacteristic(Characteristic.ContactSensorState)
+                    .onGet(async () => {
+                        const state = this.accessory.overheatProtectionEnabled;
+                        return state;
+                    })
+                accessory.addService(this.overheatProtectionControlSensorService);
+
+                if (this.logDebug) this.emit('debug', `Prepare overheat protection sensor service`);
+                this.overheatProtectionSensorService = new Service.ContactSensor(`${serviceName} Overheat Protection`, `overheatProtectionSensorService${deviceId}`);
                 this.overheatProtectionSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
-                this.overheatProtectionSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Overheat Protection`);
+                this.overheatProtectionSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Overheat Protection State`);
                 this.overheatProtectionSensorService.getCharacteristic(Characteristic.ContactSensorState)
                     .onGet(async () => {
                         const state = this.accessory.overheatProtectionActive;
@@ -647,46 +725,51 @@ class DeviceAta extends EventEmitter {
                 accessory.addService(this.overheatProtectionSensorService);
             }
 
-            //holiday mode sensor
-            if (this.holidayModeSensor && this.accessory.holidayModeEnabled !== null) {
-                if (this.logDebug) this.emit('debug', `Prepare holiday mode service`);
-                this.holidayModeSensorService = new Service.ContactSensor(`${serviceName} Holiday Mode`, `Holiday Mode Sensor ${deviceId}`);
-                this.holidayModeSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
-                this.holidayModeSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Holiday Mode`);
-                this.holidayModeSensorService.getCharacteristic(Characteristic.ContactSensorState)
+            //holiday mode
+            if (this.holidayModeSupport && this.accessory.holidayModeEnabled !== null) {
+                //control
+                if (this.logDebug) this.emit('debug', `Prepare holiday mode control service`);
+                this.holidayModeControlService = new Service.Switch(`${serviceName} Holiday Mode`, `holidayModeControlService${deviceId}`);
+                this.holidayModeControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                this.holidayModeControlService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Holiday Mode`);
+                this.holidayModeControlService.getCharacteristic(Characteristic.On)
                     .onGet(async () => {
-                        const state = this.accessory.holidayModeActive;
+                        const state = this.accessory.holidayModeEnabled;
                         return state;
                     })
-                accessory.addService(this.holidayModeSensorService);
-            }
-
-            //schedule sensor
-            if (this.scheduleSensor && this.accessory.scheduleEnabled !== null) {
-                if (this.logDebug) this.emit('debug', `Prepare schedule service`);
-                this.scheduleSensorService = new Service.ContactSensor(`${serviceName} Schedule`, `Schedule Sensor ${deviceId}`);
-                this.scheduleSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
-                this.scheduleSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Schedule`);
-                this.scheduleSensorService.getCharacteristic(Characteristic.ContactSensorState)
+                    .onSet(async (state) => {
+                        try {
+                            deviceData.HolidayMode.Enabled = state;
+                            await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'holidaymode');
+                            if (this.logInfo) this.emit('info', `Holiday mode: ${state ? 'Enabled' : 'Disabled'}`);
+                        } catch (error) {
+                            if (this.logWarn) this.emit('warn', `Set holiday mode error: ${error}`);
+                        };
+                    });
+                accessory.addService(this.holidayModeControlService);
+
+                if (this.logDebug) this.emit('debug', `Prepare holiday mode control sensor service`);
+                this.holidayModeControlSensorService = new Service.ContactSensor(`${serviceName} Holiday Mode Control`, `holidayModeControlSensorService${deviceId}`);
+                this.holidayModeControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                this.holidayModeControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Holiday Mode Control`);
+                this.holidayModeControlSensorService.getCharacteristic(Characteristic.ContactSensorState)
                     .onGet(async () => {
-                        const state = this.accessory.scheduleEnabled;
+                        const state = this.accessory.holidayModeEnabled;
                         return state;
                     })
-                accessory.addService(this.scheduleSensorService);
-            }
+                accessory.addService(this.holidayModeControlSensorService);
 
-            //error sensor
-            if (this.errorSensor && this.accessory.isInError !== null) {
-                if (this.logDebug) this.emit('debug', `Prepare error service`);
-                this.errorService = new Service.ContactSensor(`${serviceName} Error`, `Error Sensor ${deviceId}`);
-                this.errorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
-                this.errorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Error`);
-                this.errorService.getCharacteristic(Characteristic.ContactSensorState)
+                //sensors
+                if (this.logDebug) this.emit('debug', `Prepare holiday mode sensor service`);
+                this.holidayModeSensorService = new Service.ContactSensor(`${serviceName} Holiday Mode`, `holidayModeSensorService${deviceId}`);
+                this.holidayModeSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                this.holidayModeSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Holiday Mode State`);
+                this.holidayModeSensorService.getCharacteristic(Characteristic.ContactSensorState)
                     .onGet(async () => {
-                        const state = this.accessory.isInError;
+                        const state = this.accessory.holidayModeActive;
                         return state;
                     })
-                accessory.addService(this.errorService);
+                accessory.addService(this.holidayModeSensorService);
             }
 
             //presets services
@@ -747,7 +830,7 @@ class DeviceAta extends EventEmitter {
             };
 
             //schedules services
-            if (this.schedules.length > 0) {
+            if (this.schedules.length > 0 && this.accessory.scheduleEnabled !== null) {
                 if (this.logDebug) this.emit('debug', `Prepare schedules services`);
                 this.schedulesServices = [];
                 this.schedules.forEach((schedule, i) => {
@@ -757,25 +840,52 @@ class DeviceAta extends EventEmitter {
                     //get preset name prefix
                     const namePrefix = schedule.namePrefix;
 
+                    //control
+                    if (i === 0) {
+                        if (this.logDebug) this.emit('debug', `Prepare schedule control service`);
+                        const serviceNameSchedule = namePrefix ? `${accessoryName} Schedule Control` : `Schedule Control`;
+                        this.schedulesControlService = new Service.Switch(serviceNameSchedule, `schedulesControlService${deviceId} ${i}`);
+                        this.schedulesControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        this.schedulesControlService.setCharacteristic(Characteristic.ConfiguredName, serviceNameSchedule);
+                        this.schedulesControlService.getCharacteristic(Characteristic.On)
+                            .onGet(async () => {
+                                const state = this.accessory.scheduleEnabled;
+                                return state;
+                            })
+                            .onSet(async (state) => {
+                                try {
+                                    deviceData.ScheduleEnabled = state;
+                                    await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'schedule');
+                                    if (this.logInfo) this.emit('info', `Schedule: ${state ? 'Enabled' : 'Disabled'}`);
+                                } catch (error) {
+                                    if (this.logWarn) this.emit('warn', `Set schedule error: ${error}`);
+                                };
+                            });
+                        accessory.addService(this.schedulesControlService);
+
+                        if (this.logDebug) this.emit('debug', `Prepare schedule control sensor service`);
+                        this.schedulesControlSensorService = new Service.ContactSensor(serviceNameSchedule, `schedulesControlSensorService${deviceId}`);
+                        this.schedulesControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        this.schedulesControlSensorService.setCharacteristic(Characteristic.ConfiguredName, serviceNameSchedule);
+                        this.schedulesControlSensorService.getCharacteristic(Characteristic.ContactSensorState)
+                            .onGet(async () => {
+                                const state = this.accessory.scheduleEnabled;
+                                return state;
+                            })
+                        accessory.addService(this.schedulesControlSensorService);
+                    }
+
+                    //sensors
                     const serviceName = namePrefix ? `${accessoryName} ${name}` : name;
                     const serviceType = schedule.serviceType;
                     const characteristicType = schedule.characteristicType;
-                    const scheduleService = new serviceType(serviceName, `Schedule ${deviceId} ${i}`);
+                    const scheduleService = new serviceType(serviceName, `scheduleService${deviceId} ${i}`);
                     scheduleService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                     scheduleService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                     scheduleService.getCharacteristic(characteristicType)
                         .onGet(async () => {
                             const state = schedule.state;
                             return state;
-                        })
-                        .onSet(async (state) => {
-                            try {
-                                deviceData.ScheduleEnabled = state;
-                                await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'scheduleenabled');
-                                if (this.logInfo) this.emit('info', `${state ? 'Set:' : 'Unset:'} ${name}`);
-                            } catch (error) {
-                                if (this.logWarn) this.emit('warn', `Set schedule error: ${error}`);
-                            };
                         });
                     this.schedulesServices.push(scheduleService);
                     accessory.addService(scheduleService);
@@ -1060,8 +1170,6 @@ class DeviceAta extends EventEmitter {
                     this.deviceData = deviceData;
 
                     //keys
-                    const presetsIdKey = this.accountType === 'melcloud' ? 'ID' : 'Id';
-                    const setTempKey = this.accountType === 'melcloud' ? 'SetTemperature' : 'SetPoint';
                     const fanKey = this.accountType === 'melcloud' ? 'FanSpeed' : 'SetFanSpeed';
                     const tempStepKey = this.accountType === 'melcloud' ? 'TemperatureIncrement' : 'HasHalfDegreeIncrements';
                     const errorKey = this.accountType === 'melcloud' ? 'HasError' : 'IsInError';
@@ -1073,19 +1181,18 @@ class DeviceAta extends EventEmitter {
                     const supportDryKey = this.accountType === 'melcloud' ? 'ModelSupportsDry' : 'HasDryOperationMode';
                     const supportCoolKey = this.accountType === 'melcloud' ? 'ModelSupportsCool' : 'HasCoolOperationMode';
 
-                    //presets schedule
+                    //presets schedules
                     const scheduleEnabled = deviceData.ScheduleEnabled;
                     const schedulesOnServer = deviceData.Schedule ?? [];
                     const presetsOnServer = deviceData.Presets ?? [];
                     const holidayModeEnabled = deviceData.HolidayMode?.Enabled;
-                    const holidayModeActive = deviceData.HolidayMode?.Active;
-
+                    const holidayModeActive = deviceData.HolidayMode?.Active ?? false;
 
                     //protection
                     const frostProtectionEnabled = deviceData.FrostProtection?.Enabled;
-                    const frostProtectionActive = deviceData.FrostProtection?.Active;
+                    const frostProtectionActive = deviceData.FrostProtection?.Active ?? false;
                     const overheatProtectionEnabled = deviceData.OverheatProtection?.Enabled;
-                    const overheatProtectionActive = deviceData.OverheatProtection?.Active;
+                    const overheatProtectionActive = deviceData.OverheatProtection?.Active ?? false;
 
                     //device control
                     const hideVaneControls = deviceData.HideVaneControls ?? false;
@@ -1319,18 +1426,36 @@ class DeviceAta extends EventEmitter {
                     };
                     this.accessory = obj;
 
+                    //senors
                     this.roomTemperatureSensorService?.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature);
                     this.outdoorTemperatureSensorService?.updateCharacteristic(Characteristic.CurrentTemperature, outdoorTemperature);
-                    this.frostProtectionSensorService?.updateCharacteristic(Characteristic.ContactSensorState, frostProtectionActive);
-                    this.overheatProtectionSensorService?.updateCharacteristic(Characteristic.ContactSensorState, overheatProtectionActive);
-                    this.holidayModeSensorService?.updateCharacteristic(Characteristic.ContactSensorState, holidayModeActive);
-                    this.scheduleSensorService?.updateCharacteristic(Characteristic.ContactSensorState, scheduleEnabled);
                     this.errorService?.updateCharacteristic(Characteristic.ContactSensorState, isInError);
 
-                    //update presets state
+                    //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);
+                    }
+
+                    //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);
+                    }
+
+                    //holiday mode
+                    if (this.holidayModeSupport && holidayModeEnabled !== null) {
+                        this.holidayModeControlService?.updateCharacteristic(Characteristic.On, holidayModeEnabled);
+                        this.holidayModeControlSensorService?.updateCharacteristic(Characteristic.ContactSensorState, holidayModeEnabled);
+                        this.holidayModeSensorService?.updateCharacteristic(Characteristic.ContactSensorState, holidayModeActive);
+                    }
+
+                    //presets
                     if (this.presets.length > 0) {
                         this.presets.forEach((preset, i) => {
-                            const presetData = presetsOnServer.find(p => p[presetsIdKey] === preset.id);
+                            const presetData = presetsOnServer.find(p => p.ID === preset.id);
 
                             preset.state = presetData ? (presetData.Power === power
                                 && presetData.SetTemperature === setTemperature
@@ -1344,18 +1469,25 @@ class DeviceAta extends EventEmitter {
                         });
                     };
 
-                    //update schedules state
-                    if (this.schedules.length > 0) {
+                    //schedules
+                    if (this.schedules.length > 0 && scheduleEnabled !== null) {
                         this.schedules.forEach((schedule, i) => {
-                            const scheduleData = schedulesOnServer.find(s => s[presetsIdKey] === schedule.id);
-                            schedule.state = scheduleEnabled; //scheduleData.Enabled : false;
+                            //control
+                            if (i === 0) {
+                                this.schedulesControlService?.updateCharacteristic(Characteristic.On, scheduleEnabled);
+                                this.schedulesControlSensorService?.updateCharacteristic(Characteristic.ContactSensorState, scheduleEnabled);
+                            }
+
+                            //sensors
+                            const scheduleData = schedulesOnServer.find(s => s.Id === schedule.id);
+                            schedule.state = scheduleEnabled ? scheduleData.Enabled ?? false : false;
 
                             const characteristicType = schedule.characteristicType;
                             this.schedulesServices?.[i]?.updateCharacteristic(characteristicType, schedule.state);
                         });
                     };
 
-                    //update buttons state
+                    //buttons
                     if (this.buttons.length > 0) {
                         this.buttons.forEach((button, i) => {
                             const mode = button.mode;