def test_003_data_gen(self):
N_rb_dl = self.N_rb_dl
subcarriers = self.subcarriers
N_ofdm_symbols = self.N_ofdm_symbols
tag_key = self.tag_key
msg_buf_name = self.msg_buf_name
cell_id = 124
Ncp = 1
N_ant = 2
style= "tx_diversity"
sfn = 0
srcid = "source"
nf = 4
data = []
for sfn in range(nf):
mib = lte_test.pack_mib(N_rb_dl, 0, 1.0, sfn)
bch = lte_test.encode_bch(mib, N_ant)
pbch = lte_test.encode_pbch(bch, cell_id, N_ant, style)
frame = lte_test.generate_phy_frame(cell_id, N_rb_dl, N_ant)
for p in range(len(frame)):
frame[p] = lte_test.map_pbch_to_frame_layer(frame[p], pbch[p], cell_id, sfn, p)
stream = frame[0].flatten().tolist()
stream = np.add(stream, frame[1].flatten().tolist() )
data.extend(stream)
print len(data)
tags = lte_test.get_tag_list(140 * nf, 140, self.tag_key, srcid)
tb2 = gr.top_block ()
src = blocks.vector_source_c(data, False, subcarriers)
dbg = blocks.file_sink(gr.sizeof_gr_complex * 12*N_rb_dl, "/home/johannes/tests/est_frame_data.dat")
tb2.connect(src, dbg)
tb2.run()
def get_tag_list(self, fft_len, initial_offset, num_tags, value_range, inkey, srcid):
slotl = t.get_slot_length(fft_len)
tl = t.get_tag_list(num_tags, value_range, inkey, srcid)
for s in tl:
s.offset *= slotl
s.offset += initial_offset
return tl
def setUp(self):
self.tb = gr.top_block()
key = "subframe"
msg_buf_name = "cfi"
print "setup test"
data = []
self.cfi_list = []
for i in range(3):
val = i + 1
self.cfi_list.append(val)
cfi = lte_test.get_cfi_sequence(val)
data.extend(lte_test.nrz_encoding(cfi))
reps = 5
self.cfi_list *= reps
srcid = "src"
taglist = lte_test.get_tag_list(3 * reps, 10, key, srcid)
data = [float(data[i]) for i in range(len(data))]
ext_data = []
for i in range(reps):
ext_data.extend(data)
data = ext_data
self.src = blocks.vector_source_f(data, False, 32, taglist)
self.cfi = lte.pcfich_unpack_vfm(key, msg_buf_name)
self.cfi.activate_debug_mode(True)
self.tb.connect(self.src, self.cfi)
print "setup finished"
def test_003_data_gen(self):
N_rb_dl = self.N_rb_dl
subcarriers = self.subcarriers
N_ofdm_symbols = self.N_ofdm_symbols
tag_key = self.tag_key
msg_buf_name = self.msg_buf_name
cell_id = 124
Ncp = 1
N_ant = 2
style = "tx_diversity"
sfn = 0
srcid = "source"
nf = 4
data = []
for sfn in range(nf):
mib = lte_test.pack_mib(N_rb_dl, 0, 1.0, sfn)
bch = lte_test.encode_bch(mib, N_ant)
pbch = lte_test.encode_pbch(bch, cell_id, N_ant, style)
frame = lte_test.generate_phy_frame(cell_id, N_rb_dl, N_ant)
for p in range(len(frame)):
frame[p] = lte_test.map_pbch_to_frame_layer(
frame[p], pbch[p], cell_id, sfn, p)
stream = frame[0].flatten().tolist()
stream = np.add(stream, frame[1].flatten().tolist())
data.extend(stream)
print len(data)
tags = lte_test.get_tag_list(140 * nf, 140, self.tag_key, srcid)
tb2 = gr.top_block()
src = blocks.vector_source_c(data, False, subcarriers)
tb2.run()
def get_tag_list(self, fft_len, initial_offset, num_tags, value_range,
inkey, srcid):
slotl = t.get_slot_length(fft_len)
tl = t.get_tag_list(num_tags, value_range, inkey, srcid)
for s in tl:
s.offset *= slotl
s.offset += initial_offset
return tl
def test_001_t(self):
cell_id = 124
N_ant = 2
style = "tx_diversity"
N_rb_dl = self.N_rb_dl
sim_frames = 4
self.demux.set_cell_id(cell_id)
sfn = 512
mib = lte_test.pack_mib(N_rb_dl, 0, 1.0, sfn)
bch = lte_test.encode_bch(mib, N_ant)
pbch = lte_test.encode_pbch(bch, cell_id, N_ant, style)
stream = []
#for i in range(sim_frames):
# frame = lte_test.generate_frame(pbch, N_rb_dl, cell_id, i+20, N_ant)
# stream.extend(frame[0].flatten())
#
#print len(stream)
for i in range(sim_frames):
frame = lte_test.generate_phy_frame(cell_id, N_rb_dl, N_ant)
for p in range(len(frame)):
frame[p] = lte_test.map_pbch_to_frame_layer(
frame[p], pbch[p], cell_id, sfn + i, p)
stream.extend(frame[0].flatten().tolist())
key = self.key
srcid = "source"
tags = lte_test.get_tag_list(140 * sim_frames, 140, key, srcid)
self.src1.set_data(stream, tuple(tags))
self.dbg = blocks.file_sink(gr.sizeof_gr_complex * 12 * N_rb_dl,
"/home/johannes/tests/pbch_frame.dat")
self.tb.connect(self.src1, self.dbg)
# set up fg
self.tb.run()
# check data
res1 = self.snk1.data()
#res2 = self.snk2.data()
#res3 = self.snk3.data()
print len(res1)
compare = res1[0:len(pbch[0])]
#'''
#partl = 10
#for i in range(len(res1)/partl):
# partres = compare[partl*i:partl*(i+1)]
# partcom = pbch[0][partl*i:partl*(i+1)]
# try:
# self.assertComplexTuplesAlmostEqual(partcom,partres)
# print str(i*partl) + "\tsuccess"
# except:
# #print "\n\n\n\n\n\n"
# print str(i*partl) + "\t" + str(partres)
#'''
self.assertComplexTuplesAlmostEqual(compare,
tuple(pbch[0][0:len(compare)]))
def test_001_t (self):
cell_id = 124
N_ant = 2
style= "tx_diversity"
N_rb_dl = self.N_rb_dl
sim_frames = 4
self.demux.set_cell_id(cell_id)
sfn = 512
mib = lte_test.pack_mib(N_rb_dl, 0, 1.0, sfn)
bch = lte_test.encode_bch(mib, N_ant)
pbch = lte_test.encode_pbch(bch, cell_id, N_ant, style)
stream = []
#for i in range(sim_frames):
# frame = lte_test.generate_frame(pbch, N_rb_dl, cell_id, i+20, N_ant)
# stream.extend(frame[0].flatten())
#
#print len(stream)
for i in range(sim_frames):
frame = lte_test.generate_phy_frame(cell_id, N_rb_dl, N_ant)
for p in range(len(frame)):
frame[p] = lte_test.map_pbch_to_frame_layer(frame[p], pbch[p], cell_id, sfn+i, p)
stream.extend(frame[0].flatten().tolist() )
key = self.key
srcid = "source"
tags = lte_test.get_tag_list(140 * sim_frames, 140, key, srcid)
self.src1.set_data(stream, tuple(tags))
self.dbg = blocks.file_sink(gr.sizeof_gr_complex * 12*N_rb_dl, "/home/johannes/tests/pbch_frame.dat")
self.tb.connect(self.src1, self.dbg)
# set up fg
self.tb.run ()
# check data
res1 = self.snk1.data()
#res2 = self.snk2.data()
#res3 = self.snk3.data()
print len(res1)
compare = res1[0:len(pbch[0])]
#'''
#partl = 10
#for i in range(len(res1)/partl):
# partres = compare[partl*i:partl*(i+1)]
# partcom = pbch[0][partl*i:partl*(i+1)]
# try:
# self.assertComplexTuplesAlmostEqual(partcom,partres)
# print str(i*partl) + "\tsuccess"
# except:
# #print "\n\n\n\n\n\n"
# print str(i*partl) + "\t" + str(partres)
#'''
self.assertComplexTuplesAlmostEqual(compare, tuple(pbch[0][0:len(compare)]))
def test_002_t(self):
print "test_002_t BEGIN"
N_rb_dl = self.N_rb_dl
subcarriers = self.subcarriers
N_ofdm_symbols = self.N_ofdm_symbols
tag_key = self.tag_key
msg_buf_name = self.msg_buf_name
cell_id = 124
Ncp = 1
N_ant = 2
style = "tx_diversity"
sfn = 0
srcid = "source"
print "get and set data"
stream = self.get_data_stream(N_ant, cell_id, style, N_rb_dl, sfn,
subcarriers)
data_len = len(stream) / subcarriers
tag_list = lte_test.get_tag_list(data_len, N_ofdm_symbols, tag_key,
srcid)
self.src.set_data(stream, tag_list)
print "get and set pilot map"
[rs_pos_frame, rs_val_frame
] = lte_test.frame_pilot_value_and_position(N_rb_dl, cell_id, Ncp, 0)
self.estimator.set_pilot_map(rs_pos_frame, rs_val_frame)
print "pilot Map set"
self.tb.run()
# check data
#print pmt.pmt_symbol_to_string(tag_list[0].key)
expected = np.ones((subcarriers, ), dtype=np.complex)
res = self.snk.data()
failed = 0
first_failed = -1
for i in range(len(res) / subcarriers):
#print i
vec = res[i * subcarriers:(i + 1) * subcarriers]
try:
self.assertComplexTuplesAlmostEqual(vec, expected, 5)
#print "success"
except:
print str(i) + "\tfail"
print vec[0:20]
first_failed = i
#print vec
failed = failed + 1
print "failed vectors: " + str(failed)
if first_failed > -1:
i = first_failed
vec = res[i * subcarriers:(i + 1) * subcarriers]
self.assertComplexTuplesAlmostEqual(vec, expected, 5)
print "test_002_t END\n\n"
def test_002_t (self):
print "test_002_t BEGIN"
N_rb_dl = self.N_rb_dl
subcarriers = self.subcarriers
N_ofdm_symbols = self.N_ofdm_symbols
tag_key = self.tag_key
msg_buf_name = self.msg_buf_name
cell_id = 124
Ncp = 1
N_ant = 2
style= "tx_diversity"
sfn = 0
srcid = "source"
print "get and set data"
stream = self.get_data_stream(N_ant, cell_id, style, N_rb_dl, sfn, subcarriers)
data_len = len(stream)/subcarriers
tag_list = lte_test.get_tag_list(data_len, N_ofdm_symbols, tag_key, srcid)
self.src.set_data(stream, tag_list)
print "get and set pilot map"
[rs_pos_frame, rs_val_frame] = lte_test.frame_pilot_value_and_position(N_rb_dl, cell_id, Ncp, 0)
self.estimator.set_pilot_map(rs_pos_frame, rs_val_frame)
print "pilot Map set"
self.tb.run ()
# check data
#print pmt.pmt_symbol_to_string(tag_list[0].key)
expected = np.ones((subcarriers,), dtype=np.complex)
res = self.snk.data()
failed = 0
first_failed = -1
for i in range(len(res)/subcarriers):
#print i
vec = res[i*subcarriers:(i+1)*subcarriers]
try:
self.assertComplexTuplesAlmostEqual(vec, expected, 5)
#print "success"
except:
print str(i) + "\tfail"
print vec[0:20]
first_failed = i
#print vec
failed = failed +1
print "failed vectors: " + str(failed)
if first_failed > -1:
i = first_failed
vec = res[i*subcarriers:(i+1)*subcarriers]
self.assertComplexTuplesAlmostEqual(vec, expected, 5)
print "test_002_t END\n\n"
def test_002_pcfich(self):
print "pcfich test"
cfi = 2
cell_id = 387
vlen = 32
# Generate descrambling sequences.
seqs = []
for ns in range(10):
#scr = lte_test.scramble_cfi_sequence([0] * 32, cell_id, ns)
scr = lte_test.get_pcfich_scrambling_sequence(cell_id, ns)
seqs.append(lte_test.nrz_encoding(scr))
# Generate a CFI sequence
cfi_seq = lte_test.get_cfi_sequence(cfi)
nrz_cfi_seq = lte_test.nrz_encoding(cfi_seq)
# Generate scrambled sequences
nvecs = 100
scr_cfi_seqs = []
expres = []
for ns in range(nvecs):
scr_cfi_seqs.extend(
lte_test.nrz_encoding(
lte_test.scramble_cfi_sequence(cfi_seq, cell_id, ns % 10)))
expres.extend(nrz_cfi_seq)
# Get tags
tags = lte_test.get_tag_list(nvecs, 10, self.tag_key, "test_src")
# Get blocks for test flowgraph
src = blocks.vector_source_f(scr_cfi_seqs, False, vlen)
src.set_data(scr_cfi_seqs, tags)
descr = lte.descrambler_vfvf(self.tag_key, "cfi_seqs", vlen)
descr.set_descr_seqs(seqs)
snk = blocks.vector_sink_f(vlen)
# Create, connect, run fg
tb = gr.top_block()
tb.connect(src, descr, snk)
tb.run()
# Get result
res = snk.data()
# Check results!
self.assertFloatTuplesAlmostEqual(res, expres)
def test_002_pcfich(self):
print "pcfich test"
cfi = 2
cell_id = 387
vlen =32
# Generate descrambling sequences.
seqs = []
for ns in range(10):
#scr = lte_test.scramble_cfi_sequence([0] * 32, cell_id, ns)
scr = lte_test.get_pcfich_scrambling_sequence(cell_id, ns)
seqs.append(lte_test.nrz_encoding(scr))
# Generate a CFI sequence
cfi_seq = lte_test.get_cfi_sequence(cfi)
nrz_cfi_seq = lte_test.nrz_encoding(cfi_seq)
# Generate scrambled sequences
nvecs = 100
scr_cfi_seqs = []
expres = []
for ns in range(nvecs):
scr_cfi_seqs.extend(lte_test.nrz_encoding(lte_test.scramble_cfi_sequence(cfi_seq, cell_id, ns%10)))
expres.extend(nrz_cfi_seq)
# Get tags
tags = lte_test.get_tag_list(nvecs, 10, self.tag_key, "test_src")
# Get blocks for test flowgraph
src = blocks.vector_source_f(scr_cfi_seqs, False, vlen)
src.set_data(scr_cfi_seqs, tags)
descr = lte.descrambler_vfvf(self.tag_key, "cfi_seqs", vlen)
descr.set_descr_seqs(seqs)
snk = blocks.vector_sink_f(vlen)
# Create, connect, run fg
tb = gr.top_block()
tb.connect(src, descr, snk)
tb.run()
# Get result
res = snk.data()
# Check results!
self.assertFloatTuplesAlmostEqual(res, expres)
def test_001_t(self):
print "test_001_t"
# set up fg
cell_id = 124
max_len = 84 * self.cce_len
n_cce = 20
pdcch_format = 3
# set up descrambling block
seqs = []
for sub in range(10):
seq = lte_test.get_pdcch_scrambling_sequence(
max_len, cell_id, 2 * sub)
seqs.append(lte_test.nrz_encoding(seq))
self.descr.set_descr_seqs(seqs)
# generate test data
data = []
exp_res = []
for i in range(n_cce):
pdcch = lte_test.get_pdcch(pdcch_format)
exp_res.extend(lte_test.nrz_encoding(pdcch))
scr = lte_test.scramble_pdcch(pdcch, 2 * (i % 10), cell_id)
data.extend(lte_test.nrz_encoding(scr))
#data = [0] * self.cce_len * n_cce
tag_list = lte_test.get_tag_list(n_cce, 10, self.tag_key, "source")
for i in range(len(tag_list)):
tag_list[i].offset *= (2**pdcch_format)
self.src.set_data(data, tag_list)
self.tb.run()
# check data
res = self.snk.data()
# self.assertFloatTuplesAlmostEqual(res, exp_res)
for i in range(self.cce_len * n_cce):
# print i
resp = res[i * n_cce:(i + 1) * n_cce]
expp = exp_res[i * n_cce:(i + 1) * n_cce]
self.assertFloatTuplesAlmostEqual(resp, expp)
def test_001_t(self):
print "test_001_t"
# set up fg
cell_id = 124
max_len = 84 * self.cce_len
n_cce = 20
pdcch_format = 3
# set up descrambling block
seqs = []
for sub in range(10):
seq = lte_test.get_pdcch_scrambling_sequence(max_len, cell_id, 2 * sub)
seqs.append(lte_test.nrz_encoding(seq))
self.descr.set_descr_seqs(seqs)
# generate test data
data = []
exp_res = []
for i in range(n_cce):
pdcch = lte_test.get_pdcch(pdcch_format)
exp_res.extend(lte_test.nrz_encoding(pdcch))
scr = lte_test.scramble_pdcch(pdcch, 2 * (i % 10), cell_id)
data.extend(lte_test.nrz_encoding(scr))
#data = [0] * self.cce_len * n_cce
tag_list = lte_test.get_tag_list(n_cce, 10, self.tag_key, "source")
for i in range(len(tag_list)):
tag_list[i].offset *= (2 ** pdcch_format)
self.src.set_data(data, tag_list)
self.tb.run()
# check data
res = self.snk.data()
# self.assertFloatTuplesAlmostEqual(res, exp_res)
for i in range(self.cce_len * n_cce):
# print i
resp = res[i * n_cce:(i + 1) * n_cce]
expp = exp_res[i * n_cce:(i + 1) * n_cce]
self.assertFloatTuplesAlmostEqual(resp, expp)
def test_001_t (self):
cell_id = 124
N_ant = 2
style= "tx_diversity"
N_rb_dl = self.N_rb_dl
sim_frames = 4
self.demux.set_cell_id(cell_id)
sfn = 512
mib = lte_test.pack_mib(N_rb_dl, 0, 1.0, sfn)
bch = lte_test.encode_bch(mib, N_ant)
pbch = lte_test.encode_pbch(bch, cell_id, N_ant, style)
stream = []
#for i in range(sim_frames):
# frame = lte_test.generate_frame(pbch, N_rb_dl, cell_id, i+20, N_ant)
# stream.extend(frame[0].flatten())
#
#print len(stream)
for i in range(sim_frames):
frame = lte_test.generate_phy_frame(cell_id, N_rb_dl, N_ant)
for p in range(len(frame)):
frame[p] = lte_test.map_pbch_to_frame_layer(frame[p], pbch[p], cell_id, sfn+i, p)
stream.extend(frame[0].flatten().tolist() )
key = self.key
srcid = "source"
tags = lte_test.get_tag_list(140 * sim_frames, 140, key, srcid)
self.src1.set_data(stream, tuple(tags))
# set up fg
self.tb.run ()
# check data
res1 = self.snk1.data()
print len(res1)
compare = res1[0:len(pbch[0])]
self.assertComplexTuplesAlmostEqual(compare, tuple(pbch[0][0:len(compare)]))
def test_001_t (self):
cell_id = 124
srcid = "test_src"
N_ant = 2
style = "tx_diversity"
N_rb_dl = self.N_rb_dl
sfn = 0
Ncp = 1
cfi = 2
mib = lte_test.pack_mib(50,0,1.0, 511)
bch = lte_test.encode_bch(mib, N_ant)
pbch = lte_test.encode_pbch(bch, cell_id, N_ant, style)
exp_res = []
for sub in range(10):
ns = sub * 2
pcfich = lte_test.encode_pcfich(cfi, cell_id, ns, N_ant)
exp_res.append(pcfich[0])
frame = lte_test.generate_frame(pbch, N_rb_dl, cell_id, sfn, N_ant)
data = frame[0].flatten()
taglist = lte_test.get_tag_list(len(frame[0]), 140, self.key, srcid)
self.src0.set_data(data, taglist)
self.demux.set_cell_id(cell_id)
#print calculate_pcfich_pos(N_rb_dl, cell_id)
# set up fg
self.tb.run()
# check data
res = self.snk0.data()
print "test 001 check res"
for i in range(len(res)/len(exp_res[0])):
part = res[i*16:(i+1)*16]
self.assertComplexTuplesAlmostEqual(part, exp_res[i])
def test_001_t(self):
cell_id = 124
srcid = "test_src"
N_ant = 2
style = "tx_diversity"
N_rb_dl = self.N_rb_dl
sfn = 0
Ncp = 1
cfi = 2
mib = lte_test.pack_mib(50, 0, 1.0, 511)
bch = lte_test.encode_bch(mib, N_ant)
pbch = lte_test.encode_pbch(bch, cell_id, N_ant, style)
exp_res = []
for sub in range(10):
ns = sub * 2
pcfich = lte_test.encode_pcfich(cfi, cell_id, ns, N_ant)
exp_res.append(pcfich[0])
frame = lte_test.generate_frame(pbch, N_rb_dl, cell_id, sfn, N_ant)
data = frame[0].flatten()
taglist = lte_test.get_tag_list(len(frame[0]), 140, self.key, srcid)
self.src0.set_data(data, taglist)
self.demux.set_cell_id(cell_id)
#print calculate_pcfich_pos(N_rb_dl, cell_id)
# set up fg
self.tb.run()
# check data
res = self.snk0.data()
print "test 001 check res"
for i in range(len(res) / len(exp_res[0])):
part = res[i * 16:(i + 1) * 16]
self.assertComplexTuplesAlmostEqual(part, exp_res[i])
