Merge branch 'laser-temp-monitoring' into feature/switched-matrix-radar

python_app/scripts/kamil_adc_raw_producer.py

@@ -36,8 +36,8 @@ _OPEN_RETRY_LOG_EVERY = 30
 def _open_radar_with_retry(
     config: RunConfigModel,
     radar: KamilAdcService,
-    input_switch: SwitchService,
-    output_switch: SwitchService,
+    input_switch: SwitchService | None,
+    output_switch: SwitchService | None,
     stop_requested: threading.Event,
 ) -> bool:
     """Open+configure the radar and both switches, retrying forever until stop.
@@ -48,14 +48,19 @@ def _open_radar_with_retry(
     relaunched collector starts clean. Returns ``True`` once everything is open, or
     ``False`` if a stop was requested before the device became available. Backoff is
     capped and every wait is interruptible by SIGTERM.
+
+    ``input_switch``/``output_switch`` are ``None`` in switch-aware mode, where the
+    collector owns the GPIO lines and the producer must not open them.
     """
     # Tear down any prior open first: open()/switch.open() are idempotent no-ops
     # while still "open", so a mid-run reconnect must close them to force a fresh
     # collector relaunch and TTY re-attach.
-    with suppress(Exception):
-        input_switch.close()
-    with suppress(Exception):
-        output_switch.close()
+    if input_switch is not None:
+        with suppress(Exception):
+            input_switch.close()
+    if output_switch is not None:
+        with suppress(Exception):
+            output_switch.close()
     with suppress(Exception):
         radar.close()
 
@@ -65,15 +70,19 @@ def _open_radar_with_retry(
         try:
             radar.open(stop_event=stop_requested)
             radar.configure(config.radar.sweep)
-            output_switch.open()
-            input_switch.open()
+            if output_switch is not None:
+                output_switch.open()
+            if input_switch is not None:
+                input_switch.open()
         except Exception as exc:  # noqa: BLE001 — waiting for the device is the point
             # Drop any partial open (collector process, TTY reader, switches)
             # before the next attempt so the relaunch starts from a clean state.
-            with suppress(Exception):
-                input_switch.close()
-            with suppress(Exception):
-                output_switch.close()
+            if input_switch is not None:
+                with suppress(Exception):
+                    input_switch.close()
+            if output_switch is not None:
+                with suppress(Exception):
+                    output_switch.close()
             with suppress(Exception):
                 radar.close()
             attempt += 1
@@ -136,9 +145,26 @@ def main() -> int:
         "Opened SHM ring writers: raw=%s, raw_tap=%s",
         config.rings.raw.name, config.rings.raw_tap.name,
     )
-    radar = KamilAdcService(config)
-    input_switch = SwitchService.from_model(config.input_switch)
-    output_switch = SwitchService.from_model(config.output_switch)
+    # Switch-aware mode: with native switches the collector drives the RF switches
+    # itself, in the hardware gap between sweeps, and tags each sweep with its combo
+    # — no sweep lost at a switch boundary. The producer then only reads tagged
+    # sweeps and must not touch the GPIO lines the collector owns. With mock switches
+    # (dev/tests) we keep the Python-driven path, which is fine where speed and the
+    # in-gap timing do not matter.
+    collector_driven = (
+        config.input_switch.driver_mode == "native"
+        and config.output_switch.driver_mode == "native"
+    )
+    radar = KamilAdcService(
+        config,
+        switch_config_path=str(args.config) if collector_driven else None,
+    )
+    input_switch = None if collector_driven else SwitchService.from_model(config.input_switch)
+    output_switch = None if collector_driven else SwitchService.from_model(config.output_switch)
+    logger.info(
+        "Kamil ADC switch control: %s",
+        "collector-driven (in-gap, lossless)" if collector_driven else "producer-driven",
+    )
 
     try:
         if not _open_radar_with_retry(config, radar, input_switch, output_switch, stop_requested):
@@ -155,12 +181,16 @@ def main() -> int:
                 for combo in config.combos:
                     if stop_requested.is_set():
                         break
