Skip to content

Commit bc85777

Browse files
committed
feat(v1): add fan speed, water mode and mop route setters that refuse changes in SmartPlan and custom mode
1 parent 20625dd commit bc85777

4 files changed

Lines changed: 553 additions & 0 deletions

File tree

‎roborock/data/v1/v1_clean_modes.py‎

Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -525,6 +525,80 @@ def get_motor_mode_commands(
525525
return commands
526526

527527

528+
def _get_model_options(setting: CleaningSetting, features: DeviceFeatures, region: str) -> list[RoborockModeEnum]:
529+
"""Return every value the model supports for a setting, regardless of the cleaning mode."""
530+
if setting == CleaningSetting.FAN_SPEED:
531+
return list(get_clean_modes(features))
532+
if setting == CleaningSetting.WATER_MODE:
533+
return list(get_water_modes(features))
534+
return list(get_clean_routes(features, region))
535+
536+
537+
def _get_mode_codes(
538+
setting: CleaningSetting, mode: CleaningMode | None, features: DeviceFeatures, region: str
539+
) -> set[int]:
540+
"""Return the codes of a setting that are offered in the mode (see get_mode_options)."""
541+
options = get_mode_options(setting, mode, features, _get_model_options(setting, features, region))
542+
return {option.code for option in options}
543+
544+
545+
def _get_tab_route_codes(mode: CleaningMode | None, features: DeviceFeatures, region: str) -> set[int]:
546+
"""Return the route codes on the mode's tab, whether or not the route is adjustable in it."""
547+
if _offers_all_routes(mode, features):
548+
return {route.code for route in get_clean_routes(features, region)}
549+
return {CleanRoutes.FAST.code, CleanRoutes.STANDARD.code}
550+
551+
552+
def get_setting_change_codes(
553+
setting: CleaningSetting,
554+
code: int,
555+
mode: CleaningMode | None,
556+
features: DeviceFeatures,
557+
region: str,
558+
*,
559+
fan_power: int,
560+
water_box_mode: int | None,
561+
mop_mode: int | None,
562+
) -> tuple[int, int | None, int | None]:
563+
"""Return the (fan_power, water_box_mode, mop_mode) codes that change one cleaning setting.
564+
565+
The setting must be adjustable in the current cleaning mode and the code must be one
566+
of the values allowed in that mode (get_mode_options), otherwise
567+
RoborockUnsupportedFeature is raised. The other two settings keep their current codes,
568+
except that a value left over from another tab is replaced when
569+
switching modes: a fan speed that is not on the mode's list (Max+, the mop-only 105)
570+
becomes balanced (102) and a mop route that is not on the tab's list becomes standard
571+
(300). Mopping only always uses the mop-only fan code.
572+
The mop route is None when the device has no route setting or no shake module,
573+
because the route is only sent with the shake module.
574+
The water mode is None only for devices without a mop, which have no water mode.
575+
"""
576+
if setting not in get_adjustable_settings(mode, features):
577+
raise RoborockUnsupportedFeature(f"The {setting.value} cannot be changed in the current cleaning mode")
578+
selectable = _get_mode_codes(setting, mode, features, region)
579+
if setting == CleaningSetting.WATER_MODE and features.is_water_slide_mode_supported:
580+
selectable.update(range(221, 251))
581+
if code not in selectable:
582+
raise RoborockUnsupportedFeature(f"The {setting.value} code {code} is not supported in the current mode")
583+
584+
fan_codes = _get_mode_codes(CleaningSetting.FAN_SPEED, mode, features, region)
585+
if fan_codes and fan_power not in fan_codes:
586+
fan_power = VacuumModes.BALANCED.code
587+
if mop_mode is not None and mop_mode not in _get_tab_route_codes(mode, features, region):
588+
mop_mode = CleanRoutes.STANDARD.code
589+
590+
if setting == CleaningSetting.FAN_SPEED:
591+
fan_power = code
592+
elif setting == CleaningSetting.WATER_MODE:
593+
water_box_mode = code
594+
else:
595+
mop_mode = code
596+
if mode == CleaningMode.MOP:
597+
fan_power = get_mop_only_vacuum_mode(features).code
598+
sends_route = features.is_clean_route_setting_supported and features.is_shake_mop_set_supported
599+
return fan_power, water_box_mode, mop_mode if sends_route else None
600+
601+
528602
def _resolve_mode_code(value: int | ModeEnumT | None, mode_cls: type[ModeEnumT]) -> ModeEnumT | None:
529603
"""Resolve a raw code or enum into a RoborockModeEnum."""
530604
if value is None:

‎roborock/devices/traits/v1/status.py‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,12 +21,14 @@
2121
get_fan_speed_name,
2222
get_mop_route_name,
2323
get_motor_mode_commands,
24+
get_setting_change_codes,
2425
get_water_mode_mapping,
2526
get_water_mode_name,
2627
get_water_modes,
2728
resolve_cleaning_mode,
2829
)
2930
from roborock.devices.traits.common import DpsDataConverter, TraitUpdateListener
31+
from roborock.exceptions import RoborockException
3032
from roborock.roborock_message import RoborockDataProtocol
3133
from roborock.roborock_typing import RoborockCommand
3234

