pymammotion 0.4.0a2__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/bluetooth/ble.py

@@ -1,14 +1,13 @@
 from bleak import BleakClient, BleakScanner, BLEDevice
 from bleak.backends.characteristic import BleakGATTCharacteristic
 
-from pymammotion.bluetooth.const import (
-    SERVICE_CHANGED_CHARACTERISTIC,
-    UUID_NOTIFICATION_CHARACTERISTIC,
-)
+from pymammotion.bluetooth.const import SERVICE_CHANGED_CHARACTERISTIC, UUID_NOTIFICATION_CHARACTERISTIC
 from pymammotion.event.event import BleNotificationEvent
 
 
 class MammotionBLE:
+    """Class for basic ble connections to mowers."""
+
     client: BleakClient
 
     def __init__(self, bleEvt: BleNotificationEvent) -> None:
@@ -37,12 +36,10 @@ class MammotionBLE:
         return await self.connect()
 
     async def connect(self) -> bool:
-        if self.client is not None:
-            return await self.client.connect()
+        return await self.client.connect() if self.client is not None else False
 
     async def disconnect(self) -> bool:
-        if self.client is not None:
-            return await self.client.disconnect()
+        return await self.client.disconnect() if self.client is not None else False
 
     async def notification_handler(self, _characteristic: BleakGATTCharacteristic, data: bytearray) -> None:
         """Simple notification handler which prints the data received."""
@@ -60,5 +57,6 @@ class MammotionBLE:
             await self.client.start_notify(UUID_NOTIFICATION_CHARACTERISTIC, self.notification_handler)
             await self.client.start_notify(SERVICE_CHANGED_CHARACTERISTIC, self.service_changed_handler)
 
-    def getClient(self):
+    def get_client(self):
+        """Returns the ble client."""
         return self.client

pymammotion/bluetooth/ble_message.py

@@ -1,12 +1,11 @@
+from asyncio import sleep
+from io import BytesIO
 import itertools
 import json
 import logging
 import queue
 import sys
 import time
-from asyncio import sleep
-from io import BytesIO
-from typing import Union
 
 from bleak import BleakClient
 from jsonic.serializable import serialize
@@ -17,10 +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__)
@@ -320,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
@@ -334,7 +330,7 @@ class BleMessage:
             print(e)
             return ""
 
-    def clearNotification(self) -> None:
+    def clear_notification(self) -> None:
         self.notification = None
         self.notification = BlufiNotifyData()
 
@@ -344,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)
@@ -403,7 +399,7 @@ class BleMessage:
         sequence = int(response[2])  # toInt
         current_sequence = self.mReadSequence.get() & 255
         if sequence == current_sequence:
-            _LOGGER.debug(f"Received bluetooth data 1: {response.hex()}, object: {self}")
+            # _LOGGER.debug(f"Received bluetooth data 1: {response.hex()}, object: {self}")
             return 2
 
         # Compare with the second counter, mod 255
@@ -656,7 +652,7 @@ class BleMessage:
         return byteOS.getvalue()
 
     @staticmethod
