oasis-daq 0.0.0__py3-none-any.whl

oasis_daq/__init__.py

@@ -0,0 +1,28 @@
+"""Python DAQ for the Open Acquisition System for IEPE Sensors (OASIS).
+
+Version and description come from the installed distribution metadata, which
+setuptools builds from pyproject.toml, so what the About dialog shows is what
+is actually installed. In a source checkout that was never installed there is
+no metadata to read and the fallbacks below apply.
+"""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import metadata as _metadata
+from importlib.metadata import version as _version
+
+__all__ = ["APP_NAME", "DESCRIPTION", "DISTRIBUTION", "__version__"]
+
+DISTRIBUTION = "oasis-daq"  # the project name in pyproject.toml
+APP_NAME = "OASIS-DAQ"  # the same name as it is shown to the user
+
+_UNKNOWN_VERSION = "unknown"
+_FALLBACK_DESCRIPTION = (
+    "Python DAQ for the Open Acquisition System for IEPE Sensors (OASIS)"
+)
+
+try:
+    __version__ = _version(DISTRIBUTION)
+    DESCRIPTION = _metadata(DISTRIBUTION)["Summary"] or _FALLBACK_DESCRIPTION
+except PackageNotFoundError:
+    __version__ = _UNKNOWN_VERSION
+    DESCRIPTION = _FALLBACK_DESCRIPTION

oasis_daq/__main__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+raise SystemExit(main())

oasis_daq/acquisition.py

