matterbridge-roborock-vacuum-plugin 1.0.8-rc01 → 1.0.8-rc02

package/.github/workflows/publish.yml

@@ -28,7 +28,10 @@ jobs:
       - name: Build (optional)
         run: npm run build
 
+      - name: Run tests
+        run: npm run test
+
       - name: Publish to npm
         run: npm publish
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -68,6 +68,8 @@ To get the **DUID** for your devices, you have two options:
 
 ---
 
+**➡️ [See Supported & Tested Roborock Devices](./README_SUPPORTED.md)**
+
 ### 📦 Prerequisites
 
 - A working installation of [Matterbridge](https://github.com/Luligu/matterbridge)

package/README_SUPPORTED.md

@@ -0,0 +1,54 @@
+# Supported & Tested Roborock Device Models
+
+## ✅ Tested Devices
+
+| Device Name                | Model Enum Key         | Model String                  |    Thank         |
+|----------------------------|------------------------|-------------------------------|------------------|
+| Roborock Qrevo Edge 5V1    | `QREVO_EDGE_5V1`       | `roborock.vacuum.a187`        |                  |
+| Roborock S8 Pro Ultra      | `S8_PRO_ULTRA`         | `roborock.vacuum.a70`         |                  |
+| Roborock S7 MaxV           | `S7_MAXV`              | `roborock.vacuum.a27`         |                  |
+
+These devices have been fully tested and are confirmed to work as expected.
+
+---
+
+## ⚠️ Other Supported Devices
+
+All other models listed in the code are supported, but **may have some limitations**.
+
+**Reason:**  
+I do not own these devices for direct testing.
+
+If you have one of these models, please try it out and let me know your results!
+
+---
+
+### List of Other Models that I know the mode string
+
+- Q5 (`roborock.vacuum.a34`)
+- Q5_PRO (`roborock.vacuum.a72`)
+- S5 (`roborock.vacuum.s5`)
+- S5_MAX (`roborock.vacuum.s5e`)
+- S6 (`roborock.vacuum.s6`)
+- S6_MAXV (`roborock.vacuum.a10`)
+- S6_PURE (`roborock.vacuum.a08`)
+- Q7 (`roborock.vacuum.a40`)
+- Q7_MAX (`roborock.vacuum.a38`)
+- Q7_PLUS (`roborock.vacuum.a40`)
+- S7 (`roborock.vacuum.a15`)
+- S7_MAXV_ULTRA (`roborock.vacuum.a65`)
+- S7_PRO_ULTRA (`roborock.vacuum.a62`)
+- Q8_MAX (`roborock.vacuum.a73`)
+- S8 (`roborock.vacuum.a51`)
+- S8_MAXV_ULTRA (`roborock.vacuum.a97`)
+- QREVO_MASTER (`roborock.vacuum.a117`)
+- QREVO_CURV (`roborock.vacuum.a135`)
+- QREVO_S (`roborock.vacuum.a104`)
+- QREVO_PRO (`roborock.vacuum.a101`)
+- QREVO_MAXV (`roborock.vacuum.a87`)
+- QREVO_EDGE_5AE (`roborock.vacuum.xxxx`)
+
+---
+
+> **Note:**  
+> If you have a device not listed above, feel free to try it and report your experience!

package/dist/behaviorFactory.js

@@ -3,6 +3,7 @@ import { setCommandHandlerA187 } from './behaviors/roborock.vacuum/QREVO_EDGE_5V
 import { setDefaultCommandHandler } from './behaviors/roborock.vacuum/default/default.js';
 import { DeviceModel } from './roborockCommunication/Zmodel/deviceModel.js';
 import { setCommandHandlerA27 } from './behaviors/roborock.vacuum/S7_MAXV/a27.js';
+import { setCommandHandlerA51 } from './behaviors/roborock.vacuum/S8_PRO_ULTRA/a51.js';
 export function configurateBehavior(model, duid, roborockService, cleanModeSettings, logger) {
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1: {
@@ -15,9 +16,14 @@ export function configurateBehavior(model, duid, roborockService, cleanModeSetti
             setCommandHandlerA27(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
+        case DeviceModel.S8_PRO_ULTRA: {
+            const deviceHandler = new BehaviorDeviceGeneric(logger);
+            setCommandHandlerA51(duid, deviceHandler, logger, roborockService, cleanModeSettings);
+            return deviceHandler;
+        }
         default: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setDefaultCommandHandler(duid, deviceHandler, logger, roborockService);
+            setDefaultCommandHandler(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
     }

package/dist/behaviors/roborock.vacuum/S8_PRO_ULTRA/a51.js

@@ -0,0 +1,139 @@
+import { debugStringify } from 'matterbridge/logger';
+import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
+export class BehaviorA51 extends BehaviorRoborock {
+}
+export var BehaviorRoborockA51;
+(function (BehaviorRoborockA51) {
+    class State {
+        device;
+    }
+    BehaviorRoborockA51.State = State;
+})(BehaviorRoborockA51 || (BehaviorRoborockA51 = {}));
+export var VacuumSuctionPowerA51;
+(function (VacuumSuctionPowerA51) {
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Quiet"] = 101] = "Quiet";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Balanced"] = 102] = "Balanced";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Turbo"] = 103] = "Turbo";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Max"] = 104] = "Max";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Off"] = 105] = "Off";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Custom"] = 106] = "Custom";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["MaxPlus"] = 108] = "MaxPlus";
+})(VacuumSuctionPowerA51 || (VacuumSuctionPowerA51 = {}));
+export var MopWaterFlowA51;
+(function (MopWaterFlowA51) {
+    MopWaterFlowA51[MopWaterFlowA51["Off"] = 200] = "Off";
+    MopWaterFlowA51[MopWaterFlowA51["Low"] = 201] = "Low";
+    MopWaterFlowA51[MopWaterFlowA51["Medium"] = 202] = "Medium";
+    MopWaterFlowA51[MopWaterFlowA51["High"] = 203] = "High";
+    MopWaterFlowA51[MopWaterFlowA51["Custom"] = 204] = "Custom";
+})(MopWaterFlowA51 || (MopWaterFlowA51 = {}));
+export var MopRouteA51;
+(function (MopRouteA51) {
+    MopRouteA51[MopRouteA51["Standard"] = 300] = "Standard";
+    MopRouteA51[MopRouteA51["Deep"] = 301] = "Deep";
+    MopRouteA51[MopRouteA51["Custom"] = 302] = "Custom";
+    MopRouteA51[MopRouteA51["DeepPlus"] = 303] = "DeepPlus";
+    MopRouteA51[MopRouteA51["Fast"] = 304] = "Fast";
+})(MopRouteA51 || (MopRouteA51 = {}));
+const RvcRunMode = {
+    [1]: 'Idle',
+    [2]: 'Cleaning',
+    [3]: 'Mapping',
+};
+const RvcCleanMode = {
+    [5]: 'Mop',
+    [6]: 'Vacuum',
+    [7]: 'Vac & Mop',
+    [8]: 'Custom',
+};
+const CleanSetting = {
+    [5]: { suctionPower: VacuumSuctionPowerA51.Off, waterFlow: MopWaterFlowA51.Medium, distance_off: 0, mopRoute: MopRouteA51.Standard },
+    [6]: { suctionPower: VacuumSuctionPowerA51.Balanced, waterFlow: MopWaterFlowA51.Off, distance_off: 0, mopRoute: MopRouteA51.Standard },
+    [7]: { suctionPower: VacuumSuctionPowerA51.Balanced, waterFlow: MopWaterFlowA51.Medium, distance_off: 0, mopRoute: MopRouteA51.Standard },
+    [8]: { suctionPower: VacuumSuctionPowerA51.Custom, waterFlow: MopWaterFlowA51.Custom, distance_off: 0, mopRoute: MopRouteA51.Custom },
+};
+export function setCommandHandlerA51(duid, handler, logger, roborockService, cleanModeSettings) {
+    handler.setCommandHandler('changeToMode', async (newMode) => {
+        const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+        switch (activity) {
+            case 'Cleaning': {
+                await roborockService.startClean(duid);
+                return;
+            }
+            case 'Mop':
+            case 'Vacuum':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`BehaviorA51-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
+            case 'Custom': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`BehaviorA51-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
+                return;
+            }
+            default:
+                logger.notice('BehaviorA51-changeToMode-Unknown: ', newMode);
+                return;
+        }
+    });
+    handler.setCommandHandler('selectAreas', async (newAreas) => {
+        logger.notice(`BehaviorA51-selectAreas: ${newAreas}`);
+        roborockService.setSelectedAreas(duid, newAreas ?? []);
+    });
+    handler.setCommandHandler('pause', async () => {
+        logger.notice('BehaviorA51-Pause');
+        await roborockService.pauseClean(duid);
+    });
+    handler.setCommandHandler('resume', async () => {
+        logger.notice('BehaviorA51-Resume');
+        await roborockService.resumeClean(duid);
+    });
+    handler.setCommandHandler('goHome', async () => {
+        logger.notice('BehaviorA51-GoHome');
+        await roborockService.stopAndGoHome(duid);
+    });
+    handler.setCommandHandler('PlaySoundToLocate', async (identifyTime) => {
+        logger.notice('BehaviorA51-PlaySoundToLocate');
+        await roborockService.playSoundToLocate(duid);
+    });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlowA51[mopSetting?.waterFlowMode] ?? MopWaterFlowA51.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA51.Off,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA51[mopSetting?.mopRouteMode] ?? MopRouteA51.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPowerA51[vacuumSetting?.fanMode] ?? VacuumSuctionPowerA51.Balanced,
+                    waterFlow: MopWaterFlowA51.Off,
+                    distance_off: 0,
+                    mopRoute: MopRouteA51[vacuumSetting?.mopRouteMode] ?? MopRouteA51.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlowA51[vacmopSetting?.waterFlowMode] ?? MopWaterFlowA51.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA51[vacmopSetting?.fanMode] ?? VacuumSuctionPowerA51.Balanced,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA51[vacmopSetting?.mopRouteMode] ?? MopRouteA51.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
+}

