pymammotion 0.4.0b8__py3-none-any.whl → 0.4.2__py3-none-any.whl

pymammotion/bluetooth/ble_message.py

@@ -16,8 +16,7 @@ from pymammotion.bluetooth.data.framectrldata import FrameCtrlData
 from pymammotion.bluetooth.data.notifydata import BlufiNotifyData
 from pymammotion.bluetooth.model.atomic_integer import AtomicInteger
 from pymammotion.data.model.execute_boarder import ExecuteBorder
-from pymammotion.proto import dev_net_pb2
-from pymammotion.proto.luba_msg import LubaMsg, MsgAttr, MsgCmdType, MsgDevice
+from pymammotion.proto import DevNet, DrvDevInfoReq, LubaMsg, MsgAttr, MsgCmdType, MsgDevice
 from pymammotion.utility.constant.device_constant import bleOrderCmd
 
 _LOGGER = logging.getLogger(__name__)
@@ -317,7 +316,7 @@ class BleMessage:
         hash_map = {"ctrl": 1}
         await self.post_custom_data(self.get_json_string(bleOrderCmd.bleAlive, hash_map))
 
-    def get_json_string(self, cmd: int, hash_map: dict[str, object]) -> str:
+    def get_json_string(self, cmd: int, hash_map: dict[str, int]) -> str:
         jSONObject = {}
         try:
             jSONObject["cmd"] = cmd
@@ -331,7 +330,7 @@ class BleMessage:
             print(e)
             return ""
 
-    def clearNotification(self) -> None:
+    def clear_notification(self) -> None:
         self.notification = None
         self.notification = BlufiNotifyData()
 
@@ -341,14 +340,14 @@ class BleMessage:
     async def send_device_info(self) -> None:
         """Currently not called"""
         luba_msg = LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_ESP,
+            msgtype=MsgCmdType.ESP,
             sender=MsgDevice.DEV_MOBILEAPP,
             rcver=MsgDevice.DEV_COMM_ESP,
-            msgattr=MsgAttr.MSG_ATTR_REQ,
+            msgattr=MsgAttr.REQ,
             seqs=1,
             version=1,
             subtype=1,
-            net=dev_net_pb2.DevNet(todev_ble_sync=1, todev_devinfo_req=dev_net_pb2.DrvDevInfoReq()),
+            net=DevNet(todev_ble_sync=1, todev_devinfo_req=DrvDevInfoReq()),
         )
         byte_arr = luba_msg.SerializeToString()
         await self.post_custom_data_bytes(byte_arr)

pymammotion/data/model/device.py

@@ -12,13 +12,7 @@ from pymammotion.data.model.report_info import ReportData
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
 from pymammotion.data.mqtt.status import ThingStatusMessage
 from pymammotion.http.model.http import ErrorInfo
-from pymammotion.proto.mctrl_sys import (
-    DeviceFwInfo,
-    MowToAppInfoT,
-    ReportInfoData,
-    SystemRapidStateTunnelMsg,
-    SystemUpdateBufMsg,
-)
+from pymammotion.proto import DeviceFwInfo, MowToAppInfoT, ReportInfoData, SystemRapidStateTunnelMsg, SystemUpdateBufMsg
 from pymammotion.utility.constant import WorkMode
 from pymammotion.utility.conversions import parse_double
 from pymammotion.utility.map import CoordinateConverter
@@ -28,6 +22,7 @@ from pymammotion.utility.map import CoordinateConverter
 class MowingDevice(DataClassORJSONMixin):
     """Wraps the betterproto dataclasses, so we can bypass the groups for keeping all data."""
 
+    name: str = ""
     online: bool = True
     mower_state: MowerInfo = field(default_factory=MowerInfo)
     mqtt_properties: ThingPropertiesMessage | None = None

pymammotion/data/model/device_limits.py

@@ -9,7 +9,7 @@ class RangeLimit:
 
 @dataclass
 class DeviceLimits:
-    cutter_height: RangeLimit = field(default_factory=RangeLimit)
+    blade_height: RangeLimit = field(default_factory=RangeLimit)
     working_speed: RangeLimit = field(default_factory=RangeLimit)
     working_path: RangeLimit = field(default_factory=RangeLimit)
     work_area_num_max: int = 60
