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_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_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_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_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_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_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)