conson-xp 1.15.0__py3-none-any.whl → 1.17.0__py3-none-any.whl

{conson_xp-1.15.0.dist-info → conson_xp-1.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.15.0
+Version: 1.17.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -47,6 +47,7 @@ Requires-Dist: HAP-python[QRCode]>=5.0.0
 Requires-Dist: punq>=0.7.0
 Requires-Dist: twisted>=25.5.0
 Requires-Dist: bubus>=1.5.6
+Requires-Dist: psygnal>=0.15.0
 Description-Content-Type: text/markdown
 
 # 🔌 XP Protocol Communication Tool
@@ -304,6 +305,10 @@ xp conbus datapoint query
 
 xp conbus discover
 
+xp conbus event
+xp conbus event raw
+
+
 xp conbus lightlevel
 xp conbus lightlevel get
 xp conbus lightlevel off

{conson_xp-1.15.0.dist-info → conson_xp-1.17.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-conson_xp-1.15.0.dist-info/METADATA,sha256=1uDwWEJsmWvUk8RjzbLoPj0WrlRujgplsRRb5NHEJdU,9437
-conson_xp-1.15.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-conson_xp-1.15.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.15.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=cQLZ0V5wACMFH4b8H0g8gWRKytLc5RdIi_JA8HVho6Q,181
+conson_xp-1.17.0.dist-info/METADATA,sha256=Ib3pQUP44vhlduSotZu5juw2A86rHXgnO1e3fHrhuLg,9506
+conson_xp-1.17.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+conson_xp-1.17.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.17.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=3Amcz5pSjBDLeWf7aPWXM1DtmHeDt9T4cbNlNM6t964,181
 xp/cli/__init__.py,sha256=QjnKB1KaI2aIyKlzrnvCwfbBuUj8HNgwNMvNJVQofbI,81
 xp/cli/__main__.py,sha256=l2iKwMdat5rTGd3JWs-uGksnYYDDffp_Npz05QdKEeU,117
-xp/cli/commands/__init__.py,sha256=EGDWTEH_pCKIMWelnjhK4_PxBsvIH24rO9fz1nF1pKA,4638
+xp/cli/commands/__init__.py,sha256=wvo9Z5viwpjvO2432E7YP5HWjLLiW1IFpyXLc5puuGY,4766
 xp/cli/commands/conbus/__init__.py,sha256=gE3K5OEoXkkZX8UOc2v3nreQQzwkOQi7n0VZ-Z2juXA,495
 xp/cli/commands/conbus/conbus.py,sha256=eqdY8ArapvD08Z4p7Xk7eh4z0dESHuMSw7PKtwTJRYU,3021
 xp/cli/commands/conbus/conbus_actiontable_commands.py,sha256=cdjLV9cnm7teEOlu5Jf1MS_aL7lNy8KiDIyjCQa5Nzw,7138
@@ -14,7 +14,8 @@ xp/cli/commands/conbus/conbus_blink_commands.py,sha256=UK-Ey4K0FvaPQ96U0gyMid236
 xp/cli/commands/conbus/conbus_config_commands.py,sha256=BugIbgNX6_s4MySGvI6tWZkwguciajHUX2Xz8XBux7k,716
 xp/cli/commands/conbus/conbus_custom_commands.py,sha256=lICT93ijMdhVRm8KjNMLo7kQ2BLlnOZvMPbR3SxSmZ4,1692
 xp/cli/commands/conbus/conbus_datapoint_commands.py,sha256=r36OuTjREtbGKL-bskAGa0-WLw7x06td6woZn3GYJNA,3630
-xp/cli/commands/conbus/conbus_discover_commands.py,sha256=Jt-OjARc-QXCr453bhKG0zXRqvOMVKZr328zNxSDulY,1373
+xp/cli/commands/conbus/conbus_discover_commands.py,sha256=-y3TDgOnw1_cjvxvgyfQ1GQE2_WmYq-l8Md7DsdTXmo,1719
+xp/cli/commands/conbus/conbus_event_commands.py,sha256=8IjQfX9vXlTRprb1oGkMRHRDPmxb02ZnmVbv3ltCqGk,3369
 xp/cli/commands/conbus/conbus_lightlevel_commands.py,sha256=FpCwogdxa7yFUjlrxM7e8Q2Ut32tKAHabngQQChvtJI,6763
 xp/cli/commands/conbus/conbus_linknumber_commands.py,sha256=KitaGDM5HpwVUz8rLpO8VZUypUTcAg3Bzl0DVm6gnSk,3391
 xp/cli/commands/conbus/conbus_modulenumber_commands.py,sha256=L7-6y3rDllOjQ9g6Bk_RiTKIhAOHVPLdxWif9exkngs,3463
@@ -39,7 +40,7 @@ xp/cli/commands/telegram/telegram_discover_commands.py,sha256=0UArJinw1eWFbee5EG
 xp/cli/commands/telegram/telegram_linknumber_commands.py,sha256=7j0-E5Moqqga4NrKDch82C6glaFDFMQn5_3hMwie7BQ,2511
 xp/cli/commands/telegram/telegram_parse_commands.py,sha256=_OYOso1hS4f_ox96qlkYL2SuFnmimpAvqqdYlLzX9yo,2232
 xp/cli/commands/telegram/telegram_version_commands.py,sha256=WQyx1-B9yJ8V9WrFyBpOvULJ-jq12GoZZDDoRbM7eyw,1553
-xp/cli/main.py,sha256=52nMDP2Pq-W1PP4_BU5ybyTuO6QrStWOeLr44Wl_gB8,2812
+xp/cli/main.py,sha256=3TY4wZoKMK8kQBgOn0WshTsag4J4ofoGoGPgg12wueM,2810
 xp/cli/utils/__init__.py,sha256=gTGIj60Uai0iE7sr9_TtEpl04fD7krtTzbbigXUsUVU,46
 xp/cli/utils/click_tree.py,sha256=ilmM2IMa_c-TqUMsv2alrZXuS0BNhvVlrBlSfyN8lzM,1670
 xp/cli/utils/datapoint_type_choice.py,sha256=HcydhlqxZ7YyorEeTjFGkypF2JnYNPvOzkl1rhZ93Fc,1666
@@ -51,7 +52,7 @@ xp/cli/utils/system_function_choice.py,sha256=0J02EMgAQcsrE-9rEkv6YHelBoBkZ73T8V
 xp/cli/utils/xp_module_type.py,sha256=qSFJBRceqPi_cUFPxAWtLUNq37-KwUEjo9ekYOj7kLQ,1471
 xp/connection/__init__.py,sha256=ClJsVWALYZgAGYZK_Jznd3YKLrHDu17kBfwugjuPfu0,209
 xp/connection/exceptions.py,sha256=7CcRUzkyay5zA6Z9-5dIDRzua806v5N7pCcJazP_1dE,365
-xp/models/__init__.py,sha256=wCyJNKBd8J2ziOm0g00eUZH4OeTaLO5vHuoQGd_AJbg,1111
+xp/models/__init__.py,sha256=UaUiuvWevneh9gPzKNaVsuy6rxM7YlZg4mi8VlEJpfg,1210
 xp/models/actiontable/__init__.py,sha256=6kVq1rTOlpc24sZxGGVWkY48tqR42YWHLQHqakWqlPc,43
 xp/models/actiontable/actiontable.py,sha256=bIeluZhMsvukkSwy2neaewavU8YR6Pso3PIvJ8ENlGg,1251
 xp/models/actiontable/msactiontable_xp20.py,sha256=C_lYYIQagEFap0S5S40_S7AhLO2UZG2EmXjjeem7uw8,1967
@@ -66,6 +67,7 @@ xp/models/conbus/conbus_connection_status.py,sha256=iGbmtBaAMwV6UD7XG3H3tnB0fl2M
 xp/models/conbus/conbus_custom.py,sha256=8H2sPR6_LIlksuOvL7-8bPkzAJLR0rpYiiwfYYFVjEo,1965
 xp/models/conbus/conbus_datapoint.py,sha256=4ncR-vB2lRzRBAA30rYn8eguyTxsZoOKrrXtjGmPpWg,3396
 xp/models/conbus/conbus_discover.py,sha256=nxxUEKfEsH1kd0BF8ovMs7zLujRhrq1oL9ZJtysPr5o,2238
+xp/models/conbus/conbus_event_raw.py,sha256=i5gc7z-0yeunWOZ4rw3AiBt4MANezmhBQKjOOQk3oDc,1567
 xp/models/conbus/conbus_lightlevel.py,sha256=GQGhzrCBEJROosNHInXIzBy6MD2AskEIMoFEGgZ60-0,1695
 xp/models/conbus/conbus_linknumber.py,sha256=uFzKzfB06oIzZEKCb5X2JEI80JjMPFuYglsT1W1k8j4,1815
 xp/models/conbus/conbus_output.py,sha256=q7QKsD_CWT7YOk-V3otKWD1VM7qThrSLIUOunntMrMc,1953
@@ -78,7 +80,7 @@ xp/models/homekit/homekit_config.py,sha256=Y_k92PsKHFBnn3r1_RSZHJP5uLH27Gw8G7Bj5
 xp/models/homekit/homekit_conson_config.py,sha256=NML644Ij7abstMbud-TUPcxraGY4vQwKrkJOwftv2pM,2603
 xp/models/log_entry.py,sha256=kPcYuAirCXugfL3YkOK9cQVlkNWxG_8a4AVuhsykHL0,4355
 xp/models/protocol/__init__.py,sha256=TJ_CJKchA-xgQiv5vCo_ndBBZjrcaTmjT74bR0T-5Cw,38
-xp/models/protocol/conbus_protocol.py,sha256=igRgnbfjhnmNZG6kqQw4un433EpKTMXR13MJW151_7U,9041
+xp/models/protocol/conbus_protocol.py,sha256=3uWYE_t_-mp_2wPEgbDHbZoeQSEv48IdRcQpQyemEY0,9141
 xp/models/response.py,sha256=h6_B1k_v6IrWhgNWBohEGQGRCp5TcVhgQ3RJS8gTkhY,1230
 xp/models/telegram/__init__.py,sha256=-_exhjlRLbBNuPxHC4tLA2SAgf8M0yHJMeyEoQIk9PI,53
 xp/models/telegram/action_type.py,sha256=vkw_chTgmsadksGXvZ9D_qYGpjOwCw-OgbEi8Bml17g,783
@@ -115,8 +117,9 @@ xp/services/conbus/conbus_blink_all_service.py,sha256=OaEg4b8AEiEruHSkZ5jDtaoI81
 xp/services/conbus/conbus_blink_service.py,sha256=x9uM-sLnIEV8wSNsvJgo08E042g-Hh2ZF3rXkz-k_9s,5824
 xp/services/conbus/conbus_custom_service.py,sha256=4aneYdPObiZOGxPFYg5Wr70cl_xFxlQIdJBPQSa0enI,5826
 xp/services/conbus/conbus_datapoint_queryall_service.py,sha256=p9R02cVimhdJILHQ6BoeZj8Hog4oRpqBnMo3t4R8ecY,6816
-xp/services/conbus/conbus_datapoint_service.py,sha256=NsqRQfNsZ4_Pbe7kcMQpUqfhVPH7H148JDWH49ExQ1E,6392
-xp/services/conbus/conbus_discover_service.py,sha256=lH6I8YcN7Beo_f-M8XkNZ_5UuNB-x2R9U5xJNTK-QXE,10110
+xp/services/conbus/conbus_datapoint_service.py,sha256=SYhHj9RmTmaJ750tyZ1IW2kl7tgDQ1xm_EM1zUjk1aQ,6421
+xp/services/conbus/conbus_discover_service.py,sha256=sSCSDNWWGtx5QOShwJfcbG54WCYH-BxWvgE10ghibN4,12326
+xp/services/conbus/conbus_event_raw_service.py,sha256=zNY7GxT4R6ROsT1dDhoOoJkGtGbv2_AIBgOlLxZJl1A,7068
 xp/services/conbus/conbus_output_service.py,sha256=mHFOAPx2zo0TStZ3pokp6v94AQjIamcwZDeg5YH_-eo,7240
 xp/services/conbus/conbus_raw_service.py,sha256=4yZLLTIAOxpgByUTWZXw1ihGa6Xtl98ckj9T7VfprDI,4335
 xp/services/conbus/conbus_receive_service.py,sha256=frXrS0OyKKvYYQTWdma21Kd0BKw5aSuHn3ZXTTqOaj0,3953
@@ -133,12 +136,13 @@ xp/services/homekit/homekit_hap_service.py,sha256=YrFe10XPBf6EC2SRnWmcCbjdVkrHjx
 xp/services/homekit/homekit_lightbulb.py,sha256=7HGMIPwEcmvSs89ENcDhdb8g0R9WMq7115gYuwcskAs,3661
 xp/services/homekit/homekit_lightbulb_service.py,sha256=G_ummBFiBurhQ2ZVwJ9l_aZ2MQgl5Uq-oi3KjIrdb-Y,2752
 xp/services/homekit/homekit_module_service.py,sha256=7lanEinxAfTdn28ZHV-O5YyTqq_3v8FIyP2FI0jsEQM,1526
-xp/services/homekit/homekit_outlet.py,sha256=_Glfytfmvydz9TEn69N6bw3Ux0Y-EMw2eJPgeborkoA,5268
+xp/services/homekit/homekit_outlet.py,sha256=TtrOwVF3BkEvDcTOkNJIWT64zhtPLFkDgtyzW6u_4yQ,5209
 xp/services/homekit/homekit_outlet_service.py,sha256=y7DbWbbvihWwF1Gyl0l9Hup1JHin6PTlDEHdoIqTfEQ,3798
 xp/services/homekit/homekit_service.py,sha256=0lW-hg40ETco3gDBEYkR_sX-UIYsLSKCD4NWruLXUM8,14031
 xp/services/log_file_service.py,sha256=fvPcZQj8XOKUA-4ep5R8n0PelvwvRlTLlVxvIWM5KR4,10506
 xp/services/module_type_service.py,sha256=xWhr1EAZMykL5uNWHWdpa5T8yNruGKH43XRTOS8GwZg,7477
-xp/services/protocol/__init__.py,sha256=WuYn2iEcvsOIXnn5HCrU9kD3PjuMX1sIh0ljKISDoJw,720
+xp/services/protocol/__init__.py,sha256=qRufBmqRKGzpuzZ5bxBbmwf510TT00Ke8s5HcWGnqRY,818
+xp/services/protocol/conbus_event_protocol.py,sha256=btWLGM-onWXVIvL5atD7HgQKNcx6F8dNqTZf2CSquiE,12272
 xp/services/protocol/conbus_protocol.py,sha256=JO7yLkD_ohPT0ETjnAIx4CGpZyobf4LdbuozM_43btE,10276
 xp/services/protocol/protocol_factory.py,sha256=PmjN9AtW9sxNo3voqUiNgQA-pTvX1RW4XXFlHKfFr5Q,2470
 xp/services/protocol/telegram_protocol.py,sha256=Ki5DrXsKxiaqLcdP9WWUuhUI7cPu2DfwyZkh-Gv9Lb8,9496
@@ -164,8 +168,8 @@ xp/services/telegram/telegram_service.py,sha256=XrP1CPi0ckxoKBaNwLA6lo-TogWxXgmX
 xp/services/telegram/telegram_version_service.py,sha256=M5HdOTsLdcwo122FP-jW6R740ktLrtKf2TiMDVz23h8,10528
 xp/utils/__init__.py,sha256=_avMF_UOkfR3tNeDIPqQ5odmbq5raKkaq1rZ9Cn1CJs,332
 xp/utils/checksum.py,sha256=HDpiQxmdIedbCbZ4o_Box0i_Zig417BtCV_46ZyhiTk,1711
-xp/utils/dependencies.py,sha256=ibTkpQ7nak2ioqlPtb7yCqBJ9tl3NHSxDdODtUItbCg,20281
+xp/utils/dependencies.py,sha256=QsZfPDMdlrQK01YQ4PRQ8Q59ZF9w22h1evWX3J4xCjE,20930
 xp/utils/event_helper.py,sha256=W-A_xmoXlpWZBbJH6qdaN50o3-XrwFsDgvAGMJDiAgo,1001
 xp/utils/serialization.py,sha256=RWHHk86feaB4ZP7rjE4qOWK0900yg2joUBDkP76gfOY,4618
 xp/utils/time_utils.py,sha256=dEyViDlAG9GWU-J3D_YVa-sGma6yiyyMTgN4h2x3PY4,3781
-conson_xp-1.15.0.dist-info/RECORD,,
+conson_xp-1.17.0.dist-info/RECORD,,

xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.15.0"
+__version__ = "1.17.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

xp/cli/commands/__init__.py

@@ -37,6 +37,7 @@ from xp.cli.commands.conbus.conbus_datapoint_commands import (
     query_datapoint,
 )
 from xp.cli.commands.conbus.conbus_discover_commands import send_discover_telegram
+from xp.cli.commands.conbus.conbus_event_commands import conbus_event, send_event_raw
 from xp.cli.commands.conbus.conbus_lightlevel_commands import (
     xp_lightlevel_get,
     xp_lightlevel_off,
@@ -97,6 +98,7 @@ __all__ = [
     "conbus_lightlevel",
     "conbus_msactiontable",
     "conbus_actiontable",
+    "conbus_event",
     "file",
     "module",
     "reverse_proxy",
@@ -118,6 +120,7 @@ __all__ = [
     "show_config",
     "send_custom_telegram",
     "send_discover_telegram",
+    "send_event_raw",
     "xp_output_on",
     "xp_output_off",
     "xp_output_status",

xp/cli/commands/conbus/conbus_discover_commands.py

@@ -9,6 +9,7 @@ from xp.cli.utils.decorators import (
     connection_command,
 )
 from xp.models import ConbusDiscoverResponse
+from xp.models.conbus.conbus_discover import DiscoveredDevice
 from xp.services.conbus.conbus_discover_service import (
     ConbusDiscoverService,
 )
@@ -36,6 +37,14 @@ def send_discover_telegram(ctx: click.Context) -> None:
         """
         click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
 
+    def on_device_discovered(discovered_device: DiscoveredDevice) -> None:
+        """Handle discovery of sa single module.
+
+        Args:
+            discovered_device: Discover device.
+        """
+        click.echo(json.dumps(discovered_device, indent=2))
+
     def progress(_serial_number: str) -> None:
         """Handle progress updates during device discovery.
 
@@ -48,5 +57,5 @@ def send_discover_telegram(ctx: click.Context) -> None:
     service: ConbusDiscoverService = (
         ctx.obj.get("container").get_container().resolve(ConbusDiscoverService)
     )
-    with service:
-        service.start(progress, on_finish, 0.5)
+    service.run(progress, on_device_discovered, on_finish, 5)
+    service.start_reactor()

xp/cli/commands/conbus/conbus_event_commands.py

@@ -0,0 +1,115 @@
+"""Conbus event operations CLI commands."""
+
+import json
+
+import click
+
+from xp.cli.commands.conbus.conbus import conbus
+from xp.cli.utils.decorators import connection_command
+from xp.models import ConbusEventRawResponse
+from xp.models.telegram.module_type_code import ModuleTypeCode
+from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
+
+
+@click.group(name="event")
+def conbus_event() -> None:
+    """Send event telegrams to Conbus modules."""
+    pass
+
+
+@conbus_event.command("raw")
+@click.argument("module_type", type=str)
+@click.argument("link_number", type=int)
+@click.argument("input_number", type=int)
+@click.argument("time_ms", type=int, default=1000)
+@click.pass_context
+@connection_command()
+def send_event_raw(
+    ctx: click.Context,
+    module_type: str,
+    link_number: int,
+    input_number: int,
+    time_ms: int,
+) -> None:
+    r"""Send raw event telegrams to simulate button presses.
+
+    Args:
+        ctx: Click context object.
+        module_type: Module type code (e.g., CP20, XP33).
+        link_number: Link number (0-99).
+        input_number: Input number (0-9).
+        time_ms: Delay between MAKE/BREAK events in milliseconds (default: 1000).
+
+    Examples:
+        \b
+        xp conbus event raw CP20 00 00
+        xp conbus event raw XP33 00 00 500
+    """
+    # Validate parameters
+    if link_number < 0 or link_number > 99:
+        click.echo(
+            json.dumps({"error": "Link number must be between 0 and 99"}, indent=2)
+        )
+        return
+
+    if input_number < 0 or input_number > 9:
+        click.echo(
+            json.dumps({"error": "Input number must be between 0 and 9"}, indent=2)
+        )
+        return
+
+    if time_ms <= 0:
+        click.echo(json.dumps({"error": "Time must be greater than 0"}, indent=2))
+        return
+
+    # Resolve module type to numeric code
+    module_type_code: int = 0
+    try:
+        # Try to get the enum value by name
+        module_type_enum = ModuleTypeCode[module_type.upper()]
+        module_type_code = module_type_enum.value
+    except KeyError:
+        # Module type not found
+        click.echo(
+            json.dumps(
+                {
+                    "error": f"Unknown module type: {module_type}. Use module types like CP20, XP33, XP24, etc."
+                },
+                indent=2,
+            )
+        )
+        return
+
+    def on_finish(response: ConbusEventRawResponse) -> None:
+        """Handle successful completion of event raw operation.
+
+        Args:
+            response: Event raw response with sent and received telegrams.
+        """
+        click.echo(json.dumps(response.to_dict(), indent=2))
+
+    def on_progress(telegram: str) -> None:
+        """Handle progress updates during event operation.
+
+        Args:
+            telegram: Received telegram.
+        """
+        click.echo(json.dumps({"telegram": telegram}))
+
+    service: ConbusEventRawService = (
+        ctx.obj.get("container").get_container().resolve(ConbusEventRawService)
+    )
+    service.run(
+        module_type_code=module_type_code,
+        link_number=link_number,
+        input_number=input_number,
+        time_ms=time_ms,
+        progress_callback=on_progress,
+        finish_callback=on_finish,
+        timeout_seconds=5,
+    )
+    service.start_reactor()
+
+
+# Register the event command group with conbus
+conbus.add_command(conbus_event)

xp/cli/main.py

@@ -56,7 +56,7 @@ def cli(ctx: click.Context) -> None:
 
     # xp
     logging.getLogger("xp").setLevel(logging.DEBUG)
-    logging.getLogger("xp.services.homekit").setLevel(logging.WARNING)
+    logging.getLogger("xp.services.homekit").setLevel(logging.DEBUG)
 
     # pyhap
     logging.getLogger("pyhap").setLevel(logging.WARNING)

xp/models/__init__.py

@@ -5,6 +5,7 @@ from xp.models.conbus.conbus_client_config import ConbusClientConfig
 from xp.models.conbus.conbus_connection_status import ConbusConnectionStatus
 from xp.models.conbus.conbus_datapoint import ConbusDatapointResponse
 from xp.models.conbus.conbus_discover import ConbusDiscoverResponse
+from xp.models.conbus.conbus_event_raw import ConbusEventRawResponse
 from xp.models.log_entry import LogEntry
 from xp.models.telegram.event_telegram import EventTelegram
 from xp.models.telegram.event_type import EventType
@@ -30,5 +31,6 @@ __all__ = [
     "ConbusResponse",
     "ConbusDatapointResponse",
     "ConbusDiscoverResponse",
+    "ConbusEventRawResponse",
     "ConbusConnectionStatus",
 ]

xp/models/conbus/conbus_event_raw.py

@@ -0,0 +1,47 @@
+"""Conbus event raw response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusEventRawResponse:
+    """Represents a response from Conbus event raw operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        sent_telegrams: List of event telegrams sent (MAKE and BREAK).
+        received_telegrams: List of all telegrams received.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    sent_telegrams: Optional[list[str]] = None
+    received_telegrams: Optional[list[str]] = None
+    error: Optional[str] = None
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp and telegram lists if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+        if self.sent_telegrams is None:
+            self.sent_telegrams = []
+        if self.received_telegrams is None:
+            self.received_telegrams = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        return {
+            "success": self.success,
+            "sent_telegrams": self.sent_telegrams,
+            "received_telegrams": self.received_telegrams,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

xp/models/protocol/conbus_protocol.py

@@ -12,6 +12,7 @@ from xp.models.homekit.homekit_conson_config import ConsonModuleConfig
 from xp.models.telegram.datapoint_type import DataPointType
 
 if TYPE_CHECKING:
+    from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
     from xp.services.protocol.conbus_protocol import ConbusProtocol
     from xp.services.protocol.telegram_protocol import TelegramProtocol
 
@@ -249,7 +250,7 @@ class TelegramEvent(BaseEvent):
         checksum_valid: Checksum valid true or false.
     """
 
-    protocol: Union[TelegramProtocol, ConbusProtocol] = Field(
+    protocol: Union[TelegramProtocol, ConbusProtocol, ConbusEventProtocol] = Field(
         description="TelegramProtocol instance"
     )
     frame: str = Field(description="Frame <S0123450001F02D12FK>")

xp/services/conbus/conbus_datapoint_service.py

@@ -130,6 +130,7 @@ class ConbusDatapointService(ConbusProtocol):
         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.

xp/services/conbus/conbus_discover_service.py

@@ -7,49 +7,57 @@ discover telegrams to find modules on the network.
 import logging
 from typing import Callable, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
-
-from xp.models import ConbusClientConfig, ConbusDiscoverResponse
+from xp.models import ConbusDiscoverResponse
 from xp.models.conbus.conbus_discover import DiscoveredDevice
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.module_type_code import MODULE_TYPE_REGISTRY
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
-from xp.services.protocol.conbus_protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 
 
-class ConbusDiscoverService(ConbusProtocol):
+class ConbusDiscoverService:
     """
     Service for discovering modules on Conbus servers.
 
     Uses ConbusProtocol to provide discovery functionality for finding
     modules connected to the Conbus network.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
     """
 
-    def __init__(
-        self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
+    conbus_protocol: ConbusEventProtocol
+
+    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
         """Initialize the Conbus discover service.
 
         Args:
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
+            conbus_protocol: ConbusProtocol.
         """
-        super().__init__(cli_config, reactor)
         self.progress_callback: Optional[Callable[[str], None]] = None
+        self.device_discover_callback: Optional[Callable[[DiscoveredDevice], None]] = (
+            None
+        )
         self.finish_callback: Optional[Callable[[ConbusDiscoverResponse], None]] = None
 
+        self.conbus_protocol: ConbusEventProtocol = conbus_protocol
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
         self.discovered_device_result = ConbusDiscoverResponse(success=False)
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
+    def connection_made(self) -> None:
         """Handle connection established event."""
-        self.logger.debug("Connection established, sending discover telegram")
-        self.send_telegram(
+        self.logger.debug("Connection established")
+        self.logger.debug("Sending discover telegram")
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number="0000000000",
             system_function=SystemFunction.DISCOVERY,
@@ -83,7 +91,7 @@ class ConbusDiscoverService(ConbusProtocol):
             and telegram_received.payload[11:16] == "F01D"
             and len(telegram_received.payload) == 15
         ):
-            self.discovered_device(telegram_received.serial_number)
+            self.handle_discovered_device(telegram_received.serial_number)
 
         # Check for module type response (F02D07)
         elif (
@@ -109,7 +117,7 @@ class ConbusDiscoverService(ConbusProtocol):
         else:
             self.logger.debug("Not a discover or module type response")
 
-    def discovered_device(self, serial_number: str) -> None:
+    def handle_discovered_device(self, serial_number: str) -> None:
         """Handle discovered device event.
 
         Args:
@@ -128,22 +136,17 @@ class ConbusDiscoverService(ConbusProtocol):
         }
         self.discovered_device_result.discovered_devices.append(device)
 
+        if self.device_discover_callback:
+            self.device_discover_callback(device)
+
         # Send READ_DATAPOINT telegram to query module type
         self.logger.debug(f"Sending module type query for {serial_number}")
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=serial_number,
             system_function=SystemFunction.READ_DATAPOINT,
             data_value=DataPointType.MODULE_TYPE.value,
         )
-
-        self.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=serial_number,
-            system_function=SystemFunction.READ_DATAPOINT,
-            data_value=DataPointType.MODULE_TYPE_CODE.value,
-        )
-
         if self.progress_callback:
             self.progress_callback(serial_number)
 
@@ -190,11 +193,27 @@ class ConbusDiscoverService(ConbusProtocol):
                 if device["serial_number"] == serial_number:
                     device["module_type_code"] = code
                     device["module_type_name"] = module_type_name
+
+                    if self.device_discover_callback:
+                        self.device_discover_callback(device)
+
                     self.logger.debug(
                         f"Updated device {serial_number} with module_type {module_type_name}"
                     )
                     break
 
+        if self.discovered_device_result.discovered_devices:
+            for device in self.discovered_device_result.discovered_devices:
+                if not (
+                    device["serial_number"]
+                    and device["module_type"]
+                    and device["module_type_code"]
+                    and device["module_type_name"]
+                ):
+                    return
+
+        self.succeed()
+
     def handle_module_type_response(self, serial_number: str, module_type: str) -> None:
         """Handle module type response and update discovered device.
 
@@ -212,19 +231,28 @@ class ConbusDiscoverService(ConbusProtocol):
                     self.logger.debug(
                         f"Updated device {serial_number} with module_type {module_type}"
                     )
+                    if self.device_discover_callback:
+                        self.device_discover_callback(device)
+
                     break
 
-    def timeout(self) -> bool:
-        """Handle timeout event to stop discovery.
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_TYPE_CODE.value,
+        )
 
-        Returns:
-            False to stop the reactor.
-        """
-        self.logger.info("Discovery stopped after: %ss", self.timeout_seconds)
-        self.discovered_device_result.success = True
+    def timeout(self) -> None:
+        """Handle timeout event to stop discovery."""
+        timeout = self.conbus_protocol.timeout_seconds
+        self.logger.info("Discovery stopped after: %ss", timeout)
+        self.discovered_device_result.success = False
+        self.discovered_device_result.error = "Discovered device timeout"
         if self.finish_callback:
             self.finish_callback(self.discovered_device_result)
-        return False
+
+        self.stop_reactor()
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -238,9 +266,32 @@ class ConbusDiscoverService(ConbusProtocol):
         if self.finish_callback:
             self.finish_callback(self.discovered_device_result)
 
-    def start(
+        self.stop_reactor()
+
+    def succeed(self) -> None:
+        """Handle discovered device success event."""
+        self.logger.debug("Succeed")
+        self.discovered_device_result.success = True
+        self.discovered_device_result.error = None
+        if self.finish_callback:
+            self.finish_callback(self.discovered_device_result)
+
+        self.stop_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop reactor."""
+        self.logger.info("Stopping reactor")
+        self.conbus_protocol.stop_reactor()
+
+    def start_reactor(self) -> None:
+        """Start reactor."""
+        self.logger.info("Starting reactor")
+        self.conbus_protocol.start_reactor()
+
+    def run(
         self,
         progress_callback: Callable[[str], None],
+        device_discover_callback: Callable[[DiscoveredDevice], None],
         finish_callback: Callable[[ConbusDiscoverResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
@@ -248,12 +299,14 @@ class ConbusDiscoverService(ConbusProtocol):
 
         Args:
             progress_callback: Callback for each discovered device.
+            device_discover_callback: Callback for each discovered device.
             finish_callback: Callback when discovery completes.
             timeout_seconds: Optional timeout in seconds.
         """
         self.logger.info("Starting discovery")
+
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
+            self.conbus_protocol.timeout_seconds = timeout_seconds
         self.progress_callback = progress_callback
+        self.device_discover_callback = device_discover_callback
         self.finish_callback = finish_callback
-        self.start_reactor()

xp/services/conbus/conbus_event_raw_service.py

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

xp/services/homekit/homekit_outlet.py

@@ -134,19 +134,18 @@ class Outlet(Accessory):
             value: True to turn on, False to turn off.
         """
         # Emit set event
-        self.logger.debug(f"set_on {value}")
-
-        if value != self.is_on:
-            self.is_on = value
-            self.event_bus.dispatch(
-                OutletSetOnEvent(
-                    serial_number=self.accessory.serial_number,
-                    output_number=self.accessory.output_number,
-                    module=self.module,
-                    accessory=self.accessory,
-                    value=value,
-                )
+        self.logger.debug(f"set_on {value} {self.is_on}")
+
+        self.is_on = value
+        self.event_bus.dispatch(
+            OutletSetOnEvent(
+                serial_number=self.accessory.serial_number,
+                output_number=self.accessory.output_number,
+                module=self.module,
+                accessory=self.accessory,
+                value=value,
             )
+        )
 
     def get_on(self) -> bool:
         """Get the on/off state of the outlet.

xp/services/protocol/__init__.py

@@ -7,10 +7,11 @@ from xp.models.protocol.conbus_protocol import (
     ModuleDiscoveredEvent,
     TelegramReceivedEvent,
 )
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.protocol.conbus_protocol import ConbusProtocol
 from xp.services.protocol.telegram_protocol import TelegramProtocol
 
-__all__ = ["TelegramProtocol", "ConbusProtocol"]
+__all__ = ["TelegramProtocol", "ConbusProtocol", "ConbusEventProtocol"]
 
 # Rebuild models after TelegramProtocol and ConbusProtocol are imported to resolve forward references
 ConnectionMadeEvent.model_rebuild()

xp/services/protocol/conbus_event_protocol.py

@@ -0,0 +1,342 @@
+"""Conbus Event Protocol for XP telegram communication.
+
+This module implements the Twisted protocol for Conbus communication.
+"""
+
+import logging
+from queue import SimpleQueue
+from random import randint
+from threading import Lock
+from typing import Any, Optional
+
+from psygnal import Signal
+from twisted.internet import protocol
+from twisted.internet.base import DelayedCall
+from twisted.internet.interfaces import IAddress, IConnector
+from twisted.internet.posixbase import PosixReactorBase
+from twisted.python.failure import Failure
+
+from xp.models import ConbusClientConfig
+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.utils import calculate_checksum
+
+
+class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
+    """Twisted protocol for XP telegram communication.
+
+    Attributes:
+        buffer: Buffer for incoming telegram data.
+        logger: Logger instance for this protocol.
+        cli_config: Conbus configuration settings.
+        timeout_seconds: Timeout duration in seconds.
+        timeout_call: Delayed call handle for timeout management.
+        telegram_queue: FIFO queue for outgoing telegrams.
+        queue_manager_running: Flag indicating if queue manager is active.
+        queue_manager_lock: Lock for thread-safe queue manager access.
+        on_connection_made: Signal emitted when connection is established.
+        on_connection_lost: Signal emitted when connection is lost.
+        on_connection_failed: Signal emitted when connection fails.
+        on_client_connection_failed: Signal emitted when client connection fails.
+        on_client_connection_lost: Signal emitted when client connection is lost.
+        on_send_frame: Signal emitted when a frame is sent.
+        on_telegram_sent: Signal emitted when a telegram is sent.
+        on_data_received: Signal emitted when data is received.
+        on_telegram_received: Signal emitted when a telegram is received.
+        on_timeout: Signal emitted when timeout occurs.
+        on_failed: Signal emitted when operation fails.
+        on_start_reactor: Signal emitted when reactor starts.
+        on_stop_reactor: Signal emitted when reactor stops.
+    """
+
+    buffer: bytes
+
+    telegram_queue: SimpleQueue[bytes] = SimpleQueue()  # FIFO
+    queue_manager_running: bool = False
+    queue_manager_lock: Lock = Lock()
+
+    on_connection_made: Signal = Signal()
+    on_connection_lost: Signal = Signal()
+    on_connection_failed: Signal = Signal(Failure)
+    on_client_connection_failed: Signal = Signal(Failure)
+    on_client_connection_lost: Signal = Signal(Failure)
+    on_send_frame: Signal = Signal(bytes)
+    on_telegram_sent: Signal = Signal(bytes)
+    on_data_received: Signal = Signal(bytes)
+    on_telegram_received: Signal = Signal(TelegramReceivedEvent)
+    on_timeout: Signal = Signal()
+    on_failed: Signal = Signal(str)
+    on_start_reactor: Signal = Signal()
+    on_stop_reactor: Signal = Signal()
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize ConbusProtocol.
+
+        Args:
+            cli_config: Configuration for Conbus client connection.
+            reactor: Twisted reactor for event handling.
+        """
+        self.buffer = b""
+        self.logger = logging.getLogger(__name__)
+        self.cli_config = cli_config.conbus
+        self._reactor = reactor
+        self.timeout_seconds = self.cli_config.timeout
+        self.timeout_call: Optional[DelayedCall] = None
+
+    def connectionMade(self) -> None:
+        """Handle connection established event.
+
+        Called when TCP connection is successfully established.
+        Starts inactivity timeout monitoring.
+        """
+        self.logger.debug("connectionMade")
+        self.on_connection_made.emit()
+
+        # Start inactivity timeout
+        self._reset_timeout()
+
+    def dataReceived(self, data: bytes) -> None:
+        """Handle received data from TCP connection.
+
+        Parses incoming telegram frames and dispatches events.
+
+        Args:
+            data: Raw bytes received from connection.
+        """
+        self.logger.debug("dataReceived")
+        self.on_data_received.emit(data)
+        self.buffer += data
+
+        while True:
+            start = self.buffer.find(b"<")
+            if start == -1:
+                break
+
+            end = self.buffer.find(b">", start)
+            if end == -1:
+                break
+
+            # <S0123450001F02D12FK>
+            # <R0123450001F02D12FK>
+            # <E12L01I08MAK>
+            frame = self.buffer[start : end + 1]  # <S0123450001F02D12FK>
+            self.buffer = self.buffer[end + 1 :]
+            telegram = frame[1:-1]  # S0123450001F02D12FK
+            telegram_type = telegram[0:1].decode()  # S
+            payload = telegram[:-2]  # S0123450001F02D12
+            checksum = telegram[-2:].decode()  # FK
+            serial_number = (
+                telegram[1:11] if telegram_type in ("S", "R") else b""
+            )  # 0123450001
+            calculated_checksum = calculate_checksum(payload.decode(encoding="latin-1"))
+
+            checksum_valid = checksum == calculated_checksum
+            if not checksum_valid:
+                self.logger.debug(
+                    f"Invalid checksum: {checksum}, calculated: {calculated_checksum}"
+                )
+
+            self.logger.debug(
+                f"frameReceived payload: {payload.decode('latin-1')}, checksum: {checksum}"
+            )
+
+            # Reset timeout on activity
+            self._reset_timeout()
+
+            telegram_received = TelegramReceivedEvent(
+                protocol=self,
+                frame=frame.decode("latin-1"),
+                telegram=telegram.decode("latin-1"),
+                payload=payload.decode("latin-1"),
+                telegram_type=telegram_type,
+                serial_number=serial_number,
+                checksum=checksum,
+                checksum_valid=checksum_valid,
+            )
+            self.on_telegram_received.emit(telegram_received)
+
+    def sendFrame(self, data: bytes) -> None:
+        """Send telegram frame.
+
+        Args:
+            data: Raw telegram payload (without checksum/framing).
+
+        Raises:
+            IOError: If transport is not open.
+        """
+        self.on_send_frame.emit(data)
+
+        # Calculate full frame (add checksum and brackets)
+        checksum = calculate_checksum(data.decode())
+        frame_data = data.decode() + checksum
+        frame = b"<" + frame_data.encode() + b">"
+
+        if not self.transport:
+            self.logger.info("Invalid transport")
+            raise IOError("Transport is not open")
+
+        self.logger.debug(f"Sending frame: {frame.decode()}")
+        self.transport.write(frame)  # type: ignore
+        self.on_telegram_sent.emit(frame.decode())
+        self._reset_timeout()
+
+    def send_telegram(
+        self,
+        telegram_type: TelegramType,
+        serial_number: str,
+        system_function: SystemFunction,
+        data_value: str,
+    ) -> None:
+        """Send telegram with specified parameters.
+
+        Args:
+            telegram_type: Type of telegram to send.
+            serial_number: Device serial number.
+            system_function: System function code.
+            data_value: Data value to send.
+        """
+        payload = (
+            f"{telegram_type.value}"
+            f"{serial_number}"
+            f"F{system_function.value}"
+            f"D{data_value}"
+        )
+        self.telegram_queue.put_nowait(payload.encode())
+        self._reactor.callLater(0.0, self.start_queue_manager)
+
+    def buildProtocol(self, addr: IAddress) -> protocol.Protocol:
+        """Build protocol instance for connection.
+
+        Args:
+            addr: Address of the connection.
+
+        Returns:
+            Protocol instance for this connection.
+        """
+        self.logger.debug(f"buildProtocol: {addr}")
+        return self
+
+    def clientConnectionFailed(self, connector: IConnector, reason: Failure) -> None:
+        """Handle client connection failure.
+
+        Args:
+            connector: Connection connector instance.
+            reason: Failure reason details.
+        """
+        self.logger.debug(f"clientConnectionFailed: {reason}")
+        self.on_client_connection_failed.emit(reason)
+        self.connection_failed(reason)
+        self._cancel_timeout()
+
+    def clientConnectionLost(self, connector: IConnector, reason: Failure) -> None:
+        """Handle client connection lost event.
+
+        Args:
+            connector: Connection connector instance.
+            reason: Reason for connection loss.
+        """
+        self.logger.debug(f"clientConnectionLost: {reason}")
+        self.on_connection_lost.emit(reason)
+        self._cancel_timeout()
+
+    def timeout(self) -> None:
+        """Handle timeout event."""
+        self.logger.info("Timeout after: %ss", self.timeout_seconds)
+        self.on_timeout.emit()
+
+    def connection_failed(self, reason: Failure) -> None:
+        """Handle connection failure.
+
+        Args:
+            reason: Failure reason details.
+        """
+        self.logger.debug(f"Client connection failed: {reason}")
+        self.on_connection_failed.emit(reason)
+        self.on_failed.emit(reason.getErrorMessage())
+
+    def _reset_timeout(self) -> None:
+        """Reset the inactivity timeout."""
+        self._cancel_timeout()
+        self.timeout_call = self._reactor.callLater(
+            self.timeout_seconds, self._on_timeout
+        )
+
+    def _cancel_timeout(self) -> None:
+        """Cancel the inactivity timeout."""
+        if self.timeout_call and self.timeout_call.active():
+            self.timeout_call.cancel()
+
+    def _on_timeout(self) -> None:
+        """Handle inactivity timeout expiration."""
+        self.timeout()
+        self.logger.debug(f"Conbus timeout after {self.timeout_seconds} seconds")
+
+    def stop_reactor(self) -> None:
+        """Stop the reactor if it's running."""
+        if self._reactor.running:
+            self.logger.info("Stopping reactor")
+            self._reactor.stop()
+
+    def start_reactor(self) -> None:
+        """Start the reactor if it's running."""
+        # Connect to TCP server
+        self.logger.info(
+            f"Connecting to TCP server {self.cli_config.ip}:{self.cli_config.port}"
+        )
+        self._reactor.connectTCP(self.cli_config.ip, self.cli_config.port, self)
+
+        # Run the reactor (which now uses asyncio underneath)
+        self.logger.info("Starting reactor event loop.")
+        self._reactor.run()
+
+    def start_queue_manager(self) -> None:
+        """Start the queue manager if it's not running."""
+        with self.queue_manager_lock:
+            if self.queue_manager_running:
+                return
+            self.logger.debug("Queue manager: starting")
+            self.queue_manager_running = True
+            self.process_telegram_queue()
+
+    def process_telegram_queue(self) -> None:
+        """Start the queue manager if it's not running."""
+        self.logger.debug(
+            f"Queue manager: processing (remaining: {self.telegram_queue.qsize()})"
+        )
+        if self.telegram_queue.empty():
+            with self.queue_manager_lock:
+                self.logger.debug("Queue manager: stopping")
+                self.queue_manager_running = False
+                return
+
+        self.logger.debug("Queue manager: event loop")
+        telegram = self.telegram_queue.get_nowait()
+        self.sendFrame(telegram)
+        later = randint(10, 80) / 100
+        self._reactor.callLater(later, self.process_telegram_queue)
+
+    def __enter__(self) -> "ConbusEventProtocol":
+        """Enter context manager.
+
+        Returns:
+            Self for context management.
+        """
+        self.logger.debug("Entering the event loop.")
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: Optional[type],
+        _exc_val: Optional[BaseException],
+        _exc_tb: Optional[Any],
+    ) -> None:
+        """Context manager exit - ensure connection is closed."""
+        self.logger.debug("Exiting the event loop.")
+        self.stop_reactor()

xp/utils/dependencies.py

@@ -43,6 +43,7 @@ from xp.services.conbus.conbus_datapoint_service import (
     ConbusDatapointService,
 )
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
+from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
 from xp.services.conbus.conbus_receive_service import ConbusReceiveService
@@ -58,6 +59,7 @@ from xp.services.homekit.homekit_outlet_service import HomeKitOutletService
 from xp.services.homekit.homekit_service import HomeKitService
 from xp.services.log_file_service import LogFileService
 from xp.services.module_type_service import ModuleTypeService
+from xp.services.protocol import ConbusEventProtocol
 from xp.services.protocol.protocol_factory import TelegramFactory
 from xp.services.protocol.telegram_protocol import TelegramProtocol
 from xp.services.reverse_proxy_service import ReverseProxyService
@@ -163,14 +165,30 @@ class ServiceContainer:
         )
 
         self.container.register(
-            ConbusDiscoverService,
-            factory=lambda: ConbusDiscoverService(
+            ConbusEventProtocol,
+            factory=lambda: ConbusEventProtocol(
                 cli_config=self.container.resolve(ConbusClientConfig),
                 reactor=self.container.resolve(PosixReactorBase),
             ),
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            ConbusDiscoverService,
+            factory=lambda: ConbusDiscoverService(
+                conbus_protocol=self.container.resolve(ConbusEventProtocol)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            ConbusEventRawService,
+            factory=lambda: ConbusEventRawService(
+                conbus_protocol=self.container.resolve(ConbusEventProtocol)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             ConbusBlinkService,
             factory=lambda: ConbusBlinkService(