Get current location of robot

[reneroth]

Must be possible, since the app can show it. Would be enough for me to simply know which room it is currently in :) can't find anything in the docs though and the basic API responses are not giving me much to work with either.

[reneroth]

I found a solution.

The current location of the Robot is encoded in the map data. So you'll need to send the command get_map_v1 and parse the binary data received. It's a sort of binary bitmap displaying the map, with each room having its own hex value, and one pixel being roughly 50mm I believe.

The basic logic can be reverse engineered from this HomeAsisstant Xiamoi Plugin, it works essentially the same: https://github.com/PiotrMachowski/Home-Assistant-custom-components-Xiaomi-Cloud-Map-Extractor/blob/master/custom_components/xiaomi_cloud_map_extractor/xiaomi/map_data_parser.py

I'll attach my NodeJS code to get the current room the robot is in, maybe it's of use to someone:

const MM_FACTOR = 50

const CHARGER = 1
const IMAGE = 2
const PATH = 3
const GOTO_PATH = 4
const GOTO_PREDICTED_PATH = 5
const CURRENTLY_CLEANED_ZONES = 6
const GOTO_TARGET = 7
const ROBOT_POSITION = 8
const NO_GO_AREAS = 9
const VIRTUAL_WALLS = 10
const BLOCKS = 11
const NO_MOPPING_AREAS = 12
const OBSTACLES = 13
const IGNORED_OBSTACLES = 14
const OBSTACLES_WITH_PHOTO = 15
const IGNORED_OBSTACLES_WITH_PHOTO = 16
const CARPET_MAP = 17
const MOP_PATH = 18
const NO_CARPET_AREAS = 19
const DIGEST = 1024

const ROOM_PIXEL_TYPE = 0x07

const KNOWN_OBSTACLE_TYPES = {
  0: 'cable',
  2: 'shoes',
  3: 'poop',
  5: 'extension cord',
  9: 'weighting scale',
  10: 'clothes',
}

export const ATTR_TYPE = 'type'
export const ATTR_DESCRIPTION = 'description'
export const ATTR_CONFIDENCE_LEVEL = 'confidenceLevel'
export const ATTR_PHOTO_NAME = 'photoName'

export class MapData {
  constructor() {
    this.charger = null
    this.vacuumPosition = null
    this.path = null
    this.gotoPath = null
    this.predictedPath = null
    this.zones = null
    this.goto = null
    this.isValid = false
    this.walls = null
    this.noGoAreas = null
    this.noMoppingAreas = null
    this.obstacles = null
    this.ignoredObstacles = null
    this.obstaclesWithPhoto = null
    this.ignoredObstaclesWithPhoto = null
    this.blocks = null
    this.mopPath = null
    this.carpetMap = null
    this.noCarpetAreas = null
    this.majorVersion = 0
    this.minorVersion = 0
    this.mapIndex = 0
    this.mapSequence = 0
    // For image-based room data
    this.imageLeft = 0
    this.imageTop = 0
    this.imageWidth = 0
    this.imageHeight = 0
    this.rawImageData = null
    // Will store bounding boxes: { [roomNumber]: { x0, y0, x1, y1 } }
    this.rooms = {}
  }
}

export class Point {
  constructor(x, y, a) {
    this.x = x
    this.y = y
    this.a = a
  }
}

export class Path {
  constructor(pointLength, pointSize, angle, path) {
    this.pointLength = pointLength
    this.pointSize = pointSize
    this.angle = angle
    this.path = path // array of arrays of Points
  }
}

export class Zone {
  constructor(x0, y0, x1, y1) {
    this.x0 = x0
    this.y0 = y0
    this.x1 = x1
    this.y1 = y1
  }
}

export class Wall {
  constructor(x0, y0, x1, y1) {
    this.x0 = x0
    this.y0 = y0
    this.x1 = x1
    this.y1 = y1
  }
}

export class Area {
  constructor(x0, y0, x1, y1, x2, y2, x3, y3) {
    this.x0 = x0
    this.y0 = y0
    this.x1 = x1
    this.y1 = y1
    this.x2 = x2
    this.y2 = y2
    this.x3 = x3
    this.y3 = y3
  }
}

