Roborock Q10 / Q7 and similar newer models not supported in Home Assistant integration

[sam-artuso]

Integration name

Roborock

Link to integration documentation on our website

https://www.home-assistant.io/integrations/roborock/

Describe the enhancement

Linking back to the original GitHub issue that was closed and directed here: home-assistant/core#144138

Problem summary

Newer Roborock models like the Q10 S5 (and Q7 variants) do not show up in the Roborock integration and can’t be imported, despite being added to the Roborock app and reboots/reloads. The integration simply doesn’t detect or support them.

Observed behaviour

• Devices don’t import into the Roborock integration.
• Logs were attached in the original issue but didn’t lead to a resolution there.
• Community reports suggest these models may lack local API support or changed protocols, breaking Home Assistant’s discovery/local control.

Current status (as of closure)

The original issue was closed on GitHub with no fix merged and a suggestion to continue discussion here. There was no definitive update on support status or a timeline for adding it.

Questions for the community / maintainers

• Has anyone successfully integrated these newer Roborock models via a workaround (e.g., cloud workaround, Matter, alternative integration)?
• Is adding support blocked by missing local API endpoints or protocol changes?
• Are there plans to update the Roborock integration for these models, and if so, what’s the rough timeline or requirements?
• If local integration isn’t possible, would exposing enough cloud endpoints to make basic functionality available in HA be an option?

Use cases

Many users buy these newer models expecting Home Assistant integration to work. If local APIs changed or are missing, that’s a blocker for automation workflows. This affects the Roborock integration’s usefulness for newer devices.

Anything else?

No response

[github-actions[bot]]

🏷️ I've automatically added the integration: roborock label to help categorize this feature request.

[llewy]

For the Q10, I think we should check Python-roborock/python-roborock#709 so it's currently being worked on, like hard!

[logname]

Do we know if the Q10 will get a full integration any time soon? I'm just asking because I need to decide if I keep the Q10 I just got or if I return it and go for a Dreame vacuum which is more expensive but has HA integration.

If you have the means, spin up a Homey SHS container and use that on their free trial until this gets resolved. My Q10 S5 plus works on Homey, and there’s both an HA>Homey app, and a Homey>HA app.

It’s not 100% functional but it does everything I need for now. I was in the exact same boat as you, but I understand that there’s some serious progress being made in the background on both sides. Not to worry.

[anotherdave]

Just updated core to 2026.1.0. Q10 S5+ still doesn't work.

Per the release notes this version only supports basic read-only properties for the Q7.

[tybo611]

I see that 709 added Q10 support, I've pulled that code into a custom component but still getting the same error message. Is the Q10 different than the Q10 S5+ and support hasn't been added yet?

Logs show that it can recognize the Q10 but then fails to add the entity for it because protocol or category aren't supported.

[schioth]

I have been pulling my hair all day trying to get my Roborock Q10 S5+ to work in HA. Trying to catch up in all forums here, but has someone got it to work or is it still work in progress as per some comment?

[Firestar-Firestar]

I have been pulling my hair all day trying to get my Roborock Q10 S5+ to work in HA. Trying to catch up in all forums here, but has someone got it to work or is it still work in progress as per some comment?

I added mine to Google Home and then used the Google Assistant integration in Home Assistant to send simple commands like starting the vacuum, pausing the vacuum, or returning it to the dock. It’s a temporary solution, I guess, until someone actually makes it work properly, but it does the job. You can also automate it and create cards using this method. I don’t know if someone already thought of this. :3

[wisemars]

When should expect support for Roborock Q8 Max Pro (for the RU region) (perhaps this is the Roborock Q10 PF+/S8 Pro version for the US\EU region, according to information from 4PDA)?
PS: After several attempts, I still could not connect via roborock-python.

[Kinc4id]

Are we sure the Q10 es made unavailable on purpose? Because even the features in the app like Siri integration don’t work.

[gitgithubber]

