npm - matterbridge-example-dynamic-platform - Versions diffs - 1.2.0-edge.3 → 1.2.0-edge.7 - Mend

matterbridge-example-dynamic-platform 1.2.0-edge.3 → 1.2.0-edge.7

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.

Files changed (4) hide show

package/dist/appliances.js CHANGED Viewed

@@ -1,74 +1,109 @@
-import { DeviceClasses, DeviceTypeDefinition, MatterbridgeEndpoint, Status, Matterbridge, VendorId, DeviceTypeId, MatterbridgeServer, smokeCoAlarm, } from 'matterbridge';
+import { DeviceTypeId, Matterbridge, MatterbridgeEndpoint, MatterbridgeServer, MatterbridgeOnOffServer, Status, VendorId, smokeCoAlarm, RefrigeratorTag, PositionTag, laundryWasher, laundryDryer, dishwasher, refrigerator, temperatureControlledCabinetCooler, oven, temperatureControlledCabinetHeater, microwaveOven, extractorHood, cooktop, cookSurface, } from 'matterbridge';
 import { ClusterBehavior, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, EndpointServer, logEndpoint } from 'matterbridge/matter';
-import { Identify, OperationalState, OnOff, TemperatureControl, DishwasherAlarm, DishwasherMode, LaundryWasherControls, LaundryWasherMode, TemperatureMeasurement, OvenMode, RefrigeratorAndTemperatureControlledCabinetMode, } from 'matterbridge/matter/clusters';
-import { DishwasherAlarmServer, OperationalStateBehavior, TemperatureControlBehavior } from 'matterbridge/matter/behaviors';
+import { OperationalState, TemperatureControl, DishwasherMode, LaundryWasherControls, LaundryWasherMode, LaundryDryerControls, OvenMode, RefrigeratorAndTemperatureControlledCabinetMode, MicrowaveOvenMode, MicrowaveOvenControl, } from 'matterbridge/matter/clusters';
+import { DishwasherAlarmServer, LaundryDryerControlsServer, LaundryWasherControlsServer, MicrowaveOvenControlBehavior, MicrowaveOvenModeServer, OperationalStateBehavior, TemperatureControlBehavior, } from 'matterbridge/matter/behaviors';
 import { OvenCavityOperationalState } from './implementations/ovenCavityOperationalStateCluster.js';
 import { AnsiLogger } from 'matterbridge/logger';
 import { Robot } from './robot.js';
 export class Appliances extends MatterbridgeEndpoint {
-    static temperatureControlledCabinetCooler = DeviceTypeDefinition({
-        name: 'MA-temperaturecontrolledcabinetcooler',
-        code: 0x71,
-        deviceClass: DeviceClasses.Simple,
-        revision: 3,
-        requiredServerClusters: [TemperatureControl.Cluster.id, RefrigeratorAndTemperatureControlledCabinetMode.Cluster.id],
-        optionalServerClusters: [TemperatureMeasurement.Cluster.id],
-    });
-    static temperatureControlledCabinetHeater = DeviceTypeDefinition({
-        name: 'MA-temperaturecontrolledcabinetheater',
-        code: 0x71,
-        deviceClass: DeviceClasses.Simple,
-        revision: 3,
-        requiredServerClusters: [TemperatureControl.Cluster.id, OvenMode.Cluster.id, OvenCavityOperationalState.Cluster.id],
-        optionalServerClusters: [TemperatureMeasurement.Cluster.id],
-    });
-    static laundryWasher = DeviceTypeDefinition({
-        name: 'MA-laundrywasher',
-        code: 0x73,
-        deviceClass: DeviceClasses.Simple,
-        revision: 1,
-        requiredServerClusters: [OperationalState.Cluster.id],
-        optionalServerClusters: [Identify.Cluster.id, LaundryWasherMode.Cluster.id, OnOff.Cluster.id, LaundryWasherControls.Cluster.id, TemperatureControl.Cluster.id],
-    });
-    static dishwasher = DeviceTypeDefinition({
-        name: 'MA-dishwasher',
-        code: 0x75,
-        deviceClass: DeviceClasses.Simple,
-        revision: 1,
-        requiredServerClusters: [OperationalState.Cluster.id],
-        optionalServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, TemperatureControl.Cluster.id, DishwasherMode.Cluster.id, DishwasherAlarm.Cluster.id],
-    });
     constructor(deviceType, name, serial) {
-        super(deviceType, { uniqueStorageKey: `${name}-${serial}` });
-        if (deviceType.code === Appliances.laundryWasher.code) {
+        super(deviceType, { uniqueStorageKey: `${name}-${serial}` }, true);
+        if (deviceType.code === laundryWasher.code) {
             this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Laundry Washer');
-            this.createLevelTemperatureControlClusterServer(1, ['Cold', '30°', '40°', '60°']);
+            this.createDeadFrontOnOffClusterServer();
+            this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
+            this.createDefaultLaundryWasherModeClusterServer();
+            this.createSpinLaundryWasherControlsClusterServer(3, ['400', '800', '1200', '1600']);
             this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
         }
-        else if (deviceType.code === Appliances.dishwasher.code) {
+        else if (deviceType.code === laundryDryer.code) {
             this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Laundry Dryer');
             this.createDeadFrontOnOffClusterServer();
+            this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
+            this.createDefaultLaundryWasherModeClusterServer();
+            this.createDefaultLaundryDryerControlsClusterServer(1);
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+        else if (deviceType.code === dishwasher.code) {
+            this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Dishwasher');
+            this.createDeadFrontOnOffClusterServer();
             this.createLevelTemperatureControlClusterServer(1, ['Cold', '30°', '40°', '60°']);
             this.createDefaultDishwasherModeClusterServer();
             this.createDefaultDishwasherAlarmClusterServer();
             this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
         }
-        else if (deviceType.name === Appliances.temperatureControlledCabinetCooler.name) {
+        else if (deviceType.name === refrigerator.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Refrigerator');
+            const refrigerator = this.addChildDeviceType('Refrigerator', temperatureControlledCabinetCooler, { tagList: [{ mfgCode: null, namespaceId: RefrigeratorTag.Refrigerator.namespaceId, tag: RefrigeratorTag.Refrigerator.tag, label: RefrigeratorTag.Refrigerator.label }] }, true);
+            refrigerator.log.logName = `Refrigerator (cabinet Refrigerator)`;
+            refrigerator.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(refrigerator, 2, ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']);
+            refrigerator.createDefaultTemperatureMeasurementClusterServer(1000);
+            Appliances.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(refrigerator, 1);
+            const freezer = this.addChildDeviceType('Freezer', temperatureControlledCabinetCooler, { tagList: [{ mfgCode: null, namespaceId: RefrigeratorTag.Freezer.namespaceId, tag: RefrigeratorTag.Freezer.tag, label: RefrigeratorTag.Freezer.label }] }, true);
+            freezer.log.logName = `Refrigerator (cabinet Freezer)`;
+            freezer.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(freezer, 2, ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']);
+            freezer.createDefaultTemperatureMeasurementClusterServer(-2000);
+            Appliances.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(freezer, 1);
+        }
+        else if (deviceType.name === oven.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Oven');
+            const cabinettop = this.addChildDeviceType('Oven (top)', temperatureControlledCabinetHeater, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Top.namespaceId, tag: PositionTag.Top.tag, label: PositionTag.Top.label }] }, true);
+            cabinettop.log.logName = `Oven (top)`;
+            cabinettop.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(cabinettop, 2, ['Defrost', '180°', '200°', '250°', '300°']);
+            cabinettop.createDefaultTemperatureMeasurementClusterServer(20000);
+            Appliances.createDefaultOvenModeClusterServer(cabinettop, 1);
+            const cabinetbottom = this.addChildDeviceType('Oven (bottom)', temperatureControlledCabinetHeater, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Bottom.namespaceId, tag: PositionTag.Bottom.tag, label: PositionTag.Bottom.label }] }, true);
+            cabinetbottom.log.logName = `Oven (bottom)`;
+            cabinetbottom.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(cabinetbottom, 2, ['Defrost', '180°', '200°', '250°', '300°']);
+            cabinetbottom.createDefaultTemperatureMeasurementClusterServer(30000);
+            Appliances.createDefaultOvenModeClusterServer(cabinetbottom, 1);
+        }
+        else if (deviceType.name === microwaveOven.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Microwave Oven');
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+            this.createDefaultMicrowaveOvenModeClusterServer();
+            this.createDefaultMicrowaveOvenControlClusterServer();
+        }
+        else if (deviceType.name === extractorHood.name) {
             this.createDefaultIdentifyClusterServer();
-            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Temperature Controlled Cabinet Cooler');
-            this.createLevelTemperatureControlClusterServer(1, ['Cold', 'Warm', 'Hot']);
-            this.createDefaultTemperatureMeasurementClusterServer(1500);
-            this.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(1);
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Extractor Hood');
+            this.createBaseFanControlClusterServer();
+            this.createDefaultHepaFilterMonitoringClusterServer();
+            this.createDefaultActivatedCarbonFilterMonitoringClusterServer();
         }
-        else if (deviceType.name === Appliances.temperatureControlledCabinetHeater.name) {
+        else if (deviceType.name === cooktop.name) {
             this.createDefaultIdentifyClusterServer();
-            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Temperature Controlled Cabinet Heater');
-            this.createLevelTemperatureControlClusterServer(1, ['Cold', 'Warm', 'Hot']);
-            this.createDefaultTemperatureMeasurementClusterServer(2500);
-            this.createDefaultOvenModeClusterServer(3);
-            this.createDefaultOvenCavityOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Cooktop');
+            this.createOffOnlyOnOffClusterServer(true);
+            const cookSurface1 = this.addChildDeviceType('Surface 1', cookSurface, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Left.namespaceId, tag: PositionTag.Left.tag, label: PositionTag.Left.label }] }, true);
+            cookSurface1.log.logName = `Cook surface (right)`;
+            cookSurface1.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(cookSurface1, 2, ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']);
+            cookSurface1.createDefaultTemperatureMeasurementClusterServer(10000);
+            cookSurface1.createOffOnlyOnOffClusterServer(true);
+            const cookSurface2 = this.addChildDeviceType('Surface 2', cookSurface, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Right.namespaceId, tag: PositionTag.Right.tag, label: PositionTag.Right.label }] }, true);
+            cookSurface2.log.logName = `Cook surface (left)`;
+            cookSurface2.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(cookSurface2, 3, ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']);
+            cookSurface2.createDefaultTemperatureMeasurementClusterServer(12000);
+            cookSurface2.createOffOnlyOnOffClusterServer(true);
+            this.eventsOf(MatterbridgeOnOffServer).onOff$Changed.on(async (value) => {
+                if (!value) {
+                    this.log.notice('Turning off all cook surfaces');
+                    await cookSurface1.setStateOf(MatterbridgeOnOffServer, { onOff: false });
+                    await cookSurface2.setStateOf(MatterbridgeOnOffServer, { onOff: false });
+                }
+            });
         }
     }
     createDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
