conson-xp 0.11.19__py3-none-any.whl → 1.0.1__py3-none-any.whl

xp/services/conbus/conbus_datapoint_service.py

@@ -12,6 +12,7 @@ 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
@@ -93,13 +94,16 @@ class ConbusDatapointService(ConbusProtocol):
             return
 
         self.logger.debug("Received datapoint telegram")
+        self.succeed(datapoint_telegram)
+
+    def succeed(self, datapoint_telegram: ReplyTelegram) -> None:
+        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
-
         if self.finish_callback:
             self.finish_callback(self.service_response)
 
@@ -107,6 +111,7 @@ class ConbusDatapointService(ConbusProtocol):
         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.finish_callback:
             self.finish_callback(self.service_response)

xp/services/conbus/conbus_lightlevel_get_service.py

@@ -0,0 +1,101 @@
+"""Conbus Auto Report Service for getting and setting module auto report status.
+
+This service handles auto report status 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.conbus.conbus_lightlevel import ConbusLightlevelResponse
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ConbusLightlevelGetService(ConbusDatapointService):
+    """
+    Service for receiving telegrams from Conbus servers.
+
+    Uses composition with ConbusService to provide receive-only functionality
+    for collecting waiting event telegrams from the server.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus client send service"""
+        super().__init__(telegram_service, cli_config, reactor)
+        self.output_number: int = 0
+        self.service_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
+            None
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def finish_service_callback(
+        self, datapoint_response: ConbusDatapointResponse
+    ) -> None:
+
+        self.logger.debug("Parsing datapoint response")
+
+        level = 0
+        if datapoint_response.success and datapoint_response.datapoint_telegram:
+            for output_data in datapoint_response.datapoint_telegram.data_value.split(
+                ","
+            ):
+                if ":" in output_data:
+                    output_str, level_str = output_data.split(":")
+                    if int(output_str) == self.output_number:
+                        level_str = level_str.replace("[%]", "")
+                        level = int(level_str)
+                        break
+
+        service_response = ConbusLightlevelResponse(
+            success=datapoint_response.success,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            level=level,
+            error=datapoint_response.error,
+            sent_telegram=datapoint_response.sent_telegram,
+            received_telegrams=datapoint_response.received_telegrams,
+            timestamp=datetime.now(),
+        )
+
+        if self.service_callback:
+            self.service_callback(service_response)
+
+    def get_light_level(
+        self,
+        serial_number: str,
+        output_number: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        Get the current auto report status for a specific module.
+
+        Args:
+            :param  serial_number: 10-digit module serial number
+            :param  output_number: output module number
+            :param  finish_callback: callback function to call when the lightlevel status is
+            :param  timeout_seconds: timeout in seconds
+
+        """
+        self.logger.info("Starting get_lightlevel_status")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.output_number = output_number
+        self.datapoint_type = DataPointType.MODULE_LIGHT_LEVEL
+
+        self.finish_callback = self.finish_service_callback
+        self.service_callback = finish_callback
+        self.start_reactor()

xp/services/conbus/conbus_lightlevel_set_service.py

