def test_vector_int(self):
tb = self.tb
vlen = 5
N = 10 * vlen
data = make_random_float_tuple(N, 2**10)
data = [int(d * 1000) for d in data]
src = blocks.vector_source_i(data, False)
one_to_many = blocks.stream_to_streams(gr.sizeof_int, vlen)
one_to_vector = blocks.stream_to_vector(gr.sizeof_int, vlen)
many_to_vector = blocks.streams_to_vector(gr.sizeof_int, vlen)
isolated = [blocks.moving_average_ii(100, 1) for i in range(vlen)]
dut = blocks.moving_average_ii(100, 1, vlen=vlen)
dut_dst = blocks.vector_sink_i(vlen=vlen)
ref_dst = blocks.vector_sink_i(vlen=vlen)
tb.connect(src, one_to_many)
tb.connect(src, one_to_vector, dut, dut_dst)
tb.connect(many_to_vector, ref_dst)
for idx, single in enumerate(isolated):
tb.connect((one_to_many, idx), single, (many_to_vector, idx))
tb.run()
dut_data = dut_dst.data()
ref_data = ref_dst.data()
# make sure result is close to zero
self.assertTupleEqual(dut_data, ref_data)
def test_005_t(self):
# Interleaver to deinterleaver
data_in_I = [
i * 2 - 1
for i in np.random.randint(0, 2, (2 * len(self.c.codewords[0]) * (
self.c.nsym_frame - len(self.c.preamble) - len(self.c.SFD)), ))
]
data_in_Q = [
i * 2 - 1
for i in np.random.randint(0, 2, (2 * len(self.c.codewords[0]) * (
self.c.nsym_frame - len(self.c.preamble) - len(self.c.SFD)), ))
]
self.src_I = blocks.vector_source_i(data_in_I)
self.snk_I = blocks.vector_sink_i(1)
self.src_Q = blocks.vector_source_i(data_in_Q)
self.snk_Q = blocks.vector_sink_i(1)
self.tb.connect(self.src_I, self.interleaver_I,
self.preamble_sfd_prefixer_I, (self.qpsk_mapper, 0))
self.tb.connect(self.src_Q, self.interleaver_Q,
self.preamble_sfd_prefixer_Q, (self.qpsk_mapper, 1))
self.tb.connect(self.qpsk_mapper, self.dqpsk_mapper, self.dqcsk_mapper,
self.dqcsk_demapper, self.dqpsk_demapper,
self.qpsk_demapper)
self.tb.connect((self.qpsk_demapper, 0), self.preamble_sfd_removal_I,
self.deinterleaver_I, self.snk_I)
self.tb.connect((self.qpsk_demapper, 1), self.preamble_sfd_removal_Q,
self.deinterleaver_Q, self.snk_Q)
self.tb.run()
data_out_I = self.snk_I.data()
data_out_Q = self.snk_Q.data()
self.assertFloatTuplesAlmostEqual(data_out_I, data_in_I)
self.assertFloatTuplesAlmostEqual(data_out_I, data_in_I)
def test_03(self):
tb = self.tb
vlen = 5
N = 10*vlen
seed = 0
data = make_random_float_tuple(N, 2**10)
data = [int(d*1000) for d in data]
src = blocks.vector_source_i(data, False)
one_to_many = blocks.stream_to_streams(gr.sizeof_int, vlen)
one_to_vector = blocks.stream_to_vector(gr.sizeof_int, vlen)
many_to_vector = blocks.streams_to_vector(gr.sizeof_int, vlen)
isolated = [ blocks.moving_average_ii(100, 1) for i in range(vlen)]
dut = blocks.moving_average_ii(100, 1, vlen=vlen)
dut_dst = blocks.vector_sink_i(vlen=vlen)
ref_dst = blocks.vector_sink_i(vlen=vlen)
tb.connect(src, one_to_many)
tb.connect(src, one_to_vector, dut, dut_dst)
tb.connect(many_to_vector, ref_dst)
for idx, single in enumerate(isolated):
tb.connect((one_to_many,idx), single, (many_to_vector,idx))
tb.run()
dut_data = dut_dst.data()
ref_data = ref_dst.data()
# make sure result is close to zero
self.assertTupleEqual(dut_data, ref_data)
def test_rf32_to_ri32(self):
path = self.make_file("test_source", "rf32", 1)
# expected
expected_source = sigmf.source(path, "rf32", False)
convert = blocks.float_to_int(1, 1)
expected_sink = blocks.vector_sink_i(1)
# actual
actual_source = sigmf.source(path, "ri32", False)
actual_sink = blocks.vector_sink_i(1)
tb1 = gr.top_block()
tb1.connect(expected_source, convert)
tb1.connect(convert, expected_sink)
tb1.run()
tb1.wait()
tb2 = gr.top_block()
tb2.connect(actual_source, actual_sink)
tb2.run()
tb2.wait()
e = expected_sink.data()
a = actual_sink.data()
np.testing.assert_almost_equal(e, a)
def test_004_t(self):
# Preamble and SFD prefixer to removal
data_in_I = [
i * 2 - 1 for i in np.random.randint(0, 2, (2 * (
self.c.nsym_frame - len(self.c.preamble) - len(self.c.SFD)), ))
]
data_in_Q = [
i * 2 - 1 for i in np.random.randint(0, 2, (2 * (
self.c.nsym_frame - len(self.c.preamble) - len(self.c.SFD)), ))
]
self.src_I = blocks.vector_source_i(data_in_I)
self.snk_I = blocks.vector_sink_i(1)
self.src_Q = blocks.vector_source_i(data_in_Q)
self.snk_Q = blocks.vector_sink_i(1)
# self.dbg_sink1 = blocks.vector_sink_i(1)
# self.dbg_sink2 = blocks.vector_sink_i(1)
# self.dbg_sink3 = blocks.vector_sink_f(1)
# self.dbg_sink4 = blocks.vector_sink_f(1)
# self.dbg_sink5 = blocks.vector_sink_c(1)
# self.dbg_sink6 = blocks.vector_sink_f(1)
# self.dbg_sink7 = blocks.vector_sink_f(1)
self.tb.connect(self.src_I, self.preamble_sfd_prefixer_I,
(self.qpsk_mapper, 0))
self.tb.connect(self.src_Q, self.preamble_sfd_prefixer_Q,
(self.qpsk_mapper, 1))
self.tb.connect(self.qpsk_mapper, self.dqpsk_mapper, self.dqcsk_mapper,
self.dqcsk_demapper, self.dqpsk_demapper,
self.qpsk_demapper)
self.tb.connect((self.qpsk_demapper, 0), self.preamble_sfd_removal_I,
self.snk_I)
self.tb.connect((self.qpsk_demapper, 1), self.preamble_sfd_removal_Q,
self.snk_Q)
# self.tb.connect((self.qpsk_mapper,0), self.dbg_sink3)
# self.tb.connect(self.preamble_sfd_prefixer_I, self.dbg_sink2)
# self.tb.connect(self.dqpsk_mapper, self.dbg_sink4)
# self.tb.connect(self.dqcsk_mapper, self.dbg_sink5)
# self.tb.connect(self.dqcsk_demapper, self.dbg_sink6)
# self.tb.connect(self.dqcsk_demapper, self.dbg_sink7)
self.tb.run()
# print "sfd prefixer output len:", len(self.dbg_sink2.data())
# print "qpsk mapper output len:", len(self.dbg_sink3.data())
# print "dqpsk mapper output len:", len(self.dbg_sink4.data())
# print "dqcsk mapper output len:", len(self.dbg_sink5.data())
# print "dqcsk demapper output len:", len(self.dbg_sink6.data())
# print "dqpsk demapper output len:", len(self.dbg_sink7.data())
data_out_I = self.snk_I.data()
data_out_Q = self.snk_Q.data()
self.assertFloatTuplesAlmostEqual(data_in_I, data_out_I)
self.assertFloatTuplesAlmostEqual(data_in_Q, data_out_Q)
def test_001_t (self):
src = ofdm.allocation_src(6,3,"tcp://*:3333")
src.set_allocation([2]*6,[3]*6)
#skiphead = blocks.skiphead( gr.sizeof_float, 8 )
limit_id = blocks.head( gr.sizeof_short, 4 )
limit_bitcount = blocks.head( gr.sizeof_int, 4 )
limit_bitloading = blocks.head( gr.sizeof_char*6, 4 )
limit_power = blocks.head( gr.sizeof_gr_complex*6, 4 )
dst_id = blocks.vector_sink_s()
dst_bitcount = blocks.vector_sink_i()
dst_bitloading = blocks.vector_sink_b(6)
dst_power = blocks.vector_sink_c(6)
self.tb.connect((src,0),limit_id,dst_id)
self.tb.connect((src,1),limit_bitcount,dst_bitcount)
self.tb.connect((src,2),limit_bitloading,dst_bitloading)
self.tb.connect((src,3),limit_power,dst_power)
# set up fg
self.tb.run ()
# check data
result_id = dst_id.data()
result_bitcount = dst_bitcount.data()
result_bitloading = dst_bitloading.data()
result_power = dst_power.data()
print "id", result_id
print "bitcount", result_bitcount
print "bitloading", result_bitloading
print "power", result_power
def test_001_t(self):
src = ofdm.allocation_src(6, 3, "tcp://*:3333")
src.set_allocation([2] * 6, [3] * 6)
#skiphead = blocks.skiphead( gr.sizeof_float, 8 )
limit_id = blocks.head(gr.sizeof_short, 4)
limit_bitcount = blocks.head(gr.sizeof_int, 4)
limit_bitloading = blocks.head(gr.sizeof_char * 6, 4)
limit_power = blocks.head(gr.sizeof_gr_complex * 6, 4)
dst_id = blocks.vector_sink_s()
dst_bitcount = blocks.vector_sink_i()
dst_bitloading = blocks.vector_sink_b(6)
dst_power = blocks.vector_sink_c(6)
self.tb.connect((src, 0), limit_id, dst_id)
self.tb.connect((src, 1), limit_bitcount, dst_bitcount)
self.tb.connect((src, 2), limit_bitloading, dst_bitloading)
self.tb.connect((src, 3), limit_power, dst_power)
# set up fg
self.tb.run()
# check data
result_id = dst_id.data()
result_bitcount = dst_bitcount.data()
result_bitloading = dst_bitloading.data()
result_power = dst_power.data()
print "id", result_id
print "bitcount", result_bitcount
print "bitloading", result_bitloading
print "power", result_power
def __init__(self):
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 25e6
self.lo_off = lo_off = 0
self.freq_l1 = freq_l1 = 1.57542e6
##################################################
# Blocks
##################################################
self.uhd_usrp_source_0 = uhd.usrp_source(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="sc16",
otw_format="sc16",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_clock_source("gpsdo", 0)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(freq_l1, lo_off), 0)
self.uhd_usrp_source_0.set_gain(35, 0)
self.uhd_usrp_source_0.set_antenna("RX2", 0)
#self.uhd_usrp_source_0.set_antenna("TX/RX", 0)
#self.uhd_usrp_source_0.set_bandwidth(20e6, 0)
self.blocks_vector_sink_x_0 = blocks.vector_sink_i(1)
##################################################
# Connections
##################################################
self.connect((self.uhd_usrp_source_0, 0), (self.blocks_vector_sink_x_0, 0))
def test_001_t (self):
# This test case is from Fundamentals of Error-Correcting
# Codes by Huffman and Pless. First part of Example 15.7.1.
# Generator matrix from textbook example
G = np.array([[1,0,0,0,0,1,1,1],
[0,1,0,0,1,0,1,1],
[0,0,1,0,1,1,0,1],
[0,0,0,1,1,1,1,0]])
# this is the dataword to be encoded
dataword = (1,0,1,1)
# this is what the encoder should produce
codeword = (1,0,1,1,0,1,0,0)
k = len(dataword)
n = len(codeword)
src = blocks.vector_source_i(dataword)
str2vec = blocks.stream_to_vector(4, k)
vec2str = blocks.vector_to_stream(4, n)
encoder = generator_matrix_encoder_ss(G)
dst = blocks.vector_sink_i()
self.tb.connect(src, str2vec, encoder, vec2str, dst)
self.tb.run ()
result_data = dst.data()
# check data
self.assertTupleEqual(codeword,result_data)
def help_const_ii(self, src_data, exp_data, op):
src = blocks.vector_source_i(src_data)
srcv = blocks.stream_to_vector(gr.sizeof_int, len(src_data))
rhs = blocks.vector_to_stream(gr.sizeof_int, len(src_data))
dst = blocks.vector_sink_i()
self.tb.connect(src, srcv, op, rhs, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def help_ii(self, src_data, exp_data, op):
for s in zip(list(range(len(src_data))), src_data):
src = blocks.vector_source_i(s[1])
self.tb.connect(src, (op, s[0]))
dst = blocks.vector_sink_i()
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def help_ii (self, src_data, exp_data, op):
for s in zip (range (len (src_data)), src_data):
src = blocks.vector_source_i (s[1])
self.tb.connect (src, (op, s[0]))
dst = blocks.vector_sink_i ()
self.tb.connect (op, dst)
self.tb.run ()
result_data = dst.data ()
self.assertEqual (exp_data, result_data)
def test_and_const_ii (self):
src_data = (1, 2, 3, 0x5004, 0x1150)
expected_result = (0, 2, 2, 0x5000, 0x1100)
src = blocks.vector_source_i(src_data)
op = blocks.and_const_ii (0x55AA)
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(dst.data(), expected_result)
def test_float_to_int_identity(self):
src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
expected_data = (1, 2, 3, 4, 5)
src = blocks.vector_source_f(src_data)
op = blocks.float_to_int()
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_001_ii(self):
src_data = (1, 2, 3, 4, 5, 6)
dst_data = (6, 15)
src = blocks.vector_source_i(src_data)
itg = blocks.integrate_ii(3)
dst = blocks.vector_sink_i()
self.tb.connect(src, itg, dst)
self.tb.run()
self.assertEqual(dst_data, dst.data())
def test_float_to_int_identity(self):
src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
expected_data = (1, 2, 3, 4, 5)
src = blocks.vector_source_f(src_data)
op = blocks.float_to_int()
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_float_to_int_scale(self):
src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
expected_data = (5, 10, 15, 20, 25)
src = blocks.vector_source_f(src_data)
op = blocks.float_to_int(1, 5)
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_float_to_int_scale(self):
src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
expected_data = (5, 10, 15, 20, 25)
src = blocks.vector_source_f(src_data)
op = blocks.float_to_int(1, 5)
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_001_ii(self): src_data = (1, 2, 3, 4, 5, 6) dst_data = (6, 15) src = blocks.vector_source_i(src_data) itg = blocks.integrate_ii(3) dst = blocks.vector_sink_i() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data())
def help_const_ii(self, src_data, exp_data, op):
src = blocks.vector_source_i(src_data)
srcv = blocks.stream_to_vector(gr.sizeof_int, len(src_data))
rhs = blocks.vector_to_stream(gr.sizeof_int, len(src_data))
dst = blocks.vector_sink_i()
self.tb.connect(src, srcv, op, rhs, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_and_const_ii(self):
src_data = [1, 2, 3, 0x5004, 0x1150]
expected_result = [0, 2, 2, 0x5000, 0x1100]
src = blocks.vector_source_i(src_data)
op = blocks.and_const_ii(0x55AA)
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(dst.data(), expected_result)
def test_crop_only(self):
block_crop_only = pad_crop(gr.sizeof_int, 4, str(self.len_key), False,
True)
sink_crop_only = blocks.vector_sink_i()
self.tb.connect(self.src, block_crop_only, sink_crop_only)
self.tb.run()
self.assertSequenceEqual(sink_crop_only.data(), (1, 2, 3, 4, 5, 6, 7))
def test_skip_12678(self):
skip_cnt = 12678
expected_result = tuple(self.src_data[skip_cnt:])
src1 = blocks.vector_source_i(self.src_data)
op = blocks.skiphead(gr.sizeof_int, skip_cnt)
dst1 = blocks.vector_sink_i()
self.tb.connect(src1, op, dst1)
self.tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
def test_001_t (self):
# set up fg
in_data = (0, 1, 7, 3, 3, 4, 2, 1, 2, 3)
samp_block = len(in_data)
src = blocks.vector_source_f(in_data)
snk = blocks.vector_sink_i()
stv = blocks.stream_to_vector(4, samp_block)
test = classify.person_vfi(samp_block,0,0,0,0,0)
self.tb.connect(src,stv,test,snk)
self.tb.run ()
def test_skip_12678(self):
skip_cnt = 12678
expected_result = tuple(self.src_data[skip_cnt:])
src1 = blocks.vector_source_i(self.src_data)
op = blocks.skiphead(gr.sizeof_int, skip_cnt)
dst1 = blocks.vector_sink_i()
self.tb.connect(src1, op, dst1)
self.tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
def test_skip_all(self):
skip_cnt = len(self.src_data)
expected_result = tuple(self.src_data[skip_cnt:])
src1 = blocks.vector_source_i(self.src_data)
op = usrpcalibrator.skiphead_reset(gr.sizeof_int, skip_cnt)
dst1 = blocks.vector_sink_i()
self.tb.connect(src1, op, dst1)
self.tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
def test_004_t (self):
# Preamble and SFD prefixer to removal
data_in_I = [i*2-1 for i in np.random.randint(0,2,(2*(self.c.nsym_frame-len(self.c.preamble)-len(self.c.SFD)),))]
data_in_Q = [i*2-1 for i in np.random.randint(0,2,(2*(self.c.nsym_frame-len(self.c.preamble)-len(self.c.SFD)),))]
self.src_I = blocks.vector_source_i(data_in_I)
self.snk_I = blocks.vector_sink_i(1)
self.src_Q = blocks.vector_source_i(data_in_Q)
self.snk_Q = blocks.vector_sink_i(1)
# self.dbg_sink1 = blocks.vector_sink_i(1)
# self.dbg_sink2 = blocks.vector_sink_i(1)
# self.dbg_sink3 = blocks.vector_sink_f(1)
# self.dbg_sink4 = blocks.vector_sink_f(1)
# self.dbg_sink5 = blocks.vector_sink_c(1)
# self.dbg_sink6 = blocks.vector_sink_f(1)
# self.dbg_sink7 = blocks.vector_sink_f(1)
self.tb.connect(self.src_I, self.preamble_sfd_prefixer_I, (self.qpsk_mapper,0))
self.tb.connect(self.src_Q, self.preamble_sfd_prefixer_Q, (self.qpsk_mapper,1))
self.tb.connect(self.qpsk_mapper, self.dqpsk_mapper, self.dqcsk_mapper, self.dqcsk_demapper, self.dqpsk_demapper, self.qpsk_demapper)
self.tb.connect((self.qpsk_demapper,0), self.preamble_sfd_removal_I, self.snk_I)
self.tb.connect((self.qpsk_demapper,1), self.preamble_sfd_removal_Q, self.snk_Q)
# self.tb.connect((self.qpsk_mapper,0), self.dbg_sink3)
# self.tb.connect(self.preamble_sfd_prefixer_I, self.dbg_sink2)
# self.tb.connect(self.dqpsk_mapper, self.dbg_sink4)
# self.tb.connect(self.dqcsk_mapper, self.dbg_sink5)
# self.tb.connect(self.dqcsk_demapper, self.dbg_sink6)
# self.tb.connect(self.dqcsk_demapper, self.dbg_sink7)
self.tb.run()
# print "sfd prefixer output len:", len(self.dbg_sink2.data())
# print "qpsk mapper output len:", len(self.dbg_sink3.data())
# print "dqpsk mapper output len:", len(self.dbg_sink4.data())
# print "dqcsk mapper output len:", len(self.dbg_sink5.data())
# print "dqcsk demapper output len:", len(self.dbg_sink6.data())
# print "dqpsk demapper output len:", len(self.dbg_sink7.data())
data_out_I = self.snk_I.data()
data_out_Q = self.snk_Q.data()
self.assertFloatTuplesAlmostEqual(data_in_I, data_out_I)
self.assertFloatTuplesAlmostEqual(data_in_Q, data_out_Q)
def help_ii(self, src_data, exp_data, op):
for s in zip(list(range(len(src_data))), src_data):
src = blocks.vector_source_i(s[1])
self.tb.connect(src, 0, op, s[0]).set_custom_buffer(gr.buffer_cuda_properties.make(gr.buffer_cuda_type.H2D))
dst = blocks.vector_sink_i()
self.tb.connect(op, dst).set_custom_buffer(gr.buffer_cuda_properties.make(gr.buffer_cuda_type.D2H))
self.rt.initialize(self.tb)
self.rt.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_head(self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
expected_result = (1, 2, 3, 4)
src1 = blocks.vector_source_i(src_data)
op = blocks.head(gr.sizeof_int, 4)
dst1 = blocks.vector_sink_i()
self.tb.connect(src1, op)
self.tb.connect(op, dst1)
self.tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
def test_001_square_bb(self):
src_data = (2, 3, 4, 5, 6)
expected_result = (4, 9, 16, 25, 36)
src = blocks.vector_source_i(src_data)
sqr = howtogen.square_ii()
dst = blocks.vector_sink_i()
self.tb.connect(src, sqr)
self.tb.connect(sqr, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_sub_ii1(self):
src1_data = (1, 2, 3, 4, 5)
expected_result = (1, 2, 3, 4, 5)
src = blocks.vector_source_i(src1_data)
op = blocks.sub_ii()
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_001_t (self):
src_data = (128,255,0,7,127)
expected_result = (863,606,0,343,187)
src = blocks.vector_source_b (src_data)
mult = rsaTX_py_bf (3,943)
snk = blocks.vector_sink_i ()
self.tb.connect (src, mult)
self.tb.connect (mult, snk)
self.tb.run ()
result_data = snk.data ()
self.assertEqual(expected_result, result_data)
def test_const_i(self):
tb = self.tb
expected_result = (1, 1, 1, 1)
src1 = analog.sig_source_i(1e6, analog.GR_CONST_WAVE, 0, 1)
op = blocks.head(gr.sizeof_int, 4)
dst1 = blocks.vector_sink_i()
tb.connect(src1, op)
tb.connect(op, dst1)
tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
def test_sub_ii1(self):
src1_data = (1, 2, 3, 4, 5)
expected_result = (1, 2, 3, 4, 5)
src = blocks.vector_source_i(src1_data)
op = blocks.sub_ii()
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_003_t (self):
# QPSK mapper to demapper
data_in_I = [1,-1,1,-1]
data_in_Q = [1,1,-1,-1]
self.src_I = blocks.vector_source_i(data_in_I)
self.snk_I = blocks.vector_sink_i(1)
self.src_Q = blocks.vector_source_i(data_in_Q)
self.snk_Q = blocks.vector_sink_i(1)
self.tb.connect(self.src_I, (self.qpsk_mapper,0))
self.tb.connect(self.src_Q, (self.qpsk_mapper,1))
self.tb.connect(self.qpsk_mapper, self.dqpsk_mapper, self.dqcsk_mapper, self.dqcsk_demapper, self.dqpsk_demapper, self.qpsk_demapper)
self.tb.connect((self.qpsk_demapper,0), self.snk_I)
self.tb.connect((self.qpsk_demapper,1), self.snk_Q)
self.tb.run()
data_out_I = self.snk_I.data()
data_out_Q = self.snk_Q.data()
self.assertFloatTuplesAlmostEqual(data_in_I, data_out_I)
self.assertFloatTuplesAlmostEqual(data_in_Q, data_out_Q)
def test_head(self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
expected_result = (1, 2, 3, 4)
src1 = blocks.vector_source_i(src_data)
op = blocks.head(gr.sizeof_int, 4)
dst1 = blocks.vector_sink_i()
self.tb.connect(src1, op)
self.tb.connect(op, dst1)
self.tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
def test_pad_crop(self):
block_pad_crop = pad_crop(gr.sizeof_int, 4, str(self.len_key), True,
True)
sink_pad_crop = blocks.vector_sink_i()
self.tb.connect(self.src, block_pad_crop, sink_pad_crop)
self.tb.run()
self.assertSequenceEqual(sink_pad_crop.data(),
(1, 2, 3, 0, 4, 5, 6, 7))
def test_const_i(self):
tb = self.tb
expected_result = [1, 1, 1, 1]
src1 = analog.sig_source_i(1e6, analog.waveform_type.constant, 0, 1)
op = streamops.head(4)
dst1 = blocks.vector_sink_i()
tb.connect(src1, op)
tb.connect(op, dst1)
tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
def test_005_t (self):
# Interleaver to deinterleaver
data_in_I = [i*2-1 for i in np.random.randint(0,2,(2*len(self.c.codewords[0])*(self.c.nsym_frame-len(self.c.preamble)-len(self.c.SFD)),))]
data_in_Q = [i*2-1 for i in np.random.randint(0,2,(2*len(self.c.codewords[0])*(self.c.nsym_frame-len(self.c.preamble)-len(self.c.SFD)),))]
self.src_I = blocks.vector_source_i(data_in_I)
self.snk_I = blocks.vector_sink_i(1)
self.src_Q = blocks.vector_source_i(data_in_Q)
self.snk_Q = blocks.vector_sink_i(1)
self.tb.connect(self.src_I, self.interleaver_I, self.preamble_sfd_prefixer_I, (self.qpsk_mapper,0))
self.tb.connect(self.src_Q, self.interleaver_Q, self.preamble_sfd_prefixer_Q, (self.qpsk_mapper,1))
self.tb.connect(self.qpsk_mapper, self.dqpsk_mapper, self.dqcsk_mapper, self.dqcsk_demapper, self.dqpsk_demapper, self.qpsk_demapper)
self.tb.connect((self.qpsk_demapper,0), self.preamble_sfd_removal_I, self.deinterleaver_I, self.snk_I)
self.tb.connect((self.qpsk_demapper,1), self.preamble_sfd_removal_Q, self.deinterleaver_Q, self.snk_Q)
self.tb.run()
data_out_I = self.snk_I.data()
data_out_Q = self.snk_Q.data()
self.assertFloatTuplesAlmostEqual(data_out_I, data_in_I)
self.assertFloatTuplesAlmostEqual(data_out_I, data_in_I)
def help_ii(self, size, src_data, exp_data, op):
for s in zip(range (len (src_data)), src_data):
src = blocks.vector_source_i(s[1])
srcv = blocks.stream_to_vector(gr.sizeof_int, size)
self.tb.connect(src, srcv)
self.tb.connect(srcv, (op, s[0]))
rhs = blocks.vector_to_stream(gr.sizeof_int, size)
dst = blocks.vector_sink_i()
self.tb.connect(op, rhs, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_001_t(self):
# Check impulse response
# Impulse is 2^15 due to the fixed point format of the coefficients. With a large enough impulse,
# the filter's impulse response will simply be the filter coefficients.
src_data = (2 ** 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
expected_result = (
-51,
-662,
-190,
510,
12,
-719,
238,
945,
-671,
-1161,
1438,
1341,
-3060,
-1460,
10287,
17886,
10287,
-1460,
-3060,
1341,
1438,
-1161,
-671,
945,
238,
-719,
12,
510,
-190,
-662,
-51,
)
filter_taps = (-51, -662, -190, 510, 12, -719, 238, 945, -671, -1161, 1438, 1341, -3060, -1460, 10287, 17886)
# Filter coefficients are fx1.31, so scale them up to allow us to retreive the filter coefficients from the impulse response.
filter_taps = [x * 2 ** 16 for x in filter_taps]
src = blocks.vector_source_i(src_data)
# FIR filter taps are set to expected_result
fir_filter = zynq.fir_filter_ii(filter_taps)
dst = blocks.vector_sink_i()
self.tb.connect(src, fir_filter)
self.tb.connect(fir_filter, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(result_data, expected_result)
self.tb.disconnect(src, fir_filter)
self.tb.disconnect(fir_filter, dst)
def test_001_t (self):
# set up fg
data_in = [0, np.pi/2, -np.pi/2, np.pi]
self.src = blocks.vector_source_f(data_in)
self.qpsk_demapper = ieee802_15_4.qpsk_demapper_fi()
self.snk_I = blocks.vector_sink_i(1)
self.snk_Q = blocks.vector_sink_i(1)
self.tb.connect(self.src, self.qpsk_demapper)
self.tb.connect((self.qpsk_demapper,0), self.snk_I)
self.tb.connect((self.qpsk_demapper,1), self.snk_Q)
self.tb.run ()
# check data
ref_I = [1,-1,1,-1]
ref_Q = [1,1,-1,-1]
print "data in:", data_in
print "ref I:", ref_I
print "data I:", self.snk_I.data()
print "ref Q:", ref_Q
print "data Q:", self.snk_Q.data()
self.assertFloatTuplesAlmostEqual(ref_I, self.snk_I.data())
self.assertFloatTuplesAlmostEqual(ref_Q, self.snk_Q.data())
def test_001_t(self):
# set up fg
data_in = [0, np.pi / 2, -np.pi / 2, np.pi]
self.src = blocks.vector_source_f(data_in)
self.qpsk_demapper = ieee802_15_4.qpsk_demapper_fi()
self.snk_I = blocks.vector_sink_i(1)
self.snk_Q = blocks.vector_sink_i(1)
self.tb.connect(self.src, self.qpsk_demapper)
self.tb.connect((self.qpsk_demapper, 0), self.snk_I)
self.tb.connect((self.qpsk_demapper, 1), self.snk_Q)
self.tb.run()
# check data
ref_I = [1, -1, 1, -1]
ref_Q = [1, 1, -1, -1]
print("data in:", data_in)
print("ref I:", ref_I)
print("data I:", self.snk_I.data())
print("ref Q:", ref_Q)
print("data Q:", self.snk_Q.data())
self.assertFloatTuplesAlmostEqual(ref_I, self.snk_I.data())
self.assertFloatTuplesAlmostEqual(ref_Q, self.snk_Q.data())
def test_002_int(self):
tb = gr.top_block()
data = [5, 0, 0, -1, -3, -10]
exp = [1, 0, 0, -1, -1, -1]
vlen = 1
src = blocks.vector_source_i(data, False, vlen)
sign = misc.signum_xx(misc.INT, vlen)
snk = blocks.vector_sink_i(vlen)
tb.connect(src, sign, snk)
tb.run()
res = snk.data()
self.assertTupleEqual(res, tuple(exp))
def test_002_t (self):
# set up fg
cfg = phy(slow_rate=False)
data_in = range(541) # some random prime number
self.src = blocks.vector_source_i(data_in)
self.intlv = ieee802_15_4.interleaver_ii(intlv_seq=(),forward=False)
self.snk = blocks.vector_sink_i(1)
self.tb.connect(self.src, self.intlv, self.snk)
self.tb.run ()
# check data
data_out = self.snk.data()
self.assertFloatTuplesAlmostEqual(data_in, data_out)
def test_003_t(self):
# QPSK mapper to demapper
data_in_I = [1, -1, 1, -1]
data_in_Q = [1, 1, -1, -1]
self.src_I = blocks.vector_source_i(data_in_I)
self.snk_I = blocks.vector_sink_i(1)
self.src_Q = blocks.vector_source_i(data_in_Q)
self.snk_Q = blocks.vector_sink_i(1)
self.tb.connect(self.src_I, (self.qpsk_mapper, 0))
self.tb.connect(self.src_Q, (self.qpsk_mapper, 1))
self.tb.connect(self.qpsk_mapper, self.dqpsk_mapper, self.dqcsk_mapper,
self.dqcsk_demapper, self.dqpsk_demapper,
self.qpsk_demapper)
self.tb.connect((self.qpsk_demapper, 0), self.snk_I)
self.tb.connect((self.qpsk_demapper, 1), self.snk_Q)
self.tb.run()
data_out_I = self.snk_I.data()
data_out_Q = self.snk_Q.data()
self.assertFloatTuplesAlmostEqual(data_in_I, data_out_I)
self.assertFloatTuplesAlmostEqual(data_in_Q, data_out_Q)
def test_002_t(self):
# set up fg
cfg = phy(slow_rate=False)
data_in = range(541) # some random prime number
self.src = blocks.vector_source_i(data_in)
self.intlv = ieee802_15_4.interleaver_ii(intlv_seq=(), forward=False)
self.snk = blocks.vector_sink_i(1)
self.tb.connect(self.src, self.intlv, self.snk)
self.tb.run()
# check data
data_out = self.snk.data()
self.assertFloatTuplesAlmostEqual(data_in, data_out)
def test_002(self):
src_data = [1,2,3,4]
expected_result = [16777216, 33554432, 50331648, 67108864];
src = blocks.vector_source_i(src_data)
op = blocks.endian_swap(4)
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = list(dst.data())
self.assertEqual(expected_result, result_data)
def test_002(self):
src_data = [1,2,3,4]
expected_result = [16777216, 33554432, 50331648, 67108864];
src = blocks.vector_source_i(src_data)
op = blocks.endian_swap(4)
dst = blocks.vector_sink_i()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = list(dst.data())
self.assertEqual(expected_result, result_data)
def test_skip_reset(self):
skip_cnt = 2
expected_result = tuple(self.src_data[skip_cnt:])
src1 = blocks.vector_source_i(self.src_data)
op = analyzer.skiphead_reset(gr.sizeof_int, skip_cnt)
dst1 = blocks.vector_sink_i()
self.tb.connect(src1, op, dst1)
self.tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
op.reset()
src1.rewind()
self.tb.run()
self.assertEqual(expected_result, dst_data)
def test_001_t (self):
# set up fg
cfg = phy()
data1 = range(cfg.nsym_frame-len(cfg.preamble)-len(cfg.SFD))
data2 = range(cfg.nsym_frame-len(cfg.preamble)-len(cfg.SFD), 2*(cfg.nsym_frame-len(cfg.preamble)-len(cfg.SFD)))
data_in = np.concatenate((data1, data2))
self.src = blocks.vector_source_i(data_in)
self.prefixer = ieee802_15_4.preamble_sfd_prefixer_ii(cfg.preamble, cfg.SFD, cfg.nsym_frame)
self.snk = blocks.vector_sink_i(1)
self.tb.connect(self.src, self.prefixer, self.snk)
self.tb.run ()
# check data
data_out = self.snk.data()
ref = np.concatenate((cfg.preamble, cfg.SFD, data1, cfg.preamble, cfg.SFD, data2))
self.assertFloatTuplesAlmostEqual(data_out, ref)
def test_201b(self):
random.seed(0)
src_data = []
for i in range(100):
src_data.append((random.randint(-2**31,2**31-1)))
src_data = tuple(src_data)
expected_results = src_data
src = blocks.vector_source_i(tuple(src_data), False)
op1 = blocks.packed_to_unpacked_ii(8, gr.GR_LSB_FIRST)
op2 = blocks.unpacked_to_packed_ii(8, gr.GR_LSB_FIRST)
dst = blocks.vector_sink_i()
self.tb.connect(src, op1, op2)
self.tb.connect(op2, dst)
self.tb.run()
self.assertEqual(expected_results, dst.data())
def test_003_t (self):
# set up fg
cfg = phy(slow_rate=True)
data_in = range(3*len(cfg.intlv_seq)) # some random prime number
self.src = blocks.vector_source_i(data_in)
self.intlv = ieee802_15_4.interleaver_ii(intlv_seq=cfg.intlv_seq,forward=True)
self.snk = blocks.vector_sink_i(1)
self.tb.connect(self.src, self.intlv, self.snk)
self.tb.run ()
# check data
data_out = self.snk.data()
ref = []
for n in range(3):
for i in range(len(cfg.intlv_seq)):
ref.append(data_in[n*len(cfg.intlv_seq)+cfg.intlv_seq[i]])
self.assertFloatTuplesAlmostEqual(ref, data_out)
def test_003_int(self):
minimum = 2 ** 12 - 2
maximum = 2 ** 17 + 5
seed = 3
n_items = 10000
rnd_src = analog.random_uniform_source_i(minimum, maximum, seed)
head = blocks.head(4, n_items)
snk = blocks.vector_sink_i(1)
self.tb.connect(rnd_src, head, snk)
# set up fg
self.tb.run()
# check data
res = snk.data()
# plt.hist(res)
# plt.show()
self.assertGreaterEqual(np.min(res), minimum)
self.assertLess(np.max(res), maximum)
def test_001_t(self):
# set up fg
cfg = phy()
bits = (0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1)
cw = cfg.codewords
self.src = blocks.vector_source_b(bits)
self.enc = ieee802_15_4.codeword_mapper_bi(bits_per_cw=cfg.bits_per_symbol, codewords=cw)
self.snk = blocks.vector_sink_i(1)
self.snk2 = blocks.vector_sink_b(1)
self.tb.connect(self.src, self.enc, self.snk)
self.tb.connect(self.src, self.snk2)
self.tb.run()
# check data
data = self.snk.data()
print "len data:", len(self.snk2.data())
print "rx data:", data
ref = np.concatenate((cw[0], cw[1], cw[2], cw[3], cw[4], cw[5], cw[6], cw[7]))
print "ref:", ref
self.assertFloatTuplesAlmostEqual(data, ref)
