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

{conson_xp-1.45.0.dist-info → conson_xp-1.46.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.45.0
+Version: 1.46.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

{conson_xp-1.45.0.dist-info → conson_xp-1.46.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-conson_xp-1.45.0.dist-info/METADATA,sha256=8Qep1pDdqK32SxNSde2KAPTqpcOrpelxhUfmuUNS528,11403
-conson_xp-1.45.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-conson_xp-1.45.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.45.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=alg3gEKtOcsjsOHoDtvjZ8hDNHys0SvRE-z83fLJdfg,181
+conson_xp-1.46.0.dist-info/METADATA,sha256=Xxip0IyUnxyoV7r0v9lNkFPQAlyokOY0YC5tkn62bnk,11403
+conson_xp-1.46.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.46.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.46.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=kG_WD81lVigZqxRFHU7VU0M0OecuS4eeAibhjoDk7qo,181
 xp/cli/__init__.py,sha256=QjnKB1KaI2aIyKlzrnvCwfbBuUj8HNgwNMvNJVQofbI,81
 xp/cli/__main__.py,sha256=l2iKwMdat5rTGd3JWs-uGksnYYDDffp_Npz05QdKEeU,117
 xp/cli/commands/__init__.py,sha256=G7A1KFRSV0CEeDTqr_khu-K9_sc01CTI2KSfkFcaBRM,4949
@@ -121,7 +121,8 @@ xp/services/actiontable/msactiontable_xp24_serializer.py,sha256=ku84HCCjYDM9XpRK
 xp/services/actiontable/msactiontable_xp33_serializer.py,sha256=MFjEwSsIa8l3RJt-ig828E6kyiFYYXMHFKe4Q0A3NvA,8781
 xp/services/conbus/__init__.py,sha256=Hi35sMKu9o6LpYoi2tQDaQoMb8M5sOt_-LUTxxaCU_0,28
 xp/services/conbus/actiontable/__init__.py,sha256=oD6vRk_Ye-eZ9s_hldAgtRJFu4mfAnODqpkJUGHHszk,40
-xp/services/conbus/actiontable/actiontable_download_service.py,sha256=RMGC3WxlMQDJkkXy3oKmqkORrXNwQyjDkyfEGWX3JJE,21294
+xp/services/conbus/actiontable/actiontable_download_service.py,sha256=SL7D4cUzCCwONVSddVQSOHmBHhIKaIyzP57xD7l7BUU,13350
+xp/services/conbus/actiontable/actiontable_download_state_machine.py,sha256=RVQJQp9wJf3TD6SalriPmf2dI1RfBUEqx5Y1GSBiCbE,9956
 xp/services/conbus/actiontable/actiontable_list_service.py,sha256=BYNpxdhdVvn5Z3XXvUYyiGGZ3fOoKR1F0boYDfAQ80c,2894
 xp/services/conbus/actiontable/actiontable_show_service.py,sha256=Z11bVYstnIhahFKTL8WqgTmK8rMK6kvismdy7679ojY,3013
 xp/services/conbus/actiontable/actiontable_upload_service.py,sha256=HTWJqJTIDFsp5v0SBx1Wt5gUeso6w03N6bKbtsbHtJY,9705
@@ -161,7 +162,7 @@ xp/services/homekit/homekit_service.py,sha256=0lW-hg40ETco3gDBEYkR_sX-UIYsLSKCD4
 xp/services/log_file_service.py,sha256=fvPcZQj8XOKUA-4ep5R8n0PelvwvRlTLlVxvIWM5KR4,10506
 xp/services/module_type_service.py,sha256=xWhr1EAZMykL5uNWHWdpa5T8yNruGKH43XRTOS8GwZg,7477
 xp/services/protocol/__init__.py,sha256=qRufBmqRKGzpuzZ5bxBbmwf510TT00Ke8s5HcWGnqRY,818
-xp/services/protocol/conbus_event_protocol.py,sha256=XjdVwy7P87Utu_UqK7upfugrA5fYG2iWBwC4go9KFLY,15498
+xp/services/protocol/conbus_event_protocol.py,sha256=keuT_ZWXkps0zdfXMycGAqHtfIX9FsLfd9jhiY3lHPY,19274
 xp/services/protocol/conbus_protocol.py,sha256=JO7yLkD_ohPT0ETjnAIx4CGpZyobf4LdbuozM_43btE,10276
 xp/services/protocol/protocol_factory.py,sha256=PmjN9AtW9sxNo3voqUiNgQA-pTvX1RW4XXFlHKfFr5Q,2470
 xp/services/protocol/telegram_protocol.py,sha256=Ki5DrXsKxiaqLcdP9WWUuhUI7cPu2DfwyZkh-Gv9Lb8,9496
@@ -201,10 +202,10 @@ xp/term/widgets/protocol_log.py,sha256=CJUpckWj7GC1kVqixDadteyGnI4aHyzd4kkH-pSbz
 xp/term/widgets/status_footer.py,sha256=bxrcqKzJ9V0aPSn_WwraVpJz7NxBUh3yIjA3fwv5nVA,3256
 xp/utils/__init__.py,sha256=_avMF_UOkfR3tNeDIPqQ5odmbq5raKkaq1rZ9Cn1CJs,332
 xp/utils/checksum.py,sha256=HDpiQxmdIedbCbZ4o_Box0i_Zig417BtCV_46ZyhiTk,1711
-xp/utils/dependencies.py,sha256=zrvWx28N0f28JwRDRyqaf5Q9eV_yLwh9xDw9mYBUXEQ,25379
+xp/utils/dependencies.py,sha256=gjwuVFm_1KY3WkSPrtlvpJHpuoVDLwrqMXevblr1ixY,25379
 xp/utils/event_helper.py,sha256=W-A_xmoXlpWZBbJH6qdaN50o3-XrwFsDgvAGMJDiAgo,1001
 xp/utils/logging.py,sha256=rZDXwlBrYK8A6MPq5StsMNpgsRowzJXM6fvROPwJdGM,3750
 xp/utils/serialization.py,sha256=RWHHk86feaB4ZP7rjE4qOWK0900yg2joUBDkP76gfOY,4618
 xp/utils/state_machine.py,sha256=Oe2sLwCh9z_vr1tF6X0ZRGTeuckRQAGzmef7xc9CNdc,2413
 xp/utils/time_utils.py,sha256=dEyViDlAG9GWU-J3D_YVa-sGma6yiyyMTgN4h2x3PY4,3781
-conson_xp-1.45.0.dist-info/RECORD,,
+conson_xp-1.46.0.dist-info/RECORD,,

xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.45.0"
+__version__ = "1.46.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

xp/services/conbus/actiontable/actiontable_download_service.py

@@ -2,103 +2,47 @@
 
 import logging
 from dataclasses import asdict
-from enum import Enum
 from typing import Any, Optional
 
 from psygnal import SignalInstance
-from statemachine import State, StateMachine
 
 from xp.models.actiontable.actiontable import ActionTable
 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.actiontable.actiontable_serializer import ActionTableSerializer
-from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
-from xp.services.telegram.telegram_service import TelegramService
+from xp.services.conbus.actiontable.actiontable_download_state_machine import (
+    MAX_ERROR_RETRIES,
+    ActionTableDownloadStateMachine,
+)
+from xp.services.protocol.conbus_event_protocol import (
+    NO_ERROR_CODE,
+    ConbusEventProtocol,
+)
 
-# Constants
-NO_ERROR_CODE = "00"
-CHUNK_HEADER_LENGTH = 2  # data_value format: 2-char counter + actiontable chunk
-MAX_ERROR_RETRIES = 3  # Max retries for error_status_received before giving up
 
-
-class Phase(Enum):
-    """Download workflow phases.
-
-    The download workflow consists of three sequential phases:
-    - INIT: Drain pending telegrams, query error status → proceed to DOWNLOAD
-    - DOWNLOAD: Request actiontable, receive chunks with ACK, until EOF
-    - CLEANUP: Drain pending telegrams, query error status → proceed to COMPLETED
-
-    Attributes:
-        INIT: Initial phase - drain pending telegrams and query error status.
-        DOWNLOAD: Download phase - request actiontable and receive chunks.
-        CLEANUP: Cleanup phase - drain remaining telegrams and verify status.
-    """
-
-    INIT = "init"
-    DOWNLOAD = "download"
-    CLEANUP = "cleanup"
-
-
-class ActionTableDownloadService(StateMachine):
+class ActionTableDownloadService(ActionTableDownloadStateMachine):
     """Service for downloading action tables from Conbus modules via TCP.
 
-    Inherits from StateMachine - the service IS the state machine. Uses guard
-    conditions to share states between INIT and CLEANUP phases.
-    see: Download-ActionTable-Workflow.dot
+    Inherits from ActionTableDownloadStateMachine and overrides on_enter_*
+    methods to add protocol-specific behavior.
 
-    States (9 total):
-        idle -> receiving -> resetting -> waiting_ok -> requesting
-             -> waiting_data <-> receiving_chunk -> processing_eof -> completed
-
-    Phases - INIT and CLEANUP share the same states (receiving, resetting, waiting_ok):
+    The workflow consists of three phases:
 
     INIT phase (drain → reset → wait_ok):
-        idle -> receiving -> resetting -> waiting_ok --(guard: is_init_phase)--> requesting
+        Connection established, drain pending telegrams, query error status.
 
     DOWNLOAD phase (request → receive chunks → EOF):
-        requesting -> waiting_data <-> receiving_chunk -> processing_eof
+        Request actiontable, receive and ACK chunks until EOF.
 
     CLEANUP phase (drain → reset → wait_ok):
-        processing_eof -> receiving -> resetting -> waiting_ok --(guard: is_cleanup_phase)--> completed
-
-    The drain/reset/wait_ok cycle:
-    1. Drain pending telegrams (receiving state discards telegram without reading them).
-       There may be a lot of telegram. We are listening and receiving until no more
-       telegram arrive and timeout occurs.
-    2. Timeout triggers error status query (resetting)
-    3. Wait for response (waiting_ok)
-    4. On no error: guard determines target (requesting or completed)
-       On error: retry from drain step
+        After EOF, drain remaining telegrams and verify final status.
 
     Attributes:
         on_progress: Signal emitted with "." for each chunk received.
         on_error: Signal emitted with error message string.
         on_actiontable_received: Signal emitted with (ActionTable, dict, list).
         on_finish: Signal emitted when download and cleanup completed.
-        idle: Initial state - waiting for connection.
-        receiving: Drain telegrams state (INIT or CLEANUP phase).
-        resetting: Query error status state.
-        waiting_ok: Await error status response state.
-        requesting: DOWNLOAD phase - send download request state.
-        waiting_data: DOWNLOAD phase - await chunks state.
-        receiving_chunk: DOWNLOAD phase - process chunk state.
-        processing_eof: DOWNLOAD phase - deserialize result state.
-        completed: Final state - download finished.
-        do_connect: Transition from idle to receiving.
-        filter_telegram: Self-transition in receiving to drain telegrams.
-        do_timeout: Transition on timeout events.
-        send_error_status: Transition from resetting to waiting_ok.
-        error_status_received: Transition when error status is received.
-        no_error_status_received: Transition when no error status received.
-        send_download: Transition from requesting to waiting_data.
-        receive_chunk: Transition from waiting_data to receiving_chunk.
-        send_ack: Transition from receiving_chunk to waiting_data.
-        receive_eof: Transition from waiting_data to processing_eof.
-        do_finish: Transition from processing_eof to receiving (cleanup).
 
     Example:
         >>> with download_service as service:
@@ -107,66 +51,24 @@ class ActionTableDownloadService(StateMachine):
         ...     service.start_reactor()
     """
 
-    # States - unified for INIT and CLEANUP phases using guards
-    idle = State(initial=True)
-    receiving = State()  # Drain telegrams (INIT or CLEANUP phase)
-    resetting = State()  # Query error status
-    waiting_ok = State()  # Await error status response
-
-    requesting = State()  # DOWNLOAD phase: send download request
-    waiting_data = State()  # DOWNLOAD phase: await chunks
-    receiving_chunk = State()  # DOWNLOAD phase: process chunk
-    processing_eof = State()  # DOWNLOAD phase: deserialize result
-
-    completed = State(final=True)
-
-    # Phase transitions - shared states with guards for phase-dependent routing
-    do_connect = idle.to(receiving)
-    filter_telegram = receiving.to(receiving)  # Self-transition: drain to /dev/null
-    do_timeout = receiving.to(resetting) | waiting_ok.to(receiving)
-    send_error_status = resetting.to(waiting_ok)
-    error_status_received = waiting_ok.to(
-        receiving, cond="can_retry"
-    )  # Retry if under limit
-
-    # Conditional transitions based on phase
-    no_error_status_received = waiting_ok.to(
-        requesting, cond="is_init_phase"
-    ) | waiting_ok.to(completed, cond="is_cleanup_phase")
-
-    # DOWNLOAD phase transitions
-    send_download = requesting.to(waiting_data)
-    receive_chunk = waiting_data.to(receiving_chunk)
-    send_ack = receiving_chunk.to(waiting_data)
-    receive_eof = waiting_data.to(processing_eof)
-
-    # Return to drain/reset cycle for CLEANUP phase
-    do_finish = processing_eof.to(receiving)
-
     def __init__(
         self,
         conbus_protocol: ConbusEventProtocol,
         actiontable_serializer: ActionTableSerializer,
-        telegram_service: TelegramService,
     ) -> None:
         """Initialize the action table download service.
 
         Args:
             conbus_protocol: ConbusEventProtocol instance.
             actiontable_serializer: Action table serializer.
-            telegram_service: Telegram service for parsing.
         """
         self.conbus_protocol = conbus_protocol
         self.serializer = actiontable_serializer
-        self.telegram_service = telegram_service
         self.serial_number: str = ""
         self.actiontable_data: list[str] = []
-        self.logger = logging.getLogger(__name__)
-        self._phase: Phase = Phase.INIT
-        self._error_retry_count: int = 0
         self._signals_connected: bool = False
 
-        # Signals (instance attributes to avoid conflict with statemachine)
+        # Service signals
         self.on_progress: SignalInstance = SignalInstance((str,))
         self.on_error: SignalInstance = SignalInstance((str,))
         self.on_finish: SignalInstance = SignalInstance()
@@ -174,74 +76,37 @@ class ActionTableDownloadService(StateMachine):
             (ActionTable, dict[str, Any], list[str])
         )
 
-        # Initialize state machine first (before connecting signals)
-        super().__init__(allow_event_without_transition=True)
+        # Initialize state machine (must be last - triggers introspection)
+        super().__init__()
+
+        # Override logger for service-specific logging
+        self.logger = logging.getLogger(__name__)
 
         # Connect protocol signals
         self._connect_signals()
 
-    # Guard conditions for phase-dependent transitions
-
-    def is_init_phase(self) -> bool:
-        """Guard: check if currently in INIT phase.
-
-        Returns:
-            True if in INIT phase, False otherwise.
-        """
-        return self._phase == Phase.INIT
-
-    def is_cleanup_phase(self) -> bool:
-        """Guard: check if currently in CLEANUP phase.
-
-        Returns:
-            True if in CLEANUP phase, False otherwise.
-        """
-        return self._phase == Phase.CLEANUP
-
-    def can_retry(self) -> bool:
-        """Guard: check if retry is allowed (under max limit).
-
-        Returns:
-            True if retry count is below MAX_ERROR_RETRIES, False otherwise.
-        """
-        return self._error_retry_count < MAX_ERROR_RETRIES
-
-    # State machine lifecycle hooks
-    # Note: receiving state is used to drain pending telegrams from the connection
-    # pipe. Any telegram received in this state is intentionally discarded (sent
-    # to /dev/null) to ensure a clean state before processing.
+    # Override state entry hooks with protocol behavior
 
     def on_enter_receiving(self) -> None:
-        """Enter receiving state - drain pending telegrams."""
-        self.logger.debug(f"Entering RECEIVING state (phase={self._phase.value})")
+        """Enter receiving state - wait for telegrams to drain."""
+        self.logger.debug(f"Entering RECEIVING state (phase={self.phase.value})")
         self.conbus_protocol.wait()
 
     def on_enter_resetting(self) -> None:
-        """Enter resetting state - query error status."""
-        self.logger.debug(f"Entering RESETTING state (phase={self._phase.value})")
-        self.conbus_protocol.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=self.serial_number,
-            system_function=SystemFunction.READ_DATAPOINT,
-            data_value=DataPointType.MODULE_ERROR_CODE.value,
-        )
+        """Enter resetting state - send error status query."""
+        self.logger.debug(f"Entering RESETTING state (phase={self.phase.value})")
+        self.conbus_protocol.send_error_status_query(serial_number=self.serial_number)
         self.send_error_status()
 
     def on_enter_waiting_ok(self) -> None:
-        """Enter waiting_ok state - awaiting error status response."""
-        self.logger.debug(f"Entering WAITING_OK state (phase={self._phase.value})")
+        """Enter waiting_ok state - wait for error status response."""
+        self.logger.debug(f"Entering WAITING_OK state (phase={self.phase.value})")
         self.conbus_protocol.wait()
 
     def on_enter_requesting(self) -> None:
         """Enter requesting state - send download request."""
-        self._phase = Phase.DOWNLOAD
-        self.logger.debug("Entering REQUESTING state - sending download request")
-        self.conbus_protocol.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=self.serial_number,
-            system_function=SystemFunction.DOWNLOAD_ACTIONTABLE,
-            data_value=NO_ERROR_CODE,
-        )
+        self.enter_download_phase()  # Sets phase to DOWNLOAD
+        self.conbus_protocol.send_download_request(serial_number=self.serial_number)
         self.send_download()
 
     def on_enter_waiting_data(self) -> None:
@@ -252,16 +117,11 @@ class ActionTableDownloadService(StateMachine):
     def on_enter_receiving_chunk(self) -> None:
         """Enter receiving_chunk state - send ACK."""
         self.logger.debug("Entering RECEIVING_CHUNK state - sending ACK")
-        self.conbus_protocol.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=self.serial_number,
-            system_function=SystemFunction.ACK,
-            data_value=NO_ERROR_CODE,
-        )
+        self.conbus_protocol.send_ack(serial_number=self.serial_number)
         self.send_ack()
 
     def on_enter_processing_eof(self) -> None:
-        """Enter processing_eof state - deserialize and emit result, then cleanup."""
+        """Enter processing_eof state - deserialize and emit result."""
         self.logger.debug("Entering PROCESSING_EOF state - deserializing")
         all_data = "".join(self.actiontable_data)
         actiontable = self.serializer.from_encoded_string(all_data)
@@ -270,15 +130,19 @@ class ActionTableDownloadService(StateMachine):
         self.on_actiontable_received.emit(
             actiontable, actiontable_dict, actiontable_short
         )
-        # Switch to CLEANUP phase before returning to receiving state
-        self._phase = Phase.CLEANUP
-        self.do_finish()
+        # Switch to CLEANUP phase
+        self.start_cleanup_phase()
 
     def on_enter_completed(self) -> None:
-        """Enter completed state - download finished."""
+        """Enter completed state - emit finish signal."""
         self.logger.debug("Entering COMPLETED state - download finished")
         self.on_finish.emit()
 
+    def on_max_retries_exceeded(self) -> None:
+        """Handle max retries exceeded - emit error signal."""
+        self.logger.error(f"Max error retries ({MAX_ERROR_RETRIES}) exceeded")
+        self.on_error.emit(f"Module error persists after {MAX_ERROR_RETRIES} retries")
+
     # Protocol event handlers
 
     def _on_connection_made(self) -> None:
@@ -287,14 +151,6 @@ class ActionTableDownloadService(StateMachine):
         if self.idle.is_active:
             self.do_connect()
 
-    def _on_telegram_sent(self, telegram_sent: str) -> None:
-        """Handle telegram sent event.
-
-        Args:
-            telegram_sent: The telegram that was sent.
-        """
-        self.logger.debug(f"Telegram sent: {telegram_sent}")
-
     def _on_read_datapoint_received(self, reply_telegram: ReplyTelegram) -> None:
         """Handle READ_DATAPOINT response for error status check.
 
@@ -302,11 +158,10 @@ class ActionTableDownloadService(StateMachine):
             reply_telegram: The parsed reply telegram.
         """
         self.logger.debug(f"Received READ_DATAPOINT in {self.current_state}")
+        if reply_telegram.serial_number != self.serial_number:
+            return
 
         if reply_telegram.datapoint_type != DataPointType.MODULE_ERROR_CODE:
-            self.logger.debug(
-                f"Filtered: not a MODULE_ERROR_CODE (got {reply_telegram.datapoint_type})"
-            )
             return
 
         if not self.waiting_ok.is_active:
@@ -314,44 +169,38 @@ class ActionTableDownloadService(StateMachine):
 
         is_no_error = reply_telegram.data_value == NO_ERROR_CODE
         if is_no_error:
-            self._error_retry_count = 0  # Reset on success
-            self.no_error_status_received()  # Guards determine target state
+            self.handle_no_error_received()
         else:
-            self._error_retry_count += 1
-            self.logger.debug(
-                f"Error status received, retry {self._error_retry_count}/{MAX_ERROR_RETRIES}"
-            )
-            # Guard can_retry blocks transition if max retries exceeded
-            self.error_status_received()
-            # Check if guard blocked the transition (still in waiting_ok)
-            if self.waiting_ok.is_active:
-                self.logger.error(
-                    f"Max error retries ({MAX_ERROR_RETRIES}) exceeded, giving up"
-                )
-                self.on_error.emit(
-                    f"Module error persists after {MAX_ERROR_RETRIES} retries"
-                )
-
-    def _on_actiontable_chunk_received(self, reply_telegram: ReplyTelegram) -> None:
+            self.handle_error_received()
+
+    def _on_actiontable_chunk_received(
+        self, reply_telegram: ReplyTelegram, actiontable_chunk: str
+    ) -> None:
         """Handle actiontable chunk telegram received.
 
         Args:
             reply_telegram: The parsed reply telegram containing chunk data.
+            actiontable_chunk: The chunk data.
         """
         self.logger.debug(f"Received actiontable chunk in {self.current_state}")
+        if reply_telegram.serial_number != self.serial_number:
+            return
+
         if self.waiting_data.is_active:
-            data_part = reply_telegram.data_value[CHUNK_HEADER_LENGTH:]
-            self.actiontable_data.append(data_part)
+            self.actiontable_data.append(actiontable_chunk)
             self.on_progress.emit(".")
             self.receive_chunk()
 
-    def _on_eof_received(self, _reply_telegram: ReplyTelegram) -> None:
+    def _on_eof_received(self, reply_telegram: ReplyTelegram) -> None:
         """Handle EOF telegram received.
 
         Args:
-            _reply_telegram: The parsed reply telegram (unused).
+            reply_telegram: The parsed reply telegram (unused).
         """
         self.logger.debug(f"Received EOF in {self.current_state}")
+        if reply_telegram.serial_number != self.serial_number:
+            return
+
         if self.waiting_data.is_active:
             self.receive_eof()
 
@@ -369,42 +218,9 @@ class ActionTableDownloadService(StateMachine):
             self.filter_telegram()
             return
 
-        # Filter invalid telegrams
-        if not telegram_received.checksum_valid:
-            self.logger.debug("Filtered: invalid checksum")
-            return
-
-        if telegram_received.telegram_type != TelegramType.REPLY.value:
-            self.logger.debug(
-                f"Filtered: not a reply (got {telegram_received.telegram_type})"
-            )
-            return
-
-        if telegram_received.serial_number != self.serial_number:
-            self.logger.debug(
-                f"Filtered: wrong serial {telegram_received.serial_number} != {self.serial_number}"
-            )
-            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(reply_telegram)
-            return
-
-        if reply_telegram.system_function == SystemFunction.ACTIONTABLE:
-            self._on_actiontable_chunk_received(reply_telegram)
-            return
-
-        if reply_telegram.system_function == SystemFunction.EOF:
-            self._on_eof_received(reply_telegram)
-            return
-
     def _on_timeout(self) -> None:
         """Handle timeout event."""
