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

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

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

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

@@ -1,8 +1,8 @@
-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
+conson_xp-1.26.0.dist-info/METADATA,sha256=x2lguLJmE7yZdTNZLrogbVdb93RrTgFOv-Izz_7-eII,10298
+conson_xp-1.26.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.26.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.26.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=w0zdd6Iu_R5Xugn6Z7IEbzdaTA5LPt1ALETFqFfqQtc,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
@@ -42,7 +42,7 @@ xp/cli/commands/telegram/telegram_parse_commands.py,sha256=_OYOso1hS4f_ox96qlkYL
 xp/cli/commands/telegram/telegram_version_commands.py,sha256=WQyx1-B9yJ8V9WrFyBpOvULJ-jq12GoZZDDoRbM7eyw,1553
 xp/cli/commands/term/__init__.py,sha256=1NNST_8YJfj5LCujQISwQflK6LyEn7mDmZpMpvI9d-o,116
 xp/cli/commands/term/term.py,sha256=gjvsv2OE-F_KNWQrWi04fXQ5cGo0l8P-Ortbb5KTA-A,309
-xp/cli/commands/term/term_commands.py,sha256=ccBdvvyxjh2-cptmI9ohVIa02OOfG0dzO1JFb4KTowQ,744
+xp/cli/commands/term/term_commands.py,sha256=kElFFpbdUthk23lf6bfGIpzTbBEXE1Y08pU_yAyzmOg,676
 xp/cli/main.py,sha256=ap5jU0DrSnrCKDKqGXcz9N-sngZodyyN-5ReWE8Fh1s,1817
 xp/cli/utils/__init__.py,sha256=gTGIj60Uai0iE7sr9_TtEpl04fD7krtTzbbigXUsUVU,46
 xp/cli/utils/click_tree.py,sha256=ilmM2IMa_c-TqUMsv2alrZXuS0BNhvVlrBlSfyN8lzM,1670
@@ -108,6 +108,7 @@ xp/models/term/__init__.py,sha256=c1AMtVitYk80o9K_zWjYNzZYpFDASqM8S1Djm1PD4Qo,19
 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/term/telegram_display.py,sha256=RJDrJh4tqRmT0i1-tfYy17paEmVb3HY3DMuFPsEhZyc,533
 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
@@ -153,7 +154,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=h9ZdnN9CWSBXQqE-M9qmPPbMT3r25cxzXuJsvURp1WQ,14390
+xp/services/protocol/conbus_event_protocol.py,sha256=7u_Gv7vM53Ikzo56D5Vua4y8_0vsl6nUjfRJmrzgUhk,14936
 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
@@ -177,20 +178,21 @@ xp/services/telegram/telegram_link_number_service.py,sha256=1_c-_QCRPTHYn3BmMElr
 xp/services/telegram/telegram_output_service.py,sha256=UaUv_14fR8o5K2PxQBXrCzx-Hohnk-gzbev_oLw_Clc,10799
 xp/services/telegram/telegram_service.py,sha256=XrP1CPi0ckxoKBaNwLA6lo-TogWxXgmXDOsU4Xl8BlY,13237
 xp/services/telegram/telegram_version_service.py,sha256=M5HdOTsLdcwo122FP-jW6R740ktLrtKf2TiMDVz23h8,10528
+xp/services/term/__init__.py,sha256=rWZ9hypFYDwrUCW_36cRZ4RalaPByyHQCEnOxgHrbuk,151
+xp/services/term/protocol_monitor_service.py,sha256=q24gnRB4SQ1BA9ZeSU7ylYQ6yQ4j12HlSPgQowsAOv8,9950
 xp/term/__init__.py,sha256=Xg2DhBeI3xQJLfc7_BPWI1por-rUXemyer5OtOt9Cus,51
-xp/term/protocol.py,sha256=acYYsv7_4z5ePrnslSC1exKzqbKOE5ZGds4J33Q2XNs,4784
+xp/term/protocol.py,sha256=rJmhvXaLBC9tVg7oYew6yAuCO0I9n-N7uIyOLm25Wnc,3330
 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=4wh6tpaaKiEUOQTqqpUml6b5WpV3YVmXlG-W8_UYuLA,11693
-xp/term/widgets/status_footer.py,sha256=eRZHkrG5aZCMulibX56KfFyGHS8IgL-7psvr9f9S6FI,1992
+xp/term/widgets/help_menu.py,sha256=7viKIfyPJr-uz55Y1kgo6h4iHhntxwKs_qmC5siRYNM,1821
+xp/term/widgets/protocol_log.py,sha256=CJUpckWj7GC1kVqixDadteyGnI4aHyzd4kkH-pSbzno,2600
+xp/term/widgets/status_footer.py,sha256=8O3W8clgSbkX21_b9iJ_3XKgDjYTG1Bi-L_PaiEPI7U,3104
 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
+xp/utils/dependencies.py,sha256=Rw3NsvPr7P7xtm2LzLLBP7Q8W07A2fmp4HOKXDH9wS4,23457
 xp/utils/event_helper.py,sha256=W-A_xmoXlpWZBbJH6qdaN50o3-XrwFsDgvAGMJDiAgo,1001
 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.24.0.dist-info/RECORD,,
