Complex Protocol Structuring

Background: In the current robot vacuum cleaner solution, some specific advanced functions communicate between the panel and the device through DP15: command_trans. During communication, it is necessary to assemble and parse according to the format agreed in the Tuya robot vacuum cleaner protocol document, which has high understanding and development costs. To help developers quickly build a robot vacuum cleaner application, we decompose the functions in this DP into structured data for communication between the two ends.

How to Access

Device Side

Device SDK version requirement: tuyaos_robot_rvc_sdk>=1.0.0 version is required

Panel Side

In the @ray-js/robot-data-stream dependency package, corresponding request and setting methods are provided for specific advanced functions. At the same time, this dependency package also registers an event listener StreamDataNotificationCenter. When the device side responds to the corresponding command, the panel developer can receive the reported data through event listening.

Function List

Virtual Wall

const { requestVirtualWall, setVirtualWall } = useVirtualWall(devId);

The virtual wall function provides two methods: setting the virtual wall setVirtualWall and querying the virtual wall requestVirtualWall

Set Virtual Wall

Parameters

params (object): An object containing the following properties
- points (string[]): The endpoint coordinates of the virtual wall, reference format ['x0,y0,x1,y1','x2,y2,x3,y3'], x0 | y0: one point of the virtual wall, x1 | y1: another point of the virtual wall
- num (number, optional): Number of virtual walls
- mode: (number[], optional), cleaning mode of the virtual wall, 0: all forbidden, 1: forbidden to sweep, 2: forbidden to mop, if this function is not used, this parameter can be ignored

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure

type Response = {
  modes: number[]; // Modes of the virtual wall
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  num: number; // Number of virtual walls
  reqType: "virtualWallQry"; // Request type, fixed as "virtualWallQry"
  mapId: number; // Map ID
  version: string; // Version number
  taskId: string; // Task ID
  points: string[]; // Array of points of the virtual wall
}

Example

// Import useVirtualWall
import { useVirtualWall } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
// Initialize setVirtualWall
const { setVirtualWall } = useVirtualWall(devId);

setVirtualWall({
  points:['10,10,50,40']
}).then(data=>{
  // Indicates successful setting
  console.log(data)
  //   {
  //     "reqType": "virtualWallQry",
  //     "version": "1.0.0",
  //     "num": 1,
  //     "modes": [
  //         0
  //     ],
  //     "points": [
  //         "-113, -11, -30, -26"
  //     ],
  //     "mapId": 2,
  //     "success": true,
  //     "errCode": 0,
  //     "taskId": "1738980882764"
  // }
}).catch(error=>{
  // Indicates operation failure, device returns failure or device timeout causes failure, timeout is 5s
  console.log(error)
})

Note

The coordinate point information sent to the device needs to be data in the machine coordinate system. The virtual wall coordinate information obtained through the robot vacuum cleaner SDK needs to be converted according to the origin coordinates.
After receiving the reply of the device virtual wall information, the virtualWallQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Query Virtual Wall

Parameters

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure

type Response = {
  modes: number[]; // Modes of the virtual wall
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  num: number; // Number of virtual walls
  reqType: "virtualWallQry"; // Request type, fixed as "virtualWallQry"
  mapId: number; // Map ID
  version: string; // Version number
  taskId: string; // Task ID
  points: string[]; // Array of points of the virtual wall
}

Example

// Import useVirtualWall
import { useVirtualWall,StreamDataNotificationCenter,VirtualWallEnum } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
// Initialize setVirtualWall
const { requestVirtualWall } = useVirtualWall(devId);

requestVirtualWall();

// Listen for virtual wall device report information
 StreamDataNotificationCenter.on(VirtualWallEnum.query, handleVirtualWall);

// In this method, you can get the virtual wall information reported by the device and update the redux data in the project
const handleVirtualWall = (data)=>{
  console.log(data)
}

Note

The coordinate point data reported by the device is data in the machine coordinate system. When passed into the robot vacuum cleaner SDK, the data needs to be converted into the screen coordinate system.
After receiving the reply of the device virtual wall information, the virtualWallQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Restricted Area

const { requestVirtualArea, setVirtualArea } = useVirtualArea(devId);

The restricted area function provides two methods: setting the restricted area setVirtualArea and querying the restricted area requestVirtualArea

Set Restricted Area

