def process_capture(self, fstart, fstop, data):
# store usable bins before next call to capture_time_domain
usable_bins = list(self._capture_device.usable_bins)
# only read data if WSA digitizer is used
if 'DIGITIZER' in self._state.device_settings['iq_output_path']:
if self._state.sweeping():
self.read_sweep()
return
self.read_block()
if 'reflevel' in data['context_pkt']:
self._ref_level = data['context_pkt']['reflevel']
pow_data = compute_fft(self._dut,
data['data_pkt'],
data['context_pkt'],
ref=self._ref_level,
**self._dsp_options)
if not self._options.get('show_attenuated_edges'):
pow_data, usable_bins, fstart, fstop = (
trim_to_usable_fstart_fstop(pow_data, usable_bins, fstart,
fstop))
#FIXME: Find out why there is a case where pow_data may be empty
if pow_data.any():
if self._plot_options.get('reference_offset_value'):
pow_data += self._plot_options['reference_offset_value']
if self._export_csv:
self._export_csv_file(self._state.rfe_mode(), fstart,
fstop, pow_data)
self.capture_receive.emit(self._state, fstart, fstop,
data['data_pkt'], pow_data,
usable_bins, None)
def process_capture(self, fstart, fstop, data):
# store usable bins before next call to capture_time_domain
usable_bins = list(self._capture_device.usable_bins)
# only read data if WSA digitizer is used
if 'DIGITIZER' in self._state.device_settings['iq_output_path']:
if self._state.sweeping():
self.read_sweep()
return
self.read_block()
if 'reflevel' in data['context_pkt']:
self._ref_level = data['context_pkt']['reflevel']
pow_data = compute_fft(
self._dut,
data['data_pkt'],
data['context_pkt'],
ref=self._ref_level,
**self._dsp_options)
if not self._options.get('show_attenuated_edges'):
pow_data, usable_bins, fstart, fstop = (
trim_to_usable_fstart_fstop(
pow_data, usable_bins, fstart, fstop))
self.capture_receive.emit(
self._state,
fstart,
fstop,
data['data_pkt'],
pow_data,
usable_bins,
None)
def _playback_step(self):
if not self._playback_file:
self._playback_started = False
return
QtCore.QTimer.singleShot(PLAYBACK_STEP_MSEC, self._playback_step)
while True:
pkt = self._playback_vrt()
if pkt.is_context_packet():
if 'speca' in pkt.fields:
self._playback_sweep_data = None
state_json = pkt.fields['speca']
self._apply_complete_settings(state_json, playback=True)
else:
self._playback_context.update(pkt.fields)
continue
if self._state.sweeping():
if not self._playback_sweep_step(pkt):
continue
return
break
usable_bins = compute_usable_bins(
self._dut.properties,
self._state.rfe_mode(),
len(pkt.data),
self._state.decimation,
self._state.fshift)
usable_bins, fstart, fstop = adjust_usable_fstart_fstop(
self._dut.properties,
self._state.rfe_mode(),
len(pkt.data),
self._state.decimation,
self._state.center,
pkt.spec_inv,
usable_bins)
pow_data = compute_fft(
self._dut,
pkt,
self._playback_context,
**self._dsp_options)
if not self._options.get('show_attenuated_edges'):
pow_data, usable_bins, fstart, fstop = (
trim_to_usable_fstart_fstop(
pow_data, usable_bins, fstart, fstop))
self.capture_receive.emit(
self._state,
fstart,
fstop,
pkt,
pow_data,
usable_bins,
None)
def _playback_sweep_step(self, pkt):
"""
process one data packet from a recorded sweep and
plot collected data after receiving complete sweep.
returns True if data was plotted on this step.
"""
if self._playback_sweep_data is None:
self._playback_sweep_start()
last_center = None
else:
last_center = self._playback_sweep_last_center
sweep_start = float(self._state.center - self._state.span / 2)
sweep_stop = float(self._state.center + self._state.span / 2)
step_center = self._playback_context['rffreq']
updated_plot = False
if last_center is not None and last_center >= step_center:
# starting a new sweep, plot the data we have
self.capture_receive.emit(self._state, sweep_start, sweep_stop,
None, self._playback_sweep_data, None,
None)
updated_plot = True
self._playback_sweep_start()
self._playback_sweep_last_center = step_center
usable_bins = compute_usable_bins(self._dut.properties,
self._state.rfe_mode(),
len(pkt.data),
self._state.decimation,
self._state.fshift)
usable_bins, fstart, fstop = adjust_usable_fstart_fstop(
self._dut.properties, self._state.rfe_mode(), len(pkt.data),
self._state.decimation, step_center, pkt.spec_inv, usable_bins)
pow_data = compute_fft(self._dut, pkt, self._playback_context,
**self._dsp_options)
pow_data, usable_bins, fstart, fstop = (trim_to_usable_fstart_fstop(
pow_data, usable_bins, fstart, fstop))
clip_left = max(sweep_start, fstart)
clip_right = min(sweep_stop, fstop)
sweep_points = len(self._playback_sweep_data)
point_left = int((clip_left - sweep_start) * sweep_points /
(sweep_stop - sweep_start))
point_right = int((clip_right - sweep_start) * sweep_points /
(sweep_stop - sweep_start))
xvalues = np.linspace(clip_left, clip_right, point_right - point_left)
if point_left >= point_right:
logger.info('received sweep step outside sweep: %r, %r' %
((fstart, fstop), (sweep_start, sweep_stop)))
else:
self._playback_sweep_data[point_left:point_right] = np.interp(
xvalues, np.linspace(fstart, fstop, len(pow_data)), pow_data)
return updated_plot
def _playback_step(self, single=False):
if not (self._plot_options['cont_cap_mode'] or self._single_capture):
return
if not self._playback_file:
self._playback_started = False
return
QtCore.QTimer.singleShot(PLAYBACK_STEP_MSEC, self._playback_step)
while True:
pkt = self._playback_vrt()
if pkt.is_context_packet():
if 'speca' in pkt.fields:
self._playback_sweep_data = None
state_json = pkt.fields['speca']
self._apply_complete_settings(state_json, playback=True)
else:
self._playback_context.update(pkt.fields)
continue
if self._state.sweeping():
if not self._playback_sweep_step(pkt):
continue
self._single_capture = False
return
break
usable_bins = compute_usable_bins(self._dut.properties,
self._state.rfe_mode(),
len(pkt.data),
self._state.decimation,
self._state.fshift)
usable_bins, fstart, fstop = adjust_usable_fstart_fstop(
self._dut.properties, self._state.rfe_mode(), len(pkt.data),
self._state.decimation, self._state.center, pkt.spec_inv,
usable_bins)
pow_data = compute_fft(self._dut, pkt, self._playback_context,
**self._dsp_options)
if not self._options.get('show_attenuated_edges'):
pow_data, usable_bins, fstart, fstop = (
trim_to_usable_fstart_fstop(pow_data, usable_bins, fstart,
fstop))
if self._export_csv:
self._export_csv_file(self._state.rfe_mode(), fstart, fstop,
pow_data)
self.capture_receive.emit(self._state, fstart, fstop, pkt, pow_data,
usable_bins, None)
def process_capture(self, fstart, fstop, data):
# store usable bins before next call to capture_time_domain
usable_bins = list(self._capture_device.usable_bins)
# only read data if WSA digitizer is used
if 'DIGITIZER' in self._state.device_settings['iq_output_path']:
if self._state.sweeping():
self.read_sweep()
return
self.read_block()
if 'reflevel' in data['context_pkt']:
self._ref_level = data['context_pkt']['reflevel']
pow_data = compute_fft(
self._dut,
data['data_pkt'],
data['context_pkt'],
ref=self._ref_level,
**self._dsp_options)
if not self._options.get('show_attenuated_edges'):
pow_data, usable_bins, fstart, fstop = (
trim_to_usable_fstart_fstop(
pow_data, usable_bins, fstart, fstop))
#FIXME: Find out why there is a case where pow_data may be empty
if pow_data.any():
if self._plot_options.get('reference_offset_value'):
pow_data += self._plot_options['reference_offset_value']
if self._export_csv:
self._export_csv_file(self._state.rfe_mode(), fstart, fstop, pow_data)
self.capture_receive.emit(
self._state,
fstart,
fstop,
data['data_pkt'],
pow_data,
usable_bins,
None)
def _playback_sweep_step(self, pkt):
"""
process one data packet from a recorded sweep and
plot collected data after receiving complete sweep.
returns True if data was plotted on this step.
"""
if self._playback_sweep_data is None:
self._playback_sweep_start()
last_center = None
else:
last_center = self._playback_sweep_last_center
sweep_start = float(self._state.center - self._state.span / 2)
sweep_stop = float(self._state.center + self._state.span / 2)
step_center = self._playback_context['rffreq']
updated_plot = False
if last_center is not None and last_center >= step_center:
# starting a new sweep, plot the data we have
self.capture_receive.emit(
self._state,
sweep_start,
sweep_stop,
None,
self._playback_sweep_data,
None,
None)
updated_plot = True
self._playback_sweep_start()
self._playback_sweep_last_center = step_center
usable_bins = compute_usable_bins(
self._dut.properties,
self._state.rfe_mode(),
len(pkt.data),
self._state.decimation,
self._state.fshift)
usable_bins, fstart, fstop = adjust_usable_fstart_fstop(
self._dut.properties,
self._state.rfe_mode(),
len(pkt.data),
self._state.decimation,
step_center,
pkt.spec_inv,
usable_bins)
pow_data = compute_fft(
self._dut,
pkt,
self._playback_context,
**self._dsp_options)
pow_data, usable_bins, fstart, fstop = (
trim_to_usable_fstart_fstop(
pow_data, usable_bins, fstart, fstop))
clip_left = max(sweep_start, fstart)
clip_right = min(sweep_stop, fstop)
sweep_points = len(self._playback_sweep_data)
point_left = int((clip_left - sweep_start) * sweep_points / (
sweep_stop - sweep_start))
point_right = int((clip_right - sweep_start) * sweep_points / (
sweep_stop - sweep_start))
xvalues = np.linspace(clip_left, clip_right, point_right - point_left)
if point_left >= point_right:
logger.info('received sweep step outside sweep: %r, %r' %
((fstart, fstop), (sweep_start, sweep_stop)))
else:
self._playback_sweep_data[point_left:point_right] = np.interp(
xvalues, np.linspace(fstart, fstop, len(pow_data)), pow_data)
return updated_plot
def _vrt_receive(self, packet):
# context packet just update our context dictionary
if packet.is_context_packet():
# look for any geolocation info
geo = { }
for field in [ 'latitude', 'longitude', 'altitude', 'speedoverground', 'heading', 'track', 'magneticvariation' ]:
if field in packet.fields:
geo[field] = packet.fields[field]
if geo and self._geo_callback_func:
# execute callback
func = self._geo_callback_func
func(self._geo_callback_data, geo)
self._vrt_context.update(packet.fields)
self.log(packet)
return
# check to see if we recieved our sweep ID
if not ('sweepid' in self._vrt_context):
return
# make sure we are receiving packets for the right sweep
if not (self._vrt_context['sweepid'] == self._next_sweep_id):
raise SweepDeviceError("data packets received before start of sweep received! cur = %d, next = %d" % (self._vrt_context['sweepid'], self._next_sweep_id))
# increment the packet count
self.packet_count += 1
self.log("#%d of %d - %s" % (self.packet_count, self._sweep_settings.step_count, packet))
# retrieve the frequency and usable BW of the packet
packet_freq = self._vrt_context['rffreq']
usable_bw = self.dev_properties.USABLE_BW[self._sweep_settings.rfe_mode]
# compute the fft
pow_data = compute_fft(self.real_device, packet, self._vrt_context)
# calc rbw for this packet
rbw = float(self.dev_properties.FULL_BW[self._sweep_settings.rfe_mode]) / len(pow_data)
self.log("rbw = %f, %f" % (rbw, self._sweep_settings.rbw))
if self._flattening_enabled:
# Check if we are above 50 MHz and in SH mode
if packet_freq >= 50e6 and self._sweep_settings.rfe_mode == "SH":
number_of_points = len(pow_data)
# check if we have correction vectors (Noise)
if self.nf_corr_obj is not None:
# if so grab them
nf_cal = \
self.nf_corr_obj.get_correction_vector(packet_freq,
number_of_points)
else:
# if no set it to 0
nf_cal = np.zeros(number_of_points)
# check if we have corrrection vectors (Spectrum)
if self.sp_corr_obj is not None:
# if so grab them
sp_cal = \
self.sp_corr_obj.get_correction_vector(packet_freq,
number_of_points)
else:
# if not set it to 0
sp_cal = np.zeros(number_of_points)
# if the data is spectraly inverted, invert the vectors
if packet.spec_inv:
nf_cal = np.flipud(nf_cal)
sp_cal = np.flipud(sp_cal)
# calculate the correction threshold
correction_thresh = (-135.0 + ((10.0 * packet_freq / 1e6)
/ 27000.0) + 10.0
* np.log10(rbw)
+ self._sweep_settings.attenuation)
# creat the spectrum. per bin, if the ampltitude is above
# correction threshold do pow_data - sp_cal else do pow_data -
# nf_cal
pow_data = np.where(pow_data < correction_thresh,
pow_data - nf_cal, pow_data - sp_cal)
# check if DD mode was used in this sweep
if self.packet_count == 1 and self._sweep_settings.dd_mode:
# copy the data into the result array
self._copy_data(0, self.dev_properties.FULL_BW['DD'], pow_data, self._sweep_settings.bandstart, self._sweep_settings.bandstop, self.spectral_data);
if self._sweep_settings.beyond_dd:
return
else:
return self._emit_data()
# determine the usable bins in this config
self.log("===> compute_usable_bins()", self._sweep_settings.rfe_mode, self._sweep_settings.spp, 1, 0)
usable_bins = compute_usable_bins(self.dev_properties,
self._sweep_settings.rfe_mode,
self._sweep_settings.spp,
1,
0)
self.log("<--- usable_bins", usable_bins)
# adjust the usable range based on spectral inversion
self.log("===> adjust_usable_fstart_fstop()", "self.dev_properties", self._sweep_settings.rfe_mode, len(pow_data) * 2, 1, packet_freq, packet.spec_inv, usable_bins)
usable_bins, packet_start, packet_stop = adjust_usable_fstart_fstop(self.dev_properties,
self._sweep_settings.rfe_mode,
len(pow_data) * 2,
1,
packet_freq,
packet.spec_inv,
usable_bins)
self.log("<--- adjust_usable_fstart_fstop", packet_start, packet_stop, usable_bins)
#
# WARNING: the start and stop returned from this function are HIGHLY sketchy
#
# calculate packet frequency range
#packet_start = packet_freq - (self.dev_properties.FULL_BW[self._sweep_settings.rfe_mode] / 2)
#packet_stop = packet_freq + (self.dev_properties.FULL_BW[self._sweep_settings.rfe_mode] / 2)
#print "packet start/stop", packet_start, packet_stop
#trim the FFT data, note decimation is 1, fshift is 0
self.log("===> trim_to_usable_fstart_fstop()", "pow_data", usable_bins, packet_start, packet_stop)
trimmed_spectrum, edge_data, usable_start, usable_stop = trim_to_usable_fstart_fstop(pow_data,
usable_bins,
packet_start,
packet_stop)
self.log("<--- trim_to_usable_fstart_fstop", usable_start, usable_stop, "trimmed_spectrum", edge_data)
# copy the data
self._copy_data(usable_start, usable_stop, trimmed_spectrum, self._sweep_settings.bandstart, self._sweep_settings.bandstop, self.spectral_data);
# if there's no more packets, emit result
if self.packet_count == self._sweep_settings.step_count:
return self._emit_data()
# all done
return
def _vrt_receive(self, packet):
# context packet just update our context dictionary
if packet.is_context_packet():
self._vrt_context.update(packet.fields)
self.log(packet)
return
# check to see if we recieved our sweep ID
if not ('sweepid' in self._vrt_context):
return
# make sure we are receiving packets for the right sweep
if not (self._vrt_context['sweepid'] == self._next_sweep_id):
raise SweepDeviceError(
"data packets received before start of sweep received! cur = %d, next = %d"
% (self._vrt_context['sweepid'], self._next_sweep_id))
# increment the packet count
self.packet_count += 1
self.log("#%d of %d - %s" %
(self.packet_count, self._sweep_settings.step_count, packet))
# compute the fft
pow_data = compute_fft(self.real_device, packet, self._vrt_context)
# check if DD mode was used in this sweep
if self.packet_count == 1 and self._sweep_settings.dd_mode:
# copy the data into the result array
self._copy_data(0, self.dev_properties.FULL_BW['DD'], pow_data,
self._sweep_settings.bandstart,
self._sweep_settings.bandstop, self.spectral_data)
if self._sweep_settings.beyond_dd:
return
else:
return self._emit_data()
# retrieve the frequency and usable BW of the packet
packet_freq = self._vrt_context['rffreq']
usable_bw = self.dev_properties.USABLE_BW[
self._sweep_settings.rfe_mode]
# calc rbw for this packet
rbw = float(self.dev_properties.FULL_BW[
self._sweep_settings.rfe_mode]) / len(pow_data)
self.log("rbw = %f, %f" % (rbw, self._sweep_settings.rbw))
# determine the usable bins in this config
self.log("===> compute_usable_bins()", self._sweep_settings.rfe_mode,
self._sweep_settings.spp, 1, 0)
usable_bins = compute_usable_bins(self.dev_properties,
self._sweep_settings.rfe_mode,
self._sweep_settings.spp, 1, 0)
self.log("<--- usable_bins", usable_bins)
# adjust the usable range based on spectral inversion
self.log("===> adjust_usable_fstart_fstop()", "self.dev_properties",
self._sweep_settings.rfe_mode,
len(pow_data) * 2, 1, packet_freq, packet.spec_inv,
usable_bins)
usable_bins, packet_start, packet_stop = adjust_usable_fstart_fstop(
self.dev_properties, self._sweep_settings.rfe_mode,
len(pow_data) * 2, 1, packet_freq, packet.spec_inv, usable_bins)
self.log("<--- adjust_usable_fstart_fstop", packet_start, packet_stop,
usable_bins)
#
# WARNING: the start and stop returned from this function are HIGHLY sketchy
#
# calculate packet frequency range
#packet_start = packet_freq - (self.dev_properties.FULL_BW[self._sweep_settings.rfe_mode] / 2)
#packet_stop = packet_freq + (self.dev_properties.FULL_BW[self._sweep_settings.rfe_mode] / 2)
#print "packet start/stop", packet_start, packet_stop
#trim the FFT data, note decimation is 1, fshift is 0
self.log("===> trim_to_usable_fstart_fstop()", "pow_data", usable_bins,
packet_start, packet_stop)
trimmed_spectrum, edge_data, usable_start, usable_stop = trim_to_usable_fstart_fstop(
pow_data, usable_bins, packet_start, packet_stop)
self.log("<--- trim_to_usable_fstart_fstop", usable_start, usable_stop,
"trimmed_spectrum", edge_data)
# copy the data
self._copy_data(usable_start, usable_stop, trimmed_spectrum,
self._sweep_settings.bandstart,
self._sweep_settings.bandstop, self.spectral_data)
# if there's no more packets, emit result
if self.packet_count == self._sweep_settings.step_count:
return self._emit_data()
# all done
return
