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

pymammotion/data/model/device_limits.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class RangeLimit:
+    min: float
+    max: float
+
+
+@dataclass
+class DeviceLimits:
+    cutter_height: RangeLimit = field(default_factory=RangeLimit)
+    working_speed: RangeLimit = field(default_factory=RangeLimit)
+    working_path: RangeLimit = field(default_factory=RangeLimit)
+    work_area_num_max: int = 60
+    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},
+            "working_speed": {"min": self.working_speed.min, "max": self.working_speed.max},
+            "working_path": {"min": self.working_path.min, "max": self.working_path.max},
+            "work_area_num_max": self.work_area_num_max,
+            "display_image_type": self.display_image_type,
+        }
+
+    @classmethod
+    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"]),
+            working_speed=RangeLimit(min=data["working_speed"]["min"], max=data["working_speed"]["max"]),
+            working_path=RangeLimit(min=data["working_path"]["min"], max=data["working_path"]["max"]),
+            work_area_num_max=data["work_area_num_max"],
+            display_image_type=data["display_image_type"],
+        )
+
+    def validate(self) -> bool:
+        """Validate that all ranges are logical (min <= max)."""
+        return all(
+            [
+                self.cutter_height.min <= self.cutter_height.max,
+                self.working_speed.min <= self.working_speed.max,
+                self.working_path.min <= self.working_path.max,
+                self.work_area_num_max > 0,
+                self.display_image_type in (0, 1),
+            ]
+        )

pymammotion/data/model/generate_route_information.py

@@ -1,5 +1,5 @@
-import logging
 from dataclasses import dataclass
+import logging
 
 logger = logging.getLogger(__name__)
 

pymammotion/data/model/hash_list.py

@@ -3,7 +3,7 @@ from enum import IntEnum
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
-from pymammotion.proto.mctrl_nav import NavGetCommDataAck, NavGetHashListAck, SvgMessageAckT
+from pymammotion.proto import NavGetCommDataAck, NavGetHashListAck, SvgMessageAckT
 
 
 class PathType(IntEnum):
@@ -93,7 +93,7 @@ class HashList(DataClassORJSONMixin):
         # If no match was found, append the new item
         self.root_hash_list.data.append(hash_list)
 
-    def missing_hash_frame(self):
+    def missing_hash_frame(self) -> list[int]:
         return self._find_missing_frames(self.root_hash_list)
 
     def missing_frame(self, hash_data: NavGetCommDataAck | SvgMessageAckT) -> list[int]:
@@ -112,6 +112,8 @@ class HashList(DataClassORJSONMixin):
         if hash_data.type == PathType.SVG:
             return self._find_missing_frames(self.svg.get(hash_data.data_hash))
 
+        return []
+
     def update(self, hash_data: NavGetCommDataAck | SvgMessageAckT) -> bool:
         """Update the map data."""
         if hash_data.type == PathType.AREA:
@@ -133,6 +135,8 @@ class HashList(DataClassORJSONMixin):
         if hash_data.type == PathType.SVG:
             return self._add_hash_data(self.svg, hash_data)
 
+        return False
+
     @staticmethod
     def _find_missing_frames(frame_list: FrameList | RootHashList) -> list[int]:
         if frame_list.total_frame == len(frame_list.data):

pymammotion/data/model/plan.py

@@ -1,6 +1,3 @@
-from typing import List
-
-
 class Plan:
     def __init__(self) -> None:
         self.pver: int = 0

pymammotion/data/model/raw_data.py

@@ -0,0 +1,215 @@
+from dataclasses import dataclass, field
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+from pymammotion.proto import DevNet, LubaMsg, MctlDriver, MctlNav, MctlOta, MctlPept, MctlSys, SocMul
+
+
+@dataclass
+class RawMowerData:
+    raw: LubaMsg | None = field(default_factory=LubaMsg)
+
+    @classmethod
+    def from_raw(cls, raw: dict) -> "RawMowerData":
+        """Take in raw data to hold in the betterproto dataclass."""
+        return RawMowerData(raw=LubaMsg(**raw))
+
+    def update_raw(self, raw: dict) -> None:
+        """Update the raw LubaMsg data."""
+        self.raw = LubaMsg(**raw)
+
+    @property
+    def net(self):
+        """Will return a wrapped betterproto of net."""
+        return DevNetData(net=self.raw.net)
+
+    @property
+    def sys(self):
+        """Will return a wrapped betterproto of sys."""
+        return SysData(sys=self.raw.sys)
+
+    @property
+    def nav(self):
+        """Will return a wrapped betterproto of nav."""
+        return NavData(nav=self.raw.nav)
+
+    @property
+    def driver(self):
+        """Will return a wrapped betterproto of driver."""
+        return DriverData(driver=self.raw.driver)
+
+    @property
+    def mul(self):
+        """Will return a wrapped betterproto of mul."""
+        return MulData(mul=self.raw.mul)
+
+    @property
+    def ota(self):
+        """Will return a wrapped betterproto of ota."""
+        return OtaData(ota=self.raw.ota)
+
+    @property
+    def pept(self):
+        """Will return a wrapped betterproto of pept."""
+        return PeptData(pept=self.raw.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))

