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

package/dist/behaviorFactory.js

@@ -12,7 +12,7 @@ export function configurateBehavior(model, duid, roborockService, cleanModeSetti
         }
         case DeviceModel.S7_MAXV: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setCommandHandlerA27(duid, deviceHandler, logger, roborockService);
+            setCommandHandlerA27(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
         default: {

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

@@ -53,9 +53,9 @@ const RvcCleanMode = {
 };
 const CleanSetting = {
     [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 },
+    [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Standard },
+    [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off, distance_off: 0, mopRoute: MopRouteA187.Standard },
+    [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Standard },
     [8]: { suctionPower: VacuumSuctionPowerA187.Custom, waterFlow: MopWaterFlowA187.Custom, distance_off: 0, mopRoute: MopRouteA187.Custom },
 };
 export function setCommandHandlerA187(duid, handler, logger, roborockService, cleanModeSettings) {

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

@@ -47,12 +47,12 @@ const RvcCleanMode = {
     [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 },
+    [5]: { suctionPower: VacuumSuctionPowerA27.Off, waterFlow: MopWaterFlowA27.Medium, distance_off: 0, mopRoute: MopRouteA27.Standard },
+    [6]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Off, distance_off: 0, mopRoute: MopRouteA27.Standard },
+    [7]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Medium, distance_off: 0, mopRoute: MopRouteA27.Standard },
+    [8]: { suctionPower: VacuumSuctionPowerA27.Custom, waterFlow: MopWaterFlowA27.Custom, distance_off: 0, mopRoute: MopRouteA27.Custom },
 };
-export function setCommandHandlerA27(duid, handler, logger, roborockService) {
+export function setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings) {
     handler.setCommandHandler('changeToMode', async (newMode) => {
         const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
         switch (activity) {
@@ -63,10 +63,18 @@ export function setCommandHandlerA27(duid, handler, logger, roborockService) {
             }
             case 'Mop':
             case 'Vacuum':
-            case 'Vac & Mop':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
             case 'Custom': {
                 const setting = CleanSetting[newMode];
-                logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, code: ${debugStringify(setting)}`);
+                logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
                 return;
             }
             default:
@@ -74,6 +82,41 @@ export function setCommandHandlerA27(duid, handler, logger, roborockService) {
                 return;
         }
     });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlowA27[mopSetting?.waterFlowMode] ?? MopWaterFlowA27.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA27.Off,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA27[mopSetting?.mopRouteMode] ?? MopRouteA27.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPowerA27[vacuumSetting?.fanMode] ?? VacuumSuctionPowerA27.Balanced,
+                    waterFlow: MopWaterFlowA27.Off,
+                    distance_off: 0,
+                    mopRoute: MopRouteA27[vacuumSetting?.mopRouteMode] ?? MopRouteA27.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlowA27[vacmopSetting?.waterFlowMode] ?? MopWaterFlowA27.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA27[vacmopSetting?.fanMode] ?? VacuumSuctionPowerA27.Balanced,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA27[vacmopSetting?.mopRouteMode] ?? MopRouteA27.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
     handler.setCommandHandler('selectAreas', async (newAreas) => {
         logger.notice(`BehaviorA27-selectAreas: ${newAreas}`);
         roborockService.setSelectedAreas(duid, newAreas ?? []);

package/dist/roborockCommunication/broadcast/abstractClient.js

@@ -14,8 +14,8 @@ export class AbstractClient {
     logger;
     constructor(logger, context) {
         this.context = context;
-        this.serializer = new MessageSerializer(this.context);
-        this.deserializer = new MessageDeserializer(this.context);
+        this.serializer = new MessageSerializer(this.context, logger);
+        this.deserializer = new MessageDeserializer(this.context, logger);
         this.syncMessageListener = new SyncMessageListener(logger);
         this.messageListeners.register(this.syncMessageListener);
         this.logger = logger;

package/dist/roborockCommunication/broadcast/client/LocalNetworkClient.js

@@ -87,31 +87,31 @@ export class LocalNetworkClient extends AbstractClient {
         }
         try {
             this.buffer.append(message);
-            const recvBuffer = this.buffer.get();
-            if (!this.isMessageComplete(recvBuffer)) {
+            const receivedBuffer = this.buffer.get();
+            if (!this.isMessageComplete(receivedBuffer)) {
                 return;
             }
             this.buffer.reset();
             let offset = 0;
-            while (offset + 4 <= recvBuffer.length) {
-                const segmentLength = recvBuffer.readUInt32BE(offset);
+            while (offset + 4 <= receivedBuffer.length) {
+                const segmentLength = receivedBuffer.readUInt32BE(offset);
                 if (segmentLength == 17) {
                     offset += 4 + segmentLength;
                     continue;
                 }
                 try {
-                    const currentBuffer = recvBuffer.subarray(offset + 4, offset + segmentLength + 4);
+                    const currentBuffer = receivedBuffer.subarray(offset + 4, offset + segmentLength + 4);
                     const response = this.deserializer.deserialize(this.duid, currentBuffer);
                     await this.messageListeners.onMessage(response);
                 }
                 catch (error) {
-                    this.logger.error('unable to process message: ' + error);
+                    this.logger.error('LocalNetworkClient: unable to process message with error: ' + error);
                 }
                 offset += 4 + segmentLength;
             }
         }
         catch (error) {
-            this.logger.error('failed to read from a socket: ' + error);
+            this.logger.error('LocalNetworkClient: read socket buffer error: ' + error);
         }
     }
     isMessageComplete(buffer) {

package/dist/roborockCommunication/broadcast/client/MQTTClient.js

@@ -97,7 +97,7 @@ export class MQTTClient extends AbstractClient {
             await this.messageListeners.onMessage(response);
         }
         catch (error) {
-            this.logger.error('unable to process message from queue ' + topic + ': ' + error);
+            this.logger.error('MQTTClient: unable to process message with error: ' + topic + ': ' + error);
         }
     }
 }

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -73,20 +73,29 @@ export class MessageProcessor {
     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] }));
+        const smartMopMode = 110;
+        const smartMopRoute = 306;
+        const customMopMode = 106;
+        const customMopRoute = 302;
+        if (currentMopMode == smartMopMode && mopRoute == smartMopRoute)
+            return;
+        if (currentMopMode == customMopMode && mopRoute == customMopRoute)
+            return;
+        if (currentMopMode == smartMopMode) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [customMopRoute] }));
         }
         if (suctionPower && suctionPower != 0) {
             await this.client.send(duid, new RequestMessage({ method: 'set_custom_mode', params: [suctionPower] }));
         }
-        if (waterFlow && waterFlow == 207 && distance_off && distance_off != 0) {
+        const CustomizeWithDistanceOff = 207;
+        if (waterFlow && waterFlow == CustomizeWithDistanceOff && 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] }));
         }
+        if (mopRoute && mopRoute != 0) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [mopRoute] }));
+        }
     }
 }

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -7,10 +7,12 @@ import { CryptoUtils, MessageUtils } from './cryptoHelper.js';
 import { Protocol } from '../broadcast/model/protocol.js';
 export class MessageDeserializer {
     context;
-    mqttMessageParser;
-    constructor(context) {
+    messageParser;
+    logger;
+    constructor(context, logger) {
         this.context = context;
-        this.mqttMessageParser = new Parser()
+        this.logger = logger;
+        this.messageParser = new Parser()
             .endianess('big')
             .string('version', {
             length: 3,
@@ -31,13 +33,13 @@ export class MessageDeserializer {
             throw new Error('unknown protocol version ' + version);
         }
         const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
-        const expectedCrc32 = message.readUint32BE(message.length - 4);
+        const expectedCrc32 = message.readUInt32BE(message.length - 4);
         if (crc32 != expectedCrc32) {
-            return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+            throw new Error(`Wrong CRC32 ${crc32}, expected ${expectedCrc32}`);
         }
         const localKey = this.context.getLocalKey(duid);
         assert(localKey, 'unable to retrieve local key for ' + duid);
-        const data = this.mqttMessageParser.parse(message);
+        const data = this.messageParser.parse(message);
         if (version == '1.0') {
             const aesKey = CryptoUtils.md5bin(MessageUtils.encodeTimestamp(data.timestamp) + localKey + MessageUtils.SALT);
             const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
@@ -55,6 +57,7 @@ export class MessageDeserializer {
             return this.deserializeProtocolRpcResponse(duid, data);
         }
         else {
+            this.logger.error('unknown protocol: ' + data.protocol);
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
     }

package/dist/roborockCommunication/helper/messageSerializer.js

@@ -3,10 +3,12 @@ import crypto from 'crypto';
 import CRC32 from 'crc-32';
 export class MessageSerializer {
     context;
+    logger;
     seq = 1;
     random = 4711;
-    constructor(context) {
+    constructor(context, logger) {
         this.context = context;
+        this.logger = logger;
     }
     serialize(duid, request) {
         const messageId = request.messageId;

package/dist/share/function.js

@@ -63,12 +63,6 @@ export function state_to_matter_operational_status(state) {
         case OperationStatusCode.ZoneCleanMopCleaning:
         case OperationStatusCode.ZoneCleanMopMopping:
         case OperationStatusCode.RobotStatusMopping:
-        case OperationStatusCode.WashingTheMop:
-        case OperationStatusCode.WashingTheMop2:
-        case OperationStatusCode.ReturnToDock:
-        case OperationStatusCode.GoingToWashTheMop:
-        case OperationStatusCode.BackToDockWashingDuster:
-        case OperationStatusCode.EmptyingDustContainer:
             return RvcOperationalState.OperationalState.Running;
         case OperationStatusCode.InError:
         case OperationStatusCode.ChargingError:
@@ -82,7 +76,13 @@ export function state_to_matter_operational_status(state) {
         case OperationStatusCode.ShuttingDown:
         case OperationStatusCode.Locked:
             return RvcOperationalState.OperationalState.Stopped;
+        case OperationStatusCode.ReturnToDock:
         case OperationStatusCode.ReturningDock:
+        case OperationStatusCode.WashingTheMop:
+        case OperationStatusCode.WashingTheMop2:
+        case OperationStatusCode.GoingToWashTheMop:
+        case OperationStatusCode.BackToDockWashingDuster:
+        case OperationStatusCode.EmptyingDustContainer:
             return RvcOperationalState.OperationalState.SeekingCharger;
         case OperationStatusCode.Idle:
         case OperationStatusCode.Sleeping:

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

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

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

@@ -1,6 +1,6 @@
 {
   "title": "Matterbridge Roborock Vacuum Plugin",
-  "description": "matterbridge-roborock-vacuum-plugin v. 1.0.7 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.0.8-rc01 by https://github.com/RinDevJunior",
   "type": "object",
   "required": ["username", "password"],
   "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
-  "version": "1.0.7",
+  "version": "1.0.8-rc01",
   "description": "Matterbridge Roborock Vacuum Plugin",
   "author": "https://github.com/RinDevJunior",
   "license": "MIT",

package/src/behaviorFactory.ts

@@ -25,7 +25,7 @@ export function configurateBehavior(
 
     case DeviceModel.S7_MAXV: {
       const deviceHandler = new BehaviorDeviceGeneric<EndpointCommandsA27>(logger);
-      setCommandHandlerA27(duid, deviceHandler, logger, roborockService);
+      setCommandHandlerA27(duid, deviceHandler, logger, roborockService, cleanModeSettings);
       return deviceHandler;
     }
 

package/src/behaviors/roborock.vacuum/QREVO_EDGE_5V1/a187.ts

@@ -71,9 +71,9 @@ const RvcCleanMode: Record<number, string> = {
 
 const CleanSetting: Record<number, { suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number }> = {
   [4]: { suctionPower: 0, waterFlow: 0, distance_off: 0, mopRoute: MopRouteA187.Smart }, //'Smart Plan'
-  [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Custom }, //'Mop'
-  [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off, distance_off: 0, mopRoute: MopRouteA187.Custom }, //'Vacuum'
-  [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Custom }, //'Vac & Mop'
+  [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Standard }, //'Mop'
+  [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off, distance_off: 0, mopRoute: MopRouteA187.Standard }, //'Vacuum'
+  [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Standard }, //'Vac & Mop'
   [8]: { suctionPower: VacuumSuctionPowerA187.Custom, waterFlow: MopWaterFlowA187.Custom, distance_off: 0, mopRoute: MopRouteA187.Custom }, // 'Custom'
 };
 

package/src/behaviors/roborock.vacuum/QREVO_EDGE_5V1/runtimes.test.ts

@@ -0,0 +1,79 @@
+import { getCurrentCleanModeA187, getCurrentCleanModeFromFanPowerA187, getCurrentCleanModeFromWaterBoxModeA187 } from './runtimes';
+import { MopWaterFlowA187, VacuumSuctionPowerA187 } from './a187';
+
+describe('getCurrentCleanModeA187', () => {
+  it('returns undefined if fan_power or water_box_mode is undefined', () => {
+    expect(getCurrentCleanModeA187(undefined, 1)).toBeUndefined();
+    expect(getCurrentCleanModeA187(1, undefined)).toBeUndefined();
+  });
+
+  it('returns undefined if fan_power = 105 or water_box_mode = 202', () => {
+    expect(getCurrentCleanModeA187(105, 202)).toBe(5);
+  });
+
+  it('returns 4 for Smart plan', () => {
+    expect(getCurrentCleanModeA187(VacuumSuctionPowerA187.Smart, 1)).toBe(4);
+    expect(getCurrentCleanModeA187(1, MopWaterFlowA187.Smart)).toBe(4);
+  });
+
+  it('returns 8 for Custom', () => {
+    expect(getCurrentCleanModeA187(VacuumSuctionPowerA187.Custom, 1)).toBe(8);
+    expect(getCurrentCleanModeA187(1, MopWaterFlowA187.Custom)).toBe(8);
+  });
+
+  it('returns 5 for Mop', () => {
+    expect(getCurrentCleanModeA187(VacuumSuctionPowerA187.Off, 1)).toBe(5);
+  });
+
+  it('returns 6 for Vacuum', () => {
+    expect(getCurrentCleanModeA187(1, MopWaterFlowA187.Off)).toBe(6);
+  });
+
+  it('returns 7 for Vac & Mop', () => {
+    expect(getCurrentCleanModeA187(1, 1)).toBe(7);
+  });
+});
+
+describe('getCurrentCleanModeFromFanPowerA187', () => {
+  it('returns undefined if fan_power is undefined', () => {
+    expect(getCurrentCleanModeFromFanPowerA187(undefined)).toBeUndefined();
+  });
+
+  it('returns 4 for Smart plan', () => {
+    expect(getCurrentCleanModeFromFanPowerA187(VacuumSuctionPowerA187.Smart)).toBe(4);
+  });
+
+  it('returns 8 for Custom', () => {
+    expect(getCurrentCleanModeFromFanPowerA187(VacuumSuctionPowerA187.Custom)).toBe(8);
+  });
+
+  it('returns 5 for Mop', () => {
+    expect(getCurrentCleanModeFromFanPowerA187(VacuumSuctionPowerA187.Off)).toBe(5);
+  });
+
+  it('returns undefined for other values', () => {
+    expect(getCurrentCleanModeFromFanPowerA187(12345)).toBeUndefined();
+  });
+});
+
+describe('getCurrentCleanModeFromWaterBoxModeA187', () => {
+  it('returns undefined if water_box_mode is undefined', () => {
+    expect(getCurrentCleanModeFromWaterBoxModeA187(undefined)).toBeUndefined();
+  });
+
+  it('returns 4 for Smart plan', () => {
+    expect(getCurrentCleanModeFromWaterBoxModeA187(MopWaterFlowA187.Smart)).toBe(4);
+  });
+
+  it('returns 8 for Custom', () => {
+    expect(getCurrentCleanModeFromWaterBoxModeA187(MopWaterFlowA187.Custom)).toBe(8);
+  });
+
+  it('returns 6 for Vacuum', () => {
+    expect(getCurrentCleanModeFromWaterBoxModeA187(MopWaterFlowA187.Off)).toBe(6);
+  });
+
+  it('returns undefined for other values', () => {
+    expect(getCurrentCleanModeFromWaterBoxModeA187(12345)).toBeUndefined();
+  });
+});

package/src/behaviors/roborock.vacuum/S7_MAXV/a27.test.ts

@@ -0,0 +1,134 @@
+import { setCommandHandlerA27, VacuumSuctionPowerA27, MopWaterFlowA27, MopRouteA27 } from './a27';
+import { BehaviorDeviceGeneric } from '../../BehaviorDeviceGeneric';
+import { AnsiLogger } from 'matterbridge/logger';
+import RoborockService from '../../../roborockService';
+import { CleanModeSettings } from '../../../model/CleanModeSettings';
+import { jest } from '@jest/globals';
+
+describe('setCommandHandlerA27', () => {
+  let handler: BehaviorDeviceGeneric<any>;
+  let logger: AnsiLogger;
+  let roborockService: jest.Mocked<RoborockService>;
+  let cleanModeSettings: CleanModeSettings;
+  const duid = 'test-duid';
+
+  beforeEach(() => {
+    handler = {
+      setCommandHandler: jest.fn(),
+    } as any;
+
+    logger = {
+      notice: jest.fn(),
+      warn: jest.fn(),
+    } as any;
+
+    roborockService = {
+      startClean: jest.fn(),
+      changeCleanMode: jest.fn(),
+      setSelectedAreas: jest.fn(),
+      pauseClean: jest.fn(),
+      resumeClean: jest.fn(),
+      stopAndGoHome: jest.fn(),
+      playSoundToLocate: jest.fn(),
+    } as any;
+
+    cleanModeSettings = {
+      vacuuming: { fanMode: 'Max', mopRouteMode: 'DeepPlus' },
+      mopping: { waterFlowMode: 'High', mopRouteMode: 'Fast', distanceOff: 85 },
+      vacmop: {
+        fanMode: 'Turbo',
+        waterFlowMode: 'Low',
+        mopRouteMode: 'Deep',
+        distanceOff: 85,
+      },
+    };
+  });
+
+  it('should set all command handlers', () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('changeToMode', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('selectAreas', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('pause', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('resume', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('goHome', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('PlaySoundToLocate', expect.any(Function));
+  });
+
+  it('should call startClean for Cleaning mode', async () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(2); // 2 = Cleaning
+    expect(roborockService.startClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call changeCleanMode for Mop with correct values', async () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(5); // 5 = Mop
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPowerA27.Off,
+      waterFlow: MopWaterFlowA27.High,
+      mopRoute: MopRouteA27.Fast,
+      distance_off: 0,
+    });
+  });
+
+  it('should call changeCleanMode for Vacuum with correct values', async () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(6); // 6 = Vacuum
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPowerA27.Max,
+      waterFlow: MopWaterFlowA27.Off,
+      mopRoute: MopRouteA27.DeepPlus,
+      distance_off: 0,
+    });
+  });
+
+  it('should call changeCleanMode for Vac & Mop with correct values', async () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(7); // 7 = Vac & Mop
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPowerA27.Turbo,
+      waterFlow: MopWaterFlowA27.Low,
+      mopRoute: MopRouteA27.Deep,
+      distance_off: 0,
+    });
+  });
+
+  it('should call setSelectedAreas', async () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, selectAreasHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'selectAreas');
+    await (selectAreasHandler as (areas: number[]) => Promise<void>)([1, 2, 3]);
+    expect(roborockService.setSelectedAreas).toHaveBeenCalledWith(duid, [1, 2, 3]);
+  });
+
+  it('should call pauseClean', async () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, pauseHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'pause');
+    await (pauseHandler as () => Promise<void>)();
+    expect(roborockService.pauseClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call resumeClean', async () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, resumeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'resume');
+    await (resumeHandler as () => Promise<void>)();
+    expect(roborockService.resumeClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call stopAndGoHome', async () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, goHomeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'goHome');
+    await (goHomeHandler as () => Promise<void>)();
+    expect(roborockService.stopAndGoHome).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call playSoundToLocate', async () => {
+    setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, playSoundHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'PlaySoundToLocate');
+    await (playSoundHandler as (arg: number) => Promise<void>)(1);
+    expect(roborockService.playSoundToLocate).toHaveBeenCalledWith(duid);
+  });
+});

package/src/behaviors/roborock.vacuum/S7_MAXV/a27.ts

@@ -2,6 +2,7 @@ import { MaybePromise } from 'matterbridge/matter';
 import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 import { BehaviorDeviceGeneric, BehaviorRoborock, DeviceCommands } from '../../BehaviorDeviceGeneric.js';
 import RoborockService from '../../../roborockService.js';
+import { CleanModeSettings } from '../../../model/CleanModeSettings.js';
 
 export interface EndpointCommandsA27 extends DeviceCommands {
   selectAreas: (newAreas: any) => MaybePromise;
@@ -63,14 +64,20 @@ const RvcCleanMode: Record<number, string> = {
   [8]: 'Custom',
 };
 
-const CleanSetting: Record<number, { suctionPower: number; waterFlow: number; mopRoute: number }> = {
-  [5]: { suctionPower: VacuumSuctionPowerA27.Off, waterFlow: MopWaterFlowA27.Medium, mopRoute: MopRouteA27.Custom }, //'Mop'
-  [6]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Off, mopRoute: MopRouteA27.Custom }, //'Vacuum'
-  [7]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Medium, mopRoute: MopRouteA27.Custom }, //'Vac & Mop'
-  [8]: { suctionPower: VacuumSuctionPowerA27.Custom, waterFlow: MopWaterFlowA27.Custom, mopRoute: MopRouteA27.Custom }, // 'Custom'
+const CleanSetting: Record<number, { suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number }> = {
+  [5]: { suctionPower: VacuumSuctionPowerA27.Off, waterFlow: MopWaterFlowA27.Medium, distance_off: 0, mopRoute: MopRouteA27.Standard }, //'Mop'
+  [6]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Off, distance_off: 0, mopRoute: MopRouteA27.Standard }, //'Vacuum'
+  [7]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Medium, distance_off: 0, mopRoute: MopRouteA27.Standard }, //'Vac & Mop'
+  [8]: { suctionPower: VacuumSuctionPowerA27.Custom, waterFlow: MopWaterFlowA27.Custom, distance_off: 0, mopRoute: MopRouteA27.Custom }, // 'Custom'
 };
 
-export function setCommandHandlerA27(duid: string, handler: BehaviorDeviceGeneric<DeviceCommands>, logger: AnsiLogger, roborockService: RoborockService): void {
+export function setCommandHandlerA27(
+  duid: string,
+  handler: BehaviorDeviceGeneric<DeviceCommands>,
+  logger: AnsiLogger,
+  roborockService: RoborockService,
+  cleanModeSettings: CleanModeSettings | undefined,
+): void {
   handler.setCommandHandler('changeToMode', async (newMode: number) => {
     const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
     switch (activity) {
@@ -81,11 +88,18 @@ export function setCommandHandlerA27(duid: string, handler: BehaviorDeviceGeneri
       }
       case 'Mop':
       case 'Vacuum':
-      case 'Vac & Mop':
+      case 'Vac & Mop': {
+        const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+        logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+        if (setting) {
+          await roborockService.changeCleanMode(duid, setting);
+        }
+        return;
+      }
       case 'Custom': {
         const setting = CleanSetting[newMode];
-        logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, code: ${debugStringify(setting)}`);
-        //await roborockService.changeCleanMode(duid, setting);
+        logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+        await roborockService.changeCleanMode(duid, setting);
         return;
       }
       default:
@@ -94,6 +108,45 @@ export function setCommandHandlerA27(duid: string, handler: BehaviorDeviceGeneri
     }
   });
 
+  const getSettingFromCleanMode = (
+    activity: string,
+    cleanModeSettings?: CleanModeSettings,
+  ): { suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number } | undefined => {
+    switch (activity) {
+      case 'Mop': {
+        const mopSetting = cleanModeSettings?.mopping;
+        const waterFlow = MopWaterFlowA27[mopSetting?.waterFlowMode as keyof typeof MopWaterFlowA27] ?? MopWaterFlowA27.Medium;
+        return {
+          suctionPower: VacuumSuctionPowerA27.Off,
+          waterFlow,
+          distance_off: 0,
+          mopRoute: MopRouteA27[mopSetting?.mopRouteMode as keyof typeof MopRouteA27] ?? MopRouteA27.Standard,
+        };
+      }
+      case 'Vacuum': {
+        const vacuumSetting = cleanModeSettings?.vacuuming;
+        return {
+          suctionPower: VacuumSuctionPowerA27[vacuumSetting?.fanMode as keyof typeof VacuumSuctionPowerA27] ?? VacuumSuctionPowerA27.Balanced,
+          waterFlow: MopWaterFlowA27.Off,
+          distance_off: 0,
+          mopRoute: MopRouteA27[vacuumSetting?.mopRouteMode as keyof typeof MopRouteA27] ?? MopRouteA27.Standard,
+        };
+      }
+      case 'Vac & Mop': {
+        const vacmopSetting = cleanModeSettings?.vacmop;
+        const waterFlow = MopWaterFlowA27[vacmopSetting?.waterFlowMode as keyof typeof MopWaterFlowA27] ?? MopWaterFlowA27.Medium;
+        return {
+          suctionPower: VacuumSuctionPowerA27[vacmopSetting?.fanMode as keyof typeof VacuumSuctionPowerA27] ?? VacuumSuctionPowerA27.Balanced,
+          waterFlow,
+          distance_off: 0,
+          mopRoute: MopRouteA27[vacmopSetting?.mopRouteMode as keyof typeof MopRouteA27] ?? MopRouteA27.Standard,
+        };
+      }
+      default:
+        return undefined;
+    }
+  };
+
   handler.setCommandHandler('selectAreas', async (newAreas: number[]) => {
     logger.notice(`BehaviorA27-selectAreas: ${newAreas}`);
     roborockService.setSelectedAreas(duid, newAreas ?? []);

package/src/roborockCommunication/broadcast/abstractClient.ts

@@ -24,8 +24,8 @@ export abstract class AbstractClient implements Client {
 
   protected constructor(logger: AnsiLogger, context: MessageContext) {
     this.context = context;
-    this.serializer = new MessageSerializer(this.context);
-    this.deserializer = new MessageDeserializer(this.context);
+    this.serializer = new MessageSerializer(this.context, logger);
+    this.deserializer = new MessageDeserializer(this.context, logger);
 
     this.syncMessageListener = new SyncMessageListener(logger);
     this.messageListeners.register(this.syncMessageListener);

package/src/roborockCommunication/broadcast/client/LocalNetworkClient.ts

@@ -107,31 +107,32 @@ export class LocalNetworkClient extends AbstractClient {
     try {
       this.buffer.append(message);
 
-      const recvBuffer = this.buffer.get();
-      if (!this.isMessageComplete(recvBuffer)) {
+      const receivedBuffer = this.buffer.get();
+      if (!this.isMessageComplete(receivedBuffer)) {
         return;
       }
       this.buffer.reset();
 
       let offset = 0;
-      while (offset + 4 <= recvBuffer.length) {
-        const segmentLength = recvBuffer.readUInt32BE(offset);
+      while (offset + 4 <= receivedBuffer.length) {
+        const segmentLength = receivedBuffer.readUInt32BE(offset);
         if (segmentLength == 17) {
           offset += 4 + segmentLength;
           continue;
         }
 
         try {
-          const currentBuffer = recvBuffer.subarray(offset + 4, offset + segmentLength + 4);
+          const currentBuffer = receivedBuffer.subarray(offset + 4, offset + segmentLength + 4);
           const response = this.deserializer.deserialize(this.duid, currentBuffer);
           await this.messageListeners.onMessage(response);
         } catch (error) {
-          this.logger.error('unable to process message: ' + error);
+          this.logger.error('LocalNetworkClient: unable to process message with error: ' + error);
+          //unable to process message: TypeError: Cannot read properties of undefined (reading 'length')
         }
         offset += 4 + segmentLength;
       }
     } catch (error) {
-      this.logger.error('failed to read from a socket: ' + error);
+      this.logger.error('LocalNetworkClient: read socket buffer error: ' + error);
     }
   }
 
@@ -145,7 +146,7 @@ export class LocalNetworkClient extends AbstractClient {
       offset += 4 + segmentLength;
 
       if (offset > buffer.length) {
-        return false; // Data is not complete yet
+        return false;
       }
     }
 

package/src/roborockCommunication/broadcast/client/MQTTClient.ts

@@ -124,7 +124,7 @@ export class MQTTClient extends AbstractClient {
       const response = this.deserializer.deserialize(duid, message);
       await this.messageListeners.onMessage(response);
     } catch (error) {
-      this.logger.error('unable to process message from queue ' + topic + ': ' + error);
+      this.logger.error('MQTTClient: unable to process message with error: ' + topic + ': ' + error);
     }
   }
 }

package/src/roborockCommunication/broadcast/messageProcessor.ts

@@ -103,26 +103,32 @@ export class MessageProcessor {
     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' }));
+    const smartMopMode = 110;
+    const smartMopRoute = 306;
+    const customMopMode = 106;
+    const customMopRoute = 302;
 
-    //110 == AI/Smart Plan
-    //302 == Custom
-    if (currentMopMode == 110) {
-      await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [302] }));
-    }
+    if (currentMopMode == smartMopMode && mopRoute == smartMopRoute) return;
+    if (currentMopMode == customMopMode && mopRoute == customMopRoute) return;
 
-    if (mopRoute && mopRoute != 0) {
-      await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [mopRoute] }));
+    //if change mode from smart plan, firstly change to custom
+    if (currentMopMode == smartMopMode) {
+      await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [customMopRoute] }));
     }
 
     if (suctionPower && suctionPower != 0) {
       await this.client.send(duid, new RequestMessage({ method: 'set_custom_mode', params: [suctionPower] }));
     }
 
-    //207 == CustomizeWithDistanceOff
-    if (waterFlow && waterFlow == 207 && distance_off && distance_off != 0) {
+    const CustomizeWithDistanceOff = 207;
+    if (waterFlow && waterFlow == CustomizeWithDistanceOff && 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] }));
     }
+
+    if (mopRoute && mopRoute != 0) {
+      await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [mopRoute] }));
+    }
   }
 }

package/src/roborockCommunication/helper/messageDeserializer.ts

@@ -7,6 +7,7 @@ import { ResponseMessage } from '../broadcast/model/responseMessage.js';
 import { CryptoUtils, MessageUtils } from './cryptoHelper.js';
 import { Protocol } from '../broadcast/model/protocol.js';
 import { MessageContext } from '../broadcast/model/messageContext.js';
+import { AnsiLogger } from 'matterbridge/logger';
 
 export interface Message {
   version: string;
@@ -14,19 +15,21 @@ export interface Message {
   random: number;
   timestamp: number;
   protocol: number;
-  payloadLen: number;
+  payloadLen?: number;
   payload: Buffer<ArrayBufferLike>;
   crc32: number;
 }
 
 export class MessageDeserializer {
   private readonly context: MessageContext;
-  private readonly mqttMessageParser: Parser;
+  private readonly messageParser: Parser;
+  private readonly logger: AnsiLogger;
 
-  constructor(context: MessageContext) {
+  constructor(context: MessageContext, logger: AnsiLogger) {
     this.context = context;
+    this.logger = logger;
 
-    this.mqttMessageParser = new Parser()
+    this.messageParser = new Parser()
       .endianess('big')
       .string('version', {
         length: 3,
@@ -42,22 +45,20 @@ export class MessageDeserializer {
       .uint32('crc32');
   }
 
-  deserialize(duid: string, message: Buffer<ArrayBufferLike>): ResponseMessage {
+  public deserialize(duid: string, message: Buffer<ArrayBufferLike>): ResponseMessage {
     const version = message.toString('latin1', 0, 3);
     if (version !== '1.0' && version !== 'A01') {
       throw new Error('unknown protocol version ' + version);
     }
 
     const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
-    const expectedCrc32 = message.readUint32BE(message.length - 4);
+    const expectedCrc32 = message.readUInt32BE(message.length - 4);
     if (crc32 != expectedCrc32) {
-      //throw new Error(`Wrong CRC32 ${crc32}, expected ${expectedCrc32}`);
-      //ignore the error for now
-      return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+      throw new Error(`Wrong CRC32 ${crc32}, expected ${expectedCrc32}`);
     }
     const localKey = this.context.getLocalKey(duid);
     assert(localKey, 'unable to retrieve local key for ' + duid);
-    const data: Message = this.mqttMessageParser.parse(message);
+    const data: Message = this.messageParser.parse(message);
 
     if (version == '1.0') {
       const aesKey = CryptoUtils.md5bin(MessageUtils.encodeTimestamp(data.timestamp) + localKey + MessageUtils.SALT);
@@ -77,7 +78,7 @@ export class MessageDeserializer {
     if (data.protocol == Protocol.rpc_response || data.protocol == Protocol.general_request) {
       return this.deserializeProtocolRpcResponse(duid, data);
     } else {
-      //throw new Error('unknown protocol: ' + data.protocol);
+      this.logger.error('unknown protocol: ' + data.protocol);
       return new ResponseMessage(duid, { dps: { id: 0, result: null } });
     }
   }

package/src/roborockCommunication/helper/messageSerializer.ts

@@ -4,14 +4,17 @@ import crypto from 'crypto';
 import CRC32 from 'crc-32';
 import { DpsPayload, Payload } from '../broadcast/model/dps.js';
 import { MessageContext } from '../broadcast/model/messageContext.js';
+import { AnsiLogger } from 'matterbridge/logger';
 
 export class MessageSerializer {
   private readonly context: MessageContext;
+  private readonly logger: AnsiLogger;
   private seq = 1;
   private random = 4711;
 
-  constructor(context: MessageContext) {
+  constructor(context: MessageContext, logger: AnsiLogger) {
     this.context = context;
+    this.logger = logger;
   }
 
   serialize(duid: string, request: RequestMessage): { messageId: number; buffer: Buffer<ArrayBufferLike> } {

package/src/share/function.ts

@@ -68,12 +68,6 @@ export function state_to_matter_operational_status(state: number | undefined): R
     case OperationStatusCode.ZoneCleanMopCleaning:
     case OperationStatusCode.ZoneCleanMopMopping:
     case OperationStatusCode.RobotStatusMopping:
-    case OperationStatusCode.WashingTheMop:
-    case OperationStatusCode.WashingTheMop2:
-    case OperationStatusCode.ReturnToDock:
-    case OperationStatusCode.GoingToWashTheMop:
-    case OperationStatusCode.BackToDockWashingDuster:
-    case OperationStatusCode.EmptyingDustContainer:
       return RvcOperationalState.OperationalState.Running;
 
     case OperationStatusCode.InError:
@@ -91,7 +85,13 @@ export function state_to_matter_operational_status(state: number | undefined): R
     case OperationStatusCode.Locked:
       return RvcOperationalState.OperationalState.Stopped;
 
+    case OperationStatusCode.ReturnToDock:
     case OperationStatusCode.ReturningDock:
+    case OperationStatusCode.WashingTheMop:
+    case OperationStatusCode.WashingTheMop2:
+    case OperationStatusCode.GoingToWashTheMop:
+    case OperationStatusCode.BackToDockWashingDuster:
+    case OperationStatusCode.EmptyingDustContainer:
       return RvcOperationalState.OperationalState.SeekingCharger;
 
     case OperationStatusCode.Idle:

package/dist/appliances.js

@@ -1,6 +0,0 @@
-import { MatterbridgeEndpoint, powerSource, } from "matterbridge";
-export class Appliances extends MatterbridgeEndpoint {
-    constructor(deviceType, name, serial) {
-        super([deviceType, powerSource], { uniqueStorageKey: `${name}-${serial}` }, true);
-    }
-}

package/src/appliances.ts

@@ -1,15 +0,0 @@
-import {
-  DeviceTypeDefinition,
-  MatterbridgeEndpoint,
-  powerSource,
-} from "matterbridge";
-
-export class Appliances extends MatterbridgeEndpoint {
-  constructor(deviceType: DeviceTypeDefinition, name: string, serial: string) {
-    super(
-      [deviceType, powerSource],
-      { uniqueStorageKey: `${name}-${serial}` },
-      true,
-    );
-  }
-}