Beispiel #1
0
  def __init__(self, options):

    ofdm = ofdm_rxtx.TX(options)
    qam = raw.qam_tx(options.bitrate, ofdm.params.data_tones, ofdm.size, log=options.log)

    framebytes = qam.framebytes
    if options.crc:
      framebytes = 188

    gr.hier_block2.__init__(self, "TX",
      gr.io_signature(1,1, gr.sizeof_char * framebytes),
      gr.io_signature(1,1, gr.sizeof_gr_complex))

    qam_in = gr.vector_to_stream(gr.sizeof_char, qam.framebytes)

    if options.crc:
      self.connect(self,
                   raw.crc_enc(framebytes),
                   gr.vector_to_stream(gr.sizeof_char, framebytes + 4),
                   qam)
    else:
      self.connect(self,
                   gr.vector_to_stream(gr.sizeof_char, qam.framebytes),
                   qam)

    self.connect(qam,
                 gr.stream_to_vector(gr.sizeof_gr_complex, ofdm.params.data_tones),
                 ofdm,
                 self)

    self.ofdm = ofdm
    self.qam = qam
    self.framebytes = framebytes
Beispiel #2
0
    def setup_flowgraph(self):

        options = self.options

        # Attempt to enable realtime scheduling
        if options.realtime:
            r = gr.enable_realtime_scheduling()
            if r == gr.RT_OK:
                options.realtime = True
                print >> sys.stderr, "Realtime scheduling ENABLED"
            else:
                options.realtime = False
                print >> sys.stderr, "Realtime scheduling FAILED"

        self.setup_timing()

        # Setup our input source
        if options.inputfile:
            self.using_usrp = False
            print >> sys.stderr, "Reading data from: " + options.inputfile
            self.source = gr.file_source(gr.sizeof_gr_complex,
                                         options.inputfile, options.fileloop)
        else:
            self.using_usrp = True
            self.setup_usrp()

        self.setup_filter()

        #create a tuner callback
        self.mean_offset = 0.0  #this is set by tuner callback
        self.burst_cb = burst_callback(self)

        # Setup flow based on decoder selection
        #	if options.decoder.count("c"):
        self.setup_c_flowgraph()
        #	elif options.decoder.count("f"):
        #		self.setup_f_flowgraph()

        self.configure_burst_decoder()

        #Hookup a vector-stream converter if we want burst output
        if self.scopes.count("b") or options.outputfile:
            self.v2s = gr.vector_to_stream(
                gr.sizeof_float, 142)  #burst output is 142 (USEFUL_BITS)
            self.connect(self.burst, self.v2s)
        else:
            self.burst_sink = gr.null_sink(gr.sizeof_float)
            self.v2s = gr.vector_to_stream(
                gr.sizeof_float, 142)  #burst output is 142 (USEFUL_BITS)
            self.connect(self.burst, self.v2s)
            self.connect(self.v2s, self.burst_sink)

        #Output file
        if options.outputfile:
            self.filesink = gr.file_sink(gr.sizeof_float, options.outputfile)
            self.connect(self.v2s, self.filesink)
	def setup_flowgraph(self):

		options = self.options
		
		# Attempt to enable realtime scheduling
		if options.realtime:
			r = gr.enable_realtime_scheduling()
			if r == gr.RT_OK:
				options.realtime = True
				print >> sys.stderr, "Realtime scheduling ENABLED"
			else:
				options.realtime = False
				print >> sys.stderr, "Realtime scheduling FAILED"

		self.setup_timing()
		
		# Setup our input source
		if options.inputfile:
			self.using_usrp = False
			print >> sys.stderr, "Reading data from: " + options.inputfile
			self.source = gr.file_source(gr.sizeof_gr_complex, options.inputfile, options.fileloop)
		else:
			self.using_usrp = True
			#self.setup_usrp()

		self.setup_filter()

		#create a tuner callback
		self.mean_offset = 0.0		#this is set by tuner callback
		self.burst_cb = burst_callback(self)

		# Setup flow based on decoder selection
	#	if options.decoder.count("c"):
		self.setup_c_flowgraph()
	#	elif options.decoder.count("f"):
	#		self.setup_f_flowgraph()

		self.configure_burst_decoder()
		
		#Hookup a vector-stream converter if we want burst output
		if self.scopes.count("b") or options.outputfile:
			self.v2s = gr.vector_to_stream(gr.sizeof_float,142)		#burst output is 142 (USEFUL_BITS)
			self.connect(self.burst, self.v2s)
		else:
			self.burst_sink = gr.null_sink(gr.sizeof_float)
			self.v2s = gr.vector_to_stream(gr.sizeof_float,142)		#burst output is 142 (USEFUL_BITS)
			self.connect(self.burst, self.v2s)
			self.connect(self.v2s, self.burst_sink)


		#Output file
		if options.outputfile:
			self.filesink = gr.file_sink(gr.sizeof_float, options.outputfile)
			self.connect(self.v2s, self.filesink)
  def test_001(self):
    frames = 5
    config = station_configuration()
    config.subcarriers = 12
    config.data_subcarriers = 8

    config.training_data = dummy()
    config.training_data.shifted_pilot_tones = [1,4,8,11]

    data =  [1.0] * config.subcarriers
    for x in config.training_data.shifted_pilot_tones:
      data[x] = 2.0
    data = concatenate([data]*frames)

    ref = [1.0]*(config.data_subcarriers*frames)

    src = gr.vector_source_c(data)
    s2v = gr.stream_to_vector(gr.sizeof_gr_complex,config.subcarriers)
    dst = gr.vector_sink_c()
    v2s = gr.vector_to_stream(gr.sizeof_gr_complex,config.data_subcarriers)

    uut = preambles.pilot_subcarrier_filter()
    self.fg.connect(src,s2v,uut,v2s,dst)

    self.fg.run()
    self.assertEqual(ref,list(dst.data()))
Beispiel #5
0
 def setUp (self):
 
     #print os.getpid()
     #raw_input("press the any key")
     
     self.tb = gr.top_block ()
     
     offset = 43223  #sample15 = 21839 #sample20 = 43223
     fftl = 512
     cpl = 144*fftl/2048
     cpl0 = 160*fftl/2048
     slotl = 7*fftl+6*cpl+cpl0
     cell_id = 124
     N_rb_dl = 6
     
     mod=scipy.io.loadmat('/home/demel/exchange/matlab_test_first_freq.mat') 
     mat_u1=tuple(mod['test'].flatten())
     mat_d=range(len(mat_u1))
     for idx, val in enumerate(mat_u1):
         mat_d[idx]=val
     intu=tuple(mat_d[0:slotl*60])
     
     self.src  = gr.vector_source_c(intu,False,1)
     self.tag  = lte.tag_symbol_cc(offset,fftl)
     #self.head = gr.head(gr.sizeof_gr_complex,70000)
     self.sel = lte.sss_selector_cvc(fftl)
     self.vtos = gr.vector_to_stream(gr.sizeof_gr_complex,512)
     self.snk = gr.vector_sink_c(1)
     
     self.tb.connect(self.src,self.tag,self.sel,self.vtos,self.snk)#,self.head
Beispiel #6
0
    def test_014_bonder_vbb(self):
        #################################
        src_data_0 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

        ################################
        expected_result_0 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

        #################################

        # Objekte erzeugen
        src_0 = gr.vector_source_f(src_data_0)
        throttle_0 = gr.throttle(gr.sizeof_float * 1, 320000)
        s2v_0 = gr.stream_to_vector(gr.sizeof_float, 2)
        bonder = howto_swig.bonder_vff(2, 6)
        v2s_0 = gr.vector_to_stream(gr.sizeof_float, 6)
        dst_0 = gr.vector_sink_f()

        # Objekte verbinden
        self.tb.connect(src_0, throttle_0, s2v_0, bonder, v2s_0, dst_0)

        # Simulationsstart
        self.tb.run()

        # Ergebnis auswerten
        result_data0 = dst_0.data()
        self.assertEqual(expected_result_0, result_data0)
    def test_003(self):
        # Need to add padding
        padding = tuple([0 for i in range(29)])

        scale = 2
        vlen = 3
        src_data = (0.0, 1.1, 2.2,) + padding + \
                   (3.2, 4.2, 5.5,) + padding + \
                   (-1.1, -2.2, -3.2,) + padding
        expected_result = [0, 2, 4]
        expected_result.extend(padding)
        expected_result.extend([6, 8, 11])
        expected_result.extend(padding)
        expected_result.extend([-2, -4, -6])
        expected_result.extend(padding)

        src = gr.vector_source_f(src_data)
        s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
        op = gr.float_to_char(vlen, scale)
        v2s = gr.vector_to_stream(gr.sizeof_char, vlen)
        dst = gr.vector_sink_c()

        self.tb.connect(src, s2v, op, v2s, dst)
        self.tb.run()
        result_data = list(dst.data())

        self.assertEqual(expected_result, result_data)
    def test_003(self):
        # Need to add padding to keep proper alignment
        padding = tuple([0 for i in range(5)])

        scale = 2
        vlen = 3
        src_data = (0.0, 1.1, 2.2) + padding + (3.3, 4.4, 5.5) + padding + (-1.1, -2.2, -3.3) + padding
        expected_result = [0, 2, 4]
        expected_result.extend(padding)
        expected_result.extend([7, 9, 11])
        expected_result.extend(padding)
        expected_result.extend([-2, -4, -7])
        expected_result.extend(padding)

        src = gr.vector_source_f(src_data)
        s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
        op = gr.float_to_int(vlen, scale)
        v2s = gr.vector_to_stream(gr.sizeof_int, vlen)
        dst = gr.vector_sink_i()

        self.tb.connect(src, s2v, op, v2s, dst)
        self.tb.run()
        result_data = list(dst.data())

        self.assertEqual(expected_result, result_data)
Beispiel #9
0
	def test_001_diff_phasor_vcc(self):
		a = [1+2j,2+3.5j,3.5+4j,4+5j,5+6j]
		b = [1j,1j,1j,1j,1j]
		c = [-1j+3,1j,-7+0j,2.5j+0.333,3.2j]
		d = [(0.35979271051026462+0.89414454782483865j),
		     (0.19421665709046287+0.024219594550527801j),
		     (0.12445564785882557+0.40766238899138718j),
		     (0.041869638845043688+0.97860437393366329j),
		     (0.068927762235083234+0.16649764877365247j)]
		e = [(0.16207552830286298+0.435385030608331j),
		     (0.47195779613669675+0.37824764113272558j),
		     (0.13911998015446148+0.6585095669811617j),
		     (0.093510743358783954+0.98446560079828938j),
		     (0.86036393297704694+0.72043005342024602j)]
		multconj = lambda x,y: x.conjugate()*y
		src_data        = a+b+c+d+e
		expected_result = [0j,0j,0j,0j,0j]+map(multconj,a,b)+map(multconj,b,c)+map(multconj,c,d)+map(multconj,d,e)
		src = gr.vector_source_c(src_data)
		s2v = gr.stream_to_vector(gr.sizeof_gr_complex, 5)
		diff_phasor_vcc = dab_swig.diff_phasor_vcc(5)
		v2s = gr.vector_to_stream(gr.sizeof_gr_complex, 5)
		dst = gr.vector_sink_c()
		self.tb.connect(src, s2v, diff_phasor_vcc, v2s, dst)
		self.tb.run()
		result_data = dst.data()
		# print expected_result
		# print result_data
		self.assertComplexTuplesAlmostEqual(expected_result, result_data, 6)
Beispiel #10
0
 def test_001 (self):
   vlen = 128
   syms = 4
   
   freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0/vlen)
   
   fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
   ifft = gr.fft_vcc(vlen, False, [], True)
   fft_scale = gr.multiply_const_vcc([1.0/vlen]*vlen)
       
   vec = numpy.array(numpy.zeros(vlen), numpy.complex)
   vec[vlen/2-vlen/4] = 1.0
   vec = concatenate([vec]*syms)
   
   src = gr.vector_source_c(vec)
   dst = gr.vector_sink_c()
   s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
   v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
   
   eps = gr.vector_source_f([0.0]*syms)
   trig = gr.vector_source_b([1]*syms)
   
   self.fg.connect(src, s2v, ifft, (freq_shift,0))
   self.fg.connect(eps, (freq_shift,1))
   self.fg.connect(trig, (freq_shift,2))
   self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
   self.fg.run()
   
   self.assertComplexTuplesAlmostEqual(vec, numpy.array(dst.data()))
