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/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.msc = dab.msc_decode(self.dab_params, 54, 84, 2, 1, 1) self.firecode = dab.firecode_check_bb_make(14) self.file_sink_subch_decoded = blocks.file_sink_make( gr.sizeof_char, "debug/subch_decoded.dat") self.file_sink_firecode_checked = blocks.file_sink_make( gr.sizeof_char, "debug/checked_firecode.dat") self.tb.connect(self.src01, (self.msc, 0), self.firecode, self.file_sink_firecode_checked) self.tb.connect(self.src02, (self.msc, 1)) self.tb.connect(self.msc, self.file_sink_subch_decoded) self.tb.run() 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 test_001_t (self): log = gr.logger("log") 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.msc = grdab.msc_decode(self.dab_params, 54, 84, 2, 1, 1) self.firecode = grdab.firecode_check_bb_make(14) self.file_sink_subch_decoded = blocks.file_sink_make(gr.sizeof_char, "debug/subch_decoded.dat") self.file_sink_firecode_checked = blocks.file_sink_make(gr.sizeof_char, "debug/checked_firecode.dat") self.tb.connect(self.src01, (self.msc, 0), self.firecode, self.file_sink_firecode_checked) self.tb.connect(self.src02, (self.msc, 1)) self.tb.connect(self.msc, self.file_sink_subch_decoded) self.tb.run () 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 = 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): if os.path.exists("debug/PCM_piano_left.dat") and os.path.exists( "debug/PCM_piano_right.dat"): self.src_left = blocks.file_source_make( gr.sizeof_short, "debug/PCM_piano_left.dat") self.src_right = blocks.file_source_make( gr.sizeof_short, "debug/PCM_piano_right.dat") self.mp2 = dab.mp2_encode_sb_make(14, 2, 48000) self.file_sink = blocks.file_sink_make(gr.sizeof_char, "debug/mp2_encoded.mp2") self.tb.connect(self.src_left, (self.mp2, 0), self.file_sink) self.tb.connect(self.src_right, (self.mp2, 1)) self.tb.run() # check data else: log = gr.logger("log") log.debug("debug file not found - skipped test") log.set_level("WARN") pass
def __init__(self, dab_params, address, size, protection, verbose=False, debug=False): gr.hier_block2.__init__(self, "msc_decode", # Input signature gr.io_signature(1, 1, gr.sizeof_float * dab_params.num_carriers * 2), # Output signature gr.io_signature(1, 1, gr.sizeof_char)) self.dp = dab_params self.address = address self.size = size self.protect = protection self.verbose = verbose self.debug = debug # calculate n factor (multiple of 8kbits etc.) self.n = self.size / self.dp.subch_size_multiple_n[self.protect] # calculate puncturing factors (EEP, table 33, 34) self.msc_I = self.n * 192 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]) # MSC selection and block partitioning # select OFDM carriers with MSC self.select_msc_syms = grdab.select_vectors(gr.sizeof_float, self.dp.num_carriers * 2, self.dp.num_msc_syms, self.dp.num_fic_syms) # repartition MSC data in CIFs (left out due to heavy burden for scheduler and not really necessary) #self.repartition_msc_to_CIFs = grdab.repartition_vectors_make(gr.sizeof_float, self.dp.num_carriers * 2, # self.dp.cif_bits, self.dp.num_msc_syms, # self.dp.num_cifs) #repartition MSC to CUs self.repartition_msc_to_cus = grdab.repartition_vectors_make(gr.sizeof_float, self.dp.num_carriers*2, self.dp.msc_cu_size, self.dp.num_msc_syms, self.dp.num_cus * self.dp.num_cifs) # select CUs of one subchannel of each CIF and form logical frame vector self.select_subch = grdab.select_subch_vfvf_make(self.dp.msc_cu_size, self.dp.msc_cu_size * self.size, self.address, self.dp.num_cus) # time deinterleaving self.time_v2s = blocks.vector_to_stream_make(gr.sizeof_float, self.dp.msc_cu_size * self.size) self.time_deinterleaver = grdab.time_deinterleave_ff_make(self.dp.msc_cu_size * self.size, self.dp.scrambling_vector) # unpuncture self.conv_v2s = blocks.vector_to_stream(gr.sizeof_float, self.msc_punctured_codeword_length) self.unpuncture = grdab.unpuncture_ff_make(self.assembled_msc_puncturing_sequence, 0) # convolutional decoding self.fsm = trellis.fsm(1, 4, [0133, 0171, 0145, 0133]) # OK (dumped to text and verified partially) table = [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 ] assert (len(table) / 4 == self.fsm.O()) table = [(1 - 2 * x) / sqrt(2) for x in table] self.conv_decode = trellis.viterbi_combined_fb(self.fsm, self.msc_I + self.dp.conv_code_add_bits_input, 0, 0, 4, table, trellis.TRELLIS_EUCLIDEAN) self.conv_s2v = blocks.stream_to_vector(gr.sizeof_char, self.msc_I + self.dp.conv_code_add_bits_input) self.conv_prune = grdab.prune(gr.sizeof_char, self.msc_conv_codeword_length / 4, 0, self.dp.conv_code_add_bits_input) #energy descramble self.prbs_src = blocks.vector_source_b(self.dp.prbs(self.msc_I), True) self.energy_v2s = blocks.vector_to_stream(gr.sizeof_char, self.msc_I) self.add_mod_2 = blocks.xor_bb() #self.energy_s2v = blocks.stream_to_vector(gr.sizeof_char, self.msc_I) #pack bits self.pack_bits = blocks.unpacked_to_packed_bb_make(1, gr.GR_MSB_FIRST) # connect blocks self.connect((self, 0), (self.select_msc_syms), #(self.repartition_msc_to_CIFs, 0), (self.repartition_msc_to_cus), (self.select_subch, 0), #(self.repartition_cus_to_logical_frame, 0), self.time_v2s, self.time_deinterleaver, #self.conv_v2s, self.unpuncture, self.conv_decode, #self.conv_s2v, self.conv_prune, #self.energy_v2s, self.add_mod_2, self.pack_bits, #self.energy_s2v, #better output stream or vector?? (self)) self.connect(self.prbs_src, (self.add_mod_2, 1)) #debug if debug is True: #msc_select_syms self.sink_msc_select_syms = blocks.file_sink_make(gr.sizeof_float * self.dp.num_carriers * 2, "debug/msc_select_syms.dat") self.connect(self.select_msc_syms, self.sink_msc_select_syms) #msc repartition cus self.sink_repartition_msc_to_cus = blocks.file_sink_make(gr.sizeof_float * self.dp.msc_cu_size, "debug/msc_repartitioned_to_cus.dat") self.connect((self.repartition_msc_to_cus), self.sink_repartition_msc_to_cus) #data of one sub channel not decoded self.sink_select_subch = blocks.file_sink_make(gr.sizeof_float * self.dp.msc_cu_size * self.size, "debug/select_subch.dat") self.connect(self.select_subch, self.sink_select_subch) #sub channel time_deinterleaved self.sink_subch_time_deinterleaved = blocks.file_sink_make(gr.sizeof_float, "debug/subch_time_deinterleaved.dat") self.connect(self.time_deinterleaver, self.sink_subch_time_deinterleaved) #sub channel unpunctured self.sink_subch_unpunctured = blocks.file_sink_make(gr.sizeof_float, "debug/subch_unpunctured.dat") self.connect(self.unpuncture, self.sink_subch_unpunctured) # sub channel convolutional decoded self.sink_subch_decoded = blocks.file_sink_make(gr.sizeof_char, "debug/subch_decoded.dat") self.connect(self.conv_decode, self.sink_subch_decoded) # sub channel convolutional decoded self.sink_subch_pruned = blocks.file_sink_make(gr.sizeof_char, "debug/subch_pruned.dat") self.connect(self.conv_prune, self.sink_subch_pruned) # sub channel energy dispersal undone unpacked self.sink_subch_energy_disp_undone = blocks.file_sink_make(gr.sizeof_char, "debug/subch_energy_disp_undone_unpacked.dat") self.connect(self.add_mod_2, self.sink_subch_energy_disp_undone) # sub channel energy dispersal undone packed self.sink_subch_energy_disp_undone_packed = blocks.file_sink_make(gr.sizeof_char, "debug/subch_energy_disp_undone_packed.dat") self.connect(self.pack_bits, self.sink_subch_energy_disp_undone_packed)
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option, usage="%prog: [options] input-filename") parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=(0, 0), help="select USRP Tx 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("-g", "--tx-gain", type="eng_float", default=None, help="set transmit 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" interp = 64 self.sample_rate = 128e6/interp self.dab_params = dab.parameters.dab_parameters(mode=1, sample_rate=2000000, verbose=options.verbose) self.src = blocks.file_source(gr.sizeof_char, "debug/generated_transmission_frame.dat") self.trigsrc = blocks.vector_source_b([1]+[0]*(self.dab_params.symbols_per_frame-1),True) self.s2v = blocks.stream_to_vector(gr.sizeof_char, 384) self.mod = dab.ofdm_mod(self.dab_params, verbose=options.verbose) #self.sink = usrp.sink_c(interp_rate = interp) self.sink = uhd.usrp_sink("",uhd.io_type.COMPLEX_FLOAT32,1) self.sink.set_samp_rate(self.sample_rate) #self.sink.set_mux(usrp.determine_tx_mux_value(self.sink, options.tx_subdev_spec)) #self.subdev = usrp.selected_subdev(self.sink, options.tx_subdev_spec) self.sink.set_antenna(options.antenna) self.file_sink = blocks.file_sink_make(gr.sizeof_gr_complex, "debug/generated_iq_data.dat") print "--> using sample rate: " + str(self.sample_rate) self.connect(self.src, self.s2v, self.mod, self.sink) self.connect(self.trigsrc, (self.mod,1)) self.connect(self.mod, self.file_sink) self.connect(self.mod, self.sink) # tune frequency self.sink.set_center_freq(options.freq) # set gain if options.tx_gain is None: # if no gain was specified, use the mid-point in dB g = self.sink.get_gain_range() options.tx_gain = float(g.start()+g.stop())/2 self.sink.set_gain(options.tx_gain)
def __init__(self, dab_params, address, size, protection, verbose=False, debug=False): gr.hier_block2.__init__( self, "msc_decode", # Input signature gr.io_signature(1, 1, gr.sizeof_float * dab_params.num_carriers * 2), # Output signature gr.io_signature(1, 1, gr.sizeof_char)) self.dp = dab_params self.address = address self.size = size self.protect = protection self.verbose = verbose self.debug = debug # calculate n factor (multiple of 8kbits etc.) self.n = self.size / self.dp.subch_size_multiple_n[self.protect] # calculate puncturing factors (EEP, table 33, 34) self.msc_I = self.n * 192 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 = int(self.puncturing_L1[ self.protect]) * 4 * self.dp.puncturing_vectors[ self.puncturing_PI1[self.protect]] + int( 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]) # MSC selection and block partitioning # select OFDM carriers with MSC self.select_msc_syms = grdab.select_vectors(gr.sizeof_float, self.dp.num_carriers * 2, self.dp.num_msc_syms, self.dp.num_fic_syms) # repartition MSC data in CIFs (left out due to heavy burden for scheduler and not really necessary) #self.repartition_msc_to_CIFs = grdab.repartition_vectors_make(gr.sizeof_float, self.dp.num_carriers * 2, # self.dp.cif_bits, self.dp.num_msc_syms, # self.dp.num_cifs) #repartition MSC to CUs self.repartition_msc_to_cus = grdab.repartition_vectors_make( gr.sizeof_float, self.dp.num_carriers * 2, self.dp.msc_cu_size, self.dp.num_msc_syms, self.dp.num_cus * self.dp.num_cifs) # select CUs of one subchannel of each CIF and form logical frame vector self.select_subch = grdab.select_subch_vfvf_make( self.dp.msc_cu_size, self.dp.msc_cu_size * self.size, self.address, self.dp.num_cus) # time deinterleaving self.time_v2s = blocks.vector_to_stream_make( gr.sizeof_float, self.dp.msc_cu_size * self.size) self.time_deinterleaver = grdab.time_deinterleave_ff_make( self.dp.msc_cu_size * self.size, self.dp.scrambling_vector) # unpuncture self.conv_v2s = blocks.vector_to_stream( gr.sizeof_float, self.msc_punctured_codeword_length) self.unpuncture = grdab.unpuncture_ff_make( self.assembled_msc_puncturing_sequence, 0) # convolutional decoding self.fsm = trellis.fsm( 1, 4, [0o133, 0o171, 0o145, 0o133 ]) # OK (dumped to text and verified partially) table = [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 ] assert (len(table) / 4 == self.fsm.O()) table = [(1 - 2 * x) / sqrt(2) for x in table] self.conv_decode = trellis.viterbi_combined_fb( self.fsm, self.msc_I + self.dp.conv_code_add_bits_input, 0, 0, 4, table, trellis.TRELLIS_EUCLIDEAN) self.conv_s2v = blocks.stream_to_vector( gr.sizeof_char, self.msc_I + self.dp.conv_code_add_bits_input) self.conv_prune = grdab.prune(gr.sizeof_char, self.msc_conv_codeword_length / 4, 0, self.dp.conv_code_add_bits_input) #energy descramble self.prbs_src = blocks.vector_source_b(self.dp.prbs(int(self.msc_I)), True) self.energy_v2s = blocks.vector_to_stream(gr.sizeof_char, self.msc_I) self.add_mod_2 = blocks.xor_bb() #self.energy_s2v = blocks.stream_to_vector(gr.sizeof_char, self.msc_I) #pack bits self.pack_bits = blocks.unpacked_to_packed_bb_make(1, gr.GR_MSB_FIRST) # connect blocks self.connect( (self, 0), (self.select_msc_syms), #(self.repartition_msc_to_CIFs, 0), (self.repartition_msc_to_cus), (self.select_subch, 0), #(self.repartition_cus_to_logical_frame, 0), self.time_v2s, self.time_deinterleaver, #self.conv_v2s, self.unpuncture, self.conv_decode, #self.conv_s2v, self.conv_prune, #self.energy_v2s, self.add_mod_2, self.pack_bits, #self.energy_s2v, #better output stream or vector?? (self)) self.connect(self.prbs_src, (self.add_mod_2, 1)) #debug if debug is True: #msc_select_syms self.sink_msc_select_syms = blocks.file_sink_make( gr.sizeof_float * self.dp.num_carriers * 2, "debug/msc_select_syms.dat") self.connect(self.select_msc_syms, self.sink_msc_select_syms) #msc repartition cus self.sink_repartition_msc_to_cus = blocks.file_sink_make( gr.sizeof_float * self.dp.msc_cu_size, "debug/msc_repartitioned_to_cus.dat") self.connect((self.repartition_msc_to_cus), self.sink_repartition_msc_to_cus) #data of one sub channel not decoded self.sink_select_subch = blocks.file_sink_make( gr.sizeof_float * self.dp.msc_cu_size * self.size, "debug/select_subch.dat") self.connect(self.select_subch, self.sink_select_subch) #sub channel time_deinterleaved self.sink_subch_time_deinterleaved = blocks.file_sink_make( gr.sizeof_float, "debug/subch_time_deinterleaved.dat") self.connect(self.time_deinterleaver, self.sink_subch_time_deinterleaved) #sub channel unpunctured self.sink_subch_unpunctured = blocks.file_sink_make( gr.sizeof_float, "debug/subch_unpunctured.dat") self.connect(self.unpuncture, self.sink_subch_unpunctured) # sub channel convolutional decoded self.sink_subch_decoded = blocks.file_sink_make( gr.sizeof_char, "debug/subch_decoded.dat") self.connect(self.conv_decode, self.sink_subch_decoded) # sub channel convolutional decoded self.sink_subch_pruned = blocks.file_sink_make( gr.sizeof_char, "debug/subch_pruned.dat") self.connect(self.conv_prune, self.sink_subch_pruned) # sub channel energy dispersal undone unpacked self.sink_subch_energy_disp_undone = blocks.file_sink_make( gr.sizeof_char, "debug/subch_energy_disp_undone_unpacked.dat") self.connect(self.add_mod_2, self.sink_subch_energy_disp_undone) # sub channel energy dispersal undone packed self.sink_subch_energy_disp_undone_packed = blocks.file_sink_make( gr.sizeof_char, "debug/subch_energy_disp_undone_packed.dat") self.connect(self.pack_bits, self.sink_subch_energy_disp_undone_packed)
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, 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)