@matterbridge/core 3.11.1-dev-20261030-e12e668 → 3.11.1-dev-20261030-65deb56
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/chipTests.js +94 -0
- package/dist/devices/waterHeater.d.ts +15 -2
- package/dist/devices/waterHeater.js +100 -5
- package/dist/matterController.d.ts +3 -0
- package/dist/matterController.js +287 -0
- package/dist/matterbridge.d.ts +1 -1
- package/dist/matterbridge.js +15 -4
- package/package.json +5 -5
package/dist/chipTests.js
CHANGED
|
@@ -21,6 +21,9 @@ import { RvcOperationalState } from '@matter/types/clusters/rvc-operational-stat
|
|
|
21
21
|
import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
|
|
22
22
|
import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
|
|
23
23
|
import { Switch } from '@matter/types/clusters/switch';
|
|
24
|
+
import { Thermostat } from '@matter/types/clusters/thermostat';
|
|
25
|
+
import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-management';
|
|
26
|
+
import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
|
|
24
27
|
import { StatusResponseError } from '@matter/types/common';
|
|
25
28
|
import { Status, TariffPriceType, TariffUnit } from '@matter/types/globals';
|
|
26
29
|
import { MATTER_EPOCH_OFFSET_S } from '@matter/types/tlv';
|
|
@@ -28,6 +31,7 @@ import { wait } from '@matterbridge/utils/wait';
|
|
|
28
31
|
import { MatterbridgeOccupancySensingServer } from './behaviors/occupancySensingServer.js';
|
|
29
32
|
import { cliEmitter } from './cliEmitter.js';
|
|
30
33
|
import { MatterbridgeRvcOperationalStateServer, MatterbridgeRvcRunModeServer } from './devices/roboticVacuumCleaner.js';
|
|
34
|
+
import { MatterbridgeWaterHeaterManagementServer } from './devices/waterHeater.js';
|
|
31
35
|
import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
|
|
32
36
|
import { featuresFor } from './matterbridgeEndpointHelpers.js';
|
|
33
37
|
const chipTestAppPipePath = '/tmp/matterbridge-chip-test-app-pipe';
|
|
@@ -62,6 +66,14 @@ const smokeCoAlarmDeviceMutedClearTrigger = 0x005c0000000000abn;
|
|
|
62
66
|
const electricalPowerMeasurementStartFakeLoadTrigger = 0x0091000000000001n;
|
|
63
67
|
const electricalEnergyMeasurementStartFakeGeneratorTrigger = 0x0091000000000002n;
|
|
64
68
|
const electricalPowerMeasurementStopFakeReadingsTrigger = 0x0091000000000000n;
|
|
69
|
+
const waterHeaterBasicInstallationTrigger = 0x0094000000000000n;
|
|
70
|
+
const waterHeaterBasicInstallationClearTrigger = 0x0094000000000001n;
|
|
71
|
+
const waterHeaterWaterTemperature20CTrigger = 0x0094000000000002n;
|
|
72
|
+
const waterHeaterWaterTemperature61CTrigger = 0x0094000000000003n;
|
|
73
|
+
const waterHeaterWaterTemperature66CTrigger = 0x0094000000000004n;
|
|
74
|
+
const waterHeaterManualModeTrigger = 0x0094000000000005n;
|
|
75
|
+
const waterHeaterOffModeTrigger = 0x0094000000000006n;
|
|
76
|
+
const waterHeaterDrawOffHotWaterTrigger = 0x0094000000000007n;
|
|
65
77
|
const deviceEnergyManagementPowerAdjustmentTrigger = 0x0098000000000000n;
|
|
66
78
|
const deviceEnergyManagementPowerAdjustmentClearTrigger = 0x0098000000000001n;
|
|
67
79
|
const deviceEnergyManagementUserOptOutLocalTrigger = 0x0098000000000002n;
|
|
@@ -353,6 +365,7 @@ async function handleChipTestEventTrigger(eventTrigger) {
|
|
|
353
365
|
normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmDeviceMutedTrigger) &&
|
|
354
366
|
normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmDeviceMutedClearTrigger)) {
|
|
355
367
|
return ((await handleElectricalEnergyTestEventTrigger(normalizedEventTrigger)) ||
|
|
368
|
+
(await handleWaterHeaterManagementTestEventTrigger(normalizedEventTrigger)) ||
|
|
356
369
|
(await handleDeviceEnergyManagementTestEventTrigger(normalizedEventTrigger)) ||
|
|
357
370
|
(await handleEnergyEvseTestEventTrigger(normalizedEventTrigger)) ||
|
|
358
371
|
(await handleMeterIdentificationTestEventTrigger(normalizedEventTrigger)) ||
|
|
@@ -950,6 +963,87 @@ async function handleCommodityTariffTestEventTrigger(eventTrigger) {
|
|
|
950
963
|
await endpoint.setCluster(CommodityTariff, buildCommodityTariffFakeValues(commodityTariffDayOffset, commodityTariffEntryIndex), log);
|
|
951
964
|
return true;
|
|
952
965
|
}
|
|
966
|
+
async function handleWaterHeaterManagementTestEventTrigger(eventTrigger) {
|
|
967
|
+
const supportedTriggers = [
|
|
968
|
+
normalizeTestEventTrigger(waterHeaterBasicInstallationTrigger),
|
|
969
|
+
normalizeTestEventTrigger(waterHeaterBasicInstallationClearTrigger),
|
|
970
|
+
normalizeTestEventTrigger(waterHeaterWaterTemperature20CTrigger),
|
|
971
|
+
normalizeTestEventTrigger(waterHeaterWaterTemperature61CTrigger),
|
|
972
|
+
normalizeTestEventTrigger(waterHeaterWaterTemperature66CTrigger),
|
|
973
|
+
normalizeTestEventTrigger(waterHeaterManualModeTrigger),
|
|
974
|
+
normalizeTestEventTrigger(waterHeaterOffModeTrigger),
|
|
975
|
+
normalizeTestEventTrigger(waterHeaterDrawOffHotWaterTrigger),
|
|
976
|
+
];
|
|
977
|
+
if (!supportedTriggers.includes(eventTrigger) || !chipTestMatterbridge || chipTestActiveEndpointId === undefined)
|
|
978
|
+
return false;
|
|
979
|
+
const endpoint = getChipTestEndpoint(chipTestMatterbridge, chipTestActiveEndpointId);
|
|
980
|
+
if (!endpoint?.hasClusterServer(WaterHeaterManagement.id))
|
|
981
|
+
return false;
|
|
982
|
+
const log = chipTestMatterbridge.log;
|
|
983
|
+
switch (eventTrigger) {
|
|
984
|
+
case normalizeTestEventTrigger(waterHeaterBasicInstallationTrigger):
|
|
985
|
+
if (endpoint.getAttribute(WaterHeaterManagement.id, 'boostState') === WaterHeaterManagement.BoostState.Active) {
|
|
986
|
+
await endpoint.invokeBehaviorCommand(WaterHeaterManagement.id, 'cancelBoost', {});
|
|
987
|
+
}
|
|
988
|
+
await endpoint.setCluster(Thermostat, { localTemperature: 2000, occupiedHeatingSetpoint: 6000 }, log);
|
|
989
|
+
await endpoint.setCluster(WaterHeaterMode, { currentMode: 11 }, log);
|
|
990
|
+
await endpoint.setCluster(WaterHeaterManagement, {
|
|
991
|
+
heatDemand: {},
|
|
992
|
+
tankVolume: 100,
|
|
993
|
+
estimatedHeatRequired: 4_646_667,
|
|
994
|
+
tankPercentage: 0,
|
|
995
|
+
boostState: WaterHeaterManagement.BoostState.Inactive,
|
|
996
|
+
}, log);
|
|
997
|
+
return true;
|
|
998
|
+
case normalizeTestEventTrigger(waterHeaterBasicInstallationClearTrigger):
|
|
999
|
+
if (endpoint.getAttribute(WaterHeaterManagement.id, 'boostState') === WaterHeaterManagement.BoostState.Active) {
|
|
1000
|
+
await endpoint.invokeBehaviorCommand(WaterHeaterManagement.id, 'cancelBoost', {});
|
|
1001
|
+
}
|
|
1002
|
+
await endpoint.setCluster(Thermostat, { localTemperature: 5000, occupiedHeatingSetpoint: 5500 }, log);
|
|
1003
|
+
await endpoint.setCluster(WaterHeaterMode, { currentMode: 1 }, log);
|
|
1004
|
+
await endpoint.setCluster(WaterHeaterManagement, {
|
|
1005
|
+
heatDemand: {},
|
|
1006
|
+
tankVolume: 100,
|
|
1007
|
+
estimatedHeatRequired: 0,
|
|
1008
|
+
tankPercentage: 90,
|
|
1009
|
+
boostState: WaterHeaterManagement.BoostState.Inactive,
|
|
1010
|
+
}, log);
|
|
1011
|
+
return true;
|
|
1012
|
+
case normalizeTestEventTrigger(waterHeaterWaterTemperature20CTrigger):
|
|
1013
|
+
await endpoint.setCluster(Thermostat, { localTemperature: 2000 }, log);
|
|
1014
|
+
await endpoint.setCluster(WaterHeaterManagement, { tankPercentage: 0 }, log);
|
|
1015
|
+
await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
|
|
1016
|
+
return true;
|
|
1017
|
+
case normalizeTestEventTrigger(waterHeaterWaterTemperature61CTrigger):
|
|
1018
|
+
await endpoint.setCluster(Thermostat, { localTemperature: 6100 }, log);
|
|
1019
|
+
await endpoint.setCluster(WaterHeaterManagement, { tankPercentage: 100 }, log);
|
|
1020
|
+
await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
|
|
1021
|
+
return true;
|
|
1022
|
+
case normalizeTestEventTrigger(waterHeaterWaterTemperature66CTrigger):
|
|
1023
|
+
await endpoint.setCluster(Thermostat, { localTemperature: 6600 }, log);
|
|
1024
|
+
await endpoint.setCluster(WaterHeaterManagement, { tankPercentage: 100 }, log);
|
|
1025
|
+
await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
|
|
1026
|
+
return true;
|
|
1027
|
+
case normalizeTestEventTrigger(waterHeaterManualModeTrigger):
|
|
1028
|
+
await endpoint.setCluster(WaterHeaterMode, { currentMode: 12 }, log);
|
|
1029
|
+
await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
|
|
1030
|
+
return true;
|
|
1031
|
+
case normalizeTestEventTrigger(waterHeaterOffModeTrigger):
|
|
1032
|
+
await endpoint.setCluster(WaterHeaterMode, { currentMode: 11 }, log);
|
|
1033
|
+
await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
|
|
1034
|
+
return true;
|
|
1035
|
+
case normalizeTestEventTrigger(waterHeaterDrawOffHotWaterTrigger): {
|
|
1036
|
+
const currentTankPercentageAttribute = endpoint.getAttribute(WaterHeaterManagement.id, 'tankPercentage');
|
|
1037
|
+
const currentTankPercentage = typeof currentTankPercentageAttribute === 'number' ? currentTankPercentageAttribute : 100;
|
|
1038
|
+
const nextTankPercentage = currentTankPercentage === 100 ? 76 : Math.floor((currentTankPercentage * 75) / 100);
|
|
1039
|
+
await endpoint.setCluster(WaterHeaterManagement, { tankPercentage: nextTankPercentage }, log);
|
|
1040
|
+
await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
|
|
1041
|
+
return true;
|
|
1042
|
+
}
|
|
1043
|
+
default:
|
|
1044
|
+
return false;
|
|
1045
|
+
}
|
|
1046
|
+
}
|
|
953
1047
|
async function handleDeviceEnergyManagementTestEventTrigger(eventTrigger) {
|
|
954
1048
|
if (eventTrigger !== deviceEnergyManagementPowerAdjustmentTrigger &&
|
|
955
1049
|
eventTrigger !== deviceEnergyManagementPowerAdjustmentClearTrigger &&
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { type Timer } from '@matter/general';
|
|
1
2
|
import { WaterHeaterManagementServer } from '@matter/node/behaviors/water-heater-management';
|
|
2
3
|
import { WaterHeaterModeServer } from '@matter/node/behaviors/water-heater-mode';
|
|
3
4
|
import { ModeBase } from '@matter/types/clusters/mode-base';
|
|
@@ -24,6 +25,8 @@ export interface WaterHeaterOptions {
|
|
|
24
25
|
maxHeatSetpointLimit?: number;
|
|
25
26
|
heaterTypes?: WaterHeaterTypes;
|
|
26
27
|
tankPercentage?: number;
|
|
28
|
+
tankVolume?: number;
|
|
29
|
+
estimatedHeatRequired?: number | bigint;
|
|
27
30
|
voltage?: number | bigint | null;
|
|
28
31
|
current?: number | bigint | null;
|
|
29
32
|
power?: number | bigint | null;
|
|
@@ -33,7 +36,7 @@ export interface WaterHeaterOptions {
|
|
|
33
36
|
}
|
|
34
37
|
export declare class WaterHeater extends MatterbridgeEndpoint {
|
|
35
38
|
constructor(name: string, serial: string, options?: WaterHeaterOptions);
|
|
36
|
-
constructor(name: string, serial: string, waterTemperature?: number, targetWaterTemperature?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, heaterTypes?: WaterHeaterTypes, tankPercentage?: number, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energy?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
|
|
39
|
+
constructor(name: string, serial: string, waterTemperature?: number, targetWaterTemperature?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, heaterTypes?: WaterHeaterTypes, tankPercentage?: number, tankVolume?: number, estimatedHeatRequired?: number | bigint, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energy?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
|
|
37
40
|
createDefaultWaterHeaterManagementClusterServer(heaterTypes?: {
|
|
38
41
|
immersionElement1?: boolean;
|
|
39
42
|
immersionElement2?: boolean;
|
|
@@ -46,13 +49,23 @@ export declare class WaterHeater extends MatterbridgeEndpoint {
|
|
|
46
49
|
heatPump?: boolean;
|
|
47
50
|
boiler?: boolean;
|
|
48
51
|
other?: boolean;
|
|
49
|
-
}, tankPercentage?: number, boostState?: WaterHeaterManagement.BoostState): this;
|
|
52
|
+
}, tankPercentage?: number, boostState?: WaterHeaterManagement.BoostState, tankVolume?: number, estimatedHeatRequired?: number | bigint): this;
|
|
50
53
|
createDefaultWaterHeaterModeClusterServer(currentMode?: number, supportedModes?: WaterHeaterMode.ModeOption[]): this;
|
|
51
54
|
}
|
|
52
55
|
export declare class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManagementServer {
|
|
56
|
+
#private;
|
|
53
57
|
readonly endpoint: MatterbridgeEndpoint;
|
|
58
|
+
protected internal: MatterbridgeWaterHeaterManagementServer.Internal;
|
|
54
59
|
boost(request: WaterHeaterManagement.BoostRequest): Promise<void>;
|
|
55
60
|
cancelBoost(): Promise<void>;
|
|
61
|
+
evaluateWaterHeaterState(): void;
|
|
62
|
+
}
|
|
63
|
+
export declare namespace MatterbridgeWaterHeaterManagementServer {
|
|
64
|
+
class Internal {
|
|
65
|
+
activeBoostInfo: WaterHeaterManagement.WaterHeaterBoostInfo | undefined;
|
|
66
|
+
boostTargetReached: boolean;
|
|
67
|
+
boostExpiryTimer: Timer | undefined;
|
|
68
|
+
}
|
|
56
69
|
}
|
|
57
70
|
export declare class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
|
|
58
71
|
readonly endpoint: MatterbridgeEndpoint;
|
|
@@ -1,15 +1,18 @@
|
|
|
1
|
+
import { Seconds, Time } from '@matter/general';
|
|
1
2
|
import { WaterHeaterManagementServer } from '@matter/node/behaviors/water-heater-management';
|
|
2
3
|
import { WaterHeaterModeServer } from '@matter/node/behaviors/water-heater-mode';
|
|
3
4
|
import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
|
|
4
5
|
import { ModeBase } from '@matter/types/clusters/mode-base';
|
|
6
|
+
import { Thermostat } from '@matter/types/clusters/thermostat';
|
|
5
7
|
import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-management';
|
|
6
8
|
import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
|
|
7
9
|
import { fireAndForget } from '@matterbridge/utils/wait';
|
|
8
10
|
import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
|
|
11
|
+
import { MatterbridgeThermostatServer } from '../behaviors/thermostatServer.js';
|
|
9
12
|
import { deviceEnergyManagement, electricalSensor, powerSource, waterHeater } from '../matterbridgeDeviceTypes.js';
|
|
10
13
|
import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
|
|
11
14
|
export class WaterHeater extends MatterbridgeEndpoint {
|
|
12
|
-
constructor(name, serial, optionsOrWaterTemperature, targetWaterTemperature = 55, minHeatSetpointLimit = 20, maxHeatSetpointLimit = 80, heaterTypes = { immersionElement1: true }, tankPercentage = 90, voltage = null, current = null, power = null, energy = null, absMinPower = 0, absMaxPower = 0) {
|
|
15
|
+
constructor(name, serial, optionsOrWaterTemperature, targetWaterTemperature = 55, minHeatSetpointLimit = 20, maxHeatSetpointLimit = 80, heaterTypes = { immersionElement1: true }, tankPercentage = 90, tankVolume = 100, estimatedHeatRequired = 0, voltage = null, current = null, power = null, energy = null, absMinPower = 0, absMaxPower = 0) {
|
|
13
16
|
const options = typeof optionsOrWaterTemperature === 'object'
|
|
14
17
|
? optionsOrWaterTemperature
|
|
15
18
|
: {
|
|
@@ -19,6 +22,8 @@ export class WaterHeater extends MatterbridgeEndpoint {
|
|
|
19
22
|
maxHeatSetpointLimit,
|
|
20
23
|
heaterTypes,
|
|
21
24
|
tankPercentage,
|
|
25
|
+
tankVolume,
|
|
26
|
+
estimatedHeatRequired,
|
|
22
27
|
voltage,
|
|
23
28
|
current,
|
|
24
29
|
power,
|
|
@@ -30,7 +35,7 @@ export class WaterHeater extends MatterbridgeEndpoint {
|
|
|
30
35
|
this.createDefaultIdentifyClusterServer()
|
|
31
36
|
.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Water Heater')
|
|
32
37
|
.createDefaultHeatingThermostatClusterServer(options.waterTemperature ?? 50, options.targetWaterTemperature ?? 55, options.minHeatSetpointLimit ?? 20, options.maxHeatSetpointLimit ?? 80)
|
|
33
|
-
.createDefaultWaterHeaterManagementClusterServer(options.heaterTypes ?? { immersionElement1: true }, {}, options.tankPercentage ?? 90)
|
|
38
|
+
.createDefaultWaterHeaterManagementClusterServer(options.heaterTypes ?? { immersionElement1: true }, {}, options.tankPercentage ?? 90, undefined, options.tankVolume ?? 100, options.estimatedHeatRequired ?? 0)
|
|
34
39
|
.createDefaultWaterHeaterModeClusterServer();
|
|
35
40
|
fireAndForget(this.addFixedLabel('composed', 'Water Heater'), this.log, 'WaterHeater addFixedLabel');
|
|
36
41
|
this.addChildDeviceType('PowerSource', powerSource).createDefaultPowerSourceWiredClusterServer().addRequiredClusterServers();
|
|
@@ -44,12 +49,14 @@ export class WaterHeater extends MatterbridgeEndpoint {
|
|
|
44
49
|
.createDefaultDeviceEnergyManagementModeClusterServer()
|
|
45
50
|
.addRequiredClusterServers();
|
|
46
51
|
}
|
|
47
|
-
createDefaultWaterHeaterManagementClusterServer(heaterTypes, heatDemand, tankPercentage, boostState) {
|
|
48
|
-
this.behaviors.require(MatterbridgeWaterHeaterManagementServer.with(WaterHeaterManagement.Feature.TankPercent), {
|
|
52
|
+
createDefaultWaterHeaterManagementClusterServer(heaterTypes, heatDemand, tankPercentage, boostState, tankVolume, estimatedHeatRequired) {
|
|
53
|
+
this.behaviors.require(MatterbridgeWaterHeaterManagementServer.with(WaterHeaterManagement.Feature.TankPercent, WaterHeaterManagement.Feature.EnergyManagement), {
|
|
49
54
|
heaterTypes: heaterTypes ?? { immersionElement1: true },
|
|
50
55
|
heatDemand: heatDemand ?? {},
|
|
51
56
|
tankPercentage: tankPercentage ?? 100,
|
|
52
57
|
boostState: boostState ?? WaterHeaterManagement.BoostState.Inactive,
|
|
58
|
+
tankVolume: tankVolume ?? 100,
|
|
59
|
+
estimatedHeatRequired: estimatedHeatRequired ?? 0,
|
|
53
60
|
});
|
|
54
61
|
return this;
|
|
55
62
|
}
|
|
@@ -88,7 +95,21 @@ export class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManageme
|
|
|
88
95
|
context: this.context,
|
|
89
96
|
});
|
|
90
97
|
device.log.debug(`MatterbridgeWaterHeaterManagementServer: boost called with: ${JSON.stringify(request)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
98
|
+
this.internal.boostExpiryTimer?.stop();
|
|
99
|
+
const boostInfo = {
|
|
100
|
+
duration: request.boostInfo.duration,
|
|
101
|
+
oneShot: request.boostInfo.oneShot === true ? true : undefined,
|
|
102
|
+
emergencyBoost: request.boostInfo.emergencyBoost === true ? true : undefined,
|
|
103
|
+
temporarySetpoint: request.boostInfo.temporarySetpoint,
|
|
104
|
+
targetPercentage: request.boostInfo.targetPercentage,
|
|
105
|
+
targetReheat: request.boostInfo.targetReheat,
|
|
106
|
+
};
|
|
107
|
+
this.internal.activeBoostInfo = boostInfo;
|
|
108
|
+
this.internal.boostTargetReached = false;
|
|
91
109
|
this.state.boostState = WaterHeaterManagement.BoostState.Active;
|
|
110
|
+
this.#updateHeatDemand();
|
|
111
|
+
this.events.boostStarted.emit({ boostInfo }, this.context);
|
|
112
|
+
this.internal.boostExpiryTimer = Time.getTimer('WaterHeaterManagement boost expiry', Seconds(request.boostInfo.duration), this.callback(this.#expireBoost, { lock: true })).start();
|
|
92
113
|
this.endpoint.emitCommand(WaterHeaterManagement, 'boost', request, this.context);
|
|
93
114
|
}
|
|
94
115
|
async cancelBoost() {
|
|
@@ -103,10 +124,84 @@ export class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManageme
|
|
|
103
124
|
context: this.context,
|
|
104
125
|
});
|
|
105
126
|
device.log.debug(`MatterbridgeWaterHeaterManagementServer: cancelBoost called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
106
|
-
this.
|
|
127
|
+
this.internal.boostExpiryTimer?.stop();
|
|
128
|
+
this.internal.boostExpiryTimer = undefined;
|
|
129
|
+
this.internal.activeBoostInfo = undefined;
|
|
130
|
+
this.internal.boostTargetReached = false;
|
|
131
|
+
if (this.state.boostState === WaterHeaterManagement.BoostState.Active) {
|
|
132
|
+
this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
|
|
133
|
+
this.#updateHeatDemand();
|
|
134
|
+
this.events.boostEnded.emit(undefined, this.context);
|
|
135
|
+
}
|
|
107
136
|
this.endpoint.emitCommand(WaterHeaterManagement, 'cancelBoost', {}, this.context);
|
|
108
137
|
}
|
|
138
|
+
evaluateWaterHeaterState() {
|
|
139
|
+
const boostInfo = this.internal.activeBoostInfo;
|
|
140
|
+
if (this.state.boostState === WaterHeaterManagement.BoostState.Active && boostInfo && this.#isBoostTargetMet(boostInfo)) {
|
|
141
|
+
this.internal.boostTargetReached = true;
|
|
142
|
+
if (boostInfo.oneShot) {
|
|
143
|
+
this.#expireBoost();
|
|
144
|
+
return;
|
|
145
|
+
}
|
|
146
|
+
}
|
|
147
|
+
this.#updateHeatDemand();
|
|
148
|
+
}
|
|
149
|
+
#expireBoost() {
|
|
150
|
+
this.internal.boostExpiryTimer?.stop();
|
|
151
|
+
this.internal.boostExpiryTimer = undefined;
|
|
152
|
+
this.internal.activeBoostInfo = undefined;
|
|
153
|
+
this.internal.boostTargetReached = false;
|
|
154
|
+
this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
|
|
155
|
+
this.#updateHeatDemand();
|
|
156
|
+
this.events.boostEnded.emit(undefined, this.context);
|
|
157
|
+
}
|
|
158
|
+
#isBoostTargetMet(boostInfo) {
|
|
159
|
+
const state = this.state;
|
|
160
|
+
if (boostInfo.targetPercentage !== undefined && state.tankPercentage !== undefined) {
|
|
161
|
+
return state.tankPercentage >= boostInfo.targetPercentage;
|
|
162
|
+
}
|
|
163
|
+
const thermostatState = this.endpoint.stateOf(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating));
|
|
164
|
+
const localTemperature = thermostatState.localTemperature ?? 0;
|
|
165
|
+
const targetSetpoint = boostInfo.temporarySetpoint ?? thermostatState.occupiedHeatingSetpoint;
|
|
166
|
+
return localTemperature >= targetSetpoint;
|
|
167
|
+
}
|
|
168
|
+
#updateHeatDemand() {
|
|
169
|
+
const state = this.state;
|
|
170
|
+
const thermostatState = this.endpoint.stateOf(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating));
|
|
171
|
+
const localTemperature = thermostatState.localTemperature ?? 0;
|
|
172
|
+
const modeState = this.endpoint.stateOf(MatterbridgeWaterHeaterModeServer);
|
|
173
|
+
const isManualMode = modeState.supportedModes.some((mode) => mode.mode === modeState.currentMode && mode.modeTags.some((tag) => tag.value === WaterHeaterMode.ModeTag.Manual));
|
|
174
|
+
let heatingRequired = isManualMode && localTemperature < thermostatState.occupiedHeatingSetpoint;
|
|
175
|
+
const boostInfo = this.internal.activeBoostInfo;
|
|
176
|
+
if (this.state.boostState === WaterHeaterManagement.BoostState.Active && boostInfo) {
|
|
177
|
+
if (boostInfo.targetPercentage !== undefined && state.tankPercentage !== undefined) {
|
|
178
|
+
const reheatThreshold = this.internal.boostTargetReached && boostInfo.targetReheat !== undefined ? boostInfo.targetReheat : boostInfo.targetPercentage;
|
|
179
|
+
heatingRequired = heatingRequired || state.tankPercentage < reheatThreshold;
|
|
180
|
+
}
|
|
181
|
+
else {
|
|
182
|
+
const targetSetpoint = boostInfo.temporarySetpoint ?? thermostatState.occupiedHeatingSetpoint;
|
|
183
|
+
heatingRequired = heatingRequired || localTemperature < targetSetpoint;
|
|
184
|
+
}
|
|
185
|
+
}
|
|
186
|
+
this.state.heatDemand = heatingRequired
|
|
187
|
+
? {
|
|
188
|
+
immersionElement1: this.state.heaterTypes.immersionElement1,
|
|
189
|
+
immersionElement2: this.state.heaterTypes.immersionElement2,
|
|
190
|
+
heatPump: this.state.heaterTypes.heatPump,
|
|
191
|
+
boiler: this.state.heaterTypes.boiler,
|
|
192
|
+
other: this.state.heaterTypes.other,
|
|
193
|
+
}
|
|
194
|
+
: {};
|
|
195
|
+
}
|
|
109
196
|
}
|
|
197
|
+
(function (MatterbridgeWaterHeaterManagementServer) {
|
|
198
|
+
class Internal {
|
|
199
|
+
activeBoostInfo;
|
|
200
|
+
boostTargetReached = false;
|
|
201
|
+
boostExpiryTimer;
|
|
202
|
+
}
|
|
203
|
+
MatterbridgeWaterHeaterManagementServer.Internal = Internal;
|
|
204
|
+
})(MatterbridgeWaterHeaterManagementServer || (MatterbridgeWaterHeaterManagementServer = {}));
|
|
110
205
|
export class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
|
|
111
206
|
async changeToMode(request) {
|
|
112
207
|
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
@@ -0,0 +1,287 @@
|
|
|
1
|
+
import path from 'node:path';
|
|
2
|
+
import { Logger, UINT16_MAX, UINT32_MAX } from '@matter/general';
|
|
3
|
+
import { ControllerBehavior, NetworkClient, ServerNode } from '@matter/node';
|
|
4
|
+
import { BasicInformationClient } from '@matter/node/behaviors/basic-information';
|
|
5
|
+
import { Read, Subscribe } from '@matter/protocol';
|
|
6
|
+
import { VendorId } from '@matter/types/datatype';
|
|
7
|
+
import { ManualPairingCodeCodec } from '@matter/types/schema';
|
|
8
|
+
import { MATTER_STORAGE_DIR } from '@matterbridge/types';
|
|
9
|
+
import { getIntParameter, getParameter, hasParameter } from '@matterbridge/utils/cli';
|
|
10
|
+
import { createDirectory } from '@matterbridge/utils/create-dir';
|
|
11
|
+
import { getErrorMessage } from '@matterbridge/utils/error';
|
|
12
|
+
import { isValidInteger, isValidString, parseVersionString } from '@matterbridge/utils/validate';
|
|
13
|
+
import { debugStringify } from 'node-ansi-logger';
|
|
14
|
+
export async function startController(matterbridge, environment) {
|
|
15
|
+
if (!matterbridge.matterStorageService) {
|
|
16
|
+
throw new Error('No storage service initialized');
|
|
17
|
+
}
|
|
18
|
+
await createDirectory(path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR, 'MatterbridgeController'), `Matter node storage directory for MatterbridgeController`, matterbridge.log);
|
|
19
|
+
matterbridge.controllerStorageManager = await matterbridge.matterStorageService.open('MatterbridgeController');
|
|
20
|
+
matterbridge.log.info('Matter node storage manager "MatterbridgeController" created');
|
|
21
|
+
if (hasParameter('reset')) {
|
|
22
|
+
const driver = matterbridge.controllerStorageManager.driver;
|
|
23
|
+
for (const context of await driver.contexts([])) {
|
|
24
|
+
await driver.clearAll([context]);
|
|
25
|
+
}
|
|
26
|
+
for (const key of await driver.keys([])) {
|
|
27
|
+
await driver.delete([], key);
|
|
28
|
+
}
|
|
29
|
+
matterbridge.log.notice('MatterbridgeController storage reset; remote device fabrics are unchanged');
|
|
30
|
+
return;
|
|
31
|
+
}
|
|
32
|
+
matterbridge.log.info('Creating context controllerContext...');
|
|
33
|
+
matterbridge.controllerContext = matterbridge.controllerStorageManager.createContext('controllerContext');
|
|
34
|
+
if (!matterbridge.controllerContext) {
|
|
35
|
+
matterbridge.log.error('No storage context controllerContext initialized');
|
|
36
|
+
return;
|
|
37
|
+
}
|
|
38
|
+
const { randomBytes } = await import('node:crypto');
|
|
39
|
+
const storeId = 'MatterbridgeController';
|
|
40
|
+
const random = randomBytes(8).toString('hex');
|
|
41
|
+
await matterbridge.controllerContext.set('storeId', storeId);
|
|
42
|
+
await matterbridge.controllerContext.set('vendorId', matterbridge.controllerVendorId);
|
|
43
|
+
await matterbridge.controllerContext.set('vendorName', matterbridge.controllerVendorName.slice(0, 32));
|
|
44
|
+
await matterbridge.controllerContext.set('productId', matterbridge.controllerProductId);
|
|
45
|
+
await matterbridge.controllerContext.set('productName', matterbridge.controllerProductName.slice(0, 32));
|
|
46
|
+
await matterbridge.controllerContext.set('productLabel', matterbridge.controllerProductName.replace(matterbridge.controllerVendorName, '').trim().slice(0, 32));
|
|
47
|
+
await matterbridge.controllerContext.set('nodeLabel', storeId.slice(0, 32));
|
|
48
|
+
await matterbridge.controllerContext.set('serialNumber', await matterbridge.controllerContext.get('serialNumber', 'SN' + random));
|
|
49
|
+
await matterbridge.controllerContext.set('uniqueId', await matterbridge.controllerContext.get('uniqueId', 'UI' + random));
|
|
50
|
+
await matterbridge.controllerContext.set('softwareVersion', isValidInteger(parseVersionString(matterbridge.matterbridgeVersion), 0, UINT32_MAX) ? parseVersionString(matterbridge.matterbridgeVersion) : 1);
|
|
51
|
+
await matterbridge.controllerContext.set('softwareVersionString', isValidString(matterbridge.matterbridgeVersion, 5, 64) ? matterbridge.matterbridgeVersion : '1.0.0');
|
|
52
|
+
await matterbridge.controllerContext.set('hardwareVersion', isValidInteger(parseVersionString(matterbridge.systemInformation.osRelease), 0, UINT16_MAX) ? parseVersionString(matterbridge.systemInformation.osRelease) : 1);
|
|
53
|
+
await matterbridge.controllerContext.set('hardwareVersionString', isValidString(matterbridge.systemInformation.osRelease, 5, 64) ? matterbridge.systemInformation.osRelease : '1.0.0');
|
|
54
|
+
matterbridge.log.info('Creating matter commissioning controller...');
|
|
55
|
+
matterbridge.controllerNode = await ServerNode.create(ServerNode.RootEndpointWithoutGroupcast.with(ControllerBehavior), {
|
|
56
|
+
commissioning: { enabled: false },
|
|
57
|
+
controller: { adminFabricLabel: matterbridge.controllerProductName.slice(0, 32) },
|
|
58
|
+
subscriptions: { persistenceEnabled: false },
|
|
59
|
+
id: storeId,
|
|
60
|
+
environment: environment,
|
|
61
|
+
network: {
|
|
62
|
+
autoStartCommissionedPeers: false,
|
|
63
|
+
listeningAddressIpv4: matterbridge.ipv4Address,
|
|
64
|
+
listeningAddressIpv6: matterbridge.ipv6Address,
|
|
65
|
+
port: getIntParameter('port'),
|
|
66
|
+
},
|
|
67
|
+
basicInformation: {
|
|
68
|
+
nodeLabel: await matterbridge.controllerContext.get('nodeLabel'),
|
|
69
|
+
vendorId: VendorId(await matterbridge.controllerContext.get('vendorId')),
|
|
70
|
+
vendorName: await matterbridge.controllerContext.get('vendorName'),
|
|
71
|
+
productId: await matterbridge.controllerContext.get('productId'),
|
|
72
|
+
productName: await matterbridge.controllerContext.get('productName'),
|
|
73
|
+
productLabel: await matterbridge.controllerContext.get('productLabel'),
|
|
74
|
+
serialNumber: await matterbridge.controllerContext.get('serialNumber'),
|
|
75
|
+
uniqueId: await matterbridge.controllerContext.get('uniqueId'),
|
|
76
|
+
softwareVersion: await matterbridge.controllerContext.get('softwareVersion'),
|
|
77
|
+
softwareVersionString: await matterbridge.controllerContext.get('softwareVersionString'),
|
|
78
|
+
hardwareVersion: await matterbridge.controllerContext.get('hardwareVersion'),
|
|
79
|
+
hardwareVersionString: await matterbridge.controllerContext.get('hardwareVersionString'),
|
|
80
|
+
reachable: true,
|
|
81
|
+
},
|
|
82
|
+
});
|
|
83
|
+
await matterbridge.controllerNode.start();
|
|
84
|
+
matterbridge.log.info(`Loaded matter commissioning controller with ${matterbridge.controllerNode.peers.size} peer nodes.`);
|
|
85
|
+
const requestedNodeId = getIntParameter('node');
|
|
86
|
+
const nodeLabel = requestedNodeId === undefined ? undefined : `Node ${requestedNodeId}`;
|
|
87
|
+
const peerId = requestedNodeId === undefined ? undefined : `peer${requestedNodeId}`;
|
|
88
|
+
if (hasParameter('pair')) {
|
|
89
|
+
let options;
|
|
90
|
+
if (hasParameter('pairingcode')) {
|
|
91
|
+
const pairingCode = getParameter('pairingcode');
|
|
92
|
+
if (!pairingCode) {
|
|
93
|
+
matterbridge.log.error('Missing parameter --pairingcode');
|
|
94
|
+
return;
|
|
95
|
+
}
|
|
96
|
+
matterbridge.log.info(`Pairing device ${nodeLabel} with pairingcode: ${pairingCode}`);
|
|
97
|
+
const pairingData = ManualPairingCodeCodec.decode(pairingCode);
|
|
98
|
+
matterbridge.log.info(`- passcode: ${pairingData.passcode}`);
|
|
99
|
+
matterbridge.log.info(`- shortDiscriminator: ${pairingData.shortDiscriminator ?? 'n/a (should never be n/a, short discriminator is encoded in the manual pairing code)'} `);
|
|
100
|
+
matterbridge.log.info(`- longDiscriminator: ${pairingData.discriminator ?? 'n/a (manual pairing code encodes short discriminator only)'}`);
|
|
101
|
+
matterbridge.log.info(`- vendorId: ${pairingData.vendorId ?? 'n/a'}`);
|
|
102
|
+
matterbridge.log.info(`- productId: ${pairingData.productId ?? 'n/a'}`);
|
|
103
|
+
options = {
|
|
104
|
+
id: peerId,
|
|
105
|
+
pairingCode,
|
|
106
|
+
...(pairingData.shortDiscriminator === undefined ? {} : { shortDiscriminator: pairingData.shortDiscriminator }),
|
|
107
|
+
...(pairingData.vendorId === undefined ? {} : { vendorId: pairingData.vendorId }),
|
|
108
|
+
...(pairingData.productId === undefined ? {} : { productId: pairingData.productId }),
|
|
109
|
+
};
|
|
110
|
+
}
|
|
111
|
+
else {
|
|
112
|
+
const discriminator = getIntParameter('discriminator');
|
|
113
|
+
const passcode = getIntParameter('passcode') ?? 0;
|
|
114
|
+
matterbridge.log.info(`Pairing device ${nodeLabel} with discriminator: ${discriminator}, passcode: ${passcode}`);
|
|
115
|
+
options = { id: peerId, discriminator, passcode };
|
|
116
|
+
}
|
|
117
|
+
matterbridge.log.notice(`Commissioning node ${nodeLabel} with options: ${debugStringify(options)}`);
|
|
118
|
+
try {
|
|
119
|
+
const commissionedNode = await matterbridge.controllerNode.peers.commission(options);
|
|
120
|
+
matterbridge.log.notice(`Commissioning successfully done for node ${commissionedNode.id}`);
|
|
121
|
+
}
|
|
122
|
+
catch (error) {
|
|
123
|
+
matterbridge.log.error(`Commissioning failed for node ${nodeLabel}: ${getErrorMessage(error)}`);
|
|
124
|
+
}
|
|
125
|
+
}
|
|
126
|
+
else if (hasParameter('discover')) {
|
|
127
|
+
matterbridge.log.info('Discovering commissionable devices...');
|
|
128
|
+
const discovery = matterbridge.controllerNode.peers.discover();
|
|
129
|
+
discovery.catch((error) => matterbridge.log.error(`Discovery failed: ${getErrorMessage(error)}`));
|
|
130
|
+
discovery.discovered.on((node) => {
|
|
131
|
+
matterbridge.log.info(`Discovered commissionable device: ${node.id}`);
|
|
132
|
+
});
|
|
133
|
+
}
|
|
134
|
+
else if (hasParameter('peers')) {
|
|
135
|
+
const peers = matterbridge.controllerNode.peers;
|
|
136
|
+
matterbridge.log.info(`Matter commissioning controller known nodes: ${peers.size}, paired nodes: ${peers.commissioned.length}`);
|
|
137
|
+
for (const peer of peers) {
|
|
138
|
+
const match = /^peer(\d+)$/.exec(peer.id);
|
|
139
|
+
const status = peer.lifecycle.isCommissioned ? 'commissioned' : 'discovered';
|
|
140
|
+
matterbridge.log.info(`- ${match ? `Node ${match[1]}` : peer.id} (${status})`);
|
|
141
|
+
}
|
|
142
|
+
}
|
|
143
|
+
else if (hasParameter('unpair')) {
|
|
144
|
+
const requestedNodeId = getIntParameter('node');
|
|
145
|
+
if (requestedNodeId === undefined) {
|
|
146
|
+
matterbridge.log.error('Missing parameter --node for --unpair');
|
|
147
|
+
return;
|
|
148
|
+
}
|
|
149
|
+
const nodeLabel = `Node ${requestedNodeId}`;
|
|
150
|
+
const peerId = `peer${requestedNodeId}`;
|
|
151
|
+
matterbridge.log.info(`Matter commissioning controller decommissioning node: ${nodeLabel}`);
|
|
152
|
+
const peers = matterbridge.controllerNode.peers;
|
|
153
|
+
for (const peer of peers) {
|
|
154
|
+
if (peer.id === peerId) {
|
|
155
|
+
await (peer.stateOf(NetworkClient).isDisabled ? peer.enable() : peer.start());
|
|
156
|
+
await peer.decommission();
|
|
157
|
+
matterbridge.log.info(`Matter commissioning controller decommissioned node: ${nodeLabel}`);
|
|
158
|
+
return;
|
|
159
|
+
}
|
|
160
|
+
}
|
|
161
|
+
matterbridge.log.warn(`Matter commissioning controller node not found: ${nodeLabel}`);
|
|
162
|
+
}
|
|
163
|
+
else if (hasParameter('unpairall')) {
|
|
164
|
+
matterbridge.log.info('Matter commissioning controller decommissioning all nodes...');
|
|
165
|
+
const nodeIds = [...matterbridge.controllerNode.peers.commissioned];
|
|
166
|
+
for (const nodeId of nodeIds) {
|
|
167
|
+
matterbridge.log.info('Matter commissioning controller decommissioning node:', nodeId.id);
|
|
168
|
+
await (nodeId.stateOf(NetworkClient).isDisabled ? nodeId.enable() : nodeId.start());
|
|
169
|
+
await nodeId.decommission();
|
|
170
|
+
}
|
|
171
|
+
matterbridge.log.info('Matter commissioning controller decommissioned all nodes');
|
|
172
|
+
}
|
|
173
|
+
else {
|
|
174
|
+
matterbridge.log.info('Starting matter commissioning controller...');
|
|
175
|
+
matterbridge.log.info(`Matter commissioning controller started with ${matterbridge.controllerNode.peers.commissioned.length} paired nodes`);
|
|
176
|
+
const tracerSubscriptions = new Map();
|
|
177
|
+
const peersToStart = [];
|
|
178
|
+
if (peerId) {
|
|
179
|
+
const peer = matterbridge.controllerNode.peers.get(peerId);
|
|
180
|
+
if (peer) {
|
|
181
|
+
peersToStart.push(peer);
|
|
182
|
+
}
|
|
183
|
+
else {
|
|
184
|
+
matterbridge.log.warn(`Matter commissioning controller peer not found: ${nodeLabel}`);
|
|
185
|
+
}
|
|
186
|
+
}
|
|
187
|
+
else {
|
|
188
|
+
for (const peer of matterbridge.controllerNode.peers.commissioned) {
|
|
189
|
+
peersToStart.push(peer);
|
|
190
|
+
}
|
|
191
|
+
}
|
|
192
|
+
for (const peer of peersToStart) {
|
|
193
|
+
const match = /^peer(\d+)$/.exec(peer.id);
|
|
194
|
+
const startedLabel = match ? `Node ${match[1]}` : peer.id;
|
|
195
|
+
peer.lifecycle.online.on(() => {
|
|
196
|
+
matterbridge.log.notice(`Matter commissioning controller peer ${startedLabel} is online`);
|
|
197
|
+
if (peer.stateOf(NetworkClient).autoSubscribe) {
|
|
198
|
+
matterbridge.log.info(`Matter commissioning controller autoSubscribe is enabled for peer ${startedLabel}`);
|
|
199
|
+
}
|
|
200
|
+
else {
|
|
201
|
+
matterbridge.log.info(`Matter commissioning controller setting autoSubscribe for peer ${startedLabel}`);
|
|
202
|
+
peer.setStateOf(NetworkClient, { autoSubscribe: true }).catch((error) => {
|
|
203
|
+
matterbridge.log.error(`Failed to set autoSubscribe for peer ${startedLabel}: ${getErrorMessage(error)}`);
|
|
204
|
+
});
|
|
205
|
+
}
|
|
206
|
+
if (hasParameter('trace-peer') && !tracerSubscriptions.has(peer.id)) {
|
|
207
|
+
matterbridge.log.info(`Matter commissioning controller enabling trace-peer for ${startedLabel}`);
|
|
208
|
+
const subscribe = Subscribe({
|
|
209
|
+
fabricFilter: true,
|
|
210
|
+
keepSubscriptions: true,
|
|
211
|
+
attributes: [{}],
|
|
212
|
+
events: [{ isUrgent: true }],
|
|
213
|
+
});
|
|
214
|
+
const subscriptionPromise = peer.interaction.subscribe({
|
|
215
|
+
...subscribe,
|
|
216
|
+
updated: async (update) => {
|
|
217
|
+
for await (const chunk of update) {
|
|
218
|
+
for await (const report of chunk) {
|
|
219
|
+
if (report.kind === 'attr-value') {
|
|
220
|
+
matterbridge.log.info(`Peer ${startedLabel} attr ${report.path.endpointId}/${report.path.clusterId}/${report.path.attributeId} v${report.version}: ${debugStringify(report.value ?? { none: true })}`);
|
|
221
|
+
}
|
|
222
|
+
else if (report.kind === 'event-value') {
|
|
223
|
+
matterbridge.log.info(`Peer ${startedLabel} event ${report.path.endpointId}/${report.path.clusterId}/${report.path.eventId} #${report.number}: ${debugStringify(report.value ?? { none: true })}`);
|
|
224
|
+
}
|
|
225
|
+
else if (report.kind === 'attr-status') {
|
|
226
|
+
matterbridge.log.warn(`Peer ${startedLabel} attr-status ${report.path.endpointId}/${report.path.clusterId}/${report.path.attributeId}: ${String(report.status)}`);
|
|
227
|
+
}
|
|
228
|
+
else if (report.kind === 'event-status') {
|
|
229
|
+
matterbridge.log.warn(`Peer ${startedLabel} event-status ${report.path.endpointId}/${report.path.clusterId}/${report.path.eventId}: ${String(report.status)}`);
|
|
230
|
+
}
|
|
231
|
+
}
|
|
232
|
+
}
|
|
233
|
+
},
|
|
234
|
+
closed: () => {
|
|
235
|
+
matterbridge.log.warn(`Matter commissioning controller trace-peer subscription closed for ${startedLabel}`);
|
|
236
|
+
tracerSubscriptions.delete(peer.id);
|
|
237
|
+
},
|
|
238
|
+
});
|
|
239
|
+
tracerSubscriptions.set(peer.id, subscriptionPromise);
|
|
240
|
+
subscriptionPromise.catch((error) => {
|
|
241
|
+
tracerSubscriptions.delete(peer.id);
|
|
242
|
+
matterbridge.log.error(`Matter commissioning controller trace-peer subscription failed for ${startedLabel}: ${getErrorMessage(error)}`);
|
|
243
|
+
});
|
|
244
|
+
}
|
|
245
|
+
if (hasParameter('dump-peer')) {
|
|
246
|
+
void (async () => {
|
|
247
|
+
try {
|
|
248
|
+
for await (const chunk of peer.interaction.read(Read({ fabricFilter: true, attributes: [{}] }))) {
|
|
249
|
+
for await (const _report of chunk) {
|
|
250
|
+
}
|
|
251
|
+
}
|
|
252
|
+
const basicInfo = peer.stateOf(BasicInformationClient);
|
|
253
|
+
Logger.get(`BasicInformation: ${startedLabel}`).info(basicInfo);
|
|
254
|
+
}
|
|
255
|
+
catch (error) {
|
|
256
|
+
matterbridge.log.error(`Matter commissioning controller dump-peer failed for ${startedLabel}: ${getErrorMessage(error)}`);
|
|
257
|
+
}
|
|
258
|
+
})();
|
|
259
|
+
}
|
|
260
|
+
});
|
|
261
|
+
peer.lifecycle.offline.on(() => {
|
|
262
|
+
matterbridge.log.warn(`Matter commissioning controller peer ${startedLabel} is offline`);
|
|
263
|
+
});
|
|
264
|
+
peer.eventsOf(NetworkClient).autoSubscribe$Changed.on((value, oldValue) => {
|
|
265
|
+
matterbridge.log.info(`Matter commissioning controller peer ${startedLabel} autoSubscribe changed from ${oldValue ? 'active' : 'inactive'} to ${value ? 'active' : 'inactive'}`);
|
|
266
|
+
});
|
|
267
|
+
peer.eventsOf(NetworkClient).defaultSubscription$Changed.on((value, oldValue) => {
|
|
268
|
+
matterbridge.log.info(`Matter commissioning controller peer ${startedLabel} defaultSubscription changed from ${oldValue ? 'active' : 'inactive'} to ${value ? 'active' : 'inactive'}`);
|
|
269
|
+
});
|
|
270
|
+
peer.eventsOf(NetworkClient).subscriptionStatusChanged.on((isActive) => {
|
|
271
|
+
matterbridge.log.info(`Matter commissioning controller peer ${startedLabel} subscription is ${isActive ? 'active' : 'inactive'}`);
|
|
272
|
+
});
|
|
273
|
+
peer.eventsOf(NetworkClient).subscriptionAlive.on(() => {
|
|
274
|
+
matterbridge.log.info(`Matter commissioning controller peer ${startedLabel} subscription alive event received`);
|
|
275
|
+
});
|
|
276
|
+
matterbridge.log.notice(`Starting matter commissioning controller peer ${startedLabel}...`);
|
|
277
|
+
(peer.stateOf(NetworkClient).isDisabled ? peer.enable() : peer.start())
|
|
278
|
+
.then(() => {
|
|
279
|
+
matterbridge.log.notice(`Matter commissioning controller peer ${startedLabel} started successfully`);
|
|
280
|
+
return;
|
|
281
|
+
})
|
|
282
|
+
.catch((error) => {
|
|
283
|
+
matterbridge.log.error(`Matter commissioning controller failed to start peer ${startedLabel}: ${getErrorMessage(error)}`);
|
|
284
|
+
});
|
|
285
|
+
}
|
|
286
|
+
}
|
|
287
|
+
}
|
package/dist/matterbridge.d.ts
CHANGED
|
@@ -100,6 +100,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
|
|
|
100
100
|
matterStorageManager: StorageManager | undefined;
|
|
101
101
|
private serverNodeStorageManagers;
|
|
102
102
|
matterbridgeContext: StorageContext | undefined;
|
|
103
|
+
controllerStorageManager: StorageManager | undefined;
|
|
103
104
|
controllerContext: StorageContext | undefined;
|
|
104
105
|
mdnsInterface: string | undefined;
|
|
105
106
|
ipv4Address: string | undefined;
|
|
@@ -152,7 +153,6 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
|
|
|
152
153
|
private sendPluginStatusUpdate;
|
|
153
154
|
private startBridge;
|
|
154
155
|
private startChildbridge;
|
|
155
|
-
private startController;
|
|
156
156
|
private startMatterStorage;
|
|
157
157
|
private backupMatterStorage;
|
|
158
158
|
private stopMatterStorage;
|
package/dist/matterbridge.js
CHANGED
|
@@ -33,6 +33,7 @@ import { Frontend } from './frontend.js';
|
|
|
33
33
|
import { addVirtualDevice, addVirtualDevices, resolveRootDirectory } from './helpers.js';
|
|
34
34
|
import { bridge } from './matterbridgeDeviceTypes.js';
|
|
35
35
|
import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
|
|
36
|
+
import { startController } from './matterController.js';
|
|
36
37
|
import { clearAdvertisingNodes, deleteAdvertisingNode, getServerNodeData, setAdvertisingNode } from './matterNodeHelpers.js';
|
|
37
38
|
import { PluginManager } from './pluginManager.js';
|
|
38
39
|
logModuleLoaded('Matterbridge');
|
|
@@ -141,6 +142,7 @@ export class Matterbridge extends EventEmitter {
|
|
|
141
142
|
matterStorageManager;
|
|
142
143
|
serverNodeStorageManagers = new Map();
|
|
143
144
|
matterbridgeContext;
|
|
145
|
+
controllerStorageManager;
|
|
144
146
|
controllerContext;
|
|
145
147
|
mdnsInterface;
|
|
146
148
|
ipv4Address;
|
|
@@ -950,8 +952,9 @@ export class Matterbridge extends EventEmitter {
|
|
|
950
952
|
this.shutdown = true;
|
|
951
953
|
return;
|
|
952
954
|
}
|
|
953
|
-
if ((
|
|
955
|
+
if (!hasParameter('controller') && !hasParameter('experimental-backend') && getIntParameter('frontend') !== 0) {
|
|
954
956
|
await this.frontend.start(getIntParameter('frontend'));
|
|
957
|
+
}
|
|
955
958
|
if (!hasParameter('experimental-node')) {
|
|
956
959
|
try {
|
|
957
960
|
await this.startMatterStorage();
|
|
@@ -968,6 +971,13 @@ export class Matterbridge extends EventEmitter {
|
|
|
968
971
|
throw new Error(`Fatal error creating matter storage: ${getErrorMessage(error)}`, { cause: error });
|
|
969
972
|
}
|
|
970
973
|
}
|
|
974
|
+
if (hasParameter('controller') && hasParameter('reset')) {
|
|
975
|
+
this.bridgeMode = 'controller';
|
|
976
|
+
await startController(this, this.environment);
|
|
977
|
+
await this.stopMatterStorage();
|
|
978
|
+
this.shutdown = true;
|
|
979
|
+
return;
|
|
980
|
+
}
|
|
971
981
|
if (hasParameter('reset') && getParameter('reset') === undefined) {
|
|
972
982
|
this.initialized = true;
|
|
973
983
|
await this.shutdownProcessAndReset();
|
|
@@ -1026,7 +1036,7 @@ export class Matterbridge extends EventEmitter {
|
|
|
1026
1036
|
}
|
|
1027
1037
|
if (hasParameter('controller')) {
|
|
1028
1038
|
this.bridgeMode = 'controller';
|
|
1029
|
-
await this.
|
|
1039
|
+
await startController(this, this.environment);
|
|
1030
1040
|
return;
|
|
1031
1041
|
}
|
|
1032
1042
|
if (!hasParameter('bridge') && !hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === '') {
|
|
@@ -1873,8 +1883,6 @@ export class Matterbridge extends EventEmitter {
|
|
|
1873
1883
|
})();
|
|
1874
1884
|
}, Number(process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS']) || this.startMatterIntervalMs);
|
|
1875
1885
|
}
|
|
1876
|
-
async startController() {
|
|
1877
|
-
}
|
|
1878
1886
|
async startMatterStorage() {
|
|
1879
1887
|
this.log.info(`Starting matter node storage...`);
|
|
1880
1888
|
this.matterStorageService = this.environment.get(StorageService);
|
|
@@ -1904,6 +1912,9 @@ export class Matterbridge extends EventEmitter {
|
|
|
1904
1912
|
}
|
|
1905
1913
|
async stopMatterStorage() {
|
|
1906
1914
|
this.log.info('Closing matter node storage...');
|
|
1915
|
+
await this.controllerStorageManager?.close();
|
|
1916
|
+
this.controllerStorageManager = undefined;
|
|
1917
|
+
this.controllerContext = undefined;
|
|
1907
1918
|
await this.matterStorageManager?.close();
|
|
1908
1919
|
for (const [storeId, storageManager] of this.serverNodeStorageManagers) {
|
|
1909
1920
|
this.log.debug(`Closing server node storage context manager for ${plg}${storeId}${db}...`);
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@matterbridge/core",
|
|
3
|
-
"version": "3.11.1-dev-20261030-
|
|
3
|
+
"version": "3.11.1-dev-20261030-65deb56",
|
|
4
4
|
"description": "Matterbridge core library",
|
|
5
5
|
"author": "https://github.com/Luligu",
|
|
6
6
|
"homepage": "https://matterbridge.io/",
|
|
@@ -136,10 +136,10 @@
|
|
|
136
136
|
},
|
|
137
137
|
"dependencies": {
|
|
138
138
|
"@matter/main": "0.18.0",
|
|
139
|
-
"@matterbridge/dgram": "3.11.1-dev-20261030-
|
|
140
|
-
"@matterbridge/thread": "3.11.1-dev-20261030-
|
|
141
|
-
"@matterbridge/types": "3.11.1-dev-20261030-
|
|
142
|
-
"@matterbridge/utils": "3.11.1-dev-20261030-
|
|
139
|
+
"@matterbridge/dgram": "3.11.1-dev-20261030-65deb56",
|
|
140
|
+
"@matterbridge/thread": "3.11.1-dev-20261030-65deb56",
|
|
141
|
+
"@matterbridge/types": "3.11.1-dev-20261030-65deb56",
|
|
142
|
+
"@matterbridge/utils": "3.11.1-dev-20261030-65deb56",
|
|
143
143
|
"escape-html": "1.0.3",
|
|
144
144
|
"express": "5.3.0",
|
|
145
145
|
"express-rate-limit": "8.7.1",
|