Beispiel #11
0
    def test_007(self):
        vlen = 128
        syms = 4
        bin1 = vlen / 2 + 2
        bin1_val = 1.0

        expec = numpy.array(numpy.zeros(vlen), numpy.complex)
        expec[bin1] = bin1_val
        expec = concatenate([expec] * syms)

        epsilon = [0.5]
        frame_trigger = numpy.concatenate([[1], [0] * (syms - 1)])

        freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen)

        fft = gr.fft_vcc(vlen, True, [], True)  # natural order, dc = vlen / 2
        fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen)

        src = gr.sig_source_c(vlen, gr.GR_COS_WAVE, 1.5, 1.0, 0.0)
        # bin vlen/2 + 1.5
        dst = gr.vector_sink_c()
        s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
        v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)

        eps = gr.vector_source_f(epsilon)
        trig = gr.vector_source_b(frame_trigger.tolist())

        self.fg.connect(src, s2v, (freq_shift, 0))
        self.fg.connect(eps, (freq_shift, 1))
        self.fg.connect(trig, (freq_shift, 2))
        self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
        self.fg.run()

        self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5, 1e-5)
Beispiel #12
0
  def test_007 (self):
    vlen = 128
    syms = 4
    bin1 = vlen/2 + 2
    bin1_val = 1.0
        
    expec = numpy.array(numpy.zeros(vlen), numpy.complex)
    expec[bin1] = bin1_val
    expec = concatenate([expec]*syms)
    
    epsilon = [0.5]
    frame_trigger = numpy.concatenate([[1],[0]*(syms-1)])
    
    freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0/vlen)
    
    fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
    fft_scale = gr.multiply_const_vcc([1.0/vlen]*vlen)    
    
    src = gr.sig_source_c(vlen, gr.GR_COS_WAVE, 1.5, 1.0, 0.0) 
    # bin vlen/2 + 1.5
    dst = gr.vector_sink_c()
    s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
    v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
    
    eps = gr.vector_source_f(epsilon)
    trig = gr.vector_source_b(frame_trigger.tolist())
    
    self.fg.connect(src, s2v, (freq_shift,0))
    self.fg.connect(eps, (freq_shift,1))
    self.fg.connect(trig, (freq_shift,2))
    self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
    self.fg.run()

    self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5, 1e-5)  
Beispiel #13
0
    def __init__(self, vlen, channel_block, delay):
        gr.hier_block2.__init__(self, 'apply_channel_to_vect',
                gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen),
                gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen))

        self.vlen=vlen
        self.channel_block = channel_block
        self.delay = delay

        pad_len = self.vlen + self.delay*2

        if(delay>0):
            self.padding = gr.vector_source_c((0,)*(delay*2),True,delay*2)
            self.pad_cat = mlse.vector_concat_vv(vlen*gr.sizeof_gr_complex,gr.sizeof_gr_complex*2*delay)
            self.connect(self, self.pad_cat)
            self.connect(self.padding, (self.pad_cat,1))
        else:
            self.pad_cat = self 

        self.tostream = gr.vector_to_stream(gr.sizeof_gr_complex, pad_len)
        self.connect(self.pad_cat, self.tostream)

        # connect channel
        self.connect(self.tostream, self.channel_block)

        self.tovector = gr.stream_to_vector(gr.sizeof_gr_complex, pad_len)
        self.connect(self.channel_block, self.tovector)

        # cut out the proper part 
        self.trim = mlse.vector_slice_vv(
                gr.sizeof_gr_complex, 
                pad_len, 
                delay,
                vlen)
        self.connect(self.tovector, self.trim, self)
Beispiel #14
0
 def test_004_de_diff_mod_vcc (self):
     #################################
     # Testsequenz generieren
     src_data =        (1+0j, 0+2j, 0-0j, 0+1j, 2+0j, 0+0j,-1+0j,2+0j,-0+0j)
     #################################
     # Ergebnis generieren
     expected_result_0 = (0+0j, 0+0j, 0-0j, 0+1j, 0-4j, 0-0j, 0+1j, 4+0j, 0+0j)
     expected_result_1 = (0+0j, 0-4j, 4+0j)
     #################################
     
     # Objekte erzeugen
     src = gr.vector_source_c (src_data)
     s2v = gr.stream_to_vector(gr.sizeof_gr_complex, 3)
     diff = howto_swig.de_diff_mod_vcc(3,1)
     v2s = gr.vector_to_stream(gr.sizeof_gr_complex, 3)
     dst0 = gr.vector_sink_c()
     dst1 = gr.vector_sink_c()
     
     # Objekte verbinden
     self.tb.connect(src, s2v, (diff,0), v2s, dst0)
     self.tb.connect((diff,1), dst1)
     
     # Simulationsstart
     self.tb.run ()
     
     # Ergebnis auswerten
     result_data0 = dst0.data ()
     result_data1 = dst1.data ()
     self.assertComplexTuplesAlmostEqual (expected_result_0, result_data0, 6)
     self.assertComplexTuplesAlmostEqual (expected_result_1, result_data1, 6)
Beispiel #15
0
    def test_001_cutter_vbb(self):
        #################################
        # Testsequenz generieren
        src_data_0 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

        ################################
        # Ergebnis generieren
        expected_result_0 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

        #################################

        # Objekte erzeugen
        src_0 = gr.vector_source_b(src_data_0)
        throttle_0 = gr.throttle(gr.sizeof_char * 1, 320000)
        s2v_0 = gr.stream_to_vector(gr.sizeof_char, 6)
        cutter = howto_swig.cutter_vbb(6, 2)
        v2s_0 = gr.vector_to_stream(gr.sizeof_char, 2)
        dst_0 = gr.vector_sink_b()

        self.tb.connect(src_0, throttle_0, s2v_0, cutter, v2s_0, dst_0)

        self.tb.run()

        result_data0 = dst_0.data()
        self.assertEqual(expected_result_0, result_data0)
    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)
