pymammotion 0.0.40__py3-none-any.whl → 0.0.41__py3-none-any.whl

pymammotion/data/model/device.py

@@ -2,6 +2,8 @@
 
 from dataclasses import dataclass
 
+from pymammotion.data.model import HashList
+from pymammotion.data.model.location import Location
 from pymammotion.proto.dev_net import DevNet
 from pymammotion.proto.luba_msg import LubaMsg
 from pymammotion.proto.luba_mul import SocMul
@@ -9,19 +11,76 @@ 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.mctrl_sys import MctlSys, SystemUpdateBufMsg
 
 
 @dataclass
 class MowingDevice:
-    """Wraps the betterproto dataclasses so we can bypass the groups for keeping all data."""
+    """Wraps the betterproto dataclasses, so we can bypass the groups for keeping all data."""
 
     device: LubaMsg
+    map: HashList
+    location: Location
+
+    def __init__(self):
+        self.device = LubaMsg()
+        self.map = HashList(area={}, path={}, obstacle={})
+        self.location = Location()
+        self.err_code_list = []
+        self.err_code_list_time = []
 
     @classmethod
     def from_raw(cls, raw: dict) -> "MowingDevice":
         """Take in raw data to hold in the betterproto dataclass."""
-        return MowingDevice(device=LubaMsg(**raw))
+        mowing_device = MowingDevice()
+        mowing_device.device = LubaMsg(**raw)
+        return mowing_device
+
+    def update_raw(self, raw: dict) -> None:
+        """Update the raw LubaMsg data."""
+        self.device = LubaMsg(**raw)
+
+    def buffer(self, buffer_list: SystemUpdateBufMsg):
+        """Update the device based on which buffer we are reading from."""
+        match buffer_list.update_buf_data[0]:
+            case 1:
+                # 4 speed
+                self.location.RTK.latitude = buffer_list.update_buf_data[5]
+                self.location.RTK.longitude = buffer_list.update_buf_data[6]
+                self.location.dock.latitude = buffer_list.update_buf_data[7]
+                self.location.dock.longitude = buffer_list.update_buf_data[8]
+                self.location.dock.rotation = buffer_list.update_buf_data[3] + 180
+            case 2:
+                self.err_code_list.clear()
+                self.err_code_list_time.clear()
+                self.err_code_list.extend(
+                    [
+                        buffer_list.update_buf_data[3],
+                        buffer_list.update_buf_data[5],
+                        buffer_list.update_buf_data[7],
+                        buffer_list.update_buf_data[9],
+                        buffer_list.update_buf_data[11],
+                        buffer_list.update_buf_data[13],
+                        buffer_list.update_buf_data[15],
+                        buffer_list.update_buf_data[17],
+                        buffer_list.update_buf_data[19],
+                        buffer_list.update_buf_data[21],
+                    ]
+                )
+                self.err_code_list_time.extend(
+                    [
+                        buffer_list.update_buf_data[4],
+                        buffer_list.update_buf_data[6],
+                        buffer_list.update_buf_data[8],
+                        buffer_list.update_buf_data[10],
+                        buffer_list.update_buf_data[12],
+                        buffer_list.update_buf_data[14],
+                        buffer_list.update_buf_data[16],
+                        buffer_list.update_buf_data[18],
+                        buffer_list.update_buf_data[20],
+                        buffer_list.update_buf_data[22],
+                    ]
+                )
 
     @property
     def net(self):

pymammotion/data/model/hash_list.py

@@ -1,17 +1,37 @@
-import typing
+from dataclasses import dataclass
 
+from pymammotion.proto.mctrl_nav import NavGetCommDataAck
 
+
+@dataclass
+class FrameList:
+    total_frame: int
+    data: list[NavGetCommDataAck]
+
+
+@dataclass
 class HashList:
-    def __init__(self):
-        self.pver: int = 0
-        self.subCmd: int = 0
-        self.totalFrame: int = 0
-        self.currentFrame: int = 0
-        self.dataHash: int = 0
-        self.path: typing.List[int] = []
-
-    def __str__(self) -> str:
-        return (
-            f"HashBean{{pver={self.pver}, subCmd={self.subCmd}, totalFrame={self.totalFrame}, "
-            + f"currentFrame={self.currentFrame}, dataHash={self.dataHash}, path={self.path}}}"
-        )
+    """stores our map data.
+    [hashID, FrameList].
+    """
+
+    area: dict  # type 0
+    path: dict  # type 2
+    obstacle: dict  # type 1
+
+    def update(self, hash_data: NavGetCommDataAck):
+        """Update the map data."""
+        if hash_data.type == 0:
+            if self.area.get(hash_data.hash) is None:
+                self.area[hash_data.hash] = FrameList(total_frame=hash_data.total_frame, data=[hash_data])
+            self.area[hash_data.hash].data.append(hash_data)
+
+        if hash_data.type == 1:
+            if self.obstacle.get(hash_data.hash) is None:
+                self.obstacle[hash_data.hash] = FrameList(total_frame=hash_data.total_frame, data=[hash_data])
+            self.obstacle[hash_data.hash].data.append(hash_data)
+
+        if hash_data.type == 2:
+            if self.path.get(hash_data.hash) is None:
+                self.path[hash_data.hash] = FrameList(total_frame=hash_data.total_frame, data=[hash_data])
+            self.path[hash_data.hash].data.append(hash_data)

