def test_001_t(self): if os.path.exists("debug/PCM_left.dat") and os.path.exists( "debug/PCM_right.dat"): self.src_left = blocks.file_source_make(gr.sizeof_float, "debug/PCM_left.dat") self.src_right = blocks.file_source_make(gr.sizeof_float, "debug/PCM_right.dat") self.f2s_1 = blocks.float_to_short_make(1, 32767) self.f2s_2 = blocks.float_to_short_make(1, 32767) self.mp4_encode = dab.mp4_encode_sb_make(14, 2, 32000, 1) self.mp4_decode = dab.mp4_decode_bs_make(14) self.s2f_1 = blocks.short_to_float_make(1, 32767) self.s2f_2 = blocks.short_to_float_make(1, 32767) self.audio = audio.sink_make(32000) self.tb.connect(self.src_left, self.f2s_1, (self.mp4_encode, 0)) self.tb.connect(self.src_right, self.f2s_2, (self.mp4_encode, 1)) self.tb.connect(self.mp4_encode, self.mp4_decode, self.s2f_1, (self.audio, 0)) self.tb.connect((self.mp4_decode, 1), self.s2f_2, (self.audio, 1)) self.tb.run() # check data else: log = gr.logger("log") log.debug("debug file not found - skipped test") log.set_level("WARN")
def test_001_t (self): if os.path.exists("debug/transmission_frame.dat") and os.path.exists("debug/transmission_frame_trigger.dat"): self.dab_params = dab.parameters.dab_parameters(1, 208.064e6, True) self.src01 = blocks.file_source_make(gr.sizeof_float * 2 * self.dab_params.num_carriers, "debug/transmission_frame.dat") self.src02 = blocks.file_source_make(gr.sizeof_char, "debug/transmission_frame_trigger.dat") self.dabplus = dab.dabplus_audio_decoder_ff(self.dab_params, 112, 54, 84, 2, True, False, True) self.wav_sink = blocks.wavfile_sink_make("debug/music.wav", 2, 32000) self.file_sink_left = blocks.file_sink_make(gr.sizeof_float, "debug/PCM_left.dat") self.file_sink_right = blocks.file_sink_make(gr.sizeof_float, "debug/PCM_right.dat") self.tb.connect(self.src01, (self.dabplus, 0), self.file_sink_left) self.tb.connect(self.src02, (self.dabplus, 1), self.file_sink_right) self.tb.connect((self.dabplus, 0), (self.wav_sink, 0)) self.tb.connect((self.dabplus, 1), (self.wav_sink, 1)) self.audio = audio.sink_make(32000) self.tb.connect((self.dabplus, 0), (self.audio, 0)) self.tb.connect((self.dabplus, 1), (self.audio, 1)) self.tb.run() else: log = gr.logger("log") log.debug("debug file not found - skipped test") log.set_level("WARN") pass
def test_001_t (self): if os.path.exists("debug/transmission_frame.dat") and os.path.exists("debug/transmission_frame_trigger.dat"): self.dab_params = grdab.parameters.dab_parameters(1, 208.064e6, True) self.src01 = blocks.file_source_make(gr.sizeof_float * 2 * self.dab_params.num_carriers, "debug/transmission_frame.dat") self.src02 = blocks.file_source_make(gr.sizeof_char, "debug/transmission_frame_trigger.dat") self.dabplus = grdab.dabplus_audio_decoder_ff(self.dab_params, 112, 54, 84, 2, True, False, True) self.wav_sink = blocks.wavfile_sink_make("debug/music.wav", 2, 32000) self.file_sink_left = blocks.file_sink_make(gr.sizeof_float, "debug/PCM_left.dat") self.file_sink_right = blocks.file_sink_make(gr.sizeof_float, "debug/PCM_right.dat") self.tb.connect(self.src01, (self.dabplus, 0), self.file_sink_left) self.tb.connect(self.src02, (self.dabplus, 1), self.file_sink_right) self.tb.connect((self.dabplus, 0), (self.wav_sink, 0)) self.tb.connect((self.dabplus, 1), (self.wav_sink, 1)) self.audio = audio.sink_make(32000) self.tb.connect((self.dabplus, 0), (self.audio, 0)) self.tb.connect((self.dabplus, 1), (self.audio, 1)) self.tb.run() else: log = gr.logger("log") log.debug("debug file not found - skipped test") log.set_level("WARN") pass
def test_001_t (self): log = gr.logger("log") if os.path.exists("debug/rs_encoded.dat") and os.path.exists("debug/rs_encoded.dat"): self.dp = dab.parameters.dab_parameters(1, 208.064e6, True) # sources self.fib_src = dab.fib_source_b_make(1, 1, 'Galaxy_News', 'Wasteland_Radio', 'Country_Mix01', 0x09, [2], [14]) self.fib_pack = blocks.unpacked_to_packed_bb_make(1, gr.GR_MSB_FIRST) self.subch_src01 = blocks.file_source_make(gr.sizeof_char, "debug/rs_encoded.dat", True) self.subch_src02 = blocks.file_source_make(gr.sizeof_char, "debug/rs_encoded_2.dat", True) # encoder self.fib_enc = dab.fic_encode(self.dp) self.msc_encoder = dab.msc_encode(self.dp, 14, 2) self.msc_encoder2 = dab.msc_encode(self.dp, 14, 2) # multiplexer self.mux = dab.dab_transmission_frame_mux_bb_make(1, 2, [84, 84]) # mapper self.unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) self.map = dab.mapper_bc_make(self.dp.num_carriers) # demapper self.s2v = blocks.stream_to_vector_make(gr.sizeof_gr_complex, self.dp.num_carriers) self.soft_interleaver = dab.complex_to_interleaved_float_vcf_make(self.dp.num_carriers) # decode self.fic_decoder = dab.fic_decode(self.dp) self.msc_dec = dab.dabplus_audio_decoder_ff(self.dp, 112, 0, 84, 2, True) # audio sink self.audio = audio.sink_make(32000) # control stream self.trigger_src = blocks.vector_source_b([1] + [0] * 74, True) # connect everything self.tb.connect(self.fib_src, self.fib_enc, (self.mux, 0)) self.tb.connect(self.subch_src01, self.msc_encoder, (self.mux, 1)) self.tb.connect(self.subch_src02, self.msc_encoder2, (self.mux, 2)) self.tb.connect((self.mux, 0), self.unpack, self.map, self.s2v, self.soft_interleaver, (self.msc_dec, 0)) self.tb.connect(self.soft_interleaver, (self.fic_decoder, 0)) self.tb.connect(self.trigger_src, (self.fic_decoder, 1)) self.tb.connect(self.trigger_src, (self.msc_dec, 1)) self.tb.connect((self.msc_dec, 0), (self.audio, 0)) self.tb.connect((self.msc_dec, 1), (self.audio, 1)) self.tb.run () pass else: log.debug("debug file not found - skipped test") log.set_level("WARN") pass
def test_001_t (self): if os.path.exists("debug/reed_solomon_repaired.dat"): self.src = blocks.file_source_make(gr.sizeof_char, "debug/reed_solomon_repaired.dat") self.mp4 = grdab.mp4_decode_bs_make(14) self.s2f_left = blocks.short_to_float_make(1, 32767) self.s2f_right = blocks.short_to_float_make(1, 32767) self.audio = audio.sink_make(32000) self.tb.connect(self.src, (self.mp4, 0), self.s2f_left, (self.audio, 0)) self.tb.connect((self.mp4, 1), self.s2f_right, (self.audio, 1)) self.tb.run() else: log = gr.logger("log") log.debug("debug file not found - skipped test") log.set_level("WARN") pass
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 = grdab.parameters.dab_parameters( mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose) self.rx_params = grdab.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 = grdab.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 = grdab.fic_decode(self.dab_params) self.connect(self.src, self.demod, self.fic_dec) # add MSC chain self.dabplus = grdab.dabplus_audio_decoder_ff(self.dab_params, 112, 54, 84, 2, True) self.audio = audio.sink_make(32000) self.connect(self.demod, self.dabplus) # left stereo channel self.connect((self.dabplus, 0), (self.audio, 0)) # right stereo channel self.connect((self.dabplus, 1), (self.audio, 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, num_subch, ensemble_label, service_label, language, protections, data_rates_n, src_paths, selected_audio, use_usrp, sink_path="dab_iq_generated.dat"): gr.top_block.__init__(self) self.dab_mode = 1 self.frequency = frequency interp = 64 self.sample_rate = 128e6 / interp self.dp = dab.parameters.dab_parameters(self.dab_mode, 2000000, False) self.num_subch = num_subch self.ensemble_label = ensemble_label self.service_label = service_label self.language = language self.protections = protections self.data_rates_n = data_rates_n self.subch_sizes = np.multiply(self.data_rates_n, 6) self.src_paths = src_paths self.use_usrp = use_usrp self.sink_path = sink_path self.selected_audio = selected_audio self.volume = 80 ######################## # FIC ######################## # source self.fic_src = dab.fib_source_b_make(self.dab_mode, self.num_subch, self.ensemble_label, self.service_label, "", self.language, self.protections, self.data_rates_n) # encoder self.fic_enc = dab.fic_encode(self.dp) ######################## # MSC ######################## self.msc_sources = [None] * self.num_subch self.f2s_left_converters = [None] * self.num_subch self.f2s_right_converters = [None] * self.num_subch self.mp4_encoders = [None] * self.num_subch self.rs_encoders = [None] * self.num_subch self.msc_encoders = [None] * self.num_subch for i in range(0, self.num_subch): # source self.msc_sources[i] = blocks.wavfile_source_make( self.src_paths[i], True) # float to short self.f2s_left_converters[i] = blocks.float_to_short_make(1, 32767) self.f2s_right_converters[i] = blocks.float_to_short_make(1, 32767) # mp4 encoder and Reed-Solomon encoder self.mp4_encoders[i] = dab.mp4_encode_sb_make( self.data_rates_n[i], 2, 32000, 1) self.rs_encoders[i] = dab.reed_solomon_encode_bb_make( self.data_rates_n[i]) # encoder self.msc_encoders[i] = dab.msc_encode(self.dp, self.data_rates_n[i], self.protections[i]) ######################## # MUX ######################## self.mux = dab.dab_transmission_frame_mux_bb_make( self.dab_mode, self.num_subch, self.subch_sizes) #self.mux = dab.dab_transmission_frame_mux_bb_make(1, 1, [84, 84]) self.trigsrc = blocks.vector_source_b([1] + [0] * 74, True) ######################## # Modulator ######################## self.s2v_mod = blocks.stream_to_vector(gr.sizeof_char, 384) self.mod = dab.ofdm_mod(self.dp) ######################## # Sink ######################## if self.use_usrp: self.sink = uhd.usrp_sink("", uhd.io_type.COMPLEX_FLOAT32, 1) self.sink.set_samp_rate(self.sample_rate) self.sink.set_antenna("TX/RX") self.sink.set_center_freq(self.frequency) else: self.sink = blocks.file_sink_make(gr.sizeof_gr_complex, self.sink_path) # audio sink self.audio = audio.sink_make(32000) self.gain_left = blocks.multiply_const_ff_make(1, 1) self.gain_right = blocks.multiply_const_ff_make(1, 1) ######################## # Connections ######################## self.connect(self.fic_src, self.fic_enc, (self.mux, 0)) for i in range(0, self.num_subch): self.connect((self.msc_sources[i], 0), self.f2s_left_converters[i], (self.mp4_encoders[i], 0), self.rs_encoders[i], self.msc_encoders[i], (self.mux, i + 1)) self.connect((self.msc_sources[i], 1), self.f2s_right_converters[i], (self.mp4_encoders[i], 1)) self.connect((self.mux, 0), self.s2v_mod, (self.mod, 0)) self.connect(self.trigsrc, (self.mod, 1)) self.connect(self.mod, self.sink) self.connect((self.msc_sources[self.selected_audio - 1], 0), self.gain_left, (self.audio, 0)) self.connect((self.msc_sources[self.selected_audio - 1], 1), self.gain_right, (self.audio, 1))
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, dab_mode, frequency, num_subch, ensemble_label, service_label, language, country_ID, protections, data_rates_n, stereo_flags, audio_sampling_rates, src_paths, selected_audio, use_usrp, dabplus_types, sink_path="dab_iq_generated.dat"): gr.top_block.__init__(self) self.dab_mode = dab_mode self.frequency = frequency interp = 64 self.sample_rate = 128e6 / interp self.dp = dab.parameters.dab_parameters(self.dab_mode, 2000000, False) self.num_subch = num_subch self.ensemble_label = ensemble_label self.service_label = service_label self.language = language self.protections = protections self.data_rates_n = data_rates_n self.src_paths = src_paths self.use_usrp = use_usrp self.dabplus_types = dabplus_types self.sink_path = sink_path self.selected_audio = selected_audio self.volume = 80 sizes = {0: 12, 1: 8, 2: 6, 3: 4} self.subch_sizes = [None] * len(self.data_rates_n) for i in range(0, len(self.data_rates_n)): self.subch_sizes[i] = self.data_rates_n[i] * sizes[protections[i]] ######################## # FIC ######################## # source self.fic_src = dab.fib_source_b_make( self.dab_mode, country_ID, self.num_subch, self.ensemble_label, self.service_label, "", self.language, self.protections, self.data_rates_n, self.dabplus_types) # encoder self.fic_enc = dab.fic_encode(self.dp) ######################## # MSC ######################## self.recorder = audio.source_make(32000) self.msc_sources = [None] * self.num_subch self.f2s_left_converters = [None] * self.num_subch self.f2s_right_converters = [None] * self.num_subch self.mp4_encoders = [None] * self.num_subch self.mp2_encoders = [None] * self.num_subch self.rs_encoders = [None] * self.num_subch self.msc_encoders = [None] * self.num_subch for i in range(0, self.num_subch): if not self.src_paths[i] is "mic": # source self.msc_sources[i] = blocks.wavfile_source_make( self.src_paths[i], True) # float to short self.f2s_left_converters[i] = blocks.float_to_short_make(1, 32767) self.f2s_right_converters[i] = blocks.float_to_short_make(1, 32767) if self.dabplus_types[i] is 1: # mp4 encoder and Reed-Solomon encoder self.mp4_encoders[i] = dab.mp4_encode_sb_make( self.data_rates_n[i], 2, audio_sampling_rates[i], 1) self.rs_encoders[i] = dab.reed_solomon_encode_bb_make( self.data_rates_n[i]) else: # mp2 encoder self.mp2_encoders[i] = dab.mp2_encode_sb_make( self.data_rates_n[i], 2, audio_sampling_rates[i]) # encoder self.msc_encoders[i] = dab.msc_encode(self.dp, self.data_rates_n[i], self.protections[i]) ######################## # MUX ######################## self.mux = dab.dab_transmission_frame_mux_bb_make( self.dab_mode, self.num_subch, self.subch_sizes) self.trigsrc = blocks.vector_source_b( [1] + [0] * (self.dp.symbols_per_frame - 2), True) ######################## # Modulator ######################## self.s2v_mod = blocks.stream_to_vector(gr.sizeof_char, self.dp.num_carriers / 4) self.mod = dab.ofdm_mod(self.dp) ######################## # Sink ######################## if self.use_usrp: self.sink = uhd.usrp_sink("", uhd.io_type.COMPLEX_FLOAT32, 1) self.sink.set_samp_rate(self.sample_rate) self.sink.set_antenna("TX/RX") self.sink.set_center_freq(self.frequency) else: self.sink = blocks.file_sink_make(gr.sizeof_gr_complex, self.sink_path) # audio sink self.audio = audio.sink_make(32000) self.gain_left = blocks.multiply_const_ff_make(1, 1) self.gain_right = blocks.multiply_const_ff_make(1, 1) self.s2f_left = blocks.short_to_float_make(1, 32767) self.s2f_right = blocks.short_to_float_make(1, 32767) ######################## # Connections ######################## self.connect(self.fic_src, self.fic_enc, (self.mux, 0)) for i in range(0, self.num_subch): if self.dabplus_types[i] is 1: if self.src_paths[i] is "mic": self.connect( (self.recorder, 0), self.f2s_left_converters[i], (self.mp4_encoders[i], 0), self.rs_encoders[i], self.msc_encoders[i], (self.mux, i + 1)) if stereo_flags[i] == 0: self.connect((self.recorder, 1), self.f2s_right_converters[i], (self.mp4_encoders[i], 1)) else: self.connect(self.f2s_left_converters[i], (self.mp4_encoders[i], 1)) else: self.connect( (self.msc_sources[i], 0), self.f2s_left_converters[i], (self.mp4_encoders[i], 0), self.rs_encoders[i], self.msc_encoders[i], (self.mux, i + 1)) if stereo_flags[i] == 0: self.connect((self.msc_sources[i], 1), self.f2s_right_converters[i], (self.mp4_encoders[i], 1)) else: self.connect(self.f2s_left_converters[i], (self.mp4_encoders[i], 1)) else: self.connect((self.msc_sources[i], 0), self.f2s_left_converters[i], (self.mp2_encoders[i], 0), self.msc_encoders[i], (self.mux, i + 1)) if stereo_flags[i] == 0: self.connect((self.msc_sources[i], 1), self.f2s_right_converters[i], (self.mp2_encoders[i], 1)) else: self.connect(self.f2s_left_converters[i], (self.mp2_encoders[i], 1)) self.connect((self.mux, 0), self.s2v_mod, (self.mod, 0)) self.connect(self.trigsrc, (self.mod, 1)) if use_usrp: self.connect(self.mod, self.sink) else: self.connect(self.mod, blocks.throttle_make(gr.sizeof_gr_complex, 2e6), self.sink)
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 = grdab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose) self.rx_params = grdab.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 = grdab.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 = grdab.fic_decode(self.dab_params) self.connect(self.src, self.demod, self.fic_dec) # add MSC chain self.dabplus = grdab.dabplus_audio_decoder_ff(self.dab_params, 112, 54, 84, 2, True) self.audio = audio.sink_make(32000) self.connect(self.demod, self.dabplus) # left stereo channel self.connect((self.dabplus, 0), (self.audio, 0)) # right stereo channel self.connect((self.dabplus, 1), (self.audio, 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)