@@ -100,15 +135,34 @@ export class Appliances extends MatterbridgeEndpoint {
         });
         return this;
     }
-    createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(currentMode) {
-        this.behaviors.require(RefrigeratorAndTemperatureControlledCabinetModeServer, {
+    static createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(endpoint, currentMode) {
+        endpoint.behaviors.require(RefrigeratorAndTemperatureControlledCabinetModeServer, {
             supportedModes: [
+                { label: 'Auto', mode: 0, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.Auto }] },
                 { label: 'RapidCool', mode: 1, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidCool }] },
                 { label: 'RapidFreeze', mode: 2, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidFreeze }] },
             ],
             currentMode,
         });
-        return this;
+        return endpoint;
+    }
+    static createDefaultOvenModeClusterServer(endpoint, currentMode) {
+        endpoint.behaviors.require(OvenModeServer, {
+            supportedModes: [
+                { label: 'Bake', mode: 1, modeTags: [{ value: OvenMode.ModeTag.Bake }] },
+                { label: 'Convection', mode: 2, modeTags: [{ value: OvenMode.ModeTag.Convection }] },
+                { label: 'Grill', mode: 3, modeTags: [{ value: OvenMode.ModeTag.Grill }] },
+                { label: 'Roast', mode: 4, modeTags: [{ value: OvenMode.ModeTag.Roast }] },
+                { label: 'Clean', mode: 5, modeTags: [{ value: OvenMode.ModeTag.Clean }] },
+                { label: 'Convection Bake', mode: 6, modeTags: [{ value: OvenMode.ModeTag.ConvectionBake }] },
+                { label: 'Convection Roast', mode: 7, modeTags: [{ value: OvenMode.ModeTag.ConvectionRoast }] },
+                { label: 'Warming', mode: 8, modeTags: [{ value: OvenMode.ModeTag.Warming }] },
+                { label: 'Proofing', mode: 9, modeTags: [{ value: OvenMode.ModeTag.Proofing }] },
+                { label: 'Steam', mode: 10, modeTags: [{ value: OvenMode.ModeTag.Steam }] },
+            ],
+            currentMode,
+        });
+        return endpoint;
     }
     createDefaultDishwasherModeClusterServer(currentMode) {
         this.behaviors.require(DishwasherModeServer, {
@@ -121,6 +175,73 @@ export class Appliances extends MatterbridgeEndpoint {
         });
         return this;
     }
+    createDefaultLaundryWasherModeClusterServer(currentMode) {
+        this.behaviors.require(LaundryWasherModeServer, {
+            supportedModes: [
+                { label: 'Delicate', mode: 1, modeTags: [{ value: LaundryWasherMode.ModeTag.Delicate }] },
+                { label: 'Normal', mode: 2, modeTags: [{ value: LaundryWasherMode.ModeTag.Normal }] },
+                { label: 'Heavy', mode: 3, modeTags: [{ value: LaundryWasherMode.ModeTag.Heavy }] },
+                { label: 'Whites', mode: 4, modeTags: [{ value: LaundryWasherMode.ModeTag.Whites }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createDefaultMicrowaveOvenModeClusterServer(currentMode, supportedModes) {
+        this.behaviors.require(MicrowaveOvenModeServer, {
+            supportedModes: supportedModes ?? [
+                { label: 'Auto', mode: 1, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Auto }] },
+                { label: 'Quick', mode: 2, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quick }] },
+                { label: 'Quiet', mode: 3, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quiet }] },
+                { label: 'Min', mode: 4, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Min }] },
+                { label: 'Max', mode: 5, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Max }] },
+                { label: 'Normal', mode: 6, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Normal }] },
+                { label: 'Defrost', mode: 7, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Defrost }] },
+            ],
+            currentMode: currentMode ?? 1,
+        });
+        return this;
+    }
+    createDefaultMicrowaveOvenControlClusterServer(selectedWattIndex = 5, supportedWatts = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000], cookTime = 60, maxCookTime = 3600) {
+        this.behaviors.require(MatterbridgeMicrowaveOvenControlServer.with(MicrowaveOvenControl.Feature.PowerInWatts), {
+            supportedWatts,
+            selectedWattIndex,
+            cookTime,
+            maxCookTime,
+        });
+        return this;
+    }
+    createSpinLaundryWasherControlsClusterServer(spinSpeedCurrent, spinSpeeds) {
+        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Spin), {
+            spinSpeeds: spinSpeeds ?? ['400', '800', '1200', '1600'],
+            spinSpeedCurrent,
+        });
+        return this;
+    }
+    createRinseLaundryWasherControlsClusterServer(numberOfRinses, supportedRinses) {
+        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Rinse), {
+            supportedRinses: supportedRinses ?? [
+                LaundryWasherControls.NumberOfRinses.None,
+                LaundryWasherControls.NumberOfRinses.Normal,
+                LaundryWasherControls.NumberOfRinses.Extra,
+                LaundryWasherControls.NumberOfRinses.Max,
+            ],
+            numberOfRinses,
+        });
+        return this;
+    }
+    createDefaultLaundryDryerControlsClusterServer(selectedDrynessLevel, supportedDrynessLevels) {
+        this.behaviors.require(LaundryDryerControlsServer, {
+            supportedDrynessLevels: supportedDrynessLevels ?? [
+                LaundryDryerControls.DrynessLevel.Low,
+                LaundryDryerControls.DrynessLevel.Normal,
+                LaundryDryerControls.DrynessLevel.Extra,
+                LaundryDryerControls.DrynessLevel.Max,
+            ],
+            selectedDrynessLevel,
+        });
+        return this;
+    }
     createDefaultDishwasherAlarmClusterServer() {
         this.behaviors.require(DishwasherAlarmServer, {
             mask: { inflowError: true, drainError: true, doorError: true, tempTooLow: true, tempTooHigh: true, waterLevelError: true },
@@ -129,24 +250,6 @@ export class Appliances extends MatterbridgeEndpoint {
         });
         return this;
     }
-    createDefaultOvenModeClusterServer(currentMode) {
-        this.behaviors.require(OvenModeServer, {
-            supportedModes: [
-                { label: 'Bake', mode: 1, modeTags: [{ value: OvenMode.ModeTag.Bake }] },
-                { label: 'Convection', mode: 2, modeTags: [{ value: OvenMode.ModeTag.Convection }] },
-                { label: 'Grill', mode: 3, modeTags: [{ value: OvenMode.ModeTag.Grill }] },
-                { label: 'Roast', mode: 4, modeTags: [{ value: OvenMode.ModeTag.Roast }] },
-                { label: 'Clean', mode: 5, modeTags: [{ value: OvenMode.ModeTag.Clean }] },
-                { label: 'Convection Bake', mode: 6, modeTags: [{ value: OvenMode.ModeTag.ConvectionBake }] },
-                { label: 'Convection Roast', mode: 7, modeTags: [{ value: OvenMode.ModeTag.ConvectionRoast }] },
-                { label: 'Warming', mode: 8, modeTags: [{ value: OvenMode.ModeTag.Warming }] },
-                { label: 'Proofing', mode: 9, modeTags: [{ value: OvenMode.ModeTag.Proofing }] },
-                { label: 'Steam', mode: 10, modeTags: [{ value: OvenMode.ModeTag.Steam }] },
-            ],
-            currentMode,
-        });
-        return this;
-    }
     createLevelTemperatureControlClusterServer(selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot']) {
         this.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
             selectedTemperatureLevel,
@@ -154,6 +257,13 @@ export class Appliances extends MatterbridgeEndpoint {
         });
         return this;
     }
