def set_freq(self, freq, skip_sync=False): """ Safely tune all channels to freq. """ self.vprint("Tuning all channels to {freq} MHz.".format(freq=freq/1e6)) # Set frequency (tune request takes lo_offset): if hasattr(self.args, 'lo_offset') and self.args.lo_offset is not None: treq = uhd.tune_request(freq, self.args.lo_offset) else: treq = uhd.tune_request(freq) # Make sure tuning is synched: if len(self.channels) > 1 and not skip_sync: cmd_time = self.usrp.get_time_now() + uhd.time_spec(COMMAND_DELAY) for mb_idx in xrange(self.usrp.get_num_mboards()): self.usrp.set_command_time(cmd_time, mb_idx) for chan in self.channels: self.tr = self.usrp.set_center_freq(treq, chan) if self.tr == None: sys.stderr.write('[{prefix}] [ERROR] Failed to set center frequency on channel {chan}\n'.format( prefix=self.prefix, chan=chan )) exit(1) if len(self.channels) > 1 and not skip_sync: for mb_idx in xrange(self.usrp.get_num_mboards()): self.usrp.clear_command_time(mb_idx) self.vprint("Syncing channels...".format(prefix=self.prefix)) time.sleep(COMMAND_DELAY) self.freq = self.usrp.get_center_freq(self.channels[1]) self.vprint("First channel has freq: {freq} MHz.".format(freq=self.freq/1e6))
def retune(self): up_freq = self._dssdr_channels[self._ccsds_channel][0] down_freq = self._dssdr_channels[self._ccsds_channel][1] if self.options.test == False and self.options.fromfile == False and self.options.frombitlog == False: self._tune_request = uhd.tune_request(down_freq-self._dssdr_mixer_freq+self._if_freq, self._uhd_carrier_offset) self.u.set_center_freq(self._tune_request) if self.options.test == False and self.options.tofile == False and self.options.tonull == False: self._tune_request = uhd.tune_request(self._dssdr_mixer_freq-up_freq+self._if_freq, self._uhd_carrier_offset) self.u_tx.set_center_freq(self._tune_request)
def set_freq(self, freq): self.freq = freq self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=self.freq - self.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=self.freq - self.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 1)
def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate self.set_resamp_rate(float(self.interp / self.decim * self.samp_rate)) self.fosphor_qt_sink_c_0.set_frequency_range(0, self.samp_rate) self.fosphor_qt_sink_c_0_0.set_frequency_range(0, self.samp_rate) self.uhd_usrp_source_0.set_samp_rate(self.samp_rate) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.rx_freq, self.samp_rate / 2), 0) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.rx_freq, self.samp_rate / 2), 1)
def set_system_center_freq(self, system_center_freq): self.system_center_freq = system_center_freq self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.com_freq_entry_1, rf_freq=self.system_center_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.vor_freq_entry_1, rf_freq=self.system_center_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 1)
def set_rx_freq(self, rx_freq): self.rx_freq = rx_freq Qt.QMetaObject.invokeMethod(self._rx_freq_line_edit, "setText", Qt.Q_ARG("QString", eng_notation.num_to_str(self.rx_freq))) self.fosphor_qt_sink_c_0.set_frequency_range(self.rx_freq, self.samp_rate) self.fosphor_qt_sink_c_0_0.set_frequency_range(self.rx_freq, self.samp_rate) self.qtgui_freq_sink_x_0.set_frequency_range(self.rx_freq, self.samp_rate) self.qtgui_waterfall_sink_x_0.set_frequency_range(self.rx_freq, self.samp_rate) self.qtgui_waterfall_sink_x_0_0.set_frequency_range(self.rx_freq, self.samp_rate) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2), 0) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2), 1)
def set_tuning_lo_offset(self, tuning_lo_offset): self.tuning_lo_offset = tuning_lo_offset self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.freq, self.tuning_lo_offset), 0) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.freq, self.tuning_lo_offset), 1) self.uhd_usrp_sink_0.set_center_freq( uhd.tune_request(self.freq, self.tuning_lo_offset), 0) self.uhd_usrp_sink_0.set_center_freq( uhd.tune_request(self.freq, self.tuning_lo_offset), 1)
def retune(self, freq, lo_offset, gain, bw): # synchronize LOs time_retune_2 = self.usrp_source.get_time_now().get_real_secs() print "Time retune 2:", time_retune_2 self.usrp_source.set_center_freq(uhd.tune_request(freq, lo_offset), 0) self.tx_bpsk_0.set_center_freq(uhd.tune_request(freq, lo_offset)) self.usrp_source.set_gain(gain,0) self.tx_bpsk_0.set_gain(gain) self.usrp_source.set_bandwidth(bw,0) self.tx_bpsk_0.set_bandwidth(bw)
def set_lo_offset(self, lo_offset): self.lo_offset = lo_offset self.uhd_usrp_sink_0_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=self.freq - self.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=self.freq - self.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
def set_freq(self, freq, skip_sync=False): """ Safely tune all channels to freq. """ self.vprint("Tuning all channels to {freq} MHz.".format(freq=freq / 1e6)) # Set frequency (tune request takes lo_offset): if hasattr(self.args, 'lo_offset') and self.args.lo_offset is not None: treq = uhd.tune_request(freq, self.args.lo_offset) else: treq = uhd.tune_request(freq) # Special TwinRX tuning due to LO sharing if getattr(self, 'lo_source_channel', None) is not None: tune_resp = self.usrp.set_center_freq(treq, self.lo_source_channel) if getattr(self.args, 'lo_offset', None) is not None: treq = uhd.tune_request( target_freq=freq, rf_freq=freq+self.args.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL, dsp_freq=tune_resp.actual_dsp_freq, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL) else: treq = uhd.tune_request( target_freq=freq, rf_freq=freq, rf_freq_policy=uhd.tune_reqest.POLICY_MANUAL, dsp_freq=tune_resp.actual_dsp_freq, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL) for chan in self.channels: if chan == self.lo_source_channel: continue self.usrp.set_center_freq(treq, chan) # Make sure tuning is synched: command_time_set = False if len(self.channels) > 1 and not skip_sync: cmd_time = self.usrp.get_time_now() + uhd.time_spec(COMMAND_DELAY) try: for mb_idx in range(self.usrp.get_num_mboards()): self.usrp.set_command_time(cmd_time, mb_idx) command_time_set = True except RuntimeError: sys.stderr.write('[{prefix}] [WARNING] Failed to set command times.\n'.format(prefix=self.prefix)) for i, chan in enumerate(self.channels): self.tr = self.usrp.set_center_freq(treq, i) if self.tr is None: sys.stderr.write('[{prefix}] [ERROR] Failed to set center frequency on channel {chan}\n'.format( prefix=self.prefix, chan=chan )) sys.exit(1) if command_time_set: for mb_idx in range(self.usrp.get_num_mboards()): self.usrp.clear_command_time(mb_idx) self.vprint("Syncing channels...".format(prefix=self.prefix)) time.sleep(COMMAND_DELAY) self.freq = self.usrp.get_center_freq(0) self.vprint("First channel has freq: {freq} MHz.".format(freq=self.freq / 1e6))
def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate Qt.QMetaObject.invokeMethod(self._samp_rate_line_edit, "setText", Qt.Q_ARG("QString", eng_notation.num_to_str(self.samp_rate))) self.uhd_usrp_source_1.set_samp_rate(self.samp_rate) self.uhd_usrp_source_1.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2.0), 0) self.uhd_usrp_source_1.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2.0), 1) self.set_samps_per_symb(self.samp_rate/10/self.decim*self.interp/self.baud) self.qtgui_waterfall_sink_x_0_0.set_frequency_range(0, self.samp_rate) self.qtgui_waterfall_sink_x_0.set_frequency_range(0, self.samp_rate) self.qtgui_freq_sink_x_0_0.set_frequency_range(0, self.samp_rate) self.qtgui_freq_sink_x_0.set_frequency_range(0, self.samp_rate)
def set_freq(self, freq): self.freq = freq self._freq_callback(self.freq) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=self.freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.uhd_usrp_sink_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=self.freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
def set_freq(self, freq): self.freq = freq r = self.uhd_usrp_sink_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=(self.freq + self.lo_offset), rf_freq_policy=uhd.tune_request.POLICY_MANUAL)) g = self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=(self.freq + self.lo_offset), rf_freq_policy=uhd.tune_request.POLICY_MANUAL)) print "USRP Sink ", r print "USRP Source ", g
def set_freq(self, freq, skip_sync=False): """ Safely tune all channels to freq. """ self.vprint("Tuning all channels to {freq} MHz.".format(freq=freq/1e6)) # Set frequency (tune request takes lo_offset): if hasattr(self.args, 'lo_offset') and self.args.lo_offset is not None: treq = uhd.tune_request(freq, self.args.lo_offset) else: treq = uhd.tune_request(freq) # Special TwinRX tuning due to LO sharing if getattr(self, 'lo_source_channel', None) is not None: tune_resp = self.usrp.set_center_freq(treq, self.lo_source_channel) if getattr(self.args, 'lo_offset', None) is not None: treq = uhd.tune_request(target_freq=freq, rf_freq=freq+self.args.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL, dsp_freq=tune_resp.actual_dsp_freq, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL) else: treq = uhd.tune_request(target_freq=freq, rf_freq=freq, rf_freq_policy=uhd.tune_reqest.POLICY_MANUAL, dsp_freq=tune_resp.actual_dsp_freq, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL) for chan in self.channels: if chan == self.lo_source_channel: continue self.usrp.set_center_freq(treq,chan) # Make sure tuning is synched: command_time_set = False if len(self.channels) > 1 and not skip_sync: cmd_time = self.usrp.get_time_now() + uhd.time_spec(COMMAND_DELAY) try: for mb_idx in xrange(self.usrp.get_num_mboards()): self.usrp.set_command_time(cmd_time, mb_idx) command_time_set = True except RuntimeError: sys.stderr.write('[{prefix}] [WARNING] Failed to set command times.\n'.format(prefix=self.prefix)) for i, chan in enumerate(self.channels ): self.tr = self.usrp.set_center_freq(treq, i) if self.tr == None: sys.stderr.write('[{prefix}] [ERROR] Failed to set center frequency on channel {chan}\n'.format( prefix=self.prefix, chan=chan )) exit(1) if command_time_set: for mb_idx in xrange(self.usrp.get_num_mboards()): self.usrp.clear_command_time(mb_idx) self.vprint("Syncing channels...".format(prefix=self.prefix)) time.sleep(COMMAND_DELAY) self.freq = self.usrp.get_center_freq(0) self.vprint("First channel has freq: {freq} MHz.".format(freq=self.freq/1e6))
def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate Qt.QMetaObject.invokeMethod( self._samp_rate_line_edit, "setText", Qt.Q_ARG("QString", eng_notation.num_to_str(self.samp_rate))) self.uhd_usrp_source_0_0.set_samp_rate(self.samp_rate) self.uhd_usrp_source_0_0.set_center_freq( uhd.tune_request(self.fc_modes, self.samp_rate / 2), 0) self.uhd_usrp_source_0.set_samp_rate(self.samp_rate * 2) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.fc_tcas, self.samp_rate / 2), 0) self.qtgui_freq_sink_x_0_0.set_frequency_range(0, self.samp_rate) self.qtgui_freq_sink_x_0.set_frequency_range(0, self.samp_rate) self.fosphor_qt_sink_c_0_0.set_frequency_range(0, self.samp_rate) self.fosphor_qt_sink_c_0.set_frequency_range(0, self.samp_rate * 2)
def set_freq(self, freq=None, lo_offset=None): if(freq is None): sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") sys.exit(1) r = self.u.set_center_freq(uhd.tune_request(freq, lo_offset),0) if(self._ismimo): s = self.u.set_center_freq(uhd.tune_request(freq, lo_offset),1) if r: return "FREQ", freq else: frange = self.u.get_freq_range() sys.stderr.write(("\nRequested frequency (%f) out or range [%f, %f]\n") % \ (freq, frange.start(), frange.stop())) sys.exit(1)
def set_freq(self, freq=None, lo_offset=None): if (freq is None): sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") sys.exit(1) r = self.u.set_center_freq(uhd.tune_request(freq, lo_offset), 0) if (self._ismimo): s = self.u.set_center_freq(uhd.tune_request(freq, lo_offset), 1) if r: return "FREQ", freq else: frange = self.u.get_freq_range() sys.stderr.write(("\nRequested frequency (%f) out or range [%f, %f]\n") % \ (freq, frange.start(), frange.stop())) sys.exit(1)
def __init__(self): gr.top_block.__init__(self) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 25e6 self.lo_off = lo_off = 0 self.gain = gain = 28 self.freq_l2 = freq_l2 = 1.22760e9 self.freq_l1 = freq_l1 = 1.57542e9 ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="addr0=192.168.10.3,addr1=192.168.10.2", stream_args=uhd.stream_args( cpu_format="sc16", otw_format="sc8", channels=range(2), ), ) self.uhd_usrp_source_0.set_clock_source("gpsdo", 0) self.uhd_usrp_source_0.set_time_source("gpsdo", 0) self.uhd_usrp_source_0.set_clock_source("mimo", 1) self.uhd_usrp_source_0.set_time_source("mimo", 1) self.uhd_usrp_source_0.set_samp_rate(samp_rate) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(freq_l1, lo_off), 0) self.uhd_usrp_source_0.set_gain(gain, 0) self.uhd_usrp_source_0.set_antenna("RX2", 0) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(freq_l2, lo_off), 1) self.uhd_usrp_source_0.set_gain(gain, 1) self.uhd_usrp_source_0.set_antenna("RX2", 1) self.blocks_file_sink_1 = blocks.file_sink( gr.sizeof_int * 1, "/media/is4s/512GB_SSD/usrp_l2.dat", False) self.blocks_file_sink_1.set_unbuffered(False) self.blocks_file_sink_0 = blocks.file_sink( gr.sizeof_int * 1, "/media/is4s/512GB_SSD/usrp_l1.dat", False) self.blocks_file_sink_0.set_unbuffered(False) ################################################## # Connections ################################################## self.connect((self.uhd_usrp_source_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.uhd_usrp_source_0, 1), (self.blocks_file_sink_1, 0))
def set_freq(self, freq): self.freq = freq self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=self.freq - self.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.ieee802_11_frame_equalizer_0.set_frequency(self.freq)
def setup_usrp_sources(self): print 'setup_usrp_sources' self.rcvs = [] for i in range(self.n_devices): self.rcvs.append( uhd.usrp_source( self.addrs[i], stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), )) if (self._node_type == CLUSTER_NODE): self.rcvs[i].set_start_on_demand( ) # the sensor will start sensing onmand if self.rcvs[i].get_time_source(0) == "none": self.rcvs[i].set_time_source( "mimo", 0) # Set the time source without GPS to MIMO cable self.rcvs[i].set_clock_source("mimo", 0) else: self.rcvs[i].set_clock_source("external", 0) self.rcvs[i].set_samp_rate(self.sample_rate) #self.rcvs[i].set_center_freq(self.center_freq, 0) self.rcvs[i].set_center_freq( uhd.tune_request(self.center_freq, self.sample_rate * 12), 0) if (self.rx_gain): self.rcvs[i].set_gain(self.rx_gain, 0) self.rcvs[i].set_antenna("RX2", 0)
def _init_rx_connection(self, ettus_id, samp_rate, freq_0, freq_offset, gain): """ Establish a recieving connection to an Ettus device uing the UHD protocol. Parameters ---------- ettus_id : str The serial number of the ettus device samp_rate : int The sample rate desired from the reciever. freq_0 : float The desired centre frequency of the passband freq_offset : float The local oscillator offset, used to remove the peak produced by the LO. gain : float The desired gain from the receiver. """ # # We need to set up a connection to the Ettus receiver # self.rx_con = uhd.usrp_source( ",".join(("serial="+ettus_id, "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ) ) self.rx_con.set_samp_rate(samp_rate) self.rx_con.set_center_freq(uhd.tune_request(freq_0 , -freq_offset), 0) self.rx_con.set_gain(gain, 0)
def set_center_freq(self, center_freq, sources): # Tune all channels to the desired frequency tune_resp = self.uhd_usrp_source_0.set_center_freq(center_freq, 0) tune_req = uhd.tune_request( rf_freq=center_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL, dsp_freq=tune_resp.actual_dsp_freq, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL) self.uhd_usrp_source_0.set_center_freq(tune_req, 1) if sources == 4: self.uhd_usrp_source_0.set_center_freq(tune_req, 2) self.uhd_usrp_source_0.set_center_freq(tune_req, 3) # Synchronize the tuned channels now = self.uhd_usrp_source_0.get_time_now() self.uhd_usrp_source_0.set_command_time(now + uhd.time_spec(0.01)) self.uhd_usrp_source_0.set_center_freq(tune_req, 0) self.uhd_usrp_source_0.set_center_freq(tune_req, 1) if sources == 4: self.uhd_usrp_source_0.set_center_freq(tune_req, 2) self.uhd_usrp_source_0.set_center_freq(tune_req, 3) self.uhd_usrp_source_0.clear_command_time()
def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate self.set_samp_per_sym( (self.samp_rate / self.decim / 50 * 48) / self.baud) self.uhd_usrp_source_1.set_samp_rate(self.samp_rate) self.uhd_usrp_source_1.set_center_freq( uhd.tune_request(self.rx_freq, self.samp_rate / 2), 0) self.qtgui_waterfall_sink_x_0_1.set_frequency_range( self.rx_freq, self.samp_rate / 2) self.qtgui_freq_sink_x_0.set_frequency_range(self.rx_freq, self.samp_rate / 2) self.low_pass_filter_0_0.set_taps( firdes.low_pass(1, self.samp_rate, 7e3, 1e3, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0.set_taps( firdes.low_pass(1, self.samp_rate, 7e3, 1e3, firdes.WIN_HAMMING, 6.76)) self.analog_sig_source_x_1.set_sampling_freq(self.samp_rate) self.analog_sig_source_x_0_0.set_sampling_freq(self.samp_rate) self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate) self.analog_quadrature_demod_cf_0_0.set_gain( (self.samp_rate / self.decim) / (2 * math.pi * self.fsk_deviation / 8.0)) self.analog_quadrature_demod_cf_0.set_gain( (self.samp_rate / self.decim) / (2 * math.pi * self.fsk_deviation / 8.0))
def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate self.uhd_usrp_source_0.set_samp_rate(self.samp_rate) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2), 0) self.qtgui_waterfall_sink_x_0.set_frequency_range(0, self.samp_rate) self.qtgui_freq_sink_x_0.set_frequency_range(0, self.samp_rate) self.set_fn("ORBCOMM_{:s}_{:s}_{:s}_{:s}k.fc32".format(self.sat_name, self.radio_id, self.ts_str, str(int(self.samp_rate/self.decim)/1000)))
def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate self.uhd_usrp_source_0.set_samp_rate(self.samp_rate) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.freq, self.samp_rate/2), 0) self.qtgui_waterfall_sink_x_0.set_frequency_range(0, self.samp_rate) self.qtgui_time_sink_x_0.set_samp_rate(self.samp_rate) self.qtgui_freq_sink_x_0.set_frequency_range(0, self.samp_rate)
def set_fine(self, fine): self.fine = fine Qt.QMetaObject.invokeMethod( self._fine_line_edit, "setText", Qt.Q_ARG("QString", eng_notation.num_to_str(self.fine))) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.rx_freq + self.fine, self.samp_rate / 2), 0)
def __init__(self, options, filename): gr.top_block.__init__(self) inf_str = None symbol_rate = 152.34e3 sample_rate = 1e6 #if len(options) != 0: # inf_str = args[0] squelch = analog.pwr_squelch_cc(float(options.squelch), 0.1, 0, True) demod = analog.quadrature_demod_cf(1.0) cr = digital.clock_recovery_mm_ff(sample_rate/symbol_rate, 0.00765625, 0, 0.175, 0.005) slicer = digital.binary_slicer_fb() corr = digital.correlate_access_code_bb(AC, 3) sink = sniffer() if False: print "Reading from: " + inf_str src = blocks.file_source(gr.sizeof_gr_complex, inf_str, False) else: freqs = { 'AA':917.0e6, 'AB':913.0e6, 'AC':914.0e6, 'AD':915.0e6, 'BA':916.0e6, 'BB':919.0e6, 'BC':920.0e6, 'BD':921.0e6, 'CA':922.0e6, 'CB':923.0e6, 'CC':907.0e6, 'CD':908.0e6, 'DA':905.5e6, 'DB':909.0e6, 'DC':911.0e6, 'DD':910.0e6} frequency = freqs[options.channel] print "Channel: " + options.channel + " (" + str(frequency/1e6) + "MHz)" # Create a UHD device source src = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32', "sc16", args="")) # Set the subdevice spec if(options.spec): src.set_subdev_spec(options.spec, 0) # Set the antenna if(options.antenna): src.set_antenna(options.antenna, 0) # Set receiver sample rate src.set_samp_rate(options.samp_rate) # Set receive daughterboard gain if options.gain is None: g = src.get_gain_range() options.gain = float(g.start()+g.stop())/2 print "Using mid-point gain of", options.gain, "(", g.start(), "-", g.stop(), ")" src.set_gain(options.gain) # Set frequency (tune request takes lo_offset) treq = uhd.tune_request(frequency) tr = src.set_center_freq(treq) if tr == None: sys.stderr.write('Failed to set center frequency\n') raise SystemExit, 1 self.connect(src, squelch, demod, cr, slicer, corr, sink)
def set_tx_freq(self, tx_freq): self.tx_freq = tx_freq self.uhd_usrp_sink_0.set_center_freq( uhd.tune_request(self.tx_freq, dsp_freq=0, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
def set_rx_freq(self, rx_freq): self.rx_freq = rx_freq self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.rx_freq, dsp_freq=0, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate self.set_decim(self.samp_rate / 1e3) self.uhd_usrp_source_1_0.set_samp_rate(self.samp_rate) self.uhd_usrp_source_1_0.set_center_freq( uhd.tune_request(self.rx_freq, self.samp_rate / 2), 0) self.qtgui_time_sink_x_0_0.set_samp_rate(self.samp_rate / self.decim * self.interp / 3 / 4) self.qtgui_time_sink_x_0.set_samp_rate(self.samp_rate / self.decim * self.interp / 3) self.qtgui_freq_sink_x_0_0.set_frequency_range( 0, self.samp_rate / self.decim * self.interp / 3) self.qtgui_freq_sink_x_0.set_frequency_range( 0, self.samp_rate / self.decim * self.interp) self.low_pass_filter_0_1.set_taps( firdes.low_pass(1, self.samp_rate / self.decim * self.interp / 3, 1.5e3, 100, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0_0_0.set_taps( firdes.low_pass(1, self.samp_rate / self.decim * self.interp, self.lpf_cutoff, 100, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0_0.set_taps( firdes.low_pass(1, self.samp_rate / self.decim * self.interp, self.lpf_cutoff, 100, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0.set_taps( firdes.low_pass(1, self.samp_rate / self.decim * self.interp / 3, 1.5e3, 100, firdes.WIN_HAMMING, 6.76)) self.fosphor_qt_sink_c_0.set_frequency_range( self.rx_freq, self.samp_rate / int(self.samp_rate / 1e3) * 200) self.analog_sig_source_x_0_0_0.set_sampling_freq( self.samp_rate / self.decim * self.interp / 3) self.analog_sig_source_x_0_0.set_sampling_freq( self.samp_rate / self.decim * self.interp / 3) self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate)
def set_freq(self, freq): self.freq = freq self.wifi_phy_hier_0.set_frequency(self.freq) self.uhd_usrp_sink_0.set_center_freq( uhd.tune_request(self.freq, rf_freq=self.freq - self.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
def set_RF_tuner(self, RF_tuner): self.RF_tuner = RF_tuner self.cwradar_doppler_velocity_single_target_ff_0.set_radar_freq(self.RF_tuner) self._RF_tuner_slider.set_value(self.RF_tuner) self._RF_tuner_text_box.set_value(self.RF_tuner) self.usrp_receiver.set_center_freq(uhd.tune_request(self.RF_tuner, self.lo_offset_freq), 0) self.usrp_transmitter.set_center_freq(self.RF_tuner, 0)
def set_apt_freq(self, apt_freq): self.apt_freq = apt_freq Qt.QMetaObject.invokeMethod( self._apt_freq_line_edit, "setText", Qt.Q_ARG("QString", eng_notation.num_to_str(self.apt_freq))) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.apt_freq, self.samp_rate / 2), 0)
def __init__(self): gr.top_block.__init__(self) self.samp_rate = samp_rate = 1000000 self.dump_freq = dump_freq = 2400490000 self._u = uhd.usrp_source( device_addr="%default", io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=1) self._u.set_gain(0, 0) self._u.set_samp_rate(self.samp_rate) treq = uhd.tune_request(self.dump_freq, 0) tr = self._u.set_center_freq(treq) if tr == None: sys.stderr.write('Failed to set center frequency\n') raise SystemExit, 1 self.filter1 = gr.interp_fir_filter_ccf(1, firdes.low_pass(1, samp_rate, 500000, 10000, firdes.WIN_HAMMING, 6.76)) self.squelch = gr.pwr_squelch_cc(-100, 0.001, 0, True) self.demod = gr.quadrature_demod_cf(1) self.sync = digital.clock_recovery_mm_ff(2, 0.0076562, 0.5, 0.175, 0.005) self.slicer = digital.binary_slicer_fb() self.detect_seq = digital.correlate_access_code_bb("01010101010101010101010101010101", 1) self.dump = flysky.dumpsync() self.connect(self._u,self.filter1,self.squelch,self.demod,self.sync,self.slicer,self.detect_seq, self.dump)
def set_frequency(self, freq): tune_request = uhd.tune_request(freq, self.profile.usrp_lo_offset) if self.profile.usrp_use_integerN_tuning: tune_request.args = uhd.device_addr('mode_n=integer') tune_result = self.usrp.set_center_freq(tune_request) print(tune_result.to_pp_string())
def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate self.set_samps_per_symb(self.samp_rate / self.decim / self.baud) self.uhd_usrp_source_0.set_samp_rate(self.samp_rate) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.rx_freq, self.samp_rate / 2), 0) self.qtgui_waterfall_sink_x_0_0.set_frequency_range( 0, self.samp_rate / self.decim) self.qtgui_waterfall_sink_x_0.set_frequency_range( 0, self.samp_rate / self.decim) self.qtgui_time_sink_x_0.set_samp_rate(self.samp_rate / self.decim / 50 * 48) self.qtgui_freq_sink_x_0.set_frequency_range( 0, self.samp_rate / self.decim) self.low_pass_filter_0_0_0.set_taps( firdes.low_pass(1, self.samp_rate / self.decim / 50 * 48, self.audio_lpf_cutoff, 2e3, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0_0.set_taps( firdes.low_pass(1, self.samp_rate / self.decim, self.rf_lpf_cutoff, 2e3, firdes.WIN_HAMMING, 6.76)) self.set_fn("{:s}_{:s}_{:s}_{:s}k.fc32".format( self.sat_name, self.radio_id, self.ts_str, str(int(self.samp_rate) / 1000))) self.blocks_multiply_const_vxx_1.set_k( (-1 * self.samp_rate / self.decim / (2 * math.pi), )) self.blocks_keep_one_in_n_0_0.set_n( int(self.samp_rate * self.meta_rate)) self.blocks_keep_one_in_n_0.set_n( int(self.samp_rate / 4 * self.meta_rate)) self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate) self.analog_sig_source_x_0.set_frequency(self.samp_rate / 2) self.analog_quadrature_demod_cf_0.set_gain( self.samp_rate / (2 * math.pi * self.fsk_deviation_hz / 8.0))
def __init__(self): gr.top_block.__init__(self) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 25e6 self.lo_off = lo_off = 0 self.freq_l1 = freq_l1 = 1.57542e6 ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="", stream_args=uhd.stream_args( cpu_format="sc16", otw_format="sc16", channels=range(1), ), ) self.uhd_usrp_source_0.set_clock_source("gpsdo", 0) self.uhd_usrp_source_0.set_samp_rate(samp_rate) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(freq_l1, lo_off), 0) self.uhd_usrp_source_0.set_gain(35, 0) self.uhd_usrp_source_0.set_antenna("RX2", 0) #self.uhd_usrp_source_0.set_antenna("TX/RX", 0) #self.uhd_usrp_source_0.set_bandwidth(20e6, 0) self.blocks_vector_sink_x_0 = blocks.vector_sink_i(1) ################################################## # Connections ################################################## self.connect((self.uhd_usrp_source_0, 0), (self.blocks_vector_sink_x_0, 0))
def set_vor_freq_entry_1(self, vor_freq_entry_1): self.vor_freq_entry_1 = vor_freq_entry_1 self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(self.vor_freq_entry_1, rf_freq=self.band_center_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 1) self._vor_freq_entry_1_text_box.set_value(self.vor_freq_entry_1)
def set_freq(self, target_freq): """ Set the center frequency we're interested in. @param target_freq: frequency in Hz @rypte: bool """ #r = self.u.set_center_freq(target_freq, 0) r = self.u.set_center_freq(uhd.tune_request(target_freq, 4e6), 0) print '%s ' % (r.to_pp_string()) self.u.stop() print 'In locking ' while (self.u.get_sensor("lo_locked").to_bool() == False): print '.' print 'Locked' print 'actual center freq = %d ' % (self.u.get_center_freq() + 5000000) self.u.start() if r: self.myform['freq'].set_value(self.u.get_center_freq() + 5000000) self.myform['rffreq'].set_value(r.actual_rf_freq) self.myform['dspfreq'].set_value(r.actual_dsp_freq) if not self.options.oscilloscope: self.scope.set_baseband_freq(target_freq) return True return False
def __init__(self, filename, dev_addrs, onebit, gain, digital_gain, fs, fc, sync_pps): gr.top_block.__init__(self) if onebit: raise NotImplementedError("TODO: 1-bit mode not implemented.") uhd_srcs = [ uhd.usrp_source(",".join( [addr, "num_recv_frames=256,recv_frame_size=16384"]), uhd.stream_args( cpu_format="fc32", otwformat="sc16", channels=[0])) for addr in dev_addrs] str2vec = blocks.streams_to_vector(2, len(uhd_srcs)) self.connect(str2vec, blocks.stream_to_vector(2 * len(uhd_srcs), 16*1024*1024), blocks.file_sink(2 * len(uhd_srcs) * 16 * 1024 * 1024, filename, False)) for ix, src in enumerate(uhd_srcs): src.set_clock_rate(fs*2, uhd.ALL_MBOARDS) src.set_samp_rate(fs) src.set_center_freq(uhd.tune_request(fc, 3e6)) src.set_gain(gain, 0) # TODO Use offset tuning? if sync_pps: src.set_clock_source("external") # 10 MHz src.set_time_source("external") # PPS self.connect(src, # [-1.0, 1.0] blocks.multiply_const_cc(32767 * digital_gain[ix]), # [-32767.0, 32767.0] blocks.complex_to_interleaved_short(), #[-32768, 32767] blocks.short_to_char(), #[-128, 127] blocks.stream_to_vector(1, 2), # I,Q,I,Q -> IQ, IQ (str2vec, ix)) print "Setting clocks..." if sync_pps: time.sleep(1.1) # Ensure there's been an edge. TODO: necessary? last_pps_time = uhd_srcs[0].get_time_last_pps() while last_pps_time == uhd_srcs[0].get_time_last_pps(): time.sleep(0.1) print "Got edge" [src.set_time_next_pps(uhd.time_spec(round(time.time())+1)) for src in uhd_srcs] time.sleep(1.0) # Wait for edge to set the clocks else: # No external PPS/10 MHz. Just set each clock and accept some skew. t = time.time() [src.set_time_now(uhd.time_spec(time.time())) for src in uhd_srcs] if len(uhd_srcs) > 1: print "Uncabled; loosely synced only. Initial skew ~ %.1f ms" % ( (time.time()-t) * 1000) t_start = uhd.time_spec(time.time() + 1.5) [src.set_start_time(t_start) for src in uhd_srcs] print "ready"
def __init__(self): gr.top_block.__init__(self) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 25e6 self.lo_off = lo_off = 0 self.gain = gain = 28 self.freq_l2 = freq_l2 = 1.22760e9 self.freq_l1 = freq_l1 = 1.57542e9 ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="addr0=192.168.10.3,addr1=192.168.10.2", stream_args=uhd.stream_args( cpu_format="sc16", otw_format="sc8", channels=range(2), ), ) self.uhd_usrp_source_0.set_clock_source("gpsdo", 0) self.uhd_usrp_source_0.set_time_source("gpsdo", 0) self.uhd_usrp_source_0.set_clock_source("mimo", 1) self.uhd_usrp_source_0.set_time_source("mimo", 1) self.uhd_usrp_source_0.set_samp_rate(samp_rate) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(freq_l1, lo_off), 0) self.uhd_usrp_source_0.set_gain(gain, 0) self.uhd_usrp_source_0.set_antenna("RX2", 0) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(freq_l2, lo_off), 1) self.uhd_usrp_source_0.set_gain(gain, 1) self.uhd_usrp_source_0.set_antenna("RX2", 1) self.blocks_file_sink_1 = blocks.file_sink(gr.sizeof_int*1, "/media/is4s/512GB_SSD/usrp_l2.dat", False) self.blocks_file_sink_1.set_unbuffered(False) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_int*1, "/media/is4s/512GB_SSD/usrp_l1.dat", False) self.blocks_file_sink_0.set_unbuffered(False) ################################################## # Connections ################################################## self.connect((self.uhd_usrp_source_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.uhd_usrp_source_0, 1), (self.blocks_file_sink_1, 0))
def set_frequency(self, frequency): """ Method to tune the USRP to the desired frequency. Args: frequency: Desired center freqeuncy """ if self.center_freq != frequency: print "Tuning to", frequency / 1e9, "GHz" self.center_freq = frequency self.uhd.set_center_freq(uhd.tune_request(frequency, self.lo_offset), 0)
def set_freq(self, target_freq): """ Set the center frequency we're interested in. @param target_freq: frequency in Hz @rypte: bool """ r = self.u.set_center_freq(uhd.tune_request(target_freq, rf_freq=(target_freq + self.lo_offset),rf_freq_policy=uhd.tune_request.POLICY_MANUAL)) if r: return True return False
def __init__(self, args, sym_rate, sps, freq=None, lo_offset=None, gain=None, spec=None, antenna=None, clock_source=None, verbose=False): gr.hier_block2.__init__(self, "uhd_receiver", gr.io_signature(0,0,0), gr.io_signature(1,1,gr.sizeof_gr_complex)) # Set up the UHD interface as a receiver uhd_interface.__init__(self, False, args, sym_rate, sps, freq, lo_offset, gain, spec, antenna, clock_source) # Set frequency (tune request takes lo_offset) if(options.lo_offset is not None): treq = uhd.tune_request(freq, options.lo_offset) else: treq = uhd.tune_request(freq) tr = self.u.set_center_freq(treq) if tr == None: sys.stderr.write('Failed to set center frequency\n') raise SystemExit, 1 self.connect(self.u, self) if(verbose): self._print_verbage()
def setup_usrp_sinks(self): print 'setup_usrp_sinks' self.sinks = [] for i in range(self.n_devices): self.sinks.append(uhd.usrp_sink(self.addrs[i], stream_args=uhd.stream_args(cpu_format="fc32", channels=range(1), ), ) ) self.sinks[i].set_samp_rate(self.sample_rate) #self.sinks[i].set_center_freq(self.center_freq, 0) self.sinks[i].set_center_freq(uhd.tune_request(self.center_freq, self.sample_rate*12), 0) if(self.tx_gain): self.sinks[i].set_gain(self.tx_gain, 0) self.sinks[i].set_antenna("TX/RX", 0) if self.sinks[i].get_time_source(0) == "none": self.sinks[i].set_time_source("mimo", 0) # Set the time source without GPS to MIMO cable self.sinks[i].set_clock_source("mimo",0) else: self.sinks[i].set_clock_source("external", 0) #generate the random datafile for the transmitter if read data from file if self.randbinfile != 0: txfile_name = '/home/alexzh/' + self.addrs[i] + '_randtx' xfile = '/home/alexzh/' + self.addrs[i] + '_x' try: with open(txfile_name, 'r'): source_file = open(txfile_name, 'r') try: with open(xfile, 'r'): xfileid = open(xfile, 'r') except IOError: with open(xfile, 'wb') as fout: print 'Gnerating the repeated packet file for x sequence' source_file.seek(0) bytes_per_slot = int( ( SLOT_INTV - GRD_INTV ) * self.link_rate / 8 ) xpkt = source_file.read(bytes_per_slot - 64 -100) fout.write(xpkt) except IOError: with open(txfile_name, 'wb') as fout: print 'Generating Random binary file.... waiting' fout.write(os.urandom(1280000000)) #generate a file of 8M random data print '1.28G random binary file genearted'
def __init__(self, demodulator, rx_callback, options): gr.top_block.__init__(self) if(options.rx_freq is not None): # Work-around to get the modulation's bits_per_symbol args = demodulator.extract_kwargs_from_options(options) symbol_rate = options.bitrate / demodulator(**args).bits_per_symbol() ask_sample_rate = symbol_rate*options.samples_per_symbol self.source = uhd_receiver(options.args, symbol_rate, options.samples_per_symbol, options.rx_freq, options.rx_gain, options.spec, options.antenna, options.verbose) options.samples_per_symbol = self.source._sps self.source.u.set_center_freq(uhd.tune_request(options.rx_freq, ask_sample_rate*2), 0) print 'In locking ' while (self.source.u.get_sensor("lo_locked").to_bool() == False): print '.' print 'Locked' elif(options.from_file is not None): sys.stderr.write(("Reading samples from '%s'.\n\n" % (options.from_file))) self.source = gr.file_source(gr.sizeof_gr_complex, options.from_file) else: sys.stderr.write("No source defined, pulling samples from null source.\n\n") self.source = gr.null_source(gr.sizeof_gr_complex) # Set up receive path # do this after for any adjustments to the options that may # occur in the sinks (specifically the UHD sink) self.rxpath = receive_path(demodulator, rx_callback, options) self.connect(self.source, self.rxpath) self.connect(self.source, gr.file_sink(gr.sizeof_gr_complex, "benchmark_sensing.dat")) self.timer = threading.Timer(1, self.start_streaming)
def setup_usrp_sources(self): print 'setup_usrp_sources' self.rcvs = [] for i in range(self.n_devices): self.rcvs.append(uhd.usrp_source(self.addrs[i], stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) ) if(self._node_type == CLUSTER_NODE): self.rcvs[i].set_start_on_demand() # the sensor will start sensing onmand if self.rcvs[i].get_time_source(0) == "none": self.rcvs[i].set_time_source("mimo", 0) # Set the time source without GPS to MIMO cable self.rcvs[i].set_clock_source("mimo",0) else: self.rcvs[i].set_clock_source("external", 0) self.rcvs[i].set_samp_rate(self.sample_rate) #self.rcvs[i].set_center_freq(self.center_freq, 0) self.rcvs[i].set_center_freq(uhd.tune_request(self.center_freq, self.sample_rate*12), 0) if(self.rx_gain): self.rcvs[i].set_gain(self.rx_gain, 0) self.rcvs[i].set_antenna("RX2", 0)
def __init__(self, lo_offset_freq=1e6, threshold_dB=-70, RF=2.49e9, DC_filter_num_elements=4, speed_samp_rate=1, samp_rate=1e6, highpass_cutoff_freq=0, lowpass_cutoff_freq=1700, fft_len=pow(2,20), samp_rate_sink=8000, angle=0, tx_amp=1, rx_gain=30.5): grc_wxgui.top_block_gui.__init__(self, title="CW Radar Single Target") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Parameters ################################################## self.lo_offset_freq = lo_offset_freq self.threshold_dB = threshold_dB self.RF = RF self.DC_filter_num_elements = DC_filter_num_elements self.speed_samp_rate = speed_samp_rate self.samp_rate = samp_rate self.highpass_cutoff_freq = highpass_cutoff_freq self.lowpass_cutoff_freq = lowpass_cutoff_freq self.fft_len = fft_len self.samp_rate_sink = samp_rate_sink self.angle = angle self.tx_amp = tx_amp self.rx_gain = rx_gain ################################################## # Variables ################################################## self.target_speed = target_speed = 0 self.target_direction = target_direction = 0 self.tx_amp_tuner = tx_amp_tuner = tx_amp self.threshold_dB_tuner = threshold_dB_tuner = threshold_dB self.speed_textbox = speed_textbox = target_speed self.rx_gain_tuner = rx_gain_tuner = rx_gain self.lowpass_cutoff_freq_tuner = lowpass_cutoff_freq_tuner = lowpass_cutoff_freq self.highpass_cutoff_freq_tuner = highpass_cutoff_freq_tuner = highpass_cutoff_freq self.direction_textbox = direction_textbox = target_direction self.angle_tuner = angle_tuner = angle self.RF_tuner = RF_tuner = RF ################################################## # Blocks ################################################## _tx_amp_tuner_sizer = wx.BoxSizer(wx.VERTICAL) self._tx_amp_tuner_text_box = forms.text_box( parent=self.GetWin(), sizer=_tx_amp_tuner_sizer, value=self.tx_amp_tuner, callback=self.set_tx_amp_tuner, label="TX Signal Amp", converter=forms.float_converter(), proportion=0, ) self._tx_amp_tuner_slider = forms.slider( parent=self.GetWin(), sizer=_tx_amp_tuner_sizer, value=self.tx_amp_tuner, callback=self.set_tx_amp_tuner, minimum=0, maximum=1, num_steps=1000, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_tx_amp_tuner_sizer, 0, 17, 1, 26) _threshold_dB_tuner_sizer = wx.BoxSizer(wx.VERTICAL) self._threshold_dB_tuner_text_box = forms.text_box( parent=self.GetWin(), sizer=_threshold_dB_tuner_sizer, value=self.threshold_dB_tuner, callback=self.set_threshold_dB_tuner, label="Detected Target Threshold (dB)", converter=forms.float_converter(), proportion=0, ) self._threshold_dB_tuner_slider = forms.slider( parent=self.GetWin(), sizer=_threshold_dB_tuner_sizer, value=self.threshold_dB_tuner, callback=self.set_threshold_dB_tuner, minimum=-90, maximum=-30, num_steps=60, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_threshold_dB_tuner_sizer, 2, 0, 1, 17) self.speed_probe = blocks.probe_signal_f() _rx_gain_tuner_sizer = wx.BoxSizer(wx.VERTICAL) self._rx_gain_tuner_text_box = forms.text_box( parent=self.GetWin(), sizer=_rx_gain_tuner_sizer, value=self.rx_gain_tuner, callback=self.set_rx_gain_tuner, label="USRP RX Gain (dB)", converter=forms.float_converter(), proportion=0, ) self._rx_gain_tuner_slider = forms.slider( parent=self.GetWin(), sizer=_rx_gain_tuner_sizer, value=self.rx_gain_tuner, callback=self.set_rx_gain_tuner, minimum=0, maximum=30.5 + 62, num_steps=185, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_rx_gain_tuner_sizer, 0, 0, 1, 17) self.notebook = self.notebook = wx.Notebook(self.GetWin(), style=wx.NB_TOP) self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "FFT CW Doppler Radar Receiver") self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "Frequency/Time CW Doppler Radar Receiver") self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "FFT CW Doppler Radar Receiver Full Spectrum") self.GridAdd(self.notebook, 5, 0, 13, 75) _lowpass_cutoff_freq_tuner_sizer = wx.BoxSizer(wx.VERTICAL) self._lowpass_cutoff_freq_tuner_text_box = forms.text_box( parent=self.GetWin(), sizer=_lowpass_cutoff_freq_tuner_sizer, value=self.lowpass_cutoff_freq_tuner, callback=self.set_lowpass_cutoff_freq_tuner, label="Lowpass Cutoff Frequency (Hz)", converter=forms.float_converter(), proportion=0, ) self._lowpass_cutoff_freq_tuner_slider = forms.slider( parent=self.GetWin(), sizer=_lowpass_cutoff_freq_tuner_sizer, value=self.lowpass_cutoff_freq_tuner, callback=self.set_lowpass_cutoff_freq_tuner, minimum=0, maximum=3000, num_steps=1000, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_lowpass_cutoff_freq_tuner_sizer, 1, 43, 1, 32) _highpass_cutoff_freq_tuner_sizer = wx.BoxSizer(wx.VERTICAL) self._highpass_cutoff_freq_tuner_text_box = forms.text_box( parent=self.GetWin(), sizer=_highpass_cutoff_freq_tuner_sizer, value=self.highpass_cutoff_freq_tuner, callback=self.set_highpass_cutoff_freq_tuner, label="High-Pass Cutoff Frequency (Hz)", converter=forms.float_converter(), proportion=0, ) self._highpass_cutoff_freq_tuner_slider = forms.slider( parent=self.GetWin(), sizer=_highpass_cutoff_freq_tuner_sizer, value=self.highpass_cutoff_freq_tuner, callback=self.set_highpass_cutoff_freq_tuner, minimum=0, maximum=1600, num_steps=1000, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_highpass_cutoff_freq_tuner_sizer, 0, 43, 1, 32) self.direction_probe = blocks.probe_signal_i() _angle_tuner_sizer = wx.BoxSizer(wx.VERTICAL) self._angle_tuner_text_box = forms.text_box( parent=self.GetWin(), sizer=_angle_tuner_sizer, value=self.angle_tuner, callback=self.set_angle_tuner, label="Angle of Approach of the Target (Deg)", converter=forms.float_converter(), proportion=0, ) self._angle_tuner_slider = forms.slider( parent=self.GetWin(), sizer=_angle_tuner_sizer, value=self.angle_tuner, callback=self.set_angle_tuner, minimum=0, maximum=89, num_steps=890, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_angle_tuner_sizer, 1, 17, 1, 26) _RF_tuner_sizer = wx.BoxSizer(wx.VERTICAL) self._RF_tuner_text_box = forms.text_box( parent=self.GetWin(), sizer=_RF_tuner_sizer, value=self.RF_tuner, callback=self.set_RF_tuner, label="Radar Frequency (Hz)", converter=forms.float_converter(), proportion=0, ) self._RF_tuner_slider = forms.slider( parent=self.GetWin(), sizer=_RF_tuner_sizer, value=self.RF_tuner, callback=self.set_RF_tuner, minimum=2.4e9, maximum=2.5e9, num_steps=1000, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_RF_tuner_sizer, 1, 0, 1, 17) self.wxgui_waterfallsink = waterfallsink2.waterfall_sink_c( self.notebook.GetPage(1).GetWin(), baseband_freq=0, dynamic_range=100, ref_level=0, ref_scale=2.0, sample_rate=samp_rate_sink, fft_size=1024, fft_rate=100, average=False, avg_alpha=None, title="Time/Frequency CW Doppler Radar", win=window.blackmanharris, ) self.notebook.GetPage(1).Add(self.wxgui_waterfallsink.win) self.wxgui_fftsink2_full_spectrum = fftsink2.fft_sink_c( self.notebook.GetPage(2).GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate, fft_size=4096, fft_rate=15, average=False, avg_alpha=None, title="FFT CW Doppler Radar Receiver Full Spectrum", peak_hold=False, win=window.blackmanharris, ) self.notebook.GetPage(2).Add(self.wxgui_fftsink2_full_spectrum.win) self.wxgui_fftsink = fftsink2.fft_sink_c( self.notebook.GetPage(0).GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate_sink, fft_size=1024, fft_rate=100, average=False, avg_alpha=None, title="FFT CW Doppler Radar Receiver ", peak_hold=False, win=window.blackmanharris, ) self.notebook.GetPage(0).Add(self.wxgui_fftsink.win) self.usrp_transmitter = uhd.usrp_sink( ",".join(('addr=192.168.10.2', "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.usrp_transmitter.set_clock_source("internal", 0) self.usrp_transmitter.set_samp_rate(samp_rate) self.usrp_transmitter.set_center_freq(RF_tuner, 0) self.usrp_transmitter.set_gain(0, 0) self.usrp_transmitter.set_antenna('TX/RX', 0) self.usrp_receiver = uhd.usrp_source( ",".join(('addr=192.168.10.3', "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.usrp_receiver.set_clock_source("mimo", 0) self.usrp_receiver.set_time_source("mimo", 0) self.usrp_receiver.set_samp_rate(samp_rate) self.usrp_receiver.set_center_freq(uhd.tune_request(RF_tuner, lo_offset_freq), 0) self.usrp_receiver.set_gain(rx_gain_tuner, 0) self.usrp_receiver.set_antenna("J1", 0) self.usrp_receiver.set_bandwidth(15e6, 0) def _target_speed_probe(): while True: val = self.speed_probe.level() try: self.set_target_speed(val) except AttributeError: pass time.sleep(1.0 / (2)) _target_speed_thread = threading.Thread(target=_target_speed_probe) _target_speed_thread.daemon = True _target_speed_thread.start() def _target_direction_probe(): while True: val = self.direction_probe.level() try: self.set_target_direction(val) except AttributeError: pass time.sleep(1.0 / (2)) _target_direction_thread = threading.Thread(target=_target_direction_probe) _target_direction_thread.daemon = True _target_direction_thread.start() self._speed_textbox_text_box = forms.text_box( parent=self.GetWin(), value=self.speed_textbox, callback=self.set_speed_textbox, label="Target Speed (Kph)", converter=forms.float_converter(), ) self.GridAdd(self._speed_textbox_text_box, 3, 0, 1, 17) self.rational_resampler = filter.rational_resampler_ccc( interpolation=1, decimation=int(samp_rate/samp_rate_sink), taps=None, fractional_bw=None, ) self.fft_vxx_0 = fft.fft_vcc(fft_len, True, (window.blackmanharris(fft_len)), True, 1) self._direction_textbox_text_box = forms.text_box( parent=self.GetWin(), value=self.direction_textbox, callback=self.set_direction_textbox, label="Target Direction", converter=forms.str_converter(), ) self.GridAdd(self._direction_textbox_text_box, 4, 0, 1, 17) self.cwradar_vector_flip_ff = cwradar.vector_flip_ff(fft_len/2) self.cwradar_doppler_velocity_single_target_ff_0 = cwradar.doppler_velocity_single_target_ff(fft_len/2, samp_rate, RF_tuner, threshold_dB_tuner, angle_tuner, lowpass_cutoff_freq_tuner, highpass_cutoff_freq_tuner) self.complex_to_mag = blocks.complex_to_mag(fft_len) self.blocks_vector_to_stream_0_0 = blocks.vector_to_stream(gr.sizeof_float*1, fft_len) self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, fft_len) self.blocks_stream_to_vector_1_0 = blocks.stream_to_vector(gr.sizeof_float*1, fft_len/2) self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_float*1, fft_len/2) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_len) self.blocks_keep_m_in_n_0_0 = blocks.keep_m_in_n(gr.sizeof_float, fft_len/2, fft_len, fft_len/2) self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_float, fft_len/2, fft_len, 0) self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 0, tx_amp_tuner, 0) self.DC_filter_0 = blocks.multiply_const_vff(([0]*DC_filter_num_elements+[1]*((fft_len/2)-DC_filter_num_elements))) self.DC_filter = blocks.multiply_const_vff(([0]*DC_filter_num_elements+[1]*((fft_len/2)-DC_filter_num_elements))) ################################################## # Connections ################################################## self.connect((self.blocks_vector_to_stream_0_0, 0), (self.blocks_keep_m_in_n_0_0, 0)) self.connect((self.blocks_keep_m_in_n_0, 0), (self.blocks_stream_to_vector_1, 0)) self.connect((self.blocks_keep_m_in_n_0_0, 0), (self.blocks_stream_to_vector_1_0, 0)) self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_keep_m_in_n_0, 0)) self.connect((self.blocks_stream_to_vector_1_0, 0), (self.DC_filter_0, 0)) self.connect((self.blocks_stream_to_vector_1, 0), (self.cwradar_vector_flip_ff, 0)) self.connect((self.cwradar_vector_flip_ff, 0), (self.DC_filter, 0)) self.connect((self.rational_resampler, 0), (self.wxgui_waterfallsink, 0)) self.connect((self.rational_resampler, 0), (self.wxgui_fftsink, 0)) self.connect((self.fft_vxx_0, 0), (self.complex_to_mag, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.complex_to_mag, 0), (self.blocks_vector_to_stream_0, 0)) self.connect((self.complex_to_mag, 0), (self.blocks_vector_to_stream_0_0, 0)) self.connect((self.DC_filter_0, 0), (self.cwradar_doppler_velocity_single_target_ff_0, 1)) self.connect((self.DC_filter, 0), (self.cwradar_doppler_velocity_single_target_ff_0, 0)) self.connect((self.cwradar_doppler_velocity_single_target_ff_0, 0), (self.speed_probe, 0)) self.connect((self.cwradar_doppler_velocity_single_target_ff_0, 1), (self.direction_probe, 0)) self.connect((self.usrp_receiver, 0), (self.wxgui_fftsink2_full_spectrum, 0)) self.connect((self.usrp_receiver, 0), (self.rational_resampler, 0)) self.connect((self.usrp_receiver, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.analog_sig_source_x_0, 0), (self.usrp_transmitter, 0))
def set_freq_l1(self, freq_l1): self.freq_l1 = freq_l1 self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.freq_l1, self.lo_off), 0)
def set_lo_off(self, lo_off): self.lo_off = lo_off self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.freq_l1, self.lo_off), 0)
def set_tx_offset(self, tx_offset): self.tx_offset = tx_offset self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request(self.tx_freq+self.tx_correct, self.tx_offset), 0)
def __init__(self, addr="127.0.0.1", alpha=0.5, bb_gain=0.65, port="4000", samps_per_symb=4, tx_correct=0, tx_freq=2402e6, tx_gain=20, samp_rate=100e3, tx_offset=50e3): gr.top_block.__init__(self, "Tx Scram Sock") ################################################## # Parameters ################################################## self.addr = addr self.alpha = alpha self.bb_gain = bb_gain self.port = port self.samps_per_symb = samps_per_symb self.tx_correct = tx_correct self.tx_freq = tx_freq self.tx_gain = tx_gain self.samp_rate = samp_rate self.tx_offset = tx_offset ################################################## # Blocks ################################################## self.vtgs_mult_scrambler_0 = vtgs.mult_scrambler(17, 0x3FFFF) self.vtgs_ao40_encoder_0 = vtgs.ao40_encoder(False, 449838109) self.uhd_usrp_sink_0 = uhd.usrp_sink( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0.set_time_source("gpsdo", 0) self.uhd_usrp_sink_0.set_samp_rate(samp_rate) self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request(tx_freq+tx_correct, tx_offset), 0) self.uhd_usrp_sink_0.set_gain(tx_gain, 0) self.uhd_usrp_sink_0.set_antenna("TX/RX", 0) self.digital_map_bb_0 = digital.map_bb((1,0)) self.digital_dxpsk_mod_0 = digital.dbpsk_mod( samples_per_symbol=samps_per_symb, excess_bw=alpha, mod_code="gray", verbose=False, log=False) self.blocks_stream_mux_0 = blocks.stream_mux(gr.sizeof_char*1, (384,5232,384)) self.blocks_socket_pdu_0 = blocks.socket_pdu("UDP_SERVER", addr, port, 10000, False) self.blocks_pack_k_bits_bb_0 = blocks.pack_k_bits_bb(8) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((bb_gain, )) self.analog_random_source_x_0 = blocks.vector_source_b(map(int, numpy.random.randint(0, 1, 1000)), True) ################################################## # Connections ################################################## self.msg_connect((self.blocks_socket_pdu_0, 'pdus'), (self.vtgs_ao40_encoder_0, 'in')) self.connect((self.analog_random_source_x_0, 0), (self.blocks_stream_mux_0, 0)) self.connect((self.analog_random_source_x_0, 0), (self.blocks_stream_mux_0, 2)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.blocks_pack_k_bits_bb_0, 0), (self.digital_dxpsk_mod_0, 0)) self.connect((self.blocks_stream_mux_0, 0), (self.digital_map_bb_0, 0)) self.connect((self.digital_dxpsk_mod_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.digital_map_bb_0, 0), (self.vtgs_mult_scrambler_0, 0)) self.connect((self.vtgs_ao40_encoder_0, 0), (self.blocks_stream_mux_0, 1)) self.connect((self.vtgs_mult_scrambler_0, 0), (self.blocks_pack_k_bits_bb_0, 0))
def __init__(self): gr.top_block.__init__(self, "Top Block") Qt.QWidget.__init__(self) self.setWindowTitle("Top Block") try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "top_block") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.raw_samp_rate = raw_samp_rate = 2e6 self.decimation = decimation = 8 self.sym_rate = sym_rate = 2400 self.samp_rate = samp_rate = raw_samp_rate/decimation self.half_dev = half_dev = 40e3 self.freq_offset = freq_offset = 500 self.bin_width = bin_width = 10e3 ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(raw_samp_rate) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(450E6, 8E6), 0) self.uhd_usrp_source_0.set_gain(30, 0) self.low_pass_filter_1 = filter.fir_filter_fff(1, firdes.low_pass( 1, samp_rate, 10e3, 300, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0 = filter.fir_filter_ccf(decimation, firdes.low_pass( 2, raw_samp_rate, 250e3, 50e3, firdes.WIN_HAMMING, 6.76)) self.blocks_sub_xx_0 = blocks.sub_ff(1) self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float*1) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*1, "samples", False) self.blocks_file_sink_0.set_unbuffered(False) self.blocks_complex_to_mag_squared_1 = blocks.complex_to_mag_squared(1) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1) self.blks2_valve_0 = grc_blks2.valve(item_size=gr.sizeof_gr_complex*1, open=bool(False)) self.band_pass_filter_0_0 = filter.fir_filter_ccc(1, firdes.complex_band_pass( 1, samp_rate, -half_dev-bin_width/2+freq_offset, -half_dev+bin_width/2+freq_offset, 500, firdes.WIN_HAMMING, 6.76)) self.band_pass_filter_0 = filter.fir_filter_ccc(1, firdes.complex_band_pass( 1, samp_rate, +half_dev-bin_width/2+freq_offset, +half_dev+bin_width/2+freq_offset, 500, firdes.WIN_HAMMING, 6.76)) ################################################## # Connections ################################################## self.connect((self.low_pass_filter_0, 0), (self.band_pass_filter_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.band_pass_filter_0_0, 0)) self.connect((self.band_pass_filter_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.band_pass_filter_0_0, 0), (self.blocks_complex_to_mag_squared_1, 0)) self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_sub_xx_0, 0)) self.connect((self.blocks_complex_to_mag_squared_1, 0), (self.blocks_sub_xx_0, 1)) self.connect((self.blocks_sub_xx_0, 0), (self.low_pass_filter_1, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.blks2_valve_0, 0)) self.connect((self.blks2_valve_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.low_pass_filter_1, 0), (self.blocks_file_sink_0, 0)) self.connect((self.low_pass_filter_1, 0), (self.blocks_null_sink_0, 0))
def setup_usrp(self, ctor, args, cpu_format='fc32'): """ Instantiate a USRP object; takes care of all kinds of corner cases and settings. Pop it and some args onto the class that calls this. """ self.channels = args.channels self.cpu_format = cpu_format # Create a UHD device object: self.usrp = ctor( device_addr=args.args, stream_args=uhd.stream_args( cpu_format, args.otw_format, args=args.stream_args, channels=self.channels, ) ) # Set the subdevice spec: self.spec = self.normalize_sel("mboards", "subdev", self.usrp.get_num_mboards(), args.spec) if self.spec: for mb_idx in xrange(self.usrp.get_num_mboards()): self.usrp.set_subdev_spec(self.spec[mb_idx], mb_idx) # Set the clock and/or time source: if args.clock_source is not None: self.clock_source = self.normalize_sel("mboards", "clock-source", self.usrp.get_num_mboards(), args.clock_source) for mb_idx in xrange(self.usrp.get_num_mboards()): self.usrp.set_clock_source(self.clock_source[mb_idx], mb_idx) if args.time_source is not None: self.time_source = self.normalize_sel("mboards", "time-source", self.usrp.get_num_mboards(), args.time_source) for mb_idx in xrange(self.usrp.get_num_mboards()): self.usrp.set_time_source(self.time_source[mb_idx], mb_idx) # Sampling rate: self.usrp.set_samp_rate(args.samp_rate) self.samp_rate = self.usrp.get_samp_rate() self.vprint("Using sampling rate: {rate}".format(rate=self.samp_rate)) # Set the antenna: self.antenna = self.normalize_sel("channels", "antenna", len(args.channels), args.antenna) if self.antenna is not None: for i, chan in enumerate(self.channels): if not self.antenna[i] in self.usrp.get_antennas(i): print("[ERROR] {} is not a valid antenna name for this USRP device!".format(self.antenna[i])) exit(1) self.usrp.set_antenna(self.antenna[i], i) self.vprint("[{prefix}] Channel {chan}: Using antenna {ant}.".format( prefix=self.prefix, chan=chan, ant=self.usrp.get_antenna(i) )) self.antenna = self.usrp.get_antenna(0) # Set receive daughterboard gain: self.set_gain(args.gain) self.gain_range = self.usrp.get_gain_range(0) # Set frequency (tune request takes lo_offset): if hasattr(args, 'lo_offset') and args.lo_offset is not None: treq = uhd.tune_request(args.freq, args.lo_offset) else: treq = uhd.tune_request(args.freq) self.has_lo_sensor = 'lo_locked' in self.usrp.get_sensor_names() # Set LO export and LO source operation if (args.lo_export is not None) and (args.lo_source is not None): self.lo_source = self.normalize_sel("channels", "lo-source", len(self.channels), args.lo_source) self.lo_export = self.normalize_sel("channels", "lo-export", len(self.channels), args.lo_export) for chan, lo_source, lo_export in zip(self.channels, self.lo_source, self.lo_export): if (lo_source == "None") or (lo_export == "None"): continue if lo_export == "True": #If channel is LO source set frequency and store response self.usrp.set_lo_export_enabled(True, uhd.ALL_LOS, chan) if lo_source == "internal": self.lo_source_channel = chan tune_resp = self.usrp.set_center_freq(treq,chan) self.usrp.set_lo_source(lo_source, uhd.ALL_LOS,chan) # Use lo source tune response to tune dsp_freq on remaining channels if getattr(args, 'lo_offset', None) is not None: treq = uhd.tune_request(target_freq=args.freq, rf_freq=args.freq+args.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL, dsp_freq=tune_resp.actual_dsp_freq, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL) else: treq = uhd.tune_request(target_freq=args.freq, rf_freq=args.freg, rf_freq_policy=uhd.tune_request.POLICY_MANUAL, dsp_freq=tune_resp.actual_dsp_freq, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL) for chan in args.channels: if chan == self.lo_source_channel: continue self.usrp.set_center_freq(treq,chan) # Make sure tuning is synched: command_time_set = False if len(self.channels) > 1: if args.sync == 'pps': self.usrp.set_time_unknown_pps(uhd.time_spec()) cmd_time = self.usrp.get_time_now() + uhd.time_spec(COMMAND_DELAY) try: for mb_idx in xrange(self.usrp.get_num_mboards()): self.usrp.set_command_time(cmd_time, mb_idx) command_time_set = True except RuntimeError: sys.stderr.write('[{prefix}] [WARNING] Failed to set command times.\n'.format(prefix=self.prefix)) for i, chan in enumerate(self.channels): self.tr = self.usrp.set_center_freq(treq, i) if self.tr == None: sys.stderr.write('[{prefix}] [ERROR] Failed to set center frequency on channel {chan}\n'.format( prefix=self.prefix, chan=chan )) exit(1) if command_time_set: for mb_idx in xrange(self.usrp.get_num_mboards()): self.usrp.clear_command_time(mb_idx) self.vprint("Syncing channels...".format(prefix=self.prefix)) time.sleep(COMMAND_DELAY) self.freq = self.usrp.get_center_freq(0) if args.show_async_msg: self.async_msgq = gr.msg_queue(0) self.async_src = uhd.amsg_source("", self.async_msgq) self.async_rcv = gru.msgq_runner(self.async_msgq, self.async_callback)
def set_lo_off_user(self, lo_off_user): self.lo_off_user = lo_off_user self._lo_off_user_text_box.set_value(self.lo_off_user) self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request(self.nominal_uplink_freq_user,self.lo_off_user), 0)
def __init__(self, sym_rate=256, samp_per_sym=256, nominal_uplink_freq=2041.95e6*0 + 2041.9479e6 + 1e6*0, lo_off=5e6 * 0, tx_gain=15*0 + 13.5*0, backoff=0.150*0 + (0.6+0.1)*0 + 1e-3, record_path='/media/balint/PATRIOT/ICE/TX/'): grc_wxgui.top_block_gui.__init__(self, title="Uplink") ################################################## # Parameters ################################################## self.sym_rate = sym_rate self.samp_per_sym = samp_per_sym self.nominal_uplink_freq = nominal_uplink_freq self.lo_off = lo_off self.tx_gain = tx_gain self.backoff = backoff self.record_path = record_path ################################################## # Variables ################################################## self.time_format = time_format = "%Y-%d-%m_%H-%M-%S" self.time_now = time_now = time.strftime(time_format) self.samp_rate = samp_rate = 250000 self.pre_resamp_rate = pre_resamp_rate = sym_rate * samp_per_sym self.f1 = f1 = 9000.0 self.f0 = f0 = 7500.0 self.resamp_rate = resamp_rate = float(samp_rate)/float(pre_resamp_rate) self.pm = pm = 1.2*0 + 1.0 self.nominal_uplink_freq_chooser = nominal_uplink_freq_chooser = nominal_uplink_freq self.manual_doppler = manual_doppler = 0 self.file_name = file_name = time_now + ".mcfile" self.doppler = doppler = 0 self.deviation = deviation = (f1 - f0) / 2.0 self.tx_gain_user = tx_gain_user = tx_gain self.subcarrier_freq = subcarrier_freq = f0 + deviation self.source = source = 'external' self.pm_txt = pm_txt = pm self.nominal_uplink_freq_user = nominal_uplink_freq_user = nominal_uplink_freq_chooser self.lo_off_user = lo_off_user = lo_off self.length_mul = length_mul = float(samp_per_sym) * resamp_rate self.invert = invert = 1 self.final_record_path = final_record_path = os.path.join(record_path, file_name) self.final_doppler = final_doppler = doppler + manual_doppler self.backoff_user = backoff_user = backoff ################################################## # Blocks ################################################## _tx_gain_user_sizer = wx.BoxSizer(wx.VERTICAL) self._tx_gain_user_text_box = forms.text_box( parent=self.GetWin(), sizer=_tx_gain_user_sizer, value=self.tx_gain_user, callback=self.set_tx_gain_user, label="TX Gain", converter=forms.float_converter(), proportion=0, ) self._tx_gain_user_slider = forms.slider( parent=self.GetWin(), sizer=_tx_gain_user_sizer, value=self.tx_gain_user, callback=self.set_tx_gain_user, minimum=0, maximum=32, num_steps=32, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.Add(_tx_gain_user_sizer) self._nominal_uplink_freq_user_text_box = forms.text_box( parent=self.GetWin(), value=self.nominal_uplink_freq_user, callback=self.set_nominal_uplink_freq_user, label="Nominal Uplink Freq", converter=forms.float_converter(), ) self.Add(self._nominal_uplink_freq_user_text_box) self.nb = self.nb = wx.Notebook(self.GetWin(), style=wx.NB_TOP) self.nb.AddPage(grc_wxgui.Panel(self.nb), "Output FFT") self.nb.AddPage(grc_wxgui.Panel(self.nb), "Input FFT") self.nb.AddPage(grc_wxgui.Panel(self.nb), "Input Phase/Mag") self.nb.AddPage(grc_wxgui.Panel(self.nb), "Mod Clk/Data") self.nb.AddPage(grc_wxgui.Panel(self.nb), "PM Output Scope") self.nb.AddPage(grc_wxgui.Panel(self.nb), "PM Input") self.Add(self.nb) self._lo_off_user_text_box = forms.text_box( parent=self.GetWin(), value=self.lo_off_user, callback=self.set_lo_off_user, label="LO Offset", converter=forms.float_converter(), ) self.Add(self._lo_off_user_text_box) self._final_doppler_static_text = forms.static_text( parent=self.GetWin(), value=self.final_doppler, callback=self.set_final_doppler, label="Final Doppler", converter=forms.float_converter(), ) self.Add(self._final_doppler_static_text) self._doppler_text_box = forms.text_box( parent=self.GetWin(), value=self.doppler, callback=self.set_doppler, label="Doppler Shift", converter=forms.float_converter(), ) self.Add(self._doppler_text_box) _backoff_user_sizer = wx.BoxSizer(wx.VERTICAL) self._backoff_user_text_box = forms.text_box( parent=self.GetWin(), sizer=_backoff_user_sizer, value=self.backoff_user, callback=self.set_backoff_user, label="Backoff", converter=forms.float_converter(), proportion=0, ) self._backoff_user_slider = forms.slider( parent=self.GetWin(), sizer=_backoff_user_sizer, value=self.backoff_user, callback=self.set_backoff_user, minimum=0, maximum=1, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.Add(_backoff_user_sizer) self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(("", 52003), allow_none=True) self.xmlrpc_server_0.register_instance(self) threading.Thread(target=self.xmlrpc_server_0.serve_forever).start() self.wxgui_scopesink2_2 = scopesink2.scope_sink_f( self.nb.GetPage(5).GetWin(), title="Scope Plot", sample_rate=pre_resamp_rate, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=1, trig_mode=wxgui.TRIG_MODE_AUTO, y_axis_label="Counts", ) self.nb.GetPage(5).Add(self.wxgui_scopesink2_2.win) self.wxgui_scopesink2_1 = scopesink2.scope_sink_c( self.nb.GetPage(4).GetWin(), title="Scope Plot", sample_rate=samp_rate, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=1, trig_mode=wxgui.TRIG_MODE_AUTO, y_axis_label="Counts", ) self.nb.GetPage(4).Add(self.wxgui_scopesink2_1.win) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.nb.GetPage(0).GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate, fft_size=256, fft_rate=10, average=False, avg_alpha=None, title="FFT Plot", peak_hold=False, fft_in=False, always_run=False, fft_out=False, ) self.nb.GetPage(0).Add(self.wxgui_fftsink2_0.win) self.uhd_usrp_sink_0 = uhd.usrp_sink( ",".join(("serial=F4A7C3", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), "", True, ) self.uhd_usrp_sink_0.set_clock_source(source, 0) self.uhd_usrp_sink_0.set_time_source(source, 0) self.uhd_usrp_sink_0.set_samp_rate(samp_rate) self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request(nominal_uplink_freq_user,lo_off_user), 0) self.uhd_usrp_sink_0.set_gain(tx_gain*0 + tx_gain_user, 0) self.uhd_usrp_sink_0.set_antenna('TX/RX', 0) self.rational_resampler_xxx_0 = filter.rational_resampler_ccc( interpolation=int(samp_rate), decimation=int(pre_resamp_rate), taps=None, fractional_bw=None, ) self._pm_txt_static_text = forms.static_text( parent=self.GetWin(), value=self.pm_txt, callback=self.set_pm_txt, label="Phase Moduation Index", converter=forms.float_converter(), ) self.Add(self._pm_txt_static_text) self._nominal_uplink_freq_chooser_chooser = forms.drop_down( parent=self.GetWin(), value=self.nominal_uplink_freq_chooser, callback=self.set_nominal_uplink_freq_chooser, label="Nomial Uplink Frequency", choices=[2041.9479e6, 2090.66e6], labels=['B: 2041.9479', 'A: 2090.66'], ) self.Add(self._nominal_uplink_freq_chooser_chooser) self._manual_doppler_text_box = forms.text_box( parent=self.GetWin(), value=self.manual_doppler, callback=self.set_manual_doppler, label="Manual Doppler", converter=forms.float_converter(), ) self.Add(self._manual_doppler_text_box) self.mac_burst_tagger_0 = mac.burst_tagger('packet_len', length_mul, 256, 32*0 + 256, True, False) self.clock_and_data = scopesink2.scope_sink_c( self.nb.GetPage(3).GetWin(), title="Scope Plot", sample_rate=pre_resamp_rate, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=1, trig_mode=wxgui.TRIG_MODE_AUTO, y_axis_label="Counts", ) self.nb.GetPage(3).Add(self.clock_and_data.win) self.carrier = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, doppler*0 + final_doppler, 0*backoff + backoff_user, 0) self.blocks_vector_source_x_0 = blocks.vector_source_f(tuple([1] * (samp_per_sym/4) + [0] * (samp_per_sym/4) + [0] * (samp_per_sym/4) + [1] * (samp_per_sym/4)), True, 1, []) self.blocks_socket_pdu_0 = blocks.socket_pdu("TCP_SERVER", "", "52002", 10000, False) self.blocks_repeat_0 = blocks.repeat(gr.sizeof_float*1, samp_per_sym) self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len", 1) self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float*1) self.blocks_multiply_xx_1 = blocks.multiply_vcc(1) self.blocks_multiply_xx_0 = blocks.multiply_vcc(1) self.blocks_multiply_const_vxx_1_0 = blocks.multiply_const_vff((2.0/3, )) self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vff((2, )) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((invert, )) self.blocks_message_strobe_0_0 = blocks.message_strobe(pmt.cons(pmt.to_pmt({'ignore': True}), pmt.init_u8vector(1, 1*[0])), 0) self.blocks_float_to_complex_2 = blocks.float_to_complex(1) self.blocks_float_to_complex_1 = blocks.float_to_complex(1) self.blocks_file_meta_sink_0 = blocks.file_meta_sink(gr.sizeof_gr_complex*1, final_record_path, samp_rate, 1, blocks.GR_FILE_FLOAT, True, 1000000, "", True) self.blocks_file_meta_sink_0.set_unbuffered(False) self.blocks_complex_to_float_0 = blocks.complex_to_float(1) self.blocks_char_to_float_0 = blocks.char_to_float(1, 1) self.blocks_add_const_vxx_1_0 = blocks.add_const_vff((1.0/3, )) self.blocks_add_const_vxx_1 = blocks.add_const_vff((-1, )) self.binary_to_pdu0 = isee3.binary_to_pdu() self.analog_sig_source_x_0 = analog.sig_source_c(pre_resamp_rate, analog.GR_COS_WAVE, subcarrier_freq, 1/1.333, 0) self.analog_phase_modulator_fc_1 = analog.phase_modulator_fc(pm / (2.0*0 + 1)) self.analog_frequency_modulator_fc_0 = analog.frequency_modulator_fc(float(deviation) / float(pre_resamp_rate) * math.pi*2.0) ################################################## # Connections ################################################## self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_char_to_float_0, 0)) self.connect((self.blocks_char_to_float_0, 0), (self.blocks_multiply_const_vxx_1, 0)) self.connect((self.blocks_multiply_const_vxx_1, 0), (self.blocks_add_const_vxx_1, 0)) self.connect((self.blocks_add_const_vxx_1, 0), (self.blocks_repeat_0, 0)) self.connect((self.blocks_multiply_xx_0, 0), (self.blocks_complex_to_float_0, 0)) self.connect((self.analog_frequency_modulator_fc_0, 0), (self.blocks_multiply_xx_0, 0)) self.connect((self.blocks_multiply_const_vxx_1_0, 0), (self.blocks_add_const_vxx_1_0, 0)) self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_multiply_const_vxx_1_0, 0)) self.connect((self.blocks_add_const_vxx_1_0, 0), (self.blocks_float_to_complex_2, 0)) self.connect((self.blocks_float_to_complex_1, 0), (self.clock_and_data, 0)) self.connect((self.blocks_multiply_xx_1, 0), (self.wxgui_fftsink2_0, 0)) self.connect((self.carrier, 0), (self.blocks_multiply_xx_1, 1)) self.connect((self.blocks_add_const_vxx_1_0, 0), (self.blocks_float_to_complex_1, 1)) self.connect((self.blocks_repeat_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.analog_frequency_modulator_fc_0, 0)) self.connect((self.blocks_complex_to_float_0, 0), (self.analog_phase_modulator_fc_1, 0)) self.connect((self.blocks_complex_to_float_0, 1), (self.blocks_null_sink_0, 0)) self.connect((self.blocks_complex_to_float_0, 0), (self.wxgui_scopesink2_2, 0)) self.connect((self.blocks_add_const_vxx_1_0, 0), (self.blocks_float_to_complex_2, 1)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_float_to_complex_1, 0)) self.connect((self.blocks_float_to_complex_2, 0), (self.blocks_multiply_xx_0, 2)) self.connect((self.mac_burst_tagger_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.blocks_multiply_xx_1, 0), (self.mac_burst_tagger_0, 0)) self.connect((self.blocks_multiply_xx_1, 0), (self.wxgui_scopesink2_1, 0)) self.connect((self.analog_phase_modulator_fc_1, 0), (self.rational_resampler_xxx_0, 0)) self.connect((self.rational_resampler_xxx_0, 0), (self.blocks_multiply_xx_1, 0)) self.connect((self.mac_burst_tagger_0, 0), (self.blocks_file_meta_sink_0, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.binary_to_pdu0, "pdu_out", self.blocks_pdu_to_tagged_stream_0, "pdus") self.msg_connect(self.blocks_socket_pdu_0, "pdus", self.binary_to_pdu0, "binary_in") self.msg_connect(self.blocks_message_strobe_0_0, "strobe", self.blocks_pdu_to_tagged_stream_0, "pdus") self.msg_connect(self.uhd_usrp_sink_0, "ctl", self.blocks_message_strobe_0_0, "trigger")
def set_lo_offset_freq(self, lo_offset_freq): self.lo_offset_freq = lo_offset_freq self.usrp_receiver.set_center_freq(uhd.tune_request(self.RF_tuner, self.lo_offset_freq), 0)
def __init__(self): gr.top_block.__init__(self) parser=OptionParser(option_class=eng_option) parser.add_option("-a", "--args", type="string", default="", help="UHD device address args [default=%default]") parser.add_option("", "--spec", type="string", default="A:0 A:0", help="Subdevice of UHD device where appropriate") parser.add_option("-A", "--antenna", type="string", default=None, help="select Rx Antenna where appropriate") parser.add_option("", "--f1", type="eng_float", default=100.7e6, help="set 1st station frequency to FREQ", metavar="FREQ") parser.add_option("", "--f2", type="eng_float", default=102.5e6, help="set 2nd station freq to FREQ", metavar="FREQ") parser.add_option("-g", "--gain", type="eng_float", default=None, help="set gain in dB (default is midpoint)") parser.add_option("-O", "--audio-output", type="string", default="default", help="pcm device name. E.g., hw:0,0 or surround51 or /dev/dsp") parser.add_option("", "--freq-min", type="eng_float", default=87.9e6, help="Set a minimum frequency [default=%default]") parser.add_option("", "--freq-max", type="eng_float", default=108.1e6, help="Set a maximum frequency [default=%default]") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) if abs(options.f1 - options.f2) > 5.5e6: print "Sorry, two stations must be within 5.5MHz of each other" raise SystemExit f = (options.f1, options.f2) self.vol = .1 self.state = "FREQ" self.fm_freq_min = options.freq_min self.fm_freq_max = options.freq_max # build graph stream_args = uhd.stream_args('fc32', channels=range(2)) self.u = uhd.usrp_source(device_addr=options.args, stream_args=stream_args) # Set front end channel mapping self.u.set_subdev_spec(options.spec) usrp_rate = 320e3 demod_rate = 320e3 audio_rate = 32e3 audio_decim = int(demod_rate / audio_rate) self.u.set_samp_rate(usrp_rate) dev_rate = self.u.get_samp_rate() # Make sure dboard can suppor the required frequencies frange = self.u.get_freq_range() if(frange.start() > self.fm_freq_max or frange.stop() < self.fm_freq_min): sys.stderr.write("Radio does not support required frequency range.\n") sys.exit(1) # sound card as final sink self.audio_sink = audio.sink(int(audio_rate), options.audio_output) # taps for channel filter nfilts = 32 chan_coeffs = optfir.low_pass (nfilts, # gain nfilts*usrp_rate, # sampling rate 80e3, # passband cutoff 115e3, # stopband cutoff 0.1, # passband ripple 60) # stopband attenuation rrate = usrp_rate / dev_rate # set front end PLL to middle frequency mid_freq = (f[0] + f[1]) / 2.0 if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2.0 for n in range(2): chan_filt = blks2.pfb_arb_resampler_ccf(rrate, chan_coeffs, nfilts) guts = blks2.wfm_rcv (demod_rate, audio_decim) volume_control = gr.multiply_const_ff(self.vol) #self.connect((self.di, n), chan_filt) self.connect((self.u, n), chan_filt) self.connect(chan_filt, guts, volume_control) self.connect(volume_control, (self.audio_sink, n)) # Test the the requested frequencies are in range if(f[n] < self.fm_freq_min or f[n] > self.fm_freq_max): sys.stderr.write("Requested frequency is outside of required frequency range.\n") sys.exit(1) # Tune each channel by setting the RF freq to mid_freq and the # DDC freq to f[n]. tr = uhd.tune_request(f[n], rf_freq=mid_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL) self.u.set_center_freq(tr, n) # Set gain for each channel self.set_gain(options.gain, n) # Set the antenna if(options.antenna): self.u.set_antenna(options.antenna, n)