[time-nuts] Thunderbolt? (re simple gpsdo.)

Hal Murray hmurray at megapathdsl.net
Sat Dec 31 20:56:46 EST 2011


> As soon as you say "Software" the device is no longer simple.    Even a
> microprocessor is a very complex device and so is its development system.
> The software inside the uP is not simple either if you count the number of
> possible paths through the code (2 raided to the power of the number of
> branches.) 

Yes and no...

Software doesn't have to be big, bloated, ugly, and complicated.  (But I 
agree that it often is.)

This looks like fun to me, but I like writing that sort of code.  Note that 
it doesn't need an OS or even any libraries.


The context for "simple" wasn't well specified.

Does simple refer to design or construction?

How good does the GPSDO have to be?  (After all, this is time nuts.)  What 
sort of adev at what sort of time scale?


I think the main problem in this area is building a low pass filter with a 
long time constant.

The time constant of the filter has to be:
  long relative to the noise from the phase detector
  short relative to aging of the oscillator
  short relative to environmental changes
    (so the osc can track temperature and voltage
      those changes may be in the PLL system rather than the osc)

If we are starting with PPS (rather than 10KHz), the filter time constant 
needs to be 10s or 100s of seconds.  How do I build an analog filter with a 
time constant that long?

What's the input impedance of a VCXO or Rb unit?  I assume we will need an op-amp to buffer the filter.

The ugly problem in this area is that time constant to filter out phase detector noise overlaps the time constant needed to let environmental changes through.  That doesn't matter if the filter is analog or digital.

If the osc is stable (Rb) filter time constants of 1000s of seconds might make sense.  That might help take care of some of the hanging bridges.


For those who aren't familiar with this trick, it's easy to make a low pass filter in software:
  X = X*(1-k) + k*new
or
  X = X -k*X + k*new
where k is less than one.  Smaller k makes a slower filter.
If you pick k as a (negative) power of 2, the multiplies can be done with a shift so there is nothing complicated with making filters with a very long time constant.  (You may have to use multi-precision arithmetic, but that's not a big deal.)



-- 
These are my opinions, not necessarily my employer's.  I hate spam.







More information about the time-nuts mailing list