Beispiel #17
0
 def test_011_viterbi_test (self):
     #################################
     # Matlab Viterbi Testsequenz
     src_data_0 = (6.10,7.11,14.37,0.00,18.13,3.16,12.13,0.00,10.83,21.49,19.65,0.00,24.97,13.57,11.37,0.00,0.61,7.21,23.30,0.00,19.04,20.74,10.53,0.00,-3.65,-12.64,-26.67,0.00,10.62,-4.62,-14.32,0.00,10.05,10.80,-3.46,0.00,-13.44,5.20,-3.91,0.00,16.34,8.40,16.89,0.00,-1.75,-11.33,7.98,0.00,-6.68,6.79,4.78,0.00,14.16,14.18,6.76,0.00,16.59,-17.25,0.88,0.00,-10.88,-5.10,5.58,0.00,24.01,-13.35,10.51,0.00,11.26,-8.15,-5.66,0.00,-18.93,-3.86,13.61,0.00,-6.00,-13.72,7.79,0.00,10.92,13.47,10.58,0.00,13.48,-19.71,-14.66,0.00,-9.00,-3.13,-14.41,0.00,19.08,13.96,2.32,0.00,-12.29,-14.80,7.14,0.00,-10.17,11.90,12.99,0.00,-17.15,-15.61,14.06,0.00,-4.01,-29.32,10.65,0.00,-1.95,-5.50,-20.98,0.00,6.02,3.05,1.87,0.00,-7.55,-8.47,11.30,0.00,8.71,-1.94,3.38,0.00,2.87,-8.22,20.77,0.00,-11.54,-28.61,-8.87,0.00,-2.04,8.53,-4.38,0.00,17.10,-9.31,24.04,0.00,-11.07,-6.60,9.39,0.00,2.41,-1.03,-7.61,0.00,6.66,-4.19,12.54,0.00,-1.62,16.44,-9.85,0.00,-35.20,8.52,22.23,0.00,-5.33,20.10,-5.98,0.00,14.11,0.61,1.56,0.00,-8.76,-12.88,8.13,0.00,1.09,-19.52,15.89,0.00,20.90,-20.31,-15.97,0.00,-11.83,-12.27,-0.53,0.00,12.26,18.42,-11.01,0.00,-15.33,-7.92,-8.68,0.00,-10.56,-4.28,-3.37,0.00,-4.08,20.17,18.25,0.00,-22.93,10.72,16.22,0.00,23.35,21.93,3.91,0.00,-15.13,9.69,6.14,0.00,-7.97,13.64,3.36,0.00,17.49,2.76,8.93,0.00,-1.04,1.52,6.09,0.00,-9.85,20.94,14.51,0.00,30.77,2.21,14.93,0.00,1.65,-11.99,-10.15,0.00,-6.84,-7.58,-14.90,0.00,15.78,3.11,-4.94,0.00,10.68,25.81,-15.91,0.00,-2.15,15.15,5.80,0.00,-5.79,-16.44,13.01,0.00,8.91,7.15,7.54,0.00,15.27,-8.36,-9.58,0.00,-13.68,-4.94,10.56,0.00,-0.51,-7.36,-8.21,0.00,9.69,6.69,-10.96,0.00,5.83,10.17,4.06,0.00,22.13,-3.77,7.71,0.00,-5.97,-11.88,18.97,0.00,-6.80,15.29,20.14,0.00,-22.25,-4.53,-25.46,0.00,4.04,7.63,9.11,0.00,31.27,11.59,15.90,0.00,-14.39,-16.64,-7.78,0.00,17.13,-12.89,-7.93,0.00,-1.35,-26.56,11.43,0.00,-8.34,-13.67,7.63,0.00,14.59,5.34,-9.26,0.00,11.09,-10.86,-7.98,0.00,-3.41,18.91,8.10,0.00,4.80,0.85,-9.15,0.00,15.15,-15.19,10.12,0.00,2.81,-9.31,-0.66,0.00,2.39,3.08,10.51,0.00,9.41,-7.17,24.47,0.00,-10.28,-14.54,5.16,0.00,-23.50,13.94,-4.41,0.00,-11.50,-12.98,-11.52,0.00,7.96,-2.81,-8.01,0.00,-12.00,-0.85,9.06,0.00,-15.33,-6.42,-9.17,0.00,-20.85,-16.52,10.77,0.00,9.60,-20.00,-5.21,0.00,-13.22,1.68,15.86,0.00,1.24,22.38,9.85,0.00,9.24,-11.78,11.57,0.00,22.88,4.69,1.87,0.00,-1.52,-1.23,13.71,0.00,-10.35,28.43,-3.10,0.00,6.26,3.16,0.70,0.00,10.48,23.87,-15.81,0.00,12.97,15.49,16.29,0.00,14.15,-7.14,13.82,0.00,-2.81,-21.34,3.35,0.00,-4.55,3.14,6.03,0.00,-8.68,-36.42,-9.37,0.00,1.43,3.50,8.11,0.00,-2.87,-12.40,-4.15,0.00,-12.57,4.36,25.12,0.00,-7.36,17.17,-6.14,0.00,11.76,13.23,9.07,0.00,8.15,11.87,21.04,0.00,-9.05,-10.14,8.17,0.00,-3.56,10.56,-16.68,0.00,1.40,13.47,-16.17,0.00,11.59,3.32,-7.21,0.00,7.50,-12.02,-10.73,0.00,-22.25,10.72,9.96,0.00,-11.81,-2.41,8.60,0.00,17.73,10.29,-18.72,0.00,-9.52,8.01,-11.69,0.00,-2.50,-3.66,2.20,0.00,3.08,-21.95,-12.21,0.00,10.79,-26.07,8.52,0.00,-6.39,8.58,-14.17,0.00,8.98,-1.47,-1.91,0.00,-17.36,-6.53,3.86,0.00,-8.98,-18.15,4.99,0.00,-14.42,-19.02,-3.08,0.00,8.92,3.30,17.09,0.00,35.91,4.14,-7.48,0.00,-9.46,-9.49,0.65,0.00,-13.60,-12.13,-13.08,0.00,-14.48,-9.42,-11.51,0.00,-15.75,5.79,-8.93,0.00,-21.91,3.75,7.55,0.00,-26.59,4.90,5.46,0.00,-21.95,-2.00,15.01,0.00,1.95,8.13,-7.75,0.00,15.40,-3.06,0.28,0.00,-12.07,19.42,-16.81,0.00,7.35,-11.43,5.85,0.00,2.88,8.45,10.39,0.00,-14.39,-11.50,3.49,0.00,-8.89,8.83,4.91,0.00,14.71,2.32,14.16,0.00,9.87,-12.13,1.55,0.00,-15.27,-15.73,4.59,0.00,-13.15,8.11,-5.06,0.00,6.89,22.04,11.72,0.00,-21.54,-18.02,-8.12,0.00,-9.41,6.84,8.30,0.00,21.41,-7.08,-9.33,0.00,8.34,-9.89,-7.27,0.00,13.36,-5.71,18.51,0.00,10.31,-9.40,11.60,0.00,34.06,4.22,-18.35,0.00,-17.65,-18.96,-6.60,0.00,-9.40,-12.03,-2.93,0.00,8.54,-9.98,11.84,0.00,6.00,13.27,15.54,0.00,5.04,7.77,-1.80,0.00,2.07,15.19,-4.99,0.00,-12.38,8.71,-10.13,0.00,-7.99,-3.48,9.71,0.00,6.36,-6.29,-20.77,0.00,11.50,-7.51,6.06,0.00,-10.82,2.35,-5.31,0.00,-9.59,21.47,12.62,0.00,13.47,-8.04,15.76,0.00,-11.90,1.76,14.60,0.00,23.80,-16.77,-19.82,0.00,-8.35,6.00,-18.57,0.00,-13.57,-17.68,-19.84,0.00,10.00,-7.87,-9.05,0.00,12.58,6.23,17.57,0.00,-15.58,25.38,15.68,0.00,-3.96,15.09,7.94,0.00,-26.06,-7.72,-12.39,0.00,-6.65,-9.62,-10.31,0.00,12.46,-11.70,2.49,0.00,-11.44,-10.44,6.96,0.00,15.49,-14.99,12.62,0.00,6.91,-15.06,-9.04,0.00,-2.55,-13.63,10.27,0.00,27.95,3.21,-1.62,0.00,-15.52,11.13,4.41,0.00,11.22,7.92,-13.12,0.00,8.28,-6.33,-10.94,0.00,17.73,-5.05,10.03,0.00,-17.31,2.50,26.21,0.00,9.12,-20.21,-11.16,0.00,-12.77,16.14,-17.18,0.00,12.48,2.02,4.44,0.00,9.77,10.63,16.32,0.00,13.49,7.65,-1.75,0.00,-9.34,-1.29,21.86,0.00,26.00,1.23,23.37,0.00,-18.51,11.90,13.84,0.00,5.51,-18.28,-9.38,0.00,17.79,-8.54,14.96,0.00,-8.97,12.81,-7.70,0.00,-3.43,6.51,-7.64,0.00,-11.28,11.94,-11.32,0.00,21.17,-17.99,-4.99,0.00,6.19,6.62,14.13,0.00,-18.00,20.57,-7.63,0.00,8.34,-8.13,8.03,0.00,13.48,10.22,8.81,0.00,-4.21,-12.28,-10.53,0.00,7.31,-6.89,-16.45,0.00,-7.01,-11.17,-7.34,0.00,-9.81,-12.33,6.40,0.00,-9.98,12.96,-2.37,0.00,8.89,11.78,-2.87,0.00,23.69,9.57,-3.80,0.00,-4.11,21.25,9.48,0.00,7.04,13.89,1.87,0.00,-24.54,7.15,7.67,0.00,7.65,-11.11,3.47,0.00,10.42,-9.91,-1.98,0.00,-14.40,-1.61,20.83,0.00,20.47,10.08,31.24,0.00,-6.38,11.93,7.53,0.00,-13.44,4.55,-24.33,0.00,-8.88,-13.83,19.32,0.00,-16.57,6.90,4.06,0.00,-6.37,-25.32,-3.93,0.00,0.80,24.23,11.69,0.00,11.35,12.33,14.84,0.00,-4.95,-32.65,-8.25,0.00,9.27,-8.83,-5.68,0.00,-12.40,-9.31,11.87,0.00,14.25,14.49,-13.79,0.00,-13.85,12.86,-13.49,0.00,17.06,3.79,-8.20,0.00,-3.45,-6.10,-5.95,0.00,-13.15,-10.06,-10.93,0.00,18.64,-8.79,10.67,0.00,-5.09,-5.43,-0.23,0.00,13.75,-26.29,10.48,0.00,30.32,4.71,4.24,0.00,17.36,7.74,10.56,0.00,-1.94,-13.34,23.24,0.00,-0.74,18.54,-3.37,0.00,14.65,13.51,-14.69,0.00,-14.38,-15.24,10.92,0.00,-10.33,-8.51,-12.22,0.00,-24.09,-0.45,28.45,0.00,-13.65,17.67,-13.14,0.00,19.70,0.76,2.01,0.00,20.39,11.03,-7.79,0.00,-19.49,-21.86,-15.03,0.00,-8.97,-19.89,15.99,0.00,1.13,-30.56,-2.11,0.00,-2.07,3.48,11.71,0.00,-8.65,-1.82,-13.44,0.00,2.04,5.78,-13.08,0.00,11.85,5.93,-16.99,0.00,-28.90,9.54,23.02,0.00,-20.76,-14.48,5.51,0.00,5.52,4.91,14.65,0.00,-13.76,19.55,11.71,0.00,14.91,-22.55,2.56,0.00,-13.51,4.61,-22.87,0.00,-7.15,14.54,-3.19,0.00,13.92,-16.96,2.75,0.00,-3.61,-10.43,-16.55,0.00,5.06,-16.05,10.29,0.00,19.66,13.49,-8.63,0.00,15.30,12.81,13.74,0.00,3.97,-9.38,11.11,0.00,-18.28,-8.55,-8.49,0.00,-7.80,10.93,25.23,0.00,17.52,-18.41,-15.40,0.00,8.15,-21.36,17.28,0.00,-5.12,17.34,-12.89,0.00,-6.52,11.69,-28.40,0.00,-13.48,11.34,-21.74,0.00,13.18,-6.54,-17.74,0.00,5.54,30.61,5.47,0.00,15.93,-13.61,15.29,0.00,16.14,10.96,-8.18,0.00,-7.52,-4.84,13.06,0.00,17.46,10.65,-12.91,0.00,-8.62,13.11,-18.42,0.00,-22.99,-14.10,-10.73,0.00,-14.76,14.18,5.68,0.00,-6.13,13.16,-21.40,0.00,22.83,30.46,-3.56,0.00,-19.41,-13.17,-8.98,0.00,-11.71,-14.57,1.83,0.00,10.11,-25.61,16.48,0.00,-16.77,6.68,8.12,0.00,-23.66,8.51,13.06,0.00,26.88,15.51,4.13,0.00,9.10,-8.13,3.50,0.00,-7.77,-4.78,-6.69,0.00,-1.75,12.73,-11.83,0.00,12.28,-4.31,-26.17,0.00,-6.01,-12.84,17.11,0.00,5.64,26.76,14.41,0.00,12.90,-7.61,-9.63,0.00,13.24,10.44,-9.54,0.00,3.05,-5.53,-9.78,0.00,-5.76,8.89,14.20,0.00,-13.00,-14.11,-12.57,0.00,-5.28,-7.83,2.20,0.00,18.67,-11.70,7.02,0.00,-5.49,4.24,-17.36,0.00,-5.49,13.32,8.33,0.00,-10.86,9.50,8.33,0.00,-23.80,-17.43,-24.04,0.00,6.33,2.71,-3.97,0.00,7.55,11.74,-5.99,0.00,1.52,-15.62,-10.18,0.00,23.80,-5.64,15.31,0.00,-10.41,7.86,-1.33,0.00,-16.93,10.24,11.83,0.00,-16.11,15.05,-8.87,0.00,-5.06,-9.78,-32.81,0.00,-13.95,18.20,-8.33,0.00,-3.70,26.07,5.79,0.00,-2.39,19.30,-2.49,0.00,-3.78,-12.75,8.33,0.00,-15.44,11.57,-3.77,0.00,17.69,17.87,1.05,0.00,8.85,19.30,7.07,0.00,10.67,15.18,1.80,0.00,10.45,10.32,-10.76,0.00,17.16,4.43,17.66,0.00,-17.79,7.82,10.82,0.00,-19.37,13.70,-7.73,0.00,-8.58,-17.83,8.39,0.00,-12.27,12.98,5.72,0.00,20.93,17.90,7.82,0.00,-4.49,16.71,22.01,0.00,-6.07,3.20,-25.23,0.00,-20.65,-11.66,-3.48,0.00,-14.34,15.00,8.62,0.00,-21.27,16.29,8.49,0.00,22.34,24.45,-5.74,0.00,23.68,-7.32,-5.75,0.00,7.23,-10.39,-1.27,0.00,-0.67,1.55,3.91,0.00,12.17,10.17,18.50,0.00,-25.41,8.83,2.71,0.00,-15.53,5.40,5.46,0.00,-13.52,-13.86,-1.48,0.00,8.01,5.63,3.91,0.00,2.02,5.85,-5.33,0.00,-9.42,-12.67,-15.61,0.00,-14.33,-13.10,-7.68,0.00,2.81,-5.52,-12.57,0.00,9.22,18.92,13.12,0.00,-2.78,6.04,-9.31,0.00,17.56,-6.76,-11.39,0.00,11.49,7.68,9.73,0.00,8.27,-2.46,-6.43,0.00,1.80,19.12,-7.74,0.00,17.85,-17.11,11.51,0.00,-28.43,22.83,19.88,0.00,9.44,-6.70,-11.09,0.00,9.33,-19.32,-14.48,0.00,-23.05,10.32,26.66,0.00,9.71,11.75,-1.88,0.00,-10.19,5.44,18.02,0.00,7.72,13.54,10.42,0.00,2.72,-0.99,6.43,0.00,-4.85,-13.87,17.20,0.00,-13.54,13.48,-8.38,0.00,-9.87,-12.94,-22.09,0.00,11.85,-7.90,-1.60,0.00,-13.80,-23.10,12.48,0.00,-13.46,-7.88,-15.08,0.00,18.30,16.13,-18.17,0.00,-17.26,-1.09,-11.89,0.00,1.46,9.64,-8.66,0.00,12.53,3.12,11.93,0.00,14.62,-16.32,9.55,0.00,-14.04,-8.31,7.96,0.00,-14.39,9.22,9.54,0.00,-4.51,-5.79,-7.73,0.00,-11.53,-20.21,-8.32,0.00,1.49,-18.82,-1.47,0.00,4.11,17.75,-5.36,0.00,-6.44,10.37,-8.19,0.00,-10.20,-8.03,-6.37,0.00,-6.24,24.71,-3.66,0.00,-19.48,8.92,-16.02,0.00,-14.16,4.73,-19.98,0.00,10.24,-26.82,6.63,0.00,7.70,19.07,18.71,0.00,-10.86,-6.19,7.19,0.00,-7.83,4.01,2.37,0.00,4.99,10.69,16.30,0.00,-15.84,11.49,-25.02,0.00,-6.20,5.67,-16.26,0.00,1.11,-17.37,-5.38,0.00,12.19,6.59,-5.62,0.00,17.63,-15.32,2.32,0.00,-16.77,17.96,-1.53,0.00,9.30,-25.69,-22.52,0.00,-6.86,-1.58,-14.29,0.00,16.40,14.41,-2.16,0.00,-16.45,-17.25,-8.70,0.00,4.84,9.10,3.70,0.00,11.70,2.06,17.39,0.00,-5.55,-9.47,24.06,0.00,11.01,-7.12,-11.37,0.00,30.69,-8.31,7.38,0.00,2.16,-18.69,-14.38,0.00,-18.77,-11.41,-5.69,0.00,-5.02,-14.92,-28.45,0.00,-9.71,18.46,13.26,0.00,12.50,-11.56,11.81,0.00,4.52,-25.81,-1.44,0.00,15.98,17.61,-18.62,0.00,-9.76,6.79,25.02,0.00,-16.03,-8.58,13.47,0.00,6.24,14.82,-8.35,0.00,-15.16,24.51,6.62,0.00,-19.18,-13.57,2.16,0.00,9.95,7.32,1.67,0.00,-10.79,2.66,12.88,0.00,18.37,-8.19,2.10,0.00,-5.73,4.17,-15.85,0.00,1.88,-9.78,10.55,0.00,-23.09,-3.02,23.95,0.00,-11.18,6.55,-4.31,0.00,-16.39,-5.53,5.49,0.00,27.61,-13.95,-4.54,0.00,6.55,-12.33,22.44,0.00,12.84,-21.55,2.40,0.00,-9.85,-7.53,-9.16,0.00,16.50,-8.83,-9.94,0.00,3.73,3.37,-16.67,0.00,-9.53,7.32,16.32,0.00,-2.47,-7.89,-8.31,0.00,9.22,2.84,-10.16,0.00,15.58,10.75,14.53,0.00,4.32,-8.59,-8.31,0.00,-10.73,-5.90,22.67,0.00,14.32,22.38,10.25,0.00,18.39,-6.48,31.19,0.00,17.43,17.67,-20.44,0.00,-1.65,-8.23,-10.75,0.00,11.35,2.57,-17.09,0.00,16.36,2.75,-10.67,0.00,5.67,-6.76,14.17,0.00,11.78,-15.56,4.52,0.00,5.96,10.43,-14.99,0.00,24.61,28.53,-2.20,0.00,12.10,-10.41,-19.30,0.00,9.57,-12.32,-7.89,0.00,-19.11,5.29,-3.79,0.00,14.62,6.88,5.36,0.00,20.50,10.02,10.31,0.00,12.78,19.15,-3.10,0.00,8.53,12.14,-17.27,0.00,-1.77,10.68,7.29,0.00,13.45,15.14,-3.69,0.00,7.09,-13.15,-12.66,0.00,1.93,-6.89,12.26,0.00,-8.52,3.06,9.30,0.00,-20.46,8.65,1.64,0.00,4.10,2.79,-13.45,0.00,10.81,-15.56,7.23,0.00,12.87,-4.32,-12.42,0.00,12.35,10.06,1.91,0.00,-12.72,10.33,-18.24,0.00,14.37,-4.13,6.63,0.00,6.41,7.20,9.24,0.00,-12.28,-13.51,-0.78,0.00,-13.66,3.46,18.94,0.00,-1.36,8.50,10.91,0.00,4.43,4.28,13.15,0.00,6.99,-15.77,-5.60,0.00,-12.18,-12.90,-29.96,0.00,16.91,12.84,-10.45,0.00,-12.29,-27.03,1.79,0.00,10.47,4.81,2.26,0.00,-11.97,10.77,9.83,0.00,9.76,-10.20,-2.55,0.00,-2.12,5.66,-19.44,0.00,-5.90,-10.81,10.31,0.00,21.10,-11.10,-0.90,0.00,17.57,-12.43,-27.74,0.00,1.61,-4.58,4.28,0.00,8.80,-20.42,-12.06,0.00,-20.39,-1.43,5.50,0.00,-22.02,-9.48,-12.23,0.00,-2.94,-4.22,-6.13,0.00,-9.09,8.32,3.67,0.00,-5.95,12.00,5.57,0.00,12.04,12.69,25.97,0.00,-9.36,13.36,16.59,0.00,8.53,-15.41,-5.68,0.00,-17.96,5.88,12.27,0.00,20.40,8.04,-7.33,0.00,13.74,-5.88,-10.47,0.00,13.89,-14.06,-9.97,0.00,17.50,-8.63,-5.17,0.00,-21.00,26.24,8.40,0.00,-1.43,-5.47,7.84,0.00,-19.97,-10.06,-11.29,0.00,-12.05,-20.34,8.37,0.00,15.67,-5.55,-10.42,0.00,7.70,-4.05,-11.00,0.00,-13.40,4.31,15.10,0.00,-6.80,-16.44,-13.84,0.00,-17.63,-11.33,-7.64,0.00,-0.35,10.10,-17.31,0.00,-11.07,27.00,-6.81,0.00,-5.04,9.29,19.59,0.00,17.49,-5.72,9.76,0.00,14.40,-7.98,-4.71,0.00,11.53,7.39,3.10,0.00,-12.06,12.05,24.28,0.00,1.34,-14.74,11.50,0.00,-12.05,10.61,6.43,0.00,-10.83,21.94,-5.35,0.00,-12.82,-28.87,1.25,0.00,7.42,-6.77,7.22,0.00,-17.39,10.36,14.30,0.00,-7.76,5.57,-6.53,0.00,13.75,2.83,16.24,0.00,-9.07,-20.20,11.99,0.00,16.90,-9.01,15.45,0.00,16.91,-26.04,-20.39,0.00,-12.77,-3.57,-18.01,0.00,-12.35,-10.49,3.42,0.00,-16.94,11.92,9.03,0.00,-14.40,-8.18,18.56,0.00,-27.85,-21.92,17.45,0.00,-5.69,-35.54,-6.66,0.00,1.53,3.88,16.75,0.00,-3.71,-2.20,2.44,0.00,-9.79,6.17,-7.87,0.00,12.91,1.42,-2.66,0.00,3.16,5.66,-14.12,0.00,-13.48,23.61,6.23,0.00,1.49,12.01,2.90,0.00,20.26,-11.56,-16.99,0.00,-16.79,-8.39,13.69,0.00,3.28,0.80,-10.29,0.00,8.46,-5.71,16.30,0.00,-2.51,21.64,-13.52,0.00,24.50,-5.95,32.58,0.00,-6.85,-18.26,-7.43,0.00,-10.00,0.72,-0.95,0.00,7.07,-16.76,13.51,0.00,-0.90,-25.84,20.10,0.00,-15.97,14.95,12.37,0.00,-16.75,-16.59,0.35,0.00,-8.94,-17.39,-14.85,0.00,-22.05,-11.36,-11.60,0.00,-12.99,3.32,2.07,0.00,3.30,-13.55,-11.57,0.00,15.96,-7.58,-11.38,0.00,-17.41,34.20,-2.90,0.00,10.01,14.92,-4.40,0.00,5.97,19.12,3.89,0.00,-12.54,2.99,-7.19,0.00,-1.46,2.29,12.51,0.00,6.15,-13.56,21.03,0.00,-18.17,3.37,-9.77,0.00,2.37,-15.25,-16.37,0.00,-8.81,-9.48,12.49,0.00,22.78,4.13,-6.50,0.00,14.08,-18.16,-23.39,0.00,-3.72,20.38,-4.46,0.00,-9.18,-23.84,13.94,0.00,11.74,-5.05,9.93,0.00,22.04,-13.06,-11.66,0.00,-18.60,-7.87,15.92,0.00,-1.41,-10.32,5.84,0.00,11.18,10.03,8.34,0.00,8.80,-8.39,-2.85,0.00,30.54,2.88,9.48,0.00,3.79,-15.42,-12.05,0.00,4.91,21.98,26.78,0.00,14.54,-5.96,20.84,0.00,5.49,11.35,11.15,0.00,-21.10,-9.72,24.67,0.00,-16.88,10.71,-13.97,0.00,21.68,9.81,6.34,0.00,0.74,15.48,-9.28,0.00,5.03,11.68,9.32,0.00,-11.36,7.79,-15.45,0.00,-7.53,8.61,-11.70,0.00,2.29,-13.90,11.68,0.00,5.59,1.35,-12.77,0.00,-10.86,-21.24,13.81,0.00,4.40,8.00,0.68,0.00,-1.57,5.40,-8.52,0.00,14.26,-9.94,-15.40,0.00,6.59,10.71,-3.79,0.00,18.18,-9.71,-5.50,0.00,-16.25,9.54,-16.05,0.00,-5.58,-4.15,-9.90,0.00,7.87,-1.34,11.48,0.00,-19.13,-8.44,-11.66,0.00,17.24,-25.10,-7.55,0.00,11.35,14.58,3.82,0.00,-18.50,2.06,21.49,0.00,2.12,-15.71,-8.31,0.00,-6.48,8.88,12.90,0.00,-14.55,-3.30,2.89,0.00,-3.15,-2.17,-9.85,0.00,-14.66,-22.99,2.53,0.00,-4.14,4.19,0.87,0.00,-7.16,-17.51,-21.18,0.00,-8.86,-11.38,21.09,0.00,21.62,-9.79,-8.95,0.00,-4.20,16.96,-2.73,0.00,3.01,3.95,7.33,0.00,7.08,25.73,-13.60,0.00,2.19,4.50,-6.33,0.00,-4.25,9.82,-6.19,0.00,8.10,6.30,-19.24,0.00,-10.13,-12.77,-8.76,0.00,-10.69,-10.92,-6.40,0.00,11.87,-9.11,27.87,0.00,5.94,7.54,9.91,0.00,2.30,14.36,-20.13,0.00,-1.17,-9.00,13.09,0.00,-7.54,-1.90,4.73,0.00,-5.40,-13.01,-13.28,0.00,15.95,16.85,-6.48,0.00,-17.99,-3.86,11.87,0.00,22.21,12.94,-24.51,0.00,-15.17,12.80,10.74,0.00,-4.40,-4.93,-1.68,0.00,3.69,15.86,8.34,0.00,14.71,19.66,11.42,0.00,-7.93,-5.74,-21.73,0.00,13.29,-1.87,-2.47,0.00,-23.24,-7.96,4.49,0.00,-13.74,-27.19,7.37,0.00,9.65,13.01,-4.29,0.00,12.10,-2.53,-11.84,0.00,-23.78,5.41,5.75,0.00,-14.58,-13.23,1.06,0.00,-22.72,-15.77,12.05,0.00,-20.33,-11.30,8.48,0.00,11.66,9.07,6.97,0.00,16.97,-2.81,10.18,0.00,17.47,6.41,8.80,0.00,-32.99,-2.44,-9.58,0.00,-1.74,10.90,-10.26,0.00,-10.24,2.30,0.43,0.00,-18.67,25.66,9.54,0.00,-4.68,-13.03,9.09,0.00,4.57,11.83,-8.00,0.00,-19.24,8.21,-2.58,0.00,-11.74,-6.11,6.77,0.00,-10.33,3.78,18.26,0.00,15.46,9.26,-0.86,0.00,-19.45,12.31,8.85,0.00,11.77,13.83,-7.44,0.00,8.94,-14.79,18.51,0.00,15.39,-22.74,5.70,0.00,6.20,11.22,11.92,0.00,28.97,5.09,-12.75,0.00,-6.84,-13.25,-11.61,0.00,-8.80,-7.29,25.26,0.00,14.81,-13.17,-8.69,0.00,-20.68,6.70,14.87,0.00,13.06,18.15,5.01,0.00,-14.06,8.80,-4.02,0.00,-6.62,6.11,16.73,0.00,10.95,-8.68,-13.09,0.00,-3.77,10.53,-2.54,0.00,-1.41,-11.66,-7.13,0.00,8.59,-6.17,0.00,0.00,-15.65,-10.74,-4.94,0.00,-6.90,-3.98,-7.82,0.00,-27.66,18.54,-12.07,0.00,8.15,-17.29,3.59,0.00,-9.39,-11.95,-16.11,0.00,-8.98,19.46,6.72,0.00,24.29,-13.67,2.65,0.00,18.90,-18.36,0.00,0.00,12.03,15.32,-11.75,0.00,9.62,12.74,10.00,0.00,11.77,-31.63,-5.89,0.00,-11.23,-10.75,-9.24,0.00,10.49,22.14,12.03,0.00,-19.63,-12.28,2.59,0.00,-10.12,10.16,18.70,0.00,5.03,8.17,0.00,0.00,-8.70,6.66,-15.84,0.00,18.50,9.26,-1.75,0.00,-16.72,-16.54,9.70,0.00,-12.98,-23.68,-10.27,0.00,-6.37,-20.64,5.93,0.00,-3.50,7.46,-6.05,0.00,-20.80,-2.63,-2.01,0.00,11.80,-9.05,0.00,0.00,-3.68,-9.09,11.34,0.00,8.09,-6.36,-9.95,0.00,-17.14,19.63,3.92,0.00,15.55,12.00,-2.03,0.00,-22.40,13.11,-28.17,0.00,8.77,8.05,23.80,0.00,-26.97,-8.36,3.47,0.00,6.69,-7.24,0.00,0.00,13.52,-9.44,-9.72,0.00,12.50,-2.33,-14.73,0.00,1.05,-16.38,-19.06,0.00,1.71,-20.55,13.37,0.00,17.03,-10.56,6.76,0.00,-23.86,-13.22,26.04,0.00,6.20,-11.46,-11.85,0.00,-10.89,4.81,0.00,0.00,2.77,9.49,-11.40,0.00,7.91,16.04,-16.54,0.00,-15.34,14.14,-6.56,0.00,7.65,10.89,24.47,0.00,-23.78,-14.99,-11.06,0.00,10.52,-10.70,-6.16,0.00,-10.29,-6.47,-7.23,0.00,-6.51,-18.04,0.00,0.00,-18.43,11.25,-10.01,0.00,-20.75,-11.18,9.02,0.00,5.32,-13.00,10.19,0.00,8.95,-15.10,17.86,0.00,-2.82,-6.48,13.31,0.00,2.36,-19.37,15.00,0.00,-4.73,3.18,-13.54,0.00,-7.69,11.80,0.00,0.00,-9.04,2.61,17.40,0.00,10.17,-6.81,-5.82,0.00,-15.81,4.82,14.49,0.00,-14.84,-3.64,-18.41,0.00,-2.82,-15.04,-16.80,0.00,14.56,-21.95,4.96,0.00,18.61,11.91,-17.95,0.00,6.50,16.16,0.00,0.00,6.25,-20.54,25.95,0.00,11.76,-4.96,-2.19,0.00,4.56,17.59,-5.34,0.00,-0.63,25.03,-8.82,0.00,-7.63,-8.43,20.91,0.00,-6.66,24.04,-11.51,0.00,11.13,7.10,-8.41,0.00,8.32,5.50,0.00,0.00,15.49,-9.26,-12.22,0.00,-17.19,-17.38,-10.89,0.00,-19.05,-12.44,-3.04,0.00,-11.75,2.14,-9.19,0.00,-9.74,8.34,-12.20,0.00,9.38,-14.80,-12.98,0.00,13.19,4.20,-8.16,0.00,-0.44,18.91,0.00,0.00,19.87,17.17,-20.26,0.00,-3.78,-3.15,22.10,0.00,13.14,14.27,1.35,0.00,10.33,-15.14,0.60,0.00,-12.35,-4.41,-12.14,0.00,-10.31,9.82,11.10,0.00,9.42,-8.34,-14.66,0.00,-11.18,8.33,0.00,0.00,-28.87,-0.79,0.00,0.00,-21.69,9.05,0.00,0.00,-13.91,-18.71,0.00,0.00,28.28,1.05,0.00,0.00,2.75,25.92,0.00,0.00,15.85,5.32,0.00,0.00,)
     
     ################################
     # Ergebnis Matlab Viterbi Testsequenz
     expected_result_0 = (0,0,0,0,0,0,1,0,1,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,0,1,1,0,0,1,0,1,0,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,0,1,1,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,1,1,1,0,1,0,1,0,1,1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,1,0,0,1,1,1,1,0,0,1,1,0,0,1,1,0,0,0,0,1,0,0,1,0,1,0,1,1,1,1,1,0,1,1,0,1,0,0,1,1,0,0,0,1,0,0,1,1,1,1,0,0,0,0,1,1,0,1,1,0,1,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,1,1,0,1,1,0,0,1,0,0,0,0,0,1,1,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,1,0,0,0,1,1,0,0,1,0,0,0,1,0,1,0,1,0,1,1,0,0,1,1,1,0,1,0,0,1,0,1,0,0,0,1,1,0,1,0,0,1,0,1,1,1,1,1,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,1,0,1,0,1,1,0,0,1,0,1,1,0,0,1,1,1,1,0,0,0,1,1,1,1,1,0,1,1,1,0,1,0,0,0,0,0,1,1,0,1,0,1,1,0,1,1,0,1,1,1,0,1,1,0,0,0,0,0,1,0,1,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,1,1,1,1,0,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,1,1,1,0,1,0,0,1,0,0,1,1,1,1,0,1,0,1,1,1,0,1,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0,1,1,0,1,1,0,0,1,1,0,1,0,0,0,0,1,1,1,0,1,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0,1,0,0,0,0,0,1,0,0,1,0,1,0,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,0,0,0,1,0,1,0,1,0,0,1,0,0,0,1,1,1,0,0,0,1,1,0,1,1,0,1,0,1,0,1,1,1,0,0,0,1,0,0,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,0,0,1,1,1,0,0,1,0,1,0,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1,0,0,1,1,0,1,1,1,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,1,0,1,1,0,1,0,0,1,1,1,1,1,1,0,1,1,0,0,1,0,0,1,0,0,1,0,1,1,0,1,1,1,1,1,1,0,0,1,0,0,1,1,0,1,1,1,1,0,0,1,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,)
     
     #################################
     
     # Objekte erzeugen
     src_0 = gr.vector_source_f (src_data_0)
     throttle_0 = gr.throttle(gr.sizeof_float*1, 32000)
     s2v = gr.stream_to_vector(gr.sizeof_float, 3096)
     Viterbi = howto_swig.viterbi_vfb(3096)
     v2s = gr.vector_to_stream(gr.sizeof_char, 3096/4)
     dst_0 = gr.vector_sink_b()
     
     # Objekte verbinden
     self.tb.connect(src_0, throttle_0)
     self.tb.connect(throttle_0, s2v)
     self.tb.connect(s2v, Viterbi)
     self.tb.connect(Viterbi, v2s)
     self.tb.connect(v2s, dst_0)
     
     # Simulationsstart
     self.tb.run ()
     
     # Ergebnis auswerten
     result_data0 = dst_0.data ()
     result_data0 = result_data0
     expected_result_0 = expected_result_0
     self.assertEqual(expected_result_0, result_data0)
