conson-xp 1.5.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

{conson_xp-1.5.0.dist-info → conson_xp-1.7.0.dist-info}/METADATA

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

{conson_xp-1.5.0.dist-info → conson_xp-1.7.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-conson_xp-1.5.0.dist-info/METADATA,sha256=to2xeqnuavfCJCA0S4VC3trJaxL02i7c-4RQuU-1qjE,9274
-conson_xp-1.5.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-conson_xp-1.5.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.5.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=UqV_T6LhENt9Tn3-NIiQjKGRaHZSmX5DPf-StL2UAO0,180
+conson_xp-1.7.0.dist-info/METADATA,sha256=zJcFXnX0j-cYc8sCjdUkPuDsGp0-ji8KCGwE79oxZNQ,9274
+conson_xp-1.7.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+conson_xp-1.7.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.7.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=IyP3xj9rnVfGLnpDwGvX8oBbLbm-WT5Qx42Tf8OD9I4,180
 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
@@ -17,7 +17,7 @@ xp/cli/commands/conbus/conbus_datapoint_commands.py,sha256=r36OuTjREtbGKL-bskAGa
 xp/cli/commands/conbus/conbus_discover_commands.py,sha256=Jt-OjARc-QXCr453bhKG0zXRqvOMVKZr328zNxSDulY,1373
 xp/cli/commands/conbus/conbus_lightlevel_commands.py,sha256=FpCwogdxa7yFUjlrxM7e8Q2Ut32tKAHabngQQChvtJI,6763
 xp/cli/commands/conbus/conbus_linknumber_commands.py,sha256=pn491Iy_LcwZ5XLtvNTWu8qG_Vdaaxr7le1tTuVK7Qw,3392
-xp/cli/commands/conbus/conbus_msactiontable_commands.py,sha256=kKWX9S0Ip9eX9EyWPwmyKMtt6q-jRXcOaicMAKt84Ls,2652
+xp/cli/commands/conbus/conbus_msactiontable_commands.py,sha256=fb9MQ4O04H0Dinpt7vSF5GtfntTZHelQ5TuUmSBbCTg,2899
 xp/cli/commands/conbus/conbus_output_commands.py,sha256=zdRVbHzVhMbZpG2x5WXtujc3wKTsoQUV4IgkVIbJbCc,5019
 xp/cli/commands/conbus/conbus_raw_commands.py,sha256=8BKUarwvHgz-sxML7n99YVsb8B1HJNExjQpRsuY_tQw,1829
 xp/cli/commands/conbus/conbus_receive_commands.py,sha256=WdH7fYcbjweIGxD2uxrTRD8lJzViMSVdsaHTvSDJNCQ,1757
@@ -97,14 +97,16 @@ xp/models/telegram/telegram_type.py,sha256=GhqKP63oNMyh2tIvCPcsC5RFp4s4JjhmEqCLC
 xp/models/telegram/timeparam_type.py,sha256=Ar8xvSfPmOAgR2g2Je0FgvP01SL7bPvZn5_HrVDpmJM,1137
 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=x45-8d5Ba9l3hX2TFC5nqKv-g_244g-VTWhXvVXL8Jg,5159
+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_serializer.py,sha256=x45-8d5Ba9l3hX2TFC5nqKv-g_244g-VTWhXvVXL8Jg,5159
-xp/services/conbus/actiontable/actiontable_service.py,sha256=QJwROShPU7uoexB9GxT6if8u8Cfa8yJO3WJqAHNjqMY,5633
-xp/services/conbus/actiontable/msactiontable_service.py,sha256=u64nejKvHzMdmlK9VoM7P3uMGIfjyfo2xp9dXXlgvjc,7451
-xp/services/conbus/actiontable/msactiontable_xp20_serializer.py,sha256=EYspooOdi0Z8oaXGxpazwnUoTmh-d7U9auhu11iBgmU,6527
-xp/services/conbus/actiontable/msactiontable_xp24_serializer.py,sha256=30qsk9UKje1n32PPc4YoGV1lw_ZvgxNqqd8ZDgzMJpg,4504
-xp/services/conbus/actiontable/msactiontable_xp33_serializer.py,sha256=nuWfka4U9W4lpTcS8uD6azXFcryPb0CUO5O7Z28G1k8,8901
+xp/services/conbus/actiontable/actiontable_service.py,sha256=uy-BFCsjDoe1ZuZy9cTwRSIfMSxznLEN-iMtTsPW3EI,5626
+xp/services/conbus/actiontable/msactiontable_service.py,sha256=yeMJRHVJe2s_-MquOdZDDym3g7135J3CzhxfEa6Qmkc,8357
 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
 xp/services/conbus/conbus_custom_service.py,sha256=4aneYdPObiZOGxPFYg5Wr70cl_xFxlQIdJBPQSa0enI,5826
@@ -133,19 +135,20 @@ 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=WuYn2iEcvsOIXnn5HCrU9kD3PjuMX1sIh0ljKISDoJw,720
-xp/services/protocol/conbus_protocol.py,sha256=G39YPMpwhvvhFPYrzNxx6y2Is6DSP2UyCLm4T7RLPVc,10404
+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
 xp/services/reverse_proxy_service.py,sha256=BUOlcLlTU-R5iuC_96rasug21xo19wK9_4fMQXxc0QM,15061
 xp/services/server/__init__.py,sha256=QEcCj-jK0goAukJCe15TKYFQfSAzWsduPT_wW0HxZU8,48
-xp/services/server/base_server_service.py,sha256=AkeLWMOTasIIiBBGM_uTCXJ31yG1ciF98b9xKyq8VSs,9997
-xp/services/server/cp20_server_service.py,sha256=PkdkORQ-aIHtQb-wuAgkRxKcdpNWpvys_p1sXJg0yoI,1679
-xp/services/server/server_service.py,sha256=pRE_hdAlQfQBj10Y15IiBOz2wQL9LghoigZvcywbnKI,17899
-xp/services/server/xp130_server_service.py,sha256=mD3vE-JDR9s_o7zjVCu4cibM8hUbwJ1oxgb_JwtQ2WU,1819
-xp/services/server/xp20_server_service.py,sha256=s9RrqhCZ8xtgEzc8GXTlG81b4LtZLCFy79DhzBLTPjA,1428
-xp/services/server/xp230_server_service.py,sha256=c3kzkA-fEOglrjLISQLbyk_rUdKzwN20hc0qtF9MEAQ,1443
-xp/services/server/xp24_server_service.py,sha256=_QMHe0UgxVlyB0DZmP1KPdjheT1qE8V8-EW55FM58DY,6606
-xp/services/server/xp33_server_service.py,sha256=BhZaphtb1hgedTmB1bTuLlWTIZp3AOuec2gffDvKmRM,18329
+xp/services/server/base_server_service.py,sha256=B-ntxp3swbwuri-9_2EuvBDi-4Uo9AH-AA4iAFGWIS4,12682
+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=JPRFMto2l956dW7vfSclQugu2vdF0fssxxUOYjHNtA4,15833
+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
+xp/services/server/xp24_server_service.py,sha256=S4kDZHf6SsFTwIzk1PwkWntFHtmOuVcz6UclkRdTGsc,8670
+xp/services/server/xp33_server_service.py,sha256=X5BJr7RYueHAPNrfW-HnqV7ZN-OAouKxH1qMdDADqhk,19745
 xp/services/telegram/__init__.py,sha256=kv0JgMg13Fp18WgGQpalNRAWwiWbrz18X4kZAP9xpSQ,48
 xp/services/telegram/telegram_blink_service.py,sha256=Xctc9mCSZiiW1YTh8cA-4jlc8fTioS5OxT6ymhSqiYI,4487
 xp/services/telegram/telegram_checksum_service.py,sha256=rp_C5PlraOOIyqZDp9XjBBNZLUeBLdQNNHVpN6D-1v8,4729
@@ -153,12 +156,12 @@ xp/services/telegram/telegram_datapoint_service.py,sha256=A3ERuFSWc22uJUoymH-2dW
 xp/services/telegram/telegram_discover_service.py,sha256=oTpiq-yzP_UmC0xVOMMFeHO-rIlK1pF3aG-Kq4SeiBI,9025
 xp/services/telegram/telegram_link_number_service.py,sha256=1_c-_QCRPTHYn3BmMElrBJqGG6vnoIst8CB-N42hazk,6862
 xp/services/telegram/telegram_output_service.py,sha256=UaUv_14fR8o5K2PxQBXrCzx-Hohnk-gzbev_oLw_Clc,10799
-xp/services/telegram/telegram_service.py,sha256=CQKmwV0Jmlr1WwrshaANyp_e77DjBzXzuFL1U5DRgFI,13092
+xp/services/telegram/telegram_service.py,sha256=XrP1CPi0ckxoKBaNwLA6lo-TogWxXgmXDOsU4Xl8BlY,13237
 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=4G7r0m1HY9UV4E0zLS8L-axcNiX2mM-N6OOAU8dVHVM,17740
+xp/utils/dependencies.py,sha256=1XDwIg3OsmLvOazMQ3qaktcsitYW8E400RxihNWgyt0,18894
 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.5.0.dist-info/RECORD,,
+conson_xp-1.7.0.dist-info/RECORD,,

xp/__init__.py

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

xp/cli/commands/conbus/conbus_msactiontable_commands.py

@@ -49,13 +49,22 @@ def conbus_download_msactiontable(
         click.echo(progress, nl=False)
 
     def on_finish(
-        action_table: Union[Xp20MsActionTable | Xp24MsActionTable | Xp33MsActionTable],
+        action_table: Union[
+            Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None
+        ],
     ) -> None:
         """Handle successful completion of MS action table download.
 
         Args:
-            action_table: Downloaded MS action table object.
+            action_table: Downloaded MS action table object or None if failed.
+
+        Raises:
+            Abort: If action table download failed.
         """
+        if action_table is None:
+            click.echo("Error: Failed to download MS action table")
+            raise click.Abort()
+
         output = {
             "serial_number": serial_number,
             "xpmoduletype": xpmoduletype,

xp/services/actiontable/__init__.py

@@ -0,0 +1 @@
+"""Action table utils."""

xp/services/actiontable/msactiontable_serializer.py

@@ -0,0 +1,7 @@
+"""Generic MsActionTable serializer base class for type hints."""
+
+
+class MsActionTableSerializer:
+    """Serializer for ActionTable telegram encoding/decoding."""
+
+    pass

xp/services/{conbus/actiontable → actiontable}/msactiontable_xp20_serializer.py

@@ -46,8 +46,9 @@ class Xp20MsActionTableSerializer:
                 input_channel, input_index, raw_bytes
             )
 
+        encoded_data = nibbles(raw_bytes)
         # Convert raw bytes to hex string with A-P encoding
-        return nibbles(raw_bytes)
+        return "AAAA" + encoded_data
 
     @staticmethod
     def from_data(msactiontable_rawdata: str) -> Xp20MsActionTable:
@@ -62,13 +63,20 @@ class Xp20MsActionTableSerializer:
         Raises:
             ValueError: If input length is not 64 characters
         """
-        if len(msactiontable_rawdata) != 64:
+        raw_length = len(msactiontable_rawdata)
+        if raw_length < 68:  # Minimum: 4 char prefix + 64 chars data
             raise ValueError(
-                f"XP20 action table data must be 64 characters long, got {len(msactiontable_rawdata)}"
+                f"XP20 action table data must be 68 characters long, got {len(msactiontable_rawdata)}"
             )
 
-        # Convert hex string to bytes using de_nibble (A-P encoding)
-        raw_bytes = de_nibbles(msactiontable_rawdata)
+        # Remove action table count prefix (first 4 characters: AAAA, AAAB, etc.)
+        data = msactiontable_rawdata[4:]
+
+        # Take first 64 chars (32 bytes) as per pseudocode
+        hex_data = data[:64]
+
+        # Convert hex string to bytes using deNibble (A-P encoding)
+        raw_bytes = de_nibbles(hex_data)
 
         # Decode input channels
         input_channels = []
@@ -159,23 +167,3 @@ class Xp20MsActionTableSerializer:
                 and_functions_byte |= 1 << bit_index
 
         raw_bytes[AND_FUNCTIONS_INDEX + input_index] = and_functions_byte
-
-    @staticmethod
-    def from_telegrams(ms_telegrams: str) -> Xp20MsActionTable:
-        """Legacy method for backward compatibility. Use from_data() instead.
-
-        Args:
-            ms_telegrams: Full telegram string
-
-        Returns:
-            Decoded XP20 action table
-        """
-        # Extract data portion from telegram (skip header, take action table data)
-        # Based on XP24 pattern: telegram[16:84] gives us the 68-char data portion
-        # For XP20, we need 64 chars, so we take the first 64 chars after removing count
-        data_parts = ms_telegrams[16:84]
-
-        # Remove action table count (first 4 chars: AAAA, AAAB, etc.)
-        hex_data = data_parts[4:68]  # Take 64 chars after count
-
-        return Xp20MsActionTableSerializer.from_data(hex_data)

xp/services/{conbus/actiontable → actiontable}/msactiontable_xp24_serializer.py

@@ -3,7 +3,7 @@
 from xp.models.actiontable.msactiontable_xp24 import InputAction, Xp24MsActionTable
 from xp.models.telegram.input_action_type import InputActionType
 from xp.models.telegram.timeparam_type import TimeParam
-from xp.utils.serialization import de_nibbles
+from xp.utils.serialization import de_nibbles, nibbles
 
 
 class Xp24MsActionTableSerializer:
@@ -17,11 +17,12 @@ class Xp24MsActionTableSerializer:
             action_table: XP24 MS action table to serialize.
 
         Returns:
-            Serialized action table data string.
+            Serialized action table data string (68 characters).
         """
-        data_parts: list[str] = []
+        # Build byte array for the action table (32 bytes total)
+        raw_bytes = bytearray()
 
-        # Encode all 4 input actions
+        # Encode all 4 input actions (2 bytes each = 8 bytes total)
         input_actions = [
             action_table.input1_action,
             action_table.input2_action,
@@ -30,26 +31,24 @@ class Xp24MsActionTableSerializer:
         ]
 
         for action in input_actions:
-            # Use enum value directly as function ID
-            function_id = action.type.value
-            # Convert parameter to int (None becomes 0)
-            param_id = action.param.value
-            data_parts.append(f"{function_id:02X}{param_id:02X}")
-
-        # Add settings as hex values
-        data_parts.extend(
-            [
-                "AB" if action_table.mutex12 else "AA",
-                "AB" if action_table.mutex34 else "AA",
-                f"{action_table.mutual_deadtime:02X}",
-                "AB" if action_table.curtain12 else "AA",
-                "AB" if action_table.curtain34 else "AA",
-                "A" * 38,  # padding
-            ]
-        )
+            raw_bytes.append(action.type.value)
+            raw_bytes.append(action.param.value)
+
+        # Add settings (5 bytes)
+        raw_bytes.append(0x01 if action_table.mutex12 else 0x00)
+        raw_bytes.append(0x01 if action_table.mutex34 else 0x00)
+        raw_bytes.append(action_table.mutual_deadtime)
+        raw_bytes.append(0x01 if action_table.curtain12 else 0x00)
+        raw_bytes.append(0x01 if action_table.curtain34 else 0x00)
+
+        # Add padding to reach 32 bytes (19 more bytes needed)
+        raw_bytes.extend([0x00] * 19)
+
+        # Encode to A-P nibbles (32 bytes -> 64 chars)
+        encoded_data = nibbles(bytes(raw_bytes))
 
-        data = "AAAA".join(data_parts)
-        return data
+        # Prepend action table count "AAAA" (4 chars) -> total 68 chars
+        return "AAAA" + encoded_data
 
     @staticmethod
     def from_data(msactiontable_rawdata: str) -> Xp24MsActionTable:
@@ -66,7 +65,9 @@ class Xp24MsActionTableSerializer:
         """
         raw_length = len(msactiontable_rawdata)
         if raw_length != 68:
-            raise ValueError(f"Msactiontable is not 68 bytes long ({raw_length})")
+            raise ValueError(
+                f"Msactiontable is not 68 bytes long ({raw_length}): {msactiontable_rawdata}"
+            )
 
         # Remove action table count AAAA, AAAB .
         data = msactiontable_rawdata[4:]
@@ -117,18 +118,3 @@ class Xp24MsActionTableSerializer:
         param_type = TimeParam(param_id)
 
         return InputAction(action_type, param_type)
-
-    @staticmethod
-    def from_telegrams(ms_telegrams: str) -> Xp24MsActionTable:
-        """Legacy method for backward compatibility. Use from_data() instead.
-
-        Args:
-            ms_telegrams: Telegram data string.
-
-        Returns:
-            Deserialized XP24 MS action table.
-        """
-        # For backward compatibility, assume full telegrams and extract data
-        data_parts = ms_telegrams[16:84]
-
-        return Xp24MsActionTableSerializer.from_data(data_parts)

xp/services/{conbus/actiontable → actiontable}/msactiontable_xp33_serializer.py

@@ -6,7 +6,7 @@ from xp.models.actiontable.msactiontable_xp33 import (
     Xp33Scene,
 )
 from xp.models.telegram.timeparam_type import TimeParam
-from xp.utils.serialization import bits_to_byte, byte_to_bits, de_nibbles, nibble
+from xp.utils.serialization import bits_to_byte, byte_to_bits, de_nibbles, nibbles
 
 
 class Xp33MsActionTableSerializer:
@@ -96,13 +96,11 @@ class Xp33MsActionTableSerializer:
         raw_bytes[24] = bits_to_byte(leading_edge_bits)
 
         # Bytes 25-31 are padding (already 0)
-
         # Convert to hex string using nibble encoding
-        hex_data = "AAAA"
-        for byte_val in raw_bytes:
-            hex_data += nibble(byte_val)
+        encoded_data = nibbles(raw_bytes)
 
-        return hex_data
+        # Convert raw bytes to hex string with A-P encoding
+        return "AAAA" + encoded_data
 
     @staticmethod
     def from_data(msactiontable_rawdata: str) -> Xp33MsActionTable:
@@ -239,18 +237,3 @@ class Xp33MsActionTableSerializer:
             output3_level=output3_level,
             time=time_param,
         )
-
-    @staticmethod
-    def from_telegrams(ms_telegrams: str) -> Xp33MsActionTable:
-        """Legacy method for backward compatibility. Use from_data() instead.
-
-        Args:
-            ms_telegrams: Telegram data string.
-
-        Returns:
-            Deserialized XP33 MS action table.
-        """
-        # For backward compatibility, assume full telegrams and extract data
-        data_parts = ms_telegrams[16:152]  # Adjusted for XP33 length
-
-        return Xp33MsActionTableSerializer.from_data(data_parts)

xp/services/conbus/actiontable/actiontable_service.py

@@ -10,7 +10,7 @@ from xp.models.actiontable.actiontable import ActionTable
 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.conbus.actiontable.actiontable_serializer import ActionTableSerializer
+from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
 from xp.services.protocol import ConbusProtocol
 from xp.services.telegram.telegram_service import TelegramService
 

xp/services/conbus/actiontable/msactiontable_service.py

@@ -12,13 +12,13 @@ from xp.models.actiontable.msactiontable_xp33 import Xp33MsActionTable
 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.conbus.actiontable.msactiontable_xp20_serializer import (
+from xp.services.actiontable.msactiontable_xp20_serializer import (
     Xp20MsActionTableSerializer,
 )
-from xp.services.conbus.actiontable.msactiontable_xp24_serializer import (
+from xp.services.actiontable.msactiontable_xp24_serializer import (
     Xp24MsActionTableSerializer,
 )
-from xp.services.conbus.actiontable.msactiontable_xp33_serializer import (
+from xp.services.actiontable.msactiontable_xp33_serializer import (
     Xp33MsActionTableSerializer,
 )
 from xp.services.protocol import ConbusProtocol
@@ -74,7 +74,8 @@ class MsActionTableService(ConbusProtocol):
         self.error_callback: Optional[Callable[[str], None]] = None
         self.finish_callback: Optional[
             Callable[
-                [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable]], None
+                [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None]],
+                None,
             ]
         ] = None
         self.msactiontable_data: list[str] = []
@@ -114,17 +115,32 @@ class MsActionTableService(ConbusProtocol):
             self.logger.debug("Not a reply response")
             return
 
-        reply_telegram = self.telegram_service.parse_reply_telegram(telegram_received)
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
         if reply_telegram.system_function not in (
             SystemFunction.MSACTIONTABLE,
+            SystemFunction.ACK,
+            SystemFunction.NAK,
             SystemFunction.EOF,
         ):
             self.logger.debug("Not a msactiontable response")
             return
 
-        if reply_telegram.system_function == SystemFunction.ACTIONTABLE:
-            self.logger.debug("Saving msactiontable response")
-            self.msactiontable_data.append(reply_telegram.data_value)
+        if reply_telegram.system_function == SystemFunction.ACK:
+            self.logger.debug("Received ACK")
+            return
+
+        if reply_telegram.system_function == SystemFunction.NAK:
+            self.logger.debug("Received NAK")
+            self.failed("Received NAK")
+            return
+
+        if reply_telegram.system_function == SystemFunction.MSACTIONTABLE:
+            self.logger.debug("Received MSACTIONTABLE")
+            self.msactiontable_data.extend(
+                (reply_telegram.data, reply_telegram.data_value)
+            )
             if self.progress_callback:
                 self.progress_callback(".")
 
@@ -137,11 +153,14 @@ class MsActionTableService(ConbusProtocol):
             return
 
         if reply_telegram.system_function == SystemFunction.EOF:
+            self.logger.debug("Received EOF")
             all_data = "".join(self.msactiontable_data)
             # Deserialize from received data
             msactiontable = self.serializer.from_data(all_data)
-            if self.finish_callback:
-                self.finish_callback(msactiontable)
+            self.succeed(msactiontable)
+            return
+
+        self.logger.debug("Invalid msactiontable response")
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -152,6 +171,20 @@ class MsActionTableService(ConbusProtocol):
         self.logger.debug(f"Failed: {message}")
         if self.error_callback:
             self.error_callback(message)
+        self._stop_reactor()
+
+    def succeed(
+        self,
+        msactiontable: Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable],
+    ) -> None:
+        """Handle succeed connection event.
+
+        Args:
+            msactiontable: result.
+        """
+        if self.finish_callback:
+            self.finish_callback(msactiontable)
+        self._stop_reactor()
 
     def start(
         self,
@@ -160,7 +193,7 @@ class MsActionTableService(ConbusProtocol):
         progress_callback: Callable[[str], None],
         error_callback: Callable[[str], None],
         finish_callback: Callable[
-            [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable]], None
+            [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None]], None
         ],
         timeout_seconds: Optional[float] = None,
     ) -> None:

xp/services/protocol/conbus_protocol.py

@@ -230,13 +230,11 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self.timeout_call = self.reactor.callLater(
             self.timeout_seconds, self._on_timeout
         )
-        self.logger.debug(f"Timeout set for {self.timeout_seconds} seconds")
 
     def _cancel_timeout(self) -> None:
         """Cancel the inactivity timeout."""
         if self.timeout_call and self.timeout_call.active():
             self.timeout_call.cancel()
-            self.logger.debug("Timeout cancelled")
 
     def _on_timeout(self) -> None:
         """Handle inactivity timeout expiration."""

xp/services/server/base_server_service.py

@@ -7,7 +7,7 @@ containing common functionality like module type response generation.
 import logging
 import threading
 from abc import ABC
-from typing import Optional
+from typing import Any, Optional
 
 from xp.models import ModuleTypeCode
 from xp.models.telegram.datapoint_type import DataPointType
@@ -46,6 +46,9 @@ class BaseServerService(ABC):
         self.telegram_buffer: list[str] = []
         self.telegram_buffer_lock = threading.Lock()  # Lock for socket set
 
+        # MsActionTable download state (None, "ack_sent", "data_sent")
+        self.msactiontable_download_state: Optional[str] = None
+
     def generate_datapoint_type_response(
         self, datapoint_type: DataPointType
     ) -> Optional[str]:
@@ -151,6 +154,76 @@ class BaseServerService(ABC):
 
         return None
 
+    def _get_msactiontable_serializer(self) -> Optional[Any]:
+        """Get the MsActionTable serializer for this device.
+
+        Subclasses should override this to return their specific serializer.
+
+        Returns:
+            The serializer instance, or None if not supported.
+        """
+        return None
+
+    def _get_msactiontable(self) -> Optional[Any]:
+        """Get the MsActionTable for this device.
+
+        Subclasses should override this to return their msactiontable instance.
+
+        Returns:
+            The msactiontable instance, or None if not supported.
+        """
+        return None
+
+    def _handle_download_msactiontable_request(
+        self, request: SystemTelegram
+    ) -> Optional[str]:
+        """Handle F13D - DOWNLOAD_MSACTIONTABLE request.
+
+        Args:
+            request: The system telegram request to process.
+
+        Returns:
+            ACK telegram if request is valid, NAK otherwise.
+        """
+        serializer = self._get_msactiontable_serializer()
+        msactiontable = self._get_msactiontable()
+
+        # Only handle if serializer and msactiontable are available
+        if not serializer or msactiontable is None:
+            return None
+
+        # Send ACK and queue data telegram
+        ack_data = self._build_response_telegram(f"R{self.serial_number}F18D")  # ACK
+
+        # Send MsActionTable data
+        encoded_data = serializer.to_data(msactiontable)
+        data_telegram = self._build_response_telegram(
+            f"R{self.serial_number}F17D{encoded_data}"
+        )
+        self.msactiontable_download_state = "data_sent"
+
+        # Return ACK and TABLE
+        return ack_data + data_telegram
+
+    def _handle_download_msactiontable_ack_request(
+        self, _request: SystemTelegram
+    ) -> Optional[str]:
+        """Handle MsActionTable download ACK protocol.
+
+        Args:
+            _request: The system telegram request (unused, kept for signature consistency).
+
+        Returns:
+            Data telegram, EOF telegram, or NAK if state is invalid.
+        """
+        if self.msactiontable_download_state == "data_sent":
+            # Send EOF
+            eof_telegram = self._build_response_telegram(f"R{self.serial_number}F16D")
+            self.msactiontable_download_state = None
+            return eof_telegram
+
+        return self._build_response_telegram(f"R{self.serial_number}F19D")  # NAK
+
     def process_system_telegram(self, request: SystemTelegram) -> Optional[str]:
         """Template method for processing system telegrams.
 
@@ -177,6 +250,15 @@ class BaseServerService(ABC):
         elif request.system_function == SystemFunction.ACTION:
             return self._handle_action_request(request)
 
+        elif request.system_function == SystemFunction.DOWNLOAD_MSACTIONTABLE:
+            return self._handle_download_msactiontable_request(request)
+
+        elif (
+            request.system_function == SystemFunction.ACK
+            and self.msactiontable_download_state
+        ):
+            return self._handle_download_msactiontable_ack_request(request)
+
         self.logger.warning(f"Unhandled {self.device_type} request: {request}")
         return None
 
@@ -278,11 +360,7 @@ class BaseServerService(ABC):
         Returns:
             List of telegram strings from the buffer. The buffer is cleared after collection.
         """
-        self.logger.debug(
-            f"Collecting {self.serial_number} telegrams from buffer: {len(self.telegram_buffer)}"
-        )
         with self.telegram_buffer_lock:
             result = self.telegram_buffer.copy()
-            self.logger.debug(f"Resetting {self.serial_number} buffer")
             self.telegram_buffer.clear()
             return result

xp/services/server/cp20_server_service.py

@@ -8,6 +8,7 @@ from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
 from xp.models.telegram.system_telegram import SystemTelegram
+from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -25,11 +26,18 @@ class CP20ServerService(BaseServerService):
     and implements CP20 telegram format.
     """
 
-    def __init__(self, serial_number: str):
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        _msactiontable_serializer: Optional[MsActionTableSerializer] = None,
+    ):
         """Initialize CP20 server service.
 
         Args:
             serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            _msactiontable_serializer: Generic MsActionTable serializer (unused).
         """
         super().__init__(serial_number)
         self.device_type = "CP20"

xp/services/server/device_service_factory.py

@@ -0,0 +1,94 @@
+"""Device Service Factory for creating device instances.
+
+This module provides a factory for creating device service instances
+with proper dependency injection of serializers.
+"""
+
+from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
+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.server.base_server_service import BaseServerService
+from xp.services.server.cp20_server_service import CP20ServerService
+from xp.services.server.xp20_server_service import XP20ServerService
+from xp.services.server.xp24_server_service import XP24ServerService
+from xp.services.server.xp33_server_service import XP33ServerService
+from xp.services.server.xp130_server_service import XP130ServerService
+from xp.services.server.xp230_server_service import XP230ServerService
+
+
+class DeviceServiceFactory:
+    """Factory for creating device service instances.
+
+    Encapsulates device creation logic and handles serializer injection
+    for different device types.
+    """
+
+    def __init__(
+        self,
+        xp20ms_serializer: Xp20MsActionTableSerializer,
+        xp24ms_serializer: Xp24MsActionTableSerializer,
+        xp33ms_serializer: Xp33MsActionTableSerializer,
+        ms_serializer: MsActionTableSerializer,
+    ):
+        """Initialize device service factory.
+
+        Args:
+            xp20ms_serializer: XP20 MsActionTable serializer (injected via DI).
+            xp24ms_serializer: XP24 MsActionTable serializer (injected via DI).
+            xp33ms_serializer: XP33 MsActionTable serializer (injected via DI).
+            ms_serializer: Generic MsActionTable serializer (injected via DI).
+        """
+        self.xp20ms_serializer = xp20ms_serializer
+        self.xp24ms_serializer = xp24ms_serializer
+        self.xp33ms_serializer = xp33ms_serializer
+        self.ms_serializer = ms_serializer
+
+    def create_device(self, module_type: str, serial_number: str) -> BaseServerService:
+        """Create device instance for given module type.
+
+        Args:
+            module_type: Module type code (e.g., "XP20", "XP33LR").
+            serial_number: Device serial number.
+
+        Returns:
+            Device service instance configured with appropriate serializer.
+
+        Raises:
+            ValueError: If module_type is unknown or unsupported.
+        """
+        # Map module types to their constructors and parameters
+        if module_type == "CP20":
+            return CP20ServerService(serial_number, "CP20", self.ms_serializer)
+
+        elif module_type == "XP24":
+            return XP24ServerService(serial_number, "XP24", self.xp24ms_serializer)
+
+        elif module_type == "XP33":
+            return XP33ServerService(serial_number, "XP33", self.xp33ms_serializer)
+
+        elif module_type == "XP33LR":
+            return XP33ServerService(serial_number, "XP33LR", self.xp33ms_serializer)
+
+        elif module_type == "XP33LED":
+            return XP33ServerService(serial_number, "XP33LED", self.xp33ms_serializer)
+
+        elif module_type == "XP20":
+            return XP20ServerService(serial_number, "XP20", self.xp20ms_serializer)
+
+        elif module_type == "XP130":
+            return XP130ServerService(serial_number, "XP130", self.ms_serializer)
+
+        elif module_type == "XP230":
+            return XP230ServerService(serial_number, "XP230", self.ms_serializer)
+
+        else:
+            raise ValueError(
+                f"Unknown device type '{module_type}' for serial {serial_number}"
+            )

xp/services/server/server_service.py

@@ -8,19 +8,14 @@ import logging
 import socket
 import threading
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 from xp.models.homekit.homekit_conson_config import (
     ConsonModuleConfig,
     ConsonModuleListConfig,
 )
 from xp.services.server.base_server_service import BaseServerService
-from xp.services.server.cp20_server_service import CP20ServerService
-from xp.services.server.xp20_server_service import XP20ServerService
-from xp.services.server.xp24_server_service import XP24ServerService
-from xp.services.server.xp33_server_service import XP33ServerService
-from xp.services.server.xp130_server_service import XP130ServerService
-from xp.services.server.xp230_server_service import XP230ServerService
+from xp.services.server.device_service_factory import DeviceServiceFactory
 from xp.services.telegram.telegram_discover_service import TelegramDiscoverService
 from xp.services.telegram.telegram_service import TelegramService
 
@@ -43,6 +38,7 @@ class ServerService:
         self,
         telegram_service: TelegramService,
         discover_service: TelegramDiscoverService,
+        device_factory: DeviceServiceFactory,
         config_path: str = "server.yml",
         port: int = 10001,
     ):
