def test_001_t(self):
cell_id = 124
N_ant = 2
mib = lte_test.pack_mib(50, 0, 1.0, 511)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
p_scrambled = lte_test.nrz_encoding(p_scrambled)
n_bch = tuple(lte_test.nrz_encoding(bch))
#print len(p_scrambled)
#print p_scrambled[0:20]
self.src.set_data(p_scrambled) #[0:480])
self.descr.set_cell_id(cell_id)
# set up fg
self.tb.run()
res = self.snk.data()
print len(res)
count = 0
for i in range(len(res) / len(n_bch)):
part = res[len(n_bch) * i:(i + 1) * len(n_bch)]
try:
self.assertEqual(part, n_bch, 3)
print str(i) + "\tSUCCESS"
except:
print str(i)
count = count + 1
print "\nresult"
print count
print len(res) / len(n_bch)
def test_002_data(self):
cell_id = 124
N_ant = 2
tl = 1024
data = []
ref_bch = []
for i in range(tl / 4):
mib = lte_test.pack_mib(50, 0, 1.0, i * 4)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
p_scrambled = lte_test.nrz_encoding(p_scrambled)
data.extend(p_scrambled)
bch = tuple(lte_test.nrz_encoding(bch))
ref_bch.extend(bch)
self.src.set_data(data)
self.descr.set_cell_id(cell_id)
self.tb.run()
res = self.snk.data()
print len(res)
count = 0
for i in range(len(res) / len(ref_bch)):
part = res[len(ref_bch) * i:(i + 1) * len(ref_bch)]
try:
self.assertEqual(part, ref_bch, 3)
print str(i) + "\tSUCCESS"
except:
print str(i)
count = count + 1
print "\nresult"
print count
print len(res) / len(ref_bch)
def test_001_generated(self):
print "\ntest_001_generated"
cell_id = 124
N_ant = 2
style = "tx_diversity"
mib = lte_test.pack_mib(50, 0, 1.0, 511)
bch = lte_test.encode_bch(mib, N_ant)
scrambled = lte_test.pbch_scrambling(bch, cell_id)
qpsk_modulated = lte_test.qpsk_modulation(scrambled)
#print np.shape(qpsk_modulated)
layer_mapped = lte_test.layer_mapping(qpsk_modulated, N_ant, style)
pre_coded = lte_test.pre_coding(layer_mapped, N_ant, style)
#print np.shape(pre_coded)
h0 = [complex(1, 0)] * len(pre_coded[0])
h1 = [complex(1, 0)] * len(pre_coded[1])
stream = [pre_coded[0][i] + pre_coded[1][i] for i in range(len(pre_coded[0]))]
self.src1.set_data(stream)
self.src2.set_data(h0)
self.src3.set_data(h1)
self.tb.run()
res = self.snk.data()
exp_res = []
for i in range(len(stream) / 240):
print i
lay0 = layer_mapped[0][i * 120:(i + 1) * 120]
lay1 = layer_mapped[1][i * 120:(i + 1) * 120]
comb = [lay0, lay1]
exp_res.extend(lte_test.prepare_for_demapper_block(comb, N_ant, style))
print "test 001 final ASSERT!"
print self.assertComplexTuplesAlmostEqual(res, exp_res)
def test_001_t(self):
cell_id = 124
N_ant = 2
mib = lte_test.pack_mib(50, 0, 1.0, 511)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
p_scrambled = lte_test.nrz_encoding(p_scrambled)
n_bch = tuple(lte_test.nrz_encoding(bch))
self.src.set_data(p_scrambled[0:480])
self.descr.set_cell_id(cell_id)
# set up fg
self.tb.run()
res = self.snk.data()
count = 0
for i in range(len(res) / len(n_bch)):
part = res[len(n_bch) * i : (i + 1) * len(n_bch)]
try:
self.assertEqual(part, n_bch, 3)
print str(i) + "\tSUCCESS"
except:
print str(i)
count = count + 1
print "\nresult"
print count
print len(res) / len(n_bch)
def test_001_t(self):
cell_id = 124
N_ant = 2
tl = 1024
data = []
input_data = []
for i in range(tl / 4):
mib = lte_test.pack_mib(50, 0, 1.0, i * 4)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
input_data.extend(lte_test.nrz_encoding(p_scrambled))
mod = lte_test.qpsk_modulation(p_scrambled)
data.extend(mod)
self.src.set_data(data)
dbgs = blocks.file_sink(240 * gr.sizeof_gr_complex,
"/home/johannes/tests/demodulate.dat")
self.tb.connect(self.src, dbgs)
# set up fg
self.tb.run()
# check data
res = self.snk.data()
exp_res = tuple(
input_data
) #tuple([input_data[i]/math.sqrt(2) for i in range(len(input_data))])
print self.assertFloatTuplesAlmostEqual(res, exp_res, 5)
def test_001_t (self):
print "demodulation test"
mib = lte_test.pack_mib(50,0,1.0, 511)
bch = lte_test.encode_bch(mib, 2)
p_scrambled = lte_test.pbch_scrambling(bch, 124)
input_data = p_scrambled#[0:480]
qpsk_mod = lte_test.qpsk_modulation(input_data)
input_data = lte_test.nrz_encoding(input_data)
self.src.set_data(qpsk_mod)
# set up fg
self.tb.run ()
# check data
res = self.snk.data()
exp_res = tuple(input_data)#tuple([input_data[i]/math.sqrt(2) for i in range(len(input_data))])
print self.assertFloatTuplesAlmostEqual(res, exp_res, 5)
def test_002_data(self):
cell_id = 124
N_ant = 2
tl = 1024
data = []
for i in range(tl/4):
mib = lte_test.pack_mib(50,0,1.0, i*4)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
p_scrambled = lte_test.nrz_encoding(p_scrambled)
data.extend(p_scrambled)
self.src.set_data(data)
dbgs = blocks.file_sink(480 * gr.sizeof_float, "/home/johannes/tests/descramble.dat")
self.tb.connect(self.src, dbgs)
# set up fg
self.tb.run ()
pass
def test_002_data(self):
cell_id = 124
N_ant = 2
tl = 1024
data = []
for i in range(tl / 4):
mib = lte_test.pack_mib(50, 0, 1.0, i * 4)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
p_scrambled = lte_test.nrz_encoding(p_scrambled)
data.extend(p_scrambled)
self.src.set_data(data)
dbgs = blocks.file_sink(480 * gr.sizeof_float,
"/home/johannes/tests/descramble.dat")
self.tb.connect(self.src, dbgs)
# set up fg
self.tb.run()
pass
def test_003_demapping (self):
print "\ntest_003_demapping"
N_ant = [1,2,4]
cell_id = 124
mib = lte_test.pack_mib(50,0,1.0, 511)
bch = tuple(lte_test.encode_bch(mib, N_ant[0]))
data = lte_test.pbch_scrambling(bch, cell_id)
style = "tx_diversity"
self.demapper.set_decoding_style(style)
mapped = [[],[],[]]
mapped[0] = lte_test.layer_mapping(data, 1 , style)
m2 = lte_test.layer_mapping(data, 2 , style)
m2a = []
for i in range(len(m2[0])/120):
m2a.extend(m2[0][120*i:(i+1)*120])
m2a.extend(m2[1][120*i:(i+1)*120])
mapped[1] = m2a
m4 = lte_test.layer_mapping(data, 4, style)
m4a = []
for i in range(len(m4[0])/60):
m4a.extend(m4[0][i*60:(i+1)*60])
m4a.extend(m4[1][i*60:(i+1)*60])
m4a.extend(m4[2][i*60:(i+1)*60])
m4a.extend(m4[3][i*60:(i+1)*60])
mapped[2] = m4a
exp_res = [complex(data[i]) for i in range(len(data))]
for i in range(3):
self.demapper.set_N_ant(N_ant[i])
print "N_ant = " +str(self.demapper.get_N_ant())
self.src.set_data(mapped[i])
self.snk.reset()
self.tb.run()
res = self.snk.data()
try:
self.assertComplexTuplesAlmostEqual(res, tuple(exp_res) )
except:
print "FAILED N_ant = " +str(self.demapper.get_N_ant())
self.assertComplexTuplesAlmostEqual(res, tuple(exp_res) )
def test_003_demapping(self):
print "\ntest_003_demapping"
N_ant = [1, 2, 4]
cell_id = 124
mib = lte_test.pack_mib(50, 0, 1.0, 511)
bch = tuple(lte_test.encode_bch(mib, N_ant[0]))
data = lte_test.pbch_scrambling(bch, cell_id)
style = "tx_diversity"
self.demapper.set_decoding_style(style)
mapped = [[], [], []]
mapped[0] = lte_test.layer_mapping(data, 1, style)[0]
m2 = lte_test.layer_mapping(data, 2, style)
m2a = []
for i in range(len(m2[0]) / 120):
m2a.extend(m2[0][120 * i:(i + 1) * 120])
m2a.extend(m2[1][120 * i:(i + 1) * 120])
mapped[1] = m2a
m4 = lte_test.layer_mapping(data, 4, style)
m4a = []
for i in range(len(m4[0]) / 60):
m4a.extend(m4[0][i * 60:(i + 1) * 60])
m4a.extend(m4[1][i * 60:(i + 1) * 60])
m4a.extend(m4[2][i * 60:(i + 1) * 60])
m4a.extend(m4[3][i * 60:(i + 1) * 60])
mapped[2] = m4a
exp_res = [complex(data[i]) for i in range(len(data))]
for i in range(3):
self.demapper.set_N_ant(N_ant[i])
print "N_ant = " + str(self.demapper.get_N_ant()), np.shape(mapped[i])
self.src.set_data(mapped[i])
self.snk.reset()
self.tb.run()
res = self.snk.data()
try:
self.assertComplexTuplesAlmostEqual(res, tuple(exp_res))
except:
print "FAILED N_ant = " + str(self.demapper.get_N_ant())
self.assertComplexTuplesAlmostEqual(res, tuple(exp_res))
def test_001_generated(self):
print "\ntest_001_generated"
cell_id = 124
N_ant = 2
style = "tx_diversity"
mib = lte_test.pack_mib(50, 0, 1.0, 511)
bch = lte_test.encode_bch(mib, N_ant)
scrambled = lte_test.pbch_scrambling(bch, cell_id)
qpsk_modulated = lte_test.qpsk_modulation(scrambled)
#print np.shape(qpsk_modulated)
layer_mapped = lte_test.layer_mapping(qpsk_modulated, N_ant, style)
pre_coded = lte_test.pre_coding(layer_mapped, N_ant, style)
#print np.shape(pre_coded)
h0 = [complex(1, 0)] * len(pre_coded[0])
h1 = [complex(1, 0)] * len(pre_coded[1])
stream = [
pre_coded[0][i] + pre_coded[1][i] for i in range(len(pre_coded[0]))
]
self.src1.set_data(stream)
self.src2.set_data(h0)
self.src3.set_data(h1)
self.tb.run()
res = self.snk.data()
exp_res = []
for i in range(len(stream) / 240):
print i
lay0 = layer_mapped[0][i * 120:(i + 1) * 120]
lay1 = layer_mapped[1][i * 120:(i + 1) * 120]
comb = [lay0, lay1]
exp_res.extend(
lte_test.prepare_for_demapper_block(comb, N_ant, style))
print "test 001 final ASSERT!"
print self.assertComplexTuplesAlmostEqual(res, exp_res)
def test_001_t(self):
cell_id = 124
N_ant = 2
mib = lte_test.pack_mib(50, 0, 1.0, 511)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
p_scrambled = lte_test.nrz_encoding(p_scrambled)
n_bch = tuple(lte_test.nrz_encoding(bch))
print len(p_scrambled)
print p_scrambled[0:20]
self.src.set_data(p_scrambled) #[0:480])
self.descr.set_cell_id(cell_id)
#pn_seq = self.descr.pn_sequence()
#print pn_seq[0:20]
dbgs = blocks.file_sink(480 * gr.sizeof_float,
"/home/johannes/tests/descramble.dat")
self.tb.connect(self.src, dbgs)
# set up fg
self.tb.run()
res = self.snk.data()
print len(res)
count = 0
for i in range(len(res) / len(n_bch)):
part = res[len(n_bch) * i:(i + 1) * len(n_bch)]
try:
self.assertEqual(part, n_bch, 3)
print str(i) + "\tSUCCESS"
except:
print str(i)
count = count + 1
print "\nresult"
print count
print len(res) / len(n_bch)
def test_001_t(self):
cell_id = 124
N_ant = 2
mib = lte_test.pack_mib(50,0,1.0, 511)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
p_scrambled = lte_test.nrz_encoding(p_scrambled)
n_bch = tuple(lte_test.nrz_encoding(bch))
print len(p_scrambled)
print p_scrambled[0:20]
self.src.set_data(p_scrambled)#[0:480])
self.descr.set_cell_id(cell_id)
#pn_seq = self.descr.pn_sequence()
#print pn_seq[0:20]
dbgs = blocks.file_sink(480 * gr.sizeof_float, "/home/johannes/tests/descramble.dat")
self.tb.connect(self.src, dbgs)
# set up fg
self.tb.run()
res = self.snk.data()
print len(res)
count = 0
for i in range(len(res)/len(n_bch)):
part = res[len(n_bch)*i:(i+1)*len(n_bch)]
try:
self.assertEqual(part, n_bch,3)
print str(i) + "\tSUCCESS"
except:
print str(i)
count = count +1
print "\nresult"
print count
print len(res)/len(n_bch)
def test_001_t (self):
cell_id = 124
N_ant = 2
tl = 1024
data = []
input_data = []
for i in range(tl/4):
mib = lte_test.pack_mib(50,0,1.0, i*4)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
input_data.extend(lte_test.nrz_encoding(p_scrambled))
mod = lte_test.qpsk_modulation(p_scrambled)
data.extend(mod)
self.src.set_data(data)
dbgs = blocks.file_sink(240 * gr.sizeof_gr_complex, "/home/johannes/tests/demodulate.dat")
self.tb.connect(self.src, dbgs)
# set up fg
self.tb.run ()
# check data
res = self.snk.data()
exp_res = tuple(input_data)#tuple([input_data[i]/math.sqrt(2) for i in range(len(input_data))])
print self.assertFloatTuplesAlmostEqual(res, exp_res, 5)
def test_001_t(self):
cell_id = 124
N_ant = 2
tl = 1024
data = []
input_data = []
for i in range(tl / 4):
mib = lte_test.pack_mib(50, 0, 1.0, i * 4)
bch = tuple(lte_test.encode_bch(mib, N_ant))
p_scrambled = lte_test.pbch_scrambling(bch, cell_id)
input_data.extend(lte_test.nrz_encoding(p_scrambled))
mod = lte_test.qpsk_modulation(p_scrambled)
data.extend(mod)
self.src.set_data(data)
# set up fg
self.tb.run()
# check data
res = self.snk.data()
exp_res = tuple(
input_data
) #tuple([input_data[i]/math.sqrt(2) for i in range(len(input_data))])
self.assertFloatTuplesAlmostEqual(res, exp_res, 5)