Beispiel #18
0
    def __init__(self):
        gr.top_block.__init__(self)

        length = 101

        data_r = range(length)
        data_i = range(length,2*length)
        src_r = gr.vector_source_s(data_r, False)
        src_i = gr.vector_source_s(data_i, False)
        s2f_r = gr.short_to_float()
        s2f_i = gr.short_to_float()
        f2c = gr.float_to_complex()
        s2v = gr.stream_to_vector(gr.sizeof_gr_complex, length)

        shift = True
        ifft = gr.fft_vcc(length, False, [], shift)
        fft  = gr.fft_vcc(length, True, [], shift)
        
        v2s = gr.vector_to_stream(gr.sizeof_gr_complex, length)
        snk_in = gr.file_sink(gr.sizeof_gr_complex, "fftshift.in")
        snk_out = gr.file_sink(gr.sizeof_gr_complex, "fftshift.out")

        self.connect(src_r, s2f_r, (f2c,0))
        self.connect(src_i, s2f_i, (f2c,1))
        self.connect(f2c, snk_in)
        self.connect(f2c, s2v, ifft, fft, v2s, snk_out)
Beispiel #19
0
    def test_004_de_diff_mod_vcc(self):
        #################################
        # Testsequenz generieren
        src_data = (1 + 0j, 0 + 2j, 0 - 0j, 0 + 1j, 2 + 0j, 0 + 0j, -1 + 0j,
                    2 + 0j, -0 + 0j)
        #################################
        # Ergebnis generieren
        expected_result_0 = (0 + 0j, 0 + 0j, 0 - 0j, 0 + 1j, 0 - 4j, 0 - 0j,
                             0 + 1j, 4 + 0j, 0 + 0j)
        expected_result_1 = (0 + 0j, 0 - 4j, 4 + 0j)
        #################################

        # Objekte erzeugen
        src = gr.vector_source_c(src_data)
        s2v = gr.stream_to_vector(gr.sizeof_gr_complex, 3)
        diff = howto_swig.de_diff_mod_vcc(3, 1)
        v2s = gr.vector_to_stream(gr.sizeof_gr_complex, 3)
        dst0 = gr.vector_sink_c()
        dst1 = gr.vector_sink_c()

        # Objekte verbinden
        self.tb.connect(src, s2v, (diff, 0), v2s, dst0)
        self.tb.connect((diff, 1), dst1)

        # Simulationsstart
        self.tb.run()

        # Ergebnis auswerten
        result_data0 = dst0.data()
        result_data1 = dst1.data()
        self.assertComplexTuplesAlmostEqual(expected_result_0, result_data0, 6)
        self.assertComplexTuplesAlmostEqual(expected_result_1, result_data1, 6)
 def test_002_ofdm_remove_first_symbol_vcc(self):
     src_data0 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7)
     src_data1 = (1, 0, 0, 1, 0, 0)
     expected_result0 = (3, 4, 5, 6, 7, 8, 2, 3, 4, 5, 6, 7)
     expected_result0 = [x + 0j for x in expected_result0]
     expected_result1 = (1, 0, 1, 0)
     src0 = gr.vector_source_c(src_data0)
     src1 = gr.vector_source_b(src_data1)
     s2v0 = gr.stream_to_vector(gr.sizeof_gr_complex, 3)
     ofdm_remove_first_symbol = dab_swig.ofdm_remove_first_symbol_vcc(3)
     v2s0 = gr.vector_to_stream(gr.sizeof_gr_complex, 3)
     dst0 = gr.vector_sink_c()
     dst1 = gr.vector_sink_b()
     self.tb.connect(src0, s2v0, (ofdm_remove_first_symbol, 0))
     self.tb.connect(src1, (ofdm_remove_first_symbol, 1))
     self.tb.connect((ofdm_remove_first_symbol, 0), v2s0, dst0)
     self.tb.connect((ofdm_remove_first_symbol, 1), dst1)
     self.tb.run()
     result_data0 = dst0.data()
     result_data1 = dst1.data()
     # print src_data0
     # print expected_result0
     # print result_data0
     self.assertComplexTuplesAlmostEqual(expected_result0, result_data0, 6)
     self.assertEqual(result_data1, expected_result1)
