conson-xp 1.22.0__py3-none-any.whl → 1.24.0__py3-none-any.whl

{conson_xp-1.22.0.dist-info → conson_xp-1.24.0.dist-info}/METADATA

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

{conson_xp-1.22.0.dist-info → conson_xp-1.24.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-conson_xp-1.22.0.dist-info/METADATA,sha256=SHz732F4Z0CbbWIukCpttstkgiNLFBgqYAZQg94OkEk,10298
-conson_xp-1.22.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-conson_xp-1.22.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.22.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=cGDFz-p2G9nzESEviCX7b8voSRj-fYSsRjnhBPsDwSE,181
+conson_xp-1.24.0.dist-info/METADATA,sha256=OIqtn9P69KMHIOn2EV8vgrHgUSQRQnFd1VGMFOU5sdE,10298
+conson_xp-1.24.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.24.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.24.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=WnwD09XucegEUWyg8Au3w-_Cz33wTXvYu4cW_mzxpmE,181
 xp/cli/__init__.py,sha256=QjnKB1KaI2aIyKlzrnvCwfbBuUj8HNgwNMvNJVQofbI,81
 xp/cli/__main__.py,sha256=l2iKwMdat5rTGd3JWs-uGksnYYDDffp_Npz05QdKEeU,117
 xp/cli/commands/__init__.py,sha256=noh8fdZAWq-ihJEboP8WugbIgq4LJ3jUWMRA7720xWE,4909
@@ -14,7 +14,7 @@ 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=-y3TDgOnw1_cjvxvgyfQ1GQE2_WmYq-l8Md7DsdTXmo,1719
+xp/cli/commands/conbus/conbus_discover_commands.py,sha256=MnTCzvERO5xerfs0fuuIBoo1O9h_0IfoJ6snLGVl0lA,1899
 xp/cli/commands/conbus/conbus_event_commands.py,sha256=7URf-2u8Kzcy0chLYShbZfCbKawf--i-8U88AjhxleQ,3177
 xp/cli/commands/conbus/conbus_lightlevel_commands.py,sha256=FpCwogdxa7yFUjlrxM7e8Q2Ut32tKAHabngQQChvtJI,6763
 xp/cli/commands/conbus/conbus_linknumber_commands.py,sha256=KitaGDM5HpwVUz8rLpO8VZUypUTcAg3Bzl0DVm6gnSk,3391
@@ -22,7 +22,7 @@ xp/cli/commands/conbus/conbus_modulenumber_commands.py,sha256=L7-6y3rDllOjQ9g6Bk
 xp/cli/commands/conbus/conbus_msactiontable_commands.py,sha256=fb9MQ4O04H0Dinpt7vSF5GtfntTZHelQ5TuUmSBbCTg,2899
 xp/cli/commands/conbus/conbus_output_commands.py,sha256=zdRVbHzVhMbZpG2x5WXtujc3wKTsoQUV4IgkVIbJbCc,5019
 xp/cli/commands/conbus/conbus_raw_commands.py,sha256=8BKUarwvHgz-sxML7n99YVsb8B1HJNExjQpRsuY_tQw,1829
-xp/cli/commands/conbus/conbus_receive_commands.py,sha256=2lZP0a3dte3Q_Vp28xYkqLAoxnvArS9SsQdeedOHcQw,1788
+xp/cli/commands/conbus/conbus_receive_commands.py,sha256=_PsC-3xidmJBuOWUS60iDzhSHYYn5ZFmORXap-ljVGM,1902
 xp/cli/commands/conbus/conbus_scan_commands.py,sha256=JfXucOwOadvLEKT_fW9fwvqWKHaEODOojLjnO8JV_00,1730
 xp/cli/commands/file_commands.py,sha256=GV102X7FRZDUNKLlzvSsIGcoXAaofOzmjCp3HUpE9lw,5532
 xp/cli/commands/homekit/__init__.py,sha256=qqwY8ulxTx1S74Mzpb6EKjBLT6fWTNdf9PQ3HKuERKY,50
@@ -105,7 +105,9 @@ xp/models/telegram/telegram.py,sha256=IJUxHX6ftLcET9C1pjvLhUO5Db5JO6W7rUItzdEW30
 xp/models/telegram/telegram_type.py,sha256=GhqKP63oNMyh2tIvCPcsC5RFp4s4JjhmEqCLCC-8XMk,423
 xp/models/telegram/timeparam_type.py,sha256=Ar8xvSfPmOAgR2g2Je0FgvP01SL7bPvZn5_HrVDpmJM,1137
 xp/models/term/__init__.py,sha256=c1AMtVitYk80o9K_zWjYNzZYpFDASqM8S1Djm1PD4Qo,192
+xp/models/term/connection_state.py,sha256=floDRMeMcfgMrYIVsyoVHBXHtxd3hqm-xOdr3oXtaHY,1793
 xp/models/term/protocol_keys_config.py,sha256=CTujcfI2_NOeltjvHy_cnsHzxLSVsGFXieMZlD-zj0Q,1204
+xp/models/term/status_message.py,sha256=DOmzL0dbig5mP1UEoXdgzGT4UG2RyAXa_yRVo5c4x8w,394
 xp/models/write_config_type.py,sha256=T2RaO52RpzoJ4782uMHE-fX7Ymx3CaIQAEwByydXq1M,881
 xp/services/__init__.py,sha256=W9YZyrkh7vm--ZHhAXNQiOYQs5yhhmUHXP5I0Lf1XBg,782
 xp/services/actiontable/__init__.py,sha256=z6js4EuJ6xKHaseTEhuEvKo1tr9K1XyQiruReJtBiPY,26
@@ -126,12 +128,12 @@ xp/services/conbus/conbus_blink_service.py,sha256=x9uM-sLnIEV8wSNsvJgo08E042g-Hh
 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=SYhHj9RmTmaJ750tyZ1IW2kl7tgDQ1xm_EM1zUjk1aQ,6421
-xp/services/conbus/conbus_discover_service.py,sha256=sSCSDNWWGtx5QOShwJfcbG54WCYH-BxWvgE10ghibN4,12326
+xp/services/conbus/conbus_discover_service.py,sha256=ZwjYBlgP6FgpHBJk7pcKr4JHfH7WUHDxe4he4F_HblQ,12740
 xp/services/conbus/conbus_event_list_service.py,sha256=0xyXXNU44epN5bFkU6oiZMyhxfUguul3evqClvPJDcA,3618
 xp/services/conbus/conbus_event_raw_service.py,sha256=FZFu-LNLInrTKTpiGLyootozvyIF5Si5FMrxNk2ALD0,7000
 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=38lAZ0tc2AjBfcqI7qje-ES_QHiHZ3Ayybrp1ZC8ceM,5412
+xp/services/conbus/conbus_receive_service.py,sha256=7wOaEDrdoXwZE9MeUM89eB3hobYpvtbYk_YLv3MVAtc,5352
 xp/services/conbus/conbus_scan_service.py,sha256=tHJ5qaxcNXxAZb2D2F1v6IrzydfxjJOYllM6Txt1eBE,5176
 xp/services/conbus/write_config_service.py,sha256=6feNdixI_Nli4MRLe15nea-7gTEXMUwZIvTqv_1OqHI,7157
 xp/services/homekit/__init__.py,sha256=xAMKmln_AmEFdOOJGKWYi96seRlKDQpKx3-hm7XbdIo,36
@@ -151,7 +153,7 @@ xp/services/homekit/homekit_service.py,sha256=0lW-hg40ETco3gDBEYkR_sX-UIYsLSKCD4
 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=qRufBmqRKGzpuzZ5bxBbmwf510TT00Ke8s5HcWGnqRY,818
-xp/services/protocol/conbus_event_protocol.py,sha256=t_ovcLbwXays-y8u-EqFpDSfo2Xc_BNl3jAj9PqxRwg,13885
+xp/services/protocol/conbus_event_protocol.py,sha256=h9ZdnN9CWSBXQqE-M9qmPPbMT3r25cxzXuJsvURp1WQ,14390
 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
@@ -176,13 +178,13 @@ xp/services/telegram/telegram_output_service.py,sha256=UaUv_14fR8o5K2PxQBXrCzx-H
 xp/services/telegram/telegram_service.py,sha256=XrP1CPi0ckxoKBaNwLA6lo-TogWxXgmXDOsU4Xl8BlY,13237
 xp/services/telegram/telegram_version_service.py,sha256=M5HdOTsLdcwo122FP-jW6R740ktLrtKf2TiMDVz23h8,10528
 xp/term/__init__.py,sha256=Xg2DhBeI3xQJLfc7_BPWI1por-rUXemyer5OtOt9Cus,51
-xp/term/protocol.py,sha256=ERntzYvNMyI-VDCYW7EnhpPu-V6WPmyEk0xcQfm7LFM,4399
-xp/term/protocol.tcss,sha256=biaIv6X-bmD1tbXENFUNsXOF8ABkuoRAUgeSDqwudtQ,2126
-xp/term/protocol.yml,sha256=kiTe_QSMPmLvLA0ZyIhNaDPwBdi6khh5C1NSR7I9TN0,2124
+xp/term/protocol.py,sha256=acYYsv7_4z5ePrnslSC1exKzqbKOE5ZGds4J33Q2XNs,4784
+xp/term/protocol.tcss,sha256=r_KfxrbpycGHLVXqZc6INBBcUJME0hLrAZkF1oqnab4,2126
+xp/term/protocol.yml,sha256=BI1dyWfYsINsJnbSR-z4fzFOsYcY27dS6it8eo7AVnU,2124
 xp/term/widgets/__init__.py,sha256=ftWmN_fmjxy2E8Qfm-YSRmzKfgL0KTBCTpgvYWCPbUY,274
 xp/term/widgets/help_menu.py,sha256=bdT5AYRdtKt_tvZTVbG7-DPMb1mj78kggtjjsa-95BA,1780
-xp/term/widgets/protocol_log.py,sha256=yuSfc61azgQmWQxLvBcmVik3cJAW1Hocj2Sk8qr3hSg,14343
-xp/term/widgets/status_footer.py,sha256=VTN5owCprMbYmNiEbNWS_4CE8yxysDi8IBCECuU9EQY,1663
+xp/term/widgets/protocol_log.py,sha256=4wh6tpaaKiEUOQTqqpUml6b5WpV3YVmXlG-W8_UYuLA,11693
+xp/term/widgets/status_footer.py,sha256=eRZHkrG5aZCMulibX56KfFyGHS8IgL-7psvr9f9S6FI,1992
 xp/utils/__init__.py,sha256=_avMF_UOkfR3tNeDIPqQ5odmbq5raKkaq1rZ9Cn1CJs,332
 xp/utils/checksum.py,sha256=HDpiQxmdIedbCbZ4o_Box0i_Zig417BtCV_46ZyhiTk,1711
 xp/utils/dependencies.py,sha256=ECS6p0eXzocM5INLwJeckHXn_Dim18uOjXTJ29qQvkQ,22001
@@ -191,4 +193,4 @@ xp/utils/logging.py,sha256=rZDXwlBrYK8A6MPq5StsMNpgsRowzJXM6fvROPwJdGM,3750
 xp/utils/serialization.py,sha256=RWHHk86feaB4ZP7rjE4qOWK0900yg2joUBDkP76gfOY,4618
 xp/utils/state_machine.py,sha256=Oe2sLwCh9z_vr1tF6X0ZRGTeuckRQAGzmef7xc9CNdc,2413
 xp/utils/time_utils.py,sha256=dEyViDlAG9GWU-J3D_YVa-sGma6yiyyMTgN4h2x3PY4,3781
-conson_xp-1.22.0.dist-info/RECORD,,
+conson_xp-1.24.0.dist-info/RECORD,,

xp/__init__.py

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

xp/cli/commands/conbus/conbus_discover_commands.py

@@ -36,6 +36,7 @@ def send_discover_telegram(ctx: click.Context) -> None:
             discovered_devices: Discover response with all found devices.
         """
         click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
+        service.stop_reactor()
 
     def on_device_discovered(discovered_device: DiscoveredDevice) -> None:
         """Handle discovery of sa single module.
@@ -57,5 +58,9 @@ def send_discover_telegram(ctx: click.Context) -> None:
     service: ConbusDiscoverService = (
         ctx.obj.get("container").get_container().resolve(ConbusDiscoverService)
     )
-    service.run(progress, on_device_discovered, on_finish, 5)
-    service.start_reactor()
+    with service:
+        service.on_progress.connect(progress)
+        service.on_device_discovered.connect(on_device_discovered)
+        service.on_finish.connect(on_finish)
+        service.set_timeout(5)
+        service.start_reactor()

xp/cli/commands/conbus/conbus_receive_commands.py

@@ -43,8 +43,9 @@ def receive_telegrams(ctx: Context, timeout: float) -> None:
             response_received: Receive response object with telegrams.
         """
         click.echo(json.dumps(response_received.to_dict(), indent=2))
+        service.stop_reactor()
 
-    def progress(telegram_received: str) -> None:
+    def on_progress(telegram_received: str) -> None:
         """Handle progress updates during telegram receive operation.
 
         Args:
@@ -56,5 +57,7 @@ def receive_telegrams(ctx: Context, timeout: float) -> None:
         ctx.obj.get("container").get_container().resolve(ConbusReceiveService)
     )
     with service:
-        service.init(progress, on_finish, timeout)
+        service.on_progress.connect(on_progress)
+        service.on_finish.connect(on_finish)
+        service.set_timeout(timeout)
         service.start_reactor()

xp/models/term/connection_state.py

@@ -0,0 +1,58 @@
+"""Connection state management module."""
+
+from enum import Enum
+
+from xp.utils.state_machine import StateMachine
+
+
+class ConnectionState(str, Enum):
+    """Connection state enumeration.
+
+    Attributes:
+        DISCONNECTING: Disconnecting to server.
+        DISCONNECTED: Not connected to server.
+        CONNECTING: Connection in progress.
+        CONNECTED: Successfully connected.
+        FAILED: Connection failed.
+    """
+
+    DISCONNECTING = "DISCONNECTING"
+    DISCONNECTED = "DISCONNECTED"
+    CONNECTING = "CONNECTING"
+    CONNECTED = "CONNECTED"
+    FAILED = "FAILED"
+
+    @staticmethod
+    def create_state_machine() -> StateMachine:
+        """Create and configure state machine for connection management.
+
+        Returns:
+            Configured StateMachine with connection state transitions.
+        """
+        sm = StateMachine(ConnectionState.DISCONNECTED)
+
+        # Define valid transitions
+        sm.define_transition(
+            "connect", {ConnectionState.DISCONNECTED, ConnectionState.FAILED}
+        )
+        sm.define_transition(
+            "disconnect", {ConnectionState.CONNECTED, ConnectionState.CONNECTING}
+        )
+        sm.define_transition(
+            "connecting", {ConnectionState.DISCONNECTED, ConnectionState.FAILED}
+        )
+        sm.define_transition("connected", {ConnectionState.CONNECTING})
+        sm.define_transition(
+            "disconnecting", {ConnectionState.CONNECTED, ConnectionState.CONNECTING}
+        )
+        sm.define_transition("disconnected", {ConnectionState.DISCONNECTING})
+        sm.define_transition(
+            "failed",
+            {
+                ConnectionState.CONNECTING,
+                ConnectionState.CONNECTED,
+                ConnectionState.DISCONNECTING,
+            },
+        )
+
+        return sm

