@matterbridge/core 3.10.9-dev-20260905-a9a75f8 → 3.10.9-dev-20260907-5fcc59a
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/bindingServer.js +6 -6
- package/dist/behaviors/colorControlServer.js +54 -54
- package/dist/behaviors/deviceEnergyManagementModeServer.js +3 -3
- package/dist/behaviors/deviceEnergyManagementServer.d.ts +0 -1
- package/dist/behaviors/deviceEnergyManagementServer.js +9 -13
- package/dist/behaviors/fanControlServer.js +15 -14
- package/dist/behaviors/identifyServer.js +4 -4
- package/dist/behaviors/levelControlServer.js +24 -24
- package/dist/behaviors/matterbridgeServer.js +1 -1
- package/dist/behaviors/modeSelectServer.js +2 -2
- package/dist/behaviors/occupancySensingServer.js +3 -0
- package/dist/behaviors/onOffServer.js +18 -18
- package/dist/behaviors/pumpConfigurationAndControlServer.js +1 -1
- package/dist/behaviors/serviceAreaServer.js +2 -2
- package/dist/behaviors/smokeCoAlarmServer.js +3 -3
- package/dist/behaviors/switchServer.js +1 -1
- package/dist/behaviors/valveConfigurationAndControlServer.js +7 -7
- package/dist/chipTests.js +47 -5
- package/dist/demoDevices.js +14 -0
- package/dist/devices/evse.d.ts +28 -5
- package/dist/devices/evse.js +145 -30
- package/dist/matterbridgeEndpointCommandHandler.d.ts +8 -0
- package/package.json +5 -5
|
@@ -3,7 +3,7 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
|
|
|
3
3
|
export class MatterbridgeIdentifyServer extends IdentifyServer {
|
|
4
4
|
async identify(request) {
|
|
5
5
|
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
6
|
-
device.log.info(`
|
|
6
|
+
device.log.info(`MatterbridgeIdentifyServer: identifying device for ${request.identifyTime} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
7
7
|
await device.commandHandler.executeHandler('Identify.identify', {
|
|
8
8
|
command: 'identify',
|
|
9
9
|
request,
|
|
@@ -12,12 +12,12 @@ export class MatterbridgeIdentifyServer extends IdentifyServer {
|
|
|
12
12
|
endpoint: this.endpoint,
|
|
13
13
|
context: this.context,
|
|
14
14
|
});
|
|
15
|
-
device.log.debug(`MatterbridgeIdentifyServer: identify called`);
|
|
15
|
+
device.log.debug(`MatterbridgeIdentifyServer: identify called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
16
16
|
await super.identify(request);
|
|
17
17
|
}
|
|
18
18
|
async triggerEffect(request) {
|
|
19
19
|
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
20
|
-
device.log.info(`
|
|
20
|
+
device.log.info(`MatterbridgeIdentifyServer: triggering effect ${request.effectIdentifier} variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
21
21
|
await device.commandHandler.executeHandler('Identify.triggerEffect', {
|
|
22
22
|
command: 'triggerEffect',
|
|
23
23
|
request,
|
|
@@ -26,7 +26,7 @@ export class MatterbridgeIdentifyServer extends IdentifyServer {
|
|
|
26
26
|
endpoint: this.endpoint,
|
|
27
27
|
context: this.context,
|
|
28
28
|
});
|
|
29
|
-
device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called`);
|
|
29
|
+
device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
30
30
|
await super.triggerEffect(request);
|
|
31
31
|
}
|
|
32
32
|
}
|
|
@@ -7,12 +7,12 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
|
|
|
7
7
|
return super.initialize();
|
|
8
8
|
}
|
|
9
9
|
async moveToLevel(request) {
|
|
10
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
11
|
-
device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
12
10
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
13
11
|
await super.moveToLevel(request);
|
|
14
12
|
return;
|
|
15
13
|
}
|
|
14
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
15
|
+
device.log.info(`MatterbridgeLevelControlServer: setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
16
16
|
await device.commandHandler.executeHandler('LevelControl.moveToLevel', {
|
|
17
17
|
command: 'moveToLevel',
|
|
18
18
|
request,
|
|
@@ -21,16 +21,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
|
|
|
21
21
|
endpoint: this.endpoint,
|
|
22
22
|
context: this.context,
|
|
23
23
|
});
|
|
24
|
-
device.log.debug(`MatterbridgeLevelControlServer: moveToLevel called`);
|
|
24
|
+
device.log.debug(`MatterbridgeLevelControlServer: moveToLevel called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
25
25
|
await super.moveToLevel(request);
|
|
26
26
|
}
|
|
27
27
|
async moveToLevelWithOnOff(request) {
|
|
28
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
29
|
-
device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
30
28
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
31
29
|
await super.moveToLevelWithOnOff(request);
|
|
32
30
|
return;
|
|
33
31
|
}
|
|
32
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
33
|
+
device.log.info(`MatterbridgeLevelControlServer: setting level with on/off to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
34
34
|
await device.commandHandler.executeHandler('LevelControl.moveToLevelWithOnOff', {
|
|
35
35
|
command: 'moveToLevelWithOnOff',
|
|
36
36
|
request,
|
|
@@ -39,16 +39,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
|
|
|
39
39
|
endpoint: this.endpoint,
|
|
40
40
|
context: this.context,
|
|
41
41
|
});
|
|
42
|
-
device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called`);
|
|
42
|
+
device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
43
43
|
await super.moveToLevelWithOnOff(request);
|
|
44
44
|
}
|
|
45
45
|
async move(request) {
|
|
46
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
47
|
-
device.log.info(`Moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
48
46
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
49
47
|
await super.move(request);
|
|
50
48
|
return;
|
|
51
49
|
}
|
|
50
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
51
|
+
device.log.info(`MatterbridgeLevelControlServer: moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
52
52
|
await device.commandHandler.executeHandler('LevelControl.move', {
|
|
53
53
|
command: 'move',
|
|
54
54
|
request,
|
|
@@ -57,16 +57,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
|
|
|
57
57
|
endpoint: this.endpoint,
|
|
58
58
|
context: this.context,
|
|
59
59
|
});
|
|
60
|
-
device.log.debug(`MatterbridgeLevelControlServer: move called`);
|
|
60
|
+
device.log.debug(`MatterbridgeLevelControlServer: move called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
61
61
|
await super.move(request);
|
|
62
62
|
}
|
|
63
63
|
async moveWithOnOff(request) {
|
|
64
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
65
|
-
device.log.info(`Moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
66
64
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
67
65
|
await super.moveWithOnOff(request);
|
|
68
66
|
return;
|
|
69
67
|
}
|
|
68
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
69
|
+
device.log.info(`MatterbridgeLevelControlServer: moving level with on/off with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
70
70
|
await device.commandHandler.executeHandler('LevelControl.moveWithOnOff', {
|
|
71
71
|
command: 'moveWithOnOff',
|
|
72
72
|
request,
|
|
@@ -75,16 +75,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
|
|
|
75
75
|
endpoint: this.endpoint,
|
|
76
76
|
context: this.context,
|
|
77
77
|
});
|
|
78
|
-
device.log.debug(`MatterbridgeLevelControlServer: moveWithOnOff called`);
|
|
78
|
+
device.log.debug(`MatterbridgeLevelControlServer: moveWithOnOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
79
79
|
await super.moveWithOnOff(request);
|
|
80
80
|
}
|
|
81
81
|
async step(request) {
|
|
82
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
83
|
-
device.log.info(`Stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
84
82
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
85
83
|
await super.step(request);
|
|
86
84
|
return;
|
|
87
85
|
}
|
|
86
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
87
|
+
device.log.info(`MatterbridgeLevelControlServer: stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
88
88
|
await device.commandHandler.executeHandler('LevelControl.step', {
|
|
89
89
|
command: 'step',
|
|
90
90
|
request,
|
|
@@ -93,16 +93,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
|
|
|
93
93
|
endpoint: this.endpoint,
|
|
94
94
|
context: this.context,
|
|
95
95
|
});
|
|
96
|
-
device.log.debug(`MatterbridgeLevelControlServer: step called`);
|
|
96
|
+
device.log.debug(`MatterbridgeLevelControlServer: step called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
97
97
|
await super.step(request);
|
|
98
98
|
}
|
|
99
99
|
async stepWithOnOff(request) {
|
|
100
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
101
|
-
device.log.info(`Stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
102
100
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
103
101
|
await super.stepWithOnOff(request);
|
|
104
102
|
return;
|
|
105
103
|
}
|
|
104
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
105
|
+
device.log.info(`MatterbridgeLevelControlServer: stepping level with on/off with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
106
106
|
await device.commandHandler.executeHandler('LevelControl.stepWithOnOff', {
|
|
107
107
|
command: 'stepWithOnOff',
|
|
108
108
|
request,
|
|
@@ -111,16 +111,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
|
|
|
111
111
|
endpoint: this.endpoint,
|
|
112
112
|
context: this.context,
|
|
113
113
|
});
|
|
114
|
-
device.log.debug(`MatterbridgeLevelControlServer: stepWithOnOff called`);
|
|
114
|
+
device.log.debug(`MatterbridgeLevelControlServer: stepWithOnOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
115
115
|
await super.stepWithOnOff(request);
|
|
116
116
|
}
|
|
117
117
|
async stop(request) {
|
|
118
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
119
|
-
device.log.info(`Stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
120
118
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
121
119
|
await super.stop(request);
|
|
122
120
|
return;
|
|
123
121
|
}
|
|
122
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
123
|
+
device.log.info(`MatterbridgeLevelControlServer: stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
124
124
|
await device.commandHandler.executeHandler('LevelControl.stop', {
|
|
125
125
|
command: 'stop',
|
|
126
126
|
request,
|
|
@@ -129,16 +129,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
|
|
|
129
129
|
endpoint: this.endpoint,
|
|
130
130
|
context: this.context,
|
|
131
131
|
});
|
|
132
|
-
device.log.debug(`MatterbridgeLevelControlServer: stop called`);
|
|
132
|
+
device.log.debug(`MatterbridgeLevelControlServer: stop called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
133
133
|
await super.stop(request);
|
|
134
134
|
}
|
|
135
135
|
async stopWithOnOff(request) {
|
|
136
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
137
|
-
device.log.info(`Stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
138
136
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
139
137
|
await super.stopWithOnOff(request);
|
|
140
138
|
return;
|
|
141
139
|
}
|
|
140
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
141
|
+
device.log.info(`MatterbridgeLevelControlServer: stopping level change with on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
142
142
|
await device.commandHandler.executeHandler('LevelControl.stopWithOnOff', {
|
|
143
143
|
command: 'stopWithOnOff',
|
|
144
144
|
request,
|
|
@@ -147,7 +147,7 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
|
|
|
147
147
|
endpoint: this.endpoint,
|
|
148
148
|
context: this.context,
|
|
149
149
|
});
|
|
150
|
-
device.log.debug(`MatterbridgeLevelControlServer: stopWithOnOff called`);
|
|
150
|
+
device.log.debug(`MatterbridgeLevelControlServer: stopWithOnOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
151
151
|
await super.stopWithOnOff(request);
|
|
152
152
|
}
|
|
153
153
|
}
|
|
@@ -2,7 +2,7 @@ import { Behavior } from '@matter/node';
|
|
|
2
2
|
export class MatterbridgeServer extends Behavior {
|
|
3
3
|
static id = 'matterbridge';
|
|
4
4
|
initialize() {
|
|
5
|
-
this.state.log.debug(`MatterbridgeServer initialized (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
5
|
+
this.state.log.debug(`MatterbridgeServer: initialized (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
6
6
|
super.initialize();
|
|
7
7
|
}
|
|
8
8
|
}
|
|
@@ -3,7 +3,7 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
|
|
|
3
3
|
export class MatterbridgeModeSelectServer extends ModeSelectServer {
|
|
4
4
|
async changeToMode(request) {
|
|
5
5
|
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
6
|
-
device.log.info(`
|
|
6
|
+
device.log.info(`MatterbridgeModeSelectServer: changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
7
7
|
await device.commandHandler.executeHandler('ModeSelect.changeToMode', {
|
|
8
8
|
command: 'changeToMode',
|
|
9
9
|
request,
|
|
@@ -12,7 +12,7 @@ export class MatterbridgeModeSelectServer extends ModeSelectServer {
|
|
|
12
12
|
endpoint: this.endpoint,
|
|
13
13
|
context: this.context,
|
|
14
14
|
});
|
|
15
|
-
device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode
|
|
15
|
+
device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
16
16
|
await super.changeToMode(request);
|
|
17
17
|
}
|
|
18
18
|
}
|
|
@@ -1,9 +1,12 @@
|
|
|
1
1
|
import { OccupancySensingServer } from '@matter/node/behaviors/occupancy-sensing';
|
|
2
2
|
import { OccupancySensing } from '@matter/types/clusters/occupancy-sensing';
|
|
3
|
+
import { MatterbridgeServer } from './matterbridgeServer.js';
|
|
3
4
|
export class MatterbridgeOccupancySensingServer extends OccupancySensingServer.with(OccupancySensing.Feature.PassiveInfrared) {
|
|
4
5
|
#syncingHoldTime = false;
|
|
5
6
|
initialize() {
|
|
6
7
|
const result = super.initialize();
|
|
8
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
9
|
+
device.log.info(`MatterbridgeOccupancySensingServer: initializing (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
7
10
|
if (this.events.holdTime$Changing)
|
|
8
11
|
this.reactTo(this.events.holdTime$Changing, this.#syncPirOccupiedToUnoccupiedDelay);
|
|
9
12
|
if (this.events.pirOccupiedToUnoccupiedDelay$Changing)
|
|
@@ -3,12 +3,12 @@ import { OnOff } from '@matter/types/clusters/on-off';
|
|
|
3
3
|
import { MatterbridgeServer } from './matterbridgeServer.js';
|
|
4
4
|
export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Lighting) {
|
|
5
5
|
async on() {
|
|
6
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
7
|
-
device.log.info(`Switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
8
6
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
9
7
|
await super.on();
|
|
10
8
|
return;
|
|
11
9
|
}
|
|
10
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
11
|
+
device.log.info(`MatterbridgeOnOffServer: switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
12
12
|
await device.commandHandler.executeHandler('OnOff.on', {
|
|
13
13
|
command: 'on',
|
|
14
14
|
request: {},
|
|
@@ -17,16 +17,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
|
|
|
17
17
|
endpoint: this.endpoint,
|
|
18
18
|
context: this.context,
|
|
19
19
|
});
|
|
20
|
-
device.log.debug(`MatterbridgeOnOffServer: on called`);
|
|
20
|
+
device.log.debug(`MatterbridgeOnOffServer: on called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
21
21
|
await super.on();
|
|
22
22
|
}
|
|
23
23
|
async off() {
|
|
24
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
25
|
-
device.log.info(`Switching device off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
26
24
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
27
25
|
await super.off();
|
|
28
26
|
return;
|
|
29
27
|
}
|
|
28
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
29
|
+
device.log.info(`MatterbridgeOnOffServer: switching device off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
30
30
|
await device.commandHandler.executeHandler('OnOff.off', {
|
|
31
31
|
command: 'off',
|
|
32
32
|
request: {},
|
|
@@ -35,16 +35,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
|
|
|
35
35
|
endpoint: this.endpoint,
|
|
36
36
|
context: this.context,
|
|
37
37
|
});
|
|
38
|
-
device.log.debug(`MatterbridgeOnOffServer: off called`);
|
|
38
|
+
device.log.debug(`MatterbridgeOnOffServer: off called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
39
39
|
await super.off();
|
|
40
40
|
}
|
|
41
41
|
async toggle() {
|
|
42
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
43
|
-
device.log.info(`Toggle device on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
44
42
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
45
43
|
await super.toggle();
|
|
46
44
|
return;
|
|
47
45
|
}
|
|
46
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
47
|
+
device.log.info(`MatterbridgeOnOffServer: toggling device on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
48
48
|
await device.commandHandler.executeHandler('OnOff.toggle', {
|
|
49
49
|
command: 'toggle',
|
|
50
50
|
request: {},
|
|
@@ -53,16 +53,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
|
|
|
53
53
|
endpoint: this.endpoint,
|
|
54
54
|
context: this.context,
|
|
55
55
|
});
|
|
56
|
-
device.log.debug(`MatterbridgeOnOffServer: toggle called`);
|
|
56
|
+
device.log.debug(`MatterbridgeOnOffServer: toggle called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
57
57
|
await super.toggle();
|
|
58
58
|
}
|
|
59
59
|
async offWithEffect(request) {
|
|
60
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
61
|
-
device.log.info(`Switching device off with effect ${request.effectIdentifier} and variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
62
60
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
63
61
|
await super.offWithEffect(request);
|
|
64
62
|
return;
|
|
65
63
|
}
|
|
64
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
65
|
+
device.log.info(`MatterbridgeOnOffServer: switching device off with effect ${request.effectIdentifier} and variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
66
66
|
await device.commandHandler.executeHandler('OnOff.offWithEffect', {
|
|
67
67
|
command: 'offWithEffect',
|
|
68
68
|
request,
|
|
@@ -71,16 +71,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
|
|
|
71
71
|
endpoint: this.endpoint,
|
|
72
72
|
context: this.context,
|
|
73
73
|
});
|
|
74
|
-
device.log.debug(`MatterbridgeOnOffServer: offWithEffect called`);
|
|
74
|
+
device.log.debug(`MatterbridgeOnOffServer: offWithEffect called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
75
75
|
await super.offWithEffect(request);
|
|
76
76
|
}
|
|
77
77
|
async onWithRecallGlobalScene() {
|
|
78
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
79
|
-
device.log.info(`Switching device on with recall global scene (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
80
78
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
81
79
|
await super.onWithRecallGlobalScene();
|
|
82
80
|
return;
|
|
83
81
|
}
|
|
82
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
83
|
+
device.log.info(`MatterbridgeOnOffServer: switching device on with recall global scene (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
84
84
|
await device.commandHandler.executeHandler('OnOff.onWithRecallGlobalScene', {
|
|
85
85
|
command: 'onWithRecallGlobalScene',
|
|
86
86
|
request: {},
|
|
@@ -89,16 +89,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
|
|
|
89
89
|
endpoint: this.endpoint,
|
|
90
90
|
context: this.context,
|
|
91
91
|
});
|
|
92
|
-
device.log.debug(`MatterbridgeOnOffServer: onWithRecallGlobalScene called`);
|
|
92
|
+
device.log.debug(`MatterbridgeOnOffServer: onWithRecallGlobalScene called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
93
93
|
await super.onWithRecallGlobalScene();
|
|
94
94
|
}
|
|
95
95
|
async onWithTimedOff(request) {
|
|
96
|
-
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
97
|
-
device.log.info(`Switching device on with timed off control ${JSON.stringify(request.onOffControl)}, offWaitTime ${request.offWaitTime} and onTime ${request.onTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
98
96
|
if (process.env.MATTERBRIDGE_CHIP_TEST) {
|
|
99
97
|
await super.onWithTimedOff(request);
|
|
100
98
|
return;
|
|
101
99
|
}
|
|
100
|
+
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
101
|
+
device.log.info(`MatterbridgeOnOffServer: switching device on with timed off control ${JSON.stringify(request.onOffControl)}, offWaitTime ${request.offWaitTime} and onTime ${request.onTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
102
102
|
await device.commandHandler.executeHandler('OnOff.onWithTimedOff', {
|
|
103
103
|
command: 'onWithTimedOff',
|
|
104
104
|
request,
|
|
@@ -107,7 +107,7 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
|
|
|
107
107
|
endpoint: this.endpoint,
|
|
108
108
|
context: this.context,
|
|
109
109
|
});
|
|
110
|
-
device.log.debug(`MatterbridgeOnOffServer: onWithTimedOff called`);
|
|
110
|
+
device.log.debug(`MatterbridgeOnOffServer: onWithTimedOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
111
111
|
await super.onWithTimedOff(request);
|
|
112
112
|
}
|
|
113
113
|
}
|
|
@@ -66,7 +66,7 @@ export class MatterbridgePumpConfigurationAndControlServer extends PumpConfigura
|
|
|
66
66
|
}
|
|
67
67
|
#handleOperationModeChanging() {
|
|
68
68
|
if (this.state.pumpStatus?.localOverride) {
|
|
69
|
-
throw new StatusResponseError(
|
|
69
|
+
throw new StatusResponseError(`MatterbridgePumpConfigurationAndControlServer: operationMode cannot be changed while PumpStatus.LocalOverride is set (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.Failure);
|
|
70
70
|
}
|
|
71
71
|
}
|
|
72
72
|
#handleOperationModeChanged(operationMode, oldOperationMode) {
|
|
@@ -3,7 +3,7 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
|
|
|
3
3
|
export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
|
|
4
4
|
async selectAreas(request) {
|
|
5
5
|
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
6
|
-
device.log.info(`
|
|
6
|
+
device.log.info(`MatterbridgeServiceAreaServer: selecting areas [${request.newAreas.join(', ')}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
7
7
|
await device.commandHandler.executeHandler('ServiceArea.selectAreas', {
|
|
8
8
|
command: 'selectAreas',
|
|
9
9
|
request,
|
|
@@ -12,7 +12,7 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
|
|
|
12
12
|
endpoint: this.endpoint,
|
|
13
13
|
context: this.context,
|
|
14
14
|
});
|
|
15
|
-
device.log.debug(`MatterbridgeServiceAreaServer selectAreas called with
|
|
15
|
+
device.log.debug(`MatterbridgeServiceAreaServer: selectAreas called with [${request.newAreas.join(', ')}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
16
16
|
return await super.selectAreas(request);
|
|
17
17
|
}
|
|
18
18
|
}
|
|
@@ -7,7 +7,7 @@ export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(Smok
|
|
|
7
7
|
static selfTestDurationSeconds = 5;
|
|
8
8
|
async selfTestRequest() {
|
|
9
9
|
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
10
|
-
device.log.info(`
|
|
10
|
+
device.log.info(`MatterbridgeSmokeCoAlarmServer: testing SmokeCOAlarm (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
11
11
|
await device.commandHandler.executeHandler('SmokeCoAlarm.selfTestRequest', {
|
|
12
12
|
command: 'selfTestRequest',
|
|
13
13
|
request: {},
|
|
@@ -17,12 +17,12 @@ export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(Smok
|
|
|
17
17
|
context: this.context,
|
|
18
18
|
});
|
|
19
19
|
if (this.state.expressedState !== SmokeCoAlarm.ExpressedState.Normal || this.state.testInProgress) {
|
|
20
|
-
throw new StatusResponseError(
|
|
20
|
+
throw new StatusResponseError(`MatterbridgeSmokeCoAlarmServer: SmokeCOAlarm self-test is busy (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.Busy);
|
|
21
21
|
}
|
|
22
22
|
this.state.testInProgress = true;
|
|
23
23
|
this.state.expressedState = SmokeCoAlarm.ExpressedState.Testing;
|
|
24
24
|
this.#scheduleSelfTestComplete();
|
|
25
|
-
device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called`);
|
|
25
|
+
device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
26
26
|
}
|
|
27
27
|
#stopSelfTestTimer() {
|
|
28
28
|
this.internal.selfTestTimer?.stop();
|
|
@@ -3,6 +3,6 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
|
|
|
3
3
|
export class MatterbridgeSwitchServer extends SwitchServer {
|
|
4
4
|
initialize() {
|
|
5
5
|
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
6
|
-
device.log.info(`
|
|
6
|
+
device.log.info(`MatterbridgeSwitchServer: initializing (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
7
7
|
}
|
|
8
8
|
}
|
|
@@ -14,7 +14,7 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
|
|
|
14
14
|
}
|
|
15
15
|
async open(request) {
|
|
16
16
|
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
17
|
-
device.log.info(`
|
|
17
|
+
device.log.info(`MatterbridgeValveConfigurationAndControlServer: opening valve to ${request.targetLevel ? request.targetLevel + '%' : 'fully opened'} ${request.openDuration ? 'for ' + request.openDuration + 's' : 'until closed'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
18
18
|
await device.commandHandler.executeHandler('ValveConfigurationAndControl.open', {
|
|
19
19
|
command: 'open',
|
|
20
20
|
request,
|
|
@@ -23,9 +23,9 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
|
|
|
23
23
|
endpoint: this.endpoint,
|
|
24
24
|
context: this.context,
|
|
25
25
|
});
|
|
26
|
-
device.log.debug(`MatterbridgeValveConfigurationAndControlServer: open called with openDuration: ${request.openDuration} targetLevel: ${request.targetLevel}`);
|
|
26
|
+
device.log.debug(`MatterbridgeValveConfigurationAndControlServer: open called with openDuration: ${request.openDuration} targetLevel: ${request.targetLevel} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
27
27
|
if (this.#hasFault()) {
|
|
28
|
-
throw new ValveConfigurationAndControl.FailureDueToFaultError(
|
|
28
|
+
throw new ValveConfigurationAndControl.FailureDueToFaultError(`MatterbridgeValveConfigurationAndControlServer: open ignored, the valve has a registered fault (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
29
29
|
}
|
|
30
30
|
this.#stopMovementTimer();
|
|
31
31
|
this.#stopAutoCloseTimer();
|
|
@@ -35,7 +35,7 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
|
|
|
35
35
|
this.state.remainingDuration = this.state.openDuration;
|
|
36
36
|
if (this.features.level) {
|
|
37
37
|
if (request.targetLevel !== undefined && request.targetLevel !== 100 && this.state.levelStep !== undefined && request.targetLevel % this.state.levelStep !== 0) {
|
|
38
|
-
throw new StatusResponseError(`
|
|
38
|
+
throw new StatusResponseError(`MatterbridgeValveConfigurationAndControlServer: open targetLevel ${request.targetLevel} is not a multiple of levelStep ${this.state.levelStep} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
|
|
39
39
|
}
|
|
40
40
|
this.state.targetLevel = request.targetLevel ?? this.state.defaultOpenLevel ?? 100;
|
|
41
41
|
}
|
|
@@ -46,7 +46,7 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
|
|
|
46
46
|
}
|
|
47
47
|
async close() {
|
|
48
48
|
const device = this.endpoint.stateOf(MatterbridgeServer);
|
|
49
|
-
device.log.info(`
|
|
49
|
+
device.log.info(`MatterbridgeValveConfigurationAndControlServer: closing valve (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
50
50
|
await device.commandHandler.executeHandler('ValveConfigurationAndControl.close', {
|
|
51
51
|
command: 'close',
|
|
52
52
|
request: {},
|
|
@@ -55,9 +55,9 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
|
|
|
55
55
|
endpoint: this.endpoint,
|
|
56
56
|
context: this.context,
|
|
57
57
|
});
|
|
58
|
-
device.log.debug(`MatterbridgeValveConfigurationAndControlServer: close called`);
|
|
58
|
+
device.log.debug(`MatterbridgeValveConfigurationAndControlServer: close called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
59
59
|
if (this.#hasFault()) {
|
|
60
|
-
throw new ValveConfigurationAndControl.FailureDueToFaultError(
|
|
60
|
+
throw new ValveConfigurationAndControl.FailureDueToFaultError(`MatterbridgeValveConfigurationAndControlServer: close ignored, the valve has a registered fault (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
|
|
61
61
|
}
|
|
62
62
|
this.#stopMovementTimer();
|
|
63
63
|
this.#stopAutoCloseTimer();
|
package/dist/chipTests.js
CHANGED
|
@@ -4,7 +4,7 @@ import { Seconds, Time } from '@matter/general';
|
|
|
4
4
|
import { BasicInformationServer } from '@matter/node/behaviors/basic-information';
|
|
5
5
|
import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/bridged-device-basic-information';
|
|
6
6
|
import { GeneralDiagnosticsServer } from '@matter/node/behaviors/general-diagnostics';
|
|
7
|
-
import { Status, StatusResponseError } from '@matter/types';
|
|
7
|
+
import { MATTER_EPOCH_OFFSET_S, Status, StatusResponseError } from '@matter/types';
|
|
8
8
|
import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
|
|
9
9
|
import { ClosureControl } from '@matter/types/clusters/closure-control';
|
|
10
10
|
import { CommodityMetering } from '@matter/types/clusters/commodity-metering';
|
|
@@ -70,6 +70,11 @@ const energyEvseOverTemperatureFaultTrigger = 0x0099000000000011n;
|
|
|
70
70
|
const energyEvseFaultClearTrigger = 0x0099000000000012n;
|
|
71
71
|
const energyEvseDiagnosticsCompleteTrigger = 0x0099000000000020n;
|
|
72
72
|
const energyEvseTimeOfUseModeClearTrigger = 0x0099000000000021n;
|
|
73
|
+
const energyEvseSetSocLowTrigger = 0x0099000000000030n;
|
|
74
|
+
const energyEvseSetSocHighTrigger = 0x0099000000000031n;
|
|
75
|
+
const energyEvseSetSocClearTrigger = 0x0099000000000032n;
|
|
76
|
+
const energyEvseSetVehicleIdTrigger = 0x0099000000000040n;
|
|
77
|
+
const energyEvseRfidTrigger = 0x0099000000000050n;
|
|
73
78
|
const meterIdentificationAttributesValueSetTrigger = 0x0b06000000000000n;
|
|
74
79
|
const meterIdentificationTestEventClearTrigger = 0x0b06000000000001n;
|
|
75
80
|
const commodityMeteringAttributesValueSetTrigger = 0x0b07000000000000n;
|
|
@@ -296,6 +301,11 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
|
|
|
296
301
|
normalizeTestEventTrigger(energyEvseFaultClearTrigger),
|
|
297
302
|
normalizeTestEventTrigger(energyEvseDiagnosticsCompleteTrigger),
|
|
298
303
|
normalizeTestEventTrigger(energyEvseTimeOfUseModeClearTrigger),
|
|
304
|
+
normalizeTestEventTrigger(energyEvseSetSocLowTrigger),
|
|
305
|
+
normalizeTestEventTrigger(energyEvseSetSocHighTrigger),
|
|
306
|
+
normalizeTestEventTrigger(energyEvseSetSocClearTrigger),
|
|
307
|
+
normalizeTestEventTrigger(energyEvseSetVehicleIdTrigger),
|
|
308
|
+
normalizeTestEventTrigger(energyEvseRfidTrigger),
|
|
299
309
|
];
|
|
300
310
|
if (!supportedTriggers.includes(eventTrigger) || !chipTestMatterbridge || chipTestActiveEndpointId === undefined)
|
|
301
311
|
return false;
|
|
@@ -316,6 +326,9 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
|
|
|
316
326
|
minimumChargeCurrent: 6_000,
|
|
317
327
|
maximumChargeCurrent: 32_000,
|
|
318
328
|
userMaximumChargeCurrent: 32_000,
|
|
329
|
+
chargingEnabledUntil: MATTER_EPOCH_OFFSET_S,
|
|
330
|
+
...(endpoint.hasAttributeServer(EnergyEvse.id, 'dischargingEnabledUntil') ? { dischargingEnabledUntil: MATTER_EPOCH_OFFSET_S } : {}),
|
|
331
|
+
...(endpoint.hasAttributeServer(EnergyEvse.id, 'maximumDischargeCurrent') ? { maximumDischargeCurrent: 0 } : {}),
|
|
319
332
|
}, log);
|
|
320
333
|
return true;
|
|
321
334
|
case normalizeTestEventTrigger(energyEvseBasicClearTrigger):
|
|
@@ -323,7 +336,13 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
|
|
|
323
336
|
case normalizeTestEventTrigger(energyEvsePluggedInTrigger): {
|
|
324
337
|
const nextSessionId = sessionId + 1;
|
|
325
338
|
energyEvseSessionStartedAt.set(chipTestActiveEndpointId, Time.nowMs);
|
|
326
|
-
await endpoint.setCluster(EnergyEvse, {
|
|
339
|
+
await endpoint.setCluster(EnergyEvse, {
|
|
340
|
+
state: EnergyEvse.State.PluggedInNoDemand,
|
|
341
|
+
sessionId: nextSessionId,
|
|
342
|
+
sessionDuration: 0,
|
|
343
|
+
sessionEnergyCharged: 0,
|
|
344
|
+
...(endpoint.hasAttributeServer(EnergyEvse.id, 'sessionEnergyDischarged') ? { sessionEnergyDischarged: 0 } : {}),
|
|
345
|
+
}, log);
|
|
327
346
|
await endpoint.triggerEvent(EnergyEvse, 'evConnected', { sessionId: nextSessionId }, log);
|
|
328
347
|
return true;
|
|
329
348
|
}
|
|
@@ -331,18 +350,26 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
|
|
|
331
350
|
const sessionStartedAt = energyEvseSessionStartedAt.get(chipTestActiveEndpointId);
|
|
332
351
|
const sessionDuration = sessionStartedAt === undefined ? 0 : Math.floor((Time.nowMs - sessionStartedAt) / 1_000);
|
|
333
352
|
await endpoint.triggerEvent(EnergyEvse, 'evNotDetected', { sessionId, state: EnergyEvse.State.PluggedInNoDemand, sessionDuration, sessionEnergyCharged: 1 }, log);
|
|
334
|
-
await endpoint.setCluster(EnergyEvse, {
|
|
353
|
+
await endpoint.setCluster(EnergyEvse, {
|
|
354
|
+
state: EnergyEvse.State.NotPluggedIn,
|
|
355
|
+
sessionDuration,
|
|
356
|
+
sessionEnergyCharged: 1,
|
|
357
|
+
...(endpoint.hasAttributeServer(EnergyEvse.id, 'sessionEnergyDischarged') ? { sessionEnergyDischarged: 1 } : {}),
|
|
358
|
+
}, log);
|
|
335
359
|
energyEvseSessionStartedAt.delete(chipTestActiveEndpointId);
|
|
336
360
|
return true;
|
|
337
361
|
}
|
|
338
362
|
case normalizeTestEventTrigger(energyEvseChargeDemandTrigger): {
|
|
339
|
-
const
|
|
363
|
+
const supplyState = endpoint.getAttribute(EnergyEvse.id, 'supplyState');
|
|
364
|
+
const charging = supplyState === EnergyEvse.SupplyState.ChargingEnabled || supplyState === EnergyEvse.SupplyState.Enabled;
|
|
340
365
|
const nextState = charging ? EnergyEvse.State.PluggedInCharging : EnergyEvse.State.PluggedInDemand;
|
|
341
366
|
await endpoint.setCluster(EnergyEvse, { state: nextState }, log);
|
|
342
367
|
if (charging) {
|
|
343
368
|
const maximumChargeCurrentAttribute = endpoint.getAttribute(EnergyEvse.id, 'maximumChargeCurrent');
|
|
344
369
|
const maximumCurrent = typeof maximumChargeCurrentAttribute === 'number' || typeof maximumChargeCurrentAttribute === 'bigint' ? maximumChargeCurrentAttribute : 0;
|
|
345
|
-
|
|
370
|
+
const maximumDischargeCurrentAttribute = endpoint.getAttribute(EnergyEvse.id, 'maximumDischargeCurrent');
|
|
371
|
+
const maximumDischargeCurrent = typeof maximumDischargeCurrentAttribute === 'number' || typeof maximumDischargeCurrentAttribute === 'bigint' ? maximumDischargeCurrentAttribute : undefined;
|
|
372
|
+
await endpoint.triggerEvent(EnergyEvse, 'energyTransferStarted', { sessionId, state: nextState, maximumCurrent, maximumDischargeCurrent }, log);
|
|
346
373
|
}
|
|
347
374
|
return true;
|
|
348
375
|
}
|
|
@@ -372,6 +399,21 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
|
|
|
372
399
|
case normalizeTestEventTrigger(energyEvseDiagnosticsCompleteTrigger):
|
|
373
400
|
await endpoint.setCluster(EnergyEvse, { state: EnergyEvse.State.NotPluggedIn, supplyState: EnergyEvse.SupplyState.Disabled }, log);
|
|
374
401
|
return true;
|
|
402
|
+
case normalizeTestEventTrigger(energyEvseSetSocLowTrigger):
|
|
403
|
+
await endpoint.setCluster(EnergyEvse, { stateOfCharge: 20, batteryCapacity: 70_000_000 }, log);
|
|
404
|
+
return true;
|
|
405
|
+
case normalizeTestEventTrigger(energyEvseSetSocHighTrigger):
|
|
406
|
+
await endpoint.setCluster(EnergyEvse, { stateOfCharge: 95, batteryCapacity: 70_000_000 }, log);
|
|
407
|
+
return true;
|
|
408
|
+
case normalizeTestEventTrigger(energyEvseSetSocClearTrigger):
|
|
409
|
+
await endpoint.setCluster(EnergyEvse, { stateOfCharge: null, batteryCapacity: null }, log);
|
|
410
|
+
return true;
|
|
411
|
+
case normalizeTestEventTrigger(energyEvseSetVehicleIdTrigger):
|
|
412
|
+
await endpoint.setAttribute(EnergyEvse.id, 'vehicleId', 'Matterbridge EVSE', log);
|
|
413
|
+
return true;
|
|
414
|
+
case normalizeTestEventTrigger(energyEvseRfidTrigger):
|
|
415
|
+
await endpoint.triggerEvent(EnergyEvse, 'rfid', { uid: Uint8Array.of(0x4d, 0x42, 0x45, 0x56, 0x53, 0x45) }, log);
|
|
416
|
+
return true;
|
|
375
417
|
default:
|
|
376
418
|
return false;
|
|
377
419
|
}
|
package/dist/demoDevices.js
CHANGED
|
@@ -740,6 +740,20 @@ export async function createDemoDevices(matterbridge) {
|
|
|
740
740
|
tagList: [getSemtag(CommonNumberTag.One)],
|
|
741
741
|
});
|
|
742
742
|
await registerDevice(ep, 'EVSE', 'ENERGY-14-01');
|
|
743
|
+
ep = new Evse('EVSE Complete', 'ENERGY-14-01-1', {
|
|
744
|
+
id: 'EvseComplete',
|
|
745
|
+
number: EndpointNumber(14_01_1),
|
|
746
|
+
tagList: [getSemtag(CommonNumberTag.Two)],
|
|
747
|
+
stateOfCharge: 80,
|
|
748
|
+
batteryCapacity: 70_000_000,
|
|
749
|
+
vehicleId: null,
|
|
750
|
+
rfid: true,
|
|
751
|
+
v2x: true,
|
|
752
|
+
esaCanGenerate: true,
|
|
753
|
+
absMinPower: -7_400_000,
|
|
754
|
+
absMaxPower: 7_400_000,
|
|
755
|
+
});
|
|
756
|
+
await registerDevice(ep, 'EVSE Complete', 'ENERGY-14-01-1');
|
|
743
757
|
ep = new WaterHeater('Water Heater', 'ENERGY-14-02', {
|
|
744
758
|
id: 'WaterHeater',
|
|
745
759
|
number: EndpointNumber(14_02),
|