pymammotion 0.2.62__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/mammotion/commands/messages/system.py

@@ -1,16 +1,19 @@
 # === sendOrderMsg_Sys ===
-import datetime
 from abc import ABC
+import datetime
+import time
 
 from pymammotion import logger
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
-from pymammotion.mammotion.commands.messages.navigation import MessageNavigation
-from pymammotion.proto.luba_msg import LubaMsg, MsgAttr, MsgCmdType, MsgDevice
-from pymammotion.proto.mctrl_sys import (
+from pymammotion.proto import (
     DeviceProductTypeInfoT,
     LoraCfgReq,
+    LubaMsg,
     MctlSys,
     MCtrlSimulationCmdData,
+    MsgAttr,
+    MsgCmdType,
+    MsgDevice,
     ReportInfoCfg,
     RptAct,
     RptInfoType,
@@ -19,38 +22,45 @@ from pymammotion.proto.mctrl_sys import (
     SysSetDateTime,
     TimeCtrlLight,
 )
-from pymammotion.utility.device_type import DeviceType
 
 
 class MessageSystem(AbstractMessage, ABC):
-    messageNavigation: MessageNavigation = MessageNavigation()
-
-    def send_order_msg_sys(self, sys):
+    def send_order_msg_sys(self, sys) -> bytes:
         luba_msg = LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_SYS,
+            msgtype=MsgCmdType.EMBED_SYS,
+            msgattr=MsgAttr.REQ,
             sender=MsgDevice.DEV_MOBILEAPP,
-            rcver=self.get_msg_device(MsgCmdType.MSG_CMD_TYPE_EMBED_SYS, MsgDevice.DEV_MAINCTL),
+            rcver=self.get_msg_device(MsgCmdType.EMBED_SYS, MsgDevice.DEV_MAINCTL),
             sys=sys,
+            seqs=self.seqs.increment_and_get() & 255,
+            version=1,
+            subtype=self.user_account,
+            timestamp=round(time.time() * 1000),
         )
 
         return luba_msg.SerializeToString()
 
-    def send_order_msg_sys_legacy(self, sys):
+    def send_order_msg_sys_legacy(self, sys) -> bytes:
         luba_msg = LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_SYS,
+            msgtype=MsgCmdType.EMBED_SYS,
+            msgattr=MsgAttr.REQ,
             sender=MsgDevice.DEV_MOBILEAPP,
             rcver=MsgDevice.DEV_MAINCTL,
             sys=sys,
+            seqs=self.seqs.increment_and_get() & 255,
+            version=1,
+            subtype=self.user_account,
+            timestamp=round(time.time() * 1000),
         )
 
         return luba_msg.SerializeToString()
 
-    def reset_system(self):
+    def reset_system(self) -> bytes:
         build = MctlSys(todev_reset_system=1)
         logger.debug("Send command - send factory reset")
         return self.send_order_msg_sys(build)
 
-    def set_blade_control(self, on_off: int):
+    def set_blade_control(self, on_off: int) -> bytes:
         mctlsys = MctlSys()
         sys_knife_control = SysKnifeControl()
         sys_knife_control.knife_status = on_off
@@ -58,10 +68,10 @@ class MessageSystem(AbstractMessage, ABC):
 
         return self.send_order_msg_sys(mctlsys)
 
-    def get_device_product_model(self):
-        return self.send_order_msg_sys(MctlSys(device_product_type_info=DeviceProductTypeInfoT()))
+    def get_device_product_model(self) -> bytes:
+        return self.send_order_msg_sys(MctlSys(device_product_type_info=DeviceProductTypeInfoT(result=1)))
 
-    def read_and_set_sidelight(self, is_sidelight: bool, operate: int):
+    def read_and_set_sidelight(self, is_sidelight: bool, operate: int) -> bytes:
         """Read state of sidelight as well as set it."""
         if is_sidelight:
             build = TimeCtrlLight(
@@ -90,7 +100,7 @@ class MessageSystem(AbstractMessage, ABC):
             is_sidelight}, operate:{operate}, timeCtrlLight:{build}")
         return self.send_order_msg_sys(build2)
 