Beispiel #21
0
    def test_003(self):
        # Need to add padding to keep proper alignment
        padding = tuple([0 for i in range(5)])

        scale = 2
        vlen = 3
        src_data = (0.0, 1.1, 2.2,) + padding +  \
                   (3.3, 4.4, 5.5,) + padding + \
                   (-1.1, -2.2, -3.3,) + padding
        expected_result = [0, 2, 4]
        expected_result.extend(padding)
        expected_result.extend([7, 9, 11])
        expected_result.extend(padding)
        expected_result.extend([-2, -4, -7])
        expected_result.extend(padding)

        src = gr.vector_source_f(src_data)
        s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
        op = gr.float_to_int(vlen, scale)
        v2s = gr.vector_to_stream(gr.sizeof_int, vlen)
        dst = gr.vector_sink_i()

        self.tb.connect(src, s2v, op, v2s, dst)
        self.tb.run()
        result_data = list(dst.data())

        self.assertEqual(expected_result, result_data)
Beispiel #22
0
    def __init__(self):
        gr.top_block.__init__(self)

        sample_rate = 32000
        ampl = 0.1

        self._fft_length=96
        
        win = [] 
        #win = [1 for i in range(self._fft_length)]
        win2 = [1 for i in range(self._fft_length)]

        # Constructing a sine source and the fft blocks
        src0 = gr.sig_source_c (sample_rate, gr.GR_SIN_WAVE, 350, ampl)
        ss2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._fft_length)
        sv2s = gr.vector_to_stream(gr.sizeof_gr_complex, self._fft_length)
        fft_demod = gr.fft_vcc(self._fft_length, True, win2, False)
        ifft = gr.fft_vcc(self._fft_length, False, win, False)
        scale = gr.multiply_const_cc(1.0 / self._fft_length)
        
        # Some output data files
        trans_output = gr.file_sink(gr.sizeof_gr_complex, "trans_output.dat")
        reg_output = gr.file_sink(gr.sizeof_gr_complex, "reg_output.dat")

        # make the connections #
        self.connect(src0, ss2v, fft_demod, ifft, sv2s, scale, trans_output)
        self.connect(src0, reg_output)
