matterbridge-roborock-vacuum-plugin 1.0.5

package/prettier.config.js

@@ -0,0 +1,49 @@
+// @ts-check
+/*
+
+prettier.config.js
+
+Prettier:
+
+How to install:
+  npm install --save-dev prettier eslint-config-prettier eslint-plugin-prettier
+
+  
+Add package.json scripts:  
+*/
+// "format": "prettier --write \"src/**/*.{js,jsx,ts,tsx,json,css,md}\"",
+// "format:check": "prettier --check \"src/**/*.{js,jsx,ts,tsx,json,css,md}\"",
+
+/* 
+
+Add .prettierignore  
+
+# Ignore artifacts:
+dist
+node_modules
+build
+coverage
+
+# Ignore all HTML files:
+*/
+// **/*.html
+
+export default {
+    printWidth: 180, // default 80
+    tabWidth: 2,
+    useTabs: false,
+    semi: true,
+    singleQuote: true, // default false
+    quoteProps: 'preserve', // default 'as-needed'
+    jsxSingleQuote: false,
+    trailingComma: 'all',
+    bracketSpacing: true,
+    bracketSameLine: false,
+    arrowParens: 'always',
+    requirePragma: false,
+    insertPragma: false,
+    proseWrap: 'preserve',
+    endOfLine: 'lf',
+    embeddedLanguageFormatting: 'off', // default 'auto'
+    singleAttributePerLine: false,
+};

package/src/appliances.ts

@@ -0,0 +1,15 @@
+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,
+    );
+  }
+}

package/src/behaviorFactory.ts

@@ -0,0 +1,24 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import { BehaviorDeviceGeneric } from './behaviors/BehaviorDeviceGeneric.js';
+import { EndpointCommandsA187, setCommandHandlerA187 } from './behaviors/roborock.vacuum/QREVO_EDGE_5V1/a187.js';
+import RoborockService from './roborockService.js';
+import { DefaultEndpointCommands, setDefaultCommandHandler } from './behaviors/roborock.vacuum/default/default.js';
+import { DeviceModel } from './roborockCommunication/Zmodel/deviceModel.js';
+
+export type BehaviorFactoryResult = BehaviorDeviceGeneric<DefaultEndpointCommands> | BehaviorDeviceGeneric<EndpointCommandsA187>;
+
+export function configurateBehavior(model: string, duid: string, roborockService: RoborockService, logger: AnsiLogger): BehaviorFactoryResult {
+  switch (model) {
+    case DeviceModel.QREVO_EDGE_5V1: {
+      const deviceHandler = new BehaviorDeviceGeneric<EndpointCommandsA187>(logger);
+      setCommandHandlerA187(duid, deviceHandler, logger, roborockService);
+      return deviceHandler;
+    }
+
+    default: {
+      const deviceHandler = new BehaviorDeviceGeneric<DefaultEndpointCommands>(logger);
+      setDefaultCommandHandler(duid, deviceHandler, logger, roborockService);
+      return deviceHandler;
+    }
+  }
+}

package/src/behaviors/BehaviorDeviceGeneric.ts

@@ -0,0 +1,39 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import { Behavior, MaybePromise } from 'matterbridge/matter';
+
+export type DeviceCommandHandler = (...args: any[]) => MaybePromise;
+
+export interface DeviceCommands {
+  [command: string]: DeviceCommandHandler;
+}
+
+export class BehaviorDeviceGeneric<Commands extends DeviceCommands> {
+  readonly commands: Partial<Commands> = {};
+  constructor(readonly log: AnsiLogger) {}
+
+  setCommandHandler<Command extends keyof Commands>(command: Command, handler: Commands[Command]): void {
+    if (this.commands[command]) throw new Error(`Handler already registered for command ${String(command)}`);
+    this.commands[command] = handler;
+  }
+
+  async executeCommand<Command extends keyof Commands>(command: Command, ...args: Parameters<Commands[Command]>): Promise<void> {
+    const handler = this.commands[command];
+    if (!handler) throw new Error(`${String(command)} not implemented`);
+    await (handler as DeviceCommandHandler)(...args);
+  }
+}
+
+export class BehaviorGeneric<StateType extends {}> extends Behavior {
+  static override readonly id: string;
+  declare state: StateType;
+}
+
+export class BehaviorRoborock extends Behavior {
+  static override readonly id = 'roborock.vacuum.axx';
+  declare state: BehaviorRoborock.State;
+}
+export namespace BehaviorRoborock {
+  export class State {
+    device!: BehaviorDeviceGeneric<DeviceCommands>;
+  }
+}

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