package/dist/behaviors/roborock.vacuum/S8_PRO_ULTRA/initalData.js

@@ -0,0 +1,76 @@
+import { RvcCleanMode, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+export function getDefaultSupportedRunModes() {
+    return [
+        {
+            label: 'Idle',
+            mode: 1,
+            modeTags: [{ value: RvcRunMode.ModeTag.Idle }],
+        },
+        {
+            label: 'Cleaning',
+            mode: 2,
+            modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }],
+        },
+        {
+            label: 'Mapping',
+            mode: 3,
+            modeTags: [{ value: RvcRunMode.ModeTag.Mapping }],
+        },
+    ];
+}
+export function getDefaultSupportedCleanModes() {
+    return [
+        {
+            label: 'Mop',
+            mode: 5,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: 'Vacuum',
+            mode: 6,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: 'Mop & Vacuum',
+            mode: 7,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.DeepClean }],
+        },
+        {
+            label: 'Custom',
+            mode: 8,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
+        },
+    ];
+}
+export function getDefaultOperationalStates() {
+    return [
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Stopped,
+            operationalStateLabel: 'Stopped',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Running,
+            operationalStateLabel: 'Running',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Paused,
+            operationalStateLabel: 'Paused',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Error,
+            operationalStateLabel: 'Error',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.SeekingCharger,
+            operationalStateLabel: 'SeekingCharger',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Charging,
+            operationalStateLabel: 'Charging',
+        },
+        {
+            operationalStateId: RvcOperationalState.OperationalState.Docked,
+            operationalStateLabel: 'Docked',
+        },
+    ];
+}