Beispiel #23
0
    def test_001(self):
        vlen = 128
        syms = 4

        freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen)

        fft = gr.fft_vcc(vlen, True, [], True)  # natural order, dc = vlen / 2
        ifft = gr.fft_vcc(vlen, False, [], True)
        fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen)

        vec = numpy.array(numpy.zeros(vlen), numpy.complex)
        vec[vlen / 2 - vlen / 4] = 1.0
        vec = concatenate([vec] * syms)

        src = gr.vector_source_c(vec)
        dst = gr.vector_sink_c()
        s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
        v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)

        eps = gr.vector_source_f([0.0] * syms)
        trig = gr.vector_source_b([1] * syms)

        self.fg.connect(src, s2v, ifft, (freq_shift, 0))
        self.fg.connect(eps, (freq_shift, 1))
        self.fg.connect(trig, (freq_shift, 2))
        self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
        self.fg.run()

        self.assertComplexTuplesAlmostEqual(vec, numpy.array(dst.data()))
 def test_001_ofdm_coarse_frequency_correct(self):
     src_data0 = [
         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 0, 5, 7, 6, 0, 4, 0, 6, 1, 1,
         1, 0.8, 0.1, 1.3, 1, 0.7, 1, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
     ]
     expected_result0 = [7, 9, 5, 6, 0.8, 1.3, 3, 5]
     expected_result0 = [complex(x) for x in expected_result0]
     src_data1 = [1, 1, 1, 0]
     expected_result1 = (1, 1, 1, 0)
     src0 = gr.vector_source_c(src_data0)
     src1 = gr.vector_source_b(src_data1)
     s2v0 = gr.stream_to_vector(gr.sizeof_gr_complex, 10)
     ofdm_coarse_frequency_correct = dab_swig.ofdm_coarse_frequency_correct(
         10, 2)
     v2s0 = gr.vector_to_stream(gr.sizeof_gr_complex, 2)
     dst0 = gr.vector_sink_c()
     dst1 = gr.vector_sink_b()
     self.tb.connect(src0, s2v0, (ofdm_coarse_frequency_correct, 0))
     self.tb.connect(src1, (ofdm_coarse_frequency_correct, 1))
     self.tb.connect((ofdm_coarse_frequency_correct, 0), v2s0, dst0)
     self.tb.connect((ofdm_coarse_frequency_correct, 1), dst1)
     self.tb.run()
     result_data0 = dst0.data()
     result_data1 = dst1.data()
     # print expected_result0
     # print result_data0
     self.assertComplexTuplesAlmostEqual(expected_result0, result_data0, 6)
     self.assertEqual(result_data1, expected_result1)
  def test_101(self):
    vlen = 256
    N = int( 5e5 )
    soff=1.0
    taps = [1.0,0.0,2e-1+0.1j,1e-4-0.04j]
    freqoff = 0.0
    norm_freq = freqoff / vlen
    rms_amplitude = 8000
    snr_db = 10
    snr = 10.0**(snr_db/10.0)
    noise_sigma = sqrt( rms_amplitude**2 / snr)
    
    
    
    data = [1 + 1j] * vlen
    #data2 = [2] * vlen
    
    src = gr.vector_source_c( data, True, vlen )
    v2s = gr.vector_to_stream(gr.sizeof_gr_complex,vlen)
    
    
    channel = gr.channel_model(noise_sigma,norm_freq,soff,taps)
    
    dst = gr.null_sink( gr.sizeof_gr_complex )

    limit = gr.head( gr.sizeof_gr_complex * vlen, N )
    
    
    self.tb.connect( src, limit, v2s, channel, dst )
    
    r = time_it( self.tb )
    
    print "Rate: %s Samples/second" \
      % eng_notation.num_to_str( float(N) * vlen / r ) 
    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)
Beispiel #27
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_001(self):
        frames = 5
        config = station_configuration()
        config.subcarriers = 12
        config.data_subcarriers = 8

        config.training_data = dummy()
        config.training_data.shifted_pilot_tones = [1, 4, 8, 11]

        data = [1.0] * config.subcarriers
        for x in config.training_data.shifted_pilot_tones:
            data[x] = 2.0
        data = concatenate([data] * frames)

        ref = [1.0] * (config.data_subcarriers * frames)

        src = gr.vector_source_c(data)
        s2v = gr.stream_to_vector(gr.sizeof_gr_complex, config.subcarriers)
        dst = gr.vector_sink_c()
        v2s = gr.vector_to_stream(gr.sizeof_gr_complex,
                                  config.data_subcarriers)

        uut = preambles.pilot_subcarrier_filter()
        self.fg.connect(src, s2v, uut, v2s, dst)

        self.fg.run()
        self.assertEqual(ref, list(dst.data()))
    def test_003(self):
        # Need to add padding
        padding = tuple([0 for i in range(29)])

        scale = 2
        vlen = 3
        src_data = (0.0, 1.1, 2.2,) + padding + \
                   (3.2, 4.2, 5.5,) + padding + \
                   (-1.1, -2.2, -3.2,) + padding
        expected_result = [0, 2, 4]
        expected_result.extend(padding)
        expected_result.extend([6, 8, 11])
        expected_result.extend(padding)
        expected_result.extend([-2, -4, -6])
        expected_result.extend(padding)

        src = gr.vector_source_f(src_data)
        s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
        op = gr.float_to_char(vlen, scale)
        v2s = gr.vector_to_stream(gr.sizeof_char, vlen)
        dst = gr.vector_sink_c()

        self.tb.connect(src, s2v, op, v2s, dst)
        self.tb.run()
        result_data = list(dst.data())

        self.assertEqual(expected_result, result_data)
Beispiel #30
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)
Beispiel #31
0
    def test_101(self):
        vlen = 256
        N = int(5e5)
        soff = 1.0
        taps = [1.0, 0.0, 2e-1 + 0.1j, 1e-4 - 0.04j]
        freqoff = 0.0
        norm_freq = freqoff / vlen
        rms_amplitude = 8000
        snr_db = 10
        snr = 10.0**(snr_db / 10.0)
        noise_sigma = sqrt(rms_amplitude**2 / snr)

        data = [1 + 1j] * vlen
        #data2 = [2] * vlen

        src = gr.vector_source_c(data, True, vlen)
        v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)

        channel = gr.channel_model(noise_sigma, norm_freq, soff, taps)

        dst = gr.null_sink(gr.sizeof_gr_complex)

        limit = gr.head(gr.sizeof_gr_complex * vlen, N)

        self.tb.connect(src, limit, v2s, channel, dst)

        r = time_it(self.tb)

        print "Rate: %s Samples/second" \
          % eng_notation.num_to_str( float(N) * vlen / r )
	def test_001_ofdm_coarse_frequency_correct(self):
		fft_length   = 10
		num_carriers = 2
		cp_length    = 3
		src_data0        = [0,1,2,3,4,5,6,7,8,9,1,2,0,5,7,6,0,4,0,6,1,1,1,0.8,0.1,1.3,1,0.7,1,1,0,1,2,3,4,5,6,7,8,9]
		expected_result0 = [7,9,5,6,0.8,1.3,3,5]
		offset           = [3,3,-1,-1,-1,-1,-1,-1]
		frame_index      = [0,0, 0, 0, 0, 0, 1, 1]
		expected_result0 = [complex(expected_result0[i])*cmath.exp(-2j*cmath.pi*offset[i]*cp_length/float(fft_length)*frame_index[i]) for i in range(0,8)]
		src_data1 = [1,1,1,0]
		expected_result1 = (1,1,1,0)
		src0 = gr.vector_source_c(src_data0)
		src1 = gr.vector_source_b(src_data1)
		s2v0 = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length)
		ofdm_coarse_frequency_correct = dab_swig.ofdm_coarse_frequency_correct(fft_length,num_carriers,cp_length)
		v2s0 = gr.vector_to_stream(gr.sizeof_gr_complex, num_carriers)
		dst0 = gr.vector_sink_c()
		dst1 = gr.vector_sink_b()
		self.tb.connect(src0, s2v0, (ofdm_coarse_frequency_correct,0))
		self.tb.connect(src1, (ofdm_coarse_frequency_correct,1))
		self.tb.connect((ofdm_coarse_frequency_correct,0), v2s0, dst0)
		self.tb.connect((ofdm_coarse_frequency_correct,1), dst1)
		self.tb.run()
		result_data0 = dst0.data()
		result_data1 = dst1.data()
		# print expected_result0
		# print result_data0
		self.assertComplexTuplesAlmostEqual(expected_result0, result_data0, 4)
		self.assertEqual(result_data1, expected_result1)
Beispiel #33
0
    def __init__(self, vlen, channel_block, delay):
        gr.hier_block2.__init__(
            self, 'apply_channel_to_vect',
            gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen),
            gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen))

        self.vlen = vlen
        self.channel_block = channel_block
        self.delay = delay

        pad_len = self.vlen + self.delay * 2

        if (delay > 0):
            self.padding = gr.vector_source_c((0, ) * (delay * 2), True,
                                              delay * 2)
            self.pad_cat = mlse.vector_concat_vv(
                vlen * gr.sizeof_gr_complex, gr.sizeof_gr_complex * 2 * delay)
            self.connect(self, self.pad_cat)
            self.connect(self.padding, (self.pad_cat, 1))
        else:
            self.pad_cat = self

        self.tostream = gr.vector_to_stream(gr.sizeof_gr_complex, pad_len)
        self.connect(self.pad_cat, self.tostream)

        # connect channel
        self.connect(self.tostream, self.channel_block)

        self.tovector = gr.stream_to_vector(gr.sizeof_gr_complex, pad_len)
        self.connect(self.channel_block, self.tovector)

        # cut out the proper part
        self.trim = mlse.vector_slice_vv(gr.sizeof_gr_complex, pad_len, delay,
                                         vlen)
        self.connect(self.tovector, self.trim, self)
Beispiel #34
0
    def test_001(self):
        fft_length = 260
        carriers = 100
        shift = 20

        # select maximum estimation range
        estim_range = (fft_length - carriers) / 2
        l = estim_range + shift
        r = estim_range - shift

        # create preambles
        pn1 = pn_preamble(carriers)
        pn2 = pn_preamble(carriers)
        diff_pn = concatenate(
            [[conjugate(math.sqrt(2) * pn2[2 * i] / pn1[2 * i]), 0.0j]
             for i in range(carriers / 2)])
        pn1_sym = extend_symbol(pn1, l, r)
        pn2_sym = extend_symbol(pn2, l, r)

        # block under tests
        cfo_estimator = ofdm.schmidl_cfo_estimator(fft_length, carriers,
                                                   estim_range, diff_pn)

        # source, conversion, sink
        src_1 = gr.vector_source_c(pn1_sym)
        src_2 = gr.vector_source_c(pn2_sym)
        s2v_1 = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length)
        s2v_2 = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length)
        v2s = gr.vector_to_stream(gr.sizeof_float, 2 * estim_range + 1)
        dst = gr.vector_sink_f()

        self.fg.connect(src_1, s2v_1, (cfo_estimator, 0))
        self.fg.connect(src_2, s2v_2, (cfo_estimator, 1))
        self.fg.connect(cfo_estimator, v2s, dst)

        # file output
        filesink = gr.file_sink(gr.sizeof_float, "test_cfo.float")
        vec_equ = vector_equalizer(2 * estim_range + 1)
        self.fg.connect(
            v2s, gr.float_to_complex(),
            gr.stream_to_vector(gr.sizeof_gr_complex, 2 * estim_range + 1),
            vec_equ,
            gr.vector_to_stream(gr.sizeof_gr_complex, 2 * estim_range + 1),
            gr.complex_to_float(), filesink)

        runtime = self.fg
        runtime.run()