Parameters

params (object): An object containing the parameters for setting the virtual area, with the following properties:
- polygons (string[]): Array of polygons, each element is a coordinate string of a polygon.
- names (string[], optional): Array of names, each element is the name of an area.
- modes (number[]): Array of modes, each element is the mode of an area, 0: all forbidden, 1: forbidden to sweep, 2: forbidden to mop.
- num (number, optional): Number of virtual areas.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// VirtualAreaResponse object structure
interface VirtualAreaResponse {
  reqType: string; // Request type
  version: string; // Version number
  num: number; // Number of virtual areas
  modes: number[]; // Array of modes, each element is the mode of an area
  polygons: string[]; // Array of polygons, each element is a coordinate string of a polygon
  names: string[]; // Array of names, each element is the name of an area
  mapId: number; // Map ID
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  taskId: string; // Task ID
}

Example

// Import useVirtualArea
import { useVirtualArea } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
const { setVirtualArea } = useVirtualArea(devId);

 setVirtualArea({
    "polygons": [
        "-165,64,-81,64,-81,19,-165,19",
        "-175,53,-92,53,-92,9,-175,9"
    ],
    "modes": [
        0,
        2
    ],
})
  .then(data => {
    console.log(data);
//    {
//     "reqType": "restrictedAreaQry",
//     "version": "1.0.0",
//     "num": 2,
//     "modes": [
//         0,
//         2
//     ],
//     "polygons": [
//         "-165, 64,-81, 64,-81, 19,-165, 19",
//         "-175, 53,-92, 53,-92, 9,-175, 9"
//     ],
//     "names": [
//         "",
//         ""
//     ],
//     "mapId": 2,
//     "success": true,
//     "errCode": 0,
//     "taskId": "1738994024502"
// }
  })
  .catch((error) => {
    console.log(error)
  });

Note

The coordinate point information sent to the device needs to be data in the machine coordinate system. The virtual area information obtained through the robot vacuum cleaner SDK needs to be converted according to the origin coordinates.
After receiving the reply of the device restricted area information, the restrictedAreaQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Query Restricted Area

Parameters

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// VirtualAreaResponse object structure
interface VirtualAreaResponse {
  reqType: string; // Request type
  version: string; // Version number
  num: number; // Number of virtual areas
  modes: number[]; // Array of modes, each element is the mode of an area
  polygons: string[]; // Array of polygons, each element is a coordinate string of a polygon
  names: string[]; // Array of names, each element is the name of an area
  mapId: number; // Map ID
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  taskId: string; // Task ID
}

Example

// Import useVirtualArea
import { useVirtualArea,StreamDataNotificationCenter,VirtualAreaEnum } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
// Initialize requestVirtualArea
const { requestVirtualArea } = useVirtualArea(devId);

requestVirtualArea();

// Listen for virtual wall device report information
 StreamDataNotificationCenter.on(VirtualAreaEnum.query, handleVirtualArea);

// In this method, you can get the virtual wall information reported by the device and update the redux data in the project
const handleVirtualArea = (data)=>{
  console.log(data)
}

Note

The coordinate point data reported by the device is data in the machine coordinate system. When passed into the robot vacuum cleaner SDK, the data needs to be converted into the screen coordinate system.
After receiving the reply of the device restricted area information, the restrictedAreaQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Machine Voice

const { requestAllVoices, requestVoiceInUse,setVoice } = useVoice(devId);

The machine voice function provides three methods: querying all supported device voices requestAllVoices, querying the currently used machine voice requestVoiceInUse, and setting the voice setVoice

Query Voice List

Parameters

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// GetVoiceListResponse object structure
  type GetVoiceListResponse = {
    datas: {
      auditionUrl: string // Audition link
      desc?: string // Description
      extendData: {
        extendId: number // Extend ID, used to compare with the language pack ID reported by the device to determine whether the voice pack is in use
        version: string // Version
      }
      id: number // ID
      imgUrl: string // Image link
      name: string // Name
      officialUrl: string // Official link
      productId: string // Product ID
      region: string[] // Region codes
    }[] // Array of voice data
    pageNo: number // Page number
    totalCount: number // Total number of data
  }

Example

import { useVoice } from '@ray-js/robot-data-stream';
const { requestAllVoices } = useVoice(devId);

