pymammotion 0.1.9__py3-none-any.whl → 0.2.0__py3-none-any.whl

pymammotion/__init__.py

@@ -10,21 +10,13 @@ import os
 
 # works outside HA on its own
 from pymammotion.bluetooth.ble import LubaBLE
-from pymammotion.http.http import LubaHTTP, connect_http
+from pymammotion.http.http import MammotionHTTP, connect_http
 
 # TODO make a working device that will work outside HA too.
 from pymammotion.mammotion.devices import MammotionBaseBLEDevice
 from pymammotion.mqtt import MammotionMQTT
 
-
-
-__all__ = [
-    'LubaBLE',
-    'LubaHTTP',
-    'connect_http',
-    'MammotionBaseBLEDevice',
-    'MammotionMQTT'
-]
+__all__ = ["LubaBLE", "MammotionHTTP", "connect_http", "MammotionBaseBLEDevice", "MammotionMQTT"]
 
 logger = logging.getLogger(__name__)
 

pymammotion/aliyun/cloud_gateway.py

@@ -391,8 +391,6 @@ class CloudIOTGateway:
 
     def check_or_refresh_session(self):
         """Check or refresh the session."""
-        if self.load_saved_params() is False:
-            return False
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
@@ -436,7 +434,7 @@ class CloudIOTGateway:
         # Carica la stringa JSON in un dizionario
         json.loads(response_body_str)
 
-    def list_binding_by_account(self):
+    def list_binding_by_account(self) -> ListingDevByAccountResponse:
         """List bindings by account."""
         config = Config(
             app_key=self._app_key,
@@ -476,6 +474,7 @@ class CloudIOTGateway:
             raise Exception("Error in creating session: " + response_body_dict["msg"])
 
         self._listing_dev_by_account_response = ListingDevByAccountResponse.from_dict(response_body_dict)
+        return self._listing_dev_by_account_response
 
     def send_cloud_command(self, iot_id: str, command: bytes) -> str:
         """Send a cloud command to the specified IoT device."""

pymammotion/aliyun/dataclass/dev_by_account_response.py

@@ -6,7 +6,6 @@ from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 @dataclass
 class Device(DataClassORJSONMixin):
-    productModel: str
     gmtModified: int
     netType: str
     nickName: str
@@ -26,6 +25,7 @@ class Device(DataClassORJSONMixin):
     status: int
     productImage: Optional[str] = None
     categoryImage: Optional[str] = None
+    productModel: Optional[str] = None
 
 
 @dataclass

pymammotion/data/model/account.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Credentials:
+    email: str
+    password: str
+    account_id: str

pymammotion/data/model/device.py

@@ -1,4 +1,5 @@
 """MowingDevice class to wrap around the betterproto dataclasses."""
+
 import math
 from dataclasses import dataclass
 
@@ -15,7 +16,7 @@ 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, MowToAppInfoT, SystemUpdateBufMsg, ReportInfoData
+from pymammotion.proto.mctrl_sys import MctlSys, MowToAppInfoT, ReportInfoData, SystemUpdateBufMsg
 from pymammotion.utility.map import CoordinateConverter
 
 
@@ -99,12 +100,12 @@ class MowingDevice:
             if index == 0:
                 self.location.position_type = location.pos_type
                 self.location.orientation = 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.location.device = coordinate_converter.enu_to_lla(
+                    parse_double(location.real_pos_y, 4.0), parse_double(location.real_pos_x, 4.0)
+                )
 
         self.report_data = self.report_data.from_dict(toapp_report_data.to_dict(casing=betterproto.Casing.SNAKE))
 
-
-
     def mow_info(self, toapp_mow_info: MowToAppInfoT):
         pass
 

pymammotion/data/model/device_config.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 
 @dataclass
 class DeviceLimits:
-    cutter_height_min: int
-    cutter_height_max: int
+    blade_height_min: int
+    blade_height_max: int
     working_speed_min: float
     working_speed_max: float

pymammotion/data/model/location.py

@@ -34,7 +34,7 @@ class Location:
     RTK: Point
     dock: Dock
     position_type: int
-    orientation: int # 360 degree rotation +-
+    orientation: int  # 360 degree rotation +-
 
     def __init__(self):
         self.device = Point()

pymammotion/data/model/mowing_modes.py

@@ -39,7 +39,8 @@ class MowOrder(IntEnum):
 
 class BypassStrategy(IntEnum):
     """Matches up with ultra_wave."""
+
     direct_touch = 0
     slow_touch = 1
     less_touch = 2
-    no_touch = 3 # luba 2 yuka only or possibly value of 10
+    no_touch = 3  # luba 2 yuka only or possibly value of 10

pymammotion/data/model/report_info.py

@@ -1,4 +1,5 @@
-from dataclasses import dataclass, field, asdict
+from dataclasses import asdict, dataclass, field
+
 
 @dataclass
 class ConnectData:
@@ -9,11 +10,12 @@ class ConnectData:
     @classmethod
     def from_dict(cls, data: dict):
         return cls(
-            connect_type=data.get('connect_type', 0),
-            ble_rssi=data.get('ble_rssi', 0),
-            wifi_rssi=data.get('wifi_rssi', 0)
+            connect_type=data.get("connect_type", 0),
+            ble_rssi=data.get("ble_rssi", 0),
+            wifi_rssi=data.get("wifi_rssi", 0),
         )
 
+
 @dataclass
 class DeviceData:
     sys_status: int = 0
@@ -26,14 +28,15 @@ class DeviceData:
     @classmethod
     def from_dict(cls, data: dict):
         return cls(
-            sys_status=data.get('sys_status', 0),
-            charge_state=data.get('charge_state', 0),
-            battery_val=data.get('battery_val', 0),
-            sensor_status=data.get('sensor_status', 0),
-            last_status=data.get('last_status', 0),
-            sys_time_stamp=data.get('sys_time_stamp', "")
+            sys_status=data.get("sys_status", 0),
+            charge_state=data.get("charge_state", 0),
+            battery_val=data.get("battery_val", 0),
+            sensor_status=data.get("sensor_status", 0),
+            last_status=data.get("last_status", 0),
+            sys_time_stamp=data.get("sys_time_stamp", ""),
         )
 
+
 @dataclass
 class RTKData:
     status: int = 0
@@ -45,13 +48,14 @@ class RTKData:
     @classmethod
     def from_dict(cls, data: dict):
         return cls(
-            status=data.get('status', 0),
-            pos_level=data.get('pos_level', 0),
-            gps_stars=data.get('gps_stars', 0),
-            dis_status=data.get('dis_status', ""),
-            co_view_stars=data.get('co_view_stars', 0)
+            status=data.get("status", 0),
+            pos_level=data.get("pos_level", 0),
+            gps_stars=data.get("gps_stars", 0),
+            dis_status=data.get("dis_status", ""),
+            co_view_stars=data.get("co_view_stars", 0),
         )
 
+
 @dataclass
 class LocationData:
     real_pos_x: int = 0
@@ -63,13 +67,14 @@ class LocationData:
     @classmethod
     def from_dict(cls, data: dict):
         return cls(
-            real_pos_x=data.get('real_pos_x', 0),
-            real_pos_y=data.get('real_pos_y', 0),
-            real_toward=data.get('real_toward', 0),
-            pos_type=data.get('pos_type', 0),
-            bol_hash=data.get('bol_hash', "")
+            real_pos_x=data.get("real_pos_x", 0),
+            real_pos_y=data.get("real_pos_y", 0),
+            real_toward=data.get("real_toward", 0),
+            pos_type=data.get("pos_type", 0),
+            bol_hash=data.get("bol_hash", ""),
         )
 
+
 @dataclass
 class WorkData:
     path: int = 0
@@ -96,28 +101,29 @@ class WorkData:
     @classmethod
     def from_dict(cls, data: dict):
         return cls(
-            path=data.get('path', 0),
-            path_hash=data.get('path_hash', ""),
-            progress=data.get('progress', 0),
-            area=data.get('area', 0),
-            bp_info=data.get('bp_info', 0),
-            bp_hash=data.get('bp_hash', ""),
-            bp_pos_x=data.get('bp_pos_x', 0),
-            bp_pos_y=data.get('bp_pos_y', 0),
-            real_path_num=data.get('real_path_num', ""),
-            path_pos_x=data.get('path_pos_x', 0),
-            path_pos_y=data.get('path_pos_y', 0),
-            ub_zone_hash=data.get('ub_zone_hash', ""),
-            ub_path_hash=data.get('ub_path_hash', ""),
-            init_cfg_hash=data.get('init_cfg_hash', ""),
-            ub_ecode_hash=data.get('ub_ecode_hash', ""),
-            nav_run_mode=data.get('nav_run_mode', 0),
-            test_mode_status=data.get('test_mode_status', 0),
-            man_run_speed=data.get('man_run_speed', 0),
-            nav_edit_status=data.get('nav_edit_status', 0),
-            knife_height=data.get('knife_height', 0)
+            path=data.get("path", 0),
+            path_hash=data.get("path_hash", ""),
+            progress=data.get("progress", 0),
+            area=data.get("area", 0),
+            bp_info=data.get("bp_info", 0),
+            bp_hash=data.get("bp_hash", ""),
+            bp_pos_x=data.get("bp_pos_x", 0),
+            bp_pos_y=data.get("bp_pos_y", 0),
+            real_path_num=data.get("real_path_num", ""),
+            path_pos_x=data.get("path_pos_x", 0),
+            path_pos_y=data.get("path_pos_y", 0),
+            ub_zone_hash=data.get("ub_zone_hash", ""),
+            ub_path_hash=data.get("ub_path_hash", ""),
+            init_cfg_hash=data.get("init_cfg_hash", ""),
+            ub_ecode_hash=data.get("ub_ecode_hash", ""),
+            nav_run_mode=data.get("nav_run_mode", 0),
+            test_mode_status=data.get("test_mode_status", 0),
+            man_run_speed=data.get("man_run_speed", 0),
+            nav_edit_status=data.get("nav_edit_status", 0),
+            knife_height=data.get("knife_height", 0),
         )
 
+
 @dataclass
 class ReportData:
     connect: ConnectData = field(default_factory=ConnectData)
@@ -126,16 +132,15 @@ class ReportData:
     locations: list[LocationData] = field(default_factory=list)
     work: WorkData = field(default_factory=WorkData)
 
-
     def from_dict(self, data: dict):
         locations = self.locations
-        if data.get('locations') is not None:
-            locations=[LocationData.from_dict(loc) for loc in data.get('locations', [])]
+        if data.get("locations") is not None:
+            locations = [LocationData.from_dict(loc) for loc in data.get("locations", [])]
 
         return ReportData(
-            connect=ConnectData.from_dict(data.get('connect', asdict(self.connect))),
-            dev=DeviceData.from_dict(data.get('dev', asdict(self.dev))),
-            rtk=RTKData.from_dict(data.get('rtk', asdict(self.rtk))),
+            connect=ConnectData.from_dict(data.get("connect", asdict(self.connect))),
+            dev=DeviceData.from_dict(data.get("dev", asdict(self.dev))),
+            rtk=RTKData.from_dict(data.get("rtk", asdict(self.rtk))),
             locations=locations,
-            work=WorkData.from_dict(data.get('work', asdict(self.work)))
-        )
+            work=WorkData.from_dict(data.get("work", asdict(self.work))),
+        )

