def test_CFO():
SNRdB = 20
cfo = 0.5
sto = 1
zc_len = 503
preamble_seq = zadoffchu.generate_sequence(zc_len, 1, 0)
top_block = CreateCFORadioTest(SNRdB, cfo, sto, True)
top_block.run()
x_data = np.array(top_block.dst.data())
corr_data = top_block.dst2.data()
snr_estim = top_block.snr_est.SNRdB()
max_i = np.argmax(np.abs(corr_data)) + 1
range_preamble = range(max_i, max_i + 503)
max_corr = np.max(np.abs(corr_data))
pycorr = np.correlate(x_data, preamble_seq, 'full')
pycorr *= max_corr / np.max(np.abs(pycorr))
pycorr = pycorr[zc_len::]
fig, (ax0, ax1) = plt.subplots(nrows=2)
ax0.plot(np.abs(corr_data))
ax0.plot(np.abs(x_data), 'r')
ax0.plot(range_preamble, np.abs(x_data[range_preamble]), 'g')
ax0.plot(np.abs(pycorr), 'm:')
ax1.plot(np.abs(np.fft.fft(x_data[range_preamble] *
np.conj(preamble_seq))))
ax1.plot(np.abs(np.fft.fft(x_data[range_preamble])), 'g')
ax1.plot(np.abs(np.fft.fft(preamble_seq)), 'r')
plt.show()
def test_001_t(self):
# We check if with a constant source, the SNR is measured correctly
sample_rate = 1e6
frame_duration = 1.0e-3
test_duration = 1.5 * frame_duration
snr = np.random.rand() * 1000
zc_seq_len = 71
samples_per_frame = int(round(frame_duration * sample_rate))
samples_per_test = int(round(test_duration * sample_rate))
snr_estim_sample_window = zc_seq_len #int(round(samples_per_frame/20))
random_samples_skip = np.random.randint(
samples_per_frame / 2) + samples_per_frame / 2
preamble_seq = zadoffchu.generate_sequence(zc_seq_len, 1, 0)
preamble_pwr_sum = np.sum(np.abs(preamble_seq)**2)
print "***** Start test 001 *****"
framer = specmonitor.framer_c(sample_rate, frame_duration,
preamble_seq)
const_source = blocks.vector_source_c([1.0 / snr], True)
add = blocks.add_cc()
skiphead = blocks.skiphead(gr.sizeof_gr_complex, random_samples_skip)
corr_est = specmonitor.corr_est_norm_cc(
preamble_seq, 1, 0) #digital.corr_est_cc(preamble_seq, 1, 0)
snr_est = specmonitor.framer_snr_est_cc(snr_estim_sample_window,
preamble_seq.size)
# tag_db = blocks.tag_debug(gr.sizeof_gr_complex, "tag debugger")
head = blocks.head(gr.sizeof_gr_complex, samples_per_test)
dst = blocks.vector_sink_c()
self.tb.connect(framer, (add, 0))
self.tb.connect(const_source, (add, 1))
self.tb.connect(add, skiphead)
self.tb.connect(skiphead, head)
self.tb.connect(head, corr_est)
self.tb.connect(corr_est, snr_est)
# self.tb.connect(snr_est,tag_db)
self.tb.connect(snr_est, dst)
self.tb.run()
x_data = dst.data()
snrdB = snr_est.SNRdB()
y_data = np.abs(x_data)**2
# print "Random Initial Skip: ", random_samples_skip
# print "y_data size: ", len(y_data)
start_preamble_idx = samples_per_frame - random_samples_skip + preamble_seq.size
sig_range = np.arange(start_preamble_idx,
start_preamble_idx + preamble_seq.size)
floor_range = np.arange(sig_range[-1] + 1,
sig_range[-1] + 1 + snr_estim_sample_window)
y_pwr = np.mean(y_data[sig_range])
floor_pwr = np.mean(y_data[floor_range])
py_snrdB = 10 * np.log10(y_pwr / floor_pwr)
self.assertAlmostEqual(py_snrdB, 20 * np.log10(snr), 1)
self.assertAlmostEqual(snrdB, 20 * np.log10(snr), 1)
def __init__(self, snr_val, verbose=False):
gr.top_block.__init__(self, name="SNR estimation accuracy test")
zc_seq_len = 503 #199
sample_rate = 1e6
frame_duration = 2.0e-3
test_duration = 1.5 * frame_duration
samples_per_frame = int(round(frame_duration * sample_rate))
samples_per_test = int(round(test_duration * sample_rate))
n_samples_snr_estim = zc_seq_len #int(round(samples_per_frame/20))
random_samples_skip = np.random.randint(
samples_per_frame / 2) + samples_per_frame / 2
preamble_seq = zadoffchu.generate_sequence(zc_seq_len, 1, 0)
preamble_pwr_sum = np.sum(np.abs(preamble_seq)**2)
sigma_val = 1 / float(10.0**(snr_val / 20.0))
thres = 0.25
# if samples_per_test-random_samples_skip+2*preamble_seq.size+n_samples_snr_estim >= samples_per_test:
# print "The test duration is not long enough"
# exit()
self.framer = specmonitor.framer_c(sample_rate, frame_duration,
preamble_seq)
self.awgn = analog.noise_source_c(analog.GR_GAUSSIAN, sigma_val)
self.add = blocks.add_cc()
self.skiphead = blocks.skiphead(gr.sizeof_gr_complex,
random_samples_skip)
self.corr_est = specmonitor.corr_est_norm_cc(
preamble_seq, 1, 0,
thres) #digital.corr_est_cc(preamble_seq, 1, 0)
self.snr_est = specmonitor.framer_snr_est_cc(n_samples_snr_estim,
preamble_seq.size)
if verbose is True:
self.tag_db = blocks.tag_debug(gr.sizeof_gr_complex,
"tag debugger")
self.head = blocks.head(gr.sizeof_gr_complex, samples_per_test)
self.dst = blocks.vector_sink_c()
self.connect(self.framer, (self.add, 0))
self.connect(self.awgn, (self.add, 1))
self.connect(self.add, self.skiphead)
self.connect(self.skiphead, self.head)
self.connect(self.head, self.corr_est)
self.connect(self.corr_est, self.snr_est)
if verbose is True:
self.connect(self.snr_est, self.tag_db)
self.connect(self.snr_est, self.dst)
def generate_preamble(zc_len, n_repeats):
pseq_list = []
pseq_norm_list = []
for p in zc_len:
pseq = zadoffchu.generate_sequence(p,1,0)
pseq_list.append(pseq)
pseq_norm = pseq / np.sqrt(np.sum(np.abs(pseq)**2))
pseq_norm_list.append(pseq_norm)
n_samples = np.sum([zc_len[i]*n_repeats[i] for i in range(len(zc_len))])
x = np.zeros(n_samples,dtype=np.complex128)
t = 0
for i in range(len(zc_len)):
for r in range(n_repeats[i]):
x[t:t+zc_len[i]] = pseq_list[i]
t = t + zc_len[i]
return (x,pseq_list,pseq_norm_list)
def __init__(self, snr_val, cfo=0, sto=0, verbose=False):
gr.top_block.__init__(self, name="CFO estimation test")
zc_seq_len = 503 #199
sample_rate = 1e6
frame_duration = 2.0e-3
test_duration = 1.5 * frame_duration
sigma_val = 1 / float(10.0**(snr_val / 20.0))
thres = 0.25
samples_per_frame = int(round(frame_duration * sample_rate))
samples_per_test = int(round(test_duration * sample_rate))
n_samples_snr_estim = zc_seq_len
random_samples_skip = np.random.randint(
samples_per_frame / 2) + samples_per_frame / 2
preamble_seq = zadoffchu.generate_sequence(zc_seq_len, 1, 0)
preamble_pwr_sum = np.sum(np.abs(preamble_seq)**2)
self.framer = specmonitor.framer_c(sample_rate, frame_duration,
preamble_seq)
self.channel = channels.channel_model(sigma_val, cfo, sto, [1 + 1j])
self.skiphead = blocks.skiphead(gr.sizeof_gr_complex,
random_samples_skip)
self.corr_est = specmonitor.corr_est_norm_cc(
preamble_seq, 1, 0,
thres) #digital.corr_est_cc(preamble_seq, 1, 0)
self.snr_est = specmonitor.framer_snr_est_cc(n_samples_snr_estim,
preamble_seq.size)
if verbose is True:
self.tag_db = blocks.tag_debug(gr.sizeof_gr_complex,
"tag debugger")
self.head = blocks.head(gr.sizeof_gr_complex, samples_per_test)
self.dst = blocks.vector_sink_c()
self.dst2 = blocks.vector_sink_c()
self.connect(self.framer, self.channel)
self.connect(self.channel, self.skiphead)
# self.connect(self.framer,self.skiphead)
self.connect(self.skiphead, self.head)
self.connect(self.head, self.corr_est)
self.connect(self.corr_est, self.snr_est)
self.connect((self.corr_est, 1), self.dst2)
if verbose is True:
self.connect(self.snr_est, self.tag_db)
self.connect(self.snr_est, self.dst)
def test_002_t(self):
# set up fg
sample_rate = 1e6
frame_duration = 1.0e-3
test_duration = 2 * frame_duration
snr = 100
zc_seq_len = 71
samples_per_frame = int(round(frame_duration * sample_rate))
samples_per_test = int(round(test_duration * sample_rate))
n_samples_snr_estim = zc_seq_len #samples_per_frame/20
random_samples_skip = 0 #np.random.randint(samples_per_frame)
preamble_seq = zadoffchu.generate_sequence(zc_seq_len, 1, 0)
preamble_pwr_sum = np.sum(np.abs(preamble_seq)**2)
print "***** Start test 002 *****"
framer = specmonitor.framer_c(sample_rate, frame_duration,
preamble_seq)
awgn = analog.noise_source_c(analog.GR_GAUSSIAN, 1.0 / snr)
add = blocks.add_cc()
corr_est = specmonitor.corr_est_norm_cc(
preamble_seq, 1, 0) #digital.corr_est_cc(preamble_seq, 1, 0)
snr_est = specmonitor.framer_snr_est_cc(n_samples_snr_estim,
preamble_seq.size)
tag_db = blocks.tag_debug(gr.sizeof_gr_complex, "tag debugger")
head = blocks.head(gr.sizeof_gr_complex, samples_per_test)
dst = blocks.vector_sink_c()
self.tb.connect(framer, (add, 0))
self.tb.connect(awgn, (add, 1))
self.tb.connect(add, corr_est)
self.tb.connect(corr_est, snr_est)
self.tb.connect(snr_est, tag_db)
self.tb.connect(snr_est, head)
self.tb.connect(head, dst)
self.tb.run()
x_data = dst.data()
print "The final SNR is: ", snr_est.SNRdB()
plt.plot(10 * np.log10(np.abs(x_data)**2))
plt.show()