pymammotion 0.3.8__py3-none-any.whl → 0.4.0__py3-none-any.whl

pymammotion/__init__.py

@@ -12,7 +12,7 @@ from pymammotion.aliyun.cloud_gateway import CloudIOTGateway
 
 # works outside HA on its own
 from pymammotion.bluetooth.ble import MammotionBLE
-from pymammotion.http.http import MammotionHTTP, connect_http
+from pymammotion.http.http import MammotionHTTP
 
 # TODO make a working device that will work outside HA too.
 from pymammotion.mqtt import MammotionMQTT
@@ -20,7 +20,7 @@ from pymammotion.mqtt import MammotionMQTT
 logger = logging.getLogger(__name__)
 
 
-__all__ = ["MammotionBLE", "MammotionHTTP", "connect_http", "MammotionMQTT", "logger"]
+__all__ = ["MammotionBLE", "MammotionHTTP", "MammotionMQTT", "logger"]
 
 
 # TODO provide interface to pick between mqtt/cloud/bluetooth

pymammotion/aliyun/cloud_gateway.py

@@ -5,11 +5,11 @@ import hashlib
 import hmac
 import itertools
 import json
+from logging import getLogger
 import random
 import string
 import time
 import uuid
-from logging import getLogger
 
 from aiohttp import ClientSession
 from alibabacloud_iot_api_gateway.client import Client
@@ -19,14 +19,10 @@ from alibabacloud_tea_util.models import RuntimeOptions
 
 from pymammotion.aliyun.model.aep_response import AepResponse
 from pymammotion.aliyun.model.connect_response import ConnectResponse
-from pymammotion.aliyun.model.dev_by_account_response import (
-    ListingDevByAccountResponse,
-)
+from pymammotion.aliyun.model.dev_by_account_response import ListingDevByAccountResponse
 from pymammotion.aliyun.model.login_by_oauth_response import LoginByOAuthResponse
 from pymammotion.aliyun.model.regions_response import RegionResponse
-from pymammotion.aliyun.model.session_by_authcode_response import (
-    SessionByAuthCodeResponse,
-)
+from pymammotion.aliyun.model.session_by_authcode_response import SessionByAuthCodeResponse
 from pymammotion.const import ALIYUN_DOMAIN, APP_KEY, APP_SECRET, APP_VERSION
 from pymammotion.http.http import MammotionHTTP
 from pymammotion.utility.datatype_converter import DatatypeConverter
@@ -58,6 +54,10 @@ class DeviceOfflineException(Exception):
     """Raise exception when device is offline."""
 
 
+class GatewayTimeoutException(Exception):
+    """Raise exception when the gateway times out."""
+
+
 class LoginException(Exception):
     """Raise exception when library cannot log in."""
 
@@ -657,7 +657,7 @@ class CloudIOTGateway:
             iot_token=self._session_by_authcode_response.data.iotToken,
         )
 
-        # TODO move to using  InvokeThingServiceRequest()
+        # TODO move to using InvokeThingServiceRequest()
 
         message_id = str(uuid.uuid4())
 
@@ -689,13 +689,16 @@ class CloudIOTGateway:
                 str(response_body_dict.get("code")),
                 str(response_body_dict.get("message")),
             )
+            if response_body_dict.get("code") == 20056:
+                logger.debug("Gateway timeout.")
+                raise GatewayTimeoutException(response_body_dict.get("code"))
+
             if response_body_dict.get("code") == 29003:
                 logger.debug(self._session_by_authcode_response.data.identityId)
                 self.sign_out()
                 raise SetupException(response_body_dict.get("code"))
             if response_body_dict.get("code") == 6205:
                 raise DeviceOfflineException(response_body_dict.get("code"))
-                """Device is offline."""
 
         return message_id
 

pymammotion/aliyun/model/aep_response.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from mashumaro.config import BaseConfig
 from mashumaro.mixins.orjson import DataClassORJSONMixin
