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 = 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) 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.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.volume_control_l, (audio_sink, 0)) self.connect((self.guts, 1), 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) usage = "usage: %prog [options] input-samples-320kS.dat output.wav" parser=OptionParser(option_class=eng_option, usage=usage) parser.add_option("-V", "--volume", type="eng_float", default=None, help="set volume (default is midpoint)") (options, args) = parser.parse_args() if len(args) != 2: parser.print_help() sys.exit(1) input_filename = args[0] output_filename = args[1] self.vol = 0 # build graph self.src = gr.file_source(gr.sizeof_gr_complex, input_filename, False) adc_rate = 64e6 # 64 MS/s usrp_decim = 200 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 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.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) # wave file as final sink if 1: sink = gr.wavfile_sink(output_filename, 2, int(audio_rate), 16) else: sink = audio.sink (int (audio_rate), options.audio_output, False) # ok_to_block # now wire it all together self.connect (self.src, chan_filt, self.guts) self.connect ((self.guts, 0), self.volume_control_l, (sink, 0)) self.connect ((self.guts, 1), self.volume_control_r, (sink, 1)) try: self.guts.stereo_carrier_pll_recovery.squelch_enable(True) except: pass #print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet" if options.volume is None: g = self.volume_range() options.volume = float(g[0]+g[1])/2 # set initial values self.set_vol(options.volume) try: self.guts.stereo_carrier_pll_recovery.set_lock_threshold(options.squelch) except: pass
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("-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("-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") parser.add_option("", "--freq-min", type="eng_float", default=87.9e6, help="Set a minimum frequency [default=%default]") parser.add_option("", "--freq-max", type="eng_float", default=108.1e6, help="Set a maximum frequency [default=%default]") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) self.frame = frame self.panel = panel self.vol = 0 self.state = "FREQ" self.freq = 0 self.fm_freq_min = options.freq_min self.fm_freq_max = options.freq_max # build graph self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32')) # 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) usrp_rate = 320e3 demod_rate = 320e3 audio_rate = 48e3 audio_decim = 10 self.u.set_samp_rate(usrp_rate) dev_rate = self.u.get_samp_rate() nfilts = 32 chan_coeffs = gr.firdes.low_pass_2 (nfilts, # gain nfilts*usrp_rate, # sampling rate 90e3, # passband cutoff 30e3, # stopband cutoff 70) # stopband attenuation rrate = usrp_rate / dev_rate self.chan_filt = blks2.pfb_arb_resampler_ccf(rrate, chan_coeffs, nfilts) self.guts = blks2.wfm_rcv_pll (demod_rate, audio_decim) chan_rate = audio_rate / (demod_rate/audio_decim) self.rchan_filt = blks2.pfb_arb_resampler_fff(chan_rate) self.lchan_filt = blks2.pfb_arb_resampler_fff(chan_rate) # 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 self.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.guts) self.connect((self.guts, 0), self.lchan_filt, self.volume_control_l, (self.audio_sink,0)) self.connect((self.guts, 1), self.rchan_filt, self.volume_control_r, (self.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.u.get_gain_range() options.gain = float(g.start()+g.stop())/2.0 if options.volume is None: g = self.volume_range() options.volume = float(g[0]+g[1])/2 frange = self.u.get_freq_range() if(frange.start() > self.fm_freq_max or frange.stop() < self.fm_freq_min): sys.stderr.write("Radio does not support required frequency range.\n") sys.exit(1) if(options.freq < self.fm_freq_min or options.freq > self.fm_freq_max): sys.stderr.write("Requested frequency is outside of required frequency range.\n") sys.exit(1) # 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("-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=91.2e6, help="set frequency to FREQ", metavar="FREQ") parser.add_option("-g", "--gain", type="eng_float", default=None, help="set gain in dB") 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="plughw:0,0", help="pcm device name (default is plughw:0,0)") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) # connect to USRP usrp_decim = 250 self.u = usrp.source_c(0, usrp_decim) print "USRP Serial: ", self.u.serial_number() demod_rate = self.u.adc_rate() / usrp_decim # 256 kS/s audio_decim = 8 audio_rate = demod_rate / audio_decim # 32 kS/s if options.rx_subdev_spec is None: options.rx_subdev_spec = usrp.pick_subdev(self.u, dblist) 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 d'board", self.subdev.side_and_name() # gain, volume, frequency self.gain = options.gain if options.gain is None: self.gain = self.subdev.gain_range()[1] self.vol = options.volume if self.vol is None: g = self.volume_range() self.vol = float(g[0] + g[1]) / 2 self.freq = options.freq if abs(self.freq) < 1e6: self.freq *= 1e6 print "Volume:%r, Gain:%r, Freq:%3.1f MHz" % (self.vol, self.gain, self.freq / 1e6) # channel filter, wfm_rcv_pll chan_filt_coeffs = optfir.low_pass( 1, # gain demod_rate, # rate 80e3, # passband cutoff 115e3, # stopband cutoff 0.1, # passband ripple 60) # stopband attenuation self.chan_filt = gr.fir_filter_ccf(1, chan_filt_coeffs) self.guts = blks2.wfm_rcv_pll(demod_rate, audio_decim) self.connect(self.u, self.chan_filt, self.guts) # volume control, audio sink self.volume_control_l = gr.multiply_const_ff(self.vol) self.volume_control_r = gr.multiply_const_ff(self.vol) self.audio_sink = audio.sink(int(audio_rate), options.audio_output, False) self.connect((self.guts, 0), self.volume_control_l, (self.audio_sink, 0)) self.connect((self.guts, 1), self.volume_control_r, (self.audio_sink, 1)) # pilot channel filter (band-pass, 18.5-19.5kHz) pilot_filter_coeffs = gr.firdes.band_pass( 1, # gain demod_rate, # sampling rate 18.5e3, # low cutoff 19.5e3, # high cutoff 1e3, # transition width gr.firdes.WIN_HAMMING) self.pilot_filter = gr.fir_filter_fff(1, pilot_filter_coeffs) self.connect(self.guts.fm_demod, self.pilot_filter) # RDS channel filter (band-pass, 54-60kHz) rds_filter_coeffs = gr.firdes.band_pass( 1, # gain demod_rate, # sampling rate 54e3, # low cutoff 60e3, # high cutoff 3e3, # transition width gr.firdes.WIN_HAMMING) self.rds_filter = gr.fir_filter_fff(1, rds_filter_coeffs) self.connect(self.guts.fm_demod, self.rds_filter) # create 57kHz subcarrier from 19kHz pilot, downconvert RDS channel self.mixer = gr.multiply_ff() self.connect(self.pilot_filter, (self.mixer, 0)) self.connect(self.pilot_filter, (self.mixer, 1)) self.connect(self.pilot_filter, (self.mixer, 2)) self.connect(self.rds_filter, (self.mixer, 3)) # low-pass the baseband RDS signal at 1.5kHz rds_bb_filter_coeffs = gr.firdes.low_pass( 1, # gain demod_rate, # sampling rate 1.5e3, # passband cutoff 2e3, # transition width gr.firdes.WIN_HAMMING) self.rds_bb_filter = gr.fir_filter_fff(1, rds_bb_filter_coeffs) self.connect(self.mixer, self.rds_bb_filter) # 1187.5bps = 19kHz/16 self.rds_clock = rds.freq_divider(16) clock_taps = gr.firdes.low_pass( 1, # gain demod_rate, # sampling rate 1.2e3, # passband cutoff 1.5e3, # transition width gr.firdes.WIN_HANN) self.clock_filter = gr.fir_filter_fff(1, clock_taps) self.connect(self.pilot_filter, self.rds_clock, self.clock_filter) # bpsk_demod, diff_decoder, rds_decoder self.bpsk_demod = rds.bpsk_demod(demod_rate) self.differential_decoder = gr.diff_decoder_bb(2) self.msgq = gr.msg_queue() self.rds_decoder = rds.data_decoder(self.msgq) self.connect(self.rds_bb_filter, (self.bpsk_demod, 0)) self.connect(self.clock_filter, (self.bpsk_demod, 1)) self.connect(self.bpsk_demod, self.differential_decoder) self.connect(self.differential_decoder, self.rds_decoder) # set initial values self.subdev.set_gain(self.gain) self.set_vol(self.vol) self.set_freq(self.freq)
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=91.2e6, help="set frequency to FREQ", metavar="FREQ") parser.add_option("-g", "--gain", type="eng_float", default=None, help="set gain in dB") 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="plughw:0,0", help="pcm device name (default is plughw:0,0)") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) # connect to USRP usrp_decim = 250 self.u = usrp.source_c(0, usrp_decim) print "USRP Serial: ", self.u.serial_number() demod_rate = self.u.adc_rate() / usrp_decim # 256 kS/s audio_decim = 8 audio_rate = demod_rate / audio_decim # 32 kS/s if options.rx_subdev_spec is None: options.rx_subdev_spec = usrp.pick_subdev(self.u, dblist) 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 d'board", self.subdev.side_and_name() # gain, volume, frequency self.gain = options.gain if options.gain is None: self.gain = self.subdev.gain_range()[1] self.vol = options.volume if self.vol is None: g = self.volume_range() self.vol = float(g[0]+g[1])/2 self.freq = options.freq if abs(self.freq) < 1e6: self.freq *= 1e6 print "Volume:%r, Gain:%r, Freq:%3.1f MHz" % (self.vol, self.gain, self.freq/1e6) # channel filter, wfm_rcv_pll chan_filt_coeffs = optfir.low_pass( 1, # gain demod_rate, # rate 80e3, # passband cutoff 115e3, # stopband cutoff 0.1, # passband ripple 60) # stopband attenuation self.chan_filt = gr.fir_filter_ccf (1, chan_filt_coeffs) self.guts = blks2.wfm_rcv_pll (demod_rate, audio_decim) self.connect(self.u, self.chan_filt, self.guts) # volume control, audio sink self.volume_control_l = gr.multiply_const_ff(self.vol) self.volume_control_r = gr.multiply_const_ff(self.vol) self.audio_sink = audio.sink(int(audio_rate), options.audio_output, False) self.connect ((self.guts, 0), self.volume_control_l, (self.audio_sink, 0)) self.connect ((self.guts, 1), self.volume_control_r, (self.audio_sink, 1)) # pilot channel filter (band-pass, 18.5-19.5kHz) pilot_filter_coeffs = gr.firdes.band_pass( 1, # gain demod_rate, # sampling rate 18.5e3, # low cutoff 19.5e3, # high cutoff 1e3, # transition width gr.firdes.WIN_HAMMING) self.pilot_filter = gr.fir_filter_fff(1, pilot_filter_coeffs) self.connect(self.guts.fm_demod, self.pilot_filter) # RDS channel filter (band-pass, 54-60kHz) rds_filter_coeffs = gr.firdes.band_pass( 1, # gain demod_rate, # sampling rate 54e3, # low cutoff 60e3, # high cutoff 3e3, # transition width gr.firdes.WIN_HAMMING) self.rds_filter = gr.fir_filter_fff(1, rds_filter_coeffs) self.connect(self.guts.fm_demod, self.rds_filter) # create 57kHz subcarrier from 19kHz pilot, downconvert RDS channel self.mixer = gr.multiply_ff() self.connect(self.pilot_filter, (self.mixer, 0)) self.connect(self.pilot_filter, (self.mixer, 1)) self.connect(self.pilot_filter, (self.mixer, 2)) self.connect(self.rds_filter, (self.mixer, 3)) # low-pass the baseband RDS signal at 1.5kHz rds_bb_filter_coeffs = gr.firdes.low_pass( 1, # gain demod_rate, # sampling rate 1.5e3, # passband cutoff 2e3, # transition width gr.firdes.WIN_HAMMING) self.rds_bb_filter = gr.fir_filter_fff(1, rds_bb_filter_coeffs) self.connect(self.mixer, self.rds_bb_filter) # 1187.5bps = 19kHz/16 self.rds_clock = rds.freq_divider(16) clock_taps = gr.firdes.low_pass( 1, # gain demod_rate, # sampling rate 1.2e3, # passband cutoff 1.5e3, # transition width gr.firdes.WIN_HANN) self.clock_filter = gr.fir_filter_fff(1, clock_taps) self.connect(self.pilot_filter, self.rds_clock, self.clock_filter) # bpsk_demod, diff_decoder, rds_decoder self.bpsk_demod = rds.bpsk_demod(demod_rate) self.differential_decoder = gr.diff_decoder_bb(2) self.msgq = gr.msg_queue() self.rds_decoder = rds.data_decoder(self.msgq) self.connect(self.rds_bb_filter, (self.bpsk_demod, 0)) self.connect(self.clock_filter, (self.bpsk_demod, 1)) self.connect(self.bpsk_demod, self.differential_decoder) self.connect(self.differential_decoder, self.rds_decoder) # set initial values self.subdev.set_gain(self.gain) self.set_vol(self.vol) self.set_freq(self.freq)
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("-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("-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") parser.add_option("", "--freq-min", type="eng_float", default=87.9e6, help="Set a minimum frequency [default=%default]") parser.add_option("", "--freq-max", type="eng_float", default=108.1e6, help="Set a maximum frequency [default=%default]") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) self.frame = frame self.panel = panel self.vol = 0 self.state = "FREQ" self.freq = 0 self.fm_freq_min = options.freq_min self.fm_freq_max = options.freq_max # build graph self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32')) usrp_rate = 320e3 demod_rate = 320e3 audio_rate = 48e3 audio_decim = 10 self.u.set_samp_rate(usrp_rate) dev_rate = self.u.get_samp_rate() nfilts = 32 chan_coeffs = gr.firdes.low_pass_2 (nfilts, # gain nfilts*usrp_rate, # sampling rate 90e3, # passband cutoff 30e3, # stopband cutoff 70) # stopband attenuation rrate = usrp_rate / dev_rate self.chan_filt = blks2.pfb_arb_resampler_ccf(rrate, chan_coeffs, nfilts) self.guts = blks2.wfm_rcv_pll (demod_rate, audio_decim) chan_rate = audio_rate / (demod_rate/audio_decim) self.rchan_filt = blks2.pfb_arb_resampler_fff(chan_rate) self.lchan_filt = blks2.pfb_arb_resampler_fff(chan_rate) # 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 self.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.guts) self.connect((self.guts, 0), self.lchan_filt, self.volume_control_l, (self.audio_sink,0)) self.connect((self.guts, 1), self.rchan_filt, self.volume_control_r, (self.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.u.get_gain_range() options.gain = float(g.start()+g.stop())/2.0 if options.volume is None: g = self.volume_range() options.volume = float(g[0]+g[1])/2 frange = self.u.get_freq_range() if(frange.start() > self.fm_freq_max or frange.stop() < self.fm_freq_min): sys.stderr.write("Radio does not support required frequency range.\n") sys.exit(1) if(options.freq < self.fm_freq_min or options.freq > self.fm_freq_max): sys.stderr.write("Requested frequency is outside of required frequency range.\n") sys.exit(1) # 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") # 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)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Fm Rx Example") ################################################## # Variables ################################################## self.usrp_freq = usrp_freq = 96.5e6 self.samp_rate = samp_rate = 500e3 self.xlate_tune = xlate_tune = 0 self.usrp_decim = usrp_decim = 200 self.rx_freq = rx_freq = usrp_freq self.rf_gain = rf_gain = 15 self.filter_taps = filter_taps = firdes.low_pass(1,samp_rate,200e3,1e3) self.af_gain = af_gain = 3 ################################################## # Blocks ################################################## _xlate_tune_sizer = wx.BoxSizer(wx.VERTICAL) self._xlate_tune_text_box = forms.text_box( parent=self.GetWin(), sizer=_xlate_tune_sizer, value=self.xlate_tune, callback=self.set_xlate_tune, label='xlate_tune', converter=forms.float_converter(), proportion=0, ) self._xlate_tune_slider = forms.slider( parent=self.GetWin(), sizer=_xlate_tune_sizer, value=self.xlate_tune, callback=self.set_xlate_tune, minimum=-250e3, maximum=250e3, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_xlate_tune_sizer, 7, 0, 1, 5) _usrp_freq_sizer = wx.BoxSizer(wx.VERTICAL) self._usrp_freq_text_box = forms.text_box( parent=self.GetWin(), sizer=_usrp_freq_sizer, value=self.usrp_freq, callback=self.set_usrp_freq, label='usrp_freq', converter=forms.float_converter(), proportion=0, ) self._usrp_freq_slider = forms.slider( parent=self.GetWin(), sizer=_usrp_freq_sizer, value=self.usrp_freq, callback=self.set_usrp_freq, minimum=88e6, maximum=108e6, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_usrp_freq_sizer, 6, 0, 1, 5) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=13.49e3, sample_rate=250e3, fft_size=1024, fft_rate=10, average=True, avg_alpha=500e-3, title="FFT Plot", peak_hold=False, size=(1120,527), ) self.GridAdd(self.wxgui_fftsink2_0.win, 0, 0, 5, 5) self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="addr=192.168.20.2", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(samp_rate) self.uhd_usrp_source_0.set_center_freq(usrp_freq, 0) self.uhd_usrp_source_0.set_gain(15, 0) self.uhd_usrp_source_0.set_antenna("TX/RX", 0) self._rx_freq_static_text = forms.static_text( parent=self.GetWin(), value=self.rx_freq, callback=self.set_rx_freq, label='rx_freq', converter=forms.float_converter(), ) self.GridAdd(self._rx_freq_static_text, 5, 3, 1, 1) _rf_gain_sizer = wx.BoxSizer(wx.VERTICAL) self._rf_gain_text_box = forms.text_box( parent=self.GetWin(), sizer=_rf_gain_sizer, value=self.rf_gain, callback=self.set_rf_gain, label='rf_gain', converter=forms.float_converter(), proportion=0, ) self._rf_gain_slider = forms.slider( parent=self.GetWin(), sizer=_rf_gain_sizer, value=self.rf_gain, callback=self.set_rf_gain, minimum=0, maximum=50, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_rf_gain_sizer, 8, 0, 1, 2) self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((3, )) self.gr_multiply_const_vxx_0 = gr.multiply_const_vff((3, )) self.gr_freq_xlating_fir_filter_xxx_0 = gr.freq_xlating_fir_filter_ccc(1, (filter_taps), xlate_tune, samp_rate) self.blks2_wfm_rcv_pll_0 = blks2.wfm_rcv_pll( demod_rate=500e3, audio_decimation=10, ) self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_fff( interpolation=48, decimation=50, taps=None, fractional_bw=None, ) self.blks2_rational_resampler_xxx_0 = blks2.rational_resampler_fff( interpolation=48, decimation=50, taps=None, fractional_bw=None, ) self.audio_sink_0 = audio.sink(48000, "", True) _af_gain_sizer = wx.BoxSizer(wx.VERTICAL) self._af_gain_text_box = forms.text_box( parent=self.GetWin(), sizer=_af_gain_sizer, value=self.af_gain, callback=self.set_af_gain, label='af_gain', converter=forms.float_converter(), proportion=0, ) self._af_gain_slider = forms.slider( parent=self.GetWin(), sizer=_af_gain_sizer, value=self.af_gain, callback=self.set_af_gain, minimum=0, maximum=10, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_af_gain_sizer, 8, 2, 1, 2) ################################################## # Connections ################################################## self.connect((self.uhd_usrp_source_0, 0), (self.gr_freq_xlating_fir_filter_xxx_0, 0)) self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0), (self.blks2_wfm_rcv_pll_0, 0)) self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0), (self.wxgui_fftsink2_0, 0)) self.connect((self.gr_multiply_const_vxx_0, 0), (self.audio_sink_0, 0)) self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.gr_multiply_const_vxx_1, 0)) self.connect((self.blks2_rational_resampler_xxx_0, 0), (self.gr_multiply_const_vxx_0, 0)) self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 1)) self.connect((self.blks2_wfm_rcv_pll_0, 0), (self.blks2_rational_resampler_xxx_0, 0)) self.connect((self.blks2_wfm_rcv_pll_0, 1), (self.blks2_rational_resampler_xxx_1, 0))
def __init__(self): gr.top_block.__init__(self) usage = "usage: %prog [options] input-samples-320kS.dat output.wav" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-V", "--volume", type="eng_float", default=None, help="set volume (default is midpoint)") (options, args) = parser.parse_args() if len(args) != 2: parser.print_help() sys.exit(1) input_filename = args[0] output_filename = args[1] self.vol = 0 # build graph self.src = gr.file_source(gr.sizeof_gr_complex, input_filename, False) adc_rate = 64e6 # 64 MS/s usrp_decim = 200 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 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.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) # wave file as final sink if 1: sink = gr.wavfile_sink(output_filename, 2, int(audio_rate), 16) else: sink = audio.sink(int(audio_rate), options.audio_output, False) # ok_to_block # now wire it all together self.connect(self.src, chan_filt, self.guts) self.connect((self.guts, 0), self.volume_control_l, (sink, 0)) self.connect((self.guts, 1), self.volume_control_r, (sink, 1)) try: self.guts.stereo_carrier_pll_recovery.squelch_enable(True) except: pass #print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet" if options.volume is None: g = self.volume_range() options.volume = float(g[0] + g[1]) / 2 # set initial values self.set_vol(options.volume) try: self.guts.stereo_carrier_pll_recovery.set_lock_threshold( options.squelch) except: pass
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Fm Rx Example") ################################################## # Variables ################################################## self.usrp_freq = usrp_freq = 96e6 self.samp_rate = samp_rate = 500e3 self.xlate_tune = xlate_tune = 0 self.usrp_decim = usrp_decim = 200 self.rx_freq = rx_freq = usrp_freq self.rf_gain = rf_gain = 15 self.filter_taps = filter_taps = firdes.low_pass( 1, samp_rate, 200e3, 1e3) self.af_gain = af_gain = 3 self.Mult_constant = Mult_constant = 5 ################################################## # Blocks ################################################## _xlate_tune_sizer = wx.BoxSizer(wx.VERTICAL) self._xlate_tune_text_box = forms.text_box( parent=self.GetWin(), sizer=_xlate_tune_sizer, value=self.xlate_tune, callback=self.set_xlate_tune, label='xlate_tune', converter=forms.float_converter(), proportion=0, ) self._xlate_tune_slider = forms.slider( parent=self.GetWin(), sizer=_xlate_tune_sizer, value=self.xlate_tune, callback=self.set_xlate_tune, minimum=-250e3, maximum=250e3, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_xlate_tune_sizer, 7, 0, 1, 5) _usrp_freq_sizer = wx.BoxSizer(wx.VERTICAL) self._usrp_freq_text_box = forms.text_box( parent=self.GetWin(), sizer=_usrp_freq_sizer, value=self.usrp_freq, callback=self.set_usrp_freq, label='usrp_freq', converter=forms.float_converter(), proportion=0, ) self._usrp_freq_slider = forms.slider( parent=self.GetWin(), sizer=_usrp_freq_sizer, value=self.usrp_freq, callback=self.set_usrp_freq, minimum=88e6, maximum=108e6, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_usrp_freq_sizer, 6, 0, 1, 5) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=13.49e3, sample_rate=250e3, fft_size=1024, fft_rate=10, average=True, avg_alpha=500e-3, title="FFT Plot", peak_hold=False, size=(1120, 527), ) self.GridAdd(self.wxgui_fftsink2_0.win, 0, 0, 5, 5) self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="addr=192.168.10.2", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(samp_rate) self.uhd_usrp_source_0.set_center_freq(usrp_freq, 0) self.uhd_usrp_source_0.set_gain(15, 0) self.uhd_usrp_source_0.set_antenna("TX/RX", 0) self._rx_freq_static_text = forms.static_text( parent=self.GetWin(), value=self.rx_freq, callback=self.set_rx_freq, label='rx_freq', converter=forms.float_converter(), ) self.GridAdd(self._rx_freq_static_text, 5, 3, 1, 1) _rf_gain_sizer = wx.BoxSizer(wx.VERTICAL) self._rf_gain_text_box = forms.text_box( parent=self.GetWin(), sizer=_rf_gain_sizer, value=self.rf_gain, callback=self.set_rf_gain, label='rf_gain', converter=forms.float_converter(), proportion=0, ) self._rf_gain_slider = forms.slider( parent=self.GetWin(), sizer=_rf_gain_sizer, value=self.rf_gain, callback=self.set_rf_gain, minimum=0, maximum=50, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_rf_gain_sizer, 8, 0, 1, 2) self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((Mult_constant, )) self.gr_multiply_const_vxx_0 = gr.multiply_const_vff((Mult_constant, )) self.gr_freq_xlating_fir_filter_xxx_0 = gr.freq_xlating_fir_filter_ccc( 1, (filter_taps), xlate_tune, samp_rate) self.blks2_wfm_rcv_pll_0 = blks2.wfm_rcv_pll( demod_rate=500e3, audio_decimation=10, ) self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_fff( interpolation=48, decimation=50, taps=None, fractional_bw=None, ) self.blks2_rational_resampler_xxx_0 = blks2.rational_resampler_fff( interpolation=48, decimation=50, taps=None, fractional_bw=None, ) self.audio_sink_0 = audio.sink(48000, "", True) _af_gain_sizer = wx.BoxSizer(wx.VERTICAL) self._af_gain_text_box = forms.text_box( parent=self.GetWin(), sizer=_af_gain_sizer, value=self.af_gain, callback=self.set_af_gain, label='af_gain', converter=forms.float_converter(), proportion=0, ) self._af_gain_slider = forms.slider( parent=self.GetWin(), sizer=_af_gain_sizer, value=self.af_gain, callback=self.set_af_gain, minimum=0, maximum=10, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_af_gain_sizer, 8, 2, 1, 2) ################################################## # Connections ################################################## self.connect((self.uhd_usrp_source_0, 0), (self.gr_freq_xlating_fir_filter_xxx_0, 0)) self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0), (self.blks2_wfm_rcv_pll_0, 0)) self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0), (self.wxgui_fftsink2_0, 0)) self.connect((self.gr_multiply_const_vxx_0, 0), (self.audio_sink_0, 0)) self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.gr_multiply_const_vxx_1, 0)) self.connect((self.blks2_rational_resampler_xxx_0, 0), (self.gr_multiply_const_vxx_0, 0)) self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 1)) self.connect((self.blks2_wfm_rcv_pll_0, 0), (self.blks2_rational_resampler_xxx_0, 0)) self.connect((self.blks2_wfm_rcv_pll_0, 1), (self.blks2_rational_resampler_xxx_1, 0))
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")