feat: add some basic setters for q7

roborock/data/b01_q7/b01_q7_code_mappings.py

@@ -24,7 +24,6 @@ class SCWindMapping(RoborockModeEnum):
     STANDARD = ("balanced", 1)
     STRONG = ("turbo", 2)
     SUPER_STRONG = ("max", 3)
-    MAX = ("max_plus", 4)
 
 
 class WaterLevelMapping(RoborockModeEnum):
@@ -50,6 +49,14 @@ class CleanRepeatMapping(RoborockModeEnum):
     TWICE = ("twice", 1)
 
 
+class SCDeviceCleanParam(RoborockModeEnum):
+    """Maps the control values for cleaning tasks."""
+
+    STOP = ("stop", 0)
+    START = ("start", 1)
+    PAUSE = ("pause", 2)
+
+
 class WorkModeMapping(RoborockModeEnum):
     """Maps the detailed work modes of the robot."""
 

roborock/devices/b01_channel.py

@@ -28,19 +28,31 @@ async def send_decoded_command(
     dps: int,
     command: CommandType,
     params: ParamsType,
-) -> dict[str, Any]:
+) -> dict | None:
     """Send a command on the MQTT channel and get a decoded response."""
-    _LOGGER.debug("Sending MQTT command: %s", params)
     msg_id = str(get_next_int(100000000000, 999999999999))
+    _LOGGER.debug(
+        "Sending B01 MQTT command: dps=%s method=%s msg_id=%s params=%s",
+        dps,
+        command,
+        msg_id,
+        params,
+    )
     roborock_message = encode_mqtt_payload(dps, command, params, msg_id)
-    future: asyncio.Future[dict[str, Any]] = asyncio.get_running_loop().create_future()
+    future: asyncio.Future[Any] = asyncio.get_running_loop().create_future()
 
     def find_response(response_message: RoborockMessage) -> None:
         """Handle incoming messages and resolve the future."""
         try:
             decoded_dps = decode_rpc_response(response_message)
         except RoborockException as ex:
-            _LOGGER.info("Failed to decode b01 message: %s: %s", response_message, ex)
+            _LOGGER.debug(
+                "Failed to decode B01 RPC response (expecting method=%s msg_id=%s): %s: %s",
+                command,
+                msg_id,
+                response_message,
+                ex,
+            )
             return
 
         for dps_value in decoded_dps.values():
@@ -57,21 +69,50 @@ def find_response(response_message: RoborockMessage) -> None:
 
             if isinstance(inner, dict) and inner.get("msgId") == msg_id:
                 _LOGGER.debug("Received query response: %s", inner)
+                # Check for error code (0 = success, non-zero = error)
+                code = inner.get("code", 0)
+                if code != 0:
+                    error_msg = (
+                        f"B01 command failed with code {code} "
+                        f"(method={command}, msg_id={msg_id}, dps={dps}, params={params})"
+                    )
+                    _LOGGER.debug("B01 error response: %s", error_msg)
+                    if not future.done():
+                        future.set_exception(RoborockException(error_msg))
+                    return
                 data = inner.get("data")
+                # All get commands should be dicts
+                if command.endswith(".get") and not isinstance(data, dict):
+                    if not future.done():
+                        future.set_exception(
+                            RoborockException(
+                                f"Unexpected data type for response "
+                                f"(method={command}, msg_id={msg_id}, dps={dps}, params={params})"
+                            )
+                        )
+                    return
                 if not future.done():
-                    if isinstance(data, dict):
-                        future.set_result(data)
-                    else:
-                        future.set_exception(RoborockException(f"Unexpected data type for response: {data}"))
+                    future.set_result(data)
 
     unsub = await mqtt_channel.subscribe(find_response)
 
     _LOGGER.debug("Sending MQTT message: %s", roborock_message)
     try:
         await mqtt_channel.publish(roborock_message)
-        try:
-            return await asyncio.wait_for(future, timeout=_TIMEOUT)
-        except TimeoutError as ex:
-            raise RoborockException(f"Command timed out after {_TIMEOUT}s") from ex
+        return await asyncio.wait_for(future, timeout=_TIMEOUT)
+    except TimeoutError as ex:
+        raise RoborockException(
+            f"B01 command timed out after {_TIMEOUT}s (method={command}, msg_id={msg_id}, dps={dps}, params={params})"
+        ) from ex
+    except Exception as ex:
+        _LOGGER.exception(
+            "Error sending B01 decoded command (method=%s msg_id=%s dps=%s params=%s): %s",
+            command,
+            msg_id,
+            dps,
+            params,
+            ex,
+        )
+        raise
     finally:
         unsub()