requestAllVoices()
  .then(res => {
    console.log(res.data)
  })
  .finally(() => {
    setLoading(false);
  });

Note

This function requires uploading voice files on the Tuya IoT platform before it can be used. For operation methods, please contact your account manager or submit a ticket for consultation.

Query Voice in Use

Parameters

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// VoiceLanguageResponse object structure
interface VoiceLanguageResponse {
  reqType: string; // Request type
  version: string; // Version number
  id: number; // Voice language ID
  schedule: number; // Progress percentage
  status: number; // Status code
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  taskId: string; // Task ID
}

Example

requestVoiceInUse().then(data => {
  console.log(data);
// {
//     "reqType": "voiceLanguageQry",
//     "version": "1.0.0",
//     "id": 0,
//     "schedule": 100,
//     "status": 3,
//     "success": true,
//     "errCode": 0,
//     "taskId": "1738996454610"
// }
});

Note

After receiving the reply of the device's currently used voice file, the voiceLanguageQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Set Voice

Parameters

message (object): An object containing the parameters for setting the voice language, with the following properties:
- id (number): Voice language ID.
- url (string): URL of the voice language file.
- md5 (string): MD5 value of the voice language file.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// VoiceLanguageResponse object structure
interface VoiceLanguageResponse {
  reqType: string; // Request type
  version: string; // Version number
  id: number; // Voice language ID
  schedule: number; // Progress percentage
  status: number; // Status code
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  taskId: string; // Task ID
}

Example

import { useVoice,StreamDataNotificationCenter ,VoiceLanguageEnum} from '@ray-js/robot-data-stream';

const { setVoice } = useVoice(devId);

// The data here comes from the data returned by the requestAllVoices method
setVoice({
  id: extendData.extendId,
  url: officialUrl,
  md5: desc,
});

// Listen for device reports
StreamDataNotificationCenter.on(VoiceLanguageEnum.query, (data) => {
  console.log('Received voiceLanguageQry====>', data);
});

Note

After sending the device voice, the device will periodically report the download progress of the voice file until the download is complete. Therefore, it is recommended to use event listening in the code implementation.
After receiving the reply of the device downloading the voice file, the voiceLanguageQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Machine Information

const { requestDevInfo } = useDevInfo(devId);

The machine information function provides one method, requesting machine information requestDevInfo

Request Machine Information

Parameters

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// DevInfoResponse object structure

interface DevInfoResponse {
  reqType: string; // Request type
  version: string; // Version number
  info: string; // JSON string of device information
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  taskId: string; // Task ID
}

Example

import { useDevInfo } from '@ray-js/robot-data-stream';

const { requestDevInfo } = useDevInfo(devId);

   requestDevInfo()
      .then(data => {
        const { info } = data;
        const robotInfo = JsonUtil.parseJSON(info);
        console.log(robotInfo)
//      {
//     "WiFi_Name": "robot",
//     "RSSI": 58,
//     "IP": "**",
//     "Mac": "**",
//     "Firmware_Version": "**",
//     "Device_SN": "**",
//     "Module_UUID": "**"
// }
      })
      .catch(error => {
        console.log(error);
      });

Note

After receiving the reply of the device machine information, the devInfoQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Historical Map

const { deleteHistoryMap, changeCurrentMap,saveMap } = useHistoryMap(devId);

The historical map function provides three methods: saving the map saveMap, deleting the historical map deleteHistoryMap, and changing the home map changeCurrentMap

Save Map

Parameters

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure

type Response = {
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  reqType: string; // Request type
  version: string; // Version number
  taskId: string; // Task ID
}

Example

import { useHistoryMap,StreamDataNotificationCenter ,SaveCurrentMapEnum} from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
const { saveMap } = useHistoryMap(devId);

saveMap().then(()=>{
  console.log('Save successful')
}).catch(()=>{
  console.log('Save failed')
});

// Listen for device reports
 StreamDataNotificationCenter.on(SaveCurrentMapEnum.query, (data)=>{
  console.log(data)
 });

After receiving the reply of the device saving the map, the SaveCurrMapRst event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Delete Map

Parameters

mapId (number): Cloud ID of the map.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure

type Response = {
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  reqType: string; // Request type
  version: string; // Version number
  taskId: string; // Task ID
}

Example