package/dist/behaviors/roborock.vacuum/S8_PRO_ULTRA/runtimes.js

@@ -0,0 +1,33 @@
+import { MopWaterFlowA51, VacuumSuctionPowerA51 } from './a51.js';
+export function getCurrentCleanModeA51(fan_power, water_box_mode) {
+    if (!fan_power || !water_box_mode)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA51.Custom || water_box_mode == MopWaterFlowA51.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA51.Off)
+        return 5;
+    if (water_box_mode == MopWaterFlowA51.Off)
+        return 6;
+    else
+        return 7;
+}
+export function getCurrentCleanModeFromFanPowerA51(fan_power) {
+    if (!fan_power)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA51.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA51.Off)
+        return 5;
+    else
+        return undefined;
+}
+export function getCurrentCleanModeFromWaterBoxModeA51(water_box_mode) {
+    if (!water_box_mode)
+        return undefined;
+    if (water_box_mode == MopWaterFlowA51.Custom)
+        return 8;
+    if (water_box_mode == MopWaterFlowA51.Off)
+        return 6;
+    else
+        return undefined;
+}

package/dist/behaviors/roborock.vacuum/default/default.js

@@ -1,3 +1,4 @@
+import { debugStringify } from 'matterbridge/logger';
 import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
 export class DefaultBehavior extends BehaviorRoborock {
 }
