def __init__(self, options): ofdm = ofdm_rxtx.RX(options) qam = raw.qam_rx(options.bitrate, ofdm.params.data_tones, ofdm.size, log=options.log) framebytes = qam.framebytes if options.crc: framebytes = 188 gr.hier_block2.__init__(self, "QAM_RX", gr.io_signature(1,1, gr.sizeof_gr_complex), gr.io_signature(1,1, gr.sizeof_char * framebytes)) self.connect(self, ofdm, gr.vector_to_stream(gr.sizeof_gr_complex, ofdm.params.data_tones), qam) if options.crc: self.connect(qam, gr.stream_to_vector(gr.sizeof_char, framebytes + 4), raw.crc_dec(framebytes), self) else: self.connect(qam, gr.stream_to_vector(gr.sizeof_char, qam.framebytes), self) self.ofdm = ofdm self.qam = qam self.framebytes = framebytes
def test_001(self): fg = self.fg src1_data = (0,0.2,-0.3,0,12,0) src2_data = (0,0.0,3.0,0,10,0) src3_data = (0,0.0,3.0,0,1,0) src1 = gr.vector_source_f (src1_data) s2v1 = gr.stream_to_vector(gr.sizeof_float, len(src1_data)) fg.connect( src1, s2v1 ) src2 = gr.vector_source_f (src2_data) s2v2 = gr.stream_to_vector(gr.sizeof_float, len(src1_data)) fg.connect( src2, s2v2 ) src3 = gr.vector_source_f (src3_data) s2v3 = gr.stream_to_vector(gr.sizeof_float, len(src1_data)) fg.connect( src3, s2v3 ) dst1 = gr.vector_sink_s () dst2 = gr.vector_sink_s () argmax = gr.argmax_fs (len(src1_data)) fg.connect (s2v1, (argmax, 0)) fg.connect (s2v2, (argmax, 1)) fg.connect (s2v3, (argmax, 2)) fg.connect ((argmax,0), dst1) fg.connect ((argmax,1), dst2) fg.run () index = dst1.data () source = dst2.data () self.assertEqual ( index, (4,)) self.assertEqual ( source, (0,))
def __init__(self): 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)
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_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)
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_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)
def __init__(self, samplerate, bits_per_sec, fftlen): gr.hier_block2.__init__( self, "gmsk_sync", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature #this is just the old square-and-fft method #ais.freqest is simply looking for peaks spaced bits-per-sec apart self.square = gr.multiply_cc(1) self.fftvect = gr.stream_to_vector(gr.sizeof_gr_complex, fftlen) self.fft = gr.fft_vcc(fftlen, True, window.rectangular(fftlen), True) self.freqest = ais.freqest(int(samplerate), int(bits_per_sec), fftlen) self.repeat = gr.repeat(gr.sizeof_float, fftlen) self.fm = gr.frequency_modulator_fc(-1.0 / (float(samplerate) / (2 * pi))) self.mix = gr.multiply_cc(1) self.connect(self, (self.square, 0)) self.connect(self, (self.square, 1)) #this is the feedforward branch self.connect(self, (self.mix, 0)) #this is the feedback branch self.connect(self.square, self.fftvect, self.fft, self.freqest, self.repeat, self.fm, (self.mix, 1)) #and this is the output self.connect(self.mix, self)
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 __init__(self, fs, svn, alpha, fd_range, dump_bins=False): gr.hier_block2.__init__(self, "acquisition", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(3, 3, gr.sizeof_float)) fft_size = int(1e-3 * fs) doppler_range = self.get_doppler_range(fd_range) agc = gr.agc_cc(1.0 / fs, 1.0, 1.0, 1.0) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fft = gr.fft_vcc(fft_size, True, []) argmax = gr.argmax_fs(fft_size) max = gr.max_ff(fft_size) self.connect(self, s2v, fft) self.connect((argmax, 0), gr.short_to_float(), (self, 0)) self.connect((argmax, 1), gr.short_to_float(), gr.add_const_ff(-fd_range), gr.multiply_const_ff(1e3), (self, 1)) self.connect(max, (self, 2)) # Connect the individual channels to the input and the output. self.correlators = [ single_channel_correlator(fs, fd, svn, alpha, dump_bins) for fd in doppler_range ] for (correlator, i) in zip(self.correlators, range(len(self.correlators))): self.connect(fft, correlator) self.connect(correlator, (argmax, i)) self.connect(correlator, (max, i))
def __init__(self, N=512 , NW=3 , K=5, weighting='adaptive', fftshift=False): gr.hier_block2.__init__(self, "mtm", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_float*N)) self.check_parameters(N, NW, K) self.s2v = gr.stream_to_vector(gr.sizeof_gr_complex, N) self.connect(self, self.s2v) dpss = specest_gendpss.gendpss(N=N, NW=NW, K=K) self.mtm = [eigenspectrum(dpss.dpssarray[i], fftshift) for i in xrange(K)] if weighting == 'adaptive': self.sum = specest_swig.adaptiveweighting_vff(N, dpss.lambdas) self.connect_mtm(K) self.connect(self.sum, self) elif weighting == 'unity': self.sum = gr.add_ff(N) self.divide = gr.multiply_const_vff([1./K]*N) self.connect_mtm(K) self.connect(self.sum, self.divide, self) elif weighting == 'eigenvalues': self.eigvalmulti = [] self.lambdasum = 0 for i in xrange(K): self.eigvalmulti.append(gr.multiply_const_vff([dpss.lambdas[i]]*N)) self.lambdasum += dpss.lambdas[i] self.divide = gr.multiply_const_vff([1./self.lambdasum]*N) self.sum = gr.add_ff(N) self.connect_mtm(K) self.connect(self.sum, self.divide, self) else: raise ValueError, 'weighting-type should be: adaptive, unity or eigenvalues'
def __init__(self, dBm, pfa, pfd, useless_bw, plot_histogram, location): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 fft_size = 4096 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False self.histogram = plot_histogram primary_user_location = 5 nframes_to_check = 1 nframes_to_average = 1 downconverter = 1 mu = 0 src_data = self.generateRandomSignalSource( dBm, fft_size, mu, nframes_to_check * nframes_to_average, location) # Blocks src = gr.vector_source_c(src_data) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) self.ss = howto.spectrum_sensing_cf(samp_rate, fft_size, samples_per_band, pfd, pfa, tcme, output_pfa, debug_stats, primary_user_location, useless_bw, self.histogram, nframes_to_check, nframes_to_average, downconverter) self.sink = gr.vector_sink_f() # Connections self.connect(src, s2v, self.ss, self.sink)
def __init__(self, pfa, pfd, freq, useless_bw, nframes_to_check, nframes_to_average): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 fft_size = 4096 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False histogram = True primary_user_location = 42 nsegs_to_check = 6 downconverter = 1 # Blocks rtlsdr_source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" ) rtlsdr_source.set_sample_rate(samp_rate) rtlsdr_source.set_center_freq(freq, 0) rtlsdr_source.set_freq_corr(0, 0) rtlsdr_source.set_gain_mode(0, 0) rtlsdr_source.set_gain(10, 0) rtlsdr_source.set_if_gain(24, 0) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1) self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check) self.sink = gr.vector_sink_f() # Connections self.connect(rtlsdr_source, s2v, fftb, self.ss, self.sink)
def __init__(self, dBm, pfa, pfd, useless_bw): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False histogram = True primary_user_location = 0 mu = 0 fft_size = 16 history = 3 src_data = [1 + 1j] * fft_size * history # Blocks src = gr.vector_source_c(src_data) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) self.ss = howto.spectrum_sensing_cf(samp_rate, fft_size, samples_per_band, pfd, pfa, tcme, output_pfa, debug_stats, primary_user_location, useless_bw, histogram, history) self.sink = gr.vector_sink_f() # Connections self.connect(src, s2v, self.ss, self.sink)
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)
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 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)
def __init__(self, dbW, pfa, pfd): gr.top_block.__init__(self) # Parameters samp_rate = 2e6 fft_size = 4096 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False primary_user_location = 0 useless_bw = 0.0 # As we are not using any of the dongles it can be set as zero, i.e., all the band can be used. histogram = False nframes_to_check = 1 nframes_to_average = 1 downconverter = 1 nsegs_to_check = 6 # Create AWGN noise noise = awgn(fft_size, dbW) # Blocks src = gr.vector_source_c(noise) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1) self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check) self.sink = gr.vector_sink_f() # Connections self.connect(src, s2v, fftb, self.ss, self.sink)
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)
def helper(self, v0, v1, fft_length, preamble): tb = self.tb src0 = gr.vector_source_c(v0) src1 = gr.vector_source_b(v1) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length) # print "len(v) = %d" % (len(v)) op = gr.ofdm_insert_preamble(fft_length, preamble) v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_length) dst0 = gr.vector_sink_c() dst1 = gr.vector_sink_b() tb.connect(src0, s2v, (op, 0)) tb.connect(src1, (op, 1)) tb.connect((op, 0), v2s, dst0) tb.connect((op, 1), dst1) tb.run() r0 = dst0.data() r0v = [] for i in range(len(r0) // fft_length): r0v.append(r0[i * fft_length:(i + 1) * fft_length]) r1 = dst1.data() self.assertEqual(len(r0v), len(r1)) return (r1, r0v)
def test_002_energy_disp_vbb (self): ################################# src_data_0 = [] for number in range(22): src_data_0.append(0) for number in range(22): src_data_0.append(1) ################################ expected_result_0 = (0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,0, 1,1,1,1,1,0,0,0,0,1,0,0,0,0,0,1) ################################# # Objekte erzeugen src_0 = gr.vector_source_b (src_data_0) s2v_0 = gr.stream_to_vector(gr.sizeof_char, 22) Energy_disp = howto_swig.energy_disp_vbb(22) v2s_0 = gr.vector_to_stream(gr.sizeof_char, 16) dst_0 = gr.vector_sink_b() # Objekte verbinden self.tb.connect(src_0, s2v_0,Energy_disp,v2s_0,dst_0) # Simulationsstart self.tb.run () # Ergebnis auswerten result_data0 = dst_0.data () self.assertEqual(expected_result_0, result_data0)
def 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_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 __init__(self,options,Freq): gr.top_block.__init__(self) if options.input_file == "": self.IS_USRP2 = True else: self.IS_USRP2 = False #self.min_freq = options.start #self.max_freq = options.stop self.min_freq = Freq.value-(3*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more self.max_freq = Freq.value+(3*10**6) if self.min_freq > self.max_freq: self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them print "Start and stop frequencies order swapped!" self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 if self.IS_USRP2: self.u = uhd.usrp_source(options.args,uhd.io_type.COMPLEX_FLOAT32,num_channels=1) # Modified Line # self.u.set_decim(options.decim) # samp_rate = self.u.adc_rate()/self.u.decim() samp_rate = 100e6/options.decim # modified sampling rate self.u.set_samp_rate(samp_rate) else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 /options.decim # modified sampling rate self.freq_step =0 #0.75* samp_rate self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step) self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) # thread-safe message queue self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) # control scanning and record frequency domain statistics self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2 # if no gain was specified, use the mid-point in dB
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)
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_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)
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_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 = digital.ofdm_insert_preamble(fft_length, preamble) v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_length) dst0 = gr.vector_sink_c() dst1 = gr.vector_sink_b() tb.connect(src0, s2v, (op, 0)) tb.connect(src1, (op, 1)) tb.connect((op, 0), v2s, dst0) tb.connect((op, 1), dst1) tb.run() r0 = dst0.data() r0v = [] for i in range(len(r0)//fft_length): r0v.append(r0[i*fft_length:(i+1)*fft_length]) r1 = dst1.data() self.assertEqual(len(r0v), len(r1)) return (r1, r0v)
def test_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 __init__(self, dBm, pfa, pfd, nTrials): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 fft_size = 4096 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False histogram = False primary_user_location = 0 useless_bw = 200000.0 src_data = [0+0j]*fft_size*nTrials voltage = self.powerToAmplitude(dBm); # Blocks src = gr.vector_source_c(src_data) noise = gr.noise_source_c(gr.GR_GAUSSIAN, voltage, 42) add = gr.add_vcc() s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1) ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram) self.sink = gr.vector_sink_f() # Connections self.connect(src, add, s2v, fftb, ss, self.sink) self.connect(noise, (add, 1))
def xtest_004(self): vlen = 4 tune = counter4(self, 1) tune_delay = 1 dwell_delay = 2 msgq = gr.msg_queue() src_data = tuple([float(x) for x in ( 1, 2, 3, 4, 9, 6, 11, 8, 5, 10, 7, 12, 13, 14, 15, 16 )]) expected_results = tuple([float(x) for x in ( 9, 10, 11, 12)]) src = gr.vector_source_f(src_data, False) s2v = gr.stream_to_vector(gr.sizeof_float, vlen) stats = gr.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay) self.tb.connect(src, s2v, stats) self.tb.run() self.assertEqual(1, msgq.count()) for i in range(1): m = parse_msg(msgq.delete_head()) #print "m =", m.center_freq, m.data self.assertEqual(expected_results[vlen*i:vlen*i + vlen], m.data)
def test__002_t (self): """ Generate a signal with SNR as given below. Calculate the RMSE. """ nsamples = 1024 n_trials = 100 samp_rate = 32000 SNR = 20 # in dB self.siggen = siggen.signal_generator(n_sinusoids = 1, SNR = SNR, samp_rate = samp_rate, nsamples = nsamples * n_trials) self.stream = gr.stream_to_vector(gr.sizeof_gr_complex, nsamples) self.esprit = specest.esprit_vcf(n=1, m=64, nsamples = nsamples) self.sink = gr.vector_sink_f(vlen=1) # wire it up ... self.tb.connect(self.siggen, self.stream, self.esprit, self.sink) self.tb.run() MSE = 0.0 omega = self.siggen.omegas()[0] for i in range(n_trials): MSE += (omega - self.sink.data()[i])**2.0 print '\n' + 70*'-' print 'Testing specest_esprit_vcf ...' print 'Ran %u trials to estimate the frequency' % n_trials print 'Used %u samples to estimate the frequency' % nsamples print 'Sampling rate %s' % eng_notation.num_to_str(samp_rate) print 'SNR of %u dB' % SNR print 'Root mean square error %g' % numpy.sqrt(MSE/n_trials) print 'Cramer-Rao Bound %g' % numpy.sqrt(6/10**(SNR/10.0)/nsamples**3) print 70*'-'
def __init__(self,options,Freq): gr.top_block.__init__(self) if options.input_file == "": self.IS_USRP2 = True else: self.IS_USRP2 = False #self.min_freq = options.start #self.max_freq = options.stop self.min_freq = Freq.value-(3*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more self.max_freq = Freq.value+(3*10**6) if self.min_freq > self.max_freq: self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them print "Start and stop frequencies order swapped!" self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 if self.IS_USRP2: self.u = uhd.usrp_source(options.args,uhd.io_type.COMPLEX_FLOAT32,num_channels=1) # Modified Line # self.u.set_decim(options.decim) # samp_rate = self.u.adc_rate()/self.u.decim() samp_rate = 100e6/options.decim # modified sampling rate self.u.set_samp_rate(samp_rate) else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 /options.decim # modified sampling rate self.freq_step =0 #0.75* samp_rate self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) # thread-safe message queue self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) # control scanning and record frequency domain statistics self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2 # if no gain was specified, use the mid-point in dB
def run_flow_graph(sync_sym1, sync_sym2, data_sym): top_block = gr.top_block() carr_offset = random.randint(-max_offset/2, max_offset/2) * 2 tx_data = shift_tuple(sync_sym1, carr_offset) + \ shift_tuple(sync_sym2, carr_offset) + \ shift_tuple(data_sym, carr_offset) channel = [rand_range(min_chan_ampl, max_chan_ampl) * numpy.exp(1j * rand_range(0, 2 * numpy.pi)) for x in range(fft_len)] src = gr.vector_source_c(tx_data, False, fft_len) chan= gr.multiply_const_vcc(channel) noise = gr.noise_source_c(gr.GR_GAUSSIAN, wgn_amplitude) add = gr.add_cc(fft_len) chanest = digital.ofdm_chanest_vcvc(sync_sym1, sync_sym2, 1) sink = gr.vector_sink_c(fft_len) top_block.connect(src, chan, (add, 0), chanest, sink) top_block.connect(noise, gr.stream_to_vector(gr.sizeof_gr_complex, fft_len), (add, 1)) top_block.run() channel_est = None carr_offset_hat = 0 rx_sym_est = [0,] * fft_len tags = sink.tags() for tag in tags: if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_carr_offset': carr_offset_hat = pmt.pmt_to_long(tag.value) self.assertEqual(carr_offset, carr_offset_hat) if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': channel_est = shift_tuple(pmt.pmt_c32vector_elements(tag.value), carr_offset) shifted_carrier_mask = shift_tuple(carrier_mask, carr_offset) for i in range(fft_len): if shifted_carrier_mask[i] and channel_est[i]: self.assertAlmostEqual(channel[i], channel_est[i], places=0) rx_sym_est[i] = (sink.data()[i] / channel_est[i]).real return (carr_offset, list(shift_tuple(rx_sym_est, -carr_offset_hat)))
def __init__(self, fs, svn, alpha, fd_range, dump_bins=False): gr.hier_block2.__init__(self, "acquisition", gr.io_signature(1,1, gr.sizeof_gr_complex), gr.io_signature(3,3, gr.sizeof_float)) fft_size = int( 1e-3*fs) doppler_range = self.get_doppler_range(fd_range) agc = gr.agc_cc( 1.0/fs, 1.0, 1.0, 1.0) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fft = gr.fft_vcc(fft_size, True, []) argmax = gr.argmax_fs(fft_size) max = gr.max_ff(fft_size) self.connect( self, s2v, fft) self.connect( (argmax, 0), gr.short_to_float(), (self, 0)) self.connect( (argmax,1), gr.short_to_float(), gr.add_const_ff(-fd_range), gr.multiply_const_ff(1e3), (self,1)) self.connect( max, (self, 2)) # Connect the individual channels to the input and the output. self.correlators = [ single_channel_correlator( fs, fd, svn, alpha, dump_bins) for fd in doppler_range ] for (correlator, i) in zip( self.correlators, range(len(self.correlators))): self.connect( fft, correlator ) self.connect( correlator, (argmax, i) ) self.connect( correlator, (max, i) )
def __init__(self, dBm, pfa, pfd, useless_bw, plot_histogram): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False self.histogram = plot_histogram primary_user_location = 5 mu = 0 fft_size = 4096 nframes_to_check = 1 nframes_to_average = 1 downconverter = 1 src_data = self.generateRandomSignalSource(dBm, fft_size, mu, nframes_to_check*nframes_to_average) # Blocks src = gr.vector_source_c(src_data) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1) self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,self.histogram,nframes_to_check,nframes_to_average,downconverter) self.sink = gr.vector_sink_f() # Connections self.connect(src, s2v, fftb, self.ss, self.sink)
def __init__(self, dBm, pfa, pfd, useless_bw): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False histogram = True primary_user_location = 0 mu = 0 fft_size = 16 history = 3 src_data = [1+1j]*fft_size*history # Blocks src = gr.vector_source_c(src_data) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,history) self.sink = gr.vector_sink_f() # Connections self.connect(src, s2v, self.ss, self.sink)
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 __init__( self, parent, baseband_freq=0, y_per_div=10, ref_level=50, sample_rate=1, fac_size=512, fac_rate=default_fac_rate, average=False, avg_alpha=None, title="", size=default_facsink_size, peak_hold=False, ): fac_sink_base.__init__( self, input_is_real=False, baseband_freq=baseband_freq, y_per_div=y_per_div, ref_level=ref_level, sample_rate=sample_rate, fac_size=fac_size, fac_rate=fac_rate, average=average, avg_alpha=avg_alpha, title=title, peak_hold=peak_hold, ) s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fac_size) self.one_in_n = gr.keep_one_in_n( gr.sizeof_gr_complex * self.fac_size, max(1, int(self.sample_rate / self.fac_size / self.fac_rate)) ) # windowing removed ... fac = gr.fft_vcc(self.fac_size, True, ()) c2mag = gr.complex_to_mag(fac_size) # Things go off into the weeds if we try for an inverse FFT so a forward FFT will have to do... fac_fac = gr.fft_vfc(self.fac_size, True, ()) fac_c2mag = gr.complex_to_mag(fac_size) self.avg = gr.single_pole_iir_filter_ff(1.0, fac_size) log = gr.nlog10_ff( 20, self.fac_size, -20 * math.log10(self.fac_size) ) # - 20*math.log10(norm) ) # - self.avg[0] ) sink = gr.message_sink(gr.sizeof_float * fac_size, self.msgq, True) self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag, self.avg, log, sink) # gr.hier_block2.__init__(self, fg, s2p, sink) self.win = fac_window(self, parent, size=size) self.set_average(self.average) self.wxgui_connect(self, s2p)
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 __init__(self,subdev_spec=None,gain=None,length=1,alpha=1.0,msgq=None,loopback=False,verbose=False,debug=False): self._subdev_spec = subdev_spec self._gain = gain self._length = length self._alpha = alpha self._msgq = msgq self._loopback = loopback self._verbose = verbose self._debug = debug self._fg = gr.flow_graph() self._u = usrp.source_c(fpga_filename='usrp_sounder.rbf') if not self._loopback: if self._subdev_spec == None: self._subdev_spec = pick_subdevice(self._u) self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec)) self._subdev = usrp.selected_subdev(self._u, self._subdev_spec) if self._verbose: print "Using", self._subdev.name(), "for sounder receiver." self.set_gain(self._gain) self._vblen = gr.sizeof_gr_complex*self._length if self._debug: print "Generating impulse vectors of length", self._length, "byte length", self._vblen self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length) if self._verbose: print "Using smoothing alpha of", self._alpha self._lpf = gr.single_pole_iir_filter_cc(self._alpha, self._length) self._sink = gr.message_sink(self._vblen, self._msgq, True) self._fg.connect(self._u, self._s2v, self._lpf, self._sink)
def __init__(self, pfa, pfd, freq, useless_bw, nframes_to_check, nframes_to_average): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 fft_size = 4096 samples_per_band = 16 tcme = 1.9528 output_pfa = False debug_stats = False histogram = False primary_user_location = 20 nsegs_to_check = 6 downconverter = 1 # Blocks rtlsdr_source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" ) rtlsdr_source.set_sample_rate(samp_rate) rtlsdr_source.set_center_freq(freq, 0) rtlsdr_source.set_freq_corr(0, 0) rtlsdr_source.set_gain_mode(0, 0) rtlsdr_source.set_gain(10, 0) rtlsdr_source.set_if_gain(24, 0) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1) self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check) self.sink = gr.vector_sink_f() # Connections self.connect(rtlsdr_source, s2v, fftb, self.ss, self.sink)
def xtest_002(self): vlen = 4 tune = counter(1) tune_delay = 1 dwell_delay = 2 msgq = gr.msg_queue() src_data = tuple([ float(x) for x in (1, 2, 3, 4, 9, 6, 11, 8, 5, 10, 7, 12, 13, 14, 15, 16) ]) expected_results = tuple([float(x) for x in (9, 10, 11, 12)]) src = gr.vector_source_f(src_data, False) s2v = gr.stream_to_vector(gr.sizeof_float, vlen) stats = gr.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay) self.tb.connect(src, s2v, stats) self.tb.run() self.assertEqual(1, msgq.count()) for i in range(1): m = parse_msg(msgq.delete_head()) #print "m =", m.center_freq, m.data self.assertEqual(expected_results[vlen * i:vlen * i + vlen], m.data)
def test_001(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()
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_001_vector_concat_vv(self): src1 = gr.vector_source_f((1, 2, 3, 4, 5)) src2 = gr.vector_source_f((11, 12, 13)) expected_result = (1, 2, 3, 4, 5, 11, 12, 13) dst = gr.vector_sink_f() reor1 = gr.stream_to_vector(gr.sizeof_float, 5) reor2 = gr.stream_to_vector(gr.sizeof_float, 3) reor3 = gr.vector_to_stream(gr.sizeof_float, 8) cat = mlse_swig.vector_concat_vv(gr.sizeof_float * 5, gr.sizeof_float * 3) self.tb.connect(src1, reor1, (cat, 0)) self.tb.connect(src2, reor2, (cat, 1)) self.tb.connect(cat, reor3, dst) self.tb.run() self.tb.run() result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def __init__(self): sense_band_start=900*10**6 sense_band_stop=940*10**6 self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 print "*******************in sensor init********************" if self.IS_USRP2: self.u = usrp2.source_32fc(options.interface, options.MAC_addr) self.u.set_decim(options.decim) samp_rate = self.u.adc_rate() / self.u.decim() else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 / options.decim self.freq_step =0.75* samp_rate #self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = 0.75* samp_rate #self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step) self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames print tune_delay dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames print dwell_delay self.msgq = gr.msg_queue(16) self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.u.gain_range() options.gain = float(g[0]+g[1])/2
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 main(): tb = gr.top_block() # noise source n = mlse.randint_b(2) reshape_n = gr.stream_to_vector(1, 58 * 2) tb.connect(n, reshape_n) # limit experiment length head = gr.head(58 * 2, 1) tb.connect(reshape_n, head) # modulate gsm_burstmod = gsm.gsm_modulate_burst() tb.connect(head, gsm_burstmod) random_tsc_index = mlse.randint_b(8) tb.connect(random_tsc_index, (gsm_burstmod, 1)) # apply channel channel = gsm.my_channel(-100, [0.2, 1, 0.2]) channel_apply = gsm.apply_channel_to_vect(148, channel, 1) tb.connect(gsm_burstmod, channel_apply) # derotate derot = mlse.derotate_cc(148, 4, -1) #FIXME: why -1? (not as if it matters) tb.connect(channel_apply, derot) modsink = gr.vector_sink_c(148) datasink = gr.vector_sink_b(58 * 2) tb.connect(derot, modsink) tb.connect(head, datasink) # mlse-decode decode = mlse.equalizer_midamble_vcb(mlse.make_packet_config_gsm()) tb.connect(derot, decode) tb.connect(random_tsc_index, (decode, 1)) # ber ber = mlse.ber_vbi(58 * 2) tb.connect(decode, ber) tb.connect(head, (ber, 1)) result_sink = gr.vector_sink_b(58 * 2) tb.connect(decode, result_sink) chanest_sink = gr.vector_sink_c(7) tb.connect((decode, 1), chanest_sink) tb.run() tb.run() d = modsink.data() # printvect_c(d) print ber.bit_error_rate() print_bitvect(datasink.data()) print_bitvect(result_sink.data()) import operator print_bitvect(map(operator.xor, datasink.data(), result_sink.data())) printvect_c(chanest_sink.data())
def __init__(self, parent, baseband_freq=0, y_per_div=10, ref_level=50, sample_rate=1, fac_size=512, fac_rate=default_fac_rate, average=False, avg_alpha=None, title='', size=default_facsink_size, peak_hold=False): fac_sink_base.__init__(self, input_is_real=True, baseband_freq=baseband_freq, y_per_div=y_per_div, ref_level=ref_level, sample_rate=sample_rate, fac_size=fac_size, fac_rate=fac_rate, average=average, avg_alpha=avg_alpha, title=title, peak_hold=peak_hold) s2p = gr.stream_to_vector(gr.sizeof_float, self.fac_size) self.one_in_n = gr.keep_one_in_n( gr.sizeof_float * self.fac_size, max(1, int(self.sample_rate / self.fac_size / self.fac_rate))) # windowing removed... fac = gr.fft_vfc(self.fac_size, True, ()) c2mag = gr.complex_to_mag(self.fac_size) self.avg = gr.single_pole_iir_filter_ff(1.0, self.fac_size) fac_fac = gr.fft_vfc(self.fac_size, True, ()) fac_c2mag = gr.complex_to_mag(fac_size) # FIXME We need to add 3dB to all bins but the DC bin log = gr.nlog10_ff(20, self.fac_size, -20 * math.log10(self.fac_size)) sink = gr.message_sink(gr.sizeof_float * self.fac_size, self.msgq, True) self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag, self.avg, log, sink) # gr.hier_block.__init__(self, fg, s2p, sink) self.win = fac_window(self, parent, size=size) self.set_average(self.average) self.wxgui_connect(self, s2p)
def __init__(self, parent, baseband_freq=0, y_per_div=10, ref_level=50, sample_rate=1, fac_size=512, fac_rate=default_fac_rate, average=False, avg_alpha=None, title='', size=default_facsink_size, peak_hold=False): fac_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq, y_per_div=y_per_div, ref_level=ref_level, sample_rate=sample_rate, fac_size=fac_size, fac_rate=fac_rate, average=average, avg_alpha=avg_alpha, title=title, peak_hold=peak_hold) s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fac_size) self.one_in_n = gr.keep_one_in_n( gr.sizeof_gr_complex * self.fac_size, max(1, int(self.sample_rate / self.fac_size / self.fac_rate))) # windowing removed ... fac = gr.fft_vcc(self.fac_size, True, ()) c2mag = gr.complex_to_mag(fac_size) # Things go off into the weeds if we try for an inverse FFT so a forward FFT will have to do... fac_fac = gr.fft_vfc(self.fac_size, True, ()) fac_c2mag = gr.complex_to_mag(fac_size) self.avg = gr.single_pole_iir_filter_ff(1.0, fac_size) log = gr.nlog10_ff(20, self.fac_size, -20 * math.log10( self.fac_size)) # - 20*math.log10(norm) ) # - self.avg[0] ) sink = gr.message_sink(gr.sizeof_float * fac_size, self.msgq, True) self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag, self.avg, log, sink) # gr.hier_block2.__init__(self, fg, s2p, sink) self.win = fac_window(self, parent, size=size) self.set_average(self.average) self.wxgui_connect(self, s2p)
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))