conson-xp 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

xp/services/conbus/conbus_datapoint_service.py

@@ -44,7 +44,9 @@ class ConbusDatapointService(ConbusProtocol):
         self.telegram_service = telegram_service
         self.serial_number: str = ""
         self.datapoint_type: Optional[DataPointType] = None
-        self.finish_callback: Optional[Callable[[ConbusDatapointResponse], None]] = None
+        self.datapoint_finished_callback: Optional[
+            Callable[[ConbusDatapointResponse], None]
+        ] = None
         self.service_response: ConbusDatapointResponse = ConbusDatapointResponse(
             success=False,
             serial_number=self.serial_number,
@@ -125,8 +127,9 @@ class ConbusDatapointService(ConbusProtocol):
         self.service_response.system_function = SystemFunction.READ_DATAPOINT
         self.service_response.datapoint_type = self.datapoint_type
         self.service_response.datapoint_telegram = datapoint_telegram
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        self.service_response.data_value = datapoint_telegram.data_value
+        if self.datapoint_finished_callback:
+            self.datapoint_finished_callback(self.service_response)
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -139,8 +142,8 @@ class ConbusDatapointService(ConbusProtocol):
         self.service_response.timestamp = datetime.now()
         self.service_response.serial_number = self.serial_number
         self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        if self.datapoint_finished_callback:
+            self.datapoint_finished_callback(self.service_response)
 
     def query_datapoint(
         self,
@@ -160,7 +163,7 @@ class ConbusDatapointService(ConbusProtocol):
         self.logger.info("Starting query_datapoint")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
+        self.datapoint_finished_callback = finish_callback
         self.serial_number = serial_number
         self.datapoint_type = datapoint_type
         self.start_reactor()

xp/services/conbus/conbus_discover_service.py

@@ -10,7 +10,10 @@ from typing import Callable, Optional
 from twisted.internet.posixbase import PosixReactorBase
 
 from xp.models import ConbusClientConfig, ConbusDiscoverResponse
+from xp.models.conbus.conbus_discover import DiscoveredDevice
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.module_type_code import MODULE_TYPE_REGISTRY
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
 from xp.services.protocol.conbus_protocol import ConbusProtocol
@@ -73,6 +76,7 @@ class ConbusDiscoverService(ConbusProtocol):
             self.discovered_device_result.received_telegrams = []
         self.discovered_device_result.received_telegrams.append(telegram_received.frame)
 
+        # Check for discovery response
         if (
             telegram_received.checksum_valid
             and telegram_received.telegram_type == TelegramType.REPLY.value
@@ -80,8 +84,30 @@ class ConbusDiscoverService(ConbusProtocol):
             and len(telegram_received.payload) == 15
         ):
             self.discovered_device(telegram_received.serial_number)
+
+        # Check for module type response (F02D07)
+        elif (
+            telegram_received.checksum_valid
+            and telegram_received.telegram_type == TelegramType.REPLY.value
+            and telegram_received.payload[11:17] == "F02D07"
+            and len(telegram_received.payload) >= 19
+        ):
+            self.handle_module_type_code_response(
+                telegram_received.serial_number, telegram_received.payload[17:19]
+            )
+        # Check for module type response (F02D00)
+        elif (
+            telegram_received.checksum_valid
+            and telegram_received.telegram_type == TelegramType.REPLY.value
+            and telegram_received.payload[11:17] == "F02D00"
+            and len(telegram_received.payload) >= 19
+        ):
+            self.handle_module_type_response(
+                telegram_received.serial_number, telegram_received.payload[17:19]
+            )
+
         else:
-            self.logger.debug("Not a discover response")
+            self.logger.debug("Not a discover or module type response")
 
     def discovered_device(self, serial_number: str) -> None:
         """Handle discovered device event.
@@ -92,10 +118,102 @@ class ConbusDiscoverService(ConbusProtocol):
         self.logger.info("discovered_device: %s", serial_number)
         if not self.discovered_device_result.discovered_devices:
             self.discovered_device_result.discovered_devices = []
-        self.discovered_device_result.discovered_devices.append(serial_number)
+
+        # Add device with module_type as None initially
+        device: DiscoveredDevice = {
+            "serial_number": serial_number,
+            "module_type": None,
+            "module_type_code": None,
+            "module_type_name": None,
+        }
+        self.discovered_device_result.discovered_devices.append(device)
+
+        # Send READ_DATAPOINT telegram to query module type
+        self.logger.debug(f"Sending module type query for {serial_number}")
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_TYPE.value,
+        )
+
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_TYPE_CODE.value,
+        )
+
         if self.progress_callback:
             self.progress_callback(serial_number)
 
+    def handle_module_type_code_response(
+        self, serial_number: str, module_type_code: str
+    ) -> None:
+        """Handle module type code response and update discovered device.
+
+        Args:
+            serial_number: Serial number of the device.
+            module_type_code: Module type code from telegram (e.g., "07", "24").
+        """
+        self.logger.info(
+            f"Received module type code {module_type_code} for {serial_number}"
+        )
+
+        # Convert module type code to name
+        code = 0
+        try:
+            # The telegram format uses decimal values represented as strings
+            code = int(module_type_code)
+            module_info = MODULE_TYPE_REGISTRY.get(code)
+
+            if module_info:
+                module_type_name = module_info["name"]
+                self.logger.debug(
+                    f"Module type code {module_type_code} ({code}) = {module_type_name}"
+                )
+            else:
+                module_type_name = f"UNKNOWN_{module_type_code}"
+                self.logger.warning(
+                    f"Unknown module type code {module_type_code} ({code})"
+                )
+
+        except ValueError:
+            self.logger.error(
+                f"Invalid module type code format: {module_type_code} for {serial_number}"
+            )
+            module_type_name = f"INVALID_{module_type_code}"
+
+        # Find and update the device in discovered_devices
+        if self.discovered_device_result.discovered_devices:
+            for device in self.discovered_device_result.discovered_devices:
+                if device["serial_number"] == serial_number:
+                    device["module_type_code"] = code
+                    device["module_type_name"] = module_type_name
+                    self.logger.debug(
+                        f"Updated device {serial_number} with module_type {module_type_name}"
+                    )
+                    break
+
+    def handle_module_type_response(self, serial_number: str, module_type: str) -> None:
+        """Handle module type response and update discovered device.
+
+        Args:
+            serial_number: Serial number of the device.
+            module_type: Module type code from telegram (e.g., "XP33", "XP24").
+        """
+        self.logger.info(f"Received module type {module_type} for {serial_number}")
+
+        # Find and update the device in discovered_devices
+        if self.discovered_device_result.discovered_devices:
+            for device in self.discovered_device_result.discovered_devices:
+                if device["serial_number"] == serial_number:
+                    device["module_type"] = module_type
+                    self.logger.debug(
+                        f"Updated device {serial_number} with module_type {module_type}"
+                    )
+                    break
+
     def timeout(self) -> bool:
         """Handle timeout event to stop discovery.
 

xp/services/conbus/conbus_scan_service.py

@@ -128,7 +128,7 @@ class ConbusScanService(ConbusProtocol):
         function_code: str,
         progress_callback: Callable[[str], None],
         finish_callback: Callable[[ConbusResponse], None],
-        timeout_seconds: Optional[float] = None,
+        timeout_seconds: float = 0.25,
     ) -> None:
         """Scan a module for all datapoints by function code.
 

xp/services/conbus/{conbus_linknumber_set_service.py → write_config_service.py}

@@ -10,7 +10,7 @@ from typing import Callable, Optional
 from twisted.internet.posixbase import PosixReactorBase
 
 from xp.models import ConbusClientConfig
-from xp.models.conbus.conbus_linknumber import ConbusLinknumberResponse
+from xp.models.conbus.conbus_writeconfig import ConbusWriteConfigResponse
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.system_function import SystemFunction
@@ -19,11 +19,11 @@ from xp.services.protocol import ConbusProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ConbusLinknumberSetService(ConbusProtocol):
+class WriteConfigService(ConbusProtocol):
     """
-    Service for setting module link numbers via Conbus telegrams.
+    Service for writing module settings via Conbus telegrams.
 
-    Handles link number assignment by sending F04D04 telegrams and processing
+    Handles setting assignment by sending F04DXX telegrams and processing
     ACK/NAK responses from modules.
     """
 
@@ -42,13 +42,17 @@ class ConbusLinknumberSetService(ConbusProtocol):
         """
         super().__init__(cli_config, reactor)
         self.telegram_service = telegram_service
+        self.datapoint_type: Optional[DataPointType] = None
         self.serial_number: str = ""
-        self.link_number: int = 0
-        self.finish_callback: Optional[Callable[[ConbusLinknumberResponse], None]] = (
-            None
-        )
-        self.service_response: ConbusLinknumberResponse = ConbusLinknumberResponse(
-            success=False, serial_number=self.serial_number, result=""
+        self.data_value: str = ""
+        self.write_config_finished_callback: Optional[
+            Callable[[ConbusWriteConfigResponse], None]
+        ] = None
+        self.write_config_response: ConbusWriteConfigResponse = (
+            ConbusWriteConfigResponse(
+                success=False,
+                serial_number=self.serial_number,
+            )
         )
 
         # Set up logging
@@ -56,26 +60,30 @@ class ConbusLinknumberSetService(ConbusProtocol):
 
     def connection_established(self) -> None:
         """Handle connection established event."""
-        self.logger.debug(
-            f"Connection established, setting link number {self.link_number}."
-        )
+        self.logger.debug(f"Connection established, writing config {self.data_value}.")
 
         # Validate parameters before sending
         if not self.serial_number or len(self.serial_number) != 10:
             self.failed(f"Serial number must be 10 digits, got: {self.serial_number}")
             return
 
-        if not (0 <= self.link_number <= 99):
-            self.failed(f"Link number must be between 0-99, got: {self.link_number}")
+        if len(self.data_value) < 2:
+            self.failed(f"data_value must be at least 2 bytes, got: {self.data_value}")
+            return
+
+        if not self.datapoint_type:
+            self.failed(f"datapoint_type must be defined, got: {self.datapoint_type}")
             return
 
-        # Send F04D04{link_number} telegram
-        # F04 = WRITE_CONFIG, D04 = LINK_NUMBER datapoint type
+        # Send WRITE_CONFIG telegram
+        # Function F04 = WRITE_CONFIG,
+        # Datapoint = D datapoint_type
+        # Data = XX
         self.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
             system_function=SystemFunction.WRITE_CONFIG,
-            data_value=f"{DataPointType.LINK_NUMBER.value}{self.link_number:02d}",
+            data_value=f"{self.datapoint_type.value}{self.data_value}",
         )
 
     def telegram_sent(self, telegram_sent: str) -> None:
@@ -84,7 +92,7 @@ class ConbusLinknumberSetService(ConbusProtocol):
         Args:
             telegram_sent: The telegram that was sent.
         """
-        self.service_response.sent_telegram = telegram_sent
+        self.write_config_response.sent_telegram = telegram_sent
 
     def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
         """Handle telegram received event.
@@ -94,9 +102,9 @@ class ConbusLinknumberSetService(ConbusProtocol):
         """
         self.logger.debug(f"Telegram received: {telegram_received}")
 
-        if not self.service_response.received_telegrams:
-            self.service_response.received_telegrams = []
-        self.service_response.received_telegrams.append(telegram_received.frame)
+        if not self.write_config_response.received_telegrams:
+            self.write_config_response.received_telegrams = []
+        self.write_config_response.received_telegrams.append(telegram_received.frame)
 
         if (
             not telegram_received.checksum_valid
@@ -111,71 +119,75 @@ class ConbusLinknumberSetService(ConbusProtocol):
             telegram_received.frame
         )
 
-        if not reply_telegram:
-            self.logger.debug("Failed to parse reply telegram")
+        if not reply_telegram or reply_telegram.system_function not in (
+            SystemFunction.ACK,
+            SystemFunction.NAK,
+        ):
+            self.logger.debug("Not a write config reply")
             return
 
-        # Check for ACK or NAK response
-        if reply_telegram.system_function == SystemFunction.ACK:
-            self.logger.debug("Received ACK response")
-            self.succeed(SystemFunction.ACK)
-        elif reply_telegram.system_function == SystemFunction.NAK:
-            self.logger.debug("Received NAK response")
-            self.failed("Module responded with NAK")
-        else:
-            self.logger.debug(
-                f"Unexpected system function: {reply_telegram.system_function}"
-            )
+        succeed = (
+            True if reply_telegram.system_function == SystemFunction.ACK else False
+        )
+        self.finished(
+            succeed_or_failed=succeed, system_function=reply_telegram.system_function
+        )
 
-    def succeed(self, system_function: SystemFunction) -> None:
-        """Handle successful link number set operation.
+    def failed(self, message: str) -> None:
+        """Handle telegram failed event.
 
         Args:
-            system_function: The system function from the reply telegram.
+            message: The error message.
         """
-        self.logger.debug("Successfully set link number")
-        self.service_response.success = True
-        self.service_response.timestamp = datetime.now()
-        self.service_response.serial_number = self.serial_number
-        self.service_response.result = "ACK"
-        self.service_response.link_number = self.link_number
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        self.logger.debug("Failed to send telegram")
+        self.finished(succeed_or_failed=False, message=message)
 
-    def failed(self, message: str) -> None:
-        """Handle failed connection event.
+    def finished(
+        self,
+        succeed_or_failed: bool,
+        message: Optional[str] = None,
+        system_function: Optional[SystemFunction] = None,
+    ) -> None:
+        """Handle successful link number set operation.
 
         Args:
-            message: Failure message.
+            succeed_or_failed: succeed true, failed false.
+            message: error message if any.
+            system_function: The system function from the reply telegram.
         """
-        self.logger.debug(f"Failed with message: {message}")
-        self.service_response.success = False
-        self.service_response.timestamp = datetime.now()
-        self.service_response.serial_number = self.serial_number
-        self.service_response.result = "NAK"
-        self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
-
-    def set_linknumber(
+        self.logger.debug("finished writing config")
+        self.write_config_response.success = succeed_or_failed
+        self.write_config_response.error = message
+        self.write_config_response.timestamp = datetime.now()
+        self.write_config_response.serial_number = self.serial_number
+        self.write_config_response.system_function = system_function
+        self.write_config_response.datapoint_type = self.datapoint_type
+        self.write_config_response.data_value = self.data_value
+        if self.write_config_finished_callback:
+            self.write_config_finished_callback(self.write_config_response)
+
+    def write_config(
         self,
         serial_number: str,
-        link_number: int,
-        finish_callback: Callable[[ConbusLinknumberResponse], None],
+        datapoint_type: DataPointType,
+        data_value: str,
+        finish_callback: Callable[[ConbusWriteConfigResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
-        """Set the link number for a specific module.
+        """Write config to a specific module.
 
         Args:
             serial_number: 10-digit module serial number.
-            link_number: Link number to set (0-99).
+            datapoint_type: the datapoint type to write to.
+            data_value: the data to write.
             finish_callback: Callback function to call when operation completes.
             timeout_seconds: Optional timeout in seconds.
         """
-        self.logger.info("Starting set_linknumber")
+        self.logger.info("Starting write_config")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
         self.serial_number = serial_number
-        self.link_number = link_number
-        self.finish_callback = finish_callback
+        self.datapoint_type = datapoint_type
+        self.data_value = data_value
+        self.write_config_finished_callback = finish_callback
         self.start_reactor()

xp/services/protocol/telegram_protocol.py

@@ -124,7 +124,7 @@ class TelegramProtocol(protocol.Protocol):
             payload = telegram[:-2]  # S0123450001F02D12
             checksum = telegram[-2:].decode()  # FK
             serial_number = (
-                telegram[1:11] if telegram_type in "S" else b""
+                telegram[1:11] if telegram_type in ("S", "R") else b""
             )  # 0123450001
             calculated_checksum = calculate_checksum(payload.decode(encoding="latin-1"))
 
@@ -151,9 +151,9 @@ class TelegramProtocol(protocol.Protocol):
             await self.event_bus.dispatch(
                 TelegramReceivedEvent(
                     protocol=self,
-                    frame=frame.decode(),
-                    telegram=telegram.decode(),
-                    payload=payload.decode(),
+                    frame=frame.decode("latin-1"),
+                    telegram=telegram.decode("latin-1"),
+                    payload=payload.decode("latin-1"),
                     telegram_type=telegram_type,
                     serial_number=serial_number,
                     checksum=checksum,

xp/services/server/base_server_service.py

@@ -8,6 +8,7 @@ import logging
 from abc import ABC
 from typing import Optional
 
+from xp.models import ModuleTypeCode
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.system_telegram import SystemTelegram
@@ -33,7 +34,7 @@ class BaseServerService(ABC):
 
         # Must be set by subclasses
         self.device_type: str = ""
-        self.module_type_code: int = 0
+        self.module_type_code: ModuleTypeCode = ModuleTypeCode.NOMOD
         self.hardware_version: str = ""
         self.software_version: str = ""
         self.device_status: str = "OK"
@@ -54,11 +55,11 @@ class BaseServerService(ABC):
         """
         datapoint_values = {
             DataPointType.TEMPERATURE: self.temperature,
-            DataPointType.MODULE_TYPE_CODE: f"{self.module_type_code:02X}",
+            DataPointType.MODULE_TYPE_CODE: f"{self.module_type_code.value:02}",
             DataPointType.SW_VERSION: self.software_version,
             DataPointType.MODULE_STATE: self.device_status,
             DataPointType.MODULE_TYPE: self.device_type,
-            DataPointType.LINK_NUMBER: f"{self.link_number:02X}",
+            DataPointType.LINK_NUMBER: f"{self.link_number:02}",
             DataPointType.VOLTAGE: self.voltage,
             DataPointType.HW_VERSION: self.hardware_version,
             DataPointType.MODULE_ERROR_CODE: "00",
@@ -187,11 +188,15 @@ class BaseServerService(ABC):
         self.logger.debug(
             f"_handle_return_data_request {self.device_type} request: {request}"
         )
+        module_specific = self._handle_device_specific_data_request(request)
+        if module_specific:
+            return module_specific
+
         if request.datapoint_type:
             return self.generate_datapoint_type_response(request.datapoint_type)
 
         # Allow device-specific handlers
-        return self._handle_device_specific_data_request(request)
+        return None
 
     def _handle_device_specific_data_request(
         self, request: SystemTelegram

xp/services/server/cp20_server_service.py

@@ -6,6 +6,7 @@ including response generation and device configuration handling.
 
 from typing import Dict, Optional
 
+from xp.models import ModuleTypeCode
 from xp.models.telegram.system_telegram import SystemTelegram
 from xp.services.server.base_server_service import BaseServerService
 
@@ -32,7 +33,7 @@ class CP20ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "CP20"
-        self.module_type_code = 2  # CP20 module type from registry
+        self.module_type_code = ModuleTypeCode.CP20  # CP20 module type from registry
         self.firmware_version = "CP20_V0.01.05"
 
     def _handle_device_specific_data_request(

xp/services/server/server_service.py

@@ -253,15 +253,86 @@ class ServerService:
                 self.logger.error(f"Error closing client socket: {e}")
 
     def _process_request(self, message: str) -> List[str]:
-        """Process incoming request and generate responses."""
+        """Process incoming request and generate responses.
+
+        Args:
+            message: Message potentially containing multiple telegrams in format <TELEGRAM><TELEGRAM2>...
+
+        Returns:
+            List of responses for all processed telegrams.
+        """
+        responses: list[str] = []
+
+        try:
+            # Split message into individual telegrams (enclosed in angle brackets)
+            telegrams = self._split_telegrams(message)
+
+            if not telegrams:
+                self.logger.warning(f"No valid telegrams found in message: {message}")
+                return responses
+
+            # Process each telegram
+            for telegram in telegrams:
+                telegram_responses = self._process_single_telegram(telegram)
+                responses.extend(telegram_responses)
+
+        except Exception as e:
+            self.logger.error(f"Error processing request: {e}")
+
+        return responses
+
+    def _split_telegrams(self, message: str) -> List[str]:
+        """Split message into individual telegrams.
+
+        Args:
+            message: Raw message containing one or more telegrams in format <TELEGRAM><TELEGRAM2>...
+
+        Returns:
+            List of individual telegram strings including angle brackets.
+        """
+        telegrams = []
+        start = 0
+
+        while True:
+            # Find the start of a telegram
+            start_idx = message.find("<", start)
+            if start_idx == -1:
+                break
+
+            # Find the end of the telegram
+            end_idx = message.find(">", start_idx)
+            if end_idx == -1:
+                self.logger.warning(
+                    f"Incomplete telegram found starting at position {start_idx}"
+                )
+                break
+
+            # Extract telegram including angle brackets
+            telegram = message[start_idx : end_idx + 1]
+            telegrams.append(telegram)
+
+            # Move to the next position
+            start = end_idx + 1
+
+        return telegrams
+
+    def _process_single_telegram(self, telegram: str) -> List[str]:
+        """Process a single telegram and generate responses.
+
+        Args:
+            telegram: A single telegram string.
+
+        Returns:
+            List of response strings for this telegram.
+        """
         responses: list[str] = []
 
         try:
             # Parse the telegram
-            parsed_telegram = self.telegram_service.parse_system_telegram(message)
+            parsed_telegram = self.telegram_service.parse_system_telegram(telegram)
 
             if not parsed_telegram:
-                self.logger.warning(f"Failed to parse telegram: {message}")
+                self.logger.warning(f"Failed to parse telegram: {telegram}")
                 return responses
 
             # Handle discover requests
@@ -296,7 +367,7 @@ class ServerService:
                         )
 
         except Exception as e:
-            self.logger.error(f"Error processing request: {e}")
+            self.logger.error(f"Error processing telegram: {e}")
 
         return responses
 

xp/services/server/xp130_server_service.py

@@ -7,6 +7,7 @@ XP130 is an Ethernet/TCPIP interface module.
 
 from typing import Dict
 
+from xp.models import ModuleTypeCode
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -32,7 +33,7 @@ class XP130ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP130"
-        self.module_type_code = 13  # XP130 module type from registry
+        self.module_type_code = ModuleTypeCode.XP130  # XP130 module type from registry
         self.firmware_version = "XP130_V1.02.15"
 
         # XP130-specific network configuration

xp/services/server/xp20_server_service.py

@@ -6,6 +6,7 @@ including response generation and device configuration handling.
 
 from typing import Dict
 
+from xp.models import ModuleTypeCode
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -31,7 +32,7 @@ class XP20ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP20"
-        self.module_type_code = 33  # XP20 module type from registry
+        self.module_type_code = ModuleTypeCode.XP20  # XP20 module type from registry
         self.firmware_version = "XP20_V0.01.05"
 
     def get_device_info(self) -> Dict: