[Discuss-gnuradio] fxpt_nco vs rotator ?

[madengr]

I'm experimenting with very fine frequency measurements (i.e. uHz resolution)
at high sample rates.  For instance, down-converting all the WWV signals
from a 100 Msps chunk of HF spectrum to near 0 Hz then comparing their
drift.

I have a handle on the DDC within the USRP and the sig_source_c within GR,
both of which use fixed point, 32-bit NCOs, thus the frequency accuracy is
quantifiable, for example:

nco_freq = int(target_freq/(samp_rate/2**32)) * (samp_rate/2**32)

Now the Frequency Translating FIR filter uses a rotator, and from what I can
tell by looking at the source (and I may be wrong), that rotator uses VOLK
or falls back to the normal code, both of which use a floating point phase
accumulator, with the latter being double precision.

So is there anyway to quantify the frequency, over a long number of cycles,
with the floating point phase accumulator?

I ran this GRC experiment:

https://dl.dropboxusercontent.com/u/49570443/rotator_test_grc.png

I generated a 1 Hz tone at 100 Msps with both the sig_source_c and rotator,
decimating down to 10 sps, and analysing with Baudline FFT to 8 digits of
precision.  The sig_source_c was spot on at 0.97788870 Hz, i.e.
int(1/(100E6/2**32))*(100E6/2**32)

For the rotator I used a phase increment of  (1/100E6)*2*numpy.pi, which
resulted in 0.99917424 Hz via Baudline.

So I concluded the rotator has higher actuary to the target frequency of 1
Hz, but...

Does it converge, or does it slowly drift away?
Does it have more phase noise than the fixed point NCO?
I noticed it has some spurs whereas the fixed point was spur-free?

I suppose in cases like this I should use an separate NCO and decimating FIR
for down conversion, instead of the Frequency Translating FIR?

As a side experiment I tried the following python code, which shows shows an
accumulating error over 10 cycles, but I'm not sure if this is even a valid
experiment:

import numpy as np

target_freq = np.float64(1)
samp_rate = np.float64(100E6)
two_pi = np.float64(2*np.pi)
phase = np.float64(0)

cycles = 10
phase_inc = target_freq/samp_rate*two_pi

for cycle in range(cycles):
    samp = 0
    while samp < samp_rate:
        samp = samp + 1
        phase = phase + phase_inc
    freq = phase/two_pi/(cycle+1)
    print "The frequency over %i cycles is %.15g" % (cycle+1, freq)

#################################################

The frequency over 1 cycles is 1.00000000229562
The frequency over 2 cycles is 1.00000000453839
The frequency over 3 cycles is 1.00000000101206
The frequency over 4 cycles is 0.999999995386438
The frequency over 5 cycles is 0.999999992011064
The frequency over 6 cycles is 0.999999989760814
The frequency over 7 cycles is 0.999999988153493
The frequency over 8 cycles is 0.999999986948002
The frequency over 9 cycles is 0.999999986010398
The frequency over 10 cycles is 0.999999985260315





--
View this message in context: 
http://gnuradio.4.n7.nabble.com/fxpt-nco-vs-rotator-tp51750.html
Sent from the GnuRadio mailing list archive at Nabble.com.