@@ -16,7 +15,7 @@ class DeviceData(DataClassORJSONMixin):
 class AepResponse(DataClassORJSONMixin):
     code: int
     data: DeviceData
-    id: Optional[str] = None
+    id: str | None = None
 
     class Config(BaseConfig):
         omit_default = True

pymammotion/aliyun/model/dev_by_account_response.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from mashumaro.config import BaseConfig
 from mashumaro.mixins.orjson import DataClassORJSONMixin
@@ -23,11 +22,11 @@ class Device(DataClassORJSONMixin):
     identityId: str
     thingType: str
     status: int
-    nickName: Optional[str] = None
-    description: Optional[str] = None
-    productImage: Optional[str] = None
-    categoryImage: Optional[str] = None
-    productModel: Optional[str] = None
+    nickName: str | None = None
+    description: str | None = None
+    productImage: str | None = None
+    categoryImage: str | None = None
+    productModel: str | None = None
 
     class Config(BaseConfig):
         omit_default = True
@@ -44,5 +43,5 @@ class Data(DataClassORJSONMixin):
 @dataclass
 class ListingDevByAccountResponse(DataClassORJSONMixin):
     code: int
-    data: Optional[Data]
-    id: Optional[str] = None
+    data: Data | None
+    id: str | None = None

pymammotion/aliyun/model/login_by_oauth_response.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
@@ -18,7 +17,7 @@ class OpenAccount(DataClassORJSONMixin):
     domainId: int
     enableDevice: str
     status: int
-    country: Optional[str] = None
+    country: str | None = None
 
 
 @dataclass
@@ -54,7 +53,7 @@ class InnerData(DataClassORJSONMixin):
     subCode: int
     message: str
     successful: str
-    deviceId: Optional[str] = None
+    deviceId: str | None = None
 
 
 @dataclass

pymammotion/aliyun/model/regions_response.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 from mashumaro.config import BaseConfig
 from mashumaro.mixins.orjson import DataClassORJSONMixin
@@ -22,8 +22,8 @@ class RegionResponseData(DataClassORJSONMixin):
 class RegionResponse(DataClassORJSONMixin):
     data: RegionResponseData
     code: int
-    id: Optional[str] = None
-    msg: Optional[str] = None
+    id: str | None = None
+    msg: str | None = None
 
     class Config(BaseConfig):
         omit_default = True

pymammotion/aliyun/model/session_by_authcode_response.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
@@ -16,4 +15,4 @@ class SessionOauthToken(DataClassORJSONMixin):
 @dataclass
 class SessionByAuthCodeResponse(DataClassORJSONMixin):
     code: int
-    data: Optional[SessionOauthToken] = None
+    data: SessionOauthToken | None = None

pymammotion/aliyun/model/stream_subscription_response.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import List
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
@@ -13,7 +12,7 @@ class Camera(DataClassORJSONMixin):
 @dataclass
 class StreamSubscriptionResponse(DataClassORJSONMixin):
     appid: str
-    cameras: List[Camera]
+    cameras: list[Camera]
     channelName: str
     token: str
     uid: int

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:
@@ -60,5 +59,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)
@@ -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/data/model/device.py

@@ -1,32 +1,18 @@
 """MowingDevice class to wrap around the betterproto dataclasses."""
 
 from dataclasses import dataclass, field
-from typing import Optional
 
 import betterproto
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 from pymammotion.data.model import HashList, RapidState
-from pymammotion.data.model.device_config import DeviceLimits
-from pymammotion.data.model.device_info import MowerInfo
+from pymammotion.data.model.device_info import DeviceFirmwares, MowerInfo
 from pymammotion.data.model.location import Location
 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.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,
-    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
@@ -36,29 +22,19 @@ from pymammotion.utility.map import CoordinateConverter
 class MowingDevice(DataClassORJSONMixin):
     """Wraps the betterproto dataclasses, so we can bypass the groups for keeping all data."""
 
