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)
