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 __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)
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_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 __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 supply_rx_baseband(self): ## RX Spectrum if self.__dict__.has_key('rx_baseband'): return self.rx_baseband config = self.config fftlen = config.fft_length my_window = window.hamming(fftlen) #.blackmanharris(fftlen) rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen) rxs_trigger = gr.vector_source_b(concatenate([[1],[0]*199]),True) rxs_window = blocks.multiply_const_vcc(my_window) rxs_spectrum = gr.fft_vcc(fftlen,True,[],True) rxs_mag = gr.complex_to_mag(fftlen) rxs_avg = gr.single_pole_iir_filter_ff(0.01,fftlen) rxs_logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen)) rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,50) t = self.u if self.filter is None else self.filter self.connect(rxs_trigger,(rxs_sampler,1)) self.connect(t,rxs_sampler,rxs_window, rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate) if self._options.log: log_to_file(self, rxs_decimate_rate, "data/supply_rx.float") self.rx_baseband = rxs_decimate_rate return rxs_decimate_rate
def setUp(self): self.tb = gr.top_block() #print os.getpid() #raw_input("Press the ANY key!") offset = 43223 #sample15 = 21839 #sample20 = 43223 fftl = 512 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:100000]) self.src = gr.vector_source_c(intu, False, 1) self.tag = lte_swig.tag_symbol_cc(offset, fftl) self.sel = lte_swig.pss_selector_cvc(fftl) self.fft = gr.fft_vcc(fftl, True, window.rectangular(fftl), False, 1) self.ext = lte_swig.extract_occupied_tones_vcvc(N_rb_dl, fftl) self.tagp = lte.pss_tagging_cc(fftl) # Dummy self.calc = lte.pss_calc_vc(self.tagp, self.sel, fftl) #self.snk = gr.vector_sink_c(fftl) self.tb.connect(self.src, self.tag, self.sel, self.fft, self.ext, self.calc)
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 publish_rx_spectrum(self,fftlen): ## RX Spectrum fftlen = 256 my_window = window.hamming(fftlen) #.blackmanharris(fftlen) rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen) rxs_trigger = gr.vector_source_b(concatenate([[1],[0]*199]),True) rxs_window = blocks.multiply_const_vcc(my_window) rxs_spectrum = gr.fft_vcc(fftlen,True,[],True) rxs_mag = gr.complex_to_mag(fftlen) rxs_avg = gr.single_pole_iir_filter_ff(0.01,fftlen) rxs_logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen)) rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,1) msgq = gr.msg_queue(5) rxs_msg_sink = gr.message_sink(gr.sizeof_float*fftlen,msgq,True) self.connect(rxs_trigger,(rxs_sampler,1)) t = self.u if self.filter is None else self.filter self.connect(t,rxs_sampler,rxs_window, rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate, rxs_msg_sink) self.servants.append(corba_data_buffer_servant("spectrum",fftlen,msgq)) print "RXS trigger unique id", rxs_trigger.unique_id() print "Publishing RX baseband under id: spectrum"
def __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 __init__(self, fg, parent, baseband_freq=0, y_per_div=10, ref_level=100, sample_rate=1, fft_size=512, fft_rate=20, average=True, avg_alpha=None, title='', size=default_fftsink_size): fft_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, fft_size=fft_size, fft_rate=fft_rate, average=average, avg_alpha=avg_alpha, title=title) s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, fft_size) one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * fft_size, int(sample_rate/fft_size/fft_rate)) mywindow = window.blackmanharris(fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) #fft = gr.fft_vcc(fft_size, True, True) c2mag = gr.complex_to_mag(fft_size) self.avg = gr.single_pole_iir_filter_ff(1.0, fft_size) log = gr.nlog10_ff(20, fft_size) sink = gr.file_descriptor_sink(gr.sizeof_float * fft_size, self.w_fd) fg.connect(s2p, one_in_n, fft, c2mag, self.avg, log, sink) # gr.hier_block.__init__(self, fg, s2p, sink) #print self.r_fd self.fg = fg self.win = gl_fft_window(self)
def __init__(self, fg, parent, baseband_freq=0, y_per_div=10, ref_level=50, sample_rate=1, fft_size=512, fft_rate=default_fft_rate, average=False, avg_alpha=None, title='', size=default_fftsink_size, peak_hold=False): fft_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, fft_size=fft_size, fft_rate=fft_rate, average=average, avg_alpha=avg_alpha, title=title, peak_hold=peak_hold) s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) self.one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size, max(1, int(self.sample_rate/self.fft_size/self.fft_rate))) mywindow = window.blackmanharris(self.fft_size) power = 0 for tap in mywindow: power += tap*tap fft = gr.fft_vcc(self.fft_size, True, mywindow) c2mag = gr.complex_to_mag(fft_size) self.avg = gr.single_pole_iir_filter_ff(1.0, fft_size) log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) sink = gr.message_sink(gr.sizeof_float * fft_size, self.msgq, True) fg.connect(s2p, self.one_in_n, fft, c2mag, self.avg, log, sink) gr.hier_block.__init__(self, fg, s2p, sink) self.win = fft_window(self, parent, size=size) self.set_average(self.average)
def __init__(self, parent, baseband_freq=0, y_per_div=10, ref_level=50, sample_rate=1, fft_size=512, fft_rate=default_fft_rate, average=False, avg_alpha=None, title='', size=default_fftsink_size): gr.hier_block2.__init__(self, "waterfall_sink_f", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0,0,0)) waterfall_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq, sample_rate=sample_rate, fft_size=fft_size, fft_rate=fft_rate, average=average, avg_alpha=avg_alpha, title=title) self.s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, self.fft_size) self.one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size, max(1, int(self.sample_rate/self.fft_size/self.fft_rate))) mywindow = window.blackmanharris(self.fft_size) self.fft = gr.fft_vcc(self.fft_size, True, mywindow) self.c2mag = gr.complex_to_mag(self.fft_size) self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size) self.log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size)) self.sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True) self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.avg, self.log, self.sink) self.win = waterfall_window(self, parent, size=size) self.set_average(self.average)
def supply_rx_baseband(self): ## RX Spectrum if self.__dict__.has_key('rx_baseband'): return self.rx_baseband config = self.config fftlen = config.fft_length my_window = window.hamming(fftlen) #.blackmanharris(fftlen) rxs_sampler = vector_sampler(gr.sizeof_gr_complex, fftlen) rxs_trigger = blocks.vector_source_b(concatenate([[1], [0] * 199]), True) rxs_window = blocks.multiply_const_vcc(my_window) rxs_spectrum = gr.fft_vcc(fftlen, True, [], True) rxs_mag = gr.complex_to_mag(fftlen) rxs_avg = gr.single_pole_iir_filter_ff(0.01, fftlen) rxs_logdb = gr.nlog10_ff(20.0, fftlen, -20 * log10(fftlen)) rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float * fftlen, 50) t = self.u if self.filter is None else self.filter self.connect(rxs_trigger, (rxs_sampler, 1)) self.connect(t, rxs_sampler, rxs_window, rxs_spectrum, rxs_mag, rxs_avg, rxs_logdb, rxs_decimate_rate) if self._options.log: log_to_file(self, rxs_decimate_rate, "data/supply_rx.float") self.rx_baseband = rxs_decimate_rate return rxs_decimate_rate
def 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, 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_id_1, N_id_2, slot0=True, N_re=128, N_cp_ts=144, freq_corr=0): top = gr.top_block("foo") source = gr.vector_source_c(range(0, N_re), False, N_re) source.set_data(gen_sss_fd(N_id_1, N_id_2, N_re).get_sss(slot0)) fft = gr.fft_vcc(N_re, False, window.blackmanharris(1024), True) cp = digital.ofdm_cyclic_prefixer(N_re, N_re + N_cp_ts * N_re / 2048) if freq_corr != 0: freq_corr = gr.freq_xlating_fir_filter_ccf(1, 1, freq_corr, 15000 * N_re) sink = gr.vector_sink_c(1) top.connect(source, fft, cp) if freq_corr != 0: top.connect(cp, freq_corr, sink) else: top.connect(cp, sink) top.run() self.data = sink.data()
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 setUp (self): self.tb = gr.top_block () #print os.getpid() #raw_input("Press the ANY key!") offset = 43223 #sample15 = 21839 #sample20 = 43223 fftl = 512 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:100000]) self.src = gr.vector_source_c(intu,False,1) self.tag = lte_swig.tag_symbol_cc(offset,fftl) self.sel = lte_swig.pss_selector_cvc(fftl) self.fft = gr.fft_vcc(fftl,True,window.rectangular(fftl),False,1) self.ext = lte_swig.extract_occupied_tones_vcvc(N_rb_dl,fftl) self.tagp = lte.pss_tagging_cc(fftl) # Dummy self.calc = lte.pss_calc_vc(self.tagp,self.sel,fftl) #self.snk = gr.vector_sink_c(fftl) self.tb.connect(self.src, self.tag, self.sel, self.fft, self.ext, self.calc)
def __init__(self, fg, parent, baseband_freq=0, ref_level=0, sample_rate=1, fft_size=512, fft_rate=default_fft_rate, average=False, avg_alpha=None, title='', size=default_fftsink_size, report=None, span=40, ofunc=None, xydfunc=None): waterfall_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq, sample_rate=sample_rate, fft_size=fft_size, fft_rate=fft_rate, average=average, avg_alpha=avg_alpha, title=title) s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, self.fft_size) self.one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size, max(1, int(self.sample_rate/self.fft_size/self.fft_rate))) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) c2mag = gr.complex_to_mag(self.fft_size) self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size) log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size)) sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True) self.block_list = (s2p, self.one_in_n, fft, c2mag, self.avg, log, sink) self.reconnect( fg ) gr.hier_block.__init__(self, fg, s2p, sink) self.win = waterfall_window(self, parent, size=size, report=report, ref_level=ref_level, span=span, ofunc=ofunc, xydfunc=xydfunc) self.set_average(self.average)
def __init__(self, fftl): """ This hierarchical block has a complex input and complex output stream. The actual data remains unchanged. The N_id_2 or cell ID number is calculated. Based on the position of the PSS the frame structure is calculated on a half frame basis and tagged to the output stream together with N_id_2 A tag with the slot number within a half frame is tagged at the beginning of every slot. (key = slot) A tag with the N_id_2 is tagged at the beginning of every half frame. (Corresponds to slot 0) (key = N_id_2) The input data must be tagged with information for symbols. (key = symbol) the tag propagation policy is set to TPP_DONT. """ gr.hier_block2.__init__( self, "hier_pss_sync_cc", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature # This is a fixed value due to the fact that the PSS is always located at the 62 center carriers. N_rb_dl = 6 self.tag = lte.pss_tagging_cc(fftl) self.sel = lte.pss_selector_cvc(fftl) self.fft = gr.fft_vcc(fftl, True, window.rectangular(fftl), False, 1) self.ext = lte.extract_occupied_tones_vcvc(N_rb_dl, fftl) self.calc = lte.pss_calc_vc(self.tag, self.sel, fftl) # Define blocks self.connect(self, self.tag, self) self.connect(self, self.sel, self.fft, self.ext, self.calc)
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, parent, baseband_freq=0, y_per_div=10, sc_y_per_div=0.5, sc_ref_level=40, ref_level=50, sample_rate=1, fft_size=512, fft_rate=15, average=False, avg_alpha=None, title='', size=default_ra_fftsink_size, peak_hold=False, ofunc=None, xydfunc=None): gr.hier_block2.__init__(self, "ra_fft_sink_c", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)) ra_fft_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq, y_per_div=y_per_div, sc_y_per_div=sc_y_per_div, sc_ref_level=sc_ref_level, ref_level=ref_level, sample_rate=sample_rate, fft_size=fft_size, fft_rate=fft_rate, average=average, avg_alpha=avg_alpha, title=title, peak_hold=peak_hold, ofunc=ofunc, xydfunc=xydfunc) s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, fft_size) one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * fft_size, max(1, int(sample_rate/fft_size/fft_rate))) mywindow = window.blackmanharris(fft_size) fft = gr.fft_vcc(fft_size, True, mywindow) c2mag = gr.complex_to_mag(fft_size) self.avg = gr.single_pole_iir_filter_ff(1.0, fft_size) log = gr.nlog10_ff(20, fft_size, -20*math.log10(fft_size)) sink = gr.message_sink(gr.sizeof_float * fft_size, self.msgq, True) self.connect(self, s2p, one_in_n, fft, c2mag, self.avg, log, sink) self.win = fft_window(self, parent, size=size) self.set_average(self.average)
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, fftl): """ This hierarchical block has a complex input and complex output stream. The actual data remains unchanged. The N_id_2 or cell ID number is calculated. Based on the position of the PSS the frame structure is calculated on a half frame basis and tagged to the output stream together with N_id_2 A tag with the slot number within a half frame is tagged at the beginning of every slot. (key = slot) A tag with the N_id_2 is tagged at the beginning of every half frame. (Corresponds to slot 0) (key = N_id_2) The input data must be tagged with information for symbols. (key = symbol) the tag propagation policy is set to TPP_DONT. """ gr.hier_block2.__init__(self, "hier_pss_sync_cc", gr.io_signature(1,1, gr.sizeof_gr_complex), # Input signature gr.io_signature(1,1, gr.sizeof_gr_complex)) # Output signature # This is a fixed value due to the fact that the PSS is always located at the 62 center carriers. N_rb_dl = 6; self.tag = lte.pss_tagging_cc(fftl) self.sel = lte.pss_selector_cvc(fftl) self.fft = gr.fft_vcc(fftl,True,window.rectangular(fftl),False,1) self.ext = lte.extract_occupied_tones_vcvc(N_rb_dl,fftl) self.calc = lte.pss_calc_vc(self.tag,self.sel,fftl) # Define blocks self.connect(self, self.tag, self) self.connect(self, self.sel, self.fft, self.ext, self.calc)
def main(): parser = OptionParser(conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") add_options(parser, expert_grp) (options, args) = parser.parse_args() fft_length = options.fft_length or 512 file = options.file or "input.compl" out = options.out or "output.compl" src = gr.file_source(gr.sizeof_gr_complex, file) sampler = ofdm.vector_sampler(gr.sizeof_gr_complex, fft_length) trig = gr.vector_source_b([1], True) fft = gr.fft_vcc(fft_length, True, [], True) mag = gr.complex_to_mag(fft_length) avg = gr.single_pole_iir_filter_ff(0.01, fft_length) nlog = gr.nlog10_ff(20, fft_length, -10 * math.log10(fft_length)) dst = gr.file_sink(gr.sizeof_float * fft_length, out) fg = gr.top_block() fg.connect(src, sampler, fft, mag, avg, nlog, dst) fg.connect(trig, (sampler, 1)) # fg.connect(src,limit, # gr.stream_to_vector(gr.sizeof_gr_complex,fft_length), # fft, # gr.multiply_const_vcc([1./fft_length]*fft_length), # gr.complex_to_mag(fft_length), # gr.nlog10_ff(10.0,fft_length), # dst) # fg.connect( src, fft, dst ) fg.run() print "done"
def main(): parser = OptionParser(conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") add_options(parser, expert_grp) (options, args) = parser.parse_args () fft_length = options.fft_length or 512 file = options.file or "input.compl" out = options.out or "output.compl" src = gr.file_source(gr.sizeof_gr_complex,file) sampler = ofdm.vector_sampler( gr.sizeof_gr_complex, fft_length ) trig = gr.vector_source_b([1],True) fft = gr.fft_vcc( fft_length, True, [], True ) mag = gr.complex_to_mag( fft_length ) avg = gr.single_pole_iir_filter_ff(0.01, fft_length) nlog = gr.nlog10_ff( 20, fft_length, -10*math.log10(fft_length) ) dst = gr.file_sink( gr.sizeof_float * fft_length, out ) fg = gr.top_block() fg.connect( src, sampler, fft, mag, avg, nlog, dst ) fg.connect( trig, (sampler,1)) # fg.connect(src,limit, # gr.stream_to_vector(gr.sizeof_gr_complex,fft_length), # fft, # gr.multiply_const_vcc([1./fft_length]*fft_length), # gr.complex_to_mag(fft_length), # gr.nlog10_ff(10.0,fft_length), # dst) # fg.connect( src, fft, dst ) fg.run() print "done"
def __init__(self, parent, baseband_freq=0, y_per_div=10, ref_level=50, sample_rate=1, fft_size=512, fft_rate=default_fft_rate, average=False, avg_alpha=None, title='', size=default_fftsink_size, **kwargs): gr.hier_block2.__init__(self, "waterfall_sink_f", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0,0,0)) waterfall_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq, sample_rate=sample_rate, fft_size=fft_size, fft_rate=fft_rate, average=average, avg_alpha=avg_alpha, title=title) self.s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, self.fft_size) self.one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size, max(1, int(self.sample_rate/self.fft_size/self.fft_rate))) mywindow = window.blackmanharris(self.fft_size) self.fft = gr.fft_vcc(self.fft_size, True, mywindow) self.c2mag = gr.complex_to_mag(self.fft_size) self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size) self.log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size)) self.sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True) self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.avg, self.log, self.sink) self.win = waterfall_window(self, parent, size=size) self.set_average(self.average)
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 __init__(self, dpss, fftshift=False): gr.hier_block2.__init__(self, "eigenspectrum", gr.io_signature(1, 1, gr.sizeof_gr_complex*len(dpss)), gr.io_signature(1, 1, gr.sizeof_float*len(dpss))) self.window = dpss self.fft = gr.fft_vcc(len(dpss), True, self.window, fftshift) self.c2mag = gr.complex_to_mag_squared(len(dpss)) self.connect(self, self.fft, self.c2mag, self)
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 __init__(self, options): gr.top_block.__init__(self) self._fft_length = 64 win = [] self.source = gr.file_source(gr.sizeof_gr_complex * self._fft_length, options.from_file) self.ifft = gr.fft_vcc(self._fft_length, True, win, False) self.sink = gr.file_sink(gr.sizeof_gr_complex * self._fft_length, options.to_file) self.connect(self.source,self.ifft,self.sink)
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))
def test_006(self): vlen = 128 syms = 4 bin1 = vlen / 2 - vlen / 4 bin2 = vlen / 2 + vlen / 3 bin1_val = 1.0j bin2_val = -1.0 vec = numpy.array(numpy.zeros(vlen), numpy.complex) vec[bin1] = bin1_val vec[bin2] = bin2_val vec = concatenate([vec] * syms) epsilon = [1, -4, 5, 2] frame_trigger = [1] * syms expec = numpy.array(numpy.zeros(vlen * syms), numpy.complex) for i in range(syms): expec[bin1 + i * vlen + epsilon[i]] = bin1_val expec[bin2 + i * vlen + epsilon[i]] = bin2_val 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) 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(epsilon) trig = gr.vector_source_b(frame_trigger) 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.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5)
def test_006 (self): vlen = 128 syms = 4 bin1 = vlen/2-vlen/4 bin2 = vlen/2+vlen/3 bin1_val = 1.0j bin2_val = -1.0 vec = numpy.array(numpy.zeros(vlen), numpy.complex) vec[bin1] = bin1_val vec[bin2] = bin2_val vec = concatenate([vec]*syms) epsilon = [1,-4,5,2] frame_trigger = [1]*syms expec = numpy.array(numpy.zeros(vlen*syms), numpy.complex) for i in range(syms): expec[bin1+i*vlen+epsilon[i]] = bin1_val expec[bin2+i*vlen+epsilon[i]] = bin2_val 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) 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(epsilon) trig = gr.vector_source_b(frame_trigger) 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.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5)
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)
def __init__( self, vlen ): gr.hier_block2.__init__( self, "scaled_fft", gr.io_signature( 1, 1, gr.sizeof_gr_complex * vlen ), gr.io_signature( 1, 1, gr.sizeof_gr_complex * vlen ) ) fft = gr.fft_vcc( vlen, True, [], True ) fft_scale = gr.multiply_const_vcc( [1.0/vlen]*vlen ) self.connect( self, fft, fft_scale, self )
def publish_spectrum(self,fftlen): spectrum = gr.fft_vcc(fftlen,True,[],True) mag = gr.complex_to_mag(fftlen) logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen)) decimate_rate = gr.keep_one_in_n(gr.sizeof_gr_complex*fftlen,10) msgq = gr.msg_queue(10) msg_sink = gr.message_sink(gr.sizeof_float*fftlen,msgq,True) self.connect(self.filter,gr.stream_to_vector(gr.sizeof_gr_complex,fftlen), decimate_rate,spectrum,mag,logdb,msg_sink) self.servants.append(corba_data_buffer_servant("tx_spectrum",fftlen,msgq))
def test_002(self): vlen = 128 syms = 4 vec = numpy.array(numpy.zeros(vlen), numpy.complex) vec[vlen / 2 - vlen / 4] = 1.0 vec = concatenate([vec] * syms) epsilon = [-1] frame_trigger = numpy.concatenate([[1], [0] * (syms - 1)]) expec = numpy.array(numpy.zeros(vlen * syms), numpy.complex) for i in range(syms): expec[vlen / 2 - vlen / 4 + i * vlen + epsilon[0]] = 1.0 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) 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(epsilon) trig = gr.vector_source_b(frame_trigger.tolist()) 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.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-6)
def test_002 (self): vlen = 128 syms = 4 vec = numpy.array(numpy.zeros(vlen), numpy.complex) vec[vlen/2-vlen/4] = 1.0 vec = concatenate([vec]*syms) epsilon = [-1] frame_trigger = numpy.concatenate([[1],[0]*(syms-1)]) expec = numpy.array(numpy.zeros(vlen*syms), numpy.complex) for i in range(syms): expec[vlen/2-vlen/4+i*vlen+epsilon[0]] = 1.0 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) 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(epsilon) trig = gr.vector_source_b(frame_trigger.tolist()) 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.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-6)
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))
def __init__(self, mpoints, taps=None): """ Takes 1 complex stream in, produces M complex streams out that runs at 1/M times the input sample rate @param mpoints: number of freq bins/interpolation factor/subbands @param taps: filter taps for subband filter Same channel to frequency mapping as described above. """ item_size = gr.sizeof_gr_complex gr.hier_block2.__init__( self, "analysis_filterbank", gr.io_signature(1, 1, item_size), # Input signature gr.io_signature(mpoints, mpoints, item_size), ) # Output signature if taps is None: taps = _generate_synthesis_taps(mpoints) # pad taps to multiple of mpoints r = len(taps) % mpoints if r != 0: taps = taps + (mpoints - r) * (0,) # split in mpoints separate set of taps sub_taps = _split_taps(taps, mpoints) # print >> sys.stderr, "mpoints =", mpoints, "len(sub_taps) =", len(sub_taps) self.s2ss = gr.stream_to_streams(item_size, mpoints) # filters here self.ss2v = gr.streams_to_vector(item_size, mpoints) self.fft = gr.fft_vcc(mpoints, True, []) self.v2ss = gr.vector_to_streams(item_size, mpoints) self.connect(self, self.s2ss) # build mpoints fir filters... for i in range(mpoints): f = gr.fft_filter_ccc(1, sub_taps[mpoints - i - 1]) self.connect((self.s2ss, i), f) self.connect(f, (self.ss2v, i)) self.connect((self.v2ss, i), (self, i)) self.connect(self.ss2v, self.fft, self.v2ss)
def __init__(self, mpoints, taps=None): """ Takes 1 complex stream in, produces M complex streams out that runs at 1/M times the input sample rate @param mpoints: number of freq bins/interpolation factor/subbands @param taps: filter taps for subband filter Same channel to frequency mapping as described above. """ item_size = gr.sizeof_gr_complex gr.hier_block2.__init__( self, "analysis_filterbank", gr.io_signature(1, 1, item_size), # Input signature gr.io_signature(mpoints, mpoints, item_size)) # Output signature if taps is None: taps = _generate_synthesis_taps(mpoints) # pad taps to multiple of mpoints r = len(taps) % mpoints if r != 0: taps = taps + (mpoints - r) * (0, ) # split in mpoints separate set of taps sub_taps = _split_taps(taps, mpoints) # print >> sys.stderr, "mpoints =", mpoints, "len(sub_taps) =", len(sub_taps) self.s2ss = gr.stream_to_streams(item_size, mpoints) # filters here self.ss2v = gr.streams_to_vector(item_size, mpoints) self.fft = gr.fft_vcc(mpoints, True, []) self.v2ss = gr.vector_to_streams(item_size, mpoints) self.connect(self, self.s2ss) # build mpoints fir filters... for i in range(mpoints): f = gr.fft_filter_ccc(1, sub_taps[mpoints - i - 1]) self.connect((self.s2ss, i), f) self.connect(f, (self.ss2v, i)) self.connect((self.v2ss, i), (self, i)) self.connect(self.ss2v, self.fft, self.v2ss)
def __init__(self, options): """ @param options: parsed raw.ofdm_params """ self.params = ofdm_params(options) params = self.params gr.hier_block2.__init__( self, "ofdm_mod", gr.io_signature2(2, 2, gr.sizeof_gr_complex * params.data_tones, gr.sizeof_char), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature win = [] #[1 for i in range(self._fft_length)] # see gr_fft_vcc_fftw that it works differently if win = [1 1 1 ...] self.mapper = raw.ofdm_mapper(params.padded_carriers) self.preambles = digital.ofdm_insert_preamble(params.fft_length, params.padded_preambles) self.ifft = gr.fft_vcc(params.fft_length, False, win, True) self.cp_adder = digital.ofdm_cyclic_prefixer( params.fft_length, params.fft_length + params.cp_length) self.scale = gr.multiply_const_cc(1.0 / math.sqrt(params.fft_length)) self.connect((self, 0), self.mapper, (self.preambles, 0)) self.connect((self, 1), (self.preambles, 1)) self.connect(self.preambles, self.ifft, self.cp_adder, self.scale, self) if options.log: self.connect( self.mapper, gr.file_sink(gr.sizeof_gr_complex * params.fft_length, "tx-map.dat")) self.connect( self.preambles, gr.file_sink(gr.sizeof_gr_complex * params.fft_length, "tx-pre.dat")) self.connect( self.ifft, gr.file_sink(gr.sizeof_gr_complex * params.fft_length, "tx-ifft.dat")) self.connect(self.cp_adder, gr.file_sink(gr.sizeof_gr_complex, "tx-cp.dat"))
def __init__(self, N_id_2, N_re=128, N_cp_ts=144, freq_corr=0, repeat=False): gr.hier_block2.__init__( self, "PSS source time-domain", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_gr_complex), ) self.pss_fd = pss_source_fd(N_id_2, N_re, repeat); self.fft = gr.fft_vcc(N_re, False, window.blackmanharris(1024), True) self.cp = digital.ofdm_cyclic_prefixer(N_re, N_re+N_cp_ts*N_re/2048) if freq_corr != 0: self.freq_corr = gr.freq_xlating_fir_filter_ccf(1, 1, freq_corr, 15000*N_re) self.connect(self.pss_fd, self.fft, self.cp) if freq_corr != 0: self.connect(self.cp, self.freq_corr, self) else: self.connect(self.cp, self)
def __init__(self): gr.top_block.__init__(self) gain=0.7 target_freq=930e6 decim=16 interface="" MAC_addr="" fft_size=512 self.u = usrp2.source_32fc() self.u.set_decim(128) self.u.set_center_freq(930e6) self.u.set_gain(0) self.u.config_mimo(usrp2.MC_WE_DONT_LOCK) self.s2v = gr.stream_to_vector(gr.sizeof_gr_complex*1, 512) self.f_sink = gr.file_sink(gr.sizeof_gr_complex*512, "fft_data") self.f_sink.set_unbuffered(False) self.fft = gr.fft_vcc(512, True, (window.blackmanharris(512)), True) self.connect(self.u,self.s2v,self.fft,self.f_sink)
def __init__(self, N_id_1, N_id_2, slot0=True, N_re=128, N_cp_ts=144, freq_corr=0): top = gr.top_block("foo"); source = gr.vector_source_c(range(0,N_re), False, N_re) source.set_data(gen_sss_fd(N_id_1, N_id_2, N_re).get_sss(slot0)); fft = gr.fft_vcc(N_re, False, window.blackmanharris(1024), True) cp = digital.ofdm_cyclic_prefixer(N_re, N_re+N_cp_ts*N_re/2048) if freq_corr != 0: freq_corr = gr.freq_xlating_fir_filter_ccf(1, 1, freq_corr, 15000*N_re) sink = gr.vector_sink_c(1) top.connect(source, fft, cp) if freq_corr != 0: top.connect(cp, freq_corr, sink) else: top.connect(cp, sink) top.run() self.data = sink.data()
def __init__(self, fs, fd, svn, alpha, dump_bins=False): fft_size = int(1e-3 * fs) gr.hier_block2.__init__( self, "single_channel_correlator", gr.io_signature(1, 1, gr.sizeof_gr_complex * fft_size), gr.io_signature(1, 1, gr.sizeof_float * fft_size)) lc = local_code(svn=svn, fs=fs, fd=fd) mult = gr.multiply_vcc(fft_size) ifft = gr.fft_vcc(fft_size, False, []) mag = gr.complex_to_mag_squared(fft_size) self.iir = gr.single_pole_iir_filter_ff(alpha, fft_size) self.connect(self, (mult, 0)) self.connect(lc, (mult, 1)) self.connect(mult, ifft, mag, self.iir, self) if dump_bins == True: self.connect_debug_sink(self.iir, fft_size, '/home/trondd/opengnss_output', fd)
def __init__(self, daemon, fftl): """ docstring """ gr.hier_block2.__init__( self, "hier_sss_sync_cc", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature # input goes into 2 blocks: selector and tagging # 2 parallel streams: main (all data) right into tagging, sss symbol -> fft -> extract -> calc sss # required blocks: # selector # fft # resize (extract) # calc sss # tagging # SSS selector block self.sel = lte_swig.sss_selector_cvc(fftl) # in this block N_rb_dl is fixed. SSS is always mapped to those carriers. N_rb_dl = 6 # fft block and matching extract block # input : vector with size: gr_complex * fftl # output: vector with size: gr_complex * 12 * N_rb_dl self.fft = gr.fft_vcc(fftl, True, window.rectangular(fftl), False, 1) self.ext = lte_swig.extract_occupied_tones_vcvc(N_rb_dl, fftl) self.tag = lte_swig.sss_tagging_cc(fftl) # calc sink block, which sets some attributes of other blocks. self.calc = lte_swig.sss_calc_vci(self.tag, daemon, fftl) # Connect blocks self.connect(self, self.tag, self) self.connect(self, self.sel, self.fft, self.ext, self.calc)
def __init__(self, fft_length, cp_length, occupied_tones, snr, logging=False): """ Hierarchical block for receiving OFDM symbols. The input is the complex modulated signal at baseband. Synchronized packets are sent back to the demodulator. @param fft_length: total number of subcarriers @type fft_length: int @param cp_length: length of cyclic prefix as specified in subcarriers (<= fft_length) @type cp_length: int @param occupied_tones: number of subcarriers used for data @type occupied_tones: int @param snr: estimated signal to noise ratio used to guide cyclic prefix synchronizer @type snr: float @param logging: turn file logging on or off @type logging: bool """ gr.hier_block2.__init__( self, "ofdm_receiver", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature2(2, 2, gr.sizeof_gr_complex * fft_length, gr.sizeof_char * fft_length)) # Output signature bw = (float(occupied_tones) / float(fft_length)) / 2.0 tb = bw * 0.08 chan_coeffs = gr.firdes.low_pass( 1.0, # gain 1.0, # sampling rate bw + tb, # midpoint of trans. band tb, # width of trans. band gr.firdes.WIN_HAMMING) # filter type #self.chan_filt = gr.fft_filter_ccc(1, chan_coeffs) self.chan_filt = gr.multiply_cc(1) win = [1 for i in range(fft_length)] ks0time = fft_length * (0, ) SYNC = "ml" if SYNC == "ml": #TODO -1.0/... nco_sensitivity = -1.0 / fft_length # correct for fine frequency self.ofdm_sync = ofdm_sync_ml.ofdm_sync_ml(fft_length, cp_length, snr, ks0time, logging) elif SYNC == "pn": nco_sensitivity = -2.0 / fft_length # correct for fine frequency self.ofdm_sync = ofdm_sync_pn.ofdm_sync_pn(fft_length, cp_length, logging) elif SYNC == "pnac": nco_sensitivity = -2.0 / fft_length # correct for fine frequency self.ofdm_sync = ofdm_sync_pnac.ofdm_sync_pnac( fft_length, cp_length, ks0time, logging) # for testing only; do not user over the air # remove filter and filter delay for this elif SYNC == "fixed": self.chan_filt = gr.multiply_const_cc(1.0) nsymbols = 18 # enter the number of symbols per packet freq_offset = 0.0 # if you use a frequency offset, enter it here nco_sensitivity = -2.0 / fft_length # correct for fine frequency self.ofdm_sync = ofdm_sync_fixed.ofdm_sync_fixed( fft_length, cp_length, nsymbols, freq_offset, logging) # Set up blocks #self.grnull = gr.null_sink(4); self.nco = gr.frequency_modulator_fc( nco_sensitivity ) # generate a signal proportional to frequency error of sync block self.sigmix = gr.multiply_cc() self.sampler = digital_swig.ofdm_sampler(fft_length, fft_length + cp_length) self.fft_demod = gr.fft_vcc(fft_length, True, win, True) self.connect(self, self.chan_filt) # filter the input channel self.connect(self.chan_filt, self.ofdm_sync) # into the synchronization alg. self.connect( (self.ofdm_sync, 0), self.nco, (self.sigmix, 1)) # use sync freq. offset output to derotate input signal self.connect(self.chan_filt, (self.sigmix, 0)) # signal to be derotated self.connect( self.sigmix, (self.sampler, 0)) # sample off timing signal detected in sync alg #self.connect(self.chan_filt, (self.sampler,0)) # sample off timing signal detected in sync alg self.connect((self.ofdm_sync, 1), (self.sampler, 1)) # timing signal to sample at self.connect((self.sampler, 0), self.fft_demod) # send derotated sampled signal to FFT self.connect(self.fft_demod, (self, 0)) # frequency domain signal sent to output 0 self.connect((self.sampler, 1), (self, 1)) # timing sent to output 1 print "setup OK" logging = 0 if logging: self.connect( self.chan_filt, gr.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-chan_filt_c.dat")) self.connect((self.ofdm_sync, 0), gr.file_sink(gr.sizeof_float, "ofdm_receiver-sync_0.dat")) self.connect((self.ofdm_sync, 1), gr.file_sink(gr.sizeof_char, "ofdm_receiver-sync_1.dat")) self.connect( self.nco, gr.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-nco_c.dat")) self.connect( self.sigmix, gr.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-sigmix_c.dat")) self.connect((self.sampler, 0), gr.file_sink(gr.sizeof_gr_complex * fft_length, "ofdm_receiver-sampler_0.dat")) self.connect((self.sampler, 1), gr.file_sink(gr.sizeof_char * fft_length, "ofdm_receiver-sampler_1.dat")) self.connect( self.fft_demod, gr.file_sink(gr.sizeof_gr_complex * fft_length, "ofdm_receiver-fft_out_c.dat"))