homebridge-melcloud-control 4.2.3-beta.8 → 4.2.5-beta.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.
- package/CHANGELOG.md +11 -0
- package/README.md +36 -21
- package/config.schema.json +433 -25
- package/homebridge-ui/public/index.html +86 -16
- package/index.js +3 -3
- package/package.json +2 -2
- package/src/constants.js +48 -5
- package/src/deviceata.js +274 -155
- package/src/deviceatw.js +334 -218
- package/src/deviceerv.js +250 -126
- package/src/melcloud.js +24 -31
- package/src/melcloudata.js +44 -23
- package/src/melcloudatw.js +50 -31
- package/src/melclouderv.js +41 -23
- package/src/melcloudhome.js +76 -37
package/src/deviceata.js
CHANGED
|
@@ -43,6 +43,7 @@ class DeviceAta extends EventEmitter {
|
|
|
43
43
|
this.holidayModeSupport = device.holidayModeSupport || false;
|
|
44
44
|
this.presets = this.accountType === 'melcloud' ? (device.presets || []).filter(preset => (preset.displayType ?? 0) > 0 && preset.id !== '0') : [];
|
|
45
45
|
this.schedules = this.accountType === 'melcloudhome' ? (device.schedules || []).filter(schedule => (schedule.displayType ?? 0) > 0 && schedule.id !== '0') : [];
|
|
46
|
+
this.scenes = this.accountType === 'melcloudhome' ? (device.scenes || []).filter(scene => (scene.displayType ?? 0) > 0 && scene.id !== '0') : [];
|
|
46
47
|
this.buttons = (device.buttonsSensors || []).filter(sensor => (sensor.displayType ?? 0) > 0);
|
|
47
48
|
|
|
48
49
|
//files
|
|
@@ -55,24 +56,35 @@ class DeviceAta extends EventEmitter {
|
|
|
55
56
|
this.restFulConnected = false;
|
|
56
57
|
this.mqtt = account.mqtt ?? {};
|
|
57
58
|
this.mqttConnected = false;
|
|
59
|
+
|
|
60
|
+
const serviceType = [null, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor];
|
|
61
|
+
const characteristicType = [null, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState];
|
|
58
62
|
|
|
59
63
|
//presets configured
|
|
60
64
|
for (const preset of this.presets) {
|
|
61
|
-
preset.name = preset.name
|
|
62
|
-
preset.serviceType = [
|
|
63
|
-
preset.characteristicType = [
|
|
65
|
+
preset.name = preset.name;
|
|
66
|
+
preset.serviceType = serviceType[preset.displayType];
|
|
67
|
+
preset.characteristicType = characteristicType[preset.displayType];
|
|
64
68
|
preset.state = false;
|
|
65
69
|
preset.previousSettings = {};
|
|
66
70
|
}
|
|
67
71
|
|
|
68
72
|
//schedules configured
|
|
69
73
|
for (const schedule of this.schedules) {
|
|
70
|
-
schedule.name = schedule.name
|
|
71
|
-
schedule.serviceType = [
|
|
72
|
-
schedule.characteristicType = [
|
|
74
|
+
schedule.name = schedule.name;
|
|
75
|
+
schedule.serviceType = serviceType[schedule.displayType];
|
|
76
|
+
schedule.characteristicType = characteristicType[schedule.displayType];
|
|
73
77
|
schedule.state = false;
|
|
74
78
|
}
|
|
75
79
|
|
|
80
|
+
//scenes configured
|
|
81
|
+
for (const scene of this.scenes) {
|
|
82
|
+
scene.name = scene.name;
|
|
83
|
+
scene.serviceType = serviceType[scene.displayType];
|
|
84
|
+
scene.characteristicType = characteristicType[scene.displayType];
|
|
85
|
+
scene.state = false;
|
|
86
|
+
}
|
|
87
|
+
|
|
76
88
|
//buttons configured
|
|
77
89
|
for (const button of this.buttons) {
|
|
78
90
|
button.name = button.name || 'Button'
|
|
@@ -171,101 +183,101 @@ class DeviceAta extends EventEmitter {
|
|
|
171
183
|
async setOverExternalIntegration(integration, deviceData, key, value) {
|
|
172
184
|
try {
|
|
173
185
|
let set = false
|
|
174
|
-
let
|
|
186
|
+
let flag = null;
|
|
175
187
|
switch (key) {
|
|
176
188
|
case 'Power':
|
|
177
189
|
deviceData.Device[key] = value;
|
|
178
|
-
|
|
190
|
+
flag = AirConditioner.EffectiveFlags.Power;
|
|
179
191
|
break;
|
|
180
192
|
case 'OperationMode':
|
|
181
193
|
deviceData.Device[key] = value;
|
|
182
|
-
|
|
194
|
+
flag = AirConditioner.EffectiveFlags.OperationMode
|
|
183
195
|
break;
|
|
184
196
|
case 'SetTemperature':
|
|
185
197
|
deviceData.Device[key] = value;
|
|
186
|
-
|
|
198
|
+
flag = AirConditioner.EffectiveFlags.SetTemperature;
|
|
187
199
|
break;
|
|
188
200
|
case 'DefaultCoolingSetTemperature':
|
|
189
201
|
deviceData.Device[key] = value;
|
|
190
|
-
|
|
202
|
+
flag = AirConditioner.EffectiveFlags.SetTemperature;
|
|
191
203
|
break;
|
|
192
204
|
case 'DefaultHeatingSetTemperature':
|
|
193
205
|
deviceData.Device[key] = value;
|
|
194
|
-
|
|
206
|
+
flag = AirConditioner.EffectiveFlags.SetTemperature;
|
|
195
207
|
break;
|
|
196
208
|
case 'FanSpeed':
|
|
197
209
|
key = this.accountType === 'melcloud' ? key : 'SetFanSpeed';
|
|
198
210
|
deviceData.Device[key] = value;
|
|
199
|
-
|
|
211
|
+
flag = AirConditioner.EffectiveFlags.SetFanSpeed;
|
|
200
212
|
break;
|
|
201
213
|
case 'VaneHorizontalDirection':
|
|
202
214
|
deviceData.Device[key] = value;
|
|
203
|
-
|
|
215
|
+
flag = AirConditioner.EffectiveFlags.VaneHorizontalDirection;
|
|
204
216
|
break;
|
|
205
217
|
case 'VaneVerticalDirection':
|
|
206
218
|
deviceData.Device[key] = value;
|
|
207
|
-
|
|
219
|
+
flag = AirConditioner.EffectiveFlags.VaneVerticalDirection;
|
|
208
220
|
break;
|
|
209
221
|
case 'HideVaneControls':
|
|
210
222
|
if (this.accountType === 'melcloudhome') return;
|
|
211
223
|
|
|
212
224
|
deviceData[key] = value;
|
|
213
|
-
|
|
225
|
+
flag = AirConditioner.EffectiveFlags.Prohibit;
|
|
214
226
|
break;
|
|
215
227
|
case 'HideDryModeControl':
|
|
216
228
|
if (this.accountType === 'melcloudhome') return;
|
|
217
229
|
|
|
218
230
|
deviceData[key] = value;
|
|
219
|
-
|
|
231
|
+
flag = AirConditioner.EffectiveFlags.Prohibit;
|
|
220
232
|
break;
|
|
221
233
|
case 'ProhibitSetTemperature':
|
|
222
234
|
if (this.accountType === 'melcloudhome') return;
|
|
223
235
|
|
|
224
236
|
deviceData.Device[key] = value;
|
|
225
|
-
|
|
237
|
+
flag = AirConditioner.EffectiveFlags.Prohibit;
|
|
226
238
|
break;
|
|
227
239
|
case 'ProhibitOperationMode':
|
|
228
240
|
if (this.accountType === 'melcloudhome') return;
|
|
229
241
|
|
|
230
242
|
deviceData.Device[key] = value;
|
|
231
|
-
|
|
243
|
+
flag = AirConditioner.EffectiveFlags.Prohibit;
|
|
232
244
|
break;
|
|
233
245
|
case 'ProhibitPower':
|
|
234
246
|
if (this.accountType === 'melcloudhome') return;
|
|
235
247
|
|
|
236
248
|
deviceData.Device[key] = value;
|
|
237
|
-
|
|
249
|
+
flag = AirConditioner.EffectiveFlags.Prohibit;
|
|
238
250
|
break;
|
|
239
251
|
case 'FrostProtection':
|
|
240
252
|
if (this.accountType === 'melcloud') return;
|
|
241
253
|
|
|
242
254
|
deviceData.Device[key].Enabled = value;
|
|
243
|
-
|
|
255
|
+
flag = 'frostprotection';
|
|
244
256
|
break;
|
|
245
257
|
case 'OverheatProtection':
|
|
246
258
|
if (this.accountType === 'melcloud') return;
|
|
247
259
|
|
|
248
260
|
deviceData.Device[key].Enabled = value;
|
|
249
|
-
|
|
261
|
+
flag = 'overheatprotection';
|
|
250
262
|
break;
|
|
251
263
|
case 'ScheduleEnabled':
|
|
252
264
|
if (this.accountType === 'melcloud') return;
|
|
253
265
|
|
|
254
266
|
deviceData.Device[key].Enabled = value;
|
|
255
|
-
|
|
267
|
+
flag = 'schedule';
|
|
256
268
|
break;
|
|
257
269
|
case 'HolidayMode':
|
|
258
270
|
if (this.accountType === 'melcloud') return;
|
|
259
271
|
|
|
260
272
|
deviceData.Device[key].Enabled = value;
|
|
261
|
-
|
|
273
|
+
flag = 'holidaymode';
|
|
262
274
|
break;
|
|
263
275
|
default:
|
|
264
276
|
this.emit('warn', `${integration}, received key: ${key}, value: ${value}`);
|
|
265
277
|
break;
|
|
266
278
|
};
|
|
267
279
|
|
|
268
|
-
set = await this.melCloudAta.send(this.accountType, this.displayType, deviceData,
|
|
280
|
+
set = await this.melCloudAta.send(this.accountType, this.displayType, deviceData, flag);
|
|
269
281
|
return set;
|
|
270
282
|
} catch (error) {
|
|
271
283
|
throw new Error(`${integration} set key: ${key}, value: ${value}, error: ${error.message ?? error}`);
|
|
@@ -292,6 +304,7 @@ class DeviceAta extends EventEmitter {
|
|
|
292
304
|
const accountName = this.accountName;
|
|
293
305
|
const presetsOnServer = this.accessory.presets;
|
|
294
306
|
const schedulesOnServer = this.accessory.schedules;
|
|
307
|
+
const scenesOnServer = this.accessory.scenes;
|
|
295
308
|
const supportsHeat = this.accessory.supportsHeat;
|
|
296
309
|
const supportsDry = this.accessory.supportsDry;
|
|
297
310
|
const supportsCool = this.accessory.supportsCool;
|
|
@@ -334,12 +347,10 @@ class DeviceAta extends EventEmitter {
|
|
|
334
347
|
return state;
|
|
335
348
|
})
|
|
336
349
|
.onSet(async (state) => {
|
|
337
|
-
if (!!state === this.accessory.power) return;
|
|
338
|
-
|
|
339
350
|
try {
|
|
340
351
|
deviceData.Device.Power = state ? true : false;
|
|
341
352
|
await this.melCloudAta.send(this.accountType, this.displayType, deviceData, AirConditioner.EffectiveFlags.Power);
|
|
342
|
-
if (this.logInfo) this.emit('info', `Set power: ${state ? '
|
|
353
|
+
if (this.logInfo) this.emit('info', `Set power: ${state ? 'On' : 'Off'}`);
|
|
343
354
|
} catch (error) {
|
|
344
355
|
if (this.logWarn) this.emit('warn', `Set power error: ${error}`);
|
|
345
356
|
};
|
|
@@ -543,32 +554,32 @@ class DeviceAta extends EventEmitter {
|
|
|
543
554
|
})
|
|
544
555
|
.onSet(async (value) => {
|
|
545
556
|
try {
|
|
546
|
-
let
|
|
557
|
+
let flag = null;
|
|
547
558
|
switch (value) {
|
|
548
559
|
case 0: //OFF - POWER OFF
|
|
549
560
|
value = deviceData.Device.OperationMode;
|
|
550
561
|
deviceData.Device.Power = false;
|
|
551
|
-
|
|
562
|
+
flag = AirConditioner.EffectiveFlags.Power;
|
|
552
563
|
break;
|
|
553
564
|
case 1: //HEAT - HEAT
|
|
554
565
|
deviceData.Device.Power = true;
|
|
555
566
|
value = heatDryFanMode;
|
|
556
|
-
|
|
567
|
+
flag = AirConditioner.EffectiveFlags.PowerOperationModeSetTemperature;
|
|
557
568
|
break;
|
|
558
569
|
case 2: //COOL - COOL
|
|
559
570
|
value = coolDryFanMode;
|
|
560
571
|
deviceData.Device.Power = true;
|
|
561
|
-
|
|
572
|
+
flag = AirConditioner.EffectiveFlags.PowerOperationModeSetTemperature
|
|
562
573
|
break;
|
|
563
574
|
case 3: //AUTO - AUTO
|
|
564
575
|
value = autoDryFanMode;
|
|
565
576
|
deviceData.Device.Power = true;
|
|
566
|
-
|
|
577
|
+
flag = AirConditioner.EffectiveFlags.PowerOperationModeSetTemperature;
|
|
567
578
|
break;
|
|
568
579
|
};
|
|
569
580
|
|
|
570
581
|
deviceData.Device.OperationMode = value;
|
|
571
|
-
await this.melCloudAta.send(this.accountType, this.displayType, deviceData,
|
|
582
|
+
await this.melCloudAta.send(this.accountType, this.displayType, deviceData, flag);
|
|
572
583
|
const operationModeText = AirConditioner.OperationModeMapEnumToString[value];
|
|
573
584
|
if (this.logInfo) this.emit('info', `Set operation mode: ${operationModeText}`);
|
|
574
585
|
} catch (error) {
|
|
@@ -842,7 +853,8 @@ class DeviceAta extends EventEmitter {
|
|
|
842
853
|
//presets services
|
|
843
854
|
if (this.presets.length > 0) {
|
|
844
855
|
if (this.logDebug) this.emit('debug', `Prepare presets services`);
|
|
845
|
-
this.
|
|
856
|
+
this.presetControlServices = [];
|
|
857
|
+
this.presetControlSensorServices = [];
|
|
846
858
|
this.presets.forEach((preset, i) => {
|
|
847
859
|
const presetData = presetsOnServer.find(p => p.ID === preset.id);
|
|
848
860
|
|
|
@@ -855,51 +867,68 @@ class DeviceAta extends EventEmitter {
|
|
|
855
867
|
const serviceName1 = namePrefix ? `${accessoryName} ${name}` : name;
|
|
856
868
|
const serviceType = preset.serviceType;
|
|
857
869
|
const characteristicType = preset.characteristicType;
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
870
|
+
|
|
871
|
+
if (preset.displayType > 3) {
|
|
872
|
+
if (this.logDebug) this.emit('debug', `Prepare preset control ${name} service`);
|
|
873
|
+
const presetControlService = new Service.Switch(serviceName1, `presetControlService${deviceId} ${i}`);
|
|
874
|
+
presetControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
875
|
+
presetControlService.setCharacteristic(Characteristic.ConfiguredName, serviceName1);
|
|
876
|
+
presetControlService.getCharacteristic(Characteristic.On)
|
|
877
|
+
.onGet(async () => {
|
|
878
|
+
const state = preset.state;
|
|
879
|
+
return state;
|
|
880
|
+
})
|
|
881
|
+
.onSet(async (state) => {
|
|
882
|
+
try {
|
|
883
|
+
switch (state) {
|
|
884
|
+
case true:
|
|
885
|
+
preset.previousSettings = deviceData.Device;
|
|
886
|
+
deviceData.Device.Power = presetData.Power;
|
|
887
|
+
deviceData.Device.OperationMode = presetData.OperationMode;
|
|
888
|
+
deviceData.Device.SetTemperature = presetData.SetTemperature;
|
|
889
|
+
deviceData.Device.VaneHorizontalDirection = presetData.VaneHorizontalDirection;
|
|
890
|
+
deviceData.Device.VaneVerticalDirection = presetData.VaneVerticalDirection;
|
|
891
|
+
deviceData.Device.SetFanSpeed = presetData.SetFanSpeed;
|
|
892
|
+
break;
|
|
893
|
+
case false:
|
|
894
|
+
deviceData.Device.Power = preset.previousSettings.Power;
|
|
895
|
+
deviceData.Device.OperationMode = preset.previousSettings.OperationMode;
|
|
896
|
+
deviceData.Device.SetTemperature = preset.previousSettings.SetTemperature;
|
|
897
|
+
deviceData.Device.VaneHorizontalDirection = preset.previousSettings.VaneHorizontalDirection;
|
|
898
|
+
deviceData.Device.VaneVerticalDirection = preset.previousSettings.VaneVerticalDirection;
|
|
899
|
+
deviceData.Device.SetFanSpeed = preset.previousSettings.SetFanSpeed;
|
|
900
|
+
break;
|
|
901
|
+
};
|
|
902
|
+
|
|
903
|
+
await this.melCloudAta.send(this.accountType, this.displayType, deviceData, AirConditioner.EffectiveFlags.Presets);
|
|
904
|
+
if (this.logInfo) this.emit('info', `Preset ${name}: ${state ? 'Set:' : 'Unset:'} ${name}`);
|
|
905
|
+
} catch (error) {
|
|
906
|
+
if (this.logWarn) this.emit('warn', `Set preset error: ${error}`);
|
|
907
|
+
};
|
|
908
|
+
});
|
|
909
|
+
this.presetControlServices.push(presetControlService);
|
|
910
|
+
accessory.addService(presetControlService);
|
|
911
|
+
}
|
|
912
|
+
|
|
913
|
+
//sensor
|
|
914
|
+
if (this.logDebug) this.emit('debug', `Prepare preset control sensor s${name} ervice`);
|
|
915
|
+
const presetControlSensorService = new serviceType(serviceName1, `presetControlSensorService${deviceId} ${i}`);
|
|
916
|
+
presetControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
917
|
+
presetControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${serviceName1} Control`);
|
|
918
|
+
presetControlSensorService.getCharacteristic(characteristicType)
|
|
862
919
|
.onGet(async () => {
|
|
863
|
-
const state =
|
|
920
|
+
const state = this.accessory.scheduleEnabled;
|
|
864
921
|
return state;
|
|
865
922
|
})
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
switch (state) {
|
|
869
|
-
case true:
|
|
870
|
-
preset.previousSettings = deviceData.Device;
|
|
871
|
-
deviceData.Device.Power = presetData.Power;
|
|
872
|
-
deviceData.Device.OperationMode = presetData.OperationMode;
|
|
873
|
-
deviceData.Device.SetTemperature = presetData.SetTemperature;
|
|
874
|
-
deviceData.Device.VaneHorizontalDirection = presetData.VaneHorizontalDirection;
|
|
875
|
-
deviceData.Device.VaneVerticalDirection = presetData.VaneVerticalDirection;
|
|
876
|
-
deviceData.Device.SetFanSpeed = presetData.SetFanSpeed;
|
|
877
|
-
break;
|
|
878
|
-
case false:
|
|
879
|
-
deviceData.Device.Power = preset.previousSettings.Power;
|
|
880
|
-
deviceData.Device.OperationMode = preset.previousSettings.OperationMode;
|
|
881
|
-
deviceData.Device.SetTemperature = preset.previousSettings.SetTemperature;
|
|
882
|
-
deviceData.Device.VaneHorizontalDirection = preset.previousSettings.VaneHorizontalDirection;
|
|
883
|
-
deviceData.Device.VaneVerticalDirection = preset.previousSettings.VaneVerticalDirection;
|
|
884
|
-
deviceData.Device.SetFanSpeed = preset.previousSettings.SetFanSpeed;
|
|
885
|
-
break;
|
|
886
|
-
};
|
|
887
|
-
|
|
888
|
-
await this.melCloudAta.send(this.accountType, this.displayType, deviceData, AirConditioner.EffectiveFlags.Presets);
|
|
889
|
-
if (this.logInfo) this.emit('info', `${state ? 'Set:' : 'Unset:'} ${name}`);
|
|
890
|
-
} catch (error) {
|
|
891
|
-
if (this.logWarn) this.emit('warn', `Set preset error: ${error}`);
|
|
892
|
-
};
|
|
893
|
-
});
|
|
894
|
-
this.presetsServices.push(presetService);
|
|
895
|
-
accessory.addService(presetService);
|
|
923
|
+
this.presetControlSensorServices.push(presetControlSensorService);
|
|
924
|
+
accessory.addService(presetControlSensorService);
|
|
896
925
|
});
|
|
897
926
|
};
|
|
898
927
|
|
|
899
928
|
//schedules services
|
|
900
929
|
if (this.schedules.length > 0 && this.accessory.scheduleEnabled !== null) {
|
|
901
930
|
if (this.logDebug) this.emit('debug', `Prepare schedules services`);
|
|
902
|
-
this.
|
|
931
|
+
this.scheduleSensorServices = [];
|
|
903
932
|
this.schedules.forEach((schedule, i) => {
|
|
904
933
|
//get preset name
|
|
905
934
|
const name = schedule.name;
|
|
@@ -907,54 +936,117 @@ class DeviceAta extends EventEmitter {
|
|
|
907
936
|
//get preset name prefix
|
|
908
937
|
const namePrefix = schedule.namePrefix;
|
|
909
938
|
|
|
939
|
+
//control sensor
|
|
940
|
+
const serviceName1 = namePrefix ? `${accessoryName} ${name}` : name;
|
|
941
|
+
const serviceName2 = namePrefix ? `${accessoryName} Schedules` : 'Schedules';
|
|
942
|
+
const serviceType = schedule.serviceType;
|
|
943
|
+
const characteristicType = schedule.characteristicType;
|
|
944
|
+
|
|
910
945
|
//control
|
|
911
946
|
if (i === 0) {
|
|
912
|
-
if (
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
|
|
947
|
+
if (schedule.displayType > 3) {
|
|
948
|
+
if (this.logDebug) this.emit('debug', `Prepare schedule control ${name} service`);
|
|
949
|
+
this.scheduleControlService = new Service.Switch(serviceName2, `scheduleControlService${deviceId} ${i}`);
|
|
950
|
+
this.scheduleControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
951
|
+
this.scheduleControlService.setCharacteristic(Characteristic.ConfiguredName, serviceName2);
|
|
952
|
+
this.scheduleControlService.getCharacteristic(Characteristic.On)
|
|
953
|
+
.onGet(async () => {
|
|
954
|
+
const state = this.accessory.scheduleEnabled;
|
|
955
|
+
return state;
|
|
956
|
+
})
|
|
957
|
+
.onSet(async (state) => {
|
|
958
|
+
try {
|
|
959
|
+
deviceData.ScheduleEnabled = state;
|
|
960
|
+
await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'schedule');
|
|
961
|
+
if (this.logInfo) this.emit('info', `Schedule ${name}: ${state ? 'Enabled' : 'Disabled'}`);
|
|
962
|
+
} catch (error) {
|
|
963
|
+
if (this.logWarn) this.emit('warn', `Set schedule error: ${error}`);
|
|
964
|
+
};
|
|
965
|
+
});
|
|
966
|
+
accessory.addService(this.scheduleControlService);
|
|
967
|
+
}
|
|
968
|
+
|
|
969
|
+
//sensor
|
|
970
|
+
if (this.logDebug) this.emit('debug', `Prepare schedule control sensor ${name} service`);
|
|
971
|
+
this.scheduleControlSensorService = new serviceType(`${serviceName2} Control`, `scheduleControlSensorService${deviceId} ${i}`);
|
|
972
|
+
this.scheduleControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
973
|
+
this.scheduleControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${serviceName2} Control`);
|
|
974
|
+
this.scheduleControlSensorService.getCharacteristic(characteristicType)
|
|
917
975
|
.onGet(async () => {
|
|
918
976
|
const state = this.accessory.scheduleEnabled;
|
|
919
977
|
return state;
|
|
920
978
|
})
|
|
979
|
+
accessory.addService(this.scheduleControlSensorService);
|
|
980
|
+
}
|
|
981
|
+
|
|
982
|
+
//sensors
|
|
983
|
+
if (this.logDebug) this.emit('debug', `Prepare schedule sensor ${name} service`);
|
|
984
|
+
const scheduleSensorService = new serviceType(serviceName1, `scheduleSensorService${deviceId} ${i}`);
|
|
985
|
+
scheduleSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
986
|
+
scheduleSensorService.setCharacteristic(Characteristic.ConfiguredName, serviceName1);
|
|
987
|
+
scheduleSensorService.getCharacteristic(characteristicType)
|
|
988
|
+
.onGet(async () => {
|
|
989
|
+
const state = schedule.state;
|
|
990
|
+
return state;
|
|
991
|
+
});
|
|
992
|
+
this.scheduleSensorServices.push(scheduleSensorService);
|
|
993
|
+
accessory.addService(scheduleSensorService);
|
|
994
|
+
});
|
|
995
|
+
};
|
|
996
|
+
|
|
997
|
+
//scenes
|
|
998
|
+
if (this.scenes.length > 0) {
|
|
999
|
+
if (this.logDebug) this.emit('debug', `Prepare scenes services`);
|
|
1000
|
+
this.sceneControlServices = [];
|
|
1001
|
+
this.sceneControlSensorServices = [];
|
|
1002
|
+
this.scenes.forEach((scene, i) => {
|
|
1003
|
+
const sceneData = scenesOnServer.find(s => s.Id === scene.id);
|
|
1004
|
+
|
|
1005
|
+
//get preset name
|
|
1006
|
+
const name = scene.name;
|
|
1007
|
+
|
|
1008
|
+
//get preset name prefix
|
|
1009
|
+
const namePrefix = scene.namePrefix;
|
|
1010
|
+
|
|
1011
|
+
const serviceName1 = namePrefix ? `${accessoryName} ${name}` : name;
|
|
1012
|
+
const serviceType = scene.serviceType;
|
|
1013
|
+
const characteristicType = scene.characteristicType;
|
|
1014
|
+
|
|
1015
|
+
//control
|
|
1016
|
+
if (scene.displayType > 3) {
|
|
1017
|
+
if (this.logDebug) this.emit('debug', `Prepare scene control ${name} service`);
|
|
1018
|
+
const sceneControlService = new Service.Switch(serviceName1, `sceneControlService${deviceId} ${i}`);
|
|
1019
|
+
sceneControlService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
1020
|
+
sceneControlService.setCharacteristic(Characteristic.ConfiguredName, serviceName1);
|
|
1021
|
+
sceneControlService.getCharacteristic(Characteristic.On)
|
|
1022
|
+
.onGet(async () => {
|
|
1023
|
+
const state = scene.state;
|
|
1024
|
+
return state;
|
|
1025
|
+
})
|
|
921
1026
|
.onSet(async (state) => {
|
|
922
1027
|
try {
|
|
923
|
-
|
|
924
|
-
await this.melCloudAta.send(this.accountType, this.displayType, deviceData, '
|
|
925
|
-
if (this.logInfo) this.emit('info', `
|
|
1028
|
+
sceneData.Enabled = state;
|
|
1029
|
+
await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'scene', sceneData);
|
|
1030
|
+
if (this.logInfo) this.emit('info', `Scene ${name}: ${state ? 'Enabled' : 'Disabled'}`);
|
|
926
1031
|
} catch (error) {
|
|
927
|
-
if (this.logWarn) this.emit('warn', `Set
|
|
1032
|
+
if (this.logWarn) this.emit('warn', `Set scene error: ${error}`);
|
|
928
1033
|
};
|
|
929
1034
|
});
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
if (this.logDebug) this.emit('debug', `Prepare schedule control sensor service`);
|
|
933
|
-
this.schedulesControlSensorService = new Service.ContactSensor(`${serviceName} Schedule Control`, `schedulesControlSensorService${deviceId}`);
|
|
934
|
-
this.schedulesControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
935
|
-
this.schedulesControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} Schedule Control`);
|
|
936
|
-
this.schedulesControlSensorService.getCharacteristic(Characteristic.ContactSensorState)
|
|
937
|
-
.onGet(async () => {
|
|
938
|
-
const state = this.accessory.scheduleEnabled;
|
|
939
|
-
return state;
|
|
940
|
-
})
|
|
941
|
-
accessory.addService(this.schedulesControlSensorService);
|
|
1035
|
+
this.sceneControlServices.push(sceneControlService);
|
|
1036
|
+
accessory.addService(sceneControlService);
|
|
942
1037
|
}
|
|
943
1038
|
|
|
944
|
-
|
|
945
|
-
const
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
scheduleService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
950
|
-
scheduleService.setCharacteristic(Characteristic.ConfiguredName, serviceName1);
|
|
951
|
-
scheduleService.getCharacteristic(characteristicType)
|
|
1039
|
+
if (this.logDebug) this.emit('debug', `Prepare scene control sensor ${name} service`);
|
|
1040
|
+
const sceneControlSensorService = new serviceType(`${serviceName1} Control`, `sceneControlSensorService${deviceId} ${i}`);
|
|
1041
|
+
sceneControlSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
1042
|
+
sceneControlSensorService.setCharacteristic(Characteristic.ConfiguredName, `${serviceName1} Control`);
|
|
1043
|
+
sceneControlSensorService.getCharacteristic(characteristicType)
|
|
952
1044
|
.onGet(async () => {
|
|
953
|
-
const state =
|
|
1045
|
+
const state = scene.state;
|
|
954
1046
|
return state;
|
|
955
|
-
})
|
|
956
|
-
this.
|
|
957
|
-
accessory.addService(
|
|
1047
|
+
})
|
|
1048
|
+
this.sceneControlSensorServices.push(sceneControlSensorService);
|
|
1049
|
+
accessory.addService(sceneControlSensorService);
|
|
958
1050
|
});
|
|
959
1051
|
};
|
|
960
1052
|
|
|
@@ -986,47 +1078,47 @@ class DeviceAta extends EventEmitter {
|
|
|
986
1078
|
.onSet(async (state) => {
|
|
987
1079
|
try {
|
|
988
1080
|
const fanKey = this.accountType === 'melcloud' ? 'FanSpeed' : 'SetFanSpeed';
|
|
989
|
-
let
|
|
1081
|
+
let flag = null;
|
|
990
1082
|
switch (mode) {
|
|
991
1083
|
case 0: //POWER ON,OFF
|
|
992
1084
|
deviceData.Device.Power = state;
|
|
993
|
-
|
|
1085
|
+
flag = AirConditioner.EffectiveFlags.Power;
|
|
994
1086
|
break;
|
|
995
1087
|
case 1: //OPERATING MODE HEAT
|
|
996
1088
|
button.previousValue = state ? deviceData.Device.OperationMode : button.previousValue ?? deviceData.Device.OperationMode;
|
|
997
1089
|
deviceData.Device.Power = true;
|
|
998
1090
|
deviceData.Device.OperationMode = state ? 1 : button.previousValue === 9 ? 1 : button.previousValue;
|
|
999
|
-
|
|
1091
|
+
flag = AirConditioner.EffectiveFlags.PowerOperationModeSetTemperature;
|
|
1000
1092
|
break;
|
|
1001
1093
|
case 2: //OPERATING MODE DRY
|
|
1002
1094
|
button.previousValue = state ? deviceData.Device.OperationMode : button.previousValue ?? deviceData.Device.OperationMode;
|
|
1003
1095
|
deviceData.Device.Power = true;
|
|
1004
1096
|
deviceData.Device.OperationMode = state ? 2 : button.previousValue === 10 ? 2 : button.previousValue;
|
|
1005
|
-
|
|
1097
|
+
flag = AirConditioner.EffectiveFlags.PowerOperationModeSetTemperature;
|
|
1006
1098
|
break
|
|
1007
1099
|
case 3: //OPERATING MODE COOL
|
|
1008
1100
|
button.previousValue = state ? deviceData.Device.OperationMode : button.previousValue ?? deviceData.Device.OperationMode;
|
|
1009
1101
|
deviceData.Device.Power = true;
|
|
1010
1102
|
deviceData.Device.OperationMode = state ? 3 : button.previousValue === 11 ? 3 : button.previousValue;
|
|
1011
|
-
|
|
1103
|
+
flag = AirConditioner.EffectiveFlags.PowerOperationModeSetTemperature;
|
|
1012
1104
|
break;
|
|
1013
1105
|
case 4: //OPERATING MODE FAN
|
|
1014
1106
|
button.previousValue = state ? deviceData.Device.OperationMode : button.previousValue ?? deviceData.Device.OperationMode;
|
|
1015
1107
|
deviceData.Device.Power = true;
|
|
1016
1108
|
deviceData.Device.OperationMode = state ? 7 : button.previousValue;
|
|
1017
|
-
|
|
1109
|
+
flag = AirConditioner.EffectiveFlags.PowerOperationModeSetTemperature;
|
|
1018
1110
|
break;
|
|
1019
1111
|
case 5: //OPERATING MODE AUTO
|
|
1020
1112
|
button.previousValue = state ? deviceData.Device.OperationMode : button.previousValue ?? deviceData.Device.OperationMode;
|
|
1021
1113
|
deviceData.Device.Power = true;
|
|
1022
1114
|
deviceData.Device.OperationMode = state ? 8 : button.previousValue;
|
|
1023
|
-
|
|
1115
|
+
flag = AirConditioner.EffectiveFlags.PowerOperationModeSetTemperature;
|
|
1024
1116
|
break;
|
|
1025
1117
|
case 6: //OPERATING MODE PURIFY
|
|
1026
1118
|
button.previousValue = state ? deviceData.Device.OperationMode : button.previousValue ?? deviceData.Device.OperationMode;
|
|
1027
1119
|
deviceData.Device.Power = true;
|
|
1028
1120
|
deviceData.Device.OperationMode = state ? 12 : button.previousValue;
|
|
1029
|
-
|
|
1121
|
+
flag = AirConditioner.EffectiveFlags.PowerOperationModeSetTemperature;
|
|
1030
1122
|
break;
|
|
1031
1123
|
case 7: //OPERATING MODE DRY CONTROL HIDE
|
|
1032
1124
|
deviceData.HideDryModeControl = state;
|
|
@@ -1035,91 +1127,91 @@ class DeviceAta extends EventEmitter {
|
|
|
1035
1127
|
button.previousValue = state ? deviceData.Device.VaneHorizontalDirection : button.previousValue ?? deviceData.Device.VaneHorizontalDirection;
|
|
1036
1128
|
deviceData.Device.Power = true;
|
|
1037
1129
|
deviceData.Device.VaneHorizontalDirection = state ? 0 : button.previousValue;
|
|
1038
|
-
|
|
1130
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneHorizontal;
|
|
1039
1131
|
break;
|
|
1040
1132
|
case 11: //VANE H SWING MODE 1
|
|
1041
1133
|
button.previousValue = state ? deviceData.Device.VaneHorizontalDirection : button.previousValue ?? deviceData.Device.VaneHorizontalDirection;
|
|
1042
1134
|
deviceData.Device.Power = true;
|
|
1043
1135
|
deviceData.Device.VaneHorizontalDirection = state ? 1 : button.previousValue;
|
|
1044
|
-
|
|
1136
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneHorizontal;
|
|
1045
1137
|
break;
|
|
1046
1138
|
case 12: //VANE H SWING MODE 2
|
|
1047
1139
|
button.previousValue = state ? deviceData.Device.VaneHorizontalDirection : button.previousValue ?? deviceData.Device.VaneHorizontalDirection;
|
|
1048
1140
|
deviceData.Device.Power = true;
|
|
1049
1141
|
deviceData.Device.VaneHorizontalDirection = state ? 2 : button.previousValue;
|
|
1050
|
-
|
|
1142
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneHorizontal;
|
|
1051
1143
|
break;
|
|
1052
1144
|
case 13: //VANE H SWING MODE 3
|
|
1053
1145
|
button.previousValue = state ? deviceData.Device.VaneHorizontalDirection : button.previousValue ?? deviceData.Device.VaneHorizontalDirection;
|
|
1054
1146
|
deviceData.Device.Power = true;
|
|
1055
1147
|
deviceData.Device.VaneHorizontalDirection = state ? 3 : button.previousValue;
|
|
1056
|
-
|
|
1148
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneHorizontal;
|
|
1057
1149
|
break;
|
|
1058
1150
|
case 14: //VANE H SWING MODE 4
|
|
1059
1151
|
button.previousValue = state ? deviceData.Device.VaneHorizontalDirection : button.previousValue ?? deviceData.Device.VaneHorizontalDirection;
|
|
1060
1152
|
deviceData.Device.Power = true;
|
|
1061
1153
|
deviceData.Device.VaneHorizontalDirection = state ? 4 : button.previousValue;
|
|
1062
|
-
|
|
1154
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneHorizontal;
|
|
1063
1155
|
break;
|
|
1064
1156
|
case 15: //VANE H SWING MODE 5
|
|
1065
1157
|
button.previousValue = state ? deviceData.Device.VaneHorizontalDirection : button.previousValue ?? deviceData.Device.VaneHorizontalDirection;
|
|
1066
1158
|
deviceData.Device.Power = true;
|
|
1067
1159
|
deviceData.Device.VaneHorizontalDirection = state ? 5 : button.previousValue;
|
|
1068
|
-
|
|
1160
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneHorizontal;
|
|
1069
1161
|
break;
|
|
1070
1162
|
case 16: //VANE H SWING MODE SPLIT
|
|
1071
1163
|
button.previousValue = state ? deviceData.Device.VaneHorizontalDirection : button.previousValue ?? deviceData.Device.VaneHorizontalDirection;
|
|
1072
1164
|
deviceData.Device.Power = true;
|
|
1073
1165
|
deviceData.Device.VaneHorizontalDirection = state ? 8 : button.previousValue;
|
|
1074
|
-
|
|
1166
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneHorizontal;
|
|
1075
1167
|
break;
|
|
1076
1168
|
case 17: //VANE H SWING MODE SWING
|
|
1077
1169
|
button.previousValue = state ? deviceData.Device.VaneHorizontalDirection : button.previousValue ?? deviceData.Device.VaneHorizontalDirection;
|
|
1078
1170
|
deviceData.Device.Power = true;
|
|
1079
1171
|
deviceData.Device.VaneHorizontalDirection = state ? 12 : button.previousValue;
|
|
1080
|
-
|
|
1172
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneHorizontal;
|
|
1081
1173
|
break;
|
|
1082
1174
|
case 20: //VANE V SWING MODE AUTO
|
|
1083
1175
|
button.previousValue = state ? deviceData.Device.VaneVerticalDirection : button.previousValue ?? deviceData.Device.VaneVerticalDirection;
|
|
1084
1176
|
deviceData.Device.Power = true;
|
|
1085
1177
|
deviceData.Device.VaneVerticalDirection = state ? 0 : button.previousValue;
|
|
1086
|
-
|
|
1178
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneVertical;
|
|
1087
1179
|
break;
|
|
1088
1180
|
case 21: //VANE V SWING MODE 1
|
|
1089
1181
|
button.previousValue = state ? deviceData.Device.VaneVerticalDirection : button.previousValue ?? deviceData.Device.VaneVerticalDirection;
|
|
1090
1182
|
deviceData.Device.Power = true;
|
|
1091
1183
|
deviceData.Device.VaneVerticalDirection = state ? 1 : button.previousValue;
|
|
1092
|
-
|
|
1184
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneVertical;
|
|
1093
1185
|
break;
|
|
1094
1186
|
case 22: //VANE V SWING MODE 2
|
|
1095
1187
|
button.previousValue = state ? deviceData.Device.VaneVerticalDirection : button.previousValue ?? deviceData.Device.VaneVerticalDirection;
|
|
1096
1188
|
deviceData.Device.Power = true;
|
|
1097
1189
|
deviceData.Device.VaneVerticalDirection = state ? 2 : button.previousValue;
|
|
1098
|
-
|
|
1190
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneVertical;
|
|
1099
1191
|
break;
|
|
1100
1192
|
case 23: //VANE V SWING MODE 3
|
|
1101
1193
|
button.previousValue = state ? deviceData.Device.VaneVerticalDirection : button.previousValue ?? deviceData.Device.VaneVerticalDirection;
|
|
1102
1194
|
deviceData.Device.Power = true;
|
|
1103
1195
|
deviceData.Device.VaneVerticalDirection = state ? 3 : button.previousValue;
|
|
1104
|
-
|
|
1196
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneVertical;
|
|
1105
1197
|
break;
|
|
1106
1198
|
case 24: //VANE V SWING MODE 4
|
|
1107
1199
|
button.previousValue = state ? deviceData.Device.VaneVerticalDirection : button.previousValue ?? deviceData.Device.VaneVerticalDirection;
|
|
1108
1200
|
deviceData.Device.Power = true;
|
|
1109
1201
|
deviceData.Device.VaneVerticalDirection = state ? 4 : button.previousValue;
|
|
1110
|
-
|
|
1202
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneVertical;
|
|
1111
1203
|
break;
|
|
1112
1204
|
case 25: //VANE V SWING MODE 5
|
|
1113
1205
|
button.previousValue = state ? deviceData.Device.VaneVerticalDirection : button.previousValue ?? deviceData.Device.VaneVerticalDirection;
|
|
1114
1206
|
deviceData.Device.Power = true;
|
|
1115
1207
|
deviceData.Device.VaneVerticalDirection = state ? 5 : button.previousValue;
|
|
1116
|
-
|
|
1208
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneVertical;
|
|
1117
1209
|
break;
|
|
1118
1210
|
case 26: //VANE V SWING MODE SWING
|
|
1119
1211
|
button.previousValue = state ? deviceData.Device.VaneVerticalDirection : button.previousValue ?? deviceData.Device.VaneVerticalDirection;
|
|
1120
1212
|
deviceData.Device.Power = true;
|
|
1121
1213
|
deviceData.Device.VaneVerticalDirection = state ? 7 : button.previousValue;
|
|
1122
|
-
|
|
1214
|
+
flag = AirConditioner.EffectiveFlags.PowerVaneVertical;
|
|
1123
1215
|
break;
|
|
1124
1216
|
case 27: //VANE H/V CONTROLS HIDE
|
|
1125
1217
|
deviceData.HideVaneControls = state;
|
|
@@ -1128,68 +1220,68 @@ class DeviceAta extends EventEmitter {
|
|
|
1128
1220
|
button.previousValue = state ? deviceData.Device[fanKey] : button.previousValue ?? deviceData.Device[fanKey];
|
|
1129
1221
|
deviceData.Device.Power = true;
|
|
1130
1222
|
deviceData.Device[fanKey] = state ? 0 : button.previousValue;
|
|
1131
|
-
|
|
1223
|
+
flag = AirConditioner.EffectiveFlags.PowerSetFanSpeed;
|
|
1132
1224
|
break;
|
|
1133
1225
|
case 31: //FAN SPEED MODE 1
|
|
1134
1226
|
button.previousValue = state ? deviceData.Device[fanKey] : button.previousValue ?? deviceData.Device[fanKey];
|
|
1135
1227
|
deviceData.Device.Power = true;
|
|
1136
1228
|
deviceData.Device[fanKey] = state ? 1 : button.previousValue;
|
|
1137
|
-
|
|
1229
|
+
flag = AirConditioner.EffectiveFlags.PowerSetFanSpeed;
|
|
1138
1230
|
break;
|
|
1139
1231
|
case 32: //FAN SPEED MODE 2
|
|
1140
1232
|
button.previousValue = state ? deviceData.Device[fanKey] : button.previousValue ?? deviceData.Device[fanKey];
|
|
1141
1233
|
deviceData.Device.Power = true;
|
|
1142
1234
|
deviceData.Device[fanKey] = state ? 2 : button.previousValue;
|
|
1143
|
-
|
|
1235
|
+
flag = AirConditioner.EffectiveFlags.PowerSetFanSpeed;
|
|
1144
1236
|
break;
|
|
1145
1237
|
case 33: //FAN SPEED MODE 3
|
|
1146
1238
|
button.previousValue = state ? deviceData.Device[fanKey] : button.previousValue ?? deviceData.Device[fanKey];
|
|
1147
1239
|
deviceData.Device.Power = true;
|
|
1148
1240
|
deviceData.Device[fanKey] = state ? 3 : button.previousValue;
|
|
1149
|
-
|
|
1241
|
+
flag = AirConditioner.EffectiveFlags.PowerSetFanSpeed;
|
|
1150
1242
|
break;
|
|
1151
1243
|
case 34: //FAN MODE 4
|
|
1152
1244
|
button.previousValue = state ? deviceData.Device[fanKey] : button.previousValue ?? deviceData.Device[fanKey];
|
|
1153
1245
|
deviceData.Device.Power = true;
|
|
1154
1246
|
deviceData.Device[fanKey] = state ? 4 : button.previousValue;
|
|
1155
|
-
|
|
1247
|
+
flag = AirConditioner.EffectiveFlags.PowerSetFanSpeed;
|
|
1156
1248
|
break;
|
|
1157
1249
|
case 35: //FAN SPEED MODE 5
|
|
1158
1250
|
button.previousValue = state ? deviceData.Device[fanKey] : button.previousValue ?? deviceData.Device[fanKey];
|
|
1159
1251
|
deviceData.Device.Power = true;
|
|
1160
1252
|
deviceData.Device[fanKey] = state ? 5 : button.previousValue;
|
|
1161
|
-
|
|
1253
|
+
flag = AirConditioner.EffectiveFlags.PowerSetFanSpeed;
|
|
1162
1254
|
break;
|
|
1163
1255
|
case 36: //FAN SPEED MODE 6
|
|
1164
1256
|
button.previousValue = state ? deviceData.Device[fanKey] : button.previousValue ?? deviceData.Device[fanKey];
|
|
1165
1257
|
deviceData.Device.Power = true;
|
|
1166
1258
|
deviceData.Device[fanKey] = state ? 6 : button.previousValue;
|
|
1167
|
-
|
|
1259
|
+
flag = AirConditioner.EffectiveFlags.PowerSetFanSpeed;
|
|
1168
1260
|
break;
|
|
1169
1261
|
case 37: //PHYSICAL LOCK CONTROLS
|
|
1170
1262
|
deviceData.Device.ProhibitSetTemperature = state;
|
|
1171
1263
|
deviceData.Device.ProhibitOperationMode = state;
|
|
1172
1264
|
deviceData.Device.ProhibitPower = state;
|
|
1173
|
-
|
|
1265
|
+
flag = AirConditioner.EffectiveFlags.Prohibit;
|
|
1174
1266
|
break;
|
|
1175
1267
|
case 38: //PHYSICAL LOCK CONTROLS POWER
|
|
1176
1268
|
deviceData.Device.ProhibitPower = state;
|
|
1177
|
-
|
|
1269
|
+
flag = AirConditioner.EffectiveFlags.Prohibit;
|
|
1178
1270
|
break;
|
|
1179
1271
|
case 39: //PHYSICAL LOCK CONTROLS MODE
|
|
1180
1272
|
deviceData.Device.ProhibitOperationMode = state;
|
|
1181
|
-
|
|
1273
|
+
flag = AirConditioner.EffectiveFlags.Prohibit;
|
|
1182
1274
|
break;
|
|
1183
1275
|
case 40: //PHYSICAL LOCK CONTROLS TEMP
|
|
1184
1276
|
deviceData.Device.ProhibitSetTemperature = state;
|
|
1185
|
-
|
|
1277
|
+
flag = AirConditioner.EffectiveFlags.Prohibit;
|
|
1186
1278
|
break;
|
|
1187
1279
|
default:
|
|
1188
1280
|
if (this.logWarn) this.emit('warn', `Unknown button mode: ${mode}`);
|
|
1189
1281
|
break;
|
|
1190
1282
|
};
|
|
1191
1283
|
|
|
1192
|
-
await this.melCloudAta.send(this.accountType, this.displayType, deviceData,
|
|
1284
|
+
await this.melCloudAta.send(this.accountType, this.displayType, deviceData, flag);
|
|
1193
1285
|
if (this.logInfo) this.emit('info', `${state ? `Set: ${name}` : `Unset: ${name}, Set: ${button.previousValue}`}`);
|
|
1194
1286
|
} catch (error) {
|
|
1195
1287
|
if (this.logWarn) this.emit('warn', `Set button error: ${error}`);
|
|
@@ -1211,7 +1303,7 @@ class DeviceAta extends EventEmitter {
|
|
|
1211
1303
|
try {
|
|
1212
1304
|
//melcloud device
|
|
1213
1305
|
this.melCloudAta = new MelCloudAta(this.account, this.device, this.devicesFile, this.defaultTempsFile)
|
|
1214
|
-
.on('deviceInfo', (
|
|
1306
|
+
.on('deviceInfo', (modelIndoor, modelOutdoor, serialNumber, firmwareAppVersion) => {
|
|
1215
1307
|
if (this.logDeviceInfo && this.displayDeviceInfo) {
|
|
1216
1308
|
this.emit('devInfo', `---- ${this.deviceTypeText}: ${this.deviceName} ----`);
|
|
1217
1309
|
this.emit('devInfo', `Account: ${this.accountName}`);
|
|
@@ -1219,13 +1311,13 @@ class DeviceAta extends EventEmitter {
|
|
|
1219
1311
|
if (modelOutdoor) this.emit('devInfo', `Outdoor: ${modelOutdoor}`);
|
|
1220
1312
|
if (serialNumber) this.emit('devInfo', `Serial: ${serialNumber}`);
|
|
1221
1313
|
if (firmwareAppVersion) this.emit('devInfo', `Firmware: ${firmwareAppVersion}`);
|
|
1222
|
-
this.emit('devInfo', `Manufacturer:
|
|
1314
|
+
this.emit('devInfo', `Manufacturer: Mitsubishi`);
|
|
1223
1315
|
this.emit('devInfo', '----------------------------------');
|
|
1224
1316
|
this.displayDeviceInfo = false;
|
|
1225
1317
|
}
|
|
1226
1318
|
|
|
1227
1319
|
//accessory info
|
|
1228
|
-
this.manufacturer =
|
|
1320
|
+
this.manufacturer = 'Mitsubishi';
|
|
1229
1321
|
this.model = modelIndoor ? modelIndoor : modelOutdoor ? modelOutdoor : `${this.deviceTypeText}`;
|
|
1230
1322
|
this.serialNumber = serialNumber.toString();
|
|
1231
1323
|
this.firmwareRevision = firmwareAppVersion.toString();
|
|
@@ -1251,9 +1343,10 @@ class DeviceAta extends EventEmitter {
|
|
|
1251
1343
|
const supportStandbyKey = accountTypeMelcloud ? 'ModelSupportsStandbyMode' : 'HasStandby';
|
|
1252
1344
|
|
|
1253
1345
|
//presets schedules
|
|
1346
|
+
const presetsOnServer = deviceData.Presets ?? [];
|
|
1254
1347
|
const scheduleEnabled = deviceData.ScheduleEnabled;
|
|
1255
1348
|
const schedulesOnServer = deviceData.Schedule ?? [];
|
|
1256
|
-
const
|
|
1349
|
+
const scenesOnServer = deviceData.Scenes ?? [];
|
|
1257
1350
|
const holidayModeEnabled = deviceData.HolidayMode?.Enabled;
|
|
1258
1351
|
const holidayModeActive = deviceData.HolidayMode?.Active ?? false;
|
|
1259
1352
|
|
|
@@ -1315,6 +1408,7 @@ class DeviceAta extends EventEmitter {
|
|
|
1315
1408
|
const obj = {
|
|
1316
1409
|
presets: presetsOnServer,
|
|
1317
1410
|
schedules: schedulesOnServer,
|
|
1411
|
+
scenes: scenesOnServer,
|
|
1318
1412
|
supportsAutomaticFanSpeed: supportsAutomaticFanSpeed,
|
|
1319
1413
|
supportsAirDirectionFunction: supportsAirDirectionFunction,
|
|
1320
1414
|
supportsSwingFunction: supportsSwingFunction,
|
|
@@ -1331,7 +1425,7 @@ class DeviceAta extends EventEmitter {
|
|
|
1331
1425
|
maxTempHeat: maxTempHeat,
|
|
1332
1426
|
minTempCoolDryAuto: minTempCoolDryAuto,
|
|
1333
1427
|
maxTempCoolDryAuto: maxTempCoolDryAuto,
|
|
1334
|
-
power: power
|
|
1428
|
+
power: power,
|
|
1335
1429
|
inStandbyMode: inStandbyMode,
|
|
1336
1430
|
operationMode: operationMode,
|
|
1337
1431
|
currentOperationMode: 0,
|
|
@@ -1427,7 +1521,7 @@ class DeviceAta extends EventEmitter {
|
|
|
1427
1521
|
|
|
1428
1522
|
//update characteristics
|
|
1429
1523
|
this.melCloudService
|
|
1430
|
-
?.updateCharacteristic(Characteristic.Active, power
|
|
1524
|
+
?.updateCharacteristic(Characteristic.Active, power)
|
|
1431
1525
|
.updateCharacteristic(Characteristic.CurrentHeaterCoolerState, obj.currentOperationMode)
|
|
1432
1526
|
.updateCharacteristic(Characteristic.TargetHeaterCoolerState, obj.targetOperationMode)
|
|
1433
1527
|
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
@@ -1539,6 +1633,7 @@ class DeviceAta extends EventEmitter {
|
|
|
1539
1633
|
if (this.presets.length > 0) {
|
|
1540
1634
|
this.presets.forEach((preset, i) => {
|
|
1541
1635
|
const presetData = presetsOnServer.find(p => p.ID === preset.id);
|
|
1636
|
+
const characteristicType = preset.characteristicType;
|
|
1542
1637
|
|
|
1543
1638
|
preset.state = presetData ? (presetData.Power === power
|
|
1544
1639
|
&& presetData.SetTemperature === setTemperature
|
|
@@ -1547,26 +1642,50 @@ class DeviceAta extends EventEmitter {
|
|
|
1547
1642
|
&& presetData.VaneVerticalDirection === vaneVerticalDirection
|
|
1548
1643
|
&& presetData.FanSpeed === setFanSpeed) : false;
|
|
1549
1644
|
|
|
1550
|
-
|
|
1551
|
-
|
|
1645
|
+
//control
|
|
1646
|
+
if (preset.displayType > 3) {
|
|
1647
|
+
this.presetControlServices?.[i]?.updateCharacteristic(Characteristic.On, preset.state);
|
|
1648
|
+
}
|
|
1649
|
+
|
|
1650
|
+
//sencor
|
|
1651
|
+
this.presetControlSensorServices?.[i]?.updateCharacteristic(characteristicType, preset.state);
|
|
1552
1652
|
});
|
|
1553
1653
|
};
|
|
1554
1654
|
|
|
1555
1655
|
//schedules
|
|
1556
1656
|
if (this.schedules.length > 0 && scheduleEnabled !== null) {
|
|
1557
1657
|
this.schedules.forEach((schedule, i) => {
|
|
1658
|
+
const scheduleData = schedulesOnServer.find(s => s.Id === schedule.id);
|
|
1659
|
+
const characteristicType = schedule.characteristicType;
|
|
1660
|
+
schedule.state = scheduleEnabled ? scheduleData.Enabled ?? false : false;
|
|
1661
|
+
|
|
1558
1662
|
//control
|
|
1559
1663
|
if (i === 0) {
|
|
1560
|
-
|
|
1561
|
-
|
|
1664
|
+
if (schedule.displayType > 3) {
|
|
1665
|
+
this.scheduleControlService?.updateCharacteristic(Characteristic.On, scheduleEnabled);
|
|
1666
|
+
}
|
|
1667
|
+
this.scheduleControlSensorService?.updateCharacteristic(characteristicType, scheduleEnabled);
|
|
1562
1668
|
}
|
|
1563
1669
|
|
|
1564
|
-
//
|
|
1565
|
-
|
|
1566
|
-
|
|
1670
|
+
//sensor
|
|
1671
|
+
this.scheduleSensorServices?.[i]?.updateCharacteristic(characteristicType, schedule.state);
|
|
1672
|
+
});
|
|
1673
|
+
};
|
|
1567
1674
|
|
|
1568
|
-
|
|
1569
|
-
|
|
1675
|
+
//schedules
|
|
1676
|
+
if (this.scenes.length > 0) {
|
|
1677
|
+
this.scenes.forEach((scene, i) => {
|
|
1678
|
+
const sceneData = scenesOnServer.find(s => s.Id === scene.id);
|
|
1679
|
+
scene.state = sceneData.Enabled;
|
|
1680
|
+
|
|
1681
|
+
//control
|
|
1682
|
+
if (scene.displayType > 3) {
|
|
1683
|
+
this.sceneControlServices?.[i]?.updateCharacteristic(Characteristic.On, scene.state);
|
|
1684
|
+
}
|
|
1685
|
+
|
|
1686
|
+
//sensor
|
|
1687
|
+
const characteristicType = scene.characteristicType;
|
|
1688
|
+
this.sceneControlSensorServices?.[i]?.updateCharacteristic(characteristicType, scene.state);
|
|
1570
1689
|
});
|
|
1571
1690
|
};
|
|
1572
1691
|
|
|
@@ -1693,7 +1812,7 @@ class DeviceAta extends EventEmitter {
|
|
|
1693
1812
|
|
|
1694
1813
|
//log current state
|
|
1695
1814
|
if (this.logInfo) {
|
|
1696
|
-
this.emit('info', `Power: ${power ? '
|
|
1815
|
+
this.emit('info', `Power: ${power ? 'On' : 'Off'}`);
|
|
1697
1816
|
this.emit('info', `Target operation mode: ${AirConditioner.OperationModeMapEnumToString[operationMode]}`);
|
|
1698
1817
|
this.emit('info', `Current operation mode: ${this.displayType === 1 ? AirConditioner.CurrentOperationModeHeatherCoolerMapEnumToString[obj.currentOperationMode] : AirConditioner.CurrentOperationModeThermostatMapEnumToString[obj.currentOperationMode]}`);
|
|
1699
1818
|
this.emit('info', `Target temperature: ${setTemperature}${obj.temperatureUnit}`);
|