conson-xp 1.45.0__py3-none-any.whl → 1.47.0__py3-none-any.whl

xp/services/protocol/conbus_event_protocol.py

@@ -1,4 +1,5 @@
-"""Conbus Event Protocol for XP telegram communication.
+"""
+Conbus Event Protocol for XP telegram communication.
 
 This module implements the Twisted protocol for Conbus communication.
 """
@@ -21,13 +22,21 @@ from xp.models import ConbusClientConfig, ModuleTypeCode
 from xp.models.protocol.conbus_protocol import (
     TelegramReceivedEvent,
 )
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.reply_telegram import ReplyTelegram
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
+from xp.services import TelegramService
 from xp.utils import calculate_checksum
 
+# Constants
+NO_ERROR_CODE = "00"
+CHUNK_HEADER_LENGTH = 2  # data_value format: 2-char counter + actiontable chunk
+
 
 class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
-    """Twisted protocol for XP telegram communication.
+    """
+    Twisted protocol for XP telegram communication.
 
     Attributes:
         buffer: Buffer for incoming telegram data.
@@ -47,6 +56,10 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         on_telegram_sent: Signal emitted when a telegram is sent.
         on_data_received: Signal emitted when data is received.
         on_telegram_received: Signal emitted when a telegram is received.
+        on_invalid_telegram_received: Signal emitted when invalid telegram received.
+        on_read_datapoint_received: Signal emitted when read datapoint reply received.
+        on_actiontable_chunk_received: Signal emitted when actiontable chunk received.
+        on_eof_received: Signal emitted when EOF telegram received.
         on_timeout: Signal emitted when timeout occurs.
         on_failed: Signal emitted when operation fails.
         on_start_reactor: Signal emitted when reactor starts.
@@ -68,6 +81,11 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
     on_telegram_sent: Signal = Signal(bytes)
     on_data_received: Signal = Signal(bytes)
     on_telegram_received: Signal = Signal(TelegramReceivedEvent)
+    on_invalid_telegram_received: Signal = Signal(TelegramReceivedEvent)
+    on_read_datapoint_received: Signal = Signal(ReplyTelegram)
+    on_actiontable_chunk_received: Signal = Signal(ReplyTelegram, str)
+    on_eof_received: Signal = Signal(ReplyTelegram)
+
     on_timeout: Signal = Signal()
     on_failed: Signal = Signal(str)
     on_start_reactor: Signal = Signal()
@@ -77,12 +95,15 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self,
         cli_config: ConbusClientConfig,
         reactor: PosixReactorBase,
+        telegram_service: TelegramService,
     ) -> None:
-        """Initialize ConbusProtocol.
+        """
+        Initialize ConbusProtocol.
 
         Args:
             cli_config: Configuration for Conbus client connection.
             reactor: Twisted reactor for event handling.
+            telegram_service: Telegram service for parsing telegrams.
         """
         self.buffer = b""
         self.logger = logging.getLogger(__name__)
@@ -90,12 +111,14 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self._reactor = reactor
         self.timeout_seconds = self.cli_config.timeout
         self.timeout_call: Optional[DelayedCall] = None
+        self.telegram_service = telegram_service
 
     def connectionMade(self) -> None:
-        """Handle connection established event.
+        """
+        Handle connection established event.
 
-        Called when TCP connection is successfully established.
-        Starts inactivity timeout monitoring.
+        Called when TCP connection is successfully established. Starts inactivity
+        timeout monitoring.
         """
         self.logger.debug("connectionMade")
         self.on_connection_made.emit()
@@ -104,7 +127,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self._reset_timeout()
 
     def wait(self, wait_timeout: Optional[float] = None) -> None:
-        """Wait for incoming telegrams with optional timeout override.
+        """
+        Wait for incoming telegrams with optional timeout override.
 
         Args:
             wait_timeout: Optional timeout in seconds to override default.
@@ -114,7 +138,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self._reset_timeout()
 
     def dataReceived(self, data: bytes) -> None:
-        """Handle received data from TCP connection.
+        """
+        Handle received data from TCP connection.
 
         Parses incoming telegram frames and dispatches events.
 
@@ -171,10 +196,51 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
                 checksum=checksum,
                 checksum_valid=checksum_valid,
             )
-            self.on_telegram_received.emit(telegram_received)
+            self.emit_telegram_received(telegram_received)
+
+    def emit_telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """
+        Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
+        self.logger.debug(f"Received {telegram_received}")
+        self.on_telegram_received.emit(telegram_received)
+
+        # Filter invalid telegrams
+        if not telegram_received.checksum_valid:
+            self.logger.debug("Filtered: invalid checksum")
+            self.on_invalid_telegram_received.emit(telegram_received)
+            return
+
+        if telegram_received.telegram_type != TelegramType.REPLY.value:
+            self.logger.debug(
+                f"Filtered: not a reply (got {telegram_received.telegram_type})"
+            )
+            self.on_invalid_telegram_received.emit(telegram_received)
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        if reply_telegram.system_function == SystemFunction.READ_DATAPOINT:
+            self.on_read_datapoint_received.emit(reply_telegram)
+            return
+
+        if reply_telegram.system_function == SystemFunction.ACTIONTABLE:
+            actiontable_chunk = reply_telegram.data_value[CHUNK_HEADER_LENGTH:]
+            self.on_actiontable_chunk_received.emit(reply_telegram, actiontable_chunk)
+            return
+
+        if reply_telegram.system_function == SystemFunction.EOF:
+            self.on_eof_received.emit(reply_telegram)
+            return
 
     def sendFrame(self, data: bytes) -> None:
-        """Send telegram frame.
+        """
+        Send telegram frame.
 
         Args:
             data: Raw telegram payload (without checksum/framing).
@@ -203,7 +269,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         system_function: SystemFunction,
         data_value: str,
     ) -> None:
-        """Send telegram with specified parameters.
+        """
+        Send telegram with specified parameters.
 
         Args:
             telegram_type: Type of telegram to send.
@@ -222,7 +289,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
     def send_event_telegram(
         self, module_type_code: ModuleTypeCode, link_number: int, input_number: int
     ) -> None:
-        """Send telegram with specified parameters.
+        """
+        Send telegram with specified parameters.
 
         Args:
             module_type_code: Type code of module.
@@ -235,7 +303,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self.send_raw_telegram(payload)
 
     def send_raw_telegram(self, payload: str) -> None:
-        """Send telegram with specified parameters.
+        """
+        Send telegram with specified parameters.
 
         Args:
             payload: Telegram to send.
@@ -243,6 +312,48 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self.telegram_queue.put_nowait(payload.encode())
         self.call_later(0.0, self.start_queue_manager)
 
+    def send_error_status_query(self, serial_number: str) -> None:
+        """
+        Send error status query telegram.
+
+        Args:
+            serial_number: Device serial number.
+        """
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_ERROR_CODE.value,
+        )
+
+    def send_download_request(self, serial_number: str) -> None:
+        """
+        Send download request telegram.
+
+        Args:
+            serial_number: Device serial number.
+        """
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.DOWNLOAD_ACTIONTABLE,
+            data_value=NO_ERROR_CODE,
+        )
+
+    def send_ack(self, serial_number: str) -> None:
+        """
+        Send ACK telegram.
+
+        Args:
+            serial_number: Device serial number.
+        """
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.ACK,
+            data_value=NO_ERROR_CODE,
+        )
+
     def call_later(
         self,
         delay: float,
@@ -250,7 +361,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         *args: object,
         **kw: object,
     ) -> DelayedCall:
-        """Schedule a callable to be called later.
+        """
+        Schedule a callable to be called later.
 
         Args:
             delay: Delay in seconds before calling.
@@ -264,7 +376,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         return self._reactor.callLater(delay, callable_action, *args, **kw)
 
     def buildProtocol(self, addr: IAddress) -> protocol.Protocol:
-        """Build protocol instance for connection.
+        """
+        Build protocol instance for connection.
 
         Args:
             addr: Address of the connection.
@@ -276,7 +389,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         return self
 
     def clientConnectionFailed(self, connector: IConnector, reason: Failure) -> None:
-        """Handle client connection failure.
+        """
+        Handle client connection failure.
 
         Args:
             connector: Connection connector instance.
@@ -288,7 +402,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self._cancel_timeout()
 
     def clientConnectionLost(self, connector: IConnector, reason: Failure) -> None:
-        """Handle client connection lost event.
+        """
+        Handle client connection lost event.
 
         Args:
             connector: Connection connector instance.
@@ -304,7 +419,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self.on_timeout.emit()
 
     def connection_failed(self, reason: Failure) -> None:
-        """Handle connection failure.
+        """
+        Handle connection failure.
 
         Args:
             reason: Failure reason details.
@@ -339,7 +455,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             self.logger.debug(f"Reactor stop failed (likely already stopped): {e}")
 
     def connect(self) -> None:
-        """Connect to TCP server.
+        """
+        Connect to TCP server.
 
         Automatically detects and integrates with running asyncio event loop if present.
         """
@@ -397,7 +514,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self.call_later(later, self.process_telegram_queue)
 
     def set_event_loop(self, event_loop: asyncio.AbstractEventLoop) -> None:
-        """Change the event loop.
+        """
+        Change the event loop.
 
         Args:
             event_loop: the event loop instance.
@@ -414,7 +532,8 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             self.logger.info("Set reactor to running state")
 
     def __enter__(self) -> "ConbusEventProtocol":
-        """Enter context manager.
+        """
+        Enter context manager.
 
         Returns:
             Self for context management.

xp/services/protocol/conbus_protocol.py

@@ -1,4 +1,5 @@
-"""Conbus Protocol for XP telegram communication.
+"""
+Conbus Protocol for XP telegram communication.
 
 This module implements the Twisted protocol for Conbus communication.
 """
@@ -22,7 +23,8 @@ from xp.utils import calculate_checksum
 
 
 class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
-    """Twisted protocol for XP telegram communication.
+    """
+    Twisted protocol for XP telegram communication.
 
     Attributes:
         buffer: Buffer for incoming telegram data.
@@ -40,7 +42,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         cli_config: ConbusClientConfig,
         reactor: PosixReactorBase,
     ) -> None:
-        """Initialize ConbusProtocol.
+        """
+        Initialize ConbusProtocol.
 
         Args:
             cli_config: Configuration for Conbus client connection.
@@ -54,10 +57,11 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self.timeout_call: Optional[DelayedCall] = None
 
     def connectionMade(self) -> None:
-        """Handle connection established event.
+        """
+        Handle connection established event.
 
-        Called when TCP connection is successfully established.
-        Starts inactivity timeout monitoring.
+        Called when TCP connection is successfully established. Starts inactivity
+        timeout monitoring.
         """
         self.logger.debug("connectionMade")
         self.connection_established()
@@ -65,7 +69,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self._reset_timeout()
 
     def dataReceived(self, data: bytes) -> None:
-        """Handle received data from TCP connection.
+        """
+        Handle received data from TCP connection.
 
         Parses incoming telegram frames and dispatches events.
 
@@ -124,7 +129,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
             self.telegram_received(telegram_received)
 
     def sendFrame(self, data: bytes) -> None:
-        """Send telegram frame.
+        """
+        Send telegram frame.
 
         Args:
             data: Raw telegram payload (without checksum/framing).
@@ -153,7 +159,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         system_function: SystemFunction,
         data_value: str,
     ) -> None:
-        """Send telegram with specified parameters.
+        """
+        Send telegram with specified parameters.
 
         Args:
             telegram_type: Type of telegram to send.
@@ -170,7 +177,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self.sendFrame(payload.encode())
 
     def buildProtocol(self, addr: IAddress) -> protocol.Protocol:
-        """Build protocol instance for connection.
+        """
+        Build protocol instance for connection.
 
         Args:
             addr: Address of the connection.
@@ -182,7 +190,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         return self
 
     def clientConnectionFailed(self, connector: IConnector, reason: Failure) -> None:
-        """Handle client connection failure.
+        """
+        Handle client connection failure.
 
         Args:
             connector: Connection connector instance.
@@ -194,7 +203,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self._stop_reactor()
 
     def clientConnectionLost(self, connector: IConnector, reason: Failure) -> None:
-        """Handle client connection lost event.
+        """
+        Handle client connection lost event.
 
         Args:
             connector: Connection connector instance.
@@ -206,7 +216,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self._stop_reactor()
 
     def timeout(self) -> bool:
-        """Handle timeout event.
+        """
+        Handle timeout event.
 
         Returns:
             True to continue waiting for next timeout, False to stop.
@@ -216,7 +227,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         return False
 
     def connection_failed(self, reason: Failure) -> None:
-        """Handle connection failure.
+        """
+        Handle connection failure.
 
         Args:
             reason: Failure reason details.
@@ -262,7 +274,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self.reactor.run()
 
     def __enter__(self) -> "ConbusProtocol":
-        """Enter context manager.
+        """
+        Enter context manager.
 
         Returns:
             Self for context management.
@@ -282,7 +295,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
     """Override methods."""
 
     def telegram_sent(self, telegram_sent: str) -> None:
-        """Override callback when telegram has been sent.
+        """
+        Override callback when telegram has been sent.
 
         Args:
             telegram_sent: The telegram that was sent.
@@ -290,7 +304,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         pass
 
     def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
-        """Override callback when telegram is received.
+        """
+        Override callback when telegram is received.
 
         Args:
             telegram_received: Event containing received telegram details.
@@ -302,7 +317,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         pass
 
     def connection_lost(self, reason: Failure) -> None:
-        """Override callback when connection is lost.
+        """
+        Override callback when connection is lost.
 
         Args:
             reason: Reason for connection loss.
@@ -310,7 +326,8 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         pass
 
     def failed(self, message: str) -> None:
-        """Override callback when connection failed.
+        """
+        Override callback when connection failed.
 
         Args:
             message: Error message describing the failure.

xp/services/protocol/protocol_factory.py

@@ -1,4 +1,5 @@
-"""Protocol Factory for Twisted protocol creation.
+"""
+Protocol Factory for Twisted protocol creation.
 
 This module provides factory classes for protocol instantiation.
 """
