matterbridge-roborock-vacuum-plugin 1.1.0-rc13 → 1.1.0-rc15

package/README.md

@@ -69,7 +69,7 @@ To get the **DUID** for your devices, you have two options:
 ### 🚧 Project Status
 
 - **Under active development**
-- Requires **`matterbridge@3.1.3`**
+- Requires **`matterbridge@3.1.7`**
 - ⚠️ **Known Issue:** 
 + Vacuum may appear as **two devices** in Apple Home
 + Error: Wrong CRC32 2241274590, expected 0 -> this is normal error and not impact to plugin functionality

package/dist/helper.js

@@ -1,3 +1,5 @@
+import { debugStringify } from 'matterbridge/logger';
+import { RoomMap } from './model/RoomMap.js';
 export function getVacuumProperty(device, property) {
     if (device) {
         const schemas = device.schema;
@@ -14,3 +16,63 @@ export function getVacuumProperty(device, property) {
 export function isSupportedDevice(model) {
     return model.startsWith('roborock.vacuum.');
 }
+export function isStatusUpdate(result) {
+    return (Array.isArray(result) &&
+        result.length > 0 &&
+        typeof result[0] === 'object' &&
+        result[0] !== null &&
+        'msg_ver' in result[0] &&
+        result[0].msg_ver !== undefined &&
+        result[0].msg_ver !== null);
+}
+export async function getRoomMap(duid, platform) {
+    const robot = platform.robots.get(duid);
+    if (robot === undefined) {
+        platform.log.error(`Error6: Robot with DUID ${duid} not found`);
+        return undefined;
+    }
+    if (platform.roborockService === undefined)
+        return undefined;
+    const rooms = robot.device.rooms ?? [];
+    if (robot.roomInfo === undefined) {
+        const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
+        if (roomData !== undefined && roomData.length > 0) {
+            robot.roomInfo = new RoomMap(roomData ?? [], rooms);
+            return robot.roomInfo;
+        }
+    }
+    if (robot.roomInfo === undefined) {
+        const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
+        if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
+            platform.log.error(`getRoomMap - mapInfo: ${debugStringify(mapInfo.maps)}`);
+            const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
+            robot.roomInfo = new RoomMap(roomDataMap, rooms);
+        }
+    }
+    return robot.roomInfo;
+}
+export async function getRoomMapFromDevice(device, platform) {
+    const rooms = device?.rooms ?? [];
+    platform.log.notice('-------------------------------------------0--------------------------------------------------------');
+    platform.log.notice(`getRoomMapFromDevice: ${debugStringify(rooms)}`);
+    if (device && platform.roborockService) {
+        const roomData = await platform.roborockService.getRoomMappings(device.duid);
+        if (roomData !== undefined && roomData.length > 0) {
+            platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
+            const roomMap = new RoomMap(roomData ?? [], rooms);
+            platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+            platform.log.notice('-------------------------------------------1--------------------------------------------------------');
+            return roomMap;
+        }
+        const mapInfo = await platform.roborockService.getMapInformation(device.duid);
+        platform.log.notice(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
+        if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
+            const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
+            const roomMap = new RoomMap(roomDataMap, rooms);
+            platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+            platform.log.notice('-------------------------------------------2--------------------------------------------------------');
+            return roomMap;
+        }
+    }
+    return new RoomMap([], rooms);
+}

package/dist/model/RoomMap.js

@@ -1,4 +1,4 @@
-export default class RoomMap {
+export class RoomMap {
     rooms = [];
     constructor(roomData, rooms) {
         this.rooms = roomData.map((entry) => {

package/dist/platform.js

@@ -4,7 +4,7 @@ import { debugStringify } from 'matterbridge/logger';
 import RoborockService from './roborockService.js';
 import { PLUGIN_NAME } from './settings.js';
 import ClientManager from './clientManager.js';
-import { isSupportedDevice } from './helper.js';
+import { getRoomMapFromDevice, isSupportedDevice } from './helper.js';
 import { PlatformRunner } from './platformRunner.js';
 import { RoborockVacuumCleaner } from './rvc.js';
 import { configurateBehavior } from './behaviorFactory.js';
@@ -26,8 +26,8 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     rrHomeId;
     constructor(matterbridge, log, config) {
         super(matterbridge, log, config);
-        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.1.6')) {
-            throw new Error(`This plugin requires Matterbridge version >= "3.1.6". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`);
+        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.1.7')) {
+            throw new Error(`This plugin requires Matterbridge version >= "3.1.7". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`);
         }
         this.log.info('Initializing platform:', this.config.name);
         if (config.whiteList === undefined)
@@ -162,7 +162,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             const rooms = map_info?.maps?.[0]?.rooms ?? [];
             vacuum.rooms = rooms.map((room) => ({ id: room.id, name: room.displayName }));
         }
-        const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
+        const roomMap = await getRoomMapFromDevice(vacuum, this);
         this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));
         const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, this.cleanModeSettings, this.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false, this.log);
         const supportedAreas = getSupportedAreas(vacuum.rooms, roomMap, this.log);

package/dist/platformRunner.js

@@ -1,8 +1,7 @@
 import { RvcRunMode, PowerSource, ServiceArea, RvcOperationalState, RvcCleanMode } from 'matterbridge/matter/clusters';
-import { getVacuumProperty } from './helper.js';
+import { getRoomMap, getVacuumProperty, isStatusUpdate } from './helper.js';
 import { getRunningMode } from './initialData/getSupportedRunModes.js';
 import { state_to_matter_operational_status, state_to_matter_state } from './share/function.js';
-import RoomMap from './model/RoomMap.js';
 import { getBatteryState, getBatteryStatus, getOperationalErrorState } from './initialData/index.js';
 import { NotifyMessageTypes } from './notifyMessageTypes.js';
 import { Protocol } from './roborockCommunication/broadcast/model/protocol.js';
@@ -32,59 +31,6 @@ export class PlatformRunner {
         const homeData = await platform.roborockService.getHomeDataForUpdating(platform.rrHomeId);
         await this.updateRobot(NotifyMessageTypes.HomeData, homeData);
     }
-    async getRoomMapFromDevice(device) {
-        const platform = this.platform;
-        const rooms = device?.rooms ?? [];
-        platform.log.notice('-------------------------------------------0--------------------------------------------------------');
-        platform.log.notice(`getRoomMapFromDevice: ${debugStringify(rooms)}`);
-        if (device && platform.roborockService) {
-            const roomData = await platform.roborockService.getRoomMappings(device.duid);
-            if (roomData !== undefined && roomData.length > 0) {
-                platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
-                const roomMap = new RoomMap(roomData ?? [], rooms);
-                platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
-                platform.log.notice('-------------------------------------------1--------------------------------------------------------');
-                return roomMap;
-            }
-            const mapInfo = await platform.roborockService.getMapInformation(device.duid);
-            platform.log.notice(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
-            if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
-                const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
-                const roomMap = new RoomMap(roomDataMap, rooms);
-                platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
-                platform.log.notice('-------------------------------------------2--------------------------------------------------------');
-                return roomMap;
-            }
-        }
-        return new RoomMap([], rooms);
-    }
-    async getRoomMap(duid) {
-        const platform = this.platform;
-        const robot = platform.robots.get(duid);
-        if (robot === undefined) {
-            platform.log.error(`Error6: Robot with DUID ${duid} not found`);
-            return undefined;
-        }
-        if (platform.roborockService === undefined)
-            return undefined;
-        const rooms = robot.device.rooms ?? [];
-        if (robot.roomInfo === undefined) {
-            const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
-            if (roomData !== undefined && roomData.length > 0) {
-                robot.roomInfo = new RoomMap(roomData ?? [], rooms);
-                return robot.roomInfo;
-            }
-        }
-        if (robot.roomInfo === undefined) {
-            const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
-            if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
-                platform.log.error(`getRoomMap - mapInfo: ${debugStringify(mapInfo.maps)}`);
-                const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
-                robot.roomInfo = new RoomMap(roomDataMap, rooms);
-            }
-        }
-        return robot.roomInfo;
-    }
     async updateFromMQTTMessage(messageSource, messageData, duid = '', tracked = false) {
         const platform = this.platform;
         duid = duid || messageData?.duid || '';
@@ -146,7 +92,7 @@ export class PlatformRunner {
                     }
                     else {
                         const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-                        const roomMap = await this.getRoomMap(duid);
+                        const roomMap = await getRoomMap(duid, this.platform);
                         const segment_id = data.cleaning_info?.segment_id ?? -1;
                         const target_segment_id = data.cleaning_info?.target_segment_id ?? -1;
                         let target_room_id = roomMap?.rooms.find((x) => x.id === segment_id || x.alternativeId === segment_id.toString())?.id ?? -1;
@@ -237,7 +183,7 @@ export class PlatformRunner {
                 }
                 case Protocol.rpc_response: {
                     const response = data.dps[messageType];
-                    if (!self.isStatusUpdate(response.result)) {
+                    if (!isStatusUpdate(response.result)) {
                         platform.log.debug('Ignore message:', debugStringify(data));
                         return;
                     }
@@ -309,15 +255,6 @@ export class PlatformRunner {
         }
         return undefined;
     }
-    isStatusUpdate(result) {
-        return (Array.isArray(result) &&
-            result.length > 0 &&
-            typeof result[0] === 'object' &&
-            result[0] !== null &&
-            'msg_ver' in result[0] &&
-            result[0].msg_ver !== undefined &&
-            result[0].msg_ver !== null);
-    }
     updateFromHomeData(homeData) {
         const platform = this.platform;
         if (platform.robots.size === 0)

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

@@ -13,6 +13,7 @@ export class LocalNetworkClient extends AbstractClient {
     buffer = new ChunkBuffer();
     messageIdSeq;
     pingInterval;
+    keepConnectionAliveInterval = undefined;
     duid;
     ip;
     constructor(logger, context, duid, ip) {
@@ -34,6 +35,7 @@ export class LocalNetworkClient extends AbstractClient {
         this.socket.on('timeout', this.onTimeout.bind(this));
         this.socket.on('data', this.onMessage.bind(this));
         this.socket.connect(58867, this.ip);
+        this.keepConnectionAlive();
     }
     async disconnect() {
         if (!this.socket) {
@@ -57,29 +59,16 @@ export class LocalNetworkClient extends AbstractClient {
         this.socket.write(this.wrapWithLengthData(message.buffer));
     }
     async onConnect() {
-        this.logger.debug(`LocalNetworkClient: ${this.duid} connected to ${this.ip}`);
-        this.logger.debug(`LocalNetworkClient: ${this.duid} socket writable: ${this.socket?.writable}, readable: ${this.socket?.readable}`);
+        this.logger.debug(` [LocalNetworkClient]: ${this.duid} connected to ${this.ip}`);
+        this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket writable: ${this.socket?.writable}, readable: ${this.socket?.readable}`);
         this.connected = true;
         this.retryCount = 0;
         await this.sendHelloMessage();
         this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
         await this.connectionListeners.onConnected(this.duid);
     }
-    async onEnd() {
-        await this.destroySocket('Socket has ended.');
-        await this.connectionListeners.onDisconnected(this.duid, 'Socket has ended.');
-    }
     async onDisconnect(hadError) {
-        await this.destroySocket(`Socket disconnected. Had error: ${hadError}`);
-        if (!hadError) {
-            await this.connectionListeners.onDisconnected(this.duid, 'Socket disconnected. Had no error.');
-        }
-    }
-    async onTimeout() {
-        this.logger.error(`LocalNetworkClient: Socket for ${this.duid} timed out.`);
-    }
-    async destroySocket(message) {
-        this.logger.error(`LocalNetworkClient: Destroying socket for ${this.duid} due to: ${message}`);
+        this.logger.info(` [LocalNetworkClient]: ${this.duid} socket disconnected. Had error: ${hadError}`);
         this.connected = false;
         if (this.socket) {
             this.socket.destroy();
@@ -88,19 +77,18 @@ export class LocalNetworkClient extends AbstractClient {
         if (this.pingInterval) {
             clearInterval(this.pingInterval);
         }
+        await this.connectionListeners.onDisconnected(this.duid, 'Socket disconnected. Had no error.');
     }
     async onError(error) {
-        this.logger.error('LocalNetworkClient: Socket connection error: ' + error.message);
-        this.connected = false;
-        if (this.socket) {
-            this.socket.destroy();
-            this.socket = undefined;
-        }
-        if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-        }
+        this.logger.error(` [LocalNetworkClient]: Socket error for ${this.duid}: ${error.message}`);
         await this.connectionListeners.onError(this.duid, error.message);
     }
+    async onTimeout() {
+        this.logger.error(` [LocalNetworkClient]: Socket for ${this.duid} timed out.`);
+    }
+    async onEnd() {
+        this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket ended.`);
+    }
     async onMessage(message) {
         if (!this.socket) {
             return;
@@ -170,4 +158,16 @@ export class LocalNetworkClient extends AbstractClient {
         });
         await this.send(this.duid, request);
     }
+    keepConnectionAlive() {
+        if (this.keepConnectionAliveInterval) {
+            clearTimeout(this.keepConnectionAliveInterval);
+            this.keepConnectionAliveInterval.unref();
+        }
+        this.keepConnectionAliveInterval = setInterval(() => {
+            if (this.socket === undefined || !this.connected || !this.socket.writable || this.socket.readable) {
+                this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket is not writable or readable, reconnecting...`);
+                this.connect();
+            }
+        }, 60 * 60 * 1000);
+    }
 }

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

@@ -26,8 +26,7 @@ export class MQTTClient extends AbstractClient {
             username: this.mqttUsername,
             password: this.mqttPassword,
             keepalive: 30,
-            log: (...args) => {
-                this.logger.debug(`MQTTClient args: ${debugStringify(args)}`);
+            log: () => {
             },
         });
         this.mqttClient.on('connect', this.onConnect.bind(this));

package/dist/roborockCommunication/broadcast/clientRouter.js

@@ -7,9 +7,9 @@ export class ClientRouter {
     connectionListeners = new ChainedConnectionListener();
     messageListeners = new ChainedMessageListener();
     context;
-    mqttClient;
     localClients = new Map();
     logger;
+    mqttClient;
     constructor(logger, userdata) {
         this.context = new MessageContext(userdata);
         this.logger = logger;

package/dist/roborockCommunication/broadcast/listener/implementation/connectionStateListener.js

@@ -31,10 +31,10 @@ export class ConnectionStateListener {
             this.logger.info(`Device with DUID ${duid} is in disconnecting step, skipping re-registration.`);
             return;
         }
-        this.logger.info(`Re-registering device with DUID ${duid} to ${this.clientName}`);
         setTimeout(() => {
+            this.logger.info(`Re-registering device with DUID ${duid} to ${this.clientName}`);
             this.client.connect();
-        }, 3000);
+        }, 10000);
         this.client.isInDisconnectingStep = false;
     }
     async onError(duid, message) {

package/dist/roborockCommunication/broadcast/listener/implementation/syncMessageListener.js

@@ -18,10 +18,6 @@ export class SyncMessageListener {
             const dps = message.get(Protocol.rpc_response);
             const messageId = dps.id;
             const responseHandler = this.pending.get(messageId);
-            const result = dps.result;
-            if (result && result.length == 1 && result[0] == 'ok') {
-                return;
-            }
             if (responseHandler) {
                 responseHandler(dps.result);
             }

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -31,6 +31,15 @@ export class MessageProcessor {
         }
         return undefined;
     }
+    async getDeviceStatusOverMQTT(duid) {
+        const request = new RequestMessage({ method: 'get_status', secure: true });
+        const response = await this.client.get(duid, request);
+        if (response) {
+            this.logger?.debug('MQTT - Device status: ', debugStringify(response));
+            return new DeviceStatus(response);
+        }
+        return undefined;
+    }
     async getRooms(duid, rooms) {
         const request = new RequestMessage({ method: 'get_room_mapping' });
         return this.client.get(duid, request).then((response) => new RoomInfo(rooms, response ?? []));
@@ -71,7 +80,7 @@ export class MessageProcessor {
     }
     async findMyRobot(duid) {
         const request = new RequestMessage({ method: 'find_me' });
-        return this.client.send(duid, request);
+        return this.client.get(duid, request);
     }
     async getCleanModeData(duid) {
         const currentMopMode = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_mop_mode' }));

package/dist/roborockCommunication/broadcast/model/protocol.js

@@ -13,7 +13,16 @@ export var Protocol;
     Protocol[Protocol["battery"] = 122] = "battery";
     Protocol[Protocol["suction_power"] = 123] = "suction_power";
     Protocol[Protocol["water_box_mode"] = 124] = "water_box_mode";
+    Protocol[Protocol["main_brush_work_time"] = 125] = "main_brush_work_time";
+    Protocol[Protocol["side_brush_work_time"] = 126] = "side_brush_work_time";
+    Protocol[Protocol["filter_work_time"] = 127] = "filter_work_time";
     Protocol[Protocol["additional_props"] = 128] = "additional_props";
+    Protocol[Protocol["task_complete"] = 130] = "task_complete";
+    Protocol[Protocol["task_cancel_low_power"] = 131] = "task_cancel_low_power";
+    Protocol[Protocol["task_cancel_in_motion"] = 132] = "task_cancel_in_motion";
+    Protocol[Protocol["charge_status"] = 133] = "charge_status";
+    Protocol[Protocol["drying_status"] = 134] = "drying_status";
     Protocol[Protocol["back_type"] = 139] = "back_type";
     Protocol[Protocol["map_response"] = 301] = "map_response";
+    Protocol[Protocol["some_thing_happened_when_socket_closed"] = 500] = "some_thing_happened_when_socket_closed";
 })(Protocol || (Protocol = {}));

package/dist/roborockService.js

@@ -201,7 +201,7 @@ export default class RoborockService {
                 await messageProcessor.getDeviceStatus(device.duid).then((response) => {
                     if (self.deviceNotify && response) {
                         const message = { duid: device.duid, ...response.errorStatus, ...response.message };
-                        self.logger.debug('Device status update', debugStringify(message));
+                        self.logger.debug('Socket - Device status update', debugStringify(message));
                         self.deviceNotify(NotifyMessageTypes.LocalMessage, message);
                     }
                 });
@@ -211,6 +211,25 @@ export default class RoborockService {
             }
         }, this.refreshInterval * 1000);
     }
+    activateDeviceNotifyOverMQTT(device) {
+        const self = this;
+        this.logger.notice('Requesting device info for device over MQTT', device.duid);
+        const messageProcessor = this.getMessageProcessor(device.duid);
+        this.requestDeviceStatusInterval = setInterval(async () => {
+            if (messageProcessor) {
+                await messageProcessor.getDeviceStatusOverMQTT(device.duid).then((response) => {
+                    if (self.deviceNotify && response) {
+                        const message = { duid: device.duid, ...response.errorStatus, ...response.message };
+                        self.logger.debug('MQTT - Device status update', debugStringify(message));
+                        self.deviceNotify(NotifyMessageTypes.LocalMessage, message);
+                    }
+                });
+            }
+            else {
+                self.logger.error('Local client not initialized');
+            }
+        }, this.refreshInterval * 500);
+    }
     async listDevices(username) {
         assert(this.iotApi !== undefined);
         assert(this.userdata !== undefined);

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

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.1.0-rc13",
+  "version": "1.1.0-rc15",
   "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.1.0-rc13 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc15 by https://github.com/RinDevJunior",
   "type": "object",
   "required": ["username", "password"],
   "properties": {

package/misc/status.md

@@ -0,0 +1,119 @@
+# Status Message
+
+### Response
+
+| Key                         | Example  | Description                                                                                                                                         | Only available for |
+| --------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
+| `battery`                   | _100_    | Battery level (in %)                                                                                                                                |                    |
+| `clean_area`                | _140000_ | Total area (in cm²)                                                                                                                                 |                    |
+| `clean_time`                | _15_     | Total cleaning time (in s)                                                                                                                          |                    |
+| `dnd_enabled`               | _0_      | Is 'Do Not Disturb' enabled (0=disabled, 1=enabled)                                                                                                 |                    |
+| `error_code`                | _0_      | Error code (see [list](#error-codes) below)                                                                                                         |                    |
+| `fan_power`                 | _102_    | Fan power, corresponds to the values in [Custom Mode](../README_CLEANMODE.md)                                                                       |                    |
+| `in_cleaning`               | _0_      | Is device cleaning                                                                                                                                  |                    |
+| `in_fresh_state`            | _1_      | ?                                                                                                                                                   |                    |
+| `in_returning`              | _0_      | Is returning to dock (0=no, 1=yes)                                                                                                                  |                    |
+| `is_locating`               | _0_      | ?                                                                                                                                                   |                    |
+| `lab_status`                | _1_      | ?                                                                                                                                                   |                    |
+| `lock_status`               | _0_      | ?                                                                                                                                                   |                    |
+| `map_present`               | _1_      | Is map present                                                                                                                                      |                    |
+| `map_status`                | _3_      | ?                                                                                                                                                   |                    |
+| `mop_forbidden_enable`      | _0_      | ?                                                                                                                                                   |                    |
+| `msg_seq`                   | _52_     | Message sequence increments with each request                                                                                                       |                    |
+| `msg_ver`                   | _2_      | Message version (seems always 4 and 2 for s6) see below for other examples                                                                          |                    |
+| `state`                     | _8_      | Status code (see [list](#status-codes) below)                                                                                                       |                    |
+| `water_box_carriage_status` | _0_      | Is carriage mounted (0=no, 1=yes)                                                                                                                   |                    |
+| `water_box_mode`            | _204_    | Water quantity control,                                                                                                                             |                    |
+| `water_box_status`          | _1_      | Is water tank mounted (0=no, 1=yes)                                                                                                                 |                    |
+
+#### Example
+
+```json
+{
+    "result": [{
+            "msg_ver": 2,
+            "msg_seq": 52,
+            "state": 8,
+            "battery": 100,
+            "clean_time": 15,
+            "clean_area": 140000,
+            "error_code": 0,
+            "map_present": 1,
+            "in_cleaning": 0,
+            "in_returning": 0,
+            "in_fresh_state": 1,
+            "lab_status": 1,
+            "water_box_status": 1,
+            "fan_power": 102,
+            "dnd_enabled": 0,
+            "map_status": 3,
+            "is_locating": 0,
+            "lock_status": 0,
+            "water_box_mode": 204,
+            "water_box_carriage_status": 0,
+            "mop_forbidden_enable": 0
+        }
+    ],
+    "id": 96
+}
+```
+
+## Codes
+
+### Status Codes
+
+| Code | Description    |
+| ---- | -------------- |
+| 0    | Unknown        |
+| 1    | Initiating     |
+| 2    | Sleeping       |
+| 3    | Idle           |
+| 4    | Remote Control |
+| 5    | Cleaning       |
+| 6    | Returning Dock |
+| 7    | Manual Mode    |
+| 8    | Charging       |
+| 9    | Charging Error |
+| 10   | Paused         |
+| 11   | Spot Cleaning  |
+| 12   | In Error       |
+| 13   | Shutting Down  |
+| 14   | Updating       |
+| 15   | Docking        |
+| 16   | Go To          |
+| 17   | Zone Clean     |
+| 18   | Room Clean     |
+| 100  | Fully Charged  |
+
+### Error Codes
+
+| Code | Description                           |
+| ---- | ------------------------------------- |
+| 0    | No error                              |
+| 1    | Laser sensor fault                    |
+| 2    | Collision sensor fault                |
+| 3    | Wheel floating                        |
+| 4    | Cliff sensor fault                    |
+| 5    | Main brush blocked                    |
+| 6    | Side brush blocked                    |
+| 7    | Wheel blocked                         |
+| 8    | Device stuck                          |
+| 9    | Dust bin missing                      |
+| 10   | Filter blocked                        |
+| 11   | Magnetic field detected               |
+| 12   | Low battery                           |
+| 13   | Charging problem                      |
+| 14   | Battery failure                       |
+| 15   | Wall sensor fault                     |
+| 16   | Uneven surface                        |
+| 17   | Side brush failure                    |
+| 18   | Suction fan failure                   |
+| 19   | Unpowered charging station            |
+| 20   | Unknown Error                         |
+| 21   | Laser pressure sensor problem         |
+| 22   | Charge sensor problem                 |
+| 23   | Dock problem                          |
+| 24   | No-go zone or invisible wall detected |
+| 254  | Bin full                              |
+| 255  | Internal error                        |
+| -1   | Unknown Error                         |

package/package.json

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