xp/models/term/status_message.py

@@ -0,0 +1,16 @@
+"""Status message models for terminal UI."""
+
+from textual.message import Message
+
+
+class StatusMessageChanged(Message):
+    """Message posted when status message changes."""
+
+    def __init__(self, message: str) -> None:
+        """Initialize the message.
+
+        Args:
+            message: The status message to display.
+        """
+        super().__init__()
+        self.message = message

xp/services/conbus/conbus_discover_service.py

@@ -4,8 +4,11 @@ This service implements a TCP client that connects to Conbus servers and sends
 discover telegrams to find modules on the network.
 """
 
+import asyncio
 import logging
-from typing import Callable, Optional
+from typing import Any, Optional
+
+from psygnal import Signal
 
 from xp.models import ConbusDiscoverResponse
 from xp.models.conbus.conbus_discover import DiscoveredDevice
@@ -26,9 +29,15 @@ class ConbusDiscoverService:
 
     Attributes:
         conbus_protocol: Protocol instance for Conbus communication.
+        on_progress: Signal emitted when discovery progress is made (with serial number).
+        on_finish: Signal emitted when discovery finishes (with result).
+        on_device_discovered: Signal emitted when a device is discovered (with device info).
     """
 
     conbus_protocol: ConbusEventProtocol