@@ -51,25 +47,21 @@ class ServerService:
         Args:
             telegram_service: Service for parsing system telegrams.
             discover_service: Service for handling discover requests.
+            device_factory: Factory for creating device service instances (injected via DI).
             config_path: Path to the server configuration file.
             port: TCP port to listen on.
         """
         self.telegram_service = telegram_service
         self.discover_service = discover_service
+        self.device_factory = device_factory
         self.config_path = config_path
         self.port = port
         self.server_socket: Optional[socket.socket] = None
         self.is_running = False
         self.devices: List[ConsonModuleConfig] = []
-        self.device_services: Dict[
-            str,
-            Union[
-                BaseServerService,
-                XP33ServerService,
-                XP20ServerService,
-                XP130ServerService,
-            ],
-        ] = {}  # serial -> device service instance
+        self.device_services: Dict[str, BaseServerService] = (
+            {}
+        )  # serial -> device service instance
 
         # Collect device buffer to broadcast to client
         self.collector_thread: Optional[threading.Thread] = (
@@ -112,44 +104,14 @@ class ServerService:
             serial_number = module.serial_number
 
             try:
+                # Use factory to create device instance
+                self.device_services[serial_number] = self.device_factory.create_device(
+                    module_type, serial_number
+                )
 
-                # Serial number is already a string from config
-                if module_type == "CP20":
-                    self.device_services[serial_number] = CP20ServerService(
-                        serial_number
-                    )
-                if module_type == "XP24":
-                    self.device_services[serial_number] = XP24ServerService(
-                        serial_number
-                    )
-                elif module_type == "XP33":
-                    self.device_services[serial_number] = XP33ServerService(
-                        serial_number, "XP33"
-                    )
-                elif module_type == "XP33LR":
-                    self.device_services[serial_number] = XP33ServerService(
-                        serial_number, "XP33LR"
-                    )
-                elif module_type == "XP33LED":
-                    self.device_services[serial_number] = XP33ServerService(
-                        serial_number, "XP33LED"
-                    )
-                elif module_type == "XP20":
-                    self.device_services[serial_number] = XP20ServerService(
-                        serial_number
-                    )
-                elif module_type == "XP130":
-                    self.device_services[serial_number] = XP130ServerService(
-                        serial_number
-                    )
-                elif module_type == "XP230":
-                    self.device_services[serial_number] = XP230ServerService(
-                        serial_number
-                    )
-                else:
-                    self.logger.warning(
-                        f"Unknown device type '{module_type}' for serial {serial_number}"
-                    )
+            except ValueError as e:
+                # Factory raises ValueError for unknown device types
+                self.logger.warning(str(e))
 
             except Exception as e:
                 self.logger.error(
@@ -247,14 +209,11 @@ class ServerService:
                     self.logger.debug(f"Sent buffer to {client_address}")
 
                 # Receive data from client
-                self.logger.debug(f"Receiving data {client_address}")
                 data = None
                 try:
                     data = client_socket.recv(1024)
                 except socket.timeout:
-                    self.logger.debug(
-                        f"Timeout receiving data {client_address} ({timeout})"
-                    )
+                    pass
                 finally:
                     timeout -= 1
 
@@ -459,9 +418,6 @@ class ServerService:
         self.logger.info("Collector thread starting")
 
         while True:
-            self.logger.debug(
-                f"Collector thread collecting ({len(self.collector_buffer)})"
-            )
             collected = 0
             for device_service in self.device_services.values():
                 telegram_buffer = device_service.collect_telegram_buffer()
@@ -469,5 +425,4 @@ class ServerService:
                 collected += len(telegram_buffer)
 
             # Wait a bit before checking again
-            self.logger.debug(f"Collector thread collected ({collected})")
             self.collector_stop_event.wait(timeout=1)

xp/services/server/xp130_server_service.py

@@ -5,9 +5,10 @@ including response generation and device configuration handling.
 XP130 is an Ethernet/TCPIP interface module.
 """
 
