homebridge-melcloud-control 3.8.0-beta.8 → 3.8.0

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 (11) hide show
  1. package/CHANGELOG.md +6 -6
  2. package/README.md +1 -1
  3. package/config.schema.json +67 -19
  4. package/index.js +1 -1
  5. package/package.json +1 -1
  6. package/src/deviceata.js +26 -37
  7. package/src/deviceatw.js +826 -784
  8. package/src/deviceerv.js +24 -35
  9. package/src/melcloudata.js +1 -1
  10. package/src/melcloudatw.js +1 -1
  11. package/src/melclouderv.js +1 -1
package/src/deviceatw.js CHANGED
@@ -82,7 +82,6 @@ class DeviceAtw extends EventEmitter {
82
82
  const buttonServiceType = ['', Service.Outlet, Service.Switch, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor][displayType];
83
83
  const buttonCharacteristicType = ['', Characteristic.On, Characteristic.On, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState][displayType];
84
84
  button.name = button.name || 'Button'
85
- button.namePrefix = buttonNamePrefix;
86
85
  button.serviceType = buttonServiceType;
87
86
  button.characteristicType = buttonCharacteristicType;
88
87
  button.state = false;
@@ -95,7 +94,10 @@ class DeviceAtw extends EventEmitter {
95
94
  this.deviceData = {};
96
95
 
97
96
  //accessory
98
- this.accessory = { zones: [{}, {}, {}, {}] };
97
+ this.accessory = {
98
+ zones: [{}, {}, {}, {}],
99
+ zonesSensors: [{}, {}, {}, {}]
100
+ };
99
101
  this.accessory.useFahrenheit = useFahrenheit ? 1 : 0;
100
102
  this.accessory.temperatureUnit = TemperatureDisplayUnits[this.accessory.useFahrenheit];
101
103
  };
@@ -275,6 +277,7 @@ class DeviceAtw extends EventEmitter {
275
277
  async startImpulseGenerator() {
276
278
  try {
277
279
  //start impule generator
280
+ await new Promise(resolve => setTimeout(resolve, 1000));
278
281
  await this.melCloudAtw.impulseGenerator.start([{ name: 'checkState', sampling: this.refreshInterval }]);
279
282
  return true;
280
283
  } catch (error) {
@@ -287,19 +290,17 @@ class DeviceAtw extends EventEmitter {
287
290
  try {
288
291
  const presetsOnServer = this.accessory.presets;
289
292
  const zonesCount = this.accessory.zonesCount;
293
+ const caseHeatPump = this.accessory.caseHeatPump;
290
294
  const caseZone1 = this.accessory.caseZone1;
291
295
  const caseHotWater = this.accessory.caseHotWater;
292
296
  const caseZone2 = this.accessory.caseZone2;
293
297
  const heatCoolModes = this.accessory.heatCoolModes;
294
- const temperatureSensor = this.temperatureSensor;
295
- const temperatureSensorFlow = this.temperatureSensorFlow;
296
- const temperatureSensorReturn = this.temperatureSensorReturn;
297
- const temperatureSensorFlowZone1 = this.temperatureSensorFlowZone1;
298
- const temperatureSensorReturnZone1 = this.temperatureSensorReturnZone1;
299
- const temperatureSensorFlowWaterTank = this.temperatureSensorFlowWaterTank;
300
- const temperatureSensorReturnWaterTank = this.temperatureSensorReturnWaterTank;
301
- const temperatureSensorFlowZone2 = this.temperatureSensorFlowZone2;
302
- const temperatureSensorReturnZone2 = this.temperatureSensorReturnZone2;
298
+
299
+ const zonesSensorsCount = this.accessory.sensorsCount;
300
+ const caseHeatPumpSensor = this.accessory.caseHeatPumpSensor;
301
+ const caseZone1Sensor = this.accessory.caseZone1Sensor;
302
+ const caseHotWaterSensor = this.accessory.caseHotWaterSensor;
303
+ const caseZone2Sensor = this.accessory.caseZone2Sensor;
303
304
 
304
305
  //accessory
305
306
  const debug = this.enableDebugMode ? this.emit('debug', `Prepare accessory`) : false;
@@ -318,747 +319,754 @@ class DeviceAtw extends EventEmitter {
318
319
  .setCharacteristic(Characteristic.ConfiguredName, accessoryName);
319
320
 
320
321
  //services
321
- this.melCloudServices = [];
322
- for (let i = 0; i < zonesCount; i++) {
323
- const zoneName = this.accessory.zones[i].name
324
- const serviceName = `${deviceTypeText} ${accessoryName}: ${zoneName}`;
325
- switch (this.displayMode) {
326
- case 1: //Heater Cooler
327
- const debug = this.enableDebugMode ? this.emit('debug', `Prepare heather/cooler ${zoneName} service`) : false;
328
- const melCloudService = new Service.HeaterCooler(serviceName, `HeaterCooler ${deviceId} ${i}`);
329
- melCloudService.setPrimaryService(true);
330
- melCloudService.getCharacteristic(Characteristic.Active)
331
- .onGet(async () => {
332
- const state = this.accessory.power;
333
- return state;
334
- })
335
- .onSet(async (state) => {
336
- try {
337
- switch (i) {
338
- case 0: //Heat Pump
339
- deviceData.Device.Power = [false, true][state];
340
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
341
- await this.melCloudAtw.send(deviceData);
342
- const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set power: ${state ? 'ON' : 'OFF'}`);
343
- break;
322
+ if (zonesCount > 0) {
323
+ this.melCloudServices = [];
324
+ this.accessory.zones.forEach((zone, i) => {
325
+ const zoneName = zone.name
326
+ const serviceName = `${deviceTypeText} ${accessoryName}: ${zoneName}`;
327
+ switch (this.displayMode) {
328
+ case 1: //Heater Cooler
329
+ const debug = this.enableDebugMode ? this.emit('debug', `Prepare heather/cooler ${zoneName} service`) : false;
330
+ const melCloudService = new Service.HeaterCooler(serviceName, `HeaterCooler ${deviceId} ${i}`);
331
+ melCloudService.setPrimaryService(true);
332
+ melCloudService.getCharacteristic(Characteristic.Active)
333
+ .onGet(async () => {
334
+ const state = this.accessory.power;
335
+ return state;
336
+ })
337
+ .onSet(async (state) => {
338
+ try {
339
+ switch (i) {
340
+ case 0: //Heat Pump
341
+ deviceData.Device.Power = [false, true][state];
342
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
343
+ await this.melCloudAtw.send(deviceData);
344
+ const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set power: ${state ? 'ON' : 'OFF'}`);
345
+ break;
346
+ };
347
+ } catch (error) {
348
+ this.emit('warn', `Set power error: ${error}`);
344
349
  };
345
- } catch (error) {
346
- this.emit('warn', `Set power error: ${error}`);
347
- };
348
- });
349
- melCloudService.getCharacteristic(Characteristic.CurrentHeaterCoolerState)
350
- .onGet(async () => {
351
- const value = this.accessory.zones[i].currentOperationMode;
352
- return value;
353
- });
354
- melCloudService.getCharacteristic(Characteristic.TargetHeaterCoolerState)
355
- .setProps({
356
- minValue: this.accessory.zones[i].operationModesSetPropsMinValue,
357
- maxValue: this.accessory.zones[i].operationModesSetPropsMaxValue,
358
- validValues: this.accessory.zones[i].operationModesSetPropsValidValues
359
- })
360
- .onGet(async () => {
361
- const value = this.accessory.zones[i].targetOperationMode;
362
- return value;
363
- })
364
- .onSet(async (value) => {
365
- try {
366
- let operationModeText = '';
367
- switch (i) {
368
- case 0: //Heat Pump - ON, HEAT, COOL
369
- switch (value) {
370
- case 0: //AUTO
371
- deviceData.Device.Power = true;
372
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
373
- break;
374
- case 1: //HEAT
375
- deviceData.Device.Power = true;
376
- deviceData.Device.UnitStatus = 0;
377
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
378
- break;
379
- case 2: //COOL
380
- deviceData.Device.Power = true;
381
- deviceData.Device.UnitStatus = 1;
382
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
350
+ });
351
+ melCloudService.getCharacteristic(Characteristic.CurrentHeaterCoolerState)
352
+ .onGet(async () => {
353
+ const value = zone.currentOperationMode;
354
+ return value;
355
+ });
356
+ melCloudService.getCharacteristic(Characteristic.TargetHeaterCoolerState)
357
+ .setProps({
358
+ minValue: zone.operationModesSetPropsMinValue,
359
+ maxValue: zone.operationModesSetPropsMaxValue,
360
+ validValues: zone.operationModesSetPropsValidValues
361
+ })
362
+ .onGet(async () => {
363
+ const value = zone.targetOperationMode;
364
+ return value;
365
+ })
366
+ .onSet(async (value) => {
367
+ try {
368
+ let operationModeText = '';
369
+ switch (i) {
370
+ case caseHeatPump: //Heat Pump - ON, HEAT, COOL
371
+ switch (value) {
372
+ case caseHeatPump: //AUTO
373
+ deviceData.Device.Power = true;
374
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
375
+ break;
376
+ case 1: //HEAT
377
+ deviceData.Device.Power = true;
378
+ deviceData.Device.UnitStatus = 0;
379
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
380
+ break;
381
+ case 2: //COOL
382
+ deviceData.Device.Power = true;
383
+ deviceData.Device.UnitStatus = 1;
384
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
385
+ break;
386
+ };
387
+ operationModeText = [HeatPump.System[0], HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
388
+ break;
389
+ case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
390
+ switch (value) {
391
+ case 0: //AUTO - HEAT CURVE
392
+ deviceData.Device.OperationModeZone1 = 2;
393
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
394
+ break;
395
+ case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
396
+ deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
397
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
398
+ break;
399
+ case 2: //COOL - HEAT FLOW / COOL FLOW
400
+ deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
401
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
402
+ break;
403
+ };
404
+ operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
405
+ break;
406
+ case caseHotWater: //Hot Water - AUTO, HEAT NOW
407
+ switch (value) {
408
+ case 0: //AUTO
409
+ deviceData.Device.ForcedHotWaterMode = false;
410
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
411
+ break;
412
+ case 1: //HEAT
413
+ deviceData.Device.ForcedHotWaterMode = true;
414
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
415
+ break;
416
+ case 2: //COOL
417
+ deviceData.Device.ForcedHotWaterMode = false;
418
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
419
+ break
420
+ };
421
+ operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
422
+ break;
423
+ case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
424
+ switch (value) {
425
+ case 0: //AUTO
426
+ deviceData.Device.OperationModeZone2 = 2;
427
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
428
+ break;
429
+ case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
430
+ deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
431
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
432
+ break;
433
+ case 2: //COOL - HEAT FLOW / COOL FLOW
434
+ deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
435
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
436
+ break;
437
+ };
438
+ operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
439
+ break;
440
+ };
441
+
442
+ await this.melCloudAtw.send(deviceData);
443
+ const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set operation mode: ${operationModeText}`);
444
+ } catch (error) {
445
+ this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
446
+ };
447
+ });
448
+ melCloudService.getCharacteristic(Characteristic.CurrentTemperature)
449
+ .setProps({
450
+ minValue: -35,
451
+ maxValue: 150,
452
+ minStep: 0.5
453
+ })
454
+ .onGet(async () => {
455
+ const value = zone.roomTemperature;
456
+ return value;
457
+ });
458
+ //only for heat/cool, only cool and not for hot water tank
459
+ if ((heatCoolModes === 0 || heatCoolModes === 2) && i !== caseHotWater) {
460
+ melCloudService.getCharacteristic(Characteristic.CoolingThresholdTemperature)
461
+ .setProps({
462
+ minValue: zone.temperaturesSetPropsMinValue,
463
+ maxValue: zone.temperaturesSetPropsMaxValue,
464
+ minStep: this.accessory.temperatureIncrement
465
+ })
466
+ .onGet(async () => {
467
+ const value = zone.setTemperature;
468
+ return value;
469
+ })
470
+ .onSet(async (value) => {
471
+ try {
472
+ switch (i) {
473
+ case caseHeatPump: //Heat Pump
474
+ //deviceData.Device.SetTemperatureZone1 = value;
475
+ //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
383
476
  break;
384
- };
385
- operationModeText = [HeatPump.System[0], HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
386
- break;
387
- case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
388
- switch (value) {
389
- case 0: //AUTO - HEAT CURVE
390
- deviceData.Device.OperationModeZone1 = 2;
391
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
477
+ case caseZone1: //Zone 1
478
+ switch (zone.operationMode) {
479
+ case 1: //HEAT FLOW
480
+ deviceData.Device.SetHeatFlowTemperatureZone1 = value;
481
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
482
+ break;
483
+ case 4: //COOL FLOW
484
+ deviceData.Device.SetCoolFlowTemperatureZone1 = value;
485
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
486
+ break;
487
+ default:
488
+ deviceData.Device.SetTemperatureZone1 = value;
489
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
490
+ break
491
+ };
392
492
  break;
393
- case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
394
- deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
395
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
493
+ case caseHotWater: //Hot Water
494
+ deviceData.Device.SetTankWaterTemperature = value;
495
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
396
496
  break;
397
- case 2: //COOL - HEAT FLOW / COOL FLOW
398
- deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
399
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
497
+ case caseZone2: //Zone 2
498
+ switch (zone.operationMode) {
499
+ case 1: //HEAT FLOW
500
+ deviceData.Device.SetHeatFlowTemperatureZone2 = value;
501
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
502
+ break;
503
+ case 4: //COOL FLOW
504
+ deviceData.Device.SetCoolFlowTemperatureZone2 = value;
505
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
506
+ break;
507
+ default:
508
+ deviceData.Device.SetTemperatureZone2 = value;
509
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
510
+ break
511
+ };
400
512
  break;
401
513
  };
402
- operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
403
- break;
404
- case caseHotWater: //Hot Water - AUTO, HEAT NOW
405
- switch (value) {
406
- case 0: //AUTO
407
- deviceData.Device.ForcedHotWaterMode = false;
408
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
409
- break;
410
- case 1: //HEAT
411
- deviceData.Device.ForcedHotWaterMode = true;
412
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
514
+
515
+ const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
516
+ const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
517
+ } catch (error) {
518
+ this.emit('warn', `${zoneName}, Set cooling threshold temperature error: ${error}`);
519
+ };
520
+ });
521
+ };
522
+ //device can heat/cool or only heat
523
+ if (heatCoolModes === 0 || heatCoolModes === 1) {
524
+ melCloudService.getCharacteristic(Characteristic.HeatingThresholdTemperature)
525
+ .setProps({
526
+ minValue: zone.temperaturesSetPropsMinValue,
527
+ maxValue: zone.temperaturesSetPropsMaxValue,
528
+ minStep: this.accessory.temperatureIncrement
529
+ })
530
+ .onGet(async () => {
531
+ const value = zone.setTemperature;
532
+ return value;
533
+ })
534
+ .onSet(async (value) => {
535
+ try {
536
+ switch (i) {
537
+ case caseHeatPump: //Heat Pump
538
+ //deviceData.Device.SetTemperatureZone1 = value;
539
+ //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
413
540
  break;
414
- case 2: //COOL
415
- deviceData.Device.ForcedHotWaterMode = false;
416
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
417
- break
418
- };
419
- operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
420
- break;
421
- case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
422
- switch (value) {
423
- case 0: //AUTO
424
- deviceData.Device.OperationModeZone2 = 2;
425
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
541
+ case caseZone1: //Zone 1
542
+ switch (zone.operationMode) {
543
+ case 1: //HEAT FLOW
544
+ deviceData.Device.SetHeatFlowTemperatureZone1 = value;
545
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
546
+ break;
547
+ case 4: //COOL FLOW
548
+ deviceData.Device.SetCoolFlowTemperatureZone1 = value;
549
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
550
+ break;
551
+ default:
552
+ deviceData.Device.SetTemperatureZone1 = value;
553
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
554
+ break
555
+ };
426
556
  break;
427
- case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
428
- deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
429
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
557
+ case caseHotWater: //Hot Water
558
+ deviceData.Device.SetTankWaterTemperature = value;
559
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
430
560
  break;
431
- case 2: //COOL - HEAT FLOW / COOL FLOW
432
- deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
433
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
561
+ case caseZone2: //Zone 2
562
+ switch (zone.operationMode) {
563
+ case 1: //HEAT FLOW
564
+ deviceData.Device.SetHeatFlowTemperatureZone2 = value;
565
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
566
+ break;
567
+ case 4: //COOL FLOW
568
+ deviceData.Device.SetCoolFlowTemperatureZone2 = value;
569
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
570
+ break;
571
+ default:
572
+ deviceData.Device.SetTemperatureZone2 = value;
573
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
574
+ break
575
+ };
434
576
  break;
435
577
  };
436
- operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
437
- break;
438
- };
439
578
 
440
- await this.melCloudAtw.send(deviceData);
441
- const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set operation mode: ${operationModeText}`);
442
- } catch (error) {
443
- this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
444
- };
445
- });
446
- melCloudService.getCharacteristic(Characteristic.CurrentTemperature)
447
- .setProps({
448
- minValue: -35,
449
- maxValue: 150,
450
- minStep: 0.5
451
- })
452
- .onGet(async () => {
453
- const value = this.accessory.zones[i].roomTemperature;
454
- return value;
455
- });
456
- //only for heat/cool, only cool and not for hot water tank
457
- if ((heatCoolModes === 0 || heatCoolModes === 2) && i !== caseHotWater) {
458
- melCloudService.getCharacteristic(Characteristic.CoolingThresholdTemperature)
459
- .setProps({
460
- minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
461
- maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
462
- minStep: this.accessory.temperatureIncrement
463
- })
579
+ const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
580
+ const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
581
+ } catch (error) {
582
+ this.emit('warn', `${zoneName}, Set heating threshold temperature error: ${error}`);
583
+ };
584
+ });
585
+ };
586
+ melCloudService.getCharacteristic(Characteristic.LockPhysicalControls)
464
587
  .onGet(async () => {
465
- const value = this.accessory.zones[i].setTemperature;
588
+ const value = zone.lockPhysicalControl;
466
589
  return value;
467
590
  })
468
591
  .onSet(async (value) => {
469
592
  try {
593
+ value = value ? true : false;
470
594
  switch (i) {
471
- case 0: //Heat Pump
472
- //deviceData.Device.SetTemperatureZone1 = value;
473
- //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
595
+ case caseHeatPump: //Heat Pump
596
+ deviceData.Device.ProhibitZone1 = value;
597
+ deviceData.Device.ProhibitHotWater = value;
598
+ deviceData.Device.ProhibitZone2 = value;
599
+ HeatPump.EffectiveFlags.ProhibitHeatingZone1 + HeatPump.EffectiveFlags.ProhibitHotWater + HeatPump.EffectiveFlags.ProhibitHeatingZone2;
474
600
  break;
475
601
  case caseZone1: //Zone 1
476
- switch (this.accessory.zones[i].operationMode) {
477
- case 1: //HEAT FLOW
478
- deviceData.Device.SetHeatFlowTemperatureZone1 = value;
479
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
480
- break;
481
- case 4: //COOL FLOW
482
- deviceData.Device.SetCoolFlowTemperatureZone1 = value;
483
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
484
- break;
485
- default:
486
- deviceData.Device.SetTemperatureZone1 = value;
487
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
488
- break
489
- };
602
+ deviceData.Device.ProhibitZone1 = value;
603
+ HeatPump.EffectiveFlags.ProhibitHeatingZone1;
490
604
  break;
491
605
  case caseHotWater: //Hot Water
492
- deviceData.Device.SetTankWaterTemperature = value;
493
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
606
+ deviceData.Device.ProhibitHotWater = value;
607
+ HeatPump.EffectiveFlags.ProhibitHotWater;
494
608
  break;
495
609
  case caseZone2: //Zone 2
496
- switch (this.accessory.zones[i].operationMode) {
497
- case 1: //HEAT FLOW
498
- deviceData.Device.SetHeatFlowTemperatureZone2 = value;
499
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
500
- break;
501
- case 4: //COOL FLOW
502
- deviceData.Device.SetCoolFlowTemperatureZone2 = value;
503
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
504
- break;
505
- default:
506
- deviceData.Device.SetTemperatureZone2 = value;
507
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
508
- break
509
- };
610
+ deviceData.Device.ProhibitZone2 = value;
611
+ HeatPump.EffectiveFlags.ProhibitHeatingZone2;
510
612
  break;
511
613
  };
512
614
 
513
- const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
514
- const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
615
+ await this.melCloudAtw.send(deviceData);
616
+ const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set lock physical controls: ${value ? 'LOCK' : 'UNLOCK'}`);
515
617
  } catch (error) {
516
- this.emit('warn', `${zoneName}, Set cooling threshold temperature error: ${error}`);
618
+ this.emit('warn', `${zoneName}, Set lock physical controls error: ${error}`);
517
619
  };
518
620
  });
519
- };
520
- //device can heat/cool or only heat
521
- if (heatCoolModes === 0 || heatCoolModes === 1) {
522
- melCloudService.getCharacteristic(Characteristic.HeatingThresholdTemperature)
621
+ melCloudService.getCharacteristic(Characteristic.TemperatureDisplayUnits)
622
+ .onGet(async () => {
623
+ const value = this.accessory.useFahrenheit;
624
+ return value;
625
+ })
626
+ .onSet(async (value) => {
627
+ try {
628
+ accountInfo.UseFahrenheit = [false, true][value];
629
+ await this.melCloud.send(accountInfo);
630
+ this.accessory.useFahrenheit = value;
631
+ const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${TemperatureDisplayUnits[value]}`);
632
+ } catch (error) {
633
+ this.emit('warn', `Set temperature display unit error: ${error}`);
634
+ };
635
+ });
636
+ this.melCloudServices.push(melCloudService);
637
+ accessory.addService(melCloudService);
638
+ break;
639
+ case 2: //Thermostat
640
+ const debug3 = this.enableDebugMode ? this.emit('debug', `Prepare thermostat ${zoneName} service`) : false;
641
+ const melCloudServiceT = new Service.Thermostat(serviceName, `Thermostat ${deviceId} ${i}`);
642
+ melCloudServiceT.setPrimaryService(true);
643
+ melCloudServiceT.getCharacteristic(Characteristic.CurrentHeatingCoolingState)
644
+ .onGet(async () => {
645
+ const value = zone.currentOperationMode;
646
+ return value;
647
+ });
648
+ melCloudServiceT.getCharacteristic(Characteristic.TargetHeatingCoolingState)
523
649
  .setProps({
524
- minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
525
- maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
526
- minStep: this.accessory.temperatureIncrement
650
+ minValue: zone.operationModesSetPropsMinValue,
651
+ maxValue: zone.operationModesSetPropsMaxValue,
652
+ validValues: zone.operationModesSetPropsValidValues
527
653
  })
528
654
  .onGet(async () => {
529
- const value = this.accessory.zones[i].setTemperature;
655
+ const value = zone.targetOperationMode;
530
656
  return value;
531
657
  })
532
658
  .onSet(async (value) => {
533
659
  try {
660
+ let operationModeText = '';
534
661
  switch (i) {
535
- case 0: //Heat Pump
536
- //deviceData.Device.SetTemperatureZone1 = value;
537
- //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
662
+ case caseHeatPump: //Heat Pump - HEAT, COOL
663
+ switch (value) {
664
+ case 0: //OFF
665
+ deviceData.Device.Power = false;
666
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
667
+ break;
668
+ case 1: //HEAT
669
+ deviceData.Device.Power = true;
670
+ deviceData.Device.UnitStatus = 0;
671
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
672
+ break;
673
+ case 2: //COOL
674
+ deviceData.Device.Power = true;
675
+ deviceData.Device.UnitStatus = 1;
676
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
677
+ break;
678
+ case 3: //AUTO
679
+ deviceData.Device.Power = true;
680
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
681
+ break;
682
+ };
683
+ operationModeText = [HeatPump.System[0], HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
538
684
  break;
539
- case caseZone1: //Zone 1
540
- switch (this.accessory.zones[i].operationMode) {
541
- case 1: //HEAT FLOW
542
- deviceData.Device.SetHeatFlowTemperatureZone1 = value;
543
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
685
+ case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
686
+ switch (value) {
687
+ case 0: //OFF - HEAT CURVE
688
+ deviceData.Device.OperationModeZone1 = 2;
689
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
544
690
  break;
545
- case 4: //COOL FLOW
546
- deviceData.Device.SetCoolFlowTemperatureZone1 = value;
547
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
691
+ case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
692
+ deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
693
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
694
+ break;
695
+ case 2: //COOL - HEAT FLOW / COOL FLOW
696
+ deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
697
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
698
+ break;
699
+ case 3: //AUTO - HEAT CURVE
700
+ deviceData.Device.OperationModeZone1 = 2;
701
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
548
702
  break;
549
- default:
550
- deviceData.Device.SetTemperatureZone1 = value;
551
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
552
- break
553
703
  };
704
+ operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
554
705
  break;
555
- case caseHotWater: //Hot Water
556
- deviceData.Device.SetTankWaterTemperature = value;
557
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
706
+ case caseHotWater: //Hot Water - AUTO, HEAT NOW
707
+ switch (value) {
708
+ case 0: //OFF
709
+ deviceData.Device.ForcedHotWaterMode = false;
710
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
711
+ break;
712
+ case 1: //HEAT
713
+ deviceData.Device.ForcedHotWaterMode = true;
714
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
715
+ break;
716
+ case 2: //COOL
717
+ deviceData.Device.ForcedHotWaterMode = false;
718
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
719
+ break;
720
+ case 3: //AUTO
721
+ deviceData.Device.ForcedHotWaterMode = false;
722
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
723
+ break;
724
+ };
725
+ operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
558
726
  break;
559
- case caseZone2: //Zone 2
560
- switch (this.accessory.zones[i].operationMode) {
561
- case 1: //HEAT FLOW
562
- deviceData.Device.SetHeatFlowTemperatureZone2 = value;
563
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
727
+ case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
728
+ switch (value) {
729
+ case 0: //OFF - HEAT CURVE
730
+ deviceData.Device.OperationModeZone2 = 2;
731
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
564
732
  break;
565
- case 4: //COOL FLOW
566
- deviceData.Device.SetCoolFlowTemperatureZone2 = value;
567
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
733
+ case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
734
+ deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
735
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
736
+ break;
737
+ case 2: //COOL - HEAT FLOW / COOL FLOW
738
+ deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
739
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
740
+ break;
741
+ case 3: //AUTO - HEAT CURVE
742
+ deviceData.Device.OperationModeZone2 = 2;
743
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
568
744
  break;
569
- default:
570
- deviceData.Device.SetTemperatureZone2 = value;
571
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
572
- break
573
745
  };
746
+ operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
574
747
  break;
575
748
  };
576
749
 
577
- const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
578
- const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
750
+ await this.melCloudAtw.send(deviceData);
751
+ const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set operation mode: ${operationModeText}`);
579
752
  } catch (error) {
580
- this.emit('warn', `${zoneName}, Set heating threshold temperature error: ${error}`);
753
+ this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
581
754
  };
582
755
  });
583
- };
584
- melCloudService.getCharacteristic(Characteristic.LockPhysicalControls)
585
- .onGet(async () => {
586
- const value = this.accessory.zones[i].lockPhysicalControl;
587
- return value;
588
- })
589
- .onSet(async (value) => {
590
- try {
591
- value = value ? true : false;
592
- switch (i) {
593
- case 0: //Heat Pump
594
- deviceData.Device.ProhibitZone1 = value;
595
- deviceData.Device.ProhibitHotWater = value;
596
- deviceData.Device.ProhibitZone2 = value;
597
- HeatPump.EffectiveFlags.ProhibitHeatingZone1 + HeatPump.EffectiveFlags.ProhibitHotWater + HeatPump.EffectiveFlags.ProhibitHeatingZone2;
598
- break;
599
- case caseZone1: //Zone 1
600
- deviceData.Device.ProhibitZone1 = value;
601
- HeatPump.EffectiveFlags.ProhibitHeatingZone1;
602
- break;
603
- case caseHotWater: //Hot Water
604
- deviceData.Device.ProhibitHotWater = value;
605
- HeatPump.EffectiveFlags.ProhibitHotWater;
606
- break;
607
- case caseZone2: //Zone 2
608
- deviceData.Device.ProhibitZone2 = value;
609
- HeatPump.EffectiveFlags.ProhibitHeatingZone2;
610
- break;
611
- };
612
-
613
- await this.melCloudAtw.send(deviceData);
614
- const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set lock physical controls: ${value ? 'LOCK' : 'UNLOCK'}`);
615
- } catch (error) {
616
- this.emit('warn', `${zoneName}, Set lock physical controls error: ${error}`);
617
- };
618
- });
619
- melCloudService.getCharacteristic(Characteristic.TemperatureDisplayUnits)
620
- .onGet(async () => {
621
- const value = this.accessory.useFahrenheit;
622
- return value;
623
- })
624
- .onSet(async (value) => {
625
- try {
626
- accountInfo.UseFahrenheit = [false, true][value];
627
- await this.melCloud.send(accountInfo);
628
- this.accessory.useFahrenheit = value;
629
- const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${TemperatureDisplayUnits[value]}`);
630
- } catch (error) {
631
- this.emit('warn', `Set temperature display unit error: ${error}`);
632
- };
633
- });
634
- this.melCloudServices.push(melCloudService);
635
- accessory.addService(melCloudService);
636
- break;
637
- case 2: //Thermostat
638
- const debug3 = this.enableDebugMode ? this.emit('debug', `Prepare thermostat ${zoneName} service`) : false;
639
- const melCloudServiceT = new Service.Thermostat(serviceName, `Thermostat ${deviceId} ${i}`);
640
- melCloudServiceT.setPrimaryService(true);
641
- melCloudServiceT.getCharacteristic(Characteristic.CurrentHeatingCoolingState)
642
- .onGet(async () => {
643
- const value = this.accessory.zones[i].currentOperationMode;
644
- return value;
645
- });
646
- melCloudServiceT.getCharacteristic(Characteristic.TargetHeatingCoolingState)
647
- .setProps({
648
- minValue: this.accessory.zones[i].operationModesSetPropsMinValue,
649
- maxValue: this.accessory.zones[i].operationModesSetPropsMaxValue,
650
- validValues: this.accessory.zones[i].operationModesSetPropsValidValues
651
- })
652
- .onGet(async () => {
653
- const value = this.accessory.zones[i].targetOperationMode;
654
- return value;
655
- })
656
- .onSet(async (value) => {
657
- try {
658
- let operationModeText = '';
659
- switch (i) {
660
- case 0: //Heat Pump - HEAT, COOL
661
- switch (value) {
662
- case 0: //OFF
663
- deviceData.Device.Power = false;
664
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
665
- break;
666
- case 1: //HEAT
667
- deviceData.Device.Power = true;
668
- deviceData.Device.UnitStatus = 0;
669
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
670
- break;
671
- case 2: //COOL
672
- deviceData.Device.Power = true;
673
- deviceData.Device.UnitStatus = 1;
674
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
675
- break;
676
- case 3: //AUTO
677
- deviceData.Device.Power = true;
678
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
679
- break;
680
- };
681
- operationModeText = [HeatPump.System[0], HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
682
- break;
683
- case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
684
- switch (value) {
685
- case 0: //OFF - HEAT CURVE
686
- deviceData.Device.OperationModeZone1 = 2;
687
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
688
- break;
689
- case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
690
- deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
691
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
692
- break;
693
- case 2: //COOL - HEAT FLOW / COOL FLOW
694
- deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
695
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
696
- break;
697
- case 3: //AUTO - HEAT CURVE
698
- deviceData.Device.OperationModeZone1 = 2;
699
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
700
- break;
701
- };
702
- operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
703
- break;
704
- case caseHotWater: //Hot Water - AUTO, HEAT NOW
705
- switch (value) {
706
- case 0: //OFF
707
- deviceData.Device.ForcedHotWaterMode = false;
708
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
709
- break;
710
- case 1: //HEAT
711
- deviceData.Device.ForcedHotWaterMode = true;
712
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
713
- break;
714
- case 2: //COOL
715
- deviceData.Device.ForcedHotWaterMode = false;
716
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
717
- break;
718
- case 3: //AUTO
719
- deviceData.Device.ForcedHotWaterMode = false;
720
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
721
- break;
722
- };
723
- operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
724
- break;
725
- case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
726
- switch (value) {
727
- case 0: //OFF - HEAT CURVE
728
- deviceData.Device.OperationModeZone2 = 2;
729
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
730
- break;
731
- case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
732
- deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
733
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
734
- break;
735
- case 2: //COOL - HEAT FLOW / COOL FLOW
736
- deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
737
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
738
- break;
739
- case 3: //AUTO - HEAT CURVE
740
- deviceData.Device.OperationModeZone2 = 2;
741
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
742
- break;
743
- };
744
- operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
745
- break;
746
- };
747
-
748
- await this.melCloudAtw.send(deviceData);
749
- const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set operation mode: ${operationModeText}`);
750
- } catch (error) {
751
- this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
752
- };
753
- });
754
- melCloudServiceT.getCharacteristic(Characteristic.CurrentTemperature)
755
- .setProps({
756
- minValue: -35,
757
- maxValue: 150,
758
- minStep: 0.5
759
- })
760
- .onGet(async () => {
761
- const value = this.accessory.zones[i].roomTemperature;
762
- return value;
763
- });
764
- melCloudServiceT.getCharacteristic(Characteristic.TargetTemperature)
765
- .setProps({
766
- minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
767
- maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
768
- minStep: this.accessory.temperatureIncrement
769
- })
770
- .onGet(async () => {
771
- const value = this.accessory.zones[i].setTemperature;
772
- return value;
773
- })
774
- .onSet(async (value) => {
775
- try {
776
- switch (i) {
777
- case 0: //Heat Pump
778
- //deviceData.Device.SetTemperatureZone1 = value;
779
- //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
780
- break;
781
- case caseZone1: //Zone 1
782
- deviceData.Device.SetTemperatureZone1 = value;
783
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
784
- break;
785
- case caseHotWater: //Hot Water
786
- deviceData.Device.SetTankWaterTemperature = value;
787
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
788
- break;
789
- case caseZone2: //Zone 2
790
- deviceData.Device.SetTemperatureZone2 = value;
791
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
792
- break;
793
- };
794
-
795
- const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
796
- const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set temperature: ${value}${this.accessory.temperatureUnit}`);
797
- } catch (error) {
798
- this.emit('warn', `${zoneName}, Set temperature error: ${error}`);
799
- };
800
- });
801
- melCloudServiceT.getCharacteristic(Characteristic.TemperatureDisplayUnits)
802
- .onGet(async () => {
803
- const value = this.accessory.useFahrenheit;
804
- return value;
805
- })
806
- .onSet(async (value) => {
807
- try {
808
- accountInfo.UseFahrenheit = [false, true][value];
809
- await this.melCloud.send(accountInfo);
810
- this.accessory.useFahrenheit = value;
811
- const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${TemperatureDisplayUnits[value]}`);
812
- } catch (error) {
813
- this.emit('warn', `Set temperature display unit error: ${error}`);
814
- };
815
- });
816
- this.melCloudServices.push(melCloudServiceT);
817
- accessory.addService(melCloudServiceT);
818
- break;
819
- };
820
-
821
- //temperature sensor services zones
822
- switch (i) {
823
- case 0: //Heat Pump
824
- if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
825
- const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
826
- this.roomTemperatureSensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
827
- this.roomTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
828
- this.roomTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
829
- this.roomTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
756
+ melCloudServiceT.getCharacteristic(Characteristic.CurrentTemperature)
830
757
  .setProps({
831
758
  minValue: -35,
832
759
  maxValue: 150,
833
760
  minStep: 0.5
834
761
  })
835
762
  .onGet(async () => {
836
- const state = this.accessory.zones[i].roomTemperature;
837
- return state;
838
- })
839
- accessory.addService(this.roomTemperatureSensorService);
840
- };
841
-
842
- if (temperatureSensorFlow && this.accessory.zones[i].flowTemperature !== null) {
843
- const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature sensor service`) : false;
844
- this.flowTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
845
- this.flowTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
846
- this.flowTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
847
- this.flowTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
763
+ const value = zone.roomTemperature;
764
+ return value;
765
+ });
766
+ melCloudServiceT.getCharacteristic(Characteristic.TargetTemperature)
848
767
  .setProps({
849
- minValue: -35,
850
- maxValue: 150,
851
- minStep: 0.5
768
+ minValue: zone.temperaturesSetPropsMinValue,
769
+ maxValue: zone.temperaturesSetPropsMaxValue,
770
+ minStep: this.accessory.temperatureIncrement
852
771
  })
853
772
  .onGet(async () => {
854
- const state = this.accessory.zones[i].flowTemperature;
855
- return state;
773
+ const value = zone.setTemperature;
774
+ return value;
856
775
  })
857
- accessory.addService(this.flowTemperatureSensorService);
776
+ .onSet(async (value) => {
777
+ try {
778
+ switch (i) {
779
+ case caseHeatPump: //Heat Pump
780
+ //deviceData.Device.SetTemperatureZone1 = value;
781
+ //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
782
+ break;
783
+ case caseZone1: //Zone 1
784
+ deviceData.Device.SetTemperatureZone1 = value;
785
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
786
+ break;
787
+ case caseHotWater: //Hot Water
788
+ deviceData.Device.SetTankWaterTemperature = value;
789
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
790
+ break;
791
+ case caseZone2: //Zone 2
792
+ deviceData.Device.SetTemperatureZone2 = value;
793
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
794
+ break;
795
+ };
858
796
 
859
- };
860
- if (temperatureSensorReturn && this.accessory.zones[i].returnTemperature !== null) {
861
- const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature sensor service`) : false;
862
- this.returnTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
863
- this.returnTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
864
- this.returnTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
865
- this.returnTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
866
- .setProps({
867
- minValue: -35,
868
- maxValue: 150,
869
- minStep: 0.5
870
- })
871
- .onGet(async () => {
872
- const state = this.accessory.zones[i].returnTemperature;
873
- return state;
874
- })
875
- accessory.addService(this.returnTemperatureSensorService);
876
- };
877
- break;
878
- case caseZone1: //Zone 1
879
- if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
880
- const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
881
- this.roomTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
882
- this.roomTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
883
- this.roomTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
884
- this.roomTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
885
- .setProps({
886
- minValue: -35,
887
- maxValue: 150,
888
- minStep: 0.5
889
- })
797
+ const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
798
+ const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set temperature: ${value}${this.accessory.temperatureUnit}`);
799
+ } catch (error) {
800
+ this.emit('warn', `${zoneName}, Set temperature error: ${error}`);
801
+ };
802
+ });
803
+ melCloudServiceT.getCharacteristic(Characteristic.TemperatureDisplayUnits)
890
804
  .onGet(async () => {
891
- const state = this.accessory.zones[i].roomTemperature;
892
- return state;
805
+ const value = this.accessory.useFahrenheit;
806
+ return value;
893
807
  })
894
- accessory.addService(this.roomTemperatureZone1SensorService);
895
- };
808
+ .onSet(async (value) => {
809
+ try {
810
+ accountInfo.UseFahrenheit = [false, true][value];
811
+ await this.melCloud.send(accountInfo);
812
+ this.accessory.useFahrenheit = value;
813
+ const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${TemperatureDisplayUnits[value]}`);
814
+ } catch (error) {
815
+ this.emit('warn', `Set temperature display unit error: ${error}`);
816
+ };
817
+ });
818
+ this.melCloudServices.push(melCloudServiceT);
819
+ accessory.addService(melCloudServiceT);
820
+ break;
821
+ };
822
+ });
823
+ };
896
824
 
