conson-xp 0.11.16__tar.gz → 0.11.21__tar.gz

{conson_xp-0.11.16 → conson_xp-0.11.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 0.11.16
+Version: 0.11.21
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

{conson_xp-0.11.16 → conson_xp-0.11.21}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "0.11.16"
+version = "0.11.21"
 
 [project.license]
 file = "LICENSE"

{conson_xp-0.11.16 → conson_xp-0.11.21}/src/xp/__init__.py

@@ -2,7 +2,7 @@
 
 """conson-xp"""
 
-__version__ = "0.11.16"
+__version__ = "0.11.21"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-0.11.16 → conson_xp-0.11.21}/src/xp/cli/commands/__init__.py

@@ -38,7 +38,6 @@ from xp.cli.commands.conbus.conbus_datapoint_commands import (
 )
 from xp.cli.commands.conbus.conbus_discover_commands import send_discover_telegram
 from xp.cli.commands.conbus.conbus_lightlevel_commands import (
-    xp_lightlevel_get,
     xp_lightlevel_off,
     xp_lightlevel_on,
     xp_lightlevel_set,

{conson_xp-0.11.16 → conson_xp-0.11.21}/src/xp/cli/commands/conbus/conbus_blink_commands.py

@@ -11,6 +11,8 @@ from xp.cli.utils.decorators import (
     handle_service_errors,
 )
 from xp.cli.utils.serial_number_type import SERIAL
+from xp.models.conbus.conbus_blink import ConbusBlinkResponse
+from xp.services.conbus.conbus_blink_all_service import ConbusBlinkAllService
 from xp.services.conbus.conbus_blink_service import ConbusBlinkService
 from xp.services.telegram.telegram_blink_service import BlinkError
 
@@ -29,12 +31,15 @@ def send_blink_on_telegram(ctx: Context, serial_number: str) -> None:
     \b
         xp conbus blink on 0012345008
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
 
-    with service:
+    def finish(service_response: ConbusBlinkResponse) -> None:
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
 
-        response = service.send_blink_telegram(serial_number, "on")
-        click.echo(json.dumps(response.to_dict(), indent=2))
+    service: ConbusBlinkService = (
+        ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
+    )
+    with service:
+        service.send_blink_telegram(serial_number, "on", finish, 0.5)
 
 
 @conbus_blink.command("off")
@@ -51,12 +56,15 @@ def send_blink_off_telegram(ctx: Context, serial_number: str) -> None:
     \b
         xp conbus blink off 0012345008
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
 
-    with service:
+    def finish(service_response: ConbusBlinkResponse) -> None:
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
 
-        response = service.send_blink_telegram(serial_number, "off")
-        click.echo(json.dumps(response.to_dict(), indent=2))
+    service: ConbusBlinkService = (
+        ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
+    )
+    with service:
+        service.send_blink_telegram(serial_number, "off", finish, 0.5)
 
 
 @conbus_blink.group("all", short_help="Control blink state for all devices")
@@ -80,14 +88,19 @@ def blink_all_off(ctx: Context) -> None:
     \b
         xp conbus blink all off
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
 
+    def finish(discovered_devices: ConbusBlinkResponse) -> None:
+        click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
+
+    def progress(message: str) -> None:
+        click.echo(message)
+        pass
+
+    service: ConbusBlinkAllService = (
+        ctx.obj.get("container").get_container().resolve(ConbusBlinkAllService)
+    )
     with service:
-        response = service.blink_all("off")
-        if response.success:
-            click.echo("All devices blink turned off")
-        else:
-            click.echo(f"Error: {response.error}")
+        service.send_blink_all_telegram("off", progress, finish, 0.5)
 
 
 @conbus_blink_all.command("on", short_help="Turn on blinking for all devices")
@@ -103,11 +116,16 @@ def blink_all_on(ctx: Context) -> None:
     \b
         xp conbus blink all on
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
 
+    def finish(discovered_devices: ConbusBlinkResponse) -> None:
+        click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
+
+    def progress(message: str) -> None:
+        click.echo(message)
+        pass
+
+    service: ConbusBlinkAllService = (
+        ctx.obj.get("container").get_container().resolve(ConbusBlinkAllService)
+    )
     with service:
-        response = service.blink_all("on")
-        if response.success:
-            click.echo("All devices blink turned on")
-        else:
-            click.echo(f"Error: {response.error}")
+        service.send_blink_all_telegram("on", progress, finish, 0.5)

{conson_xp-0.11.16 → conson_xp-0.11.21}/src/xp/cli/commands/conbus/conbus_lightlevel_commands.py

@@ -10,9 +10,10 @@ from xp.cli.utils.decorators import (
     handle_service_errors,
 )
 from xp.cli.utils.serial_number_type import SERIAL
-from xp.services.conbus.conbus_lightlevel_service import (
+from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
+from xp.services.conbus.conbus_lightlevel_set_service import (
     ConbusLightlevelError,
-    ConbusLightlevelService,
+    ConbusLightlevelSetService,
 )
 
 
@@ -34,12 +35,17 @@ def xp_lightlevel_set(
         xp conbus lightlevel set 0123450001 2 50   # Set output 2 to 50%
         xp conbus lightlevel set 0011223344 0 100  # Set output 0 to 100%
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLightlevelService)
 
-    with service:
-        response = service.set_lightlevel(serial_number, output_number, level)
+    def finish(response: "ConbusLightlevelResponse") -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLightlevelSetService)
+    )
+
+    with service:
+        service.set_lightlevel(serial_number, output_number, level, finish, 0.5)
+
 
 @conbus_lightlevel.command("off")
 @click.argument("serial_number", type=SERIAL)
