conson-xp 1.3.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

{conson_xp-1.3.0.dist-info → conson_xp-1.4.0.dist-info}/METADATA

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

{conson_xp-1.3.0.dist-info → conson_xp-1.4.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-conson_xp-1.3.0.dist-info/METADATA,sha256=vbTIsfypeY2WgsmWOGOeLT0pMaLOtQAh0PGVDTpkUzA,9274
-conson_xp-1.3.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-conson_xp-1.3.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.3.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=zgW0EVZ8tN8g8HSuCLDaoFIBrf1aZ7IwB6_185Hu2yk,180
+conson_xp-1.4.0.dist-info/METADATA,sha256=gVe0dQdYUIfvh1zZ9TLnHgL1bMgCbwaBQDlbnMTGIig,9274
+conson_xp-1.4.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+conson_xp-1.4.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.4.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=K0b80vyQTL1NHu42mglJvDuAouKQOPKpfKPus7iPCEg,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
@@ -64,7 +64,7 @@ xp/models/conbus/conbus_client_config.py,sha256=fWPmHM-OVUzSASKq667JzP7e9_Qp9ZUy
 xp/models/conbus/conbus_connection_status.py,sha256=iGbmtBaAMwV6UD7XG3H3tnB0fl2MR8rJhpjrLH2KjsE,1097
 xp/models/conbus/conbus_custom.py,sha256=8H2sPR6_LIlksuOvL7-8bPkzAJLR0rpYiiwfYYFVjEo,1965
 xp/models/conbus/conbus_datapoint.py,sha256=4ncR-vB2lRzRBAA30rYn8eguyTxsZoOKrrXtjGmPpWg,3396
-xp/models/conbus/conbus_discover.py,sha256=oYIHLLsXmgSQHrayS-JgcEpEaK_01Q1WTQEQj79h4j4,1642
+xp/models/conbus/conbus_discover.py,sha256=nxxUEKfEsH1kd0BF8ovMs7zLujRhrq1oL9ZJtysPr5o,2238
 xp/models/conbus/conbus_lightlevel.py,sha256=GQGhzrCBEJROosNHInXIzBy6MD2AskEIMoFEGgZ60-0,1695
 xp/models/conbus/conbus_linknumber.py,sha256=uFzKzfB06oIzZEKCb5X2JEI80JjMPFuYglsT1W1k8j4,1815
 xp/models/conbus/conbus_output.py,sha256=q7QKsD_CWT7YOk-V3otKWD1VM7qThrSLIUOunntMrMc,1953
@@ -91,7 +91,7 @@ xp/models/telegram/module_type_code.py,sha256=bg8Zi58yKs5DDnEF0bGnZ9vvpqzmIZzd1k
 xp/models/telegram/output_telegram.py,sha256=vTSdeAGk7va89pZ8-oh0cna98N3T6if-6UcrstWsN6s,3473
 xp/models/telegram/reply_telegram.py,sha256=oqNwDvaOhFTPuXL0fP9Ca3rbcKepDhRz9kIneKCk6n0,10376
 xp/models/telegram/system_function.py,sha256=Iv9u4sYCPnMcvlpbBrNNxu0NpUOFsi5kPgT2vrelbVw,3266
-xp/models/telegram/system_telegram.py,sha256=oYW9xfY4ldlid0XQ5D5ymk0-a9Jvr5EHD9O4Cb6JOPk,3192
+xp/models/telegram/system_telegram.py,sha256=9FNQ4Mf47mRK7wGrTg2GzziVsrEWCE5ZkZp5kA7K3w0,3218
 xp/models/telegram/telegram.py,sha256=IJUxHX6ftLcET9C1pjvLhUO5Db5JO6W7rUItzdEW30I,842
 xp/models/telegram/telegram_type.py,sha256=GhqKP63oNMyh2tIvCPcsC5RFp4s4JjhmEqCLCC-8XMk,423
 xp/models/telegram/timeparam_type.py,sha256=Ar8xvSfPmOAgR2g2Je0FgvP01SL7bPvZn5_HrVDpmJM,1137
@@ -110,11 +110,11 @@ xp/services/conbus/conbus_blink_service.py,sha256=x9uM-sLnIEV8wSNsvJgo08E042g-Hh
 xp/services/conbus/conbus_custom_service.py,sha256=4aneYdPObiZOGxPFYg5Wr70cl_xFxlQIdJBPQSa0enI,5826
 xp/services/conbus/conbus_datapoint_queryall_service.py,sha256=p9R02cVimhdJILHQ6BoeZj8Hog4oRpqBnMo3t4R8ecY,6816
 xp/services/conbus/conbus_datapoint_service.py,sha256=NsqRQfNsZ4_Pbe7kcMQpUqfhVPH7H148JDWH49ExQ1E,6392
-xp/services/conbus/conbus_discover_service.py,sha256=0rdGLZfi-gsjBeuFiUwGz0tUC85hbZUDxJ93ImBmq4U,5239
+xp/services/conbus/conbus_discover_service.py,sha256=lH6I8YcN7Beo_f-M8XkNZ_5UuNB-x2R9U5xJNTK-QXE,10110
 xp/services/conbus/conbus_output_service.py,sha256=mHFOAPx2zo0TStZ3pokp6v94AQjIamcwZDeg5YH_-eo,7240
 xp/services/conbus/conbus_raw_service.py,sha256=4yZLLTIAOxpgByUTWZXw1ihGa6Xtl98ckj9T7VfprDI,4335
 xp/services/conbus/conbus_receive_service.py,sha256=frXrS0OyKKvYYQTWdma21Kd0BKw5aSuHn3ZXTTqOaj0,3953
-xp/services/conbus/conbus_scan_service.py,sha256=43Bhj7pVDOjIS2MdlD7iDvNK7Gy5KxX1qB8hiTwY5LQ,5186
+xp/services/conbus/conbus_scan_service.py,sha256=tHJ5qaxcNXxAZb2D2F1v6IrzydfxjJOYllM6Txt1eBE,5176
 xp/services/conbus/write_config_service.py,sha256=qe5TwQdVnMCcJ4lCeZLADdUeoDpbEaV3XoZ19a3F_qk,7128
 xp/services/homekit/__init__.py,sha256=xAMKmln_AmEFdOOJGKWYi96seRlKDQpKx3-hm7XbdIo,36
 xp/services/homekit/homekit_cache_service.py,sha256=NdijyH5_iyhsTHBb-OyT8Y2xnNDj8F5MP8neoVQ26hY,11010
@@ -135,17 +135,17 @@ xp/services/module_type_service.py,sha256=xWhr1EAZMykL5uNWHWdpa5T8yNruGKH43XRTOS
 xp/services/protocol/__init__.py,sha256=WuYn2iEcvsOIXnn5HCrU9kD3PjuMX1sIh0ljKISDoJw,720
 xp/services/protocol/conbus_protocol.py,sha256=G39YPMpwhvvhFPYrzNxx6y2Is6DSP2UyCLm4T7RLPVc,10404
 xp/services/protocol/protocol_factory.py,sha256=PmjN9AtW9sxNo3voqUiNgQA-pTvX1RW4XXFlHKfFr5Q,2470
-xp/services/protocol/telegram_protocol.py,sha256=JKYxGbO2h3muIroYPYxS7An_BNfriXKLf3u0gdN_KnQ,9462
+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=HQKx4DW6lJ25dGofjaB_3HHPvEZGbL1XeQ20wU5k_z0,8755
-xp/services/server/cp20_server_service.py,sha256=AQhfHBqXQsVL5emkXfSLdjlKaAIWtXXKqyxYNKNKWpQ,1624
-xp/services/server/server_service.py,sha256=4lhd8feL7eRR5GZIiuag51z5W20KlGRrIGICgvOXwAQ,12459
-xp/services/server/xp130_server_service.py,sha256=QbkOykAdYqSSOeI7uq3g-qy1zlXSB9mjWBfRz1esPis,1764
-xp/services/server/xp20_server_service.py,sha256=w8LF6vl6jNeKKlrUVdv-2Tk1qq9DMfe40PiPps6kq84,1374
-xp/services/server/xp230_server_service.py,sha256=n8eqmyWWVYVuLl-N3gu1zA0-Viifyo5VyMrGXLcvpgc,1388
-xp/services/server/xp24_server_service.py,sha256=ygYym0oCzmHaVwDbl-XAZYyFlLLwyycMAO8g8D1q2iU,3806
-xp/services/server/xp33_server_service.py,sha256=qswOUv3YS5pT6rDoony49EC-MFKJZKPo7DI3fKG74ts,6307
+xp/services/server/base_server_service.py,sha256=6RmL7bLRqdjEZgIf7lBwwBOdrpQMWhdQnpuF01469M8,8921
+xp/services/server/cp20_server_service.py,sha256=PkdkORQ-aIHtQb-wuAgkRxKcdpNWpvys_p1sXJg0yoI,1679
+xp/services/server/server_service.py,sha256=K25vq6B83n-iwYwEsani5KLULp9DBUBIoAzrYmXmUJ8,14688
+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=DneRmJEd7oZGxC-Tj8KqAt54wEQwSUzKuCFMSEf2_bI,11069
 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
@@ -161,4 +161,4 @@ xp/utils/dependencies.py,sha256=4G7r0m1HY9UV4E0zLS8L-axcNiX2mM-N6OOAU8dVHVM,1774
 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.3.0.dist-info/RECORD,,
+conson_xp-1.4.0.dist-info/RECORD,,

xp/__init__.py

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

xp/models/conbus/conbus_discover.py

@@ -2,7 +2,23 @@
 
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, TypedDict
+
+
+class DiscoveredDevice(TypedDict):
+    """Discovered device information.
+
+    Attributes:
+        serial_number: Serial number of the device.
+        module_type: Module type name (e.g., "XP24", "XP230"), None if not yet retrieved.
+        module_type_code: Module type code (e.g., "13", "10"), None if not yet retrieved.
+        module_type_name: Module type name converted from module_type_code, None if not yet retrieved.
+    """
+
+    serial_number: str
+    module_type: Optional[str]
+    module_type_code: Optional[int]
+    module_type_name: Optional[str]
 
 
 @dataclass
@@ -13,7 +29,7 @@ class ConbusDiscoverResponse:
         success: Whether the operation was successful.
         sent_telegram: Telegram sent to discover devices.
         received_telegrams: List of telegrams received.
-        discovered_devices: List of discovered device serial numbers.
+        discovered_devices: List of discovered devices with their module types.
         error: Error message if operation failed.
         timestamp: Timestamp of the response.
     """
@@ -21,7 +37,7 @@ class ConbusDiscoverResponse:
     success: bool
     sent_telegram: Optional[str] = None
     received_telegrams: Optional[list[str]] = None
-    discovered_devices: Optional[list[str]] = None
+    discovered_devices: Optional[list[DiscoveredDevice]] = None
     error: Optional[str] = None
     timestamp: Optional[datetime] = None
 

xp/models/telegram/system_telegram.py

@@ -22,10 +22,10 @@ class SystemTelegram(Telegram):
     Examples: <S0020012521F02D18FN>
 
     Attributes:
-        serial_number: Serial number of the device.
-        system_function: System function code.
-        data: Data payload.
-        datapoint_type: Type of datapoint.
+        serial_number: Serial number of the device (0020012521)
+        system_function: System function code (02).
+        data: Data payload (18)
+        datapoint_type: Type of datapoint (18).
     """
 
     serial_number: str = ""

xp/services/conbus/conbus_discover_service.py

@@ -10,7 +10,10 @@ from typing import Callable, Optional
 from twisted.internet.posixbase import PosixReactorBase
 
 from xp.models import ConbusClientConfig, ConbusDiscoverResponse
+from xp.models.conbus.conbus_discover import DiscoveredDevice
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.module_type_code import MODULE_TYPE_REGISTRY
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
 from xp.services.protocol.conbus_protocol import ConbusProtocol
@@ -73,6 +76,7 @@ class ConbusDiscoverService(ConbusProtocol):
             self.discovered_device_result.received_telegrams = []
         self.discovered_device_result.received_telegrams.append(telegram_received.frame)
 
+        # Check for discovery response
         if (
             telegram_received.checksum_valid
             and telegram_received.telegram_type == TelegramType.REPLY.value
@@ -80,8 +84,30 @@ class ConbusDiscoverService(ConbusProtocol):
             and len(telegram_received.payload) == 15
         ):
             self.discovered_device(telegram_received.serial_number)
+
+        # Check for module type response (F02D07)
+        elif (
+            telegram_received.checksum_valid
+            and telegram_received.telegram_type == TelegramType.REPLY.value
+            and telegram_received.payload[11:17] == "F02D07"
+            and len(telegram_received.payload) >= 19
+        ):
+            self.handle_module_type_code_response(
+                telegram_received.serial_number, telegram_received.payload[17:19]
+            )
+        # Check for module type response (F02D00)
+        elif (
+            telegram_received.checksum_valid
+            and telegram_received.telegram_type == TelegramType.REPLY.value
+            and telegram_received.payload[11:17] == "F02D00"
+            and len(telegram_received.payload) >= 19
+        ):
+            self.handle_module_type_response(
+                telegram_received.serial_number, telegram_received.payload[17:19]
+            )
+
         else:
-            self.logger.debug("Not a discover response")
+            self.logger.debug("Not a discover or module type response")
 
     def discovered_device(self, serial_number: str) -> None:
         """Handle discovered device event.
@@ -92,10 +118,102 @@ class ConbusDiscoverService(ConbusProtocol):
         self.logger.info("discovered_device: %s", serial_number)
         if not self.discovered_device_result.discovered_devices:
             self.discovered_device_result.discovered_devices = []
-        self.discovered_device_result.discovered_devices.append(serial_number)
+
+        # Add device with module_type as None initially
+        device: DiscoveredDevice = {
+            "serial_number": serial_number,
+            "module_type": None,
+            "module_type_code": None,
+            "module_type_name": None,
+        }
+        self.discovered_device_result.discovered_devices.append(device)
+
+        # Send READ_DATAPOINT telegram to query module type
+        self.logger.debug(f"Sending module type query for {serial_number}")
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_TYPE.value,
+        )
+
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_TYPE_CODE.value,
+        )
+
         if self.progress_callback:
             self.progress_callback(serial_number)
 
+    def handle_module_type_code_response(
+        self, serial_number: str, module_type_code: str
+    ) -> None:
+        """Handle module type code response and update discovered device.
+
+        Args:
+            serial_number: Serial number of the device.
+            module_type_code: Module type code from telegram (e.g., "07", "24").
+        """
+        self.logger.info(
+            f"Received module type code {module_type_code} for {serial_number}"
+        )
+
+        # Convert module type code to name
+        code = 0
+        try:
+            # The telegram format uses decimal values represented as strings
+            code = int(module_type_code)
+            module_info = MODULE_TYPE_REGISTRY.get(code)
+
+            if module_info:
+                module_type_name = module_info["name"]
+                self.logger.debug(
+                    f"Module type code {module_type_code} ({code}) = {module_type_name}"
+                )
+            else:
+                module_type_name = f"UNKNOWN_{module_type_code}"
+                self.logger.warning(
+                    f"Unknown module type code {module_type_code} ({code})"
+                )
+
+        except ValueError:
+            self.logger.error(
+                f"Invalid module type code format: {module_type_code} for {serial_number}"
+            )
+            module_type_name = f"INVALID_{module_type_code}"
+
+        # Find and update the device in discovered_devices
+        if self.discovered_device_result.discovered_devices:
+            for device in self.discovered_device_result.discovered_devices:
+                if device["serial_number"] == serial_number:
+                    device["module_type_code"] = code
+                    device["module_type_name"] = module_type_name
+                    self.logger.debug(
+                        f"Updated device {serial_number} with module_type {module_type_name}"
+                    )
+                    break
+
+    def handle_module_type_response(self, serial_number: str, module_type: str) -> None:
+        """Handle module type response and update discovered device.
+
+        Args:
+            serial_number: Serial number of the device.
+            module_type: Module type code from telegram (e.g., "XP33", "XP24").
+        """
+        self.logger.info(f"Received module type {module_type} for {serial_number}")
+
+        # Find and update the device in discovered_devices
+        if self.discovered_device_result.discovered_devices:
+            for device in self.discovered_device_result.discovered_devices:
+                if device["serial_number"] == serial_number:
+                    device["module_type"] = module_type
+                    self.logger.debug(
+                        f"Updated device {serial_number} with module_type {module_type}"
+                    )
+                    break
+
     def timeout(self) -> bool:
         """Handle timeout event to stop discovery.
 

xp/services/conbus/conbus_scan_service.py

@@ -128,7 +128,7 @@ class ConbusScanService(ConbusProtocol):
         function_code: str,
         progress_callback: Callable[[str], None],
         finish_callback: Callable[[ConbusResponse], None],
-        timeout_seconds: Optional[float] = None,
+        timeout_seconds: float = 0.25,
     ) -> None:
         """Scan a module for all datapoints by function code.
 

xp/services/protocol/telegram_protocol.py

@@ -124,7 +124,7 @@ class TelegramProtocol(protocol.Protocol):
             payload = telegram[:-2]  # S0123450001F02D12
             checksum = telegram[-2:].decode()  # FK
             serial_number = (
-                telegram[1:11] if telegram_type in "S" else b""
+                telegram[1:11] if telegram_type in ("S", "R") else b""
             )  # 0123450001
             calculated_checksum = calculate_checksum(payload.decode(encoding="latin-1"))
 
@@ -151,9 +151,9 @@ class TelegramProtocol(protocol.Protocol):
             await self.event_bus.dispatch(
                 TelegramReceivedEvent(
                     protocol=self,
-                    frame=frame.decode(),
-                    telegram=telegram.decode(),
-                    payload=payload.decode(),
+                    frame=frame.decode("latin-1"),
+                    telegram=telegram.decode("latin-1"),
+                    payload=payload.decode("latin-1"),
                     telegram_type=telegram_type,
                     serial_number=serial_number,
                     checksum=checksum,

xp/services/server/base_server_service.py

@@ -8,6 +8,7 @@ import logging
 from abc import ABC
 from typing import Optional
 
+from xp.models import ModuleTypeCode
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.system_telegram import SystemTelegram
@@ -33,7 +34,7 @@ class BaseServerService(ABC):
 
         # Must be set by subclasses
         self.device_type: str = ""
-        self.module_type_code: int = 0
+        self.module_type_code: ModuleTypeCode = ModuleTypeCode.NOMOD
         self.hardware_version: str = ""
         self.software_version: str = ""
         self.device_status: str = "OK"
@@ -54,11 +55,11 @@ class BaseServerService(ABC):
         """
         datapoint_values = {
             DataPointType.TEMPERATURE: self.temperature,
-            DataPointType.MODULE_TYPE_CODE: f"{self.module_type_code:02X}",
+            DataPointType.MODULE_TYPE_CODE: f"{self.module_type_code.value:02}",
             DataPointType.SW_VERSION: self.software_version,
             DataPointType.MODULE_STATE: self.device_status,
             DataPointType.MODULE_TYPE: self.device_type,
-            DataPointType.LINK_NUMBER: f"{self.link_number:02X}",
+            DataPointType.LINK_NUMBER: f"{self.link_number:02}",
             DataPointType.VOLTAGE: self.voltage,
             DataPointType.HW_VERSION: self.hardware_version,
             DataPointType.MODULE_ERROR_CODE: "00",
@@ -187,11 +188,15 @@ class BaseServerService(ABC):
         self.logger.debug(
             f"_handle_return_data_request {self.device_type} request: {request}"
         )
+        module_specific = self._handle_device_specific_data_request(request)
+        if module_specific:
+            return module_specific
+
         if request.datapoint_type:
             return self.generate_datapoint_type_response(request.datapoint_type)
 
         # Allow device-specific handlers
-        return self._handle_device_specific_data_request(request)
+        return None
 
     def _handle_device_specific_data_request(
         self, request: SystemTelegram

xp/services/server/cp20_server_service.py

@@ -6,6 +6,7 @@ including response generation and device configuration handling.
 
 from typing import Dict, Optional
 
+from xp.models import ModuleTypeCode
 from xp.models.telegram.system_telegram import SystemTelegram
 from xp.services.server.base_server_service import BaseServerService
 
@@ -32,7 +33,7 @@ class CP20ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "CP20"
-        self.module_type_code = 2  # CP20 module type from registry
+        self.module_type_code = ModuleTypeCode.CP20  # CP20 module type from registry
         self.firmware_version = "CP20_V0.01.05"
 
     def _handle_device_specific_data_request(

xp/services/server/server_service.py

@@ -253,15 +253,86 @@ class ServerService:
                 self.logger.error(f"Error closing client socket: {e}")
 
     def _process_request(self, message: str) -> List[str]:
-        """Process incoming request and generate responses."""
+        """Process incoming request and generate responses.
+
+        Args:
+            message: Message potentially containing multiple telegrams in format <TELEGRAM><TELEGRAM2>...
+
+        Returns:
+            List of responses for all processed telegrams.
+        """
+        responses: list[str] = []
+
+        try:
+            # Split message into individual telegrams (enclosed in angle brackets)
+            telegrams = self._split_telegrams(message)
+
+            if not telegrams:
+                self.logger.warning(f"No valid telegrams found in message: {message}")
+                return responses
+
+            # Process each telegram
+            for telegram in telegrams:
+                telegram_responses = self._process_single_telegram(telegram)
+                responses.extend(telegram_responses)
+
+        except Exception as e:
+            self.logger.error(f"Error processing request: {e}")
+
+        return responses
+
+    def _split_telegrams(self, message: str) -> List[str]:
+        """Split message into individual telegrams.
+
+        Args:
+            message: Raw message containing one or more telegrams in format <TELEGRAM><TELEGRAM2>...
+
+        Returns:
+            List of individual telegram strings including angle brackets.
+        """
+        telegrams = []
+        start = 0
+
+        while True:
+            # Find the start of a telegram
+            start_idx = message.find("<", start)
+            if start_idx == -1:
+                break
+
+            # Find the end of the telegram
+            end_idx = message.find(">", start_idx)
+            if end_idx == -1:
+                self.logger.warning(
+                    f"Incomplete telegram found starting at position {start_idx}"
+                )
+                break
+
+            # Extract telegram including angle brackets
+            telegram = message[start_idx : end_idx + 1]
+            telegrams.append(telegram)
+
+            # Move to the next position
+            start = end_idx + 1
+
+        return telegrams
+
+    def _process_single_telegram(self, telegram: str) -> List[str]:
+        """Process a single telegram and generate responses.
+
+        Args:
+            telegram: A single telegram string.
+
+        Returns:
+            List of response strings for this telegram.
+        """
         responses: list[str] = []
 
         try:
             # Parse the telegram
-            parsed_telegram = self.telegram_service.parse_system_telegram(message)
+            parsed_telegram = self.telegram_service.parse_system_telegram(telegram)
 
             if not parsed_telegram:
-                self.logger.warning(f"Failed to parse telegram: {message}")
+                self.logger.warning(f"Failed to parse telegram: {telegram}")
                 return responses
 
             # Handle discover requests
@@ -296,7 +367,7 @@ class ServerService:
                         )
 
         except Exception as e:
-            self.logger.error(f"Error processing request: {e}")
+            self.logger.error(f"Error processing telegram: {e}")
 
         return responses
 

xp/services/server/xp130_server_service.py

@@ -7,6 +7,7 @@ XP130 is an Ethernet/TCPIP interface module.
 
 from typing import Dict
 
+from xp.models import ModuleTypeCode
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -32,7 +33,7 @@ class XP130ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP130"
-        self.module_type_code = 13  # XP130 module type from registry
+        self.module_type_code = ModuleTypeCode.XP130  # XP130 module type from registry
         self.firmware_version = "XP130_V1.02.15"
 
         # XP130-specific network configuration

xp/services/server/xp20_server_service.py

@@ -6,6 +6,7 @@ including response generation and device configuration handling.
 
 from typing import Dict
 
+from xp.models import ModuleTypeCode
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -31,7 +32,7 @@ class XP20ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP20"
-        self.module_type_code = 33  # XP20 module type from registry
+        self.module_type_code = ModuleTypeCode.XP20  # XP20 module type from registry
         self.firmware_version = "XP20_V0.01.05"
 
     def get_device_info(self) -> Dict:

xp/services/server/xp230_server_service.py

@@ -6,6 +6,7 @@ including response generation and device configuration handling.
 
 from typing import Dict
 
+from xp.models import ModuleTypeCode
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -31,7 +32,7 @@ class XP230ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP230"
-        self.module_type_code = 34  # XP230 module type from registry
+        self.module_type_code = ModuleTypeCode.XP230  # XP230 module type from registry
         self.firmware_version = "XP230_V1.00.04"
 
     def get_device_info(self) -> Dict:

xp/services/server/xp24_server_service.py

@@ -6,6 +6,7 @@ including response generation and device configuration handling.
 
 from typing import Dict, Optional
 
+from xp.models import ModuleTypeCode
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.system_telegram import SystemTelegram
@@ -18,6 +19,16 @@ class XP24ServerError(Exception):
     pass
 
 
+class XP24Output:
+    """Represents an XP24 output state.
+
+    Attributes:
+        state: Current state of the output (True=on, False=off).
+    """
+
+    state: bool = False
+
+
 class XP24ServerService(BaseServerService):
     """
     XP24 device emulation service.
@@ -34,30 +45,107 @@ class XP24ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP24"
-        self.module_type_code = 7  # XP24 module type from registry
+        self.module_type_code = ModuleTypeCode.XP24
+        self.autoreport_status = True
         self.firmware_version = "XP24_V0.34.03"
+        self.output_0: XP24Output = XP24Output()
+        self.output_1: XP24Output = XP24Output()
+        self.output_2: XP24Output = XP24Output()
+        self.output_3: XP24Output = XP24Output()
+
+    def _handle_device_specific_action_request(
+        self, request: SystemTelegram
+    ) -> Optional[str]:
+        """Handle XP24-specific data requests."""
+        telegrams = self._handle_action_module_output_state(request.data)
+        self.logger.debug(
+            f"Generated {self.device_type} module type responses: {telegrams}"
+        )
+        return telegrams
+
+    def _handle_action_module_output_state(self, data_value: str) -> str:
+        """Handle XP24-specific module output state."""
+        output_number = int(data_value[:2])
+        output_state = data_value[2:]
+        if output_number not in range(0, 4):
+            return self._build_ack_nak_response_telegram(False)
+
+        if output_state not in ("AA", "AB"):
+            return self._build_ack_nak_response_telegram(False)
+
+        output = (self.output_0, self.output_1, self.output_2, self.output_3)[
+            output_number
+        ]
+        previous_state = output.state
+        output.state = True if output_state == "AB" else False
+        state_changed = previous_state != output.state
+
+        telegrams = self._build_ack_nak_response_telegram(True)
+        if state_changed and self.autoreport_status:
+            telegrams += self._build_make_break_response_telegram(
+                output.state, output_number
+            )
+
+        return telegrams
+
+    def _build_ack_nak_response_telegram(self, ack_or_nak: bool) -> str:
+        """Build a complete ACK or NAK response telegram with checksum.
+
+        Args:
+            ack_or_nak: true: ACK telegram response, false: NAK telegram response.
+
+        Returns:
+            The complete telegram with checksum enclosed in angle brackets.
+        """
+        data_value = (
+            SystemFunction.ACK.value if ack_or_nak else SystemFunction.NAK.value
+        )
+        data_part = f"R{self.serial_number}" f"F{data_value:02}D"
+        return self._build_response_telegram(data_part)
+
+    def _build_make_break_response_telegram(
+        self, make_or_break: bool, output_number: int
+    ) -> str:
+        """Build a complete ACK or NAK response telegram with checksum.
+
+        Args:
+            make_or_break: true: MAKE event response, false: BREAK event response.
+            output_number: output concerned
+
+        Returns:
+            The complete event telegram with checksum enclosed in angle brackets.
+        """
+        data_value = "M" if make_or_break else "B"
+        data_part = (
+            f"E{self.module_type_code.value:02}"
+            f"L{self.link_number:02}"
+            f"I{output_number:02}"
+            f"{data_value}"
+        )
+        return self._build_response_telegram(data_part)
 
     def _handle_device_specific_data_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
         """Handle XP24-specific data requests."""
-        if (
-            request.system_function != SystemFunction.READ_DATAPOINT
-            or not request.datapoint_type
-        ):
+        if not request.datapoint_type:
             return None
 
         datapoint_type = request.datapoint_type
-        datapoint_values = {
-            DataPointType.MODULE_OUTPUT_STATE: "xxxx0001",
-            DataPointType.MODULE_STATE: "OFF",
-            DataPointType.MODULE_OPERATING_HOURS: "00:000[H],01:000[H],02:000[H],03:000[H]",
-        }
+        handler = {
+            DataPointType.MODULE_OUTPUT_STATE: self._handle_read_module_output_state,
+            DataPointType.MODULE_STATE: self._handle_read_module_state,
+            DataPointType.MODULE_OPERATING_HOURS: self._handle_read_module_operating_hours,
+        }.get(datapoint_type)
+        if not handler:
+            return None
+
+        data_value = handler()
         data_part = (
             f"R{self.serial_number}"
-            f"F02{datapoint_type.value}"
-            f"{self.module_type_code}"
-            f"{datapoint_values.get(datapoint_type)}"
+            f"F02D{datapoint_type.value}"
+            f"{self.module_type_code.value:02}"
+            f"{data_value}"
         )
         telegram = self._build_response_telegram(data_part)
 
@@ -66,21 +154,26 @@ class XP24ServerService(BaseServerService):
         )
         return telegram
 
-    def _handle_device_specific_action_request(
-        self, request: SystemTelegram
-    ) -> Optional[str]:
-        """Handle XP24-specific action requests.
-
-        Args:
-            request: The system telegram request.
-
-        Returns:
-            The response telegram string, or None if request cannot be handled.
-        """
-        if request.system_function != SystemFunction.ACTION:
-            return None
-
-        return self.generate_action_response(request)
+    def _handle_read_module_operating_hours(self) -> str:
+        """Handle XP24-specific module operating hours."""
+        return "00:000[H],01:000[H],02:000[H],03:000[H]"
+
+    def _handle_read_module_state(self) -> str:
+        """Handle XP24-specific module state."""
+        for output in (self.output_0, self.output_1, self.output_2, self.output_3):
+            if output.state:
+                return "ON"
+        return "OFF"
+
+    def _handle_read_module_output_state(self) -> str:
+        """Handle XP24-specific module output state."""
+        return (
+            f"xxxx"
+            f"{1 if self.output_0.state else 0}"
+            f"{1 if self.output_1.state else 0}"
+            f"{1 if self.output_2.state else 0}"
+            f"{1 if self.output_3.state else 0}"
+        )
 
     def get_device_info(self) -> Dict:
         """Get XP24 device information.
@@ -91,29 +184,9 @@ class XP24ServerService(BaseServerService):
         return {
             "serial_number": self.serial_number,
             "device_type": self.device_type,
+            "module_type_code": self.module_type_code.value,
             "firmware_version": self.firmware_version,
             "status": self.device_status,
             "link_number": self.link_number,
+            "autoreport_status": self.autoreport_status,
         }
-
-    def generate_action_response(self, request: SystemTelegram) -> Optional[str]:
-        """Generate action response telegram (simulated).
-
-        Args:
-            request: The system telegram request.
-
-        Returns:
-            The ACK or NAK response telegram string.
-        """
-        response = "F19D"  # NAK
-        if (
-            request.system_function == SystemFunction.ACTION
-            and request.data[:2] in ("00", "01", "02", "03")
-            and request.data[2:] in ("AA", "AB")
-        ):
-            response = "F18D"  # ACK
-
-        data_part = f"R{self.serial_number}{response}"
-        telegram = self._build_response_telegram(data_part)
-        self._log_response("module_action_response", telegram)
-        return telegram

xp/services/server/xp33_server_service.py

@@ -7,11 +7,11 @@ including response generation and device configuration handling for
 
 from typing import Dict, Optional
 
+from xp.models import ModuleTypeCode
 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.server.base_server_service import BaseServerService
-from xp.utils import calculate_checksum
 
 
 class XP33ServerError(Exception):
@@ -38,27 +38,28 @@ class XP33ServerService(BaseServerService):
         super().__init__(serial_number)
         self.variant = variant  # XP33 or XP33LR or XP33LED
         self.device_type = "XP33"
-        self.module_type_code = 11  # XP33 module type
+        self.module_type_code = ModuleTypeCode.XP33  # XP33 module type
 
         # XP33 device characteristics (anonymized for interoperability testing)
         if variant == "XP33LED":
             self.firmware_version = "XP33LED_V0.00.00"
             self.ean_code = "1234567890123"  # Test EAN - not a real product code
             self.max_power = 300  # 3 x 100VA
-            self.module_type_code = 31  # XP33LR module type
+            self.module_type_code = ModuleTypeCode.XP33LED  # XP33LR module type
         elif variant == "XP33LR":  # XP33LR
             self.firmware_version = "XP33LR_V0.00.00"
             self.ean_code = "1234567890124"  # Test EAN - not a real product code
             self.max_power = 640  # Total 640VA
-            self.module_type_code = 30  # XP33LR module type
+            self.module_type_code = ModuleTypeCode.XP33LR  # XP33LR module type
         else:  # XP33
             self.firmware_version = "XP33_V0.04.02"
             self.ean_code = "1234567890125"  # Test EAN - not a real product code
             self.max_power = 100  # Total 640VA
-            self.module_type_code = 11  # XP33 module type
+            self.module_type_code = ModuleTypeCode.XP33  # XP33 module type
 
         self.device_status = "00"  # Normal status
         self.link_number = 4  # 4 links configured
+        self.autoreport_status = True
 
         # Channel states (3 channels, 0-100% dimming)
         self.channel_states = [0, 0, 0]  # All channels at 0%
@@ -71,36 +72,164 @@ class XP33ServerService(BaseServerService):
             4: [0, 0, 0],  # Scene 4: Off
         }
 
+    def _handle_device_specific_action_request(
+        self, request: SystemTelegram
+    ) -> Optional[str]:
+        """Handle XP33-specific action requests."""
+        telegrams = self._handle_action_channel_dimming(request.data)
+        self.logger.debug(f"Generated {self.device_type} action responses: {telegrams}")
+        return telegrams
+
+    def _handle_action_channel_dimming(self, data_value: str) -> str:
+        """Handle XP33-specific channel dimming action.
+
+        Args:
+            data_value: Action data in format channel_number:dimming_level.
+                       E.g., "00:050" means channel 0, 50% dimming.
+
+        Returns:
+            Response telegram(s) - ACK/NAK, optionally with event telegram.
+        """
+        if ":" not in data_value or len(data_value) < 6:
+            return self._build_ack_nak_response_telegram(False)
+
+        try:
+            parts = data_value.split(":")
+            channel_number = int(parts[0])
+            dimming_level = int(parts[1])
+        except (ValueError, IndexError):
+            return self._build_ack_nak_response_telegram(False)
+
+        if channel_number not in range(len(self.channel_states)):
+            return self._build_ack_nak_response_telegram(False)
+
+        if dimming_level not in range(0, 101):
+            return self._build_ack_nak_response_telegram(False)
+
+        previous_level = self.channel_states[channel_number]
+        self.channel_states[channel_number] = dimming_level
+        state_changed = (previous_level == 0 and dimming_level > 0) or (
+            previous_level > 0 and dimming_level == 0
+        )
+
+        telegrams = self._build_ack_nak_response_telegram(True)
+        if state_changed and self.autoreport_status:
+            # Report dimming change event
+            telegrams += self._build_dimming_event_telegram(
+                dimming_level, channel_number
+            )
+
+        return telegrams
+
+    def _build_ack_nak_response_telegram(self, ack_or_nak: bool) -> str:
+        """Build a complete ACK or NAK response telegram with checksum.
+
+        Args:
+            ack_or_nak: true: ACK telegram response, false: NAK telegram response.
+
+        Returns:
+            The complete telegram with checksum enclosed in angle brackets.
+        """
+        data_value = (
+            SystemFunction.ACK.value if ack_or_nak else SystemFunction.NAK.value
+        )
+        data_part = f"R{self.serial_number}" f"F{data_value:02}D"
+        return self._build_response_telegram(data_part)
+
+    def _build_dimming_event_telegram(
+        self, dimming_level: int, channel_number: int
+    ) -> str:
+        """Build a complete dimming event telegram with checksum.
+
+        Args:
+            dimming_level: Dimming level 0-100%.
+            channel_number: Channel concerned (0-2).
+
+        Returns:
+            The complete event telegram with checksum enclosed in angle brackets.
+        """
+        data_value = "M" if dimming_level > 0 else "B"
+        data_part = (
+            f"E{self.module_type_code.value:02}"
+            f"L{self.link_number:02}"
+            f"I{channel_number:02}"
+            f"{data_value}"
+        )
+        return self._build_response_telegram(data_part)
+
     def _handle_device_specific_data_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
-        """Handle XP24-specific data requests."""
-        if (
-            request.system_function != SystemFunction.READ_DATAPOINT
-            or not request.datapoint_type
-        ):
+        """Handle XP33-specific data requests."""
+        if not request.datapoint_type:
             return None
 
         datapoint_type = request.datapoint_type
-        datapoint_values = {
-            DataPointType.MODULE_OUTPUT_STATE: "xxxxx001",
-            DataPointType.MODULE_STATE: "OFF",
-            DataPointType.MODULE_OPERATING_HOURS: "00:000[H],01:000[H],02:000[H]",
-        }
+        handler = {
+            DataPointType.MODULE_OUTPUT_STATE: self._handle_read_module_output_state,
+            DataPointType.MODULE_STATE: self._handle_read_module_state,
+            DataPointType.MODULE_OPERATING_HOURS: self._handle_read_module_operating_hours,
+            DataPointType.MODULE_LIGHT_LEVEL: self._handle_read_light_level,
+        }.get(datapoint_type)
+        if not handler:
+            return None
+
+        data_value = handler()
         data_part = (
             f"R{self.serial_number}"
-            f"F02{datapoint_type.value}"
-            f"{self.module_type_code}"
-            f"{datapoint_values.get(datapoint_type)}"
+            f"F02D{datapoint_type.value}"
+            f"{self.module_type_code.value:02}"
+            f"{data_value}"
         )
-        checksum = calculate_checksum(data_part)
-        telegram = f"<{data_part}{checksum}>"
+        telegram = self._build_response_telegram(data_part)
 
         self.logger.debug(
             f"Generated {self.device_type} module type response: {telegram}"
         )
         return telegram
 
+    def _handle_read_module_output_state(self) -> str:
+        """Handle XP33-specific module output state.
+
+        Returns:
+            String representation of the output state for 3 channels.
+        """
+        return (
+            f"xxxxx"
+            f"{1 if self.channel_states[0] > 0 else 0}"
+            f"{1 if self.channel_states[1] > 0 else 0}"
+            f"{1 if self.channel_states[2] > 0 else 0}"
+        )
+
+    def _handle_read_module_state(self) -> str:
+        """Handle XP33-specific module state.
+
+        Returns:
+            'ON' if any channel is active, 'OFF' otherwise.
+        """
+        if any(level > 0 for level in self.channel_states):
+            return "ON"
+        return "OFF"
+
+    def _handle_read_module_operating_hours(self) -> str:
+        """Handle XP33-specific module operating hours.
+
+        Returns:
+            Operating hours for all 3 channels.
+        """
+        return "00:000[H],01:000[H],02:000[H]"
+
+    def _handle_read_light_level(self) -> str:
+        """Handle XP33-specific light level reading.
+
+        Returns:
+            Light levels for all channels in format "00:000[%],01:000[%],02:000[%]".
+        """
+        levels = [
+            f"{i:02d}:{level:03d}[%]" for i, level in enumerate(self.channel_states)
+        ]
+        return ",".join(levels)
+
     def set_channel_dimming(self, channel: int, level: int) -> bool:
         """Set individual channel dimming level.
 
@@ -147,6 +276,7 @@ class XP33ServerService(BaseServerService):
             "max_power": self.max_power,
             "status": self.device_status,
             "link_number": self.link_number,
+            "autoreport_status": self.autoreport_status,
             "channel_states": self.channel_states.copy(),
             "available_scenes": list(self.scenes.keys()),
         }