@@ -0,0 +1,117 @@
+import { MaybePromise } from 'matterbridge/matter';
+import { AnsiLogger } from 'matterbridge/logger';
+import { BehaviorDeviceGeneric, BehaviorRoborock, DeviceCommands } from '../../BehaviorDeviceGeneric.js';
+import RoborockService from '../../../roborockService.js';
+
+export interface EndpointCommandsA187 extends DeviceCommands {
+  selectAreas: (newAreas: any) => MaybePromise;
+  changeToMode: (newMode: number) => MaybePromise;
+  pause: () => MaybePromise;
+  resume: () => MaybePromise;
+  goHome: () => MaybePromise;
+  PlaySoundToLocate: (identifyTime: number) => MaybePromise;
+}
+
+export class BehaviorA187 extends BehaviorRoborock {
+  declare state: BehaviorRoborockA187.State;
+}
+
+export namespace BehaviorRoborockA187 {
+  export class State {
+    device!: BehaviorDeviceGeneric<EndpointCommandsA187>;
+  }
+}
+
+//suction_power
+export enum VacuumSuctionPowerA187 {
+  Quiet = 101,
+  Balanced = 102,
+  Turbo = 103,
+  Max = 104,
+  Off = 105,
+  Custom = 106,
+  MaxPlus = 108,
+  Smart = 110,
+}
+
+//water_box_mode
+export enum MopWaterFlowA187 {
+  Off = 200,
+  Low = 201,
+  Medium = 202,
+  High = 203,
+  Custom = 204,
+  Smart = 209,
+}
+
+const RvcRunMode: Record<number, string> = {
+  [1]: 'Idle', //DO NOT HANDLE HERE,
+  [2]: 'Cleaning',
+  [3]: 'Mapping',
+};
+const RvcCleanMode: Record<number, string> = {
+  [4]: 'Smart Plan',
+  [5]: 'Mop',
+  [6]: 'Vacuum',
+  [7]: 'Vac & Mop',
+  [8]: 'Custom',
+};
+
+const CleanSetting: Record<number, { suctionPower: VacuumSuctionPowerA187; waterFlow: MopWaterFlowA187 }> = {
+  [4]: { suctionPower: VacuumSuctionPowerA187.Smart, waterFlow: MopWaterFlowA187.Smart },
+  [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium },
+  [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off },
+  [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium },
+  [8]: { suctionPower: VacuumSuctionPowerA187.Custom, waterFlow: MopWaterFlowA187.Custom },
+};
+
+export function setCommandHandlerA187(duid: string, handler: BehaviorDeviceGeneric<DeviceCommands>, logger: AnsiLogger, roborockService: RoborockService): void {
+  handler.setCommandHandler('changeToMode', async (newMode: number) => {
+    const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+    switch (activity) {
+      case 'Cleaning': {
+        logger.notice('BehaviorA187-ChangeRunMode to: ', activity);
+        await roborockService.startClean(duid);
+        return;
+      }
+      case 'Smart Plan':
+      case 'Mop':
+      case 'Vacuum':
+      case 'Mop & Vacuum':
+      case 'Custom': {
+        const setting = CleanSetting[newMode];
+        logger.notice(`BehaviorA187-ChangeCleanMode to: ${activity}, code: ${JSON.stringify(setting)}`);
+        await roborockService.changeCleanMode(duid, setting);
+        return;
+      }
+      default:
+        logger.notice('BehaviorA187-changeToMode-Unknown: ', newMode);
+        return;
+    }
+  });
+
+  handler.setCommandHandler('selectAreas', async (newAreas: number[]) => {
+    logger.notice(`BehaviorA187-selectAreas: ${newAreas}`);
+    roborockService.setSelectedAreas(duid, newAreas ?? []);
+  });
+
+  handler.setCommandHandler('pause', async () => {
+    logger.notice('BehaviorA187-Pause');
+    await roborockService.pauseClean(duid);
+  });
+
+  handler.setCommandHandler('resume', async () => {
+    logger.notice('BehaviorA187-Resume');
+    await roborockService.resumeClean(duid);
+  });
+
+  handler.setCommandHandler('goHome', async () => {
+    logger.notice('BehaviorA187-GoHome');
+    await roborockService.stopAndGoHome(duid);
+  });
+
+  handler.setCommandHandler('PlaySoundToLocate', async (identifyTime: number) => {
+    logger.notice('BehaviorA187-PlaySoundToLocate');
+    await roborockService.playSoundToLocate(duid);
+  });
+}

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

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

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

@@ -0,0 +1,29 @@
+import { MopWaterFlowA187, VacuumSuctionPowerA187 } from './a187.js';
+
+export function getCurrentCleanModeA187(fan_power: number | undefined, water_box_mode: number | undefined): number | undefined {
+  if (!fan_power || !water_box_mode) return undefined;
+  if (fan_power == VacuumSuctionPowerA187.Smart || water_box_mode == MopWaterFlowA187.Smart) return 4; // 'Smart Plan',
+  if (fan_power == VacuumSuctionPowerA187.Custom || water_box_mode == MopWaterFlowA187.Custom) return 8; // 'Custom',
+  if (fan_power == VacuumSuctionPowerA187.Off) return 5; // 'Mop',
+  if (water_box_mode == MopWaterFlowA187.Off)
+    return 6; // 'Vacuum',
+  else return 7; //Vac & Mop
+}
+
+export function getCurrentCleanModeFromFanPowerA187(fan_power: number | undefined): number | undefined {
+  if (!fan_power) return undefined;
+  if (fan_power == VacuumSuctionPowerA187.Smart) return 4; // 'Smart Plan',
+  if (fan_power == VacuumSuctionPowerA187.Custom) return 8; // 'Custom',
+  if (fan_power == VacuumSuctionPowerA187.Off)
+    return 5; // 'Mop',
+  else return undefined;
+}
+
+export function getCurrentCleanModeFromWaterBoxModeA187(water_box_mode: number | undefined): number | undefined {
+  if (!water_box_mode) return undefined;
+  if (water_box_mode == MopWaterFlowA187.Smart) return 4; // 'Smart Plan',
+  if (water_box_mode == MopWaterFlowA187.Custom) return 8; // 'Custom',
+  if (water_box_mode == MopWaterFlowA187.Off)
+    return 6; // 'Vacuum',
+  else return undefined;
+}

package/src/behaviors/roborock.vacuum/default/default.ts

