def __init__(self, N, fs): gr.hier_block2.__init__(self, "usrp_source", gr.io_signature(0,0,0), gr.io_signature(1,1, gr.sizeof_gr_complex)) # Parameters. frequency = 1575.6e6 decim_rate = int(64e6/fs) fpga_filename = "std_4rx_0tx.rbf" # Sources. usrp = usrp.source_c( decim_rate=decim_rate, fpga_filename=fpga_filename ) head = gr.head( gr.sizeof_gr_complex, N*fs*1e-3 ) self.connect( usrp, head, self ) # USRP settings. rx_subdev_spec = usrp.pick_rx_subdevice(usrp) usrp.set_mux(usrp.determine_rx_mux_value(usrp, rx_subdev_spec)) subdev = usrp.selected_subdev( usrp, rx_subdev_spec ) print "Subdev gain range: " print subdev.gain_range() subdev.set_gain(70) r = usrp.tune( 0,_subdev, frequency ) if not r: sys.exit('Failed to set frequency')
def __init__(self, usrp_offset): gr.flow_graph.__init__(self) print "decim = %d, gain = %d, offset = %.2f" % (decim, gain, usrp_offset) print "filter center %.2f, filter width %.2f" % (xcf, xtw) u = usrp.source_c(decim_rate=decim) s = usrp.pick_subdev(u, (usrp_dbid.DBS_RX,)) u.set_mux(usrp.determine_rx_mux_value(u, s)) subdev = usrp.selected_subdev(u, s) if subdev.dbid() != usrp_dbid.DBS_RX: raise Exception("dbs daughterboard not detected!") subdev.set_gain(gain) sps = u.adc_freq() / u.decim_rate() if sps < 2 * gsm_rate: raise Exception("sample rate too low") u.tune(0, subdev, c0 + usrp_offset) xt = gr.firdes.low_pass(1.0, sps, xcf, xtw, gr.firdes.WIN_HAMMING) xf = gr.fir_filter_ccf(1, xt) self.gs = gs = gssm.sink(sps) self.connect(u, xf, gs)
def __init__(self, usrp_offset): gr.top_block.__init__(self) u = usrp.source_c(decim_rate = decim) s = usrp.pick_subdev(u, (usrp_dbid.DBS_RX,)) u.set_mux(usrp.determine_rx_mux_value(u, s)) subdev = usrp.selected_subdev(u, s) if subdev.dbid() != usrp_dbid.DBS_RX: raise Exception('dbs daughterboard not detected!') subdev.set_gain(gain) sps = u.adc_freq() / u.decim_rate() if sps < 2 * gsm_rate: raise Exception('sample rate too low') u.tune(0, subdev, c0 + usrp_offset) xcf = 150e3 xtw = 50e3 xt = gr.firdes.low_pass(1.0, sps, xcf, xtw, gr.firdes.WIN_HAMMING) xf = gr.fir_filter_ccf(1, xt) g = gssm.sink(sps) self.connect(u, xf, g)
def setup_usrp(freq, gain): ######## set up usrp u = usrp.source_c(decim_rate=32) # 2M sampling freq rx_subdev_spec = usrp.pick_rx_subdevice(u) #print "u.db(0,0).dbid() = ", self.u.db(0,0).dbid() #print "u.db(1,0).dbid() = ", self.u.db(1,0).dbid() #print "rx_subdev_spec = ", options.rx_subdev_spec mux=usrp.determine_rx_mux_value(u, rx_subdev_spec) #print "mux = ", mux u.set_mux(mux) # determine the daughterboard subdevice we're using subdev = usrp.selected_subdev(u, rx_subdev_spec) #print "Using RX d'board %s" % (self.subdev.side_and_name(),) input_rate = u.adc_freq() / u.decim_rate() #print "ADC sampling @ ", eng_notation.num_to_str(self.u.adc_freq()) #print "USB sample rate %s" % (eng_notation.num_to_str(input_rate)) subdev.set_gain(gain) r = u.tune(0, subdev, freq) #print "freq range = [%s, %s]" % (eng_notation.num_to_str(self.subdev.freq_min()), eng_notation.num_to_str(self.subdev.freq_max())) if not r: sys.stderr.write('Failed to set frequency\n') raise SystemExit, 1 return u
def _setup_usrp_source(self): self.rx_u = usrp.source_c (fusb_block_size=self._fusb_block_size, fusb_nblocks=self._fusb_nblocks) adc_rate = self.rx_u.adc_rate() self.rx_u.set_decim_rate(self._decim) # determine the daughterboard subdevice we're using if self._rx_subdev_spec is None: print 'not set rx subdev' self._rx_subdev_spec = usrp.pick_rx_subdevice(self.rx_u) print self._rx_subdev_spec self.rx_subdev = usrp.selected_subdev(self.rx_u, self._rx_subdev_spec) gains = self.rx_subdev.gain_range() self.rx_subdev.set_gain((gains[0]+gains[1])/2) self.rx_u.set_mux(usrp.determine_rx_mux_value(self.rx_u, self._rx_subdev_spec)) print 'subdev size %d' % self.rx_subdev.which() ok = self.rx_u.tune(0, self.rx_subdev, self._rx_freq) if not ok: print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(self._rx_freq),) raise ValueError self.rx_subdev.set_auto_tr(True)
def __init__(self): gr.top_block.__init__ (self) self.u = usrp.source_c(0, usrp_decim) print "USRP Serial: ", self.u.serial_number() usrp_rate = self.u.adc_rate() / usrp_decim # 256 kS/s rx_subdev_spec = usrp.pick_subdev(self.u, dblist) self.u.set_mux(usrp.determine_rx_mux_value(self.u, rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, rx_subdev_spec) print "Using d'board", self.subdev.side_and_name() self.gain = self.subdev.gain_range()[1] self.subdev.set_gain(self.gain) r = usrp.tune(self.u, 0, self.subdev, freq) if r: print "Freq: ", freq/1e6, "MHz" else: print "Failed to set frequency, quitting!" sys.exit(1) chan_filter_coeffs = gr.firdes.low_pass( 1.0, # gain usrp_rate, # sampling rate 80e3, # passband cutoff 35e3, # transition width gr.firdes.WIN_HAMMING) self.chan_filter = gr.fir_filter_ccf(1, chan_filter_coeffs) print "# channel filter:", len(chan_filter_coeffs), "taps" self.file_sink = gr.file_sink(gr.sizeof_gr_complex*1, "/home/sdr/rds_samples.dat") self.connect(self.u, self.chan_filter, self.file_sink)
def __init__( self, decim ): self.freq = -2.5e6 self.src = usrp.source_c( ) self.subdev = usrp.pick_subdev( self.src, (usrp_dbid.BASIC_RX, usrp_dbid.TV_RX, usrp_dbid.TV_RX_REV_2, usrp_dbid.TV_RX_REV_3, usrp_dbid.TV_RX_MIMO, usrp_dbid.TV_RX_REV_2_MIMO, usrp_dbid.TV_RX_REV_3_MIMO)) print self.subdev self.subdevice = usrp.selected_subdev( self.src, self.subdev ) self.mux = usrp.determine_rx_mux_value( self.src, self.subdev ) self.decim = decim self.adc_rate = self.src.adc_rate() self.usrp_rate = self.adc_rate / self.decim self.src.set_decim_rate( self.decim ) self.src.set_mux( self.mux ) usrp.tune( self.src, 0, self.subdevice, self.freq )
def __init__(self,subdev_spec=None,gain=None,length=1,alpha=1.0,msgq=None,loopback=False,verbose=False,debug=False): self._subdev_spec = subdev_spec self._gain = gain self._length = length self._alpha = alpha self._msgq = msgq self._loopback = loopback self._verbose = verbose self._debug = debug self._fg = gr.flow_graph() self._u = usrp.source_c(fpga_filename='usrp_sounder.rbf') if not self._loopback: if self._subdev_spec == None: self._subdev_spec = pick_subdevice(self._u) self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec)) self._subdev = usrp.selected_subdev(self._u, self._subdev_spec) if self._verbose: print "Using", self._subdev.name(), "for sounder receiver." self.set_gain(self._gain) self._vblen = gr.sizeof_gr_complex*self._length if self._debug: print "Generating impulse vectors of length", self._length, "byte length", self._vblen self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length) if self._verbose: print "Using smoothing alpha of", self._alpha self._lpf = gr.single_pole_iir_filter_cc(self._alpha, self._length) self._sink = gr.message_sink(self._vblen, self._msgq, True) self._fg.connect(self._u, self._s2v, self._lpf, self._sink)
def _setup_usrp_source(self, options): #create USRP self._usrp = usrp.source_c(which= options.which, decim_rate = options.decim_rate) if options.rx_subdev_spec is None: options.rx_subdev_spec = usrp.pick_rx_subdevice(self._usrp) self._subdev = usrp.selected_subdev(self._usrp, options.rx_subdev_spec) adc_rate = self._usrp.adc_rate() mux = usrp.determine_rx_mux_value(self._usrp, options.rx_subdev_spec) self._usrp.set_mux(mux) tr = self._usrp.tune(0, self._subdev, options.freq) if not (tr): print "Failed to tune to center frequency!" else: print "Center frequency:", n2s(options.freq) if options.gain is None: g = self._subdev.gain_range(); options.gain = float(g[0]+g[1])/2.0 self._subdev.set_gain(options.gain) #the bitrate option is initialised to value self.rs_rate = options.rate #Hard initialisation of bits per symbol self.bits_per_symbol = 1 if options.verbose: print "USRP source:", self._usrp print "Decimation:", options.decim_rate
def _set_source(self): options = self.options fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096) fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16) self.usrp = usrp.source_c(decim_rate=options.decim, fusb_block_size=fusb_block_size, fusb_nblocks=fusb_nblocks) if options.rx_subdev_spec is None: options.rx_subdev_spec = usrp.pick_rx_subdevice(self.usrp) self.usrp.set_mux(usrp.determine_rx_mux_value(self.usrp, options.rx_subdev_spec)) # determine the daughterboard subdevice self.subdev = usrp.selected_subdev(self.usrp, options.rx_subdev_spec) print "Using Rx d'board %s" % (self.subdev.side_and_name(),) input_rate = self.usrp.adc_freq() / self.usrp.decim_rate() print "USB sample rate %s" % (eng_notation.num_to_str(input_rate)) # set initial values if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.gain = float(g[0]+g[1])/2 r = self.usrp.tune(0, self.subdev, options.freq) self.subdev.set_gain(options.gain) return self.usrp
def __set_rx_from_usrp(self, subdev_spec, decimation_rate, gain, frequency, preserve): from gnuradio import usrp # setup USRP self.usrp.set_decim_rate(decimation_rate) if subdev_spec is None: subdev_spec = usrp.pick_rx_subdevice(self.usrp) self.usrp.set_mux(usrp.determine_rx_mux_value(self.usrp, subdev_spec)) subdev = usrp.selected_subdev(self.usrp, subdev_spec) capture_rate = self.usrp.adc_freq() / self.usrp.decim_rate() self.info["capture-rate"] = capture_rate if gain is None: g = subdev.gain_range() gain = float(g[0]+g[1])/2 subdev.set_gain(gain) r = self.usrp.tune(0, subdev, frequency) if not r: raise RuntimeError("failed to set USRP frequency") # capture file if preserve: try: self.capture_filename = os.tmpnam() except RuntimeWarning: ignore = True capture_file = gr.file_sink(gr.sizeof_gr_complex, self.capture_filename) self.__connect([[self.usrp, capture_file]]) else: self.capture_filename = None # everything else self.__build_graph(self.usrp, capture_rate)
def __init__(self, options, args, queue): gr.top_block.__init__(self) self.options = options self.args = args self.u = usrp.source_c(which=0, decim_rate=self.options.decim) if self.options.rx_subdev_spec is None: self.options.rx_subdev_spec = pick_subdevice(self.u) self.u.set_mux(usrp.determine_rx_mux_value(self.u, self.options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, self.options.rx_subdev_spec) if options.gain is None: # Select a gain in the middle of the range g = self.subdev.gain_range() options.gain = float(g[0]+g[1])/2 self.subdev.set_gain(options.gain) r = self.u.tune(0, self.subdev, options.freq) if_rate = self.u.adc_freq() / self.u.decim_rate() self.mode_s = ppm_demod(if_rate, options.thresh) pass_all = 0 if options.output_all: pass_all = 1 self.format = air.ms_fmt_log(pass_all, queue) self.connect(self.u, self.mode_s, self.format)
def main(): tb = gr.top_block() ofdm_rx = howto.ofdm_rx(); #rs = gr.vector_source_c() #rs = gr.file_source(gr.sizeof_gr_complex,'out.dat') src = usrp.source_c(0) #nchannel src.set_nchannels(1) sample_rate = 1e6 ulist = [src] print "ulist" print ulist for u in ulist: rdecim = int(u.adc_rate() / sample_rate) u.set_decim_rate(rdecim) sys.stderr.write("the decimate = %d\n"%(rdecim)) srx1 = usrp.pick_rx_subdevice(src) print "srx1=" print srx1 subdev = () """configure USRP mux and set rx/tx subdev """ ulist = [src] assert len(ulist) == 1 src = ulist[0] src.set_mux( usrp.determine_rx_mux_value(src, srx1)) subdev += (usrp.selected_subdev(src, srx1), ) for s in subdev: exec("if not hasattr(s, '_u'): s._u = src") for s in subdev: s.set_auto_tr(True) print "subdev" print subdev freq = 2400000000.0 for s in subdev: r = usrp.tune(s._u, s.which(), s, freq) if r: sys.stderr.write("setting frequency of %s :\n"%(str(s))) sys.stderr.write(" baseband frequency = %s \n" %(eng_notation.num_to_str(r.baseband_freq))) sys.stderr.write(" DUC/DDC offset = %s\n" %(eng_notation.num_to_str(r.dxc_freq))) elif not r: sys.stderr.write("Unable to set frequency of %s to %g MHz \n"%(str(s), freq/ 1.0e6)) #g = 40.0 for s in subdev: gain_range = s.gain_range() #rx_gain = max(min(g, gain_range[1]), gain_range[0]) rx_gain = 0.3 * gain_range[1] s.set_gain(rx_gain) sys.stderr.write("the rx_gain = %d \n " %(rx_gain)) tb.connect(src, ofdm_rx) print 'connect' tb.run()
def __init__(self, options): gr.top_block.__init__(self) # Create a USRP source with GPIO FPGA build, then configure u = usrp.source_s(decim_rate=options.decim,fpga_filename=gpio.fpga_filename) if options.force_complex_RXA: # This is a dirty hack to force complex mode (receive both I and Q) on basicRX or LFRX # This forces the receive board in RXA (side A) to be used # FIXME: This has as a side effect that the gain for Q is not set. So only use with gain 0 (--gain 0) options.rx_subdev_spec=(0,0) u.set_mux(0x10) if not (0==options.gain): print "WARNING, you should set the gain to 0 with --gain 0 when using --force-complex-RXA" print "The gain for Q will now still be zero while the gain for I is not" #options.gain=0 else: if options.rx_subdev_spec is None: options.rx_subdev_spec = usrp.pick_rx_subdevice(u) u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec)) subdev = usrp.selected_subdev(u, options.rx_subdev_spec) print "Using RX d'board %s" % (subdev.side_and_name(),) input_rate = u.adc_freq()/u.decim_rate() print "USB sample rate %s" % (eng_notation.num_to_str(input_rate)) if options.gain is None: # if no gain was specified, use the mid-point in dB g = subdev.gain_range() options.gain = float(g[0]+g[1])/2 #TODO setting gain on basicRX only sets the I channel, use a second subdev to set gain of Q channel #see gnuradio-examples/multi-antenna for possible solutions subdev.set_gain(options.gain) #TODO check if freq has same problem as gain when trying to use complex mode on basicRX r = u.tune(0, subdev, options.freq) if not r: sys.stderr.write('Failed to set frequency\n') raise SystemExit, 1 # Connect pipeline src = u if options.nsamples is not None: head = gr.head(gr.sizeof_short, int(options.nsamples)*2) self.connect(u, head) src = head ana_strip = gpio.and_const_ss(0xFFFE) dig_strip = gpio.and_const_ss(0x0001) ana_sink = gr.file_sink(gr.sizeof_short, options.ana_filename) dig_sink = gr.file_sink(gr.sizeof_short, options.dig_filename) self.connect(src, ana_strip, ana_sink) self.connect(src, dig_strip, dig_sink)
def _setup_usrp1(self): self._u = usrp.source_c (self._which, fusb_block_size=self._fusb_block_size, fusb_nblocks=self._fusb_nblocks) # determine the daughterboard subdevice we're using if self._subdev_spec is None: self._subdev_spec = usrp.pick_rx_subdevice(self._u) self._subdev = usrp.selected_subdev(self._u, self._subdev_spec) self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec)) self._dxc = 0
def __init__(self, options, queue): gr.top_block.__init__(self) self.u = usrp.source_c() self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec) print "Using RX d'board %s" % self.subdev.side_and_name() self.u.set_decim_rate(options.decim) self.centerfreq = options.centerfreq print "Tuning to: %fMHz" % (self.centerfreq - options.error) if not(self.tune(options.centerfreq - options.error)): print "Failed to set initial frequency" if options.gain is None: #set to halfway g = self.subdev.gain_range() options.gain = (g[0]+g[1]) / 2.0 print "Setting gain to %i" % options.gain self.subdev.set_gain(options.gain) if self.subdev.name() == "DBS Rx": self.subdev.set_bw(options.bandwidth) #only for DBSRX print "Setting DBS RX bandwidth to %fMHz" % float(options.bandwidth / 1e6) self.rate = self.u.adc_rate() / options.decim print "Samples per second is %i" % self.rate self._syms_per_sec = 3600; options.audiorate = 11025 options.rate = self.rate options.samples_per_second = self.rate #yeah i know it's on the list options.syms_per_sec = self._syms_per_sec options.gain_mu = 0.01 options.mu=0.5 options.omega_relative_limit = 0.3 options.syms_per_sec = self._syms_per_sec options.offset = options.centerfreq - options.freq print "Control channel offset: %f" % options.offset self.demod = fsk_demod(options) self.start_correlator = gr.correlate_access_code_bb("10101100",0) #should mark start of packet self.smartnet_sync = smartnet.sync() self.smartnet_deinterleave = smartnet.deinterleave() self.smartnet_parity = smartnet.parity() self.smartnet_crc = smartnet.crc() self.smartnet_packetize = smartnet.packetize() self.parse = smartnet.parse(queue) #packet-based. this simply posts lightly-formatted messages to the queue. self.connect(self.u, self.demod) self.connect(self.demod, self.start_correlator, self.smartnet_sync, self.smartnet_deinterleave, self.smartnet_parity, self.smartnet_crc, self.smartnet_packetize, self.parse)
def __init__(self, options): gr.hier_block2.__init__(self, "transmit_path", gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0)) #Set up usrp block self.u = usrp.source_c() adc_rate = self.u.adc_rate() # 64 MS/s usrp_decim = 16 gain = 65 self.u.set_decim_rate(usrp_decim) usrp_rate = adc_rate / usrp_decim # 320 kS/s print usrp_rate #subdev_spec = usrp.pick_subdev(self.u) subdev_spec = (0,0) mux_value = usrp.determine_rx_mux_value(self.u, subdev_spec) self.u.set_mux(mux_value) self.subdev = usrp.selected_subdev(self.u, subdev_spec) self.subdev.set_gain(gain) self.subdev.set_auto_tr(False) self.subdev.set_enable(True) if not(self.set_freq(915e6)): print "Failed to set initial frequency" #set up the rest of the path deci = 1 self.agc = gr.agc_cc( rate = 1e-7, reference = 1.0, gain = 0.001, max_gain = 0.5) matchtaps = [complex(-1,-1)] * 8 + [complex(1,1)] * 8 + [complex(-1,-1)]* 8 + [complex(1,1)]* 8 #matchtaps = [complex(-1,-1)] * 8 + [complex(1,1)] * 8 self.matchfilter = gr.fir_filter_ccc(1, matchtaps) reverse = [complex(1,1)] * (8 / deci) + [complex(-1,-1)] * (8 / deci) + [complex(1,1)]* (8 / deci) + [complex(-1,-1)]* (8 / deci) #pretaps = matchtaps * 3 + reverse * 4 + matchtaps * 4 + reverse * 8 + matchtaps * 6 + matchtaps * 62 pretaps = matchtaps * 2 + reverse * 2 + matchtaps * 2 + reverse * 4 + matchtaps * 3 + matchtaps * 31 #pretaps = matchtaps * 3 + reverse * 8 + matchtaps * 6 + matchtaps * 64 self.preamble_filter = gr.fir_filter_ccc(1, pretaps) self.c_f = gr.complex_to_real() self.c_f2 = gr.complex_to_real() self.lock = howto.lock_time(32, 5, 32) self.pd = howto.find_pre_ff(55, 200) self.dec = symbols_decoder() self.vect = gr.vector_sink_f() #self.connect(self.u, self.agc, self.matchfilter, self.c_f, (self.lock, 0), self.dec, self.vect) #self.connect(self.agc, self.preamble_filter, self.c_f2, self.pd, (self.lock, 1)) self.connect(self.u, self.agc, self.matchfilter, self.c_f, self.vect)
def _setup_usrp(self): self._u = usrp.source_c(fpga_filename='usrp_radar_mono.rbf') if self._subdev_spec == None: self._subdev_spec = usrp.pick_rx_subdevice(self._u) self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec)) self._subdev = usrp.selected_subdev(self._u, self._subdev_spec) if self._verbose: print "Using", self._subdev.side_and_name(), "for radar receiver." print "Setting receiver gain to", self._gain self.set_gain(self._gain) self.tune(self._frequency)
def __init__(self): gr.flow_graph.__init__(self) parser = OptionParser (option_class=eng_option) parser.add_option("-R", "--rx-subdev-spec", type="subdev", default='B', help="select USRP Rx side A or B (default=first one with a daughterboard)") parser.add_option ("-c", "--cordic-freq", type="eng_float", default=434845200, help="set rx cordic frequency to FREQ", metavar="FREQ") parser.add_option ("-g", "--gain", type="eng_float", default=0, help="set Rx PGA gain in dB [0,20]") (options, args) = parser.parse_args () print "cordic_freq = %s" % (eng_notation.num_to_str (options.cordic_freq)) # ---------------------------------------------------------------- self.freq = 1000 self.samples_per_symbol = 256 self.usrp_decim = int (64e6 / self.samples_per_symbol / self.freq) self.fs = self.freq * self.samples_per_symbol print "freq = ", eng_notation.num_to_str(self.freq) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) u = usrp.source_s (0, self.usrp_decim) if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(u) u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec)) subdev = usrp.selected_subdev(u, options.rx_subdev_spec) print "Using RX d'board %s" % (subdev.side_and_name(),) u.tune(0, subdev, options.cordic_freq) u.set_pga(0, options.gain) u.set_pga(1, options.gain) self.u = u self.filesink = gr.file_sink(gr.sizeof_float, 'rx_sin.dat') self.stof = gr.short_to_float() filter_coeffs = gr.firdes.low_pass (1.0, # gain self.fs, # sampling rate self.freq, # low pass cutoff freq 0.1*self.freq, # width of trans. band gr.firdes.WIN_HANN) # filter type self.lowpass = gr.fir_filter_fff(1, filter_coeffs) self.connect(self.u, self.stof, self.lowpass, self.filesink)
def _setup_usrp_source(self): self.u = usrp.source_c (fusb_block_size=self._fusb_block_size, fusb_nblocks=self._fusb_nblocks) adc_rate = self.u.adc_rate() self.u.set_decim_rate(self._decim) # determine the daughterboard subdevice we're using if self._rx_subdev_spec is None: self._rx_subdev_spec = usrp.pick_rx_subdevice(self.u) self.subdev = usrp.selected_subdev(self.u, self._rx_subdev_spec) self.u.set_mux(usrp.determine_rx_mux_value(self.u, self._rx_subdev_spec))
def __init__(self, fg, decim=8, rx_subdev_spec=None, width_16=False, verbose=False, gain=None, freq=None): # build the graph" self.u = usrp.source_c(decim_rate=decim, fpga_filename="usrp_std_d2.rbf") if rx_subdev_spec is None: rx_subdev_spec = pick_subdevice(self.u) self.u.set_mux(usrp.determine_rx_mux_value(self.u, rx_subdev_spec)) if not width_16: width = 8 shift = 8 format = self.u.make_format(width, shift) r = self.u.set_format(format) if verbose: print "Bits Per Encoded Sample = 8" else: if verbose: print "Bits Per Encoded Sample = 16" # determine the daughterboard subdevice we're using self.subdev = usrp.selected_subdev(self.u, rx_subdev_spec) if verbose: print "adc frequency = ", self.u.adc_freq() print "decimation frequency = ", self.u.decim_rate() print "input_rate = ", self.u.adc_freq() / self.u.decim_rate() if gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() gain = float(g[0]+g[1])/2 if verbose: print "gain = ", gain if freq is None: # if no freq was specified, use the mid-point r = self.subdev.freq_range() freq = float(r[0]+r[1])/2 self.subdev.set_gain(gain) r = self.u.tune(0, self.subdev, freq) if verbose: print "desired freq = ", freq #print "baseband frequency", r.baseband_freq #print "dxc frequency", r.dxc_freq gr.hier_block.__init__(self, fg, None, self.u)
def __init__(self, options, rx_callback): """ @param options Optparse option field for command line arguments. @param rx_callback Callback function for the event when a packet is received. """ gr.flow_graph.__init__(self) print "cordic_freq = %s" % (eng_notation.num_to_str (options.cordic_freq_rx)) # ---------------------------------------------------------------- self.data_rate = options.data_rate self.samples_per_symbol = 2 self.usrp_decim = int (64e6 / self.samples_per_symbol / self.data_rate) self.fs = self.data_rate * self.samples_per_symbol payload_size = 128 # bytes print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) u = usrp.source_c (0, self.usrp_decim) if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(u) u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(u, options.rx_subdev_spec) print "Using RX d'board %s" % (self.subdev.side_and_name(),) #self.subdev.select_rx_antenna('RX2') u.tune(0, self.subdev, options.cordic_freq_rx) u.set_pga(0, options.gain) u.set_pga(1, options.gain) self.u = u self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts(self, callback=rx_callback, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) #self.file_sink = gr.file_sink(gr.sizeof_gr_complex, "/dev/null") self.connect(self.u, self.squelch, self.packet_receiver) #self.connect(self.u, self.file_sink) self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def __init__(self, options, queue): gr.top_block.__init__(self, "usrp_flex_all") if options.from_file is not None: src = gr.file_source(gr.sizeof_gr_complex, options.from_file) if options.verbose: print "Reading samples from file", options.from_file else: src = usrp.source_c() if options.rx_subdev_spec is None: options.rx_subdev_spec = usrp.pick_rx_subdevice(src) subdev = usrp.selected_subdev(src, options.rx_subdev_spec) src.set_mux(usrp.determine_rx_mux_value(src, options.rx_subdev_spec)) src.set_decim_rate(20) result = usrp.tune(src, 0, subdev, 930.5125e6+options.calibration) if options.verbose: print "Using", subdev.name(), " for receiving." print "Tuned USRP to", 930.5125e6+options.calibration taps = gr.firdes.low_pass(1.0, 1.0, 1.0/128.0*0.4, 1.0/128.0*0.1, gr.firdes.WIN_HANN) if options.verbose: print "Channel filter has", len(taps), "taps" bank = blks2.analysis_filterbank(128, taps) self.connect(src, bank) if options.log and options.from_file == None: src_sink = gr.file_sink(gr.sizeof_gr_complex, 'usrp.dat') self.connect(src, src_sink) for i in range(128): if i < 64: freq = 930.5e6+i*25e3 else: freq = 928.9e6+(i-64)*25e3 if (freq < 929.0e6 or freq > 932.0e6): self.connect((bank, i), gr.null_sink(gr.sizeof_gr_complex)) else: self.connect((bank, i), pager.flex_demod(queue, freq, options.verbose, options.log)) if options.log: self.connect((bank, i), gr.file_sink(gr.sizeof_gr_complex, 'chan_'+'%3.3f'%(freq/1e6)+'.dat'))
def setup_usrp(freq): # Constants interp = 128 decim = 64 # Make USRP instances to TX and RX utx = usrp.sink_c(fpga_filename="local_rssi5.rbf") urx = usrp.source_c(fpga_filename="local_rssi5.rbf") # Set decim and interp rates utx.set_interp_rate(interp) urx.set_decim_rate(decim) # Pick subdevice subdev_spec_tx = usrp.pick_tx_subdevice(utx) subdev_spec_rx = usrp.pick_rx_subdevice(urx) # Set up mux mux_tx = usrp.determine_tx_mux_value(utx, subdev_spec_tx) mux_rx = usrp.determine_rx_mux_value(urx, subdev_spec_rx) utx.set_mux(mux_tx) urx.set_mux(mux_rx) # pick d'board subdev_tx = usrp.selected_subdev(utx, subdev_spec_tx) subdev_rx = usrp.selected_subdev(urx, subdev_spec_rx) print "Using TX d'board %s" %(subdev_tx.side_and_name()) print "Using RX d'board %s" %(subdev_rx.side_and_name()) # Gain subdev_tx.set_gain((subdev_tx.gain_range()[0] + subdev_tx.gain_range()[1]) / 2) subdev_rx.set_gain((subdev_rx.gain_range()[0] + subdev_rx.gain_range()[1]) / 2) # Tune if not utx.tune(subdev_tx._which, subdev_tx, freq): DEBUG( "error tuning TX") if not urx.tune(subdev_rx._which, subdev_rx, freq): DEBUG( "error tuning RX") # Power on subdev_tx.set_enable(True) subdev_rx.set_enable(True) sys.stdout.flush() return utx, urx
def _setup_usrp(self, which, decim, subdev_spec, freq, gain): self._usrp = usrp.source_c(which=which, decim_rate=decim) if subdev_spec is None: subdev_spec = usrp.pick_rx_subdevice(self._usrp) self._subdev = usrp.selected_subdev(self._usrp, subdev_spec) mux = usrp.determine_rx_mux_value(self._usrp, subdev_spec) self._usrp.set_mux(mux) tr = self._usrp.tune(0, self._subdev, freq) if not (tr): print "Failed to tune to center frequency!" else: print "Center frequency:", n2s(freq) if gain is None: g = self._subdev.gain_range(); gain = float(g[0]+g[1])/2.0 self._subdev.set_gain(gain) print "RX d'board:", self._subdev.side_and_name()
def __init__(self): gr.top_block.__init__(self) #build graph now #usrp_source self.usrp = usrp.source_c() adc_rate = self.usrp.adc_rate() #64MHz hw_decim = 16 #so Sample rate into host is 4MHz self.usrp.set_decim_rate(hw_decim) self.subdev = usrp.selected_subdev(self.usrp, usrp.pick_rx_subdevice(self.usrp)) self.usrp.set_mux(usrp.determine_rx_mux_value(self.usrp, usrp.pick_rx_subdevice(self.usrp))) print "Using RX d'board %s" % (self.subdev.side_and_name(),) self.subdev.set_gain(30) rf_freq = 106800000 # 106.8MHz self.set_freq(rf_freq) print "Freq: ", rf_freq self.subdev.select_rx_antenna("TX/RX") #low pass filter self.sample_rate = adc_rate / hw_decim self.lpf_decim = 20 # so after channel filter, the sample rate is 200KHz self.lp_filter = gr.fir_filter_ccf( self.lpf_decim, gr.firdes.low_pass ( 1, self.sample_rate, 100e3, # cut off freq 10e3, # transition band gr.firdes.WIN_BLACKMAN, # Window function 6.76 # not used )) # WBFM receiver quad_rate = self.sample_rate #input rate of demodulator max_dev = 75e3 #max deviation of FM Broadcast fm_demod_gain = quad_rate/(2 * math.pi * max_dev) self.fm_decoder = gr.quadrature_demod_cf (fm_demod_gain) # Rational Resampler self.audio_sample_rate = 96000 self.rational_resampler = blks2.rational_resampler_fff ( interpolation = int(self.audio_sample_rate/1000), decimation = int(self.sample_rate/self.lpf_decim/1000), taps = None, fractional_bw = None, ) self.audio_sink = audio.sink (int(self.audio_sample_rate), "", True) #connections self.connect ( self.usrp, self.lp_filter, self.fm_decoder, self.rational_resampler, self.audio_sink )
def _setup_usrp_source(self): self.u = usrp.source_c (fusb_block_size=self._fusb_block_size, fusb_nblocks=self._fusb_nblocks) adc_rate = self.u.adc_rate() # derive values of bitrate, samples_per_symbol, and decim from desired info (self._bitrate, self._samples_per_symbol, self._decim) = \ pick_rx_bitrate(self._bitrate, self._demod_class.bits_per_symbol(), \ self._samples_per_symbol, self._decim, adc_rate) self.u.set_decim_rate(self._decim) # determine the daughterboard subdevice we're using if self._rx_subdev_spec is None: self._rx_subdev_spec = usrp.pick_rx_subdevice(self.u) self.subdev = usrp.selected_subdev(self.u, self._rx_subdev_spec) self.u.set_mux(usrp.determine_rx_mux_value(self.u, self._rx_subdev_spec))
def setup_usrp(self): options = self.options #set resonable defaults if no user prefs set if options.realtime: if options.fusb_block_size == 0: options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024) if options.fusb_nblocks == 0: options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16) else: if options.fusb_block_size == 0: options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096) if options.fusb_nblocks == 0: options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16) print >> sys.stderr, "fusb_block_size =", options.fusb_block_size print >> sys.stderr, "fusb_nblocks =", options.fusb_nblocks self.ursp = usrp.source_c(decim_rate=options.decim,fusb_block_size=options.fusb_block_size,fusb_nblocks=options.fusb_nblocks) self.ursp.set_fpga_master_clock_freq(options.clock_frequency) if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(self.ursp) self.ursp.set_mux(usrp.determine_rx_mux_value(self.ursp, options.rx_subdev_spec)) # determine the daughterboard subdevice self.subdev = usrp.selected_subdev(self.ursp, options.rx_subdev_spec) input_rate = self.ursp.adc_freq() / self.ursp.decim_rate() if options.antenna is not None: print >> sys.stderr, "USRP antenna %s" % (options.antenna,) self.subdev.select_rx_antenna(options.antenna) # set initial values if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.gain = float(g[0]+g[1])/2 self.set_gain(options.gain) self.source = self.ursp
def __init__(self): gr.hier_block2.__init__(self, "rx_path", gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0)) self.frequency = 13.56e6 self.gain = 10 # USRP settings self.u_rx = usrp.source_c() #create the USRP source for RX #try and set the LF_RX for this rx_subdev_spec = usrp.pick_subdev(self.u_rx, (usrp_dbid.LF_RX, usrp_dbid.LF_TX)) #Configure the MUX for the daughterboard self.u_rx.set_mux(usrp.determine_rx_mux_value(self.u_rx, rx_subdev_spec)) #Tell it to use the LF_RX self.subdev_rx = usrp.selected_subdev(self.u_rx, rx_subdev_spec) #Make sure it worked print "Using RX dboard %s" % (self.subdev_rx.side_and_name(),) #Set gain.. duh self.subdev_rx.set_gain(self.gain) #Tune the center frequency self.u_rx.tune(0, self.subdev_rx, self.frequency) adc_rate = self.u_rx.adc_rate() #64 MS/s usrp_decim = 256 self.u_rx.set_decim_rate(usrp_decim) #BW = 64 MS/s / decim = 64,000,000 / 256 = 250 kHz #Not sure if this decim rate exceeds USRP capabilities, #if it does then some software decim may have to be done as well usrp_rx_rate = adc_rate / usrp_decim self.iir = gr.single_pole_iir_filter_ff(.001) self.mag = gr.complex_to_mag() self.snk = gr.probe_signal_f() # dst = audio.sink (sample_rate, "") # stv = gr.stream_to_vector (gr.sizeof_float, fft_size) # c2m = gr.complex_to_mag_squared (fft_size) self.connect(self.u_rx, self.mag, self.iir, self.snk)
def __init__(self, subdev_spec, decim, gain=None, calibration=0.0): gr.hier_block2.__init__(self, "usrp_src", gr.io_signature(0, 0, 0), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature self._decim = decim self._src = usrp.source_c() if subdev_spec is None: subdev_spec = usrp.pick_rx_subdevice(self._src) self._subdev = usrp.selected_subdev(self._src, subdev_spec) self._src.set_mux(usrp.determine_rx_mux_value(self._src, subdev_spec)) self._src.set_decim_rate(self._decim) # If no gain specified, set to midrange if gain is None: g = self._subdev.gain_range() gain = (g[0]+g[1])/2.0 self._subdev.set_gain(gain) self._cal = calibration self.connect(self._src, self)
def __init__(self, frame, panel, vbox, argv): stdgui.gui_flow_graph.__init__(self) self.frame = frame self.panel = panel parser = OptionParser(option_class=eng_option) parser.add_option( "-R", "--rx-subdev-spec", type="subdev", default=None, help= "select USRP Rx side A or B (default=first one with a daughterboard)" ) parser.add_option( "-d", "--decim", type="int", default=16, help="set fgpa decimation rate to DECIM [default=%default]") parser.add_option("-f", "--freq", type="eng_float", default=None, help="set frequency 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("-W", "--waterfall", action="store_true", default=False, help="Enable waterfall display") parser.add_option("-8", "--width-8", action="store_true", default=False, help="Enable 8-bit samples across USB") parser.add_option("-S", "--oscilloscope", action="store_true", default=False, help="Enable oscilloscope display") parser.add_option("-F", "--filename", default=None, help="Name of file with filter coefficients") parser.add_option("-C", "--cfilename", default=None, help="Name of file with compensator coefficients") parser.add_option("-B", "--bitstream", default="mrfm.rbf", help="Name of FPGA Bitstream file (.rbf)") parser.add_option( "-n", "--frame-decim", type="int", default=20, help="set oscope frame decimation factor to n [default=12]") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) self.show_debug_info = True # default filter coefs b00 = b01 = 16384 b10 = b20 = a10 = a20 = b11 = b21 = a11 = a21 = 0 ba = read_ints(options.filename) if len(ba) >= 6: b00 = ba[0] b10 = ba[1] b20 = ba[2] a10 = ba[4] a20 = ba[5] if len(ba) >= 12: b01 = ba[6] b11 = ba[7] b21 = ba[8] a11 = ba[10] a21 = ba[11] print b00, b10, b20, a10, a20, b01, b11, b21, a11, a21 # default compensator coefficients c11 = c22 = 1 c12 = c21 = cscale = 0 cs = read_ints(options.cfilename) if len(cs) >= 5: c11 = cs[0] c12 = cs[1] c21 = cs[2] c22 = cs[3] cscale = cs[4] print c11, c12, c21, c22, cscale # build the graph self.u = mrfm.source_c(options.bitstream) self.u.set_decim_rate(options.decim) self.u.set_center_freq(options.freq) frac_bits = 14 self.u.set_coeffs(frac_bits, b20, b10, b00, a20, a10, b21, b11, b01, a21, a11) self.u.set_compensator(c11, c12, c21, c22, cscale) if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(self.u) self.u.set_mux( usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec)) if options.width_8: width = 8 shift = 8 format = self.u.make_format(width, shift) print "format =", hex(format) r = self.u.set_format(format) print "set_format =", r # determine the daughterboard subdevice we're using self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec) #input_rate = self.u.adc_freq() / self.u.decim_rate() input_rate = self.u.adc_freq() / options.decim # fft_rate = 15 fft_rate = 5 self.deint = gr.deinterleave(gr.sizeof_gr_complex) self.connect(self.u, self.deint) if options.waterfall: self.scope1 = waterfallsink.waterfall_sink_c( self, panel, fft_size=1024, sample_rate=input_rate, fft_rate=fft_rate) self.scope2 = waterfallsink.waterfall_sink_c( self, panel, fft_size=1024, sample_rate=input_rate, fft_rate=fft_rate) elif options.oscilloscope: self.scope1 = scopesink.scope_sink_c( self, panel, sample_rate=input_rate, frame_decim=options.frame_decim) # added option JPJ 4/21/2006 self.scope2 = scopesink.scope_sink_c( self, panel, sample_rate=input_rate, frame_decim=options.frame_decim) else: self.scope1 = fftsink.fft_sink_c(self, panel, fft_size=1024, sample_rate=input_rate, fft_rate=fft_rate) self.scope2 = fftsink.fft_sink_c(self, panel, fft_size=1024, sample_rate=input_rate, fft_rate=fft_rate) # Show I, I' on top scope panel, Q, Q' on bottom #self.fin = gr.complex_to_float() #self.fout = gr.complex_to_float() #self.connect((self.deint,0), self.fin) #self.connect((self.deint,1), self.fout) #self.ii = gr.float_to_complex() #self.qq = gr.float_to_complex() #self.connect((self.fin,0), (self.ii,0)) #self.connect((self.fout,0), (self.ii,1)) #self.connect((self.fin,1), (self.qq,0)) #self.connect((self.fout,1), (self.qq,1)) #self.connect(self.ii, self.scope1) #self.connect(self.qq, self.scope2) self.connect((self.deint, 0), self.scope1) self.connect((self.deint, 1), self.scope2) self._build_gui(vbox) # set initial values if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.gain = float(g[0] + g[1]) / 2 if options.freq is None: # if no freq was specified, use the mid-point r = self.subdev.freq_range() options.freq = float(r[0] + r[1]) / 2 self.set_gain(options.gain) if not (self.set_freq(options.freq)): self._set_status_msg("Failed to set initial frequency") if self.show_debug_info: self.myform['decim'].set_value(self.u.decim_rate()) self.myform['fs@usb'].set_value(self.u.adc_freq() / self.u.decim_rate()) self.myform['dbname'].set_value(self.subdev.name())
def __init__(self): gr.top_block.__init__(self) amplitude = 30000 filt_out = gr.file_sink(gr.sizeof_gr_complex, "./filt.out") filt2_out = gr.file_sink(gr.sizeof_gr_complex, "./filt2.out") ffilt_out = gr.file_sink(gr.sizeof_float, "./ffilt.out") ffilt2_out = gr.file_sink(gr.sizeof_float, "./ffilt2.out") interp_rate = 128 dec_rate = 8 sw_dec = 4 num_taps = int(64000 / ((dec_rate * 4) * 256)) #Filter matched to 1/4 of the 256 kHz tag cycle taps = [complex(1, 1)] * num_taps matched_filt = gr.fir_filter_ccc(sw_dec, taps) agc = gr.agc2_cc(0.3, 1e-3, 1, 1, 100) to_mag = gr.complex_to_mag() center = rfid.center_ff(4) omega = 2 mu = 0.25 gain_mu = 0.25 gain_omega = .25 * gain_mu * gain_mu omega_relative_limit = .05 mm = gr.clock_recovery_mm_ff(omega, gain_omega, mu, gain_mu, omega_relative_limit) self.reader = rfid.reader_f(int(128e6 / interp_rate)) tag_decoder = rfid.tag_decoder_f() command_gate = rfid.command_gate_cc(12, 60, 64000000 / dec_rate / sw_dec) to_complex = gr.float_to_complex() amp = gr.multiply_const_ff(amplitude) f_sink = gr.file_sink(gr.sizeof_gr_complex, 'f_sink.out') f_sink2 = gr.file_sink(gr.sizeof_gr_complex, 'f_sink2.out') #TX freq = 915e6 rx_gain = 30 tx = usrp.sink_c(fusb_block_size=1024, fusb_nblocks=8) tx.set_interp_rate(interp_rate) tx_subdev = (0, 0) tx.set_mux(usrp.determine_tx_mux_value(tx, tx_subdev)) subdev = usrp.selected_subdev(tx, tx_subdev) subdev.set_enable(True) subdev.set_gain(subdev.gain_range()[2]) t = tx.tune(subdev.which(), subdev, freq) if not t: print "Couldn't set tx freq" #End TX #RX rx = usrp.source_c(0, dec_rate, fusb_block_size=512 * 4, fusb_nblocks=16) rx_subdev_spec = (1, 0) rx.set_mux(usrp.determine_rx_mux_value(rx, rx_subdev_spec)) rx_subdev = usrp.selected_subdev(rx, rx_subdev_spec) rx_subdev.set_gain(rx_gain) rx_subdev.set_auto_tr(False) rx_subdev.set_enable(True) r = usrp.tune(rx, 0, rx_subdev, freq) self.rx = rx if not r: print "Couldn't set rx freq" #End RX command_gate.set_ctrl_out(self.reader.ctrl_q()) tag_decoder.set_ctrl_out(self.reader.ctrl_q()) agc2 = gr.agc2_ff(0.3, 1e-3, 1, 1, 100) #########Build Graph self.connect(rx, matched_filt) self.connect(matched_filt, command_gate) self.connect(command_gate, agc) self.connect(agc, to_mag) self.connect(to_mag, center, agc2, mm, tag_decoder) self.connect(tag_decoder, self.reader, amp, to_complex, tx) ################# self.connect(matched_filt, filt_out)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) parser = OptionParser(option_class=eng_option) parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None, help="select USRP Rx side A or B (default=A)") parser.add_option("-f", "--freq", type="eng_float", default=100.1e6, help="set frequency to FREQ", metavar="FREQ") parser.add_option("-g", "--gain", type="eng_float", default=65, help="set gain in dB (default is midpoint)") parser.add_option("-s", "--squelch", type="eng_float", default=0, help="set squelch level (default is 0)") parser.add_option("-V", "--volume", type="eng_float", default=None, help="set volume (default is midpoint)") parser.add_option( "-O", "--audio-output", type="string", default="", help="pcm device name. E.g., hw:0,0 or surround51 or /dev/dsp") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) self.frame = frame self.panel = panel self.vol = 0 self.state = "FREQ" self.freq = 0 # build graph self.u = usrp.source_c() # usrp is data source adc_rate = self.u.adc_rate() # 64 MS/s usrp_decim = 200 self.u.set_decim_rate(usrp_decim) usrp_rate = adc_rate / usrp_decim # 320 kS/s chanfilt_decim = 1 demod_rate = usrp_rate / chanfilt_decim audio_decimation = 10 audio_rate = 3 * demod_rate / audio_decimation / 2 # 48 kHz if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(self.u) self.u.set_mux( usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec) chan_filt_coeffs = gr.firdes.low_pass_2( 1, # gain usrp_rate, # sampling rate 90e3, # passband cutoff 30e3, # transition bandwidth 70, # stopband attenuation gr.firdes.WIN_BLACKMAN) print len(chan_filt_coeffs) chan_filt = gr.fir_filter_ccf(chanfilt_decim, chan_filt_coeffs) self.rchan_sample = blks2.rational_resampler_fff(3, 2) self.lchan_sample = blks2.rational_resampler_fff(3, 2) #self.guts = blks2.wfm_rcv (demod_rate, audio_decimation) self.guts = blks2.wfm_rcv_pll(demod_rate, audio_decimation) # FIXME rework {add,multiply}_const_* to handle multiple streams self.volume_control_l = gr.multiply_const_ff(self.vol) self.volume_control_r = gr.multiply_const_ff(self.vol) # sound card as final sink audio_sink = audio.sink(int(audio_rate), options.audio_output, False) # ok_to_block # now wire it all together self.connect(self.u, chan_filt, self.guts) self.connect((self.guts, 0), self.lchan_sample, self.volume_control_l, (audio_sink, 0)) self.connect((self.guts, 1), self.rchan_sample, self.volume_control_r, (audio_sink, 1)) try: self.guts.stereo_carrier_pll_recovery.squelch_enable(True) except: print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet" self._build_gui(vbox, usrp_rate, demod_rate, audio_rate) if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.gain = float(g[0] + g[1]) / 2 if options.volume is None: g = self.volume_range() options.volume = float(g[0] + g[1]) / 2 if abs(options.freq) < 1e6: options.freq *= 1e6 # set initial values self.set_gain(options.gain) self.set_vol(options.volume) try: self.guts.stereo_carrier_pll_recovery.set_lock_threshold( options.squelch) except: print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet" if not (self.set_freq(options.freq)): self._set_status_msg("Failed to set initial frequency")
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-f", "--freq", type="eng_float", default=206352000, help="Carrier frequency [default=%default]") parser.add_option("-g", "--gain", type="eng_float", default=8, help="USRP gain (dB) [default=%default]") parser.add_option( "-n", "--config", type="string", default="channel.conf", help="DAB+ channel configuration file [default=%default]") (options, args) = parser.parse_args() if len(args) > 0: parser.print_help() raise SystemExit, 1 self.conf = options.config ######## set up usrp self.u = usrp.source_c(decim_rate=32) # 2M sampling freq rx_subdev_spec = usrp.pick_rx_subdevice(self.u) #print "u.db(0,0).dbid() = ", self.u.db(0,0).dbid() #print "u.db(1,0).dbid() = ", self.u.db(1,0).dbid() #print "rx_subdev_spec = ", options.rx_subdev_spec mux = usrp.determine_rx_mux_value(self.u, rx_subdev_spec) #print "mux = ", mux self.u.set_mux(mux) # determine the daughterboard subdevice we're using self.subdev = usrp.selected_subdev(self.u, rx_subdev_spec) #print "Using RX d'board %s" % (self.subdev.side_and_name(),) input_rate = self.u.adc_freq() / self.u.decim_rate() #print "ADC sampling @ ", eng_notation.num_to_str(self.u.adc_freq()) #print "USB sample rate %s" % (eng_notation.num_to_str(input_rate)) self.subdev.set_gain(options.gain) r = self.u.tune(0, self.subdev, options.freq) #print "freq range = [%s, %s]" % (eng_notation.num_to_str(self.subdev.freq_min()), eng_notation.num_to_str(self.subdev.freq_max())) if not r: sys.stderr.write('Failed to set frequency\n') raise SystemExit, 1 mode = options.dab_mode param = dabp.parameters(mode) # null symbol detector samples_per_null_sym = param.get_Nnull() #print "samples per null symbol : %d" % samples_per_null_sym nulldet = dabp.detect_null(samples_per_null_sym) # ofdm demod demod = dabp.ofdm_demod(mode) # FIC/MSC demultiplexer demux = dabp.fic_msc_demux(0, mode) # depuncturer punc = dabp.depuncturer_fic(mode) I = punc.getI() # viterbi vit = dabp.vitdec(I) # descrambler scram = dabp.scrambler(I) # FIB sink self.dst = dabp.fib_sink() nullsink = gr.null_sink(gr.sizeof_char) # connect everything self.connect(self.u, nulldet) self.connect(self.u, (demod, 0)) self.connect(nulldet, (demod, 1)) self.connect((demod, 0), demux, punc, vit, scram, self.dst) self.connect((demod, 1), nullsink)
def __init__(self): gr.top_block.__init__(self) parser=OptionParser(option_class=eng_option) parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None, help="select USRP Rx side A or B (default=A)") parser.add_option("-f", "--freq", type="eng_float", default=100.1e6, help="set frequency 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="", help="pcm device name. E.g., hw:0,0 or surround51 or /dev/dsp") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) self.vol = .1 self.state = "FREQ" self.freq = 0 # build graph self.u = usrp.source_c() # usrp is data source adc_rate = self.u.adc_rate() # 64 MS/s usrp_decim = 200 self.u.set_decim_rate(usrp_decim) usrp_rate = adc_rate / usrp_decim # 320 kS/s chanfilt_decim = 1 demod_rate = usrp_rate / chanfilt_decim audio_decimation = 10 audio_rate = demod_rate / audio_decimation # 32 kHz if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(self.u) self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec) print "Using RX d'board %s" % (self.subdev.side_and_name(),) chan_filt_coeffs = optfir.low_pass (1, # gain usrp_rate, # sampling rate 80e3, # passband cutoff 115e3, # stopband cutoff 0.1, # passband ripple 60) # stopband attenuation #print len(chan_filt_coeffs) chan_filt = gr.fir_filter_ccf (chanfilt_decim, chan_filt_coeffs) self.guts = blks2.wfm_rcv (demod_rate, audio_decimation) self.volume_control = gr.multiply_const_ff(self.vol) # sound card as final sink audio_sink = audio.sink(int(audio_rate), options.audio_output, False) # ok_to_block # now wire it all together self.connect (self.u, chan_filt, self.guts, self.volume_control, audio_sink) if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.gain = float(g[0]+g[1])/2 if abs(options.freq) < 1e6: options.freq *= 1e6 # set initial values self.set_gain(options.gain) if not(self.set_freq(options.freq)): self._set_status_msg("Failed to set initial frequency")
def main(): parser = OptionParser(option_class=eng_option) parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None, help="select USRP Rx side A or B (default=A)") parser.add_option("-f", "--freq", type="eng_float", default=144.800e6, help="set frequency 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("-d", "--do-logging", action="store_true", default=False, help="enable logging on datafiles") parser.add_option("-s", "--use-datafile", action="store_true", default=False, help="use usrp.dat (256kbps) as input") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) markfreq = 2200 spacefreq = 1200 bitrate = 1200 usrp_decim = 250 if_rate = 64e6 / usrp_decim #256e3 sf = (if_rate * 3) / 5 #153600 bit_oversampling = 8 sw_decim = int(sf / bitrate / bit_oversampling) #8 bf = sf / sw_decim symdev = abs(markfreq - spacefreq) / 2 symcf = min(markfreq, spacefreq) + symdev nbfmdev = 3e3 nbfmk = if_rate / (2 * pi * nbfmdev) symk = bf / (2 * pi * symdev) fg = gr.flow_graph() if options.do_logging: logger1 = gr.file_sink(gr.sizeof_gr_complex, "usrpout.dat") logger2 = gr.file_sink(gr.sizeof_float, "demod.dat") logger3 = gr.file_sink(gr.sizeof_float, "clkrec.dat") logger4 = gr.file_sink(gr.sizeof_char, "slicer.dat") if options.use_datafile: src = gr.file_source(gr.sizeof_gr_complex, "usrp.dat") else: u = usrp.source_c() u.set_decim_rate(usrp_decim) if options.rx_subdev_spec is None: subdev_spec = usrp.pick_rx_subdevice(u) else: subdev_spec = options.rx_subdev_spec subdev = usrp.selected_subdev(u, subdev_spec) print "Using RX d'board %s" % (subdev.side_and_name(), ) u.set_mux(usrp.determine_rx_mux_value(u, subdev_spec)) print "MUX:%x" % (usrp.determine_rx_mux_value(u, subdev_spec)) if options.gain is None: g = subdev.gain_range() gain = float(g[0] + g[1]) / 2 else: gain = options.gain subdev.set_gain(gain) print "Gain set to", str(gain) r = usrp.tune(u, 0, subdev, options.freq) if r: print "Frequency set to", options.freq else: print "Frequency set to", options.freq, "failed" src = u chan_taps = gr.firdes.low_pass(1, if_rate, 13e3, 4e3, gr.firdes.WIN_HANN) chan = gr.fir_filter_ccf(1, chan_taps) #256e3 dee = blks.fm_deemph(fg, if_rate, 75e-6) fmdem = gr.quadrature_demod_cf(nbfmk) res_taps = blks.design_filter(3, 5, 0.4) res = blks.rational_resampler_fff(fg, 3, 5, res_taps) #153600 lo = gr.sig_source_c(sf, gr.GR_SIN_WAVE, -symcf, 1) mix = gr.multiply_cc() r2c = gr.float_to_complex() lp_taps = gr.firdes.low_pass(sw_decim, sf, 600, 2e3, gr.firdes.WIN_HANN) lp = gr.fir_filter_ccf(sw_decim, lp_taps) dem = gr.quadrature_demod_cf(symk) alpha = 0.0001 freqoff = gr.single_pole_iir_filter_ff(alpha) sub = gr.sub_ff() _def_gain_mu = 0.05 _def_mu = 0.5 _def_freq_error = 0.00 _def_omega_relative_limit = 0.005 _omega = bit_oversampling * (1 + _def_freq_error) _gain_omega = .25 * _def_gain_mu * _def_gain_mu clkrec = gr.clock_recovery_mm_ff(_omega, _gain_omega, _def_mu, _def_gain_mu, _def_omega_relative_limit) slicer = gr.binary_slicer_fb() pktq = gr.msg_queue() sink = packetradio.hdlc_framer(pktq, 0) watcher = queue_watcher_thread(pktq, rx_callback) fg.connect(src, chan, fmdem, dee, res, r2c, (mix, 0)) fg.connect(lo, (mix, 1)) fg.connect(mix, lp, dem) fg.connect(dem, (sub, 0)) fg.connect(dem, freqoff, (sub, 1)) fg.connect(sub, clkrec, slicer) fg.connect(slicer, sink) if options.do_logging: fg.connect(src, logger1) fg.connect(sub, logger2) fg.connect(clkrec, logger3) fg.connect(slicer, logger4) fg.start() fg.wait()
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) parser = OptionParser(option_class=eng_option) parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None, help="select USRP Rx side A or B (default=A)") parser.add_option("-f", "--freq", type="eng_float", default=1008.0e3, help="set frequency to FREQ", metavar="FREQ") parser.add_option( "-I", "--use-if-freq", action="store_true", default=False, help= "use intermediate freq (compensates DC problems in quadrature boards)" ) parser.add_option("-g", "--gain", type="eng_float", default=None, help="set gain in dB (default is maximum)") parser.add_option("-V", "--volume", type="eng_float", default=None, help="set volume (default is midpoint)") parser.add_option( "-O", "--audio-output", type="string", default="", help="pcm device name. E.g., hw:0,0 or surround51 or /dev/dsp") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) self.frame = frame self.panel = panel self.use_IF = options.use_if_freq if self.use_IF: self.IF_freq = 64000.0 else: self.IF_freq = 0.0 self.vol = 0 self.state = "FREQ" self.freq = 0 # build graph #TODO: add an AGC after the channel filter and before the AM_demod self.u = usrp.source_c() # usrp is data source adc_rate = self.u.adc_rate() # 64 MS/s usrp_decim = 250 self.u.set_decim_rate(usrp_decim) usrp_rate = adc_rate / usrp_decim # 256 kS/s chanfilt_decim = 4 demod_rate = usrp_rate / chanfilt_decim # 64 kHz audio_decimation = 2 audio_rate = demod_rate / audio_decimation # 32 kHz if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(self.u) self.u.set_mux( usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec) print "Using RX d'board %s" % (self.subdev.side_and_name(), ) chan_filt_coeffs = optfir.low_pass( 1, # gain usrp_rate, # sampling rate 8e3, # passband cutoff 12e3, # stopband cutoff 1.0, # passband ripple 60) # stopband attenuation #print len(chan_filt_coeffs) self.chan_filt = gr.fir_filter_ccf(chanfilt_decim, chan_filt_coeffs) if self.use_IF: # Turn If to baseband and filter. self.chan_filt = gr.freq_xlating_fir_filter_ccf( chanfilt_decim, chan_filt_coeffs, self.IF_freq, usrp_rate) else: self.chan_filt = gr.fir_filter_ccf(chanfilt_decim, chan_filt_coeffs) self.am_demod = gr.complex_to_mag() self.volume_control = gr.multiply_const_ff(self.vol) audio_filt_coeffs = optfir.low_pass( 1, # gain demod_rate, # sampling rate 8e3, # passband cutoff 10e3, # stopband cutoff 0.1, # passband ripple 60) # stopband attenuation self.audio_filt = gr.fir_filter_fff(audio_decimation, audio_filt_coeffs) # sound card as final sink audio_sink = audio.sink(int(audio_rate), options.audio_output, False) # ok_to_block # now wire it all together self.connect(self.u, self.chan_filt, self.am_demod, self.audio_filt, self.volume_control, audio_sink) self._build_gui(vbox, usrp_rate, demod_rate, audio_rate) if options.gain is None: g = self.subdev.gain_range() if True: # if no gain was specified, use the maximum gain available # (usefull for Basic_RX which is relatively deaf and the most probable board to be used for AM) # TODO: check db type to decide on default gain. options.gain = float(g[1]) else: # if no gain was specified, use the mid-point in dB options.gain = float(g[0] + g[1]) / 2 if options.volume is None: g = self.volume_range() options.volume = float(g[0] * 3 + g[1]) / 4 if abs(options.freq) < 1e3: options.freq *= 1e3 # set initial values self.set_gain(options.gain) self.set_vol(options.volume) if not (self.set_freq(options.freq)): self._set_status_msg("Failed to set initial frequency")
def __init__(self): gr.top_block.__init__(self) amplitude = 5000 interp_rate = 256 dec_rate = 16 sw_dec = 5 num_taps = int(64000 / ( (dec_rate * 4) * 40 )) #Filter matched to 1/4 of the 40 kHz tag cycle taps = [complex(1,1)] * num_taps matched_filt = gr.fir_filter_ccc(sw_dec, taps); agc = gr.agc2_cc(0.3, 1e-3, 1, 1, 100) to_mag = gr.complex_to_mag() center = rfid.center_ff(10) omega = 5 mu = 0.25 gain_mu = 0.25 gain_omega = .25 * gain_mu * gain_mu omega_relative_limit = .05 mm = gr.clock_recovery_mm_ff(omega, gain_omega, mu, gain_mu, omega_relative_limit) self.reader = rfid.reader_f(int(128e6/interp_rate)); tag_decoder = rfid.tag_decoder_f() command_gate = rfid.command_gate_cc(12, 250, 64000000 / dec_rate / sw_dec) to_complex = gr.float_to_complex() amp = gr.multiply_const_ff(amplitude) #output the TX and RX signals only f_txout = gr.file_sink(gr.sizeof_gr_complex, 'f_txout.out'); f_rxout = gr.file_sink(gr.sizeof_gr_complex, 'f_rxout.out'); #TX # working frequency at 915 MHz by default and RX Gain of 20 freq = options.center_freq #915e6 rx_gain = options.rx_gain #20 tx = usrp.sink_c(fusb_block_size = 512, fusb_nblocks=4) tx.set_interp_rate(256) tx_subdev = (0,0) tx.set_mux(usrp.determine_tx_mux_value(tx, tx_subdev)) subdev = usrp.selected_subdev(tx, tx_subdev) subdev.set_enable(True) subdev.set_gain(subdev.gain_range()[2]) t = tx.tune(subdev.which(), subdev, freq) if not t: print "Couldn't set tx freq" #End TX #RX rx = usrp.source_c(0, dec_rate, fusb_block_size = 512, fusb_nblocks = 4) rx_subdev_spec = (1,0) rx.set_mux(usrp.determine_rx_mux_value(rx, rx_subdev_spec)) rx_subdev = usrp.selected_subdev(rx, rx_subdev_spec) rx_subdev.set_gain(rx_gain) rx_subdev.set_auto_tr(False) rx_subdev.set_enable(True) r = usrp.tune(rx, 0, rx_subdev, freq) self.rx = rx if not r: print "Couldn't set rx freq" #End RX command_gate.set_ctrl_out(self.reader.ctrl_q()) tag_decoder.set_ctrl_out(self.reader.ctrl_q()) #########Build Graph self.connect(rx, matched_filt) self.connect(matched_filt, command_gate) self.connect(command_gate, agc) self.connect(agc, to_mag) self.connect(to_mag, center, mm, tag_decoder) self.connect(tag_decoder, self.reader, amp, to_complex, tx); ################# #Output dumps for debug self.connect(rx, f_rxout); self.connect(to_complex, f_txout);
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None, help="select USRP Rx side A or B (default=A)") 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=40, help="set gain in dB (default is midpoint)") parser.add_option( "-O", "--audio-output", type="string", default="", help="pcm device name. E.g., hw:0,0 or surround51 or /dev/dsp") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) if abs(options.f1) < 1e6: options.f1 *= 1e6 if abs(options.f2) < 1e6: options.f2 *= 1e6 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" # build graph self.u = usrp.source_c(0, nchan=2) # usrp is data source adc_rate = self.u.adc_rate() # 64 MS/s usrp_decim = 200 self.u.set_decim_rate(usrp_decim) usrp_rate = adc_rate / usrp_decim # 320 kS/s chanfilt_decim = 1 demod_rate = usrp_rate / chanfilt_decim audio_decimation = 10 audio_rate = demod_rate / audio_decimation # 32 kHz if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(self.u) mv = usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec) mv |= (mv << 8) & 0xff00 # both DDC inputs setup same way self.u.set_mux(mv) self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec) print "Using RX d'board %s" % (self.subdev.side_and_name(), ) # deinterleave two channels from FPGA di = gr.deinterleave(gr.sizeof_gr_complex) # wire up the head of the chain self.connect(self.u, di) # sound card as final sink audio_sink = audio.sink(int(audio_rate), options.audio_output) # taps for channel filter chan_filt_coeffs = optfir.low_pass( 1, # gain usrp_rate, # sampling rate 80e3, # passband cutoff 115e3, # stopband cutoff 0.1, # passband ripple 60) # stopband attenuation #print len(chan_filt_coeffs) mid_freq = (f[0] + f[1]) / 2 # set front end PLL to middle frequency tune_result = self.subdev.set_freq(mid_freq) for n in range(2): chan_filt = gr.fir_filter_ccf(chanfilt_decim, chan_filt_coeffs) guts = blks2.wfm_rcv(demod_rate, audio_decimation) volume_control = gr.multiply_const_ff(self.vol) self.connect((di, n), chan_filt) self.connect(chan_filt, guts, volume_control) self.connect(volume_control, (audio_sink, n)) dxc_freq, inverted = calc_dxc_freq(f[n], tune_result.baseband_freq, self.u.converter_rate()) self.u.set_rx_freq(n, dxc_freq) if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.gain = float(g[0] + g[1]) / 2 # set initial values self.set_gain(options.gain)
def __init__(self, options): gr.top_block.__init__(self) fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096) fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16) self._u = usrp.source_c(decim_rate=options.decim, fusb_block_size=fusb_block_size, fusb_nblocks=fusb_nblocks) # master clock if options.fpga_freq is not None: self._u.set_fpga_master_clock_freq(long(options.fpga_freq)) # default subdev if use didn't pick one if options.rx_subdev_spec is None: if u.db(0, 0).dbid() >= 0: options.rx_subdev_spec = (0, 0) elif u.db(1, 0).dbid() >= 0: options.rx_subdev_spec = (1, 0) else: options.rx_subdev_spec = (0, 0) # configure usrp mux self._u.set_mux( usrp.determine_rx_mux_value(self._u, options.rx_subdev_spec)) # determine the daughterboard subdevice self.subdev = usrp.selected_subdev(self._u, options.rx_subdev_spec) # select antenna if options.antenna is not None: print "Selecting antenna %s" % (options.antenna, ) self.subdev.select_rx_antenna(options.antenna) # set initial values if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.gain = float(g[0] + g[1]) / 2 r = self._u.tune(0, self.subdev, options.freq) self.subdev.set_gain(options.gain) #sample_rate = options.fpga_clock/options.decim sample_rate = self._u.adc_freq() / self._u.decim_rate() symbol_rate = 18000 sps = 2 # output rate will be 36,000 ntaps = 11 * sps new_sample_rate = symbol_rate * sps channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, gr.firdes.WIN_HANN) FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps, options.calibration, sample_rate) sys.stderr.write("sample rate: %d\n" % (sample_rate)) DEMOD = cqpsk.cqpsk_demod(samples_per_symbol=sps, excess_bw=0.35, costas_alpha=0.03, gain_mu=0.05, mu=0.05, omega_relative_limit=0.05, log=options.log, verbose=options.verbose) OUT = gr.file_sink(gr.sizeof_float, options.output_file) r = float(sample_rate) / float(new_sample_rate) INTERPOLATOR = gr.fractional_interpolator_cc(0, r) self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)