100 lines
3.8 KiB
Python
100 lines
3.8 KiB
Python
"""Standalone smoke test for Compact-M K209 VISA HiSLIP acquisition."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
|
|
import numpy as np
|
|
|
|
from python_app.hardware_full.compact_m_k209_service import CompactMK209Service
|
|
from python_app.models.run_config_model import RadarSweepModel
|
|
|
|
|
|
def _parse_args() -> argparse.Namespace:
|
|
"""Parse command-line options for the local K209 VISA smoke test."""
|
|
parser = argparse.ArgumentParser(description="Acquire one K209 sweep through VISA HiSLIP")
|
|
parser.add_argument(
|
|
"--resource",
|
|
required=True,
|
|
help=(
|
|
"S2VNA VISA resource, e.g. TCPIP0::127.0.0.1::hislip0,4880::INSTR "
|
|
"when the USB-connected K209 is controlled by local S2VNA"
|
|
),
|
|
)
|
|
parser.add_argument("--start-hz", type=float, default=1_000_000.0)
|
|
parser.add_argument("--stop-hz", type=float, default=6_000_000_000.0)
|
|
parser.add_argument("--points", type=int, default=201)
|
|
parser.add_argument("--ifbw-hz", type=float, default=50_000.0)
|
|
parser.add_argument("--power-dbm", type=float, default=-10.0)
|
|
parser.add_argument("--timeout-ms", type=int, default=20_000)
|
|
parser.add_argument("--no-preset", action="store_true")
|
|
parser.add_argument(
|
|
"--visa-library",
|
|
default="@ivi",
|
|
help="PyVISA IVI backend specification, e.g. @ivi or /usr/lib/x86_64-linux-gnu/libvisa.so",
|
|
)
|
|
return parser.parse_args()
|
|
|
|
|
|
def _validate_result(result, expected_points: int) -> None:
|
|
"""Raise RuntimeError unless the sweep has the expected point count, monotonic axis, and finite S11/S21."""
|
|
if result.x.shape != (expected_points,):
|
|
raise RuntimeError(f"Unexpected frequency shape: {result.x.shape}")
|
|
s11 = result.trace("s11")
|
|
s21 = result.trace("s21")
|
|
if s11.shape != (expected_points,) or s21.shape != (expected_points,):
|
|
raise RuntimeError(f"Unexpected trace shapes: s11={s11.shape}, s21={s21.shape}")
|
|
if not np.all(np.isfinite(result.x)):
|
|
raise RuntimeError("Frequency axis contains non-finite values")
|
|
if np.any(np.diff(result.x) < 0.0):
|
|
raise RuntimeError("Frequency axis is not monotonic")
|
|
if not np.all(np.isfinite(s11.real)) or not np.all(np.isfinite(s11.imag)):
|
|
raise RuntimeError("S11 contains non-finite values")
|
|
if not np.all(np.isfinite(s21.real)) or not np.all(np.isfinite(s21.imag)):
|
|
raise RuntimeError("S21 contains non-finite values")
|
|
|
|
|
|
def main() -> int:
|
|
"""Acquire one sweep from a locally connected K209 and validate it end to end.
|
|
|
|
Opens the VISA session, configures the sweep, validates the result, checks the SCPI
|
|
error queue, and prints a summary; raises on any validation or SCPI failure.
|
|
"""
|
|
args = _parse_args()
|
|
sweep = RadarSweepModel(
|
|
start_hz=args.start_hz,
|
|
stop_hz=args.stop_hz,
|
|
points=args.points,
|
|
if_bandwidth_hz=args.ifbw_hz,
|
|
power_dbm=args.power_dbm,
|
|
)
|
|
|
|
service = CompactMK209Service(
|
|
resource=args.resource,
|
|
timeout_ms=args.timeout_ms,
|
|
preset_on_open=not args.no_preset,
|
|
visa_library=args.visa_library,
|
|
)
|
|
try:
|
|
service.open()
|
|
print(f"K209 IDN: {service.query_identity()}")
|
|
service.configure(sweep)
|
|
result = service.acquire()
|
|
_validate_result(result, args.points)
|
|
system_error = service.query_system_error()
|
|
if not system_error.startswith("0,"):
|
|
raise RuntimeError(f"K209 SCPI error after sweep: {system_error}")
|
|
print(
|
|
"K209 sweep OK: "
|
|
f"points={result.x.size}, first_hz={result.x[0]:.3f}, last_hz={result.x[-1]:.3f}, "
|
|
f"mean_abs_s11={np.mean(np.abs(result.trace('s11'))):.6g}, "
|
|
f"mean_abs_s21={np.mean(np.abs(result.trace('s21'))):.6g}"
|
|
)
|
|
finally:
|
|
service.close()
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|