roborock/devices/traits/b01/q7/__init__.py

@@ -1,7 +1,15 @@
 """Traits for Q7 B01 devices.
 Potentially other devices may fall into this category in the future."""
 
+from typing import Any
+
 from roborock import B01Props
+from roborock.data.b01_q7.b01_q7_code_mappings import (
+    CleanTaskTypeMapping,
+    SCDeviceCleanParam,
+    SCWindMapping,
+    WaterLevelMapping,
+)
 from roborock.devices.b01_channel import send_decoded_command
 from roborock.devices.mqtt_channel import MqttChannel
 from roborock.devices.traits import Trait
@@ -22,11 +30,85 @@ def __init__(self, channel: MqttChannel) -> None:
 
     async def query_values(self, props: list[RoborockB01Props]) -> B01Props | None:
         """Query the device for the values of the given Q7 properties."""
-        result = await send_decoded_command(
-            self._channel, dps=10000, command=RoborockB01Q7Methods.GET_PROP, params={"property": props}
+        result = await self.send(
+            RoborockB01Q7Methods.GET_PROP,
+            {"property": props},
         )
+        if not isinstance(result, dict):
+            raise TypeError(f"Unexpected response type for GET_PROP: {type(result).__name__}: {result!r}")
         return B01Props.from_dict(result)
 
+    async def set_prop(self, prop: RoborockB01Props, value: Any) -> Any:
+        """Set a property on the device."""
+        await self.send(
+            command=RoborockB01Q7Methods.SET_PROP,
+            params={prop: value},
+        )
+
+    async def set_fan_speed(self, fan_speed: SCWindMapping) -> Any:
+        """Set the fan speed (wind)."""
+        return await self.set_prop(RoborockB01Props.WIND, fan_speed.code)
+
+    async def set_water_level(self, water_level: WaterLevelMapping) -> Any:
+        """Set the water level (water)."""
+        return await self.set_prop(RoborockB01Props.WATER, water_level.code)
+
+    async def start_clean(self) -> Any:
+        """Start cleaning."""
+        return await self.send(
+            command=RoborockB01Q7Methods.SET_ROOM_CLEAN,
+            params={
+                "clean_type": CleanTaskTypeMapping.ALL.code,
+                "ctrl_value": SCDeviceCleanParam.START.code,
+                "room_ids": [],
+            },
+        )
+
+    async def pause_clean(self) -> Any:
+        """Pause cleaning."""
+        return await self.send(
+            command=RoborockB01Q7Methods.SET_ROOM_CLEAN,
+            params={
+                "clean_type": CleanTaskTypeMapping.ALL.code,
+                "ctrl_value": SCDeviceCleanParam.PAUSE.code,
+                "room_ids": [],
+            },
+        )
+
+    async def stop_clean(self) -> Any:
+        """Stop cleaning."""
+        return await self.send(
+            command=RoborockB01Q7Methods.SET_ROOM_CLEAN,
+            params={
+                "clean_type": CleanTaskTypeMapping.ALL.code,
+                "ctrl_value": SCDeviceCleanParam.STOP.code,
+                "room_ids": [],
+            },
+        )
+
+    async def return_to_dock(self) -> Any:
+        """Return to dock."""
+        return await self.send(
+            command=RoborockB01Q7Methods.START_RECHARGE,
+            params={},
+        )
+
+    async def find_me(self) -> Any:
+        """Locate the robot."""
+        return await self.send(
+            command=RoborockB01Q7Methods.FIND_DEVICE,
+            params={},
+        )
+
+    async def send(self, command: RoborockB01Q7Methods, params: dict) -> Any:
+        """Send a command to the device."""
+        return await send_decoded_command(
+            self._channel,
+            dps=10000,
+            command=command,
+            params=params,
+        )
+
 
 def create(channel: MqttChannel) -> Q7PropertiesApi:
     """Create traits for B01 devices."""

roborock/protocols/b01_protocol.py

@@ -28,7 +28,10 @@ def encode_mqtt_payload(dps: int, command: CommandType, params: ParamsType, msg_
             dps: {
                 "method": str(command),
                 "msgId": msg_id,
-                "params": params or [],
+                # Important: some B01 methods use an empty object `{}` (not `[]`) for
+                # "no params", and some setters legitimately send `0` which is falsy.
+                # Only default to `[]` when params is actually None.
+                "params": params if params is not None else [],
             }
         }
     }