-from typing import Dict
+from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
+from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -25,11 +26,18 @@ class XP130ServerService(BaseServerService):
     and implements XP130 telegram format for Ethernet/TCPIP interface module.
     """
 
-    def __init__(self, serial_number: str):
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        _msactiontable_serializer: Optional[MsActionTableSerializer] = None,
+    ):
         """Initialize XP130 server service.
 
         Args:
             serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            _msactiontable_serializer: Generic MsActionTable serializer (unused).
         """
         super().__init__(serial_number)
         self.device_type = "XP130"

xp/services/server/xp20_server_service.py

@@ -4,9 +4,13 @@ This service provides XP20-specific device emulation functionality,
 including response generation and device configuration handling.
 """
 
-from typing import Dict
+from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
+from xp.models.actiontable.msactiontable_xp20 import Xp20MsActionTable
+from xp.services.actiontable.msactiontable_xp20_serializer import (
+    Xp20MsActionTableSerializer,
+)
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -24,17 +28,55 @@ class XP20ServerService(BaseServerService):
     and implements XP20 telegram format.
     """
 
-    def __init__(self, serial_number: str):
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        msactiontable_serializer: Optional[Xp20MsActionTableSerializer] = None,
+    ):
         """Initialize XP20 server service.
 
         Args:
             serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            msactiontable_serializer: MsActionTable serializer (injected via DI).
         """
         super().__init__(serial_number)
         self.device_type = "XP20"
         self.module_type_code = ModuleTypeCode.XP20  # XP20 module type from registry
         self.firmware_version = "XP20_V0.01.05"
 
+        # MsActionTable support
+        self.msactiontable_serializer = (
+            msactiontable_serializer or Xp20MsActionTableSerializer()
+        )
+        self.msactiontable = self._get_default_msactiontable()
+
+    def _get_msactiontable_serializer(self) -> Optional[Xp20MsActionTableSerializer]:
+        """Get the MsActionTable serializer for XP20.
+
+        Returns:
+            The XP20 MsActionTable serializer instance.
+        """
+        return self.msactiontable_serializer
+
+    def _get_msactiontable(self) -> Optional[Xp20MsActionTable]:
+        """Get the MsActionTable for XP20.
+
+        Returns:
+            The XP20 MsActionTable instance.
+        """
+        return self.msactiontable
+
+    def _get_default_msactiontable(self) -> Xp20MsActionTable:
+        """Generate default MsActionTable configuration.
+
+        Returns:
+            Default XP20 MsActionTable with all inputs unconfigured.
+        """
+        # All inputs unconfigured (all flags False, AND functions empty)
+        return Xp20MsActionTable()
+
     def get_device_info(self) -> Dict:
         """Get XP20 device information.
 