+conson_xp-1.26.0.dist-info/RECORD,,

xp/__init__.py

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

xp/cli/commands/term/term_commands.py

@@ -23,9 +23,5 @@ def protocol_monitor(ctx: Context) -> None:
     """
     from xp.term.protocol import ProtocolMonitorApp
 
-    # Resolve ServiceContainer from context
-    container = ctx.obj.get("container").get_container()
-
-    # Initialize and run Textual app
-    app = ProtocolMonitorApp(container=container)
-    app.run()
+    # Resolve ProtocolMonitorApp from container and run
+    ctx.obj.get("container").get_container().resolve(ProtocolMonitorApp).run()

xp/models/term/telegram_display.py

@@ -0,0 +1,19 @@
+"""Domain models for telegram display in terminal interface."""
+
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+
+@dataclass
+class TelegramDisplayEvent:
+    """Event containing telegram data for display in TUI.
+
+    Attributes:
+        direction: Direction of telegram ("RX" for received, "TX" for transmitted).
+        telegram: Formatted telegram string.
+        timestamp: Optional timestamp of the event.
+    """
+
+    direction: Literal["RX", "TX"]
+    telegram: str
+    timestamp: Optional[float] = None

xp/services/protocol/conbus_event_protocol.py

@@ -325,10 +325,23 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             self._reactor.stop()
 
     def connect(self) -> None:
-        """Connect to TCP server."""
+        """Connect to TCP server.
+
+        Automatically detects and integrates with running asyncio event loop if present.
+        """
         self.logger.info(
             f"Connecting to TCP server {self.cli_config.ip}:{self.cli_config.port}"
         )
+
+        # Auto-detect and integrate with asyncio event loop if available
+        try:
+            event_loop = asyncio.get_running_loop()
+            self.logger.debug(f"Detected running event loop: {event_loop}")
+            self.set_event_loop(event_loop)
+        except RuntimeError:
+            # No running event loop - that's fine for non-async contexts
+            self.logger.debug("No running event loop detected - using reactor only")
+
         self._reactor.connectTCP(self.cli_config.ip, self.cli_config.port, self)
 
     def disconnect(self) -> None:

xp/services/term/__init__.py

@@ -0,0 +1,5 @@
+"""Terminal interface services."""
+
+from xp.services.term.protocol_monitor_service import ProtocolMonitorService
+
+__all__ = ["ProtocolMonitorService"]

xp/services/term/protocol_monitor_service.py

@@ -0,0 +1,265 @@
+"""Protocol Monitor Service for terminal interface."""
+
+import logging
+from typing import Any, ItemsView, Optional
+
+from psygnal import Signal
+from twisted.python.failure import Failure
+
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.term.connection_state import ConnectionState
+from xp.models.term.protocol_keys_config import ProtocolKeyConfig, ProtocolKeysConfig
+from xp.models.term.telegram_display import TelegramDisplayEvent
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+
+
+class ProtocolMonitorService:
+    """Service for protocol monitoring in terminal interface.
+
+    Wraps ConbusEventProtocol and provides high-level operations
+    for the TUI without exposing protocol implementation details.
+
+    Attributes:
+        _conbus_protocol: Protocol instance for Conbus communication.
+        _protocol_keys: Configuration for protocol keyboard shortcuts.
+        connection_state: Current connection state (read-only property).
+        server_info: Server connection info as "IP:port" (read-only property).
+        on_connection_state_changed: Signal emitted when connection state changes.
+        on_telegram_display: Signal emitted when telegram should be displayed.
+        on_status_message: Signal emitted for status updates.
+    """
+
+    on_connection_state_changed: Signal = Signal(ConnectionState)
+    on_telegram_display: Signal = Signal(TelegramDisplayEvent)
+    on_status_message: Signal = Signal(str)
+
+    def __init__(
+        self,
+        conbus_protocol: ConbusEventProtocol,
+        protocol_keys: ProtocolKeysConfig,
+    ) -> None:
+        """Initialize the Protocol Monitor service.
+
+        Args:
+            conbus_protocol: ConbusEventProtocol instance.
+            protocol_keys: Protocol keys configuration.
+        """
+        self.logger = logging.getLogger(__name__)
+        self._conbus_protocol = conbus_protocol
+        self._connection_state = ConnectionState.DISCONNECTED
+        self._state_machine = ConnectionState.create_state_machine()
+        self._protocol_keys = protocol_keys
+
+        # Connect to protocol signals
+        self._connect_signals()
+
+    def _connect_signals(self) -> None:
+        """Connect to protocol signals."""
+        self._conbus_protocol.on_connection_made.connect(self._on_connection_made)
+        self._conbus_protocol.on_connection_failed.connect(self._on_connection_failed)
+        self._conbus_protocol.on_telegram_received.connect(self._on_telegram_received)
+        self._conbus_protocol.on_telegram_sent.connect(self._on_telegram_sent)
+        self._conbus_protocol.on_timeout.connect(self._on_timeout)
+        self._conbus_protocol.on_failed.connect(self._on_failed)
+
+    def _disconnect_signals(self) -> None:
+        """Disconnect from protocol signals."""
+        self._conbus_protocol.on_connection_made.disconnect(self._on_connection_made)
+        self._conbus_protocol.on_connection_failed.disconnect(
+            self._on_connection_failed
+        )
+        self._conbus_protocol.on_telegram_received.disconnect(
+            self._on_telegram_received
+        )
+        self._conbus_protocol.on_telegram_sent.disconnect(self._on_telegram_sent)
+        self._conbus_protocol.on_timeout.disconnect(self._on_timeout)
+        self._conbus_protocol.on_failed.disconnect(self._on_failed)
+
+    @property
+    def connection_state(self) -> ConnectionState:
+        """Get current connection state.
+
+        Returns:
+            Current connection state.
+        """
+        return self._connection_state
+
+    @property
+    def server_info(self) -> str:
+        """Get server connection info (IP:port).
+
+        Returns:
+            Server address in format "IP:port".
+        """
+        return f"{self._conbus_protocol.cli_config.ip}:{self._conbus_protocol.cli_config.port}"
+
+    def _connect(self) -> None:
+        """Initiate connection to server."""
+        if not self._state_machine.can_transition("connect"):
+            self.logger.warning(
+                f"Cannot connect: current state is {self._connection_state.value}"
+            )
+            return
+
+        if self._state_machine.transition("connecting", ConnectionState.CONNECTING):
+            self._connection_state = ConnectionState.CONNECTING
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Connecting to {self.server_info}...")
+
+        self._conbus_protocol.connect()
+
+    def _disconnect(self) -> None:
+        """Disconnect from server."""
+        if not self._state_machine.can_transition("disconnect"):
+            self.logger.warning(
+                f"Cannot disconnect: current state is {self._connection_state.value}"
+            )
+            return
+
+        if self._state_machine.transition(
+            "disconnecting", ConnectionState.DISCONNECTING
+        ):
+            self._connection_state = ConnectionState.DISCONNECTING
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit("Disconnecting...")
+
+        self._conbus_protocol.disconnect()
+
+        if self._state_machine.transition("disconnected", ConnectionState.DISCONNECTED):
+            self._connection_state = ConnectionState.DISCONNECTED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit("Disconnected")
+
+    def toggle_connection(self) -> None:
+        """Toggle connection state between connected and disconnected.
+
+        Disconnects if currently connected or connecting.
+        Connects if currently disconnected or failed.
+        """
+        if self._connection_state in (
+            ConnectionState.CONNECTED,
+            ConnectionState.CONNECTING,
+        ):
+            self._disconnect()
+        else:
+            self._connect()
+
+    def _send_telegram(self, name: str, telegram: str) -> None:
+        """Send a raw telegram.
+
+        Args:
+            name: Display name for the telegram.
+            telegram: Raw telegram string.
+        """
+        try:
+            self._conbus_protocol.send_raw_telegram(telegram)
+            self.on_status_message.emit(f"{name} sent.")
+        except Exception as e:
+            self.logger.error(f"Failed to send telegram: {e}")
+            self.on_status_message.emit(f"Failed: {e}")
+
+    def handle_key_press(self, key: str) -> bool:
+        """Handle protocol key press.
+
+        Args:
+            key: Key that was pressed.
+
+        Returns:
+            True if key was handled, False otherwise.
+        """
+        if key in self._protocol_keys.protocol:
+            key_config = self._protocol_keys.protocol[key]
+            for telegram in key_config.telegrams:
+                self._send_telegram(key_config.name, telegram)
+            return True
+        return False
+
+    # Protocol signal handlers
+
+    def _on_connection_made(self) -> None:
+        """Handle connection established."""
+        if self._state_machine.transition("connected", ConnectionState.CONNECTED):
+            self._connection_state = ConnectionState.CONNECTED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Connected to {self.server_info}")
+
+    def _on_connection_failed(self, failure: Failure) -> None:
+        """Handle connection failed.
+
+        Args:
+            failure: Twisted failure object with error details.
+        """
+        if self._state_machine.transition("disconnected", ConnectionState.DISCONNECTED):
+            self._connection_state = ConnectionState.DISCONNECTED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(failure.getErrorMessage())
+
+    def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
+        """Handle telegram received.
+
+        Args:
+            event: Telegram received event with frame data.
+        """
+        display_event = TelegramDisplayEvent(direction="RX", telegram=event.frame)
+        self.on_telegram_display.emit(display_event)
+
+    def _on_telegram_sent(self, telegram: str) -> None:
+        """Handle telegram sent.
+
+        Args:
+            telegram: Sent telegram string.
+        """
+        display_event = TelegramDisplayEvent(direction="TX", telegram=telegram)
+        self.on_telegram_display.emit(display_event)
+
+    def _on_timeout(self) -> None:
+        """Handle timeout."""
+        self.logger.debug("Timeout occurred (continuous monitoring)")
+
+    def _on_failed(self, error: str) -> None:
+        """Handle connection failed.
+
+        Args:
+            error: Error message describing the failure.
+        """
+        if self._state_machine.transition("failed", ConnectionState.FAILED):
+            self._connection_state = ConnectionState.FAILED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Failed: {error}")
+
+    def cleanup(self) -> None:
+        """Clean up service resources."""
+        self._disconnect_signals()
+        if self._conbus_protocol.transport:
+            self._disconnect()
+
+    def get_keys(self) -> ItemsView[str, ProtocolKeyConfig]:
+        """Get protocol key mappings.
+
+        Returns:
+            Dictionary items view of key to ProtocolKeyConfig mappings.
+        """
+        return self._protocol_keys.protocol.items()
+
+    def __enter__(self) -> "ProtocolMonitorService":
+        """Enter context manager.
+
+        Returns:
+            Self for context management.
+        """
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: Optional[type],
+        _exc_val: Optional[BaseException],
+        _exc_tb: Optional[Any],
+    ) -> None:
+        """Exit context manager and clean up resources.
+
+        Args:
+            _exc_type: Exception type if any.
+            _exc_val: Exception value if any.
+            _exc_tb: Exception traceback if any.
+        """
+        self.cleanup()

xp/term/protocol.py

@@ -6,8 +6,6 @@ from typing import Any, Optional
 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
@@ -20,7 +18,7 @@ class ProtocolMonitorApp(App[None]):
     terminal interface with keyboard shortcuts for control.
 
     Attributes:
-        container: ServiceContainer for dependency injection.
+        protocol_service: ProtocolMonitorService for protocol operations.
         CSS_PATH: Path to CSS stylesheet file.
         BINDINGS: Keyboard bindings for app actions.
         TITLE: Application title displayed in header.
@@ -38,27 +36,17 @@ class ProtocolMonitorApp(App[None]):
         ("0-9,a-q", "protocol_keys", "Keys"),
     ]
 
-    def __init__(self, container: Any) -> None:
+    def __init__(self, protocol_service: Any) -> None:
         """Initialize the Protocol Monitor app.
 
         Args:
-            container: ServiceContainer for resolving services.
+            protocol_service: ProtocolMonitorService for protocol operations.
         """
         super().__init__()
-        self.container = container
+        self.protocol_service = protocol_service
         self.protocol_widget: Optional[ProtocolLogWidget] = None
         self.help_menu: Optional[HelpMenuWidget] = None
         self.footer_widget: Optional[StatusFooterWidget] = None
-        self.protocol_keys = self._load_protocol_keys()
-
-    def _load_protocol_keys(self) -> ProtocolKeysConfig:
-        """Load protocol keys from YAML config file.
-
-        Returns:
-            ProtocolKeysConfig instance.
-        """
-        config_path = Path(__file__).parent / "protocol.yml"
-        return ProtocolKeysConfig.from_yaml(config_path)
 
     def compose(self) -> ComposeResult:
         """Compose the app layout with widgets.
@@ -67,31 +55,37 @@ class ProtocolMonitorApp(App[None]):
             ProtocolLogWidget and Footer widgets.
         """
         with Horizontal(id="main-container"):
-            self.protocol_widget = ProtocolLogWidget(container=self.container)
+            self.protocol_widget = ProtocolLogWidget(service=self.protocol_service)
             yield self.protocol_widget
 
             # Help menu (hidden by default)
             self.help_menu = HelpMenuWidget(
-                protocol_keys=self.protocol_keys, id="help-menu"
+                service=self.protocol_service, id="help-menu"
             )
             yield self.help_menu
 
-        self.footer_widget = StatusFooterWidget(id="footer-container")
+        self.footer_widget = StatusFooterWidget(
+            service=self.protocol_service, id="footer-container"
+        )
         yield self.footer_widget
 
+    async def on_mount(self) -> None:
+        """Initialize app after UI is mounted.
+
+        Delays connection by 0.5s to let UI render first.
+        """
+        import asyncio
+
+        # Delay connection to let UI render
+        await asyncio.sleep(0.5)
+        self.protocol_service.connect()
+
     def action_toggle_connection(self) -> None:
         """Toggle connection on 'c' key press.
 
         Connects if disconnected/failed, disconnects if connected/connecting.
         """
-        if self.protocol_widget:
-            from xp.term.widgets.protocol_log import ConnectionState
-
-            state = self.protocol_widget.connection_state
-            if state in (ConnectionState.CONNECTED, ConnectionState.CONNECTING):
-                self.protocol_widget.disconnect()
-            else:
-                self.protocol_widget.connect()
+        self.protocol_service.toggle_connection()
 
     def action_reset(self) -> None:
         """Reset and clear protocol widget on 'r' key press."""
@@ -104,34 +98,4 @@ class ProtocolMonitorApp(App[None]):
         Args:
             event: Key press event from Textual.
         """