import { useHistoryMap,StreamDataNotificationCenter ,DeleteMapEnum} from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
const { deleteHistoryMap } = useHistoryMap(devId);

 deleteHistoryMap(id)
  .then((data) => {
    console.log('Delete successful')
  }).catch(error=>{
    console.log(error)
  })

// Listen for device reports
 StreamDataNotificationCenter.on(DeleteMapEnum.rst, ()=>{
  console.log('Received device report')
 });

Note

After receiving the reply of the device deleting the map, the deleteMapRst event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Change Home Map

Parameters

mapId (number): Map ID.
url (string): Map URL.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure

type Response = {
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  reqType: string; // Request type
  mapId: number; // Map ID
  version: string; // Version number
  taskId: string; // Task ID
}

Example

import { useHistoryMap,UseMapEnum,StreamDataNotificationCenter } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
const { changeCurrentMap } = useHistoryMap(devId);

const mapId = 123;
const url = 'https://example.com/map.png';

changeCurrentMap(mapId, url).then(response => {
  console.log('Change successful:', response);
}).catch(error => {
  console.error('Change failed:', error);
});

 StreamDataNotificationCenter.on(UseMapEnum.query, ()=>{
  console.log('Received device report')
 });

Note

After receiving the reply of the device changing the home map, the useMapRst event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Room Division

const {setPartDivision} = usePartDivision(devId);

Room division is a user operation behavior. This hook only provides a function for room division operation setPartDivision

Room Division

Parameters

points (Point[]): Array of division points, the coordinates thrown out by the SDK method can be directly passed in.
roomId (number): Room ID, the room to be divided.
origin (Point): Coordinates of the map origin.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure

type Response = {
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  reqType: string; // Request type
  version: string; // Version number
  taskId: string; // Task ID
}

Example

import { usePartDivision } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
const { setPartDivision } = usePartDivision(devId);

const points = [
  { x: 100, y: 100 },
  { x: 200, y: 200 },
];
const roomId = 1;
const origin = { x: 0, y: 0 };


setPartDivision(points, roomId, origin).then(()=>{
  console.log('Save successful')
}).catch(()=>{
  console.log('Save failed')
});

Note

After receiving the reply of the device room division, the partDivisionRst event will be thrown, which can be listened to through the StreamDataNotificationCenter.
The coordinates of the division line passed into the setPartDivision method are data in the screen coordinate system, that is, the data thrown out by the robot vacuum cleaner SDK method.

Room Merge

const {setPartMerge} = usePartMerge(devId);

Room merge is a user operation behavior. This hook only provides a function for room merge operation setPartMerge

Room Merge

Parameters

ids (number[]): Array of room IDs to be merged.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure

type Response = {
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  reqType: string; // Request type
  version: string; // Version number
  taskId: string; // Task ID
}

Example

import { usePartMerge } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
const { setPartMerge } = usePartMerge(devId);

const ids = [1, 2, 3];

setPartMerge(ids).then(response => {
  console.log('Set successful:', response);
}).catch(error => {
  console.error('Set failed:', error);
});

Note

After receiving the reply of the device room merge, the partMergeRst event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Do Not Disturb Mode

import { useQuiteHours } from '@ray-js/robot-data-stream';

const { setQuiteHours ,requestQuiteHours} = useQuiteHours(devId);

The do not disturb mode function provides two methods: setting the do not disturb mode setQuiteHours and querying the do not disturb mode requestQuiteHours

Request Do Not Disturb Mode

Parameters

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure

type Response = {
  time: string[]; // Array of time periods, each element is a string in the format "start time, end time"
  day: number; // Whether there is a cross-day, 1 means yes, 0 means no.
  active: number; // Whether it is activated, 0 means not activated, 1 means activated
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  reqType: string; // Request type
  mapId: number; // Map ID
  version: string; // Version number
  taskId: string; // Task ID
}

Example

// Import useVirtualWall
import { useQuiteHours } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
// requestQuiteHours
const { requestQuiteHours } = useVirtualWall(devId);

requestQuiteHours().then(data => {
  console.log('Do not disturb mode data:', data);
  //  {
  //   "reqType": "quietHoursQry",
  //   "time": ["9,15", "0,18"],
  //   "version": "1.0.0",
  //   "day": 1,
  //   "taskId": "1733126622485"，
  //   "mapId":111
  // }
}).catch(error => {
  console.error('Request failed:', error);
});