-        self.logger.debug(f"Timeout occurred (phase={self._phase.value})")
+        self.logger.debug(f"Timeout occurred (phase={self.phase.value})")
         if self.receiving.is_active:
             self.do_timeout()  # receiving -> resetting
         elif self.waiting_ok.is_active:
@@ -472,8 +288,14 @@ class ActionTableDownloadService(StateMachine):
         if self._signals_connected:
             return
         self.conbus_protocol.on_connection_made.connect(self._on_connection_made)
-        self.conbus_protocol.on_telegram_sent.connect(self._on_telegram_sent)
         self.conbus_protocol.on_telegram_received.connect(self._on_telegram_received)
+        self.conbus_protocol.on_read_datapoint_received.connect(
+            self._on_read_datapoint_received
+        )
+        self.conbus_protocol.on_actiontable_chunk_received.connect(
+            self._on_actiontable_chunk_received
+        )
+        self.conbus_protocol.on_eof_received.connect(self._on_eof_received)
         self.conbus_protocol.on_timeout.connect(self._on_timeout)
         self.conbus_protocol.on_failed.connect(self._on_failed)
         self._signals_connected = True
@@ -483,8 +305,14 @@ class ActionTableDownloadService(StateMachine):
         if not self._signals_connected:
             return
         self.conbus_protocol.on_connection_made.disconnect(self._on_connection_made)
-        self.conbus_protocol.on_telegram_sent.disconnect(self._on_telegram_sent)
         self.conbus_protocol.on_telegram_received.disconnect(self._on_telegram_received)
+        self.conbus_protocol.on_read_datapoint_received.disconnect(
+            self._on_read_datapoint_received
+        )
+        self.conbus_protocol.on_actiontable_chunk_received.disconnect(
+            self._on_actiontable_chunk_received
+        )
+        self.conbus_protocol.on_eof_received.disconnect(self._on_eof_received)
         self.conbus_protocol.on_timeout.disconnect(self._on_timeout)
         self.conbus_protocol.on_failed.disconnect(self._on_failed)
         self._signals_connected = False
