def test_001_t (self): src = ofdm.allocation_src(6,3,"tcp://*:3333") src.set_allocation([2]*6,[3]*6) #skiphead = blocks.skiphead( gr.sizeof_float, 8 ) limit_id = blocks.head( gr.sizeof_short, 4 ) limit_bitcount = blocks.head( gr.sizeof_int, 4 ) limit_bitloading = blocks.head( gr.sizeof_char*6, 4 ) limit_power = blocks.head( gr.sizeof_gr_complex*6, 4 ) dst_id = blocks.vector_sink_s() dst_bitcount = blocks.vector_sink_i() dst_bitloading = blocks.vector_sink_b(6) dst_power = blocks.vector_sink_c(6) self.tb.connect((src,0),limit_id,dst_id) self.tb.connect((src,1),limit_bitcount,dst_bitcount) self.tb.connect((src,2),limit_bitloading,dst_bitloading) self.tb.connect((src,3),limit_power,dst_power) # set up fg self.tb.run () # check data result_id = dst_id.data() result_bitcount = dst_bitcount.data() result_bitloading = dst_bitloading.data() result_power = dst_power.data() print "id", result_id print "bitcount", result_bitcount print "bitloading", result_bitloading print "power", result_power
def __init__(self): gr.top_block.__init__(self) usage = "%prog: [options] filename" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-r", "--sample-rate", type="eng_float", default=48000, help="set sample rate to RATE (48000)") parser.add_option("-N", "--samples", type="eng_float", default=None, help="number of samples to record") (options, args) = parser.parse_args () if len(args) != 1 or options.samples is None: parser.print_help() raise SystemExit, 1 sample_rate = int(options.sample_rate) ampl = 0.1 src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 350, ampl) src1 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 440, ampl) head0 = blocks.head(gr.sizeof_float, int(options.samples)) head1 = blocks.head(gr.sizeof_float, int(options.samples)) dst = blocks.wavfile_sink(args[0], 2, int(options.sample_rate), 16) self.connect(src0, head0, (dst, 0)) self.connect(src1, head1, (dst, 1))
def test_preamble (self): pream_len = 52 pream = (mapper.preamble_generator(pream_len,511,1033)).get_preamble() rand_src = blocks.vector_source_b(map(int, numpy.random.randint(0, 2, 1024)), True) head = blocks.head(gr.sizeof_char*1, 1024) src_sink = blocks.vector_sink_b(1) pream_inst = mapper.preamble_insert_bb(pream_len*10, (pream)) bit2symb = mapper.mapper(mapper.BPSK, ([0,1])) pream_sync = mapper.preamble_sync_cc(pream_len*10, (pream), mapper.BPSK, ([0,1]), .97, .90) symb2bit = mapper.demapper(mapper.BPSK, ([0,1])) rec_sink = blocks.vector_sink_b(1) self.tb.connect((rand_src, 0), (head, 0)) self.tb.connect((head, 0), (pream_inst, 0)) self.tb.connect((head, 0), (src_sink, 0)) self.tb.connect((pream_inst, 0), (bit2symb, 0)) self.tb.connect((bit2symb, 0), (pream_sync, 0)) self.tb.connect((pream_sync, 0), (symb2bit, 0)) self.tb.connect((symb2bit, 0), (rec_sink, 0)) self.tb.start() sleep(1) self.tb.stop() data_space = pream_len*9 sd = src_sink.data() rd = rec_sink.data() self.assertEqual(sd[0:data_space],rd[0:data_space])
def test_001_t (self): # set up fg test_len = 1000 packet_len = test_len pulse_send = (200,300,100) pulse_wait = (100,100) amplitude = 0.5 num_skip = 5 # skip samples with skiphead num_xcorr = 300 # num of xcorrs to determine delay samples src = radar.signal_generator_sync_pulse_c(packet_len,pulse_send,pulse_wait,amplitude,"packet_len") head = blocks.head(8,test_len) skiphead = blocks.skiphead(8,num_skip) est = radar.estimator_sync_pulse_c(num_xcorr,"packet_len") res = radar.print_results() debug = blocks.message_debug() self.tb.connect(src,skiphead,head) self.tb.connect((head,0),(est,0)) # TX stream (undelayed but skiped) self.tb.connect((src,0),(est,1)) # RX stream (delayed but unskiped) self.tb.msg_connect(est,'Msg out',res,'Msg in') self.tb.msg_connect(est,'Msg out',debug,'store') self.tb.run () # check data msg = debug.get_message(0) num_skip_est = pmt.to_long(pmt.nth(1,pmt.nth(1,msg))) self.assertEqual(num_skip_est,num_skip)
def test_001_t (self): # set up fg samp_cw = 300 samp_up = 200 samp_down = 100 mult = 3 test_len = (samp_cw+samp_up+samp_down)*mult samp_rate = 2000 len_key = "packet_len" packet_parts = (samp_cw, samp_up, samp_down) src = radar.signal_generator_fmcw_c(samp_rate, samp_up, samp_down, samp_cw, 500, 250, 1, len_key); head = blocks.head(8,test_len) split0 = radar.split_cc(0,packet_parts,len_key) split1 = radar.split_cc(1,packet_parts,len_key) split2 = radar.split_cc(2,packet_parts,len_key) snk0 = blocks.vector_sink_c() snk1 = blocks.vector_sink_c() snk2 = blocks.vector_sink_c() self.tb.connect(src,head) self.tb.connect(head,split0,snk0) self.tb.connect(head,split1,snk1) self.tb.connect(head,split2,snk2) self.tb.run () # check data self.assertEqual(len(snk0.data()),mult*samp_cw) # check correct number of samples in every sink self.assertEqual(len(snk1.data()),mult*samp_up) self.assertEqual(len(snk2.data()),mult*samp_down)
def __init__(self): gr.top_block.__init__(self) default_nsamples = 10e6 parser = ArgumentParser() parser.add_argument("-p", "--npipelines", type=intx, default=1, metavar="NPIPES", help="the number of pipelines to create (default=%(default)s)") parser.add_argument("-s", "--nstages", type=intx, default=1, metavar="NSTAGES", help="the number of stages in each pipeline (default=%(default)s)") parser.add_argument("-N", "--nsamples", type=eng_float, default=default_nsamples, help=("the number of samples to run through the graph (default=%s)" % (eng_notation.num_to_str(default_nsamples)))) parser.add_argument("-m", "--machine-readable", action="store_true", default=False, help="enable machine readable output") args = parser.parse_args() self.npipes = args.npipelines self.nstages = args.nstages self.nsamples = args.nsamples self.machine_readable = args.machine_readable ntaps = 256 # Something vaguely like floating point ops self.flop = 2 * ntaps * args.npipelines * args.nstages * args.nsamples src = blocks.null_source(gr.sizeof_float) head = blocks.head(gr.sizeof_float, int(args.nsamples)) self.connect(src, head) for n in range(args.npipelines): self.connect(head, pipeline(args.nstages, ntaps))
def __init__(self, item_size, num_outputs, default_output): """ Selector constructor. Args: item_size: the size of the gr data stream in bytes num_inputs: the number of inputs (integer) num_outputs: the number of outputs (integer) input_index: the index for the source data output_index: the index for the destination data """ gr.hier_block2.__init__( self, 'selector', gr.io_signature(1, 1, item_size), gr.io_signature(num_outputs, num_outputs, item_size), ) num_inputs = 1 # Terminator blocks for unused inputs and outputs self.input_terminators = [blocks.null_sink(item_size) for i in range(num_inputs)] self.output_terminators = [blocks.head(item_size, 0) for i in range(num_outputs)] self.copy = blocks.copy(item_size) # Connections for i in range(num_inputs): self.connect((self, i), self.input_terminators[i]) for i in range(num_outputs): self.connect(blocks.null_source(item_size), self.output_terminators[i], (self, i)) # Set parameters self.num_outputs = num_outputs self.input_index = 0 self.output_index = default_output # Register the message port self.message_port_register_hier_in("selection") self.mb = message_receiver(self); # Connect message port self.msg_connect(self, "selection", self.mb,"selection") # Connect default self._connect_current()
def test_begin_tag_repeat(self): src_data = range(1000) expected_result = range(1000) expected_result.extend(range(1000)) snk2 = blocks.vector_sink_f() with tempfile.NamedTemporaryFile() as temp: src = blocks.vector_source_f(src_data) snk = blocks.file_sink(gr.sizeof_float, temp.name) snk.set_unbuffered(True) src2 = blocks.file_source(gr.sizeof_float, temp.name, True) src2.set_begin_tag(pmt.string_to_symbol("file_begin")) hd = blocks.head(gr.sizeof_float, 2000) self.tb.connect(src, snk) self.tb.run() self.tb.disconnect(src, snk) self.tb.connect(src2, hd, snk2) self.tb.run() result_data = snk2.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data) tags = snk2.tags() self.assertEqual(len(tags), 2) self.assertEqual(str(tags[0].key), "file_begin") self.assertEqual(str(tags[0].value), "0") self.assertEqual(tags[0].offset, 0) self.assertEqual(str(tags[1].key), "file_begin") self.assertEqual(str(tags[1].value), "1") self.assertEqual(tags[1].offset, 1000)
def __init__(self): gr.top_block.__init__(self) usage="%prog: [options] output_filename" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-I", "--audio-input", type="string", default="", help="pcm input device name. E.g., hw:0,0 or /dev/dsp") parser.add_option("-r", "--sample-rate", type="eng_float", default=48000, help="set sample rate to RATE (48000)") parser.add_option("-N", "--nsamples", type="eng_float", default=None, help="number of samples to collect [default=+inf]") (options, args) = parser.parse_args () if len(args) != 1: parser.print_help() raise( SystemExit, 1 ) filename = args[0] sample_rate = int(options.sample_rate) src = audio.source (sample_rate, options.audio_input) dst = blocks.wavfile_sink (filename, 1, sample_rate) if options.nsamples is None: self.connect((src, 0), dst) else: head = blocks.head(gr.sizeof_float, int(options.nsamples)) self.connect((src, 0), head, dst)
def __init__(self, item_size, num_inputs, num_outputs, input_index, output_index): """ Selector constructor. Args: item_size: the size of the gr data stream in bytes num_inputs: the number of inputs (integer) num_outputs: the number of outputs (integer) input_index: the index for the source data output_index: the index for the destination data """ gr.hier_block2.__init__( self, 'selector', gr.io_signature(num_inputs, num_inputs, item_size), gr.io_signature(num_outputs, num_outputs, item_size), ) #terminator blocks for unused inputs and outputs self.input_terminators = [blocks.null_sink(item_size) for i in range(num_inputs)] self.output_terminators = [blocks.head(item_size, 0) for i in range(num_outputs)] self.copy = blocks.copy(item_size) #connections for i in range(num_inputs): self.connect((self, i), self.input_terminators[i]) for i in range(num_outputs): self.connect(blocks.null_source(item_size), self.output_terminators[i], (self, i)) self.item_size = item_size self.input_index = input_index self.output_index = output_index self.num_inputs = num_inputs self.num_outputs = num_outputs self._connect_current()
def test_001_t (self): self.degree = 5 self.length = 2**self.degree - 1 expected_result = (self.length - 1)*[-1.0/self.length]+[1] # send a maximum length sequence with period 31 src_real = digital.glfsr_source_f(self.degree, True, 0, 1) src_imag = blocks.null_source(gr.sizeof_float*1) f2c = blocks.float_to_complex(1) mls_correlator = channelsounder_swig.mls_correlator(self.degree, mask = 0, seed = 1) # keep only the samples of the first two autocorrelation periods head = blocks.head(gr.sizeof_gr_complex, 2*self.length) dest = blocks.vector_sink_c(1) self.tb.connect( src_real, (f2c, 0)) self.tb.connect( src_imag, (f2c, 1)) self.tb.connect( f2c, mls_correlator ) self.tb.connect( mls_correlator, head, dest ) # set up fg self.tb.run () # check data result_data = dest.data() # discard the first period, since it is tainted by the zeros inserted # by set_history() result_data = result_data[self.length:] self.assertFloatTuplesAlmostEqual (expected_result, result_data, 6)
def __init__(self, N, fs, bw0, bw1, tw, atten, D): gr.top_block.__init__(self) self._nsamps = N self._fs = fs self._bw0 = bw0 self._bw1 = bw1 self._tw = tw self._at = atten self._decim = D taps = filter.firdes.complex_band_pass_2(1, self._fs, self._bw0, self._bw1, self._tw, self._at) print "Num. Taps: ", len(taps) self.src = analog.noise_source_c(analog.GR_GAUSSIAN, 1) self.head = blocks.head(gr.sizeof_gr_complex, self._nsamps) self.filt0 = filter.fft_filter_ccc(self._decim, taps) self.vsnk_src = blocks.vector_sink_c() self.vsnk_out = blocks.vector_sink_c() self.connect(self.src, self.head, self.vsnk_src) self.connect(self.head, self.filt0, self.vsnk_out)
def test_003_t (self): # test cut frequency negative freq # set up fg test_len = 1000 samp_rate = 2000 freq1 = -200 freq2 = -205 ampl = 1 packet_len = test_len threshold = -100 samp_protect = 2 src1 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq1, ampl*0.2) src2 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq2, ampl) add = blocks.add_cc(); head = blocks.head(8,test_len) s2ts = blocks.stream_to_tagged_stream(8,1,packet_len,"packet_len") fft = radar.ts_fft_cc(packet_len) peak = radar.find_max_peak_c(samp_rate, threshold, samp_protect, (-200,200), True) debug = blocks.message_debug() self.tb.connect((src1,0), (add,0)) self.tb.connect((src2,0), (add,1)) self.tb.connect(add,head,s2ts,fft,peak) self.tb.msg_connect(peak,"Msg out",debug,"store") #self.tb.msg_connect(peak,"Msg out",debug,"print") self.tb.start() sleep(0.5) self.tb.stop() self.tb.wait() # check frequency in os_cfar message with given one msg = debug.get_message(0) self.assertAlmostEqual(freq1,pmt.f32vector_ref(pmt.nth(1,pmt.nth(1,msg)),0),8)
def test_004_es_source_pdus(self): print "test_004_es_source_pdus" msg = pmt.cons( pmt.to_pmt( {"somekey":"val2", "somekey2":"someval2" } ), pmt.to_pmt( numpy.array( [0,1,2,3,4,5,6,7,8,9] , dtype=numpy.float32) ) ); src = es.source([gr.sizeof_float], 8, 2); stb = blocks.message_strobe( msg, 100.0 ); tb = gr.top_block(); tb.msg_connect(stb, "strobe", src, "schedule_event"); th = blocks.throttle(gr.sizeof_float, 1000*100); hd = blocks.head(gr.sizeof_float, 1000*100); snk = blocks.vector_sink_f(); tb.connect(src,th,hd,snk); # TODO: this can not use run because it is # subject to GNU Radio's shutdown msg block bug # for remaining upstream msg blocks ... #tb.run(); # workaround tb.start(); time.sleep(1); tb.stop(); tb.wait(); self.assertEqual( sum(snk.data())>0, True );
def __init__(self): gr.top_block.__init__(self) self.qapp = QtGui.QApplication(sys.argv) data0 = 10*[0,] + 40*[1,0] + 10*[0,] data0 += 10*[0,] + 40*[0,1] + 10*[0,] data1 = 20*[0,] + [0,0,0,1,1,1,0,0,0,0] + 70*[0,] # Adjust these to change the layout of the plot. # Can be set to fractions. ncols = 100.25 nrows = 100 fs = 200 src0 = blocks.vector_source_f(data0, True) src1 = blocks.vector_source_f(data1, True) thr = blocks.throttle(gr.sizeof_float, 50000) hed = blocks.head(gr.sizeof_float, 10000000) self.snk1 = qtgui.time_raster_sink_f(fs, nrows, ncols, [], [], "Float Time Raster Example", 2) self.connect(src0, thr, (self.snk1, 0)) self.connect(src1, (self.snk1, 1)) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) self.main_box = dialog_box(pyWin) self.main_box.show()
def run_fir_filters_fff(self): self.blocks = [] self.tb = gr.top_block() self.blocks.append(blocks.null_source(gr.sizeof_float)) self.blocks.append(blocks.head(gr.sizeof_float, self.N)) # First filter is much larger than others taps = numpy.random.random(self.mult*self.ntaps) self.blocks.append(filter.fir_filter_fff(1, taps)) self.blocks[0].set_processor_affinity([0,]) # Set up rest of mfirs filters with new taps for each filter for m in xrange(1, self.mfirs): taps = numpy.random.random(self.ntaps) self.blocks.append(filter.fir_filter_fff(1, taps)) #self.blocks[m].set_processor_affinity([1,]) #self.blocks[m].set_processor_affinity([1,]) #self.blocks[m].set_processor_affinity([1,]) #self.blocks[m].set_processor_affinity([1,]) #self.blocks[m].set_processor_affinity([1,]) #self.blocks[m].set_processor_affinity([1,]) #self.blocks[m].set_processor_affinity([1,]) # Add a null sink self.blocks.append(blocks.null_sink(gr.sizeof_float)) # Connect the blocks and run self.tb.connect(*self.blocks) self.tb.run()
def run_test (f,Kb,bitspersymbol,K,dimensionality,tot_constellation,N0,seed): tb = gr.top_block () # TX src = blocks.lfsr_32k_source_s() src_head = blocks.head (gr.sizeof_short,Kb/16) # packet size in shorts s2fsmi = blocks.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality enc = trellis.encoder_ss(f,0) # initial state = 0 # essentially here we implement the combination of modulation and channel as a memoryless modulation (the memory induced by the channel is hidden in the FSM) mod = digital.chunks_to_symbols_sf(tot_constellation,dimensionality) # CHANNEL add = blocks.add_ff() noise = analog.noise_source_f(analog.GR_GAUSSIAN,math.sqrt(N0/2),seed) # RX metrics = trellis.metrics_f(f.O(),dimensionality,tot_constellation,digital.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set. fsmi2s = blocks.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts dst = blocks.check_lfsr_32k_s(); tb.connect (src,src_head,s2fsmi,enc,mod) tb.connect (mod,(add,0)) tb.connect (noise,(add,1)) tb.connect (add,metrics) tb.connect (metrics,va,fsmi2s,dst) tb.run() ntotal = dst.ntotal () nright = dst.nright () runlength = dst.runlength () #print ntotal,nright,runlength return (ntotal,ntotal-nright)
def __init__(self): gr.top_block.__init__(self, "Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.digital_crc32_bb_0 = digital.crc32_bb(False, "packet_len") self.blocks_tag_debug_1 = blocks.tag_debug(gr.sizeof_char*1, "Pre-CRC", ""); self.blocks_tag_debug_1.set_display(True) self.blocks_tag_debug_0 = blocks.tag_debug(gr.sizeof_char*1, "Post-CRC", ""); self.blocks_tag_debug_0.set_display(True) self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, 100, "packet_len") self.blocks_head_0 = blocks.head(gr.sizeof_char*1, 100*5) self.analog_random_source_x_0 = blocks.vector_source_b(map(int, numpy.random.randint(0, 255, 1000)), True) ################################################## # Connections ################################################## self.connect((self.analog_random_source_x_0, 0), (self.blocks_head_0, 0)) self.connect((self.blocks_head_0, 0), (self.blocks_stream_to_tagged_stream_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.digital_crc32_bb_0, 0)) self.connect((self.digital_crc32_bb_0, 0), (self.blocks_tag_debug_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.blocks_tag_debug_1, 0))
def run_test (fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,constellation,Es,N0,IT,seed): tb = gr.top_block () # TX src = blocks.lfsr_32k_source_s() src_head = blocks.head(gr.sizeof_short,Kb/16) # packet size in shorts s2fsmi = blocks.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the outer FSM input cardinality enc = trellis.sccc_encoder_ss(fo,0,fi,0,interleaver,K) mod = digital.chunks_to_symbols_sf(constellation,dimensionality) # CHANNEL add = blocks.add_ff() noise = analog.noise_source_f(analog.GR_GAUSSIAN,math.sqrt(N0/2),seed) # RX dec = trellis.sccc_decoder_combined_fs(fo,0,-1,fi,0,-1,interleaver,K,IT,trellis.TRELLIS_MIN_SUM,dimensionality,constellation,digital.TRELLIS_EUCLIDEAN,1.0) fsmi2s = blocks.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts dst = blocks.check_lfsr_32k_s() #tb.connect (src,src_head,s2fsmi,enc_out,inter,enc_in,mod) tb.connect (src,src_head,s2fsmi,enc,mod) tb.connect (mod,(add,0)) tb.connect (noise,(add,1)) #tb.connect (add,head) #tb.connect (tail,fsmi2s,dst) tb.connect (add,dec,fsmi2s,dst) tb.run() #print enc_out.ST(), enc_in.ST() ntotal = dst.ntotal () nright = dst.nright () runlength = dst.runlength () return (ntotal,ntotal-nright)
def test_001_t (self): # test on positive frequencies # set up fg test_len = 1000 samp_rate = 2000 freq = 200 ampl = 1 packet_len = test_len threshold = -100 samp_protect = 2 src = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq, ampl) head = blocks.head(8,test_len) s2ts = blocks.stream_to_tagged_stream(8,1,packet_len,"packet_len") fft = radar.ts_fft_cc(packet_len) peak = radar.find_max_peak_c(samp_rate, threshold, samp_protect, (0,0), False) debug = blocks.message_debug() self.tb.connect(src,head,s2ts,fft,peak) self.tb.msg_connect(peak,"Msg out",debug,"store") #self.tb.msg_connect(peak,"Msg out",debug,"print") self.tb.start() sleep(0.5) self.tb.stop() self.tb.wait() # check frequency in os_cfar message with given one msg = debug.get_message(0) self.assertAlmostEqual(freq,pmt.f32vector_ref(pmt.nth(1,pmt.nth(1,msg)),0),8)
def test_001_t (self): # set up fg test_len = 1000 packet_len = 1024 samp_rate = 32000 frequency = (500, 500) amplitude = 1 test = radar.signal_generator_cw_c(packet_len, samp_rate, frequency, amplitude) head = blocks.head(8,test_len) sink = blocks.vector_sink_c() self.tb.connect(test,head,sink) self.tb.run () # create reference data ref_data = [0]*test_len phase = 0 for i in range(test_len): ref_data[i] = amplitude*np.exp(1j*phase) phase = phase + 2*np.pi*frequency[0]/samp_rate #phase = np.modf(phase,2*np.pi) ref_data = [0]*test_len phase = 0 for i in range(test_len): ref_data[i] = amplitude*np.exp(1j*phase) phase = phase+2*np.pi*frequency[0]/samp_rate # check data out_data = sink.data() self.assertEqual(len(out_data),test_len) # check out_data length self.assertComplexTuplesAlmostEqual(out_data,ref_data,2) # check out_data with ref_data
def __init__(self, fs_in, fs_out, fc, N=10000): gr.top_block.__init__(self) rerate = float(fs_out) / float(fs_in) print "Resampling from %f to %f by %f " %(fs_in, fs_out, rerate) # Creating our own taps taps = filter.firdes.low_pass_2(32, 32, 0.25, 0.1, 80) self.src = analog.sig_source_c(fs_in, analog.GR_SIN_WAVE, fc, 1) #self.src = analog.noise_source_c(analog.GR_GAUSSIAN, 1) self.head = blocks.head(gr.sizeof_gr_complex, N) # A resampler with our taps self.resamp_0 = filter.pfb.arb_resampler_ccf(rerate, taps, flt_size=32) # A resampler that just needs a resampling rate. # Filter is created for us and designed to cover # entire bandwidth of the input signal. # An optional atten=XX rate can be used here to # specify the out-of-band rejection (default=80). self.resamp_1 = filter.pfb.arb_resampler_ccf(rerate) self.snk_in = blocks.vector_sink_c() self.snk_0 = blocks.vector_sink_c() self.snk_1 = blocks.vector_sink_c() self.connect(self.src, self.head, self.snk_in) self.connect(self.head, self.resamp_0, self.snk_0) self.connect(self.head, self.resamp_1, self.snk_1)
def __init__(self): gr.top_block.__init__(self, "USRP_TCP") ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="sc16", otw_format="sc16", channels=range(1), ), ) self.uhd_usrp_source_0.set_time_source("gpsdo", 0) self.uhd_usrp_source_0.set_samp_rate(4e6) self.uhd_usrp_source_0.set_center_freq(1575.42e6, 0) self.uhd_usrp_source_0.set_gain(30, 0) self.uhd_usrp_source_0.set_antenna("RX2", 0) (self.uhd_usrp_source_0).set_min_output_buffer(100) (self.uhd_usrp_source_0).set_max_output_buffer(200) self.blocks_head_0 = blocks.head(gr.sizeof_short*2, 1024) self.ASPIN_Async_TCP_Client_0 = ASPIN.Async_TCP_Client("192.168.10.10", 25565, 1472, 1000000) ################################################## # Connections ################################################## self.connect((self.blocks_head_0, 0), (self.ASPIN_Async_TCP_Client_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.blocks_head_0, 0))
def setUp (self): self.tb = gr.top_block () self.tp = drm.transm_params(1, 3, False, 0, False, 1, 0, 1, 1, 0, False, 24000, "station label", "text message") self.src = drm.generate_sdc_b(self.tp) self.head = blocks.head(self.tp.sdc().L(), 1) self.snk = blocks.vector_sink_b(self.tp.sdc().L()) self.tb.connect(self.src, self.head, self.snk)
def test_002_t (self): # set up fg test_len = 2**15 samp_rate = 250000 freq = -2000 ampl = 1 packet_len = test_len min_output_buffer = 2*packet_len compare_sample = 5 protect_sample = 0 rel_threshold = 0.78 mult_threshold = 10 src = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq, ampl) src.set_min_output_buffer(min_output_buffer) head = blocks.head(8,test_len) head.set_min_output_buffer(min_output_buffer) s2ts = blocks.stream_to_tagged_stream(8,1,packet_len,"packet_len") s2ts.set_min_output_buffer(min_output_buffer) fft = radar.ts_fft_cc(packet_len) fft.set_min_output_buffer(min_output_buffer) cfar = radar.os_cfar_c(samp_rate, compare_sample, protect_sample, rel_threshold, mult_threshold) debug = blocks.message_debug() self.tb.connect(src,head,s2ts,fft,cfar) self.tb.msg_connect(cfar,"Msg out",debug,"store") self.tb.msg_connect(cfar,"Msg out",debug,"print") self.tb.start() sleep(0.5) self.tb.stop() self.tb.wait() # check frequency in os_cfar message with given one msg = debug.get_message(0) self.assertAlmostEqual(freq/pmt.f32vector_ref(pmt.nth(1,pmt.nth(1,msg)),0),1,2)
def test_001_t (self): # Setup parameters of the System fsm = fsm_args["awgn1o2_16"] os = numpy.array(fsm[4], dtype=int) data = numpy.array([-5,-5,-5,-5,5,5,-5,5,5,-5]) expected_data = numpy.array([0,0,0,0,1,1,0,1,1,0]) print data data_src = blocks.vector_source_f(map(float, data)) # Set up TX src_head = blocks.head(gr.sizeof_float*1, 10) shuffle = numpy.array([0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,], dtype=int) # Setup RX max_log_map_cel = celec.max_log_map_f(2, 4, 10, 0, -1, shuffle, os) conv = blocks.float_to_char() rx_sink = blocks.vector_sink_f(1) self.tb.connect(data_src, src_head, max_log_map_cel, rx_sink) # set up fg self.tb.run () print rx_sink.data()
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 test_002_t (self): # set up fg # purpse is testing fft on high sample rates test_len = 2**19 packet_len = 2**17 min_output_buffer = packet_len*2 samp_rate = 10000000 frequency = 200000 amplitude = 1 src = radar.signal_generator_cw_c(packet_len,samp_rate,(frequency,frequency),amplitude) src.set_min_output_buffer(min_output_buffer) head = blocks.head(8,test_len) head.set_min_output_buffer(min_output_buffer) fft1 = radar.ts_fft_cc(packet_len) fft1.set_min_output_buffer(min_output_buffer) fft2 = radar.ts_fft_cc(packet_len) fft2.set_min_output_buffer(min_output_buffer) snk1 = blocks.vector_sink_c() snk2 = blocks.vector_sink_c() self.tb.connect(src,head,fft1,snk1) self.tb.connect(head,fft2,snk2) self.tb.run () # check both ffts self.assertComplexTuplesAlmostEqual(snk1.data(),snk2.data(),2) # compare both ffts
def test_003 (self): # Test that block stops when interacting with streaming interface port = str(random.Random().randint(0, 30000) + 10000) srcdata = (0x73, 0x75, 0x63, 0x68, 0x74, 0x65, 0x73, 0x74, 0x76, 0x65, 0x72, 0x79, 0x70, 0x61, 0x73, 0x73) tag_dict = {"offset": 0} tag_dict["key"] = pmt.intern("len") tag_dict["value"] = pmt.from_long(8) tag1 = gr.python_to_tag(tag_dict) tag_dict["offset"] = 8 tag2 = gr.python_to_tag(tag_dict) tags = [tag1, tag2] src = blocks.vector_source_b(srcdata, False, 1, tags) ts_to_pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "len") pdu_send = blocks.socket_pdu("UDP_CLIENT", "localhost", "4141") #pdu_recv = blocks.socket_pdu("UDP_SERVER", "localhost", port) pdu_to_ts = blocks.pdu_to_tagged_stream(blocks.byte_t, "len") head = blocks.head(gr.sizeof_char, 10) sink = blocks.vector_sink_b(1) self.tb.connect(src, ts_to_pdu) self.tb.msg_connect(ts_to_pdu, "pdus", pdu_send, "pdus") # a UDP socket connects pdu_send to pdu_recv # TODO: test that the recv socket can be destroyed from downstream # that signals DONE. Also that we get the PDUs we sent #self.tb.msg_connect(pdu_recv, "pdus", pdu_to_ts, "pdus") #self.tb.connect(pdu_to_ts, head, sink) self.tb.run()
def test_003_es_sink (self): print "test_003_es_sink" iv = [0,1,2,3,4,5,6,7,8,9]; src = blocks.vector_source_f(iv, repeat=True); hd = blocks.head(gr.sizeof_float, 10000); snk = es.sink([gr.sizeof_float], 8); t = es.trigger_sample_timer(gr.sizeof_float, 10, 5, 10, 10); tb = gr.top_block(); pduh = es.es_make_handler_pdu(es.es_handler_print.TYPE_F32); msgdb = blocks.message_debug() tb.connect(src, hd, t, snk); tb.msg_connect( t, "which_stream", snk, "schedule_event" ) tb.msg_connect( t, "sample_timer_event", pduh, "handle_event" ) tb.msg_connect( pduh, "pdus_out", msgdb, "store" ) tb.run(); # expected output of each event in the periodic sequence sv = numpy.array( iv[5:] + iv[:5], dtype=numpy.float32 ); # verify each received message nm = msgdb.num_messages(); print "nm = %d"%(nm); for i in range(0, nm): m = msgdb.get_message(i); mp = pmt.to_python(pmt.cdr(m)); print mp; self.assertEqual( sv.all(), mp.all() );
def test_sqr_f(self): tb = self.tb expected_result = (0, 0, 0, 0, 1, 1, 1, 1, 0) src1 = analog.sig_source_f(8, analog.GR_SQR_WAVE, 1.0, 1.0) op = blocks.head(gr.sizeof_float, 9) dst1 = blocks.vector_sink_f() tb.connect(src1, op) tb.connect(op, dst1) tb.run() dst_data = dst1.data() self.assertEqual(expected_result, dst_data)
def __init__(self, options, rec_len=3, sample_rate=2e6, carrier_frequency=939e6, ppm=0, args=""): gr.top_block.__init__(self, "Wideband Scanner") self.rec_len = rec_len self.sample_rate = sample_rate self.carrier_frequency = carrier_frequency self.ppm = ppm # if no file name is given process data from rtl_sdr source print "Args=", args self.rtlsdr_source = osmosdr.source(args="numchan=" + str(1) + " " + args) self.rtlsdr_source.set_sample_rate(sample_rate) # capture half of GSM channel lower than channel center (-0.1MHz) # this is needed when even number of channels is captured in order to process full captured bandwidth self.rtlsdr_source.set_center_freq(carrier_frequency - 0.1e6, 0) # correction of central frequency # if the receiver has large frequency offset # the value of this variable should be set close to that offset in ppm self.rtlsdr_source.set_freq_corr(options.ppm, 0) self.rtlsdr_source.set_dc_offset_mode(2, 0) self.rtlsdr_source.set_iq_balance_mode(0, 0) self.rtlsdr_source.set_gain_mode(True, 0) self.rtlsdr_source.set_bandwidth(sample_rate, 0) self.head = blocks.head(gr.sizeof_gr_complex * 1, int(rec_len * sample_rate)) # shift again by -0.1MHz in order to align channel center in 0Hz self.blocks_rotator_cc = blocks.rotator_cc(-2 * pi * 0.1e6 / options.samp_rate) self.wideband_receiver = wideband_receiver(OSR=4, fc=carrier_frequency, samp_rate=sample_rate) self.gsm_extract_system_info = grgsm.extract_system_info() self.connect((self.rtlsdr_source, 0), (self.head, 0)) self.connect((self.head, 0), (self.blocks_rotator_cc, 0)) self.connect((self.blocks_rotator_cc, 0), (self.wideband_receiver, 0)) self.msg_connect(self.wideband_receiver, 'msgs', self.gsm_extract_system_info, 'msgs')
def test_tri_f(self): tb = self.tb expected_result = (1, .75, .5, .25, 0, .25, .5, .75, 1) src1 = analog.sig_source_f(8, analog.GR_TRI_WAVE, 1.0, 1.0) op = blocks.head(gr.sizeof_float, 9) dst1 = blocks.vector_sink_f() tb.connect(src1, op) tb.connect(op, dst1) tb.run() dst_data = dst1.data() self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 5)
def __init__(self, dtype="discrete", limit=10000, randomize=False): if (dtype == "discrete"): gr.hier_block2.__init__(self, "source_alphabet", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_char)) self.src = blocks.file_source( gr.sizeof_char, "source_material/gutenberg_shakespeare.txt") self.convert = blocks.packed_to_unpacked_bb(1, gr.GR_LSB_FIRST) #self.convert = blocks.packed_to_unpacked_bb(8, gr.GR_LSB_FIRST); self.limit = blocks.head(gr.sizeof_char, limit) self.connect(self.src, self.convert) last = self.convert # whiten our sequence with a random block scrambler (optionally) if randomize: rand_len = 256 rand_bits = np.random.randint(2, size=rand_len) self.randsrc = blocks.vector_source_b(rand_bits, True) self.xor = blocks.xor_bb() self.connect(self.randsrc, (self.xor, 1)) self.connect(last, self.xor) last = self.xor else: # "type_continuous" gr.hier_block2.__init__(self, "source_alphabet", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_float)) self.src = mediatools.audiosource_s( ["source_material/serial-s01-e01.mp3"]) self.convert2 = blocks.interleaved_short_to_complex() self.convert3 = blocks.multiply_const_cc(1.0 / 65535) self.convert = blocks.complex_to_float() self.limit = blocks.head(gr.sizeof_float, limit) self.connect(self.src, self.convert2, self.convert3, self.convert) last = self.convert # connect head or not, and connect to output if limit == None: self.connect(last, self) else: self.connect(last, self.limit, self)
def test_qpsk_3tap_lms_training(self): # set up fg gain = 0.01 # LMS gain num_taps = 16 num_samp = 2000 num_test = 500 cons = digital.constellation_qpsk().base() rxmod = digital.generic_mod(cons, False, self.sps, True, self.eb, False, False) modulated_sync_word_pre = digital.modulate_vector_bc( rxmod.to_basic_block(), self.preamble + self.preamble, [1]) modulated_sync_word = modulated_sync_word_pre[86:( 512 + 86)] # compensate for the RRC filter delay corr_max = numpy.abs( numpy.dot(modulated_sync_word, numpy.conj(modulated_sync_word))) corr_calc = self.corr_thresh / (corr_max * corr_max) preamble_symbols = self.map_symbols_to_constellation( self.unpack_values(self.preamble, 8, 2), cons) alg = digital.adaptive_algorithm_lms(cons, gain).base() evm = digital.meas_evm_cc(cons, digital.evm_measurement_t.EVM_PERCENT) leq = digital.linear_equalizer(num_taps, self.sps, alg, False, preamble_symbols, 'corr_est') correst = digital.corr_est_cc(modulated_sync_word, self.sps, 12, corr_calc, digital.THRESHOLD_ABSOLUTE) constmod = digital.generic_mod(constellation=cons, differential=False, samples_per_symbol=4, pre_diff_code=True, excess_bw=0.35, verbose=False, log=False) chan = channels.channel_model(noise_voltage=0.0, frequency_offset=0.0, epsilon=1.0, taps=(1.0 + 1.0j, 0.63 - .22j, -.1 + .07j), noise_seed=0, block_tags=False) vso = blocks.vector_source_b(self.preamble + self.data, True, 1, []) head = blocks.head(gr.sizeof_float * 1, num_samp) vsi = blocks.vector_sink_f() self.tb.connect(vso, constmod, chan, correst, leq, evm, head, vsi) self.tb.run() # look at the last 1000 samples, should converge quickly, below 5% EVM upper_bound = list(20.0 * numpy.ones((num_test, ))) lower_bound = list(0.0 * numpy.zeros((num_test, ))) output_data = vsi.data() output_data = output_data[-num_test:] self.assertLess(output_data, upper_bound) self.assertGreater(output_data, lower_bound)
def run_fastnoise_source_i(self): ntype = analog.GR_GAUSSIAN ampl = 10 seed = 0 self.blocks = [] self.tb = gr.top_block() self.blocks.append(analog.fastnoise_source_i(ntype, ampl, seed)) self.blocks.append(blocks.head(gr.sizeof_int, self.N)) self.blocks.append(blocks.null_sink(gr.sizeof_int)) self.tb.connect(*self.blocks) self.tb.run()
def run_noise_source_c(self): ntype = analog.GR_GAUSSIAN ampl = 10 seed = 0 self.blocks = [] self.tb = gr.top_block() self.blocks.append(analog.noise_source_c(ntype, ampl, seed)) self.blocks.append(blocks.head(gr.sizeof_gr_complex, self.N)) self.blocks.append(blocks.null_sink(gr.sizeof_gr_complex)) self.tb.connect(*self.blocks) self.tb.run()
def run_sig_source_s(self): fs = 1 ntype = analog.GR_SIN_WAVE freq = 10 ampl = 1 self.tb = gr.top_block() self.op = analog.sig_source_s(fs, ntype, freq, ampl) self.head = blocks.head(gr.sizeof_short, self.N) self.snk = blocks.null_sink(gr.sizeof_short) self.tb.connect(self.op, self.head, self.snk) self.tb.run()
def test_packet_insert (self): # set up test limits # only collect 20 samples sample_lim = 20 samp_rate = 1e6 block_start_s = 100 block_start_ps = 5* int(1e12/samp_rate) # set up input packet struct num_samps = 5 packet_start_time = (100, 10* int(1e12/samp_rate)) iq_pkt_dict = { "meta":{ "timestamp_s":packet_start_time, "packet_len":num_samps }, "data":list(np.array(range(num_samps), dtype=np.complex)) } iq_pkt = dict_to_iq_packet(iq_pkt_dict) # set up our expected output expected = np.concatenate( (np.array( [0,]*5, dtype=np.complex ), np.array(range(num_samps), dtype=np.complex), np.array( [0,]*10, dtype=np.complex)) ) # set up flowgraph blocks op = envsim.envsim_source(samp_rate) head = blocks.head(gr.sizeof_gr_complex*1, sample_lim) dst = blocks.vector_sink_c() # make connections self.tb.connect(op,head,dst) # set source block's time op.set_start_time(block_start_s, block_start_ps) # publish our pmt message before the flowgraph starts to # avoid a race condition op.to_basic_block()._post(pmt.intern("packets"), iq_pkt) self.tb.run () # check data result = dst.data() self.assertListEqual(list(expected), list(result))
def test_001_correlate(self): degree = 10 length = 2**degree-1 src = digital.glfsr_source_f(degree) head = blocks.head(gr.sizeof_float, length*length) f2c = blocks.float_to_complex() corr = digital.pn_correlator_cc(degree) dst = blocks.vector_sink_c() self.tb.connect(src, head, f2c, corr, dst) self.tb.run() data = dst.data() self.assertEqual(data[-1], (1.0+0j))
def test_saw_c(self): tb = self.tb expected_result = (.5+.25j, .625+.375j, .75+.5j, .875+.625j, 0+.75j, .125+.875j, .25+1j, .375+.125j, .5+.25j) src1 = analog.sig_source_c(8, analog.GR_SAW_WAVE, 1.0, 1.0) op = blocks.head(gr.sizeof_gr_complex, 9) dst1 = blocks.vector_sink_c() tb.connect(src1, op) tb.connect(op, dst1) tb.run() dst_data = dst1.data() self.assertComplexTuplesAlmostEqual(expected_result, dst_data, 5)
def test_001_t(self): src = dab.fib_source_b_make(1, 1, 'Galaxy_News', 'Wasteland_Radio', 'Country_Mix', 0x09, [0], [8]) fib_unpacked_to_packed = blocks.unpacked_to_packed_bb( 1, gr.GR_MSB_FIRST) s2v = blocks.stream_to_vector(gr.sizeof_char, 32) crc16 = dab.crc16_bb(32, 0x1021, 0xffff) fibsink = dab.fib_sink_vb() self.tb.connect(src, fib_unpacked_to_packed, blocks.head(gr.sizeof_char, 300), s2v, crc16, fibsink) self.tb.run() pass
def test_freq_msg(self): src = analog.sig_source_c(8, analog.GR_SIN_WAVE, 1.0, 1.0) op = blocks.head(gr.sizeof_gr_complex, 9) snk = blocks.vector_sink_c() self.tb.connect(src, op, snk) self.assertAlmostEqual(src.frequency(), 1.0) frequency = 3.0 src._post(pmt.to_pmt('freq'), pmt.from_double(frequency)) self.tb.run() self.assertAlmostEqual(src.frequency(), frequency)
def test_001_t(self): # set up fg test_len = 1024 packet_len = test_len samp_rate = 2000 center_freq = 1e9 velocity = 15 src = radar.signal_generator_cw_c(packet_len, samp_rate, (0, 0), 1) head = blocks.head(8, test_len) sim = radar.static_target_simulator_cc( (10, 10), (velocity, velocity), (1e9, 1e9), (0, 0), (0, ), samp_rate, center_freq, 1, True, False) mult = blocks.multiply_cc() fft = radar.ts_fft_cc(packet_len) cfar = radar.os_cfar_c(samp_rate, 5, 0, 0.78, 10, True) est = radar.estimator_cw(center_freq) res = radar.print_results() debug = blocks.message_debug() self.tb.connect(src, head, (mult, 1)) self.tb.connect(head, sim, (mult, 0)) self.tb.connect(mult, fft, cfar) self.tb.msg_connect(cfar, 'Msg out', est, 'Msg in') self.tb.msg_connect(est, 'Msg out', res, 'Msg in') self.tb.msg_connect(est, 'Msg out', debug, 'store') #self.tb.msg_connect(est,'Msg out',debug,'print') self.tb.start() sleep(0.5) self.tb.stop() self.tb.wait() # check data msg = debug.get_message(0) self.assertEqual("rx_time", pmt.symbol_to_string(pmt.nth(0, (pmt.nth( 0, msg))))) # check rx_time message part (symbol) self.assertEqual(0, pmt.to_uint64( pmt.tuple_ref(pmt.nth(1, (pmt.nth(0, msg))), 0))) # check rx_time value self.assertEqual( 0.0, pmt.to_double(pmt.tuple_ref(pmt.nth(1, (pmt.nth(0, msg))), 1))) self.assertEqual( "velocity", pmt.symbol_to_string(pmt.nth( 0, (pmt.nth(1, msg))))) # check velocity message part (symbol) self.assertAlmostEqual( 1, velocity / pmt.f32vector_ref(pmt.nth(1, (pmt.nth(1, msg))), 0), 2) # check velocity value
def test_sine_f(self): tb = self.tb sqrt2 = math.sqrt(2) / 2 expected_result = (0, sqrt2, 1, sqrt2, 0, -sqrt2, -1, -sqrt2, 0) src1 = analog.sig_source_f(8, analog.GR_SIN_WAVE, 1.0, 1.0) op = blocks.head(gr.sizeof_float, 9) dst1 = blocks.vector_sink_f() tb.connect(src1, op) tb.connect(op, dst1) tb.run() dst_data = dst1.data() self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 5)
def __init__(self, c_freq, int_time, samp_rate, fftsize, username, config): gr.top_block.__init__(self, "Salsa Receiver") ################################################## # Variables ################################################## self.samp_rate = samp_rate self.outfile = outfile = config.get( 'USRP', 'tmpdir') + "/SALSA_" + username + ".tmp" self.int_time = int_time self.gain = gain = config.getfloat('USRP', 'usrp_gain') self.fftsize = fftsize self.c_freq = c_freq ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="addr=" + config.get('USRP', 'host'), 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, "Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1E6 self.gain = gain = 0 self.f0 = f0 = 3.625E9 self.bandwidth = bandwidth = 5 ################################################## # Blocks ################################################## self.uhd_usrp_source_1 = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_1.set_samp_rate(samp_rate) self.uhd_usrp_source_1.set_center_freq(f0, 0) self.uhd_usrp_source_1.set_gain(gain, 0) self.uhd_usrp_source_1.set_antenna("TX/RX", 0) self.uhd_usrp_source_1.set_bandwidth(bandwidth, 0) self.blocks_skiphead_0 = blocks.skiphead(gr.sizeof_gr_complex * 1, 20) self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0) self.blocks_multiply_xx_0 = blocks.multiply_vcc(1) self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex * 1, 1000) self.blocks_file_sink_1 = blocks.file_sink( gr.sizeof_float * 1, "/home/odroid/Documents/2ndRF/calibration/Power", False) self.blocks_file_sink_1.set_unbuffered(False) self.blocks_conjugate_cc_0 = blocks.conjugate_cc() self.blocks_complex_to_real_0 = blocks.complex_to_real(1) ################################################## # Connections ################################################## self.connect((self.blocks_complex_to_real_0, 0), (self.blocks_nlog10_ff_0, 0)) self.connect((self.blocks_conjugate_cc_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.blocks_head_0, 0), (self.blocks_conjugate_cc_0, 0)) self.connect((self.blocks_head_0, 0), (self.blocks_multiply_xx_0, 0)) self.connect((self.blocks_multiply_xx_0, 0), (self.blocks_complex_to_real_0, 0)) self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_file_sink_1, 0)) self.connect((self.blocks_skiphead_0, 0), (self.blocks_head_0, 0)) self.connect((self.uhd_usrp_source_1, 0), (self.blocks_skiphead_0, 0))
def run_flowgraph(filename): samp_rate = 32000 head = blocks.head(gr.sizeof_float * 1, samp_rate) source = analog.sig_source_f(samp_rate, analog.GR_COS_WAVE, 1000, 1, 0) sigmf_sink = sigmf.sink("rf32_le", filename) tb = gr.top_block() tb.connect(source, head) tb.connect(head, sigmf_sink) tb.run() tb.wait()
def test_symbol_src ( self, arity ): vlen = 1 N = int( 1e7 ) demapper = ofdm.generic_demapper_vcb( vlen ) const = demapper.get_constellation( arity ) assert( len( const ) == 2**arity ) symsrc = ofdm.symbol_random_src( const, vlen ) # tx = transmitter_hier_bc(M=M,K=K,qam_size=qam_size,syms_per_frame=syms_per_frame,theta_sel=theta_sel,exclude_preamble=exclude_preamble,sel_preamble=None) acc = ofdm.accumulator_cc() skiphead = blocks.skiphead( gr.sizeof_gr_complex, N-1 ) limit = blocks.head( gr.sizeof_gr_complex, 1 ) dst = blocks.vector_sink_c() c2mag = blocks.complex_to_mag_squared() acc_c2m = ofdm.accumulator_ff() skiphead_c2m = blocks.skiphead( gr.sizeof_float, N-1 ) limit_c2m = blocks.head( gr.sizeof_float, 1 ) dst_c2m = blocks.vector_sink_f() tb = gr.top_block ( "test__block" ) tb.connect( symsrc, acc, skiphead, limit, dst ) tb.connect( symsrc, c2mag, acc_c2m, skiphead_c2m, limit_c2m, dst_c2m ) tb.run() data = numpy.array( dst.data() ) data_c2m = numpy.array( dst_c2m.data() ) m = data / N av_pow = data_c2m / N assert( abs( m ) < 0.01 ) assert( abs( 1.0 - av_pow ) < 0.5 ) print "Uniform distributed random symbol source has" print "\tno offset for N=%d, relative error: %f" % (arity, abs( m ) ) print "\tAverage signal power equal 1.0, relative error: %f\t\tOK" \ % ( abs( 1.0 - av_pow ) )
def setUp(self): self.tb = gr.top_block() self.src = blocks.vector_source_b((1, 2, 3, 4, 5, 6, 7, 8, 9), 1, 9) self.demux = drm.partitioning_vbvb(9, (2, 3, 4)) self.head = blocks.head(9, 2) self.snk1 = blocks.vector_sink_b(2) self.snk2 = blocks.vector_sink_b(3) self.snk3 = blocks.vector_sink_b(4) self.tb.connect(self.src, self.head, self.demux) self.tb.connect((self.demux, 0), self.snk1) self.tb.connect((self.demux, 1), self.snk2) self.tb.connect((self.demux, 2), self.snk3)
def test_jammer_sg_f (self): tb = self.tb sqrt2 = math.sqrt(2)/2 exp_res = (1, sqrt2, 0, -sqrt2, -1, -sqrt2, 0, sqrt2, 1) src = jammer.jammer_sg_f(8,1,1,0) #1 Hz frequency cosine sampled @ 8 Hz op = blocks.head(gr.sizeof_float, 9) #Limits to 9 samples of the input dst = blocks.vector_sink_f() #sink for the signal tb.connect(src, op) #connect source to head tb.connect(op,dst) #connect head to sink self.tb.run () #run flowgraph # check data dst_data = dst.data() self.assertFloatTuplesAlmostEqual(exp_res, dst_data, 5)
def test_002(self): # Confirm that we can instantiate and run an FM deemphasis block tb = self.tb src = analog.sig_source_f(48000, analog.GR_COS_WAVE, 5000.0, 1.0) op = analog.fm_deemph(fs=48000, tau=75e-6) head = blocks.head(gr.sizeof_float, 100) dst = blocks.vector_sink_f() tb.connect(src, op) tb.connect(op, head) tb.connect(head, dst) tb.run()
def test_cosine_c(self): tb = self.tb sqrt2 = math.sqrt(2) / 2 sqrt2j = 1j * math.sqrt(2) / 2 expected_result = (1, sqrt2 + sqrt2j, 1j, -sqrt2 + sqrt2j, -1, -sqrt2 - sqrt2j, -1j, sqrt2 - sqrt2j, 1) src1 = analog.sig_source_c(8, analog.GR_COS_WAVE, 1.0, 1.0) op = blocks.head(gr.sizeof_gr_complex, 9) dst1 = blocks.vector_sink_c() tb.connect(src1, op) tb.connect(op, dst1) tb.run() dst_data = dst1.data() self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 5)
def test_with_noise(self): # set up fg noise = analog.fastnoise_source_c(analog.GR_GAUSSIAN, 1, 0, 8192) head = blocks.head(gr.sizeof_gr_complex * 1, 2048) rcvr = flex_receiver(0, 50e3) msgsink = blocks.message_debug() self.tb.connect((noise, 0), (head, 0)) self.tb.connect((head, 0), (rcvr, 0)) self.tb.msg_connect((rcvr, 'pages'), (msgsink, 'store')) self.tb.run() # No data is expected to be output, this merely tests that a noise source won't crash any # of the pieces which are knit together with the flex_receiver heir block. self.assertEqual(0, msgsink.num_messages())
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() raise SystemExit, 1 src = blocks.lfsr_32k_source_s() head = blocks.head(gr.sizeof_short, 2048) self.dst = blocks.vector_sink_s() self.connect(src, head, self.dst)
def test_003_t(self): """test_003_t: two set function after 1 second and 2 seconds""" tb = self.tb samp_rate = 4096 #under 4096 does not work so fast. items = samp_rate * 3 # 3 seconds of simulation debug = flaress.debug_func_probe(gr.sizeof_float * 1) def _probe_func_probe(): time.sleep(1) try: debug.debug_nitems() except AttributeError: pass time.sleep(1) try: debug.debug_nitems() except AttributeError: pass _probe_func_thread = threading.Thread(target=_probe_func_probe) _probe_func_thread.daemon = True src = analog.sig_source_f(samp_rate, analog.GR_CONST_WAVE, 0, 0, 0) throttle = blocks.throttle(gr.sizeof_float * 1, samp_rate, True) head = blocks.head(gr.sizeof_float, int(items)) # throttle.set_max_noutput_items (samp_rate) # throttle.set_min_noutput_items (samp_rate) tb.connect(src, throttle) tb.connect(throttle, head) tb.connect(head, debug) _probe_func_thread.start() tb.run() data = debug.data() self.assertEqual(len(data), 2) self.assertLessEqual(data[0], samp_rate * 2) self.assertGreaterEqual(data[0], samp_rate) self.assertLessEqual(data[1], samp_rate * 3) self.assertGreaterEqual(data[1], samp_rate * 2) print("-Set function received at the moment: %f s." % (data[0] * (1.0 / samp_rate))) print("-Set function received at the moment: %f s." % (data[1] * (1.0 / samp_rate)))
def test_sine(self, param): """this function run the defined test, for easier understanding""" tb = self.tb data_agc = namedtuple('data_agc', 'src out') src_sine = analog.sig_source_c(param.samp_rate, analog.GR_SIN_WAVE, param.freq_sine, 1) src_square = analog.sig_source_f( param.samp_rate, analog.GR_SQR_WAVE, param.freq_square, ((param.input_amplitude_max - param.input_amplitude_min) / math.sqrt(2)), (param.input_amplitude_min / math.sqrt(2))) src_noise = analog.noise_source_c(analog.GR_GAUSSIAN, param.noise, 0) adder = blocks.add_vcc(1) multiply_const = blocks.multiply_const_ff(-1) multiply_complex = blocks.multiply_cc() dst_agc = blocks.vector_sink_c() dst_source = blocks.vector_sink_c() float_to_complex = blocks.float_to_complex() head = blocks.head(gr.sizeof_gr_complex, int(param.N)) agc = ecss.agc_cc(param.settling_time, param.reference, 1.0, 65536.0, param.samp_rate) tb.connect(src_square, (float_to_complex, 0)) tb.connect(src_square, multiply_const) tb.connect(multiply_const, (float_to_complex, 1)) tb.connect(src_sine, (adder, 0)) tb.connect(src_noise, (adder, 1)) tb.connect(adder, (multiply_complex, 0)) tb.connect(float_to_complex, (multiply_complex, 1)) tb.connect(multiply_complex, head) tb.connect(head, agc) tb.connect(agc, dst_agc) tb.connect(head, dst_source) self.tb.run() data_agc.src = dst_source.data() data_agc.out = dst_agc.data() return data_agc
def __init__(self, n_samples, n_offset_samples, n_prbs, linear_gain, pad_interval, mcs, frequency_offset): super(GrLTETracesFlowgraph, self).__init__() self.subcarrier_spacing = 15000 # params self.n_samples = n_samples self.n_prbs = n_prbs self.linear_gain = linear_gain self.mcs = mcs # derived params self.fft_size = GrLTETracesFlowgraph.prb_mapping[self.n_prbs] self.samp_rate = float(self.fft_size * self.subcarrier_spacing) n_prbs_str = "%02d" % (self.n_prbs, ) mcs_str = "%02d" % (self.mcs) fname = '{}/lte_dump_prb_{}_mcs_{}.32fc'.format( frames_path, n_prbs_str, mcs_str) self.expected_bw = GrLTETracesFlowgraph.fftsize_mapping[self.fft_size] self.resamp_ratio = 20.0e6 / self.samp_rate self.n_samples_per_frame = int(10.0e-3 * self.samp_rate) self.n_offset_samples = int( lf.random_generator.load_value(n_offset_samples)) randgen = lf.random_generator.load_generator(pad_interval) # scale by sampling rate new_params = tuple( [int(v / self.resamp_ratio) for v in randgen.params]) randgen.params = new_params if isinstance(frequency_offset, tuple): assert frequency_offset[0] == 'uniform' self.frequency_offset = frequency_offset[1] else: # it is just a value self.frequency_offset = [frequency_offset] # blocks self.file_reader = blocks.file_source(gr.sizeof_gr_complex, fname, True) self.tagger = blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, 1, self.n_samples_per_frame, "packet_len") self.burst_shaper = specmonitor.random_burst_shaper_cc( randgen.dynrandom(), 0, self.frequency_offset, "packet_len") # self.resampler = filter.rational_resampler_base_ccc(interp,decim,taps) self.resampler = filter.fractional_resampler_cc( 0, 1 / self.resamp_ratio) self.skiphead = blocks.skiphead(gr.sizeof_gr_complex, self.n_offset_samples) self.head = blocks.head(gr.sizeof_gr_complex, self.n_samples) self.dst = blocks.vector_sink_c() self.setup_flowgraph()
def __init__(self): gr.top_block.__init__(self) default_nsamples = 10e6 parser = ArgumentParser() parser.add_argument( "-p", "--npipelines", type=intx, default=1, metavar="NPIPES", help="the number of pipelines to create (default=%(default)s)") parser.add_argument( "-s", "--nstages", type=intx, default=1, metavar="NSTAGES", help="the number of stages in each pipeline (default=%(default)s)") parser.add_argument( "-N", "--nsamples", type=eng_float, default=default_nsamples, help=( "the number of samples to run through the graph (default=%s)" % (eng_notation.num_to_str(default_nsamples)))) parser.add_argument("-m", "--machine-readable", action="store_true", default=False, help="enable machine readable output") args = parser.parse_args() self.npipes = args.npipelines self.nstages = args.nstages self.nsamples = args.nsamples self.machine_readable = args.machine_readable ntaps = 256 # Something vaguely like floating point ops self.flop = 2 * ntaps * args.npipelines * args.nstages * args.nsamples src = blocks.null_source(gr.sizeof_float) head = blocks.head(gr.sizeof_float, int(args.nsamples)) self.connect(src, head) for n in range(args.npipelines): self.connect(head, pipeline(args.nstages, ntaps))
def __init__(self, snr_db=10, num_symbols=1024, taps=[]): gr.top_block.__init__(self, "CMA Watterson Experiment") ################################################## # Variables ################################################## self.snr_db = snr_db self.samp_rate = samp_rate = 1000000 self.num_symbols = num_symbols self.taps = taps self.const = const = digital.constellation_8psk().base() ################################################## # Blocks ################################################## #self.interp_fir_filter_xxx_0_0 = filter.interp_fir_filter_ccc(2, (firdes.low_pass_2(1, 1, .25, .1, 80))) #self.interp_fir_filter_xxx_0_0.declare_sample_delay(0) self.digital_cma_equalizer_cc_0 = digital.cma_equalizer_cc( 4, 1, .01, 2) self.digital_chunks_to_symbols_xx_1 = digital.chunks_to_symbols_bc( (const.points()), 1) self.channels_channel_model_0 = channels.channel_model( noise_voltage=10**(-self.snr_db / 20.0) / numpy.sqrt(2), frequency_offset=0.0, epsilon=1.0, taps=self.taps, noise_seed=0, block_tags=False) self.blocks_vector_sink_x_0 = blocks.vector_sink_c(1) self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex * 1, num_symbols) self.analog_random_source_x_1 = blocks.vector_source_b( map(int, numpy.random.randint(0, const.arity(), 1000)), True) self.blocks_repeat_0 = blocks.repeat(gr.sizeof_gr_complex * 1, 2) ################################################## # Connections ################################################## self.connect((self.analog_random_source_x_1, 0), (self.digital_chunks_to_symbols_xx_1, 0)) self.connect((self.blocks_head_0, 0), (self.blocks_vector_sink_x_0, 0)) self.connect((self.channels_channel_model_0, 0), (self.digital_cma_equalizer_cc_0, 0)) #self.connect((self.digital_chunks_to_symbols_xx_1, 0), (self.interp_fir_filter_xxx_0_0, 0)) self.connect((self.digital_cma_equalizer_cc_0, 0), (self.blocks_head_0, 0)) #self.connect((self.interp_fir_filter_xxx_0_0, 0), (self.channels_channel_model_0, 0)) self.connect((self.blocks_repeat_0, 0), (self.channels_channel_model_0, 0)) self.connect((self.digital_chunks_to_symbols_xx_1, 0), (self.blocks_repeat_0, 0))