pymammotion/data/model/location.py

@@ -0,0 +1,40 @@
+"""Contains RTK models for robot location and RTK positions."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Point:
+    """Returns a lat long."""
+
+    latitude: float
+    longitude: float
+
+    def __init__(self):
+        self.latitude = 0
+        self.longitude = 0
+
+
+@dataclass
+class Dock(Point):
+    """Stores robot dock position."""
+
+    rotation: int
+
+    def __init__(self):
+        super().__init__()
+        self.rotation = 0
+
+
+@dataclass
+class Location:
+    """Stores/retrieves RTK GPS data."""
+
+    device: Point
+    RTK: Point
+    dock: Dock
+
+    def __init__(self):
+        self.device = Point()
+        self.RTK = Point()
+        self.dock = Dock()

pymammotion/data/model/rapid_state.py

@@ -26,11 +26,7 @@ class RapidState:
     @classmethod
     def from_raw(cls, raw: list[int]) -> "RapidState":
         return RapidState(
-            rtk_status=RTKStatus.FINE
-            if raw[0] == 4
-            else RTKStatus.BAD
-            if raw[0] in (1, 5)
-            else RTKStatus.NONE,
+            rtk_status=RTKStatus.FINE if raw[0] == 4 else RTKStatus.BAD if raw[0] in (1, 5) else RTKStatus.NONE,
             pos_level=raw[1],
             satellites_total=raw[2],
             rtk_age=raw[3] / 10000,

pymammotion/data/state_manager.py

@@ -0,0 +1,84 @@
+"""Manage state from notifications into MowingDevice."""
+
+import betterproto
+
+from pymammotion.data.model.device import MowingDevice
+from pymammotion.event.event import DataEvent
+from pymammotion.proto.luba_msg import LubaMsg
+
+
+class StateManager:
+    """Manage state."""
+
+    _device: MowingDevice
+    gethash_ack_callback: DataEvent
+    get_commondata_ack_callback: DataEvent
+
+    def __init__(self, device: MowingDevice):
+        self._device = device
+        self.gethash_ack_callback = DataEvent()
+        self.get_commondata_ack_callback = DataEvent()
+
+    def get_device(self) -> MowingDevice:
+        """Get device."""
+        return self._device
+
+    def set_device(self, device: MowingDevice):
+        """Set device."""
+        self._device = device
+
+    async def notification(self, message: LubaMsg):
+        """Handle protobuf notifications."""
+        res = betterproto.which_one_of(message, "LubaSubMsg")
+
+        match res[0]:
+            case "nav":
+                await self._update_nav_data(message)
+            case "sys":
+                self._update_sys_data(message)
+            case "driver":
+                self._update_driver_data(message)
+            case "net":
+                self._update_net_data(message)
+            case "mul":
+                self._update_mul_data(message)
+            case "ota":
+                self._update_ota_data(message)
+
+    async def _update_nav_data(self, message):
+        """Update nav data."""
+        nav_msg = betterproto.which_one_of(message.nav, "SubNavMsg")
+        match nav_msg[0]:
+            case "toapp_gethash_ack":
+                # call callback to handle this data
+                print(nav_msg[1])
+                await self.gethash_ack_callback.data_event(nav_msg[1])
+            case "toapp_get_commondata_ack":
+                # callback to additional method
+                print(nav_msg[1])
+                self._device.map.update(nav_msg[1])
+                await self.get_commondata_ack_callback.data_event(nav_msg[1])
+
+    def _update_sys_data(self, message):
+        """Update system."""
+        sys_msg = betterproto.which_one_of(message.sys, "SubSysMsg")
+        match sys_msg[0]:
+            case "system_update_buf":
+                # call callback to handle this data
+                print(sys_msg[1])
+                self._device.buffer(sys_msg[1])
+            case "toapp_report_data":
+                # data for sensors
+                pass
+
+    def _update_driver_data(self, message):
+        pass
+
+    def _update_net_data(self, message):
+        pass
+
+    def _update_mul_data(self, message):
+        pass
+
+    def _update_ota_data(self, message):
+        pass

pymammotion/event/event.py

@@ -14,9 +14,7 @@ class Event:
         return self
 
     async def __call__(self, *args, **kwargs):
-        await asyncio.gather(
-            *[handler(*args, **kwargs) for handler in self.__eventhandlers]
-        )
+        await asyncio.gather(*[handler(*args, **kwargs) for handler in self.__eventhandlers])
 
 
 class MoveEvent:
@@ -48,3 +46,20 @@ class BleNotificationEvent:
 
     def RemoveSubscribersForBleNotificationEvent(self, objMethod):
         self.OnBleNotification -= objMethod
+
+
+class DataEvent:
+    """Callbacks for data events."""
+
+    def __init__(self):
+        self.on_data_event = Event()
+
+    async def data_event(self, data):
+        # This function will be executed when data is received.
+        await self.on_data_event(data)
+
+    def add_subscribers(self, obj_method):
+        self.on_data_event += obj_method
+
+    def remove_subscribers(self, obj_method):
+        self.on_data_event -= obj_method

pymammotion/http/http.py

@@ -51,9 +51,7 @@ class LubaHTTP:
         self._login = login
 
     @classmethod
-    async def login(
-        cls, session: ClientSession, username: str, password: str
-    ) -> Response[LoginResponseData]:
+    async def login(cls, session: ClientSession, username: str, password: str) -> Response[LoginResponseData]:
         async with session.post(
             "/user-server/v1/user/oauth/token",
             params=dict(
@@ -69,9 +67,7 @@ class LubaHTTP:
             # TODO catch errors from mismatch user / password
             # Assuming the data format matches the expected structure
             login_response_data = LoginResponseData.from_dict(data["data"])
-            return Response(
-                data=login_response_data, code=data["code"], msg=data["msg"]
-            )
+            return Response(data=login_response_data, code=data["code"], msg=data["msg"])
 
 
 async def connect_http(username: str, password: str) -> LubaHTTP:

pymammotion/mammotion/commands/mammotion_command.py

@@ -6,9 +6,7 @@ from pymammotion.mammotion.commands.messages.video import MessageVideo
 from pymammotion.proto import dev_net_pb2, luba_msg_pb2
 
 
-class MammotionCommand(
-    MessageSystem, MessageNavigation, MessageNetwork, MessageOta, MessageVideo
-):
+class MammotionCommand(MessageSystem, MessageNavigation, MessageNetwork, MessageOta, MessageVideo):
     """MQTT commands for Luba."""
 
     def __init__(self, device_name: str) -> None:

pymammotion/mammotion/commands/messages/driver.py

@@ -28,49 +28,35 @@ class MessageDriver(AbstractMessage, ABC):
 
     def set_blade_height(self, height: int):
         logger.debug(f"Send knife height height={height}")
-        build = mctrl_driver_pb2.MctlDriver(
-            todev_knife_height_set=mctrl_driver_pb2.DrvKnifeHeight(knifeHeight=height)
-        )
+        build = mctrl_driver_pb2.MctlDriver(todev_knife_height_set=mctrl_driver_pb2.DrvKnifeHeight(knifeHeight=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_pb2.MctlDriver(
-            bidire_speed_read_set=mctrl_driver_pb2.DrvSrSpeed(speed=speed, rw=1)
-        )
+        build = mctrl_driver_pb2.MctlDriver(bidire_speed_read_set=mctrl_driver_pb2.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_pb2.MctlDriver(
-            rtk_sys_mask_query=mctrl_driver_pb2.rtk_sys_mask_query_t(
-                sat_system=sat_system
-            )
-        )
-        logger.debug(
-            f"Send command--Navigation satellite frequency point synchronization={sat_system}"
+            rtk_sys_mask_query=mctrl_driver_pb2.rtk_sys_mask_query_t(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_pb2.MctlDriver(
-            rtk_cfg_req=mctrl_driver_pb2.rtk_cfg_req_t(
-                cmd_req=cmd_req, cmd_length=len(cmd_req) - 1
-            )
-        )
-        logger.debug(
-            f"Send command--Navigation satellite frequency point setting={cmd_req}"
+            rtk_cfg_req=mctrl_driver_pb2.rtk_cfg_req_t(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}"
         )
         return self.send_order_msg_driver(build)
 
     def get_speed(self):
-        build = mctrl_driver_pb2.MctlDriver(
-            bidire_speed_read_set=mctrl_driver_pb2.DrvSrSpeed(rw=0)
-        )
+        build = mctrl_driver_pb2.MctlDriver(bidire_speed_read_set=mctrl_driver_pb2.DrvSrSpeed(rw=0))
         logger.debug("Send command--Get speed value")
         return self.send_order_msg_driver(build)
 

pymammotion/mammotion/commands/messages/media.py

@@ -4,6 +4,7 @@ from pymammotion.proto.luba_mul import MUL_LANGUAGE
 
 
 class MessageMedia:
+    @staticmethod
     def send_order_msg_media(self, mul):
         luba_msg = luba_msg_pb2.LubaMsg(
             msgtype=luba_msg_pb2.MSG_CMD_TYPE_MUL,
@@ -19,18 +20,12 @@ class MessageMedia:
         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))
-        )
+        return self.send_order_msg_media(luba_mul_pb2.SocMul(set_audio=luba_mul_pb2.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)
-            )
+            luba_mul_pb2.SocMul(set_audio=luba_mul_pb2.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))
-        )
+        return self.send_order_msg_media(luba_mul_pb2.SocMul(set_wiper=luba_mul_pb2.MulSetWiper(round=round_num)))