some kamil_adc fixes

python_app/hardware_full/kamil_adc/tty_reader.py

@@ -52,6 +52,10 @@ class KamilAdcTtyReader:
     _stop_event: threading.Event = field(init=False, default_factory=threading.Event, repr=False)
     _mailbox_cv: threading.Condition = field(init=False, default_factory=threading.Condition, repr=False)
     _latest_sweep: RawSweep | None = field(init=False, default=None, repr=False)
+    # Latest clean sweep per switch combination, for the switch-aware collector.
+    # read_sweep() ignores this and serves the single newest sweep (calibration /
+    # non-switch mode); read_sweep_for() serves a specific combination.
+    _combo_slots: dict[tuple[int, int], RawSweep] = field(init=False, default_factory=dict, repr=False)
     _reader_error: Exception | None = field(init=False, default=None, repr=False)
     _published_count: int = field(init=False, default=0, repr=False)
 
@@ -62,6 +66,7 @@ class KamilAdcTtyReader:
         self._fd = os.open(self.tty_path, os.O_RDONLY | os.O_NOCTTY | os.O_NONBLOCK)
         self._stop_event.clear()
         self._latest_sweep = None
+        self._combo_slots = {}
         self._reader_error = None
         self._published_count = 0
         self._thread = threading.Thread(
@@ -89,6 +94,7 @@ class KamilAdcTtyReader:
             finally:
                 self._fd = None
         self._latest_sweep = None
+        self._combo_slots = {}
         self._reader_error = None
 
     @property
@@ -131,6 +137,39 @@ class KamilAdcTtyReader:
                     )
                 self._mailbox_cv.wait(timeout=min(_READ_POLL_INTERVAL_S, remaining_s))
 
+    def read_sweep_for(
+        self,
+        combo: tuple[int, int],
+        *,
+        timeout_s: float,
+        process: subprocess.Popen[bytes] | None = None,
+    ) -> RawSweep:
+        """Wait for and return the latest clean sweep for ``combo``.
+
+        Used in switch-aware mode, where the collector drives the switches and tags
+        each sweep with its combination. Only clean sweeps are delivered (the reader
+        thread drops the dirty ones); the slot is consumed on read so each caller
+        gets a fresh capture. Raises like :meth:`read_sweep`.
+        """
+        if self._thread is None:
+            raise RuntimeError("Kamil ADC TTY reader is not open")
+        deadline = time.monotonic() + float(timeout_s)
+        with self._mailbox_cv:
+            while True:
+                sweep = self._combo_slots.pop(combo, None)
+                if sweep is not None:
+                    return sweep
+                if self._reader_error is not None:
+                    raise self._reader_error
+                raise_if_process_exited(process)
+                remaining_s = deadline - time.monotonic()
+                if remaining_s <= 0.0:
+                    raise TimeoutError(
+                        f"Timed out waiting for Kamil ADC sweep for combo {combo} "
+                        f"after {float(timeout_s):.3f}s"
+                    )
+                self._mailbox_cv.wait(timeout=min(_READ_POLL_INTERVAL_S, remaining_s))
+
     # ------------------------------------------------------------------
     # Reader-thread internals
     # ------------------------------------------------------------------
@@ -177,11 +216,22 @@ class KamilAdcTtyReader:
         return chunk
 
     def _publish_sweep(self, sweep: RawSweep) -> None:
-        """Store ``sweep`` as the latest mailbox value, overwriting any unread one."""
+        """Publish a completed sweep to the mailbox(es), waking any waiter.
+
+        Dirty sweeps (those that straddled a switch transition) are counted but not
+        delivered: the collector re-takes that combination on the next sweep. Clean
+        tagged sweeps go to their per-combo slot; untagged sweeps (non-switch mode)
+        only update the single newest-sweep mailbox that read_sweep() serves.
+        """
         with self._mailbox_cv:
-            self._latest_sweep = sweep
             self._published_count += 1
-            self._mailbox_cv.notify()
+            if sweep.dirty:
+                self._mailbox_cv.notify_all()
+                return
+            self._latest_sweep = sweep
+            if sweep.combo is not None:
+                self._combo_slots[sweep.combo] = sweep
+            self._mailbox_cv.notify_all()
 
     def _publish_error(self, exc: Exception) -> None:
         """Record ``exc`` as the reader fault and wake any waiter."""