897
- if (temperatureSensorFlowZone1 && this.accessory.zones[i].flowTemperature !== null) {
898
- const debug2 = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature zone 1 sensor service`) : false;
899
- this.flowTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
900
- this.flowTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
901
- this.flowTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
902
- this.flowTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
903
- .setProps({
904
- minValue: -35,
905
- maxValue: 150,
906
- minStep: 0.5
907
- })
908
- .onGet(async () => {
909
- const state = this.accessory.zones[i].flowTemperature;
910
- return state;
911
- })
912
- accessory.addService(this.flowTemperatureZone1SensorService);
913
- };
825
+ //sensor services
826
+ if (zonesSensorsCount > 0) {
827
+ this.accessory.zonesSensors.forEach((zone, i) => {
828
+ const zoneName = zone.name
829
+ const serviceName = `${deviceTypeText} ${accessoryName}: ${zoneName}`;
830
+ switch (i) {
831
+ case caseHeatPumpSensor: //Heat Pump
832
+ if (zone.roomTemperature !== null) {
833
+ const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
834
+ this.roomTemperatureSensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
835
+ this.roomTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
836
+ this.roomTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
837
+ this.roomTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
838
+ .setProps({
839
+ minValue: -35,
840
+ maxValue: 150,
841
+ minStep: 0.5
842
+ })
843
+ .onGet(async () => {
844
+ const state = zone.roomTemperature;
845
+ return state;
846
+ })
847
+ accessory.addService(this.roomTemperatureSensorService);
848
+ };
914
849
 
915
- if (temperatureSensorReturnZone1 && this.accessory.zones[i].returnTemperature !== null) {
916
- const debug3 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature zone 1 sensor service`) : false;
917
- this.returnTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
918
- this.returnTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
919
- this.returnTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
920
- this.returnTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
921
- .setProps({
922
- minValue: -35,
923
- maxValue: 150,
924
- minStep: 0.5
925
- })
926
- .onGet(async () => {
927
- const state = this.accessory.zones[i].returnTemperature;
928
- return state;
929
- })
930
- accessory.addService(this.returnTemperatureZone1SensorService);
931
- };
932
- break;
933
- case caseHotWater: //Hot Water
934
- if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
935
- const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
936
- this.roomTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
937
- this.roomTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
938
- this.roomTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
939
- this.roomTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
940
- .setProps({
941
- minValue: -35,
942
- maxValue: 150,
943
- minStep: 0.5
944
- })
945
- .onGet(async () => {
946
- const state = this.accessory.zones[i].roomTemperature;
947
- return state;
948
- })
949
- accessory.addService(this.roomTemperatureWaterTankSensorService);
950
- };
850
+ if (zone.flowTemperature !== null) {
851
+ const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature sensor service`) : false;
852
+ this.flowTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
853
+ this.flowTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
854
+ this.flowTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
855
+ this.flowTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
856
+ .setProps({
857
+ minValue: -35,
858
+ maxValue: 150,
859
+ minStep: 0.5
860
+ })
861
+ .onGet(async () => {
862
+ const state = zone.flowTemperature;
863
+ return state;
864
+ })
865
+ accessory.addService(this.flowTemperatureSensorService);
951
866
 
952
- if (temperatureSensorFlowWaterTank && this.accessory.zones[i].flowTemperature !== null) {
953
- const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature water tank sensor service`) : false;
954
- this.flowTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
955
- this.flowTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
956
- this.flowTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
957
- this.flowTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
958
- .setProps({
959
- minValue: -35,
960
- maxValue: 150,
961
- minStep: 0.5
962
- })
963
- .onGet(async () => {
964
- const state = this.accessory.zones[i].flowTemperature;
965
- return state;
966
- })
967
- accessory.addService(this.flowTemperatureWaterTankSensorService);
968
- };
867
+ };
969
868
 