-    def test_tool_order_to_sys(self, sub_cmd: int, param_id: int, param_value: list[int]):
+    def test_tool_order_to_sys(self, sub_cmd: int, param_id: int, param_value: list[int]) -> bytes:
         build = MCtrlSimulationCmdData(sub_cmd=sub_cmd, param_id=param_id, param_value=param_value)
         logger.debug(f"Send tool test command: subCmd={sub_cmd}, param_id:{
             param_id}, param_value={param_value}")
@@ -99,20 +109,14 @@ class MessageSystem(AbstractMessage, ABC):
             param_id}, param_value={param_value}")
         return self.send_order_msg_sys(build2)
 
-    def read_and_set_rtk_paring_code(self, op: int, cgf: str | None = None):
+    def read_and_set_rtk_paring_code(self, op: int, cgf: str | None = None) -> bytes:
         logger.debug(f"Send read and write base station configuration quality op:{
             op}, cgf:{cgf}")
         return self.send_order_msg_sys(MctlSys(todev_lora_cfg_req=LoraCfgReq(op=op, cfg=cgf)))
 
-    def allpowerfull_rw(self, id: int, context: int, rw: int):
-        if (id == 6 or id == 3 or id == 7) and DeviceType.is_luba_2(self.get_device_name()):
-            self.messageNavigation.allpowerfull_rw_adapter_x3(id, context, rw)
-            return
-        build = MctlSys(bidire_comm_cmd=SysCommCmd(id=id, context=context, rw=rw))
-        logger.debug(f"Send command - 9 general read and write command id={id}, context={context}, rw={rw}")
-        if id == 5:
-            # This logic doesnt make snese, but its what they had so..
-            return self.send_order_msg_sys(build)
+    def allpowerfull_rw(self, rw_id: int, context: int, rw: int) -> bytes:
+        build = MctlSys(bidire_comm_cmd=SysCommCmd(id=rw_id, context=context, rw=rw))
+        logger.debug(f"Send command - 9 general read and write command id={rw_id}, context={context}, rw={rw}")
         return self.send_order_msg_sys(build)
 
     # Commented out as not needed and too many refs to try fix up
@@ -175,7 +179,8 @@ class MessageSystem(AbstractMessage, ABC):
     #         test_id}, testDuration={test_duration}", "Factory tool logger.debug222", True)
     #     return self.send_order_msg_sys(build2)
 
-    def send_sys_set_date_time(self):
+    def send_sys_set_date_time(self) -> bytes:
+        # TODO get HA timezone
         calendar = datetime.datetime.now()
         i = calendar.year
         i2 = calendar.month
@@ -209,9 +214,12 @@ class MessageSystem(AbstractMessage, ABC):
         )
         return self.send_order_msg_sys(build)
 
-    def get_device_version_info(self):
+    def get_device_version_info(self) -> bytes:
         return self.send_order_msg_sys(MctlSys(todev_get_dev_fw_info=1))
 
+    def read_and_set_rtk_pairing_code(self, op: int, cfg: str) -> bytes:
+        return self.send_order_msg_sys(MctlSys(todev_lora_cfg_req=LoraCfgReq(op=op, cfg=cfg)))
+
     # === sendOrderMsg_Sys2 ===
 
     def request_iot_sys(
@@ -234,12 +242,26 @@ class MessageSystem(AbstractMessage, ABC):
             )
         )
         logger.debug(f"Send command==== IOT slim data Act {
-            build.todev_report_cfg.act} {build}")
+            build.todev_report_cfg.act}")
         return self.send_order_msg_sys_legacy(build)
 
+    def get_maintenance(self) -> bytes:
+        return self.request_iot_sys(
+            rpt_act=RptAct.RPT_START,
+            rpt_info_type=[
+                RptInfoType.RIT_MAINTAIN,
+                RptInfoType.RIT_BASESTATION_INFO,
+                RptInfoType.RIT_FW_INFO,
+            ],
+            timeout=1000,
+            period=1000,
+            no_change_period=2000,
+            count=3,
+        )
+
     def get_report_cfg_stop(self, timeout: int = 10000, period: int = 1000, no_change_period: int = 1000):
         # TODO use send_order_msg_sys_legacy