pymammotion/data/mqtt/event.py

@@ -1,6 +1,6 @@
 from base64 import b64decode
 from dataclasses import dataclass
-from typing import Any, Literal, Union
+from typing import Any, Literal, Optional, Union
 
 from google.protobuf import json_format
 from mashumaro.mixins.orjson import DataClassORJSONMixin
@@ -67,6 +67,17 @@ class GeneralParams(DataClassORJSONMixin):
     tenantInstanceId: str
     value: Any
 
+    # Campi opzionali
+    checkFailedData: Optional[dict] = None
+    _tenantId: Optional[str] = None
+    generateTime: Optional[int] = None
+    JMSXDeliveryCount: Optional[int] = None
+    qos: Optional[int] = None
+    requestId: Optional[str] = None
+    _categoryKey: Optional[str] = None
+    deviceType: Optional[str] = None
+    _traceId: Optional[str] = None
+
 
 @dataclass
 class DeviceProtobufMsgEventParams(GeneralParams):
@@ -88,3 +99,23 @@ class ThingEventMessage(DataClassORJSONMixin):
     id: str
     params: Union[DeviceProtobufMsgEventParams, DeviceWarningEventParams]
     version: Literal["1.0"]
+
+    @classmethod
+    def from_dicts(cls, payload: dict) -> "ThingEventMessage":
+        """Deserializza il payload JSON in un'istanza di ThingEventMessage."""
+        method = payload.get("method")
+        event_id = payload.get("id")
+        params_dict = payload.get("params", {})
+        version = payload.get("version")
+
+        # Determina quale classe usare per i parametri
+        identifier = params_dict.get("identifier")
+        if identifier == "device_protobuf_msg_event":
+            params_obj = DeviceProtobufMsgEventParams(**params_dict)
+        elif identifier == "device_warning_event":
+            params_obj = DeviceWarningEventParams(**params_dict)
+        else:
+            raise ValueError(f"Unknown identifier: {identifier}")
+
+        # Crea e restituisce l'istanza di ThingEventMessage
+        return cls(method=method, id=event_id, params=params_obj, version=version)