970
- if (temperatureSensorReturnWaterTank && this.accessory.zones[i].returnTemperature !== null) {
971
- const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature water tank sensor service`) : false;
972
- this.returnTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
973
- this.returnTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
974
- this.returnTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
975
- this.returnTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
976
- .setProps({
977
- minValue: -35,
978
- maxValue: 150,
979
- minStep: 0.5
980
- })
981
- .onGet(async () => {
982
- const state = this.accessory.zones[i].returnTemperature;
983
- return state;
984
- })
985
- accessory.addService(this.returnTemperatureWaterTankSensorService);
986
- };
987
- break;
988
- case caseZone2: //Zone 2
989
- if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
990
- const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
991
- this.roomTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
992
- this.roomTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
993
- this.roomTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
994
- this.roomTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
995
- .setProps({
996
- minValue: -35,
997
- maxValue: 150,
998
- minStep: 0.5
999
- })
1000
- .onGet(async () => {
1001
- const state = this.accessory.zones[i].roomTemperature;
1002
- return state;
1003
- })
1004
- accessory.addService(this.roomTemperatureZone2SensorService);
1005
- };
869
+ if (zone.returnTemperature !== null) {
870
+ const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature sensor service`) : false;
871
+ this.returnTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
872
+ this.returnTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
873
+ this.returnTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
874
+ this.returnTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
875
+ .setProps({
876
+ minValue: -35,
877
+ maxValue: 150,
878
+ minStep: 0.5
879
+ })
880
+ .onGet(async () => {
881
+ const state = zone.returnTemperature;
882
+ return state;
883
+ })
884
+ accessory.addService(this.returnTemperatureSensorService);
885
+ };
886
+ break;
887
+ case caseZone1Sensor: //Zone 1
888
+ if (zone.roomTemperature !== null) {
889
+ const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
890
+ this.roomTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
891
+ this.roomTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
892
+ this.roomTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
893
+ this.roomTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
894
+ .setProps({
895
+ minValue: -35,
896
+ maxValue: 150,
897
+ minStep: 0.5
898
+ })
899
+ .onGet(async () => {
900
+ const state = zone.roomTemperature;
901
+ return state;
902
+ })
903
+ accessory.addService(this.roomTemperatureZone1SensorService);
904
+ };
1006
905
 
