def test_003_ff(self): N = 10000 # number of samples to use fs = 1000 # baseband sampling rate rrate = 1.123 # resampling rate freq = 10 data = sig_source_f(fs, freq, 1, N) ctrl = const_source_f(rrate, N) signal = blocks.vector_source_f(data) control = blocks.vector_source_f(ctrl) op = filter.fractional_resampler_ff(0, 1) snk = blocks.vector_sink_f() self.tb.connect(signal, op, snk) self.tb.connect(control, (op,1)) self.tb.run() Ntest = 5000 L = len(snk.data()) t = map(lambda x: float(x)/(fs/rrate), xrange(L)) phase = 0.1884 expected_data = map(lambda x: math.sin(2.*math.pi*freq*x+phase), t) dst_data = snk.data() self.assertFloatTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 3)
def test_interleaving(self): # Takes 3 streams (a, b and c) # Outputs 2 streams. # First (d) is interleaving of a and b. # Second (e) is interleaving of a and b and c. c is taken in # chunks of 2 which are reversed. A = (1, 2, 3, 4, 5) B = (11, 12, 13, 14, 15) C = (99, 98, 97, 96, 95, 94, 93, 92, 91, 90) expected_D = (1, 11, 2, 12, 3, 13, 4, 14, 5, 15) expected_E = (1, 11, 98, 99, 2, 12, 96, 97, 3, 13, 94, 95, 4, 14, 92, 93, 5, 15, 90, 91) mapping = [[(0, 0), (1, 0)], # mapping to produce D [(0, 0), (1, 0), (2, 1), (2, 0)], # mapping to produce E ] srcA = blocks.vector_source_f(A, False, 1) srcB = blocks.vector_source_f(B, False, 1) srcC = blocks.vector_source_f(C, False, 2) vmap = blocks.vector_map(gr.sizeof_int, (1, 1, 2), mapping) dstD = blocks.vector_sink_f(2) dstE = blocks.vector_sink_f(4) self.tb.connect(srcA, (vmap, 0)) self.tb.connect(srcB, (vmap, 1)) self.tb.connect(srcC, (vmap, 2)) self.tb.connect((vmap, 0), dstD) self.tb.connect((vmap, 1), dstE) self.tb.run() self.assertEqual(expected_D, dstD.data()) self.assertEqual(expected_E, dstE.data())
def test_preserve_tag_head_pos(self): """ Test the 'preserve head position' function. This will add a 'special' tag to item 0 on stream 1. It should be on item 0 of the output stream. """ special_tag = gr.tag_t() special_tag.key = pmt.string_to_symbol('spam') special_tag.offset = 0 special_tag.value = pmt.to_pmt('eggs') len_tag_key = "length" packet_len_1 = 5 packet_len_2 = 3 mux = blocks.tagged_stream_mux(gr.sizeof_float, len_tag_key, 1) sink = blocks.vector_sink_f() self.tb.connect( blocks.vector_source_f(range(packet_len_1)), blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_1, len_tag_key), (mux, 0) ) self.tb.connect( blocks.vector_source_f(range(packet_len_2), False, 1, (special_tag,)), blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_2, len_tag_key), (mux, 1) ) self.tb.connect(mux, sink) self.tb.run() self.assertEqual(sink.data(), tuple(range(packet_len_1) + range(packet_len_2))) tags = [gr.tag_to_python(x) for x in sink.tags()] tags = sorted([(x.offset, x.key, x.value) for x in tags]) tags_expected = [ (0, 'length', packet_len_1 + packet_len_2), (0, 'spam', 'eggs'), ] self.assertEqual(tags, tags_expected)
def test_003_filter_delay_two_inputs(self): # give two different inputs tb = self.tb sampling_freq = 100 ntaps = 51 N = int(ntaps + sampling_freq * 0.10) data1 = sin_source_f(sampling_freq, sampling_freq * 0.10, 1.0, N) data2 = cos_source_f(sampling_freq, sampling_freq * 0.10, 1.0, N) src1 = blocks.vector_source_f(data1) src2 = blocks.vector_source_f(data2) taps = filter.firdes.hilbert(ntaps, filter.firdes.WIN_HAMMING) hd = filter.filter_delay_fc(taps) expected_result = fir_filter2(data1, data2, taps, (ntaps-1)/2) dst2 = blocks.vector_sink_c() tb.connect(src1, (hd,0)) tb.connect(src2, (hd,1)) tb.connect(hd, dst2) tb.run() # get output result_data = dst2.data() self.assertComplexTuplesAlmostEqual(expected_result, result_data, 5)
def help_stream_tag_propagation(self, N, stream_sizes): src_data1 = stream_sizes[0]*N*[1,] src_data2 = stream_sizes[1]*N*[2,] src_data3 = stream_sizes[2]*N*[3,] # stream_mux scheme (3,2,4) src1 = blocks.vector_source_f(src_data1) src2 = blocks.vector_source_f(src_data2) src3 = blocks.vector_source_f(src_data3) tag_stream1 = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, stream_sizes[0], 'src1') tag_stream2 = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, stream_sizes[1], 'src2') tag_stream3 = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, stream_sizes[2], 'src3') mux = blocks.stream_mux(gr.sizeof_float, stream_sizes) dst = blocks.vector_sink_f() self.tb.connect(src1, tag_stream1) self.tb.connect(src2, tag_stream2) self.tb.connect(src3, tag_stream3) self.tb.connect(tag_stream1, (mux,0)) self.tb.connect(tag_stream2, (mux,1)) self.tb.connect(tag_stream3, (mux,2)) self.tb.connect(mux, dst) self.tb.run() return (dst.data (), dst.tags ())
def test_001(self): tb = self.tb src1_data = (0,0.2,-0.3,0,12,0) src2_data = (0,0.0,3.0,0,10,0) src3_data = (0,0.0,3.0,0,1,0) src1 = blocks.vector_source_f(src1_data) s2v1 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src1, s2v1) src2 = blocks.vector_source_f(src2_data) s2v2 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src2, s2v2) src3 = blocks.vector_source_f(src3_data) s2v3 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src3, s2v3) dst1 = blocks.vector_sink_s() dst2 = blocks.vector_sink_s() argmax = blocks.argmax_fs(len(src1_data)) tb.connect(s2v1, (argmax, 0)) tb.connect(s2v2, (argmax, 1)) tb.connect(s2v3, (argmax, 2)) tb.connect((argmax,0), dst1) tb.connect((argmax,1), dst2) tb.run() index = dst1.data() source = dst2.data() self.assertEqual(index, (4,)) self.assertEqual(source, (0,))
def test_003_square3_ff(self): src_data0 = (0, 1, 0, 1, 0) src_data1 = (-3.0, 4.0, -5.5, 2.0, 3.0) src_data2 = (2.0, 2.0, 2.0, 2.0, 2.0) src_data3 = (2.7, 2.7, 2.1, 2.3, 2.5) expected_result0 = (-3.0, 2.0, -5.5, 2.0, 3.0) expected_result1 = (-3.0, 2.7, -5.5, 2.3, 3.0) src0 = blocks.vector_source_f(src_data0) src1 = blocks.vector_source_f(src_data1) src2 = blocks.vector_source_f(src_data2) src3 = blocks.vector_source_f(src_data3) sqr = square3_ff() dst0 = blocks.vector_sink_f() dst1 = blocks.vector_sink_f() self.tb.connect(src0, (sqr, 0)) self.tb.connect(src1, (sqr, 1)) self.tb.connect(src2, (sqr, 2)) self.tb.connect(src3, (sqr, 3)) self.tb.connect((sqr, 0), dst0) self.tb.connect((sqr, 1), dst1) self.tb.run() result_data0 = dst0.data() result_data1 = dst1.data() from pudb import set_trace set_trace() self.assertFloatTuplesAlmostEqual(expected_result0, result_data0, 6) self.assertFloatTuplesAlmostEqual(expected_result1, result_data1, 6)
def test_001_t (self): M = 4 mu = 0.02 s = [ 0.0, 0.3090170, 0.5877853, 0.8090170, 0.9510565, 1.0, 0.9510565, 0.8090170, 0.5877853, 0.3090170, 1.225E-16, -0.3090170, -0.5877853, -0.8090170, -0.9510565, -1.0, -0.9510565, -0.8090170, -0.5877853, -0.3090170, -2.449E-16 ] x = [ 0.1869771, 0.3164567, 0.5817531, 0.7321207, 0.9280425, 0.9442921, 0.7227481, 0.7236329, 0.4502919, 0.4182683, 0.1211515, -0.3072967, -0.6598651, -0.5849396, -0.8081715, -1.0660516, -0.9508943, -0.7868964, -0.4899220, -0.3765086, 0.0794150 ] y_expected = [ 0.0, 0.0, 0.0030070, 0.0198613, 0.0684855, 0.1548310, 0.2389200, 0.3069399, 0.3028421, 0.2665137, 0.1899010, 0.0551109, -0.0944788, -0.2088661, -0.3248339, -0.4673856, -0.5688788, -0.6141125, -0.5422770, -0.4194642, -0.2149493 ] x_src = blocks.vector_source_f(x, False) s_src = blocks.vector_source_f(s, False) eq_lms = eq.eq_lms_ff(M, mu, False) dst = blocks.vector_sink_f() self.tb.connect((x_src, 0), (eq_lms, 0)) self.tb.connect((s_src, 0), (eq_lms, 1)) self.tb.connect((eq_lms, 0), (dst, 0)) self.tb.run () y = dst.data() self.assertFloatTuplesAlmostEqual(y_expected, y, 6)
def test_preserve_tag_head_pos(self): """ Test the 'preserve head position' function. This will add a 'special' tag to item 0 on stream 1. It should be on item 0 of the output stream. """ packet_len_0 = 5 data0 = range(packet_len_0) packet_len_1 = 3 data1 = range(packet_len_1) mux = blocks.tagged_stream_mux( gr.sizeof_float, self.tsb_key, 1 # Mark port 1 as carrying special tags on the head position ) sink = blocks.tsb_vector_sink_f(tsb_key=self.tsb_key) self.tb.connect( blocks.vector_source_f(data0), blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_0, self.tsb_key), (mux, 0) ) self.tb.connect( blocks.vector_source_f(range(packet_len_1), tags=(make_tag('spam', 'eggs', 0),)), blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_1, self.tsb_key), (mux, 1) ) self.tb.connect(mux, sink) self.tb.run() self.assertEqual(len(sink.data()), 1) self.assertEqual(sink.data()[0], tuple(data0 + data1)) self.assertEqual(len(sink.tags()), 1) tag = gr.tag_to_python(sink.tags()[0]) tag = (tag.offset, tag.key, tag.value) tag_expected = (0, 'spam', 'eggs') self.assertEqual(tag, tag_expected)
def test_int_002 (self): blksize = 4 lenx = 64 plusup_big = lambda a: a + (blksize * 4) plusup_little = lambda a: a + blksize a_vec = range(0,blksize) for i in range(0,(lenx/(4 * blksize)) - 1): a_vec += map(plusup_big, a_vec[len(a_vec) - blksize:]) b_vec = map(plusup_little, a_vec) c_vec = map(plusup_little, b_vec) d_vec = map(plusup_little, c_vec) src0 = blocks.vector_source_f (a_vec) src1 = blocks.vector_source_f (b_vec) src2 = blocks.vector_source_f (c_vec) src3 = blocks.vector_source_f (d_vec) op = blocks.interleave (gr.sizeof_float, blksize) dst = blocks.vector_sink_f () self.tb.connect (src0, (op, 0)) self.tb.connect (src1, (op, 1)) self.tb.connect (src2, (op, 2)) self.tb.connect (src3, (op, 3)) self.tb.connect (op, dst) self.tb.run () expected_result = tuple (range (lenx)) result_data = dst.data () self.assertFloatTuplesAlmostEqual (expected_result, result_data)
def __init__(self): gr.top_block.__init__(self) self.qapp = QtGui.QApplication(sys.argv) data0 = 10*[0,] + 40*[1,0] + 10*[0,] data0 += 10*[0,] + 40*[0,1] + 10*[0,] data1 = 20*[0,] + [0,0,0,1,1,1,0,0,0,0] + 70*[0,] # Adjust these to change the layout of the plot. # Can be set to fractions. ncols = 100.25 nrows = 100 fs = 200 src0 = blocks.vector_source_f(data0, True) src1 = blocks.vector_source_f(data1, True) thr = blocks.throttle(gr.sizeof_float, 50000) hed = blocks.head(gr.sizeof_float, 10000000) self.snk1 = qtgui.time_raster_sink_f(fs, nrows, ncols, [], [], "Float Time Raster Example", 2) self.connect(src0, thr, (self.snk1, 0)) self.connect(src1, (self.snk1, 1)) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) self.main_box = dialog_box(pyWin) self.main_box.show()
def test_stretch_01(self): tb = self.tb data = 10*[1,] data0 = map(lambda x: x/20.0, data) data1 = map(lambda x: x/10.0, data) expected_result0 = 10*[0.05,] expected_result1 = 10*[0.1,] src0 = blocks.vector_source_f(data0, False) src1 = blocks.vector_source_f(data1, False) inter = blocks.streams_to_vector(gr.sizeof_float, 2) op = blocks.stretch_ff(0.1, 2) deinter = blocks.vector_to_streams(gr.sizeof_float, 2) dst0 = blocks.vector_sink_f() dst1 = blocks.vector_sink_f() tb.connect(src0, (inter,0)) tb.connect(src1, (inter,1)) tb.connect(inter, op) tb.connect(op, deinter) tb.connect((deinter,0), dst0) tb.connect((deinter,1), dst1) tb.run() dst0_data = dst0.data() dst1_data = dst1.data() self.assertFloatTuplesAlmostEqual(expected_result0, dst0_data, 4) self.assertFloatTuplesAlmostEqual(expected_result1, dst1_data, 4)
def test_001_t (self): src_data0 = (20,121,210,11,110) src_data1 = (-3.0, 4.0, -5.5, 2.0, 3.0) src_data2 = (2.0, 2.0, 2.0, 2.0, 2.0) src_data3 = (2.7, 2.7, 2.1, 2.3, 2.5) expected_result0 = (-3.0, 2.0, 2.0, 2.0, 2.0) expected_result1 = (-3.0, 2.7, 2.1, 2.0, 2.5) src0 = blocks.vector_source_f (src_data0) src1 = blocks.vector_source_f (src_data1) src2 = blocks.vector_source_f (src_data2) src3 = blocks.vector_source_f (src_data3) switch = FM_stereo_mono_switch (75.0) dst0 = blocks.vector_sink_f () dst1 = blocks.vector_sink_f () self.tb.connect (src0, (switch,0)) self.tb.connect (src1,(switch,1)) self.tb.connect (src2,(switch,2)) self.tb.connect (src3,(switch,3)) self.tb.connect ((switch,0), dst0) self.tb.connect ((switch,1), dst1) self.tb.run () result_data0 = dst0.data () result_data1 = dst1.data () #from pudb import set_trace; set_trace() self.assertFloatTuplesAlmostEqual (expected_result0, result_data0, 6) self.assertFloatTuplesAlmostEqual (expected_result1, result_data1, 6)
def test_002_t (self): #This tests multiple streams, to make sure it outputs the same input from before numstreams=3 src_data0=(1.0,2.0,3.0) src_data1=(4.0,5.0,6.0) src_data2=(7.0,8.0,9.0) expected_result0=(1.0,2.0,3.0) src0 = blocks.vector_source_f(src_data0) src1 = blocks.vector_source_f(src_data1) src2 = blocks.vector_source_f(src_data2) blk = testblocks.streams_to_streams_ff(numstreams) dst0 = blocks.vector_sink_f() dst1 = blocks.vector_sink_f() dst2 = blocks.vector_sink_f() self.tb.connect(src0, (blk,0) ) self.tb.connect(src1, (blk,1) ) self.tb.connect(src2, (blk,2) ) self.tb.connect((blk,0), dst0) self.tb.connect((blk,1), dst1) self.tb.connect((blk,2), dst2) self.tb.run() result_data0 = dst0.data() result_data1 = dst1.data() result_data2 = dst2.data() # check data print result_data0 self.assertFloatTuplesAlmostEqual(expected_result0, result_data0, 6)
def test_add_f32(self): tb = gr.top_block() src0 = blocks.vector_source_f([1, 3, 5, 7, 9], False) src1 = blocks.vector_source_f([0, 2, 4, 6, 8], False) adder = add_2_f32_1_f32() sink = blocks.vector_sink_f() tb.connect((src0, 0), (adder, 0)) tb.connect((src1, 0), (adder, 1)) tb.connect(adder, sink) tb.run() self.assertEqual(sink.data(), (1, 5, 9, 13, 17))
def test_largeN_ff(self): stream_sizes = [3, 8191] r1 = (1,) * stream_sizes[0] r2 = (2,) * stream_sizes[1] v0 = blocks.vector_source_f(r1, repeat=False) v1 = blocks.vector_source_f(r2, repeat=False) mux = blocks.stream_mux(gr.sizeof_float, stream_sizes) dst = blocks.vector_sink_f () self.tb.connect (v0, (mux,0)) self.tb.connect (v1, (mux,1)) self.tb.connect (mux, dst) self.tb.run () self.assertEqual (r1 + r2, dst.data())
def test_float_to_complex_2(self): src1_data = (1.0, 3.0, 5.0, 7.0, 9.0) src2_data = (2.0, 4.0, 6.0, 8.0, 10.0) expected_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j) src1 = blocks.vector_source_f(src1_data) src2 = blocks.vector_source_f(src2_data) op = blocks.float_to_complex() dst = blocks.vector_sink_c() self.tb.connect(src1, (op, 0)) self.tb.connect(src2, (op, 1)) self.tb.connect(op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def help_stream_2ff(self, N, stream_sizes): v0 = blocks.vector_source_f(N*[1,], False) v1 = blocks.vector_source_f(N*[2,], False) mux = blocks.stream_mux(gr.sizeof_float, stream_sizes) dst = blocks.vector_sink_f () self.tb.connect (v0, (mux,0)) self.tb.connect (v1, (mux,1)) self.tb.connect (mux, dst) self.tb.run () return dst.data ()
def setUp (self): self.tb = gr.top_block() self.dut = prioritizer(False) self.src0 = blocks.vector_source_f([0.0], repeat = True) self.src1 = blocks.vector_source_f([1.0], repeat = True) self.throttle0 = blocks.throttle(gr.sizeof_float, 1e6) self.throttle1 = blocks.throttle(gr.sizeof_float, 1e4) ## 1/100 of the 0 rate self.head = blocks.head(gr.sizeof_float, int(1e4)) # about one second self.sink = blocks.vector_sink_f() self.tb.connect(self.src0, self.throttle0) self.tb.connect(self.src1, self.throttle1) self.tb.connect(self.throttle0, (self.dut,0)) self.tb.connect(self.throttle1, (self.dut,1)) self.tb.connect(self.dut, self. head, self.sink)
def test_001_t (self): # set up fg src = blocks.vector_source_f([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]) src_th = blocks.vector_source_f([0,0,0,1,1,1,1,1,1,1,1,1,1,1,1]) dut = capture_tools.annotate_every_n_samples_from_trigger_ff(3, 2) dst = blocks.vector_sink_f() self.tb.connect(src,(dut, 0)) self.tb.connect(src_th,(dut, 1)) self.tb.connect(dut, dst) self.tb.run () print(dst.data()) print(dst.tags()) for t in dst.tags(): print(t.key) print(t.offset)
def test_001_t (self): test = ieee802154g.preamble_detector(8) # typical preamble cycle, at 8 samples per symbol. num_cycles = 20 data = num_cycles * [-0.098, -0.064, 0.064, 0.093, 0.081, 0.071, 0.069, 0.065, 0.070, 0.037, -0.087, -0.118, -0.105, -0.101, -0.099, -0.095] src = blocks.vector_source_f(data, False) snk = blocks.vector_sink_f() self.tb.connect(src, test, snk) self.tb.run () dst_data = snk.data() # check data assert len(dst_data) == num_cycles * 2 cnt = 0 locked = False pos = False for n in dst_data: if not locked: if n > 0.08: # found peak positive locked = True pos = True elif cnt > 24: assert False, "failed to lock" break else: if pos: assert n < 0 else: assert n > 0 pos = not pos cnt += 1
def test_003_stream(self): print("test_003_stream") nframes = 5 expo = 8 block_size = 2 ** expo num_info_bits = 2 ** (expo - 1) max_list_size = 2 ** (expo - 2) num_frozen_bits = block_size - num_info_bits frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0) frozen_bit_values = np.array([0] * num_frozen_bits,) encoder = PolarEncoder(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) ref = np.array([], dtype=int) data = np.array([], dtype=int) for i in range(nframes): b = np.random.randint(2, size=num_info_bits) d = encoder.encode(b) data = np.append(data, d) ref = np.append(ref, b) gr_data = 2.0 * data - 1.0 polar_decoder = fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) src = blocks.vector_source_f(gr_data, False) dec_block = extended_decoder(polar_decoder, None) snk = blocks.vector_sink_b(1) self.tb.connect(src, dec_block) self.tb.connect(dec_block, snk) self.tb.run() res = np.array(snk.data()).astype(dtype=int) self.assertTupleEqual(tuple(res), tuple(ref))
def test_deint_001 (self): lenx = 64 src = blocks.vector_source_f (range (lenx)) op = blocks.deinterleave (gr.sizeof_float) dst0 = blocks.vector_sink_f () dst1 = blocks.vector_sink_f () dst2 = blocks.vector_sink_f () dst3 = blocks.vector_sink_f () self.tb.connect (src, op) self.tb.connect ((op, 0), dst0) self.tb.connect ((op, 1), dst1) self.tb.connect ((op, 2), dst2) self.tb.connect ((op, 3), dst3) 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 test02(self): # Test float/float version omega = 2 gain_omega = 0.01 mu = 0.5 gain_mu = 0.01 omega_rel_lim = 0.001 self.test = digital.clock_recovery_mm_ff(omega, gain_omega, mu, gain_mu, omega_rel_lim) data = 100*[1,] self.src = blocks.vector_source_f(data, False) self.snk = blocks.vector_sink_f() self.tb.connect(self.src, self.test, self.snk) self.tb.run() expected_result = 100*[0.99972, ] # doesn't quite get to 1.0 dst_data = self.snk.data() # Only compare last Ncmp samples Ncmp = 30 len_e = len(expected_result) len_d = len(dst_data) expected_result = expected_result[len_e - Ncmp:] dst_data = dst_data[len_d - Ncmp:] #print expected_result #print dst_data self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 5)
def test_002_one_vector(self): print("test_002_one_vector") expo = 6 block_size = 2 ** expo num_info_bits = 2 ** (expo - 1) max_list_size = 2 ** (expo - 2) num_frozen_bits = block_size - num_info_bits frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0) frozen_bit_values = np.array([0] * num_frozen_bits,) bits = np.random.randint(2, size=num_info_bits) encoder = PolarEncoder(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) data = encoder.encode(bits) gr_data = 2.0 * data - 1.0 polar_decoder = fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values) src = blocks.vector_source_f(gr_data, False) dec_block = extended_decoder(polar_decoder, None) snk = blocks.vector_sink_b(1) self.tb.connect(src, dec_block) self.tb.connect(dec_block, snk) self.tb.run() res = np.array(snk.data()).astype(dtype=int) print("\ninput -> result -> bits") print(data) print(res) print(bits) self.assertTupleEqual(tuple(res), tuple(bits))
def test_fff_000(self): N = 500 # number of samples to use fs = 5000.0 # baseband sampling rate rrate = 2.3421 # resampling rate nfilts = 32 taps = filter.firdes.low_pass_2(nfilts, nfilts*fs, fs/2, fs/10, attenuation_dB=80, window=filter.firdes.WIN_BLACKMAN_hARRIS) freq = 121.213 data = sig_source_f(fs, freq, 1, N) signal = blocks.vector_source_f(data) pfb = filter.pfb_arb_resampler_fff(rrate, taps, nfilts) snk = blocks.vector_sink_f() self.tb.connect(signal, pfb, snk) self.tb.run() Ntest = 50 L = len(snk.data()) # Get group delay and estimate of phase offset from the filter itself. delay = pfb.group_delay() phase = pfb.phase_offset(freq, fs) # Create a timeline offset by the filter's group delay t = map(lambda x: float(x)/(fs*rrate), xrange(delay, L+delay)) # Data of the sinusoid at frequency freq with the delay and phase offset. expected_data = map(lambda x: math.sin(2.*math.pi*freq*x+phase), t) dst_data = snk.data() self.assertFloatTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 2)
def test_001_t (self): count = 2 interval = 1000 msg_list = [pmt.string_to_symbol('hello')] * count src_data = [1.0] * (count * interval) src = blocks.vector_source_f(src_data, False) msg_gen = message_generator(msg_list, interval) msg_cons = varicode_enc_b() dest = blocks.vector_sink_b() self.tb.connect(src, msg_gen) self.tb.connect(msg_cons, dest) self.tb.msg_connect(msg_gen, 'out_port', msg_cons, 'in_port') self.tb.run() print "Msg Ctr:", msg_gen.msg_ctr while msg_gen.msg_ctr < count: print "Msg Ctr:", msg_gen.msg_ctr time.sleep(0.5) print "Msg Ctr:", msg_gen.msg_ctr self.tb.stop() self.tb.wait() print 'Output Data:', dest.data()
def test_fir_filter_fff_001(self): src_data = 40*[1, 2, 3, 4] expected_data = (0.5, 1.5, 3.0, 5.0, 5.5, 6.5, 8.0, 10.0, 10.5, 11.5, 13.0, 15.0, 15.5, 16.5, 18.0, 20.0, 20.5, 21.5, 23.0, 25.0, 25.5, 26.5, 28.0, 30.0, 30.5, 31.5, 33.0, 35.0, 35.5, 36.5, 38.0, 40.0, 40.5, 41.5, 43.0, 45.0, 45.5, 46.5, 48.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0) src = blocks.vector_source_f(src_data) op = filter.fir_filter_fff(1, 20*[0.5, 0.5]) dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_data, result_data, 5)
def test_003_t (self): vec_len = 3 my_select = 2 src_data = (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,1.0,10.0,100.0) expected_result = (3.0,6.0,9.0,100.0) src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, vec_len) blk = testblocks.vec_select(vec_len, my_select) dst = blocks.vector_sink_f() blk.set_select(3) self.tb.connect(src, s2v) self.tb.connect(s2v, blk) self.tb.connect(blk, dst) self.tb.run() result_data = dst.data() print "T3 Source: " print str(src_data).strip('[]') print "T3 Expected Results: " print str(expected_result).strip('[]') print "T3 Results: " print str(result_data).strip('[]') self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_file_descriptor(self): src_data = range(1000) expected_result = range(1000) snk2 = blocks.vector_sink_f() with tempfile.NamedTemporaryFile() as temp: fhandle0 = open(temp.name, "wb") fd0 = fhandle0.fileno() src = blocks.vector_source_f(src_data) snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0) self.tb.connect(src, snk) self.tb.run() os.fsync(fd0) fhandle0.close() fhandle1 = open(temp.name, "rb") fd1 = fhandle1.fileno() src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False) self.tb.disconnect(src, snk) self.tb.connect(src2, snk2) self.tb.run() os.fsync(fd1) fhandle1.close() result_data = snk2.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data) self.assertEqual(len(snk2.tags()), 0)
def test_001_t(self): # data self.vector_length = 10 self.data = (0, 2, 4, 6, 8, 10, 12, 14, 16, 18) self.expected = (2) # blocks self.src = blocks.vector_source_f(self.data, False, self.vector_length) self.slope = xcorr.linearslope_ff(self.vector_length) self.snk = blocks.vector_sink_f() # connections self.tb.connect(self.src, self.slope, self.snk) self.tb.run() # check data self.result = self.snk.data() self.assertAlmostEqual(self.expected, self.result[0], 3)
def test_001 (self): vlen = 10 self.rx_data = None src_data = list(range(vlen))*100 src = blocks.vector_source_f(src_data, False, vlen) zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0") address = zeromq_pub_sink.last_endpoint() self.tb.connect(src, zeromq_pub_sink) self.probe_manager = zeromq.probe_manager() self.probe_manager.add_socket(address, 'float32', self.recv_data) zmq_pull_t = threading.Thread(target=self.probe_manager.watcher) zmq_pull_t.daemon = True zmq_pull_t.start() self.tb.run() zmq_pull_t.join(6.0) # Check to see if we timed out self.assertFalse(zmq_pull_t.is_alive()) self.assertFloatTuplesAlmostEqual(self.rx_data, src_data)
def test_deinterleave(self): tb = self.tb # set up fg cols, rows = 4, 10 vec = sum((rows * [x,] for x in range(cols)), []) expected = rows * list(range(cols)) src = blocks.vector_source_f(vec, False) itlv = matrix_interleaver(gr.sizeof_float, rows=rows, cols=cols, deint=True) snk = blocks.vector_sink_f() tb.connect(src, itlv, snk) tb.run() result = snk.data() # check data self.assertFloatTuplesAlmostEqual(expected, result)
def test_largeN_ff(self): stream_sizes = [3, 8191] r0 = [ 1.0, ] * stream_sizes[0] r1 = [ 2.0, ] * stream_sizes[1] v = blocks.vector_source_f(r0 + r1, repeat=False) demux = blocks.stream_demux(gr.sizeof_float, stream_sizes) dst0 = blocks.vector_sink_f() dst1 = blocks.vector_sink_f() self.tb.connect(v, demux) self.tb.connect((demux, 0), dst0) self.tb.connect((demux, 1), dst1) self.tb.run() self.assertEqual(r0, dst0.data()) self.assertEqual(r1, dst1.data())
def help_stream_2ff(self, N, stream_sizes): v = blocks.vector_source_f(N * [ 1, ] + N * [ 2, ], False) demux = blocks.stream_demux(gr.sizeof_float, stream_sizes) dst0 = blocks.vector_sink_f() dst1 = blocks.vector_sink_f() self.tb.connect(v, demux) self.tb.connect((demux, 0), dst0) self.tb.connect((demux, 1), dst1) self.tb.run() return (dst0.data(), dst1.data())
def test_fff(self): taps = [1, 10, 100, 1000, 10000] src_data = (0, 2, 3, 5, 7, 11, 13, 17) interpolation = 3 xr = (0, 0, 0, 2, 20, 200, 2003, 20030, 300, 3005, 30050, 500, 5007, 50070, 700, 7011, 70110, 1100, 11013, 110130, 1300, 13017, 130170) expected_result = tuple([float(x) for x in xr]) src = blocks.vector_source_f(src_data) op = filter.interp_fir_filter_fff(interpolation, taps) dst = blocks.vector_sink_f() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() result_data = dst.data() L = min(len(result_data), len(expected_result)) self.assertEqual(expected_result[0:L], result_data[0:L])
def test_001_t(self): """ test 256 bit packet """ # set up fg data_in = range(256) # np.random.randint(0, 2, size=256) key = pmt.intern("len_tag") val = pmt.from_long(256) tag = gr.tag_utils.python_to_tag((0, key, val)) self.src = blocks.vector_source_f(data_in, False, 1, [tag]) self.deintlvr = lpwan.dsss_deinterleaver_ff("len_tag") self.snk = blocks.vector_sink_f(1) self.tb.connect(self.src, self.deintlvr, self.snk) self.tb.run() # check data self.assertFloatTuplesAlmostEqual(dsss_const.intlvr_seq_256, self.snk.data()[0:256])
def test_002(self): self.maxDiff = None tb = gr.top_block() src = blocks.vector_source_f(list(range(0, 100))) km = [] snk = [] for i in range(5): km.append(streamops.keep_m_in_n(3, 5, i)) snk.append(blocks.vector_sink_f()) tb.connect((src, km[i], snk[i])) tb.run() for i in range(5): self.assertEqual( sorted( list(range(i, 100, 5)) + list(range((i + 1) % 5, 100, 5)) + list(range((i + 2) % 5, 100, 5))), list(snk[i].data()))
def test_002_(self): src_data = numpy.array( [-1.0, -1.0 / 2.0, -1.0 / 3.0, -1.0 / 4.0, -1.0 / 5.0]) trg_data = copy.deepcopy(src_data) src = blocks.vector_source_f(src_data, False, len(src_data)) st = blocks.stretch_ff(-1.0 / 5.0, len(src_data)) dst = blocks.vector_sink_f(len(src_data)) self.tb.connect(src, st) self.tb.connect(st, dst) self.tb.run() rsl_data = dst.data() sum = 0 for (u, v) in zip(trg_data, rsl_data): w = u - v sum += w * w sum /= float(len(trg_data)) assert sum < 1e-6
def test_002_t(self): # set up fg trig_data = (0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1) dataforw = (1, 2, 3, 4, 5) databack = (5, 4, 3, 2, 1) expected_result = (0, 0, -1, -2, -3, -4, -5, 0, 1, 2, 3, 4, 1) trig_src = blocks.vector_source_f(trig_data) triggeredvecsrc = Maran.triggered_vector_source(databack, -1, 2, 2) testdata = triggeredvecsrc.data() self.assertFloatTuplesAlmostEqual(databack, testdata, 0) triggeredvecsrc.set_data(dataforw) testdata = triggeredvecsrc.data() self.assertFloatTuplesAlmostEqual(dataforw, testdata, 0) dst = blocks.vector_sink_c() self.tb.connect(trig_src, triggeredvecsrc, dst) self.tb.run() result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data, 0)
def test_001_t(self): # data self.vector_length = 5 self.data = (1.1, 2.1, 3.1, 4.1, 5.1) self.expected = (1.1, 2.1, 3.1, 4.1, 5.1) # blocks self.src = blocks.vector_source_f(self.data) self.hold = doa.hold_ff(False) self.snk = blocks.vector_sink_f() # connections self.tb.connect(self.src, self.hold, self.snk) self.tb.run() # check data self.results = self.snk.data() self.assertFloatTuplesAlmostEqual(self.expected, self.results, 3)
def test_002_t(self): # data self.vector_length = 5 self.data = (1.2, 2.2, 3.2, 4.2, 5.2) self.expected = (0, 0, 0, 0, 0) # blocks self.src = blocks.vector_source_f(self.data) self.hold = doa.hold_ff(True) self.snk = blocks.vector_sink_f() # connections self.tb.connect(self.src, self.hold, self.snk) self.tb.run() # check data self.results = self.snk.data() self.assertFloatTuplesAlmostEqual(self.expected, self.results)
def test_001_t(self): # set up fg senal_entrante = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20) src = blocks.vector_source_f(senal_entrante) diez = diezma_ff(4) snk = blocks.vector_sink_f() self.tb.connect(src, diez) self.tb.connect(diez, snk) # Aqui va lo que querramos incluir para probar y encontrar fallas, como prints. self.tb.run() senal_salida = snk.data() salida_esperada = (1, 5, 9, 13, 17) print("la respuesta; ", senal_salida) print("la esperada; ", salida_esperada) self.assertFloatTuplesAlmostEqual(salida_esperada, senal_salida, 6)
def test_001_t(self): # data self.data = (3.0000, -3.0000, 1.1000, -1.1000, 0) self.expected = (-1.2694, 1.2694, -0.3577, 0.3577, 0) # blocks self.src = blocks.vector_source_f(self.data) self.p2d = xcorr.phase2xcorr_ff(.5) self.snk = blocks.vector_sink_f() # connections self.tb.connect(self.src, self.p2d) self.tb.connect(self.p2d, self.snk) self.tb.run() # check data self.results = self.snk.data() self.assertFloatTuplesAlmostEqual(self.expected, self.results, 3)
def test_001_interp(self): taps = [1, 10, 100, 1000, 10000] src_data = (0, 2, 3, 5, 7, 11, 13, 17) interpolation = 3 xr = (2, 20, 200, 2003, 20030, 300, 3005, 30050, 500, 5007, 50070, 700, 7011, 70110, 1100, 11013, 110130, 1300, 13017, 130170, 1700.0, 17000.0, 170000.0, 0.0) expected_result = tuple([float(x) for x in xr]) tb = gr.top_block() src = blocks.vector_source_f(src_data) op = filter.rational_resampler_base_fff(interpolation, 1, taps) dst = blocks.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def test_f_000(self): # Test normal operation of the float puncture block self.puncsize = 8 self.puncpat = 0xEF self.delay = 0 self.puncture_setup() src = blocks.vector_source_f(self.src_data) op = fec.puncture_ff(self.puncsize, self.puncpat, self.delay) dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() dst_data = list(dst.data()) self.assertEqual(self.expected, dst_data)
def test_001(self): src_data = 10 * [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2, 1] ctrl_data = 10 * [1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] expected_result = 10 * (0, 0, 0, 0, 4, 5, 6, 7, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9) src = blocks.vector_source_f(src_data) ctrl = blocks.vector_source_b(ctrl_data) op = blocks.sample_and_hold_ff() dst = blocks.vector_sink_f() self.tb.connect(src, (op, 0)) self.tb.connect(ctrl, (op, 1)) self.tb.connect(op, dst) self.tb.run() result = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result, places=6)
def test_001_t(self): packet_len = 4 data = list(range(2 * packet_len)) tag = gr.tag_t() tag.key = pmt.intern("foo") tag.offset = 5 tag.value = pmt.intern("bar") src = blocks.vector_source_f(data, tags=(tag, )) sink = blocks.tsb_vector_sink_f(tsb_key=self.tsb_key) self.tb.connect( src, blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len, self.tsb_key), sink) self.tb.run() self.assertEqual((tuple(data[0:packet_len]), tuple(data[packet_len:])), sink.data()) self.assertEqual(len(sink.tags()), 1) self.assertEqual(sink.tags()[0].offset, tag.offset)
def test_002_correct_individual_phase_offset_vff(self): data = [x * pi / 2 + pi / 4 for x in [1, -2, -1, 0, 1, -2]] src_data = map(lambda x, y: x + y, data, [0.1, 0.3, -0.4, 0.2, 0.4, 0.1]) expected_result = map(lambda x, y: x + y, data, [0.05, 0.15, -0.2, 0.075, 0.125, 0.15]) src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, 3) mut = grdab.correct_individual_phase_offset_vff(3, 0.5) v2s = blocks.vector_to_stream(gr.sizeof_float, 3) dst = blocks.vector_sink_f() self.tb.connect(src, s2v, mut, v2s, dst) self.tb.run() result_data = dst.data() # print src_data # print expected_result # print result_data self.assertFloatTuplesAlmostEqual(expected_result, result_data, 5)
def test_003_(self): src_grid = (0.0, 1.0, 2.0, 3.0, 4.0) trg_grid = copy.deepcopy(src_grid) src_data = (0.0, 1.0, 0.0, 1.0, 0.0) src = blocks.vector_source_f(src_data, False, len(src_grid)) sq = wavelet.squash_ff(src_grid, trg_grid) dst = blocks.vector_sink_f(len(trg_grid)) self.tb.connect(src, sq) self.tb.connect(sq, dst) self.tb.run() rsl_data = dst.data() sum = 0 for (u, v) in zip(src_data, rsl_data): w = u - v sum += w * w sum /= float(len(src_data)) assert sum < 1e-6
def test_001(self): nsamples = 100000 input_data = list(range(nsamples)) src = blocks.vector_source_f(input_data, False) hblock = hwrap() snk1 = blocks.vector_sink_f() snk2 = blocks.vector_sink_f() self.tb.connect(src, 0, hblock, 0) self.tb.connect(hblock, 0, snk1, 0) self.tb.connect(src, 0, hblock, 0) self.tb.connect(hblock, 1, snk2, 0) self.tb.run() self.assertEqual(input_data, snk1.data()) self.assertEqual(input_data, snk2.data())
def test_01(self): tb = self.tb data = [0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2] expected_result = [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1] src = blocks.vector_source_f(data, False) op = blocks.threshold_ff(1, 1) dst = blocks.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() dst_data = dst.data() self.assertEqual(expected_result, dst_data)
def test_pwr_squelch_004(self): alpha = 0.0001 thr = -25 src_data = map(lambda x: float(x)/10.0, range(1, 40)) src = blocks.vector_source_f(src_data) op = analog.pwr_squelch_ff(thr, alpha) dst = blocks.vector_sink_f() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() expected_result = src_data expected_result[0:20] = 20*[0,] result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data, 4)
def test_001_t(self): src_data = [ 1, ] * 50 packet_len = 10 len_tag_key = 'packet_len' src = blocks.vector_source_f(src_data, False, 1) tagger = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len, len_tag_key) sink = blocks.vector_sink_f() self.tb.connect(src, tagger, sink) self.tb.run() self.assertEqual(sink.data(), src_data) tags = [gr.tag_to_python(x) for x in sink.tags()] tags = sorted([(x.offset, x.key, x.value) for x in tags]) expected_tags = [(int(pos), 'packet_len', packet_len) for pos in range(0, 50, 10)] self.assertEqual(tags, expected_tags)
def __init__(self): if choice == 1: self.num = 0 self.g = 3 self.p = 5 self.x = 4 if choice == 2: self.num = 0 self.g = 5 self.p = 7 self.x = 5 num = pow(self.g, self.x) % self.p print("g^x mod p=%d") % num gr.top_block.__init__(self, "Top Block") self.vector = blocks.vector_source_f((num, num, num), True, 1, []) self.packet = grc_blks2.packet_mod_f(grc_blks2.packet_encoder( samples_per_symbol=2, bits_per_symbol=1, preamble="", access_code="", pad_for_usrp=True), payload_length=256) self.mod = digital.gmsk_mod(samples_per_symbol=2, bt=0.35, verbose=False, log=False) self.sender = osmosdr.sink(args="numchan" + str(1) + "" + "") self.sender.set_sample_rate(1e6) self.sender.set_center_freq(100e6) self.sender.set_freq_corr(0, 0) self.sender.set_gain_mode(False, 0) self.sender.set_gain(20, 0) self.sender.set_if_gain(30, 0) self.sender.set_bb_gain(30, 0) self.sender.set_antenna("", 0) self.sender.set_bandwidth(0, 0) #connection self.connect((self.vector, 0), (self.packet, 0)) self.connect((self.packet, 0), (self.mod, 0)) self.connect((self.mod, 0), (self.sender, 0))
def test_002_t(self): self.vector_len = 2**12 self.num_max_vals = 5 # generate vector from octave oc = oct2py.Oct2Py() oc.addpath(os.path.dirname(__file__)) data, expected_pks, expected_t_pks = oc.test002_findpeaks( self.num_max_vals, self.vector_len) data = data.flatten().tolist() ################################################## # Blocks ################################################## self.blocks_vector_source_x_0 = blocks.vector_source_f( data, False, self.vector_len, []) self.doa_find_local_max_0 = doa.find_local_max(self.num_max_vals, self.vector_len, 0.0, 2 * numpy.pi) self.blocks_vector_sink_x_0 = blocks.vector_sink_f(self.num_max_vals) self.blocks_vector_sink_x_1 = blocks.vector_sink_f(self.num_max_vals) ################################################## # Connections ################################################## self.tb.connect((self.blocks_vector_source_x_0, 0), (self.doa_find_local_max_0, 0)) self.tb.connect((self.doa_find_local_max_0, 0), (self.blocks_vector_sink_x_0, 0)) self.tb.connect((self.doa_find_local_max_0, 1), (self.blocks_vector_sink_x_1, 0)) # set up fg self.tb.run() # get data from sink measured_pks = self.blocks_vector_sink_x_0.data() measured_pks_locs = self.blocks_vector_sink_x_1.data() # check data for i in range(len(measured_pks)): self.assertAlmostEqual(expected_pks[i], measured_pks[i], 5) and self.assertAlmostEqual( expected_t_pks[i], measured_t_pks[i], 5)
def test_001_t(self): # Setup parameters of the System fsm = fsm_args["awgn1o2_16"] os = numpy.array(fsm[4], dtype=int) data = numpy.array([-5, -5, -5, -5, 5, 5, -5, 5, 5, -5]) expected_data = numpy.array([0, 0, 0, 0, 1, 1, 0, 1, 1, 0]) print data data_src = blocks.vector_source_f(map(float, data)) # Set up TX src_head = blocks.head(gr.sizeof_float * 1, 10) shuffle = numpy.array([ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, ], dtype=int) # Setup RX max_log_map_cel = celec.max_log_map_f(2, 4, 10, 0, -1, shuffle, os) conv = blocks.float_to_char() rx_sink = blocks.vector_sink_f(1) self.tb.connect(data_src, src_head, max_log_map_cel, rx_sink) # set up fg self.tb.run() print rx_sink.data()
def test_peak1(self): #print "\n\nTEST 1" tb = self.tb n = 10 data = ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ) + n * (0, ) expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) + n * (0, ) src = blocks.vector_source_f(data, False) regen = blocks.peak_detector2_fb(7.0, 25, 0.001) dst = blocks.vector_sink_b() tb.connect(src, regen) tb.connect(regen, dst) tb.run() dst_data = dst.data() self.assertEqual(expected_result, dst_data)
def test_002_t (self): # set up fg pi=np.pi data_in = [0, pi/2, pi, -pi/2, pi/2, -pi/2, -pi/2, 0, 0, pi, pi/2, pi/2] data_in = [i + pi/4 for i in data_in] self.src = blocks.vector_source_f(data_in) self.dqpsk = ie802_15_4.dqpsk_mapper_ff(framelen=6, forward=False) self.snk = blocks.vector_sink_f(1) self.tb.connect(self.src, self.dqpsk, self.snk) self.tb.run () # check data data_out = self.snk.data() data_out = [np.exp(1j*i) for i in data_out] ref = [0, pi/2, pi, -pi/2, pi/2, pi, -pi/2, 0, 0, pi, pi, pi/2] ref = [np.exp(1j*i) for i in ref] # print "in:", data_in # print "out:", data_out # print "ref:", ref self.assertComplexTuplesAlmostEqual(ref, data_out, 5)
def test_002_one_vector(self): block_power = 4 block_size = 2 ** block_power num_info_bits = block_size // 2 frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0) bits, gr_data = self.generate_test_data(block_size, num_info_bits, frozen_bit_positions, 1, False) polar_decoder = fec.polar_decoder_sc_systematic.make(block_size, num_info_bits, frozen_bit_positions) src = blocks.vector_source_f(gr_data, False) dec_block = extended_decoder(polar_decoder, None) snk = blocks.vector_sink_b(1) self.tb.connect(src, dec_block) self.tb.connect(dec_block, snk) self.tb.run() res = np.array(snk.data()).astype(dtype=int) self.assertTupleEqual(tuple(res), tuple(bits))