-    def calc_crc(initial: int, data: Union[bytes, bytearray]) -> int:
+    def calc_crc(initial: int, data: bytes | bytearray) -> int:
         """Calculate CRC value for given initial value and byte array.
 
         Args:

pymammotion/const.py

@@ -8,3 +8,6 @@ MAMMOTION_DOMAIN = "https://id.mammotion.com"
 MAMMOTION_API_DOMAIN = "https://domestic.mammotion.com"
 MAMMOTION_CLIENT_ID = "MADKALUBAS"
 MAMMOTION_CLIENT_SECRET = "GshzGRZJjuMUgd2sYHM7"
+
+MAMMOTION_OUATH2_CLIENT_ID = "GxebgSt8si6pKqR"
+MAMMOTION_OUATH2_CLIENT_SECRET = "JP0508SRJFa0A90ADpzLINDBxMa4Vj"

pymammotion/data/model/__init__.py

@@ -2,8 +2,7 @@
 
 from .generate_route_information import GenerateRouteInformation
 from .hash_list import HashList
-from .plan import Plan
 from .rapid_state import RapidState, RTKStatus
 from .region_data import RegionData
 
-__all__ = ["GenerateRouteInformation", "HashList", "Plan", "RapidState", "RTKStatus", "RegionData"]
+__all__ = ["GenerateRouteInformation", "HashList", "RapidState", "RTKStatus", "RegionData"]

pymammotion/data/model/device.py

@@ -1,23 +1,22 @@
 """MowingDevice class to wrap around the betterproto dataclasses."""
 
 from dataclasses import dataclass, field
-from typing import Optional
 
-import betterproto
+import betterproto2
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 from pymammotion.data.model import HashList, RapidState
-from pymammotion.data.model.device_info import MowerInfo
+from pymammotion.data.model.device_info import DeviceFirmwares, DeviceNonWorkingHours, MowerInfo
+from pymammotion.data.model.errors import DeviceErrors
+from pymammotion.data.model.events import Events
 from pymammotion.data.model.location import Location
 from pymammotion.data.model.report_info import ReportData
+from pymammotion.data.model.work import CurrentTaskSettings
+from pymammotion.data.mqtt.event import ThingEventMessage
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
-from pymammotion.http.model.http import ErrorInfo
-from pymammotion.proto.mctrl_sys import (
-    MowToAppInfoT,
-    ReportInfoData,
-    SystemRapidStateTunnelMsg,
-    SystemUpdateBufMsg,
-)
+from pymammotion.data.mqtt.status import ThingStatusMessage
+from pymammotion.http.model.http import CheckDeviceVersion
+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
@@ -27,30 +26,42 @@ 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
+    enabled: bool = True
+    update_check: CheckDeviceVersion = field(default_factory=CheckDeviceVersion)
     mower_state: MowerInfo = field(default_factory=MowerInfo)
     mqtt_properties: ThingPropertiesMessage | None = None
+    status_properties: ThingStatusMessage | None = None
+    device_event: ThingEventMessage | None = None
     map: HashList = field(default_factory=HashList)
+    work: CurrentTaskSettings = field(default_factory=CurrentTaskSettings)
     location: Location = field(default_factory=Location)
     mowing_state: RapidState = field(default_factory=RapidState)
     report_data: ReportData = field(default_factory=ReportData)
-    err_code_list: list = field(default_factory=list)
-    err_code_list_time: Optional[list] = field(default_factory=list)
-    error_codes: dict[str, ErrorInfo] = field(default_factory=dict)
+    device_firmwares: DeviceFirmwares = field(default_factory=DeviceFirmwares)
+    errors: DeviceErrors = field(default_factory=DeviceErrors)
+    non_work_hours: DeviceNonWorkingHours = field(default_factory=DeviceNonWorkingHours)
+    events: Events = field(default_factory=Events)
 
     def buffer(self, buffer_list: SystemUpdateBufMsg) -> None:
         """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 = parse_double(buffer_list.update_buf_data[5], 8.0)
-                self.location.RTK.longitude = parse_double(buffer_list.update_buf_data[6], 8.0)
-                self.location.dock.latitude = parse_double(buffer_list.update_buf_data[7], 4.0)
-                self.location.dock.longitude = parse_double(buffer_list.update_buf_data[8], 4.0)
-                self.location.dock.rotation = buffer_list.update_buf_data[3] + 180
+                # 4 speed?
+                if buffer_list.update_buf_data[5] != 0:
+                    self.location.RTK.latitude = parse_double(buffer_list.update_buf_data[5], 8.0)
+                    self.location.RTK.longitude = parse_double(buffer_list.update_buf_data[6], 8.0)
+                if buffer_list.update_buf_data[7] != 0:
+                    # latitude Y longitude X
+                    self.location.dock.longitude = parse_double(buffer_list.update_buf_data[7], 4.0)
+                    self.location.dock.latitude = parse_double(buffer_list.update_buf_data[8], 4.0)
+                    self.location.dock.rotation = buffer_list.update_buf_data[3]
+
             case 2:
-                self.err_code_list.clear()
-                self.err_code_list_time.clear()
-                self.err_code_list.extend(
+                self.errors.err_code_list.clear()
+                self.errors.err_code_list_time.clear()
+                self.errors.err_code_list.extend(
                     [
                         buffer_list.update_buf_data[3],
                         buffer_list.update_buf_data[5],
@@ -64,7 +75,7 @@ class MowingDevice(DataClassORJSONMixin):
                         buffer_list.update_buf_data[21],
                     ]
                 )
-                self.err_code_list_time.extend(
+                self.errors.err_code_list_time.extend(
                     [
                         buffer_list.update_buf_data[4],
                         buffer_list.update_buf_data[6],
@@ -78,28 +89,48 @@ class MowingDevice(DataClassORJSONMixin):
                         buffer_list.update_buf_data[22],
                     ]
                 )
+            case 3:
+                # task state event
+                task_area_map: dict[int, int] = {}
+                task_area_ids = []
+
+                for i in range(3, len(buffer_list.update_buf_data), 2):
+                    area_id = buffer_list.update_buf_data[i]
+
+                    if area_id != 0:
+                        area_value = int(buffer_list.update_buf_data[i + 1])
+                        task_area_map[area_id] = area_value
+                        task_area_ids.append(area_id)
+                self.events.work_tasks_event.hash_list = task_area_map
+                self.events.work_tasks_event.ids = task_area_ids
 
     def update_report_data(self, toapp_report_data: ReportInfoData) -> None:
+        """Set report data for the mower."""
         coordinate_converter = CoordinateConverter(self.location.RTK.latitude, self.location.RTK.longitude)
         for index, location in enumerate(toapp_report_data.locations):
             if index == 0 and location.real_pos_y != 0:
                 self.location.position_type = location.pos_type
-                self.location.orientation = location.real_toward / 10000
+                self.location.orientation = int(location.real_toward / 10000)
                 self.location.device = coordinate_converter.enu_to_lla(
                     parse_double(location.real_pos_y, 4.0), parse_double(location.real_pos_x, 4.0)
                 )
+                self.map.invalidate_maps(location.bol_hash)
                 if location.zone_hash:
                     self.location.work_zone = (
                         location.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
                     )
 
-        self.report_data.update(toapp_report_data.to_dict(casing=betterproto.Casing.SNAKE))
+        if toapp_report_data.fw_info:
+            self.update_device_firmwares(toapp_report_data.fw_info)
+
+        self.report_data.update(toapp_report_data.to_dict(casing=betterproto2.Casing.SNAKE))
 
     def run_state_update(self, rapid_state: SystemRapidStateTunnelMsg) -> None:
+        """Set lat long, work zone of RTK and robot."""
         coordinate_converter = CoordinateConverter(self.location.RTK.latitude, self.location.RTK.longitude)
         self.mowing_state = RapidState().from_raw(rapid_state.rapid_state_data)
         self.location.position_type = self.mowing_state.pos_type
-        self.location.orientation = self.mowing_state.toward / 10000
+        self.location.orientation = int(self.mowing_state.toward / 10000)
         self.location.device = coordinate_converter.enu_to_lla(
             parse_double(self.mowing_state.pos_y, 4.0), parse_double(self.mowing_state.pos_x, 4.0)
         )
@@ -109,7 +140,44 @@ class MowingDevice(DataClassORJSONMixin):
             )
 
     def mow_info(self, toapp_mow_info: MowToAppInfoT) -> None:
-        pass
+        """Set mow info."""
 
     def report_missing_data(self) -> None:
         """Report missing data so we can refetch it."""
+
+    def update_device_firmwares(self, fw_info: DeviceFwInfo) -> None:
+        """Set firmware versions on all parts of the robot or RTK."""
+        for mod in fw_info.mod:
+            match mod.type:
+                case 1:
+                    self.device_firmwares.main_controller = mod.version
+                case 3:
+                    self.device_firmwares.left_motor_driver = mod.version
+                case 4:
+                    self.device_firmwares.right_motor_driver = mod.version
+                case 5:
+                    self.device_firmwares.rtk_rover_station = mod.version
+                case 101:
+                    # RTK main board
+                    self.device_firmwares.main_controller = mod.version
+                case 102:
+                    self.device_firmwares.rtk_version = mod.version
+                case 103:
+                    self.device_firmwares.lora_version = mod.version
+
+
+@dataclass
+class RTKDevice(DataClassORJSONMixin):
+    name: str
+    iot_id: str
+    product_key: str
+    online: bool = True
+    lat: float = 0.0
+    lon: float = 0.0
+    lora: str = ""
+    wifi_rssi: int = 0
+    device_version: str = ""
+    lora_version: str = ""
+    wifi_sta_mac: str = ""
+    bt_mac: str = ""
+    update_check: CheckDeviceVersion = field(default_factory=CheckDeviceVersion)

pymammotion/data/model/device_config.py

@@ -30,23 +30,23 @@ class OperationSettings(DataClassORJSONMixin):
     obstacle_laps: int = 1
     mowing_laps: int = 1  # border laps
     start_progress: int = 0
-    areas: list[int] = field(default_factory=list)
+    areas: set[int] = field(default_factory=set)
 
 
 def create_path_order(operation_mode: OperationSettings, device_name: str) -> str:
     # TODO add scheduling logic from getReserved() WorkSettingViewModel.java
-    i2 = 0
     bArr = bytearray(8)
     bArr[0] = operation_mode.border_mode
     bArr[1] = operation_mode.obstacle_laps
     bArr[3] = int(operation_mode.start_progress)
     bArr[2] = 0
+    bArr[5] = 0
     if not DeviceType.is_luba1(device_name):
         bArr[4] = 0
-        if DeviceType.is_yuka(device_name):
+        if DeviceType.is_yuka(device_name) and not DeviceType.is_yuka_mini(device_name):
             bArr[5] = calculate_yuka_mode(operation_mode)
         else:
-            bArr[5] = 8 if DeviceType.is_luba_2(device_name) else 0
+            bArr[5] = 8 if DeviceType.is_luba_pro(device_name) else 0
 
         bArr[6] = int(operation_mode.collect_grass_frequency) if operation_mode.is_dump else 10
     if DeviceType.is_luba1(device_name):

pymammotion/data/model/device_info.py

@@ -14,12 +14,47 @@ class SideLight(DataClassORJSONMixin):
     action: int = 0
 
 
+@dataclass
+class DeviceNonWorkingHours(DataClassORJSONMixin):
+    sub_cmd: int = 0
+    start_time: str = ""
+    end_time: str = ""
+
+
+@dataclass
+class LampInfo(DataClassORJSONMixin):
+    lamp_bright: int = 0
+    manual_light: bool = False
+    night_light: bool = False
+
+
 @dataclass
 class MowerInfo(DataClassORJSONMixin):
     blade_status: bool = False
+    rain_detection: bool = False
+    traversal_mode: int = 0
+    turning_mode: int = 0
+    blade_mode: int = 0
+    blade_rpm: int = 0
     side_led: SideLight = field(default_factory=SideLight)
     collector_installation_status: bool = False
     model: str = ""
     swversion: str = ""
     product_key: str = ""
     model_id: str = ""
+    sub_model_id: str = ""
+    ble_mac: str = ""
+    wifi_mac: str = ""
+    lamp_info: LampInfo = field(default_factory=LampInfo)
+
+
+@dataclass
+class DeviceFirmwares(DataClassORJSONMixin):
+    device_version: str = ""
+    left_motor_driver: str = ""
+    lora_version: str = ""
+    main_controller: str = ""
+    model_name: str = ""
+    right_motor_driver: str = ""
+    rtk_rover_station: str = ""
+    rtk_version: str = ""

pymammotion/data/model/device_limits.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 
 @dataclass
@@ -9,18 +9,18 @@ class RangeLimit:
 
 @dataclass
 class DeviceLimits:
-    cutter_height: RangeLimit = RangeLimit(min=30, max=100)
-    working_speed: RangeLimit = RangeLimit(min=0.2, max=1.2)
-    working_path: RangeLimit = RangeLimit(min=15, max=35)
+    blade_height: RangeLimit = field(default_factory=RangeLimit)
+    working_speed: RangeLimit = field(default_factory=RangeLimit)
+    path_spacing: RangeLimit = field(default_factory=RangeLimit)
     work_area_num_max: int = 60
     display_image_type: int = 0
 
     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},