1007
- if (temperatureSensorFlowZone2 && this.accessory.zones[i].flowTemperature !== null) {
1008
- const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature zone 2 sensor service`) : false;
1009
- this.flowTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow${deviceId} ${i}`);
1010
- this.flowTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1011
- this.flowTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
1012
- this.flowTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
1013
- .setProps({
1014
- minValue: -35,
1015
- maxValue: 150,
1016
- minStep: 0.5
1017
- })
1018
- .onGet(async () => {
1019
- const state = this.accessory.zones[i].flowTemperature;
1020
- return state;
1021
- })
1022
- accessory.addService(this.flowTemperatureZone2SensorService);
1023
- };
906
+ if (zone.flowTemperature !== null) {
907
+ const debug2 = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature zone 1 sensor service`) : false;
908
+ this.flowTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
909
+ this.flowTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
910
+ this.flowTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
911
+ this.flowTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
912
+ .setProps({
913
+ minValue: -35,
914
+ maxValue: 150,
915
+ minStep: 0.5
916
+ })
917
+ .onGet(async () => {
918
+ const state = zone.flowTemperature;
919
+ return state;
920
+ })
921
+ accessory.addService(this.flowTemperatureZone1SensorService);
922
+ };
1024
923
 
1025
- if (temperatureSensorReturnZone2 && this.accessory.zones[i].returnTemperature !== null) {
1026
- const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature zone 2 sensor service`) : false;
1027
- this.returnTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return${deviceId} ${i}`);
1028
- this.returnTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1029
- this.returnTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
1030
- this.returnTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
1031
- .setProps({
1032
- minValue: -35,
1033
- maxValue: 150,
1034
- minStep: 0.5
1035
- })
1036
- .onGet(async () => {
1037
- const state = this.accessory.zones[i].returnTemperature;
1038
- return state;
1039
- })
1040
- accessory.addService(this.returnTemperatureZone2SensorService);
1041
- };
1042
- break;
1043
- };
924
+ if (zone.returnTemperature !== null) {
925
+ const debug3 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature zone 1 sensor service`) : false;
926
+ this.returnTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
927
+ this.returnTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
928
+ this.returnTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
929
+ this.returnTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
930
+ .setProps({
931
+ minValue: -35,
932
+ maxValue: 150,
933
+ minStep: 0.5
934
+ })
935
+ .onGet(async () => {
936
+ const state = zone.returnTemperature;
937
+ return state;
938
+ })
939
+ accessory.addService(this.returnTemperatureZone1SensorService);
940
+ };
941
+ break;
942
+ case caseHotWaterSensor: //Hot Water
943
+ if (zone.roomTemperature !== null) {
944
+ const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
945
+ this.roomTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
946
+ this.roomTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
947
+ this.roomTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
948
+ this.roomTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
949
+ .setProps({
950
+ minValue: -35,
951
+ maxValue: 150,
952
+ minStep: 0.5
953
+ })
954
+ .onGet(async () => {
955
+ const state = zone.roomTemperature;
956
+ return state;
957
+ })
958
+ accessory.addService(this.roomTemperatureWaterTankSensorService);
959
+ };
960
+
961
+ if (zone.flowTemperature !== null) {
962
+ const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature water tank sensor service`) : false;
963
+ this.flowTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
964
+ this.flowTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
965
+ this.flowTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
966
+ this.flowTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
967
+ .setProps({
968
+ minValue: -35,
969
+ maxValue: 150,
970
+ minStep: 0.5
971
+ })
972
+ .onGet(async () => {
973
+ const state = zone.flowTemperature;
974
+ return state;
975
+ })
976
+ accessory.addService(this.flowTemperatureWaterTankSensorService);
977
+ };
978
+
979
+ if (zone.returnTemperature !== null) {
980
+ const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature water tank sensor service`) : false;
981
+ this.returnTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
982
+ this.returnTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
983
+ this.returnTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
984
+ this.returnTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
985
+ .setProps({
986
+ minValue: -35,
987
+ maxValue: 150,
988
+ minStep: 0.5
989
+ })
990
+ .onGet(async () => {
991
+ const state = zone.returnTemperature;
992
+ return state;
993
+ })
994
+ accessory.addService(this.returnTemperatureWaterTankSensorService);
995
+ };
996
+ break;
997
+ case caseZone2Sensor: //Zone 2
998
+ if (zone.roomTemperature !== null) {
999
+ const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
1000
+ this.roomTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
1001
+ this.roomTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1002
+ this.roomTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
1003
+ this.roomTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
1004
+ .setProps({
1005
+ minValue: -35,
1006
+ maxValue: 150,
1007
+ minStep: 0.5
1008
+ })
1009
+ .onGet(async () => {
1010
+ const state = zone.roomTemperature;
1011
+ return state;
1012
+ })
1013
+ accessory.addService(this.roomTemperatureZone2SensorService);
1014
+ };
1015
+
1016
+ if (zone.flowTemperature !== null) {
1017
+ const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature zone 2 sensor service`) : false;
1018
+ this.flowTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow${deviceId} ${i}`);
1019
+ this.flowTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1020
+ this.flowTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
1021
+ this.flowTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
1022
+ .setProps({
1023
+ minValue: -35,
1024
+ maxValue: 150,
1025
+ minStep: 0.5
1026
+ })
1027
+ .onGet(async () => {
1028
+ const state = zone.flowTemperature;
1029
+ return state;
1030
+ })
1031
+ accessory.addService(this.flowTemperatureZone2SensorService);
1032
+ };
1033
+
1034
+ if (zone.returnTemperature !== null) {
1035
+ const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature zone 2 sensor service`) : false;
1036
+ this.returnTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return${deviceId} ${i}`);
1037
+ this.returnTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1038
+ this.returnTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
1039
+ this.returnTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
1040
+ .setProps({
1041
+ minValue: -35,
1042
+ maxValue: 150,
1043
+ minStep: 0.5
1044
+ })
1045
+ .onGet(async () => {
1046
+ const state = zone.returnTemperature;
1047
+ return state;
1048
+ })
1049
+ accessory.addService(this.returnTemperatureZone2SensorService);
1050
+ };
1051
+ break;
1052
+ };
1053
+ });
1044
1054
  };
