Open RF Prototyping

cd ${RFBLOCKS_REFDESIGNS}/DualDacAdc/scripts/rp
export PYTHONPATH=.
python sa

export QT_NO_FT_CACHE=1

@property
def centre_freq(self) -> float:
    """The centre frequency for the currently selected channel (in MHz).

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.channel = 1
    >>> sa_app.centre_freq
    2027.5
    >>> sa_app.centre_freq = 1000
    >>> sa_app.centre_freq
    1000.0
    """

@property
def start_freq(self) -> float:
    """The start frequency for the currently selected channel (in MHz).

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.centre_freq = 1000
    >>> sa_app.start_freq = 999.95
    >>> sa_app.stop_freq = 1000.5
    >>> f"{sa_app.freq_span:.4f}"
    '0.5500'
    """

@property
def stop_freq(self) -> float:
    """The stop frequency for the currently selected channel (in MHz).

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.centre_freq = 1000
    >>> sa_app.start_freq = 999.95
    >>> sa_app.stop_freq = 1000.5
    >>> f"{sa_app.freq_span:.4f}"
    '0.5500'
    """

@property
def freq_span(self) -> float:
    """The frequency span for the currently selected channel (in MHz).

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.centre_freq = 1000
    >>> sa_app.start_freq = 999.95
    >>> sa_app.stop_freq = 1000.5
    >>> f"{sa_app.freq_span:.4f}"
    '0.5500'
    >>> sa_app.freq_span = 1.0
    >>> sa_app.start_freq
    999.725
    >>> sa_app.stop_freq
    1000.725
    """

@property
def rbw(self) -> float:
    """The resolution bandwidth of the currently selected channel (in MHz).

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.rbw
    5000
    >>> sa_app.rbw = 2000
    >>> sa_app.sweeps(5)
    >>> sa_app.auto_rbw
    False
    """

@property
def auto_rbw(self) -> bool:
    """Enable/disable auto setting of RBW for the currently selected
    channel (in MHz).

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.auto_rbw
    True
    """

@property
def ref_level(self) -> float:
    """The reference level for the currently selected channel (in dBm).

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.centre_freq = 1000
    >>> sa_app.ref_level = 5.0
    >>> sa_app.ampl_scale = 12
    >>> sa_app.sweep()
    """

@property
def ampl_scale(self) -> float:
    """The amplitude scaling for the currently selected channel (in dB).

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.centre_freq = 1000
    >>> sa_app.ref_level = 5.0
    >>> sa_app.ampl_scale = 12
    >>> sa_app.sweep()
    """

@property
def atten(self) -> float:
    """The ADC attenuator setting for the currently selected channel (in dB)

    This is set in steps of 0.25dB from 0.0dB to 31.75dB.

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.centre_freq = 1000
    >>> sa_app.ref_level = 5.0
    >>> sa_app.ampl_scale = 12
    >>> sa_app.sweep()
    >>> sa_app.atten
    0.0
    >>> sa_app.atten = 10
    >>> sa_app.atten
    10
    >>> sa_app.sweep()
    """

def marker_normal(self, mkr_id: int=1) -> None:
    """Set the specified marker for the currently selected channel to
    be in 'normal' mode.

    :param mkr_id: The id for the marker (1 to 4).
    :type mkr_id: int
    """

def marker_delta(self, mkr_id: int=1) -> None:
    """Set the specified marker for the currently selected channel to
    be in 'delta' mode.

    :param mkr_id: The id for the marker (1 to 4).
    :type mkr_id: int
    """

def marker_off(self, mkr_id: int=1) -> None:
    """Turn the specified marker for the currently selected channel off.

    :param mkr_id: The id for the marker (1 to 4).
    :type mkr_id: int
    """

@property
def selected_marker(self) -> SpectrumMarker:
    """Return a reference to the currently selected marker.
    """

@property
def marker_type(self) -> int:
    """Return the type of the currently selected marker
    """

@property
def marker_posn(self) -> Tuple[float, float]:
    """Return the position of the currently selected marker.

    :returns: A tuple containing the frequency (in MHz)
        and power (in dBm) of the currently selected marker.
        If the marker is either a delta or span type then the
        position will be for the reference marker.
    """

@property
def marker_delta_posn(self) -> Tuple[float, float]:
    """Return the delta frequency and power values for the currently
    selected marker.

    Note that if the currently selected marker is not either a delta
    or span type marker the values returned in the tuple will be None.

    :returns: A tuple containing the frequency and power delta of the
        currently selected marker.
    """

def set_marker_delta_posn(self, f:float) -> None:
    """Move the offset frequency position of the currently selected marker.
    If the type of the currently selected marker is not ``MKR_TYPE_DELTA``
    this function will do nothing.

    :param f: The offset from the reference marker to move the delta
        marker to.
    :type f: float

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.marker_delta()
    >>> from plot import SpectrumMarker
    >>> sa_app.marker_delta_type(mkr_id=1, mkr_type=SpectrumMarker.REF_DELTA_TYPE)
    >>> sa_app.peak_search()
    >>> sa_app.marker_delta_type(mkr_id=1, mkr_type=SpectrumMarker.DELTA_DELTA_TYPE)
    >>> sa_app.set_marker_delta_posn(0.5)
    >>> sa_app.marker_delta_posn
    (0.5009602327528455, -91.42057798668877)
    """

def peak_search(self) -> None:
    """
    """

def next_peak(self) -> None:
    """
    """

def detector_type_normal(self) -> None:
    """
    """

def detector_type_pos(self) -> None:
    """
    """

def detector_type_neg(self) -> None:
    """
    """

def detector_type_sample(self) -> None:
    """
    """

def trace_type_normal(self, trace_id: int=1) -> None:
    """
    """

def trace_type_avg(self, trace_id: int=1) -> None:
    """
    """

def trace_type_min(self, trace_id: int=1) -> None:
    """
    """

def trace_type_max(self, trace_id: int=1) -> None:
    """
    """

@property
def trace_average(self) -> int:
    """
    """

def sweep(self) -> None:
    """Perform a single spectrum sweep on the currently selected channel.
    """

def sweeps(self, sweep_count: int) -> None:
    """Perform the specified number of spectrum sweeps on the currently
    selected channel.

    :param sweep_count: The number of spectrum sweeps to carry out.
    :type sweep_count: int
    """

@property
def running(self) -> bool:
    """The status of the currently selected channel.

    :return: True if the channel is currently running and performing
    spectrum sweeps.  False if the channel is not running.
    """

@property
def chan_capabilities(self) -> Dict:
    """
    """

@property
def chan_type_is_direct(self) -> bool:
    """
    """

