homebridge-melcloud-control 3.8.4-beta.5 → 3.8.4-beta.7

package/package.json

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

package/src/deviceata.js

@@ -1045,6 +1045,7 @@ class DeviceAta extends EventEmitter {
                         swingMode: swingFunction && vaneHorizontalDirection === 12 && vaneVerticalDirection === 7 ? 1 : 0,
                         lockPhysicalControl: prohibitSetTemperature && prohibitOperationMode && prohibitPower ? 1 : 0,
                         temperatureIncrement: temperatureIncrement,
+                        useFahrenheit: this.useFahrenheit,
                         temperatureUnit: TemperatureDisplayUnits[this.useFahrenheit]
                     };
 
@@ -1090,6 +1091,7 @@ class DeviceAta extends EventEmitter {
                             };
 
                             obj.currentOperationMode = !power ? 0 : inStandbyMode ? 1 : obj.currentOperationMode;
+                            obj.targetOperationMode = obj.targetOperationMode;
                             obj.operationModeSetPropsMinValue = modelSupportsAuto && modelSupportsHeat ? 0 : !modelSupportsAuto && modelSupportsHeat ? 1 : modelSupportsAuto && !modelSupportsHeat ? 0 : 2;
                             obj.operationModeSetPropsMaxValue = 2
                             obj.operationModeSetPropsValidValues = modelSupportsAuto && modelSupportsHeat ? [0, 1, 2] : !modelSupportsAuto && modelSupportsHeat ? [1, 2] : modelSupportsAuto && !modelSupportsHeat ? [0, 2] : [2];
@@ -1191,7 +1193,6 @@ class DeviceAta extends EventEmitter {
                             };
                             break;
                     };