+    static createLevelTemperatureControlClusterServer(endpoint, selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot']) {
+        endpoint.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
+            selectedTemperatureLevel,
+            supportedTemperatureLevels,
+        });
+        return endpoint;
+    }
     createNumberTemperatureControlClusterServer(temperatureSetpoint, minTemperature, maxTemperature, step = 1) {
         this.behaviors.require(MatterbridgeNumberTemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep), {
             temperatureSetpoint,
@@ -163,17 +273,26 @@ export class Appliances extends MatterbridgeEndpoint {
         });
         return this;
     }
+    static createNumberTemperatureControlClusterServer(endpoint, temperatureSetpoint, minTemperature, maxTemperature, step = 1) {
+        endpoint.behaviors.require(MatterbridgeNumberTemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep), {
+            temperatureSetpoint,
+            minTemperature,
+            maxTemperature,
+            step,
+        });
+        return endpoint;
+    }
 }
 class MatterbridgeOperationalStateServer extends OperationalStateBehavior {
     initialize() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.log.info('MatterbridgeOperationalStateServer initialized: setting operational state to Docked');
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer initialized: setting operational state to Stopped');
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
     }
     pause() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.log.info('MatterbridgeOperationalStateServer: pause called setting operational state to Paused and currentMode to Paused');
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: pause called setting operational state to Paused');
         this.state.operationalState = OperationalState.OperationalStateEnum.Paused;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
         return {
@@ -181,8 +300,8 @@ class MatterbridgeOperationalStateServer extends OperationalStateBehavior {
         };
     }
     stop() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.log.info('MatterbridgeOperationalStateServer: stop called setting operational state to Stopped and currentMode to Idle');
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: stop called setting operational state to Stopped');
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
         return {
@@ -190,8 +309,8 @@ class MatterbridgeOperationalStateServer extends OperationalStateBehavior {
         };
     }
     start() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.log.info('MatterbridgeOperationalStateServer: start called setting operational state to Running and currentMode to Running');
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: start called setting operational state to Running');
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
         return {
@@ -199,8 +318,8 @@ class MatterbridgeOperationalStateServer extends OperationalStateBehavior {
         };
     }
     resume() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        device.log.info('MatterbridgeOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: resume called setting operational state to Running');
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
         return {
@@ -211,14 +330,13 @@ class MatterbridgeOperationalStateServer extends OperationalStateBehavior {
 class MatterbridgeLevelTemperatureControlServer extends TemperatureControlBehavior.with(TemperatureControl.Feature.TemperatureLevel) {
     initialize() {
         if (this.state.supportedTemperatureLevels.length >= 2) {
-            const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-            device.log.info('MatterbridgeLevelTemperatureControlServer initialized: setting selectedTemperatureLevel to 1');
-            this.state.selectedTemperatureLevel = 1;
+            const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+            device.log.info('MatterbridgeLevelTemperatureControlServer initialized');
         }
     }
     setTemperature(request) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        if (request.targetTemperatureLevel && request.targetTemperatureLevel >= 0 && request.targetTemperatureLevel < this.state.supportedTemperatureLevels.length) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (request.targetTemperatureLevel !== undefined && request.targetTemperatureLevel >= 0 && request.targetTemperatureLevel < this.state.supportedTemperatureLevels.length) {
             device.log.info(`MatterbridgeLevelTemperatureControlServer: setTemperature called setting selectedTemperatureLevel to ${request.targetTemperatureLevel}: ${this.state.supportedTemperatureLevels[request.targetTemperatureLevel]}`);
             this.state.selectedTemperatureLevel = request.targetTemperatureLevel;
         }
@@ -229,12 +347,12 @@ class MatterbridgeLevelTemperatureControlServer extends TemperatureControlBehavi
 }
 class MatterbridgeNumberTemperatureControlServer extends TemperatureControlBehavior.with(TemperatureControl.Feature.TemperatureNumber) {
     initialize() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('MatterbridgeNumberTemperatureControlServer initialized');
     }
     setTemperature(request) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        if (request.targetTemperature && request.targetTemperature >= this.state.minTemperature && request.targetTemperature <= this.state.maxTemperature) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (request.targetTemperature !== undefined && request.targetTemperature >= this.state.minTemperature && request.targetTemperature <= this.state.maxTemperature) {
             device.log.info(`MatterbridgeNumberTemperatureControlServer: setTemperature called setting temperatureSetpoint to ${request.targetTemperature}`);
             this.state.temperatureSetpoint = request.targetTemperature;
         }
@@ -243,16 +361,42 @@ class MatterbridgeNumberTemperatureControlServer extends TemperatureControlBehav
         }
     }
 }