pymammotion/http/http.py

@@ -1,10 +1,12 @@
 from dataclasses import dataclass
-from typing import Generic, Literal, TypeVar
+from typing import Generic, Literal, Optional, TypeVar
 
 from aiohttp import ClientSession
+from aiohttp.hdrs import AUTHORIZATION
 from mashumaro import DataClassDictMixin
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
+from pymammotion.aliyun.dataclass.connect_response import Device
 from pymammotion.const import (
     MAMMOTION_CLIENT_ID,
     MAMMOTION_CLIENT_SECRET,
@@ -25,7 +27,7 @@ class Response(DataClassDictMixin, Generic[DataT]):
 class LoginResponseUserInformation(DataClassORJSONMixin):
     areaCode: str
     domainAbbreviation: str
-    email: str
+    email: Optional[str]
     userId: str
     userAccount: str
     authType: str
@@ -44,11 +46,11 @@ class LoginResponseData(DataClassORJSONMixin):
     jti: str
 
 
-class LubaHTTP:
-    def __init__(self, session: ClientSession, login: LoginResponseData):
-        self._session = session
-        self._session.headers["Authorization"] = f"Bearer {login.access_token}"
-        self._login = login
+class MammotionHTTP:
+    def __init__(self, login: LoginResponseData):
+        self._headers = dict()
+        self._headers["Authorization"] = f"Bearer {login.access_token}"
+        self.login = login
 
     @classmethod
     async def login(cls, session: ClientSession, username: str, password: str) -> Response[LoginResponseData]:
@@ -63,14 +65,13 @@ class LubaHTTP:
             ),
         ) as resp:
             data = await resp.json()
-            print(data)
             # 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"])
 
 
-async def connect_http(username: str, password: str) -> LubaHTTP:
+async def connect_http(username: str, password: str) -> MammotionHTTP:
     async with ClientSession(MAMMOTION_DOMAIN) as session:
-        login_response = await LubaHTTP.login(session, username, password)
-        return LubaHTTP(session, login_response.data)
+        login_response = await MammotionHTTP.login(session, username, password)
+        return MammotionHTTP(login_response.data)

pymammotion/mammotion/commands/mammotion_command.py

@@ -4,14 +4,11 @@ from pymammotion.mammotion.commands.messages.ota import MessageOta
 from pymammotion.mammotion.commands.messages.system import MessageSystem
 from pymammotion.mammotion.commands.messages.video import MessageVideo
 from pymammotion.proto import dev_net_pb2, luba_msg_pb2
-from pymammotion.utility.device_type import DeviceType
 
 
 class MammotionCommand(MessageSystem, MessageNavigation, MessageNetwork, MessageOta, MessageVideo):
     """MQTT commands for Luba."""
 
-
-
     def __init__(self, device_name: str) -> None:
         self._device_name = device_name
         self._product_key = ""