@@ -8,16 +9,50 @@ export var DefaultBehaviorRoborock;
     }
     DefaultBehaviorRoborock.State = State;
 })(DefaultBehaviorRoborock || (DefaultBehaviorRoborock = {}));
+export var VacuumSuctionPower;
+(function (VacuumSuctionPower) {
+    VacuumSuctionPower[VacuumSuctionPower["Quiet"] = 101] = "Quiet";
+    VacuumSuctionPower[VacuumSuctionPower["Balanced"] = 102] = "Balanced";
+    VacuumSuctionPower[VacuumSuctionPower["Turbo"] = 103] = "Turbo";
+    VacuumSuctionPower[VacuumSuctionPower["Max"] = 104] = "Max";
+    VacuumSuctionPower[VacuumSuctionPower["Off"] = 105] = "Off";
+    VacuumSuctionPower[VacuumSuctionPower["Custom"] = 106] = "Custom";
+    VacuumSuctionPower[VacuumSuctionPower["MaxPlus"] = 108] = "MaxPlus";
+})(VacuumSuctionPower || (VacuumSuctionPower = {}));
+export var MopWaterFlow;
+(function (MopWaterFlow) {
+    MopWaterFlow[MopWaterFlow["Off"] = 200] = "Off";
+    MopWaterFlow[MopWaterFlow["Low"] = 201] = "Low";
+    MopWaterFlow[MopWaterFlow["Medium"] = 202] = "Medium";
+    MopWaterFlow[MopWaterFlow["High"] = 203] = "High";
+    MopWaterFlow[MopWaterFlow["Custom"] = 204] = "Custom";
+})(MopWaterFlow || (MopWaterFlow = {}));
+export var MopRoute;
+(function (MopRoute) {
+    MopRoute[MopRoute["Standard"] = 300] = "Standard";
+    MopRoute[MopRoute["Deep"] = 301] = "Deep";
+    MopRoute[MopRoute["Custom"] = 302] = "Custom";
+    MopRoute[MopRoute["DeepPlus"] = 303] = "DeepPlus";
+    MopRoute[MopRoute["Fast"] = 304] = "Fast";
+})(MopRoute || (MopRoute = {}));
 const RvcRunMode = {
     [1]: 'Idle',
     [2]: 'Cleaning',
     [3]: 'Mapping',
 };
 const RvcCleanMode = {
-    [4]: 'Mop',
-    [5]: 'Vacuum',
+    [5]: 'Mop',
+    [6]: 'Vacuum',
+    [7]: 'Vac & Mop',
+    [8]: 'Custom',
 };