@property
def fe_atten(self) -> float:
    """The value of the RF front end attenuator for the currently
    selected channel.

    :returns: The current front end attenuation in dB.

    :raises: NotImplementedError if there is no RF front end hardware
        configured.

    >>> import rpyc
    >>> sa = rpyc.connect("127.0.0.1", 18865)
    >>> sa_app = sa.root.sa_app
    >>> sa_app.fe_atten
    10.0
    >>> sa_app.fe_atten = 0.0
    >>> sa_app.fe_atten
    0.0
    """

@property
def fe_gain(self) -> float:
    """The value of the RF front end gain for the recently selected
    channel.

    :returns: The current front end gain in dB.

    """

class DataStore:

    @property
    def spectra(self) -> List[Spectrum]:
    """A list containing the spectra for each of the traces.
    """

    @property
    def selected_trace_id(self) -> int:
    """The index of the currently selected trace.
    """

    @property
    def selected_trace_type(self) -> int:
    """The currently selected trace type.
    """

    @property
    def freq(self) -> np.ndarray:
    """The frequency value array for the currently selected trace.
    """

    @property
    def pwr(self) -> np.ndarray:
    """The power value array for the currently selected trace.
    """

    @property
    def sweep_params(self) -> SweepParameters:
    """The sweep parameters for the currently selected trace.
    """


@dataclass
class Spectrum():
    freq: np.ndarray
    pwr: np.ndarray
    iq_data: np.ndarray
    parameters: SweepParameters
    timestamp: datetime


@dataclass
class SweepParameters():
    # Start and stop frequencies in MHz.
    f_start: float
    f_stop: float

    fe_lo: float = 0.0
    s1: float = 0.0
    s2: float = 0.0
    window_type: str = 'HFT144D'
    window_w3db: float = 4.4697
    f_clk: float = ADC_122_16_F_CLK


    @property
    def fs(self):
    """
    """

    @property
    def bin_width(self):
    """
    """

    @property
    def decimation_rate(self):
    """
    """

    @property
    def enbw(self):
    """
    """

    @property
    def rbw(self):
    """
    """

    @property
    def window(self):
    """
    """

import sys
from argparse import ArgumentParser, RawTextHelpFormatter
import json
import textwrap
import rpyc


DEFAULT_SETTINGS_FILE = "sa-settings.json"
CHANNEL_LABELS = ['Ch 1', 'Ch_2']


def save_settings(sa_app, outfile, chan_list):
    settings = {}

    for ch in chan_list:
        ch_settings = {}
        chan_label = CHANNEL_LABELS[ch]
        sa_app.channel = ch
        ch_settings['centre_freq'] = sa_app.centre_freq
        ch_settings['start_freq'] = sa_app.start_freq
        ch_settings['stop_freq'] = sa_app.stop_freq
        ch_settings['freq_span'] = sa_app.freq_span
        ch_settings['ref_level'] = sa_app.ref_level
        ch_settings['ampl_scale'] = sa_app.ampl_scale
        ch_settings['atten'] = sa_app.atten
        ch_settings['auto_rbw'] = sa_app.auto_rbw
        ch_settings['rbw'] = sa_app.rbw
        settings[chan_label] = ch_settings

    with open(outfile, 'w') as fd:
        json.dump(settings, fd)


def restore_settings(sa_app, infile, chan_list):
    with open(infile) as fd:
        settings = json.load(fd)

    for ch in chan_list:
        chan_label = CHANNEL_LABELS[ch]
        ch_settings = settings[chan_label]
        sa_app.channel = ch
        sa_app.centre_freq = float(ch_settings['centre_freq'])
        sa_app.start_freq = float(ch_settings['start_freq'])
        sa_app.stop_freq = float(ch_settings['stop_freq'])
        sa_app.freq_span = float(ch_settings['freq_span'])
        sa_app.ref_level = float(ch_settings['ref_level'])
        sa_app.ampl_scale = float(ch_settings['ampl_scale'])
        sa_app.atten = float(ch_settings['atten'])
        sa_app.auto_rbw = ch_settings['auto_rbw']
        sa_app.rbw = float(ch_settings['rbw'])


def main():
    default_rpyc_addr = "127.0.0.1"
    default_rpyc_port = 18865

    parser = ArgumentParser(description=
                            "Save/restore settings for the RPSA app.",
                            formatter_class=RawTextHelpFormatter)

    parser.add_argument(
        "-a", "--saaddr",
        default=default_rpyc_addr,
        help=f"IP address for the RPSA RPyC service ({default_rpyc_addr})")
    parser.add_argument(
        "-p", "--saport",
        default=default_rpyc_port, type=int,
        help=f"TCP port for the RPSA RPyC service ({default_rpyc_port})")
    parser.add_argument(
        "-S", "--save", action='store_true',
        help="Save the current RPSA settings")
    parser.add_argument(
        "-R", "--restore", action='store_true',
        help="Restore RPSA settings")
    parser.add_argument(
        "-f", "--settings_file", default=DEFAULT_SETTINGS_FILE,
        help=f"File to save or restore SA settings to or from ({DEFAULT_SETTINGS_FILE})")
    parser.add_argument(
        "-C", "--channel", choices=["1", "2"],
        help=textwrap.dedent('''\
        Channel settings to save or restore.
        Note that not specifying a channel will save or
        restore both channels.
        '''))

    args = parser.parse_args()
    if args.save and args.restore:
        print("Both 'save' and 'restore' have been specified.")
        print("Please choose just one operation.")
        sys.exit(0)
    if args.channel is not None:
        channels = [int(args.channel) - 1]
    else:
        channels = [0, 1]

    sa = rpyc.connect(args.saaddr, args.saport)
    sa_app = sa.root.sa_app

    if args.save:
        save_settings(sa_app, args.settings_file, channels)
    else:
        restore_settings(sa_app, args.settings_file, channels)


if __name__ == '__main__':
    main()

import sys
import textwrap
from argparse import ArgumentParser, RawTextHelpFormatter
import rpyc
from rfblocks import BridgeCoupler


AVERAGING_SWEEPS = 5
MEASUREMENT_SPAN = 0.1


def set_rf(rf_chan, f_rf, rf_pwr):
    rf_chan.plo_ctl.freq = float(f_rf)
    rf_chan.level = rf_pwr
    lock_status = rf_chan.configure()
    return lock_status


def sweep(sa_service, sa_app, sweep_count=AVERAGING_SWEEPS):
    rpyc_timeout = sa_service._config['sync_request_timeout']
    sa_service._config['sync_request_timeout'] = None
    sa_app.sweeps(sweep_count)
    sa_service._config['sync_request_timeout'] = rpyc_timeout


def measure_signal_level(sa_service, sa_app, sa_chan, freq,
                         span, sweep_count):
    sa_app.trace_type_normal()
    sa_app.channel = sa_chan
    sa_app.centre_freq = freq
    sa_app.freq_span = span
    sa_app.sweep()
    sa_app.trace_type_avg()
    sweep(sa_service, sa_app, sweep_count)
    sa_app.marker_normal()
    sa_app.peak_search()
    signal_freq, signal_pwr = sa_app.marker_posn
    return signal_freq, signal_pwr


