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

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()),
         }

xp/services/telegram/telegram_datapoint_service.py

@@ -0,0 +1,70 @@
+"""Service for processing Telegram protocol datapoint values."""
+
+
+class TelegramDatapointService:
+    """Service for processing Telegram protocol datapoint values.
+
+    Provides methods to parse and extract values from different types of
+    Telegram datapoints including autoreport status, light level outputs,
+    and link number values.
+    """
+
+    def get_autoreport_status(self, data_value: str) -> bool:
+        """Get the autoreport status value.
+
+        Args:
+            data_value: The raw autoreport status data value (PP or AA).
+
+        Returns:
+            The autoreport status: Enable (True) or disable (False).
+        """
+        status_value = True if data_value == "PP" else False
+        return status_value
+
+    def get_autoreport_status_data_value(self, status_value: bool) -> str:
+        """Get the autoreport status data_value.
+
+        Args:
+            status_value: Enable (True) or disable (False).
+
+        Returns:
+            data_value: The raw autoreport status data value (PP or AA).
+        """
+        data_value = "PP" if status_value else "AA"
+        return data_value
+
+    def get_lightlevel(self, data_value: str, output_number: int) -> int:
+        """Extract the light level for a specific output number.
+
+        Parses comma-separated output data in the format "output:level[%]"
+        and returns the level for the requested output number.
+
+        Args:
+            data_value: Comma-separated string of output:level pairs
+                       (e.g., "1:50[%],2:75[%]").
+            output_number: The output number to get the level for.
+
+        Returns:
+            The light level as an integer (0 if output not found).
+        """
+        level = 0
+        for output_data in data_value.split(","):
+            if ":" in output_data:
+                output_str, level_str = output_data.split(":")
+                if int(output_str) == output_number:
+                    level_str = level_str.replace("[%]", "")
+                    level = int(level_str)
+                    break
+        return level
+
+    def get_linknumber(self, data_value: str) -> int:
+        """Parse and return the link number value.
+
+        Args:
+            data_value: The raw link number data value as a string.
+
+        Returns:
+            The link number as an integer.
+        """
+        link_number_value = int(data_value)
+        return link_number_value

xp/utils/dependencies.py

@@ -21,8 +21,6 @@ from xp.services.conbus.actiontable.msactiontable_xp24_serializer import (
 from xp.services.conbus.actiontable.msactiontable_xp33_serializer import (
     Xp33MsActionTableSerializer,
 )
-from xp.services.conbus.conbus_autoreport_get_service import ConbusAutoreportGetService
-from xp.services.conbus.conbus_autoreport_set_service import ConbusAutoreportSetService
 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
@@ -33,13 +31,11 @@ from xp.services.conbus.conbus_datapoint_service import (
     ConbusDatapointService,
 )
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
-from xp.services.conbus.conbus_lightlevel_set_service import ConbusLightlevelSetService
-from xp.services.conbus.conbus_linknumber_get_service import ConbusLinknumberGetService
-from xp.services.conbus.conbus_linknumber_set_service import ConbusLinknumberSetService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
 from xp.services.conbus.conbus_receive_service import ConbusReceiveService
 from xp.services.conbus.conbus_scan_service import ConbusScanService
+from xp.services.conbus.write_config_service import WriteConfigService
 from xp.services.homekit.homekit_cache_service import HomeKitCacheService
 from xp.services.homekit.homekit_conbus_service import HomeKitConbusService
 from xp.services.homekit.homekit_dimminglight_service import HomeKitDimmingLightService
@@ -191,8 +187,9 @@ class ServiceContainer:
         )
 
         self.container.register(
-            ConbusLightlevelSetService,
-            factory=lambda: ConbusLightlevelSetService(
+            WriteConfigService,
+            factory=lambda: WriteConfigService(
+                telegram_service=self.container.resolve(TelegramService),
                 cli_config=self.container.resolve(ConbusClientConfig),
                 reactor=self.container.resolve(PosixReactorBase),
             ),
@@ -247,45 +244,6 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
-        self.container.register(
-            ConbusAutoreportSetService,
-            factory=lambda: ConbusAutoreportSetService(
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
-        self.container.register(
-            ConbusAutoreportGetService,
-            factory=lambda: ConbusAutoreportGetService(
-                telegram_service=self.container.resolve(TelegramService),
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
-        self.container.register(
-            ConbusLinknumberGetService,
-            factory=lambda: ConbusLinknumberGetService(
-                telegram_service=self.container.resolve(TelegramService),
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
-        self.container.register(
-            ConbusLinknumberSetService,
-            factory=lambda: ConbusLinknumberSetService(
-                telegram_service=self.container.resolve(TelegramService),
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
         self.container.register(
             ConbusCustomService,
             factory=lambda: ConbusCustomService(

xp/api/__init__.py

@@ -1 +0,0 @@
-"""API module for FastAPI endpoints and models."""