@@ -0,0 +1,78 @@
+import { MaybePromise } from 'matterbridge/matter';
+import { AnsiLogger } from 'matterbridge/logger';
+import { BehaviorDeviceGeneric, BehaviorRoborock, DeviceCommands } from '../../BehaviorDeviceGeneric.js';
+import RoborockService from '../../../roborockService.js';
+
+export interface DefaultEndpointCommands extends DeviceCommands {
+  selectAreas: (newAreas: number[]) => MaybePromise;
+  changeToMode: (newMode: number) => MaybePromise;
+  pause: () => MaybePromise;
+  resume: () => MaybePromise;
+  goHome: () => MaybePromise;
+  PlaySoundToLocate: (identifyTime: number) => MaybePromise;
+}
+
+export class DefaultBehavior extends BehaviorRoborock {
+  declare state: DefaultBehaviorRoborock.State;
+}
+
+export namespace DefaultBehaviorRoborock {
+  export class State {
+    device!: BehaviorDeviceGeneric<DefaultEndpointCommands>;
+  }
+}
+
+const RvcRunMode: Record<number, string> = {
+  [1]: 'Idle', //DO NOT HANDLE HERE,
+  [2]: 'Cleaning',
+  [3]: 'Mapping',
+};
+const RvcCleanMode: Record<number, string> = {
+  [4]: 'Mop',
+  [5]: 'Vacuum',
+};
+
+export function setDefaultCommandHandler(duid: string, handler: BehaviorDeviceGeneric<DeviceCommands>, logger: AnsiLogger, roborockService: RoborockService): void {
+  handler.setCommandHandler('changeToMode', async (newMode: number) => {
+    const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+    switch (activity) {
+      case 'Cleaning': {
+        await roborockService.startClean(duid);
+        return;
+      }
+      case 'Mop':
+      case 'Vacuum': {
+        logger.notice('DefaultBehavior-ChangeCleanMode to: ', activity);
+        return;
+      }
+      default:
+        logger.notice('DefaultBehavior-changeToMode-Unknown: ', newMode);
+        return;
+    }
+  });
+
+  handler.setCommandHandler('selectAreas', async (newAreas: number[]) => {
+    logger.notice(`DefaultBehavior-selectAreas: ${newAreas}`);
+    roborockService.setSelectedAreas(duid, newAreas ?? []);
+  });
+
+  handler.setCommandHandler('pause', async () => {
+    logger.notice('DefaultBehavior-Pause');
+    await roborockService.pauseClean(duid);
+  });
+
+  handler.setCommandHandler('resume', async () => {
+    logger.notice('DefaultBehavior-Resume');
+    await roborockService.resumeClean(duid);
+  });
+
+  handler.setCommandHandler('goHome', async () => {
+    logger.notice('DefaultBehavior-GoHome');
+    await roborockService.stopAndGoHome(duid);
+  });
+
+  handler.setCommandHandler('PlaySoundToLocate', async (identifyTime: number) => {
+    logger.notice('DefaultBehavior-PlaySoundToLocate');
+    await roborockService.playSoundToLocate(duid);
+  });
+}

package/src/behaviors/roborock.vacuum/default/initalData.ts

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

package/src/clientManager.ts

@@ -0,0 +1,23 @@
+import { ClientRouter } from './roborockCommunication/broadcast/clientRouter.js';
+import { UserData } from './roborockCommunication/index.js';
+import { AnsiLogger } from 'matterbridge/logger';
+
+export default class ClientManager {
+  private readonly clients = new Map<string, ClientRouter>();
+  private logger: AnsiLogger;
+
+  public constructor(logger: AnsiLogger) {
+    this.logger = logger;
+  }
+
+  public get(username: string, userdata: UserData): ClientRouter {
+    if (!this.clients.has(username)) {
+      this.clients.set(username, new ClientRouter(this.logger, userdata));
+    }
+    return <ClientRouter>this.clients.get(username);
+  }
+
+  public destroy(username: string): void {
+    this.clients.delete(username);
+  }
+}

package/src/extensions/AxiosStaticExtensions.ts

@@ -0,0 +1,35 @@
+import { AxiosStatic } from 'axios';
+import { AnsiLogger } from 'matterbridge/logger';
+
+declare module 'axios' {
+  interface AxiosStatic {
+    interceptRequestAndResponse(logger: AnsiLogger): this;
+  }
+}
+
+// Add the method to the actual axios object
+import axios from 'axios';
+
+(axios as any).interceptRequestAndResponse = function (logger: AnsiLogger): AxiosStatic {
+  this.interceptors.request.use((request: any) => {
+    logger.debug('Axios Request:', {
+      method: request.method,
+      url: request.url,
+      data: request.data,
+      headers: request.headers,
+    });
+    return request;
+  });
+
+  this.interceptors.response.use((response: any) => {
+    logger.debug('Axios Response:', {
+      status: response.status,
+      data: response.data,
+      headers: response.headers,
+      url: response.config.url,
+    });
+    return response;
+  });
+
+  return this;
+};

package/src/extensions/index.ts

@@ -0,0 +1 @@
+import './AxiosStaticExtensions.js';