def measure_or_set_signal_level(sa_service, sa_app,
                                rfgen_chan, sa_chan,
                                freq, level, span, sweep_count):
    lo_chan = rfgen_chan  # Default RFGen channel 2
    lo_sa_chan = sa_chan  # Default RPSA 'Chan 1'

    min_pwr, max_pwr = lo_chan.power_range(freq)
    if level < min_pwr:
        p_des = min_pwr
    elif level > max_pwr:
        p_des = max_pwr
    else:
        p_des = level

    if level is not None:
        # Set freq and level, measure actual level
        lo_chan.plo_ctl.freq = freq
        lo_chan.level = level
        lo_chan.configure()

        attempts = 0
        while attempts < 5:
            measured_freq, measured_pwr = measure_signal_level(
                sa_service, sa_app, lo_sa_chan,
                freq, span, sweep_count)
            actual_pwr = (measured_pwr - lo_chan.coupler.coupling(freq)
                          + lo_chan.coupler.insertion_loss(freq))
            delta_p = p_des - actual_pwr
            attempts += 1
            if abs(delta_p) > 0.3:
                lo_chan.level = lo_chan.level + delta_p
                lo_chan.configure()
            else:
                break
    else:
        measured_freq, measured_pwr = measure_signal_level(
            sa_service, sa_app, lo_sa_chan, freq, span, sweep_count)
        actual_pwr = (measured_pwr
                      - lo_chan.coupler.coupling(measured_freq)
                      + lo_chan.coupler.insertion_loss(measured_freq))
    return (measured_freq, actual_pwr)


def main():
    default_rpsa_addr = "127.0.0.1"
    default_rpsa_port = 18865
    default_rfgen_addr = "127.0.0.1"
    default_rfgen_port = 18864
    default_signal_freq = 1000.0
    default_rfgen_chan = '2'
    default_sa_chan = '1'
    default_sa_span = MEASUREMENT_SPAN
    default_sweep_count = AVERAGING_SWEEPS

    parser = ArgumentParser(description=
                            "Measure/set RF signal generator output",
                            formatter_class=RawTextHelpFormatter)

    parser.add_argument(
        "-a", "--saaddr",
        default=default_rpsa_addr,
        help=f"IP address for the RPSA RPyC service ({default_rpsa_addr})")
    parser.add_argument(
        "-p", "--saport",
        default=default_rpsa_port, type=int,
        help=f"TCP port for the RPSA RPyC service ({default_rpsa_port})")
    parser.add_argument(
        "-A", "--rfgen_addr",
        default=default_rfgen_addr,
        help=f"IP address for the RFGen RPyC service ({default_rfgen_addr})")
    parser.add_argument(
        "-P", "--rfgen_port",
        default=default_rfgen_port, type=int,
        help=f"TCP port for the RFGen RPyC service ({default_rfgen_port})")
    parser.add_argument(
        "--rfgen_chan",
        default=default_rfgen_chan, choices=["1", "2"],
        help=f"Signal generator channel to use. ({default_rfgen_chan})")
    parser.add_argument(
        "--sa_chan",
        default=default_sa_chan, choices=["1", "2"],
        help=f"Spectrum analyzer channel to use. ({default_sa_chan})")
    parser.add_argument(
        "--sa_span",
        default=default_sa_span, type=float,
        help=f"Spectrum analyzer span to use (in MHz). ({default_sa_span})")
    parser.add_argument(
        "--sweep_count",
        default=default_sweep_count, type=int,
        help=f"Number of SA sweeps to average measurement over. ({default_sweep_count})")
    parser.add_argument(
        "-F", "--freq", required=True, type=float,
        help=f"Signal generator frequency (in MHz). ({default_signal_freq})")
    parser.add_argument(
        "-L", "--level", type=float,
        help=f"Signal generator output power, in dBm.")

    args = parser.parse_args()

    sa = rpyc.connect(args.saaddr, args.saport)
    sa_app = sa.root.sa_app
    rfgen = rpyc.connect(args.rfgen_addr, args.rfgen_port)
    rfgen_app = rfgen.root
    rfgen_chan = rfgen_app.channels[f"Chan {args.rfgen_chan}"]
    sa_chan = int(args.sa_chan) - 1
    freq, pwr = measure_or_set_signal_level(sa, sa_app,
                                            rfgen_chan, sa_chan,
                                            args.freq, args.level,
                                            args.sa_span, args.sweep_count)
    print(f"{freq=}, {pwr=}")


if __name__ == '__main__':
    main()

import sys
from argparse import ArgumentParser, RawTextHelpFormatter
import json
import textwrap

import numpy as np

import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Agg')

import rpyc

from dyadic.splot import init_style
from sa.utils import (
    FREQ_SUFFIXES,
    TRACE_TYPE_NORMAL, TRACE_TYPE_MAX, TRACE_TYPE_MIN, TRACE_TYPE_AVG,
    TRACE_TYPE_BLANK, TRACE_TYPE_FREEZE
)
from sa.plot import (
    SpectrumPlotWidget, SpectrumMarker
)


DEFAULT_PLOT_FILE = "plot.svg"
ANNOTATION_SIZE = 'x-small'
TITLE_SIZE = "xx-large"
ANNOTATION_COLOUR = "#0f0f0f80"
TITLE_COLOUR = "#0f0f0f40"

MARKER_COLOUR = 'r'
DELTA_MARKER_COLOUR = 'b'
MARKER_SIZE = 4
DOWN_TRIANGLE = 7
UP_TRIANGLE = 6


def format_freq(f: float, prec: int = 3) -> str:
    """f is in MHz
    """
    if abs(f) < 0.001:
        return f"{(f*1e6):4.1f}{FREQ_SUFFIXES[2]}"
    elif abs(f) < 1.0:
        return f"{(f*1e3):6.2f}{FREQ_SUFFIXES[1]}"
    else:
        return f"{f:7.{prec}f}{FREQ_SUFFIXES[0]}"