Today, I updated from 2025.12.x to 2026.1.1 and immediately tested my new Q7 M5 (roborock.vacuum.sc05). The 6 entities (status, remaining filter time, remaining mop life, remaining sensor time, remaining main brush time, remaining side brush time) are working. 👍 💯
Now all that's missing are the remaining functions. 😄

[bthornton191]

I’m seeing the same results. My Q7 (SC05) shows the six sensor entities.

One additional note. Unlike my older Roborock A125 (“Pat”), which creates a vacuum.pat entity, my Q7 (“R2D2”) does not generate a vacuum.r2d2 entity.

I assume this is expected while the new models only expose read‑only entities

[Lash-L]

the vacuum entity was a few hours late from missing the cutoff for 2025.1, but you should see it in 2025.2

[Flappiee]

Q10 S5+ here, delivered today.
I'm not a developer but if i can help, please let me know! Would be great if it can be controlled from Home Assistant.

[logname]

I’m using the Homey Community Roborock Cloud integration with my Q10 S5+ and getting at least partial control. No rooms yet, but I can at least switch maps and control the robot. You can use the Homey Self Hosted Server Add-On for HASS OS free for a month, or run Homey SHS on one of the other platforms until integration here is resolved. Control from HA via one of the the two Homey community integrations (HA>Homey or Homey>HA).

[HA-Tom]

Hi,
I'm using two Roborock vacuum robots, one S6 maxV and a new Q10 x5, The Q10 x5 doesn't appear in the Roborock Integration, only the S6 maxV.
Core 2026.1.3, Supervisor 2026.01.1

[Neu-Bob]

My Q5 loaded into the HomeAssistant but no controls! Appreciate everyone that is working on getting support for these newer vacuums!

[sobrarbe]

Hello, I own a Roborock Q10 S5+, but Home Assistant is not detecting the vacuum through the official integration. I assumed that the communication protocol released for the Q7 would be the same for the Q10 — apologies for my lack of knowledge, I’m not a developer.

I mainly wanted to thank you for the work you’re doing and to ask whether the Roborock Q10 S5+ might eventually be supported in Home Assistant.

Thank you, everyone

[Tsaaek]

Made it work!!!
Been tinkering with gemini and when succeeded, asked to made a guide. Hope it helps to developers and migrate to core version soon

Yeah, LLMs have been super helpful. Using the foundations that have been built by several talented developers, I also managed to create a Q10 S5+ driver for Hubitat.

Working

* Clean

* Dock

* Empty Dust

* Pause

* Resume

* Maps
  
  * App Get Maps command so you can retrieve the maps from the robot and then you can call them up by the same name saved in the mobile app or via the map ID number that shows up in the Hubitat driver Current States

* Suction Power
  
  * Quiet
  * Balanced
  * Turbo
  * Max
  * Max+

* Water volume
  
  * Low
  * Medium
  * High

* Cleaning modes
  
  * Van & Mop
  * Vacuum
  * Mop
  * Vac then Mop

Not working

* Rooms

* Zones

That sound amazing. Where can I find this driver?

[logname]

That sound amazing. Where can I find this driver?

Sorry. It's in a private repo for now. I have passed it back to the original dev. He's aware but is on vacation at the moment. I need to honor his right to distribute his copyrighted work, which is part of this driver. You'll be able to get it on the Hubitat forum when he distributes it.

[Bart274]

Made it work!!!

Been tinkering with gemini and when succeeded, asked to made a guide. Hope it helps to developers and migrate to core version soon

This guide provides a workaround to enable full support for the Roborock Q10 S5+ (B01 series). Currently, this model is detected but not fully functional in the official integration because it uses a different status reporting structure and command path.

🛠 Installation as a Custom Component Since these changes are not yet in the official repository, you must run the integration as a custom_component:

Download the official Roborock integration source code.

Create a folder named custom_components inside your Home Assistant /config/ directory.

Copy the roborock folder from the ZIP into /config/custom_components/.

Modify the following three files as shown below.

