def setup_flowgraph(self, mode, ber_skipbytes=0): # parameters self.dp.set_mode(mode) self.rp.set_mode(mode) self.vlen = self.dp.num_carriers/4 self.ber_skipbytes = ber_skipbytes # trigger signals frame_trigger = [1]+[0]*(self.dp.symbols_per_frame-2) self.frame_start = frame_trigger*(len(self.random_bytes)/(self.vlen*(self.dp.symbols_per_frame-1)))+frame_trigger[0:(len(self.random_bytes)/self.vlen)%(self.dp.symbols_per_frame-1)] # sources/sinks self.source = gr.vector_source_b(self.random_bytes, False) self.trig = gr.vector_source_b(self.frame_start, False) if self.ber_sink: self.sink = dab.blocks.measure_ber_b() else: self.sink = gr.vector_sink_b() self.trig_sink = gr.null_sink(gr.sizeof_char) # self.noise_start = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000)) # self.noise_start_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_START) # self.noise_end = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000)) # self.noise_end_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_END) # blocks self.s2v = gr.stream_to_vector(gr.sizeof_char, self.vlen) self.v2s = gr.vector_to_stream(gr.sizeof_char, self.vlen) if self.ber_sink: self.ber_skipbytes0 = gr.skiphead(gr.sizeof_char, self.ber_skipbytes) self.ber_skipbytes1 = gr.skiphead(gr.sizeof_char, self.ber_skipbytes+self.dp.bytes_per_frame) # more blocks (they have state, so better reinitialise them) self.mod = dab.ofdm_mod(self.dp, debug = False) self.rescale = gr.multiply_const_cc(1) self.amp = gr.multiply_const_cc(1) self.channel = blks2.channel_model(noise_voltage=0, noise_seed=random.randint(0,10000)) # self.cat = dab.concatenate_signals(gr.sizeof_gr_complex) self.demod = dab.ofdm_demod(self.dp, self.rp, debug = False, verbose = True) # connect it all if self.ber_sink: self.connect(self.source, self.s2v, (self.mod,0), self.rescale, self.amp, self.channel, (self.demod,0), self.v2s, self.ber_skipbytes0, self.sink) self.connect(self.source, self.ber_skipbytes1, (self.sink,1)) else: self.connect(self.source, self.s2v, (self.mod,0), self.rescale, self.amp, self.channel, (self.demod,0), self.v2s, self.sink) self.connect(self.trig, (self.mod,1)) self.connect((self.demod, 1), self.trig_sink) # SNR calculation and prober self.probe_signal = gr.probe_avg_mag_sqrd_c(0,0.00001) self.probe_total = gr.probe_avg_mag_sqrd_c(0,0.00001) self.connect(self.amp, self.probe_signal) self.connect(self.channel, self.probe_total)
def clear_state(self): if self.ber_sink: self.ber_skipbytes0.rewind() self.ber_skipbytes1.rewind() # self.cat.reset() self.demod.clear_state() # TODO some state is still left in the demod block - for now just make a new one self.disconnect(self.channel, self.demod) self.disconnect((self.demod,0), self.v2s) self.disconnect((self.demod,1), self.trig_sink) self.demod = dab.ofdm_demod(self.dp, self.rp, debug = False, verbose = True) self.connect(self.channel, self.demod) self.connect((self.demod,0), self.v2s) self.connect((self.demod,1), self.trig_sink)
def __init__(self): gr.top_block.__init__(self) usage = "%prog: [options] samples_file" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option("-s", "--resample-fixed", type="eng_float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False, help="Estimate sample rate offset and resample (dynamic fractional interpolation)") parser.add_option('-u', '--usrp-source', action="store_true", default=False, help="Samples from USRP (-> adjust params for 2 MSPS)") parser.add_option('-d', '--debug', action="store_true", default=False, help="Write output to files") parser.add_option('-v', '--verbose', action="store_true", default=False, help="Print status messages") (options, args) = parser.parse_args () if options.usrp_source: dp = dab.dab_parameters(options.dab_mode, verbose=options.verbose, sample_rate=2000000) else: dp = dab.dab_parameters(options.dab_mode, verbose=options.verbose) rp = dab.receiver_parameters(options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, correct_ffe=True, equalize_magnitude=True, verbose=options.verbose) if len(args)<1: print "error: need file with samples" sys.exit(1) else: filename = args[0] if options.verbose: print "--> using samples from file " + filename self.src = gr.file_source(gr.sizeof_gr_complex, filename, False) self.dab_demod = dab.ofdm_demod(dp, rp, verbose=options.verbose, debug=options.debug) self.fic_dec = dab.fic_decode(dp, verbose=options.verbose, debug=options.debug) self.connect(self.src, self.dab_demod, self.fic_dec) self.connect((self.dab_demod,1), (self.fic_dec,1))
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) self.frame = frame self.panel = panel parser = OptionParser(option_class=eng_option, usage="%prog: [options] <filename>") parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option('-c', '--correct-ffe', action="store_true", default=False, help="do fine frequency correction") parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False, help="do fine frequency correction by retuning the USRP instead of in software") parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False, help="do magnitude equalization") parser.add_option("-s", "--resample-fixed", type="eng_float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False, help="Estimate sample rate offset and resample (dynamic fractional interpolation)") parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0), help="select USRP Rx side A or B [default=A]") parser.add_option("-f", "--freq", type="eng_float", default=227.36e6, help="set frequency to FREQ [default=%default]") parser.add_option("-r", "--sample-rate", type="int", default=2000000, help="set sample rate to SAMPLE_RATE [default=%default]") parser.add_option("-d", "--decim", type="intx", default=32, help="set decimation rate to DECIM [default=%default]") parser.add_option("-g", "--rx-gain", type="eng_float", default=None, help="set receive gain in dB (default is midpoint)") parser.add_option('-v', '--verbose', action="store_true", default=False, help="verbose output") (options, args) = parser.parse_args() self.verbose = options.verbose self.sample_rate = options.sample_rate if len(args) == 0: if self.verbose: print "--> receiving from USRP" self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "" ) self.src.set_sample_rate(self.sample_rate) # tune frequency self.frequency = options.freq self.set_freq(options.freq) # set gain if options.rx_gain is None: # if no gain was specified, use AGC self.src.set_gain_mode(1, 0) else: self.src.set_gain(options.rx_gain, 0) else: if self.verbose: print "--> receiving from file: " + args[0] self.filename = args[0] self.src = blocks.file_source(gr.sizeof_gr_complex, self.filename, False) self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose) self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude) self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=self.verbose) self.v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.dab_params.num_carriers) self.scope = scopesink2.scope_sink_c(self.panel, title="DAB constellation sink", sample_rate=self.dab_params.sample_rate, xy_mode=True) self.trigsink = blocks.null_sink(gr.sizeof_char) self.sink = blocks.null_sink(gr.sizeof_float*self.dab_params.num_carriers*2) self.connect(self.src, self.demod, self.sink) self.connect((self.demod,1), self.trigsink) # build GUI self.connect(self.demod.deinterleave, self.v2s, self.scope) vbox.Add(self.scope.win, 10, wx.EXPAND) # FFT Sink self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.panel, baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=self.sample_rate, fft_size=1024, fft_rate=15, average=False, avg_alpha=None, title="FFT Plot", peak_hold=False, ) vbox.Add(self.wxgui_fftsink2_0.win) self.connect((self.src, 0), (self.wxgui_fftsink2_0, 0)) # retune USRP to correct FFE? self.correct_ffe_usrp = options.correct_ffe_usrp if self.correct_ffe_usrp: print "--> correcting FFE on USRP" self.run_correct_ffe_thread = True self.ffe_updater = threading.Timer(0.1, self.correct_ffe) self.ffe_updater.setDaemon(True) self.ffe_updater.start()
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option, usage="%prog: [options] output-filename") parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option('-c', '--correct-ffe', action="store_true", default=False, help="do fine frequency correction") parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False, help="do fine frequency correction by retuning the USRP instead of in software") parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False, help="do magnitude equalization") parser.add_option("-s", "--resample-fixed", type="eng_float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False, help="Estimate sample rate offset and resample (dynamic fractional interpolation)") parser.add_option("-f", "--freq", type="eng_float", default=227.36e6, help="set frequency to FREQ [default=%default]") parser.add_option("-r", "--sample-rate", type="int", default=2000000, help="set sample rate to SAMPLE_RATE [default=%default]") parser.add_option("-g", "--rx-gain", type="eng_float", default=None, help="set receive gain in dB (default is midpoint)") parser.add_option('-v', '--verbose', action="store_true", default=False, help="verbose output") (options, args) = parser.parse_args () # if len(args)!=1: # parser.print_help() # sys.exit(1) # else: # self.filename = args[0] # if gr.enable_realtime_scheduling() != gr.RT_OK: # print "-> failed to enable realtime scheduling" self.verbose = options.verbose self.sample_rate = sample_rate = options.sample_rate self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "" ) self.src.set_sample_rate(sample_rate) #self.src.set_center_freq(209.936e6, 0) self.src.set_freq_corr(0, 0) self.src.set_gain_mode(1, 0) self.src.set_gain(0, 0) self.dab_params = dab.parameters.dab_parameters( mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose ) self.rx_params = dab.parameters.receiver_parameters( mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude ) self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=options.verbose) if len(args) >= 1: self.filename = args[0] self.sink = gr.file_sink(gr.sizeof_char*12288, self.filename) #self.sink = gr.file_sink(gr.sizeof_char*3072, self.filename) self.connect(self.demod, self.sink) # self.trigsink = gr.null_sink(gr.sizeof_char) # self.connect((self.demod,1), self.trigsink) self.fic_dec = dab.fic_decode(self.dab_params) self.connect(self.src, self.demod, (self.fic_dec,0)) self.connect((self.demod,1), (self.fic_dec,1)) # tune frequency self.frequency = options.freq self.set_freq(options.freq) # set gain if options.rx_gain is None: # if no gain was specified, use AGC self.src.set_gain_mode(1, 0) else: self.src.set_gain(options.rx_gain, 0) self.update_ui = options.verbose if self.update_ui: self.run_ui_update_thread = True self.ui_updater = threading.Timer(0.1,self.update_ui_function) self.ui_updater.setDaemon(True) self.ui_updater.start() self.correct_ffe_usrp = options.correct_ffe_usrp if self.correct_ffe_usrp: print "--> correcting FFE on USRP" self.run_correct_ffe_thread = True self.ffe_updater = threading.Timer(0.1, self.correct_ffe) self.ffe_updater.setDaemon(True) self.ffe_updater.start()
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option, usage="%prog: [options] <filename>") parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option('-c', '--correct-ffe', action="store_true", default=False, help="do fine frequency correction") parser.add_option( '-u', '--correct-ffe-usrp', action="store_true", default=False, help= "do fine frequency correction by retuning the USRP instead of in software" ) parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False, help="do magnitude equalization") parser.add_option( "-s", "--resample-fixed", type="eng_float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option( "-S", "--autocorrect-sample-rate", action="store_true", default=False, help= "Estimate sample rate offset and resample (dynamic fractional interpolation)" ) parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0), help="select USRP Rx side A or B [default=A]") parser.add_option("-f", "--freq", type="eng_float", default=227.36e6, help="set frequency to FREQ [default=%default]") parser.add_option( "-r", "--sample-rate", type="int", default=2000000, help="set sample rate to SAMPLE_RATE [default=%default]") parser.add_option( "-d", "--decim", type="intx", default=32, help="set decimation rate to DECIM [default=%default]") parser.add_option("-g", "--rx-gain", type="eng_float", default=None, help="set receive gain in dB (default is midpoint)") parser.add_option('-v', '--verbose', action="store_true", default=False, help="verbose output") (options, args) = parser.parse_args() self.verbose = options.verbose self.sample_rate = options.sample_rate if len(args) == 0: if self.verbose: print "--> receiving from USRP" self.src = osmosdr.source() self.src.set_sample_rate(self.sample_rate) self.src.set_freq_corr(0) # tune frequency self.frequency = options.freq self.orig_frequency = options.freq self.set_freq(options.freq) self.src.set_freq_corr(0) # set gain if options.rx_gain is None: # if no gain was specified, use AGC self.src.set_gain_mode(1, 0) else: self.src.set_gain(options.rx_gain, 0) else: if self.verbose: print "--> receiving from file: " + args[0] self.filename = args[0] self.src = blocks.file_source(gr.sizeof_gr_complex, self.filename, False) self.dab_params = dab.parameters.dab_parameters( mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose) self.rx_params = dab.parameters.receiver_parameters( mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude) self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=self.verbose) self.v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.dab_params.num_carriers) self.trigsink = blocks.null_sink(gr.sizeof_char) self.sink = blocks.null_sink(gr.sizeof_float * self.dab_params.num_carriers * 2) self.connect(self.src, self.demod, self.sink) self.connect((self.demod, 1), self.trigsink) # retune USRP to correct FFE? self.correct_ffe_usrp = options.correct_ffe_usrp if self.correct_ffe_usrp: print "--> correcting FFE on USRP" self.run_correct_ffe_thread = True self.ffe_updater = threading.Timer(0.1, self.correct_ffe) self.ffe_updater.setDaemon(True) self.ffe_updater.start()
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option, usage="%prog: [options] output-filename") parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option('-c', '--correct-ffe', action="store_true", default=False, help="do fine frequency correction") parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False, help="do fine frequency correction by retuning the USRP instead of in software") parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False, help="do magnitude equalization") parser.add_option("-s", "--resample-fixed", type="eng_float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False, help="Estimate sample rate offset and resample (dynamic fractional interpolation)") parser.add_option("-f", "--freq", type="eng_float", default=227.36e6, help="set frequency to FREQ [default=%default]") parser.add_option("-r", "--sample-rate", type="int", default=2000000, help="set sample rate to SAMPLE_RATE [default=%default]") parser.add_option("-g", "--rx-gain", type="eng_float", default=None, help="set receive gain in dB (default is midpoint)") parser.add_option('-v', '--verbose', action="store_true", default=False, help="verbose output") (options, args) = parser.parse_args () # if len(args)!=1: # parser.print_help() # sys.exit(1) # else: # self.filename = args[0] # if gr.enable_realtime_scheduling() != gr.RT_OK: # print "-> failed to enable realtime scheduling" self.verbose = options.verbose self.sample_rate = sample_rate = options.sample_rate self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "" ) self.src.set_sample_rate(sample_rate) #self.src.set_center_freq(209.936e6, 0) self.src.set_freq_corr(0, 0) self.src.set_gain_mode(1, 0) self.src.set_gain(0, 0) self.dab_params = dab.parameters.dab_parameters( mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose ) self.rx_params = dab.parameters.receiver_parameters( mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude ) self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=options.verbose) if len(args) >= 1: self.filename = args[0] self.sink = blocks.file_sink(gr.sizeof_char*12288, self.filename) #self.sink = gr.file_sink(gr.sizeof_char*3072, self.filename) self.connect(self.demod, self.sink) # self.trigsink = gr.null_sink(gr.sizeof_char) # self.connect((self.demod,1), self.trigsink) self.fic_dec = dab.fic_decode(self.dab_params) self.connect(self.src, self.demod, (self.fic_dec,0)) self.connect((self.demod,1), (self.fic_dec,1)) # tune frequency self.frequency = options.freq self.set_freq(options.freq) # set gain if options.rx_gain is None: # if no gain was specified, use AGC self.src.set_gain_mode(1, 0) else: self.src.set_gain(options.rx_gain, 0) self.update_ui = options.verbose if self.update_ui: self.run_ui_update_thread = True self.ui_updater = threading.Timer(0.1,self.update_ui_function) self.ui_updater.setDaemon(True) self.ui_updater.start() self.correct_ffe_usrp = options.correct_ffe_usrp if self.correct_ffe_usrp: print "--> correcting FFE on USRP" self.run_correct_ffe_thread = True self.ffe_updater = threading.Timer(0.1, self.correct_ffe) self.ffe_updater.setDaemon(True) self.ffe_updater.start()
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option, usage="%prog: [options] <filename>") parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option('-c', '--correct-ffe', action="store_true", default=False, help="do fine frequency correction") parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False, help="do fine frequency correction by retuning the USRP instead of in software") parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False, help="do magnitude equalization") parser.add_option("-s", "--resample-fixed", type="eng_float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False, help="Estimate sample rate offset and resample (dynamic fractional interpolation)") parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0), help="select USRP Rx side A or B [default=A]") parser.add_option("-f", "--freq", type="eng_float", default=227.36e6, help="set frequency to FREQ [default=%default]") parser.add_option("-r", "--sample-rate", type="int", default=2000000, help="set sample rate to SAMPLE_RATE [default=%default]") parser.add_option("-d", "--decim", type="intx", default=32, help="set decimation rate to DECIM [default=%default]") parser.add_option("-g", "--rx-gain", type="eng_float", default=None, help="set receive gain in dB (default is midpoint)") parser.add_option('-v', '--verbose', action="store_true", default=False, help="verbose output") (options, args) = parser.parse_args() self.verbose = options.verbose self.sample_rate = options.sample_rate if len(args) == 0: if self.verbose: print "--> receiving from USRP" self.src = osmosdr.source() self.src.set_sample_rate(self.sample_rate) self.src.set_freq_corr(0) # tune frequency self.frequency = options.freq self.orig_frequency = options.freq self.set_freq(options.freq) self.src.set_freq_corr(0) # set gain if options.rx_gain is None: # if no gain was specified, use AGC self.src.set_gain_mode(1, 0) else: self.src.set_gain(options.rx_gain, 0) else: if self.verbose: print "--> receiving from file: " + args[0] self.filename = args[0] self.src = blocks.file_source(gr.sizeof_gr_complex, self.filename, False) self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose) self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude) self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=self.verbose) self.v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.dab_params.num_carriers) self.trigsink = blocks.null_sink(gr.sizeof_char) self.sink = blocks.null_sink(gr.sizeof_float*self.dab_params.num_carriers*2) self.connect(self.src, self.demod, self.sink) self.connect((self.demod,1), self.trigsink) # retune USRP to correct FFE? self.correct_ffe_usrp = options.correct_ffe_usrp if self.correct_ffe_usrp: print "--> correcting FFE on USRP" self.run_correct_ffe_thread = True self.ffe_updater = threading.Timer(0.1, self.correct_ffe) self.ffe_updater.setDaemon(True) self.ffe_updater.start()
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option, usage="%prog: [options] output-filename") parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option('-c', '--correct-ffe', action="store_true", default=False, help="do fine frequency correction") parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False, help="do fine frequency correction by retuning the USRP instead of in software") parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False, help="do magnitude equalization") parser.add_option("-s", "--resample-fixed", type="eng_float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False, help="Estimate sample rate offset and resample (dynamic fractional interpolation)") parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0), help="select USRP Rx side A or B [default=A]") parser.add_option("-f", "--freq", type="eng_float", default=227.36e6, help="set frequency to FREQ [default=%default]") parser.add_option("-d", "--decim", type="intx", default=32, help="set decimation rate to DECIM [default=%default]") parser.add_option("-g", "--rx-gain", type="eng_float", default=None, help="set receive gain in dB (default is midpoint)") parser.add_option('-v', '--verbose', action="store_true", default=False, help="verbose output") (options, args) = parser.parse_args () # if len(args)!=1: # parser.print_help() # sys.exit(1) # else: # self.filename = args[0] # if gr.enable_realtime_scheduling() != gr.RT_OK: # print "-> failed to enable realtime scheduling" self.verbose = options.verbose self.src = usrp.source_c(decim_rate=options.decim) self.src.set_mux(usrp.determine_rx_mux_value(self.src, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.src, options.rx_subdev_spec) print "--> using RX dboard " + self.subdev.side_and_name() self.sample_rate = self.src.adc_rate()/options.decim self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose) self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude) self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=options.verbose) # self.sink = gr.file_sink(gr.sizeof_char*384, self.filename) # self.trigsink = gr.null_sink(gr.sizeof_char) # self.connect(self.src, self.demod, self.sink) # self.connect((self.demod,1), self.trigsink) self.fic_dec = dab.fic_decode(self.dab_params) self.connect(self.src, self.demod, (self.fic_dec,0)) self.connect((self.demod,1), (self.fic_dec,1)) # tune frequency self.frequency = options.freq self.set_freq(options.freq) # set gain if options.rx_gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.rx_gain = float(g[0]+g[1])/2 self.subdev.set_gain(options.rx_gain) self.update_ui = options.verbose if self.update_ui: self.run_ui_update_thread = True self.ui_updater = threading.Timer(0.1,self.update_ui_function) self.ui_updater.setDaemon(True) self.ui_updater.start() self.correct_ffe_usrp = options.correct_ffe_usrp if self.correct_ffe_usrp: print "--> correcting FFE on USRP" self.run_correct_ffe_thread = True self.ffe_updater = threading.Timer(0.1, self.correct_ffe) self.ffe_updater.setDaemon(True) self.ffe_updater.start()
def __init__(self, dab_mode, frequency, bit_rate, address, size, protection, audio_bit_rate, dabplus, use_usrp, src_path, sink_path="None"): gr.top_block.__init__(self) self.dab_mode = dab_mode self.verbose = False self.sample_rate = 2e6 self.dabplus = dabplus self.use_usrp = use_usrp self.src_path = src_path self.sink_path = sink_path gr.log.set_level("warn") ######################## # source ######################## if self.use_usrp: self.src = uhd.usrp_source("", uhd.io_type.COMPLEX_FLOAT32, 1) self.src.set_samp_rate(self.sample_rate) self.src.set_antenna("TX/RX") else: print "using file source" self.src = blocks.file_source_make(gr.sizeof_gr_complex, self.src_path, False) # set paramters to default mode self.softbits = True self.filter_input = True self.autocorrect_sample_rate = False self.resample_fixed = 1 self.correct_ffe = True self.equalize_magnitude = True self.frequency = frequency self.dab_params = dab.parameters.dab_parameters( self.dab_mode, self.sample_rate, self.verbose) self.rx_params = dab.parameters.receiver_parameters( self.dab_mode, self.softbits, self.filter_input, self.autocorrect_sample_rate, self.resample_fixed, self.verbose, self.correct_ffe, self.equalize_magnitude) ######################## # FFT and waterfall plot ######################## self.fft_plot = qtgui.freq_sink_c_make(1024, fft.window.WIN_BLACKMAN_HARRIS, self.frequency, 2e6, "FFT") self.waterfall_plot = qtgui.waterfall_sink_c_make( 1024, fft.window.WIN_BLACKMAN_HARRIS, self.frequency, 2e6, "Waterfall") #self.time_plot = qtgui.time_sink_c_make(1024, 2e6, "Time") ######################## # OFDM demod ######################## self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, self.verbose) ######################## # SNR measurement ######################## self.v2s_snr = blocks.vector_to_stream_make( gr.sizeof_gr_complex, self.dab_params.num_carriers) self.snr_measurement = digital.mpsk_snr_est_cc_make( digital.SNR_EST_SIMPLE, 10000) self.constellation_plot = qtgui.const_sink_c_make(1024, "", 1) ######################## # FIC decoder ######################## self.fic_dec = dab.fic_decode(self.dab_params) ######################## # MSC decoder ######################## if self.dabplus: self.dabplus = dab.dabplus_audio_decoder_ff( self.dab_params, bit_rate, address, size, protection, True) else: self.msc_dec = dab.msc_decode(self.dab_params, address, size, protection) self.unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) self.mp2_dec = dab.mp2_decode_bs_make(bit_rate / 8) self.s2f_left = blocks.short_to_float_make(1, 32767) self.s2f_right = blocks.short_to_float_make(1, 32767) self.gain_left = blocks.multiply_const_ff(1, 1) self.gain_right = blocks.multiply_const_ff(1, 1) ######################## # audio sink ######################## self.valve_left = dab.valve_ff_make(True) self.valve_right = dab.valve_ff_make(True) self.audio = audio.sink_make(audio_bit_rate) self.wav_sink = blocks.wavfile_sink_make("dab_audio.wav", 2, audio_bit_rate) ######################## # Connections ######################## self.connect(self.src, self.fft_plot) self.connect(self.src, self.waterfall_plot) self.connect(self.src, self.demod, (self.fic_dec, 0)) self.connect((self.demod, 1), (self.fic_dec, 1)) if self.dabplus: self.connect((self.demod, 0), (self.dabplus, 0)) self.connect((self.demod, 1), (self.dabplus, 1)) else: self.connect((self.demod, 0), (self.msc_dec, 0), self.unpack, self.mp2_dec) self.connect((self.demod, 1), (self.msc_dec, 1)) self.connect((self.mp2_dec, 0), self.s2f_left, self.gain_left) self.connect((self.mp2_dec, 1), self.s2f_right, self.gain_right) self.connect((self.demod, 0), self.v2s_snr, self.snr_measurement, self.constellation_plot) # connect audio to sound card and file sink if self.dabplus: self.connect((self.dabplus, 0), (self.audio, 0)) self.connect((self.dabplus, 1), (self.audio, 1)) self.connect((self.dabplus, 0), self.valve_left, (self.wav_sink, 0)) self.connect((self.dabplus, 1), self.valve_right, (self.wav_sink, 1)) else: self.connect(self.gain_left, (self.audio, 0)) self.connect(self.gain_right, (self.audio, 1)) self.connect(self.gain_left, self.valve_left, (self.wav_sink, 0)) self.connect(self.gain_right, self.valve_right, (self.wav_sink, 1)) # tune USRP frequency if self.use_usrp: self.set_freq(self.frequency) # set gain # if no gain was specified, use the mid-point in dB g = self.src.get_gain_range() self.rx_gain = float(g.start() + g.stop()) / 2 self.src.set_gain(self.rx_gain)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) self.frame = frame self.panel = panel parser = OptionParser(option_class=eng_option, usage="%prog: [options] <filename>") parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option('-c', '--correct-ffe', action="store_true", default=False, help="do fine frequency correction") parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False, help="do fine frequency correction by retuning the USRP instead of in software") parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False, help="do magnitude equalization") parser.add_option("-s", "--resample-fixed", type="eng_float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False, help="Estimate sample rate offset and resample (dynamic fractional interpolation)") parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0), help="select USRP Rx side A or B [default=A]") parser.add_option("-f", "--freq", type="eng_float", default=227.36e6, help="set frequency to FREQ [default=%default]") parser.add_option("-r", "--sample-rate", type="int", default=2000000, help="set sample rate to SAMPLE_RATE [default=%default]") parser.add_option("-d", "--decim", type="intx", default=32, help="set decimation rate to DECIM [default=%default]") parser.add_option("-g", "--rx-gain", type="eng_float", default=None, help="set receive gain in dB (default is midpoint)") parser.add_option('-v', '--verbose', action="store_true", default=False, help="verbose output") (options, args) = parser.parse_args() self.verbose = options.verbose if len(args) == 0: if self.verbose: print "--> receiving from USRP" self.src = usrp.source_c(decim_rate=options.decim) self.src.set_mux(usrp.determine_rx_mux_value(self.src, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.src, options.rx_subdev_spec) if self.verbose: print "--> using RX dboard " + self.subdev.side_and_name() # tune frequency self.frequency = options.freq self.set_freq(options.freq) # set gain if options.rx_gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.rx_gain = float(g[0]+g[1])/2 self.subdev.set_gain(options.rx_gain) self.sample_rate = self.src.adc_rate()/options.decim else: if self.verbose: print "--> receiving from file: " + args[0] self.filename = args[0] self.src = gr.file_source(gr.sizeof_gr_complex, self.filename, False) self.sample_rate = options.sample_rate self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose) self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude) self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=self.verbose) self.v2s = gr.vector_to_stream(gr.sizeof_gr_complex, self.dab_params.num_carriers) self.scope = scopesink2.scope_sink_c(self.panel, title="DAB constellation sink", sample_rate=self.dab_params.sample_rate, xy_mode=True) self.trigsink = gr.null_sink(gr.sizeof_char) self.sink = gr.null_sink(gr.sizeof_float*self.dab_params.num_carriers*2) self.connect(self.src, self.demod, self.sink) self.connect((self.demod,1), self.trigsink) # build GUI self.connect(self.demod.deinterleave, self.v2s, self.scope) vbox.Add(self.scope.win, 10, wx.EXPAND) # retune USRP to correct FFE? self.correct_ffe_usrp = options.correct_ffe_usrp if self.correct_ffe_usrp: print "--> correcting FFE on USRP" self.run_correct_ffe_thread = True self.ffe_updater = threading.Timer(0.1, self.correct_ffe) self.ffe_updater.setDaemon(True) self.ffe_updater.start()
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option, usage="%prog: [options] output-filename") parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option('-c', '--correct-ffe', action="store_true", default=False, help="do fine frequency correction") parser.add_option( '-u', '--correct-ffe-usrp', action="store_true", default=False, help= "do fine frequency correction by retuning the USRP instead of in software" ) parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False, help="do magnitude equalization") parser.add_option( "-s", "--resample-fixed", type="eng_float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option( "-S", "--autocorrect-sample-rate", action="store_true", default=False, help= "Estimate sample rate offset and resample (dynamic fractional interpolation)" ) parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0), help="select USRP Rx side A or B [default=A]") parser.add_option("-f", "--freq", type="eng_float", default=227.36e6, help="set frequency to FREQ [default=%default]") parser.add_option( "-d", "--decim", type="intx", default=32, help="set decimation rate to DECIM [default=%default]") parser.add_option("-g", "--rx-gain", type="eng_float", default=None, help="set receive gain in dB (default is midpoint)") parser.add_option('-v', '--verbose', action="store_true", default=False, help="verbose output") parser.add_option('-a', '--antenna', type="string", default="TX/RX", help="select antenna") (options, args) = parser.parse_args() # if len(args)!=1: # parser.print_help() # sys.exit(1) # else: # self.filename = args[0] # if gr.enable_realtime_scheduling() != gr.RT_OK: # print "-> failed to enable realtime scheduling" self.verbose = options.verbose self.src = uhd.usrp_source("", uhd.io_type.COMPLEX_FLOAT32, 1) #self.src.set_mux(usrp.determine_rx_mux_value(self.src, options.rx_subdev_spec)) #self.subdev = uhd.selected_subdev(self.src, options.rx_subdev_spec) #print "--> using RX dboard " + self.subdev.side_and_name() self.sample_rate = 2e6 #self.src.adc_rate()/options.decim self.src.set_samp_rate(self.sample_rate) self.src.set_antenna(options.antenna) self.dab_params = dab.parameters.dab_parameters( mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose) self.rx_params = dab.parameters.receiver_parameters( mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude) self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=options.verbose) # self.sink = gr.file_sink(gr.sizeof_char*384, self.filename) # self.trigsink = gr.null_sink(gr.sizeof_char) # self.connect(self.src, self.demod, self.sink) # self.connect((self.demod,1), self.trigsink) self.fic_dec = dab.fic_decode(self.dab_params) self.connect(self.src, self.demod, (self.fic_dec, 0)) self.connect((self.demod, 1), (self.fic_dec, 1)) # tune frequency self.frequency = options.freq self.set_freq(options.freq) # set gain if options.rx_gain is None: # if no gain was specified, use the mid-point in dB g = self.src.get_gain_range() options.rx_gain = float(g.start() + g.stop()) / 2 self.src.set_gain(options.rx_gain) #self.subdev.set_gain(options.rx_gain) self.update_ui = options.verbose if self.update_ui: self.run_ui_update_thread = True self.ui_updater = threading.Timer(0.1, self.update_ui_function) self.ui_updater.setDaemon(True) self.ui_updater.start() self.correct_ffe_usrp = options.correct_ffe_usrp if self.correct_ffe_usrp: print "--> correcting FFE on USRP" self.run_correct_ffe_thread = True self.ffe_updater = threading.Timer(0.1, self.correct_ffe) self.ffe_updater.setDaemon(True) self.ffe_updater.start()
def __init__(self, frequency, bit_rate, address, size, protection, use_usrp, src_path, record_audio = False, sink_path = "None"): gr.top_block.__init__(self) self.dab_mode = 1 self.verbose = False self.sample_rate = 2e6 self.use_usrp = use_usrp self.src_path = src_path self.record_audio = record_audio self.sink_path = sink_path ######################## # source ######################## if self.use_usrp: self.src = uhd.usrp_source("", uhd.io_type.COMPLEX_FLOAT32, 1) self.src.set_samp_rate(self.sample_rate) self.src.set_antenna("TX/RX") else: print "using file source" self.src = blocks.file_source_make(gr.sizeof_gr_complex, self.src_path, True) # set paramters to default mode self.softbits = True self.filter_input = True self.autocorrect_sample_rate = False self.resample_fixed = 1 self.correct_ffe = True self.equalize_magnitude = True self.frequency = frequency self.dab_params = dab.parameters.dab_parameters(self.dab_mode, self.sample_rate, self.verbose) self.rx_params = dab.parameters.receiver_parameters(self.dab_mode, self.softbits, self.filter_input, self.autocorrect_sample_rate, self.resample_fixed, self.verbose, self.correct_ffe, self.equalize_magnitude) ######################## # OFDM demod ######################## self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, self.verbose) ######################## # SNR measurement ######################## self.v2s_snr = blocks.vector_to_stream_make(gr.sizeof_gr_complex, 1536) self.snr_measurement = digital.mpsk_snr_est_cc_make(digital.SNR_EST_SIMPLE, 10000) self.null_sink_snr = blocks.null_sink_make(gr.sizeof_gr_complex) ######################## # FIC decoder ######################## self.fic_dec = dab.fic_decode(self.dab_params) ######################## # MSC decoder and audio sink ######################## self.dabplus = dab.dabplus_audio_decoder_ff(self.dab_params, bit_rate, address, size, protection, True) self.audio = audio.sink_make(32000) ######################## # Connections ######################## self.connect(self.src, self.demod, (self.fic_dec, 0)) self.connect((self.demod, 1), (self.fic_dec, 1)) self.connect((self.demod, 0), (self.dabplus, 0)) self.connect((self.demod, 1), (self.dabplus, 1)) self.connect((self.demod, 0), self.v2s_snr, self.snr_measurement, self.null_sink_snr) # connect audio to sound card # left stereo channel self.connect((self.dabplus, 0), (self.audio, 0)) # right stereo channel self.connect((self.dabplus, 1), (self.audio, 1)) # connect file sink if recording is selected if self.record_audio: self.sink = blocks.wavfile_sink_make("dab_audio.wav", 2, 32000) self.connect((self.dabplus, 0), (self.sink, 0)) self.connect((self.dabplus, 1), (self.sink, 1)) # tune USRP frequency if self.use_usrp: self.set_freq(self.frequency) # set gain # if no gain was specified, use the mid-point in dB g = self.src.get_gain_range() self.rx_gain = float(g.start() + g.stop()) / 2 self.src.set_gain(self.rx_gain)