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, parent, y_per_div=1, y_divs=8, ref_level=50, x_vals=numpy.arange(10), ninputs=1, size=default_curvesink_size, title='', x_units='', y_units='', legends=[], **kwargs): self.x_vals=x_vals; self.legends=legends gr.hier_block2.__init__(self, "curve_sink_f", gr.io_signature(ninputs, ninputs, gr.sizeof_float), gr.io_signature(0,0,0)) curve_sink_base.__init__(self, input_is_real=True, y_per_div=y_per_div, y_divs=y_divs, ref_level=ref_level, title=title, x_units=x_units, y_units=y_units) self.s2p = []; for i in range(0, ninputs): self.s2p.append(blocks.stream_to_vector(gr.sizeof_float, len(x_vals))) #self.one_in_n = gr.keep_one_in_n(gr.sizeof_float * self.fft_size, # max(1, int(self.sample_rate/self.fft_size/self.fft_rate))) self.interleave = blocks.interleave(gr.sizeof_float * len(x_vals)); self.s2v = blocks.stream_to_vector(gr.sizeof_float * len(x_vals), ninputs); self.sink = blocks.message_sink(gr.sizeof_float * len(x_vals) * ninputs, self.msgq, True); for i in range(0, ninputs): self.connect((self, i), self.s2p[i], (self.interleave, i)) self.connect(self.interleave, self.s2v, self.sink); self.win=curve_window(self, parent, size=size, x_units=self.x_units, y_units=self.y_units, ninputs=ninputs)
def __init__(self, size, factor, itemsize=gr.sizeof_gr_complex): """ size: (int) vector size (FFT size) of next block factor: (int) output will have this many more samples than input If size is not divisible by factor, then the output will necessarily have jitter. """ size = int(size) factor = int(factor) # assert size % factor == 0 offset = size // factor gr.hier_block2.__init__( self, type(self).__name__, gr.io_signature(1, 1, itemsize), gr.io_signature(1, 1, itemsize * size), ) if factor == 1: # No duplication needed; simplify flowgraph self.connect(self, blocks.stream_to_vector(itemsize, size), self) else: interleave = blocks.interleave(itemsize * size) self.connect(interleave, self) for i in xrange(0, factor): self.connect( self, blocks.delay(itemsize, (factor - 1 - i) * offset), blocks.stream_to_vector(itemsize, size), (interleave, i))
def test_001(self): tb = self.tb src1_data = (0,0.2,-0.3,0,12,0) src2_data = (0,0.0,3.0,0,10,0) src3_data = (0,0.0,3.0,0,1,0) src1 = blocks.vector_source_f(src1_data) s2v1 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src1, s2v1) src2 = blocks.vector_source_f(src2_data) s2v2 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src2, s2v2) src3 = blocks.vector_source_f(src3_data) s2v3 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src3, s2v3) dst1 = blocks.vector_sink_s() dst2 = blocks.vector_sink_s() argmax = blocks.argmax_fs(len(src1_data)) tb.connect(s2v1, (argmax, 0)) tb.connect(s2v2, (argmax, 1)) tb.connect(s2v3, (argmax, 2)) tb.connect((argmax,0), dst1) tb.connect((argmax,1), dst2) tb.run() index = dst1.data() source = dst2.data() self.assertEqual(index, (4,)) self.assertEqual(source, (0,))
def __init__(self, update_period=32, window=1024, step_size=0.001, num_ports=2): gr.hier_block2.__init__( self, "Phase Align", gr.io_signaturev(num_ports, num_ports, gen_sig_io(num_ports)), gr.io_signaturev(num_ports, num_ports, gen_sig_io(num_ports)), ) self.message_port_register_hier_in("Trigger") ################################################## # Parameters ################################################## self.update_period = update_period self.window = window self.step_size = step_size self.num_ports = num_ports ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## # Const block for reference signal to do nothing self.blocks_add_const_vxx_0 = blocks.add_const_vcc((0, )) self.connect((self, 0), (self.blocks_add_const_vxx_0, 0)) self.connect((self.blocks_add_const_vxx_0, 0), (self, 0)) for p in range(num_ports-1): # Create PC object object_name_pc = 'wifius_phase_correct_vci_'+str(p) setattr(self, object_name_pc, wifius.phase_correct_vci(1024, samp_rate, window, step_size, update_period, False)) # Add Stream To Vector For Ref object_name_vr = 'blocks_stream_to_vector_a_'+str(p) setattr(self, object_name_vr, blocks.stream_to_vector(gr.sizeof_gr_complex*1, window)) # Add Stream To Vector For Next Signal object_name_sv = 'blocks_stream_to_vector_b_'+str(p) setattr(self, object_name_sv, blocks.stream_to_vector(gr.sizeof_gr_complex*1, window)) # Add Vector To Stream For Output of PC object_name_vs = 'blocks_vector_to_stream_'+str(p) setattr(self, object_name_vs, blocks.vector_to_stream(gr.sizeof_gr_complex*1, window)) # Make Connections self.connect((self, 0), (getattr(self,object_name_vr), 0)) self.connect((self, p+1), (getattr(self,object_name_sv), 0)) self.connect((getattr(self,object_name_vr), 0), (getattr(self,object_name_pc), 0)) self.connect((getattr(self,object_name_sv), 0), (getattr(self,object_name_pc), 1)) self.connect((getattr(self,object_name_pc), 0), (getattr(self,object_name_vs), 0)) self.connect((getattr(self,object_name_vs), 0), (self, p+1)) self.msg_connect((self, 'Trigger'), (getattr(self,object_name_pc), 'set_enable_sync'))
def __init__(self, filename, dev_addrs, onebit, gain, digital_gain, fs, fc, sync_pps): gr.top_block.__init__(self) if onebit: raise NotImplementedError("TODO: 1-bit mode not implemented.") uhd_srcs = [ uhd.usrp_source(",".join( [addr, "num_recv_frames=256,recv_frame_size=16384"]), uhd.stream_args( cpu_format="fc32", otwformat="sc16", channels=[0])) for addr in dev_addrs] str2vec = blocks.streams_to_vector(2, len(uhd_srcs)) self.connect(str2vec, blocks.stream_to_vector(2 * len(uhd_srcs), 16*1024*1024), blocks.file_sink(2 * len(uhd_srcs) * 16 * 1024 * 1024, filename, False)) for ix, src in enumerate(uhd_srcs): src.set_clock_rate(fs*2, uhd.ALL_MBOARDS) src.set_samp_rate(fs) src.set_center_freq(uhd.tune_request(fc, 3e6)) src.set_gain(gain, 0) # TODO Use offset tuning? if sync_pps: src.set_clock_source("external") # 10 MHz src.set_time_source("external") # PPS self.connect(src, # [-1.0, 1.0] blocks.multiply_const_cc(32767 * digital_gain[ix]), # [-32767.0, 32767.0] blocks.complex_to_interleaved_short(), #[-32768, 32767] blocks.short_to_char(), #[-128, 127] blocks.stream_to_vector(1, 2), # I,Q,I,Q -> IQ, IQ (str2vec, ix)) print "Setting clocks..." if sync_pps: time.sleep(1.1) # Ensure there's been an edge. TODO: necessary? last_pps_time = uhd_srcs[0].get_time_last_pps() while last_pps_time == uhd_srcs[0].get_time_last_pps(): time.sleep(0.1) print "Got edge" [src.set_time_next_pps(uhd.time_spec(round(time.time())+1)) for src in uhd_srcs] time.sleep(1.0) # Wait for edge to set the clocks else: # No external PPS/10 MHz. Just set each clock and accept some skew. t = time.time() [src.set_time_now(uhd.time_spec(time.time())) for src in uhd_srcs] if len(uhd_srcs) > 1: print "Uncabled; loosely synced only. Initial skew ~ %.1f ms" % ( (time.time()-t) * 1000) t_start = uhd.time_spec(time.time() + 1.5) [src.set_start_time(t_start) for src in uhd_srcs] print "ready"
def test_002_t (self): #print "TEST: discarded carriers and num sync words" # set up fg test_len = 200 vlen = 20 ts_len = test_len/vlen discarded_carriers = (-8,-4,-2,1,2,3,9) num_sync_words = 2 in_data0 = [0]*test_len in_data1 = [0]*test_len for k in range(test_len): in_data0[k] = complex(k-4, k+1) in_data1[k] = complex(k+3, k-2) src0 = blocks.vector_source_c(in_data0) s2v0 = blocks.stream_to_vector(8,vlen) s2ts0 = blocks.stream_to_tagged_stream(8,vlen,ts_len,'packet_len') src1 = blocks.vector_source_c(in_data1) s2v1 = blocks.stream_to_vector(8,vlen) s2ts1 = blocks.stream_to_tagged_stream(8,vlen,ts_len,'packet_len') div = radar.ofdm_divide_vcvc(vlen,vlen,discarded_carriers,num_sync_words) v2s = blocks.vector_to_stream(8,vlen) snk = blocks.vector_sink_c() self.tb.connect(src0,s2v0,s2ts0) self.tb.connect(src1,s2v1,s2ts1) self.tb.connect((s2ts0,0),(div,0)) self.tb.connect((s2ts1,0),(div,1)) self.tb.connect(div,v2s,snk) self.tb.run () # get ref data discarded_carriers_shift = [0]*len(discarded_carriers) for k in range(len(discarded_carriers)): discarded_carriers_shift[k] = discarded_carriers[k] + vlen/2 ref_data = [0]*test_len for k in range(test_len/vlen): for l in range(vlen): if k < num_sync_words: # do not process sync words with discarded carriers ref_data[vlen*k+l] = in_data0[vlen*k+l]/in_data1[vlen*k+l] else: # process discarded carriers if l in discarded_carriers_shift: # if actual item shall be discarded ref_data[vlen*k+l] = 0 else: # if actual item shall NOT be discarded ref_data[vlen*k+l] = in_data0[vlen*k+l]/in_data1[vlen*k+l] # check data #print "REF" #print ref_data out_data = snk.data() #print "DATA" #print out_data for k in range(len(out_data)): self.assertAlmostEqual(ref_data[k], out_data[k],4)
def __init__(self, M): gr.hier_block2.__init__(self, "overlap_serial_to_parallel_cvc", gr.io_signature(1, 1, gr.sizeof_gr_complex*1), gr.io_signature(1, 1, gr.sizeof_gr_complex*M), ) ################################################## # Parameters ################################################## self.M = M ################################################## # Blocks ################################################## ##self.fbmc_vector_reshape_vcvc_1 = fbmc_vector_reshape_vcvc(M/2, M) ##self.fbmc_vector_reshape_vcvc_0 = fbmc_vector_reshape_vcvc(M, M/2) self.fbmc_vector_copy_vcvc_0 = ofdm.fbmc_vector_copy_vcvc(M/2, 2) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, M/2) # self.blocks_skiphead_0 = blocks.skiphead(gr.sizeof_gr_complex*M/2, 1) ################################################## # Connections ################################################## # self.connect((self.blocks_skiphead_0, 0), (self.fbmc_vector_reshape_vcvc_1, 0)) self.connect((self, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fbmc_vector_copy_vcvc_0, 0)) # self.connect((self.fbmc_vector_copy_vcvc_0, 0), (self, 0)) # self.connect((self.fbmc_vector_copy_vcvc_0, 0), (self.fbmc_vector_reshape_vcvc_0, 0)) # self.connect((self.fbmc_vector_reshape_vcvc_0, 0), (self.blocks_skiphead_0, 0)) # self.connect((self.fbmc_vector_reshape_vcvc_0, 0), (self, 0)) # self.fbmc_vector_copy_vcvc_0 = fbmc.vector_copy_vcvc(M, 2) self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, M/2) self.blocks_stream_to_vector_0_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*M/2, 2) # self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, M) self.blocks_skiphead_0 = blocks.skiphead(gr.sizeof_gr_complex*M/2, 1) # ################################################## # # Connections # ################################################## # self.connect((self.blocks_stream_to_vector_0, 0), (self.fbmc_vector_copy_vcvc_0, 0)) # self.connect((self.fbmc_vector_copy_vcvc_0, 0), (self.blocks_vector_to_stream_0, 0)) # # self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_stream_to_vector_0_0, 0)) # self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_skiphead_0, 0)) # self.connect((self.blocks_skiphead_0, 0), (self.blocks_stream_to_vector_0_0, 0)) # # self.connect((self, 0), (self.blocks_stream_to_vector_0, 0)) # self.connect((self.blocks_stream_to_vector_0_0, 0), (self, 0)) self.connect((self.fbmc_vector_copy_vcvc_0, 0),(self.blocks_skiphead_0, 0)) self.connect((self.blocks_skiphead_0, 0), (self.blocks_stream_to_vector_0_0, 0)) # self.connect((self, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_stream_to_vector_0_0, 0), (self, 0))
def __init__(self, n=512): gr.top_block.__init__(self, "SDR Spectrum Analyzer Server") ################################################## # Variables ################################################## self.port = port = 9999 self.gan = gan = 10 self.fc = fc = 99700000 self.ab = ab = 20000000 self.N = N = 1024 self.n = n self.IP = IP = "192.168.1.103" self.Antena = Antena = "RX2" self.ventana = ventana = window.blackmanharris self.base = base = "exponencial" ################################################## # Blocks ################################################## self.src = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.src.set_samp_rate(ab) self.src.set_center_freq(fc, 0) self.src.set_gain(gan, 0) self.src.set_antenna("RX2", 0) self.dbm = RadioGIS.dbm() self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, N) self.blocks_vector_to_stream_1 = blocks.vector_to_stream(gr.sizeof_float*1, N) self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_float*1, N*n) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, N) self.blocks_complex_to_mag_0 = blocks.complex_to_mag(N) self.udp_sink_0 = blocks.udp_sink(gr.sizeof_float*1, IP, port, 1472, True) self.RadioGIS_fft_0 = RadioGIS.fft(N, base, (ventana(N))) self.RadioGIS_averager_0 = RadioGIS.averager(N, n) ################################################## # Connections ################################################## self.connect((self.RadioGIS_averager_0, 0), (self.blocks_vector_to_stream_0, 0)) self.connect((self.dbm, 0), (self.udp_sink_0, 0)) self.connect((self.RadioGIS_fft_0, 0), (self.blocks_complex_to_mag_0, 0)) self.connect((self.blocks_complex_to_mag_0, 0), (self.blocks_vector_to_stream_1, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.RadioGIS_fft_0, 0)) self.connect((self.blocks_stream_to_vector_1, 0), (self.RadioGIS_averager_0, 0)) self.connect((self.blocks_vector_to_stream_0, 0), (self.dbm, 0)) self.connect((self.blocks_vector_to_stream_1, 0), (self.blocks_stream_to_vector_1, 0)) self.connect((self.src, 0), (self.blocks_stream_to_vector_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_001_diff_phasor_vcc(self): a = [1+2j,2+3.5j,3.5+4j,4+5j,5+6j] b = [1j,1j,1j,1j,1j] c = [-1j+3,1j,-7+0j,2.5j+0.333,3.2j] d = [(0.35979271051026462+0.89414454782483865j), (0.19421665709046287+0.024219594550527801j), (0.12445564785882557+0.40766238899138718j), (0.041869638845043688+0.97860437393366329j), (0.068927762235083234+0.16649764877365247j)] e = [(0.16207552830286298+0.435385030608331j), (0.47195779613669675+0.37824764113272558j), (0.13911998015446148+0.6585095669811617j), (0.093510743358783954+0.98446560079828938j), (0.86036393297704694+0.72043005342024602j)] multconj = lambda x,y: x.conjugate()*y src_data = a+b+c+d+e expected_result = [0j,0j,0j,0j,0j]+map(multconj,a,b)+map(multconj,b,c)+map(multconj,c,d)+map(multconj,d,e) src = blocks.vector_source_c(src_data) s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, 5) diff_phasor_vcc = grdab.diff_phasor_vcc(5) v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, 5) dst = blocks.vector_sink_c() self.tb.connect(src, s2v, diff_phasor_vcc, v2s, dst) self.tb.run() result_data = dst.data() # print expected_result # print result_data self.assertComplexTuplesAlmostEqual(expected_result, result_data, 6)
def __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 test_004(self): vlen = 4 tune = counter4(self, 1) tune_delay = 1 dwell_delay = 2 msgq = gr.msg_queue() src_data = tuple([float(x) for x in ( 1, 2, 3, 4, 9, 6, 11, 8, 5, 10, 7, 12, 13, 14, 15, 16 )]) expected_results = tuple([float(x) for x in ( 9, 10, 11, 12)]) src = blocks.vector_source_f(src_data, False) s2v = blocks.stream_to_vector(gr.sizeof_float, vlen) stats = blocks.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay) self.tb.connect(src, s2v, stats) self.tb.run() self.assertEqual(1, msgq.count()) for i in range(1): m = parse_msg(msgq.delete_head()) #print "m =", m.center_freq, m.data self.assertEqual(expected_results[vlen*i:vlen*i + vlen], m.data)
def test_001_ofdm_coarse_frequency_correct(self): fft_length = 10 num_carriers = 2 cp_length = 3 src_data0 = [0,1,2,3,4,5,6,7,8,9,1,2,0,5,7,6,0,4,0,6,1,1,1,0.8,0.1,1.3,1,0.7,1,1,0,1,2,3,4,5,6,7,8,9] expected_result0 = [7,9,5,6,0.8,1.3,3,5] offset = [3,3,-1,-1,-1,-1,-1,-1] frame_index = [0,0, 0, 0, 0, 0, 1, 1] expected_result0 = [complex(expected_result0[i])*cmath.exp(-2j*cmath.pi*offset[i]*cp_length/float(fft_length)*frame_index[i]) for i in range(0,8)] src_data1 = [1,1,1,0] expected_result1 = (1,1,1,0) src0 = blocks.vector_source_c(src_data0) src1 = blocks.vector_source_b(src_data1) s2v0 = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_length) ofdm_coarse_frequency_correct = grdab.ofdm_coarse_frequency_correct(fft_length,num_carriers,cp_length) v2s0 = blocks.vector_to_stream(gr.sizeof_gr_complex, num_carriers) dst0 = blocks.vector_sink_c() dst1 = blocks.vector_sink_b() self.tb.connect(src0, s2v0, (ofdm_coarse_frequency_correct,0)) self.tb.connect(src1, (ofdm_coarse_frequency_correct,1)) self.tb.connect((ofdm_coarse_frequency_correct,0), v2s0, dst0) self.tb.connect((ofdm_coarse_frequency_correct,1), dst1) self.tb.run() result_data0 = dst0.data() result_data1 = dst1.data() # print expected_result0 # print result_data0 self.assertComplexTuplesAlmostEqual(expected_result0, result_data0, 4) self.assertEqual(result_data1, expected_result1)
def test_03(self): tb = self.tb vlen = 5 N = 10*vlen seed = 0 data = make_random_float_tuple(N, 2**10) data = [int(d*1000) for d in data] src = blocks.vector_source_i(data, False) one_to_many = blocks.stream_to_streams(gr.sizeof_int, vlen) one_to_vector = blocks.stream_to_vector(gr.sizeof_int, vlen) many_to_vector = blocks.streams_to_vector(gr.sizeof_int, vlen) isolated = [ blocks.moving_average_ii(100, 1) for i in range(vlen)] dut = blocks.moving_average_ii(100, 1, vlen=vlen) dut_dst = blocks.vector_sink_i(vlen=vlen) ref_dst = blocks.vector_sink_i(vlen=vlen) tb.connect(src, one_to_many) tb.connect(src, one_to_vector, dut, dut_dst) tb.connect(many_to_vector, ref_dst) for idx, single in enumerate(isolated): tb.connect((one_to_many,idx), single, (many_to_vector,idx)) tb.run() dut_data = dut_dst.data() ref_data = ref_dst.data() # make sure result is close to zero self.assertTupleEqual(dut_data, ref_data)
def test_001_t (self): # set up fg # check samples on output test_len = 12 in_data = range(test_len) vlen_in = 3 vlen_out = 4 src = blocks.vector_source_c(in_data) stv = blocks.stream_to_vector(8,vlen_in) s2ts = blocks.stream_to_tagged_stream(8,vlen_in,test_len/vlen_in,'packet_len') transpose = radar.transpose_matrix_vcvc(vlen_in,vlen_out,'packet_len') vts = blocks.vector_to_stream(8,vlen_out) snk = blocks.vector_sink_c() self.tb.connect(src,stv,s2ts,transpose,vts,snk) self.tb.run() # check data out_data = snk.data() ref_data = [0]*len(in_data) counter = 0; for k in range(vlen_in): for l in range(test_len/vlen_in): ref_data[counter] = in_data[l*vlen_in+k] counter = counter+1 out_data_real = [0]*len(in_data) for k in range(len(in_data)): out_data_real[k] = out_data[k].real for k in range(len(out_data_real)): self.assertEqual(out_data_real[k],ref_data[k])
def test_002_ofdm_remove_first_symbol_vcc(self): src_data0 = (0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7) src_data1 = (1,0,0,1,0,0) expected_result0 = (3,4,5,6,7,8,2,3,4,5,6,7) expected_result0 = [x+0j for x in expected_result0] expected_result1 = (1,0,1,0) src0 = blocks.vector_source_c(src_data0) src1 = blocks.vector_source_b(src_data1) s2v0 = blocks.stream_to_vector(gr.sizeof_gr_complex,3) ofdm_remove_first_symbol = grdab.ofdm_remove_first_symbol_vcc(3) v2s0 = blocks.vector_to_stream(gr.sizeof_gr_complex,3) dst0 = blocks.vector_sink_c() dst1 = blocks.vector_sink_b() self.tb.connect(src0, s2v0, (ofdm_remove_first_symbol,0)) self.tb.connect(src1, (ofdm_remove_first_symbol,1)) self.tb.connect((ofdm_remove_first_symbol,0), v2s0, dst0) self.tb.connect((ofdm_remove_first_symbol,1), dst1) self.tb.run() result_data0 = dst0.data() result_data1 = dst1.data() # print src_data0 # print expected_result0 # print result_data0 self.assertComplexTuplesAlmostEqual(expected_result0, result_data0, 6) self.assertEqual(result_data1, expected_result1)
def test_003_t (self): vec_len = 3 my_select = 2 src_data = (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,1.0,10.0,100.0) expected_result = (3.0,6.0,9.0,100.0) src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, vec_len) blk = testblocks.vec_select(vec_len, my_select) dst = blocks.vector_sink_f() blk.set_select(3) self.tb.connect(src, s2v) self.tb.connect(s2v, blk) self.tb.connect(blk, dst) self.tb.run() result_data = dst.data() print "T3 Source: " print str(src_data).strip('[]') print "T3 Expected Results: " print str(expected_result).strip('[]') print "T3 Results: " print str(result_data).strip('[]') self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
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 run_flow_graph(sync_sym1, sync_sym2, data_sym): top_block = gr.top_block() carr_offset = random.randint(-max_offset/2, max_offset/2) * 2 tx_data = shift_tuple(sync_sym1, carr_offset) + \ shift_tuple(sync_sym2, carr_offset) + \ shift_tuple(data_sym, carr_offset) channel = [rand_range(min_chan_ampl, max_chan_ampl) * numpy.exp(1j * rand_range(0, 2 * numpy.pi)) for x in range(fft_len)] src = blocks.vector_source_c(tx_data, False, fft_len) chan = blocks.multiply_const_vcc(channel) noise = analog.noise_source_c(analog.GR_GAUSSIAN, wgn_amplitude) add = blocks.add_cc(fft_len) chanest = digital.ofdm_chanest_vcvc(sync_sym1, sync_sym2, 1) sink = blocks.vector_sink_c(fft_len) top_block.connect(src, chan, (add, 0), chanest, sink) top_block.connect(noise, blocks.stream_to_vector(gr.sizeof_gr_complex, fft_len), (add, 1)) top_block.run() channel_est = None carr_offset_hat = 0 rx_sym_est = [0,] * fft_len tags = sink.tags() for tag in tags: if pmt.symbol_to_string(tag.key) == 'ofdm_sync_carr_offset': carr_offset_hat = pmt.to_long(tag.value) self.assertEqual(carr_offset, carr_offset_hat) if pmt.symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': channel_est = shift_tuple(pmt.c32vector_elements(tag.value), carr_offset) shifted_carrier_mask = shift_tuple(carrier_mask, carr_offset) for i in range(fft_len): if shifted_carrier_mask[i] and channel_est[i]: self.assertAlmostEqual(channel[i], channel_est[i], places=0) rx_sym_est[i] = (sink.data()[i] / channel_est[i]).real return (carr_offset, list(shift_tuple(rx_sym_est, -carr_offset_hat)))
def __init__(self): 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_002_t (self): # set up fg # check on reverse by using two times test_len = 12 in_data = range(test_len) vlen_in = 3 vlen_out = 4 src = blocks.vector_source_c(in_data) stv = blocks.stream_to_vector(8,vlen_in) s2ts = blocks.stream_to_tagged_stream(8,vlen_in,test_len/vlen_in,'packet_len') transpose1 = radar.transpose_matrix_vcvc(vlen_in,vlen_out,'packet_len') transpose2 = radar.transpose_matrix_vcvc(vlen_out,vlen_in,'packet_len') vts = blocks.vector_to_stream(8,vlen_in) snk = blocks.vector_sink_c() vts2 = blocks.vector_to_stream(8,vlen_out) snk2 = blocks.vector_sink_c() self.tb.connect(src,stv,s2ts,transpose1,transpose2,vts,snk) self.tb.connect(transpose1,vts2,snk2) self.tb.run() # check data out_data_real = [0]*len(in_data) out_data = snk.data() for k in range(len(in_data)): out_data_real[k] = out_data[k].real print "Input data:", in_data print "Output data:", out_data_real print "Transpose data:", snk2.data() for k in range(len(out_data_real)): self.assertEqual(out_data_real[k],in_data[k])
def __init__(self, size, factor, migrate=None): ''' size: (int) vector size (FFT size) of next block factor: (int) output will have this many more samples than input If size is not divisible by factor, then the output will necessarily have jitter. ''' size = int(size) factor = int(factor) # assert size % factor == 0 offset = size // factor gr.hier_block2.__init__( self, self.__class__.__name__, gr.io_signature(1, 1, self.__element), gr.io_signature(1, 1, self.__element), ) if factor == 1: # No duplication needed; simplify flowgraph # GR refused to connect self to self, so insert a dummy block self.connect(self, blocks.copy(self.__element), self) else: interleave = blocks.interleave(self.__element * size) self.connect( interleave, blocks.vector_to_stream(self.__element, size), self) for i in xrange(0, factor): self.connect( self, blocks.delay(self.__element, (factor - 1 - i) * offset), blocks.stream_to_vector(self.__element, size), (interleave, i))
def device_definition(options): """ Definition of the devices used in the program. @param options """ tb = OpERAFlow(name='US') the_source = blocks.file_source(gr.sizeof_gr_complex, "./%d_%d_%d_%d_noise.bin" % (options.fft_length, options.cp_length, options.ebn0, options.it), False) radio = RadioDevice(name="radio") det = Correlator() middle = gr.hier_block2( name='hier', input_signature = gr.io_signature(1, 1, gr.sizeof_gr_complex), output_signature = gr.io_signature(1, 1, gr.sizeof_float * 1024), ) middle.connect(middle, blocks.stream_to_vector(gr.sizeof_gr_complex, 1024), blocks.complex_to_mag(1024), middle) ed = EnergySSArch(1024, 1, EnergyDecision(th = options.threshold)) radio.add_arch(source = the_source, arch = middle, sink =(det,0), uhd_device=the_source, name='estimator') radio.add_arch(source = the_source, arch = ed, sink =(det,1), uhd_device=the_source, name = "ed") tb.add_radio(radio, "radio") return tb, radio, det
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_float), gr.io_signature(0,0,0)) waterfall_sink_base.__init__(self, input_is_real=True, 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 = blocks.stream_to_vector(gr.sizeof_float, self.fft_size) self.one_in_n = blocks.keep_one_in_n(gr.sizeof_float * 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_vfc(self.fft_size, True, mywindow) self.c2mag = blocks.complex_to_mag(self.fft_size) self.avg = filter.single_pole_iir_filter_ff(1.0, self.fft_size) self.log = blocks.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size)) self.sink = blocks.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, 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 test_002_t (self): # set up fg in_data = range(20) vlen_in = 5 crop_x = (2,4) crop_y = (1,4) src = blocks.vector_source_c(in_data) s2v = blocks.stream_to_vector(8,vlen_in) s2ts = blocks.stream_to_tagged_stream(8,vlen_in,len(in_data)/vlen_in,'packet_len') crop = radar.crop_matrix_vcvc(vlen_in,crop_x,crop_y) v2s = blocks.vector_to_stream(8,crop_x[1]-crop_x[0]) snk = blocks.vector_sink_c() debug = blocks.tag_debug(8,'debug') self.tb.connect(src,s2v,s2ts,crop,v2s,snk) self.tb.connect(v2s,debug) self.tb.run () # check data ref_data = (7,8,12,13,17,18) out_data = snk.data() print "INDATA:", in_data print "REF: ", ref_data print "OUTPUT:", out_data for k in range(len(out_data)): self.assertEqual(out_data[k].real,ref_data[k])
def __init__(self, samp_rate=1000, vecsize=500, folding=5, pulse_rate=0.7477): gr.hier_block2.__init__( self, "Synch Folder2", gr.io_signature(1, 1, gr.sizeof_float*1), gr.io_signature(1, 1, gr.sizeof_float*vecsize), ) ################################################## # Parameters ################################################## self.samp_rate = samp_rate self.vecsize = vecsize self.folding = folding self.pulse_rate = pulse_rate ################################################## # Blocks ################################################## self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(1.0/folding, vecsize) self.fractional_resampler_xx_0 = filter.fractional_resampler_ff(0, float(samp_rate)/(float(pulse_rate)*float(vecsize))) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_float*1, vecsize) ################################################## # Connections ################################################## self.connect((self.blocks_stream_to_vector_0, 0), (self.single_pole_iir_filter_xx_0, 0)) self.connect((self.fractional_resampler_xx_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self, 0), (self.fractional_resampler_xx_0, 0)) self.connect((self.single_pole_iir_filter_xx_0, 0), (self, 0))
def test_001(self): src_data = (0, 0.2, -0.25, 0, 12, 0) expected_result = (float(min(src_data)),) src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) op = blocks.min_ff(len(src_data)) dst = blocks.vector_sink_f() self.tb.connect(src, s2v, op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def help_cc(self, size, src_data, exp_data, op): for s in zip(list(range(len(src_data))), src_data): src = blocks.vector_source_c(s[1]) srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, size) dst = blocks.vector_sink_c() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_002_unpuncture_vff(self): src_data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) punc_seq = (1, 0, 0, 0, 1, 0, 1, 1, 1) exp_res = (0, 0, 0, 0, 1, 0, 2, 3, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9) src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, 5) unpuncture_vff = dab.unpuncture_vff(punc_seq) v2s = blocks.vector_to_stream(gr.sizeof_float, 9) dst = blocks.vector_sink_f() self.tb.connect(src, s2v, unpuncture_vff, v2s, dst) self.tb.run() result_data = dst.data() self.assertFloatTuplesAlmostEqual(exp_res, result_data)
def stest_s001(self): src_data = (0, 2, -3, 0, 12, 0) expected_result = (min(src_data),) src = blocks.vector_source_s(src_data) s2v = blocks.stream_to_vector(gr.sizeof_short,len(src_data)) op = blocks.min_ss(len(src_data)) dst = blocks.vector_sink_s() self.tb.connect(src, s2v, op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def test_001(self): tb = self.tb src1_data = [0, 0.2, -0.3, 0, 12, 0] src2_data = [0, 0.0, 3.0, 0, 10, 0] src3_data = [0, 0.0, 3.0, 0, 1, 0] src1 = blocks.vector_source_f(src1_data) s2v1 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src1, s2v1) src2 = blocks.vector_source_f(src2_data) s2v2 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src2, s2v2) src3 = blocks.vector_source_f(src3_data) s2v3 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src3, s2v3) dst1 = blocks.vector_sink_s() dst2 = blocks.vector_sink_s() argmax = blocks.argmax_fs(len(src1_data)) tb.connect(s2v1, (argmax, 0)) tb.connect(s2v2, (argmax, 1)) tb.connect(s2v3, (argmax, 2)) tb.connect((argmax, 0), dst1) tb.connect((argmax, 1), dst2) tb.run() index = dst1.data() source = dst2.data() self.assertEqual(index, [ 4, ]) self.assertEqual(source, [ 0, ])
def setUp(self): self.tb = gr.top_block() print "begin setup" key = "descr_part" self.src = blocks.vector_source_f([0.0] * 480, False, 480) self.rpt = blocks.repeat(gr.sizeof_float * 480, 4) self.stv = blocks.stream_to_vector(gr.sizeof_float * 480, 4) self.descr = lte.pbch_descrambler_vfvf(key) self.snk = blocks.vector_sink_f(120) self.tb.connect(self.src, self.rpt, self.stv, self.descr, self.snk) print "end setup"
def test_001_correct_individual_phase_offset_vff(self): expected_result = [x * pi / 2 + pi / 4 for x in [1, -2, -1, 0, 1, -2]] src_data = map(lambda x, y: x + y, expected_result, [0.1, 0.3, -0.2, 0.2, 0.4, 0.1]) src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, 3) mut = grdab.correct_individual_phase_offset_vff(3, 1) v2s = blocks.vector_to_stream(gr.sizeof_float, 3) dst = blocks.vector_sink_f() self.tb.connect(src, s2v, mut, v2s, dst) self.tb.run() result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data, 5)
def stest_002(self): src_data=(-100,-99,-98,-97,-96,-1) expected_result = (float(min(src_data)),) src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) op = blocks.min_ff(len(src_data)) dst = blocks.vector_sink_f() self.tb.connect(src, s2v, op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def stest_s002(self): src_data=(-100,-99,-98,-97,-96,-1) expected_result = (max(src_data),) src = blocks.vector_source_s(src_data) s2v = blocks.stream_to_vector(gr.sizeof_short, len(src_data)) op = blocks.max_ss(len(src_data)) dst = blocks.vector_sink_s() self.tb.connect(src, s2v, op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def test_ff_003(self): block_size = 2 src_data = (0, 1000, 2000, 3000, 4000, 5000) expected_result = (0, 125, 250, 484.375, 718.75, 1048.828125) src = blocks.vector_source_f(src_data) s2p = blocks.stream_to_vector(gr.sizeof_float, block_size) op = filter.single_pole_iir_filter_ff(0.125, block_size) p2s = blocks.vector_to_stream(gr.sizeof_float, block_size) dst = blocks.vector_sink_f() self.tb.connect(src, s2p, op, p2s, dst) self.tb.run() result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data, 3)
def __init__(self): gr.top_block.__init__(self, "Salsa Eceiver") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 5000000.0 self.outfile = outfile = "/tmp/vale.dat" self.int_time = int_time = 10 self.gain = gain = 60 self.fftsize = fftsize = 4096 self.c_freq = c_freq = 1420.4e6 ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="addr=192.168.10.2", stream_args=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(c_freq, 0) self.uhd_usrp_source_0.set_gain(gain, 0) self.fft_vxx_0 = fft.fft_vcc(fftsize, True, (window.blackmanharris(fftsize)), True, 1) self.blocks_vector_to_stream_0 = blocks.vector_to_stream( gr.sizeof_gr_complex * 1, fftsize) self.blocks_stream_to_vector_0 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, fftsize) self.blocks_head_0 = blocks.head(gr.sizeof_float * 1, int(int_time * samp_rate)) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float * 1, outfile, False) self.blocks_file_sink_0.set_unbuffered(False) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1) ################################################## # Connections ################################################## 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)) self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_head_0, 0)) self.connect((self.blocks_head_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
def __init__(self): gr.top_block.__init__(self) ################################################ ### EL FLUJOGRAMA ### ################################################ # Las variables usadas en el flujograma samp_rate = 11025 N = 1024 Sps = 6 ntaps = 6 * 6 beta = 0 # respuesta al impulso #h=misbloques.rect(Sps) # forma rectangular #h=misbloques.nyq(Sps,ntaps) # forma sinc #h=misbloques.rcos(Sps,ntaps,beta) # forma coseno alzado #h=misbloques.rrcos(Sps,ntaps,beta) # forma raiz coseno alzado #h=misbloques.B_NRZ_L(Sps) # forma NRZ_L #h=misbloques.RZ(Sps) # forma RZ h = misbloques.saw(Sps) # forma saw # Los bloques p_fuente = misbloques.e_generador_fun_f(Sps, h) p_pantalla_t = qtgui.time_sink_f( 512, # numero de muestras en la ventana del osciloscopio samp_rate, "senal promediada", # nombre que aparece en la grafica 1 # Nuemero de entradas del osciloscopio ) p_chorro_a_vector = blocks.stream_to_vector(gr.sizeof_float * 1, N) p_psd = misbloques.e_vector_psd_ff(N, 2000000) p_pantalla_vectorial = qtgui.vector_sink_f( N, -samp_rate / 2., samp_rate / N, "frecuencia", "Magnitud", "PSD", 1 # Number of inputs ) p_pantalla_vectorial.enable_autoscale(True) # LAS CONEXIONES self.connect(p_fuente, p_pantalla_t) self.connect(p_fuente, p_chorro_a_vector, p_psd, p_pantalla_vectorial) # La configuracion para graficar pyobj = sip.wrapinstance(p_pantalla_vectorial.pyqwidget(), Qt.QWidget) pyobj1 = sip.wrapinstance(p_pantalla_t.pyqwidget(), Qt.QWidget) pyobj.show() pyobj1.show()
def test_001_t(self): vsize = 2048 vin = numpy.zeros(vsize) for i in range(vsize): vin[i] = float(i) # create a set of vectors src = blocks.vector_source_f(vin.tolist(), False) s2v = blocks.stream_to_vector(gr.sizeof_float, vsize) # parameters we're setting frequency = 1419.5E6 bandwidth = 6.E6 azimuth = 179.9 elevation = 44.9 observers = "Science Aficionados" setupFile = "Watch.not" site = "Moumau House" device = "rtlsdr,bias=0" device = "airspy,pack=1,bias=1" obstype = radioastronomy.OBSSURVEY record = radioastronomy.INTRECORD nmedian = 4**6 nave = 10 gain1 = 40.5 gain2 = 11.0 gain3 = 11.0 # block we're testing vblock = ra_ascii_sink(setupFile, observers, vsize, frequency, bandwidth, azimuth, elevation, record, obstype, nmedian, nave, site, device, gain1, gain2, gain3) print 'Test init DataDir: ', vblock.obs.datadir # skip writing the notes file over and over dosave = False # now set all parameters vblock.set_frequency(frequency, dosave) vblock.set_bandwidth(bandwidth, dosave) vblock.set_azimuth(azimuth, dosave) vblock.set_elevation(elevation, dosave) vblock.set_nmedian(nmedian, dosave) vblock.set_gain1(gain1, dosave) vblock.set_gain2(gain2, dosave) vblock.set_gain3(gain3, dosave) vblock.set_record(record) self.tb.connect(src, s2v) self.tb.connect(s2v, vblock) self.tb.run() vblock.set_record(radioastronomy.INTWAIT) self.tb.run()
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) 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 fft_channelizer( self, fft_len, channel_bins): #do a fwd fft self.fft_channelizer_s2v = blocks.stream_to_vector( gr.sizeof_gr_complex*1, fft_len) self.fft_channelizer_fft_fwd = fft.fft_vcc( fft_len, True, (window.blackmanharris(1024)), True, 1) self.fft_channelizer_v2s = blocks.vector_to_stream( gr.sizeof_gr_complex*1, fft_len) self.connect( self.fft_channelizer_s2v, self.fft_channelizer_fft_fwd, self.fft_channelizer_v2s) #per channel self.fft_channelizer_skiphead = [] self.fft_channelizer_keep_m_in_n = [] self.fft_channelizer_stream2vector = [] self.fft_channelizer_multiply_const = [] self.fft_channelizer_fft_rev = [] self.fft_channelizer_vector2stream = [] for from_bin, to_bin in channel_bins: #output samp rate: samp_rate / (fft_len/keep) keep = to_bin - from_bin fft_channelizer_taps = taps.taps(keep) self.fft_channelizer_skiphead.append( blocks.skiphead(gr.sizeof_gr_complex*1, from_bin)) self.fft_channelizer_keep_m_in_n.append( blocks.keep_m_in_n(gr.sizeof_gr_complex, keep, fft_len, 0)) self.fft_channelizer_stream2vector.append( blocks.stream_to_vector(gr.sizeof_gr_complex*1, keep)) self.fft_channelizer_multiply_const.append( blocks.multiply_const_vcc(fft_channelizer_taps)) self.fft_channelizer_fft_rev.append( fft.fft_vcc( keep, False, (window.blackmanharris(1024)), True, 1)) self.fft_channelizer_vector2stream.append( blocks.vector_to_stream( gr.sizeof_gr_complex*1, keep)) self.connect( self.fft_channelizer_v2s, self.fft_channelizer_skiphead[-1], self.fft_channelizer_keep_m_in_n[-1], self.fft_channelizer_stream2vector[-1], self.fft_channelizer_multiply_const[-1], self.fft_channelizer_fft_rev[-1], self.fft_channelizer_vector2stream[-1]) return self.fft_channelizer_s2v, self.fft_channelizer_vector2stream
def test_001_puncture_vbb(self): src_data = (0, 77, 78, 78, 1, 80, 2, 3, 4, 5, 81, 82, 83, 6, 84, 7, 8, 9) punc_seq = (1, 0, 0, 0, 1, 0, 1, 1, 1) exp_res = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) src = blocks.vector_source_b(src_data) s2v = blocks.stream_to_vector(gr.sizeof_char, 9) puncture_vbb = dab.puncture_vbb(punc_seq) v2s = blocks.vector_to_stream(gr.sizeof_char, 5) dst = blocks.vector_sink_b() self.tb.connect(src, s2v, puncture_vbb, v2s, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_res, result_data)
def test_002_t(self): vector01 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) expected_result = (1, 0, 0, 0, 5, 0, 0, 4, 9, 0, 3, 8, 13, 2, 7, 12) src = blocks.vector_source_b(vector01, True) s2v = blocks.stream_to_vector(gr.sizeof_char, 4) time_interleaver = dab.time_interleave_bb(4, [0, 3, 2, 1]) v2s = blocks.vector_to_stream(gr.sizeof_char, 4) dst = blocks.vector_sink_b() self.tb.connect(src, s2v, time_interleaver, blocks.head_make(gr.sizeof_char * 4, 4), v2s, dst) self.tb.run() result = dst.data() #print result self.assertEqual(expected_result, result)
def stest_004(self): dim = 2 src_data0 = (0, 2, -3, 0, 12, 0) src_data1 = (1, 1, 1, 1, 1, 1) expected_data = [] tmp = [float(max(x, y)) for x, y in zip(src_data0, src_data1)] for i in range(len(tmp) / dim): expected_data.append(float(max(tmp[i * dim:(i + 1) * dim]))) src0 = blocks.vector_source_f(src_data0) s2v0 = blocks.stream_to_vector(gr.sizeof_float, dim) src1 = blocks.vector_source_f(src_data1) s2v1 = blocks.stream_to_vector(gr.sizeof_float, dim) op = blocks.max_ff(dim) dst = blocks.vector_sink_f() self.tb.connect(src0, s2v0, (op, 0)) self.tb.connect(src1, s2v1, (op, 1)) self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def test_002_prune_vectors(self): src_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] expected_result = [3, 4, 8, 9, 13, 14] src = blocks.vector_source_b(src_data) s2v = blocks.stream_to_vector(gr.sizeof_char, 5) prune_vectors = dab.prune_vectors(gr.sizeof_char, 5, 2, 1) v2s = blocks.vector_to_stream(gr.sizeof_char, 2) dst = blocks.vector_sink_b() self.tb.connect(src, s2v, prune_vectors, v2s, dst) self.tb.run() result_data = dst.data() # print expected_result # print result_data self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_001_t (self): vsize = 2048 # setup for random distribution of samples with zero mean mu = 0. sigma = 0.01 nsigma = 3. vtest = vsize/8 vreal = np.random.normal( mu, sigma, vsize) vimg = np.random.normal( mu, sigma, vsize) vcomplex = (1j*vimg) + vreal # create a set of vectors src = blocks.vector_source_c( vcomplex.tolist(), False) snk1 = blocks.stream_to_vector(gr.sizeof_float, vsize) snk2 = blocks.stream_to_vector(gr.sizeof_float, vsize) # parameters we're setting bandwidth = 6.E6 setupFile = "Watch.not" eventblock = ra_event( vtest, nsigma, bandwidth, setupFile) self.tb.connect (src, eventblock) self.tb.connect (eventblock, snk1, 0) self.tb.connect (eventblock, snk2, 1) self.tb.run ()
def test_004_t(self): vector01 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) expected_result = (0,0,0,4,0,0,0,8,0,0,0,12,0,0,0,16,0,0,3,4,0,0,7,8,0,0,11,12,0,0,15,16) src = blocks.vector_source_b(vector01, True) b2f = blocks.char_to_float_make() s2v = blocks.stream_to_vector(gr.sizeof_float, 16) time_deinterleaver = dab.time_deinterleave_ff_make(16, [0, 1, 2, 4]) v2s = blocks.vector_to_stream(gr.sizeof_float, 16) dst = blocks.vector_sink_f() self.tb.connect(src, b2f, time_deinterleaver, blocks.head_make(gr.sizeof_float, 16*2), dst) self.tb.run() result = dst.data() #print result self.assertEqual(expected_result, result)
def test_002_t(self): vector01 = (1, 0, 0, 0, 5, 4, 0, 0, 9, 8, 3, 0, 13, 12, 7, 2) expected_result = (0, 0, 0, 0, 0, 4, 0, 0, 0, 8, 0, 0, 1, 12, 3, 0) src = blocks.vector_source_b(vector01, True) b2f = blocks.char_to_float_make() s2v = blocks.stream_to_vector(gr.sizeof_float, 4) time_deinterleaver = dab.time_deinterleave_ff_make(4, [0, 3, 2, 1]) v2s = blocks.vector_to_stream(gr.sizeof_float, 4) dst = blocks.vector_sink_f() self.tb.connect(src, b2f, time_deinterleaver, blocks.head_make(gr.sizeof_float, 4*4), dst) self.tb.run() result = dst.data() #print result self.assertEqual(expected_result, result)
def stest_s004(self): dim = 2 src_data0 = [0, 2, -3, 0, 12, 0] src_data1 = [1, 1, 1, 1, 1, 1] expected_data = [] tmp = [min(x, y) for x, y in zip(src_data0, src_data1)] for i in range(len(tmp) / dim): expected_data.append(min(tmp[i * dim:(i + 1) * dim])) src0 = blocks.vector_source_s(src_data0) s2v0 = blocks.stream_to_vector(gr.sizeof_short, dim) src1 = blocks.vector_source_s(src_data1) s2v1 = blocks.stream_to_vector(gr.sizeof_short, dim) op = blocks.min_ss(dim) dst = blocks.vector_sink_s() self.tb.connect(src0, s2v0, (op, 0)) self.tb.connect(src1, s2v1, (op, 1)) self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def test_001_complex_to_interleaved_float_vcf(self): src_data = (1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j) expected_result = (1, 3, 2, 4, 5, 7, 6, 8) src = blocks.vector_source_c(src_data) s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, 2) complex_to_interleaved_float_vcf = grdab.complex_to_interleaved_float_vcf( 2) v2s = blocks.vector_to_stream(gr.sizeof_float, 4) dst = blocks.vector_sink_f() self.tb.connect(src, s2v, complex_to_interleaved_float_vcf, v2s, dst) self.tb.run() result_data = dst.data() # print result_data self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def __init__(self, fft_size, samp_rate): gr.hier_block2.__init__( self, "spectrum_sense", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(1, 1, gr.sizeof_float * fft_size)) # Output signature self.fft_size = fft_size self.samp_rate = samp_rate ################################################## # Blocks ################################################## # stream to vector for fft s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) #self.one_in_n = gr.keep_one_in_n(gr.sizeof_float * self.fft_size, # max(1, int(self.sample_rate/self.fft_size/self.fft_rate))) # filter window mywindow = filter.window.blackmanharris(self.fft_size) # fft ffter = fft.fft_vcc(self.fft_size, True, mywindow, True) # complex to magnitude block c2mag = blocks.complex_to_mag_squared( self.fft_size) # use sqrt of this for power # average avg = filter.single_pole_iir_filter_ff(0.4, self.fft_size) multiply_const = blocks.multiply_const_vff( (np.ones(self.fft_size) * (1.0 / self.samp_rate))) nlog10 = blocks.nlog10_ff(10, self.fft_size, 0) # FIXME We need to add 3dB to all bins but the DC bin #self.log = gr.nlog10_ff(20, self.fft_size, # -20*math.log10(self.fft_size) # Adjust for number of bins # -10*math.log10(power/self.fft_size) # Adjust for windowing loss # -20*math.log10(ref_scale/2)) # Adjust for reference scale #v2s = blocks.vector_to_stream(gr.sizeof_float*1, self.fft_size) # connect blocks self.connect(self, s2v, ffter, c2mag, avg, multiply_const, nlog10, self)
def test_001_t(self): # set up fg src_data = (1, 2.1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20) expected_result = (8.5, 9.525, 10.5, 11.5, 12.5) src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, 5) stats = usrpcalibrator.bin_statistics_ff(5, 4) dst = blocks.vector_sink_f(5) self.tb.connect(src, s2v, stats, dst) self.tb.run() # check data result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_003_t(self): vector01 = (3, 0, 0, 0, 7, 0, 0, 0, 11, 4, 0, 0, 15, 8, 0, 0, 19, 12, 1, 0, 23, 16, 5, 0, 27, 20, 9, 2, 31, 24, 13, 6) expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 0, 0, 7, 8, 0, 0, 11, 12, 0, 0, 15, 16, 0, 0, 19,20, 0, 0, 23, 24, 0, 0) src = blocks.vector_source_b(vector01, True) b2f = blocks.char_to_float_make() s2v = blocks.stream_to_vector(gr.sizeof_float, 8) time_deinterleaver = dab.time_deinterleave_ff_make(8, [2, 3, 0, 1]) v2s = blocks.vector_to_stream(gr.sizeof_float, 8) dst = blocks.vector_sink_f() self.tb.connect(src, b2f, time_deinterleaver, blocks.head_make(gr.sizeof_float, 8*4), dst) self.tb.run() result = dst.data() #print result self.assertEqual(expected_result, result)
def test_002_t(self): # set up fg src_data = (0, 0, 1, 0, 0, 1.0, 1, 2, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1, 0, 0) src = blocks.vector_source_f(src_data) f2c = blocks.float_to_char() s2v = blocks.stream_to_vector(gr.sizeof_char, 5) f = open('/tmp/threshold_timestamp_test002.out', 'w') tts = msod_sensor.threshold_timestamp(5, gr.sizeof_char, 1, 1.5, f.fileno()) ns = blocks.null_sink(5 * gr.sizeof_float) self.tb.connect(src, f2c, s2v, tts, ns) self.tb.run() f.close()
def __init__(self, fname, epsilon, max_iterations): gr.top_block.__init__(self) self.src = blocks.vector_source_b(()) print "initializing encoder" self.encoder = ldpc.ldpc_encoder_bb(fname) print "encoder initialized" self.K = self.encoder.get_K() self.N = self.encoder.get_N() print self.K print self.N str2Kvec = blocks.stream_to_vector(1, self.K) chk2symb = digital.chunks_to_symbols_bf(([1, -1]), 1) str2Nvec = blocks.stream_to_vector(4, self.N) self.channel = ldpc.bsc_bb(self.N, epsilon) self.decoder = ldpc.ldpc_decoder_bb(fname, epsilon, max_iterations) print "decoder initialized" self.noise = analog.noise_source_f(analog.GR_GAUSSIAN, epsilon, 0) self.adder = blocks.add_vff(1) Kvec2str = blocks.vector_to_stream(1, self.K) Nvec2str = blocks.vector_to_stream(4, self.N) self.dst = blocks.vector_sink_b() self.connect(self.src, str2Kvec, self.encoder, self.channel, self.decoder, Kvec2str, self.dst)
def __init__(self, c_freq=1420000000, nbin=1000, nchan=1024, obs_time=60, samp_rate=2400000): gr.top_block.__init__(self, "Top Block") ################################################## # Parameters ################################################## self.c_freq = c_freq self.nbin = nbin self.nchan = nchan self.obs_time = obs_time self.samp_rate = samp_rate ################################################## # Variables ################################################## self.gain = gain = 10000 ################################################## # Blocks ################################################## self.fft_vxx_0 = fft.fft_vcc(nchan, True, (window.blackmanharris(nchan)), True, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan) self.blocks_integrate_xx_0 = blocks.integrate_ff(nbin, nchan) self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*1, int(obs_time*samp_rate)) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*nchan, '/home/pictor/Desktop/pictortelescope/observation.dat', True) self.blocks_file_sink_0.set_unbuffered(False) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(nchan) self.RTL820T = osmosdr.source( args="numchan=" + str(1) + " " + '' ) self.RTL820T.set_sample_rate(samp_rate) self.RTL820T.set_center_freq(c_freq, 0) self.RTL820T.set_freq_corr(0, 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(30, 0) self.RTL820T.set_if_gain(30, 0) self.RTL820T.set_bb_gain(30, 0) self.RTL820T.set_antenna('', 0) self.RTL820T.set_bandwidth(0, 0) ################################################## # Connections ################################################## self.connect((self.RTL820T, 0), (self.blocks_head_0, 0)) 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))