Set Do Not Disturb Mode

Parameters

params (object): An object containing the parameters for setting the do not disturb mode, with the following properties:
- startTime (object): Start time, containing the following properties:
  - hour (number): Hour, range 0-23.
  - minute (number): Minute, range 0-59.
- endTime (object): End time, containing the following properties:
  - hour (number): Hour, range 0-23.
  - minute (number): Minute, range 0-59.
- active (number): Do not disturb mode switch, 1 means on, 0 means off.
- day (number): Whether there is a cross-day, 1 means yes, 0 means no.
- version (string, optional): Protocol version.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

{ 
  reqType: string;  // Request type
  version: string;// Version number
  active: number;// Whether it is activated, 0 means not activated, 1 means activated
  time: string[];// Array of time periods, each element is a string in the format "start time, end time"
  day: number;// Whether there is a cross-day, 1 means yes, 0 means no.
  success: boolean; // Whether the request was successful
  errCode: number;// Error code, 0 means no error
  taskId: string; // Task ID
}

Example

import { Switch } from '@ray-js/smart-ui';
import { useQuiteHours } from '@ray-js/robot-data-stream';

// Device ID
const { devId } = useDevice(device => device.devInfo);
const { setQuiteHours } = useQuiteHours(devId);


  setQuiteHours({
    startTime:{
      hour:22,
      minute:0
    },
    endTime:{
      hour:8,
      minute:0
    },
    active: value,
    day: 1,
  })
    .then(data => {
     console.log('Set successful')
    })
    .catch(() => {
     console.log('Set failed')
    });

Reset Map

const {setResetMap} = useResetMap(devId);

Reset Map

Parameters

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure

type Response = {
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  reqType: string; // Request type
  version: string; // Version number
  taskId: string; // Task ID
}

Example

import { useResetMap } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
const { setResetMap } = useResetMap(devId);


setResetMap().then(response => {
  console.log('Reset map successful', response);
}).catch(error => {
  console.error('Reset map failed:', error);
});

Room Property

const { requestRoomProperty, setRoomProperty } = useRoomProperty(devId);

The room property function provides two methods: setting the room property setRoomProperty and querying the room property requestRoomProperty

Set Room Property

Parameters

message (object): An object containing the parameters for setting the room property, with the following properties:
- suctions (string[], optional): Array of suctions.
- cisterns (string[], optional): Array of cisterns.
- cleanCounts (number[], optional): Array of clean counts.
- yMops (number[], optional): Array of mops.
- sweepMopModes (string[], optional): Array of sweep mop modes.
- names (string[], optional): Array of names.
- ids (number[]): Array of room IDs.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure
type Response = {
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  reqType: string; // Request type
  version: string; // Version number
  taskId: string; // Task ID
  num:number; //Number of rooms
  mapId：number;//Map ID
    // Suction, closed - off gentle - quiet normal - normal strong - strong max - super strong, default value is ''
  suctions?: string[];
  // Mop water volume "closed"- off,"low"-low,"middle"-middle,"high"-high, default value is ''
  cisterns?: string[];
  // Clean count default value 1
  cleanCounts?: number[];
  // Mop mode 1: turn on Y-shaped mop 0: turn off Y-shaped mop -1 not set default value -1
  yMops?: number[];
  // Sweep mop mode "only_sweep": only sweep,"only_mop": only mop,"both_work": sweep and mop at the same time,"clean_before_mop": sweep before mop, default value is 'only_sweep'
  sweepMopModes?: string[];
  // Room floor type, default value -1
  floorTypes?: number[];
  // Room name, default is an empty string
  names?: string[];
  // Array of room IDs
  ids?: number[];
  // Room order
  orders?: number[];
}

Example

import { useRoomProperty } from '@ray-js/robot-data-stream';
const { devId } = useDevice(device => device.devInfo);
const { setRoomProperty } = usePartMerge(devId);

const roomPropertyData = {
  suctions: ['low', 'gentle', 'max'],
  cisterns: ['closed', 'middle', 'high'],
  cleanCounts: [1, 2, 1],
  yMops: [0, 1, -1],
  sweepMopModes: ['only_sweep', 'sweep_and_mop', 'only_mop'],
  names: ['Living Room', 'Bedroom', 'Kitchen'],
  ids: [1, 2, 3],
  floorTypes:[-1,-1,-1]
  orders:[1,2,3]
};

