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. _______________________________________________ Discuss-gnuradio mailing list Discuss-gnuradio@gnu.org http://lists.gnu.org/mailman/listinfo/discuss-gnuradio