homebridge-melcloud-control 3.8.0-beta.2 → 3.8.0-beta.21

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 (9) hide show
  1. package/config.schema.json +84 -12
  2. package/index.js +4 -4
  3. package/package.json +1 -1
  4. package/src/deviceata.js +10 -13
  5. package/src/deviceatw.js +680 -687
  6. package/src/deviceerv.js +10 -13
  7. package/src/melcloudata.js +1 -1
  8. package/src/melcloudatw.js +1 -1
  9. package/src/melclouderv.js +1 -1
package/src/deviceatw.js CHANGED
@@ -275,6 +275,7 @@ class DeviceAtw extends EventEmitter {
275
275
  async startImpulseGenerator() {
276
276
  try {
277
277
  //start impule generator
278
+ await new Promise(resolve => setTimeout(resolve, 1000));
278
279
  await this.melCloudAtw.impulseGenerator.start([{ name: 'checkState', sampling: this.refreshInterval }]);
279
280
  return true;
280
281
  } catch (error) {
@@ -287,6 +288,7 @@ class DeviceAtw extends EventEmitter {
287
288
  try {
288
289
  const presetsOnServer = this.accessory.presets;
289
290
  const zonesCount = this.accessory.zonesCount;
291
+ const caseHeatPump = this.accessory.caseHeatPump;
290
292
  const caseZone1 = this.accessory.caseZone1;
291
293
  const caseHotWater = this.accessory.caseHotWater;
292
294
  const caseZone2 = this.accessory.caseZone2;
@@ -318,208 +320,451 @@ class DeviceAtw extends EventEmitter {
318
320
  .setCharacteristic(Characteristic.ConfiguredName, accessoryName);
319
321
 
320
322
  //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;
323
+ if (zonesCount > 0) {
324
+ this.melCloudServices = [];
325
+ for (let i = 0; i < zonesCount; i++) {
326
+ const zoneName = this.accessory.zones[i].name
327
+ const serviceName = `${deviceTypeText} ${accessoryName}: ${zoneName}`;
328
+ switch (this.displayMode) {
329
+ case 1: //Heater Cooler
330
+ const debug = this.enableDebugMode ? this.emit('debug', `Prepare heather/cooler ${zoneName} service`) : false;
331
+ const melCloudService = new Service.HeaterCooler(serviceName, `HeaterCooler ${deviceId} ${i}`);
332
+ melCloudService.setPrimaryService(true);
333
+ melCloudService.getCharacteristic(Characteristic.Active)
334
+ .onGet(async () => {
335
+ const state = this.accessory.power;
336
+ return state;
337
+ })
338
+ .onSet(async (state) => {
339
+ try {
340
+ switch (i) {
341
+ case 0: //Heat Pump
342
+ deviceData.Device.Power = [false, true][state];
343
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
344
+ await this.melCloudAtw.send(deviceData);
345
+ const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set power: ${state ? 'ON' : 'OFF'}`);
346
+ break;
347
+ };
348
+ } catch (error) {
349
+ this.emit('warn', `Set power error: ${error}`);
344
350
  };
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;
351
+ });
352
+ melCloudService.getCharacteristic(Characteristic.CurrentHeaterCoolerState)
353
+ .onGet(async () => {
354
+ const value = this.accessory.zones[i].currentOperationMode;
355
+ return value;
356
+ });
357
+ melCloudService.getCharacteristic(Characteristic.TargetHeaterCoolerState)
358
+ .setProps({
359
+ minValue: this.accessory.zones[i].operationModesSetPropsMinValue,
360
+ maxValue: this.accessory.zones[i].operationModesSetPropsMaxValue,
361
+ validValues: this.accessory.zones[i].operationModesSetPropsValidValues
362
+ })
363
+ .onGet(async () => {
364
+ const value = this.accessory.zones[i].targetOperationMode;
365
+ return value;
366
+ })
367
+ .onSet(async (value) => {
368
+ try {
369
+ let operationModeText = '';
370
+ switch (i) {
371
+ case 0: //Heat Pump - ON, HEAT, COOL
372
+ switch (value) {
373
+ case caseHeatPump: //AUTO
374
+ deviceData.Device.Power = true;
375
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
376
+ break;
377
+ case 1: //HEAT
378
+ deviceData.Device.Power = true;
379
+ deviceData.Device.UnitStatus = 0;
380
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
381
+ break;
382
+ case 2: //COOL
383
+ deviceData.Device.Power = true;
384
+ deviceData.Device.UnitStatus = 1;
385
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
386
+ break;
387
+ };
388
+ operationModeText = [HeatPump.System[0], HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
389
+ break;
390
+ case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
391
+ switch (value) {
392
+ case 0: //AUTO - HEAT CURVE
393
+ deviceData.Device.OperationModeZone1 = 2;
394
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
395
+ break;
396
+ case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
397
+ deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
398
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
399
+ break;
400
+ case 2: //COOL - HEAT FLOW / COOL FLOW
401
+ deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
402
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
403
+ break;
404
+ };
405
+ operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
406
+ break;
407
+ case caseHotWater: //Hot Water - AUTO, HEAT NOW
408
+ switch (value) {
409
+ case 0: //AUTO
410
+ deviceData.Device.ForcedHotWaterMode = false;
411
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
412
+ break;
413
+ case 1: //HEAT
414
+ deviceData.Device.ForcedHotWaterMode = true;
415
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
416
+ break;
417
+ case 2: //COOL
418
+ deviceData.Device.ForcedHotWaterMode = false;
419
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
420
+ break
421
+ };
422
+ operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
423
+ break;
424
+ case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
425
+ switch (value) {
426
+ case 0: //AUTO
427
+ deviceData.Device.OperationModeZone2 = 2;
428
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
429
+ break;
430
+ case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
431
+ deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
432
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
433
+ break;
434
+ case 2: //COOL - HEAT FLOW / COOL FLOW
435
+ deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
436
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
437
+ break;
438
+ };
439
+ operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
440
+ break;
441
+ };
442
+
443
+ await this.melCloudAtw.send(deviceData);
444
+ const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set operation mode: ${operationModeText}`);
445
+ } catch (error) {
446
+ this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
447
+ };
448
+ });
449
+ melCloudService.getCharacteristic(Characteristic.CurrentTemperature)
450
+ .setProps({
451
+ minValue: -35,
452
+ maxValue: 150,
453
+ minStep: 0.5
454
+ })
455
+ .onGet(async () => {
456
+ const value = this.accessory.zones[i].roomTemperature;
457
+ return value;
458
+ });
459
+ //only for heat/cool, only cool and not for hot water tank
460
+ if ((heatCoolModes === 0 || heatCoolModes === 2) && i !== caseHotWater) {
461
+ melCloudService.getCharacteristic(Characteristic.CoolingThresholdTemperature)
462
+ .setProps({
463
+ minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
464
+ maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
465
+ minStep: this.accessory.temperatureIncrement
466
+ })
467
+ .onGet(async () => {
468
+ const value = this.accessory.zones[i].setTemperature;
469
+ return value;
470
+ })
471
+ .onSet(async (value) => {
472
+ try {
473
+ switch (i) {
474
+ case caseHeatPump: //Heat Pump
475
+ //deviceData.Device.SetTemperatureZone1 = value;
476
+ //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
383
477
  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;
478
+ case caseZone1: //Zone 1
479
+ switch (this.accessory.zones[i].operationMode) {
480
+ case 1: //HEAT FLOW
481
+ deviceData.Device.SetHeatFlowTemperatureZone1 = value;
482
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
483
+ break;
484
+ case 4: //COOL FLOW
485
+ deviceData.Device.SetCoolFlowTemperatureZone1 = value;
486
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
487
+ break;
488
+ default:
489
+ deviceData.Device.SetTemperatureZone1 = value;
490
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
491
+ break
492
+ };
392
493
  break;
393
- case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
394
- deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
395
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
494
+ case caseHotWater: //Hot Water
495
+ deviceData.Device.SetTankWaterTemperature = value;
496
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
396
497
  break;
397
- case 2: //COOL - HEAT FLOW / COOL FLOW
398
- deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
399
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
498
+ case caseZone2: //Zone 2
499
+ switch (this.accessory.zones[i].operationMode) {
500
+ case 1: //HEAT FLOW
501
+ deviceData.Device.SetHeatFlowTemperatureZone2 = value;
502
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
503
+ break;
504
+ case 4: //COOL FLOW
505
+ deviceData.Device.SetCoolFlowTemperatureZone2 = value;
506
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
507
+ break;
508
+ default:
509
+ deviceData.Device.SetTemperatureZone2 = value;
510
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
511
+ break
512
+ };
400
513
  break;
401
514
  };
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;
515
+
516
+ const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
517
+ const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
518
+ } catch (error) {
519
+ this.emit('warn', `${zoneName}, Set cooling threshold temperature error: ${error}`);
520
+ };
521
+ });
522
+ };
523
+ //device can heat/cool or only heat
524
+ if (heatCoolModes === 0 || heatCoolModes === 1) {
525
+ melCloudService.getCharacteristic(Characteristic.HeatingThresholdTemperature)
526
+ .setProps({
527
+ minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
528
+ maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
529
+ minStep: this.accessory.temperatureIncrement
530
+ })
531
+ .onGet(async () => {
532
+ const value = this.accessory.zones[i].setTemperature;
533
+ return value;
534
+ })
535
+ .onSet(async (value) => {
536
+ try {
537
+ switch (i) {
538
+ case caseHeatPump: //Heat Pump
539
+ //deviceData.Device.SetTemperatureZone1 = value;
540
+ //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
413
541
  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;
542
+ case caseZone1: //Zone 1
543
+ switch (this.accessory.zones[i].operationMode) {
544
+ case 1: //HEAT FLOW
545
+ deviceData.Device.SetHeatFlowTemperatureZone1 = value;
546
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
547
+ break;
548
+ case 4: //COOL FLOW
549
+ deviceData.Device.SetCoolFlowTemperatureZone1 = value;
550
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
551
+ break;
552
+ default:
553
+ deviceData.Device.SetTemperatureZone1 = value;
554
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
555
+ break
556
+ };
426
557
  break;
427
- case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
428
- deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
429
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
558
+ case caseHotWater: //Hot Water
559
+ deviceData.Device.SetTankWaterTemperature = value;
560
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
430
561
  break;
431
- case 2: //COOL - HEAT FLOW / COOL FLOW
432
- deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
433
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
562
+ case caseZone2: //Zone 2
563
+ switch (this.accessory.zones[i].operationMode) {
564
+ case 1: //HEAT FLOW
565
+ deviceData.Device.SetHeatFlowTemperatureZone2 = value;
566
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
567
+ break;
568
+ case 4: //COOL FLOW
569
+ deviceData.Device.SetCoolFlowTemperatureZone2 = value;
570
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
571
+ break;
572
+ default:
573
+ deviceData.Device.SetTemperatureZone2 = value;
574
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
575
+ break
576
+ };
434
577
  break;
435
578
  };
436
- operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
437
- break;
438
- };
439
579
 
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)
580
+ const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
581
+ const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
582
+ } catch (error) {
583
+ this.emit('warn', `${zoneName}, Set heating threshold temperature error: ${error}`);
584
+ };
585
+ });
586
+ };
587
+ melCloudService.getCharacteristic(Characteristic.LockPhysicalControls)
588
+ .onGet(async () => {
589
+ const value = this.accessory.zones[i].lockPhysicalControl;
590
+ return value;
591
+ })
592
+ .onSet(async (value) => {
593
+ try {
594
+ value = value ? true : false;
595
+ switch (i) {
596
+ case caseHeatPump: //Heat Pump
597
+ deviceData.Device.ProhibitZone1 = value;
598
+ deviceData.Device.ProhibitHotWater = value;
599
+ deviceData.Device.ProhibitZone2 = value;
600
+ HeatPump.EffectiveFlags.ProhibitHeatingZone1 + HeatPump.EffectiveFlags.ProhibitHotWater + HeatPump.EffectiveFlags.ProhibitHeatingZone2;
601
+ break;
602
+ case caseZone1: //Zone 1
603
+ deviceData.Device.ProhibitZone1 = value;
604
+ HeatPump.EffectiveFlags.ProhibitHeatingZone1;
605
+ break;
606
+ case caseHotWater: //Hot Water
607
+ deviceData.Device.ProhibitHotWater = value;
608
+ HeatPump.EffectiveFlags.ProhibitHotWater;
609
+ break;
610
+ case caseZone2: //Zone 2
611
+ deviceData.Device.ProhibitZone2 = value;
612
+ HeatPump.EffectiveFlags.ProhibitHeatingZone2;
613
+ break;
614
+ };
615
+
616
+ await this.melCloudAtw.send(deviceData);
617
+ const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set lock physical controls: ${value ? 'LOCK' : 'UNLOCK'}`);
618
+ } catch (error) {
619
+ this.emit('warn', `${zoneName}, Set lock physical controls error: ${error}`);
620
+ };
621
+ });
622
+ melCloudService.getCharacteristic(Characteristic.TemperatureDisplayUnits)
623
+ .onGet(async () => {
624
+ const value = this.accessory.useFahrenheit;
625
+ return value;
626
+ })
627
+ .onSet(async (value) => {
628
+ try {
629
+ accountInfo.UseFahrenheit = [false, true][value];
630
+ await this.melCloud.send(accountInfo);
631
+ this.accessory.useFahrenheit = value;
632
+ const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${TemperatureDisplayUnits[value]}`);
633
+ } catch (error) {
634
+ this.emit('warn', `Set temperature display unit error: ${error}`);
635
+ };
636
+ });
637
+ this.melCloudServices.push(melCloudService);
638
+ accessory.addService(melCloudService);
639
+ break;
640
+ case 2: //Thermostat
641
+ const debug3 = this.enableDebugMode ? this.emit('debug', `Prepare thermostat ${zoneName} service`) : false;
642
+ const melCloudServiceT = new Service.Thermostat(serviceName, `Thermostat ${deviceId} ${i}`);
643
+ melCloudServiceT.setPrimaryService(true);
644
+ melCloudServiceT.getCharacteristic(Characteristic.CurrentHeatingCoolingState)
645
+ .onGet(async () => {
646
+ const value = this.accessory.zones[i].currentOperationMode;
647
+ return value;
648
+ });
649
+ melCloudServiceT.getCharacteristic(Characteristic.TargetHeatingCoolingState)
459
650
  .setProps({
460
- minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
461
- maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
462
- minStep: this.accessory.temperatureIncrement
651
+ minValue: this.accessory.zones[i].operationModesSetPropsMinValue,
652
+ maxValue: this.accessory.zones[i].operationModesSetPropsMaxValue,
653
+ validValues: this.accessory.zones[i].operationModesSetPropsValidValues
463
654
  })
464
655
  .onGet(async () => {
465
- const value = this.accessory.zones[i].setTemperature;
656
+ const value = this.accessory.zones[i].targetOperationMode;
466
657
  return value;
467
658
  })
468
659
  .onSet(async (value) => {
469
660
  try {
661
+ let operationModeText = '';
470
662
  switch (i) {
471
- case 0: //Heat Pump
472
- //deviceData.Device.SetTemperatureZone1 = value;
473
- //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
663
+ case caseHeatPump: //Heat Pump - HEAT, COOL
664
+ switch (value) {
665
+ case 0: //OFF
666
+ deviceData.Device.Power = false;
667
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
668
+ break;
669
+ case 1: //HEAT
670
+ deviceData.Device.Power = true;
671
+ deviceData.Device.UnitStatus = 0;
672
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
673
+ break;
674
+ case 2: //COOL
675
+ deviceData.Device.Power = true;
676
+ deviceData.Device.UnitStatus = 1;
677
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
678
+ break;
679
+ case 3: //AUTO
680
+ deviceData.Device.Power = true;
681
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
682
+ break;
683
+ };
684
+ operationModeText = [HeatPump.System[0], HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
474
685
  break;
475
- 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;
686
+ case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
687
+ switch (value) {
688
+ case 0: //OFF - HEAT CURVE
689
+ deviceData.Device.OperationModeZone1 = 2;
690
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
480
691
  break;
481
- case 4: //COOL FLOW
482
- deviceData.Device.SetCoolFlowTemperatureZone1 = value;
483
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
692
+ case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
693
+ deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
694
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
695
+ break;
696
+ case 2: //COOL - HEAT FLOW / COOL FLOW
697
+ deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
698
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
699
+ break;
700
+ case 3: //AUTO - HEAT CURVE
701
+ deviceData.Device.OperationModeZone1 = 2;
702
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
484
703
  break;
485
- default:
486
- deviceData.Device.SetTemperatureZone1 = value;
487
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
488
- break
489
704
  };
705
+ operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
490
706
  break;
491
- case caseHotWater: //Hot Water
492
- deviceData.Device.SetTankWaterTemperature = value;
493
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
707
+ case caseHotWater: //Hot Water - AUTO, HEAT NOW
708
+ switch (value) {
709
+ case 0: //OFF
710
+ deviceData.Device.ForcedHotWaterMode = false;
711
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
712
+ break;
713
+ case 1: //HEAT
714
+ deviceData.Device.ForcedHotWaterMode = true;
715
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
716
+ break;
717
+ case 2: //COOL
718
+ deviceData.Device.ForcedHotWaterMode = false;
719
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
720
+ break;
721
+ case 3: //AUTO
722
+ deviceData.Device.ForcedHotWaterMode = false;
723
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
724
+ break;
725
+ };
726
+ operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
494
727
  break;
495
- 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;
728
+ case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
729
+ switch (value) {
730
+ case 0: //OFF - HEAT CURVE
731
+ deviceData.Device.OperationModeZone2 = 2;
732
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
500
733
  break;
501
- case 4: //COOL FLOW
502
- deviceData.Device.SetCoolFlowTemperatureZone2 = value;
503
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
734
+ case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
735
+ deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
736
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
737
+ break;
738
+ case 2: //COOL - HEAT FLOW / COOL FLOW
739
+ deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
740
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
741
+ break;
742
+ case 3: //AUTO - HEAT CURVE
743
+ deviceData.Device.OperationModeZone2 = 2;
744
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
504
745
  break;
505
- default:
506
- deviceData.Device.SetTemperatureZone2 = value;
507
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
508
- break
509
746
  };
747
+ operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
510
748
  break;
511
749
  };
512
750
 
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}`);
751
+ await this.melCloudAtw.send(deviceData);
752
+ const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set operation mode: ${operationModeText}`);
515
753
  } catch (error) {
516
- this.emit('warn', `${zoneName}, Set cooling threshold temperature error: ${error}`);
754
+ this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
517
755
  };
518
756
  });
519
- };
520
- //device can heat/cool or only heat
521
- if (heatCoolModes === 0 || heatCoolModes === 1) {
522
- melCloudService.getCharacteristic(Characteristic.HeatingThresholdTemperature)
757
+ melCloudServiceT.getCharacteristic(Characteristic.CurrentTemperature)
758
+ .setProps({
759
+ minValue: -35,
760
+ maxValue: 150,
761
+ minStep: 0.5
762
+ })
763
+ .onGet(async () => {
764
+ const value = this.accessory.zones[i].roomTemperature;
765
+ return value;
766
+ });
767
+ melCloudServiceT.getCharacteristic(Characteristic.TargetTemperature)
523
768
  .setProps({
524
769
  minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
525
770
  maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
@@ -532,514 +777,273 @@ class DeviceAtw extends EventEmitter {
532
777
  .onSet(async (value) => {
533
778
  try {
534
779
  switch (i) {
535
- case 0: //Heat Pump
780
+ case caseHeatPump: //Heat Pump
536
781
  //deviceData.Device.SetTemperatureZone1 = value;
537
782
  //deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
538
783
  break;
539
784
  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;
544
- break;
545
- case 4: //COOL FLOW
546
- deviceData.Device.SetCoolFlowTemperatureZone1 = value;
547
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
548
- break;
549
- default:
550
- deviceData.Device.SetTemperatureZone1 = value;
551
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
552
- break
553
- };
785
+ deviceData.Device.SetTemperatureZone1 = value;
786
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
554
787
  break;
555
788
  case caseHotWater: //Hot Water
556
789
  deviceData.Device.SetTankWaterTemperature = value;
557
790
  deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
558
791
  break;
559
792
  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;
564
- break;
565
- case 4: //COOL FLOW
566
- deviceData.Device.SetCoolFlowTemperatureZone2 = value;
567
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
568
- break;
569
- default:
570
- deviceData.Device.SetTemperatureZone2 = value;
571
- deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
572
- break
573
- };
793
+ deviceData.Device.SetTemperatureZone2 = value;
794
+ deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
574
795
  break;
575
796
  };
576
797
 
577
798
  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}`);
799
+ const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set temperature: ${value}${this.accessory.temperatureUnit}`);
579
800
  } catch (error) {
580
- this.emit('warn', `${zoneName}, Set heating threshold temperature error: ${error}`);
801
+ this.emit('warn', `${zoneName}, Set temperature error: ${error}`);
581
802
  };
582
803
  });
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)
830
- .setProps({
831
- minValue: -35,
832
- maxValue: 150,
833
- minStep: 0.5
834
- })
804
+ melCloudServiceT.getCharacteristic(Characteristic.TemperatureDisplayUnits)
835
805
  .onGet(async () => {
836
- const state = this.accessory.zones[i].roomTemperature;
837
- return state;
806
+ const value = this.accessory.useFahrenheit;
807
+ return value;
838
808
  })
839
- accessory.addService(this.roomTemperatureSensorService);
840
- };
809
+ .onSet(async (value) => {
810
+ try {
811
+ accountInfo.UseFahrenheit = [false, true][value];
812
+ await this.melCloud.send(accountInfo);
813
+ this.accessory.useFahrenheit = value;
814
+ const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${TemperatureDisplayUnits[value]}`);
815
+ } catch (error) {
816
+ this.emit('warn', `Set temperature display unit error: ${error}`);
817
+ };
818
+ });
819
+ this.melCloudServices.push(melCloudServiceT);
820
+ accessory.addService(melCloudServiceT);
821
+ break;
822
+ };
841
823
 
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)
848
- .setProps({
849
- minValue: -35,
850
- maxValue: 150,
851
- minStep: 0.5
852
- })
853
- .onGet(async () => {
854
- const state = this.accessory.zones[i].flowTemperature;
855
- return state;
856
- })
857
- accessory.addService(this.flowTemperatureSensorService);
824
+ //temperature sensor services zones
825
+ switch (i) {
826
+ case caseHeatPump: //Heat Pump
827
+ if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
828
+ const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
829
+ this.roomTemperatureSensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
830
+ this.roomTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
831
+ this.roomTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
832
+ this.roomTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
833
+ .setProps({
834
+ minValue: -35,
835
+ maxValue: 150,
836
+ minStep: 0.5
837
+ })
838
+ .onGet(async () => {
839
+ const state = this.accessory.zones[i].roomTemperature;
840
+ return state;
841
+ })
842
+ accessory.addService(this.roomTemperatureSensorService);
843
+ };
858
844
 
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
- })
890
- .onGet(async () => {
891
- const state = this.accessory.zones[i].roomTemperature;
892
- return state;
893
- })
894
- accessory.addService(this.roomTemperatureZone1SensorService);
895
- };
845
+ if (temperatureSensorFlow && this.accessory.zones[i].flowTemperature !== null) {
846
+ const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature sensor service`) : false;
847
+ this.flowTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
848
+ this.flowTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
849
+ this.flowTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
850
+ this.flowTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
851
+ .setProps({
852
+ minValue: -35,
853
+ maxValue: 150,
854
+ minStep: 0.5
855
+ })
856
+ .onGet(async () => {
857
+ const state = this.accessory.zones[i].flowTemperature;
858
+ return state;
859
+ })
860
+ accessory.addService(this.flowTemperatureSensorService);
896
861
 
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
- };
862
+ };
863
+ if (temperatureSensorReturn && this.accessory.zones[i].returnTemperature !== null) {
864
+ const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature sensor service`) : false;
865
+ this.returnTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
866
+ this.returnTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
867
+ this.returnTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
868
+ this.returnTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
869
+ .setProps({
870
+ minValue: -35,
871
+ maxValue: 150,
872
+ minStep: 0.5
873
+ })
874
+ .onGet(async () => {
875
+ const state = this.accessory.zones[i].returnTemperature;
876
+ return state;
877
+ })
878
+ accessory.addService(this.returnTemperatureSensorService);
879
+ };
880
+ break;
881
+ case caseZone1: //Zone 1
882
+ if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
883
+ const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
884
+ this.roomTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
885
+ this.roomTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
886
+ this.roomTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
887
+ this.roomTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
888
+ .setProps({
889
+ minValue: -35,
890
+ maxValue: 150,
891
+ minStep: 0.5
892
+ })
893
+ .onGet(async () => {
894
+ const state = this.accessory.zones[i].roomTemperature;
895
+ return state;
896
+ })
897
+ accessory.addService(this.roomTemperatureZone1SensorService);
898
+ };
914
899
 
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
- };
900
+ if (temperatureSensorFlowZone1 && this.accessory.zones[i].flowTemperature !== null) {
901
+ const debug2 = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature zone 1 sensor service`) : false;
902
+ this.flowTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
903
+ this.flowTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
904
+ this.flowTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
905
+ this.flowTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
906
+ .setProps({
907
+ minValue: -35,
908
+ maxValue: 150,
909
+ minStep: 0.5
910
+ })
911
+ .onGet(async () => {
912
+ const state = this.accessory.zones[i].flowTemperature;
913
+ return state;
914
+ })
915
+ accessory.addService(this.flowTemperatureZone1SensorService);
916
+ };
951
917
 
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
- };
918
+ if (temperatureSensorReturnZone1 && this.accessory.zones[i].returnTemperature !== null) {
919
+ const debug3 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature zone 1 sensor service`) : false;
920
+ this.returnTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
921
+ this.returnTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
922
+ this.returnTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
923
+ this.returnTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
924
+ .setProps({
925
+ minValue: -35,
926
+ maxValue: 150,
927
+ minStep: 0.5
928
+ })
929
+ .onGet(async () => {
930
+ const state = this.accessory.zones[i].returnTemperature;
931
+ return state;
932
+ })
933
+ accessory.addService(this.returnTemperatureZone1SensorService);
934
+ };
935
+ break;
936
+ case caseHotWater: //Hot Water
937
+ if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
938
+ const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
939
+ this.roomTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
940
+ this.roomTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
941
+ this.roomTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
942
+ this.roomTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
943
+ .setProps({
944
+ minValue: -35,
945
+ maxValue: 150,
946
+ minStep: 0.5
947
+ })
948
+ .onGet(async () => {
949
+ const state = this.accessory.zones[i].roomTemperature;
950
+ return state;
951
+ })
952
+ accessory.addService(this.roomTemperatureWaterTankSensorService);
953
+ };
969
954
 
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
- };
955
+ if (temperatureSensorFlowWaterTank && this.accessory.zones[i].flowTemperature !== null) {
956
+ const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature water tank sensor service`) : false;
957
+ this.flowTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
958
+ this.flowTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
959
+ this.flowTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
960
+ this.flowTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
961
+ .setProps({
962
+ minValue: -35,
963
+ maxValue: 150,
964
+ minStep: 0.5
965
+ })
966
+ .onGet(async () => {
967
+ const state = this.accessory.zones[i].flowTemperature;
968
+ return state;
969
+ })
970
+ accessory.addService(this.flowTemperatureWaterTankSensorService);
971
+ };
1006
972
 
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
- };
973
+ if (temperatureSensorReturnWaterTank && this.accessory.zones[i].returnTemperature !== null) {
974
+ const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature water tank sensor service`) : false;
975
+ this.returnTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
976
+ this.returnTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
977
+ this.returnTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
978
+ this.returnTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
979
+ .setProps({
980
+ minValue: -35,
981
+ maxValue: 150,
982
+ minStep: 0.5
983
+ })
984
+ .onGet(async () => {
985
+ const state = this.accessory.zones[i].returnTemperature;
986
+ return state;
987
+ })
988
+ accessory.addService(this.returnTemperatureWaterTankSensorService);
989
+ };
990
+ break;
991
+ case caseZone2: //Zone 2
992
+ if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
993
+ const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
994
+ this.roomTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
995
+ this.roomTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
996
+ this.roomTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
997
+ this.roomTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
998
+ .setProps({
999
+ minValue: -35,
1000
+ maxValue: 150,
1001
+ minStep: 0.5
1002
+ })
1003
+ .onGet(async () => {
1004
+ const state = this.accessory.zones[i].roomTemperature;
1005
+ return state;
1006
+ })
1007
+ accessory.addService(this.roomTemperatureZone2SensorService);
1008
+ };
1024
1009
 
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;
1010
+ if (temperatureSensorFlowZone2 && this.accessory.zones[i].flowTemperature !== null) {
1011
+ const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature zone 2 sensor service`) : false;
1012
+ this.flowTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow${deviceId} ${i}`);
1013
+ this.flowTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1014
+ this.flowTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
1015
+ this.flowTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
1016
+ .setProps({
1017
+ minValue: -35,
1018
+ maxValue: 150,
1019
+ minStep: 0.5
1020
+ })
1021
+ .onGet(async () => {
1022
+ const state = this.accessory.zones[i].flowTemperature;
1023
+ return state;
1024
+ })
1025
+ accessory.addService(this.flowTemperatureZone2SensorService);
1026
+ };
1027
+
1028
+ if (temperatureSensorReturnZone2 && this.accessory.zones[i].returnTemperature !== null) {
1029
+ const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature zone 2 sensor service`) : false;
1030
+ this.returnTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return${deviceId} ${i}`);
1031
+ this.returnTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
1032
+ this.returnTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
1033
+ this.returnTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
1034
+ .setProps({
1035
+ minValue: -35,
1036
+ maxValue: 150,
1037
+ minStep: 0.5
1038
+ })
1039
+ .onGet(async () => {
1040
+ const state = this.accessory.zones[i].returnTemperature;
1041
+ return state;
1042
+ })
1043
+ accessory.addService(this.returnTemperatureZone2SensorService);
1044
+ };
1045
+ break;
1046
+ };
1043
1047
  };
1044
1048
  };
1045
1049
 
@@ -1331,34 +1335,32 @@ class DeviceAtw extends EventEmitter {
1331
1335
  this.firmwareRevision = firmwareAppVersion;
1332
1336
  this.displayDeviceInfo = false;
1333
1337
  })
1334
- .on('deviceState', (deviceData) => {
1338
+ .on('deviceState', async (deviceData) => {
1335
1339
  this.deviceData = deviceData;
1336
1340
 
1337
1341
  //presets
1338
1342
  const presetsOnServer = deviceData.Presets ?? [];
1339
1343
 
1340
1344
  //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;
1345
+ const hasHeatPump = ![1, 2, 3, 4, 5, 6, 13].includes(this.hideZone);
1346
+ const hasZone1 = ![2, 3, 4, 7, 8, 9, 13].includes(this.hideZone);
1347
+ const hasHotWaterTank = ![3, 5, 6, 8, 9, 10, 11, 13].includes(this.hideZone) && deviceData.Device.HasHotWaterTank;
1348
+ const hasZone2 = ![4, 6, 9, 11, 13].includes(this.hideZone) && deviceData.Device.HasZone2;
1344
1349
  const canHeat = deviceData.Device.CanHeat ?? false;
1345
1350
  const canCool = deviceData.Device.CanCool ?? false;
1346
1351
  const heatCoolModes = canHeat && canCool ? 0 : canHeat ? 1 : canCool ? 2 : 3;
1347
1352
  const temperatureIncrement = deviceData.Device.TemperatureIncrement ?? 1;
1348
1353
  const minSetTemperature = deviceData.Device.MinSetTemperature ?? 10;
1349
1354
  const maxSetTemperature = deviceData.Device.MaxSetTemperature ?? 30;
1350
- const maxTankTemperature = deviceData.Device.MaxTankTemperature ?? 70
1355
+ const maxTankTemperature = deviceData.Device.MaxTankTemperature ?? 70;
1351
1356
 
1352
1357
  //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;
1358
+ let currentCase = 0;
1359
+ const caseHeatPump = hasHeatPump ? currentCase++ : -1;
1360
+ const caseZone1 = hasZone1 ? currentCase++ : -1;
1361
+ const caseHotWater = hasHotWaterTank ? currentCase++ : -1;
1362
+ const caseZone2 = hasZone2 ? currentCase++ : -1;
1363
+ const zonesCount = currentCase;
1362
1364
 
1363
1365
  //heat pump
1364
1366
  const heatPumpName = 'Heat Pump';
@@ -1415,6 +1417,7 @@ class DeviceAtw extends EventEmitter {
1415
1417
  this.accessory.hasZone2 = hasZone2;
1416
1418
  this.accessory.zonesCount = zonesCount;
1417
1419
  this.accessory.heatCoolModes = heatCoolModes;
1420
+ this.accessory.caseHeatPump = caseHeatPump;
1418
1421
  this.accessory.caseZone1 = caseZone1;
1419
1422
  this.accessory.caseHotWater = caseHotWater;
1420
1423
  this.accessory.caseZone2 = caseZone2;
@@ -1439,7 +1442,7 @@ class DeviceAtw extends EventEmitter {
1439
1442
  switch (this.displayMode) {
1440
1443
  case 1: //Heater Cooler
1441
1444
  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
1445
+ 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
1446
  name = heatPumpName;
1444
1447
  operationModeZone = operationMode;
1445
1448
  currentOperationMode = !power ? 0 : [1, 2, 2, 3, 2, 1, 1, 2, 1, 1, 1, 2][operationMode]; //INACTIVE, IDLE, HEATING, COOLING
@@ -1543,9 +1546,6 @@ class DeviceAtw extends EventEmitter {
1543
1546
  operationModeSetPropsMaxValue = [2, 2, 2, 0][heatCoolModes];
1544
1547
  operationModeSetPropsValidValues = [[0, 1, 2], [0, 1, 2], [1, 2], [0]][heatCoolModes];
1545
1548
  break;
1546
- default: //unknown zone detected
1547
- this.emit('message', `Unknown zone: ${i} detected`);
1548
- break;
1549
1549
  };
1550
1550
 
1551
1551
  //update characteristics
@@ -1563,7 +1563,7 @@ class DeviceAtw extends EventEmitter {
1563
1563
  break;
1564
1564
  case 2: //Thermostat
1565
1565
  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
1566
+ 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
1567
  name = heatPumpName;
1568
1568
  operationModeZone = operationMode;
1569
1569
  currentOperationMode = !power ? 0 : [0, 1, 1, 2, 1, 0, 0, 1, 0, 0, 0, 1][operationMode]; //OFF, HEAT, COOL
@@ -1653,9 +1653,6 @@ class DeviceAtw extends EventEmitter {
1653
1653
  operationModeSetPropsMaxValue = [3, 3, 2, 0][heatCoolModes];
1654
1654
  operationModeSetPropsValidValues = [[1, 2, 3], [1, 2, 3], [1, 2], [0]][heatCoolModes];
1655
1655
  break;
1656
- default: //unknown zone detected
1657
- this.emit('message', `Unknown zone: ${i} detected`);
1658
- break;
1659
1656
  };
1660
1657
 
1661
1658
  //update characteristics
@@ -1670,7 +1667,7 @@ class DeviceAtw extends EventEmitter {
1670
1667
  break;
1671
1668
  };
1672
1669
 
1673
- //push value to arrays
1670
+ //add value to arrays
1674
1671
  this.accessory.zones[i].name = name;
1675
1672
  this.accessory.zones[i].operationMode = operationModeZone;
1676
1673
  this.accessory.zones[i].currentOperationMode = currentOperationMode;
@@ -1692,7 +1689,7 @@ class DeviceAtw extends EventEmitter {
1692
1689
 
1693
1690
  //update temperature sensors
1694
1691
  switch (i) {
1695
- case 0: //Heat Pump
1692
+ case caseHeatPump: //Heat Pump
1696
1693
  if (this.roomTemperatureSensorService) {
1697
1694
  this.roomTemperatureSensorService
1698
1695
  .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
@@ -1708,7 +1705,7 @@ class DeviceAtw extends EventEmitter {
1708
1705
  .updateCharacteristic(Characteristic.CurrentTemperature, returnTemperature)
1709
1706
  };
1710
1707
  break;
1711
- case 1: //Zone 1
1708
+ case caseZone1: //Zone 1
1712
1709
  if (this.roomTemperatureZone1SensorService) {
1713
1710
  this.roomTemperatureZone1SensorService
1714
1711
  .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
@@ -1762,7 +1759,7 @@ class DeviceAtw extends EventEmitter {
1762
1759
  if (!this.disableLogInfo) {
1763
1760
  let operationModeText = '';
1764
1761
  switch (i) {
1765
- case 0: //Heat Pump - HEAT, COOL, OFF
1762
+ case caseHeatPump: //Heat Pump - HEAT, COOL, OFF
1766
1763
  this.emit('message', `${heatPumpName}, Power: ${power ? 'ON' : 'OFF'}`)
1767
1764
  this.emit('message', `${heatPumpName}, Operation mode: ${HeatPump.System[unitStatus]}`);
1768
1765
  this.emit('message', `${heatPumpName},'Outdoor temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