+class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControlBehavior.with(MicrowaveOvenControl.Feature.PowerInWatts) {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeMicrowaveOvenControlServer initialized');
+    }
+    setCookingParameters(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (request.wattSettingIndex !== undefined && request.wattSettingIndex >= 0 && request.wattSettingIndex < this.state.supportedWatts.length) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting selectedWattIndex to ${request.wattSettingIndex}`);
+            this.state.selectedWattIndex = request.wattSettingIndex;
+        }
+        else {
+            device.log.error(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with invalid wattSettingIndex ${request.wattSettingIndex}`);
+        }
+    }
+    addMoreTime(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (request.timeToAdd !== undefined && request.timeToAdd >= 0) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: addMoreTime called setting cookTime to ${this.state.cookTime + request.timeToAdd}`);
+            this.state.cookTime += request.timeToAdd;
+        }
+        else {
+            device.log.error(`MatterbridgeMicrowaveOvenControlServer: addMoreTime called with invalid cookTime ${request.timeToAdd}`);
+        }
+    }
+}
 export const OvenCavityOperationalStateBehavior = ClusterBehavior.withInterface().for(OvenCavityOperationalState.Cluster);
 export class OvenCavityOperationalStateServer extends OvenCavityOperationalStateBehavior {
     initialize() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('OvenCavityOperationalStateServer initialized: setting operational state to Stopped and operational error to No error');
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
     }
     stop() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('OvenCavityOperationalStateServer: stop called setting operational state to Stopped and operational error to No error');
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
@@ -261,7 +405,7 @@ export class OvenCavityOperationalStateServer extends OvenCavityOperationalState
         };
     }
     start() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('OvenCavityOperationalStateServer: start called setting operational state to Running and operational error to No error');
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
@@ -273,14 +417,15 @@ export class OvenCavityOperationalStateServer extends OvenCavityOperationalState
 export const RefrigeratorAndTemperatureControlledCabinetModeBehavior = ClusterBehavior.withInterface().for(RefrigeratorAndTemperatureControlledCabinetMode.Cluster);
 class RefrigeratorAndTemperatureControlledCabinetModeServer extends RefrigeratorAndTemperatureControlledCabinetModeBehavior {
     initialize() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer initialized: setting currentMode to 1');
         this.state.currentMode = 1;
     }
     changeToMode(request) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        if (this.state.supportedModes.find((mode) => mode.mode === request.newMode)) {
-            device.log.info(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with mode ${request.newMode} = ${this.state.supportedModes[request.newMode].label}`);
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
+        if (supportedMode) {
+            device.log.info(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
             this.state.currentMode = request.newMode;
             return { status: Status.Success, statusText: 'Success' };
         }
@@ -293,14 +438,15 @@ class RefrigeratorAndTemperatureControlledCabinetModeServer extends Refrigerator
 export const OvenModeBehavior = ClusterBehavior.withInterface().for(OvenMode.Cluster);
 class OvenModeServer extends OvenModeBehavior {
     initialize() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('OvenModeServer initialized: setting currentMode to 3');
         this.state.currentMode = 3;
     }
     changeToMode(request) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        if (this.state.supportedModes.find((mode) => mode.mode === request.newMode)) {
-            device.log.info(`OvenModeServer: changeToMode called with mode ${request.newMode} = ${this.state.supportedModes[request.newMode].label}`);
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
+        if (supportedMode) {
+            device.log.info(`OvenModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
             this.state.currentMode = request.newMode;
             return { status: Status.Success, statusText: 'Success' };
         }
@@ -313,14 +459,23 @@ class OvenModeServer extends OvenModeBehavior {
 export const DishwasherModeBehavior = ClusterBehavior.withInterface().for(DishwasherMode.Cluster);
 class DishwasherModeServer extends DishwasherModeBehavior {
     initialize() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('DishwasherModeServer initialized: setting currentMode to 3');
-        this.state.currentMode = 3;
+        this.state.currentMode = 2;
+        this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
+    }
+    handleOnOffChange(onOff) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (onOff === false) {
+            device.log.info('***OnOffServer changed to OFF: setting Dead Front state to Manufacturer Specific');
+            this.state.currentMode = 2;
+        }
     }
     changeToMode(request) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        if (this.state.supportedModes.find((mode) => mode.mode === request.newMode)) {
-            device.log.info(`DishwasherModeServer: changeToMode called with mode ${request.newMode} = ${this.state.supportedModes[request.newMode].label}`);
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
+        if (supportedMode) {
+            device.log.info(`DishwasherModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
             this.state.currentMode = request.newMode;
             return { status: Status.Success, statusText: 'Success' };
         }
@@ -330,6 +485,35 @@ class DishwasherModeServer extends DishwasherModeBehavior {
         }
     }
 }
+export const LaundryWasherModeBehavior = ClusterBehavior.withInterface().for(LaundryWasherMode.Cluster);
+class LaundryWasherModeServer extends LaundryWasherModeBehavior {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('LaundryWasherModeServer initialized: setting currentMode to 3');
+        this.state.currentMode = 2;
+        this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
+    }
+    handleOnOffChange(onOff) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (onOff === false) {
+            device.log.notice('OnOffServer changed to OFF: setting Dead Front state to Manufacturer Specific');
+            this.state.currentMode = 2;
+        }
+    }
+    changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
+        if (supportedMode) {
+            device.log.info(`LaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
+            this.state.currentMode = request.newMode;
+            return { status: Status.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.error(`LaundryWasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+        }
+    }
+}
 if (process.argv.includes('-testRobot')) {
     const matterbridge = await Matterbridge.loadInstance(false);
     matterbridge.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4, logLevel: "debug" });

