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() )
Ejemplo n.º 3
0
    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)
Ejemplo n.º 4
0
    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))
Ejemplo n.º 5
0
 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"))
Ejemplo n.º 9
0
	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):])
Ejemplo n.º 10
0
    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))
Ejemplo n.º 11
0
	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
Ejemplo n.º 12
0
	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)
Ejemplo n.º 13
0
	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)
Ejemplo n.º 14
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
Ejemplo n.º 15
0
 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())
Ejemplo n.º 16
0
	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)
Ejemplo n.º 17
0
    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)
Ejemplo n.º 18
0
 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())
Ejemplo n.º 19
0
    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)
Ejemplo n.º 20
0
    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)
Ejemplo n.º 21
0
 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)
Ejemplo n.º 22
0
    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))
Ejemplo n.º 24
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())
Ejemplo n.º 25
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)
Ejemplo n.º 26
0
  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"
Ejemplo n.º 27
0
 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})
Ejemplo n.º 28
0
	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))
Ejemplo n.º 29
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)
Ejemplo n.º 30
0
 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)
Ejemplo n.º 31
0
    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)
Ejemplo n.º 32
0
    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)
Ejemplo n.º 33
0
	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))
Ejemplo n.º 34
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)
Ejemplo n.º 35
0
  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)
Ejemplo n.º 37
0
    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)
Ejemplo n.º 39
0
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
Ejemplo n.º 40
0
    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)
Ejemplo n.º 41
0
    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)
Ejemplo n.º 42
0
    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)
Ejemplo n.º 43
0
  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))
Ejemplo n.º 45
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)
Ejemplo n.º 46
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(
             [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())
Ejemplo n.º 48
0
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"
Ejemplo n.º 49
0
	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())
Ejemplo n.º 50
0
    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)