conson-xp 1.18.0__py3-none-any.whl

xp/services/conbus/conbus_discover_service.py

@@ -0,0 +1,312 @@
+"""Conbus Discover Service for TCP communication with Conbus servers.
+
+This service implements a TCP client that connects to Conbus servers and sends
+discover telegrams to find modules on the network.
+"""
+
+import logging
+from typing import Callable, Optional
+
+from xp.models import 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_event_protocol import ConbusEventProtocol
+
+
+class ConbusDiscoverService:
+    """
+    Service for discovering modules on Conbus servers.
+
+    Uses ConbusProtocol to provide discovery functionality for finding
+    modules connected to the Conbus network.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
+    """
+
+    conbus_protocol: ConbusEventProtocol
+
+    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
+        """Initialize the Conbus discover service.
+
+        Args:
+            conbus_protocol: ConbusProtocol.
+        """
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.device_discover_callback: Optional[Callable[[DiscoveredDevice], None]] = (
+            None
+        )
+        self.finish_callback: Optional[Callable[[ConbusDiscoverResponse], None]] = None
+
+        self.conbus_protocol: ConbusEventProtocol = conbus_protocol
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
+        self.discovered_device_result = ConbusDiscoverResponse(success=False)
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_made(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established")
+        self.logger.debug("Sending discover telegram")
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number="0000000000",
+            system_function=SystemFunction.DISCOVERY,
+            data_value="00",
+        )
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
+        self.logger.debug(f"Telegram sent: {telegram_sent}")
+        self.discovered_device_result.sent_telegram = telegram_sent
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
+        self.logger.debug(f"Telegram received: {telegram_received}")
+        if not self.discovered_device_result.received_telegrams:
+            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
+            and telegram_received.payload[11:16] == "F01D"
+            and len(telegram_received.payload) == 15
+        ):
+            self.handle_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 or module type response")
+
+    def handle_discovered_device(self, serial_number: str) -> None:
+        """Handle discovered device event.
+
+        Args:
+            serial_number: Serial number of the discovered device.
+        """
+        self.logger.info("discovered_device: %s", serial_number)
+        if not self.discovered_device_result.discovered_devices:
+            self.discovered_device_result.discovered_devices = []
+
+        # 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)
+
+        if self.device_discover_callback:
+            self.device_discover_callback(device)
+
+        # Send READ_DATAPOINT telegram to query module type
+        self.logger.debug(f"Sending module type query for {serial_number}")
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_TYPE.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
+
+                    if self.device_discover_callback:
+                        self.device_discover_callback(device)
+
+                    self.logger.debug(
+                        f"Updated device {serial_number} with module_type {module_type_name}"
+                    )
+                    break
+
+        if self.discovered_device_result.discovered_devices:
+            for device in self.discovered_device_result.discovered_devices:
+                if not (
+                    device["serial_number"]
+                    and device["module_type"]
+                    and device["module_type_code"]
+                    and device["module_type_name"]
+                ):
+                    return
+
+        self.succeed()
+
+    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}"
+                    )
+                    if self.device_discover_callback:
+                        self.device_discover_callback(device)
+
+                    break
+
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_TYPE_CODE.value,
+        )
+
+    def timeout(self) -> None:
+        """Handle timeout event to stop discovery."""
+        timeout = self.conbus_protocol.timeout_seconds
+        self.logger.info("Discovery stopped after: %ss", timeout)
+        self.discovered_device_result.success = False
+        self.discovered_device_result.error = "Discovered device timeout"
+        if self.finish_callback:
+            self.finish_callback(self.discovered_device_result)
+
+        self.stop_reactor()
+
+    def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.debug(f"Failed: {message}")
+        self.discovered_device_result.success = False
+        self.discovered_device_result.error = message
+        if self.finish_callback:
+            self.finish_callback(self.discovered_device_result)
+
+        self.stop_reactor()
+
+    def succeed(self) -> None:
+        """Handle discovered device success event."""
+        self.logger.debug("Succeed")
+        self.discovered_device_result.success = True
+        self.discovered_device_result.error = None
+        if self.finish_callback:
+            self.finish_callback(self.discovered_device_result)
+
+        self.stop_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop reactor."""
+        self.logger.info("Stopping reactor")
+        self.conbus_protocol.stop_reactor()
+
+    def start_reactor(self) -> None:
+        """Start reactor."""
+        self.logger.info("Starting reactor")
+        self.conbus_protocol.start_reactor()
+
+    def run(
+        self,
+        progress_callback: Callable[[str], None],
+        device_discover_callback: Callable[[DiscoveredDevice], None],
+        finish_callback: Callable[[ConbusDiscoverResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Run reactor in dedicated thread with its own event loop.
+
+        Args:
+            progress_callback: Callback for each discovered device.
+            device_discover_callback: Callback for each discovered device.
+            finish_callback: Callback when discovery completes.
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.info("Starting discovery")
+
+        if timeout_seconds:
+            self.conbus_protocol.timeout_seconds = timeout_seconds
+        self.progress_callback = progress_callback
+        self.device_discover_callback = device_discover_callback
+        self.finish_callback = finish_callback

xp/services/conbus/conbus_event_raw_service.py

@@ -0,0 +1,181 @@
+"""Conbus Event Raw Service for sending raw event telegrams.
+
+This service implements a TCP client that connects to Conbus servers and sends
+raw event telegrams to simulate button presses on Conbus modules.
+"""
+
+import logging
+from typing import Callable, Optional
+
+from twisted.internet.base import DelayedCall
+
+from xp.models import ConbusEventRawResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+
+
+class ConbusEventRawService:
+    """Service for sending raw event telegrams to Conbus servers.
+
+    Uses ConbusEventProtocol to send MAKE/BREAK event sequences to
+    simulate button presses on Conbus modules.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
+    """
+
+    conbus_protocol: ConbusEventProtocol
+
+    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
+        """Initialize the Conbus event raw service.
+
+        Args:
+            conbus_protocol: ConbusEventProtocol instance.
+        """
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.finish_callback: Optional[Callable[[ConbusEventRawResponse], None]] = None
+
+        self.conbus_protocol: ConbusEventProtocol = conbus_protocol
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
+        self.event_result = ConbusEventRawResponse(success=False)
+        self.logger = logging.getLogger(__name__)
+
+        # Event parameters
+        self.module_type_code: int = 0
+        self.link_number: int = 0
+        self.input_number: int = 0
+        self.time_ms: int = 1000
+        self.break_event_call: Optional[DelayedCall] = None
+
+    def connection_made(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established")
+        self.logger.debug("Sending MAKE event telegram")
+        self._send_make_event()
+
+    def _send_make_event(self) -> None:
+        """Send MAKE event telegram."""
+        payload = f"E{self.module_type_code:02d}L{self.link_number:02d}I{self.input_number:02d}M"
+        self.logger.debug(f"Sending MAKE event: {payload}")
+        self.conbus_protocol.telegram_queue.put_nowait(payload.encode())
+        self.conbus_protocol.call_later(0.0, self.conbus_protocol.start_queue_manager)
+
+        # Schedule BREAK event after delay
+        delay_seconds = self.time_ms / 1000.0
+        self.break_event_call = self.conbus_protocol.call_later(
+            delay_seconds, self._send_break_event
+        )
+
+    def _send_break_event(self) -> None:
+        """Send BREAK event telegram."""
+        payload = f"E{self.module_type_code:02d}L{self.link_number:02d}I{self.input_number:02d}B"
+        self.logger.debug(f"Sending BREAK event: {payload}")
+        self.conbus_protocol.telegram_queue.put_nowait(payload.encode())
+        self.conbus_protocol.call_later(0.0, self.conbus_protocol.start_queue_manager)
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
+        self.logger.debug(f"Telegram sent: {telegram_sent}")
+        if self.event_result.sent_telegrams is None:
+            self.event_result.sent_telegrams = []
+        self.event_result.sent_telegrams.append(telegram_sent)
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
+        self.logger.debug(f"Telegram received: {telegram_received.frame}")
+        if self.event_result.received_telegrams is None:
+            self.event_result.received_telegrams = []
+        self.event_result.received_telegrams.append(telegram_received.frame)
+
+        # Display progress - show ALL received telegrams
+        if self.progress_callback:
+            self.progress_callback(telegram_received.frame)
+
+    def timeout(self) -> None:
+        """Handle timeout event.
+
+        Timeout is the normal/expected way to finish this service.
+        """
+        timeout_seconds = self.conbus_protocol.timeout_seconds
+        self.logger.info("Event raw finished after timeout: %ss", timeout_seconds)
+        self.event_result.success = True
+        self.event_result.error = None
+        if self.finish_callback:
+            self.finish_callback(self.event_result)
+
+        self.stop_reactor()
+
+    def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.debug(f"Failed: {message}")
+        self.event_result.success = False
+        self.event_result.error = message
+        if self.finish_callback:
+            self.finish_callback(self.event_result)
+
+        self.stop_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop reactor."""
+        self.logger.info("Stopping reactor")
+        # Cancel break event call if it's still pending
+        if self.break_event_call and self.break_event_call.active():
+            self.break_event_call.cancel()
+        self.conbus_protocol.stop_reactor()
+
+    def start_reactor(self) -> None:
+        """Start reactor."""
+        self.logger.info("Starting reactor")
+        self.conbus_protocol.start_reactor()
+
+    def run(
+        self,
+        module_type_code: int,
+        link_number: int,
+        input_number: int,
+        time_ms: int,
+        progress_callback: Optional[Callable[[str], None]],
+        finish_callback: Callable[[ConbusEventRawResponse], None],
+        timeout_seconds: int = 5,
+    ) -> None:
+        """Run reactor in dedicated thread with its own event loop.
+
+        Args:
+            module_type_code: Module type code (numeric, e.g., 2 for CP20, 33 for XP33).
+            link_number: Link number (0-99).
+            input_number: Input number (0-9).
+            time_ms: Delay in milliseconds between MAKE and BREAK events.
+            progress_callback: Callback for progress updates (received telegrams).
+            finish_callback: Callback when operation completes.
+            timeout_seconds: Timeout in seconds (default: 5).
+        """
+        self.logger.info(
+            f"Starting event raw: module={module_type_code}, "
+            f"link={link_number}, input={input_number}, time={time_ms}ms"
+        )
+
+        self.module_type_code = module_type_code
+        self.link_number = link_number
+        self.input_number = input_number
+        self.time_ms = time_ms
+
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+        self.progress_callback = progress_callback
+        self.finish_callback = finish_callback

