added multidevice support

python_app/scripts/manual_smoke_run.py

@@ -114,6 +114,11 @@ def main() -> int:
         sweep_points=config.radar.sweep.points,
         ifbw_hz=config.radar.sweep.if_bandwidth_hz,
         power_dbm=config.radar.sweep.power_dbm,
+        extra_serials=(
+            config.radar.multi_device.slave_serials
+            if config.is_multi_device
+            else None
+        ),
     )
 
     s21_calibration_set = build_synthetic_collection(config, value_scale=1.0, s11_scale=0.15, s11_phase_offset=0.4)

python_app/scripts/multi_device_raw_producer.py

@@ -0,0 +1,95 @@
+"""Raw acquisition producer for LibreVNA multi-device mode."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+import signal
+import threading
+import time
+
+from python_app.hardware_full.multi_device_service import MultiDeviceLibreVnaService
+from python_app.models.run_config_model import RunConfigModel
+from python_app.orchestration.shm import ShmRingWriter
+from python_app.storage.npz.serialize import RAW_MAGIC, serialize_trace_collection
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> int:
+    """Run producer process until config or signal requests exit."""
+    parser = argparse.ArgumentParser(description="Publish LibreVNA multi-device raw sweeps to SHM rings")
+    parser.add_argument("--config", required=True, type=Path, help="Path to run_config.json")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+    stop_requested = threading.Event()
+
+    def request_stop(_signum: int, _frame: object) -> None:
+        stop_requested.set()
+
+    signal.signal(signal.SIGINT, request_stop)
+    signal.signal(signal.SIGTERM, request_stop)
+
+    config = RunConfigModel.load_from_path(args.config)
+    config.apply_device_model_constraints()
+    if not config.is_multi_device:
+        raise RuntimeError("multi_device_raw_producer requires radar.model='librevna_multi'")
+
+    raw_writer = ShmRingWriter(
+        config.rings.raw.name,
+        config.rings.raw.capacity,
+        config.rings.raw.slot_size_bytes,
+    )
+    raw_tap_writer = ShmRingWriter(
+        config.rings.raw_tap.name,
+        config.rings.raw_tap.capacity,
+        config.rings.raw_tap.slot_size_bytes,
+    )
+    radar = MultiDeviceLibreVnaService(
+        master_serial=config.radar.serial,
+        slave_serials=list(config.radar.multi_device.slave_serials),
+        force_external_reference=config.radar.multi_device.force_external_reference,
+        recovery_attempts=config.radar.multi_device.recovery_attempts,
+        backend_mode=config.radar.driver_mode,
+    )
+
+    try:
+        radar.open()
+        radar.configure(config.radar.sweep)
+        collection_id = 1
+        while not stop_requested.is_set():
+            collection_start = time.monotonic()
+            collection = radar.acquire_collection(collection_id=collection_id)
+
+            payload = serialize_trace_collection(collection, RAW_MAGIC)
+            if not raw_writer.push(payload):
+                raise RuntimeError(
+                    f"Raw payload size {len(payload)} exceeds ring slot size {raw_writer.slot_size_bytes}"
+                )
+            if not raw_tap_writer.push(payload):
+                raise RuntimeError(
+                    f"Raw tap payload size {len(payload)} exceeds ring slot size {raw_tap_writer.slot_size_bytes}"
+                )
+            if not config.runtime.continuous:
+                break
+            collection_duration_s = time.monotonic() - collection_start
+            if collection_id == 1 or collection_id % 20 == 0 or collection_duration_s > 2.0:
+                logger.info(
+                    "multi-device collection %d acquired in %.3f s",
+                    collection_id,
+                    collection_duration_s,
+                )
+            collection_id += 1
+    finally:
+        radar.close()
+        raw_tap_writer.close()
+        raw_writer.close()
+
+    logger.info("multi-device raw producer stopped")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())