def setUp(self): self.tb = gr.top_block() self.pbch = lte.decode_pbch_vcvf() """ This hierarchical block consists of the following blocks lte.pre_decoder_vcvc(1, style) lte.pre_decoder_vcvc(2, style) lte.layer_demapper_vcvc(1, style) lte.layer_demapper_vcvc(2, style) gr.interleave(240*gr.sizeof_gr_complex) lte.qpsk_soft_demod_vcvf() lte.descrambling_vfvf() """ self.src0 = gr.vector_source_c([0] * 240, False, 240) self.src1 = gr.vector_source_c([0] * 240, False, 240) self.src2 = gr.vector_source_c([0] * 240, False, 240) self.snk = gr.vector_sink_f(120) self.tb.connect(self.src0, (self.pbch, 0)) self.tb.connect(self.src1, (self.pbch, 1)) self.tb.connect(self.src2, (self.pbch, 2)) self.tb.connect(self.pbch, self.snk)
def test_add_fc32(self): tb = gr.top_block() src0 = gr.vector_source_c([1, 3j, 5, 7j, 9], False) src1 = gr.vector_source_c([0, 2j, 4, 6j, 8], False) adder = add_2_fc32_1_fc32() sink = gr.vector_sink_c() tb.connect((src0, 0), (adder, 0)) tb.connect((src1, 0), (adder, 1)) tb.connect(adder, sink) tb.run() self.assertEqual(sink.data(), (1, 5j, 9, 13j, 17))
def test_000(self): src_data0 = (-2 - 2j, -1 - 1j, -2 + 2j, -1 + 1j, 2 - 2j, 1 - 1j, 2 + 2j, 1 + 1j, 0 + 0j) src_data1 = (-3 - 3j, -4 - 4j, -3 + 3j, -4 + 4j, 3 - 3j, 4 - 4j, 3 + 3j, 4 + 4j, 0 + 0j) exp_data = (12 + 0j, 8 + 0j, 12 + 0j, 8 + 0j, 12 + 0j, 8 + 0j, 12 + 0j, 8 + 0j, 0 + 0j) src0 = gr.vector_source_c(src_data0) src1 = gr.vector_source_c(src_data1) op = gr.multiply_conjugate_cc() self.help_cc((src_data0, src_data1), exp_data, op)
def __init__(self): gr.top_block.__init__(self) usage = "%prog: [options] samples_file" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-m", "--dab-mode", type="int", default=1, help="DAB mode [default=%default]") parser.add_option("-F", "--filter-input", action="store_true", default=False, help="Enable FFT filter at input") parser.add_option("-s", "--resample-fixed", type="float", default=1, help="resample by a fixed factor (fractional interpolation)") parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False, help="Estimate sample rate offset and resample (dynamic fractional interpolation)") parser.add_option('-r', '--sample-rate', type="int", default=2048000, help="Use non-standard sample rate (default=%default)") parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False, help="Enable individual carrier magnitude equalizer") parser.add_option('-d', '--debug', action="store_true", default=False, help="Write output to files") parser.add_option('-v', '--verbose', action="store_true", default=False, help="Print status messages") (options, args) = parser.parse_args () dp = parameters.dab_parameters(options.dab_mode, verbose=options.verbose, sample_rate=options.sample_rate) rp = parameters.receiver_parameters(options.dab_mode, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, equalize_magnitude=options.equalize_magnitude, verbose=options.verbose) if len(args)<1: if options.verbose: print "-> using repeating random vector as source" self.sigsrc = gr.vector_source_c([10e6*(random.random() + 1j*random.random()) for i in range(0,100000)],True) self.ns_simulate = gr.vector_source_c([0.01]*dp.ns_length+[1]*dp.symbols_per_frame*dp.symbol_length,1) self.mult = gr.multiply_cc() # simulate null symbols ... self.src = gr.throttle( gr.sizeof_gr_complex,2048000) self.connect(self.sigsrc, (self.mult, 0)) self.connect(self.ns_simulate, (self.mult, 1)) self.connect(self.mult, self.src) else: filename = args[0] if options.verbose: print "-> using samples from file " + filename self.src = gr.file_source(gr.sizeof_gr_complex, filename, False) self.dab_demod = ofdm.ofdm_demod(dp, rp, debug=options.debug, verbose=options.verbose) self.connect(self.src, self.dab_demod) # sink output to nowhere self.nop0 = gr.nop(gr.sizeof_char*dp.num_carriers/4) self.nop1 = gr.nop(gr.sizeof_char) self.connect((self.dab_demod,0),self.nop0) self.connect((self.dab_demod,1),self.nop1)
def setUp (self): self.tb = gr.top_block () print "qa_pbch_demux_vcvc START" # Input 1, PBCH frame mod=scipy.io.loadmat('/home/demel/exchange/matlab_frame.mat') mat_u1=tuple(mod['frame_mat'].flatten()) mat_d=range(len(mat_u1)) for idx, val in enumerate(mat_u1): mat_d[idx]=val intu1=tuple(mat_d) # Input 2, CE values for antenna port 1 mod=scipy.io.loadmat('/home/demel/exchange/matlab_ce_frame_mat1.mat') mat_u2=tuple(mod['ce_frame_mat1'].flatten()) mat_d=range(len(mat_u2)) for idx, val in enumerate(mat_u2): mat_d[idx]=val intu2=tuple(mat_d) # Input 2, CE values for antenna port 1 mod=scipy.io.loadmat('/home/demel/exchange/matlab_ce_frame_mat2.mat') mat_u2=tuple(mod['ce_frame_mat2'].flatten()) mat_d=range(len(mat_u2)) for idx, val in enumerate(mat_u2): mat_d[idx]=val intu3=tuple(mat_d) self.src1 = gr.vector_source_c( intu1, False, 72) self.src2 = gr.vector_source_c( intu2, False, 72) self.src3 = gr.vector_source_c( intu3, False, 72) cell_id = 124 N_rb_dl = 6 self.demux = lte_swig.pbch_demux_vcvc(N_rb_dl) # cell_id, self.demux.set_cell_id(cell_id) self.snk1 = gr.vector_sink_c(240) self.snk2 = gr.vector_sink_c(240) self.snk3 = gr.vector_sink_c(240) self.tb.connect(self.src1,(self.demux,0) ) self.tb.connect( (self.demux,0),self.snk1) self.tb.connect(self.src2,(self.demux,1) ) self.tb.connect( (self.demux,1),self.snk2) self.tb.connect(self.src3,(self.demux,2) ) self.tb.connect( (self.demux,2),self.snk3)
def setUp(self): self.tb = gr.top_block() print "qa_pbch_demux_vcvc START" # Input 1, PBCH frame mod = scipy.io.loadmat('/home/demel/exchange/matlab_frame.mat') mat_u1 = tuple(mod['frame_mat'].flatten()) mat_d = range(len(mat_u1)) for idx, val in enumerate(mat_u1): mat_d[idx] = val intu1 = tuple(mat_d) # Input 2, CE values for antenna port 1 mod = scipy.io.loadmat('/home/demel/exchange/matlab_ce_frame_mat1.mat') mat_u2 = tuple(mod['ce_frame_mat1'].flatten()) mat_d = range(len(mat_u2)) for idx, val in enumerate(mat_u2): mat_d[idx] = val intu2 = tuple(mat_d) # Input 2, CE values for antenna port 1 mod = scipy.io.loadmat('/home/demel/exchange/matlab_ce_frame_mat2.mat') mat_u2 = tuple(mod['ce_frame_mat2'].flatten()) mat_d = range(len(mat_u2)) for idx, val in enumerate(mat_u2): mat_d[idx] = val intu3 = tuple(mat_d) self.src1 = gr.vector_source_c(intu1, False, 72) self.src2 = gr.vector_source_c(intu2, False, 72) self.src3 = gr.vector_source_c(intu3, False, 72) cell_id = 124 N_rb_dl = 6 self.demux = lte_swig.pbch_demux_vcvc(N_rb_dl) # cell_id, self.demux.set_cell_id(cell_id) self.snk1 = gr.vector_sink_c(240) self.snk2 = gr.vector_sink_c(240) self.snk3 = gr.vector_sink_c(240) self.tb.connect(self.src1, (self.demux, 0)) self.tb.connect((self.demux, 0), self.snk1) self.tb.connect(self.src2, (self.demux, 1)) self.tb.connect((self.demux, 1), self.snk2) self.tb.connect(self.src3, (self.demux, 2)) self.tb.connect((self.demux, 2), self.snk3)
def test03(self): # Test complex/complex version with varying input omega = 2 gain_omega = 0.01 mu = 0.25 gain_mu = 0.1 omega_rel_lim = 0.0001 self.test = digital_swig.clock_recovery_mm_cc(omega, gain_omega, mu, gain_mu, omega_rel_lim) data = 1000 * [complex(1, 1), complex(1, 1), complex(-1, -1), complex(-1, -1)] self.src = gr.vector_source_c(data, False) self.snk = gr.vector_sink_c() self.tb.connect(self.src, self.test, self.snk) self.tb.run() expected_result = 1000 * [complex(-1.2, -1.2), complex(1.2, 1.2)] dst_data = self.snk.data() # Only compare last Ncmp samples Ncmp = 100 len_e = len(expected_result) len_d = len(dst_data) expected_result = expected_result[len_e - Ncmp :] dst_data = dst_data[len_d - Ncmp :] # print expected_result # print dst_data self.assertComplexTuplesAlmostEqual(expected_result, dst_data, 1)
def test_fir_filter_ccf_001(self): self.generate_ccf_source() expected_data = ((0.001697700354270637 + 0.004312471952289343j), (0.003520616563037038 - 0.003014103975147009j), (0.004252811893820763 - 0.008337559178471565j), (0.0030743128154426813 - 0.010262271389365196j), (0.0007344777695834637 - 0.007861139252781868j), (-0.0011067686136811972 - 0.0028924935031682253j), (-0.002371778478845954 + 0.0019914964213967323j), (-0.003023319412022829 + 0.005717850290238857j), (-0.0021738125942647457 + 0.007211698684841394j), (-0.0004628606839105487 + 0.005501383915543556j), (0.0007428556564264 + 0.0019867848604917526j), (0.001634795218706131 - 0.0013514887541532516j), (0.002205110155045986 - 0.00402155052870512j), (0.0015480631263926625 - 0.005179159343242645j), (0.00026722141774371266 - 0.003887997241690755j), (-0.0004911854630336165 - 0.0013578246580436826j), (-0.0011226939968764782 + 0.0009080552263185382j), (-0.0016229727771133184 + 0.0028335191309452057j), (-0.0010890064295381308 + 0.0037298379465937614j), (-0.00012392725329846144 + 0.0027196139562875032j)) src = gr.vector_source_c(self.src_data) op = filter.freq_xlating_fir_filter_ccf(1, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def transform(self, src_data): SRC = gr.vector_source_c(src_data, False) EQU = gr.cma_equalizer_cc(4, 1.0, .001) DST = gr.vector_sink_c() self.tb.connect(SRC, EQU, DST) self.tb.run() return DST.data()
def setUp (self): #print os.getpid() #raw_input("press the any key") self.tb = gr.top_block () offset = 43223 #sample15 = 21839 #sample20 = 43223 fftl = 512 cpl = 144*fftl/2048 cpl0 = 160*fftl/2048 slotl = 7*fftl+6*cpl+cpl0 cell_id = 124 N_rb_dl = 6 mod=scipy.io.loadmat('/home/demel/exchange/matlab_test_first_freq.mat') mat_u1=tuple(mod['test'].flatten()) mat_d=range(len(mat_u1)) for idx, val in enumerate(mat_u1): mat_d[idx]=val intu=tuple(mat_d[0:slotl*60]) self.src = gr.vector_source_c(intu,False,1) self.tag = lte.tag_symbol_cc(offset,fftl) #self.head = gr.head(gr.sizeof_gr_complex,70000) self.sel = lte.sss_selector_cvc(fftl) self.vtos = gr.vector_to_stream(gr.sizeof_gr_complex,512) self.snk = gr.vector_sink_c(1) self.tb.connect(self.src,self.tag,self.sel,self.vtos,self.snk)#,self.head
def test_001b_simple_skip_nothing(self): """ Same as before, but put a skip-header in there """ fft_len = 8 equalizer = digital.ofdm_equalizer_static(fft_len, symbols_skipped=1) n_syms = 3 len_tag_key = "frame_len" tx_data = (1, ) * fft_len * n_syms len_tag = gr.gr_tag_t() len_tag.offset = 0 len_tag.key = pmt.pmt_string_to_symbol(len_tag_key) len_tag.value = pmt.pmt_from_long(n_syms) chan_tag = gr.gr_tag_t() chan_tag.offset = 0 chan_tag.key = pmt.pmt_string_to_symbol("ofdm_sync_chan_taps") chan_tag.value = pmt.pmt_init_c32vector(fft_len, (1, ) * fft_len) src = gr.vector_source_c(tx_data, False, fft_len, (len_tag, chan_tag)) eq = digital.ofdm_frame_equalizer_vcvc(equalizer.base(), 0, len_tag_key) sink = gr.vector_sink_c(fft_len) self.tb.connect(src, eq, sink) self.tb.run() # Check data self.assertEqual(tx_data, sink.data())
def test_003_multiburst(self): """ Send several bursts, see if the number of detects is correct. Burst lengths and content are random. """ n_bursts = 42 fft_len = 32 cp_len = 4 tx_signal = [] for i in xrange(n_bursts): sync_symbol = [(random.randint(0, 1) * 2) - 1 for x in range(fft_len / 2)] * 2 tx_signal += [0,] * random.randint(0, 2*fft_len) + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(fft_len * random.randint(5,23))] add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() channel = gr.channel_model(0.005) self.tb.connect(gr.vector_source_c(tx_signal), channel, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() n_bursts_detected = numpy.sum(sink_detect.data()) # We allow for one false alarm or missed burst self.assertTrue( abs(n_bursts_detected - n_bursts) <= 1, msg="""Because of statistics, it is possible (though unlikely) that the number of detected bursts differs slightly. If the number of detects is off by one or two, run the test again and see what happen. Detection error was: %d """ % (numpy.sum(sink_detect.data()) - n_bursts))
def __init__(self, dbW, pfa, pfd): gr.top_block.__init__(self) # Parameters samp_rate = 2e6 fft_size = 4096 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False primary_user_location = 0 useless_bw = 0.0 # As we are not using any of the dongles it can be set as zero, i.e., all the band can be used. histogram = False nframes_to_check = 1 nframes_to_average = 1 downconverter = 1 nsegs_to_check = 6 # Create AWGN noise noise = awgn(fft_size, dbW) # Blocks src = gr.vector_source_c(noise) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1) self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check) self.sink = gr.vector_sink_f() # Connections self.connect(src, s2v, fftb, self.ss, self.sink)
def __init__(self, N, sps, rolloff, ntaps, bw, noise, foffset, toffset, poffset): gr.top_block.__init__(self) rrc_taps = gr.firdes.root_raised_cosine( sps, sps, 1.0, rolloff, ntaps) data = 2.0*scipy.random.randint(0, 2, N) - 1.0 data = scipy.exp(1j*poffset) * data self.src = gr.vector_source_c(data.tolist(), False) self.rrc = gr.interp_fir_filter_ccf(sps, rrc_taps) self.chn = gr.channel_model(noise, foffset, toffset) self.fll = digital.fll_band_edge_cc(sps, rolloff, ntaps, bw) self.vsnk_src = gr.vector_sink_c() self.vsnk_fll = gr.vector_sink_c() self.vsnk_frq = gr.vector_sink_f() self.vsnk_phs = gr.vector_sink_f() self.vsnk_err = gr.vector_sink_f() self.connect(self.src, self.rrc, self.chn, self.fll, self.vsnk_fll) self.connect(self.rrc, self.vsnk_src) self.connect((self.fll,1), self.vsnk_frq) self.connect((self.fll,2), self.vsnk_phs) self.connect((self.fll,3), self.vsnk_err)
def test_fir_filter_ccf_001(self): self.generate_ccf_source() expected_data = ((0.001697700354270637+0.004312471952289343j), (0.003520616563037038-0.003014103975147009j), (0.004252811893820763-0.008337559178471565j), (0.0030743128154426813-0.010262271389365196j), (0.0007344777695834637-0.007861139252781868j), (-0.0011067686136811972-0.0028924935031682253j), (-0.002371778478845954+0.0019914964213967323j), (-0.003023319412022829+0.005717850290238857j), (-0.0021738125942647457+0.007211698684841394j), (-0.0004628606839105487+0.005501383915543556j), (0.0007428556564264+0.0019867848604917526j), (0.001634795218706131-0.0013514887541532516j), (0.002205110155045986-0.00402155052870512j), (0.0015480631263926625-0.005179159343242645j), (0.00026722141774371266-0.003887997241690755j), (-0.0004911854630336165-0.0013578246580436826j), (-0.0011226939968764782+0.0009080552263185382j), (-0.0016229727771133184+0.0028335191309452057j), (-0.0010890064295381308+0.0037298379465937614j), (-0.00012392725329846144+0.0027196139562875032j)) src = gr.vector_source_c(self.src_data) op = filter.freq_xlating_fir_filter_ccf(1, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def __init__(self, vlen, channel_block, delay): gr.hier_block2.__init__( self, 'apply_channel_to_vect', gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen), gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen)) self.vlen = vlen self.channel_block = channel_block self.delay = delay pad_len = self.vlen + self.delay * 2 if (delay > 0): self.padding = gr.vector_source_c((0, ) * (delay * 2), True, delay * 2) self.pad_cat = mlse.vector_concat_vv( vlen * gr.sizeof_gr_complex, gr.sizeof_gr_complex * 2 * delay) self.connect(self, self.pad_cat) self.connect(self.padding, (self.pad_cat, 1)) else: self.pad_cat = self self.tostream = gr.vector_to_stream(gr.sizeof_gr_complex, pad_len) self.connect(self.pad_cat, self.tostream) # connect channel self.connect(self.tostream, self.channel_block) self.tovector = gr.stream_to_vector(gr.sizeof_gr_complex, pad_len) self.connect(self.channel_block, self.tovector) # cut out the proper part self.trim = mlse.vector_slice_vv(gr.sizeof_gr_complex, pad_len, delay, vlen) self.connect(self.tovector, self.trim, self)
def setUp(self): self.tb = gr.top_block() offset = 43223 #sample15 = 21839 #sample20 = 43223 fftl = 512 cpl = 144 * fftl / 2048 cpl0 = 160 * fftl / 2048 slotl = 7 * fftl + 6 + cpl + cpl0 cell_id = 124 N_rb_dl = 6 mod = scipy.io.loadmat( '/home/demel/exchange/matlab_test_first_freq.mat') mat_u1 = tuple(mod['test'].flatten()) mat_d = range(len(mat_u1)) for idx, val in enumerate(mat_u1): mat_d[idx] = val intu = tuple(mat_d[0:100 * slotl]) self.src = gr.vector_source_c(intu, False, 1) self.tag = lte_swig.tag_symbol_cc(offset, fftl) self.stag = lte_swig.sss_tagging_cc(fftl) self.snk = gr.vector_sink_c(1) self.tb.connect(self.src, self.tag, self.stag, self.snk)
def test_006_channel_and_carroffset(self): """ Add a channel, check if it's correctly estimated """ fft_len = 16 carr_offset = 2 # Index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 sync_symbol1 = (0, 0, 0, 1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, 0) sync_symbol2 = (0, 0, 0, 1j, -1, 1, -1j, 1j, 0, 1, -1j, -1, -1j, 1, 0, 0) data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0) # Channel 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 # Shifted (0, 0, 0, 0, 0, 1j, -1, 1, -1j, 1j, 0, 1, -1j, -1, -1j, 1) chanest_exp = (0, 0, 0, 5, 6, 7, 8, 9, 0, 11, 12, 13, 14, 15, 0, 0) tx_data = shift_tuple(sync_symbol1, carr_offset) + \ shift_tuple(sync_symbol2, carr_offset) + \ shift_tuple(data_symbol, carr_offset) channel = range(fft_len) src = gr.vector_source_c(tx_data, False, fft_len) chan = gr.multiply_const_vcc(channel) chanest = digital.ofdm_chanest_vcvc(sync_symbol1, sync_symbol2, 1) sink = gr.vector_sink_c(fft_len) self.tb.connect(src, chan, chanest, sink) self.tb.run() tags = sink.tags() chan_est = None for tag in tags: if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_carr_offset': self.assertEqual(pmt.pmt_to_long(tag.value), carr_offset) if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': chan_est = pmt.pmt_c32vector_elements(tag.value) self.assertEqual(chan_est, chanest_exp) self.assertEqual( sink.data(), tuple( numpy.multiply(shift_tuple(data_symbol, carr_offset), channel)))
def test_003_channel_no_carroffset(self): """ Add a channel, check if it's correctly estimated """ fft_len = 16 carr_offset = 0 sync_symbol1 = (0, 0, 0, 1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, 0) sync_symbol2 = (0, 0, 0, 1j, -1, 1, -1j, 1j, 0, 1, -1j, -1, -1j, 1, 0, 0) data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0) tx_data = sync_symbol1 + sync_symbol2 + data_symbol channel = (0, 0, 0, 2, -2, 2, 3j, 2, 0, 2, 2, 2, 2, 3, 0, 0) src = gr.vector_source_c(tx_data, False, fft_len) chan = gr.multiply_const_vcc(channel) chanest = digital.ofdm_chanest_vcvc(sync_symbol1, sync_symbol2, 1) sink = gr.vector_sink_c(fft_len) sink_chanest = gr.vector_sink_c(fft_len) self.tb.connect(src, chan, chanest, sink) self.tb.connect((chanest, 1), sink_chanest) self.tb.run() tags = sink.tags() self.assertEqual(shift_tuple(sink.data(), -carr_offset), tuple(numpy.multiply(data_symbol, channel))) for tag in tags: if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_carr_offset': self.assertEqual(pmt.pmt_to_long(tag.value), carr_offset) if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': self.assertEqual(pmt.pmt_c32vector_elements(tag.value), channel) self.assertEqual(sink_chanest.data(), channel)
def test_001(self): """ Run test: - No overlap - Hamming window from Python - Constant input signal of amplitude 1 The given input signal has a known power of 1. Therefore, the integral of the PSD estimation result should be pretty close to 1.""" fft_len = 256 overlap = 0 ma_len = 1 window = hamming(fft_len) src_data = (1,) * ((ma_len + 1) * fft_len) src = gr.vector_source_c(src_data, False) welch = specest.welch(fft_len, overlap, ma_len, False, window) sink = gr.vector_sink_f(fft_len) self.tb.connect(src, welch, sink) self.tb.run() dst_data = sink.data() dst_data = array(dst_data[-fft_len:]) power_est = sum(dst_data) * 2 * pi / fft_len self.assertAlmostEqual(power_est, 1, 5)
def test_003_channel_no_carroffset (self): """ Add a channel, check if it's correctly estimated """ fft_len = 16 carr_offset = 0 sync_symbol1 = (0, 0, 0, 1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, 0) sync_symbol2 = (0, 0, 0, 1j, -1, 1, -1j, 1j, 0, 1, -1j, -1, -1j, 1, 0, 0) data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0) tx_data = sync_symbol1 + sync_symbol2 + data_symbol channel = (0, 0, 0, 2, -2, 2, 3j, 2, 0, 2, 2, 2, 2, 3, 0, 0) src = gr.vector_source_c(tx_data, False, fft_len) chan = gr.multiply_const_vcc(channel) chanest = digital.ofdm_chanest_vcvc(sync_symbol1, sync_symbol2, 1) sink = gr.vector_sink_c(fft_len) sink_chanest = gr.vector_sink_c(fft_len) self.tb.connect(src, chan, chanest, sink) self.tb.connect((chanest, 1), sink_chanest) self.tb.run() tags = sink.tags() self.assertEqual(shift_tuple(sink.data(), -carr_offset), tuple(numpy.multiply(data_symbol, channel))) for tag in tags: if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_carr_offset': self.assertEqual(pmt.pmt_to_long(tag.value), carr_offset) if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': self.assertEqual(pmt.pmt_c32vector_elements(tag.value), channel) self.assertEqual(sink_chanest.data(), channel)
def setUp (self): self.tb = gr.top_block () ############################ # define variables for test purposes self.fftl = fftl = 2048 N_rb_dl = 6 self.N_id = N_id = 124 N_id_1 = N_id/3 N_id_2 = N_id%3 # This blocks are needed as "dummy" references self.tag = lte_swig.sss_tagging2_vcvc(fftl) self.eq = lte_swig.linear_OFDM_estimator_vcvc(N_rb_dl) self.demux = lte_swig.pbch_demux_vcvc(N_rb_dl) self.descr = lte_swig.descrambling_vfvf() self.daemon = lte_swig.cell_id_daemon(self.eq, self.demux, self.descr) #Source data = range(2*fftl) self.src = gr.vector_source_c(data, False, fftl) # UUT self.calc = lte_swig.sss_calc2_vc(self.tag, self.daemon, fftl) self.tb.connect(self.src, self.calc)
def run_flow_graph(sync_sym1, sync_sym2, data_sym): top_block = gr.top_block() carr_offset = random.randint(-max_offset/2, max_offset/2) * 2 tx_data = shift_tuple(sync_sym1, carr_offset) + \ shift_tuple(sync_sym2, carr_offset) + \ shift_tuple(data_sym, carr_offset) channel = [rand_range(min_chan_ampl, max_chan_ampl) * numpy.exp(1j * rand_range(0, 2 * numpy.pi)) for x in range(fft_len)] src = gr.vector_source_c(tx_data, False, fft_len) chan= gr.multiply_const_vcc(channel) noise = gr.noise_source_c(gr.GR_GAUSSIAN, wgn_amplitude) add = gr.add_cc(fft_len) chanest = digital.ofdm_chanest_vcvc(sync_sym1, sync_sym2, 1) sink = gr.vector_sink_c(fft_len) top_block.connect(src, chan, (add, 0), chanest, sink) top_block.connect(noise, gr.stream_to_vector(gr.sizeof_gr_complex, fft_len), (add, 1)) top_block.run() channel_est = None carr_offset_hat = 0 rx_sym_est = [0,] * fft_len tags = sink.tags() for tag in tags: if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_carr_offset': carr_offset_hat = pmt.pmt_to_long(tag.value) self.assertEqual(carr_offset, carr_offset_hat) if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': channel_est = shift_tuple(pmt.pmt_c32vector_elements(tag.value), carr_offset) shifted_carrier_mask = shift_tuple(carrier_mask, carr_offset) for i in range(fft_len): if shifted_carrier_mask[i] and channel_est[i]: self.assertAlmostEqual(channel[i], channel_est[i], places=0) rx_sym_est[i] = (sink.data()[i] / channel_est[i]).real return (carr_offset, list(shift_tuple(rx_sym_est, -carr_offset_hat)))
def setUp(self): self.tb = gr.top_block() #print os.getpid() #raw_input("Press the ANY key!") offset = 43223 #sample15 = 21839 #sample20 = 43223 fftl = 512 cell_id = 124 N_rb_dl = 6 mod = scipy.io.loadmat( '/home/demel/exchange/matlab_test_first_freq.mat') mat_u1 = tuple(mod['test'].flatten()) mat_d = range(len(mat_u1)) for idx, val in enumerate(mat_u1): mat_d[idx] = val intu = tuple(mat_d[0:100000]) self.src = gr.vector_source_c(intu, False, 1) #self.tag = lte_swig.tag_symbol_cc(offset,fftl) self.tagp = lte_swig.pss_tagging_cc(fftl) self.snk = gr.vector_sink_c(1) self.tb.connect(self.src, self.tagp, self.snk) #self.tag,
def test_002_freq(self): """ Add a fine frequency offset and see if that get's detected properly """ fft_len = 32 cp_len = 4 # This frequency offset is normalized to rads, i.e. \pi == f_s/2 max_freq_offset = 2 * numpy.pi / fft_len # Otherwise, it's coarse freq_offset = ((2 * random.random()) - 1) * max_freq_offset sig_len = (fft_len + cp_len) * 10 sync_symbol = [(random.randint(0, 1) * 2) - 1 for x in range(fft_len / 2)] * 2 tx_signal = sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(sig_len)] mult = gr.multiply_cc() add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len, True) channel = gr.channel_model(0.005, freq_offset / 2.0 / numpy.pi) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() self.tb.connect(gr.vector_source_c(tx_signal), channel, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() phi_hat = sink_freq.data()[sink_detect.data().index(1)] est_freq_offset = 2 * phi_hat / fft_len self.assertAlmostEqual(est_freq_offset, freq_offset, places=2)
def __init__(self, dBm, pfa, pfd, useless_bw, plot_histogram): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False self.histogram = plot_histogram primary_user_location = 5 mu = 0 fft_size = 4096 nframes_to_check = 1 nframes_to_average = 1 downconverter = 1 src_data = self.generateRandomSignalSource( dBm, fft_size, mu, nframes_to_check * nframes_to_average) # Blocks src = gr.vector_source_c(src_data) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1) self.ss = howto.spectrum_sensing_cf(samp_rate, fft_size, samples_per_band, pfd, pfa, tcme, output_pfa, debug_stats, primary_user_location, useless_bw, self.histogram, nframes_to_check, nframes_to_average, downconverter) self.sink = gr.vector_sink_f() # Connections self.connect(src, s2v, fftb, self.ss, self.sink)
def test_001_simple (self): """ Very simple functionality testing """ fft_len = 8 equalizer = digital.ofdm_equalizer_static(fft_len) n_syms = 3 len_tag_key = "frame_len" tx_data = (1,) * fft_len * n_syms len_tag = gr.gr_tag_t() len_tag.offset = 0 len_tag.key = pmt.pmt_string_to_symbol(len_tag_key) len_tag.value = pmt.pmt_from_long(n_syms) chan_tag = gr.gr_tag_t() chan_tag.offset = 0 chan_tag.key = pmt.pmt_string_to_symbol("ofdm_sync_chan_taps") chan_tag.value = pmt.pmt_init_c32vector(fft_len, (1,) * fft_len) src = gr.vector_source_c(tx_data, False, fft_len, (len_tag, chan_tag)) eq = digital.ofdm_frame_equalizer_vcvc(equalizer.base(), len_tag_key) sink = gr.vector_sink_c(fft_len) self.tb.connect(src, eq, sink) self.tb.run () # Check data self.assertEqual(tx_data, sink.data()) for tag in sink.tags(): self.assertEqual(pmt.pmt_symbol_to_string(tag.key), len_tag_key) self.assertEqual(pmt.pmt_to_long(tag.value), n_syms)
def __init__(self, N, sps, rolloff, ntaps, bw, noise, foffset, toffset, poffset): gr.top_block.__init__(self) rrc_taps = gr.firdes.root_raised_cosine( sps, sps, 1.0, rolloff, ntaps) data = 2.0*scipy.random.randint(0, 2, N) - 1.0 data = scipy.exp(1j*poffset) * data self.src = gr.vector_source_c(data.tolist(), False) self.rrc = filter.interp_fir_filter_ccf(sps, rrc_taps) self.chn = filter.channel_model(noise, foffset, toffset) self.fll = digital.fll_band_edge_cc(sps, rolloff, ntaps, bw) self.vsnk_src = gr.vector_sink_c() self.vsnk_fll = gr.vector_sink_c() self.vsnk_frq = gr.vector_sink_f() self.vsnk_phs = gr.vector_sink_f() self.vsnk_err = gr.vector_sink_f() self.connect(self.src, self.rrc, self.chn, self.fll, self.vsnk_fll) self.connect(self.rrc, self.vsnk_src) self.connect((self.fll,1), self.vsnk_frq) self.connect((self.fll,2), self.vsnk_phs) self.connect((self.fll,3), self.vsnk_err)
def test_complex_to_arg(self): pi = math.pi input_data = (0, pi / 6, pi / 4, pi / 2, 3 * pi / 4, 7 * pi / 8, -pi / 6, -pi / 4, -pi / 2, -3 * pi / 4, -7 * pi / 8) expected_result = ( 0.0, # 0 0.52382522821426392, # pi/6 0.78539806604385376, # pi/4 1.5707963705062866, # pi/2 2.3561947345733643, # 3pi/4 2.7491819858551025, # 7pi/8 -0.52382522821426392, # -pi/6 -0.78539806604385376, # -pi/4 -1.5707963705062866, # -pi/2 -2.3561947345733643, # -3pi/4 -2.7491819858551025) # -7pi/8 src_data = tuple([math.cos(x) + math.sin(x) * 1j for x in input_data]) src = gr.vector_source_c(src_data) op = gr.complex_to_arg() dst = gr.vector_sink_f() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() actual_result = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, actual_result, 3)
def __init__(self, N, sps, rolloff, ntaps, bw, noise, foffset, toffset, poffset, mode=0): gr.top_block.__init__(self) rrc_taps = gr.firdes.root_raised_cosine(sps, sps, 1.0, rolloff, ntaps) gain = 2 * scipy.pi / 100.0 nfilts = 32 rrc_taps_rx = gr.firdes.root_raised_cosine(nfilts, sps * nfilts, 1.0, rolloff, ntaps * nfilts) data = 2.0 * scipy.random.randint(0, 2, N) - 1.0 data = scipy.exp(1j * poffset) * data self.src = gr.vector_source_c(data.tolist(), False) self.rrc = gr.interp_fir_filter_ccf(sps, rrc_taps) self.chn = gr.channel_model(noise, foffset, toffset) self.off = gr.fractional_interpolator_cc(0.20, 1.0) if mode == 0: self.clk = gr.pfb_clock_sync_ccf(sps, gain, rrc_taps_rx, nfilts, nfilts // 2, 3.5) self.taps = self.clk.get_taps() self.dtaps = self.clk.get_diff_taps() self.vsnk_err = gr.vector_sink_f() self.vsnk_rat = gr.vector_sink_f() self.vsnk_phs = gr.vector_sink_f() self.connect((self.clk, 1), self.vsnk_err) self.connect((self.clk, 2), self.vsnk_rat) self.connect((self.clk, 3), self.vsnk_phs) else: # mode == 1 mu = 0.5 gain_mu = 0.1 gain_omega = 0.25 * gain_mu * gain_mu omega_rel_lim = 0.02 self.clk = digital.clock_recovery_mm_cc(sps, gain_omega, mu, gain_mu, omega_rel_lim) self.vsnk_err = gr.vector_sink_f() self.connect((self.clk, 1), self.vsnk_err) self.vsnk_src = gr.vector_sink_c() self.vsnk_clk = gr.vector_sink_c() self.connect(self.src, self.rrc, self.chn, self.off, self.clk, self.vsnk_clk) self.connect(self.off, self.vsnk_src)
def test_fir_filter_ccc_002(self): self.generate_ccc_source() expected_data = ( (-0.000650451984257 + 0.00120697380044j), (-9.59713361226e-05 + 0.00102412770502j), (0.000958710326813 - 0.00145424995571j), (0.000901343999431 - 0.00290832063183j), (-0.000822560978122 + 0.000296717538731j), (-0.00211223773658 + 0.00519825471565j), (-0.00037001183955 + 0.00358242215589j), (0.00327983591706 - 0.00616005761549j), (0.00356886954978 - 0.0117237549275j), (-0.00328874029219 + 0.00182871113066j), (-0.0139285130426 + 0.0320657044649j), (-0.0198133718222 + 0.0562113076448j), (-0.0157803222537 + 0.0530290603638j), (-0.00550725404173 + 0.0255754813552j), (0.00252919178456 - 0.00232240976766j), (0.00368427345529 - 0.0114002330229j), (0.000506620621309 - 0.00402843113989j), (-0.00180401885882 + 0.00427213776857j), (-0.00122803344857 + 0.00427243299782j), (0.000414476031438 - 0.000383919978049j)) src = gr.vector_source_c(self.src_data) op = filter.freq_xlating_fir_filter_ccc(4, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def transform(self, src_data): SRC = gr.vector_source_c(src_data, False) EQU = digital.cma_equalizer_cc(4, 1.0, .001, 1) DST = gr.vector_sink_c() self.tb.connect(SRC, EQU, DST) self.tb.run() return DST.data()
def __init__(self, dBm, pfa, pfd, useless_bw, plot_histogram): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False self.histogram = plot_histogram primary_user_location = 5 mu = 0 fft_size = 4096 nframes_to_check = 1 nframes_to_average = 1 downconverter = 1 src_data = self.generateRandomSignalSource(dBm, fft_size, mu, nframes_to_check*nframes_to_average) # Blocks src = gr.vector_source_c(src_data) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1) self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,self.histogram,nframes_to_check,nframes_to_average,downconverter) self.sink = gr.vector_sink_f() # Connections self.connect(src, s2v, fftb, self.ss, self.sink)
def test_007_vector_sampler(self): data = range(1,577,1) # 1..576 trigger = numpy.concatenate([[0]*575,[1]]) blocks = 10000 expected = data[64:577] assert(len(expected)==512) expected = numpy.concatenate([expected*blocks]) assert(len(expected) == 512*blocks) src = gr.vector_source_c(data,True) src2 = gr.vector_source_b(trigger.tolist(),True) dst = gr.vector_sink_c() sampler = ofdm.vector_sampler(gr.sizeof_gr_complex,512) v2s = gr.vector_to_stream(gr.sizeof_gr_complex,512) self.fg.connect(src, (sampler,0)) self.fg.connect(src2,gr.head(gr.sizeof_char,blocks*576), (sampler,1)) self.fg.connect(sampler, v2s, dst) self.fg.run() #self.assertEqual(numpy.array(expected,numpy.Complex), numpy.array(dst.data(), numpy.Complex)) if numpy.array(expected).all() != numpy.array(dst.data()).all(): print "up" print len(expected),len(dst.data()) vec = dst.data() for i in range(min(len(expected),len(dst.data()))): if vec[i] != expected[i]: print "e at ",i
def test01(self): # Test complex/complex version omega = 2 gain_omega = 0.001 mu = 0.5 gain_mu = 0.01 omega_rel_lim = 0.001 self.test = digital_swig.clock_recovery_mm_cc(omega, gain_omega, mu, gain_mu, omega_rel_lim) data = 100 * [complex(1, 1)] self.src = gr.vector_source_c(data, False) self.snk = gr.vector_sink_c() self.tb.connect(self.src, self.test, self.snk) self.tb.run() expected_result = 100 * [complex(0.99972, 0.99972)] # doesn't quite get to 1.0 dst_data = self.snk.data() # Only compare last Ncmp samples Ncmp = 30 len_e = len(expected_result) len_d = len(dst_data) expected_result = expected_result[len_e - Ncmp :] dst_data = dst_data[len_d - Ncmp :] # print expected_result # print dst_data self.assertComplexTuplesAlmostEqual(expected_result, dst_data, 5)
def test_001_t (self): """ pretty simple """ fft_len = 6 tx_symbols = (1, 2, 3) pilot_symbols = ((1j,),) occupied_carriers = ((0, 1, 2),) pilot_carriers = ((3,),) expected_result = (1, 2, 3, 1j, 0, 0) mtu = 128 tag_name = "len" tag = gr.gr_tag_t() tag.offset = 0 tag.key = pmt.pmt_string_to_symbol(tag_name) tag.value = pmt.pmt_from_long(len(tx_symbols)) src = gr.vector_source_c(tx_symbols, (tag,), False, 1) alloc = ofdm.carrier_allocator_cvc(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, tag_name) sink = gr.vector_sink_c(fft_len) self.tb.connect(src, alloc, sink) self.tb.run () self.assertEqual(sink.data(), expected_result)
def __init__(self, dBm, pfa, pfd, nTrials): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 fft_size = 4096 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False histogram = False primary_user_location = 0 useless_bw = 200000.0 src_data = [0+0j]*fft_size*nTrials voltage = self.powerToAmplitude(dBm); # Blocks src = gr.vector_source_c(src_data) noise = gr.noise_source_c(gr.GR_GAUSSIAN, voltage, 42) add = gr.add_vcc() s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1) ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram) self.sink = gr.vector_sink_f() # Connections self.connect(src, add, s2v, fftb, ss, self.sink) self.connect(noise, (add, 1))
def test_001_t (self): """ more advanced: - 6 symbols per carrier - 2 pilots per carrier - have enough data for nearly 3 OFDM symbols """ tx_symbols = range(1, 16); pilot_symbols = ((1j, 2j), (3j, 4j)) occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) pilot_carriers = ((2, 13), (3, 12)) expected_result = (0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0) fft_len = 16 mtu = 4096 tag_name = "len" tag = gr.gr_tag_t() tag.offset = 0 tag.key = pmt.pmt_string_to_symbol(tag_name) tag.value = pmt.pmt_from_long(len(tx_symbols)) src = gr.vector_source_c(tx_symbols, (tag,), False, 1) alloc = ofdm.carrier_allocator_cvc(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, tag_name) sink = gr.vector_sink_c(fft_len) self.tb.connect(src, alloc, sink) self.tb.run () self.assertEqual(sink.data(), expected_result)
def test_006_channel_and_carroffset (self): """ Add a channel, check if it's correctly estimated """ fft_len = 16 carr_offset = 2 # Index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 sync_symbol1 = (0, 0, 0, 1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, 0) sync_symbol2 = (0, 0, 0, 1j, -1, 1, -1j, 1j, 0, 1, -1j, -1, -1j, 1, 0, 0) data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0) # Channel 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 # Shifted (0, 0, 0, 0, 0, 1j, -1, 1, -1j, 1j, 0, 1, -1j, -1, -1j, 1) chanest_exp = (0, 0, 0, 5, 6, 7, 8, 9, 0, 11, 12, 13, 14, 15, 0, 0) tx_data = shift_tuple(sync_symbol1, carr_offset) + \ shift_tuple(sync_symbol2, carr_offset) + \ shift_tuple(data_symbol, carr_offset) channel = range(fft_len) src = gr.vector_source_c(tx_data, False, fft_len) chan = gr.multiply_const_vcc(channel) chanest = digital.ofdm_chanest_vcvc(sync_symbol1, sync_symbol2, 1) sink = gr.vector_sink_c(fft_len) self.tb.connect(src, chan, chanest, sink) self.tb.run() tags = sink.tags() chan_est = None for tag in tags: if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_carr_offset': self.assertEqual(pmt.pmt_to_long(tag.value), carr_offset) if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': chan_est = pmt.pmt_c32vector_elements(tag.value) self.assertEqual(chan_est, chanest_exp) self.assertEqual(sink.data(), tuple(numpy.multiply(shift_tuple(data_symbol, carr_offset), channel)))
def ofdmtest (self): options = Options() enc = raw.ofdm_mod(options) dec = raw.ofdm_demod(options, noutputs=2) NN = 4 qpsk = lambda : cmath.exp(1j * (math.pi/NN * (2*random.randint(0, NN-1)+1))) n = enc.params.data_tones * options.size * 1000 data = tuple([qpsk() for i in range(n)]) signal = [0] * options.size signal[0] = 1 signal = tuple(signal) msg = gr.vector_source_b(signal, True, 1) src = gr.vector_source_c(data, False, enc.params.data_tones) dst = gr.vector_sink_c(enc.params.data_tones) self.tb.connect(src, enc, dec, dst) self.tb.connect(msg, (enc,1)) self.tb.run() rxdata = numpy.array(dst.data()) txdata = numpy.array(data[:len(rxdata)]) power = numpy.average(numpy.square(numpy.abs(txdata))) print len(txdata), len(rxdata), power mse = numpy.average(numpy.square(numpy.abs(numpy.subtract(txdata,rxdata)))) self.assertAlmostEquals(1.0, power, 7) snr = 10 * math.log10(power / mse) self.assertTrue(snr > 40) # that's a pretty low estimate for noiseless
def test_quad_demod_001(self): f = 1000.0 fs = 8000.0 src_data = [] for i in xrange(200): ti = i / fs src_data.append(cmath.exp(2j * cmath.pi * f * ti)) # f/fs is a quarter turn per sample. # Set the gain based on this to get 1 out. gain = 1.0 / (cmath.pi / 4) expected_result = [ 0, ] + 199 * [1.0] src = gr.vector_source_c(src_data) op = analog.quadrature_demod_cf(gain) dst = gr.vector_sink_f() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_result, result_data, 5)
def __init__(self, dBm, pfa, pfd, useless_bw): gr.top_block.__init__(self) # Constants samp_rate = 2.4e6 samples_per_band = 16 tcme = 1.9528 output_pfa = True debug_stats = False histogram = True primary_user_location = 0 mu = 0 fft_size = 16 history = 3 src_data = [1+1j]*fft_size*history # Blocks src = gr.vector_source_c(src_data) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size) self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,history) self.sink = gr.vector_sink_f() # Connections self.connect(src, s2v, self.ss, self.sink)
def test_001_detect(self): """ Send two bursts, with zeros in between, and check they are both detected at the correct position and no false alarms occur """ n_zeros = 15 fft_len = 32 cp_len = 4 sig_len = (fft_len + cp_len) * 10 sync_symbol = [(random.randint(0, 1) * 2) - 1 for x in range(fft_len / 2)] * 2 tx_signal = [0,] * n_zeros + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(sig_len)] tx_signal = tx_signal * 2 add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() self.tb.connect(gr.vector_source_c(tx_signal), (add, 0)) self.tb.connect(gr.noise_source_c(gr.GR_GAUSSIAN, .005), (add, 1)) self.tb.connect(add, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() sig1_detect = sink_detect.data()[0:len(tx_signal) / 2] sig2_detect = sink_detect.data()[len(tx_signal) / 2:] self.assertTrue( abs(sig1_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertTrue( abs(sig2_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertEqual(numpy.sum(sig1_detect), 1) self.assertEqual(numpy.sum(sig2_detect), 1)
def test_001_simple(self): """ Standard test """ fft_len = 16 tx_symbols = (0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0) expected_result = tuple(range(1, 16)) + (0, 0, 0) occupied_carriers = ( (1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14), ) n_syms = len(tx_symbols) / fft_len tag_name = "len" tag = gr.gr_tag_t() tag.offset = 0 tag.key = pmt.pmt_string_to_symbol(tag_name) tag.value = pmt.pmt_from_long(n_syms) src = gr.vector_source_c(tx_symbols, False, fft_len, (tag, )) serializer = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, tag_name, "", 0, "", False) sink = gr.vector_sink_c() self.tb.connect(src, serializer, sink) self.tb.run() self.assertEqual(sink.data(), expected_result) self.assertEqual(len(sink.tags()), 1) result_tag = sink.tags()[0] self.assertEqual(pmt.pmt_symbol_to_string(result_tag.key), tag_name) self.assertEqual(pmt.pmt_to_long(result_tag.value), n_syms * len(occupied_carriers[0]))
def test_001(self): frames = 5 config = station_configuration() config.subcarriers = 12 config.data_subcarriers = 8 config.training_data = dummy() config.training_data.shifted_pilot_tones = [1,4,8,11] data = [1.0] * config.subcarriers for x in config.training_data.shifted_pilot_tones: data[x] = 2.0 data = concatenate([data]*frames) ref = [1.0]*(config.data_subcarriers*frames) src = gr.vector_source_c(data) s2v = gr.stream_to_vector(gr.sizeof_gr_complex,config.subcarriers) dst = gr.vector_sink_c() v2s = gr.vector_to_stream(gr.sizeof_gr_complex,config.data_subcarriers) uut = preambles.pilot_subcarrier_filter() self.fg.connect(src,s2v,uut,v2s,dst) self.fg.run() self.assertEqual(ref,list(dst.data()))
def helper(self, v0, v1, fft_length, preamble): tb = self.tb src0 = gr.vector_source_c(v0) src1 = gr.vector_source_b(v1) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length) # print "len(v) = %d" % (len(v)) op = gr.ofdm_insert_preamble(fft_length, preamble) v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_length) dst0 = gr.vector_sink_c() dst1 = gr.vector_sink_b() tb.connect(src0, s2v, (op, 0)) tb.connect(src1, (op, 1)) tb.connect((op, 0), v2s, dst0) tb.connect((op, 1), dst1) tb.run() r0 = dst0.data() r0v = [] for i in range(len(r0) // fft_length): r0v.append(r0[i * fft_length:(i + 1) * fft_length]) r1 = dst1.data() self.assertEqual(len(r0v), len(r1)) return (r1, r0v)
def test_002_static_wo_tags (self): fft_len = 8 # 4 5 6 7 0 1 2 3 tx_data = [-1, -1, 1, 2, -1, 3, 0, -1, # 0 -1, -1, 0, 2, -1, 2, 0, -1, # 8 -1, -1, 3, 0, -1, 1, 0, -1, # 16 (Pilot symbols) -1, -1, 1, 1, -1, 0, 2, -1] # 24 cnst = digital.constellation_qpsk() tx_signal = [cnst.map_to_points_v(x)[0] if x != -1 else 0 for x in tx_data] occupied_carriers = ((1, 2, 6, 7),) pilot_carriers = ((), (), (1, 2, 6, 7), ()) pilot_symbols = ( [], [], [cnst.map_to_points_v(x)[0] for x in (1, 0, 3, 0)], [] ) equalizer = digital.ofdm_equalizer_static(fft_len, occupied_carriers, pilot_carriers, pilot_symbols) channel = [ 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, # These coefficients will be rotated slightly... 0, 0, 1j, 1j, 0, 1j, 1j, 0, # Go crazy here! 0, 0, 1j, 1j, 0, 1j, 1j, 0 # ...and again here. ] for idx in range(fft_len, 2*fft_len): channel[idx] = channel[idx-fft_len] * numpy.exp(1j * .1 * numpy.pi * (numpy.random.rand()-.5)) idx2 = idx+2*fft_len channel[idx2] = channel[idx2] * numpy.exp(1j * 0 * numpy.pi * (numpy.random.rand()-.5)) src = gr.vector_source_c(numpy.multiply(tx_signal, channel), False, fft_len) eq = digital.ofdm_frame_equalizer_vcvc(equalizer.base(), "", False, 4) sink = gr.vector_sink_c(fft_len) self.tb.connect(src, eq, sink) self.tb.run () rx_data = [cnst.decision_maker_v((x,)) if x != 0 else -1 for x in sink.data()] self.assertEqual(tx_data, rx_data)
def test_003_connect (self): """ Connect carrier_allocator to ofdm_serializer, make sure output==input """ fft_len = 8 n_syms = 10 occupied_carriers = ((1, 2, 6, 7),) pilot_carriers = ((3,),(5,)) pilot_symbols = ((1j,),(-1j,)) tx_data = tuple([numpy.random.randint(0, 10) for x in range(4 * n_syms)]) tag_name = "len" tag = gr.gr_tag_t() tag.offset = 0 tag.key = pmt.pmt_string_to_symbol(tag_name) tag.value = pmt.pmt_from_long(len(tx_data)) src = gr.vector_source_c(tx_data, False, 1, (tag,)) alloc = digital.ofdm_carrier_allocator_cvc(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, tag_name) serializer = digital.ofdm_serializer_vcc(alloc) sink = gr.vector_sink_c() self.tb.connect(src, alloc, serializer, sink) self.tb.run () self.assertEqual(sink.data(), tx_data)
def test_001(self): src_data = (1, 2, 3, 4, 5) src_gauss_ch1 = (2, 2, 1, 1, 2) expected_result = (2, 4, 3, 4, 10) src0 = gr.vector_source_c(src_data) src1 = gr.vector_source_c(src_gauss_ch1) mpc_channel = winelo_swig.mpc_channel_cc((0,), (1,)) sink = gr.vector_sink_c() # set up fg self.tb.connect(src0, (mpc_channel, 0)) self.tb.connect(src1, (mpc_channel, 1)) self.tb.connect(mpc_channel, sink) self.tb.run() # check data result_data = sink.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_fir_filter_ccf_002(self): self.generate_ccf_source() expected_data = ((6.419439159799367e-05 - 0.0006292851758189499j), (-0.00037074743886478245 + 0.0013245552545413375j), (0.0006853155209682882 - 0.0023769831750541925j), (-0.001427714480087161 + 0.002608160488307476j), (0.0015907397028058767 - 0.000811046629678458j), (-0.0004226673918310553 - 0.0024389736354351044j), (-0.0013841050677001476 + 0.006231029983609915j), (0.0035029184073209763 - 0.009738259017467499j), (-0.005924836732447147 + 0.010320881381630898j), (0.006831614300608635 - 0.003950652200728655j), (-0.0021247887052595615 - 0.015604906715452671j), (-0.04283163696527481 + 0.09995654970407486j), (-0.01391829177737236 + 0.07924056798219681j), (0.010886997915804386 - 0.02463012933731079j), (-0.0056075905449688435 + 0.004998659715056419j), (0.0016976913902908564 + 0.004312459379434586j), (0.0007344821933656931 - 0.007861112244427204j), (-0.002173811662942171 + 0.007211671676486731j), (0.0022051059640944004 - 0.00402153329923749j), (-0.0011226903880015016 + 0.0009080505697056651j)) src = gr.vector_source_c(self.src_data) op = filter.freq_xlating_fir_filter_ccf(4, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def setUp (self): print "setUp" self.tb = gr.top_block () self.src = gr.vector_source_c([0]*240,False,240) self.demapper = lte_swig.layer_demapper_vcvc(0, "tx_diversity") self.snk = gr.vector_sink_c(240) self.tb.connect(self.src, self.demapper, self.snk)
def test_fir_filter_ccc_001(self): self.generate_ccc_source() expected_data = ( (0.0036842757836 - 0.0114002721384j), (0.00324621866457 - 0.0108166672289j), (0.00206564785913 - 0.00923090614378j), (0.00109899020754 - 0.00656201224774j), (0.000506619049702 - 0.00402844604105j), (-0.000523390364833 - 0.00166808743961j), (-0.00140534969978 + 0.00103991874494j), (-0.00154365820345 + 0.00315759982914j), (-0.00180402118713 + 0.00427215453237j), (-0.00216706306674 + 0.00524478312582j), (-0.00178848754149 + 0.0057489364408j), (-0.00129876169376 + 0.00512680830434j), (-0.00122803379782 + 0.00427244976163j), (-0.000722666736692 + 0.00351428100839j), (5.53092104383e-05 + 0.00207865727134j), (0.000227351076319 + 0.000517217209563j), (0.000414477253798 - 0.000383921898901j), (0.000998671515845 - 0.00135387131013j), (0.00104933069088 - 0.00243046949618j), (0.000765930046327 - 0.0026717747096j)) src = gr.vector_source_c(self.src_data) op = filter.freq_xlating_fir_filter_ccc(1, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_001_simple (self): """ Standard test """ fft_len = 16 tx_symbols = range(1, 16); tx_symbols = (0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0) expected_result = tuple(range(1, 16)) + (0, 0, 0) occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) n_syms = len(tx_symbols)/fft_len tag_name = "len" tag = gr.gr_tag_t() tag.offset = 0 tag.key = pmt.pmt_string_to_symbol(tag_name) tag.value = pmt.pmt_from_long(n_syms) src = gr.vector_source_c(tx_symbols, False, fft_len, (tag,)) serializer = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, tag_name, "", 0, False) sink = gr.vector_sink_c() self.tb.connect(src, serializer, sink) self.tb.run () self.assertEqual(sink.data(), expected_result) self.assertEqual(len(sink.tags()), 1) result_tag = sink.tags()[0] self.assertEqual(pmt.pmt_symbol_to_string(result_tag.key), tag_name) self.assertEqual(pmt.pmt_to_long(result_tag.value), n_syms * len(occupied_carriers[0]))
def setUp (self): self.tb = gr.top_block () mod=scipy.io.loadmat('/home/demel/exchange/matlab_sss.mat') mat_u1=tuple(mod['sss'].flatten()) mat_d=range(len(mat_u1)) for idx, val in enumerate(mat_u1): mat_d[idx]=val intu=tuple(mat_d) fftl = 512 self.daemon = lte_swig.cell_id_daemon() # This is not yet a complete test! It's just for the purpose of testing the decoding and correlating. # Tag handling is not tested. self.src = gr.vector_source_c(intu,False,72) self.tag = lte_swig.sss_tagging_cc(fftl) # calc sink block, which sets some attributes of other blocks. self.calc = lte_swig.sss_calc_vc(self.tag, fftl) self.tb.connect(self.src,self.calc)
def test_quad_demod_001(self): f = 1000.0 fs = 8000.0 src_data = [] for i in xrange(200): ti = i/fs src_data.append(cmath.exp(2j*cmath.pi*f*ti)) # f/fs is a quarter turn per sample. # Set the gain based on this to get 1 out. gain = 1.0/(cmath.pi/4) expected_result = [0,] + 199*[1.0] src = gr.vector_source_c(src_data) op = analog.quadrature_demod_cf(gain) dst = gr.vector_sink_f() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_result, result_data, 5)
def test_002_with_offset (self): """ Standard test, carrier offset """ fft_len = 16 tx_symbols = range(1, 16); tx_symbols = (0, 0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0) carr_offset = 1 # Compare this with tx_symbols from the previous test expected_result = tuple(range(1, 16)) + (0, 0, 0) occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) n_syms = len(tx_symbols)/fft_len tag_name = "len" tag = gr.gr_tag_t() tag.offset = 0 tag.key = pmt.pmt_string_to_symbol(tag_name) tag.value = pmt.pmt_from_long(n_syms) offsettag = gr.gr_tag_t() offsettag.offset = 0 offsettag.key = pmt.pmt_string_to_symbol("ofdm_sync_carr_offset") offsettag.value = pmt.pmt_from_long(carr_offset) src = gr.vector_source_c(tx_symbols, False, fft_len, (tag, offsettag)) serializer = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, tag_name, "", 0, False) sink = gr.vector_sink_c() self.tb.connect(src, serializer, sink) self.tb.run () self.assertEqual(sink.data(), expected_result) self.assertEqual(len(sink.tags()), 2) for tag in sink.tags(): if pmt.pmt_symbol_to_string(tag.key) == tag_name: self.assertEqual(pmt.pmt_to_long(tag.value), n_syms * len(occupied_carriers[0]))