xp/services/conbus/conbus_output_service.py

@@ -0,0 +1,194 @@
+"""Conbus Output Service for sending action telegrams to Conbus modules.
+
+This service handles sending action telegrams (ON/OFF) to module outputs
+and processing ACK/NAK responses.
+"""
+
+import logging
+from datetime import datetime
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
+from xp.models.conbus.conbus_output import ConbusOutputResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.action_type import ActionType
+from xp.models.telegram.output_telegram import OutputTelegram
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.protocol import ConbusProtocol
+from xp.services.telegram.telegram_output_service import (
+    TelegramOutputService,
+    XPOutputError,
+)
+
+
+class ConbusOutputError(Exception):
+    """Raised when Conbus output operations fail."""
+
+    pass
+
+
+class ConbusOutputService(ConbusProtocol):
+    """
+    Service for sending action telegrams to Conbus module outputs.
+
+    Manages action telegram transmission (ON/OFF) and processes
+    ACK/NAK responses from modules.
+    """
+
+    def __init__(
+        self,
+        telegram_output_service: TelegramOutputService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ):
+        """Initialize the Conbus output service.
+
+        Args:
+            telegram_output_service: TelegramOutputService for telegram generation/parsing.
+            cli_config: Conbus client configuration.
+            reactor: Twisted reactor for async operations.
+        """
+        super().__init__(cli_config, reactor)
+        self.telegram_output_service = telegram_output_service
+        self.serial_number: str = ""
+        self.output_number: int = 0
+        self.action_type: ActionType = ActionType.ON_RELEASE
+        self.finish_callback: Optional[Callable[[ConbusOutputResponse], None]] = None
+        self.service_response: ConbusOutputResponse = ConbusOutputResponse(
+            success=False,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            action_type=self.action_type,
+            timestamp=datetime.now(),
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug(
+            f"Connection established, sending action {self.action_type} to output {self.output_number}."
+        )
+
+        # Validate parameters before sending
+        try:
+            self.telegram_output_service.validate_output_number(self.output_number)
+            self.telegram_output_service.validate_serial_number(self.serial_number)
+        except XPOutputError as e:
+            self.failed(str(e))
+            return
+
+        # Send F27D{output:02d}{action} telegram
+        # F27 = ACTION, D = data with output number and action type
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.ACTION,
+            data_value=f"{self.output_number:02d}{self.action_type.value}",
+        )
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
+        self.service_response.sent_telegram = telegram_sent
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
+        self.logger.debug(f"Telegram received: {telegram_received}")
+
+        if not self.service_response.received_telegrams:
+            self.service_response.received_telegrams = []
+        self.service_response.received_telegrams.append(telegram_received.frame)
+
+        if (
+            not telegram_received.checksum_valid
+            or telegram_received.telegram_type != TelegramType.REPLY
+            or telegram_received.serial_number != self.serial_number
+        ):
+            self.logger.debug("Not a reply for our serial number")
+            return
+
+        # Parse the reply telegram to get ACK/NAK
+        output_telegram = self.telegram_output_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        if output_telegram and output_telegram.system_function in (
+            SystemFunction.ACK,
+            SystemFunction.NAK,
+        ):
+            self.logger.debug(f"Received {output_telegram.system_function} response")
+            self.succeed(output_telegram)
+        else:
+            self.logger.debug(
+                f"Unexpected system function: {output_telegram.system_function}"
+            )
+
+    def succeed(self, output_telegram: OutputTelegram) -> None:
+        """Handle successful output action.
+
+        Args:
+            output_telegram: The output telegram received as response.
+        """
+        self.logger.debug("Successfully sent action to output")
+        self.service_response.success = True
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.action_type = self.action_type
+        self.service_response.output_telegram = output_telegram
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.debug(f"Failed with message: {message}")
+        self.service_response.success = False
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.action_type = self.action_type
+        self.service_response.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def send_action(
+        self,
+        serial_number: str,
+        output_number: int,
+        action_type: ActionType,
+        finish_callback: Callable[[ConbusOutputResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Send an action telegram to a module output.
+
+        Args:
+            serial_number: 10-digit module serial number.
+            output_number: Output number (0-99).
+            action_type: Action to perform (ON_RELEASE, OFF_PRESS, etc.).
+            finish_callback: Callback function to call when operation completes.
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.info("Starting send_action")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.output_number = output_number
+        self.action_type = action_type
+        self.finish_callback = finish_callback
+        self.start_reactor()