rf-bench 0.2.0__py3-none-any.whl

rf_bench/__init__.py

@@ -0,0 +1,138 @@
+"""
+rf_bench — Python drivers and RF utilities for bench instrument automation
+
+Drivers connect via raw TCP/SCPI (Siglent instruments, port 5025) or Hamlib
+rigctld (radios, port 4532). No NI-VISA or pyvisa required.
+
+Subpackages::
+
+    rf_bench.siglent   — SSA3000X, SDG1000X, SDS2000X, SDM3000X, SPD3303X
+    rf_bench.icom      — IC7300
+    rf_bench.yaesu     — FT891
+    rf_bench.utils     — RF math: conversions, noise, impedance, propagation,
+                         passive components, attenuators, IM products, S-meter
+
+All public symbols are re-exported here for convenience::
+
+    from rf_bench import SDG1000X, SPD3303X, IC7300, FT891, dbm_to_vpp, format_freq
+
+Or import from subpackages directly::
+
+    from rf_bench.siglent import SSA3000X, SDG1000X, SDM3000X, SPD3303X
+    from rf_bench.icom import IC7300
+    from rf_bench.utils import thermal_noise_floor, cascaded_noise_figure, pi_attenuator
+"""
+
+# Instrument classes
+from .siglent import (
+    SSA3000X, SDG1000X, SDS2000X, DBM_MIN, DBM_MAX,
+    SDM3000X, SDM_RANGE_AUTO,
+    SPD3303X, TRACKING_INDEPENDENT, TRACKING_SERIES, TRACKING_PARALLEL,
+)
+from .icom   import IC7300
+from .yaesu  import FT891, PREAMP_OFF, PREAMP_AMP1
+
+# RF utilities — re-exported flat for convenience
+from .utils import (
+    # Constants
+    SPEED_OF_LIGHT, S9_HF_DBM, S9_VHF_DBM,
+    # Power / voltage
+    dbm_to_vpp, vpp_to_dbm,
+    dbm_to_vrms, vrms_to_dbm,
+    dbm_to_watts, watts_to_dbm,
+    dbm_to_uv, uv_to_dbm,
+    # Power ratio / extended dB
+    db_to_linear, linear_to_db,
+    db_to_voltage_ratio, voltage_ratio_to_db,
+    dbm_to_dbw, dbw_to_dbm,
+    dbm_to_dbuv, dbuv_to_dbm,
+    # Impedance / reflection
+    rl_to_vswr, vswr_to_rl,
+    gamma_to_vswr, vswr_to_gamma,
+    rl_to_gamma, gamma_to_rl,
+    rl_to_vswr_v, vswr_to_rl_v, gamma_to_vswr_v,
+    # Noise and dynamic range
+    thermal_noise_floor,
+    noise_figure_from_mds, mds_from_noise_figure,
+    ip3_from_imd, ip3_to_dynamic_range,
+    cascaded_noise_figure,
+    noise_temp_to_nf, nf_to_noise_temp,
+    # Propagation / antenna
+    wavelength, quarter_wave, half_wave,
+    freespace_path_loss,
+    # Passive components
+    capacitive_reactance, inductive_reactance,
+    lc_resonant_freq, l_from_resonant, c_from_resonant,
+    q_factor, bw_from_q,
+    parallel_resistance, voltage_divider,
+    skin_depth,
+    # Attenuator design
+    pi_attenuator, t_attenuator,
+    # IM products
+    intermod_products,
+    # S-meter
+    s_unit_to_dbm, dbm_to_s_unit,
+    # Formatting
+    format_freq, format_freq_short,
+    # Standard value series
+    nearest_rbw, nearest_value,
+    SIGLENT_RBW_SERIES, E12_SERIES, E24_SERIES, E48_SERIES, E96_SERIES,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    # Siglent instruments
+    "SSA3000X",
+    "SDG1000X", "DBM_MIN", "DBM_MAX",
+    "SDS2000X",
+    "SDM3000X", "SDM_RANGE_AUTO",
+    "SPD3303X", "TRACKING_INDEPENDENT", "TRACKING_SERIES", "TRACKING_PARALLEL",
+    # Icom
+    "IC7300",
+    # Yaesu
+    "FT891", "PREAMP_OFF", "PREAMP_AMP1",
+    # Constants
+    "SPEED_OF_LIGHT", "S9_HF_DBM", "S9_VHF_DBM",
+    # Power / voltage
+    "dbm_to_vpp", "vpp_to_dbm",
+    "dbm_to_vrms", "vrms_to_dbm",
+    "dbm_to_watts", "watts_to_dbm",
+    "dbm_to_uv", "uv_to_dbm",
+    # Power ratio / extended dB
+    "db_to_linear", "linear_to_db",
+    "db_to_voltage_ratio", "voltage_ratio_to_db",
+    "dbm_to_dbw", "dbw_to_dbm",
+    "dbm_to_dbuv", "dbuv_to_dbm",
+    # Impedance / reflection
+    "rl_to_vswr", "vswr_to_rl",
+    "gamma_to_vswr", "vswr_to_gamma",
+    "rl_to_gamma", "gamma_to_rl",
+    "rl_to_vswr_v", "vswr_to_rl_v", "gamma_to_vswr_v",
+    # Noise and dynamic range
+    "thermal_noise_floor",
+    "noise_figure_from_mds", "mds_from_noise_figure",
+    "ip3_from_imd", "ip3_to_dynamic_range",
+    "cascaded_noise_figure",
+    "noise_temp_to_nf", "nf_to_noise_temp",
+    # Propagation / antenna
+    "wavelength", "quarter_wave", "half_wave",
+    "freespace_path_loss",
+    # Passive components
+    "capacitive_reactance", "inductive_reactance",
+    "lc_resonant_freq", "l_from_resonant", "c_from_resonant",
+    "q_factor", "bw_from_q",
+    "parallel_resistance", "voltage_divider",
+    "skin_depth",
+    # Attenuator design
+    "pi_attenuator", "t_attenuator",
+    # IM products
+    "intermod_products",
+    # S-meter
+    "s_unit_to_dbm", "dbm_to_s_unit",
+    # Formatting
+    "format_freq", "format_freq_short",
+    # Standard value series
+    "nearest_rbw", "nearest_value",
+    "SIGLENT_RBW_SERIES", "E12_SERIES", "E24_SERIES", "E48_SERIES", "E96_SERIES",
+]

rf_bench/icom/__init__.py

@@ -0,0 +1,5 @@
+"""rf_bench.icom — Icom transceiver drivers via Hamlib rigctld"""
+
+from .ic7300 import IC7300
+
+__all__ = ["IC7300"]

rf_bench/icom/ic7300.py

@@ -0,0 +1,213 @@
+"""
+ic7300.py — Icom IC-7300 CAT control via Hamlib rigctld
+
+Communicates with rigctld over a plain TCP socket on port 4532.
+rigctld must be running before any test is started:
+
+    rigctld -m 3073 -r /dev/ttyUSB0 -s 115200 &
+
+Hamlib model numbers: 3073 (Hamlib 4.x), 373 (Hamlib 3.x).
+
+The IC-7300 CI-V baud rate must match (Menu → Set → Connectors → CI-V Baud Rate).
+"""
+
+import socket
+import time
+
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+DEFAULT_HOST = "localhost"
+DEFAULT_PORT = 4532
+CONNECT_TIMEOUT = 5    # seconds
+RECV_TIMEOUT    = 3    # seconds
+RECV_BUFSIZE    = 4096
+
+# AGC mode values as sent to rigctld set_level AGC
+AGC_OFF   = 0
+AGC_FAST  = 1
+AGC_MID   = 2   # "medium" on IC-7300 front panel
+AGC_SLOW  = 3
+
+# Mode strings understood by Hamlib
+MODES = {"usb": "USB", "lsb": "LSB", "cw": "CW", "cwr": "CWR",
+         "am": "AM", "fm": "FM", "rtty": "RTTY"}
+
+# Standard passband widths (Hz) by mode — used as default if not specified
+DEFAULT_PASSBAND = {"USB": 2400, "LSB": 2400, "CW": 500, "CWR": 500,
+                    "AM": 6000, "FM": 15000, "RTTY": 500}
+
+
+# ---------------------------------------------------------------------------
+# Driver class
+# ---------------------------------------------------------------------------
+
+class IC7300:
+    """
+    IC-7300 CAT driver via Hamlib rigctld.
+
+    All frequency values are in Hz. get_strength() returns a numeric value
+    whose scale depends on the Hamlib version and calibration; use the
+    smeter-cal test to map it to dBm.
+
+    Usage:
+        rig = IC7300()
+        rig.set_mode("usb")
+        rig.set_frequency(14_200_000)
+        rig.set_agc("off")
+        strength = rig.get_strength()
+        rig.close()
+    """
+
+    def __init__(self, host: str = DEFAULT_HOST, port: int = DEFAULT_PORT):
+        self._host = host
+        self._port = port
+        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._sock.settimeout(CONNECT_TIMEOUT)
+        self._sock.connect((host, port))
+        self._sock.settimeout(RECV_TIMEOUT)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def get_frequency(self) -> float:
+        """Return current VFO-A frequency in Hz."""
+        resp = self._cmd("\\get_freq")
+        try:
+            # rigctld responds with just the number, or "Frequency: <n>"
+            return float(resp.split()[-1])
+        except (ValueError, IndexError):
+            return 0.0
+
+    def set_frequency(self, freq_hz: float) -> None:
+        """Set VFO-A frequency in Hz."""
+        self._cmd(f"\\set_freq {int(freq_hz)}")
+        time.sleep(0.1)   # give the IC-7300 time to tune
+
+    def get_mode(self) -> tuple[str, int]:
+        """
+        Return current (mode_string, passband_hz).
+        Mode string is a Hamlib mode name e.g. "USB", "CW".
+        """
+        resp = self._cmd("\\get_mode")
+        lines = resp.strip().splitlines()
+        mode = lines[0].strip() if lines else "?"
+        try:
+            passband = int(lines[1].strip()) if len(lines) > 1 else 0
+        except ValueError:
+            passband = 0
+        return mode, passband
+
+    def set_mode(self, mode: str, passband_hz: int = 0) -> None:
+        """
+        Set receiver mode.
+
+        Args:
+            mode:        One of 'usb', 'lsb', 'cw', 'cwr', 'am', 'fm', 'rtty'
+            passband_hz: IF filter width in Hz. 0 = use rig default.
+        """
+        ham_mode = MODES.get(mode.lower(), mode.upper())
+        if passband_hz == 0:
+            passband_hz = DEFAULT_PASSBAND.get(ham_mode, 0)
+        self._cmd(f"\\set_mode {ham_mode} {passband_hz}")
+        time.sleep(0.15)
+
+    def get_strength(self) -> float:
+        """
+        Return the S-meter / signal strength level.
+
+        Hamlib returns STRENGTH as a float. For the IC-7300 via Hamlib 4.x
+        this is typically in dB relative to S9 (range ≈ −54 to +60 dB).
+        The exact mapping depends on the Hamlib version; use smeter-cal to
+        characterize the specific rig/version combination.
+
+        Returns NaN if the read fails.
+        """
+        resp = self._cmd("\\get_level STRENGTH")
+        try:
+            return float(resp.split()[-1])
+        except (ValueError, IndexError):
+            return float("nan")
+
+    def get_strength_settled(self, settle_s: float = 0.5, samples: int = 3) -> float:
+        """
+        Wait settle_s seconds then take the average of `samples` strength readings.
+
+        Use after changing SDG level to let the IC-7300's AGC settle before reading.
+        """
+        time.sleep(settle_s)
+        readings = []
+        for _ in range(samples):
+            v = self.get_strength()
+            if not float("nan") == v:  # isnan check
+                readings.append(v)
+            time.sleep(0.1)
+        if not readings:
+            return float("nan")
+        return sum(readings) / len(readings)
+
+    def set_agc(self, mode: str) -> None:
+        """
+        Set AGC mode.
+
+        Args:
+            mode: 'off', 'fast', 'mid', or 'slow'
+        """
+        agc_map = {"off": AGC_OFF, "fast": AGC_FAST, "mid": AGC_MID, "slow": AGC_SLOW}
+        val = agc_map.get(mode.lower())
+        if val is None:
+            raise ValueError(f"AGC mode must be one of {list(agc_map)}, got {mode!r}")
+        self._cmd(f"\\set_level AGC {val}")
+        time.sleep(0.1)
+
+    def get_agc(self) -> int:
+        """Return current AGC value (0=off, 1=fast, 2=mid, 3=slow)."""
+        resp = self._cmd("\\get_level AGC")
+        try:
+            return int(float(resp.split()[-1]))
+        except (ValueError, IndexError):
+            return -1
+
+    def set_rf_gain(self, gain: float) -> None:
+        """
+        Set RF gain (0.0 – 1.0, where 1.0 = maximum gain).
+        With AGC off, this directly controls receiver sensitivity.
+        """
+        self._cmd(f"\\set_level RFGAIN {gain:.3f}")
+
+    def close(self) -> None:
+        """Close the rigctld connection."""
+        self._sock.close()
+
+    # ------------------------------------------------------------------
+    # Context manager
+    # ------------------------------------------------------------------
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _cmd(self, cmd: str) -> str:
+        """Send a command to rigctld and return the response."""
+        self._sock.sendall((cmd + "\n").encode())
+        time.sleep(0.05)
+        try:
+            resp = b""
+            while True:
+                chunk = self._sock.recv(RECV_BUFSIZE)
+                resp += chunk
+                # rigctld responses end with a newline (or blank line for multi-line)
+                if resp.endswith(b"\n"):
+                    break
+            return resp.decode(errors="replace").strip()
+        except socket.timeout:
+            return ""