@@ -0,0 +1,410 @@
+"""Triggered multi-board acquisition loop for impact testing.
+
+Multi-board handling follows oasis-gui: all boards share the CONVST line, the
+primary board broadcasts the sampling parameters and every board stores the
+same capture on its own SD card. Acquisition therefore has two steps here:
+the primary board is armed and the impact is recorded (`_sample`), then the
+capture is pulled from every board's USB MSC volume - all boards at the same
+time, the primary included, since the volumes are independent - and the
+boards' channels are stacked in port order (`stack_sources`).
+
+Splitting the two steps means the sampling command is sent from here instead
+of through ``OasisBoard.acquire()``, which always downloads the primary's own
+capture before returning.
+"""
+
+from __future__ import annotations
+
+import tempfile
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+
+import numpy as np
+from oasis_api import OasisBoard
+from PyQt6.QtCore import QThread, pyqtSignal
+
+DEFAULT_SERIAL_BAUDRATE = 1_000_000
+PULL_ATTEMPTS = 2  # a second pull after rebooting the boards that failed
+
+
+class PullError(RuntimeError):
+    """One or more boards did not hand over their capture; `ports` lists them."""
+
+    def __init__(self, failures: dict[str, str]) -> None:
+        self.failures = dict(failures)
+        self.ports = list(failures)
+        super().__init__(
+            "Transfer failed: "
+            + " | ".join(f"{port}: {error}" for port, error in self.failures.items())
+        )
+
+
+class AcquisitionWorker(QThread):
+    """Repeatedly arms the boards and emits one record per triggered impact."""
+
+    stateChanged = pyqtSignal(str, str)  # state key, human readable detail
+    log = pyqtSignal(str)
+    progress = pyqtSignal(int)
+    recordReady = pyqtSignal(object)  # dict: data [C, S], t [S], sample_rate
+    finished_ok = pyqtSignal()
+    failed = pyqtSignal(str)
+
+    def __init__(
+        self,
+        ports: list[str],
+        voltage_ranges: list[list[float]],  # one 8-list per board
+        sample_rate: int,
+        duration: float,
+        oversampling_exp: int,
+        trigger_level: float,
+        continuous: bool = True,
+        baudrate: int = DEFAULT_SERIAL_BAUDRATE,
+        parent=None,
+    ) -> None:
+        super().__init__(parent)
+        self.ports = list(ports)
+        self.voltage_ranges = [list(ranges) for ranges in voltage_ranges]
+        self.sample_rate = int(sample_rate)
+        self.duration = float(duration)
+        self.oversampling_exp = int(oversampling_exp)
+        self.trigger_level = float(trigger_level)
+        self.continuous = bool(continuous)
+        self.baudrate = int(baudrate)
+        self._stop_requested = False
+        self._board: OasisBoard | None = None
+        self._board_lock = threading.Lock()
+        self._pull_percent: dict[str, int] = {}  # per-board transfer progress
+
+    # --- control ------------------------------------------------------------
+    def request_stop(self) -> None:
+        self._stop_requested = True
+        with self._board_lock:
+            board = self._board
+        if board is not None:
+            try:
+                board.abort()
+            except Exception:
+                pass
+
+    # --- worker -------------------------------------------------------------
+    def run(self) -> None:
+        try:
+            self._configure_secondary_boards()
+        except Exception as exc:
+            self.failed.emit(f"Configuring additional boards failed: {exc}")
+            return
+
+        while not self._stop_requested:
+            try:
+                payload = self._acquire_once()
+            except Exception as exc:
+                if self._stop_requested:
+                    break
+                self.failed.emit(str(exc))
+                return
+            if payload is None:
+                break
+            self.recordReady.emit(payload)
+            if not self.continuous:
+                break
+        self.finished_ok.emit()
+
+    def _configure_secondary_boards(self) -> None:
+        """Push voltage ranges and oversampling to the non-primary boards."""
+        for port, ranges in zip(self.ports[1:], self.voltage_ranges[1:]):
+            if self._stop_requested:  # arming can take seconds per board
+                return
+            self.stateChanged.emit("arming", f"Configuring board on {port}...")
+            board = OasisBoard(mode="serial", port=port, baudrate=self.baudrate)
+            try:
+                board.connect()
+                board.set_parameters(
+                    t_sample=self.duration,
+                    f_sample=self.sample_rate,
+                    voltage_range=ranges,
+                    trigger=self.trigger_level > 0,
+                    v_trigg=self.trigger_level,
+                    oversampling=self.oversampling_exp,
+                    sync_mode=0,
+                )
+                board.set_oversampling_and_range_only()
+            finally:
+                try:
+                    board.close()
+                except Exception:
+                    pass
+
+    def _acquire_once(self) -> dict | None:
+        filename = datetime.now().strftime("%Y-%m-%d-%H.%M.%S.%f")[:-3]
+        stored = self._sample(filename)
+        if stored is None:
+            return None
+        with tempfile.TemporaryDirectory(prefix="oasis_pull_") as scratch:
+            data, t = stack_sources(self._pull_all(stored, scratch))
+        return {
+            "data": data,
+            "t": t,
+            "sample_rate": float(self.sample_rate),
+        }
+
+    def _sample(self, filename: str) -> str | None:
+        """Arm the primary board and wait until the capture is stored.
+
+        Returns the file name the boards stored the capture under, or None
+        when the acquisition was stopped. This is ``OasisBoard.acquire()``
+        without its final step: the capture stays on the boards so that every
+        board can be pulled at the same time afterwards.
+        """
+        board = OasisBoard(mode="serial", port=self.ports[0], baudrate=self.baudrate)
+        with self._board_lock:
+            self._board = board
+        try:
+            board.set_parameters(
+                t_sample=self.duration,
+                f_sample=self.sample_rate,
+                voltage_range=self.voltage_ranges[0],
+                trigger=self.trigger_level > 0,
+                v_trigg=self.trigger_level,
+                oversampling=self.oversampling_exp,
+                sync_mode=0,
+            )
+
+            @board.on_trigger()
+            def _on_trigger() -> None:
+                self.stateChanged.emit("triggered", "Impact detected - recording...")
+
+            board.connect()
+            board.set_oversampling_and_range_only()
+            try:
+                board.ser.reset_input_buffer()
+            except Exception:
+                pass
+
+            if self.trigger_level > 0:
+                self.stateChanged.emit(
+                    "waiting",
+                    f"Armed - waiting for impact (trigger {self.trigger_level:g} V on CH1)",
+                )
+            else:
+                self.stateChanged.emit("waiting", "Recording (free run)...")
+
+            trigger_level = board.trigger_level if board.trigger_mode else 0
+            command = (
+                f"OASIS.Sample({board.t_sample},{board.f_sample},"
+                f"{trigger_level},{board.sync_mode},{filename})"
+            )
+            board.ser.write((command + "\n").encode("utf-8"))
+            stored = board._wait_for_serial_sample_completion(
+                board.ser, filename, log=self.log.emit
+            )
+            return None if self._stop_requested else stored
+        finally:
+            with self._board_lock:
+                self._board = None
+            try:
+                board.close()  # the capture travels over USB MSC, not over serial
+            except Exception:
+                pass
+
+    def _pull_all(self, filename: str, output_dir: str) -> list[dict]:
+        """Pull the capture from every board at once, in port order.
+
+        Seen on the bench: after a number of captures a board's USB MSC volume
+        no longer re-appears on the host and that board stops capturing until
+        it is rebooted. A failed transfer therefore reboots the boards that
+        failed, pushes the settings to them again and retries once; a second
+        failure is reported (that impact is lost).
+        """
+        count = len(self.ports)
+        detail = (
+            "Transferring data..."
+            if count == 1
+            else f"Transferring data from {count} boards in parallel..."
+        )
+        for attempt in range(1, PULL_ATTEMPTS + 1):
+            self._pull_percent = {}
+            self.stateChanged.emit(
+                "transferring", detail + (" (retry)" if attempt > 1 else "")
+            )
+            self.progress.emit(0)
+            try:
+                return collect_serial_sources_parallel(
+                    filename=filename,
+                    serial_ports=self.ports,
+                    t_sample=self.duration,
+                    f_sample=self.sample_rate,
+                    output_dir=output_dir,
+                    baudrate=self.baudrate,
+                    progress=self._pull_progress,
+                )
+            except PullError as exc:
+                if attempt >= PULL_ATTEMPTS or self._stop_requested:
+                    raise
+                self.log.emit(
+                    f"[GUI] {exc}; rebooting the board(s) that failed and retrying..."
+                )
+                self._reboot_boards(exc.ports)
+        raise RuntimeError("unreachable")
+
+    def _pull_progress(self, port: str, percent: int) -> None:
+        """Mean transfer progress over all boards (called from pull threads)."""
+        self._pull_percent[port] = int(percent)
+        self.progress.emit(int(sum(self._pull_percent.values()) / len(self.ports)))
+
+    def _reboot_boards(self, ports: list[str]) -> None:
+        for port in ports:
+            if self._stop_requested:
+                return
+            self.stateChanged.emit("arming", f"Rebooting board on {port}...")
+            reboot_board(port, self.baudrate)
+        if any(port in ports for port in self.ports[1:]):
+            # a rebooted board lost its voltage ranges and oversampling
+            self._configure_secondary_boards()
+
+
+# --- multi-board helpers (adapted from oasis-gui) ----------------------------
+def collect_serial_sources_parallel(
+    filename: str,
+    serial_ports: list[str],
+    t_sample: float,
+    f_sample: float,
+    output_dir: str | None = None,
+    baudrate: int = DEFAULT_SERIAL_BAUDRATE,
+    timeout_s: float = 45.0,
+    progress=None,  # callable(port, percent), called from the pull threads
+) -> list[dict]:
+    """Pull the stored capture from every board's USB MSC volume in parallel.
+
+    Each board copies from its own volume, so one thread per board is used and
+    the transfer takes as long as the slowest board rather than the sum of all
+    of them. Sources are returned in the order of ``serial_ports``; a board
+    that fails raises `PullError` naming every port that did not deliver.
+    """
+    ports = []
+    seen = set()
+    for port in serial_ports:
+        if port and port not in seen:
+            seen.add(port)
+            ports.append(port)
+    if not ports:
+        return []
+
+    if output_dir is None:
+        output_dir = tempfile.mkdtemp(prefix=f"oasis_pull_{filename}_")
+    index_map = {port: index for index, port in enumerate(ports)}
+    effective_timeout_s = max(float(timeout_s), float(t_sample) * 2.0 + 10.0)
+
+    def pull_one(port: str) -> dict:
+        board = OasisBoard(mode="serial", port=port, baudrate=baudrate)
+        result = board.collect_distributed_serial_files(
+            filename=filename,
+            serial_ports=[port],
+            t_sample=t_sample,
+            f_sample=f_sample,
+            output_dir=output_dir,
+            baudrate=baudrate,
+            timeout=effective_timeout_s,
+            print_log=lambda *_: None,
+            download_progress=progress,
+        )
+        if not result:
+            raise RuntimeError("No file collected.")
+        return result[0]
+
+    sources: list[dict] = []
+    failures: dict[str, str] = {}
+    with ThreadPoolExecutor(max_workers=len(ports)) as pool:
+        futures = {pool.submit(pull_one, port): port for port in ports}
+        for future in as_completed(futures):
+            port = futures[future]
+            try:
+                sources.append(future.result())
+            except Exception as exc:
+                failures[port] = str(exc)
+    if failures:
+        raise PullError({port: failures[port] for port in ports if port in failures})
+    sources.sort(key=lambda entry: index_map.get(entry.get("port", ""), 9999))
+    return sources
+
+
+def stack_sources(sources: list[dict]) -> tuple[np.ndarray, np.ndarray]:
+    """Decode pulled captures and stack the boards' channels in port order.
+
+    Returns the data [channels, samples] in volts and the time axis of the
+    primary board (negative before the trigger). Captures that differ in
+    length by a sample are truncated to the shortest one.
+    """
+    if not sources:
+        raise RuntimeError("No capture was collected.")
+
+    blocks = []
+    times = []
+    for source in sources:
+        offline = OasisBoard(mode="offline")
+        offline.load_from_files(
+            meta_path=source["meta_path"],
+            raw_path=source.get("raw_path"),
+            pretrig_raw_path=source.get("pretrig_raw_path"),
+            print_log=lambda *_: None,
+        )
+        blocks.append(np.asarray(offline.OASISData, dtype=float))
+        times.append(np.asarray(offline.t, dtype=float))
+
+    target = int(min(block.shape[1] for block in blocks))
+    return np.vstack([block[:, :target] for block in blocks]), times[0][:target]
+
+
+def reboot_board(port: str, baudrate: int = DEFAULT_SERIAL_BAUDRATE) -> None:
+    """``OASIS.Reboot()`` over serial; returns once the port re-enumerates.
+    The USB MSC volume follows a few seconds later (oasis-api waits for it
+    when the capture is pulled)."""
+    OasisBoard._reboot_serial_port_for_msc_refresh(port, baudrate=baudrate)
+
+
+def list_serial_ports() -> list[str]:
+    from serial.tools import list_ports
+
+    return [info.device for info in list_ports.comports()]
+
+
+def parse_device_info(raw: str) -> dict | None:
+    """Parse the ``OASIS.RawInfo()`` response (same layout as oasis-gui):
+    ``hw;fw;adc_bits;teds;wss;device_name;architecture``."""
+    cleaned = str(raw).replace("\r", "").replace("\n", "")
+    fields = [entry.strip() for entry in cleaned.split(";") if entry.strip()]
+    if not fields:
+        return None
+    if ")" in fields[0]:
+        fields[0] = fields[0].rsplit(")", 1)[-1].strip()
+    if len(fields) < 7:
+        return None
+    try:
+        return {
+            "hw_version": fields[0],
+            "fw_version": fields[1],
+            "adc_bits": int(fields[2]),
+            "teds": int(fields[3]),
+            "wss": int(fields[4]),
+            "device_name": fields[5],
+            "architecture": fields[6],
+        }
+    except ValueError:
+        return None
+
+
+def read_device_info(port: str, baudrate: int = DEFAULT_SERIAL_BAUDRATE) -> dict:
+    """Connect to a board, read its stored device info, and disconnect."""
+    board = OasisBoard(mode="serial", port=port, baudrate=baudrate)
+    board.connect()
+    try:
+        raw = board.device_raw_info()
+    finally:
+        try:
+            board.close()
+        except Exception:
+            pass
+    fields = parse_device_info(raw)
+    if fields is None:
+        raise RuntimeError(f"Unexpected device info response: {raw!r}")
+    return fields