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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.28.0
+Version: 1.32.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -325,6 +325,7 @@ xp conbus event
 xp conbus event list
 xp conbus event raw
 
+xp conbus export
 
 xp conbus lightlevel
 xp conbus lightlevel get

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

@@ -1,8 +1,8 @@
-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
+conson_xp-1.32.0.dist-info/METADATA,sha256=7pNhSUQaahCS55NfZHY_NR7e7d3VZ73oDUXwcCirr4A,10329
+conson_xp-1.32.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.32.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.32.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=WvYNIdtUKhtQhMR_bDasGkHpOfRlda8a-wO0v7kBE5c,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
@@ -16,6 +16,7 @@ xp/cli/commands/conbus/conbus_custom_commands.py,sha256=lICT93ijMdhVRm8KjNMLo7kQ
 xp/cli/commands/conbus/conbus_datapoint_commands.py,sha256=r36OuTjREtbGKL-bskAGa0-WLw7x06td6woZn3GYJNA,3630
 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_export_commands.py,sha256=s3jgg3Wqi1P6rYujpE_9aPA47S4UBQfrZPTr9vzH-UA,2951
 xp/cli/commands/conbus/conbus_lightlevel_commands.py,sha256=FpCwogdxa7yFUjlrxM7e8Q2Ut32tKAHabngQQChvtJI,6763
 xp/cli/commands/conbus/conbus_linknumber_commands.py,sha256=KitaGDM5HpwVUz8rLpO8VZUypUTcAg3Bzl0DVm6gnSk,3391
 xp/cli/commands/conbus/conbus_modulenumber_commands.py,sha256=L7-6y3rDllOjQ9g6Bk_RiTKIhAOHVPLdxWif9exkngs,3463
@@ -43,7 +44,7 @@ xp/cli/commands/telegram/telegram_version_commands.py,sha256=WQyx1-B9yJ8V9WrFyBp
 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=CwqnLPEi7LuC7bCo7kIGKMZoVICY0nu42k8C554A1TA,1206
-xp/cli/main.py,sha256=ap5jU0DrSnrCKDKqGXcz9N-sngZodyyN-5ReWE8Fh1s,1817
+xp/cli/main.py,sha256=3bksBas1mI-PZQGVxDJ7aoAG09L-cMQMK9Uf7y6_aF8,1963
 xp/cli/utils/__init__.py,sha256=gTGIj60Uai0iE7sr9_TtEpl04fD7krtTzbbigXUsUVU,46
 xp/cli/utils/click_tree.py,sha256=ilmM2IMa_c-TqUMsv2alrZXuS0BNhvVlrBlSfyN8lzM,1670
 xp/cli/utils/datapoint_type_choice.py,sha256=HcydhlqxZ7YyorEeTjFGkypF2JnYNPvOzkl1rhZ93Fc,1666
@@ -73,6 +74,7 @@ xp/models/conbus/conbus_datapoint.py,sha256=4ncR-vB2lRzRBAA30rYn8eguyTxsZoOKrrXt
 xp/models/conbus/conbus_discover.py,sha256=nxxUEKfEsH1kd0BF8ovMs7zLujRhrq1oL9ZJtysPr5o,2238
 xp/models/conbus/conbus_event_list.py,sha256=M8aHRHVB5VDIjqMzjO86xlERt7AMdfjIjt1b70RF52Y,958
 xp/models/conbus/conbus_event_raw.py,sha256=i5gc7z-0yeunWOZ4rw3AiBt4MANezmhBQKjOOQk3oDc,1567
+xp/models/conbus/conbus_export.py,sha256=m2zrkpVifC9EZZBlJGFaaVyGq8w1a1nbapQM1n9mJo8,1078
 xp/models/conbus/conbus_lightlevel.py,sha256=GQGhzrCBEJROosNHInXIzBy6MD2AskEIMoFEGgZ60-0,1695
 xp/models/conbus/conbus_linknumber.py,sha256=uFzKzfB06oIzZEKCb5X2JEI80JjMPFuYglsT1W1k8j4,1815
 xp/models/conbus/conbus_logger_config.py,sha256=cFWjWn8tc_hPPI2kQAib_Akddar8O-3zkoj6wLBsdUo,3328
@@ -106,7 +108,7 @@ xp/models/telegram/telegram_type.py,sha256=GhqKP63oNMyh2tIvCPcsC5RFp4s4JjhmEqCLC
 xp/models/telegram/timeparam_type.py,sha256=Ar8xvSfPmOAgR2g2Je0FgvP01SL7bPvZn5_HrVDpmJM,1137
 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/module_state.py,sha256=tg5V3HNicXhXE10WuDSCN8OleVrorXrOosXOEgEAVE0,934
 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
@@ -133,6 +135,7 @@ xp/services/conbus/conbus_datapoint_service.py,sha256=SYhHj9RmTmaJ750tyZ1IW2kl7t
 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_export_service.py,sha256=-EIDiXOitLwXTKCfw1zv4XIuIKWaT-3FkxtQwms7PgM,17920
 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=7wOaEDrdoXwZE9MeUM89eB3hobYpvtbYk_YLv3MVAtc,5352
