lcm-cli 0.1.0__py3-none-any.whl

lcm_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,254 @@
+Metadata-Version: 2.4
+Name: lcm-cli
+Version: 0.1.0
+Summary: ROS2-like command line tools for LCM (Lightweight Communications and Marshalling)
+Project-URL: Homepage, https://github.com/lcm-tools/lcm-tools
+Project-URL: Repository, https://github.com/lcm-tools/lcm-tools
+Project-URL: Issues, https://github.com/lcm-tools/lcm-tools/issues
+Author: lcm-tools contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,debugging,lcm,middleware,multicast,robotics,ros2
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: decode
+Requires-Dist: lcm>=1.5.0; extra == 'decode'
+Provides-Extra: dev
+Requires-Dist: pytest-timeout>=2.1; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# LCM CLI Tools
+
+**[English](README.md)** | [中文](README_zh.md)
+
+> ROS2-style command line tools for monitoring and debugging LCM (Lightweight Communications and Marshalling) networks.
+
+## Features
+
+```
+lcm topic echo <channel>   — View real-time topic data (like ros2 topic echo)
+lcm topic list             — List active topics/channels (like ros2 topic list)
+lcm topic stats            — Real-time topic stats: rate, bandwidth, msg count (like ros2 topic hz)
+lcm node list              — List discovered publisher nodes (like ros2 node list)
+```
+
+**Highlight**: Built-in pure-Python `.lcm` file parser — no `lcm-gen` or `PYTHONPATH` needed. Just point to your `.lcm` files and messages are decoded automatically.
+
+## Installation
+
+```bash
+# From PyPI
+pip install lcm-tools
+
+# From source (development)
+git clone https://github.com/your-username/lcm-tools.git
+cd lcm-tools
+pip install -e .
+
+# Optional: traditional lcm-gen Python package decode support
+pip install lcm-tools[decode]
+```
+
+**Requirements**: Python >= 3.9, `typer`, `rich` (`lcm` package is optional, only for legacy `--type module.Class` decoding).
+
+## Quick Start
+
+```bash
+# Show all subcommands
+lcm --help
+
+# List active channels (listens for 5 seconds)
+lcm topic list
+
+# View messages on a channel (raw hex format)
+lcm topic echo EXAMPLE
+
+# Receive only 10 messages
+lcm topic echo EXAMPLE -n 10
+
+# Match multiple channels with regex
+lcm topic echo "CAM.*"
+
+# Monitor real-time statistics for all channels
+lcm topic stats
+
+# Monitor a specific channel only
+lcm topic stats CAMERA
+
+# List discovered publisher nodes
+lcm node list
+```
+
+## Message Decoding
+
+### Method 1: Specify `.lcm` files directly (recommended)
+
+No `lcm-gen` installation, no `PYTHONPATH` configuration. The tool includes a built-in pure-Python parser:
+
+```bash
+# Specify a single .lcm file — auto-matches message type by fingerprint
+lcm topic echo EXAMPLE --lcm-file types/example_t.lcm
+
+# Specify a directory (recursively scans all .lcm files)
+lcm topic echo EXAMPLE -f types/
+
+# Specify multiple paths
+lcm topic echo EXAMPLE -f types/ -f extra_types/
+
+# Specify a concrete type name (when .lcm files contain multiple structs)
+lcm topic echo EXAMPLE -f types/ --type example_t
+```
+
+Supports the complete LCM type system:
+- All primitive types (`int8_t` ~ `int64_t`, `float`, `double`, `string`, `boolean`, `byte`)
+- Fixed-length and variable-length arrays (`double position[3]`, `int16_t ranges[num_ranges]`)
+- Multi-dimensional arrays (`int32_t data[size_a][size_b][size_c]`)
+- Nested structs and cross-file type references
+- Recursive types (e.g., `node_t children[n]` in a linked-list `node_t`)
+- Constant declarations (`const int32_t MAX_SIZE = 100`)
+
+**How it works**: Parses `.lcm` files → builds decode classes in memory (`type()` dynamic creation) → auto-matches by the first 8-byte fingerprint of the payload → decodes and recursively expands nested structs. No files are generated at any point.
+
+### Method 2: Traditional `lcm-gen` generated files
+
+```bash
+# Install the lcm Python package
+pip install lcm-tools[decode]
+
+# Generate Python files with lcm-gen, then configure PYTHONPATH
+lcm-gen --python -d types/ types/example_t.lcm
+export PYTHONPATH=types:$PYTHONPATH
+
+# Use --type to specify the decode class (module.Class format)
+lcm topic echo EXAMPLE --type exlcm.example_t
+```
+
+### Custom Multicast Address
+
+```bash
+lcm topic list --lcm-url 239.255.76.68 --lcm-port 7668
+```
+
+### Statistics
+
+| Metric | Description |
+|--------|-------------|
+| Rate (Hz) | Message frequency within a sliding window (last 2000 messages) |
+| BW (KB/s) | Bandwidth within the sliding window |
+| Avg Size (B) | Average bytes per message |
+| Total (KB) | Cumulative total transferred |
+
+## Architecture
+
+```
+┌───────────────────────────────────────────────────┐
+│                  CLI Layer (Typer)                │
+│   topic echo │ topic list │ topic stats │ node    │
+├───────────────────────────────────────────────────┤
+│              Display Layer (Rich Panel)           │
+│   recursive nesting │ hex dump │ stats table      │
+├───────────────────────────────────────────────────┤
+│           Type Parsing Layer (Pure Python)        │
+│   .lcm parse → AST → fingerprint → dynamic class  │
+├───────────────────────────────────────────────────┤
+│            Protocol Layer (Raw UDP Socket)        │
+│       LCM Wire Protocol parsing (zero deps)       │
+├───────────────────────────────────────────────────┤
+│            UDP Multicast (239.255.76.67)          │
+└───────────────────────────────────────────────────┘
+```
+
+- **Zero external LCM dependency**: Core functionality directly parses the LCM wire protocol from UDP multicast packets
+- **Built-in type parsing**: Pure-Python `.lcm` file parser + runtime decode class generator
+- **Node discovery**: Infers different publishers from UDP packet source IP:port
+- **Legacy decode compatible**: Optional `lcm` Python package for `--type module.Class` decoding
+
+## LCM Protocol
+
+LCM uses UDP multicast for communication (default `239.255.76.67:7667`).
+
+**Short messages** (< 64KB): 8-byte header (magic=0x4c433032 + seqno) + channel name (null-terminated) + payload
+
+**Fragmented messages**: 20-byte header (magic=0x4c433033 + seqno + payload_size + fragment_offset + fragment_no + n_fragments)
+
+Reference: [LCM UDP Multicast Protocol](https://lcm-proj.github.io/lcm/content/udp-multicast-protocol.html)
+
+## LCM vs ROS2 Concepts
+
+| LCM Concept | ROS2 Equivalent | Description |
+|-------------|----------------|-------------|
+| Channel | Topic | Message publish/subscribe conduit |
+| UDP (IP:port) | Node | LCM has no native node concept; inferred from publisher address |
+| Fingerprint | Message Type Hash | Unique identifier for a message type |
+
+## Project Structure
+
+```
+src/lcm_tools/
+├── cli.py                       # Typer entry point, registers subcommands
+├── commands/
+│   ├── topic_echo.py            # lcm topic echo
+│   ├── topic_list.py            # lcm topic list
+│   ├── topic_stats.py           # lcm topic stats
+│   └── node_list.py             # lcm node list
+├── core/
+│   ├── discovery.py             # Passive channel/node discovery
+│   ├── stats.py                 # Real-time statistics (rate, bandwidth)
+│   ├── lcm_type_parser.py       # .lcm file parser + fingerprint algorithm
+│   └── lcm_type_builder.py      # Runtime decode class generation + TypeRegistry
+├── display/
+│   ├── echo_display.py          # Rich panel display (with recursive nesting)
+│   └── stats_display.py         # Statistics table display
+├── listener.py                  # UDP multicast listener thread
+└── protocol.py                  # LCM Wire Protocol parser
+```
+
+## Testing
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -v
+```
+
+## Network Configuration
+
+If you can't receive messages, check your multicast routing:
+
+**macOS:**
+```bash
+# View multicast routes
+netstat -rn | grep 239
+
+# Add route if needed
+sudo route add -net 239.255.76.0/24 -interface en0
+```
+
+**Linux:**
+```bash
+# Add route
+sudo ip route add 239.255.76.0/24 dev eth0
+```
+
+## License
+
+MIT

lcm_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+lcm_tools/__init__.py,sha256=MJTza6au1FnWncO_lPNRfJUkY4zLBxoD0gr0PEqh4y4,94
+lcm_tools/__main__.py,sha256=rL0qCqIX2Z8dOUd11dtX7zP-z_RWpbMQQUvLuI_1kcY,125
+lcm_tools/cli.py,sha256=3Y-fYc1pTyXEF6dBodxE4-GV78qwxVed5KDnT51Pe2U,1860
+lcm_tools/listener.py,sha256=t7jKX2VNQL5XKcHrJ6EqFqGr2wwIXFjX_j0GUx8uQuE,4710
+lcm_tools/protocol.py,sha256=ULXe0e5UchGV6uLJCIIuLmu76pPPj1AAmP5TCswMMaM,4833
+lcm_tools/commands/__init__.py,sha256=OKM15hJi770MsQWgSzoHam09SmQlma-q5e5-hZsnzDc,32
+lcm_tools/commands/node_list.py,sha256=A8Oi9VwbDUxRENx_f0wBE_9N-AAD-T6AudBVO97hlvc,2362
+lcm_tools/commands/topic_echo.py,sha256=Xxi4e9uCOad6zBFSqB--sr_PxvMg13cWPzBdEHbWRPU,5822
+lcm_tools/commands/topic_list.py,sha256=AZzSRPjSAkyA8xSRfMBM4QEDhknnLqOJ-7-7WkiS9fk,1922
+lcm_tools/commands/topic_stats.py,sha256=6sFzzT_R5OjvKTDfJVEIe0ZdUQbXiFK04ocf2TmxUo4,2430
+lcm_tools/core/__init__.py,sha256=SSWlrq864vGN21KxHwIffre1Fa7jEoN-tCJfV0C7syI,32
+lcm_tools/core/discovery.py,sha256=lxTOuAoZCHeV0TKXQTtw2y8yElJGyotPdiK70RVwXQg,4537
+lcm_tools/core/lcm_type_builder.py,sha256=TXs-NV-8_CKSPpIeHT8ZRwBk4c6yu7Fngay29EyNmNw,19811
+lcm_tools/core/lcm_type_parser.py,sha256=xGlObzmrLoD00dbnoJe5BSIMWZgHbKfQYZaEgNAHVKI,16924
+lcm_tools/core/stats.py,sha256=2xxXhIEqR-omfRvQWU05FsFl8HC22HOK5p67U5oHel0,5622
+lcm_tools/display/__init__.py,sha256=eAGGFoWZ9yeriISW8mu8ocAB5hfS00-MNPwNVo7QxZQ,35
+lcm_tools/display/echo_display.py,sha256=8muEjvXcyGuetrm71-TX6ReY5fEBm3oHn1fj8SejtDQ,7823
+lcm_tools/display/stats_display.py,sha256=Km142prR5qO6ZhOBs43lf4VPN8P0obhFQaVfryZRSb4,3307
+lcm_cli-0.1.0.dist-info/METADATA,sha256=0LzvX5XC-WBlmYNmSC8Qxq1foERSGgkTxo2BPS6J_50,9490
+lcm_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+lcm_cli-0.1.0.dist-info/entry_points.txt,sha256=r3ZNR7GWTY7gm7zd4kUlyQvz3rwAyZgcowufTWbnglQ,42
+lcm_cli-0.1.0.dist-info/licenses/LICENSE,sha256=fzMYOaWB2zTO3LgLDAcKCA_ATJE8qGROhvCSUOXShsw,1079
+lcm_cli-0.1.0.dist-info/RECORD,,

lcm_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

lcm_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lcm = lcm_tools.cli:app

lcm_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 lcm-tools contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lcm_tools/__init__.py

@@ -0,0 +1,3 @@
+"""LCM CLI tools - ROS2-like command line tools for LCM middleware."""
+
+__version__ = "0.1.0"

lcm_tools/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running lcm_tools as `python -m lcm_tools`."""
+
+from lcm_tools.cli import app
+
+if __name__ == "__main__":
+    app()

lcm_tools/cli.py

@@ -0,0 +1,52 @@
+"""LCM CLI - ROS2-like command line tools for LCM middleware.
+
+Provides the ``lcm`` command with subcommands:
+  lcm topic echo <channel>   — View real-time topic data
+  lcm topic list             — List active topics (channels)
+  lcm topic stats            — Monitor topic statistics
+  lcm node list              — List discovered publisher nodes
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from lcm_tools.commands.node_list import node_app
+from lcm_tools.commands.topic_echo import echo
+from lcm_tools.commands.topic_list import list_channels
+from lcm_tools.commands.topic_stats import stats
+
+# ---------------------------------------------------------------------------
+# Root application
+# ---------------------------------------------------------------------------
+app = typer.Typer(
+    name="lcm",
+    help="LCM command line tools — inspect and monitor LCM networks.\n\n"
+    "Similar to ROS2 CLI tools (ros2 topic echo, ros2 node list, etc.) "
+    "but for LCM (Lightweight Communications and Marshalling).",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+# ---------------------------------------------------------------------------
+# Topic subcommand group
+# ---------------------------------------------------------------------------
+topic_app = typer.Typer(
+    help="Inspect and monitor LCM topics (channels).",
+    no_args_is_help=True,
+)
+app.add_typer(topic_app, name="topic")
+
+# Register topic subcommands
+topic_app.command(name="echo", help="Echo messages on a channel.")(echo)
+topic_app.command(name="list", help="List active channels.")(list_channels)
+topic_app.command(name="stats", help="Show real-time channel statistics.")(stats)
+
+# Node subcommand group is imported as a Typer app and attached directly
+app.add_typer(node_app, name="node")
+
+
+if __name__ == "__main__":
+    app()

lcm_tools/commands/__init__.py

@@ -0,0 +1 @@
+"""LCM CLI commands package."""

lcm_tools/commands/node_list.py

@@ -0,0 +1,82 @@
+"""``lcm node list`` — discover and list publisher nodes.
+
+LCM has no native "node name" concept (unlike ROS2).  This command
+identifies publisher processes by their UDP source address (IP:port),
+grouped with the set of channels each has published to.
+
+This is a best-effort inference based on the multicast traffic that
+reaches this host within a configurable listening window.
+"""
+
+from __future__ import annotations
+
+import time
+
+import typer
+from rich.console import Console
+
+from lcm_tools.core.discovery import ChannelDiscovery
+from lcm_tools.display.stats_display import build_node_table
+from lcm_tools.listener import run_listener
+from lcm_tools.protocol import DEFAULT_MC_ADDR, DEFAULT_MC_PORT
+
+_console = Console()
+
+# Typer sub-app for `lcm node`
+node_app = typer.Typer(
+    help="Inspect LCM publisher nodes (inferred from UDP source address).",
+    no_args_is_help=True,
+)
+
+
+@node_app.command(name="list")
+def list_nodes(
+    duration: float = typer.Option(
+        5.0,
+        "--duration",
+        "-d",
+        help="How many seconds to listen for node activity.",
+    ),
+    lcm_url: str = typer.Option(
+        DEFAULT_MC_ADDR,
+        "--lcm-url",
+        help="LCM multicast address.",
+    ),
+    lcm_port: int = typer.Option(
+        DEFAULT_MC_PORT,
+        "--lcm-port",
+        help="LCM multicast port.",
+    ),
+) -> None:
+    """List discovered publisher nodes (like ``ros2 node list``).
+
+    Note: LCM does not have a native "node name" concept.  Nodes are
+    identified here by their UDP source IP:port, which corresponds to
+    the publisher's network interface.
+    """
+    discovery = ChannelDiscovery()
+
+    _console.print(
+        f"[bold]Discovering nodes for {duration}s ...[/bold]  "
+        f"(multicast: {lcm_url}:{lcm_port})"
+    )
+
+    stop_event = run_listener(discovery.on_packet, mc_addr=lcm_url, mc_port=lcm_port)
+
+    try:
+        time.sleep(duration)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        stop_event.set()
+
+    nodes = discovery.get_nodes(stale_after=duration + 2.0)
+    if not nodes:
+        _console.print("[yellow]No publisher nodes found.[/yellow]")
+        _console.print(
+            "[dim]Hint: make sure a publisher is running and your "
+            "multicast routing is configured.[/dim]"
+        )
+        raise typer.Exit(code=0)
+
+    _console.print(build_node_table(nodes))

lcm_tools/commands/topic_echo.py

@@ -0,0 +1,188 @@
+"""``lcm topic echo`` — echo messages received on a channel.
+
+Listens on the LCM multicast group and prints every message matching
+the given channel name (or pattern).
+
+Supports four display modes:
+- **default**: Rich panel with hex dump and metadata
+- **--raw**: compact one-line-per-message text
+- **--type module.Class**: decode payload with an lcm-gen generated class
+- **--lcm-file path.lcm**: auto-decode from .lcm file definitions
+"""
+
+from __future__ import annotations
+
+import queue
+import re
+import signal
+import sys
+import threading
+from typing import Any, List, Optional
+
+import typer
+from rich.console import Console
+
+from lcm_tools.display.echo_display import (
+    echo_packet_auto_decode,
+    echo_packet_decoded,
+    echo_packet_default,
+    echo_packet_raw,
+    load_decode_class,
+)
+from lcm_tools.listener import run_listener
+from lcm_tools.protocol import DEFAULT_MC_ADDR, DEFAULT_MC_PORT, PacketInfo
+
+_console = Console()
+
+
+def echo(
+    channel: str = typer.Argument(
+        ...,
+        help="Channel name to listen on. Use a regex pattern to match "
+        "multiple channels (e.g. 'CAM.*').",
+    ),
+    count: Optional[int] = typer.Option(
+        None,
+        "--count",
+        "-n",
+        help="Stop after receiving this many messages.",
+    ),
+    timeout: Optional[float] = typer.Option(
+        None,
+        "--timeout",
+        "-t",
+        help="Stop after this many seconds with no matching messages.",
+    ),
+    raw: bool = typer.Option(
+        False,
+        "--raw",
+        help="Compact raw-text output (suitable for piping).",
+    ),
+    type_path: Optional[str] = typer.Option(
+        None,
+        "--type",
+        help="lcm-gen type for decoding, e.g. 'exlcm.example_t'. "
+        "With --lcm-file, use just the struct name (e.g. 'example_t').",
+    ),
+    lcm_files: Optional[List[str]] = typer.Option(
+        None,
+        "--lcm-file",
+        "-f",
+        help="Path to .lcm file or directory containing .lcm files. "
+        "Can be specified multiple times. Enables auto-decode without lcm-gen.",
+    ),
+    lcm_url: str = typer.Option(
+        DEFAULT_MC_ADDR,
+        "--lcm-url",
+        help="LCM multicast address.",
+    ),
+    lcm_port: int = typer.Option(
+        DEFAULT_MC_PORT,
+        "--lcm-port",
+        help="LCM multicast port.",
+    ),
+) -> None:
+    """Echo messages on an LCM channel (like ``ros2 topic echo``)."""
+    # Compile channel filter
+    try:
+        pattern = re.compile(channel)
+    except re.error as exc:
+        _console.print(f"[red]Invalid regex pattern:[/red] {exc}")
+        raise typer.Exit(code=1)
+
+    # Build TypeRegistry from --lcm-file if provided
+    type_registry: Any = None
+    if lcm_files:
+        try:
+            from lcm_tools.core.lcm_type_builder import TypeRegistry
+
+            type_registry = TypeRegistry()
+            type_registry.register_paths(lcm_files)
+            n_types = len(type_registry.all_types)
+            _console.print(
+                f"[green]Loaded {n_types} type(s) from "
+                f"{len(lcm_files)} LCM file path(s).[/green]"
+            )
+        except Exception as exc:
+            _console.print(f"[red]Failed to load LCM files:[/red] {exc}")
+            raise typer.Exit(code=1)
+
+    # Resolve decode class
+    decode_cls: Any = None
+    if type_path:
+        if type_registry is not None:
+            # Look up from registry (--lcm-file + --type)
+            decode_cls = type_registry.find_by_name(type_path)
+            if decode_cls is None:
+                available = ", ".join(sorted(type_registry.all_types.keys()))
+                _console.print(
+                    f"[red]Type '{type_path}' not found in LCM files.[/red]\n"
+                    f"Available: {available}"
+                )
+                raise typer.Exit(code=1)
+        else:
+            # Traditional: import from PYTHONPATH
+            try:
+                decode_cls = load_decode_class(type_path)
+            except Exception as exc:
+                _console.print(f"[red]Failed to load type '{type_path}':[/red] {exc}")
+                raise typer.Exit(code=1)
+
+    # Thread-safe queue bridging the listener thread → main display thread
+    pkt_queue: "queue.Queue[Optional[PacketInfo]]" = queue.Queue(maxsize=5000)
+
+    def _on_packet(pkt: PacketInfo) -> None:
+        if pkt.has_channel and pattern.search(pkt.channel):  # type: ignore[arg-type]
+            try:
+                pkt_queue.put_nowait(pkt)
+            except queue.Full:
+                pass  # drop oldest if producer outpaces display
+
+    stop_event = run_listener(
+        _on_packet,
+        mc_addr=lcm_url,
+        mc_port=lcm_port,
+    )
+
+    _console.print(
+        f"[bold]Listening on '{channel}' ...[/bold]  "
+        f"(multicast: {lcm_url}:{lcm_port}, Ctrl+C to stop)"
+    )
+
+    received = 0
+    import time
+
+    last_match_time = time.monotonic()
+
+    try:
+        while True:
+            try:
+                pkt = pkt_queue.get(timeout=0.3)
+            except queue.Empty:
+                if timeout and (time.monotonic() - last_match_time) >= timeout:
+                    break
+                continue
+
+            if pkt is None:
+                break
+
+            received += 1
+            last_match_time = time.monotonic()
+
+            if raw:
+                echo_packet_raw(pkt, received)
+            elif decode_cls:
+                echo_packet_decoded(pkt, received, decode_cls)
+            elif type_registry is not None:
+                echo_packet_auto_decode(pkt, received, type_registry)
+            else:
+                echo_packet_default(pkt, received)
+
+            if count and received >= count:
+                break
+
+    except KeyboardInterrupt:
+        pass
+    finally:
+        stop_event.set()
+        _console.print(f"\n[dim]Received {received} message(s).[/dim]")