roborock/roborock_typing.py

@@ -280,14 +280,67 @@ class RoborockCommand(str, Enum):
 class RoborockB01Q7Methods(StrEnum):
     """Methods used by the Roborock Q7 model."""
 
+    # NOTE: In the Q7 Hermes dump these appear as suffixes and are also used
+    # with an "event." prefix at runtime (see `hermes/.../module_524.js`).
+    ADD_CLEAN_FAILED_POST = "add_clean_failed.post"
+    EVENT_ADD_CLEAN_FAILED_POST = "event.add_clean_failed.post"
+    CLEAN_FINISH_POST = "clean_finish.post"
+    EVENT_CLEAN_FINISH_POST = "event.clean_finish.post"
+    EVENT_BUILD_MAP_FINISH_POST = "event.BuildMapFinish.post"
+    EVENT_MAP_CHANGE_POST = "event.map_change.post"
+    EVENT_WORK_APPOINT_CLEAN_FAILED_POST = "event.work_appoint_clean_failed.post"
+    START_CLEAN_POST = "startClean.post"
+    ADD_ORDER = "service.add_order"
+    ADD_SWEEP_CLEAN = "service.add_sweep_clean"
+    ARRANGE_ROOM = "service.arrange_room"
+    DEL_MAP = "service.del_map"
+    DEL_ORDER = "service.del_order"
+    DEL_ORDERS = "service.del_orders"
+    DELETE_RECORD_BY_URL = "service.delete_record_by_url"
+    DOWNLOAD_VOICE_TYPE = "service.download_voice_type"
+    ERASE_PREFERENCE = "service.erase_preference"
+    FIND_DEVICE = "service.find_device"
+    GET_ROOM_ORDER = "service.get_room_order"
+    GET_VOICE_DOWNLOAD = "service.get_voice_download"
+    HELLO_WIKKA = "service.hello_wikka"
+    RENAME_MAP = "service.rename_map"
+    RENAME_ROOM = "service.rename_room"
+    RENAME_ROOMS = "service.rename_rooms"
+    REPLACE_MAP = "service.replace_map"
+    RESET_CONSUMABLE = "service.reset_consumable"
+    SAVE_CARPET = "service.save_carpet"
+    SAVE_RECOMMEND_FB = "service.save_recommend_fb"
+    SAVE_SILL = "service.save_sill"
+    SET_AREA_START = "service.set_area_start"
+    SET_AREAS_START = "service.set_areas_start"
+    SET_CUR_MAP = "service.set_cur_map"
+    SET_DIRECTION = "service.set_direction"
+    SET_GLOBAL_SORT = "service.set_global_sort"
+    SET_MAP_HIDE = "service.set_map_hide"
+    SET_MULTI_ROOM_MATERIAL = "service.set_multi_room_material"
+    SET_POINT_CLEAN = "service.set_point_clean"
+    SET_PREFERENCE = "service.set_preference"
+    SET_PREFERENCE_TYPE = "service.set_preference_type"
+    SET_QUIET_TIME = "service.set_quiet_time"
+    SET_ROOM_CLEAN = "service.set_room_clean"
+    SET_ROOM_ORDER = "service.set_room_order"
+    SET_VIRTUAL_WALL = "service.set_virtual_wall"
+    SET_ZONE_CLEAN = "service.set_zone_clean"
+    SET_ZONE_POINTS = "service.set_zone_points"
+    SPLIT_ROOM = "service.split_room"
+    START_EXPLORE = "service.start_explore"
+    START_POINT_CLEAN = "service.start_point_clean"
+    START_RECHARGE = "service.start_recharge"
+    STOP_RECHARGE = "service.stop_recharge"
+    UPLOAD_BY_MAPID = "service.upload_by_mapid"
+    UPLOAD_RECORD_BY_URL = "service.upload_record_by_url"
     GET_PROP = "prop.get"
     GET_MAP_LIST = "service.get_map_list"
     UPLOAD_BY_MAPTYPE = "service.upload_by_maptype"
     SET_PROP = "prop.set"
     GET_PREFERENCE = "service.get_preference"
     GET_RECORD_LIST = "service.get_record_list"
     GET_ORDER = "service.get_order"
-    EVENT_ORDER_LIST_POST = "event.order_list.post"
     POST_PROP = "prop.post"