@@ -162,9 +165,10 @@ xp/services/protocol/telegram_protocol.py,sha256=Ki5DrXsKxiaqLcdP9WWUuhUI7cPu2Df
 xp/services/reverse_proxy_service.py,sha256=BUOlcLlTU-R5iuC_96rasug21xo19wK9_4fMQXxc0QM,15061
 xp/services/server/__init__.py,sha256=QEcCj-jK0goAukJCe15TKYFQfSAzWsduPT_wW0HxZU8,48
 xp/services/server/base_server_service.py,sha256=B-ntxp3swbwuri-9_2EuvBDi-4Uo9AH-AA4iAFGWIS4,12682
+xp/services/server/client_buffer_manager.py,sha256=1d_MqfzuUqBwaQUiC1n5K76WwSxrdngYAmNH7he6u3o,2235
 xp/services/server/cp20_server_service.py,sha256=SXdI6Jt400T9sLdw86ovEqKRGeV3nYVaHEA9Gcj6W2A,2041
 xp/services/server/device_service_factory.py,sha256=Y4TvSFALeq0zYzHfCwcbikSpmIyYbLcvm9756n5Jm7Q,3744
-xp/services/server/server_service.py,sha256=JPRFMto2l956dW7vfSclQugu2vdF0fssxxUOYjHNtA4,15833
+xp/services/server/server_service.py,sha256=2t3guPVX3YUyNJo7B5b1U80eRMyEgE7irT2X8MMQMag,16302
 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
@@ -181,7 +185,7 @@ xp/services/telegram/telegram_service.py,sha256=XrP1CPi0ckxoKBaNwLA6lo-TogWxXgmX
 xp/services/telegram/telegram_version_service.py,sha256=M5HdOTsLdcwo122FP-jW6R740ktLrtKf2TiMDVz23h8,10528
 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/services/term/state_monitor_service.py,sha256=PgwCH8nce1RODV33aJefiX3on-pSGEgP_4FDAoU5Trc,16218
 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
@@ -189,15 +193,15 @@ 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=w2NjwiC_s16St0rigZ9ef9S0V9Y4v0J5eCVCHAdRKF4,1789
-xp/term/widgets/modules_list.py,sha256=_B46p8lCOH4jr1kVqphS7Rixr6bobg6c_pD4RCj_NRE,7321
+xp/term/widgets/modules_list.py,sha256=DD0PUnY4gv05hkCVxThWULHg1ZNNY8xr1XFaZrv9kS4,7666
 xp/term/widgets/protocol_log.py,sha256=CJUpckWj7GC1kVqixDadteyGnI4aHyzd4kkH-pSbzno,2600
 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=UmVAEpGqEG6Li0h6u6I-mFgBTu6dsTeWjWUnfaGFofQ,24227
+xp/utils/dependencies.py,sha256=d91Xt4PwnyeMB_tLB-hNDpm95QGMg5uiq52yvOM9BBE,24557
 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.28.0.dist-info/RECORD,,
+conson_xp-1.32.0.dist-info/RECORD,,

xp/__init__.py

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

xp/cli/commands/conbus/conbus_export_commands.py

@@ -0,0 +1,88 @@
+"""Conbus export CLI command."""
+
+from contextlib import suppress
+
+import click
+
+from xp.cli.commands.conbus.conbus import conbus
+from xp.cli.utils.decorators import connection_command
+from xp.models.conbus.conbus_export import ConbusExportResponse
+from xp.models.homekit.homekit_conson_config import ConsonModuleConfig
+from xp.services.conbus.conbus_export_service import ConbusExportService
+
+
+@conbus.command("export")
+@click.pass_context
+@connection_command()
+def export_conbus_config(ctx: click.Context) -> None:
+    r"""Export Conbus device configuration to YAML file.
+
+    Discovers all devices on the Conbus network and queries their configuration
+    datapoints to generate a complete export.yml file in conson.yml format.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        # Export to export.yml in current directory
+        xp conbus export
+    """
+
+    def on_progress(serial_number: str, current: int, total: int) -> None:
+        """Handle progress updates during export.
+
+        Args:
+            serial_number: Serial number of discovered device.
+            current: Current device number.
+            total: Total devices discovered.
+        """
+        click.echo(f"Querying device {current}/{total}: {serial_number}...")
+
+    def on_device_exported(module: ConsonModuleConfig) -> None:
+        """Handle device export completion.
+
+        Args:
+            module: Exported module configuration.
+        """
+        module_type = module.module_type or "UNKNOWN"
+        module_code = (
+            module.module_type_code if module.module_type_code is not None else "?"
+        )
+        click.echo(f"  ✓ Module type: {module_type} ({module_code})")
+
+        if module.link_number is not None:
+            click.echo(f"  ✓ Link number: {module.link_number}")
+        if module.sw_version:
+            click.echo(f"  ✓ Software version: {module.sw_version}")
+
+    def on_finish(result: ConbusExportResponse) -> None:
+        """Handle export completion.
+
+        Args:
+            result: Export result.
+
+        Raises:
+            ClickException: When export fails with error message from result.
+        """
+        # Try to stop reactor (may already be stopped)
+        with suppress(Exception):
+            service.stop_reactor()
+
+        if result.success:
+            click.echo(
+                f"\nExport complete: {result.output_file} ({result.device_count} devices)"
+            )
+        else:
+            click.echo(f"Error: {result.error}", err=True)
+            raise click.ClickException(result.error or "Export failed")
+
+    service: ConbusExportService = (
+        ctx.obj.get("container").get_container().resolve(ConbusExportService)
+    )
+    with service:
+        service.on_progress.connect(on_progress)
+        service.on_device_exported.connect(on_device_exported)
+        service.on_finish.connect(on_finish)
+        service.set_timeout(5)
+        service.start_reactor()