pymammotion/data/model/region_data.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
@@ -7,14 +6,14 @@ from mashumaro.mixins.orjson import DataClassORJSONMixin
 @dataclass
 class RegionData(DataClassORJSONMixin):
     def __init__(self) -> None:
-        self.hash: Optional[int] = None
+        self.hash: int | None = None
         self.action: int = 0
         self.current_frame: int = 0
-        self.data_hash: Optional[int] = None
+        self.data_hash: int | None = None
         self.data_len: int = 0
-        self.p_hash_a: Optional[int] = None
-        self.p_hash_b: Optional[int] = None
-        self.path: Optional[list[list[float]]] = None
+        self.p_hash_a: int | None = None
+        self.p_hash_b: int | None = None
+        self.path: list[list[float]] | None = None
         self.pver: int = 0
         self.result: int = 0
         self.sub_cmd: int = 0
@@ -72,31 +71,31 @@ class RegionData(DataClassORJSONMixin):
     def set_current_frame(self, current_frame: int) -> None:
         self.current_frame = current_frame
 
-    def get_path(self) -> Optional[list[list[float]]]:
+    def get_path(self) -> list[list[float]] | None:
         return self.path
 
     def set_path(self, path: list[list[float]]) -> None:
         self.path = path
 
-    def get_hash(self) -> Optional[int]:
+    def get_hash(self) -> int | None:
         return self.hash
 
     def set_data_hash(self, data_hash: int) -> None:
         self.data_hash = data_hash
 
-    def get_data_hash(self) -> Optional[int]:
+    def get_data_hash(self) -> int | None:
         return self.data_hash
 
     def set_p_hash_a(self, p_hash_a: int) -> None:
         self.p_hash_a = p_hash_a
 
-    def get_p_hash_a(self) -> Optional[int]:
+    def get_p_hash_a(self) -> int | None:
         return self.p_hash_a
 
     def set_p_hash_b(self, p_hash_b: int) -> None:
         self.p_hash_b = p_hash_b
 
-    def get_p_hash_b(self) -> Optional[int]:
+    def get_p_hash_b(self) -> int | None:
         return self.p_hash_b
 
     def __str__(self) -> str:

pymammotion/data/model/report_info.py

@@ -8,7 +8,7 @@ class ConnectData(DataClassORJSONMixin):
     connect_type: int = 0
     ble_rssi: int = 0
     wifi_rssi: int = 0
-    used_net: str = ""
+    used_net: str = "None"
 
 
 @dataclass

pymammotion/data/mqtt/event.py

@@ -1,6 +1,6 @@
 from base64 import b64decode
 from dataclasses import dataclass
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 
 from google.protobuf import json_format
 from mashumaro.mixins.orjson import DataClassORJSONMixin
@@ -91,16 +91,16 @@ class GeneralParams(DataClassORJSONMixin):
     tenantInstanceId: str
     value: Any
 
-    identifier: Optional[str] = None
-    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
+    identifier: str | None = None
+    checkFailedData: dict | None = None
+    _tenantId: str | None = None
+    generateTime: int | None = None
+    JMSXDeliveryCount: int | None = None
+    qos: int | None = None
+    requestId: str | None = None
+    _categoryKey: str | None = None
+    deviceType: str | None = None
+    _traceId: str | None = None
 
 
 @dataclass