-export function setDefaultCommandHandler(duid, handler, logger, roborockService) {
+const CleanSetting = {
+    [5]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [6]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard },
+    [7]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [8]: { suctionPower: VacuumSuctionPower.Custom, waterFlow: MopWaterFlow.Custom, distance_off: 0, mopRoute: MopRoute.Custom },
+};
+export function setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings) {
     handler.setCommandHandler('changeToMode', async (newMode) => {
         const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
         switch (activity) {
@@ -26,8 +61,19 @@ export function setDefaultCommandHandler(duid, handler, logger, roborockService)
                 return;
             }
             case 'Mop':
-            case 'Vacuum': {
-                logger.notice('DefaultBehavior-ChangeCleanMode to: ', activity);
+            case 'Vacuum':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
+            case 'Custom': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
                 return;
             }
             default:
@@ -55,4 +101,39 @@ export function setDefaultCommandHandler(duid, handler, logger, roborockService)
         logger.notice('DefaultBehavior-PlaySoundToLocate');
         await roborockService.playSoundToLocate(duid);
     });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlow[mopSetting?.waterFlowMode] ?? MopWaterFlow.Medium;
+                return {
+                    suctionPower: VacuumSuctionPower.Off,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRoute[mopSetting?.mopRouteMode] ?? MopRoute.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPower[vacuumSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
+                    waterFlow: MopWaterFlow.Off,
+                    distance_off: 0,
+                    mopRoute: MopRoute[vacuumSetting?.mopRouteMode] ?? MopRoute.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlow[vacmopSetting?.waterFlowMode] ?? MopWaterFlow.Medium;
+                return {
+                    suctionPower: VacuumSuctionPower[vacmopSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRoute[vacmopSetting?.mopRouteMode] ?? MopRoute.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
 }

package/dist/behaviors/roborock.vacuum/default/initalData.js

@@ -20,15 +20,25 @@ export function getDefaultSupportedRunModes() {
 }
 export function getDefaultSupportedCleanModes() {
     return [
+        {
+            label: 'Mop',
+            mode: 5,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
         {
             label: 'Vacuum',
-            mode: 4,
-            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }],
+            mode: 6,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
         },
         {
-            label: 'Mop',
-            mode: 5,
-            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }],
+            label: 'Mop & Vacuum',
+            mode: 7,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.DeepClean }],
+        },
+        {
+            label: 'Custom',
+            mode: 8,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
         },
     ];
 }

package/dist/behaviors/roborock.vacuum/default/runtimes.js

@@ -0,0 +1,33 @@
+import { MopWaterFlow, VacuumSuctionPower } from './default.js';
+export function getCurrentCleanModeDefault(fan_power, water_box_mode) {
+    if (!fan_power || !water_box_mode)
+        return undefined;
+    if (fan_power == VacuumSuctionPower.Custom || water_box_mode == MopWaterFlow.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPower.Off)
+        return 5;
+    if (water_box_mode == MopWaterFlow.Off)
+        return 6;
+    else
+        return 7;
+}
+export function getCurrentCleanModeFromFanPowerDefault(fan_power) {
+    if (!fan_power)
+        return undefined;
+    if (fan_power == VacuumSuctionPower.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPower.Off)
+        return 5;
+    else
+        return undefined;
+}
+export function getCurrentCleanModeFromWaterBoxModeDefault(water_box_mode) {
+    if (!water_box_mode)
+        return undefined;
+    if (water_box_mode == MopWaterFlow.Custom)
+        return 8;
+    if (water_box_mode == MopWaterFlow.Off)
+        return 6;
+    else
+        return undefined;
+}

package/dist/initialData/getSupportedScenes.js

@@ -0,0 +1,26 @@
+import { debugStringify } from 'matterbridge/logger';
+import { randomInt } from 'crypto';
+export function getSupportedScenes(scenes, log) {
+    log?.debug('getSupportedScenes', debugStringify(scenes));
+    if (!scenes || scenes.length === 0) {
+        log?.error('No scenes found');
+        return [];
+    }
+    const supportedAreas = scenes
+        .filter((s) => s.enabled && s.id)
+        .map((scene) => {
+        return {
+            areaId: scene.id + randomInt(5000, 9000),
+            mapId: null,
+            areaInfo: {
+                locationInfo: {
+                    locationName: `Scene: ${scene.name}`,
+                    floorNumber: null,
+                    areaType: null,
+                },
+                landmarkInfo: null,
+            },
+        };
+    });
+    return supportedAreas;
+}

package/dist/initialData/index.js

@@ -3,3 +3,4 @@ export { getOperationalStates, getOperationalErrorState } from './getOperational
 export { getSupportedCleanModes } from './getSupportedCleanModes.js';
 export { getSupportedAreas } from './getSupportedAreas.js';
 export { getBatteryStatus, getBatteryState } from './getBatteryStatus.js';
+export { getSupportedScenes } from './getSupportedScenes.js';

package/dist/model/ExperimentalFeatureSetting.js

@@ -0,0 +1 @@
+export {};

package/dist/platform.js

@@ -10,7 +10,7 @@ import { PlatformRunner } from './platformRunner.js';
 import { RoborockVacuumCleaner } from './rvc.js';
 import { configurateBehavior } from './behaviorFactory.js';
 import { RoborockAuthenticateApi, RoborockIoTApi } from './roborockCommunication/index.js';