xp/cli/main.py

@@ -4,11 +4,13 @@ import click
 from click_help_colors import HelpColorsGroup
 
 from xp.cli.commands import homekit
+
+# Import all conbus command modules to register their commands
+from xp.cli.commands.conbus import conbus_discover_commands  # noqa: F401
+from xp.cli.commands.conbus import conbus_export_commands  # noqa: F401
 from xp.cli.commands.conbus.conbus import conbus
 from xp.cli.commands.file_commands import file
 from xp.cli.commands.module_commands import module
-
-# Import all conbus command modules to register their commands
 from xp.cli.commands.reverse_proxy_commands import reverse_proxy
 from xp.cli.commands.server.server_commands import server
 

xp/models/conbus/conbus_export.py

@@ -0,0 +1,31 @@
+"""Conbus export response model."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+
+
+@dataclass
+class ConbusExportResponse:
+    """Response from Conbus export operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        config: Exported module configuration list.
+        device_count: Number of devices exported.
+        output_file: Path to output file.
+        export_status: Export status (OK, FAILED_TIMEOUT, FAILED_NO_DEVICES, etc.).
+        error: Error message if operation failed.
+        sent_telegrams: List of telegrams sent during export.
+        received_telegrams: List of telegrams received during export.
+    """
+
+    success: bool
+    config: Optional[ConsonModuleListConfig] = None
+    device_count: int = 0
+    output_file: str = "export.yml"
+    export_status: str = "OK"
+    error: Optional[str] = None
+    sent_telegrams: list[str] = field(default_factory=list)
+    received_telegrams: list[str] = field(default_factory=list)

xp/models/term/module_state.py

@@ -13,6 +13,7 @@ class ModuleState:
         name: Module name/identifier (e.g., A01, A02).
         serial_number: Module serial number.
         module_type: Module type designation (e.g., XP130, XP230, XP24).
+        link_number: Link number for the module.
         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").
@@ -22,6 +23,7 @@ class ModuleState:
     name: str
     serial_number: str
     module_type: str
+    link_number: int
     outputs: str
     auto_report: bool
     error_status: str

xp/services/conbus/conbus_export_service.py

@@ -0,0 +1,460 @@
+"""Conbus export service for exporting device configurations."""
+
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+from psygnal import Signal
+
+from xp.models.conbus.conbus_export import ConbusExportResponse
+from xp.models.homekit.homekit_conson_config import (
+    ConsonModuleConfig,
+    ConsonModuleListConfig,
+)
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.reply_telegram import ReplyTelegram
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ConbusExportService:
+    """Service for exporting Conbus device configurations.
+
+    Discovers all devices on the Conbus network and queries their configuration
+    datapoints to generate a structured export file compatible with conson.yml format.
+
+    Attributes:
+        conbus_protocol: Protocol for Conbus communication.
+        discovered_devices: List of discovered device serial numbers.
+        device_configs: Partial device configurations being built.
+        device_datapoints_received: Set of datapoints received per device.
+        export_result: Final export result.
+        export_status: Export status (OK, FAILED_TIMEOUT, etc.).
+        on_progress: Signal emitted on device discovery (serial, current, total).
+        on_device_exported: Signal emitted when device export completes.
+        on_finish: Signal emitted when export finishes.
+        DATAPOINT_SEQUENCE: Sequence of 7 datapoints to query for each device.
+    """
+
+    # Signals (class attributes)
+    on_progress: Signal = Signal(str, int, int)  # serial, current, total
+    on_device_exported: Signal = Signal(ConsonModuleConfig)
+    on_finish: Signal = Signal(ConbusExportResponse)
+
+    # Datapoint sequence to query for each device
+    DATAPOINT_SEQUENCE = [
+        DataPointType.MODULE_TYPE,
+        DataPointType.MODULE_TYPE_CODE,
+        DataPointType.LINK_NUMBER,
+        DataPointType.MODULE_NUMBER,
+        DataPointType.SW_VERSION,
+        DataPointType.HW_VERSION,
+        DataPointType.AUTO_REPORT_STATUS,
+    ]
+
+    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
+        """Initialize the Conbus export service.
+
+        Args:
+            conbus_protocol: Protocol for Conbus communication.
+        """
+        self.logger = logging.getLogger(__name__)
+        self.conbus_protocol = conbus_protocol
+        self.telegram_service = TelegramService()
+
+        # State management
+        self.discovered_devices: list[str] = []
+        self.device_configs: dict[str, dict[str, Any]] = {}
+        self.device_datapoints_received: dict[str, set[str]] = {}
+        self.export_result = ConbusExportResponse(success=False)
+        self.export_status = "OK"
+        self._finalized = False  # Track if export has been finalized
+
+        # Connect protocol signals
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
+    def connection_made(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established, starting discovery")
+
+        # Send DISCOVERY telegram
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number="0000000000",
+            system_function=SystemFunction.DISCOVERY,
+            data_value="00",
+        )
+
+    def telegram_sent(self, telegram: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram: Telegram that was sent.
+        """
+        self.export_result.sent_telegrams.append(telegram)
+
+    def telegram_received(self, event: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            event: Telegram received event.
+        """
+        self.export_result.received_telegrams.append(event.telegram)
+
+        # Only process valid reply telegrams
+        if not event.checksum_valid or event.telegram_type != TelegramType.REPLY.value:
+            return
+
+        # Parse telegram using TelegramService
+        try:
+            parsed: ReplyTelegram = self.telegram_service.parse_reply_telegram(
+                event.frame
+            )
+        except Exception as e:
+            self.logger.debug(f"Failed to parse telegram: {e}")
+            return
+
+        # Check for discovery response (F01D)
+        if parsed.system_function == SystemFunction.DISCOVERY:
+            self._handle_discovery_response(parsed.serial_number)
+
+        # Check for datapoint response (F02D)
+        elif parsed.system_function == SystemFunction.READ_DATAPOINT:
+            if parsed.datapoint_type and parsed.data_value:
+                self._handle_datapoint_response(
+                    parsed.serial_number, parsed.datapoint_type.value, parsed.data_value
+                )
+
+    def _handle_discovery_response(self, serial_number: str) -> None:
+        """Handle discovery response and query all datapoints.
+
+        Args:
+            serial_number: Serial number of discovered device.
+        """
+        if serial_number in self.discovered_devices:
+            self.logger.debug(f"Ignoring duplicate discovery: {serial_number}")
+            return
+
+        self.logger.debug(f"Device discovered: {serial_number}")
+        self.discovered_devices.append(serial_number)
+        self.device_configs[serial_number] = {"serial_number": serial_number}
+        self.device_datapoints_received[serial_number] = set()
+
+        # Emit progress signal
+        current = len(self.discovered_devices)
+        total = current  # We don't know total until timeout
+        self.on_progress.emit(serial_number, current, total)
+
+        # Send all datapoint queries immediately (protocol handles throttling)
+        self.logger.debug(
+            f"Sending {len(self.DATAPOINT_SEQUENCE)} queries for {serial_number}"
+        )
+        for datapoint in self.DATAPOINT_SEQUENCE:
+            self.conbus_protocol.send_telegram(
+                telegram_type=TelegramType.SYSTEM,
+                serial_number=serial_number,
+                system_function=SystemFunction.READ_DATAPOINT,
+                data_value=datapoint.value,
+            )
+
+    def _handle_datapoint_response(
+        self, serial_number: str, datapoint_code: str, value: str
+    ) -> None:
+        """Handle datapoint response and store value.
+
+        Args:
+            serial_number: Serial number of device.
+            datapoint_code: Datapoint type code.
+            value: Datapoint value.
+        """
+        if serial_number not in self.device_configs:
+            self.logger.warning(
+                f"Received datapoint for unknown device: {serial_number}"
+            )
+            return
+
+        self.logger.debug(f"Datapoint {datapoint_code}={value} for {serial_number}")
+
+        # Store value in device config
+        datapoint = DataPointType.from_code(datapoint_code)
+        if datapoint:
+            self._store_datapoint_value(serial_number, datapoint, value)
+            self.device_datapoints_received[serial_number].add(datapoint_code)
+            self._check_device_complete(serial_number)
+        else:
+            self.logger.warning(f"Unknown datapoint code: {datapoint_code}")
+
+    def _store_datapoint_value(
+        self, serial_number: str, datapoint: DataPointType, value: str
+    ) -> None:
+        """Store datapoint value in device config.
+
+        Args:
+            serial_number: Serial number of device.
+            datapoint: Datapoint type.
+            value: Datapoint value.
+        """
+        config = self.device_configs[serial_number]
+
+        if datapoint == DataPointType.MODULE_TYPE:
+            config["module_type"] = value
+        elif datapoint == DataPointType.MODULE_TYPE_CODE:
+            try:
+                config["module_type_code"] = int(value)
+            except ValueError:
+                self.logger.warning(f"Invalid module_type_code: {value}")
+        elif datapoint == DataPointType.LINK_NUMBER:
+            try:
+                config["link_number"] = int(value)
+            except ValueError:
+                self.logger.warning(f"Invalid link_number: {value}")
+        elif datapoint == DataPointType.MODULE_NUMBER:
+            try:
+                config["module_number"] = int(value)
+            except ValueError:
+                self.logger.warning(f"Invalid module_number: {value}")
+        elif datapoint == DataPointType.SW_VERSION:
+            config["sw_version"] = value
+        elif datapoint == DataPointType.HW_VERSION:
+            config["hw_version"] = value
+        elif datapoint == DataPointType.AUTO_REPORT_STATUS:
+            config["auto_report_status"] = value
+
+    def _check_device_complete(self, serial_number: str) -> None:
+        """Check if device has all datapoints and emit completion signal.
+
+        Args:
+            serial_number: Serial number of device.
+        """
+        received = self.device_datapoints_received[serial_number]
+        expected = {dp.value for dp in self.DATAPOINT_SEQUENCE}
+
+        if received == expected:
+            self.logger.debug(f"Device {serial_number} complete (7/7 datapoints)")
+            config = self.device_configs[serial_number]
+
+            # Build ConsonModuleConfig with name based on link_number
+            try:
+                # Add required 'name' field as A{link_number}
+                if "name" not in config:
+                    link_number = config.get("link_number", 0)
+                    config["name"] = f"A{link_number}"
+                module_config = ConsonModuleConfig(**config)
+                self.on_device_exported.emit(module_config)
+            except Exception as e:
+                self.logger.error(f"Failed to build config for {serial_number}: {e}")
+
+            # Check if all devices complete
+            if all(
+                len(self.device_datapoints_received[sn]) == len(self.DATAPOINT_SEQUENCE)
+                for sn in self.discovered_devices
+            ):
+                self.logger.debug("All devices complete")
+                self._finalize_export()
+
+    def _finalize_export(self) -> None:
+        """Finalize export and write file."""
+        # Only finalize once
+        if self._finalized:
+            return
+
+        self._finalized = True
+        self.logger.info("Finalizing export")
+
+        if not self.discovered_devices:
+            self.export_status = "FAILED_NO_DEVICES"
+            self.export_result.success = False
+            self.export_result.error = "No devices found"
+            self.export_result.export_status = self.export_status
+            self.on_finish.emit(self.export_result)
+            return
+
+        # Build module list (including partial devices)
+        modules = []
+        for serial_number in self.discovered_devices:
+            config = self.device_configs[serial_number].copy()
+            try:
+                # Add required 'name' field as A{link_number} if not present
+                if "name" not in config:
+                    link_number = config.get("link_number", 0)
+                    config["name"] = f"A{link_number}"
+                # Only include fields that were received
+                module_config = ConsonModuleConfig(**config)
+                modules.append(module_config)
+            except Exception as e:
+                self.logger.warning(f"Partial device {serial_number}: {e}")
+
+        # Sort modules by link_number
+        modules.sort(key=lambda m: m.link_number if m.link_number is not None else 999)
+
+        # Create ConsonModuleListConfig
+        try:
+            module_list = ConsonModuleListConfig(root=modules)
+            self.export_result.config = module_list
+            self.export_result.device_count = len(modules)
+
+            # Write to file
+            self._write_export_file("export.yml")
+
+            self.export_result.success = True
+            self.export_result.export_status = self.export_status
+            self.on_finish.emit(self.export_result)
+
+        except Exception as e:
+            self.logger.error(f"Failed to create export: {e}")
+            self.export_status = "FAILED_WRITE"
+            self.export_result.success = False
+            self.export_result.error = str(e)
+            self.export_result.export_status = self.export_status
+            self.on_finish.emit(self.export_result)
+
+    def _write_export_file(self, path: str) -> None:
+        """Write export to YAML file.
+
+        Args:
+            path: Output file path.
+
+        Raises:
+            Exception: If file write fails.
+        """
+        try:
+            output_path = Path(path)
+
+            if self.export_result.config:
+                # Use Pydantic's model_dump to serialize, excluding only internal fields
+                data = self.export_result.config.model_dump(
+                    exclude={
+                        "root": {
+                            "__all__": {
+                                "enabled",
+                                "conbus_ip",
+                                "conbus_port",
+                                "action_table",
+                            }
+                        }
+                    },
+                    exclude_none=True,
+                )
+
+                # Export as list at root level (not wrapped in 'root:' key)
+                modules_list = data.get("root", [])
+
+                with output_path.open("w") as f:
+                    # Dump each module separately with blank lines between them
+                    for i, module in enumerate(modules_list):
+                        # Add blank line before each module except the first
+                        if i > 0:
+                            f.write("\n")
+
+                        # Dump single item as list element
+                        yaml_str = yaml.safe_dump(
+                            [module],
+                            default_flow_style=False,
+                            sort_keys=False,
+                            allow_unicode=True,
+                        )
+                        # Remove the trailing newline and write
+                        f.write(yaml_str.rstrip("\n") + "\n")
+
+            self.logger.info(f"Export written to {path}")
+            self.export_result.output_file = path
+
+        except Exception as e:
+            self.logger.error(f"Failed to write export file: {e}")
+            self.export_status = "FAILED_WRITE"
+            raise
+
+    def timeout(self) -> None:
+        """Handle timeout event."""
+        timeout = self.conbus_protocol.timeout_seconds
+        self.logger.info(f"Export timeout after {timeout}s")
+
+        # Check if any devices incomplete
+        incomplete = [
+            sn
+            for sn in self.discovered_devices
+            if len(self.device_datapoints_received[sn]) < len(self.DATAPOINT_SEQUENCE)
+        ]
+
+        if incomplete:
+            self.logger.warning(f"Partial export: {len(incomplete)} incomplete devices")
+            self.export_status = "FAILED_TIMEOUT"
+
+        self._finalize_export()
+
+    def failed(self, message: str) -> None:
+        """Handle connection failure event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.error(f"Connection failed: {message}")
+        self.export_status = "FAILED_CONNECTION"
+        self.export_result.success = False
+        self.export_result.error = message
+        self.export_result.export_status = self.export_status
+        self.on_finish.emit(self.export_result)
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Set timeout for export operation.
+
+        Args:
+            timeout_seconds: Timeout in seconds.
+        """
+        self.logger.debug(f"Set timeout: {timeout_seconds}s")
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def set_event_loop(self, event_loop: asyncio.AbstractEventLoop) -> None:
+        """Set event loop for async operations.
+
+        Args:
+            event_loop: Event loop to use.
+        """
+        self.logger.debug("Set event loop")
+        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:
+        """Stop the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "ConbusExportService":
+        """Enter context manager.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for reuse
+        self.discovered_devices = []
+        self.device_configs = {}
+        self.device_datapoints_received = {}
+        self.export_result = ConbusExportResponse(success=False)
+        self.export_status = "OK"
+        self._finalized = False
+        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_progress.disconnect()
+        self.on_device_exported.disconnect()
+        self.on_finish.disconnect()
+        self.stop_reactor()

xp/services/server/client_buffer_manager.py

@@ -0,0 +1,69 @@
+"""Client buffer manager for broadcasting telegrams to connected clients.
+
+This module provides thread-safe management of per-client telegram queues,
+enabling broadcast of telegrams from device services to all connected clients.
+"""
+
+import queue
+import socket
+import threading
+from typing import Dict, Optional
+
+
+class ClientBufferManager:
+    """
+    Thread-safe manager for client telegram queues.
+
+    Manages individual queues for each connected client, providing thread-safe
+    operations for client registration, unregistration, and telegram broadcasting.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the client buffer manager."""
+        self._buffers: Dict[socket.socket, queue.Queue[str]] = {}
+        self._lock = threading.Lock()
+
+    def register_client(self, client_socket: socket.socket) -> queue.Queue[str]:
+        """Register a new client and create its telegram queue.
+
+        Args:
+            client_socket: The socket of the connecting client.
+
+        Returns:
+            The newly created queue for this client.
+        """
+        with self._lock:
+            client_queue: queue.Queue[str] = queue.Queue()
+            self._buffers[client_socket] = client_queue
+            return client_queue
+
+    def unregister_client(self, client_socket: socket.socket) -> None:
+        """Unregister a client and remove its telegram queue.
+
+        Args:
+            client_socket: The socket of the disconnecting client.
+        """
+        with self._lock:
+            self._buffers.pop(client_socket, None)
+
+    def broadcast(self, telegram: str) -> None:
+        """Broadcast a telegram to all connected clients.
+
+        Args:
+            telegram: The telegram string to broadcast.
+        """
+        with self._lock:
+            for client_queue in self._buffers.values():
+                client_queue.put(telegram)
+
+    def get_queue(self, client_socket: socket.socket) -> Optional[queue.Queue[str]]:
+        """Retrieve the queue for a specific client.
+
+        Args:
+            client_socket: The socket of the client.
+
+        Returns:
+            The client's queue if registered, None otherwise.
+        """
+        with self._lock:
+            return self._buffers.get(client_socket)

xp/services/server/server_service.py

@@ -5,6 +5,7 @@ Discover Request telegrams with configurable device information.
 """
 
 import logging
+import queue
 import socket
 import threading
 from pathlib import Path
@@ -15,6 +16,7 @@ from xp.models.homekit.homekit_conson_config import (
     ConsonModuleListConfig,
 )
 from xp.services.server.base_server_service import BaseServerService
+from xp.services.server.client_buffer_manager import ClientBufferManager
 from xp.services.server.device_service_factory import DeviceServiceFactory
 from xp.services.telegram.telegram_discover_service import TelegramDiscoverService
 from xp.services.telegram.telegram_service import TelegramService
@@ -68,7 +70,7 @@ class ServerService:
             None  # Background thread for storm
         )
         self.collector_stop_event = threading.Event()  # Event to stop thread