@@ -117,7 +117,7 @@ class DeviceNotificationEventParams(GeneralParams):
     {'data': '{"localTime":1725159492000,"code":"1002"}'},
     """
 
-    identifier: Literal["device_notification_event", "device_warning_code_event"]
+    identifier: Literal["device_notification_event", "device_information_event", "device_warning_code_event"]
     type: Literal["info"]
     value: DeviceNotificationEventValue
 
@@ -146,7 +146,7 @@ class DeviceConfigurationRequestEvent(GeneralParams):
 class ThingEventMessage(DataClassORJSONMixin):
     method: Literal["thing.events", "thing.properties"]
     id: str
-    params: Union[DeviceProtobufMsgEventParams, DeviceWarningEventParams, dict]
+    params: DeviceProtobufMsgEventParams | DeviceWarningEventParams | dict
     version: Literal["1.0"]
 
     @classmethod
@@ -170,7 +170,11 @@ class ThingEventMessage(DataClassORJSONMixin):
             params_obj = DeviceBizReqEventParams.from_dict(params_dict)
         elif identifier == "device_config_req_event":
             params_obj = payload.get("params", {})
-        elif identifier == "device_notification_event" or identifier == "device_warning_code_event":
+        elif (
+            identifier == "device_notification_event"
+            or identifier == "device_warning_code_event"
+            or identifier == "device_information_event"
+        ):
             params_obj = DeviceNotificationEventParams.from_dict(params_dict)
         else:
             raise ValueError(f"Unknown identifier: {identifier} {params_dict}")

pymammotion/data/mqtt/properties.py

@@ -116,7 +116,7 @@ Items = Union[
 @dataclass
 class Item:
     time: int
-    value: Union[int, float, str, dict[str, Any]]  # Depending on the type of value
+    value: int | float | str | dict[str, Any]  # Depending on the type of value
 
 
 @dataclass

pymammotion/data/mqtt/status.py

@@ -26,7 +26,7 @@ class Status(DataClassORJSONMixin):
 @dataclass
 class Params(DataClassORJSONMixin):
     groupIdList: list[GroupIdListItem]
-    netType: Literal["NET_WIFI"]
+    netType: Literal["NET_WIFI", "NET_MNET"]
     activeTime: int
     ip: str
     aliyunCommodityCode: Literal["iothub_senior"]

pymammotion/data/state_manager.py

@@ -1,8 +1,9 @@
 """Manage state from notifications into MowingDevice."""
 
-import logging
+from collections.abc import Awaitable, Callable
 from datetime import datetime
-from typing import Any, Awaitable, Callable, Optional
+import logging
+from typing import Any
 
 import betterproto
 
@@ -10,10 +11,20 @@ from pymammotion.data.model.device import MowingDevice
 from pymammotion.data.model.device_info import SideLight
 from pymammotion.data.model.hash_list import AreaHashNameList
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
-from pymammotion.proto.dev_net import WifiIotStatusReport
-from pymammotion.proto.luba_msg import LubaMsg
-from pymammotion.proto.mctrl_nav import AppGetAllAreaHashName, NavGetCommDataAck, NavGetHashListAck, SvgMessageAckT
-from pymammotion.proto.mctrl_sys import DeviceProductTypeInfoT, TimeCtrlLight
+from pymammotion.data.mqtt.status import ThingStatusMessage
+from pymammotion.proto import (
+    AppGetAllAreaHashName,
+    DeviceFwInfo,
+    DeviceProductTypeInfoT,
+    DrvDevInfoResp,
+    DrvDevInfoResult,
+    LubaMsg,
+    NavGetCommDataAck,
+    NavGetHashListAck,
+    SvgMessageAckT,
+    TimeCtrlLight,
+    WifiIotStatusReport,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -23,15 +34,22 @@ class StateManager:
 
     _device: MowingDevice
     last_updated_at: datetime = datetime.now()
+    cloud_gethash_ack_callback: Callable[[NavGetHashListAck], Awaitable[None]] | None = None
+    cloud_get_commondata_ack_callback: Callable[[NavGetCommDataAck | SvgMessageAckT], Awaitable[None]] | None = None
+    cloud_on_notification_callback: Callable[[tuple[str, Any | None]], Awaitable[None]] | None = None
+
+    # possibly don't need anymore
+    cloud_queue_command_callback: Callable[[str, dict[str, Any]], Awaitable[bytes]] | None = None
+
+    ble_gethash_ack_callback: Callable[[NavGetHashListAck], Awaitable[None]] | None = None
+    ble_get_commondata_ack_callback: Callable[[NavGetCommDataAck | SvgMessageAckT], Awaitable[None]] | None = None
+    ble_on_notification_callback: Callable[[tuple[str, Any | None]], Awaitable[None]] | None = None
+
+    # possibly don't need anymore
+    ble_queue_command_callback: Callable[[str, dict[str, Any]], Awaitable[bytes]] | None = None
 
     def __init__(self, device: MowingDevice) -> None:
         self._device = device
-        self.gethash_ack_callback: Optional[Callable[[NavGetHashListAck], Awaitable[None]]] = None
-        self.get_commondata_ack_callback: Optional[Callable[[NavGetCommDataAck | SvgMessageAckT], Awaitable[None]]] = (
-            None
-        )
-        self.on_notification_callback: Optional[Callable[[tuple[str, Any | None]], Awaitable[None]]] = None
-        self.queue_command_callback: Optional[Callable[[str, dict[str, Any]], Awaitable[bytes]]] = None
         self.last_updated_at = datetime.now()
 
     def get_device(self) -> MowingDevice:
@@ -42,9 +60,40 @@ class StateManager:
         """Set device."""
         self._device = device
 
-    async def properties(self, properties: ThingPropertiesMessage) -> None:
-        params = properties.params
-        self._device.mqtt_properties = params
+    def properties(self, thing_properties: ThingPropertiesMessage) -> None:
+        # TODO update device based off thing properties
+        self._device.mqtt_properties = thing_properties
+
+    def status(self, thing_status: ThingStatusMessage) -> None:
+        if not self._device.online:
+            self._device.online = True
+        self._device.status_properties = thing_status
+
+    @property
+    def online(self) -> bool:
+        return self._device.online
+
+    @online.setter
+    def online(self, value: bool) -> None:
+        self._device.online = value
+
+    async def gethash_ack_callback(self, msg: NavGetHashListAck) -> None:
+        if self.cloud_gethash_ack_callback:
+            await self.cloud_gethash_ack_callback(msg)
+        elif self.ble_gethash_ack_callback:
+            await self.ble_gethash_ack_callback(msg)
+
+    async def on_notification_callback(self, res: tuple[str, Any | None]) -> None:
+        if self.cloud_on_notification_callback:
+            await self.cloud_on_notification_callback(res)
+        elif self.ble_on_notification_callback:
+            await self.ble_on_notification_callback(res)
+
+    async def get_commondata_ack_callback(self, comm_data: NavGetCommDataAck | SvgMessageAckT) -> None:
+        if self.cloud_get_commondata_ack_callback:
+            await self.cloud_get_commondata_ack_callback(comm_data)
+        elif self.ble_get_commondata_ack_callback:
+            await self.ble_get_commondata_ack_callback(comm_data)
 
     async def notification(self, message: LubaMsg) -> None:
         """Handle protobuf notifications."""
@@ -55,7 +104,7 @@ class StateManager:
             case "nav":
                 await self._update_nav_data(message)
             case "sys":
-                await self._update_sys_data(message)
+                self._update_sys_data(message)
             case "driver":
                 self._update_driver_data(message)
             case "net":
@@ -65,8 +114,7 @@ class StateManager:
             case "ota":
                 self._update_ota_data(message)
 
-        if self.on_notification_callback:
-            await self.on_notification_callback(res)
+        await self.on_notification_callback(res)
 
     async def _update_nav_data(self, message) -> None:
         """Update nav data."""
@@ -82,17 +130,17 @@ class StateManager:
                 if updated:
                     await self.get_commondata_ack_callback(common_data)
             case "toapp_svg_msg":
-                common_data: SvgMessageAckT = nav_msg[1]
-                updated = self._device.map.update(common_data)
+                common_svg_data: SvgMessageAckT = nav_msg[1]
+                updated = self._device.map.update(common_svg_data)
                 if updated:
-                    await self.get_commondata_ack_callback(common_data)
+                    await self.get_commondata_ack_callback(common_svg_data)
 
             case "toapp_all_hash_name":
                 hash_names: AppGetAllAreaHashName = nav_msg[1]
                 converted_list = [AreaHashNameList(name=item.name, hash=item.hash) for item in hash_names.hashnames]
                 self._device.map.area_name = converted_list
 
-    async def _update_sys_data(self, message) -> None:
+    def _update_sys_data(self, message) -> None:
         """Update system."""
         sys_msg = betterproto.which_one_of(message.sys, "SubSysMsg")
         match sys_msg[0]:
@@ -110,7 +158,13 @@ class StateManager:
                 self._device.mower_state.side_led = side_led
             case "device_product_type_info":
                 device_product_type: DeviceProductTypeInfoT = sys_msg[1]
-                self._device.mower_state.model_id = device_product_type.main_product_type
+                if device_product_type.main_product_type != "" or device_product_type.sub_product_type != "":
+                    self._device.mower_state.model_id = device_product_type.main_product_type
+                    self._device.mower_state.sub_model_id = device_product_type.sub_product_type
+            case "toapp_dev_fw_info":
+                device_fw_info: DeviceFwInfo = sys_msg[1]
+                self._device.device_firmwares.device_version = device_fw_info.version
+                self._device.mower_state.swversion = device_fw_info.version
 
     def _update_driver_data(self, message) -> None:
         pass
@@ -121,6 +175,12 @@ class StateManager:
             case "toapp_wifi_iot_status":
                 wifi_iot_status: WifiIotStatusReport = net_msg[1]
                 self._device.mower_state.product_key = wifi_iot_status.productkey
+            case "toapp_devinfo_resp":
+                toapp_devinfo_resp: DrvDevInfoResp = net_msg[1]
+                for resp in toapp_devinfo_resp.resp_ids:
+                    if resp.res == DrvDevInfoResult.DRV_RESULT_SUC and resp.id == 1 and resp.type == 6:
+                        self._device.mower_state.swversion = resp.info
+                        self._device.device_firmwares.device_version = resp.info
 
     def _update_mul_data(self, message) -> None:
         pass