homebridge-melcloud-control 3.5.0 → 3.5.2
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/index.js +5 -5
- package/package.json +2 -2
- package/src/deviceata.js +725 -724
- package/src/deviceatw.js +1670 -1669
- package/src/deviceerv.js +1002 -1001
- package/src/impulsegenerator.js +14 -13
package/src/deviceatw.js
CHANGED
|
@@ -100,906 +100,463 @@ class DeviceAtw extends EventEmitter {
|
|
|
100
100
|
this.accessory.temperatureUnit = TemperatureDisplayUnits[this.accessory.useFahrenheit];
|
|
101
101
|
};
|
|
102
102
|
|
|
103
|
-
async
|
|
103
|
+
async setOverExternalIntegration(integration, deviceData, key, value) {
|
|
104
104
|
try {
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
105
|
+
let set = false
|
|
106
|
+
switch (key) {
|
|
107
|
+
case 'Power':
|
|
108
|
+
deviceData.Device[key] = value;
|
|
109
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
110
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
111
|
+
break;
|
|
112
|
+
case 'OperationMode':
|
|
113
|
+
deviceData.Device[key] = value;
|
|
114
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationMode;
|
|
115
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
116
|
+
break;
|
|
117
|
+
case 'OperationModeZone1':
|
|
118
|
+
deviceData.Device[key] = value;
|
|
119
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
120
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
121
|
+
break;
|
|
122
|
+
case 'OperationModeZone2':
|
|
123
|
+
deviceData.Device[key] = value;
|
|
124
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
|
|
125
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
126
|
+
break;
|
|
127
|
+
case 'SetTemperatureZone1':
|
|
128
|
+
deviceData.Device[key] = value;
|
|
129
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
|
|
130
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
131
|
+
break;
|
|
132
|
+
case 'SetTemperatureZone2':
|
|
133
|
+
deviceData.Device[key] = value;
|
|
134
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
|
|
135
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
136
|
+
break;
|
|
137
|
+
case 'SetHeatFlowTemperatureZone1':
|
|
138
|
+
deviceData.Device[key] = value;
|
|
139
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
|
|
140
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
141
|
+
break;
|
|
142
|
+
case 'SetHeatFlowTemperatureZone2':
|
|
143
|
+
deviceData.Device[key] = value;
|
|
144
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
|
|
145
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
146
|
+
break;
|
|
147
|
+
case 'SetCoolFlowTemperatureZone1':
|
|
148
|
+
deviceData.Device[key] = value;
|
|
149
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
|
|
150
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
151
|
+
break;
|
|
152
|
+
case 'SetCoolFlowTemperatureZone2':
|
|
153
|
+
deviceData.Device[key] = value;
|
|
154
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
|
|
155
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
156
|
+
break;
|
|
157
|
+
case 'SetTankWaterTemperature':
|
|
158
|
+
deviceData.Device[key] = value;
|
|
159
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
|
|
160
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
161
|
+
break;
|
|
162
|
+
case 'ForcedHotWaterMode':
|
|
163
|
+
deviceData.Device[key] = value;
|
|
164
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
165
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
166
|
+
break;
|
|
167
|
+
case 'EcoHotWater':
|
|
168
|
+
deviceData.Device[key] = value;
|
|
169
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.EcoHotWater;
|
|
170
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
171
|
+
break;
|
|
172
|
+
case 'HolidayMode':
|
|
173
|
+
deviceData.Device[key] = value;
|
|
174
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.HolidayMode;
|
|
175
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
176
|
+
break;
|
|
177
|
+
case 'ProhibitZone1':
|
|
178
|
+
deviceData.Device[key] = value;
|
|
179
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ProhibitZone1;
|
|
180
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
181
|
+
break;
|
|
182
|
+
case 'ProhibitZone2':
|
|
183
|
+
deviceData.Device[key] = value;
|
|
184
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ProhibitZone2;
|
|
185
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
186
|
+
break;
|
|
187
|
+
case 'ProhibitHotWater':
|
|
188
|
+
deviceData.Device[key] = value;
|
|
189
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ProhibitHotWater;
|
|
190
|
+
set = await this.melCloudAtw.send(deviceData);
|
|
191
|
+
break;
|
|
192
|
+
default:
|
|
193
|
+
this.emit('warn', `${integration}, received key: ${key}, value: ${value}`);
|
|
194
|
+
break;
|
|
195
|
+
};
|
|
196
|
+
return set;
|
|
197
|
+
} catch (error) {
|
|
198
|
+
throw new Error(`${integration} set key: ${key}, value: ${value}, error: ${error.message ?? error}`);
|
|
199
|
+
};
|
|
200
|
+
}
|
|
201
|
+
//prepare accessory
|
|
202
|
+
async prepareAccessory(accountInfo, deviceData, deviceId, deviceTypeText, deviceName, accountName) {
|
|
203
|
+
try {
|
|
204
|
+
const presetsOnServer = this.accessory.presets;
|
|
205
|
+
const zonesCount = this.accessory.zonesCount;
|
|
206
|
+
const caseHotWater = this.accessory.caseHotWater;
|
|
207
|
+
const caseZone2 = this.accessory.caseZone2;
|
|
208
|
+
const heatCoolModes = this.accessory.heatCoolModes;
|
|
209
|
+
const temperatureSensor = this.temperatureSensor;
|
|
210
|
+
const temperatureSensorFlow = this.temperatureSensorFlow;
|
|
211
|
+
const temperatureSensorReturn = this.temperatureSensorReturn;
|
|
212
|
+
const temperatureSensorFlowZone1 = this.temperatureSensorFlowZone1;
|
|
213
|
+
const temperatureSensorReturnZone1 = this.temperatureSensorReturnZone1;
|
|
214
|
+
const temperatureSensorFlowWaterTank = this.temperatureSensorFlowWaterTank;
|
|
215
|
+
const temperatureSensorReturnWaterTank = this.temperatureSensorReturnWaterTank;
|
|
216
|
+
const temperatureSensorFlowZone2 = this.temperatureSensorFlowZone2;
|
|
217
|
+
const temperatureSensorReturnZone2 = this.temperatureSensorReturnZone2;
|
|
112
218
|
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
this.restFul1 = new RestFul({
|
|
120
|
-
port: this.deviceId.slice(-4),
|
|
121
|
-
debug: this.restFul.debug || false
|
|
122
|
-
});
|
|
219
|
+
//accessory
|
|
220
|
+
const debug = this.enableDebugMode ? this.emit('debug', `Prepare accessory`) : false;
|
|
221
|
+
const accessoryName = deviceName;
|
|
222
|
+
const accessoryUUID = AccessoryUUID.generate(accountName + deviceId.toString());
|
|
223
|
+
const accessoryCategory = Categories.AIR_HEATER;
|
|
224
|
+
const accessory = new Accessory(accessoryName, accessoryUUID, accessoryCategory);
|
|
123
225
|
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
226
|
+
//information service
|
|
227
|
+
const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare information service`) : false;
|
|
228
|
+
accessory.getService(Service.AccessoryInformation)
|
|
229
|
+
.setCharacteristic(Characteristic.Manufacturer, this.manufacturer)
|
|
230
|
+
.setCharacteristic(Characteristic.Model, this.model)
|
|
231
|
+
.setCharacteristic(Characteristic.SerialNumber, this.serialNumber)
|
|
232
|
+
.setCharacteristic(Characteristic.FirmwareRevision, this.firmwareRevision)
|
|
233
|
+
.setCharacteristic(Characteristic.ConfiguredName, accessoryName);
|
|
234
|
+
|
|
235
|
+
//services
|
|
236
|
+
this.melCloudServices = [];
|
|
237
|
+
for (let i = 0; i < zonesCount; i++) {
|
|
238
|
+
const zoneName = this.accessory.zones[i].name
|
|
239
|
+
const serviceName = `${deviceTypeText} ${accessoryName}: ${zoneName}`;
|
|
240
|
+
switch (this.displayMode) {
|
|
241
|
+
case 1: //Heater Cooler
|
|
242
|
+
const debug = this.enableDebugMode ? this.emit('debug', `Prepare heather/cooler ${zoneName} service`) : false;
|
|
243
|
+
const melCloudService = new Service.HeaterCooler(serviceName, `HeaterCooler ${deviceId} ${i}`);
|
|
244
|
+
melCloudService.getCharacteristic(Characteristic.Active)
|
|
245
|
+
.onGet(async () => {
|
|
246
|
+
const state = this.accessory.power;
|
|
247
|
+
return state;
|
|
127
248
|
})
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
249
|
+
.onSet(async (state) => {
|
|
250
|
+
try {
|
|
251
|
+
switch (i) {
|
|
252
|
+
case 0: //Heat Pump
|
|
253
|
+
deviceData.Device.Power = [false, true][state];
|
|
254
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
255
|
+
await this.melCloudAtw.send(deviceData);
|
|
256
|
+
const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set power: ${state ? 'ON' : 'OFF'}`);
|
|
257
|
+
break;
|
|
133
258
|
};
|
|
134
|
-
})
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
})
|
|
138
|
-
.on('error', (error) => {
|
|
139
|
-
this.emit('warn', error);
|
|
140
|
-
});
|
|
141
|
-
}
|
|
142
|
-
const restFul0 = this.restFulConnected ? this.restFul1.update('info', deviceData) : false;
|
|
143
|
-
const restFul1 = this.restFulConnected ? this.restFul1.update('state', deviceData.Device) : false;
|
|
144
|
-
}
|
|
145
|
-
|
|
146
|
-
//MQTT client
|
|
147
|
-
const mqttEnabled = this.mqtt.enable || false;
|
|
148
|
-
if (mqttEnabled) {
|
|
149
|
-
if (!this.mqttConnected) {
|
|
150
|
-
this.mqtt1 = new Mqtt({
|
|
151
|
-
host: this.mqtt.host,
|
|
152
|
-
port: this.mqtt.port || 1883,
|
|
153
|
-
clientId: `${this.mqtt.clientId}_${this.deviceId}` || `${this.deviceTypeText}_${this.deviceName}_${this.deviceId}`,
|
|
154
|
-
prefix: `${this.mqtt.prefix}/${this.deviceTypeText}/${this.deviceName}`,
|
|
155
|
-
user: this.mqtt.user,
|
|
156
|
-
passwd: this.mqtt.pass,
|
|
157
|
-
debug: this.mqtt.debug || false
|
|
259
|
+
} catch (error) {
|
|
260
|
+
this.emit('warn', `Set power error: ${error}`);
|
|
261
|
+
};
|
|
158
262
|
});
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
263
|
+
melCloudService.getCharacteristic(Characteristic.CurrentHeaterCoolerState)
|
|
264
|
+
.onGet(async () => {
|
|
265
|
+
const value = this.accessory.zones[i].currentOperationMode;
|
|
266
|
+
return value;
|
|
267
|
+
});
|
|
268
|
+
melCloudService.getCharacteristic(Characteristic.TargetHeaterCoolerState)
|
|
269
|
+
.setProps({
|
|
270
|
+
minValue: this.accessory.zones[i].operationModesSetPropsMinValue,
|
|
271
|
+
maxValue: this.accessory.zones[i].operationModesSetPropsMaxValue,
|
|
272
|
+
validValues: this.accessory.zones[i].operationModesSetPropsValidValues
|
|
163
273
|
})
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
const flowTemperatureHeatPump = deviceData.Device.FlowTemperature;
|
|
244
|
-
const returnTemperatureHeatPump = deviceData.Device.ReturnTemperature;
|
|
245
|
-
|
|
246
|
-
//zone 1
|
|
247
|
-
const zone1Name = deviceData.Zone1Name ?? 'Zone 1';
|
|
248
|
-
const roomTemperatureZone1 = deviceData.Device.RoomTemperatureZone1;
|
|
249
|
-
const operationModeZone1 = deviceData.Device.OperationModeZone1;
|
|
250
|
-
const setTemperatureZone1 = deviceData.Device.SetTemperatureZone1;
|
|
251
|
-
const setHeatFlowTemperatureZone1 = deviceData.Device.SetHeatFlowTemperatureZone1;
|
|
252
|
-
const setCoolFlowTemperatureZone1 = deviceData.Device.SetCoolFlowTemperatureZone1;
|
|
253
|
-
const prohibitZone1 = deviceData.Device.ProhibitZone1 ?? false;
|
|
254
|
-
const idleZone1 = deviceData.Device.IdleZone1 ?? false;
|
|
255
|
-
const flowTemperatureZone1 = deviceData.Device.FlowTemperatureZone1;
|
|
256
|
-
const returnTemperatureZone1 = deviceData.Device.ReturnTemperatureZone1;
|
|
257
|
-
|
|
258
|
-
//hot water
|
|
259
|
-
const hotWaterName = 'Hot Water';
|
|
260
|
-
const tankWaterTemperature = deviceData.Device.TankWaterTemperature;
|
|
261
|
-
const setTankWaterTemperature = deviceData.Device.SetTankWaterTemperature;
|
|
262
|
-
const forcedHotWaterMode = deviceData.Device.ForcedHotWaterMode ? 1 : 0;
|
|
263
|
-
const ecoHotWater = deviceData.Device.EcoHotWater ?? false;
|
|
264
|
-
const prohibitHotWater = deviceData.Device.ProhibitHotWater ?? false;
|
|
265
|
-
const flowTemperatureWaterTank = deviceData.Device.FlowTemperatureBoiler;
|
|
266
|
-
const returnTemperatureWaterTank = deviceData.Device.ReturnTemperatureBoiler;
|
|
267
|
-
|
|
268
|
-
//zone 2
|
|
269
|
-
const zone2Name = deviceData.Zone2Name ?? 'Zone 2';
|
|
270
|
-
const roomTemperatureZone2 = deviceData.Device.RoomTemperatureZone2;
|
|
271
|
-
const operationModeZone2 = deviceData.Device.OperationModeZone2;
|
|
272
|
-
const setTemperatureZone2 = deviceData.Device.SetTemperatureZone2;
|
|
273
|
-
const setHeatFlowTemperatureZone2 = deviceData.Device.SetHeatFlowTemperatureZone2;
|
|
274
|
-
const setCoolFlowTemperatureZone2 = deviceData.Device.SetCoolFlowTemperatureZone2;
|
|
275
|
-
const prohibitZone2 = deviceData.Device.ProhibitZone2 ?? false;
|
|
276
|
-
const idleZone2 = deviceData.Device.IdleZone2 ?? false;
|
|
277
|
-
const flowTemperatureZone2 = deviceData.Device.FlowTemperatureZone2;
|
|
278
|
-
const returnTemperatureZone2 = deviceData.Device.ReturnTemperatureZone2;
|
|
279
|
-
|
|
280
|
-
//accessory
|
|
281
|
-
this.accessory.presets = presetsOnServer;
|
|
282
|
-
this.accessory.power = power ? 1 : 0;
|
|
283
|
-
this.accessory.unitStatus = unitStatus;
|
|
284
|
-
this.accessory.idleZone1 = idleZone1;
|
|
285
|
-
this.accessory.idleZone2 = idleZone2;
|
|
286
|
-
this.accessory.temperatureIncrement = temperatureIncrement;
|
|
287
|
-
this.accessory.hasHotWaterTank = hasHotWaterTank;
|
|
288
|
-
this.accessory.hasZone2 = hasZone2;
|
|
289
|
-
this.accessory.zonesCount = zonesCount;
|
|
290
|
-
this.accessory.heatCoolModes = heatCoolModes;
|
|
291
|
-
this.accessory.caseHotWater = caseHotWater;
|
|
292
|
-
this.accessory.caseZone2 = caseZone2;
|
|
293
|
-
|
|
294
|
-
//default values
|
|
295
|
-
let name = 'Heat Pump'
|
|
296
|
-
let operationModeZone = 0;
|
|
297
|
-
let currentOperationMode = 0;
|
|
298
|
-
let targetOperationMode = 0;
|
|
299
|
-
let roomTemperature = 20;
|
|
300
|
-
let setTemperature = 20;
|
|
301
|
-
let lockPhysicalControl = 0;
|
|
302
|
-
let flowTemperature = 0;
|
|
303
|
-
let returnTemperature = 0;
|
|
304
|
-
let operationModeSetPropsMinValue = 0;
|
|
305
|
-
let operationModeSetPropsMaxValue = 3;
|
|
306
|
-
let operationModeSetPropsValidValues = [0];
|
|
307
|
-
let temperatureSetPropsMinValue = -35;
|
|
308
|
-
let temperatureSetPropsMaxValue = 100;
|
|
309
|
-
|
|
310
|
-
for (let i = 0; i < zonesCount; i++) {
|
|
311
|
-
switch (this.displayMode) {
|
|
312
|
-
case 1: //Heater Cooler
|
|
313
|
-
switch (i) {
|
|
314
|
-
case 0: //Heat Pump Operation Mode - IDLE, HOT WATER, HEATING ZONES, COOLING, HOT WATER STORAGE, FREEZE STAT, LEGIONELLA, HEATING ECO, MODE 1, MODE 2, MODE 3, HEATING UP /// Unit Status - HEAT, COOL
|
|
315
|
-
name = heatPumpName;
|
|
316
|
-
operationModeZone = operationMode;
|
|
317
|
-
currentOperationMode = !power ? 0 : [1, 2, 2, 3, 2, 1, 1, 2, 1, 1, 1, 2][operationMode]; //INACTIVE, IDLE, HEATING, COOLING
|
|
318
|
-
targetOperationMode = [1, 2][unitStatus]; //AUTO, HEAT, COOL
|
|
319
|
-
roomTemperature = outdoorTemperature;
|
|
320
|
-
setTemperature = outdoorTemperature;
|
|
321
|
-
lockPhysicalControl = hasHotWaterTank && hasZone2 ? (prohibitZone1 && prohibitHotWater && prohibitZone2 ? 1 : 0) : hasHotWaterTank ? (prohibitZone1 && prohibitHotWater ? 1 : 0) : hasZone2 ? (prohibitZone1 && prohibitZone2 ? 1 : 0) : 0;
|
|
322
|
-
flowTemperature = flowTemperatureHeatPump;
|
|
323
|
-
returnTemperature = returnTemperatureHeatPump;
|
|
324
|
-
|
|
325
|
-
operationModeSetPropsMinValue = [1, 1, 2, 0][heatCoolModes];
|
|
326
|
-
operationModeSetPropsMaxValue = [2, 1, 2, 0][heatCoolModes];
|
|
327
|
-
operationModeSetPropsValidValues = [[1, 2], [1], [2], [0]][heatCoolModes];
|
|
328
|
-
temperatureSetPropsMinValue = -35;
|
|
329
|
-
temperatureSetPropsMaxValue = 100;
|
|
330
|
-
break;
|
|
331
|
-
case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
332
|
-
name = zone1Name;
|
|
333
|
-
operationModeZone = operationMode;
|
|
334
|
-
currentOperationMode = !power ? 0 : idleZone1 ? 1 : [2, 2, 2, 3, 3, 2][operationModeZone1]; //INACTIVE, IDLE, HEATING, COOLING
|
|
335
|
-
targetOperationMode = [1, 2, 0, 1, 2, 1][operationModeZone1]; //AUTO, HEAT, COOL
|
|
336
|
-
|
|
337
|
-
switch (operationModeZone1) {
|
|
338
|
-
case 1: //HEAT FLOW
|
|
339
|
-
setTemperature = setHeatFlowTemperatureZone1;
|
|
340
|
-
roomTemperature = flowTemperatureZone1;
|
|
341
|
-
temperatureSetPropsMinValue = 25;
|
|
342
|
-
temperatureSetPropsMaxValue = 60;
|
|
343
|
-
break;
|
|
344
|
-
case 4: //COOL FLOW
|
|
345
|
-
setTemperature = setCoolFlowTemperatureZone1;
|
|
346
|
-
roomTemperature = flowTemperatureZone1;
|
|
347
|
-
temperatureSetPropsMinValue = 16;
|
|
348
|
-
temperatureSetPropsMaxValue = 31;
|
|
349
|
-
break;
|
|
350
|
-
default:
|
|
351
|
-
setTemperature = setTemperatureZone1;
|
|
352
|
-
roomTemperature = roomTemperatureZone1;
|
|
353
|
-
temperatureSetPropsMinValue = 10;
|
|
354
|
-
temperatureSetPropsMaxValue = 31;
|
|
355
|
-
break
|
|
356
|
-
};
|
|
357
|
-
|
|
358
|
-
lockPhysicalControl = prohibitZone1 ? 1 : 0;
|
|
359
|
-
flowTemperature = flowTemperatureZone1;
|
|
360
|
-
returnTemperature = returnTemperatureZone1;
|
|
361
|
-
|
|
362
|
-
operationModeSetPropsMinValue = [0, 0, 1, 0][heatCoolModes];
|
|
363
|
-
operationModeSetPropsMaxValue = [2, 2, 2, 0][heatCoolModes];
|
|
364
|
-
operationModeSetPropsValidValues = [[0, 1, 2], [0, 1, 2], [1, 2], [0]][heatCoolModes];
|
|
365
|
-
break;
|
|
366
|
-
case caseHotWater: //Hot Water - NORMAL, HEAT NOW
|
|
367
|
-
name = hotWaterName;
|
|
368
|
-
operationModeZone = operationMode;
|
|
369
|
-
currentOperationMode = !power ? 0 : operationMode === 1 ? 2 : [1, 2][forcedHotWaterMode]; //INACTIVE, IDLE, HEATING, COOLING
|
|
370
|
-
targetOperationMode = [0, 1][forcedHotWaterMode] //AUTO, HEAT, COOL
|
|
371
|
-
roomTemperature = tankWaterTemperature;
|
|
372
|
-
setTemperature = setTankWaterTemperature;
|
|
373
|
-
lockPhysicalControl = prohibitHotWater ? 1 : 0;
|
|
374
|
-
flowTemperature = flowTemperatureWaterTank;
|
|
375
|
-
returnTemperature = returnTemperatureWaterTank;
|
|
376
|
-
|
|
377
|
-
operationModeSetPropsMinValue = 0;
|
|
378
|
-
operationModeSetPropsMaxValue = 1;
|
|
379
|
-
operationModeSetPropsValidValues = [0, 1];
|
|
380
|
-
temperatureSetPropsMinValue = 0;
|
|
381
|
-
temperatureSetPropsMaxValue = maxTankTemperature;
|
|
382
|
-
break;
|
|
383
|
-
case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
384
|
-
name = zone2Name;
|
|
385
|
-
operationModeZone = operationMode;
|
|
386
|
-
currentOperationMode = !power ? 0 : idleZone2 ? 1 : [2, 2, 2, 3, 3, 2][operationModeZone2]; //INACTIVE, IDLE, HEATING, COOLING
|
|
387
|
-
targetOperationMode = [1, 2, 0, 1, 2, 1][operationModeZone2]; //AUTO, HEAT, COOL
|
|
388
|
-
|
|
389
|
-
switch (operationModeZone2) {
|
|
390
|
-
case 1: //HEAT FLOW
|
|
391
|
-
setTemperature = setHeatFlowTemperatureZone2;
|
|
392
|
-
roomTemperature = flowTemperatureZone2;
|
|
393
|
-
temperatureSetPropsMinValue = 25;
|
|
394
|
-
temperatureSetPropsMaxValue = 60;
|
|
395
|
-
break;
|
|
396
|
-
case 4: //COOL FLOW
|
|
397
|
-
setTemperature = setCoolFlowTemperatureZone2;
|
|
398
|
-
roomTemperature = flowTemperatureZone2;
|
|
399
|
-
temperatureSetPropsMinValue = 16;
|
|
400
|
-
temperatureSetPropsMaxValue = 31;
|
|
401
|
-
break;
|
|
402
|
-
default:
|
|
403
|
-
setTemperature = setTemperatureZone2;
|
|
404
|
-
roomTemperature = roomTemperatureZone2;
|
|
405
|
-
temperatureSetPropsMinValue = 10;
|
|
406
|
-
temperatureSetPropsMaxValue = 31;
|
|
407
|
-
break
|
|
408
|
-
};
|
|
409
|
-
|
|
410
|
-
lockPhysicalControl = prohibitZone2 ? 1 : 0;
|
|
411
|
-
flowTemperature = flowTemperatureZone2;
|
|
412
|
-
returnTemperature = returnTemperatureZone2;
|
|
413
|
-
|
|
414
|
-
operationModeSetPropsMinValue = [0, 0, 1, 0][heatCoolModes];
|
|
415
|
-
operationModeSetPropsMaxValue = [2, 2, 2, 0][heatCoolModes];
|
|
416
|
-
operationModeSetPropsValidValues = [[0, 1, 2], [0, 1, 2], [1, 2], [0]][heatCoolModes];
|
|
417
|
-
break;
|
|
418
|
-
default: //unknown zone detected
|
|
419
|
-
this.emit('message', `Unknown zone: ${i} detected.`);
|
|
420
|
-
break;
|
|
421
|
-
};
|
|
422
|
-
|
|
423
|
-
//update characteristics
|
|
424
|
-
if (this.melCloudServices) {
|
|
425
|
-
this.melCloudServices[i]
|
|
426
|
-
.updateCharacteristic(Characteristic.Active, power)
|
|
427
|
-
.updateCharacteristic(Characteristic.CurrentHeaterCoolerState, currentOperationMode)
|
|
428
|
-
.updateCharacteristic(Characteristic.TargetHeaterCoolerState, targetOperationMode)
|
|
429
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
430
|
-
.updateCharacteristic(Characteristic.LockPhysicalControls, lockPhysicalControl)
|
|
431
|
-
.updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
|
|
432
|
-
const updateDefCool = heatCoolModes === 0 || heatCoolModes === 2 ? this.melCloudServices[i].updateCharacteristic(Characteristic.CoolingThresholdTemperature, setTemperature) : false;
|
|
433
|
-
const updateDefHeat = heatCoolModes === 0 || heatCoolModes === 1 ? this.melCloudServices[i].updateCharacteristic(Characteristic.HeatingThresholdTemperature, setTemperature) : false;
|
|
434
|
-
}
|
|
435
|
-
break;
|
|
436
|
-
case 2: //Thermostat
|
|
437
|
-
switch (i) {
|
|
438
|
-
case 0: //Heat Pump Operation Mode - IDLE, HOT WATER, HEATING ZONES, COOLING, HOT WATER STORAGE, FREEZE STAT, LEGIONELLA, HEATING ECO, MODE 1, MODE 2, MODE 3, HEATING UP /// Unit Status - HEAT, COOL
|
|
439
|
-
name = heatPumpName;
|
|
440
|
-
operationModeZone = operationMode;
|
|
441
|
-
currentOperationMode = !power ? 0 : [0, 1, 1, 2, 1, 0, 0, 1, 0, 0, 0, 1][operationMode]; //OFF, HEAT, COOL
|
|
442
|
-
targetOperationMode = !power ? 0 : [1, 2][unitStatus]; //OFF, HEAT, COOL, AUTO
|
|
443
|
-
roomTemperature = outdoorTemperature;
|
|
444
|
-
setTemperature = outdoorTemperature;
|
|
445
|
-
|
|
446
|
-
operationModeSetPropsMinValue = [0, 0, 0, 0][heatCoolModes];
|
|
447
|
-
operationModeSetPropsMaxValue = [2, 1, 2, 0][heatCoolModes];
|
|
448
|
-
operationModeSetPropsValidValues = [[0, 1, 2], [0, 1], [0, 2], [0]][heatCoolModes];
|
|
449
|
-
temperatureSetPropsMinValue = 10;
|
|
450
|
-
temperatureSetPropsMaxValue = 70;
|
|
451
|
-
break;
|
|
452
|
-
case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
453
|
-
name = zone1Name;
|
|
454
|
-
operationModeZone = operationMode;
|
|
455
|
-
currentOperationMode = !power ? 0 : idleZone1 ? 0 : [1, 1, 1, 2, 2, 1][operationModeZone1]; //OFF, HEAT, COOL
|
|
456
|
-
targetOperationMode = [1, 2, 3, 1, 2, 1][operationModeZone1]; //OFF, HEAT, COOL, AUTO
|
|
457
|
-
|
|
458
|
-
switch (operationModeZone1) {
|
|
459
|
-
case 1: //HEAT FLOW
|
|
460
|
-
setTemperature = setHeatFlowTemperatureZone1;
|
|
461
|
-
roomTemperature = flowTemperatureZone1;
|
|
462
|
-
temperatureSetPropsMinValue = 25;
|
|
463
|
-
temperatureSetPropsMaxValue = 60;
|
|
464
|
-
break;
|
|
465
|
-
case 4: //COOL FLOW
|
|
466
|
-
setTemperature = setCoolFlowTemperatureZone1;
|
|
467
|
-
roomTemperature = flowTemperatureZone1;
|
|
468
|
-
temperatureSetPropsMinValue = 16;
|
|
469
|
-
temperatureSetPropsMaxValue = 31;
|
|
470
|
-
break;
|
|
471
|
-
default:
|
|
472
|
-
setTemperature = setTemperatureZone1;
|
|
473
|
-
roomTemperature = roomTemperatureZone1;
|
|
474
|
-
temperatureSetPropsMinValue = 10;
|
|
475
|
-
temperatureSetPropsMaxValue = 31;
|
|
476
|
-
break
|
|
477
|
-
};
|
|
478
|
-
|
|
479
|
-
operationModeSetPropsMinValue = [1, 1, 1, 0][heatCoolModes];
|
|
480
|
-
operationModeSetPropsMaxValue = [3, 3, 2, 0][heatCoolModes];
|
|
481
|
-
operationModeSetPropsValidValues = [[1, 2, 3], [1, 2, 3], [1, 2], [0]][heatCoolModes];
|
|
482
|
-
break;
|
|
483
|
-
case caseHotWater: //Hot Water - NORMAL, HEAT NOW
|
|
484
|
-
name = hotWaterName;
|
|
485
|
-
operationModeZone = operationMode;
|
|
486
|
-
currentOperationMode = !power ? 0 : operationMode === 1 ? 1 : [0, 1][forcedHotWaterMode]; //OFF, HEAT, COOL
|
|
487
|
-
targetOperationMode = [3, 1][forcedHotWaterMode] //OFF, HEAT, COOL, AUTO
|
|
488
|
-
roomTemperature = tankWaterTemperature;
|
|
489
|
-
setTemperature = setTankWaterTemperature;
|
|
490
|
-
|
|
491
|
-
operationModeSetPropsMinValue = 1;
|
|
492
|
-
operationModeSetPropsMaxValue = 3;
|
|
493
|
-
operationModeSetPropsValidValues = [1, 3];
|
|
494
|
-
temperatureSetPropsMinValue = 0;
|
|
495
|
-
temperatureSetPropsMaxValue = 60;
|
|
496
|
-
break;
|
|
497
|
-
case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
498
|
-
name = zone2Name;
|
|
499
|
-
operationModeZone = operationMode;
|
|
500
|
-
currentOperationMode = !power ? 0 : idleZone2 ? 0 : [1, 1, 1, 2, 2, 1][operationModeZone2]; //OFF, HEAT, COOL
|
|
501
|
-
targetOperationMode = [1, 2, 3, 1, 2, 1][operationModeZone2]; //OFF, HEAT, COOL, AUTO
|
|
502
|
-
|
|
503
|
-
switch (operationModeZone2) {
|
|
504
|
-
case 1: //HEAT FLOW
|
|
505
|
-
setTemperature = setHeatFlowTemperatureZone2;
|
|
506
|
-
roomTemperature = flowTemperatureZone2;
|
|
507
|
-
temperatureSetPropsMinValue = 25;
|
|
508
|
-
temperatureSetPropsMaxValue = 60;
|
|
509
|
-
break;
|
|
510
|
-
case 4: //COOL FLOW
|
|
511
|
-
setTemperature = setCoolFlowTemperatureZone2;
|
|
512
|
-
roomTemperature = flowTemperatureZone2;
|
|
513
|
-
temperatureSetPropsMinValue = 16;
|
|
514
|
-
temperatureSetPropsMaxValue = 31;
|
|
515
|
-
break;
|
|
516
|
-
default:
|
|
517
|
-
setTemperature = setTemperatureZone2;
|
|
518
|
-
roomTemperature = roomTemperatureZone2;
|
|
519
|
-
temperatureSetPropsMinValue = 10;
|
|
520
|
-
temperatureSetPropsMaxValue = 31;
|
|
521
|
-
break
|
|
522
|
-
};
|
|
523
|
-
|
|
524
|
-
operationModeSetPropsMinValue = [1, 1, 1, 0][heatCoolModes];
|
|
525
|
-
operationModeSetPropsMaxValue = [3, 3, 2, 0][heatCoolModes];
|
|
526
|
-
operationModeSetPropsValidValues = [[1, 2, 3], [1, 2, 3], [1, 2], [0]][heatCoolModes];
|
|
527
|
-
break;
|
|
528
|
-
default: //unknown zone detected
|
|
529
|
-
this.emit('message', `Unknown zone: ${i} detected.`);
|
|
530
|
-
break;
|
|
531
|
-
};
|
|
532
|
-
|
|
533
|
-
//update characteristics
|
|
534
|
-
if (this.melCloudServices) {
|
|
535
|
-
this.melCloudServices[i]
|
|
536
|
-
.updateCharacteristic(Characteristic.CurrentHeatingCoolingState, currentOperationMode)
|
|
537
|
-
.updateCharacteristic(Characteristic.TargetHeatingCoolingState, targetOperationMode)
|
|
538
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
539
|
-
.updateCharacteristic(Characteristic.TargetTemperature, setTemperature)
|
|
540
|
-
.updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
|
|
541
|
-
}
|
|
542
|
-
break;
|
|
543
|
-
};
|
|
544
|
-
|
|
545
|
-
//push value to arrays
|
|
546
|
-
this.accessory.zones[i].name = name;
|
|
547
|
-
this.accessory.zones[i].operationMode = operationModeZone;
|
|
548
|
-
this.accessory.zones[i].currentOperationMode = currentOperationMode;
|
|
549
|
-
this.accessory.zones[i].targetOperationMode = targetOperationMode;
|
|
550
|
-
this.accessory.zones[i].roomTemperature = roomTemperature;
|
|
551
|
-
this.accessory.zones[i].setTemperature = setTemperature;
|
|
552
|
-
this.accessory.zones[i].lockPhysicalControl = lockPhysicalControl;
|
|
553
|
-
this.accessory.zones[i].flowTemperature = flowTemperature;
|
|
554
|
-
this.accessory.zones[i].returnTemperature = returnTemperature;
|
|
555
|
-
this.accessory.zones[i].temperaturesSetPropsMinValue = temperatureSetPropsMinValue;
|
|
556
|
-
this.accessory.zones[i].temperaturesSetPropsMaxValue = temperatureSetPropsMaxValue;
|
|
557
|
-
|
|
558
|
-
//only on first run
|
|
559
|
-
if (this.startPrepareAccessory) {
|
|
560
|
-
this.accessory.zones[i].operationModesSetPropsMinValue = operationModeSetPropsMinValue;
|
|
561
|
-
this.accessory.zones[i].operationModesSetPropsMaxValue = operationModeSetPropsMaxValue;
|
|
562
|
-
this.accessory.zones[i].operationModesSetPropsValidValues = operationModeSetPropsValidValues;
|
|
563
|
-
};
|
|
564
|
-
|
|
565
|
-
//update temperature sensors
|
|
566
|
-
switch (i) {
|
|
567
|
-
case 0: //Heat Pump
|
|
568
|
-
if (this.roomTemperatureSensorService) {
|
|
569
|
-
this.roomTemperatureSensorService
|
|
570
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
571
|
-
};
|
|
572
|
-
|
|
573
|
-
if (this.flowTemperatureSensorService) {
|
|
574
|
-
this.flowTemperatureSensorService
|
|
575
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, flowTemperature)
|
|
576
|
-
};
|
|
577
|
-
|
|
578
|
-
if (this.returnTemperatureSensorService) {
|
|
579
|
-
this.returnTemperatureSensorService
|
|
580
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, returnTemperature)
|
|
581
|
-
};
|
|
582
|
-
break;
|
|
583
|
-
case 1: //Zone 1
|
|
584
|
-
if (this.roomTemperatureZone1SensorService) {
|
|
585
|
-
this.roomTemperatureZone1SensorService
|
|
586
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
587
|
-
};
|
|
588
|
-
|
|
589
|
-
if (this.flowTemperatureZone1SensorService) {
|
|
590
|
-
this.flowTemperatureZone1SensorService
|
|
591
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, flowTemperatureZone1)
|
|
592
|
-
};
|
|
593
|
-
|
|
594
|
-
if (this.returnTemperatureZone1SensorService) {
|
|
595
|
-
this.returnTemperatureZone1SensorService
|
|
596
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, returnTemperatureZone1)
|
|
597
|
-
};
|
|
598
|
-
break;
|
|
599
|
-
case caseHotWater: //Hot Water
|
|
600
|
-
if (this.roomTemperatureWaterTankSensorService) {
|
|
601
|
-
this.roomTemperatureWaterTankSensorService
|
|
602
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
603
|
-
};
|
|
604
|
-
|
|
605
|
-
if (this.flowTemperatureWaterTankSensorService) {
|
|
606
|
-
this.flowTemperatureWaterTankSensorService
|
|
607
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, flowTemperatureWaterTank)
|
|
608
|
-
};
|
|
609
|
-
|
|
610
|
-
if (this.returnTemperatureWaterTankSensorService) {
|
|
611
|
-
this.returnTemperatureWaterTankSensorService
|
|
612
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, returnTemperatureWaterTank)
|
|
613
|
-
};
|
|
614
|
-
break;
|
|
615
|
-
case caseZone2: //Zone 2
|
|
616
|
-
if (this.roomTemperatureZone2SensorService) {
|
|
617
|
-
this.roomTemperatureZone2SensorService
|
|
618
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
619
|
-
};
|
|
620
|
-
|
|
621
|
-
if (this.flowTemperatureZone2SensorService) {
|
|
622
|
-
this.flowTemperatureZone2SensorService
|
|
623
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, flowTemperatureZone2)
|
|
624
|
-
};
|
|
625
|
-
|
|
626
|
-
if (this.returnTemperatureZone2SensorService) {
|
|
627
|
-
this.returnTemperatureZone2SensorService
|
|
628
|
-
.updateCharacteristic(Characteristic.CurrentTemperature, returnTemperatureZone2)
|
|
629
|
-
};
|
|
630
|
-
break;
|
|
631
|
-
};
|
|
632
|
-
|
|
633
|
-
//log current state
|
|
634
|
-
if (!this.disableLogInfo) {
|
|
635
|
-
let operationModeText = '';
|
|
636
|
-
switch (i) {
|
|
637
|
-
case 0: //Heat Pump - HEAT, COOL, OFF
|
|
638
|
-
this.emit('message', `${heatPumpName}, Power: ${power ? 'ON' : 'OFF'}`)
|
|
639
|
-
this.emit('message', `${heatPumpName}, Operation mode: ${HeatPump.System[unitStatus]}`);
|
|
640
|
-
this.emit('message', `${heatPumpName},'Outdoor temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
|
|
641
|
-
const info = flowTemperature !== null ? this.emit('message', `${heatPumpName}, Flow temperature: ${flowTemperature}${this.accessory.temperatureUnit}`) : false;
|
|
642
|
-
const info1 = returnTemperature !== null ? this.emit('message', `${heatPumpName}, Return temperature: ${returnTemperature}${this.accessory.temperatureUnit}`) : false;
|
|
643
|
-
this.emit('message', `${heatPumpName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
|
|
644
|
-
this.emit('message', `${heatPumpName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
|
|
645
|
-
break;
|
|
646
|
-
case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
647
|
-
operationModeText = idleZone1 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone1];
|
|
648
|
-
this.emit('message', `${zone1Name}, Operation mode: ${operationModeText}`);
|
|
649
|
-
this.emit('message', `${zone1Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
|
|
650
|
-
this.emit('message', `${zone1Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
|
|
651
|
-
const info2 = flowTemperatureZone1 !== null ? this.emit('message', `${zone1Name}, Flow temperature: ${flowTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
|
|
652
|
-
const info3 = returnTemperatureZone1 !== null ? this.emit('message', `${zone1Name}, Return temperature: ${returnTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
|
|
653
|
-
this.emit('message', `${zone1Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
|
|
654
|
-
this.emit('message', `${zone1Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
|
|
655
|
-
break;
|
|
656
|
-
case caseHotWater: //Hot Water - AUTO, HEAT NOW
|
|
657
|
-
operationModeText = operationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[forcedHotWaterMode ? 1 : 0];
|
|
658
|
-
this.emit('message', `${hotWaterName}, Operation mode: ${operationModeText}`);
|
|
659
|
-
this.emit('message', `${hotWaterName}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
|
|
660
|
-
this.emit('message', `${hotWaterName}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
|
|
661
|
-
const info4 = flowTemperatureWaterTank !== null ? this.emit('message', `${hotWaterName}, Flow temperature: ${flowTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
|
|
662
|
-
const info5 = returnTemperatureWaterTank !== null ? this.emit('message', `${hotWaterName}, Return temperature: ${returnTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
|
|
663
|
-
this.emit('message', `${hotWaterName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
|
|
664
|
-
this.emit('message', `${hotWaterName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
|
|
665
|
-
break;
|
|
666
|
-
case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
667
|
-
operationModeText = idleZone2 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone2];
|
|
668
|
-
this.emit('message', `${zone2Name}, Operation mode: ${operationModeText}`);
|
|
669
|
-
this.emit('message', `${zone2Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
|
|
670
|
-
this.emit('message', `${zone2Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
|
|
671
|
-
const info6 = flowTemperatureZone2 !== null ? this.emit('message', `${zone2Name}, Flow temperature: ${flowTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
|
|
672
|
-
const info7 = roomTemperatureZone2 !== null ? this.emit('message', `${zone2Name}, Return temperature: ${roomTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
|
|
673
|
-
this.emit('message', `${zone2Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
|
|
674
|
-
this.emit('message', `${zone2Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
|
|
675
|
-
break;
|
|
676
|
-
};
|
|
677
|
-
};
|
|
678
|
-
};
|
|
679
|
-
|
|
680
|
-
//update presets state
|
|
681
|
-
if (this.presetsConfigured.length > 0) {
|
|
682
|
-
for (let i = 0; i < this.presetsConfigured.length; i++) {
|
|
683
|
-
const preset = this.presetsConfigured[i];
|
|
684
|
-
const presetData = presetsOnServer.find(p => p.ID === preset.Id);
|
|
685
|
-
|
|
686
|
-
preset.state = presetData ? (presetData.Power === power
|
|
687
|
-
&& presetData.EcoHotWater === ecoHotWater
|
|
688
|
-
&& presetData.OperationModeZone1 === operationModeZone1
|
|
689
|
-
&& presetData.OperationModeZone2 === operationModeZone2
|
|
690
|
-
&& presetData.SetTankWaterTemperature === setTankWaterTemperature
|
|
691
|
-
&& presetData.SetTemperatureZone1 === setTemperatureZone1
|
|
692
|
-
&& presetData.SetTemperatureZone2 === setTemperatureZone2
|
|
693
|
-
&& presetData.ForcedHotWaterMode === forcedHotWaterMode
|
|
694
|
-
&& presetData.SetHeatFlowTemperatureZone1 === setHeatFlowTemperatureZone1
|
|
695
|
-
&& presetData.SetHeatFlowTemperatureZone2 === setHeatFlowTemperatureZone2
|
|
696
|
-
&& presetData.SetCoolFlowTemperatureZone1 === setCoolFlowTemperatureZone1
|
|
697
|
-
&& presetData.SetCoolFlowTemperatureZone2 === setCoolFlowTemperatureZone2) : false;
|
|
698
|
-
|
|
699
|
-
if (this.presetsServices) {
|
|
700
|
-
const characteristicType = preset.characteristicType;
|
|
701
|
-
this.presetsServices[i]
|
|
702
|
-
.updateCharacteristic(characteristicType, preset.state)
|
|
703
|
-
};
|
|
704
|
-
};
|
|
705
|
-
};
|
|
706
|
-
|
|
707
|
-
//update buttons state
|
|
708
|
-
if (this.buttonsConfiguredCount > 0) {
|
|
709
|
-
for (let i = 0; i < this.buttonsConfiguredCount; i++) {
|
|
710
|
-
const button = this.buttonsConfigured[i];
|
|
711
|
-
const mode = button.mode;
|
|
712
|
-
switch (mode) {
|
|
713
|
-
case 0: //POWER ON,OFF
|
|
714
|
-
button.state = (power === true);
|
|
715
|
-
break;
|
|
716
|
-
case 1: //HEAT PUMP HEAT
|
|
717
|
-
button.state = power ? (operationMode === 0) : false;
|
|
718
|
-
break;
|
|
719
|
-
case 2: //COOL
|
|
720
|
-
button.state = power ? (operationMode === 1) : false;
|
|
721
|
-
break;
|
|
722
|
-
case 53: //HOLIDAY
|
|
723
|
-
button.state = power ? (holidayMode === true) : false;
|
|
724
|
-
break;
|
|
725
|
-
case 10: //ALL ZONES PHYSICAL LOCK CONTROL
|
|
726
|
-
button.state = power ? (prohibitZone1 === true && prohibitHotWater === true && prohibitZone2 === true) : false;
|
|
727
|
-
break;
|
|
728
|
-
case 20: //HOT WATER AUTO
|
|
729
|
-
button.state = power ? (forcedHotWaterMode === false) : false;
|
|
730
|
-
break;
|
|
731
|
-
case 21: //ECO
|
|
732
|
-
button.state = power ? (ecoHotWater === true) : false;
|
|
733
|
-
break;
|
|
734
|
-
case 22: //FORCE HEAT
|
|
735
|
-
button.state = power ? (forcedHotWaterMode === true) : false;
|
|
736
|
-
break;
|
|
737
|
-
case 30: //PHYSICAL LOCK CONTROL
|
|
738
|
-
button.state = (prohibitHotWater === true);
|
|
739
|
-
break;
|
|
740
|
-
case 40: //ZONE 1 HEAT THERMOSTAT
|
|
741
|
-
button.state = power ? (operationModeZone1 === 0) : false;
|
|
742
|
-
break;
|
|
743
|
-
case 41: //HEAT FLOW
|
|
744
|
-
button.state = power ? (operationModeZone1 === 1) : false;
|
|
745
|
-
break;
|
|
746
|
-
case 42: //HEAT CURVE
|
|
747
|
-
button.state = power ? (operationModeZone1 === 2) : false;
|
|
748
|
-
break;
|
|
749
|
-
case 43: //COOL THERMOSTAT
|
|
750
|
-
button.state = power ? (operationModeZone1 === 3) : false;
|
|
751
|
-
break;
|
|
752
|
-
case 44: //COOL FLOW
|
|
753
|
-
button.state = power ? (operationModeZone1 === 4) : false;
|
|
754
|
-
break;
|
|
755
|
-
case 45: //FLOOR DRY UP
|
|
756
|
-
button.state = power ? (operationModeZone1 === 5) : false;
|
|
757
|
-
break;
|
|
758
|
-
case 50: //PHYSICAL LOCK CONTROL
|
|
759
|
-
button.state = (prohibitZone1 === true);
|
|
760
|
-
break;
|
|
761
|
-
case 60: //ZONE 2 HEAT THERMOSTAT
|
|
762
|
-
button.state = power ? (operationModeZone2 === 0) : false;
|
|
763
|
-
break;
|
|
764
|
-
case 61: //HEAT FLOW
|
|
765
|
-
button.state = power ? (operationModeZone2 === 1) : false;
|
|
766
|
-
break;
|
|
767
|
-
case 62: //HEAT CURVE
|
|
768
|
-
button.state = power ? (operationModeZone2 === 2) : false;
|
|
769
|
-
break;
|
|
770
|
-
case 63: //COOL THERMOSTAT
|
|
771
|
-
button.state = power ? (operationModeZone2 === 3) : false;
|
|
772
|
-
break;
|
|
773
|
-
case 64: //COOL FLOW
|
|
774
|
-
button.state = power ? (operationModeZone2 === 4) : false;
|
|
775
|
-
break;
|
|
776
|
-
case 65: //FLOOR DRY UP
|
|
777
|
-
button.state = power ? (operationModeZone2 === 5) : false;
|
|
778
|
-
break;
|
|
779
|
-
case 70: //PHYSICAL LOCK CONTROL
|
|
780
|
-
button.state = (prohibitZone2 === true);
|
|
781
|
-
break;
|
|
782
|
-
default: //Unknown button
|
|
783
|
-
this.emit('warn', `Unknown button mode: ${mode} detected.`);
|
|
784
|
-
break;
|
|
785
|
-
};
|
|
786
|
-
|
|
787
|
-
//update services
|
|
788
|
-
if (this.buttonsServices) {
|
|
789
|
-
const characteristicType = button.characteristicType;
|
|
790
|
-
this.buttonsServices[i]
|
|
791
|
-
.updateCharacteristic(characteristicType, button.state)
|
|
792
|
-
};
|
|
793
|
-
};
|
|
794
|
-
};
|
|
795
|
-
|
|
796
|
-
//start prepare accessory
|
|
797
|
-
if (!this.startPrepareAccessory) {
|
|
798
|
-
return;
|
|
799
|
-
}
|
|
800
|
-
|
|
801
|
-
try {
|
|
802
|
-
const accessory = await this.prepareAccessory(this.accountInfo, deviceData, this.deviceId, this.deviceTypeText, this.deviceName, this.accountName);
|
|
803
|
-
this.emit('publishAccessory', accessory);
|
|
804
|
-
this.startPrepareAccessory = false;
|
|
805
|
-
} catch (error) {
|
|
806
|
-
this.emit('error', error);
|
|
807
|
-
};
|
|
808
|
-
})
|
|
809
|
-
.on('success', (message) => {
|
|
810
|
-
this.emit('success', message);
|
|
811
|
-
})
|
|
812
|
-
.on('message', (message) => {
|
|
813
|
-
this.emit('message', message);
|
|
814
|
-
})
|
|
815
|
-
.on('debug', (debug) => {
|
|
816
|
-
this.emit('debug', debug);
|
|
817
|
-
})
|
|
818
|
-
.on('warn', async (warn) => {
|
|
819
|
-
this.emit('warn', warn);
|
|
820
|
-
})
|
|
821
|
-
.on('error', async (error) => {
|
|
822
|
-
this.emit('error', error);
|
|
823
|
-
});
|
|
824
|
-
|
|
825
|
-
//check state
|
|
826
|
-
await this.melCloudAtw.checkState();
|
|
827
|
-
|
|
828
|
-
//start impule generator
|
|
829
|
-
await this.melCloudAtw.impulseGenerator.start([{ name: 'checkState', sampling: this.refreshInterval }]);
|
|
830
|
-
|
|
831
|
-
return true;
|
|
832
|
-
} catch (error) {
|
|
833
|
-
throw new Error(`Start error: ${error}`);
|
|
834
|
-
};
|
|
835
|
-
};
|
|
836
|
-
|
|
837
|
-
async setOverExternalIntegration(integration, deviceData, key, value) {
|
|
838
|
-
try {
|
|
839
|
-
let set = false
|
|
840
|
-
switch (key) {
|
|
841
|
-
case 'Power':
|
|
842
|
-
deviceData.Device[key] = value;
|
|
843
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
844
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
845
|
-
break;
|
|
846
|
-
case 'OperationMode':
|
|
847
|
-
deviceData.Device[key] = value;
|
|
848
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationMode;
|
|
849
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
850
|
-
break;
|
|
851
|
-
case 'OperationModeZone1':
|
|
852
|
-
deviceData.Device[key] = value;
|
|
853
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
854
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
855
|
-
break;
|
|
856
|
-
case 'OperationModeZone2':
|
|
857
|
-
deviceData.Device[key] = value;
|
|
858
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
|
|
859
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
860
|
-
break;
|
|
861
|
-
case 'SetTemperatureZone1':
|
|
862
|
-
deviceData.Device[key] = value;
|
|
863
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
|
|
864
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
865
|
-
break;
|
|
866
|
-
case 'SetTemperatureZone2':
|
|
867
|
-
deviceData.Device[key] = value;
|
|
868
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
|
|
869
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
870
|
-
break;
|
|
871
|
-
case 'SetHeatFlowTemperatureZone1':
|
|
872
|
-
deviceData.Device[key] = value;
|
|
873
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
|
|
874
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
875
|
-
break;
|
|
876
|
-
case 'SetHeatFlowTemperatureZone2':
|
|
877
|
-
deviceData.Device[key] = value;
|
|
878
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
|
|
879
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
880
|
-
break;
|
|
881
|
-
case 'SetCoolFlowTemperatureZone1':
|
|
882
|
-
deviceData.Device[key] = value;
|
|
883
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
|
|
884
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
885
|
-
break;
|
|
886
|
-
case 'SetCoolFlowTemperatureZone2':
|
|
887
|
-
deviceData.Device[key] = value;
|
|
888
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
|
|
889
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
890
|
-
break;
|
|
891
|
-
case 'SetTankWaterTemperature':
|
|
892
|
-
deviceData.Device[key] = value;
|
|
893
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
|
|
894
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
895
|
-
break;
|
|
896
|
-
case 'ForcedHotWaterMode':
|
|
897
|
-
deviceData.Device[key] = value;
|
|
898
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
899
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
900
|
-
break;
|
|
901
|
-
case 'EcoHotWater':
|
|
902
|
-
deviceData.Device[key] = value;
|
|
903
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.EcoHotWater;
|
|
904
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
905
|
-
break;
|
|
906
|
-
case 'HolidayMode':
|
|
907
|
-
deviceData.Device[key] = value;
|
|
908
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.HolidayMode;
|
|
909
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
910
|
-
break;
|
|
911
|
-
case 'ProhibitZone1':
|
|
912
|
-
deviceData.Device[key] = value;
|
|
913
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ProhibitZone1;
|
|
914
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
915
|
-
break;
|
|
916
|
-
case 'ProhibitZone2':
|
|
917
|
-
deviceData.Device[key] = value;
|
|
918
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ProhibitZone2;
|
|
919
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
920
|
-
break;
|
|
921
|
-
case 'ProhibitHotWater':
|
|
922
|
-
deviceData.Device[key] = value;
|
|
923
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ProhibitHotWater;
|
|
924
|
-
set = await this.melCloudAtw.send(deviceData);
|
|
925
|
-
break;
|
|
926
|
-
default:
|
|
927
|
-
this.emit('warn', `${integration}, received key: ${key}, value: ${value}`);
|
|
928
|
-
break;
|
|
929
|
-
};
|
|
930
|
-
return set;
|
|
931
|
-
} catch (error) {
|
|
932
|
-
throw new Error(`${integration} set key: ${key}, value: ${value}, error: ${error.message ?? error}`);
|
|
933
|
-
};
|
|
934
|
-
}
|
|
935
|
-
//prepare accessory
|
|
936
|
-
async prepareAccessory(accountInfo, deviceData, deviceId, deviceTypeText, deviceName, accountName) {
|
|
937
|
-
try {
|
|
938
|
-
const presetsOnServer = this.accessory.presets;
|
|
939
|
-
const zonesCount = this.accessory.zonesCount;
|
|
940
|
-
const caseHotWater = this.accessory.caseHotWater;
|
|
941
|
-
const caseZone2 = this.accessory.caseZone2;
|
|
942
|
-
const heatCoolModes = this.accessory.heatCoolModes;
|
|
943
|
-
const temperatureSensor = this.temperatureSensor;
|
|
944
|
-
const temperatureSensorFlow = this.temperatureSensorFlow;
|
|
945
|
-
const temperatureSensorReturn = this.temperatureSensorReturn;
|
|
946
|
-
const temperatureSensorFlowZone1 = this.temperatureSensorFlowZone1;
|
|
947
|
-
const temperatureSensorReturnZone1 = this.temperatureSensorReturnZone1;
|
|
948
|
-
const temperatureSensorFlowWaterTank = this.temperatureSensorFlowWaterTank;
|
|
949
|
-
const temperatureSensorReturnWaterTank = this.temperatureSensorReturnWaterTank;
|
|
950
|
-
const temperatureSensorFlowZone2 = this.temperatureSensorFlowZone2;
|
|
951
|
-
const temperatureSensorReturnZone2 = this.temperatureSensorReturnZone2;
|
|
274
|
+
.onGet(async () => {
|
|
275
|
+
const value = this.accessory.zones[i].targetOperationMode;
|
|
276
|
+
return value;
|
|
277
|
+
})
|
|
278
|
+
.onSet(async (value) => {
|
|
279
|
+
try {
|
|
280
|
+
let operationModeText = '';
|
|
281
|
+
switch (i) {
|
|
282
|
+
case 0: //Heat Pump - ON, HEAT, COOL
|
|
283
|
+
switch (value) {
|
|
284
|
+
case 0: //AUTO
|
|
285
|
+
deviceData.Device.Power = true;
|
|
286
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
287
|
+
break;
|
|
288
|
+
case 1: //HEAT
|
|
289
|
+
deviceData.Device.Power = true;
|
|
290
|
+
deviceData.Device.UnitStatus = 0;
|
|
291
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
|
|
292
|
+
break;
|
|
293
|
+
case 2: //COOL
|
|
294
|
+
deviceData.Device.Power = true;
|
|
295
|
+
deviceData.Device.UnitStatus = 1;
|
|
296
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
|
|
297
|
+
break;
|
|
298
|
+
};
|
|
299
|
+
operationModeText = [HeatPump.System[0], HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
|
|
300
|
+
break;
|
|
301
|
+
case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
302
|
+
switch (value) {
|
|
303
|
+
case 0: //AUTO - HEAT CURVE
|
|
304
|
+
deviceData.Device.OperationModeZone1 = 2;
|
|
305
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
306
|
+
break;
|
|
307
|
+
case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
|
|
308
|
+
deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
|
|
309
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
310
|
+
break;
|
|
311
|
+
case 2: //COOL - HEAT FLOW / COOL FLOW
|
|
312
|
+
deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
|
|
313
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
314
|
+
break;
|
|
315
|
+
};
|
|
316
|
+
operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
|
|
317
|
+
break;
|
|
318
|
+
case caseHotWater: //Hot Water - AUTO, HEAT NOW
|
|
319
|
+
switch (value) {
|
|
320
|
+
case 0: //AUTO
|
|
321
|
+
deviceData.Device.ForcedHotWaterMode = false;
|
|
322
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
323
|
+
break;
|
|
324
|
+
case 1: //HEAT
|
|
325
|
+
deviceData.Device.ForcedHotWaterMode = true;
|
|
326
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
327
|
+
break;
|
|
328
|
+
case 2: //COOL
|
|
329
|
+
deviceData.Device.ForcedHotWaterMode = false;
|
|
330
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
331
|
+
break
|
|
332
|
+
};
|
|
333
|
+
operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
|
|
334
|
+
break;
|
|
335
|
+
case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
336
|
+
switch (value) {
|
|
337
|
+
case 0: //AUTO
|
|
338
|
+
deviceData.Device.OperationModeZone2 = 2;
|
|
339
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
|
|
340
|
+
break;
|
|
341
|
+
case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
|
|
342
|
+
deviceData.Device.OperationModeZone2 = [0, 3][this.unitStatus];
|
|
343
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
|
|
344
|
+
break;
|
|
345
|
+
case 2: //COOL - HEAT FLOW / COOL FLOW
|
|
346
|
+
deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
|
|
347
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
|
|
348
|
+
break;
|
|
349
|
+
};
|
|
350
|
+
operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
|
|
351
|
+
break;
|
|
352
|
+
};
|
|
952
353
|
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
|
|
957
|
-
|
|
958
|
-
|
|
354
|
+
await this.melCloudAtw.send(deviceData);
|
|
355
|
+
const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set operation mode: ${operationModeText}`);
|
|
356
|
+
} catch (error) {
|
|
357
|
+
this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
|
|
358
|
+
};
|
|
359
|
+
});
|
|
360
|
+
melCloudService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
361
|
+
.setProps({
|
|
362
|
+
minValue: -35,
|
|
363
|
+
maxValue: 150,
|
|
364
|
+
minStep: 0.5
|
|
365
|
+
})
|
|
366
|
+
.onGet(async () => {
|
|
367
|
+
const value = this.accessory.zones[i].roomTemperature;
|
|
368
|
+
return value;
|
|
369
|
+
});
|
|
370
|
+
//only for heat/cool, only cool and not for hot water tank
|
|
371
|
+
if ((heatCoolModes === 0 || heatCoolModes === 2) && i !== caseHotWater) {
|
|
372
|
+
melCloudService.getCharacteristic(Characteristic.CoolingThresholdTemperature)
|
|
373
|
+
.setProps({
|
|
374
|
+
minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
|
|
375
|
+
maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
|
|
376
|
+
minStep: this.accessory.temperatureIncrement
|
|
377
|
+
})
|
|
378
|
+
.onGet(async () => {
|
|
379
|
+
const value = this.accessory.zones[i].setTemperature;
|
|
380
|
+
return value;
|
|
381
|
+
})
|
|
382
|
+
.onSet(async (value) => {
|
|
383
|
+
try {
|
|
384
|
+
switch (i) {
|
|
385
|
+
case 0: //Heat Pump
|
|
386
|
+
//deviceData.Device.SetTemperatureZone1 = value;
|
|
387
|
+
//deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
|
|
388
|
+
break;
|
|
389
|
+
case 1: //Zone 1
|
|
390
|
+
switch (this.accessory.zones[i].operationMode) {
|
|
391
|
+
case 1: //HEAT FLOW
|
|
392
|
+
deviceData.Device.SetHeatFlowTemperatureZone1 = value;
|
|
393
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
|
|
394
|
+
break;
|
|
395
|
+
case 4: //COOL FLOW
|
|
396
|
+
deviceData.Device.SetCoolFlowTemperatureZone1 = value;
|
|
397
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
|
|
398
|
+
break;
|
|
399
|
+
default:
|
|
400
|
+
deviceData.Device.SetTemperatureZone1 = value;
|
|
401
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
|
|
402
|
+
break
|
|
403
|
+
};
|
|
404
|
+
break;
|
|
405
|
+
case caseHotWater: //Hot Water
|
|
406
|
+
deviceData.Device.SetTankWaterTemperature = value;
|
|
407
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
|
|
408
|
+
break;
|
|
409
|
+
case caseZone2: //Zone 2
|
|
410
|
+
switch (this.accessory.zones[i].operationMode) {
|
|
411
|
+
case 1: //HEAT FLOW
|
|
412
|
+
deviceData.Device.SetHeatFlowTemperatureZone2 = value;
|
|
413
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
|
|
414
|
+
break;
|
|
415
|
+
case 4: //COOL FLOW
|
|
416
|
+
deviceData.Device.SetCoolFlowTemperatureZone2 = value;
|
|
417
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
|
|
418
|
+
break;
|
|
419
|
+
default:
|
|
420
|
+
deviceData.Device.SetTemperatureZone2 = value;
|
|
421
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
|
|
422
|
+
break
|
|
423
|
+
};
|
|
424
|
+
break;
|
|
425
|
+
};
|
|
959
426
|
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
|
|
966
|
-
|
|
967
|
-
|
|
427
|
+
const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
|
|
428
|
+
const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set cooling threshold temperature: ${value}${this.accessory.temperatureUnit}`);
|
|
429
|
+
} catch (error) {
|
|
430
|
+
this.emit('warn', `${zoneName}, Set cooling threshold temperature error: ${error}`);
|
|
431
|
+
};
|
|
432
|
+
});
|
|
433
|
+
};
|
|
434
|
+
//device can heat/cool or only heat
|
|
435
|
+
if (heatCoolModes === 0 || heatCoolModes === 1) {
|
|
436
|
+
melCloudService.getCharacteristic(Characteristic.HeatingThresholdTemperature)
|
|
437
|
+
.setProps({
|
|
438
|
+
minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
|
|
439
|
+
maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
|
|
440
|
+
minStep: this.accessory.temperatureIncrement
|
|
441
|
+
})
|
|
442
|
+
.onGet(async () => {
|
|
443
|
+
const value = this.accessory.zones[i].setTemperature;
|
|
444
|
+
return value;
|
|
445
|
+
})
|
|
446
|
+
.onSet(async (value) => {
|
|
447
|
+
try {
|
|
448
|
+
switch (i) {
|
|
449
|
+
case 0: //Heat Pump
|
|
450
|
+
//deviceData.Device.SetTemperatureZone1 = value;
|
|
451
|
+
//deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
|
|
452
|
+
break;
|
|
453
|
+
case 1: //Zone 1
|
|
454
|
+
switch (this.accessory.zones[i].operationMode) {
|
|
455
|
+
case 1: //HEAT FLOW
|
|
456
|
+
deviceData.Device.SetHeatFlowTemperatureZone1 = value;
|
|
457
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone1;
|
|
458
|
+
break;
|
|
459
|
+
case 4: //COOL FLOW
|
|
460
|
+
deviceData.Device.SetCoolFlowTemperatureZone1 = value;
|
|
461
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone1;
|
|
462
|
+
break;
|
|
463
|
+
default:
|
|
464
|
+
deviceData.Device.SetTemperatureZone1 = value;
|
|
465
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
|
|
466
|
+
break
|
|
467
|
+
};
|
|
468
|
+
break;
|
|
469
|
+
case caseHotWater: //Hot Water
|
|
470
|
+
deviceData.Device.SetTankWaterTemperature = value;
|
|
471
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
|
|
472
|
+
break;
|
|
473
|
+
case caseZone2: //Zone 2
|
|
474
|
+
switch (this.accessory.zones[i].operationMode) {
|
|
475
|
+
case 1: //HEAT FLOW
|
|
476
|
+
deviceData.Device.SetHeatFlowTemperatureZone2 = value;
|
|
477
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
|
|
478
|
+
break;
|
|
479
|
+
case 4: //COOL FLOW
|
|
480
|
+
deviceData.Device.SetCoolFlowTemperatureZone2 = value;
|
|
481
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
|
|
482
|
+
break;
|
|
483
|
+
default:
|
|
484
|
+
deviceData.Device.SetTemperatureZone2 = value;
|
|
485
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
|
|
486
|
+
break
|
|
487
|
+
};
|
|
488
|
+
break;
|
|
489
|
+
};
|
|
968
490
|
|
|
969
|
-
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
|
|
974
|
-
|
|
975
|
-
|
|
976
|
-
|
|
977
|
-
const melCloudService = new Service.HeaterCooler(serviceName, `HeaterCooler ${deviceId} ${i}`);
|
|
978
|
-
melCloudService.getCharacteristic(Characteristic.Active)
|
|
491
|
+
const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
|
|
492
|
+
const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set heating threshold temperature: ${value}${this.accessory.temperatureUnit}`);
|
|
493
|
+
} catch (error) {
|
|
494
|
+
this.emit('warn', `${zoneName}, Set heating threshold temperature error: ${error}`);
|
|
495
|
+
};
|
|
496
|
+
});
|
|
497
|
+
};
|
|
498
|
+
melCloudService.getCharacteristic(Characteristic.LockPhysicalControls)
|
|
979
499
|
.onGet(async () => {
|
|
980
|
-
const
|
|
981
|
-
return
|
|
500
|
+
const value = this.accessory.zones[i].lockPhysicalControl;
|
|
501
|
+
return value;
|
|
982
502
|
})
|
|
983
|
-
.onSet(async (
|
|
503
|
+
.onSet(async (value) => {
|
|
984
504
|
try {
|
|
505
|
+
value = value ? true : false;
|
|
985
506
|
switch (i) {
|
|
986
507
|
case 0: //Heat Pump
|
|
987
|
-
deviceData.Device.
|
|
988
|
-
deviceData.Device.
|
|
989
|
-
|
|
990
|
-
|
|
508
|
+
deviceData.Device.ProhibitZone1 = value;
|
|
509
|
+
deviceData.Device.ProhibitHotWater = value;
|
|
510
|
+
deviceData.Device.ProhibitZone2 = value;
|
|
511
|
+
HeatPump.EffectiveFlags.ProhibitHeatingZone1 + HeatPump.EffectiveFlags.ProhibitHotWater + HeatPump.EffectiveFlags.ProhibitHeatingZone2;
|
|
512
|
+
break;
|
|
513
|
+
case 1: //Zone 1
|
|
514
|
+
deviceData.Device.ProhibitZone1 = value;
|
|
515
|
+
HeatPump.EffectiveFlags.ProhibitHeatingZone1;
|
|
516
|
+
break;
|
|
517
|
+
case caseHotWater: //Hot Water
|
|
518
|
+
deviceData.Device.ProhibitHotWater = value;
|
|
519
|
+
HeatPump.EffectiveFlags.ProhibitHotWater;
|
|
520
|
+
break;
|
|
521
|
+
case caseZone2: //Zone 2
|
|
522
|
+
deviceData.Device.ProhibitZone2 = value;
|
|
523
|
+
HeatPump.EffectiveFlags.ProhibitHeatingZone2;
|
|
991
524
|
break;
|
|
992
525
|
};
|
|
526
|
+
|
|
527
|
+
await this.melCloudAtw.send(deviceData);
|
|
528
|
+
const info = this.disableLogInfo ? false : this.emit('message', `${zoneName}, Set lock physical controls: ${value ? 'LOCK' : 'UNLOCK'}`);
|
|
529
|
+
} catch (error) {
|
|
530
|
+
this.emit('warn', `${zoneName}, Set lock physical controls error: ${error}`);
|
|
531
|
+
};
|
|
532
|
+
});
|
|
533
|
+
melCloudService.getCharacteristic(Characteristic.TemperatureDisplayUnits)
|
|
534
|
+
.onGet(async () => {
|
|
535
|
+
const value = this.accessory.useFahrenheit;
|
|
536
|
+
return value;
|
|
537
|
+
})
|
|
538
|
+
.onSet(async (value) => {
|
|
539
|
+
try {
|
|
540
|
+
accountInfo.UseFahrenheit = [false, true][value];
|
|
541
|
+
await this.melCloud.send(accountInfo);
|
|
542
|
+
this.accessory.useFahrenheit = value;
|
|
543
|
+
const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${TemperatureDisplayUnits[value]}`);
|
|
993
544
|
} catch (error) {
|
|
994
|
-
this.emit('warn', `Set
|
|
545
|
+
this.emit('warn', `Set temperature display unit error: ${error}`);
|
|
995
546
|
};
|
|
996
547
|
});
|
|
997
|
-
|
|
548
|
+
this.melCloudServices.push(melCloudService);
|
|
549
|
+
accessory.addService(melCloudService);
|
|
550
|
+
break;
|
|
551
|
+
case 2: //Thermostat
|
|
552
|
+
const debug3 = this.enableDebugMode ? this.emit('debug', `Prepare thermostat ${zoneName} service`) : false;
|
|
553
|
+
const melCloudServiceT = new Service.Thermostat(serviceName, `Thermostat ${deviceId} ${i}`);
|
|
554
|
+
melCloudServiceT.getCharacteristic(Characteristic.CurrentHeatingCoolingState)
|
|
998
555
|
.onGet(async () => {
|
|
999
556
|
const value = this.accessory.zones[i].currentOperationMode;
|
|
1000
557
|
return value;
|
|
1001
558
|
});
|
|
1002
|
-
|
|
559
|
+
melCloudServiceT.getCharacteristic(Characteristic.TargetHeatingCoolingState)
|
|
1003
560
|
.setProps({
|
|
1004
561
|
minValue: this.accessory.zones[i].operationModesSetPropsMinValue,
|
|
1005
562
|
maxValue: this.accessory.zones[i].operationModesSetPropsMaxValue,
|
|
@@ -1013,10 +570,10 @@ class DeviceAtw extends EventEmitter {
|
|
|
1013
570
|
try {
|
|
1014
571
|
let operationModeText = '';
|
|
1015
572
|
switch (i) {
|
|
1016
|
-
case 0: //Heat Pump -
|
|
573
|
+
case 0: //Heat Pump - HEAT, COOL
|
|
1017
574
|
switch (value) {
|
|
1018
|
-
case 0: //
|
|
1019
|
-
deviceData.Device.Power =
|
|
575
|
+
case 0: //OFF
|
|
576
|
+
deviceData.Device.Power = false;
|
|
1020
577
|
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
1021
578
|
break;
|
|
1022
579
|
case 1: //HEAT
|
|
@@ -1029,12 +586,16 @@ class DeviceAtw extends EventEmitter {
|
|
|
1029
586
|
deviceData.Device.UnitStatus = 1;
|
|
1030
587
|
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
|
|
1031
588
|
break;
|
|
589
|
+
case 3: //AUTO
|
|
590
|
+
deviceData.Device.Power = true;
|
|
591
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
592
|
+
break;
|
|
1032
593
|
};
|
|
1033
594
|
operationModeText = [HeatPump.System[0], HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
|
|
1034
595
|
break;
|
|
1035
596
|
case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
1036
597
|
switch (value) {
|
|
1037
|
-
case 0: //
|
|
598
|
+
case 0: //OFF - HEAT CURVE
|
|
1038
599
|
deviceData.Device.OperationModeZone1 = 2;
|
|
1039
600
|
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1040
601
|
break;
|
|
@@ -1046,12 +607,16 @@ class DeviceAtw extends EventEmitter {
|
|
|
1046
607
|
deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
|
|
1047
608
|
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1048
609
|
break;
|
|
610
|
+
case 3: //AUTO - HEAT CURVE
|
|
611
|
+
deviceData.Device.OperationModeZone1 = 2;
|
|
612
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
613
|
+
break;
|
|
1049
614
|
};
|
|
1050
615
|
operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
|
|
1051
616
|
break;
|
|
1052
617
|
case caseHotWater: //Hot Water - AUTO, HEAT NOW
|
|
1053
618
|
switch (value) {
|
|
1054
|
-
case 0: //
|
|
619
|
+
case 0: //OFF
|
|
1055
620
|
deviceData.Device.ForcedHotWaterMode = false;
|
|
1056
621
|
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
1057
622
|
break;
|
|
@@ -1062,13 +627,17 @@ class DeviceAtw extends EventEmitter {
|
|
|
1062
627
|
case 2: //COOL
|
|
1063
628
|
deviceData.Device.ForcedHotWaterMode = false;
|
|
1064
629
|
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
1065
|
-
break
|
|
630
|
+
break;
|
|
631
|
+
case 3: //AUTO
|
|
632
|
+
deviceData.Device.ForcedHotWaterMode = false;
|
|
633
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
634
|
+
break;
|
|
1066
635
|
};
|
|
1067
636
|
operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
|
|
1068
637
|
break;
|
|
1069
638
|
case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
1070
639
|
switch (value) {
|
|
1071
|
-
case 0: //
|
|
640
|
+
case 0: //OFF - HEAT CURVE
|
|
1072
641
|
deviceData.Device.OperationModeZone2 = 2;
|
|
1073
642
|
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1074
643
|
break;
|
|
@@ -1080,6 +649,10 @@ class DeviceAtw extends EventEmitter {
|
|
|
1080
649
|
deviceData.Device.OperationModeZone2 = [1, 4][this.unitStatus];
|
|
1081
650
|
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1082
651
|
break;
|
|
652
|
+
case 3: //AUTO - HEAT CURVE
|
|
653
|
+
deviceData.Device.OperationModeZone2 = 2;
|
|
654
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone2;
|
|
655
|
+
break;
|
|
1083
656
|
};
|
|
1084
657
|
operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
|
|
1085
658
|
break;
|
|
@@ -1091,7 +664,7 @@ class DeviceAtw extends EventEmitter {
|
|
|
1091
664
|
this.emit('warn', `${zoneName}, Set operation mode error: ${error}`);
|
|
1092
665
|
};
|
|
1093
666
|
});
|
|
1094
|
-
|
|
667
|
+
melCloudServiceT.getCharacteristic(Characteristic.CurrentTemperature)
|
|
1095
668
|
.setProps({
|
|
1096
669
|
minValue: -35,
|
|
1097
670
|
maxValue: 150,
|
|
@@ -1101,843 +674,1271 @@ class DeviceAtw extends EventEmitter {
|
|
|
1101
674
|
const value = this.accessory.zones[i].roomTemperature;
|
|
1102
675
|
return value;
|
|
1103
676
|
});
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
|
|
677
|
+
melCloudServiceT.getCharacteristic(Characteristic.TargetTemperature)
|
|
678
|
+
.setProps({
|
|
679
|
+
minValue: this.accessory.zones[i].temperaturesSetPropsMinValue,
|
|
680
|
+
maxValue: this.accessory.zones[i].temperaturesSetPropsMaxValue,
|
|
681
|
+
minStep: this.accessory.temperatureIncrement
|
|
682
|
+
})
|
|
683
|
+
.onGet(async () => {
|
|
684
|
+
const value = this.accessory.zones[i].setTemperature;
|
|
685
|
+
return value;
|
|
686
|
+
})
|
|
687
|
+
.onSet(async (value) => {
|
|
688
|
+
try {
|
|
689
|
+
switch (i) {
|
|
690
|
+
case 0: //Heat Pump
|
|
691
|
+
//deviceData.Device.SetTemperatureZone1 = value;
|
|
692
|
+
//deviceData.Device.EffectiveFlags = CONSTANTS.HeatPump.EffectiveFlags.SetTemperatureZone1;
|
|
693
|
+
break;
|
|
694
|
+
case 1: //Zone 1
|
|
695
|
+
deviceData.Device.SetTemperatureZone1 = value;
|
|
696
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone1;
|
|
697
|
+
break;
|
|
698
|
+
case caseHotWater: //Hot Water
|
|
699
|
+
deviceData.Device.SetTankWaterTemperature = value;
|
|
700
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
|
|
701
|
+
break;
|
|
702
|
+
case caseZone2: //Zone 2
|
|
703
|
+
deviceData.Device.SetTemperatureZone2 = value;
|
|
704
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
|
|
705
|
+
break;
|
|
706
|
+
};
|
|
707
|
+
|
|
708
|
+
const set = i > 0 ? await this.melCloudAtw.send(deviceData) : false;
|
|
709
|
+
const info = this.disableLogInfo || i === 0 ? false : this.emit('message', `${zoneName}, Set temperature: ${value}${this.accessory.temperatureUnit}`);
|
|
710
|
+
} catch (error) {
|
|
711
|
+
this.emit('warn', `${zoneName}, Set temperature error: ${error}`);
|
|
712
|
+
};
|
|
713
|
+
});
|
|
714
|
+
melCloudServiceT.getCharacteristic(Characteristic.TemperatureDisplayUnits)
|
|
715
|
+
.onGet(async () => {
|
|
716
|
+
const value = this.accessory.useFahrenheit;
|
|
717
|
+
return value;
|
|
718
|
+
})
|
|
719
|
+
.onSet(async (value) => {
|
|
720
|
+
try {
|
|
721
|
+
accountInfo.UseFahrenheit = [false, true][value];
|
|
722
|
+
await this.melCloud.send(accountInfo);
|
|
723
|
+
this.accessory.useFahrenheit = value;
|
|
724
|
+
const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${TemperatureDisplayUnits[value]}`);
|
|
725
|
+
} catch (error) {
|
|
726
|
+
this.emit('warn', `Set temperature display unit error: ${error}`);
|
|
727
|
+
};
|
|
728
|
+
});
|
|
729
|
+
this.melCloudServices.push(melCloudServiceT);
|
|
730
|
+
accessory.addService(melCloudServiceT);
|
|
731
|
+
break;
|
|
732
|
+
};
|
|
733
|
+
|
|
734
|
+
//temperature sensor services zones
|
|
735
|
+
switch (i) {
|
|
736
|
+
case 0: //Heat Pump
|
|
737
|
+
if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
|
|
738
|
+
const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
|
|
739
|
+
this.roomTemperatureSensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
|
|
740
|
+
this.roomTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
741
|
+
this.roomTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
|
|
742
|
+
this.roomTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
743
|
+
.setProps({
|
|
744
|
+
minValue: -35,
|
|
745
|
+
maxValue: 150,
|
|
746
|
+
minStep: 0.5
|
|
747
|
+
})
|
|
748
|
+
.onGet(async () => {
|
|
749
|
+
const state = this.accessory.zones[i].roomTemperature;
|
|
750
|
+
return state;
|
|
751
|
+
})
|
|
752
|
+
accessory.addService(this.roomTemperatureSensorService);
|
|
753
|
+
};
|
|
754
|
+
|
|
755
|
+
if (temperatureSensorFlow && this.accessory.zones[i].flowTemperature !== null) {
|
|
756
|
+
const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature sensor service`) : false;
|
|
757
|
+
this.flowTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
|
|
758
|
+
this.flowTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
759
|
+
this.flowTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
|
|
760
|
+
this.flowTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
761
|
+
.setProps({
|
|
762
|
+
minValue: -35,
|
|
763
|
+
maxValue: 150,
|
|
764
|
+
minStep: 0.5
|
|
765
|
+
})
|
|
766
|
+
.onGet(async () => {
|
|
767
|
+
const state = this.accessory.zones[i].flowTemperature;
|
|
768
|
+
return state;
|
|
769
|
+
})
|
|
770
|
+
accessory.addService(this.flowTemperatureSensorService);
|
|
771
|
+
|
|
772
|
+
};
|
|
773
|
+
if (temperatureSensorReturn && this.accessory.zones[i].returnTemperature !== null) {
|
|
774
|
+
const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature sensor service`) : false;
|
|
775
|
+
this.returnTemperatureSensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
|
|
776
|
+
this.returnTemperatureSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
777
|
+
this.returnTemperatureSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
|
|
778
|
+
this.returnTemperatureSensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
779
|
+
.setProps({
|
|
780
|
+
minValue: -35,
|
|
781
|
+
maxValue: 150,
|
|
782
|
+
minStep: 0.5
|
|
783
|
+
})
|
|
784
|
+
.onGet(async () => {
|
|
785
|
+
const state = this.accessory.zones[i].returnTemperature;
|
|
786
|
+
return state;
|
|
787
|
+
})
|
|
788
|
+
accessory.addService(this.returnTemperatureSensorService);
|
|
789
|
+
};
|
|
790
|
+
break;
|
|
791
|
+
case 1: //Zone 1
|
|
792
|
+
if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
|
|
793
|
+
const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
|
|
794
|
+
this.roomTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
|
|
795
|
+
this.roomTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
796
|
+
this.roomTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
|
|
797
|
+
this.roomTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
798
|
+
.setProps({
|
|
799
|
+
minValue: -35,
|
|
800
|
+
maxValue: 150,
|
|
801
|
+
minStep: 0.5
|
|
802
|
+
})
|
|
803
|
+
.onGet(async () => {
|
|
804
|
+
const state = this.accessory.zones[i].roomTemperature;
|
|
805
|
+
return state;
|
|
806
|
+
})
|
|
807
|
+
accessory.addService(this.roomTemperatureZone1SensorService);
|
|
808
|
+
};
|
|
809
|
+
|
|
810
|
+
if (temperatureSensorFlowZone1 && this.accessory.zones[i].flowTemperature !== null) {
|
|
811
|
+
const debug2 = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature zone 1 sensor service`) : false;
|
|
812
|
+
this.flowTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
|
|
813
|
+
this.flowTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
814
|
+
this.flowTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
|
|
815
|
+
this.flowTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
816
|
+
.setProps({
|
|
817
|
+
minValue: -35,
|
|
818
|
+
maxValue: 150,
|
|
819
|
+
minStep: 0.5
|
|
820
|
+
})
|
|
821
|
+
.onGet(async () => {
|
|
822
|
+
const state = this.accessory.zones[i].flowTemperature;
|
|
823
|
+
return state;
|
|
824
|
+
})
|
|
825
|
+
accessory.addService(this.flowTemperatureZone1SensorService);
|
|
826
|
+
};
|
|
827
|
+
|
|
828
|
+
if (temperatureSensorReturnZone1 && this.accessory.zones[i].returnTemperature !== null) {
|
|
829
|
+
const debug3 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature zone 1 sensor service`) : false;
|
|
830
|
+
this.returnTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
|
|
831
|
+
this.returnTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
832
|
+
this.returnTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
|
|
833
|
+
this.returnTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
834
|
+
.setProps({
|
|
835
|
+
minValue: -35,
|
|
836
|
+
maxValue: 150,
|
|
837
|
+
minStep: 0.5
|
|
838
|
+
})
|
|
839
|
+
.onGet(async () => {
|
|
840
|
+
const state = this.accessory.zones[i].returnTemperature;
|
|
841
|
+
return state;
|
|
842
|
+
})
|
|
843
|
+
accessory.addService(this.returnTemperatureZone1SensorService);
|
|
844
|
+
};
|
|
845
|
+
break;
|
|
846
|
+
case caseHotWater: //Hot Water
|
|
847
|
+
if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
|
|
848
|
+
const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
|
|
849
|
+
this.roomTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
|
|
850
|
+
this.roomTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
851
|
+
this.roomTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
|
|
852
|
+
this.roomTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
853
|
+
.setProps({
|
|
854
|
+
minValue: -35,
|
|
855
|
+
maxValue: 150,
|
|
856
|
+
minStep: 0.5
|
|
857
|
+
})
|
|
858
|
+
.onGet(async () => {
|
|
859
|
+
const state = this.accessory.zones[i].roomTemperature;
|
|
860
|
+
return state;
|
|
861
|
+
})
|
|
862
|
+
accessory.addService(this.roomTemperatureWaterTankSensorService);
|
|
863
|
+
};
|
|
864
|
+
|
|
865
|
+
if (temperatureSensorFlowWaterTank && this.accessory.zones[i].flowTemperature !== null) {
|
|
866
|
+
const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature water tank sensor service`) : false;
|
|
867
|
+
this.flowTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow ${deviceId} ${i}`);
|
|
868
|
+
this.flowTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
869
|
+
this.flowTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
|
|
870
|
+
this.flowTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
871
|
+
.setProps({
|
|
872
|
+
minValue: -35,
|
|
873
|
+
maxValue: 150,
|
|
874
|
+
minStep: 0.5
|
|
875
|
+
})
|
|
876
|
+
.onGet(async () => {
|
|
877
|
+
const state = this.accessory.zones[i].flowTemperature;
|
|
878
|
+
return state;
|
|
879
|
+
})
|
|
880
|
+
accessory.addService(this.flowTemperatureWaterTankSensorService);
|
|
881
|
+
};
|
|
882
|
+
|
|
883
|
+
if (temperatureSensorReturnWaterTank && this.accessory.zones[i].returnTemperature !== null) {
|
|
884
|
+
const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature water tank sensor service`) : false;
|
|
885
|
+
this.returnTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return ${deviceId} ${i}`);
|
|
886
|
+
this.returnTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
887
|
+
this.returnTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
|
|
888
|
+
this.returnTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
1107
889
|
.setProps({
|
|
1108
|
-
minValue:
|
|
1109
|
-
maxValue:
|
|
1110
|
-
minStep:
|
|
890
|
+
minValue: -35,
|
|
891
|
+
maxValue: 150,
|
|
892
|
+
minStep: 0.5
|
|
1111
893
|
})
|
|
1112
894
|
.onGet(async () => {
|
|
1113
|
-
const
|
|
1114
|
-
return
|
|
895
|
+
const state = this.accessory.zones[i].returnTemperature;
|
|
896
|
+
return state;
|
|
1115
897
|
})
|
|
1116
|
-
|
|
1117
|
-
|
|
1118
|
-
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
|
|
1126
|
-
|
|
1127
|
-
|
|
1128
|
-
|
|
1129
|
-
|
|
1130
|
-
|
|
1131
|
-
|
|
1132
|
-
|
|
1133
|
-
|
|
1134
|
-
|
|
1135
|
-
|
|
1136
|
-
|
|
1137
|
-
};
|
|
1138
|
-
break;
|
|
1139
|
-
case caseHotWater: //Hot Water
|
|
1140
|
-
deviceData.Device.SetTankWaterTemperature = value;
|
|
1141
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTankWaterTemperature;
|
|
1142
|
-
break;
|
|
1143
|
-
case caseZone2: //Zone 2
|
|
1144
|
-
switch (this.accessory.zones[i].operationMode) {
|
|
1145
|
-
case 1: //HEAT FLOW
|
|
1146
|
-
deviceData.Device.SetHeatFlowTemperatureZone2 = value;
|
|
1147
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetHeatFlowTemperatureZone2;
|
|
1148
|
-
break;
|
|
1149
|
-
case 4: //COOL FLOW
|
|
1150
|
-
deviceData.Device.SetCoolFlowTemperatureZone2 = value;
|
|
1151
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetCoolFlowTemperatureZone2;
|
|
1152
|
-
break;
|
|
1153
|
-
default:
|
|
1154
|
-
deviceData.Device.SetTemperatureZone2 = value;
|
|
1155
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.SetTemperatureZone2;
|
|
1156
|
-
break
|
|
1157
|
-
};
|
|
1158
|
-
break;
|
|
1159
|
-
};
|
|
898
|
+
accessory.addService(this.returnTemperatureWaterTankSensorService);
|
|
899
|
+
};
|
|
900
|
+
break;
|
|
901
|
+
case caseZone2: //Zone 2
|
|
902
|
+
if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
|
|
903
|
+
const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
|
|
904
|
+
this.roomTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
|
|
905
|
+
this.roomTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
906
|
+
this.roomTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
|
|
907
|
+
this.roomTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
908
|
+
.setProps({
|
|
909
|
+
minValue: -35,
|
|
910
|
+
maxValue: 150,
|
|
911
|
+
minStep: 0.5
|
|
912
|
+
})
|
|
913
|
+
.onGet(async () => {
|
|
914
|
+
const state = this.accessory.zones[i].roomTemperature;
|
|
915
|
+
return state;
|
|
916
|
+
})
|
|
917
|
+
accessory.addService(this.roomTemperatureZone2SensorService);
|
|
918
|
+
};
|
|
1160
919
|
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1166
|
-
|
|
920
|
+
if (temperatureSensorFlowZone2 && this.accessory.zones[i].flowTemperature !== null) {
|
|
921
|
+
const debug = this.enableDebugMode ? this.emit('debug', `Prepare flow temperature zone 2 sensor service`) : false;
|
|
922
|
+
this.flowTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName} Flow`, `${zoneName} Temperature Sensor Flow${deviceId} ${i}`);
|
|
923
|
+
this.flowTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
924
|
+
this.flowTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Flow`);
|
|
925
|
+
this.flowTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
926
|
+
.setProps({
|
|
927
|
+
minValue: -35,
|
|
928
|
+
maxValue: 150,
|
|
929
|
+
minStep: 0.5
|
|
930
|
+
})
|
|
931
|
+
.onGet(async () => {
|
|
932
|
+
const state = this.accessory.zones[i].flowTemperature;
|
|
933
|
+
return state;
|
|
934
|
+
})
|
|
935
|
+
accessory.addService(this.flowTemperatureZone2SensorService);
|
|
1167
936
|
};
|
|
1168
|
-
|
|
1169
|
-
if (
|
|
1170
|
-
|
|
937
|
+
|
|
938
|
+
if (temperatureSensorReturnZone2 && this.accessory.zones[i].returnTemperature !== null) {
|
|
939
|
+
const debug1 = this.enableDebugMode ? this.emit('debug', `Prepare return temperature zone 2 sensor service`) : false;
|
|
940
|
+
this.returnTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName} Return`, `${zoneName} Temperature Sensor Return${deviceId} ${i}`);
|
|
941
|
+
this.returnTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
942
|
+
this.returnTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName} Return`);
|
|
943
|
+
this.returnTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
1171
944
|
.setProps({
|
|
1172
|
-
minValue:
|
|
1173
|
-
maxValue:
|
|
1174
|
-
minStep:
|
|
945
|
+
minValue: -35,
|
|
946
|
+
maxValue: 150,
|
|
947
|
+
minStep: 0.5
|
|
1175
948
|
})
|
|
1176
949
|
.onGet(async () => {
|
|
1177
|
-
const
|
|
1178
|
-
return
|
|
950
|
+
const state = this.accessory.zones[i].returnTemperature;
|
|
951
|
+
return state;
|
|
1179
952
|
})
|
|
1180
|
-
|
|
1181
|
-
|
|
1182
|
-
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
|
|
1187
|
-
|
|
1188
|
-
|
|
1189
|
-
|
|
1190
|
-
|
|
1191
|
-
|
|
1192
|
-
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
1202
|
-
|
|
1203
|
-
|
|
1204
|
-
|
|
1205
|
-
|
|
1206
|
-
|
|
1207
|
-
|
|
1208
|
-
|
|
1209
|
-
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
|
|
1220
|
-
|
|
1221
|
-
|
|
1222
|
-
|
|
1223
|
-
|
|
953
|
+
accessory.addService(this.returnTemperatureZone2SensorService);
|
|
954
|
+
};
|
|
955
|
+
break;
|
|
956
|
+
};
|
|
957
|
+
};
|
|
958
|
+
|
|
959
|
+
//presets services
|
|
960
|
+
if (this.presetsConfiguredCount > 0) {
|
|
961
|
+
const debug = this.enableDebugMode ? this.emit('debug', `Prepare presets services`) : false;
|
|
962
|
+
this.presetsServices = [];
|
|
963
|
+
|
|
964
|
+
for (let i = 0; i < this.presetsConfiguredCount; i++) {
|
|
965
|
+
const preset = this.presetsConfigured[i];
|
|
966
|
+
const presetData = presetsOnServer.find(p => p.ID === preset.Id);
|
|
967
|
+
|
|
968
|
+
//get preset name
|
|
969
|
+
const presetName = preset.name;
|
|
970
|
+
|
|
971
|
+
//get preset name prefix
|
|
972
|
+
const presetNamePrefix = preset.namePrefix;
|
|
973
|
+
|
|
974
|
+
const serviceName = presetNamePrefix ? `${accessoryName} ${presetName}` : presetName;
|
|
975
|
+
const serviceType = preset.serviceType;
|
|
976
|
+
const characteristicType = preset.characteristicType;
|
|
977
|
+
const presetService = new serviceType(serviceName, `Preset ${deviceId} ${i}`);
|
|
978
|
+
presetService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
979
|
+
presetService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
|
|
980
|
+
presetService.getCharacteristic(characteristicType)
|
|
981
|
+
.onGet(async () => {
|
|
982
|
+
const state = preset.state;
|
|
983
|
+
return state;
|
|
984
|
+
})
|
|
985
|
+
.onSet(async (state) => {
|
|
986
|
+
try {
|
|
987
|
+
switch (state) {
|
|
988
|
+
case true:
|
|
989
|
+
preset.previousSettings = deviceData.Device;
|
|
990
|
+
deviceData.Device.Power = presetData.Power;
|
|
991
|
+
deviceData.Device.EcoHotWater = presetData.EcoHotWater;
|
|
992
|
+
deviceData.Device.OperationModeZone1 = presetData.OperationModeZone1;
|
|
993
|
+
deviceData.Device.OperationModeZone2 = presetData.OperationModeZone2;
|
|
994
|
+
deviceData.Device.SetTankWaterTemperature = presetData.SetTankWaterTemperature;
|
|
995
|
+
deviceData.Device.SetTemperatureZone1 = presetData.SetTemperatureZone1;
|
|
996
|
+
deviceData.Device.SetTemperatureZone2 = presetData.SetTemperatureZone2;
|
|
997
|
+
deviceData.Device.ForcedHotWaterMode = presetData.ForcedHotWaterMode;
|
|
998
|
+
deviceData.Device.SetHeatFlowTemperatureZone1 = presetData.SetHeatFlowTemperatureZone1;
|
|
999
|
+
deviceData.Device.SetHeatFlowTemperatureZone2 = presetData.SetHeatFlowTemperatureZone2;
|
|
1000
|
+
deviceData.Device.SetCoolFlowTemperatureZone1 = presetData.SetCoolFlowTemperatureZone1;
|
|
1001
|
+
deviceData.Device.SetCoolFlowTemperatureZone2 = presetData.SetCoolFlowTemperatureZone2;
|
|
1002
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
1003
|
+
break;
|
|
1004
|
+
case false:
|
|
1005
|
+
deviceData.Device.Power = preset.previousSettings.Power;
|
|
1006
|
+
deviceData.Device.EcoHotWater = preset.previousSettings.EcoHotWater;
|
|
1007
|
+
deviceData.Device.OperationModeZone1 = preset.previousSettings.OperationModeZone1;
|
|
1008
|
+
deviceData.Device.OperationModeZone2 = preset.previousSettings.OperationModeZone2;
|
|
1009
|
+
deviceData.Device.SetTankWaterTemperature = preset.previousSettings.SetTankWaterTemperature;
|
|
1010
|
+
deviceData.Device.SetTemperatureZone1 = preset.previousSettings.SetTemperatureZone1;
|
|
1011
|
+
deviceData.Device.SetTemperatureZone2 = preset.previousSettings.SetTemperatureZone2;
|
|
1012
|
+
deviceData.Device.ForcedHotWaterMode = preset.previousSettings.ForcedHotWaterMode;
|
|
1013
|
+
deviceData.Device.SetHeatFlowTemperatureZone1 = preset.previousSettings.SetHeatFlowTemperatureZone1;
|
|
1014
|
+
deviceData.Device.SetHeatFlowTemperatureZone2 = preset.previousSettings.SetHeatFlowTemperatureZone2;
|
|
1015
|
+
deviceData.Device.SetCoolFlowTemperatureZone1 = preset.previousSettings.SetCoolFlowTemperatureZone1;
|
|
1016
|
+
deviceData.Device.SetCoolFlowTemperatureZone2 = preset.previousSettings.SetCoolFlowTemperatureZone2;
|
|
1017
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
1018
|
+
break;
|
|
1019
|
+
};
|
|
1020
|
+
|
|
1021
|
+
await this.melCloudAtw.send(deviceData);
|
|
1022
|
+
const info = this.disableLogInfo ? false : this.emit('message', `${state ? 'Set:' : 'Unset:'} ${presetName}`);
|
|
1023
|
+
} catch (error) {
|
|
1024
|
+
this.emit('warn', `Set preset error: ${error}`);
|
|
1025
|
+
};
|
|
1026
|
+
});
|
|
1027
|
+
this.presetsServices.push(presetService);
|
|
1028
|
+
accessory.addService(presetService);
|
|
1029
|
+
};
|
|
1030
|
+
};
|
|
1031
|
+
|
|
1032
|
+
//buttons services
|
|
1033
|
+
if (this.buttonsConfiguredCount > 0) {
|
|
1034
|
+
const debug = this.enableDebugMode ? this.emit('debug', `Prepare buttons services`) : false;
|
|
1035
|
+
this.buttonsServices = [];
|
|
1036
|
+
|
|
1037
|
+
for (let i = 0; i < this.buttonsConfiguredCount; i++) {
|
|
1038
|
+
const button = this.buttonsConfigured[i];
|
|
1224
1039
|
|
|
1225
|
-
|
|
1226
|
-
|
|
1227
|
-
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
|
|
1231
|
-
|
|
1232
|
-
|
|
1233
|
-
|
|
1234
|
-
|
|
1235
|
-
|
|
1236
|
-
|
|
1237
|
-
|
|
1040
|
+
//get button mode
|
|
1041
|
+
const mode = button.mode;
|
|
1042
|
+
|
|
1043
|
+
//get button display type
|
|
1044
|
+
const displayType = button.displayType;
|
|
1045
|
+
|
|
1046
|
+
//get button name
|
|
1047
|
+
const buttonName = button.name;
|
|
1048
|
+
|
|
1049
|
+
//get button name prefix
|
|
1050
|
+
const buttonNamePrefix = button.namePrefix;
|
|
1051
|
+
|
|
1052
|
+
const serviceName = buttonNamePrefix ? `${accessoryName} ${buttonName}` : buttonName;
|
|
1053
|
+
const serviceType = button.serviceType;
|
|
1054
|
+
const characteristicType = button.characteristicType;
|
|
1055
|
+
const buttonService = new serviceType(serviceName, `Button ${deviceId} ${i}`);
|
|
1056
|
+
buttonService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
1057
|
+
buttonService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
|
|
1058
|
+
buttonService.getCharacteristic(characteristicType)
|
|
1059
|
+
.onGet(async () => {
|
|
1060
|
+
const state = button.state;
|
|
1061
|
+
return state;
|
|
1062
|
+
})
|
|
1063
|
+
.onSet(async (state) => {
|
|
1064
|
+
if (displayType > 0 && displayType < 3) {
|
|
1238
1065
|
try {
|
|
1239
|
-
|
|
1240
|
-
|
|
1241
|
-
|
|
1242
|
-
deviceData.Device.
|
|
1243
|
-
deviceData.Device.ProhibitHotWater = value;
|
|
1244
|
-
deviceData.Device.ProhibitZone2 = value;
|
|
1245
|
-
HeatPump.EffectiveFlags.ProhibitHeatingZone1 + HeatPump.EffectiveFlags.ProhibitHotWater + HeatPump.EffectiveFlags.ProhibitHeatingZone2;
|
|
1066
|
+
switch (mode) {
|
|
1067
|
+
case 0: //POWER ON,OFF
|
|
1068
|
+
deviceData.Device.Power = state;
|
|
1069
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
1246
1070
|
break;
|
|
1247
|
-
case 1: //
|
|
1248
|
-
deviceData.Device.
|
|
1071
|
+
case 1: //HEAT PUMP HEAT
|
|
1072
|
+
button.previousValue = state ? deviceData.Device.UnitStatus : button.previousValue ?? deviceData.Device.UnitStatus;
|
|
1073
|
+
deviceData.Device.Power = true;
|
|
1074
|
+
deviceData.Device.UnitStatus = state ? 0 : button.previousValue;
|
|
1075
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
|
|
1076
|
+
break;
|
|
1077
|
+
case 2: //COOL
|
|
1078
|
+
button.previousValue = state ? deviceData.Device.UnitStatus : button.previousValue ?? deviceData.Device.UnitStatus;
|
|
1079
|
+
deviceData.Device.Power = true;
|
|
1080
|
+
deviceData.Device.UnitStatus = state ? 1 : button.previousValue;
|
|
1081
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
|
|
1082
|
+
break;
|
|
1083
|
+
case 3: //HOLIDAY
|
|
1084
|
+
deviceData.Device.HolidayMode = state;
|
|
1085
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.HolidayMode;
|
|
1086
|
+
break;
|
|
1087
|
+
case 10: //ALL ZONES PHYSICAL LOCK CONTROL
|
|
1088
|
+
deviceData.Device.ProhibitZone1 = state;
|
|
1089
|
+
deviceData.Device.ProhibitHotWater = state;
|
|
1090
|
+
deviceData.Device.ProhibitZone2 = state;
|
|
1091
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ProhibitHeatingZone1 + HeatPump.EffectiveFlags.ProhibitHotWater + HeatPump.EffectiveFlags.ProhibitHeatingZone2;
|
|
1092
|
+
break;
|
|
1093
|
+
case 20: //ZONE 1 HEAT THERMOSTAT
|
|
1094
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1095
|
+
deviceData.Device.Power = true;
|
|
1096
|
+
deviceData.Device.OperationModeZone1 = state ? 0 : button.previousValue;
|
|
1097
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1098
|
+
break;
|
|
1099
|
+
case 21: //HEAT FLOW
|
|
1100
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1101
|
+
deviceData.Device.Power = true;
|
|
1102
|
+
deviceData.Device.OperationModeZone1 = state ? 1 : button.previousValue;
|
|
1103
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1104
|
+
break;
|
|
1105
|
+
case 22: //HEAT CURVE
|
|
1106
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1107
|
+
deviceData.Device.Power = true;
|
|
1108
|
+
deviceData.Device.OperationModeZone1 = state ? 2 : button.previousValue;
|
|
1109
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1110
|
+
break;
|
|
1111
|
+
case 23: //COOL THERMOSTAT
|
|
1112
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1113
|
+
deviceData.Device.Power = true;
|
|
1114
|
+
deviceData.Device.OperationModeZone1 = state ? 3 : button.previousValue;
|
|
1115
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1116
|
+
break;
|
|
1117
|
+
case 24: //COOL FLOW
|
|
1118
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1119
|
+
deviceData.Device.Power = true;
|
|
1120
|
+
deviceData.Device.OperationModeZone1 = state ? 4 : button.previousValue;
|
|
1121
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1122
|
+
break;
|
|
1123
|
+
case 25: //FLOOR DRY UP
|
|
1124
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1125
|
+
deviceData.Device.Power = true;
|
|
1126
|
+
deviceData.Device.OperationModeZone1 = state ? 5 : button.previousValue;
|
|
1127
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1128
|
+
break;
|
|
1129
|
+
case 30: //PHYSICAL LOCK CONTROL
|
|
1130
|
+
deviceData.Device.ProhibitZone1 = state;
|
|
1249
1131
|
HeatPump.EffectiveFlags.ProhibitHeatingZone1;
|
|
1250
1132
|
break;
|
|
1251
|
-
case
|
|
1252
|
-
deviceData.Device.
|
|
1133
|
+
case 40: //HOT WATER NORMAL/FORCE HOT WATER
|
|
1134
|
+
deviceData.Device.Power = true;
|
|
1135
|
+
deviceData.Device.ForcedHotWaterMode = state;
|
|
1136
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
1137
|
+
break;
|
|
1138
|
+
case 41: //NORMAL/ECO
|
|
1139
|
+
deviceData.Device.Power = true;
|
|
1140
|
+
deviceData.Device.EcoHotWater = state;
|
|
1141
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.EcoHotWater;
|
|
1142
|
+
break;
|
|
1143
|
+
case 50: //PHYSICAL LOCK CONTROL
|
|
1144
|
+
deviceData.Device.ProhibitHotWater = state;
|
|
1253
1145
|
HeatPump.EffectiveFlags.ProhibitHotWater;
|
|
1254
1146
|
break;
|
|
1255
|
-
case
|
|
1256
|
-
deviceData.Device.
|
|
1257
|
-
|
|
1147
|
+
case 60: //ZONE 2 HEAT THERMOSTAT
|
|
1148
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1149
|
+
deviceData.Device.Power = true;
|
|
1150
|
+
deviceData.Device.OperationModeZone2 = state ? 0 : button.previousValue;
|
|
1151
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1258
1152
|
break;
|
|
1259
|
-
|
|
1260
|
-
|
|
1261
|
-
|
|
1262
|
-
|
|
1263
|
-
|
|
1264
|
-
this.emit('warn', `${zoneName}, Set lock physical controls error: ${error}`);
|
|
1265
|
-
};
|
|
1266
|
-
});
|
|
1267
|
-
melCloudService.getCharacteristic(Characteristic.TemperatureDisplayUnits)
|
|
1268
|
-
.onGet(async () => {
|
|
1269
|
-
const value = this.accessory.useFahrenheit;
|
|
1270
|
-
return value;
|
|
1271
|
-
})
|
|
1272
|
-
.onSet(async (value) => {
|
|
1273
|
-
try {
|
|
1274
|
-
accountInfo.UseFahrenheit = [false, true][value];
|
|
1275
|
-
await this.melCloud.send(accountInfo);
|
|
1276
|
-
this.accessory.useFahrenheit = value;
|
|
1277
|
-
const info = this.disableLogInfo ? false : this.emit('message', `Set temperature display unit: ${TemperatureDisplayUnits[value]}`);
|
|
1278
|
-
} catch (error) {
|
|
1279
|
-
this.emit('warn', `Set temperature display unit error: ${error}`);
|
|
1280
|
-
};
|
|
1281
|
-
});
|
|
1282
|
-
this.melCloudServices.push(melCloudService);
|
|
1283
|
-
accessory.addService(melCloudService);
|
|
1284
|
-
break;
|
|
1285
|
-
case 2: //Thermostat
|
|
1286
|
-
const debug3 = this.enableDebugMode ? this.emit('debug', `Prepare thermostat ${zoneName} service`) : false;
|
|
1287
|
-
const melCloudServiceT = new Service.Thermostat(serviceName, `Thermostat ${deviceId} ${i}`);
|
|
1288
|
-
melCloudServiceT.getCharacteristic(Characteristic.CurrentHeatingCoolingState)
|
|
1289
|
-
.onGet(async () => {
|
|
1290
|
-
const value = this.accessory.zones[i].currentOperationMode;
|
|
1291
|
-
return value;
|
|
1292
|
-
});
|
|
1293
|
-
melCloudServiceT.getCharacteristic(Characteristic.TargetHeatingCoolingState)
|
|
1294
|
-
.setProps({
|
|
1295
|
-
minValue: this.accessory.zones[i].operationModesSetPropsMinValue,
|
|
1296
|
-
maxValue: this.accessory.zones[i].operationModesSetPropsMaxValue,
|
|
1297
|
-
validValues: this.accessory.zones[i].operationModesSetPropsValidValues
|
|
1298
|
-
})
|
|
1299
|
-
.onGet(async () => {
|
|
1300
|
-
const value = this.accessory.zones[i].targetOperationMode;
|
|
1301
|
-
return value;
|
|
1302
|
-
})
|
|
1303
|
-
.onSet(async (value) => {
|
|
1304
|
-
try {
|
|
1305
|
-
let operationModeText = '';
|
|
1306
|
-
switch (i) {
|
|
1307
|
-
case 0: //Heat Pump - HEAT, COOL
|
|
1308
|
-
switch (value) {
|
|
1309
|
-
case 0: //OFF
|
|
1310
|
-
deviceData.Device.Power = false;
|
|
1311
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
1312
|
-
break;
|
|
1313
|
-
case 1: //HEAT
|
|
1314
|
-
deviceData.Device.Power = true;
|
|
1315
|
-
deviceData.Device.UnitStatus = 0;
|
|
1316
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
|
|
1317
|
-
break;
|
|
1318
|
-
case 2: //COOL
|
|
1319
|
-
deviceData.Device.Power = true;
|
|
1320
|
-
deviceData.Device.UnitStatus = 1;
|
|
1321
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
|
|
1322
|
-
break;
|
|
1323
|
-
case 3: //AUTO
|
|
1324
|
-
deviceData.Device.Power = true;
|
|
1325
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
1326
|
-
break;
|
|
1327
|
-
};
|
|
1328
|
-
operationModeText = [HeatPump.System[0], HeatPump.System[deviceData.Device.UnitStatus]][this.accessory.power];
|
|
1153
|
+
case 61: // HEAT FLOW
|
|
1154
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1155
|
+
deviceData.Device.Power = true;
|
|
1156
|
+
deviceData.Device.OperationModeZone2 = state ? 1 : button.previousValue;
|
|
1157
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1329
1158
|
break;
|
|
1330
|
-
case
|
|
1331
|
-
|
|
1332
|
-
|
|
1333
|
-
|
|
1334
|
-
|
|
1335
|
-
break;
|
|
1336
|
-
case 1: //HEAT - HEAT THERMOSTAT / COOL THERMOSTAT
|
|
1337
|
-
deviceData.Device.OperationModeZone1 = [0, 3][this.unitStatus];
|
|
1338
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1339
|
-
break;
|
|
1340
|
-
case 2: //COOL - HEAT FLOW / COOL FLOW
|
|
1341
|
-
deviceData.Device.OperationModeZone1 = [1, 4][this.unitStatus];
|
|
1342
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1343
|
-
break;
|
|
1344
|
-
case 3: //AUTO - HEAT CURVE
|
|
1345
|
-
deviceData.Device.OperationModeZone1 = 2;
|
|
1346
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1347
|
-
break;
|
|
1348
|
-
};
|
|
1349
|
-
operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone1];
|
|
1159
|
+
case 62: //HEAT CURVE
|
|
1160
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1161
|
+
deviceData.Device.Power = true;
|
|
1162
|
+
deviceData.Device.OperationModeZone2 = state ? 2 : button.previousValue;
|
|
1163
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1350
1164
|
break;
|
|
1351
|
-
case
|
|
1352
|
-
|
|
1353
|
-
|
|
1354
|
-
|
|
1355
|
-
|
|
1356
|
-
break;
|
|
1357
|
-
case 1: //HEAT
|
|
1358
|
-
deviceData.Device.ForcedHotWaterMode = true;
|
|
1359
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
1360
|
-
break;
|
|
1361
|
-
case 2: //COOL
|
|
1362
|
-
deviceData.Device.ForcedHotWaterMode = false;
|
|
1363
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
1364
|
-
break;
|
|
1365
|
-
case 3: //AUTO
|
|
1366
|
-
deviceData.Device.ForcedHotWaterMode = false;
|
|
1367
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
1368
|
-
break;
|
|
1369
|
-
};
|
|
1370
|
-
operationModeText = deviceData.Device.OperationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[deviceData.Device.ForcedHotWaterMode ? 1 : 0];
|
|
1165
|
+
case 63: //COOL THERMOSTAT
|
|
1166
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1167
|
+
deviceData.Device.Power = true;
|
|
1168
|
+
deviceData.Device.OperationModeZone2 = state ? 3 : button.previousValue;
|
|
1169
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1371
1170
|
break;
|
|
1372
|
-
case
|
|
1373
|
-
|
|
1374
|
-
|
|
1375
|
-
|
|
1376
|
-
|
|
1377
|
-
|
|
1378
|
-
|
|
1379
|
-
|
|
1380
|
-
|
|
1381
|
-
|
|
1382
|
-
|
|
1383
|
-
|
|
1384
|
-
|
|
1385
|
-
|
|
1386
|
-
|
|
1387
|
-
|
|
1388
|
-
|
|
1389
|
-
|
|
1390
|
-
};
|
|
1391
|
-
operationModeText = HeatPump.ZoneOperation[deviceData.Device.OperationModeZone2];
|
|
1171
|
+
case 64: //COOL FLOW
|
|
1172
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1173
|
+
deviceData.Device.Power = true;
|
|
1174
|
+
deviceData.Device.OperationModeZone2 = state ? 4 : button.previousValue;
|
|
1175
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1176
|
+
break;
|
|
1177
|
+
case 65: //FLOOR DRY UP
|
|
1178
|
+
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1179
|
+
deviceData.Device.Power = true;
|
|
1180
|
+
deviceData.Device.OperationModeZone2 = state ? 5 : button.previousValue;
|
|
1181
|
+
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1182
|
+
break;
|
|
1183
|
+
case 70: //PHYSICAL LOCK CONTROL
|
|
1184
|
+
deviceData.Device.ProhibitZone2 = state;
|
|
1185
|
+
HeatPump.EffectiveFlags.ProhibitHeatingZone2;
|
|
1186
|
+
break;
|
|
1187
|
+
default:
|
|
1188
|
+
this.emit('message', `Unknown button mode: ${mode}`);
|
|
1392
1189
|
break;
|
|
1393
1190
|
};
|
|
1394
1191
|
|
|
1395
|
-
await this.melCloudAtw.send(deviceData);
|
|
1396
|
-
const info = this.disableLogInfo ? false : this.emit('message', `${
|
|
1397
|
-
} catch (error) {
|
|
1398
|
-
this.emit('warn',
|
|
1399
|
-
};
|
|
1400
|
-
}
|
|
1401
|
-
|
|
1402
|
-
|
|
1403
|
-
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
|
|
1409
|
-
|
|
1410
|
-
|
|
1411
|
-
|
|
1412
|
-
|
|
1413
|
-
|
|
1414
|
-
|
|
1415
|
-
|
|
1416
|
-
|
|
1417
|
-
|
|
1418
|
-
|
|
1419
|
-
|
|
1420
|
-
|
|
1421
|
-
|
|
1422
|
-
|
|
1423
|
-
|
|
1424
|
-
|
|
1425
|
-
|
|
1426
|
-
|
|
1427
|
-
|
|
1428
|
-
|
|
1429
|
-
|
|
1430
|
-
|
|
1431
|
-
|
|
1432
|
-
|
|
1433
|
-
|
|
1434
|
-
|
|
1435
|
-
|
|
1436
|
-
|
|
1437
|
-
|
|
1438
|
-
|
|
1439
|
-
|
|
1440
|
-
|
|
1192
|
+
await this.melCloudAtw.send(deviceData);
|
|
1193
|
+
const info = this.disableLogInfo ? false : this.emit('message', `${state ? `Set: ${buttonName}` : `Unset: ${buttonName}, Set: ${button.previousValue}`}`);
|
|
1194
|
+
} catch (error) {
|
|
1195
|
+
this.emit('warn', `Set button error: ${error}`);
|
|
1196
|
+
};
|
|
1197
|
+
};
|
|
1198
|
+
});
|
|
1199
|
+
this.buttonsServices.push(buttonService);
|
|
1200
|
+
accessory.addService(buttonService)
|
|
1201
|
+
};
|
|
1202
|
+
};
|
|
1203
|
+
|
|
1204
|
+
return accessory;
|
|
1205
|
+
} catch (error) {
|
|
1206
|
+
throw new Error(`Prepare accessory error: ${error.message || error}`);
|
|
1207
|
+
};
|
|
1208
|
+
};
|
|
1209
|
+
|
|
1210
|
+
//start
|
|
1211
|
+
async start() {
|
|
1212
|
+
try {
|
|
1213
|
+
//melcloud device
|
|
1214
|
+
this.melCloudAtw = new MelCloudAtw({
|
|
1215
|
+
contextKey: this.contextKey,
|
|
1216
|
+
devicesFile: this.devicesFile,
|
|
1217
|
+
deviceId: this.deviceId,
|
|
1218
|
+
debugLog: this.enableDebugMode
|
|
1219
|
+
});
|
|
1220
|
+
|
|
1221
|
+
this.melCloudAtw.on('externalIntegrations', (deviceData) => {
|
|
1222
|
+
try {
|
|
1223
|
+
//RESTFul server
|
|
1224
|
+
const restFulEnabled = this.restFul.enable || false;
|
|
1225
|
+
if (restFulEnabled) {
|
|
1226
|
+
if (!this.restFulConnected) {
|
|
1227
|
+
this.restFul1 = new RestFul({
|
|
1228
|
+
port: this.deviceId.slice(-4),
|
|
1229
|
+
debug: this.restFul.debug || false
|
|
1230
|
+
});
|
|
1231
|
+
|
|
1232
|
+
this.restFul1.on('connected', (message) => {
|
|
1233
|
+
this.restFulConnected = true;
|
|
1234
|
+
this.emit('success', message);
|
|
1235
|
+
})
|
|
1236
|
+
.on('set', async (key, value) => {
|
|
1237
|
+
try {
|
|
1238
|
+
await this.setOverExternalIntegration('RESTFul', deviceData, key, value);
|
|
1239
|
+
} catch (error) {
|
|
1240
|
+
this.emit('warn', error);
|
|
1241
|
+
};
|
|
1242
|
+
})
|
|
1243
|
+
.on('debug', (debug) => {
|
|
1244
|
+
this.emit('debug', debug);
|
|
1245
|
+
})
|
|
1246
|
+
.on('error', (error) => {
|
|
1247
|
+
this.emit('warn', error);
|
|
1248
|
+
});
|
|
1249
|
+
}
|
|
1250
|
+
const restFul0 = this.restFulConnected ? this.restFul1.update('info', deviceData) : false;
|
|
1251
|
+
const restFul1 = this.restFulConnected ? this.restFul1.update('state', deviceData.Device) : false;
|
|
1252
|
+
}
|
|
1253
|
+
|
|
1254
|
+
//MQTT client
|
|
1255
|
+
const mqttEnabled = this.mqtt.enable || false;
|
|
1256
|
+
if (mqttEnabled) {
|
|
1257
|
+
if (!this.mqttConnected) {
|
|
1258
|
+
this.mqtt1 = new Mqtt({
|
|
1259
|
+
host: this.mqtt.host,
|
|
1260
|
+
port: this.mqtt.port || 1883,
|
|
1261
|
+
clientId: `${this.mqtt.clientId}_${this.deviceId}` || `${this.deviceTypeText}_${this.deviceName}_${this.deviceId}`,
|
|
1262
|
+
prefix: `${this.mqtt.prefix}/${this.deviceTypeText}/${this.deviceName}`,
|
|
1263
|
+
user: this.mqtt.user,
|
|
1264
|
+
passwd: this.mqtt.pass,
|
|
1265
|
+
debug: this.mqtt.debug || false
|
|
1266
|
+
});
|
|
1267
|
+
|
|
1268
|
+
this.mqtt1.on('connected', (message) => {
|
|
1269
|
+
this.mqttConnected = true;
|
|
1270
|
+
this.emit('success', message);
|
|
1271
|
+
})
|
|
1272
|
+
.on('subscribed', (message) => {
|
|
1273
|
+
this.emit('success', message);
|
|
1274
|
+
})
|
|
1275
|
+
.on('set', async (key, value) => {
|
|
1276
|
+
try {
|
|
1277
|
+
await this.setOverExternalIntegration('MQTT', deviceData, key, value);
|
|
1278
|
+
} catch (error) {
|
|
1279
|
+
this.emit('warn', error);
|
|
1280
|
+
};
|
|
1281
|
+
})
|
|
1282
|
+
.on('debug', (debug) => {
|
|
1283
|
+
this.emit('debug', debug);
|
|
1284
|
+
})
|
|
1285
|
+
.on('error', (error) => {
|
|
1286
|
+
this.emit('warn', error);
|
|
1287
|
+
});
|
|
1288
|
+
}
|
|
1289
|
+
const mqtt0 = this.mqttConnected ? this.mqtt1.emit('publish', `Info`, deviceData) : false;
|
|
1290
|
+
const mqtt1 = this.mqttConnected ? this.mqtt1.emit('publish', `State`, deviceData.Device) : false;
|
|
1291
|
+
}
|
|
1292
|
+
} catch (error) {
|
|
1293
|
+
this.emit('warn', `External integration start error: ${error}.`);
|
|
1294
|
+
};
|
|
1295
|
+
})
|
|
1296
|
+
.on('deviceInfo', (manufacturer, modelIndoor, modelOutdoor, serialNumber, firmwareAppVersion, hasHotWaterTank, hasZone2) => {
|
|
1297
|
+
if (!this.displayDeviceInfo) {
|
|
1298
|
+
return;
|
|
1299
|
+
}
|
|
1300
|
+
|
|
1301
|
+
if (!this.disableLogDeviceInfo) {
|
|
1302
|
+
this.emit('devInfo', `---- ${this.deviceTypeText}: ${this.deviceName} ----`);
|
|
1303
|
+
this.emit('devInfo', `Account: ${this.accountName}`);
|
|
1304
|
+
const indoor = modelIndoor ? this.emit('devInfo', `Indoor: ${modelIndoor}`) : false;
|
|
1305
|
+
const outdoor = modelOutdoor ? this.emit('devInfo', `Outdoor: ${modelOutdoor}`) : false
|
|
1306
|
+
this.emit('devInfo', `Serial: ${serialNumber}`)
|
|
1307
|
+
this.emit('devInfo', `Firmware: ${firmwareAppVersion}`);
|
|
1308
|
+
this.emit('devInfo', `Manufacturer: ${manufacturer}`);
|
|
1309
|
+
this.emit('devInfo', '----------------------------------');
|
|
1310
|
+
this.emit('devInfo', `Hot Water Tank: ${hasHotWaterTank ? 'Yes' : 'No'}`);
|
|
1311
|
+
this.emit('devInfo', `Zone 2: ${hasZone2 ? 'Yes' : 'No'}`);
|
|
1312
|
+
this.emit('devInfo', '----------------------------------');
|
|
1313
|
+
};
|
|
1314
|
+
|
|
1315
|
+
//accessory info
|
|
1316
|
+
this.manufacturer = manufacturer;
|
|
1317
|
+
this.model = modelIndoor ? modelIndoor : modelOutdoor ? modelOutdoor : `${this.deviceTypeText} ${this.deviceId}`;
|
|
1318
|
+
this.serialNumber = serialNumber;
|
|
1319
|
+
this.firmwareRevision = firmwareAppVersion;
|
|
1320
|
+
this.displayDeviceInfo = false;
|
|
1321
|
+
})
|
|
1322
|
+
.on('deviceState', async (deviceData) => {
|
|
1323
|
+
//presets
|
|
1324
|
+
const presetsOnServer = deviceData.Presets ?? [];
|
|
1325
|
+
|
|
1326
|
+
//device info
|
|
1327
|
+
const hasHotWaterTank = deviceData.Device.HasHotWaterTank ?? false;
|
|
1328
|
+
const hasZone2 = deviceData.Device.HasZone2 ?? false;
|
|
1329
|
+
const canHeat = deviceData.Device.CanHeat ?? false;
|
|
1330
|
+
const canCool = deviceData.Device.CanCool ?? false;
|
|
1331
|
+
const heatCoolModes = canHeat && canCool ? 0 : canHeat ? 1 : canCool ? 2 : 3;
|
|
1332
|
+
const temperatureIncrement = deviceData.Device.TemperatureIncrement ?? 1;
|
|
1333
|
+
const minSetTemperature = deviceData.Device.MinSetTemperature ?? 10;
|
|
1334
|
+
const maxSetTemperature = deviceData.Device.MaxSetTemperature ?? 30;
|
|
1335
|
+
const maxTankTemperature = deviceData.Device.MaxTankTemperature ?? 70
|
|
1336
|
+
|
|
1337
|
+
//zones
|
|
1338
|
+
const hotWater = hasHotWaterTank ? 1 : 0;
|
|
1339
|
+
const zone2 = hasZone2 ? 1 : 0;
|
|
1340
|
+
const zonesCount = 2 + hotWater + zone2;
|
|
1341
|
+
const caseHotWater = hasHotWaterTank ? 2 : -1;
|
|
1342
|
+
const caseZone2 = hasZone2 ? hasHotWaterTank ? 3 : 2 : -1;
|
|
1343
|
+
|
|
1344
|
+
//heat pump
|
|
1345
|
+
const heatPumpName = 'Heat Pump';
|
|
1346
|
+
const power = deviceData.Device.Power ?? false;
|
|
1347
|
+
const unitStatus = deviceData.Device.UnitStatus ?? 0;
|
|
1348
|
+
const operationMode = deviceData.Device.OperationMode;
|
|
1349
|
+
const outdoorTemperature = deviceData.Device.OutdoorTemperature;
|
|
1350
|
+
const holidayMode = deviceData.Device.HolidayMode ?? false;
|
|
1351
|
+
const flowTemperatureHeatPump = deviceData.Device.FlowTemperature;
|
|
1352
|
+
const returnTemperatureHeatPump = deviceData.Device.ReturnTemperature;
|
|
1353
|
+
|
|
1354
|
+
//zone 1
|
|
1355
|
+
const zone1Name = deviceData.Zone1Name ?? 'Zone 1';
|
|
1356
|
+
const roomTemperatureZone1 = deviceData.Device.RoomTemperatureZone1;
|
|
1357
|
+
const operationModeZone1 = deviceData.Device.OperationModeZone1;
|
|
1358
|
+
const setTemperatureZone1 = deviceData.Device.SetTemperatureZone1;
|
|
1359
|
+
const setHeatFlowTemperatureZone1 = deviceData.Device.SetHeatFlowTemperatureZone1;
|
|
1360
|
+
const setCoolFlowTemperatureZone1 = deviceData.Device.SetCoolFlowTemperatureZone1;
|
|
1361
|
+
const prohibitZone1 = deviceData.Device.ProhibitZone1 ?? false;
|
|
1362
|
+
const idleZone1 = deviceData.Device.IdleZone1 ?? false;
|
|
1363
|
+
const flowTemperatureZone1 = deviceData.Device.FlowTemperatureZone1;
|
|
1364
|
+
const returnTemperatureZone1 = deviceData.Device.ReturnTemperatureZone1;
|
|
1365
|
+
|
|
1366
|
+
//hot water
|
|
1367
|
+
const hotWaterName = 'Hot Water';
|
|
1368
|
+
const tankWaterTemperature = deviceData.Device.TankWaterTemperature;
|
|
1369
|
+
const setTankWaterTemperature = deviceData.Device.SetTankWaterTemperature;
|
|
1370
|
+
const forcedHotWaterMode = deviceData.Device.ForcedHotWaterMode ? 1 : 0;
|
|
1371
|
+
const ecoHotWater = deviceData.Device.EcoHotWater ?? false;
|
|
1372
|
+
const prohibitHotWater = deviceData.Device.ProhibitHotWater ?? false;
|
|
1373
|
+
const flowTemperatureWaterTank = deviceData.Device.FlowTemperatureBoiler;
|
|
1374
|
+
const returnTemperatureWaterTank = deviceData.Device.ReturnTemperatureBoiler;
|
|
1375
|
+
|
|
1376
|
+
//zone 2
|
|
1377
|
+
const zone2Name = deviceData.Zone2Name ?? 'Zone 2';
|
|
1378
|
+
const roomTemperatureZone2 = deviceData.Device.RoomTemperatureZone2;
|
|
1379
|
+
const operationModeZone2 = deviceData.Device.OperationModeZone2;
|
|
1380
|
+
const setTemperatureZone2 = deviceData.Device.SetTemperatureZone2;
|
|
1381
|
+
const setHeatFlowTemperatureZone2 = deviceData.Device.SetHeatFlowTemperatureZone2;
|
|
1382
|
+
const setCoolFlowTemperatureZone2 = deviceData.Device.SetCoolFlowTemperatureZone2;
|
|
1383
|
+
const prohibitZone2 = deviceData.Device.ProhibitZone2 ?? false;
|
|
1384
|
+
const idleZone2 = deviceData.Device.IdleZone2 ?? false;
|
|
1385
|
+
const flowTemperatureZone2 = deviceData.Device.FlowTemperatureZone2;
|
|
1386
|
+
const returnTemperatureZone2 = deviceData.Device.ReturnTemperatureZone2;
|
|
1387
|
+
|
|
1388
|
+
//accessory
|
|
1389
|
+
this.accessory.presets = presetsOnServer;
|
|
1390
|
+
this.accessory.power = power ? 1 : 0;
|
|
1391
|
+
this.accessory.unitStatus = unitStatus;
|
|
1392
|
+
this.accessory.idleZone1 = idleZone1;
|
|
1393
|
+
this.accessory.idleZone2 = idleZone2;
|
|
1394
|
+
this.accessory.temperatureIncrement = temperatureIncrement;
|
|
1395
|
+
this.accessory.hasHotWaterTank = hasHotWaterTank;
|
|
1396
|
+
this.accessory.hasZone2 = hasZone2;
|
|
1397
|
+
this.accessory.zonesCount = zonesCount;
|
|
1398
|
+
this.accessory.heatCoolModes = heatCoolModes;
|
|
1399
|
+
this.accessory.caseHotWater = caseHotWater;
|
|
1400
|
+
this.accessory.caseZone2 = caseZone2;
|
|
1401
|
+
|
|
1402
|
+
//default values
|
|
1403
|
+
let name = 'Heat Pump'
|
|
1404
|
+
let operationModeZone = 0;
|
|
1405
|
+
let currentOperationMode = 0;
|
|
1406
|
+
let targetOperationMode = 0;
|
|
1407
|
+
let roomTemperature = 20;
|
|
1408
|
+
let setTemperature = 20;
|
|
1409
|
+
let lockPhysicalControl = 0;
|
|
1410
|
+
let flowTemperature = 0;
|
|
1411
|
+
let returnTemperature = 0;
|
|
1412
|
+
let operationModeSetPropsMinValue = 0;
|
|
1413
|
+
let operationModeSetPropsMaxValue = 3;
|
|
1414
|
+
let operationModeSetPropsValidValues = [0];
|
|
1415
|
+
let temperatureSetPropsMinValue = -35;
|
|
1416
|
+
let temperatureSetPropsMaxValue = 100;
|
|
1417
|
+
|
|
1418
|
+
for (let i = 0; i < zonesCount; i++) {
|
|
1419
|
+
switch (this.displayMode) {
|
|
1420
|
+
case 1: //Heater Cooler
|
|
1421
|
+
switch (i) {
|
|
1422
|
+
case 0: //Heat Pump Operation Mode - IDLE, HOT WATER, HEATING ZONES, COOLING, HOT WATER STORAGE, FREEZE STAT, LEGIONELLA, HEATING ECO, MODE 1, MODE 2, MODE 3, HEATING UP /// Unit Status - HEAT, COOL
|
|
1423
|
+
name = heatPumpName;
|
|
1424
|
+
operationModeZone = operationMode;
|
|
1425
|
+
currentOperationMode = !power ? 0 : [1, 2, 2, 3, 2, 1, 1, 2, 1, 1, 1, 2][operationMode]; //INACTIVE, IDLE, HEATING, COOLING
|
|
1426
|
+
targetOperationMode = [1, 2][unitStatus]; //AUTO, HEAT, COOL
|
|
1427
|
+
roomTemperature = outdoorTemperature;
|
|
1428
|
+
setTemperature = outdoorTemperature;
|
|
1429
|
+
lockPhysicalControl = hasHotWaterTank && hasZone2 ? (prohibitZone1 && prohibitHotWater && prohibitZone2 ? 1 : 0) : hasHotWaterTank ? (prohibitZone1 && prohibitHotWater ? 1 : 0) : hasZone2 ? (prohibitZone1 && prohibitZone2 ? 1 : 0) : 0;
|
|
1430
|
+
flowTemperature = flowTemperatureHeatPump;
|
|
1431
|
+
returnTemperature = returnTemperatureHeatPump;
|
|
1441
1432
|
|
|
1442
|
-
|
|
1443
|
-
|
|
1444
|
-
|
|
1445
|
-
|
|
1446
|
-
|
|
1447
|
-
|
|
1448
|
-
|
|
1449
|
-
|
|
1450
|
-
|
|
1451
|
-
|
|
1452
|
-
|
|
1453
|
-
|
|
1454
|
-
|
|
1455
|
-
|
|
1456
|
-
|
|
1457
|
-
|
|
1458
|
-
|
|
1459
|
-
|
|
1460
|
-
|
|
1433
|
+
operationModeSetPropsMinValue = [1, 1, 2, 0][heatCoolModes];
|
|
1434
|
+
operationModeSetPropsMaxValue = [2, 1, 2, 0][heatCoolModes];
|
|
1435
|
+
operationModeSetPropsValidValues = [[1, 2], [1], [2], [0]][heatCoolModes];
|
|
1436
|
+
temperatureSetPropsMinValue = -35;
|
|
1437
|
+
temperatureSetPropsMaxValue = 100;
|
|
1438
|
+
break;
|
|
1439
|
+
case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
1440
|
+
name = zone1Name;
|
|
1441
|
+
operationModeZone = operationMode;
|
|
1442
|
+
currentOperationMode = !power ? 0 : idleZone1 ? 1 : [2, 2, 2, 3, 3, 2][operationModeZone1]; //INACTIVE, IDLE, HEATING, COOLING
|
|
1443
|
+
targetOperationMode = [1, 2, 0, 1, 2, 1][operationModeZone1]; //AUTO, HEAT, COOL
|
|
1444
|
+
|
|
1445
|
+
switch (operationModeZone1) {
|
|
1446
|
+
case 1: //HEAT FLOW
|
|
1447
|
+
setTemperature = setHeatFlowTemperatureZone1;
|
|
1448
|
+
roomTemperature = flowTemperatureZone1;
|
|
1449
|
+
temperatureSetPropsMinValue = 25;
|
|
1450
|
+
temperatureSetPropsMaxValue = 60;
|
|
1451
|
+
break;
|
|
1452
|
+
case 4: //COOL FLOW
|
|
1453
|
+
setTemperature = setCoolFlowTemperatureZone1;
|
|
1454
|
+
roomTemperature = flowTemperatureZone1;
|
|
1455
|
+
temperatureSetPropsMinValue = 16;
|
|
1456
|
+
temperatureSetPropsMaxValue = 31;
|
|
1457
|
+
break;
|
|
1458
|
+
default:
|
|
1459
|
+
setTemperature = setTemperatureZone1;
|
|
1460
|
+
roomTemperature = roomTemperatureZone1;
|
|
1461
|
+
temperatureSetPropsMinValue = 10;
|
|
1462
|
+
temperatureSetPropsMaxValue = 31;
|
|
1463
|
+
break
|
|
1464
|
+
};
|
|
1465
|
+
|
|
1466
|
+
lockPhysicalControl = prohibitZone1 ? 1 : 0;
|
|
1467
|
+
flowTemperature = flowTemperatureZone1;
|
|
1468
|
+
returnTemperature = returnTemperatureZone1;
|
|
1469
|
+
|
|
1470
|
+
operationModeSetPropsMinValue = [0, 0, 1, 0][heatCoolModes];
|
|
1471
|
+
operationModeSetPropsMaxValue = [2, 2, 2, 0][heatCoolModes];
|
|
1472
|
+
operationModeSetPropsValidValues = [[0, 1, 2], [0, 1, 2], [1, 2], [0]][heatCoolModes];
|
|
1473
|
+
break;
|
|
1474
|
+
case caseHotWater: //Hot Water - NORMAL, HEAT NOW
|
|
1475
|
+
name = hotWaterName;
|
|
1476
|
+
operationModeZone = operationMode;
|
|
1477
|
+
currentOperationMode = !power ? 0 : operationMode === 1 ? 2 : [1, 2][forcedHotWaterMode]; //INACTIVE, IDLE, HEATING, COOLING
|
|
1478
|
+
targetOperationMode = [0, 1][forcedHotWaterMode] //AUTO, HEAT, COOL
|
|
1479
|
+
roomTemperature = tankWaterTemperature;
|
|
1480
|
+
setTemperature = setTankWaterTemperature;
|
|
1481
|
+
lockPhysicalControl = prohibitHotWater ? 1 : 0;
|
|
1482
|
+
flowTemperature = flowTemperatureWaterTank;
|
|
1483
|
+
returnTemperature = returnTemperatureWaterTank;
|
|
1484
|
+
|
|
1485
|
+
operationModeSetPropsMinValue = 0;
|
|
1486
|
+
operationModeSetPropsMaxValue = 1;
|
|
1487
|
+
operationModeSetPropsValidValues = [0, 1];
|
|
1488
|
+
temperatureSetPropsMinValue = 0;
|
|
1489
|
+
temperatureSetPropsMaxValue = maxTankTemperature;
|
|
1490
|
+
break;
|
|
1491
|
+
case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
1492
|
+
name = zone2Name;
|
|
1493
|
+
operationModeZone = operationMode;
|
|
1494
|
+
currentOperationMode = !power ? 0 : idleZone2 ? 1 : [2, 2, 2, 3, 3, 2][operationModeZone2]; //INACTIVE, IDLE, HEATING, COOLING
|
|
1495
|
+
targetOperationMode = [1, 2, 0, 1, 2, 1][operationModeZone2]; //AUTO, HEAT, COOL
|
|
1496
|
+
|
|
1497
|
+
switch (operationModeZone2) {
|
|
1498
|
+
case 1: //HEAT FLOW
|
|
1499
|
+
setTemperature = setHeatFlowTemperatureZone2;
|
|
1500
|
+
roomTemperature = flowTemperatureZone2;
|
|
1501
|
+
temperatureSetPropsMinValue = 25;
|
|
1502
|
+
temperatureSetPropsMaxValue = 60;
|
|
1503
|
+
break;
|
|
1504
|
+
case 4: //COOL FLOW
|
|
1505
|
+
setTemperature = setCoolFlowTemperatureZone2;
|
|
1506
|
+
roomTemperature = flowTemperatureZone2;
|
|
1507
|
+
temperatureSetPropsMinValue = 16;
|
|
1508
|
+
temperatureSetPropsMaxValue = 31;
|
|
1509
|
+
break;
|
|
1510
|
+
default:
|
|
1511
|
+
setTemperature = setTemperatureZone2;
|
|
1512
|
+
roomTemperature = roomTemperatureZone2;
|
|
1513
|
+
temperatureSetPropsMinValue = 10;
|
|
1514
|
+
temperatureSetPropsMaxValue = 31;
|
|
1515
|
+
break
|
|
1516
|
+
};
|
|
1517
|
+
|
|
1518
|
+
lockPhysicalControl = prohibitZone2 ? 1 : 0;
|
|
1519
|
+
flowTemperature = flowTemperatureZone2;
|
|
1520
|
+
returnTemperature = returnTemperatureZone2;
|
|
1521
|
+
|
|
1522
|
+
operationModeSetPropsMinValue = [0, 0, 1, 0][heatCoolModes];
|
|
1523
|
+
operationModeSetPropsMaxValue = [2, 2, 2, 0][heatCoolModes];
|
|
1524
|
+
operationModeSetPropsValidValues = [[0, 1, 2], [0, 1, 2], [1, 2], [0]][heatCoolModes];
|
|
1525
|
+
break;
|
|
1526
|
+
default: //unknown zone detected
|
|
1527
|
+
this.emit('message', `Unknown zone: ${i} detected.`);
|
|
1528
|
+
break;
|
|
1461
1529
|
};
|
|
1462
|
-
});
|
|
1463
|
-
this.melCloudServices.push(melCloudServiceT);
|
|
1464
|
-
accessory.addService(melCloudServiceT);
|
|
1465
|
-
break;
|
|
1466
|
-
};
|
|
1467
1530
|
|
|
1468
|
-
|
|
1469
|
-
|
|
1470
|
-
|
|
1471
|
-
|
|
1472
|
-
|
|
1473
|
-
|
|
1474
|
-
|
|
1475
|
-
|
|
1476
|
-
|
|
1477
|
-
|
|
1478
|
-
|
|
1479
|
-
|
|
1480
|
-
|
|
1481
|
-
|
|
1482
|
-
|
|
1483
|
-
|
|
1484
|
-
|
|
1485
|
-
|
|
1486
|
-
|
|
1487
|
-
|
|
1531
|
+
//update characteristics
|
|
1532
|
+
if (this.melCloudServices) {
|
|
1533
|
+
this.melCloudServices[i]
|
|
1534
|
+
.updateCharacteristic(Characteristic.Active, power)
|
|
1535
|
+
.updateCharacteristic(Characteristic.CurrentHeaterCoolerState, currentOperationMode)
|
|
1536
|
+
.updateCharacteristic(Characteristic.TargetHeaterCoolerState, targetOperationMode)
|
|
1537
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
1538
|
+
.updateCharacteristic(Characteristic.LockPhysicalControls, lockPhysicalControl)
|
|
1539
|
+
.updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
|
|
1540
|
+
const updateDefCool = heatCoolModes === 0 || heatCoolModes === 2 ? this.melCloudServices[i].updateCharacteristic(Characteristic.CoolingThresholdTemperature, setTemperature) : false;
|
|
1541
|
+
const updateDefHeat = heatCoolModes === 0 || heatCoolModes === 1 ? this.melCloudServices[i].updateCharacteristic(Characteristic.HeatingThresholdTemperature, setTemperature) : false;
|
|
1542
|
+
}
|
|
1543
|
+
break;
|
|
1544
|
+
case 2: //Thermostat
|
|
1545
|
+
switch (i) {
|
|
1546
|
+
case 0: //Heat Pump Operation Mode - IDLE, HOT WATER, HEATING ZONES, COOLING, HOT WATER STORAGE, FREEZE STAT, LEGIONELLA, HEATING ECO, MODE 1, MODE 2, MODE 3, HEATING UP /// Unit Status - HEAT, COOL
|
|
1547
|
+
name = heatPumpName;
|
|
1548
|
+
operationModeZone = operationMode;
|
|
1549
|
+
currentOperationMode = !power ? 0 : [0, 1, 1, 2, 1, 0, 0, 1, 0, 0, 0, 1][operationMode]; //OFF, HEAT, COOL
|
|
1550
|
+
targetOperationMode = !power ? 0 : [1, 2][unitStatus]; //OFF, HEAT, COOL, AUTO
|
|
1551
|
+
roomTemperature = outdoorTemperature;
|
|
1552
|
+
setTemperature = outdoorTemperature;
|
|
1553
|
+
|
|
1554
|
+
operationModeSetPropsMinValue = [0, 0, 0, 0][heatCoolModes];
|
|
1555
|
+
operationModeSetPropsMaxValue = [2, 1, 2, 0][heatCoolModes];
|
|
1556
|
+
operationModeSetPropsValidValues = [[0, 1, 2], [0, 1], [0, 2], [0]][heatCoolModes];
|
|
1557
|
+
temperatureSetPropsMinValue = 10;
|
|
1558
|
+
temperatureSetPropsMaxValue = 70;
|
|
1559
|
+
break;
|
|
1560
|
+
case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
1561
|
+
name = zone1Name;
|
|
1562
|
+
operationModeZone = operationMode;
|
|
1563
|
+
currentOperationMode = !power ? 0 : idleZone1 ? 0 : [1, 1, 1, 2, 2, 1][operationModeZone1]; //OFF, HEAT, COOL
|
|
1564
|
+
targetOperationMode = [1, 2, 3, 1, 2, 1][operationModeZone1]; //OFF, HEAT, COOL, AUTO
|
|
1565
|
+
|
|
1566
|
+
switch (operationModeZone1) {
|
|
1567
|
+
case 1: //HEAT FLOW
|
|
1568
|
+
setTemperature = setHeatFlowTemperatureZone1;
|
|
1569
|
+
roomTemperature = flowTemperatureZone1;
|
|
1570
|
+
temperatureSetPropsMinValue = 25;
|
|
1571
|
+
temperatureSetPropsMaxValue = 60;
|
|
1572
|
+
break;
|
|
1573
|
+
case 4: //COOL FLOW
|
|
1574
|
+
setTemperature = setCoolFlowTemperatureZone1;
|
|
1575
|
+
roomTemperature = flowTemperatureZone1;
|
|
1576
|
+
temperatureSetPropsMinValue = 16;
|
|
1577
|
+
temperatureSetPropsMaxValue = 31;
|
|
1578
|
+
break;
|
|
1579
|
+
default:
|
|
1580
|
+
setTemperature = setTemperatureZone1;
|
|
1581
|
+
roomTemperature = roomTemperatureZone1;
|
|
1582
|
+
temperatureSetPropsMinValue = 10;
|
|
1583
|
+
temperatureSetPropsMaxValue = 31;
|
|
1584
|
+
break
|
|
1585
|
+
};
|
|
1488
1586
|
|
|
1489
|
-
|
|
1490
|
-
|
|
1491
|
-
|
|
1492
|
-
|
|
1493
|
-
|
|
1494
|
-
|
|
1495
|
-
|
|
1496
|
-
|
|
1497
|
-
|
|
1498
|
-
|
|
1499
|
-
|
|
1500
|
-
.onGet(async () => {
|
|
1501
|
-
const state = this.accessory.zones[i].flowTemperature;
|
|
1502
|
-
return state;
|
|
1503
|
-
})
|
|
1504
|
-
accessory.addService(this.flowTemperatureSensorService);
|
|
1587
|
+
operationModeSetPropsMinValue = [1, 1, 1, 0][heatCoolModes];
|
|
1588
|
+
operationModeSetPropsMaxValue = [3, 3, 2, 0][heatCoolModes];
|
|
1589
|
+
operationModeSetPropsValidValues = [[1, 2, 3], [1, 2, 3], [1, 2], [0]][heatCoolModes];
|
|
1590
|
+
break;
|
|
1591
|
+
case caseHotWater: //Hot Water - NORMAL, HEAT NOW
|
|
1592
|
+
name = hotWaterName;
|
|
1593
|
+
operationModeZone = operationMode;
|
|
1594
|
+
currentOperationMode = !power ? 0 : operationMode === 1 ? 1 : [0, 1][forcedHotWaterMode]; //OFF, HEAT, COOL
|
|
1595
|
+
targetOperationMode = [3, 1][forcedHotWaterMode] //OFF, HEAT, COOL, AUTO
|
|
1596
|
+
roomTemperature = tankWaterTemperature;
|
|
1597
|
+
setTemperature = setTankWaterTemperature;
|
|
1505
1598
|
|
|
1506
|
-
|
|
1507
|
-
|
|
1508
|
-
|
|
1509
|
-
|
|
1510
|
-
|
|
1511
|
-
|
|
1512
|
-
|
|
1513
|
-
|
|
1514
|
-
|
|
1515
|
-
|
|
1516
|
-
|
|
1517
|
-
})
|
|
1518
|
-
.onGet(async () => {
|
|
1519
|
-
const state = this.accessory.zones[i].returnTemperature;
|
|
1520
|
-
return state;
|
|
1521
|
-
})
|
|
1522
|
-
accessory.addService(this.returnTemperatureSensorService);
|
|
1523
|
-
};
|
|
1524
|
-
break;
|
|
1525
|
-
case 1: //Zone 1
|
|
1526
|
-
if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
|
|
1527
|
-
const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
|
|
1528
|
-
this.roomTemperatureZone1SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
|
|
1529
|
-
this.roomTemperatureZone1SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
1530
|
-
this.roomTemperatureZone1SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
|
|
1531
|
-
this.roomTemperatureZone1SensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
1532
|
-
.setProps({
|
|
1533
|
-
minValue: -35,
|
|
1534
|
-
maxValue: 150,
|
|
1535
|
-
minStep: 0.5
|
|
1536
|
-
})
|
|
1537
|
-
.onGet(async () => {
|
|
1538
|
-
const state = this.accessory.zones[i].roomTemperature;
|
|
1539
|
-
return state;
|
|
1540
|
-
})
|
|
1541
|
-
accessory.addService(this.roomTemperatureZone1SensorService);
|
|
1542
|
-
};
|
|
1599
|
+
operationModeSetPropsMinValue = 1;
|
|
1600
|
+
operationModeSetPropsMaxValue = 3;
|
|
1601
|
+
operationModeSetPropsValidValues = [1, 3];
|
|
1602
|
+
temperatureSetPropsMinValue = 0;
|
|
1603
|
+
temperatureSetPropsMaxValue = 60;
|
|
1604
|
+
break;
|
|
1605
|
+
case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
1606
|
+
name = zone2Name;
|
|
1607
|
+
operationModeZone = operationMode;
|
|
1608
|
+
currentOperationMode = !power ? 0 : idleZone2 ? 0 : [1, 1, 1, 2, 2, 1][operationModeZone2]; //OFF, HEAT, COOL
|
|
1609
|
+
targetOperationMode = [1, 2, 3, 1, 2, 1][operationModeZone2]; //OFF, HEAT, COOL, AUTO
|
|
1543
1610
|
|
|
1544
|
-
|
|
1545
|
-
|
|
1546
|
-
|
|
1547
|
-
|
|
1548
|
-
|
|
1549
|
-
|
|
1550
|
-
|
|
1551
|
-
|
|
1552
|
-
|
|
1553
|
-
|
|
1554
|
-
|
|
1555
|
-
|
|
1556
|
-
|
|
1557
|
-
|
|
1558
|
-
|
|
1559
|
-
|
|
1560
|
-
|
|
1611
|
+
switch (operationModeZone2) {
|
|
1612
|
+
case 1: //HEAT FLOW
|
|
1613
|
+
setTemperature = setHeatFlowTemperatureZone2;
|
|
1614
|
+
roomTemperature = flowTemperatureZone2;
|
|
1615
|
+
temperatureSetPropsMinValue = 25;
|
|
1616
|
+
temperatureSetPropsMaxValue = 60;
|
|
1617
|
+
break;
|
|
1618
|
+
case 4: //COOL FLOW
|
|
1619
|
+
setTemperature = setCoolFlowTemperatureZone2;
|
|
1620
|
+
roomTemperature = flowTemperatureZone2;
|
|
1621
|
+
temperatureSetPropsMinValue = 16;
|
|
1622
|
+
temperatureSetPropsMaxValue = 31;
|
|
1623
|
+
break;
|
|
1624
|
+
default:
|
|
1625
|
+
setTemperature = setTemperatureZone2;
|
|
1626
|
+
roomTemperature = roomTemperatureZone2;
|
|
1627
|
+
temperatureSetPropsMinValue = 10;
|
|
1628
|
+
temperatureSetPropsMaxValue = 31;
|
|
1629
|
+
break
|
|
1630
|
+
};
|
|
1561
1631
|
|
|
1562
|
-
|
|
1563
|
-
|
|
1564
|
-
|
|
1565
|
-
|
|
1566
|
-
|
|
1567
|
-
|
|
1568
|
-
|
|
1569
|
-
|
|
1570
|
-
maxValue: 150,
|
|
1571
|
-
minStep: 0.5
|
|
1572
|
-
})
|
|
1573
|
-
.onGet(async () => {
|
|
1574
|
-
const state = this.accessory.zones[i].returnTemperature;
|
|
1575
|
-
return state;
|
|
1576
|
-
})
|
|
1577
|
-
accessory.addService(this.returnTemperatureZone1SensorService);
|
|
1578
|
-
};
|
|
1579
|
-
break;
|
|
1580
|
-
case caseHotWater: //Hot Water
|
|
1581
|
-
if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
|
|
1582
|
-
const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
|
|
1583
|
-
this.roomTemperatureWaterTankSensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
|
|
1584
|
-
this.roomTemperatureWaterTankSensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
1585
|
-
this.roomTemperatureWaterTankSensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
|
|
1586
|
-
this.roomTemperatureWaterTankSensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
1587
|
-
.setProps({
|
|
1588
|
-
minValue: -35,
|
|
1589
|
-
maxValue: 150,
|
|
1590
|
-
minStep: 0.5
|
|
1591
|
-
})
|
|
1592
|
-
.onGet(async () => {
|
|
1593
|
-
const state = this.accessory.zones[i].roomTemperature;
|
|
1594
|
-
return state;
|
|
1595
|
-
})
|
|
1596
|
-
accessory.addService(this.roomTemperatureWaterTankSensorService);
|
|
1597
|
-
};
|
|
1632
|
+
operationModeSetPropsMinValue = [1, 1, 1, 0][heatCoolModes];
|
|
1633
|
+
operationModeSetPropsMaxValue = [3, 3, 2, 0][heatCoolModes];
|
|
1634
|
+
operationModeSetPropsValidValues = [[1, 2, 3], [1, 2, 3], [1, 2], [0]][heatCoolModes];
|
|
1635
|
+
break;
|
|
1636
|
+
default: //unknown zone detected
|
|
1637
|
+
this.emit('message', `Unknown zone: ${i} detected.`);
|
|
1638
|
+
break;
|
|
1639
|
+
};
|
|
1598
1640
|
|
|
1599
|
-
|
|
1600
|
-
|
|
1601
|
-
|
|
1602
|
-
|
|
1603
|
-
|
|
1604
|
-
|
|
1605
|
-
|
|
1606
|
-
|
|
1607
|
-
|
|
1608
|
-
|
|
1609
|
-
})
|
|
1610
|
-
.onGet(async () => {
|
|
1611
|
-
const state = this.accessory.zones[i].flowTemperature;
|
|
1612
|
-
return state;
|
|
1613
|
-
})
|
|
1614
|
-
accessory.addService(this.flowTemperatureWaterTankSensorService);
|
|
1641
|
+
//update characteristics
|
|
1642
|
+
if (this.melCloudServices) {
|
|
1643
|
+
this.melCloudServices[i]
|
|
1644
|
+
.updateCharacteristic(Characteristic.CurrentHeatingCoolingState, currentOperationMode)
|
|
1645
|
+
.updateCharacteristic(Characteristic.TargetHeatingCoolingState, targetOperationMode)
|
|
1646
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
1647
|
+
.updateCharacteristic(Characteristic.TargetTemperature, setTemperature)
|
|
1648
|
+
.updateCharacteristic(Characteristic.TemperatureDisplayUnits, this.accessory.useFahrenheit);
|
|
1649
|
+
}
|
|
1650
|
+
break;
|
|
1615
1651
|
};
|
|
1616
1652
|
|
|
1617
|
-
|
|
1618
|
-
|
|
1619
|
-
|
|
1620
|
-
|
|
1621
|
-
|
|
1622
|
-
|
|
1623
|
-
|
|
1624
|
-
|
|
1625
|
-
|
|
1626
|
-
|
|
1627
|
-
|
|
1628
|
-
|
|
1629
|
-
const state = this.accessory.zones[i].returnTemperature;
|
|
1630
|
-
return state;
|
|
1631
|
-
})
|
|
1632
|
-
accessory.addService(this.returnTemperatureWaterTankSensorService);
|
|
1633
|
-
};
|
|
1634
|
-
break;
|
|
1635
|
-
case caseZone2: //Zone 2
|
|
1636
|
-
if (temperatureSensor && this.accessory.zones[i].roomTemperature !== null) {
|
|
1637
|
-
const debug = this.enableDebugMode ? this.emit('debug', `${zoneName}, Prepare temperature sensor service`) : false;
|
|
1638
|
-
this.roomTemperatureZone2SensorService = new Service.TemperatureSensor(`${serviceName}`, `${zoneName} Temperature Sensor ${deviceId} ${i}`);
|
|
1639
|
-
this.roomTemperatureZone2SensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
1640
|
-
this.roomTemperatureZone2SensorService.setCharacteristic(Characteristic.ConfiguredName, `${accessoryName} ${zoneName}`);
|
|
1641
|
-
this.roomTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
1642
|
-
.setProps({
|
|
1643
|
-
minValue: -35,
|
|
1644
|
-
maxValue: 150,
|
|
1645
|
-
minStep: 0.5
|
|
1646
|
-
})
|
|
1647
|
-
.onGet(async () => {
|
|
1648
|
-
const state = this.accessory.zones[i].roomTemperature;
|
|
1649
|
-
return state;
|
|
1650
|
-
})
|
|
1651
|
-
accessory.addService(this.roomTemperatureZone2SensorService);
|
|
1652
|
-
};
|
|
1653
|
+
//push value to arrays
|
|
1654
|
+
this.accessory.zones[i].name = name;
|
|
1655
|
+
this.accessory.zones[i].operationMode = operationModeZone;
|
|
1656
|
+
this.accessory.zones[i].currentOperationMode = currentOperationMode;
|
|
1657
|
+
this.accessory.zones[i].targetOperationMode = targetOperationMode;
|
|
1658
|
+
this.accessory.zones[i].roomTemperature = roomTemperature;
|
|
1659
|
+
this.accessory.zones[i].setTemperature = setTemperature;
|
|
1660
|
+
this.accessory.zones[i].lockPhysicalControl = lockPhysicalControl;
|
|
1661
|
+
this.accessory.zones[i].flowTemperature = flowTemperature;
|
|
1662
|
+
this.accessory.zones[i].returnTemperature = returnTemperature;
|
|
1663
|
+
this.accessory.zones[i].temperaturesSetPropsMinValue = temperatureSetPropsMinValue;
|
|
1664
|
+
this.accessory.zones[i].temperaturesSetPropsMaxValue = temperatureSetPropsMaxValue;
|
|
1653
1665
|
|
|
1654
|
-
|
|
1655
|
-
|
|
1656
|
-
this.
|
|
1657
|
-
this.
|
|
1658
|
-
this.
|
|
1659
|
-
this.flowTemperatureZone2SensorService.getCharacteristic(Characteristic.CurrentTemperature)
|
|
1660
|
-
.setProps({
|
|
1661
|
-
minValue: -35,
|
|
1662
|
-
maxValue: 150,
|
|
1663
|
-
minStep: 0.5
|
|
1664
|
-
})
|
|
1665
|
-
.onGet(async () => {
|
|
1666
|
-
const state = this.accessory.zones[i].flowTemperature;
|
|
1667
|
-
return state;
|
|
1668
|
-
})
|
|
1669
|
-
accessory.addService(this.flowTemperatureZone2SensorService);
|
|
1666
|
+
//only on first run
|
|
1667
|
+
if (this.startPrepareAccessory) {
|
|
1668
|
+
this.accessory.zones[i].operationModesSetPropsMinValue = operationModeSetPropsMinValue;
|
|
1669
|
+
this.accessory.zones[i].operationModesSetPropsMaxValue = operationModeSetPropsMaxValue;
|
|
1670
|
+
this.accessory.zones[i].operationModesSetPropsValidValues = operationModeSetPropsValidValues;
|
|
1670
1671
|
};
|
|
1671
1672
|
|
|
1672
|
-
|
|
1673
|
-
|
|
1674
|
-
|
|
1675
|
-
|
|
1676
|
-
|
|
1677
|
-
|
|
1678
|
-
|
|
1679
|
-
minValue: -35,
|
|
1680
|
-
maxValue: 150,
|
|
1681
|
-
minStep: 0.5
|
|
1682
|
-
})
|
|
1683
|
-
.onGet(async () => {
|
|
1684
|
-
const state = this.accessory.zones[i].returnTemperature;
|
|
1685
|
-
return state;
|
|
1686
|
-
})
|
|
1687
|
-
accessory.addService(this.returnTemperatureZone2SensorService);
|
|
1688
|
-
};
|
|
1689
|
-
break;
|
|
1690
|
-
};
|
|
1691
|
-
};
|
|
1673
|
+
//update temperature sensors
|
|
1674
|
+
switch (i) {
|
|
1675
|
+
case 0: //Heat Pump
|
|
1676
|
+
if (this.roomTemperatureSensorService) {
|
|
1677
|
+
this.roomTemperatureSensorService
|
|
1678
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
1679
|
+
};
|
|
1692
1680
|
|
|
1693
|
-
|
|
1694
|
-
|
|
1695
|
-
|
|
1696
|
-
|
|
1681
|
+
if (this.flowTemperatureSensorService) {
|
|
1682
|
+
this.flowTemperatureSensorService
|
|
1683
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, flowTemperature)
|
|
1684
|
+
};
|
|
1697
1685
|
|
|
1698
|
-
|
|
1699
|
-
|
|
1700
|
-
|
|
1686
|
+
if (this.returnTemperatureSensorService) {
|
|
1687
|
+
this.returnTemperatureSensorService
|
|
1688
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, returnTemperature)
|
|
1689
|
+
};
|
|
1690
|
+
break;
|
|
1691
|
+
case 1: //Zone 1
|
|
1692
|
+
if (this.roomTemperatureZone1SensorService) {
|
|
1693
|
+
this.roomTemperatureZone1SensorService
|
|
1694
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
1695
|
+
};
|
|
1701
1696
|
|
|
1702
|
-
|
|
1703
|
-
|
|
1697
|
+
if (this.flowTemperatureZone1SensorService) {
|
|
1698
|
+
this.flowTemperatureZone1SensorService
|
|
1699
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, flowTemperatureZone1)
|
|
1700
|
+
};
|
|
1704
1701
|
|
|
1705
|
-
|
|
1706
|
-
|
|
1702
|
+
if (this.returnTemperatureZone1SensorService) {
|
|
1703
|
+
this.returnTemperatureZone1SensorService
|
|
1704
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, returnTemperatureZone1)
|
|
1705
|
+
};
|
|
1706
|
+
break;
|
|
1707
|
+
case caseHotWater: //Hot Water
|
|
1708
|
+
if (this.roomTemperatureWaterTankSensorService) {
|
|
1709
|
+
this.roomTemperatureWaterTankSensorService
|
|
1710
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
1711
|
+
};
|
|
1707
1712
|
|
|
1708
|
-
|
|
1709
|
-
|
|
1710
|
-
|
|
1711
|
-
const presetService = new serviceType(serviceName, `Preset ${deviceId} ${i}`);
|
|
1712
|
-
presetService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
1713
|
-
presetService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
|
|
1714
|
-
presetService.getCharacteristic(characteristicType)
|
|
1715
|
-
.onGet(async () => {
|
|
1716
|
-
const state = preset.state;
|
|
1717
|
-
return state;
|
|
1718
|
-
})
|
|
1719
|
-
.onSet(async (state) => {
|
|
1720
|
-
try {
|
|
1721
|
-
switch (state) {
|
|
1722
|
-
case true:
|
|
1723
|
-
preset.previousSettings = deviceData.Device;
|
|
1724
|
-
deviceData.Device.Power = presetData.Power;
|
|
1725
|
-
deviceData.Device.EcoHotWater = presetData.EcoHotWater;
|
|
1726
|
-
deviceData.Device.OperationModeZone1 = presetData.OperationModeZone1;
|
|
1727
|
-
deviceData.Device.OperationModeZone2 = presetData.OperationModeZone2;
|
|
1728
|
-
deviceData.Device.SetTankWaterTemperature = presetData.SetTankWaterTemperature;
|
|
1729
|
-
deviceData.Device.SetTemperatureZone1 = presetData.SetTemperatureZone1;
|
|
1730
|
-
deviceData.Device.SetTemperatureZone2 = presetData.SetTemperatureZone2;
|
|
1731
|
-
deviceData.Device.ForcedHotWaterMode = presetData.ForcedHotWaterMode;
|
|
1732
|
-
deviceData.Device.SetHeatFlowTemperatureZone1 = presetData.SetHeatFlowTemperatureZone1;
|
|
1733
|
-
deviceData.Device.SetHeatFlowTemperatureZone2 = presetData.SetHeatFlowTemperatureZone2;
|
|
1734
|
-
deviceData.Device.SetCoolFlowTemperatureZone1 = presetData.SetCoolFlowTemperatureZone1;
|
|
1735
|
-
deviceData.Device.SetCoolFlowTemperatureZone2 = presetData.SetCoolFlowTemperatureZone2;
|
|
1736
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
1737
|
-
break;
|
|
1738
|
-
case false:
|
|
1739
|
-
deviceData.Device.Power = preset.previousSettings.Power;
|
|
1740
|
-
deviceData.Device.EcoHotWater = preset.previousSettings.EcoHotWater;
|
|
1741
|
-
deviceData.Device.OperationModeZone1 = preset.previousSettings.OperationModeZone1;
|
|
1742
|
-
deviceData.Device.OperationModeZone2 = preset.previousSettings.OperationModeZone2;
|
|
1743
|
-
deviceData.Device.SetTankWaterTemperature = preset.previousSettings.SetTankWaterTemperature;
|
|
1744
|
-
deviceData.Device.SetTemperatureZone1 = preset.previousSettings.SetTemperatureZone1;
|
|
1745
|
-
deviceData.Device.SetTemperatureZone2 = preset.previousSettings.SetTemperatureZone2;
|
|
1746
|
-
deviceData.Device.ForcedHotWaterMode = preset.previousSettings.ForcedHotWaterMode;
|
|
1747
|
-
deviceData.Device.SetHeatFlowTemperatureZone1 = preset.previousSettings.SetHeatFlowTemperatureZone1;
|
|
1748
|
-
deviceData.Device.SetHeatFlowTemperatureZone2 = preset.previousSettings.SetHeatFlowTemperatureZone2;
|
|
1749
|
-
deviceData.Device.SetCoolFlowTemperatureZone1 = preset.previousSettings.SetCoolFlowTemperatureZone1;
|
|
1750
|
-
deviceData.Device.SetCoolFlowTemperatureZone2 = preset.previousSettings.SetCoolFlowTemperatureZone2;
|
|
1751
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
1752
|
-
break;
|
|
1713
|
+
if (this.flowTemperatureWaterTankSensorService) {
|
|
1714
|
+
this.flowTemperatureWaterTankSensorService
|
|
1715
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, flowTemperatureWaterTank)
|
|
1753
1716
|
};
|
|
1754
1717
|
|
|
1755
|
-
|
|
1756
|
-
|
|
1757
|
-
|
|
1758
|
-
|
|
1718
|
+
if (this.returnTemperatureWaterTankSensorService) {
|
|
1719
|
+
this.returnTemperatureWaterTankSensorService
|
|
1720
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, returnTemperatureWaterTank)
|
|
1721
|
+
};
|
|
1722
|
+
break;
|
|
1723
|
+
case caseZone2: //Zone 2
|
|
1724
|
+
if (this.roomTemperatureZone2SensorService) {
|
|
1725
|
+
this.roomTemperatureZone2SensorService
|
|
1726
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)
|
|
1727
|
+
};
|
|
1728
|
+
|
|
1729
|
+
if (this.flowTemperatureZone2SensorService) {
|
|
1730
|
+
this.flowTemperatureZone2SensorService
|
|
1731
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, flowTemperatureZone2)
|
|
1732
|
+
};
|
|
1733
|
+
|
|
1734
|
+
if (this.returnTemperatureZone2SensorService) {
|
|
1735
|
+
this.returnTemperatureZone2SensorService
|
|
1736
|
+
.updateCharacteristic(Characteristic.CurrentTemperature, returnTemperatureZone2)
|
|
1737
|
+
};
|
|
1738
|
+
break;
|
|
1739
|
+
};
|
|
1740
|
+
|
|
1741
|
+
//log current state
|
|
1742
|
+
if (!this.disableLogInfo) {
|
|
1743
|
+
let operationModeText = '';
|
|
1744
|
+
switch (i) {
|
|
1745
|
+
case 0: //Heat Pump - HEAT, COOL, OFF
|
|
1746
|
+
this.emit('message', `${heatPumpName}, Power: ${power ? 'ON' : 'OFF'}`)
|
|
1747
|
+
this.emit('message', `${heatPumpName}, Operation mode: ${HeatPump.System[unitStatus]}`);
|
|
1748
|
+
this.emit('message', `${heatPumpName},'Outdoor temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
|
|
1749
|
+
const info = flowTemperature !== null ? this.emit('message', `${heatPumpName}, Flow temperature: ${flowTemperature}${this.accessory.temperatureUnit}`) : false;
|
|
1750
|
+
const info1 = returnTemperature !== null ? this.emit('message', `${heatPumpName}, Return temperature: ${returnTemperature}${this.accessory.temperatureUnit}`) : false;
|
|
1751
|
+
this.emit('message', `${heatPumpName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
|
|
1752
|
+
this.emit('message', `${heatPumpName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
|
|
1753
|
+
break;
|
|
1754
|
+
case 1: //Zone 1 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
1755
|
+
operationModeText = idleZone1 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone1];
|
|
1756
|
+
this.emit('message', `${zone1Name}, Operation mode: ${operationModeText}`);
|
|
1757
|
+
this.emit('message', `${zone1Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
|
|
1758
|
+
this.emit('message', `${zone1Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
|
|
1759
|
+
const info2 = flowTemperatureZone1 !== null ? this.emit('message', `${zone1Name}, Flow temperature: ${flowTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
|
|
1760
|
+
const info3 = returnTemperatureZone1 !== null ? this.emit('message', `${zone1Name}, Return temperature: ${returnTemperatureZone1}${this.accessory.temperatureUnit}`) : false;
|
|
1761
|
+
this.emit('message', `${zone1Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
|
|
1762
|
+
this.emit('message', `${zone1Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
|
|
1763
|
+
break;
|
|
1764
|
+
case caseHotWater: //Hot Water - AUTO, HEAT NOW
|
|
1765
|
+
operationModeText = operationMode === 1 ? HeatPump.ForceDhw[1] : HeatPump.ForceDhw[forcedHotWaterMode ? 1 : 0];
|
|
1766
|
+
this.emit('message', `${hotWaterName}, Operation mode: ${operationModeText}`);
|
|
1767
|
+
this.emit('message', `${hotWaterName}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
|
|
1768
|
+
this.emit('message', `${hotWaterName}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
|
|
1769
|
+
const info4 = flowTemperatureWaterTank !== null ? this.emit('message', `${hotWaterName}, Flow temperature: ${flowTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
|
|
1770
|
+
const info5 = returnTemperatureWaterTank !== null ? this.emit('message', `${hotWaterName}, Return temperature: ${returnTemperatureWaterTank}${this.accessory.temperatureUnit}`) : false;
|
|
1771
|
+
this.emit('message', `${hotWaterName}, Temperature display unit: ${this.accessory.temperatureUnit}`);
|
|
1772
|
+
this.emit('message', `${hotWaterName}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
|
|
1773
|
+
break;
|
|
1774
|
+
case caseZone2: //Zone 2 - HEAT THERMOSTAT, HEAT FLOW, HEAT CURVE, COOL THERMOSTAT, COOL FLOW, FLOOR DRY UP
|
|
1775
|
+
operationModeText = idleZone2 ? HeatPump.ZoneOperation[6] : HeatPump.ZoneOperation[operationModeZone2];
|
|
1776
|
+
this.emit('message', `${zone2Name}, Operation mode: ${operationModeText}`);
|
|
1777
|
+
this.emit('message', `${zone2Name}, Temperature: ${roomTemperature}${this.accessory.temperatureUnit}`);
|
|
1778
|
+
this.emit('message', `${zone2Name}, Target temperature: ${setTemperature}${this.accessory.temperatureUnit}`)
|
|
1779
|
+
const info6 = flowTemperatureZone2 !== null ? this.emit('message', `${zone2Name}, Flow temperature: ${flowTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
|
|
1780
|
+
const info7 = roomTemperatureZone2 !== null ? this.emit('message', `${zone2Name}, Return temperature: ${roomTemperatureZone2}${this.accessory.temperatureUnit}`) : false;
|
|
1781
|
+
this.emit('message', `${zone2Name}, Temperature display unit: ${this.accessory.temperatureUnit}`);
|
|
1782
|
+
this.emit('message', `${zone2Name}, Lock physical controls: ${lockPhysicalControl ? 'LOCKED' : 'UNLOCKED'}`);
|
|
1783
|
+
break;
|
|
1784
|
+
};
|
|
1785
|
+
};
|
|
1786
|
+
};
|
|
1787
|
+
|
|
1788
|
+
//update presets state
|
|
1789
|
+
if (this.presetsConfigured.length > 0) {
|
|
1790
|
+
for (let i = 0; i < this.presetsConfigured.length; i++) {
|
|
1791
|
+
const preset = this.presetsConfigured[i];
|
|
1792
|
+
const presetData = presetsOnServer.find(p => p.ID === preset.Id);
|
|
1793
|
+
|
|
1794
|
+
preset.state = presetData ? (presetData.Power === power
|
|
1795
|
+
&& presetData.EcoHotWater === ecoHotWater
|
|
1796
|
+
&& presetData.OperationModeZone1 === operationModeZone1
|
|
1797
|
+
&& presetData.OperationModeZone2 === operationModeZone2
|
|
1798
|
+
&& presetData.SetTankWaterTemperature === setTankWaterTemperature
|
|
1799
|
+
&& presetData.SetTemperatureZone1 === setTemperatureZone1
|
|
1800
|
+
&& presetData.SetTemperatureZone2 === setTemperatureZone2
|
|
1801
|
+
&& presetData.ForcedHotWaterMode === forcedHotWaterMode
|
|
1802
|
+
&& presetData.SetHeatFlowTemperatureZone1 === setHeatFlowTemperatureZone1
|
|
1803
|
+
&& presetData.SetHeatFlowTemperatureZone2 === setHeatFlowTemperatureZone2
|
|
1804
|
+
&& presetData.SetCoolFlowTemperatureZone1 === setCoolFlowTemperatureZone1
|
|
1805
|
+
&& presetData.SetCoolFlowTemperatureZone2 === setCoolFlowTemperatureZone2) : false;
|
|
1806
|
+
|
|
1807
|
+
if (this.presetsServices) {
|
|
1808
|
+
const characteristicType = preset.characteristicType;
|
|
1809
|
+
this.presetsServices[i]
|
|
1810
|
+
.updateCharacteristic(characteristicType, preset.state)
|
|
1811
|
+
};
|
|
1812
|
+
};
|
|
1813
|
+
};
|
|
1814
|
+
|
|
1815
|
+
//update buttons state
|
|
1816
|
+
if (this.buttonsConfiguredCount > 0) {
|
|
1817
|
+
for (let i = 0; i < this.buttonsConfiguredCount; i++) {
|
|
1818
|
+
const button = this.buttonsConfigured[i];
|
|
1819
|
+
const mode = button.mode;
|
|
1820
|
+
switch (mode) {
|
|
1821
|
+
case 0: //POWER ON,OFF
|
|
1822
|
+
button.state = (power === true);
|
|
1823
|
+
break;
|
|
1824
|
+
case 1: //HEAT PUMP HEAT
|
|
1825
|
+
button.state = power ? (operationMode === 0) : false;
|
|
1826
|
+
break;
|
|
1827
|
+
case 2: //COOL
|
|
1828
|
+
button.state = power ? (operationMode === 1) : false;
|
|
1829
|
+
break;
|
|
1830
|
+
case 53: //HOLIDAY
|
|
1831
|
+
button.state = power ? (holidayMode === true) : false;
|
|
1832
|
+
break;
|
|
1833
|
+
case 10: //ALL ZONES PHYSICAL LOCK CONTROL
|
|
1834
|
+
button.state = power ? (prohibitZone1 === true && prohibitHotWater === true && prohibitZone2 === true) : false;
|
|
1835
|
+
break;
|
|
1836
|
+
case 20: //HOT WATER AUTO
|
|
1837
|
+
button.state = power ? (forcedHotWaterMode === false) : false;
|
|
1838
|
+
break;
|
|
1839
|
+
case 21: //ECO
|
|
1840
|
+
button.state = power ? (ecoHotWater === true) : false;
|
|
1841
|
+
break;
|
|
1842
|
+
case 22: //FORCE HEAT
|
|
1843
|
+
button.state = power ? (forcedHotWaterMode === true) : false;
|
|
1844
|
+
break;
|
|
1845
|
+
case 30: //PHYSICAL LOCK CONTROL
|
|
1846
|
+
button.state = (prohibitHotWater === true);
|
|
1847
|
+
break;
|
|
1848
|
+
case 40: //ZONE 1 HEAT THERMOSTAT
|
|
1849
|
+
button.state = power ? (operationModeZone1 === 0) : false;
|
|
1850
|
+
break;
|
|
1851
|
+
case 41: //HEAT FLOW
|
|
1852
|
+
button.state = power ? (operationModeZone1 === 1) : false;
|
|
1853
|
+
break;
|
|
1854
|
+
case 42: //HEAT CURVE
|
|
1855
|
+
button.state = power ? (operationModeZone1 === 2) : false;
|
|
1856
|
+
break;
|
|
1857
|
+
case 43: //COOL THERMOSTAT
|
|
1858
|
+
button.state = power ? (operationModeZone1 === 3) : false;
|
|
1859
|
+
break;
|
|
1860
|
+
case 44: //COOL FLOW
|
|
1861
|
+
button.state = power ? (operationModeZone1 === 4) : false;
|
|
1862
|
+
break;
|
|
1863
|
+
case 45: //FLOOR DRY UP
|
|
1864
|
+
button.state = power ? (operationModeZone1 === 5) : false;
|
|
1865
|
+
break;
|
|
1866
|
+
case 50: //PHYSICAL LOCK CONTROL
|
|
1867
|
+
button.state = (prohibitZone1 === true);
|
|
1868
|
+
break;
|
|
1869
|
+
case 60: //ZONE 2 HEAT THERMOSTAT
|
|
1870
|
+
button.state = power ? (operationModeZone2 === 0) : false;
|
|
1871
|
+
break;
|
|
1872
|
+
case 61: //HEAT FLOW
|
|
1873
|
+
button.state = power ? (operationModeZone2 === 1) : false;
|
|
1874
|
+
break;
|
|
1875
|
+
case 62: //HEAT CURVE
|
|
1876
|
+
button.state = power ? (operationModeZone2 === 2) : false;
|
|
1877
|
+
break;
|
|
1878
|
+
case 63: //COOL THERMOSTAT
|
|
1879
|
+
button.state = power ? (operationModeZone2 === 3) : false;
|
|
1880
|
+
break;
|
|
1881
|
+
case 64: //COOL FLOW
|
|
1882
|
+
button.state = power ? (operationModeZone2 === 4) : false;
|
|
1883
|
+
break;
|
|
1884
|
+
case 65: //FLOOR DRY UP
|
|
1885
|
+
button.state = power ? (operationModeZone2 === 5) : false;
|
|
1886
|
+
break;
|
|
1887
|
+
case 70: //PHYSICAL LOCK CONTROL
|
|
1888
|
+
button.state = (prohibitZone2 === true);
|
|
1889
|
+
break;
|
|
1890
|
+
default: //Unknown button
|
|
1891
|
+
this.emit('warn', `Unknown button mode: ${mode} detected.`);
|
|
1892
|
+
break;
|
|
1759
1893
|
};
|
|
1760
|
-
});
|
|
1761
|
-
this.presetsServices.push(presetService);
|
|
1762
|
-
accessory.addService(presetService);
|
|
1763
|
-
};
|
|
1764
|
-
};
|
|
1765
|
-
|
|
1766
|
-
//buttons services
|
|
1767
|
-
if (this.buttonsConfiguredCount > 0) {
|
|
1768
|
-
const debug = this.enableDebugMode ? this.emit('debug', `Prepare buttons services`) : false;
|
|
1769
|
-
this.buttonsServices = [];
|
|
1770
|
-
|
|
1771
|
-
for (let i = 0; i < this.buttonsConfiguredCount; i++) {
|
|
1772
|
-
const button = this.buttonsConfigured[i];
|
|
1773
|
-
|
|
1774
|
-
//get button mode
|
|
1775
|
-
const mode = button.mode;
|
|
1776
1894
|
|
|
1777
|
-
|
|
1778
|
-
|
|
1895
|
+
//update services
|
|
1896
|
+
if (this.buttonsServices) {
|
|
1897
|
+
const characteristicType = button.characteristicType;
|
|
1898
|
+
this.buttonsServices[i]
|
|
1899
|
+
.updateCharacteristic(characteristicType, button.state)
|
|
1900
|
+
};
|
|
1901
|
+
};
|
|
1902
|
+
};
|
|
1779
1903
|
|
|
1780
|
-
//
|
|
1781
|
-
|
|
1904
|
+
//start prepare accessory
|
|
1905
|
+
if (!this.startPrepareAccessory) {
|
|
1906
|
+
return;
|
|
1907
|
+
}
|
|
1782
1908
|
|
|
1783
|
-
|
|
1784
|
-
|
|
1909
|
+
try {
|
|
1910
|
+
const accessory = await this.prepareAccessory(this.accountInfo, deviceData, this.deviceId, this.deviceTypeText, this.deviceName, this.accountName);
|
|
1911
|
+
this.emit('publishAccessory', accessory);
|
|
1912
|
+
this.startPrepareAccessory = false;
|
|
1913
|
+
} catch (error) {
|
|
1914
|
+
this.emit('error', error);
|
|
1915
|
+
};
|
|
1916
|
+
})
|
|
1917
|
+
.on('success', (message) => {
|
|
1918
|
+
this.emit('success', message);
|
|
1919
|
+
})
|
|
1920
|
+
.on('message', (message) => {
|
|
1921
|
+
this.emit('message', message);
|
|
1922
|
+
})
|
|
1923
|
+
.on('debug', (debug) => {
|
|
1924
|
+
this.emit('debug', debug);
|
|
1925
|
+
})
|
|
1926
|
+
.on('warn', async (warn) => {
|
|
1927
|
+
this.emit('warn', warn);
|
|
1928
|
+
})
|
|
1929
|
+
.on('error', async (error) => {
|
|
1930
|
+
this.emit('error', error);
|
|
1931
|
+
});
|
|
1785
1932
|
|
|
1786
|
-
|
|
1787
|
-
|
|
1788
|
-
const characteristicType = button.characteristicType;
|
|
1789
|
-
const buttonService = new serviceType(serviceName, `Button ${deviceId} ${i}`);
|
|
1790
|
-
buttonService.addOptionalCharacteristic(Characteristic.ConfiguredName);
|
|
1791
|
-
buttonService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
|
|
1792
|
-
buttonService.getCharacteristic(characteristicType)
|
|
1793
|
-
.onGet(async () => {
|
|
1794
|
-
const state = button.state;
|
|
1795
|
-
return state;
|
|
1796
|
-
})
|
|
1797
|
-
.onSet(async (state) => {
|
|
1798
|
-
if (displayType > 0 && displayType < 3) {
|
|
1799
|
-
try {
|
|
1800
|
-
switch (mode) {
|
|
1801
|
-
case 0: //POWER ON,OFF
|
|
1802
|
-
deviceData.Device.Power = state;
|
|
1803
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power;
|
|
1804
|
-
break;
|
|
1805
|
-
case 1: //HEAT PUMP HEAT
|
|
1806
|
-
button.previousValue = state ? deviceData.Device.UnitStatus : button.previousValue ?? deviceData.Device.UnitStatus;
|
|
1807
|
-
deviceData.Device.Power = true;
|
|
1808
|
-
deviceData.Device.UnitStatus = state ? 0 : button.previousValue;
|
|
1809
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
|
|
1810
|
-
break;
|
|
1811
|
-
case 2: //COOL
|
|
1812
|
-
button.previousValue = state ? deviceData.Device.UnitStatus : button.previousValue ?? deviceData.Device.UnitStatus;
|
|
1813
|
-
deviceData.Device.Power = true;
|
|
1814
|
-
deviceData.Device.UnitStatus = state ? 1 : button.previousValue;
|
|
1815
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
|
|
1816
|
-
break;
|
|
1817
|
-
case 3: //HOLIDAY
|
|
1818
|
-
deviceData.Device.HolidayMode = state;
|
|
1819
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.HolidayMode;
|
|
1820
|
-
break;
|
|
1821
|
-
case 10: //ALL ZONES PHYSICAL LOCK CONTROL
|
|
1822
|
-
deviceData.Device.ProhibitZone1 = state;
|
|
1823
|
-
deviceData.Device.ProhibitHotWater = state;
|
|
1824
|
-
deviceData.Device.ProhibitZone2 = state;
|
|
1825
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.ProhibitHeatingZone1 + HeatPump.EffectiveFlags.ProhibitHotWater + HeatPump.EffectiveFlags.ProhibitHeatingZone2;
|
|
1826
|
-
break;
|
|
1827
|
-
case 20: //ZONE 1 HEAT THERMOSTAT
|
|
1828
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1829
|
-
deviceData.Device.Power = true;
|
|
1830
|
-
deviceData.Device.OperationModeZone1 = state ? 0 : button.previousValue;
|
|
1831
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1832
|
-
break;
|
|
1833
|
-
case 21: //HEAT FLOW
|
|
1834
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1835
|
-
deviceData.Device.Power = true;
|
|
1836
|
-
deviceData.Device.OperationModeZone1 = state ? 1 : button.previousValue;
|
|
1837
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1838
|
-
break;
|
|
1839
|
-
case 22: //HEAT CURVE
|
|
1840
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1841
|
-
deviceData.Device.Power = true;
|
|
1842
|
-
deviceData.Device.OperationModeZone1 = state ? 2 : button.previousValue;
|
|
1843
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1844
|
-
break;
|
|
1845
|
-
case 23: //COOL THERMOSTAT
|
|
1846
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1847
|
-
deviceData.Device.Power = true;
|
|
1848
|
-
deviceData.Device.OperationModeZone1 = state ? 3 : button.previousValue;
|
|
1849
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1850
|
-
break;
|
|
1851
|
-
case 24: //COOL FLOW
|
|
1852
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1853
|
-
deviceData.Device.Power = true;
|
|
1854
|
-
deviceData.Device.OperationModeZone1 = state ? 4 : button.previousValue;
|
|
1855
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1856
|
-
break;
|
|
1857
|
-
case 25: //FLOOR DRY UP
|
|
1858
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone1 : button.previousValue ?? deviceData.Device.OperationModeZone1;
|
|
1859
|
-
deviceData.Device.Power = true;
|
|
1860
|
-
deviceData.Device.OperationModeZone1 = state ? 5 : button.previousValue;
|
|
1861
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone1;
|
|
1862
|
-
break;
|
|
1863
|
-
case 30: //PHYSICAL LOCK CONTROL
|
|
1864
|
-
deviceData.Device.ProhibitZone1 = state;
|
|
1865
|
-
HeatPump.EffectiveFlags.ProhibitHeatingZone1;
|
|
1866
|
-
break;
|
|
1867
|
-
case 40: //HOT WATER NORMAL/FORCE HOT WATER
|
|
1868
|
-
deviceData.Device.Power = true;
|
|
1869
|
-
deviceData.Device.ForcedHotWaterMode = state;
|
|
1870
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.ForcedHotWaterMode;
|
|
1871
|
-
break;
|
|
1872
|
-
case 41: //NORMAL/ECO
|
|
1873
|
-
deviceData.Device.Power = true;
|
|
1874
|
-
deviceData.Device.EcoHotWater = state;
|
|
1875
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.EcoHotWater;
|
|
1876
|
-
break;
|
|
1877
|
-
case 50: //PHYSICAL LOCK CONTROL
|
|
1878
|
-
deviceData.Device.ProhibitHotWater = state;
|
|
1879
|
-
HeatPump.EffectiveFlags.ProhibitHotWater;
|
|
1880
|
-
break;
|
|
1881
|
-
case 60: //ZONE 2 HEAT THERMOSTAT
|
|
1882
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1883
|
-
deviceData.Device.Power = true;
|
|
1884
|
-
deviceData.Device.OperationModeZone2 = state ? 0 : button.previousValue;
|
|
1885
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1886
|
-
break;
|
|
1887
|
-
case 61: // HEAT FLOW
|
|
1888
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1889
|
-
deviceData.Device.Power = true;
|
|
1890
|
-
deviceData.Device.OperationModeZone2 = state ? 1 : button.previousValue;
|
|
1891
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1892
|
-
break;
|
|
1893
|
-
case 62: //HEAT CURVE
|
|
1894
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1895
|
-
deviceData.Device.Power = true;
|
|
1896
|
-
deviceData.Device.OperationModeZone2 = state ? 2 : button.previousValue;
|
|
1897
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1898
|
-
break;
|
|
1899
|
-
case 63: //COOL THERMOSTAT
|
|
1900
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1901
|
-
deviceData.Device.Power = true;
|
|
1902
|
-
deviceData.Device.OperationModeZone2 = state ? 3 : button.previousValue;
|
|
1903
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1904
|
-
break;
|
|
1905
|
-
case 64: //COOL FLOW
|
|
1906
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1907
|
-
deviceData.Device.Power = true;
|
|
1908
|
-
deviceData.Device.OperationModeZone2 = state ? 4 : button.previousValue;
|
|
1909
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1910
|
-
break;
|
|
1911
|
-
case 65: //FLOOR DRY UP
|
|
1912
|
-
button.previousValue = state ? deviceData.Device.OperationModeZone2 : button.previousValue ?? deviceData.Device.OperationModeZone2;
|
|
1913
|
-
deviceData.Device.Power = true;
|
|
1914
|
-
deviceData.Device.OperationModeZone2 = state ? 5 : button.previousValue;
|
|
1915
|
-
deviceData.Device.EffectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationModeZone2;
|
|
1916
|
-
break;
|
|
1917
|
-
case 70: //PHYSICAL LOCK CONTROL
|
|
1918
|
-
deviceData.Device.ProhibitZone2 = state;
|
|
1919
|
-
HeatPump.EffectiveFlags.ProhibitHeatingZone2;
|
|
1920
|
-
break;
|
|
1921
|
-
default:
|
|
1922
|
-
this.emit('message', `Unknown button mode: ${mode}`);
|
|
1923
|
-
break;
|
|
1924
|
-
};
|
|
1933
|
+
//check state
|
|
1934
|
+
await this.melCloudAtw.checkState();
|
|
1925
1935
|
|
|
1926
|
-
|
|
1927
|
-
|
|
1928
|
-
} catch (error) {
|
|
1929
|
-
this.emit('warn', `Set button error: ${error}`);
|
|
1930
|
-
};
|
|
1931
|
-
};
|
|
1932
|
-
});
|
|
1933
|
-
this.buttonsServices.push(buttonService);
|
|
1934
|
-
accessory.addService(buttonService)
|
|
1935
|
-
};
|
|
1936
|
-
};
|
|
1936
|
+
//start impule generator
|
|
1937
|
+
await this.melCloudAtw.impulseGenerator.start([{ name: 'checkState', sampling: this.refreshInterval }]);
|
|
1937
1938
|
|
|
1938
|
-
return
|
|
1939
|
+
return true;
|
|
1939
1940
|
} catch (error) {
|
|
1940
|
-
throw new Error(`
|
|
1941
|
+
throw new Error(`Start error: ${error}`);
|
|
1941
1942
|
};
|
|
1942
1943
|
};
|
|
1943
1944
|
};
|