-        self.collector_buffer: list[str] = []  # All collected buffers
+        self.client_buffers = ClientBufferManager()  # Per-client queue manager
 
         # Set up logging
         self.logger = logging.getLogger(__name__)
@@ -191,6 +193,9 @@ class ServerService:
         self, client_socket: socket.socket, client_address: tuple[str, int]
     ) -> None:
         """Handle individual client connection."""
+        # Register client and get its dedicated queue
+        client_queue = self.client_buffers.register_client(client_socket)
+
         try:
 
             idle_timeout = 300
@@ -202,11 +207,14 @@ class ServerService:
 
             while True:
 
-                # send waiting buffer
-                for i in range(len(self.collector_buffer)):
-                    buffer = self.collector_buffer.pop()
-                    client_socket.send(buffer.encode("latin-1"))
-                    self.logger.debug(f"Sent buffer to {client_address}")
+                # send waiting buffer from client's dedicated queue
+                while not client_queue.empty():
+                    try:
+                        buffer = client_queue.get_nowait()
+                        client_socket.send(buffer.encode("latin-1"))
+                        self.logger.debug(f"Sent buffer to {client_address}")
+                    except queue.Empty:
+                        break
 
                 # Receive data from client
                 data = None
@@ -230,11 +238,8 @@ class ServerService:
 
                 # Process request (discover or data request)
                 responses = self._process_request(message)
