h3cx
9407bfeb79
All internal and public errors have been revised (GPT 5.6 Sol) to return more detail without horrendously long error classes, this has reduced the number of error types but each now carries a reason and a code for differentiation if needed PlaybackEngine has been implemented and is functional, core mode changes what signal descriptors are returned to avoid duplicates, the playback engine currently discards the derived signals that would be recorded in the DLPak and derived signals are reprocessed live Future will require the behavior listed above to be selectable so one of two options are possible: A - Derived signals are reprocessed live by the relevant derive units (current behavior B - Derived signals are played back directly from the PlaybackEngine, this requires turning off the routing to the live derive units to avoid duplicate values This will also require the option to perform offline processing with derive units to be able to create derived signals after the fact, this will likely incur a new 'offline' mode in the core to gate things correctly, this will likely be useful for heavier processing that cannot be done live, filters that require a lookahead, or more precise derived signals using interpolated signals for higher acurracy which also brings the ability to offline process on a fixed timebase instead of following either input signal to the derived signal
252 lines
7.9 KiB
Python
252 lines
7.9 KiB
Python
import logging
|
|
import select
|
|
import sys
|
|
import termios
|
|
import time
|
|
import tty
|
|
from contextlib import contextmanager
|
|
from pathlib import Path
|
|
from typing import Iterator
|
|
from uuid import UUID, uuid4
|
|
|
|
from rich.console import Group
|
|
from rich.live import Live
|
|
from rich.panel import Panel
|
|
from rich.table import Table
|
|
from rich.text import Text
|
|
|
|
from dynalab_core import Core
|
|
from dynalab_core.config import CoreConfig
|
|
from dynalab_core.errors import DynaLabError
|
|
from dynalab_core.protocols.packets.handshake import SignalDescriptor
|
|
|
|
|
|
HOST = "127.0.0.1"
|
|
PORT = 8765
|
|
DISPLAY_FREQUENCY_HZ = 5.0
|
|
|
|
signal_id_1: UUID = UUID("3f32cea3-d872-4c16-a0a2-54b57171aeb2")
|
|
signal_id_2: UUID = UUID("6578ac37-99d1-410c-b3f7-d049339919b2")
|
|
|
|
|
|
@contextmanager
|
|
def keyboard_input() -> Iterator[None]:
|
|
"""Read individual keys and restore the terminal settings on exit."""
|
|
if not sys.stdin.isatty():
|
|
raise RuntimeError("This example must be run in an interactive terminal")
|
|
|
|
file_descriptor = sys.stdin.fileno()
|
|
previous_settings = termios.tcgetattr(file_descriptor)
|
|
tty.setcbreak(file_descriptor)
|
|
|
|
try:
|
|
yield
|
|
finally:
|
|
termios.tcsetattr(file_descriptor, termios.TCSADRAIN, previous_settings)
|
|
|
|
|
|
class Dashboard:
|
|
def __init__(self, core: Core, config: CoreConfig) -> None:
|
|
self.core = core
|
|
self.config = config
|
|
self.running = True
|
|
self.playback_loaded = False
|
|
self.message = "Waiting for a connector"
|
|
self.message_style = "dim"
|
|
|
|
def handle_key(self, key: str) -> None:
|
|
try:
|
|
if key.lower() == "q":
|
|
self.running = False
|
|
elif key.lower() == "r":
|
|
self.toggle_recording()
|
|
elif key.lower() == "m":
|
|
self.toggle_mode()
|
|
elif key.lower() == "l":
|
|
self.load_playback()
|
|
elif key == " ":
|
|
self.toggle_playback()
|
|
except DynaLabError as error:
|
|
self.set_message(str(error), "bold red")
|
|
|
|
def toggle_recording(self) -> None:
|
|
if self.core.get_mode() != "realtime":
|
|
self.set_message("Recording is only available in realtime mode", "yellow")
|
|
return
|
|
|
|
if self.core.get_recording_state():
|
|
self.core.stop_recording()
|
|
self.set_message("Recording stopped and prepared for playback", "green")
|
|
else:
|
|
self.core.start_recording()
|
|
self.set_message("Recording started", "bold red")
|
|
|
|
def toggle_mode(self) -> None:
|
|
if self.core.get_recording_state():
|
|
self.set_message("Stop recording before changing mode", "yellow")
|
|
return
|
|
|
|
if self.core.get_mode() == "realtime":
|
|
self.core.set_mode("playback")
|
|
self.set_message(
|
|
"Playback mode selected; press L to load a recording", "green"
|
|
)
|
|
else:
|
|
if self.core.get_playback_state():
|
|
self.core.pause()
|
|
self.core.set_mode("realtime")
|
|
self.set_message("Realtime mode selected", "green")
|
|
|
|
def load_playback(self) -> None:
|
|
if self.core.get_mode() != "playback":
|
|
self.set_message("Switch to playback mode before loading", "yellow")
|
|
return
|
|
|
|
self.core.load_playback_engine()
|
|
self.playback_loaded = True
|
|
self.set_message("Internal processing buffer loaded", "green")
|
|
|
|
def toggle_playback(self) -> None:
|
|
if self.core.get_mode() != "playback":
|
|
self.set_message("Switch to playback mode before pressing Space", "yellow")
|
|
return
|
|
|
|
if self.core.get_playback_state():
|
|
self.core.pause()
|
|
self.set_message("Playback paused", "yellow")
|
|
else:
|
|
self.core.play()
|
|
self.set_message("Playback started", "green")
|
|
|
|
def set_message(self, message: str, style: str) -> None:
|
|
self.message = message
|
|
self.message_style = style
|
|
|
|
def render(self) -> Group:
|
|
mode = self.core.get_mode()
|
|
recording = self.core.get_recording_state()
|
|
playing = self.core.get_playback_state()
|
|
|
|
status = Table.grid(expand=True)
|
|
status.add_column(ratio=1)
|
|
status.add_column(ratio=1)
|
|
status.add_column(ratio=1)
|
|
status.add_row(
|
|
Text(f"Mode: {mode.title()}", style="bold cyan"),
|
|
Text(
|
|
"Recording: ON" if recording else "Recording: OFF",
|
|
style="bold red" if recording else "dim",
|
|
),
|
|
Text(
|
|
self.playback_status(playing),
|
|
style="bold green" if playing else "dim",
|
|
),
|
|
)
|
|
|
|
values = self.core.get_all_live_values()
|
|
descriptors = sorted(
|
|
self.core.get_all_signal_descriptors(), key=lambda signal: signal.name
|
|
)
|
|
value_table = Table(expand=True, show_lines=False)
|
|
value_table.add_column("Signal", style="cyan", ratio=2)
|
|
value_table.add_column("Origin", style="dim", ratio=1)
|
|
value_table.add_column("Value", justify="right", ratio=1)
|
|
value_table.add_column("Unit", style="dim", ratio=1)
|
|
|
|
if descriptors:
|
|
for descriptor in descriptors:
|
|
value = values.get(descriptor.id)
|
|
value_table.add_row(
|
|
descriptor.name,
|
|
descriptor.origin,
|
|
f"{value: .5f}" if value is not None else "—",
|
|
descriptor.unit or "",
|
|
)
|
|
else:
|
|
value_table.add_row("Waiting for connector…", "", "—", "")
|
|
|
|
controls = Text.from_markup(
|
|
"[bold]R[/bold] Record [bold]M[/bold] Mode "
|
|
"[bold]L[/bold] Load [bold]Space[/bold] Play/Pause "
|
|
"[bold]Q[/bold] Quit"
|
|
)
|
|
|
|
return Group(
|
|
Panel(
|
|
status,
|
|
title="DynaLab Core",
|
|
subtitle=f"{self.config.bind_str()} · values refresh at 5 Hz",
|
|
border_style="blue",
|
|
),
|
|
Panel(value_table, title="Live values", border_style="cyan"),
|
|
Panel(Text(self.message, style=self.message_style), title="Status"),
|
|
Panel(controls, title="Hotkeys", border_style="blue"),
|
|
)
|
|
|
|
def playback_status(self, playing: bool) -> str:
|
|
if playing:
|
|
return "Playback: PLAYING"
|
|
if self.playback_loaded:
|
|
return "Playback: LOADED"
|
|
return "Playback: NOT LOADED"
|
|
|
|
|
|
def main() -> None:
|
|
logging.basicConfig(level=logging.CRITICAL)
|
|
config = CoreConfig(host=HOST, port=PORT)
|
|
core = Core(config)
|
|
processing_source = Path(__file__).with_name("process.py").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
dashboard = Dashboard(core, config)
|
|
|
|
core.bind_derive_unit(
|
|
processing_source,
|
|
[
|
|
SignalDescriptor(
|
|
id=signal_id_1,
|
|
name="Dummy signal 1",
|
|
type="number",
|
|
timeout_ms=5000,
|
|
),
|
|
SignalDescriptor(
|
|
id=signal_id_2,
|
|
name="Dummy signal 2",
|
|
type="number",
|
|
timeout_ms=5000,
|
|
),
|
|
],
|
|
SignalDescriptor(
|
|
id=uuid4(),
|
|
name="Dummy product",
|
|
type="number",
|
|
timeout_ms=5000,
|
|
origin="derived",
|
|
),
|
|
)
|
|
|
|
try:
|
|
core.start()
|
|
with keyboard_input(), Live(
|
|
dashboard.render(),
|
|
auto_refresh=False,
|
|
screen=True,
|
|
) as live:
|
|
while dashboard.running:
|
|
update_started = time.monotonic()
|
|
|
|
while select.select([sys.stdin], [], [], 0)[0]:
|
|
dashboard.handle_key(sys.stdin.read(1))
|
|
|
|
live.update(dashboard.render(), refresh=True)
|
|
elapsed = time.monotonic() - update_started
|
|
time.sleep(max(0.0, 1.0 / DISPLAY_FREQUENCY_HZ - elapsed))
|
|
except KeyboardInterrupt:
|
|
pass
|
|
finally:
|
|
core.stop()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|