homebridge-melcloud-control 3.1.10 → 3.1.16

package/src/melcloud.js

@@ -15,9 +15,8 @@ class MelCloud extends EventEmitter {
         this.devicesFile = devicesFile;
         this.enableDebugMode = enableDebugMode;
         this.requestConfig = requestConfig;
-        this.contextKey = '';
-        this.useFahrenheit = 0;
         this.devicesId = [];
+        this.contextKey = '';
 
         this.options = {
             data: {
@@ -50,7 +49,7 @@ class MelCloud extends EventEmitter {
             const axiosInstanceLogin = axios.create({
                 method: 'POST',
                 baseURL: CONSTANTS.ApiUrls.BaseURL,
-                timeout: 5000,
+                timeout: 10000,
                 withCredentials: true,
                 maxContentLength: 100000000,
                 maxBodyLength: 1000000000,
@@ -63,7 +62,7 @@ class MelCloud extends EventEmitter {
             const account = accountData.data;
             const accountInfo = account.LoginData;
             const contextKey = accountInfo.ContextKey;
-            this.useFahrenheit = accountInfo.UseFahrenheit
+            const useFahrenheit = accountInfo.UseFahrenheit ? 1 : 0;
             this.contextKey = contextKey;
 
             //remove sensitive data
@@ -83,6 +82,24 @@ class MelCloud extends EventEmitter {
                 return;
             };
 
+            //create axios instance post
+            this.axiosInstancePost = axios.create({
+                method: 'POST',
+                baseURL: CONSTANTS.ApiUrls.BaseURL,
+                timeout: 10000,
+                headers: {
+                    'X-MitsContextKey': contextKey,
+                    'content-type': 'application/json'
+                },
+                maxContentLength: 100000000,
+                maxBodyLength: 1000000000,
+                withCredentials: true,
+                httpsAgent: new https.Agent({
+                    keepAlive: false,
+                    rejectUnauthorized: false
+                })
+            });
+
             //save melcloud info to the file
             await this.saveData(this.accountFile, accountInfo);
 
@@ -91,7 +108,8 @@ class MelCloud extends EventEmitter {
 
             const obj = {
                 accountInfo: accountInfo,
-                contextKey: contextKey
+                contextKey: contextKey,
+                useFahrenheit: useFahrenheit
             }
 
             return obj;
@@ -106,7 +124,7 @@ class MelCloud extends EventEmitter {
             const axiosInstanceGet = axios.create({
                 method: 'GET',
                 baseURL: CONSTANTS.ApiUrls.BaseURL,
-                timeout: 5000,
+                timeout: 10000,
                 headers: {
                     'X-MitsContextKey': contextKey
                 },
@@ -177,29 +195,11 @@ class MelCloud extends EventEmitter {
 
     async send(accountInfo) {
         try {
-            //create axios instance post
-            const axiosInstancePost = axios.create({
-                method: 'POST',
-                baseURL: CONSTANTS.ApiUrls.BaseURL,
-                timeout: 5000,
-                headers: {
-                    'X-MitsContextKey': this.contextKey,
-                    'content-type': 'application/json'
-                },
-                maxContentLength: 100000000,
-                maxBodyLength: 1000000000,
-                withCredentials: true,
-                httpsAgent: new https.Agent({
-                    keepAlive: false,
-                    rejectUnauthorized: false
-                })
-            });
-
             const options = {
                 data: accountInfo
             };
 
-            await axiosInstancePost(CONSTANTS.ApiUrls.UpdateApplicationOptions, options);
+            await this.axiosInstancePost(CONSTANTS.ApiUrls.UpdateApplicationOptions, options);
             await this.saveData(this.accountInfoFile, accountInfo);
             return true;
         } catch (error) {

package/src/melcloudata.js

@@ -10,14 +10,12 @@ const CONSTANTS = require('./constants.json');
 class MelCloudAta extends EventEmitter {
     constructor(config) {
         super();
-        this.accountFile = config.accountFile;
         this.devicesFile = config.devicesFile;
         this.deviceId = config.deviceId;
         this.debugLog = config.debugLog;
 
         //set default values
-        this.deviceData = {};
-        this.displayDeviceInfo = true;
+        this.deviceState = {};
 
         this.axiosInstancePost = axios.create({
             method: 'POST',
@@ -39,41 +37,22 @@ class MelCloudAta extends EventEmitter {
             try {
                 await this.checkState();
             } catch (error) {
-                await this.impulseGenerator.stop();
-                this.emit('error', `Impulse generator check state error: ${error.message || error}, check again in 15s.`);
+                this.emit('error', `Impulse generator check state error: ${error.message || error}.`);
             };
         }).on('state', (state) => { });
     };
 
     async checkState() {
         try {
-            //read account info from file
-            const accountInfo = await this.readData(this.accountFile);
-
-            //remove sensitive data
-            const debugData = {
-                ...accountInfo,
-                ContextKey: 'removed',
-                ClientId: 'removed',
-                Client: 'removed',
-                Name: 'removed',
-                MapLongitude: 'removed',
-                MapLatitude: 'removed'
-            };
-            const debug = this.debugLog ? this.emit('debug', `Account Info: ${JSON.stringify(debugData, null, 2)}`) : false;
-            const useFahrenheit = accountInfo.UseFahrenheit ? 1 : 0;
-            this.useFahrenheit = useFahrenheit;
-
             //read device info from file
             const devicesData = await this.readData(this.devicesFile);
-            const debug1 = this.debugLog ? this.emit('debug', `Device Info: ${JSON.stringify(devicesData, null, 2)}`) : false;
             const deviceData = devicesData.find((device) => device.DeviceID === this.deviceId);
 
             if (!deviceData) {
-                await this.impulseGenerator.stop();
-                this.emit('error', `Device data not found, check again in 15s.`);
+                this.emit('warn', `Device data not found.`);
                 return;
             }
+            const debug = this.debugLog ? this.emit('debug', `Device Data: ${JSON.stringify(deviceData, null, 2)}`) : false;
 
             //device info
             const deviceId = deviceData.DeviceID;
@@ -151,15 +130,15 @@ class MelCloudAta extends EventEmitter {
             const modelDisableEnergyReport = device.ModelDisableEnergyReport;
             const modelSupportsStandbyMode = device.ModelSupportsStandbyMode;
             const modelSupportsEnergyReporting = device.ModelSupportsEnergyReporting;
-            const prohibitSetTemperature = device.ProhibitSetTemperature ?? false;
-            const prohibitOperationMode = device.ProhibitOperationMode ?? false;
-            const prohibitPower = device.ProhibitPower ?? false;
-            const power = device.Power ?? false;
+            const prohibitSetTemperature = device.ProhibitSetTemperature;
+            const prohibitOperationMode = device.ProhibitOperationMode;
+            const prohibitPower = device.ProhibitPower;
+            const power = device.Power;
             const roomTemperature = device.RoomTemperature;
             const outdoorTemperature = device.OutdoorTemperature;
             const setTemperature = device.SetTemperature;
             const actualFanSpeed = device.ActualFanSpeed;
-            const fanSpeed = device.FanSpeed ?? 0;
+            const fanSpeed = device.FanSpeed;
             const automaticFanSpeed = device.AutomaticFanSpeed;
             const vaneVerticalDirection = device.VaneVerticalDirection;
             const vaneVerticalSwing = device.VaneVerticalSwing;
@@ -167,12 +146,12 @@ class MelCloudAta extends EventEmitter {
             const vaneHorizontalSwing = device.VaneHorizontalSwing;
             const operationMode = device.OperationMode;
             const effectiveFlags = device.EffectiveFlags;
-            const inStandbyMode = device.InStandbyMode ?? false;
+            const inStandbyMode = device.InStandbyMode;
             const demandPercentage = device.DemandPercentage;
             const configuredDemandPercentage = device.ConfiguredDemandPercentage;
             const hasDemandSideControl = device.HasDemandSideControl;
-            const defaultCoolingSetTemperature = device.DefaultCoolingSetTemperature ?? 23;
-            const defaultHeatingSetTemperature = device.DefaultHeatingSetTemperature ?? 21;
+            const defaultCoolingSetTemperature = device.DefaultCoolingSetTemperature;
+            const defaultHeatingSetTemperature = device.DefaultHeatingSetTemperature;
             const roomTemperatureLabel = device.RoomTemperatureLabel;
             const heatingEnergyConsumedRate1 = device.HeatingEnergyConsumedRate1;
             const heatingEnergyConsumedRate2 = device.HeatingEnergyConsumedRate2;
@@ -328,49 +307,40 @@ class MelCloudAta extends EventEmitter {
                 this.emit('warn', `Units are not configured in MELCloud service.`);
             };
 
-            //emit info
-            const emitInfo = this.displayDeviceInfo ? this.emit('deviceInfo', manufacturer, modelIndoor, modelOutdoor, serialNumber, firmwareAppVersion) : false;
-            this.displayDeviceInfo = false;
-
-            //device state
             const deviceState = {
-                DeviceId: deviceId,
-                EffectiveFlags: effectiveFlags,
                 RoomTemperature: roomTemperature,
                 SetTemperature: setTemperature,
-                SetFanSpeed: fanSpeed,
+                FanSpeed: fanSpeed,
                 OperationMode: operationMode,
-                VaneHorizontal: vaneHorizontalDirection,
-                VaneVertical: vaneVerticalDirection,
+                VaneHorizontalDirection: vaneHorizontalDirection,
+                VaneVerticalDirection: vaneVerticalDirection,
                 HideVaneControls: hideVaneControls,
                 HideDryModeControl: hideDryModeControl,
-                DefaultCoolingSetTemperature: defaultCoolingSetTemperature,
-                DefaultHeatingSetTemperature: defaultHeatingSetTemperature,
                 InStandbyMode: inStandbyMode,
                 ProhibitSetTemperature: prohibitSetTemperature,
                 ProhibitOperationMode: prohibitOperationMode,
                 ProhibitPower: prohibitPower,
-                Power: power,
-                Offline: offline
+                Power: power
             }
 
-            //external integrations
-            this.emit('externalIntegrations', deviceData, deviceState);
-
             //check state changes
-            const stateHasNotChanged = JSON.stringify(deviceData) === JSON.stringify(this.deviceData);
-            if (stateHasNotChanged) {
+            const deviceDataHasNotChanged = JSON.stringify(deviceState) === JSON.stringify(this.deviceState);
+            if (deviceDataHasNotChanged) {
                 return;
             }
+            this.deviceState = deviceState;
+
+            //external integrations
+            this.emit('externalIntegrations', deviceData);
+
+            //emit info
+            this.emit('deviceInfo', manufacturer, modelIndoor, modelOutdoor, serialNumber, firmwareAppVersion);
 
             //emit state
-            this.deviceData = deviceData;
-            const debug2 = this.debugLog ? this.emit('debug', `Device State: ${JSON.stringify(deviceState, null, 2)}`) : false;
-            this.emit('deviceState', deviceData, deviceState, useFahrenheit);
+            this.emit('deviceState', deviceData);
 
             return true;
         } catch (error) {
-            await this.impulseGenerator.stop();
             throw new Error(`Check state error: ${error.message || error}.`);
         };
     };
@@ -386,45 +356,66 @@ class MelCloudAta extends EventEmitter {
         }
     }
 
-    async send(deviceState) {
+    async send(deviceData) {
         try {
             //prevent to set out of range temp
-            const minTempHeat = this.deviceData.Device.MinTempHeat ?? 10;
-            const maxTempHeat = this.deviceData.Device.MaxTempHeat ?? 31;
-            const minTempCoolDry = this.deviceData.Device.MinTempCoolDry ?? 16;
-            const maxTempCoolDry = this.deviceData.Device.MaxTempCoolDry ?? 31;
-            const minTempAutomatic = this.deviceData.Device.MinTempAutomatic ?? 16;
-            const maxTempAutomatic = this.deviceData.Device.MaxTempAutomatic ?? 31;
-            switch (deviceState.OperationMode) {//operating mode 0, HEAT, DRY, COOL, 4, 5, 6, FAN, AUTO, ISEE HEAT, ISEE DRY, ISEE COOL
+            const minTempHeat = deviceData.Device.MinTempHeat ?? 10;
+            const maxTempHeat = deviceData.Device.MaxTempHeat ?? 31;
+            const minTempCoolDry = deviceData.Device.MinTempCoolDry ?? 16;
+            const maxTempCoolDry = deviceData.Device.MaxTempCoolDry ?? 31;
+            const minTempAutomatic = deviceData.Device.MinTempAutomatic ?? 16;
+            const maxTempAutomatic = deviceData.Device.MaxTempAutomatic ?? 31;
+
+
+            switch (deviceData.Device.OperationMode) {//operating mode 0, HEAT, DRY, COOL, 4, 5, 6, FAN, AUTO, ISEE HEAT, ISEE DRY, ISEE COOL
                 case 1:
-                    deviceState.SetTemperature = deviceState.SetTemperature < minTempHeat ? minTempHeat : deviceState.SetTemperature;
-                    deviceState.SetTemperature = deviceState.SetTemperature > maxTempHeat ? maxTempHeat : deviceState.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature < minTempHeat ? minTempHeat : deviceData.Device.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature > maxTempHeat ? maxTempHeat : deviceData.Device.SetTemperature;
                     break;
                 case 2:
-                    deviceState.SetTemperature = deviceState.SetTemperature < minTempCoolDry ? minTempCoolDry : deviceState.SetTemperature;
-                    deviceState.SetTemperature = deviceState.SetTemperature > maxTempCoolDry ? maxTempCoolDry : deviceState.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature < minTempCoolDry ? minTempCoolDry : deviceData.Device.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature > maxTempCoolDry ? maxTempCoolDry : deviceData.Device.SetTemperature;
                     break;
                 case 3:
-                    deviceState.SetTemperature = deviceState.SetTemperature < minTempCoolDry ? minTempCoolDry : deviceState.SetTemperature;
-                    deviceState.SetTemperature = deviceState.SetTemperature > maxTempCoolDry ? maxTempCoolDry : deviceState.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature < minTempCoolDry ? minTempCoolDry : deviceData.Device.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature > maxTempCoolDry ? maxTempCoolDry : deviceData.Device.SetTemperature;
                     break;
                 case 8:
-                    deviceState.SetTemperature = deviceState.SetTemperature < minTempAutomatic ? minTempAutomatic : deviceState.SetTemperature;
-                    deviceState.SetTemperature = deviceState.SetTemperature > maxTempAutomatic ? maxTempAutomatic : deviceState.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature < minTempAutomatic ? minTempAutomatic : deviceData.Device.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature > maxTempAutomatic ? maxTempAutomatic : deviceData.Device.SetTemperature;
                     break;
                 default:
-                    deviceState.SetTemperature = deviceState.SetTemperature < 10 ? 10 : deviceState.SetTemperature;
-                    deviceState.SetTemperature = deviceState.SetTemperature > 31 ? 31 : deviceState.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature < 10 ? 10 : deviceData.Device.SetTemperature;
+                    deviceData.Device.SetTemperature = deviceData.Device.SetTemperature > 31 ? 31 : deviceData.Device.SetTemperature;
                     break;
             };
 
-            deviceState.HasPendingCommand = true;
-            const options = {
-                data: deviceState
-            };
+            const payload = {
+                data: {
+                    DeviceID: deviceData.Device.DeviceID,
+                    EffectiveFlags: deviceData.Device.EffectiveFlags,
+                    RoomTemperature: deviceData.Device.RoomTemperature,
+                    SetTemperature: deviceData.Device.SetTemperature,
+                    SetFanSpeed: deviceData.Device.FanSpeed,
+                    OperationMode: deviceData.Device.OperationMode,
+                    VaneHorizontal: deviceData.Device.VaneHorizontalDirection,
+                    VaneVertical: deviceData.Device.VaneVerticalDirection,
+                    HideVaneControls: deviceData.Device.HideVaneControls,
+                    HideDryModeControl: deviceData.Device.HideDryModeControl,
+                    DefaultCoolingSetTemperature: deviceData.Device.DefaultCoolingSetTemperature ?? 23,
+                    DefaultHeatingSetTemperature: deviceData.Device.DefaultHeatingSetTemperature ?? 21,
+                    InStandbyMode: deviceData.Device.InStandbyMode,
+                    ProhibitSetTemperature: deviceData.Device.ProhibitSetTemperature,
+                    ProhibitOperationMode: deviceData.Device.ProhibitOperationMode,
+                    ProhibitPower: deviceData.Device.ProhibitPower,
+                    Power: deviceData.Device.Power,
+                    Offline: deviceData.Device.Offline,
+                    HasPendingCommand: true
+                }
+            }
 
-            await this.axiosInstancePost(CONSTANTS.ApiUrls.SetAta, options);
-            this.emit('deviceState', this.deviceData, deviceState, this.useFahrenheit);
+            await this.axiosInstancePost(CONSTANTS.ApiUrls.SetAta, payload);
+            this.emit('deviceState', deviceData);
             return true;
         } catch (error) {
             throw new Error(error.message ?? error);

package/src/melcloudatw.js

@@ -10,14 +10,12 @@ const CONSTANTS = require('./constants.json');
 class MelCloudAtw extends EventEmitter {
     constructor(config) {
         super();
-        this.accountFile = config.accountFile;
         this.devicesFile = config.devicesFile;
         this.deviceId = config.deviceId;
         this.debugLog = config.debugLog;
 
         //set default values
-        this.deviceData = {};
-        this.displayDeviceInfo = true;
+        this.deviceState = {};
 
         this.axiosInstancePost = axios.create({
             method: 'POST',
@@ -39,41 +37,22 @@ class MelCloudAtw extends EventEmitter {
             try {
                 await this.checkState();
             } catch (error) {
-                await this.impulseGenerator.stop();
-                this.emit('error', `Impulse generator check state error: ${error.message || error}, check again in 15s.`);
+                this.emit('error', `Impulse generator check state error: ${error.message || error}.`);
             };
         }).on('state', (state) => { });
     };
 
     async checkState() {
         try {
-            //read account info from file
-            const accountInfo = await this.readData(this.accountFile);
-
-            //remove sensitive data
-            const debugData = {
-                ...accountInfo,
-                ContextKey: 'removed',
-                ClientId: 'removed',
-                Client: 'removed',
-                Name: 'removed',
-                MapLongitude: 'removed',
-                MapLatitude: 'removed'
-            };
-            const debug = this.debugLog ? this.emit('debug', `Account Info: ${JSON.stringify(debugData, null, 2)}`) : false;
-            const useFahrenheit = accountInfo.UseFahrenheit ? 1 : 0;
-            this.useFahrenheit = useFahrenheit;
-
             //read device info from file
             const devicesData = await this.readData(this.devicesFile);
-            const debug1 = this.debugLog ? this.emit('debug', `Device Info: ${JSON.stringify(devicesData, null, 2)}`) : false;
             const deviceData = devicesData.find((device) => device.DeviceID === this.deviceId);
 
             if (!deviceData) {
-                await this.impulseGenerator.stop();
-                this.emit('error', `Device data not found, check again in 15s.`);
+                this.emit('warn', `Device data not found.`);
                 return;
             }
+            const debug = this.debugLog ? this.emit('debug', `Device Data: ${JSON.stringify(deviceData, null, 2)}`) : false;
 
             //device info
             const deviceId = deviceData.DeviceID;
@@ -169,7 +148,7 @@ class MelCloudAtw extends EventEmitter {
             const valveStatus2Way2a = device.ValveStatus2Way2a;
             const valveStatus2Way2b = device.ValveStatus2Way2b;
             const tankWaterTemperature = device.TankWaterTemperature;
-            const unitStatus = device.UnitStatus ?? 0;
+            const unitStatus = device.UnitStatus;
             const heatingFunctionEnabled = device.HeatingFunctionEnabled;
             const serverTimerEnabled = device.ServerTimerEnabled;
             const thermostatStatusZone1 = device.ThermostatStatusZone1;
@@ -180,8 +159,8 @@ class MelCloudAtw extends EventEmitter {
             const condensingTemperature = device.CondensingTemperature;
             const effectiveFlags = device.EffectiveFlags;
             const lastEffectiveFlags = device.LastEffectiveFlags;
-            const power = device.Power ?? false;
-            const ecoHotWater = device.EcoHotWater ?? false;
+            const power = device.Power;
+            const ecoHotWater = device.EcoHotWater;
             const operationMode = device.OperationMode;
             const operationModeZone1 = device.OperationModeZone1;
             const operationModeZone2 = device.OperationModeZone2;
@@ -190,13 +169,13 @@ class MelCloudAtw extends EventEmitter {
             const setTankWaterTemperature = device.SetTankWaterTemperature;
             const targetHCTemperatureZone1 = device.TargetHCTemperatureZone1;
             const targetHCTemperatureZone2 = device.TargetHCTemperatureZone2;
-            const forcedHotWaterMode = device.ForcedHotWaterMode ? 1 : 0 ?? 0;
-            const holidayMode = device.HolidayMode ?? false;
-            const prohibitHotWater = device.ProhibitHotWater ?? false;
-            const prohibitHeatingZone1 = device.ProhibitHeatingZone1 ?? false;
-            const prohibitHeatingZone2 = device.ProhibitHeatingZone2 ?? false;
-            const prohibitCoolingZone1 = device.ProhibitCoolingZone1 ?? false;
-            const prohibitCoolingZone2 = device.ProhibitCoolingZone2 ?? false;
+            const forcedHotWaterMode = device.ForcedHotWaterMode;
+            const holidayMode = device.HolidayMode;
+            const prohibitHotWater = device.ProhibitHotWater;
+            const prohibitHeatingZone1 = device.ProhibitHeatingZone1;
+            const prohibitHeatingZone2 = device.ProhibitHeatingZone2;
+            const prohibitCoolingZone1 = device.ProhibitCoolingZone1;
+            const prohibitCoolingZone2 = device.ProhibitCoolingZone2;
             const serverTimerDesired = device.ServerTimerDesired;
             const secondaryZoneHeatCurve = device.SecondaryZoneHeatCurve;
             const setHeatFlowTemperatureZone1 = device.SetHeatFlowTemperatureZone1;
@@ -390,14 +369,7 @@ class MelCloudAtw extends EventEmitter {
                 this.emit('message', `Units are not configured in MELCloud service.`);
             };
 
-            //emit info
-            const emitInfo = this.displayDeviceInfo ? this.emit('deviceInfo', manufacturer, modelIndoor, modelOutdoor, serialNumber, firmwareAppVersion, hasHotWaterTank, hasZone2) : false;
-            this.displayDeviceInfo = false;
-
-            //device state
             const deviceState = {
-                DeviceId: deviceId,
-                EffectiveFlags: effectiveFlags,
                 SetTemperatureZone1: setTemperatureZone1,
                 SetTemperatureZone2: setTemperatureZone2,
                 RoomTemperatureZone1: roomTemperatureZone1,
@@ -421,27 +393,27 @@ class MelCloudAtw extends EventEmitter {
                 IdleZone1: idleZone1,
                 IdleZone2: idleZone2,
                 UnitStatus: unitStatus,
-                Power: power,
-                Offline: offline
+                Power: power
             }
 
-            //external integrations
-            this.emit('externalIntegrations', deviceData, deviceState, deviceId);
-
             //check state changes
-            const stateHasNotChanged = JSON.stringify(deviceData) === JSON.stringify(this.deviceData);
-            if (stateHasNotChanged) {
+            const deviceDataHasNotChanged = JSON.stringify(deviceState) === JSON.stringify(this.deviceState);
+            if (deviceDataHasNotChanged) {
                 return;
             }
+            this.deviceState = deviceState;
+
+            //external integrations
+            this.emit('externalIntegrations', deviceData);
+
+            //emit info
+            this.emit('deviceInfo', manufacturer, modelIndoor, modelOutdoor, serialNumber, firmwareAppVersion, hasHotWaterTank, hasZone2);
 
             //emit state
-            this.deviceData = deviceData;
-            const debug2 = this.debugLog ? this.emit('debug', `Device State: ${JSON.stringify(deviceState, null, 2)}`) : false;
-            this.emit('deviceState', deviceData, deviceState, useFahrenheit);
+            this.emit('deviceState', deviceData);
 
             return true;
         } catch (error) {
-            await this.impulseGenerator.stop();
             throw new Error(`Check state error: ${error.message || error}.`);
         };
     };
@@ -456,27 +428,55 @@ class MelCloudAtw extends EventEmitter {
         }
     }
 
-    async send(deviceState) {
+    async send(deviceData) {
         try {
             //prevent to set out of range temp
             const minTempZones = 10;
             const maxTempZones = 31;
             const minTempWaterTank = 16;
-            const maxTempWaterTank = this.deviceData.Device.MaxTankTemperature ?? 70;
-            deviceState.SetTemperatureZone1 = deviceState.SetTemperatureZone1 < minTempZones ? minTempZones : deviceState.SetTemperatureZone1;
-            deviceState.SetTemperatureZone1 = deviceState.SetTemperatureZone1 > maxTempZones ? maxTempZones : deviceState.SetTemperatureZone1;
-            deviceState.SetTemperatureZone1 = deviceState.SetTemperatureZone2 < minTempZones ? minTempZones : deviceState.SetTemperatureZone2;
-            deviceState.SetTemperatureZone1 = deviceState.SetTemperatureZone2 > maxTempZones ? maxTempZones : deviceState.SetTemperatureZone2;
-            deviceState.SetTankWaterTemperature = deviceState.SetTankWaterTemperature < minTempWaterTank ? minTempWaterTank : deviceState.SetTankWaterTemperature;
-            deviceState.SetTankWaterTemperature = deviceState.SetTankWaterTemperature > maxTempWaterTank ? maxTempWaterTank : deviceState.SetTankWaterTemperature;
+            const maxTempWaterTank = deviceData.Device.MaxTankTemperature ?? 70;
+            deviceData.Device.SetTemperatureZone1 = deviceData.Device.SetTemperatureZone1 < minTempZones ? minTempZones : deviceData.Device.SetTemperatureZone1;
+            deviceData.Device.SetTemperatureZone1 = deviceData.Device.SetTemperatureZone1 > maxTempZones ? maxTempZones : deviceData.Device.SetTemperatureZone1;
+            deviceData.Device.SetTemperatureZone1 = deviceData.Device.SetTemperatureZone2 < minTempZones ? minTempZones : deviceData.Device.SetTemperatureZone2;
+            deviceData.Device.SetTemperatureZone1 = deviceData.Device.SetTemperatureZone2 > maxTempZones ? maxTempZones : deviceData.Device.SetTemperatureZone2;
+            deviceData.Device.SetTankWaterTemperature = deviceData.Device.SetTankWaterTemperature < minTempWaterTank ? minTempWaterTank : deviceData.Device.SetTankWaterTemperature;
+            deviceData.Device.SetTankWaterTemperature = deviceData.Device.SetTankWaterTemperature > maxTempWaterTank ? maxTempWaterTank : deviceData.Device.SetTankWaterTemperature;
 
-            deviceState.HasPendingCommand = true;
-            const options = {
-                data: deviceState
-            };
+            const payload = {
+                data: {
+                    DeviceID: deviceData.Device.DeviceID,
+                    EffectiveFlags: deviceData.Device.EffectiveFlags,
+                    SetTemperatureZone1: deviceData.Device.SetTemperatureZone1,
+                    SetTemperatureZone2: deviceData.Device.SetTemperatureZone2,
+                    RoomTemperatureZone1: deviceData.Device.RoomTemperatureZone1,
+                    RoomTemperatureZone2: deviceData.Device.RoomTemperatureZone2,
+                    OperationMode: deviceData.Device.OperationMode,
+                    OperationModeZone1: deviceData.Device.OperationModeZone1,
+                    OperationModeZone2: deviceData.Device.OperationModeZone2,
+                    SetHeatFlowTemperatureZone1: deviceData.Device.SetHeatFlowTemperatureZone1,
+                    SetHeatFlowTemperatureZone2: deviceData.Device.SetHeatFlowTemperatureZone2,
+                    SetCoolFlowTemperatureZone1: deviceData.Device.SetCoolFlowTemperatureZone1,
+                    SetCoolFlowTemperatureZone2: deviceData.Device.SetCoolFlowTemperatureZone2,
+                    TankWaterTemperature: deviceData.Device.TankWaterTemperature,
+                    SetTankWaterTemperature: deviceData.Device.SetTankWaterTemperature,
+                    ForcedHotWaterMode: deviceData.Device.ForcedHotWaterMode,
+                    OutdoorTemperature: deviceData.Device.OutdoorTemperature,
+                    EcoHotWater: deviceData.Device.EcoHotWater,
+                    HolidayMode: deviceData.Device.HolidayMode,
+                    ProhibitZone1: deviceData.Device.ProhibitHeatingZone1,
+                    ProhibitZone2: deviceData.Device.ProhibitHeatingZone2,
+                    ProhibitHotWater: deviceData.Device.ProhibitHotWater,
+                    IdleZone1: deviceData.Device.IdleZone1,
+                    IdleZone2: deviceData.Device.IdleZone2,
+                    UnitStatus: deviceData.Device.UnitStatus,
+                    Power: deviceData.Device.Power,
+                    Offline: deviceData.Device.Offline,
+                    HasPendingCommand: true
+                }
+            }
 
-            await this.axiosInstancePost(CONSTANTS.ApiUrls.SetAtw, options);
-            this.emit('deviceState', this.deviceData, deviceState, this.useFahrenheit);
+            await this.axiosInstancePost(CONSTANTS.ApiUrls.SetAtw, payload);
+            this.emit('deviceState', deviceData);
             return true;
         } catch (error) {
             throw new Error(error.message ?? error);