-
-                # Send responses
                 for response in responses:
-                    client_socket.send(response.encode("latin-1"))
-                    self.logger.debug(f"Sent to {client_address}: {response[:-1]}")
+                    self.client_buffers.broadcast(response)
 
         except socket.timeout:
             self.logger.debug(f"Client {client_address} timed out")
@@ -242,6 +247,8 @@ class ServerService:
             self.logger.error(f"Error handling client {client_address}: {e}")
         finally:
             try:
+                # Unregister client before closing socket
+                self.client_buffers.unregister_client(client_socket)
                 client_socket.close()
                 self.logger.info(f"Client {client_address} disconnected")
             except Exception as e:
@@ -330,6 +337,8 @@ class ServerService:
                 self.logger.warning(f"Failed to parse telegram: {telegram}")
                 return responses
 
+            self.client_buffers.broadcast(parsed_telegram.raw_telegram)
+
             # Handle discover requests
             if self.discover_service.is_discover_request(parsed_telegram):
                 for device_service in self.device_services.values():
@@ -421,7 +430,8 @@ class ServerService:
             collected = 0
             for device_service in self.device_services.values():
                 telegram_buffer = device_service.collect_telegram_buffer()
-                self.collector_buffer.extend(telegram_buffer)
+                for telegram in telegram_buffer:
+                    self.client_buffers.broadcast(telegram)
                 collected += len(telegram_buffer)
 
             # Wait a bit before checking again

