def test_003 (self): stream = [ [float(0)]*10, [float(1)]*10, [float(2)]*10 ] mux = [ 0,2,2,1,1,2,0,2,0,0, 1,0,1,0,1,2,1,2,1,1, 2,0,0,2,1,2,0,1,2,0 ] imux = [] for x in mux: imux.append(int(x)) data = [gr.vector_source_f(stream[0]), gr.vector_source_f(stream[1]), gr.vector_source_f(stream[2])] dst = gr.vector_sink_f() uut = ofdm.static_mux_v(gr.sizeof_float, imux) self.fg.connect(data[0], (uut,0)) self.fg.connect(data[1], (uut,1)) self.fg.connect(data[2], (uut,2)) self.fg.connect(uut,dst) self.fg.run() self.assertEqual(map(float,mux),list(dst.data()))
def test_002_t(self): """ Defined source data for three incoming port For one port src_data0 For N port src_data0,src_data1,src_data2,.......,src_dataN. """ src_data0 = (1,2,3,1) src_data1 = (2,7,3,0) src_data2 = (1,2,2,3) src_data3 = (25,16,4,81) expected_result = (8,20,13,12) src0 = gr.vector_source_f(src_data0) src1 = gr.vector_source_f(src_data1) src2 = gr.vector_source_f(src_data2) src3 = gr.vector_source_f(src_data3) cal_ref = Calculator("(a0*a1)+a2+sqrt(a3)",4) dst = gr.vector_sink_f() self.tb.connect(src0,(cal_ref,0)) self.tb.connect(src1,(cal_ref,1)) self.tb.connect(src2,(cal_ref,2)) self.tb.connect(src3,(cal_ref,3)) self.tb.connect(cal_ref,dst) self.tb.run() result_data = dst.data() print "Result data is : ",result_data self.assertFloatTuplesAlmostEqual(expected_result,result_data,6)
def test_001(self): fg = self.fg 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 = gr.vector_source_f (src1_data) s2v1 = gr.stream_to_vector(gr.sizeof_float, len(src1_data)) fg.connect( src1, s2v1 ) src2 = gr.vector_source_f (src2_data) s2v2 = gr.stream_to_vector(gr.sizeof_float, len(src1_data)) fg.connect( src2, s2v2 ) src3 = gr.vector_source_f (src3_data) s2v3 = gr.stream_to_vector(gr.sizeof_float, len(src1_data)) fg.connect( src3, s2v3 ) dst1 = gr.vector_sink_s () dst2 = gr.vector_sink_s () argmax = gr.argmax_fs (len(src1_data)) fg.connect (s2v1, (argmax, 0)) fg.connect (s2v2, (argmax, 1)) fg.connect (s2v3, (argmax, 2)) fg.connect ((argmax,0), dst1) fg.connect ((argmax,1), dst2) fg.run () index = dst1.data () source = dst2.data () self.assertEqual ( index, (4,)) self.assertEqual ( source, (0,))
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.gr_vector_source_x_0_0 = gr.vector_source_f((40,50,60), True, 1) self.gr_vector_source_x_0 = gr.vector_source_f((4,5,6), True, 1) self.gr_vector_sink_x_0 = gr.vector_sink_f(1) self.gr_sbhs_0 = gr_sbhs.gr_sbhs() self.gr_sbhs_0.set_parameters(1) self.gr_file_sink_0 = gr.file_sink(gr.sizeof_float*1, "ne2.txt") self.gr_file_sink_0.set_unbuffered(True) ################################################## # Connections ################################################## self.connect((self.gr_vector_source_x_0, 0), (self.gr_sbhs_0, 0)) self.connect((self.gr_vector_source_x_0_0, 0), (self.gr_sbhs_0, 1)) self.connect((self.gr_sbhs_0, 0), (self.gr_vector_sink_x_0, 0)) self.connect((self.gr_sbhs_0, 0), (self.gr_file_sink_0, 0))
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 = gr.vector_source_f(data0, False) src1 = gr.vector_source_f(data1, False) inter = gr.streams_to_vector(gr.sizeof_float, 2) op = blocks.stretch_ff(0.1, 2) deinter = gr.vector_to_streams(gr.sizeof_float, 2) dst0 = gr.vector_sink_f() dst1 = gr.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_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 = gr.vector_source_f(A, False, 1) srcB = gr.vector_source_f(B, False, 1) srcC = gr.vector_source_f(C, False, 2) vmap = gr.vector_map(gr.sizeof_int, (1, 1, 2), mapping) dstD = gr.vector_sink_f(2) dstE = gr.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_add_f32(self): tb = gr.top_block() src0 = gr.vector_source_f([1, 3, 5, 7, 9], False) src1 = gr.vector_source_f([0, 2, 4, 6, 8], False) adder = add_2_f32_1_f32() sink = gr.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_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 = gr.vector_source_f(src1_data) src2 = gr.vector_source_f(src2_data) op = blocks_swig.float_to_complex() dst = gr.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 = gr.vector_source_f(N*[1,], False) v1 = gr.vector_source_f(N*[2,], False) mux = gr.stream_mux(gr.sizeof_float, stream_sizes) dst = gr.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 test_002_interp(self): taps = random_floats(31) #src_data = random_floats(10000) # FIXME the 10k case fails! src_data = random_floats(1000) interpolation = 3 expected_result = reference_interp_filter(src_data, interpolation, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(interpolation, 1, taps) dst = gr.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) if False: sys.stderr.write('delta = %2d: ntaps = %d interp = %d ilen = %d\n' % (L2 - L1, len(taps), interpolation, len(src_data))) sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % (len(result_data), len(expected_result))) #self.assertEqual(expected_result[0:L], result_data[0:L]) # FIXME check first 3 answers self.assertEqual(expected_result[3:L], result_data[3:L])
def xtest_004_decim_random_vals(self): MAX_TAPS = 9 MAX_DECIM = 7 OUTPUT_LEN = 9 random.seed(0) # we want reproducibility for ntaps in xrange(1, MAX_TAPS + 1): for decim in xrange(1, MAX_DECIM+1): for ilen in xrange(ntaps + decim, ntaps + OUTPUT_LEN*decim): src_data = random_floats(ilen) taps = random_floats(ntaps) expected_result = reference_dec_filter(src_data, decim, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(1, decim, taps) dst = gr.vector_sink_f() tb.connect(src, op, dst) tb.run() tb = None result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) if False: sys.stderr.write('delta = %2d: ntaps = %d decim = %d ilen = %d\n' % (L2 - L1, ntaps, decim, ilen)) sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % (len(result_data), len(expected_result))) self.assertEqual(expected_result[0:L], result_data[0:L])
def xtest_005_interp_random_vals(self): MAX_TAPS = 9 MAX_INTERP = 7 INPUT_LEN = 9 random.seed(0) # we want reproducibility for ntaps in xrange(1, MAX_TAPS + 1): for interp in xrange(1, MAX_INTERP+1): for ilen in xrange(ntaps, ntaps + INPUT_LEN): src_data = random_floats(ilen) taps = random_floats(ntaps) expected_result = reference_interp_filter(src_data, interp, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(interp, 1, taps) dst = gr.vector_sink_f() tb.connect(src, op, dst) tb.run() tb = None result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) #if True or abs(L1-L2) > 1: if False: sys.stderr.write('delta = %2d: ntaps = %d interp = %d ilen = %d\n' % (L2 - L1, ntaps, interp, ilen)) #sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % # (len(result_data), len(expected_result))) #self.assertEqual(expected_result[0:L], result_data[0:L]) # FIXME check first ntaps+1 answers self.assertEqual(expected_result[ntaps+1:L], result_data[ntaps+1:L])
def transform(self, src_data, rate, freq): src = gr.vector_source_f(src_data, False) dft = gr.goertzel_fc(rate, rate, freq) dst = gr.vector_sink_c() self.tb.connect(src, dft, dst) self.tb.run() return dst.data()
def xtest_fff_003(self): random.seed(0) for i in xrange(25): sys.stderr.write("\n>>> Loop = %d\n" % (i,)) src_len = 4096 src_data = make_random_float_tuple(src_len) ntaps = int(random.uniform(2, 1000)) taps = make_random_float_tuple(ntaps) expected_result = reference_filter_fff(1, taps, src_data) src = gr.vector_source_f(src_data) op = gr.fft_filter_fff(1, taps) dst = gr.vector_sink_f() tb = gr.top_block() tb.connect(src, op, dst) tb.run() result_data = dst.data() #print "src_len =", src_len, " ntaps =", ntaps try: self.assert_fft_float_ok2(expected_result, result_data, abs_eps=1.0) except: expected = open('expected', 'w') for x in expected_result: expected.write(`x` + '\n') actual = open('actual', 'w') for x in result_data: actual.write(`x` + '\n') raise
def test_002(self): udp_rcv = gr.udp_source( gr.sizeof_float, '0.0.0.0', 0, eof=False ) rcv_port = udp_rcv.get_port() udp_snd = gr.udp_sink( gr.sizeof_float, '127.0.0.1', 65500 ) udp_snd.connect( 'localhost', rcv_port ) n_data = 16 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) src = gr.vector_source_f(src_data) dst = gr.vector_sink_f() self.tb_snd.connect( src, udp_snd ) self.tb_rcv.connect( udp_rcv, dst ) self.tb_rcv.start() self.tb_snd.run() udp_snd.disconnect() self.timeout = False q = Timer(3.0,self.stop_rcv) q.start() self.tb_rcv.wait() q.cancel() result_data = dst.data() self.assertEqual(expected_result, result_data) self.assert_(self.timeout) # source ignores EOF?
def test_deint_001 (self): lenx = 64 src0 = gr.vector_source_f (range (lenx)) op = gr.deinterleave (gr.sizeof_float,4) dst0 = gr.vector_sink_f () dst1 = gr.vector_sink_f () dst2 = gr.vector_sink_f () dst3 = gr.vector_sink_f () self.tb.connect (src0, op) op.connect(dst0,usesPortName="float_out_1") op.connect(dst1,usesPortName="float_out_2") op.connect(dst2,usesPortName="float_out_3") op.connect(dst3,usesPortName="float_out_4") 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 src = gr.vector_source_f (range (lenx)) op = gr.deinterleave (gr.sizeof_float) dst0 = gr.vector_sink_f () dst1 = gr.vector_sink_f () dst2 = gr.vector_sink_f () dst3 = gr.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 test_fir_filter_fcc_002(self): self.generate_fcc_source() expected_data = ((-6.94218761055e-05-9.90489479591e-06j), (-2.56973435171e-05+8.05932795629e-05j), (7.01698663761e-05+7.36373840482e-05j), (7.57163215894e-05-4.65324592369e-05j), (-3.01657128148e-05-0.000122838056996j), (-9.53659764491e-05-3.73945695173e-05j), (-2.33501577895e-05+0.000109135726234j), (6.65136758471e-05+0.000125709688291j), (3.08501912514e-05-9.16842873266e-06j), (-2.64703612629e-05-0.000135892929393j), (0.000136643866426-0.000162003751029j), (0.000501801609062-0.000185820827028j), (0.000694551155902-0.000299874518532j), (0.000424396857852-0.00038379128091j), (-9.1786707344e-05-0.000242479465669j), (-0.000337087287335+7.45999423089e-05j), (-0.000116414521472+0.000258556567132j), (0.000215422536712+0.000116706112749j), (0.000224391726078-0.000156330308528j), (-5.96956087975e-05-0.000211163976928j)) src = gr.vector_source_f(self.src_data) op = filter.freq_xlating_fir_filter_fcc(4, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_fir_filter_fcf_001(self): self.generate_fcf_source() expected_data = ((0.000247188087087-0.000157509770361j), (-0.000155229790835-0.000246197130764j), (-0.000264906557277+0.000174603672349j), (6.99016964063e-05+0.000174961372977j), (-5.48477692064e-05-0.0001131295503j), (-0.000237467131228+0.000118011368613j), (0.000136614587973+0.000229531884543j), (0.000229347482673-0.000166581812664j), (-0.000106010869786-0.000150042149471j), (2.92293734674e-05+0.000142060467624j), (0.000228707227507-9.30760797928e-05j), (-0.000124306126963-0.000216641055886j), (-0.000204823678359+0.00016052465071j), (0.00012825592421+0.000133123627165j), (-1.18284006021e-05-0.000159015646204j), (-0.000219973371713+7.5438656495e-05j), (0.000114713984658+0.000205190401175j), (0.000185727752978-0.000154630601173j), (-0.000141745767905-0.000120098840853j), (-3.9850056055e-07+0.000168364742422j)) src = gr.vector_source_f(self.src_data) op = filter.freq_xlating_fir_filter_fcf(1, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_006_interp_decim(self): taps = (0,1,0,0) src_data = range(10000) interp = 3 decimation = 2 expected_result = reference_interp_dec_filter(src_data, interp, decimation, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(interp, decimation, taps) dst = gr.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) if False: sys.stderr.write('delta = %2d: ntaps = %d decim = %d ilen = %d\n' % (L2 - L1, len(taps), decimation, len(src_data))) sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % (len(result_data), len(expected_result))) self.assertEqual(expected_result[1:L], result_data[1:L])
def xtest_004(self): vlen = 4 tune = counter4(self, 1) tune_delay = 1 dwell_delay = 2 msgq = gr.msg_queue() src_data = tuple([float(x) for x in ( 1, 2, 3, 4, 9, 6, 11, 8, 5, 10, 7, 12, 13, 14, 15, 16 )]) expected_results = tuple([float(x) for x in ( 9, 10, 11, 12)]) src = gr.vector_source_f(src_data, False) s2v = gr.stream_to_vector(gr.sizeof_float, vlen) stats = gr.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay) self.tb.connect(src, s2v, stats) self.tb.run() self.assertEqual(1, msgq.count()) for i in range(1): m = parse_msg(msgq.delete_head()) #print "m =", m.center_freq, m.data self.assertEqual(expected_results[vlen*i:vlen*i + vlen], m.data)
def test_001_t (self): src_data = [0]*10 src_data1 = [1]*20 src_data = src_data+src_data1 #expected_result = (-2.0, 0.0, 5.0, 8.0, 9.0, 11.0, 14.0, 18.0) src0 = gr.vector_source_f(src_data) sqr = dsim() sqr.set_parameters(2,0.5,1,.1,10,1) #Preload sqr.input_config(1).preload_items = 1 dst = gr.vector_sink_f() self.tb.connect(src0, (sqr,0)) # src0(vector_source) -> sqr_input_0 self.tb.connect((sqr,0), (sqr,1)) # sqr_output_0 -> sqr_input_1 self.tb.connect(sqr,dst) # sqr_output_0 -> dst (vector_source) self.tb.run() result_data = dst.data() import matplotlib.pyplot as plt plt.plot(result_data) print "result", result_data plt.show()
def test_fir_filter_fcf_002(self): self.generate_fcf_source() expected_data = ((7.3052920925e-05-3.91741014028e-06j), (3.11913172482e-05-0.000109872074972j), (-0.000128646017401-3.49857727997e-05j), (-5.49546712136e-05+8.96326746442e-05j), (5.14321582159e-05+9.64698920143e-05j), (0.000120189361041+2.4231892894e-05j), (0.000100405508419-0.000223224604269j), (-0.000274751859251-2.33274622587e-05j), (1.52600114234e-06+0.000133301247843j), (3.77224641852e-05+5.29596509296e-05j), (-3.60160379387e-06+0.000247975171078j), (0.00113093166146-0.000663110695314j), (0.00059568521101-0.00099650840275j), (-0.000475480686873+0.000250602373853j), (0.000191397906747+0.000271986238658j), (0.000247183139436-0.000157510468853j), (-5.48357638763e-05-0.000113135029096j), (-0.00010601492977-0.00015005269961j), (-0.000204817260965+0.000160534662427j), (0.000114742244477+0.000205190313864j)) src = gr.vector_source_f(self.src_data) op = filter.freq_xlating_fir_filter_fcf(4, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
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_swig.clock_recovery_mm_ff(omega, gain_omega, mu, gain_mu, omega_rel_lim) data = 100 * [1] self.src = gr.vector_source_f(data, False) self.snk = gr.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_fir_filter_fcc_001(self): self.generate_fcc_source() expected_data = ((-0.000337088305969+7.46004516259e-05j), (-5.63409266761e-05+0.000301144464174j), (9.16960561881e-05-2.89259278361e-05j), (-0.000231866899412-6.25764005235e-05j), (-0.000116414688819+0.000258557556663j), (0.000206079319469+5.05045172758e-05j), (-3.85114690289e-05-0.00019276549574j), (-0.000146380873048+0.000112079876999j), (0.000215423395275+0.000116706331028j), (0.000136050162837-0.000232611957472j), (-0.000155499437824-5.41604022146e-05j), (0.000106907449663+0.00016310159117j), (0.000224392410018-0.000156331108883j), (-0.000131131906528-0.000172063446371j), (-5.92393880652e-05+0.00016801241145j), (0.000214921761653-5.32235890205e-06j), (-5.96960526309e-05-0.000211164733628j), (-0.000193948610104+0.000113364716526j), (0.000134820176754+0.000142527525895j), (4.74465123261e-05-0.000175131688593j)) src = gr.vector_source_f(self.src_data) op = filter.freq_xlating_fir_filter_fcc(1, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
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 test_005_(self): src_data = (1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0) dwav = numpy.array(src_data) wvps = numpy.zeros(3) # wavelet power spectrum scl = 1.0/sqr(dwav[0]) k = 1 for e in range(len(wvps)): wvps[e] = scl*sqr(dwav[k:k+(01<<e)]).sum() k += 01<<e src = gr.vector_source_f(src_data, False, len(src_data)) kon = wavelet_swig.wvps_ff(len(src_data)) dst = gr.vector_sink_f(int(math.ceil(math.log(len(src_data), 2)))) self.tb.connect(src, kon) self.tb.connect(kon, dst) self.tb.run() snk_data = dst.data() sum = 0 for (u,v) in zip(snk_data, wvps): w = u - v sum += w * w sum /= float(len(snk_data)) assert sum < 1e-6
def test_001(self): port = 65500 n_data = 16 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) src = gr.vector_source_f(src_data) udp_snd = gr.udp_sink( gr.sizeof_float, 'localhost', port ) self.tb_snd.connect( src, udp_snd ) udp_rcv = gr.udp_source( gr.sizeof_float, 'localhost', port ) dst = gr.vector_sink_f() self.tb_rcv.connect( udp_rcv, dst ) self.tb_rcv.start() self.tb_snd.run() udp_snd.disconnect() self.timeout = False q = Timer(3.0,self.stop_rcv) q.start() self.tb_rcv.wait() q.cancel() result_data = dst.data() self.assertEqual(expected_result, result_data) self.assert_(not self.timeout)
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option("-I", "--audio-input", type="string", default="", help="pcm input device name. E.g., hw:0,0 or /dev/dsp") parser.add_option("-O", "--audio-output", type="string", default="", help="pcm output device name. E.g., hw:0,0 or /dev/dsp") parser.add_option("-r", "--sample-rate", type="eng_float", default=8000, help="set sample rate to RATE (8000)") (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() raise SystemExit, 1 sample_rate = int(options.sample_rate) src = audio.source (sample_rate, options.audio_input) dst = audio.sink (sample_rate, options.audio_output) vec1 = [1, -1] vsource = gr.vector_source_f(vec1, True) multiply = gr.multiply_ff() self.connect(src, (multiply, 0)) self.connect(vsource, (multiply, 1)) self.connect(multiply, dst)
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 = gr.vector_source_f(src_data) op = filter.fir_filter_fff(1, 20*[0.5, 0.5]) dst = gr.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_01(self): tb = self.tb data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) src = gr.vector_source_f(data, False) regen = blocks.peak_detector_fb() dst = gr.vector_sink_b() tb.connect(src, regen) tb.connect(regen, dst) tb.run() dst_data = dst.data() self.assertEqual(expected_result, dst_data)
def add_source(self, signal=None): try: if signal is None: src = gr.message_source(gr.sizeof_float, 1) # queue depth 1, MUST BE 1 self.sources.append(src) self.lengths.append(0) self.is_const.append(False) else: src = gr.vector_source_f(list(signal), True) self.sources.append(src) self.lengths.append(len(signal)) self.is_const.append(True) id = len(self.sources) - 1 self.tb.connect(src, (self.mux, id)) except Exception, ex: print repr(ex) raise RuntimeError, "Could not connect new source to mux"
def test_031_multiple_internal_inputs(self): tb = gr.top_block() src = gr.vector_source_f([ 1.0, ]) hb = gr.hier_block2("hb", gr.io_signature(1, 1, gr.sizeof_float), gr.io_signature(1, 1, gr.sizeof_float)) m1 = gr.multiply_const_ff(1.0) m2 = gr.multiply_const_ff(2.0) add = gr.add_ff() hb.connect(hb, m1) # m1 is connected to hb external input #0 hb.connect(hb, m2) # m2 is also connected to hb external input #0 hb.connect(m1, (add, 0)) hb.connect(m2, (add, 1)) hb.connect(add, hb) # add is connected to hb external output #0 dst = gr.vector_sink_f() tb.connect(src, hb, dst) tb.run() self.assertEquals(dst.data(), (3.0, ))
def xtest_fff_005(self): random.seed(0) for i in xrange(25): sys.stderr.write("\n>>> Loop = %d\n" % (i,)) src_len = 4*1024 src_data = make_random_float_tuple(src_len) ntaps = int(random.uniform(2, 1000)) taps = make_random_float_tuple(ntaps) expected_result = reference_filter_fff(1, taps, src_data) src = gr.vector_source_f(src_data) op = gr.fft_filter_fff(1, taps) dst = gr.vector_sink_f() tb = gr.top_block() tb.connect(src, op, dst) tb.run() result_data = dst.data() self.assert_fft_float_ok2(expected_result, result_data, abs_eps=2.0)
def test_000(self): num_msgs = 10 msg_interval = 1000 msg_list = [] for i in range(num_msgs): msg_list.append(pmt.pmt_from_long(i)) # Create vector source with dummy data to trigger messages src_data = [] for i in range(num_msgs * msg_interval): src_data.append(float(i)) src = gr.vector_source_f(src_data, False) msg_gen = message_generator(msg_list, msg_interval) msg_cons = message_consumer() # Connect vector source to message gen self.tb.connect(src, msg_gen) # Connect message generator to message consumer self.tb.msg_connect(msg_gen, 'out_port', msg_cons, 'in_port') # Verify that the messgae port query functions work self.assertEqual( pmt.pmt_symbol_to_string( pmt.pmt_vector_ref(msg_gen.message_ports_out(), 0)), 'out_port') self.assertEqual( pmt.pmt_symbol_to_string( pmt.pmt_vector_ref(msg_cons.message_ports_in(), 0)), 'in_port') # Run to verify message passing self.tb.start() # Wait for all messages to be sent while msg_gen.msg_ctr < num_msgs: time.sleep(0.5) self.tb.stop() self.tb.wait() # Verify that the message consumer got all the messages self.assertEqual(num_msgs, len(msg_cons.msg_list)) for i in range(num_msgs): self.assertTrue(pmt.pmt_equal(msg_list[i], msg_cons.msg_list[i]))
def test_006(self): vlen = 128 syms = 4 bin1 = vlen / 2 - vlen / 4 bin2 = vlen / 2 + vlen / 3 bin1_val = 1.0j bin2_val = -1.0 vec = numpy.array(numpy.zeros(vlen), numpy.complex) vec[bin1] = bin1_val vec[bin2] = bin2_val vec = concatenate([vec] * syms) epsilon = [1, -4, 5, 2] frame_trigger = [1] * syms expec = numpy.array(numpy.zeros(vlen * syms), numpy.complex) for i in range(syms): expec[bin1 + i * vlen + epsilon[i]] = bin1_val expec[bin2 + i * vlen + epsilon[i]] = bin2_val freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen) fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2 ifft = gr.fft_vcc(vlen, False, [], True) fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen) src = gr.vector_source_c(vec) dst = gr.vector_sink_c() s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen) v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen) eps = gr.vector_source_f(epsilon) trig = gr.vector_source_b(frame_trigger) self.fg.connect(src, s2v, ifft, (freq_shift, 0)) self.fg.connect(eps, (freq_shift, 1)) self.fg.connect(trig, (freq_shift, 2)) self.fg.connect(freq_shift, fft, fft_scale, v2s, dst) self.fg.run() self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5)
def test_008(self): vlen = 128 syms = 4 bin1 = vlen / 2 + 4 bin1_val = 1.0 cp_length = vlen / 4 expec = numpy.array(numpy.zeros(vlen), numpy.complex) expec[bin1] = bin1_val expec = concatenate([expec] * syms) epsilon = [-0.5] frame_trigger = numpy.concatenate([[1], [0] * (syms - 1)]) freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen, cp_length) fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2 fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen) sampler = ofdm.vector_sampler(gr.sizeof_gr_complex, vlen) trigger_vec = concatenate([[0] * (vlen + cp_length - 1), [1]]) trigger_vec = concatenate([trigger_vec] * syms) trigger = gr.vector_source_b(trigger_vec.tolist()) src = gr.sig_source_c(vlen, gr.GR_COS_WAVE, 4.5, 1.0, 0.0) # bin vlen/2 + 4.5 dst = gr.vector_sink_c() v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen) eps = gr.vector_source_f(epsilon) trig = gr.vector_source_b(frame_trigger.tolist()) self.fg.connect(src, (sampler, 0)) self.fg.connect(trigger, (sampler, 1)) self.fg.connect(sampler, (freq_shift, 0)) self.fg.connect(eps, (freq_shift, 1)) self.fg.connect(trig, (freq_shift, 2)) self.fg.connect(freq_shift, fft, fft_scale, v2s, dst) self.fg.run() self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5, 1e-5)
def test_002(self): # Need to add padding to keep proper alignment padding = tuple([0 for i in range(2)]) src_data = (2147483647, 2147483648, 2200000000, -2147483648, -2147483649, -2200000000) + padding expected_result = [ 2147483647, 2147483647, 2147483647, -2147483647, -2147483647, -2147483647 ] expected_result.extend(padding) 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 setUp(self): self.tb = gr.top_block() print "qa_descrambling_vfvf START" cell_id = 124 inf = open('/home/demel/exchange/matlab_pbch_demod_p.txt') intu = range(480) for i in range(480): intu[i] = float(inf.readline()) self.src = gr.vector_source_f(intu, True, 480) self.ld = lte_swig.descrambling_vfvf() self.ld.set_cell_id(cell_id) self.sink = gr.vector_sink_f(120) self.head = gr.head(480 * 4, 10) self.tb.connect(self.src, self.head, self.ld, self.sink)
def setUp (self): print "qa_lte_rate_unmatch_vff START" inf=open('/home/demel/exchange/matlab_pbch_descr.txt') intu=range(120) for i in range(120): intu[i]=float(inf.readline()) #print line #intu[i]=float(line) invec=intu # invec is a sample vector interleaved from Matlab self.tb = gr.top_block () self.src = gr.vector_source_f( invec, True, 40) self.vtos = gr.vector_to_stream(1*gr.sizeof_float,40) self.stov = gr.stream_to_vector(1*gr.sizeof_float,1*120) self.head = gr.head(120*4,1) self.lru = lte_swig.rate_unmatch_vff() # 124 self.sink = gr.vector_sink_f(120) self.tb.connect(self.src, self.vtos, self.stov, self.head, self.lru, self.sink)
def test_004(self): ''' Test impulse response - short form, ff ''' src_data = [ 1, ] + 100 * [ 0, ] expected_result = ((-0.029296875), (-0.0302734375), (0.96875), (-0.0302734375), (-0.029296875)) src = gr.vector_source_f(src_data) op = gr.dc_blocker_ff(32, False) dst = gr.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() # only test samples around D-1 result_data = dst.data()[29:34] self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def xtest_003_interp(self): taps = random_floats(9) src_data = random_floats(10000) decimation = 3 expected_result = reference_dec_filter(src_data, decimation, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = filter.rational_resampler_base_fff(1, decimation, taps) dst = gr.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() result_data = dst.data() N = 10 offset = 10#len(taps)-1 print expected_result[100+offset:100+offset+N] print result_data[100:100+N]
def test_006_interp_decim(self): taps = random_floats(31) src_data = random_floats(10000) interp = 3 decimation = 2 expected_result = reference_interp_dec_filter(src_data, interp, decimation, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = filter.rational_resampler_base_fff(interp, decimation, taps) dst = gr.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() result_data = dst.data() N = 1000 offset = len(taps)/2 self.assertFloatTuplesAlmostEqual(expected_result[offset:offset+N], result_data[0:N], 5)
def test_pwr_squelch_004(self): alpha = 0.0001 thr = -25 src_data = map(lambda x: float(x) / 10.0, range(1, 40)) src = gr.vector_source_f(src_data) op = analog.pwr_squelch_ff(thr, alpha) dst = gr.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_003(self): ''' Test impulse response - long form, ff ''' src_data = [ 1, ] + 100 * [ 0, ] expected_result = ((-0.02072429656982422), (-0.02081298828125), (0.979156494140625), (-0.02081298828125), (-0.02072429656982422)) src = gr.vector_source_f(src_data) op = gr.dc_blocker_ff(32, True) dst = gr.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() # only test samples around 2D-2 result_data = dst.data()[60:65] self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def test_001(self): src_data = 200 * [ 0, ] + 200 * [ 0.5, ] + 200 * [ 1, ] expected_result = 200*[1,] + \ sig_source_f(1, 0.125, 1, 200) + \ sig_source_f(1, 0.25, 1, 200) src = gr.vector_source_f(src_data) op = blocks_swig.vco_f(1, math.pi / 2.0, 1) dst = gr.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data, 5)
def test_deint_001(self): lenx = 63 src0 = gr.vector_source_f(range(lenx)) op = gr.deinterleave(gr.sizeof_float, 3) dst0 = gr.vector_sink_f() dst1 = gr.vector_sink_f() dst2 = gr.vector_sink_f() self.tb.connect(src0, op) op.connect(dst0, usesPortName="float_out_1") op.connect(dst1, usesPortName="float_out_2") op.connect(dst2, usesPortName="float_out_3") self.tb.run() expected_result0 = tuple(range(0, lenx, 3)) expected_result1 = tuple(range(1, lenx, 3)) expected_result2 = tuple(range(2, lenx, 3)) self.assertFloatTuplesAlmostEqual(expected_result0, dst0.data()) self.assertFloatTuplesAlmostEqual(expected_result1, dst1.data()) self.assertFloatTuplesAlmostEqual(expected_result2, dst2.data())
def test_001_t(self): src_data = (0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) expected_result = (-2.0, 0.0, 5.0, 8.0, 9.0, 11.0, 14.0, 18.0) src0 = gr.vector_source_f(src_data) sqr = square3_ff() #Preload sqr.input_config(1).preload_items = 1 dst = gr.vector_sink_f() self.tb.connect(src0, (sqr, 0)) # src0(vector_source) -> sqr_input_0 #self.tb.connect((sqr,0), (sqr,1)) # sqr_output_0 -> sqr_input_1 self.tb.connect(sqr, dst) # sqr_output_0 -> dst (vector_source) self.tb.run() result_data = dst.data() print str(result_data), "Result data" print str(expected_result), "expected "
def test_003_f_1(self): #Test streams_to_vector (using stream_to_streams & vector_to_stream). n = 1 src_len = n * 8 src_data = tuple(range(src_len)) expected_results = src_data src = gr.vector_source_f(src_data) op1 = gr.stream_to_streams_comp(gr.sizeof_float, n) op2 = gr.streams_to_vector_comp(gr.sizeof_float, n) op3 = gr.vector_to_stream_comp(gr.sizeof_float, n) dst = gr.vector_sink_f() self.tb.connect(src, op1) for i in range(n): self.tb.connect((op1, i), (op2, i)) self.tb.connect(op2, op3, dst) self.tb.run() self.assertEqual(expected_results, dst.data())
def test_001_t (self): src0 = numpy.arange(0,3.1416,1) src0 = gr.vector_source_f(src0) expected_result = (0.0, 0.8414709568023682, 0.9092974066734314, 0.14112000167369843) sqr = generic() sqr.set_parameters("sin",1) dst = gr.vector_sink_f() self.tb.connect(src0, (sqr,0)) # src0(vector_source) -> sqr_input_0 self.tb.connect(sqr,dst) # sqr_output_0 -> dst (vector_source) self.tb.run() result_data = dst.data() print result_data, "Result data" self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def run_test (fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed): tb = gr.top_block () # TX src = gr.lfsr_32k_source_s() src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the outer FSM input cardinality enc_out = trellis.encoder_ss(fo,0) # initial state = 0 inter = trellis.permutation(interleaver.K(),interleaver.INTER(),1,gr.sizeof_short) enc_in = trellis.encoder_ss(fi,0) # initial state = 0 mod = gr.chunks_to_symbols_sf(constellation,dimensionality) # CHANNEL add = gr.add_ff() noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed) # RX metrics_in = trellis.metrics_f(fi.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for innner Viterbi gnd = gr.vector_source_f([0],True); siso_in = trellis.siso_f(fi,K,0,-1,True,False,trellis.TRELLIS_MIN_SUM) # Put -1 if the Initial/Final states are not set. deinter = trellis.permutation(interleaver.K(),interleaver.DEINTER(),fi.I(),gr.sizeof_float) va_out = trellis.viterbi_s(fo,K,0,-1) # Put -1 if the Initial/Final states are not set. fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts dst = gr.check_lfsr_32k_s() tb.connect (src,src_head,s2fsmi,enc_out,inter,enc_in,mod) tb.connect (mod,(add,0)) tb.connect (noise,(add,1)) tb.connect (add,metrics_in) tb.connect (gnd,(siso_in,0)) tb.connect (metrics_in,(siso_in,1)) tb.connect (siso_in,deinter,va_out,fsmi2s,dst) tb.run() ntotal = dst.ntotal () nright = dst.nright () runlength = dst.runlength () return (ntotal,ntotal-nright)
def test_003(self): scale = 2 vlen = 3 # Pad source data becasue of gr_sptr->output_multiple src_data = (0.0, 1.1, 2.2,0,0,0,0,0,0,0,0,0,0,0,0,0, \ 3.3, 4.4, 5.5,0,0,0,0,0,0,0,0,0,0,0,0,0, \ -1.1, -2.2, -3.30,0,0,0,0,0,0,0,0,0,0,0,0,0) expected_result = [0, 2, 4,0,0,0,0,0,0,0,0,0,0,0,0,0, \ 7, 9, 11,0,0,0,0,0,0,0,0,0,0,0,0,0,\ -2, -4, -7,0,0,0,0,0,0,0,0,0,0,0,0,0] src = gr.vector_source_f(src_data) s2v = gr.stream_to_vector(gr.sizeof_float, vlen) op = gr.float_to_short(vlen, scale) v2s = gr.vector_to_stream(gr.sizeof_short, vlen) dst = gr.vector_sink_s() self.tb.connect(src, s2v, op, v2s, dst) self.tb.run() result_data = list(dst.data()) self.assertEqual(expected_result, result_data)
def test_01(self): tb = self.tb N = 10000 seed = 0 data = make_random_float_tuple(N, 1) expected_result = N * [ 0, ] src = gr.vector_source_f(data, False) op = blocks.moving_average_ff(100, 0.001) dst = gr.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() dst_data = dst.data() # make sure result is close to zero self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 1)
def test_001_interp(self): taps = [1, 10, 100, 1000, 10000] src_data = (0, 2, 3, 5, 7, 11, 13, 17) interpolation = 3 xr = (0,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) expected_result = tuple([float(x) for x in xr]) tb = gr.top_block() src = gr.vector_source_f(src_data) op = filter.rational_resampler_base_fff(interpolation, 1, taps) dst = gr.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Corr Test Gui") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.wxgui_scopesink2_0 = scopesink2.scope_sink_f( self.GetWin(), title="Scope Plot", sample_rate=samp_rate, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=2, trig_mode=gr.gr_TRIG_MODE_AUTO, y_axis_label="Counts", ) self.Add(self.wxgui_scopesink2_0.win) self.gr_vector_source_x_0 = gr.vector_source_f((concatenate((ones(10),zeros(200)),1)), True, 1) self.gr_throttle_0 = gr.throttle(gr.sizeof_float*1, samp_rate) self.fir_filter_xxx_0 = filter.fir_filter_fff(1, (ones(10))) ################################################## # Connections ################################################## self.connect((self.gr_vector_source_x_0, 0), (self.gr_throttle_0, 0)) self.connect((self.gr_throttle_0, 0), (self.fir_filter_xxx_0, 0)) self.connect((self.fir_filter_xxx_0, 0), (self.wxgui_scopesink2_0, 0)) self.connect((self.gr_throttle_0, 0), (self.wxgui_scopesink2_0, 1))
def test_001_t (self): """ Simplest possible test: put in zeros, then header, then payload, trigger signal, try to demux. The return signal from the header parser is faked via _post() """ n_zeros = 100 header = (1, 2, 3) payload = tuple(range(17)) data_signal = (0,) * n_zeros + header + payload trigger_signal = [0,] * len(data_signal) trigger_signal[n_zeros] = 1 data_src = gr.vector_source_f(data_signal, False) trigger_src = gr.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float ) self.assertEqual(pmt.pmt_length(hpd.message_ports_in()), 1) header_sink = gr.vector_sink_f() payload_sink = gr.vector_sink_f() self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post( pmt.pmt_intern('header_data'), pmt.pmt_from_long(len(payload)) ) while len(payload_sink.data()) < len(payload): time.sleep(.2) self.tb.stop() self.tb.wait() self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload)
def make_rx(tb,fo,fi,dimensionality,tot_constellation,K,interleaver,IT,Es,N0,type): metrics_in = trellis.metrics_f(fi.O(),dimensionality,tot_constellation,digital.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for innner SISO scale = gr.multiply_const_ff(1.0/N0) gnd = gr.vector_source_f([0],True); inter=[] deinter=[] siso_in=[] siso_out=[] # generate all blocks for it in range(IT): inter.append( trellis.permutation(interleaver.K(),interleaver.INTER(),fi.I(),gr.sizeof_float) ) siso_in.append( trellis.siso_f(fi,K,0,-1,True,False,type) ) deinter.append( trellis.permutation(interleaver.K(),interleaver.DEINTER(),fi.I(),gr.sizeof_float) ) if it < IT-1: siso_out.append( trellis.siso_f(fo,K,0,-1,False,True,type) ) else: siso_out.append( trellis.viterbi_s(fo,K,0,-1) ) # no soft outputs needed # connect first stage tb.connect (gnd,inter[0]) tb.connect (metrics_in,scale) tb.connect (scale,(siso_in[0],1)) # connect the rest for it in range(IT): if it < IT-1: tb.connect (metrics_in,(siso_in[it+1],1)) tb.connect (siso_in[it],deinter[it],(siso_out[it],1)) tb.connect (gnd,(siso_out[it],0)) tb.connect (siso_out[it],inter[it+1]) tb.connect (inter[it],(siso_in[it],0)) else: tb.connect (siso_in[it],deinter[it],siso_out[it]) tb.connect (inter[it],(siso_in[it],0)) return (metrics_in,siso_out[IT-1])
def test_001(self): src_data = range(1000) expected_result = range(1000) filename = "tmp.32f" src = gr.vector_source_f(src_data) snk = blocks.file_sink(gr.sizeof_float, filename) snk.set_unbuffered(True) src2 = blocks.file_source(gr.sizeof_float, filename) snk2 = gr.vector_sink_f() self.tb.connect(src, snk) self.tb.run() self.tb.disconnect(src, snk) self.tb.connect(src2, snk2) self.tb.run() os.remove(filename) result_data = snk2.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def test_001_f(self): #Test stream_to_streams. n = 4 src_len = n * 8 src_data = range(src_len) expected_results = calc_expected_result(src_data, n) src = gr.vector_source_f(src_data) op = gr.stream_to_streams_comp(gr.sizeof_float, n) self.tb.connect(src, op) dsts = [] for i in range(n): dst = gr.vector_sink_f() self.tb.connect((op, i), (dst, 0)) dsts.append(dst) self.tb.run() for d in range(n): self.assertEqual(expected_results[d], dsts[d].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)