-        mctlsys = MctlSys(
+        mctl_sys = MctlSys(
             todev_report_cfg=ReportInfoCfg(
                 act=RptAct.RPT_STOP,
                 timeout=timeout,
@@ -249,30 +271,32 @@ class MessageSystem(AbstractMessage, ABC):
             )
         )
 
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_CONNECT)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_RTK)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_LOCAL)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_WORK)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_STA)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_MAINTAIN)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_POINT)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_VIO)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_STATISTIC)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_CONNECT)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_RTK)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_LOCAL)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_WORK)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_STA)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_POINT)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_VIO)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_STATISTIC)
 
-        lubaMsg = LubaMsg()
-        lubaMsg.msgtype = MsgCmdType.MSG_CMD_TYPE_EMBED_SYS
-        lubaMsg.sender = MsgDevice.DEV_MOBILEAPP
-        lubaMsg.rcver = MsgDevice.DEV_MAINCTL
-        lubaMsg.msgattr = MsgAttr.MSG_ATTR_REQ
-        lubaMsg.seqs = 1
-        lubaMsg.version = 1
-        lubaMsg.subtype = 1
-        lubaMsg.sys = mctlsys
-        return lubaMsg.SerializeToString()
+        luba_msg = LubaMsg(
+            msgtype=MsgCmdType.EMBED_SYS,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=MsgDevice.DEV_MAINCTL,
+            msgattr=MsgAttr.REQ,
+            seqs=self.seqs.increment_and_get() & 255,
+            version=1,
+            subtype=self.user_account,
+            sys=mctl_sys,
+            timestamp=round(time.time() * 1000),
+        )
+
+        return luba_msg.SerializeToString()
 
     def get_report_cfg(self, timeout: int = 10000, period: int = 1000, no_change_period: int = 2000):
         # TODO use send_order_msg_sys_legacy
-        mctlsys = MctlSys(
+        mctl_sys = MctlSys(
             todev_report_cfg=ReportInfoCfg(
                 act=RptAct.RPT_START,
                 timeout=timeout,
@@ -282,24 +306,25 @@ class MessageSystem(AbstractMessage, ABC):
             )
         )
 
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_CONNECT)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_RTK)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_LOCAL)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_WORK)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_STA)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_MAINTAIN)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_POINT)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_VIO)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_STATISTIC)
-        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_BASESTATION_INFO)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_CONNECT)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_RTK)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_LOCAL)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_WORK)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_STA)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_POINT)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_VIO)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_STATISTIC)
+        mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_BASESTATION_INFO)
 
-        lubaMsg = LubaMsg()
-        lubaMsg.msgtype = MsgCmdType.MSG_CMD_TYPE_EMBED_SYS
-        lubaMsg.sender = MsgDevice.DEV_MOBILEAPP
-        lubaMsg.rcver = MsgDevice.DEV_MAINCTL
-        lubaMsg.msgattr = MsgAttr.MSG_ATTR_REQ
-        lubaMsg.seqs = 1
-        lubaMsg.version = 1
-        lubaMsg.subtype = 1
-        lubaMsg.sys = mctlsys
-        return lubaMsg.SerializeToString()
+        luba_msg = LubaMsg(
+            msgtype=MsgCmdType.EMBED_SYS,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=MsgDevice.DEV_MAINCTL,
+            msgattr=MsgAttr.REQ,
+            seqs=self.seqs.increment_and_get() & 255,
+            version=1,
+            subtype=self.user_account,
+            sys=mctl_sys,
+            timestamp=round(time.time() * 1000),
+        )
+        return luba_msg.SerializeToString()

pymammotion/mammotion/commands/messages/video.py

@@ -1,28 +1,33 @@
 # === sendOrderMsg_Video ===
 from abc import ABC
+import time
 
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
-from pymammotion.proto import luba_msg_pb2, luba_mul_pb2
-from pymammotion.proto.luba_msg import MsgCmdType, MsgDevice
+from pymammotion.proto import LubaMsg, MsgAttr, MsgCmdType, MsgDevice, MulCameraPosition, MulSetVideo, SocMul
 from pymammotion.utility.device_type import DeviceType
 
 
 class MessageVideo(AbstractMessage, ABC):
