matterbridge-roborock-vacuum-plugin 1.0.7-rc02 → 1.0.7

package/README.md

@@ -42,13 +42,23 @@
 ---
 ### 🆔 How to Get Your DUID
 
-To get the **DUID** for your devices. Follow the steps below to retrieve it:
+To get the **DUID** for your devices, you have two options:
 
+**Option 1: From Matterbridge Logs**
 1. **Start Matterbridge** with the plugin enabled.
 2. **Watch the Docker console logs directly** (not the Matterbridge UI logs, as they may be truncated).
 3. Look for the log message that says:
    ```text
    Initializing - devices: [...]
+   ```
+
+**Option 2: From the Roborock App**
+1. Open the **Roborock app** on your phone.
+2. Go to your **Device**.
+3. Tap **Settings** > **Product Info**.
+4. Find the **DID** field. The value will look like `rr_xxxxxxx`.
+5. **Remove the `rr_` prefix** from the DID value. The remaining string is your DUID.
+
 ---
 ### 🚧 Project Status
 

package/dist/behaviorFactory.js

@@ -2,11 +2,17 @@ import { BehaviorDeviceGeneric } from './behaviors/BehaviorDeviceGeneric.js';
 import { setCommandHandlerA187 } from './behaviors/roborock.vacuum/QREVO_EDGE_5V1/a187.js';
 import { setDefaultCommandHandler } from './behaviors/roborock.vacuum/default/default.js';
 import { DeviceModel } from './roborockCommunication/Zmodel/deviceModel.js';
