@matterbridge/core 3.10.9-dev-20260906-2a9dc0e → 3.10.9-dev-20260907-5fcc59a

package/dist/chipTests.js

@@ -4,7 +4,7 @@ import { Seconds, Time } from '@matter/general';
 import { BasicInformationServer } from '@matter/node/behaviors/basic-information';
 import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/bridged-device-basic-information';
 import { GeneralDiagnosticsServer } from '@matter/node/behaviors/general-diagnostics';
-import { Status, StatusResponseError } from '@matter/types';
+import { MATTER_EPOCH_OFFSET_S, Status, StatusResponseError } from '@matter/types';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
 import { ClosureControl } from '@matter/types/clusters/closure-control';
 import { CommodityMetering } from '@matter/types/clusters/commodity-metering';
@@ -70,6 +70,11 @@ const energyEvseOverTemperatureFaultTrigger = 0x0099000000000011n;
 const energyEvseFaultClearTrigger = 0x0099000000000012n;
 const energyEvseDiagnosticsCompleteTrigger = 0x0099000000000020n;
 const energyEvseTimeOfUseModeClearTrigger = 0x0099000000000021n;
+const energyEvseSetSocLowTrigger = 0x0099000000000030n;
+const energyEvseSetSocHighTrigger = 0x0099000000000031n;
+const energyEvseSetSocClearTrigger = 0x0099000000000032n;
+const energyEvseSetVehicleIdTrigger = 0x0099000000000040n;
+const energyEvseRfidTrigger = 0x0099000000000050n;
 const meterIdentificationAttributesValueSetTrigger = 0x0b06000000000000n;
 const meterIdentificationTestEventClearTrigger = 0x0b06000000000001n;
 const commodityMeteringAttributesValueSetTrigger = 0x0b07000000000000n;
@@ -296,6 +301,11 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
         normalizeTestEventTrigger(energyEvseFaultClearTrigger),
         normalizeTestEventTrigger(energyEvseDiagnosticsCompleteTrigger),
         normalizeTestEventTrigger(energyEvseTimeOfUseModeClearTrigger),
+        normalizeTestEventTrigger(energyEvseSetSocLowTrigger),
+        normalizeTestEventTrigger(energyEvseSetSocHighTrigger),
+        normalizeTestEventTrigger(energyEvseSetSocClearTrigger),
+        normalizeTestEventTrigger(energyEvseSetVehicleIdTrigger),
+        normalizeTestEventTrigger(energyEvseRfidTrigger),
     ];
     if (!supportedTriggers.includes(eventTrigger) || !chipTestMatterbridge || chipTestActiveEndpointId === undefined)
         return false;
@@ -316,6 +326,9 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
                 minimumChargeCurrent: 6_000,
                 maximumChargeCurrent: 32_000,
                 userMaximumChargeCurrent: 32_000,
+                chargingEnabledUntil: MATTER_EPOCH_OFFSET_S,
+                ...(endpoint.hasAttributeServer(EnergyEvse.id, 'dischargingEnabledUntil') ? { dischargingEnabledUntil: MATTER_EPOCH_OFFSET_S } : {}),
+                ...(endpoint.hasAttributeServer(EnergyEvse.id, 'maximumDischargeCurrent') ? { maximumDischargeCurrent: 0 } : {}),
             }, log);
             return true;
         case normalizeTestEventTrigger(energyEvseBasicClearTrigger):
@@ -323,7 +336,13 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
         case normalizeTestEventTrigger(energyEvsePluggedInTrigger): {
             const nextSessionId = sessionId + 1;
             energyEvseSessionStartedAt.set(chipTestActiveEndpointId, Time.nowMs);
-            await endpoint.setCluster(EnergyEvse, { state: EnergyEvse.State.PluggedInNoDemand, sessionId: nextSessionId, sessionDuration: 0, sessionEnergyCharged: 0 }, log);
+            await endpoint.setCluster(EnergyEvse, {
+                state: EnergyEvse.State.PluggedInNoDemand,
+                sessionId: nextSessionId,
+                sessionDuration: 0,
+                sessionEnergyCharged: 0,
+                ...(endpoint.hasAttributeServer(EnergyEvse.id, 'sessionEnergyDischarged') ? { sessionEnergyDischarged: 0 } : {}),
+            }, log);
             await endpoint.triggerEvent(EnergyEvse, 'evConnected', { sessionId: nextSessionId }, log);
             return true;
         }
@@ -331,18 +350,26 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
             const sessionStartedAt = energyEvseSessionStartedAt.get(chipTestActiveEndpointId);
             const sessionDuration = sessionStartedAt === undefined ? 0 : Math.floor((Time.nowMs - sessionStartedAt) / 1_000);
             await endpoint.triggerEvent(EnergyEvse, 'evNotDetected', { sessionId, state: EnergyEvse.State.PluggedInNoDemand, sessionDuration, sessionEnergyCharged: 1 }, log);
