conson-xp 1.40.0__py3-none-any.whl → 1.43.0__py3-none-any.whl

{conson_xp-1.40.0.dist-info → conson_xp-1.43.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.40.0
+Version: 1.43.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -49,6 +49,7 @@ Requires-Dist: twisted>=25.5.0
 Requires-Dist: bubus>=1.5.6
 Requires-Dist: psygnal>=0.15.0
 Requires-Dist: textual>=1.0.0
+Requires-Dist: python-statemachine>=2.5.0
 Description-Content-Type: text/markdown
 
 # 🔌 XP Protocol Communication Tool
@@ -376,6 +377,7 @@ xp conbus msactiontable
 xp conbus msactiontable download
 xp conbus msactiontable list
 xp conbus msactiontable show
+xp conbus msactiontable upload
 
 
 xp conbus output

{conson_xp-1.40.0.dist-info → conson_xp-1.43.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
-conson_xp-1.40.0.dist-info/METADATA,sha256=FxnffMc3lu49w-4RKgg8x5f8wH3rl7rdjqCvr-BqhLI,11330
-conson_xp-1.40.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-conson_xp-1.40.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.40.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=J-7i4_8TyVn5z8NeO8OcuNsvrQlrsttTuKcPk6MvDMo,181
+conson_xp-1.43.0.dist-info/METADATA,sha256=UEKUuurqgD2CZtaFX4SC-svZfzBSrOhJ7T1Dqg-HTK4,11403
+conson_xp-1.43.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.43.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.43.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=af_iRTXOsyO7zIzqM-7iNsCptIKD9yYi2OXdX5aD458,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
 xp/cli/commands/conbus/__init__.py,sha256=HYaX2__XxwD3Xaw4CzflvL8CwoUa4yR6wOyH8wwyofM,535
 xp/cli/commands/conbus/conbus.py,sha256=1j9-Nwnf6nqD4ztBZnZEbJOTlkYo4D-Ks2J7BGNF3MU,3575
-xp/cli/commands/conbus/conbus_actiontable_commands.py,sha256=fIEe45iMWZ3Dbr0STzO8qbtWHR-R8qpGa_sLNeBm_og,7471
+xp/cli/commands/conbus/conbus_actiontable_commands.py,sha256=yLVSADwei7tX6JFa25TCpTxyMHyNJfWlDFqpR8AGRmo,7657
 xp/cli/commands/conbus/conbus_autoreport_commands.py,sha256=TgXFVpoyFNiEatL6r78IghzyF0R2S3cgTrGZaiJPjwA,3934
 xp/cli/commands/conbus/conbus_blink_commands.py,sha256=HRn4Lr_BO7_WynsaUnO_hKezOi3MVhkPYEOnh0rMMlg,5324
 xp/cli/commands/conbus/conbus_config_commands.py,sha256=BugIbgNX6_s4MySGvI6tWZkwguciajHUX2Xz8XBux7k,716
@@ -20,7 +20,7 @@ xp/cli/commands/conbus/conbus_export_commands.py,sha256=KSeXZbD6tO0_BMgqmg20iVaE
 xp/cli/commands/conbus/conbus_lightlevel_commands.py,sha256=AQhVneN5_rH6wd7D4KW80XIMh9MGjJv85gN57S206j4,7036
 xp/cli/commands/conbus/conbus_linknumber_commands.py,sha256=hVr1g6nDTa4MezW8joHPjPuZcMp2ttd9PfZaT9sQED4,3528
 xp/cli/commands/conbus/conbus_modulenumber_commands.py,sha256=FjFWnLU_aUoAXQ2tKKLC-ichNiIb90_9OWpSdIUyHvc,3600
-xp/cli/commands/conbus/conbus_msactiontable_commands.py,sha256=9JNZRemAgUUaNkKPzDUgIY5jnv-hCK8-bM5XjLYUIjc,7808
+xp/cli/commands/conbus/conbus_msactiontable_commands.py,sha256=2M4abf8i51HwLF3wmUAgoCN-veXKMA8Fd0nWThyNPdg,9706
 xp/cli/commands/conbus/conbus_output_commands.py,sha256=rJx8pfsl_ZeCNXhEelsY7mfYnaj_DHdz4TC-e8d5QGs,5286
 xp/cli/commands/conbus/conbus_raw_commands.py,sha256=892-S6wxp5xNPz6K86Le8KtQXNO4a0PQv20Hzx3vhiA,1996
 xp/cli/commands/conbus/conbus_receive_commands.py,sha256=_PsC-3xidmJBuOWUS60iDzhSHYYn5ZFmORXap-ljVGM,1902
@@ -59,7 +59,7 @@ xp/models/__init__.py,sha256=lROqr559DGd8WpJJUtfPT95VERCwMZHpBDEc96QSxQ0,1312
 xp/models/actiontable/__init__.py,sha256=6kVq1rTOlpc24sZxGGVWkY48tqR42YWHLQHqakWqlPc,43
 xp/models/actiontable/actiontable.py,sha256=bIeluZhMsvukkSwy2neaewavU8YR6Pso3PIvJ8ENlGg,1251
 xp/models/actiontable/msactiontable_xp20.py,sha256=zc9akPpuaW-pBk1vD9xn0JDWm_c2fiJYDuuk-DbvbGQ,5006
-xp/models/actiontable/msactiontable_xp24.py,sha256=ePuw5sAwmnUWZoti_uadvG1E-d7XGmucPm3WW2dQP0c,9415
+xp/models/actiontable/msactiontable_xp24.py,sha256=tpgYvlQwxhjo70Ucsg_rB9ox7-jlG2b-GBj-UXwP2Ic,9377
 xp/models/actiontable/msactiontable_xp33.py,sha256=p_0HrvUmnqEEUlle7n0vpspGXFPrO5pXZeVF7n9K19g,11781
 xp/models/conbus/__init__.py,sha256=VIusMWQdBtlwDgj7oSj06wQkklihTp4oWFShvP_JUgA,35
 xp/models/conbus/conbus.py,sha256=mZQzKPfrdttT-qUnYUSyrEYyc_eHs8z301E5ejeiyvk,2689
@@ -121,7 +121,7 @@ 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=C6cjNRRsl7_jjn94I6ycCDvoqIpivNv0cMVkR-CQBXk,7608
+xp/services/conbus/actiontable/actiontable_download_service.py,sha256=OD58pJyk-ij26a_ISc4OoK4X7rVj7rKwanV2wYVhsQY,18670
 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
@@ -142,6 +142,7 @@ xp/services/conbus/msactiontable/__init__.py,sha256=rDYzumPSfcTjDADHxjE7bXQoeWtZ
 xp/services/conbus/msactiontable/msactiontable_download_service.py,sha256=YAQeUAO04VkRTEvWwXBD_b6tdVjDYk55K4pZd7lxfE8,10049
 xp/services/conbus/msactiontable/msactiontable_list_service.py,sha256=bTqUI2xs3Ie0MeZ_PYm-Bgx9A-Eewlpc8Tv6jhi1_kA,3127
 xp/services/conbus/msactiontable/msactiontable_show_service.py,sha256=pyoB5xN1bDh0E8kity4k0UnYpc7-YWhs8oIMvAeC9Xk,3023
+xp/services/conbus/msactiontable/msactiontable_upload_service.py,sha256=D_sWGFlABVCBxzqt-6y8eB--ZpywS5MjC6ER-JESq74,12336
 xp/services/conbus/write_config_service.py,sha256=PQsN7rtTKHpwtAG8moLksUfRVqqE_0sxdE37meR1ZQ0,8935
 xp/services/homekit/__init__.py,sha256=xAMKmln_AmEFdOOJGKWYi96seRlKDQpKx3-hm7XbdIo,36
 xp/services/homekit/homekit_cache_service.py,sha256=NdijyH5_iyhsTHBb-OyT8Y2xnNDj8F5MP8neoVQ26hY,11010
@@ -160,7 +161,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=PpSr5sWcibN_xb2iMWAtWc0dTkUkFZelgYuPiejutkE,15155
+xp/services/protocol/conbus_event_protocol.py,sha256=XjdVwy7P87Utu_UqK7upfugrA5fYG2iWBwC4go9KFLY,15498
 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
@@ -170,7 +171,7 @@ xp/services/server/base_server_service.py,sha256=B-ntxp3swbwuri-9_2EuvBDi-4Uo9AH
 xp/services/server/client_buffer_manager.py,sha256=1d_MqfzuUqBwaQUiC1n5K76WwSxrdngYAmNH7he6u3o,2235
 xp/services/server/cp20_server_service.py,sha256=SXdI6Jt400T9sLdw86ovEqKRGeV3nYVaHEA9Gcj6W2A,2041
 xp/services/server/device_service_factory.py,sha256=Y4TvSFALeq0zYzHfCwcbikSpmIyYbLcvm9756n5Jm7Q,3744
-xp/services/server/server_service.py,sha256=YAkn3rxNYnxs3E1Dpwtt3ZzymFXZHKEz8Nitim-Xewg,16300
+xp/services/server/server_service.py,sha256=2jMrL-Azn7KaqpgSI1ztBh0UD3JWom5ns33IkqMCDac,16302
 xp/services/server/xp130_server_service.py,sha256=YnvetDp72-QzkyDGB4qfZZIwFs03HuibUOz2zb9XR0c,2191
 xp/services/server/xp20_server_service.py,sha256=1wJ7A-bRkN9O5Spu3q3LNDW31mNtNF2eNMQ5E6O2ltA,2928
 xp/services/server/xp230_server_service.py,sha256=k9ftCY5tjLFP31mKVCspq283RVaPkGx-Yq61Urk8JLs,1815
@@ -200,10 +201,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=Z1vRSWr_dhmyNhD4dstJg-ZOlKVPPq_viGGNJ32GRNs,24584
+xp/utils/dependencies.py,sha256=zrvWx28N0f28JwRDRyqaf5Q9eV_yLwh9xDw9mYBUXEQ,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.40.0.dist-info/RECORD,,
+conson_xp-1.43.0.dist-info/RECORD,,

xp/__init__.py

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

xp/cli/commands/conbus/conbus_actiontable_commands.py

@@ -61,7 +61,7 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
         """
         click.echo(progress, nl=False)
 
-    def on_finish(
+    def on_actiontable_received(
         _actiontable: ActionTable,
         actiontable_dict: Dict[str, Any],
         actiontable_short: list[str],
@@ -79,6 +79,9 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
             "actiontable": actiontable_dict,
         }
         click.echo(json.dumps(output, indent=2, default=str))
+
+    def on_finish() -> None:
+        """Handle successful completion of action table download."""
         service.stop_reactor()
 
     def on_error(error: str) -> None:
@@ -93,6 +96,7 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
     with service:
         service.on_progress.connect(on_progress)
         service.on_finish.connect(on_finish)
+        service.on_actiontable_received.connect(on_actiontable_received)
         service.on_error.connect(on_error)
         service.start(serial_number=serial_number)
         service.start_reactor()

xp/cli/commands/conbus/conbus_msactiontable_commands.py

@@ -25,6 +25,9 @@ from xp.services.conbus.msactiontable.msactiontable_list_service import (
 from xp.services.conbus.msactiontable.msactiontable_show_service import (
     MsActionTableShowService,
 )
+from xp.services.conbus.msactiontable.msactiontable_upload_service import (
+    MsActionTableUploadService,
+)
 
 
 @conbus_msactiontable.command("download", short_help="Download MSActionTable")
@@ -206,6 +209,65 @@ def conbus_show_msactiontable(ctx: Context, serial_number: str) -> None:
         )
 
 
+@conbus_msactiontable.command("upload", short_help="Upload MSActionTable")
+@click.argument("serial_number", type=SERIAL)
+@click.argument("xpmoduletype", type=XP_MODULE_TYPE)
+@click.pass_context
+@connection_command()
+def conbus_upload_msactiontable(
+    ctx: Context, serial_number: str, xpmoduletype: str
+) -> None:
+    """Upload MS action table from conson.yml to XP module.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+        xpmoduletype: XP module type.
+    """
+    service: MsActionTableUploadService = (
+        ctx.obj.get("container").get_container().resolve(MsActionTableUploadService)
+    )
+
+    def on_progress(progress: str) -> None:
+        """Handle progress updates during MS action table upload.
+
+        Args:
+            progress: Progress message string.
+        """
+        click.echo(progress, nl=False)
+
+    def on_finish(success: bool) -> None:
+        """Handle successful completion of MS action table upload.
+
+        Args:
+            success: Whether upload was successful.
+        """
+        service.stop_reactor()
+        if success:
+            click.echo("\nMsactiontable uploaded successfully")
+
+    def on_error(error: str) -> None:
+        """Handle errors during MS action table upload.
+
+        Args:
+            error: Error message string.
+        """
+        service.stop_reactor()
+        click.echo(f"\nError: {error}")
+
+    click.echo(f"Uploading msactiontable to {serial_number}...")
+
+    with service:
+        service.on_progress.connect(on_progress)
+        service.on_error.connect(on_error)
+        service.on_finish.connect(on_finish)
+        service.start(
+            serial_number=serial_number,
+            xpmoduletype=xpmoduletype,
+        )
+        service.start_reactor()
+
+
 def _format_yaml(data: dict, indent: int = 0) -> str:
     """Format a dictionary as YAML-like output.
 

xp/models/actiontable/msactiontable_xp24.py

@@ -178,7 +178,7 @@ class Xp24MsActionTable(BaseModel):
             param_value = action.param.value
             action_parts.append(f"{short_code}:{param_value}")
 
-        result = f"XP24 {' '.join(action_parts)}"
+        result = " ".join(action_parts)
 
         # Add settings
         settings = (
@@ -212,14 +212,14 @@ class Xp24MsActionTable(BaseModel):
 
         # Parse action part
         tokens = action_part.split()
-        if len(tokens) != 5 or tokens[0] != "XP24":
+        if len(tokens) != 4:
             raise ValueError(
-                f"Invalid short format: expected 'XP24 <a1> <a2> <a3> <a4>', got '{action_part}'"
+                f"Invalid short format: expected '<a1> <a2> <a3> <a4>', got '{action_part}'"
             )
 
         # Parse input actions
         input_actions = []
-        for i, token in enumerate(tokens[1:5], 1):
+        for i, token in enumerate(tokens[0:4], 1):
             if ":" not in token:
                 raise ValueError(f"Invalid action format at position {i}: '{token}'")
 

xp/services/conbus/actiontable/actiontable_download_service.py

@@ -4,10 +4,13 @@ import logging
 from dataclasses import asdict
 from typing import Any, Dict, Optional
 
-from psygnal import Signal
+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
@@ -15,9 +18,11 @@ from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ActionTableDownloadService:
+class ActionTableDownloadService(StateMachine):
     """TCP client service for downloading action tables from Conbus modules.
 
+    Inherits from StateMachine - the service IS the state machine.
+
     Manages TCP socket connections, handles telegram generation and transmission,
     and processes server responses for action table downloads.
 
@@ -25,13 +30,74 @@ class ActionTableDownloadService:
         on_progress: Signal emitted with telegram frame when progress is made.
         on_error: Signal emitted with error message string when an error occurs.
         on_finish: Signal emitted with (ActionTable, Dict[str, Any], list[str]) when complete.
+        idle: Initial state, waiting for connection.
+        receiving: Listening for telegrams, filtering relevant responses.
+        resetting: Timeout occurred, preparing error status query.
+        waiting_ok: Sent error status query, awaiting ACK/NAK.
+        requesting: Ready to send download request.
+        waiting_data: Awaiting actiontable chunk or EOF.
+        receiving_chunk: Processing received actiontable data.
+        processing_eof: Received EOF, deserializing actiontable.
+        completed: Download finished successfully.
+        do_connect: Transition from idle to receiving.
+        do_timeout: Transition from receiving to resetting.
+        send_error_status: Transition from resetting to waiting_ok.
+        error_status_received: Transition from waiting_ok to receiving (retry).
+        no_error_status_received: Transition from waiting_ok to requesting or completed.
+        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.
+        receiving2: Second receiving state after EOF processing.
+        resetting2: Second resetting state for finalization phase.
+        waiting_ok2: Second waiting_ok state for finalization phase.
+        filter_telegram: Self-transition for filtering telegrams in receiving state.
+        filter_telegram2: Self-transition for filtering telegrams in receiving2 state.
+        do_timeout2: Timeout transition for finalization phase.
+        send_error_status2: Error status query transition for finalization phase.
+        error_status_received2: Error received transition for finalization phase.
+        no_error_status_received2: No error received transition to completed state.
     """
 
-    on_progress: Signal = Signal(str)
-    on_error: Signal = Signal(str)
-    on_finish: Signal = Signal(
-        ActionTable, Dict[str, Any], list[str]
-    )  # (ActionTable, Dict[str, Any], list[str])
+    # States (9 states as per spec)
+    idle = State(initial=True)
+    receiving = State()
+    resetting = State()
+    waiting_ok = State()
+
+    requesting = State()
+    waiting_data = State()
+    receiving_chunk = State()
+    processing_eof = State()
+
+    receiving2 = State()
+    resetting2 = State()
+    waiting_ok2 = State()
+
+    completed = State(final=True)
+
+    # Phase 1: Connection & Initialization
+    do_connect = idle.to(receiving)
+    filter_telegram = receiving.to(receiving)  # Self-transition for filtering
+    do_timeout = receiving.to(resetting) | waiting_ok.to(receiving)
+    send_error_status = resetting.to(waiting_ok)
+    error_status_received = waiting_ok.to(receiving)
+    no_error_status_received = waiting_ok.to(requesting)
+
+    # Phase 2: Download
+    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)
+
+    # Phase 3: Finalization
+    do_finish = processing_eof.to(receiving2)
+    filter_telegram2 = receiving2.to(receiving2)  # Self-transition for filtering
+    do_timeout2 = receiving2.to(resetting2) | waiting_ok2.to(receiving2)
+    send_error_status2 = resetting2.to(waiting_ok2)
+    error_status_received2 = waiting_ok2.to(receiving2)
+    no_error_status_received2 = waiting_ok2.to(completed)
 
     def __init__(
         self,
@@ -51,29 +117,127 @@ class ActionTableDownloadService:
         self.telegram_service = telegram_service
         self.serial_number: str = ""
         self.actiontable_data: list[str] = []
-        # Set up logging
         self.logger = logging.getLogger(__name__)
 
+        # Signals (instance attributes to avoid conflict with statemachine)
+        self.on_progress: SignalInstance = SignalInstance((str,))
+        self.on_error: SignalInstance = SignalInstance((str,))
+        self.on_finish: SignalInstance = SignalInstance()
+        self.on_actiontable_received: SignalInstance = SignalInstance(
+            (ActionTable, Dict[str, Any], list[str])
+        )
+
         # Connect protocol signals
-        self.conbus_protocol.on_connection_made.connect(self.connection_made)
-        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
-        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
-        self.conbus_protocol.on_timeout.connect(self.timeout)
-        self.conbus_protocol.on_failed.connect(self.failed)
+        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_timeout.connect(self._on_timeout)
+        self.conbus_protocol.on_failed.connect(self._on_failed)
 
-    def connection_made(self) -> None:
-        """Handle connection established event."""
-        self.logger.debug(
-            "Connection established, sending download actiontable telegram"
+        # Initialize state machine
+        super().__init__(allow_event_without_transition=True)
+
+    # State machine lifecycle hooks
+
+    def on_enter_receiving(self) -> None:
+        """Enter receiving state - listening for telegrams."""
+        self.logger.debug("Entering RECEIVING state - waiting for telegrams")
+        self.conbus_protocol.wait()
+
+    def on_enter_receiving2(self) -> None:
+        """Enter receiving state - listening for telegrams."""
+        self.logger.debug("Entering RECEIVING2 state - waiting for telegrams")
+        self.conbus_protocol.wait()
+
+    def on_enter_resetting(self) -> None:
+        """Enter resetting state - query error status."""
+        self.logger.debug("Entering RESETTING state - querying error status")
+
+        # query_datapoint_module_error_code
+        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,
         )
+        self.send_error_status()
+
+    def on_enter_resetting2(self) -> None:
+        """Enter resetting state - query error status."""
+        self.logger.debug("Entering RESETTING2 state - querying error status")
+
+        # query_datapoint_module_error_code
+        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,
+        )
+        self.send_error_status2()
+
+    def on_enter_waiting_ok(self) -> None:
+        """Enter waiting_ok state - awaiting ERROR/NO_ERROR."""
+        self.logger.debug("Entering WAITING_OK state - awaiting ERROR/NO_ERROR")
+        self.conbus_protocol.wait()
+
+    def on_enter_waiting_ok2(self) -> None:
+        """Enter waiting_ok state - awaiting ERROR/NO_ERROR."""
+        self.logger.debug("Entering WAITING_OK state - awaiting ERROR/NO_ERROR")
+        self.conbus_protocol.wait()
+
+    def on_enter_requesting(self) -> None:
+        """Enter requesting state - send download request."""
+        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="00",
         )
+        self.send_download()
+
+    def on_enter_waiting_data(self) -> None:
+        """Enter waiting_data state - wait for actiontable chunks."""
+        self.logger.debug("Entering WAITING_DATA state - awaiting chunks")
+        self.conbus_protocol.wait()
 
-    def telegram_sent(self, telegram_sent: str) -> None:
+    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="00",
+        )
+        self.send_ack()
+
+    def on_enter_processing_eof(self) -> None:
+        """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)
+        actiontable_dict = asdict(actiontable)
+        actiontable_short = self.serializer.format_decoded_output(actiontable)
+        self.on_actiontable_received.emit(
+            actiontable, actiontable_dict, actiontable_short
+        )
+        self.do_finish()
+
+    def on_enter_completed(self) -> None:
+        """Enter completed state - download finished."""
+        self.logger.debug("Entering COMPLETED state - download finished")
+        self.on_finish.emit()
+
+    # Protocol event handlers
+
+    def _on_connection_made(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection made")
+        if self.idle.is_active:
+            self.do_connect()
+
+    def _on_telegram_sent(self, telegram_sent: str) -> None:
         """Handle telegram sent event.
 
         Args:
@@ -81,59 +245,148 @@ class ActionTableDownloadService:
         """
         self.logger.debug(f"Telegram sent: {telegram_sent}")
 
-    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+    def _on_read_datapoint_received(self, reply_telegram: ReplyTelegram) -> None:
+        """Handle READ_DATAPOINT response for error status check.
+
+        Args:
+            reply_telegram: The parsed reply telegram.
+        """
+        self.logger.debug(f"Received READ_DATAPOINT in {self.current_state}")
+
+        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 reply_telegram.data_value == "00":
+            if self.waiting_ok.is_active:
+                self.no_error_status_received()
+
+        if reply_telegram.data_value != "00":
+            if self.waiting_ok.is_active:
+                self.error_status_received()
+
+        if reply_telegram.data_value == "00":
+            if self.waiting_ok2.is_active:
+                self.no_error_status_received2()
+
+        if reply_telegram.data_value != "00":
+            if self.waiting_ok2.is_active:
+                self.error_status_received2()
+
+    def _on_ack_received(self, _reply_telegram: ReplyTelegram) -> None:
+        """Handle ACK telegram received.
+
+        Args:
+            _reply_telegram: The parsed reply telegram (unused).
+        """
+        self.logger.debug(f"Received ACK in {self.current_state}")
+        if self.waiting_ok.is_active:
+            self.ack_received()
+
+        if self.waiting_ok2.is_active:
+            self.ack_received2()
+
+    def _on_nack_received(self, _reply_telegram: ReplyTelegram) -> None:
+        """Handle NAK telegram received.
+
+        Args:
+            _reply_telegram: The parsed reply telegram (unused).
+        """
+        self.logger.debug(f"Received NAK in {self.current_state}")
+        if self.waiting_ok.is_active:
+            self.nak_received()
+
+    def _on_actiontable_chunk_received(self, reply_telegram: ReplyTelegram) -> None:
+        """Handle actiontable chunk telegram received.
+
+        Args:
+            reply_telegram: The parsed reply telegram containing chunk data.
+        """
+        self.logger.debug(f"Received actiontable chunk in {self.current_state}")
+        if self.waiting_data.is_active:
+            data_part = reply_telegram.data_value[2:]
+            self.actiontable_data.append(data_part)
+            self.on_progress.emit(".")
+            self.receive_chunk()
+
+    def _on_eof_received(self, _reply_telegram: ReplyTelegram) -> None:
+        """Handle EOF telegram received.
+
+        Args:
+            _reply_telegram: The parsed reply telegram (unused).
+        """
+        self.logger.debug(f"Received EOF in {self.current_state}")
+        if self.waiting_data.is_active:
+            self.receive_eof()
+
+    def _on_telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
         """Handle telegram received event.
 
         Args:
             telegram_received: The telegram received event.
         """
-        self.logger.debug(f"Telegram received: {telegram_received}")
-        if (
-            not telegram_received.checksum_valid
-            or telegram_received.telegram_type != TelegramType.REPLY.value
-            or telegram_received.serial_number != self.serial_number
-        ):
-            self.logger.debug("Not a reply response")
+        self.logger.debug(f"Received{telegram_received} in {self.current_state}")
+        if self.receiving.is_active:
+            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 not in (
-            SystemFunction.ACTIONTABLE,
-            SystemFunction.EOF,
-        ):
-            self.logger.debug("Not a actiontable response")
+
+        if reply_telegram.system_function == SystemFunction.READ_DATAPOINT:
+            self._on_read_datapoint_received(reply_telegram)
             return
 
-        if reply_telegram.system_function == SystemFunction.ACTIONTABLE:
-            self.logger.debug("Saving actiontable response")
-            data_part = reply_telegram.data_value[2:]
-            self.actiontable_data.append(data_part)
-            self.on_progress.emit(".")
+        if reply_telegram.system_function == SystemFunction.ACK:
+            self._on_ack_received(reply_telegram)
+            return
 
-            self.conbus_protocol.send_telegram(
-                telegram_type=TelegramType.SYSTEM,
-                serial_number=self.serial_number,
-                system_function=SystemFunction.ACK,
-                data_value="00",
-            )
+        if reply_telegram.system_function == SystemFunction.NAK:
+            self._on_nack_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:
-            all_data = "".join(self.actiontable_data)
-            # Deserialize from received data
-            actiontable = self.serializer.from_encoded_string(all_data)
-            actiontable_dict = asdict(actiontable)
-            actiontable_short = self.serializer.format_decoded_output(actiontable)
-            self.on_finish.emit(actiontable, actiontable_dict, actiontable_short)
-
-    def timeout(self) -> None:
+            self._on_eof_received(reply_telegram)
+            return
+
+    def _on_timeout(self) -> None:
         """Handle timeout event."""
         self.logger.debug("Timeout occurred")
-        self.failed("Timeout")
-
-    def failed(self, message: str) -> None:
+        if self.receiving.is_active:
+            self.do_timeout()  # receiving -> resetting
+        elif self.waiting_ok.is_active:
+            self.do_timeout()  # waiting_ok -> receiving
+        elif self.receiving2.is_active:
+            self.do_timeout2()  # receiving2 -> resetting2
+        elif self.waiting_ok2.is_active:
+            self.do_timeout2()  # waiting_ok2 -> receiving2
+        else:
+            self.logger.debug("Timeout in non-recoverable state")
+            self.on_error.emit("Timeout")
+
+    def _on_failed(self, message: str) -> None:
         """Handle failed connection event.
 
         Args:
@@ -142,10 +395,12 @@ class ActionTableDownloadService:
         self.logger.debug(f"Failed: {message}")
         self.on_error.emit(message)
 
+    # Public API
+
     def start(
         self,
         serial_number: str,
-        timeout_seconds: Optional[float] = None,
+        timeout_seconds: Optional[float] = 2.0,
     ) -> None:
         """Run reactor in dedicated thread with its own event loop.
 
@@ -153,11 +408,10 @@ class ActionTableDownloadService:
             serial_number: Module serial number.
             timeout_seconds: Optional timeout in seconds.
         """
-        self.logger.info("Starting actiontable")
+        self.logger.info("Starting actiontable download")
         self.serial_number = serial_number
         if timeout_seconds:
             self.conbus_protocol.timeout_seconds = timeout_seconds
-        # Caller invokes start_reactor()
 
     def set_timeout(self, timeout_seconds: float) -> None:
         """Set operation timeout.
@@ -183,18 +437,28 @@ class ActionTableDownloadService:
         """
         # Reset state for singleton reuse
         self.actiontable_data = []
+        self._download_complete = False
+        # Reset state machine to idle
+        self._reset_state()
         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
+        self._download_complete = False
+
     def __exit__(
         self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
     ) -> None:
         """Exit context manager and disconnect signals."""
         # Disconnect protocol signals