-export function configurateBehavior(model, duid, roborockService, logger) {
+import { setCommandHandlerA27 } from './behaviors/roborock.vacuum/S7_MAXV/a27.js';
+export function configurateBehavior(model, duid, roborockService, cleanModeSettings, logger) {
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setCommandHandlerA187(duid, deviceHandler, logger, roborockService);
+            setCommandHandlerA187(duid, deviceHandler, logger, roborockService, cleanModeSettings);
+            return deviceHandler;
+        }
+        case DeviceModel.S7_MAXV: {
+            const deviceHandler = new BehaviorDeviceGeneric(logger);
+            setCommandHandlerA27(duid, deviceHandler, logger, roborockService);
             return deviceHandler;
         }
         default: {

package/dist/behaviors/roborock.vacuum/QREVO_EDGE_5V1/a187.js

@@ -27,15 +27,16 @@ export var MopWaterFlowA187;
     MopWaterFlowA187[MopWaterFlowA187["Medium"] = 202] = "Medium";
     MopWaterFlowA187[MopWaterFlowA187["High"] = 203] = "High";
     MopWaterFlowA187[MopWaterFlowA187["Custom"] = 204] = "Custom";
+    MopWaterFlowA187[MopWaterFlowA187["CustomizeWithDistanceOff"] = 207] = "CustomizeWithDistanceOff";
     MopWaterFlowA187[MopWaterFlowA187["Smart"] = 209] = "Smart";
 })(MopWaterFlowA187 || (MopWaterFlowA187 = {}));
 export var MopRouteA187;
 (function (MopRouteA187) {
-    MopRouteA187[MopRouteA187["Fast"] = 304] = "Fast";
     MopRouteA187[MopRouteA187["Standard"] = 300] = "Standard";
     MopRouteA187[MopRouteA187["Deep"] = 301] = "Deep";
     MopRouteA187[MopRouteA187["Custom"] = 302] = "Custom";
     MopRouteA187[MopRouteA187["DeepPlus"] = 303] = "DeepPlus";
+    MopRouteA187[MopRouteA187["Fast"] = 304] = "Fast";
     MopRouteA187[MopRouteA187["Smart"] = 306] = "Smart";
 })(MopRouteA187 || (MopRouteA187 = {}));
 const RvcRunMode = {
@@ -51,13 +52,13 @@ const RvcCleanMode = {
     [8]: 'Custom',
 };
 const CleanSetting = {
-    [4]: { suctionPower: 0, waterFlow: 0, mopRoute: MopRouteA187.Smart },
-    [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium, mopRoute: MopRouteA187.Custom },
-    [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off, mopRoute: MopRouteA187.Custom },
-    [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium, mopRoute: MopRouteA187.Custom },
-    [8]: { suctionPower: VacuumSuctionPowerA187.Custom, waterFlow: MopWaterFlowA187.Custom, mopRoute: MopRouteA187.Custom },
+    [4]: { suctionPower: 0, waterFlow: 0, distance_off: 0, mopRoute: MopRouteA187.Smart },
+    [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Custom },
+    [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off, distance_off: 0, mopRoute: MopRouteA187.Custom },
+    [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Custom },
+    [8]: { suctionPower: VacuumSuctionPowerA187.Custom, waterFlow: MopWaterFlowA187.Custom, distance_off: 0, mopRoute: MopRouteA187.Custom },
 };
-export function setCommandHandlerA187(duid, handler, logger, roborockService) {
+export function setCommandHandlerA187(duid, handler, logger, roborockService, cleanModeSettings) {
     handler.setCommandHandler('changeToMode', async (newMode) => {
         const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
         switch (activity) {
@@ -67,20 +68,64 @@ export function setCommandHandlerA187(duid, handler, logger, roborockService) {
                 return;
             }
             case 'Smart Plan':
-            case 'Mop':
-            case 'Vacuum':
-            case 'Vac & Mop':
             case 'Custom': {
                 const setting = CleanSetting[newMode];
-                logger.notice(`BehaviorA187-ChangeCleanMode to: ${activity}, code: ${debugStringify(setting)}`);
+                logger.notice(`BehaviorA187-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
                 await roborockService.changeCleanMode(duid, setting);
                 return;
             }
+            case 'Mop':
+            case 'Vacuum':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`BehaviorA187-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
             default:
                 logger.notice('BehaviorA187-changeToMode-Unknown: ', newMode);
                 return;
         }
     });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlowA187[mopSetting?.waterFlowMode] ?? MopWaterFlowA187.Medium;
+                const distance_off = waterFlow == MopWaterFlowA187.CustomizeWithDistanceOff ? 210 - 5 * (mopSetting?.distanceOff ?? 25) : 0;
+                return {
+                    suctionPower: VacuumSuctionPowerA187.Off,
+                    waterFlow,
+                    distance_off,
+                    mopRoute: MopRouteA187[mopSetting?.mopRouteMode] ?? MopRouteA187.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPowerA187[vacuumSetting?.fanMode] ?? VacuumSuctionPowerA187.Balanced,
+                    waterFlow: MopWaterFlowA187.Off,
+                    distance_off: 0,
+                    mopRoute: MopRouteA187[vacuumSetting?.mopRouteMode] ?? MopRouteA187.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlowA187[vacmopSetting?.waterFlowMode] ?? MopWaterFlowA187.Medium;
+                const distance_off = waterFlow == MopWaterFlowA187.CustomizeWithDistanceOff ? 210 - 5 * (vacmopSetting?.distanceOff ?? 25) : 0;
+                return {
+                    suctionPower: VacuumSuctionPowerA187[vacmopSetting?.fanMode] ?? VacuumSuctionPowerA187.Balanced,
+                    waterFlow,
+                    distance_off,
+                    mopRoute: MopRouteA187[vacmopSetting?.mopRouteMode] ?? MopRouteA187.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
     handler.setCommandHandler('selectAreas', async (newAreas) => {
         logger.notice(`BehaviorA187-selectAreas: ${newAreas}`);
         roborockService.setSelectedAreas(duid, newAreas ?? []);

package/dist/behaviors/roborock.vacuum/S7_MAXV/a27.js

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

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

@@ -0,0 +1,76 @@
+import { RvcCleanMode, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+export function getSupportedRunModesA27() {
+    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 getSupportedCleanModesA27() {
+    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 getOperationalStatesA27() {
+    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/S7_MAXV/runtimes.js

@@ -0,0 +1,33 @@
+import { MopWaterFlowA27, VacuumSuctionPowerA27 } from './a27.js';
+export function getCurrentCleanModeA27(fan_power, water_box_mode) {
+    if (!fan_power || !water_box_mode)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA27.Custom || water_box_mode == MopWaterFlowA27.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA27.Off)
+        return 5;
+    if (water_box_mode == MopWaterFlowA27.Off)
+        return 6;
+    else
+        return 7;
+}
+export function getCurrentCleanModeFromFanPowerA27(fan_power) {
+    if (!fan_power)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA27.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA27.Off)
+        return 5;
+    else
+        return undefined;
+}
+export function getCurrentCleanModeFromWaterBoxModeA27(water_box_mode) {
+    if (!water_box_mode)
+        return undefined;
+    if (water_box_mode == MopWaterFlowA27.Custom)
+        return 8;
+    if (water_box_mode == MopWaterFlowA27.Off)
+        return 6;
+    else
+        return undefined;
+}

package/dist/initialData/getOperationalStates.js

@@ -3,10 +3,13 @@ import { getOperationalStatesA187 } from '../behaviors/roborock.vacuum/QREVO_EDG
 import { getDefaultOperationalStates } from '../behaviors/roborock.vacuum/default/initalData.js';
 import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
 import { VacuumErrorCode } from '../roborockCommunication/Zenum/vacuumAndDockErrorCode.js';
+import { getOperationalStatesA27 } from '../behaviors/roborock.vacuum/S7_MAXV/initalData.js';
 export function getOperationalStates(model) {
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1:
             return getOperationalStatesA187();
+        case DeviceModel.S7_MAXV:
+            return getOperationalStatesA27();
         default:
             return getDefaultOperationalStates();
     }

package/dist/initialData/getSupportedCleanModes.js

@@ -1,10 +1,13 @@
 import { getSupportedCleanModesA187 } from '../behaviors/roborock.vacuum/QREVO_EDGE_5V1/initalData.js';
 import { getDefaultSupportedCleanModes } from '../behaviors/roborock.vacuum/default/initalData.js';
 import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+import { getSupportedCleanModesA27 } from '../behaviors/roborock.vacuum/S7_MAXV/initalData.js';
 export function getSupportedCleanModes(model) {
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1:
             return getSupportedCleanModesA187();
+        case DeviceModel.S7_MAXV:
+            return getSupportedCleanModesA27();
         default:
             return getDefaultSupportedCleanModes();
     }

package/dist/initialData/getSupportedRunModes.js

@@ -1,6 +1,7 @@
 import { getSupportedRunModesA187 } from '../behaviors/roborock.vacuum/QREVO_EDGE_5V1/initalData.js';
 import { getDefaultSupportedRunModes } from '../behaviors/roborock.vacuum/default/initalData.js';
 import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+import { getSupportedRunModesA27 } from '../behaviors/roborock.vacuum/S7_MAXV/initalData.js';
 export function getRunningMode(model, modeTag) {
     if (!model || !modeTag)
         return null;
@@ -12,6 +13,8 @@ export function getSupportedRunModes(model) {
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1:
             return getSupportedRunModesA187();
+        case DeviceModel.S7_MAXV:
+            return getSupportedRunModesA27();
         default:
             return getDefaultSupportedRunModes();
     }

package/dist/model/CleanModeSettings.js

@@ -0,0 +1,5 @@
+export class CleanModeSettings {
+    vacuuming;
+    mopping;
+    vacmop;
+}

package/dist/platform.js

@@ -19,7 +19,6 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     platformRunner;
     devices;
     serialNumber;
-    whiteList;
     constructor(matterbridge, log, config) {
         super(matterbridge, log, config);
         if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.0.4')) {
@@ -32,8 +31,6 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             config.blackList = [];
         if (config.enableExperimentalFeature === undefined)
             config.enableExperimentalFeature = false;
-        this.whiteList = config.whiteList;
-        config.whiteList = [];
         this.clientManager = new ClientManager(this.log);
         this.devices = new Map();
     }
@@ -74,15 +71,16 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
         const devices = await this.roborockService.listDevices(username);
         this.log.notice('Initializing - devices: ', debugStringify(devices));
         let vacuum = undefined;
-        if (this.whiteList.length > 0) {
-            const firstDUID = this.whiteList[0];
-            vacuum = devices.find((d) => d.duid == firstDUID);
+        if (this.config.whiteList.length > 0) {
+            const firstDUID = this.config.whiteList[0];
+            const duid = firstDUID.split('-')[1];
+            vacuum = devices.find((d) => d.duid == duid);
         }
         else {
             vacuum = devices.find((d) => isSupportedDevice(d.data.model));
         }
         if (!vacuum) {
-            this.log.error('Initializing: No supported devices found');
+            this.log.error('Initializing: No device found');
             return;
         }
         await this.roborockService.initializeMessageClient(username, vacuum, userData);
@@ -93,6 +91,11 @@ 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();
@@ -110,11 +113,15 @@ 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, this.log);
+        const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, cleanModeSettings, this.log);
         this.roborockService.setSupportedAreas(vacuum.duid, getSupportedAreas(vacuum.rooms, roomMap, this.log));
         this.robot = new RoborockVacuumCleaner(username, vacuum, roomMap, this.log);
         this.robot.configurateHandler(behaviorHandler);

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -63,24 +63,29 @@ export class MessageProcessor {
         const request = new RequestMessage(def);
         return this.client.send(duid, request);
     }
-    async getCustomMessage(duid, def) {
-        const response = this.client.get(duid, def);
-        this.logger?.warn('XXXXXXX: ', debugStringify(response));
-        return response;
+    getCustomMessage(duid, def) {
+        return this.client.get(duid, def);
     }
     async findMyRobot(duid) {
         const request = new RequestMessage({ method: 'find_me' });
         return this.client.send(duid, request);
     }
-    async changeCleanMode(duid, suctionPower, waterFlow, mopRoute) {
-        this.logger?.notice(`Change clean mode for ${duid} to suctionPower: ${suctionPower}, waterFlow: ${waterFlow}`);
+    async changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off) {
+        this.logger?.notice(`Change clean mode for ${duid} to suctionPower: ${suctionPower}, waterFlow: ${waterFlow}, mopRoute: ${mopRoute}, distance_off: ${distance_off}`);
+        const currentMopMode = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_custom_mode' }));
+        if (currentMopMode == 110) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [302] }));
+        }
         if (mopRoute && mopRoute != 0) {
             await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [mopRoute] }));
         }
         if (suctionPower && suctionPower != 0) {
             await this.client.send(duid, new RequestMessage({ method: 'set_custom_mode', params: [suctionPower] }));
         }
-        if (waterFlow && waterFlow != 0) {
+        if (waterFlow && waterFlow == 207 && distance_off && distance_off != 0) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_water_box_custom_mode', params: { 'water_box_mode': waterFlow, 'distance_off': distance_off } }));
+        }
+        else if (waterFlow && waterFlow != 0) {
             await this.client.send(duid, new RequestMessage({ method: 'set_water_box_custom_mode', params: [waterFlow] }));
         }
     }

package/dist/roborockService.js

@@ -48,9 +48,9 @@ export default class RoborockService {
     getSupportedAreas(duid) {
         return this.supportedAreas.get(duid);
     }
-    async changeCleanMode(duid, { suctionPower, waterFlow, mopRoute }) {
+    async changeCleanMode(duid, { suctionPower, waterFlow, distance_off, mopRoute }) {
         this.logger.notice('changeCleanMode');
-        return this.messageProcessor?.changeCleanMode(duid, suctionPower, waterFlow, mopRoute);
+        return this.messageProcessor?.changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off);
     }
     async startClean(duid) {
         const areas = this.supportedAreas.get(duid);
@@ -89,6 +89,9 @@ export default class RoborockService {
         this.logger.debug('customGetInSecure-message', method);
         return this.getMessageProcessor()?.getCustomMessage(duid, new RequestMessage({ method, secure: true }));
     }
+    async customSend(duid, request) {
+        return this.getMessageProcessor()?.sendCustomMessage(duid, request);
+    }
     stopService() {
         if (this.messageClient) {
             this.messageClient.disconnect();

package/dist/rvc.js

@@ -10,7 +10,8 @@ export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
         const cleanModes = getSupportedCleanModes(device.data.model);
         const supportedRunModes = getSupportedRunModes(device.data.model);
         const supportedAreas = getSupportedAreas(device.rooms, roomMap, log);
-        super(device.name, device.duid, supportedRunModes[0].mode, supportedRunModes, cleanModes[0].mode, cleanModes, undefined, undefined, RvcOperationalState.OperationalState.Docked, getOperationalStates(device.data.model), supportedAreas, undefined, supportedAreas[0].areaId);
+        const deviceName = `${device.name}-${device.duid}`.replace(/\s+/g, '');
+        super(deviceName, device.duid, supportedRunModes[0].mode, supportedRunModes, cleanModes[0].mode, cleanModes, undefined, undefined, RvcOperationalState.OperationalState.Docked, getOperationalStates(device.data.model), supportedAreas, undefined, supportedAreas[0].areaId);
         this.username = username;
         this.device = device;
         this.rrHomeId = device.rrHomeId;

package/dist/share/runtimeHelper.js

@@ -1,10 +1,14 @@
 import { getCurrentCleanModeA187, getCurrentCleanModeFromFanPowerA187, getCurrentCleanModeFromWaterBoxModeA187 } from '../behaviors/roborock.vacuum/QREVO_EDGE_5V1/runtimes.js';
+import { getCurrentCleanModeA27, getCurrentCleanModeFromFanPowerA27, getCurrentCleanModeFromWaterBoxModeA27 } from '../behaviors/roborock.vacuum/S7_MAXV/runtimes.js';
 import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
 export function getCurrentCleanModeFunc(model) {
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1: {
             return getCurrentCleanModeA187;
         }
+        case DeviceModel.S7_MAXV: {
+            return getCurrentCleanModeA27;
+        }
         default:
             return (_, __) => undefined;
     }
@@ -14,6 +18,9 @@ export function getCurrentCleanModeFromFanPowerFunc(model) {
         case DeviceModel.QREVO_EDGE_5V1: {
             return getCurrentCleanModeFromFanPowerA187;
         }
+        case DeviceModel.S7_MAXV: {
+            return getCurrentCleanModeFromFanPowerA27;
+        }
         default:
             return (_) => undefined;
     }
@@ -23,6 +30,9 @@ export function getCurrentCleanModeFromWaterBoxModeFunc(model) {
         case DeviceModel.QREVO_EDGE_5V1: {
             return getCurrentCleanModeFromWaterBoxModeA187;
         }
+        case DeviceModel.S7_MAXV: {
+            return getCurrentCleanModeFromWaterBoxModeA27;
+        }
         default:
             return (_) => undefined;
     }

package/matterbridge-roborock-vacuum-plugin.config.json

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.0.7-rc02",
+  "version": "1.0.7",
   "whiteList": [],
   "blackList": [],
   "useInterval": true,