def test_deint_001(self): lenx = 64 src0 = gr.vector_source_i(range(lenx)) op = gr.deinterleave(gr.sizeof_int, 4) dst0 = gr.vector_sink_i() dst1 = gr.vector_sink_i() dst2 = gr.vector_sink_i() dst3 = gr.vector_sink_i() self.tb.connect(src0, op) op.connect(dst0, usesPortName="long_out_0") op.connect(dst1, usesPortName="long_out_1") op.connect(dst2, usesPortName="long_out_2") op.connect(dst3, usesPortName="long_out_3") self.tb.run() expected_result0 = tuple(range(0, lenx, 4)) expected_result1 = tuple(range(1, lenx, 4)) expected_result2 = tuple(range(2, lenx, 4)) expected_result3 = tuple(range(3, lenx, 4)) self.assertFloatTuplesAlmostEqual(expected_result0, dst0.data()) self.assertFloatTuplesAlmostEqual(expected_result1, dst1.data()) self.assertFloatTuplesAlmostEqual(expected_result2, dst2.data()) self.assertFloatTuplesAlmostEqual(expected_result3, dst3.data())
def test_deint_001 (self): lenx = 64 src0 = gr.vector_source_i (range (lenx)) op = gr.deinterleave (gr.sizeof_int,4) dst0 = gr.vector_sink_i () dst1 = gr.vector_sink_i () dst2 = gr.vector_sink_i () dst3 = gr.vector_sink_i () self.tb.connect (src0, op) op.connect(dst0,usesPortName="long_out_0") op.connect(dst1,usesPortName="long_out_1") op.connect(dst2,usesPortName="long_out_2") op.connect(dst3,usesPortName="long_out_3") self.tb.run () expected_result0 = tuple (range (0, lenx, 4)) expected_result1 = tuple (range (1, lenx, 4)) expected_result2 = tuple (range (2, lenx, 4)) expected_result3 = tuple (range (3, lenx, 4)) self.assertFloatTuplesAlmostEqual (expected_result0, dst0.data()) self.assertFloatTuplesAlmostEqual (expected_result1, dst1.data()) self.assertFloatTuplesAlmostEqual (expected_result2, dst2.data ()) self.assertFloatTuplesAlmostEqual (expected_result3, dst3.data ())
def xtest_003(self): # number of input streams != number of output streams src0_data = self.make_random_int_tuple(16000) src1_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) src1 = gr.vector_source_i(src1_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() dst1 = gr.vector_sink_i() self.tb.connect(src0, (op, 0), dst0) self.tb.connect(src1, (op, 1)) self.assertRaises(ValueError, self.tb.run)
def test_003(self): # number of input streams != number of output streams src0_data = self.make_random_int_tuple(16000) src1_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) src1 = gr.vector_source_i(src1_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() dst1 = gr.vector_sink_i() self.fg.connect(src0, (op, 0), dst0) self.fg.connect(src1, (op, 1)) self.assertRaises(ValueError, self.fg.run)
def test_002_codem5(self): """ Check Golay-SD-decoding m5 for 5 possible inputs """ expected_data = (1360, 1481, 990, 1522, 1604) src_data = (0.395, 0.737, 0.360, 0.688, 0.443, 0.243, 0.755, 0.045, 0.263, 0.587, 0.150, 0.348, 0.521, 0.742, 0.672, 0.394, 0.485, 0.862, 0.531, 0.526, 0.094, 0.697, 0.139, 0.193, 0.973, 0.933, 0.772, 0.628, 0.764, 0.366, 0.449, 0.405, 0.155, 0.589, 0.885, 0.515, 0.990, 0.862, 0.168, 0.769, 0.834, 0.439, 0.672, 0.328, 0.950, 0.791, 0.217, 0.378, 0.756, 0.809, 0.397, 0.770, 0.392, 0.888, 0.430, 0.822, 0.198, 0.271, 0.425, 0.331, 0.020, 0.443, 0.705, 0.684, 0.228, 0.802, 0.480, 0.528, 0.990, 0.613, 0.866, 0.001, 0.989, 0.880, 0.816, 0.583, 0.697, 0.930, 0.561, 0.851, 0.055, 0.148, 0.496, 0.190, 0.496, 0.679, 0.137, 0.112, 0.090, 0.535, 0.319, 0.790, 0.826, 0.749, 0.407, 0.200, 0.193, 0.490, 0.050, 0.363, 0.615, 0.032, 0.630, 0.553, 0.210, 0.845, 0.485, 0.863, 0.121, 0.017, 0.581, 0.929, 0.582, 0.770, 0.983, 0.891, 0.730, 0.661, 0.626, 0.084, 0.667, 0.247, 0.586, 0.739, 0.846, 0.575, 0.901, 0.499, 0.729, 0.932, 0.053, 0.574, 0.621, 0.167, 0.143, 0.106, 0.083, 0.948, 0.206, 0.418, 0.641, 0.565, 0.209, 0.271, 0.874, 0.853, 0.491, 0.124, 0.446, 0.536, 0.500, 0.696, 0.539, 0.282, 0.636, 0.043, 0.190, 0.147, 0.206, 0.124) src1 = gr.vector_source_f(src_data, 0, 32) coding_action = chancoding.rmg_decoder_sd_vfi(5, 5) sink = gr.vector_sink_i() self.tb.connect(src1, coding_action) self.tb.connect(coding_action, sink) self.tb.run() for i in range(len(expected_data)): self.assertEqual(sink.data()[i], expected_data[i])
def test_003(self): # Need to add padding to keep proper alignment padding = tuple([0 for i in range(5)]) scale = 2 vlen = 3 src_data = (0.0, 1.1, 2.2,) + padding + \ (3.3, 4.4, 5.5,) + padding + \ (-1.1, -2.2, -3.3,) + padding expected_result = [0, 2, 4] expected_result.extend(padding) expected_result.extend([7, 9, 11]) expected_result.extend(padding) expected_result.extend([-2, -4, -7]) expected_result.extend(padding) src = gr.vector_source_f(src_data) s2v = gr.stream_to_vector(gr.sizeof_float, vlen) op = gr.float_to_int(vlen, scale) v2s = gr.vector_to_stream(gr.sizeof_int, vlen) dst = gr.vector_sink_i() self.tb.connect(src, s2v, op, v2s, dst) self.tb.run() result_data = list(dst.data()) self.assertEqual(expected_result, result_data)
def test_002(self): # 2 input streams; 2 output streams src0_data = self.make_random_int_tuple(16000) src1_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) src1 = gr.vector_source_i(src1_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() dst1 = gr.vector_sink_i() self.tb.connect(src0, (op, 0), dst0) self.tb.connect(src1, (op, 1), dst1) self.tb.run() dst0_data = dst0.data() dst1_data = dst1.data() self.assertEqual(src0_data, dst0_data) self.assertEqual(src1_data, dst1_data)
def test_int_001(self): lenx = 64 src0 = range(0, lenx, 4) src1 = range(1, lenx, 4) src2 = range(2, lenx, 4) src3 = range(3, lenx, 4) a = sb.DataSource(dataFormat="long") b = sb.DataSource(dataFormat="long") c = sb.DataSource(dataFormat="long") d = sb.DataSource(dataFormat="long") op = gr.interleave(gr.sizeof_int, 4) dst = gr.vector_sink_i() a.connect(op, providesPortName="long_in_0") b.connect(op, providesPortName="long_in_1") c.connect(op, providesPortName="long_in_2") d.connect(op, providesPortName="long_in_3") a.push(src0, EOS=True) b.push(src1, EOS=True) c.push(src2, EOS=True) d.push(src3, EOS=True) self.tb.connect(op, dst) self.tb.run() expected_result = tuple(range(lenx)) result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def test_002(self): # 2 input streams; 2 output streams src0_data = self.make_random_int_tuple(16000) src1_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) src1 = gr.vector_source_i(src1_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() dst1 = gr.vector_sink_i() self.fg.connect(src0, (op, 0), dst0) self.fg.connect(src1, (op, 1), dst1) self.fg.run() dst0_data = dst0.data() dst1_data = dst1.data() self.assertEqual(src0_data, dst0_data) self.assertEqual(src1_data, dst1_data)
def test_int_001 (self): lenx = 64 src0 = range (0, lenx, 4) src1 = range (1, lenx, 4) src2 = range (2, lenx, 4) src3 = range (3, lenx, 4) a = sb.DataSource(dataFormat="long") b = sb.DataSource(dataFormat="long") c = sb.DataSource(dataFormat="long") d = sb.DataSource(dataFormat="long") op = gr.interleave (gr.sizeof_int, 4) dst = gr.vector_sink_i () a.connect(op, providesPortName="long_in_0") b.connect(op, providesPortName="long_in_1") c.connect(op, providesPortName="long_in_2") d.connect(op, providesPortName="long_in_3") a.push(src0,EOS=True) b.push(src1,EOS=True) c.push(src2,EOS=True) d.push(src3,EOS=True) self.tb.connect (op, dst) self.tb.run () expected_result = tuple (range (lenx)) result_data = dst.data () self.assertFloatTuplesAlmostEqual (expected_result, result_data)
def test_001_coder3m7 (self): """ Check Golay-encoding m=7 for 5 possible inputs """ src_data = (121,9,235,32,492,194,342,100,10,1) expected_data = ( 786312737, -786354655, -786312738, -786354655, 303895266, -303951134, -303895267, -303951134, -2071231372, 2071233652, -2071231372, -2071233653, -487776787, 487726573, 487776786, 487726573, 2104655245, 2104656498, -2104655246, 2104656498, 1954253691, -1954247813, 1954253691, 1954247812, -668457176, -668411689, -668457176, 668411688, 773968161, 773926622, -773968162, 773926622, 303895266, -303951134, 303895266, 303951133, 303951133, -303895267, -303951134, -303895267) src1 = gr.vector_source_i(src_data) coding_action = chancoding.rmg_encoder_vii(7,11) sink = gr.vector_sink_i(4) self.tb.connect(src1, coding_action) self.tb.connect(coding_action, sink) self.tb.run() for i in range( len(expected_data) ): self.assertEqual( sink.data()[i] , expected_data[i], i)
def test_003_t (self): """ two states, random switching """ n_bytes = 10000 ber = (0, 0.5) trans_matrix = (0.5, 0.5, 0.5, 0.5) src = gr.glfsr_source_b(32) # Create some pseudo-random bits head = gr.head(1, n_bytes) chan = cc.markovchan_bb(ber, trans_matrix, 8) ber = cc.ber_b(8) sink_state = gr.vector_sink_i() self.tb.connect(src, head, chan, (ber, 0)) self.tb.connect(head, (ber, 1)) self.tb.connect((chan, 1), sink_state) self.tb.run () n_times_in_state_1 = np.sum(sink_state.data()) print "\nNumber of times in state 1 = " + str(n_times_in_state_1) print " Expected value = " + str(n_bytes/2) self.assertTrue(n_times_in_state_1 > 3500 and n_times_in_state_1 < 6500, "Due to the statistical nature of the bsc, this can actually fail (though very unlikely). Try again.") print " Measured BER = " + str(ber.ber()) print "Expected value = 0.25" self.assertTrue(abs(ber.ber()- 0.25) < 0.05, msg="Due to the statistical nature of the bsc, this can actually fail (though very unlikely). Try again.")
def test_001_coder3m7(self): """ Check Golay-encoding m=7 for 5 possible inputs """ src_data = (121, 9, 235, 32, 492, 194, 342, 100, 10, 1) expected_data = (786312737, -786354655, -786312738, -786354655, 303895266, -303951134, -303895267, -303951134, -2071231372, 2071233652, -2071231372, -2071233653, -487776787, 487726573, 487776786, 487726573, 2104655245, 2104656498, -2104655246, 2104656498, 1954253691, -1954247813, 1954253691, 1954247812, -668457176, -668411689, -668457176, 668411688, 773968161, 773926622, -773968162, 773926622, 303895266, -303951134, 303895266, 303951133, 303951133, -303895267, -303951134, -303895267) src1 = gr.vector_source_i(src_data) coding_action = chancoding.rmg_encoder_vii(7, 11) sink = gr.vector_sink_i(4) self.tb.connect(src1, coding_action) self.tb.connect(coding_action, sink) self.tb.run() for i in range(len(expected_data)): self.assertEqual(sink.data()[i], expected_data[i], i)
def test_003(self): # Need to add padding to keep proper alignment padding = tuple([0 for i in range(5)]) scale = 2 vlen = 3 src_data = (0.0, 1.1, 2.2) + padding + (3.3, 4.4, 5.5) + padding + (-1.1, -2.2, -3.3) + padding expected_result = [0, 2, 4] expected_result.extend(padding) expected_result.extend([7, 9, 11]) expected_result.extend(padding) expected_result.extend([-2, -4, -7]) expected_result.extend(padding) src = gr.vector_source_f(src_data) s2v = gr.stream_to_vector(gr.sizeof_float, vlen) op = gr.float_to_int(vlen, scale) v2s = gr.vector_to_stream(gr.sizeof_int, vlen) dst = gr.vector_sink_i() self.tb.connect(src, s2v, op, v2s, dst) self.tb.run() result_data = list(dst.data()) self.assertEqual(expected_result, result_data)
def test_001_codeallr2m3 (self): """ Check Golay-SD-decoding m=3 for all possible inputs """ src_data = ( 0.648,0.680,0.636,0.946,0.209,0.710,0.237,0.120, 0.608,0.451,0.459,0.662,0.771,0.351,0.663,0.417, 0.842,0.833,0.257,0.614,0.583,0.541,0.870,0.265, 0.319,0.120,0.940,0.646,0.480,0.640,0.545,0.648, 0.544,0.722,0.523,0.994,0.219,0.106,0.110,0.064) expected_data = ( 6, 0, 14, 1, 22) src1 = gr.vector_source_f(src_data,0,8) coding_action = chancoding.rmg_decoder_sd_vfi(3,1) sink = gr.vector_sink_i() self.tb.connect(src1, coding_action) self.tb.connect(coding_action, sink) self.tb.run() self.assertEqual( coding_action.get_vlen_in(), 8) self.assertEqual( coding_action.get_vlen_out(), 1) self.assertEqual( coding_action.get_num_bits_out(), 5) for i in range( len(expected_data) ): self.assertEqual( sink.data()[i] , expected_data[i], i)
def __init__(self, decim=16, N_id_2=0, avg_frames=1, freq_corr=0, N_id_1=134, file_name="/home/user/git/gr-lte/gr-lte/test/traces/lte_02_796m_30720k_frame.cfile"): gr.top_block.__init__(self, "Pss Corr Block Gui") ################################################## # Parameters ################################################## self.decim = decim self.N_id_2 = N_id_2 self.avg_frames = avg_frames self.freq_corr = freq_corr self.N_id_1 = N_id_1 self.file_name = file_name ################################################## # Variables ################################################## self.vec_half_frame = vec_half_frame = 30720*5/decim self.transition_width = transition_width = 100e3 self.samp_rate = samp_rate = 30720e3/decim self.cutoff_freq = cutoff_freq = 550e3 ################################################## # Blocks ################################################## self.gr_vector_sink_sss10 = gr.vector_sink_i(1) self.gr_vector_sink_sss0 = gr.vector_sink_i(1) self.gr_vector_sink_pss = gr.vector_sink_i(1) self.gr_throttle_0 = gr.throttle(gr.sizeof_gr_complex*1, samp_rate*decim) self.gr_null_sink_0 = gr.null_sink(gr.sizeof_gr_complex*1) self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex*1, file_name, False) self.fir_filter_xxx_0 = filter.fir_filter_ccc(decim, (firdes.low_pass(1, decim*samp_rate, cutoff_freq, transition_width))) self.any_0_0_0 = sss_corr(N_id_1,N_id_2,False, decim, avg_frames,freq_corr) self.any_0_0 = sss_corr(N_id_1,N_id_2,True, decim, avg_frames,freq_corr) self.any_0 = pss_corr(N_id_2, decim, avg_frames*2,freq_corr) ################################################## # Connections ################################################## self.connect((self.any_0_0_0, 0), (self.gr_vector_sink_sss10, 0)) self.connect((self.fir_filter_xxx_0, 0), (self.any_0_0_0, 0)) self.connect((self.any_0_0, 0), (self.gr_vector_sink_sss0, 0)) self.connect((self.fir_filter_xxx_0, 0), (self.any_0_0, 0)) self.connect((self.any_0, 0), (self.gr_vector_sink_pss, 0)) self.connect((self.fir_filter_xxx_0, 0), (self.any_0, 0)) self.connect((self.gr_throttle_0, 0), (self.fir_filter_xxx_0, 0)) self.connect((self.gr_file_source_0, 0), (self.gr_throttle_0, 0)) self.connect((self.gr_file_source_0, 0), (self.gr_null_sink_0, 0))
def help_const_ii(self, src_data, exp_data, op): src = gr.vector_source_i(src_data) srcv = gr.stream_to_vector(gr.sizeof_int, len(src_data)) rhs = gr.vector_to_stream(gr.sizeof_int, len(src_data)) dst = gr.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 (range (len (src_data)), src_data): src = gr.vector_source_i (s[1]) self.tb.connect (src, (op, s[0])) dst = gr.vector_sink_i () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () self.assertEqual (exp_data, result_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 = gr.vector_source_f(src_data) op = blocks_swig.float_to_int() dst = gr.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 = gr.vector_source_i(src_data) op = blocks_swig.and_const_ii (0x55AA) dst = gr.vector_sink_i() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(dst.data(), expected_result)
def run(self, n_receive=None): """ Run the simulation. Args: n_receive: Stop after receiving this many samples. """ b100.set_image(self.fpgaimage) # steps_rqd only in for compatibility from gnuradio import gr, uhd if n_receive is None: n_receive = 10000 # Flip high and low bits of in_raw flipped_raw = flip_bits(self.in_raw, self.width) flipped_raw = unsigned_to_signed(flipped_raw, self.width) stream_args = uhd.stream_args(cpu_format='sc16', channels=range(1)) from_usrp = uhd.usrp_source(device_addr='', stream_args=stream_args) head = gr.head(4, n_receive) snk = gr.vector_sink_i() to_usrp = uhd.usrp_sink(device_addr='', stream_args=stream_args) src = gr.vector_source_i(flipped_raw) tb = gr.top_block() tb.connect(from_usrp, head, snk) tb.connect(src, to_usrp) tb.run() self.out_raw = snk.data() # Remove 0's start_offset = None stop_offset = None enumerated_raw = list(enumerate(self.out_raw)) for i, r in enumerated_raw: if r != 0: start_offset = i break for i, r in reversed(enumerated_raw): if r != 0: stop_offset = i break if start_offset is None or stop_offset is None: raise StandardError("Could not find any non-zero returned data.") self.out_raw = self.out_raw[start_offset:stop_offset + 1] # Shift to positive integers positive = [] for r in self.out_raw: if r < 0: r += pow(2, self.width) positive.append(r) self.out_raw = positive # Flip bits in out_raw self.out_raw = flip_bits(self.out_raw, self.width) if self.output_msgs: header_shift = pow(2, self.width - 1) samples, packets = stream_to_samples_and_packets(self.out_raw) self.out_samples = [ int_to_c(s, self.width / 2 - 1) for s in samples ] self.out_messages = packets
def test_001_ii(self): src_data = (1, 2, 3, 4, 5, 6) dst_data = (6, 15) src = gr.vector_source_i(src_data) itg = blocks_swig.integrate_ii(3) dst = gr.vector_sink_i() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data())
def body_110 (self): fg = self.fg src_data = (0, 1, 2, 3) src1 = gr.vector_source_i (src_data) dst1 = gr.vector_sink_i () fg.connect ((src1, 0), (dst1, 0)) fg.run () dst_data = dst1.data () self.assertEqual (src_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 = gr.vector_source_f(src_data) op = blocks_swig.float_to_int(1, 5) dst = gr.vector_sink_i() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def help_ii(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_i(s[1]) self.tb.connect(src, (op, s[0])) dst = gr.vector_sink_i() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_001_ii(self): src_data = (1, 2, 3, 4, 5, 6) dst_data = (6, 15) src = gr.vector_source_i(src_data) itg = gr.integrate_ii(3) dst = gr.vector_sink_i() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data())
def test_copy (self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_result = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) src = gr.vector_source_i(src_data) op = gr.copy(gr.sizeof_int, True,4) dst = gr.vector_sink_i() self.tb.connect(src, op, dst) self.tb.run() dst_data = dst.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 = gr.vector_source_i (self.src_data) op = gr.skiphead (gr.sizeof_int, skip_cnt) dst1 = gr.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(self): # 1 input stream; 1 output stream src0_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() self.fg.connect(src0, op, dst0) self.fg.run() dst0_data = dst0.data() self.assertEqual(src0_data, dst0_data)
def test_001(self): # 1 input stream; 1 output stream src0_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() self.tb.connect(src0, op, dst0) self.tb.run() dst0_data = dst0.data() self.assertEqual(src0_data, dst0_data)
def test_skip_all(self): skip_cnt = len(self.src_data) expected_result = tuple(self.src_data[skip_cnt:]) src1 = gr.vector_source_i(self.src_data) op = gr.skiphead(gr.sizeof_int, skip_cnt) dst1 = gr.vector_sink_i() self.tb.connect(src1, op, dst1) self.tb.run() dst_data = dst1.data() self.assertEqual(expected_result, dst_data)
def run(self, n_receive=None): """ Run the simulation. Args: n_receive: Stop after receiving this many samples. """ b100.set_image(self.fpgaimage) # steps_rqd only in for compatibility from gnuradio import gr, uhd if n_receive is None: n_receive = 10000 # Flip high and low bits of in_raw flipped_raw = flip_bits(self.in_raw, self.width) flipped_raw = unsigned_to_signed(flipped_raw, self.width) stream_args = uhd.stream_args(cpu_format='sc16', channels=range(1)) from_usrp = uhd.usrp_source(device_addr='', stream_args=stream_args) head = gr.head(4, n_receive) snk = gr.vector_sink_i() to_usrp = uhd.usrp_sink(device_addr='', stream_args=stream_args) src = gr.vector_source_i(flipped_raw) tb = gr.top_block() tb.connect(from_usrp, head, snk) tb.connect(src, to_usrp) tb.run() self.out_raw = snk.data() # Remove 0's start_offset = None stop_offset = None enumerated_raw = list(enumerate(self.out_raw)) for i, r in enumerated_raw: if r != 0: start_offset = i break for i, r in reversed(enumerated_raw): if r != 0: stop_offset = i break if start_offset is None or stop_offset is None: raise StandardError("Could not find any non-zero returned data.") self.out_raw = self.out_raw[start_offset: stop_offset+1] # Shift to positive integers positive = [] for r in self.out_raw: if r < 0: r += pow(2, self.width) positive.append(r) self.out_raw = positive # Flip bits in out_raw self.out_raw = flip_bits(self.out_raw, self.width) if self.output_msgs: header_shift = pow(2, self.width-1) samples, packets = stream_to_samples_and_packets(self.out_raw) self.out_samples = [int_to_c(s, self.width/2-1) for s in samples] self.out_messages = packets
def body_303_hier (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (35, 38, 41, 44) src1 = gr.vector_source_i (src_data) op = gr.compose (fg, gr.add_const_ii (10), mult_add (fg, 3, 5)) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_head (self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_result = (1, 2, 3, 4) src1 = gr.vector_source_i (src_data) op = gr.head (gr.sizeof_int, 4) dst1 = gr.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_head(self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_result = (1, 2, 3, 4) src1 = gr.vector_source_i(src_data) op = gr.head(gr.sizeof_int, 4) dst1 = gr.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 help_ii (self, src_data, exp_data, op, port_prefix='data_in_'): for s in zip (range (len (src_data)), src_data): src = gr.vector_source_i (s[1]) src.source.connect(op,providesPortName=port_prefix+str(s[0])) src.streamID = str(s[0]) self.tb.sources.append(src) dst = gr.vector_sink_i () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () self.assertEqual (exp_data, result_data)
def test_012_connect (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (2, 3, 4, 5) src1 = gr.vector_source_i (src_data) op = gr.add_const_ii (2) dst1 = gr.vector_sink_i () fg.connect (src1, op) fg.connect (op, dst1) # print "edge_list:", fg.edge_list fg.validate ()
def body_302_hier (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (10, 11, 12, 13) src1 = gr.vector_source_i (src_data) op = gr.compose (fg, gr.add_const_ii (10)) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_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 = gr.head(gr.sizeof_int, 4) dst1 = gr.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_const_i (self): fg = self.fg expected_result = (1, 1, 1, 1) src1 = gr.sig_source_i (1e6, gr.GR_CONST_WAVE, 0, 1) op = gr.head (gr.sizeof_int, 4) dst1 = gr.vector_sink_i () fg.connect (src1, op) fg.connect (op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def body_111v (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (2, 3, 4, 5) src1 = gr.vector_source_i (src_data) op = gr.add_const_ii (2) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def body_300_hier (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (10, 11, 12, 13) src1 = gr.vector_source_i (src_data) op = wrap_add (fg, 10) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_const_i (self): tb = self.tb expected_result = (1, 1, 1, 1) src1 = gr.sig_source_i (1e6, gr.GR_CONST_WAVE, 0, 1) op = gr.head (gr.sizeof_int, 4) dst1 = gr.vector_sink_i () tb.connect (src1, op) tb.connect (op, dst1) tb.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def help_ii(self, src_data, exp_data, op, port_prefix='data_in_'): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_i(s[1]) src.source.connect(op, providesPortName=port_prefix + str(s[0])) src.streamID = str(s[0]) self.tb.sources.append(src) dst = gr.vector_sink_i() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def body_301_hier (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (5, 8, 11, 14) src1 = gr.vector_source_i (src_data) op = mult_add (fg, 3, 5) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_deint_001(self): lenx = 64 src = gr.vector_source_i(range(lenx)) op = gr.deinterleave(gr.sizeof_int, 1) dst0 = gr.vector_sink_i() self.tb.connect(src, op) self.tb.connect((op, 0), dst0) self.tb.run() expected_result0 = tuple(range(0, lenx, 1)) self.assertFloatTuplesAlmostEqual(expected_result0, dst0.data())
def test_001_lut(self): """test with integers""" src = gr.vector_source_b((1, 3, 2, 0)) table = [[1, 5, 3, 9], [2, 3, 8, -1], [3, 9, 12, 3]] expected_result = [table[i] for i in (1, 0, 2, 0)] expected_result = tuple(itertools.chain.from_iterable(expected_result)) dst = gr.vector_sink_i(len(table[0])) lut = mlse_swig.lut_biv(table) self.tb.connect(src, lut, dst) self.tb.run() result_data = dst.data() self.assertEquals(expected_result, result_data)
def help_ii(self, size, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_i(s[1]) srcv = gr.stream_to_vector(gr.sizeof_int, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = gr.vector_to_stream(gr.sizeof_int, size) dst = gr.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(self): src_data = (0.0, 1.1, 2.2, 3.3, 4.4, 5.5, -1.1, -2.2, -3.3, -4.4, -5.5) expected_result = [int(round(s)) for s in src_data] src = gr.vector_source_f(src_data) op = gr.float_to_int() dst = gr.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_code_r5m5 (self): """ Check encoding r=5 m=5 for 5 possible inputs """ expected_data = (-1771465066, 1721341545, 252654387, 858993459, -1431672471) src_data = (125,182,392,16,419) src1 = gr.vector_source_i(src_data) coding_action = chancoding.rm_encoder_vii(5,5) sink = gr.vector_sink_i() self.tb.connect(src1, coding_action) self.tb.connect(coding_action, sink) self.tb.run() for i in range( len(expected_data) ): self.assertEqual( sink.data()[i] , expected_data[i], i)
def test_001(self): self.maxDiff = None tb = gr.top_block() src1 = gr.vector_source_i(range(0, 100)) src2 = gr.vector_source_i(range(0, 100)) src3 = gr.vector_source_i(range(0, 100)) # itemsize, M, N, offset km2 = gr.keep_m_in_n(gr.sizeof_int, 4, 1, 2, 0) km3 = gr.keep_m_in_n(gr.sizeof_int, 4, 1, 3, 1) km7 = gr.keep_m_in_n(gr.sizeof_int, 4, 1, 7, 2) snk2 = gr.vector_sink_i() snk3 = gr.vector_sink_i() snk7 = gr.vector_sink_i() tb.connect(src1, km2, snk2) tb.connect(src2, km3, snk3) tb.connect(src3, km7, snk7) tb.run() self.assertEqual(range(0, 100, 2), list(snk2.data())) self.assertEqual(range(1, 100, 3), list(snk3.data())) self.assertEqual(range(2, 100, 7), list(snk7.data()))
def test_int_001(self): lenx = 64 src0 = range(0, lenx, 1) a = sb.DataSource(dataFormat="long") op = gr.interleave(gr.sizeof_int, 1) dst = gr.vector_sink_i() a.connect(op, providesPortName="long_in") a.push(src0, EOS=True) self.tb.connect(op, dst) self.tb.run() expected_result = tuple(range(lenx)) result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def test_001(self): """numbers from 0 to 6, this time in an int source""" src = mlse_swig.randint_i(7) head = gr.head(gr.sizeof_int, 10000) dst = gr.vector_sink_i() self.tb.connect(src, head, dst) self.tb.run() data = dst.data() a = set(data) self.assertEquals(a, set(range(7))) counts = [data.count(i) for i in range(7)] countdiff = max(counts) - min(counts) print max(counts), min(counts), countdiff self.assertTrue(countdiff < 500) # this can fail by chance
def test_002(self): src_data = [1, 2, 3, 4] expected_result = [16777216, 33554432, 50331648, 67108864] src = gr.vector_source_i(src_data) op = gr.endian_swap(4) dst = gr.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=(-100,-99,-98,-97,-96,-1) expected_result = ((max(src_data)), ) src = gr.vector_source_i(src_data) s2v = gr.stream_to_vector(gr.sizeof_int, len(src_data)) op = gr.max_(gr.sizeof_int, 1, len(src_data) ) dst = gr.vector_sink_i() self.tb.connect(src, s2v, op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)