conson-xp 1.27.0__py3-none-any.whl → 1.28.0__py3-none-any.whl

{conson_xp-1.27.0.dist-info → conson_xp-1.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.27.0
+Version: 1.28.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -417,6 +417,7 @@ xp telegram version
 
 xp term
 xp term protocol
+xp term state
 
 <!-- END CLI HELP -->
 ```

{conson_xp-1.27.0.dist-info → conson_xp-1.28.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-conson_xp-1.27.0.dist-info/METADATA,sha256=5eKGY1BwK31UUlBeKY7UO1oV_bUOX48Nu8Qq1CdkCwA,10298
-conson_xp-1.27.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-conson_xp-1.27.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.27.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=oeK4ZrD0Lxf1u59BKhKprbn_yw_JcxIHSVma8YiI5M8,181
+conson_xp-1.28.0.dist-info/METADATA,sha256=vm3hTbH67pUIRDsWHMEsHM4UGNUw3ZNL6V5Xh3KZxPE,10312
+conson_xp-1.28.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.28.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.28.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=Ww_plPH2wL8n-IB9Qn1--AEu9xjpxIPxX53TpCchpnM,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=kElFFpbdUthk23lf6bfGIpzTbBEXE1Y08pU_yAyzmOg,676
+xp/cli/commands/term/term_commands.py,sha256=CwqnLPEi7LuC7bCo7kIGKMZoVICY0nu42k8C554A1TA,1206
 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
@@ -104,8 +104,9 @@ xp/models/telegram/system_telegram.py,sha256=9FNQ4Mf47mRK7wGrTg2GzziVsrEWCE5ZkZp
 xp/models/telegram/telegram.py,sha256=IJUxHX6ftLcET9C1pjvLhUO5Db5JO6W7rUItzdEW30I,842
 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/__init__.py,sha256=aFvzGZHr_dI6USb8MJuYLSLMvxi_ZWMVtokHDt8428s,263
 xp/models/term/connection_state.py,sha256=floDRMeMcfgMrYIVsyoVHBXHtxd3hqm-xOdr3oXtaHY,1793
+xp/models/term/module_state.py,sha256=p9pXCVRDIdMEbAf5jhAHoZ2dnqhpu2rli_ThA1WUCj0,864
 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
@@ -167,32 +168,36 @@ xp/services/server/server_service.py,sha256=JPRFMto2l956dW7vfSclQugu2vdF0fssxxUO
 xp/services/server/xp130_server_service.py,sha256=YnvetDp72-QzkyDGB4qfZZIwFs03HuibUOz2zb9XR0c,2191
 xp/services/server/xp20_server_service.py,sha256=1wJ7A-bRkN9O5Spu3q3LNDW31mNtNF2eNMQ5E6O2ltA,2928
 xp/services/server/xp230_server_service.py,sha256=k9ftCY5tjLFP31mKVCspq283RVaPkGx-Yq61Urk8JLs,1815
-xp/services/server/xp24_server_service.py,sha256=S4kDZHf6SsFTwIzk1PwkWntFHtmOuVcz6UclkRdTGsc,8670
-xp/services/server/xp33_server_service.py,sha256=X5BJr7RYueHAPNrfW-HnqV7ZN-OAouKxH1qMdDADqhk,19745
+xp/services/server/xp24_server_service.py,sha256=a-RZzmieoPd8-SrNX1qwdqzsizjjWwz6TAb0f4Ehz2k,8598
+xp/services/server/xp33_server_service.py,sha256=vvgQxnYXfHlzh3uFYxexHrrOr4l1qPI85n6ig17iWA0,19673
 xp/services/telegram/__init__.py,sha256=kv0JgMg13Fp18WgGQpalNRAWwiWbrz18X4kZAP9xpSQ,48
 xp/services/telegram/telegram_blink_service.py,sha256=Xctc9mCSZiiW1YTh8cA-4jlc8fTioS5OxT6ymhSqiYI,4487
 xp/services/telegram/telegram_checksum_service.py,sha256=rp_C5PlraOOIyqZDp9XjBBNZLUeBLdQNNHVpN6D-1v8,4729
 xp/services/telegram/telegram_datapoint_service.py,sha256=iZ-zp_EM_1ouyeTbd2erhIY2x-98nEHveWWN_a9NfFU,2750
 xp/services/telegram/telegram_discover_service.py,sha256=oTpiq-yzP_UmC0xVOMMFeHO-rIlK1pF3aG-Kq4SeiBI,9025
 xp/services/telegram/telegram_link_number_service.py,sha256=1_c-_QCRPTHYn3BmMElrBJqGG6vnoIst8CB-N42hazk,6862
-xp/services/telegram/telegram_output_service.py,sha256=UaUv_14fR8o5K2PxQBXrCzx-Hohnk-gzbev_oLw_Clc,10799
+xp/services/telegram/telegram_output_service.py,sha256=LK9xHAc3eNeXz82Xs9Nm8WfrHNr7-u2vboDiB7mIFPQ,11950
 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/__init__.py,sha256=BIeOK042bMR-0l6MA80wdW5VuHlpWOXtRER9IG5ilQA,245
 xp/services/term/protocol_monitor_service.py,sha256=PhEzLNzWf1XieQw94ua-hJu9ccwrAzhdxSZGe4kHghs,9945
+xp/services/term/state_monitor_service.py,sha256=gLvNdFMQ8TKX_fAu27TaIyCiEmf-hepkt7zYgFVTvng,12337
 xp/term/__init__.py,sha256=Xg2DhBeI3xQJLfc7_BPWI1por-rUXemyer5OtOt9Cus,51
 xp/term/protocol.py,sha256=oLJAExvIaOSpy75A5TaYB_7R9skTTtNtPx8hiJLdy_U,3425
 xp/term/protocol.tcss,sha256=r_KfxrbpycGHLVXqZc6INBBcUJME0hLrAZkF1oqnab4,2126
+xp/term/state.py,sha256=sR7I6t4gJSkO2YS3TwonAnGPR_f43coCk4xKdWETus0,3233
+xp/term/state.tcss,sha256=Njp7fc16cCunLq7hi5RvXjPi4jSCGi5aPDnusb9dq1Y,1401
 xp/term/widgets/__init__.py,sha256=ftWmN_fmjxy2E8Qfm-YSRmzKfgL0KTBCTpgvYWCPbUY,274
-xp/term/widgets/help_menu.py,sha256=7viKIfyPJr-uz55Y1kgo6h4iHhntxwKs_qmC5siRYNM,1821
+xp/term/widgets/help_menu.py,sha256=w2NjwiC_s16St0rigZ9ef9S0V9Y4v0J5eCVCHAdRKF4,1789
+xp/term/widgets/modules_list.py,sha256=_B46p8lCOH4jr1kVqphS7Rixr6bobg6c_pD4RCj_NRE,7321
 xp/term/widgets/protocol_log.py,sha256=CJUpckWj7GC1kVqixDadteyGnI4aHyzd4kkH-pSbzno,2600
-xp/term/widgets/status_footer.py,sha256=8O3W8clgSbkX21_b9iJ_3XKgDjYTG1Bi-L_PaiEPI7U,3104
+xp/term/widgets/status_footer.py,sha256=bxrcqKzJ9V0aPSn_WwraVpJz7NxBUh3yIjA3fwv5nVA,3256
 xp/utils/__init__.py,sha256=_avMF_UOkfR3tNeDIPqQ5odmbq5raKkaq1rZ9Cn1CJs,332
 xp/utils/checksum.py,sha256=HDpiQxmdIedbCbZ4o_Box0i_Zig417BtCV_46ZyhiTk,1711
-xp/utils/dependencies.py,sha256=Rw3NsvPr7P7xtm2LzLLBP7Q8W07A2fmp4HOKXDH9wS4,23457
+xp/utils/dependencies.py,sha256=UmVAEpGqEG6Li0h6u6I-mFgBTu6dsTeWjWUnfaGFofQ,24227
 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.27.0.dist-info/RECORD,,
+conson_xp-1.28.0.dist-info/RECORD,,

xp/__init__.py

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

xp/cli/commands/term/term_commands.py

@@ -25,3 +25,24 @@ def protocol_monitor(ctx: Context) -> None:
 
     # Resolve ProtocolMonitorApp from container and run
     ctx.obj.get("container").get_container().resolve(ProtocolMonitorApp).run()
+
+
+@term.command("state")
+@click.pass_context
+def state_monitor(ctx: Context) -> None:
+    r"""Start TUI for module state monitoring.
+
+    Displays module states from Conson configuration with real-time
+    updates in an interactive terminal interface.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp term state
+    """
+    from xp.term.state import StateMonitorApp
+
+    # Resolve StateMonitorApp from container and run
+    ctx.obj.get("container").get_container().resolve(StateMonitorApp).run()

xp/models/term/__init__.py

@@ -1,11 +1,13 @@
 """Terminal UI models."""
 
+from xp.models.term.module_state import ModuleState
 from xp.models.term.protocol_keys_config import (
     ProtocolKeyConfig,
     ProtocolKeysConfig,
 )
 
 __all__ = [
+    "ModuleState",
     "ProtocolKeyConfig",
     "ProtocolKeysConfig",
 ]

xp/models/term/module_state.py

@@ -0,0 +1,28 @@
+"""Module state data model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class ModuleState:
+    """State of a Conson module for TUI display.
+
+    Attributes:
+        name: Module name/identifier (e.g., A01, A02).
+        serial_number: Module serial number.
+        module_type: Module type designation (e.g., XP130, XP230, XP24).
+        outputs: Output states as space-separated binary values. Empty string for modules without outputs.
+        auto_report: Auto-report enabled status (Y/N).
+        error_status: Module status ("OK" or error code like "E10").
+        last_update: Last communication timestamp. None if never updated.
+    """
+
+    name: str
+    serial_number: str
+    module_type: str
+    outputs: str
+    auto_report: bool
+    error_status: str
+    last_update: Optional[datetime]

xp/services/server/xp24_server_service.py

@@ -161,10 +161,7 @@ class XP24ServerService(BaseServerService):
 
         data_value = handler()
         data_part = (
-            f"R{self.serial_number}"
-            f"F02D{datapoint_type.value}"
-            f"{self.module_type_code.value:02}"
-            f"{data_value}"
+            f"R{self.serial_number}" f"F02D{datapoint_type.value}" f"{data_value}"
         )
         telegram = self._build_response_telegram(data_part)
 

xp/services/server/xp33_server_service.py

@@ -226,10 +226,7 @@ class XP33ServerService(BaseServerService):
 
         data_value = handler()
         data_part = (
-            f"R{self.serial_number}"
-            f"F02D{datapoint_type.value}"
-            f"{self.module_type_code.value:02}"
-            f"{data_value}"
+            f"R{self.serial_number}" f"F02D{datapoint_type.value}" f"{data_value}"
         )
         telegram = self._build_response_telegram(data_part)
 

xp/services/telegram/telegram_output_service.py

@@ -320,3 +320,36 @@ class TelegramOutputService:
             f"Timestamp: {telegram.timestamp}\n"
             f"Checksum: {telegram.checksum}{checksum_status}"
         )
+
+    @staticmethod
+    def format_output_state(data_value: str) -> str:
+        """Format module output state data value for display.
+
+        Algorithm:
+        1. Remove 'x' characters
+        2. Format to 4 chars with space padding on the right
+        3. Invert order
+        4. Add spaces between characters
+
+        Args:
+            data_value: Raw data value from module output state datapoint (e.g., "xxxx0101", "xx1110").
+
+        Returns:
+            Formatted output string with spaces (e.g., "1 0 1 0", "0 1 1 1").
+
+        Examples:
+            >>> TelegramOutputService.format_output_state("xxxx0101")
+            "1 0 1 0"
+            >>> TelegramOutputService.format_output_state("xx1110")
+            "0 1 1 1"
+            >>> TelegramOutputService.format_output_state("xxxx01")
+            "  1 0"
+        """
+        # Remove 'x' characters
+        cleaned = data_value.replace("x", "").replace("X", "")
+        # Format to 4 chars with space padding on the right
+        padded = cleaned.ljust(4)[:4]
+        # Invert order
+        inverted = padded[::-1]
+        # Add spaces between characters
+        return " ".join(inverted)

xp/services/term/__init__.py

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

xp/services/term/state_monitor_service.py

@@ -0,0 +1,313 @@
+"""State Monitor Service for terminal interface."""
+
+import logging
+from datetime import datetime
+from typing import Dict, List
+
+from psygnal import Signal
+
+from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.models.term.connection_state import ConnectionState
+from xp.models.term.module_state import ModuleState
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+from xp.services.telegram.telegram_output_service import TelegramOutputService
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class StateMonitorService:
+    """Service for module state monitoring in terminal interface.
+
+    Wraps ConbusEventProtocol and ConsonModuleListConfig to provide
+    high-level module state tracking for the TUI.
+
+    Attributes:
+        on_connection_state_changed: Signal emitted when connection state changes.
+        on_module_list_updated: Signal emitted when module list refreshed from config.
+        on_module_state_changed: Signal emitted when individual module state updates.
+        on_module_error: Signal emitted when module error occurs.
+        on_status_message: Signal emitted for status messages.
+        connection_state: Property returning current connection state.
+        server_info: Property returning server connection info (IP:port).
+        module_states: Property returning list of all module states.
+    """
+
+    on_connection_state_changed: Signal = Signal(ConnectionState)
+    on_module_list_updated: Signal = Signal(list)
+    on_module_state_changed: Signal = Signal(ModuleState)
+    on_module_error: Signal = Signal(str, str)
+    on_status_message: Signal = Signal(str)
+
+    def __init__(
+        self,
+        conbus_protocol: ConbusEventProtocol,
+        conson_config: ConsonModuleListConfig,
+        telegram_service: TelegramService,
+    ) -> None:
+        """Initialize the State Monitor service.
+
+        Args:
+            conbus_protocol: ConbusEventProtocol instance.
+            conson_config: ConsonModuleListConfig for module configuration.
+            telegram_service: TelegramService for parsing telegrams.
+        """
+        self.logger = logging.getLogger(__name__)
+        self._conbus_protocol = conbus_protocol
+        self._conson_config = conson_config
+        self._telegram_service = telegram_service
+        self._connection_state = ConnectionState.DISCONNECTED
+        self._state_machine = ConnectionState.create_state_machine()
+        self._module_states: Dict[str, ModuleState] = {}
+
+        # Connect to protocol signals
+        self._connect_signals()
+
+        # Initialize module states from config
+        self._initialize_module_states()
+
+    def _initialize_module_states(self) -> None:
+        """Initialize module states from ConsonModuleListConfig."""
+        for module_config in self._conson_config.root:
+            # Map auto_report_status: PP → True, others → False
+            auto_report = module_config.auto_report_status == "PP"
+
+            module_state = ModuleState(
+                name=module_config.name,
+                serial_number=module_config.serial_number,
+                module_type=module_config.module_type,
+                outputs="",  # Empty initially
+                auto_report=auto_report,
+                error_status="OK",
+                last_update=None,  # Not updated yet
+            )
+            self._module_states[module_config.serial_number] = module_state
+
+    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_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_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}"
+
+    @property
+    def module_states(self) -> List[ModuleState]:
+        """Get all module states.
+
+        Returns:
+            List of all module states.
+        """
+        return list(self._module_states.values())
+
+    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 refresh_all(self) -> None:
+        """Refresh all module states.
+
+        Queries module_output_state datapoint for eligible modules (XP24, XP33LR, XP33LED).
+        Updates outputs column and last_update timestamp for each queried module.
+        """
+        self.on_status_message.emit("Refreshing module states...")
+
+        # Eligible module types that support output state queries
+        eligible_types = {"XP24", "XP33LR", "XP33LED"}
+
+        # Filter and query eligible modules
+        for module_state in self._module_states.values():
+            if module_state.module_type in eligible_types:
+                self._query_module_output_state(module_state.serial_number)
+                self.logger.debug(
+                    f"Querying output state for {module_state.name} ({module_state.module_type})"
+                )
+
+    def _query_module_output_state(self, serial_number: str) -> None:
+        """Query module output state datapoint.
+
+        Args:
+            serial_number: Module serial number to query.
+        """
+        self._conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=str(DataPointType.MODULE_OUTPUT_STATE.value),
+        )
+
+    def _on_connection_made(self) -> None:
+        """Handle connection made event."""
+        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}")
+
+            # Emit initial module list
+            self.on_module_list_updated.emit(self.module_states)
+
+    def _on_connection_failed(self, failure: Exception) -> None:
+        """Handle connection failed event.
+
+        Args:
+            failure: Exception that caused 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"Connection failed: {failure}")
+
+    def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Parse output states from telegram and update module state.
+
+        Args:
+            event: Telegram received event.
+        """
+        # Only process reply telegrams
+        if event.telegram_type != TelegramType.REPLY:
+            return
+
+        serial_number = event.serial_number
+        if not serial_number or serial_number not in self._module_states:
+            return
+
+        # Parse the reply telegram
+        reply_telegram = self._telegram_service.parse_reply_telegram(event.frame)
+        if not reply_telegram:
+            return
+
+        # Check if this is a module output state response
+        if (
+            reply_telegram.system_function == SystemFunction.READ_DATAPOINT
+            and reply_telegram.datapoint_type == DataPointType.MODULE_OUTPUT_STATE
+        ):
+            module_state = self._module_states[serial_number]
+
+            # Parse output state from data_value using TelegramOutputService
+            outputs = TelegramOutputService.format_output_state(
+                reply_telegram.data_value
+            )
+            module_state.outputs = outputs
+            module_state.last_update = datetime.now()
+
+            self.on_module_state_changed.emit(module_state)
+            self.logger.debug(f"Updated outputs for {module_state.name}: {outputs}")
+
+    def _on_timeout(self) -> None:
+        """Handle timeout event."""
+        self.on_status_message.emit("Connection timeout")
+
+    def _on_failed(self, failure: Exception) -> None:
+        """Handle protocol failure event.
+
+        Args:
+            failure: Exception that caused 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"Protocol error: {failure}")
+
+    def cleanup(self) -> None:
+        """Clean up service resources."""
+        self._disconnect_signals()
+        self.logger.debug("StateMonitorService cleaned up")
+
+    def __enter__(self) -> "StateMonitorService":
+        """Context manager entry.
+
+        Returns:
+            Self for context manager.
+        """
+        return self
+
+    def __exit__(self, _exc_type: object, _exc_val: object, _exc_tb: object) -> None:
+        """Context manager exit.
+
+        Args:
+            _exc_type: Exception type.
+            _exc_val: Exception value.
+            _exc_tb: Exception traceback.
+        """
+        self.cleanup()

xp/term/state.py

@@ -0,0 +1,97 @@
+"""State Monitor TUI Application."""
+
+from pathlib import Path
+from typing import Optional
+
+from textual.app import App, ComposeResult
+
+from xp.services.term.state_monitor_service import StateMonitorService
+from xp.term.widgets.modules_list import ModulesListWidget
+from xp.term.widgets.status_footer import StatusFooterWidget
+
+
+class StateMonitorApp(App[None]):
+    """Textual app for module state monitoring.
+
+    Displays module states from Conson configuration in an interactive
+    terminal interface with real-time updates.
+
+    Attributes:
+        state_service: StateMonitorService for module state operations.
+        CSS_PATH: Path to CSS stylesheet file.
+        BINDINGS: Keyboard bindings for app actions.
+        TITLE: Application title displayed in header.
+        ENABLE_COMMAND_PALETTE: Disable Textual's command palette feature.
+    """
+
+    CSS_PATH = Path(__file__).parent / "state.tcss"
+    TITLE = "Modules"
+    ENABLE_COMMAND_PALETTE = False
+
+    BINDINGS = [
+        ("Q", "quit", "Quit"),
+        ("C", "toggle_connection", "Connect"),
+        ("r", "refresh_all", "Refresh"),
+    ]
+
+    def __init__(self, state_service: StateMonitorService) -> None:
+        """Initialize the State Monitor app.
+
+        Args:
+            state_service: StateMonitorService for module state operations.
+        """
+        super().__init__()
+        self.state_service: StateMonitorService = state_service
+        self.modules_widget: Optional[ModulesListWidget] = None
+        self.footer_widget: Optional[StatusFooterWidget] = None
+
+    def compose(self) -> ComposeResult:
+        """Compose the app layout with widgets.
+
+        Yields:
+            ModulesListWidget and StatusFooterWidget.
+        """
+        self.modules_widget = ModulesListWidget(
+            service=self.state_service, id="modules-list"
+        )
+        yield self.modules_widget
+
+        self.footer_widget = StatusFooterWidget(
+            service=self.state_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.
+        Sets up automatic screen refresh every second to update elapsed times.
+        """
+        import asyncio
+
+        # Delay connection to let UI render
+        await asyncio.sleep(0.5)
+        self.state_service.connect()
+
+        # Set up periodic refresh to update elapsed times
+        self.set_interval(1.0, self._refresh_last_update_column)
+
+    def _refresh_last_update_column(self) -> None:
+        """Refresh only the last_update column to show elapsed time."""
+        if self.modules_widget:
+            self.modules_widget.refresh_last_update_times()
+
+    def action_toggle_connection(self) -> None:
+        """Toggle connection on 'c' key press.
+
+        Connects if disconnected/failed, disconnects if connected/connecting.
+        """
+        self.state_service.toggle_connection()
+
+    def action_refresh_all(self) -> None:
+        """Refresh all module data on 'r' key press."""
+        self.state_service.refresh_all()
+
+    def on_unmount(self) -> None:
+        """Clean up service when app unmounts."""
+        self.state_service.cleanup()

xp/term/state.tcss

@@ -0,0 +1,86 @@
+/* State Monitor TUI Styling */
+
+/* Color overrides */
+$success: #00ff00;
+
+/* App-level styling */
+Screen {
+    background: $background;
+}
+
+/* Modules List Widget */
+ModulesListWidget {
+    border: solid $success;
+    border-title-align: left;
+    width: 1fr;
+    height: 1fr;
+    background: $background;
+    padding: 1;
+}
+
+ModulesListWidget:focus {
+    background: $background;
+    background-tint: transparent;
+}
+
+#modules-table {
+    background: $background !important;
+    width: 100%;
+    height: 1fr;
+}
+
+#modules-table:focus {
+    background: $background !important;
+    background-tint: transparent;
+}
+
+DataTable {
+    background: $background;
+    color: $success;
+}
+
+DataTable > .datatable--header {
+    background: $background;
+    color: $success;
+}
+
+DataTable > .datatable--cursor {
+    background: $background;
+    color: $success;
+}
+
+DataTable:focus > .datatable--cursor {
+    background: $background;
+    color: $success;
+}
+
+/* Footer styling */
+#footer-container {
+    dock: bottom;
+    height: 1;
+    background: $background;
+}
+
+Footer {
+    width: auto;
+    background: $background;
+    color: $text;
+}
+
+#status-text {
+    dock: right;
+    width: auto;
+    padding: 0 3;
+    background: $background;
+    color: $text;
+    text-align: right;
+}
+
+#status-line {
+    dock: right;
+    width: auto;
+    padding: 0 1;
+    background: $background;
+    color: $text;
+    text-align: right;
+}

xp/term/widgets/help_menu.py

@@ -36,10 +36,10 @@ class HelpMenuWidget(Vertical):
         """
         super().__init__(*args, **kwargs)
         self.service: ProtocolMonitorService = service
-        self.help_table: DataTable = DataTable(id="help-table", show_header=False)
-        self.help_table.can_focus = False
+        self.help_table: DataTable = DataTable(
+            id="help-table", show_header=False, cursor_type="row"
+        )
         self.border_title = "Help menu"
-        self.can_focus = False
 
     def compose(self) -> ComposeResult:
         """Compose the help menu layout.

xp/term/widgets/modules_list.py

@@ -0,0 +1,217 @@
+"""Modules List Widget for displaying module state table."""
+
+from datetime import datetime
+from typing import Any, List, Optional
+
+from textual.app import ComposeResult
+from textual.widgets import DataTable, Static
+
+from xp.models.term.module_state import ModuleState
+from xp.services.term.state_monitor_service import StateMonitorService
+
+
+class ModulesListWidget(Static):
+    """Widget displaying module states in a data table.
+
+    Shows module information with real-time updates from StateMonitorService.
+    Table displays: name, serial_number, module_type, outputs, report, status, last_update.
+
+    Attributes:
+        service: StateMonitorService for module state updates.
+        table: DataTable widget displaying module information.
+    """
+
+    def __init__(
+        self,
+        service: Optional[StateMonitorService] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the Modules List widget.
+
+        Args:
+            service: Optional StateMonitorService for signal subscriptions.
+            args: Additional positional arguments for Static.
+            kwargs: Additional keyword arguments for Static.
+        """
+        super().__init__(*args, **kwargs)
+        self.service = service
+        self.table: Optional[DataTable] = None
+        self._row_keys: dict[str, Any] = {}  # Map serial_number to row key
+
+    def compose(self) -> ComposeResult:
+        """Compose the widget layout.
+
+        Yields:
+            DataTable widget.
+        """
+        self.table = DataTable(id="modules-table", cursor_type="row")
+        yield self.table
+
+    def on_mount(self) -> None:
+        """Initialize table and subscribe to service signals when widget mounts."""
+        # Set border title
+        self.border_title = "Modules"
+
+        if self.table:
+            # Set table to full width
+            self.table.styles.width = "100%"
+
+            # Setup table columns
+            self.table.add_column("name", key="name")
+            self.table.add_column("serial number", key="serial_number")
+            self.table.add_column("module type", key="module_type")
+            self.table.add_column("outputs", key="outputs")
+            self.table.add_column("report", key="report")
+            self.table.add_column("status", key="status")
+            self.table.add_column("last update", key="last_update")
+
+        if self.service:
+            self.service.on_module_list_updated.connect(self.update_module_list)
+            self.service.on_module_state_changed.connect(self.update_module_state)
+
+    def on_unmount(self) -> None:
+        """Unsubscribe from service signals when widget unmounts."""
+        if self.service:
+            self.service.on_module_list_updated.disconnect(self.update_module_list)
+            self.service.on_module_state_changed.disconnect(self.update_module_state)
+
+    def update_module_list(self, module_states: List[ModuleState]) -> None:
+        """Update entire module list from service.
+
+        Clears existing table and repopulates with all modules.
+
+        Args:
+            module_states: List of all module states.
+        """
+        if not self.table:
+            return
+
+        # Clear existing rows
+        self.table.clear()
+        self._row_keys.clear()
+
+        # Add all modules
+        for module_state in module_states:
+            self._add_module_row(module_state)
+
+    def update_module_state(self, module_state: ModuleState) -> None:
+        """Update individual module state in table.
+
+        Updates existing row if module exists, otherwise adds new row.
+
+        Args:
+            module_state: Updated module state.
+        """
+        if not self.table:
+            return
+
+        serial_number = module_state.serial_number
+
+        if serial_number in self._row_keys:
+            # Update existing row
+            row_key = self._row_keys[serial_number]
+            self.table.update_cell(
+                row_key, "outputs", self._format_outputs(module_state.outputs)
+            )
+            self.table.update_cell(
+                row_key, "report", self._format_report(module_state.auto_report)
+            )
+            self.table.update_cell(row_key, "status", module_state.error_status)
+            self.table.update_cell(
+                row_key,
+                "last_update",
+                self._format_last_update(module_state.last_update),
+            )
+        else:
+            # Add new row
+            self._add_module_row(module_state)
+
+    def _add_module_row(self, module_state: ModuleState) -> None:
+        """Add a module row to the table.
+
+        Args:
+            module_state: Module state to add.
+        """
+        if not self.table:
+            return
+
+        row_key = self.table.add_row(
+            module_state.name,
+            module_state.serial_number,
+            module_state.module_type,
+            self._format_outputs(module_state.outputs),
+            self._format_report(module_state.auto_report),
+            module_state.error_status,
+            self._format_last_update(module_state.last_update),
+        )
+        self._row_keys[module_state.serial_number] = row_key
+
+    def _format_outputs(self, outputs: str) -> str:
+        """Format outputs for display.
+
+        Args:
+            outputs: Raw output string.
+
+        Returns:
+            Formatted output string (empty string for modules without outputs).
+        """
+        return outputs
+
+    def _format_report(self, auto_report: bool) -> str:
+        """Format auto-report status for display.
+
+        Args:
+            auto_report: Auto-report boolean value.
+
+        Returns:
+            "Y" if True, "N" if False.
+        """
+        return "Y" if auto_report else "N"
+
+    def _format_last_update(self, last_update: Optional[datetime]) -> str:
+        """Format last update timestamp for display.
+
+        Shows elapsed time in HH:MM:SS format or "--:--:--" if never updated.
+
+        Args:
+            last_update: Last update timestamp or None.
+
+        Returns:
+            Formatted time string.
+        """
+        if last_update is None:
+            return "--:--:--"
+
+        # Calculate elapsed time
+        elapsed = datetime.now() - last_update
+        total_seconds = int(elapsed.total_seconds())
+
+        hours = total_seconds // 3600
+        minutes = (total_seconds % 3600) // 60
+        seconds = total_seconds % 60
+
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+    def refresh_last_update_times(self) -> None:
+        """Refresh only the last_update column for all modules.
+
+        Updates the elapsed time display without querying the service.
+        """
+        if not self.table or not self.service:
+            return
+
+        # Update last_update column for each module
+        for serial_number, row_key in self._row_keys.items():
+            # Get the module state from service
+            module_states = self.service.module_states
+            module_state = next(
+                (m for m in module_states if m.serial_number == serial_number), None
+            )
+            if module_state:
+                # Update only the last_update cell
+                self.table.update_cell(
+                    row_key,
+                    "last_update",
+                    self._format_last_update(module_state.last_update),
+                )

xp/term/widgets/status_footer.py

@@ -1,6 +1,6 @@
 """Status Footer Widget for displaying app footer with connection status."""
 
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 from textual.app import ComposeResult
 from textual.containers import Horizontal
@@ -8,6 +8,7 @@ from textual.widgets import Footer, Static
 
 from xp.models.term.connection_state import ConnectionState
 from xp.services.term.protocol_monitor_service import ProtocolMonitorService
+from xp.services.term.state_monitor_service import StateMonitorService
 
 
 class StatusFooterWidget(Horizontal):
@@ -17,21 +18,21 @@ class StatusFooterWidget(Horizontal):
     the current connection state. Subscribes directly to service signals.
 
     Attributes:
-        service: ProtocolMonitorService for connection state and status updates.
+        service: ProtocolMonitorService or StateMonitorService 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,
-        service: Optional[ProtocolMonitorService] = None,
+        service: Optional[Union[ProtocolMonitorService, StateMonitorService]] = None,
         *args: Any,
         **kwargs: Any,
     ) -> None:
         """Initialize the Status Footer widget.
 
         Args:
-            service: Optional ProtocolMonitorService for signal subscriptions.
+            service: Optional ProtocolMonitorService or StateMonitorService for signal subscriptions.
             args: Additional positional arguments for Horizontal.
             kwargs: Additional keyword arguments for Horizontal.
         """

xp/utils/dependencies.py

@@ -75,7 +75,9 @@ 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.services.term.state_monitor_service import StateMonitorService
 from xp.term.protocol import ProtocolMonitorApp
+from xp.term.state import StateMonitorApp
 from xp.utils.logging import LoggerService
 
 asyncioreactor.install()
@@ -217,6 +219,24 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            StateMonitorService,
+            factory=lambda: StateMonitorService(
+                conbus_protocol=self.container.resolve(ConbusEventProtocol),
+                conson_config=self.container.resolve(ConsonModuleListConfig),
+                telegram_service=self.container.resolve(TelegramService),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            StateMonitorApp,
+            factory=lambda: StateMonitorApp(
+                state_service=self.container.resolve(StateMonitorService)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             ConbusEventRawService,
             factory=lambda: ConbusEventRawService(