package/src/helper.ts

@@ -0,0 +1,22 @@
+import { Device } from './roborockCommunication/index.js';
+
+export function getVacuumProperty(device: Device, property: string): number | undefined {
+  if (device) {
+    const schemas = device.schema;
+    const schema = schemas.find((sch) => sch.code == property);
+
+    if (schema && device.deviceStatus && device.deviceStatus[schema.id] != undefined) {
+      return Number(device.deviceStatus[schema.id]);
+    }
+
+    if (device.deviceStatus && device.deviceStatus[property] != undefined) {
+      return Number(device.deviceStatus[property]);
+    }
+  }
+
+  return undefined;
+}
+
+export function isSupportedDevice(model: string): boolean {
+  return model.startsWith('roborock.vacuum.');
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+import { Matterbridge, PlatformConfig } from 'matterbridge';
+import { AnsiLogger } from 'matterbridge/logger';
+import { RoborockMatterbridgePlatform } from './platform.js';
+
+/**
+ * This is the standard interface for Matterbridge plugins.
+ * Each plugin should export a default function that follows this signature.
+ *
+ * @param {Matterbridge} matterbridge - The Matterbridge instance.
+ * @param {AnsiLogger} log - The logger instance.
+ * @param {PlatformConfig} config - The platform configuration.
+ * @returns {RoborockMatterbridgePlatform} The initialized platform.
+ */
+export default function initializePlugin(matterbridge: Matterbridge, log: AnsiLogger, config: PlatformConfig): RoborockMatterbridgePlatform {
+  return new RoborockMatterbridgePlatform(matterbridge, log, config);
+}

package/src/initialData/getBatteryStatus.ts

@@ -0,0 +1,26 @@
+import { PowerSource } from 'matterbridge/matter/clusters';
+import { OperationStatusCode } from '../roborockCommunication/Zenum/operationStatusCode.js';
+
+export function getBatteryStatus(batteryLevel?: number): PowerSource.BatChargeLevel {
+  if (batteryLevel === undefined) return PowerSource.BatChargeLevel.Ok;
+
+  if (batteryLevel >= 70) {
+    return PowerSource.BatChargeLevel.Ok;
+  } else if (batteryLevel >= 40) {
+    return PowerSource.BatChargeLevel.Warning;
+  } else {
+    return PowerSource.BatChargeLevel.Critical;
+  }
+}
+
+export function getBatteryState(deviceState: number, batRemaining: number): PowerSource.BatChargeState {
+  if (deviceState == OperationStatusCode.Charging) {
+    return batRemaining < 100 ? PowerSource.BatChargeState.IsCharging : PowerSource.BatChargeState.IsAtFullCharge;
+  }
+
+  if (deviceState == OperationStatusCode.ChargingError) {
+    return PowerSource.BatChargeState.IsNotCharging;
+  }
+
+  return PowerSource.BatChargeState.IsAtFullCharge;
+}

package/src/initialData/getOperationalStates.ts

@@ -0,0 +1,24 @@
+import { RvcOperationalState } from 'matterbridge/matter/clusters';
+import { getOperationalStatesA187 } from '../behaviors/roborock.vacuum/QREVO_EDGE_5V1/initalData.js';
+import { getDefaultOperationalStates } from '../behaviors/roborock.vacuum/default/initalData.js';
+import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+import { VacuumErrorCode } from '../roborockCommunication/Zenum/vacuumAndDockErrorCode.js';
+
+export function getOperationalStates(model: string): RvcOperationalState.OperationalStateStruct[] {
+  switch (model) {
+    case DeviceModel.QREVO_EDGE_5V1:
+      return getOperationalStatesA187();
+    default:
+      return getDefaultOperationalStates();
+  }
+}
+
+export function getOperationalErrorState(errorCode: VacuumErrorCode): RvcOperationalState.OperationalState | undefined {
+  switch (errorCode) {
+    case VacuumErrorCode.None:
+      return undefined;
+    default: {
+      return RvcOperationalState.OperationalState.Error;
+    }
+  }
+}