1. File: init.py
   Find the device setup logic and ensure the Q10 is intercepted to use the new Coordinator.

if device.b01_q10_properties:
    _LOGGER.info("Q10 S5+ detected, using custom B01 coordinator")
    coordinator = RoborockB01Q10UpdateCoordinator(hass, entry, device, device.b01_q10_properties)

2. File: coordinator.py
   Add this class at the end of the file. This coordinator handles the specific MQTT startup and data refresh required for the B01 series.

class RoborockB01Q10UpdateCoordinator(RoborockDataUpdateCoordinatorB01):
    """Specific Coordinator for B01-Q10 Series."""
    def __init__(self, hass: HomeAssistant, config_entry: RoborockConfigEntry, device: RoborockDevice, api: Any) -> None:
        super().__init__(hass, config_entry, device)
        self.api = api
        self._api_started = False

    async def _async_update_data(self) -> Any:
        try:
            if not self._api_started and hasattr(self.api, 'start'):
                await self.api.start()
                self._api_started = True

            if hasattr(self.api, 'refresh'):
                await self.api.refresh()
        except Exception as ex:
            _LOGGER.debug("Q10 Refresh Error: %s", ex)
            
        return getattr(self.api, 'status', {})

3. File: vacuum.py
   Add this class at the end of the file. It translates the string-based statuses into Home Assistant activities.

class RoborockB01Q10UpdateCoordinator(RoborockDataUpdateCoordinatorB01):
    """Specific Coordinator for B01-Q10 Series."""
    def __init__(self, hass: HomeAssistant, config_entry: RoborockConfigEntry, device: RoborockDevice, api: Any) -> None:
        super().__init__(hass, config_entry, device)
        self.api = api
        self._api_started = False

    async def _async_update_data(self) -> Any:
        try:
            if not self._api_started and hasattr(self.api, 'start'):
                await self.api.start()
                self._api_started = True

            if hasattr(self.api, 'refresh'):
                await self.api.refresh()
        except Exception as ex:
            _LOGGER.debug("Q10 Refresh Error: %s", ex)
            
        return getattr(self.api, 'status', {})

3. File: vacuum.py
   Add this class at the end of the file. It translates the string-based statuses into Home Assistant activities.

class RoborockQ10Vacuum(CoordinatorEntity, StateVacuumEntity):
    """Vacuum entity specifically designed for Roborock Q10 S5+."""
    _attr_icon = "mdi:robot-vacuum"
    _attr_supported_features = (
        VacuumEntityFeature.PAUSE | VacuumEntityFeature.STOP | VacuumEntityFeature.RETURN_HOME | 
        VacuumEntityFeature.FAN_SPEED | VacuumEntityFeature.STATE | VacuumEntityFeature.START | 
        VacuumEntityFeature.BATTERY
    )
    _attr_translation_key = "roborock"

    def __init__(self, coordinator: RoborockB01Q10UpdateCoordinator) -> None:
        super().__init__(coordinator)
        self.coordinator = coordinator
        self._attr_unique_id = coordinator.duid_slug
        self._attr_device_info = coordinator.device_info

    @property
    def battery_level(self) -> int | None:
        return getattr(self.coordinator.data, 'battery', None)

    @property
    def activity(self) -> VacuumActivity | None:
        data = self.coordinator.data
        if not data: return VacuumActivity.IDLE
        status_raw = str(getattr(data, 'status', '')).lower()
        
        if any(x in status_raw for x in ["charging", "dock", "charge_complete"]):
            return VacuumActivity.DOCKED
        if any(x in status_raw for x in ["returning", "back_to"]):
            return VacuumActivity.RETURNING
        if any(x in status_raw for x in ["paused", "stop"]):
            return VacuumActivity.PAUSED
        if any(x in status_raw for x in ["relocation", "work", "clean", "sweep"]):
            return VacuumActivity.CLEANING
        return VacuumActivity.IDLE

    @property
    def fan_speed(self) -> str | None:
        data = self.coordinator.data
        if data and hasattr(data, 'fan_level'):
            val = data.fan_level
            return val.name if hasattr(val, 'name') else str(val)
        return None

    @property
    def fan_speed_list(self) -> list[str]:
        return ["close", "quiet", "normal", "strong", "max", "super"]

    async def async_start(self) -> None:
        await self.coordinator.api.vacuum.start_clean()
        await self.coordinator.async_refresh()

    async def async_pause(self) -> None:
        await self.coordinator.api.vacuum.pause_clean()
        await self.coordinator.async_refresh()

    async def async_return_to_base(self, **kwargs: Any) -> None:
        await self.coordinator.api.vacuum.return_to_dock()
        await self.coordinator.async_refresh()

    async def async_set_fan_speed(self, fan_speed: str, **kwargs: Any) -> None:
        from roborock.data.b01_q10.b01_q10_code_mappings import YXFanLevel
        await self.coordinator.api.vacuum.set_fan_level(YXFanLevel.from_value(fan_speed))
        await self.coordinator.async_refresh()

