feat: use newer eufy device api

* Adding L60 SES support

* Update custom_components/robovac/vacuums/T2267.py

Co-authored-by: Luke Morrigan <luke@lukeb.co.uk>

---------

Co-authored-by: Luke Morrigan <luke@lukeb.co.uk>

.github/workflows/release.yaml

@@ -2,6 +2,9 @@ on:
     push:
         branches:
             - main
+    pull_request:
+        branches:
+            - main
     workflow_dispatch:
 
 jobs:

custom_components/robovac/config_flow.py

@@ -14,7 +14,6 @@
 
 """Config flow for Eufy Robovac integration."""
 from __future__ import annotations
-import json
 
 import logging
 from typing import Any, Optional
@@ -133,31 +132,31 @@ def get_eufy_vacuums(self):
         phone_code=self[CONF_COUNTRY_CODE],
     )
 
-    items = device_response["items"]
+    items = device_response["devices"]
     self[CONF_VACS] = {}
     for item in items:
-        if item["device"]["product"]["appliance"] == "Cleaning":
+        if item["product"]["appliance"] == "Cleaning":
             try:
-                device = tuya_client.get_device(item["device"]["id"])
+                device = tuya_client.get_device(item["id"])
+                _LOGGER.debug("Robovac schema: {}".format(device["schema"]))
 
                 vac_details = {
-                    CONF_ID: item["device"]["id"],
-                    CONF_MODEL: item["device"]["product"]["product_code"],
-                    CONF_NAME: item["device"]["alias_name"],
-                    CONF_DESCRIPTION: item["device"]["name"],
-                    CONF_MAC: item["device"]["wifi"]["mac"],
+                    CONF_ID: item["id"],
+                    CONF_MODEL: item["product"]["product_code"],
+                    CONF_NAME: item["alias_name"],
+                    CONF_DESCRIPTION: item["name"],
+                    CONF_MAC: item["wifi"]["mac"],
                     CONF_IP_ADDRESS: "",
                     CONF_AUTODISCOVERY: True,
                     CONF_ACCESS_TOKEN: device["localKey"],
                 }