xp/services/server/xp230_server_service.py

@@ -4,9 +4,10 @@ This service provides XP230-specific device emulation functionality,
 including response generation and device configuration handling.
 """
 
-from typing import Dict
+from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
+from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -24,11 +25,18 @@ class XP230ServerService(BaseServerService):
     and implements XP230 telegram format.
     """
 
-    def __init__(self, serial_number: str):
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        _msactiontable_serializer: Optional[MsActionTableSerializer] = None,
+    ):
         """Initialize XP230 server service.
 
         Args:
             serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            _msactiontable_serializer: Generic MsActionTable serializer (unused).
         """
         super().__init__(serial_number)
         self.device_type = "XP230"

xp/services/server/xp24_server_service.py

@@ -7,9 +7,15 @@ including response generation and device configuration handling.
 from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
+from xp.models.actiontable.msactiontable_xp24 import InputAction, Xp24MsActionTable
 from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.input_action_type import InputActionType
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.system_telegram import SystemTelegram
+from xp.models.telegram.timeparam_type import TimeParam
+from xp.services.actiontable.msactiontable_xp24_serializer import (
+    Xp24MsActionTableSerializer,
+)
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -37,11 +43,18 @@ class XP24ServerService(BaseServerService):
     and implements XP24 telegram format.
     """
 
-    def __init__(self, serial_number: str):
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        msactiontable_serializer: Optional[Xp24MsActionTableSerializer] = None,
+    ):
         """Initialize XP24 server service.
 
         Args:
             serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            msactiontable_serializer: MsActionTable serializer (injected via DI).
         """
         super().__init__(serial_number)
         self.device_type = "XP24"
@@ -53,6 +66,12 @@ class XP24ServerService(BaseServerService):
         self.output_2: XP24Output = XP24Output()
         self.output_3: XP24Output = XP24Output()
 
+        # MsActionTable support
+        self.msactiontable_serializer = (
+            msactiontable_serializer or Xp24MsActionTableSerializer()
+        )
+        self.msactiontable = self._get_default_msactiontable()
+
     def _handle_device_specific_action_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
@@ -175,6 +194,40 @@ class XP24ServerService(BaseServerService):
             f"{1 if self.output_3.state else 0}"
         )
 
+    def _get_msactiontable_serializer(self) -> Optional[Xp24MsActionTableSerializer]:
+        """Get the MsActionTable serializer for XP24.
+
+        Returns:
+            The XP24 MsActionTable serializer instance.
+        """
+        return self.msactiontable_serializer
+
+    def _get_msactiontable(self) -> Optional[Xp24MsActionTable]:
+        """Get the MsActionTable for XP24.
+
+        Returns:
+            The XP24 MsActionTable instance.
+        """
+        return self.msactiontable
+
+    def _get_default_msactiontable(self) -> Xp24MsActionTable:
+        """Generate default MsActionTable configuration.
+
+        Returns:
+            Default XP24 MsActionTable with all inputs set to VOID.
+        """
+        return Xp24MsActionTable(
+            input1_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
+            input2_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
+            input3_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
+            input4_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
+            mutex12=False,
+            mutex34=False,
+            curtain12=False,
+            curtain34=False,
+            mutual_deadtime=12,  # MS300
+        )
+
     def get_device_info(self) -> Dict:
         """Get XP24 device information.
 

