# [time-nuts] First success with very simple, very low cost GPSDO

WarrenS warrensjmail-one at yahoo.com
Sun Apr 13 13:44:11 EDT 2014

```woops, corrected typing error below
Vi = Vi + I*Vdp
Vf = (P + F) * Vdp + (I * Vi)
to
Vi = Vi + I*Vdp
Vf = (P + F) * Vdp + Vi

----- Original Message -----

Magnus wrote

>You are over-focusing ...
At least on that we totally agree.
The same can be said of you in over-focusing on what comes before the Phase
error term Vdp. The PI code we've been discussing does not care.
Can we just focus to see if you can find a mistake in my understanding of

The output (Vf) is the sum of the integrator (Vi) and P*Vdp   (line 4)
The output of the integrator (Vi) is the sum of the integral of  I*Vdp and
the integral of F*derivative_of_Vdp  (Line #3)
The integral of the derivative cancel  (reference below)

So the above can be simplified to
The output Vf is the sum of three terms:
P*Vdp
I * integral_of_Vdp
F*Vdp

The P and F gains above both have the exact same effect and can further be
simplified to:
The output Vf is the sum of two terms:
(P+F)*Vdp
I * integral_of_Vdp

As far as I can tell, your code:
>> Vdf = Vdp - Vdp_pre
>> Vdp_pre = Vdp
>> Vi = Vi + I*Vdp + F*Vdf
>> Vf = Vi + P*Vdp

Gives the exact same output as:
> Vi = Vi + I*Vdp
> Vf = (P + F) * Vdp + Vi
Which is nothing more than a standard PI controller
Do we still disagree?? If so where?

reference
http://www.mathmistakes.info/facts/CalculusFacts/learn/doi/doi.html
that says in part;
the fundamental theorem of calculus can be loosely expressed in words as:
"the integral of a derivative of a function is that original function", ...

ws

***********************************
Warren,

On 13/04/14 07:44, WarrenS wrote:
> Magnus wrote
>
>> It may appear so, but the derivate, scale-factor F and integrate does not
>> make the scale-factor F equalent to P, since you are forgetting that the
>> derivate removes the DC term
>
> We don't quite agree on that point yet.
> I can not find anything different or special that your code example is
> doing "at it's output",
> It seems to produce the exact same results as a standard PI controller.
> Also in your code and all PI code the FLL function you talk about is
> provided by the P term, Don't need to add the derivate, scale-factor F
> and integrate term.

You are over-focusing on the derivate canceling the integrate of the
loop-state, but if you want to play that game and make sense out of it,
you should not cancel out the integrator in the PI operation, but the
integrators of the reference (resulting in omega_0) and that of the
steered oscillator (resulting in omega_0 + omega_e + Ko*Vf). As they go
through the phase comparator (really a frequency comparator) you have
Kd*(omega_0 - (omega_0 - omega_e)) = -Kd*omega_e -Kd*Ko*Vf. That is then
scaled by the F factor into the integrator and the integrator then
alters it's state to cancel this out. This is happening when frequency
error (omega_e - it's angular frequency variant) is so large that the
PLL part is beating and has almost no DC component to charge the
integrator with. The P factor will simply not aid in building up the
integrator state like this.

So, that part is a FLL.

I know it is confusing, but one has to see the complete loop, and see
how you can aid in bulding up the frequency correction state. PLLs is
really bad at this if the error is large. FLL aiding that state buildup
helps a lot.

Once you have started to understand the double nature of this loop, it's
FLL and PLL styles you also realize that the FLL part degrades itself
into a contributor to the AC-components proportional path, as the
frequency error component has a zero DC component. However, if the loop
is put into stress, the FLL starts aiding on the frequency again. There
is thus no "mode" but rather "dominant characteristics" and depending on
the frequency error of the loop either the FLL or PLL is dominant.

Cheers,
Magnus

```