setRoomProperty(roomPropertyData).then(response => {
  console.log('Set successful:', response);
}).catch(error => {
  console.error('Set failed:', error);
});

Note

When setting room properties, all room properties need to be passed in. For example, when modifying the room floor, the room name and other data also need to be sent to the device.
The order of suctions, cisterns, etc. needs to be consistent with the order of ids. For example, if the first data of ids is the bedroom, then the first element of suctions also needs to be the suction of the bedroom.

Request Room Property

Method Name

requestRoomProperty

Parameters

Return Value

Refer to the return parameters of setRoomProperty

Example

import { useRoomProperty } from '@ray-js/robot-data-stream';
const { devId } = useDevice(device => device.devInfo);
const { requestRoomProperty } = usePartMerge(devId);

requestRoomProperty().then(response => {
  console.log('Room property data:', response);
}).catch(error => {
  console.error('Request failed:', error);
});

Schedule Task

const { requestSchedule, setSchedule } = useSchedule(devId);

The schedule task function provides two methods: setting the schedule setSchedule and querying the schedule requestSchedule

Set Schedule

Parameters

message (object): An object containing the parameters for setting the schedule task, with the following properties:
- list (Array): List of schedule tasks.
- num (number): Number of schedule tasks.

type ScheduleItem = {
   // Suction, closed - off gentle - quiet normal - normal strong - strong max - super strong, default value is ''
  suctions?: string[];
   // Mop water volume "closed"- off,"low"-low,"middle"-middle,"high"-high, default value is ''
  cisterns?: string[];
  // Mop mode 1: turn on Y-shaped mop 0: turn off Y-shaped mop -1 not set default value -1
  yMops?: number[];
 // Sweep mop mode "only_sweep": only sweep,"only_mop": only mop,"both_work": sweep and mop at the same time,"clean_before_mop": sweep before mop, default value is 'only_sweep'
  sweepMopModes?: string[];
    // Array of room IDs, if ids is an empty array, it means the whole house is executed
  ids?: number[];
  // Whether the schedule is valid, 0: schedule off 1: schedule on
  active: number; 
  // Weekly cycle, Monday to Sunday
  cycle: number[]; 
   // Execution time, [hour, minute]
  time: number[];
};

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure, ScheduleItem structure is consistent with the input parameter structure
type Response ={
  reqType: string; // Request type
  version: string; // Version number
  success: boolean; // Whether the request was successful
  errCode: number; // Error code, 0 means no error
  taskId: string; // Task ID
  list: Array<ScheduleItem>;
  num: number;
};

Example

import { useSchedule } from '@ray-js/robot-data-stream';
const { devId } = useDevice(device => device.devInfo);
const {  setSchedule } = useSchedule(devId);


const scheduleData = {
  list: [
    {
      // Schedule on
      active: 1,
      // Execute only once
      cycle:[0,0,0,0,0,0,0],
      // Cleaning time 8:00
      time: [8, 0],
      // Normal suction
      suctions: ['normal'],
      // Water volume off
      cisterns: ['closed'],
      // Clean only once
      cleanCounts: [1],
      // Y-shaped mop off
      yMops: [0],
      // Forbidden sweep mode
      sweepMopModes: ['only_sweep'],
      // Whole house cleaning
      ids: [],
    },
  ],
  num: 1,
};

setSchedule(scheduleData).then(response => {
  console.log('Set successful:', response);
}).catch(error => {
  console.error('Set failed:', error);
});

Note

The schedule data needs to be sent in full. For example, if one schedule has been added, when adding the second schedule, the list data sent needs to include the data of the first schedule.

Query Schedule

Parameters

Return Value

Refer to the return parameters of the setSchedule method

Example

import { useSchedule } from '@ray-js/robot-data-stream';
const { devId } = useDevice(device => device.devInfo);
const { requestRoomProperty } = useSchedule(devId);

requestSchedule().then(response => {
  console.log('Schedule data:', response);
}).catch(error => {
  console.error('Request failed:', error);
});

Select Room Cleaning

const { requestSelectRoomClean, setRoomClean } = useSelectRoomClean(devId);

The select room cleaning function provides two methods: setting the select room cleaning setSpotClean and querying the select room cleaning requestSpotClean

Set Select Room Cleaning