Beispiel #35
0
	def __init__(self, decim=16, N_id_1=134, N_id_2=0):
		grc_wxgui.top_block_gui.__init__(self, title="Sss Corr Gui")
		_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
		self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))

		##################################################
		# Parameters
		##################################################
		self.decim = decim
		self.N_id_1 = N_id_1
		self.N_id_2 = N_id_2

		##################################################
		# Variables
		##################################################
		self.sss_start_ts = sss_start_ts = 10608 - 2048 - 144
		self.samp_rate = samp_rate = 30720e3/decim

		##################################################
		# Blocks
		##################################################
		self.wxgui_scopesink2_0 = scopesink2.scope_sink_f(
			self.GetWin(),
			title="Scope Plot",
			sample_rate=200,
			v_scale=0,
			v_offset=0,
			t_scale=0,
			ac_couple=False,
			xy_mode=False,
			num_inputs=1,
			trig_mode=gr.gr_TRIG_MODE_AUTO,
			y_axis_label="Counts",
		)
		self.Add(self.wxgui_scopesink2_0.win)
		self.gr_vector_to_stream_0 = gr.vector_to_stream(gr.sizeof_gr_complex*1, 2048/decim)
		self.gr_throttle_0 = gr.throttle(gr.sizeof_gr_complex*1, samp_rate*decim)
		self.gr_stream_to_vector_0 = gr.stream_to_vector(gr.sizeof_gr_complex*1, 2048/decim)
		self.gr_skiphead_0 = gr.skiphead(gr.sizeof_gr_complex*1, sss_start_ts)
		self.gr_multiply_const_vxx_0 = gr.multiply_const_vcc((gen_sss_fd(N_id_1, N_id_2, 2048/decim).get_sss_conj_rev()))
		self.gr_integrate_xx_0 = gr.integrate_cc(2048/decim)
		self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex*1, "/home/user/git/gr-lte/gr-lte/test/traces/lte_02_796m_30720k_frame.cfile", True)
		self.gr_fft_vxx_0 = gr.fft_vcc(2048/decim, True, (window.blackmanharris(1024)), True, 1)
		self.gr_complex_to_mag_0 = gr.complex_to_mag(1)
		self.fir_filter_xxx_0 = filter.fir_filter_ccc(decim, (firdes.low_pass(1, decim*samp_rate, 550e3, 100e3)))

		##################################################
		# Connections
		##################################################
		self.connect((self.gr_file_source_0, 0), (self.gr_throttle_0, 0))
		self.connect((self.gr_stream_to_vector_0, 0), (self.gr_fft_vxx_0, 0))
		self.connect((self.gr_fft_vxx_0, 0), (self.gr_multiply_const_vxx_0, 0))
		self.connect((self.gr_multiply_const_vxx_0, 0), (self.gr_vector_to_stream_0, 0))
		self.connect((self.gr_vector_to_stream_0, 0), (self.gr_integrate_xx_0, 0))
		self.connect((self.gr_integrate_xx_0, 0), (self.gr_complex_to_mag_0, 0))
		self.connect((self.gr_complex_to_mag_0, 0), (self.wxgui_scopesink2_0, 0))
		self.connect((self.gr_throttle_0, 0), (self.gr_skiphead_0, 0))
		self.connect((self.gr_skiphead_0, 0), (self.fir_filter_xxx_0, 0))
		self.connect((self.fir_filter_xxx_0, 0), (self.gr_stream_to_vector_0, 0))
  def test_30( self ):
    
    gamma = 0.001
    beta = -0.1
    
    vlen = 208
    N = 20
    M = 5
    pcount = 8
    pdist = vlen / pcount
    assert( ( pdist % 2 ) == 0 )
    
    nondata_blocks = [0, 1]
    pilot_subc = numpy.arange(pcount) * pdist + pdist/2 - vlen/2
    assert( pilot_subc[0] == - pilot_subc[len(pilot_subc)-1] )

    data = [1.+0.j] * vlen
    frame_start = [0] * N
    frame_start[0] = 1
    
    sub_dc = vlen/2
    
    ind_range = numpy.arange( vlen ) - vlen/2
    assert( ind_range[0] == -vlen/2 )
    
    phase_offset = ind_range * gamma + numpy.ones(vlen) * beta
    assert( phase_offset[sub_dc] == beta )
    phase = phase_offset
    
    phase_offset = exp( 1j * phase_offset )
    
    data = data * phase_offset
    data = concatenate( [data] * N )
    
    src = gr.vector_source_c( data, True, vlen )
    src2 = gr.vector_source_b( frame_start, True )
    dst = gr.vector_sink_c()
    
    limit2 = gr.head( gr.sizeof_char, N * M )
    
    uut = ofdm.LMS_phase_tracking2( vlen, pilot_subc.tolist(), nondata_blocks )
    
    self.tb.connect( src, uut, 
                     gr.vector_to_stream( gr.sizeof_gr_complex, vlen ), dst ) 
    self.tb.connect( src2, limit2, ( uut, 1 ) )
    
    self.tb.run()
    
    d = numpy.array( dst.data() )
    
    for i in range( M ):
      xx = i * N * vlen
      ad = numpy.angle( d[ (xx+len(nondata_blocks)*vlen):(xx+N*vlen) ] )
      ad2 = numpy.angle( d[ xx : (xx+len(nondata_blocks)*vlen) ] )
      
      self.assertFloatTuplesAlmostEqual( 
        concatenate( [phase]*len(nondata_blocks) ), ad2, 3 )
      
      self.assertFloatTuplesAlmostEqual( numpy.zeros(len(ad)), ad, 3 )
 def __init__(self, fg):
     """
     @param fg: flow graph
     """
     v2s = gr.vector_to_stream(gr.sizeof_char, atsc.sizeof_atsc_mpeg_packet)
     self.sink = gr.vector_sink_b()
     fg.connect(v2s, self.sink)
     gr.hier_block.__init__(self, fg, v2s, None)
    def help_const_cc(self, src_data, exp_data, op):
	src = gr.vector_source_c(src_data)
	srcv = gr.stream_to_vector(gr.sizeof_gr_complex, len(src_data))
	rhs = gr.vector_to_stream(gr.sizeof_gr_complex, len(src_data))
        dst = gr.vector_sink_c()
        self.fg.connect(src, srcv, op, rhs, dst)
        self.fg.run()
        result_data = dst.data()
        self.assertEqual(exp_data, result_data)
Beispiel #39
0
    def __init__(self):
        """
        """

        v2s = gr.vector_to_stream(gr.sizeof_char, atsc.sizeof_atsc_mpeg_packet)
        self.sink = gr.vector_sink_b()
        gr.hier_block2.__init__(self, "vector_sink_ts", v2s.input_signature(),
                                gr.io_signature(0, 0, 0))
        self.connect(self, v2s, self.sink)
Beispiel #40
0
 def test_fc32_to_f32_2(self):
     tb = gr.top_block()
     src = gr.vector_source_c([1+2j, 3+4j, 5+6j, 7+8j, 9+10j], False)
     convert = fc32_to_f32_2()
     v2s = gr.vector_to_stream(gr.sizeof_float, 2)
     sink = gr.vector_sink_f()
     tb.connect(src, convert, v2s, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
Beispiel #41
0
 def help_const_ii(self, src_data, exp_data, op):
     src = gr.vector_source_i(src_data)
     srcv = gr.stream_to_vector(gr.sizeof_int, len(src_data))
     rhs = gr.vector_to_stream(gr.sizeof_int, len(src_data))
     dst = gr.vector_sink_i()
     self.tb.connect(src, srcv, op, rhs, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertEqual(exp_data, result_data)
    def help_const_ii(self, src_data, exp_data, op):
	src = gr.vector_source_i(src_data)
	srcv = gr.stream_to_vector(gr.sizeof_int, len(src_data))
	rhs = gr.vector_to_stream(gr.sizeof_int, len(src_data))
        dst = gr.vector_sink_i()
        self.tb.connect(src, srcv, op, rhs, dst)
        self.tb.run()
        result_data = dst.data()
        self.assertEqual(exp_data, result_data)
 def test_fc32_to_f32_2(self):
     tb = gr.top_block()
     src = gr.vector_source_c([1+2j, 3+4j, 5+6j, 7+8j, 9+10j], False)
     convert = fc32_to_f32_2()
     v2s = gr.vector_to_stream(gr.sizeof_float, 2)
     sink = gr.vector_sink_f()
     tb.connect(src, convert, v2s, sink)
     tb.run()
     self.assertEqual(sink.data(), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
Beispiel #44
0
    def __init__(self, decim=16):
        grc_wxgui.top_block_gui.__init__(self, title="File Fft")
        _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
        self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))

        ##################################################
        # Parameters
        ##################################################
        self.decim = decim

        ##################################################
        # Variables
        ##################################################
        self.samp_rate = samp_rate = 32000
        self.fft_size = fft_size = 2048 / decim
        self.N_re = N_re = 62

        ##################################################
        # Blocks
        ##################################################
        self.wxgui_scopesink2_0 = scopesink2.scope_sink_c(
            self.GetWin(),
            title="Scope Plot",
            sample_rate=samp_rate,
            v_scale=0,
            v_offset=0,
            t_scale=0,
            ac_couple=False,
            xy_mode=False,
            num_inputs=1,
            trig_mode=gr.gr_TRIG_MODE_AUTO,
            y_axis_label="Counts",
        )
        self.Add(self.wxgui_scopesink2_0.win)
        self.gr_vector_to_stream_0 = gr.vector_to_stream(
            gr.sizeof_gr_complex * 1, fft_size)
        self.gr_stream_to_vector_0 = gr.stream_to_vector(
            gr.sizeof_gr_complex * 1, fft_size)
        self.gr_keep_m_in_n_0 = gr.keep_m_in_n(gr.sizeof_gr_complex, N_re,
                                               fft_size, (fft_size - N_re) / 2)
        self.gr_file_source_0 = gr.file_source(
            gr.sizeof_gr_complex * 1,
            "/home/user/git/gr-lte/gr-lte/test/foo_pss0_sss_in.cfile", True)
        self.gr_fft_vxx_0 = gr.fft_vcc(fft_size, True,
                                       (window.blackmanharris(1024)), True, 1)

        ##################################################
        # Connections
        ##################################################
        self.connect((self.gr_stream_to_vector_0, 0), (self.gr_fft_vxx_0, 0))
        self.connect((self.gr_file_source_0, 0),
                     (self.gr_stream_to_vector_0, 0))
        self.connect((self.gr_vector_to_stream_0, 0),
                     (self.gr_keep_m_in_n_0, 0))
        self.connect((self.gr_fft_vxx_0, 0), (self.gr_vector_to_stream_0, 0))
        self.connect((self.gr_keep_m_in_n_0, 0), (self.wxgui_scopesink2_0, 0))
Beispiel #45
0
    def __init__(self):
        """
        """

        v2s = gr.vector_to_stream(gr.sizeof_char, atsc.sizeof_atsc_mpeg_packet)
        self.sink = gr.vector_sink_b()
	gr.hier_block2.__init__(self, "vector_sink_ts",
				v2s.input_signature(),
				gr.io_signature(0, 0, 0))
        self.connect(self, v2s, self.sink)
Beispiel #46
0
    def __init__(self, ):
#    """
#    docstring
#	"""
        gr.hier_block2.__init__(self, "viterbi_vfvb",
                gr.io_signature(1,1, gr.sizeof_float*120), # sizeof (<+float+>)),  # Input signature
				gr.io_signature(1,1, gr.sizeof_char*40 )) #sizeof (<+float+>))) # Output signature

        #print "\nlte_viterbi_vfvb START"
        
        #tpp=gr.tag_propagation_policy()
        #################################
        # Define blocks
        # Repeat input vector one time to get viterbi decoder state right (tail-biting stuff)
        self.rpt  = gr.repeat(gr.sizeof_float*120,2)
        # viterbi decoder requires stream as input
        self.vtos = gr.vector_to_stream(1*gr.sizeof_float,120)
        
	
        # Correct FSM instantiation: k=num_input_bits, n=num_output_bits, Tuple[dim(k*n)] (decimal notation)
        self.fsm  = trellis.fsm(1,3,[91,121,117])

        # Values for viterbi decoder        
        K = 80  # steps for one coding block
        SO = 0  # initial state
        SK = -1 # final state (in this case unknown, therefore -1)
        D = 3   # dimensionality
        # D = 3 follows from the fact that 1 {0,1} input symbol of the encoder produces 3 {0,1} output symbols.
        # (packed into one byte {0,1,...,7} )
        # with NRZ coding follows: 
        # 0 -->  1
        # 1 --> -1
        # This leads to the following constellation input
        #               |  0  |  1   | 2    | 3     |  4   |  5    |  6    |  7     |
        constellation = [1,1,1,1,1,-1,1,-1,1,1,-1,-1,-1,1,1,-1,1,-1,-1,-1,1,-1,-1,-1]
        # print "len(constellation)/D = " + str(len(constellation)/D) + "\tfsm.O = " + str(self.fsm.O())
	    
	    # Viterbi_combined input: FSM, K, SO, SK, D, TABLE, TYPE
	    # FSM    = Finite State Machine
	    # K      = number of output symbols produced by the FSM
	    # SO     = initial state of the FSM
	    # SK     = final state of the FSM (unknown in this example)
	    # D      = dimensionality
	    # TABLE  = constellation of the input symbols
        self.vit  = trellis.viterbi_combined_fb(self.fsm,K,SO,SK,D,constellation,200)	

        # stream output of viterbi decoder to vector
        self.stov2 = gr.stream_to_vector(1*gr.sizeof_char,80)
        # second half of the viterbi output carries desired information. (tail-biting stuff)
        my_map=range(40)
        for i in my_map:
            my_map[i]=i+40
        self.map = lte.vector_resize_vbvb(my_map,80,40)

        self.connect(self,self.rpt,self.vtos,self.vit,self.stov2,self.map,self)
  def test_001(self):
    fft_length = 260
    carriers = 100
    shift = 20

    # select maximum estimation range
    estim_range = (fft_length-carriers)/2
    l = estim_range+shift
    r = estim_range-shift

    # create preambles
    pn1 = pn_preamble(carriers)
    pn2 = pn_preamble(carriers)
    diff_pn = concatenate([[conjugate(math.sqrt(2)*pn2[2*i]/pn1[2*i]),0.0j] for i in range(carriers/2)])	
    pn1_sym = extend_symbol(pn1,l,r)
    pn2_sym = extend_symbol(pn2,l,r)

    # block under tests
    cfo_estimator = ofdm.schmidl_cfo_estimator(fft_length,carriers,estim_range,diff_pn)

    # source, conversion, sink
    src_1 = gr.vector_source_c(pn1_sym)
    src_2 = gr.vector_source_c(pn2_sym)
    s2v_1 = gr.stream_to_vector(gr.sizeof_gr_complex,fft_length)
    s2v_2 = gr.stream_to_vector(gr.sizeof_gr_complex,fft_length)
    v2s = gr.vector_to_stream(gr.sizeof_float,2*estim_range+1)
    dst = gr.vector_sink_f()

    self.fg.connect(src_1, s2v_1, (cfo_estimator,0))
    self.fg.connect(src_2, s2v_2, (cfo_estimator,1))
    self.fg.connect(cfo_estimator,v2s,dst)

    # file output
    filesink = gr.file_sink(gr.sizeof_float,"test_cfo.float")
    vec_equ = vector_equalizer(2*estim_range+1)
    self.fg.connect(v2s,gr.float_to_complex(),
      gr.stream_to_vector(gr.sizeof_gr_complex,2*estim_range+1),
      vec_equ,gr.vector_to_stream(gr.sizeof_gr_complex,2*estim_range+1),
      gr.complex_to_float(),filesink)

    runtime=self.fg
    runtime.run()
Beispiel #48
0
    def test_003(self):
        # Same test as above, only use 2 threads

	tb = gr.top_block()
        fft_size = 32

        tmp_data = ((4377+4516j),
                    (-1706.1268310546875+1638.4256591796875j),
                    (-915.2083740234375+660.69427490234375j),
                    (-660.370361328125+381.59600830078125j),
                    (-499.96044921875+238.41630554199219j),
                    (-462.26748657226562+152.88948059082031j),
                    (-377.98440551757812+77.5928955078125j),
                    (-346.85821533203125+47.152004241943359j),
                    (-295+20j),
                    (-286.33609008789062-22.257017135620117j),
                    (-271.52999877929688-33.081821441650391j),
                    (-224.6358642578125-67.019538879394531j),
                    (-244.24473571777344-91.524826049804688j),
                    (-203.09068298339844-108.54627227783203j),
                    (-198.45195007324219-115.90768432617188j),
                    (-182.97744750976562-128.12318420410156j),
                    (-167-180j),
                    (-130.33688354492188-173.83778381347656j),
                    (-141.19784545898438-190.28807067871094j),
                    (-111.09677124023438-214.48896789550781j),
                    (-70.039543151855469-242.41630554199219j),
                    (-68.960540771484375-228.30015563964844j),
                    (-53.049201965332031-291.47097778320312j),
                    (-28.695289611816406-317.64553833007812j),
                    (57-300j),
                    (45.301143646240234-335.69509887695312j),
                    (91.936195373535156-373.32437133789062j),
                    (172.09465026855469-439.275146484375j),
                    (242.24473571777344-504.47515869140625j),
                    (387.81732177734375-666.6788330078125j),
                    (689.48553466796875-918.2142333984375j),
                    (1646.539306640625-1694.1956787109375j))

        src_data = tuple([x/fft_size for x in tmp_data])

        expected_result = tuple([complex(primes[2*i], primes[2*i+1]) for i in range(fft_size)])

        nthreads = 2

        src = gr.vector_source_c(src_data)
        s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
        fft = gr.fft_vcc(fft_size, False, [], False, nthreads)
        v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_size)
        dst = gr.vector_sink_c()
        tb.connect(src, s2v, fft, v2s, dst)
        tb.run()
        result_data = dst.data()
        self.assert_fft_ok2(expected_result, result_data)