1045
1055
 
1046
1056
  //presets services
1047
1057
  if (this.presetsConfiguredCount > 0) {
1048
1058
  const debug = this.enableDebugMode ? this.emit('debug', `Prepare presets services`) : false;
1049
1059
  this.presetsServices = [];
1050
-
1051
- for (let i = 0; i < this.presetsConfiguredCount; i++) {
1052
- const preset = this.presetsConfigured[i];
1060
+ this.presetsConfigured.forEach((preset, i) => {
1053
1061
  const presetData = presetsOnServer.find(p => p.ID === preset.Id);
1054
1062
 
1055
1063
  //get preset name
1056
- const presetName = preset.name;
1064
+ const name = preset.name;
1057
1065
 
1058
1066
  //get preset name prefix
1059
- const presetNamePrefix = preset.namePrefix;
1067
+ const namePrefix = preset.namePrefix;
1060
1068
 
1061
- const serviceName = presetNamePrefix ? `${accessoryName} ${presetName}` : presetName;
1069
+ const serviceName = namePrefix ? `${accessoryName} ${name}` : name;
1062
1070
  const serviceType = preset.serviceType;
1063
1071
  const characteristicType = preset.characteristicType;
1064
1072
  const presetService = new serviceType(serviceName, `Preset ${deviceId} ${i}`);
@@ -1106,24 +1114,21 @@ class DeviceAtw extends EventEmitter {
1106
1114
  };
1107
1115
 
1108
1116
  await this.melCloudAtw.send(deviceData);
1109
- const info = this.disableLogInfo ? false : this.emit('message', `${state ? 'Set:' : 'Unset:'} ${presetName}`);
1117
+ const info = this.disableLogInfo ? false : this.emit('message', `${state ? 'Set:' : 'Unset:'} ${name}`);
1110
1118
  } catch (error) {
1111
1119
  this.emit('warn', `Set preset error: ${error}`);
1112
1120
  };
1113
1121
  });
1114
1122
  this.presetsServices.push(presetService);
1115
1123
  accessory.addService(presetService);
1116
- };
1124
+ });
1117
1125
  };