@@ -18,7 +19,8 @@ from xp.services.protocol import TelegramProtocol
 
 
 class TelegramFactory(protocol.ClientFactory):
-    """Factory for creating Telegram protocol instances.
+    """
+    Factory for creating Telegram protocol instances.
 
     Attributes:
         event_bus: Event bus for dispatching protocol events.
@@ -33,7 +35,8 @@ class TelegramFactory(protocol.ClientFactory):
         telegram_protocol: TelegramProtocol,
         connector: IConnector,
     ) -> None:
-        """Initialize TelegramFactory.
+        """
+        Initialize TelegramFactory.
 
         Args:
             event_bus: Event bus for protocol events.
@@ -46,7 +49,8 @@ class TelegramFactory(protocol.ClientFactory):
         self.logger = logging.getLogger(__name__)
 
     def buildProtocol(self, addr: IAddress) -> TelegramProtocol:
-        """Build protocol instance for connection.
+        """
+        Build protocol instance for connection.
 
         Args:
             addr: Address of the connection.
@@ -58,7 +62,8 @@ class TelegramFactory(protocol.ClientFactory):
         return self.telegram_protocol
 
     def clientConnectionFailed(self, connector: IConnector, reason: Failure) -> None:
-        """Handle connection failure event.
+        """
+        Handle connection failure event.
 
         Args:
             connector: Connection connector instance.
@@ -68,7 +73,8 @@ class TelegramFactory(protocol.ClientFactory):
         self.connector.stop()
 
     def clientConnectionLost(self, connector: IConnector, reason: Failure) -> None:
-        """Handle connection lost event.
+        """
+        Handle connection lost event.
 
         Args:
             connector: Connection connector instance.

xp/services/protocol/telegram_protocol.py

@@ -1,4 +1,5 @@
-"""Telegram Protocol for XP telegram communication.
+"""
+Telegram Protocol for XP telegram communication.
 
 This module provides the protocol implementation for telegram-based communication.
 """
@@ -20,7 +21,8 @@ from xp.utils import calculate_checksum
 
 
 class TelegramProtocol(protocol.Protocol):
-    """Twisted protocol for XP telegram communication with built-in debouncing.
+    """
+    Twisted protocol for XP telegram communication with built-in debouncing.
 
     Automatically deduplicates identical telegram frames sent within a
     configurable time window (default 50ms).
@@ -38,7 +40,8 @@ class TelegramProtocol(protocol.Protocol):
     event_bus: EventBus
 
     def __init__(self, event_bus: EventBus, debounce_ms: int = 50) -> None:
-        """Initialize TelegramProtocol.
+        """
+        Initialize TelegramProtocol.
 
         Args:
             event_bus: Event bus for dispatching protocol events.
@@ -64,7 +67,8 @@ class TelegramProtocol(protocol.Protocol):
             self.logger.error(f"Error scheduling async handler: {e}", exc_info=True)
 
     def _on_task_done(self, task: asyncio.Task) -> None:
-        """Handle async task completion.
+        """
+        Handle async task completion.
 
         Args:
             task: Completed async task.
@@ -92,7 +96,8 @@ class TelegramProtocol(protocol.Protocol):
             )
 
     def dataReceived(self, data: bytes) -> None:
-        """Handle received data from Twisted.
+        """
+        Handle received data from Twisted.
 
         Args:
             data: Raw bytes received from connection.
@@ -164,7 +169,8 @@ class TelegramProtocol(protocol.Protocol):
             )
 
     def sendFrame(self, data: bytes) -> None:
-        """Send telegram frame.
+        """
+        Send telegram frame.
 
         Args:
             data: Raw telegram payload (without checksum/framing).