def test_xor_bb (self):
src1_data = [1, 2, 3, 4, 0x50]
src2_data = [8, 2, 1 , 8, 0x05]
expected_result = [9, 0, 2, 0xC, 0x55]
op = blocks.xor_bb ()
self.help_bb ((src1_data, src2_data),
expected_result, op)
def test_001_t(self):
energy_dispersal_undone = (0x05, 0x00, 0x10, 0xea, 0x04, 0x24, 0x06,
0x02, 0xd3, 0xa6, 0x01, 0x3f, 0x06, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x4c, 0x89)
energy_dispersal_done = (0x02, 0xBE, 0x3E, 0x8E, 0x16, 0xB9, 0xA5,
0xCD, 0x48, 0xB3, 0x22, 0xB2, 0xAD, 0x76,
0x88, 0x80, 0x42, 0x30, 0x9C, 0xAB, 0x0D,
0xE9, 0xB9, 0x14, 0x2B, 0x4F, 0xD9, 0x25,
0xBF, 0x26, 0xEA, 0xE9)
fib_packed_to_unpacked = blocks.packed_to_unpacked_bb(
1, gr.GR_MSB_FIRST)
fib_unpacked_to_packed = blocks.unpacked_to_packed_bb(
1, gr.GR_MSB_FIRST)
src = blocks.vector_source_b(energy_dispersal_undone)
self.dp = grdab.parameters.dab_parameters(1, 2e6, False)
prbs_src = blocks.vector_source_b(
self.dp.prbs(self.dp.energy_dispersal_fic_vector_length), True)
add_mod_2 = blocks.xor_bb()
dst = blocks.vector_sink_b()
self.tb.connect(src, fib_packed_to_unpacked, add_mod_2,
fib_unpacked_to_packed, dst)
self.tb.connect(prbs_src, (add_mod_2, 1))
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(energy_dispersal_done, result_data,
6)
def test_xor_bb (self):
src1_data = (1, 2, 3, 4, 0x50)
src2_data = (8, 2, 1 , 8, 0x05)
expected_result = (9, 0, 2, 0xC, 0x55)
op = blocks.xor_bb ()
self.help_bb ((src1_data, src2_data),
expected_result, op)
def __init__(self, n_bits=1000, bits_per_symbol=3):
gr.hier_block2.__init__(
self, "Custom Ber",
gr.io_signaturev(2, 2, [gr.sizeof_char*1, gr.sizeof_char*1]),
gr.io_signature(1, 1, gr.sizeof_float*1),
)
##################################################
# Parameters
##################################################
self.n_bits = n_bits
self.bits_per_symbol = bits_per_symbol
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 8e6
##################################################
# Blocks
##################################################
self.blocks_xor_xx_0 = blocks.xor_bb()
self.blocks_unpack_k_bits_bb_0 = blocks.unpack_k_bits_bb(bits_per_symbol)
self.blocks_uchar_to_float_0 = blocks.uchar_to_float()
self.blocks_moving_average_xx_0 = blocks.moving_average_ff(n_bits, 1/float(n_bits), n_bits*4)
##################################################
# Connections
##################################################
self.connect((self.blocks_moving_average_xx_0, 0), (self, 0))
self.connect((self.blocks_uchar_to_float_0, 0), (self.blocks_moving_average_xx_0, 0))
self.connect((self.blocks_unpack_k_bits_bb_0, 0), (self.blocks_uchar_to_float_0, 0))
self.connect((self.blocks_xor_xx_0, 0), (self.blocks_unpack_k_bits_bb_0, 0))
self.connect((self, 1), (self.blocks_xor_xx_0, 1))
self.connect((self, 0), (self.blocks_xor_xx_0, 0))
def __init__(self):
gr.hier_block2.__init__(
self,
"Bit Error Rate",
gr.io_signaturev(2, 2, [gr.sizeof_char * 1, gr.sizeof_char * 1]),
gr.io_signature(1, 1, gr.sizeof_float * 1),
)
##################################################
# Variables
##################################################
self._msgLength_config = ConfigParser.ConfigParser()
self._msgLength_config.read("./configs/sdrConfig.txt")
try:
msgLength = self._msgLength_config.getint("main", "key")
except:
msgLength = 10000
self.msgLength = msgLength
self._bits_per_byte_config = ConfigParser.ConfigParser()
self._bits_per_byte_config.read("./configs/sdrConfig.txt")
try:
bits_per_byte = self._bits_per_byte_config.getint("main", "key")
except:
bits_per_byte = 8
self.bits_per_byte = bits_per_byte
intdecim = 100000
if msgLength < intdecim:
intdecim = msgLength
##################################################
# Blocks
##################################################
self.blocks_xor_xx_0 = blocks.xor_bb()
self.blocks_unpack_k_bits_bb_0 = blocks.unpack_k_bits_bb(bits_per_byte)
self.blocks_uchar_to_float_0 = blocks.uchar_to_float()
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff(
(1.0 / msgLength, ))
self.blocks_integrate_xx_0 = blocks.integrate_ff(intdecim)
##################################################
# Connections
##################################################
self.connect((self.blocks_integrate_xx_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
self.connect((self, 1), (self.blocks_xor_xx_0, 1))
self.connect((self, 0), (self.blocks_xor_xx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self, 0))
self.connect((self.blocks_xor_xx_0, 0),
(self.blocks_unpack_k_bits_bb_0, 0))
self.connect((self.blocks_unpack_k_bits_bb_0, 0),
(self.blocks_uchar_to_float_0, 0))
self.connect((self.blocks_uchar_to_float_0, 0),
(self.blocks_integrate_xx_0, 0))
def __init__(self, dtype="discrete", limit=10000, randomize=False):
if dtype == "discrete":
gr.hier_block2.__init__(self, "source_alphabet",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_char))
self.src = blocks.file_source(
gr.sizeof_char, "source_material/gutenberg_shakespeare.txt")
self.convert = blocks.packed_to_unpacked_bb(1, gr.GR_LSB_FIRST)
# self.convert = blocks.packed_to_unpacked_bb(8, gr.GR_LSB_FIRST);
self.limit = blocks.head(gr.sizeof_char, limit)
self.connect(self.src, self.convert)
last = self.convert
# whiten our sequence with a random block scrambler (optionally)
if randomize:
rand_len = 256
rand_bits = np.random.randint(2, size=rand_len)
self.rand_src = blocks.vector_source_b(rand_bits, True)
self.xor = blocks.xor_bb()
self.connect(self.rand_src, (self.xor, 1))
self.connect(last, self.xor)
last = self.xor
elif dtype == "continuous": # continuous
gr.hier_block2.__init__(self, "source_alphabet",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_float))
self.src = blocks.wavfile_source(
"source_material/serial-s01-e01.mp3", True)
self.float_short = blocks.float_to_short(1, 1)
self.convert2 = blocks.interleaved_short_to_complex()
self.convert3 = blocks.multiply_const_cc(1.0 / 65535)
self.convert = blocks.complex_to_float()
self.limit = blocks.head(gr.sizeof_float, limit)
self.connect(self.src, self.convert2, self.convert3, self.convert)
last = self.convert
else: # noise
gr.hier_block2.__init__(
self, "source_alphabet", gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_gr_complex))
self.src = analog.fastnoise_source_c(analog.GR_GAUSSIAN, 1e-4, 0,
8192)
self.limit = blocks.head(gr.sizeof_gr_complex, limit)
last = self.src
# connect head or not, and connect to output
if limit is None:
self.connect(last, self)
else:
self.connect(last, self.limit, self)
def __init__(self,
dtype="discrete",
limit=10000,
randomize=False,
repeat=False):
if (dtype == "discrete"):
gr.hier_block2.__init__(self, "source_alphabet",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_char))
self.src = blocks.file_source(
gr.sizeof_char,
"source_material/gutenberg_shakespeare.txt",
repeat=repeat)
self.convert = blocks.packed_to_unpacked_bb(1, gr.GR_LSB_FIRST)
#self.convert = blocks.packed_to_unpacked_bb(8, gr.GR_LSB_FIRST);
if limit is not None:
self.limit = blocks.head(gr.sizeof_char, limit)
self.connect(self.src, self.convert)
last = self.convert
# whiten our sequence with a random block scrambler (optionally)
if (randomize):
rand_len = 256
rand_bits = np.random.randint(2, size=rand_len)
self.randsrc = blocks.vector_source_b(rand_bits, True)
self.xor = blocks.xor_bb()
self.connect(self.randsrc, (self.xor, 1))
self.connect(last, self.xor)
last = self.xor
else: # "type_continuous"
gr.hier_block2.__init__(self, "source_alphabet",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_float))
self.src = mediatools.audiosource_s(
["source_material/serial-s01-e01.mp3"])
self.convert2 = blocks.interleaved_short_to_complex()
self.convert3 = blocks.multiply_const_cc(1.0 / 65535)
self.convert = blocks.complex_to_float()
if limit is not None:
self.limit = blocks.head(gr.sizeof_float, limit)
self.connect(self.src, self.convert2, self.convert3, self.convert)
last = self.convert
# connect head or not, and connect to output
if (limit is None):
self.connect(last, self)
else:
self.connect(last, self.limit, self)
def __init__(self, bits_per_byte):
gr.hier_block2.__init__(self, "BitErrors",
gr.io_signature(2, 2, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_int))
# Bit comparison
comp = blocks.xor_bb()
intdump_decim = 100000
if N_BITS < intdump_decim:
intdump_decim = int(N_BITS)
self.connect(self, comp, blocks.unpack_k_bits_bb(bits_per_byte),
blocks.uchar_to_float(),
blocks.integrate_ff(intdump_decim),
blocks.multiply_const_ff(1.0 / N_BITS), self)
self.connect((self, 1), (comp, 1))
def test_001_t (self):
energy_dispersal_undone = (0x05, 0x00, 0x10, 0xea, 0x04, 0x24, 0x06, 0x02, 0xd3, 0xa6, 0x01, 0x3f, 0x06, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x89)
energy_dispersal_done = (0x02, 0xBE, 0x3E, 0x8E, 0x16, 0xB9, 0xA5, 0xCD, 0x48, 0xB3, 0x22, 0xB2, 0xAD, 0x76, 0x88, 0x80, 0x42, 0x30, 0x9C, 0xAB, 0x0D, 0xE9, 0xB9, 0x14, 0x2B, 0x4F, 0xD9, 0x25, 0xBF, 0x26, 0xEA, 0xE9)
fib_packed_to_unpacked = blocks.packed_to_unpacked_bb(1,gr.GR_MSB_FIRST)
fib_unpacked_to_packed = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST)
src = blocks.vector_source_b(energy_dispersal_undone)
self.dp = grdab.parameters.dab_parameters(1, 2e6, False)
prbs_src = blocks.vector_source_b(self.dp.prbs(self.dp.energy_dispersal_fic_vector_length), True)
add_mod_2 = blocks.xor_bb()
dst = blocks.vector_sink_b()
self.tb.connect(src, fib_packed_to_unpacked, add_mod_2, fib_unpacked_to_packed, dst)
self.tb.connect(prbs_src, (add_mod_2, 1))
self.tb.run ()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(energy_dispersal_done, result_data, 6)
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, bits_per_byte):
gr.hier_block2.__init__(self, "BitErrors",
gr.io_signature(2, 2, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_int))
# Bit comparison
comp = blocks.xor_bb()
intdump_decim = 100000
if N_BITS < intdump_decim:
intdump_decim = int(N_BITS)
self.connect(self,
comp,
blocks.unpack_k_bits_bb(bits_per_byte),
blocks.uchar_to_float(),
blocks.integrate_ff(intdump_decim),
blocks.multiply_const_ff(1.0 / N_BITS),
self)
self.connect((self, 1), (comp, 1))
def sim ( self, arity, snr_db, N ):
vlen = 1
N = int( N )
snr = 10.0**(snr_db/10.0)
sigpow = 1.0
noise_pow = sigpow / snr
demapper = ofdm.generic_demapper_vcb( vlen )
const = demapper.get_constellation( arity )
assert( len( const ) == 2**arity )
symsrc = ofdm.symbol_random_src( const, vlen )
noise_src = ofdm.complex_white_noise( 0.0, sqrt( noise_pow ) )
channel = blocks.add_cc()
bitmap_src = blocks.vector_source_b( [arity] * vlen, True, vlen )
bm_trig_src = blocks.vector_source_b( [1], True )
ref_bitstream = blocks.unpack_k_bits_bb( arity )
bitstream_xor = blocks.xor_bb()
bitstream_c2f = blocks.char_to_float()
acc_biterr = ofdm.accumulator_ff()
skiphead = blocks.skiphead( gr.sizeof_float, N-1 )
limit = blocks.head( gr.sizeof_float, 1 )
dst = blocks.vector_sink_f()
tb = gr.top_block ( "test_block" )
tb.connect( (symsrc,0), (channel,0) )
tb.connect( noise_src, (channel,1) )
tb.connect( channel, (demapper,0), (bitstream_xor,0) )
tb.connect( bitmap_src, (demapper,1) )
tb.connect( bm_trig_src, (demapper,2) )
tb.connect( (symsrc,1), ref_bitstream, (bitstream_xor,1) )
tb.connect( bitstream_xor, bitstream_c2f, acc_biterr )
tb.connect( acc_biterr, skiphead, limit, dst )
tb.run()
bit_errors = numpy.array( dst.data() )
assert( len( bit_errors ) == 1 )
bit_errors = bit_errors[0]
return bit_errors / N
def __init__(self):
gr.hier_block2.__init__(
self, "Bit Error Rate",
gr.io_signaturev(2, 2, [gr.sizeof_char*1, gr.sizeof_char*1]),
gr.io_signature(1, 1, gr.sizeof_float*1),
)
##################################################
# Variables
##################################################
self._msgLength_config = ConfigParser.ConfigParser()
self._msgLength_config.read("./configs/sdrConfig.txt")
try: msgLength = self._msgLength_config.getint("main", "key")
except: msgLength = 10000
self.msgLength = msgLength
self._bits_per_byte_config = ConfigParser.ConfigParser()
self._bits_per_byte_config.read("./configs/sdrConfig.txt")
try: bits_per_byte = self._bits_per_byte_config.getint("main", "key")
except: bits_per_byte = 8
self.bits_per_byte = bits_per_byte
intdecim = 100000
if msgLength < intdecim:
intdecim = msgLength
##################################################
# Blocks
##################################################
self.blocks_xor_xx_0 = blocks.xor_bb()
self.blocks_unpack_k_bits_bb_0 = blocks.unpack_k_bits_bb(bits_per_byte)
self.blocks_uchar_to_float_0 = blocks.uchar_to_float()
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((1.0/msgLength, ))
self.blocks_integrate_xx_0 = blocks.integrate_ff(intdecim)
##################################################
# Connections
##################################################
self.connect((self.blocks_integrate_xx_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self, 1), (self.blocks_xor_xx_0, 1))
self.connect((self, 0), (self.blocks_xor_xx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self, 0))
self.connect((self.blocks_xor_xx_0, 0), (self.blocks_unpack_k_bits_bb_0, 0))
self.connect((self.blocks_unpack_k_bits_bb_0, 0), (self.blocks_uchar_to_float_0, 0))
self.connect((self.blocks_uchar_to_float_0, 0), (self.blocks_integrate_xx_0, 0))
def sim ( self, arity, snr_db, N ):
M = 1024
theta_sel = 0
syms_per_frame = 10
zero_pads = 1
center_preamble = [1, -1j, -1, 1j] # assumed to be normalized to 1
qam_size = 2**arity
preamble = [0]*M*zero_pads+center_preamble*((int)(M/len(center_preamble)))+[0]*M*zero_pads
# num_symbols = 2**12
exclude_preamble = 0
exclude_multipath =0
sel_taps = 0 # epa=0, eva = 1, etu=3
freq_offset=0
exclude_noise = 0
sel_noise_type =0 # gaussian
eq_select = 3
# SNR = 20
K = 4
N = int( N ) # num of !samples!
num_bits = N*arity
# amp = math.sqrt(M/(10**(float(snr_db)/10)))/math.sqrt(2)
# amp = math.sqrt((10**(float(-1*snr_db)/20))*(2*K*M+(2*syms_per_frame-1)*M)/(4*syms_per_frame))/math.sqrt(2)
if exclude_preamble:
amp = math.sqrt((10**(float(-1*snr_db)/10))*(2*K*M+(2*syms_per_frame-1)*M)/(4*syms_per_frame))/math.sqrt(2)
else:
amp = math.sqrt((10**(float(-1*snr_db)/10))*(M*(syms_per_frame+1)/(syms_per_frame+1+2*zero_pads))*((K*M+(2*syms_per_frame-1)*M/2)/(M*syms_per_frame)))/math.sqrt(2)
# print amp
# print amp2
tx = transmitter_hier_bc(M, K, qam_size, syms_per_frame, theta_sel, exclude_preamble, center_preamble,1)
rx = receiver_hier_cb(M, K, qam_size, syms_per_frame, theta_sel, eq_select, exclude_preamble, center_preamble,1)
ch = channel_hier_cc(M, K, syms_per_frame, exclude_multipath, sel_taps, freq_offset, exclude_noise, sel_noise_type, snr_db, exclude_preamble, zero_pads)
# # src = blocks.vector_source_b(src_data, vlen=1)
xor_block = blocks.xor_bb()
head1 = blocks.head(gr.sizeof_char*1, N)
head0 = blocks.head(gr.sizeof_char*1, N)
add_block = blocks.add_vcc(1)
src = blocks.vector_source_b(map(int, numpy.random.randint(0, qam_size, 100000)), True)
noise = analog.fastnoise_source_c(analog.GR_GAUSSIAN, amp, 0, 8192)
dst = blocks.vector_sink_b(vlen=1)
tb = gr.top_block ( "test_block" )
tb.connect((src, 0), (head1, 0)) #esas
tb.connect((head1, 0), (xor_block, 0)) #esas
tb.connect((src, 0), (tx, 0)) #esas
tb.connect((tx, 0), (add_block, 0)) #esas
tb.connect((noise, 0), (add_block, 1)) #esas
# tb.connect((head0, 0), (add_block, 1)) #esas
tb.connect((add_block, 0), (rx, 0)) #esas
tb.connect((rx, 0),(head0, 0)) #esas
tb.connect((head0, 0), (xor_block, 1)) #esas
tb.connect((xor_block, 0), (dst, 0)) #esas
tb.run()
# what we record in dst.data will be output of xor_block. now we have to process those data
# so as to find bit errors.
result_data = dst.data()
bit_errors = 0
for i in range(len(result_data)):
# print bin(result_data[i])
bit_errors = bit_errors + (bin(result_data[i]).count('1'))
# print len(result_data)
# return 1
return float(bit_errors) / num_bits
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 test_xor_bb(self):
src1_data = (1, 2, 3, 4, 0x50)
src2_data = (8, 2, 1, 8, 0x05)
expected_result = (9, 0, 2, 0xC, 0x55)
op = blocks.xor_bb()
self.help_bb((src1_data, src2_data), expected_result, op)
def sim ( self, arity, snr_db, N ):
M = 1024
theta_sel = 0
syms_per_frame = 20
zero_pads = 1
# center_preamble = [1, -1j, -1, 1j] # assumed to be normalized to 1
qam_size = 2**arity
# preamble = [0]*M*zero_pads+center_preamble*((int)(M/len(center_preamble)))+[0]*M*zero_pads
# print preamble
# num_symbols = 2**12
exclude_preamble = 1
exclude_multipath = 1
sel_taps = 2 # epa=0, eva = 1, etu=2
freq_offset= 0
exclude_noise = 0
sel_noise_type =0 # gaussian
eq_select = 0 # 0=1-tap 1=3-taps w/linear intrp 2=3-taps w/ geo. intrp. 3= no eq.
carriers = M
sel_preamble = 0 # 0: IAM-C 1: IAM-C with 3 rep. 2: IAM-R
extra_pad=False
# SNR = 20
K = 4
N = int( N ) # num of !samples!
num_bits = N*arity
normalizing_factor = float(1)/(M*.6863)#*.6863)
# print normalizing_factor
# amp = math.sqrt(M/(10**(float(snr_db)/10)))/math.sqrt(2)
# amp = math.sqrt((10**(float(-1*snr_db)/20))*(2*K*M+(2*syms_per_frame-1)*M)/(4*syms_per_frame))/math.sqrt(2)
if exclude_preamble:
amp = normalizing_factor*math.sqrt((10**(float(-1*snr_db)/10))*(2*K*M+(2*syms_per_frame-1)*M)/(4*syms_per_frame))/math.sqrt(2)
# amp = normalizing_factor*math.sqrt((10**(float(-1*snr_db)/10))*(2*K*M+(2*syms_per_frame-1)*M)/(4*syms_per_frame))/math.sqrt(2)
else:
amp = normalizing_factor*math.sqrt((10**(float(-1*snr_db)/10))*(M*(syms_per_frame+1)/(syms_per_frame+1+2*zero_pads))*((K*M+(2*syms_per_frame-1)*M/2)/(M*syms_per_frame)))/math.sqrt(2)
# print amp
# print amp2
taps = (1)
if sel_taps == 0: #epa
taps = (0.998160541385960,0.0605566335500750,0.00290305927764350)
elif sel_taps == 1: #eva
taps = (0.748212004186014,0.317358833370450,0.572776845645705,0,0.0538952624324030,0.0874078808126807,0,0,0,0.0276407988816600,0,0,0,0.00894438719057275)
elif sel_taps ==2: #etu
taps = (0.463990169152204,0.816124099344485,0,0.292064507384192,0,0,0,0,0.146379002496595,0,0,0,0.0923589067029112,0,0,0,0,0,0,0,0,0,0,0,0,0.0582745305123628)
tx = ofdm.fbmc_transmitter_hier_bc(M, K, qam_size, syms_per_frame, carriers, theta_sel, exclude_preamble, sel_preamble,zero_pads,extra_pad)
rx = ofdm.fbmc_receiver_hier_cb(M, K, qam_size, syms_per_frame, carriers, theta_sel, eq_select, exclude_preamble, sel_preamble, zero_pads,extra_pad)
# def __init__(self, M=1024, K=4, qam_size=16, syms_per_frame=10, carriers=924, theta_sel=0, sel_eq=0, exclude_preamble=0, sel_preamble=0, zero_pads=1, extra_pad=False):
# ch = ofdm.fbmc_channel_hier_cc(M, K, syms_per_frame, exclude_multipath, sel_taps, freq_offset, exclude_noise, sel_noise_type, snr_db, exclude_preamble, zero_pads)
# src = blocks.vector_source_b(src_data, vlen=1)
xor_block = blocks.xor_bb()
head1 = blocks.head(gr.sizeof_char*1, N)
head0 = blocks.head(gr.sizeof_char*1, N)
add_block = blocks.add_vcc(1)
src = blocks.vector_source_b(map(int, numpy.random.randint(0, qam_size, 100000)), True)
noise = analog.fastnoise_source_c(analog.GR_GAUSSIAN, amp, 0, 8192)
dst = blocks.vector_sink_b(vlen=1)
# ch_model = channels.channel_model(
# noise_voltage=0.0,
# frequency_offset=freq_offset,
# epsilon=1.0,
# taps=taps,
# noise_seed=0,
# block_tags=False
# )
tb = gr.top_block ( "test_block" )
tb.connect((src, 0), (head1, 0)) #esas
tb.connect((head1, 0), (xor_block, 0)) #esas
tb.connect((src, 0), (tx, 0)) #esas
# tb.connect((tx, 0), (add_block, 0)) #esas
if exclude_multipath:
tb.connect((tx, 0), (add_block, 0)) #esas
else:
tb.connect((tx, 0), (ch_model, 0))
tb.connect((ch_model, 0), (add_block, 0))
tb.connect((noise, 0), (add_block, 1)) #esas
tb.connect((add_block, 0), (rx, 0)) #esas
tb.connect((rx, 0),(head0, 0)) #esas
tb.connect((head0, 0), (xor_block, 1)) #esas
tb.connect((xor_block, 0), (dst, 0)) #esas
tb.run()
# what we record in dst.data will be output of xor_block. now we have to process those data
# so as to find bit errors.
result_data = dst.data()
bit_errors = 0
for i in range(len(result_data)):
# print bin(result_data[i])
bit_errors = bit_errors + (bin(result_data[i]).count('1'))
# print len(result_data)
# return 1
return float(bit_errors) / num_bits
def __init__(self):
gr.top_block.__init__(self, "And or xor")
Qt.QWidget.__init__(self)
self.setWindowTitle("And or xor")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "logicalsignal")
try:
if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"):
self.restoreGeometry(
self.settings.value("geometry").toByteArray())
else:
self.restoreGeometry(self.settings.value("geometry"))
except:
pass
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.qtgui_time_sink_x_0_0_0 = qtgui.time_sink_f(
128, #size
samp_rate, #samp_rate
"", #name
2 #number of inputs
)
self.qtgui_time_sink_x_0_0_0.set_update_time(0.10)
self.qtgui_time_sink_x_0_0_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0_0_0.set_y_label('XOR', "")
self.qtgui_time_sink_x_0_0_0.enable_tags(True)
self.qtgui_time_sink_x_0_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS,
0.0, 0, 0, "")
self.qtgui_time_sink_x_0_0_0.enable_autoscale(False)
self.qtgui_time_sink_x_0_0_0.enable_grid(False)
self.qtgui_time_sink_x_0_0_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0_0_0.enable_control_panel(False)
self.qtgui_time_sink_x_0_0_0.enable_stem_plot(False)
labels = [
'Signal 1', 'Signal 2', 'Signal 3', 'Signal 4', 'Signal 5',
'Signal 6', 'Signal 7', 'Signal 8', 'Signal 9', 'Signal 10'
]
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
'blue', 'red', 'green', 'black', 'cyan', 'magenta', 'yellow',
'dark red', 'dark green', 'dark blue'
]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
for i in range(2):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0_0_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0_0_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0_0_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0_0_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0_0_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0_0_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0_0_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_0_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0_0_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_0_0_win)
self.qtgui_time_sink_x_0_0 = qtgui.time_sink_f(
128, #size
samp_rate, #samp_rate
"", #name
2 #number of inputs
)
self.qtgui_time_sink_x_0_0.set_update_time(0.10)
self.qtgui_time_sink_x_0_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0_0.set_y_label('OR', "")
self.qtgui_time_sink_x_0_0.enable_tags(True)
self.qtgui_time_sink_x_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0,
0, 0, "")
self.qtgui_time_sink_x_0_0.enable_autoscale(False)
self.qtgui_time_sink_x_0_0.enable_grid(False)
self.qtgui_time_sink_x_0_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0_0.enable_control_panel(False)
self.qtgui_time_sink_x_0_0.enable_stem_plot(False)
labels = [
'Signal 1', 'Signal 2', 'Signal 3', 'Signal 4', 'Signal 5',
'Signal 6', 'Signal 7', 'Signal 8', 'Signal 9', 'Signal 10'
]
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
'blue', 'red', 'green', 'black', 'cyan', 'magenta', 'yellow',
'dark red', 'dark green', 'dark blue'
]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
for i in range(2):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_0_win)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
128, #size
samp_rate, #samp_rate
"", #name
2 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0.set_y_label('AND', "")
self.qtgui_time_sink_x_0.enable_tags(True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0, 0,
0, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(False)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
self.qtgui_time_sink_x_0.enable_stem_plot(False)
labels = [
'Signal 1', 'Signal 2', 'Signal 3', 'Signal 4', 'Signal 5',
'Signal 6', 'Signal 7', 'Signal 8', 'Signal 9', 'Signal 10'
]
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
'blue', 'red', 'green', 'black', 'cyan', 'magenta', 'yellow',
'dark red', 'dark green', 'dark blue'
]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
for i in range(2):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_win)
self.blocks_xor_xx_0_0 = blocks.xor_bb()
self.blocks_xor_xx_0 = blocks.xor_bb()
self.blocks_uchar_to_float_0_0_0_0 = blocks.uchar_to_float()
self.blocks_uchar_to_float_0_0_0 = blocks.uchar_to_float()
self.blocks_uchar_to_float_0_0 = blocks.uchar_to_float()
self.blocks_uchar_to_float_0 = blocks.uchar_to_float()
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_char * 1, samp_rate,
True)
self.blocks_or_xx_0 = blocks.or_bb()
self.blocks_null_source_0 = blocks.null_source(gr.sizeof_char * 1)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_char * 1)
self.blocks_and_xx_0 = blocks.and_bb()
self.analog_sig_source_x_1 = analog.sig_source_b(
samp_rate, analog.GR_SQR_WAVE, 4000, 1, 0, 0)
self.analog_sig_source_x_0 = analog.sig_source_b(
samp_rate, analog.GR_SQR_WAVE, 1000, 1, 0, 0)
self.analog_const_source_x_0 = analog.sig_source_b(
0, analog.GR_CONST_WAVE, 0, 0, 1)
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0),
(self.blocks_xor_xx_0, 1))
self.connect((self.analog_sig_source_x_0, 0),
(self.blocks_and_xx_0, 0))
self.connect((self.analog_sig_source_x_0, 0), (self.blocks_or_xx_0, 0))
self.connect((self.analog_sig_source_x_0, 0),
(self.blocks_uchar_to_float_0, 0))
self.connect((self.analog_sig_source_x_0, 0),
(self.blocks_xor_xx_0_0, 0))
self.connect((self.analog_sig_source_x_1, 0),
(self.blocks_xor_xx_0, 0))
self.connect((self.blocks_and_xx_0, 0),
(self.blocks_uchar_to_float_0_0_0_0, 0))
self.connect((self.blocks_null_source_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_or_xx_0, 0),
(self.blocks_uchar_to_float_0_0_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_null_sink_0, 0))
self.connect((self.blocks_uchar_to_float_0, 0),
(self.qtgui_time_sink_x_0, 0))
self.connect((self.blocks_uchar_to_float_0, 0),
(self.qtgui_time_sink_x_0_0, 0))
self.connect((self.blocks_uchar_to_float_0, 0),
(self.qtgui_time_sink_x_0_0_0, 0))
self.connect((self.blocks_uchar_to_float_0_0, 0),
(self.qtgui_time_sink_x_0_0_0, 1))
self.connect((self.blocks_uchar_to_float_0_0_0, 0),
(self.qtgui_time_sink_x_0_0, 1))
self.connect((self.blocks_uchar_to_float_0_0_0_0, 0),
(self.qtgui_time_sink_x_0, 1))
self.connect((self.blocks_xor_xx_0, 0), (self.blocks_and_xx_0, 1))
self.connect((self.blocks_xor_xx_0, 0), (self.blocks_or_xx_0, 1))
self.connect((self.blocks_xor_xx_0, 0), (self.blocks_xor_xx_0_0, 1))
self.connect((self.blocks_xor_xx_0_0, 0),
(self.blocks_uchar_to_float_0_0, 0))
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):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
##################################################
# Variables
##################################################
self.thresh = thresh = 900*10**-3
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
_thresh_sizer = wx.BoxSizer(wx.VERTICAL)
self._thresh_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_thresh_sizer,
value=self.thresh,
callback=self.set_thresh,
label='thresh',
converter=forms.float_converter(),
proportion=0,
)
self._thresh_slider = forms.slider(
parent=self.GetWin(),
sizer=_thresh_sizer,
value=self.thresh,
callback=self.set_thresh,
minimum=0,
maximum=1,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_thresh_sizer)
self.wxgui_scopesink2_0 = scopesink2.scope_sink_f(
self.GetWin(),
title="Scope Plot",
sample_rate=samp_rate,
v_scale=200*10**-3,
v_offset=0,
t_scale=100*10**-3,
ac_couple=False,
xy_mode=False,
num_inputs=2,
trig_mode=wxgui.TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.Add(self.wxgui_scopesink2_0.win)
self.wxgui_numbersink2_0 = numbersink2.number_sink_f(
self.GetWin(),
unit="Units",
minval=0,
maxval=1,
factor=1.0,
decimal_places=6,
ref_level=0,
sample_rate=samp_rate,
number_rate=15,
average=False,
avg_alpha=None,
label="Number Plot",
peak_hold=False,
show_gauge=True,
)
self.Add(self.wxgui_numbersink2_0.win)
self.digital_glfsr_source_x_0 = digital.glfsr_source_b(6, True, 0, 1)
self.blocks_xor_xx_0 = blocks.xor_bb()
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_char*1, samp_rate,True)
self.blocks_threshold_ff_0 = blocks.threshold_ff(thresh, thresh, 0)
self.blocks_float_to_char_0 = blocks.float_to_char(1, 1)
self.blocks_add_const_vxx_0 = blocks.add_const_vff((0.5, ))
self.blks2_error_rate_0 = grc_blks2.error_rate(
type='BER',
win_size=1280,
bits_per_symbol=1,
)
self.analog_noise_source_x_0 = analog.noise_source_f(analog.GR_UNIFORM, 0.5, 32)
##################################################
# Connections
##################################################
self.connect((self.analog_noise_source_x_0, 0), (self.blocks_add_const_vxx_0, 0))
self.connect((self.blks2_error_rate_0, 0), (self.wxgui_numbersink2_0, 0))
self.connect((self.blks2_error_rate_0, 0), (self.wxgui_scopesink2_0, 0))
self.connect((self.blocks_add_const_vxx_0, 0), (self.blocks_threshold_ff_0, 0))
self.connect((self.blocks_float_to_char_0, 0), (self.blocks_xor_xx_0, 1))
self.connect((self.blocks_threshold_ff_0, 0), (self.blocks_float_to_char_0, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.wxgui_scopesink2_0, 1))
self.connect((self.blocks_throttle_0, 0), (self.blks2_error_rate_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_xor_xx_0, 0))
self.connect((self.blocks_xor_xx_0, 0), (self.blks2_error_rate_0, 1))
self.connect((self.digital_glfsr_source_x_0, 0), (self.blocks_throttle_0, 0))
def sim(self, arity, snr_db, N):
M = 1024
theta_sel = 0
syms_per_frame = 20
zero_pads = 1
# center_preamble = [1, -1j, -1, 1j] # assumed to be normalized to 1
qam_size = 2**arity
# preamble = [0]*M*zero_pads+center_preamble*((int)(M/len(center_preamble)))+[0]*M*zero_pads
# print preamble
# num_symbols = 2**12
exclude_preamble = 1
exclude_multipath = 1
sel_taps = 2 # epa=0, eva = 1, etu=2
freq_offset = 0
exclude_noise = 0
sel_noise_type = 0 # gaussian
eq_select = 0 # 0=1-tap 1=3-taps w/linear intrp 2=3-taps w/ geo. intrp. 3= no eq.
carriers = M
sel_preamble = 0 # 0: IAM-C 1: IAM-C with 3 rep. 2: IAM-R
extra_pad = False
# SNR = 20
K = 4
N = int(N) # num of !samples!
num_bits = N * arity
normalizing_factor = float(1) / (M * .6863) #*.6863)
# print normalizing_factor
# amp = math.sqrt(M/(10**(float(snr_db)/10)))/math.sqrt(2)
# amp = math.sqrt((10**(float(-1*snr_db)/20))*(2*K*M+(2*syms_per_frame-1)*M)/(4*syms_per_frame))/math.sqrt(2)
if exclude_preamble:
amp = normalizing_factor * math.sqrt(
(10**(float(-1 * snr_db) / 10)) *
(2 * K * M + (2 * syms_per_frame - 1) * M) /
(4 * syms_per_frame)) / math.sqrt(2)
# amp = normalizing_factor*math.sqrt((10**(float(-1*snr_db)/10))*(2*K*M+(2*syms_per_frame-1)*M)/(4*syms_per_frame))/math.sqrt(2)
else:
amp = normalizing_factor * math.sqrt(
(10**(float(-1 * snr_db) / 10)) *
(M * (syms_per_frame + 1) /
(syms_per_frame + 1 + 2 * zero_pads)) *
((K * M + (2 * syms_per_frame - 1) * M / 2) /
(M * syms_per_frame))) / math.sqrt(2)
# print amp
# print amp2
taps = (1)
if sel_taps == 0: #epa
taps = (0.998160541385960, 0.0605566335500750, 0.00290305927764350)
elif sel_taps == 1: #eva
taps = (0.748212004186014, 0.317358833370450, 0.572776845645705, 0,
0.0538952624324030, 0.0874078808126807, 0, 0, 0,
0.0276407988816600, 0, 0, 0, 0.00894438719057275)
elif sel_taps == 2: #etu
taps = (0.463990169152204, 0.816124099344485, 0, 0.292064507384192,
0, 0, 0, 0, 0.146379002496595, 0, 0, 0, 0.0923589067029112,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0582745305123628)
tx = ofdm.fbmc_transmitter_hier_bc(M, K, qam_size, syms_per_frame,
carriers, theta_sel,
exclude_preamble, sel_preamble,
zero_pads, extra_pad)
rx = ofdm.fbmc_receiver_hier_cb(M, K, qam_size, syms_per_frame,
carriers, theta_sel, eq_select,
exclude_preamble, sel_preamble,
zero_pads, extra_pad)
# def __init__(self, M=1024, K=4, qam_size=16, syms_per_frame=10, carriers=924, theta_sel=0, sel_eq=0, exclude_preamble=0, sel_preamble=0, zero_pads=1, extra_pad=False):
# ch = ofdm.fbmc_channel_hier_cc(M, K, syms_per_frame, exclude_multipath, sel_taps, freq_offset, exclude_noise, sel_noise_type, snr_db, exclude_preamble, zero_pads)
# src = blocks.vector_source_b(src_data, vlen=1)
xor_block = blocks.xor_bb()
head1 = blocks.head(gr.sizeof_char * 1, N)
head0 = blocks.head(gr.sizeof_char * 1, N)
add_block = blocks.add_vcc(1)
src = blocks.vector_source_b(
map(int, numpy.random.randint(0, qam_size, 100000)), True)
noise = analog.fastnoise_source_c(analog.GR_GAUSSIAN, amp, 0, 8192)
dst = blocks.vector_sink_b(vlen=1)
# ch_model = channels.channel_model(
# noise_voltage=0.0,
# frequency_offset=freq_offset,
# epsilon=1.0,
# taps=taps,
# noise_seed=0,
# block_tags=False
# )
tb = gr.top_block("test_block")
tb.connect((src, 0), (head1, 0)) #esas
tb.connect((head1, 0), (xor_block, 0)) #esas
tb.connect((src, 0), (tx, 0)) #esas
# tb.connect((tx, 0), (add_block, 0)) #esas
if exclude_multipath:
tb.connect((tx, 0), (add_block, 0)) #esas
else:
tb.connect((tx, 0), (ch_model, 0))
tb.connect((ch_model, 0), (add_block, 0))
tb.connect((noise, 0), (add_block, 1)) #esas
tb.connect((add_block, 0), (rx, 0)) #esas
tb.connect((rx, 0), (head0, 0)) #esas
tb.connect((head0, 0), (xor_block, 1)) #esas
tb.connect((xor_block, 0), (dst, 0)) #esas
tb.run()
# what we record in dst.data will be output of xor_block. now we have to process those data
# so as to find bit errors.
result_data = dst.data()
bit_errors = 0
for i in range(len(result_data)):
# print bin(result_data[i])
bit_errors = bit_errors + (bin(result_data[i]).count('1'))
# print len(result_data)
# return 1
return float(bit_errors) / num_bits
def __init__(self):
gr.top_block.__init__(self, "Dsss")
Qt.QWidget.__init__(self)
self.setWindowTitle("Dsss")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "dsss")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.spread_factor = spread_factor = 8
self.spc = spc = 4
self.const = const = digital.constellation_qpsk().base()
self.sps = sps = spc * spread_factor
self.samp_rate = samp_rate = 100e3
self.point = point = const.points()
##################################################
# Blocks
##################################################
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
2048, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"", #name
1 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(0.10)
self.qtgui_freq_sink_x_0.set_y_axis(-140, 10)
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0,
"")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(False)
self.qtgui_freq_sink_x_0.set_fft_average(1.0)
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_freq_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "dark blue"
]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(
self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_freq_sink_x_0_win)
self.digital_psk_mod_0 = digital.psk.psk_mod(
constellation_points=4,
mod_code="gray",
differential=True,
samples_per_symbol=sps,
excess_bw=0.35,
verbose=False,
log=False,
)
self.digital_glfsr_source_x_0 = digital.glfsr_source_b(16, True, 0, 1)
self.channels_channel_model_0 = channels.channel_model(
noise_voltage=0.0001,
frequency_offset=0.0,
epsilon=1.0,
taps=(1.0, ),
noise_seed=0,
block_tags=False)
self.blocks_xor_xx_0 = blocks.xor_bb()
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1,
samp_rate, True)
self.analog_random_source_x_0 = blocks.vector_source_b(
map(int, numpy.random.randint(0, 256, 10000)), True)
##################################################
# Connections
##################################################
self.connect((self.analog_random_source_x_0, 0),
(self.blocks_xor_xx_0, 0))
self.connect((self.blocks_throttle_0, 0),
(self.qtgui_freq_sink_x_0, 0))
self.connect((self.blocks_xor_xx_0, 0), (self.digital_psk_mod_0, 0))
self.connect((self.channels_channel_model_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.digital_glfsr_source_x_0, 0),
(self.blocks_xor_xx_0, 1))
self.connect((self.digital_psk_mod_0, 0),
(self.channels_channel_model_0, 0))
def __init__(self, dab_params, verbose=False, debug=False):
"""
Hierarchical block for FIC decoding
@param dab_params DAB parameter object (grdab.parameters.dab_parameters)
"""
gr.hier_block2.__init__(self, "fic",
gr.io_signature(1, 1, gr.sizeof_float * dab_params.num_carriers * 2),
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 = grdab.select_vectors(gr.sizeof_float, self.dp.num_carriers * 2, self.dp.num_fic_syms, 0)
self.repartition_fic = grdab.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 = grdab.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 = grdab.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 = grdab.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 = grdab.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))
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 sim(self, arity, snr_db, N):
M = 1024
theta_sel = 0
syms_per_frame = 10
zero_pads = 1
center_preamble = [1, -1j, -1, 1j] # assumed to be normalized to 1
qam_size = 2**arity
preamble = [0] * M * zero_pads + center_preamble * (
(int)(M / len(center_preamble))) + [0] * M * zero_pads
# num_symbols = 2**12
exclude_preamble = 0
exclude_multipath = 0
sel_taps = 0 # epa=0, eva = 1, etu=3
freq_offset = 0
exclude_noise = 0
sel_noise_type = 0 # gaussian
eq_select = 3
start = 10
end = 29
# SNR = 20
K = 4
N = int(N) # num of !samples!
num_bits = N * arity
# if sel_preamble == 0: # standard one vector center preamble [1,-j,-1,j]
# self.center_preamble = center_preamble = [1, -1j, -1, 1j]*((int)(M/4))
# elif sel_preamble == 1: # standard preamble with triple repetition
# self.center_preamble = center_preamble = [1, -1j, -1, 1j]*((int)(M/4))*3 #[1/math.sqrt(3), -1j/math.sqrt(3), -1/math.sqrt(3), 1j/math.sqrt(3)]*((int)(M/4))*3
# elif sel_preamble ==2: # IAM-R preamble [1, -1,-1, 1]
# self.center_preamble = center_preamble = [1, -1, -1, 1]*((int)(M/4))
# else: # standard one vector center preamble [1,-j,-1,j]
# self.center_preamble = center_preamble = [1, -1j, -1, 1j]*((int)(M/4))
sel_preamble = 0
zero_pads = 1
extra_pad = False
if exclude_preamble:
amp = math.sqrt((10**(float(-1 * snr_db) / 10)) *
(2 * K * M + (2 * syms_per_frame - 1) * M) /
(4 * syms_per_frame)) / math.sqrt(2)
else:
amp = math.sqrt((10**(float(-1 * snr_db) / 10)) *
(M * (syms_per_frame + 1) /
(syms_per_frame + 1 + 2 * zero_pads)) *
((K * M + (2 * syms_per_frame - 1) * M / 2) /
(M * syms_per_frame))) / math.sqrt(2)
# print amp
# print amp2
tx = fbmc_transmitter_multiuser_bc(M, K, qam_size, syms_per_frame,
start, end, theta_sel,
exclude_preamble, sel_preamble,
zero_pads, extra_pad)
rx = fbmc_receiver_hier_cb(M,
K,
qam_size,
syms_per_frame,
carriers=924,
theta_sel=0,
sel_eq=0,
exclude_preamble=0,
sel_preamble=0,
zero_pads=1,
extra_pad=False)
ch = channel_hier_cc(M, K, syms_per_frame, exclude_multipath, sel_taps,
freq_offset, exclude_noise, sel_noise_type,
snr_db, exclude_preamble, zero_pads)
# # src = blocks.vector_source_b(src_data, vlen=1)
xor_block = blocks.xor_bb()
head1 = blocks.head(gr.sizeof_char * 1, N)
head0 = blocks.head(gr.sizeof_char * 1, N)
add_block = blocks.add_vcc(1)
src = blocks.vector_source_b(
map(int, numpy.random.randint(0, qam_size, 100000)), True)
noise = analog.fastnoise_source_c(analog.GR_GAUSSIAN, amp, 0, 8192)
dst = blocks.vector_sink_b(vlen=1)
tb = gr.top_block("test_block")
tb.connect((src, 0), (head1, 0)) #esas
tb.connect((head1, 0), (xor_block, 0)) #esas
tb.connect((src, 0), (tx, 0)) #esas
tb.connect((tx, 0), (add_block, 0)) #esas
tb.connect((noise, 0), (add_block, 1)) #esas
# tb.connect((head0, 0), (add_block, 1)) #esas
tb.connect((add_block, 0), (rx, 0)) #esas
tb.connect((rx, 0), (head0, 0)) #esas
tb.connect((head0, 0), (xor_block, 1)) #esas
tb.connect((xor_block, 0), (dst, 0)) #esas
tb.run()
# what we record in dst.data will be output of xor_block. now we have to process those data
# so as to find bit errors.
result_data = dst.data()
bit_errors = 0
for i in range(len(result_data)):
# print bin(result_data[i])
bit_errors = bit_errors + (bin(result_data[i]).count('1'))
# print len(result_data)
# return 1
return float(bit_errors) / num_bits
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 sim ( self, arity, snr_db, N ):
vlen = 10
N = int( N )
snr = 10.0**(snr_db/10.0)
sigpow = 1.0
noise_pow = sigpow / snr
#skipping first symbol due to demapper implementation (demmaper assumes that the first symbol is ID and do not decode ui)
skiphead_src = blocks.skiphead( gr.sizeof_char, vlen+3)#vlen+3 )
demapper = ofdm.generic_demapper_vcb( vlen,N/vlen+1 )
const = demapper.get_constellation( arity )
assert( len( const ) == 2**arity )
symsrc = ofdm.symbol_random_src( const, vlen )
#noise_src = ofdm.complex_white_noise( 0.0, sqrt( noise_pow ) )
noise_src = analog.fastnoise_source_c(analog.GR_GAUSSIAN, 0.0, 0, 8192)
channel = blocks.add_cc()
ch_model = channels.channel_model(
noise_voltage=0.0,
frequency_offset=0.0,
epsilon=1.0,
#taps = (0.998160541385960,0.0605566335500750,0.00290305927764350),
taps = (1,0),
noise_seed=8192,
block_tags=False
)
bitmap_src = blocks.vector_source_b( [arity] * vlen, True, vlen )
#bm_trig_src = blocks.vector_source_b( [1], True )
ref_bitstream = blocks.unpack_k_bits_bb( arity )
bitstream_xor = blocks.xor_bb()
bitstream_c2f = blocks.char_to_float()
acc_biterr = ofdm.accumulator_ff()
skiphead = blocks.skiphead( gr.sizeof_float, N-1 )
limit = blocks.head( gr.sizeof_float, 1 )
dst = blocks.vector_sink_f()
rec_dst = blocks.vector_sink_b()
ref_dst = blocks.vector_sink_b()
tb = gr.top_block ( "test_block" )
#tb.connect( (symsrc,0),blocks.vector_to_stream(gr.sizeof_gr_complex ,vlen),blocks.head(gr.sizeof_gr_complex,N/arity),blocks.null_sink(gr.sizeof_gr_complex))
#tb.connect( (symsrc,0),fft.fft_vcc(vlen,False,[],True),blocks.vector_to_stream(gr.sizeof_gr_complex ,vlen), ch_model, (channel,0) )
tb.connect( (symsrc,0),blocks.vector_to_stream(gr.sizeof_gr_complex ,vlen), ch_model, (channel,0) )
tb.connect( noise_src, (channel,1) )
#tb.connect( channel, blocks.stream_to_vector(gr.sizeof_gr_complex ,vlen),fft.fft_vcc(vlen,True,[],True), (demapper,0), (bitstream_xor,0) )
tb.connect( channel, blocks.stream_to_vector(gr.sizeof_gr_complex ,vlen), (demapper,0), (bitstream_xor,0) )
tb.connect( bitmap_src, (demapper,1) )
#tb.connect( bm_trig_src, (demapper,2) )
tb.connect( (symsrc,1),blocks.vector_to_stream(gr.sizeof_char ,vlen),skiphead_src, ref_bitstream, (bitstream_xor,1) )
tb.connect( bitstream_xor, bitstream_c2f, acc_biterr )
tb.connect( acc_biterr, skiphead, limit, dst )
tb.connect( demapper, rec_dst )
tb.connect( ref_bitstream, ref_dst )
tb.run()
bit_errors = numpy.array( dst.data() )
assert( len( bit_errors ) == 1 )
bit_errors = bit_errors[0]
rec_data = list(rec_dst.data())
ref_data = list(ref_dst.data())
print "ref_data: ", ref_data[:2000]
print "size ref_data: ", len(ref_data)#[:2320
print "rec_data: ", rec_data[:500]
print "size rec_data: ", len(rec_data)#[:2320
return bit_errors / N
