def test_003( self ): vlen = 200 N = 100000 _n = N / vlen refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) vlen = concatenate( [ [vlen]*(_n/2),[vlen/2]*(_n/2),[vlen/4]*(_n)] ) src0 = gr.vector_source_b( refdata.tolist() ) src1 = gr.vector_source_b( data.tolist() ) src2 = gr.vector_source_i( vlen.tolist() ) uut = ofdm.bit_position_dependent_BER( "test" ) self.tb.connect( src0, ( uut, 0 ) ) self.tb.connect( src1, ( uut, 1 ) ) self.tb.connect( src2, ( uut, 2 ) ) if os.path.exists("test_000.uint"): os.remove("test_000.uint") if os.path.exists("test_001.uint"): os.remove("test_001.uint") self.assert_( not os.path.exists("test_000.uint") ) self.assert_( not os.path.exists("test_001.uint") ) self.tb.run() self.assert_( os.path.exists("test_000.uint")) self.assert_( os.path.exists("test_001.uint"))
def test_001( self ): vlen = 256 N = 100000 refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) ref = numpy.array([0]*vlen) for x in range(len(data)): ref[x%vlen] += 1 if refdata[x] != data[x] else 0 src0 = gr.vector_source_b( refdata.tolist() ) src1 = gr.vector_source_b( data.tolist() ) src2 = gr.vector_source_i( [vlen]*N ) uut = ofdm.bit_position_dependent_BER( "test" ) self.tb.connect( src0, ( uut, 0 ) ) self.tb.connect( src1, ( uut, 1 ) ) self.tb.connect( src2, ( uut, 2 ) ) self.tb.run() ret = numpy.array( uut.get_cntr_vec() ) self.assert_( (ret==ref).all() )
def stdtest_01(self, bps): # no reuse, bps bits per symbol vsyms = 10 vlen = 10 bits = vsyms * vlen * bps refdata = [randint(0, 1) for i in range(bits)] cmap = [bps] * (vsyms * vlen) src = gr.vector_source_b(refdata) dst = gr.vector_sink_b() src_map = gr.vector_source_b(cmap) s2v = gr.stream_to_vector(gr.sizeof_char, vlen) self.tb.connect(src_map, s2v) dut1 = ofdm.generic_mapper_bcv(vlen) dut2 = ofdm.generic_demapper_vcb(vlen) self.tb.connect(src, dut1, dut2, dst) self.tb.connect(s2v, (dut1, 1)) self.tb.connect(s2v, (dut2, 1)) self.tb.run() self.assertEqual(list(dst.data()), refdata)
def setUp(self): self.tb = gr.top_block() # Read in binary Matlab data from viterbi decoder output. vit = scipy.io.loadmat('/home/demel/exchange/matlab_vit.mat') mat_u = range(40) mat_u = tuple(vit['vit'].flatten()) mat_vit = range(40) for i in mat_vit: mat_vit[i] = int(mat_u[i]) mat_vit = tuple(mat_vit) self.in_data = mat_vit intu = mat_vit[0:24] print intu self.src1 = gr.vector_source_b(intu, False, 24) N_ant = range(1) N_ant[0] = 2 self.src2 = gr.vector_source_b(N_ant, False, 1) self.mib = lte_swig.mib_unpack_vb() #self.snk = gr.null_sink(1) self.tb.connect(self.src1, (self.mib, 0)) self.tb.connect(self.src2, (self.mib, 1))
def stdtest_01(self,bps): # no reuse, bps bits per symbol vsyms = 10 vlen = 10 bits = vsyms*vlen*bps refdata = [randint(0,1) for i in range(bits)] cmap = [bps]*(vsyms*vlen) src = gr.vector_source_b(refdata) dst = gr.vector_sink_b() src_map = gr.vector_source_b(cmap) s2v = gr.stream_to_vector(gr.sizeof_char, vlen) self.tb.connect(src_map,s2v) dut1 = ofdm.generic_mapper_bcv(vlen) dut2 = ofdm.generic_demapper_vcb(vlen) self.tb.connect(src,dut1,dut2,dst) self.tb.connect(s2v,(dut1,1)) self.tb.connect(s2v,(dut2,1)) self.tb.run() self.assertEqual(list(dst.data()),refdata)
def test_002(self): vlen = 200 N = 100000 _n = N / vlen refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) ref = numpy.array([0] * (vlen / 2)) for x in range(N / 2, N): ref[x % (vlen / 2)] += 1 if refdata[x] != data[x] else 0 vlen = concatenate([[vlen] * (_n / 2), [vlen / 2] * (_n)]) src0 = gr.vector_source_b(refdata.tolist()) src1 = gr.vector_source_b(data.tolist()) src2 = gr.vector_source_i(vlen.tolist()) uut = ofdm.bit_position_dependent_BER("test") self.tb.connect(src0, (uut, 0)) self.tb.connect(src1, (uut, 1)) self.tb.connect(src2, (uut, 2)) if os.path.exists("test_000.uint"): os.remove("test_000.uint") self.assert_(not os.path.exists("test_000.uint")) self.tb.run() ret = numpy.array(uut.get_cntr_vec()) self.assert_((ret == ref).all()) self.assert_(os.path.exists("test_000.uint"))
def test_001(self): vlen = 256 N = 100000 refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) ref = numpy.array([0] * vlen) for x in range(len(data)): ref[x % vlen] += 1 if refdata[x] != data[x] else 0 src0 = gr.vector_source_b(refdata.tolist()) src1 = gr.vector_source_b(data.tolist()) src2 = gr.vector_source_i([vlen] * N) uut = ofdm.bit_position_dependent_BER("test") self.tb.connect(src0, (uut, 0)) self.tb.connect(src1, (uut, 1)) self.tb.connect(src2, (uut, 2)) self.tb.run() ret = numpy.array(uut.get_cntr_vec()) self.assert_((ret == ref).all())
def test_003(self): vlen = 200 N = 100000 _n = N / vlen refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) vlen = concatenate([[vlen] * (_n / 2), [vlen / 2] * (_n / 2), [vlen / 4] * (_n)]) src0 = gr.vector_source_b(refdata.tolist()) src1 = gr.vector_source_b(data.tolist()) src2 = gr.vector_source_i(vlen.tolist()) uut = ofdm.bit_position_dependent_BER("test") self.tb.connect(src0, (uut, 0)) self.tb.connect(src1, (uut, 1)) self.tb.connect(src2, (uut, 2)) if os.path.exists("test_000.uint"): os.remove("test_000.uint") if os.path.exists("test_001.uint"): os.remove("test_001.uint") self.assert_(not os.path.exists("test_000.uint")) self.assert_(not os.path.exists("test_001.uint")) self.tb.run() self.assert_(os.path.exists("test_000.uint")) self.assert_(os.path.exists("test_001.uint"))
def derandomizer_pp_desync(self, offset): """ Tests the ability of the derandomiser to synchronise when the inverted SYNC is <offset> packets away Note: This method itself is not a unit test method. """ assert offset < 8 useful_data = make_transport_stream() src = gr.vector_source_b(useful_data) pad = dvb_swig.pad_mpeg_ts_packet_bp() randomizer = dvb_swig.randomizer_pp() depad = dvb_swig.depad_mpeg_ts_packet_pb() dst = gr.vector_sink_b() self.tb.connect(src, pad, randomizer, depad, dst) self.tb.run() randomized_data = dst.data() src_data = make_fake_transport_stream_packet(offset) src_data.extend(randomized_data) self.tb = gr.top_block() src = gr.vector_source_b(src_data) pad = dvb_swig.pad_mpeg_ts_packet_bp() derandomizer = dvb_swig.derandomizer_pp() depad = dvb_swig.depad_mpeg_ts_packet_pb() dst = gr.vector_sink_b() self.tb.connect(src, pad, derandomizer, depad, dst) self.tb.run() result_data = dst.data() self.assertEqual(tuple(useful_data), result_data[-len(useful_data):])
def setUp (self): self.tb = gr.top_block () # Read in binary Matlab data from viterbi decoder output. vit=scipy.io.loadmat('/home/demel/exchange/matlab_vit.mat') mat_u=range(40) mat_u=tuple(vit['vit'].flatten()) mat_vit=range(40) for i in mat_vit: mat_vit[i]=int(mat_u[i]) mat_vit=tuple(mat_vit) self.in_data=mat_vit intu=mat_vit[0:24] print intu self.src1 = gr.vector_source_b(intu, False, 24) N_ant = range(1) N_ant[0] = 2 self.src2 = gr.vector_source_b(N_ant,False,1) self.mib = lte_swig.mib_unpack_vb() #self.snk = gr.null_sink(1) self.tb.connect(self.src1,(self.mib,0)) self.tb.connect(self.src2,(self.mib,1))
def test_003_measure_ber_b(self): src0 = gr.vector_source_b([0,7,255,250]) src1 = gr.vector_source_b([0,2,255,3]) sink = dab_swig.measure_ber_b() self.tb.connect(src0, (sink,0)) self.tb.connect(src1, (sink,1)) self.tb.run() self.assertAlmostEqual(sink.ber(), 8./32.) # every bit is set 50% of the time
def test_001_measure_ber_b(self): src0 = gr.vector_source_b([0]*100) src1 = gr.vector_source_b([255]*100) sink = dab_swig.measure_ber_b() self.tb.connect(src0, (sink,0)) self.tb.connect(src1, (sink,1)) self.tb.run() assert(sink.ber()==1)
def test_001_measure_ber_b(self): src0 = gr.vector_source_b(range(0,256)) src1 = gr.vector_source_b(range(0,256)) sink = dab_swig.measure_ber_b() self.tb.connect(src0, (sink,0)) self.tb.connect(src1, (sink,1)) self.tb.run() assert(sink.ber()==0)
def test_002_measure_ber_b(self): src0 = gr.vector_source_b(range(0,256)*2) src1 = gr.vector_source_b([0]*256+[255]*256) sink = dab_swig.measure_ber_b() self.tb.connect(src0, (sink,0)) self.tb.connect(src1, (sink,1)) self.tb.run() self.assertAlmostEqual(sink.ber(), 0.5) # every bit is set 50% of the time
def test_027a_internally_unconnected_input(self): tb = gr.top_block() hb = gr.hier_block2("block", gr.io_signature(1, 1, 1), gr.io_signature(1, 1, 1)) hsrc = gr.vector_source_b([1]) hb.connect(hsrc, hb) # wire output internally src = gr.vector_source_b([1]) dst = gr.vector_sink_b() tb.connect(src, hb, dst) # hb's input is not connected internally self.assertRaises(RuntimeError, lambda: tb.run())
def setup_flowgraph(self, mode, ber_skipbytes=0): # parameters self.dp.set_mode(mode) self.rp.set_mode(mode) self.vlen = self.dp.num_carriers/4 self.ber_skipbytes = ber_skipbytes # trigger signals frame_trigger = [1]+[0]*(self.dp.symbols_per_frame-2) self.frame_start = frame_trigger*(len(self.random_bytes)/(self.vlen*(self.dp.symbols_per_frame-1)))+frame_trigger[0:(len(self.random_bytes)/self.vlen)%(self.dp.symbols_per_frame-1)] # sources/sinks self.source = gr.vector_source_b(self.random_bytes, False) self.trig = gr.vector_source_b(self.frame_start, False) if self.ber_sink: self.sink = dab.blocks.measure_ber_b() else: self.sink = gr.vector_sink_b() self.trig_sink = gr.null_sink(gr.sizeof_char) # self.noise_start = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000)) # self.noise_start_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_START) # self.noise_end = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000)) # self.noise_end_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_END) # blocks self.s2v = gr.stream_to_vector(gr.sizeof_char, self.vlen) self.v2s = gr.vector_to_stream(gr.sizeof_char, self.vlen) if self.ber_sink: self.ber_skipbytes0 = gr.skiphead(gr.sizeof_char, self.ber_skipbytes) self.ber_skipbytes1 = gr.skiphead(gr.sizeof_char, self.ber_skipbytes+self.dp.bytes_per_frame) # more blocks (they have state, so better reinitialise them) self.mod = dab.ofdm_mod(self.dp, debug = False) self.rescale = gr.multiply_const_cc(1) self.amp = gr.multiply_const_cc(1) self.channel = blks2.channel_model(noise_voltage=0, noise_seed=random.randint(0,10000)) # self.cat = dab.concatenate_signals(gr.sizeof_gr_complex) self.demod = dab.ofdm_demod(self.dp, self.rp, debug = False, verbose = True) # connect it all if self.ber_sink: self.connect(self.source, self.s2v, (self.mod,0), self.rescale, self.amp, self.channel, (self.demod,0), self.v2s, self.ber_skipbytes0, self.sink) self.connect(self.source, self.ber_skipbytes1, (self.sink,1)) else: self.connect(self.source, self.s2v, (self.mod,0), self.rescale, self.amp, self.channel, (self.demod,0), self.v2s, self.sink) self.connect(self.trig, (self.mod,1)) self.connect((self.demod, 1), self.trig_sink) # SNR calculation and prober self.probe_signal = gr.probe_avg_mag_sqrd_c(0,0.00001) self.probe_total = gr.probe_avg_mag_sqrd_c(0,0.00001) self.connect(self.amp, self.probe_signal) self.connect(self.channel, self.probe_total)
def test_1(self): datas = ( 0, 1, 2, 5, 6, 10, 14, 15, 16, 3, 4, 7, 8, 9, 11, 12, 13, 17 ) expected = tuple(range(18)) tagname = "packet_length" len_tags_0 = ( make_len_tag(0, tagname, 3), make_len_tag(3, tagname, 2), make_len_tag(5, tagname, 1), make_len_tag(6, tagname, 3) ) len_tags_1 = ( make_len_tag(0, tagname, 2), make_len_tag(2, tagname, 3), make_len_tag(5, tagname, 3), make_len_tag(8, tagname, 1) ) test_tag_0 = gr.gr_tag_t() test_tag_0.key = pmt.pmt_string_to_symbol('spam') test_tag_0.offset = 4 # On the second '1' test_tag_0.value = pmt.to_pmt(42) test_tag_1 = gr.gr_tag_t() test_tag_1.key = pmt.pmt_string_to_symbol('eggs') test_tag_1.offset = 3 # On the first '3' of the 2nd stream test_tag_1.value = pmt.to_pmt(23) src0 = gr.vector_source_b(datas[0:9], False, 1, len_tags_0 + (test_tag_0,)) src1 = gr.vector_source_b(datas[9:], False, 1, len_tags_1 + (test_tag_1,)) tagged_stream_mux = blocks.tagged_stream_mux(gr.sizeof_char, tagname) snk = gr.vector_sink_b() self.tb.connect(src0, (tagged_stream_mux, 0)) self.tb.connect(src1, (tagged_stream_mux, 1)) self.tb.connect(tagged_stream_mux, snk) self.tb.run() self.assertEqual(expected, snk.data()) tags = [gr.tag_to_python(x) for x in snk.tags()] tags = sorted([(x.offset, x.key, x.value) for x in tags]) tags_expected = [ (0, 'packet_length', 5), (5, 'packet_length', 5), (6, 'spam', 42), (8, 'eggs', 23), (10, 'packet_length', 4), (14, 'packet_length', 4) ] self.assertEqual(tags, tags_expected)
def test_027a_internally_unconnected_input(self): tb = gr.top_block() hb = gr.hier_block2("block", gr.io_signature(1, 1, 1), gr.io_signature(1, 1, 1)) hsrc = gr.vector_source_b([ 1, ]) hb.connect(hsrc, hb) # wire output internally src = gr.vector_source_b([ 1, ]) dst = gr.vector_sink_b() tb.connect(src, hb, dst) # hb's input is not connected internally self.assertRaises(RuntimeError, lambda: tb.run())
def test_001_berout (self): """ Check the float output and the ber() function with unpacked data """ src1 = gr.vector_source_b((1,1,1,1,1,1,1,1,1,1)) src2 = gr.vector_source_b((1,1,1,1,1,1,1,1,1,0)) ber = chancoding.ber_b() sink = gr.vector_sink_f() self.tb.connect(src1, (ber, 0)) self.tb.connect(src2, (ber, 1)) self.tb.connect(ber, sink) self.tb.run() self.assertAlmostEqual(ber.ber(), 0.1) self.assertEqual(ber.bit_errors(), 1) self.assertFloatTuplesAlmostEqual(sink.data(), (0,0,0,0,0,0,0,0,0,0.1), 8)
def test_002_packeddata(self): """ Pack 4 bits into a byte and run the check again """ src1 = gr.vector_source_b((0b1111, 0b1111, 0b1111)) src2 = gr.vector_source_b((0b1111, 0b1111, 0b1110)) ber = chancoding.ber_b(4) sink = gr.vector_sink_f() self.tb.connect(src1, (ber, 0)) self.tb.connect(src2, (ber, 1)) self.tb.connect(ber, sink) self.tb.run() self.assertAlmostEqual(ber.ber(), 1. / 12) self.assertEqual(ber.bit_errors(), 1) self.assertFloatTuplesAlmostEqual(sink.data(), (0, 0, 1. / 12), 8)
def test_001 (self): """basic test""" src1=gr.vector_source_b((1,0,0,1,1,0),False,3) src2=gr.vector_source_b((1,0,0,0,1,1),False,3) expected_result = (0,2) dst=gr.vector_sink_i() ber = mlse_swig.ber_vbi(3); self.tb.connect(src1,(ber,0)) self.tb.connect(src2,(ber,1)) self.tb.connect(ber,dst) self.tb.run() result_data = dst.data() self.assertEqual( expected_result, result_data) self.assertAlmostEqual( ber.bit_error_rate(), 1/3., 6) self.assertAlmostEqual( ber.packet_error_rate(), 0.5, 6)
def test_002_packeddata (self): """ Pack 4 bits into a byte and run the check again """ src1 = gr.vector_source_b((0b1111, 0b1111, 0b1111)) src2 = gr.vector_source_b((0b1111, 0b1111, 0b1110)) ber = chancoding.ber_b(4) sink = gr.vector_sink_f() self.tb.connect(src1, (ber, 0)) self.tb.connect(src2, (ber, 1)) self.tb.connect(ber, sink) self.tb.run() self.assertAlmostEqual(ber.ber(), 1./12) self.assertEqual(ber.bit_errors(), 1) self.assertFloatTuplesAlmostEqual(sink.data(), (0,0,1./12), 8)
def __init__(self): grc_wxgui.top_block_gui.__init__( self, title="CPFSK High rate", ) self.samp_rate = samp_rate = 32000 self.gr_cpfsk_bc_0 = gr.cpfsk_bc(1, 1, 2) self.random_source_x_0 = gr.vector_source_b( numpy.random.randint(0, 2, 1000), True) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=0, y_per_div=10, ref_level=50, sample_rate=samp_rate, fft_size=1024, fft_rate=30, average=False, avg_alpha=None, title="CPFSK high rate FFT", peak_hold=False, ) self.Add(self.wxgui_fftsink2_0.win) self.connect((self.gr_cpfsk_bc_0, 0), (self.wxgui_fftsink2_0, 0)) self.connect((self.random_source_x_0, 0), (self.gr_cpfsk_bc_0, 0))
def test_deint_001(self): lenx = 64 src0 = gr.vector_source_b(range(lenx)) op = gr.deinterleave(gr.sizeof_char, 4) dst0 = gr.vector_sink_b() dst1 = gr.vector_sink_b() dst2 = gr.vector_sink_b() dst3 = gr.vector_sink_b() self.tb.connect(src0, op) op.connect(dst0, usesPortName="byte_out_0") op.connect(dst1, usesPortName="byte_out_1") op.connect(dst2, usesPortName="byte_out_2") op.connect(dst3, usesPortName="byte_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 helper(self, v0, v1, fft_length, preamble): tb = self.tb src0 = gr.vector_source_c(v0) src1 = gr.vector_source_b(v1) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length) # print "len(v) = %d" % (len(v)) op = gr.ofdm_insert_preamble(fft_length, preamble) v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_length) dst0 = gr.vector_sink_c() dst1 = gr.vector_sink_b() tb.connect(src0, s2v, (op, 0)) tb.connect(src1, (op, 1)) tb.connect((op, 0), v2s, dst0) tb.connect((op, 1), dst1) tb.run() r0 = dst0.data() r0v = [] for i in range(len(r0) // fft_length): r0v.append(r0[i * fft_length:(i + 1) * fft_length]) r1 = dst1.data() self.assertEqual(len(r0v), len(r1)) return (r1, r0v)
def publish_rx_spectrum(self,fftlen): ## RX Spectrum fftlen = 256 my_window = window.hamming(fftlen) #.blackmanharris(fftlen) rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen) rxs_trigger = gr.vector_source_b(concatenate([[1],[0]*199]),True) rxs_window = blocks.multiply_const_vcc(my_window) rxs_spectrum = gr.fft_vcc(fftlen,True,[],True) rxs_mag = gr.complex_to_mag(fftlen) rxs_avg = gr.single_pole_iir_filter_ff(0.01,fftlen) rxs_logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen)) rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,1) msgq = gr.msg_queue(5) rxs_msg_sink = gr.message_sink(gr.sizeof_float*fftlen,msgq,True) self.connect(rxs_trigger,(rxs_sampler,1)) t = self.u if self.filter is None else self.filter self.connect(t,rxs_sampler,rxs_window, rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate, rxs_msg_sink) self.servants.append(corba_data_buffer_servant("spectrum",fftlen,msgq)) print "RXS trigger unique id", rxs_trigger.unique_id() print "Publishing RX baseband under id: spectrum"
def test_003_ofdm (self): """ Header 1: 193 bytes Header 2: 8 bytes 2 bits per complex symbol, 32 carriers => 64 bits = 8 bytes per OFDM symbol """ encoded_headers = ( # | Number of bytes | Packet number | Parity 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ) packet_len_tagname = "packet_len" frame_len_tagname = "frame_len" src = gr.vector_source_b(encoded_headers) header_formatter = digital.packet_header_ofdm( (range(32),), # 32 carriers are occupied (which doesn't matter here) 1, # 1 OFDM symbol per header (= 32 bits) packet_len_tagname, frame_len_tagname, "packet_num", 1, # 1 bit per header symbols (BPSK) 2 # 2 bits per payload symbol (QPSK) ) parser = digital.packet_headerparser_b(header_formatter.base()) sink = gr.message_debug() self.tb.connect(src, parser) self.tb.msg_connect(parser, "header_data", sink, "store") self.tb.start() time.sleep(1) self.tb.stop() self.tb.wait() self.assertEqual(sink.num_messages(), 2) msg1 = pmt.to_python(sink.get_message(0)) msg2 = pmt.to_python(sink.get_message(1)) self.assertEqual(msg1, {'packet_len': 193*4, 'frame_len': 25, 'packet_num': 0}) self.assertEqual(msg2, {'packet_len': 8*4, 'frame_len': 1, 'packet_num': 1})
def __init__(self): gr.top_block.__init__(self, "Many Rate Changing") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.random_source_x_0 = gr.vector_source_b(map(int, numpy.random.randint(0, 256, 1000)), True) self.gr_unpacked_to_packed_xx_0 = gr.unpacked_to_packed_bb(2, gr.GR_LSB_FIRST) self.gr_packed_to_unpacked_xx_0 = gr.packed_to_unpacked_bb(2, gr.GR_MSB_FIRST) self.gr_null_sink_0_2 = gr.null_sink(gr.sizeof_char*1) self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_float, 3, 20, 0) self.blocks_float_to_char_0 = blocks.float_to_char(1, 1) self.blocks_char_to_float_0 = blocks.char_to_float(1, 1) ################################################## # Connections ################################################## self.connect((self.blocks_char_to_float_0, 0), (self.blocks_keep_m_in_n_0, 0)) self.connect((self.blocks_keep_m_in_n_0, 0), (self.blocks_float_to_char_0, 0)) self.connect((self.blocks_float_to_char_0, 0), (self.gr_packed_to_unpacked_xx_0, 0)) self.connect((self.gr_unpacked_to_packed_xx_0, 0), (self.blocks_char_to_float_0, 0)) self.connect((self.random_source_x_0, 0), (self.gr_unpacked_to_packed_xx_0, 0)) self.connect((self.gr_packed_to_unpacked_xx_0, 0), (self.gr_null_sink_0_2, 0))
def test_002_energy_disp_vbb (self): ################################# src_data_0 = [] for number in range(22): src_data_0.append(0) for number in range(22): src_data_0.append(1) ################################ expected_result_0 = (0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,0, 1,1,1,1,1,0,0,0,0,1,0,0,0,0,0,1) ################################# # Objekte erzeugen src_0 = gr.vector_source_b (src_data_0) s2v_0 = gr.stream_to_vector(gr.sizeof_char, 22) Energy_disp = howto_swig.energy_disp_vbb(22) v2s_0 = gr.vector_to_stream(gr.sizeof_char, 16) dst_0 = gr.vector_sink_b() # Objekte verbinden self.tb.connect(src_0, s2v_0,Energy_disp,v2s_0,dst_0) # Simulationsstart self.tb.run () # Ergebnis auswerten result_data0 = dst_0.data () self.assertEqual(expected_result_0, result_data0)
def setUp (self): self.tb = gr.top_block () my_map = range(46) for i in range(40): my_map[i+6] = int(i) my_map[0]=int(34) my_map[1]=int(35) my_map[2]=int(36) my_map[3]=int(37) my_map[4]=int(38) my_map[5]=int(39) my_data = range(40) for i in my_data: my_data[i]=int(i) self.src = gr.vector_source_b(my_data,False,40) self.head = gr.head(40,1) self.vrs = lte_swig.vector_resize_vbvb(my_map,40,46) self.snk = gr.vector_sink_b(46) self.tb.connect(self.src,self.head,self.vrs,self.snk)
def __init__(self, sps, # Samples per symbol excess_bw, # RRC filter excess bandwidth (typically 0.35-0.5) amplitude # DAC output level, 0-32767, typically 2000-8000 ): gr.hier_block2.__init__(self, "transmit_path", gr.io_signature(0, 0, 0), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature # Create BERT data bit stream self._bits = gr.vector_source_b([1,], True) # Infinite stream of ones self._scrambler = gr.scrambler_bb(0x8A, 0x7F, 7) # CCSDS 7-bit scrambler # Map to constellation self._constellation = [-1+0j, 1+0j] self._mapper = gr.chunks_to_symbols_bc(self._constellation) # Create RRC with specified excess bandwidth taps = gr.firdes.root_raised_cosine(sps*amplitude, # Gain sps, # Sampling rate 1.0, # Symbol rate excess_bw, # Roll-off factor 11*sps) # Number of taps self._rrc = gr.interp_fir_filter_ccf(sps, # Interpolation rate taps) # FIR taps # Wire block inputs and outputs self.connect(self._bits, self._scrambler, self._mapper, self._rrc, self)
def test_00(self): expected_result = ( 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff) # Filter taps to expand the data to oversample by 8 # Just using a RRC for some basic filter shape taps = gr.firdes.root_raised_cosine(8, 8, 1.0, 0.5, 21) src = gr.vector_source_b(expected_result) frame = digital.simple_framer(4) unpack = gr.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST) expand = gr.interp_fir_filter_fff(8, taps) b2f = gr.char_to_float() mult2 = gr.multiply_const_ff(2) sub1 = gr.add_const_ff(-1) op = digital.simple_correlator(4) dst = gr.vector_sink_b() self.tb.connect(src, frame, unpack, b2f, mult2, sub1, expand) self.tb.connect(expand, op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def __init__(self): gr.top_block.__init__(self, "Wmbus Phy2") ################################################## # Variables ################################################## self.frame = frame = [1,1] ################################################## # Blocks ################################################## self.gr_vector_source_x_0 = gr.vector_source_b((frame), False, 1) self.gr_vector_sink_x_1 = gr.vector_sink_b(1) self.gr_vector_sink_x_0 = gr.vector_sink_b(1) self.gr_unpacked_to_packed_xx_0 = gr.unpacked_to_packed_bb(4, gr.GR_MSB_FIRST) self.gr_pack_k_bits_bb_0 = gr.pack_k_bits_bb(6) self.digital_map_bb_1 = digital.map_bb(([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1])) self.digital_map_bb_0 = digital.map_bb(([16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 3, 16, 1, 2, 16, 16, 16, 16, 7, 16, 16, 0, 16, 16, 5, 6, 16, 4, 16, 16, 16, 16, 16, 16, 11, 16, 9, 10, 16, 16, 15, 16, 16, 8, 16, 16, 16, 16, 13, 14, 16, 12, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16])) ################################################## # Connections ################################################## self.connect((self.gr_vector_source_x_0, 0), (self.gr_pack_k_bits_bb_0, 0)) self.connect((self.gr_pack_k_bits_bb_0, 0), (self.digital_map_bb_0, 0)) self.connect((self.digital_map_bb_0, 0), (self.gr_unpacked_to_packed_xx_0, 0)) self.connect((self.gr_unpacked_to_packed_xx_0, 0), (self.gr_vector_sink_x_0, 0)) self.connect((self.digital_map_bb_0, 0), (self.digital_map_bb_1, 0)) self.connect((self.digital_map_bb_1, 0), (self.gr_vector_sink_x_1, 0))
def helper(self, v0, v1, fft_length, preamble): tb = self.tb src0 = gr.vector_source_c(v0) src1 = gr.vector_source_b(v1) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length) # print "len(v) = %d" % (len(v)) op = gr.ofdm_insert_preamble(fft_length, preamble) v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_length) dst0 = gr.vector_sink_c() dst1 = gr.vector_sink_b() tb.connect(src0, s2v, (op, 0)) tb.connect(src1, (op, 1)) tb.connect((op, 0), v2s, dst0) tb.connect((op, 1), dst1) tb.run() r0 = dst0.data() r0v = [] for i in range(len(r0)//fft_length): r0v.append(r0[i*fft_length:(i+1)*fft_length]) r1 = dst1.data() self.assertEqual(len(r0v), len(r1)) return (r1, r0v)
def test_007_vector_sampler(self): data = range(1,577,1) # 1..576 trigger = numpy.concatenate([[0]*575,[1]]) blocks = 10000 expected = data[64:577] assert(len(expected)==512) expected = numpy.concatenate([expected*blocks]) assert(len(expected) == 512*blocks) src = gr.vector_source_c(data,True) src2 = gr.vector_source_b(trigger.tolist(),True) dst = gr.vector_sink_c() sampler = ofdm.vector_sampler(gr.sizeof_gr_complex,512) v2s = gr.vector_to_stream(gr.sizeof_gr_complex,512) self.fg.connect(src, (sampler,0)) self.fg.connect(src2,gr.head(gr.sizeof_char,blocks*576), (sampler,1)) self.fg.connect(sampler, v2s, dst) self.fg.run() #self.assertEqual(numpy.array(expected,numpy.Complex), numpy.array(dst.data(), numpy.Complex)) if numpy.array(expected).all() != numpy.array(dst.data()).all(): print "up" print len(expected),len(dst.data()) vec = dst.data() for i in range(min(len(expected),len(dst.data()))): if vec[i] != expected[i]: print "e at ",i
def test_003_12bits_formatter_object(self): # 3 PDUs: | | | | data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4) tagname = "packet_len" tag1 = gr.gr_tag_t() tag1.offset = 0 tag1.key = pmt.pmt_string_to_symbol(tagname) tag1.value = pmt.pmt_from_long(4) tag2 = gr.gr_tag_t() tag2.offset = 4 tag2.key = pmt.pmt_string_to_symbol(tagname) tag2.value = pmt.pmt_from_long(2) tag3 = gr.gr_tag_t() tag3.offset = 6 tag3.key = pmt.pmt_string_to_symbol(tagname) tag3.value = pmt.pmt_from_long(4) src = gr.vector_source_b(data, False, 1, (tag1, tag2, tag3)) formatter_object = digital.packet_header_default(12, tagname) header = digital.packet_headergenerator_bb( formatter_object.formatter(), tagname) sink = gr.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() expected_data = (0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0) self.assertEqual(sink.data(), expected_data)
def ofdmtest (self): options = Options() enc = raw.ofdm_mod(options) dec = raw.ofdm_demod(options, noutputs=2) NN = 4 qpsk = lambda : cmath.exp(1j * (math.pi/NN * (2*random.randint(0, NN-1)+1))) n = enc.params.data_tones * options.size * 1000 data = tuple([qpsk() for i in range(n)]) signal = [0] * options.size signal[0] = 1 signal = tuple(signal) msg = gr.vector_source_b(signal, True, 1) src = gr.vector_source_c(data, False, enc.params.data_tones) dst = gr.vector_sink_c(enc.params.data_tones) self.tb.connect(src, enc, dec, dst) self.tb.connect(msg, (enc,1)) self.tb.run() rxdata = numpy.array(dst.data()) txdata = numpy.array(data[:len(rxdata)]) power = numpy.average(numpy.square(numpy.abs(txdata))) print len(txdata), len(rxdata), power mse = numpy.average(numpy.square(numpy.abs(numpy.subtract(txdata,rxdata)))) self.assertAlmostEquals(1.0, power, 7) snr = 10 * math.log10(power / mse) self.assertTrue(snr > 40) # that's a pretty low estimate for noiseless
def test_004_8bits_formatter_ofdm(self): occupied_carriers = ((1, 2, 3, 5, 6, 7), ) # 3 PDUs: | | | | data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4) tagname = "packet_len" tag1 = gr.gr_tag_t() tag1.offset = 0 tag1.key = pmt.pmt_string_to_symbol(tagname) tag1.value = pmt.pmt_from_long(4) tag2 = gr.gr_tag_t() tag2.offset = 4 tag2.key = pmt.pmt_string_to_symbol(tagname) tag2.value = pmt.pmt_from_long(2) tag3 = gr.gr_tag_t() tag3.offset = 6 tag3.key = pmt.pmt_string_to_symbol(tagname) tag3.value = pmt.pmt_from_long(4) src = gr.vector_source_b(data, False, 1, (tag1, tag2, tag3)) formatter_object = digital.packet_header_ofdm(occupied_carriers, 1, tagname) self.assertEqual(formatter_object.header_len(), 6) self.assertEqual( pmt.pmt_symbol_to_string(formatter_object.len_tag_key()), tagname) header = digital.packet_headergenerator_bb( formatter_object.formatter(), tagname) sink = gr.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() expected_data = (0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0) self.assertEqual(sink.data(), expected_data)
def test_mod_cpm(): tb = gr.top_block() precode = mlse.xor_encode_bb() nrz = gr.map_bb([1, -1]) mod = gr.gmskmod_bc(1, 0.3, 4) #src = gr.vector_source_b([0,0,0,0,1,1,1,1,0,0]) #src = gr.vector_source_b([1,1,0,0,1,0,0,1,1,1,0,0,0,0]) src = gr.vector_source_b((1, ) * 1000) sink = gr.vector_sink_c() derot = mlse.derotate_cc(1, 4) tb.connect(src, precode, nrz, mod, derot, sink) precode_probe = gr.vector_sink_b() tb.connect(nrz, precode_probe) tb.run() d = sink.data() from cmath import phase, pi, rect real = lambda x: x.real import operator d_r = d #list(decimate(d,5,2)) d2 = [int(round((phase(i) / pi) * 100)) for i in d] derotate = [(-1j)**(i + 1) for i in range(len(d_r))] d3 = map(operator.mul, d_r, derotate) # print "\n".join(map(str,map(real,d3))) print precode_probe.data() # print "\n".join(map(str,map(phase,d))) print "\n".join([str(phase(i) / pi) for i in d]) print len(d) print derotate
def test_regen2 (self): tb = self.tb data = 200*[0,] data[9] = 1 data[99] = 1 expected_result = 200*[0,] expected_result[9] = 1 expected_result[19] = 1 expected_result[29] = 1 expected_result[39] = 1 expected_result[99] = 1 expected_result[109] = 1 expected_result[119] = 1 expected_result[129] = 1 src = gr.vector_source_b(data, False) regen = gr.regenerate_bb(10, 3) dst = gr.vector_sink_b() tb.connect (src, regen) tb.connect (regen, dst) tb.run () dst_data = dst.data () self.assertEqual (tuple(expected_result), dst_data)
def test_001_t (self): """ First header: Packet length 4, packet num 0 Second header: Packet 2, packet num 1 Third header: Invalid (parity bit does not check) (would be len 4, num 2) """ encoded_headers = ( # | Number of bytes | Packet number | Parity 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ) packet_len_tagname = "packet_len" random_tag = gr.gr_tag_t() random_tag.offset = 5 random_tag.key = pmt.pmt_string_to_symbol("foo") random_tag.value = pmt.pmt_from_long(42) src = gr.vector_source_b(encoded_headers, tags=(random_tag,)) parser = digital.packet_headerparser_b(32, packet_len_tagname) sink = gr.message_debug() self.tb.connect(src, parser) self.tb.msg_connect(parser, "header_data", sink, "store") self.tb.start() time.sleep(1) self.tb.stop() self.tb.wait() self.assertEqual(sink.num_messages(), 3) msg1 = pmt.to_python(sink.get_message(0)) msg2 = pmt.to_python(sink.get_message(1)) msg3 = pmt.to_python(sink.get_message(2)) self.assertEqual(msg1, {'packet_len': 4, 'packet_num': 0, 'foo': 42}) self.assertEqual(msg2, {'packet_len': 2, 'packet_num': 1}) self.assertEqual(msg3, False)
def test_regen2(self): tb = self.tb data = 200 * [ 0, ] data[9] = 1 data[99] = 1 expected_result = 200 * [ 0, ] expected_result[9] = 1 expected_result[19] = 1 expected_result[29] = 1 expected_result[39] = 1 expected_result[99] = 1 expected_result[109] = 1 expected_result[119] = 1 expected_result[129] = 1 src = gr.vector_source_b(data, False) regen = blocks.regenerate_bb(10, 3) dst = gr.vector_sink_b() tb.connect(src, regen) tb.connect(regen, dst) tb.run() dst_data = dst.data() self.assertEqual(tuple(expected_result), dst_data)
def supply_rx_baseband(self): ## RX Spectrum if self.__dict__.has_key('rx_baseband'): return self.rx_baseband config = self.config fftlen = config.fft_length my_window = window.hamming(fftlen) #.blackmanharris(fftlen) rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen) rxs_trigger = gr.vector_source_b(concatenate([[1],[0]*199]),True) rxs_window = blocks.multiply_const_vcc(my_window) rxs_spectrum = gr.fft_vcc(fftlen,True,[],True) rxs_mag = gr.complex_to_mag(fftlen) rxs_avg = gr.single_pole_iir_filter_ff(0.01,fftlen) rxs_logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen)) rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,50) t = self.u if self.filter is None else self.filter self.connect(rxs_trigger,(rxs_sampler,1)) self.connect(t,rxs_sampler,rxs_window, rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate) if self._options.log: log_to_file(self, rxs_decimate_rate, "data/supply_rx.float") self.rx_baseband = rxs_decimate_rate return rxs_decimate_rate
def __init__(self): gr.top_block.__init__(self, "Many Rate Changing") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.random_source_x_0 = gr.vector_source_b( map(int, numpy.random.randint(0, 256, 1000)), True) self.gr_unpacked_to_packed_xx_0 = gr.unpacked_to_packed_bb( 2, gr.GR_LSB_FIRST) self.gr_packed_to_unpacked_xx_0 = gr.packed_to_unpacked_bb( 2, gr.GR_MSB_FIRST) self.gr_null_sink_0_2 = gr.null_sink(gr.sizeof_char * 1) self.blocks_float_to_char_0 = blocks.float_to_char(1, 1) self.blocks_char_to_float_0 = blocks.char_to_float(1, 1) ################################################## # Connections ################################################## self.connect((self.blocks_char_to_float_0, 0), (self.blocks_float_to_char_0, 0)) self.connect((self.blocks_float_to_char_0, 0), (self.gr_packed_to_unpacked_xx_0, 0)) self.connect((self.gr_unpacked_to_packed_xx_0, 0), (self.blocks_char_to_float_0, 0)) self.connect((self.random_source_x_0, 0), (self.gr_unpacked_to_packed_xx_0, 0)) self.connect((self.gr_packed_to_unpacked_xx_0, 0), (self.gr_null_sink_0_2, 0))
def __init__(self, constellation, differential, data_length=None, src_data=None): """ constellation -- a constellation object differential -- whether differential encoding is used data_length -- the number of bits of data to use src_data -- a list of the bits to use """ super(rec_test_tb, self).__init__() # Transmission Blocks if src_data is None: self.src_data = tuple([rndm.randint(0,1) for i in range(0, data_length)]) else: self.src_data = src_data packer = gr.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) src = gr.vector_source_b(self.src_data) mod = generic_mod(constellation, differential=differential) # Channel channel = gr.channel_model(NOISE_VOLTAGE, FREQUENCY_OFFSET, TIMING_OFFSET) # Receiver Blocks demod = generic_demod(constellation, differential=differential, freq_bw=FREQ_BW, phase_bw=PHASE_BW) self.dst = gr.vector_sink_b() self.connect(src, packer, mod, channel, demod, self.dst)
def __init__(self, constellation, differential, data_length=None, src_data=None): """ constellation -- a constellation object differential -- whether differential encoding is used data_length -- the number of bits of data to use src_data -- a list of the bits to use """ super(rec_test_tb, self).__init__() # Transmission Blocks if src_data is None: self.src_data = tuple( [random.randint(0, 1) for i in range(0, data_length)]) else: self.src_data = src_data packer = gr.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) src = gr.vector_source_b(self.src_data) mod = generic_mod(constellation, differential=differential) # Channel channel = gr.channel_model(NOISE_VOLTAGE, FREQUENCY_OFFSET, TIMING_OFFSET) # Receiver Blocks demod = generic_demod(constellation, differential=differential, freq_bw=FREQ_BW, phase_bw=PHASE_BW) self.dst = gr.vector_sink_b() self.connect(src, packer, mod, channel, demod, self.dst)
def test_300(self): input_data = (0,1,2,3,4,5,6,7,8,9) src = gr.vector_source_b(input_data) dst = gr.vector_sink_b() self.fg.connect(src, dst) self.fg.run() self.assertEquals(input_data, dst.data())
def main(): parser = OptionParser(conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") add_options(parser, expert_grp) (options, args) = parser.parse_args() fft_length = options.fft_length or 512 file = options.file or "input.compl" out = options.out or "output.compl" src = gr.file_source(gr.sizeof_gr_complex, file) sampler = ofdm.vector_sampler(gr.sizeof_gr_complex, fft_length) trig = gr.vector_source_b([1], True) fft = gr.fft_vcc(fft_length, True, [], True) mag = gr.complex_to_mag(fft_length) avg = gr.single_pole_iir_filter_ff(0.01, fft_length) nlog = gr.nlog10_ff(20, fft_length, -10 * math.log10(fft_length)) dst = gr.file_sink(gr.sizeof_float * fft_length, out) fg = gr.top_block() fg.connect(src, sampler, fft, mag, avg, nlog, dst) fg.connect(trig, (sampler, 1)) # fg.connect(src,limit, # gr.stream_to_vector(gr.sizeof_gr_complex,fft_length), # fft, # gr.multiply_const_vcc([1./fft_length]*fft_length), # gr.complex_to_mag(fft_length), # gr.nlog10_ff(10.0,fft_length), # dst) # fg.connect( src, fft, dst ) fg.run() print "done"
def test_loopback_rand_rs_int(self): """ Loopback of data, (de)randomiser, rs (en/de)coder, (de)interleaver """ src_data = make_transport_stream() # Disregard end bytes of source data, accounting for interleaver delay expected_delay = dvb_interleaver_bb.DELAY * \ dvb_swig.MPEG_TS_PKT_LENGTH / dvb_swig.DVB_RS_ENCODED_LENGTH expected_result = tuple(src_data[:-expected_delay]) src = gr.vector_source_b(src_data) txpad = dvb_swig.pad_mpeg_ts_packet_bp() randomizer = dvb_swig.randomizer_pp() rs_encoder = dvb_swig.rs_encoder_pp() txdepad = dvb_swig.depad_dvb_packet_rs_encoded_pb() interleaver = dvb_interleaver_bb.interleaver_bb() deinterleaver = dvb_interleaver_bb.deinterleaver_bb() rxpad = dvb_swig.pad_dvb_packet_rs_encoded_bp() rs_decoder = dvb_swig.rs_decoder_pp() derandomizer = dvb_swig.derandomizer_pp() rxdepad = dvb_swig.depad_mpeg_ts_packet_pb() dst = gr.vector_sink_b() # Connect and run self.tb.connect(src, txpad, randomizer, rs_encoder, txdepad, interleaver, deinterleaver) self.tb.connect(deinterleaver, rxpad, rs_decoder, derandomizer, rxdepad, dst) self.tb.run() # Check that the decoded bytes are the same as original self.assertEqual(expected_result, dst.data())
def setUp(self): print "qa_crc_calculator_vbvb START" self.tb = gr.top_block() # Read in binary Matlab data from viterbi decoder output. vit = scipy.io.loadmat('/home/demel/exchange/matlab_vit.mat') mat_u = range(40) mat_u = tuple(vit['vit'].flatten()) mat_vit = range(40) for i in mat_vit: mat_vit[i] = int(mat_u[i]) mat_vit = tuple(mat_vit) self.in_data = mat_vit intu = mat_vit self.src = gr.vector_source_b(intu, False, 40) #self.conv = gr.float_to_char(24,1) print type(intu[8]) print type(intu) print intu crc_poly = (1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1) init_state = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) final_xor1 = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) final_xor2 = (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) final_xor4 = (0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1) block_len = 24 self.crc = lte_swig.crc_calculator_vbvb( ) #crc_poly,init_state,final_xor1,block_len) self.snk = gr.vector_sink_b(24) self.snk2 = gr.vector_sink_b(1) self.tb.connect(self.src, (self.crc, 0), self.snk) self.tb.connect((self.crc, 1), self.snk2)