fix: show docked Q10 robot on map

Author: tubededentifrice

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

@@ -119,7 +119,7 @@ def __init__(self, channel: B01Q10Channel) -> None:
         self.network_info = NetworkInfoTrait()
         self.consumable = ConsumableTrait()
         self._map_dps = MapDpsTrait()
-        self.map = MapContentTrait(self._map_dps)
+        self.map = MapContentTrait(self._map_dps, self.status)
         self.clean_history = CleanHistoryTrait(self.command)
         # Read-model traits updated from the device's DPS push stream.
         self._updatable_traits = [

roborock/devices/traits/b01/q10/map.py

@@ -1,15 +1,17 @@
 """Push-driven map traits for B01 Q10 devices.
 
-Map-related state arrives on three independent streams:
+Map-related state arrives on four independent streams:
 
 * map packets are decoded from map-protocol responses;
 * trace packets are decoded from trace-protocol responses;
 * restricted zones and virtual walls arrive as ordinary DPS values.
+* the device status indicates when an idle robot is charging at the saved dock.
 
 ``MapDpsTrait`` owns the low-level DPS read model. ``MapContentTrait`` depends
-on it and combines that state with the latest map/trace packets through the pure
-functions in :mod:`roborock.map.b01_q10_render`. The high-level trait keeps only
-the latest value from each source and one replace-whole rendered image;
+on it and the status trait, then combines that state with the latest map/trace
+packets through the pure functions in :mod:`roborock.map.b01_q10_render`. The
+high-level trait keeps only the latest value from each source and one
+replace-whole rendered image;
 calibration, path placement and overlay placement remain inside the renderer.
 """
 
@@ -18,7 +20,7 @@
 from typing import Any
 
 from roborock.data import RoborockBase
-from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
+from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP, YXDeviceState
 from roborock.devices.traits.common import DpsDataConverter, TraitUpdateListener
 from roborock.exceptions import RoborockException
 from roborock.map.b01_q10_map_parser import (
@@ -32,6 +34,7 @@
 from roborock.map.b01_q10_render import Q10MapOverlays, render_q10_map
 
 from .common import UpdatableTrait
+from .status import StatusTrait
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -73,23 +76,27 @@ def update_from_dps(self, decoded_dps: dict[B01_Q10_DP, Any]) -> None:
 class MapContentTrait(TraitUpdateListener):
     """High-level composed Q10 map view.
 
-    The latest map and trace packets are combined with the injected
-    :class:`MapDpsTrait` whenever any of those three sources changes.
+    The latest map and trace packets are combined with the injected map DPS and
+    status traits whenever any source changes.
     """
 
     def __init__(
         self,
         map_dps: MapDpsTrait,
+        status: StatusTrait | None = None,
         *,
         map_parser_config: B01Q10MapParserConfig | None = None,
     ) -> None:
         TraitUpdateListener.__init__(self, logger=_LOGGER)
         self._config = map_parser_config or B01Q10MapParserConfig()
         self._map_dps = map_dps
+        self._status = status or StatusTrait()
+        self._robot_at_dock = self._status.status == YXDeviceState.CHARGING
         self._map_packet: Q10MapPacket | None = None
         self._trace_packet: Q10TracePacket | None = None
         self._image_content: bytes | None = None
         self._map_dps.add_update_listener(self._map_dps_updated)
+        self._status.add_update_listener(self._status_updated)
 
     @property
     def image_content(self) -> bytes | None:
@@ -129,7 +136,18 @@ def update_from_trace_packet(self, packet: Q10TracePacket) -> None:
         self._notify_update()
 
     def _map_dps_updated(self) -> None:
-        """Render after the low-level DPS source changes."""
+        """Render after the low-level map DPS source changes."""
+        if self._map_packet is None:
+            return
+        self._render()
+        self._notify_update()
+
+    def _status_updated(self) -> None:
+        """Render only when the status changes whether the robot is docked."""
+        robot_at_dock = self._status.status == YXDeviceState.CHARGING
+        if robot_at_dock == self._robot_at_dock:
+            return
+        self._robot_at_dock = robot_at_dock
         if self._map_packet is None:
             return
         self._render()
@@ -145,6 +163,7 @@ def _render(self) -> None:
                 self._trace_packet,
                 self._map_dps.overlays,
                 config=self._config,
+                robot_at_dock=self._robot_at_dock,
             )
         except RoborockException as ex:
             _LOGGER.debug("Failed to render Q10 map packet: %s", ex)

roborock/map/b01_q10_map_parser.py

@@ -93,15 +93,18 @@ def classify_q10_cell(value: int) -> str:
 #   50 mm/px, so dividing by 10 yields the origin in grid pixels -- the (ox, oy)
 #   that solve_calibration otherwise recovers by sliding the path.
 # - 15-16 resolution (u16be): reads 5 (= 0.05 m/px = 50 mm/px) universally.
-# - 17-18 charger x, 19-20 charger y (s16be, 5 mm units), 21-22 charger phi.
+# - 17-18 charger x, 19-20 charger y (s16be, absolute map decipixels),
+#   21-22 charger phi. The official app's device-point transform confirms these
+#   coordinates are already in the map-array frame and must not receive x_min /
+#   y_min a second time.
 _ORIGIN_X_OFFSET = 11
 _ORIGIN_Y_OFFSET = 13
 _HEADER_RESOLUTION_OFFSET = 15
 _CHARGER_X_OFFSET = 17
 _CHARGER_Y_OFFSET = 19
 _CHARGER_PHI_OFFSET = 21
-# The header origin/charger are in 5 mm units and the grid is 50 mm/px, so a
-# header coordinate maps to grid pixels by dividing by this.
+# The header origin and charger fields both divide by 10 to reach grid pixels,
+# although they use different coordinate frames as documented above.
 _HEADER_UNITS_PER_PIXEL = 10
 
 # Grid cell values >= this are walls / borders rather than room segments.
@@ -149,9 +152,11 @@ class Q10HeaderCalibration:
     straight from the map packet -- no cleaning path / fit required, so it works
     docked or pre-clean. See :meth:`origin_pixels`.
 
-    ``origin_x`` / ``origin_y`` and the charger coordinates are in 5 mm units;
-    ``resolution`` is the raw header field (5 == 50 mm/px). ``charger_phi`` is the
-    raw dock heading field. Reported and verified by @andrewlyeats (ss07).
+    ``origin_x`` / ``origin_y`` are in 5 mm units and define the world-coordinate
+    origin. The charger coordinates are absolute decipixels in the map-array
+    frame, so they are divided by 10 without applying that origin again.
+    ``resolution`` is the raw header field (5 == 50 mm/px). ``charger_phi`` is
+    the raw dock heading field. Reported and verified by @andrewlyeats (ss07).
     """
 
     origin_x: int
@@ -177,6 +182,15 @@ def origin_pixels(self) -> tuple[float, float] | None:
             return None
         return (self.origin_x / _HEADER_UNITS_PER_PIXEL, self.origin_y / _HEADER_UNITS_PER_PIXEL)
 
+    def charger_pixels(self) -> tuple[float, float] | None:
+        """Return the saved dock in absolute map-array pixel coordinates."""
+        if (self.charger_x == 0 and self.charger_y == 0) or self.charger_x == -1 or self.charger_y == -1:
+            return None
+        return (
+            self.charger_x / _HEADER_UNITS_PER_PIXEL,
+            self.charger_y / _HEADER_UNITS_PER_PIXEL,
+        )
+
 
 @dataclass
 class Q10MapPacket:

roborock/map/b01_q10_render.py

@@ -14,10 +14,12 @@
 """
 
 import io
+import math
 from collections.abc import Sequence
 from dataclasses import dataclass
 
 from vacuum_map_parser_base.config.drawable import Drawable
+from vacuum_map_parser_base.config.size import Size, Sizes
 from vacuum_map_parser_base.map_data import Area, MapData, Path, Point, Wall
 
 from roborock.exceptions import RoborockException
@@ -86,6 +88,7 @@ def render_q10_map(
     overlays: Q10MapOverlays,
     *,
     config: B01Q10MapParserConfig,
+    robot_at_dock: bool = False,
 ) -> bytes:
     """Compose the latest map, trace and DPS inputs into one PNG image.
 
@@ -116,8 +119,10 @@ def render_q10_map(
         charger_heading = packet.header_calibration.charger_phi if packet.header_calibration is not None else None
         _place_trace(map_data, trace_calibration, trace, charger_heading=charger_heading)
         has_drawables = True
+    has_drawables = _place_charger_from_header(map_data, packet) or has_drawables
+    if robot_at_dock:
+        has_drawables = _place_docked_robot(map_data) or has_drawables
     if vector_calibration is not None:
-        has_drawables = _place_charger_from_header(map_data, packet, vector_calibration) or has_drawables
         _place_overlays(map_data, vector_calibration, overlays)
         has_drawables = has_drawables or bool(map_data.no_go_areas or map_data.no_mopping_areas or map_data.walls)
     if has_drawables:
@@ -253,14 +258,33 @@ def _place_trace(
 def _place_charger_from_header(
     map_data: MapData,
     packet: Q10MapPacket,
-    calibration: GridCalibration,
 ) -> bool:
-    """Place the saved dock using the header's 5 mm coordinates."""
+    """Place the saved dock using its absolute header pixel coordinates."""
     header = packet.header_calibration
-    if header is None:
+    if header is None or (position := header.charger_pixels()) is None:
+        return False
+    map_data.charger = Point(*position, -header.charger_phi)
+    return True
+
+
+def _place_docked_robot(map_data: MapData) -> bool:
+    """Place a charging robot immediately in front of the saved dock.
+
+    A zero-point idle trace has no robot coordinates. The dock heading does,
+    however, identify its outward-facing side. Offset the robot by the shared
+    unscaled V1 charger radius so the two standard glyphs meet without one
+    covering the other, and preserve the saved dock heading.
+    """
+    charger = map_data.charger
+    if charger is None or charger.a is None:
         return False
-    px, py = calibration.world_to_pixel(header.charger_x, header.charger_y)
-    map_data.charger = Point(px, py, calibration.y_sign * header.charger_phi)
+    angle = math.radians(charger.a)
+    offset = Sizes.SIZES[Size.CHARGER_RADIUS]
+    map_data.vacuum_position = Point(
+        charger.x + offset * math.cos(angle),
+        charger.y - offset * math.sin(angle),
+        charger.a,
+    )
     return True
 
 

tests/devices/traits/b01/q10/test_map.py

@@ -21,6 +21,7 @@
 from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
 from roborock.devices.traits.b01.q10 import Q10PropertiesApi, create
 from roborock.devices.traits.b01.q10.map import MapContentTrait, MapDpsTrait
+from roborock.devices.traits.b01.q10.status import StatusTrait
 from roborock.exceptions import RoborockException
 from roborock.map.b01_q10_map_parser import (
     Q10Point,
@@ -375,3 +376,27 @@ def test_map_dps_push_without_overlay_data_points_is_noop() -> None:
 
     assert map_dps.overlays == Q10MapOverlays()
     assert not notified
+
+
+def test_charging_status_renders_robot_at_dock() -> None:
+    """Charging status adds the idle robot marker without inventing a path."""
+    status = StatusTrait()
+    trait = MapContentTrait(MapDpsTrait(), status)
+    packet = parse_map_packet(FIXTURE.read_bytes())
+    notified: list[None] = []
+    trait.add_update_listener(lambda: notified.append(None))
+
+    with patch(
+        "roborock.devices.traits.b01.q10.map.render_q10_map",
+        side_effect=[b"map with dock", b"map with docked robot"],
+    ) as render:
+        trait.update_from_map_packet(packet)
+        notified.clear()
+        status.update_from_dps({B01_Q10_DP.STATUS: 8})
+        status.update_from_dps({B01_Q10_DP.BATTERY: 50})
+
+    assert trait.image_content == b"map with docked robot"
+    assert trait.path == []
+    assert notified == [None]
+    assert render.call_count == 2
+    assert render.call_args.kwargs["robot_at_dock"] is True

tests/map/test_b01_q10_map_parser.py

@@ -442,6 +442,7 @@ def test_parse_header_calibration_fields() -> None:
     assert not cal.is_keepalive
     # 5 mm units / (50 mm/px) -> divide by 10 for grid pixels.
     assert cal.origin_pixels() == (-376.0, 192.0)
+    assert cal.charger_pixels() == (-5.0, 3.0)
 
 
 def test_parse_header_calibration_keepalive_has_no_origin() -> None:

tests/map/test_b01_q10_render.py

@@ -10,6 +10,8 @@
 from pathlib import Path
 
 from PIL import Image
+from vacuum_map_parser_base.config.size import Size, Sizes
+from vacuum_map_parser_base.map_data import MapData, Point
 
 from roborock.map.b01_grid_layers import GridCalibration
 from roborock.map.b01_q10_map_parser import (
@@ -32,6 +34,8 @@
     Q10MapOverlays,
     _calibration_from_header_metadata,
     _erased_cells,
+    _place_charger_from_header,
+    _place_docked_robot,
     _vector_calibration,
     render_q10_map,
     solve_q10_calibration,
@@ -159,6 +163,31 @@ def test_render_draws_dock_from_header_without_trace() -> None:
     assert rendered != base
 
 
+def test_place_charger_uses_absolute_header_pixels() -> None:
+    """The dock coordinates do not receive the world origin a second time."""
+    packet = replace(_packet(), header_calibration=HEADER)
+    map_data = MapData()
+
+    assert _place_charger_from_header(map_data, packet)
+
+    assert map_data.charger == Point(3, 3, -90)
+
+
+def test_place_docked_robot_uses_shared_v1_marker_geometry() -> None:
+    """The idle robot sits beside the dock, facing it, without a path."""
+    map_data = MapData()
+    map_data.charger = Point(20, 30, 90)
+
+    assert _place_docked_robot(map_data)
+
+    assert map_data.vacuum_position == Point(
+        20,
+        30 - Sizes.SIZES[Size.CHARGER_RADIUS],
+        90,
+    )
+    assert map_data.path is None
+
+
 def test_render_applies_erase_zones() -> None:
     """With a calibration, erase-zone cells are blanked from the image."""
     packet, trace = _calibrated_inputs()