-    async def send_order_msg_video(self, mul):
-        luba_msg = luba_msg_pb2.LubaMsg(
-            msgtype=luba_msg_pb2.MSG_CMD_TYPE_MUL,
-            sender=luba_msg_pb2.DEV_MOBILEAPP,
-            rcver=self.get_msg_device(MsgCmdType.MSG_CMD_TYPE_MUL, MsgDevice.SOC_MODULE_MULTIMEDIA),
+    def send_order_msg_video(self, mul: SocMul):
+        luba_msg = LubaMsg(
+            msgtype=MsgCmdType.MUL,
+            msgattr=MsgAttr.REQ,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=self.get_msg_device(MsgCmdType.MUL, MsgDevice.SOC_MODULE_MULTIMEDIA),
             mul=mul,
+            seqs=self.seqs.increment_and_get() & 255,
+            version=1,
+            subtype=self.user_account,
+            timestamp=round(time.time() * 1000),
         )
 
         return luba_msg.SerializeToString()
 
     def device_agora_join_channel_with_position(self, enter_state: int):
         position = (
-            luba_mul_pb2.MUL_CAMERA_POSITION.ALL
-            if DeviceType.is_yuka(self.get_device_name())
-            else luba_mul_pb2.MUL_CAMERA_POSITION.LEFT
+            MulCameraPosition.ALL
+            if DeviceType.value_of_str(self.get_device_name()).get_value() == DeviceType.LUBA_YUKA.get_value()
+            else MulCameraPosition.LEFT
         )
-        mctl_sys = luba_mul_pb2.SocMul(set_video=luba_mul_pb2.MulSetVideo(position=position, vi_switch=enter_state))
-        return self.send_order_msg_video(mctl_sys)
+        soc_mul = SocMul(set_video=MulSetVideo(position=position, vi_switch=enter_state))
+        return self.send_order_msg_video(soc_mul)

pymammotion/mammotion/devices/__init__.py

@@ -1,5 +1,29 @@
-"""mqtt init."""
+"""Mammotion devices module."""
 
-from .mammotion import MammotionBaseBLEDevice
+from .mammotion import Mammotion, MammotionDeviceManager
+from .mammotion_bluetooth import MammotionBaseBLEDevice
+from .mammotion_cloud import MammotionBaseCloudDevice, MammotionCloud
+from .mammotion_mower_ble import MammotionMowerBLEDevice
+from .mammotion_mower_cloud import MammotionMowerCloudDevice
+from .mower_device import MammotionMowerDevice
+from .mower_manager import MammotionMowerDeviceManager
+from .rtk_ble import MammotionRTKBLEDevice
+from .rtk_cloud import MammotionRTKCloudDevice
+from .rtk_device import MammotionRTKDevice
+from .rtk_manager import MammotionRTKDeviceManager
 
-__all__ = ["MammotionBaseBLEDevice"]
+__all__ = [
+    "Mammotion",
+    "MammotionDeviceManager",
+    "MammotionMowerDeviceManager",
+    "MammotionBaseBLEDevice",
+    "MammotionBaseCloudDevice",
+    "MammotionCloud",
+    "MammotionMowerBLEDevice",
+    "MammotionMowerCloudDevice",
+    "MammotionMowerDevice",
+    "MammotionRTKBLEDevice",
+    "MammotionRTKCloudDevice",
+    "MammotionRTKDevice",
+    "MammotionRTKDeviceManager",
+]

pymammotion/mammotion/devices/base.py

@@ -1,100 +1,35 @@
+from abc import ABC, abstractmethod
 import asyncio
 import logging
-from abc import abstractmethod
-from typing import Any, Awaitable, Callable
+from typing import Any
 
-import betterproto
+import betterproto2
 
 from pymammotion.aliyun.model.dev_by_account_response import Device
-from pymammotion.data.model import RegionData
 from pymammotion.data.model.device import MowingDevice
-from pymammotion.data.state_manager import StateManager
-from pymammotion.proto.luba_msg import LubaMsg
-from pymammotion.proto.mctrl_nav import NavGetCommDataAck, NavGetHashListAck
+from pymammotion.data.model.raw_data import RawMowerData
+from pymammotion.data.mower_state_manager import MowerStateManager
+from pymammotion.proto import LubaMsg
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def find_next_integer(lst: list[int], current_hash: int) -> int | None:
-    try:
-        # Find the index of the current integer
-        current_index = lst.index(current_hash)
-
-        # Check if there is a next integer in the list
-        if current_index + 1 < len(lst):
-            return lst[current_index + 1]
-        else:
-            return None  # Or raise an exception or handle it in some other way
-    except ValueError:
-        # Handle the case where current_int is not in the list
-        return None  # Or raise an exception or handle it in some other way
-
-
-class MammotionBaseDevice:
+class MammotionBaseDevice(ABC):
     """Base class for Mammotion devices."""
 
-    _state_manager: StateManager
-    _cloud_device: Device | None = None
-
-    def __init__(self, device: MowingDevice, cloud_device: Device | None = None) -> None:
+    def __init__(self, state_manager: MowerStateManager, cloud_device: Device) -> None:
         """Initialize MammotionBaseDevice."""
         self.loop = asyncio.get_event_loop()
-        self._raw_data = LubaMsg().to_dict(casing=betterproto.Casing.SNAKE)
-        self._state_manager = StateManager(device)
-        self._state_manager.gethash_ack_callback = self.datahash_response
-        self._state_manager.get_commondata_ack_callback = self.commdata_response
+        self._state_manager = state_manager
+        self._raw_data = dict()
+        self._raw_mower_data: RawMowerData = RawMowerData()
         self._notify_future: asyncio.Future[bytes] | None = None
         self._cloud_device = cloud_device
 
-    def set_notification_callback(self, func: Callable[[], Awaitable[None]]) -> None:
-        self._state_manager.on_notification_callback = func
-
-    def set_queue_callback(self, func: Callable[[str, dict[str, Any]], Awaitable[bytes]]) -> None:
-        self._state_manager.queue_command_callback = func
-
-    async def datahash_response(self, hash_ack: NavGetHashListAck) -> None:
-        """Handle datahash responses."""
-        current_frame = hash_ack.current_frame
-
-        missing_frames = self.mower.map.missing_hash_frame()
-        if len(missing_frames) == 0:
-            data_hash = self.mower.map.missing_hashlist.pop()
-            return await self.queue_command("synchronize_hash_data", hash_num=data_hash)
-
-        if current_frame != missing_frames[0] - 1:
-            current_frame = missing_frames[0] - 1
-        await self.queue_command("get_hash_response", total_frame=hash_ack.total_frame, current_frame=current_frame)
-
-    async def commdata_response(self, common_data: NavGetCommDataAck) -> None:
-        """Handle common data responses."""
-        total_frame = common_data.total_frame
-        current_frame = common_data.current_frame
-
-        missing_frames = self.mower.map.missing_frame(common_data)
-        if len(missing_frames) == 0:
-            # get next in hash ack list
-
-            data_hash = self.mower.map.missing_hashlist.pop() if len(self.mower.map.missing_hashlist) > 0 else None
-            if data_hash is None:
-                return
-
-            await self.queue_command("synchronize_hash_data", hash_num=data_hash)
-        else:
-            if current_frame != missing_frames[0] - 1:
-                current_frame = missing_frames[0] - 1
-
-            region_data = RegionData()
-            region_data.hash = common_data.hash
-            region_data.action = common_data.action
-            region_data.type = common_data.type
-            region_data.total_frame = total_frame
-            region_data.current_frame = current_frame
-            await self.queue_command("get_regional_data", regional_data=region_data)
-
     def _update_raw_data(self, data: bytes) -> None:
         """Update raw and model data from notifications."""
         tmp_msg = LubaMsg().parse(data)
-        res = betterproto.which_one_of(tmp_msg, "LubaSubMsg")
+        res = betterproto2.which_one_of(tmp_msg, "LubaSubMsg")
         match res[0]:
             case "nav":
                 self._update_nav_data(tmp_msg)
@@ -109,11 +44,11 @@ class MammotionBaseDevice:
             case "ota":
                 self._update_ota_data(tmp_msg)
 
-        self.mower.update_raw(self._raw_data)
+        self._raw_mower_data.update_raw(self._raw_data)
 
     def _update_nav_data(self, tmp_msg) -> None:
         """Update navigation data."""
-        nav_sub_msg = betterproto.which_one_of(tmp_msg.nav, "SubNavMsg")
+        nav_sub_msg = betterproto2.which_one_of(tmp_msg.nav, "SubNavMsg")
         if nav_sub_msg[1] is None:
             _LOGGER.debug("Sub message was NoneType %s", nav_sub_msg[0])
             return
@@ -121,32 +56,32 @@ class MammotionBaseDevice:
         if isinstance(nav_sub_msg[1], int):
             nav[nav_sub_msg[0]] = nav_sub_msg[1]
         else:
-            nav[nav_sub_msg[0]] = nav_sub_msg[1].to_dict(casing=betterproto.Casing.SNAKE)
+            nav[nav_sub_msg[0]] = nav_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["nav"] = nav
 
-    def _update_sys_data(self, tmp_msg) -> None:
+    def _update_sys_data(self, tmp_msg: LubaMsg) -> None:
         """Update system data."""
-        sys_sub_msg = betterproto.which_one_of(tmp_msg.sys, "SubSysMsg")
+        sys_sub_msg = betterproto2.which_one_of(tmp_msg.sys, "SubSysMsg")
         if sys_sub_msg[1] is None:
             _LOGGER.debug("Sub message was NoneType %s", sys_sub_msg[0])
             return
         sys = self._raw_data.get("sys", {})
-        sys[sys_sub_msg[0]] = sys_sub_msg[1].to_dict(casing=betterproto.Casing.SNAKE)
+        sys[sys_sub_msg[0]] = sys_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["sys"] = sys
 
-    def _update_driver_data(self, tmp_msg) -> None:
+    def _update_driver_data(self, tmp_msg: LubaMsg) -> None:
         """Update driver data."""
-        drv_sub_msg = betterproto.which_one_of(tmp_msg.driver, "SubDrvMsg")
+        drv_sub_msg = betterproto2.which_one_of(tmp_msg.driver, "SubDrvMsg")
         if drv_sub_msg[1] is None:
             _LOGGER.debug("Sub message was NoneType %s", drv_sub_msg[0])
             return
         drv = self._raw_data.get("driver", {})
-        drv[drv_sub_msg[0]] = drv_sub_msg[1].to_dict(casing=betterproto.Casing.SNAKE)
+        drv[drv_sub_msg[0]] = drv_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["driver"] = drv
 
-    def _update_net_data(self, tmp_msg) -> None:
+    def _update_net_data(self, tmp_msg: LubaMsg) -> None:
         """Update network data."""
-        net_sub_msg = betterproto.which_one_of(tmp_msg.net, "NetSubType")
+        net_sub_msg = betterproto2.which_one_of(tmp_msg.net, "NetSubType")
         if net_sub_msg[1] is None:
             _LOGGER.debug("Sub message was NoneType %s", net_sub_msg[0])
             return
@@ -154,27 +89,27 @@ class MammotionBaseDevice:
         if isinstance(net_sub_msg[1], int):
             net[net_sub_msg[0]] = net_sub_msg[1]
         else:
-            net[net_sub_msg[0]] = net_sub_msg[1].to_dict(casing=betterproto.Casing.SNAKE)
+            net[net_sub_msg[0]] = net_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["net"] = net
 
-    def _update_mul_data(self, tmp_msg) -> None:
+    def _update_mul_data(self, tmp_msg: LubaMsg) -> None:
         """Update mul data."""
-        mul_sub_msg = betterproto.which_one_of(tmp_msg.mul, "SubMul")
+        mul_sub_msg = betterproto2.which_one_of(tmp_msg.mul, "SubMul")
         if mul_sub_msg[1] is None:
             _LOGGER.debug("Sub message was NoneType %s", mul_sub_msg[0])
             return
         mul = self._raw_data.get("mul", {})
-        mul[mul_sub_msg[0]] = mul_sub_msg[1].to_dict(casing=betterproto.Casing.SNAKE)
+        mul[mul_sub_msg[0]] = mul_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["mul"] = mul
 
-    def _update_ota_data(self, tmp_msg) -> None:
+    def _update_ota_data(self, tmp_msg: LubaMsg) -> None:
         """Update OTA data."""
-        ota_sub_msg = betterproto.which_one_of(tmp_msg.ota, "SubOtaMsg")
+        ota_sub_msg = betterproto2.which_one_of(tmp_msg.ota, "SubOtaMsg")
         if ota_sub_msg[1] is None:
             _LOGGER.debug("Sub message was NoneType %s", ota_sub_msg[0])
             return
         ota = self._raw_data.get("ota", {})
-        ota[ota_sub_msg[0]] = ota_sub_msg[1].to_dict(casing=betterproto.Casing.SNAKE)
+        ota[ota_sub_msg[0]] = ota_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["ota"] = ota
 
     @property
@@ -188,53 +123,41 @@ class MammotionBaseDevice:
         return self._state_manager.get_device()
 
     @abstractmethod
-    async def queue_command(self, key: str, **kwargs: any) -> bytes | None:
+    async def queue_command(self, key: str, **kwargs: Any) -> None:
         """Queue commands to mower."""
 
     @abstractmethod
-    async def _ble_sync(self):
+    async def _ble_sync(self) -> None:
         """Send ble sync command every 3 seconds or sooner."""
 
     @abstractmethod
-    def stop(self):
+    def stop(self) -> None:
         """Stop everything ready for destroying."""
 
-    async def start_sync(self, retry: int) -> None:
-        """Start synchronization with the device."""
-        await self.queue_command("get_device_base_info")
-        await self.queue_command("get_device_product_model")
-        await self.queue_command("get_report_cfg")
-        """RTK and dock location."""
-        await self.queue_command("allpowerfull_rw", id=5, rw=1, context=1)
-
-    async def start_map_sync(self) -> None:
-        """Start sync of map data."""
-
-        if self._cloud_device and len(self.mower.map.area_name) == 0:
-            await self.queue_command("get_area_name_list", device_id=self._cloud_device.iotId)
-
-        await self.queue_command("read_plan", sub_cmd=2, plan_index=0)
+    async def async_read_settings(self) -> None:
+        """Read settings from device."""
+        # no cutting in rain nav_sys_param_cmd (id 3 context 1/0)
+        await self.queue_command("read_write_device", rw_id=3, context=1, rw=0)
+        # ??
+        await self.queue_command("read_write_device", rw_id=4, context=1, rw=0)
+        # turning mode nav_sys_param_cmd (id 6, context 1/0)
+        await self.queue_command("read_write_device", rw_id=6, context=1, rw=0)
+        # traversal mode
+        await self.queue_command("read_write_device", rw_id=7, context=1, rw=0)
 
-        await self.queue_command("get_all_boundary_hash_list", sub_cmd=0)
-        await self.queue_command("get_hash_response", total_frame=1, current_frame=1)
-        if len(self.mower.map.missing_hashlist) > 0:
-            data_hash = self.mower.map.missing_hashlist.pop()
-            await self.queue_command("synchronize_hash_data", hash_num=data_hash)
+        await self.queue_command("read_and_set_sidelight", is_sidelight=True, operate=1)
 
-        # sub_cmd 3 is job hashes??
-        # sub_cmd 4 is dump location (yuka)
-        # jobs list
-        # hash_list_result = await self._send_command_with_args("get_all_boundary_hash_list", sub_cmd=3)
+        await self.queue_command("read_and_set_rtk_pairing_code", op=1, cfg="")
 
     async def async_get_errors(self) -> None:
         """Error codes."""
-        await self.queue_command("allpowerfull_rw", id=5, rw=1, context=2)
-        await self.queue_command("allpowerfull_rw", id=5, rw=1, context=3)
+        await self.queue_command("read_write_device", rw_id=5, rw=1, context=2)
+        await self.queue_command("read_write_device", rw_id=5, rw=1, context=3)
 
-    async def command(self, key: str, **kwargs):
+    async def command(self, key: str, **kwargs: Any) -> None:
         """Send a command to the device."""
-        return await self.queue_command(key, **kwargs)
+        await self.queue_command(key, **kwargs)
 
     @property
-    def state_manager(self):
+    def state_manager(self) -> MowerStateManager:
         return self._state_manager