+    online: bool = True
     mower_state: MowerInfo = field(default_factory=MowerInfo)
     mqtt_properties: ThingPropertiesMessage | None = None
+    status_properties: ThingStatusMessage | None = None
     map: HashList = field(default_factory=HashList)
     location: Location = field(default_factory=Location)
     mowing_state: RapidState = field(default_factory=RapidState)
     report_data: ReportData = field(default_factory=ReportData)
+    device_firmwares: DeviceFirmwares = field(default_factory=DeviceFirmwares)
     err_code_list: list = field(default_factory=list)
-    err_code_list_time: Optional[list] = field(default_factory=list)
-    limits: DeviceLimits = field(default_factory=DeviceLimits)
-    device: Optional[LubaMsg] = field(default_factory=LubaMsg)
+    err_code_list_time: list | None = field(default_factory=list)
     error_codes: dict[str, ErrorInfo] = field(default_factory=dict)
 
-    @classmethod
-    def from_raw(cls, raw: dict) -> "MowingDevice":
-        """Take in raw data to hold in the betterproto dataclass."""
-        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) -> None:
         """Update the device based on which buffer we are reading from."""
         match buffer_list.update_buf_data[0]:
@@ -106,7 +82,7 @@ class MowingDevice(DataClassORJSONMixin):
         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)
                 )
@@ -115,13 +91,16 @@ class MowingDevice(DataClassORJSONMixin):
                         location.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
                     )
 
+        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=betterproto.Casing.SNAKE))
 
     def run_state_update(self, rapid_state: SystemRapidStateTunnelMsg) -> None:
         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)
         )
@@ -136,198 +115,22 @@ class MowingDevice(DataClassORJSONMixin):
     def report_missing_data(self) -> None:
         """Report missing data so we can refetch it."""
 
