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