matterbridge-roborock-vacuum-plugin 1.1.0-rc18 → 1.1.1-rc02

package/src/roborockCommunication/broadcast/model/messageContext.ts

@@ -1,34 +1,47 @@
-import { randomBytes } from 'node:crypto';
+import { randomBytes, randomInt } from 'node:crypto';
 import * as CryptoUtils from '../../helper/cryptoHelper.js';
 import { UserData } from '../../Zmodel/userData.js';
 
 export class MessageContext {
   private readonly endpoint: string;
-  readonly nonce: Buffer;
-  private readonly devices = new Map<string, { localKey: string; protocolVersion: string }>();
+  private readonly devices = new Map<string, { localKey: string; protocolVersion: string; nonce: number | undefined }>();
+  public readonly nonce: number;
+  public readonly serializeNonce: Buffer;
 
   constructor(userdata: UserData) {
     this.endpoint = CryptoUtils.md5bin(userdata.rriot.k).subarray(8, 14).toString('base64');
-    this.nonce = randomBytes(16);
+    this.nonce = randomInt(1000, 1000000);
+    this.serializeNonce = randomBytes(16);
   }
 
-  registerDevice(duid: string, localKey: string, pv: string) {
-    this.devices.set(duid, { localKey: localKey, protocolVersion: pv });
+  public registerDevice(duid: string, localKey: string, pv: string, nonce: number | undefined) {
+    this.devices.set(duid, { localKey: localKey, protocolVersion: pv, nonce });
   }
 
-  getNonceAsHex(): string {
-    return this.nonce.toString('hex').toUpperCase();
+  public updateNonce(duid: string, nonce: number): void {
+    const device = this.devices.get(duid);
+    if (device) {
+      device.nonce = nonce;
+    }
   }
 
-  getLocalKey(duid: string): string | undefined {
+  public getSerializeNonceAsHex(): string {
+    return this.serializeNonce.toString('hex').toUpperCase();
+  }
+
+  public getLocalKey(duid: string): string | undefined {
     return this.devices.get(duid)?.localKey;
   }
 
-  getProtocolVersion(duid: string): string | undefined {
+  public getProtocolVersion(duid: string): string | undefined {
     return this.devices.get(duid)?.protocolVersion;
   }
 
-  getEndpoint(): string {
+  public getDeviceNonce(duid: string): number | undefined {
+    return this.devices.get(duid)?.nonce;
+  }
+
+  public getEndpoint(): string {
     return this.endpoint;
   }
 }

package/src/roborockCommunication/broadcast/model/requestMessage.ts

@@ -7,14 +7,18 @@ export interface ProtocolRequest {
   method?: string | undefined;
   params?: unknown[] | Record<string, unknown> | undefined;
   secure?: boolean;
+  nonce?: number;
+  timestamp?: number;
 }
 
 export class RequestMessage {
-  readonly messageId: number;
-  readonly protocol: Protocol;
-  readonly method: string | undefined;
-  readonly params: unknown[] | Record<string, unknown> | undefined;
-  readonly secure: boolean;
+  public readonly messageId: number;
+  public readonly protocol: Protocol;
+  public readonly method: string | undefined;
+  public readonly params: unknown[] | Record<string, unknown> | undefined;
+  public readonly secure: boolean;
+  public readonly timestamp: number;
+  public readonly nonce: number;
 
   constructor(args: ProtocolRequest) {
     this.messageId = args.messageId ?? randomInt(10000, 32767);
@@ -22,6 +26,8 @@ export class RequestMessage {
     this.method = args.method;
     this.params = args.params;
     this.secure = args.secure ?? false;
+    this.nonce = args.nonce ?? randomInt(10000, 32767);
+    this.timestamp = args.timestamp ?? Math.floor(Date.now() / 1000);
   }
 
   toMqttRequest() {
@@ -36,6 +42,7 @@ export class RequestMessage {
         method: this.method,
         params: this.params,
         secure: this.secure,
+        timestamp: this.timestamp,
       });
     } else {
       return this;

package/src/roborockCommunication/helper/messageDeserializer.ts

@@ -1,26 +1,19 @@
 import crypto from 'node:crypto';
 import CRC32 from 'crc-32';
-import { Parser } from 'binary-parser';
 import { ResponseMessage } from '../broadcast/model/responseMessage.js';
 import * as CryptoUtils 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;
-  seq: number;
-  random: number;
-  timestamp: number;
-  protocol: number;
-  payloadLen?: number;
-  payload: Buffer<ArrayBufferLike>;
-  crc32: number;
-}
+import { Parser } from 'binary-parser/dist/binary_parser.js';
+import { ContentMessage } from '../broadcast/model/contentMessage.js';
+import { HeaderMessage } from '../broadcast/model/headerMessage.js';
+import { DpsPayload } from '../broadcast/model/dps.js';
 
 export class MessageDeserializer {
   private readonly context: MessageContext;
-  private readonly messageParser: Parser<Message>;
+  private readonly headerMessageParser: Parser;
+  private readonly contentMessageParser: Parser;
   private readonly logger: AnsiLogger;
   private readonly supportedVersions: string[] = ['1.0', 'A01', 'B01'];
 
@@ -28,15 +21,18 @@ export class MessageDeserializer {
     this.context = context;
     this.logger = logger;
 
-    this.messageParser = new Parser()
+    this.headerMessageParser = new Parser()
       .endianness('big')
       .string('version', {
         length: 3,
       })
       .uint32('seq')
-      .uint32('random')
+      .uint32('nonce')
       .uint32('timestamp')
-      .uint16('protocol')
+      .uint16('protocol');
+
+    this.contentMessageParser = new Parser()
+      .endianness('big')
       .uint16('payloadLen')
       .buffer('payload', {
         length: 'payloadLen',
@@ -45,53 +41,68 @@ export class MessageDeserializer {
   }
 
   public deserialize(duid: string, message: Buffer<ArrayBufferLike>): ResponseMessage {
-    const version = message.toString('latin1', 0, 3);
-    if (!this.supportedVersions.includes(version)) {
-      throw new Error('unknown protocol version ' + version);
+    // check message header
+    const header: HeaderMessage = this.headerMessageParser.parse(message);
+    if (!this.supportedVersions.includes(header.version)) {
+      throw new Error('unknown protocol version ' + header.version);
     }
 
+    if (header.protocol === Protocol.hello_response || header.protocol === Protocol.ping_response) {
+      const dpsValue: DpsPayload = {
+        id: header.seq,
+        result: {
+          version: header.version,
+          nonce: header.nonce,
+        },
+      };
+      return new ResponseMessage(duid, { [header.protocol.toString()]: dpsValue });
+    }
+
+    // parse message content
+    const data: ContentMessage = this.contentMessageParser.parse(message.subarray(this.headerMessageParser.sizeOf()));
+
+    // check crc32
     const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
     const expectedCrc32 = message.readUInt32BE(message.length - 4);
     if (crc32 != expectedCrc32) {
       throw new Error(`Wrong CRC32 ${crc32}, expected ${expectedCrc32}`);
     }
+
     const localKey = this.context.getLocalKey(duid);
     if (!localKey) {
       this.logger.notice(`Unable to retrieve local key for ${duid}, it should be from other vacuums`);
       return new ResponseMessage(duid, { dps: { id: 0, result: null } });
     }
 
-    const data: Message = this.messageParser.parse(message);
-
-    if (version == '1.0') {
-      const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(data.timestamp) + localKey + CryptoUtils.SALT);
+    if (header.version == '1.0') {
+      const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(header.timestamp) + localKey + CryptoUtils.SALT);
       const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
       data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
-    } else if (version == 'A01') {
-      const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+    } else if (header.version == 'A01') {
+      const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
       const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
       data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
-    } else if (version == 'B01') {
-      const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+    } else if (header.version == 'B01') {
+      const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
       const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
       // unpad ??
       data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
     }
 
     // map visualization not support
-    if (data.protocol == Protocol.map_response) {
+    if (header.protocol == Protocol.map_response) {
       return new ResponseMessage(duid, { dps: { id: 0, result: null } });
     }
 
-    if (data.protocol == Protocol.rpc_response || data.protocol == Protocol.general_request) {
+    if (header.protocol == Protocol.rpc_response || header.protocol == Protocol.general_request) {
       return this.deserializeRpcResponse(duid, data);
     } else {
-      this.logger.error('unknown protocol: ' + data.protocol);
+      this.logger.error('unknown protocol: ' + header.protocol);
       return new ResponseMessage(duid, { dps: { id: 0, result: null } });
     }
   }
 
-  private deserializeRpcResponse(duid: string, data: Message): ResponseMessage {
+  private deserializeRpcResponse(duid: string, data: ContentMessage): ResponseMessage {
     const payload = JSON.parse(data.payload.toString());
     const dps = payload.dps;
     this.parseJsonInDps(dps, Protocol.general_request);

package/src/roborockCommunication/helper/messageSerializer.ts

@@ -5,19 +5,20 @@ 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';
+import { Protocol } from '../broadcast/model/protocol.js';
 
 export class MessageSerializer {
   private readonly context: MessageContext;
   private readonly logger: AnsiLogger;
-  private seq = 1;
-  private random = 4711;
+  private sequence = 1;
+  private readonly supportedVersions: string[] = ['1.0', 'A01', 'B01'];
 
   constructor(context: MessageContext, logger: AnsiLogger) {
     this.context = context;
     this.logger = logger;
   }
 
-  serialize(duid: string, request: RequestMessage): { messageId: number; buffer: Buffer<ArrayBufferLike> } {
+  public serialize(duid: string, request: RequestMessage): { messageId: number; buffer: Buffer<ArrayBufferLike> } {
     const messageId = request.messageId;
     const buffer = this.buildBuffer(duid, messageId, request);
     return { messageId: messageId, buffer: buffer };
@@ -35,27 +36,31 @@ export class MessageSerializer {
     if (request.secure) {
       data.security = {
         endpoint: this.context.getEndpoint(),
-        nonce: this.context.getNonceAsHex(),
+        nonce: this.context.getSerializeNonceAsHex(),
       };
     }
-
-    const timestamp = Math.floor(Date.now() / 1000);
     return {
       dps: {
         [request.protocol]: JSON.stringify(data),
       },
-      t: timestamp,
+      t: request.timestamp,
     };
   }
 
   private buildBuffer(duid: string, messageId: number, request: RequestMessage): Buffer<ArrayBufferLike> {
     const version = this.context.getProtocolVersion(duid);
-    const localKey = this.context.getLocalKey(duid);
+    if (!version || !this.supportedVersions.includes(version)) {
+      throw new Error('unknown protocol version ' + version);
+    }
+    let encrypted;
+    if (request.protocol === Protocol.hello_response || request.protocol === Protocol.ping_response) {
+      encrypted = Buffer.alloc(0);
+    }
 
+    const localKey = this.context.getLocalKey(duid);
     const payloadData = this.buildPayload(messageId, request);
     const payload = JSON.stringify(payloadData);
 
-    let encrypted;
     if (version == '1.0') {
       const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(payloadData.t) + localKey + CryptoUtils.SALT);
       const cipher = crypto.createCipheriv('aes-128-ecb', aesKey, null);
@@ -63,12 +68,12 @@ export class MessageSerializer {
     } else if (version == 'A01') {
       // 726f626f726f636b2d67a6d6da is in version 4.0 of the roborock app
       const encoder = new TextEncoder();
-      const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+      const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
       const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
       encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
     } else if (version == 'B01') {
       const encoder = new TextEncoder();
-      const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+      const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
       const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
       // pad ??
       encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
@@ -78,9 +83,9 @@ export class MessageSerializer {
 
     const msg = Buffer.alloc(23 + encrypted.length);
     msg.write(version);
-    msg.writeUint32BE(this.seq++ & 0xffffffff, 3);
-    msg.writeUint32BE(this.random++ & 0xffffffff, 7);
-    msg.writeUint32BE(payloadData.t, 11);
+    msg.writeUint32BE(this.sequence++ & 0xffffffff, 3);
+    msg.writeUint32BE(request.nonce & 0xffffffff, 7);
+    msg.writeUint32BE(request.timestamp, 11);
     msg.writeUint16BE(request.protocol, 15);
     msg.writeUint16BE(encrypted.length, 17);
     encrypted.copy(msg, 19);

package/src/roborockService.ts

@@ -25,6 +25,7 @@ import type { AbstractMessageHandler, AbstractMessageListener, BatteryMessage, D
 import { ServiceArea } from 'matterbridge/matter/clusters';
 import { LocalNetworkClient } from './roborockCommunication/broadcast/client/LocalNetworkClient.js';
 import { RoomIndexMap } from './model/roomIndexMap.js';
+import { DpsPayload } from './roborockCommunication/broadcast/model/dps.js';
 export type Factory<A, T> = (logger: AnsiLogger, arg: A) => T;
 
 export default class RoborockService {
@@ -479,7 +480,7 @@ export default class RoborockService {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
     this.messageClient = this.clientManager.get(username, userdata);
-    this.messageClient.registerDevice(device.duid, device.localKey, device.pv);
+    this.messageClient.registerDevice(device.duid, device.localKey, device.pv, undefined);
 
     this.messageClient.registerMessageListener({
       onMessage: (message: ResponseMessage) => {
@@ -493,6 +494,12 @@ export default class RoborockService {
             self.deviceNotify(NotifyMessageTypes.CloudMessage, message);
           }
         }
+
+        if (message instanceof ResponseMessage && message.contain(Protocol.hello_response)) {
+          const dps = message.dps[Protocol.hello_response] as DpsPayload;
+          const result = dps.result as { nonce: number };
+          self.messageClient?.updateNonce(message.duid, result.nonce);
+        }
       },
     } as AbstractMessageListener);
 

package/src/runtimes/handleCloudMessage.ts

@@ -0,0 +1,134 @@
+import { getRunningMode } from '../initialData/getSupportedRunModes.js';
+import { CloudMessageModel } from '../model/CloudMessageModel.js';
+import { hasDockingStationError } from '../model/DockingStationStatus.js';
+import { RoborockMatterbridgePlatform } from '../platform.js';
+import { AdditionalPropCode, DeviceStatusNotify, Protocol } from '../roborockCommunication/index.js';
+import { state_to_matter_operational_status, state_to_matter_state } from '../share/function.js';
+import { RvcCleanMode, RvcOperationalState, RvcRunMode, ServiceArea } from 'matterbridge/matter/clusters';
+import { triggerDssError } from './handleLocalMessage.js';
+import { DpsPayload } from '../roborockCommunication/broadcast/model/dps.js';
+import { getRoomMapFromDevice, isStatusUpdate } from '../helper.js';
+import { debugStringify } from 'matterbridge/logger';
+import { CloudMessageResult } from '../roborockCommunication/Zmodel/messageResult.js';
+import { NotifyMessageTypes } from '../notifyMessageTypes.js';
+import { getCurrentCleanModeFunc } from '../share/runtimeHelper.js';
+import { getSupportedAreas } from '../initialData/getSupportedAreas.js';
+import { PlatformRunner } from '../platformRunner.js';
+import { RoborockVacuumCleaner } from '../rvc.js';
+
+export async function handleCloudMessage(data: CloudMessageModel, platform: RoborockMatterbridgePlatform, runner: PlatformRunner, duid: string): Promise<void> {
+  const messageTypes = Object.keys(data.dps).map(Number);
+  const robot = platform.robots.get(duid);
+  if (robot === undefined) {
+    platform.log.error(`Error3: Robot with DUID ${duid} not found`);
+    return;
+  }
+
+  // Known: 122, 121, 102,
+  // Unknown: 128, 139
+  messageTypes.forEach(async (messageType) => {
+    switch (messageType) {
+      case Protocol.status_update: {
+        const status = Number(data.dps[messageType]);
+        const matterState = state_to_matter_state(status);
+
+        if (matterState) {
+          robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(matterState), platform.log);
+        }
+
+        const operationalStateId = state_to_matter_operational_status(status);
+        if (operationalStateId) {
+          const dssHasError = hasDockingStationError(robot.dockStationStatus);
+          if (!(dssHasError && triggerDssError(robot, platform))) {
+            robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+          }
+        }
+        break;
+      }
+      case Protocol.rpc_response: {
+        const response = data.dps[messageType] as DpsPayload;
+        // ignore network info
+        if (!isStatusUpdate(response.result)) {
+          platform.log.debug('Ignore message:', debugStringify(data));
+          return;
+        }
+
+        let roboStatus: CloudMessageResult | undefined;
+        if (Array.isArray(response.result) && response.result.length > 0) {
+          roboStatus = response.result[0] as CloudMessageResult;
+        }
+
+        if (roboStatus) {
+          const message = { ...roboStatus } as DeviceStatusNotify;
+          platform.log.debug('rpc_response:', debugStringify(message));
+          await runner.updateFromMQTTMessage(NotifyMessageTypes.LocalMessage, message, duid, true);
+        }
+        break;
+      }
+      case Protocol.suction_power:
+      case Protocol.water_box_mode: {
+        await platform.roborockService?.getCleanModeData(duid).then((cleanModeData) => {
+          if (cleanModeData) {
+            const currentCleanMode = getCurrentCleanModeFunc(
+              robot.device.data.model,
+              platform.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false,
+            )({
+              suctionPower: cleanModeData.suctionPower,
+              waterFlow: cleanModeData.waterFlow,
+              distance_off: cleanModeData.distance_off,
+              mopRoute: cleanModeData.mopRoute,
+            });
+
+            platform.log.debug(`Clean mode data: ${debugStringify(cleanModeData)}`);
+            platform.log.debug(`Current clean mode: ${currentCleanMode}`);
+            if (currentCleanMode) {
+              robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
+            }
+          }
+        });
+        break; // Do nothing, handled in local message
+      }
+      case Protocol.additional_props: {
+        platform.log.notice(`Received additional properties for robot ${duid}: ${debugStringify(data)}`);
+        const propCode = data.dps[Protocol.additional_props] as number;
+        platform.log.debug(`DPS for additional properties: ${propCode}, AdditionalPropCode: ${AdditionalPropCode[propCode]}`);
+        if (propCode === AdditionalPropCode.map_change) {
+          await handleMapChange(robot, platform, duid);
+        }
+        break;
+      }
+      case Protocol.back_type: {
+        // TODO: check if this is needed
+        break;
+      }
+      default: {
+        platform.log.notice(`Unknown message type ${messageType}, protocol: ${Protocol[messageType]}, message: ${debugStringify(data)}`);
+        break;
+      }
+    }
+  });
+}
+
+export async function handleMapChange(robot: RoborockVacuumCleaner, platform: RoborockMatterbridgePlatform, duid: string): Promise<void> {
+  const enableMultipleMap = (platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature?.enableMultipleMap) ?? false;
+  if (!enableMultipleMap) return;
+
+  await getRoomMapFromDevice(robot.device, platform).then((roomMap) => {
+    const { supportedAreas, supportedMaps, roomIndexMap } = getSupportedAreas(robot.device.rooms, roomMap, enableMultipleMap, platform.log);
+
+    platform.log.debug(`handleMapChange - supportedAreas: ${debugStringify(supportedAreas)}`);
+    platform.log.debug(`handleMapChange - supportedMaps: ${debugStringify(supportedMaps)}`);
+    platform.log.debug(`handleMapChange - roomIndexMap: `, roomIndexMap);
+
+    platform.roborockService?.setSupportedAreas(duid, supportedAreas);
+    platform.roborockService?.setSelectedAreas(duid, []);
+    robot.updateAttribute(ServiceArea.Cluster.id, 'supportedAreas', supportedAreas, platform.log);
+    robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
+    robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+
+    if (enableMultipleMap) {
+      platform.roborockService?.setSupportedAreaIndexMap(duid, roomIndexMap);
+      robot.updateAttribute(ServiceArea.Cluster.id, 'supportedMaps', supportedMaps, platform.log);
+    }
+  });
+}

package/src/runtimes/handleHomeDataMessage.ts

@@ -0,0 +1,67 @@
+import { PowerSource, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+import { getVacuumProperty } from '../helper.js';
+import { RoborockMatterbridgePlatform } from '../platform.js';
+import { Device, Home } from '../roborockCommunication/index.js';
+import { debugStringify } from 'matterbridge/logger';
+import { getBatteryState, getBatteryStatus } from '../initialData/index.js';
+import { state_to_matter_operational_status, state_to_matter_state } from '../share/function.js';
+import { OperationStatusCode } from '../roborockCommunication/Zenum/operationStatusCode.js';
+import { getRunningMode } from '../initialData/getSupportedRunModes.js';
+import { hasDockingStationError } from '../model/DockingStationStatus.js';
+import { triggerDssError } from './handleLocalMessage.js';
+
+export async function updateFromHomeData(homeData: Home, platform: RoborockMatterbridgePlatform): Promise<void> {
+  if (platform.robots.size === 0) return;
+  const devices = homeData.devices.filter((d: Device) => platform.robots.has(d.duid));
+
+  for (const device of devices) {
+    const robot = platform.robots.get(device.duid);
+    if (robot === undefined) {
+      platform.log.error(`Error5: Robot with DUID ${device.duid} not found`);
+      continue;
+    }
+
+    const deviceData = robot.device.data;
+    if (!device || deviceData === undefined) {
+      platform.log.error('Device not found in home data');
+      return;
+    }
+
+    device.schema = homeData.products.find((prd) => prd.id === device.productId || prd.model === device.data.model)?.schema ?? [];
+    platform.log.debug('updateFromHomeData-homeData:', debugStringify(homeData));
+    platform.log.debug('updateFromHomeData-device:', debugStringify(device));
+    platform.log.debug('updateFromHomeData-schema:' + debugStringify(device.schema));
+    platform.log.debug('updateFromHomeData-battery:' + debugStringify(device.deviceStatus));
+
+    const batteryLevel = getVacuumProperty(device, 'battery');
+    if (batteryLevel) {
+      robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel ? batteryLevel * 2 : 200, platform.log);
+      robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
+    }
+
+    const state = getVacuumProperty(device, 'state');
+    const matterState = state_to_matter_state(state);
+    if (!state || !matterState) {
+      return;
+    }
+    platform.log.debug(`updateFromHomeData-RvcRunMode code: ${state} name: ${OperationStatusCode[state]}, matterState: ${RvcRunMode.ModeTag[matterState]}`);
+
+    if (matterState) {
+      robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(matterState), platform.log);
+    }
+    if (batteryLevel) {
+      robot.updateAttribute(PowerSource.Cluster.id, 'batChargeState', getBatteryState(state, batteryLevel), platform.log);
+    }
+
+    const operationalStateId = state_to_matter_operational_status(state);
+
+    if (operationalStateId) {
+      const dssHasError = hasDockingStationError(robot.dockStationStatus);
+      platform.log.debug(`dssHasError: ${dssHasError}, dockStationStatus: ${debugStringify(robot.dockStationStatus ?? {})}`);
+      if (!(dssHasError && triggerDssError(robot, platform))) {
+        platform.log.debug(`updateFromHomeData-OperationalState: ${RvcOperationalState.OperationalState[operationalStateId]}`);
+        robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+      }
+    }
+  }
+}