def draw_marker(sa_app, ax, mkr):
    ampl_scale = sa_app.ampl_scale
    fspan = sa_app.freq_span
    f_offset = fspan * 0.005
    a_offset = ampl_scale * 0.175
    if mkr.marker_type in [SpectrumMarker.MKR_TYPE_DELTA]:
        mkr_text = f"{mkr.marker_id:d}R"
    else:
        mkr_text = f"{mkr.marker_id:d}"
    if mkr.pwr > (sa_app.ref_level - (ampl_scale * 0.2)):
        ax.plot(mkr.freq, sa_app.ref_level,
                marker=UP_TRIANGLE,
                markersize=MARKER_SIZE,
                color=MARKER_COLOUR)
        ax.annotate(mkr_text,
                    xy=(mkr.freq - f_offset, sa_app.ref_level - (2.0 * a_offset)),
                    fontsize=ANNOTATION_SIZE,
                    color=MARKER_COLOUR)
    else:
        ax.plot(mkr.freq, mkr.pwr,
                marker=DOWN_TRIANGLE,
                markersize=MARKER_SIZE,
                color=MARKER_COLOUR)
        ax.annotate(mkr_text,
                    xy=(mkr.freq - f_offset, mkr.pwr + a_offset),
                    fontsize=ANNOTATION_SIZE,
                    color=MARKER_COLOUR)
    if mkr.marker_type in [SpectrumMarker.MKR_TYPE_DELTA]:
        if mkr.aux_pwr > (sa_app.ref_level - (sa_app.ampl_scale * 0.2)):
            ax.plot(mkr.aux_freq, sa_app.ref_level,
                    marker=UP_TRIANGLE,
                    markersize=MARKER_SIZE,
                    color=MARKER_COLOUR)
            ax.annotate(f"{mkr.marker_id:d}",
                        xy=(mkr.aux_freq - f_offset,
                            sa_app.ref_level - (2.0 * a_offset)),
                        fontsize=ANNOTATION_SIZE,
                        color=MARKER_COLOUR)
        else:
            ax.plot(mkr.aux_freq, mkr.aux_pwr,
                    marker=DOWN_TRIANGLE,
                    markersize=MARKER_SIZE,
                    color=MARKER_COLOUR)
            ax.annotate(f"{mkr.marker_id:d}",
                        xy=(mkr.aux_freq - f_offset, mkr.aux_pwr + a_offset),
                        fontsize=ANNOTATION_SIZE,
                        color=MARKER_COLOUR)


def annotate_marker(sa_app, ax, mkr):
    if mkr.marker_type in [SpectrumMarker.MKR_TYPE_NORMAL,
                           SpectrumMarker.MKR_TYPE_DELTA]:
        mkr_id = mkr.marker_id
        draw_marker(sa_app, ax, mkr)
        ax.annotate(f"Mkr{mkr_id}: {mkr.pwr:.2f} dBm",
                    xy=(0.74, 0.95),
                    xycoords="axes fraction",
                    fontsize=ANNOTATION_SIZE,
                    color=ANNOTATION_COLOUR)
        fspan = sa_app.freq_span
        if fspan < SpectrumPlotWidget.HIGH_PREC_SPAN:
            freq_text = f"          {format_freq(mkr.freq, prec=6)}"
        else:
            freq_text = f"          {format_freq(mkr.freq)}"
        ax.annotate(freq_text,
                    xy=(0.74, 0.91),
                    xycoords="axes fraction",
                    fontsize=ANNOTATION_SIZE,
                    color=ANNOTATION_COLOUR)
        if mkr.marker_type in [SpectrumMarker.MKR_TYPE_DELTA]:
            ax.annotate(f"\u0394Mkr{mkr_id}: {mkr.delta_pwr:.2f} dBm",
                        xy=(0.74, 0.87),
                        xycoords="axes fraction",
                        fontsize=ANNOTATION_SIZE,
                        color=ANNOTATION_COLOUR)
            ax.annotate(f"            {format_freq(mkr.delta_freq)}",
                        xy=(0.74, 0.83),
                        xycoords="axes fraction",
                        fontsize=ANNOTATION_SIZE,
                        color=ANNOTATION_COLOUR)