@@ -0,0 +1,205 @@
+"""Conbus Lightlevel Service for controlling light levels on Conbus modules.
+
+This service implements lightlevel control operations for XP modules,
+including setting specific light levels, turning lights on/off, and
+querying current light levels.
+"""
+
+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_lightlevel import ConbusLightlevelResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.protocol import ConbusProtocol
+
+
+class ConbusLightlevelError(Exception):
+    """Raised when Conbus lightlevel operations fail"""
+
+    pass
+
+
+class ConbusLightlevelSetService(ConbusProtocol):
+    """
+    Service for controlling light levels on Conbus modules.
+
+    Manages lightlevel operations including setting specific levels,
+    turning lights on/off, and querying current states.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ):
+        """Initialize the Conbus lightlevel service"""
+        super().__init__(cli_config, reactor)
+        self.serial_number: str = ""
+        self.output_number: int = 0
+        self.level: int = 0
+        self.finish_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
+            None
+        )
+        self.service_response: ConbusLightlevelResponse = ConbusLightlevelResponse(
+            success=False,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            level=None,
+            timestamp=datetime.now(),
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        self.logger.debug(
+            f"Connection established, setting light level for output {self.output_number} to {self.level}%..."
+        )
+
+        # Format data as output_number:level (e.g., ""15" + "02:050")
+        data_value = f"{DataPointType.MODULE_LIGHT_LEVEL.value}{self.output_number:02d}:{self.level:03d}"
+
+        # Send telegram using WRITE_CONFIG function with MODULE_LIGHT_LEVEL datapoint
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.WRITE_CONFIG,  # "04"
+            data_value=data_value,
+        )
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        self.service_response.sent_telegram = telegram_sent
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        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
+
+        # Any valid reply means success (ACK or NAK)
+        if telegram_received.telegram_type == TelegramType.REPLY:
+            self.logger.debug("Received lightlevel response")
+            self.succeed()
+
+    def succeed(self) -> None:
+        self.logger.debug("Succeed")
+        self.service_response.success = True
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.level = self.level
+        self.service_response.timestamp = datetime.now()
+
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def failed(self, message: str) -> None:
+        self.logger.debug(f"Failed with message: {message}")
+        self.service_response.success = False
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.level = self.level
+        self.service_response.timestamp = datetime.now()
+        self.service_response.error = message
+
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def set_lightlevel(
+        self,
+        serial_number: str,
+        output_number: int,
+        level: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Set light level for a specific output on a module.
+
+        Args:
+            serial_number: Module serial number
+            output_number: Output number (0-based, 0-8)
+            level: Light level percentage (0-100)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+
+        Examples:
+            \b
+                xp conbus lightlevel set 0012345008 2 50
+                xp conbus lightlevel set 0012345008 0 100
+        """
+
+        self.logger.info(
+            f"Setting light level for {serial_number} output {output_number} to {level}%"
+        )
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.finish_callback = finish_callback
+        self.serial_number = serial_number
+        self.output_number = output_number
+        self.level = level
+
+        # Validate output_number range (0-8)
+        if not 0 <= self.output_number <= 8:
+            self.failed(
+                f"Output number must be between 0 and 8, got {self.output_number}"
+            )
+            return
+
+        # Validate level range
+        if not 0 <= self.level <= 100:
+            self.failed(f"Light level must be between 0 and 100, got {self.level}")
+            return
+
+        self.start_reactor()
+
+    def turn_off(
+        self,
+        serial_number: str,
+        output_number: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Turn off light (set level to 0) for a specific output.
+
+        Args:
+            serial_number: Module serial number
+            output_number: Output number (0-8)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+        """
+        self.set_lightlevel(
+            serial_number, output_number, 0, finish_callback, timeout_seconds
+        )
+
+    def turn_on(
+        self,
+        serial_number: str,
+        output_number: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Turn on light (set level to 80%) for a specific output.
+
+        Args:
+            serial_number: Module serial number
+            output_number: Output number (0-8)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+        """
+        self.set_lightlevel(
+            serial_number, output_number, 80, finish_callback, timeout_seconds
+        )

xp/services/conbus/conbus_linknumber_get_service.py

@@ -0,0 +1,86 @@
+"""Conbus Link Number Service for setting module link numbers.
+
+This service handles setting link numbers for modules through Conbus telegrams.
+"""
+
+import logging
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig, ConbusDatapointResponse
+from xp.models.conbus.conbus_linknumber import ConbusLinknumberResponse
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ConbusLinknumberGetService(ConbusDatapointService):
+    """
+    Service for receiving telegrams from Conbus servers.
+
+    Uses composition with ConbusService to provide receive-only functionality
+    for collecting waiting event telegrams from the server.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus client send service"""
+        super().__init__(telegram_service, cli_config, reactor)
+        self.service_callback: Optional[Callable[[ConbusLinknumberResponse], None]] = (
+            None
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def finish_service_callback(
+        self, datapoint_response: ConbusDatapointResponse
+    ) -> None:
+
+        self.logger.debug("Parsing datapoint response")
+        link_number_value = 0
+        if datapoint_response.success and datapoint_response.datapoint_telegram:
+            link_number_value = int(datapoint_response.datapoint_telegram.data_value)
+
+        linknumber_response = ConbusLinknumberResponse(
+            success=datapoint_response.success,
+            result="SUCCESS" if datapoint_response.success else "FAILURE",
+            link_number=link_number_value,
+            serial_number=self.serial_number,
+            error=datapoint_response.error,
+            sent_telegram=datapoint_response.sent_telegram,
+            received_telegrams=datapoint_response.received_telegrams,
+            timestamp=datapoint_response.timestamp,
+        )
+
+        if self.service_callback:
+            self.service_callback(linknumber_response)
+
+    def get_linknumber(
+        self,
+        serial_number: str,
+        finish_callback: Callable[[ConbusLinknumberResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        Get the current auto report status for a specific module.
+
+        Args:
+            :param  serial_number: 10-digit module serial number
+            :param  finish_callback: callback function to call when the linknumber status is
+            :param  timeout_seconds: timeout in seconds
+
+        """
+        self.logger.info("Starting get_linknumber")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.datapoint_type = DataPointType.LINK_NUMBER
+        self.finish_callback = self.finish_service_callback
+        self.service_callback = finish_callback
+        self.start_reactor()

xp/services/conbus/conbus_linknumber_set_service.py

@@ -0,0 +1,155 @@
+"""Conbus Link Number Service for setting module link numbers.
+
+This service handles setting link numbers 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_linknumber import ConbusLinknumberResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+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 ConbusLinknumberSetService(ConbusProtocol):
+    """
+    Service for setting module link numbers via Conbus telegrams.
+
+    Handles link number assignment by sending F04D04 telegrams and processing
+    ACK/NAK responses from modules.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus link number set service"""
+        super().__init__(cli_config, reactor)
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.link_number: int = 0
+        self.finish_callback: Optional[Callable[[ConbusLinknumberResponse], None]] = (
+            None
+        )
+        self.service_response: ConbusLinknumberResponse = ConbusLinknumberResponse(
+            success=False, serial_number=self.serial_number, result=""
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        self.logger.debug(
+            f"Connection established, setting link number {self.link_number}..."
+        )
+
+        # Validate parameters before sending
+        if not self.serial_number or len(self.serial_number) != 10:
+            self.failed(f"Serial number must be 10 digits, got: {self.serial_number}")
+            return
+
+        if not (0 <= self.link_number <= 99):
+            self.failed(f"Link number must be between 0-99, got: {self.link_number}")
+            return
+
+        # Send F04D04{link_number} telegram
+        # F04 = WRITE_CONFIG, D04 = LINK_NUMBER datapoint type
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.WRITE_CONFIG,
+            data_value=f"{DataPointType.LINK_NUMBER.value}{self.link_number:02d}",
+        )
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        self.service_response.sent_telegram = telegram_sent
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        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
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        if not reply_telegram:
+            self.logger.debug("Failed to parse reply telegram")
+            return
+
+        # Check for ACK or NAK response
+        if reply_telegram.system_function == SystemFunction.ACK:
+            self.logger.debug("Received ACK response")
+            self.succeed(SystemFunction.ACK)
+        elif reply_telegram.system_function == SystemFunction.NAK:
+            self.logger.debug("Received NAK response")
+            self.failed("Module responded with NAK")
+        else:
+            self.logger.debug(
+                f"Unexpected system function: {reply_telegram.system_function}"
+            )
+
+    def succeed(self, system_function: SystemFunction) -> None:
+        self.logger.debug("Successfully set link number")
+        self.service_response.success = True
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.result = "ACK"
+        self.service_response.link_number = self.link_number
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def failed(self, message: str) -> None:
+        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.result = "NAK"
+        self.service_response.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def set_linknumber(
+        self,
+        serial_number: str,
+        link_number: int,
+        finish_callback: Callable[[ConbusLinknumberResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        Set the link number for a specific module.
+
+        Args:
+            serial_number: 10-digit module serial number
+            link_number: Link number to set (0-99)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+        """
+        self.logger.info("Starting set_linknumber")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.link_number = link_number
+        self.finish_callback = finish_callback
+        self.start_reactor()