def open_device(self, name, ok):
if not ok:
self._main_window.show()
return
if self.dut:
self.dut.disconnect()
self._main_window.show()
dut = WSA(connector=TwistedConnector(self._reactor))
yield dut.connect(name)
self.dev_set = {
'attenuator': 0,
'freq': 2450e6,
'decimation': 1,
'fshift': 0,
'rfe_mode': 'SH',
'iq_output_path': 'DIGITIZER'
}
self.dut = dut
self.dut_prop = self.dut.properties
self.bandwidth = self.dut_prop.FULL_BW[self.dev_set['rfe_mode']]
self.rbw = 125000000 / SAMPLE_VALUES[3]
self.enable_mhold = False
self.mhold = []
self.cap_dut = CaptureDevice(dut,
async_callback=self.receive_capture,
device_settings=self.dev_set)
self.initUI()
self.enable_controls()
self.read_block()
def open_device(self, name, ok):
if not ok:
self.show()
return
self.show()
dut = WSA(connector=TwistedConnector(self._get_reactor()))
yield dut.connect(name)
self._device_address = name
self.setWindowTitle('PyRF RTSA %s Connected To: %s' %
(__version__, name))
if hasattr(dut.properties, 'MINIMUM_FW_VERSION') and parse_version(
dut.fw_version) < parse_version(
dut.properties.MINIMUM_FW_VERSION):
too_old = QtGui.QMessageBox()
too_old.setText(
'Your device firmware version is {0}'
' but this application is expecting at least version'
' {1}. Some features may not work properly'.format(
dut.fw_version, dut.properties.MINIMUM_FW_VERSION))
too_old.exec_()
self.controller.set_device(dut)
self.record_action.setDisabled(False)
self.stop_action.setDisabled(True)
self.device_info.setDisabled(False)
def __init__(self, ip_address):
self._driver = WSA()
self._driver.connect(ip_address)
self._numpts = 4096
self._center_MHz = 2447.
self._span_MHz = 125.
self._start_MHz = self._center_MHz - (self._span_MHz / 2)
self._stop_MHz = self._center_MHz + (self._span_MHz / 2)
self._frequencies_MHz = np.linspace(self._start_MHz, self._stop_MHz,
self._numpts)
self._last_power_spectrum_dBm = None
self._capture_history_len = 2000
self.capture_history = WaterfallModel(self._frequencies_MHz,
self._capture_history_len)
self._capture_count = 0
self._capture_timer = QtCore.QTimer(
) #for app-side acquisition control
self._capture_timer.timeout.connect(self._on_capture_timer)
self.capturing = False
self.reset()
# return peak frequency and amplitude
return (pfreq, pamp)
# open faillog
if log_errors:
fp = open("mcfail.log", "a")
# connect to siggen
sg = N5183("10.126.110.19")
sg.freq(2400e6)
sg.amplitude(pin)
sg.output(1)
# connect to wsa
dut = WSA()
dut.connect(sys.argv[1])
dut.scpiset("*RST")
dut.flush()
# create sweep device
sd = SweepDevice(dut)
# test for a long time
t = 0
while t < numtrials:
# choose random fstart
req_fstart = int(random.random() * 8e9)
# choose random fstop
def __init__(self,
name: str,
address: str,
**kwargs: Any) -> None:
super().__init__(name, **kwargs)
self.dut = WSA()
self.addr = address
self.dut.connect(address)
self.dut.request_read_perm()
# Basic settings
self._rfemode = 'SH'
self._fstart = 5e9
self._fstop = 6e9
self._rbw = 5e3
self._gain = 'high'
self._attenuation = 0
self._average = 10
self._decimation = 1
self._reflevel = 0
self.triggered = False
self._acquired_data = None
self.add_parameter('rfe_mode',
unit = '',
initial_value= 'SH',
label = 'Input Mode',
get_cmd = self.get_rfe_mode,
set_cmd = self.set_rfe_mode,
get_parser = str)
self.add_parameter('attenuation',
unit = 'dB',
initial_value = 0.0,
label = 'attenuation',
get_cmd = self.get_attenuation,
set_cmd = self.set_attenuation,
get_parser = float,)
self.add_parameter('gain',
unit = '',
label = 'gain',
get_cmd = self.get_psfm_gain,
set_cmd = self.set_psfm_gain,
get_parser = str)
self.add_parameter('average',
unit = '',
label = 'average',
get_cmd = self.get_average,
set_cmd = self.set_average,
get_parser = int)
self.add_parameter('rbw',
unit = 'Hz',
label = 'resolution bandwidth',
get_cmd = self.get_rbw,
set_cmd = self.set_rbw ,
get_parser = float)
self.add_parameter('f_start',
unit='Hz',
label='fstart',
get_cmd= self.get_fstart,
set_cmd= self.set_fstart,
get_parser = float)
self.add_parameter('f_stop',
unit='Hz',
label='fstop',
get_cmd = self.get_fstop,
set_cmd= self.set_fstop,
get_parser = float)
self.add_parameter('n_points',
unit='',
get_cmd= self.get_npoints,
set_cmd= '',
get_parser = int)
self.add_parameter('freq_axis',
unit='Hz',
label='Frequency',
parameter_class=Setpoints,
startpar=self.f_start,
stoppar=self.f_stop,
npointspar=self.n_points,
vals=Arrays(shape=(self.n_points.get_latest,)))
self.add_parameter('spectrum',
unit='dBm',
setpoints=(self.freq_axis,),
label='Noise power',
parameter_class=SpectrumArray,
vals=Arrays(shape=(self.n_points.get_latest,)))
#!/usr/bin/env python
import sys
from pyrf.devices.thinkrf import WSA
from pyrf.connectors.twisted_async import TwistedConnector
from twisted.internet import reactor, defer
import twisted.python.log
# connect to wsa
dut = WSA(connector=TwistedConnector(reactor))
@defer.inlineCallbacks
def show_i_q():
yield dut.connect(sys.argv[1])
# setup test conditions
yield dut.reset()
yield dut.request_read_perm()
yield dut.freq(2450e6)
yield dut.decimation(0)
dut.connector.vrt_callback = receive_vrt
# capture 1 packet
yield dut.capture(1024, 1)
def receive_vrt(packet):
# read until I get 1 data packet
if not packet.is_data_packet():
return
def __init__(self, name: str, address: str, **kwargs: Any) -> None:
super().__init__(name, **kwargs)
self.dut = WSA()
self.dut.connect(address)
self.dut.reset()
self.dut.request_read_perm()
self._span = 5e6
self._RBW = 125e6 / (32 * 512)
self._average = 1
self._decimation = 1
self._reflevel = 0
self._capture_mode = 'BLOCK'
self._freqlist = []
self._spectralist = []
# sweep capture is not implemented yet
self.add_parameter('capture_mode',
unit='',
initial_value='BLOCK',
vals=Enum('BLOCK', 'SWEEP'),
label='Capture Mode',
get_cmd=self.get_capture_mode,
set_cmd=self.set_capture_mode,
get_parser=str)
self.add_parameter('rfe_mode',
unit='',
initial_value='SH',
label='Input Mode',
get_cmd=self.dut.rfe_mode,
set_cmd=self.dut.rfe_mode,
get_parser=str)
self.add_parameter(
'attenuation',
unit='dB',
initial_value=0.0,
label='attenuation',
get_cmd=self.dut.attenuator,
set_cmd=self.dut.attenuator,
get_parser=float,
)
self.add_parameter('gain',
unit='',
label='gain',
get_cmd=self.dut.psfm_gain,
set_cmd=self.dut.psfm_gain,
get_parser=str)
self.add_parameter('reflevel',
unit='dBm',
label='reference level',
get_cmd=self.get_ref,
set_cmd=self.set_ref,
get_parser=float)
self.add_parameter('average',
unit='',
label='average',
get_cmd=self.get_avg,
set_cmd=self.set_avg,
get_parser=int)
self.add_parameter(
'ppb',
unit='',
#initial_value = 1,
label='packets/block',
get_cmd=self.dut.ppb,
set_cmd=self.dut.ppb,
get_parser=int,
)
self.add_parameter(
'spp',
unit='',
#initial_value = 32 * 512,
label='samples/packet',
get_cmd=self.dut.spp,
set_cmd=self.dut.spp,
get_parser=int,
)
self.add_parameter(
'span',
unit='Hz',
label='span',
# vals = Numbers(0,100e6),
get_cmd=self.get_span,
set_cmd=self.set_span,
get_parser=float)
#TODO : implement a function that automatically adjusts the RWB to the value closest to the one in the device properties list
self.add_parameter(
'rbw',
unit='Hz',
# initial_value= 125e6 / (self.spp() * self.ppb),
label='resolution bandwidth',
# vals = Numbers(0,100e6),
get_cmd=self.get_RBW,
set_cmd=self.set_RBW,
get_parser=float)
self.add_parameter('f_center',
unit='Hz',
label='f center',
vals=Numbers(0.1e9, 27e9),
get_cmd=self.dut.freq,
set_cmd=self.dut.freq,
get_parser=float)
self.add_parameter(
'f_start',
# initial_value= 5.1e9,
unit='Hz',
label='f start',
#vals=Numbers(0,1e3),
get_cmd=lambda: self.f_center() - self.span() / 2,
set_cmd='',
get_parser=float)
self.add_parameter(
'f_stop',
unit='Hz',
label='f stop',
#initial_value=fstop,
#vals=Numbers(1,1e3),
get_cmd=lambda: self.f_center() + self.span() / 2,
set_cmd='',
get_parser=float)
self.add_parameter(
'n_points',
unit='',
# initial_value=len(spectra_data),
#vals=Numbers(1,1e3),
get_cmd=self.get_npoints,
set_cmd='',
get_parser=int)
self.add_parameter('freq_axis',
unit='Hz',
label='Frequency',
parameter_class=GeneratedSetPoints,
startparam=self.f_start,
stopparam=self.f_stop,
xpointsparam=self.n_points,
vals=Arrays(shape=(self.n_points.get_latest, )))
self.add_parameter('spectrum',
unit='dBm',
setpoints=(self.freq_axis, ),
label='Noise power',
parameter_class=SpectrumArray,
vals=Arrays(shape=(self.n_points.get_latest, )))
def _init_hardware(self, ip_address):
self._driver = WSA()
self._driver.connect(ip_address)
