def BuildFFT(self,scope=True): fft0w = filter.window.blackmanharris(2048) fft0 = fft.fft_vcc(2048, True, fft0w, True) fft1w = filter.window.blackmanharris(2048) fft1 = fft.fft_vcc(2048, True, fft1w, True) self.connect(self.rx0,blocks.stream_to_vector(gr.sizeof_gr_complex, 2048),fft0) self.connect(self.rx1,blocks.stream_to_vector(gr.sizeof_gr_complex, 2048),fft1) v2s = blocks.vector_to_stream(gr.sizeof_float,20) fp2 = findphase_c(2048) self.connect(fft0,(fp2,0)) self.connect(fft1,(fp2,1)) self.connect(fp2,v2s) if scope: self.ffth = qtgui.histogram_sink_f(100,360,-179,180,"FFT Phase Histogram") #self.ffth.enable_autoscale(False) self.ffth.enable_accumulate(True) self.ffth.enable_grid(True) #self.histo.enable_menu(True) self.connect(v2s,self.ffth) self.ffthqt = sip.wrapinstance(self.ffth.pyqwidget(), QtGui.QWidget) self.ffthqt.show()
def __init__(self): gr.top_block.__init__(self) self.sample_rate = 5000000 self.ampl = 0.1 self.freq = 144000000 self.uhd = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd.set_samp_rate(self.sample_rate) self.uhd.set_center_freq(self.freq, 0) self.uhd.set_gain(0, 0) self.uhd.set_antenna("RX2", 0) self.fft_vxx_0 = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1) self.throttle = blocks.throttle(gr.sizeof_gr_complex*1, self.sample_rate,True) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, self.sample_rate,True) self.stream = blocks.stream_to_vector_decimator( item_size=gr.sizeof_gr_complex, sample_rate=self.sample_rate, vec_rate=30, vec_len=1024, ) self.probe = blocks.probe_signal_vf(1024) self.fft = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1) src0 = analog.sig_source_c(self.sample_rate, analog.GR_SIN_WAVE, self.freq, self.ampl) dst = audio.sink(self.sample_rate, "") self.sqrt = blocks.complex_to_mag_squared(1024) def fft_out(): while 1: val = self.probe.level() print max(val) freq = (val.index(max(val)) * (self.sample_rate/1024.0)) + (self.freq - (self.sample_rate/2.0)) print freq time.sleep(1) fft_thread = threading.Thread(target=fft_out) fft_thread.daemon = True fft_thread.start() self.connect((self.uhd,0),(self.throttle, 0)) self.connect((self.throttle,0),(self.stream,0)) self.connect((self.stream, 0),(self.fft, 0)) self.connect((self.fft, 0),(self.sqrt, 0)) self.connect((self.sqrt, 0),(self.probe, 0))
def __init__(self, N=12, M=256, indices=[], mapping=0, modulation=16, cp_ratio=0.25): gr.hier_block2.__init__(self, "scfdma_receiver_cb", gr.io_signature(1, 1, gr.sizeof_gr_complex*1), gr.io_signature(len(indices), len(indices), gr.sizeof_char*1), ) ################################################## # Parameters ################################################## self.indices = indices self.modulation = modulation self.cp_ratio = cp_ratio self.M = M self.N = N self.mapping = mapping ################################################## # Variables ################################################## self.demappers = demappers = list() self.idft_blocks = idft_blocks = list() self.estimation_blocks = estimation_blocks = list() ################################################## # Blocks ################################################## # self.ofdm_scfdma_subcarrier_demapper_vcvc_0 = ofdm.scfdma_subcarrier_demapper_vcvc(N, M, start_index, mapping) # self.ofdm_fbmc_symbol_estimation_vcb_0 = ofdm.fbmc_symbol_estimation_vcb(N, modulation) # self.fft_vxx_0_0 = fft.fft_vcc(N, False, (), True, 1) self.fft_vxx_0 = fft.fft_vcc(M, True, (), True, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, M) self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_gr_complex, M, int(M*(1+cp_ratio)), int(cp_ratio*M)) # create demappers, idft and estimation blocks for i in range(len(indices)): self.demappers.append(ofdm.scfdma_subcarrier_demapper_vcvc(N, M, indices[i], mapping)) self.idft_blocks.append(fft.fft_vcc(N, False, (), True, 1)) self.estimation_blocks.append(ofdm.fbmc_symbol_estimation_vcb(N, modulation)) ################################################## # Connections ################################################## self.connect((self, 0), (self.blocks_keep_m_in_n_0, 0)) self.connect((self.blocks_keep_m_in_n_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) # connect the rest for i in range(len(indices)): self.connect((self.fft_vxx_0, 0), (self.demappers[i],0)) self.connect((self.demappers[i],0), (self.idft_blocks[i],0)) self.connect((self.idft_blocks[i],0), (self.estimation_blocks[i],0)) self.connect((self.estimation_blocks[i],0), (self, i))
def test_004_connect(self): """ Advanced test: - Allocator -> IFFT -> Frequency offset -> FFT -> Serializer - FFT does shift (moves DC to middle) - Make sure input == output - Frequency offset is -2 carriers """ fft_len = 8 n_syms = 1 carr_offset = -2 freq_offset = 1.0 / fft_len * carr_offset # Normalized frequency occupied_carriers = ((-2, -1, 1, 2),) pilot_carriers = ((-3,), (3,)) pilot_symbols = ((1j,), (-1j,)) tx_data = (1, 2, 3, 4) tag_name = "len" tag = gr.tag_t() tag.offset = 0 tag.key = pmt.string_to_symbol(tag_name) tag.value = pmt.from_long(len(tx_data)) offsettag = gr.tag_t() offsettag.offset = 0 offsettag.key = pmt.string_to_symbol("ofdm_sync_carr_offset") offsettag.value = pmt.from_long(carr_offset) src = blocks.vector_source_c(tx_data, False, 1, (tag, offsettag)) alloc = digital.ofdm_carrier_allocator_cvc( fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (), tag_name ) tx_ifft = fft.fft_vcc(fft_len, False, (1.0 / fft_len,) * fft_len, True) oscillator = analog.sig_source_c(1.0, analog.GR_COS_WAVE, freq_offset, 1.0 / fft_len) mixer = blocks.multiply_cc() rx_fft = fft.fft_vcc(fft_len, True, (), True) sink2 = blocks.vector_sink_c(fft_len) self.tb.connect(rx_fft, sink2) serializer = digital.ofdm_serializer_vcc(alloc, "", 0, "ofdm_sync_carr_offset", True) sink = blocks.vector_sink_c() self.tb.connect( src, alloc, tx_ifft, blocks.vector_to_stream(gr.sizeof_gr_complex, fft_len), (mixer, 0), blocks.stream_to_vector(gr.sizeof_gr_complex, fft_len), rx_fft, serializer, sink, ) self.tb.connect(oscillator, (mixer, 1)) self.tb.run() self.assertComplexTuplesAlmostEqual(sink.data()[-len(occupied_carriers[0]) :], tx_data, places=4)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 2.4e6 ################################################## # Blocks ################################################## self.howto_spectrum_sensing_cf_0 = howto.spectrum_sensing_cf(samp_rate,2048,16,0.001,0.0001,1.9528,True,True,0,200000.0,False,3,4,1,6) self.gr_null_sink_0 = gr.null_sink(gr.sizeof_float*1) self.fft_vxx_0 = fft.fft_vcc(2048, True, (window.blackmanharris(1024)), False, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 2048) self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 1000, 1, 0) ################################################## # Connections ################################################## self.connect((self.fft_vxx_0, 0), (self.howto_spectrum_sensing_cf_0, 0)) self.connect((self.howto_spectrum_sensing_cf_0, 0), (self.gr_null_sink_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.analog_sig_source_x_0, 0), (self.blocks_stream_to_vector_0, 0))
def test_reverse_window_shift(self): src_data = tuple([x / self.fft_size for x in primes_transformed]) expected_result = ( (-74.8629 - 63.2502j), (-3.5446 - 2.0365j), (2.9231 + 1.6827j), (-2.7852 - 0.8613j), (2.4763 + 2.7881j), (-2.7457 - 3.2602j), (4.7748 + 2.4145j), (-2.8807 - 4.5313j), (5.9949 + 4.1976j), (-6.1095 - 6.0681j), (5.2248 + 5.7743j), (-6.0436 - 6.3773j), (9.7184 + 9.2482j), (-8.2791 - 8.6507j), (6.3273 + 6.1560j), (-12.2841 - 12.4692j), (10.5816 + 10.0241j), (-13.0312 - 11.9451j), (12.2983 + 13.3644j), (-13.0372 - 14.0795j), (14.4682 + 13.3079j), (-16.7673 - 16.7287j), (14.3946 + 11.5916j), (-16.8368 - 21.3156j), (20.4528 + 16.8499j), (-18.4075 - 18.2446j), (17.7507 + 19.2109j), (-21.5207 - 20.7159j), (22.2183 + 19.8012j), (-22.2144 - 20.0343j), (17.0359 + 17.6910j), (-91.8955 - 103.1093j)) window = fft.window.hamming(ntaps=self.fft_size) src = blocks.vector_source_c(src_data) s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) op = fft.fft_vcc(self.fft_size, False, window, True) v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size) dst = blocks.vector_sink_c() self.tb.connect(src, s2v, op, v2s, dst) self.tb.run() result_data = dst.data() self.assert_fft_ok2(expected_result, result_data)
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, fft_len, rate, sample_rate): gr.hier_block2.__init__(self, "psd_logger", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)) self.fft_len = fft_len self.rate = rate self.sample_rate = sample_rate self.msgq = gr.msg_queue(2) self.log_file = open( '/tmp/psd_log' + '-' + time.strftime("%y%m%d") + '-' + time.strftime("%H%M%S"), 'w') self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n( gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate / self.fft_len / self.rate))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, mywindow) power = 0 for tap in mywindow: power += tap * tap self.c2mag = blocks.complex_to_mag(self.fft_len) self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True) self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.sink) self._watcher = _queue_watcher(self.msgq, self.log_file)
def __init__(self, N=400): gr.top_block.__init__(self, "Compress Fft") ################################################## # Parameters ################################################## self.N = N ################################################## # Blocks ################################################## self.rfsniffer_stream_to_vector_overlap_0 = rfsniffer.stream_to_vector_overlap(gr.sizeof_gr_complex, N, N/2) self.fft_vxx_0 = fft.fft_vcc(N, True, (window.hanning(N)), True, 1) self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, N) self.blocks_file_source_0 = blocks.file_source(gr.sizeof_gr_complex*1, "/tmp/capture.iq", False) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex*1, "/tmp/compress_fft.iq", False) self.blocks_file_sink_0.set_unbuffered(False) ################################################## # Connections ################################################## self.connect((self.blocks_file_source_0, 0), (self.rfsniffer_stream_to_vector_overlap_0, 0)) self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0)) self.connect((self.rfsniffer_stream_to_vector_overlap_0, 0), (self.fft_vxx_0, 0))
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 __init__(self, fft_size=2048, decim=100): gr.hier_block2.__init__( self, "RA:FFT", gr.io_signature(1, 1, gr.sizeof_gr_complex*1), gr.io_signature(1, 1, gr.sizeof_float*fft_size), ) ################################################## # Parameters ################################################## self.fft_size = fft_size self.decim = decim ################################################## # Blocks ################################################## self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(1.0/decim, fft_size) self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), True, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff(([1.0/fft_size]*fft_size)) self.blocks_keep_one_in_n_0 = blocks.keep_one_in_n(gr.sizeof_float*fft_size, decim) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_size) ################################################## # Connections ################################################## self.connect((self.blocks_multiply_const_vxx_0, 0), (self.single_pole_iir_filter_xx_0, 0)) self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.single_pole_iir_filter_xx_0, 0), (self.blocks_keep_one_in_n_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_keep_one_in_n_0, 0), (self, 0))
def __init__(self): gr.hier_block2.__init__(self, "ofdm_tx", gr.io_signature(1, 1, gr.sizeof_char), gr.io_signature(1, 1, gr.sizeof_gr_complex)) self.sequencr = aux.insert_sequence_numbers_bb() self.encoder = aux.encoder_reed_solomon_bb() self.framer = blocks.stream_to_tagged_stream( gr.sizeof_char, 1, config.get_bytes_per_frame(), LEN_TAG_KEY) #divide the incoming data streams in frames self.connect(self, self.sequencr, self.encoder, self.framer) #We can do some byte scrambling if needed (variable modulus modulation ) self.unpacker_data_stream = blocks.repack_bits_bb( #modulation of the data (split the bytes, and modulate the split bytes 8, config.get_bits_per_symbol(), LEN_TAG_KEY) self.modulator_data_stream = digital.chunks_to_symbols_bc( config.get_constellation().points()) self.connect(self.framer, self.unpacker_data_stream, self.modulator_data_stream) self.allocator = digital.ofdm_carrier_allocator_cvc( config.get_fft_length(), occupied_carriers=config.get_data_tones(), pilot_carriers=config.get_pilot_tones(), pilot_symbols=config.get_pilot_symbols(), sync_words=config.get_preambles(), len_tag_key=LEN_TAG_KEY) self.connect(self.modulator_data_stream, self.allocator) self.fft_block = fft.fft_vcc(config.get_fft_length(), False, (), True) self.connect(self.allocator, self.fft_block) self.prefixer = digital.ofdm_cyclic_prefixer( config.get_fft_length(), config.get_cp_length() + config.get_fft_length(), 0, LEN_TAG_KEY) self.burst_handler = aux.add_zeros_cc( 14, 104) #digital.burst_shaper_cc([],1040,1040,False, LEN_TAG_KEY) self.connect(self.fft_block, self.prefixer, self.burst_handler) self.connect(self.burst_handler, self)
def __init__(self, window_size): gr.hier_block2.__init__(self, "FFT_IFFT", gr.io_signature(1,1,gr.sizeof_float), gr.io_signature(1,1,gr.sizeof_float)) vector_to_stream = blocks.vector_to_stream(gr.sizeof_gr_complex, window_size) stream_to_vector = blocks.stream_to_vector(gr.sizeof_float, window_size) divide = blocks.divide_cc(1) complex_to_float = blocks.complex_to_float(1) fft_forward = fft.fft_vfc(window_size, True, (fft.window.blackmanharris(window_size)), 1) fft_backward = fft.fft_vcc(window_size, False, (fft.window.blackmanharris(window_size)), False, 1) constant = analog.sig_source_c(0, analog.GR_CONST_WAVE, 0, 0, window_size) #print("1. Connect self to stream_to_vector") self.connect((self, 0), (stream_to_vector, 0)) #print("2. Connect stream_to_vector to fft_forward") self.connect((stream_to_vector, 0), (fft_forward, 0)) #print("3. Connect fft_forward to fft_backward") self.connect((fft_forward, 0), (fft_backward, 0)) #print("4. Connect fft_backward to vector_to_stream") self.connect((fft_backward, 0), (vector_to_stream, 0)) #print("5. Connect vector_to_stream to port 0 of divide") self.connect((vector_to_stream, 0), (divide, 0)) #print("6. Connect constant to port 1 of divide") self.connect(constant, (divide, 1)) #print("7. Connect divide to complex_to_float") self.connect((divide, 0), (complex_to_float, 0)) #print("8. Connect complex_to_float to self") self.connect((complex_to_float, 0), (self, 0))
def __init__(self, n_chans, n_filterbanks=1, taps=None, outchans=None, atten=100, bw=1.0, tb=0.2, ripple=0.1): if n_filterbanks > n_chans: n_filterbanks = n_chans if outchans is None: outchans = range(n_chans) gr.hier_block2.__init__( self, "pfb_channelizer_hier_ccf", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(len(outchans), len(outchans), gr.sizeof_gr_complex)) if taps is None: taps = optfir.low_pass(1, n_chans, bw, bw+tb, ripple, atten) taps = list(taps) extra_taps = int(math.ceil(1.0*len(taps)/n_chans)*n_chans - len(taps)) taps = taps + [0] * extra_taps # Make taps for each channel chantaps = [list(reversed(taps[i: len(taps): n_chans])) for i in range(0, n_chans)] # Convert the input stream into a stream of vectors. self.s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, n_chans) # Create a mapping to separate out each filterbank (a group of channels to be processed together) # And a list of sets of taps for each filterbank. low_cpp = int(n_chans/n_filterbanks) extra = n_chans - low_cpp*n_filterbanks cpps = [low_cpp+1]*extra + [low_cpp]*(n_filterbanks-extra) splitter_mapping = [] filterbanktaps = [] total = 0 for cpp in cpps: splitter_mapping.append([(0, i) for i in range(total, total+cpp)]) filterbanktaps.append(chantaps[total: total+cpp]) total += cpp assert(total == n_chans) # Split the stream of vectors in n_filterbanks streams of vectors. self.splitter = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], splitter_mapping) # Create the filterbanks self.fbs = [filter.filterbank_vcvcf(taps) for taps in filterbanktaps] # Combine the streams of vectors back into a single stream of vectors. combiner_mapping = [[]] for i, cpp in enumerate(cpps): for j in range(cpp): combiner_mapping[0].append((i, j)) self.combiner = blocks.vector_map(gr.sizeof_gr_complex, cpps, combiner_mapping) # Add the final FFT to the channelizer. self.fft = fft.fft_vcc(n_chans, forward=True, window=[1.0]*n_chans) # Select the desired channels if outchans != range(n_chans): selector_mapping = [[(0, i) for i in outchans]] self.selector = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], selector_mapping) # Convert stream of vectors to a normal stream. self.v2ss = blocks.vector_to_streams(gr.sizeof_gr_complex, len(outchans)) self.connect(self, self.s2v, self.splitter) for i in range(0, n_filterbanks): self.connect((self.splitter, i), self.fbs[i], (self.combiner, i)) self.connect(self.combiner, self.fft) if outchans != range(n_chans): self.connect(self.fft, self.selector, self.v2ss) else: self.connect(self.fft, self.v2ss) for i in range(0, len(outchans)): self.connect((self.v2ss, i), (self, i))
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, 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_gr_complex*len(dpss))) self.window = dpss self.fft = fft.fft_vcc(len(dpss), True, self.window, fftshift) self.connect(self, self.fft, self)
def __init__(self, cf): gr.top_block.__init__(self, "FM radio FFT example") ################################################## # Blocks ################################################## self.fft_vxx_0 = fft.fft_vcc(2048, True, (window.rectangular(2048)), True, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 2048) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*2048, "/home/pradeep/tutorial_btp/fm/out", False) self.blocks_file_sink_0.set_unbuffered(False) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(2048) self.RTL820T = osmosdr.source( args="numchan=" + str(1) + " " + "" ) self.RTL820T.set_sample_rate(2.0E6) self.RTL820T.set_center_freq(cf, 0) self.RTL820T.set_freq_corr(00, 0) self.RTL820T.set_dc_offset_mode(0, 0) self.RTL820T.set_iq_balance_mode(0, 0) self.RTL820T.set_gain_mode(False, 0) self.RTL820T.set_gain(0, 0) self.RTL820T.set_if_gain(00000000000, 0) self.RTL820T.set_bb_gain(000000000000, 0) self.RTL820T.set_antenna("", 0) self.RTL820T.set_bandwidth(0, 0) ################################################## # Connections ################################################## self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.RTL820T, 0), (self.blocks_stream_to_vector_0, 0)) #self.connect((self.fft_vxx_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_file_sink_0, 0))
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 __init__(self, samplerate, bits_per_sec, fftlen): gr.hier_block2.__init__( self, "square_and_fft_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 just the old square-and-fft method #ais.freqest is simply looking for peaks spaced bits-per-sec apart self.square = blocks.multiply_cc(1) self.fftvect = blocks.stream_to_vector(gr.sizeof_gr_complex, fftlen) self.fft = fft.fft_vcc(fftlen, True, window.rectangular(fftlen), True) self.freqest = ais.freqest(int(samplerate), int(bits_per_sec), fftlen) self.repeat = blocks.repeat(gr.sizeof_float, fftlen) self.fm = analog.frequency_modulator_fc(-1.0 / (float(samplerate) / (2 * pi))) self.mix = blocks.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 __init__(self, n_chans, n_filterbanks=1, taps=None, outchans=None, atten=100, bw=1.0, tb=0.2, ripple=0.1): if n_filterbanks > n_chans: n_filterbanks = n_chans if outchans is None: outchans = list(range(n_chans)) gr.hier_block2.__init__( self, "pfb_channelizer_hier_ccf", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(len(outchans), len(outchans), gr.sizeof_gr_complex)) if taps is None: taps = self.create_taps(n_chans, atten=100, bw=1.0, tb=0.2, ripple=0.1) taps = list(taps) extra_taps = int(math.ceil(1.0*len(taps)/n_chans)*n_chans - len(taps)) taps = taps + [0] * extra_taps # Make taps for each channel chantaps = [list(reversed(taps[i: len(taps): n_chans])) for i in range(0, n_chans)] # Convert the input stream into a stream of vectors. self.s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, n_chans) # Create a mapping to separate out each filterbank (a group of channels to be processed together) # And a list of sets of taps for each filterbank. low_cpp = int(n_chans / n_filterbanks) extra = n_chans - low_cpp*n_filterbanks cpps = [low_cpp+1]*extra + [low_cpp]*(n_filterbanks-extra) splitter_mapping = [] filterbanktaps = [] total = 0 for cpp in cpps: splitter_mapping.append([(0, i) for i in range(total, total+cpp)]) filterbanktaps.append(chantaps[total: total+cpp]) total += cpp assert(total == n_chans) # Split the stream of vectors in n_filterbanks streams of vectors. self.splitter = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], splitter_mapping) # Create the filterbanks self.fbs = [filter.filterbank_vcvcf(taps) for taps in filterbanktaps] # Combine the streams of vectors back into a single stream of vectors. combiner_mapping = [[]] for i, cpp in enumerate(cpps): for j in range(cpp): combiner_mapping[0].append((i, j)) self.combiner = blocks.vector_map(gr.sizeof_gr_complex, cpps, combiner_mapping) # Add the final FFT to the channelizer. self.fft = fft.fft_vcc(n_chans, forward=True, window=[1.0]*n_chans) # Select the desired channels if outchans != list(range(n_chans)): selector_mapping = [[(0, i) for i in outchans]] self.selector = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], selector_mapping) # Convert stream of vectors to a normal stream. self.v2ss = blocks.vector_to_streams(gr.sizeof_gr_complex, len(outchans)) self.connect(self, self.s2v, self.splitter) for i in range(0, n_filterbanks): self.connect((self.splitter, i), self.fbs[i], (self.combiner, i)) self.connect(self.combiner, self.fft) if outchans != list(range(n_chans)): self.connect(self.fft, self.selector, self.v2ss) else: self.connect(self.fft, self.v2ss) for i in range(0, len(outchans)): self.connect((self.v2ss, i), (self, i))
def test_003_t(self): # test fft against gnuradio fft # set up fg test_len = 1024 * 2 packet_len = test_len samp_rate = 2000 frequency = (100, 100) amplitude = 1 src = radar.signal_generator_cw_c(packet_len, samp_rate, frequency, amplitude) head = blocks.head(8, test_len) tsfft = radar.ts_fft_cc(packet_len) snk1 = blocks.vector_sink_c() self.tb.connect(src, head, tsfft, snk1) s2v = blocks.stream_to_vector(8, packet_len) fft_inbuild = fft.fft_vcc(test_len, 1, fft.window_rectangular(0)) snk2 = blocks.vector_sink_c() v2s = blocks.vector_to_stream(8, packet_len) self.tb.connect(head, s2v, fft_inbuild, v2s, snk2) self.tb.run() # compaire ffts data_tsfft = snk1.data() data_fft_inbuild = snk2.data() self.assertComplexTuplesAlmostEqual( data_tsfft, data_fft_inbuild, 2) # compare inbuild fft and fft from block
def __init__(self, auto_carrier, carrier, all_spectrum, freq_central, samp_rate, nintems, signal_bw, noise_bw, avg_alpha, average, win): """ Estimates the SNR. Provide access to the setting the filter and sample rate. Args: sample_rate: Incoming stream sample rate nintems: Number of FFT bins avg_alpha: FFT averaging (over time) constant [0.0-1.0] average: Whether to average [True, False] win: the window taps generation function auto_carrier: To allow self-detection of the carrier, so the highest bin [True, False] carrier: To evalutaion of the CNR or SNR [True, False] all_spectrum: To set the whole spectrum (less the signal's one) to evaluate noise power density [True, False] freq_central: Sets the central frequency (for the bandwidth) of the signal (in the CNR mode, it is the manual set of the carrier's frequency) signal_bw: Sets the bandwidth (for the SNR mode) of the signal to the power evaluation noise_bw: Sets the bandwidth (if all_sepctrum is false) of the noise to the power evaluation """ gr.hier_block2.__init__(self, "snr_estimator_cfv", gr.io_signature(1,1, gr.sizeof_gr_complex), # Input signature gr.io_signature2(2,2, gr.sizeof_float, gr.sizeof_float * nintems)) # Output signature self.auto_carrier = auto_carrier self.carrier = carrier self.all_spectrum = all_spectrum self.freq_central = freq_central self.samp_rate = samp_rate self.nintems = nintems self.signal_bw = signal_bw self.noise_bw = noise_bw self.avg_alpha = avg_alpha self.average = average self.win = win fft_window = self.win(self.nintems) self.fft = fft.fft_vcc(self.nintems, True, fft_window, True) self._sd = blocks.stream_to_vector(gr.sizeof_gr_complex, self.nintems) self.c2magsq = blocks.complex_to_mag_squared(self.nintems) self._avg = filter.single_pole_iir_filter_ff(1.0, self.nintems) self.snr = flaress.snr(self.auto_carrier, self.carrier, self.all_spectrum, self.freq_central, self.samp_rate, self.nintems, self.signal_bw, self.noise_bw) window_power = sum(map(lambda x: x*x, fft_window)) self.log = blocks.nlog10_ff(10, self.nintems, -20*math.log10(self.nintems) # Adjust for number of bins -10*math.log10(float(window_power)/self.nintems) # Adjust for windowing loss -20*math.log10(float(2)/2)) # Adjust for reference scale self.connect(self, self._sd, self.fft, self.c2magsq, self._avg, self.snr, (self, 0)) self.connect(self._avg, self.log, (self, 1)) self._average = average self._avg_alpha = avg_alpha self.set_avg_alpha(avg_alpha) self.set_average(average)
def __init__(self, window_size): gr.hier_block2.__init__(self, "FFT_IFFT", gr.io_signature(1, 1, gr.sizeof_float), gr.io_signature(1, 1, gr.sizeof_float)) vector_to_stream = blocks.vector_to_stream(gr.sizeof_gr_complex, window_size) stream_to_vector = blocks.stream_to_vector(gr.sizeof_float, window_size) divide = blocks.divide_cc(1) complex_to_float = blocks.complex_to_float(1) fft_forward = fft.fft_vfc(window_size, True, (fft.window.blackmanharris(window_size)), 1) fft_backward = fft.fft_vcc( window_size, False, (fft.window.blackmanharris(window_size)), False, 1) constant = analog.sig_source_c(0, analog.GR_CONST_WAVE, 0, 0, window_size) #print("1. Connect self to stream_to_vector") self.connect((self, 0), (stream_to_vector, 0)) #print("2. Connect stream_to_vector to fft_forward") self.connect((stream_to_vector, 0), (fft_forward, 0)) #print("3. Connect fft_forward to fft_backward") self.connect((fft_forward, 0), (fft_backward, 0)) #print("4. Connect fft_backward to vector_to_stream") self.connect((fft_backward, 0), (vector_to_stream, 0)) #print("5. Connect vector_to_stream to port 0 of divide") self.connect((vector_to_stream, 0), (divide, 0)) #print("6. Connect constant to port 1 of divide") self.connect(constant, (divide, 1)) #print("7. Connect divide to complex_to_float") self.connect((divide, 0), (complex_to_float, 0)) #print("8. Connect complex_to_float to self") self.connect((complex_to_float, 0), (self, 0))
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 = fft.fft_vcc(self.fft_size, True, mywindow) self.c2mag = gr.complex_to_mag(self.fft_size) self.avg = filter.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): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1e6 self.freq = freq = 2e9 ################################################## # Blocks ################################################## self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=freq, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate, fft_size=1024, fft_rate=15, average=False, avg_alpha=None, title='FFT Plot', peak_hold=False, ) self.Add(self.wxgui_fftsink2_0.win) self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(samp_rate) self.uhd_usrp_source_0.set_center_freq(freq, 0) self.uhd_usrp_source_0.set_gain(10, 0) self.uhd_usrp_source_0.set_antenna('RX2', 0) self.fft_vxx_0 = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, 1024) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float * 1024, '/home/prabhat/a', False) self.blocks_file_sink_0.set_unbuffered(False) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared( 1024) ################################################## # Connections ################################################## self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self, sample_rate, fft_size, ref_scale, frame_rate): gr.hier_block2.__init__( self, "logpowerfft_win", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_float * fft_size)) self._sd = blocks.stream_to_vector_decimator( item_size=gr.sizeof_gr_complex, sample_rate=sample_rate, vec_rate=frame_rate, vec_len=fft_size) fft_window = fft_lib.window_hamming(fft_size) fft = fft_lib.fft_vcc(fft_size, True, fft_window, True) window_power = sum([x * x for x in fft_window]) c2magsq = blocks.complex_to_mag_squared(fft_size) self._avg = filter.single_pole_iir_filter_ff(1.0, fft_size) self._log = blocks.nlog10_ff( 10, fft_size, -20 * math.log10(fft_size) # Adjust for number of bins - 10 * math.log10( float(window_power) / fft_size) # Adjust for windowing loss - 20 * math.log10(float(ref_scale) / 2)) # Adjust for reference scale self.connect(self, self._sd, fft, c2magsq, self._avg, self._log, self)
def test_multithreaded(self): nthreads = nthreads_min while nthreads < nthreads_max: fft_size_pow = fft_size_pow_min while fft_size_pow < fft_size_pow_max: self.fft_size = 2**fft_size_pow print "fft_size:\t%d" % self.fft_size print "nthreads:\t%d" % nthreads src_data = tuple( [x / self.fft_size for x in primes_transformed]) #expected_result = tuple([complex(primes[2 * i], primes[2 * i + 1]) for i in range(self.fft_size)]) src = blocks.vector_source_c(src_data) s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) op = fft.fft_vcc(self.fft_size, True, [], False, nthreads) v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size) dst = blocks.vector_sink_c() self.tb.connect(src, s2v, op, v2s, dst) start = time.time() self.tb.run() end = time.time() totaltime = end - start print "execTime: %6.6f" % totaltime #print(op.pc_work_time()) # print(op.pc_noutput_items_var()) result_data = dst.data() #self.assert_fft_ok2(expected_result, result_data) fft_size_pow = fft_size_pow + 1 nthreads = nthreads + 1
def test_003_t (self): # test fft against gnuradio fft # set up fg test_len = 1024*2 packet_len = test_len samp_rate = 2000 frequency = (100,100) amplitude = 1 src = radar.signal_generator_cw_c(packet_len,samp_rate,frequency,amplitude) head = blocks.head(8,test_len) tsfft = radar.ts_fft_cc(packet_len) snk1 = blocks.vector_sink_c() self.tb.connect(src,head,tsfft,snk1) s2v = blocks.stream_to_vector(8, packet_len) fft_inbuild = fft.fft_vcc(test_len,True,fft.window_rectangular(0)) snk2 = blocks.vector_sink_c() v2s = blocks.vector_to_stream(8, packet_len); self.tb.connect(head,s2v,fft_inbuild,v2s,snk2) self.tb.run() # compaire ffts data_tsfft = snk1.data() data_fft_inbuild = snk2.data() self.assertComplexTuplesAlmostEqual(data_tsfft,data_fft_inbuild,2) # compare inbuild fft and fft from block
def __init__(self, fft_size, mavg_size, ed_threshold): """ CTOR @param fft_size FFT Size @param mavg_size Energy Detector mavg size. """ gr.hier_block2.__init__( self, name="simple_ranking_detector", input_signature=gr.io_signature(1, 1, gr.sizeof_gr_complex), output_signature=gr.io_signature(2, 2, gr.sizeof_float), ) # Blocks # Convert the output of a FFT self.s2v_0 = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_size) self.fft_0 = fft.fft_vcc(fft_size, True, []) self.c2mag_0 = blocks.complex_to_mag_squared(fft_size) # Instantiate the energy calculator from sensing import EnergyDecision self.ql = QLearningWorker(fft_size, algorithm=EnergyDecision(ed_threshold)) #::TODO:: parece que nao tem mais o metodo connect # Flow graph self.connect(self, self.s2v_0, self.fft_0, self.c2mag_0, self.ql) self.connect((self.ql, 0), (self, 0)) self.connect((self.ql, 1), (self, 1))
def __init__(self, fft_len, rate, sample_rate): gr.hier_block2.__init__(self, "psd_logger", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0,0,0)) self.fft_len = fft_len self.rate = rate self.sample_rate = sample_rate self.msgq = gr.msg_queue(2) self.log_file = open('/tmp/psd_log'+'-'+ time.strftime("%y%m%d") + '-' + time.strftime("%H%M%S"),'w') self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate/self.fft_len/self.rate))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, mywindow) power = 0 for tap in mywindow: power += tap*tap self.c2mag = blocks.complex_to_mag(self.fft_len) self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True) self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.sink) self._watcher = _queue_watcher(self.msgq, self.log_file)
def ms_to_file(hb,block,filename,N=4096,delay=0,fft=False,scale=1): streamsize = determine_streamsize(block) vlen = streamsize/gr.sizeof_gr_complex blks = [block] if fft and vlen > 1: gr_fft = fft_blocks.fft_vcc(vlen,True,[],True) blks.append(gr_fft) mag_sqrd = gr.complex_to_mag_squared(vlen) blks.append(mag_sqrd) if vlen > 1: v2s = blocks.vector_to_stream(gr.sizeof_float,vlen) blks.append(v2s) if delay != 0: delayline = delayline_ff(delay) blks.append(delayline) gr_scale = gr.multiply_const_ff(scale) blks.append(gr_scale) filter = gr.fir_filter_fff(1,[1.0/N]*N) blks.append(filter) for i in range(len(blks)-1): hb.connect(blks[i],blks[i+1]) log_to_file(hb,filter,filename)
def __init__(self, ber_block, ncorrelations, lfsr_bits = 16): gr.top_block.__init__(self) prn_len = 2**lfsr_bits prn = np.concatenate((scipy.signal.max_len_seq(lfsr_bits)[0], [1])) prn_fft_conj = np.conjugate(np.fft.fft(2*prn-1)) self.source = blocks.vector_source_b(prn, True, 1, []) self.ber_block = ber_block self.char2float = blocks.char_to_float(1, 0.5) self.add_const = blocks.add_const_ff(-1.0) self.source_vector = blocks.stream_to_vector(gr.sizeof_float, prn_len) self.fft = fft.fft_vfc(prn_len, True, window.rectangular(prn_len), 1) self.prn_fft_source = blocks.vector_source_c(prn_fft_conj, True, prn_len, []) self.multiply_ffts = blocks.multiply_vcc(prn_len) self.ifft = fft.fft_vcc(prn_len, False, np.ones(prn_len)/prn_len**2, False, 1) self.corr_mag = blocks.complex_to_mag(prn_len) self.max_corr = blocks.max_ff(prn_len, 1) self.multiply_const = blocks.multiply_const_ff(-0.5) self.add_const2 = blocks.add_const_ff(0.5) self.head = blocks.head(gr.sizeof_float, ncorrelations) self.sink = blocks.vector_sink_f() self.connect(self.source, self.ber_block, self.char2float, self.add_const, self.source_vector, self.fft, (self.multiply_ffts,0), self.ifft, self.corr_mag, self.max_corr, self.multiply_const, self.add_const2, self.head, self.sink) self.connect(self.prn_fft_source, (self.multiply_ffts,1))
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 _test_window(self): src_data = tuple([ complex(primes[2 * i], primes[2 * i + 1]) for i in range(self.fft_size) ]) expected_result = ( (2238.9174 + 2310.4750j), (-1603.7416 - 466.7420j), (116.7449 - 70.8553j), (-13.9157 + 19.0855j), (-4.8283 + 16.7025j), (-43.7425 + 16.9871j), (-16.1904 + 1.7494j), (-32.3797 + 6.9964j), (-13.5283 + 7.7721j), (-24.3276 - 7.5378j), (-29.2711 + 4.5709j), (-2.7124 - 6.6307j), (-33.5486 - 8.3485j), (-8.3016 - 9.9534j), (-18.8590 - 8.3501j), (-13.9092 - 1.1396j), (-17.7626 - 26.9281j), (0.0182 - 8.9000j), (-19.9143 - 14.1320j), (-10.3073 - 15.5759j), (3.5800 - 29.1835j), (-7.5263 - 1.5900j), (-3.0392 - 31.7445j), (-15.1355 - 33.6158j), (28.2345 - 11.4373j), (-6.0055 - 27.0418j), (5.2074 - 21.2431j), (23.1617 - 31.8610j), (13.6494 - 11.1982j), (14.7145 - 14.4113j), (-60.0053 + 114.7418j), (-440.1561 - 1632.9807j)) window = fft.window_hamming(ntaps=self.fft_size) src = blocks.vector_source_c(src_data) s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) op = fft.fft_vcc(self.fft_size, True, window, False) v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size) dst = blocks.vector_sink_c() self.tb.connect(src, s2v, op, v2s, dst) self.tb.run() result_data = dst.data()
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, length, height): gr.hier_block2.__init__(self, "ascii plot", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0,0,0)) self.fft_len = fft_len self.sample_rate = sample_rate self.average = average self.tune_freq = tune_freq self.rate = rate self.length = length self.height = height self.msgq = gr.msg_queue(2) #######BLOCKS##### self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate/self.fft_len/self.rate))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, (), True) self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len) self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_len) self.log = blocks.nlog10_ff(10, self.fft_len, -10*math.log10(self.fft_len) # Adjust for number of bins -10*math.log10(self.sample_rate)) # Adjust for sample rate self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True) #####CONNECTIONS#### self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.avg, self.log, self.sink) self._main = main_thread(self.msgq, self.fft_len, self.sample_rate, self.tune_freq, self.length, self.height)
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, width, height): gr.hier_block2.__init__(self, "ascii plot", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)) self.fft_len = fft_len self.sample_rate = sample_rate self.average = average self.tune_freq = tune_freq self.rate = rate if width == 0 and height == 0: rows, columns = os.popen('stty size', 'r').read().split() self.height = int(rows) - 5 self.width = int(columns) / 2 - 10 else: self.height = height self.width = width self.msgq = gr.msg_queue(2) #######BLOCKS##### self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n( gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate / self.fft_len / self.rate))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, (), True) self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len) self.avg = grfilter.single_pole_iir_filter_ff(self.average, self.fft_len) self.log = blocks.nlog10_ff( 10, self.fft_len, -10 * math.log10(self.fft_len) # Adjust for number of bins - 10 * math.log10(self.sample_rate)) # Adjust for sample rate self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True) #register message out to other blocks self.message_port_register_hier_out("pkt_out") #packet generator self.packet_generator = of.chat_blocks.chat_sender() #####CONNECTIONS#### self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.avg, self.log, self.sink) #MSG output self.msg_connect(self.packet_generator, "out", self, "pkt_out") ####THREADS#### self._ascii_plotter = ascii_plotter(self.width, self.height, self.tune_freq, self.sample_rate, self.fft_len) self._main = main_thread(self.msgq, self._ascii_plotter, self.packet_generator)
def __init__(self, yaml_config): super(DarkflowFlowGraph, self).__init__() # params self.yaml_config = yaml_config sample_rate = 20.0e6 centre_freq = 3.5e9 gaindB = 30 # flowgraph blocks self.usrp_source = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.usrp_source.set_samp_rate(sample_rate) self.usrp_source.set_center_freq(centre_freq, 0) self.usrp_source.set_gain(gaindB, 0) self.toparallel = blocks.stream_to_vector(gr.sizeof_gr_complex, 64) self.fftblock = fft.fft_vcc(64, True, signal.get_window(('tukey', 0.25), 64), True) self.mag2 = blocks.complex_to_mag_squared(64) self.classifier = darkflow_ckpt_classifier_c(self.yaml_config, 64, True, 10, 10000) # self.tostream = blocks.vector_to_stream(gr.sizeof_float,64) # self.null_sink = blocks.null_sink(gr.sizeof_float) # make flowgraph self.connect(self.usrp_source, self.toparallel) self.connect(self.toparallel, self.fftblock) self.connect(self.fftblock, self.mag2) self.connect(self.mag2, self.classifier)
def __init__(self, sample_rate, fac_size, fac_rate): gr.hier_block2.__init__(self, "fast_autocorrelator_c", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_float)) # Parameters self.sample_rate = sample_rate self.fac_size = fac_size self.fac_rate = fac_rate self.window = () # Block Objects For Complex Fast Autocorrelator self.stream_to_vector = blocks.stream_to_vector( gr.sizeof_gr_complex, fac_size) self.keep_one_in_n = blocks.keep_one_in_n( gr.sizeof_gr_complex * fac_size, max(1, int(sample_rate / fac_size / fac_rate))) self.fac_fft = fft.fft_vfc(fac_size, True, self.window) self.complex_to_mag = blocks.complex_to_mag(fac_size) self.fac_complex_to_mag = blocks.complex_to_mag(fac_size) self.nlog10_ff = blocks.nlog10_ff(20, fac_size, -20 * math.log10(fac_size)) self.single_pole_iir_filter_ff = filter.single_pole_iir_filter_ff( 1.0, fac_size) self.fft_vcc = fft.fft_vcc(fac_size, True, self.window) self.vector_to_stream = blocks.vector_to_stream( gr.sizeof_float, self.fac_size) # Connections for Auto Correlator self.connect(self, self.stream_to_vector, self.keep_one_in_n, self.fft_vcc, self.complex_to_mag, self.fac_fft, self.fac_complex_to_mag, self.single_pole_iir_filter_ff, self.nlog10_ff, self.vector_to_stream, self)
def __init__(self, bandwidth=2e6, bb_gain=20, channels=1024, dev_args='', duration=60, frequency=1420e6, if_gain=20, obs_file='observation.dat', rf_gain=30, t_sample=1): gr.top_block.__init__(self, "Run Observation") ################################################## # Parameters ################################################## self.bandwidth = bandwidth self.bb_gain = bb_gain self.channels = channels self.dev_args = dev_args self.duration = duration self.frequency = frequency self.if_gain = if_gain self.obs_file = obs_file self.rf_gain = rf_gain self.t_sample = t_sample ################################################## # Variables ################################################## self.sinc_sample_locations = sinc_sample_locations = np.arange(-np.pi*4/2.0, np.pi*4/2.0, np.pi/channels) self.sinc = sinc = np.sinc(sinc_sample_locations/np.pi) self.custom_window = custom_window = sinc*np.hamming(4*channels) ################################################## # Blocks ################################################## self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + dev_args ) self.osmosdr_source_0.set_sample_rate(bandwidth) self.osmosdr_source_0.set_center_freq(frequency, 0) self.osmosdr_source_0.set_freq_corr(0, 0) self.osmosdr_source_0.set_dc_offset_mode(0, 0) self.osmosdr_source_0.set_iq_balance_mode(0, 0) self.osmosdr_source_0.set_gain_mode(False, 0) self.osmosdr_source_0.set_gain(rf_gain, 0) self.osmosdr_source_0.set_if_gain(if_gain, 0) self.osmosdr_source_0.set_bb_gain(bb_gain, 0) self.osmosdr_source_0.set_antenna('', 0) self.osmosdr_source_0.set_bandwidth(0, 0) self.fft_vxx_0 = fft.fft_vcc(channels, True, (window.blackmanharris(channels)), True, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, channels) self.blocks_integrate_xx_0 = blocks.integrate_ff(int(t_sample*bandwidth/channels), channels) self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*1, int(duration*bandwidth)) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*channels, obs_file, True) self.blocks_file_sink_0.set_unbuffered(False) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(channels) ################################################## # Connections ################################################## self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_integrate_xx_0, 0)) self.connect((self.blocks_head_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_integrate_xx_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.osmosdr_source_0, 0), (self.blocks_head_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 = fft.fft_vcc(len(dpss), True, self.window, fftshift) self.c2mag = blocks.complex_to_mag_squared(len(dpss)) self.connect(self, self.fft, self.c2mag, self)
def create_ofdm_blocks(self): self.carrier_allocator = digital.ofdm_carrier_allocator_cvc( self.fft_len, self.occupied_carriers, self.pilot_carriers, self.pilot_symbols, self.sync_words, self.len_tag_key) self.ifft = fft.fft_vcc(self.fft_len, False, (), True, 1) ofdm_len = self.fft_len + self.cp_len self.ofdm_cyclic_prefixer = digital.ofdm_cyclic_prefixer( self.fft_len, ofdm_len, 0, self.len_tag_key)
def __init__(self, fft_len, cp_len, occupied_carriers, pilot_carriers, pilot_symbols, constellation, nofdm_symbols, packet_len_tag): gr.hier_block2.__init__( self, "ofdm_frame_to_symbols_vcc", gr.io_signature(1, 1, fft_len * gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_gr_complex)) self.fft_len = fft_len self.cp_len = cp_len self.occupied_carriers = occupied_carriers self.pilot_carriers = pilot_carriers self.pilot_symbols = pilot_symbols self.constellation = constellation self.nofdm_symbols = nofdm_symbols self.packet_len_tag = packet_len_tag self.frame_len_tag_key = "frame_length" self.fft_payload = fft.fft_vcc(fft_size=self.fft_len, forward=True, window=(), shift=True) self.chanest = digital.ofdm_chanest_vcvc( sync_symbol1=utils.ofdm_make_sync_word1(self.fft_len, self.occupied_carriers, self.pilot_carriers), sync_symbol2=utils.ofdm_make_sync_word2(self.fft_len, self.occupied_carriers, self.pilot_carriers), n_data_symbols=self.nofdm_symbols) self.payload_equalizer = digital.ofdm_equalizer_simpledfe( fft_len=self.fft_len, constellation=self.constellation.base(), occupied_carriers=self.occupied_carriers, pilot_carriers=self.pilot_carriers, pilot_symbols=self.pilot_symbols, symbols_skipped=0) self.payload_eq = digital.ofdm_frame_equalizer_vcvc( equalizer=self.payload_equalizer.base(), cp_len=cp_len, len_tag_key=self.frame_len_tag_key, propagate_channel_state=True, fixed_frame_len=self.nofdm_symbols) # doesn't accept names of parameters self.payload_serializer = digital.ofdm_serializer_vcc( self.fft_len, # fft_len = self.occupied_carriers, # occupied_carriers = self.frame_len_tag_key, # len_tag_key = self.packet_len_tag, # packet_len_tag = 0 # symbolsskipped = ) self.connect(self, self.fft_payload, self.chanest, self.payload_eq, self.payload_serializer, self)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.rational_resampler_xxx_0 = filter.rational_resampler_ccc( interpolation=70, decimation=64, taps=None, fractional_bw=None, ) self.osmosdr_sink_0 = osmosdr.sink( args="numchan=" + str(1) + " " + "bladerf=0,buffers=128,buflen=32768" ) self.osmosdr_sink_0.set_sample_rate(10e6) self.osmosdr_sink_0.set_center_freq(800e6, 0) self.osmosdr_sink_0.set_freq_corr(0, 0) self.osmosdr_sink_0.set_gain(19, 0) self.osmosdr_sink_0.set_if_gain(0, 0) self.osmosdr_sink_0.set_bb_gain(0, 0) self.osmosdr_sink_0.set_antenna("", 0) self.osmosdr_sink_0.set_bandwidth(0, 0) self.fft_vxx_0 = fft.fft_vcc(2048, False, (window.rectangular(2048)), True, 10) self.dvbt_symbol_inner_interleaver_0 = dvbt.symbol_inner_interleaver(1512, dvbt.T2k, 1) self.dvbt_reference_signals_0 = dvbt.reference_signals(gr.sizeof_gr_complex, 1512, 2048, dvbt.QAM16, dvbt.NH, dvbt.C1_2, dvbt.C1_2, dvbt.G1_32, dvbt.T2k, 0, 0) self.dvbt_reed_solomon_enc_0 = dvbt.reed_solomon_enc(2, 8, 0x11d, 255, 239, 8, 51, 8) self.dvbt_inner_coder_0 = dvbt.inner_coder(1, 1512, dvbt.QAM16, dvbt.NH, dvbt.C1_2) self.dvbt_energy_dispersal_0 = dvbt.energy_dispersal(1) self.dvbt_dvbt_map_0 = dvbt.dvbt_map(1512, dvbt.QAM16, dvbt.NH, dvbt.T2k, 1) self.dvbt_convolutional_interleaver_0 = dvbt.convolutional_interleaver(136, 12, 17) self.dvbt_bit_inner_interleaver_0 = dvbt.bit_inner_interleaver(1512, dvbt.QAM16, dvbt.NH, dvbt.T2k) self.digital_ofdm_cyclic_prefixer_0 = digital.ofdm_cyclic_prefixer(2048, 2048+64, 0, "") self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.0022097087, )) self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char*1, "test.ts", True) ################################################## # Connections ################################################## self.connect((self.blocks_file_source_0, 0), (self.dvbt_energy_dispersal_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.rational_resampler_xxx_0, 0)) self.connect((self.digital_ofdm_cyclic_prefixer_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.dvbt_bit_inner_interleaver_0, 0), (self.dvbt_symbol_inner_interleaver_0, 0)) self.connect((self.dvbt_convolutional_interleaver_0, 0), (self.dvbt_inner_coder_0, 0)) self.connect((self.dvbt_dvbt_map_0, 0), (self.dvbt_reference_signals_0, 0)) self.connect((self.dvbt_energy_dispersal_0, 0), (self.dvbt_reed_solomon_enc_0, 0)) self.connect((self.dvbt_inner_coder_0, 0), (self.dvbt_bit_inner_interleaver_0, 0)) self.connect((self.dvbt_reed_solomon_enc_0, 0), (self.dvbt_convolutional_interleaver_0, 0)) self.connect((self.dvbt_reference_signals_0, 0), (self.fft_vxx_0, 0)) self.connect((self.dvbt_symbol_inner_interleaver_0, 0), (self.dvbt_dvbt_map_0, 0)) self.connect((self.fft_vxx_0, 0), (self.digital_ofdm_cyclic_prefixer_0, 0)) self.connect((self.rational_resampler_xxx_0, 0), (self.osmosdr_sink_0, 0))
def __init__(self): gr.top_block.__init__(self, "Hd Tx Rtl File") ################################################## # Blocks ################################################## self.rational_resampler_xxx_1 = filter.rational_resampler_ccc( interpolation=2, decimation=1, taps=None, fractional_bw=None) self.nrsc5_sis_encoder_0 = nrsc5.sis_encoder('ABCD') self.nrsc5_psd_encoder_0 = nrsc5.psd_encoder(0, 'Title', 'Artist') self.nrsc5_l2_encoder_0 = nrsc5.l2_encoder(1, 0, 146176) self.nrsc5_l1_fm_encoder_mp1_0 = nrsc5.l1_fm_encoder(1) self.nrsc5_hdc_encoder_0 = nrsc5.hdc_encoder(2, 64000) self.fft_vxx_0 = fft.fft_vcc(2048, False, window.rectangular(2048), True, 1) self.blocks_wavfile_source_0 = blocks.wavfile_source('sample.wav', True) self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, 2048) self.blocks_vector_source_x_0 = blocks.vector_source_c([math.sin(math.pi / 2 * i / 112) for i in range(112)] + [1] * (2048-112) + [math.cos(math.pi / 2 * i / 112) for i in range(112)], True, 1, []) self.blocks_repeat_0 = blocks.repeat(gr.sizeof_gr_complex*2048, 2) self.blocks_multiply_xx_0 = blocks.multiply_vcc(1) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_cc(0.5) self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_gr_complex, 2160, 4096, 0) self.blocks_interleave_0 = blocks.interleave(gr.sizeof_float*1, 1) self.blocks_float_to_uchar_0 = blocks.float_to_uchar() self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char*1, 'hd-generated.raw', False) self.blocks_file_sink_0.set_unbuffered(False) self.blocks_conjugate_cc_0 = blocks.conjugate_cc() self.blocks_complex_to_float_0 = blocks.complex_to_float(1) self.blocks_add_const_vxx_0_0 = blocks.add_const_ff(127.5) ################################################## # Connections ################################################## self.connect((self.blocks_add_const_vxx_0_0, 0), (self.blocks_float_to_uchar_0, 0)) self.connect((self.blocks_complex_to_float_0, 0), (self.blocks_interleave_0, 0)) self.connect((self.blocks_complex_to_float_0, 1), (self.blocks_interleave_0, 1)) self.connect((self.blocks_conjugate_cc_0, 0), (self.rational_resampler_xxx_1, 0)) self.connect((self.blocks_float_to_uchar_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.blocks_interleave_0, 0), (self.blocks_add_const_vxx_0_0, 0)) self.connect((self.blocks_keep_m_in_n_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_complex_to_float_0, 0)) self.connect((self.blocks_multiply_xx_0, 0), (self.blocks_conjugate_cc_0, 0)) self.connect((self.blocks_repeat_0, 0), (self.blocks_vector_to_stream_0, 0)) self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_multiply_xx_0, 0)) self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_keep_m_in_n_0, 0)) self.connect((self.blocks_wavfile_source_0, 1), (self.nrsc5_hdc_encoder_0, 1)) self.connect((self.blocks_wavfile_source_0, 0), (self.nrsc5_hdc_encoder_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_repeat_0, 0)) self.connect((self.nrsc5_hdc_encoder_0, 0), (self.nrsc5_l2_encoder_0, 0)) self.connect((self.nrsc5_l1_fm_encoder_mp1_0, 0), (self.fft_vxx_0, 0)) self.connect((self.nrsc5_l2_encoder_0, 0), (self.nrsc5_l1_fm_encoder_mp1_0, 0)) self.connect((self.nrsc5_psd_encoder_0, 0), (self.nrsc5_l2_encoder_0, 1)) self.connect((self.nrsc5_sis_encoder_0, 0), (self.nrsc5_l1_fm_encoder_mp1_0, 1)) self.connect((self.rational_resampler_xxx_1, 0), (self.blocks_multiply_const_vxx_0, 0))
def __init__(self, max_freq_offset=10, guard=0.125, mode=3, snr=10, tmcc_print=False): gr.hier_block2.__init__( # self, "ISDB-T RF Channel Decoding", self, "isdbt_rf_channel_decoding", gr.io_signature(1, 1, gr.sizeof_gr_complex * 1), gr.io_signaturev(2, 2, [ gr.sizeof_gr_complex * 13 * 96 * 2**(mode - 1), gr.sizeof_gr_complex * (13 * 108 * 2**(mode - 1) + 1) ]), ) ################################################## # Parameters ################################################## self.max_freq_offset = max_freq_offset self.guard = guard self.mode = mode self.snr = snr self.tmcc_print = tmcc_print ################################################## # Variables ################################################## self.total_carriers = total_carriers = 2**(10 + mode) self.data_carriers = data_carriers = 13 * 96 * 2**(mode - 1) self.active_carriers = active_carriers = 13 * 108 * 2**(mode - 1) + 1 ################################################## # Blocks ################################################## self.isdbt_tmcc_decoder_0 = isdbt.tmcc_decoder(mode, tmcc_print) self.isdbt_sync_and_channel_estimaton_0 = isdbt.sync_and_channel_estimaton( total_carriers, active_carriers, max_freq_offset) self.isdbt_ofdm_sym_acquisition_0 = isdbt.ofdm_sym_acquisition( total_carriers, int(guard * total_carriers), snr) self.fft_vxx_0 = fft.fft_vcc(total_carriers, True, (window.rectangular(total_carriers)), True, 1) ################################################## # Connections ################################################## self.connect((self.fft_vxx_0, 0), (self.isdbt_sync_and_channel_estimaton_0, 0)) self.connect((self.isdbt_ofdm_sym_acquisition_0, 0), (self.fft_vxx_0, 0)) self.connect((self.isdbt_sync_and_channel_estimaton_0, 0), (self.isdbt_tmcc_decoder_0, 0)) self.connect((self.isdbt_sync_and_channel_estimaton_0, 1), (self, 1)) self.connect((self.isdbt_tmcc_decoder_0, 0), (self, 0)) self.connect((self, 0), (self.isdbt_ofdm_sym_acquisition_0, 0))
def __init__(self, fft_len, cp_len, occupied_carriers, pilot_carriers, pilot_symbols, packet_len_tag, verbose=False): gr.hier_block2.__init__( self, "ofdm_symbols_to_frame_cvc", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, fft_len * gr.sizeof_gr_complex)) self.fft_len = fft_len self.cp_len = cp_len self.occupied_carriers = occupied_carriers self.pilot_carriers = pilot_carriers self.pilot_symbols = pilot_symbols self.packet_len_tag = packet_len_tag self.allocator = digital.ofdm_carrier_allocator_cvc( fft_len=self.fft_len, occupied_carriers=self.occupied_carriers, pilot_carriers=self.pilot_carriers, pilot_symbols=self.pilot_symbols, sync_words=[ utils.ofdm_make_sync_word1(self.fft_len, self.occupied_carriers, self.pilot_carriers), utils.ofdm_make_sync_word2(self.fft_len, self.occupied_carriers, self.pilot_carriers), ], len_tag_key=self.packet_len_tag) self.ffter = fft.fft_vcc(fft_size=self.fft_len, forward=False, window=(), shift=True) self.connect(self, self.allocator, self.ffter, self) if verbose == True: self.connect( self, blocks.file_sink(itemsize=gr.sizeof_gr_complex, filename='ofdm_symbols_to_frame_input.gr')) self.connect( self.allocator, blocks.file_sink( itemsize=self.fft_len * gr.sizeof_gr_complex, filename='ofdm_symbols_to_frame_allocator.gr')) self.connect( self.ffter, blocks.file_sink(itemsize=self.fft_len * gr.sizeof_gr_complex, filename='ofdm_symbols_to_frame_ffter.gr'))
def __init__(self, fft_len, cp_len, occupied_carriers, pilot_carriers, pilot_symbols, packet_len_tag, verbose=False): gr.hier_block2.__init__( self, "ofdm_symbols_to_frame_cvc", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, fft_len*gr.sizeof_gr_complex) ) self.fft_len = fft_len self.cp_len = cp_len self.occupied_carriers = occupied_carriers self.pilot_carriers = pilot_carriers self.pilot_symbols = pilot_symbols self.packet_len_tag = packet_len_tag self.allocator = digital.ofdm_carrier_allocator_cvc( fft_len=self.fft_len, occupied_carriers=self.occupied_carriers, pilot_carriers=self.pilot_carriers, pilot_symbols=self.pilot_symbols, sync_words=[ utils.ofdm_make_sync_word1(self.fft_len, self.occupied_carriers, self.pilot_carriers), utils.ofdm_make_sync_word2(self.fft_len, self.occupied_carriers, self.pilot_carriers), ], len_tag_key=self.packet_len_tag ) self.ffter = fft.fft_vcc( fft_size=self.fft_len, forward=False, window=(), shift=True ) self.connect(self, self.allocator, self.ffter, self) if verbose==True: self.connect(self, blocks.file_sink( itemsize=gr.sizeof_gr_complex, filename='ofdm_symbols_to_frame_input.gr') ) self.connect(self.allocator, blocks.file_sink( itemsize=self.fft_len*gr.sizeof_gr_complex, filename='ofdm_symbols_to_frame_allocator.gr') ) self.connect(self.ffter, blocks.file_sink( itemsize=self.fft_len*gr.sizeof_gr_complex, filename='ofdm_symbols_to_frame_ffter.gr') )
def __init__(self, fft_size=4096): gr.hier_block2.__init__( self, "Fast Autocor", gr.io_signature(1, 1, gr.sizeof_gr_complex*1), gr.io_signature(1, 1, gr.sizeof_float*1), ) ################################################## # Parameters ################################################## self.fft_size = fft_size ################################################## # Blocks ################################################## self.fft_vxx_0_0 = fft.fft_vcc(fft_size, False, (window.hamming(fft_size)), False, 1) self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (window.hamming(fft_size)), False, 1) self.blocks_vector_to_stream_0_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, fft_size) self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, fft_size) self.blocks_stream_to_vector_0_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size) self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vff((1.0/fft_size, )) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((2048.0/fft_size, )) self.blocks_float_to_complex_0 = blocks.float_to_complex(1) self.blocks_complex_to_real_0 = blocks.complex_to_real(1) self.blocks_complex_to_mag_squared_1 = blocks.complex_to_mag_squared(1) ################################################## # Connections ################################################## self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_complex_to_mag_squared_1, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.blocks_stream_to_vector_0_0, 0), (self.fft_vxx_0_0, 0)) self.connect((self.fft_vxx_0_0, 0), (self.blocks_vector_to_stream_0_0, 0)) self.connect((self.blocks_vector_to_stream_0_0, 0), (self.blocks_complex_to_real_0, 0)) self.connect((self.blocks_float_to_complex_0, 0), (self.blocks_stream_to_vector_0_0, 0)) self.connect((self.blocks_complex_to_real_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self, 0)) self.connect((self.blocks_complex_to_mag_squared_1, 0), (self.blocks_multiply_const_vxx_1, 0)) self.connect((self.blocks_multiply_const_vxx_1, 0), (self.blocks_float_to_complex_0, 0))
def __init__(self, fft_len, sample_rate, average, rate, max_tu, data_precision): gr.hier_block2.__init__(self, "ascii plot", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)) self.fft_len = fft_len self.sample_rate = sample_rate self.average = average self.rate = rate self.max_tu = max_tu - 2 #reserve two bytes for segmentation self.data_precision = data_precision if data_precision: print '32bit FFT in use (more bandwidth and precision)' else: print '8bit FFT in use (less bandwidth and precision)' self.msgq = gr.msg_queue(2) #######BLOCKS##### self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n( gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate / self.fft_len / self.rate))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, mywindow, True) self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len) self.avg = grfilter.single_pole_iir_filter_ff(self.average, self.fft_len) self.log = blocks.nlog10_ff( 10, self.fft_len, -10 * math.log10(self.fft_len) # Adjust for number of bins - 10 * math.log10(self.sample_rate)) # Adjust for sample rate self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True) #register message out to other blocks self.message_port_register_hier_out("pdus") self._packet_source = packet_source() #####CONNECTIONS#### self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.avg, self.log, self.sink) self.msg_connect(self._packet_source, "out", self, "pdus") ####THREADS#### self._main = main_thread(self.msgq, self._packet_source, self.max_tu, self.fft_len, self.data_precision)
def __init__(self, radioNum): gr.top_block.__init__(self, "Spectrum Analyzer") ################################################## # Variables ################################################## self.samp_rate = samp_rate = int(300e3) self.center_freq = center_freq = 900e6 self.radio_num = radioNum # Create custom PMT metadata containing the assigned radio number key0 = pmt.intern("radio_num") val0 = pmt.from_long(self.radio_num) extra_meta = pmt.make_dict() extra_meta = pmt.dict_add(extra_meta, key0, val0) ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", args='peak=0.003906', channels=list(range(0, 1)), ), ) self.uhd_usrp_source_0.set_center_freq(center_freq, 0) self.uhd_usrp_source_0.set_gain(28, 0) self.uhd_usrp_source_0.set_antenna('RX2', 0) self.uhd_usrp_source_0.set_bandwidth(samp_rate, 0) self.uhd_usrp_source_0.set_samp_rate(samp_rate) # No synchronization enforced. self.fft_vxx_0 = fft.fft_vcc(1024, True, window.blackmanharris(1024), True, 1) self.blocks_vector_to_stream_0 = blocks.vector_to_stream( gr.sizeof_gr_complex * 1, 1024) self.blocks_stream_to_vector_0 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, 1024) self.blocks_file_meta_sink_0 = blocks.file_meta_sink( gr.sizeof_gr_complex * 1, f'./sample{self.radio_num}.dat', samp_rate, 1, blocks.GR_FILE_FLOAT, True, 300000, extra_meta, False) self.blocks_file_meta_sink_0.set_unbuffered(False) ################################################## # Connections ################################################## self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_file_meta_sink_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.blocks_stream_to_vector_0, 0))
def test_003(self): # Same test as above, only use 2 threads tb = gr.top_block() fft_size = 32 tmp_data = ((4377+4516j), (-1706.1268310546875+1638.4256591796875j), (-915.2083740234375+660.69427490234375j), (-660.370361328125+381.59600830078125j), (-499.96044921875+238.41630554199219j), (-462.26748657226562+152.88948059082031j), (-377.98440551757812+77.5928955078125j), (-346.85821533203125+47.152004241943359j), (-295+20j), (-286.33609008789062-22.257017135620117j), (-271.52999877929688-33.081821441650391j), (-224.6358642578125-67.019538879394531j), (-244.24473571777344-91.524826049804688j), (-203.09068298339844-108.54627227783203j), (-198.45195007324219-115.90768432617188j), (-182.97744750976562-128.12318420410156j), (-167-180j), (-130.33688354492188-173.83778381347656j), (-141.19784545898438-190.28807067871094j), (-111.09677124023438-214.48896789550781j), (-70.039543151855469-242.41630554199219j), (-68.960540771484375-228.30015563964844j), (-53.049201965332031-291.47097778320312j), (-28.695289611816406-317.64553833007812j), (57-300j), (45.301143646240234-335.69509887695312j), (91.936195373535156-373.32437133789062j), (172.09465026855469-439.275146484375j), (242.24473571777344-504.47515869140625j), (387.81732177734375-666.6788330078125j), (689.48553466796875-918.2142333984375j), (1646.539306640625-1694.1956787109375j)) src_data = tuple([x/fft_size for x in tmp_data]) expected_result = tuple([complex(primes[2*i], primes[2*i+1]) for i in range(fft_size)]) nthreads = 2 src = blocks.vector_source_c(src_data) s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_size) op = fft.fft_vcc(fft_size, False, [], False, nthreads) v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, fft_size) dst = blocks.vector_sink_c() tb.connect(src, s2v, op, v2s, dst) tb.run() result_data = dst.data() self.assert_fft_ok2(expected_result, result_data)
def __init__(self, ipp1="127.0.0.1", ipp2="127.0.0.1", ipp3="127.0.0.1", ipp4="127.0.0.1", iptx="127.0.0.1", samp_rate=100): gr.top_block.__init__(self, "OFDM Rx") ################################################## # Parameters ################################################## self.ipp1 = ipp1 self.ipp2 = ipp2 self.ipp3 = ipp3 self.ipp4 = ipp4 self.iptx = iptx self.samp_rate = samp_rate ################################################## # Variables ################################################## self.pilot_symbols = pilot_symbols = ((1, 1, 1, -1,),) self.pilot_carriers = pilot_carriers = ((-21, -7, 7, 21,),) self.payload_mod = payload_mod = digital.constellation_qpsk() self.packet_length_tag_key = packet_length_tag_key = "packet_len" self.occupied_carriers = occupied_carriers = (range(-26, -21) + range(-20, -7) + range(-6, 0) + range(1, 7) + range(8, 21) + range(22, 27),) self.length_tag_key = length_tag_key = "frame_len" self.header_mod = header_mod = digital.constellation_bpsk() self.fft_len = fft_len = 64 self.sync_word2 = sync_word2 = [0j, 0j, 0j, 0j, 0j, 0j, (-1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1 +0j), (1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), 0j, (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), 0j, 0j, 0j, 0j, 0j] self.sync_word1 = sync_word1 = [0., 0., 0., 0., 0., 0., 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 0., 0., 0., 0., 0.] self.payload_equalizer = payload_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, payload_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols, 1) self.packet_len = packet_len = 96 self.header_formatter = header_formatter = digital.packet_header_ofdm(occupied_carriers, n_syms=1, len_tag_key=packet_length_tag_key, frame_len_tag_key=length_tag_key, bits_per_header_sym=header_mod.bits_per_symbol(), bits_per_payload_sym=payload_mod.bits_per_symbol(), scramble_header=False) self.header_equalizer = header_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, header_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols) ################################################## # Blocks ################################################## self.zeromq_pull_source_0_0_0_0_0_0 = zeromq.pull_source(gr.sizeof_gr_complex, 64, "tcp://" + ipp2 + ":55521", 100, True) self.my_number_sync_timestamp_0 = my.number_sync_timestamp() self.fft_vxx_1 = fft.fft_vcc(fft_len, True, (), True, 1) self.digital_ofdm_serializer_vcc_payload = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, length_tag_key, packet_length_tag_key, 1, "", True) self.digital_ofdm_frame_equalizer_vcvc_1 = digital.ofdm_frame_equalizer_vcvc(payload_equalizer.base(), fft_len/4, length_tag_key, True, 0) self.digital_crc32_bb_0 = digital.crc32_bb(True, packet_length_tag_key, True) self.digital_constellation_decoder_cb_1 = digital.constellation_decoder_cb(payload_mod.base()) self.blocks_repack_bits_bb_0 = blocks.repack_bits_bb(payload_mod.bits_per_symbol(), 8, packet_length_tag_key, True, gr.GR_LSB_FIRST) ################################################## # Connections ################################################## self.connect((self.blocks_repack_bits_bb_0, 0), (self.digital_crc32_bb_0, 0)) self.connect((self.digital_constellation_decoder_cb_1, 0), (self.blocks_repack_bits_bb_0, 0)) self.connect((self.digital_crc32_bb_0, 0), (self.my_number_sync_timestamp_0, 0)) self.connect((self.digital_ofdm_frame_equalizer_vcvc_1, 0), (self.digital_ofdm_serializer_vcc_payload, 0)) self.connect((self.digital_ofdm_serializer_vcc_payload, 0), (self.digital_constellation_decoder_cb_1, 0)) self.connect((self.fft_vxx_1, 0), (self.digital_ofdm_frame_equalizer_vcvc_1, 0)) self.connect((self.zeromq_pull_source_0_0_0_0_0_0, 0), (self.fft_vxx_1, 0))
def __init__(self, ipp1="127.0.0.1", ipp2="127.0.0.1", ipp3="127.0.0.1", ipp4="127.0.0.1", iptx="127.0.0.1", samp_rate=10000): gr.top_block.__init__(self, "OFDM Rx") ################################################## # Parameters ################################################## self.ipp1 = ipp1 self.ipp2 = ipp2 self.ipp3 = ipp3 self.ipp4 = ipp4 self.iptx = iptx self.samp_rate = samp_rate ################################################## # Variables ################################################## self.pilot_symbols = pilot_symbols = ((1, 1, 1, -1,),) self.pilot_carriers = pilot_carriers = ((-21, -7, 7, 21,),) self.payload_mod = payload_mod = digital.constellation_qpsk() self.packet_length_tag_key = packet_length_tag_key = "packet_len" self.occupied_carriers = occupied_carriers = (range(-26, -21) + range(-20, -7) + range(-6, 0) + range(1, 7) + range(8, 21) + range(22, 27),) self.length_tag_key = length_tag_key = "frame_len" self.header_mod = header_mod = digital.constellation_bpsk() self.fft_len = fft_len = 64 self.sync_word2 = sync_word2 = [0j, 0j, 0j, 0j, 0j, 0j, (-1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1 +0j), (1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), 0j, (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), 0j, 0j, 0j, 0j, 0j] self.sync_word1 = sync_word1 = [0., 0., 0., 0., 0., 0., 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 0., 0., 0., 0., 0.] self.payload_equalizer = payload_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, payload_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols, 1) self.packet_len = packet_len = 96 self.header_formatter = header_formatter = digital.packet_header_ofdm(occupied_carriers, n_syms=1, len_tag_key=packet_length_tag_key, frame_len_tag_key=length_tag_key, bits_per_header_sym=header_mod.bits_per_symbol(), bits_per_payload_sym=payload_mod.bits_per_symbol(), scramble_header=False) self.header_equalizer = header_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, header_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols) ################################################## # Blocks ################################################## self.zeromq_push_msg_sink_0 = zeromq.push_msg_sink("tcp://" + ipp3 + ":55530", 100) self.zeromq_pull_source_0_0_0_0_0 = zeromq.pull_source(gr.sizeof_gr_complex, 64, "tcp://"+ ipp2 + ":55520", 100, True) self.fft_vxx_0 = fft.fft_vcc(fft_len, True, (()), True, 1) self.digital_packet_headerparser_b_0 = digital.packet_headerparser_b(header_formatter.base()) self.digital_ofdm_serializer_vcc_header = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, length_tag_key, "", 0, "", True) self.digital_ofdm_frame_equalizer_vcvc_0 = digital.ofdm_frame_equalizer_vcvc(header_equalizer.base(), fft_len/4, length_tag_key, True, 1) self.digital_ofdm_chanest_vcvc_0 = digital.ofdm_chanest_vcvc((sync_word1), (sync_word2), 1, 0, 3, False) self.digital_constellation_decoder_cb_0 = digital.constellation_decoder_cb(header_mod.base()) ################################################## # Connections ################################################## self.msg_connect((self.digital_packet_headerparser_b_0, 'header_data'), (self.zeromq_push_msg_sink_0, 'in')) self.connect((self.digital_constellation_decoder_cb_0, 0), (self.digital_packet_headerparser_b_0, 0)) self.connect((self.digital_ofdm_chanest_vcvc_0, 0), (self.digital_ofdm_frame_equalizer_vcvc_0, 0)) self.connect((self.digital_ofdm_frame_equalizer_vcvc_0, 0), (self.digital_ofdm_serializer_vcc_header, 0)) self.connect((self.digital_ofdm_serializer_vcc_header, 0), (self.digital_constellation_decoder_cb_0, 0)) self.connect((self.fft_vxx_0, 0), (self.digital_ofdm_chanest_vcvc_0, 0)) self.connect((self.zeromq_pull_source_0_0_0_0_0, 0), (self.fft_vxx_0, 0))
def test_003(self): # Same test as above, only use 2 threads tb = gr.top_block() fft_size = 32 tmp_data = ( (4377 + 4516j), (-1706.1268310546875 + 1638.4256591796875j), (-915.2083740234375 + 660.69427490234375j), (-660.370361328125 + 381.59600830078125j), (-499.96044921875 + 238.41630554199219j), (-462.26748657226562 + 152.88948059082031j), (-377.98440551757812 + 77.5928955078125j), (-346.85821533203125 + 47.152004241943359j), (-295 + 20j), (-286.33609008789062 - 22.257017135620117j), (-271.52999877929688 - 33.081821441650391j), (-224.6358642578125 - 67.019538879394531j), (-244.24473571777344 - 91.524826049804688j), (-203.09068298339844 - 108.54627227783203j), (-198.45195007324219 - 115.90768432617188j), (-182.97744750976562 - 128.12318420410156j), (-167 - 180j), (-130.33688354492188 - 173.83778381347656j), (-141.19784545898438 - 190.28807067871094j), (-111.09677124023438 - 214.48896789550781j), (-70.039543151855469 - 242.41630554199219j), (-68.960540771484375 - 228.30015563964844j), (-53.049201965332031 - 291.47097778320312j), (-28.695289611816406 - 317.64553833007812j), (57 - 300j), (45.301143646240234 - 335.69509887695312j), (91.936195373535156 - 373.32437133789062j), (172.09465026855469 - 439.275146484375j), (242.24473571777344 - 504.47515869140625j), (387.81732177734375 - 666.6788330078125j), (689.48553466796875 - 918.2142333984375j), (1646.539306640625 - 1694.1956787109375j)) src_data = tuple([x / fft_size for x in tmp_data]) expected_result = tuple([ complex(primes[2 * i], primes[2 * i + 1]) for i in range(fft_size) ]) nthreads = 2 src = blocks.vector_source_c(src_data) s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_size) op = fft.fft_vcc(fft_size, False, [], False, nthreads) v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, fft_size) dst = blocks.vector_sink_c() tb.connect(src, s2v, op, v2s, dst) tb.run() result_data = dst.data() self.assert_fft_ok2(expected_result, result_data)
def test_002(self): src_data = tuple([x / self.fft_size for x in primes_transformed]) expected_result = tuple([complex(primes[2 * i], primes[2 * i + 1]) for i in range(self.fft_size)]) src = blocks.vector_source_c(src_data) s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) op = fft.fft_vcc(self.fft_size, False, [], False) v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size) dst = blocks.vector_sink_c() self.tb.connect(src, s2v, op, v2s, dst) self.tb.run() result_data = dst.data() self.assert_fft_ok2(expected_result, result_data)
def __init__(self, N=12, M=256, start_index=10, mapping=0, modulation=16, cp_ratio=0.25): gr.hier_block2.__init__(self, "scfdma_transmitter_bc", gr.io_signature(1, 1, gr.sizeof_char*1), gr.io_signature(1, 1, gr.sizeof_gr_complex*1), ) ################################################## # Parameters ################################################## self.N = N self.M = M self.start_index = start_index self.modulation = modulation self.cp_ratio = cp_ratio self.mapping = mapping ################################################## # Blocks ################################################## self.ofdm_scfdma_subcarrier_mapper_vcvc_0 = ofdm.scfdma_subcarrier_mapper_vcvc(N, M, start_index, mapping) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc([1.0/(M*N)]) self.ofdm_fbmc_symbol_creation_bvc_0 = ofdm.fbmc_symbol_creation_bvc(N, modulation) self.ofdm_cyclic_prefixer_0 = ofdm.cyclic_prefixer(M, int(M*(1+cp_ratio))) self.fft_vxx_0_0 = fft.fft_vcc(M, False, (), True, 1) self.fft_vxx_0 = fft.fft_vcc(N, True, (), True, 1) ################################################## # Connections ################################################## self.connect((self.fft_vxx_0, 0), (self.ofdm_scfdma_subcarrier_mapper_vcvc_0, 0)) self.connect((self.fft_vxx_0_0, 0), (self.ofdm_cyclic_prefixer_0, 0)) self.connect((self.ofdm_cyclic_prefixer_0, 0), (self.blocks_multiply_const_vxx_0,0)) self.connect((self.blocks_multiply_const_vxx_0,0), (self,0)) self.connect((self.ofdm_fbmc_symbol_creation_bvc_0, 0), (self.fft_vxx_0, 0)) self.connect((self.ofdm_scfdma_subcarrier_mapper_vcvc_0, 0), (self.fft_vxx_0_0, 0)) self.connect((self, 0), (self.ofdm_fbmc_symbol_creation_bvc_0, 0))
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Fft To Tcp") ################################################## # Variables ################################################## self.veclen = veclen = 8192 self.test = test = 1420e6 self.samp_rate = samp_rate = 1500000 ################################################## # Blocks ################################################## self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", 8080), allow_none=True) self.xmlrpc_server_0.register_instance(self) threading.Thread(target=self.xmlrpc_server_0.serve_forever).start() self.rtlsdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + "") self.rtlsdr_source_0.set_sample_rate(samp_rate) self.rtlsdr_source_0.set_center_freq(test, 0) self.rtlsdr_source_0.set_freq_corr(0, 0) self.rtlsdr_source_0.set_dc_offset_mode(0, 0) self.rtlsdr_source_0.set_iq_balance_mode(0, 0) self.rtlsdr_source_0.set_gain_mode(False, 0) self.rtlsdr_source_0.set_gain(1, 0) self.rtlsdr_source_0.set_if_gain(20, 0) self.rtlsdr_source_0.set_bb_gain(20, 0) self.rtlsdr_source_0.set_antenna("", 0) self.rtlsdr_source_0.set_bandwidth(0, 0) self.fft_vxx_0 = fft.fft_vcc(veclen, True, (window.blackmanharris(veclen)), True, 1) self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, samp_rate) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, veclen) self.blocks_complex_to_mag_0 = blocks.complex_to_mag(veclen) self.blks2_tcp_sink_0_0 = grc_blks2.tcp_sink( itemsize=gr.sizeof_gr_complex * samp_rate, addr="127.0.0.1", port=10002, server=True ) self.blks2_tcp_sink_0 = grc_blks2.tcp_sink( itemsize=gr.sizeof_float * veclen, addr="127.0.0.1", port=10001, server=True ) ################################################## # Connections ################################################## self.connect((self.blocks_complex_to_mag_0, 0), (self.blks2_tcp_sink_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.blocks_stream_to_vector_1, 0), (self.blks2_tcp_sink_0_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_0, 0)) self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_1, 0))
def test_two(self): tb = gr.top_block() MTU = 4000 tagname = "length" packets = ( (0, 0, 0, 0)*32, #(0, 0, 1, 0)*16, #(1, 1, 1, 0)*4, ) data, tags = ofdm.utils.packets_to_vectors(packets, tagname) constellation = digital.bpsk_constellation() src = gr.vector_source_b(data, tags, False, 1) tag_scaler1 = ofdm.scale_tags(1, tagname, 0.125) packer = gr.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) crc = ofdm.crc32_bb(False, MTU, tagname) tag_scaler2 = ofdm.scale_tags(1, tagname, 8) unpacker = gr.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST) mod1 = digital.chunks_to_symbols_bc(constellation.points()) mod2 = digital.chunks_to_symbols_bc(constellation.points()) occupied_carriers = ((1, 2, 4, 5),) fft_len = 16 header = ofdm.ofdm_header_bb(len(occupied_carriers[0])) mux1 = ofdm.tagged_stream_mux(gr.sizeof_gr_complex, 2, tagname, MTU) mux2 = ofdm.tagged_stream_mux(gr.sizeof_gr_complex*fft_len, 2, tagname, MTU) ifft = fft.fft_vcc(fft_len, forward=False, window=[1]*fft_len) cp_len = 4 rolloff_len = 2 cp = digital.ofdm_cyclic_prefixer(fft_len, fft_len+cp_len, rolloff_len, tagname, MTU) pilot_symbols = ((1j,),) pilot_carriers = ((3,),) alloc = ofdm.carrier_allocator_cvc(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, tagname) snk = gr.vector_sink_c() sync_packet = [0, 1, 0, 1, 0, 1] + [0]*10 sync_data, sync_tags = ofdm.utils.packets_to_vectors([sync_packet], tagname, vlen=fft_len) sync_header = gr.vector_source_c(sync_data, sync_tags, True, fft_len) tb.connect(src, tag_scaler1, packer, crc, tag_scaler2, unpacker, mod1, (mux1, 1)) tb.connect(crc, header, mod2, (mux1, 0)) tb.connect(mux1, alloc, (mux2, 1)) tb.connect(sync_header, (mux2, 0)) tb.connect(mux2, ifft, cp, snk) #tb.connect(src, tag_scaler1, packer, crc, tag_scaler2, unpacker, mod1, alloc, snk) tb.run()