homebridge-melcloud-control 4.2.3-beta.8 → 4.2.4

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 (15) hide show
  1. package/CHANGELOG.md +11 -0
  2. package/README.md +36 -21
  3. package/config.schema.json +433 -25
  4. package/homebridge-ui/public/index.html +86 -16
  5. package/index.js +3 -3
  6. package/package.json +2 -2
  7. package/src/constants.js +48 -5
  8. package/src/deviceata.js +274 -155
  9. package/src/deviceatw.js +334 -218
  10. package/src/deviceerv.js +250 -126
  11. package/src/melcloud.js +24 -31
  12. package/src/melcloudata.js +40 -21
  13. package/src/melcloudatw.js +46 -29
  14. package/src/melclouderv.js +37 -21
  15. package/src/melcloudhome.js +76 -37
package/src/deviceatw.js CHANGED
@@ -43,6 +43,7 @@ class DeviceAtw extends EventEmitter {
43
43
  this.holidayModeSupport = device.holidayModeSupport || false;
44
44
  this.presets = this.accountType === 'melcloud' ? (device.presets || []).filter(preset => (preset.displayType ?? 0) > 0 && preset.id !== '0') : [];
45
45
  this.schedules = this.accountType === 'melcloudhome' ? (device.schedules || []).filter(schedule => (schedule.displayType ?? 0) > 0 && schedule.id !== '0') : [];
46
+ this.scenes = this.accountType === 'melcloudhome' ? (device.scenes || []).filter(scene => (scene.displayType ?? 0) > 0 && scene.id !== '0') : [];
46
47
  this.buttons = (device.buttonsSensors || []).filter(button => (button.displayType ?? 0) > 0);
47
48
  this.deviceId = device.id;
48
49
  this.deviceName = device.name;
@@ -57,23 +58,34 @@ class DeviceAtw extends EventEmitter {
57
58
  this.mqtt = account.mqtt ?? {};
58
59
  this.mqttConnected = false;
59
60
 
61
+ const serviceType = [null, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor];
62
+ const characteristicType = [null, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState];
63
+
60
64
  //presets configured
61
65
  for (const preset of this.presets) {
62
- preset.name = preset.name || 'Preset'
63
- preset.serviceType = [null, Service.Outlet, Service.Switch, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor][preset.displayType];
64
- preset.characteristicType = [null, Characteristic.On, Characteristic.On, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState][preset.displayType];
66
+ preset.name = preset.name;
67
+ preset.serviceType = serviceType[preset.displayType];
68
+ preset.characteristicType = characteristicType[preset.displayType];
65
69
  preset.state = false;
66
70
  preset.previousSettings = {};
67
71
  }
68
72
 
69
73
  //schedules configured
70
74
  for (const schedule of this.schedules) {
71
- schedule.name = schedule.name || 'Schedule'
72
- schedule.serviceType = [null, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor][schedule.displayType];
73
- schedule.characteristicType = [null, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState][schedule.displayType];
75
+ schedule.name = schedule.name;
76
+ schedule.serviceType = serviceType[schedule.displayType];
77
+ schedule.characteristicType = characteristicType[schedule.displayType];
74
78
  schedule.state = false;
75
79
  }
76
80
 
81
+ //scenes configured
82
+ for (const scene of this.scenes) {
83
+ scene.name = scene.name;
84
+ scene.serviceType = serviceType[scene.displayType];
85
+ scene.characteristicType = characteristicType[scene.displayType];
86
+ scene.state = false;
87
+ }
88
+
77
89
  //buttons configured
78
90
  for (const button of this.buttons) {
79
91
  button.name = button.name || 'Button'
@@ -172,93 +184,93 @@ class DeviceAtw extends EventEmitter {
172
184
  async setOverExternalIntegration(integration, deviceData, key, value) {
173
185
  try {
174
186
  let set = false
175
- let effectiveFlags = null;
187
+ let flag = null;
176
188
  switch (key) {
177
189
  case 'Power':
178
190
  deviceData.Device[key] = value;
179
- effectiveFlags = HeatPump.EffectiveFlags.Power;
191
+ flag = HeatPump.EffectiveFlags.Power;
180
192
  break;
181
193
  case 'OperationMode':
182
194
  deviceData.Device[key] = value;
183
- effectiveFlags = HeatPump.EffectiveFlags.OperationMode;
195
+ flag = HeatPump.EffectiveFlags.OperationMode;
184
196
  break;
185
197
  case 'OperationModeZone1':
186
198
  deviceData.Device[key] = value;
187
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
199
+ flag = HeatPump.EffectiveFlags.OperationModeZone1;
188
200
  break;
189
201
  case 'OperationModeZone2':
190
202
  deviceData.Device[key] = value;
191
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
203
+ flag = HeatPump.EffectiveFlags.OperationModeZone2;
192
204
  break;
193
205
  case 'SetTemperatureZone1':
194
206
  deviceData.Device[key] = value;
195
- effectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
207
+ flag = HeatPump.EffectiveFlags.SetTemperatureZone2;
196
208
  break;
197
209
  case 'SetTemperatureZone2':
198
210
  deviceData.Device[key] = value;
199
- effectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
211
+ flag = HeatPump.EffectiveFlags.SetTemperatureZone2;
200
212
  break;
201
213
  case 'SetHeatFlowTemperatureZone1':
202
214
  deviceData.Device[key] = value;
203
- effectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
215
+ flag = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
204
216
  break;
205
217
  case 'SetHeatFlowTemperatureZone2':
206
218
  deviceData.Device[key] = value;
207
- effectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
219
+ flag = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
208
220
  break;
209
221
  case 'SetCoolFlowTemperatureZone1':
210
222
  deviceData.Device[key] = value;
211
- effectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
223
+ flag = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
212
224
  break;
213
225
  case 'SetCoolFlowTemperatureZone2':
214
226
  deviceData.Device[key] = value;
215
- effectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
227
+ flag = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
216
228
  break;
217
229
  case 'SetTankWaterTemperature':
218
230
  deviceData.Device[key] = value;
219
- effectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
231
+ flag = HeatPump.EffectiveFlags.SetTankWaterTemperature;
220
232
  break;
221
233
  case 'ForcedHotWaterMode':
222
234
  deviceData.Device[key] = value;
223
- effectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
235
+ flag = HeatPump.EffectiveFlags.ForcedHotWaterMode;
224
236
  break;
225
237
  case 'EcoHotWater':
226
238
  deviceData.Device[key] = value;
227
- effectiveFlags = HeatPump.EffectiveFlags.EcoHotWater;
239
+ flag = HeatPump.EffectiveFlags.EcoHotWater;
228
240
  break;
229
241
  case 'ProhibitZone1':
230
242
  if (this.accountType === 'melcloudhome') return;
231
243
 
232
244
  deviceData.Device[key] = value;
233
- effectiveFlags = HeatPump.EffectiveFlags.ProhibitZone1;
245
+ flag = HeatPump.EffectiveFlags.ProhibitZone1;
234
246
  break;
235
247
  case 'ProhibitZone2':
236
248
  if (this.accountType === 'melcloudhome') return;
237
249
 
238
250
  deviceData.Device[key] = value;
239
- effectiveFlags = HeatPump.EffectiveFlags.ProhibitZone2;
251
+ flag = HeatPump.EffectiveFlags.ProhibitZone2;
240
252
  break;
241
253
  case 'ProhibitHotWater':
242
254
  if (this.accountType === 'melcloudhome') return;
243
255
 
244
256
  deviceData.Device[key] = value;
245
- effectiveFlags = HeatPump.EffectiveFlags.ProhibitHotWater;
257
+ flag = HeatPump.EffectiveFlags.ProhibitHotWater;
246
258
  break;
247
259
  case 'ScheduleEnabled':
248
260
  if (this.accountType === 'melcloud') return;
249
261
 
250
262
  deviceData.Device[key].Enabled = value;
251
- effectiveFlags = 'schedule';
263
+ flag = 'schedule';
252
264
  break;
253
265
  case 'HolidayMode':
254
266
  if (this.accountType === 'melcloud') {
255
267
  deviceData.Device[key] = value;
256
- effectiveFlags = HeatPump.EffectiveFlags.HolidayMode;
268
+ flag = HeatPump.EffectiveFlags.HolidayMode;
257
269
  }
258
270
 
259
271
  if (this.accountType === 'melcloudhome') {
260
272
  deviceData.Device[key].Enabled = value;
261
- effectiveFlags = 'holidaymode';
273
+ flag = 'holidaymode';
262
274
  }
263
275
  break;
264
276
  default:
@@ -266,7 +278,7 @@ class DeviceAtw extends EventEmitter {
266
278
  break;
267
279
  };
268
280
 
269
- set = await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, effectiveFlags);
281
+ set = await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, flag);
270
282
  return set;
271
283
  } catch (error) {
272
284
  throw new Error(`${integration} set key: ${key}, value: ${value}, error: ${error.message ?? error}`);
@@ -293,6 +305,7 @@ class DeviceAtw extends EventEmitter {
293
305
  const accountName = this.accountName;
294
306
  const presetsOnServer = this.accessory.presets;
295
307
  const schedulesOnServer = this.accessory.schedules;
308
+ const scenesOnServer = this.accessory.scenes;
296
309
  const zonesCount = this.accessory.zonesCount;
297
310
  const caseHeatPump = this.accessory.caseHeatPump;
298
311
  const caseZone1 = this.accessory.caseZone1;
@@ -340,14 +353,12 @@ class DeviceAtw extends EventEmitter {
340
353
  return state;
341
354
  })
342
355
  .onSet(async (state) => {
343
- if (!!state === this.accessory.power) return;
344
-
345
356
  try {
346
357
  switch (i) {
347
358
  case 0: //Heat Pump
348
359
  deviceData.Device.Power = state ? true : false;
349
360
  await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, HeatPump.EffectiveFlags.Power);
350
- if (this.logInfo) this.emit('info', `${zoneName}, Set power: ${state ? 'ON' : 'OFF'}`);
361
+ if (this.logInfo) this.emit('info', `${zoneName}, Set power: ${state ? 'On' : 'Off'}`);
351
362
  break;
352
363
  };
353
364
  } catch (error) {
@@ -372,23 +383,23 @@ class DeviceAtw extends EventEmitter {
372
383
  .onSet(async (value) => {
373
384
  try {
374
385
  let operationModeText = '';
375
- let effectiveFlags = null;
386
+ let flag = null;
376
387
  switch (i) {
377
388
  case caseHeatPump: //Heat Pump - ON, HEAT, COOL
378
389
  switch (value) {
379
390
  case caseHeatPump: //AUTO
380
391
  deviceData.Device.Power = true;
381
- effectiveFlags = HeatPump.EffectiveFlags.Power;
392
+ flag = HeatPump.EffectiveFlags.Power;
382
393
  break;
383
394
  case 1: //HEAT
384
395
  deviceData.Device.Power = true;
385
396
  deviceData.Device.UnitStatus = 0;
386
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
397
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
387
398
  break;
388
399
  case 2: //COOL
389
400
  deviceData.Device.Power = true;
390
401
  deviceData.Device.UnitStatus = 1;
391
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
402
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
392
403
  break;
393
404
  };
394
405
  operationModeText = [HeatPump.SystemMapEnumToString[0], HeatPump.SystemMapEnumToString[deviceData.Device.UnitStatus]][this.accessory.power];
@@ -397,15 +408,15 @@ class DeviceAtw extends EventEmitter {
397
408
  switch (value) {
398
409
  case 0: //AUTO - HEAT CURVE
399
410
  deviceData.Device.OperationModeZone1 = 2;
400
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
411
+ flag = HeatPump.EffectiveFlags.OperationModeZone1;
401
412
  break;
402
413
  case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
403
414
  deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
404
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
415
+ flag = HeatPump.EffectiveFlags.OperationModeZone1;
405
416
  break;
406
417
  case 2: //COOL - HEAT FLOW / COOL FLOW
407
418
  deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
408
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
419
+ flag = HeatPump.EffectiveFlags.OperationModeZone1;
409
420
  break;
410
421
  };
411
422
  operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
@@ -414,15 +425,15 @@ class DeviceAtw extends EventEmitter {
414
425
  switch (value) {
415
426
  case 0: //AUTO
416
427
  deviceData.Device.ForcedHotWaterMode = false;
417
- effectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
428
+ flag = HeatPump.EffectiveFlags.ForcedHotWaterMode;
418
429
  break;
419
430
  case 1: //HEAT
420
431
  deviceData.Device.ForcedHotWaterMode = true;
421
- effectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
432
+ flag = HeatPump.EffectiveFlags.ForcedHotWaterMode;
422
433
  break;
423
434
  case 2: //COOL
424
435
  deviceData.Device.ForcedHotWaterMode = false;
425
- effectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
436
+ flag = HeatPump.EffectiveFlags.ForcedHotWaterMode;
426
437
  break
427
438
  };
428
439
  operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhwMapEnumToString[1] : HeatPump.ForceDhwMapEnumToString[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
@@ -431,22 +442,22 @@ class DeviceAtw extends EventEmitter {
431
442
  switch (value) {
432
443
  case 0: //AUTO
433
444
  deviceData.Device.OperationModeZone2 = 2;
434
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
445
+ flag = HeatPump.EffectiveFlags.OperationModeZone2;
435
446
  break;
436
447
  case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
437
448
  deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
438
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
449
+ flag = HeatPump.EffectiveFlags.OperationModeZone2;
439
450
  break;
440
451
  case 2: //COOL - HEAT FLOW / COOL FLOW
441
452
  deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
442
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
453
+ flag = HeatPump.EffectiveFlags.OperationModeZone2;
443
454
  break;
444
455
  };
445
456
  operationModeText = HeatPump.ZoneOperationMapEnumToString[deviceData.Device.OperationModeZone2];
446
457
  break;
447
458
  };
448
459
 
449
- await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, effectiveFlags);
460
+ await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, flag);
450
461
  if (this.logInfo) this.emit('info', `${zoneName}, Set operation mode: ${operationModeText}`);
451
462
  } catch (error) {
452
463
  if (this.logWarn) this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
@@ -476,51 +487,51 @@ class DeviceAtw extends EventEmitter {
476
487
  })
477
488
  .onSet(async (value) => {
478
489
  try {
479
- let effectiveFlags = null;
490
+ let flag = null;
480
491
  switch (i) {
481
492
  case caseHeatPump: //Heat Pump
482
493
  //deviceData.Device.SetTemperatureZone1 = value;
483
- //effectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
494
+ //flag = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
484
495
  break;
485
496
  case caseZone1: //Zone 1
486
497
  switch (zone.operationMode) {
487
498
  case 1: //HEAT FLOW
488
499
  deviceData.Device.SetHeatFlowTemperatureZone1 = value;
489
- effectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
500
+ flag = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
490
501
  break;
491
502
  case 4: //COOL FLOW
492
503
  deviceData.Device.SetCoolFlowTemperatureZone1 = value;
493
- effectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
504
+ flag = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
494
505
  break;
495
506
  default:
496
507
  deviceData.Device.SetTemperatureZone1 = value;
497
- effectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
508
+ flag = HeatPump.EffectiveFlags.SetTemperatureZone1;
498
509
  break
499
510
  };
500
511
  break;
501
512
  case caseHotWater: //Hot Water
502
513
  deviceData.Device.SetTankWaterTemperature = value;
503
- effectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
514
+ flag = HeatPump.EffectiveFlags.SetTankWaterTemperature;
504
515
  break;
505
516
  case caseZone2: //Zone 2
506
517
  switch (zone.operationMode) {
507
518
  case 1: //HEAT FLOW
508
519
  deviceData.Device.SetHeatFlowTemperatureZone2 = value;
509
- effectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
520
+ flag = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
510
521
  break;
511
522
  case 4: //COOL FLOW
512
523
  deviceData.Device.SetCoolFlowTemperatureZone2 = value;
513
- effectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
524
+ flag = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
514
525
  break;
515
526
  default:
516
527
  deviceData.Device.SetTemperatureZone2 = value;
517
- effectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
528
+ flag = HeatPump.EffectiveFlags.SetTemperatureZone2;
518
529
  break
519
530
  };
520
531
  break;
521
532
  };
522
533
 
523
- if (i > 0) await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, effectiveFlags);
534
+ if (i > 0) await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, flag);
524
535
  if (this.logInfo && i !== 0) this.emit('info', `${zoneName}, Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
525
536
  } catch (error) {
526
537
  if (this.logWarn) this.emit('warn', `${zoneName}, Set cooling threshold temperature error: ${error}`);
@@ -541,51 +552,51 @@ class DeviceAtw extends EventEmitter {
541
552
  })
542
553
  .onSet(async (value) => {
543
554
  try {
544
- let effectiveFlags = null;
555
+ let flag = null;
545
556
  switch (i) {
546
557
  case caseHeatPump: //Heat Pump
547
558
  //deviceData.Device.SetTemperatureZone1 = value;
548
- //effectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
559
+ //flag = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
549
560
  break;
550
561
  case caseZone1: //Zone 1
551
562
  switch (zone.operationMode) {
552
563
  case 1: //HEAT FLOW
553
564
  deviceData.Device.SetHeatFlowTemperatureZone1 = value;
554
- effectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
565
+ flag = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
555
566
  break;
556
567
  case 4: //COOL FLOW
557
568
  deviceData.Device.SetCoolFlowTemperatureZone1 = value;
558
- effectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
569
+ flag = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
559
570
  break;
560
571
  default:
561
572
  deviceData.Device.SetTemperatureZone1 = value;
562
- effectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
573
+ flag = HeatPump.EffectiveFlags.SetTemperatureZone1;
563
574
  break
564
575
  };
565
576
  break;
566
577
  case caseHotWater: //Hot Water
567
578
  deviceData.Device.SetTankWaterTemperature = value;
568
- effectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
579
+ flag = HeatPump.EffectiveFlags.SetTankWaterTemperature;
569
580
  break;
570
581
  case caseZone2: //Zone 2
571
582
  switch (zone.operationMode) {
572
583
  case 1: //HEAT FLOW
573
584
  deviceData.Device.SetHeatFlowTemperatureZone2 = value;
574
- effectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
585
+ flag = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
575
586
  break;
576
587
  case 4: //COOL FLOW
577
588
  deviceData.Device.SetCoolFlowTemperatureZone2 = value;
578
- effectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
589
+ flag = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
579
590
  break;
580
591
  default:
581
592
  deviceData.Device.SetTemperatureZone2 = value;
582
- effectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
593
+ flag = HeatPump.EffectiveFlags.SetTemperatureZone2;
583
594
  break
584
595
  };
585
596
  break;
586
597
  };
587
598
 
588
- if (i > 0) await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, effectiveFlags);
599
+ if (i > 0) await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, flag);
589
600
  if (this.logInfo && i !== 0) this.emit('info', `${zoneName}, Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
590
601
  } catch (error) {
591
602
  if (this.logWarn) this.emit('warn', `${zoneName}, Set heating threshold temperature error: ${error}`);
@@ -671,27 +682,27 @@ class DeviceAtw extends EventEmitter {
671
682
  .onSet(async (value) => {
672
683
  try {
673
684
  let operationModeText = '';
674
- let effectiveFlags = null;
685
+ let flag = null;
675
686
  switch (i) {
676
687
  case caseHeatPump: //Heat Pump - HEAT, COOL
677
688
  switch (value) {
678
689
  case 0: //OFF
679
690
  deviceData.Device.Power = false;
680
- effectiveFlags = HeatPump.EffectiveFlags.Power;
691
+ flag = HeatPump.EffectiveFlags.Power;
681
692
  break;
682
693
  case 1: //HEAT
683
694
  deviceData.Device.Power = true;
684
695
  deviceData.Device.UnitStatus = 0;
685
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
696
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
686
697
  break;
687
698
  case 2: //COOL
688
699
  deviceData.Device.Power = true;
689
700
  deviceData.Device.UnitStatus = 1;
690
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
701
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
691
702
  break;
692
703
  case 3: //AUTO
693
704
  deviceData.Device.Power = true;
694
- effectiveFlags = HeatPump.EffectiveFlags.Power;
705
+ flag = HeatPump.EffectiveFlags.Power;
695
706
  break;
696
707
  };
697
708
  operationModeText = [HeatPump.SystemMapEnumToString[0], HeatPump.SystemMapEnumToString[deviceData.Device.UnitStatus]][this.accessory.power];
@@ -700,19 +711,19 @@ class DeviceAtw extends EventEmitter {
700
711
  switch (value) {
701
712
  case 0: //OFF - HEAT CURVE
702
713
  deviceData.Device.OperationModeZone1 = 2;
703
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
714
+ flag = HeatPump.EffectiveFlags.OperationModeZone1;
704
715
  break;
705
716
  case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
706
717
  deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
707
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
718
+ flag = HeatPump.EffectiveFlags.OperationModeZone1;
708
719
  break;
709
720
  case 2: //COOL - HEAT FLOW / COOL FLOW
710
721
  deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
711
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
722
+ flag = HeatPump.EffectiveFlags.OperationModeZone1;
712
723
  break;
713
724
  case 3: //AUTO - HEAT CURVE
714
725
  deviceData.Device.OperationModeZone1 = 2;
715
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
726
+ flag = HeatPump.EffectiveFlags.OperationModeZone1;
716
727
  break;
717
728
  };
718
729
  operationModeText = HeatPump.ZoneOperationMapEnumToString[deviceData.Device.OperationModeZone1];
@@ -721,19 +732,19 @@ class DeviceAtw extends EventEmitter {
721
732
  switch (value) {
722
733
  case 0: //OFF
723
734
  deviceData.Device.ForcedHotWaterMode = false;
724
- effectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
735
+ flag = HeatPump.EffectiveFlags.ForcedHotWaterMode;
725
736
  break;
726
737
  case 1: //HEAT
727
738
  deviceData.Device.ForcedHotWaterMode = true;
728
- effectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
739
+ flag = HeatPump.EffectiveFlags.ForcedHotWaterMode;
729
740
  break;
730
741
  case 2: //COOL
731
742
  deviceData.Device.ForcedHotWaterMode = false;
732
- effectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
743
+ flag = HeatPump.EffectiveFlags.ForcedHotWaterMode;
733
744
  break;
734
745
  case 3: //AUTO
735
746
  deviceData.Device.ForcedHotWaterMode = false;
736
- effectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
747
+ flag = HeatPump.EffectiveFlags.ForcedHotWaterMode;
737
748
  break;
738
749
  };
739
750
  operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhwMapEnumToString[1] : HeatPump.ForceDhwMapEnumToString[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
@@ -742,26 +753,26 @@ class DeviceAtw extends EventEmitter {
742
753
  switch (value) {
743
754
  case 0: //OFF - HEAT CURVE
744
755
  deviceData.Device.OperationModeZone2 = 2;
745
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
756
+ flag = HeatPump.EffectiveFlags.OperationModeZone2;
746
757
  break;
747
758
  case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
748
759
  deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
749
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
760
+ flag = HeatPump.EffectiveFlags.OperationModeZone2;
750
761
  break;
751
762
  case 2: //COOL - HEAT FLOW / COOL FLOW
752
763
  deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
753
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
764
+ flag = HeatPump.EffectiveFlags.OperationModeZone2;
754
765
  break;
755
766
  case 3: //AUTO - HEAT CURVE
756
767
  deviceData.Device.OperationModeZone2 = 2;
757
- effectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
768
+ flag = HeatPump.EffectiveFlags.OperationModeZone2;
758
769
  break;
759
770
  };
760
771
  operationModeText = HeatPump.ZoneOperationMapEnumToString[deviceData.Device.OperationModeZone2];
761
772
  break;
762
773
  };
763
774
 
764
- await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, effectiveFlags);
775
+ await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, flag);
765
776
  if (this.logInfo) this.emit('info', `${zoneName}, Set operation mode: ${operationModeText}`);
766
777
  } catch (error) {
767
778
  if (this.logWarn) this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
@@ -789,27 +800,27 @@ class DeviceAtw extends EventEmitter {
789
800
  })
790
801
  .onSet(async (value) => {
791
802
  try {
792
- let effectiveFlags = null;
803
+ let flag = null;
793
804
  switch (i) {
794
805
  case caseHeatPump: //Heat Pump
795
806
  //deviceData.Device.SetTemperatureZone1 = value;
796
- //effectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
807
+ //flag = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
797
808
  break;
798
809
  case caseZone1: //Zone 1
799
810
  deviceData.Device.SetTemperatureZone1 = value;
800
- effectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
811
+ flag = HeatPump.EffectiveFlags.SetTemperatureZone1;
801
812
  break;
802
813
  case caseHotWater: //Hot Water
803
814
  deviceData.Device.SetTankWaterTemperature = value;
804
- effectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
815
+ flag = HeatPump.EffectiveFlags.SetTankWaterTemperature;
805
816
  break;
806
817
  case caseZone2: //Zone 2
807
818
  deviceData.Device.SetTemperatureZone2 = value;
808
- effectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
819
+ flag = HeatPump.EffectiveFlags.SetTemperatureZone2;
809
820
  break;
810
821
  };
811
822
 
812
- if (i > 0) await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, effectiveFlags);
823
+ if (i > 0) await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, flag);
813
824
  if (this.logInfo && i !== 0) this.emit('info', `${zoneName}, Set temperature: ${value}${this.accessory.temperatureUnit}`);
814
825
  } catch (error) {
815
826
  if (this.logWarn) this.emit('warn', `${zoneName}, Set temperature error: ${error}`);
@@ -1111,7 +1122,6 @@ class DeviceAtw extends EventEmitter {
1111
1122
  accessory.addService(this.errorService);
1112
1123
  }
1113
1124
 
1114
-
1115
1125
  //holiday mode
1116
1126
  if (this.holidayModeSupport && this.accessory.holidayModeEnabled !== null) {
1117
1127
  //control
@@ -1162,7 +1172,8 @@ class DeviceAtw extends EventEmitter {
1162
1172
  //presets services
1163
1173
  if (this.presets.length > 0) {
1164
1174
  if (this.logDebug) this.emit('debug', `Prepare presets services`);
1165
- this.presetsServices = [];
1175
+ this.presetControlServices = [];
1176
+ this.presetControlSensorServices = [];
1166
1177
  this.presets.forEach((preset, i) => {
1167
1178
  const presetData = presetsOnServer.find(p => p.ID === preset.id);
1168
1179
 
@@ -1172,66 +1183,71 @@ class DeviceAtw extends EventEmitter {
1172
1183
  //get preset name prefix
1173
1184
  const namePrefix = preset.namePrefix;
1174
1185
 
1175
- const serviceName = namePrefix ? `${accessoryName} ${name}` : name;
1186
+ const serviceName1 = namePrefix ? `${accessoryName} ${name}` : name;
1176
1187
  const serviceType = preset.serviceType;
1177
1188
  const characteristicType = preset.characteristicType;
1178
- const presetService = new serviceType(serviceName, `Preset ${deviceId} ${i}`);
1179
- presetService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1180
- presetService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
1181
- presetService.getCharacteristic(characteristicType)
1189
+
1190
+ if (preset.displayType > 3) {
1191
+ if (this.logDebug) this.emit('debug', `Prepare preset control ${name} service`);
1192
+ const presetControlService = new Service.Switch(serviceName1, `presetControlService${deviceId} ${i}`);
1193
+ presetControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1194
+ presetControlService.setCharacteristic(Characteristic.ConfiguredName, serviceName1);
1195
+ presetControlService.getCharacteristic(Characteristic.On)
1196
+ .onGet(async () => {
1197
+ const state = preset.state;
1198
+ return state;
1199
+ })
1200
+ .onSet(async (state) => {
1201
+ try {
1202
+ switch (state) {
1203
+ case true:
1204
+ preset.previousSettings = deviceData.Device;
1205
+ deviceData.Device.Power = presetData.Power;
1206
+ deviceData.Device.OperationMode = presetData.OperationMode;
1207
+ deviceData.Device.SetTemperature = presetData.SetTemperature;
1208
+ deviceData.Device.VaneHorizontalDirection = presetData.VaneHorizontalDirection;
1209
+ deviceData.Device.VaneVerticalDirection = presetData.VaneVerticalDirection;
1210
+ deviceData.Device.SetFanSpeed = presetData.SetFanSpeed;
1211
+ break;
1212
+ case false:
1213
+ deviceData.Device.Power = preset.previousSettings.Power;
1214
+ deviceData.Device.OperationMode = preset.previousSettings.OperationMode;
1215
+ deviceData.Device.SetTemperature = preset.previousSettings.SetTemperature;
1216
+ deviceData.Device.VaneHorizontalDirection = preset.previousSettings.VaneHorizontalDirection;
1217
+ deviceData.Device.VaneVerticalDirection = preset.previousSettings.VaneVerticalDirection;
1218
+ deviceData.Device.SetFanSpeed = preset.previousSettings.SetFanSpeed;
1219
+ break;
1220
+ };
1221
+
1222
+ await this.melCloudAta.send(this.accountType, this.displayType, deviceData, AirConditioner.EffectiveFlags.Presets);
1223
+ if (this.logInfo) this.emit('info', `Preset ${name}: ${state ? 'Set:' : 'Unset:'} ${name}`);
1224
+ } catch (error) {
1225
+ if (this.logWarn) this.emit('warn', `Set preset error: ${error}`);
1226
+ };
1227
+ });
1228
+ this.presetControlServices.push(presetControlService);
1229
+ accessory.addService(presetControlService);
1230
+ }
1231
+
1232
+ //sensor
1233
+ if (this.logDebug) this.emit('debug', `Prepare preset control sensor s${name} ervice`);
1234
+ const presetControlSensorService = new serviceType(serviceName1, `presetControlSensorService${deviceId} ${i}`);
1235
+ presetControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1236
+ presetControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${serviceName1} Control`);
1237
+ presetControlSensorService.getCharacteristic(characteristicType)
1182
1238
  .onGet(async () => {
1183
- const state = preset.state;
1239
+ const state = this.accessory.scheduleEnabled;
1184
1240
  return state;
1185
1241
  })
1186
- .onSet(async (state) => {
1187
- try {
1188
- switch (state) {
1189
- case true:
1190
- preset.previousSettings = deviceData.Device;
1191
- deviceData.Device.Power = presetData.Power;
1192
- deviceData.Device.EcoHotWater = presetData.EcoHotWater;
1193
- deviceData.Device.OperationModeZone1 = presetData.OperationModeZone1;
1194
- deviceData.Device.OperationModeZone2 = presetData.OperationModeZone2;
1195
- deviceData.Device.SetTankWaterTemperature = presetData.SetTankWaterTemperature;
1196
- deviceData.Device.SetTemperatureZone1 = presetData.SetTemperatureZone1;
1197
- deviceData.Device.SetTemperatureZone2 = presetData.SetTemperatureZone2;
1198
- deviceData.Device.ForcedHotWaterMode = presetData.ForcedHotWaterMode;
1199
- deviceData.Device.SetHeatFlowTemperatureZone1 = presetData.SetHeatFlowTemperatureZone1;
1200
- deviceData.Device.SetHeatFlowTemperatureZone2 = presetData.SetHeatFlowTemperatureZone2;
1201
- deviceData.Device.SetCoolFlowTemperatureZone1 = presetData.SetCoolFlowTemperatureZone1;
1202
- deviceData.Device.SetCoolFlowTemperatureZone2 = presetData.SetCoolFlowTemperatureZone2;
1203
- break;
1204
- case false:
1205
- deviceData.Device.Power = preset.previousSettings.Power;
1206
- deviceData.Device.EcoHotWater = preset.previousSettings.EcoHotWater;
1207
- deviceData.Device.OperationModeZone1 = preset.previousSettings.OperationModeZone1;
1208
- deviceData.Device.OperationModeZone2 = preset.previousSettings.OperationModeZone2;
1209
- deviceData.Device.SetTankWaterTemperature = preset.previousSettings.SetTankWaterTemperature;
1210
- deviceData.Device.SetTemperatureZone1 = preset.previousSettings.SetTemperatureZone1;
1211
- deviceData.Device.SetTemperatureZone2 = preset.previousSettings.SetTemperatureZone2;
1212
- deviceData.Device.ForcedHotWaterMode = preset.previousSettings.ForcedHotWaterMode;
1213
- deviceData.Device.SetHeatFlowTemperatureZone1 = preset.previousSettings.SetHeatFlowTemperatureZone1;
1214
- deviceData.Device.SetHeatFlowTemperatureZone2 = preset.previousSettings.SetHeatFlowTemperatureZone2;
1215
- deviceData.Device.SetCoolFlowTemperatureZone1 = preset.previousSettings.SetCoolFlowTemperatureZone1;
1216
- deviceData.Device.SetCoolFlowTemperatureZone2 = preset.previousSettings.SetCoolFlowTemperatureZone2;
1217
- break;
1218
- };
1219
-
1220
- await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, HeatPump.EffectiveFlags.Power);
1221
- if (this.logInfo) this.emit('info', `${state ? 'Set:' : 'Unset:'} ${name}`);
1222
- } catch (error) {
1223
- if (this.logWarn) this.emit('warn', `Set preset error: ${error}`);
1224
- };
1225
- });
1226
- this.presetsServices.push(presetService);
1227
- accessory.addService(presetService);
1242
+ this.presetControlSensorServices.push(presetControlSensorService);
1243
+ accessory.addService(presetControlSensorService);
1228
1244
  });
1229
1245
  };
1230
1246
 
1231
1247
  //schedules services
1232
1248
  if (this.schedules.length > 0 && this.accessory.scheduleEnabled !== null) {
1233
1249
  if (this.logDebug) this.emit('debug', `Prepare schedules services`);
1234
- this.schedulesServices = [];
1250
+ this.scheduleSensorServices = [];
1235
1251
  this.schedules.forEach((schedule, i) => {
1236
1252
  //get preset name
1237
1253
  const name = schedule.name;
@@ -1239,54 +1255,117 @@ class DeviceAtw extends EventEmitter {
1239
1255
  //get preset name prefix
1240
1256
  const namePrefix = schedule.namePrefix;
1241
1257
 
1258
+ //control sensor
1259
+ const serviceName1 = namePrefix ? `${accessoryName} ${name}` : name;
1260
+ const serviceName2 = namePrefix ? `${accessoryName} Schedules` : 'Schedules';
1261
+ const serviceType = schedule.serviceType;
1262
+ const characteristicType = schedule.characteristicType;
1263
+
1242
1264
  //control
1243
1265
  if (i === 0) {
1244
- if (this.logDebug) this.emit('debug', `Prepare schedule control service`);
1245
- this.schedulesControlService = new Service.Switch(`${serviceName} Schedule`, `schedulesControlService${deviceId} ${i}`);
1246
- this.schedulesControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1247
- this.schedulesControlService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Schedules`);
1248
- this.schedulesControlService.getCharacteristic(Characteristic.On)
1266
+ if (schedule.displayType > 3) {
1267
+ if (this.logDebug) this.emit('debug', `Prepare schedule control ${name} service`);
1268
+ this.scheduleControlService = new Service.Switch(serviceName2, `scheduleControlService${deviceId} ${i}`);
1269
+ this.scheduleControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1270
+ this.scheduleControlService.setCharacteristic(Characteristic.ConfiguredName, serviceName2);
1271
+ this.scheduleControlService.getCharacteristic(Characteristic.On)
1272
+ .onGet(async () => {
1273
+ const state = this.accessory.scheduleEnabled;
1274
+ return state;
1275
+ })
1276
+ .onSet(async (state) => {
1277
+ try {
1278
+ deviceData.ScheduleEnabled = state;
1279
+ await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'schedule');
1280
+ if (this.logInfo) this.emit('info', `Schedule ${name}: ${state ? 'Enabled' : 'Disabled'}`);
1281
+ } catch (error) {
1282
+ if (this.logWarn) this.emit('warn', `Set schedule error: ${error}`);
1283
+ };
1284
+ });
1285
+ accessory.addService(this.scheduleControlService);
1286
+ }
1287
+
1288
+ //sensor
1289
+ if (this.logDebug) this.emit('debug', `Prepare schedule control sensor ${name} service`);
1290
+ this.scheduleControlSensorService = new serviceType(`${serviceName2} Control`, `scheduleControlSensorService${deviceId} ${i}`);
1291
+ this.scheduleControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1292
+ this.scheduleControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${serviceName2} Control`);
1293
+ this.scheduleControlSensorService.getCharacteristic(characteristicType)
1249
1294
  .onGet(async () => {
1250
1295
  const state = this.accessory.scheduleEnabled;
1251
1296
  return state;
1252
1297
  })
1298
+ accessory.addService(this.scheduleControlSensorService);
1299
+ }
1300
+
1301
+ //sensors
1302
+ if (this.logDebug) this.emit('debug', `Prepare schedule sensor ${name} service`);
1303
+ const scheduleSensorService = new serviceType(serviceName1, `scheduleSensorService${deviceId} ${i}`);
1304
+ scheduleSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1305
+ scheduleSensorService.setCharacteristic(Characteristic.ConfiguredName, serviceName1);
1306
+ scheduleSensorService.getCharacteristic(characteristicType)
1307
+ .onGet(async () => {
1308
+ const state = schedule.state;
1309
+ return state;
1310
+ });
1311
+ this.scheduleSensorServices.push(scheduleSensorService);
1312
+ accessory.addService(scheduleSensorService);
1313
+ });
1314
+ };
1315
+
1316
+ //scenes
1317
+ if (this.scenes.length > 0) {
1318
+ if (this.logDebug) this.emit('debug', `Prepare scenes services`);
1319
+ this.sceneControlServices = [];
1320
+ this.sceneControlSensorServices = [];
1321
+ this.scenes.forEach((scene, i) => {
1322
+ const sceneData = scenesOnServer.find(s => s.Id === scene.id);
1323
+
1324
+ //get preset name
1325
+ const name = scene.name;
1326
+
1327
+ //get preset name prefix
1328
+ const namePrefix = scene.namePrefix;
1329
+
1330
+ const serviceName1 = namePrefix ? `${accessoryName} ${name}` : name;
1331
+ const serviceType = scene.serviceType;
1332
+ const characteristicType = scene.characteristicType;
1333
+
1334
+ //control
1335
+ if (scene.displayType > 3) {
1336
+ if (this.logDebug) this.emit('debug', `Prepare scene control ${name} service`);
1337
+ const sceneControlService = new Service.Switch(serviceName1, `sceneControlService${deviceId} ${i}`);
1338
+ sceneControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1339
+ sceneControlService.setCharacteristic(Characteristic.ConfiguredName, serviceName1);
1340
+ sceneControlService.getCharacteristic(Characteristic.On)
1341
+ .onGet(async () => {
1342
+ const state = scene.state;
1343
+ return state;
1344
+ })
1253
1345
  .onSet(async (state) => {
1254
1346
  try {
1255
- deviceData.ScheduleEnabled = state;
1256
- await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'schedule');
1257
- if (this.logInfo) this.emit('info', `Schedule: ${state ? 'Enabled' : 'Disabled'}`);
1347
+ sceneData.Enabled = state;
1348
+ await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'scene', sceneData);
1349
+ if (this.logInfo) this.emit('info', `Scene ${name}: ${state ? 'Enabled' : 'Disabled'}`);
1258
1350
  } catch (error) {
1259
- if (this.logWarn) this.emit('warn', `Set schedule error: ${error}`);
1351
+ if (this.logWarn) this.emit('warn', `Set scene error: ${error}`);
1260
1352
  };
1261
1353
  });
1262
- accessory.addService(this.schedulesControlService);
1263
-
1264
- if (this.logDebug) this.emit('debug', `Prepare schedule control sensor service`);
1265
- this.schedulesControlSensorService = new Service.ContactSensor(`${serviceName} Schedule Control`, `schedulesControlSensorService${deviceId}`);
1266
- this.schedulesControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1267
- this.schedulesControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Schedule Control`);
1268
- this.schedulesControlSensorService.getCharacteristic(Characteristic.ContactSensorState)
1269
- .onGet(async () => {
1270
- const state = this.accessory.scheduleEnabled;
1271
- return state;
1272
- })
1273
- accessory.addService(this.schedulesControlSensorService);
1354
+ this.sceneControlServices.push(sceneControlService);
1355
+ accessory.addService(sceneControlService);
1274
1356
  }
1275
1357
 
1276
- //sensors
1277
- const serviceName1 = namePrefix ? `${accessoryName} ${name}` : name;
1278
- const serviceType = schedule.serviceType;
1279
- const characteristicType = schedule.characteristicType;
1280
- const scheduleService = new serviceType(serviceName, `scheduleService${deviceId} ${i}`);
1281
- scheduleService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1282
- scheduleService.setCharacteristic(Characteristic.ConfiguredName, serviceName1);
1283
- scheduleService.getCharacteristic(characteristicType)
1358
+ if (this.logDebug) this.emit('debug', `Prepare scene control sensor ${name} service`);
1359
+ const sceneControlSensorService = new serviceType(`${serviceName1} Control`, `sceneControlSensorService${deviceId} ${i}`);
1360
+ sceneControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1361
+ sceneControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${serviceName1} Control`);
1362
+ sceneControlSensorService.getCharacteristic(characteristicType)
1284
1363
  .onGet(async () => {
1285
- const state = schedule.state;
1364
+ const state = scene.state;
1286
1365
  return state;
1287
- });
1288
- this.schedulesServices.push(scheduleService);
1289
- accessory.addService(scheduleService);
1366
+ })
1367
+ this.sceneControlSensorServices.push(sceneControlSensorService);
1368
+ accessory.addService(sceneControlSensorService);
1290
1369
  });
1291
1370
  };
1292
1371
 
@@ -1321,123 +1400,130 @@ class DeviceAtw extends EventEmitter {
1321
1400
  .onSet(async (state) => {
1322
1401
  if (displayType > 0 && displayType < 3) {
1323
1402
  try {
1324
- let effectiveFlags = null;
1403
+ let flag = null;
1325
1404
  switch (mode) {
1326
1405
  case 0: //POWER ON,OFF
1327
1406
  deviceData.Device.Power = state;
1328
- effectiveFlags = HeatPump.EffectiveFlags.Power;
1407
+ flag = HeatPump.EffectiveFlags.Power;
1329
1408
  break;
1330
1409
  case 1: //HEAT PUMP HEAT
1331
1410
  button.previousValue = state ? deviceData.Device.UnitStatus : button.previousValue ?? deviceData.Device.UnitStatus;
1332
1411
  deviceData.Device.Power = true;
1333
1412
  deviceData.Device.UnitStatus = state ? 0 : button.previousValue;
1334
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
1413
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
1335
1414
  break;
1336
1415
  case 2: //COOL
1337
1416
  button.previousValue = state ? deviceData.Device.UnitStatus : button.previousValue ?? deviceData.Device.UnitStatus;
1338
1417
  deviceData.Device.Power = true;
1339
1418
  deviceData.Device.UnitStatus = state ? 1 : button.previousValue;
1340
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
1419
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
1341
1420
  break;
1342
1421
  case 3: //HOLIDAY
1343
- deviceData.Device.HolidayMode = state;
1344
- effectiveFlags = HeatPump.EffectiveFlags.HolidayMode;
1422
+ if (this.accountType === 'melcloud') {
1423
+ deviceData.Device.HolidayMode = state;
1424
+ flag = HeatPump.EffectiveFlags.HolidayMode;
1425
+ }
1426
+
1427
+ if (this.accountType === 'melcloudhome') {
1428
+ deviceData.Device.HolidayMode.Enabled = state;
1429
+ flag = 'holidaymode';
1430
+ }
1345
1431
  break;
1346
1432
  case 10: //ALL ZONES PHYSICAL LOCK CONTROL
1347
1433
  deviceData.Device.ProhibitZone1 = state;
1348
1434
  deviceData.Device.ProhibitHotWater = state;
1349
1435
  deviceData.Device.ProhibitZone2 = state;
1350
- effectiveFlags = HeatPump.EffectiveFlags.ProhibitHeatingZone1 + HeatPump.EffectiveFlags.ProhibitHotWater + HeatPump.EffectiveFlags.ProhibitHeatingZone2;
1436
+ flag = HeatPump.EffectiveFlags.ProhibitHeatingZone1 + HeatPump.EffectiveFlags.ProhibitHotWater + HeatPump.EffectiveFlags.ProhibitHeatingZone2;
1351
1437
  break;
1352
1438
  case 20: //ZONE 1 HEAT THERMOSTAT
1353
1439
  button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
1354
1440
  deviceData.Device.Power = true;
1355
1441
  deviceData.Device.OperationModeZone1 = state ? 0 : button.previousValue;
1356
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1442
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1357
1443
  break;
1358
1444
  case 21: //HEAT FLOW
1359
1445
  button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
1360
1446
  deviceData.Device.Power = true;
1361
1447
  deviceData.Device.OperationModeZone1 = state ? 1 : button.previousValue;
1362
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1448
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1363
1449
  break;
1364
1450
  case 22: //HEAT CURVE
1365
1451
  button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
1366
1452
  deviceData.Device.Power = true;
1367
1453
  deviceData.Device.OperationModeZone1 = state ? 2 : button.previousValue;
1368
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1454
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1369
1455
  break;
1370
1456
  case 23: //COOL THERMOSTAT
1371
1457
  button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
1372
1458
  deviceData.Device.Power = true;
1373
1459
  deviceData.Device.OperationModeZone1 = state ? 3 : button.previousValue;
1374
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1460
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1375
1461
  break;
1376
1462
  case 24: //COOL FLOW
1377
1463
  button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
1378
1464
  deviceData.Device.Power = true;
1379
1465
  deviceData.Device.OperationModeZone1 = state ? 4 : button.previousValue;
1380
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1466
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1381
1467
  break;
1382
1468
  case 25: //FLOOR DRY UP
1383
1469
  button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
1384
1470
  deviceData.Device.Power = true;
1385
1471
  deviceData.Device.OperationModeZone1 = state ? 5 : button.previousValue;
1386
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1472
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
1387
1473
  break;
1388
1474
  case 30: //PHYSICAL LOCK CONTROL
1389
1475
  deviceData.Device.ProhibitZone1 = state;
1390
- effectiveFlags = HeatPump.EffectiveFlags.ProhibitHeatingZone1;
1476
+ flag = HeatPump.EffectiveFlags.ProhibitHeatingZone1;
1391
1477
  break;
1392
1478
  case 40: //HOT WATER NORMAL/FORCE HOT WATER
1393
1479
  deviceData.Device.Power = true;
1394
1480
  deviceData.Device.ForcedHotWaterMode = state;
1395
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.ForcedHotWaterMode;
1481
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.ForcedHotWaterMode;
1396
1482
  break;
1397
1483
  case 41: //NORMAL/ECO
1398
1484
  deviceData.Device.Power = true;
1399
1485
  deviceData.Device.EcoHotWater = state;
1400
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.EcoHotWater;
1486
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.EcoHotWater;
1401
1487
  break;
1402
1488
  case 50: //PHYSICAL LOCK CONTROL
1403
1489
  deviceData.Device.ProhibitHotWater = state;
1404
- effectiveFlags = HeatPump.EffectiveFlags.ProhibitHotWater;
1490
+ flag = HeatPump.EffectiveFlags.ProhibitHotWater;
1405
1491
  break;
1406
1492
  case 60: //ZONE 2 HEAT THERMOSTAT
1407
1493
  button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
1408
1494
  deviceData.Device.Power = true;
1409
1495
  deviceData.Device.OperationModeZone2 = state ? 0 : button.previousValue;
1410
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1496
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1411
1497
  break;
1412
1498
  case 61: // HEAT FLOW
1413
1499
  button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
1414
1500
  deviceData.Device.Power = true;
1415
1501
  deviceData.Device.OperationModeZone2 = state ? 1 : button.previousValue;
1416
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1502
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1417
1503
  break;
1418
1504
  case 62: //HEAT CURVE
1419
1505
  button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
1420
1506
  deviceData.Device.Power = true;
1421
1507
  deviceData.Device.OperationModeZone2 = state ? 2 : button.previousValue;
1422
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1508
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1423
1509
  break;
1424
1510
  case 63: //COOL THERMOSTAT
1425
1511
  button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
1426
1512
  deviceData.Device.Power = true;
1427
1513
  deviceData.Device.OperationModeZone2 = state ? 3 : button.previousValue;
1428
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1514
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1429
1515
  break;
1430
1516
  case 64: //COOL FLOW
1431
1517
  button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
1432
1518
  deviceData.Device.Power = true;
1433
1519
  deviceData.Device.OperationModeZone2 = state ? 4 : button.previousValue;
1434
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1520
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1435
1521
  break;
1436
1522
  case 65: //FLOOR DRY UP
1437
1523
  button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
1438
1524
  deviceData.Device.Power = true;
1439
1525
  deviceData.Device.OperationModeZone2 = state ? 5 : button.previousValue;
1440
- effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1526
+ flag = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
1441
1527
  break;
1442
1528
  case 70: //PHYSICAL LOCK CONTROL
1443
1529
  deviceData.Device.ProhibitZone2 = state;
@@ -1448,7 +1534,7 @@ class DeviceAtw extends EventEmitter {
1448
1534
  break;
1449
1535
  };
1450
1536
 
1451
- await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, effectiveFlags);
1537
+ await this.melCloudAtw.send(this.accountType, this.displayType, deviceData, flag);
1452
1538
  if (this.logInfo) this.emit('info', `${state ? `Set: ${name}` : `Unset: ${name}, Set: ${button.previousValue}`}`);
1453
1539
  } catch (error) {
1454
1540
  if (this.logWarn) this.emit('warn', `Set button error: ${error}`);
@@ -1471,7 +1557,7 @@ class DeviceAtw extends EventEmitter {
1471
1557
  try {
1472
1558
  //melcloud device
1473
1559
  this.melCloudAtw = new MelCloudAtw(this.account, this.device, this.devicesFile, this.defaultTempsFile)
1474
- .on('deviceInfo', (manufacturer, modelIndoor, modelOutdoor, serialNumber, firmwareAppVersion, supportsHotWaterTank, supportsZone2) => {
1560
+ .on('deviceInfo', (modelIndoor, modelOutdoor, serialNumber, firmwareAppVersion, supportsHotWaterTank, supportsZone2) => {
1475
1561
  if (this.logDeviceInfo && this.displayDeviceInfo) {
1476
1562
  this.emit('devInfo', `---- ${this.deviceTypeText}: ${this.deviceName} ----`);
1477
1563
  this.emit('devInfo', `Account: ${this.accountName}`);
@@ -1479,7 +1565,7 @@ class DeviceAtw extends EventEmitter {
1479
1565
  if (modelOutdoor) this.emit('devInfo', `Outdoor: ${modelOutdoor}`);
1480
1566
  this.emit('devInfo', `Serial: ${serialNumber}`)
1481
1567
  this.emit('devInfo', `Firmware: ${firmwareAppVersion}`);
1482
- this.emit('devInfo', `Manufacturer: ${manufacturer}`);
1568
+ this.emit('devInfo', `Manufacturer: Mitsubishi`);
1483
1569
  this.emit('devInfo', '----------------------------------');
1484
1570
  this.emit('devInfo', `Zone 1: Yes`);
1485
1571
  this.emit('devInfo', `Hot Water Tank: ${supportsHotWaterTank ? 'Yes' : 'No'}`);
@@ -1489,7 +1575,7 @@ class DeviceAtw extends EventEmitter {
1489
1575
  }
1490
1576
 
1491
1577
  //accessory info
1492
- this.manufacturer = manufacturer;
1578
+ this.manufacturer = 'Mitsubishi';
1493
1579
  this.model = modelIndoor ? modelIndoor : modelOutdoor ? modelOutdoor : `${this.deviceTypeText} ${this.deviceId}`;
1494
1580
  this.serialNumber = serialNumber.toString();
1495
1581
  this.firmwareRevision = firmwareAppVersion.toString();
@@ -1507,10 +1593,12 @@ class DeviceAtw extends EventEmitter {
1507
1593
  const supportStandbyKey = accountTypeMelcloud ? 'ModelSupportsStandbyMode' : 'HasStandby';
1508
1594
 
1509
1595
  //presets schedule
1596
+ const presetsOnServer = deviceData.Presets ?? [];
1510
1597
  const scheduleEnabled = deviceData.ScheduleEnabled;
1511
1598
  const schedulesOnServer = deviceData.Schedule ?? [];
1512
- const presetsOnServer = deviceData.Presets ?? [];
1513
- const holidayModeEnabled = deviceData.HolidayMode?.Enabled;
1599
+ const scenesOnServer = deviceData.Scenes ?? [];
1600
+ const holidayMode = deviceData.Device.HolidayMode;
1601
+ const holidayModeEnabled = accountTypeMelcloud ? holidayMode : deviceData.HolidayMode?.Enabled;
1514
1602
  const holidayModeActive = deviceData.HolidayMode?.Active ?? false;
1515
1603
 
1516
1604
  //device info
@@ -1545,12 +1633,11 @@ class DeviceAtw extends EventEmitter {
1545
1633
 
1546
1634
  //heat pump
1547
1635
  const heatPumpName = 'Heat Pump';
1548
- const power = deviceData.Device.Power ?? false;
1636
+ const power = deviceData.Device.Power;
1549
1637
  const inStandbyMode = deviceData.Device.InStandbyMode;
1550
1638
  const unitStatus = deviceData.Device.UnitStatus ?? 0;
1551
1639
  const operationMode = deviceData.Device.OperationMode;
1552
1640
  const outdoorTemperature = deviceData.Device.OutdoorTemperature;
1553
- const holidayMode = deviceData.Device.HolidayMode ?? false;
1554
1641
  const flowTemperatureHeatPump = deviceData.Device.FlowTemperature;
1555
1642
  const returnTemperatureHeatPump = deviceData.Device.ReturnTemperature;
1556
1643
  const isConnected = accountTypeMelcloud ? !deviceData.Device[connectKey] : deviceData.Device[connectKey];
@@ -1594,7 +1681,8 @@ class DeviceAtw extends EventEmitter {
1594
1681
  const obj = {
1595
1682
  presets: presetsOnServer,
1596
1683
  schedules: schedulesOnServer,
1597
- power: power ? 1 : 0,
1684
+ scenes: scenesOnServer,
1685
+ power: power,
1598
1686
  inStandbyMode: inStandbyMode,
1599
1687
  unitStatus: unitStatus,
1600
1688
  idleZone1: idleZone1,
@@ -1880,11 +1968,11 @@ class DeviceAtw extends EventEmitter {
1880
1968
  let operationModeText = '';
1881
1969
  switch (i) {
1882
1970
  case caseHeatPump: //Heat Pump - HEAT, COOL, OFF
1883
- this.emit('info', `${heatPumpName}, Power: ${power ? 'ON' : 'OFF'}`)
1971
+ this.emit('info', `${heatPumpName}, Power: ${power ? 'On' : 'Off'}`)
1884
1972
  this.emit('info', `${heatPumpName}, Operation mode: ${HeatPump.SystemMapEnumToString[unitStatus]}`);
1885
1973
  this.emit('info', `${heatPumpName},'Outdoor temperature: ${roomTemperature}${obj.temperatureUnit}`);
1886
1974
  this.emit('info', `${heatPumpName}, Temperature display unit: ${obj.temperatureUnit}`);
1887
- this.emit('info', `${heatPumpName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1975
+ this.emit('info', `${heatPumpName}, Lock physical controls: ${lockPhysicalControl ? 'Locked' : 'Unlocked'}`);
1888
1976
  break;
1889
1977
  case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1890
1978
  operationModeText = idleZone1 ? HeatPump.ZoneOperationMapEnumToString[6] : HeatPump.ZoneOperationMapEnumToString[operationModeZone1];
@@ -1892,7 +1980,7 @@ class DeviceAtw extends EventEmitter {
1892
1980
  this.emit('info', `${zone1Name}, Temperature: ${roomTemperature}${obj.temperatureUnit}`);
1893
1981
  this.emit('info', `${zone1Name}, Target temperature: ${setTemperature}${obj.temperatureUnit}`)
1894
1982
  this.emit('info', `${zone1Name}, Temperature display unit: ${obj.temperatureUnit}`);
1895
- this.emit('info', `${zone1Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1983
+ this.emit('info', `${zone1Name}, Lock physical controls: ${lockPhysicalControl ? 'Locked' : 'Unlocked'}`);
1896
1984
  break;
1897
1985
  case caseHotWater: //Hot Water - AUTO, HEAT NOW
1898
1986
  operationModeText = operationMode === 1 ? HeatPump.ForceDhwMapEnumToString[1] : HeatPump.ForceDhwMapEnumToString[forcedHotWaterMode ? 1 : 0];
@@ -1900,7 +1988,7 @@ class DeviceAtw extends EventEmitter {
1900
1988
  this.emit('info', `${hotWaterName}, Temperature: ${roomTemperature}${obj.temperatureUnit}`);
1901
1989
  this.emit('info', `${hotWaterName}, Target temperature: ${setTemperature}${obj.temperatureUnit}`)
1902
1990
  this.emit('info', `${hotWaterName}, Temperature display unit: ${obj.temperatureUnit}`);
1903
- this.emit('info', `${hotWaterName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1991
+ this.emit('info', `${hotWaterName}, Lock physical controls: ${lockPhysicalControl ? 'Locked' : 'Unlocked'}`);
1904
1992
  break;
1905
1993
  case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1906
1994
  operationModeText = idleZone2 ? HeatPump.ZoneOperationMapEnumToString[6] : HeatPump.ZoneOperationMapEnumToString[operationModeZone2];
@@ -1908,7 +1996,7 @@ class DeviceAtw extends EventEmitter {
1908
1996
  this.emit('info', `${zone2Name}, Temperature: ${roomTemperature}${obj.temperatureUnit}`);
1909
1997
  this.emit('info', `${zone2Name}, Target temperature: ${setTemperature}${obj.temperatureUnit}`)
1910
1998
  this.emit('info', `${zone2Name}, Temperature display unit: ${obj.temperatureUnit}`);
1911
- this.emit('info', `${zone2Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1999
+ this.emit('info', `${zone2Name}, Lock physical controls: ${lockPhysicalControl ? 'Locked' : 'Unlocked'}`);
1912
2000
  break;
1913
2001
  };
1914
2002
  };
@@ -2016,6 +2104,7 @@ class DeviceAtw extends EventEmitter {
2016
2104
  if (this.presets.length > 0) {
2017
2105
  this.presets.forEach((preset, i) => {
2018
2106
  const presetData = presetsOnServer.find(p => p.ID === preset.id);
2107
+ const characteristicType = preset.characteristicType;
2019
2108
 
2020
2109
  preset.state = presetData ? (presetData.Power === power
2021
2110
  && presetData.EcoHotWater === ecoHotWater
@@ -2030,23 +2119,50 @@ class DeviceAtw extends EventEmitter {
2030
2119
  && presetData.SetCoolFlowTemperatureZone1 === setCoolFlowTemperatureZone1
2031
2120
  && presetData.SetCoolFlowTemperatureZone2 === setCoolFlowTemperatureZone2) : false;
2032
2121
 
2033
- const characteristicType = preset.characteristicType;
2034
- this.presetsServices?.[i]?.updateCharacteristic(characteristicType, preset.state);
2122
+ //control
2123
+ if (preset.displayType > 3) {
2124
+ this.presetControlServices?.[i]?.updateCharacteristic(Characteristic.On, preset.state);
2125
+ }
2126
+
2127
+ //sencor
2128
+ this.presetControlSensorServices?.[i]?.updateCharacteristic(characteristicType, preset.state);
2035
2129
  });
2036
2130
  };
2037
2131
 
2038
2132
  //schedules
2039
2133
  if (this.schedules.length > 0 && scheduleEnabled !== null) {
2040
2134
  this.schedules.forEach((schedule, i) => {
2041
- //control
2042
- if (i === 0) this.schedulesControlService?.updateCharacteristic(Characteristic.On, scheduleEnabled);
2043
-
2044
- //sensors
2045
2135
  const scheduleData = schedulesOnServer.find(s => s.Id === schedule.id);
2136
+ const characteristicType = schedule.characteristicType;
2046
2137
  schedule.state = scheduleEnabled ? scheduleData.Enabled ?? false : false;
2047
2138
 
2048
- const characteristicType = schedule.characteristicType;
2049
- this.schedulesServices?.[i]?.updateCharacteristic(characteristicType, schedule.state);
2139
+ //control
2140
+ if (i === 0) {
2141
+ if (schedule.displayType > 3) {
2142
+ this.scheduleControlService?.updateCharacteristic(Characteristic.On, scheduleEnabled);
2143
+ }
2144
+ this.scheduleControlSensorService?.updateCharacteristic(characteristicType, scheduleEnabled);
2145
+ }
2146
+
2147
+ //sensor
2148
+ this.scheduleSensorServices?.[i]?.updateCharacteristic(characteristicType, schedule.state);
2149
+ });
2150
+ };
2151
+
2152
+ //schedules
2153
+ if (this.scenes.length > 0) {
2154
+ this.scenes.forEach((scene, i) => {
2155
+ const sceneData = scenesOnServer.find(s => s.Id === scene.id);
2156
+ scene.state = sceneData.Enabled;
2157
+
2158
+ //control
2159
+ if (scene.displayType > 3) {
2160
+ this.sceneControlServices?.[i]?.updateCharacteristic(Characteristic.On, scene.state);
2161
+ }
2162
+
2163
+ //sensor
2164
+ const characteristicType = scene.characteristicType;
2165
+ this.sceneControlSensorServices?.[i]?.updateCharacteristic(characteristicType, scene.state);
2050
2166
  });
2051
2167
  };
2052
2168
 
@@ -2065,7 +2181,7 @@ class DeviceAtw extends EventEmitter {
2065
2181
  button.state = power ? (operationMode === 1) : false;
2066
2182
  break;
2067
2183
  case 53: //HOLIDAY
2068
- button.state = power ? (holidayMode === true) : false;
2184
+ button.state = power ? (holidayModeEnabled === true) : false;
2069
2185
  break;
2070
2186
  case 10: //ALL ZONES PHYSICAL LOCK CONTROL
2071
2187
  button.state = power ? (prohibitZone1 === true && prohibitHotWater === true && prohibitZone2 === true) : false;