def test_001(self):
vlen = 128
syms = 4
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
ifft = gr.fft_vcc(vlen, False, [], True)
fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen)
vec = numpy.array(numpy.zeros(vlen), numpy.complex)
vec[vlen / 2 - vlen / 4] = 1.0
vec = concatenate([vec] * syms)
src = gr.vector_source_c(vec)
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f([0.0] * syms)
trig = gr.vector_source_b([1] * syms)
self.fg.connect(src, s2v, ifft, (freq_shift, 0))
self.fg.connect(eps, (freq_shift, 1))
self.fg.connect(trig, (freq_shift, 2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual(vec, numpy.array(dst.data()))
def __init__(self):
gr.top_block.__init__(self)
sample_rate = 32000
ampl = 0.1
self._fft_length=96
win = []
#win = [1 for i in range(self._fft_length)]
win2 = [1 for i in range(self._fft_length)]
# Constructing a sine source and the fft blocks
src0 = gr.sig_source_c (sample_rate, gr.GR_SIN_WAVE, 350, ampl)
ss2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._fft_length)
sv2s = gr.vector_to_stream(gr.sizeof_gr_complex, self._fft_length)
fft_demod = gr.fft_vcc(self._fft_length, True, win2, False)
ifft = gr.fft_vcc(self._fft_length, False, win, False)
scale = gr.multiply_const_cc(1.0 / self._fft_length)
# Some output data files
trans_output = gr.file_sink(gr.sizeof_gr_complex, "trans_output.dat")
reg_output = gr.file_sink(gr.sizeof_gr_complex, "reg_output.dat")
# make the connections #
self.connect(src0, ss2v, fft_demod, ifft, sv2s, scale, trans_output)
self.connect(src0, reg_output)
def __init__(self):
gr.top_block.__init__(self)
length = 101
data_r = range(length)
data_i = range(length,2*length)
src_r = gr.vector_source_s(data_r, False)
src_i = gr.vector_source_s(data_i, False)
s2f_r = gr.short_to_float()
s2f_i = gr.short_to_float()
f2c = gr.float_to_complex()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, length)
shift = True
ifft = gr.fft_vcc(length, False, [], shift)
fft = gr.fft_vcc(length, True, [], shift)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, length)
snk_in = gr.file_sink(gr.sizeof_gr_complex, "fftshift.in")
snk_out = gr.file_sink(gr.sizeof_gr_complex, "fftshift.out")
self.connect(src_r, s2f_r, (f2c,0))
self.connect(src_i, s2f_i, (f2c,1))
self.connect(f2c, snk_in)
self.connect(f2c, s2v, ifft, fft, v2s, snk_out)
def test_001 (self):
vlen = 128
syms = 4
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0/vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
ifft = gr.fft_vcc(vlen, False, [], True)
fft_scale = gr.multiply_const_vcc([1.0/vlen]*vlen)
vec = numpy.array(numpy.zeros(vlen), numpy.complex)
vec[vlen/2-vlen/4] = 1.0
vec = concatenate([vec]*syms)
src = gr.vector_source_c(vec)
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f([0.0]*syms)
trig = gr.vector_source_b([1]*syms)
self.fg.connect(src, s2v, ifft, (freq_shift,0))
self.fg.connect(eps, (freq_shift,1))
self.fg.connect(trig, (freq_shift,2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual(vec, numpy.array(dst.data()))
def __init__(self, samplerate, bits_per_sec, fftlen):
gr.hier_block2.__init__(
self,
"gmsk_sync",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
#this is just the old square-and-fft method
#ais.freqest is simply looking for peaks spaced bits-per-sec apart
self.square = gr.multiply_cc(1)
self.fftvect = gr.stream_to_vector(gr.sizeof_gr_complex, fftlen)
self.fft = gr.fft_vcc(fftlen, True, window.rectangular(fftlen), True)
self.freqest = ais.freqest(int(samplerate), int(bits_per_sec), fftlen)
self.repeat = gr.repeat(gr.sizeof_float, fftlen)
self.fm = gr.frequency_modulator_fc(-1.0 / (float(samplerate) /
(2 * pi)))
self.mix = gr.multiply_cc(1)
self.connect(self, (self.square, 0))
self.connect(self, (self.square, 1))
#this is the feedforward branch
self.connect(self, (self.mix, 0))
#this is the feedback branch
self.connect(self.square, self.fftvect, self.fft, self.freqest,
self.repeat, self.fm, (self.mix, 1))
#and this is the output
self.connect(self.mix, self)
def supply_rx_baseband(self):
## RX Spectrum
if self.__dict__.has_key('rx_baseband'):
return self.rx_baseband
config = self.config
fftlen = config.fft_length
my_window = window.hamming(fftlen) #.blackmanharris(fftlen)
rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen)
rxs_trigger = gr.vector_source_b(concatenate([[1],[0]*199]),True)
rxs_window = blocks.multiply_const_vcc(my_window)
rxs_spectrum = gr.fft_vcc(fftlen,True,[],True)
rxs_mag = gr.complex_to_mag(fftlen)
rxs_avg = gr.single_pole_iir_filter_ff(0.01,fftlen)
rxs_logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen))
rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,50)
t = self.u if self.filter is None else self.filter
self.connect(rxs_trigger,(rxs_sampler,1))
self.connect(t,rxs_sampler,rxs_window,
rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate)
if self._options.log:
log_to_file(self, rxs_decimate_rate, "data/supply_rx.float")
self.rx_baseband = rxs_decimate_rate
return rxs_decimate_rate
def setUp(self):
self.tb = gr.top_block()
#print os.getpid()
#raw_input("Press the ANY key!")
offset = 43223 #sample15 = 21839 #sample20 = 43223
fftl = 512
cell_id = 124
N_rb_dl = 6
mod = scipy.io.loadmat(
'/home/demel/exchange/matlab_test_first_freq.mat')
mat_u1 = tuple(mod['test'].flatten())
mat_d = range(len(mat_u1))
for idx, val in enumerate(mat_u1):
mat_d[idx] = val
intu = tuple(mat_d[0:100000])
self.src = gr.vector_source_c(intu, False, 1)
self.tag = lte_swig.tag_symbol_cc(offset, fftl)
self.sel = lte_swig.pss_selector_cvc(fftl)
self.fft = gr.fft_vcc(fftl, True, window.rectangular(fftl), False, 1)
self.ext = lte_swig.extract_occupied_tones_vcvc(N_rb_dl, fftl)
self.tagp = lte.pss_tagging_cc(fftl) # Dummy
self.calc = lte.pss_calc_vc(self.tagp, self.sel, fftl)
#self.snk = gr.vector_sink_c(fftl)
self.tb.connect(self.src, self.tag, self.sel, self.fft, self.ext,
self.calc)
def __init__(self, fs, svn, alpha, fd_range, dump_bins=False):
gr.hier_block2.__init__(self, "acquisition",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(3, 3, gr.sizeof_float))
fft_size = int(1e-3 * fs)
doppler_range = self.get_doppler_range(fd_range)
agc = gr.agc_cc(1.0 / fs, 1.0, 1.0, 1.0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fft = gr.fft_vcc(fft_size, True, [])
argmax = gr.argmax_fs(fft_size)
max = gr.max_ff(fft_size)
self.connect(self, s2v, fft)
self.connect((argmax, 0), gr.short_to_float(), (self, 0))
self.connect((argmax, 1), gr.short_to_float(),
gr.add_const_ff(-fd_range), gr.multiply_const_ff(1e3),
(self, 1))
self.connect(max, (self, 2))
# Connect the individual channels to the input and the output.
self.correlators = [
single_channel_correlator(fs, fd, svn, alpha, dump_bins)
for fd in doppler_range
]
for (correlator, i) in zip(self.correlators,
range(len(self.correlators))):
self.connect(fft, correlator)
self.connect(correlator, (argmax, i))
self.connect(correlator, (max, i))
def publish_rx_spectrum(self,fftlen):
## RX Spectrum
fftlen = 256
my_window = window.hamming(fftlen) #.blackmanharris(fftlen)
rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen)
rxs_trigger = gr.vector_source_b(concatenate([[1],[0]*199]),True)
rxs_window = blocks.multiply_const_vcc(my_window)
rxs_spectrum = gr.fft_vcc(fftlen,True,[],True)
rxs_mag = gr.complex_to_mag(fftlen)
rxs_avg = gr.single_pole_iir_filter_ff(0.01,fftlen)
rxs_logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen))
rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,1)
msgq = gr.msg_queue(5)
rxs_msg_sink = gr.message_sink(gr.sizeof_float*fftlen,msgq,True)
self.connect(rxs_trigger,(rxs_sampler,1))
t = self.u if self.filter is None else self.filter
self.connect(t,rxs_sampler,rxs_window,
rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate,
rxs_msg_sink)
self.servants.append(corba_data_buffer_servant("spectrum",fftlen,msgq))
print "RXS trigger unique id", rxs_trigger.unique_id()
print "Publishing RX baseband under id: spectrum"
def __init__(self,options,Freq): gr.top_block.__init__(self) if options.input_file == "": self.IS_USRP2 = True else: self.IS_USRP2 = False #self.min_freq = options.start #self.max_freq = options.stop self.min_freq = Freq.value-(3*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more self.max_freq = Freq.value+(3*10**6) if self.min_freq > self.max_freq: self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them print "Start and stop frequencies order swapped!" self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 if self.IS_USRP2: self.u = uhd.usrp_source(options.args,uhd.io_type.COMPLEX_FLOAT32,num_channels=1) # Modified Line # self.u.set_decim(options.decim) # samp_rate = self.u.adc_rate()/self.u.decim() samp_rate = 100e6/options.decim # modified sampling rate self.u.set_samp_rate(samp_rate) else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 /options.decim # modified sampling rate self.freq_step =0 #0.75* samp_rate self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) # thread-safe message queue self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) # control scanning and record frequency domain statistics self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2 # if no gain was specified, use the mid-point in dB
def __init__(self, fg, parent, baseband_freq=0,
y_per_div=10, ref_level=100, sample_rate=1, fft_size=512,
fft_rate=20, average=True, avg_alpha=None, title='',
size=default_fftsink_size):
fft_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq,
y_per_div=y_per_div, ref_level=ref_level,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title)
s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, fft_size)
one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * fft_size,
int(sample_rate/fft_size/fft_rate))
mywindow = window.blackmanharris(fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
#fft = gr.fft_vcc(fft_size, True, True)
c2mag = gr.complex_to_mag(fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
log = gr.nlog10_ff(20, fft_size)
sink = gr.file_descriptor_sink(gr.sizeof_float * fft_size, self.w_fd)
fg.connect(s2p, one_in_n, fft, c2mag, self.avg, log, sink)
# gr.hier_block.__init__(self, fg, s2p, sink)
#print self.r_fd
self.fg = fg
self.win = gl_fft_window(self)
def __init__(self, fg, parent, baseband_freq=0,
y_per_div=10, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, peak_hold=False):
fft_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq,
y_per_div=y_per_div, ref_level=ref_level,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title,
peak_hold=peak_hold)
s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
power = 0
for tap in mywindow:
power += tap*tap
fft = gr.fft_vcc(self.fft_size, True, mywindow)
c2mag = gr.complex_to_mag(fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
log = gr.nlog10_ff(20, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
sink = gr.message_sink(gr.sizeof_float * fft_size, self.msgq, True)
fg.connect(s2p, self.one_in_n, fft, c2mag, self.avg, log, sink)
gr.hier_block.__init__(self, fg, s2p, sink)
self.win = fft_window(self, parent, size=size)
self.set_average(self.average)
def __init__(self, parent, baseband_freq=0,
y_per_div=10, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size):
gr.hier_block2.__init__(self, "waterfall_sink_f",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
waterfall_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title)
self.s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = gr.fft_vcc(self.fft_size, True, mywindow)
self.c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
self.sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.avg, self.log, self.sink)
self.win = waterfall_window(self, parent, size=size)
self.set_average(self.average)
def supply_rx_baseband(self):
## RX Spectrum
if self.__dict__.has_key('rx_baseband'):
return self.rx_baseband
config = self.config
fftlen = config.fft_length
my_window = window.hamming(fftlen) #.blackmanharris(fftlen)
rxs_sampler = vector_sampler(gr.sizeof_gr_complex, fftlen)
rxs_trigger = blocks.vector_source_b(concatenate([[1], [0] * 199]),
True)
rxs_window = blocks.multiply_const_vcc(my_window)
rxs_spectrum = gr.fft_vcc(fftlen, True, [], True)
rxs_mag = gr.complex_to_mag(fftlen)
rxs_avg = gr.single_pole_iir_filter_ff(0.01, fftlen)
rxs_logdb = gr.nlog10_ff(20.0, fftlen, -20 * log10(fftlen))
rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float * fftlen, 50)
t = self.u if self.filter is None else self.filter
self.connect(rxs_trigger, (rxs_sampler, 1))
self.connect(t, rxs_sampler, rxs_window, rxs_spectrum, rxs_mag,
rxs_avg, rxs_logdb, rxs_decimate_rate)
if self._options.log:
log_to_file(self, rxs_decimate_rate, "data/supply_rx.float")
self.rx_baseband = rxs_decimate_rate
return rxs_decimate_rate
def test_007(self):
vlen = 128
syms = 4
bin1 = vlen / 2 + 2
bin1_val = 1.0
expec = numpy.array(numpy.zeros(vlen), numpy.complex)
expec[bin1] = bin1_val
expec = concatenate([expec] * syms)
epsilon = [0.5]
frame_trigger = numpy.concatenate([[1], [0] * (syms - 1)])
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen)
src = gr.sig_source_c(vlen, gr.GR_COS_WAVE, 1.5, 1.0, 0.0)
# bin vlen/2 + 1.5
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f(epsilon)
trig = gr.vector_source_b(frame_trigger.tolist())
self.fg.connect(src, s2v, (freq_shift, 0))
self.fg.connect(eps, (freq_shift, 1))
self.fg.connect(trig, (freq_shift, 2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5, 1e-5)
def __init__(self, fs, svn, alpha, fd_range, dump_bins=False):
gr.hier_block2.__init__(self,
"acquisition",
gr.io_signature(1,1, gr.sizeof_gr_complex),
gr.io_signature(3,3, gr.sizeof_float))
fft_size = int( 1e-3*fs)
doppler_range = self.get_doppler_range(fd_range)
agc = gr.agc_cc( 1.0/fs, 1.0, 1.0, 1.0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fft = gr.fft_vcc(fft_size, True, [])
argmax = gr.argmax_fs(fft_size)
max = gr.max_ff(fft_size)
self.connect( self, s2v, fft)
self.connect( (argmax, 0),
gr.short_to_float(),
(self, 0))
self.connect( (argmax,1),
gr.short_to_float(),
gr.add_const_ff(-fd_range),
gr.multiply_const_ff(1e3),
(self,1))
self.connect( max, (self, 2))
# Connect the individual channels to the input and the output.
self.correlators = [ single_channel_correlator( fs, fd, svn, alpha, dump_bins) for fd in doppler_range ]
for (correlator, i) in zip( self.correlators, range(len(self.correlators))):
self.connect( fft, correlator )
self.connect( correlator, (argmax, i) )
self.connect( correlator, (max, i) )
def __init__(self,
N_id_1,
N_id_2,
slot0=True,
N_re=128,
N_cp_ts=144,
freq_corr=0):
top = gr.top_block("foo")
source = gr.vector_source_c(range(0, N_re), False, N_re)
source.set_data(gen_sss_fd(N_id_1, N_id_2, N_re).get_sss(slot0))
fft = gr.fft_vcc(N_re, False, window.blackmanharris(1024), True)
cp = digital.ofdm_cyclic_prefixer(N_re, N_re + N_cp_ts * N_re / 2048)
if freq_corr != 0:
freq_corr = gr.freq_xlating_fir_filter_ccf(1, 1, freq_corr,
15000 * N_re)
sink = gr.vector_sink_c(1)
top.connect(source, fft, cp)
if freq_corr != 0:
top.connect(cp, freq_corr, sink)
else:
top.connect(cp, sink)
top.run()
self.data = sink.data()
def __init__(self,options,Freq): gr.top_block.__init__(self) if options.input_file == "": self.IS_USRP2 = True else: self.IS_USRP2 = False #self.min_freq = options.start #self.max_freq = options.stop self.min_freq = Freq.value-(3*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more self.max_freq = Freq.value+(3*10**6) if self.min_freq > self.max_freq: self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them print "Start and stop frequencies order swapped!" self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 if self.IS_USRP2: self.u = uhd.usrp_source(options.args,uhd.io_type.COMPLEX_FLOAT32,num_channels=1) # Modified Line # self.u.set_decim(options.decim) # samp_rate = self.u.adc_rate()/self.u.decim() samp_rate = 100e6/options.decim # modified sampling rate self.u.set_samp_rate(samp_rate) else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 /options.decim # modified sampling rate self.freq_step =0 #0.75* samp_rate self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step) self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) # thread-safe message queue self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) # control scanning and record frequency domain statistics self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2 # if no gain was specified, use the mid-point in dB
def setUp (self):
self.tb = gr.top_block ()
#print os.getpid()
#raw_input("Press the ANY key!")
offset = 43223 #sample15 = 21839 #sample20 = 43223
fftl = 512
cell_id = 124
N_rb_dl = 6
mod=scipy.io.loadmat('/home/demel/exchange/matlab_test_first_freq.mat')
mat_u1=tuple(mod['test'].flatten())
mat_d=range(len(mat_u1))
for idx, val in enumerate(mat_u1):
mat_d[idx]=val
intu=tuple(mat_d[0:100000])
self.src = gr.vector_source_c(intu,False,1)
self.tag = lte_swig.tag_symbol_cc(offset,fftl)
self.sel = lte_swig.pss_selector_cvc(fftl)
self.fft = gr.fft_vcc(fftl,True,window.rectangular(fftl),False,1)
self.ext = lte_swig.extract_occupied_tones_vcvc(N_rb_dl,fftl)
self.tagp = lte.pss_tagging_cc(fftl) # Dummy
self.calc = lte.pss_calc_vc(self.tagp,self.sel,fftl)
#self.snk = gr.vector_sink_c(fftl)
self.tb.connect(self.src, self.tag, self.sel, self.fft, self.ext, self.calc)
def __init__(self, fg, parent, baseband_freq=0,
ref_level=0, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, report=None, span=40, ofunc=None, xydfunc=None):
waterfall_sink_base.__init__(self, input_is_real=False,
baseband_freq=baseband_freq,
sample_rate=sample_rate,
fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha,
title=title)
s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size)
log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.block_list = (s2p, self.one_in_n, fft, c2mag, self.avg, log, sink)
self.reconnect( fg )
gr.hier_block.__init__(self, fg, s2p, sink)
self.win = waterfall_window(self, parent, size=size, report=report,
ref_level=ref_level, span=span, ofunc=ofunc, xydfunc=xydfunc)
self.set_average(self.average)
def __init__(self, fftl):
"""
This hierarchical block has a complex input and complex output stream. The actual data remains unchanged.
The N_id_2 or cell ID number is calculated.
Based on the position of the PSS the frame structure is calculated on a half frame basis and tagged to the output stream together with N_id_2
A tag with the slot number within a half frame is tagged at the beginning of every slot. (key = slot)
A tag with the N_id_2 is tagged at the beginning of every half frame. (Corresponds to slot 0) (key = N_id_2)
The input data must be tagged with information for symbols. (key = symbol)
the tag propagation policy is set to TPP_DONT.
"""
gr.hier_block2.__init__(
self,
"hier_pss_sync_cc",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
# This is a fixed value due to the fact that the PSS is always located at the 62 center carriers.
N_rb_dl = 6
self.tag = lte.pss_tagging_cc(fftl)
self.sel = lte.pss_selector_cvc(fftl)
self.fft = gr.fft_vcc(fftl, True, window.rectangular(fftl), False, 1)
self.ext = lte.extract_occupied_tones_vcvc(N_rb_dl, fftl)
self.calc = lte.pss_calc_vc(self.tag, self.sel, fftl)
# Define blocks
self.connect(self, self.tag, self)
self.connect(self, self.sel, self.fft, self.ext, self.calc)
def test_007 (self):
vlen = 128
syms = 4
bin1 = vlen/2 + 2
bin1_val = 1.0
expec = numpy.array(numpy.zeros(vlen), numpy.complex)
expec[bin1] = bin1_val
expec = concatenate([expec]*syms)
epsilon = [0.5]
frame_trigger = numpy.concatenate([[1],[0]*(syms-1)])
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0/vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
fft_scale = gr.multiply_const_vcc([1.0/vlen]*vlen)
src = gr.sig_source_c(vlen, gr.GR_COS_WAVE, 1.5, 1.0, 0.0)
# bin vlen/2 + 1.5
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f(epsilon)
trig = gr.vector_source_b(frame_trigger.tolist())
self.fg.connect(src, s2v, (freq_shift,0))
self.fg.connect(eps, (freq_shift,1))
self.fg.connect(trig, (freq_shift,2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5, 1e-5)
def __init__(self, parent, baseband_freq=0,
y_per_div=10, sc_y_per_div=0.5, sc_ref_level=40,
ref_level=50, sample_rate=1, fft_size=512,
fft_rate=15, average=False, avg_alpha=None, title='',
size=default_ra_fftsink_size, peak_hold=False, ofunc=None, xydfunc=None):
gr.hier_block2.__init__(self, "ra_fft_sink_c",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
ra_fft_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq,
y_per_div=y_per_div, sc_y_per_div=sc_y_per_div,
sc_ref_level=sc_ref_level, ref_level=ref_level,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold, ofunc=ofunc,
xydfunc=xydfunc)
s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, fft_size)
one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * fft_size,
max(1, int(sample_rate/fft_size/fft_rate)))
mywindow = window.blackmanharris(fft_size)
fft = gr.fft_vcc(fft_size, True, mywindow)
c2mag = gr.complex_to_mag(fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
log = gr.nlog10_ff(20, fft_size, -20*math.log10(fft_size))
sink = gr.message_sink(gr.sizeof_float * fft_size, self.msgq, True)
self.connect(self, s2p, one_in_n, fft, c2mag, self.avg, log, sink)
self.win = fft_window(self, parent, size=size)
self.set_average(self.average)
def __init__(
self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title="",
size=default_facsink_size,
peak_hold=False,
):
fac_sink_base.__init__(
self,
input_is_real=False,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
ref_level=ref_level,
sample_rate=sample_rate,
fac_size=fac_size,
fac_rate=fac_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold,
)
s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fac_size)
self.one_in_n = gr.keep_one_in_n(
gr.sizeof_gr_complex * self.fac_size, max(1, int(self.sample_rate / self.fac_size / self.fac_rate))
)
# windowing removed ...
fac = gr.fft_vcc(self.fac_size, True, ())
c2mag = gr.complex_to_mag(fac_size)
# Things go off into the weeds if we try for an inverse FFT so a forward FFT will have to do...
fac_fac = gr.fft_vfc(self.fac_size, True, ())
fac_c2mag = gr.complex_to_mag(fac_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fac_size)
log = gr.nlog10_ff(
20, self.fac_size, -20 * math.log10(self.fac_size)
) # - 20*math.log10(norm) ) # - self.avg[0] )
sink = gr.message_sink(gr.sizeof_float * fac_size, self.msgq, True)
self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag, self.avg, log, sink)
# gr.hier_block2.__init__(self, fg, s2p, sink)
self.win = fac_window(self, parent, size=size)
self.set_average(self.average)
self.wxgui_connect(self, s2p)
def __init__(self, fftl):
"""
This hierarchical block has a complex input and complex output stream. The actual data remains unchanged.
The N_id_2 or cell ID number is calculated.
Based on the position of the PSS the frame structure is calculated on a half frame basis and tagged to the output stream together with N_id_2
A tag with the slot number within a half frame is tagged at the beginning of every slot. (key = slot)
A tag with the N_id_2 is tagged at the beginning of every half frame. (Corresponds to slot 0) (key = N_id_2)
The input data must be tagged with information for symbols. (key = symbol)
the tag propagation policy is set to TPP_DONT.
"""
gr.hier_block2.__init__(self, "hier_pss_sync_cc",
gr.io_signature(1,1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1,1, gr.sizeof_gr_complex)) # Output signature
# This is a fixed value due to the fact that the PSS is always located at the 62 center carriers.
N_rb_dl = 6;
self.tag = lte.pss_tagging_cc(fftl)
self.sel = lte.pss_selector_cvc(fftl)
self.fft = gr.fft_vcc(fftl,True,window.rectangular(fftl),False,1)
self.ext = lte.extract_occupied_tones_vcvc(N_rb_dl,fftl)
self.calc = lte.pss_calc_vc(self.tag,self.sel,fftl)
# Define blocks
self.connect(self, self.tag, self)
self.connect(self, self.sel, self.fft, self.ext, self.calc)
def main():
parser = OptionParser(conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
add_options(parser, expert_grp)
(options, args) = parser.parse_args()
fft_length = options.fft_length or 512
file = options.file or "input.compl"
out = options.out or "output.compl"
src = gr.file_source(gr.sizeof_gr_complex, file)
sampler = ofdm.vector_sampler(gr.sizeof_gr_complex, fft_length)
trig = gr.vector_source_b([1], True)
fft = gr.fft_vcc(fft_length, True, [], True)
mag = gr.complex_to_mag(fft_length)
avg = gr.single_pole_iir_filter_ff(0.01, fft_length)
nlog = gr.nlog10_ff(20, fft_length, -10 * math.log10(fft_length))
dst = gr.file_sink(gr.sizeof_float * fft_length, out)
fg = gr.top_block()
fg.connect(src, sampler, fft, mag, avg, nlog, dst)
fg.connect(trig, (sampler, 1))
# fg.connect(src,limit,
# gr.stream_to_vector(gr.sizeof_gr_complex,fft_length),
# fft,
# gr.multiply_const_vcc([1./fft_length]*fft_length),
# gr.complex_to_mag(fft_length),
# gr.nlog10_ff(10.0,fft_length),
# dst)
# fg.connect( src, fft, dst )
fg.run()
print "done"
def main():
parser = OptionParser(conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
add_options(parser, expert_grp)
(options, args) = parser.parse_args ()
fft_length = options.fft_length or 512
file = options.file or "input.compl"
out = options.out or "output.compl"
src = gr.file_source(gr.sizeof_gr_complex,file)
sampler = ofdm.vector_sampler( gr.sizeof_gr_complex, fft_length )
trig = gr.vector_source_b([1],True)
fft = gr.fft_vcc( fft_length, True, [], True )
mag = gr.complex_to_mag( fft_length )
avg = gr.single_pole_iir_filter_ff(0.01, fft_length)
nlog = gr.nlog10_ff( 20, fft_length, -10*math.log10(fft_length) )
dst = gr.file_sink( gr.sizeof_float * fft_length, out )
fg = gr.top_block()
fg.connect( src, sampler, fft, mag, avg, nlog, dst )
fg.connect( trig, (sampler,1))
# fg.connect(src,limit,
# gr.stream_to_vector(gr.sizeof_gr_complex,fft_length),
# fft,
# gr.multiply_const_vcc([1./fft_length]*fft_length),
# gr.complex_to_mag(fft_length),
# gr.nlog10_ff(10.0,fft_length),
# dst)
# fg.connect( src, fft, dst )
fg.run()
print "done"
def __init__(self, parent, baseband_freq=0,
y_per_div=10, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, **kwargs):
gr.hier_block2.__init__(self, "waterfall_sink_f",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
waterfall_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title)
self.s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = gr.fft_vcc(self.fft_size, True, mywindow)
self.c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
self.sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.avg, self.log, self.sink)
self.win = waterfall_window(self, parent, size=size)
self.set_average(self.average)
def __init__(self, decim=16, N_id_1=134, N_id_2=0): grc_wxgui.top_block_gui.__init__(self, title="Sss Corr Gui") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Parameters ################################################## self.decim = decim self.N_id_1 = N_id_1 self.N_id_2 = N_id_2 ################################################## # Variables ################################################## self.sss_start_ts = sss_start_ts = 10608 - 2048 - 144 self.samp_rate = samp_rate = 30720e3/decim ################################################## # Blocks ################################################## self.wxgui_scopesink2_0 = scopesink2.scope_sink_f( self.GetWin(), title="Scope Plot", sample_rate=200, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=1, trig_mode=gr.gr_TRIG_MODE_AUTO, y_axis_label="Counts", ) self.Add(self.wxgui_scopesink2_0.win) self.gr_vector_to_stream_0 = gr.vector_to_stream(gr.sizeof_gr_complex*1, 2048/decim) self.gr_throttle_0 = gr.throttle(gr.sizeof_gr_complex*1, samp_rate*decim) self.gr_stream_to_vector_0 = gr.stream_to_vector(gr.sizeof_gr_complex*1, 2048/decim) self.gr_skiphead_0 = gr.skiphead(gr.sizeof_gr_complex*1, sss_start_ts) self.gr_multiply_const_vxx_0 = gr.multiply_const_vcc((gen_sss_fd(N_id_1, N_id_2, 2048/decim).get_sss_conj_rev())) self.gr_integrate_xx_0 = gr.integrate_cc(2048/decim) self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex*1, "/home/user/git/gr-lte/gr-lte/test/traces/lte_02_796m_30720k_frame.cfile", True) self.gr_fft_vxx_0 = gr.fft_vcc(2048/decim, True, (window.blackmanharris(1024)), True, 1) self.gr_complex_to_mag_0 = gr.complex_to_mag(1) self.fir_filter_xxx_0 = filter.fir_filter_ccc(decim, (firdes.low_pass(1, decim*samp_rate, 550e3, 100e3))) ################################################## # Connections ################################################## self.connect((self.gr_file_source_0, 0), (self.gr_throttle_0, 0)) self.connect((self.gr_stream_to_vector_0, 0), (self.gr_fft_vxx_0, 0)) self.connect((self.gr_fft_vxx_0, 0), (self.gr_multiply_const_vxx_0, 0)) self.connect((self.gr_multiply_const_vxx_0, 0), (self.gr_vector_to_stream_0, 0)) self.connect((self.gr_vector_to_stream_0, 0), (self.gr_integrate_xx_0, 0)) self.connect((self.gr_integrate_xx_0, 0), (self.gr_complex_to_mag_0, 0)) self.connect((self.gr_complex_to_mag_0, 0), (self.wxgui_scopesink2_0, 0)) self.connect((self.gr_throttle_0, 0), (self.gr_skiphead_0, 0)) self.connect((self.gr_skiphead_0, 0), (self.fir_filter_xxx_0, 0)) self.connect((self.fir_filter_xxx_0, 0), (self.gr_stream_to_vector_0, 0))
def __init__(self, dpss, fftshift=False):
gr.hier_block2.__init__(self, "eigenspectrum",
gr.io_signature(1, 1, gr.sizeof_gr_complex*len(dpss)),
gr.io_signature(1, 1, gr.sizeof_float*len(dpss)))
self.window = dpss
self.fft = gr.fft_vcc(len(dpss), True, self.window, fftshift)
self.c2mag = gr.complex_to_mag_squared(len(dpss))
self.connect(self, self.fft, self.c2mag, self)
def __init__(self, dpss, fftshift=False):
gr.hier_block2.__init__(self, "eigenspectrum",
gr.io_signature(1, 1, gr.sizeof_gr_complex*len(dpss)),
gr.io_signature(1, 1, gr.sizeof_float*len(dpss)))
self.window = dpss
self.fft = gr.fft_vcc(len(dpss), True, self.window, fftshift)
self.c2mag = gr.complex_to_mag_squared(len(dpss))
self.connect(self, self.fft, self.c2mag, self)
def __init__(self):
sense_band_start=900*10**6
sense_band_stop=940*10**6
self.fft_size = options.fft_size
self.ofdm_bins = options.sense_bins
# build graph
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
#log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# modifications for USRP2
print "*******************in sensor init********************"
if self.IS_USRP2:
self.u = usrp2.source_32fc(options.interface, options.MAC_addr)
self.u.set_decim(options.decim)
samp_rate = self.u.adc_rate() / self.u.decim()
else:
self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True)
samp_rate = 100e6 / options.decim
self.freq_step =0.75* samp_rate
#self.min_center_freq = (self.min_freq + self.max_freq)/2
global BW
BW = 0.75* samp_rate #self.max_freq - self.min_freq
global size
size=self.fft_size
global ofdm_bins
ofdm_bins = self.ofdm_bins
global usr
#global thrshold_inorder
usr=samp_rate
nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames
print tune_delay
dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames
print dwell_delay
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self)
# hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay,
dwell_delay)
self.connect(self.u, s2v, fft,c2mag,stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.gain_range()
options.gain = float(g[0]+g[1])/2
def __init__(self, options):
gr.top_block.__init__(self)
self._fft_length = 64
win = []
self.source = gr.file_source(gr.sizeof_gr_complex * self._fft_length, options.from_file)
self.ifft = gr.fft_vcc(self._fft_length, True, win, False)
self.sink = gr.file_sink(gr.sizeof_gr_complex * self._fft_length, options.to_file)
self.connect(self.source,self.ifft,self.sink)
def __init__(self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title='',
size=default_facsink_size,
peak_hold=False):
fac_sink_base.__init__(self,
input_is_real=False,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
ref_level=ref_level,
sample_rate=sample_rate,
fac_size=fac_size,
fac_rate=fac_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold)
s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fac_size)
self.one_in_n = gr.keep_one_in_n(
gr.sizeof_gr_complex * self.fac_size,
max(1, int(self.sample_rate / self.fac_size / self.fac_rate)))
# windowing removed ...
fac = gr.fft_vcc(self.fac_size, True, ())
c2mag = gr.complex_to_mag(fac_size)
# Things go off into the weeds if we try for an inverse FFT so a forward FFT will have to do...
fac_fac = gr.fft_vfc(self.fac_size, True, ())
fac_c2mag = gr.complex_to_mag(fac_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fac_size)
log = gr.nlog10_ff(20, self.fac_size, -20 * math.log10(
self.fac_size)) # - 20*math.log10(norm) ) # - self.avg[0] )
sink = gr.message_sink(gr.sizeof_float * fac_size, self.msgq, True)
self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag,
self.avg, log, sink)
# gr.hier_block2.__init__(self, fg, s2p, sink)
self.win = fac_window(self, parent, size=size)
self.set_average(self.average)
self.wxgui_connect(self, s2p)
def __init__(self, decim=16):
grc_wxgui.top_block_gui.__init__(self, title="File Fft")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Parameters
##################################################
self.decim = decim
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
self.fft_size = fft_size = 2048 / decim
self.N_re = N_re = 62
##################################################
# Blocks
##################################################
self.wxgui_scopesink2_0 = scopesink2.scope_sink_c(
self.GetWin(),
title="Scope Plot",
sample_rate=samp_rate,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=gr.gr_TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.Add(self.wxgui_scopesink2_0.win)
self.gr_vector_to_stream_0 = gr.vector_to_stream(
gr.sizeof_gr_complex * 1, fft_size)
self.gr_stream_to_vector_0 = gr.stream_to_vector(
gr.sizeof_gr_complex * 1, fft_size)
self.gr_keep_m_in_n_0 = gr.keep_m_in_n(gr.sizeof_gr_complex, N_re,
fft_size, (fft_size - N_re) / 2)
self.gr_file_source_0 = gr.file_source(
gr.sizeof_gr_complex * 1,
"/home/user/git/gr-lte/gr-lte/test/foo_pss0_sss_in.cfile", True)
self.gr_fft_vxx_0 = gr.fft_vcc(fft_size, True,
(window.blackmanharris(1024)), True, 1)
##################################################
# Connections
##################################################
self.connect((self.gr_stream_to_vector_0, 0), (self.gr_fft_vxx_0, 0))
self.connect((self.gr_file_source_0, 0),
(self.gr_stream_to_vector_0, 0))
self.connect((self.gr_vector_to_stream_0, 0),
(self.gr_keep_m_in_n_0, 0))
self.connect((self.gr_fft_vxx_0, 0), (self.gr_vector_to_stream_0, 0))
self.connect((self.gr_keep_m_in_n_0, 0), (self.wxgui_scopesink2_0, 0))
def test_006(self):
vlen = 128
syms = 4
bin1 = vlen / 2 - vlen / 4
bin2 = vlen / 2 + vlen / 3
bin1_val = 1.0j
bin2_val = -1.0
vec = numpy.array(numpy.zeros(vlen), numpy.complex)
vec[bin1] = bin1_val
vec[bin2] = bin2_val
vec = concatenate([vec] * syms)
epsilon = [1, -4, 5, 2]
frame_trigger = [1] * syms
expec = numpy.array(numpy.zeros(vlen * syms), numpy.complex)
for i in range(syms):
expec[bin1 + i * vlen + epsilon[i]] = bin1_val
expec[bin2 + i * vlen + epsilon[i]] = bin2_val
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
ifft = gr.fft_vcc(vlen, False, [], True)
fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen)
src = gr.vector_source_c(vec)
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f(epsilon)
trig = gr.vector_source_b(frame_trigger)
self.fg.connect(src, s2v, ifft, (freq_shift, 0))
self.fg.connect(eps, (freq_shift, 1))
self.fg.connect(trig, (freq_shift, 2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5)
def test_006 (self):
vlen = 128
syms = 4
bin1 = vlen/2-vlen/4
bin2 = vlen/2+vlen/3
bin1_val = 1.0j
bin2_val = -1.0
vec = numpy.array(numpy.zeros(vlen), numpy.complex)
vec[bin1] = bin1_val
vec[bin2] = bin2_val
vec = concatenate([vec]*syms)
epsilon = [1,-4,5,2]
frame_trigger = [1]*syms
expec = numpy.array(numpy.zeros(vlen*syms), numpy.complex)
for i in range(syms):
expec[bin1+i*vlen+epsilon[i]] = bin1_val
expec[bin2+i*vlen+epsilon[i]] = bin2_val
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0/vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
ifft = gr.fft_vcc(vlen, False, [], True)
fft_scale = gr.multiply_const_vcc([1.0/vlen]*vlen)
src = gr.vector_source_c(vec)
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f(epsilon)
trig = gr.vector_source_b(frame_trigger)
self.fg.connect(src, s2v, ifft, (freq_shift,0))
self.fg.connect(eps, (freq_shift,1))
self.fg.connect(trig, (freq_shift,2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5)
def test_003(self):
# Same test as above, only use 2 threads
tb = gr.top_block()
fft_size = 32
tmp_data = ((4377+4516j),
(-1706.1268310546875+1638.4256591796875j),
(-915.2083740234375+660.69427490234375j),
(-660.370361328125+381.59600830078125j),
(-499.96044921875+238.41630554199219j),
(-462.26748657226562+152.88948059082031j),
(-377.98440551757812+77.5928955078125j),
(-346.85821533203125+47.152004241943359j),
(-295+20j),
(-286.33609008789062-22.257017135620117j),
(-271.52999877929688-33.081821441650391j),
(-224.6358642578125-67.019538879394531j),
(-244.24473571777344-91.524826049804688j),
(-203.09068298339844-108.54627227783203j),
(-198.45195007324219-115.90768432617188j),
(-182.97744750976562-128.12318420410156j),
(-167-180j),
(-130.33688354492188-173.83778381347656j),
(-141.19784545898438-190.28807067871094j),
(-111.09677124023438-214.48896789550781j),
(-70.039543151855469-242.41630554199219j),
(-68.960540771484375-228.30015563964844j),
(-53.049201965332031-291.47097778320312j),
(-28.695289611816406-317.64553833007812j),
(57-300j),
(45.301143646240234-335.69509887695312j),
(91.936195373535156-373.32437133789062j),
(172.09465026855469-439.275146484375j),
(242.24473571777344-504.47515869140625j),
(387.81732177734375-666.6788330078125j),
(689.48553466796875-918.2142333984375j),
(1646.539306640625-1694.1956787109375j))
src_data = tuple([x/fft_size for x in tmp_data])
expected_result = tuple([complex(primes[2*i], primes[2*i+1]) for i in range(fft_size)])
nthreads = 2
src = gr.vector_source_c(src_data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fft = gr.fft_vcc(fft_size, False, [], False, nthreads)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_size)
dst = gr.vector_sink_c()
tb.connect(src, s2v, fft, v2s, dst)
tb.run()
result_data = dst.data()
self.assert_fft_ok2(expected_result, result_data)
def __init__( self, vlen ):
gr.hier_block2.__init__( self,
"scaled_fft",
gr.io_signature( 1, 1, gr.sizeof_gr_complex * vlen ),
gr.io_signature( 1, 1, gr.sizeof_gr_complex * vlen ) )
fft = gr.fft_vcc( vlen, True, [], True )
fft_scale = gr.multiply_const_vcc( [1.0/vlen]*vlen )
self.connect( self, fft, fft_scale, self )
def test_003(self):
# Same test as above, only use 2 threads
tb = gr.top_block()
fft_size = 32
tmp_data = ((4377+4516j),
(-1706.1268310546875+1638.4256591796875j),
(-915.2083740234375+660.69427490234375j),
(-660.370361328125+381.59600830078125j),
(-499.96044921875+238.41630554199219j),
(-462.26748657226562+152.88948059082031j),
(-377.98440551757812+77.5928955078125j),
(-346.85821533203125+47.152004241943359j),
(-295+20j),
(-286.33609008789062-22.257017135620117j),
(-271.52999877929688-33.081821441650391j),
(-224.6358642578125-67.019538879394531j),
(-244.24473571777344-91.524826049804688j),
(-203.09068298339844-108.54627227783203j),
(-198.45195007324219-115.90768432617188j),
(-182.97744750976562-128.12318420410156j),
(-167-180j),
(-130.33688354492188-173.83778381347656j),
(-141.19784545898438-190.28807067871094j),
(-111.09677124023438-214.48896789550781j),
(-70.039543151855469-242.41630554199219j),
(-68.960540771484375-228.30015563964844j),
(-53.049201965332031-291.47097778320312j),
(-28.695289611816406-317.64553833007812j),
(57-300j),
(45.301143646240234-335.69509887695312j),
(91.936195373535156-373.32437133789062j),
(172.09465026855469-439.275146484375j),
(242.24473571777344-504.47515869140625j),
(387.81732177734375-666.6788330078125j),
(689.48553466796875-918.2142333984375j),
(1646.539306640625-1694.1956787109375j))
src_data = tuple([x/fft_size for x in tmp_data])
expected_result = tuple([complex(primes[2*i], primes[2*i+1]) for i in range(fft_size)])
nthreads = 2
src = gr.vector_source_c(src_data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fft = gr.fft_vcc(fft_size, False, [], False, nthreads)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_size)
dst = gr.vector_sink_c()
tb.connect(src, s2v, fft, v2s, dst)
tb.run()
result_data = dst.data()
self.assert_fft_ok2(expected_result, result_data)
def publish_spectrum(self,fftlen):
spectrum = gr.fft_vcc(fftlen,True,[],True)
mag = gr.complex_to_mag(fftlen)
logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen))
decimate_rate = gr.keep_one_in_n(gr.sizeof_gr_complex*fftlen,10)
msgq = gr.msg_queue(10)
msg_sink = gr.message_sink(gr.sizeof_float*fftlen,msgq,True)
self.connect(self.filter,gr.stream_to_vector(gr.sizeof_gr_complex,fftlen),
decimate_rate,spectrum,mag,logdb,msg_sink)
self.servants.append(corba_data_buffer_servant("tx_spectrum",fftlen,msgq))
def test_002(self):
vlen = 128
syms = 4
vec = numpy.array(numpy.zeros(vlen), numpy.complex)
vec[vlen / 2 - vlen / 4] = 1.0
vec = concatenate([vec] * syms)
epsilon = [-1]
frame_trigger = numpy.concatenate([[1], [0] * (syms - 1)])
expec = numpy.array(numpy.zeros(vlen * syms), numpy.complex)
for i in range(syms):
expec[vlen / 2 - vlen / 4 + i * vlen + epsilon[0]] = 1.0
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
ifft = gr.fft_vcc(vlen, False, [], True)
fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen)
src = gr.vector_source_c(vec)
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f(epsilon)
trig = gr.vector_source_b(frame_trigger.tolist())
self.fg.connect(src, s2v, ifft, (freq_shift, 0))
self.fg.connect(eps, (freq_shift, 1))
self.fg.connect(trig, (freq_shift, 2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-6)
def test_002 (self):
vlen = 128
syms = 4
vec = numpy.array(numpy.zeros(vlen), numpy.complex)
vec[vlen/2-vlen/4] = 1.0
vec = concatenate([vec]*syms)
epsilon = [-1]
frame_trigger = numpy.concatenate([[1],[0]*(syms-1)])
expec = numpy.array(numpy.zeros(vlen*syms), numpy.complex)
for i in range(syms):
expec[vlen/2-vlen/4+i*vlen+epsilon[0]] = 1.0
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0/vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
ifft = gr.fft_vcc(vlen, False, [], True)
fft_scale = gr.multiply_const_vcc([1.0/vlen]*vlen)
src = gr.vector_source_c(vec)
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f(epsilon)
trig = gr.vector_source_b(frame_trigger.tolist())
self.fg.connect(src, s2v, ifft, (freq_shift,0))
self.fg.connect(eps, (freq_shift,1))
self.fg.connect(trig, (freq_shift,2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-6)
def __init__(self, decim=16): grc_wxgui.top_block_gui.__init__(self, title="File Fft") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Parameters ################################################## self.decim = decim ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 self.fft_size = fft_size = 2048/decim self.N_re = N_re = 62 ################################################## # Blocks ################################################## self.wxgui_scopesink2_0 = scopesink2.scope_sink_c( self.GetWin(), title="Scope Plot", sample_rate=samp_rate, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=1, trig_mode=gr.gr_TRIG_MODE_AUTO, y_axis_label="Counts", ) self.Add(self.wxgui_scopesink2_0.win) self.gr_vector_to_stream_0 = gr.vector_to_stream(gr.sizeof_gr_complex*1, fft_size) self.gr_stream_to_vector_0 = gr.stream_to_vector(gr.sizeof_gr_complex*1, fft_size) self.gr_keep_m_in_n_0 = gr.keep_m_in_n(gr.sizeof_gr_complex, N_re, fft_size, (fft_size-N_re)/2) self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex*1, "/home/user/git/gr-lte/gr-lte/test/foo_pss0_sss_in.cfile", True) self.gr_fft_vxx_0 = gr.fft_vcc(fft_size, True, (window.blackmanharris(1024)), True, 1) ################################################## # Connections ################################################## self.connect((self.gr_stream_to_vector_0, 0), (self.gr_fft_vxx_0, 0)) self.connect((self.gr_file_source_0, 0), (self.gr_stream_to_vector_0, 0)) self.connect((self.gr_vector_to_stream_0, 0), (self.gr_keep_m_in_n_0, 0)) self.connect((self.gr_fft_vxx_0, 0), (self.gr_vector_to_stream_0, 0)) self.connect((self.gr_keep_m_in_n_0, 0), (self.wxgui_scopesink2_0, 0))
def __init__(self, mpoints, taps=None):
"""
Takes 1 complex stream in, produces M complex streams out
that runs at 1/M times the input sample rate
@param mpoints: number of freq bins/interpolation factor/subbands
@param taps: filter taps for subband filter
Same channel to frequency mapping as described above.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(
self,
"analysis_filterbank",
gr.io_signature(1, 1, item_size), # Input signature
gr.io_signature(mpoints, mpoints, item_size),
) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0,)
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
# print >> sys.stderr, "mpoints =", mpoints, "len(sub_taps) =", len(sub_taps)
self.s2ss = gr.stream_to_streams(item_size, mpoints)
# filters here
self.ss2v = gr.streams_to_vector(item_size, mpoints)
self.fft = gr.fft_vcc(mpoints, True, [])
self.v2ss = gr.vector_to_streams(item_size, mpoints)
self.connect(self, self.s2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = gr.fft_filter_ccc(1, sub_taps[mpoints - i - 1])
self.connect((self.s2ss, i), f)
self.connect(f, (self.ss2v, i))
self.connect((self.v2ss, i), (self, i))
self.connect(self.ss2v, self.fft, self.v2ss)
def __init__(self, mpoints, taps=None):
"""
Takes 1 complex stream in, produces M complex streams out
that runs at 1/M times the input sample rate
@param mpoints: number of freq bins/interpolation factor/subbands
@param taps: filter taps for subband filter
Same channel to frequency mapping as described above.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(
self,
"analysis_filterbank",
gr.io_signature(1, 1, item_size), # Input signature
gr.io_signature(mpoints, mpoints, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0, )
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
# print >> sys.stderr, "mpoints =", mpoints, "len(sub_taps) =", len(sub_taps)
self.s2ss = gr.stream_to_streams(item_size, mpoints)
# filters here
self.ss2v = gr.streams_to_vector(item_size, mpoints)
self.fft = gr.fft_vcc(mpoints, True, [])
self.v2ss = gr.vector_to_streams(item_size, mpoints)
self.connect(self, self.s2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = gr.fft_filter_ccc(1, sub_taps[mpoints - i - 1])
self.connect((self.s2ss, i), f)
self.connect(f, (self.ss2v, i))
self.connect((self.v2ss, i), (self, i))
self.connect(self.ss2v, self.fft, self.v2ss)
def __init__(self, options):
"""
@param options: parsed raw.ofdm_params
"""
self.params = ofdm_params(options)
params = self.params
gr.hier_block2.__init__(
self,
"ofdm_mod",
gr.io_signature2(2, 2, gr.sizeof_gr_complex * params.data_tones,
gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
win = [] #[1 for i in range(self._fft_length)]
# see gr_fft_vcc_fftw that it works differently if win = [1 1 1 ...]
self.mapper = raw.ofdm_mapper(params.padded_carriers)
self.preambles = digital.ofdm_insert_preamble(params.fft_length,
params.padded_preambles)
self.ifft = gr.fft_vcc(params.fft_length, False, win, True)
self.cp_adder = digital.ofdm_cyclic_prefixer(
params.fft_length, params.fft_length + params.cp_length)
self.scale = gr.multiply_const_cc(1.0 / math.sqrt(params.fft_length))
self.connect((self, 0), self.mapper, (self.preambles, 0))
self.connect((self, 1), (self.preambles, 1))
self.connect(self.preambles, self.ifft, self.cp_adder, self.scale,
self)
if options.log:
self.connect(
self.mapper,
gr.file_sink(gr.sizeof_gr_complex * params.fft_length,
"tx-map.dat"))
self.connect(
self.preambles,
gr.file_sink(gr.sizeof_gr_complex * params.fft_length,
"tx-pre.dat"))
self.connect(
self.ifft,
gr.file_sink(gr.sizeof_gr_complex * params.fft_length,
"tx-ifft.dat"))
self.connect(self.cp_adder,
gr.file_sink(gr.sizeof_gr_complex, "tx-cp.dat"))
def __init__(self, N_id_2, N_re=128, N_cp_ts=144, freq_corr=0, repeat=False):
gr.hier_block2.__init__(
self, "PSS source time-domain",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_gr_complex),
)
self.pss_fd = pss_source_fd(N_id_2, N_re, repeat);
self.fft = gr.fft_vcc(N_re, False, window.blackmanharris(1024), True)
self.cp = digital.ofdm_cyclic_prefixer(N_re, N_re+N_cp_ts*N_re/2048)
if freq_corr != 0:
self.freq_corr = gr.freq_xlating_fir_filter_ccf(1, 1, freq_corr, 15000*N_re)
self.connect(self.pss_fd, self.fft, self.cp)
if freq_corr != 0:
self.connect(self.cp, self.freq_corr, self)
else:
self.connect(self.cp, self)
def __init__(self): gr.top_block.__init__(self) gain=0.7 target_freq=930e6 decim=16 interface="" MAC_addr="" fft_size=512 self.u = usrp2.source_32fc() self.u.set_decim(128) self.u.set_center_freq(930e6) self.u.set_gain(0) self.u.config_mimo(usrp2.MC_WE_DONT_LOCK) self.s2v = gr.stream_to_vector(gr.sizeof_gr_complex*1, 512) self.f_sink = gr.file_sink(gr.sizeof_gr_complex*512, "fft_data") self.f_sink.set_unbuffered(False) self.fft = gr.fft_vcc(512, True, (window.blackmanharris(512)), True) self.connect(self.u,self.s2v,self.fft,self.f_sink)
def __init__(self, N_id_1, N_id_2, slot0=True, N_re=128, N_cp_ts=144, freq_corr=0):
top = gr.top_block("foo");
source = gr.vector_source_c(range(0,N_re), False, N_re)
source.set_data(gen_sss_fd(N_id_1, N_id_2, N_re).get_sss(slot0));
fft = gr.fft_vcc(N_re, False, window.blackmanharris(1024), True)
cp = digital.ofdm_cyclic_prefixer(N_re, N_re+N_cp_ts*N_re/2048)
if freq_corr != 0:
freq_corr = gr.freq_xlating_fir_filter_ccf(1, 1, freq_corr, 15000*N_re)
sink = gr.vector_sink_c(1)
top.connect(source, fft, cp)
if freq_corr != 0:
top.connect(cp, freq_corr, sink)
else:
top.connect(cp, sink)
top.run()
self.data = sink.data()
def __init__(self, fs, fd, svn, alpha, dump_bins=False):
fft_size = int(1e-3 * fs)
gr.hier_block2.__init__(
self, "single_channel_correlator",
gr.io_signature(1, 1, gr.sizeof_gr_complex * fft_size),
gr.io_signature(1, 1, gr.sizeof_float * fft_size))
lc = local_code(svn=svn, fs=fs, fd=fd)
mult = gr.multiply_vcc(fft_size)
ifft = gr.fft_vcc(fft_size, False, [])
mag = gr.complex_to_mag_squared(fft_size)
self.iir = gr.single_pole_iir_filter_ff(alpha, fft_size)
self.connect(self, (mult, 0))
self.connect(lc, (mult, 1))
self.connect(mult, ifft, mag, self.iir, self)
if dump_bins == True:
self.connect_debug_sink(self.iir, fft_size,
'/home/trondd/opengnss_output', fd)
def __init__(self, daemon, fftl):
"""
docstring
"""
gr.hier_block2.__init__(
self,
"hier_sss_sync_cc",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
# input goes into 2 blocks: selector and tagging
# 2 parallel streams: main (all data) right into tagging, sss symbol -> fft -> extract -> calc sss
# required blocks:
# selector
# fft
# resize (extract)
# calc sss
# tagging
# SSS selector block
self.sel = lte_swig.sss_selector_cvc(fftl)
# in this block N_rb_dl is fixed. SSS is always mapped to those carriers.
N_rb_dl = 6
# fft block and matching extract block
# input : vector with size: gr_complex * fftl
# output: vector with size: gr_complex * 12 * N_rb_dl
self.fft = gr.fft_vcc(fftl, True, window.rectangular(fftl), False, 1)
self.ext = lte_swig.extract_occupied_tones_vcvc(N_rb_dl, fftl)
self.tag = lte_swig.sss_tagging_cc(fftl)
# calc sink block, which sets some attributes of other blocks.
self.calc = lte_swig.sss_calc_vci(self.tag, daemon, fftl)
# Connect blocks
self.connect(self, self.tag, self)
self.connect(self, self.sel, self.fft, self.ext, self.calc)
def __init__(self,
fft_length,
cp_length,
occupied_tones,
snr,
logging=False):
"""
Hierarchical block for receiving OFDM symbols.
The input is the complex modulated signal at baseband.
Synchronized packets are sent back to the demodulator.
@param fft_length: total number of subcarriers
@type fft_length: int
@param cp_length: length of cyclic prefix as specified in subcarriers (<= fft_length)
@type cp_length: int
@param occupied_tones: number of subcarriers used for data
@type occupied_tones: int
@param snr: estimated signal to noise ratio used to guide cyclic prefix synchronizer
@type snr: float
@param logging: turn file logging on or off
@type logging: bool
"""
gr.hier_block2.__init__(
self,
"ofdm_receiver",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_gr_complex * fft_length,
gr.sizeof_char * fft_length)) # Output signature
bw = (float(occupied_tones) / float(fft_length)) / 2.0
tb = bw * 0.08
chan_coeffs = gr.firdes.low_pass(
1.0, # gain
1.0, # sampling rate
bw + tb, # midpoint of trans. band
tb, # width of trans. band
gr.firdes.WIN_HAMMING) # filter type
#self.chan_filt = gr.fft_filter_ccc(1, chan_coeffs)
self.chan_filt = gr.multiply_cc(1)
win = [1 for i in range(fft_length)]
ks0time = fft_length * (0, )
SYNC = "ml"
if SYNC == "ml":
#TODO -1.0/...
nco_sensitivity = -1.0 / fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_ml.ofdm_sync_ml(fft_length, cp_length,
snr, ks0time, logging)
elif SYNC == "pn":
nco_sensitivity = -2.0 / fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_pn.ofdm_sync_pn(fft_length, cp_length,
logging)
elif SYNC == "pnac":
nco_sensitivity = -2.0 / fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_pnac.ofdm_sync_pnac(
fft_length, cp_length, ks0time, logging)
# for testing only; do not user over the air
# remove filter and filter delay for this
elif SYNC == "fixed":
self.chan_filt = gr.multiply_const_cc(1.0)
nsymbols = 18 # enter the number of symbols per packet
freq_offset = 0.0 # if you use a frequency offset, enter it here
nco_sensitivity = -2.0 / fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_fixed.ofdm_sync_fixed(
fft_length, cp_length, nsymbols, freq_offset, logging)
# Set up blocks
#self.grnull = gr.null_sink(4);
self.nco = gr.frequency_modulator_fc(
nco_sensitivity
) # generate a signal proportional to frequency error of sync block
self.sigmix = gr.multiply_cc()
self.sampler = digital_swig.ofdm_sampler(fft_length,
fft_length + cp_length)
self.fft_demod = gr.fft_vcc(fft_length, True, win, True)
self.connect(self, self.chan_filt) # filter the input channel
self.connect(self.chan_filt,
self.ofdm_sync) # into the synchronization alg.
self.connect(
(self.ofdm_sync, 0), self.nco,
(self.sigmix,
1)) # use sync freq. offset output to derotate input signal
self.connect(self.chan_filt,
(self.sigmix, 0)) # signal to be derotated
self.connect(
self.sigmix,
(self.sampler, 0)) # sample off timing signal detected in sync alg
#self.connect(self.chan_filt, (self.sampler,0)) # sample off timing signal detected in sync alg
self.connect((self.ofdm_sync, 1),
(self.sampler, 1)) # timing signal to sample at
self.connect((self.sampler, 0),
self.fft_demod) # send derotated sampled signal to FFT
self.connect(self.fft_demod,
(self, 0)) # frequency domain signal sent to output 0
self.connect((self.sampler, 1), (self, 1)) # timing sent to output 1
print "setup OK"
logging = 0
if logging:
self.connect(
self.chan_filt,
gr.file_sink(gr.sizeof_gr_complex,
"ofdm_receiver-chan_filt_c.dat"))
self.connect((self.ofdm_sync, 0),
gr.file_sink(gr.sizeof_float,
"ofdm_receiver-sync_0.dat"))
self.connect((self.ofdm_sync, 1),
gr.file_sink(gr.sizeof_char,
"ofdm_receiver-sync_1.dat"))
self.connect(
self.nco,
gr.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-nco_c.dat"))
self.connect(
self.sigmix,
gr.file_sink(gr.sizeof_gr_complex,
"ofdm_receiver-sigmix_c.dat"))
self.connect((self.sampler, 0),
gr.file_sink(gr.sizeof_gr_complex * fft_length,
"ofdm_receiver-sampler_0.dat"))
self.connect((self.sampler, 1),
gr.file_sink(gr.sizeof_char * fft_length,
"ofdm_receiver-sampler_1.dat"))
self.connect(
self.fft_demod,
gr.file_sink(gr.sizeof_gr_complex * fft_length,
"ofdm_receiver-fft_out_c.dat"))