-import { getSupportedAreas } from './initialData/index.js';
+import { getSupportedAreas, getSupportedScenes } from './initialData/index.js';
 export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     robot;
     rvcInterval;
@@ -19,6 +19,8 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     platformRunner;
     devices;
     serialNumber;
+    cleanModeSettings;
+    enableExperimentalFeature;
     constructor(matterbridge, log, config) {
         super(matterbridge, log, config);
         if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.0.4')) {
@@ -62,6 +64,12 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             });
             return response;
         });
+        this.enableExperimentalFeature = this.config.enableExperimental;
+        if (this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature?.cleanModeSettings?.enableCleanModeMapping) {
+            this.cleanModeSettings = this.enableExperimentalFeature.cleanModeSettings;
+            this.log.notice(`Experimental Feature has been enable`);
+            this.log.notice(`cleanModeSettings ${debugStringify(this.cleanModeSettings)}`);
+        }
         this.platformRunner = new PlatformRunner(this);
         this.roborockService = new RoborockService(() => new RoborockAuthenticateApi(this.log, axiosInstance), (logger, ud) => new RoborockIoTApi(ud, logger), this.config.refreshInterval ?? 60, this.clientManager, this.log);
         const username = this.config.username;
@@ -91,11 +99,6 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     }
     async onConfigure() {
         await super.onConfigure();
-        if (this.config.enableExperimentalFeature) {
-            const cleanModeSettings = this.config.cleanModeSettings;
-            this.log.notice(`Experimental Feature has been enable`);
-            this.log.notice(`cleanModeSettings ${debugStringify(cleanModeSettings)}`);
-        }
         const self = this;
         this.rvcInterval = setInterval(async () => {
             self.platformRunner?.requestHomeData();
@@ -113,17 +116,18 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             this.log.error('Initializing: No supported devices found');
             return;
         }
-        let cleanModeSettings = undefined;
-        if (this.config.enableExperimentalFeature) {
-            cleanModeSettings = this.config.cleanModeSettings;
-        }
         const self = this;
         await this.roborockService.initializeMessageClientForLocal(vacuum);
         const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
         this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));
-        const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, cleanModeSettings, this.log);
+        const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, this.cleanModeSettings, this.log);
         this.roborockService.setSupportedAreas(vacuum.duid, getSupportedAreas(vacuum.rooms, roomMap, this.log));
-        this.robot = new RoborockVacuumCleaner(username, vacuum, roomMap, this.log);
+        let routineAsRoom = [];
+        if (this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature.advancedFeature?.showRoutinesAsRoom) {
+            routineAsRoom = getSupportedScenes(vacuum.scenes, this.log);
+            this.roborockService.setSupportedScenes(vacuum.duid, routineAsRoom);
+        }
+        this.robot = new RoborockVacuumCleaner(username, vacuum, roomMap, routineAsRoom, this.log);
         this.robot.configurateHandler(behaviorHandler);
         this.log.info('vacuum:', debugStringify(vacuum));
         this.setSelectDevice(this.robot.serialNumber ?? '', this.robot.deviceName ?? '', undefined, 'hub');

package/dist/platformRunner.js

@@ -157,7 +157,7 @@ export class PlatformRunner {
                 case Protocol.rpc_response: {
                     const response = data.dps[messageType];
                     if (!self.isStatusUpdate(response.result)) {
-                        platform.log.notice('Ignore message:', debugStringify(data));
+                        platform.log.debug('Ignore message:', debugStringify(data));
                         return;
                     }
                     const roboStatus = response.result[0];
@@ -200,8 +200,9 @@ export class PlatformRunner {
         if (platform.config.enableExperimentalFeature && message.dss !== undefined) {
             const dss = parseDockingStationStatus(message.dss);
             this.platform.log.debug('DockingStationStatus:', debugStringify(dss));
-            if (dss && hasDockingStationError(dss)) {
-                platform.robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', RvcOperationalState.OperationalState.Error, platform.log);
+            const currentOperationState = robot.getAttribute(RvcOperationalState.Cluster.id, 'operationalState');
+            if (dss && hasDockingStationError(dss) && currentOperationState !== RvcOperationalState.OperationalState.Running) {
+                robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', RvcOperationalState.OperationalState.Error, platform.log);
             }
         }
         if (message.fan_power !== undefined) {