conson-xp 1.39.0__py3-none-any.whl → 1.41.0__py3-none-any.whl

{conson_xp-1.39.0.dist-info → conson_xp-1.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.39.0
+Version: 1.41.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -376,6 +376,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.39.0.dist-info → conson_xp-1.41.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-conson_xp-1.39.0.dist-info/METADATA,sha256=ZnnTqw5hdtgrYNryR8of7kj7-8cD0Hy5GB4h_syNtok,11330
-conson_xp-1.39.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-conson_xp-1.39.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.39.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=XLd0Ey5N2BokGf5bKHhDEB2BpUIExFL_W41vN72w-Ko,181
+conson_xp-1.41.0.dist-info/METADATA,sha256=pML1FepvoeR1ktngrS69ieWa5rMO0j43m8BC22G_UW0,11361
+conson_xp-1.41.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.41.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.41.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=fIc-tmd56J8tWGwB8NrHfsUhz6rBuPHOZmnmWfimedo,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
@@ -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=Xs6TxwyzqMuUtvH1aQkQQToTR57Zzbs4IyeH28NKrtc,5616
+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
@@ -58,10 +58,9 @@ xp/cli/utils/xp_module_type.py,sha256=qSFJBRceqPi_cUFPxAWtLUNq37-KwUEjo9ekYOj7kL
 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.py,sha256=42RdQB3rUzAP_UeH5PS6iADOnkev47rDR77_yttSkBg,192
-xp/models/actiontable/msactiontable_xp20.py,sha256=iMNKrDpLcaynaG1pflfyoQjey-KUsoSjqy4J4XF-YGk,2031
-xp/models/actiontable/msactiontable_xp24.py,sha256=yYaWS7VRr2EyLXozfoJWLmgQmMU9dGo81V4VU4q6cUo,9464
-xp/models/actiontable/msactiontable_xp33.py,sha256=K1noQe5TNoTFLWE58r0-ZOB8lYM3oXFqoNL7z7Uob5A,2945
+xp/models/actiontable/msactiontable_xp20.py,sha256=zc9akPpuaW-pBk1vD9xn0JDWm_c2fiJYDuuk-DbvbGQ,5006
+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
 xp/models/conbus/conbus_autoreport.py,sha256=lKotDfxRBb7h2Z1d4qI3KhhLJhFDwKqLbSdG5Makm8Y,2289
@@ -82,7 +81,7 @@ xp/models/conbus/conbus_raw.py,sha256=xqvYao6IE1SXum7JBgZpSuWXm9x_QZquS9N_3_r0Hj
 xp/models/conbus/conbus_receive.py,sha256=-1u1qK-texfKCNZV-GYf_9KyLtJdIrx7HuZsKzu26Ow,1322
 xp/models/conbus/conbus_writeconfig.py,sha256=z8fdJeFLyGJW7UMHcHxGrHIMS6gG1D3aXeYUkBuwnEg,2136
 xp/models/config/__init__.py,sha256=gEZnX9eE3DjFtLtF32riEjJQLypqQRbyPauBI4Cowbs,36
-xp/models/config/conson_module_config.py,sha256=KL9AYVUiet50SaVajIjicW6FNQ38Qm1vk1jZbZnMb00,2708
+xp/models/config/conson_module_config.py,sha256=2uM1M4oKgQ3pkuEAEHHFMwZVGpWImJEe91TWgfS1ikU,2981
 xp/models/homekit/__init__.py,sha256=5HDSOClCu0ArK3IICn3_LDMMLBAzLjBxUUSF73bxSSk,34
 xp/models/homekit/homekit_accessory.py,sha256=NsHFhskuxIdJpF9-MvXHtjkLYvNHmSGFOy0GmQv3PY4,1038
 xp/models/homekit/homekit_config.py,sha256=Y_k92PsKHFBnn3r1_RSZHJP5uLH27Gw8G7Bj5N8jvUE,2904
@@ -117,9 +116,9 @@ xp/services/__init__.py,sha256=W9YZyrkh7vm--ZHhAXNQiOYQs5yhhmUHXP5I0Lf1XBg,782
 xp/services/actiontable/__init__.py,sha256=z6js4EuJ6xKHaseTEhuEvKo1tr9K1XyQiruReJtBiPY,26
 xp/services/actiontable/actiontable_serializer.py,sha256=U7bhd8lYMUJAsFydCt_Y5uOJoUODhSjRlUQPD6jsqMo,8517
 xp/services/actiontable/msactiontable_serializer.py,sha256=RRL6TZ1gpSQw81kAiw2BV3jTqm4fCJC0pWIcO26Cmos,174
-xp/services/actiontable/msactiontable_xp20_serializer.py,sha256=UP274qQfjFbAMojpeeqz72vJvNgAo_J5nyr4OFExsqE,6404
-xp/services/actiontable/msactiontable_xp24_serializer.py,sha256=kgEKT-GSlye4ExjeXIAB1O-qi0cAm6POxoC2bKlwBi0,4601
-xp/services/actiontable/msactiontable_xp33_serializer.py,sha256=XwBG-flfrSYxm0uy93gutZRj0LKGvOcJGnJpIFQQOuI,8747
+xp/services/actiontable/msactiontable_xp20_serializer.py,sha256=5e9L-xlFUSu2RJnhr0BQIbhIPZVRiOhp8kKvbWsU5BQ,6438
+xp/services/actiontable/msactiontable_xp24_serializer.py,sha256=ku84HCCjYDM9XpRKIWx1HnW1_U0LyFDH57f9Gig-pgQ,4607
+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
@@ -140,9 +139,10 @@ xp/services/conbus/conbus_raw_service.py,sha256=FmUaF9o2nFZVP8LpabKIwkg0P8coLCke
 xp/services/conbus/conbus_receive_service.py,sha256=7wOaEDrdoXwZE9MeUM89eB3hobYpvtbYk_YLv3MVAtc,5352
 xp/services/conbus/conbus_scan_service.py,sha256=QN7_x8BtNbHnqG7akcooAAcjz9Ex2y3VNDdhShKHUX8,6824
 xp/services/conbus/msactiontable/__init__.py,sha256=rDYzumPSfcTjDADHxjE7bXQoeWtZTDGaYzFTYdVl_9g,42
-xp/services/conbus/msactiontable/msactiontable_download_service.py,sha256=V3qa_DIPC2G2ihCNxPo0f17AY5v7mHQsZd9y3dOyekg,10077
-xp/services/conbus/msactiontable/msactiontable_list_service.py,sha256=9mAybvJLoZOzJSEV0QRh5iYY_j0ArbyZvFZa8y9rpWE,2886
+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
@@ -201,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.39.0.dist-info/RECORD,,
+conson_xp-1.41.0.dist-info/RECORD,,

xp/__init__.py

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

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")
@@ -55,29 +58,30 @@ def conbus_download_msactiontable(
         click.echo(progress, nl=False)
 
     def on_finish(
-        msaction_table: Union[
-            Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None
-        ],
-        msaction_table_short: str,
+        msaction_table: Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable],
+        msaction_table_short: list[str],
     ) -> None:
-        """Handle successful completion of MS action table download.
+        """Handle successful completion of XP24 MS action table download.
 
         Args:
-            msaction_table: Downloaded MS action table object or None if failed.
-            msaction_table_short: Short version of MS action table object or None if failed.
-
-        Raises:
-            Abort: If action table download failed.
+            msaction_table: Downloaded XP MS action table object.
+            msaction_table_short: Short version of XP24 MS action table.
         """
         service.stop_reactor()
-        if msaction_table is None:
-            click.echo("Error: Failed to download MS action table")
-            raise click.Abort()
+
+        # Format short representation based on module type
+        short_field_name = f"{xpmoduletype}_msaction_table"
+        # XP24 returns single-element list, XP20/XP33 return multi-line lists
+        short_value: Union[str, list[str]]
+        if len(msaction_table_short) == 1:
+            short_value = msaction_table_short[0]
+        else:
+            short_value = msaction_table_short
 
         output = {
             "serial_number": serial_number,
             "xpmoduletype": xpmoduletype,
-            "msaction_table_short": msaction_table_short,
+            short_field_name: short_value,
             "msaction_table": msaction_table.model_dump(),
         }
         click.echo(json.dumps(output, indent=2, default=str))
@@ -93,6 +97,8 @@ def conbus_download_msactiontable(
     with service:
         service.on_progress.connect(on_progress)
         service.on_error.connect(on_error)
+
+        # Connect to the appropriate signal based on module type
         service.on_finish.connect(on_finish)
         service.start(
             serial_number=serial_number,
@@ -155,9 +161,37 @@ def conbus_show_msactiontable(ctx: Context, serial_number: str) -> None:
         Args:
             module: Dictionary containing module configuration.
         """
+        click.echo(f"\nModule: {module.name} ({module.serial_number})")
+
+        # Display short format if action table exists
+        if module.xp33_msaction_table:
+            click.echo("Short:")
+            for line in module.xp33_msaction_table:
+                click.echo(f"  - {line}")
+        elif module.xp24_msaction_table:
+            click.echo("Short:")
+            for line in module.xp24_msaction_table:
+                click.echo(f"  - {line}")
+        elif module.xp20_msaction_table:
+            click.echo("Short:")
+            for line in module.xp20_msaction_table:
+                click.echo(f"  - {line}")
+
+        # Display full YAML format
+        click.echo("Full:")
         module_data = module.model_dump()
         module_data.pop("action_table", None)
-        click.echo(json.dumps(module_data, indent=2, default=str))
+
+        # Show the action table in YAML format
+        if module.xp33_msaction_table:
+            yaml_dict = {"xp33_msaction_table": module_data}
+            click.echo(_format_yaml(yaml_dict, indent=2))
+        elif module.xp24_msaction_table:
+            yaml_dict = {"xp24_msaction_table": module_data}
+            click.echo(_format_yaml(yaml_dict, indent=2))
+        elif module.xp20_msaction_table:
+            yaml_dict = {"xp20_msaction_table": module_data}
+            click.echo(_format_yaml(yaml_dict, indent=2))
 
     def error_callback(error: str) -> None:
         """Handle errors during action table show.
@@ -173,3 +207,88 @@ def conbus_show_msactiontable(ctx: Context, serial_number: str) -> None:
             finish_callback=on_finish,
             error_callback=error_callback,
         )
+
+
+@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.
+
+    Args:
+        data: Dictionary to format.
+        indent: Current indentation level.
+
+    Returns:
+        YAML-like formatted string.
+    """
+    lines: list[str] = []
+    for key, value in data.items():
+        if isinstance(value, dict):
+            lines.extend((f"{' ' * indent}{key}:", _format_yaml(value, indent + 2)))
+        elif isinstance(value, list):
+            lines.append(f"{' ' * indent}{key}:")
+            for item in value:
+                if isinstance(item, dict):
+                    lines.append(_format_yaml(item, indent + 2))
+                else:
+                    lines.append(f"{' ' * (indent + 2)}- {item}")
+        else:
+            lines.append(f"{' ' * indent}{key}: {value}")
+    return "\n".join(lines)

xp/models/actiontable/msactiontable_xp20.py

@@ -2,8 +2,6 @@
 
 from pydantic import BaseModel, Field
 
-from xp.models.actiontable.msactiontable import MsActionTable
-
 
 class InputChannel(BaseModel):
     """Configuration for a single input channel in XP20 action table.
@@ -25,7 +23,7 @@ class InputChannel(BaseModel):
     ta_function: bool = False
 
 
-class Xp20MsActionTable(MsActionTable):
+class Xp20MsActionTable(BaseModel):
     """XP20 Action Table for managing 8 input channels.
 
     Contains configuration for 8 input channels (input1 through input8),
@@ -51,3 +49,95 @@ class Xp20MsActionTable(MsActionTable):
     input6: InputChannel = Field(default_factory=InputChannel)
     input7: InputChannel = Field(default_factory=InputChannel)
     input8: InputChannel = Field(default_factory=InputChannel)
+
+    def to_short_format(self) -> list[str]:
+        """Convert action table to short format string.
+
+        Returns:
+            Short format string with each channel on a separate line.
+            Example:
+                CH1 I:0 S:0 G:0 AND:00000000 SA:0 TA:0
+                CH2 I:0 S:0 G:0 AND:00000000 SA:0 TA:0
+                ...
+        """
+        lines = []
+        for i in range(1, 9):
+            channel = getattr(self, f"input{i}")
+            # Convert and_functions list to binary string
+            and_bits = "".join("1" if bit else "0" for bit in channel.and_functions)
+            line = (
+                f"CH{i} "
+                f"I:{1 if channel.invert else 0} "
+                f"S:{1 if channel.short_long else 0} "
+                f"G:{1 if channel.group_on_off else 0} "
+                f"AND:{and_bits} "
+                f"SA:{1 if channel.sa_function else 0} "
+                f"TA:{1 if channel.ta_function else 0}"
+            )
+            lines.append(line)
+        return lines
+
+    @classmethod
+    def from_short_format(cls, short_str: list[str]) -> "Xp20MsActionTable":
+        """Parse short format string into action table.
+
+        Args:
+            short_str: Short format string with 8 channel lines.
+
+        Returns:
+            Xp20MsActionTable instance.
+
+        Raises:
+            ValueError: If format is invalid.
+        """
+        import re
+
+        if len(short_str) != 8:
+            raise ValueError(f"Expected 8 channel lines, got {len(short_str)}")
+
+        pattern = re.compile(
+            r"^CH([1-8]) I:([01]) S:([01]) G:([01]) AND:([01]{8}) SA:([01]) TA:([01])$"
+        )
+
+        channels = {}
+        for line in short_str:
+            line = line.strip()
+            match = pattern.match(line)
+            if not match:
+                raise ValueError(f"Invalid channel format: {line}")
+
+            ch_num = int(match.group(1))
+            invert = match.group(2) == "1"
+            short_long = match.group(3) == "1"
+            group_on_off = match.group(4) == "1"
+            and_bits = match.group(5)
+            sa_function = match.group(6) == "1"
+            ta_function = match.group(7) == "1"
+
+            # Convert binary string to list of bools
+            and_functions = [bit == "1" for bit in and_bits]
+
+            channels[ch_num] = InputChannel(
+                invert=invert,
+                short_long=short_long,
+                group_on_off=group_on_off,
+                and_functions=and_functions,
+                sa_function=sa_function,
+                ta_function=ta_function,
+            )
+
+        # Verify all channels are present
+        for i in range(1, 9):
+            if i not in channels:
+                raise ValueError(f"Missing channel {i}")
+
+        return cls(
+            input1=channels[1],
+            input2=channels[2],
+            input3=channels[3],
+            input4=channels[4],
+            input5=channels[5],
+            input6=channels[6],
+            input7=channels[7],
+            input8=channels[8],
+        )

xp/models/actiontable/msactiontable_xp24.py

@@ -4,7 +4,6 @@ from typing import Any, ClassVar, Union
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
-from xp.models.actiontable.msactiontable import MsActionTable
 from xp.models.telegram.input_action_type import InputActionType
 from xp.models.telegram.timeparam_type import TimeParam
 
@@ -82,7 +81,7 @@ class InputAction(BaseModel):
         raise ValueError(f"Invalid type for TimeParam: {type(v)}")
 
 
-class Xp24MsActionTable(MsActionTable):
+class Xp24MsActionTable(BaseModel):
     """XP24 Action Table for managing input actions and settings.
 
     Each input has an action type (TOGGLE, ON, LEVELSET, etc.)
@@ -159,7 +158,7 @@ class Xp24MsActionTable(MsActionTable):
     curtain34: bool = False  # Curtain setting for inputs 3-4
     mutual_deadtime: int = MS300  # Master timing (MS300=12 or MS500=20)
 
-    def to_short_format(self) -> str:
+    def to_short_format(self) -> list[str]:
         """Convert action table to short format string.
 
         Returns:
@@ -179,7 +178,7 @@ class Xp24MsActionTable(MsActionTable):
             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 = (
@@ -191,10 +190,10 @@ class Xp24MsActionTable(MsActionTable):
         )
         result = f"{result} | {settings}"
 
-        return result
+        return [result]
 
     @classmethod
-    def from_short_format(cls, short_str: str) -> "Xp24MsActionTable":
+    def from_short_format(cls, short_str: list[str]) -> "Xp24MsActionTable":
         """Parse short format string into action table.
 
         Args:
@@ -207,20 +206,20 @@ class Xp24MsActionTable(MsActionTable):
             ValueError: If format is invalid.
         """
         # Split by pipe to separate actions from settings
-        parts = short_str.split("|")
+        parts = short_str[0].split("|")
         action_part = parts[0].strip()
         settings_part = parts[1].strip()
 
         # 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/models/actiontable/msactiontable_xp33.py

@@ -4,7 +4,6 @@ from typing import Union
 
 from pydantic import BaseModel, Field, field_validator
 
-from xp.models.actiontable.msactiontable import MsActionTable
 from xp.models.telegram.timeparam_type import TimeParam
 
 
@@ -70,7 +69,7 @@ class Xp33Scene(BaseModel):
         raise ValueError(f"Invalid type for TimeParam: {type(v)}")
 
 
-class Xp33MsActionTable(MsActionTable):
+class Xp33MsActionTable(BaseModel):
     """XP33 Action Table for managing outputs and scenes.
 
     Attributes:
@@ -91,3 +90,271 @@ class Xp33MsActionTable(MsActionTable):
     scene2: Xp33Scene = Field(default_factory=Xp33Scene)
     scene3: Xp33Scene = Field(default_factory=Xp33Scene)
     scene4: Xp33Scene = Field(default_factory=Xp33Scene)
+
+    def to_short_format(self) -> list[str]:
+        """Convert action table to short format string.
+
+        Returns:
+            Short format string (multi-line format with OUT and SCENE lines).
+        """
+        lines = []
+
+        # Format outputs
+        outputs = [
+            (1, self.output1),
+            (2, self.output2),
+            (3, self.output3),
+        ]
+        for num, output in outputs:
+            lines.append(f"OUT{num} {self._format_output(output)}")
+
+        # Format scenes
+        scenes = [
+            (1, self.scene1),
+            (2, self.scene2),
+            (3, self.scene3),
+            (4, self.scene4),
+        ]
+        for num, scene in scenes:
+            lines.append(f"SCENE{num} {self._format_scene(scene)}")
+
+        return lines
+
+    @classmethod
+    def from_short_format(cls, short_str: list[str]) -> "Xp33MsActionTable":
+        """Parse short format string into action table.
+
+        Args:
+            short_str: Short format string (list of lines).
+
+        Returns:
+            Xp33MsActionTable instance.
+
+        Raises:
+            ValueError: If format is invalid.
+        """
+        # Parse outputs and scenes from lines
+        outputs = {}
+        scenes = {}
+
+        for line in short_str:
+            line = line.strip()
+            if not line:
+                continue
+
+            if line.startswith("OUT"):
+                # Parse output line: OUT1 MIN:0 MAX:100 SO:0 SF:0 LE:0
+                parts = line.split(None, 1)
+                if len(parts) != 2:
+                    raise ValueError(f"Invalid output line format: '{line}'")
+
+                out_key = parts[0]  # OUT1, OUT2, OUT3
+                if not out_key.startswith("OUT"):
+                    raise ValueError(f"Expected OUT prefix, got: '{out_key}'")
+
+                try:
+                    out_num = int(out_key[3:])
+                    if out_num not in (1, 2, 3):
+                        raise ValueError(
+                            f"Invalid output number: {out_num}, expected 1-3"
+                        )
+                except ValueError:
+                    raise ValueError(f"Invalid output number in: '{out_key}'")
+
+                outputs[out_num] = cls._parse_output(parts[1])
+
+            elif line.startswith("SCENE"):
+                # Parse scene line: SCENE1 OUT1:0 OUT2:0 OUT3:0 T:NONE
+                parts = line.split(None, 1)
+                if len(parts) != 2:
+                    raise ValueError(f"Invalid scene line format: '{line}'")
+
+                scene_key = parts[0]  # SCENE1, SCENE2, etc.
+                if not scene_key.startswith("SCENE"):
+                    raise ValueError(f"Expected SCENE prefix, got: '{scene_key}'")
+
+                try:
+                    scene_num = int(scene_key[5:])
+                    if scene_num not in (1, 2, 3, 4):
+                        raise ValueError(
+                            f"Invalid scene number: {scene_num}, expected 1-4"
+                        )
+                except ValueError:
+                    raise ValueError(f"Invalid scene number in: '{scene_key}'")
+
+                scenes[scene_num] = cls._parse_scene(parts[1])
+
+        # Validate we have all required outputs and scenes
+        for i in (1, 2, 3):
+            if i not in outputs:
+                raise ValueError(f"Missing output{i} configuration")
+
+        for i in (1, 2, 3, 4):
+            if i not in scenes:
+                raise ValueError(f"Missing scene{i} configuration")
+
+        return cls(
+            output1=outputs[1],
+            output2=outputs[2],
+            output3=outputs[3],
+            scene1=scenes[1],
+            scene2=scenes[2],
+            scene3=scenes[3],
+            scene4=scenes[4],
+        )
+
+    @staticmethod
+    def _format_output(output: Xp33Output) -> str:
+        """Format output configuration to short string.
+
+        Args:
+            output: Xp33Output instance.
+
+        Returns:
+            Short string like "MIN:10 MAX:90 SO:1 SF:0 LE:1".
+        """
+        return (
+            f"MIN:{output.min_level} "
+            f"MAX:{output.max_level} "
+            f"SO:{1 if output.scene_outputs else 0} "
+            f"SF:{1 if output.start_at_full else 0} "
+            f"LE:{1 if output.leading_edge else 0}"
+        )
+
+    @staticmethod
+    def _parse_output(output_str: str) -> Xp33Output:
+        """Parse output configuration from short string.
+
+        Args:
+            output_str: Short string like "MIN:10 MAX:90 SO:1 SF:0 LE:1".
+
+        Returns:
+            Xp33Output instance.
+
+        Raises:
+            ValueError: If format is invalid.
+        """
+        # Parse key:value pairs
+        parts = output_str.split()
+        params = {}
+
+        for part in parts:
+            if ":" not in part:
+                raise ValueError(f"Invalid output parameter format: '{part}'")
+
+            key, value = part.split(":", 1)
+            params[key] = value
+
+        # Validate required keys
+        required_keys = ["MIN", "MAX", "SO", "SF", "LE"]
+        for key in required_keys:
+            if key not in params:
+                raise ValueError(f"Missing required parameter: {key}")
+
+        # Parse and validate values
+        try:
+            min_level = int(params["MIN"])
+            max_level = int(params["MAX"])
+            scene_outputs = params["SO"] == "1"
+            start_at_full = params["SF"] == "1"
+            leading_edge = params["LE"] == "1"
+
+            # Validate ranges
+            if not (0 <= min_level <= 100):
+                raise ValueError(f"MIN level out of range (0-100): {min_level}")
+            if not (0 <= max_level <= 100):
+                raise ValueError(f"MAX level out of range (0-100): {max_level}")
+
+            return Xp33Output(
+                min_level=min_level,
+                max_level=max_level,
+                scene_outputs=scene_outputs,
+                start_at_full=start_at_full,
+                leading_edge=leading_edge,
+            )
+        except ValueError as e:
+            raise ValueError(f"Invalid output parameter value: {e}")
+
+    @staticmethod
+    def _format_scene(scene: Xp33Scene) -> str:
+        """Format scene configuration to short string.
+
+        Args:
+            scene: Xp33Scene instance.
+
+        Returns:
+            Short string like "OUT1:50 OUT2:60 OUT3:70 T:T5SEC".
+        """
+        time_str = scene.time.name
+        return (
+            f"OUT1:{scene.output1_level} "
+            f"OUT2:{scene.output2_level} "
+            f"OUT3:{scene.output3_level} "
+            f"T:{time_str}"
+        )
+
+    @staticmethod
+    def _parse_scene(scene_str: str) -> Xp33Scene:
+        """Parse scene configuration from short string.
+
+        Args:
+            scene_str: Short string like "OUT1:50 OUT2:60 OUT3:70 T:T5SEC".
+
+        Returns:
+            Xp33Scene instance.
+
+        Raises:
+            ValueError: If format is invalid.
+        """
+        # Parse key:value pairs
+        parts = scene_str.split()
+        params = {}
+
+        for part in parts:
+            if ":" not in part:
+                raise ValueError(f"Invalid scene parameter format: '{part}'")
+
+            key, value = part.split(":", 1)
+            params[key] = value
+
+        # Validate required keys
+        required_keys = ["OUT1", "OUT2", "OUT3", "T"]
+        for key in required_keys:
+            if key not in params:
+                raise ValueError(f"Missing required parameter: {key}")
+
+        # Parse and validate values
+        try:
+            output1_level = int(params["OUT1"])
+            output2_level = int(params["OUT2"])
+            output3_level = int(params["OUT3"])
+
+            # Validate ranges
+            if not (0 <= output1_level <= 100):
+                raise ValueError(f"OUT1 level out of range (0-100): {output1_level}")
+            if not (0 <= output2_level <= 100):
+                raise ValueError(f"OUT2 level out of range (0-100): {output2_level}")
+            if not (0 <= output3_level <= 100):
+                raise ValueError(f"OUT3 level out of range (0-100): {output3_level}")
+
+            # Parse time parameter - support both name and numeric value
+            time_str = params["T"]
+            try:
+                # Try parsing as enum name first
+                time_param = TimeParam[time_str]
+            except KeyError:
+                # Try parsing as numeric value
+                try:
+                    time_value = int(time_str)
+                    time_param = TimeParam(time_value)
+                except (ValueError, KeyError):
+                    raise ValueError(f"Invalid TimeParam: '{time_str}'")
+
+            return Xp33Scene(
+                output1_level=output1_level,
+                output2_level=output2_level,
+                output3_level=output3_level,
+                time=time_param,
+            )
+        except ValueError as e:
+            raise ValueError(f"Invalid scene parameter value: {e}")

xp/models/config/conson_module_config.py

@@ -23,7 +23,9 @@ class ConsonModuleConfig(BaseModel):
         sw_version: Optional software version.
         hw_version: Optional hardware version.
         action_table: Optional action table configuration.
-        msaction_table: Optional ms action table configuration.
+        xp20_msaction_table: Optional xp20 ms action table configuration.
+        xp24_msaction_table: Optional xp24 ms action table configuration.
+        xp33_msaction_table: Optional xp33 ms action table configuration.
         auto_report_status: Optional auto report status.
     """
 
@@ -40,7 +42,9 @@ class ConsonModuleConfig(BaseModel):
     hw_version: Optional[str] = None
     auto_report_status: Optional[str] = None
     action_table: Optional[List[str]] = None
-    msaction_table: Optional[str] = None
+    xp20_msaction_table: Optional[List[str]] = None
+    xp24_msaction_table: Optional[List[str]] = None
+    xp33_msaction_table: Optional[List[str]] = None
 
 
 class ConsonModuleListConfig(BaseModel):

xp/services/actiontable/msactiontable_xp20_serializer.py

@@ -16,7 +16,7 @@ class Xp20MsActionTableSerializer:
     """Handles serialization/deserialization of XP20 action tables to/from telegrams."""
 
     @staticmethod
-    def format_decoded_output(action_table: Xp20MsActionTable) -> str:
+    def format_decoded_output(action_table: Xp20MsActionTable) -> list[str]:
         """Serialize XP20 action table to humane compact readable format.
 
         Args:
@@ -25,7 +25,7 @@ class Xp20MsActionTableSerializer:
         Returns:
             Human-readable string describing XP20 action table
         """
-        return ""
+        return action_table.to_short_format()
 
     @staticmethod
     def to_data(action_table: Xp20MsActionTable) -> str:

xp/services/actiontable/msactiontable_xp24_serializer.py

@@ -10,7 +10,7 @@ class Xp24MsActionTableSerializer:
     """Handles serialization/deserialization of XP24 action tables to/from telegrams."""
 
     @staticmethod
-    def format_decoded_output(action_table: Xp24MsActionTable) -> str:
+    def format_decoded_output(action_table: Xp24MsActionTable) -> list[str]:
         """Serialize XP24 action table to humane compact readable format.
 
         Args:

xp/services/actiontable/msactiontable_xp33_serializer.py

@@ -13,7 +13,7 @@ class Xp33MsActionTableSerializer:
     """Handles serialization/deserialization of XP33 action tables to/from telegrams."""
 
     @staticmethod
-    def format_decoded_output(action_table: Xp33MsActionTable) -> str:
+    def format_decoded_output(action_table: Xp33MsActionTable) -> list[str]:
         """Serialize XP33 action table to humane compact readable format.
 
         Args:
@@ -22,7 +22,7 @@ class Xp33MsActionTableSerializer:
         Returns:
             Human-readable string describing XP33 action table
         """
-        return ""
+        return action_table.to_short_format()
 
     @staticmethod
     def _percentage_to_byte(percentage: int) -> int:

xp/services/conbus/msactiontable/msactiontable_download_service.py

@@ -5,7 +5,6 @@ from typing import Any, Optional, Union
 
 from psygnal import Signal
 
-from xp.models.actiontable.msactiontable import MsActionTable
 from xp.models.actiontable.msactiontable_xp20 import Xp20MsActionTable
 from xp.models.actiontable.msactiontable_xp24 import Xp24MsActionTable
 from xp.models.actiontable.msactiontable_xp33 import Xp33MsActionTable
@@ -42,12 +41,12 @@ class MsActionTableDownloadService:
         conbus_protocol: Protocol instance for Conbus communication.
         on_progress: Signal emitted for progress updates (str).
         on_error: Signal emitted for errors (str).
-        on_finish: Signal emitted when download completes (MsActionTable or None).
+        on_finish: Signal emitted when XP download completes (Xp20MsActionTable, str).
     """
 
     on_progress: Signal = Signal(str)
     on_error: Signal = Signal(str)
-    on_finish: Signal = Signal(MsActionTable, str)  # Union type for Xp20/24/33 or None
+    on_finish: Signal = Signal(object, list[str])
 
     def __init__(
         self,
@@ -188,7 +187,7 @@ class MsActionTableDownloadService:
     def succeed(
         self,
         msactiontable: Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable],
-        msactiontable_short: str,
+        msactiontable_short: list[str],
     ) -> None:
         """Handle succeed connection event.
 
@@ -196,6 +195,7 @@ class MsActionTableDownloadService:
             msactiontable: result.
             msactiontable_short: result in short form.
         """
+        # Emit to the appropriate signal based on module type
         self.on_finish.emit(msactiontable, msactiontable_short)
 
     def start(

xp/services/conbus/msactiontable/msactiontable_list_service.py

@@ -72,7 +72,15 @@ class MsActionTableListService:
             {
                 "serial_number": module.serial_number,
                 "module_type": module.module_type,
-                "msaction_table": 1 if module.msaction_table else 0,
+                "msaction_table": (
+                    1
+                    if (
+                        module.xp20_msaction_table
+                        or module.xp24_msaction_table
+                        or module.xp33_msaction_table
+                    )
+                    else 0
+                ),
             }
             for module in config.root
         ]

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/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(

xp/models/actiontable/msactiontable.py

@@ -1,9 +0,0 @@
-"""Base class for MS Action Table models."""
-
-from pydantic import BaseModel
-
-
-class MsActionTable(BaseModel):
-    """Base class for all MS Action Table types (XP20, XP24, XP33)."""
-
-    pass