@@ -26,7 +23,6 @@ class MammotionCommand(MessageSystem, MessageNavigation, MessageNetwork, Message
     def set_device_product_key(self, product_key: str) -> None:
         self._product_key = product_key
 
-
     """BLE commands for Luba."""
 
     def send_todev_ble_sync(self, sync_type: int) -> bytes:

pymammotion/mammotion/commands/messages/navigation.py

@@ -34,7 +34,10 @@ logger = logging.getLogger(__name__)
 class MessageNavigation(AbstractMessage, ABC):
     def get_msg_device(self, msg_type: MsgCmdType, msg_device: MsgDevice) -> MsgDevice:
         """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:
+        if (
+            not DeviceType.is_luba1(self.get_device_name(), self.get_device_product_key())
+            and msg_type == MsgCmdType.MSG_CMD_TYPE_NAV
+        ):
             return MsgDevice.DEV_NAVIGATION
         return msg_device
 

pymammotion/mammotion/devices/mammotion.py

@@ -3,15 +3,17 @@
 from __future__ import annotations
 
 import asyncio
+import base64
 import codecs
 import json
 import logging
 from abc import abstractmethod
 from enum import Enum
-from typing import Any, cast
+from typing import Any, Callable, Optional, cast
 from uuid import UUID
 
 import betterproto
+from aiohttp import ClientSession
 from bleak import BleakClient
 from bleak.backends.device import BLEDevice
 from bleak.backends.service import BleakGATTCharacteristic, BleakGATTServiceCollection
@@ -23,11 +25,15 @@ from bleak_retry_connector import (
     establish_connection,
 )
 
+from pymammotion.aliyun.cloud_gateway import CloudIOTGateway
 from pymammotion.bluetooth import BleMessage
+from pymammotion.const import MAMMOTION_DOMAIN
 from pymammotion.data.model import RegionData
+from pymammotion.data.model.account import Credentials
 from pymammotion.data.model.device import MowingDevice
 from pymammotion.data.mqtt.event import ThingEventMessage
 from pymammotion.data.state_manager import StateManager
+from pymammotion.http.http import MammotionHTTP, connect_http
 from pymammotion.mammotion.commands.mammotion_command import MammotionCommand
 from pymammotion.mqtt import MammotionMQTT
 from pymammotion.proto.luba_msg import LubaMsg
@@ -71,7 +77,7 @@ _LOGGER = logging.getLogger(__name__)
 def slashescape(err):
     """Escape a slash character."""
     # print err, dir(err), err.start, err.end, err.object[:err.start]
-    thebyte = err.object[err.start: err.end]
+    thebyte = err.object[err.start : err.end]
     repl = "\\x" + hex(ord(thebyte))[2:]
     return (repl, err.end)
 
@@ -106,6 +112,12 @@ async def _handle_retry(fut: asyncio.Future[None], func, command: bytes) -> None
         await func(command)
 
 
+async def _handle_retry_cloud(fut: asyncio.Future[None], func, iotId: str, command: bytes) -> None:
+    """Handle a retry."""
+    if not fut.done():
+        func(iotId, command)
+
+
 class ConnectionPreference(Enum):
     """Enum for connection preference."""
 
@@ -118,20 +130,83 @@ class MammotionDevice:
     """Represents a Mammotion device."""
 
     _ble_device: MammotionBaseBLEDevice | None = None
+    _cloud_device: MammotionBaseCloudDevice | None = None
+    _devices_list = []
 
     def __init__(
-            self,
-            ble_device: BLEDevice,
-            preference: ConnectionPreference = ConnectionPreference.EITHER,
+        self,
+        ble_device: BLEDevice,
+        cloud_credentials: Credentials | None = None,
+        preference: ConnectionPreference = ConnectionPreference.EITHER,
     ) -> None:
         """Initialize MammotionDevice."""
         if ble_device:
             self._ble_device = MammotionBaseBLEDevice(ble_device)
             self._preference = preference
 
+        if cloud_credentials:
+            self.initiate_cloud_connection(cloud_credentials.account_id or cloud_credentials.email, cloud_credentials.password)
+
+    async def initiate_cloud_connection(self, account: str, password: str):
+        cloud_client = await self.login(account, password)
+
+        _mammotion_mqtt = MammotionMQTT(region_id=cloud_client._region.data.regionId,
+                                        product_key=cloud_client._aep_response.data.productKey,
+                                        device_name=cloud_client._aep_response.data.deviceName,
+                                        device_secret=cloud_client._aep_response.data.deviceSecret,
+                                        iot_token=cloud_client._session_by_authcode_response.data.iotToken,
+                                        client_id=cloud_client._client_id)
+
+        _mammotion_mqtt._cloud_client = cloud_client
+        _mammotion_mqtt.connect_async()
+
+        self._devices_list = []
+        for device in cloud_client._listing_dev_by_account_response.data.data:
+            if (device.deviceName.startswith(("Luba-", "Yuka-"))):
+                dev = MammotionBaseCloudDevice(
+                    mqtt_client=_mammotion_mqtt,
+                    iot_id=device.iotId,
+                    device_name=device.deviceName,
+                    nick_name=device.nickName
+                )
+                self._devices_list.append(dev)
+
+    @staticmethod
+    async def login(account: str, password: str) -> CloudIOTGateway:
+        """Login to mammotion cloud."""
+        cloud_client = CloudIOTGateway()
+        async with ClientSession(MAMMOTION_DOMAIN) as session:
+            mammotion_http = await connect_http(account, password)
+            country_code = mammotion_http.login.userInformation.domainAbbreviation
+            _LOGGER.debug("CountryCode: " + country_code)
+            _LOGGER.debug("AuthCode: " + mammotion_http.login.authorization_code)
+            cloud_client.get_region(country_code, mammotion_http.login.authorization_code)
+            await cloud_client.connect()
+            await cloud_client.login_by_oauth(country_code, mammotion_http.login.authorization_code)
+            cloud_client.aep_handle()
+            cloud_client.session_by_auth_code()
+
+            cloud_client.list_binding_by_account()
+            return cloud_client
+
+
     async def send_command(self, key: str):
         """Send a command to the device."""
-        return await self._ble_device.command(key)
+        if self._preference is ConnectionPreference.BLUETOOTH:
+            return await self._ble_device.command(key)
+        if self._preference is ConnectionPreference.WIFI:
+            return await self._cloud_device.command(key)
+        # TODO work with both with EITHER
+
+    async def send_command_with_args(self, key, kwargs):
+        """Send a command with args to the device."""
+        if self._preference is ConnectionPreference.BLUETOOTH:
+            return await self._ble_device.command(key, **kwargs)
+        if self._preference is ConnectionPreference.WIFI:
+            return await self._cloud_device.command(key, **kwargs)
+        # TODO work with both with EITHER
+
+
 
 
 def has_field(message: betterproto.Message) -> bool:
@@ -318,8 +393,10 @@ class MammotionBaseDevice:
 
         await self._send_command_with_args("get_hash_response", total_frame=1, current_frame=1)
 
-        await self._send_command_with_args("get_area_name_list",
-                                           device_id=self.luba_msg.device.net.toapp_wifi_iot_status.devicename)
+        await self._send_command_with_args(
+            "get_area_name_list", device_id=self.luba_msg.device.net.toapp_wifi_iot_status.devicename
+        )
+
         # sub_cmd 3 is job hashes??
         # sub_cmd 4 is dump location (yuka)
         # jobs list
@@ -545,7 +622,6 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         new_msg = LubaMsg().parse(data)
         if betterproto.serialized_on_wire(new_msg.net):
             if new_msg.net.todev_ble_sync != 0 or has_field(new_msg.net.toapp_wifi_iot_status):
-
                 if has_field(new_msg.net.toapp_wifi_iot_status) and self._commands.get_device_product_key() == "":
                     self._commands.set_device_product_key(new_msg.net.toapp_wifi_iot_status.productkey)
 
@@ -713,58 +789,149 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
     """Base class for Mammotion Cloud devices."""
 
     def __init__(
-            self,
-            mqtt_client: MammotionMQTT,
-            iot_id: str,
-            device_name: str,
-            nick_name: str,
-            **kwargs: Any,
+        self,
+        mqtt_client: MammotionMQTT,
+        iot_id: str,
+        device_name: str,
+        nick_name: str,
+        **kwargs: Any,
     ) -> None:
         """Initialize MammotionBaseCloudDevice."""
         super().__init__()
+        self._ble_sync_task = None
+        self.is_ready = False
         self._mqtt_client = mqtt_client
         self.iot_id = iot_id
         self.nick_name = nick_name
         self._command_futures = {}
         self._commands: MammotionCommand = MammotionCommand(device_name)
-        self.loop = asyncio.get_event_loop()
+        self.currentID = ""
+        self.on_ready_callback: Optional[Callable[[], None]] = None
+        self._operation_lock = asyncio.Lock()
+
+        self._mqtt_client.on_connected = self.on_connected
+        self._mqtt_client.on_disconnected = self.on_disconnected
+        self._mqtt_client.on_message = self._on_mqtt_message
+        self._mqtt_client.on_ready = self.on_ready
+        if self._mqtt_client.is_connected:
+            self._ble_sync()
+            self.run_periodic_sync_task()
+
+        # temporary for testing only
+        # self._start_sync_task = self.loop.call_later(30, lambda: asyncio.ensure_future(self.start_sync(0)))
+
+    def on_ready(self):
+        """Callback for when MQTT is subscribed to events."""
+        if self.on_ready_callback:
+            self.on_ready_callback()
+
+    def on_connected(self):
+        """Callback for when MQTT connects."""
+        self._ble_sync()
+        self.run_periodic_sync_task()
+
+    def on_disconnected(self):
+        """Callback for when MQTT disconnects."""
 
-    def _on_mqtt_message(self, topic: str, payload: str) -> None:
+    def _ble_sync(self):
+        command_bytes = self._commands.send_todev_ble_sync(3)
+        self._mqtt_client.get_cloud_client().send_cloud_command(self.iot_id, command_bytes)
+
+    async def run_periodic_sync_task(self) -> None:
+        """Send ble sync to robot."""
+        try:
+            self._ble_sync()
+        finally:
+            self.schedule_ble_sync()
+
+    def schedule_ble_sync(self):
+        """Periodically sync to keep connection alive."""
+        if self._mqtt_client is not None and self._mqtt_client.is_connected:
+            self._ble_sync_task = self.loop.call_later(
+                160, lambda: asyncio.ensure_future(self.run_periodic_sync_task())
+            )
+
+    def _on_mqtt_message(self, topic: str, payload: str, iot_id: str) -> None:
         """Handle incoming MQTT messages."""
         _LOGGER.debug("MQTT message received on topic %s: %s", topic, payload)
-        payload = json.loads(payload)
-        message_id = self._extract_message_id(payload)
-        if message_id and message_id in self._command_futures:
-            self._parse_mqtt_response(topic=topic, payload=payload)
-            future = self._command_futures.pop(message_id)
-            if not future.done():
-                future.set_result(payload)
+
+        json_str = json.dumps(payload)
+        payload = json.loads(json_str)
+
+        self._handle_mqtt_message(topic, payload)
 
     async def _send_command(self, key: str, retry: int | None = None) -> bytes | None:
         """Send command to device via MQTT and read response."""
-        future = self.loop.create_future()
-        command_bytes = getattr(self._commands, key)()
-        message_id = self._mqtt_client.get_cloud_client().send_cloud_command(self.iot_id, command_bytes)
-        if message_id != "":
-            self._command_futures[message_id] = future
+        if self._operation_lock.locked():
+            _LOGGER.debug("%s: Operation already in progress, waiting for it to complete;", self.nick_name)
+
+        async with self._operation_lock:
             try:
-                return await asyncio.wait_for(future, timeout=TIMEOUT_CLOUD_RESPONSE)
-            except asyncio.TimeoutError:
-                _LOGGER.error("Command '%s' timed out", key)
-        return None
+                command_bytes = getattr(self._commands, key)()
+                return await self._send_command_locked(key, command_bytes)
+            except Exception as ex:
+                _LOGGER.exception("%s: error in sending command -  %s", self.nick_name, ex)
+                raise
+
+    async def _send_command_locked(self, key: str, command: bytes) -> bytes:
+        """Send command to device and read response."""
+        try:
+            return await self._execute_command_locked(key, command)
+        except Exception as ex:
+            # Disconnect so we can reset state and try again
+            await asyncio.sleep(DBUS_ERROR_BACKOFF_TIME)
+            _LOGGER.debug(
+                "%s: error in _send_command_locked: %s",
+                self.nick_name,
+                ex,
+            )
+            raise
+
+    async def _execute_command_locked(self, key: str, command: bytes) -> bytes:
+        """Execute command and read response."""
+        assert self._mqtt_client is not None
+        self._notify_future = self.loop.create_future()
+        self._key = key
+        _LOGGER.debug("%s: Sending command: %s", self.nick_name, key)
+        self._mqtt_client.get_cloud_client().send_cloud_command(self.iot_id, command)
+
+        retry_handle = self.loop.call_at(
+            self.loop.time() + 20,
+            lambda: asyncio.ensure_future(
+                _handle_retry_cloud(
+                    self._notify_future, self._mqtt_client.get_cloud_client().send_cloud_command, self.iot_id, command
+                )
+            ),
+        )
+        timeout = 20
+        timeout_handle = self.loop.call_at(self.loop.time() + timeout, _handle_timeout, self._notify_future)
+        timeout_expired = False
+        try:
+            notify_msg = await self._notify_future
+        except asyncio.TimeoutError:
+            timeout_expired = True
+            raise
+        finally:
+            if not timeout_expired:
+                timeout_handle.cancel()
+                retry_handle.cancel()
+            self._notify_future = None
+
+        _LOGGER.debug("%s: Message received", self.nick_name)
+
+        return notify_msg
 
     async def _send_command_with_args(self, key: str, **kwargs: any) -> bytes | None:
         """Send command with arguments to device via MQTT and read response."""
-        future = self.loop.create_future()
-        command_bytes = getattr(self._commands, key)(**kwargs)
-        message_id = self._mqtt_client.get_cloud_client().send_cloud_command(self.iot_id, command_bytes)
-        if message_id != "":
-            self._command_futures[message_id] = future
+        if self._operation_lock.locked():
+            _LOGGER.debug("%s: Operation already in progress, waiting for it to complete;", self.nick_name)
+        async with self._operation_lock:
             try:
-                return await asyncio.wait_for(future, timeout=TIMEOUT_CLOUD_RESPONSE)
-            except asyncio.TimeoutError:
-                _LOGGER.error("Command '%s' timed out", key)
-        return None
+                command_bytes = getattr(self._commands, key)(**kwargs)
+                return await self._send_command_locked(key, command_bytes)
+            except Exception as ex:
+                _LOGGER.exception("%s: error in sending command -  %s", self.nick_name, ex)
+                raise
 
     def _extract_message_id(self, payload: dict) -> str:
         """Extract the message ID from the payload."""
@@ -782,10 +949,21 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
     def _parse_mqtt_response(self, topic: str, payload: dict) -> None:
         """Parse the MQTT response."""
         if topic.endswith("/app/down/thing/events"):
-            event = ThingEventMessage(**payload)
+            _LOGGER.debug("Thing event received")
+            event = ThingEventMessage.from_dicts(payload)
             params = event.params
             if params.identifier == "device_protobuf_msg_event":
-                self._update_raw_data(cast(bytes, params.value.content))
+                _LOGGER.debug("Protobuf event")
+                binary_data = base64.b64decode(params.value.get("content", ""))
+                self._update_raw_data(cast(bytes, binary_data))
+                new_msg = LubaMsg().parse(cast(bytes, binary_data))
+                if self._notify_future and not self._notify_future.done():
+                    self._notify_future.set_result(new_msg)
+                asyncio.run(self._state_manager.notification(new_msg))
+
+    def _handle_mqtt_message(self, topic: str, payload: dict) -> None:
+        """Async handler for incoming MQTT messages."""
+        self._parse_mqtt_response(topic=topic, payload=payload)
 
     async def _disconnect(self):
         """Disconnect the MQTT client."""

pymammotion/mqtt/mammotion_mqtt.py

@@ -8,7 +8,7 @@ from logging import getLogger
 from typing import Callable, Optional, cast
 
 from linkkit.linkkit import LinkKit
-from paho.mqtt.client import Client, MQTTMessage, MQTTv311, connack_string
+from paho.mqtt.client import MQTTMessage
 
 from pymammotion.aliyun.cloud_gateway import CloudIOTGateway
 from pymammotion.data.mqtt.event import ThingEventMessage
@@ -22,8 +22,6 @@ logger = getLogger(__name__)
 class MammotionMQTT:
     """MQTT client for pymammotion."""
 
-    _cloud_client = None
-
     def __init__(
         self,
         region_id: str,
@@ -35,8 +33,11 @@ class MammotionMQTT:
     ):
         """Create instance of MammotionMQTT."""
         super().__init__()
-
+        self._cloud_client = None
+        self.is_connected = False
+        self.is_ready = False
         self.on_connected: Optional[Callable[[], None]] = None
+        self.on_ready: Optional[Callable[[], None]] = None
         self.on_error: Optional[Callable[[str], None]] = None
         self.on_disconnected: Optional[Callable[[], None]] = None
         self.on_message: Optional[Callable[[str, str, str], None]] = None
@@ -73,41 +74,19 @@ class MammotionMQTT:
         self._linkkit_client.on_disconnect = self._on_disconnect
         self._linkkit_client.on_thing_enable = self._thing_on_thing_enable
         self._linkkit_client.on_topic_message = self._thing_on_topic_message
-        #        self._mqtt_host = "public.itls.eu-central-1.aliyuncs.com"
         self._mqtt_host = f"{self._product_key}.iot-as-mqtt.{region_id}.aliyuncs.com"
 
-        self._client = Client(
-            client_id=self._mqtt_client_id,
-            protocol=MQTTv311,
-        )
-        self._client.on_message = self._on_message
-        self._client.on_connect = self._on_connect
-        self._client.on_disconnect = self._on_disconnect
-        self._client.username_pw_set(self._mqtt_username, self._mqtt_password)
-        self._client.enable_logger(logger.getChild("paho"))
-
-    # region Connection handling
-    def connect(self):
-        """Connect to MQTT Server."""
-        logger.info("Connecting...")
-        self._client.connect(host=self._mqtt_host)
-        self._client.loop_forever()
-
     def connect_async(self):
         """Connect async to MQTT Server."""
         logger.info("Connecting...")
         self._linkkit_client.thing_setup()
         self._linkkit_client.connect_async()
-        # self._client.connect_async(host=self._mqtt_host)
-        # self._client.loop_start()
         self._linkkit_client.start_worker_loop()
 
     def disconnect(self):
         """Disconnect from MQTT Server."""
         logger.info("Disconnecting...")
         self._linkkit_client.disconnect()
-        self._client.disconnect()
-        self._client.loop_stop()
 
     def _thing_on_thing_enable(self, user_data):
         """Is called when Thing is enabled."""
@@ -139,6 +118,9 @@ class MammotionMQTT:
             ),
         )
 
+        if self.on_ready:
+            self.is_ready = True
+            self.on_ready()
         # self._linkkit_client.query_ota_firmware()
         # command = MammotionCommand(device_name="Luba")
         # self._cloud_client.send_cloud_command(command.get_report_cfg())
@@ -158,39 +140,18 @@ class MammotionMQTT:
 
     def _thing_on_connect(self, session_flag, rc, user_data):
         """Is called on thing connect."""
+        self.is_connected = True
+        if self.on_connected is not None:
+            self.on_connected()
         logger.debug("on_connect, session_flag:%d, rc:%d", session_flag, rc)
 
         # self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/#")
 
-    def _on_connect(self, _client, _userdata, _flags: dict, rc: int):
-        """Is called when on connect."""
-        if rc == 0:
-            logger.debug("Connected")
-            self._client.subscribe(f"/sys/{self._product_key}/{self._device_name}/#")
-            self._client.subscribe(f"/sys/{self._product_key}/{self._device_name}/app/down/account/bind_reply")
-
-            self._client.publish(
-                f"/sys/{self._product_key}/{self._device_name}/app/up/account/bind",
-                json.dumps(
-                    {
-                        "id": "msgid1",
-                        "version": "1.0",
-                        "request": {"clientId": self._mqtt_username},
-                        "params": {"iotToken": self._iot_token},
-                    }
-                ),
-            )
-
-            if self.on_connected:
-                self.on_connected()
-        else:
-            logger.error("Could not connect %s", connack_string(rc))
-            if self.on_error:
-                self.on_error(connack_string(rc))
-
     def _on_disconnect(self, _client, _userdata, rc: int):
         """Is called on disconnect."""
         logger.info("Disconnected")
+        self.is_connected = False
+        self.is_ready = False
         logger.debug(rc)
         if self.on_disconnected:
             self.on_disconnected()

pymammotion/utility/constant/device_constant.py

@@ -257,6 +257,7 @@ def device_mode(value) -> str:
 
 class PosType(IntEnum):
     """Position of the robot."""
+
     AREA_BORDER_ON = 7
     AREA_INSIDE = 1
     AREA_OUT = 0
@@ -268,4 +269,3 @@ class PosType(IntEnum):
     OBS_ON = 2
     TURN_AREA_INSIDE = 4
     VIRTUAL_INSIDE = 6
-

pymammotion/utility/map.py

@@ -1,4 +1,5 @@
 import math
+
 import numpy as np
 
 from pymammotion.data.model.location import Point
@@ -8,11 +9,11 @@ class CoordinateConverter:
     def __init__(self, latitude_rad: float, longitude_rad: float):
         # Initialize constants
         self.WGS84A = 6378137.0
-        self.f_ = 3.3528106647474805E-21
+        self.f_ = 3.3528106647474805e-21
         self.b_ = (1.0 - self.f_) * self.WGS84A
         self.e2_ = (2.0 - self.f_) * self.f_
         self.e2m_ = (1.0 - self.f_) * (1.0 - self.f_)
-        self.ep2_ = ((self.WGS84A ** 2) - (self.b_ ** 2)) / (self.b_ ** 2)
+        self.ep2_ = ((self.WGS84A**2) - (self.b_**2)) / (self.b_**2)
 
         # Initialize rotation matrix
         self.R_ = np.zeros((3, 3))
@@ -31,7 +32,7 @@ class CoordinateConverter:
         sin_lon = math.sin(lon_rad)
         cos_lon = math.cos(lon_rad)
 
-        sqrt = self.WGS84A / math.sqrt(1.0 - (self.e2_ * (sin_lat ** 2)))
+        sqrt = self.WGS84A / math.sqrt(1.0 - (self.e2_ * (sin_lat**2)))
         d3 = sqrt * cos_lat
 
         self.x0_ = d3 * cos_lon
@@ -62,7 +63,10 @@ class CoordinateConverter:
         cos_lat = math.cos(atan2_lat)
 
         lon = math.atan2(d4, d3) * 180.0 / math.pi
-        lat = math.atan2(d5 + self.ep2_ * self.b_ * (sin_lat ** 3), hypot - self.e2_ * self.WGS84A * (cos_lat ** 3)) * 180.0 / math.pi
+        lat = (
+            math.atan2(d5 + self.ep2_ * self.b_ * (sin_lat**3), hypot - self.e2_ * self.WGS84A * (cos_lat**3))
+            * 180.0
+            / math.pi
+        )
 
         return Point(latitude=lat, longitude=lon)
-

{pymammotion-0.1.9.dist-info → pymammotion-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymammotion
-Version: 0.1.9
+Version: 0.2.0
 Summary: 
 License: GNU-3.0
 Author: Michael Arthur

{pymammotion-0.1.9.dist-info → pymammotion-0.2.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-pymammotion/__init__.py,sha256=Hf_TaQAcSiPIwtxcGvznzCB0EOnJmrnZ9PQEqQhmitM,1530
+pymammotion/__init__.py,sha256=kmnjdt3AEMejIz5JK7h1tTJj5ZriAgKwZBa3ScA4-Ao,1516
 pymammotion/aliyun/__init__.py,sha256=T1lkX7TRYiL4nqYanG4l4MImV-SlavSbuooC-W-uUGw,29
-pymammotion/aliyun/cloud_gateway.py,sha256=3j6y4yrN0Gf0T-jbultLqQeEEihdkjn3uSdUodQ30Dw,18295
+pymammotion/aliyun/cloud_gateway.py,sha256=7cU-40s70H8q5D53Qxnul9FenzIgzXZZXN9BEEDKMoo,18308
 pymammotion/aliyun/cloud_service.py,sha256=YWcKuKK6iRWy5mTnBYgHxcCusiRGGzQt3spSf7dGDss,2183
 pymammotion/aliyun/dataclass/aep_response.py,sha256=EPuTU8uN0vkbPY_8MdBKAxASSBI9r021kODeOqrcdtw,353
 pymammotion/aliyun/dataclass/connect_response.py,sha256=Yz-fEbDzgGPTo5Of2oAjmFkSv08T7ze80pQU4k-gKIU,824
-pymammotion/aliyun/dataclass/dev_by_account_response.py,sha256=I3ZQEfF_223dw7yvvICYhQXYwo3_I6SJf5P9qlNbrhk,861
+pymammotion/aliyun/dataclass/dev_by_account_response.py,sha256=qU29Jdpjvxv6mfp4tC3V6UCCkjBwdwttuGfV2C6ELo4,878
 pymammotion/aliyun/dataclass/login_by_oauth_response.py,sha256=6TQYAMyQ1jf_trsnTST007qlNXve3BqsvpV0Dwp7CFA,1245
 pymammotion/aliyun/dataclass/regions_response.py,sha256=0Kcly3OPMIEGK36O0OGFvZrHl6nJfnKzNeC4RPXvFhU,591
 pymammotion/aliyun/dataclass/session_by_authcode_response.py,sha256=wLGSX2nHkA7crmyYeE_dYly_lDtoYWAiIZjQ0C6m44o,358
@@ -20,36 +20,37 @@ pymammotion/bluetooth/data/notifydata.py,sha256=N1bphpueWUWbsWUcpZmMGt2CyCgLcKAF
 pymammotion/const.py,sha256=3plR6t5sFVhx3LoUbW5PE2gqIANoD-fSm-T0q8uIwIU,336
 pymammotion/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/data/model/__init__.py,sha256=d8FlIgCcWqoH3jJSpnm-IY-25RM-l2nbRwLtWjSHo74,222
-pymammotion/data/model/device.py,sha256=FHX1V_bzvpaGlAz6NXdxShNBYOAG-5g8ebnmj3jOqiA,10353
-pymammotion/data/model/device_config.py,sha256=6BcyVbMyw6vA1jANof8_mnG-jizGsF96pbKeHP4t8G4,179
+pymammotion/data/model/account.py,sha256=rgYV61aTY2DlxLbY19Wa3Bp76KGos0_dnfRryvTXa80,118
+pymammotion/data/model/device.py,sha256=jIroL0wEAbxnVQWzd4vKYTUvWwqmUDF4VPss6T7J1bs,10390
+pymammotion/data/model/device_config.py,sha256=E3rhLvUH4BuWEpBfylBYBEwn4G8u7c0QbKxWRElw3Sg,177
 pymammotion/data/model/enums.py,sha256=tD_vYsxstOV_lUkYF9uWkrjVOgAJPNnGevy_xmiu3WE,1558
 pymammotion/data/model/excute_boarder_params.py,sha256=kadSth4y-VXlXIZ6R-Ng-kDvBbM-3YRr8bmR86qR0U0,1355
 pymammotion/data/model/execute_boarder.py,sha256=oDb2h5tFtOQIa8OCNYaDugqCgCZBLjQRzQTNVcJVAGQ,1072
 pymammotion/data/model/generate_route_information.py,sha256=5w1MM1-gXGXb_AoEap_I5xTxAFbNSzXuqQFEkw4NmDs,4301
 pymammotion/data/model/hash_list.py,sha256=z4y0mzbW8LQ5nsaHbMlt1y6uS4suB4D_VljAyIEjFR0,1171
-pymammotion/data/model/location.py,sha256=KEDVD5RgW7z5713EtWgdcseswK71u-7Kb__o58Dl_h8,783
-pymammotion/data/model/mowing_modes.py,sha256=121zhvouPKRbF7mynJIc7tJ0zO9bS-Nq4CFhFI7Nt0s,663
+pymammotion/data/model/location.py,sha256=Fw6r4PFCjBmbUPsI6b0Swke6RgUlzoW7NXjR8EGjgzk,784
+pymammotion/data/model/mowing_modes.py,sha256=2GAF-xaHpv6CSGobYoNtfSi2if8_jW0nonCqN50SNx0,665
 pymammotion/data/model/plan.py,sha256=7JvqAo0a9Yg1Vtifd4J3Dx3StEppxrMOfmq2-877kYg,2891
 pymammotion/data/model/rapid_state.py,sha256=_e9M-65AbkvIqXyMYzLKBxbNvpso42qD8R-JSt66THY,986
 pymammotion/data/model/region_data.py,sha256=75xOTM1qeRbSROp53eIczw3yCmYM9DgMjMh8qE9xkKo,2880
-pymammotion/data/model/report_info.py,sha256=n-bdKf_Np0N9meyEbpoVFrbjTnYFF4Q-3uJpiHtYo0M,4444
+pymammotion/data/model/report_info.py,sha256=1Rj_yRZ9apWX296QHae5prdObDbs32bsQf9rzMz2KEQ,4458
 pymammotion/data/mqtt/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pymammotion/data/mqtt/event.py,sha256=kEilMLmwZG2nbokLw7X28KF3b-te8G-MfNARYm4LG6I,2170
+pymammotion/data/mqtt/event.py,sha256=7hq-dl-HdKJB-TQ2kKfYfrebR_8qWE_lF2nQLlPyphU,3437
 pymammotion/data/mqtt/properties.py,sha256=HkBPghr26L9_b4QaOi1DtPgb0UoPIOGSe9wb3kgnM6Y,2815
 pymammotion/data/mqtt/status.py,sha256=zqnlo-MzejEQZszl0i0Wucoc3E76x6UtI9JLxoBnu54,1067
 pymammotion/data/state_manager.py,sha256=ItihtkmJCeIdXOYD3YRBp241cP29oMABbSISyC5A7tw,2805
 pymammotion/event/__init__.py,sha256=mgATR6vPHACNQ-0zH5fi7NdzeTCDV1CZyaWPmtUusi8,115
 pymammotion/event/event.py,sha256=Fy5-I1p92AO_D67VW4eHQqA4pOt7MZsrP--tVfIVUz8,1820
 pymammotion/http/_init_.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pymammotion/http/http.py,sha256=t9jO1U3Kjy30TzHkzQViv5BtmCKnNfyxrurAvXSghok,2284
+pymammotion/http/http.py,sha256=VoAuDTciiueo8JRjqoZHf8wa0cfvIsFizOp8ISVHRs4,2361
 pymammotion/mammotion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/mammotion/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/mammotion/commands/abstract_message.py,sha256=nw6r7694yzl7iJKqRqhLmAPRjd_TL_Xo_-JXq2_a_ug,222
-pymammotion/mammotion/commands/mammotion_command.py,sha256=5WwD-V0XBkaYIRhxe-kVTTNpeA0XMYZLvmU_pj9rgdc,1548
+pymammotion/mammotion/commands/mammotion_command.py,sha256=ppeWOBO6ifwyajpatIq4RLLpo82-XiU-mVtL-Q9W4Qc,1490
 pymammotion/mammotion/commands/messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/mammotion/commands/messages/driver.py,sha256=IFtmp9gJ3p3U2xtTgWVpKBMbnVnUht6Ioih17po6Hr4,3783
 pymammotion/mammotion/commands/messages/media.py,sha256=ps0l06CXy5Ej--gTNCsyKttwo7yHLVrJUpn-wNJYecs,1150
-pymammotion/mammotion/commands/messages/navigation.py,sha256=c7C6Dru-Xwtq-epzS9vKsy_6QlQ7ozKq9QDhFn2IRHU,23181
+pymammotion/mammotion/commands/messages/navigation.py,sha256=-qit4SrtMpnPr0qsub_HD0pzKMlYsyzspW5uf1Ym008,23217
 pymammotion/mammotion/commands/messages/network.py,sha256=1a0BIhaBhBuhqYaK5EUqLbDgfzjzsIGrXS32wMKtxOU,8316
 pymammotion/mammotion/commands/messages/ota.py,sha256=XkeuWBZtpYMMBze6r8UN7dJXbe2FxUNGNnjwBpXJKM0,1240
 pymammotion/mammotion/commands/messages/system.py,sha256=nQ-g-0ESDQ2YBB6JW7IF4Q1bmTbX_baA4dOw2P3GixI,10957
@@ -57,9 +58,9 @@ pymammotion/mammotion/commands/messages/video.py,sha256=_8lJsU4sLm2CGnc7RDkueA0A
 pymammotion/mammotion/control/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/mammotion/control/joystick.py,sha256=EWV20MMzQuhbLlNlXbsyZKSEpeM7x1CQL7saU4Pn0-g,6165
 pymammotion/mammotion/devices/__init__.py,sha256=T72jt0ejtMjo1rPmn_FeMF3pmp0LLeRRpc9WcDKEYYY,126
-pymammotion/mammotion/devices/mammotion.py,sha256=Dhn7KJxqCiCGbLh5NXJjAjx8Usg3NlD4QykseXK9tpI,31135
+pymammotion/mammotion/devices/mammotion.py,sha256=HooHk3GFCwIdZ79Fb4isMR2u_B1qCWpziSzC2nuTpFU,38641
 pymammotion/mqtt/__init__.py,sha256=Ocs5e-HLJvTuDpVXyECEsWIvwsUaxzj7lZ9mSYutNDY,105
-pymammotion/mqtt/mammotion_mqtt.py,sha256=EBnUwqah-mZNcAn5Hq2sV3NKXueIYWNhYPiaXwaXdHg,9084
+pymammotion/mqtt/mammotion_mqtt.py,sha256=VU0c8X1DrZSZDLCVAsCaEbLX2zcyrUbEAYaPzOXALNo,7523
 pymammotion/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/proto/basestation.proto,sha256=_x5gAz3FkZXS1jtq4GgZgaDCuRU-UV-7HTFdsfQ3zbo,1034
 pymammotion/proto/basestation.py,sha256=js64_N2xQYRxWPRdVNEapO0qe7vBlfYnjW5sE8hi7hw,2026
@@ -103,13 +104,13 @@ pymammotion/proto/mctrl_sys_pb2.py,sha256=DYemb514mlC7c27t-k1YqqBif0xxhLmnIWk8rX
 pymammotion/proto/mctrl_sys_pb2.pyi,sha256=BrivyEP8s7nnuSQkezTbnse9A4J1ad5o6yFcufELLVU,38910
 pymammotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/utility/constant/__init__.py,sha256=tZz7szqIhrzNjfcLU3ysfINfg5VEBUAisd9AhP4mvT0,38
-pymammotion/utility/constant/device_constant.py,sha256=Ebmf1S9Of4s_SNp8yC7Vsbh35IniAeY-DYV4lRY5Kmw,7109
+pymammotion/utility/constant/device_constant.py,sha256=aM69DJJy-h-btLP9RJezld1zm1rGz4gZRdRSpArVtmc,7109
 pymammotion/utility/datatype_converter.py,sha256=v6zym2Zu0upxQjR-xDqXwi3516zpntSlg7LP8tQF5K8,4216
 pymammotion/utility/device_type.py,sha256=KYawu2glZMVlPmxRbA4kVFujXz3miHp3rJiOWRVj-GI,8285
-pymammotion/utility/map.py,sha256=GNDcA-YBIglRJjvQylNdJVefoVzlH16mFSxnojK_B_A,2175
+pymammotion/utility/map.py,sha256=aoi-Luzuph02hKynTofMoq3mnPstanx75MDAVv49CuY,2211
 pymammotion/utility/periodic.py,sha256=9wJMfwXPlx6Mbp3Fws7LLTI34ZDKphH1bva_Ggyk32g,3281
 pymammotion/utility/rocker_util.py,sha256=syPL0QN4zMzHiTIkUKS7RXBBptjdbkfNlPddwUD5V3A,7171
-pymammotion-0.1.9.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pymammotion-0.1.9.dist-info/METADATA,sha256=HhR28E9a2dkTRoICxUxGJcQBZ4exibBI0UW2ud3ppIU,3922
-pymammotion-0.1.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pymammotion-0.1.9.dist-info/RECORD,,
+pymammotion-0.2.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pymammotion-0.2.0.dist-info/METADATA,sha256=Rhb3BsXkrf-fHqvTLQkqnRS1ldAsccbkc6ZhsuZpLR4,3922
+pymammotion-0.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pymammotion-0.2.0.dist-info/RECORD,,