Results Battery: Real-time reporting (tested with 97%).

Status: Proper transitions between Cleaning, Docked, and Returning.

Controls: Start, Pause, Dock, and Fan Speed working correctly.

I tried to make your changes into a custom component, however my integration still says there is no device found. Would you mind sharing your version already in a github repository so we can check it out as well?
Thanks in advance!

[Crissiii10]

Made it work!!!

Been tinkering with gemini and when succeeded, asked to made a guide. Hope it helps to developers and migrate to core version soon

This guide provides a workaround to enable full support for the Roborock Q10 S5+ (B01 series). Currently, this model is detected but not fully functional in the official integration because it uses a different status reporting structure and command path.

🛠 Installation as a Custom Component Since these changes are not yet in the official repository, you must run the integration as a custom_component:

Download the official Roborock integration source code.

Create a folder named custom_components inside your Home Assistant /config/ directory.

Copy the roborock folder from the ZIP into /config/custom_components/.

Modify the following three files as shown below.

1. File: init.py
   Find the device setup logic and ensure the Q10 is intercepted to use the new Coordinator.

if device.b01_q10_properties:
    _LOGGER.info("Q10 S5+ detected, using custom B01 coordinator")
    coordinator = RoborockB01Q10UpdateCoordinator(hass, entry, device, device.b01_q10_properties)

2. File: coordinator.py
   Add this class at the end of the file. This coordinator handles the specific MQTT startup and data refresh required for the B01 series.

class RoborockB01Q10UpdateCoordinator(RoborockDataUpdateCoordinatorB01):
    """Specific Coordinator for B01-Q10 Series."""
    def __init__(self, hass: HomeAssistant, config_entry: RoborockConfigEntry, device: RoborockDevice, api: Any) -> None:
        super().__init__(hass, config_entry, device)
        self.api = api
        self._api_started = False

    async def _async_update_data(self) -> Any:
        try:
            if not self._api_started and hasattr(self.api, 'start'):
                await self.api.start()
                self._api_started = True

            if hasattr(self.api, 'refresh'):
                await self.api.refresh()
        except Exception as ex:
            _LOGGER.debug("Q10 Refresh Error: %s", ex)
            
        return getattr(self.api, 'status', {})

3. File: vacuum.py
   Add this class at the end of the file. It translates the string-based statuses into Home Assistant activities.

class RoborockB01Q10UpdateCoordinator(RoborockDataUpdateCoordinatorB01):
    """Specific Coordinator for B01-Q10 Series."""
    def __init__(self, hass: HomeAssistant, config_entry: RoborockConfigEntry, device: RoborockDevice, api: Any) -> None:
        super().__init__(hass, config_entry, device)
        self.api = api
        self._api_started = False

    async def _async_update_data(self) -> Any:
        try:
            if not self._api_started and hasattr(self.api, 'start'):
                await self.api.start()
                self._api_started = True

            if hasattr(self.api, 'refresh'):
                await self.api.refresh()
        except Exception as ex:
            _LOGGER.debug("Q10 Refresh Error: %s", ex)
            
        return getattr(self.api, 'status', {})