@@ -1771,7 +1768,7 @@ class DeviceAtw extends EventEmitter {
1771
1768
  this.emit('message', `${heatPumpName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
1772
1769
  this.emit('message', `${heatPumpName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
1773
1770
  break;
1774
- case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1771
+ case caseZone1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
1775
1772
  operationModeText = idleZone1 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone1];
1776
1773
  this.emit('message', `${zone1Name}, Operation mode: ${operationModeText}`);
1777
1774
  this.emit('message', `${zone1Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
@@ -1920,6 +1917,13 @@ class DeviceAtw extends EventEmitter {
1920
1917
  };
1921
1918
  };
1922
1919
  };
1920
+
1921
+ //prepare accessory
1922
+ if (this.startPrepareAccessory) {
1923
+ const accessory = await this.prepareAccessory(this.accountInfo, deviceData, this.deviceId, this.deviceTypeText, this.deviceName, this.accountName);
1924
+ this.emit('publishAccessory', accessory);
1925
+ this.startPrepareAccessory = false;
1926
+ }
1923
1927
  })
1924
1928
  .on('success', (success) => {
1925
1929
  this.emit('success', success);
@@ -1947,18 +1951,7 @@ class DeviceAtw extends EventEmitter {
1947
1951
  const startExternalIntegrations = this.restFul.enable || this.mqtt.enable ? await this.externalIntegrations() : false;
1948
1952
 
1949
1953
  //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
- }
1954
+ await this.melCloudAtw.checkState();
1962
1955
 
1963
1956
  return true;
1964
1957
  } catch (error) {