+    on_progress: Signal = Signal(str)
+    on_finish: Signal = Signal(DiscoveredDevice)
+    on_device_discovered: Signal = Signal(ConbusDiscoverResponse)
 
     def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
         """Initialize the Conbus discover service.
@@ -36,12 +45,6 @@ class ConbusDiscoverService:
         Args:
             conbus_protocol: ConbusProtocol.
         """
-        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)
@@ -135,9 +138,7 @@ class ConbusDiscoverService:
             "module_type_name": None,
         }
         self.discovered_device_result.discovered_devices.append(device)
-
-        if self.device_discover_callback:
-            self.device_discover_callback(device)
+        self.on_device_discovered.emit(device)
 
         # Send READ_DATAPOINT telegram to query module type
         self.logger.debug(f"Sending module type query for {serial_number}")
@@ -147,8 +148,7 @@ class ConbusDiscoverService:
             system_function=SystemFunction.READ_DATAPOINT,
             data_value=DataPointType.MODULE_TYPE.value,
         )
-        if self.progress_callback:
-            self.progress_callback(serial_number)
+        self.on_progress.emit(serial_number)
 
     def handle_module_type_code_response(
         self, serial_number: str, module_type_code: str
@@ -194,8 +194,7 @@ class ConbusDiscoverService:
                     device["module_type_code"] = code
                     device["module_type_name"] = module_type_name
 
-                    if self.device_discover_callback:
-                        self.device_discover_callback(device)
+                    self.on_device_discovered.emit(device)
 
                     self.logger.debug(
                         f"Updated device {serial_number} with module_type {module_type_name}"
@@ -231,9 +230,7 @@ class ConbusDiscoverService:
                     self.logger.debug(
                         f"Updated device {serial_number} with module_type {module_type}"
                     )
-                    if self.device_discover_callback:
-                        self.device_discover_callback(device)
-
+                    self.on_device_discovered.emit(device)
                     break
 
         self.conbus_protocol.send_telegram(
@@ -249,10 +246,7 @@ class ConbusDiscoverService:
         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)
-
-        self.stop_reactor()
+        self.on_finish.emit(self.discovered_device_result)
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -263,50 +257,64 @@ class ConbusDiscoverService:
         self.logger.debug(f"Failed: {message}")
         self.discovered_device_result.success = False
         self.discovered_device_result.error = message
-        if self.finish_callback:
-            self.finish_callback(self.discovered_device_result)
-
-        self.stop_reactor()
+        self.on_finish.emit(self.discovered_device_result)
 
     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.on_finish.emit(self.discovered_device_result)
 
-        self.stop_reactor()
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Setup callbacks and timeout for receiving telegrams.
 
-    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()
+        Args:
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.debug("Set timeout")
+        self.conbus_protocol.timeout_seconds = timeout_seconds
 
-    def run(
+    def set_event_loop(
         self,
-        progress_callback: Callable[[str], None],
-        device_discover_callback: Callable[[DiscoveredDevice], None],
-        finish_callback: Callable[[ConbusDiscoverResponse], None],
-        timeout_seconds: Optional[float] = None,
+        event_loop: asyncio.AbstractEventLoop,
     ) -> None:
-        """Run reactor in dedicated thread with its own event loop.
+        """Setup callbacks and timeout for receiving telegrams.
 
         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.
+            event_loop: Optional event loop to use for async operations.
         """
-        self.logger.info("Starting discovery")
+        self.logger.debug("Set eventloop")
+        self.conbus_protocol.set_event_loop(event_loop)
 
-        if 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
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "ConbusDiscoverService":
+        """Enter context manager.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.receive_response = ConbusDiscoverResponse(success=True)
+        return self
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager and disconnect signals."""
+        self.conbus_protocol.on_connection_made.disconnect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.disconnect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.disconnect(self.telegram_received)
+        self.conbus_protocol.on_timeout.disconnect(self.timeout)
+        self.conbus_protocol.on_failed.disconnect(self.failed)
+        self.on_device_discovered.disconnect()
+        self.on_progress.disconnect()
+        self.on_finish.disconnect()
+        self.stop_reactor()

xp/services/conbus/conbus_receive_service.py

@@ -6,7 +6,9 @@ allowing clients to receive waiting event telegrams using empty telegram sends.
 
 import asyncio
 import logging
-from typing import Any, Callable, Optional
+from typing import Any, Optional
+
+from psygnal import Signal
 
 from xp.models.conbus.conbus_receive import ConbusReceiveResponse
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
@@ -22,9 +24,13 @@ class ConbusReceiveService:
 
     Attributes:
         conbus_protocol: Protocol instance for Conbus communication.
+        on_progress: Signal emitted when a telegram is received (with telegram frame).
+        on_finish: Signal emitted when receiving finishes (with result).
     """
 
     conbus_protocol: ConbusEventProtocol
+    on_progress: Signal = Signal(str)
+    on_finish: Signal = Signal(ConbusReceiveResponse)
 
     def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
         """Initialize the Conbus receive service.
@@ -32,8 +38,6 @@ class ConbusReceiveService:
         Args:
             conbus_protocol: ConbusEventProtocol instance.
         """
-        self.progress_callback: Optional[Callable[[str], None]] = None
-        self.finish_callback: Optional[Callable[[ConbusReceiveResponse], None]] = None
         self.receive_response: ConbusReceiveResponse = ConbusReceiveResponse(
             success=True
         )
@@ -67,8 +71,7 @@ class ConbusReceiveService:
             telegram_received: The telegram received event.
         """
         self.logger.debug(f"Telegram received: {telegram_received}")
-        if self.progress_callback:
-            self.progress_callback(telegram_received.frame)
+        self.on_progress.emit(telegram_received.frame)
 
         if not self.receive_response.received_telegrams:
             self.receive_response.received_telegrams = []
@@ -79,8 +82,7 @@ class ConbusReceiveService:
         timeout = self.conbus_protocol.timeout_seconds
         self.logger.info("Receive stopped after: %ss", timeout)
         self.receive_response.success = True
-        if self.finish_callback:
-            self.finish_callback(self.receive_response)
+        self.on_finish.emit(self.receive_response)
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -91,37 +93,37 @@ class ConbusReceiveService:
         self.logger.debug("Failed %s:", message)
         self.receive_response.success = False
         self.receive_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.receive_response)
+        self.on_finish.emit(self.receive_response)
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Setup callbacks and timeout for receiving telegrams.
 
-    def init(
+        Args:
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.debug("Set timeout")
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def set_event_loop(
         self,
-        progress_callback: Callable[[str], None],
-        finish_callback: Callable[[ConbusReceiveResponse], None],
-        timeout_seconds: Optional[float] = None,
-        event_loop: Optional[asyncio.AbstractEventLoop] = None,
+        event_loop: asyncio.AbstractEventLoop,
     ) -> None:
         """Setup callbacks and timeout for receiving telegrams.
 
         Args:
-            progress_callback: Callback for each received telegram.
-            finish_callback: Callback when receiving completes.
-            timeout_seconds: Optional timeout in seconds.
             event_loop: Optional event loop to use for async operations.
         """
-        self.logger.info("Starting receive")
-        if timeout_seconds:
-            self.conbus_protocol.timeout_seconds = timeout_seconds
-        self.progress_callback = progress_callback
-        self.finish_callback = finish_callback
-
-        if event_loop:
-            self.conbus_protocol.set_event_loop(event_loop)
+        self.logger.debug("Set eventloop")
+        self.conbus_protocol.set_event_loop(event_loop)
 
     def start_reactor(self) -> None:
         """Start the reactor."""
         self.conbus_protocol.start_reactor()
 
+    def stop_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.stop_reactor()
+
     def __enter__(self) -> "ConbusReceiveService":
         """Enter context manager.
 
@@ -141,3 +143,6 @@ class ConbusReceiveService:
         self.conbus_protocol.on_telegram_received.disconnect(self.telegram_received)
         self.conbus_protocol.on_timeout.disconnect(self.timeout)
         self.conbus_protocol.on_failed.disconnect(self.failed)
+        self.on_progress.disconnect()
+        self.on_finish.disconnect()
+        self.stop_reactor()

xp/services/protocol/conbus_event_protocol.py

@@ -17,7 +17,7 @@ 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 import ConbusClientConfig, ModuleTypeCode
 from xp.models.protocol.conbus_protocol import (
     TelegramReceivedEvent,
 )
@@ -168,9 +168,6 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
 
         Args:
             data: Raw telegram payload (without checksum/framing).
-
-        Raises:
-            IOError: If transport is not open.
         """
         self.on_send_frame.emit(data)
 
@@ -180,8 +177,9 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         frame = b"<" + frame_data.encode() + b">"
 
         if not self.transport:
-            self.logger.info("Invalid transport")
-            raise IOError("Transport is not open")
+            self.logger.info("Invalid transport, connection closed.")
+            self.on_connection_failed.emit(Failure("Invalid transport."))
+            return
 
         self.logger.debug(f"Sending frame: {frame.decode()}")
         self.transport.write(frame)  # type: ignore
@@ -211,6 +209,21 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         )
         self.send_raw_telegram(payload)
 
+    def send_event_telegram(
+        self, module_type_code: ModuleTypeCode, link_number: int, input_number: int
+    ) -> None:
+        """Send telegram with specified parameters.
+
+        Args:
+            module_type_code: Type code of module.
+            link_number: Link number.
+            input_number: Input number.
+        """
+        payload = (
+            f"E" f"{module_type_code}" f"L{link_number:02d}" f"I{input_number:02d}"
+        )
+        self.send_raw_telegram(payload)
+
     def send_raw_telegram(self, payload: str) -> None:
         """Send telegram with specified parameters.
 

xp/term/protocol.py

@@ -7,6 +7,7 @@ from textual.app import App, ComposeResult
 from textual.containers import Horizontal
 
 from xp.models.term import ProtocolKeysConfig
+from xp.models.term.status_message import StatusMessageChanged
 from xp.term.widgets.help_menu import HelpMenuWidget
 from xp.term.widgets.protocol_log import ProtocolLogWidget
 from xp.term.widgets.status_footer import StatusFooterWidget
@@ -125,3 +126,12 @@ class ProtocolMonitorApp(App[None]):
         """
         if self.footer_widget:
             self.footer_widget.update_status(state)
+
+    def on_status_message_changed(self, message: StatusMessageChanged) -> None:
+        """Handle status message changes from protocol widget.
+
+        Args:
+            message: Message containing the status text.
+        """
+        if self.footer_widget:
+            self.footer_widget.update_message(message.message)

xp/term/protocol.tcss

@@ -119,7 +119,7 @@ Footer {
 #status-text {
     dock: right;
     width: auto;
-    padding: 0 1;
+    padding: 0 3;
     background: $background;
     color: $text;
     text-align: right;

xp/term/protocol.yml

@@ -63,8 +63,8 @@ protocol:
   "e":
     name: "Link 1 Off"
     telegrams:
-      - E02L01I00M
-      - E02L01I00B
+      - E02L01I09M
+      - E02L01I09B
 
   "f":
     name: "Link 2 On"
@@ -75,8 +75,8 @@ protocol:
   "g":
     name: "Link 2 Off"
     telegrams:
-      - E02L02I00M
-      - E02L02I00B
+      - E02L02I09M
+      - E02L02I09B
 
   "h":
     name: "Link 3 On"
@@ -87,8 +87,8 @@ protocol:
   "i":
     name: "Link 3 Off"
     telegrams:
-      - E02L03I00M
-      - E02L03I00B
+      - E02L03I09M
+      - E02L03I09B
 
   "j":
     name: "Link 4 On"
@@ -99,8 +99,8 @@ protocol:
   "k":
     name: "Link 4 Off"
     telegrams:
-      - E02L04I00M
-      - E02L04I00B
+      - E02L04I09M
+      - E02L04I09B
 
   "l":
     name: "Link 5 On"
@@ -111,8 +111,8 @@ protocol:
   "m":
     name: "Link 5 Off"
     telegrams:
-      - E02L05I00M
-      - E02L05I00B
+      - E02L05I09M
+      - E02L05I09B
 
   "n":
     name: "Link 6 On"
@@ -123,8 +123,8 @@ protocol:
   "o":
     name: "Link 6 Off"
     telegrams:
-      - E02L06I00M
-      - E02L06I00B
+      - E02L06I09M
+      - E02L06I09B
 
   "p":
     name: "Link 7 On"
@@ -135,5 +135,5 @@ protocol:
   "q":
     name: "Link 7 Off"
     telegrams:
-      - E02L07I00M
-      - E02L07I00B
+      - E02L07I09M
+      - E02L07I09B

xp/term/widgets/protocol_log.py

@@ -2,71 +2,17 @@
 
 import asyncio
 import logging
-from enum import Enum
 from typing import Any, Optional
 
-from textual.message import Message
 from textual.reactive import reactive
 from textual.widget import Widget
 from textual.widgets import RichLog
+from twisted.python.failure import Failure
 
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
-from xp.services.conbus.conbus_receive_service import ConbusReceiveService
+from xp.models.term.connection_state import ConnectionState
+from xp.models.term.status_message import StatusMessageChanged
 from xp.services.protocol import ConbusEventProtocol
-from xp.utils.state_machine import StateMachine
-
-
-class ConnectionState(str, Enum):
-    """Connection state enumeration.
-
-    Attributes:
-        DISCONNECTING: Disconnecting to server.
-        DISCONNECTED: Not connected to server.
-        CONNECTING: Connection in progress.
-        CONNECTED: Successfully connected.
-        FAILED: Connection failed.
-    """
-
-    DISCONNECTING = "DISCONNECTING"
-    DISCONNECTED = "DISCONNECTED"
-    CONNECTING = "CONNECTING"
-    CONNECTED = "CONNECTED"
-    FAILED = "FAILED"
-
-
-def create_connection_state_machine() -> StateMachine:
-    """Create and configure state machine for connection management.
-
-    Returns:
-        Configured StateMachine with connection state transitions.
-    """
-    sm = StateMachine(ConnectionState.DISCONNECTED)
-
-    # Define valid transitions
-    sm.define_transition(
-        "connect", {ConnectionState.DISCONNECTED, ConnectionState.FAILED}
-    )
-    sm.define_transition(
-        "disconnect", {ConnectionState.CONNECTED, ConnectionState.CONNECTING}
-    )
-    sm.define_transition(
-        "connecting", {ConnectionState.DISCONNECTED, ConnectionState.FAILED}
-    )
-    sm.define_transition("connected", {ConnectionState.CONNECTING})
-    sm.define_transition(
-        "disconnecting", {ConnectionState.CONNECTED, ConnectionState.CONNECTING}
-    )
-    sm.define_transition("disconnected", {ConnectionState.DISCONNECTING})
-    sm.define_transition(
-        "failed",
-        {
-            ConnectionState.CONNECTING,
-            ConnectionState.CONNECTED,
-            ConnectionState.DISCONNECTING,
-        },
-    )
-
-    return sm
 
 
 class ProtocolLogWidget(Widget):
@@ -79,23 +25,10 @@ class ProtocolLogWidget(Widget):
         container: ServiceContainer for dependency injection.
         connection_state: Current connection state (reactive).
         protocol: Reference to ConbusEventProtocol (prevents duplicate connections).
-        service: ConbusReceiveService instance.
         logger: Logger instance for this widget.
         log_widget: RichLog widget for displaying messages.
     """
 
-    class StatusMessageChanged(Message):
-        """Message posted when status message changes."""
-
-        def __init__(self, message: str) -> None:
-            """Initialize the message.
-
-            Args:
-                message: The status message to display.
-            """
-            super().__init__()
-            self.message = message
-
     connection_state = reactive(ConnectionState.DISCONNECTED)
 
     def __init__(self, container: Any) -> None:
@@ -108,10 +41,9 @@ class ProtocolLogWidget(Widget):
         self.border_title = "Protocol"
         self.container = container
         self.protocol: Optional[ConbusEventProtocol] = None
-        self.service: Optional[ConbusReceiveService] = None
         self.logger = logging.getLogger(__name__)
         self.log_widget: Optional[RichLog] = None
-        self._state_machine = create_connection_state_machine()
+        self._state_machine = ConnectionState.create_state_machine()
 
     def compose(self) -> Any:
         """Compose the widget layout.
@@ -129,11 +61,11 @@ class ProtocolLogWidget(Widget):
         Resolves ConbusReceiveService and connects signals.
         """
         # Resolve service from container (singleton)
-        self.service = self.container.resolve(ConbusReceiveService)
-        self.protocol = self.service.conbus_protocol
+        self.protocol = self.container.resolve(ConbusEventProtocol)
 
         # Connect psygnal signals
         self.protocol.on_connection_made.connect(self._on_connection_made)
+        self.protocol.on_connection_failed.connect(self._on_connection_failed)
         self.protocol.on_telegram_received.connect(self._on_telegram_received)
         self.protocol.on_telegram_sent.connect(self._on_telegram_sent)
         self.protocol.on_timeout.connect(self._on_timeout)
@@ -150,10 +82,6 @@ class ProtocolLogWidget(Widget):
         Integrates Twisted reactor with Textual's asyncio loop cleanly.
         """
         # Guard against duplicate connections (race condition)
-        if self.service is None:
-            self.logger.error("Service not initialized")
-            return
-
         if self.protocol is None:
             self.logger.error("Protocol not initialized")
             return
@@ -169,10 +97,8 @@ class ProtocolLogWidget(Widget):
             # Transition to CONNECTING
             if self._state_machine.transition("connecting", ConnectionState.CONNECTING):
                 self.connection_state = ConnectionState.CONNECTING
-                self.post_message(
-                    self.StatusMessageChanged(
-                        f"Connecting to {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}..."
-                    )
+                self.post_status(
+                    f"Connecting to {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}..."
                 )
 
             # Store protocol reference
@@ -180,41 +106,12 @@ class ProtocolLogWidget(Widget):
             self.logger.info(f"Reactor object: {self.protocol._reactor}")
             self.logger.info(f"Reactor running: {self.protocol._reactor.running}")
 
-            # Setup service callbacks
-            def progress_callback(telegram: str) -> None:
-                """Handle progress updates for telegram reception.
-
-                Args:
-                    telegram: Received telegram string.
-                """
-                pass
-
-            def finish_callback(response: Any) -> None:
-                """Handle completion of telegram reception.
-
-                Args:
-                    response: Response object from telegram reception.
-                """
-                pass
-
             # Get the currently running asyncio event loop (Textual's loop)
             event_loop = asyncio.get_running_loop()
             self.logger.info(f"Current running loop: {event_loop}")
             self.logger.info(f"Loop is running: {event_loop.is_running()}")
 
-            self.service.init(
-                progress_callback=progress_callback,
-                finish_callback=finish_callback,
-                timeout_seconds=None,  # Continuous monitoring
-                event_loop=event_loop,
-            )
-
-            reactor = self.service.conbus_protocol._reactor
-            reactor.connectTCP(
-                self.protocol.cli_config.ip,
-                self.protocol.cli_config.port,
-                self.protocol,
-            )
+            self.protocol.connect()
 
             # Wait for connection to establish
             await asyncio.sleep(1.0)
@@ -222,15 +119,16 @@ class ProtocolLogWidget(Widget):
 
         except Exception as e:
             self.logger.error(f"Connection failed: {e}")
+            self.post_status(f"Connection failed: {e}")
             # Transition to FAILED
             if self._state_machine.transition("failed", ConnectionState.FAILED):
                 self.connection_state = ConnectionState.FAILED
-                self.post_message(self.StatusMessageChanged(f"Connection error: {e}"))
 
     def _start_connection(self) -> None:
         """Start connection (sync wrapper for async method)."""
         # Use run_worker to run async method from sync context
         self.logger.debug("Start connection")
+        self.post_status("Start connection")
         self.run_worker(self._start_connection_async(), exclusive=True)
 
     def _on_connection_made(self) -> None:
@@ -239,16 +137,26 @@ class ProtocolLogWidget(Widget):
         Sets state to CONNECTED and displays success message.
         """
         self.logger.debug("Connection made")
+        self.post_status("Connection made")
         # Transition to CONNECTED
         if self._state_machine.transition("connected", ConnectionState.CONNECTED):
             self.connection_state = ConnectionState.CONNECTED
             if self.protocol:
-                self.post_message(
-                    self.StatusMessageChanged(
-                        f"Connected to {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}"
-                    )
+                self.post_status(
+                    f"Connected to {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}"
                 )
 
+    def _on_connection_failed(self, failure: Failure) -> None:
+        """Handle connection failed signal.
+
+        Sets state to DISCONNECTED and displays success message.
+        """
+        self.logger.debug("Connection failed")
+        self.post_status(failure.getErrorMessage())
+        # Transition to CONNECTED
+        if self._state_machine.transition("disconnected", ConnectionState.DISCONNECTED):
+            self.connection_state = ConnectionState.DISCONNECTED
+
     def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
         """Handle telegram received signal.
 
@@ -289,7 +197,15 @@ class ProtocolLogWidget(Widget):
         if self._state_machine.transition("failed", ConnectionState.FAILED):
             self.connection_state = ConnectionState.FAILED
             self.logger.error(f"Connection failed: {error}")
-            self.post_message(self.StatusMessageChanged(f"Failed: {error}"))
+            self.post_status(f"Failed: {error}")
+
+    def post_status(self, message: str) -> None:
+        """Post status message.
+
+        Args:
+            message: message to be sent to status bar.
+        """
+        self.post_message(StatusMessageChanged(message))
 
     def connect(self) -> None:
         """Connect to Conbus server.
@@ -326,7 +242,7 @@ class ProtocolLogWidget(Widget):
             "disconnecting", ConnectionState.DISCONNECTING
         ):
             self.connection_state = ConnectionState.DISCONNECTING
-            self.post_message(self.StatusMessageChanged("Disconnecting..."))
+            self.post_status("Disconnecting...")
 
         if self.protocol:
             self.protocol.disconnect()
@@ -334,7 +250,7 @@ class ProtocolLogWidget(Widget):
         # Transition to DISCONNECTED
         if self._state_machine.transition("disconnected", ConnectionState.DISCONNECTED):
             self.connection_state = ConnectionState.DISCONNECTED
-            self.post_message(self.StatusMessageChanged("Disconnected"))
+            self.post_status("Disconnected")
 
     def send_telegram(self, name: str, telegram: str) -> None:
         """Send a raw telegram string.
@@ -349,19 +265,19 @@ class ProtocolLogWidget(Widget):
 
         try:
             # Remove angle brackets if present
-            self.post_message(self.StatusMessageChanged(f"Sending {name}..."))
+            self.post_status(f"{name} sent.")
             # Send raw telegram
             self.protocol.send_raw_telegram(telegram)
 
         except Exception as e:
             self.logger.error(f"Failed to send telegram: {e}")
-            self.post_message(self.StatusMessageChanged(f"Failed: {e}"))
+            self.post_status(f"Failed: {e}")
 
     def clear_log(self) -> None:
         """Clear the protocol log widget."""
         if self.log_widget:
             self.log_widget.clear()
-            self.post_message(self.StatusMessageChanged("Log cleared"))
+            self.post_status("Log cleared")
 
     def on_unmount(self) -> None:
         """Clean up when widget unmounts.

xp/term/widgets/status_footer.py

@@ -25,6 +25,7 @@ class StatusFooterWidget(Horizontal):
             kwargs: Additional keyword arguments for Horizontal.
         """
         super().__init__(*args, **kwargs)
+        self.status_text_widget: Static = Static("", id="status-text")
         self.status_widget: Static = Static("○", id="status-line")
 
     def compose(self) -> ComposeResult:
@@ -34,6 +35,7 @@ class StatusFooterWidget(Horizontal):
             Footer and status indicator widgets.
         """
         yield Footer()
+        yield self.status_text_widget
         yield self.status_widget
 
     def update_status(self, state: Any) -> None:
@@ -51,3 +53,11 @@ class StatusFooterWidget(Horizontal):
             "DISCONNECTED": "○",
         }.get(state.value, "○")
         self.status_widget.update(dot)
+
+    def update_message(self, message: str) -> None:
+        """Update status text with message.
+
+        Args:
+            message: Status message to display.
+        """
+        self.status_text_widget.update(message)