-                    output_switch.switch_to(combo.output)
-                    input_switch.switch_to(combo.input)
-                    if config.runtime.settling_ms > 0:
-                        time.sleep(config.runtime.settling_ms / 1000.0)
-
-                    sweep = radar.acquire()
+                    if collector_driven:
+                        # The collector already switched and tagged the sweep; just
+                        # read the clean capture for this combination.
+                        sweep = radar.acquire(combo=(combo.input, combo.output))
+                    else:
+                        output_switch.switch_to(combo.output)
+                        input_switch.switch_to(combo.input)
+                        if config.runtime.settling_ms > 0:
+                            time.sleep(config.runtime.settling_ms / 1000.0)
+                        sweep = radar.acquire()
                     traces.append(
                         TraceData(
                             combo=ComboKey(input=combo.input, output=combo.output),
@@ -222,10 +252,12 @@ def main() -> int:
                 logger.info("Kamil ADC collection %d acquired in %.3f s", collection_id, collection_duration_s)
             collection_id += 1
     finally:
-        with suppress(Exception):
-            output_switch.close()
-        with suppress(Exception):
-            input_switch.close()
+        if output_switch is not None:
+            with suppress(Exception):
+                output_switch.close()
+        if input_switch is not None:
+            with suppress(Exception):
+                input_switch.close()
         with suppress(Exception):
             radar.close()
         raw_tap_writer.close()

python_app/scripts/laser_temp_checker.py

@@ -0,0 +1,78 @@
+"""Standalone laser temperature checker process.
+
+Reads the target setpoints frozen at variation start and tails the JSONL readings
+channel produced by the monitor. For every reading it validates both lasers and
+prints a console warning whenever a measured temperature drifts from its target by
+more than the tolerance (default 0.03 °C). Never touches the serial port, so it is
+fully independent of the monitor and can be started/stopped at any time.
+
+Example::
+
+    python -m python_app.scripts.laser_temp_checker
+    python -m python_app.scripts.laser_temp_checker --session s.json --readings r.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import signal
+import threading
+from pathlib import Path
+
+from python_app.hardware_full.laser_control.monitoring import (
+    DEFAULT_READINGS_PATH,
+    DEFAULT_SESSION_PATH,
+    LaserTemperatureChecker,
+    LaserVariationSession,
+    ReadingReader,
+)
+
+logger = logging.getLogger("laser_temp_checker")
+
+_POLL_INTERVAL_S = 0.2
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Validate laser temperature against setpoints")
+    parser.add_argument("--session", type=Path, default=DEFAULT_SESSION_PATH,
+                        help="Session snapshot with target setpoints + tolerance")
+    parser.add_argument("--readings", type=Path, default=DEFAULT_READINGS_PATH,
+                        help="JSONL readings channel to tail")
+    parser.add_argument("--tolerance", type=float, default=None,
+                        help="Override tolerance in °C (default: from session)")
+    parser.add_argument("--reminder-every", type=int, default=0,
+                        help="Repeat a warning every N readings while off target (0=off)")
+    parser.add_argument("--from-start", action="store_true",
+                        help="Validate the whole readings file, not just new lines")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+
+    session = LaserVariationSession.load(args.session)
+    if args.tolerance is not None:
+        session.tolerance_c = args.tolerance
+    checker = LaserTemperatureChecker.from_session(session, reminder_every=args.reminder_every)
+    logger.info(
+        "Checking against T1=%.3f T2=%.3f °C, tolerance ±%.3f °C (%s)",
+        session.target_temp1, session.target_temp2, session.tolerance_c, session.variation_type,
+    )
+
+    reader = ReadingReader(args.readings, from_start=args.from_start)
+    stop_event = threading.Event()
+
+    def request_stop(_signum: int, _frame: object) -> None:
+        stop_event.set()
+
+    signal.signal(signal.SIGINT, request_stop)
+    signal.signal(signal.SIGTERM, request_stop)
+
+    while not stop_event.is_set():
+        for reading in reader.poll():
+            checker.process(reading)
+        stop_event.wait(_POLL_INTERVAL_S)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

python_app/scripts/laser_temp_monitor.py

@@ -0,0 +1,149 @@
+"""Standalone laser temperature monitor process.
+
+Owns the laser serial port, (optionally) starts a current-variation task, then
+polls the board once per sweep and appends each reading to a JSONL channel that
+the temperature checker tails. Runs until SIGINT/SIGTERM.
+
+Examples::
+
+    # Start LD1 current variation from a run config, then monitor:
+    python -m python_app.scripts.laser_temp_monitor --config run_config.json --start
+
+    # Monitor a variation that is already running:
+    python -m python_app.scripts.laser_temp_monitor --config run_config.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import signal
+import threading
+from datetime import datetime
+from pathlib import Path
+
+from python_app.hardware_full.laser_control.controller import (
+    DEVICE_MAIN_MESSAGE_ID,
+    LaserController,
+)
+from python_app.hardware_full.laser_control.exceptions import PortBusyError
+from python_app.hardware_full.laser_control.models import VariationType
+from python_app.hardware_full.laser_control.monitoring import (
+    DEFAULT_READINGS_PATH,
+    DEFAULT_SESSION_PATH,
+    LaserTemperatureMonitor,
+    LaserVariationSession,
+    ReadingWriter,
+    resolve_period_s,
+)
+from python_app.models.run_config_model import RunConfigModel
+
+logger = logging.getLogger("laser_temp_monitor")
+
+
+def _start_variation(controller: LaserController, variation) -> None:
+    """Send the CHANGE_CURRENT_LD1 task and freeze the session snapshot."""
+    controller.reset()
+    controller.set_manual_mode(
+        temp1=variation.static_temp1,
+        temp2=variation.static_temp2,
+        current1=variation.static_current1,
+        current2=variation.static_current2,
+        message_id=DEVICE_MAIN_MESSAGE_ID,
+    )
+    controller.start_variation(
+        variation_type=VariationType[variation.variation_type],
+        params={
+            "static_temp1": variation.static_temp1,
+            "static_temp2": variation.static_temp2,
+            "static_current1": variation.static_current1,
+            "static_current2": variation.static_current2,
+            "min_value": variation.min_value,
+            "max_value": variation.max_value,
+            "step": variation.step,
+            "time_step": variation.time_step,
+            "delay_time": variation.delay_time,
+        },
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Poll laser temperature once per sweep")
+    parser.add_argument("--config", required=True, type=Path, help="Path to run_config.json")
+    parser.add_argument("--readings", type=Path, default=DEFAULT_READINGS_PATH,
+                        help="JSONL readings channel to append to")
+    parser.add_argument("--session", type=Path, default=DEFAULT_SESSION_PATH,
+                        help="Session snapshot path (written with --start)")
+    parser.add_argument("--strategy", default="computed",
+                        help="'computed' (per sweep) or 'interval:<ms>'")
+    parser.add_argument("--start", action="store_true",
+                        help="Send CHANGE_CURRENT_LD1 before monitoring")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+
+    config = RunConfigModel.load_from_path(args.config)
+    laser = config.radar.laser_control
+    variation = laser.variation
+    if variation.variation_type != "CHANGE_CURRENT_LD1":
+        logger.warning(
+            "Only CHANGE_CURRENT_LD1 is supported by firmware; got %s",
+            variation.variation_type,
+        )
+
+    period_s = resolve_period_s(
+        args.strategy,
+        min_value=variation.min_value,
+        max_value=variation.max_value,
+        step=variation.step,
+        time_step_us=variation.time_step,
+        delay_time_ms=variation.delay_time,
+    )
+
+    stop_event = threading.Event()
+
+    def request_stop(_signum: int, _frame: object) -> None:
+        stop_event.set()
+
+    signal.signal(signal.SIGINT, request_stop)
+    signal.signal(signal.SIGTERM, request_stop)
+
+    controller = LaserController(
+        port=laser.port or None,
+        pi_coeff1_p=laser.pi_coeff1_p,
+        pi_coeff1_i=laser.pi_coeff1_i,
+        pi_coeff2_p=laser.pi_coeff2_p,
+        pi_coeff2_i=laser.pi_coeff2_i,
+    )
+    try:
+        controller.connect()
+    except PortBusyError as exc:
+        # Expected, benign conflict: the manual-control UI (or another monitor)
+        # already owns the port. Exit cleanly with guidance, not a traceback.
+        logger.error("%s", exc)
+        return 2
+    try:
+        if args.start:
+            _start_variation(controller, variation)
+            LaserVariationSession(
+                variation_type=variation.variation_type,
+                target_temp1=variation.static_temp1,
+                target_temp2=variation.static_temp2,
+                tolerance_c=variation.temp_tolerance_c,
+                started_at_iso=datetime.now().isoformat(timespec="seconds"),
+            ).save(args.session)
+            logger.info("Started CHANGE_CURRENT_LD1 and wrote session %s", args.session)
+
+        with ReadingWriter(args.readings) as writer:
+            monitor = LaserTemperatureMonitor(
+                controller=controller, writer=writer, period_s=period_s
+            )
+            logger.info("Monitoring to %s (period=%.3fs)", args.readings, period_s)
+            monitor.run(stop_event)
+    finally:
+        controller.disconnect()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())