def test_002_select_vectors(self):
skip = 2
len = 3
vlen = 2
src_data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1,
2, 3, 4, 5, 6, 7, 8, 9)
trig = (0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0)
expected_data = (6, 7, 8, 9, 10, 11, 6, 7, 8, 9)
expected_trig = (1, 0, 0, 1, 0)
src = blocks.vector_source_f(src_data)
trigsrc = blocks.vector_source_b(trig)
s2v = blocks.stream_to_vector(gr.sizeof_float, 2)
select_vectors = dab.select_vectors(gr.sizeof_float, vlen, len, skip)
v2s = blocks.vector_to_stream(gr.sizeof_float, 2)
dst = blocks.vector_sink_f()
trigdst = blocks.vector_sink_b()
self.tb.connect(src, s2v, select_vectors, v2s, dst)
self.tb.connect(trigsrc, (select_vectors, 1), trigdst)
self.tb.run()
result_data = dst.data()
result_trig = trigdst.data()
# print expected_result
# print result_data
self.assertFloatTuplesAlmostEqual(expected_data, result_data)
self.assertEqual(expected_trig, result_trig)
def test_002_select_vectors(self): skip = 2 len = 3 vlen = 2 src_data = (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0,1,2,3,4,5,6,7,8,9) trig = (0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0) expected_data = (6,7,8,9,10,11,6,7,8,9) expected_trig = (1, 0, 0, 1, 0) src = blocks.vector_source_f(src_data) trigsrc = blocks.vector_source_b(trig) s2v = blocks.stream_to_vector(gr.sizeof_float, 2) select_vectors = dab.select_vectors(gr.sizeof_float,vlen,len,skip) v2s = blocks.vector_to_stream(gr.sizeof_float, 2) dst = blocks.vector_sink_f() trigdst = blocks.vector_sink_b() self.tb.connect(src, s2v, select_vectors, v2s, dst) self.tb.connect(trigsrc, (select_vectors,1), trigdst) self.tb.run() result_data = dst.data() result_trig = trigdst.data() # print expected_result # print result_data self.assertFloatTuplesAlmostEqual(expected_data, result_data) self.assertEqual(expected_trig, result_trig)
def __init__(self, dab_params, verbose=False, debug=False):
"""
Hierarchical block for FIC decoding
@param dab_params DAB parameter object (dab.parameters.dab_parameters)
"""
gr.hier_block2.__init__(
self, "fic",
gr.io_signature2(2, 2,
gr.sizeof_float * dab_params.num_carriers * 2,
gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_char * 32))
self.dp = dab_params
self.verbose = verbose
self.debug = debug
# FIB selection and block partitioning
self.select_fic_syms = dab.select_vectors(gr.sizeof_float,
self.dp.num_carriers * 2,
self.dp.num_fic_syms, 0)
self.repartition_fic = dab.repartition_vectors(
gr.sizeof_float, self.dp.num_carriers * 2,
self.dp.fic_punctured_codeword_length, self.dp.num_fic_syms,
self.dp.num_cifs)
# unpuncturing
self.unpuncture = dab.unpuncture_vff(
self.dp.assembled_fic_puncturing_sequence, 0)
# convolutional coding
# self.fsm = trellis.fsm(self.dp.conv_code_in_bits, self.dp.conv_code_out_bits, self.dp.conv_code_generator_polynomials)
self.fsm = trellis.fsm(
1, 4, [0133, 0171, 0145, 0133
]) # OK (dumped to text and verified partially)
self.conv_v2s = blocks.vector_to_stream(
gr.sizeof_float, self.dp.fic_conv_codeword_length)
# self.conv_decode = trellis.viterbi_combined_fb(self.fsm, 20, 0, 0, 1, [1./sqrt(2),-1/sqrt(2)] , trellis.TRELLIS_EUCLIDEAN)
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, 774, 0, 0, 4, table, trellis.TRELLIS_EUCLIDEAN)
#self.conv_s2v = blocks.stream_to_vector(gr.sizeof_char, 774)
self.conv_prune = dab.prune(gr.sizeof_char,
self.dp.fic_conv_codeword_length / 4, 0,
self.dp.conv_code_add_bits_input)
# energy dispersal
self.prbs_src = blocks.vector_source_b(
self.dp.prbs(self.dp.energy_dispersal_fic_vector_length), True)
#self.energy_v2s = blocks.vector_to_stream(gr.sizeof_char, self.dp.energy_dispersal_fic_vector_length)
self.add_mod_2 = blocks.xor_bb()
self.energy_s2v = blocks.stream_to_vector(
gr.sizeof_char, self.dp.energy_dispersal_fic_vector_length)
self.cut_into_fibs = dab.repartition_vectors(
gr.sizeof_char, self.dp.energy_dispersal_fic_vector_length,
self.dp.fib_bits, 1, self.dp.energy_dispersal_fic_fibs_per_vector)
# connect all
self.nullsink = blocks.null_sink(gr.sizeof_char)
self.pack = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST)
self.fibout = blocks.stream_to_vector(1, 32)
# self.filesink = gr.file_sink(gr.sizeof_char, "debug/fic.dat")
self.fibsink = dab.fib_sink_vb()
# self.connect((self,0), (self.select_fic_syms,0), (self.repartition_fic,0), self.unpuncture, self.conv_v2s, self.conv_decode, self.conv_s2v, self.conv_prune, self.energy_v2s, self.add_mod_2, self.energy_s2v, (self.cut_into_fibs,0), gr.vector_to_stream(1,256), gr.unpacked_to_packed_bb(1,gr.GR_MSB_FIRST), self.filesink)
self.connect(
(self, 0),
(self.select_fic_syms, 0),
(self.repartition_fic, 0),
self.unpuncture,
self.conv_v2s,
self.conv_decode,
#self.conv_s2v,
self.conv_prune,
#self.energy_v2s,
self.add_mod_2,
self.energy_s2v,
(self.cut_into_fibs, 0),
blocks.vector_to_stream(1, 256),
self.pack,
self.fibout,
self.fibsink)
self.connect(self.fibout, self)
self.connect(self.prbs_src, (self.add_mod_2, 1))
self.connect((self, 1), (self.select_fic_syms, 1),
(self.repartition_fic, 1), (self.cut_into_fibs, 1),
self.nullsink)
if self.debug:
self.connect(
(self, 0),
blocks.file_sink(gr.sizeof_float * self.dp.num_carriers * 2,
"debug/transmission_frame.dat"))
self.connect(
(self, 1),
blocks.file_sink(gr.sizeof_char,
"debug/transmission_frame_trigger.dat"))
self.connect(
self.select_fic_syms,
blocks.file_sink(gr.sizeof_float * self.dp.num_carriers * 2,
"debug/fic_select_syms.dat"))
self.connect(
self.repartition_fic,
blocks.file_sink(
gr.sizeof_float * self.dp.fic_punctured_codeword_length,
"debug/fic_repartitioned.dat"))
self.connect(
self.unpuncture,
blocks.file_sink(
gr.sizeof_float * self.dp.fic_conv_codeword_length,
"debug/fic_unpunctured.dat"))
self.connect(
self.conv_decode,
blocks.file_sink(gr.sizeof_char, "debug/fic_decoded.dat"))
self.connect(
self.conv_prune,
blocks.file_sink(gr.sizeof_char,
"debug/fic_decoded_pruned.dat"))
#self.connect(self.conv_decode, blocks.file_sink(gr.sizeof_char * self.dp.energy_dispersal_fic_vector_length, "debug/fic_energy_dispersal_undone.dat"))
self.connect(
self.pack,
blocks.file_sink(gr.sizeof_char,
"debug/fic_energy_undone.dat"))
def __init__(self,
dab_params,
address,
size,
protection,
verbose=False,
debug=False):
gr.hier_block2.__init__(
self,
"msc_decode",
# Input signature
gr.io_signature2(2, 2,
gr.sizeof_float * dab_params.num_carriers * 2,
gr.sizeof_char),
# 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 = dab.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 = dab.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 = dab.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 = dab.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 = dab.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 = dab.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 = dab.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, 0),
#(self.repartition_msc_to_CIFs, 0),
(self.repartition_msc_to_cus, 0),
(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))
#connect trigger chain
self.connect(
(self, 1),
(self.select_msc_syms, 1),
#(self.repartition_msc_to_CIFs, 1),
(self.repartition_msc_to_cus, 1),
#(self.select_subch, 1),
#(self.repartition_CUs_to_logical_frame, 1);
blocks.null_sink(gr.sizeof_char))
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, 0),
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, dab_params, verbose=True, debug=False):
"""
Hierarchical block for FIC decoding
@param dab_params DAB parameter object (dab.parameters.dab_parameters)
"""
gr.hier_block2.__init__(self,"fic",
gr.io_signature2(2, 2, gr.sizeof_float*dab_params.num_carriers*2, gr.sizeof_char), # input
gr.io_signature(1, 1, gr.sizeof_char*32)) # output signature
self.dp = dab_params
self.verbose = verbose
self.debug = debug
# FIB selection and block partitioning
self.select_fic_syms = dab.select_vectors(gr.sizeof_float, self.dp.num_carriers*2, self.dp.num_fic_syms, 0)
self.repartition_fic = dab.repartition_vectors(gr.sizeof_float, self.dp.num_carriers*2, self.dp.fic_punctured_codeword_length, self.dp.num_fic_syms, self.dp.num_cifs)
# unpuncturing
self.unpuncture = dab.unpuncture_vff(self.dp.assembled_fic_puncturing_sequence,0)
# convolutional coding
# self.fsm = trellis.fsm(self.dp.conv_code_in_bits, self.dp.conv_code_out_bits, self.dp.conv_code_generator_polynomials)
self.fsm = trellis.fsm(1, 4, [0133, 0171, 0145, 0133]) # OK (dumped to text and verified partially)
self.conv_v2s = blocks.vector_to_stream(gr.sizeof_float, self.dp.fic_conv_codeword_length)
# self.conv_decode = trellis.viterbi_combined_fb(self.fsm, 20, 0, 0, 1, [1./sqrt(2),-1/sqrt(2)] , trellis.TRELLIS_EUCLIDEAN)
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, 774, 0, 0, 4, table, trellis.TRELLIS_EUCLIDEAN)
self.conv_s2v = blocks.stream_to_vector(gr.sizeof_char, 774)
self.conv_prune = dab.prune_vectors(gr.sizeof_char, self.dp.fic_conv_codeword_length/4, 0, self.dp.conv_code_add_bits_input)
# energy dispersal
self.prbs_src = blocks.vector_source_b(self.dp.prbs(self.dp.energy_dispersal_fic_vector_length), True)
self.energy_v2s = blocks.vector_to_stream(gr.sizeof_char, self.dp.energy_dispersal_fic_vector_length)
self.add_mod_2 = blocks.xor_bb()
self.energy_s2v = blocks.stream_to_vector(gr.sizeof_char, self.dp.energy_dispersal_fic_vector_length)
self.cut_into_fibs = dab.repartition_vectors(gr.sizeof_char, self.dp.energy_dispersal_fic_vector_length, self.dp.fib_bits, 1, self.dp.energy_dispersal_fic_fibs_per_vector)
# connect all
self.nullsink = blocks.null_sink(gr.sizeof_char)
self.fibout = blocks.stream_to_vector(1,32)
# self.filesink = gr.file_sink(gr.sizeof_char, "debug/fic.dat")
self.fibsink = dab.fib_sink_vb()
# self.connect((self,0), (self.select_fic_syms,0), (self.repartition_fic,0), self.unpuncture, self.conv_v2s, self.conv_decode, self.conv_s2v, self.conv_prune, self.energy_v2s, self.add_mod_2, self.energy_s2v, (self.cut_into_fibs,0), gr.vector_to_stream(1,256), gr.unpacked_to_packed_bb(1,gr.GR_MSB_FIRST), self.filesink)
self.connect((self,0),
(self.select_fic_syms,0),
(self.repartition_fic,0),
self.unpuncture,
self.conv_v2s,
self.conv_decode,
self.conv_s2v,
self.conv_prune,
self.energy_v2s,
self.add_mod_2,
self.energy_s2v,
(self.cut_into_fibs,0),
blocks.vector_to_stream(1,256),
blocks.unpacked_to_packed_bb(1,gr.GR_MSB_FIRST),
self.fibout,
self.fibsink)
self.connect(self.fibout, self)
self.connect(self.prbs_src, (self.add_mod_2,1))
self.connect((self,1), (self.select_fic_syms,1), (self.repartition_fic,1), (self.cut_into_fibs,1), self.nullsink)
if self.debug:
self.connect(self.select_fic_syms, blocks.file_sink(gr.sizeof_float*self.dp.num_carriers*2, "debug/fic_select_syms.dat"))
self.connect(self.repartition_fic, blocks.file_sink(gr.sizeof_float*self.dp.fic_punctured_codeword_length, "debug/fic_repartitioned.dat"))
self.connect(self.unpuncture, blocks.file_sink(gr.sizeof_float*self.dp.fic_conv_codeword_length, "debug/fic_unpunctured.dat"))
self.connect(self.conv_decode, blocks.file_sink(gr.sizeof_char, "debug/fic_decoded.dat"))
self.connect(self.energy_s2v, blocks.file_sink(gr.sizeof_char*self.dp.energy_dispersal_fic_vector_length, "debug/fic_energy_dispersal_undone.dat"))