Parameters

message (object): An object containing the parameters for setting the select room cleaning, with the following properties:
- ids (number[]): Array of room IDs.
- suctions (string[], optional): Array of suctions.
- cisterns (string[], optional): Array of cisterns.
- cleanCounts (number[], optional): Array of clean counts.
- yMops (number[], optional): Array of mops.
- sweepMopModes (string[], optional): Array of sweep mop modes.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation

// Response object structure, ScheduleItem structure is consistent with the input parameter structure
type Response ={
   reqType: string; // Request type
    version: string; // Version number
    success: boolean; // Whether the request was successful
    errCode: number; // Error code, 0 means no error
    taskId: string; // Task ID
    ids:string[];  // Array of room IDs
    suctions: string[];//Array of suctions
    cisterns:string[]; // Array of cisterns
    cleanCounts:number[];//Array of clean counts
    yMops: number[];//Array of mops 
    sweepMopModes: string[];  //Array of sweep mop modes 
};

Example

const roomCleanData = {
  ids: [1, 2, 3],
  suctions: ['strong', 'strong', 'high'],
  cisterns: ['low', 'middle', 'high'],
  cleanCounts: [1, 2, 1],
  yMops: [0, 1, 0],
  sweepMopModes: ['only_sweep', 'clean_before_mop', 'both_work'],
};

setRoomClean(roomCleanData).then(() => {
  console.log('Set successful');
}).catch(error => {
  console.error('Set failed:', error);
});

Note

After receiving the reply of the device select room cleaning, the roomCleanQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Query Select Room Cleaning

Parameters

Return Value

Refer to setRoomClean

Example

import { useSelectRoomClean } from '@ray-js/robot-data-stream';
const { devId } = useDevice(device => device.devInfo);
const { requestSelectRoomClean } = useSelectRoomClean(devId);

requestSelectRoomClean().then(response => {
  console.log('Cleaning data:', response);
}).catch(error => {
  console.error('Request failed:', error);
});

Note

After receiving the reply of the device select room cleaning, the roomCleanQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Zone Cleaning

const { requestZoneClean, setZoneClean } = useZoneClean(devId);

The zone cleaning function provides two methods: setting the zone cleaning setZoneClean and querying the zone cleaning requestZoneClean

Set Zone Cleaning

Parameters

message (object): An object containing the parameters for setting the zone cleaning, with the following properties:
- polygons (string[]): Array of polygons, each element is a coordinate string of a polygon.
- suctions (string[], optional): Array of suctions.
- cisterns (string[], optional): Array of cisterns.
- cleanCounts (number[], optional): Array of clean counts.
- yMops (number[], optional): Array of mops.
- sweepMopModes (string[], optional): Array of sweep mop modes.
- names (string[], optional): Array of names.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure
type Response ={
   reqType: string; // Request type
    version: string; // Version number
    success: boolean; // Whether the request was successful
    errCode: number; // Error code, 0 means no error
    taskId: string; // Task ID
    polygons:string[];  // Array of polygons, each element is a coordinate string of a polygon.
    suctions: string[];//Array of suctions
    cisterns:string[]; // Array of cisterns
    cleanCounts:number[];//Array of clean counts
    yMops: number[];//Array of mops 
    sweepMopModes: string[];  //Array of sweep mop modes 
    names?:string[]; //Array of names.
};

Example

const zoneCleanData = {
  polygons: ['-165,64,-81,64,-81,19,-165,19', '-175,53,-92,53,-92,9,-175,9'],
  suctions: ['gentle', 'normal'],
  cisterns: ['closed', 'middle'],
  cleanCounts: [1, 2],
  yMops: [0, 1],
  sweepMopModes: ['only_sweep', 'both_work'],
  names: ['Area 1', 'Area 2'],
};

setZoneClean(spotCleanData).then(response => {
  console.log('Set successful:', response);
}).catch(error => {
  console.error('Set failed:', error);
});

Note

After receiving the reply of the device zone cleaning, the zoneCleanQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Query Zone Cleaning

Parameters

Return Value

Refer to the return value of setZoneClean

Note

After receiving the reply of the device zone cleaning, the zoneCleanQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Spot Cleaning

const { requestSpotClean, setSpotClean } = useSpotClean(devId);

The spot cleaning function provides two methods: setting the spot cleaning setSpotClean and querying the spot cleaning requestSpotClean