rf_bench/siglent/__init__.py

@@ -0,0 +1,23 @@
+"""rf_bench.siglent — Siglent instrument drivers (SCPI over raw TCP, port 5025)"""
+
+from .ssa3000x import SSA3000X
+from .sdg1000x import SDG1000X, DBM_MIN, DBM_MAX
+from .sds2000x import SDS2000X
+from .sdm3000x import SDM3000X, RANGE_AUTO as SDM_RANGE_AUTO
+from .spd3303x import (
+    SPD3303X,
+    TRACKING_INDEPENDENT, TRACKING_SERIES, TRACKING_PARALLEL,
+)
+
+__all__ = [
+    # Spectrum analyzer
+    "SSA3000X",
+    # Function generator
+    "SDG1000X", "DBM_MIN", "DBM_MAX",
+    # Oscilloscope
+    "SDS2000X",
+    # Bench multimeter
+    "SDM3000X", "SDM_RANGE_AUTO",
+    # Triple-output power supply
+    "SPD3303X", "TRACKING_INDEPENDENT", "TRACKING_SERIES", "TRACKING_PARALLEL",
+]

rf_bench/siglent/sdg1000x.py

@@ -0,0 +1,220 @@
+"""
+sdg1000x.py — Siglent SDG1000X function generator driver
+
+Connects via raw TCP/SCPI to port 5025. Uses Siglent's EasyWave protocol
+(C1:BSWV / C2:BSWV commands), not standard IEEE SCPI. Both channels are
+independent; each can be set to different frequencies and levels simultaneously.
+
+Model: Siglent SDG1000X series
+Default address: 10.1.1.61:5025
+
+Amplitude notes:
+    All public methods accept and return dBm (into 50 Ω).
+    Internally the SDG uses Vpp across its configured load impedance.
+    With LOAD,50 the displayed/set amplitude IS the voltage across the 50 Ω load.
+    Conversion is handled by rf_utils.dbm_to_vpp / vpp_to_dbm.
+
+Known firmware behavior:
+    Some SDG firmware versions ignore the LOAD parameter inside BSWV and require
+    a separate `C1:OUTP ON,LOAD,50` to set the termination. Always enable output
+    with the LOAD parameter explicit (output_on() handles this).
+"""
+
+import socket
+import time
+
+from ..utils.rf_utils import dbm_to_vpp, vpp_to_dbm
+
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+DEFAULT_HOST = "10.1.1.61"
+DEFAULT_PORT = 5025
+CONNECT_TIMEOUT = 10      # seconds
+RECV_TIMEOUT    = 5       # seconds
+RECV_BUFSIZE    = 65536
+
+# SDG1000X amplitude limits (Vpp into 50 Ω)
+VPP_MIN_50 = 0.002   # 2 mVpp ≈ −46 dBm; waveform quality degrades below ~10 mVpp
+VPP_MAX_50 = 10.0    # 10 Vpp ≈ +24 dBm
+
+DBM_MIN = vpp_to_dbm(VPP_MIN_50)   # ≈ −46 dBm
+DBM_MAX = vpp_to_dbm(VPP_MAX_50)   # ≈ +24 dBm
+
+
+# ---------------------------------------------------------------------------
+# Driver class
+# ---------------------------------------------------------------------------
+
+class SDG1000X:
+    """
+    Driver for the Siglent SDG1000X dual-channel function generator.
+
+    Usage:
+        sdg = SDG1000X("10.1.1.61")
+        sdg.set_sine(1, freq_hz=14_001_000, level_dbm=-20)
+        sdg.set_sine(2, freq_hz=14_001_500, level_dbm=-20)
+        sdg.output_on(1)
+        sdg.output_on(2)
+        ...
+        sdg.output_off_all()
+        sdg.close()
+
+    Context manager:
+        with SDG1000X("10.1.1.61") as sdg:
+            sdg.set_sine(1, 14e6, -20)
+            sdg.output_on(1)
+            ...
+    """
+
+    def __init__(self, host: str = DEFAULT_HOST, port: int = DEFAULT_PORT):
+        self._host = host
+        self._port = port
+        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._sock.settimeout(CONNECT_TIMEOUT)
+        self._sock.connect((host, port))
+        self._sock.settimeout(RECV_TIMEOUT)
+        # Drain any startup banner
+        time.sleep(0.1)
+        try:
+            self._sock.recv(RECV_BUFSIZE)
+        except socket.timeout:
+            pass
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def identify(self) -> str:
+        """Return IDN string."""
+        return self._query("*IDN?")
+
+    def set_sine(self, channel: int, freq_hz: float, level_dbm: float,
+                 phase_deg: float = 0.0) -> None:
+        """
+        Configure a channel for sine wave output.
+
+        Args:
+            channel:   1 or 2
+            freq_hz:   Frequency in Hz (1 μHz to 60 MHz)
+            level_dbm: Output level in dBm into 50 Ω
+            phase_deg: Phase offset in degrees [default 0]
+
+        The channel output is NOT enabled by this call; follow with output_on().
+        """
+        self._check_channel(channel)
+        self._check_level(level_dbm)
+
+        vpp = dbm_to_vpp(level_dbm)
+        ch  = f"C{channel}"
+        self._cmd(
+            f"{ch}:BSWV WVTP,SINE,"
+            f"FRQ,{freq_hz:.6f},"
+            f"AMP,{vpp:.6f},"
+            f"OFST,0,"
+            f"PHSE,{phase_deg:.3f}"
+        )
+
+    def output_on(self, channel: int) -> None:
+        """Enable output on the specified channel with 50 Ω termination."""
+        self._check_channel(channel)
+        self._cmd(f"C{channel}:OUTP ON,LOAD,50")
+
+    def output_off(self, channel: int) -> None:
+        """Disable output on the specified channel."""
+        self._check_channel(channel)
+        self._cmd(f"C{channel}:OUTP OFF")
+
+    def output_off_all(self) -> None:
+        """Disable both channel outputs."""
+        self.output_off(1)
+        self.output_off(2)
+
+    def set_level(self, channel: int, level_dbm: float) -> None:
+        """
+        Change only the output level of a configured channel (preserves frequency).
+        """
+        self._check_channel(channel)
+        self._check_level(level_dbm)
+        vpp = dbm_to_vpp(level_dbm)
+        self._cmd(f"C{channel}:BSWV AMP,{vpp:.6f}")
+
+    def query_channel(self, channel: int) -> dict:
+        """
+        Query current channel settings.
+
+        Returns a dict with keys: wvtp, freq_hz, amp_vpp, amp_dbm, ofst, phase_deg.
+        """
+        self._check_channel(channel)
+        resp = self._query(f"C{channel}:BSWV?")
+        # Response: "C1:BSWV WVTP,SINE,FRQ,14001000.0,AMP,0.063,..."
+        params = {}
+        if "BSWV" in resp:
+            resp = resp.split("BSWV", 1)[1].strip()
+        parts = resp.split(",")
+        for i in range(0, len(parts) - 1, 2):
+            key = parts[i].strip().upper()
+            val = parts[i + 1].strip()
+            params[key] = val
+
+        result = {"wvtp": params.get("WVTP", "?")}
+        try:
+            result["freq_hz"]   = float(params.get("FRQ",  0))
+            result["amp_vpp"]   = float(params.get("AMP",  0))
+            result["amp_dbm"]   = vpp_to_dbm(result["amp_vpp"])
+            result["ofst"]      = float(params.get("OFST", 0))
+            result["phase_deg"] = float(params.get("PHSE", 0))
+        except (ValueError, ZeroDivisionError):
+            pass
+        return result
+
+    def close(self) -> None:
+        """Disable outputs and close the TCP connection."""
+        try:
+            self.output_off_all()
+        except Exception:
+            pass
+        self._sock.close()
+
+    # ------------------------------------------------------------------
+    # Context manager
+    # ------------------------------------------------------------------
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _check_channel(channel: int) -> None:
+        if channel not in (1, 2):
+            raise ValueError(f"Channel must be 1 or 2, got {channel}")
+
+    def _check_level(self, level_dbm: float) -> None:
+        if not (DBM_MIN <= level_dbm <= DBM_MAX):
+            raise ValueError(
+                f"Level {level_dbm:.1f} dBm out of range "
+                f"[{DBM_MIN:.1f}, {DBM_MAX:.1f}] dBm"
+            )
+
+    def _cmd(self, cmd: str) -> None:
+        """Send a command and wait briefly for the instrument to process it."""
+        self._sock.sendall((cmd + "\n").encode())
+        time.sleep(0.05)
+
+    def _query(self, cmd: str) -> str:
+        """Send a query and return the response string."""
+        self._sock.sendall((cmd + "\n").encode())
+        time.sleep(0.05)
+        try:
+            data = self._sock.recv(RECV_BUFSIZE)
+            return data.decode(errors="replace").strip()
+        except socket.timeout:
+            return ""