-    @property
-    def net(self):
-        """Will return a wrapped betterproto of net."""
-        return DevNetData(net=self.device.net)
-
-    @property
-    def sys(self):
-        """Will return a wrapped betterproto of sys."""
-        return SysData(sys=self.device.sys)
-
-    @property
-    def nav(self):
-        """Will return a wrapped betterproto of nav."""
-        return NavData(nav=self.device.nav)
-
-    @property
-    def driver(self):
-        """Will return a wrapped betterproto of driver."""
-        return DriverData(driver=self.device.driver)
-
-    @property
-    def mul(self):
-        """Will return a wrapped betterproto of mul."""
-        return MulData(mul=self.device.mul)
-
-    @property
-    def ota(self):
-        """Will return a wrapped betterproto of ota."""
-        return OtaData(ota=self.device.ota)
-
-    @property
-    def pept(self):
-        """Will return a wrapped betterproto of pept."""
-        return PeptData(pept=self.device.pept)
-
-
-@dataclass
-class DevNetData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    net: dict
-
-    def __init__(self, net: DevNet) -> None:
-        if isinstance(net, dict):
-            self.net = net
-        else:
-            self.net = net.to_dict()
-
-    def __getattr__(self, item):
-        """Intercept call to get net in dict and return a betterproto dataclass."""
-        if self.net.get(item) is None:
-            return DevNet().__getattribute__(item)
-
-        if not isinstance(self.net.get(item), dict):
-            return self.net.get(item)
-
-        return DevNet().__getattribute__(item).from_dict(value=self.net.get(item))
-
-
-@dataclass
-class SysData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    sys: dict
-
-    def __init__(self, sys: MctlSys) -> None:
-        if isinstance(sys, dict):
-            self.sys = sys
-        else:
-            self.sys = sys.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get sys in dict and return a betterproto dataclass."""
-        if self.sys.get(item) is None:
-            return MctlSys().__getattribute__(item)
-
-        if not isinstance(self.sys.get(item), dict):
-            return self.sys.get(item)
-
-        return MctlSys().__getattribute__(item).from_dict(value=self.sys.get(item))
-
-
-@dataclass
-class NavData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    nav: dict
-
-    def __init__(self, nav: MctlNav) -> None:
-        if isinstance(nav, dict):
-            self.nav = nav
-        else:
-            self.nav = nav.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get nav in dict and return a betterproto dataclass."""
-        if self.nav.get(item) is None:
-            return MctlNav().__getattribute__(item)
-
-        if not isinstance(self.nav.get(item), dict):
-            return self.nav.get(item)
-
-        return MctlNav().__getattribute__(item).from_dict(value=self.nav.get(item))
-
-
-@dataclass
-class DriverData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    driver: dict
-
-    def __init__(self, driver: MctlDriver) -> None:
-        if isinstance(driver, dict):
-            self.driver = driver
-        else:
-            self.driver = driver.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get driver in dict and return a betterproto dataclass."""
-        if self.driver.get(item) is None:
-            return MctlDriver().__getattribute__(item)
-
-        if not isinstance(self.driver.get(item), dict):
-            return self.driver.get(item)
-
-        return MctlDriver().__getattribute__(item).from_dict(value=self.driver.get(item))
-
-
-@dataclass
-class MulData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    mul: dict
-
-    def __init__(self, mul: SocMul) -> None:
-        if isinstance(mul, dict):
-            self.mul = mul
-        else:
-            self.mul = mul.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get mul in dict and return a betterproto dataclass."""
-        if self.mul.get(item) is None:
-            return SocMul().__getattribute__(item)
-
-        if not isinstance(self.mul.get(item), dict):
-            return self.mul.get(item)
-
-        return SocMul().__getattribute__(item).from_dict(value=self.mul.get(item))
-
-
-@dataclass
-class OtaData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    ota: dict
-
-    def __init__(self, ota: MctlOta) -> None:
-        if isinstance(ota, dict):
-            self.ota = ota
-        else:
-            self.ota = ota.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get ota in dict and return a betterproto dataclass."""
-        if self.ota.get(item) is None:
-            return MctlOta().__getattribute__(item)
-
-        if not isinstance(self.ota.get(item), dict):
-            return self.ota.get(item)
-
-        return MctlOta().__getattribute__(item).from_dict(value=self.ota.get(item))
-
-
-@dataclass
-class PeptData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    pept: dict
-
-    def __init__(self, pept: MctlPept) -> None:
-        if isinstance(pept, dict):
-            self.pept = pept
-        else:
-            self.pept = pept.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get pept in dict and return a betterproto dataclass."""
-        if self.pept.get(item) is None:
-            return MctlPept().__getattribute__(item)
-
-        if not isinstance(self.pept.get(item), dict):
-            return self.pept.get(item)
-
-        return MctlPept().__getattribute__(item).from_dict(value=self.pept.get(item))
+    def update_device_firmwares(self, fw_info: DeviceFwInfo) -> None:
+        """Sets 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

pymammotion/data/model/device_config.py

@@ -5,16 +5,6 @@ from mashumaro.mixins.orjson import DataClassORJSONMixin
 from pymammotion.utility.device_type import DeviceType
 
 
-@dataclass
-class DeviceLimits(DataClassORJSONMixin):
-    blade_height_min: int = 30
-    blade_height_max: int = 100
-    working_speed_min: float = 0.2
-    working_speed_max: float = 1.2
-    working_path_min: int = 15
-    working_path_max: int = 35
-
-
 @dataclass
 class OperationSettings(DataClassORJSONMixin):
     """Operation settings for a device."""

pymammotion/data/model/device_info.py

@@ -23,3 +23,16 @@ class MowerInfo(DataClassORJSONMixin):
     swversion: str = ""
     product_key: str = ""
     model_id: str = ""
+    sub_model_id: str = ""
+
+
+@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 = ""