@@ -58,12 +64,17 @@ def xp_lightlevel_off(
         xp conbus lightlevel off 0123450001 2   # Turn off output 2
         xp conbus lightlevel off 0011223344 0   # Turn off output 0
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLightlevelService)
 
-    with service:
-        response = service.turn_off(serial_number, output_number)
+    def finish(response: "ConbusLightlevelResponse") -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLightlevelSetService)
+    )
+
+    with service:
+        service.turn_off(serial_number, output_number, finish, 0.5)
+
 
 @conbus_lightlevel.command("on")
 @click.argument("serial_number", type=SERIAL)
@@ -82,12 +93,17 @@ def xp_lightlevel_on(
         xp conbus lightlevel on 0123450001 2   # Turn on output 2 (80%)
         xp conbus lightlevel on 0011223344 0   # Turn on output 0 (80%)
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLightlevelService)
 
-    with service:
-        response = service.turn_on(serial_number, output_number)
+    def finish(response: "ConbusLightlevelResponse") -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLightlevelSetService)
+    )
+
+    with service:
+        service.turn_on(serial_number, output_number, finish, 0.5)
+
 
 @conbus_lightlevel.command("get")
 @click.argument("serial_number", type=SERIAL)
@@ -99,15 +115,18 @@ def xp_lightlevel_get(
     ctx: click.Context, serial_number: str, output_number: int
 ) -> None:
     """Get current light level for output_number on XP module serial_number
-
     Examples:
-
     \b
         xp conbus lightlevel get 0123450001 2   # Get light level for output 2
         xp conbus lightlevel get 0011223344 0   # Get light level for output 0
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLightlevelService)
 
-    with service:
-        response = service.get_lightlevel(serial_number, output_number)
+    def finish(response: "ConbusLightlevelResponse") -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
+
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLightlevelSetService)
+    )
+
+    with service:
+        service.get_lightlevel(serial_number, output_number, finish, 0.5)

conson_xp-0.11.21/src/xp/cli/commands/conbus/conbus_raw_commands.py

@@ -0,0 +1,51 @@
+"""Conbus raw telegram CLI commands."""
+
+import json
+
+import click
+from click import Context
+
+from xp.cli.commands.conbus.conbus import conbus
+from xp.cli.utils.decorators import (
+    connection_command,
+)
+from xp.models.conbus.conbus_raw import ConbusRawResponse
+from xp.services.conbus.conbus_raw_service import ConbusRawService
+
+
+@conbus.command("raw")
+@click.argument("raw_telegrams")
+@click.pass_context
+@connection_command()
+def send_raw_telegrams(ctx: Context, raw_telegrams: str) -> None:
+    """
+    Send raw telegram sequence to Conbus server.
+
+    Accepts a string containing one or more telegrams in format <...>.
+    Multiple telegrams should be concatenated without separators.
+
+    Examples:
+
+    \b
+        xp conbus raw '<S2113010000F02D12>'
+        xp conbus raw '<S2113010000F02D12><S2113010001F02D12><S2113010002F02D12>'
+        xp conbus raw '<S0012345003F02D12FM><S0012345004F02D12FD><S0012345005F02D12FI><S0012345006F02D12FL><S0012345007F02D12FK><S0012345008F02D12FJ><S0012345009F02D12FF>'
+    """
+    service: ConbusRawService = (
+        ctx.obj.get("container").get_container().resolve(ConbusRawService)
+    )
+
+    def on_progress(message: str) -> None:
+        click.echo(message)
+        pass
+
+    def on_finish(service_response: ConbusRawResponse) -> None:
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
+
+    with service:
+        service.send_raw_telegram(
+            raw_input=raw_telegrams,
+            progress_callback=on_progress,
+            finish_callback=on_finish,
+            timeout_seconds=5.0,
+        )

{conson_xp-0.11.16 → conson_xp-0.11.21}/src/xp/models/conbus/conbus_blink.py

@@ -31,10 +31,30 @@ class ConbusBlinkResponse:
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for JSON serialization"""
-        return {
+        result = {
             "success": self.success,
-            "sent_telegram": self.sent_telegram,
-            "received_telegrams": self.received_telegrams,
-            "error": self.error,
+            "serial_number": self.serial_number,
+            "operation": self.operation,
+            "system_function": (
+                self.system_function.name if self.system_function else None
+            ),
+            "sent_telegram": (
+                self.sent_telegram.to_dict()
+                if self.sent_telegram and hasattr(self.sent_telegram, "to_dict")
+                else str(self.sent_telegram) if self.sent_telegram else None
+            ),
+            "reply_telegram": (
+                self.reply_telegram.to_dict()
+                if self.reply_telegram and hasattr(self.reply_telegram, "to_dict")
+                else str(self.reply_telegram) if self.reply_telegram else None
+            ),
             "timestamp": self.timestamp.isoformat() if self.timestamp else None,
         }
+
+        # Only include these if they have values
+        if self.received_telegrams:
+            result["received_telegrams"] = self.received_telegrams
+        if self.error:
+            result["error"] = self.error
+
+        return result

{conson_xp-0.11.16 → conson_xp-0.11.21}/src/xp/services/conbus/conbus_autoreport_get_service.py

@@ -79,22 +79,29 @@ class ConbusAutoreportGetService(ConbusProtocol):
             telegram_received.frame
         )
         if (
-            reply_telegram is not None
-            and reply_telegram.system_function == SystemFunction.READ_DATAPOINT
-            and reply_telegram.datapoint_type == DataPointType.AUTO_REPORT_STATUS
+            not reply_telegram
+            or reply_telegram.system_function != SystemFunction.READ_DATAPOINT
+            or reply_telegram.datapoint_type != DataPointType.AUTO_REPORT_STATUS
         ):