xp/services/term/state_monitor_service.py

@@ -2,13 +2,14 @@
 
 import logging
 from datetime import datetime
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 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.module_type_code import ModuleTypeCode
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
 from xp.models.term.connection_state import ConnectionState
@@ -78,6 +79,7 @@ class StateMonitorService:
                 name=module_config.name,
                 serial_number=module_config.serial_number,
                 module_type=module_config.module_type,
+                link_number=module_config.link_number,
                 outputs="",  # Empty initially
                 auto_report=auto_report,
                 error_status="OK",
@@ -239,15 +241,24 @@ class StateMonitorService:
     def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
         """Handle telegram received event.
 
-        Parse output states from telegram and update module state.
+        Routes telegrams to appropriate handlers based on type.
+        Processes reply telegrams for datapoint queries and event telegrams for state changes.
 
         Args:
             event: Telegram received event.
         """
-        # Only process reply telegrams
-        if event.telegram_type != TelegramType.REPLY:
-            return
+        # Route based on telegram type
+        if event.telegram_type == TelegramType.REPLY:
+            self._handle_reply_telegram(event)
+        elif event.telegram_type == TelegramType.EVENT:
+            self._handle_event_telegram(event)
+
+    def _handle_reply_telegram(self, event: TelegramReceivedEvent) -> None:
+        """Handle reply telegram for datapoint queries.
 
+        Args:
+            event: Telegram received event.
+        """
         serial_number = event.serial_number
         if not serial_number or serial_number not in self._module_states:
             return