Set Spot Cleaning

Parameters

message (object): An object containing the parameters for setting the spot cleaning, with the following properties:
- polygons (string[]): Array of polygons, each element is a coordinate string of a polygon.
- suctions (string[], optional): Array of suctions.
- cisterns (string[], optional): Array of cisterns.
- cleanCounts (number[], optional): Array of clean counts.
- yMops (number[], optional): Array of mops.
- sweepMopModes (string[], optional): Array of sweep mop modes.
- names (string[], optional): Array of names.

Return Value

Promise: A Promise object representing the response result of the asynchronous operation.

// Response object structure
type Response ={
   reqType: string; // Request type
    version: string; // Version number
    success: boolean; // Whether the request was successful
    errCode: number; // Error code, 0 means no error
    taskId: string; // Task ID
    polygons:string[];  // Array of polygons, each element is a coordinate string of a polygon.
    suctions: string[];//Array of suctions
    cisterns:string[]; // Array of cisterns
    cleanCounts:number[];//Array of clean counts
    yMops: number[];//Array of mops 
    sweepMopModes: string[];  //Array of sweep mop modes 
    names?:string[]; //Array of names.
};

Example

import { useSpotClean } from '@ray-js/robot-data-stream';

const { devId } = useDevice(device => device.devInfo);
const { setSpotClean } = useSpotClean(devId);

const params ={
  "yMops":[-1],
  "names":[""],
  "polygons":["13,30"],
  "num":1,
  "suctions":["max"],
  "cisterns":["max"],
  "sweepMopModes":["both_work"]
}

setSpotClean(params).then((data)=>{
  console.log('Set spot cleaning',data)
}).catch(err=>{
  console.log(err)
})

Note

After receiving the reply of the device spot cleaning, the spotCleanQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

Query Spot Cleaning

Parameters

Return Value

Refer to the return value of setSpotClean

Example

import { useSpotClean } from '@ray-js/robot-data-stream';
const { devId } = useDevice(device => device.devInfo);
const { requestSpotClean } = useSpotClean(devId);

requestSpotClean().then(response => {
  console.log('Spot cleaning data:', response);
}).catch(error => {
  console.error('Request failed:', error);
});

Note

After receiving the reply of the device spot cleaning, the spotCleanQry event will be thrown, which can be listened to through the StreamDataNotificationCenter.

#Complex Protocol Structuring

#How to Access

#Device Side

#Panel Side

#Function List

#Virtual Wall

#Set Virtual Wall

#Query Virtual Wall

#Restricted Area

#Set Restricted Area

#Query Restricted Area

#Machine Voice

#Query Voice List

#Query Voice in Use

#Set Voice

#Machine Information

#Request Machine Information

#Historical Map

#Save Map

#Delete Map

#Change Home Map

#Room Division

#Room Division

#Room Merge

#Room Merge

#Do Not Disturb Mode

#Request Do Not Disturb Mode

#Set Do Not Disturb Mode

#Reset Map

#Reset Map

#Room Property

#Set Room Property

#Request Room Property

#Schedule Task

#Set Schedule

#Query Schedule

#Select Room Cleaning

#Set Select Room Cleaning

#Query Select Room Cleaning

#Zone Cleaning

#Set Zone Cleaning

#Query Zone Cleaning

#Spot Cleaning

#Set Spot Cleaning

#Query Spot Cleaning

Complex Protocol Structuring

How to Access

Device Side

Panel Side

Function List

Virtual Wall

Set Virtual Wall

Query Virtual Wall

Restricted Area

Set Restricted Area

Query Restricted Area

Machine Voice

Query Voice List

Query Voice in Use

Set Voice

Machine Information

Request Machine Information

Historical Map

Save Map

Delete Map

Change Home Map

Room Division

Room Division

Room Merge

Room Merge

Do Not Disturb Mode

Request Do Not Disturb Mode

Set Do Not Disturb Mode

Reset Map

Reset Map

Room Property

Set Room Property

Request Room Property

Schedule Task

Set Schedule

Query Schedule

Select Room Cleaning

Set Select Room Cleaning

Query Select Room Cleaning

Zone Cleaning

Set Zone Cleaning

Query Zone Cleaning

Spot Cleaning

Set Spot Cleaning

Query Spot Cleaning