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