@@ -197,6 +199,35 @@ async def set_cleaning_mode(self, cleaning_mode: str | CleaningMode) -> None:
197199
)
198200
await self._apply_motor_mode(fan_power, water_box_mode, mop_mode)
199201

202+
async def set_fan_speed(self, mode: VacuumModes) -> None:
203+
"""Set the fan speed while keeping the water mode and mop route."""
204+
await self._set_cleaning_setting(CleaningSetting.FAN_SPEED, mode.code)
205+
206+
async def set_water_mode(self, mode: WaterModes) -> None:
207+
"""Set the water mode while keeping the fan speed and mop route."""
208+
await self._set_cleaning_setting(CleaningSetting.WATER_MODE, mode.code)
209+
210+
async def set_mop_route(self, route: CleanRoutes) -> None:
211+
"""Set the mop route while keeping the fan speed and water mode."""
212+
await self._set_cleaning_setting(CleaningSetting.MOP_ROUTE, route.code)
213+
214+
async def _set_cleaning_setting(self, setting: CleaningSetting, code: int) -> None:
215+
features = self._device_features_trait
216+
# A device without a mop has no water mode, so only the fan power has to be loaded.
217+
if self.fan_power is None or (features.is_support_water_mode and self.water_box_mode is None):
218+
raise RoborockException("Status is not loaded, call refresh() first")
219+
fan_power, water_box_mode, mop_mode = get_setting_change_codes(
220+
setting,
221+
code,
222+
self.current_cleaning_mode,
223+
features,
224+
self._region or "us",
225+
fan_power=self.fan_power,
226+
water_box_mode=self.water_box_mode,
227+
mop_mode=self.mop_mode,
228+
)
229+
await self._apply_motor_mode(fan_power, water_box_mode, mop_mode)
230+
200231
async def _apply_motor_mode(self, fan_power: int, water_box_mode: int | None, mop_mode: int | None) -> None:
201232
"""Send the codes in the order the model needs, then update the cached status.
202233

‎tests/data/v1/test_v1_clean_modes.py‎

Lines changed: 180 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@
1515
get_cleaning_mode_codes,
1616
get_display_options,
1717
get_motor_mode_commands,
18+
get_setting_change_codes,
1819
get_water_modes,
1920
)
2021
from roborock.device_features import DeviceFeatures
@@ -245,6 +246,92 @@ def test_get_cleaning_mode_codes_unsupported_mode() -> None:
245246
get_cleaning_mode_codes(CleaningMode.SMART_MODE, _features(), None)
246247

247248

249+
@pytest.mark.parametrize(
250+
("setting", "code", "mode", "status", "overrides", "expected"),
251+
[
252+
(CleaningSetting.FAN_SPEED, 104, CleaningMode.VAC_AND_MOP, (102, 202, 300), {}, (104, 202, 300)),
253+
(CleaningSetting.WATER_MODE, 203, CleaningMode.MOP, (105, 202, 300), {}, (105, 203, 300)),
254+
(CleaningSetting.MOP_ROUTE, 301, CleaningMode.MOP, (105, 202, 300), {}, (105, 202, 301)),
255+
# Without a route setting the route is not sent.
256+
(
257+
CleaningSetting.FAN_SPEED,
258+
103,
259+
CleaningMode.VACUUM,
260+
(102, 200, 300),
261+
{"is_clean_route_setting_supported": False},
262+
(103, 200, None),
263+
),
264+
# Without the shake module the route is not sent either.
265+
(
266+
CleaningSetting.FAN_SPEED,
267+
103,
268+
CleaningMode.VACUUM,
269+
(102, 200, 300),
270+
{"is_shake_mop_set_supported": False},
271+
(103, 200, None),
272+
),
273+
# Water slide devices accept every slider position.
274+
(
275+
CleaningSetting.WATER_MODE,
276+
233,
277+
CleaningMode.VAC_AND_MOP,
278+
(102, 225, 300),
279+
{"is_water_slide_mode_supported": True},
280+
(102, 233, 300),
281+
),
282+
],
283+
)
284+
def test_get_setting_change_codes(
285+
setting: CleaningSetting,
286+
code: int,
287+
mode: CleaningMode,
288+
status: tuple[int, int, int],
289+
overrides: dict[str, bool],
290+
expected: tuple[int, int, int | None],
291+
) -> None:
292+
features = _features(is_pure_clean_mop_supported=True, **overrides)
293+
assert (
294+
get_setting_change_codes(
295+
setting, code, mode, features, "us", fan_power=status[0], water_box_mode=status[1], mop_mode=status[2]
296+
)
297+
== expected
298+
)
299+
300+
301+
@pytest.mark.parametrize(
302+
("setting", "code", "mode", "overrides"),
303+
[
304+
(CleaningSetting.FAN_SPEED, 104, CleaningMode.SMART_MODE, {}),
305+
(CleaningSetting.FAN_SPEED, 104, CleaningMode.CUSTOM, {}),
306+
(CleaningSetting.FAN_SPEED, 104, None, {}),
307+
(CleaningSetting.FAN_SPEED, 104, CleaningMode.MOP, {}),
308+
(CleaningSetting.WATER_MODE, 203, CleaningMode.VACUUM, {}),
309+
(CleaningSetting.FAN_SPEED, 110, CleaningMode.VAC_AND_MOP, {}),
310+
(CleaningSetting.FAN_SPEED, 999, CleaningMode.VAC_AND_MOP, {}),
311+
(CleaningSetting.WATER_MODE, 220, CleaningMode.VAC_AND_MOP, {"is_water_slide_mode_supported": True}),
312+
(CleaningSetting.WATER_MODE, 251, CleaningMode.VAC_AND_MOP, {"is_water_slide_mode_supported": True}),
313+
(CleaningSetting.MOP_ROUTE, 302, CleaningMode.VAC_AND_MOP, {}),
314+
# Mopping without water is not mopping.
315+
(CleaningSetting.WATER_MODE, 200, CleaningMode.MOP, {}),
316+
],
317+
)
318+
def test_get_setting_change_codes_refused(
319+
setting: CleaningSetting, code: int, mode: CleaningMode | None, overrides: dict[str, bool]
320+
) -> None:
321+
features = _features(is_pure_clean_mop_supported=True, **overrides)
322+
with pytest.raises(RoborockUnsupportedFeature):
323+
get_setting_change_codes(setting, code, mode, features, "us", fan_power=102, water_box_mode=202, mop_mode=300)
324+
325+
326+
@pytest.mark.parametrize("route_supported", [True, False])
327+
def test_get_setting_change_codes_vacuum_only(route_supported: bool) -> None:
328+
"""Without a mop there is no water mode or route to carry along."""
329+
features = _features(is_support_water_mode=False, is_clean_route_setting_supported=route_supported)
330+
assert get_setting_change_codes(
331+
CleaningSetting.FAN_SPEED, 104, None, features, "us", fan_power=102, water_box_mode=None, mop_mode=None
332+
) == (104, None, None)
333+
334+
248335
_SAROS_10R = {
249336
"is_soft_clean_mode_supported": False,
250337
"is_pure_clean_mop_supported": True,
@@ -347,6 +434,85 @@ def test_water_mode_display_options_keep_off_without_sub_tabs() -> None:
347434
assert WaterModes.OFF in options
348435

349436

437+
@pytest.mark.parametrize(
438+
("setting", "code", "mode", "overrides"),
439+
[
440+
(CleaningSetting.MOP_ROUTE, 301, CleaningMode.VAC_AND_MOP, {}),
441+
(CleaningSetting.MOP_ROUTE, 303, CleaningMode.VACUUM, {}),
442+
(CleaningSetting.FAN_SPEED, 108, CleaningMode.VAC_AND_MOP, {}),
443+
(CleaningSetting.FAN_SPEED, 108, CleaningMode.VACUUM, {"is_max_plus_mode_supported": False}),
444+
(CleaningSetting.WATER_MODE, 200, CleaningMode.VAC_AND_MOP, {}),
445+
(CleaningSetting.MOP_ROUTE, 300, CleaningMode.VAC_AND_MOP, {"is_shake_mop_set_supported": False}),
446+
],
447+
)
448+
def test_get_setting_change_codes_refuses_values_outside_mode_list(
449+
setting: CleaningSetting, code: int, mode: CleaningMode, overrides: dict[str, bool]
450+
) -> None:
451+
features = _features(**{**_SAROS_10R, **overrides})
452+
with pytest.raises(RoborockUnsupportedFeature):
453+
get_setting_change_codes(setting, code, mode, features, "us", fan_power=102, water_box_mode=235, mop_mode=300)
454+
455+
456+
@pytest.mark.parametrize(
457+
("setting", "code", "mode", "status", "expected", "overrides"),
458+
[
459+
(CleaningSetting.FAN_SPEED, 108, CleaningMode.VACUUM, (102, 200, 300), (108, 200, 300), {}),
460+
(CleaningSetting.MOP_ROUTE, 304, CleaningMode.VACUUM, (108, 200, 300), (108, 200, 304), {}),
461+
(CleaningSetting.MOP_ROUTE, 301, CleaningMode.MOP, (105, 235, 300), (105, 235, 301), {}),
462+
# A route or fan speed set in another tab by an older client is not carried along.
463+
(CleaningSetting.WATER_MODE, 240, CleaningMode.VAC_AND_MOP, (102, 235, 301), (102, 240, 300), {}),
464+
(CleaningSetting.WATER_MODE, 240, CleaningMode.VAC_AND_MOP, (108, 235, 300), (102, 240, 300), {}),
465+
(CleaningSetting.MOP_ROUTE, 304, CleaningMode.VAC_AND_MOP, (108, 235, 300), (102, 235, 304), {}),
466+
(CleaningSetting.WATER_MODE, 240, CleaningMode.MOP, (105, 235, 301), (105, 240, 301), {}),
467+
# The mop-only fan code left behind outside mopping only becomes balanced, like Max+.
468+
(CleaningSetting.MOP_ROUTE, 304, CleaningMode.VACUUM, (105, 200, 300), (102, 200, 304), {}),
469+
(CleaningSetting.WATER_MODE, 240, CleaningMode.VAC_AND_MOP, (105, 235, 300), (102, 240, 300), {}),
470+
# Gentle is on the fan list of soft-clean models, so code 105 stays there.
471+
(
472+
CleaningSetting.WATER_MODE,
473+
240,
474+
CleaningMode.VAC_AND_MOP,
475+
(105, 235, 300),
476+
(105, 240, 300),
477+
{"is_soft_clean_mode_supported": True},
478+
),
479+
# A leftover route is replaced even when the mode has no adjustable route.
480+
(
481+
CleaningSetting.WATER_MODE,
482+
240,
483+
CleaningMode.VAC_AND_MOP,
484+
(102, 235, 301),
485+
(102, 240, 300),
486+
{"is_clean_route_fast_mode_supported": False},
487+
),
488+
# Fast is on the tab's short list and stays.
489+
(
490+
CleaningSetting.WATER_MODE,
491+
240,
492+
CleaningMode.VAC_AND_MOP,
493+
(102, 235, 304),
494+
(102, 240, 304),
495+
{"is_clean_route_fast_mode_supported": False},
496+
),
497+
],
498+
)
499+
def test_get_setting_change_codes_replaces_values_outside_mode_list(
500+
setting: CleaningSetting,
501+
code: int,
502+
mode: CleaningMode,
503+
status: tuple[int, int, int],
504+
expected: tuple[int, int, int],
505+
overrides: dict[str, bool],
506+
) -> None:
507+
features = _features(**{**_SAROS_10R, **overrides})
508+
assert (
509+
get_setting_change_codes(
510+
setting, code, mode, features, "us", fan_power=status[0], water_box_mode=status[1], mop_mode=status[2]
511+
)
512+
== expected
513+
)
514+
515+
350516
@pytest.mark.parametrize("mode", [CleaningMode.SMART_MODE, CleaningMode.CUSTOM])
351517
@pytest.mark.parametrize("shake", [True, False])
352518
def test_get_display_options_route_special_values_need_shake(mode: CleaningMode, shake: bool) -> None:
@@ -365,6 +531,20 @@ def test_water_mode_display_options_include_off_when_turning_water_on_without_mo
365531
assert len(options) > 1
366532

367533

534+
def test_get_setting_change_codes_turns_water_on_without_mode_tabs() -> None:
535+
features = _features(**{**_SAROS_10R, "is_pure_clean_mop_supported": False})
536+
assert get_setting_change_codes(
537+
CleaningSetting.WATER_MODE,
538+
240,
539+
CleaningMode.VACUUM,
540+
features,
541+
"us",
542+
fan_power=102,
543+
water_box_mode=200,
544+
mop_mode=300,
545+
) == (102, 240, 300)
546+
547+
368548
def test_fan_speed_display_options_keep_full_list_without_a_mop() -> None:
369549
"""Devices without a mop have no mode tabs at all and keep every fan speed the model lists, Max+ included."""
370550
features = _features(is_support_water_mode=False, is_max_plus_mode_supported=True)

0 commit comments

Comments
 (0)