def test_deint_001(self): lenx = 64 src0 = gr.vector_source_s(range(lenx)) op = gr.deinterleave(gr.sizeof_short, 4) dst0 = gr.vector_sink_s() dst1 = gr.vector_sink_s() dst2 = gr.vector_sink_s() dst3 = gr.vector_sink_s() self.tb.connect(src0, op) op.connect(dst0, usesPortName="short_out_0") op.connect(dst1, usesPortName="short_out_1") op.connect(dst2, usesPortName="short_out_2") op.connect(dst3, usesPortName="short_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_001(self): src1_data = [0,2,-3,0,12,0] src2_data = [0,0,3,0,10,0] src3_data = (0,0,3,0,1,0) src4_data = (0,1,8,6,3,4) a = sb.DataSource(dataFormat="short") b = sb.DataSource(dataFormat="short") c = sb.DataSource(dataFormat="short") d = sb.DataSource(dataFormat="short") argmax = gr.argmax(gr.sizeof_short, len(src1_data), 4) a.connect(argmax,providesPortName="short_in_1") b.connect(argmax,providesPortName="short_in_2") c.connect(argmax,providesPortName="short_in_3") d.connect(argmax,providesPortName="short_in_4") dest1 = gr.vector_sink_s () dest2 = gr.vector_sink_s () argmax.connect(dest1,usesPortName="short_out_1") argmax.connect(dest2,usesPortName="short_out_2") sb.start() a.push(src1_data,EOS=True) b.push(src2_data,EOS=True) c.push(src2_data,EOS=True) d.push(src2_data,EOS=True) index = dest1.getData(eos_block=True) source = dest2.getData(eos_block=True) self.assertEqual ( tuple(index), (4,)) self.assertEqual ( tuple(source), (0,))
def test_001(self): src1_data = [0, 2, -3, 0, 12, 0] src2_data = [0, 0, 3, 0, 10, 0] src3_data = (0, 0, 3, 0, 1, 0) src4_data = (0, 1, 8, 6, 3, 4) a = sb.DataSource(dataFormat="short") b = sb.DataSource(dataFormat="short") c = sb.DataSource(dataFormat="short") d = sb.DataSource(dataFormat="short") argmax = gr.argmax(gr.sizeof_short, len(src1_data), 4) a.connect(argmax, providesPortName="short_in_1") b.connect(argmax, providesPortName="short_in_2") c.connect(argmax, providesPortName="short_in_3") d.connect(argmax, providesPortName="short_in_4") dest1 = gr.vector_sink_s() dest2 = gr.vector_sink_s() argmax.connect(dest1, usesPortName="short_out_1") argmax.connect(dest2, usesPortName="short_out_2") sb.start() a.push(src1_data, EOS=True) b.push(src2_data, EOS=True) c.push(src2_data, EOS=True) d.push(src2_data, EOS=True) index = dest1.getData(eos_block=True) source = dest2.getData(eos_block=True) self.assertEqual(tuple(index), (4, )) self.assertEqual(tuple(source), (0, ))
def test_deint_001 (self): lenx = 64 src0 = gr.vector_source_s (range (lenx)) op = gr.deinterleave (gr.sizeof_short,4) dst0 = gr.vector_sink_s () dst1 = gr.vector_sink_s () dst2 = gr.vector_sink_s () dst3 = gr.vector_sink_s () self.tb.connect (src0, op) op.connect(dst0,usesPortName="short_out_0") op.connect(dst1,usesPortName="short_out_1") op.connect(dst2,usesPortName="short_out_2") op.connect(dst3,usesPortName="short_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_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 = gr.vector_source_f(src1_data) s2v1 = gr.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src1, s2v1) src2 = gr.vector_source_f(src2_data) s2v2 = gr.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src2, s2v2) src3 = gr.vector_source_f(src3_data) s2v3 = gr.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src3, s2v3) dst1 = gr.vector_sink_s() dst2 = gr.vector_sink_s() argmax = gr.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_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 test_001(self): src1_data = [0,0.2,-0.3,0,12,0] a = sb.DataSource(dataFormat="float") argmax = gr.argmax(gr.sizeof_float, len(src1_data),1 ) a.connect(argmax,providesPortName="float_in") dest1 = gr.vector_sink_s () dest2 = gr.vector_sink_s () argmax.connect(dest1,usesPortName="short_out_1") argmax.connect(dest2,usesPortName="short_out_2") sb.start() a.push(src1_data,EOS=True) index = dest1.getData(eos_block=True) source = dest2.getData(eos_block=True) self.assertEqual ( tuple(index), (4,)) self.assertEqual ( tuple(source), (0,))
def test_001(self): src1_data = [0, 0.2, -0.3, 0, 12, 0] a = sb.DataSource(dataFormat="float") argmax = gr.argmax(gr.sizeof_float, len(src1_data), 1) a.connect(argmax, providesPortName="float_in") dest1 = gr.vector_sink_s() dest2 = gr.vector_sink_s() argmax.connect(dest1, usesPortName="short_out_1") argmax.connect(dest2, usesPortName="short_out_2") sb.start() a.push(src1_data, EOS=True) index = dest1.getData(eos_block=True) source = dest2.getData(eos_block=True) self.assertEqual(tuple(index), (4, )) self.assertEqual(tuple(source), (0, ))
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="short") b = sb.DataSource(dataFormat="short") c = sb.DataSource(dataFormat="short") d = sb.DataSource(dataFormat="short") op = gr.interleave(gr.sizeof_short, 4) dst = gr.vector_sink_s() a.connect(op, providesPortName="short_in_0") b.connect(op, providesPortName="short_in_1") c.connect(op, providesPortName="short_in_2") d.connect(op, providesPortName="short_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): l = 100000 stream = [ [0]*l, [1]*l, [2]*l, [3]*l ] mux = concatenate(stream) seed() for i in range(l): a = randint(0,len(mux)-1) b = randint(0,len(mux)-1) mux[a],mux[b] = mux[b],mux[a] imux = [] for x in mux: imux.append(int(x)) data = [gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2]), gr.vector_source_s(stream[3])] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, 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(data[3], (uut,3)) self.fg.connect(uut,dst) self.fg.run() self.assertEqual(list(mux),list(dst.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="short") b = sb.DataSource(dataFormat="short") c = sb.DataSource(dataFormat="short") d = sb.DataSource(dataFormat="short") op = gr.interleave (gr.sizeof_short, 4) dst = gr.vector_sink_s () a.connect(op, providesPortName="short_in_0") b.connect(op, providesPortName="short_in_1") c.connect(op, providesPortName="short_in_2") d.connect(op, providesPortName="short_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_005 (self): stream = [ [0]*10, [1]*10, [2]*10 ] mux = [ 0,1,2 ] ref = [ 0,1,2,0,1,2,0,1,2,0,1,2,0,1,2,0,1,2,0,1,2, 0,1,2,0,1,2,0,1,2 ] imux = [] for x in mux: imux.append(int(x)) data = [gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2])] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, 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(ref,list(dst.data()))
def test_006 (self): l = 100000 stream = [ [0]*l, [1]*l, [2]*l ] mux = [ 0,2,1 ] ref = concatenate([mux]*l) imux = [] for x in mux: imux.append(int(x)) data = [gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2])] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, 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(list(ref),list(dst.data()))
def main(): gr.enable_realtime_scheduling() parser = OptionParser(option_class=eng_option, conflict_handler="resolve") (options, args) = parser.parse_args () d = {'verbose': True, 'samples_per_symbol': 2, 'usrpx': None, 'excess_bw': 0.34999999999999998, 'fusb_block_size': 0, 'log': False, 'costas_alpha': 0.14999999999999999, 'bitrate': 100000.0, 'decim': DECIM, 'omega_relative_limit': 0.0050000000000000001, 'fusb_nblocks': 0, 'which': 0, 'rx_subdev_spec': None, 'freq_error': 0.0, 'lo_offset': None, 'modulation': 'gmsk', 'gain_mu': None, 'interface': 'eth0', 'freq': None, 'rx_freq': 2.475e9, 'rx_gain': RXGAIN, 'tx_freq': 2440000000.0, 'mu': 0.5, 'mac_addr': '', 'show_rx_gain_range': True, 'gray_code': True, 'tx_subdev_spec' : None, 'tx_gain' : None, 'show_tx_gain_range': False} for i, j in d.items(): setattr(options, i, j) u = usrp_options.create_usrp_source(options) adc_rate = u.adc_rate() if options.verbose: print 'USRP Source:', u (_bitrate, _samples_per_symbol, _decim) = \ pick_rx_bitrate(options.bitrate, 2, \ options.samples_per_symbol, options.decim, adc_rate, \ u.get_decim_rates()) u.set_decim(_decim) if not u.set_center_freq(options.rx_freq): print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(options.rx_freq)) raise ValueError, eng_notation.num_to_str(options.rx_freq) tb = gr.top_block() dst = gr.vector_sink_s () dump = gr.file_sink(gr.sizeof_gr_complex, 'packet.dat') tb.connect(u, dump) tb.run()
def test_001(self): stream = [[0] * 10, [1] * 10, [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_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2]) ] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, 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(mux, list(dst.data()))
def test_006(self): l = 100000 stream = [[0] * l, [1] * l, [2] * l] mux = [0, 2, 1] ref = concatenate([mux] * l) imux = [] for x in mux: imux.append(int(x)) data = [ gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2]) ] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, 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(list(ref), list(dst.data()))
def test_002(self): l = 100000 stream = [[0] * l, [1] * l, [2] * l, [3] * l] mux = concatenate(stream) seed() for i in range(l): a = randint(0, len(mux) - 1) b = randint(0, len(mux) - 1) mux[a], mux[b] = mux[b], mux[a] imux = [] for x in mux: imux.append(int(x)) data = [ gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2]), gr.vector_source_s(stream[3]) ] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, 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(data[3], (uut, 3)) self.fg.connect(uut, dst) self.fg.run() self.assertEqual(list(mux), list(dst.data()))
def help_const_ss(self, src_data, exp_data, op): src = gr.vector_source_s(src_data) srcv = gr.stream_to_vector(gr.sizeof_short, len(src_data)) rhs = gr.vector_to_stream(gr.sizeof_short, len(src_data)) dst = gr.vector_sink_s() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_float_to_short_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_short() dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def test_complex_to_interleaved_short(self): src_data = (1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j, 9 + 10j) expected_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) src = gr.vector_source_c(src_data) op = blocks_swig.complex_to_interleaved_short() dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def test_and_const_ss (self): src_data = (1, 2, 3, 0x5004, 0x1150) expected_result = (0, 2, 2, 0x5000, 0x1100) src = gr.vector_source_s(src_data) op = blocks_swig.and_const_ss (0x55AA) dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(dst.data(), expected_result)
def test_000_ss(self): src_data = (1, 2, 3, 4, 5, 6) dst_data = (6, 15) src = gr.vector_source_s(src_data) itg = blocks_swig.integrate_ss(3) dst = gr.vector_sink_s() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data())
def test_000_ss(self): src_data = (1, 2, 3, 4, 5, 6) dst_data = (6, 15) src = gr.vector_source_s(src_data) itg = gr.integrate_ss(3) dst = gr.vector_sink_s() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data())
def test_char_to_short(self): src_data = (1, 2, 3, 4, 5) expected_data = (256, 512, 768, 1024, 1280) src = gr.vector_source_b(src_data) op = blocks_swig.char_to_short() dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def test_complex_to_interleaved_short(self): src_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j) expected_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) src = gr.vector_source_c(src_data) op = blocks_swig.complex_to_interleaved_short() dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def help_ss_const (self, src_data, exp_data, op): for s in zip (range (len (src_data)), src_data): src = gr.vector_source_s (s[1]) self.tb.connect (src, (op, s[0])) dst = gr.vector_sink_s () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () self.assertEqual (exp_data, result_data)
def help_const_ss(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_s(s[1]) self.tb.connect(src, (op, s[0])) dst = gr.vector_sink_s() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_float_to_short_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_short(1, 5) dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def test_001_fpdata_sink (self): src_data = (-3, 4, -5, 2, 3) expected_result = (-3, 4, -5, 2, 3) src = gr.vector_source_s (src_data) fpgnu = fpgnu_swig.fpdata_sink (1) dst = gr.vector_sink_s () self.tb.connect (src, fpgnu) self.tb.connect (fpgnu, dst) self.tb.run () result_data = 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_s(self.src_data) op = gr.skiphead(gr.sizeof_short, skip_cnt) dst1 = gr.vector_sink_s() self.tb.connect(src1, op, dst1) self.tb.run() dst_data = dst1.data() self.assertEqual(expected_result, dst_data)
def test_skip_all(self): skip_cnt = len(self.src_data) expected_result = tuple(self.src_data[skip_cnt:]) src1 = gr.vector_source_s (self.src_data) op = gr.skiphead (gr.sizeof_short, skip_cnt) dst1 = gr.vector_sink_s () self.tb.connect (src1, op, dst1) self.tb.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_copy_drop (self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_result = () src = gr.vector_source_s(src_data) op = gr.copy(gr.sizeof_short, False, 2) dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() dst_data = dst.data() self.assertEqual(expected_result, dst_data)
def help_ss(self, src_data, exp_data, op, port_prefix='data_in_'): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_s(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_s() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_const_s (self): tb = self.tb expected_result = (1, 1, 1, 1) src1 = gr.sig_source_s (1e6, gr.GR_CONST_WAVE, 0, 1) op = gr.head (gr.sizeof_short, 4) dst1 = gr.vector_sink_s () tb.connect (src1, op) tb.connect (op, dst1) tb.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_sqr_s(self): tb = self.tb expected_result = (0, 0, 0, 0, 1, 1, 1, 1, 0) src1 = gr.sig_source_s(8, gr.GR_SQR_WAVE, 1.0, 1.0) op = gr.head(gr.sizeof_short, 9) dst1 = gr.vector_sink_s() tb.connect(src1, op) tb.connect(op, dst1) tb.run() dst_data = dst1.data() self.assertEqual(expected_result, dst_data)
def test_sqr_s (self): tb = self.tb expected_result = (0, 0, 0, 0, 1, 1, 1, 1, 0) src1 = gr.sig_source_s (8, gr.GR_SQR_WAVE, 1.0, 1.0) op = gr.head (gr.sizeof_short, 9) dst1 = gr.vector_sink_s () tb.connect (src1, op) tb.connect (op, dst1) tb.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_const_s(self): tb = self.tb expected_result = (1, 1, 1, 1) src1 = gr.sig_source_s(1e6, gr.GR_CONST_WAVE, 0, 1) op = gr.head(gr.sizeof_short, 4) dst1 = gr.vector_sink_s() tb.connect(src1, op) tb.connect(op, dst1) tb.run() dst_data = dst1.data() self.assertEqual(expected_result, dst_data)
def help_ss (self, src_data, exp_data, op, port_prefix='data_in_'): for s in zip (range (len (src_data)), src_data): src = gr.vector_source_s (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_s () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () self.assertEqual (exp_data, result_data)
def run_test(f, Kb, bitspersymbol, K, channel, modulation, dimensionality, tot_constellation, N0, seed): tb = gr.top_block() L = len(channel) # TX # this for loop is TOO slow in python!!! packet = [0] * (K + 2 * L) random.seed(seed) for i in range(len(packet)): packet[i] = random.randint(0, 2**bitspersymbol - 1) # random symbols for i in range(L): # first/last L symbols set to 0 packet[i] = 0 packet[len(packet) - i - 1] = 0 src = gr.vector_source_s(packet, False) mod = gr.chunks_to_symbols_sf(modulation[1], modulation[0]) # CHANNEL isi = gr.fir_filter_fff(1, channel) add = gr.add_ff() noise = gr.noise_source_f(gr.GR_GAUSSIAN, math.sqrt(N0 / 2), seed) # RX skip = gr.skiphead( gr.sizeof_float, L ) # skip the first L samples since you know they are coming from the L zero symbols #metrics = trellis.metrics_f(f.O(),dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi #va = trellis.viterbi_s(f,K+L,0,0) # Put -1 if the Initial/Final states are not set. va = trellis.viterbi_combined_s( f, K + L, 0, 0, dimensionality, tot_constellation, trellis.TRELLIS_EUCLIDEAN ) # using viterbi_combined_s instead of metrics_f/viterbi_s allows larger packet lengths because metrics_f is complaining for not being able to allocate large buffers. This is due to the large f.O() in this application... dst = gr.vector_sink_s() tb.connect(src, mod) tb.connect(mod, isi, (add, 0)) tb.connect(noise, (add, 1)) #tb.connect (add,metrics) #tb.connect (metrics,va,dst) tb.connect(add, skip, va, dst) tb.run() data = dst.data() ntotal = len(data) - L nright = 0 for i in range(ntotal): if packet[i + L] == data[i]: nright = nright + 1 #else: #print "Error in ", i return (ntotal, ntotal - nright)
def test_fir_filter_fsf_002(self): src_data = 40*[1, 2, 3, 4] expected_data = (0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50) src = gr.vector_source_f(src_data) op = filter.fir_filter_fsf(4, 20*[0.5, 0.5]) dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data, 5)
def test_deint_001(self): lenx = 64 src = gr.vector_source_s(range(lenx)) op = gr.deinterleave(gr.sizeof_short, 1) dst0 = gr.vector_sink_s() 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_deint_001 (self): lenx = 64 src = gr.vector_source_s (range (lenx)) op = gr.deinterleave (gr.sizeof_short, 1) dst0 = gr.vector_sink_s () 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 help_ss(self, size, src_data, exp_data, op): for s in zip(range (len (src_data)), src_data): src = gr.vector_source_s(s[1]) srcv = gr.stream_to_vector(gr.sizeof_short, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = gr.vector_to_stream(gr.sizeof_short, size) dst = gr.vector_sink_s() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def help_ss(self, size, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_s(s[1]) srcv = gr.stream_to_vector(gr.sizeof_short, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = gr.vector_to_stream(gr.sizeof_short, size) dst = gr.vector_sink_s() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_001_short(self): src_data = [n*1 for n in range(100)]; dst_data = [] for n in range(100): dst_data += [n, n, n] src = gr.vector_source_s(src_data) rpt = gr.repeat(gr.sizeof_short, 3) dst = gr.vector_sink_s() self.tb.connect(src, rpt, dst) self.tb.run() self.assertEqual(tuple(dst_data), dst.data())
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() raise SystemExit, 1 src = gr.lfsr_32k_source_s() head = gr.head(gr.sizeof_short, 2048) self.dst = gr.vector_sink_s() self.connect(src, head, self.dst)
def test_001(self): self.maxDiff = None tb = gr.top_block() src1 = gr.vector_source_s(range(0, 100)) src2 = gr.vector_source_s(range(0, 100)) src3 = gr.vector_source_s(range(0, 100)) # itemsize, M, N, offset km2 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 2, 0) km3 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 3, 1) km7 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 7, 2) snk2 = gr.vector_sink_s() snk3 = gr.vector_sink_s() snk7 = gr.vector_sink_s() 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_003 (self): repetitions = 4 inout = [8+4+2+1, 1] #unsigned short input_bits, unsigned short repetitions uut1 = ofdm.repetition_encoder_sb(4, repetitions, [1,0,1,1,1,0,1,1,1,0,1,1,0,1,1,0]) uut2 = ofdm.repetition_decoder_bs(4, repetitions, [1,0,1,1,1,0,1,1,1,0,1,1,0,1,1,0]) src = gr.vector_source_s(inout) dst = gr.vector_sink_s() self.fg.connect(src, uut1, uut2, dst) self.fg.run() self.assertEqual(inout, list(dst.data()))
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() raise SystemExit, 1 src = gr.lfsr_32k_source_s() head = gr.head(gr.sizeof_short, 2048) self.dst = gr.vector_sink_s() self.connect(src, head, self.dst)
def test_001(self): src_data = [1, 2, 3, 4] expected_result = [256, 512, 768, 1024] src = gr.vector_source_s(src_data) op = gr.endian_swap(2) dst = gr.vector_sink_s() 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 = (32766, 32767, 32768, -32767, -32768, -32769) expected_result = [32766, 32767, 32767, -32767, -32768, -32768] src = gr.vector_source_f(src_data) op = gr.float_to_short() dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() result_data = list(dst.data()) self.assertEqual(expected_result, result_data)
def test_int_001(self): lenx = 64 src0 = range(0, lenx, 1) a = sb.DataSource(dataFormat="short") op = gr.interleave(gr.sizeof_short, 1) dst = gr.vector_sink_s() a.connect(op, providesPortName="short_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)