-            self.logger.debug("Received autoreport status telegram")
-            self.service_response.success = True
-            self.service_response.timestamp = datetime.now()
-            self.service_response.serial_number = self.serial_number
-            self.service_response.auto_report_status = reply_telegram.data_value
+            self.logger.debug("Not an autoreport reply")
+            return
+
+        autoreport_status = reply_telegram.data_value
+        self.succeed(autoreport_status)
 
-            if self.finish_callback:
-                self.finish_callback(self.service_response)
+    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:

conson_xp-0.11.21/src/xp/services/conbus/conbus_blink_all_service.py

@@ -0,0 +1,162 @@
+"""Conbus Client Send Service for TCP communication with Conbus servers.
+
+This service implements a TCP client that connects to Conbus servers and sends
+various types of telegrams including discover, version, and sensor data requests.
+"""
+
+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 ConbusBlinkAllService(ConbusProtocol):
+    """
+    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__(cli_config, reactor)
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.on_or_off = "none"
+        self.progress_callback: Optional[Callable[[str], None]] = 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:
+        self.logger.debug("Connection established, send discover telegram...")
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number="0000000000",
+            system_function=SystemFunction.DISCOVERY,
+            data_value="00",
+        )
+        if self.progress_callback:
+            self.progress_callback(".")
+
+    def send_blink(self, serial_number: str) -> None:
+        self.logger.debug("Device discovered, send blink...")
+
+        # 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=serial_number,
+            system_function=system_function,
+            data_value="00",
+        )
+        self.service_response.system_function = system_function
+        self.service_response.operation = self.on_or_off
+
+        if self.progress_callback:
+            self.progress_callback(".")
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        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:
+
+        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
+        ):
+            self.logger.debug("Not a reply")
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+        if (
+            reply_telegram
+            and reply_telegram.system_function == SystemFunction.DISCOVERY
+        ):
+            self.logger.debug("Received discovery response")
+            self.send_blink(reply_telegram.serial_number)
+            if self.progress_callback:
+                self.progress_callback(".")
+            return
+
+        if reply_telegram and reply_telegram.system_function in (
+            SystemFunction.BLINK,
+            SystemFunction.UNBLINK,
+        ):
+            self.logger.debug("Received blink response")
+            if self.progress_callback:
+                self.progress_callback(".")
+            return
+
+        self.logger.debug("Received unexpected 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)
+
+    def send_blink_all_telegram(
+        self,
+        on_or_off: str,
+        progress_callback: Callable[[str], None],
+        finish_callback: Callable[[ConbusBlinkResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        Get the current auto report status for a specific module.
+
+        Args:
+            on_or_off: blink or unblink device
+            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
+
+        Raises:
+            ConbusAutoreportError: If the operation fails
+        """
+
+        self.logger.info("Starting get_autoreport_status")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.progress_callback = progress_callback
+        self.finish_callback = finish_callback
+        self.on_or_off = on_or_off
+        self.start_reactor()

conson_xp-0.11.21/src/xp/services/conbus/conbus_blink_service.py

@@ -0,0 +1,134 @@
+"""Conbus Client Send Service for TCP communication with Conbus servers.
+
+This service implements a TCP client that connects to Conbus servers and sends
+various types of telegrams including discover, version, and sensor data requests.
+"""
+
+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 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__(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:
+        self.logger.debug("Connection established, retrieving autoreport status...")
+        # 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:
+        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:
+
+        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:
+        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:
+        """
+        Send blink command to start blinking module LED.
+
+        Examples:
+
+        \b
+            xp conbus blink 0012345008 on
+            xp conbus blink 0012345008 off
+        """
+
+        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.on_or_off = on_or_off
+        self.start_reactor()

{conson_xp-0.11.16 → conson_xp-0.11.21}/src/xp/services/conbus/conbus_discover_service.py

@@ -59,8 +59,8 @@ class ConbusDiscoverService(ConbusProtocol):
         self.discovered_device_result.received_telegrams.append(telegram_received.frame)
 
         if (
-            telegram_received.telegram_type == TelegramType.REPLY.value
-            and telegram_received.checksum_valid
+            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
         ):