conson-xp 0.11.21__py3-none-any.whl → 1.1.0__py3-none-any.whl

xp/services/conbus/conbus_autoreport_get_service.py

@@ -4,22 +4,18 @@ This service handles auto report status operations for modules through Conbus te
 """
 
 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 import ConbusClientConfig, ConbusDatapointResponse
 from xp.models.conbus.conbus_autoreport import ConbusAutoreportResponse
-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.conbus.conbus_datapoint_service import ConbusDatapointService
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ConbusAutoreportGetService(ConbusProtocol):
+class ConbusAutoreportGetService(ConbusDatapointService):
     """
     Service for receiving telegrams from Conbus servers.
 
@@ -34,78 +30,35 @@ class ConbusAutoreportGetService(ConbusProtocol):
         reactor: PosixReactorBase,
     ) -> None:
         """Initialize the Conbus client send service"""
-        super().__init__(cli_config, reactor)
-        self.telegram_service = telegram_service
-        self.serial_number: str = ""
-        self.finish_callback: Optional[Callable[[ConbusAutoreportResponse], None]] = (
+        super().__init__(telegram_service, cli_config, reactor)
+        self.service_callback: Optional[Callable[[ConbusAutoreportResponse], None]] = (
             None
         )
-        self.service_response: ConbusAutoreportResponse = ConbusAutoreportResponse(
-            success=False,
-            serial_number=self.serial_number,
-        )
 
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
-        self.logger.debug("Connection established, retrieving autoreport status...")
-        self.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=self.serial_number,
-            system_function=SystemFunction.READ_DATAPOINT,
-            data_value=str(DataPointType.AUTO_REPORT_STATUS.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)
+    def finish_service_callback(
+        self, datapoint_response: ConbusDatapointResponse
+    ) -> None:
 
-        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
+        self.logger.debug("Parsing datapoint response")
+        autoreport_status = ""
+        if datapoint_response.success and datapoint_response.datapoint_telegram:
+            autoreport_status = datapoint_response.datapoint_telegram.data_value
 
-        reply_telegram = self.telegram_service.parse_reply_telegram(
-            telegram_received.frame
+        service_response = ConbusAutoreportResponse(
+            success=datapoint_response.success,
+            serial_number=self.serial_number,
+            auto_report_status=autoreport_status,
+            error=datapoint_response.error,
+            sent_telegram=datapoint_response.sent_telegram,
+            received_telegrams=datapoint_response.received_telegrams,
+            timestamp=datapoint_response.timestamp,
         )
-        if (
-            not reply_telegram
-            or reply_telegram.system_function != SystemFunction.READ_DATAPOINT
-            or reply_telegram.datapoint_type != DataPointType.AUTO_REPORT_STATUS
-        ):
-            self.logger.debug("Not an autoreport reply")
-            return
-
-        autoreport_status = reply_telegram.data_value
-        self.succeed(autoreport_status)
-
-    def succeed(self, autoreport_status: str) -> None:
-        self.logger.debug("Received autoreport status: {autoreport_status}")
-        self.service_response.success = True
-        self.service_response.serial_number = self.serial_number
-        self.service_response.timestamp = datetime.now()
-        self.service_response.auto_report_status = autoreport_status
-        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.timestamp = datetime.now()
-        self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+
+        if self.service_callback:
+            self.service_callback(service_response)
 
     def get_autoreport_status(
         self,
@@ -117,20 +70,16 @@ class ConbusAutoreportGetService(ConbusProtocol):
         Get the current auto report status for a specific module.
 
         Args:
-            serial_number: 10-digit module serial number
-            finish_callback: callback function to call when the autoreport status is
-            timeout_seconds: timeout in seconds
-
-        Returns:
-            ConbusAutoreportResponse with operation result and auto report status
+            :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
 
-        Raises:
-            ConbusAutoreportError: If the operation fails
         """
-
         self.logger.info("Starting get_autoreport_status")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
         self.serial_number = serial_number
+        self.datapoint_type = DataPointType.AUTO_REPORT_STATUS
+        self.finish_callback = self.finish_service_callback
+        self.service_callback = finish_callback
         self.start_reactor()

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

@@ -9,18 +9,14 @@ from typing import Callable, Optional
 
 from twisted.internet.posixbase import PosixReactorBase
 
-from xp.models import ConbusClientConfig
+from xp.models import ConbusClientConfig, ConbusDatapointResponse
 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.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.conbus.conbus_datapoint_service import ConbusDatapointService
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ConbusLightlevelGetService(ConbusProtocol):
+class ConbusLightlevelGetService(ConbusDatapointService):
     """
     Service for receiving telegrams from Conbus servers.
 
@@ -35,93 +31,46 @@ class ConbusLightlevelGetService(ConbusProtocol):
         reactor: PosixReactorBase,
     ) -> None:
         """Initialize the Conbus client send service"""
-        super().__init__(cli_config, reactor)
-        self.telegram_service = telegram_service
-        self.serial_number: str = ""
+        super().__init__(telegram_service, cli_config, reactor)
         self.output_number: int = 0
-        self.finish_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
+        self.service_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
             None
         )
-        self.service_response: ConbusLightlevelResponse = ConbusLightlevelResponse(
-            success=False,
-            serial_number=self.serial_number,
-            output_number=self.output_number,
-            level=0,
-            timestamp=datetime.now(),
-        )
 
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
-        self.logger.debug("Connection established, retrieving lightlevel status...")
-        self.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=self.serial_number,
-            system_function=SystemFunction.READ_DATAPOINT,
-            data_value=str(DataPointType.MODULE_LIGHT_LEVEL.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)
+    def finish_service_callback(
+        self, datapoint_response: ConbusDatapointResponse
+    ) -> None:
 
-        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
+        self.logger.debug("Parsing datapoint response")
 
-        reply_telegram = self.telegram_service.parse_reply_telegram(
-            telegram_received.frame
+        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 (
-            not reply_telegram
-            or reply_telegram.system_function != SystemFunction.READ_DATAPOINT
-            or reply_telegram.datapoint_type != DataPointType.MODULE_LIGHT_LEVEL
-        ):
-            self.logger.debug("Not a lightlevel telegram")
-            return
-
-        self.logger.debug("Received lightlevel status telegram")
-        lightlevel = self.extract_lightlevel(reply_telegram)
-        self.succeed(lightlevel)
-
-    def extract_lightlevel(self, reply_telegram: ReplyTelegram) -> int:
-        level = 0
-        for output_data in reply_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
-        return level
-
-    def succeed(self, lightlevel: int) -> None:
-        self.service_response.success = True
-        self.service_response.timestamp = datetime.now()
-        self.service_response.serial_number = self.serial_number
-        self.service_response.level = lightlevel
-        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.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        if self.service_callback:
+            self.service_callback(service_response)
 
     def get_light_level(
         self,
@@ -143,7 +92,10 @@ class ConbusLightlevelGetService(ConbusProtocol):
         self.logger.info("Starting get_lightlevel_status")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
         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_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()