conson-xp 1.18.0__py3-none-any.whl

xp/services/conbus/conbus_blink_service.py

@@ -0,0 +1,158 @@
+"""Conbus Blink Service for TCP communication with Conbus servers.
+
+This service implements a TCP client that connects to Conbus servers and sends
+blink/unblink telegrams to control module LED indicators.
+"""
+
+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_blink import ConbusBlinkResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.protocol import ConbusProtocol
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ConbusBlinkService(ConbusProtocol):
+    """
+    Service for blinking module LEDs on Conbus servers.
+
+    Uses ConbusProtocol to provide blink/unblink functionality
+    for controlling module LED indicators.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus blink service.
+
+        Args:
+            telegram_service: Service for parsing telegrams.
+            cli_config: Configuration for Conbus client connection.
+            reactor: Twisted reactor for event loop.
+        """
+        super().__init__(cli_config, reactor)
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.on_or_off = "none"
+        self.finish_callback: Optional[Callable[[ConbusBlinkResponse], None]] = None
+        self.service_response: ConbusBlinkResponse = ConbusBlinkResponse(
+            success=False,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.NONE,
+            operation=self.on_or_off,
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established, sending blink command.")
+        # Blink is 05, Unblink is 06
+        system_function = SystemFunction.UNBLINK
+        if self.on_or_off.lower() == "on":
+            system_function = SystemFunction.BLINK
+
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=system_function,
+            data_value="00",
+        )
+        self.service_response.system_function = system_function
+        self.service_response.operation = self.on_or_off
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
+        system_telegram = self.telegram_service.parse_system_telegram(telegram_sent)
+        self.service_response.sent_telegram = system_telegram
+
+    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")
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+        if reply_telegram is not None and reply_telegram.system_function in (
+            SystemFunction.ACK,
+            SystemFunction.NAK,
+        ):
+            self.logger.debug("Received blink response")
+            self.service_response.success = True
+            self.service_response.timestamp = datetime.now()
+            self.service_response.serial_number = self.serial_number
+            self.service_response.reply_telegram = reply_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.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def send_blink_telegram(
+        self,
+        serial_number: str,
+        on_or_off: str,
+        finish_callback: Callable[[ConbusBlinkResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        r"""Send blink command to start blinking module LED.
+
+        Args:
+            serial_number: 10-digit module serial number.
+            on_or_off: "on" to blink or "off" to unblink.
+            finish_callback: Callback function to call when the reply is received.
+            timeout_seconds: Timeout in seconds.
+
+        Examples:
+            \b
+            xp conbus blink 0012345008 on
+            xp conbus blink 0012345008 off
+        """
+        self.logger.info("Starting send_blink_telegram")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.finish_callback = finish_callback
+        self.serial_number = serial_number
+        self.on_or_off = on_or_off
+        self.start_reactor()

xp/services/conbus/conbus_custom_service.py

@@ -0,0 +1,156 @@
+"""Conbus Custom Service for sending custom telegrams to modules.
+
+This service handles custom telegram operations for modules through Conbus telegrams.
+"""
+
+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_custom import ConbusCustomResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.reply_telegram import ReplyTelegram
+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_service import TelegramService
+
+
+class ConbusCustomService(ConbusProtocol):
+    """
+    Service for sending custom telegrams to Conbus modules.
+
+    Uses ConbusProtocol to provide custom telegram functionality
+    for sending arbitrary function codes and data to modules.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus custom service.
+
+        Args:
+            telegram_service: Service for parsing telegrams.
+            cli_config: Configuration for Conbus client connection.
+            reactor: Twisted reactor for event loop.
+        """
+        super().__init__(cli_config, reactor)
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.function_code: str = ""
+        self.data: str = ""
+        self.finish_callback: Optional[Callable[[ConbusCustomResponse], None]] = None
+        self.service_response: ConbusCustomResponse = ConbusCustomResponse(
+            success=False,
+            serial_number=self.serial_number,
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug(
+            f"Connection established, sending custom telegram F{self.function_code}D{self.data}."
+        )
+        system_function = SystemFunction.from_code(self.function_code)
+        if not system_function:
+            self.logger.debug(f"Invalid function code F{self.function_code}")
+            self.failed(f"Invalid function code {self.function_code}")
+            return
+
+        self.send_telegram(
+            serial_number=self.serial_number,
+            telegram_type=TelegramType.SYSTEM,
+            system_function=system_function,
+            data_value=self.data,
+        )
+
+    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
+        parsed_telegram = self.telegram_service.parse_telegram(telegram_received.frame)
+        reply_telegram = None
+        if isinstance(parsed_telegram, ReplyTelegram):
+            reply_telegram = parsed_telegram
+
+        self.logger.debug("Received reply telegram")
+        self.service_response.success = True
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.function_code = self.function_code
+        self.service_response.data = self.data
+        self.service_response.reply_telegram = reply_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.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def send_custom_telegram(
+        self,
+        serial_number: str,
+        function_code: str,
+        data: str,
+        finish_callback: Callable[[ConbusCustomResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Send a custom telegram to a module.
+
+        Args:
+            serial_number: 10-digit module serial number.
+            function_code: Function code (e.g., "02", "17").
+            data: Data code (e.g., "E2", "AA").
+            finish_callback: Callback function to call when the reply is received.
+            timeout_seconds: Timeout in seconds.
+        """
+        self.logger.info("Starting send_custom_telegram")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.finish_callback = finish_callback
+        self.serial_number = serial_number
+        self.function_code = function_code
+        self.data = data
+        self.start_reactor()

xp/services/conbus/conbus_datapoint_queryall_service.py

@@ -0,0 +1,182 @@
+"""Conbus DataPoint Query All Service.
+
+This module provides service for querying all datapoint types from a module.
+"""
+
+import logging
+from datetime import datetime
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig, ConbusDatapointResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.reply_telegram import ReplyTelegram
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services import TelegramService
+from xp.services.protocol import ConbusProtocol
+
+
+class ConbusDatapointQueryAllService(ConbusProtocol):
+    """
+    Utility service for querying all datapoints from a module.
+
+    This service orchestrates multiple ConbusDatapointService calls to query
+    all available datapoint types sequentially.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the query all service.
+
+        Args:
+            telegram_service: TelegramService for dependency injection.
+            cli_config: ConbusClientConfig for connection settings.
+            reactor: PosixReactorBase for async operations.
+        """
+        super().__init__(cli_config, reactor)
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.finish_callback: Optional[Callable[[ConbusDatapointResponse], None]] = None
+        self.progress_callback: Optional[Callable[[ReplyTelegram], None]] = None
+        self.service_response: ConbusDatapointResponse = ConbusDatapointResponse(
+            success=False,
+            serial_number=self.serial_number,
+        )
+        self.datapoint_types = list(DataPointType)
+        self.current_index = 0
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established, querying datapoints.")
+        self.next_datapoint()
+
+    def next_datapoint(self) -> bool:
+        """Query the next datapoint type.
+
+        Returns:
+            True if there are more datapoints to query, False otherwise.
+        """
+        self.logger.debug("Querying next datapoint")
+
+        if self.current_index >= len(self.datapoint_types):
+            return False
+
+        datapoint_type_code = self.datapoint_types[self.current_index]
+        datapoint_type = DataPointType(datapoint_type_code)
+
+        self.logger.debug(f"Datapoint: {datapoint_type}")
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=str(datapoint_type.value),
+        )
+        self.current_index += 1
+        return True
+
+    def timeout(self) -> bool:
+        """Handle timeout event by querying next datapoint.
+
+        Returns:
+            True to continue, False to stop the reactor.
+        """
+        self.logger.debug("Timeout, querying next datapoint")
+        query_next_datapoint = self.next_datapoint()
+        if not query_next_datapoint:
+            if self.finish_callback:
+                self.logger.debug("Received all datapoints telegram")
+                self.service_response.success = True
+                self.service_response.timestamp = datetime.now()
+                self.service_response.serial_number = self.serial_number
+                self.service_response.system_function = SystemFunction.READ_DATAPOINT
+                self.finish_callback(self.service_response)
+                return False
+        return True
+
+    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
+        datapoint_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+        if (
+            not datapoint_telegram
+            or datapoint_telegram.system_function != SystemFunction.READ_DATAPOINT
+        ):
+            self.logger.debug("Not a reply for our datapoint type")
+            return
+
+        self.logger.debug("Received a datapoint telegram")
+        if self.progress_callback:
+            self.progress_callback(datapoint_telegram)
+
+    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.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def query_all_datapoints(
+        self,
+        serial_number: str,
+        finish_callback: Callable[[ConbusDatapointResponse], None],
+        progress_callback: Callable[[ReplyTelegram], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Query all datapoints from a module.
+
+        Args:
+            serial_number: 10-digit module serial number.
+            finish_callback: Callback function to call when all datapoints are received.
+            progress_callback: Callback function to call when each datapoint is received.
+            timeout_seconds: Timeout in seconds.
+        """
+        self.logger.info("Starting query_all_datapoints")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.finish_callback = finish_callback
+        self.progress_callback = progress_callback
+        self.serial_number = serial_number
+        self.start_reactor()

xp/services/conbus/conbus_datapoint_service.py

@@ -0,0 +1,170 @@
+"""Conbus Datapoint Service for querying module datapoints.
+
+This service handles datapoint query operations for modules through Conbus telegrams.
+"""
+
+import logging
+from datetime import datetime
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig, ConbusDatapointResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.reply_telegram import ReplyTelegram
+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_service import TelegramService
+
+
+class ConbusDatapointService(ConbusProtocol):
+    """
+    Service for querying datapoints from Conbus modules.
+
+    Uses ConbusProtocol to provide datapoint query functionality
+    for reading sensor data and module information.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus datapoint service.
+
+        Args:
+            telegram_service: Service for parsing telegrams.
+            cli_config: Configuration for Conbus client connection.
+            reactor: Twisted reactor for event loop.
+        """
+        super().__init__(cli_config, reactor)
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.datapoint_type: Optional[DataPointType] = None
+        self.datapoint_finished_callback: Optional[
+            Callable[[ConbusDatapointResponse], None]
+        ] = None
+        self.service_response: ConbusDatapointResponse = ConbusDatapointResponse(
+            success=False,
+            serial_number=self.serial_number,
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug(
+            f"Connection established, querying datapoint {self.datapoint_type}."
+        )
+        if self.datapoint_type is None:
+            self.failed("Datapoint type not set")
+            return
+
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=str(self.datapoint_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
+        datapoint_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        if (
+            not datapoint_telegram
+            or datapoint_telegram.system_function != SystemFunction.READ_DATAPOINT
+            or datapoint_telegram.datapoint_type != self.datapoint_type
+        ):
+            self.logger.debug("Not a reply for our datapoint type")
+            return
+
+        self.logger.debug("Received datapoint telegram")
+        self.succeed(datapoint_telegram)
+
+    def succeed(self, datapoint_telegram: ReplyTelegram) -> None:
+        """Handle successful datapoint query.
+
+        Args:
+            datapoint_telegram: The parsed datapoint telegram.
+        """
+        self.logger.debug("Succeed querying datapoint")
+        self.service_response.success = True
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.system_function = SystemFunction.READ_DATAPOINT
+        self.service_response.datapoint_type = self.datapoint_type
+        self.service_response.datapoint_telegram = datapoint_telegram
+        self.service_response.data_value = datapoint_telegram.data_value
+        if self.datapoint_finished_callback:
+            self.datapoint_finished_callback(self.service_response)
+        self._stop_reactor()
+
+    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.error = message
+        if self.datapoint_finished_callback:
+            self.datapoint_finished_callback(self.service_response)
+
+    def query_datapoint(
+        self,
+        serial_number: str,
+        datapoint_type: DataPointType,
+        finish_callback: Callable[[ConbusDatapointResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Query a specific datapoint from a module.
+
+        Args:
+            serial_number: 10-digit module serial number.
+            datapoint_type: Type of datapoint to query.
+            finish_callback: Callback function to call when the datapoint is received.
+            timeout_seconds: Timeout in seconds.
+        """
+        self.logger.info("Starting query_datapoint")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.datapoint_finished_callback = finish_callback
+        self.serial_number = serial_number
+        self.datapoint_type = datapoint_type
+        self.start_reactor()