-        if event.key in self.protocol_keys.protocol and self.protocol_widget:
-            key_config = self.protocol_keys.protocol[event.key]
-            for telegram in key_config.telegrams:
-                self.protocol_widget.send_telegram(key_config.name, telegram)
-
-    def on_mount(self) -> None:
-        """Set up status line updates when app mounts."""
-        if self.protocol_widget:
-            self.protocol_widget.watch(
-                self.protocol_widget,
-                "connection_state",
-                self._update_status,
-            )
-
-    def _update_status(self, state: Any) -> None:
-        """Update status line with connection state.
-
-        Args:
-            state: Current connection state.
-        """
-        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)
+        self.protocol_service.handle_key_press(event.key)

xp/term/widgets/help_menu.py

@@ -1,12 +1,13 @@
 """Help Menu Widget for displaying keyboard shortcuts and protocol keys."""
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from textual.app import ComposeResult
 from textual.containers import Vertical
 from textual.widgets import DataTable
 
-from xp.models.term import ProtocolKeysConfig
+if TYPE_CHECKING:
+    from xp.services.term.protocol_monitor_service import ProtocolMonitorService
 
 
 class HelpMenuWidget(Vertical):
@@ -16,25 +17,25 @@ class HelpMenuWidget(Vertical):
     corresponding protocol commands.
 
     Attributes:
-        protocol_keys: Configuration of protocol keys and their telegrams.
+        service: ProtocolMonitorService for accessing protocol keys.
         help_table: DataTable widget for displaying key mappings.
     """
 
     def __init__(
         self,
-        protocol_keys: ProtocolKeysConfig,
+        service: "ProtocolMonitorService",
         *args: Any,
         **kwargs: Any,
     ) -> None:
         """Initialize the Help Menu widget.
 
         Args:
-            protocol_keys: Configuration containing protocol key mappings.
+            service: ProtocolMonitorService instance.
             args: Additional positional arguments for Vertical.
             kwargs: Additional keyword arguments for Vertical.
         """
         super().__init__(*args, **kwargs)
-        self.protocol_keys = protocol_keys
+        self.service: ProtocolMonitorService = service
         self.help_table: DataTable = DataTable(id="help-table", show_header=False)
         self.help_table.can_focus = False
         self.border_title = "Help menu"
@@ -51,5 +52,5 @@ class HelpMenuWidget(Vertical):
     def on_mount(self) -> None:
         """Populate help table when widget mounts."""
         self.help_table.add_columns("Key", "Command")
-        for key, config in self.protocol_keys.protocol.items():
+        for key, config in self.service.get_keys():
             self.help_table.add_row(key, config.name)

xp/term/widgets/protocol_log.py

@@ -1,49 +1,38 @@
 """Protocol Log Widget for displaying telegram stream."""
 
-import asyncio
 import logging
 from typing import Any, Optional
 
-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.models.term.connection_state import ConnectionState
-from xp.models.term.status_message import StatusMessageChanged
-from xp.services.protocol import ConbusEventProtocol
+from xp.models.term.telegram_display import TelegramDisplayEvent
+from xp.services.term.protocol_monitor_service import ProtocolMonitorService
 
 
 class ProtocolLogWidget(Widget):
     """Widget for displaying protocol telegram stream.
 
-    Connects to Conbus server via ConbusReceiveService and displays
-    live RX/TX telegram stream with color-coded direction markers.
+    Displays live RX/TX telegram stream with color-coded direction markers
+    via ProtocolMonitorService.
 
     Attributes:
-        container: ServiceContainer for dependency injection.
-        connection_state: Current connection state (reactive).
-        protocol: Reference to ConbusEventProtocol (prevents duplicate connections).
+        service: ProtocolMonitorService for protocol operations.
         logger: Logger instance for this widget.
         log_widget: RichLog widget for displaying messages.
     """
 
-    connection_state = reactive(ConnectionState.DISCONNECTED)
-
-    def __init__(self, container: Any) -> None:
+    def __init__(self, service: ProtocolMonitorService) -> None:
         """Initialize the Protocol Log widget.
 
         Args:
-            container: ServiceContainer for resolving services.
+            service: ProtocolMonitorService instance for protocol operations.
         """
         super().__init__()
         self.border_title = "Protocol"
-        self.container = container
-        self.protocol: Optional[ConbusEventProtocol] = None
+        self.service = service
         self.logger = logging.getLogger(__name__)
         self.log_widget: Optional[RichLog] = None
-        self._state_machine = ConnectionState.create_state_machine()
 
     def compose(self) -> Any:
         """Compose the widget layout.
@@ -54,256 +43,39 @@ class ProtocolLogWidget(Widget):
         self.log_widget = RichLog(highlight=False, markup=True)
         yield self.log_widget
 
-    async def on_mount(self) -> None:
-        """Initialize connection when widget mounts.
+    def on_mount(self) -> None:
+        """Initialize widget when mounted.
 