@@ -289,6 +300,95 @@ class StateMonitorService:
             self.on_connection_state_changed.emit(self._connection_state)
             self.on_status_message.emit(f"Protocol error: {failure}")
 
+    def _find_module_by_link(self, link_number: int) -> Optional[ModuleState]:
+        """Find module state by link number.
+
+        Args:
+            link_number: Link number to search for.
+
+        Returns:
+            ModuleState if found, None otherwise.
+        """
+        for module_state in self._module_states.values():
+            if module_state.link_number == link_number:
+                return module_state
+        return None
+
+    def _update_output_bit(
+        self, module_state: ModuleState, output_number: int, output_state: bool
+    ) -> None:
+        """Update a single output bit in module state.
+
+        Args:
+            module_state: Module state to update.
+            output_number: Output number (0-3 for XP24).
+            output_state: True for ON, False for OFF.
+        """
+        # Parse existing outputs string "0 1 0 0" → [0, 1, 0, 0]
+        outputs = module_state.outputs.split() if module_state.outputs else []
+
+        # Ensure we have enough outputs
+        while len(outputs) <= output_number:
+            outputs.append("0")
+
+        # Update the specific output
+        outputs[output_number] = "1" if output_state else "0"
+
+        # Convert back to string format
+        module_state.outputs = " ".join(outputs)
+
+    def _handle_event_telegram(self, event: TelegramReceivedEvent) -> None:
+        """Handle event telegram for output state changes.
+
+        Processes XP24 output event telegrams to update module state in real-time.
+        Output events use input_number field with values 80-83 to represent outputs 0-3.
+
+        Args:
+            event: Telegram received event containing event telegram.
+        """
+        # Parse the event telegram
+        event_telegram = self._telegram_service.parse_event_telegram(event.frame)
+        if not event_telegram:
+            self.logger.debug("Failed to parse event telegram")
+            return
+
+        # Only process XP24 output events
+        if event_telegram.module_type != ModuleTypeCode.XP24.value:
+            self.logger.debug(
+                f"Ignoring event from module type {event_telegram.module_type}"
+            )
+            return
+
+        # Validate output number range (80-83 for XP24 outputs 0-3)
+        if not (80 <= event_telegram.input_number <= 83):
+            self.logger.debug(
+                f"Ignoring input event I{event_telegram.input_number:02d}"
+            )
+            return
+
+        # Find module by link number
+        module_state = self._find_module_by_link(event_telegram.link_number)
+        if not module_state:
+            self.logger.debug(
+                f"Module not found for link number {event_telegram.link_number}"
+            )
+            return
+
+        # Convert input_number to output_number (80→0, 81→1, 82→2, 83→3)
+        output_number = event_telegram.input_number - 80
+        output_state = event_telegram.is_button_press  # M=True, B=False
+
+        # Update output state
+        self._update_output_bit(module_state, output_number, output_state)
+        module_state.last_update = datetime.now()
+
+        # Emit signal for UI update
+        self.on_module_state_changed.emit(module_state)
+        self.logger.debug(
+            f"Updated {module_state.name} output {output_number} to "
+            f"{'ON' if output_state else 'OFF'}"
+        )
+
     def cleanup(self) -> None:
         """Clean up service resources."""
         self._disconnect_signals()