1118
1126
 
1119
1127
  //buttons services
1120
1128
  if (this.buttonsConfiguredCount > 0) {
1121
1129
  const debug = this.enableDebugMode ? this.emit('debug', `Prepare buttons services`) : false;
1122
1130
  this.buttonsServices = [];
1123
-
1124
- for (let i = 0; i < this.buttonsConfiguredCount; i++) {
1125
- const button = this.buttonsConfigured[i];
1126
-
1131
+ this.buttonsConfigured.forEach((button, i) => {
1127
1132
  //get button mode
1128
1133
  const mode = button.mode;
1129
1134
 
@@ -1131,12 +1136,12 @@ class DeviceAtw extends EventEmitter {
1131
1136
  const displayType = button.displayType;
1132
1137
 
1133
1138
  //get button name
1134
- const buttonName = button.name;
1139
+ const name = button.name;
1135
1140
 
1136
1141
  //get button name prefix
1137
- const buttonNamePrefix = button.namePrefix;
1142
+ const namePrefix = button.namePrefix;
1138
1143
 
1139
- const serviceName = buttonNamePrefix ? `${accessoryName} ${buttonName}` : buttonName;
1144
+ const serviceName = namePrefix ? `${accessoryName} ${name}` : name;
1140
1145
  const serviceType = button.serviceType;
1141
1146
  const characteristicType = button.characteristicType;
1142
1147
  const buttonService = new serviceType(serviceName, `Button ${deviceId} ${i}`);
@@ -1277,7 +1282,7 @@ class DeviceAtw extends EventEmitter {
1277
1282
  };
1278
1283
 
1279
1284
  await this.melCloudAtw.send(deviceData);
1280
- const info = this.disableLogInfo ? false : this.emit('message', `${state ? `Set: ${buttonName}` : `Unset: ${buttonName}, Set: ${button.previousValue}`}`);
1285
+ const info = this.disableLogInfo ? false : this.emit('message', `${state ? `Set: ${name}` : `Unset: ${name}, Set: ${button.previousValue}`}`);
1281
1286
  } catch (error) {
1282
1287
  this.emit('warn', `Set button error: ${error}`);
1283
1288
  };
@@ -1285,7 +1290,7 @@ class DeviceAtw extends EventEmitter {
1285
1290
  });
1286
1291
  this.buttonsServices.push(buttonService);
1287
1292
  accessory.addService(buttonService)
1288
- };
1293
+ });
1289
1294
  };
1290
1295
 
1291
1296
  return accessory;
@@ -1319,6 +1324,7 @@ class DeviceAtw extends EventEmitter {
1319
1324
  this.emit('devInfo', `Firmware: ${firmwareAppVersion}`);
1320
1325
  this.emit('devInfo', `Manufacturer: ${manufacturer}`);
1321
1326
  this.emit('devInfo', '----------------------------------');
1327
+ this.emit('devInfo', `Zone 1: Yes`);
1322
1328
  this.emit('devInfo', `Hot Water Tank: ${hasHotWaterTank ? 'Yes' : 'No'}`);
1323
1329
  this.emit('devInfo', `Zone 2: ${hasZone2 ? 'Yes' : 'No'}`);
1324
1330
  this.emit('devInfo', '----------------------------------');
@@ -1331,34 +1337,40 @@ class DeviceAtw extends EventEmitter {
1331
1337
  this.firmwareRevision = firmwareAppVersion;
1332
1338
  this.displayDeviceInfo = false;
1333
1339
  })