xp/services/server/xp33_server_service.py

@@ -10,9 +10,13 @@ import threading
 from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
+from xp.models.actiontable.msactiontable_xp33 import Xp33MsActionTable
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.system_telegram import SystemTelegram
+from xp.services.actiontable.msactiontable_xp33_serializer import (
+    Xp33MsActionTableSerializer,
+)
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -30,12 +34,18 @@ class XP33ServerService(BaseServerService):
     and implements XP33 telegram format for 3-channel dimmer modules.
     """
 
-    def __init__(self, serial_number: str, variant: str = "XP33LR"):
+    def __init__(
+        self,
+        serial_number: str,
+        variant: str = "XP33LR",
+        msactiontable_serializer: Optional[Xp33MsActionTableSerializer] = None,
+    ):
         """Initialize XP33 server service.
 
         Args:
             serial_number: The device serial number.
             variant: Device variant (XP33, XP33LR, or XP33LED).
+            msactiontable_serializer: MsActionTable serializer (injected via DI).
         """
         super().__init__(serial_number)
         self.variant = variant  # XP33 or XP33LR or XP33LED
@@ -85,6 +95,12 @@ class XP33ServerService(BaseServerService):
         self.client_sockets_lock = threading.Lock()  # Lock for socket set
         self.storm_packets_sent = 0  # Counter for packets sent during storm
 
+        # MsActionTable support
+        self.msactiontable_serializer = (
+            msactiontable_serializer or Xp33MsActionTableSerializer()
+        )
+        self.msactiontable = self._get_default_msactiontable()
+
     def _handle_device_specific_action_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
@@ -449,6 +465,31 @@ class XP33ServerService(BaseServerService):
             return True
         return False
 
+    def _get_msactiontable_serializer(self) -> Optional[Xp33MsActionTableSerializer]:
+        """Get the MsActionTable serializer for XP33.
+
+        Returns:
+            The XP33 MsActionTable serializer instance.
+        """
+        return self.msactiontable_serializer
+
+    def _get_msactiontable(self) -> Optional[Xp33MsActionTable]:
+        """Get the MsActionTable for XP33.
+
+        Returns:
+            The XP33 MsActionTable instance.
+        """
+        return self.msactiontable
+
+    def _get_default_msactiontable(self) -> Xp33MsActionTable:
+        """Generate default MsActionTable configuration.
+
+        Returns:
+            Default XP33 MsActionTable with all outputs at 0-100% range, no scenes configured.
+        """
+        # All outputs at 0-100% range, no scenes configured
+        return Xp33MsActionTable()
+
     def get_device_info(self) -> Dict:
         """Get XP33 device information.
 

