def __init__( self, block, *args, **kwds ): ui_frame.__init__( self, *args, **kwds ) self.block = block self.freq_disp.SetRange(0, 30e6) f = self.block.src.freq self.freq_disp.SetValue( -f ) self.volume.SetRange( 0, 20 ) self.pga.SetRange( 0, 20 ) self.rssi_range = 1 self.rssi.SetRange( self.rssi_range ) self.agc_max.SetValue( str( self.rssi_range ) ) self.spin_e0.SetValue( 50 ) self.spin_e1.SetValue( 50 ) self.spin_e2.SetValue( 50 ) self.spin_e3.SetValue( 50 ) self.spin_e4.SetValue( 50 ) self.spin_e5.SetValue( 50 ) self.spin_e6.SetValue( 50 ) bw = 3.3e3 self.bandwidth.SetValue( str( bw ) ) self.block.demod.set_bw( bw ) self.bw_spin.SetValue( 5 ) agc_gain = self.block.agc.gain.k() self.agc_gain_s.SetValue( 5 ) self.agc_gain.SetValue( str( agc_gain ) ) agc_ref = self.block.agc.offs.k() self.agc_ref.SetValue( str( agc_ref ) ) self.agc_ref_s.SetValue( 5 ) self.fespectrum = fftsink.fft_sink_c( self.block.graph, self.fe_panel, fft_size=512, sample_rate = block.fe_rate, baseband_freq = 0, average = False, size = ( 680, 140 ) ) self.ifspectrum = fftsink.fft_sink_c( self.block.graph, self.if_panel, fft_size=512, sample_rate = block.audio_rate, baseband_freq = 0, average = False, size = ( 680, 140 ) ) em.eventManager.Register( self.fe_mouse, wx.EVT_MOTION, self.fespectrum.win ) em.eventManager.Register( self.fe_click, wx.EVT_LEFT_DOWN, self.fespectrum.win ) block.graph.connect( block.src.src, self.fespectrum ) block.graph.connect( block.demod.xlate, self.ifspectrum )
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, 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 SMINI 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( smini.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 = smini.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, parent, ID, title): wxFrame.__init__(self, parent, ID, title, wxDefaultPosition) self.pga = 0 self.pgaMin = -20 self.pgaMax = 0 self.pgaStep = 0.25 # Parsing options parser = OptionParser(option_class=eng_option, usage="usage: %prog [options] filename1" \ " [-f frequency2 filename2 [...]]") parser.add_option("-a", "--agc", action="store_true", help="enable agc") parser.add_option("-c", "--clockrate", type="eng_float", default=128e6, help="set USRP clock rate (128e6)") parser.add_option("--copy", action="store_true", help="enable real to imag data copy when in real mode") parser.add_option("-e", "--encoding", type="choice", choices=["s", "f"], default="f", help="choose data encoding: [s]igned or [f]loat.") parser.add_option("-f", "--frequency", type="eng_float", action="callback", callback=appendFrequency, help="set output frequency (222.064e6)") parser.add_option("-g", "--gain", type="float", help="set output pga gain") parser.add_option("-l", "--list", action="callback", callback=listUsrp, help="list USRPs and daugtherboards") parser.add_option("-m", "--mode", type="eng_float", default=2, help="mode: 1: real, 2: complex (2)") parser.add_option("-o", "--osc", action="store_true", help="enable oscilloscope") parser.add_option("-r", "--samplingrate", type="eng_float", default=3.2e6, help="set input sampling rate (3200000)") parser.add_option("-s", "--spectrum", action="store_true", help="enable spectrum analyzer") # parser.add_option("-t", "--tx", type="choice", choices=["A", "B"], # default="A", help="choose USRP tx A|B output (A)") parser.add_option("-u", "--usrp", action="store_true", help="enable USRP output") (options, args) = parser.parse_args() if len(args) == 0 : options.filename = [ "/dev/stdin" ] else : options.filename = args # Setting default frequency if options.frequency is None : options.frequency = [ 222.064e6 ] if len(options.filename) != len(options.frequency) : parser.error("Nb input file != nb frequency!") # Status bar # self.CreateStatusBar(3, 0) # msg = "PGA: %.2f dB" % (self.pga * self.pgaStep) # self.SetStatusText(msg, 1) # msg = "Freq: %.3f mHz" % (options.frequency[0] / 1000000.0) # self.SetStatusText(msg, 2) # Menu bar menu = wxMenu() menu.Append(ID_ABOUT, "&About", "More information about this program") menu.AppendSeparator() menu.Append(ID_EXIT, "E&xit", "Terminate the program") menuBar = wxMenuBar() menuBar.Append(menu, "&File") self.SetMenuBar(menuBar) # Main windows mainSizer = wxFlexGridSizer(0, 1) sliderSizer = wxFlexGridSizer(0, 2) buttonSizer = wxBoxSizer(wxHORIZONTAL) if options.usrp : # TX d'board 0 gainLabel = wxStaticText(self, -1, "PGA 0") gainSlider = wxSlider(self, ID_GAIN_SLIDER0, self.pga, self.pgaMin / self.pgaStep, self.pgaMax / self.pgaStep, style = wxSL_HORIZONTAL | wxSL_AUTOTICKS) gainSlider.SetSize((400, -1)) sliderSizer.Add(gainLabel, 0, wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0) sliderSizer.Add(gainSlider, 0, wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0) freqLabel = wxStaticText(self, -1, "Frequency 0") freqSlider = wxSlider(self, ID_FREQ_SLIDER0, options.frequency[0] / 16000, 0, 20e3, style = wxSL_HORIZONTAL | wxSL_AUTOTICKS) freqSlider.SetSize((400, -1)) sliderSizer.Add(freqLabel, 0, wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0) sliderSizer.Add(freqSlider, 0, wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0) if len(options.frequency) > 1 : # TX d'board 1 gainLabel = wxStaticText(self, -1, "PGA 1") gainSlider = wxSlider(self, ID_GAIN_SLIDER1, self.pga, self.pgaMin / self.pgaStep, self.pgaMax / self.pgaStep, style = wxSL_HORIZONTAL | wxSL_AUTOTICKS) gainSlider.SetSize((400, -1)) sliderSizer.Add(gainLabel, 0, wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0) sliderSizer.Add(gainSlider, 0, wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0) freqLabel = wxStaticText(self, -1, "Frequency 1") freqSlider = wxSlider(self, ID_FREQ_SLIDER1, options.frequency[1] / 16000, 0, 20e3, style = wxSL_HORIZONTAL | wxSL_AUTOTICKS) freqSlider.SetSize((400, -1)) sliderSizer.Add(freqLabel, 0, wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0) sliderSizer.Add(freqSlider, 0, wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0) mainSizer.Add(sliderSizer, 1, wxEXPAND, 0) start = wxButton(self, ID_START, "Start") stop = wxButton(self, ID_STOP, "Stop") buttonSizer.Add(start, 1, wxALIGN_CENTER, 0) buttonSizer.Add(stop, 1, wxALIGN_CENTER, 0) mainSizer.Add(buttonSizer, 1, wxEXPAND, 0) # GnuRadio self.fg = gr.flow_graph() if options.mode == 1 : print "Source: real" if (options.encoding == "s") : print "Source encoding: short" src = gr.file_source(gr.sizeof_short, options.filename[0], 1) if (options.copy) : print "Imag: copy" imag = src else : print "Imag: null" imag = gr.null_source(gr.sizeof_short) interleaver = gr.interleave(gr.sizeof_short) self.fg.connect(src, (interleaver, 0)) self.fg.connect(imag, (interleaver, 1)) tail = interleaver elif (options.encoding == "f") : print "Source encoding: float" src = gr.file_source(gr.sizeof_gr_complex, options.filename[0], 1) tail = src elif (options.mode == 2) : print "Source: complex" if len(options.frequency) == 1 : if (options.encoding == "s") : print "Source encoding: short" src = gr.file_source(gr.sizeof_short, options.filename[0], 1) elif (options.encoding == "f") : print "Source encoding: float" src = gr.file_source(gr.sizeof_gr_complex, options.filename[0], 1) else : parser.error("Invalid encoding type for complex data!") tail = src elif (len(options.frequency) == 2) : src0 = gr.file_source(gr.sizeof_gr_complex, options.filename[0], 1) src1 = gr.file_source(gr.sizeof_gr_complex, options.filename[1], 1) interleaver = gr.interleave(gr.sizeof_gr_complex) self.fg.connect(src0, (interleaver, 0)) self.fg.connect(src1, (interleaver, 1)) tail = interleaver else : parser.error( "Invalid number of source (> 2) with complex input!") else : parser.error("Invalid mode!") # Interpolation dac_freq = options.clockrate interp = int(dac_freq / options.samplingrate) if interp == 0 : parser.error("Invalid sampling rate!") if options.mode == 2 : print "Input sampling rate: %s complex samples/s" % \ num_to_str(options.samplingrate) else : print "Input sampling rate: %s samples/s" % \ num_to_str(options.samplingrate) print "Interpolation rate: int(%s / %s) = %sx" % \ (num_to_str(dac_freq), num_to_str(options.samplingrate), interp) if interp > 512 : factor = gcd(dac_freq / 512, options.samplingrate) num = int((dac_freq / 512) / factor) den = int(options.samplingrate / factor) print "Resampling by %i / %i" % (num, den) resampler = blks.rational_resampler_ccc(self.fg, num, den) self.fg.connect(tail, resampler) tail = resampler interp = 512 options.samplingrate = dac_freq / 512 # AGC if options.agc : agc = gr.agc_cc() self.fg.connect(tail, agc) tail = agc # USRP if options.usrp : nchan = len(options.frequency) if len(options.frequency) == 1 : if options.mode == 1 : mux = 0x00000098 elif options.mode == 2 : mux = 0x00000098 else : parser.error("Unsupported mode for USRP mux!") elif len(options.frequency) == 2 : if options.mode == 1 : mux = 0x0000ba98 elif options.mode == 2 : mux = 0x0000ba98 else : parser.error("Unsupported mode for USRP mux!") else : parser.error("Invalid number of frequency [0..2]!") # if options.tx == "A" : # mux = 0x00000098 # else : # mux = 0x00009800 print "Nb channels: ", nchan print "Mux: 0x%x" % mux if options.encoding == 's' : dst = usrp.sink_s(0, interp, nchan, mux) elif options.encoding == 'f' : dst = usrp.sink_c(0, interp, nchan, mux) else : parser.error("Unsupported data encoding for USRP!") dst.set_verbose(1) for i in range(len(options.frequency)) : if options.gain is None : print "Setting gain to %f" % dst.pga_max() dst.set_pga(i << 1, dst.pga_max()) else : print "Setting gain to %f" % options.gain dst.set_pga(i << 1, options.gain) tune = false for dboard in dst.db: if (dboard[0].dbid() != -1): device = dboard[0] print "Tuning TX d'board %s to %sHz" % \ (device.side_and_name(), num_to_str(options.frequency[i])) device.lo_offset = 38e6 (min, max, offset) = device.freq_range() print " Frequency" print " Min: %sHz" % num_to_str(min) print " Max: %sHz" % num_to_str(max) print " Offset: %sHz" % num_to_str(offset) #device.set_gain(device.gain_range()[1]) device.set_enable(True) tune = \ dst.tune(device._which, device, options.frequency[i] * 128e6 / dac_freq) if tune: print " Baseband frequency: %sHz" % \ num_to_str(tune.baseband_freq) print " DXC frequency: %sHz" % \ num_to_str(tune.dxc_freq) print " Residual Freqency: %sHz" % \ num_to_str(tune.residual_freq) print " Inverted: ", \ tune.inverted mux = usrp.determine_tx_mux_value(dst, (device._which, 0)) dst.set_mux(mux) break else: print " Failed!" if not tune: print " Failed!" raise SystemExit # int nunderruns () print "USRP" print " Rx halfband: ", dst.has_rx_halfband() print " Tx halfband: ", dst.has_tx_halfband() print " Nb DDC: ", dst.nddc() print " Nb DUC: ", dst.nduc() #dst._write_9862(0, 14, 224) print " DAC frequency: %s samples/s" % num_to_str(dst.dac_freq()) print " Fpga decimation rate: %s -> %s samples/s" % \ (num_to_str(dst.interp_rate()), num_to_str(dac_freq / dst.interp_rate())) print " Nb channels:", if hasattr(dst, "nchannels()") : print dst.nchannels() else: print "N/A" print " Mux:", if hasattr(dst, "mux()") : print "0x%x" % dst.mux() else : print "N/A" print " FPGA master clock frequency:", if hasattr(dst, "fpga_master_clock_freq()") : print "%sHz" % num_to_str(dst.fpga_master_clock_freq()) else : print "N/A" print " Converter rate:", if hasattr(dst, "converter_rate()") : print "%s" % num_to_str(dst.converter_rate()) else : print "N/A" print " DAC rate:", if hasattr(dst, "dac_rate()") : print "%s sample/s" % num_to_str(dst.dac_rate()) else : print "N/A" print " Interp rate: %sx" % num_to_str(dst.interp_rate()) print " DUC frequency 0: %sHz" % num_to_str(dst.tx_freq(0)) print " DUC frequency 1: %sHz" % num_to_str(dst.tx_freq(1)) print " Programmable Gain Amplifier 0: %s dB" % \ num_to_str(dst.pga(0)) print " Programmable Gain Amplifier 1: %s dB" % \ num_to_str(dst.pga(2)) else : dst = gr.null_sink(gr.sizeof_gr_complex) # AGC if options.agc : agc = gr.agc_cc() self.fg.connect(tail, agc) tail = agc self.fg.connect(tail, dst) # oscilloscope if options.osc : oscPanel = wxPanel(self, -1) if (options.encoding == "s") : converter = gr.interleaved_short_to_complex() self.fg.connect(tail, converter) signal = converter elif (options.encoding == "f") : signal = tail else : parser.error("Unsupported data encoding for oscilloscope!") #block = scope_sink_f(fg, parent, title=label, sample_rate=input_rate) #return (block, block.win) oscWin = scopesink.scope_sink_c(self.fg, oscPanel, "Signal", options.samplingrate) self.fg.connect(signal, oscWin) mainSizer.Add(oscPanel, 1, wxEXPAND) # spectrometer if options.spectrum : ymin = 0 ymax = 160 fftPanel = wxPanel(self, -1) if (options.encoding == "s") : converter = gr.interleaved_short_to_complex() self.fg.connect(tail, converter) signal = converter elif (options.encoding == "f") : signal = tail else : parser.error("Unsupported data encoding for oscilloscope!") fftWin = fftsink.fft_sink_c(self.fg, fftPanel, title="Spectrum", fft_size=2048, sample_rate=options.samplingrate, y_per_div=(ymax - ymin) / 8, ref_level=ymax, fft_rate=50, average=True ) self.fg.connect(signal, fftWin) mainSizer.Add(fftPanel, 1, wxEXPAND) # Events EVT_MENU(self, ID_ABOUT, self.OnAbout) EVT_MENU(self, ID_EXIT, self.TimeToQuit) EVT_SLIDER(self, ID_GAIN_SLIDER0, self.slideEvent) EVT_SLIDER(self, ID_FREQ_SLIDER0, self.slideEvent) EVT_SLIDER(self, ID_GAIN_SLIDER1, self.slideEvent) EVT_SLIDER(self, ID_FREQ_SLIDER1, self.slideEvent) EVT_BUTTON(self, ID_START, self.onClick) EVT_BUTTON(self, ID_STOP, self.onClick) #Layout sizers self.SetSizer(mainSizer) self.SetAutoLayout(1) mainSizer.Fit(self) self.fg.start()
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("-S", "--subdev", type="subdev", default=(0, None), # help="select USRP Rx side A or B (default=A)") parser.add_option("-d", "--decim", type="int", default=128, help="set fgpa decimation rate to DECIM [default=%default]") parser.add_option("-f", "--freq", type="eng_float", default=146.585e6, help="set frequency to FREQ [default=%default])", metavar="FREQ") parser.add_option("-g", "--gain", type="eng_float", default=20, help="set gain in dB [default=%default]") parser.add_option("-F", "--filter", action="store_true", default=True, help="Enable channel filter") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() raise SystemExit nchan = 4 if options.filter: sw_decim = 4 else: sw_decim = 1 self.u = usrp.source_c(0, options.decim, fpga_filename="std_4rx_0tx.rbf") if self.u.nddc() < nchan: sys.stderr.write('This code requires an FPGA build with %d DDCs. This FPGA has only %d.\n' % ( nchan, self.u.nddc())) raise SystemExit if not self.u.set_nchannels(nchan): sys.stderr.write('set_nchannels(%d) failed\n' % (nchan,)) raise SystemExit input_rate = self.u.adc_freq() / self.u.decim_rate() print "USB data rate = %s" % (eng_notation.num_to_str(input_rate),) print "Scope data rate = %s" % (eng_notation.num_to_str(input_rate/sw_decim),) self.subdev = self.u.db[0] + self.u.db[1] if (len (self.subdev) != 4 or self.u.db[0][0].dbid() != usrp_dbid.BASIC_RX or self.u.db[1][0].dbid() != usrp_dbid.BASIC_RX): sys.stderr.write('This code requires a Basic Rx board on Sides A & B\n') sys.exit(1) self.u.set_mux(gru.hexint(0xf3f2f1f0)) # deinterleave four channels from FPGA di = gr.deinterleave(gr.sizeof_gr_complex) self.connect(self.u, di) # taps for channel filter chan_filt_coeffs = optfir.low_pass (1, # gain input_rate, # sampling rate 80e3, # passband cutoff 115e3, # stopband cutoff 0.1, # passband ripple 60) # stopband attenuation #print len(chan_filt_coeffs) for i in range(nchan): scope = fftsink.fft_sink_c(self, panel, sample_rate=input_rate/sw_decim, title="Input %d" % (i,), ref_level=80, y_per_div=20) vbox.Add(scope.win, 10, wx.EXPAND) if options.filter: chan_filt = gr.fir_filter_ccf(sw_decim, chan_filt_coeffs) self.connect((di, i), chan_filt, scope) else: self.connect((di, i), scope) self.set_gain(options.gain) self.set_freq(options.freq)
def __init__(self, frame, panel, vbox, argv): stdgui.gui_flow_graph.__init__ (self, frame, panel, vbox, argv) parser = OptionParser (option_class=eng_option) parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None, help="select USRP Tx side A or B") parser.add_option("-f", "--freq", type="eng_float", default=None, help="set Tx frequency to FREQ [required]", metavar="FREQ") parser.add_option("","--debug", action="store_true", default=False, help="Launch Tx debugger") (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() sys.exit(1) if options.freq is None: sys.stderr.write("usrp_tx_video.py: must specify frequency with -f FREQ\n") parser.print_help() sys.exit(1) # ---------------------------------------------------------------- self.u = usrp.sink_c () # the USRP sink (consumes samples) self.dac_rate = self.u.dac_rate() # 128 MS/s self.usrp_interp = 128 self.usrp_rate = self.dac_rate / self.usrp_interp self.u.set_interp_rate(self.usrp_interp) # determine the daughterboard subdevice we're using if options.tx_subdev_spec is None: options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u) m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec) self.u.set_mux(m) self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec) print "Using TX d'board %s with rate %ld" % (self.subdev.side_and_name(), self.usrp_rate) self.subdev.set_gain(self.subdev.gain_range()[1]) # set max Tx gain self.u.tune(self.subdev._which, self.subdev, options.freq) self.subdev.set_enable(True) # enable transmitter t = pipeline(self, options.freq, self.usrp_rate) gain = gr.multiply_const_cc (32000.0) # connect it all self.connect (t, gain) self.connect (gain, self.u) # plot an FFT to verify we are sending what we want if 1: post_mod_fft = fftsink.fft_sink_c(self, panel, title="Signal in frequency domain", fft_size=64, sample_rate=self.usrp_rate, y_per_div=20, ref_level=40) #post_mod_oscope = scopesink.scope_sink_c(self, panel, sample_rate=self.usrp_rate, # title="Signal in time domain", v_scale = 1, # t_scale=0.0001) self.connect (t, post_mod_fft) #self.connect (t, post_mod_oscope) vbox.Add (post_mod_fft.win, 1, wx.EXPAND) #vbox.Add (post_mod_oscope.win, 1, wx.EXPAND) if options.debug: self.debugger = tx_debug_gui.tx_debug_gui(self.subdev) self.debugger.Show(True)