3. File: vacuum.py
   Add this class at the end of the file. It translates the string-based statuses into Home Assistant activities.

class RoborockQ10Vacuum(CoordinatorEntity, StateVacuumEntity):
    """Vacuum entity specifically designed for Roborock Q10 S5+."""
    _attr_icon = "mdi:robot-vacuum"
    _attr_supported_features = (
        VacuumEntityFeature.PAUSE | VacuumEntityFeature.STOP | VacuumEntityFeature.RETURN_HOME | 
        VacuumEntityFeature.FAN_SPEED | VacuumEntityFeature.STATE | VacuumEntityFeature.START | 
        VacuumEntityFeature.BATTERY
    )
    _attr_translation_key = "roborock"

    def __init__(self, coordinator: RoborockB01Q10UpdateCoordinator) -> None:
        super().__init__(coordinator)
        self.coordinator = coordinator
        self._attr_unique_id = coordinator.duid_slug
        self._attr_device_info = coordinator.device_info

    @property
    def battery_level(self) -> int | None:
        return getattr(self.coordinator.data, 'battery', None)

    @property
    def activity(self) -> VacuumActivity | None:
        data = self.coordinator.data
        if not data: return VacuumActivity.IDLE
        status_raw = str(getattr(data, 'status', '')).lower()
        
        if any(x in status_raw for x in ["charging", "dock", "charge_complete"]):
            return VacuumActivity.DOCKED
        if any(x in status_raw for x in ["returning", "back_to"]):
            return VacuumActivity.RETURNING
        if any(x in status_raw for x in ["paused", "stop"]):
            return VacuumActivity.PAUSED
        if any(x in status_raw for x in ["relocation", "work", "clean", "sweep"]):
            return VacuumActivity.CLEANING
        return VacuumActivity.IDLE

    @property
    def fan_speed(self) -> str | None:
        data = self.coordinator.data
        if data and hasattr(data, 'fan_level'):
            val = data.fan_level
            return val.name if hasattr(val, 'name') else str(val)
        return None

    @property
    def fan_speed_list(self) -> list[str]:
        return ["close", "quiet", "normal", "strong", "max", "super"]

    async def async_start(self) -> None:
        await self.coordinator.api.vacuum.start_clean()
        await self.coordinator.async_refresh()

    async def async_pause(self) -> None:
        await self.coordinator.api.vacuum.pause_clean()
        await self.coordinator.async_refresh()

    async def async_return_to_base(self, **kwargs: Any) -> None:
        await self.coordinator.api.vacuum.return_to_dock()
        await self.coordinator.async_refresh()

    async def async_set_fan_speed(self, fan_speed: str, **kwargs: Any) -> None:
        from roborock.data.b01_q10.b01_q10_code_mappings import YXFanLevel
        await self.coordinator.api.vacuum.set_fan_level(YXFanLevel.from_value(fan_speed))
        await self.coordinator.async_refresh()

Results Battery: Real-time reporting (tested with 97%).

Status: Proper transitions between Cleaning, Docked, and Returning.

Controls: Start, Pause, Dock, and Fan Speed working correctly.

Is it possible to share the modified files? Or on which line do you modified the First One? Thanks for the Great work

[jagimenose]

Add this couple of mods to your__init.py file:

(last line "RoborockB01Q10UpdateCoordinator)

from .coordinator import (
    RoborockB01Q7UpdateCoordinator,
    RoborockConfigEntry,
    RoborockCoordinators,
    RoborockDataUpdateCoordinator,
    RoborockDataUpdateCoordinatorA01,
    RoborockDataUpdateCoordinatorB01,
    RoborockWashingMachineUpdateCoordinator,
    RoborockWetDryVacUpdateCoordinator,
    RoborockB01Q10UpdateCoordinator,
)

and modify def build_setup_functions (marked as ADD THIS)

def build_setup_functions(
    hass: HomeAssistant,
    entry: RoborockConfigEntry,
    devices: list[RoborockDevice],
    user_data: UserData,
) -> list[
    Coroutine[
        Any,
        Any,
        RoborockDataUpdateCoordinator
        | RoborockDataUpdateCoordinatorA01
        | RoborockDataUpdateCoordinatorB01
        | None,
    ]
]:
    """Create a list of setup functions that can later be called asynchronously."""
    coordinators: list[
        RoborockDataUpdateCoordinator
        | RoborockDataUpdateCoordinatorA01
        | RoborockDataUpdateCoordinatorB01
    ] = []
    for device in devices:
        _LOGGER.debug("Creating device %s: %s", device.name, device)
        if device.v1_properties is not None:
            coordinators.append(
                RoborockDataUpdateCoordinator(hass, entry, device, device.v1_properties)
            )
        elif device.dyad is not None:
            coordinators.append(
                RoborockWetDryVacUpdateCoordinator(hass, entry, device, device.dyad)
            )
        elif device.zeo is not None:
            coordinators.append(
                RoborockWashingMachineUpdateCoordinator(hass, entry, device, device.zeo)
            )
        # --- ADD THIS ---
        elif device.device_info.pv == "B01":
            _LOGGER.info("Detectada aspiradora B01 (Q10 S5+), forzando coordinador Q10")
            # Extraemos las propiedades de donde vengan para no fallar
            api_props = getattr(device, 'b01_q10_properties', None) or getattr(device, 'b01_q7_properties', None) or device.device_info
            
            coordinators.append(
                RoborockB01Q10UpdateCoordinator(
                    hass, entry, device, api_props
                )
            )
        # -----------------------------------------------------------
        else:
            _LOGGER.warning(
                "Not adding device %s because its protocol version %s or category %s is not supported",
                device.duid,
                device.device_info.pv,
                device.product.category.name,
            )

    return [setup_coordinator(coordinator) for coordinator in coordinators]

[catartica76]

I miss them

• Cleaning modes
  • Van & Mop
  • Vacuum
  • Mop
  • Vac then Mop

thanks
jagimenose

[jagimenose]

Managed to add cleaning modes (now tinkering with rooms, I have all of them but guessing which ones is)

First, I created a Helper (Settings > Devices & Services > Helpers > Dropdown / Input Select) named Q10 Cleaning Mode (input_select.q10_cleaning_mode). Added these three options:
Vacuum Only
Mop Only
Vacuum and Mop

And then modified async_send_command funcion in vacuum.py

# Import the Q10 secret mapping
import importlib
modulo = importlib.import_module("roborock.data.b01_q10.b01_q10_code_mappings")

# 1. Read our dropdown menu state from Home Assistant
modo_estado = self.coordinator.hass.states.get("input_select.q10_cleaning_mode")
modo_texto = modo_estado.state if modo_estado else "Vacuum Only"

# 2. Translate the choice to Q10 variables
if modo_texto == "Mop Only":
    modo_limpieza = modulo.YXCleanType.ONLY_MOP
elif modo_texto == "Vacuum and Mop":
    modo_limpieza = modulo.YXCleanType.BOTH_WORK
else:
    modo_limpieza = modulo.YXCleanType.ONLY_SWEEP

# 3. Send the cleaning mode to the correct Data Point
await self.coordinator.api.command.send(modulo.B01_Q10_DP.CLEAN_MODE, modo_limpieza)

[McMoobud]

AMAZING!

[Lash-L]

Hi all!

Q10 support will be included in 2026.4. Keep in mind if you did any kind of local changes/modding to use our changes in the python-roborock library, I would recommend undoing them when you upgrade as you don't want to fall behind as new functionality and features/bug fixes are added.

This PR added support: home-assistant/core#165624

These PRs are adding additional support:

home-assistant/core#166120

home-assistant/core#166155

home-assistant/core#166142

home-assistant/core#166149

[jagimenose]

This isn't the first version of anything; it's just a personal workaround to get my Roborock q10 s5+ just working until official integration comes. Take it as is.

[MiezLisa]

This isn't the first version of anything; it's just a personal workaround to get my Roborock q10 s5+ just working until official integration comes. Take it as is.

My reply refers to the post by “Lash-L” (https://github.com/orgs/home-assistant/discussions/2249#discussioncomment-16260748
), not to your “jagimenose” workaround — sorry, there was a misunderstanding.

[logname]

It is a bit of a lunchbag letdown isn't it? Especially since I was able to use an AI agent with existing work and get most of those settings in a Groovy driver for Hubitat. I don't want to downplay the work that has been done in anyway though. What I was able to get AI to build was only possible thanks to the really hard work done by human developers. AI is not intelligent despite the name, and it can only work with what you feed it.

However, I do think you can achieve most of the settings you seek by using the customize setting in the Roborock mobile app. If you assign custom settings to a map, then each time you initiate a cleaning from HA with that map, it will use those settings. Before I had the ability to clean by room from Hubitat, I was using this as a way to clean a specific room from Homey with specific settings for each. As an example, my kitchen and living room are divided by a partition wall with a large opening between them. The robot of course maps them as two rooms, so I just mapped both rooms twice and then used the Roborock map editor to erase the kitchen on one map and erase the living room on the other map. When I called up the map that only contained the Kitchen, it would use the customized settings (i.e. Vac & Mop, Suction Power, Cycles and Cleaning Route Preference). No reason you shouldn't be able to do the same thing with Home Assistant.

Note that when I worked with the AI agent to build the driver for Hubitat, it was not able to find a way to control cycles and cleaning route preferences. This may only be possible from the Roborock mobile app, so you might always need to control those two features from the app, or via the "customize" option for maps. The Q10 S5+ is not like the robots that have come before it, so it's not a simple app or driver conversion or anything like that.

[Hanis127]

Hi, first of all, thanks for your work.

Unfortunately, this is quite frustrating. I’ve had the Roborock Q10 S5 for more than five months now—it's a perfect fit for me and my apartment. I just wanted a small robot that vacuums and maybe occasionally mops.

So I was even more excited when the April update finally added support for my robot in Home Assistant. I installed the update full of anticipation—and now I’m very disappointed...

No battery level information No option to select cleaning modes (vacuum & mop, vacuum only, mop only, vacuum then mop) No option to set the number of cleaning cycles (once or twice) No option to control water usage while mopping (water flow) No option to adjust how tight the cleaning lines are (preferred cleaning route)

The only thing that can be adjusted is the suction power.

As far as I understand, the Q10 S5 can only be started in “vacuum & mop” mode, without any ability to configure more detailed options. If I forget to remove the mop holder, the robot will always mop—whether I want it to or not! That’s not good.

I understand that not everything can be included in the first version, but having the basic functions would have been nice. Sorry for the negative feedback—I’m just disappointed...

Additional features might get supported after the initial Q10 implementation
Python-roborock/python-roborock#767

[Lash-L]

Yes more features are coming. There are a number of open PRs onto the home assistant repo that just weren't finished before the beta cutoff.

[vmedunytsia]

Will the Roborock Q7 TF have maps, rooms, and a battery in the home assistant?

[Lash-L]

Yes, it's getting there:

Python-roborock/python-roborock#785

along with a few others. unfortunately, the map is a completely different structure than the maps for other vacuums.

[nuno-carvalho]

Could a list of Qxx compatible products be available?

I'm thinking on buying Roborock Q10VF, and I would like to know previously if it will work

[Zae]

I just want to say, thank you very much for the hard work! <3

[izotop510]

Thanks to the developers for your contributions , I hope you can improve the integration soon . ;)