def annotate_plot(sa_app, chan, ax):
    sweep_params = sa_app.data_store().sweep_params
    ax.annotate(f"Ch {chan+1:d}",
                xy=(0.21, 0.92),
                xycoords="axes fraction",
                fontsize=TITLE_SIZE,
                fontweight="bold",
                color=TITLE_COLOUR)
    ax.annotate(f"Start: {format_freq(sa_app.start_freq)}",
                xy=(0.01, -0.05),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    ax.annotate(f"Span: {format_freq(sa_app.freq_span)}",
                xy=(0.41, -0.05),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    ax.annotate(f"Stop: {format_freq(sa_app.stop_freq)}",
                xy=(0.74, -0.05),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    ax.annotate(f"Ref: {sa_app.ref_level:.2f} dBm",
                xy=(0.01, 0.95),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    ax.annotate(f"RBW: {format_freq(sweep_params.rbw/1e6)}",
                xy=(0.01, 0.91),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    ax.annotate(f"Atten: {sa_app.atten:.2f} dB",
                xy=(0.41, 0.95),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    trace_type = sa_app.data_store().selected_trace_type
    if trace_type in [TRACE_TYPE_MAX, TRACE_TYPE_MIN, TRACE_TYPE_AVG]:
        avg_count = sa_app.data_store().average_counter
        if trace_type == TRACE_TYPE_AVG:
            avg_text = f"Avg: {avg_count:d}"
        elif trace_type == TRACE_TYPE_MAX:
            avg_text = f"Max: {avg_count:d}"
        elif trace_type == TRACE_TYPE_MIN:
            avg_text = f"Min: {avg_count:d}"
        ax.annotate(avg_text,
                    xy=(0.01, 0.65),
                    xycoords="axes fraction",
                    fontsize=ANNOTATION_SIZE,
                    color=ANNOTATION_COLOUR)
    mkr = sa_app.selected_marker
    annotate_marker(sa_app, ax, mkr)


def plot(sa_app, chan_list, plot_file):
    init_style()
    if len(chan_list) == 2:
        fig = plt.figure(num=None, figsize=(6.0, 6.5), dpi=72)
        ax = [fig.add_subplot(2, 1, 1), fig.add_subplot(2, 1, 2)]
    else:
        fig = plt.figure(num=None, figsize=(6.0, 3), dpi=72)
        ax = [fig.add_subplot(1, 1, 1)]

    for ch in chan_list:
        if len(chan_list) == 1:
            axes = ax[0]
        else:
            axes = ax[ch]
        sa_app.channel = ch

        min_freq = sa_app.start_freq
        max_freq = sa_app.stop_freq
        min_pwr = sa_app.ref_level - 10*sa_app.ampl_scale
        max_pwr = sa_app.ref_level

        data = sa_app.data_store()
        pwr = np.array(data.pwr)
        freq = np.array(data.freq)
        axes.set_xlim(min_freq, max_freq)
        axes.set_xticks(np.linspace(min_freq, max_freq, 11))
        axes.xaxis.set_ticklabels([])
        axes.set_ylim(min_pwr, max_pwr)
        axes.tick_params(axis="x", which="both", direction="in")
        axes.tick_params(axis="y", which="both", length=0.0)
        axes.grid(linestyle=':')
        axes.grid(which='both', axis='x', linestyle=':')
        axes.plot(freq, pwr)
        annotate_plot(sa_app, ch, axes)

    fig.tight_layout()
    plt.savefig(plot_file)


def main():
    default_rpyc_addr = "127.0.0.1"
    default_rpyc_port = 18865

    parser = ArgumentParser(description=
                            "Generate spectrum plots from the RPSA app.",
                            formatter_class=RawTextHelpFormatter)
    parser.add_argument(
        "-a", "--saaddr",
        default=default_rpyc_addr,
        help=f"IP address for the RPSA RPyC service ({default_rpyc_addr})")
    parser.add_argument(
        "-p", "--saport",
        default=default_rpyc_port, type=int,
        help=f"TCP port for the RPSA RPyC service ({default_rpyc_port})")
    parser.add_argument(
        "-C", "--channel", choices=["1", "2"],
        help=textwrap.dedent('''\
        Channel spectra to plot.  Note that not specifying a channel will
        cause plots of both channels to be produced.
        '''))
    parser.add_argument(
        "-O", "--plot_file", default=DEFAULT_PLOT_FILE,
        help=f"File to save the generated plot to ({DEFAULT_PLOT_FILE})"
    )

    args = parser.parse_args()
    if args.channel is not None:
        channels = [int(args.channel) - 1]
    else:
        channels = [0, 1]

    sa = rpyc.connect(args.saaddr, args.saport)
    sa_app = sa.root.sa_app
    plot(sa_app, channels, args.plot_file)


if __name__ == '__main__':
    main()

from math import floor
import random
import textwrap
from argparse import ArgumentParser, RawTextHelpFormatter
import numpy as np

import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Agg')

import rpyc

from dyadic.splot import init_style
from sa.utils import (
    FREQ_SUFFIXES,
    DETECTOR_TYPE_NORMAL, DETECTOR_TYPE_SAMPLE, DETECTOR_TYPE_POS,
    DETECTOR_TYPE_NEG
)


LINEAR = 0
RANDOM = 1

WIDEBAND_SWEEP_BINS = 1000
DETECTOR_TYPES = {
    "NORMAL": DETECTOR_TYPE_NORMAL,
    "SAMPLE": DETECTOR_TYPE_SAMPLE,
    "POS": DETECTOR_TYPE_POS,
    "NEG": DETECTOR_TYPE_NEG}

ANNOTATION_SIZE = 'x-small'
TITLE_SIZE = "xx-large"
ANNOTATION_COLOUR = "#0f0f0f80"
TITLE_COLOUR = "#0f0f0f40"


def format_freq(f: float, prec: int = 3) -> str:
    """f is in MHz
    """
    if abs(f) < 0.001:
        return f"{(f*1e6):4.1f}{FREQ_SUFFIXES[2]}"
    elif abs(f) < 1.0:
        return f"{(f*1e3):6.2f}{FREQ_SUFFIXES[1]}"
    else:
        return f"{f:7.{prec}f}{FREQ_SUFFIXES[0]}"


def peak_detect(pwr, resampled_idx, window_size):
    """Find peaks within a spectrum prior to resampling.

    :param pwr: A numpy array containing the spectrum power values
             as computed by the :py:meth:`power_spectrum` function.
    :type pwr: nparray
    :param resampled_idx: Array indexes for the resampled spectrum
    :type resampled_idx: List[int]
    :param window_size: The window size for the resampled spectrum
    :type window_size: int

    :return: A numpy array of bool values. Each value corresponds to
             a value in the resampled spectrum and is True if the
             associated power value is a peak and False if the value
             is noise.
    """

    NOISE_PERCENTILE = 50
    STD_THRESHOLD = 4.0
    MEAN_THRESHOLD = 4.0

    def stats(arr):
        return np.mean(arr), np.std(arr)

    j = k = window_size//2
    if window_size % 2:
        k += 1
    means = []
    stds = []
    for i in resampled_idx:
        if i - j < 0:
            m, s = stats(pwr[0:k])
        elif i + k >= len(pwr):
            m, s = stats(pwr[i-j:])
        else:
            m, s = stats(pwr[i-j:i+k])
        means.append(m)
        stds.append(s)
    baseline_mean = np.percentile(means, NOISE_PERCENTILE)
    baseline_std = np.percentile(stds, NOISE_PERCENTILE)
    bins = len(resampled_idx)
    if baseline_std == 0 or baseline_mean == 0:
        is_peak = np.ones(bins, dtype=bool)
    else:
        is_peak = np.where(
            ((stds/baseline_std > STD_THRESHOLD)
             & (means/baseline_mean > MEAN_THRESHOLD)),
            np.ones(bins, dtype=bool),
            np.zeros(bins, dtype=bool))
    return is_peak


def detector(detect_type, freq, pwr, bins):
    """Resample a power spectrum.

    :param detect_type: The detector type to use when resampling.
                       One of DETECTOR_TYPE_POS, DETECTOR_TYPE_NEG,
                       DETECTOR_TYPE_SAMPLE, DETECTOR_TYPE_NORMAL.
    :type detect_type: int.
    :param freq: Spectrum frequency array
    :type freq: nparray
    :param pwr: Spectrum power array
    :type pwr: nparray
    :param bins: The number of bins required in the resampled spectrum.
    :type bins: int
    """

    def max_pwr(arr, idx):
        if idx - j < 0:
            a = arr[0:k]
        elif idx + k >= len(pwr):
            a = arr[idx-j:]
        else:
            a = arr[idx-j:idx+k]
        return a.max()

    def min_pwr(arr, idx):
        if idx - j < 0:
            a = arr[0:k]
        elif idx + k >= len(pwr):
            a = arr[idx-j:]
        else:
            a = arr[idx-j:idx+k]
        return a.min()

    def sample_pwr(arr, idx):
        if idx - j < 0:
            a = arr[0:k]
        elif idx + k >= len(pwr):
            a = arr[idx-j:]
        else:
            a = arr[idx-j:idx+k]
        return np.take(a, a.size // 2)

    f_start = freq[0]
    f_stop = freq[-1]

    window_size = floor(len(freq)/bins)
    j = k = window_size//2
    if window_size % 2:
        k += 1
    resampled_freqs = np.linspace(f_start, f_stop, bins)
    indexes = [(np.abs(freq-f)).argmin() for f in resampled_freqs]
    resampled_pwr = []
    if detect_type == DETECTOR_TYPE_POS:
        for i in indexes:
            resampled_pwr.append(max_pwr(pwr, i))
    elif detect_type == DETECTOR_TYPE_NEG:
        for i in indexes:
            resampled_pwr.append(min_pwr(pwr, i))
    elif detect_type == DETECTOR_TYPE_SAMPLE:
        for i in indexes:
            resampled_pwr.append(sample_pwr(pwr, i))
    elif detect_type == DETECTOR_TYPE_NORMAL:
        is_peak = peak_detect(pwr, indexes, window_size)
        for i in range(bins):
            if is_peak[i]:
                resampled_pwr.append(max_pwr(pwr, indexes[i]))
            else:
                if i % 2:
                    # Odd
                    resampled_pwr.append(min_pwr(pwr, indexes[i]))
                else:
                    resampled_pwr.append(max_pwr(pwr, indexes[i]))

    return (resampled_freqs, resampled_pwr)


def set_span(sa_app, freq_span, rbw, detector):
    if freq_span > 45.0:
        freq_span = 45.0
    elif freq_span < 5.0:
        freq_span = 5.0
    if freq_span < 20.01:
        offset_step = 1.0
    elif freq_span < 40.01:
        offset_step = 0.5
    else:
        offset_step = 0.25
    sa_app.trace_type_normal()
    sa_app.detector_type = detector
    sa_app.freq_span = freq_span
    if rbw is not None:
        sa_app.rbw = rbw
    else:
        sa_app.auto_rbw = True
    sa_app.sweep()
    return offset_step


def sweep(sa_app, centre_freq,
          sweep_type=LINEAR, sweep_count=20, offset_step=1.0):
    sa_app.trace_type_normal()
    sa_app.centre_freq = centre_freq
    sa_app.sweep()
    max_offset = sa_app.max_felo_offset
    sa_app.trace_type_avg()
    if sweep_type == RANDOM:
        for offset in [0.25 + (random.random() * (max_offset - 0.25))
                       for i in range(sweep_count)]:
            sa_app.felo_offset = float(offset)
            sa_app.sweep()
    else:
        for offset in np.arange(max_offset, 0.0, -offset_step):
            sa_app.felo_offset = float(offset)
            sa_app.sweep()
    sa_app.trace_type_normal()
    data = sa_app.data_store()
    return (np.array(data.freq), np.array(data.pwr))


def wideband_sweep(sa_app, start_freq, stop_freq,
                   section_span, rbw, detector, **kwargs):
    offset_step = set_span(sa_app, section_span, rbw, detector)
    centre_freqs = np.arange(start_freq + (section_span/2), stop_freq,
                             section_span)
    freq = np.array([])
    pwr = np.array([])
    for centre_freq in centre_freqs:
        f, p = sweep(sa_app, centre_freq, offset_step=offset_step, **kwargs)
        freq = np.concatenate((freq, f))
        pwr = np.concatenate((pwr, p))
    return (freq, pwr)


def annotate_plot(sa_app, ax, rbw):
    chan = sa_app.channel
    if rbw is None:
        rbw = sa_app.rbw
    ax.annotate(f"Ch {chan+1:d}",
                xy=(0.21, 0.92),
                xycoords="axes fraction",
                fontsize=TITLE_SIZE,
                fontweight="bold",
                color=TITLE_COLOUR)
    ax.annotate(f"Start: {format_freq(sa_app.start_freq)}",
                xy=(0.01, 0.05),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    ax.annotate(f"Stop: {format_freq(sa_app.stop_freq)}",
                xy=(0.74, 0.05),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    ax.annotate(f"Ref: {sa_app.ref_level:.2f} dBm",
                xy=(0.01, 0.95),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    ax.annotate(f"RBW: {format_freq(rbw/1e6)}",
                xy=(0.01, 0.91),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)
    ax.annotate(f"Atten: {sa_app.atten:.2f} dB",
                xy=(0.41, 0.95),
                xycoords="axes fraction",
                fontsize=ANNOTATION_SIZE,
                color=ANNOTATION_COLOUR)


def plot(sa_app, min_freq, max_freq, rbw, freq, pwr, plot_file):
    init_style()
    fig = plt.figure(num=None, figsize=(6.0, 3), dpi=72)
    axes = fig.add_subplot(1, 1, 1)

    min_pwr = sa_app.ref_level - 10*sa_app.ampl_scale
    max_pwr = sa_app.ref_level

    axes.set_xlim(min_freq, max_freq)
    #axes.set_xticks(np.linspace(min_freq, max_freq, 11))
    # axes.xaxis.set_ticklabels([])
    axes.set_ylim(min_pwr, max_pwr)
    #axes.set_yticks(np.linspace(min_pwr, max_pwr, 11))
    axes.tick_params(axis="x", which="both", direction="in")
    axes.tick_params(axis="y", which="both", length=0.0)
    axes.grid(linestyle=':')
    axes.grid(which='both', axis='x', linestyle=':')
    axes.plot(freq, pwr)

    annotate_plot(sa_app, axes, rbw)

    fig.tight_layout()
    plt.savefig(plot_file)


def main():
    default_rpyc_addr = "127.0.0.1"
    default_rpyc_port = 18865
    default_sweep_type = "RANDOM"
    default_sweep_count = 40
    default_section_span = 20.0
    default_plot_file = "wb-plot.svg"
    default_detector_type = "NORMAL"

    parser = ArgumentParser(description=
                            "Generate a wideband spectrum plot",
                            formatter_class=RawTextHelpFormatter)

    parser.add_argument(
        "-a", "--saaddr",
        default=default_rpyc_addr,
        help=f"IP address for the RPSA RPyC service ({default_rpyc_addr})")
    parser.add_argument(
        "-p", "--saport",
        default=default_rpyc_port, type=int,
        help=f"TCP port for the RPSA RPyC service ({default_rpyc_port})")
    parser.add_argument(
        "-s", "--start_freq", type=float, required=True,
        help="Start frequency for the wideband sweep")
    parser.add_argument(
        "-e", "--stop_freq", type=float, required=True,
        help="Stop frequency for the wideband sweep")
    parser.add_argument(
        "-S", "--section_span", type=float, default=default_section_span,
        help=textwrap.dedent(f'''\
        Frequency span of each section of the wideband sweep.
        Default: {default_section_span}'''))
    parser.add_argument(
        "-R", "--rbw", type=float, default=None,
       help="RBW of the sweeps (in Hz).")
    parser.add_argument(
        "-D", "--detector",
        choices=["NORMAL", "SAMPLE", "POS", "NEG"],
        default=default_detector_type,
        help=textwrap.dedent(f'''\
        The detector type to use for the wideband sweep.
        Default: {default_detector_type}'''))
    parser.add_argument(
        "-T", "--sweep_type", choices=["LINEAR", "RANDOM"],
        default=default_sweep_type,
        help=textwrap.dedent(f'''\
        The type of sweep for each section of the wideband sweep.
        Default: {default_sweep_type}'''))
    parser.add_argument(
        "-C", "--sweep_count", type=int, default=default_sweep_count,
        help=textwrap.dedent(f'''\
        The number of sweeps to average for each section of the wideband sweep.
        Default: {default_sweep_count}'''))
    parser.add_argument(
        "-P", "--plot_file", default=default_plot_file,
        help=textwrap.dedent(f'''\
        The file to write the plot of the wideband sweep.
        Default: {default_plot_file}'''))
    parser.add_argument(
        "-O", "--output_file",
        help="The file to write the wideband sweep data to.")

    args = parser.parse_args()

    if args.sweep_type == "RANDOM":
        sweep_type = RANDOM
    else:
        sweep_type = LINEAR

    sa = rpyc.connect(args.saaddr, args.saport)
    sa_app = sa.root.sa_app

    raw_freq, raw_pwr = wideband_sweep(
        sa_app, args.start_freq, args.stop_freq,
        args.section_span, args.rbw, detector=DETECTOR_TYPES[args.detector],
        sweep_type=sweep_type, sweep_count=args.sweep_count)
    freq, pwr = detector(DETECTOR_TYPES[args.detector],
                         raw_freq, raw_pwr, WIDEBAND_SWEEP_BINS)
    if args.output_file is not None:
        pass
    plot(sa_app, args.start_freq, args.stop_freq, args.rbw,
         freq, pwr, args.plot_file)


if __name__ == '__main__':
    main()

import sys
from math import log10, floor
from dataclasses import dataclass
from argparse import ArgumentParser, RawTextHelpFormatter
import json

import numpy as np

import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Agg')
from dyadic.splot import init_style

import rpyc

from sa.utils import (
    FREQ_SUFFIXES,
    DETECTOR_TYPE_NORMAL, DETECTOR_TYPE_SAMPLE, DETECTOR_TYPE_POS,
    DETECTOR_TYPE_NEG
)


RESAMPLED_SWEEP_BINS = 1000

# Phase noise sweeps are specified as tuples with the following values:
#
#  span (MHz),
#  centre freq. offset (from carrier, MHz)
#  RBW (Hz)
#  Trace averages
#  Frequency of first sample bin (in MHz, offset from carrier)
#  Frequency of last sample bin (in MHz, offset from carrier)
#
# For example: (1.0, 0.45, 2000, 30, 0.25, 0.5)
# Uses a spectrum analyzer frequency span of 1 MHz, places the
# centre frequency of the analyzer as (carrier freq.) + 0.45 MHz,
# sets the analyzer RBW to 2000 Hz, averages over 30 sweeps.
# The samples extracted from the resulting spectrum are taken
# from 0.25 to 0.5 MHz (offset from carrier frequency).
#
pn_sweeps = [
    (2.0, 0.9, 2000, 30, 0.5, 1.5),
    (1.0, 0.45, 2000, 30, 0.25, 0.5),
    (0.5, 0.24, 1000, 30, 0.1, 0.25),
    (0.2, 0.095, 500, 30, 0.05, 0.1),
    (0.1, 0.045, 200, 20, 0.025, 0.05),
    (0.05, 0.022, 200, 20, 0.01, 0.025),
    (0.02, 0.008, 100, 20, 0.005, 0.01),
    (0.01, 0.004, 20, 20, 0.002, 0.005),
    (0.005, 0.002, 20, 20, 0.001, 0.002),
    (0.002, 0.0008, 10, 10, 0.0005, 0.001),
    (0.001, 0.0004, 5, 10, 0.00025, 0.0005),
    (0.0005, 0.0002, 5, 10, 0.0001, 0.00025)
]


@dataclass
class SweepParameters:
    span: float
    freq_offset: float
    rbw: float
    trace_avg: int
    sample_low: float
    sample_high: float


def peak_detect(pwr, resampled_idx, window_size):
    """Find peaks within a spectrum prior to resampling.

    :param pwr: A numpy array containing the spectrum power values
             as computed by the :py:meth:`power_spectrum` function.
    :type pwr: nparray
    :param resampled_idx: Array indexes for the resampled spectrum
    :type resampled_idx: List[int]
    :param window_size: The window size for the resampled spectrum
    :type window_size: int

    :return: A numpy array of bool values. Each value corresponds to
             a value in the resampled spectrum and is True if the
             associated power value is a peak and False if the value
             is noise.
    """

    NOISE_PERCENTILE = 50
    STD_THRESHOLD = 4.0
    MEAN_THRESHOLD = 4.0

    def stats(arr):
        return np.mean(arr), np.std(arr)

    j = k = window_size//2
    if window_size % 2:
        k += 1
    means = []
    stds = []
    for i in resampled_idx:
        if i - j < 0:
            m, s = stats(pwr[0:k])
        elif i + k >= len(pwr):
            m, s = stats(pwr[i-j:])
        else:
            m, s = stats(pwr[i-j:i+k])
        means.append(m)
        stds.append(s)
    baseline_mean = np.percentile(means, NOISE_PERCENTILE)
    baseline_std = np.percentile(stds, NOISE_PERCENTILE)
    bins = len(resampled_idx)
    if baseline_std == 0 or baseline_mean == 0:
        is_peak = np.ones(bins, dtype=bool)
    else:
        is_peak = np.where(
            ((stds/baseline_std > STD_THRESHOLD)
             & (means/baseline_mean > MEAN_THRESHOLD)),
            np.ones(bins, dtype=bool),
            np.zeros(bins, dtype=bool))
    return is_peak


def detector(detect_type, freq, pwr, bins):
    """Resample a power spectrum.

    :param detect_type: The detector type to use when resampling.
                       One of DETECTOR_TYPE_POS, DETECTOR_TYPE_NEG,
                       DETECTOR_TYPE_SAMPLE, DETECTOR_TYPE_NORMAL.
    :type detect_type: int.
    :param freq: Spectrum frequency array
    :type freq: nparray
    :param pwr: Spectrum power array
    :type pwr: nparray
    :param bins: The number of bins required in the resampled spectrum.
    :type bins: int
    """

    def max_pwr(arr, idx):
        if idx - j < 0:
            a = arr[0:k]
        elif idx + k >= len(pwr):
            a = arr[idx-j:]
        else:
            a = arr[idx-j:idx+k]
        return a.max()

    def min_pwr(arr, idx):
        if idx - j < 0:
            a = arr[0:k]
        elif idx + k >= len(pwr):
            a = arr[idx-j:]
        else:
            a = arr[idx-j:idx+k]
        return a.min()

    def sample_pwr(arr, idx):
        if idx - j < 0:
            a = arr[0:k]
        elif idx + k >= len(pwr):
            a = arr[idx-j:]
        else:
            a = arr[idx-j:idx+k]
        return np.take(a, a.size // 2)

    f_start = freq[0]
    f_stop = freq[-1]

    window_size = floor(len(freq)/bins)
    j = k = window_size//2
    if window_size % 2:
        k += 1
    resampled_freqs = np.linspace(f_start, f_stop, bins)
    indexes = [(np.abs(freq-f)).argmin() for f in resampled_freqs]
    resampled_pwr = []
    if detect_type == DETECTOR_TYPE_POS:
        for i in indexes:
            resampled_pwr.append(max_pwr(pwr, i))
    elif detect_type == DETECTOR_TYPE_NEG:
        for i in indexes:
            resampled_pwr.append(min_pwr(pwr, i))
    elif detect_type == DETECTOR_TYPE_SAMPLE:
        for i in indexes:
            resampled_pwr.append(sample_pwr(pwr, i))
    elif detect_type == DETECTOR_TYPE_NORMAL:
        is_peak = peak_detect(pwr, indexes, window_size)
        for i in range(bins):
            if is_peak[i]:
                resampled_pwr.append(max_pwr(pwr, indexes[i]))
            else:
                if i % 2:
                    # Odd
                    resampled_pwr.append(min_pwr(pwr, indexes[i]))
                else:
                    resampled_pwr.append(max_pwr(pwr, indexes[i]))

    return (resampled_freqs, resampled_pwr)


def find_nearest_index(array, value):
    return (np.abs(array - value)).argmin()


def initialize(sa_app, sa_chan):
    sa_app.channel = sa_chan
    sa_app.fe_atten = 0.0
    sa_app.ampl_scale = 12.0
    sa_app.detector_type_pos()
    sa_app.auto_rbw = False
    sa_app.marker_normal()


def sweep(sa_app, f_centre, f_span, rbw, sweep_count=20):
    sa_app.freq_span = f_span
    sa_app.centre_freq = f_centre
    sa_app.rbw = rbw
    sa_app.trace_type_normal()
    sa_app.sweep()
    if sweep_count > 1:
        sa_app.trace_type_avg()
        sa_app.sweeps(sweep_count)
    sa_app.peak_search()
    return sa_app.marker_posn


def measure_pn(sa_app, peak_pwr, rbw, f_low, f_high):
    data = sa_app.data_store()
    freq_arr = np.array(data.freq)
    pwr_arr = np.array(data.pwr)
    pn_arr = (pwr_arr - peak_pwr) - 10*log10(rbw)
    idx_low = find_nearest_index(freq_arr, f_low)
    idx_high = find_nearest_index(freq_arr, f_high)
    return freq_arr[idx_low:idx_high], pn_arr[idx_low:idx_high]


def create_fig(title):
    fig = plt.figure(figsize=(6.0, 4.0), dpi=72)
    ax = fig.add_subplot(111)
    if len(title):
        _ = ax.set_title(title)
    _ = ax.set_xlim(100, 2e6)
    _ = ax.set_xscale('log')
    _ = ax.set_xticks([100, 200, 500, 1e3, 2e3, 5e3, 1e4, 2e4, 5e4,
                       1e5, 2e5, 5e5, 1e6, 2e6])
    _ = ax.set_xticklabels(['100', '', '', '1K', '', '', '10K', '', '',
                            '100K', '', '', '1M', ''])
    _ = ax.set_xlabel('Frequency (Hz)')
    _ = ax.set_ylim(-160, -60)
    _ = ax.set_yticks(np.linspace(-160, -60, 11))
    _ = ax.set_yticklabels(['', '-150', '-140', '-130', '-120',
                            '-110', '-100', '-90', '-80', '-70', '-60'])
    _ = ax.set_ylabel('Phase Noise (dBc/Hz)')
    ax.grid(linestyle=':')
    ax.grid(which='both', axis='x', linestyle=':')
    return fig, ax


def main():
    default_rpyc_addr = "127.0.0.1"
    default_rpyc_port = 18865
    default_sa_chan = "1"
    default_plotfile = "pn.svg"
    default_savefile = "pn.json"

    parser = ArgumentParser(description=
                            "Measure phase noise",
                            formatter_class=RawTextHelpFormatter)

    parser.add_argument(
        "-a", "--saaddr",
        default=default_rpyc_addr,
        help=f"IP address for the RPSA RPyC service ({default_rpyc_addr})")
    parser.add_argument(
        "-p", "--saport",
        default=default_rpyc_port, type=int,
        help=f"TCP port for the RPSA RPyC service ({default_rpyc_port})")
    parser.add_argument(
        "carrier_freq",
        help="Frequency of the carrier tone (in MHz)")
    parser.add_argument(
        "-C", "--channel", choices=["1", "2"], default=default_sa_chan,
        help=f"Channel spectra for phase noise measurement ({default_sa_chan}).")
    parser.add_argument(
        "-P", "--plot_file",
        default=default_plotfile,
        help=f"Write the phase noise plot to this file ({default_plotfile})")
    parser.add_argument(
        "-S", "--save_file",
        default=default_savefile,
        help=f"Write phase noise data to this file ({default_savefile})")
    parser.add_argument(
        "-T", "--plot_title",
        help=f"Title to use for the phase noise plot")
    parser.add_argument(
        "-R", "--resample", action='store_true',
        help="Resample the phase noise plot.")

    args = parser.parse_args()

    sa = rpyc.connect(args.saaddr, args.saport)
    sa_app = sa.root.sa_app
    sa_chan = int(args.channel) - 1

    freq_arr = np.array([])
    pn_arr = np.array([])
    initialize(sa_app, sa_chan)
    f_sig, p_sig = sweep(sa_app, float(args.carrier_freq), 2.0, 5000, 1)
    for pn_sweep in pn_sweeps:
        sweep_params = SweepParameters(*pn_sweep)
        f_sig, p_sig = sweep(sa_app, f_sig + sweep_params.freq_offset,
                             sweep_params.span, sweep_params.rbw,
                             sweep_params.trace_avg)
        sample_low = f_sig + sweep_params.sample_low
        sample_high = f_sig + sweep_params.sample_high
        f_arr, p_arr = measure_pn(sa_app, p_sig, sweep_params.rbw,
                                  sample_low, sample_high)
        freq_arr = np.insert(freq_arr, 0, f_arr)
        pn_arr = np.insert(pn_arr, 0, p_arr)

    # Convert the frequencies to offsets from the carrier.
    # Note that we use the last measured value of the carrier
    # frequency peak
    freq_arr -= f_sig
    if args.resample is True:
        freq_arr, pn_arr = detector(DETECTOR_TYPE_NORMAL,
                                     freq_arr, pn_arr, RESAMPLED_SWEEP_BINS)

    with open(args.save_file, 'w') as fd:
        json.dump({'freq': list(freq_arr), 'pn': list(pn_arr)}, fd)

    fig, ax = create_fig(args.plot_title)
    _ = ax.plot(freq_arr * 1e6, pn_arr)
    fig.tight_layout()
    fig.savefig(args.plot_file)


if __name__ == '__main__':
    main()