-        self.conbus_protocol.on_connection_made.disconnect(self.connection_made)
-        self.conbus_protocol.on_telegram_sent.disconnect(self.telegram_sent)
-        self.conbus_protocol.on_telegram_received.disconnect(self.telegram_received)
-        self.conbus_protocol.on_timeout.disconnect(self.timeout)
-        self.conbus_protocol.on_failed.disconnect(self.failed)
+        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_timeout.disconnect(self._on_timeout)
+        self.conbus_protocol.on_failed.disconnect(self._on_failed)
         # Disconnect service signals
         self.on_progress.disconnect()
         self.on_error.disconnect()

xp/services/conbus/msactiontable/msactiontable_upload_service.py

@@ -0,0 +1,324 @@
+"""Service for uploading MS action tables via Conbus protocol."""
+
+import logging
+from typing import Any, Optional, Union
+
+from psygnal import Signal
+
+from xp.models.config.conson_module_config import ConsonModuleListConfig
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.actiontable.msactiontable_xp20_serializer import (
+    Xp20MsActionTableSerializer,
+)
+from xp.services.actiontable.msactiontable_xp24_serializer import (
+    Xp24MsActionTableSerializer,
+)
+from xp.services.actiontable.msactiontable_xp33_serializer import (
+    Xp33MsActionTableSerializer,
+)
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class MsActionTableUploadError(Exception):
+    """Raised when MS action table upload operations fail."""
+
+    pass
+
+
+class MsActionTableUploadService:
+    """TCP client service for uploading MS action tables to Conbus modules.
+
+    Manages TCP socket connections, handles telegram generation and transmission,
+    and processes server responses for MS action table uploads.
+
+    Attributes:
+        on_progress: Signal emitted with telegram frame when progress is made.
+        on_error: Signal emitted with error message string when an error occurs.
+        on_finish: Signal emitted with bool (True on success) when upload completes.
+    """
+
+    on_progress: Signal = Signal(str)
+    on_error: Signal = Signal(str)
+    on_finish: Signal = Signal(bool)  # True on success
+
+    def __init__(
+        self,
+        conbus_protocol: ConbusEventProtocol,
+        xp20ms_serializer: Xp20MsActionTableSerializer,
+        xp24ms_serializer: Xp24MsActionTableSerializer,
+        xp33ms_serializer: Xp33MsActionTableSerializer,
+        telegram_service: TelegramService,
+        conson_config: ConsonModuleListConfig,
+    ) -> None:
+        """Initialize the MS action table upload service.
+
+        Args:
+            conbus_protocol: ConbusEventProtocol for communication.
+            xp20ms_serializer: XP20 MS action table serializer.
+            xp24ms_serializer: XP24 MS action table serializer.
+            xp33ms_serializer: XP33 MS action table serializer.
+            telegram_service: Telegram service for parsing.
+            conson_config: Conson module list configuration.
+        """
+        self.conbus_protocol = conbus_protocol
+        self.xp20ms_serializer = xp20ms_serializer
+        self.xp24ms_serializer = xp24ms_serializer
+        self.xp33ms_serializer = xp33ms_serializer
+        self.serializer: Union[
+            Xp20MsActionTableSerializer,
+            Xp24MsActionTableSerializer,
+            Xp33MsActionTableSerializer,
+        ] = xp20ms_serializer
+        self.telegram_service = telegram_service
+        self.conson_config = conson_config
+        self.serial_number: str = ""
+        self.xpmoduletype: str = ""
+
+        # Upload state
+        self.upload_data: str = ""
+        self.upload_initiated: bool = False
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+        # Connect protocol signals
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
+    def connection_made(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug(
+            "Connection established, sending upload msactiontable telegram"
+        )
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.UPLOAD_MSACTIONTABLE,
+            data_value="00",
+        )
+
+    def 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 telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
+        self.logger.debug(f"Telegram received: {telegram_received}")
+        if (
+            not telegram_received.checksum_valid
+            or telegram_received.telegram_type != TelegramType.REPLY.value
+            or telegram_received.serial_number != self.serial_number
+        ):
+            self.logger.debug("Not a reply response")
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        self._handle_upload_response(reply_telegram)
+
+    def _handle_upload_response(self, reply_telegram: Any) -> None:
+        """Handle telegram responses during upload.
+
+        Args:
+            reply_telegram: Parsed reply telegram.
+        """
+        if reply_telegram.system_function == SystemFunction.ACK:
+            self.logger.debug("Received ACK for upload")
+
+            if not self.upload_initiated:
+                # First ACK - send data chunk
+                self.logger.debug("Sending msactiontable data")
+                self.conbus_protocol.send_telegram(
+                    telegram_type=TelegramType.SYSTEM,
+                    serial_number=self.serial_number,
+                    system_function=SystemFunction.MSACTIONTABLE,
+                    data_value=self.upload_data,
+                )
+                self.upload_initiated = True
+                self.on_progress.emit(".")
+            else:
+                # Second ACK - send EOF
+                self.logger.debug("Data sent, sending EOF")
+                self.conbus_protocol.send_telegram(
+                    telegram_type=TelegramType.SYSTEM,
+                    serial_number=self.serial_number,
+                    system_function=SystemFunction.EOF,
+                    data_value="00",
+                )
+                self.on_finish.emit(True)
+        elif reply_telegram.system_function == SystemFunction.NAK:
+            self.logger.debug("Received NAK during upload")
+            self.failed("Upload failed: NAK received")
+        else:
+            self.logger.debug(f"Unexpected response during upload: {reply_telegram}")
+
+    def timeout(self) -> None:
+        """Handle timeout event."""
+        self.logger.debug("Upload timeout")
+        self.failed("Upload timeout")
+
+    def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.debug(f"Failed: {message}")
+        self.on_error.emit(message)
+
+    def start(
+        self,
+        serial_number: str,
+        xpmoduletype: str,
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Upload MS action table to module.
+
+        Uploads the MS action table configuration to the specified module.
+
+        Args:
+            serial_number: Module serial number.
+            xpmoduletype: XP module type (xp20, xp24, xp33).
+            timeout_seconds: Optional timeout in seconds.
+
+        Raises:
+            MsActionTableUploadError: If configuration or validation errors occur.
+        """
+        self.logger.info("Starting msactiontable upload")
+        self.serial_number = serial_number
+        self.xpmoduletype = xpmoduletype
+
+        # Select serializer based on module type
+        if xpmoduletype == "xp20":
+            self.serializer = self.xp20ms_serializer
+            config_field = "xp20_msaction_table"
+        elif xpmoduletype == "xp24":
+            self.serializer = self.xp24ms_serializer
+            config_field = "xp24_msaction_table"
+        elif xpmoduletype == "xp33":
+            self.serializer = self.xp33ms_serializer
+            config_field = "xp33_msaction_table"
+        else:
+            raise MsActionTableUploadError(f"Unsupported module type: {xpmoduletype}")
+
+        if timeout_seconds:
+            self.conbus_protocol.timeout_seconds = timeout_seconds
+
+        # Find module
+        module = self.conson_config.find_module(serial_number)
+        if not module:
+            self.failed(f"Module {serial_number} not found in conson.yml")
+            return
+
+        # Validate module type matches
+        if module.module_type.lower() != xpmoduletype.lower():
+            self.failed(
+                f"Module type mismatch: module has type {module.module_type}, "
+                f"but {xpmoduletype} was specified"
+            )
+            return
+
+        # Get msactiontable config for the module type
+        msactiontable_config = getattr(module, config_field, None)
+
+        if not msactiontable_config:
+            self.failed(
+                f"Module {serial_number} does not have {config_field} configured in conson.yml"
+            )
+            return
+
+        if not isinstance(msactiontable_config, list) or len(msactiontable_config) == 0:
+            self.failed(
+                f"Module {serial_number} has empty {config_field} list in conson.yml"
+            )
+            return
+
+        # Parse MS action table from short format (first element)
+        try:
+            short_format = msactiontable_config
+            msactiontable: Union[
+                "Xp20MsActionTable", "Xp24MsActionTable", "Xp33MsActionTable"
+            ]
+            if xpmoduletype == "xp20":
+                from xp.models.actiontable.msactiontable_xp20 import Xp20MsActionTable
+
+                msactiontable = Xp20MsActionTable.from_short_format(short_format)
+            elif xpmoduletype == "xp24":
+                from xp.models.actiontable.msactiontable_xp24 import Xp24MsActionTable
+
+                msactiontable = Xp24MsActionTable.from_short_format(short_format)
+            elif xpmoduletype == "xp33":
+                from xp.models.actiontable.msactiontable_xp33 import Xp33MsActionTable
+
+                msactiontable = Xp33MsActionTable.from_short_format(short_format)
+        except (ValueError, AttributeError) as e:
+            self.logger.error(f"Invalid msactiontable format: {e}")
+            self.failed(f"Invalid msactiontable format: {e}")
+            return
+
+        # Serialize to telegram data (68 characters: AAAA + 64 data chars)
+        self.upload_data = self.serializer.to_data(msactiontable)  # type: ignore[arg-type]
+
+        self.logger.debug(
+            f"Upload data encoded: {len(self.upload_data)} chars (single chunk)"
+        )
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Set operation timeout.
+
+        Args:
+            timeout_seconds: Timeout in seconds.
+        """
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "MsActionTableUploadService":
+        """Enter context manager - reset state for singleton reuse.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state
+        self.upload_data = ""
+        self.upload_initiated = False
+        self.serial_number = ""
+        self.xpmoduletype = ""
+        return self
+
+    def __exit__(self, _exc_type: Any, _exc_val: Any, _exc_tb: Any) -> None:
+        """Exit context manager - cleanup signals and reactor."""
+        # Disconnect protocol signals
+        self.conbus_protocol.on_connection_made.disconnect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.disconnect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.disconnect(self.telegram_received)
+        self.conbus_protocol.on_timeout.disconnect(self.timeout)
+        self.conbus_protocol.on_failed.disconnect(self.failed)
+        # Disconnect service signals
+        self.on_progress.disconnect()
+        self.on_error.disconnect()
+        self.on_finish.disconnect()
+        # Stop reactor
+        self.stop_reactor()

xp/services/protocol/conbus_event_protocol.py

@@ -103,6 +103,16 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         # Start inactivity timeout
         self._reset_timeout()
 
+    def wait(self, wait_timeout: Optional[float] = None) -> None:
+        """Wait for incoming telegrams with optional timeout override.
+
+        Args:
+            wait_timeout: Optional timeout in seconds to override default.
+        """
+        if wait_timeout:
+            self.timeout_seconds = wait_timeout
+        self._reset_timeout()
+
     def dataReceived(self, data: bytes) -> None:
         """Handle received data from TCP connection.
 

xp/services/server/server_service.py

@@ -337,7 +337,7 @@ class ServerService:
                 self.logger.warning(f"Failed to parse telegram: {telegram}")
                 return responses
 
-            self.client_buffers.broadcast(parsed_telegram.raw_telegram)
+            # self.client_buffers.broadcast(parsed_telegram.raw_telegram)
 
             # Handle discover requests
             if self.discover_service.is_discover_request(parsed_telegram):

xp/utils/dependencies.py

@@ -60,6 +60,9 @@ from xp.services.conbus.msactiontable.msactiontable_list_service import (
 from xp.services.conbus.msactiontable.msactiontable_show_service import (
     MsActionTableShowService,
 )
+from xp.services.conbus.msactiontable.msactiontable_upload_service import (
+    MsActionTableUploadService,
+)
 from xp.services.conbus.write_config_service import WriteConfigService
 from xp.services.homekit.homekit_cache_service import HomeKitCacheService
 from xp.services.homekit.homekit_conbus_service import HomeKitConbusService
@@ -381,6 +384,19 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            MsActionTableUploadService,
+            factory=lambda: MsActionTableUploadService(
+                conbus_protocol=self.container.resolve(ConbusEventProtocol),
+                xp20ms_serializer=self.container.resolve(Xp20MsActionTableSerializer),
+                xp24ms_serializer=self.container.resolve(Xp24MsActionTableSerializer),
+                xp33ms_serializer=self.container.resolve(Xp33MsActionTableSerializer),
+                telegram_service=self.container.resolve(TelegramService),
+                conson_config=self.container.resolve(ConsonModuleListConfig),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             ConbusCustomService,
             factory=lambda: ConbusCustomService(