homebridge-melcloud-control 2.3.0-beta.8 → 2.3.1-beta.0

package/src/deviceerv.js

@@ -29,15 +29,12 @@ class DeviceErv extends EventEmitter {
 
         //external integrations
         const restFul = account.restFul ?? {};
-        const restFulEnabled = restFul.enable || false;
         this.restFulConnected = false;
         const mqtt = account.mqtt ?? {};
-        const mqttEnabled = mqtt.enable || false;
         this.mqttConnected = false;
 
-        //variables
+        //function
         this.melCloud = melCloud; //function
-        this.startPrepareAccessory = true;
 
         //buttons configured
         this.buttonsConfigured = [];
@@ -60,6 +57,19 @@ class DeviceErv extends EventEmitter {
         }
         this.buttonsConfiguredCount = this.buttonsConfigured.length || 0;
 
+        //variables
+        this.startPrepareAccessory = true;
+        this.currentOperationMode = 0;
+        this.targetOperationMode = 0;
+        this.fanSpeed = 0;
+        this.lockPhysicalControl = 0;
+        this.useFahrenheit = 0;
+
+        this.operationModeSetPropsMinValue = 0;
+        this.operationModeSetPropsMaxValue = 3;
+        this.operationModeSetPropsValidValues = [0];
+        this.fanSpeedSetPropsMaxValue = 2;
+
         //melcloud device
         this.melCloudErv = new MelCloudErv({
             contextKey: contextKey,
@@ -71,6 +81,7 @@ class DeviceErv extends EventEmitter {
 
         this.melCloudErv.on('externalIntegrations', (deviceData, deviceState) => {
             //RESTFul server
+            const restFulEnabled = restFul.enable || false;
             if (restFulEnabled) {
                 if (!this.restFulConnected) {
                     this.restFul = new RestFul({
@@ -101,6 +112,7 @@ class DeviceErv extends EventEmitter {
             }
 
             //MQTT client
+            const mqttEnabled = mqtt.enable || false;
             if (mqttEnabled) {
                 if (!this.mqttConnected) {
                     this.mqtt = new Mqtt({
@@ -228,96 +240,141 @@ class DeviceErv extends EventEmitter {
                 this.presets = presets;
                 this.presetsCount = this.presetsEnabled ? presets.length : 0;
 
-                //operating mode
-                let currentOperationMode = 0;
-                let targetOperationMode = 0;
-                let fanSpeed = 0;
-                let lockPhysicalControls = 0;
-
                 //set temperature
                 const targetTemperature = hasCoolOperationMode || hasHeatOperationMode ? setTemperature : 20;
-                let operationModeSetPropsMinValue = 0;
-                let operationModeSetPropsMaxValue = 3;
-                let operationModeSetPropsValidValues = [0, 1, 2, 3];
-                let fanSpeedSetPropsMaxValue = 2;
 
+                //operation mode - 0, HEAT, 2, COOL, 4, 5, 6, FAN, AUTO
                 switch (displayMode) {
                     case 0: //Heater Cooler
-                        //operation mode - 0, HEAT, 2, COOL, 4, 5, 6, FAN, AUTO
-                        //ventilation mode - LOSSNAY, BYPASS, AUTO
-                        //actual ventilation mode - LOSSNAY, BYPASS
-                        currentOperationMode = !power ? 0 : [2, 3, [2, 3][actualVentilationMode]][ventilationMode]; //INACTIVE, IDLE, HEATING, COOLING
-                        targetOperationMode = [1, 2, 0][ventilationMode]; //AUTO, HEAT, COOL
-                        operationModeSetPropsMinValue = hasAutoVentilationMode ? 0 : 1;
-                        operationModeSetPropsMaxValue = hasAutoVentilationMode ? 2 : 2;
-                        operationModeSetPropsValidValues = hasAutoVentilationMode ? (hasBypassVentilationMode ? [0, 1, 2] : [0, 2]) : (hasBypassVentilationMode ? [1, 2] : [2]);
+                        switch (power) {
+                            case true:
+                                switch (ventilationMode) {
+                                    case 0: //LOSSNAY
+                                        this.currentOperationMode = 2; //HEATING
+                                        this.targetOperationMode = 1; //HEAT
+                                        break;
+                                    case 1: //BYPASS
+                                        this.currentOperationMode = 3; //COOLING
+                                        this.targetOperationMode = 2; //COOL
+                                        break;
+                                    case 2: //AUTO
+                                        switch (actualVentilationMode) {
+                                            case 0: //LOSSNAY
+                                                this.currentOperationMode = 2; //HEATING
+                                                break;
+                                            case 1: //BYPASS
+                                                this.currentOperationMode = 3; //COOLING
+                                                break;
+                                            default:
+                                                this.emit('warn', `Unknown actual ventilation mode: ${actualVentilationMode}`);
+                                                break;
+                                        };
+                                        this.targetOperationMode = 0; //AUTO
+                                        break;
+                                    default:
+                                        this.emit('warn', `Unknown ventilation mode: ${ventilationMode}`);
+                                        break;
+                                };
+                                break;
+                            case false:
+                                this.currentOperationMode = 0; //OFF
+                                break;
+                        };
+
+                        this.operationModeSetPropsMinValue = hasAutoVentilationMode ? 0 : 1;
+                        this.operationModeSetPropsMaxValue = hasAutoVentilationMode ? 2 : 2;
+                        this.operationModeSetPropsValidValues = hasAutoVentilationMode ? (hasBypassVentilationMode ? [0, 1, 2] : [0, 2]) : (hasBypassVentilationMode ? [1, 2] : [2]);
 
                         //fan speed mode
                         switch (numberOfFanSpeeds) {
                             case 2: //Fan speed mode 2
-                                fanSpeed = hasAutomaticFanSpeed ? [3, 1, 2][setFanSpeed] : [0, 1, 2][setFanSpeed];
-                                fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 3 : 2;
+                                this.fanSpeed = hasAutomaticFanSpeed ? [3, 1, 2][setFanSpeed] : [0, 1, 2][setFanSpeed];
+                                this.fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 3 : 2;
                                 break;
                             case 3: //Fan speed mode 3
-                                fanSpeed = hasAutomaticFanSpeed ? [4, 1, 2, 3][setFanSpeed] : [0, 1, 2, 3][setFanSpeed];
-                                fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 4 : 3;
+                                this.this.fanSpeed = hasAutomaticFanSpeed ? [4, 1, 2, 3][setFanSpeed] : [0, 1, 2, 3][setFanSpeed];
+                                this.fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 4 : 3;
                                 break;
                             case 4: //Fan speed mode 4
-                                fanSpeed = hasAutomaticFanSpeed ? [5, 1, 2, 3, 4][setFanSpeed] : [0, 1, 2, 3, 4][setFanSpeed];
-                                fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 5 : 4;
+                                this.fanSpeed = hasAutomaticFanSpeed ? [5, 1, 2, 3, 4][setFanSpeed] : [0, 1, 2, 3, 4][setFanSpeed];
+                                this.fanSpeedSetPropsMaxValue = hasAutomaticFanSpeed ? 5 : 4;
                                 break;
                         };
 
-                        //lock physical controls
-                        lockPhysicalControls = 0;
-
                         //update characteristics
                         if (this.melCloudService) {
                             this.melCloudService
                                 .updateCharacteristic(Characteristic.Active, power)
-                                .updateCharacteristic(Characteristic.CurrentHeaterCoolerState, currentOperationMode)
-                                .updateCharacteristic(Characteristic.TargetHeaterCoolerState, targetOperationMode)
+                                .updateCharacteristic(Characteristic.CurrentHeaterCoolerState, this.currentOperationMode)
+                                .updateCharacteristic(Characteristic.TargetHeaterCoolerState, this.targetOperationMode)
                                 .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
-                                .updateCharacteristic(Characteristic.RotationSpeed, fanSpeed)
-                                .updateCharacteristic(Characteristic.LockPhysicalControls, lockPhysicalControls)
-                                .updateCharacteristic(Characteristic.TemperatureDisplayUnits, useFahrenheit);
+                                .updateCharacteristic(Characteristic.RotationSpeed, this.fanSpeed)
+                                .updateCharacteristic(Characteristic.LockPhysicalControls, this.lockPhysicalControl)
+                                .updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.useFahrenheit);
                             const updateHOM = hasHeatOperationMode ? this.melCloudService.updateCharacteristic(Characteristic.HeatingThresholdTemperature, targetTemperature) : false;
                             const updateCOM = hasCoolOperationMode ? this.melCloudService.updateCharacteristic(Characteristic.CoolingThresholdTemperature, targetTemperature) : false;
                         };
                         break;
                     case 1: //Thermostat
                         //operation mode - 0, HEAT, 2, COOL, 4, 5, 6, FAN, AUTO
-                        //ventilation mode - LOSSNAY, BYPASS, AUTO
-                        //actual ventilation mode - LOSSNAY, BYPASS
-                        currentOperationMode = !power ? 0 : [1, 2, [1, 2][actualVentilationMode]][ventilationMode]; //OFF, HEAT, COOL
-                        targetOperationMode = !power ? 0 : [1, 2, 3][ventilationMode]; //OFF, HEAT, COOL, AUTO
-                        operationModeSetPropsMinValue = hasAutoVentilationMode ? 0 : 0;
-                        operationModeSetPropsMaxValue = hasAutoVentilationMode ? 3 : 2;
-                        operationModeSetPropsValidValues = hasAutoVentilationMode ? (hasBypassVentilationMode ? [0, 1, 2, 3] : [0, 2, 3]) : (hasBypassVentilationMode ? [0, 1, 2] : [0, 2]);
+                        switch (power) {
+                            case true:
+                                switch (ventilationMode) {
+                                    case 0: //LOSSNAY
+                                        this.currentOperationMode = 1; //HEATING
+                                        this.targetOperationMode = 1; //HEAT
+                                        break;
+                                    case 1: //BYPASS
+                                        this.currentOperationMode = 2; //COOLING
+                                        this.targetOperationMode = 2; //COOL
+                                        break;
+                                    case 2: //AUTO
+                                        switch (actualVentilationMode) {
+                                            case 0: //LOSSNAY
+                                                this.currentOperationMode = 1; //HEATING
+                                                break;
+                                            case 1: //BYPASS
+                                                this.currentOperationMode = 2; //COOLING
+                                                break;
+                                            default:
+                                                this.emit('warn', `Unknown actual ventilation mode: ${actualVentilationMode}`);
+                                                break;
+                                        };
+                                        this.targetOperationMode = 3; //AUTO
+                                        break;
+                                    default:
+                                        this.emit('warn', `Unknown ventilation mode: ${ventilationMode}`);
+                                        break;
+                                };
+                                break;
+                            case false:
+                                this.currentOperationMode = 0; //OFF
+                                this.targetOperationMode = 0; //OFF
+                                break;
+                        };
+                        this.operationModeSetPropsMinValue = hasAutoVentilationMode ? 0 : 0;
+                        this.operationModeSetPropsMaxValue = hasAutoVentilationMode ? 3 : 2;
+                        this.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, currentOperationMode)
-                                .updateCharacteristic(Characteristic.TargetHeatingCoolingState, targetOperationMode)
+                                .updateCharacteristic(Characteristic.CurrentHeatingCoolingState, this.currentOperationMode)
+                                .updateCharacteristic(Characteristic.TargetHeatingCoolingState, this.targetOperationMode)
                                 .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
                                 .updateCharacteristic(Characteristic.TargetTemperature, targetTemperature)
-                                .updateCharacteristic(Characteristic.TemperatureDisplayUnits, useFahrenheit);
+                                .updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.useFahrenheit);
                         };
                         break;
                 };
 
                 this.power = power;
                 this.offline = offline;
-                this.currentOperationMode = currentOperationMode;
-                this.targetOperationMode = targetOperationMode;
                 this.roomTemperature = roomTemperature;
                 this.supplyTemperature = supplyTemperature;
                 this.outdoorTemperature = outdoorTemperature;
                 this.setTemperature = targetTemperature;
-                this.fanSpeed = fanSpeed;
                 this.setFanSpeed = setFanSpeed;
-                this.lockPhysicalControls = lockPhysicalControls;
 
                 //update temperature sensors
                 if (this.roomTemperatureSensorService) {
@@ -398,7 +455,7 @@ class DeviceErv extends EventEmitter {
                                 button.state = power ? (setFanSpeed === 4) : false;
                                 break;
                             case 15: //PHYSICAL LOCK CONTROLS
-                                button.state = (lockPhysicalControls === 1);
+                                button.state = (this.lockPhysicalControl === 1);
                                 break;
                             case 16: //ROOM TEMP HIDE
                                 button.state = (hideRoomTemperature === true);
@@ -467,12 +524,6 @@ class DeviceErv extends EventEmitter {
                 //start prepare accessory
                 if (this.startPrepareAccessory) {
                     try {
-                        this.operationModeSetPropsMinValue = operationModeSetPropsMinValue;
-                        this.operationModeSetPropsMaxValue = operationModeSetPropsMaxValue;
-                        this.operationModeSetPropsValidValues = operationModeSetPropsValidValues;
-                        this.fanSpeedSetPropsMaxValue = fanSpeedSetPropsMaxValue;
-
-                        await new Promise(resolve => setTimeout(resolve, 150));
                         const accessory = await this.prepareAccessory(accountInfo, deviceState, deviceId, deviceTypeText, deviceName, accountName);
                         this.emit('publishAccessory', accessory);
                         this.startPrepareAccessory = false;
@@ -756,7 +807,7 @@ class DeviceErv extends EventEmitter {
                     };
                     //this.melCloudService.getCharacteristic(Characteristic.LockPhysicalControls)
                     //    .onGet(async () => {
-                    //        const value = this.lockPhysicalControls;
+                    //        const value = this.lockPhysicalControl;
                     //        const info = this.disableLogInfo ? false : this.emit('message', `Lock physical controls: ${value ? 'LOCKED' : 'UNLOCKED'}`);
                     //        return value;
                     //    })

package/src/melcloud.js

@@ -35,7 +35,7 @@ class MelCloud extends EventEmitter {
             try {
                 await this.chackDevicesList();
             } catch (error) {
-                this.emit('error', `Scheck devices list: ${error}.`);
+                this.emit('error', `Check devices list: ${error}.`);
             };
         }).on('state', (state) => { });
 
@@ -52,7 +52,7 @@ class MelCloud extends EventEmitter {
             const axiosInstanceLogin = axios.create({
                 method: 'POST',
                 baseURL: CONSTANTS.ApiUrls.BaseURL,
-                timeout: 25000,
+                timeout: 5000,
                 withCredentials: true,
                 maxContentLength: 100000000,
                 maxBodyLength: 1000000000,
@@ -90,7 +90,7 @@ class MelCloud extends EventEmitter {
             this.axiosInstanceGet = axios.create({
                 method: 'GET',
                 baseURL: CONSTANTS.ApiUrls.BaseURL,
-                timeout: 15000,
+                timeout: 5000,
                 headers: {
                     'X-MitsContextKey': contextKey
                 },
@@ -107,7 +107,7 @@ class MelCloud extends EventEmitter {
             this.axiosInstancePost = axios.create({
                 method: 'POST',
                 baseURL: CONSTANTS.ApiUrls.BaseURL,
-                timeout: 15000,
+                timeout: 5000,
                 headers: {
                     'X-MitsContextKey': contextKey,
                     'content-type': 'application/json'
@@ -202,10 +202,10 @@ class MelCloud extends EventEmitter {
     async saveData(path, data) {
         try {
             await fsPromises.writeFile(path, JSON.stringify(data, null, 2));
-            const debug3 = this.enableDebugMode ? this.emit('debug', `Data saved to path: ${path}.`) : false;
+            const debug3 = this.enableDebugMode ? this.emit('debug', `Data saved to: ${path}.`) : false;
             return true;
         } catch (error) {
-            throw new Error(`Save data to path: ${path}, error: ${error.message ?? error}`);
+            throw new Error(`Save data to: ${path}, error: ${error.message ?? error}`);
         }
     }
 

package/src/melcloudata.js

@@ -14,7 +14,7 @@ class MelCloudAta extends EventEmitter {
         const accountInfoFile = config.accountInfoFile;
         const deviceInfoFile = config.deviceInfoFile;
         const debugLog = config.debugLog;
-        const refreshInterval= config.refreshInterval;
+        const refreshInterval = config.refreshInterval;
 
         //set default values
         this.deviceData = {};
@@ -127,13 +127,13 @@ class MelCloudAta extends EventEmitter {
                 const legacyDevice = device.LegacyDevice;
                 const unitSupportsStandbyMode = device.UnitSupportsStandbyMode;
                 const isSplitSystem = device.IsSplitSystem;
-                const hasHalfDegreeIncrements = device.HasHalfDegreeIncrements ?? false;
-                const hasOutdoorTemperature = device.HasOutdoorTemperature ?? false
+                const hasHalfDegreeIncrements = device.HasHalfDegreeIncrements;
+                const hasOutdoorTemperature = device.HasOutdoorTemperature;
                 const modelIsAirCurtain = device.ModelIsAirCurtain;
-                const modelSupportsFanSpeed = device.ModelSupportsFanSpeed ?? false;
-                const modelSupportsAuto = device.ModelSupportsAuto ?? false;
-                const modelSupportsHeat = device.ModelSupportsHeat ?? false;
-                const modelSupportsDry = device.ModelSupportsDry ?? false;
+                const modelSupportsFanSpeed = device.ModelSupportsFanSpeed;
+                const modelSupportsAuto = device.ModelSupportsAuto;
+                const modelSupportsHeat = device.ModelSupportsHeat;
+                const modelSupportsDry = device.ModelSupportsDry;
                 const modelSupportsVaneVertical = device.ModelSupportsVaneVertical;
                 const modelSupportsVaneHorizontal = device.ModelSupportsVaneHorizontal;
                 const modelSupportsWideVane = device.ModelSupportsWideVane;