-        Delays connection by 0.5s to let UI render first.
-        Resolves ConbusReceiveService and connects signals.
+        Connects to service signals for telegram display.
         """
-        # Resolve service from container (singleton)
-        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)
-        self.protocol.on_failed.connect(self._on_failed)
-
-        # Delay connection to let UI render
-        await asyncio.sleep(0.5)
-        self._start_connection()
-
-    async def _start_connection_async(self) -> None:
-        """Start TCP connection to Conbus server (async).
-
-        Guards against duplicate connections and sets up protocol signals.
-        Integrates Twisted reactor with Textual's asyncio loop cleanly.
-        """
-        # Guard against duplicate connections (race condition)
-        if self.protocol is None:
-            self.logger.error("Protocol not initialized")
-            return
-
-        # Guard: Don't connect if already connected or connecting
-        if not self._state_machine.can_transition("connecting"):
-            self.logger.warning(
-                f"Already {self._state_machine.get_state().value}, ignoring connect request"
-            )
-            return
-
-        try:
-            # Transition to CONNECTING
-            if self._state_machine.transition("connecting", ConnectionState.CONNECTING):
-                self.connection_state = ConnectionState.CONNECTING
-                self.post_status(
-                    f"Connecting to {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}..."
-                )
-
-            # Store protocol reference
-            self.logger.info(f"Protocol object: {self.protocol}")
-            self.logger.info(f"Reactor object: {self.protocol._reactor}")
-            self.logger.info(f"Reactor running: {self.protocol._reactor.running}")
-
-            # 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.protocol.connect()
-
-            # Wait for connection to establish
-            await asyncio.sleep(1.0)
-            self.logger.info(f"After 1s - transport: {self.protocol.transport}")
-
-        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
-
-    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)
+        # Connect to service signals
+        self.service.on_telegram_display.connect(self._on_telegram_display)
 
-    def _on_connection_made(self) -> None:
-        """Handle connection established signal.
-
-        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_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.
-
-        Args:
-            event: Telegram received event with frame data.
-        """
-        self.logger.debug("Telegram received")
-        if self.log_widget:
-            # Display [RX] and frame in bright green
-            self.log_widget.write(f"[#00ff00]\\[RX] {event.frame}[/#00ff00]")
-
-    def _on_telegram_sent(self, telegram: str) -> None:
-        """Handle telegram sent signal.
+    def _on_telegram_display(self, event: TelegramDisplayEvent) -> None:
+        """Handle telegram display event from service.
 
         Args:
-            telegram: Sent telegram string.
+            event: Telegram display event with direction and telegram data.
         """
-        self.logger.debug("Telegram sent")
         if self.log_widget:
-            # Display [TX] and frame in bold bright green
-            self.log_widget.write(f"[bold #00ff00]\\[TX] {telegram}[/bold #00ff00]")
-
-    def _on_timeout(self) -> None:
-        """Handle timeout signal.
-
-        Logs timeout but continues monitoring (no action needed).
-        """
-        self.logger.debug("Timeout")
-        self.logger.debug("Timeout occurred (continuous monitoring)")
-
-    def _on_failed(self, error: str) -> None:
-        """Handle connection failed signal.
-
-        Args:
-            error: Error message describing the failure.
-        """
-        # Transition to FAILED
-        if self._state_machine.transition("failed", ConnectionState.FAILED):
-            self.connection_state = ConnectionState.FAILED
-            self.logger.error(f"Connection 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.
-
-        Only initiates connection if currently DISCONNECTED or FAILED.
-        """
-        self.logger.debug("Connect")
-
-        # Guard: Check if connection is allowed
-        if not self._state_machine.can_transition("connect"):
-            self.logger.warning(
-                f"Cannot connect: current state is {self._state_machine.get_state().value}"
-            )
-            return
-
-        self._start_connection()
-
-    def disconnect(self) -> None:
-        """Disconnect from Conbus server.
-
-        Only disconnects if currently CONNECTED or CONNECTING.
-        """
-        self.logger.debug("Disconnect")
-
-        # Guard: Check if disconnection is allowed
-        if not self._state_machine.can_transition("disconnect"):
-            self.logger.warning(
-                f"Cannot disconnect: current state is {self._state_machine.get_state().value}"
+            color = "bold #00ff00" if event.direction == "TX" else "#00ff00"
+            self.log_widget.write(
+                f"[{color}]\\[{event.direction}] {event.telegram}[/{color}]"
             )
-            return
-
-        # Transition to DISCONNECTING
-        if self._state_machine.transition(
-            "disconnecting", ConnectionState.DISCONNECTING
-        ):
-            self.connection_state = ConnectionState.DISCONNECTING
-            self.post_status("Disconnecting...")
-
-        if self.protocol:
-            self.protocol.disconnect()
-
-        # Transition to DISCONNECTED
-        if self._state_machine.transition("disconnected", ConnectionState.DISCONNECTED):
-            self.connection_state = ConnectionState.DISCONNECTED
-            self.post_status("Disconnected")
-
-    def send_telegram(self, name: str, telegram: str) -> None:
-        """Send a raw telegram string.
-
-        Args:
-            name: Telegram name (e.g., "Discover")
-            telegram: Telegram string including angle brackets (e.g., "S0000000000F01D00")
-        """
-        if self.protocol is None:
-            self.logger.warning("Cannot send telegram: not connected")
-            return
-
-        try:
-            # Remove angle brackets if present
-            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_status(f"Failed: {e}")
 
     def clear_log(self) -> None:
         """Clear the protocol log widget."""
         if self.log_widget:
             self.log_widget.clear()
-            self.post_status("Log cleared")
 
     def on_unmount(self) -> None:
         """Clean up when widget unmounts.
 
-        Disconnects signals and closes transport connection.
+        Disconnects signals from service.
         """
-        if self.protocol is not None:
-            try:
-                # Disconnect all signals
-                self.protocol.on_connection_made.disconnect(self._on_connection_made)
-                self.protocol.on_telegram_received.disconnect(
-                    self._on_telegram_received
-                )
-                self.protocol.on_telegram_sent.disconnect(self._on_telegram_sent)
-                self.protocol.on_timeout.disconnect(self._on_timeout)
-                self.protocol.on_failed.disconnect(self._on_failed)
-
-                # Close transport if connected
-                if self.protocol.transport:
-                    self.protocol.disconnect()
-
-                # Reset protocol reference
-                self.protocol = None
-
-                # Set state to disconnected
-                self.connection_state = ConnectionState.DISCONNECTED
+        try:
+            # Disconnect service signals
+            self.service.on_telegram_display.disconnect(self._on_telegram_display)
 
-            except Exception as e:
-                self.logger.error(f"Error during cleanup: {e}")
+        except Exception as e:
+            self.logger.error(f"Error during cleanup: {e}")

xp/term/widgets/status_footer.py

@@ -1,30 +1,42 @@
 """Status Footer Widget for displaying app footer with connection status."""
 
-from typing import Any
+from typing import Any, Optional
 
 from textual.app import ComposeResult
 from textual.containers import Horizontal
 from textual.widgets import Footer, Static
 
+from xp.models.term.connection_state import ConnectionState
+from xp.services.term.protocol_monitor_service import ProtocolMonitorService
+
 
 class StatusFooterWidget(Horizontal):
     """Footer widget with connection status indicator.
 
     Combines the Textual Footer with a status indicator dot that shows
-    the current connection state.
+    the current connection state. Subscribes directly to service signals.
 
     Attributes:
+        service: ProtocolMonitorService for connection state and status updates.
         status_widget: Static widget displaying colored status dot.
+        status_text_widget: Static widget displaying status messages.
     """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
+    def __init__(
+        self,
+        service: Optional[ProtocolMonitorService] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
         """Initialize the Status Footer widget.
 
         Args:
+            service: Optional ProtocolMonitorService for signal subscriptions.
             args: Additional positional arguments for Horizontal.
             kwargs: Additional keyword arguments for Horizontal.
         """
         super().__init__(*args, **kwargs)
+        self.service = service
         self.status_text_widget: Static = Static("", id="status-text")
         self.status_widget: Static = Static("○", id="status-line")
 
@@ -38,7 +50,19 @@ class StatusFooterWidget(Horizontal):
         yield self.status_text_widget
         yield self.status_widget
 
-    def update_status(self, state: Any) -> None:
+    def on_mount(self) -> None:
+        """Subscribe to service signals when widget mounts."""
+        if self.service:
+            self.service.on_connection_state_changed.connect(self.update_status)
+            self.service.on_status_message.connect(self.update_message)
+
+    def on_unmount(self) -> None:
+        """Unsubscribe from service signals when widget unmounts."""
+        if self.service:
+            self.service.on_connection_state_changed.disconnect(self.update_status)
+            self.service.on_status_message.disconnect(self.update_message)
+
+    def update_status(self, state: ConnectionState) -> None:
         """Update status indicator with connection state.
 
         Args:

xp/utils/dependencies.py

@@ -10,6 +10,7 @@ from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_logger_config import ConbusLoggerConfig
 from xp.models.homekit.homekit_config import HomekitConfig
 from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+from xp.models.term.protocol_keys_config import ProtocolKeysConfig
 from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
 from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
 from xp.services.actiontable.msactiontable_xp20_serializer import (
@@ -73,6 +74,8 @@ from xp.services.telegram.telegram_discover_service import TelegramDiscoverServi
 from xp.services.telegram.telegram_link_number_service import LinkNumberService
 from xp.services.telegram.telegram_output_service import TelegramOutputService
 from xp.services.telegram.telegram_service import TelegramService
+from xp.services.term.protocol_monitor_service import ProtocolMonitorService
+from xp.term.protocol import ProtocolMonitorApp
 from xp.utils.logging import LoggerService
 
 asyncioreactor.install()
@@ -94,6 +97,7 @@ class ServiceContainer:
         homekit_config_path: str = "homekit.yml",
         conson_config_path: str = "conson.yml",
         server_port: int = 10001,
+        protocol_keys_config_path: str = "protocol.yml",
         reverse_proxy_port: int = 10001,
     ):
         """
@@ -104,6 +108,7 @@ class ServiceContainer:
             logger_config_path: Path to the Conbus Loggerr configuration file
             homekit_config_path: Path to the HomeKit configuration file
             conson_config_path: Path to the Conson configuration file
+            protocol_keys_config_path: Path to the protocol keys configuration file
             server_port: Port for the server service
             reverse_proxy_port: Port for the reverse proxy service
         """
@@ -112,6 +117,7 @@ class ServiceContainer:
         self._logger_config_path = logger_config_path
         self._homekit_config_path = homekit_config_path
         self._conson_config_path = conson_config_path
+        self._protocol_keys_config_path = protocol_keys_config_path
         self._server_port = server_port
         self._reverse_proxy_port = reverse_proxy_port
 
@@ -193,6 +199,24 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        # Terminal UI
+        self.container.register(
+            ProtocolMonitorService,
+            factory=lambda: ProtocolMonitorService(
+                conbus_protocol=self.container.resolve(ConbusEventProtocol),
+                protocol_keys=self._load_protocol_keys(),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            ProtocolMonitorApp,
+            factory=lambda: ProtocolMonitorApp(
+                protocol_service=self.container.resolve(ProtocolMonitorService)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             ConbusEventRawService,
             factory=lambda: ConbusEventRawService(
@@ -549,6 +573,19 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+    def _load_protocol_keys(self) -> "ProtocolKeysConfig":
+        """Load protocol keys from YAML config file.
+
+        Returns:
+            ProtocolKeysConfig instance loaded from configuration path.
+        """
+        from pathlib import Path
+
+        from xp.models.term.protocol_keys_config import ProtocolKeysConfig
+
+        config_path = Path(self._protocol_keys_config_path).resolve()
+        return ProtocolKeysConfig.from_yaml(config_path)
+
     def get_container(self) -> punq.Container:
         """
         Get the configured container with all services registered.

xp/term/protocol.yml

@@ -1,139 +0,0 @@
-protocol:
-  "1":
-    name: "Discover"
-    telegrams:
-      - S0000000000F01D00
-  "2":
-    name: "Error Code"
-    telegrams:
-      - S0020044966F02D10
-  "3":
-    name: "Module Type"
-    telegrams:
-      - S0020044966F02D00
-  "4":
-    name: "Auto Report"
-    telegrams:
-      - S0020044966F02D21
-  "5":
-    name: "Link Number"
-    telegrams:
-      - S0020044966F02D04
-  "6":
-    name: "Blink On"
-    telegrams:
-      - S0020044966F01D01
-  "7":
-    name: "Blink Off"
-    telegrams:
-      - S0020044966F01D00
-  "8":
-    name: "Output 1 On"
-    telegrams:
-      - S0020044966F02101
-  "9":
-    name: "Output 1 Off"
-    telegrams:
-      - S0020044966F02100
-  "0":
-    name: "Output State"
-    telegrams:
-      - S0020044966F02D09
-  "a":
-    name: "Module State"
-    telegrams:
-      - S0020044966F02D09
-  "b":
-    name: "All Off"
-    telegrams:
-      - E02L00I00M
-      - E02L00I00B
-  "c":
-    name: "All On"
-    telegrams:
-      - E02L00I08M
-      - E02L00I08B
-
-  "d":
-    name: "Link 1 On"
-    telegrams:
-      - E02L01I08M
-      - E02L01I08B
-
-  "e":
-    name: "Link 1 Off"
-    telegrams:
-      - E02L01I09M
-      - E02L01I09B
-
-  "f":
-    name: "Link 2 On"
-    telegrams:
-      - E02L02I08M
-      - E02L02I08B
-
-  "g":
-    name: "Link 2 Off"
-    telegrams:
-      - E02L02I09M
-      - E02L02I09B
-
-  "h":
-    name: "Link 3 On"
-    telegrams:
-      - E02L03I08M
-      - E02L03I08B
-
-  "i":
-    name: "Link 3 Off"
-    telegrams:
-      - E02L03I09M
-      - E02L03I09B
-
-  "j":
-    name: "Link 4 On"
-    telegrams:
-      - E02L04I08M
-      - E02L04I08B
-
-  "k":
-    name: "Link 4 Off"
-    telegrams:
-      - E02L04I09M
-      - E02L04I09B
-
-  "l":
-    name: "Link 5 On"
-    telegrams:
-      - E02L05I08M
-      - E02L05I08B
-
-  "m":
-    name: "Link 5 Off"
-    telegrams:
-      - E02L05I09M
-      - E02L05I09B
-
-  "n":
-    name: "Link 6 On"
-    telegrams:
-      - E02L06I08M
-      - E02L06I08B
-
-  "o":
-    name: "Link 6 Off"
-    telegrams:
-      - E02L06I09M
-      - E02L06I09B
-
-  "p":
-    name: "Link 7 On"
-    telegrams:
-      - E02L07I08M
-      - E02L07I08B
-
-  "q":
-    name: "Link 7 Off"
-    telegrams:
-      - E02L07I09M
-      - E02L07I09B