@@ -497,20 +325,12 @@ class ActionTableDownloadService(StateMachine):
         """
         # Reset state for singleton reuse
         self.actiontable_data = []
-        self._phase = Phase.INIT
-        self._error_retry_count = 0
-        # Reset state machine to idle
-        self._reset_state()
+        # Reset state machine
+        self.reset()
         # Reconnect signals (in case previously disconnected)
         self._connect_signals()
         return self
 
-    def _reset_state(self) -> None:
-        """Reset state machine to initial state."""
-        # python-statemachine uses model.state to track current state
-        # Set it directly to the initial state id
-        self.model.state = self.idle.id
-
     def __exit__(
         self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
     ) -> None:

xp/services/conbus/actiontable/actiontable_download_state_machine.py

@@ -0,0 +1,276 @@
+"""State machine for ActionTable download workflow."""
+
+import logging
+from abc import ABCMeta, abstractmethod
+from enum import Enum
+
+from statemachine import State, StateMachine
+from statemachine.factory import StateMachineMetaclass
+
+
+class AbstractStateMachineMeta(StateMachineMetaclass, ABCMeta):
+    """Combined metaclass for abstract state machines.
+
+    Combines StateMachineMetaclass (for state machine introspection) with
+    ABCMeta (for abstract method enforcement).
+    """
+
+    pass
+
+
+# Constants
+MAX_ERROR_RETRIES = 3  # Max retries for error_status_received before giving up
+
+
+class Phase(Enum):
+    """Download workflow phases.
+
+    The download workflow consists of three sequential phases:
+    - INIT: Drain pending telegrams, query error status → proceed to DOWNLOAD
+    - DOWNLOAD: Request actiontable, receive chunks with ACK, until EOF
+    - CLEANUP: Drain pending telegrams, query error status → proceed to COMPLETED
+
+    Attributes:
+        INIT: Initial phase - drain pending telegrams and query error status.
+        DOWNLOAD: Download phase - request actiontable and receive chunks.
+        CLEANUP: Cleanup phase - drain remaining telegrams and verify status.
+    """
+
+    INIT = "init"
+    DOWNLOAD = "download"
+    CLEANUP = "cleanup"
+
+
+class ActionTableDownloadStateMachine(StateMachine, metaclass=AbstractStateMachineMeta):
+    """State machine for ActionTable download workflow.
+
+    Pure state machine with states, transitions, and guards. Subclasses can
+    override on_enter_* methods to add protocol-specific behavior.
+
+    States (9 total):
+        idle -> receiving -> resetting -> waiting_ok -> requesting
+             -> waiting_data <-> receiving_chunk -> processing_eof -> completed
+
+    Phases - INIT and CLEANUP share the same states (receiving, resetting, waiting_ok):
+
+    INIT phase (drain → reset → wait_ok):
+        idle -> receiving -> resetting -> waiting_ok --(guard: is_init_phase)--> requesting
+
+    DOWNLOAD phase (request → receive chunks → EOF):
+        requesting -> waiting_data <-> receiving_chunk -> processing_eof
+
+    CLEANUP phase (drain → reset → wait_ok):
+        processing_eof -> receiving -> resetting -> waiting_ok --(guard: is_cleanup_phase)--> completed
+
+    The drain/reset/wait_ok cycle:
+    1. Drain pending telegrams (receiving state discards telegrams)
+    2. Timeout triggers error status query (resetting)
+    3. Wait for response (waiting_ok)
+    4. On no error: guard determines target (requesting or completed)
+       On error: retry from drain step (limited by MAX_ERROR_RETRIES)
+
+    Attributes:
+        phase: Current workflow phase (INIT, DOWNLOAD, CLEANUP).
+        error_retry_count: Current error retry count.
+        idle: Initial state before connection.
+        receiving: Drain pending telegrams state (INIT or CLEANUP phase).
+        resetting: Query error status state.
+        waiting_ok: Await error status response state.
+        requesting: DOWNLOAD phase state - send download request.
+        waiting_data: DOWNLOAD phase state - await chunks.
+        receiving_chunk: DOWNLOAD phase state - process chunk.
+        processing_eof: DOWNLOAD phase state - deserialize result.
+        completed: Final state - download finished.
+        do_connect: Transition from idle to receiving.
+        filter_telegram: Self-transition in receiving state for draining.
+        do_timeout: Timeout transitions from receiving/waiting_ok.
+        send_error_status: Transition from resetting to waiting_ok.
+        error_status_received: Transition from waiting_ok to receiving on error.
+        no_error_status_received: Conditional transition based on phase.
+        send_download: Transition from requesting to waiting_data.
+        receive_chunk: Transition from waiting_data to receiving_chunk.
+        send_ack: Transition from receiving_chunk to waiting_data.
+        receive_eof: Transition from waiting_data to processing_eof.
+        do_finish: Transition from processing_eof to receiving.
+    """
+
+    # States - unified for INIT and CLEANUP phases using guards
+    idle = State(initial=True)
+    receiving = State()  # Drain telegrams (INIT or CLEANUP phase)
+    resetting = State()  # Query error status
+    waiting_ok = State()  # Await error status response
+
+    requesting = State()  # DOWNLOAD phase: send download request
+    waiting_data = State()  # DOWNLOAD phase: await chunks
+    receiving_chunk = State()  # DOWNLOAD phase: process chunk
+    processing_eof = State()  # DOWNLOAD phase: deserialize result
+
+    completed = State(final=True)
+
+    # Phase transitions - shared states with guards for phase-dependent routing
+    do_connect = idle.to(receiving)
+    filter_telegram = receiving.to(receiving)  # Self-transition: drain to /dev/null
+    do_timeout = receiving.to(resetting) | waiting_ok.to(receiving)
+    send_error_status = resetting.to(waiting_ok)
+    error_status_received = waiting_ok.to(
+        receiving, cond="can_retry"
+    )  # Retry if under limit
+
+    # Conditional transitions based on phase
+    no_error_status_received = waiting_ok.to(
+        requesting, cond="is_init_phase"
+    ) | waiting_ok.to(completed, cond="is_cleanup_phase")
+
+    # DOWNLOAD phase transitions
+    send_download = requesting.to(waiting_data)
+    receive_chunk = waiting_data.to(receiving_chunk)
+    send_ack = receiving_chunk.to(waiting_data)
+    receive_eof = waiting_data.to(processing_eof)
+
+    # Return to drain/reset cycle for CLEANUP phase
+    do_finish = processing_eof.to(receiving)
+
+    def __init__(self) -> None:
+        """Initialize the state machine."""
+        self.logger = logging.getLogger(__name__)
+        self._phase: Phase = Phase.INIT
+        self._error_retry_count: int = 0
+
+        # Initialize state machine
+        super().__init__(allow_event_without_transition=True)
+
+    @property
+    def phase(self) -> Phase:
+        """Get current phase."""
+        return self._phase
+
+    @phase.setter
+    def phase(self, value: Phase) -> None:
+        """Set current phase.
+
+        Args:
+            value: The phase value to set.
+        """
+        self._phase = value
+
+    @property
+    def error_retry_count(self) -> int:
+        """Get current error retry count."""
+        return self._error_retry_count
+
+    @error_retry_count.setter
+    def error_retry_count(self, value: int) -> None:
+        """Set error retry count.
+
+        Args:
+            value: The error retry count value to set.
+        """
+        self._error_retry_count = value
+
+    # Guard conditions for phase-dependent transitions
+
+    def is_init_phase(self) -> bool:
+        """Guard: check if currently in INIT phase.
+
+        Returns:
+            True if in INIT phase, False otherwise.
+        """
+        return self._phase == Phase.INIT
+
+    def is_cleanup_phase(self) -> bool:
+        """Guard: check if currently in CLEANUP phase.
+
+        Returns:
+            True if in CLEANUP phase, False otherwise.
+        """
+        return self._phase == Phase.CLEANUP
+
+    def can_retry(self) -> bool:
+        """Guard: check if retry is allowed (under max limit).
+
+        Returns:
+            True if retry count is under MAX_ERROR_RETRIES, False otherwise.
+        """
+        return self._error_retry_count < MAX_ERROR_RETRIES
+
+    # State entry hooks - subclasses MUST implement these
+
+    @abstractmethod
+    def on_enter_receiving(self) -> None:
+        """Enter receiving state - drain pending telegrams."""
+        ...
+
+    @abstractmethod
+    def on_enter_resetting(self) -> None:
+        """Enter resetting state - query error status."""
+        ...
+
+    @abstractmethod
+    def on_enter_waiting_ok(self) -> None:
+        """Enter waiting_ok state - awaiting error status response."""
+        ...
+
+    @abstractmethod
+    def on_enter_requesting(self) -> None:
+        """Enter requesting state - send download request."""
+        ...
+
+    @abstractmethod
+    def on_enter_waiting_data(self) -> None:
+        """Enter waiting_data state - wait for actiontable chunks."""
+        ...
+
+    @abstractmethod
+    def on_enter_receiving_chunk(self) -> None:
+        """Enter receiving_chunk state - send ACK."""
+        ...
+
+    @abstractmethod
+    def on_enter_processing_eof(self) -> None:
+        """Enter processing_eof state - deserialize and emit result."""
+        ...
+
+    @abstractmethod
+    def on_enter_completed(self) -> None:
+        """Enter completed state - download finished."""
+        ...
+
+    @abstractmethod
+    def on_max_retries_exceeded(self) -> None:
+        """Called when max error retries exceeded."""
+        ...
+
+    # Public methods for state machine control
+
+    def enter_download_phase(self) -> None:
+        """Enter requesting state - send download request."""
+        self._phase = Phase.DOWNLOAD
+
+    def handle_no_error_received(self) -> None:
+        """Handle successful error status check (no error)."""
+        self._error_retry_count = 0  # Reset on success
+        self.no_error_status_received()
+
+    def handle_error_received(self) -> None:
+        """Handle error status received - increment retry and attempt transition."""
+        self._error_retry_count += 1
+        self.logger.debug(
+            f"Error status received, retry {self._error_retry_count}/{MAX_ERROR_RETRIES}"
+        )
+        # Guard can_retry blocks transition if max retries exceeded
+        self.error_status_received()
+        # Check if guard blocked the transition (still in waiting_ok)
+        if self.waiting_ok.is_active:
+            self.on_max_retries_exceeded()
+
+    def start_cleanup_phase(self) -> None:
+        """Switch to CLEANUP phase and trigger do_finish transition."""
+        self._phase = Phase.CLEANUP
+        self.do_finish()
+
+    def reset(self) -> None:
+        """Reset state machine to initial state."""
+        self._phase = Phase.INIT
+        self._error_retry_count = 0
+        # python-statemachine uses model.state to track current state
+        self.model.state = self.idle.id

xp/services/protocol/conbus_event_protocol.py

@@ -21,10 +21,17 @@ 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.
@@ -47,6 +54,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 +79,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 +93,14 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         self,
         cli_config: ConbusClientConfig,
         reactor: PosixReactorBase,
+        telegram_service: TelegramService,
     ) -> None:
         """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,6 +108,7 @@ 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.
@@ -171,7 +190,46 @@ 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.
@@ -243,6 +301,45 @@ 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,

xp/utils/dependencies.py

@@ -207,6 +207,7 @@ class ServiceContainer:
             factory=lambda: ConbusEventProtocol(
                 cli_config=self.container.resolve(ConbusClientConfig),
                 reactor=self.container.resolve(PosixReactorBase),
+                telegram_service=self.container.resolve(TelegramService),
             ),
             scope=punq.Scope.singleton,
         )
@@ -326,7 +327,6 @@ class ServiceContainer:
             factory=lambda: ActionTableDownloadService(
                 conbus_protocol=self.container.resolve(ConbusEventProtocol),
                 actiontable_serializer=self.container.resolve(ActionTableSerializer),
-                telegram_service=self.container.resolve(TelegramService),
             ),
             scope=punq.Scope.singleton,
         )