320 lines
13 KiB
Python
320 lines
13 KiB
Python
"""Tests for the Kamil ADC TTY reader, config round-trip, and producer wiring."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import pty
|
|
import struct
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import tty
|
|
import unittest
|
|
from unittest import mock
|
|
|
|
from python_app.hardware_full.kamil_adc import KamilAdcService, KamilAdcTtyReader
|
|
from python_app.hardware_full.kamil_adc.protocol import (
|
|
COMBO_MARKER,
|
|
MAIN_MARKER,
|
|
REFERENCE_MARKER,
|
|
)
|
|
from python_app.models.run_config_model import RunConfigModel
|
|
from python_app.orchestration.process_supervisor import ProcessSupervisor
|
|
|
|
|
|
def _boundary() -> bytes:
|
|
return struct.pack("<HHHH", MAIN_MARKER, 0xFFFF, 0xFFFF, 0xFFFF)
|
|
|
|
|
|
def _main(step: int, real: int, imag: int) -> bytes:
|
|
return struct.pack("<HHhh", MAIN_MARKER, step, real, imag)
|
|
|
|
|
|
def _reference(step: int, real: int, imag: int) -> bytes:
|
|
return struct.pack("<HHhh", REFERENCE_MARKER, step, real, imag)
|
|
|
|
|
|
def _combo(input_pos: int, output_pos: int, dirty: int = 0) -> bytes:
|
|
return struct.pack("<HHhh", COMBO_MARKER, input_pos, output_pos, dirty)
|
|
|
|
|
|
class KamilAdcTtyReaderTest(unittest.TestCase):
|
|
"""End-to-end tests over a PTY exercising the background reader thread."""
|
|
|
|
def _open_pty_reader(self) -> tuple[int, int, KamilAdcTtyReader]:
|
|
master_fd, slave_fd = pty.openpty()
|
|
tty.setraw(slave_fd)
|
|
reader = KamilAdcTtyReader(os.ttyname(slave_fd))
|
|
reader.open()
|
|
return master_fd, slave_fd, reader
|
|
|
|
@staticmethod
|
|
def _close(master_fd: int, slave_fd: int, reader: KamilAdcTtyReader) -> None:
|
|
try:
|
|
reader.close()
|
|
finally:
|
|
os.close(master_fd)
|
|
os.close(slave_fd)
|
|
|
|
def test_publishes_sweep_with_aligned_main_and_reference(self) -> None:
|
|
master_fd, slave_fd, reader = self._open_pty_reader()
|
|
try:
|
|
os.write(
|
|
master_fd,
|
|
_boundary()
|
|
+ _main(1, 10, -1) + _reference(1, 100, 5)
|
|
+ _main(2, -20, 2) + _reference(2, 200, 6)
|
|
+ _boundary(),
|
|
)
|
|
sweep = reader.read_sweep(timeout_s=1.0)
|
|
self.assertEqual(sweep.steps.tolist(), [1, 2])
|
|
self.assertEqual(sweep.main.tolist(), [complex(10, -1), complex(-20, 2)])
|
|
self.assertEqual(sweep.reference.tolist(), [complex(100, 5), complex(200, 6)])
|
|
finally:
|
|
self._close(master_fd, slave_fd, reader)
|
|
|
|
def test_variable_length_sweeps_are_allowed(self) -> None:
|
|
"""Unlike the old format, sweep length may vary — no locking, just resample later."""
|
|
master_fd, slave_fd, reader = self._open_pty_reader()
|
|
try:
|
|
# One complete sweep per write, read between, so delivery is deterministic
|
|
# (the reader publishes only the latest, overwriting unread sweeps).
|
|
os.write(master_fd, _boundary() + _main(1, 1, 0) + _reference(1, 9, 0) + _boundary())
|
|
first = reader.read_sweep(timeout_s=1.0)
|
|
self.assertEqual(first.steps.tolist(), [1])
|
|
|
|
os.write(
|
|
master_fd,
|
|
_main(1, 2, 0) + _reference(1, 8, 0)
|
|
+ _main(2, 3, 0) + _reference(2, 7, 0)
|
|
+ _boundary(),
|
|
)
|
|
second = reader.read_sweep(timeout_s=1.0)
|
|
self.assertEqual(second.steps.tolist(), [1, 2])
|
|
finally:
|
|
self._close(master_fd, slave_fd, reader)
|
|
|
|
def test_only_latest_sweep_is_published(self) -> None:
|
|
master_fd, slave_fd, reader = self._open_pty_reader()
|
|
try:
|
|
payload = (
|
|
_boundary() + _main(1, 1, 0) + _reference(1, 1, 0)
|
|
+ _boundary() + _main(1, 2, 0) + _reference(1, 2, 0)
|
|
+ _boundary() + _main(1, 3, 0) + _reference(1, 3, 0)
|
|
+ _boundary()
|
|
)
|
|
os.write(master_fd, payload)
|
|
deadline = time.monotonic() + 1.0
|
|
while time.monotonic() < deadline and reader.published_count < 3:
|
|
time.sleep(0.005)
|
|
self.assertGreaterEqual(reader.published_count, 3)
|
|
sweep = reader.read_sweep(timeout_s=1.0)
|
|
self.assertEqual(sweep.main.tolist(), [complex(3, 0)])
|
|
finally:
|
|
self._close(master_fd, slave_fd, reader)
|
|
|
|
def test_corrupt_frame_fails_fast(self) -> None:
|
|
master_fd, slave_fd, reader = self._open_pty_reader()
|
|
try:
|
|
corrupt = struct.pack("<HHhh", 0x001A, 1, 5, 5) # unknown marker
|
|
os.write(master_fd, _boundary() + _main(1, 10, -1) + corrupt + _boundary())
|
|
with self.assertRaises((ValueError, RuntimeError)):
|
|
reader.read_sweep(timeout_s=1.0)
|
|
finally:
|
|
self._close(master_fd, slave_fd, reader)
|
|
|
|
def test_no_completed_sweep_times_out(self) -> None:
|
|
master_fd, slave_fd, reader = self._open_pty_reader()
|
|
try:
|
|
os.write(master_fd, _boundary() + _main(1, 10, -1) + _reference(1, 1, 0))
|
|
with self.assertRaisesRegex(TimeoutError, "Timed out waiting for Kamil ADC sweep"):
|
|
reader.read_sweep(timeout_s=0.1)
|
|
finally:
|
|
self._close(master_fd, slave_fd, reader)
|
|
|
|
def test_read_sweep_for_demuxes_by_combo(self) -> None:
|
|
master_fd, slave_fd, reader = self._open_pty_reader()
|
|
try:
|
|
os.write(
|
|
master_fd,
|
|
_boundary() + _combo(0, 0) + _main(1, 11, 0) + _reference(1, 1, 0)
|
|
+ _boundary() + _combo(0, 1) + _main(1, 22, 0) + _reference(1, 1, 0)
|
|
+ _boundary(),
|
|
)
|
|
# Each combination is served from its own slot, regardless of order.
|
|
second = reader.read_sweep_for((0, 1), timeout_s=1.0)
|
|
self.assertEqual(second.main.real.tolist(), [22])
|
|
self.assertEqual(second.combo, (0, 1))
|
|
first = reader.read_sweep_for((0, 0), timeout_s=1.0)
|
|
self.assertEqual(first.main.real.tolist(), [11])
|
|
finally:
|
|
self._close(master_fd, slave_fd, reader)
|
|
|
|
def test_read_sweep_for_drops_dirty_and_takes_retake(self) -> None:
|
|
master_fd, slave_fd, reader = self._open_pty_reader()
|
|
try:
|
|
os.write(
|
|
master_fd,
|
|
# A dirty combo (0,1) sweep, then its clean re-take of the same combo.
|
|
_boundary() + _combo(0, 1, dirty=1) + _main(1, 99, 0) + _reference(1, 1, 0)
|
|
+ _boundary() + _combo(0, 1) + _main(1, 42, 0) + _reference(1, 1, 0)
|
|
+ _boundary(),
|
|
)
|
|
sweep = reader.read_sweep_for((0, 1), timeout_s=1.0)
|
|
# The dirty sweep (99) is dropped; only the clean re-take (42) is served.
|
|
self.assertEqual(sweep.main.real.tolist(), [42])
|
|
self.assertFalse(sweep.dirty)
|
|
finally:
|
|
self._close(master_fd, slave_fd, reader)
|
|
|
|
|
|
class KamilAdcConfigTest(unittest.TestCase):
|
|
def test_config_round_trip_preserves_kamil_sections(self) -> None:
|
|
payload = {
|
|
"radar": {
|
|
"model": "kamil_adc",
|
|
"serial": "kamil_adc",
|
|
"driver_mode": "native",
|
|
"kamil_adc": {
|
|
"project_dir": "",
|
|
"executable_path": "build/bin/kamil_adc_collector",
|
|
"tty_path": "/tmp/ttyADC_data",
|
|
"args": ["profile:phase", "do8_freq_ref"],
|
|
"env": {"ADC_ENV": "1"},
|
|
"startup_timeout_s": 7.0,
|
|
"sweep_timeout_s": 8.0,
|
|
"stop_timeout_s": 3.0,
|
|
"phase_calibration": {
|
|
"phase0_rad": 1.5,
|
|
"freq0_hz": 2_046_000_000.0,
|
|
"phase1_rad": 301.0,
|
|
"freq1_hz": 5_612_000_000.0,
|
|
},
|
|
"band": {
|
|
"start_hz": 2_100_000_000.0,
|
|
"stop_hz": 5_500_000_000.0,
|
|
"points": 1024,
|
|
},
|
|
},
|
|
"laser_control": {"enabled": True, "port": "/dev/ttyUSB0", "mode": "manual"},
|
|
"sweep": {"start_hz": 1.0, "stop_hz": 2.0, "points": 2},
|
|
},
|
|
"switches": {"port1": {"positions": 1}, "port2": {"positions": 1}},
|
|
}
|
|
|
|
encoded = RunConfigModel.from_dict(payload).to_dict()
|
|
kamil = encoded["radar"]["kamil_adc"]
|
|
|
|
self.assertEqual(encoded["radar"]["model"], "kamil_adc")
|
|
self.assertEqual(kamil["executable_path"], "build/bin/kamil_adc_collector")
|
|
self.assertEqual(kamil["args"], ["profile:phase", "do8_freq_ref"])
|
|
self.assertEqual(kamil["phase_calibration"]["phase0_rad"], 1.5)
|
|
self.assertEqual(kamil["phase_calibration"]["freq1_hz"], 5_612_000_000.0)
|
|
self.assertEqual(kamil["band"], {"start_hz": 2_100_000_000.0, "stop_hz": 5_500_000_000.0, "points": 1024})
|
|
|
|
def test_close_never_raises_when_collector_refuses_to_die(self) -> None:
|
|
"""close() must stay exception-safe even if a SIGKILL'd collector is not
|
|
reaped within the grace window (e.g. wedged in USB D-state)."""
|
|
with tempfile.TemporaryDirectory() as tmp_dir:
|
|
config = RunConfigModel.from_dict(
|
|
{
|
|
"radar": {
|
|
"model": "kamil_adc",
|
|
"driver_mode": "native",
|
|
"kamil_adc": {
|
|
"project_dir": tmp_dir,
|
|
"executable_path": "/bin/sh", # any real executable
|
|
"tty_path": "/tmp/ttyADC_test",
|
|
},
|
|
},
|
|
"switches": {"port1": {"positions": 1}, "port2": {"positions": 1}},
|
|
}
|
|
)
|
|
service = KamilAdcService(config)
|
|
|
|
class _UnreapableProcess:
|
|
pid = 2_000_000_000 # implausible; killpg is patched out below anyway
|
|
|
|
def poll(self) -> None:
|
|
return None # always "alive"
|
|
|
|
def wait(self, timeout: float | None = None) -> int:
|
|
raise subprocess.TimeoutExpired(cmd="kamil_adc_collector", timeout=timeout)
|
|
|
|
service._process = _UnreapableProcess() # type: ignore[assignment]
|
|
with mock.patch("python_app.hardware_full.kamil_adc.service.os.killpg"):
|
|
service.close() # must not raise
|
|
|
|
def test_drain_after_switch_waits_for_fresh_sweeps(self) -> None:
|
|
"""After a switch change, drain must skip the configured number of freshly
|
|
published sweeps before returning, so the next capture is post-switch."""
|
|
import types
|
|
|
|
from python_app.hardware_full.kamil_adc import service as service_module
|
|
|
|
with tempfile.TemporaryDirectory() as tmp_dir:
|
|
config = RunConfigModel.from_dict(
|
|
{
|
|
"radar": {
|
|
"model": "kamil_adc",
|
|
"driver_mode": "native",
|
|
"kamil_adc": {
|
|
"project_dir": tmp_dir,
|
|
"executable_path": "/bin/sh",
|
|
"tty_path": "/tmp/ttyADC_test",
|
|
"sweep_timeout_s": 5.0,
|
|
},
|
|
},
|
|
"switches": {"port1": {"positions": 1}, "port2": {"positions": 1}},
|
|
}
|
|
)
|
|
service = KamilAdcService(config)
|
|
service._reader = types.SimpleNamespace(published_count=10) # type: ignore[assignment]
|
|
service._process = types.SimpleNamespace(poll=lambda: None) # type: ignore[assignment]
|
|
|
|
# Each poll-sleep advances the published count, as the reader thread would.
|
|
def _advance(_seconds: float) -> None:
|
|
service._reader.published_count += 1
|
|
|
|
with mock.patch.object(service_module.time, "sleep", _advance):
|
|
service.drain_after_switch(sweeps=3)
|
|
|
|
# Started at 10, must have waited for at least 3 more sweeps.
|
|
self.assertGreaterEqual(service._reader.published_count, 13)
|
|
|
|
def test_drain_after_switch_is_noop_when_not_open(self) -> None:
|
|
with tempfile.TemporaryDirectory() as tmp_dir:
|
|
config = RunConfigModel.from_dict(
|
|
{
|
|
"radar": {
|
|
"model": "kamil_adc",
|
|
"driver_mode": "native",
|
|
"kamil_adc": {
|
|
"project_dir": tmp_dir,
|
|
"executable_path": "/bin/sh",
|
|
"tty_path": "/tmp/ttyADC_test",
|
|
},
|
|
},
|
|
"switches": {"port1": {"positions": 1}, "port2": {"positions": 1}},
|
|
}
|
|
)
|
|
KamilAdcService(config).drain_after_switch() # no reader → must not raise
|
|
|
|
def test_supervisor_selects_kamil_adc_producer(self) -> None:
|
|
with tempfile.TemporaryDirectory() as tmp_dir:
|
|
config_path = Path(tmp_dir) / "run_config.json"
|
|
config_path.write_text(json.dumps({"radar": {"model": "kamil_adc"}}), encoding="utf-8")
|
|
command = ProcessSupervisor(Path("/repo"))._acquisition_command(config_path)
|
|
|
|
self.assertEqual(
|
|
command,
|
|
[sys.executable, "-m", "python_app.scripts.kamil_adc_raw_producer", "--config", str(config_path)],
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|