xp/term/widgets/modules_list.py

@@ -3,6 +3,7 @@
 from datetime import datetime
 from typing import Any, List, Optional
 
+from rich.text import Text
 from textual.app import ComposeResult
 from textual.widgets import DataTable, Static
 
@@ -14,7 +15,7 @@ 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.
+    Table displays: name, serial_number, module_type, link_number, outputs, report, status, last_update.
 
     Attributes:
         service: StateMonitorService for module state updates.
@@ -54,11 +55,9 @@ class ModulesListWidget(Static):
         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("link", key="link_number")
             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")
@@ -115,13 +114,17 @@ class ModulesListWidget(Static):
                 row_key, "outputs", self._format_outputs(module_state.outputs)
             )
             self.table.update_cell(
-                row_key, "report", self._format_report(module_state.auto_report)
+                row_key,
+                "report",
+                Text(self._format_report(module_state.auto_report), justify="center"),
             )
             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),
+                Text(
+                    self._format_last_update(module_state.last_update), justify="center"
+                ),
             )
         else:
             # Add new row
@@ -138,12 +141,13 @@ class ModulesListWidget(Static):
 
         row_key = self.table.add_row(
             module_state.name,
+            Text(str(module_state.link_number), justify="right"),
             module_state.serial_number,
             module_state.module_type,
             self._format_outputs(module_state.outputs),
-            self._format_report(module_state.auto_report),
+            Text(self._format_report(module_state.auto_report), justify="center"),
             module_state.error_status,
-            self._format_last_update(module_state.last_update),
+            Text(self._format_last_update(module_state.last_update), justify="center"),
         )
         self._row_keys[module_state.serial_number] = row_key
 
@@ -213,5 +217,8 @@ class ModulesListWidget(Static):
                 self.table.update_cell(
                     row_key,
                     "last_update",
-                    self._format_last_update(module_state.last_update),
+                    Text(
+                        self._format_last_update(module_state.last_update),
+                        justify="center",
+                    ),
                 )

xp/utils/dependencies.py

@@ -47,6 +47,7 @@ from xp.services.conbus.conbus_datapoint_service import (
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
 from xp.services.conbus.conbus_event_list_service import ConbusEventListService
 from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
+from xp.services.conbus.conbus_export_service import ConbusExportService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
 from xp.services.conbus.conbus_receive_service import ConbusReceiveService
@@ -201,6 +202,14 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            ConbusExportService,
+            factory=lambda: ConbusExportService(
+                conbus_protocol=self.container.resolve(ConbusEventProtocol)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         # Terminal UI
         self.container.register(
             ProtocolMonitorService,