Now that I got Han's attention, I'll start a new thread.
> Clockbuilderpro seems to do a massive search for the lowest possible integer values of a,b,c in both PLL and output msynth's
> when I ask for one output of a particular frequency, often leaving both msynths in fractional mode.
Not quite true.?
The output MSynth is as reported, low integers but not in integer mode
on the few random samples I've tried so far.
The PLL MSynth can have fairly large values for B and C, as expected.
Jerry?
######################################################
Hans, on a completely different note, you may find this interesting,
It takes the three si5351 msynth register values for p1, p2, p3 as reported by Clockbuilderpro
and back computes values for a, b, c
Just got it to work this morning, seems right but may yet have issues.
I assume a,b,c must all be integers.
However, a and b could take on fractional values in increments of 1/128 and still yield integer values for p1,p2,p3.
I wonder if that's legal, though not seeing that out of Clockbuilderpro.
Clockbuilderpro seems to do a massive search for the lowest possible integer values of a,b,c in both PLL and output msynth's
when I ask for one output of a particular frequency, often leaving both msynths in fractional mode.
So low integer values are likely the primary way to reduce phase noise.
This is a considerably different approach than all the C code for the si5351 I find out there on the interwebs
Regardless, my guess is that the si5351 has less phase noise in all cases than the typical LC vfo.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv) {
int floorg, floorc, ax128, bx128, a, b, c, p1, p2, p3;
if (argc==4) {
p1 = atoi(argv[1]);
p2 = atoi(argv[2]);
p3 = atoi(argv[3]);
} else {
printf("Usage: Takes 3 int args for si5351 msynth reg values p1,p2,p3\n");
printf("reports int values for a,b,c where a+b/c is the divide ratio\n");
exit(1);
}
printf(" p1:%d p2:%d p3:%d \n", p1, p2, p3);
c = p3;
// Given an si5351 msynth divide of (a + b/c):
// p1 = 128*a + Floor(128*b/c) - 512
// p2 = 128*b - c*Floor(128*b/c)
// p3 = c // All from Silabs AN619
// Since b<c, Floor(128*b/c) has a value between 0 and 127 inclusive
// We compute a and b for each of those values, determine which is legal
for (floorg=0; floorg<128; floorg++) { // Guess value of Floor(128*b/c)
ax128 = p1 + 512 - floorg; // Where ax128 is a*128
bx128 = p2 + c*floorg; // and bx128 is b*128
floorc = bx128/c; // Compute value Floor(128*b/c)
a = ax128/128; b=bx128/128;
// Report result if value of Floor(128*b/c) is consistent with guess,
// and if the computed values for a and b are integers, and b<c.
if (floorc==floorg && ax128%128==0 && bx128%128==0 && b<c)
printf(" a:%d b:%d c:%d \n", a, b, c);
}
exit(0);
}
Jerry, KE7ER