-                self[CONF_VACS][item["device"]["id"]] = vac_details
+                self[CONF_VACS][item["id"]] = vac_details
             except:
                 _LOGGER.debug(
-                    "Skipping vacuum {}: found on Eufy but not on Tuya. Eufy details:".format(
-                        item["device"]["id"]
+                    "Vacuum {} found on Eufy, but not on Tuya. Skipping.".format(
+                        item["id"]
                     )
                 )
-                _LOGGER.debug(json.dumps(item["device"], indent=2))
 
     return response
 

custom_components/robovac/eufywebapi.py

@@ -39,7 +39,7 @@ class EufyLogon:
         return requests.request("GET", setting_url, headers=eufyheaders, timeout=1.5)
 
     def get_device_info(self, url, userid, token):
-        device_url = url + "/v1/device/list/devices-and-groups"
+        device_url = url + "/v1/device/v2"
         eufyheaders["token"] = token
         eufyheaders["id"] = userid
         return requests.request("GET", device_url, headers=eufyheaders)

custom_components/robovac/robovac.py

@@ -1,107 +1,6 @@
-from enum import IntEnum
-from homeassistant.components.vacuum import VacuumEntityFeature
+from .vacuums.base import RobovacCommand
 from .tuyalocalapi import TuyaDevice
-
-
-class RoboVacEntityFeature(IntEnum):
-    """Supported features of the RoboVac entity."""
-
-    EDGE = 1
-    SMALL_ROOM = 2
-    CLEANING_TIME = 4
-    CLEANING_AREA = 8
-    DO_NOT_DISTURB = 16
-    AUTO_RETURN = 32
-    CONSUMABLES = 64
-    ROOM = 128
-    ZONE = 256
-    MAP = 512
-    BOOST_IQ = 1024
-
-
-ROBOVAC_SERIES = {
-    "C": [
-        "T2103",
-        "T2117",
-        "T2118",
-        "T2119",
-        "T2120",
-        "T2123",
-        "T2128",
-        "T2130",
-        "T2132",
-    ],
-    "G": [
-        "T1250",
-        "T2250",
-        "T2251",
-        "T2252",
-        "T2253",
-        "T2254",
-        "T2150",
-        "T2255",
-        "T2256",
-        "T2257",
-        "T2258",
-        "T2259",
-        "T2270",
-        "T2272",
-        "T2273",
-    ],
-    "L": ["T2181", "T2182", "T2190", "T2192", "T2193", "T2194"],
-    "X": ["T2261", "T2262", "T2320"],
-}
-
-HAS_MAP_FEATURE = ["T2253", *ROBOVAC_SERIES["L"], *ROBOVAC_SERIES["X"]]
-
-HAS_CONSUMABLES = [
-    "T1250",
-    "T2181",
-    "T2182",
-    "T2190",
-    "T2193",
-    "T2194",
-    "T2253",
-    "T2256",
-    "T2258",
-    "T2261",
-    "T2273",
-    "T2320",
-]
-
-ROBOVAC_SERIES_FEATURES = {
-    "C": RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM,
-    "G": RoboVacEntityFeature.CLEANING_TIME
-    | RoboVacEntityFeature.CLEANING_AREA
-    | RoboVacEntityFeature.DO_NOT_DISTURB
-    | RoboVacEntityFeature.AUTO_RETURN,
-    "L": RoboVacEntityFeature.CLEANING_TIME
-    | RoboVacEntityFeature.CLEANING_AREA
-    | RoboVacEntityFeature.DO_NOT_DISTURB
-    | RoboVacEntityFeature.AUTO_RETURN
-    | RoboVacEntityFeature.ROOM
-    | RoboVacEntityFeature.ZONE
-    | RoboVacEntityFeature.BOOST_IQ,
-    "X": RoboVacEntityFeature.CLEANING_TIME
-    | RoboVacEntityFeature.CLEANING_AREA
-    | RoboVacEntityFeature.DO_NOT_DISTURB
-    | RoboVacEntityFeature.AUTO_RETURN
-    | RoboVacEntityFeature.ROOM
-    | RoboVacEntityFeature.ZONE
-    | RoboVacEntityFeature.BOOST_IQ,
-}
-
-ROBOVAC_SERIES_FAN_SPEEDS = {
-    "C": ["No Suction", "Standard", "Boost IQ", "Max"],
-    "G": ["Standard", "Turbo", "Max", "Boost IQ"],
-    "L": ["Quiet", "Standard", "Turbo", "Max"],
-    "X": ["Pure", "Standard", "Turbo", "Max"],
-}
-
-
-SUPPORTED_ROBOVAC_MODELS = list(
-    set([item for sublist in ROBOVAC_SERIES.values() for item in sublist])
-)
+from .vacuums import ROBOVAC_MODELS
 
 
 class ModelNotSupportedException(Exception):
@@ -112,48 +11,35 @@ class RoboVac(TuyaDevice):
     """"""
 
     def __init__(self, model_code, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.model_code = model_code
-
-        if self.model_code not in SUPPORTED_ROBOVAC_MODELS:
+        if model_code not in ROBOVAC_MODELS:
             raise ModelNotSupportedException(
-                "Model {} is not supported".format(self.model_code)
+                "Model {} is not supported".format(model_code)
             )
 
+        self.model_details = ROBOVAC_MODELS[model_code]
+        super().__init__(self.model_details, *args, **kwargs)
+
     def getHomeAssistantFeatures(self):
-        supportedFeatures = (
-            VacuumEntityFeature.BATTERY
-            | VacuumEntityFeature.CLEAN_SPOT
-            | VacuumEntityFeature.FAN_SPEED
-            | VacuumEntityFeature.LOCATE
-            | VacuumEntityFeature.PAUSE
-            | VacuumEntityFeature.RETURN_HOME
-            | VacuumEntityFeature.SEND_COMMAND
-            | VacuumEntityFeature.START
-            | VacuumEntityFeature.STATE
-            | VacuumEntityFeature.STOP
-        )
-
-        if self.model_code in HAS_MAP_FEATURE:
-            supportedFeatures |= VacuumEntityFeature.MAP
-
-        return supportedFeatures
+        return self.model_details.homeassistant_features
 
     def getRoboVacFeatures(self):
-        supportedFeatures = ROBOVAC_SERIES_FEATURES[self.getRoboVacSeries()]
-
-        if self.model_code in HAS_MAP_FEATURE:
-            supportedFeatures |= RoboVacEntityFeature.MAP
-
-        if self.model_code in HAS_CONSUMABLES:
-            supportedFeatures |= RoboVacEntityFeature.CONSUMABLES
-
-        return supportedFeatures
-
-    def getRoboVacSeries(self):
-        for series, models in ROBOVAC_SERIES.items():
-            if self.model_code in models:
-                return series
+        return self.model_details.robovac_features
 
     def getFanSpeeds(self):
-        return ROBOVAC_SERIES_FAN_SPEEDS[self.getRoboVacSeries()]
+        return self.model_details.commands[RobovacCommand.FAN_SPEED]["values"]
+
+    def getModes(self):
+        return self.model_details.commands[RobovacCommand.MODE]["values"]
+
+    def getSupportedCommands(self):
+        return list(self.model_details.commands.keys())
+
+    def getCommandCodes(self):
+        command_codes = {}
+        for key, value in self.model_details.commands.items():
+            if isinstance(value, dict):
+                command_codes[key] = str(value["code"])
+            else:
+                command_codes[key] = str(value)
+
+        return command_codes

custom_components/robovac/tuyalocalapi.py

@@ -54,6 +54,8 @@ from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 from cryptography.hazmat.primitives.hashes import Hash, MD5
 from cryptography.hazmat.primitives.padding import PKCS7
 
+from .vacuums.base import RobovacCommand
+
 INITIAL_BACKOFF = 5
 INITIAL_QUEUE_TIME = 0.1
 BACKOFF_MULTIPLIER = 1.70224
@@ -604,6 +606,7 @@ class TuyaDevice:
 
     def __init__(
         self,
+        model_details,
         device_id,
         host,
         timeout,
@@ -616,6 +619,7 @@ class TuyaDevice:
     ):
         """Initialize the device."""
         self._LOGGER = _LOGGER.getChild(device_id)
+        self.model_details = model_details
         self.device_id = device_id
         self.host = host
         self.port = port
@@ -717,7 +721,9 @@ class TuyaDevice:
         try:
             sock.connect((self.host, self.port))
         except (socket.timeout, TimeoutError) as e:
-            self._dps["106"] = "CONNECTION_FAILED"
+            self._dps[self.model_details.commands[RobovacCommand.ERROR]] = (
+                "CONNECTION_FAILED"
+            )
             raise ConnectionTimeoutException("Connection timed out")
         loop = asyncio.get_running_loop()
         loop.create_connection
@@ -744,6 +750,7 @@ class TuyaDevice:
 
         if self.writer is not None:
             self.writer.close()
+            await self.writer.wait_closed()
 
         if self.reader is not None and not self.reader.at_eof():
             self.reader.feed_eof()
@@ -754,7 +761,7 @@ class TuyaDevice:
         message = Message(Message.GET_COMMAND, payload, encrypt=encrypt, device=self)
         self._queue.append(message)
         response = await self.async_recieve(message)
-        asyncio.create_task(self.async_update_state(response))
+        await self.async_update_state(response)
 
     async def async_set(self, dps):
         t = int(time.time())
@@ -896,9 +903,6 @@ class TuyaDevice:
             await self._async_send(message, retries=retries - 1)
 
     async def async_recieve(self, message):
-        if self._connected is False:
-            return
-
         if message.expect_response is True:
             try:
                 self._recieve_task = asyncio.create_task(

custom_components/robovac/vacuum.py

@@ -29,7 +29,6 @@ from enum import IntEnum, StrEnum
 from homeassistant.loader import bind_hass
 from homeassistant.components.vacuum import (
     StateVacuumEntity,
-    VacuumEntityFeature,
     STATE_CLEANING,
     STATE_DOCKED,
     STATE_ERROR,
@@ -55,15 +54,15 @@ from homeassistant.const import (
     STATE_UNAVAILABLE,
 )
 
+from .vacuums.base import RoboVacEntityFeature, RobovacCommand
+
 from .tuyalocalapi import TuyaException
 from .const import CONF_VACS, DOMAIN, REFRESH_RATE, PING_RATE, TIMEOUT
 
 from .errors import getErrorMessage
 from .robovac import (
-    SUPPORTED_ROBOVAC_MODELS,
     ModelNotSupportedException,
     RoboVac,
-    RoboVacEntityFeature,
 )
 
 from homeassistant.const import ATTR_BATTERY_LEVEL
@@ -88,22 +87,6 @@ SCAN_INTERVAL = timedelta(seconds=REFRESH_RATE)
 UPDATE_RETRIES = 3
 
 
-class TUYA_CODES(StrEnum):
-    BATTERY_LEVEL = "104"
-    STATE = "15"
-    ERROR_CODE = "106"
-    MODE = "5"
-    FAN_SPEED = "102"
-    CLEANING_AREA = "110"
-    CLEANING_TIME = "109"
-    AUTO_RETURN = "135"
-    DO_NOT_DISTURB = "107"
-    BOOST_IQ = "118"
-
-
-TUYA_CONSUMABLES_CODES = ["142", "116"]
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: ConfigEntry,
@@ -283,7 +266,16 @@ class RoboVacEntity(StateVacuumEntity):
 
         self._attr_supported_features = self.vacuum.getHomeAssistantFeatures()
         self._attr_robovac_supported = self.vacuum.getRoboVacFeatures()
-        self._attr_fan_speed_list = self.vacuum.getFanSpeeds()
+
+        fan_speeds = self.vacuum.getFanSpeeds()
+        self.fan_speed_map = {}
+
+        for speed in fan_speeds:
+            self.fan_speed_map[friendly_text(speed)] = speed
+
+        self._attr_fan_speed_list = list(self.fan_speed_map.keys())
+        _LOGGER.debug(self._attr_fan_speed_list)
+        self._tuya_command_codes = self.vacuum.getCommandCodes()
 
         self._attr_mode = None
         self._attr_consumables = None
@@ -301,19 +293,14 @@ class RoboVacEntity(StateVacuumEntity):
         self.tuya_state = None
         self.tuyastatus = None
 
+    async def async_added_to_hass(self):
+        await self.async_forced_update()
+
     async def async_update(self):
         """Synchronise state from the vacuum."""
-        if self.error_code == "UNSUPPORTED_MODEL":
-            return
-
-        if self.ip_address == "":
-            self.error_code = "IP_ADDRESS"
-            return
-
         try:
-            await self.vacuum.async_get()
+            await self.async_update_vacuum()
             self.update_failures = 0
-            self.update_entity_values()
         except TuyaException as e:
             self.update_failures += 1
             _LOGGER.warn(
@@ -324,6 +311,21 @@ class RoboVacEntity(StateVacuumEntity):
             if self.update_failures >= UPDATE_RETRIES:
                 self.error_code = "CONNECTION_FAILED"
 
+    async def async_update_vacuum(self):
+        if self.error_code == "UNSUPPORTED_MODEL":
+            return
+
+        if self.ip_address == "":
+            self.error_code = "IP_ADDRESS"
+            return
+
+        await self.vacuum.async_get()
+        self.update_entity_values()
+
+    async def async_forced_update(self):
+        await self.async_update_vacuum()
+        self.async_write_ha_state()
+
     async def pushed_update_handler(self):
         self.update_entity_values()
         self.async_write_ha_state()
@@ -331,81 +333,117 @@ class RoboVacEntity(StateVacuumEntity):
     def update_entity_values(self):
         self.tuyastatus = self.vacuum._dps
 
-        # for 15C
-        self._attr_battery_level = self.tuyastatus.get(TUYA_CODES.BATTERY_LEVEL)
-        self.tuya_state = self.tuyastatus.get(TUYA_CODES.STATE)
-        self.error_code = self.tuyastatus.get(TUYA_CODES.ERROR_CODE)
-        self._attr_mode = self.tuyastatus.get(TUYA_CODES.MODE)
-        self._attr_fan_speed = self.tuyastatus.get(TUYA_CODES.FAN_SPEED)
-        if self.fan_speed == "No_suction":
-            self._attr_fan_speed = "No Suction"
-        elif self.fan_speed == "Boost_IQ":
-            self._attr_fan_speed = "Boost IQ"
-        elif self.fan_speed == "Quiet":
-            self._attr_fan_speed = "Pure"
-        # for G30
-        self._attr_cleaning_area = self.tuyastatus.get(TUYA_CODES.CLEANING_AREA)
-        self._attr_cleaning_time = self.tuyastatus.get(TUYA_CODES.CLEANING_TIME)
-        self._attr_auto_return = self.tuyastatus.get(TUYA_CODES.AUTO_RETURN)
-        self._attr_do_not_disturb = self.tuyastatus.get(TUYA_CODES.DO_NOT_DISTURB)
-        self._attr_boost_iq = self.tuyastatus.get(TUYA_CODES.BOOST_IQ)
-        # self.map_data = self.tuyastatus.get("121")
-        # self.erro_msg? = self.tuyastatus.get("124")
+        self._attr_battery_level = self.tuyastatus.get(
+            self._tuya_command_codes[RobovacCommand.BATTERY]
+        )
+        self.tuya_state = self.tuyastatus.get(
+            self._tuya_command_codes[RobovacCommand.STATUS]
+        )
+        self.error_code = self.tuyastatus.get(
+            self._tuya_command_codes[RobovacCommand.ERROR]
+        )
+        self._attr_mode = self.tuyastatus.get(
+            self._tuya_command_codes[RobovacCommand.MODE]
+        )
+        self._attr_fan_speed = friendly_text(
+            self.tuyastatus.get(self._tuya_command_codes[RobovacCommand.FAN_SPEED], "")
+        )
+
+        if self.robovac_supported & RoboVacEntityFeature.CLEANING_AREA:
+            self._attr_cleaning_area = self.tuyastatus.get(
+                self._tuya_command_codes[RobovacCommand.CLEANING_AREA]
+            )
+
+        if self.robovac_supported & RoboVacEntityFeature.CLEANING_TIME:
+            self._attr_cleaning_time = self.tuyastatus.get(
+                self._tuya_command_codes[RobovacCommand.CLEANING_TIME]
+            )
+
+        if self.robovac_supported & RoboVacEntityFeature.AUTO_RETURN:
+            self._attr_auto_return = self.tuyastatus.get(
+                self._tuya_command_codes[RobovacCommand.AUTO_RETURN]
+            )
+
+        if self.robovac_supported & RoboVacEntityFeature.DO_NOT_DISTURB:
+            self._attr_do_not_disturb = self.tuyastatus.get(
+                self._tuya_command_codes[RobovacCommand.DO_NOT_DISTURB]
+            )
+
+        if self.robovac_supported & RoboVacEntityFeature.BOOST_IQ:
+            self._attr_boost_iq = self.tuyastatus.get(
+                self._tuya_command_codes[RobovacCommand.BOOST_IQ]
+            )
+
         if self.robovac_supported & RoboVacEntityFeature.CONSUMABLES:
-            for CONSUMABLE_CODE in TUYA_CONSUMABLES_CODES:
-                if (
-                    CONSUMABLE_CODE in self.tuyastatus
-                    and self.tuyastatus.get(CONSUMABLE_CODE) is not None
-                ):
-                    consumables = ast.literal_eval(
-                        base64.b64decode(self.tuyastatus.get(CONSUMABLE_CODE)).decode(
-                            "ascii"
-                        )
+            consumables = ast.literal_eval(
+                base64.b64decode(
+                    self.tuyastatus.get(
+                        self._tuya_command_codes[RobovacCommand.CONSUMABLES]
                     )
-                    if (
-                        "consumable" in consumables
-                        and "duration" in consumables["consumable"]
-                    ):
-                        self._attr_consumables = consumables["consumable"]["duration"]
+                ).decode("ascii")
+            )
+            _LOGGER.debug("Consumables decoded value is: {}".format(consumables))
+            if "consumable" in consumables and "duration" in consumables["consumable"]:
+                _LOGGER.debug(
+                    "Consumables encoded value is: {}".format(
+                        consumables["consumable"]["duration"]
+                    )
+                )
+                self._attr_consumables = consumables["consumable"]["duration"]
 
     async def async_locate(self, **kwargs):
         """Locate the vacuum cleaner."""
         _LOGGER.info("Locate Pressed")
-        if self.tuyastatus.get("103"):
-            await self.vacuum.async_set({"103": False})
+        code = self._tuya_command_codes[RobovacCommand.LOCATE]
+        if self.tuyastatus.get(code):
+            await self.vacuum.async_set({code: False})
         else:
-            await self.vacuum.async_set({"103": True})
+            await self.vacuum.async_set({code: True})
+        asyncio.create_task(self.async_forced_update())
 
     async def async_return_to_base(self, **kwargs):
         """Set the vacuum cleaner to return to the dock."""
         _LOGGER.info("Return home Pressed")
-        await self.vacuum.async_set({"101": True})
+        await self.vacuum.async_set(
+            {self._tuya_command_codes[RobovacCommand.RETURN_HOME]: True}
+        )
+        asyncio.create_task(self.async_forced_update())
 
     async def async_start(self, **kwargs):
-        self._attr_mode = "auto"
-        await self.vacuum.async_set({"5": self.mode})
+        await self.vacuum.async_set(
+            {self._tuya_command_codes[RobovacCommand.START_PAUSE]: True}
+        )
+        asyncio.create_task(self.async_forced_update())
 
     async def async_pause(self, **kwargs):
-        await self.vacuum.async_set({"2": False})
+        await self.vacuum.async_set(
+            {self._tuya_command_codes[RobovacCommand.START_PAUSE]: False}
+        )
+        asyncio.create_task(self.async_forced_update())
 
     async def async_stop(self, **kwargs):
         await self.async_return_to_base()
+        asyncio.create_task(self.async_forced_update())
 
     async def async_clean_spot(self, **kwargs):
         """Perform a spot clean-up."""
         _LOGGER.info("Spot Clean Pressed")
-        await self.vacuum.async_set({"5": "Spot"})
+        await self.vacuum.async_set(
+            {self._tuya_command_codes[RobovacCommand.MODE]: "Spot"}
+        )
+        asyncio.create_task(self.async_forced_update())
 
     async def async_set_fan_speed(self, fan_speed, **kwargs):
         """Set fan speed."""
         _LOGGER.info("Fan Speed Selected")
-        if fan_speed == "No Suction":
-            fan_speed = "No_suction"
-        elif fan_speed == "Boost IQ":
-            fan_speed = "Boost_IQ"
-        elif fan_speed == "Pure":
-            fan_speed = "Quiet"
-        await self.vacuum.async_set({"102": fan_speed})
+        await self.vacuum.async_set(
+            {
+                self._tuya_command_codes[RobovacCommand.FAN_SPEED]: self.fan_speed_map[
+                    fan_speed
+                ]
+            }
+        )
+        asyncio.create_task(self.async_forced_update())
 
     async def async_send_command(
         self, command: str, params: dict | list | None = None, **kwargs
@@ -448,6 +486,13 @@ class RoboVacEntity(StateVacuumEntity):
             base64_str = base64.b64encode(json_str.encode("utf8")).decode("utf8")
             _LOGGER.info("roomClean call %s", json_str)
             await self.vacuum.async_set({"124": base64_str})
+        asyncio.create_task(self.async_forced_update())
 
     async def async_will_remove_from_hass(self):
         await self.vacuum.async_disable()
+
+
+def friendly_text(input):
+    return " ".join(
+        word[0].upper() + word[1:] for word in input.replace("_", " ").split()
+    )

custom_components/robovac/vacuums/T1250.py

@@ -0,0 +1,44 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T1250:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2103.py

@@ -0,0 +1,38 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2103:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["No_suction","Standard","Boost_IQ","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+    }

custom_components/robovac/vacuums/T2117.py

@@ -0,0 +1,38 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2117:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["No_suction","Standard","Boost_IQ","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+    }

custom_components/robovac/vacuums/T2118.py

@@ -0,0 +1,38 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2118:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["No_suction","Standard","Boost_IQ","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+    }

custom_components/robovac/vacuums/T2119.py

@@ -0,0 +1,38 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2119:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["No_suction","Standard","Boost_IQ","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+    }

custom_components/robovac/vacuums/T2120.py

@@ -0,0 +1,38 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2120:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["No_suction","Standard","Boost_IQ","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+    }

custom_components/robovac/vacuums/T2123.py

@@ -0,0 +1,38 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2123:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["No_suction","Standard","Boost_IQ","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+    }

custom_components/robovac/vacuums/T2128.py

@@ -0,0 +1,38 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2128:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["No_suction","Standard","Boost_IQ","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+    }

custom_components/robovac/vacuums/T2130.py

@@ -0,0 +1,38 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2130:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["No_suction","Standard","Boost_IQ","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+    }

custom_components/robovac/vacuums/T2132.py

@@ -0,0 +1,38 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2132:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.EDGE | RoboVacEntityFeature.SMALL_ROOM
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["No_suction","Standard","Boost_IQ","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+    }

custom_components/robovac/vacuums/T2150.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2150:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2181.py

@@ -0,0 +1,46 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2181:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.ROOM | RoboVacEntityFeature.ZONE | RoboVacEntityFeature.BOOST_IQ | RoboVacEntityFeature.MAP | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Quiet","Standard","Turbo","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.BOOST_IQ: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2182.py

@@ -0,0 +1,46 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2182:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.ROOM | RoboVacEntityFeature.ZONE | RoboVacEntityFeature.BOOST_IQ | RoboVacEntityFeature.MAP | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Quiet","Standard","Turbo","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.BOOST_IQ: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2190.py

@@ -0,0 +1,46 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2190:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.ROOM | RoboVacEntityFeature.ZONE | RoboVacEntityFeature.BOOST_IQ | RoboVacEntityFeature.MAP | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Quiet","Standard","Turbo","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.BOOST_IQ: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2192.py

@@ -0,0 +1,45 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2192:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.ROOM | RoboVacEntityFeature.ZONE | RoboVacEntityFeature.BOOST_IQ | RoboVacEntityFeature.MAP
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Quiet","Standard","Turbo","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.BOOST_IQ: 0,
+    }

custom_components/robovac/vacuums/T2193.py

@@ -0,0 +1,46 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2193:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.ROOM | RoboVacEntityFeature.ZONE | RoboVacEntityFeature.BOOST_IQ | RoboVacEntityFeature.MAP | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Quiet","Standard","Turbo","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.BOOST_IQ: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2194.py

@@ -0,0 +1,46 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2194:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.ROOM | RoboVacEntityFeature.ZONE | RoboVacEntityFeature.BOOST_IQ | RoboVacEntityFeature.MAP | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Quiet","Standard","Turbo","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.BOOST_IQ: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2250.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2250:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2251.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2251:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2252.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2252:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2253.py

@@ -0,0 +1,45 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2253:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.MAP | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2254.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2254:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2255.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2255:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2256.py

@@ -0,0 +1,44 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2256:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2257.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2257:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2258.py

@@ -0,0 +1,44 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2258:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2259.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2259:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2261.py

@@ -0,0 +1,46 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2261:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.ROOM | RoboVacEntityFeature.ZONE | RoboVacEntityFeature.BOOST_IQ | RoboVacEntityFeature.MAP | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Pure","Standard","Turbo","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.BOOST_IQ: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2262.py

@@ -0,0 +1,45 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2262:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.ROOM | RoboVacEntityFeature.ZONE | RoboVacEntityFeature.BOOST_IQ | RoboVacEntityFeature.MAP
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Pure","Standard","Turbo","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.BOOST_IQ: 0,
+    }

custom_components/robovac/vacuums/T2267.py

@@ -0,0 +1,56 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2267:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = (
+        RoboVacEntityFeature.CLEANING_TIME
+        | RoboVacEntityFeature.CLEANING_AREA
+        | RoboVacEntityFeature.DO_NOT_DISTURB
+        | RoboVacEntityFeature.AUTO_RETURN
+        | RoboVacEntityFeature.ROOM
+        | RoboVacEntityFeature.ZONE
+        | RoboVacEntityFeature.BOOST_IQ
+        | RoboVacEntityFeature.MAP
+        | RoboVacEntityFeature.CONSUMABLES
+    )
+    commands = {
+        RobovacCommand.START_PAUSE: 156,
+        RobovacCommand.DIRECTION: {
+            "code": 155,
+            "values": ["Brake", "Forward", "Back", "Left", "Right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 152,
+            # "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 153,
+        RobovacCommand.RETURN_HOME: 173,
+        RobovacCommand.FAN_SPEED: {
+            "code": 158,
+            "values": ["Quiet", "Standard", "Turbo", "Max"],
+        },
+        RobovacCommand.LOCATE: 160,
+        RobovacCommand.BATTERY: 163,
+        RobovacCommand.ERROR: 177,
+        RobovacCommand.DO_NOT_DISTURB: 157,
+        RobovacCommand.BOOST_IQ: 159,
+        RobovacCommand.CONSUMABLES: 168,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+    }

custom_components/robovac/vacuums/T2270.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2270:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2272.py

@@ -0,0 +1,43 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2272:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+    }

custom_components/robovac/vacuums/T2273.py

@@ -0,0 +1,44 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2273:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Standard","Turbo","Max","Boost_IQ"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/T2320.py

@@ -0,0 +1,46 @@
+from homeassistant.components.vacuum import VacuumEntityFeature
+from .base import RoboVacEntityFeature, RobovacCommand
+
+
+class T2320:
+    homeassistant_features = (
+        VacuumEntityFeature.BATTERY
+        | VacuumEntityFeature.CLEAN_SPOT
+        | VacuumEntityFeature.FAN_SPEED
+        | VacuumEntityFeature.LOCATE
+        | VacuumEntityFeature.PAUSE
+        | VacuumEntityFeature.RETURN_HOME
+        | VacuumEntityFeature.SEND_COMMAND
+        | VacuumEntityFeature.START
+        | VacuumEntityFeature.STATE
+        | VacuumEntityFeature.STOP
+        | VacuumEntityFeature.MAP
+    )
+    robovac_features = RoboVacEntityFeature.CLEANING_TIME | RoboVacEntityFeature.CLEANING_AREA | RoboVacEntityFeature.DO_NOT_DISTURB | RoboVacEntityFeature.AUTO_RETURN | RoboVacEntityFeature.ROOM | RoboVacEntityFeature.ZONE | RoboVacEntityFeature.BOOST_IQ | RoboVacEntityFeature.MAP | RoboVacEntityFeature.CONSUMABLES
+    commands = {
+        RobovacCommand.START_PAUSE: 2,
+        RobovacCommand.DIRECTION: {
+            "code": 3,
+            "values": ["forward", "back", "left", "right"],
+        },
+        RobovacCommand.MODE: {
+            "code": 5,
+            "values": ["auto", "SmallRoom", "Spot", "Edge", "Nosweep"],
+        },
+        RobovacCommand.STATUS: 15,
+        RobovacCommand.RETURN_HOME: 101,
+        RobovacCommand.FAN_SPEED: {
+            "code": 102,
+            "values": ["Pure","Standard","Turbo","Max"],
+        },
+        RobovacCommand.LOCATE: 103,
+        RobovacCommand.BATTERY: 104,
+        RobovacCommand.ERROR: 106,
+        # These commands need codes adding
+        # RobovacCommand.CLEANING_AREA: 0,
+        # RobovacCommand.CLEANING_TIME: 0,
+        # RobovacCommand.AUTO_RETURN: 0,
+        # RobovacCommand.DO_NOT_DISTURB: 0,
+        # RobovacCommand.BOOST_IQ: 0,
+        # RobovacCommand.CONSUMABLES: 0,
+    }

custom_components/robovac/vacuums/__init__.py

@@ -0,0 +1,72 @@
+from .T2103 import T2103
+from .T2117 import T2117
+from .T2118 import T2118
+from .T2119 import T2119
+from .T2120 import T2120
+from .T2123 import T2123
+from .T2128 import T2128
+from .T2130 import T2130
+from .T2132 import T2132
+from .T1250 import T1250
+from .T2250 import T2250
+from .T2251 import T2251
+from .T2252 import T2252
+from .T2253 import T2253
+from .T2254 import T2254
+from .T2150 import T2150
+from .T2255 import T2255
+from .T2256 import T2256
+from .T2257 import T2257
+from .T2258 import T2258
+from .T2259 import T2259
+from .T2270 import T2270
+from .T2272 import T2272
+from .T2273 import T2273
+from .T2181 import T2181
+from .T2182 import T2182
+from .T2190 import T2190
+from .T2192 import T2192
+from .T2193 import T2193
+from .T2194 import T2194
+from .T2267 import T2267
+from .T2261 import T2261
+from .T2262 import T2262
+from .T2320 import T2320
+
+
+ROBOVAC_MODELS = {
+    "T2103": T2103,
+    "T2117": T2117,
+    "T2118": T2118,
+    "T2119": T2119,
+    "T2120": T2120,
+    "T2123": T2123,
+    "T2128": T2128,
+    "T2130": T2130,
+    "T2132": T2132,
+    "T1250": T1250,
+    "T2250": T2250,
+    "T2251": T2251,
+    "T2252": T2252,
+    "T2253": T2253,
+    "T2254": T2254,
+    "T2150": T2150,
+    "T2255": T2255,
+    "T2256": T2256,
+    "T2257": T2257,
+    "T2258": T2258,
+    "T2259": T2259,
+    "T2270": T2270,
+    "T2272": T2272,
+    "T2273": T2273,
+    "T2181": T2181,
+    "T2182": T2182,
+    "T2190": T2190,
+    "T2192": T2192,
+    "T2193": T2193,
+    "T2194": T2194,
+    "T2267": T2267,
+    "T2261": T2261,
+    "T2262": T2262,
+    "T2320": T2320
+}

custom_components/robovac/vacuums/base.py

@@ -0,0 +1,35 @@
+from enum import IntEnum, StrEnum
+
+
+class RoboVacEntityFeature(IntEnum):
+    """Supported features of the RoboVac entity."""
+
+    EDGE = 1
+    SMALL_ROOM = 2
+    CLEANING_TIME = 4
+    CLEANING_AREA = 8
+    DO_NOT_DISTURB = 16
+    AUTO_RETURN = 32
+    CONSUMABLES = 64
+    ROOM = 128
+    ZONE = 256
+    MAP = 512
+    BOOST_IQ = 1024
+
+
+class RobovacCommand(StrEnum):
+    START_PAUSE = "start_pause"
+    DIRECTION = "direction"
+    MODE = "mode"
+    STATUS = "status"
+    RETURN_HOME = "return_home"
+    FAN_SPEED = "fan_speed"
+    LOCATE = "locate"
+    BATTERY = "battery"
+    ERROR = "error"
+    CLEANING_AREA = "cleaning_area"
+    CLEANING_TIME = "cleaning_time"
+    AUTO_RETURN = "auto_return"
+    DO_NOT_DISTURB = "do_not_disturb"
+    BOOST_IQ = "boost_iq"
+    CONSUMABLES = "consumables"