+            "path_spacing": {"min": self.path_spacing.min, "max": self.path_spacing.max},
             "work_area_num_max": self.work_area_num_max,
             "display_image_type": self.display_image_type,
         }
@@ -29,9 +29,9 @@ 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"]),
+            path_spacing=RangeLimit(min=data["path_spacing"]["min"], max=data["path_spacing"]["max"]),
             work_area_num_max=data["work_area_num_max"],
             display_image_type=data["display_image_type"],
         )
@@ -40,9 +40,9 @@ 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.path_spacing.min <= self.path_spacing.max,
                 self.work_area_num_max > 0,
                 self.display_image_type in (0, 1),
             ]

pymammotion/data/model/enums.py

@@ -1,6 +1,16 @@
 from enum import Enum
 
 
+class ConnectionPreference(Enum):
+    """Enum for connection preference."""
+
+    ANY = 0
+    WIFI = 1
+    BLUETOOTH = 2
+    PREFER_WIFI = 3
+    PREFER_BLUETOOTH = 4
+
+
 class PositionMode(Enum):
     FIX = 0
     SINGLE = 1
@@ -9,7 +19,7 @@ class PositionMode(Enum):
     UNKNOWN = 4
 
     @staticmethod
-    def from_value(value: int):
+    def from_value(value: int) -> "PositionMode":
         if value == 0:
             return PositionMode.FIX
         elif value == 1:
@@ -42,7 +52,7 @@ class RTKStatus(Enum):
     UNKNOWN = 6
 
     @staticmethod
-    def from_value(value: int):
+    def from_value(value: int) -> "RTKStatus":
         if value == 0:
             return RTKStatus.NONE
         elif value == 1 or value == 2:

pymammotion/data/model/errors.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass, field
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+from pymammotion.http.model.http import ErrorInfo
+
+
+@dataclass
+class DeviceErrors(DataClassORJSONMixin):
+    err_code_list: list[int] = field(default_factory=list)
+    err_code_list_time: list[int] = field(default_factory=list)
+    error_codes: dict[str, ErrorInfo] = field(default_factory=dict)

pymammotion/data/model/events.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass, field
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+
+@dataclass
+class WorkTaskEvent(DataClassORJSONMixin):
+    hash_area_map: dict[int, int] = field(default_factory=dict)
+    ids: list[int] = field(default_factory=list)
+
+
+@dataclass
+class Events(DataClassORJSONMixin):
+    work_tasks_event: WorkTaskEvent = field(default_factory=WorkTaskEvent)