homebridge-melcloud-control 3.1.10 → 3.1.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (12) hide show
  1. package/CHANGELOG.md +7 -2
  2. package/README.md +8 -8
  3. package/homebridge-ui/server.js +1 -3
  4. package/index.js +4 -3
  5. package/package.json +2 -2
  6. package/src/deviceata.js +353 -358
  7. package/src/deviceatw.js +349 -345
  8. package/src/deviceerv.js +205 -208
  9. package/src/melcloud.js +25 -25
  10. package/src/melcloudata.js +71 -80
  11. package/src/melcloudatw.js +67 -67
  12. package/src/melclouderv.js +45 -56
package/src/deviceatw.js CHANGED
@@ -7,7 +7,7 @@ const CONSTANTS = require('./constants.json');
7
7
  let Accessory, Characteristic, Service, Categories, AccessoryUUID;
8
8
 
9
9
  class DeviceAtw extends EventEmitter {
10
- constructor(api, account, device, melCloud, accountInfo, contextKey, accountName, deviceId, deviceName, deviceTypeText, accountFile, devicesFile, refreshInterval) {
10
+ constructor(api, account, device, melCloud, accountInfo, contextKey, accountName, deviceId, deviceName, deviceTypeText, devicesFile, refreshInterval, useFahrenheit) {
11
11
  super();
12
12
 
13
13
  Accessory = api.platformAccessory;
@@ -38,10 +38,11 @@ class DeviceAtw extends EventEmitter {
38
38
  this.deviceId = deviceId;
39
39
  this.deviceName = deviceName;
40
40
  this.deviceTypeText = deviceTypeText;
41
- this.accountFile = accountFile;
42
41
  this.devicesFile = devicesFile;
43
42
  this.refreshInterval = refreshInterval;
43
+ this.useFahrenheit = useFahrenheit;
44
44
  this.startPrepareAccessory = true;
45
+ this.displayDeviceInfo = true;
45
46
 
46
47
  //external integrations
47
48
  this.restFul = account.restFul ?? {};
@@ -76,10 +77,10 @@ class DeviceAtw extends EventEmitter {
76
77
  this.buttonsConfigured = [];
77
78
  for (const button of this.buttons) {
78
79
  const buttonName = button.name ?? false;
79
- const buttonMode = button.mode ?? false;
80
+ const buttonMode = button.mode ?? -1;
80
81
  const buttonDisplayType = button.displayType ?? 0;
81
82
  const buttonNamePrefix = button.namePrefix ?? false;
82
- if (buttonName && buttonMode && buttonDisplayType > 0) {
83
+ if (buttonName && buttonMode >= 0 && buttonDisplayType > 0) {
83
84
  const buttonServiceType = ['', Service.Outlet, Service.Switch, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor][buttonDisplayType];
84
85
  const buttonCharacteristicType = ['', Characteristic.On, Characteristic.On, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState][buttonDisplayType];
85
86
  button.namePrefix = buttonNamePrefix;
@@ -102,13 +103,12 @@ class DeviceAtw extends EventEmitter {
102
103
  //melcloud device
103
104
  this.melCloudAtw = new MelCloudAtw({
104
105
  contextKey: this.contextKey,
105
- accountFile: this.accountFile,
106
106
  devicesFile: this.devicesFile,
107
107
  deviceId: this.deviceId,
108
108
  debugLog: this.enableDebugMode
109
109
  });
110
110
 
111
- this.melCloudAtw.on('externalIntegrations', (deviceData, deviceState) => {
111
+ this.melCloudAtw.on('externalIntegrations', (deviceData) => {
112
112
  try {
113
113
  //RESTFul server
114
114
  const restFulEnabled = this.restFul.enable || false;
@@ -125,7 +125,7 @@ class DeviceAtw extends EventEmitter {
125
125
  })
126
126
  .on('set', async (key, value) => {
127
127
  try {
128
- await this.setOverExternalIntegration('RESTFul', deviceState, key, value);
128
+ await this.setOverExternalIntegration('RESTFul', deviceData, key, value);
129
129
  } catch (error) {
130
130
  this.emit('warn', `RESTFul set error: ${error}.`);
131
131
  };
@@ -138,7 +138,7 @@ class DeviceAtw extends EventEmitter {
138
138
  });
139
139
  }
140
140
  const restFul0 = this.restFulConnected ? this.restFul1.update('info', deviceData) : false;
141
- const restFul1 = this.restFulConnected ? this.restFul1.update('state', deviceState) : false;
141
+ const restFul1 = this.restFulConnected ? this.restFul1.update('state', deviceData.Device) : false;
142
142
  }
143
143
 
144
144
  //MQTT client
@@ -164,7 +164,7 @@ class DeviceAtw extends EventEmitter {
164
164
  })
165
165
  .on('set', async (key, value) => {
166
166
  try {
167
- await this.setOverExternalIntegration('MQTT', deviceState, key, value);
167
+ await this.setOverExternalIntegration('MQTT', deviceData, key, value);
168
168
  } catch (error) {
169
169
  this.emit('warn', `MQTT set error: ${error}.`);
170
170
  };
@@ -177,13 +177,17 @@ class DeviceAtw extends EventEmitter {
177
177
  });
178
178
  }
179
179
  const mqtt0 = this.mqttConnected ? this.mqtt1.emit('publish', `Info`, deviceData) : false;
180
- const mqtt1 = this.mqttConnected ? this.mqtt1.emit('publish', `State`, deviceState) : false;
180
+ const mqtt1 = this.mqttConnected ? this.mqtt1.emit('publish', `State`, deviceData.Device) : false;
181
181
  }
182
182
  } catch (error) {
183
183
  this.emit('warn', `External integration start error: ${error.message || error}.`);
184
184
  };
185
185
  })
186
186
  .on('deviceInfo', (manufacturer, modelIndoor, modelOutdoor, serialNumber, firmwareAppVersion, hasHotWaterTank, hasZone2) => {
187
+ if (!this.displayDeviceInfo) {
188
+ return;
189
+ }
190
+
187
191
  if (!this.disableLogDeviceInfo) {
188
192
  this.emit('devInfo', `---- ${this.deviceTypeText}: ${this.deviceName} ----`);
189
193
  this.emit('devInfo', `Account: ${this.accountName}`);
@@ -203,8 +207,9 @@ class DeviceAtw extends EventEmitter {
203
207
  this.model = modelIndoor ? modelIndoor : modelOutdoor ? modelOutdoor : `${this.deviceTypeText} ${this.deviceId}`;
204
208
  this.serialNumber = serialNumber;
205
209
  this.firmwareRevision = firmwareAppVersion;
210
+ this.displayDeviceInfo = false;
206
211
  })
207
- .on('deviceState', async (deviceData, deviceState, useFahrenheit) => {
212
+ .on('deviceState', async (deviceData) => {
208
213
  //device info
209
214
  const displayMode = this.displayMode;
210
215
  const heatPumpName = 'Heat Pump';
@@ -217,7 +222,7 @@ class DeviceAtw extends EventEmitter {
217
222
  const canCool = deviceData.Device.CanCool ?? false;
218
223
  const heatCoolModes = canHeat && canCool ? 0 : canHeat ? 1 : canCool ? 2 : 3;
219
224
  const temperatureIncrement = deviceData.Device.TemperatureIncrement ?? 1;
220
- const temperatureUnit = CONSTANTS.TemperatureDisplayUnits[useFahrenheit];
225
+ const temperatureUnit = CONSTANTS.TemperatureDisplayUnits[this.useFahrenheit];
221
226
  const minSetTemperature = deviceData.Device.MinSetTemperature ?? 10;
222
227
  const maxSetTemperature = deviceData.Device.MaxSetTemperature ?? 30;
223
228
  const maxTankTemperature = deviceData.Device.MaxTankTemperature ?? 70;
@@ -246,40 +251,40 @@ class DeviceAtw extends EventEmitter {
246
251
  this.caseZone2 = caseZone2;
247
252
 
248
253
  //device state
249
- const setTemperatureZone1 = deviceState.SetTemperatureZone1;
250
- const setTemperatureZone2 = deviceState.SetTemperatureZone2;
251
- const roomTemperatureZone1 = deviceState.RoomTemperatureZone1;
252
- const roomTemperatureZone2 = deviceState.RoomTemperatureZone2;
253
- const operationMode = deviceState.OperationMode;
254
- const operationModeZone1 = deviceState.OperationModeZone1;
255
- const operationModeZone2 = deviceState.OperationModeZone2;
256
- const setHeatFlowTemperatureZone1 = deviceState.SetHeatFlowTemperatureZone1;
257
- const setHeatFlowTemperatureZone2 = deviceState.SetHeatFlowTemperatureZone2;
258
- const setCoolFlowTemperatureZone1 = deviceState.SetCoolFlowTemperatureZone1;
259
- const setCoolFlowTemperatureZone2 = deviceState.SetCoolFlowTemperatureZone2;
260
- const tankWaterTemperature = deviceState.TankWaterTemperature;
261
- const setTankWaterTemperature = deviceState.SetTankWaterTemperature;
262
- const forcedHotWaterMode = deviceState.ForcedHotWaterMode ? 1 : 0;
263
- const unitStatus = deviceState.UnitStatus;
264
- const outdoorTemperature = deviceState.OutdoorTemperature;
265
- const ecoHotWater = deviceState.EcoHotWater;
266
- const holidayMode = deviceState.HolidayMode;
267
- const prohibitZone1 = deviceState.ProhibitZone1;
268
- const prohibitZone2 = deviceState.ProhibitZone2;
269
- const prohibitHotWater = deviceState.ProhibitHotWater;
270
- const idleZone1 = deviceState.IdleZone1;
271
- const idleZone2 = deviceState.IdleZone2;
272
- const power = deviceState.Power;
273
- const offline = deviceState.Offline;
254
+ const power = deviceData.Device.Power ?? false;
255
+ const offline = deviceData.Device.Offline ?? false;
256
+ const setTemperatureZone1 = deviceData.Device.SetTemperatureZone1;
257
+ const setTemperatureZone2 = deviceData.Device.SetTemperatureZone2;
258
+ const roomTemperatureZone1 = deviceData.Device.RoomTemperatureZone1;
259
+ const roomTemperatureZone2 = deviceData.Device.RoomTemperatureZone2;
260
+ const operationMode = deviceData.Device.OperationMode;
261
+ const operationModeZone1 = deviceData.Device.OperationModeZone1;
262
+ const operationModeZone2 = deviceData.Device.OperationModeZone2;
263
+ const setHeatFlowTemperatureZone1 = deviceData.Device.SetHeatFlowTemperatureZone1;
264
+ const setHeatFlowTemperatureZone2 = deviceData.Device.SetHeatFlowTemperatureZone2;
265
+ const setCoolFlowTemperatureZone1 = deviceData.Device.SetCoolFlowTemperatureZone1;
266
+ const setCoolFlowTemperatureZone2 = deviceData.Device.SetCoolFlowTemperatureZone2;
267
+ const tankWaterTemperature = deviceData.Device.TankWaterTemperature;
268
+ const setTankWaterTemperature = deviceData.Device.SetTankWaterTemperature;
269
+ const forcedHotWaterMode = deviceData.Device.ForcedHotWaterMode ? 1 : 0;
270
+ const unitStatus = deviceData.Device.UnitStatus ?? 0;
271
+ const outdoorTemperature = deviceData.Device.OutdoorTemperature;
272
+ const ecoHotWater = deviceData.Device.EcoHotWater ?? false;
273
+ const holidayMode = deviceData.Device.HolidayMode ?? false;
274
+ const prohibitZone1 = deviceData.Device.ProhibitZone1 ?? false;
275
+ const prohibitZone2 = deviceData.Device.ProhibitZone2 ?? false;
276
+ const prohibitHotWater = deviceData.Device.ProhibitHotWater ?? false;
277
+ const idleZone1 = deviceData.Device.IdleZone1 ?? false;
278
+ const idleZone2 = deviceData.Device.IdleZone2 ?? false;
274
279
 
275
280
  //accessory
276
281
  this.accessory.presetsOnServer = presetsOnServer;
277
- this.accessory.power = power;
278
- this.accessory.offline = offline;
282
+ this.accessory.power = power ? 1 : 0;
283
+ this.accessory.offline = offline ?? false;
279
284
  this.accessory.unitStatus = unitStatus;
280
285
  this.accessory.idleZone1 = idleZone1;
281
286
  this.accessory.idleZone2 = idleZone2;
282
- this.accessory.useFahrenheit = useFahrenheit;
287
+ this.accessory.useFahrenheit = this.useFahrenheit;
283
288
  this.accessory.temperatureUnit = temperatureUnit;
284
289
  this.accessory.temperatureIncrement = temperatureIncrement;
285
290
  this.accessory.hasHotWaterTank = hasHotWaterTank;
@@ -381,7 +386,7 @@ class DeviceAtw extends EventEmitter {
381
386
  .updateCharacteristic(Characteristic.TargetHeaterCoolerState, targetOperationMode)
382
387
  .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
383
388
  .updateCharacteristic(Characteristic.LockPhysicalControls, lockPhysicalControl)
384
- .updateCharacteristic(Characteristic.TemperatureDisplayUnits, useFahrenheit);
389
+ .updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
385
390
  const updateHT = heatCoolModes === 0 || heatCoolModes === 1 ? this.melCloudServices[i].updateCharacteristic(Characteristic.HeatingThresholdTemperature, setTemperature) : false;
386
391
  const updateCT = heatCoolModes === 0 || heatCoolModes === 2 ? this.melCloudServices[i].updateCharacteristic(Characteristic.CoolingThresholdTemperature, setTemperature) : false;
387
392
  }
@@ -452,9 +457,12 @@ class DeviceAtw extends EventEmitter {
452
457
  .updateCharacteristic(Characteristic.TargetHeatingCoolingState, targetOperationMode)
453
458
  .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
454
459
  .updateCharacteristic(Characteristic.TargetTemperature, setTemperature)
455
- .updateCharacteristic(Characteristic.TemperatureDisplayUnits, useFahrenheit);
460
+ .updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
456
461
  }
457
462
  break;
463
+ default:
464
+ this.emit('warn', `Unknown display mode: ${displayMode}`);
465
+ return;
458
466
  };
459
467
 
460
468
  //push value to arrays
@@ -595,8 +603,7 @@ class DeviceAtw extends EventEmitter {
595
603
  if (this.presetsConfigured.length > 0) {
596
604
  for (let i = 0; i < this.presetsConfigured.length; i++) {
597
605
  const preset = this.presetsConfigured[i];
598
- const index = presetsOnServer.findIndex(p => p.ID === preset.Id);
599
- const presetData = presetsOnServer[index];
606
+ const presetData = presetsOnServer.find(p => p.ID === preset.Id);
600
607
 
601
608
  preset.state = presetData ? (presetData.Power === power
602
609
  && presetData.EcoHotWater === ecoHotWater
@@ -714,7 +721,7 @@ class DeviceAtw extends EventEmitter {
714
721
  }
715
722
 
716
723
  try {
717
- const accessory = await this.prepareAccessory(this.accountInfo, deviceState, this.deviceId, this.deviceTypeText, this.deviceName, this.accountName);
724
+ const accessory = await this.prepareAccessory(this.accountInfo, deviceData, this.deviceId, this.deviceTypeText, this.deviceName, this.accountName);
718
725
  this.emit('publishAccessory', accessory);
719
726
  this.startPrepareAccessory = false;
720
727
  } catch (error) {
@@ -732,8 +739,6 @@ class DeviceAtw extends EventEmitter {
732
739
  })
733
740
  .on('error', async (error) => {
734
741
  this.emit('error', error);
735
- await new Promise(resolve => setTimeout(resolve, 15000));
736
- await this.melCloudAtw.impulseGenerator.start([{ name: 'checkState', sampling: this.refreshInterval }]);
737
742
  });
738
743
 
739
744
  //check state
@@ -748,94 +753,94 @@ class DeviceAtw extends EventEmitter {
748
753
  };
749
754
  };
750
755
 
751
- async setOverExternalIntegration(integration, deviceState, key, value) {
756
+ async setOverExternalIntegration(integration, deviceData, key, value) {
752
757
  try {
753
758
  let set = false
754
759
  switch (key) {
755
760
  case 'Power':
756
- deviceState[key] = value;
757
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
758
- set = await this.melCloudAtw.send(deviceState);
761
+ deviceData.Device[key] = value;
762
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
763
+ set = await this.melCloudAtw.send(deviceData);
759
764
  break;
760
765
  case 'OperationMode':
761
- deviceState[key] = value;
762
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
763
- set = await this.melCloudAtw.send(deviceState);
766
+ deviceData.Device[key] = value;
767
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
768
+ set = await this.melCloudAtw.send(deviceData);
764
769
  break;
765
770
  case 'OperationModeZone1':
766
- deviceState[key] = value;
767
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
768
- set = await this.melCloudAtw.send(deviceState);
771
+ deviceData.Device[key] = value;
772
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
773
+ set = await this.melCloudAtw.send(deviceData);
769
774
  break;
770
775
  case 'OperationModeZone2':
771
- deviceState[key] = value;
772
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
773
- set = await this.melCloudAtw.send(deviceState);
776
+ deviceData.Device[key] = value;
777
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
778
+ set = await this.melCloudAtw.send(deviceData);
774
779
  break;
775
780
  case 'SetTemperatureZone1':
776
- deviceState[key] = value;
777
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
778
- set = await this.melCloudAtw.send(deviceState);
781
+ deviceData.Device[key] = value;
782
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
783
+ set = await this.melCloudAtw.send(deviceData);
779
784
  break;
780
785
  case 'SetTemperatureZone2':
781
- deviceState[key] = value;
782
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
783
- set = await this.melCloudAtw.send(deviceState);
786
+ deviceData.Device[key] = value;
787
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
788
+ set = await this.melCloudAtw.send(deviceData);
784
789
  break;
785
790
  case 'SetHeatFlowTemperatureZone1':
786
- deviceState[key] = value;
787
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
788
- set = await this.melCloudAtw.send(deviceState);
791
+ deviceData.Device[key] = value;
792
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
793
+ set = await this.melCloudAtw.send(deviceData);
789
794
  break;
790
795
  case 'SetHeatFlowTemperatureZone2':
791
- deviceState[key] = value;
792
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
793
- set = await this.melCloudAtw.send(deviceState);
796
+ deviceData.Device[key] = value;
797
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
798
+ set = await this.melCloudAtw.send(deviceData);
794
799
  break;
795
800
  case 'SetCoolFlowTemperatureZone1':
796
- deviceState[key] = value;
797
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
798
- set = await this.melCloudAtw.send(deviceState);
801
+ deviceData.Device[key] = value;
802
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
803
+ set = await this.melCloudAtw.send(deviceData);
799
804
  break;
800
805
  case 'SetCoolFlowTemperatureZone2':
801
- deviceState[key] = value;
802
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
803
- set = await this.melCloudAtw.send(deviceState);
806
+ deviceData.Device[key] = value;
807
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
808
+ set = await this.melCloudAtw.send(deviceData);
804
809
  break;
805
810
  case 'SetTankWaterTemperature':
806
- deviceState[key] = value;
807
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTankWaterTemperature;
808
- set = await this.melCloudAtw.send(deviceState);
811
+ deviceData.Device[key] = value;
812
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTankWaterTemperature;
813
+ set = await this.melCloudAtw.send(deviceData);
809
814
  break;
810
815
  case 'ForcedHotWaterMode':
811
- deviceState[key] = value;
812
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
813
- set = await this.melCloudAtw.send(deviceState);
816
+ deviceData.Device[key] = value;
817
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
818
+ set = await this.melCloudAtw.send(deviceData);
814
819
  break;
815
820
  case 'EcoHotWater':
816
- deviceState[key] = value;
817
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.EcoHotWater;
818
- set = await this.melCloudAtw.send(deviceState);
821
+ deviceData.Device[key] = value;
822
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.EcoHotWater;
823
+ set = await this.melCloudAtw.send(deviceData);
819
824
  break;
820
825
  case 'HolidayMode':
821
- deviceState[key] = value;
822
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.HolidayMode;
823
- set = await this.melCloudAtw.send(deviceState);
826
+ deviceData.Device[key] = value;
827
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.HolidayMode;
828
+ set = await this.melCloudAtw.send(deviceData);
824
829
  break;
825
830
  case 'ProhibitZone1':
826
- deviceState[key] = value;
827
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ProhibitZone1;
828
- set = await this.melCloudAtw.send(deviceState);
831
+ deviceData.Device[key] = value;
832
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ProhibitZone1;
833
+ set = await this.melCloudAtw.send(deviceData);
829
834
  break;
830
835
  case 'ProhibitZone2':
831
- deviceState[key] = value;
832
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ProhibitZone2;
833
- set = await this.melCloudAtw.send(deviceState);
836
+ deviceData.Device[key] = value;
837
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ProhibitZone2;
838
+ set = await this.melCloudAtw.send(deviceData);
834
839
  break;
835
840
  case 'ProhibitHotWater':
836
- deviceState[key] = value;
837
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ProhibitHotWater;
838
- set = await this.melCloudAtw.send(deviceState);
841
+ deviceData.Device[key] = value;
842
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ProhibitHotWater;
843
+ set = await this.melCloudAtw.send(deviceData);
839
844
  break;
840
845
  default:
841
846
  this.emit('warn', `${integration}, received key: ${key}, value: ${value}`);
@@ -847,7 +852,7 @@ class DeviceAtw extends EventEmitter {
847
852
  };
848
853
  }
849
854
  //prepare accessory
850
- async prepareAccessory(accountInfo, deviceState, deviceId, deviceTypeText, deviceName, accountName) {
855
+ async prepareAccessory(accountInfo, deviceData, deviceId, deviceTypeText, deviceName, accountName) {
851
856
  try {
852
857
  //accessory
853
858
  const debug = this.enableDebugMode ? this.emit('debug', `Prepare accessory`) : false;
@@ -902,9 +907,9 @@ class DeviceAtw extends EventEmitter {
902
907
  try {
903
908
  switch (i) {
904
909
  case 0: //Heat Pump
905
- deviceState.Power = [false, true][state];
906
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
907
- await this.melCloudAtw.send(deviceState);
910
+ deviceData.Device.Power = [false, true][state];
911
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
912
+ await this.melCloudAtw.send(deviceData);
908
913
  const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set power: ${state ? 'ON' : 'OFF'}`);
909
914
  break;
910
915
  };
@@ -934,76 +939,76 @@ class DeviceAtw extends EventEmitter {
934
939
  case 0: //Heat Pump - ON, HEAT, COOL
935
940
  switch (value) {
936
941
  case 0: //AUTO
937
- deviceState.Power = true;
938
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
942
+ deviceData.Device.Power = true;
943
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
939
944
  break;
940
945
  case 1: //HEAT
941
- deviceState.Power = true;
942
- deviceState.UnitStatus = 0;
943
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
946
+ deviceData.Device.Power = true;
947
+ deviceData.Device.UnitStatus = 0;
948
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
944
949
  break;
945
950
  case 2: //COOL
946
- deviceState.Power = true;
947
- deviceState.UnitStatus = 1;
948
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
951
+ deviceData.Device.Power = true;
952
+ deviceData.Device.UnitStatus = 1;
953
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
949
954
  break;
950
955
  };
951
- operationModeText = !this.accessory.power ? CONSTANTS.HeatPump.System[0] : CONSTANTS.HeatPump.System[deviceState.UnitStatus];
956
+ operationModeText = [CONSTANTS.HeatPump.System[0], CONSTANTS.HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
952
957
  break;
953
958
  case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
954
959
  switch (value) {
955
960
  case 0: //AUTO - HEAT CURVE
956
- deviceState.OperationModeZone1 = 2;
957
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
961
+ deviceData.Device.OperationModeZone1 = 2;
962
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
958
963
  break;
959
964
  case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
960
- deviceState.OperationModeZone1 = [0, 3][this.unitStatus];
961
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
965
+ deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
966
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
962
967
  break;
963
968
  case 2: //COOL - HEAT FLOW / COOL FLOW
964
- deviceState.OperationModeZone1 = [1, 4][this.unitStatus];
965
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
969
+ deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
970
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
966
971
  break;
967
972
  };
968
- operationModeText = CONSTANTS.HeatPump.ZoneOperation[deviceState.OperationModeZone1];
973
+ operationModeText = CONSTANTS.HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
969
974
  break;
970
975
  case caseHotWater: //Hot Water - AUTO, HEAT NOW
971
976
  switch (value) {
972
977
  case 0: //AUTO
973
- deviceState.ForcedHotWaterMode = false;
974
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
978
+ deviceData.Device.ForcedHotWaterMode = false;
979
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
975
980
  break;
976
981
  case 1: //HEAT
977
- deviceState.ForcedHotWaterMode = true;
978
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
982
+ deviceData.Device.ForcedHotWaterMode = true;
983
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
979
984
  break;
980
985
  case 2: //COOL
981
- deviceState.ForcedHotWaterMode = false;
982
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
986
+ deviceData.Device.ForcedHotWaterMode = false;
987
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
983
988
  break
984
989
  };
985
- operationModeText = deviceState.OperationMode === 1 ? CONSTANTS.HeatPump.ForceDhw[1] : CONSTANTS.HeatPump.ForceDhw[deviceState.ForcedHotWaterMode ? 1 : 0];
990
+ operationModeText = deviceData.Device.OperationMode === 1 ? CONSTANTS.HeatPump.ForceDhw[1] : CONSTANTS.HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
986
991
  break;
987
992
  case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
988
993
  switch (value) {
989
994
  case 0: //AUTO
990
- deviceState.OperationModeZone2 = 2;
991
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
995
+ deviceData.Device.OperationModeZone2 = 2;
996
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
992
997
  break;
993
998
  case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
994
- deviceState.OperationModeZone2 = [0, 3][this.unitStatus];
995
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
999
+ deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
1000
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
996
1001
  break;
997
1002
  case 2: //COOL - HEAT FLOW / COOL FLOW
998
- deviceState.OperationModeZone2 = [1, 4][this.unitStatus];
999
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1003
+ deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
1004
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1000
1005
  break;
1001
1006
  };
1002
- operationModeText = CONSTANTS.HeatPump.ZoneOperation[deviceState.OperationModeZone2];
1007
+ operationModeText = CONSTANTS.HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
1003
1008
  break;
1004
1009
  };
1005
1010
 
1006
- await this.melCloudAtw.send(deviceState);
1011
+ await this.melCloudAtw.send(deviceData);
1007
1012
  const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set operation mode: ${operationModeText}`);
1008
1013
  } catch (error) {
1009
1014
  this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
@@ -1035,24 +1040,24 @@ class DeviceAtw extends EventEmitter {
1035
1040
  try {
1036
1041
  switch (i) {
1037
1042
  case 0: //Heat Pump
1038
- //deviceState.SetTemperatureZone1 = value;
1039
- //deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1043
+ //deviceData.Device.SetTemperatureZone1 = value;
1044
+ //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1040
1045
  break;
1041
1046
  case 1: //Zone 1
1042
- deviceState.SetTemperatureZone1 = value;
1043
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1047
+ deviceData.Device.SetTemperatureZone1 = value;
1048
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1044
1049
  break;
1045
1050
  case caseHotWater: //Hot Water
1046
- deviceState.SetTankWaterTemperature = value;
1047
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTankWaterTemperature;
1051
+ deviceData.Device.SetTankWaterTemperature = value;
1052
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTankWaterTemperature;
1048
1053
  break;
1049
1054
  case caseZone2: //Zone 2
1050
- deviceState.SetTemperatureZone2 = value;
1051
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
1055
+ deviceData.Device.SetTemperatureZone2 = value;
1056
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
1052
1057
  break;
1053
1058
  };
1054
1059
 
1055
- const set = i > 0 ? await this.melCloudAtw.send(deviceState) : false;
1060
+ const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
1056
1061
  const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
1057
1062
  } catch (error) {
1058
1063
  this.emit('warn', `${zoneName}, Set heating threshold temperature error: ${error}`);
@@ -1075,24 +1080,24 @@ class DeviceAtw extends EventEmitter {
1075
1080
  try {
1076
1081
  switch (i) {
1077
1082
  case 0: //Heat Pump
1078
- //deviceState.SetTemperatureZone1 = value;
1079
- //deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1083
+ //deviceData.Device.SetTemperatureZone1 = value;
1084
+ //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1080
1085
  break;
1081
1086
  case 1: //Zone 1
1082
- deviceState.SetTemperatureZone1 = value;
1083
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1087
+ deviceData.Device.SetTemperatureZone1 = value;
1088
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1084
1089
  break;
1085
1090
  case caseHotWater: //Hot Water
1086
- deviceState.SetTankWaterTemperature = value;
1087
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTankWaterTemperature;
1091
+ deviceData.Device.SetTankWaterTemperature = value;
1092
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTankWaterTemperature;
1088
1093
  break;
1089
1094
  case caseZone2: //Zone 2
1090
- deviceState.SetTemperatureZone2 = value;
1091
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
1095
+ deviceData.Device.SetTemperatureZone2 = value;
1096
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
1092
1097
  break;
1093
1098
  };
1094
1099
 
1095
- const set = i > 0 ? await this.melCloudAtw.send(deviceState) : false;
1100
+ const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
1096
1101
  const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
1097
1102
  } catch (error) {
1098
1103
  this.emit('warn', `${zoneName}, Set cooling threshold temperature error: ${error}`);
@@ -1109,26 +1114,26 @@ class DeviceAtw extends EventEmitter {
1109
1114
  value = value ? true : false;
1110
1115
  switch (i) {
1111
1116
  case 0: //Heat Pump
1112
- deviceState.ProhibitZone1 = value;
1113
- deviceState.ProhibitHotWater = value;
1114
- deviceState.ProhibitZone2 = value;
1117
+ deviceData.Device.ProhibitZone1 = value;
1118
+ deviceData.Device.ProhibitHotWater = value;
1119
+ deviceData.Device.ProhibitZone2 = value;
1115
1120
  CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone1 + CONSTANTS.HeatPump.EffectiveFlags.ProhibitHotWater + CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone2;
1116
1121
  break;
1117
1122
  case 1: //Zone 1
1118
- deviceState.ProhibitZone1 = value;
1123
+ deviceData.Device.ProhibitZone1 = value;
1119
1124
  CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone1;
1120
1125
  break;
1121
1126
  case caseHotWater: //Hot Water
1122
- deviceState.ProhibitHotWater = value;
1127
+ deviceData.Device.ProhibitHotWater = value;
1123
1128
  CONSTANTS.HeatPump.EffectiveFlags.ProhibitHotWater;
1124
1129
  break;
1125
1130
  case caseZone2: //Zone 2
1126
- deviceState.ProhibitZone2 = value;
1131
+ deviceData.Device.ProhibitZone2 = value;
1127
1132
  CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone2;
1128
1133
  break;
1129
1134
  };
1130
1135
 
1131
- await this.melCloudAtw.send(deviceState);
1136
+ await this.melCloudAtw.send(deviceData);
1132
1137
  const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set lock physical controls: ${value ? 'LOCK' : 'UNLOCK'}`);
1133
1138
  } catch (error) {
1134
1139
  this.emit('warn', `${zoneName}, Set lock physical controls error: ${error}`);
@@ -1176,92 +1181,92 @@ class DeviceAtw extends EventEmitter {
1176
1181
  case 0: //Heat Pump - HEAT, COOL
1177
1182
  switch (value) {
1178
1183
  case 0: //OFF
1179
- deviceState.Power = false;
1180
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
1184
+ deviceData.Device.Power = false;
1185
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
1181
1186
  break;
1182
1187
  case 1: //HEAT
1183
- deviceState.Power = true;
1184
- deviceState.UnitStatus = 0;
1185
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
1188
+ deviceData.Device.Power = true;
1189
+ deviceData.Device.UnitStatus = 0;
1190
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
1186
1191
  break;
1187
1192
  case 2: //COOL
1188
- deviceState.Power = true;
1189
- deviceState.UnitStatus = 1;
1190
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
1193
+ deviceData.Device.Power = true;
1194
+ deviceData.Device.UnitStatus = 1;
1195
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
1191
1196
  break;
1192
1197
  case 3: //AUTO
1193
- deviceState.Power = true;
1194
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
1198
+ deviceData.Device.Power = true;
1199
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
1195
1200
  break;
1196
1201
  };
1197
- operationModeText = !this.accessory.power ? CONSTANTS.HeatPump.System[0] : CONSTANTS.HeatPump.System[deviceState.UnitStatus];
1202
+ operationModeText = [CONSTANTS.HeatPump.System[0], CONSTANTS.HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
1198
1203
  break;
1199
1204
  case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1200
1205
  switch (value) {
1201
1206
  case 0: //OFF - HEAT CURVE
1202
- deviceState.OperationModeZone1 = 2;
1203
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1207
+ deviceData.Device.OperationModeZone1 = 2;
1208
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1204
1209
  break;
1205
1210
  case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
1206
- deviceState.OperationModeZone1 = [0, 3][this.unitStatus];
1207
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1211
+ deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
1212
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1208
1213
  break;
1209
1214
  case 2: //COOL - HEAT FLOW / COOL FLOW
1210
- deviceState.OperationModeZone1 = [1, 4][this.unitStatus];
1211
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1215
+ deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
1216
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1212
1217
  break;
1213
1218
  case 3: //AUTO - HEAT CURVE
1214
- deviceState.OperationModeZone1 = 2;
1215
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1219
+ deviceData.Device.OperationModeZone1 = 2;
1220
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1216
1221
  break;
1217
1222
  };
1218
- operationModeText = CONSTANTS.HeatPump.ZoneOperation[deviceState.OperationModeZone1];
1223
+ operationModeText = CONSTANTS.HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
1219
1224
  break;
1220
1225
  case caseHotWater: //Hot Water - AUTO, HEAT NOW
1221
1226
  switch (value) {
1222
1227
  case 0: //OFF
1223
- deviceState.ForcedHotWaterMode = false;
1224
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1228
+ deviceData.Device.ForcedHotWaterMode = false;
1229
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1225
1230
  break;
1226
1231
  case 1: //HEAT
1227
- deviceState.ForcedHotWaterMode = true;
1228
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1232
+ deviceData.Device.ForcedHotWaterMode = true;
1233
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1229
1234
  break;
1230
1235
  case 2: //COOL
1231
- deviceState.ForcedHotWaterMode = false;
1232
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1236
+ deviceData.Device.ForcedHotWaterMode = false;
1237
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1233
1238
  break;
1234
1239
  case 3: //AUTO
1235
- deviceState.ForcedHotWaterMode = false;
1236
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1240
+ deviceData.Device.ForcedHotWaterMode = false;
1241
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1237
1242
  break;
1238
1243
  };
1239
- operationModeText = deviceState.OperationMode === 1 ? CONSTANTS.HeatPump.ForceDhw[1] : CONSTANTS.HeatPump.ForceDhw[deviceState.ForcedHotWaterMode ? 1 : 0];
1244
+ operationModeText = deviceData.Device.OperationMode === 1 ? CONSTANTS.HeatPump.ForceDhw[1] : CONSTANTS.HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
1240
1245
  break;
1241
1246
  case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1242
1247
  switch (value) {
1243
1248
  case 0: //OFF - HEAT CURVE
1244
- deviceState.OperationModeZone2 = 2;
1245
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1249
+ deviceData.Device.OperationModeZone2 = 2;
1250
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1246
1251
  break;
1247
1252
  case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
1248
- deviceState.OperationModeZone2 = [0, 3][this.unitStatus];
1249
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1253
+ deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
1254
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1250
1255
  break;
1251
1256
  case 2: //COOL - HEAT FLOW / COOL FLOW
1252
- deviceState.OperationModeZone2 = [1, 4][this.unitStatus];
1253
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1257
+ deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
1258
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1254
1259
  break;
1255
1260
  case 3: //AUTO - HEAT CURVE
1256
- deviceState.OperationModeZone2 = 2;
1257
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1261
+ deviceData.Device.OperationModeZone2 = 2;
1262
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1258
1263
  break;
1259
1264
  };
1260
- operationModeText = CONSTANTS.HeatPump.ZoneOperation[deviceState.OperationModeZone2];
1265
+ operationModeText = CONSTANTS.HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
1261
1266
  break;
1262
1267
  };
1263
1268
 
1264
- await this.melCloudAtw.send(deviceState);
1269
+ await this.melCloudAtw.send(deviceData);
1265
1270
  const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set operation mode: ${operationModeText}`);
1266
1271
  } catch (error) {
1267
1272
  this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
@@ -1291,24 +1296,24 @@ class DeviceAtw extends EventEmitter {
1291
1296
  try {
1292
1297
  switch (i) {
1293
1298
  case 0: //Heat Pump
1294
- //deviceState.SetTemperatureZone1 = value;
1295
- //deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1299
+ //deviceData.Device.SetTemperatureZone1 = value;
1300
+ //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1296
1301
  break;
1297
1302
  case 1: //Zone 1
1298
- deviceState.SetTemperatureZone1 = value;
1299
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1303
+ deviceData.Device.SetTemperatureZone1 = value;
1304
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
1300
1305
  break;
1301
1306
  case caseHotWater: //Hot Water
1302
- deviceState.SetTankWaterTemperature = value;
1303
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTankWaterTemperature;
1307
+ deviceData.Device.SetTankWaterTemperature = value;
1308
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTankWaterTemperature;
1304
1309
  break;
1305
1310
  case caseZone2: //Zone 2
1306
- deviceState.SetTemperatureZone2 = value;
1307
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
1311
+ deviceData.Device.SetTemperatureZone2 = value;
1312
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone2;
1308
1313
  break;
1309
1314
  };
1310
1315
 
1311
- const set = i > 0 ? await this.melCloudAtw.send(deviceState) : false;
1316
+ const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
1312
1317
  const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set temperature: ${value}${this.accessory.temperatureUnit}`);
1313
1318
  } catch (error) {
1314
1319
  this.emit('warn', `${zoneName}, Set temperature error: ${error}`);
@@ -1566,8 +1571,7 @@ class DeviceAtw extends EventEmitter {
1566
1571
 
1567
1572
  for (let i = 0; i < presetsConfiguredCount; i++) {
1568
1573
  const preset = presetsConfigured[i];
1569
- const index = presetsOnServer.findIndex(p => p.ID === preset.Id);
1570
- const presetData = presetsOnServer[index];
1574
+ const presetData = presetsOnServer.find(p => p.ID === preset.Id);
1571
1575
 
1572
1576
  //get preset name
1573
1577
  const presetName = preset.name;
@@ -1594,34 +1598,34 @@ class DeviceAtw extends EventEmitter {
1594
1598
  try {
1595
1599
  switch (state) {
1596
1600
  case true:
1597
- previousPresets[i] = deviceState;
1598
- deviceState.Power = presetData.Power;
1599
- deviceState.EcoHotWater = presetData.EcoHotWater;
1600
- deviceState.OperationModeZone1 = presetData.OperationModeZone1;
1601
- deviceState.OperationModeZone2 = presetData.OperationModeZone2;
1602
- deviceState.SetTankWaterTemperature = presetData.SetTankWaterTemperature;
1603
- deviceState.SetTemperatureZone1 = presetData.SetTemperatureZone1;
1604
- deviceState.SetTemperatureZone2 = presetData.SetTemperatureZone2;
1605
- deviceState.ForcedHotWaterMode = presetData.ForcedHotWaterMode;
1606
- deviceState.SetHeatFlowTemperatureZone1 = presetData.SetHeatFlowTemperatureZone1;
1607
- deviceState.SetHeatFlowTemperatureZone2 = presetData.SetHeatFlowTemperatureZone2;
1608
- deviceState.SetCoolFlowTemperatureZone1 = presetData.SetCoolFlowTemperatureZone1;
1609
- deviceState.SetCoolFlowTemperatureZone2 = presetData.SetCoolFlowTemperatureZone2;
1610
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
1601
+ previousPresets[i] = deviceData.Device;
1602
+ deviceData.Device.Power = presetData.Power;
1603
+ deviceData.Device.EcoHotWater = presetData.EcoHotWater;
1604
+ deviceData.Device.OperationModeZone1 = presetData.OperationModeZone1;
1605
+ deviceData.Device.OperationModeZone2 = presetData.OperationModeZone2;
1606
+ deviceData.Device.SetTankWaterTemperature = presetData.SetTankWaterTemperature;
1607
+ deviceData.Device.SetTemperatureZone1 = presetData.SetTemperatureZone1;
1608
+ deviceData.Device.SetTemperatureZone2 = presetData.SetTemperatureZone2;
1609
+ deviceData.Device.ForcedHotWaterMode = presetData.ForcedHotWaterMode;
1610
+ deviceData.Device.SetHeatFlowTemperatureZone1 = presetData.SetHeatFlowTemperatureZone1;
1611
+ deviceData.Device.SetHeatFlowTemperatureZone2 = presetData.SetHeatFlowTemperatureZone2;
1612
+ deviceData.Device.SetCoolFlowTemperatureZone1 = presetData.SetCoolFlowTemperatureZone1;
1613
+ deviceData.Device.SetCoolFlowTemperatureZone2 = presetData.SetCoolFlowTemperatureZone2;
1614
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
1611
1615
  break;
1612
1616
  case false:
1613
- deviceState = previousPresets[i];
1617
+ deviceData.Device = previousPresets[i];
1614
1618
  break;
1615
1619
  };
1616
1620
 
1617
- await this.melCloudAtw.send(deviceState);
1621
+ await this.melCloudAtw.send(deviceData);
1618
1622
  const info = this.disableLogInfo ? false : this.emit('message', `Set: ${presetName}`);
1619
1623
  } catch (error) {
1620
1624
  this.emit('warn', `Set preset error: ${error}`);
1621
1625
  };
1622
1626
  });
1623
1627
  };
1624
- previousPresets.push(deviceState);
1628
+ previousPresets.push(deviceData.Device);
1625
1629
  this.presetsServices.push(presetService);
1626
1630
  accessory.addService(presetService);
1627
1631
  };
@@ -1658,128 +1662,128 @@ class DeviceAtw extends EventEmitter {
1658
1662
  const state = button.state;
1659
1663
  return state;
1660
1664
  })
1661
- if (displayType > 2) {
1662
- buttonService.onSet(async (state) => {
1663
- try {
1664
- switch (mode) {
1665
- case 0: //POWER ON,OFF
1666
- deviceState.Power = state;
1667
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
1668
- break;
1669
- case 1: //HEAT PUMP HEAT
1670
- deviceState.Power = true;
1671
- deviceState.UnitStatus = 0;
1672
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
1673
- break;
1674
- case 2: //COOL
1675
- deviceState.Power = true;
1676
- deviceState.UnitStatus = 1;
1677
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
1678
- break;
1679
- case 3: //HOLIDAY
1680
- deviceState.HolidayMode = state;
1681
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.HolidayMode;
1682
- break;
1683
- case 10: //ALL ZONES PHYSICAL LOCK CONTROL
1684
- deviceState.ProhibitZone1 = state;
1685
- deviceState.ProhibitHotWater = state;
1686
- deviceState.ProhibitZone2 = state;
1687
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone1 + CONSTANTS.HeatPump.EffectiveFlags.ProhibitHotWater + CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone2;
1688
- break;
1689
- case 20: //ZONE 1 HEAT THERMOSTAT
1690
- deviceState.Power = true;
1691
- deviceState.OperationModeZone1 = 0;
1692
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1693
- break;
1694
- case 21: //HEAT FLOW
1695
- deviceState.Power = true;
1696
- deviceState.OperationModeZone1 = 1;
1697
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1698
- break;
1699
- case 22: //HEAT CURVE
1700
- deviceState.Power = true;
1701
- deviceState.OperationModeZone1 = 2;
1702
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1703
- break;
1704
- case 23: //COOL THERMOSTAT
1705
- deviceState.Power = true;
1706
- deviceState.OperationModeZone1 = 3;
1707
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1708
- break;
1709
- case 24: //COOL FLOW
1710
- deviceState.Power = true;
1711
- deviceState.OperationModeZone1 = 4;
1712
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1713
- break;
1714
- case 25: //FLOOR DRY UP
1715
- deviceState.Power = true;
1716
- deviceState.OperationModeZone1 = 5;
1717
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1718
- break;
1719
- case 30: //PHYSICAL LOCK CONTROL
1720
- deviceState.ProhibitZone1 = state;
1721
- CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone1;
1722
- break;
1723
- case 40: //HOT WATER NORMAL/FORCE HOT WATER
1724
- deviceState.Power = true;
1725
- deviceState.ForcedHotWaterMode = state;
1726
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1727
- break;
1728
- case 41: //NORMAL/ECO
1729
- deviceState.Power = true;
1730
- deviceState.EcoHotWater = state;
1731
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.EcoHotWater;
1732
- break;
1733
- case 50: //PHYSICAL LOCK CONTROL
1734
- deviceState.ProhibitHotWater = state;
1735
- CONSTANTS.HeatPump.EffectiveFlags.ProhibitHotWater;
1736
- break;
1737
- case 60: //ZONE 2 HEAT THERMOSTAT
1738
- deviceState.Power = true;
1739
- deviceState.OperationModeZone2 = 0;
1740
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1741
- break;
1742
- case 61: // HEAT FLOW
1743
- deviceState.Power = true;
1744
- deviceState.OperationModeZone2 = 1;
1745
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1746
- break;
1747
- case 62: //HEAT CURVE
1748
- deviceState.Power = true;
1749
- deviceState.OperationModeZone2 = 2;
1750
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1751
- break;
1752
- case 63: //COOL THERMOSTAT
1753
- deviceState.Power = true;
1754
- deviceState.OperationModeZone2 = 3;
1755
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1756
- break;
1757
- case 64: //COOL FLOW
1758
- deviceState.Power = true;
1759
- deviceState.OperationModeZone2 = 4;
1760
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1761
- break;
1762
- case 65: //FLOOR DRY UP
1763
- deviceState.Power = true;
1764
- deviceState.OperationModeZone2 = 5;
1765
- deviceState.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1766
- break;
1767
- case 70: //PHYSICAL LOCK CONTROL
1768
- deviceState.ProhibitZone2 = state;
1769
- CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone2;
1770
- break;
1771
- default:
1772
- this.emit('message', `Unknown button mode: ${mode}`);
1773
- break;
1774
- };
1665
+ .onSet(async (state) => {
1666
+ if (displayType > 0 && displayType < 3) {
1667
+ try {
1668
+ switch (mode) {
1669
+ case 0: //POWER ON,OFF
1670
+ deviceData.Device.Power = state;
1671
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power;
1672
+ break;
1673
+ case 1: //HEAT PUMP HEAT
1674
+ deviceData.Device.Power = true;
1675
+ deviceData.Device.UnitStatus = 0;
1676
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
1677
+ break;
1678
+ case 2: //COOL
1679
+ deviceData.Device.Power = true;
1680
+ deviceData.Device.UnitStatus = 1;
1681
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationMode;
1682
+ break;
1683
+ case 3: //HOLIDAY
1684
+ deviceData.Device.HolidayMode = state;
1685
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.HolidayMode;
1686
+ break;
1687
+ case 10: //ALL ZONES PHYSICAL LOCK CONTROL
1688
+ deviceData.Device.ProhibitZone1 = state;
1689
+ deviceData.Device.ProhibitHotWater = state;
1690
+ deviceData.Device.ProhibitZone2 = state;
1691
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone1 + CONSTANTS.HeatPump.EffectiveFlags.ProhibitHotWater + CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone2;
1692
+ break;
1693
+ case 20: //ZONE 1 HEAT THERMOSTAT
1694
+ deviceData.Device.Power = true;
1695
+ deviceData.Device.OperationModeZone1 = 0;
1696
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1697
+ break;
1698
+ case 21: //HEAT FLOW
1699
+ deviceData.Device.Power = true;
1700
+ deviceData.Device.OperationModeZone1 = 1;
1701
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1702
+ break;
1703
+ case 22: //HEAT CURVE
1704
+ deviceData.Device.Power = true;
1705
+ deviceData.Device.OperationModeZone1 = 2;
1706
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1707
+ break;
1708
+ case 23: //COOL THERMOSTAT
1709
+ deviceData.Device.Power = true;
1710
+ deviceData.Device.OperationModeZone1 = 3;
1711
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1712
+ break;
1713
+ case 24: //COOL FLOW
1714
+ deviceData.Device.Power = true;
1715
+ deviceData.Device.OperationModeZone1 = 4;
1716
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1717
+ break;
1718
+ case 25: //FLOOR DRY UP
1719
+ deviceData.Device.Power = true;
1720
+ deviceData.Device.OperationModeZone1 = 5;
1721
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone1;
1722
+ break;
1723
+ case 30: //PHYSICAL LOCK CONTROL
1724
+ deviceData.Device.ProhibitZone1 = state;
1725
+ CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone1;
1726
+ break;
1727
+ case 40: //HOT WATER NORMAL/FORCE HOT WATER
1728
+ deviceData.Device.Power = true;
1729
+ deviceData.Device.ForcedHotWaterMode = state;
1730
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.ForcedHotWaterMode;
1731
+ break;
1732
+ case 41: //NORMAL/ECO
1733
+ deviceData.Device.Power = true;
1734
+ deviceData.Device.EcoHotWater = state;
1735
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.EcoHotWater;
1736
+ break;
1737
+ case 50: //PHYSICAL LOCK CONTROL
1738
+ deviceData.Device.ProhibitHotWater = state;
1739
+ CONSTANTS.HeatPump.EffectiveFlags.ProhibitHotWater;
1740
+ break;
1741
+ case 60: //ZONE 2 HEAT THERMOSTAT
1742
+ deviceData.Device.Power = true;
1743
+ deviceData.Device.OperationModeZone2 = 0;
1744
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1745
+ break;
1746
+ case 61: // HEAT FLOW
1747
+ deviceData.Device.Power = true;
1748
+ deviceData.Device.OperationModeZone2 = 1;
1749
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1750
+ break;
1751
+ case 62: //HEAT CURVE
1752
+ deviceData.Device.Power = true;
1753
+ deviceData.Device.OperationModeZone2 = 2;
1754
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1755
+ break;
1756
+ case 63: //COOL THERMOSTAT
1757
+ deviceData.Device.Power = true;
1758
+ deviceData.Device.OperationModeZone2 = 3;
1759
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1760
+ break;
1761
+ case 64: //COOL FLOW
1762
+ deviceData.Device.Power = true;
1763
+ deviceData.Device.OperationModeZone2 = 4;
1764
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1765
+ break;
1766
+ case 65: //FLOOR DRY UP
1767
+ deviceData.Device.Power = true;
1768
+ deviceData.Device.OperationModeZone2 = 5;
1769
+ deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.Power + CONSTANTS.HeatPump.EffectiveFlags.OperationModeZone2;
1770
+ break;
1771
+ case 70: //PHYSICAL LOCK CONTROL
1772
+ deviceData.Device.ProhibitZone2 = state;
1773
+ CONSTANTS.HeatPump.EffectiveFlags.ProhibitHeatingZone2;
1774
+ break;
1775
+ default:
1776
+ this.emit('message', `Unknown button mode: ${mode}`);
1777
+ break;
1778
+ };
1775
1779
 
1776
- await this.melCloudAtw.send(deviceState);
1777
- const info = this.disableLogInfo ? false : this.emit('message', `Set: ${buttonName}`);
1778
- } catch (error) {
1779
- this.emit('warn', `Set button error: ${error}`);
1780
+ await this.melCloudAtw.send(deviceData);
1781
+ const info = this.disableLogInfo ? false : this.emit('message', `Set: ${buttonName}`);
1782
+ } catch (error) {
1783
+ this.emit('warn', `Set button error: ${error}`);
1784
+ };
1780
1785
  };
1781
1786
  });
1782
- };
1783
1787
  this.buttonsServices.push(buttonService);
1784
1788
  accessory.addService(buttonService)
1785
1789
  };