xp/services/telegram/telegram_service.py

@@ -3,6 +3,7 @@
 This module provides telegram parsing functionality for event, system, and reply telegrams.
 """
 
+import logging
 import re
 from typing import Union
 
@@ -48,7 +49,8 @@ class TelegramService:
 
     def __init__(self) -> None:
         """Initialize the telegram service."""
-        pass
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
 
     def parse_event_telegram(self, raw_telegram: str) -> EventTelegram:
         """Parse a raw telegram string into an EventTelegram object.
@@ -242,6 +244,7 @@ class TelegramService:
             raise TelegramParsingError("Empty telegram string")
 
         # Validate and parse using regex
+        self.logger.debug(f"Parsing reply telegram {raw_telegram}")
         match = self.REPLY_TELEGRAM_PATTERN.match(raw_telegram.strip())
         if not match:
             raise TelegramParsingError(f"Invalid reply telegram format: {raw_telegram}")

xp/utils/dependencies.py

@@ -9,18 +9,19 @@ from twisted.internet.posixbase import PosixReactorBase
 from xp.models import ConbusClientConfig
 from xp.models.homekit.homekit_config import HomekitConfig
 from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
-from xp.services.conbus.actiontable.actiontable_serializer import ActionTableSerializer
-from xp.services.conbus.actiontable.actiontable_service import ActionTableService
-from xp.services.conbus.actiontable.msactiontable_service import MsActionTableService
-from xp.services.conbus.actiontable.msactiontable_xp20_serializer import (
+from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
+from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
+from xp.services.actiontable.msactiontable_xp20_serializer import (
     Xp20MsActionTableSerializer,
 )
-from xp.services.conbus.actiontable.msactiontable_xp24_serializer import (
+from xp.services.actiontable.msactiontable_xp24_serializer import (
     Xp24MsActionTableSerializer,
 )
-from xp.services.conbus.actiontable.msactiontable_xp33_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.msactiontable_service import MsActionTableService
 from xp.services.conbus.conbus_blink_all_service import ConbusBlinkAllService
 from xp.services.conbus.conbus_blink_service import ConbusBlinkService
 from xp.services.conbus.conbus_custom_service import ConbusCustomService
@@ -49,6 +50,7 @@ from xp.services.module_type_service import ModuleTypeService
 from xp.services.protocol.protocol_factory import TelegramFactory
 from xp.services.protocol.telegram_protocol import TelegramProtocol
 from xp.services.reverse_proxy_service import ReverseProxyService
+from xp.services.server.device_service_factory import DeviceServiceFactory
 from xp.services.server.server_service import ServerService
 from xp.services.telegram.telegram_blink_service import TelegramBlinkService
 from xp.services.telegram.telegram_discover_service import TelegramDiscoverService
@@ -324,12 +326,31 @@ class ServiceContainer:
         # Module type services layer
         self.container.register(ModuleTypeService, scope=punq.Scope.singleton)
 
+        # MsActionTable serializers
+        self.container.register(MsActionTableSerializer, scope=punq.Scope.singleton)
+        self.container.register(Xp20MsActionTableSerializer, scope=punq.Scope.singleton)
+        self.container.register(Xp24MsActionTableSerializer, scope=punq.Scope.singleton)
+        self.container.register(Xp33MsActionTableSerializer, scope=punq.Scope.singleton)
+
+        # Device service factory
+        self.container.register(
+            DeviceServiceFactory,
+            factory=lambda: DeviceServiceFactory(
+                xp20ms_serializer=self.container.resolve(Xp20MsActionTableSerializer),
+                xp24ms_serializer=self.container.resolve(Xp24MsActionTableSerializer),
+                xp33ms_serializer=self.container.resolve(Xp33MsActionTableSerializer),
+                ms_serializer=self.container.resolve(MsActionTableSerializer),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         # Server services layer
         self.container.register(
             ServerService,
             factory=lambda: ServerService(
                 telegram_service=self.container.resolve(TelegramService),
                 discover_service=self.container.resolve(TelegramDiscoverService),
+                device_factory=self.container.resolve(DeviceServiceFactory),
                 config_path="server.yml",
                 port=self._server_port,
             ),