def __init__(self, dab_params): gr.hier_block2.__init__( self, "fic_encode", gr.io_signature(1, 1, gr.sizeof_char), # Input signature gr.io_signature(1, 1, gr.sizeof_char)) # Output signature self.dp = dab_params # crc self.unpacked_to_packed_crc = blocks.unpacked_to_packed_bb_make( 1, gr.GR_MSB_FIRST) self.s2v_crc = blocks.stream_to_vector(gr.sizeof_char, 32) self.crc16 = dab.crc16_bb(32, 0x1021, 0xffff) self.v2s_crc = blocks.vector_to_stream(gr.sizeof_char, 32) self.packed_to_unpacked_crc = blocks.packed_to_unpacked_bb_make( 1, gr.GR_MSB_FIRST) # energy dispersal self.prbs_src = blocks.vector_source_b( self.dp.prbs(self.dp.energy_dispersal_fic_vector_length), True) self.add_mod_2 = blocks.xor_bb() # convolutional encoder self.conv_pack = blocks.unpacked_to_packed_bb_make(1, gr.GR_MSB_FIRST) self.conv_encoder = dab.conv_encoder_bb_make( self.dp.energy_dispersal_fic_vector_length / 8) self.conv_unpack = blocks.packed_to_unpacked_bb_make( 1, gr.GR_MSB_FIRST) # puncturing self.puncture = dab.puncture_bb_make( self.dp.assembled_fic_puncturing_sequence) # pack bits self.unpacked_to_packed_encoded = blocks.unpacked_to_packed_bb_make( 1, gr.GR_MSB_FIRST) # connect everything self.connect((self, 0), self.unpacked_to_packed_crc, self.s2v_crc, self.crc16, self.v2s_crc, self.packed_to_unpacked_crc, (self.add_mod_2, 0), self.conv_pack, self.conv_encoder, self.conv_unpack, self.puncture, self.unpacked_to_packed_encoded, self) #connect prbs self.connect(self.prbs_src, (self.add_mod_2, 1))
def __init__(self, dab_params, bit_rate, address, subch_size, protection, output_float, verbose=False, debug=False): if output_float: # map short samples to the range [-1,1] in floats gr.hier_block2.__init__(self, "dab_audio_decoder_ff", # Input signature gr.io_signature(1, 1, gr.sizeof_float * dab_params.num_carriers * 2), # Output signature gr.io_signature2(2, 2, gr.sizeof_float, gr.sizeof_float)) else: # output signed 16 bit integers (directly from decoder) gr.hier_block2.__init__(self, "dab_audio_decoder_ff", # Input signature gr.io_signature(1, 1, gr.sizeof_float * dab_params.num_carriers * 2), # Output signature gr.io_signature2(2, 2, gr.sizeof_short, gr.sizeof_short)) self.msc_dec = grdab.msc_decode(dab_params, address, subch_size, protection) self.unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) self.mp2_dec = grdab.mp2_decode_bs_make(bit_rate / 8) self.connect((self, 0), self.msc_dec, self.unpack, self.mp2_dec) if output_float: # map short samples to the range [-1,1] in floats 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) self.connect((self.mp2_dec, 0), self.s2f_left, self.gain_left, (self, 0)) self.connect((self.mp2_dec, 1), self.s2f_right, self.gain_right, (self, 1)) else: # output signed 16 bit integers (directly from decoder) self.connect((self.mp2_dec, 0), (self, 0)) self.connect((self.mp2_dec, 1), (self, 1))
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/mp2_encoded.dat"): self.src_mp2 = blocks.file_source_make(gr.sizeof_char, "debug/mp2_encoded.dat") self.unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) self.mp2_decode = grdab.mp2_decode_bs_make(14) self.sink_left = blocks.file_sink_make(gr.sizeof_short, "debug/mp2_decoded_left.dat") self.sink_right = blocks.file_sink_make(gr.sizeof_short, "debug/mp2_decoded_right.dat") self.tb.connect(self.src_mp2, self.unpack, (self.mp2_decode, 0), self.sink_left) self.tb.connect((self.mp2_decode, 1), self.sink_right) self.tb.run() else: log = gr.logger("log") log.debug("debug file not found - skipped test") log.set_level("WARN") pass
def __init__(self, dab_params, bit_rate, address, subch_size, protection, output_float, verbose=False, debug=False): if output_float: # map short samples to the range [-1,1] in floats gr.hier_block2.__init__( self, "dab_audio_decoder_ff", # Input signature gr.io_signature(1, 1, gr.sizeof_float * dab_params.num_carriers * 2), # Output signature gr.io_signature2(2, 2, gr.sizeof_float, gr.sizeof_float)) else: # output signed 16 bit integers (directly from decoder) gr.hier_block2.__init__( self, "dab_audio_decoder_ff", # Input signature gr.io_signature(1, 1, gr.sizeof_float * dab_params.num_carriers * 2), # Output signature gr.io_signature2(2, 2, gr.sizeof_short, gr.sizeof_short)) self.msc_dec = grdab.msc_decode(dab_params, address, subch_size, protection) self.unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) self.mp2_dec = grdab.mp2_decode_bs_make(bit_rate / 8) self.connect((self, 0), self.msc_dec, self.unpack, self.mp2_dec) if output_float: # map short samples to the range [-1,1] in floats 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) self.connect((self.mp2_dec, 0), self.s2f_left, self.gain_left, (self, 0)) self.connect((self.mp2_dec, 1), self.s2f_right, self.gain_right, (self, 1)) else: # output signed 16 bit integers (directly from decoder) self.connect((self.mp2_dec, 0), (self, 0)) self.connect((self.mp2_dec, 1), (self, 1))
def test_001_t(self): if os.path.exists("debug/mp2_encoded.dat"): self.src_mp2 = blocks.file_source_make(gr.sizeof_char, "debug/mp2_encoded.dat") self.unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) self.mp2_decode = dab.mp2_decode_bs_make(14) self.sink_left = blocks.file_sink_make( gr.sizeof_short, "debug/mp2_decoded_left.dat") self.sink_right = blocks.file_sink_make( gr.sizeof_short, "debug/mp2_decoded_right.dat") self.tb.connect(self.src_mp2, self.unpack, (self.mp2_decode, 0), self.sink_left) self.tb.connect((self.mp2_decode, 1), self.sink_right) 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): self.symbol_length = 32*4 self.dab_params = dab_parameters(1, 208.064e6, True) # source self.dp = dab_parameters(1, 208.064e6, True) self.fib_src = dab.fib_source_b_make(1, 1, 1, "ensemble1", "service1 ", "musicmix", 4, [2], [15], [1]) # encoder self.fib_enc = fic_encode(self.dab_params) self.unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) # mapper 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 = fic_decode(self.dab_params) # control stream self.trigger_src = blocks.vector_source_b([1] + [0]*74, True) self.tb.connect(self.fib_src, blocks.head_make(gr.sizeof_char, 100000), self.fib_enc, self.unpack, self.map, self.s2v, self.soft_interleaver, self.fic_decoder ) self.tb.connect(self.trigger_src, (self.fic_decoder, 1)) self.tb.run () pass
def __init__(self, dab_params, data_rate_n, protection): gr.hier_block2.__init__(self, "msc_encode", gr.io_signature(1, 1, gr.sizeof_char), # Input signature gr.io_signature(1, 1, gr.sizeof_char)) # Output signature self.dp = dab_params self.n = data_rate_n self.msc_I = self.n * 192 self.protect = protection # unpack self.unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) # energy dispersal self.prbs_src = blocks.vector_source_b(self.dp.prbs(self.msc_I), True) self.add_mod_2 = blocks.xor_bb() # convolutional encoder self.conv_pack = blocks.unpacked_to_packed_bb_make(1, gr.GR_MSB_FIRST) self.conv_encoder = dab.conv_encoder_bb_make(self.msc_I / 8) self.conv_unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) # calculate puncturing factors (EEP, table 33, 34) if (self.n > 1 or self.protect != 1): self.puncturing_L1 = [6 * self.n - 3, 2 * self.n - 3, 6 * self.n - 3, 4 * self.n - 3] self.puncturing_L2 = [3, 4 * self.n + 3, 3, 2 * self.n + 3] self.puncturing_PI1 = [24, 14, 8, 3] self.puncturing_PI2 = [23, 13, 7, 2] # calculate length of punctured codeword (11.3.2) self.msc_punctured_codeword_length = self.puncturing_L1[self.protect] * 4 * self.dp.puncturing_vectors_ones[ self.puncturing_PI1[self.protect]] + self.puncturing_L2[self.protect] * 4 * \ self.dp.puncturing_vectors_ones[ self.puncturing_PI2[self.protect]] + 12 self.assembled_msc_puncturing_sequence = self.puncturing_L1[self.protect] * 4 * self.dp.puncturing_vectors[ self.puncturing_PI1[self.protect]] + self.puncturing_L2[self.protect] * 4 * self.dp.puncturing_vectors[ self.puncturing_PI2[self.protect]] + self.dp.puncturing_tail_vector self.msc_conv_codeword_length = 4 * self.msc_I + 24 # 4*I + 24 () # exception in table else: self.msc_punctured_codeword_length = 5 * 4 * self.dp.puncturing_vectors_ones[13] + 1 * 4 * \ self.dp.puncturing_vectors_ones[ 12] + 12 # sanity check assert (6 * self.n == self.puncturing_L1[self.protect] + self.puncturing_L2[self.protect]) # puncturing self.puncture = dab.puncture_bb_make(self.assembled_msc_puncturing_sequence) # time interleaving self.s2v_time_interleave = blocks.stream_to_vector_make(gr.sizeof_char, self.msc_punctured_codeword_length) self.time_interleaver = dab.time_interleave_bb_make(self.msc_punctured_codeword_length, self.dp.scrambling_vector) self.v2s_time_interleave = blocks.vector_to_stream_make(gr.sizeof_char, self.msc_punctured_codeword_length) # pack bits self.unpacked_to_packed_encoded = blocks.unpacked_to_packed_bb_make(1, gr.GR_MSB_FIRST) # connect everything self.connect(self, self.unpack, self.add_mod_2, self.conv_pack, self.conv_encoder, self.conv_unpack, self.puncture, self.s2v_time_interleave, self.time_interleaver, self.v2s_time_interleave, self.unpacked_to_packed_encoded, self) # connect prbs self.connect(self.prbs_src, (self.add_mod_2, 1))
def __init__(self, dab_params, verbose=False, debug=False): """ Hierarchical block for OFDM modulation @param dab_params DAB parameter object (grdab.parameters.dab_parameters) @param debug enables debug output to files """ dp = dab_params gr.hier_block2.__init__( self, "ofdm_mod", gr.io_signature2(2, 2, gr.sizeof_char * dp.num_carriers / 4, gr.sizeof_char), # input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # output signature # symbol mapping self.mapper_v2s = blocks.vector_to_stream_make(gr.sizeof_char, 384) self.mapper_unpack = blocks.packed_to_unpacked_bb_make( 1, gr.GR_MSB_FIRST) self.mapper = grdab.mapper_bc_make(dp.num_carriers) self.mapper_s2v = blocks.stream_to_vector_make(gr.sizeof_gr_complex, 1536) # add pilot symbol self.insert_pilot = grdab.ofdm_insert_pilot_vcc(dp.prn) # phase sum self.sum_phase = grdab.sum_phasor_trig_vcc(dp.num_carriers) # frequency interleaving self.interleave = grdab.frequency_interleaver_vcc( dp.frequency_interleaving_sequence_array) # add central carrier & move to middle self.move_and_insert_carrier = grdab.ofdm_move_and_insert_zero( dp.fft_length, dp.num_carriers) # ifft self.ifft = fft.fft_vcc(dp.fft_length, False, [], True) # cyclic prefixer self.prefixer = digital.ofdm_cyclic_prefixer(dp.fft_length, dp.symbol_length) # convert back to vectors self.s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, dp.symbol_length) # add null symbol self.insert_null = grdab.insert_null_symbol(dp.ns_length, dp.symbol_length) # # connect it all # # data self.connect((self, 0), self.mapper_v2s, self.mapper_unpack, self.mapper, self.mapper_s2v, (self.insert_pilot, 0), (self.sum_phase, 0), self.interleave, self.move_and_insert_carrier, self.ifft, self.prefixer, self.s2v, (self.insert_null, 0)) self.connect(self.insert_null, self) # control signal (frame start) self.connect((self, 1), (self.insert_pilot, 1), (self.sum_phase, 1), (self.insert_null, 1)) if debug: #self.connect(self.mapper, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/generated_signal_mapper.dat")) self.connect( self.insert_pilot, blocks.file_sink(gr.sizeof_gr_complex * dp.num_carriers, "debug/generated_signal_insert_pilot.dat")) self.connect( self.sum_phase, blocks.file_sink(gr.sizeof_gr_complex * dp.num_carriers, "debug/generated_signal_sum_phase.dat")) self.connect( self.interleave, blocks.file_sink(gr.sizeof_gr_complex * dp.num_carriers, "debug/generated_signal_interleave.dat")) self.connect( self.move_and_insert_carrier, blocks.file_sink( gr.sizeof_gr_complex * dp.fft_length, "debug/generated_signal_move_and_insert_carrier.dat")) self.connect( self.ifft, blocks.file_sink(gr.sizeof_gr_complex * dp.fft_length, "debug/generated_signal_ifft.dat")) self.connect( self.prefixer, blocks.file_sink(gr.sizeof_gr_complex, "debug/generated_signal_prefixer.dat")) self.connect( self.insert_null, blocks.file_sink(gr.sizeof_gr_complex, "debug/generated_signal.dat"))
def __init__(self, dab_params, verbose=False, debug=False): """ Hierarchical block for OFDM modulation @param dab_params DAB parameter object (grdab.parameters.dab_parameters) @param debug enables debug output to files """ dp = dab_params gr.hier_block2.__init__(self,"ofdm_mod", gr.io_signature2(2, 2, gr.sizeof_char*dp.num_carriers/4, gr.sizeof_char), # input signature gr.io_signature (1, 1, gr.sizeof_gr_complex)) # output signature # symbol mapping self.mapper_v2s = blocks.vector_to_stream_make(gr.sizeof_char, 384) self.mapper_unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST) self.mapper = grdab.mapper_bc_make(dp.num_carriers) self.mapper_s2v = blocks.stream_to_vector_make(gr.sizeof_gr_complex, 1536) # add pilot symbol self.insert_pilot = grdab.ofdm_insert_pilot_vcc(dp.prn) # phase sum self.sum_phase = grdab.sum_phasor_trig_vcc(dp.num_carriers) # frequency interleaving self.interleave = grdab.frequency_interleaver_vcc(dp.frequency_interleaving_sequence_array) # add central carrier & move to middle self.move_and_insert_carrier = grdab.ofdm_move_and_insert_zero(dp.fft_length, dp.num_carriers) # ifft self.ifft = fft.fft_vcc(dp.fft_length, False, [], True) # cyclic prefixer self.prefixer = digital.ofdm_cyclic_prefixer(dp.fft_length, dp.symbol_length) # convert back to vectors self.s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, dp.symbol_length) # add null symbol self.insert_null = grdab.insert_null_symbol(dp.ns_length, dp.symbol_length) # # connect it all # # data self.connect((self,0), self.mapper_v2s, self.mapper_unpack, self.mapper, self.mapper_s2v, (self.insert_pilot,0), (self.sum_phase,0), self.interleave, self.move_and_insert_carrier, self.ifft, self.prefixer, self.s2v, (self.insert_null,0)) self.connect(self.insert_null, self) # control signal (frame start) self.connect((self,1), (self.insert_pilot,1), (self.sum_phase,1), (self.insert_null,1)) if debug: #self.connect(self.mapper, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/generated_signal_mapper.dat")) self.connect(self.insert_pilot, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/generated_signal_insert_pilot.dat")) self.connect(self.sum_phase, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/generated_signal_sum_phase.dat")) self.connect(self.interleave, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/generated_signal_interleave.dat")) self.connect(self.move_and_insert_carrier, blocks.file_sink(gr.sizeof_gr_complex*dp.fft_length, "debug/generated_signal_move_and_insert_carrier.dat")) self.connect(self.ifft, blocks.file_sink(gr.sizeof_gr_complex*dp.fft_length, "debug/generated_signal_ifft.dat")) self.connect(self.prefixer, blocks.file_sink(gr.sizeof_gr_complex, "debug/generated_signal_prefixer.dat")) self.connect(self.insert_null, blocks.file_sink(gr.sizeof_gr_complex, "debug/generated_signal.dat"))
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)