conson-xp 1.9.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

{conson_xp-1.9.0.dist-info → conson_xp-1.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.9.0
+Version: 1.11.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -276,6 +276,9 @@ xp conbus
 
 xp conbus actiontable
 xp conbus actiontable download
+xp conbus actiontable list
+xp conbus actiontable show
+xp conbus actiontable upload
 
 
 xp conbus autoreport

{conson_xp-1.9.0.dist-info → conson_xp-1.11.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
-conson_xp-1.9.0.dist-info/METADATA,sha256=usy0aEumo7eEblOFryKcZJMRf2sbegjsd6rBUdyuMfw,9274
-conson_xp-1.9.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-conson_xp-1.9.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.9.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=L0H6Mwrze8ZJt6uirLh_Crx5go9rdWWiCFZ91ox0TII,180
+conson_xp-1.11.0.dist-info/METADATA,sha256=fGKwcGHNxOkx1fqKtt_yiGvb2qdCzbv3mABmqZVQvZ0,9358
+conson_xp-1.11.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+conson_xp-1.11.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.11.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=XSIJ1JlixN5N_iTzjciH-3DCu1QnEoPIUXf79udFESc,181
 xp/cli/__init__.py,sha256=QjnKB1KaI2aIyKlzrnvCwfbBuUj8HNgwNMvNJVQofbI,81
 xp/cli/__main__.py,sha256=l2iKwMdat5rTGd3JWs-uGksnYYDDffp_Npz05QdKEeU,117
 xp/cli/commands/__init__.py,sha256=02CbZoKmNX-fn5etX4Hdgg2lUt1MsLFPYx2VkXZyFJ8,4394
 xp/cli/commands/conbus/__init__.py,sha256=gE3K5OEoXkkZX8UOc2v3nreQQzwkOQi7n0VZ-Z2juXA,495
 xp/cli/commands/conbus/conbus.py,sha256=OTebWu-V-_1tOq2nWExPLtDuAeqy7fB7ltUqzHfgcY8,2705
-xp/cli/commands/conbus/conbus_actiontable_commands.py,sha256=iyF3WVLKz4haA_79IP2Yp4y_WFB8aJ5DTH-pTbCfBTk,2252
+xp/cli/commands/conbus/conbus_actiontable_commands.py,sha256=cdjLV9cnm7teEOlu5Jf1MS_aL7lNy8KiDIyjCQa5Nzw,7138
 xp/cli/commands/conbus/conbus_autoreport_commands.py,sha256=oZgyUUFNsb4yf2WO81l2w1PrasNwdC__QwxNkJ2jCaU,3794
 xp/cli/commands/conbus/conbus_blink_commands.py,sha256=UK-Ey4K0FvaPQ96U0gyMid236RlBmUhPNRes9y0SlkM,4848
 xp/cli/commands/conbus/conbus_config_commands.py,sha256=BugIbgNX6_s4MySGvI6tWZkwguciajHUX2Xz8XBux7k,716
@@ -52,9 +52,9 @@ xp/connection/__init__.py,sha256=ClJsVWALYZgAGYZK_Jznd3YKLrHDu17kBfwugjuPfu0,209
 xp/connection/exceptions.py,sha256=7CcRUzkyay5zA6Z9-5dIDRzua806v5N7pCcJazP_1dE,365
 xp/models/__init__.py,sha256=wCyJNKBd8J2ziOm0g00eUZH4OeTaLO5vHuoQGd_AJbg,1111
 xp/models/actiontable/__init__.py,sha256=6kVq1rTOlpc24sZxGGVWkY48tqR42YWHLQHqakWqlPc,43
-xp/models/actiontable/actiontable.py,sha256=D24fftW51fYhz03LzTy21KJLoFLE7KaC6bgiiQcjQRY,1255
+xp/models/actiontable/actiontable.py,sha256=bIeluZhMsvukkSwy2neaewavU8YR6Pso3PIvJ8ENlGg,1251
 xp/models/actiontable/msactiontable_xp20.py,sha256=C_lYYIQagEFap0S5S40_S7AhLO2UZG2EmXjjeem7uw8,1967
-xp/models/actiontable/msactiontable_xp24.py,sha256=hugTkpEfiFwzLNU2xCJgpRtTXglpYG_wC_dRdYCAog4,2093
+xp/models/actiontable/msactiontable_xp24.py,sha256=ne1dC6CA-5GoTnsLCr6Faue_PmSwC7vtUnX4NSRrQ_Y,2089
 xp/models/actiontable/msactiontable_xp33.py,sha256=2IEA0CBPvnatOueBPZiV0DPc7YFzTQIqIMqed8TKXeM,1932
 xp/models/conbus/__init__.py,sha256=VIusMWQdBtlwDgj7oSj06wQkklihTp4oWFShvP_JUgA,35
 xp/models/conbus/conbus.py,sha256=mZQzKPfrdttT-qUnYUSyrEYyc_eHs8z301E5ejeiyvk,2689
@@ -84,7 +84,7 @@ xp/models/telegram/action_type.py,sha256=vkw_chTgmsadksGXvZ9D_qYGpjOwCw-OgbEi8Bm
 xp/models/telegram/datapoint_type.py,sha256=clmgqCsTNKuHmWN6ol2Hwj_71I10f36Oq-S5D5ZA9a8,2942
 xp/models/telegram/event_telegram.py,sha256=FCCfyZXQEUPB6Uo1m7B9nvFCJ0Ipv2CApmImAZo_Xa4,4689
 xp/models/telegram/event_type.py,sha256=VZhaDpey7KYWnmwN-gstj-r4Vd5hiGdzQuRazUdixB8,333
-xp/models/telegram/input_action_type.py,sha256=_0D6U6WslUcA1imht7ZQ5t8EAvkqyk7c2IfmNqZAAR0,1868
+xp/models/telegram/input_action_type.py,sha256=EDYtE4uxByUyGsZTkXxwN9rQxCAejWk08_kv-7COurM,1852
 xp/models/telegram/input_type.py,sha256=X3AcKKMNHswNZs5xgT_AnxeKQpSx_U7ctGnr6AYqNoU,491
 xp/models/telegram/module_type.py,sha256=TdrcQC3UcdESzyUmS9PaVeJuF5VxH1WUtDWdf4QRA50,5223
 xp/models/telegram/module_type_code.py,sha256=bg8Zi58yKs5DDnEF0bGnZ9vvpqzmIZzd1k9Wu4ufB-Y,8177
@@ -98,14 +98,17 @@ xp/models/telegram/timeparam_type.py,sha256=Ar8xvSfPmOAgR2g2Je0FgvP01SL7bPvZn5_H
 xp/models/write_config_type.py,sha256=T2RaO52RpzoJ4782uMHE-fX7Ymx3CaIQAEwByydXq1M,881
 xp/services/__init__.py,sha256=W9YZyrkh7vm--ZHhAXNQiOYQs5yhhmUHXP5I0Lf1XBg,782
 xp/services/actiontable/__init__.py,sha256=z6js4EuJ6xKHaseTEhuEvKo1tr9K1XyQiruReJtBiPY,26
-xp/services/actiontable/actiontable_serializer.py,sha256=ZDIbFG5BlLbSo5O0as119oiNx1IdPLSCNBdQdOlT4V4,5446
+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=3Lz6t3uRYhoeMRhjDAO1XuWPJzH-ML13t05UQLFUW-s,6057
 xp/services/actiontable/msactiontable_xp24_serializer.py,sha256=zdKzcrKqD41POqj_1c4B4why_Jp9mNXncajsnXXBtPw,4215
 xp/services/actiontable/msactiontable_xp33_serializer.py,sha256=xoZBA38pBSUPA9nn7HgaH1ZM5sR2heQbJ6JVlPVbzUY,8400
 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_service.py,sha256=z8rfQehfPOJ_LfGL3rVMaZAJYkeDRYrh1pd2r1dFZwQ,5978
+xp/services/conbus/actiontable/actiontable_download_service.py,sha256=x9k5VlVjvsAJi4McDGqErLaBE_dosV5uMSrNF_r6ic0,6013
+xp/services/conbus/actiontable/actiontable_list_service.py,sha256=6izVZkM2hlWXUMUo1NkNzSMvPo0wFfDxYTADQBXQptU,3000
+xp/services/conbus/actiontable/actiontable_show_service.py,sha256=jqNZ4UvZPHH66OYuryjnU1Km-a83OCwYvK0vc56oL8I,3017
+xp/services/conbus/actiontable/actiontable_upload_service.py,sha256=txhMumjcIHPI4TZk6CERhjyyTKUNhUb7fdSmaylYC48,8189
 xp/services/conbus/actiontable/msactiontable_service.py,sha256=K0TiYL8g4ac8BS1tqS0UAIYJigOlNhxVLIb8ZFybnVE,8393
 xp/services/conbus/conbus_blink_all_service.py,sha256=OaEg4b8AEiEruHSkZ5jDtaoI81vwwxLq4KWXO7zBdD0,6582
 xp/services/conbus/conbus_blink_service.py,sha256=x9uM-sLnIEV8wSNsvJgo08E042g-Hh2ZF3rXkz-k_9s,5824
@@ -160,8 +163,8 @@ xp/services/telegram/telegram_service.py,sha256=XrP1CPi0ckxoKBaNwLA6lo-TogWxXgmX
 xp/services/telegram/telegram_version_service.py,sha256=M5HdOTsLdcwo122FP-jW6R740ktLrtKf2TiMDVz23h8,10528
 xp/utils/__init__.py,sha256=_avMF_UOkfR3tNeDIPqQ5odmbq5raKkaq1rZ9Cn1CJs,332
 xp/utils/checksum.py,sha256=HDpiQxmdIedbCbZ4o_Box0i_Zig417BtCV_46ZyhiTk,1711
-xp/utils/dependencies.py,sha256=1XDwIg3OsmLvOazMQ3qaktcsitYW8E400RxihNWgyt0,18894
+xp/utils/dependencies.py,sha256=xUmk4XWGArR5__kHdEG1Y4K_dHxsP5mkXhwon_SW6Eo,20110
 xp/utils/event_helper.py,sha256=W-A_xmoXlpWZBbJH6qdaN50o3-XrwFsDgvAGMJDiAgo,1001
 xp/utils/serialization.py,sha256=RWHHk86feaB4ZP7rjE4qOWK0900yg2joUBDkP76gfOY,4618
 xp/utils/time_utils.py,sha256=dEyViDlAG9GWU-J3D_YVa-sGma6yiyyMTgN4h2x3PY4,3781
-conson_xp-1.9.0.dist-info/RECORD,,
+conson_xp-1.11.0.dist-info/RECORD,,

xp/__init__.py

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

xp/cli/commands/conbus/conbus_actiontable_commands.py

@@ -1,6 +1,8 @@
 """ActionTable CLI commands."""
 
 import json
+from contextlib import suppress
+from pathlib import Path
 from typing import Any
 
 import click
@@ -12,9 +14,28 @@ from xp.cli.utils.decorators import (
 )
 from xp.cli.utils.serial_number_type import SERIAL
 from xp.models.actiontable.actiontable import ActionTable
-from xp.services.conbus.actiontable.actiontable_service import (
+from xp.models.homekit.homekit_conson_config import (
+    ConsonModuleConfig,
+    ConsonModuleListConfig,
+)
+from xp.services.conbus.actiontable.actiontable_download_service import (
     ActionTableService,
 )
+from xp.services.conbus.actiontable.actiontable_list_service import (
+    ActionTableListService,
+)
+from xp.services.conbus.actiontable.actiontable_show_service import (
+    ActionTableShowService,
+)
+from xp.services.conbus.actiontable.actiontable_upload_service import (
+    ActionTableUploadService,
+)
+
+
+class ActionTableError(Exception):
+    """Raised when ActionTable operations fail."""
+
+    pass
 
 
 @conbus_actiontable.command("download", short_help="Download ActionTable")
@@ -74,3 +95,139 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
             finish_callback=on_finish,
             error_callback=error_callback,
         )
+
+
+@conbus_actiontable.command("upload", short_help="Upload ActionTable")
+@click.argument("serial_number", type=SERIAL)
+@click.pass_context
+@connection_command()
+def conbus_upload_actiontable(ctx: Context, serial_number: str) -> None:
+    """Upload action table from conson.yml to XP module.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+    """
+    service: ActionTableUploadService = (
+        ctx.obj.get("container").get_container().resolve(ActionTableUploadService)
+    )
+
+    click.echo(f"Uploading action table to {serial_number}...")
+
+    # Track number of entries for success message
+    entries_count = 0
+
+    def progress_callback(progress: str) -> None:
+        """Handle progress updates during action table upload.
+
+        Args:
+            progress: Progress message string.
+        """
+        click.echo(progress, nl=False)
+
+    def success_callback() -> None:
+        """Handle successful completion of action table upload."""
+        click.echo("\nAction table uploaded successfully")
+        if entries_count > 0:
+            click.echo(f"{entries_count} entries written")
+
+    def error_callback(error: str) -> None:
+        """Handle errors during action table upload.
+
+        Args:
+            error: Error message string.
+
+        Raises:
+            ActionTableError: Always raised with upload failure message.
+        """
+        raise ActionTableError(f"Upload failed: {error}")
+
+    with service:
+        # Load config to get entry count for success message
+        config_path = Path.cwd() / "conson.yml"
+        if config_path.exists():
+            with suppress(Exception):
+                config = ConsonModuleListConfig.from_yaml(str(config_path))
+                module = config.find_module(serial_number)
+                if module and module.action_table:
+                    entries_count = len(module.action_table)
+
+        service.start(
+            serial_number=serial_number,
+            progress_callback=progress_callback,
+            success_callback=success_callback,
+            error_callback=error_callback,
+        )
+
+
+@conbus_actiontable.command("list", short_help="List modules with ActionTable")
+@click.pass_context
+def conbus_list_actiontable(ctx: Context) -> None:
+    """List all modules with action table configurations from conson.yml.
+
+    Args:
+        ctx: Click context object.
+    """
+    service: ActionTableListService = (
+        ctx.obj.get("container").get_container().resolve(ActionTableListService)
+    )
+
+    def on_finish(module_list: dict) -> None:
+        """Handle successful completion of action table list.
+
+        Args:
+            module_list: Dictionary containing modules and total count.
+        """
+        click.echo(json.dumps(module_list, indent=2, default=str))
+
+    def error_callback(error: str) -> None:
+        """Handle errors during action table list.
+
+        Args:
+            error: Error message string.
+        """
+        click.echo(error)
+
+    with service:
+        service.start(
+            finish_callback=on_finish,
+            error_callback=error_callback,
+        )
+
+
+@conbus_actiontable.command("show", short_help="Show ActionTable configuration")
+@click.argument("serial_number", type=SERIAL)
+@click.pass_context
+def conbus_show_actiontable(ctx: Context, serial_number: str) -> None:
+    """Show action table configuration for a specific module from conson.yml.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+    """
+    service: ActionTableShowService = (
+        ctx.obj.get("container").get_container().resolve(ActionTableShowService)
+    )
+
+    def on_finish(module: ConsonModuleConfig) -> None:
+        """Handle successful completion of action table show.
+
+        Args:
+            module: Dictionary containing module configuration.
+        """
+        click.echo(json.dumps(module.model_dump(), indent=2, default=str))
+
+    def error_callback(error: str) -> None:
+        """Handle errors during action table show.
+
+        Args:
+            error: Error message string.
+        """
+        click.echo(error)
+
+    with service:
+        service.start(
+            serial_number=serial_number,
+            finish_callback=on_finish,
+            error_callback=error_callback,
+        )

xp/models/actiontable/actiontable.py

@@ -27,7 +27,7 @@ class ActionTableEntry:
     link_number: int = 0
     module_input: int = 0
     module_output: int = 1
-    command: InputActionType = InputActionType.TURNOFF
+    command: InputActionType = InputActionType.OFF
     parameter: TimeParam = TimeParam.NONE
     inverted: bool = False
 

xp/models/actiontable/msactiontable_xp24.py

@@ -23,7 +23,7 @@ class InputAction:
 class Xp24MsActionTable:
     """XP24 Action Table for managing input actions and settings.
 
-    Each input has an action type (TOGGLE, TURNON, LEVELSET, etc.)
+    Each input has an action type (TOGGLE, ON, LEVELSET, etc.)
     with an optional parameter string.
 
     Attributes:

xp/models/telegram/input_action_type.py

@@ -8,8 +8,8 @@ class InputActionType(Enum):
 
     Attributes:
         VOID: No action.
-        TURNON: Turn on action.
-        TURNOFF: Turn off action.
+        ON: Turn on action.
+        OFF: Turn off action.
         TOGGLE: Toggle action.
         BLOCK: Block action.
         AUXRELAY: Auxiliary relay action.
@@ -39,8 +39,8 @@ class InputActionType(Enum):
     """
 
     VOID = 0
-    TURNON = 1
-    TURNOFF = 2
+    ON = 1
+    OFF = 2
     TOGGLE = 3
     BLOCK = 4
     AUXRELAY = 5

xp/services/actiontable/actiontable_serializer.py

@@ -1,5 +1,7 @@
 """Serializer for ActionTable telegram encoding/decoding."""
 
+import re
+
 from xp.models import ModuleTypeCode
 from xp.models.actiontable.actiontable import ActionTable, ActionTableEntry
 from xp.models.telegram.input_action_type import InputActionType
@@ -18,7 +20,13 @@ from xp.utils.serialization import (
 
 
 class ActionTableSerializer:
-    """Handles serialization/deserialization of ActionTable to/from telegrams."""
+    """Handles serialization/deserialization of ActionTable to/from telegrams.
+
+    Attributes:
+        MAX_ENTRIES: Maximum number of entries in an ActionTable (96).
+    """
+
+    MAX_ENTRIES = 96  # ActionTable must always contain exactly 96 entries
 
     @staticmethod
     def from_data(data: bytes) -> ActionTable:
@@ -57,12 +65,12 @@ class ActionTableSerializer:
             try:
                 module_type = ModuleTypeCode(module_type_raw)
             except ValueError:
-                module_type = ModuleTypeCode.CP20  # Default fallback
+                module_type = ModuleTypeCode.NOMOD  # Default fallback
 
             try:
                 command = InputActionType(command_raw)
             except ValueError:
-                command = InputActionType.TURNOFF  # Default fallback
+                command = InputActionType.OFF  # Default fallback
 
             try:
                 parameter = TimeParam(parameter_raw)
@@ -91,7 +99,7 @@ class ActionTableSerializer:
             action_table: ActionTable to serialize
 
         Returns:
-            Raw byte data for telegram
+            Raw byte data for telegram (always 480 bytes for 96 entries)
         """
         data = bytearray()
 
@@ -112,6 +120,14 @@ class ActionTableSerializer:
                 [type_byte, link_byte, input_byte, output_command_byte, parameter_byte]
             )
 
+        # Pad to 96 entries with default NOMOD entries (00 00 00 00 00)
+        current_entries = len(action_table.entries)
+        if current_entries < ActionTableSerializer.MAX_ENTRIES:
+            # Default entry: NOMOD 0 0 > 0 OFF (all zeros)
+            padding_bytes = [0x00, 0x00, 0x00, 0x00, 0x00]
+            for _ in range(ActionTableSerializer.MAX_ENTRIES - current_entries):
+                data.extend(padding_bytes)
+
         return bytes(data)
 
     @staticmethod
@@ -176,3 +192,82 @@ class ActionTableSerializer:
             lines.append(line)
 
         return lines
+
+    @staticmethod
+    def parse_action_string(action_str: str) -> ActionTableEntry:
+        """Parse action table entry from string format.
+
+        Args:
+            action_str: String in format "CP20 0 0 > 1 OFF" or "CP20 0 1 > 1 ~ON"
+
+        Returns:
+            Parsed ActionTableEntry
+
+        Raises:
+            ValueError: If string format is invalid
+        """
+        # Remove trailing semicolon if present
+        action_str = action_str.strip().rstrip(";")
+
+        # Pattern: <Type> <Link> <Input> > <Output> <Command> [Parameter]
+        pattern = r"^(\w+)\s+(\d+)\s+(\d+)\s+>\s+(\d+)\s+(~?)(\w+)(?:\s+(\d+))?$"
+        match = re.match(pattern, action_str)
+
+        if not match:
+            raise ValueError(f"Invalid action table format: {action_str}")
+
+        (
+            module_type_str,
+            link_str,
+            input_str,
+            output_str,
+            inverted_str,
+            command_str,
+            parameter_str,
+        ) = match.groups()
+
+        # Parse module type
+        try:
+            module_type = ModuleTypeCode[module_type_str]
+        except KeyError:
+            raise ValueError(f"Invalid module type: {module_type_str}")
+
+        # Parse command
+        try:
+            command = InputActionType[command_str]
+        except KeyError:
+            raise ValueError(f"Invalid command: {command_str}")
+
+        # Parse parameter (default to NONE)
+        parameter = TimeParam.NONE
+        if parameter_str:
+            try:
+                parameter = TimeParam(int(parameter_str))
+            except ValueError:
+                raise ValueError(f"Invalid parameter: {parameter_str}")
+
+        return ActionTableEntry(
+            module_type=module_type,
+            link_number=int(link_str),
+            module_input=int(input_str),
+            module_output=int(output_str),
+            command=command,
+            parameter=parameter,
+            inverted=bool(inverted_str),
+        )
+
+    @staticmethod
+    def parse_action_table(action_strings: list[str]) -> ActionTable:
+        """Parse action table from list of string entries.
+
+        Args:
+            action_strings: List of action strings from conson.yml
+
+        Returns:
+            Parsed ActionTable
+        """
+        entries = [
+            ActionTableSerializer.parse_action_string(action_str)
+            for action_str in action_strings
+        ]
+        return ActionTable(entries=entries)

xp/services/conbus/actiontable/{actiontable_service.py → actiontable_download_service.py}

@@ -17,11 +17,10 @@ from xp.services.telegram.telegram_service import TelegramService
 
 
 class ActionTableService(ConbusProtocol):
-    """
-    TCP client service for sending telegrams to Conbus servers.
+    """TCP client service for downloading action tables from Conbus modules.
 
     Manages TCP socket connections, handles telegram generation and transmission,
-    and processes server responses.
+    and processes server responses for action table downloads.
     """
 
     def __init__(
@@ -31,7 +30,7 @@ class ActionTableService(ConbusProtocol):
         actiontable_serializer: ActionTableSerializer,
         telegram_service: TelegramService,
     ) -> None:
-        """Initialize the Conbus client send service.
+        """Initialize the action table download service.
 
         Args:
             cli_config: Conbus client configuration.

xp/services/conbus/actiontable/actiontable_list_service.py

@@ -0,0 +1,91 @@
+"""Service for listing modules with action table configurations from conson.yml."""
+
+import logging
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+
+class ActionTableListService:
+    """Service for listing modules with action table configurations.
+
+    Reads conson.yml and returns a list of all modules that have action table
+    configurations defined.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the action table list service."""
+        self.logger = logging.getLogger(__name__)
+        self.finish_callback: Optional[Callable[[dict[str, Any]], None]] = None
+        self.error_callback: Optional[Callable[[str], None]] = None
+
+    def __enter__(self) -> "ActionTableListService":
+        """Context manager entry.
+
+        Returns:
+            Self for context manager use.
+        """
+        return self
+
+    def __exit__(self, _exc_type: Any, _exc_val: Any, _exc_tb: Any) -> None:
+        """Context manager exit."""
+        pass
+
+    def start(
+        self,
+        finish_callback: Callable[[dict[str, Any]], None],
+        error_callback: Callable[[str], None],
+        config_path: Optional[Path] = None,
+    ) -> None:
+        """List all modules with action table configurations.
+
+        Args:
+            finish_callback: Callback to invoke with the module list.
+            error_callback: Callback to invoke on error.
+            config_path: Optional path to conson.yml. Defaults to current directory.
+        """
+        self.finish_callback = finish_callback
+        self.error_callback = error_callback
+
+        # Default to current directory if not specified
+        if config_path is None:
+            config_path = Path.cwd() / "conson.yml"
+
+        # Check if config file exists
+        if not config_path.exists():
+            self._handle_error("Error: conson.yml not found in current directory")
+            return
+
+        # Load configuration
+        try:
+            from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+
+            config = ConsonModuleListConfig.from_yaml(str(config_path))
+        except Exception as e:
+            self.logger.error(f"Failed to load conson.yml: {e}")
+            self._handle_error(f"Error: Failed to load conson.yml: {e}")
+            return
+
+        # Filter modules that have action_table configured
+        modules_with_actiontable = [
+            {
+                "serial_number": module.serial_number,
+                "module_type": module.module_type,
+            }
+            for module in config.root
+        ]
+
+        # Prepare result
+        result = {"modules": modules_with_actiontable}
+
+        # Invoke callback
+        if self.finish_callback is not None:
+            self.finish_callback(result)
+
+    def _handle_error(self, message: str) -> None:
+        """Handle error and invoke error callback.
+
+        Args:
+            message: Error message.
+        """
+        if self.error_callback is not None:
+            self.error_callback(message)

xp/services/conbus/actiontable/actiontable_show_service.py

@@ -0,0 +1,89 @@
+"""Service for showing action table configuration for a specific module."""
+
+import logging
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from xp.models.homekit.homekit_conson_config import ConsonModuleConfig
+
+
+class ActionTableShowService:
+    """Service for showing action table configuration for a specific module.
+
+    Reads conson.yml and returns the action table configuration for the specified
+    module serial number.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the action table show service."""
+        self.logger = logging.getLogger(__name__)
+        self.finish_callback: Optional[Callable[[ConsonModuleConfig], None]] = None
+        self.error_callback: Optional[Callable[[str], None]] = None
+
+    def __enter__(self) -> "ActionTableShowService":
+        """Context manager entry.
+
+        Returns:
+            Self for context manager use.
+        """
+        return self
+
+    def __exit__(self, _exc_type: Any, _exc_val: Any, _exc_tb: Any) -> None:
+        """Context manager exit."""
+        pass
+
+    def start(
+        self,
+        serial_number: str,
+        finish_callback: Callable[[ConsonModuleConfig], None],
+        error_callback: Callable[[str], None],
+        config_path: Optional[Path] = None,
+    ) -> None:
+        """Show action table configuration for a specific module.
+
+        Args:
+            serial_number: Module serial number.
+            finish_callback: Callback to invoke with the module configuration.
+            error_callback: Callback to invoke on error.
+            config_path: Optional path to conson.yml. Defaults to current directory.
+        """
+        self.finish_callback = finish_callback
+        self.error_callback = error_callback
+
+        # Default to current directory if not specified
+        if config_path is None:
+            config_path = Path.cwd() / "conson.yml"
+
+        # Check if config file exists
+        if not config_path.exists():
+            self._handle_error("Error: conson.yml not found in current directory")
+            return
+
+        # Load configuration
+        try:
+            from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+
+            config = ConsonModuleListConfig.from_yaml(str(config_path))
+        except Exception as e:
+            self.logger.error(f"Failed to load conson.yml: {e}")
+            self._handle_error(f"Error: Failed to load conson.yml: {e}")
+            return
+
+        # Find module
+        module = config.find_module(serial_number)
+        if not module:
+            self._handle_error(f"Error: Module {serial_number} not found in conson.yml")
+            return
+
+        # Invoke callback
+        if self.finish_callback is not None:
+            self.finish_callback(module)
+
+    def _handle_error(self, message: str) -> None:
+        """Handle error and invoke error callback.
+
+        Args:
+            message: Error message.
+        """
+        if self.error_callback is not None:
+            self.error_callback(message)

xp/services/conbus/actiontable/actiontable_upload_service.py

@@ -0,0 +1,211 @@
+"""Service for uploading ActionTable via Conbus protocol."""
+
+import logging
+from typing import Any, Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
+from xp.models.homekit.homekit_conson_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.actiontable_serializer import ActionTableSerializer
+from xp.services.protocol import ConbusProtocol
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ActionTableUploadService(ConbusProtocol):
+    """TCP client service for uploading action tables to Conbus modules.
+
+    Manages TCP socket connections, handles telegram generation and transmission,
+    and processes server responses for action table uploads.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+        actiontable_serializer: ActionTableSerializer,
+        telegram_service: TelegramService,
+        conson_config: ConsonModuleListConfig,
+    ) -> None:
+        """Initialize the action table upload service.
+
+        Args:
+            cli_config: Conbus client configuration.
+            reactor: Twisted reactor instance.
+            actiontable_serializer: Action table serializer.
+            telegram_service: Telegram service for parsing.
+            conson_config: Conson module list configuration.
+        """
+        super().__init__(cli_config, reactor)
+        self.serializer = actiontable_serializer
+        self.telegram_service = telegram_service
+        self.conson_config = conson_config
+        self.serial_number: str = ""
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.error_callback: Optional[Callable[[str], None]] = None
+        self.success_callback: Optional[Callable[[], None]] = None
+
+        # Upload state
+        self.upload_data_chunks: list[str] = []
+        self.current_chunk_index: int = 0
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established, sending upload actiontable telegram")
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.UPLOAD_ACTIONTABLE,
+            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")
+            # Send next chunk or EOF
+            if self.current_chunk_index < len(self.upload_data_chunks):
+                chunk = self.upload_data_chunks[self.current_chunk_index]
+                self.logger.debug(f"Sending chunk {self.current_chunk_index + 1}")
+
+                # Calculate prefix: AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO
+                # First character: 'A' (fixed)
+                # Second character: 'A' + chunk_index (sequential counter A-O for 15 chunks)
+                prefix_hex = f"AAA{ord('A') + self.current_chunk_index:c}"
+
+                self.send_telegram(
+                    telegram_type=TelegramType.SYSTEM,
+                    serial_number=self.serial_number,
+                    system_function=SystemFunction.ACTIONTABLE,
+                    data_value=f"{prefix_hex}{chunk}",
+                )
+                self.current_chunk_index += 1
+                if self.progress_callback:
+                    self.progress_callback(".")
+            else:
+                # All chunks sent, send EOF
+                self.logger.debug("All chunks sent, sending EOF")
+                self.send_telegram(
+                    telegram_type=TelegramType.SYSTEM,
+                    serial_number=self.serial_number,
+                    system_function=SystemFunction.EOF,
+                    data_value="00",
+                )
+                if self.success_callback:
+                    self.success_callback()
+                self._stop_reactor()
+        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 failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.debug(f"Failed: {message}")
+        if self.error_callback:
+            self.error_callback(message)
+        self._stop_reactor()
+
+    def start(
+        self,
+        serial_number: str,
+        progress_callback: Callable[[str], None],
+        error_callback: Callable[[str], None],
+        success_callback: Callable[[], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Upload action table to module.
+
+        Uploads the action table configuration to the specified module.
+
+        Args:
+            serial_number: Module serial number.
+            progress_callback: Callback for progress updates.
+            error_callback: Callback for errors.
+            success_callback: Callback when upload completes successfully.
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.info("Starting actiontable upload")
+        self.serial_number = serial_number
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.progress_callback = progress_callback
+        self.error_callback = error_callback
+        self.success_callback = success_callback
+
+        # 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
+
+        # Parse action table strings to ActionTable object
+        try:
+            module_action_table = module.action_table or []
+            action_table = self.serializer.parse_action_table(module_action_table)
+        except ValueError as e:
+            self.logger.error(f"Invalid action table format: {e}")
+            self.failed(f"Invalid action table format: {e}")
+            return
+
+        # Encode action table to hex string
+        encoded_data = self.serializer.to_encoded_string(action_table)
+
+        # Chunk the data into 64 byte chunks
+        chunk_size = 64
+        self.upload_data_chunks = [
+            encoded_data[i : i + chunk_size]
+            for i in range(0, len(encoded_data), chunk_size)
+        ]
+        self.current_chunk_index = 0
+
+        self.logger.debug(
+            f"Upload data encoded: {len(encoded_data)} chars, "
+            f"{len(self.upload_data_chunks)} chunks"
+        )
+
+        self.start_reactor()

xp/utils/dependencies.py

@@ -20,7 +20,18 @@ from xp.services.actiontable.msactiontable_xp24_serializer import (
 from xp.services.actiontable.msactiontable_xp33_serializer import (
     Xp33MsActionTableSerializer,
 )
-from xp.services.conbus.actiontable.actiontable_service import ActionTableService
+from xp.services.conbus.actiontable.actiontable_download_service import (
+    ActionTableService,
+)
+from xp.services.conbus.actiontable.actiontable_list_service import (
+    ActionTableListService,
+)
+from xp.services.conbus.actiontable.actiontable_show_service import (
+    ActionTableShowService,
+)
+from xp.services.conbus.actiontable.actiontable_upload_service import (
+    ActionTableUploadService,
+)
 from xp.services.conbus.actiontable.msactiontable_service import MsActionTableService
 from xp.services.conbus.conbus_blink_all_service import ConbusBlinkAllService
 from xp.services.conbus.conbus_blink_service import ConbusBlinkService
@@ -215,6 +226,30 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            ActionTableUploadService,
+            factory=lambda: ActionTableUploadService(
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
+                actiontable_serializer=self.container.resolve(ActionTableSerializer),
+                telegram_service=self.container.resolve(TelegramService),
+                conson_config=self.container.resolve(ConsonModuleListConfig),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            ActionTableListService,
+            factory=ActionTableListService,
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            ActionTableShowService,
+            factory=ActionTableShowService,
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             Xp20MsActionTableSerializer,
             factory=lambda: Xp20MsActionTableSerializer,