-
                     this.accessory = obj;
 
                     if (this.roomTemperatureSensorService) {

package/src/deviceatw.js

@@ -91,11 +91,8 @@ class DeviceAtw extends EventEmitter {
         this.deviceData = {};
 
         //accessory
-        this.accessory = {
-            zones: [{}, {}, {}, {}],
-            zonesSensors: [{}, {}, {}, {}]
-        };
-        this.accessory.useFahrenheit = useFahrenheit ? 1 : 0;
+        this.accessory = {};
+        this.useFahrenheit = useFahrenheit ? 1 : 0;
     };
 
     async externalIntegrations() {
@@ -1417,28 +1414,33 @@ class DeviceAtw extends EventEmitter {
                     const returnTemperatureZone2 = deviceData.Device.ReturnTemperatureZone2;
 
                     //accessory
-                    this.accessory.presets = presetsOnServer;
-                    this.accessory.power = power ? 1 : 0;
-                    this.accessory.unitStatus = unitStatus;
-                    this.accessory.idleZone1 = idleZone1;
-                    this.accessory.idleZone2 = idleZone2;
-                    this.accessory.temperatureIncrement = temperatureIncrement;
-                    this.accessory.hasHeatPump = hasHeatPump;
-                    this.accessory.hasZone1 = hasZone1;
-                    this.accessory.hasHotWaterTank = hasHotWaterTank;
-                    this.accessory.hasZone2 = hasZone2;
-                    this.accessory.heatCoolModes = heatCoolModes;
-                    this.accessory.caseHeatPump = caseHeatPump;
-                    this.accessory.caseZone1 = caseZone1;
-                    this.accessory.caseHotWater = caseHotWater;
-                    this.accessory.caseZone2 = caseZone2;
-                    this.accessory.zonesCount = zonesCount;
-                    this.accessory.caseHeatPumpSensor = caseHeatPumpSensor;
-                    this.accessory.caseZone1Sensor = caseZone1Sensor;
-                    this.accessory.caseHotWaterSensor = caseHotWaterSensor;
-                    this.accessory.caseZone2Sensor = caseZone2Sensor;
-                    this.accessory.sensorsCount = zonesSensorsCount;
-                    this.accessory.temperatureUnit = TemperatureDisplayUnits[this.accessory.useFahrenheit];
+                    const obj = {
+                        presets: presetsOnServer,
+                        power: power ? 1 : 0,
+                        unitStatus: unitStatus,
+                        idleZone1: idleZone1,
+                        idleZone2: idleZone2,
+                        temperatureIncrement: temperatureIncrement,
+                        hasHeatPump: hasHeatPump,
+                        hasZone1: hasZone1,
+                        hasHotWaterTank: hasHotWaterTank,
+                        hasZone2: hasZone2,
+                        heatCoolModes: heatCoolModes,
+                        caseHeatPump: caseHeatPump,
+                        caseZone1: caseZone1,
+                        caseHotWater: caseHotWater,
+                        caseZone2: caseZone2,
+                        zonesCount: zonesCount,
+                        caseHeatPumpSensor: caseHeatPumpSensor,
+                        caseZone1Sensor: caseZone1Sensor,
+                        caseHotWaterSensor: caseHotWaterSensor,
+                        caseZone2Sensor: caseZone2Sensor,
+                        sensorsCount: zonesSensorsCount,
+                        useFahrenheit: this.useFahrenheit,
+                        temperatureUnit: TemperatureDisplayUnits[this.useFahrenheit],
+                        zones: [{}, {}, {}, {}],
+                        zonesSensors: [{}, {}, {}, {}]
+                    };
 
                     //default values
                     let name = 'Heat Pump'
@@ -1564,7 +1566,7 @@ class DeviceAtw extends EventEmitter {
                                         .updateCharacteristic(Characteristic.TargetHeaterCoolerState, targetOperationMode)
                                         .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
                                         .updateCharacteristic(Characteristic.LockPhysicalControls, lockPhysicalControl)
-                                        .updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
+                                        .updateCharacteristic(Characteristic.TemperatureDisplayUnits, obj.useFahrenheit);
                                     const updateDefCool = heatCoolModes === 0 || heatCoolModes === 2 ? this.melCloudServices[i].updateCharacteristic(Characteristic.CoolingThresholdTemperature, setTemperature) : false;
                                     const updateDefHeat = heatCoolModes === 0 || heatCoolModes === 1 ? this.melCloudServices[i].updateCharacteristic(Characteristic.HeatingThresholdTemperature, setTemperature) : false;
                                 }
@@ -1670,24 +1672,24 @@ class DeviceAtw extends EventEmitter {
                                         .updateCharacteristic(Characteristic.TargetHeatingCoolingState, targetOperationMode)
                                         .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
                                         .updateCharacteristic(Characteristic.TargetTemperature, setTemperature)
-                                        .updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
+                                        .updateCharacteristic(Characteristic.TemperatureDisplayUnits, obj.useFahrenheit);
                                 }
                                 break;
                         };
 
                         //add value to zones arrays
-                        this.accessory.zones[i].name = name;
-                        this.accessory.zones[i].operationMode = operationModeZone;
-                        this.accessory.zones[i].currentOperationMode = currentOperationMode;
-                        this.accessory.zones[i].targetOperationMode = targetOperationMode;
-                        this.accessory.zones[i].roomTemperature = roomTemperature;
-                        this.accessory.zones[i].setTemperature = setTemperature;
-                        this.accessory.zones[i].lockPhysicalControl = lockPhysicalControl;
-                        this.accessory.zones[i].temperaturesSetPropsMinValue = temperatureSetPropsMinValue;
-                        this.accessory.zones[i].temperaturesSetPropsMaxValue = temperatureSetPropsMaxValue;
-                        const setPropsMinValue = this.startPrepareAccessory ? this.accessory.zones[i].operationModesSetPropsMinValue = operationModeSetPropsMinValue : false;
-                        const setPropsMaxValue = this.startPrepareAccessory ? this.accessory.zones[i].operationModesSetPropsMaxValue = operationModeSetPropsMaxValue : false;
-                        const setPropsValidValues = this.startPrepareAccessory ? this.accessory.zones[i].operationModesSetPropsValidValues = operationModeSetPropsValidValues : false;
+                        obj.zones[i].name = name;
+                        obj.zones[i].operationMode = operationModeZone;
+                        obj.zones[i].currentOperationMode = currentOperationMode;
+                        obj.zones[i].targetOperationMode = targetOperationMode;
+                        obj.zones[i].roomTemperature = roomTemperature;
+                        obj.zones[i].setTemperature = setTemperature;
+                        obj.zones[i].lockPhysicalControl = lockPhysicalControl;
+                        obj.zones[i].temperaturesSetPropsMinValue = temperatureSetPropsMinValue;
+                        obj.zones[i].temperaturesSetPropsMaxValue = temperatureSetPropsMaxValue;
+                        const setPropsMinValue = this.startPrepareAccessory ? obj.zones[i].operationModesSetPropsMinValue = operationModeSetPropsMinValue : false;
+                        const setPropsMaxValue = this.startPrepareAccessory ? obj.zones[i].operationModesSetPropsMaxValue = operationModeSetPropsMaxValue : false;
+                        const setPropsValidValues = this.startPrepareAccessory ? obj.zones[i].operationModesSetPropsValidValues = operationModeSetPropsValidValues : false;
 
                         //log current state
                         if (!this.disableLogInfo) {
@@ -1696,32 +1698,32 @@ class DeviceAtw extends EventEmitter {
                                 case caseHeatPump: //Heat Pump - HEAT, COOL, OFF
                                     this.emit('info', `${heatPumpName}, Power: ${power ? 'ON' : 'OFF'}`)
                                     this.emit('info', `${heatPumpName}, Operation mode: ${HeatPump.System[unitStatus]}`);
-                                    this.emit('info', `${heatPumpName},'Outdoor temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
-                                    this.emit('info', `${heatPumpName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
+                                    this.emit('info', `${heatPumpName},'Outdoor temperature: ${roomTemperature}${obj.temperatureUnit}`);
+                                    this.emit('info', `${heatPumpName}, Temperature display unit: ${obj.temperatureUnit}`);
                                     this.emit('info', `${heatPumpName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
                                     break;
                                 case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
                                     operationModeText = idleZone1 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone1];
                                     this.emit('info', `${zone1Name}, Operation mode: ${operationModeText}`);
-                                    this.emit('info', `${zone1Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
-                                    this.emit('info', `${zone1Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
-                                    this.emit('info', `${zone1Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
+                                    this.emit('info', `${zone1Name}, Temperature: ${roomTemperature}${obj.temperatureUnit}`);
+                                    this.emit('info', `${zone1Name}, Target temperature: ${setTemperature}${obj.temperatureUnit}`)
+                                    this.emit('info', `${zone1Name}, Temperature display unit: ${obj.temperatureUnit}`);
                                     this.emit('info', `${zone1Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
                                     break;
                                 case caseHotWater: //Hot Water - AUTO, HEAT NOW
                                     operationModeText = operationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[forcedHotWaterMode ? 1 : 0];
                                     this.emit('info', `${hotWaterName}, Operation mode: ${operationModeText}`);
-                                    this.emit('info', `${hotWaterName}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
-                                    this.emit('info', `${hotWaterName}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
-                                    this.emit('info', `${hotWaterName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
+                                    this.emit('info', `${hotWaterName}, Temperature: ${roomTemperature}${obj.temperatureUnit}`);
+                                    this.emit('info', `${hotWaterName}, Target temperature: ${setTemperature}${obj.temperatureUnit}`)
+                                    this.emit('info', `${hotWaterName}, Temperature display unit: ${obj.temperatureUnit}`);
                                     this.emit('info', `${hotWaterName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
                                     break;
                                 case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
                                     operationModeText = idleZone2 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone2];
                                     this.emit('info', `${zone2Name}, Operation mode: ${operationModeText}`);
-                                    this.emit('info', `${zone2Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
-                                    this.emit('info', `${zone2Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
-                                    this.emit('info', `${zone2Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
+                                    this.emit('info', `${zone2Name}, Temperature: ${roomTemperature}${obj.temperatureUnit}`);
+                                    this.emit('info', `${zone2Name}, Target temperature: ${setTemperature}${obj.temperatureUnit}`)
+                                    this.emit('info', `${zone2Name}, Temperature display unit: ${obj.temperatureUnit}`);
                                     this.emit('info', `${zone2Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
                                     break;
                             };
@@ -1822,37 +1824,38 @@ class DeviceAtw extends EventEmitter {
                         };
 
                         //add value to sensors arrays
-                        this.accessory.zonesSensors[i].name = name;
-                        this.accessory.zonesSensors[i].roomTemperature = roomTemperature;
-                        this.accessory.zonesSensors[i].flowTemperature = flowTemperature;
-                        this.accessory.zonesSensors[i].returnTemperature = returnTemperature;
+                        obj.zonesSensors[i].name = name;
+                        obj.zonesSensors[i].roomTemperature = roomTemperature;
+                        obj.zonesSensors[i].flowTemperature = flowTemperature;
+                        obj.zonesSensors[i].returnTemperature = returnTemperature;
 
                         //log current state
                         if (!this.disableLogInfo) {
                             switch (i) {
                                 case caseHeatPumpSensor: //Heat Pump - HEAT, COOL, OFF
-                                    const info = outdoorTemperature !== null ? this.emit('info', `${heatPumpName}, Outdoor temperature: ${outdoorTemperature}${this.accessory.temperatureUnit}`) : false;
-                                    const info0 = flowTemperatureHeatPump !== null ? this.emit('info', `${heatPumpName}, Flow temperature: ${flowTemperatureHeatPump}${this.accessory.temperatureUnit}`) : false;
-                                    const info1 = returnTemperatureHeatPump !== null ? this.emit('info', `${heatPumpName}, Return temperature: ${returnTemperatureHeatPump}${this.accessory.temperatureUnit}`) : false;
+                                    const info = outdoorTemperature !== null ? this.emit('info', `${heatPumpName}, Outdoor temperature: ${outdoorTemperature}${obj.temperatureUnit}`) : false;
+                                    const info0 = flowTemperatureHeatPump !== null ? this.emit('info', `${heatPumpName}, Flow temperature: ${flowTemperatureHeatPump}${obj.temperatureUnit}`) : false;
+                                    const info1 = returnTemperatureHeatPump !== null ? this.emit('info', `${heatPumpName}, Return temperature: ${returnTemperatureHeatPump}${obj.temperatureUnit}`) : false;
                                     break;
                                 case caseZone1Sensor: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
-                                    const info2 = roomTemperatureZone1 !== null ? this.emit('info', `${zone1Name}, Room temperature: ${roomTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
-                                    const info3 = flowTemperatureZone1 !== null ? this.emit('info', `${zone1Name}, Flow temperature: ${flowTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
-                                    const info4 = returnTemperatureZone1 !== null ? this.emit('info', `${zone1Name}, Return temperature: ${returnTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
+                                    const info2 = roomTemperatureZone1 !== null ? this.emit('info', `${zone1Name}, Room temperature: ${roomTemperatureZone1}${obj.temperatureUnit}`) : false;
+                                    const info3 = flowTemperatureZone1 !== null ? this.emit('info', `${zone1Name}, Flow temperature: ${flowTemperatureZone1}${obj.temperatureUnit}`) : false;
+                                    const info4 = returnTemperatureZone1 !== null ? this.emit('info', `${zone1Name}, Return temperature: ${returnTemperatureZone1}${obj.temperatureUnit}`) : false;
                                     break;
                                 case caseHotWaterSensor: //Hot Water - AUTO, HEAT NOW
-                                    const info5 = tankWaterTemperature !== null ? this.emit('info', `${hotWaterName}, Temperature: ${tankWaterTemperature}${this.accessory.temperatureUnit}`) : false;
-                                    const info6 = flowTemperatureWaterTank !== null ? this.emit('info', `${hotWaterName}, Flow temperature: ${flowTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
-                                    const info7 = returnTemperatureWaterTank !== null ? this.emit('info', `${hotWaterName}, Return temperature: ${returnTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
+                                    const info5 = tankWaterTemperature !== null ? this.emit('info', `${hotWaterName}, Temperature: ${tankWaterTemperature}${obj.temperatureUnit}`) : false;
+                                    const info6 = flowTemperatureWaterTank !== null ? this.emit('info', `${hotWaterName}, Flow temperature: ${flowTemperatureWaterTank}${obj.temperatureUnit}`) : false;
+                                    const info7 = returnTemperatureWaterTank !== null ? this.emit('info', `${hotWaterName}, Return temperature: ${returnTemperatureWaterTank}${obj.temperatureUnit}`) : false;
                                     break;
                                 case caseZone2Sensor: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
-                                    const info8 = roomTemperatureZone2 !== null ? this.emit('info', `${zone2Name}, Room temperature: ${roomTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
-                                    const info9 = flowTemperatureZone2 !== null ? this.emit('info', `${zone2Name}, Flow temperature: ${flowTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
-                                    const info10 = returnTemperatureZone2 !== null ? this.emit('info', `${zone2Name}, Return temperature: ${returnTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
+                                    const info8 = roomTemperatureZone2 !== null ? this.emit('info', `${zone2Name}, Room temperature: ${roomTemperatureZone2}${obj.temperatureUnit}`) : false;
+                                    const info9 = flowTemperatureZone2 !== null ? this.emit('info', `${zone2Name}, Flow temperature: ${flowTemperatureZone2}${obj.temperatureUnit}`) : false;
+                                    const info10 = returnTemperatureZone2 !== null ? this.emit('info', `${zone2Name}, Return temperature: ${returnTemperatureZone2}${obj.temperatureUnit}`) : false;
                                     break;
                             };
                         };
                     };
+                    this.accessory = obj;
 
                     //update presets state
                     if (this.presetsConfigured.length > 0) {

package/src/deviceerv.js

@@ -85,7 +85,7 @@ class DeviceErv extends EventEmitter {
 
         //accessory
         this.accessory = {};
-        this.accessory.useFahrenheit = useFahrenheit ? 1 : 0;
+        this.useFahrenheit = useFahrenheit ? 1 : 0;
     };
 
     async externalIntegrations() {
@@ -936,93 +936,99 @@ class DeviceErv extends EventEmitter {
                     const ventilationMode = deviceData.Device.VentilationMode;
 
                     //accessory
-                    this.accessory.presets = presetsOnServer;
-                    this.accessory.hasRoomTemperature = hasRoomTemperature;
-                    this.accessory.hasSupplyTemperature = hasSupplyTemperature;
-                    this.accessory.hasOutdoorTemperature = hasOutdoorTemperature;
-                    this.accessory.hasCoolOperationMode = hasCoolOperationMode;
-                    this.accessory.hasHeatOperationMode = hasHeatOperationMode;
-                    this.accessory.hasCO2Sensor = hasCO2Sensor;
-                    this.accessory.roomCO2Level = roomCO2Level;
-                    this.accessory.roomCO2Detected = roomCO2Detected;
-                    this.accessory.hasPM25Sensor = hasPM25Sensor;
-                    this.accessory.pM25SensorStatus = pM25SensorStatus;
-                    this.accessory.pM25Level = pM25Level;
-                    this.accessory.pM25AirQuality = pM25AirQuality;
-                    this.accessory.hasAutoVentilationMode = hasAutoVentilationMode;
-                    this.accessory.hasBypassVentilationMode = hasBypassVentilationMode;
-                    this.accessory.hasAutomaticFanSpeed = hasAutomaticFanSpeed;
-                    this.accessory.coreMaintenanceRequired = coreMaintenanceRequired;
-                    this.accessory.filterMaintenanceRequired = filterMaintenanceRequired;
-                    this.accessory.actualVentilationMode = actualVentilationMode;
-                    this.accessory.numberOfFanSpeeds = numberOfFanSpeeds;
-                    this.accessory.power = power ? 1 : 0;
-                    this.accessory.operationMode = operationMode;
-                    this.accessory.ventilationMode = ventilationMode;
-                    this.accessory.roomTemperature = roomTemperature;
-                    this.accessory.supplyTemperature = supplyTemperature;
-                    this.accessory.outdoorTemperature = outdoorTemperature;
-                    this.accessory.setTemperature = setTemperature;
-                    this.accessory.defaultHeatingSetTemperature = defaultHeatingSetTemperature;
-                    this.accessory.defaultCoolingSetTemperature = defaultCoolingSetTemperature;
-                    this.accessory.lockPhysicalControl = 0;
-                    this.accessory.temperatureIncrement = temperatureIncrement;
-                    this.accessory.minTempHeat = minTempHeat;
-                    this.accessory.temperatureIncrement = maxTempHeat;
-                    this.accessory.minTempCoolDry = minTempCoolDry;
-                    this.accessory.maxTempCoolDry = maxTempCoolDry;
-                    this.accessory.temperatureUnit = TemperatureDisplayUnits[this.accessory.useFahrenheit];
+                    const obj = {
+                        presets: presetsOnServer,
+                        hasRoomTemperature: hasRoomTemperature,
+                        hasSupplyTemperature: hasSupplyTemperature,
+                        hasOutdoorTemperature: hasOutdoorTemperature,
+                        hasCoolOperationMode: hasCoolOperationMode,
+                        hasHeatOperationMode: hasHeatOperationMode,
+                        hasCO2Sensor: hasCO2Sensor,
+                        roomCO2Level: roomCO2Level,
+                        roomCO2Detected: roomCO2Detected,
+                        hasPM25Sensor: hasPM25Sensor,
+                        pM25SensorStatus: pM25SensorStatus,
+                        pM25Level: pM25Level,
+                        pM25AirQuality: pM25AirQuality,
+                        hasAutoVentilationMode: hasAutoVentilationMode,
+                        hasBypassVentilationMode: hasBypassVentilationMode,
+                        hasAutomaticFanSpeed: hasAutomaticFanSpeed,
+                        coreMaintenanceRequired: coreMaintenanceRequired,
+                        filterMaintenanceRequired: filterMaintenanceRequired,
+                        actualVentilationMode: actualVentilationMode,
+                        numberOfFanSpeeds: numberOfFanSpeeds,
+                        power: power ? 1 : 0,
+                        operationMode: operationMode,
+                        currentOperationMode: 0,
+                        targetOperationMode: 0,
+                        ventilationMode: ventilationMode,
+                        roomTemperature: roomTemperature,
+                        supplyTemperature: supplyTemperature,
+                        outdoorTemperature: outdoorTemperature,
+                        setTemperature: setTemperature,
+                        defaultHeatingSetTemperature: defaultHeatingSetTemperature,
+                        defaultCoolingSetTemperature: defaultCoolingSetTemperature,
+                        lockPhysicalControl: 0,
+                        temperatureIncrement: temperatureIncrement,
+                        minTempHeat: minTempHeat,
+                        temperatureIncrement: maxTempHeat,
+                        minTempCoolDry: minTempCoolDry,
+                        maxTempCoolDry: maxTempCoolDry,
+                        useFahrenheit: this.useFahrenheit,
+                        temperatureUnit: TemperatureDisplayUnits[this.useFahrenheit]
+                    };
 
                     //ventilation mode - 0, HEAT, 2, COOL, 4, 5, 6, FAN, AUTO
                     switch (this.displayMode) {
                         case 1: //Heater Cooler
                             switch (ventilationMode) {
                                 case 0: //LOSSNAY
-                                    this.accessory.currentOperationMode = 2; //INACTIVE, IDLE, HEATING, COOLIN
-                                    this.accessory.targetOperationMode = 1; //AUTO, HEAT, COOL
+                                    obj.currentOperationMode = 2; //INACTIVE, IDLE, HEATING, COOLIN
+                                    obj.targetOperationMode = 1; //AUTO, HEAT, COOL
                                     break;
                                 case 1: //BYPASS
-                                    this.accessory.currentOperationMode = 3;
-                                    this.accessory.targetOperationMode = 2;
+                                    obj.currentOperationMode = 3;
+                                    obj.targetOperationMode = 2;
                                     break;
                                 case 2: //AUTO
                                     switch (actualVentilationMode) {
                                         case 0: //LOSSNAY
-                                            this.accessory.currentOperationMode = 2;
+                                            obj.currentOperationMode = 2;
                                             break;
                                         case 1: //BYPASS
-                                            this.accessory.currentOperationMode = 3;
+                                            obj.currentOperationMode = 3;
                                             break;
                                         default:
                                             this.emit('warn', `Unknown actual ventilation mode: ${actualVentilationMode}`);
                                             break;
                                     };
-                                    this.accessory.targetOperationMode = 0;
+                                    obj.targetOperationMode = 0;
                                     break;
                                 default:
                                     this.emit('warn', `Unknown ventilation mode: ${ventilationMode}`);
                                     break;
                             };
 
-                            this.accessory.currentOperationMode = !power ? 0 : this.accessory.currentOperationMode;
-                            this.accessory.operationModeSetPropsMinValue = hasAutoVentilationMode ? 0 : 1;
-                            this.accessory.operationModeSetPropsMaxValue = hasAutoVentilationMode ? 2 : 2;
-                            this.accessory.operationModeSetPropsValidValues = hasAutoVentilationMode ? (hasBypassVentilationMode ? [0, 1, 2] : [0, 2]) : (hasBypassVentilationMode ? [1, 2] : [2]);
+                            obj.currentOperationMode = !power ? 0 : obj.currentOperationMode;
+                            obj.targetOperationMode = obj.targetOperationMode;
+                            obj.operationModeSetPropsMinValue = hasAutoVentilationMode ? 0 : 1;
+                            obj.operationModeSetPropsMaxValue = hasAutoVentilationMode ? 2 : 2;
+                            obj.operationModeSetPropsValidValues = hasAutoVentilationMode ? (hasBypassVentilationMode ? [0, 1, 2] : [0, 2]) : (hasBypassVentilationMode ? [1, 2] : [2]);
 
                             //fan speed mode
-                            this.accessory.fanSpeedSetPropsMaxValue = 2;
+                            obj.fanSpeedSetPropsMaxValue = 2;
                             switch (numberOfFanSpeeds) {
                                 case 2: //Fan speed mode 2
-                                    this.accessory.fanSpeed = hasAutomaticFanSpeed ? [3, 1, 2][setFanSpeed] : [0, 1, 2][setFanSpeed];
-                                    this.accessory.fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 3 : 2;
+                                    obj.fanSpeed = hasAutomaticFanSpeed ? [3, 1, 2][setFanSpeed] : [0, 1, 2][setFanSpeed];
+                                    obj.fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 3 : 2;
                                     break;
                                 case 3: //Fan speed mode 3
-                                    this.this.accessory.fanSpeed = hasAutomaticFanSpeed ? [4, 1, 2, 3][setFanSpeed] : [0, 1, 2, 3][setFanSpeed];
-                                    this.accessory.fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 4 : 3;
+                                    this.obj.fanSpeed = hasAutomaticFanSpeed ? [4, 1, 2, 3][setFanSpeed] : [0, 1, 2, 3][setFanSpeed];
+                                    obj.fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 4 : 3;
                                     break;
                                 case 4: //Fan speed mode 4
-                                    this.accessory.fanSpeed = hasAutomaticFanSpeed ? [5, 1, 2, 3, 4][setFanSpeed] : [0, 1, 2, 3, 4][setFanSpeed];
-                                    this.accessory.fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 5 : 4;
+                                    obj.fanSpeed = hasAutomaticFanSpeed ? [5, 1, 2, 3, 4][setFanSpeed] : [0, 1, 2, 3, 4][setFanSpeed];
+                                    obj.fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 5 : 4;
                                     break;
                             };
 
@@ -1030,12 +1036,12 @@ class DeviceErv extends EventEmitter {
                             if (this.melCloudService) {
                                 this.melCloudService
                                     .updateCharacteristic(Characteristic.Active, power)
-                                    .updateCharacteristic(Characteristic.CurrentHeaterCoolerState, this.accessory.currentOperationMode)
-                                    .updateCharacteristic(Characteristic.TargetHeaterCoolerState, this.accessory.targetOperationMode)
+                                    .updateCharacteristic(Characteristic.CurrentHeaterCoolerState, obj.currentOperationMode)
+                                    .updateCharacteristic(Characteristic.TargetHeaterCoolerState, obj.targetOperationMode)
                                     .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
-                                    .updateCharacteristic(Characteristic.RotationSpeed, this.accessory.fanSpeed)
-                                    .updateCharacteristic(Characteristic.LockPhysicalControls, this.accessory.lockPhysicalControl)
-                                    .updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
+                                    .updateCharacteristic(Characteristic.RotationSpeed, obj.fanSpeed)
+                                    .updateCharacteristic(Characteristic.LockPhysicalControls, obj.lockPhysicalControl)
+                                    .updateCharacteristic(Characteristic.TemperatureDisplayUnits, obj.useFahrenheit);
                                 const updateDefCool = hasCoolOperationMode ? this.melCloudService.updateCharacteristic(Characteristic.CoolingThresholdTemperature, defaultCoolingSetTemperature) : false;
                                 const updateDefHeat = hasHeatOperationMode ? this.melCloudService.updateCharacteristic(Characteristic.HeatingThresholdTemperature, defaultHeatingSetTemperature) : false;
                             };
@@ -1044,49 +1050,50 @@ class DeviceErv extends EventEmitter {
                             //operation mode - 0, HEAT, 2, COOL, 4, 5, 6, FAN, AUTO
                             switch (ventilationMode) {
                                 case 0: //LOSSNAY
-                                    this.accessory.currentOperationMode = 1; //OFF, HEAT, COOL
-                                    this.accessory.targetOperationMode = 1; //OFF, HEAT, COOL, AUTO
+                                    obj.currentOperationMode = 1; //OFF, HEAT, COOL
+                                    obj.targetOperationMode = 1; //OFF, HEAT, COOL, AUTO
                                     break;
                                 case 1: //BYPASS
-                                    this.accessory.currentOperationMode = 2;
-                                    this.accessory.targetOperationMode = 2;
+                                    obj.currentOperationMode = 2;
+                                    obj.targetOperationMode = 2;
                                     break;
                                 case 2: //AUTO
                                     switch (actualVentilationMode) {
                                         case 0: //LOSSNAY
-                                            this.accessory.currentOperationMode = 1;
+                                            obj.currentOperationMode = 1;
                                             break;
                                         case 1: //BYPASS
-                                            this.accessory.currentOperationMode = 2;
+                                            obj.currentOperationMode = 2;
                                             break;
                                         default:
                                             this.emit('warn', `Unknown actual ventilation mode: ${actualVentilationMode}`);
                                             break;
                                     };
-                                    this.accessory.targetOperationMode = 3;
+                                    obj.targetOperationMode = 3;
                                     break;
                                 default:
                                     this.emit('warn', `Unknown ventilation mode: ${ventilationMode}`);
                                     break;
                             };
 
-                            this.accessory.currentOperationMode = !power ? 0 : this.accessory.currentOperationMode;
-                            this.accessory.targetOperationMode = !power ? 0 : this.accessory.targetOperationMode;
-                            this.accessory.operationModeSetPropsMinValue = hasAutoVentilationMode ? 0 : 0;
-                            this.accessory.operationModeSetPropsMaxValue = hasAutoVentilationMode ? 3 : 2;
-                            this.accessory.operationModeSetPropsValidValues = hasAutoVentilationMode ? (hasBypassVentilationMode ? [0, 1, 2, 3] : [0, 2, 3]) : (hasBypassVentilationMode ? [0, 1, 2] : [0, 2]);
+                            obj.currentOperationMode = !power ? 0 : obj.currentOperationMode;
+                            obj.targetOperationMode = !power ? 0 : obj.targetOperationMode;
+                            obj.operationModeSetPropsMinValue = hasAutoVentilationMode ? 0 : 0;
+                            obj.operationModeSetPropsMaxValue = hasAutoVentilationMode ? 3 : 2;
+                            obj.operationModeSetPropsValidValues = hasAutoVentilationMode ? (hasBypassVentilationMode ? [0, 1, 2, 3] : [0, 2, 3]) : (hasBypassVentilationMode ? [0, 1, 2] : [0, 2]);
 
                             //update characteristics
                             if (this.melCloudService) {
                                 this.melCloudService
-                                    .updateCharacteristic(Characteristic.CurrentHeatingCoolingState, this.accessory.currentOperationMode)
-                                    .updateCharacteristic(Characteristic.TargetHeatingCoolingState, this.accessory.targetOperationMode)
+                                    .updateCharacteristic(Characteristic.CurrentHeatingCoolingState, obj.currentOperationMode)
+                                    .updateCharacteristic(Characteristic.TargetHeatingCoolingState, obj.targetOperationMode)
                                     .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
                                     .updateCharacteristic(Characteristic.TargetTemperature, setTemperature)
-                                    .updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
+                                    .updateCharacteristic(Characteristic.TemperatureDisplayUnits, obj.useFahrenheit);
                             };
                             break;
                     };
+                    this.accessory = obj;
 
                     //update temperature sensors
                     if (this.roomTemperatureSensorService) {
@@ -1185,7 +1192,7 @@ class DeviceErv extends EventEmitter {
                                     button.state = power ? (setFanSpeed === 4) : false;
                                     break;
                                 case 15: //PHYSICAL LOCK CONTROLS
-                                    button.state = (this.accessory.lockPhysicalControl === 1);
+                                    button.state = (obj.lockPhysicalControl === 1);
                                     break;
                                 case 16: //ROOM TEMP HIDE
                                     button.state = (hideRoomTemperature === true);
@@ -1215,12 +1222,12 @@ class DeviceErv extends EventEmitter {
                         this.emit('info', `Power: ${power ? 'ON' : 'OFF'}`);
                         this.emit('info', `Target ventilation mode: ${Ventilation.OperationMode[ventilationMode]}`);
                         this.emit('info', `Current ventilation mode: ${Ventilation.OperationMode[actualVentilationMode]}`);
-                        this.emit('info', `Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`);
-                        this.emit('info', `Room temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
-                        const info1 = hasSupplyTemperature && deviceData.Device.SupplyTemperature !== null ? this.emit('info', `Supply temperature: ${roomTemperature}${this.accessory.temperatureUnit}`) : false;
-                        const info2 = hasOutdoorTemperature && deviceData.Device.OutdoorTemperature !== null ? this.emit('info', `Outdoor temperature: ${roomTemperature}${this.accessory.temperatureUnit}`) : false;
+                        this.emit('info', `Target temperature: ${setTemperature}${obj.temperatureUnit}`);
+                        this.emit('info', `Room temperature: ${roomTemperature}${obj.temperatureUnit}`);
+                        const info1 = hasSupplyTemperature && deviceData.Device.SupplyTemperature !== null ? this.emit('info', `Supply temperature: ${roomTemperature}${obj.temperatureUnit}`) : false;
+                        const info2 = hasOutdoorTemperature && deviceData.Device.OutdoorTemperature !== null ? this.emit('info', `Outdoor temperature: ${roomTemperature}${obj.temperatureUnit}`) : false;
                         this.emit('info', `Fan speed mode: ${Ventilation.FanSpeed[setFanSpeed]}`);
-                        this.emit('info', `Temperature display unit: ${this.accessory.temperatureUnit}`);
+                        this.emit('info', `Temperature display unit: ${obj.temperatureUnit}`);
                         this.emit('info', `Core maintenance: ${Ventilation.CoreMaintenance[coreMaintenanceRequired]}`);
                         this.emit('info', `Filter maintenance: ${Ventilation.FilterMaintenance[filterMaintenanceRequired]}`);
                         const info5 = hasCO2Sensor ? this.emit('info', `CO2 detected: ${Ventilation.Co2Detected[roomCO2Detected]}`) : false;