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 __init__(self): gr.top_block.__init__(self) usage = "usage: %prog [options]" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-f", "--tx-freq", type="eng_float", default=None, metavar="Hz", help="Transmit frequency [default=center_frequency]") (options, args) = parser.parse_args() args = "" #only supporting USB USRPs for now #find uhd devices d = uhd.find_devices(uhd.device_addr(args)) if d: uhd_type = d[0].get('type') print "\nFound '%s'" % uhd_type else: print "\nNo device found" self.u_tx = None return #check version of USRP and set num_channels if uhd_type == "usrp": tx_nchan = 2 rx_nchan = 2 else: tx_nchan = 1 rx_nchan = 1 #setup transmit chain (usrp sink, signal source) #usrp sink stream_args = uhd.stream_args('fc32', channels = range(tx_nchan)) self.u_tx = uhd.usrp_sink(device_addr=args, stream_args=stream_args) self.u_tx.set_samp_rate(MAX_RATE) #analog signal source - sig_source_c(sampling_freq,waveform, wave_freq, ampl, offset=0) self.tx_src0 = analog.sig_source_c(self.u_tx.get_samp_rate(), analog.GR_CONST_WAVE, 0, 1.0, 0) #check and output freq range, gain range, num_channels #gain range and max tx_gain_range = self.u_tx.get_gain_range() tx_gain_min = tx_gain_range.start() tx_gain_max = tx_gain_range.stop() #freq range tx_freq_range = self.u_tx.get_freq_range() tx_freq_low = tx_freq_range.start() tx_freq_high = tx_freq_range.stop() tx_freq_mid = (tx_freq_low + tx_freq_high) / 2.0 if options.tx_freq is None: self.tx_freq = tx_freq_mid else: if options.tx_freq < 1e6: options.tx_freq *= 1e6 self.tx_freq = options.tx_freq #output info print "\nDevice Info -\tType: %s\tFreq(MHz): (%d,%d,%d)\tGain(dB): (%f,%f)\n" % (uhd_type, (tx_freq_low/1e6), (tx_freq_mid/1e6), (tx_freq_high/1e6), tx_gain_min, tx_gain_max) #set initial parameters self.u_tx.set_center_freq(self.tx_freq) self.u_tx.set_gain(tx_gain_max) #connect blocks self.connect(self.tx_src0, self.u_tx)
def __init__(self, args, tx_enable, rx_enable): gr.top_block.__init__(self) d = uhd.find_devices(uhd.device_addr(args)) uhd_type = d[0].get('type') print "\nFound '%s' at args '%s'" % \ (uhd_type, args) # Test the type of USRP; if it's a USRP (v1), it has # 2 channels; otherwise, it has 1 channel if uhd_type == "usrp": tx_nchan = 2 rx_nchan = 2 else: tx_nchan = 1 rx_nchan = 1 if tx_enable: print "\nTRANSMIT CHAIN" self.u_tx = uhd.usrp_sink(device_addr=args, io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=tx_nchan) self.u_tx.set_samp_rate(MAX_RATE) self.tx_src0 = gr.sig_source_c(self.u_tx.get_samp_rate(), gr.GR_CONST_WAVE, 0, 1.0, 0) # Get dboard gain range and select maximum tx_gain_range = self.u_tx.get_gain_range() tx_gain = tx_gain_range.stop() # Get dboard freq range and select midpoint tx_freq_range = self.u_tx.get_freq_range() tx_freq_mid = (tx_freq_range.start() + tx_freq_range.stop())/2.0 for i in xrange(tx_nchan): self.u_tx.set_center_freq (tx_freq_mid + i*1e6, i) self.u_tx.set_gain(tx_gain, i) print "\nTx Sample Rate: %ssps" % (n2s(self.u_tx.get_samp_rate())) for i in xrange(tx_nchan): print "Tx Channel %d: " % (i) print "\tFrequency = %sHz" % \ (n2s(self.u_tx.get_center_freq(i))) print "\tGain = %f dB" % (self.u_tx.get_gain(i)) print "" self.connect (self.tx_src0, self.u_tx) if rx_enable: print "\nRECEIVE CHAIN" self.u_rx = uhd.usrp_source(device_addr=args, io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=rx_nchan) self.rx_dst0 = gr.null_sink (gr.sizeof_gr_complex) self.u_rx.set_samp_rate(MAX_RATE) # Get dboard gain range and select maximum rx_gain_range = self.u_rx.get_gain_range() rx_gain = rx_gain_range.stop() # Get dboard freq range and select midpoint rx_freq_range = self.u_rx.get_freq_range() rx_freq_mid = (rx_freq_range.start() + rx_freq_range.stop())/2.0 for i in xrange(tx_nchan): self.u_rx.set_center_freq (rx_freq_mid + i*1e6, i) self.u_rx.set_gain(rx_gain, i) print "\nRx Sample Rate: %ssps" % (n2s(self.u_rx.get_samp_rate())) for i in xrange(rx_nchan): print "Rx Channel %d: " % (i) print "\tFrequency = %sHz" % \ (n2s(self.u_rx.get_center_freq(i))) print "\tGain = %f dB" % (self.u_rx.get_gain(i)) print "" self.connect (self.u_rx, self.rx_dst0)
def _usrp_setup(self): """Create, set up, and return USRP sink object.""" op = self.op # create usrp sink block u = uhd.usrp_sink( device_addr=",".join(chain(op.mboard_strs, op.dev_args)), stream_args=uhd.stream_args( cpu_format="fc32", otw_format="sc16", channels=list(range(op.nchs)), args=",".join(op.stream_args), ), ) # set clock and time source if synced if op.sync: try: u.set_clock_source(op.sync_source, uhd.ALL_MBOARDS) u.set_time_source(op.sync_source, uhd.ALL_MBOARDS) except RuntimeError: errstr = ( "Unknown sync_source option: '{0}'. Must be one of {1}." ).format(op.sync_source, u.get_clock_sources(0)) raise ValueError(errstr) # check for ref lock mbnums_with_ref = [ mb_num for mb_num in range(op.nmboards) if "ref_locked" in u.get_mboard_sensor_names(mb_num) ] if mbnums_with_ref: if op.verbose: sys.stdout.write("Waiting for reference lock...") sys.stdout.flush() timeout = 0 while not all( u.get_mboard_sensor("ref_locked", mb_num).to_bool() for mb_num in mbnums_with_ref): if op.verbose: sys.stdout.write(".") sys.stdout.flush() time.sleep(1) timeout += 1 if timeout > 30: if op.verbose: sys.stdout.write("failed\n") sys.stdout.flush() raise RuntimeError("Failed to lock to 10 MHz reference.") if op.verbose: sys.stdout.write("locked\n") sys.stdout.flush() # set mainboard options for mb_num in range(op.nmboards): u.set_subdev_spec(op.subdevs[mb_num], mb_num) # set global options # sample rate u.set_samp_rate(float(op.samplerate)) # read back actual value samplerate = u.get_samp_rate() # calculate longdouble precision sample rate # (integer division of clock rate) cr = u.get_clock_rate() srdec = int(round(cr / samplerate)) samplerate_ld = np.longdouble(cr) / srdec op.samplerate = samplerate_ld sr_rat = Fraction(cr).limit_denominator() / srdec op.samplerate_num = sr_rat.numerator op.samplerate_den = sr_rat.denominator # set per-channel options # set command time so settings are synced COMMAND_DELAY = 0.2 cmd_time = u.get_time_now() + uhd.time_spec(COMMAND_DELAY) u.set_command_time(cmd_time, uhd.ALL_MBOARDS) for ch_num in range(op.nchs): # local oscillator sharing settings lo_source = op.lo_sources[ch_num] if lo_source: try: u.set_lo_source(lo_source, uhd.ALL_LOS, ch_num) except RuntimeError: errstr = ( "Unknown LO source option: '{0}'. Must be one of {1}," " or it may not be possible to set the LO source on" " this daughterboard.").format( lo_source, u.get_lo_sources(uhd.ALL_LOS, ch_num)) raise ValueError(errstr) lo_export = op.lo_exports[ch_num] if lo_export is not None: if not lo_source: errstr = ( "Channel {0}: must set an LO source in order to set" " LO export.").format(ch_num) raise ValueError(errstr) u.set_lo_export_enabled(lo_export, uhd.ALL_LOS, ch_num) # center frequency and tuning offset tune_res = u.set_center_freq( uhd.tune_request( op.centerfreqs[ch_num], op.lo_offsets[ch_num], args=uhd.device_addr(",".join(op.tune_args)), ), ch_num, ) # store actual values from tune result op.centerfreqs[ ch_num] = tune_res.actual_rf_freq + tune_res.actual_dsp_freq op.lo_offsets[ch_num] = -tune_res.actual_dsp_freq # dc offset dc_offset = op.dc_offsets[ch_num] if dc_offset is not None: u.set_dc_offset(dc_offset, ch_num) # iq balance iq_balance = op.iq_balances[ch_num] if iq_balance is not None: u.set_iq_balance(iq_balance, ch_num) # gain u.set_gain(op.gains[ch_num], ch_num) # bandwidth bw = op.bandwidths[ch_num] if bw: u.set_bandwidth(bw, ch_num) # antenna ant = op.antennas[ch_num] if ant: try: u.set_antenna(ant, ch_num) except RuntimeError: errstr = ( "Unknown RX antenna option: '{0}'. Must be one of {1}." ).format(ant, u.get_antennas(ch_num)) raise ValueError(errstr) # commands are done, clear time u.clear_command_time(uhd.ALL_MBOARDS) time.sleep(COMMAND_DELAY) # read back actual channel settings for ch_num in range(op.nchs): if op.lo_sources[ch_num]: op.lo_sources[ch_num] = u.get_lo_source(uhd.ALL_LOS, ch_num) if op.lo_exports[ch_num] is not None: op.lo_exports[ch_num] = u.get_lo_export_enabled( uhd.ALL_LOS, ch_num) op.gains[ch_num] = u.get_gain(ch_num) op.bandwidths[ch_num] = u.get_bandwidth(chan=ch_num) op.antennas[ch_num] = u.get_antenna(chan=ch_num) if op.verbose: print("Using the following devices:") chinfostrs = [ "Motherboard: {mb_id} ({mb_addr}) | Daughterboard: {db_name}", "Subdev: {sub} | Antenna: {ant} | Gain: {gain} | Rate: {sr}", "Frequency: {freq:.3f} ({lo_off:+.3f}) | Bandwidth: {bw}", ] if any(op.lo_sources) or any(op.lo_exports): chinfostrs.append( "LO source: {lo_source} | LO export: {lo_export}") chinfo = "\n".join([" " + l for l in chinfostrs]) for ch_num in range(op.nchs): header = "---- {0} ".format(ch_num) header += "-" * (78 - len(header)) print(header) usrpinfo = dict(u.get_usrp_info(chan=ch_num)) info = {} info["mb_id"] = usrpinfo["mboard_id"] mba = op.mboards_bychan[ch_num] if mba == "default": mba = usrpinfo["mboard_serial"] info["mb_addr"] = mba info["db_name"] = usrpinfo["tx_subdev_name"] info["sub"] = op.subdevs_bychan[ch_num] info["ant"] = op.antennas[ch_num] info["bw"] = op.bandwidths[ch_num] info["dc_offset"] = op.dc_offsets[ch_num] info["freq"] = op.centerfreqs[ch_num] info["gain"] = op.gains[ch_num] info["iq_balance"] = op.iq_balances[ch_num] info["lo_off"] = op.lo_offsets[ch_num] info["lo_source"] = op.lo_sources[ch_num] info["lo_export"] = op.lo_exports[ch_num] info["sr"] = op.samplerate print(chinfo.format(**info)) print("-" * 78) return u
def __init__(self): gr.top_block.__init__(self) args = "" #only supporting USB USRPs for now #find uhd devices d = uhd.find_devices(uhd.device_addr(args)) if d: uhd_type = d[0].get('type') print "\nFound '%s'" % uhd_type else: print "\nNo device found" self.u_tx = None return #check version of USRP and set num_channels if uhd_type == "usrp": tx_nchan = 2 rx_nchan = 2 else: tx_nchan = 1 rx_nchan = 1 #setup transmit chain (usrp sink, signal source) #usrp sink stream_args = uhd.stream_args('fc32', channels=range(tx_nchan)) self.u_tx = uhd.usrp_sink(device_addr=args, stream_args=stream_args) self.u_tx.set_samp_rate(MAX_RATE) #analog signal source - sig_source_c(sampling_freq,waveform, wave_freq, ampl, offset=0) self.tx_src0 = analog.sig_source_c(self.u_tx.get_samp_rate(), analog.GR_CONST_WAVE, 0, 1.0, 0) #check and output freq range, gain range, num_channels #gain range and max tx_gain_range = self.u_tx.get_gain_range() tx_gain_min = tx_gain_range.start() tx_gain_max = tx_gain_range.stop() #freq range tx_freq_range = self.u_tx.get_freq_range() tx_freq_low = tx_freq_range.start() tx_freq_high = tx_freq_range.stop() tx_freq_mid = (tx_freq_low + tx_freq_high) / 2.0 #output info print "\nDevice Info" print "\n\tType: %s" % uhd_type print "\n\tMin Freq: %d MHz" % (tx_freq_low / 1e6) print "\tMax Freq: %d MHz" % (tx_freq_high / 1e6) print "\tMid Freq: %d MHz" % (tx_freq_mid / 1e6) print "\n\tMin Gain: %d dB" % tx_gain_min print "\tMax Gain: %d dB" % tx_gain_max #set initial parameters for i in xrange(tx_nchan): self.u_tx.set_center_freq(tx_freq_mid + i * 1e6, i) self.u_tx.set_gain(tx_gain_max, i) #connect blocks self.connect(self.tx_src0, self.u_tx)
def __init__(self): gr.top_block.__init__(self) usage = "%prog: [options] tx-freq0 tx-freq1" parser = OptionParser (option_class=eng_option, usage=usage) parser.add_option("-a", "--args", type="string", default="", help="UHD device address args [default=%default]") parser.add_option("", "--spec", type="string", default=None, 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("-s", "--samp-rate", type="eng_float", default=320e3, help="set sample rate [default=%default]") parser.add_option("-g", "--gain", type="eng_float", default=None, help="set gain in dB (default is midpoint)") (options, args) = parser.parse_args () if len(args) != 2: parser.print_help() raise SystemExit else: freq0 = str_to_num(args[0]) freq1 = str_to_num(args[1]) # ---------------------------------------------------------------- # Set up USRP to transmit on both daughterboards d = uhd.find_devices(uhd.device_addr(options.args)) uhd_type = d[0].get('type') stream_args = uhd.stream_args('fc32', channels=range(2)) self.u = uhd.usrp_sink(device_addr=options.args, stream_args=stream_args) # Set up USRP system based on type if(uhd_type == "usrp"): self.u.set_subdev_spec("A:0 B:0") tr0 = uhd.tune_request(freq0) tr1 = uhd.tune_request(freq1) else: if abs(freq0 - freq1) > 5.5e6: sys.stderr.write("\nError: When not using two separate d'boards, frequencies must bewithin 5.5MHz of each other.\n") raise SystemExit self.u.set_subdev_spec("A:0 A:0") mid_freq = (freq0 + freq1)/2.0 tr0 = uhd.tune_request(freq0, rf_freq=mid_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL) tr1 = uhd.tune_request(freq1, rf_freq=mid_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL) # Use the tune requests to tune each channel self.set_freq(tr0, 0) self.set_freq(tr1, 1) self.usrp_rate = options.samp_rate self.u.set_samp_rate(self.usrp_rate) dev_rate = self.u.get_samp_rate() # ---------------------------------------------------------------- # build two signal sources, interleave them, amplify and # connect them to usrp sig0 = example_signal_0(self.usrp_rate) sig1 = example_signal_1(self.usrp_rate) intl = blocks.interleave(gr.sizeof_gr_complex) self.connect(sig0, (intl, 0)) self.connect(sig1, (intl, 1)) # Correct for any difference in requested and actual rates rrate = self.usrp_rate / dev_rate resamp = filter.pfb.arb_resampler_ccf(rrate) # and wire them up self.connect(intl, resamp, self.u) 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 self.set_gain(options.gain, 0) self.set_gain(options.gain, 1) # Set the subdevice spec if(options.spec): self.u.set_subdev_spec(options.spec, 0) # Set the antenna if(options.antenna): self.u.set_antenna(options.antenna, 0) self.u.set_antenna(options.antenna, 1)
def __init__(self): gr.top_block.__init__(self) usage="%prog: [options] tx-freq0 tx-freq1" parser = OptionParser (option_class=eng_option, usage=usage) parser.add_option("-a", "--args", type="string", default="", help="UHD device address args [default=%default]") parser.add_option("", "--spec", type="string", default=None, 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("-s", "--samp-rate", type="eng_float", default=320e3, help="set sample rate [default=%default]") parser.add_option("-g", "--gain", type="eng_float", default=None, help="set gain in dB (default is midpoint)") (options, args) = parser.parse_args () if len(args) != 2: parser.print_help() raise SystemExit else: freq0 = str_to_num(args[0]) freq1 = str_to_num(args[1]) # ---------------------------------------------------------------- # Set up USRP to transmit on both daughterboards d = uhd.find_devices(uhd.device_addr(options.args)) uhd_type = d[0].get('type') stream_args = uhd.stream_args('fc32', channels=range(2)) self.u = uhd.usrp_sink(device_addr=options.args, stream_args=stream_args) # Set up USRP system based on type if(uhd_type == "usrp"): self.u.set_subdev_spec("A:0 B:0") tr0 = uhd.tune_request(freq0) tr1 = uhd.tune_request(freq1) else: if abs(freq0 - freq1) > 5.5e6: sys.stderr.write("\nError: When not using two separate d'boards, frequencies must bewithin 5.5MHz of each other.\n") raise SystemExit self.u.set_subdev_spec("A:0 A:0") mid_freq = (freq0 + freq1)/2.0 tr0 = uhd.tune_request(freq0, rf_freq=mid_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL) tr1 = uhd.tune_request(freq1, rf_freq=mid_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL) # Use the tune requests to tune each channel self.set_freq(tr0, 0) self.set_freq(tr1, 1) self.usrp_rate = options.samp_rate self.u.set_samp_rate(self.usrp_rate) dev_rate = self.u.get_samp_rate() # ---------------------------------------------------------------- # build two signal sources, interleave them, amplify and # connect them to usrp sig0 = example_signal_0(self.usrp_rate) sig1 = example_signal_1(self.usrp_rate) intl = gr.interleave(gr.sizeof_gr_complex) self.connect(sig0, (intl, 0)) self.connect(sig1, (intl, 1)) # Correct for any difference in requested and actual rates rrate = self.usrp_rate / dev_rate resamp = blks2.pfb_arb_resampler_ccf(rrate) # and wire them up self.connect(intl, resamp, self.u) 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 self.set_gain(options.gain, 0) self.set_gain(options.gain, 1) # Set the subdevice spec if(options.spec): self.u.set_subdev_spec(options.spec, 0) # Set the antenna if(options.antenna): self.u.set_antenna(options.antenna, 0) self.u.set_antenna(options.antenna, 1)
def __init__(self, args1, args2): gr.top_block.__init__(self) ############################## # TRANSMIT CHAIN ############################## print "\nTRANSMIT CHAIN" ##USRP transmits repeating file generated in MATLAB #self.tx_src = blocks.file_source(gr.sizeof_gr_complex, "iq_in.dat", True) #USRP transmits a repeating vector generated here... tx_list = [ 0.2363 + 0.0741j, 0.0733 - 0.2865j, -0.1035 - 0.2663j, -0.0853 + 0.1909j, -0.0736 + 0.2699j, 0.0773 + 0.1481j, -0.0336 + 0.2079j, -0.0644 - 0.2244j, 0.0396 + 0.2822j, -0.0595 - 0.2416j, 0.1379 + 0.2658j, -0.0449 - 0.2539j, 0.0593 + 0.2946j, 0.0221 - 0.0113j, -0.1303 + 0.2762j, -0.1351 - 0.2598j, -0.0275 - 0.2617j, 0.2157 + 0.1021j, 0.0332 - 0.0383j, -0.1369 - 0.2680j ] self.vec_tx_src = blocks.vector_source_c(tuple(tx_list), True, SIGNAL_LEN, []) self.tx_src = blocks.vector_to_stream(gr.sizeof_gr_complex, SIGNAL_LEN) #Find USRP with device characteristics specified by args1 d1 = uhd.find_devices(uhd.device_addr(args1)) uhd_type1 = d1[0].get('type') print "\nFound '%s' at args '%s'" % \ (uhd_type1, args1) stream_args = uhd.stream_args('fc32') self.u_tx = uhd.usrp_sink(device_addr=args1, stream_args=stream_args) self.u_tx.set_samp_rate(SAMPLE_RATE) self.u_tx.set_clock_source("external") self.center_freq = END_FREQ - STEP_FREQ self.tr = uhd.tune_request(self.center_freq) self.tr.args = uhd.device_addr_t("mode_n=integer") self.u_tx.set_center_freq(self.tr) self.u_tx.set_bandwidth(SAMPLE_RATE * 1.5) # Get dboard gain range and select maximum tx_gain_range = self.u_tx.get_gain_range() tx_gain = tx_gain_range.stop() self.u_tx.set_gain(tx_gain - 9) self.connect(self.vec_tx_src, self.tx_src, self.u_tx) ############################## # RECEIVE CHAIN ############################## print "\nRECEIVE CHAIN" #USRP logs IQ data to file #This PMT dictionary stuff is stupid, however it's required otherwise the header will become corrupted... key = pmt.intern("rx_freq") val = pmt.from_double(0) extras = pmt.make_dict() extras = pmt.dict_add(extras, key, val) extras = pmt.serialize_str(extras) self.tag_debug = None self.u_rxs = [] for usrp_addr in args2.split(","): kv = usrp_addr.split("=") rx_dst = blocks.file_meta_sink( gr.sizeof_gr_complex * SIGNAL_LEN, "iq_out_{}.dat".format(kv[1]), SAMPLE_RATE, extra_dict=extras) #, detached_header=True) #rx_dst = blocks.file_sink(gr.sizeof_gr_complex*SIGNAL_LEN, "iq_out.dat") # Accumulate repeating sequences using custom block rx_accum = slocalization.accumulator_vcvc(SIGNAL_LEN, int(1e3)) #Find USRP with device characteristics specified by args1 d2 = uhd.find_devices(uhd.device_addr(usrp_addr)) uhd_type2 = d2[0].get('type') print "\nFound '%s' at args '%s'" % \ (uhd_type2, usrp_addr) u_rx = uhd.usrp_source(device_addr=usrp_addr, io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=1) u_rx.set_samp_rate(SAMPLE_RATE) u_rx.set_bandwidth(SAMPLE_RATE * 1.5) u_rx.set_clock_source("external") u_rx.set_center_freq(self.tr) self.u_rxs.append(u_rx) # Get dboard gain range and select maximum rx_gain_range = u_rx.get_gain_range() rx_gain = rx_gain_range.stop() u_rx.set_gain(rx_gain, 0) # Convert stream to vector s_to_v = blocks.stream_to_vector(gr.sizeof_gr_complex, SIGNAL_LEN) self.connect(u_rx, s_to_v, rx_accum, rx_dst) #self.connect (u_rx, s_to_v, rx_dst) if not self.tag_debug: # DEBUG: Monitor incoming tags... self.tag_debug = blocks.tag_debug( gr.sizeof_gr_complex * SIGNAL_LEN, "tag_debugger", "") self.connect(rx_accum, self.tag_debug) # Synchronize both USRPs' timebases u_rx.set_time_now(uhd.time_spec(0.0)) # Synchronize both USRPs' timebases self.u_tx.set_time_now(uhd.time_spec(0.0))
def __init__(self, args, tx_enable, rx_enable): gr.top_block.__init__(self) d = uhd.find_devices(uhd.device_addr(args)) print(d) uhd_type = d[0].get('type') print "\nFound '%s' at args '%s'" % \ (uhd_type, args) # Test the type of USRP; if it's a USRP (v1), it has # 2 channels; otherwise, it has 1 channel if uhd_type == "usrp": tx_nchan = 2 rx_nchan = 2 else: tx_nchan = 1 rx_nchan = 1 if tx_enable: print "\nTRANSMIT CHAIN" stream_args = uhd.stream_args('fc32', channels=range(tx_nchan)) self.u_tx = uhd.usrp_sink(device_addr=args, stream_args=stream_args) self.u_tx.set_samp_rate(MAX_RATE) self.tx_src0 = analog.sig_source_c(self.u_tx.get_samp_rate(), analog.GR_CONST_WAVE, 0, 1.0, 0) # Get dboard gain range and select maximum tx_gain_range = self.u_tx.get_gain_range() tx_gain = tx_gain_range.stop() # Get dboard freq range and select midpoint tx_freq_range = self.u_tx.get_freq_range() tx_freq_mid = (tx_freq_range.start() + tx_freq_range.stop()) / 2.0 for i in xrange(tx_nchan): self.u_tx.set_center_freq(tx_freq_mid + i * 1e6, i) self.u_tx.set_gain(tx_gain, i) print "\nTx Sample Rate: %ssps" % (n2s(self.u_tx.get_samp_rate())) for i in xrange(tx_nchan): print "Tx Channel %d: " % (i) print "\tFrequency = %sHz" % \ (n2s(self.u_tx.get_center_freq(i))) print "\tGain = %f dB" % (self.u_tx.get_gain(i)) print "" self.connect(self.tx_src0, self.u_tx) if rx_enable: print "\nRECEIVE CHAIN" self.u_rx = uhd.usrp_source(device_addr=args, io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=rx_nchan) self.rx_dst0 = blocks.null_sink(gr.sizeof_gr_complex) self.u_rx.set_samp_rate(MAX_RATE) # Get dboard gain range and select maximum rx_gain_range = self.u_rx.get_gain_range() rx_gain = rx_gain_range.stop() # Get dboard freq range and select midpoint rx_freq_range = self.u_rx.get_freq_range() rx_freq_mid = (rx_freq_range.start() + rx_freq_range.stop()) / 2.0 for i in xrange(tx_nchan): self.u_rx.set_center_freq(rx_freq_mid + i * 1e6, i) self.u_rx.set_gain(rx_gain, i) print "\nRx Sample Rate: %ssps" % (n2s(self.u_rx.get_samp_rate())) for i in xrange(rx_nchan): print "Rx Channel %d: " % (i) print "\tFrequency = %sHz" % \ (n2s(self.u_rx.get_center_freq(i))) print "\tGain = %f dB" % (self.u_rx.get_gain(i)) print "" self.connect(self.u_rx, self.rx_dst0)
def __init__(self): gr.top_block.__init__(self) usage = "usage: %prog [options] min_freq max_freq" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-a", "--args", type="string", default="", help="UHD device address args [default=%default]") parser.add_option("", "--spec", type="string", default=None, help="Subdevice of UHD device where appropriate") parser.add_option("-R", "--rx-antenna", type="string", default="RX2", help="select RX antenna where appropriate") parser.add_option("-T", "--tx-antenna", type="string", default="TX/RX", help="select TX antenna where appropriate") parser.add_option("-s", "--samp-rate", type="eng_float", default=1e6, help="set sample rate [default=%default]") parser.add_option("-g", "--gain", type="eng_float", default=None, help="set gain in dB (default is midpoint)") parser.add_option( "", "--tune-delay", type="eng_float", default=0.25, metavar="SECS", help= "time to delay (in seconds) after changing frequency [default=%default]" ) parser.add_option( "", "--dwell-delay", type="eng_float", default=0.25, metavar="SECS", help= "time to delay (in seconds) at a given frequency [default=%default]" ) parser.add_option( "-b", "--channel-bandwidth", type="eng_float", default=6.25e3, metavar="Hz", help="channel bandwidth of fft bins in Hz [default=%default]") parser.add_option("-l", "--lo-offset", type="eng_float", default=0, metavar="Hz", help="lo_offset in Hz [default=%default]") parser.add_option("-q", "--squelch-threshold", type="eng_float", default=None, metavar="dB", help="squelch threshold in dB [default=%default]") parser.add_option( "-F", "--fft-size", type="int", default=None, help="specify the number of FFT bins [default=samp_rate/channel_bw]" ) parser.add_option("", "--real-time", action="store_true", default=False, help="Attempt to enable real-time scheduling") parser.add_option( "-w", "--tx-bandwidth", type="eng_float", default=6e6, metavar="Hz", help="transmit frequency bandwidth [default=%default]") (options, args) = parser.parse_args() if len(args) != 2: parser.print_help() sys.exit(1) self.channel_bandwidth = options.channel_bandwidth #fft channel bandwidth self.tx_bandwidth = options.tx_bandwidth self.min_freq = eng_notation.str_to_num(args[0]) self.max_freq = eng_notation.str_to_num(args[1]) if self.min_freq < 1e6: self.min_freq *= 1e6 if self.max_freq < 1e6: self.max_freq *= 1e6 self.n_channel_grps = 5 #number of channel groups self.curr_channel_grp = 0 self.n_channels = 5 #number of channels / channel group self.curr_channel = 0 self.tx_guard_band = 4e6 if self.min_freq > self.max_freq: #swap them self.min_freq, self.max_freq = self.max_freq, self.min_freq self.channel_grp_bw = (self.max_freq - self.min_freq) / self.n_channel_grps self.tx_channel_bw = self.channel_grp_bw / self.n_channels # tx channel bw if not options.real_time: real_time = False else: #Attempt to enable realtime scheduling r = gr.enable_realtime_scheduling() if r == gr.RT_OK: realtime = True else: realtime = False print "Note: failed to enable realtime scheduling" #build graph self.u_rx = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32')) #Set the subdevice spec if options.spec: self.u_rx.set_subdev_spec(options.spec, 0) #Set the antenna if options.rx_antenna: self.u_rx.set_antenna(options.rx_antenna, 0) self.u_rx.set_samp_rate(options.samp_rate) self.usrp_rate = usrp_rate = self.u_rx.get_samp_rate() self.lo_offset = options.lo_offset if options.fft_size is None: self.fft_size = int(self.usrp_rate / self.channel_bandwidth) else: self.fft_size = options.fft_size print "FFT Size: %d, USRP Samp Rate: %d, Channel Bandwidth: %d" % ( self.fft_size, self.usrp_rate, self.channel_bandwidth) self.squelch_threshold = options.squelch_threshold s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = filter.window.blackmanharris(self.fft_size) ffter = fft.fft_vcc(self.fft_size, True, mywindow, True) c2mag = blocks.complex_to_mag_squared(self.fft_size) tune_delay = max(0, int( round(options.tune_delay * usrp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int( round(options.dwell_delay * usrp_rate / self.fft_size))) # in fft frames self.msgq = gr.msg_queue(1) self._tune_callback = tune( self) #hang on to this to keep it from being GC'd stats = blocks.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) self.connect(self.u_rx, s2v, ffter, c2mag, stats) #transmit chain d = uhd.find_devices(uhd.device_addr(options.args)) if d: uhd_type = d[0].get('type') print "\nFound '%s'" % uhd_type else: print "\nNo device found" self.u_tx = None return #check version of USRP and set num_channels if uhd_type == "usrp": tx_nchan = 2 rx_nchan = 2 else: tx_nchan = 1 rx_nchan = 1 #setup transmit chain (usrp sink, signal source) #usrp sink stream_args = uhd.stream_args('fc32', channels=range(tx_nchan)) self.u_tx = uhd.usrp_sink(device_addr=options.args, stream_args=stream_args) self.u_tx.set_samp_rate(self.usrp_rate) if options.tx_antenna: self.u_tx.set_antenna(options.tx_antenna, 0) #analog signal source - sig_source_c(sampling_freq,waveform, wave_freq, ampl, offset=0) self.tx_src0 = analog.sig_source_c(self.u_tx.get_samp_rate(), analog.GR_CONST_WAVE, 0, 1.0, 0) #connect blocks self.connect(self.tx_src0, self.u_tx) if options.gain is None: # if no gain was specified use the midpoint in dB g = self.u_rx.get_gain_range() options.gain = float(g.start() + g.stop()) / 2.0 self.set_gain(options.gain) print "gain =", options.gain #initialize transmission parameters self.set_channel_group(3) self.step_count = 0
def _usrp_setup(self): """Create, set up, and return USRP sink object.""" op = self.op # create usrp sink block usrp = uhd.usrp_sink( device_addr=','.join(chain(op.mboard_strs, op.dev_args)), stream_args=uhd.stream_args(cpu_format='fc32', otw_format='sc16', channels=range(op.nchs), args=','.join(op.stream_args))) # set clock and time source if synced if op.sync: try: usrp.set_clock_source(op.sync_source, uhd.ALL_MBOARDS) usrp.set_time_source(op.sync_source, uhd.ALL_MBOARDS) except RuntimeError: errstr = ( "Unknown sync_source option: '{0}'. Must be one of {1}." ).format(op.sync_source, usrp.get_clock_sources(0)) raise ValueError(errstr) # check for ref lock mbnums_with_ref = [ mb_num for mb_num in range(op.nmboards) if 'ref_locked' in usrp.get_mboard_sensor_names(mb_num) ] if mbnums_with_ref: if op.verbose: sys.stdout.write('Waiting for reference lock...') sys.stdout.flush() timeout = 0 while not all( usrp.get_mboard_sensor('ref_locked', mb_num).to_bool() for mb_num in mbnums_with_ref): if op.verbose: sys.stdout.write('.') sys.stdout.flush() time.sleep(1) timeout += 1 if timeout > 30: if op.verbose: sys.stdout.write('failed\n') sys.stdout.flush() raise RuntimeError('Failed to lock to 10 MHz reference.') if op.verbose: sys.stdout.write('locked\n') sys.stdout.flush() # set mainboard options for mb_num in range(op.nmboards): usrp.set_subdev_spec(op.subdevs[mb_num], mb_num) # set global options # sample rate usrp.set_samp_rate(float(op.samplerate)) # read back actual value samplerate = usrp.get_samp_rate() # calculate longdouble precision sample rate # (integer division of clock rate) cr = usrp.get_clock_rate() srdec = int(round(cr / samplerate)) samplerate_ld = np.longdouble(cr) / srdec op.samplerate = samplerate_ld sr_rat = Fraction(cr).limit_denominator() / srdec op.samplerate_num = sr_rat.numerator op.samplerate_den = sr_rat.denominator # Set device time using the onboard GPS freq_stepper.set_dev_time(usrp) # set per-channel options # set command time so settings are synced gpstime = datetime.utcfromtimestamp(usrp.get_mboard_sensor("gps_time")) gpstime_secs = (pytz.utc.localize(gpstime) - drf.util.epoch).total_seconds() COMMAND_DELAY = 0.2 cmd_time_secs = gpstime_secs + COMMAND_DELAY usrp.set_command_time( uhd.time_spec(float(cmd_time_secs)), uhd.ALL_MBOARDS, ) for ch_num in range(op.nchs): # local oscillator sharing settings lo_source = op.lo_sources[ch_num] if lo_source: try: usrp.set_lo_source(lo_source, uhd.ALL_LOS, ch_num) except RuntimeError: errstr = ( "Unknown LO source option: '{0}'. Must be one of {1}," " or it may not be possible to set the LO source on" " this daughterboard.").format( lo_source, usrp.get_lo_sources(uhd.ALL_LOS, ch_num)) raise ValueError(errstr) lo_export = op.lo_exports[ch_num] if lo_export is not None: if not lo_source: errstr = ( 'Channel {0}: must set an LO source in order to set' ' LO export.').format(ch_num) raise ValueError(errstr) usrp.set_lo_export_enabled(lo_export, uhd.ALL_LOS, ch_num) # center frequency and tuning offset tune_res = usrp.set_center_freq( uhd.tune_request( op.centerfreqs[ch_num], op.lo_offsets[ch_num], args=uhd.device_addr(','.join(op.tune_args)), ), ch_num, ) # store actual values from tune result op.centerfreqs[ch_num] = (tune_res.actual_rf_freq + tune_res.actual_dsp_freq) op.lo_offsets[ch_num] = -tune_res.actual_dsp_freq # dc offset dc_offset = op.dc_offsets[ch_num] if dc_offset is not None: usrp.set_dc_offset(dc_offset, ch_num) # iq balance iq_balance = op.iq_balances[ch_num] if iq_balance is not None: usrp.set_iq_balance(iq_balance, ch_num) # gain usrp.set_gain(op.gains[ch_num], ch_num) # bandwidth bw = op.bandwidths[ch_num] if bw: usrp.set_bandwidth(bw, ch_num) # antenna ant = op.antennas[ch_num] if ant: try: usrp.set_antenna(ant, ch_num) except RuntimeError: errstr = ( "Unknown RX antenna option: '{0}'. Must be one of {1}." ).format(ant, usrp.get_antennas(ch_num)) raise ValueError(errstr) # commands are done, clear time usrp.clear_command_time(uhd.ALL_MBOARDS) time.sleep(COMMAND_DELAY) # read back actual channel settings for ch_num in range(op.nchs): if op.lo_sources[ch_num]: op.lo_sources[ch_num] = usrp.get_lo_source(uhd.ALL_LOS, ch_num) if op.lo_exports[ch_num] is not None: op.lo_exports[ch_num] = usrp.get_lo_export_enabled( uhd.ALL_LOS, ch_num, ) op.gains[ch_num] = usrp.get_gain(ch_num) op.bandwidths[ch_num] = usrp.get_bandwidth(chan=ch_num) op.antennas[ch_num] = usrp.get_antenna(chan=ch_num) if op.verbose: print('Using the following devices:') chinfostrs = [ 'Motherboard: {mb_id} ({mb_addr}) | Daughterboard: {db_name}', 'Subdev: {sub} | Antenna: {ant} | Gain: {gain} | Rate: {sr}', 'Frequency: {freq:.3f} ({lo_off:+.3f}) | Bandwidth: {bw}', ] if any(op.lo_sources) or any(op.lo_exports): chinfostrs.append( 'LO source: {lo_source} | LO export: {lo_export}') chinfo = '\n'.join([' ' + l for l in chinfostrs]) for ch_num in range(op.nchs): header = '---- {0} '.format(ch_num) header += '-' * (78 - len(header)) print(header) usrpinfo = dict(usrp.get_usrp_info(chan=ch_num)) info = {} info['mb_id'] = usrpinfo['mboard_id'] mba = op.mboards_bychan[ch_num] if mba == 'default': mba = usrpinfo['mboard_serial'] info['mb_addr'] = mba info['db_name'] = usrpinfo['tx_subdev_name'] info['sub'] = op.subdevs_bychan[ch_num] info['ant'] = op.antennas[ch_num] info['bw'] = op.bandwidths[ch_num] info['dc_offset'] = op.dc_offsets[ch_num] info['freq'] = op.centerfreqs[ch_num] info['gain'] = op.gains[ch_num] info['iq_balance'] = op.iq_balances[ch_num] info['lo_off'] = op.lo_offsets[ch_num] info['lo_source'] = op.lo_sources[ch_num] info['lo_export'] = op.lo_exports[ch_num] info['sr'] = op.samplerate print(chinfo.format(**info)) print('-' * 78) return usrp
def _usrp_setup(self): """Create, set up, and return USRP source object.""" op = self.op # create usrp source block if op.dec > 1: op.cpu_format = 'fc32' else: op.cpu_format = 'sc16' op.otw_format = 'sc16' u = uhd.usrp_source( device_addr=','.join(chain(op.mboard_strs, op.dev_args)), stream_args=uhd.stream_args(cpu_format=op.cpu_format, otw_format=op.otw_format, channels=range(len(op.chs)), args=','.join(op.stream_args)), ) # set clock and time source if synced if op.sync: try: u.set_clock_source(op.sync_source, uhd.ALL_MBOARDS) u.set_time_source(op.sync_source, uhd.ALL_MBOARDS) except RuntimeError: errstr = ( "Unknown sync_source option: '{0}'. Must be one of {1}." ).format(op.sync_source, u.get_clock_sources(0)) raise ValueError(errstr) # set mainboard options for mb_num in range(op.nmboards): u.set_subdev_spec(op.subdevs[mb_num], mb_num) # set global options # sample rate u.set_samp_rate(float(op.samplerate)) # read back actual value samplerate = u.get_samp_rate() # calculate longdouble precision sample rate # (integer division of clock rate) cr = u.get_clock_rate() srdec = int(round(cr / samplerate)) samplerate_ld = np.longdouble(cr) / srdec op.samplerate = samplerate_ld sr_rat = Fraction(cr).limit_denominator() / srdec op.samplerate_num = sr_rat.numerator op.samplerate_den = sr_rat.denominator # set per-channel options # set command time so settings are synced COMMAND_DELAY = 0.2 cmd_time = u.get_time_now() + uhd.time_spec(COMMAND_DELAY) u.set_command_time(cmd_time, uhd.ALL_MBOARDS) for ch_num in range(op.nchs): # local oscillator sharing settings lo_source = op.lo_sources[ch_num] if lo_source: try: u.set_lo_source(lo_source, uhd.ALL_LOS, ch_num) except RuntimeError: errstr = ( "Unknown LO source option: '{0}'. Must be one of {1}," " or it may not be possible to set the LO source on" " this daughterboard.").format( lo_source, u.get_lo_sources(uhd.ALL_LOS, ch_num)) raise ValueError(errstr) lo_export = op.lo_exports[ch_num] if lo_export is not None: if not lo_source: errstr = ( 'Channel {0}: must set an LO source in order to set' ' LO export.').format(ch_num) raise ValueError(errstr) u.set_lo_export_enabled(lo_export, uhd.ALL_LOS, ch_num) # center frequency and tuning offset tune_res = u.set_center_freq( uhd.tune_request( op.centerfreqs[ch_num], op.lo_offsets[ch_num], args=uhd.device_addr(','.join(op.tune_args)), ), ch_num, ) # store actual values from tune result op.centerfreqs[ch_num] = (tune_res.actual_rf_freq - tune_res.actual_dsp_freq) op.lo_offsets[ch_num] = tune_res.actual_dsp_freq # gain u.set_gain(op.gains[ch_num], ch_num) # bandwidth bw = op.bandwidths[ch_num] if bw: u.set_bandwidth(bw, ch_num) # antenna ant = op.antennas[ch_num] if ant: try: u.set_antenna(ant, ch_num) except RuntimeError: errstr = ( "Unknown RX antenna option: '{0}'. Must be one of {1}." ).format(ant, u.get_antennas(ch_num)) raise ValueError(errstr) # commands are done, clear time u.clear_command_time(uhd.ALL_MBOARDS) time.sleep(COMMAND_DELAY) # read back actual channel settings for ch_num in range(op.nchs): if op.lo_sources[ch_num]: op.lo_sources[ch_num] = u.get_lo_source(uhd.ALL_LOS, ch_num) if op.lo_exports[ch_num] is not None: op.lo_exports[ch_num] = u.get_lo_export_enabled( uhd.ALL_LOS, ch_num, ) op.gains[ch_num] = u.get_gain(ch_num) op.bandwidths[ch_num] = u.get_bandwidth(chan=ch_num) op.antennas[ch_num] = u.get_antenna(chan=ch_num) if op.verbose: print('Using the following devices:') chinfostrs = [ 'Motherboard: {mb_id} ({mb_addr}) | Daughterboard: {db_name}', 'Subdev: {sub} | Antenna: {ant} | Gain: {gain} | Rate: {sr}', 'Frequency: {freq:.3f} ({lo_off:+.3f}) | Bandwidth: {bw}', ] if any(op.lo_sources) or any(op.lo_exports): chinfostrs.append( 'LO source: {lo_source} | LO export: {lo_export}') chinfo = '\n'.join([' ' + l for l in chinfostrs]) for ch_num in range(op.nchs): header = '---- {0} '.format(op.chs[ch_num]) header += '-' * (78 - len(header)) print(header) usrpinfo = dict(u.get_usrp_info(chan=ch_num)) info = {} info['mb_id'] = usrpinfo['mboard_id'] mba = op.mboards_bychan[ch_num] if mba == 'default': mba = usrpinfo['mboard_serial'] info['mb_addr'] = mba info['db_name'] = usrpinfo['rx_subdev_name'] info['sub'] = op.subdevs_bychan[ch_num] info['ant'] = op.antennas[ch_num] info['bw'] = op.bandwidths[ch_num] info['freq'] = op.centerfreqs[ch_num] info['gain'] = op.gains[ch_num] info['lo_off'] = op.lo_offsets[ch_num] info['lo_source'] = op.lo_sources[ch_num] info['lo_export'] = op.lo_exports[ch_num] info['sr'] = op.samplerate print(chinfo.format(**info)) print('-' * 78) return u
def step( usrp, op, ch_num=0, sleeptime=0.1, freq_list_fname=None, flog_fname=None, lock_fname=None, time_source='GPS', timestr='%Y/%b/%d %H:%M:%S', ): """ Step the USRP's oscillator through a list of frequencies """ if freq_list_fname: freq_list = get_freq_list( freq_list_fname) if freq_list_fname else set_freq_list() else: freq_list = set_freq_list() print('Starting freq_stepper') prev_lock = False # Check for GPS lock while not usrp.get_mboard_sensor("gps_locked", 0).to_bool(): print("waiting for gps lock...") time.sleep(5) assert usrp.get_mboard_sensor("gps_locked", 0).to_bool(), "GPS still not locked" # Begin infinite transmission loop freq = 0 while 1: # Set USRP time (necessary to know what sample number we shifted frequencies at) usrptime_secs = usrp.get_time_now().get_real_secs() if time_source == 'GPS': # Set GPS time (necessary to sync operations between the transmitter and receiver) gpstime = datetime.utcfromtimestamp( usrp.get_mboard_sensor("gps_time")) time_next = pytz.utc.localize(gpstime) + timedelta(seconds=1) elif time_source == 'USRP': time_next = drf.util.epoch + timedelta(seconds=usrptime_secs + 1) # Calculate the samplerate try: ch_samplerate_frac = op.ch_samplerates_frac[ch_num] ch_samplerate_ld = (np.longdouble(ch_samplerate_frac.numerator) / np.longdouble(ch_samplerate_frac.denominator)) except: ch_samplerate_ld = op.samplerate # Frequency shifting block # Change frequency each time we hit a new time in the list, otherwise hold the existing note if ((time_next.second) in freq_list.keys()) and (freq != freq_list[time_next.second]): tune_time = time_next freq = freq_list[time_next.second] # Specify USRP tune time on the first exact sample after listed time # tune_time_secs = (tune_time - drf.util.epoch).total_seconds() tune_time_secs = usrp.get_time_last_pps().get_real_secs() + 1 tune_time_rsamples = np.ceil(tune_time_secs * op.samplerate) tune_time_secs = tune_time_rsamples / op.samplerate gps_lock = usrp.get_mboard_sensor("gps_locked").to_bool() print('GPS lock status: %s' % gps_lock) timestr = tune_time.strftime('%Y/%m/%d-%H:%M:%S') if lock_fname: if gps_lock != prev_lock: with open(tune_time.strftime(lock_fname), 'a+') as f: f.write('GPS lock status: %s at %s' % (gps_lock, timestr)) prev_lock = gps_lock # Optionally write out the shift samples of each frequency tune_sample = int(np.uint64(tune_time_secs * ch_samplerate_ld)) if flog_fname: # Change to 'a' to append with open(tune_time.strftime(flog_fname), 'w') as f: f.write('%s %s %i\n' % (timestr, str(freq).rjust(4), tune_sample)) usrp.set_command_time( uhd.time_spec(float(tune_time_secs)), uhd.ALL_MBOARDS, ) # Tune to the next frequency in the list tune_res = usrp.set_center_freq( uhd.tune_request(freq * 1E6, op.lo_offsets[ch_num], \ args=uhd.device_addr(','.join(op.tune_args)), ), ch_num, ) usrp.clear_command_time(uhd.ALL_MBOARDS) if op.verbose: print('Tuned to %s MHz at %s (sample %i)' % \ (str(freq).rjust(4), tune_time.strftime(timestr), tune_sample, ) ) """ gpstime = datetime.utcfromtimestamp(usrp.get_mboard_sensor("gps_time")) usrptime = drf.util.epoch + timedelta(seconds=usrp.get_time_now().get_real_secs()) print('GPS tune time: %s\nUSRP tune time: %s' % (gpstime.strftime(timestr), usrptime.strftime(timestr)) ) """ time.sleep(sleeptime)