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
363 lines
9.7 KiB
Python
363 lines
9.7 KiB
Python
import asyncio
|
|
import logging
|
|
import threading
|
|
from concurrent.futures import CancelledError as FutureCancelledError
|
|
from concurrent.futures import TimeoutError as FutureTimeoutError
|
|
from math import sin, tau
|
|
from statistics import mean
|
|
from time import monotonic, monotonic_ns, perf_counter
|
|
from uuid import UUID, uuid4
|
|
|
|
from rich.logging import RichHandler
|
|
|
|
from dynalab_core.protocols.common import VersionDescriptor
|
|
from dynalab_core.protocols.constants import PROTOCOL_VERSION
|
|
from dynalab_core.protocols.json.wire import read_message, write_message
|
|
from dynalab_core.protocols.packets.data import ValueBatch, ValueDescriptor
|
|
from dynalab_core.protocols.packets.handshake import (
|
|
ConnectorHello,
|
|
DynaLabHello,
|
|
SignalDescriptor,
|
|
)
|
|
from dynalab_core.protocols.packets.heartbeat import Heartbeat
|
|
|
|
|
|
HOST = "127.0.0.1"
|
|
PORT = 8765
|
|
|
|
# Set to None to send as quickly as possible.
|
|
# For a controlled rate, use something like 5_000.0.
|
|
TARGET_FREQUENCY_HZ: float | None = 1000
|
|
SINE_FREQUENCY_HZ = 0.5
|
|
|
|
FREQUENCY_SAMPLE_SIZE = 20000
|
|
|
|
CONNECTOR_VERSION = VersionDescriptor(
|
|
type="alpha",
|
|
major=0,
|
|
minor=0,
|
|
patch=1,
|
|
)
|
|
|
|
logging.basicConfig(
|
|
level=logging.DEBUG,
|
|
format="%(name)s %(message)s",
|
|
datefmt="%H:%M:%S",
|
|
handlers=[
|
|
RichHandler(
|
|
rich_tracebacks=True,
|
|
show_path=False,
|
|
)
|
|
],
|
|
force=True,
|
|
)
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
signal_id_1: UUID = UUID("3f32cea3-d872-4c16-a0a2-54b57171aeb2")
|
|
signal_id_2: UUID = UUID("6578ac37-99d1-410c-b3f7-d049339919b2")
|
|
|
|
|
|
def monotonic_ms() -> int:
|
|
return round(monotonic() * 1_000)
|
|
|
|
|
|
async def send_message(
|
|
writer: asyncio.StreamWriter,
|
|
write_lock: asyncio.Lock,
|
|
message: object,
|
|
) -> None:
|
|
"""
|
|
Serialize access to the asyncio StreamWriter.
|
|
|
|
Both heartbeat replies and value messages use this function.
|
|
"""
|
|
async with write_lock:
|
|
await write_message(writer, message)
|
|
|
|
|
|
def value_sender_thread(
|
|
loop: asyncio.AbstractEventLoop,
|
|
writer: asyncio.StreamWriter,
|
|
write_lock: asyncio.Lock,
|
|
stop_event: threading.Event,
|
|
) -> None:
|
|
"""
|
|
Run the high-frequency timing loop in a dedicated OS thread.
|
|
|
|
The asyncio StreamWriter is not thread-safe, so each write is submitted
|
|
back to the asyncio event loop with run_coroutine_threadsafe().
|
|
"""
|
|
intervals: list[float] = []
|
|
previous_send_time: float | None = None
|
|
sine_start_time = perf_counter()
|
|
|
|
if TARGET_FREQUENCY_HZ is not None:
|
|
period = 1.0 / TARGET_FREQUENCY_HZ
|
|
next_send_time = perf_counter()
|
|
else:
|
|
period = None
|
|
next_send_time = 0.0
|
|
|
|
log.debug("Value sender thread started")
|
|
|
|
try:
|
|
while not stop_event.is_set():
|
|
if period is not None:
|
|
while True:
|
|
remaining = next_send_time - perf_counter()
|
|
|
|
if remaining <= 0:
|
|
break
|
|
|
|
# Sleep for larger remaining times, then spin for the
|
|
# final fraction of a millisecond.
|
|
if remaining > 0.001:
|
|
stop_event.wait(remaining - 0.0005)
|
|
|
|
if stop_event.is_set():
|
|
return
|
|
|
|
next_send_time += period
|
|
|
|
sine_value = sin(
|
|
tau * SINE_FREQUENCY_HZ * (perf_counter() - sine_start_time)
|
|
)
|
|
timestamp = monotonic_ns()
|
|
message = ValueBatch(values=[])
|
|
value1 = ValueDescriptor(
|
|
signal_id=signal_id_1,
|
|
value=2.0 * sine_value,
|
|
timestamp=timestamp,
|
|
)
|
|
value2 = ValueDescriptor(
|
|
signal_id=signal_id_2,
|
|
value=sine_value,
|
|
timestamp=timestamp,
|
|
)
|
|
message.values.append(value1)
|
|
message.values.append(value2)
|
|
|
|
future = asyncio.run_coroutine_threadsafe(
|
|
send_message(
|
|
writer,
|
|
write_lock,
|
|
message,
|
|
),
|
|
loop,
|
|
)
|
|
|
|
try:
|
|
# Waiting prevents an ever-growing queue of scheduled writes.
|
|
future.result(timeout=2.0)
|
|
except FutureTimeoutError:
|
|
log.warning("Timed out sending value message")
|
|
future.cancel()
|
|
return
|
|
except FutureCancelledError:
|
|
return
|
|
except Exception:
|
|
log.exception("Value sender failed")
|
|
return
|
|
|
|
current_send_time = perf_counter()
|
|
|
|
if previous_send_time is not None:
|
|
intervals.append(current_send_time - previous_send_time)
|
|
|
|
previous_send_time = current_send_time
|
|
|
|
if len(intervals) >= FREQUENCY_SAMPLE_SIZE:
|
|
average_interval = mean(intervals)
|
|
frequency_hz = 1.0 / average_interval
|
|
|
|
log.debug(
|
|
"Value frequency: %.3f kHz",
|
|
frequency_hz / 1_000.0,
|
|
)
|
|
|
|
intervals.clear()
|
|
|
|
if period is not None:
|
|
# Do not try to catch up by rapidly sending many old periods.
|
|
current_time = perf_counter()
|
|
|
|
if next_send_time < current_time - period:
|
|
missed_periods = int((current_time - next_send_time) / period)
|
|
next_send_time += missed_periods * period
|
|
|
|
finally:
|
|
log.debug("Value sender thread stopped")
|
|
|
|
|
|
async def perform_handshake(
|
|
reader: asyncio.StreamReader,
|
|
writer: asyncio.StreamWriter,
|
|
write_lock: asyncio.Lock,
|
|
) -> None:
|
|
try:
|
|
message = await asyncio.wait_for(
|
|
read_message(reader),
|
|
timeout=30.0,
|
|
)
|
|
except TimeoutError as exc:
|
|
raise TimeoutError("Timed out waiting for server hello") from exc
|
|
|
|
if not isinstance(message, DynaLabHello):
|
|
raise RuntimeError(f"Expected DynaLabHello, received {type(message).__name__}")
|
|
|
|
log.debug(
|
|
"Received hello from core instance %s",
|
|
message.instance_id,
|
|
)
|
|
|
|
connector_hello = ConnectorHello(
|
|
connector_uuid=uuid4(),
|
|
protocol_version=PROTOCOL_VERSION,
|
|
connector_name="Test connector",
|
|
connector_version=CONNECTOR_VERSION.get_version(),
|
|
signals=[
|
|
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
|
|
),
|
|
],
|
|
)
|
|
|
|
try:
|
|
await asyncio.wait_for(
|
|
send_message(
|
|
writer,
|
|
write_lock,
|
|
connector_hello,
|
|
),
|
|
timeout=5.0,
|
|
)
|
|
except TimeoutError as exc:
|
|
raise TimeoutError("Timed out sending connector hello") from exc
|
|
|
|
log.info(
|
|
"Connector hello sent for %s",
|
|
connector_hello.connector_uuid,
|
|
)
|
|
|
|
|
|
async def receive_messages(
|
|
reader: asyncio.StreamReader,
|
|
writer: asyncio.StreamWriter,
|
|
write_lock: asyncio.Lock,
|
|
) -> None:
|
|
while True:
|
|
message = await read_message(reader)
|
|
|
|
if isinstance(message, Heartbeat):
|
|
message.return_timestamp = monotonic_ms()
|
|
|
|
await send_message(
|
|
writer,
|
|
write_lock,
|
|
message,
|
|
)
|
|
|
|
log.debug(
|
|
"Returned heartbeat %s",
|
|
message.sequence,
|
|
)
|
|
else:
|
|
log.debug(
|
|
"Received unexpected message: %s",
|
|
type(message).__name__,
|
|
)
|
|
|
|
|
|
async def main() -> None:
|
|
writer: asyncio.StreamWriter | None = None
|
|
sender_thread: threading.Thread | None = None
|
|
sender_stop_event = threading.Event()
|
|
|
|
try:
|
|
reader, writer = await asyncio.open_connection(
|
|
host=HOST,
|
|
port=PORT,
|
|
)
|
|
|
|
log.info(
|
|
"Connected to DynaLab core at %s:%d",
|
|
HOST,
|
|
PORT,
|
|
)
|
|
|
|
write_lock = asyncio.Lock()
|
|
|
|
await perform_handshake(
|
|
reader,
|
|
writer,
|
|
write_lock,
|
|
)
|
|
|
|
loop = asyncio.get_running_loop()
|
|
|
|
sender_thread = threading.Thread(
|
|
target=value_sender_thread,
|
|
name="value_sender",
|
|
args=(
|
|
loop,
|
|
writer,
|
|
write_lock,
|
|
sender_stop_event,
|
|
),
|
|
daemon=True,
|
|
)
|
|
sender_thread.start()
|
|
|
|
await receive_messages(
|
|
reader,
|
|
writer,
|
|
write_lock,
|
|
)
|
|
|
|
except TimeoutError as exc:
|
|
log.warning("%s", exc)
|
|
|
|
except asyncio.IncompleteReadError:
|
|
log.warning("DynaLab core closed the connection")
|
|
|
|
except ConnectionError as exc:
|
|
log.warning("Connection error: %s", exc)
|
|
|
|
except RuntimeError as exc:
|
|
log.warning("Protocol error: %s", exc)
|
|
|
|
finally:
|
|
sender_stop_event.set()
|
|
|
|
if sender_thread is not None:
|
|
# Do not call thread.join() directly because that would block the
|
|
# asyncio event loop while the thread may be waiting on it.
|
|
await asyncio.to_thread(
|
|
sender_thread.join,
|
|
3.0,
|
|
)
|
|
|
|
if sender_thread.is_alive():
|
|
log.warning("Value sender thread did not stop cleanly")
|
|
|
|
if writer is not None:
|
|
writer.close()
|
|
|
|
try:
|
|
await writer.wait_closed()
|
|
except ConnectionError:
|
|
pass
|
|
|
|
log.info("Disconnected from DynaLab core")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
asyncio.run(main())
|
|
except KeyboardInterrupt:
|
|
log.info("Stopped by user")
|