homebridge-melcloud-control 3.1.11 → 3.1.16

package/src/melcloudata.js

@@ -15,8 +15,7 @@ class MelCloudAta extends EventEmitter {
         this.debugLog = config.debugLog;
 
         //set default values
-        this.deviceData = {};
-        this.displayDeviceInfo = true;
+        this.deviceState = {};
 
         this.axiosInstancePost = axios.create({
             method: 'POST',
@@ -38,8 +37,7 @@ 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) => { });
     };
@@ -48,13 +46,13 @@ class MelCloudAta extends EventEmitter {
         try {
             //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) {
                 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;
@@ -132,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;
@@ -148,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;
@@ -309,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);
+            this.emit('deviceState', deviceData);
 
             return true;
         } catch (error) {
-            await this.impulseGenerator.stop();
             throw new Error(`Check state error: ${error.message || error}.`);
         };
     };
@@ -367,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);
+            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

@@ -15,8 +15,7 @@ class MelCloudAtw extends EventEmitter {
         this.debugLog = config.debugLog;
 
         //set default values
-        this.deviceData = {};
-        this.displayDeviceInfo = true;
+        this.deviceState = {};
 
         this.axiosInstancePost = axios.create({
             method: 'POST',
@@ -38,8 +37,7 @@ 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) => { });
     };
@@ -48,13 +46,13 @@ class MelCloudAtw extends EventEmitter {
         try {
             //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) {
                 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;
@@ -150,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;
@@ -161,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;
@@ -171,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;
@@ -371,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,
@@ -402,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);
+            this.emit('deviceState', deviceData);
 
             return true;
         } catch (error) {
-            await this.impulseGenerator.stop();
             throw new Error(`Check state error: ${error.message || error}.`);
         };
     };
@@ -437,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);
+            await this.axiosInstancePost(CONSTANTS.ApiUrls.SetAtw, payload);
+            this.emit('deviceState', deviceData);
             return true;
         } catch (error) {
             throw new Error(error.message ?? error);

package/src/melclouderv.js

@@ -15,8 +15,7 @@ class MelCloudErv extends EventEmitter {
         this.debugLog = config.debugLog;
 
         //set default values
-        this.deviceData = {};
-        this.displayDeviceInfo = true;
+        this.deviceState = {};
 
         this.axiosInstancePost = axios.create({
             method: 'POST',
@@ -38,8 +37,7 @@ class MelCloudErv 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) => { });
     };
@@ -48,13 +46,13 @@ class MelCloudErv extends EventEmitter {
         try {
             //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) {
                 this.emit('warn', `Device data not found.`);
                 return;
             }
+            const debug = this.debugLog ? this.emit('debug', `Device Data: ${JSON.stringify(deviceData, null, 2)}`) : false;
 
             //deviceData
             const deviceId = deviceData.DeviceID;
@@ -298,14 +296,7 @@ class MelCloudErv 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) : false;
-            this.displayDeviceInfo = false;
-
-            //device state
             const deviceState = {
-                DeviceId: deviceId,
-                EffectiveFlags: effectiveFlags,
                 RoomTemperature: roomTemperature,
                 SupplyTemperature: supplyTemperature,
                 OutdoorTemperature: outdoorTemperature,
@@ -314,32 +305,30 @@ class MelCloudErv extends EventEmitter {
                 SetFanSpeed: setFanSpeed,
                 OperationMode: operationMode,
                 VentilationMode: ventilationMode,
-                DefaultCoolingSetTemperature: defaultCoolingSetTemperature,
-                DefaultHeatingSetTemperature: defaultHeatingSetTemperature,
                 HideRoomTemperature: hideRoomTemperature,
                 HideSupplyTemperature: hideSupplyTemperature,
                 HideOutdoorTemperature: hideOutdoorTemperature,
-                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);
 
             //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);
+            this.emit('deviceState', deviceData);
 
             return true;
         } catch (error) {
-            await this.impulseGenerator.stop();
             throw new Error(`Check state error: ${error.message || error}.`);
         };
     };
@@ -354,21 +343,40 @@ class MelCloudErv extends EventEmitter {
         }
     }
 
-    async send(deviceState) {
+    async send(deviceData) {
         try {
             //prevent to set out of range temp
-            const minTemp = this.deviceData.Device.MinTempHeat ?? 10;
-            const maxTemp = this.deviceData.Device.MaxTempHeat ?? 31;
-            deviceState.SetTemperature = deviceState.SetTemperature < minTemp ? minTemp : deviceState.SetTemperature;
-            deviceState.SetTemperature = deviceState.SetTemperature > maxTemp ? maxTemp : deviceState.SetTemperature;
+            const minTemp = deviceData.Device.MinTempHeat ?? 10;
+            const maxTemp = deviceData.Device.MaxTempHeat ?? 31;
+            deviceData.Device.SetTemperature = deviceData.Device.SetTemperature < minTemp ? minTemp : deviceData.Device.SetTemperature;
+            deviceData.Device.SetTemperature = deviceData.Device.SetTemperature > maxTemp ? maxTemp : deviceData.Device.SetTemperature;
 
-            deviceState.HasPendingCommand = true;
-            const options = {
-                data: deviceState
-            };
+            //device state
+            const payload = {
+                data: {
+                    DeviceID: deviceData.Device.DeviceID,
+                    EffectiveFlags: deviceData.Device.EffectiveFlags,
+                    RoomTemperature: deviceData.Device.RoomTemperature,
+                    SupplyTemperature: deviceData.Device.SupplyTemperature,
+                    OutdoorTemperature: deviceData.Device.OutdoorTemperature,
+                    NightPurgeMode: deviceData.Device.NightPurgeMode,
+                    SetTemperature: deviceData.Device.SetTemperature,
+                    SetFanSpeed: deviceData.Device.SetFanSpeed,
+                    OperationMode: deviceData.Device.OperationMode,
+                    VentilationMode: deviceData.Device.VentilationMode,
+                    DefaultCoolingSetTemperature: deviceData.Device.DefaultCoolingSetTemperature ?? 23,
+                    DefaultHeatingSetTemperature: deviceData.Device.DefaultHeatingSetTemperature ?? 21,
+                    HideRoomTemperature: deviceData.Device.HideRoomTemperature,
+                    HideSupplyTemperature: deviceData.Device.HideSupplyTemperature,
+                    HideOutdoorTemperature: deviceData.Device.HideOutdoorTemperature,
+                    Power: deviceData.Device.Power,
+                    Offline: deviceData.Device.Offline,
+                    HasPendingCommand: true
+                }
+            }
 
-            await this.axiosInstancePost(CONSTANTS.ApiUrls.SetErv, options);
-            this.emit('deviceState', this.deviceData, deviceState);
+            await this.axiosInstancePost(CONSTANTS.ApiUrls.SetErv, payload);
+            this.emit('deviceState', deviceData);
             return true;
         } catch (error) {
             throw new Error(error.message ?? error);