-            await endpoint.setCluster(EnergyEvse, { state: EnergyEvse.State.NotPluggedIn, sessionDuration, sessionEnergyCharged: 1 }, log);
+            await endpoint.setCluster(EnergyEvse, {
+                state: EnergyEvse.State.NotPluggedIn,
+                sessionDuration,
+                sessionEnergyCharged: 1,
+                ...(endpoint.hasAttributeServer(EnergyEvse.id, 'sessionEnergyDischarged') ? { sessionEnergyDischarged: 1 } : {}),
+            }, log);
             energyEvseSessionStartedAt.delete(chipTestActiveEndpointId);
             return true;
         }
         case normalizeTestEventTrigger(energyEvseChargeDemandTrigger): {
-            const charging = endpoint.getAttribute(EnergyEvse.id, 'supplyState') === EnergyEvse.SupplyState.ChargingEnabled;
+            const supplyState = endpoint.getAttribute(EnergyEvse.id, 'supplyState');
+            const charging = supplyState === EnergyEvse.SupplyState.ChargingEnabled || supplyState === EnergyEvse.SupplyState.Enabled;
             const nextState = charging ? EnergyEvse.State.PluggedInCharging : EnergyEvse.State.PluggedInDemand;
             await endpoint.setCluster(EnergyEvse, { state: nextState }, log);
             if (charging) {
                 const maximumChargeCurrentAttribute = endpoint.getAttribute(EnergyEvse.id, 'maximumChargeCurrent');
                 const maximumCurrent = typeof maximumChargeCurrentAttribute === 'number' || typeof maximumChargeCurrentAttribute === 'bigint' ? maximumChargeCurrentAttribute : 0;
-                await endpoint.triggerEvent(EnergyEvse, 'energyTransferStarted', { sessionId, state: nextState, maximumCurrent }, log);
+                const maximumDischargeCurrentAttribute = endpoint.getAttribute(EnergyEvse.id, 'maximumDischargeCurrent');
+                const maximumDischargeCurrent = typeof maximumDischargeCurrentAttribute === 'number' || typeof maximumDischargeCurrentAttribute === 'bigint' ? maximumDischargeCurrentAttribute : undefined;
+                await endpoint.triggerEvent(EnergyEvse, 'energyTransferStarted', { sessionId, state: nextState, maximumCurrent, maximumDischargeCurrent }, log);
             }
             return true;
         }
@@ -372,6 +399,21 @@ async function handleEnergyEvseTestEventTrigger(eventTrigger) {
         case normalizeTestEventTrigger(energyEvseDiagnosticsCompleteTrigger):
             await endpoint.setCluster(EnergyEvse, { state: EnergyEvse.State.NotPluggedIn, supplyState: EnergyEvse.SupplyState.Disabled }, log);
             return true;
+        case normalizeTestEventTrigger(energyEvseSetSocLowTrigger):
+            await endpoint.setCluster(EnergyEvse, { stateOfCharge: 20, batteryCapacity: 70_000_000 }, log);
+            return true;
+        case normalizeTestEventTrigger(energyEvseSetSocHighTrigger):
+            await endpoint.setCluster(EnergyEvse, { stateOfCharge: 95, batteryCapacity: 70_000_000 }, log);
+            return true;
+        case normalizeTestEventTrigger(energyEvseSetSocClearTrigger):
+            await endpoint.setCluster(EnergyEvse, { stateOfCharge: null, batteryCapacity: null }, log);
+            return true;
+        case normalizeTestEventTrigger(energyEvseSetVehicleIdTrigger):
+            await endpoint.setAttribute(EnergyEvse.id, 'vehicleId', 'Matterbridge EVSE', log);
+            return true;
+        case normalizeTestEventTrigger(energyEvseRfidTrigger):
+            await endpoint.triggerEvent(EnergyEvse, 'rfid', { uid: Uint8Array.of(0x4d, 0x42, 0x45, 0x56, 0x53, 0x45) }, log);
+            return true;
         default:
             return false;
     }

package/dist/demoDevices.js

@@ -740,6 +740,20 @@ export async function createDemoDevices(matterbridge) {
         tagList: [getSemtag(CommonNumberTag.One)],
     });
     await registerDevice(ep, 'EVSE', 'ENERGY-14-01');
