remoteRF-server 1.4.5__tar.gz → 1.4.7__tar.gz

{remoterf_server-1.4.5 → remoterf_server-1.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.4.5
+Version: 1.4.7
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3

{remoterf_server-1.4.5 → remoterf_server-1.4.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "1.4.5"
+version = "1.4.7"
 description = "RemoteRF server-side control package"
 license = { text = "GPL-3.0-or-later" }
 requires-python = ">=3.10"

{remoterf_server-1.4.5/src/remoteRF_server/drivers/adalm_pluto → remoterf_server-1.4.7/src/remoteRF_server/common/idl}/pluto_schema.py

@@ -46,8 +46,24 @@ def _normalize_channels(value):
 
 # == PLUTO Connection Logic ==
 
-def connect_pluto(*, serial: str):
+def connect_pluto(*, serial: str, ip: str = ""):
     serial = (serial or "").strip()
+    ip = (ip or "").strip()
+    if ip:
+        # An always-powered Pluto on the network (its static ipaddr_eth).
+        try:
+            dev = adi.Pluto(f"ip:{ip}")
+            found = str(dev._ctx.attrs.get("hw_serial", "")).strip()
+            if serial and found.lower() != serial.lower():
+                print(f"ip:{ip} is Pluto {found}, expected {serial}")
+                return None
+            from remoteRF_server.common.utils.ansi_codes import Sty, printf
+
+            printf(f"Connected to Pluto via ip:{ip}", Sty.GRAY)
+            return dev
+        except Exception as e:
+            print(f"Failed to connect to Pluto ip:{ip}: {e}")
+            return None
     if not serial:
         print("A Pluto serial must be provided")
         return None
@@ -88,7 +104,7 @@ class PlutoSchema(DeviceSchema):
 
     device_type = "adalm_pluto"
     client_class = "Pluto"
-    driver_version = "0.0.3"
+    driver_version = "0.0.4"
     _fir_rate = None  # the rate whose pyadi FIR this schema last loaded
 
     @staticmethod
@@ -96,8 +112,7 @@ class PlutoSchema(DeviceSchema):
         # init.poe: true -> the Pluto is powered from a PoE switch port and starts off.
         if is_poe(kwargs):
             return poe_pluto_from_init(kwargs)
-        serial = kwargs.get("serial")
-        return connect_pluto(serial=serial)
+        return connect_pluto(serial=kwargs.get("serial"), ip=kwargs.get("ip"))
 
     # region ad9364
 

remoterf_server-1.4.7/src/remoteRF_server/drivers/adalm_pluto/pluto_diag.py

@@ -0,0 +1,274 @@
+# Copyright (C) 2026 RemoteRF
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""`diag` tests for ADALM-Pluto (USB, PoE, MIMO). Nothing radiates: the tone
+tests use the AD936x internal digital loopback at the lowest TX gain, and a
+Multi-Tap's coax loopback (init `multi_tap: true`) stays at TX <= -10 dB."""
+
+from __future__ import annotations
+
+import time
+
+import numpy as np
+
+from remoteRF_server.drivers.adalm_pluto.poe import PoePluto
+from remoteRF_server.server.diag import Skip
+
+TX_MIN_DB = -89.75
+FS = 3_000_000
+TONE_N = 6000  # FS / TONE_N = 500 Hz: every offset below is a whole number of cycles
+RX_N = 8192
+OFFSETS = (100_000, 250_000, -300_000)
+MIN_SNR_DB = 20.0
+COAX_TX_DB = (-40, -30, -20, -10)  # never above -10 dB
+COAX_RX_DB = (10, 30, 50)
+SNAPSHOT = ("sample_rate", "rx_lo", "tx_lo", "rx_rf_bandwidth", "tx_rf_bandwidth",
+            "gain_control_mode_chan0", "rx_hardwaregain_chan0", "tx_hardwaregain_chan0", "rx_buffer_size",
+            "tx_cyclic_buffer", "loopback")
+MIMO_SNAPSHOT = ("tx_hardwaregain_chan1", "tx_enabled_channels", "rx_enabled_channels")
+
+
+def _poe(ctx):
+    native = ctx["schema"].device
+    return native if isinstance(native, PoePluto) else None
+
+
+def _rx(schema):
+    data = schema.device.rx()
+    return np.asarray(data[0] if isinstance(data, (list, tuple)) else data)
+
+
+def _close(got, want, tol, what):
+    if abs(float(got) - float(want)) > tol:
+        raise RuntimeError(f"{what}: set {want:.10g}, read back {float(got):.10g}")
+
+
+def power(ctx):
+    schema = ctx["schema"]
+    poe = _poe(ctx)
+    ctx["was_on"] = poe is None or poe.power_state == "on"
+    started = time.monotonic()
+    if poe is not None and not ctx["was_on"]:
+        poe.power_up()
+    rate = int(schema.get_sample_rate())
+    mimo = ctx.get("type") == "adalm_pluto_mimo"
+    ctx["snapshot"] = {name: getattr(schema, f"get_{name}")() for name in SNAPSHOT + (MIMO_SNAPSHOT if mimo else ())}
+    # Quiet the transmitter before anything retunes it: a boot-time DDS tone or a
+    # previous holder's cyclic buffer would otherwise follow the LO sweep on air.
+    schema.call_disable_dds()
+    schema.call_tx_destroy_buffer()
+    schema.set_tx_hardwaregain_chan0(TX_MIN_DB)
+    if mimo:  # every tone test sends and reads channel 0 only
+        schema.set_tx_hardwaregain_chan1(TX_MIN_DB)
+        schema.set_tx_enabled_channels([0])
+        schema.set_rx_enabled_channels([0])
+    if ctx["was_on"]:
+        return f"answering at {rate} S/s", {"sample_rate": rate}
+    took = round(time.monotonic() - started, 1)
+    return f"booted in {took} s", {"boot_s": took}
+
+
+def context(ctx):
+    attrs = dict(ctx["schema"].device._ctx.attrs)
+    values = {k: str(attrs[k]) for k in ("hw_model", "hw_serial", "fw_version", "ad9361-phy,model") if k in attrs}
+    if "hw_serial" not in values:
+        raise RuntimeError("IIO context has no hw_serial")
+    return f"{values.get('hw_model', 'Pluto')} fw {values.get('fw_version', '?')} sn {values['hw_serial']}", values
+
+
+def temperature(ctx):
+    dev = ctx["schema"].device
+    try:
+        celsius = float(dev._get_iio_attr("temp0", "input", False)) / 1000
+    except Exception:
+        raise Skip("no temperature sensor exposed")
+    if not 0 < celsius < 95:
+        raise RuntimeError(f"{celsius:.1f} °C is out of range")
+    return f"{celsius:.1f} °C", {"celsius": celsius}
+
+
+def sample_rates(ctx):
+    schema = ctx["schema"]
+    for rate in (1_000_000, 2_500_000, 10_000_000, 20_000_000, FS):
+        schema.set_sample_rate(rate)
+        _close(schema.get_sample_rate(), rate, rate * 0.01, "sample rate")
+    return "1, 2.5, 10, 20, 3 MS/s read back"
+
+
+def lo_tuning(ctx):
+    schema = ctx["schema"]
+    freqs = (400e6, 915e6, 2.4e9, 3.5e9)  # inside the stock AD9363 range
+    for f in freqs:
+        schema.set_rx_lo(int(f))
+        schema.set_tx_lo(int(f))
+        _close(schema.get_rx_lo(), f, 1e3, "RX LO")
+        _close(schema.get_tx_lo(), f, 1e3, "TX LO")
+    return "RX/TX LO 400 MHz-3.5 GHz read back"
+
+
+def bandwidth(ctx):
+    schema = ctx["schema"]
+    for bw in (1_000_000, 5_000_000, 18_000_000):
+        schema.set_rx_rf_bandwidth(bw)
+        schema.set_tx_rf_bandwidth(bw)
+        _close(schema.get_rx_rf_bandwidth(), bw, bw * 0.1, "RX bandwidth")
+        _close(schema.get_tx_rf_bandwidth(), bw, bw * 0.1, "TX bandwidth")
+    return "RX/TX 1, 5, 18 MHz read back"
+
+
+def gains(ctx):
+    schema = ctx["schema"]
+    schema.call_disable_dds()  # nothing queued for TX while its gain moves
+    for mode in ("slow_attack", "fast_attack", "manual"):
+        schema.set_gain_control_mode_chan0(mode)
+        if schema.get_gain_control_mode_chan0() != mode:
+            raise RuntimeError(f"gain mode {mode} did not stick")
+    for gain in (10, 30, 50):
+        schema.set_rx_hardwaregain_chan0(gain)
+        _close(schema.get_rx_hardwaregain_chan0(), gain, 1, "RX gain")
+    for gain in (-60, -75, TX_MIN_DB):
+        schema.set_tx_hardwaregain_chan0(gain)
+        _close(schema.get_tx_hardwaregain_chan0(), gain, 0.5, "TX gain")
+    return "3 gain modes, RX 10/30/50 dB, TX -60/-75/-89.75 dB"
+
+
+def rx_buffers(ctx):
+    schema = ctx["schema"]
+    schema.set_sample_rate(FS)
+    schema.set_gain_control_mode_chan0("manual")
+    schema.set_rx_hardwaregain_chan0(30)
+    schema.set_rx_buffer_size(RX_N)
+    power = []
+    for _ in range(3):
+        data = _rx(schema)
+        if data.size != RX_N:
+            raise RuntimeError(f"read {data.size} samples, expected {RX_N}")
+        if not np.all(np.isfinite(data)) or not np.any(data):
+            raise RuntimeError("buffer is all zero or not finite")
+        power.append(float(np.mean(np.abs(data) ** 2)))
+    dbfs = round(10 * np.log10(max(np.mean(power), 1e-12) / 2**22), 1)
+    return f"3 x {RX_N} samples, {dbfs} dBFS", {"rx_dbfs": dbfs}
+
+
+def _tone(schema, offset, tx_db, rx_db):
+    """Peak frequency and SNR (dB) of a tone at `offset` Hz sent TX -> RX."""
+    schema.set_tx_hardwaregain_chan0(tx_db)
+    schema.set_gain_control_mode_chan0("manual")
+    schema.set_rx_hardwaregain_chan0(rx_db)
+    n = np.arange(TONE_N)
+    schema.call_tx_destroy_buffer()
+    schema.set_tx_cyclic_buffer(True)
+    schema.call_tx(0.5 * 2**14 * np.exp(2j * np.pi * offset * n / FS))
+    try:
+        schema.call_rx_destroy_buffer()
+        for _ in range(2):  # the first buffers can predate the tone
+            _rx(schema)
+        data = _rx(schema)
+    finally:
+        schema.call_tx_destroy_buffer()
+    spectrum = np.abs(np.fft.fftshift(np.fft.fft(data * np.hanning(data.size)))) ** 2
+    freqs = np.fft.fftshift(np.fft.fftfreq(data.size, 1 / FS))
+    peak = int(np.argmax(spectrum))
+    snr = 10 * np.log10(max(float(spectrum[peak]), 1e-30) / max(float(np.median(spectrum)), 1e-30))
+    return float(freqs[peak]), round(float(snr), 1)
+
+
+def _prepare_tone(schema, lo):
+    schema.set_sample_rate(FS)
+    schema.set_rx_lo(int(lo))
+    schema.set_tx_lo(int(lo))
+    schema.set_rx_buffer_size(RX_N)
+
+
+def loopback_tone(ctx):
+    schema = ctx["schema"]
+    _prepare_tone(schema, 915e6)
+    values = {}
+    schema.set_loopback(1)  # AD936x digital TX -> RX, inside the chip
+    try:
+        for offset in OFFSETS:
+            peak, snr = _tone(schema, offset, TX_MIN_DB, 10)
+            values[f"{offset // 1000:+d}kHz"] = {"peak_hz": peak, "snr_db": snr}
+            if abs(peak - offset) > 5_000:
+                raise RuntimeError(f"tone at {offset / 1e3:+g} kHz came back at {peak / 1e3:+.1f} kHz")
+            if snr < MIN_SNR_DB:
+                raise RuntimeError(f"tone at {offset / 1e3:+g} kHz: SNR {snr} dB < {MIN_SNR_DB}")
+    finally:
+        schema.set_loopback(0)
+    worst = min(v["snr_db"] for v in values.values())
+    return f"{len(OFFSETS)} offsets found, SNR >= {worst} dB", values
+
+
+def coax_loopback(ctx):
+    if not ctx["init"].get("multi_tap"):
+        raise Skip("not a Multi-Tap")
+    schema = ctx["schema"]
+    _prepare_tone(schema, 915e6)
+    schema.set_loopback(0)
+    for tx_db in COAX_TX_DB:
+        for rx_db in COAX_RX_DB:
+            peak, snr = _tone(schema, OFFSETS[0], tx_db, rx_db)
+            if abs(peak - OFFSETS[0]) <= 5_000 and snr >= MIN_SNR_DB:
+                return f"tone at TX {tx_db} dB / RX {rx_db} dB, SNR {snr} dB", {
+                    "tx_db": tx_db, "rx_db": rx_db, "snr_db": snr}
+    raise RuntimeError(f"no tone over the coax up to TX {COAX_TX_DB[-1]} dB / RX {COAX_RX_DB[-1]} dB")
+
+
+def _boot_s(schema):
+    """A PoE Pluto in standby boots in ~30 s."""
+    native = schema.device
+    return 30 if isinstance(native, PoePluto) and native.power_state != "on" else 1
+
+
+# (name, typical s, timeout s, fn); the first is the gate.
+TESTS = [
+    ("power", _boot_s, 100, power),
+    ("iio context", 1, 10, context),
+    ("temperature", 1, 10, temperature),
+    ("sample rate", 5, 40, sample_rates),
+    ("lo tuning", 3, 30, lo_tuning),
+    ("bandwidth", 2, 20, bandwidth),
+    ("gain", 2, 20, gains),
+    ("rx buffers", 2, 20, rx_buffers),
+    ("loopback tone", 4, 40, loopback_tone),
+    ("coax loopback", 2, 60, coax_loopback),
+]
+
+
+def teardown(ctx):
+    """Stop TX; a PoE Pluto that was in standby goes back to it unless now reserved,
+    anything else gets its settings back."""
+    schema = ctx["schema"]
+    poe = _poe(ctx)
+    if poe is not None and not ctx.get("was_on", True) and not ctx["reserved"]():
+        schema.call_power_down()
+        return
+    schema.call_tx_destroy_buffer()
+    schema.call_rx_destroy_buffer()
+    schema.set_loopback(0)
+    snapshot = dict(ctx.get("snapshot", {}))
+    if snapshot.get("gain_control_mode_chan0") != "manual":
+        snapshot.pop("rx_hardwaregain_chan0", None)  # an AGC mode owns it
+    failed = []
+    for name, value in snapshot.items():
+        try:
+            getattr(schema, f"set_{name}")(value)
+        except Exception:
+            failed.append(name)
+    if failed:
+        raise RuntimeError(f"could not restore {', '.join(failed)}")
+
+
+TEARDOWN_S = (2, 30)

{remoterf_server-1.4.5/src/remoteRF_server/common/idl → remoterf_server-1.4.7/src/remoteRF_server/drivers/adalm_pluto}/pluto_schema.py

@@ -46,8 +46,24 @@ def _normalize_channels(value):
 
 # == PLUTO Connection Logic ==
 
-def connect_pluto(*, serial: str):
+def connect_pluto(*, serial: str, ip: str = ""):
     serial = (serial or "").strip()
+    ip = (ip or "").strip()
+    if ip:
+        # An always-powered Pluto on the network (its static ipaddr_eth).
+        try:
+            dev = adi.Pluto(f"ip:{ip}")
+            found = str(dev._ctx.attrs.get("hw_serial", "")).strip()
+            if serial and found.lower() != serial.lower():
+                print(f"ip:{ip} is Pluto {found}, expected {serial}")
+                return None
+            from remoteRF_server.common.utils.ansi_codes import Sty, printf
+
+            printf(f"Connected to Pluto via ip:{ip}", Sty.GRAY)
+            return dev
+        except Exception as e:
+            print(f"Failed to connect to Pluto ip:{ip}: {e}")
+            return None
     if not serial:
         print("A Pluto serial must be provided")
         return None
@@ -88,7 +104,7 @@ class PlutoSchema(DeviceSchema):
 
     device_type = "adalm_pluto"
     client_class = "Pluto"
-    driver_version = "0.0.3"
+    driver_version = "0.0.4"
     _fir_rate = None  # the rate whose pyadi FIR this schema last loaded
 
     @staticmethod
@@ -96,8 +112,7 @@ class PlutoSchema(DeviceSchema):
         # init.poe: true -> the Pluto is powered from a PoE switch port and starts off.
         if is_poe(kwargs):
             return poe_pluto_from_init(kwargs)
-        serial = kwargs.get("serial")
-        return connect_pluto(serial=serial)
+        return connect_pluto(serial=kwargs.get("serial"), ip=kwargs.get("ip"))
 
     # region ad9364
 

remoterf_server-1.4.7/src/remoteRF_server/drivers/bluetooth_diag.py

@@ -0,0 +1,51 @@
+# Copyright (C) 2026 RemoteRF
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""`diag` tests for a Bluetooth adapter (contrib/drivers/bluetooth_schema.py)."""
+
+from __future__ import annotations
+
+SCAN_S = 5
+
+
+def powered(ctx):
+    schema = ctx["schema"]
+    if not schema.get_powered():
+        raise RuntimeError("adapter is not powered")
+    return f"{schema.get_address()} powered", {"address": str(schema.get_address())}
+
+
+def scan(ctx):
+    summary = ctx["schema"].call_scan_summary(timeout=SCAN_S)
+    if not isinstance(summary, dict):
+        raise RuntimeError("scan returned nothing")
+    count = summary.get("total_devices", "?")
+    return f"{SCAN_S} s scan, {count} devices nearby", {"devices": count}
+
+
+TESTS = [
+    ("adapter", 1, 10, powered),
+    ("scan", SCAN_S, SCAN_S + 15, scan),
+]
+
+
+def teardown(ctx):
+    """The next holder must not read diag's scan of nearby devices."""
+    native = ctx["schema"].device
+    native.device_cache = {}
+    native.last_scan_time = 0.0
+
+
+TEARDOWN_S = (0, 5)

remoterf_server-1.4.7/src/remoteRF_server/drivers/gps_diag.py

@@ -0,0 +1,77 @@
+# Copyright (C) 2026 RemoteRF
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""`diag` tests for an NMEA GPS receiver (contrib/drivers/gps_schema.py)."""
+
+from __future__ import annotations
+
+import time
+from functools import reduce
+
+from remoteRF_server.server.diag import Skip
+
+LISTEN_S = 6
+
+
+def _checksum_ok(line: str) -> bool:
+    body, _, given = line.strip().lstrip("$").partition("*")
+    try:
+        return reduce(lambda a, c: a ^ ord(c), body, 0) == int(given[:2], 16)
+    except ValueError:
+        return False
+
+
+def liveness(ctx):
+    schema = ctx["schema"]
+    first = list(schema.call_read_raw(50))
+    end = time.monotonic() + LISTEN_S
+    while time.monotonic() < end:
+        time.sleep(0.5)
+        now = list(schema.call_read_raw(50))
+        if now and now != first:
+            ctx["lines"] = now
+            return f"new sentences within {LISTEN_S} s", {"sentences": len(now)}
+    raise RuntimeError(f"no new NMEA sentence in {LISTEN_S} s")
+
+
+def sentence_types(ctx):
+    kinds = sorted({line.strip().lstrip("$").split(",")[0][2:] for line in ctx["lines"] if line.strip().startswith("$")})
+    if not {"GGA", "RMC"} & set(kinds):
+        raise RuntimeError(f"no GGA or RMC among {', '.join(kinds) or 'nothing'}")
+    return ", ".join(kinds), {"types": kinds}
+
+
+def parse(ctx):
+    lines = [l for l in ctx["lines"] if "*" in l]
+    good = sum(_checksum_ok(l) for l in lines)
+    if not lines or good < 0.8 * len(lines):
+        raise RuntimeError(f"{good} of {len(lines)} checksums valid")
+    return f"{good}/{len(lines)} checksums valid", {"valid": good, "total": len(lines)}
+
+
+def fix(ctx):
+    schema = ctx["schema"]
+    if not schema.get_has_fix():
+        raise Skip("no fix yet (optional)")
+    values = {"satellites": int(schema.get_satellites()), "quality": int(schema.get_fix_quality())}
+    return f"fix, {values['satellites']} satellites", values
+
+
+TESTS = [
+    ("nmea liveness", LISTEN_S, LISTEN_S + 5, liveness),
+    ("sentence types", 0, 5, sentence_types),
+    ("checksums", 0, 5, parse),
+    ("fix", 0, 5, fix),
+]

remoterf_server-1.4.7/src/remoteRF_server/drivers/rtl_sdr/rtl_sdr_diag.py

@@ -0,0 +1,116 @@
+# Copyright (C) 2026 RemoteRF
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""`diag` tests for RTL-SDR (receive only)."""
+
+from __future__ import annotations
+
+import numpy as np
+
+SNAPSHOT = ("sample_rate", "center_freq", "gain")
+
+
+def _close(got, want, tol, what):
+    if abs(float(got) - float(want)) > tol:
+        raise RuntimeError(f"{what}: set {want:.10g}, read back {float(got):.10g}")
+
+
+def tuner(ctx):
+    schema = ctx["schema"]
+    ctx["snapshot"] = {name: getattr(schema, f"get_{name}")() for name in SNAPSHOT}
+    values = {"tuner": str(schema.get_tuner_type()), "serial": str(schema.get_serial_number() or "")}
+    return f"tuner {values['tuner']}, sn {values['serial'] or '-'}", values
+
+
+def sample_rates(ctx):
+    schema = ctx["schema"]
+    for rate in (1_024_000, 2_048_000, 2_400_000):
+        schema.set_sample_rate(rate)
+        _close(schema.get_sample_rate(), rate, rate * 0.01, "sample rate")
+    return "1.024, 2.048, 2.4 MS/s read back"
+
+
+def center_freqs(ctx):
+    schema = ctx["schema"]
+    for f in (100e6, 433.92e6, 915e6, 1.5e9):
+        schema.set_center_freq(int(f))
+        _close(schema.get_center_freq(), f, 10e3, "center frequency")
+    return "100 MHz-1.5 GHz read back"
+
+
+def gains(ctx):
+    schema = ctx["schema"]
+    valid = sorted(float(g) for g in schema.get_valid_gains_db())
+    if not valid:
+        raise RuntimeError("tuner reports no gains")
+    unreported = 0
+    for gain in (valid[0], valid[len(valid) // 2], valid[-1]):
+        schema.set_gain(gain)
+        got = schema.get_gain()
+        if gain and not float(got):  # RTL-SDR Blog V4 (R828D) reads 0 for any manual gain
+            unreported += 1
+            continue
+        _close(got, gain, 1, "gain")
+    note = ", tuner does not report gain" if unreported else ""
+    return f"{len(valid)} gains, {valid[0]:g}-{valid[-1]:g} dB set{note}", {"gains": len(valid)}
+
+
+def byte_reads(ctx):
+    schema = ctx["schema"]
+    schema.set_sample_rate(2_048_000)
+    schema.set_center_freq(100_000_000)
+    try:
+        schema.call_reset_buffer()
+    except Exception:  # noqa: BLE001 - optional in pyrtlsdr; the server's reads never need it
+        pass
+    for n in (512, 512 * 32, 512 * 256):
+        data = np.frombuffer(bytes(schema.call_read_bytes(n)), dtype=np.uint8)
+        if data.size != n or data.size % 512:
+            raise RuntimeError(f"asked {n} bytes, got {data.size}")
+    mean = float(data.mean())
+    if data.std() == 0:
+        raise RuntimeError(f"every byte is {int(data[0])}")
+    if not 64 < mean < 192:
+        raise RuntimeError(f"bytes average {mean:.0f}, expected near 127.5")
+    return f"512 / 16 KiB / 128 KiB reads, mean {mean:.1f}", {"byte_mean": round(mean, 1)}
+
+
+def samples(ctx):
+    data = np.asarray(ctx["schema"].call_read_samples(16384))
+    if data.size != 16384 or not np.all(np.isfinite(data)):
+        raise RuntimeError("short or non-finite IQ read")
+    dc = float(abs(data.mean()))
+    if dc > 0.5 or float(data.std()) == 0:
+        raise RuntimeError(f"IQ looks stuck (dc {dc:.2f})")
+    return f"16384 IQ samples, dc {dc:.3f}", {"dc": round(dc, 4)}
+
+
+# (name, typical s, timeout s, fn); the first is the gate.
+TESTS = [
+    ("tuner", 1, 10, tuner),
+    ("sample rate", 1, 15, sample_rates),
+    ("center freq", 1, 15, center_freqs),
+    ("gain", 1, 15, gains),
+    ("byte reads", 1, 15, byte_reads),
+    ("iq samples", 1, 15, samples),
+]
+
+
+def teardown(ctx):
+    for name, value in ctx.get("snapshot", {}).items():
+        getattr(ctx["schema"], f"set_{name}")(value)
+
+
+TEARDOWN_S = (1, 10)