Hello!
I’m doing a project where i need to tune a signal around 10.7Mhz, and
then
start making a capture to a file.
So I need to the a tuner which searches for the correct center
frequency, so
that I can narrow the sampling band as much as possible.
The idea I’m trying to implement is a two step search.
On the first I use a 250khz band using only USRP decimation, and a 4096
points fft. This way the center frequency has an accuracy of about
120hz.
On the second step I narrow the band to 25kHz, decimating 10 times the
signal
from the usrp using software decimation. It’s implemented using
gr.keep_one_in_n(type,10). Keeping the same FFT size there should be an
error of about 12hz.
Now the problem is this: the estimation from the first step is closer to
the
real value, read on a spectrum analyzer, than the one in the second.
Since I have the same number of points for the FFT, shouldn’t the
resolution
per bin be 10 times better because the bandwidth is 10 times narrower?
Do I need to change the way I’m decimating the signal? (Not using
keep_one_in_n …)
Why am I getting poorer results?
This is the 2-step tuner I have for now:
#//////////////////////////////////////////////////////////
Set initial values so start signal search with the tunner
#//////////////////////////////////////////////////////////
cf = 10.701200e6 # center frequency
fs = 250.0e3 # sampling frequency
fsize = 4096 # number of point on the FFT
print
print “Initilizing Tunner…”
tb = tunner(cf, fs, fsize)
print “1st Search…”
tb.start()
Waiting period, to avoid initial flunctuations
time.sleep(5)
Get 500 samples to make the first estimation
while(len(tb.v_sink.out_freq()) < 30):
pass
tb.stop()
tb.wait()
print “Search done!”
Make evaluation
@ get magnitude vector
@ get frequency vector
print “Evaluating…”
mg = scipy.array(tb.v_sink2.out_mag())
fq = scipy.array(tb.v_sink.out_freq())
print “MAG:”, mg
print “FREQ:”, fq
if mg.mean() > -10:
cf = fq.mean()
print "Center Frequency = ", cf
print
elif mg.mean() <= -10:
print “Not enough power!!”
print
#//////////////////////////////////////////////////////
Set values to fine tunne the frequency before capture
#//////////////////////////////////////////////////////
tb = None
cf = 10.701200e6
fs = 25.0e3
fsize = 4096
print
print “Initilizing Tunner…”
tb = tunner(cf, fs, fsize)
print “2nd Search…”
tb.start()
Waiting period, to avoid initial flunctuations
time.sleep(5)
Get 30 samples to make the first estimation
while(len(tb.v_sink.out_freq()) < 30):
pass
tb.stop()
tb.wait()
print “Search done!”
Make evaluation
@ get magnitude vector
@ get frequency vector
print “Evaluating…”
mg = scipy.array(tb.v_sink2.out_mag())
fq = scipy.array(tb.v_sink.out_freq())
print “MAG:”, mg
print “FREQ:”, fq
if mg.mean() > -10:
cf = fq.mean()
print "Center Frequency = ", cf
print
elif mg.mean() <= -10:
print “Not enough power!!”
And this is the part of the init that concerns the decimation:
(buffer_sink is a block made by me that implement a circular buffer to
store
values)
class tunner(gr.top_block):
def init(self, center_frequency, sampling_frequency, fft_size):
gr.top_block.init(self)
(....)
full_decim = int(64e6/sampling_frequency)
print "FULL DECIM = ", full_decim
if full_decim > 256:
decim = 256
sw_decim = gr.keep_one_in_n(gr.sizeof_gr_complex,
int(250e3/sampling_frequency))
print "SW = ", int(250e3/sampling_frequency)
elif full_decim <= 256:
decim = full_decim
sw_decim = gr.keep_one_in_n(gr.sizeof_gr_complex, 1)
print “SW = 0”
(....)
self.connect(self.u, sw_decim, ss2v, fft, c2m, (imax,0),
s2f1, self.buffer_sink)
self.connect((imax,1), s2f2, p1)
View this message in context:
http://www.nabble.com/Software-Decimation---problem-estimating-frequency-tp22804977p22804977.html
Sent from the GnuRadio mailing list archive at Nabble.com.