@@ -18,7 +18,7 @@ class DeviceLimits:
     def to_dict(self) -> dict:
         """Convert the device limits to a dictionary format."""
         return {
-            "cutter_height": {"min": self.cutter_height.min, "max": self.cutter_height.max},
+            "blade_height": {"min": self.blade_height.min, "max": self.blade_height.max},
             "working_speed": {"min": self.working_speed.min, "max": self.working_speed.max},
             "working_path": {"min": self.working_path.min, "max": self.working_path.max},
             "work_area_num_max": self.work_area_num_max,
@@ -29,7 +29,7 @@ class DeviceLimits:
     def from_dict(cls, data: dict) -> "DeviceLimits":
         """Create a DeviceLimits instance from a dictionary."""
         return cls(
-            cutter_height=RangeLimit(min=data["cutter_height"]["min"], max=data["cutter_height"]["max"]),
+            blade_height=RangeLimit(min=data["blade_height"]["min"], max=data["blade_height"]["max"]),
             working_speed=RangeLimit(min=data["working_speed"]["min"], max=data["working_speed"]["max"]),
             working_path=RangeLimit(min=data["working_path"]["min"], max=data["working_path"]["max"]),
             work_area_num_max=data["work_area_num_max"],
@@ -40,7 +40,7 @@ class DeviceLimits:
         """Validate that all ranges are logical (min <= max)."""
         return all(
             [
-                self.cutter_height.min <= self.cutter_height.max,
+                self.blade_height.min <= self.blade_height.max,
                 self.working_speed.min <= self.working_speed.max,
                 self.working_path.min <= self.working_path.max,
                 self.work_area_num_max > 0,

pymammotion/data/model/hash_list.py

@@ -3,7 +3,7 @@ from enum import IntEnum
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
-from pymammotion.proto.mctrl_nav import NavGetCommDataAck, NavGetHashListAck, SvgMessageAckT
+from pymammotion.proto import NavGetCommDataAck, SvgMessageAckT
 
 
 class PathType(IntEnum):
@@ -16,21 +16,91 @@ class PathType(IntEnum):
     SVG = 13
 
 
+@dataclass
+class CommDataCouple:
+    x: float = 0.0
+    y: float = 0.0
+
+
+@dataclass
+class AreaLabelName(DataClassORJSONMixin):
+    label: str = ""
+
+
+@dataclass
+class NavGetCommData(DataClassORJSONMixin):
+    pver: int = 0
+    sub_cmd: int = 0
+    result: int = 0
+    action: int = 0
+    type: int = 0
+    hash: int = 0
+    paternal_hash_a: int = 0
+    paternal_hash_b: int = 0
+    total_frame: int = 0
+    current_frame: int = 0
+    data_hash: int = 0
+    data_len: int = 0
+    data_couple: list["CommDataCouple"] = field(default_factory=list)
+    reserved: str = ""
+    area_label: "AreaLabelName" = field(default_factory=AreaLabelName)
+
+
+@dataclass
+class SvgMessageData(DataClassORJSONMixin):
+    x_move: float = 0.0
+    y_move: float = 0.0
+    scale: float = 0.0
+    rotate: float = 0.0
+    base_width_m: float = 0.0
+    base_width_pix: int = 0
+    base_height_m: float = 0.0
+    base_height_pix: int = 0
+    data_count: int = 0
+    hide_svg: bool = False
+    name_count: int = 0
+    svg_file_name: str = ""
+    svg_file_data: str = ""
+
+
+@dataclass
+class SvgMessage(DataClassORJSONMixin):
+    pver: int = 0
+    sub_cmd: int = 0
+    total_frame: int = 0
+    current_frame: int = 0
+    data_hash: int = 0
+    paternal_hash_a: int = 0
+    type: int = 0
+    result: int = 0
+    svg_message: "SvgMessageData" = field(default_factory=SvgMessageData)
+
+
 @dataclass
 class FrameList(DataClassORJSONMixin):
     total_frame: int
-    data: list[NavGetCommDataAck | SvgMessageAckT]
+    data: list[NavGetCommData | SvgMessage]
 
 
-@dataclass
-class NavGetHashListData(DataClassORJSONMixin, NavGetHashListAck):
+@dataclass(eq=False, repr=False)
+class NavGetHashListData(DataClassORJSONMixin):
     """Dataclass for NavGetHashListData."""
 
+    pver: int = 0
+    sub_cmd: int = 0
+    total_frame: int = 0
+    current_frame: int = 0
+    data_hash: int = 0
+    hash_len: int = 0
+    reserved: str = ""
+    result: int = 0
+    data_couple: list[int] = field(default_factory=list)
+
 
 @dataclass
 class RootHashList(DataClassORJSONMixin):
     total_frame: int = 0
-    data: list[NavGetHashListAck] = field(default_factory=list)
+    data: list[NavGetHashListData] = field(default_factory=list)
 
 
 @dataclass
@@ -81,7 +151,7 @@ class HashList(DataClassORJSONMixin):
             )
         ]
 
-    def update_root_hash_list(self, hash_list: NavGetHashListAck) -> None:
+    def update_root_hash_list(self, hash_list: NavGetHashListData) -> None:
         self.root_hash_list.total_frame = hash_list.total_frame
 
         for index, obj in enumerate(self.root_hash_list.data):
@@ -93,7 +163,7 @@ class HashList(DataClassORJSONMixin):
         # If no match was found, append the new item
         self.root_hash_list.data.append(hash_list)
 
-    def missing_hash_frame(self):
+    def missing_hash_frame(self) -> list[int]:
         return self._find_missing_frames(self.root_hash_list)
 
     def missing_frame(self, hash_data: NavGetCommDataAck | SvgMessageAckT) -> list[int]:
@@ -112,7 +182,9 @@ class HashList(DataClassORJSONMixin):
         if hash_data.type == PathType.SVG:
             return self._find_missing_frames(self.svg.get(hash_data.data_hash))
 
-    def update(self, hash_data: NavGetCommDataAck | SvgMessageAckT) -> bool:
+        return []
+
+    def update(self, hash_data: NavGetCommData | SvgMessage) -> bool:
         """Update the map data."""
         if hash_data.type == PathType.AREA:
             existing_name = next((area for area in self.area_name if area.hash == hash_data.hash), None)
@@ -133,6 +205,8 @@ class HashList(DataClassORJSONMixin):
         if hash_data.type == PathType.SVG:
             return self._add_hash_data(self.svg, hash_data)
 
+        return False
+
     @staticmethod
     def _find_missing_frames(frame_list: FrameList | RootHashList) -> list[int]:
         if frame_list.total_frame == len(frame_list.data):
@@ -144,8 +218,8 @@ class HashList(DataClassORJSONMixin):
         return missing_numbers
 
     @staticmethod
-    def _add_hash_data(hash_dict: dict, hash_data: NavGetCommDataAck | SvgMessageAckT) -> bool:
-        if isinstance(hash_data, SvgMessageAckT):
+    def _add_hash_data(hash_dict: dict, hash_data: NavGetCommData | SvgMessage) -> bool:
+        if isinstance(hash_data, SvgMessage):
             if hash_dict.get(hash_data.data_hash) is None:
                 hash_dict[hash_data.data_hash] = FrameList(total_frame=hash_data.total_frame, data=[hash_data])
                 return True

pymammotion/data/model/raw_data.py

@@ -2,14 +2,7 @@ from dataclasses import dataclass, field
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
-from pymammotion.proto.dev_net import DevNet
-from pymammotion.proto.luba_msg import LubaMsg
-from pymammotion.proto.luba_mul import SocMul
-from pymammotion.proto.mctrl_driver import MctlDriver
-from pymammotion.proto.mctrl_nav import MctlNav
-from pymammotion.proto.mctrl_ota import MctlOta
-from pymammotion.proto.mctrl_pept import MctlPept
-from pymammotion.proto.mctrl_sys import MctlSys
+from pymammotion.proto import DevNet, LubaMsg, MctlDriver, MctlNav, MctlOta, MctlPept, MctlSys, SocMul
 
 
 @dataclass

pymammotion/data/state_manager.py

@@ -9,13 +9,22 @@ import betterproto
 
 from pymammotion.data.model.device import MowingDevice
 from pymammotion.data.model.device_info import SideLight
-from pymammotion.data.model.hash_list import AreaHashNameList
+from pymammotion.data.model.hash_list import AreaHashNameList, NavGetCommData, NavGetHashListData, SvgMessage
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
 from pymammotion.data.mqtt.status import ThingStatusMessage
-from pymammotion.proto.dev_net import DrvDevInfoResp, DrvDevInfoResult, WifiIotStatusReport
-from pymammotion.proto.luba_msg import LubaMsg
-from pymammotion.proto.mctrl_nav import AppGetAllAreaHashName, NavGetCommDataAck, NavGetHashListAck, SvgMessageAckT
-from pymammotion.proto.mctrl_sys import DeviceFwInfo, DeviceProductTypeInfoT, TimeCtrlLight
+from pymammotion.proto import (
+    AppGetAllAreaHashName,
+    DeviceFwInfo,
+    DeviceProductTypeInfoT,
+    DrvDevInfoResp,
+    DrvDevInfoResult,
+    LubaMsg,
+    NavGetCommDataAck,
+    NavGetHashListAck,
+    SvgMessageAckT,
+    TimeCtrlLight,
+    WifiIotStatusReport,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -59,6 +68,8 @@ class StateManager:
         if not self._device.online:
             self._device.online = True
         self._device.status_properties = thing_status
+        if self._device.mower_state.product_key == "":
+            self._device.mower_state.product_key = thing_status.params.productKey
 
     @property
     def online(self) -> bool:
@@ -90,6 +101,9 @@ class StateManager:
         """Handle protobuf notifications."""
         res = betterproto.which_one_of(message, "LubaSubMsg")
         self.last_updated_at = datetime.now()
+        # additional catch all if we don't get a status update
+        if not self._device.online:
+            self._device.online = True
 
         match res[0]:
             case "nav":
@@ -113,18 +127,24 @@ class StateManager:
         match nav_msg[0]:
             case "toapp_gethash_ack":
                 hashlist_ack: NavGetHashListAck = nav_msg[1]
-                self._device.map.update_root_hash_list(hashlist_ack)
+                self._device.map.update_root_hash_list(
+                    NavGetHashListData.from_dict(hashlist_ack.to_dict(casing=betterproto.Casing.SNAKE))
+                )
                 await self.gethash_ack_callback(nav_msg[1])
             case "toapp_get_commondata_ack":
                 common_data: NavGetCommDataAck = nav_msg[1]
-                updated = self._device.map.update(common_data)
+                updated = self._device.map.update(
+                    NavGetCommData.from_dict(common_data.to_dict(casing=betterproto.Casing.SNAKE))
+                )
                 if updated:
                     await self.get_commondata_ack_callback(common_data)
             case "toapp_svg_msg":
-                common_data: SvgMessageAckT = nav_msg[1]
-                updated = self._device.map.update(common_data)
+                common_svg_data: SvgMessageAckT = nav_msg[1]
+                updated = self._device.map.update(
+                    SvgMessage.from_dict(common_svg_data.to_dict(casing=betterproto.Casing.SNAKE))
+                )
                 if updated:
-                    await self.get_commondata_ack_callback(common_data)
+                    await self.get_commondata_ack_callback(common_svg_data)
 
             case "toapp_all_hash_name":
                 hash_names: AppGetAllAreaHashName = nav_msg[1]

pymammotion/mammotion/commands/abstract_message.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from pymammotion.proto.luba_msg import MsgCmdType, MsgDevice
+from pymammotion.proto import MsgCmdType, MsgDevice
 from pymammotion.utility.device_type import DeviceType
 
 
@@ -16,7 +16,7 @@ class AbstractMessage:
         """Changes the rcver name if it's not a luba1."""
         if (
             not DeviceType.is_luba1(self.get_device_name(), self.get_device_product_key())
-            and msg_type == MsgCmdType.MSG_CMD_TYPE_NAV
+            and msg_type == MsgCmdType.NAV
         ):
             return MsgDevice.DEV_NAVIGATION
         return msg_device

pymammotion/mammotion/commands/messages/driver.py

@@ -4,8 +4,19 @@ from logging import getLogger
 import time
 
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
-from pymammotion.proto import mctrl_driver
-from pymammotion.proto.luba_msg import LubaMsg, MsgAttr, MsgCmdType, MsgDevice
+from pymammotion.proto import (
+    DrvKnifeHeight,
+    DrvMotionCtrl,
+    DrvMowCtrlByHand,
+    DrvSrSpeed,
+    LubaMsg,
+    MctlDriver,
+    MsgAttr,
+    MsgCmdType,
+    MsgDevice,
+    RtkCfgReqT,
+    RtkSysMaskQueryT,
+)
 
 logger = getLogger(__name__)
 
@@ -13,10 +24,10 @@ logger = getLogger(__name__)
 class MessageDriver(AbstractMessage, ABC):
     def send_order_msg_driver(self, driver) -> bytes:
         return LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_DRIVER,
+            msgtype=MsgCmdType.EMBED_DRIVER,
             sender=MsgDevice.DEV_MOBILEAPP,
-            rcver=self.get_msg_device(MsgCmdType.MSG_CMD_TYPE_EMBED_DRIVER, MsgDevice.DEV_MAINCTL),
-            msgattr=MsgAttr.MSG_ATTR_REQ,
+            rcver=self.get_msg_device(MsgCmdType.EMBED_DRIVER, MsgDevice.DEV_MAINCTL),
+            msgattr=MsgAttr.REQ,
             timestamp=round(time.time() * 1000),
             seqs=1,
             version=1,
@@ -26,25 +37,23 @@ class MessageDriver(AbstractMessage, ABC):
 
     def set_blade_height(self, height: int):
         logger.debug(f"Send knife height height={height}")
-        build = mctrl_driver.MctlDriver(todev_knife_height_set=mctrl_driver.DrvKnifeHeight(knife_height=height))
+        build = MctlDriver(todev_knife_height_set=DrvKnifeHeight(knife_height=height))
         logger.debug(f"Send command--Knife motor height setting height={height}")
         return self.send_order_msg_driver(build)
 
     def set_speed(self, speed: float):
         logger.debug(f"{self.get_device_name()} set speed, {speed}")
-        build = mctrl_driver.MctlDriver(bidire_speed_read_set=mctrl_driver.DrvSrSpeed(speed=speed, rw=1))
+        build = MctlDriver(bidire_speed_read_set=DrvSrSpeed(speed=speed, rw=1))
         logger.debug(f"Send command--Speed setting speed={speed}")
         return self.send_order_msg_driver(build)
 
     def syn_nav_star_point_data(self, sat_system: int):
-        build = mctrl_driver.MctlDriver(rtk_sys_mask_query=mctrl_driver.RtkSysMaskQueryT(sat_system=sat_system))
+        build = MctlDriver(rtk_sys_mask_query=RtkSysMaskQueryT(sat_system=sat_system))
         logger.debug(f"Send command--Navigation satellite frequency point synchronization={sat_system}")
         return self.send_order_msg_driver(build)
 
     def set_nav_star_point(self, cmd_req: str):
-        build = mctrl_driver.MctlDriver(
-            rtk_cfg_req=mctrl_driver.RtkCfgReqT(cmd_req=cmd_req, cmd_length=len(cmd_req) - 1)
-        )
+        build = MctlDriver(rtk_cfg_req=RtkCfgReqT(cmd_req=cmd_req, cmd_length=len(cmd_req) - 1))
         logger.debug(f"Send command--Navigation satellite frequency point setting={cmd_req}")
         logger.debug(
             f"Navigation satellite setting, Send command--Navigation satellite frequency point setting={cmd_req}"
@@ -52,7 +61,7 @@ class MessageDriver(AbstractMessage, ABC):
         return self.send_order_msg_driver(build)
 
     def get_speed(self):
-        build = mctrl_driver.MctlDriver(bidire_speed_read_set=mctrl_driver.DrvSrSpeed(rw=0))
+        build = MctlDriver(bidire_speed_read_set=DrvSrSpeed(rw=0))
         logger.debug("Send command--Get speed value")
         return self.send_order_msg_driver(build)
 
@@ -63,12 +72,12 @@ class MessageDriver(AbstractMessage, ABC):
         cut_knife_height: int,
         max_run_speed: float,
     ):
-        build = mctrl_driver.MctlDriver(
-            mow_ctrl_by_hand=mctrl_driver.DrvMowCtrlByHand(
+        build = MctlDriver(
+            mow_ctrl_by_hand=DrvMowCtrlByHand(
                 main_ctrl=main_ctrl,
                 cut_knife_ctrl=cut_knife_ctrl,
                 cut_knife_height=cut_knife_height,
-                max_run__speed=max_run_speed,
+                max_run_speed=max_run_speed,
             )
         )
         logger.debug(
@@ -78,13 +87,11 @@ class MessageDriver(AbstractMessage, ABC):
 
         return self.send_order_msg_driver(build)
 
-    def send_movement(self, linear_speed: int, angular_speed: int):
+    def send_movement(self, linear_speed: int, angular_speed: int) -> bytes:
         logger.debug(f"Control command print, linearSpeed={
         linear_speed} // angularSpeed={angular_speed}")
         return self.send_order_msg_driver(
-            mctrl_driver.MctlDriver(
-                todev_devmotion_ctrl=mctrl_driver.DrvMotionCtrl(
-                    set_linear_speed=linear_speed, set_angular_speed=angular_speed
-                )
+            MctlDriver(
+                todev_devmotion_ctrl=DrvMotionCtrl(set_linear_speed=linear_speed, set_angular_speed=angular_speed)
             )
         )

pymammotion/mammotion/commands/messages/media.py

@@ -2,18 +2,16 @@
 from abc import ABC
 
 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.luba_mul import MUL_LANGUAGE
+from pymammotion.proto import LubaMsg, MsgAttr, MsgCmdType, MsgDevice, MulLanguage, MulSetAudio, MulSetWiper, SocMul
 
 
 class MessageMedia(AbstractMessage, ABC):
     def send_order_msg_media(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),
-            msgattr=luba_msg_pb2.MSG_ATTR_REQ,
+        luba_msg = LubaMsg(
+            msgtype=MsgCmdType.MUL,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=self.get_msg_device(MsgCmdType.MUL, MsgDevice.SOC_MODULE_MULTIMEDIA),
+            msgattr=MsgAttr.REQ,
             seqs=1,
             version=1,
             subtype=1,
@@ -23,12 +21,13 @@ class MessageMedia(AbstractMessage, ABC):
         return luba_msg.SerializeToString()
 
     def set_car_volume(self, volume: int):
-        return self.send_order_msg_media(luba_mul_pb2.SocMul(set_audio=luba_mul_pb2.MulSetAudio(at_switch=volume)))
+        """Set the car volume. 0 - 100"""
+        return self.send_order_msg_media(SocMul(set_audio=MulSetAudio(at_switch=volume)))
 
-    def set_car_voice_language(self, language_type: MUL_LANGUAGE | str | None):
-        return self.send_order_msg_media(
-            luba_mul_pb2.SocMul(set_audio=luba_mul_pb2.MulSetAudio(au_language=language_type))
-        )
+    def set_car_voice_language(self, language_type: MulLanguage | str | None):
+        return self.send_order_msg_media(SocMul(set_audio=MulSetAudio(au_language=language_type)))
 
     def set_car_wiper(self, round_num: int):
-        return self.send_order_msg_media(luba_mul_pb2.SocMul(set_wiper=luba_mul_pb2.MulSetWiper(round=round_num)))
+        """Set mower wiper."""
+        # 2
+        return self.send_order_msg_media(SocMul(set_wiper=MulSetWiper(round=round_num)))

pymammotion/mammotion/commands/messages/navigation.py

@@ -7,10 +7,13 @@ from pymammotion.data.model import GenerateRouteInformation
 from pymammotion.data.model.plan import Plan
 from pymammotion.data.model.region_data import RegionData
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
-from pymammotion.proto.luba_msg import LubaMsg, MsgAttr, MsgCmdType, MsgDevice
-from pymammotion.proto.mctrl_nav import (
+from pymammotion.proto import (
     AppRequestCoverPathsT,
+    LubaMsg,
     MctlNav,
+    MsgAttr,
+    MsgCmdType,
+    MsgDevice,
     NavGetCommData,
     NavGetHashList,
     NavMapNameMsg,
@@ -32,10 +35,10 @@ logger = logging.getLogger(__name__)
 class MessageNavigation(AbstractMessage, ABC):
     def send_order_msg_nav(self, build) -> bytes:
         luba_msg = LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_NAV,
+            msgtype=MsgCmdType.NAV,
             sender=MsgDevice.DEV_MOBILEAPP,
-            rcver=self.get_msg_device(MsgCmdType.MSG_CMD_TYPE_NAV, MsgDevice.DEV_MAINCTL),
-            msgattr=MsgAttr.MSG_ATTR_REQ,
+            rcver=self.get_msg_device(MsgCmdType.NAV, MsgDevice.DEV_MAINCTL),
+            msgattr=MsgAttr.REQ,
             seqs=1,
             version=1,
             subtype=1,
@@ -45,8 +48,8 @@ class MessageNavigation(AbstractMessage, ABC):
 
         return luba_msg.SerializeToString()
 
-    def allpowerfull_rw_adapter_x3(self, id: int, context: int, rw: int) -> bytes:
-        build = MctlNav(nav_sys_param_cmd=NavSysParamMsg(id=id, context=context, rw=rw))
+    def allpowerfull_rw_adapter_x3(self, rw_id: int, context: int, rw: int) -> bytes:
+        build = MctlNav(nav_sys_param_cmd=NavSysParamMsg(id=rw_id, context=context, rw=rw))
         logger.debug(f"Send command--9 general read and write command id={id}, context={context}, rw={rw}")
         return self.send_order_msg_nav(build)
 
@@ -268,7 +271,7 @@ class MessageNavigation(AbstractMessage, ABC):
         logger.debug("Send command--Get area name list")
         return self.send_order_msg_nav(mctl_nav)
 
-    def set_area_name(self, device_id, hash_id: int, name: str) -> bytes:
+    def set_area_name(self, device_id: str, hash_id: int, name: str) -> bytes:
         # Build the NavMapNameMsg with the specified parameters
         mctl_nav = MctlNav(
             toapp_map_name_msg=NavMapNameMsg(hash=hash_id, name=name, result=0, device_id=device_id, rw=1)
@@ -280,7 +283,7 @@ class MessageNavigation(AbstractMessage, ABC):
 
     def get_all_boundary_hash_list(self, sub_cmd: int) -> bytes:
         build = MctlNav(todev_gethash=NavGetHashList(pver=1, sub_cmd=sub_cmd))
-        logger.debug(f"Area loading=====================:Get area hash list++Bluetooth:{sub_cmd}")
+        logger.debug(f"Area loading=====================:Get area hash list:{sub_cmd}")
         return self.send_order_msg_nav(build)
 
     def get_hash_response(self, total_frame: int, current_frame: int) -> bytes:
@@ -327,9 +330,9 @@ class MessageNavigation(AbstractMessage, ABC):
         logger.debug(f"Send command--Send tool command id={param_id},values={values}")
         return self.send_order_msg_nav(build)
 
-    def end_draw_border(self, type: int) -> bytes:
+    def end_draw_border(self, type: int) -> bytes | None:
         if type == -1:
-            return
+            return None
         build = MctlNav(todev_get_commondata=NavGetCommData(pver=1, action=1, type=type))
         logger.debug(f"Send command--End drawing boundary, obstacle, channel command type={type}")
         return self.send_order_msg_nav(build)
@@ -339,9 +342,9 @@ class MessageNavigation(AbstractMessage, ABC):
         logger.debug("Send command--Cancel current recording (boundary, obstacle)")
         return self.send_order_msg_nav(build)
 
-    def delete_map_elements(self, type: int, hash_num: int) -> bytes:
+    def delete_map_elements(self, type: int, hash_num: int) -> bytes | None:
         if type == -1:
-            return
+            return None
         build = MctlNav(todev_get_commondata=NavGetCommData(pver=1, action=6, type=type, hash=hash_num))
         logger.debug(f"Send command--Delete boundary or obstacle or channel command type={type},hash={hash}")
         return self.send_order_msg_nav(build)