@matterbridge/core 3.10.6-dev-20260816-34076cc → 3.10.6-dev-20260817-a8ee796
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/dist/behaviors/booleanStateConfigurationServer.d.ts +8 -4
- package/dist/behaviors/booleanStateConfigurationServer.js +72 -1
- package/dist/behaviors/export.d.ts +1 -0
- package/dist/behaviors/export.js +1 -0
- package/dist/behaviors/occupancySensingServer.d.ts +19 -0
- package/dist/behaviors/occupancySensingServer.js +29 -0
- package/dist/behaviors/smokeCoAlarmServer.d.ts +10 -0
- package/dist/behaviors/smokeCoAlarmServer.js +34 -0
- package/dist/behaviors/thermostatServer.d.ts +4 -0
- package/dist/behaviors/thermostatServer.js +59 -4
- package/dist/chipTest.d.ts +10 -0
- package/dist/chipTest.js +506 -0
- package/dist/cli.js +1 -0
- package/dist/frontend.js +63 -9
- package/dist/helpers.js +7 -1
- package/dist/matterbridge.js +9 -1
- package/dist/matterbridgeEndpoint.d.ts +3 -1
- package/dist/matterbridgeEndpoint.js +17 -9
- package/dist/matterbridgeEndpointHelpers.d.ts +17 -2
- package/dist/matterbridgeEndpointHelpers.js +32 -5
- package/package.json +5 -5
package/dist/chipTest.js
ADDED
|
@@ -0,0 +1,506 @@
|
|
|
1
|
+
import { spawnSync } from 'node:child_process';
|
|
2
|
+
import { closeSync, constants, existsSync, openSync, readSync, unlinkSync } from 'node:fs';
|
|
3
|
+
import { BasicInformationServer } from '@matter/node/behaviors/basic-information';
|
|
4
|
+
import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/bridged-device-basic-information';
|
|
5
|
+
import { GeneralDiagnosticsServer } from '@matter/node/behaviors/general-diagnostics';
|
|
6
|
+
import { Status, StatusResponseError } from '@matter/types';
|
|
7
|
+
import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
|
|
8
|
+
import { EndpointNumber } from '@matter/types/datatype';
|
|
9
|
+
import { MatterbridgeOccupancySensingServer } from './behaviors/occupancySensingServer.js';
|
|
10
|
+
import { cliEmitter } from './cliEmitter.js';
|
|
11
|
+
import { getSupportedDeviceType } from './matterbridgeDeviceTypes.js';
|
|
12
|
+
import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
|
|
13
|
+
const chipTestAppPipePath = '/tmp/matterbridge-chip-test-app-pipe';
|
|
14
|
+
const chipTestValidEventTrigger = 0xfffffffffff10000n;
|
|
15
|
+
const smokeCoAlarmWarningSmokeAlarmTrigger = 0x005c000000000090n;
|
|
16
|
+
const smokeCoAlarmCriticalSmokeAlarmTrigger = 0x005c00000000009cn;
|
|
17
|
+
const smokeCoAlarmSmokeAlarmClearTrigger = 0x005c0000000000a0n;
|
|
18
|
+
const smokeCoAlarmWarningCoAlarmTrigger = 0xffffffff00000091n;
|
|
19
|
+
const smokeCoAlarmCriticalCoAlarmTrigger = 0xffffffff0000009dn;
|
|
20
|
+
const smokeCoAlarmCoAlarmClearTrigger = 0xffffffff000000a1n;
|
|
21
|
+
const smokeCoAlarmYamlWarningCoAlarmTrigger = 0x005c000000000091n;
|
|
22
|
+
const smokeCoAlarmYamlCriticalCoAlarmTrigger = 0x005c00000000009dn;
|
|
23
|
+
const smokeCoAlarmYamlCoAlarmClearTrigger = 0x005c0000000000a1n;
|
|
24
|
+
const smokeCoAlarmWarningBatteryAlertTrigger = 0xffffffff00000095n;
|
|
25
|
+
const smokeCoAlarmCriticalBatteryAlertTrigger = 0xffffffff0000009en;
|
|
26
|
+
const smokeCoAlarmBatteryAlertClearTrigger = 0xffffffff000000a5n;
|
|
27
|
+
const smokeCoAlarmYamlWarningBatteryAlertTrigger = 0x005c000000000095n;
|
|
28
|
+
const smokeCoAlarmYamlBatteryAlertClearTrigger = 0x005c0000000000a5n;
|
|
29
|
+
const smokeCoAlarmHardwareFaultAlertTrigger = 0xffffffff00000093n;
|
|
30
|
+
const smokeCoAlarmHardwareFaultAlertClearTrigger = 0xffffffff000000a3n;
|
|
31
|
+
const smokeCoAlarmEndOfServiceAlertTrigger = 0xffffffff0000009an;
|
|
32
|
+
const smokeCoAlarmEndOfServiceAlertClearTrigger = 0xffffffff000000aan;
|
|
33
|
+
const smokeCoAlarmDeviceMutedTrigger = 0x005c00000000009bn;
|
|
34
|
+
const smokeCoAlarmDeviceMutedClearTrigger = 0x005c0000000000abn;
|
|
35
|
+
export const chipTestEnableKey = Uint8Array.from({ length: 16 }, (_, index) => index);
|
|
36
|
+
const smokeCoAlarmChipTestEnableKey = Uint8Array.from([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
|
|
37
|
+
let chipTestMatterbridge;
|
|
38
|
+
let closeChipTestAppPipe;
|
|
39
|
+
export class MatterbridgeGeneralDiagnosticsServer extends GeneralDiagnosticsServer {
|
|
40
|
+
initialize() {
|
|
41
|
+
this.state.testEventTriggersEnabled = true;
|
|
42
|
+
this.state.deviceTestEnableKey = chipTestEnableKey;
|
|
43
|
+
super.initialize();
|
|
44
|
+
}
|
|
45
|
+
async testEventTrigger({ eventTrigger, enableKey }) {
|
|
46
|
+
const keyData = Uint8Array.from(enableKey);
|
|
47
|
+
if (keyData.every((byte) => byte === 0)) {
|
|
48
|
+
throw new StatusResponseError('Invalid test enable key, all zeros', Status.ConstraintError);
|
|
49
|
+
}
|
|
50
|
+
if (!isChipTestEnableKey(keyData)) {
|
|
51
|
+
throw new StatusResponseError('Invalid test enable key', Status.ConstraintError);
|
|
52
|
+
}
|
|
53
|
+
if (BigInt(eventTrigger) === chipTestValidEventTrigger)
|
|
54
|
+
return;
|
|
55
|
+
if (await handleChipTestEventTrigger(BigInt(eventTrigger)))
|
|
56
|
+
return;
|
|
57
|
+
super.triggerTestEvent(eventTrigger);
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
function isChipTestEnableKey(keyData) {
|
|
61
|
+
return equalsBytes(keyData, chipTestEnableKey) || equalsBytes(keyData, smokeCoAlarmChipTestEnableKey);
|
|
62
|
+
}
|
|
63
|
+
function equalsBytes(first, second) {
|
|
64
|
+
return first.length === second.length && first.every((byte, index) => byte === second[index]);
|
|
65
|
+
}
|
|
66
|
+
export async function createChipTestDevices(matterbridge) {
|
|
67
|
+
if (!process.env.MATTERBRIDGE_CHIP_TEST || !process.env.MATTERBRIDGE_RUN_CHIP_TEST || matterbridge.bridgeMode !== 'bridge' || !matterbridge.aggregatorNode)
|
|
68
|
+
return;
|
|
69
|
+
chipTestMatterbridge = matterbridge;
|
|
70
|
+
const serverNode = matterbridge.serverNode;
|
|
71
|
+
const aggregator = matterbridge.aggregatorNode;
|
|
72
|
+
if (!serverNode || !aggregator) {
|
|
73
|
+
matterbridge.log.error('CHIP test devices can only be created when the server node and aggregator node are available');
|
|
74
|
+
return;
|
|
75
|
+
}
|
|
76
|
+
let ep;
|
|
77
|
+
matterbridge.plugins.set({
|
|
78
|
+
name: 'matterbridge-chip',
|
|
79
|
+
path: '',
|
|
80
|
+
type: 'DynamicPlatform',
|
|
81
|
+
version: '1.0.0',
|
|
82
|
+
description: 'Chip test plugin',
|
|
83
|
+
author: 'Matterbridge',
|
|
84
|
+
enabled: false,
|
|
85
|
+
private: false,
|
|
86
|
+
registeredDevices: 0,
|
|
87
|
+
});
|
|
88
|
+
const registerDevice = async (device, deviceName, serialNumber) => {
|
|
89
|
+
device.createDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber);
|
|
90
|
+
device.addRequiredClusters();
|
|
91
|
+
device.plugin = 'matterbridge-chip';
|
|
92
|
+
await matterbridge.addBridgedEndpoint('matterbridge-chip', device);
|
|
93
|
+
};
|
|
94
|
+
const bridgedNode = getSupportedDeviceType('BridgedNode');
|
|
95
|
+
const powerSource = getSupportedDeviceType('PowerSource');
|
|
96
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('ElectricalSensor'), bridgedNode, powerSource], { number: EndpointNumber(2_06) });
|
|
97
|
+
ep.createDefaultElectricalPowerMeasurementClusterServer(220_000, 1_000, 220_000_000, 50_000);
|
|
98
|
+
ep.createDefaultElectricalEnergyMeasurementClusterServer(100_000_000, 10_000_000);
|
|
99
|
+
await registerDevice(ep, 'Electrical Sensor', 'UTILITY-02-06');
|
|
100
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('ElectricalSensor'), bridgedNode, powerSource], { number: EndpointNumber(2_06_1) });
|
|
101
|
+
ep.createDefaultElectricalPowerMeasurementClusterServer(220_000, 1_000, 220_000_000, 50_000);
|
|
102
|
+
ep.createImportedElectricalEnergyMeasurementClusterServer(200_000_000);
|
|
103
|
+
await registerDevice(ep, 'Electrical Sensor Imported', 'UTILITY-02-06-1');
|
|
104
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('ElectricalSensor'), bridgedNode, powerSource], { number: EndpointNumber(2_06_2) });
|
|
105
|
+
ep.createDefaultElectricalPowerMeasurementClusterServer(220_000, 1_000, 220_000_000, 50_000);
|
|
106
|
+
ep.createExportedElectricalEnergyMeasurementClusterServer(50_000_000);
|
|
107
|
+
await registerDevice(ep, 'Electrical Sensor Exported', 'UTILITY-02-06-2');
|
|
108
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('DeviceEnergyManagement'), bridgedNode, powerSource], { number: EndpointNumber(2_07) });
|
|
109
|
+
ep.createDefaultDeviceEnergyManagementClusterServer();
|
|
110
|
+
ep.createDefaultDeviceEnergyManagementModeClusterServer();
|
|
111
|
+
await registerDevice(ep, 'Device Energy Management', 'UTILITY-02-07');
|
|
112
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('ContactSensor'), bridgedNode, powerSource], { number: EndpointNumber(7_01) });
|
|
113
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
114
|
+
ep.createDefaultBooleanStateClusterServer();
|
|
115
|
+
ep.createDefaultBooleanStateConfigurationClusterServer();
|
|
116
|
+
await registerDevice(ep, 'Contact Sensor', 'SENSOR-07-01');
|
|
117
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('LightSensor'), bridgedNode, powerSource], { number: EndpointNumber(7_02) });
|
|
118
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
119
|
+
ep.createDefaultIlluminanceMeasurementClusterServer(1000, 1, 65534);
|
|
120
|
+
await registerDevice(ep, 'Light Sensor', 'SENSOR-07-02');
|
|
121
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('OccupancySensor'), bridgedNode, powerSource], { number: EndpointNumber(7_03) });
|
|
122
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
123
|
+
await registerDevice(ep, 'Occupancy Sensor', 'SENSOR-07-03');
|
|
124
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('TemperatureSensor'), bridgedNode, powerSource], { number: EndpointNumber(7_04) });
|
|
125
|
+
ep.createDefaultPowerSourceReplaceableBatteryClusterServer();
|
|
126
|
+
ep.createDefaultTemperatureMeasurementClusterServer(2000, -27315, 32767);
|
|
127
|
+
await registerDevice(ep, 'Temperature Sensor', 'SENSOR-07-04');
|
|
128
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('PressureSensor'), bridgedNode, powerSource], { number: EndpointNumber(7_05) });
|
|
129
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
130
|
+
ep.createDefaultPressureMeasurementClusterServer(1013, 0, 2000);
|
|
131
|
+
await registerDevice(ep, 'Pressure Sensor', 'SENSOR-07-05');
|
|
132
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('FlowSensor'), bridgedNode, powerSource], { number: EndpointNumber(7_06) });
|
|
133
|
+
ep.createDefaultPowerSourceWiredClusterServer();
|
|
134
|
+
ep.createDefaultFlowMeasurementClusterServer(100, 0, 1000);
|
|
135
|
+
await registerDevice(ep, 'Flow Sensor', 'SENSOR-07-06');
|
|
136
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('HumiditySensor'), bridgedNode, powerSource], { number: EndpointNumber(7_07) });
|
|
137
|
+
ep.createDefaultPowerSourceRechargeableBatteryClusterServer();
|
|
138
|
+
ep.createDefaultRelativeHumidityMeasurementClusterServer(5000, 0, 10000);
|
|
139
|
+
await registerDevice(ep, 'Humidity Sensor', 'SENSOR-07-07');
|
|
140
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('OnOffSensor'), bridgedNode, powerSource], { number: EndpointNumber(7_08) });
|
|
141
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
142
|
+
await registerDevice(ep, 'On/Off Sensor', 'SENSOR-07-08');
|
|
143
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('SmokeCOAlarm'), bridgedNode, powerSource], { number: EndpointNumber(7_09) });
|
|
144
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
145
|
+
await registerDevice(ep, 'Smoke/CO Alarm', 'SENSOR-07-09');
|
|
146
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('SmokeCOAlarm'), bridgedNode, powerSource], { number: EndpointNumber(7_09_1) });
|
|
147
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
148
|
+
ep.createSmokeOnlySmokeCOAlarmClusterServer();
|
|
149
|
+
await registerDevice(ep, 'Smoke Alarm', 'SENSOR-07-09-1');
|
|
150
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('SmokeCOAlarm'), bridgedNode, powerSource], { number: EndpointNumber(7_09_2) });
|
|
151
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
152
|
+
ep.createCoOnlySmokeCOAlarmClusterServer();
|
|
153
|
+
await registerDevice(ep, 'CO Alarm', 'SENSOR-07-09-2');
|
|
154
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('AirQualitySensor'), bridgedNode, powerSource], { number: EndpointNumber(7_10) });
|
|
155
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
156
|
+
ep.createDefaultTvocMeasurementClusterServer(50, undefined, undefined, undefined, 0, 1000);
|
|
157
|
+
ep.addOptionalClusterServers();
|
|
158
|
+
await registerDevice(ep, 'Air Quality Sensor', 'SENSOR-07-10');
|
|
159
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('WaterFreezeDetector'), bridgedNode, powerSource], { number: EndpointNumber(7_11) });
|
|
160
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
161
|
+
ep.createDefaultBooleanStateClusterServer(false);
|
|
162
|
+
ep.createDefaultBooleanStateConfigurationClusterServer();
|
|
163
|
+
await registerDevice(ep, 'Water Freeze Detector', 'SENSOR-07-11');
|
|
164
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('WaterLeakDetector'), bridgedNode, powerSource], { number: EndpointNumber(7_12) });
|
|
165
|
+
ep.createDefaultPowerSourceBatteryClusterServer();
|
|
166
|
+
ep.createDefaultBooleanStateClusterServer(false);
|
|
167
|
+
ep.createDefaultBooleanStateConfigurationClusterServer();
|
|
168
|
+
await registerDevice(ep, 'Water Leak Detector', 'SENSOR-07-12');
|
|
169
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('RainSensor'), bridgedNode, powerSource], { number: EndpointNumber(7_13) });
|
|
170
|
+
ep.createDefaultPowerSourceRechargeableBatteryClusterServer();
|
|
171
|
+
ep.createDefaultBooleanStateClusterServer(false);
|
|
172
|
+
ep.createDefaultBooleanStateConfigurationClusterServer();
|
|
173
|
+
await registerDevice(ep, 'Rain Sensor', 'SENSOR-07-13');
|
|
174
|
+
ep = new MatterbridgeEndpoint([getSupportedDeviceType('SoilSensor'), bridgedNode, powerSource], { number: EndpointNumber(7_14) });
|
|
175
|
+
ep.createDefaultPowerSourceWiredClusterServer();
|
|
176
|
+
await registerDevice(ep, 'Soil Sensor', 'SENSOR-07-14');
|
|
177
|
+
}
|
|
178
|
+
export function createChipTestAppPipe(matterbridge) {
|
|
179
|
+
closeChipTestAppPipe?.();
|
|
180
|
+
try {
|
|
181
|
+
if (existsSync(chipTestAppPipePath))
|
|
182
|
+
unlinkSync(chipTestAppPipePath);
|
|
183
|
+
const mkfifo = spawnSync('mkfifo', [chipTestAppPipePath], { encoding: 'utf8' });
|
|
184
|
+
if (mkfifo.status !== 0) {
|
|
185
|
+
matterbridge.log.error(`Failed to create CHIP test app pipe ${chipTestAppPipePath}: ${mkfifo.stderr.trim()}`);
|
|
186
|
+
return;
|
|
187
|
+
}
|
|
188
|
+
}
|
|
189
|
+
catch (error) {
|
|
190
|
+
matterbridge.log.error(`Failed to create CHIP test app pipe ${chipTestAppPipePath}: ${error instanceof Error ? error.message : String(error)}`);
|
|
191
|
+
return;
|
|
192
|
+
}
|
|
193
|
+
matterbridge.log.notice(`CHIP test app pipe listening on ${chipTestAppPipePath}`);
|
|
194
|
+
let buffer = '';
|
|
195
|
+
let commandQueue = Promise.resolve(null);
|
|
196
|
+
let isClosing = false;
|
|
197
|
+
let pipeFd;
|
|
198
|
+
let shutdownListener;
|
|
199
|
+
const closePipe = () => {
|
|
200
|
+
isClosing = true;
|
|
201
|
+
if (shutdownListener) {
|
|
202
|
+
cliEmitter.off('shutdown', shutdownListener);
|
|
203
|
+
shutdownListener = undefined;
|
|
204
|
+
}
|
|
205
|
+
if (pipeFd !== undefined) {
|
|
206
|
+
try {
|
|
207
|
+
closeSync(pipeFd);
|
|
208
|
+
}
|
|
209
|
+
catch (error) {
|
|
210
|
+
matterbridge.log.debug(`Failed to close CHIP test app pipe ${chipTestAppPipePath}: ${error instanceof Error ? error.message : String(error)}`);
|
|
211
|
+
}
|
|
212
|
+
pipeFd = undefined;
|
|
213
|
+
}
|
|
214
|
+
try {
|
|
215
|
+
if (existsSync(chipTestAppPipePath))
|
|
216
|
+
unlinkSync(chipTestAppPipePath);
|
|
217
|
+
}
|
|
218
|
+
catch (error) {
|
|
219
|
+
matterbridge.log.debug(`Failed to remove CHIP test app pipe ${chipTestAppPipePath}: ${error instanceof Error ? error.message : String(error)}`);
|
|
220
|
+
}
|
|
221
|
+
closeChipTestAppPipe = undefined;
|
|
222
|
+
};
|
|
223
|
+
const enqueueCommand = (line) => {
|
|
224
|
+
const commandLine = line.trim();
|
|
225
|
+
if (!commandLine)
|
|
226
|
+
return;
|
|
227
|
+
commandQueue = commandQueue
|
|
228
|
+
.then(async () => {
|
|
229
|
+
const command = JSON.parse(commandLine);
|
|
230
|
+
if (!isChipTestAppPipeCommand(command)) {
|
|
231
|
+
matterbridge.log.warn(`Ignoring invalid CHIP test app pipe command: ${commandLine}`);
|
|
232
|
+
return null;
|
|
233
|
+
}
|
|
234
|
+
await handleChipTestAppPipeCommand(matterbridge, command);
|
|
235
|
+
return null;
|
|
236
|
+
})
|
|
237
|
+
.catch((error) => {
|
|
238
|
+
matterbridge.log.error(`Failed to handle CHIP test app pipe command ${commandLine}: ${error instanceof Error ? error.message : String(error)}`);
|
|
239
|
+
return null;
|
|
240
|
+
});
|
|
241
|
+
};
|
|
242
|
+
const handleChunk = (chunk) => {
|
|
243
|
+
buffer += chunk;
|
|
244
|
+
let newlineIndex = buffer.indexOf('\n');
|
|
245
|
+
while (newlineIndex !== -1) {
|
|
246
|
+
enqueueCommand(buffer.slice(0, newlineIndex));
|
|
247
|
+
buffer = buffer.slice(newlineIndex + 1);
|
|
248
|
+
newlineIndex = buffer.indexOf('\n');
|
|
249
|
+
}
|
|
250
|
+
};
|
|
251
|
+
try {
|
|
252
|
+
pipeFd = openSync(chipTestAppPipePath, constants.O_RDWR | constants.O_NONBLOCK);
|
|
253
|
+
}
|
|
254
|
+
catch (error) {
|
|
255
|
+
matterbridge.log.error(`Failed to open CHIP test app pipe ${chipTestAppPipePath}: ${error instanceof Error ? error.message : String(error)}`);
|
|
256
|
+
closePipe();
|
|
257
|
+
return;
|
|
258
|
+
}
|
|
259
|
+
const readBuffer = Buffer.alloc(4096);
|
|
260
|
+
const pollInterval = setInterval(() => {
|
|
261
|
+
if (isClosing || pipeFd === undefined)
|
|
262
|
+
return;
|
|
263
|
+
try {
|
|
264
|
+
let bytesRead = readSync(pipeFd, readBuffer, 0, readBuffer.length, null);
|
|
265
|
+
while (bytesRead > 0) {
|
|
266
|
+
handleChunk(readBuffer.toString('utf8', 0, bytesRead));
|
|
267
|
+
bytesRead = readSync(pipeFd, readBuffer, 0, readBuffer.length, null);
|
|
268
|
+
}
|
|
269
|
+
}
|
|
270
|
+
catch (error) {
|
|
271
|
+
if (error instanceof Error && 'code' in error && ['EAGAIN', 'EWOULDBLOCK'].includes(String(error.code)))
|
|
272
|
+
return;
|
|
273
|
+
matterbridge.log.error(`CHIP test app pipe ${chipTestAppPipePath} read error: ${error instanceof Error ? error.message : String(error)}`);
|
|
274
|
+
}
|
|
275
|
+
}, 50);
|
|
276
|
+
pollInterval.unref();
|
|
277
|
+
const closePipeWithInterval = () => {
|
|
278
|
+
clearInterval(pollInterval);
|
|
279
|
+
closePipe();
|
|
280
|
+
};
|
|
281
|
+
closeChipTestAppPipe = closePipeWithInterval;
|
|
282
|
+
shutdownListener = closePipeWithInterval;
|
|
283
|
+
cliEmitter.once('shutdown', shutdownListener);
|
|
284
|
+
}
|
|
285
|
+
async function handleChipTestEventTrigger(eventTrigger) {
|
|
286
|
+
if (eventTrigger !== smokeCoAlarmWarningSmokeAlarmTrigger &&
|
|
287
|
+
eventTrigger !== smokeCoAlarmCriticalSmokeAlarmTrigger &&
|
|
288
|
+
eventTrigger !== smokeCoAlarmSmokeAlarmClearTrigger &&
|
|
289
|
+
eventTrigger !== smokeCoAlarmWarningCoAlarmTrigger &&
|
|
290
|
+
eventTrigger !== smokeCoAlarmCriticalCoAlarmTrigger &&
|
|
291
|
+
eventTrigger !== smokeCoAlarmCoAlarmClearTrigger &&
|
|
292
|
+
eventTrigger !== smokeCoAlarmYamlWarningCoAlarmTrigger &&
|
|
293
|
+
eventTrigger !== smokeCoAlarmYamlCriticalCoAlarmTrigger &&
|
|
294
|
+
eventTrigger !== smokeCoAlarmYamlCoAlarmClearTrigger &&
|
|
295
|
+
eventTrigger !== smokeCoAlarmWarningBatteryAlertTrigger &&
|
|
296
|
+
eventTrigger !== smokeCoAlarmCriticalBatteryAlertTrigger &&
|
|
297
|
+
eventTrigger !== smokeCoAlarmBatteryAlertClearTrigger &&
|
|
298
|
+
eventTrigger !== smokeCoAlarmYamlWarningBatteryAlertTrigger &&
|
|
299
|
+
eventTrigger !== smokeCoAlarmYamlBatteryAlertClearTrigger &&
|
|
300
|
+
eventTrigger !== smokeCoAlarmHardwareFaultAlertTrigger &&
|
|
301
|
+
eventTrigger !== smokeCoAlarmHardwareFaultAlertClearTrigger &&
|
|
302
|
+
eventTrigger !== smokeCoAlarmEndOfServiceAlertTrigger &&
|
|
303
|
+
eventTrigger !== smokeCoAlarmEndOfServiceAlertClearTrigger &&
|
|
304
|
+
eventTrigger !== smokeCoAlarmDeviceMutedTrigger &&
|
|
305
|
+
eventTrigger !== smokeCoAlarmDeviceMutedClearTrigger) {
|
|
306
|
+
return false;
|
|
307
|
+
}
|
|
308
|
+
return await handleSmokeCoAlarmTestEventTrigger(eventTrigger);
|
|
309
|
+
}
|
|
310
|
+
async function handleSmokeCoAlarmTestEventTrigger(eventTrigger) {
|
|
311
|
+
if (!chipTestMatterbridge)
|
|
312
|
+
return false;
|
|
313
|
+
const endpoint = getChipTestEndpoint(chipTestMatterbridge, 709);
|
|
314
|
+
if (!endpoint)
|
|
315
|
+
return false;
|
|
316
|
+
switch (eventTrigger) {
|
|
317
|
+
case smokeCoAlarmWarningSmokeAlarmTrigger:
|
|
318
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
319
|
+
smokeState: SmokeCoAlarm.AlarmState.Warning,
|
|
320
|
+
expressedState: SmokeCoAlarm.ExpressedState.SmokeAlarm,
|
|
321
|
+
}, chipTestMatterbridge.log);
|
|
322
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'smokeAlarm', { alarmSeverityLevel: SmokeCoAlarm.AlarmState.Warning }, chipTestMatterbridge.log);
|
|
323
|
+
return true;
|
|
324
|
+
case smokeCoAlarmCriticalSmokeAlarmTrigger:
|
|
325
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
326
|
+
smokeState: SmokeCoAlarm.AlarmState.Critical,
|
|
327
|
+
expressedState: SmokeCoAlarm.ExpressedState.SmokeAlarm,
|
|
328
|
+
}, chipTestMatterbridge.log);
|
|
329
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'smokeAlarm', { alarmSeverityLevel: SmokeCoAlarm.AlarmState.Critical }, chipTestMatterbridge.log);
|
|
330
|
+
return true;
|
|
331
|
+
case smokeCoAlarmSmokeAlarmClearTrigger:
|
|
332
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
333
|
+
smokeState: SmokeCoAlarm.AlarmState.Normal,
|
|
334
|
+
expressedState: getSmokeCoAlarmExpressedState(endpoint, { smokeState: SmokeCoAlarm.AlarmState.Normal }),
|
|
335
|
+
}, chipTestMatterbridge.log);
|
|
336
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'allClear', undefined, chipTestMatterbridge.log);
|
|
337
|
+
return true;
|
|
338
|
+
case smokeCoAlarmWarningCoAlarmTrigger:
|
|
339
|
+
case smokeCoAlarmYamlWarningCoAlarmTrigger:
|
|
340
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
341
|
+
coState: SmokeCoAlarm.AlarmState.Warning,
|
|
342
|
+
expressedState: SmokeCoAlarm.ExpressedState.CoAlarm,
|
|
343
|
+
}, chipTestMatterbridge.log);
|
|
344
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'coAlarm', { alarmSeverityLevel: SmokeCoAlarm.AlarmState.Warning }, chipTestMatterbridge.log);
|
|
345
|
+
return true;
|
|
346
|
+
case smokeCoAlarmCriticalCoAlarmTrigger:
|
|
347
|
+
case smokeCoAlarmYamlCriticalCoAlarmTrigger:
|
|
348
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
349
|
+
coState: SmokeCoAlarm.AlarmState.Critical,
|
|
350
|
+
expressedState: SmokeCoAlarm.ExpressedState.CoAlarm,
|
|
351
|
+
}, chipTestMatterbridge.log);
|
|
352
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'coAlarm', { alarmSeverityLevel: SmokeCoAlarm.AlarmState.Critical }, chipTestMatterbridge.log);
|
|
353
|
+
return true;
|
|
354
|
+
case smokeCoAlarmCoAlarmClearTrigger:
|
|
355
|
+
case smokeCoAlarmYamlCoAlarmClearTrigger:
|
|
356
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
357
|
+
coState: SmokeCoAlarm.AlarmState.Normal,
|
|
358
|
+
expressedState: getSmokeCoAlarmExpressedState(endpoint, { coState: SmokeCoAlarm.AlarmState.Normal }),
|
|
359
|
+
}, chipTestMatterbridge.log);
|
|
360
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'allClear', undefined, chipTestMatterbridge.log);
|
|
361
|
+
return true;
|
|
362
|
+
case smokeCoAlarmWarningBatteryAlertTrigger:
|
|
363
|
+
case smokeCoAlarmYamlWarningBatteryAlertTrigger:
|
|
364
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
365
|
+
batteryAlert: SmokeCoAlarm.AlarmState.Warning,
|
|
366
|
+
expressedState: getSmokeCoAlarmExpressedState(endpoint, { batteryAlert: SmokeCoAlarm.AlarmState.Warning }),
|
|
367
|
+
}, chipTestMatterbridge.log);
|
|
368
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'lowBattery', { alarmSeverityLevel: SmokeCoAlarm.AlarmState.Warning }, chipTestMatterbridge.log);
|
|
369
|
+
return true;
|
|
370
|
+
case smokeCoAlarmCriticalBatteryAlertTrigger:
|
|
371
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
372
|
+
batteryAlert: SmokeCoAlarm.AlarmState.Critical,
|
|
373
|
+
expressedState: getSmokeCoAlarmExpressedState(endpoint, { batteryAlert: SmokeCoAlarm.AlarmState.Critical }),
|
|
374
|
+
}, chipTestMatterbridge.log);
|
|
375
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'lowBattery', { alarmSeverityLevel: SmokeCoAlarm.AlarmState.Critical }, chipTestMatterbridge.log);
|
|
376
|
+
return true;
|
|
377
|
+
case smokeCoAlarmBatteryAlertClearTrigger:
|
|
378
|
+
case smokeCoAlarmYamlBatteryAlertClearTrigger:
|
|
379
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
380
|
+
batteryAlert: SmokeCoAlarm.AlarmState.Normal,
|
|
381
|
+
expressedState: getSmokeCoAlarmExpressedState(endpoint, { batteryAlert: SmokeCoAlarm.AlarmState.Normal }),
|
|
382
|
+
}, chipTestMatterbridge.log);
|
|
383
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'allClear', undefined, chipTestMatterbridge.log);
|
|
384
|
+
return true;
|
|
385
|
+
case smokeCoAlarmHardwareFaultAlertTrigger:
|
|
386
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
387
|
+
hardwareFaultAlert: true,
|
|
388
|
+
expressedState: SmokeCoAlarm.ExpressedState.HardwareFault,
|
|
389
|
+
}, chipTestMatterbridge.log);
|
|
390
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'hardwareFault', undefined, chipTestMatterbridge.log);
|
|
391
|
+
return true;
|
|
392
|
+
case smokeCoAlarmHardwareFaultAlertClearTrigger:
|
|
393
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
394
|
+
hardwareFaultAlert: false,
|
|
395
|
+
expressedState: SmokeCoAlarm.ExpressedState.Normal,
|
|
396
|
+
}, chipTestMatterbridge.log);
|
|
397
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'allClear', undefined, chipTestMatterbridge.log);
|
|
398
|
+
return true;
|
|
399
|
+
case smokeCoAlarmEndOfServiceAlertTrigger:
|
|
400
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
401
|
+
endOfServiceAlert: SmokeCoAlarm.EndOfService.Expired,
|
|
402
|
+
expressedState: SmokeCoAlarm.ExpressedState.EndOfService,
|
|
403
|
+
}, chipTestMatterbridge.log);
|
|
404
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'endOfService', undefined, chipTestMatterbridge.log);
|
|
405
|
+
return true;
|
|
406
|
+
case smokeCoAlarmEndOfServiceAlertClearTrigger:
|
|
407
|
+
await endpoint.setCluster(SmokeCoAlarm, {
|
|
408
|
+
endOfServiceAlert: SmokeCoAlarm.EndOfService.Normal,
|
|
409
|
+
expressedState: SmokeCoAlarm.ExpressedState.Normal,
|
|
410
|
+
}, chipTestMatterbridge.log);
|
|
411
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'allClear', undefined, chipTestMatterbridge.log);
|
|
412
|
+
return true;
|
|
413
|
+
case smokeCoAlarmDeviceMutedTrigger:
|
|
414
|
+
if (endpoint.getAttribute(SmokeCoAlarm.id, 'smokeState') === SmokeCoAlarm.AlarmState.Warning ||
|
|
415
|
+
endpoint.getAttribute(SmokeCoAlarm.id, 'coState') === SmokeCoAlarm.AlarmState.Warning) {
|
|
416
|
+
await endpoint.setCluster(SmokeCoAlarm, { deviceMuted: SmokeCoAlarm.MuteState.Muted }, chipTestMatterbridge.log);
|
|
417
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'alarmMuted', undefined, chipTestMatterbridge.log);
|
|
418
|
+
}
|
|
419
|
+
return true;
|
|
420
|
+
case smokeCoAlarmDeviceMutedClearTrigger:
|
|
421
|
+
await endpoint.setCluster(SmokeCoAlarm, { deviceMuted: SmokeCoAlarm.MuteState.NotMuted }, chipTestMatterbridge.log);
|
|
422
|
+
await endpoint.triggerEvent(SmokeCoAlarm, 'muteEnded', undefined, chipTestMatterbridge.log);
|
|
423
|
+
return true;
|
|
424
|
+
default:
|
|
425
|
+
return false;
|
|
426
|
+
}
|
|
427
|
+
}
|
|
428
|
+
function getSmokeCoAlarmExpressedState(endpoint, state = {}) {
|
|
429
|
+
const smokeState = state.smokeState ?? endpoint.getAttribute(SmokeCoAlarm.id, 'smokeState');
|
|
430
|
+
const coState = state.coState ?? endpoint.getAttribute(SmokeCoAlarm.id, 'coState');
|
|
431
|
+
const batteryAlert = state.batteryAlert ?? endpoint.getAttribute(SmokeCoAlarm.id, 'batteryAlert');
|
|
432
|
+
if (smokeState !== SmokeCoAlarm.AlarmState.Normal)
|
|
433
|
+
return SmokeCoAlarm.ExpressedState.SmokeAlarm;
|
|
434
|
+
if (batteryAlert !== SmokeCoAlarm.AlarmState.Normal)
|
|
435
|
+
return SmokeCoAlarm.ExpressedState.BatteryAlert;
|
|
436
|
+
if (coState !== SmokeCoAlarm.AlarmState.Normal)
|
|
437
|
+
return SmokeCoAlarm.ExpressedState.CoAlarm;
|
|
438
|
+
return SmokeCoAlarm.ExpressedState.Normal;
|
|
439
|
+
}
|
|
440
|
+
async function handleChipTestAppPipeCommand(matterbridge, command) {
|
|
441
|
+
const endpointId = command.Name === 'SetOccupancy' && command.EndpointId === 1 ? 703 : (command.EndpointId ?? (command.Name === 'SimulateConfigurationVersionChange' ? 701 : undefined));
|
|
442
|
+
if (endpointId === undefined) {
|
|
443
|
+
matterbridge.log.warn(`Ignoring CHIP test app pipe command without EndpointId: ${JSON.stringify(command)}`);
|
|
444
|
+
return;
|
|
445
|
+
}
|
|
446
|
+
const endpoint = getChipTestEndpoint(matterbridge, endpointId);
|
|
447
|
+
if (!endpoint) {
|
|
448
|
+
matterbridge.log.warn(`Ignoring CHIP test app pipe command for unknown endpoint ${endpointId}: ${JSON.stringify(command)}`);
|
|
449
|
+
return;
|
|
450
|
+
}
|
|
451
|
+
switch (command.Name) {
|
|
452
|
+
case 'SetBooleanState':
|
|
453
|
+
await endpoint.setStateOf(endpoint.behaviors.supported.booleanState, { stateValue: Boolean(command.NewState) });
|
|
454
|
+
matterbridge.log.info(`CHIP test app pipe set BooleanState.StateValue to ${Boolean(command.NewState)} on endpoint ${endpointId}`);
|
|
455
|
+
return;
|
|
456
|
+
case 'SetBooleanStateSensorFault':
|
|
457
|
+
await endpoint.setStateOf(endpoint.behaviors.supported.booleanStateConfiguration, { sensorFault: { generalFault: Boolean(command.SensorFault) } });
|
|
458
|
+
matterbridge.log.info(`CHIP test app pipe set BooleanStateConfiguration.SensorFault to ${command.SensorFault ?? 0} on endpoint ${endpointId}`);
|
|
459
|
+
return;
|
|
460
|
+
case 'SimulateConfigurationVersionChange':
|
|
461
|
+
if (matterbridge.serverNode) {
|
|
462
|
+
const configurationVersion = (matterbridge.serverNode.stateOf(BasicInformationServer).configurationVersion ?? 1) + 1;
|
|
463
|
+
await matterbridge.serverNode.setStateOf(BasicInformationServer, { configurationVersion });
|
|
464
|
+
matterbridge.log.info(`CHIP test app pipe set BasicInformation.ConfigurationVersion to ${configurationVersion} on endpoint 0`);
|
|
465
|
+
}
|
|
466
|
+
endpoint.configurationVersion = (endpoint.stateOf(BridgedDeviceBasicInformationServer).configurationVersion ?? 1) + 1;
|
|
467
|
+
await endpoint.setStateOf(BridgedDeviceBasicInformationServer, { configurationVersion: endpoint.configurationVersion });
|
|
468
|
+
matterbridge.log.info(`CHIP test app pipe set BridgedDeviceBasicInformation.ConfigurationVersion to ${endpoint.configurationVersion} on endpoint ${endpointId}`);
|
|
469
|
+
return;
|
|
470
|
+
case 'SetOccupancy':
|
|
471
|
+
await endpoint.setStateOf(MatterbridgeOccupancySensingServer, { occupancy: { occupied: Boolean(command.Occupancy) } });
|
|
472
|
+
matterbridge.log.info(`CHIP test app pipe set OccupancySensing.Occupancy to ${command.Occupancy ?? 0} on endpoint ${endpointId}`);
|
|
473
|
+
return;
|
|
474
|
+
case 'SetSimulatedSoilMoisture':
|
|
475
|
+
await endpoint.setStateOf(endpoint.behaviors.supported.soilMeasurement, { soilMoistureMeasuredValue: command.SoilMoistureValue ?? null });
|
|
476
|
+
matterbridge.log.info(`CHIP test app pipe set SoilMeasurement.SoilMoistureMeasuredValue to ${command.SoilMoistureValue ?? null} on endpoint ${endpointId}`);
|
|
477
|
+
return;
|
|
478
|
+
default:
|
|
479
|
+
matterbridge.log.warn(`Ignoring unsupported CHIP test app pipe command: ${JSON.stringify(command)}`);
|
|
480
|
+
}
|
|
481
|
+
}
|
|
482
|
+
function getChipTestEndpoint(matterbridge, endpointId) {
|
|
483
|
+
const aggregatorEndpoint = matterbridge.aggregatorNode;
|
|
484
|
+
if (!aggregatorEndpoint)
|
|
485
|
+
return undefined;
|
|
486
|
+
const endpoints = [aggregatorEndpoint, ...aggregatorEndpoint.parts];
|
|
487
|
+
for (const endpoint of endpoints) {
|
|
488
|
+
if (Number(endpoint.number) === endpointId && endpoint instanceof MatterbridgeEndpoint)
|
|
489
|
+
return endpoint;
|
|
490
|
+
for (const childEndpoint of endpoint.parts) {
|
|
491
|
+
if (Number(childEndpoint.number) === endpointId && childEndpoint instanceof MatterbridgeEndpoint)
|
|
492
|
+
return childEndpoint;
|
|
493
|
+
}
|
|
494
|
+
}
|
|
495
|
+
return undefined;
|
|
496
|
+
}
|
|
497
|
+
function isChipTestAppPipeCommand(value) {
|
|
498
|
+
return (typeof value === 'object' &&
|
|
499
|
+
value !== null &&
|
|
500
|
+
(!('Name' in value) || typeof value.Name === 'string') &&
|
|
501
|
+
(!('EndpointId' in value) || typeof value.EndpointId === 'number') &&
|
|
502
|
+
(!('NewState' in value) || typeof value.NewState === 'boolean') &&
|
|
503
|
+
(!('Occupancy' in value) || typeof value.Occupancy === 'number') &&
|
|
504
|
+
(!('SensorFault' in value) || typeof value.SensorFault === 'number') &&
|
|
505
|
+
(!('SoilMoistureValue' in value) || typeof value.SoilMoistureValue === 'number'));
|
|
506
|
+
}
|
package/dist/cli.js
CHANGED
package/dist/frontend.js
CHANGED
|
@@ -4,7 +4,9 @@ import path from 'node:path';
|
|
|
4
4
|
import { Diagnostic, Lifecycle, LogDestination, LogFormat as MatterLogFormat, Logger, LogLevel as MatterLogLevel } from '@matter/general';
|
|
5
5
|
import { DeviceAdvertiser, DeviceCommissioner, FabricManager } from '@matter/protocol';
|
|
6
6
|
import { BridgedDeviceBasicInformation } from '@matter/types/clusters/bridged-device-basic-information';
|
|
7
|
+
import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
|
|
7
8
|
import { PowerSource } from '@matter/types/clusters/power-source';
|
|
9
|
+
import { SoilMeasurement } from '@matter/types/clusters/soil-measurement';
|
|
8
10
|
import { CommissioningOptions } from '@matter/types/commissioning';
|
|
9
11
|
import { FabricIndex } from '@matter/types/datatype';
|
|
10
12
|
import { BroadcastServer } from '@matterbridge/thread/server';
|
|
@@ -1061,6 +1063,24 @@ export class Frontend extends EventEmitter {
|
|
|
1061
1063
|
};
|
|
1062
1064
|
let attributes = '';
|
|
1063
1065
|
let supportedModes = [];
|
|
1066
|
+
const getMeasurementText = (value, scale, unit) => {
|
|
1067
|
+
if (value === null)
|
|
1068
|
+
return 'unknown';
|
|
1069
|
+
if (isValidNumber(value) || typeof value === 'bigint')
|
|
1070
|
+
return `${Number(value) / scale}${unit}`;
|
|
1071
|
+
return '';
|
|
1072
|
+
};
|
|
1073
|
+
const getEnergyText = (value) => {
|
|
1074
|
+
if (value === null)
|
|
1075
|
+
return 'unknown';
|
|
1076
|
+
if (isValidObject(value) && 'energy' in value && (isValidNumber(value.energy) || typeof value.energy === 'bigint'))
|
|
1077
|
+
return `${Number(value.energy) / 1_000_000}kWh`;
|
|
1078
|
+
return '';
|
|
1079
|
+
};
|
|
1080
|
+
const appendMeasurement = (label, value) => {
|
|
1081
|
+
if (value)
|
|
1082
|
+
attributes += `${label}: ${value} `;
|
|
1083
|
+
};
|
|
1064
1084
|
device.forEachAttribute((clusterName, clusterId, attributeName, attributeId, attributeValue) => {
|
|
1065
1085
|
if (typeof attributeValue === 'undefined' || attributeValue === undefined)
|
|
1066
1086
|
return;
|
|
@@ -1078,7 +1098,7 @@ export class Frontend extends EventEmitter {
|
|
|
1078
1098
|
attributes += `Heat to: ${attributeValue / 100}°C `;
|
|
1079
1099
|
if (clusterName === 'thermostat' && attributeName === 'occupiedCoolingSetpoint' && isValidNumber(attributeValue))
|
|
1080
1100
|
attributes += `Cool to: ${attributeValue / 100}°C `;
|
|
1081
|
-
const modeClusters = new Set(['modeSelect', 'rvcRunMode', 'rvcCleanMode', 'laundryWasherMode', 'ovenMode', 'microwaveOvenMode']);
|
|
1101
|
+
const modeClusters = new Set(['modeSelect', 'rvcRunMode', 'rvcCleanMode', 'laundryWasherMode', 'ovenMode', 'microwaveOvenMode', 'deviceEnergyManagementMode']);
|
|
1082
1102
|
if (modeClusters.has(clusterName) && attributeName === 'supportedModes') {
|
|
1083
1103
|
supportedModes = attributeValue;
|
|
1084
1104
|
}
|
|
@@ -1124,8 +1144,12 @@ export class Frontend extends EventEmitter {
|
|
|
1124
1144
|
attributes += `Speed: ${attributeValue} `;
|
|
1125
1145
|
if (clusterName === 'occupancySensing' && attributeName === 'occupancy' && isValidObject(attributeValue, 1))
|
|
1126
1146
|
attributes += `Occupancy: ${attributeValue.occupied} `;
|
|
1127
|
-
if (clusterName === 'illuminanceMeasurement' && attributeName === 'measuredValue'
|
|
1128
|
-
|
|
1147
|
+
if (clusterName === 'illuminanceMeasurement' && attributeName === 'measuredValue') {
|
|
1148
|
+
if (attributeValue === null)
|
|
1149
|
+
attributes += `Illuminance: unknown `;
|
|
1150
|
+
else if (isValidNumber(attributeValue))
|
|
1151
|
+
attributes += `Illuminance: ${Math.round(Math.max(Math.pow(10, attributeValue / 10000), 0))} `;
|
|
1152
|
+
}
|
|
1129
1153
|
if (clusterName === 'airQuality' && attributeName === 'airQuality')
|
|
1130
1154
|
attributes += `Air quality: ${attributeValue} `;
|
|
1131
1155
|
if (clusterName === 'totalVolatileOrganicCompoundsConcentrationMeasurement' && attributeName === 'measuredValue')
|
|
@@ -1138,14 +1162,44 @@ export class Frontend extends EventEmitter {
|
|
|
1138
1162
|
attributes += `Pm10: ${attributeValue} `;
|
|
1139
1163
|
if (clusterName === 'formaldehydeConcentrationMeasurement' && attributeName === 'measuredValue')
|
|
1140
1164
|
attributes += `CH₂O: ${attributeValue} `;
|
|
1141
|
-
if (clusterName === 'temperatureMeasurement' && attributeName === 'measuredValue'
|
|
1142
|
-
|
|
1143
|
-
|
|
1144
|
-
|
|
1165
|
+
if (clusterName === 'temperatureMeasurement' && attributeName === 'measuredValue') {
|
|
1166
|
+
if (attributeValue === null)
|
|
1167
|
+
attributes += `Temperature: unknown `;
|
|
1168
|
+
else if (isValidNumber(attributeValue))
|
|
1169
|
+
attributes += `Temperature: ${attributeValue / 100}°C `;
|
|
1170
|
+
}
|
|
1171
|
+
if (clusterName === 'relativeHumidityMeasurement' && attributeName === 'measuredValue') {
|
|
1172
|
+
if (attributeValue === null)
|
|
1173
|
+
attributes += `Humidity: unknown `;
|
|
1174
|
+
else if (isValidNumber(attributeValue))
|
|
1175
|
+
attributes += `Humidity: ${attributeValue / 100}% `;
|
|
1176
|
+
}
|
|
1145
1177
|
if (clusterName === 'pressureMeasurement' && attributeName === 'measuredValue')
|
|
1146
|
-
attributes += `Pressure: ${attributeValue} `;
|
|
1178
|
+
attributes += `Pressure: ${attributeValue === null ? 'unknown' : attributeValue} `;
|
|
1147
1179
|
if (clusterName === 'flowMeasurement' && attributeName === 'measuredValue')
|
|
1148
|
-
attributes += `Flow: ${attributeValue} `;
|
|
1180
|
+
attributes += `Flow: ${attributeValue === null ? 'unknown' : attributeValue} `;
|
|
1181
|
+
if (clusterId === SoilMeasurement.id && attributeName === 'soilMoistureMeasuredValue') {
|
|
1182
|
+
if (attributeValue === null)
|
|
1183
|
+
attributes += `Soil moisture: unknown `;
|
|
1184
|
+
else if (isValidNumber(attributeValue))
|
|
1185
|
+
attributes += `Soil moisture: ${attributeValue}% `;
|
|
1186
|
+
}
|
|
1187
|
+
if (clusterName === 'electricalPowerMeasurement' && attributeName === 'voltage')
|
|
1188
|
+
appendMeasurement('Voltage', getMeasurementText(attributeValue, 1_000, 'V'));
|
|
1189
|
+
if (clusterName === 'electricalPowerMeasurement' && attributeName === 'activeCurrent')
|
|
1190
|
+
appendMeasurement('Current', getMeasurementText(attributeValue, 1_000, 'A'));
|
|
1191
|
+
if (clusterName === 'electricalPowerMeasurement' && attributeName === 'activePower')
|
|
1192
|
+
appendMeasurement('Power', getMeasurementText(attributeValue, 1_000_000, 'kW'));
|
|
1193
|
+
if (clusterName === 'electricalPowerMeasurement' && attributeName === 'frequency')
|
|
1194
|
+
appendMeasurement('Frequency', getMeasurementText(attributeValue, 1_000, 'Hz'));
|
|
1195
|
+
if (clusterName === 'electricalEnergyMeasurement' && attributeName === 'cumulativeEnergyImported')
|
|
1196
|
+
appendMeasurement('Imported', getEnergyText(attributeValue));
|
|
1197
|
+
if (clusterName === 'electricalEnergyMeasurement' && attributeName === 'cumulativeEnergyExported')
|
|
1198
|
+
appendMeasurement('Exported', getEnergyText(attributeValue));
|
|
1199
|
+
if (clusterName === 'deviceEnergyManagement' && attributeName === 'esaCanGenerate')
|
|
1200
|
+
attributes += `ESA can generate: ${attributeValue} `;
|
|
1201
|
+
if (clusterName === 'deviceEnergyManagement' && attributeName === 'esaState')
|
|
1202
|
+
attributes += `ESA state: ${DeviceEnergyManagement.EsaState[attributeValue]} `;
|
|
1149
1203
|
if (clusterName === 'fixedLabel' && attributeName === 'labelList')
|
|
1150
1204
|
attributes += `${getFixedLabel(device)} `;
|
|
1151
1205
|
if (clusterName === 'userLabel' && attributeName === 'labelList')
|
package/dist/helpers.js
CHANGED
|
@@ -58,7 +58,13 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
|
|
|
58
58
|
return device;
|
|
59
59
|
}
|
|
60
60
|
export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
|
|
61
|
-
if (
|
|
61
|
+
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
62
|
+
const { createChipTestAppPipe, createChipTestDevices } = await import('./chipTest.js');
|
|
63
|
+
if (process.env.MATTERBRIDGE_RUN_CHIP_TEST)
|
|
64
|
+
await createChipTestDevices(matterbridge);
|
|
65
|
+
createChipTestAppPipe(matterbridge);
|
|
66
|
+
}
|
|
67
|
+
if (!process.env.MATTERBRIDGE_CHIP_TEST && matterbridge.virtualMode !== 'disabled' && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
|
|
62
68
|
matterbridge.log.notice(`Creating virtual devices for Matterbridge server node...`);
|
|
63
69
|
await addVirtualDevice(aggregatorEndpoint, 'Restart Matterbridge', matterbridge.virtualMode, async () => {
|
|
64
70
|
if (matterbridge.restartMode === 'none')
|