1334
- .on('deviceState', (deviceData) => {
1340
+ .on('deviceState', async (deviceData) => {
1335
1341
  this.deviceData = deviceData;
1336
1342
 
1337
1343
  //presets
1338
1344
  const presetsOnServer = deviceData.Presets ?? [];
1339
1345
 
1340
1346
  //device info
1341
- const hasZone1 = this.hideZone !== 1 || this.hideZone !== 5 || this.hideZone !== 7 ? true : false;
1342
- const hasHotWaterTank = (this.hideZone !== 4 || this.hideZone !== 5 || this.hideZone !== 6 || this.hideZone !== 7) && deviceData.Device.HasHotWaterTank ? true : false;
1343
- const hasZone2 = (this.hideZone !== 2 || this.hideZone !== 3 || this.hideZone !== 6 || this.hideZone !== 7) && deviceData.Device.HasZone2 ? true : false;
1347
+ const hasHeatPump = ![1, 2, 3, 4, 5, 6, 7, 15].includes(this.hideZone);
1348
+ const hasZone1 = ![2, 3, 4, 8, 9, 10, 11, 15].includes(this.hideZone);
1349
+ const hasHotWaterTank = ![3, 5, 6, 9, 10, 12, 13, 15].includes(this.hideZone) && deviceData.Device.HasHotWaterTank;
1350
+ const hasZone2 = ![4, 6, 7, 10, 11, 13, 14, 15].includes(this.hideZone) && deviceData.Device.HasZone2;
1344
1351
  const canHeat = deviceData.Device.CanHeat ?? false;
1345
1352
  const canCool = deviceData.Device.CanCool ?? false;
1346
1353
  const heatCoolModes = canHeat && canCool ? 0 : canHeat ? 1 : canCool ? 2 : 3;
1347
1354
  const temperatureIncrement = deviceData.Device.TemperatureIncrement ?? 1;
1348
1355
  const minSetTemperature = deviceData.Device.MinSetTemperature ?? 10;
1349
1356
  const maxSetTemperature = deviceData.Device.MaxSetTemperature ?? 30;
1350
- const maxTankTemperature = deviceData.Device.MaxTankTemperature ?? 70
1357
+ const maxTankTemperature = deviceData.Device.MaxTankTemperature ?? 70;
1351
1358
 
1352
1359
  //zones
1353
- const zone1 = hasZone1 ? 1 : 0;
1354
- const hotWater = hasHotWaterTank ? 1 : 0;
1355
- const zone2 = hasZone2 ? 1 : 0;
1356
- const zonesCount = 1 + zone1 + hotWater + zone2;
1357
-
1358
- //zone cases
1359
- const caseZone1 = hasZone1 ? 1 : -1;
1360
- const caseHotWater = hasHotWaterTank ? 2 : -1;
1361
- const caseZone2 = hasZone2 ? hasHotWaterTank ? 3 : 2 : -1;
1360
+ let currentZoneCase = 0;
1361
+ const caseHeatPump = hasHeatPump ? currentZoneCase++ : -1;
1362
+ const caseZone1 = hasZone1 ? currentZoneCase++ : -1;
1363
+ const caseHotWater = hasHotWaterTank ? currentZoneCase++ : -1;
1364
+ const caseZone2 = hasZone2 ? currentZoneCase++ : -1;
1365
+ const zonesCount = currentZoneCase;
1366
+
1367
+ //zones sensors
1368
+ let currentZoneSensorCase = 0;
1369
+ const caseHeatPumpSensor = this.temperatureSensor || this.temperatureSensorFlow || this.temperatureSensorReturn ? currentZoneSensorCase++ : -1;
1370
+ const caseZone1Sensor = this.temperatureSensorFlowZone1 || this.temperatureSensorReturnZone1 ? currentZoneSensorCase++ : -1;
1371
+ const caseHotWaterSensor = (this.temperatureSensorFlowWaterTank || this.temperatureSensorReturnWaterTank) && deviceData.Device.HasHotWaterTank ? currentZoneSensorCase++ : -1;
1372
+ const caseZone2Sensor = (this.temperatureSensorFlowZone2 || this.temperatureSensorReturnZone2) && deviceData.Device.HasZone2 ? currentZoneSensorCase++ : -1;
1373
+ const zonesSensorsCount = currentZoneSensorCase;
1362
1374
 
1363
1375
  //heat pump
1364
1376
  const heatPumpName = 'Heat Pump';
@@ -1411,13 +1423,21 @@ class DeviceAtw extends EventEmitter {
1411
1423
  this.accessory.idleZone1 = idleZone1;
1412
1424
  this.accessory.idleZone2 = idleZone2;
1413
1425
  this.accessory.temperatureIncrement = temperatureIncrement;
1426
+ this.accessory.hasHeatPump = hasHeatPump;
1427
+ this.accessory.hasZone1 = hasZone1;
1414
1428
  this.accessory.hasHotWaterTank = hasHotWaterTank;
1415
1429
  this.accessory.hasZone2 = hasZone2;
1416
- this.accessory.zonesCount = zonesCount;
1417
1430
  this.accessory.heatCoolModes = heatCoolModes;
1431
+ this.accessory.caseHeatPump = caseHeatPump;
1418
1432
  this.accessory.caseZone1 = caseZone1;
1419
1433
  this.accessory.caseHotWater = caseHotWater;
1420
1434
  this.accessory.caseZone2 = caseZone2;
1435
+ this.accessory.zonesCount = zonesCount;
1436
+ this.accessory.caseHeatPumpSensor = caseHeatPumpSensor;
1437
+ this.accessory.caseZone1Sensor = caseZone1Sensor;
1438
+ this.accessory.caseHotWaterSensor = caseHotWaterSensor;
1439
+ this.accessory.caseZone2Sensor = caseZone2Sensor;
1440
+ this.accessory.sensorsCount = zonesSensorsCount;
1421
1441
 
1422
1442
  //default values
1423
1443
  let name = 'Heat Pump'
@@ -1439,17 +1459,15 @@ class DeviceAtw extends EventEmitter {
1439
1459
  switch (this.displayMode) {
1440
1460
  case 1: //Heater Cooler
1441
1461
  switch (i) {
1442
- case 0: //Heat Pump Operation Mode - IDLE, HOT WATER, HEATING ZONES, COOLING, HOT WATER STORAGE, FREEZE STAT, LEGIONELLA, HEATING ECO, MODE 1, MODE 2, MODE 3, HEATING UP /// Unit Status - HEAT, COOL
1462
+ case caseHeatPump: //Heat Pump Operation Mode - IDLE, HOT WATER, HEATING ZONES, COOLING, HOT WATER STORAGE, FREEZE STAT, LEGIONELLA, HEATING ECO, MODE 1, MODE 2, MODE 3, HEATING UP /// Unit Status - HEAT, COOL
1443
1463
  name = heatPumpName;
1444
1464
  operationModeZone = operationMode;
1445
1465
  currentOperationMode = !power ? 0 : [1, 2, 2, 3, 2, 1, 1, 2, 1, 1, 1, 2][operationMode]; //INACTIVE, IDLE, HEATING, COOLING
1446
1466
  targetOperationMode = [1, 2][unitStatus]; //AUTO, HEAT, COOL
1447
1467
  roomTemperature = outdoorTemperature;
1448
1468
  setTemperature = outdoorTemperature;
1449
- lockPhysicalControl = hasHotWaterTank && hasZone2 ? (prohibitZone1 && prohibitHotWater && prohibitZone2 ? 1 : 0) : hasHotWaterTank ? (prohibitZone1 && prohibitHotWater ? 1 : 0) : hasZone2 ? (prohibitZone1 && prohibitZone2 ? 1 : 0) : 0;
1450
- flowTemperature = flowTemperatureHeatPump;
1451
- returnTemperature = returnTemperatureHeatPump;
1452
1469
 
1470
+ lockPhysicalControl = hasHotWaterTank && hasZone2 ? (prohibitZone1 && prohibitHotWater && prohibitZone2 ? 1 : 0) : hasHotWaterTank ? (prohibitZone1 && prohibitHotWater ? 1 : 0) : hasZone2 ? (prohibitZone1 && prohibitZone2 ? 1 : 0) : 0;
1453
1471
  operationModeSetPropsMinValue = [1, 1, 2, 0][heatCoolModes];
1454
1472
  operationModeSetPropsMaxValue = [2, 1, 2, 0][heatCoolModes];
1455
1473
  operationModeSetPropsValidValues = [[1, 2], [1], [2], [0]][heatCoolModes];
@@ -1484,9 +1502,6 @@ class DeviceAtw extends EventEmitter {
1484
1502
  };
1485
1503
 
1486
1504
  lockPhysicalControl = prohibitZone1 ? 1 : 0;
1487
- flowTemperature = flowTemperatureZone1;
1488
- returnTemperature = returnTemperatureZone1;
1489
-
1490
1505
  operationModeSetPropsMinValue = [0, 0, 1, 0][heatCoolModes];
1491
1506
  operationModeSetPropsMaxValue = [2, 2, 2, 0][heatCoolModes];
1492
1507
  operationModeSetPropsValidValues = [[0, 1, 2], [0, 1, 2], [1, 2], [0]][heatCoolModes];
@@ -1498,10 +1513,8 @@ class DeviceAtw extends EventEmitter {
1498
1513
  targetOperationMode = [0, 1][forcedHotWaterMode] //AUTO, HEAT, COOL
1499
1514
  roomTemperature = tankWaterTemperature;
1500
1515
  setTemperature = setTankWaterTemperature;
1501
- lockPhysicalControl = prohibitHotWater ? 1 : 0;
1502
- flowTemperature = flowTemperatureWaterTank;
1503
- returnTemperature = returnTemperatureWaterTank;
1504
1516
 
1517
+ lockPhysicalControl = prohibitHotWater ? 1 : 0;
1505
1518
  operationModeSetPropsMinValue = 0;
1506
1519
  operationModeSetPropsMaxValue = 1;
1507
1520
  operationModeSetPropsValidValues = [0, 1];
@@ -1536,16 +1549,10 @@ class DeviceAtw extends EventEmitter {
1536
1549
  };
1537
1550
 
1538
1551
  lockPhysicalControl = prohibitZone2 ? 1 : 0;
1539
- flowTemperature = flowTemperatureZone2;
1540
- returnTemperature = returnTemperatureZone2;
1541
-
1542
1552
  operationModeSetPropsMinValue = [0, 0, 1, 0][heatCoolModes];
1543
1553
  operationModeSetPropsMaxValue = [2, 2, 2, 0][heatCoolModes];
1544
1554
  operationModeSetPropsValidValues = [[0, 1, 2], [0, 1, 2], [1, 2], [0]][heatCoolModes];
1545
1555
  break;
1546
- default: //unknown zone detected
1547
- this.emit('message', `Unknown zone: ${i} detected`);
1548
- break;
1549
1556
  };
1550
1557
 
1551
1558
  //update characteristics
@@ -1563,7 +1570,7 @@ class DeviceAtw extends EventEmitter {
1563
1570
  break;
1564
1571
  case 2: //Thermostat
1565
1572
  switch (i) {
1566
- case 0: //Heat Pump Operation Mode - IDLE, HOT WATER, HEATING ZONES, COOLING, HOT WATER STORAGE, FREEZE STAT, LEGIONELLA, HEATING ECO, MODE 1, MODE 2, MODE 3, HEATING UP /// Unit Status - HEAT, COOL
1573
+ case caseHeatPump: //Heat Pump Operation Mode - IDLE, HOT WATER, HEATING ZONES, COOLING, HOT WATER STORAGE, FREEZE STAT, LEGIONELLA, HEATING ECO, MODE 1, MODE 2, MODE 3, HEATING UP /// Unit Status - HEAT, COOL
1567
1574
  name = heatPumpName;
1568
1575
  operationModeZone = operationMode;
1569
1576
  currentOperationMode = !power ? 0 : [0, 1, 1, 2, 1, 0, 0, 1, 0, 0, 0, 1][operationMode]; //OFF, HEAT, COOL
@@ -1653,9 +1660,6 @@ class DeviceAtw extends EventEmitter {
1653
1660
  operationModeSetPropsMaxValue = [3, 3, 2, 0][heatCoolModes];
1654
1661
  operationModeSetPropsValidValues = [[1, 2, 3], [1, 2, 3], [1, 2], [0]][heatCoolModes];
1655
1662
  break;
1656
- default: //unknown zone detected
1657
- this.emit('message', `Unknown zone: ${i} detected`);
1658
- break;
1659
1663
  };
1660
1664
 
1661
1665
  //update characteristics
@@ -1670,7 +1674,7 @@ class DeviceAtw extends EventEmitter {
1670
1674
  break;
1671
1675
  };
1672
1676
 
1673
- //push value to arrays
1677
+ //add value to zones arrays
1674
1678
  this.accessory.zones[i].name = name;
1675
1679
  this.accessory.zones[i].operationMode = operationModeZone;
1676
1680
  this.accessory.zones[i].currentOperationMode = currentOperationMode;
@@ -1678,40 +1682,86 @@ class DeviceAtw extends EventEmitter {
1678
1682
  this.accessory.zones[i].roomTemperature = roomTemperature;
1679
1683
  this.accessory.zones[i].setTemperature = setTemperature;
1680
1684
  this.accessory.zones[i].lockPhysicalControl = lockPhysicalControl;
1681
- this.accessory.zones[i].flowTemperature = flowTemperature;
1682
- this.accessory.zones[i].returnTemperature = returnTemperature;
1683
1685
  this.accessory.zones[i].temperaturesSetPropsMinValue = temperatureSetPropsMinValue;
1684
1686
  this.accessory.zones[i].temperaturesSetPropsMaxValue = temperatureSetPropsMaxValue;
1687
+ const setPropsMinValue = this.startPrepareAccessory ? this.accessory.zones[i].operationModesSetPropsMinValue = operationModeSetPropsMinValue : false;
1688
+ const setPropsMaxValue = this.startPrepareAccessory ? this.accessory.zones[i].operationModesSetPropsMaxValue = operationModeSetPropsMaxValue : false;
1689
+ const setPropsValidValues = this.startPrepareAccessory ? this.accessory.zones[i].operationModesSetPropsValidValues = operationModeSetPropsValidValues : false;
1685
1690
 
1686
- //only on first run
1687
- if (this.startPrepareAccessory) {
1688
- this.accessory.zones[i].operationModesSetPropsMinValue = operationModeSetPropsMinValue;
1689
- this.accessory.zones[i].operationModesSetPropsMaxValue = operationModeSetPropsMaxValue;
1690
- this.accessory.zones[i].operationModesSetPropsValidValues = operationModeSetPropsValidValues;
1691
+ //log current state
1692
+ if (!this.disableLogInfo) {
1693
+ let operationModeText = '';
1694
+ switch (i) {
1695
+ case caseHeatPump: //Heat Pump - HEAT, COOL, OFF
1696
+ this.emit('message', `${heatPumpName}, Power: ${power ? 'ON' : 'OFF'}`)
1697
+ this.emit('message', `${heatPumpName}, Operation mode: ${HeatPump.System[unitStatus]}`);
1698
+ this.emit('message', `${heatPumpName},'Outdoor temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
1699
+ this.emit('message', `${heatPumpName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
1700
+ this.emit('message', `${heatPumpName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1701
+ break;
1702
+ case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1703
+ operationModeText = idleZone1 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone1];
1704
+ this.emit('message', `${zone1Name}, Operation mode: ${operationModeText}`);
1705
+ this.emit('message', `${zone1Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
1706
+ this.emit('message', `${zone1Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
1707
+ this.emit('message', `${zone1Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
1708
+ this.emit('message', `${zone1Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1709
+ break;
1710
+ case caseHotWater: //Hot Water - AUTO, HEAT NOW
1711
+ operationModeText = operationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[forcedHotWaterMode ? 1 : 0];
1712
+ this.emit('message', `${hotWaterName}, Operation mode: ${operationModeText}`);
1713
+ this.emit('message', `${hotWaterName}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
1714
+ this.emit('message', `${hotWaterName}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
1715
+ this.emit('message', `${hotWaterName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
1716
+ this.emit('message', `${hotWaterName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1717
+ break;
1718
+ case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1719
+ operationModeText = idleZone2 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone2];
1720
+ this.emit('message', `${zone2Name}, Operation mode: ${operationModeText}`);
1721
+ this.emit('message', `${zone2Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
1722
+ this.emit('message', `${zone2Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
1723
+ this.emit('message', `${zone2Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
1724
+ this.emit('message', `${zone2Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1725
+ break;
1726
+ };
1691
1727
  };
1728
+ };
1692
1729
 
1693
- //update temperature sensors
1730
+ //update sensors characteristics
1731
+ for (let i = 0; i < zonesSensorsCount; i++) {
1694
1732
  switch (i) {
1695
- case 0: //Heat Pump
1733
+ case caseHeatPumpSensor: //Heat Pump
1734
+ name = heatPumpName;
1735
+ roomTemperature = outdoorTemperature;
1736
+ flowTemperature = flowTemperatureHeatPump;
1737
+ returnTemperature = returnTemperatureHeatPump;
1738
+
1739
+ //updte characteristics
1696
1740
  if (this.roomTemperatureSensorService) {
1697
1741
  this.roomTemperatureSensorService
1698
- .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
1742
+ .updateCharacteristic(Characteristic.CurrentTemperature, outdoorTemperature)
1699
1743
  };
1700
1744
 
1701
1745
  if (this.flowTemperatureSensorService) {
1702
1746
  this.flowTemperatureSensorService
1703
- .updateCharacteristic(Characteristic.CurrentTemperature, flowTemperature)
1747
+ .updateCharacteristic(Characteristic.CurrentTemperature, flowTemperatureHeatPump)
1704
1748
  };
1705
1749
 
1706
1750
  if (this.returnTemperatureSensorService) {
1707
1751
  this.returnTemperatureSensorService
1708
- .updateCharacteristic(Characteristic.CurrentTemperature, returnTemperature)
1752
+ .updateCharacteristic(Characteristic.CurrentTemperature, returnTemperatureHeatPump)
1709
1753
  };
1710
1754
  break;
1711
- case 1: //Zone 1
1755
+ case caseZone1Sensor: //Zone 1
1756
+ name = zone1Name;
1757
+ roomTemperature = roomTemperatureZone1;
1758
+ flowTemperature = flowTemperatureZone1;
1759
+ returnTemperature = returnTemperatureZone1;
1760
+
1761
+ //updte characteristics
1712
1762
  if (this.roomTemperatureZone1SensorService) {
1713
1763
  this.roomTemperatureZone1SensorService
1714
- .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
1764
+ .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperatureZone1)
1715
1765
  };
1716
1766
 
1717
1767
  if (this.flowTemperatureZone1SensorService) {
@@ -1724,10 +1774,16 @@ class DeviceAtw extends EventEmitter {
1724
1774
  .updateCharacteristic(Characteristic.CurrentTemperature, returnTemperatureZone1)
1725
1775
  };
1726
1776
  break;
1727
- case caseHotWater: //Hot Water
1777
+ case caseHotWaterSensor: //Hot Water
1778
+ name = hotWaterName;
1779
+ roomTemperature = tankWaterTemperature;
1780
+ flowTemperature = flowTemperatureWaterTank;
1781
+ returnTemperature = returnTemperatureWaterTank;
1782
+
1783
+ //updte characteristics
1728
1784
  if (this.roomTemperatureWaterTankSensorService) {
1729
1785
  this.roomTemperatureWaterTankSensorService
1730
- .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
1786
+ .updateCharacteristic(Characteristic.CurrentTemperature, tankWaterTemperature)
1731
1787
  };
1732
1788
 
1733
1789
  if (this.flowTemperatureWaterTankSensorService) {
@@ -1740,10 +1796,16 @@ class DeviceAtw extends EventEmitter {
1740
1796
  .updateCharacteristic(Characteristic.CurrentTemperature, returnTemperatureWaterTank)
1741
1797
  };
1742
1798
  break;
1743
- case caseZone2: //Zone 2
1799
+ case caseZone2Sensor: //Zone 2
1800
+ name = zone2Name;
1801
+ roomTemperature = roomTemperatureZone2;
1802
+ flowTemperature = flowTemperatureZone2;
1803
+ returnTemperature = returnTemperatureZone2;
1804
+
1805
+ //updte characteristics
1744
1806
  if (this.roomTemperatureZone2SensorService) {
1745
1807
  this.roomTemperatureZone2SensorService
1746
- .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
1808
+ .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperatureZone2)
1747
1809
  };
1748
1810
 
1749
1811
  if (this.flowTemperatureZone2SensorService) {
@@ -1758,48 +1820,33 @@ class DeviceAtw extends EventEmitter {
1758
1820
  break;
1759
1821
  };
1760
1822
 
1823
+ //add value to sensors arrays
1824
+ this.accessory.zonesSensors[i].roomTemperature = roomTemperature;
1825
+ this.accessory.zonesSensors[i].flowTemperature = flowTemperature;
1826
+ this.accessory.zonesSensors[i].returnTemperature = returnTemperature;
1827
+
1761
1828
  //log current state
1762
1829
  if (!this.disableLogInfo) {
1763
- let operationModeText = '';
1764
1830
  switch (i) {
1765
- case 0: //Heat Pump - HEAT, COOL, OFF
1766
- this.emit('message', `${heatPumpName}, Power: ${power ? 'ON' : 'OFF'}`)
1767
- this.emit('message', `${heatPumpName}, Operation mode: ${HeatPump.System[unitStatus]}`);
1768
- this.emit('message', `${heatPumpName},'Outdoor temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
1769
- const info = flowTemperature !== null ? this.emit('message', `${heatPumpName}, Flow temperature: ${flowTemperature}${this.accessory.temperatureUnit}`) : false;
1770
- const info1 = returnTemperature !== null ? this.emit('message', `${heatPumpName}, Return temperature: ${returnTemperature}${this.accessory.temperatureUnit}`) : false;
1771
- this.emit('message', `${heatPumpName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
1772
- this.emit('message', `${heatPumpName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1831
+ case caseHeatPumpSensor: //Heat Pump - HEAT, COOL, OFF
1832
+ const info = outdoorTemperature !== null ? this.emit('message', `${heatPumpName}, Outdoor temperature: ${outdoorTemperature}${this.accessory.temperatureUnit}`) : false;
1833
+ const info0 = flowTemperatureHeatPump !== null ? this.emit('message', `${heatPumpName}, Flow temperature: ${flowTemperatureHeatPump}${this.accessory.temperatureUnit}`) : false;
1834
+ const info1 = returnTemperatureHeatPump !== null ? this.emit('message', `${heatPumpName}, Return temperature: ${returnTemperatureHeatPump}${this.accessory.temperatureUnit}`) : false;
1773
1835
  break;
1774
- case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1775
- operationModeText = idleZone1 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone1];
1776
- this.emit('message', `${zone1Name}, Operation mode: ${operationModeText}`);
1777
- this.emit('message', `${zone1Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
1778
- this.emit('message', `${zone1Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
1779
- const info2 = flowTemperatureZone1 !== null ? this.emit('message', `${zone1Name}, Flow temperature: ${flowTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
1780
- const info3 = returnTemperatureZone1 !== null ? this.emit('message', `${zone1Name}, Return temperature: ${returnTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
1781
- this.emit('message', `${zone1Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
1782
- this.emit('message', `${zone1Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1836
+ case caseZone1Sensor: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1837
+ const info2 = roomTemperatureZone1 !== null ? this.emit('message', `${zone1Name}, Room temperature: ${roomTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
1838
+ const info3 = flowTemperatureZone1 !== null ? this.emit('message', `${zone1Name}, Flow temperature: ${flowTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
1839
+ const info4 = returnTemperatureZone1 !== null ? this.emit('message', `${zone1Name}, Return temperature: ${returnTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
1783
1840
  break;
1784
- case caseHotWater: //Hot Water - AUTO, HEAT NOW
1785
- operationModeText = operationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[forcedHotWaterMode ? 1 : 0];
1786
- this.emit('message', `${hotWaterName}, Operation mode: ${operationModeText}`);
1787
- this.emit('message', `${hotWaterName}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
1788
- this.emit('message', `${hotWaterName}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
1789
- const info4 = flowTemperatureWaterTank !== null ? this.emit('message', `${hotWaterName}, Flow temperature: ${flowTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
1790
- const info5 = returnTemperatureWaterTank !== null ? this.emit('message', `${hotWaterName}, Return temperature: ${returnTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
1791
- this.emit('message', `${hotWaterName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
1792
- this.emit('message', `${hotWaterName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1841
+ case caseHotWaterSensor: //Hot Water - AUTO, HEAT NOW
1842
+ const info5 = tankWaterTemperature !== null ? this.emit('message', `${hotWaterName}, Temperature: ${tankWaterTemperature}${this.accessory.temperatureUnit}`) : false;
1843
+ const info6 = flowTemperatureWaterTank !== null ? this.emit('message', `${hotWaterName}, Flow temperature: ${flowTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
1844
+ const info7 = returnTemperatureWaterTank !== null ? this.emit('message', `${hotWaterName}, Return temperature: ${returnTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
1793
1845
  break;
1794
- case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1795
- operationModeText = idleZone2 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone2];
1796
- this.emit('message', `${zone2Name}, Operation mode: ${operationModeText}`);
1797
- this.emit('message', `${zone2Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
1798
- this.emit('message', `${zone2Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
1799
- const info6 = flowTemperatureZone2 !== null ? this.emit('message', `${zone2Name}, Flow temperature: ${flowTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
1800
- const info7 = roomTemperatureZone2 !== null ? this.emit('message', `${zone2Name}, Return temperature: ${roomTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
1801
- this.emit('message', `${zone2Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
1802
- this.emit('message', `${zone2Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1846
+ case caseZone2Sensor: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1847
+ const info8 = roomTemperatureZone2 !== null ? this.emit('message', `${zone2Name}, Room temperature: ${roomTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
1848
+ const info9 = flowTemperatureZone2 !== null ? this.emit('message', `${zone2Name}, Flow temperature: ${flowTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
1849
+ const info10 = returnTemperatureZone2 !== null ? this.emit('message', `${zone2Name}, Return temperature: ${returnTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
1803
1850
  break;
1804
1851
  };
1805
1852
  };
@@ -1807,8 +1854,7 @@ class DeviceAtw extends EventEmitter {
1807
1854
 
1808
1855
  //update presets state
1809
1856
  if (this.presetsConfigured.length > 0) {
1810
- for (let i = 0; i < this.presetsConfigured.length; i++) {
1811
- const preset = this.presetsConfigured[i];
1857
+ this.presetsConfigured.forEach((preset, i) => {
1812
1858
  const presetData = presetsOnServer.find(p => p.ID === preset.Id);
1813
1859
 
1814
1860
  preset.state = presetData ? (presetData.Power === power
@@ -1829,7 +1875,7 @@ class DeviceAtw extends EventEmitter {
1829
1875
  this.presetsServices[i]
1830
1876
  .updateCharacteristic(characteristicType, preset.state)
1831
1877
  };
1832
- };
1878
+ });
1833
1879
  };
1834
1880
 
1835
1881
  //update buttons state
@@ -1920,6 +1966,13 @@ class DeviceAtw extends EventEmitter {
1920
1966
  };
1921
1967
  };
1922
1968
  };
1969
+
1970
+ //prepare accessory
1971
+ if (this.startPrepareAccessory) {
1972
+ const accessory = await this.prepareAccessory(this.accountInfo, deviceData, this.deviceId, this.deviceTypeText, this.deviceName, this.accountName);
1973
+ this.emit('publishAccessory', accessory);
1974
+ this.startPrepareAccessory = false;
1975
+ }
1923
1976
  })
1924
1977
  .on('success', (success) => {
1925
1978
  this.emit('success', success);
@@ -1947,18 +2000,7 @@ class DeviceAtw extends EventEmitter {
1947
2000
  const startExternalIntegrations = this.restFul.enable || this.mqtt.enable ? await this.externalIntegrations() : false;
1948
2001
 
1949
2002
  //check state
1950
- const deviceData = await this.melCloudAtw.checkState();
1951
-
1952
- if (deviceData === false) {
1953
- return null;
1954
- }
1955
-
1956
- //prepare accessory
1957
- if (this.startPrepareAccessory) {
1958
- const accessory = await this.prepareAccessory(this.accountInfo, deviceData, this.deviceId, this.deviceTypeText, this.deviceName, this.accountName);
1959
- this.emit('publishAccessory', accessory);
1960
- this.startPrepareAccessory = false;
1961
- }
2003
+ await this.melCloudAtw.checkState();
1962
2004
 
1963
2005
  return true;
1964
2006
  } catch (error) {