export class Obstacle {
  constructor(x, y, details) {
    this.x = x
    this.y = y
    this.details = details
  }
}

export class RoborockMap {
  constructor(raw) {
    this.raw = raw
    this._isParsed = false
    this._mapData = new MapData()
  }

  get mapData() {
    this.#parse()
    return this._mapData
  }

  #parse() {
    // TODO: parse only what is needed
    if (this._isParsed) return
    this._isParsed = true
    const mapHeaderLength = this.#getInt16(this.raw, 0x02)
    this._mapData.majorVersion = this.#getInt16(this.raw, 0x08)
    this._mapData.minorVersion = this.#getInt16(this.raw, 0x0a)
    this._mapData.mapIndex = this.#getInt32(this.raw, 0x0c)
    this._mapData.mapSequence = this.#getInt32(this.raw, 0x10)

    let blockStartPosition = mapHeaderLength

    while (blockStartPosition < this.raw.length) {
      const blockHeaderLength = this.#getInt16(
        this.raw,
        blockStartPosition + 0x02
      )
      const header = this.#getBytes(
        this.raw,
        blockStartPosition,
        blockHeaderLength
      )
      const blockType = this.#getInt16(header, 0x00)
      const blockDataLength = this.#getInt32(header, 0x04)
      const blockDataStart = blockStartPosition + blockHeaderLength
      const data = this.#getBytes(this.raw, blockDataStart, blockDataLength)

      switch (blockType) {
        case CHARGER:
          this._mapData.charger = this.#parseObjectPosition(
            blockDataLength,
            data
          )
          break
        case ROBOT_POSITION:
          this._mapData.vacuumPosition = this.#parseObjectPosition(
            blockDataLength,
            data
          )
          break
        case PATH:
          this._mapData.path = this.#parsePath(blockStartPosition, header)
          break
        case GOTO_PATH:
          this._mapData.gotoPath = this.#parsePath(blockStartPosition, header)
          break
        case GOTO_PREDICTED_PATH:
          this._mapData.predictedPath = this.#parsePath(
            blockStartPosition,
            header
          )
          break
        case CURRENTLY_CLEANED_ZONES:
          this._mapData.zones = this.#parseZones(data, header)
          break
        case GOTO_TARGET:
          this._mapData.goto = this.#parseGotoTarget(data)
          break
        case DIGEST:
          this._mapData.isValid = true
          break
        case VIRTUAL_WALLS:
          this._mapData.walls = this.#parseWalls(data, header)
          break
        case NO_GO_AREAS:
          this._mapData.noGoAreas = this.#parseArea(header, data)
          break
        case NO_MOPPING_AREAS:
          this._mapData.noMoppingAreas = this.#parseArea(header, data)
          break
        case OBSTACLES:
          this._mapData.obstacles = this.#parseObstacles(data, header)
          break
        case IGNORED_OBSTACLES:
          this._mapData.ignoredObstacles = this.#parseObstacles(data, header)
          break
        case OBSTACLES_WITH_PHOTO:
          this._mapData.obstaclesWithPhoto = this.#parseObstacles(data, header)
          break
        case IGNORED_OBSTACLES_WITH_PHOTO:
          this._mapData.ignoredObstaclesWithPhoto = this.#parseObstacles(
            data,
            header
          )
          break
        case BLOCKS: {
          const blockPairs = this.#getInt16(header, 0x08)
          this._mapData.blocks = this.#getBytes(data, 0, blockPairs)
          break
        }
        case MOP_PATH: {
          const pointsMask = this.#getBytes(
            this.raw,
            blockDataStart,
            blockDataLength
          )
          this._mapData.mopPath = this.#parseMopPath(
            this._mapData.path,
            pointsMask
          )
          break
        }
        case CARPET_MAP: {
          const carpet = this.#getBytes(
            this.raw,
            blockDataStart,
            blockDataLength
          )
          this._mapData.carpetMap = this.#parseCarpetMap(carpet)
          break
        }
        case NO_CARPET_AREAS:
          this._mapData.noCarpetAreas = this.#parseArea(header, data)
          break
        case IMAGE:
          this.#parseImageBlock(header, data, blockHeaderLength)
          break
        default:
          // unidentified block type
          break
      }

      blockStartPosition += blockDataLength + this.#getInt8(header, 2)
    }

    return this._mapData
  }

  #mapToImage(p) {
    return new Point(p.x / MM_FACTOR, p.y / MM_FACTOR)
  }

  getCurrentVacuumImagePosition() {
    if (!this.mapData.vacuumPosition || !this.mapData.rawImageData) return null

    const pos = this.#mapToImage(this.mapData.vacuumPosition)
    pos.x = Math.round(pos.x - this.mapData.imageLeft)
    pos.y = Math.round(pos.y - this.mapData.imageTop)

    return pos
  }

  getCurrentRoom() {
    const pos = this.getCurrentVacuumImagePosition()
    if (!pos) return null

    if (
      pos.x < 0 ||
      pos.y < 0 ||
      pos.x >= this.mapData.imageWidth ||
      pos.y >= this.mapData.rawImageData.length / this.mapData.imageWidth
    ) {
      return null
    }

    const pixelType =
      this.mapData.rawImageData[pos.x + pos.y * this.mapData.imageWidth]

    if (![0x01, 0x02].includes(pixelType)) {
      if ((pixelType & 0x07) === 7) {
        return (pixelType & 0xff) >> 3
      }
    }

    return null
  }

  #parseImageBlock(header, data, blockHeaderLength) {
    const imageTop = this.#getInt32(header, blockHeaderLength - 16)
    const imageLeft = this.#getInt32(header, blockHeaderLength - 12)
    const imageHeight = this.#getInt32(header, blockHeaderLength - 8)
    const imageWidth = this.#getInt32(header, blockHeaderLength - 4)

    this._mapData.imageLeft = imageLeft
    this._mapData.imageTop = imageTop
    this._mapData.imageWidth = imageWidth
    this._mapData.imageHeight = imageHeight
    this._mapData.rawImageData = data

    for (let y = 0; y < imageHeight; y++) {
      for (let x = 0; x < imageWidth; x++) {
        const idx = x + y * imageWidth
        const pixelType = data[idx]
        if ((pixelType & ROOM_PIXEL_TYPE) === 7) {
          const roomNumber = (pixelType & 0xff) >> 3
          if (!this._mapData.rooms[roomNumber]) {
            this._mapData.rooms[roomNumber] = {
              x0: x,
              y0: y,
              x1: x,
              y1: y,
            }
          } else {
            const r = this._mapData.rooms[roomNumber]
            r.x0 = Math.min(r.x0, x)
            r.y0 = Math.min(r.y0, y)
            r.x1 = Math.max(r.x1, x)
            r.y1 = Math.max(r.y1, y)
          }
        }
      }
    }
  }

  #parseGotoTarget(data) {
    const x = this.#getInt16(data, 0)
    const y = this.#getInt16(data, 2)
    return new Point(x, y)
  }

  #parseObjectPosition(blockDataLength, data) {
    const x = this.#getInt32(data, 0)
    const y = this.#getInt32(data, 4)
    let a
    if (blockDataLength > 8) {
      a = this.#getInt32(data, 8)
      if (a > 0xff) a = (a & 0xff) - 256
    }
    return new Point(x, y, a)
  }

  #parseWalls(data, header) {
    const wallPairs = this.#getInt16(header, 0x08)
    const walls = []
    for (let ws = 0; ws < wallPairs * 8; ws += 8) {
      const x0 = this.#getInt16(data, ws)
      const y0 = this.#getInt16(data, ws + 2)
      const x1 = this.#getInt16(data, ws + 4)
      const y1 = this.#getInt16(data, ws + 6)
      walls.push(new Wall(x0, y0, x1, y1))
    }
    return walls
  }

  #parseObstacles(data, header) {
    const obstaclePairs = this.#getInt16(header, 0x08)
    const obstacles = []
    if (!obstaclePairs) return obstacles
    const obstacleSize = data.length / obstaclePairs
    for (let os = 0; os < obstaclePairs * obstacleSize; os += obstacleSize) {
      const x = this.#getInt16(data, os)
      const y = this.#getInt16(data, os + 2)
      const details = {}
      if (obstacleSize >= 6) {
        details[ATTR_TYPE] = this.#getInt16(data, os + 4)
        if (KNOWN_OBSTACLE_TYPES[details[ATTR_TYPE]]) {
          details[ATTR_DESCRIPTION] = KNOWN_OBSTACLE_TYPES[details[ATTR_TYPE]]
        }
        if (obstacleSize >= 10) {
          const u1 = this.#getInt16(data, os + 6)
          const u2 = this.#getInt16(data, os + 8)
          details[ATTR_CONFIDENCE_LEVEL] = !u2 ? 0 : (u1 * 10.0) / u2
          if (obstacleSize === 28 && (data[os + 12] & 0xff) > 0) {
            const txt = this.#getBytes(data, os + 12, 16)
            details[ATTR_PHOTO_NAME] = txt.toString('ascii')
          }
        }
      }
      obstacles.push(new Obstacle(x, y, details))
    }
    return obstacles
  }

  #parseZones(data, header) {
    const zonePairs = this.#getInt16(header, 0x08)
    const zones = []
    for (let z = 0; z < zonePairs * 8; z += 8) {
      const x0 = this.#getInt16(data, z)
      const y0 = this.#getInt16(data, z + 2)
      const x1 = this.#getInt16(data, z + 4)
      const y1 = this.#getInt16(data, z + 6)
      zones.push(new Zone(x0, y0, x1, y1))
    }
    return zones
  }

  #parsePath(blockStartPosition, header) {
    const pathPoints = []
    const endPos = this.#getInt32(header, 0x04)
    const pointLength = this.#getInt32(header, 0x08)
    const pointSize = this.#getInt32(header, 0x0c)
    const angle = this.#getInt32(header, 0x10)
    const startPos = blockStartPosition + 0x14

    for (let pos = startPos; pos < startPos + endPos; pos += 4) {
      const x = this.#getInt16(this.raw, pos)
      const y = this.#getInt16(this.raw, pos + 2)
      pathPoints.push(new Point(x, y))
    }

    return new Path(pointLength, pointSize, angle, [pathPoints])
  }

  #parseMopPath(path, mask) {
    if (!path || !path.path) return null
    const mopPaths = []
    let pointsNum = 0
    for (const eachPath of path.path) {
      let mopPathPoints = []
      for (let i = 0; i < eachPath.length; i++) {
        if (mask[i]) {
          mopPathPoints.push(eachPath[i])
          if (i + 1 < mask.length && !mask[i + 1]) {
            pointsNum += mopPathPoints.length
            mopPaths.push(mopPathPoints)
            mopPathPoints = []
          }
        }
      }
      pointsNum += mopPathPoints.length
      mopPaths.push(mopPathPoints)
    }
    return new Path(pointsNum, path.pointSize, path.angle, mopPaths)
  }

  #parseArea(header, data) {
    const areaPairs = this.#getInt16(header, 0x08)
    const areas = []
    for (let a = 0; a < areaPairs * 16; a += 16) {
      const x0 = this.#getInt16(data, a)
      const y0 = this.#getInt16(data, a + 2)
      const x1 = this.#getInt16(data, a + 4)
      const y1 = this.#getInt16(data, a + 6)
      const x2 = this.#getInt16(data, a + 8)
      const y2 = this.#getInt16(data, a + 10)
      const x3 = this.#getInt16(data, a + 12)
      const y3 = this.#getInt16(data, a + 14)
      areas.push(new Area(x0, y0, x1, y1, x2, y2, x3, y3))
    }
    return areas
  }

  #parseCarpetMap(data) {
    const carpetMap = new Set()
    data.forEach((v, i) => {
      if (v) carpetMap.add(i)
    })
    return carpetMap
  }

  #getBytes(data, startIndex, size) {
    return data.slice(startIndex, startIndex + size)
  }

  #getInt8(data, address) {
    return data.readUInt8(address)
  }

  #getInt16(data, address) {
    return data.readUInt16LE(address)
  }

  #getInt32(data, address) {
    return data.readUInt32LE(address)
  }
}

export default RoborockMap

Thank you for an awesome library <3