def generate_preamble(self, subcarriers, active_subcarriers, cp_len,
ramp_len, cyclic_shift):
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers,
dc_free=True)
return mapped_preamble(self.seed, self.filtertype, self.filteralpha,
active_subcarriers, subcarriers,
subcarrier_map, self.overlap, cp_len, ramp_len,
use_zadoff_chu=True, cyclic_shift=cyclic_shift)
def test_003_snr(self):
nframes = 30
timeslots = 5
subcarriers = 1024
active_subcarriers = 936
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
active_ratio = subcarriers / active_subcarriers
subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers,
dc_free=True)
preambles = mapped_preamble(self.seed, self.filtertype, self.filteralpha,
active_subcarriers, subcarriers,
subcarrier_map, overlap, cp_len, ramp_len)
core_preamble = preambles[1]
sigenergy = calculate_energy(core_preamble)
data = np.copy(core_preamble)
snrs = np.arange(3, 3 * nframes, 3, dtype=np.float)
snrs_lin = 10. ** (snrs / 10.)
expected_snrs_lin = np.concatenate(((np.inf,), snrs_lin))
for i, snr_lin in enumerate(snrs_lin):
nscale = calculate_noise_scale(
snr_lin, sigenergy, active_ratio, core_preamble.size)
noise = get_noise_vector(core_preamble.size, nscale)
d = core_preamble + noise
data = np.concatenate((data, d))
dut = gfdm.channel_estimator_cc(
timeslots, subcarriers, active_subcarriers, True, 1, core_preamble)
src = blocks.vector_source_c(data)
snk = blocks.vector_sink_c()
self.tb.connect(src, dut, snk)
self.tb.run()
res = np.array(snk.data())
self.assertEqual(res.size, nframes * timeslots * subcarriers)
tags = snk.tags()
snr_tags = [t for t in tags if pmt.eq(t.key, pmt.mp("snr_lin"))]
for i, t in enumerate(snr_tags):
self.assertEqual(t.offset, i * timeslots * subcarriers)
res_lin = pmt.to_float(t.value)
res_db = 10. * np.log10(res_lin)
ref_db = 10. * np.log10(expected_snrs_lin[i])
# print(f"Reference: {ref_db:6.3f}dB\t{res_db:6.3f}dB")
if np.isfinite(ref_db):
self.assertTrue(np.abs(res_db - ref_db) < 1.)
def get_full_preambles(filtertype, alpha, active_subcarriers, subcarriers,
subcarrier_map, overlap, cp_len, ramp_len,
cyclic_shifts):
seed = 4711
preambles = []
for cs in cyclic_shifts:
p = mapped_preamble(seed, filtertype, alpha, active_subcarriers, subcarriers,
subcarrier_map, overlap, cp_len, ramp_len,
use_zadoff_chu=True, cyclic_shift=cs)
preambles.append(p[0])
return preambles
def test_001_t(self):
n_frames = 20
timeslots = 9
subcarriers = 128
active_subcarriers = 110
cp_len = subcarriers // 2
smap = get_subcarrier_map(subcarriers, active_subcarriers)
seed = 4711
ftype = 'rrc'
falpha = .5
preamble, x_preamble = mapped_preamble(seed, ftype, falpha,
active_subcarriers, subcarriers,
smap, 2, cp_len, cp_len // 2)
frame_len = len(preamble) + timeslots * subcarriers + cp_len
frame_gap = np.zeros(frame_len, dtype=np.complex)
data = frame_gap
ref = np.array([], dtype=np.complex)
for i in range(n_frames):
d_block = modulate_mapped_gfdm_block(
get_random_qpsk(timeslots * active_subcarriers), timeslots,
subcarriers, active_subcarriers, 2, falpha)
frame = pinch_cp_add_block(d_block, timeslots, subcarriers, cp_len,
cp_len // 2)
frame = np.concatenate((preamble, frame))
ref = np.concatenate((ref, frame))
data = np.concatenate((data, frame, frame_gap))
# print np.sum(np.abs(x_preamble) ** 2)
# import matplotlib.pyplot as plt
# plt.plot(data.real)
# plt.plot(data.imag)
# plt.show()
backoff = 80
src = blocks.vector_source_c(data)
e_detector = gfdm.frame_energy_detector_cc(10., 32, frame_len, backoff,
'energy')
detector = gfdm.simple_preamble_sync_cc(frame_len, subcarriers, cp_len,
x_preamble, 'energy', 'frame')
snk = blocks.vector_sink_c()
self.tb.connect(src, e_detector, detector, snk)
self.tb.run()
# check data
res = np.array(snk.data())
tags = snk.tags()
for t in tags:
print 'srcid {}, key {}, offset {}, value {}'.format(
t.srcid, t.key, t.offset, t.value)
self.assertComplexTuplesAlmostEqual(res, ref[0:len(res)], 5)
def test_001_t(self):
n_frames = 20
timeslots = 9
subcarriers = 128
active_subcarriers = 110
cp_len = subcarriers // 2
smap = get_subcarrier_map(subcarriers, active_subcarriers)
seed = 4711
ftype = 'rrc'
falpha = .5
tag_key = 'frame_start'
preamble, x_preamble = mapped_preamble(seed, ftype, falpha,
active_subcarriers, subcarriers,
smap, 2, cp_len, cp_len // 2)
block_len = timeslots * subcarriers
offset = len(preamble) + cp_len
frame_len = len(preamble) + timeslots * subcarriers + cp_len
data = np.array([], dtype=np.complex)
ref = np.array([], dtype=np.complex)
tags = []
print 'frame_len: ', frame_len
for i in range(n_frames):
d_block = modulate_mapped_gfdm_block(
get_random_qpsk(timeslots * active_subcarriers), timeslots,
subcarriers, active_subcarriers, 2, falpha)
frame = pinch_cp_add_block(d_block, timeslots, subcarriers, cp_len,
cp_len // 2)
frame = np.concatenate((preamble, frame))
r = frame[offset:offset + block_len]
ref = np.concatenate((ref, r))
tag = gr.tag_t()
tag.key = pmt.string_to_symbol(tag_key)
tag.offset = len(data)
tag.srcid = pmt.string_to_symbol('qa')
tag.value = pmt.from_long(block_len)
tags.append(tag)
data = np.concatenate((data, frame))
src = blocks.vector_source_c(data, False, 1, tags)
cp_rm = gfdm.remove_prefix_cc(frame_len, block_len, offset, tag_key)
snk = blocks.vector_sink_c()
self.tb.connect(src, cp_rm, snk)
self.tb.run()
# # check data
res = np.array(snk.data())
tags = snk.tags()
self.assertTrue(len(tags) == 0) # propagation policy is TPP_DONT
self.assertComplexTuplesAlmostEqual(res, ref, 5)
def test_001_selective(self):
timeslots = 5
subcarriers = 64
active_subcarriers = 52
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
active_symbols = timeslots * active_subcarriers
subcarrier_map = get_subcarrier_map(subcarriers,
active_subcarriers,
dc_free=True)
preambles = mapped_preamble(
self.seed,
self.filtertype,
self.filteralpha,
active_subcarriers,
subcarriers,
subcarrier_map,
overlap,
cp_len,
ramp_len,
)
full_preamble = preambles[0]
core_preamble = preambles[1]
h = np.array([1.0, 0.5, 0.1j, 0.1 + 0.05j], dtype=complex)
data = np.convolve(full_preamble, h, "full")[0:full_preamble.size]
data = data[cp_len:-ramp_len]
self.assertEqual(data.size, core_preamble.size)
estimator = Preamble_channel_estimator(timeslots, subcarriers,
active_subcarriers, True, 1,
core_preamble)
self.assertEqual(estimator.timeslots(), timeslots)
self.assertEqual(estimator.subcarriers(), subcarriers)
self.assertEqual(estimator.active_subcarriers(), active_subcarriers)
self.assertEqual(estimator.frame_len(), timeslots * subcarriers)
self.assertEqual(estimator.is_dc_free(), True)
res = estimator.estimate_frame(data)
lowres = res[0:active_symbols // 2]
hires = res[-active_symbols // 2:]
fh = np.fft.fft(h, timeslots * subcarriers)
lowfh = fh[0:active_symbols // 2]
hifh = fh[-active_symbols // 2:]
self.assertComplexTuplesAlmostEqual(lowres, lowfh, 1)
self.assertComplexTuplesAlmostEqual(hires, hifh, 1)
def test_002_selective(self):
timeslots = 5
subcarriers = 64
active_subcarriers = 52
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
active_symbols = timeslots * active_subcarriers
subcarrier_map = get_subcarrier_map(subcarriers,
active_subcarriers,
dc_free=True)
preambles = mapped_preamble(
self.seed,
self.filtertype,
self.filteralpha,
active_subcarriers,
subcarriers,
subcarrier_map,
overlap,
cp_len,
ramp_len,
)
full_preamble = preambles[0]
core_preamble = preambles[1]
h = np.array([1.0, 0.5, 0.1j, 0.1 + 0.05j], dtype=complex)
data = np.convolve(full_preamble, h, "full")[0:full_preamble.size]
data = data[cp_len:-ramp_len]
self.assertEqual(data.size, core_preamble.size)
dut = gfdm.channel_estimator_cc(timeslots, subcarriers,
active_subcarriers, True, 1,
core_preamble)
src = blocks.vector_source_c(data)
snk = blocks.vector_sink_c()
self.tb.connect(src, dut, snk)
self.tb.run()
res = np.array(snk.data())
lowres = res[0:active_symbols // 2]
hires = res[-active_symbols // 2:]
fh = np.fft.fft(h, timeslots * subcarriers)
lowfh = fh[0:active_symbols // 2]
hifh = fh[-active_symbols // 2:]
self.assertComplexTuplesAlmostEqual(lowres, lowfh, 1)
self.assertComplexTuplesAlmostEqual(hires, hifh, 1)
def test_002_snr(self):
timeslots = 5
subcarriers = 1024
active_subcarriers = 936
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
active_ratio = subcarriers / active_subcarriers
subcarrier_map = get_subcarrier_map(subcarriers,
active_subcarriers,
dc_free=True)
preambles = mapped_preamble(
self.seed,
self.filtertype,
self.filteralpha,
active_subcarriers,
subcarriers,
subcarrier_map,
overlap,
cp_len,
ramp_len,
)
core_preamble = preambles[1]
sigenergy = calculate_energy(core_preamble)
data = np.copy(core_preamble)
snr = 4.0
snr_lin = 10.0**(snr / 10.0)
nscale = calculate_noise_scale(snr_lin, sigenergy, active_ratio,
core_preamble.size)
noise = get_noise_vector(core_preamble.size, nscale)
data = core_preamble + noise
estimator = Preamble_channel_estimator(timeslots, subcarriers,
active_subcarriers, True, 1,
core_preamble)
res = estimator.estimate_snr(data)
res_db = 10.0 * np.log10(res)
print(res, snr_lin)
print(res_db, snr)
self.assertTrue(np.abs(res_db - snr) < 1.0)
def test_001_t(self):
n_frames = 20
timeslots = 9
subcarriers = 128
active_subcarriers = 110
cp_len = subcarriers // 2
smap = get_subcarrier_map(subcarriers, active_subcarriers)
seed = 4711
ftype = 'rrc'
falpha = .5
tag_key = 'frame_start'
preamble, x_preamble = mapped_preamble(seed, ftype, falpha, active_subcarriers, subcarriers, smap, 2, cp_len, cp_len // 2)
block_len = timeslots * subcarriers
offset = len(preamble) + cp_len
frame_len = len(preamble) + timeslots * subcarriers + cp_len
data = np.array([], dtype=np.complex)
ref = np.array([], dtype=np.complex)
tags = []
print 'frame_len: ', frame_len
for i in range(n_frames):
d_block = modulate_mapped_gfdm_block(get_random_qpsk(timeslots * active_subcarriers), timeslots, subcarriers, active_subcarriers, 2, falpha)
frame = pinch_cp_add_block(d_block, timeslots, subcarriers, cp_len, cp_len // 2)
frame = np.concatenate((preamble, frame))
r = frame[offset:offset + block_len]
ref = np.concatenate((ref, r))
tag = gr.tag_t()
tag.key = pmt.string_to_symbol(tag_key)
tag.offset = len(data)
tag.srcid = pmt.string_to_symbol('qa')
tag.value = pmt.from_long(block_len)
tags.append(tag)
data = np.concatenate((data, frame))
src = blocks.vector_source_c(data, False, 1, tags)
cp_rm = gfdm.remove_prefix_cc(frame_len, block_len, offset, tag_key)
snk = blocks.vector_sink_c()
self.tb.connect(src, cp_rm, snk)
self.tb.run()
# # check data
res = np.array(snk.data())
tags = snk.tags()
self.assertTrue(len(tags) == 0) # propagation policy is TPP_DONT
self.assertComplexTuplesAlmostEqual(res, ref, 5)
def test_001_t(self):
n_frames = 20
timeslots = 9
subcarriers = 128
active_subcarriers = 110
cp_len = subcarriers // 2
smap = get_subcarrier_map(subcarriers, active_subcarriers)
seed = 4711
ftype = 'rrc'
falpha = .5
preamble, x_preamble = mapped_preamble(seed, ftype, falpha, active_subcarriers, subcarriers, smap, 2, cp_len, cp_len // 2)
frame_len = len(preamble) + timeslots * subcarriers + cp_len
frame_gap = np.zeros(frame_len, dtype=np.complex)
data = frame_gap
ref = np.array([], dtype=np.complex)
for i in range(n_frames):
d_block = modulate_mapped_gfdm_block(get_random_qpsk(timeslots * active_subcarriers), timeslots, subcarriers, active_subcarriers, 2, falpha)
frame = pinch_cp_add_block(d_block, timeslots, subcarriers, cp_len, cp_len // 2)
frame = np.concatenate((preamble, frame))
ref = np.concatenate((ref, frame))
data = np.concatenate((data, frame, frame_gap))
# print np.sum(np.abs(x_preamble) ** 2)
# import matplotlib.pyplot as plt
# plt.plot(data.real)
# plt.plot(data.imag)
# plt.show()
backoff = 80
src = blocks.vector_source_c(data)
e_detector = gfdm.frame_energy_detector_cc(10., 32, frame_len, backoff, 'energy')
detector = gfdm.simple_preamble_sync_cc(frame_len, subcarriers, cp_len, x_preamble, 'energy', 'frame')
snk = blocks.vector_sink_c()
self.tb.connect(src, e_detector, detector, snk)
self.tb.run()
# check data
res = np.array(snk.data())
tags = snk.tags()
for t in tags:
print 'srcid {}, key {}, offset {}, value {}'.format(t.srcid, t.key, t.offset, t.value)
self.assertComplexTuplesAlmostEqual(res, ref[0:len(res)], 5)
def preamble_sync_test():
seed = 4711
timeslots = 9
subcarriers = 32
active_subcarriers = 20
cp_len = 16
filter_len = 8
overlap = 2
subcarrier_map = np.concatenate(
(np.arange(0, active_subcarriers // 2),
np.arange(subcarriers - active_subcarriers // 2, subcarriers)))
print subcarrier_map
snr_db = 5.
offset = 1000
preamble, x_preamble = mapped_preamble(seed, 'rrc', .5, active_subcarriers,
subcarriers, subcarrier_map,
overlap, cp_len, filter_len)
noise_variance = calculate_awgn_noise_variance(preamble, snr_db)
rx = get_complex_noise_vector(len(preamble) + 2 * offset, noise_variance)
rx[offset:offset + len(preamble)] += preamble
print('frame offset', offset, 'with cp_len', cp_len)
xc = np.correlate(rx, x_preamble, 'valid')
# xc *= np.max(np.abs(rx)) / np.max(np.abs(xc))
# xc /= calculate_average_signal_energy(tx)
peak = np.argmax(np.abs(xc))
print('frame located @{}'.format(peak))
nc, cfo, abs_corr_vals, corr_vals, napcc, apcc = find_frame_start(
rx, x_preamble, subcarriers, cp_len)
print('find frame start res @{} and cfo: {}'.format(nc, cfo))
s_nm, s_cfo, simple_ac = simplified_sync_algo(rx, x_preamble, subcarriers,
cp_len)
print('simple algo res @{} and cfo: {}'.format(s_nm, s_cfo))
sync_kernel = cgfdm.py_auto_cross_corr_multicarrier_sync_cc(
subcarriers, cp_len, x_preamble)
kpos, kcfo = sync_kernel.detect_frame(rx.astype(dtype=np.complex64))
print('kernel: nc={}, cfo={}'.format(kpos, kcfo))
assert (kpos == s_nm)
assert (np.abs(s_cfo - kcfo) < 1e-7)
def preamble_sync_test():
seed = 4711
timeslots = 9
subcarriers = 32
active_subcarriers = 20
cp_len = 16
filter_len = 8
overlap = 2
subcarrier_map = np.concatenate((np.arange(0, active_subcarriers // 2), np.arange(subcarriers - active_subcarriers // 2, subcarriers)))
print subcarrier_map
snr_db = 5.
offset = 1000
preamble, x_preamble = mapped_preamble(seed, 'rrc', .5, active_subcarriers, subcarriers, subcarrier_map, overlap,
cp_len, filter_len)
noise_variance = calculate_awgn_noise_variance(preamble, snr_db)
rx = get_complex_noise_vector(len(preamble) + 2 * offset, noise_variance)
rx[offset:offset + len(preamble)] += preamble
print('frame offset', offset, 'with cp_len', cp_len)
xc = np.correlate(rx, x_preamble, 'valid')
# xc *= np.max(np.abs(rx)) / np.max(np.abs(xc))
# xc /= calculate_average_signal_energy(tx)
peak = np.argmax(np.abs(xc))
print('frame located @{}'.format(peak))
nc, cfo, abs_corr_vals, corr_vals, napcc, apcc = find_frame_start(rx, x_preamble, subcarriers,
cp_len)
print('find frame start res @{} and cfo: {}'.format(nc, cfo))
s_nm, s_cfo, simple_ac = simplified_sync_algo(rx, x_preamble, subcarriers, cp_len)
print('simple algo res @{} and cfo: {}'.format(s_nm, s_cfo))
sync_kernel = cgfdm.py_auto_cross_corr_multicarrier_sync_cc(subcarriers, cp_len, x_preamble)
kpos, kcfo = sync_kernel.detect_frame(rx.astype(dtype=np.complex64))
print('kernel: nc={}, cfo={}'.format(kpos, kcfo))
assert(kpos == s_nm)
assert(np.abs(s_cfo - kcfo) < 1e-7)
def test_001_simple(self):
timeslots = 3
subcarriers = 32
active_subcarriers = 24
overlap = 2
cp_len = subcarriers // 2
ramp_len = cp_len // 2
subcarrier_map = get_subcarrier_map(subcarriers,
active_subcarriers,
dc_free=True)
preambles = mapped_preamble(
self.seed,
self.filtertype,
self.filteralpha,
active_subcarriers,
subcarriers,
subcarrier_map,
overlap,
cp_len,
ramp_len,
)
core_preamble = preambles[1]
dut = gfdm.channel_estimator_cc(timeslots, subcarriers,
active_subcarriers, True, 1,
core_preamble)
src = blocks.vector_source_c(core_preamble)
snk = blocks.vector_sink_c()
self.tb.connect(src, dut, snk)
self.tb.run()
res = np.array(snk.data())
self.assertComplexTuplesAlmostEqual(res,
np.ones(res.size, dtype=res.dtype),
6)