package/dist/platform.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { MatterbridgeEndpoint, MatterbridgeDynamicPlatform, airConditioner, airQualitySensor, bridgedNode, colorTemperatureLight, coverDevice, dimmableLight, doorLockDevice, fanDevice, flowSensor, humiditySensor, onOffLight, onOffOutlet, onOffSwitch, powerSource, rainSensor, smokeCoAlarm, temperatureSensor, thermostatDevice, waterFreezeDetector, waterLeakDetector, airPurifier, pumpDevice, waterValve, genericSwitch, } from 'matterbridge';
+import { MatterbridgeEndpoint, MatterbridgeDynamicPlatform, airQualitySensor, bridgedNode, colorTemperatureLight, coverDevice, dimmableLight, doorLockDevice, fanDevice, flowSensor, humiditySensor, onOffLight, onOffOutlet, onOffSwitch, powerSource, rainSensor, smokeCoAlarm, temperatureSensor, thermostatDevice, waterFreezeDetector, waterLeakDetector, airPurifier, pumpDevice, waterValve, genericSwitch, airConditioner, laundryWasher, cooktop, extractorHood, microwaveOven, oven, refrigerator, dishwasher, laundryDryer, onOffMountedSwitch, dimmableMountedSwitch, } from 'matterbridge';
 import { isValidBoolean, isValidNumber } from 'matterbridge/utils';
 import { LocationTag } from 'matterbridge/matter';
 import { PowerSource, BooleanState, OnOff, LevelControl, AirQuality, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FlowMeasurement, ColorControl, DoorLock, FanControl, FormaldehydeConcentrationMeasurement, NitrogenDioxideConcentrationMeasurement, OzoneConcentrationMeasurement, Pm10ConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, RadonConcentrationMeasurement, RelativeHumidityMeasurement, RelativeHumidityMeasurementCluster, SmokeCoAlarm, TemperatureMeasurement, Thermostat, ThermostatCluster, TotalVolatileOrganicCompoundsConcentrationMeasurement, WindowCovering, } from 'matterbridge/matter/clusters';
@@ -50,6 +50,8 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
     airConditionerInterval;
     genericSwitchInterval;
     genericSwitchLastEvent = 'Release';
+    intervalOnOff = false;
+    intervalLevel = 0;
     bridgedDevices = new Map();
     fanModeLookup = ['Off', 'Low', 'Medium', 'High', 'On', 'Auto', 'Smart'];
     constructor(matterbridge, log, config) {
@@ -92,6 +94,65 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.switch.log);
             this.switch?.log.info('Command off called');
         });