Beispiel #49
0
    def test_003(self):
        # Same test as above, only use 2 threads

	tb = gr.top_block()
        fft_size = 32

        tmp_data = ((4377+4516j),
                    (-1706.1268310546875+1638.4256591796875j),
                    (-915.2083740234375+660.69427490234375j),
                    (-660.370361328125+381.59600830078125j),
                    (-499.96044921875+238.41630554199219j),
                    (-462.26748657226562+152.88948059082031j),
                    (-377.98440551757812+77.5928955078125j),
                    (-346.85821533203125+47.152004241943359j),
                    (-295+20j),
                    (-286.33609008789062-22.257017135620117j),
                    (-271.52999877929688-33.081821441650391j),
                    (-224.6358642578125-67.019538879394531j),
                    (-244.24473571777344-91.524826049804688j),
                    (-203.09068298339844-108.54627227783203j),
                    (-198.45195007324219-115.90768432617188j),
                    (-182.97744750976562-128.12318420410156j),
                    (-167-180j),
                    (-130.33688354492188-173.83778381347656j),
                    (-141.19784545898438-190.28807067871094j),
                    (-111.09677124023438-214.48896789550781j),
                    (-70.039543151855469-242.41630554199219j),
                    (-68.960540771484375-228.30015563964844j),
                    (-53.049201965332031-291.47097778320312j),
                    (-28.695289611816406-317.64553833007812j),
                    (57-300j),
                    (45.301143646240234-335.69509887695312j),
                    (91.936195373535156-373.32437133789062j),
                    (172.09465026855469-439.275146484375j),
                    (242.24473571777344-504.47515869140625j),
                    (387.81732177734375-666.6788330078125j),
                    (689.48553466796875-918.2142333984375j),
                    (1646.539306640625-1694.1956787109375j))

        src_data = tuple([x/fft_size for x in tmp_data])

        expected_result = tuple([complex(primes[2*i], primes[2*i+1]) for i in range(fft_size)])

        nthreads = 2

        src = gr.vector_source_c(src_data)
        s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
        fft = gr.fft_vcc(fft_size, False, [], False, nthreads)
        v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_size)
        dst = gr.vector_sink_c()
        tb.connect(src, s2v, fft, v2s, dst)
        tb.run()
        result_data = dst.data()
        self.assert_fft_ok2(expected_result, result_data)
Beispiel #50
0
 def help_cc(self, size, src_data, exp_data, op):
     for s in zip(range(len(src_data)), src_data):
         src = gr.vector_source_c(s[1])
         srcv = gr.stream_to_vector(gr.sizeof_gr_complex, size)
         self.tb.connect(src, srcv)
         self.tb.connect(srcv, (op, s[0]))
     rhs = gr.vector_to_stream(gr.sizeof_gr_complex, size)
     dst = gr.vector_sink_c()
     self.tb.connect(op, rhs, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertEqual(exp_data, result_data)
Beispiel #51
0
  def __init__(self, data_tones, num_symbols, mode=0):
    symbol_size = data_tones * gr.sizeof_gr_complex
    gr.hier_block2.__init__(self, "SNR",
      gr.io_signature2(2,2, symbol_size, symbol_size),
      gr.io_signature(1,1, gr.sizeof_float))

    sub = gr.sub_cc(data_tones)
    self.connect((self,0), (sub,0))
    self.connect((self,1), (sub,1))

    err = gr.complex_to_mag_squared(data_tones);
    self.connect(sub, err);
    pow = gr.complex_to_mag_squared(data_tones);
    self.connect((self,1), pow);

    if mode == 0:
      # one snr per symbol (num_symbols is ignored)
      snr = gr.divide_ff()
      self.connect(pow, gr.vector_to_stream(gr.sizeof_float, data_tones),
        gr.integrate_ff(data_tones), (snr,0))
      self.connect(err, gr.vector_to_stream(gr.sizeof_float, data_tones),
        gr.integrate_ff(data_tones), (snr,1))
      out = snr
    elif mode == 1:
      # one snr per packet
      snr = gr.divide_ff()
      self.connect(pow, gr.vector_to_stream(gr.sizeof_float, data_tones),
        gr.integrate_ff(data_tones*num_symbols), (snr,0))
      self.connect(err, gr.vector_to_stream(gr.sizeof_float, data_tones),
        gr.integrate_ff(data_tones*num_symbols), (snr,1))
      out = snr
    elif mode == 2:
      # one snr per frequency bin
      snr = gr.divide_ff(data_tones)
      self.connect(pow, raw.symbol_avg(data_tones, num_symbols), (snr,0))
      self.connect(err, raw.symbol_avg(data_tones, num_symbols), (snr,1))
      out = gr.vector_to_stream(gr.sizeof_float, data_tones)
      self.connect(snr, out)

    self.connect(out, gr.nlog10_ff(10), self)
Beispiel #52
0
  def __init__(self, framebytes, numframes, mode=0):
    gr.hier_block2.__init__(self, "BER",
      gr.io_signature2(2,2, framebytes, framebytes),
      gr.io_signature(1,1, gr.sizeof_float))

    xor = gr.xor_bb()
    self.connect((self,0), gr.vector_to_stream(gr.sizeof_char, framebytes), (xor,0))
    self.connect((self,1), gr.vector_to_stream(gr.sizeof_char, framebytes), (xor,1))

    if mode == 0:
      # one ber per packet
      ber = raw.ber_avg(1, framebytes)
      self.connect(xor,
                   ber)
    elif mode == 1:
      # one ber per byte in packet
      ber = raw.ber_avg(framebytes, numframes)
      self.connect(xor,
                   gr.stream_to_vector(gr.sizeof_char, framebytes),
                   ber)

    self.connect(ber, self)
    def simple_test2(self, gamma, beta):
        vlen = 208
        N = 20
        pcount = 8
        pdist = vlen / pcount
        assert ((pdist % 2) == 0)

        nondata_blocks = [0, 1]
        pilot_subc = numpy.arange(pcount) * pdist + pdist / 2 - vlen / 2
        assert (pilot_subc[0] == -pilot_subc[len(pilot_subc) - 1])

        data = [1. + 0.j] * vlen
        frame_start = [0] * N
        frame_start[0] = 1

        sub_dc = vlen / 2

        ind_range = numpy.arange(vlen) - vlen / 2
        assert (ind_range[0] == -vlen / 2)

        phase_offset = ind_range * gamma + numpy.ones(vlen) * beta
        assert (phase_offset[sub_dc] == beta)
        phase = phase_offset

        phase_offset = exp(1j * phase_offset)

        data = data * phase_offset
        data = concatenate([data] * N)

        src = gr.vector_source_c(data, False, vlen)
        src2 = gr.vector_source_b(frame_start, False)
        dst = gr.vector_sink_c()

        uut = ofdm.LMS_phase_tracking2(vlen, pilot_subc.tolist(),
                                       nondata_blocks)

        self.tb.connect(src, uut,
                        gr.vector_to_stream(gr.sizeof_gr_complex, vlen), dst)
        self.tb.connect(src2, (uut, 1))

        self.tb.run()

        d = numpy.array(dst.data())

        ad = numpy.angle(d[(len(nondata_blocks) * vlen):len(d)])
        ad2 = numpy.angle(d[0:(len(nondata_blocks) * vlen)])

        self.assertFloatTuplesAlmostEqual(
            concatenate([phase] * len(nondata_blocks)), ad2, 3)

        self.assertFloatTuplesAlmostEqual(numpy.zeros(len(ad)), ad, 3)
Beispiel #54
0
 def test_002_vector_slice_vv(self):
     """tests reversing and cutting off the beginning of the input"""
     src = gr.vector_source_f(
         (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
     expected_result = (5, 4, 3, 10, 9, 8, 15, 14, 13)
     dst = gr.vector_sink_f()
     reor1 = gr.stream_to_vector(gr.sizeof_float, 5)
     reor2 = gr.vector_to_stream(gr.sizeof_float, 3)
     slicer = mlse_swig.vector_slice_vv(gr.sizeof_float, 5, 2, 3, 1)
     self.tb.connect(src, reor1, slicer, reor2, dst)
     self.tb.run()
     self.tb.run()
     result_data = dst.data()
     self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
Beispiel #55
0
 def test_001_vector_slice_vv(self):
     """tests negative offsets"""
     src = gr.vector_source_f(
         (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
     expected_result = (0, 1, 2, 0, 6, 7, 0, 11, 12)
     dst = gr.vector_sink_f()
     reor1 = gr.stream_to_vector(gr.sizeof_float, 5)
     reor2 = gr.vector_to_stream(gr.sizeof_float, 3)
     slicer = mlse_swig.vector_slice_vv(gr.sizeof_float, 5, -1, 3)
     self.tb.connect(src, reor1, slicer, reor2, dst)
     self.tb.run()
     self.tb.run()
     result_data = dst.data()
     self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)