+    ep = new Evse('EVSE Complete', 'ENERGY-14-01-1', {
+        id: 'EvseComplete',
+        number: EndpointNumber(14_01_1),
+        tagList: [getSemtag(CommonNumberTag.Two)],
+        stateOfCharge: 80,
+        batteryCapacity: 70_000_000,
+        vehicleId: null,
+        rfid: true,
+        v2x: true,
+        esaCanGenerate: true,
+        absMinPower: -7_400_000,
+        absMaxPower: 7_400_000,
+    });
+    await registerDevice(ep, 'EVSE Complete', 'ENERGY-14-01-1');
     ep = new WaterHeater('Water Heater', 'ENERGY-14-02', {
         id: 'WaterHeater',
         number: EndpointNumber(14_02),

package/dist/devices/evse.d.ts

@@ -6,7 +6,9 @@ import { EnergyEvse } from '@matter/types/clusters/energy-evse';
 import { EnergyEvseMode } from '@matter/types/clusters/energy-evse-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import type { Semtag } from '@matter/types/globals';
+import { type AnsiLogger } from 'node-ansi-logger';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { ClusterAttributeValues } from '../matterbridgeEndpointCommandHandler.js';
 export interface EvseOptions {
     mode?: 'server' | 'matter';
     id?: string;
@@ -23,12 +25,19 @@ export interface EvseOptions {
     energy?: number | bigint | null;
     absMinPower?: number;
     absMaxPower?: number;
+    esaCanGenerate?: boolean;
+    stateOfCharge?: number | null;
+    batteryCapacity?: number | bigint | null;
+    vehicleId?: string | null;
+    rfid?: boolean;
+    v2x?: boolean;
 }
 export declare class Evse extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: EvseOptions);
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: EnergyEvseMode.ModeOption[], state?: EnergyEvse.State, supplyState?: EnergyEvse.SupplyState, faultState?: EnergyEvse.FaultState, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energy?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
-    createDefaultEnergyEvseClusterServer(state?: EnergyEvse.State, supplyState?: EnergyEvse.SupplyState, faultState?: EnergyEvse.FaultState): this;
-    createDefaultEnergyEvseModeClusterServer(currentMode?: number, supportedModes?: EnergyEvseMode.ModeOption[]): this;
+    createDefaultEnergyEvseClusterServer(state?: EnergyEvse.State, supplyState?: EnergyEvse.SupplyState, faultState?: EnergyEvse.FaultState, stateOfCharge?: number | null, batteryCapacity?: number | bigint | null, vehicleId?: string | null, rfid?: boolean, v2x?: boolean): this;
+    createDefaultEnergyEvseModeClusterServer(currentMode?: number, supportedModes?: EnergyEvseMode.ModeOption[], v2x?: boolean): this;
+    triggerRfidEvent(uid: Uint8Array, log?: AnsiLogger): Promise<boolean>;
 }
 declare const MatterbridgeEnergyEvseServer_base: import("@matter/node").ClusterBehavior.Type<typeof EnergyEvseServer, import("@matter/types").ClusterType.WithSupportedFeatures<EnergyEvse, {
     chargingPreferences: true;
@@ -40,21 +49,35 @@ declare const MatterbridgeEnergyEvseServer_base: import("@matter/node").ClusterB
 export declare class MatterbridgeEnergyEvseServer extends MatterbridgeEnergyEvseServer_base {
     #private;
     protected internal: MatterbridgeEnergyEvseServer.Internal;
+    state: ClusterAttributeValues<(typeof EnergyEvse)['attributes']> & MatterbridgeEnergyEvseServer.State;
     initialize(): Promise<void>;
     disable(): Promise<void>;
     enableCharging(request: EnergyEvse.EnableChargingRequest): Promise<void>;
+    enableDischarging(request: EnergyEvse.EnableDischargingRequest): Promise<void>;
     startDiagnostics(): Promise<void>;
     setTargets(request: EnergyEvse.SetTargetsRequest): Promise<void>;
     getTargets(): Promise<EnergyEvse.GetTargetsResponse>;
     clearTargets(): Promise<void>;
 }
 export declare namespace MatterbridgeEnergyEvseServer {
-    class Internal {
+    export class Internal {
         chargingExpiryTimer: Timer | undefined;
-        chargingTargetSchedules: EnergyEvse.ChargingTargetSchedule[];
+        dischargingExpiryTimer: Timer | undefined;
         maximumChargeCurrentUpdateTimer: Timer | undefined;
-        requestedMaximumChargeCurrent: number;
     }
+    const State_base: new () => import("@matter/node").ClusterState.Type<import("@matter/types").ClusterType.WithSupportedFeatures<EnergyEvse, {
+        chargingPreferences: true;
+        plugAndCharge: false;
+        rfid: false;
+        soCReporting: false;
+        v2X: false;
+    }>, typeof EnergyEvseServer>;
+    export class State extends State_base {
+        chargingTargetSchedules: EnergyEvse.ChargingTargetSchedule[];
+        requestedMaximumChargeCurrent: number | undefined;
+        requestedMaximumDischargeCurrent: number | undefined;
+    }
+    export {};
 }
 export declare class MatterbridgeEnergyEvseModeServer extends EnergyEvseModeServer {
     changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;

package/dist/devices/evse.js

@@ -20,8 +20,8 @@ export class Evse extends MatterbridgeEndpoint {
         super([evse], { id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, number: options.number, tagList: options.tagList, mode: options.mode });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Evse')
-            .createDefaultEnergyEvseClusterServer(options.state, options.supplyState, options.faultState)
-            .createDefaultEnergyEvseModeClusterServer(options.currentMode, options.supportedModes)
+            .createDefaultEnergyEvseClusterServer(options.state, options.supplyState, options.faultState, options.stateOfCharge, options.batteryCapacity, options.vehicleId, options.rfid, options.v2x)
+            .createDefaultEnergyEvseModeClusterServer(options.currentMode, options.supportedModes, options.v2x)
             .createDefaultTemperatureMeasurementClusterServer(24_00)
             .addRequiredClusterServers();
         fireAndForget(this.addFixedLabel('composed', 'EVSE'), this.log, 'Error adding composed label to EVSE');
@@ -32,12 +32,13 @@ export class Evse extends MatterbridgeEndpoint {
             .createDefaultElectricalEnergyMeasurementClusterServer(options.energy ?? null, 0)
             .addRequiredClusterServers();
         this.addChildDeviceType('DeviceEnergyManagement', deviceEnergyManagement)
-            .createDefaultDeviceEnergyManagementClusterServer(DeviceEnergyManagement.EsaType.Evse, false, DeviceEnergyManagement.EsaState.Online, options.absMinPower, options.absMaxPower)
+            .createDefaultDeviceEnergyManagementClusterServer(DeviceEnergyManagement.EsaType.Evse, options.esaCanGenerate ?? false, DeviceEnergyManagement.EsaState.Online, options.absMinPower, options.absMaxPower)
             .createDefaultDeviceEnergyManagementModeClusterServer()
             .addRequiredClusterServers();
     }
-    createDefaultEnergyEvseClusterServer(state, supplyState, faultState) {
-        this.behaviors.require(MatterbridgeEnergyEvseServer.with(EnergyEvse.Feature.ChargingPreferences), {
+    createDefaultEnergyEvseClusterServer(state, supplyState, faultState, stateOfCharge, batteryCapacity, vehicleId, rfid, v2x) {
+        const evseServer = MatterbridgeEnergyEvseServer.with(EnergyEvse.Feature.ChargingPreferences, ...(stateOfCharge !== undefined ? [EnergyEvse.Feature.SoCReporting] : []), ...(vehicleId !== undefined ? [EnergyEvse.Feature.PlugAndCharge] : []), ...(rfid ? [EnergyEvse.Feature.Rfid] : []), ...(v2x ? [EnergyEvse.Feature.V2X] : []));
+        this.behaviors.require(rfid ? evseServer.enable({ events: { rfid: true } }) : evseServer, {
             state: state !== undefined ? state : EnergyEvse.State.NotPluggedIn,
             supplyState: supplyState !== undefined ? supplyState : EnergyEvse.SupplyState.ChargingEnabled,
             faultState: faultState !== undefined ? faultState : EnergyEvse.FaultState.NoError,
@@ -49,26 +50,44 @@ export class Evse extends MatterbridgeEndpoint {
             sessionId: null,
             sessionDuration: null,
             sessionEnergyCharged: null,
+            ...(stateOfCharge !== undefined ? { stateOfCharge, batteryCapacity: batteryCapacity ?? null } : {}),
+            ...(vehicleId !== undefined ? { vehicleId } : {}),
+            ...(v2x ? { dischargingEnabledUntil: null, maximumDischargeCurrent: 0, sessionEnergyDischarged: null } : {}),
         });
         return this;
     }
-    createDefaultEnergyEvseModeClusterServer(currentMode, supportedModes) {
+    createDefaultEnergyEvseModeClusterServer(currentMode, supportedModes, v2x) {
         this.behaviors.require(MatterbridgeEnergyEvseModeServer, {
             supportedModes: supportedModes ?? [
                 { label: 'On demand', mode: 1, modeTags: [{ value: EnergyEvseMode.ModeTag.Manual }] },
                 { label: 'Scheduled', mode: 2, modeTags: [{ value: EnergyEvseMode.ModeTag.TimeOfUse }] },
                 { label: 'Solar charging', mode: 3, modeTags: [{ value: EnergyEvseMode.ModeTag.SolarCharging }] },
+                ...(v2x ? [{ label: 'Home to vehicle and Vehicle to home', mode: 4, modeTags: [{ value: EnergyEvseMode.ModeTag.V2X }] }] : []),
             ],
             currentMode: currentMode ?? 1,
         });
         return this;
     }
+    async triggerRfidEvent(uid, log) {
+        if (![4, 7, 10].includes(uid.length)) {
+            (log ?? this.log).warn(`triggerRfidEvent: invalid RFID uid length ${uid.length} (expected 4, 7 or 10 bytes)`);
+            return false;
+        }
+        return this.triggerEvent(EnergyEvseServer.with(EnergyEvse.Feature.Rfid), 'rfid', { uid }, log);
+    }
 }
 export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEvse.Feature.ChargingPreferences) {
     async initialize() {
         await super.initialize();
-        this.internal.requestedMaximumChargeCurrent = Number(this.state.maximumChargeCurrent);
-        this.internal.chargingTargetSchedules = [];
+        this.state.requestedMaximumChargeCurrent ??= Number(this.state.maximumChargeCurrent);
+        this.state.requestedMaximumDischargeCurrent ??= this.features.v2X ? Number(this.state.maximumDischargeCurrent) : 0;
+        this.state.chargingTargetSchedules ??= [];
+        if (this.state.chargingEnabledUntil !== null) {
+            this.#scheduleChargingExpiry(this.state.chargingEnabledUntil);
+        }
+        if (this.features.v2X && this.state.dischargingEnabledUntil !== null) {
+            this.#scheduleDischargingExpiry(this.state.dischargingEnabledUntil);
+        }
         const userMaximumChargeCurrentChanged = this.events.userMaximumChargeCurrent$Changed;
         if (userMaximumChargeCurrentChanged) {
             this.reactTo(userMaximumChargeCurrentChanged, this.#handleUserMaximumChargeCurrentChanged);
@@ -87,6 +106,10 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
         device.log.debug(`MatterbridgeEnergyEvseServer: disable called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.state.chargingEnabledUntil = MATTER_EPOCH_OFFSET_S;
         this.#stopCharging(EnergyEvse.EnergyTransferStoppedReason.EvseStopped);
+        if (this.features.v2X) {
+            this.state.dischargingEnabledUntil = MATTER_EPOCH_OFFSET_S;
+            this.#stopDischarging(EnergyEvse.EnergyTransferStoppedReason.EvseStopped);
+        }
     }
     async enableCharging(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -99,24 +122,56 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
             endpoint: this.endpoint,
         });
         device.log.debug(`MatterbridgeEnergyEvseServer: enableCharging called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        if (this.state.supplyState === EnergyEvse.SupplyState.DisabledDiagnostics) {
-            throw new StatusResponse.FailureError(`MatterbridgeEnergyEvseServer: cannot enable charging while diagnostics are active (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (this.state.supplyState === EnergyEvse.SupplyState.DisabledError ||
+            this.state.supplyState === EnergyEvse.SupplyState.DisabledDiagnostics ||
+            this.state.faultState !== EnergyEvse.FaultState.NoError) {
+            throw new StatusResponse.FailureError(`MatterbridgeEnergyEvseServer: cannot enable charging while an error or diagnostics are active (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         }
         this.internal.chargingExpiryTimer?.stop();
         this.internal.chargingExpiryTimer = undefined;
-        this.state.supplyState = EnergyEvse.SupplyState.ChargingEnabled;
+        this.state.supplyState = this.#isDischargingActive() ? EnergyEvse.SupplyState.Enabled : EnergyEvse.SupplyState.ChargingEnabled;
         this.state.chargingEnabledUntil = request.chargingEnabledUntil;
         this.state.minimumChargeCurrent = request.minimumChargeCurrent;
-        this.internal.requestedMaximumChargeCurrent = Number(request.maximumChargeCurrent);
+        this.state.requestedMaximumChargeCurrent = Number(request.maximumChargeCurrent);
         this.#updateMaximumChargeCurrent();
-        this.#updateNextChargeTarget();
         if (this.state.state === EnergyEvse.State.PluggedInDemand) {
             this.state.state = EnergyEvse.State.PluggedInCharging;
-            this.events.energyTransferStarted.emit({ sessionId: this.state.sessionId ?? 0, state: EnergyEvse.State.PluggedInCharging, maximumCurrent: this.state.maximumChargeCurrent }, this.context);
+            this.events.energyTransferStarted.emit({
+                sessionId: this.state.sessionId ?? 0,
+                state: this.state.state,
+                maximumCurrent: this.state.maximumChargeCurrent,
+                ...(this.features.v2X ? { maximumDischargeCurrent: this.state.maximumDischargeCurrent } : {}),
+            }, this.context);
         }
+        this.#updateNextChargeTarget();
         if (request.chargingEnabledUntil !== null) {
-            const remainingSeconds = Math.max(0, Math.ceil(request.chargingEnabledUntil - Time.nowMs / 1000));
-            this.internal.chargingExpiryTimer = Time.getTimer('EnergyEvse charging expiry', Seconds(remainingSeconds), this.callback(this.#expireCharging, { lock: true })).start();
+            this.#scheduleChargingExpiry(request.chargingEnabledUntil);
+        }
+    }
+    async enableDischarging(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeEnergyEvseServer: enableDischarging (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('EnergyEvse.enableDischarging', {
+            command: 'enableDischarging',
+            request,
+            cluster: EnergyEvseServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        device.log.debug(`MatterbridgeEnergyEvseServer: enableDischarging called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (this.state.supplyState === EnergyEvse.SupplyState.DisabledError ||
+            this.state.supplyState === EnergyEvse.SupplyState.DisabledDiagnostics ||
+            this.state.faultState !== EnergyEvse.FaultState.NoError) {
+            throw new StatusResponse.FailureError(`MatterbridgeEnergyEvseServer: cannot enable discharging while an error or diagnostics are active (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        }
+        this.internal.dischargingExpiryTimer?.stop();
+        this.internal.dischargingExpiryTimer = undefined;
+        this.state.supplyState = this.#isChargingActive() ? EnergyEvse.SupplyState.Enabled : EnergyEvse.SupplyState.DischargingEnabled;
+        this.state.dischargingEnabledUntil = request.dischargingEnabledUntil;
+        this.state.requestedMaximumDischargeCurrent = Number(request.maximumDischargeCurrent);
+        this.#updateMaximumDischargeCurrent();
+        if (request.dischargingEnabledUntil !== null) {
+            this.#scheduleDischargingExpiry(request.dischargingEnabledUntil);
         }
     }
     async startDiagnostics() {
@@ -138,25 +193,70 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
     }
     #expireCharging() {
         this.internal.chargingExpiryTimer = undefined;
+        this.state.chargingEnabledUntil = MATTER_EPOCH_OFFSET_S;
         this.#stopCharging(EnergyEvse.EnergyTransferStoppedReason.EvseStopped);
     }
+    #expireDischarging() {
+        this.internal.dischargingExpiryTimer = undefined;
+        this.state.dischargingEnabledUntil = MATTER_EPOCH_OFFSET_S;
+        this.#stopDischarging(EnergyEvse.EnergyTransferStoppedReason.EvseStopped);
+    }
+    #scheduleChargingExpiry(chargingEnabledUntil) {
+        const remainingSeconds = Math.max(0, Math.ceil(chargingEnabledUntil - Time.nowMs / 1000));
+        this.internal.chargingExpiryTimer = Time.getTimer('EnergyEvse charging expiry', Seconds(remainingSeconds), this.callback(this.#expireCharging, { lock: true })).start();
+    }
+    #scheduleDischargingExpiry(dischargingEnabledUntil) {
+        const remainingSeconds = Math.max(0, Math.ceil(dischargingEnabledUntil - Time.nowMs / 1000));
+        this.internal.dischargingExpiryTimer = Time.getTimer('EnergyEvse discharging expiry', Seconds(remainingSeconds), this.callback(this.#expireDischarging, { lock: true })).start();
+    }
+    #isChargingActive() {
+        return this.state.supplyState === EnergyEvse.SupplyState.ChargingEnabled || this.state.supplyState === EnergyEvse.SupplyState.Enabled;
+    }
+    #isDischargingActive() {
+        return this.state.supplyState === EnergyEvse.SupplyState.DischargingEnabled || this.state.supplyState === EnergyEvse.SupplyState.Enabled;
+    }
     #handleUserMaximumChargeCurrentChanged() {
         this.internal.maximumChargeCurrentUpdateTimer?.stop();
         this.internal.maximumChargeCurrentUpdateTimer = Time.getTimer('EnergyEvse maximum charge current update', Seconds(0), this.callback(this.#updateMaximumChargeCurrent, { lock: true })).start();
     }
     #updateMaximumChargeCurrent() {
-        this.state.maximumChargeCurrent = Math.min(Number(this.state.circuitCapacity), this.internal.requestedMaximumChargeCurrent, Number(this.state.userMaximumChargeCurrent));
+        this.state.maximumChargeCurrent = Math.min(Number(this.state.circuitCapacity), Number(this.state.requestedMaximumChargeCurrent), Number(this.state.userMaximumChargeCurrent));
+    }
+    #updateMaximumDischargeCurrent() {
+        this.state.maximumDischargeCurrent = Math.min(Number(this.state.circuitCapacity), Number(this.state.requestedMaximumDischargeCurrent));
     }
     #stopCharging(reason) {
         this.internal.chargingExpiryTimer?.stop();
         this.internal.chargingExpiryTimer = undefined;
         if (this.state.state === EnergyEvse.State.PluggedInCharging) {
-            this.events.energyTransferStopped.emit({ sessionId: this.state.sessionId ?? 0, state: this.state.state, reason, energyTransferred: 0 }, this.context);
+            this.events.energyTransferStopped.emit({
+                sessionId: this.state.sessionId ?? 0,
+                state: this.state.state,
+                reason,
+                energyTransferred: 0,
+                ...(this.features.v2X ? { energyDischarged: 0 } : {}),
+            }, this.context);
             this.state.state = EnergyEvse.State.PluggedInDemand;
         }
-        this.state.supplyState = EnergyEvse.SupplyState.Disabled;
+        this.state.supplyState =
+            this.features.v2X && this.#isPermissionActive(this.state.dischargingEnabledUntil) ? EnergyEvse.SupplyState.DischargingEnabled : EnergyEvse.SupplyState.Disabled;
+        this.state.minimumChargeCurrent = 0;
+        this.state.maximumChargeCurrent = 0;
         this.#clearNextChargeTarget();
     }
+    #stopDischarging(reason) {
+        this.internal.dischargingExpiryTimer?.stop();
+        this.internal.dischargingExpiryTimer = undefined;
+        if (this.state.state === EnergyEvse.State.PluggedInDischarging) {
+            this.events.energyTransferStopped.emit({ sessionId: this.state.sessionId ?? 0, state: this.state.state, reason, energyTransferred: 0, energyDischarged: 0 }, this.context);
+            this.state.state = EnergyEvse.State.PluggedInDemand;
+        }
+        this.state.supplyState = this.#isPermissionActive(this.state.chargingEnabledUntil) ? EnergyEvse.SupplyState.ChargingEnabled : EnergyEvse.SupplyState.Disabled;
+        this.state.maximumDischargeCurrent = 0;
+    }
+    #isPermissionActive(enabledUntil) {
+        return enabledUntil === null || enabledUntil > Time.nowMs / 1000;
+    }
     async setTargets(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeEnergyEvseServer: setTargets request ${debugStringify(request.chargingTargetSchedules)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -169,6 +269,9 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
         });
         let updatedDays = 0;
         for (const schedule of request.chargingTargetSchedules) {
+            if (this.features.soCReporting && schedule.chargingTargets.some((target) => target.targetSoC === undefined || target.targetSoC === null)) {
+                throw new StatusResponse.InvalidCommandError(`MatterbridgeEnergyEvseServer: TargetSoC is required when SoC reporting is available (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            }
             const scheduleDays = this.#encodeTargetDays(schedule.dayOfWeekForSequence);
             if ((updatedDays & scheduleDays) !== 0) {
                 throw new StatusResponse.ConstraintErrorError(`MatterbridgeEnergyEvseServer: each day may occur in only one ChargingTargetSchedule (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -178,11 +281,11 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
             }
             updatedDays |= scheduleDays;
         }
-        const unchangedSchedules = this.internal.chargingTargetSchedules.flatMap((schedule) => {
+        const unchangedSchedules = this.state.chargingTargetSchedules.flatMap((schedule) => {
             const remainingDays = this.#encodeTargetDays(schedule.dayOfWeekForSequence) & ~updatedDays;
             return remainingDays === 0 ? [] : [{ ...schedule, dayOfWeekForSequence: new EnergyEvse.TargetDayOfWeek(remainingDays) }];
         });
-        this.internal.chargingTargetSchedules = [...unchangedSchedules, ...structuredClone(request.chargingTargetSchedules)];
+        this.state.chargingTargetSchedules = [...unchangedSchedules, ...structuredClone(request.chargingTargetSchedules)];
         this.#updateNextChargeTarget();
     }
     async getTargets() {
@@ -195,7 +298,7 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        return { chargingTargetSchedules: structuredClone(this.internal.chargingTargetSchedules) };
+        return { chargingTargetSchedules: structuredClone(this.state.chargingTargetSchedules) };
     }
     async clearTargets() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -207,7 +310,12 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        this.internal.chargingTargetSchedules = [];
+        this.state.chargingTargetSchedules = [];
+        const modeState = this.endpoint.stateOf(EnergyEvseModeServer);
+        const isAutomaticMode = modeState.supportedModes.some((mode) => mode.mode === modeState.currentMode && mode.modeTags.some((tag) => tag.value === EnergyEvseMode.ModeTag.TimeOfUse));
+        if (isAutomaticMode && this.state.state === EnergyEvse.State.PluggedInCharging) {
+            this.#stopCharging(EnergyEvse.EnergyTransferStoppedReason.EvseStopped);
+        }
         this.#clearNextChargeTarget();
     }
     #encodeTargetDays(days) {
@@ -227,14 +335,14 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
     }
     #updateNextChargeTarget() {
         this.#clearNextChargeTarget();
-        if (this.state.supplyState !== EnergyEvse.SupplyState.ChargingEnabled || this.state.state === EnergyEvse.State.NotPluggedIn)
+        if (!this.#isChargingActive() || this.state.state === EnergyEvse.State.NotPluggedIn)
             return;
         const now = new Date(Time.nowMs);
         for (let dayOffset = 0; dayOffset <= 7; dayOffset++) {
             const targetDate = new Date(now);
             targetDate.setDate(now.getDate() + dayOffset);
             const dayBit = 1 << targetDate.getDay();
-            const schedule = this.internal.chargingTargetSchedules.find((candidate) => (this.#encodeTargetDays(candidate.dayOfWeekForSequence) & dayBit) !== 0);
+            const schedule = this.state.chargingTargetSchedules.find((candidate) => (this.#encodeTargetDays(candidate.dayOfWeekForSequence) & dayBit) !== 0);
             if (!schedule)
                 continue;
             const targets = schedule.chargingTargets.toSorted((a, b) => a.targetTimeMinutesPastMidnight - b.targetTimeMinutesPastMidnight);
@@ -243,13 +351,15 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
                 if (targetDate.getTime() <= now.getTime())
                     continue;
                 const targetTime = Math.floor(targetDate.getTime() / 1000);
-                const requiredEnergy = target.addedEnergy === undefined ? null : target.addedEnergy;
+                const useTargetSoC = target.targetSoC !== undefined && (target.addedEnergy === undefined || (this.features.soCReporting && this.state.stateOfCharge !== null));
+                const requiredEnergy = useTargetSoC || target.addedEnergy === undefined ? null : target.addedEnergy;
+                const targetSoCReached = useTargetSoC && this.state.stateOfCharge !== null && this.state.stateOfCharge >= Number(target.targetSoC);
                 this.state.nextChargeTargetTime = targetTime;
                 this.state.nextChargeRequiredEnergy = requiredEnergy;
-                this.state.nextChargeTargetSoC = target.addedEnergy === undefined ? (target.targetSoC ?? null) : null;
+                this.state.nextChargeTargetSoC = useTargetSoC ? Number(target.targetSoC) : null;
                 const maximumPowerMw = (230_000 * Number(this.state.maximumChargeCurrent)) / 1_000;
                 const chargingSeconds = requiredEnergy === null || maximumPowerMw <= 0 ? 1 : Math.max(1, Math.ceil((Number(requiredEnergy) * 3_600) / maximumPowerMw));
-                this.state.nextChargeStartTime = targetTime - chargingSeconds;
+                this.state.nextChargeStartTime = targetSoCReached ? null : targetTime - chargingSeconds;
                 return;
             }
         }
@@ -259,11 +369,16 @@ Supervision(MatterbridgeEnergyEvseServer.prototype.constructor, 'setTargets', 'c
 (function (MatterbridgeEnergyEvseServer) {
     class Internal {
         chargingExpiryTimer;
-        chargingTargetSchedules = [];
+        dischargingExpiryTimer;
         maximumChargeCurrentUpdateTimer;
-        requestedMaximumChargeCurrent = 0;
     }
     MatterbridgeEnergyEvseServer.Internal = Internal;
+    class State extends EnergyEvseServer.with(EnergyEvse.Feature.ChargingPreferences).State {
+        chargingTargetSchedules = [];
+        requestedMaximumChargeCurrent = undefined;
+        requestedMaximumDischargeCurrent = undefined;
+    }
+    MatterbridgeEnergyEvseServer.State = State;
 })(MatterbridgeEnergyEvseServer || (MatterbridgeEnergyEvseServer = {}));
 export class MatterbridgeEnergyEvseModeServer extends EnergyEvseModeServer {
     async changeToMode(request) {

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -847,6 +847,7 @@ export type CommandHandlerDataMap = {
         endpoint: MatterbridgeEndpoint;
     };
     'enableCharging': CommandHandlerData<'EnergyEvse.enableCharging'>;
+    'enableDischarging': CommandHandlerData<'EnergyEvse.enableDischarging'>;
     'disable': CommandHandlerData<'EnergyEvse.disable'>;
     'setTargets': CommandHandlerData<'EnergyEvse.setTargets'>;
     'getTargets': CommandHandlerData<'EnergyEvse.getTargets'>;
@@ -858,6 +859,13 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof EnergyEvse)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'EnergyEvse.enableDischarging': {
+        command: 'enableDischarging';
+        request: EnergyEvse.EnableDischargingRequest;
+        cluster: 'energyEvse';
+        attributes: ClusterAttributeValues<(typeof EnergyEvse)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'EnergyEvse.disable': {
         command: 'disable';
         request: {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.9-dev-20260906-2a9dc0e",
+  "version": "3.10.9-dev-20260907-5fcc59a",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -132,10 +132,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.9-dev-20260906-2a9dc0e",
-    "@matterbridge/thread": "3.10.9-dev-20260906-2a9dc0e",
-    "@matterbridge/types": "3.10.9-dev-20260906-2a9dc0e",
-    "@matterbridge/utils": "3.10.9-dev-20260906-2a9dc0e",
+    "@matterbridge/dgram": "3.10.9-dev-20260907-5fcc59a",
+    "@matterbridge/thread": "3.10.9-dev-20260907-5fcc59a",
+    "@matterbridge/types": "3.10.9-dev-20260907-5fcc59a",
+    "@matterbridge/utils": "3.10.9-dev-20260907-5fcc59a",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.0",