+        this.mountedOnOffSwitch = new MatterbridgeEndpoint([onOffMountedSwitch, bridgedNode, powerSource], { uniqueStorageKey: 'OnOffMountedSwitch' }, this.config.debug)
+            .createDefaultIdentifyClusterServer()
+            .createDefaultGroupsClusterServer()
+            .createDefaultBridgedDeviceBasicInformationClusterServer('OnOff Mounted Switch', '0x298242164', 0xfff1, 'Matterbridge', 'Matterbridge OnOff Mounted Switch', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+            .createDefaultOnOffClusterServer()
+            .createDefaultPowerSourceRechargeableBatteryClusterServer(70);
+        this.setSelectDevice(this.mountedOnOffSwitch.serialNumber ?? '', this.mountedOnOffSwitch.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(this.mountedOnOffSwitch.deviceName ?? '')) {
+            await this.registerDevice(this.mountedOnOffSwitch);
+            this.bridgedDevices.set(this.mountedOnOffSwitch.deviceName ?? '', this.mountedOnOffSwitch);
+        }
+        else {
+            this.mountedOnOffSwitch = undefined;
+        }
+        this.mountedOnOffSwitch?.addCommandHandler('identify', async ({ request: { identifyTime } }) => {
+            this.mountedOnOffSwitch?.log.info(`Command identify called identifyTime:${identifyTime}`);
+        });
+        this.mountedOnOffSwitch?.addCommandHandler('on', async () => {
+            await this.mountedOnOffSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.mountedOnOffSwitch.log);
+            this.mountedOnOffSwitch?.log.info('Command on called');
+        });
+        this.mountedOnOffSwitch?.addCommandHandler('off', async () => {
+            await this.mountedOnOffSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.mountedOnOffSwitch.log);
+            this.mountedOnOffSwitch?.log.info('Command off called');
+        });
+        this.mountedDimmerSwitch = new MatterbridgeEndpoint([dimmableMountedSwitch, bridgedNode, powerSource], { uniqueStorageKey: 'DimmerMountedSwitch' }, this.config.debug)
+            .createDefaultIdentifyClusterServer()
+            .createDefaultGroupsClusterServer()
+            .createDefaultBridgedDeviceBasicInformationClusterServer('Dimmer Mounted Switch', '0x22145578864', 0xfff1, 'Matterbridge', 'Matterbridge Dimmer Mounted Switch', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+            .createDefaultOnOffClusterServer()
+            .createDefaultLevelControlClusterServer()
+            .createDefaultPowerSourceRechargeableBatteryClusterServer(70);
+        this.setSelectDevice(this.mountedDimmerSwitch.serialNumber ?? '', this.mountedDimmerSwitch.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(this.mountedDimmerSwitch.deviceName ?? '')) {
+            await this.registerDevice(this.mountedDimmerSwitch);
+            this.bridgedDevices.set(this.mountedDimmerSwitch.deviceName ?? '', this.mountedDimmerSwitch);
+        }
+        else {
+            this.mountedDimmerSwitch = undefined;
+        }
+        this.mountedDimmerSwitch?.addCommandHandler('identify', async ({ request: { identifyTime } }) => {
+            this.mountedDimmerSwitch?.log.info(`Command identify called identifyTime:${identifyTime}`);
+        });
+        this.mountedDimmerSwitch?.addCommandHandler('on', async () => {
+            await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.mountedDimmerSwitch.log);
+            this.mountedDimmerSwitch?.log.info('Command on called');
+        });
+        this.mountedDimmerSwitch?.addCommandHandler('off', async () => {
+            await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.mountedDimmerSwitch.log);
+            this.mountedDimmerSwitch?.log.info('Command off called');
+        });
+        this.mountedDimmerSwitch?.addCommandHandler('moveToLevel', async ({ request: { level } }) => {
+            await this.mountedDimmerSwitch?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.mountedDimmerSwitch.log);
+            this.mountedDimmerSwitch?.log.debug(`Command moveToLevel called request: ${level}`);
+        });
+        this.mountedDimmerSwitch?.addCommandHandler('moveToLevelWithOnOff', async ({ request: { level } }) => {
+            await this.mountedDimmerSwitch?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.mountedDimmerSwitch.log);
+            this.mountedDimmerSwitch?.log.debug(`Command moveToLevelWithOnOff called request: ${level}`);
+        });
         this.lightOnOff = new MatterbridgeEndpoint([onOffLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (on/off)' }, this.config.debug)
             .createDefaultIdentifyClusterServer()
             .createDefaultGroupsClusterServer()
@@ -123,7 +184,7 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             .createDefaultBridgedDeviceBasicInformationClusterServer('Dimmer', '0x234554564', 0xfff1, 'Matterbridge', 'Matterbridge Dimmer', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
             .createDefaultOnOffClusterServer()
             .createDefaultLevelControlClusterServer()
-            .createDefaultPowerSourceReplaceableBatteryClusterServer(70);
+            .createDefaultPowerSourceReplaceableBatteryClusterServer(70, PowerSource.BatChargeLevel.Ok, 2990, '2 x AA', 2);
         this.setSelectDevice(this.dimmer.serialNumber ?? '', this.dimmer.deviceName ?? '', undefined, 'hub');
         if (this.validateDevice(this.dimmer.deviceName ?? '')) {
             await this.registerDevice(this.dimmer);
@@ -556,7 +617,9 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             .createDefaultFanControlClusterServer()
             .createDefaultTemperatureMeasurementClusterServer(20 * 100)
             .createDefaultRelativeHumidityMeasurementClusterServer(50 * 100)
-            .createDefaultPowerSourceWiredClusterServer();
+            .createDefaultPowerSourceWiredClusterServer()
+            .createDefaultActivatedCarbonFilterMonitoringClusterServer()
+            .createDefaultHepaFilterMonitoringClusterServer();
         this.setSelectDevice(this.airPurifier.serialNumber ?? '', this.airPurifier.deviceName ?? '', undefined, 'hub');
         if (this.validateDevice(this.airPurifier.deviceName ?? '')) {
             await this.registerDevice(this.airPurifier);
@@ -617,8 +680,6 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         });
         this.airConditioner?.addCommandHandler('on', async () => {
             this.airConditioner?.log.info('Command on called');
-            await this.airConditioner?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.airConditioner?.log);
-            await this.airConditioner?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(ThermostatCluster.id, 'localTemperature', 20 * 100, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(TemperatureMeasurement.Cluster.id, 'measuredValue', 20 * 100, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(RelativeHumidityMeasurementCluster.id, 'measuredValue', 50 * 100, this.airConditioner?.log);
@@ -627,7 +688,6 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         });
         this.airConditioner?.addCommandHandler('off', async () => {
             this.airConditioner?.log.info('Command off called');
-            await this.airConditioner?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(ThermostatCluster.id, 'localTemperature', null, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(TemperatureMeasurement.Cluster.id, 'measuredValue', null, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(RelativeHumidityMeasurementCluster.id, 'measuredValue', null, this.airConditioner?.log);
@@ -859,49 +919,75 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             await this.registerDevice(robot);
             this.bridgedDevices.set(robot.deviceName ?? '', robot);
         }
-        const laundryWasher = new Appliances(Appliances.laundryWasher, 'Laundry Washer', '1234567890');
-        this.setSelectDevice(laundryWasher.serialNumber ?? '', laundryWasher.deviceName ?? '', undefined, 'hub');
-        if (this.validateDevice(laundryWasher.deviceName ?? '')) {
-            await this.registerDevice(laundryWasher);
-            this.bridgedDevices.set(laundryWasher.deviceName ?? '', laundryWasher);
-        }
-        const dishwasher = new Appliances(Appliances.dishwasher, 'Dishwasher', '0987654321');
-        this.setSelectDevice(dishwasher.serialNumber ?? '', dishwasher.deviceName ?? '', undefined, 'hub');
-        if (this.validateDevice(dishwasher.deviceName ?? '')) {
-            await this.registerDevice(dishwasher);
-            this.bridgedDevices.set(dishwasher.deviceName ?? '', dishwasher);
-        }
-        const temperatureControlledCabinetCooler = new Appliances(Appliances.temperatureControlledCabinetCooler, 'Temperature Controlled Cabinet Cooler', '0986594321');
-        this.setSelectDevice(temperatureControlledCabinetCooler.serialNumber ?? '', temperatureControlledCabinetCooler.deviceName ?? '', undefined, 'hub');
-        if (this.validateDevice(temperatureControlledCabinetCooler.deviceName ?? '')) {
-            await this.registerDevice(temperatureControlledCabinetCooler);
-            this.bridgedDevices.set(temperatureControlledCabinetCooler.deviceName ?? '', temperatureControlledCabinetCooler);
-        }
-        const temperatureControlledCabinetHeater = new Appliances(Appliances.temperatureControlledCabinetHeater, 'Temperature Controlled Cabinet Heater', '0986554421');
-        this.setSelectDevice(temperatureControlledCabinetHeater.serialNumber ?? '', temperatureControlledCabinetHeater.deviceName ?? '', undefined, 'hub');
-        if (this.validateDevice(temperatureControlledCabinetHeater.deviceName ?? '')) {
-            await this.registerDevice(temperatureControlledCabinetHeater);
-            this.bridgedDevices.set(temperatureControlledCabinetHeater.deviceName ?? '', temperatureControlledCabinetHeater);
+        const laundryWasherDevice = new Appliances(laundryWasher, 'Laundry Washer', '1234567890');
+        this.setSelectDevice(laundryWasherDevice.serialNumber ?? '', laundryWasherDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(laundryWasherDevice.deviceName ?? '')) {
+            await this.registerDevice(laundryWasherDevice);
+            this.bridgedDevices.set(laundryWasherDevice.deviceName ?? '', laundryWasherDevice);
+        }
+        const laundryDryerDevice = new Appliances(laundryDryer, 'Laundry Dryer', '1235227890');
+        this.setSelectDevice(laundryDryerDevice.serialNumber ?? '', laundryDryerDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(laundryDryerDevice.deviceName ?? '')) {
+            await this.registerDevice(laundryDryerDevice);
+            this.bridgedDevices.set(laundryDryerDevice.deviceName ?? '', laundryDryerDevice);
+        }
+        const dishwasherDevice = new Appliances(dishwasher, 'Dishwasher', '0987654321');
+        this.setSelectDevice(dishwasherDevice.serialNumber ?? '', dishwasherDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(dishwasherDevice.deviceName ?? '')) {
+            await this.registerDevice(dishwasherDevice);
+            this.bridgedDevices.set(dishwasherDevice.deviceName ?? '', dishwasherDevice);
+        }
+        const refrigeratorDevice = new Appliances(refrigerator, 'Refrigerator', '9987654322');
+        this.setSelectDevice(refrigeratorDevice.serialNumber ?? '', refrigeratorDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(refrigeratorDevice.deviceName ?? '')) {
+            await this.registerDevice(refrigeratorDevice);
+            this.bridgedDevices.set(refrigeratorDevice.deviceName ?? '', refrigeratorDevice);
+        }
+        const ovenDevice = new Appliances(oven, 'Oven', '1298867891');
+        this.setSelectDevice(ovenDevice.serialNumber ?? '', ovenDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(ovenDevice.deviceName ?? '')) {
+            await this.registerDevice(ovenDevice);
+            this.bridgedDevices.set(ovenDevice.deviceName ?? '', ovenDevice);
+        }
+        const microwaveOvenDevice = new Appliances(microwaveOven, 'Microwave Oven', '1234567892');
+        this.setSelectDevice(microwaveOvenDevice.serialNumber ?? '', microwaveOvenDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(microwaveOvenDevice.deviceName ?? '')) {
+            await this.registerDevice(microwaveOvenDevice);
+            this.bridgedDevices.set(microwaveOvenDevice.deviceName ?? '', microwaveOvenDevice);
+        }
+        const extractorHoodDevice = new Appliances(extractorHood, 'Extractor Hood', '1234567893');
+        this.setSelectDevice(extractorHoodDevice.serialNumber ?? '', extractorHoodDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(extractorHoodDevice.deviceName ?? '')) {
+            await this.registerDevice(extractorHoodDevice);
+            this.bridgedDevices.set(extractorHoodDevice.deviceName ?? '', extractorHoodDevice);
+        }
+        const cooktopDevice = new Appliances(cooktop, 'Cooktop', '1255887894');
+        this.setSelectDevice(cooktopDevice.serialNumber ?? '', cooktopDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(cooktopDevice.deviceName ?? '')) {
+            await this.registerDevice(cooktopDevice);
+            this.bridgedDevices.set(cooktopDevice.deviceName ?? '', cooktopDevice);
         }
     }
     async onConfigure() {
         await super.onConfigure();
         this.log.info('onConfigure called');
-        await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.switch.log);
-        this.switch?.log.info('Set switch initial onOff to false');
+        await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', this.intervalOnOff, this.switch.log);
+        await this.mountedOnOffSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', this.intervalOnOff, this.mountedOnOffSwitch.log);
+        this.switch?.log.info(`Set switch initial onOff to ${this.intervalOnOff}`);
         if (this.config.useInterval) {
             this.switchInterval = setInterval(async () => {
-                const status = this.switch?.getAttribute(OnOff.Cluster.id, 'onOff', this.switch.log);
-                if (isValidBoolean(status)) {
-                    await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', !status, this.switch.log);
-                    this.switch?.log.info(`Set switch onOff to ${!status}`);
-                }
+                await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', this.intervalOnOff, this.switch.log);
+                await this.mountedOnOffSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', this.intervalOnOff, this.mountedOnOffSwitch.log);
+                this.log.info(`Set switches onOff to ${this.intervalOnOff}`);
+                this.intervalOnOff = !this.intervalOnOff;
             }, 60 * 1000 + 100);
         }
         await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightOnOff.log);
         this.lightOnOff?.log.info('Set light initial onOff to false.');
         await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.dimmer.log);
         await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', 1, this.dimmer.log);
+        await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.mountedDimmerSwitch.log);
+        await this.mountedDimmerSwitch?.setAttribute(LevelControl.Cluster.id, 'currentLevel', 1, this.mountedDimmerSwitch.log);
         this.dimmer?.log.info(`Set dimmer initial onOff to false, currentLevel to 1.`);
         await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.light.log);
         await this.light?.setAttribute(LevelControl.Cluster.id, 'currentLevel', 200, this.light.log);
@@ -928,41 +1014,34 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         this.lightCT?.log.info('Set light CT initial onOff to true, currentLevel to 128, colorTemperatureMireds to 250.');
         if (this.config.useInterval) {
             this.lightInterval = setInterval(async () => {
-                const state = this.light?.getAttribute(OnOff.Cluster.id, 'onOff', this.light.log);
-                let level = this.light?.getAttribute(LevelControl.Cluster.id, 'currentLevel', this.light.log);
-                if (isValidBoolean(state) && isValidNumber(level, 0, 254)) {
-                    level += 10;
-                    if (level >= 250) {
-                        level = 1;
-                        await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightOnOff.log);
-                        await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.dimmer.log);
-                        await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.light.log);
-                        await this.lightXY?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightXY.log);
-                        await this.lightHS?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightHS.log);
-                        await this.lightCT?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightCT.log);
-                        this.log.info('Set lights onOff to false');
-                        await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.dimmer.log);
-                        await this.light?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.light.log);
-                        await this.lightXY?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightXY.log);
-                        await this.lightHS?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightHS.log);
-                        await this.lightCT?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightCT.log);
-                        this.log.info(`Set lights currentLevel to ${level}`);
-                    }
-                    else {
-                        await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightOnOff?.log);
-                        await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.dimmer.log);
-                        await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.light.log);
-                        await this.lightXY?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightXY.log);
-                        await this.lightHS?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightHS.log);
-                        await this.lightCT?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightCT.log);
-                        this.log.info('Set lights onOff to true');
-                        await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.dimmer.log);
-                        await this.light?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.light.log);
-                        await this.lightXY?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightXY.log);
-                        await this.lightHS?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightHS.log);
-                        await this.lightCT?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightCT.log);
-                        this.log.info(`Set lights currentLevel to ${level}`);
-                    }
+                this.intervalLevel += 10;
+                if (this.intervalLevel >= 250) {
+                    this.intervalLevel = 0;
+                    await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightOnOff.log);
+                    await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.dimmer.log);
+                    await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.mountedDimmerSwitch.log);
+                    await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.light.log);
+                    await this.lightXY?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightXY.log);
+                    await this.lightHS?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightHS.log);
+                    await this.lightCT?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightCT.log);
+                    this.log.info('Set lights onOff to false');
+                }
+                else {
+                    await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightOnOff?.log);
+                    await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.dimmer.log);
+                    await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.mountedDimmerSwitch.log);
+                    await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.light.log);
+                    await this.lightXY?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightXY.log);
+                    await this.lightHS?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightHS.log);
+                    await this.lightCT?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightCT.log);
+                    this.log.info('Set lights onOff to true');
+                    await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.dimmer.log);
+                    await this.mountedDimmerSwitch?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.mountedDimmerSwitch.log);
+                    await this.light?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.light.log);
+                    await this.lightXY?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.lightXY.log);
+                    await this.lightHS?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.lightHS.log);
+                    await this.lightCT?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.lightCT.log);
+                    this.log.info(`Set lights currentLevel to ${this.intervalLevel}`);
                 }
             }, 60 * 1000 + 200);
         }
@@ -1186,6 +1265,6 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         await super.onShutdown(reason);
         this.log.info('onShutdown called with reason:', reason ?? 'none');
         if (this.config.unregisterOnShutdown === true)
-            await this.unregisterAllDevices(250);
+            await this.unregisterAllDevices(500);
     }
 }

package/npm-shrinkwrap.json CHANGED Viewed

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge-example-dynamic-platform",
-  "version": "1.2.0-edge.3",
+  "version": "1.2.0-edge.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge-example-dynamic-platform",
-      "version": "1.2.0-edge.3",
+      "version": "1.2.0-edge.7",
       "license": "MIT",
       "dependencies": {
         "node-ansi-logger": "3.0.1",

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-example-dynamic-platform",
-  "version": "1.2.0-edge.3",
+  "version": "1.2.0-edge.7",
   "description": "Matterbridge dynamic plugin",
   "author": "https://github.com/Luligu",
   "license": "MIT",