1 /* 2 * This program simulates a first-order, type-II phase-lock loop using 3 * actual code segments from modified kernel distributions for SunOS, 4 * Ultrix and OSF/1 kernels. These segments do not use any licensed code. 5 */ 6 7 #ifdef HAVE_CONFIG_H 8 # include <config.h> 9 #endif 10 11 #include <stdio.h> 12 #include <ctype.h> 13 #include <math.h> 14 #include <sys/time.h> 15 16 #ifdef HAVE_TIMEX_H 17 # include "timex.h" 18 #endif 19 20 /* 21 * Phase-lock loop definitions 22 */ 23 #define HZ 100 /* timer interrupt frequency (Hz) */ 24 #define MAXPHASE 512000 /* max phase error (us) */ 25 #define MAXFREQ 200 /* max frequency error (ppm) */ 26 #define TAU 2 /* time constant (shift 0 - 6) */ 27 #define POLL 16 /* interval between updates (s) */ 28 #define MAXSEC 1200 /* max interval between updates (s) */ 29 30 /* 31 * Function declarations 32 */ 33 void hardupdate(); 34 void hardclock(); 35 void second_overflow(); 36 37 /* 38 * Kernel variables 39 */ 40 int tick; /* timer interrupt period (us) */ 41 int fixtick; /* amortization constant (ppm) */ 42 struct timeval timex; /* ripoff of kernel time variable */ 43 44 /* 45 * Phase-lock loop variables 46 */ 47 int time_status = TIME_BAD; /* clock synchronization status */ 48 long time_offset = 0; /* time adjustment (us) */ 49 long time_constant = 0; /* pll time constant */ 50 long time_tolerance = MAXFREQ; /* frequency tolerance (ppm) */ 51 long time_precision = 1000000 / HZ; /* clock precision (us) */ 52 long time_maxerror = MAXPHASE; /* maximum error (us) */ 53 long time_esterror = MAXPHASE; /* estimated error (us) */ 54 long time_phase = 0; /* phase offset (scaled us) */ 55 long time_freq = 0; /* frequency offset (scaled ppm) */ 56 long time_adj = 0; /* tick adjust (scaled 1 / HZ) */ 57 long time_reftime = 0; /* time at last adjustment (s) */ 58 59 /* 60 * Simulation variables 61 */ 62 double timey = 0; /* simulation time (us) */ 63 long timez = 0; /* current error (us) */ 64 long poll_interval = 0; /* poll counter */ 65 66 /* 67 * Simulation test program 68 */ 69 int main(int argc,char * argv[])70 main( 71 int argc, 72 char *argv[] 73 ) 74 { 75 tick = 1000000 / HZ; 76 fixtick = 1000000 % HZ; 77 timex.tv_sec = 0; 78 timex.tv_usec = MAXPHASE; 79 time_freq = 0; 80 time_constant = TAU; 81 printf("tick %d us, fixtick %d us\n", tick, fixtick); 82 printf(" time offset freq _offset _freq _adj\n"); 83 84 /* 85 * Grind the loop until ^C 86 */ 87 while (1) { 88 timey += (double)(1000000) / HZ; 89 if (timey >= 1000000) 90 timey -= 1000000; 91 hardclock(); 92 if (timex.tv_usec >= 1000000) { 93 timex.tv_usec -= 1000000; 94 timex.tv_sec++; 95 second_overflow(); 96 poll_interval++; 97 if (!(poll_interval % POLL)) { 98 timez = (long)timey - timex.tv_usec; 99 if (timez > 500000) 100 timez -= 1000000; 101 if (timez < -500000) 102 timez += 1000000; 103 hardupdate(timez); 104 printf("%10li%10li%10.2f %08lx %08lx %08lx\n", 105 timex.tv_sec, timez, 106 (double)time_freq / (1 << SHIFT_KF), 107 time_offset, time_freq, time_adj); 108 } 109 } 110 } 111 } 112 113 /* 114 * This routine simulates the ntp_adjtime() call 115 * 116 * For default SHIFT_UPDATE = 12, offset is limited to +-512 ms, the 117 * maximum interval between updates is 4096 s and the maximum frequency 118 * offset is +-31.25 ms/s. 119 */ 120 void hardupdate(long offset)121 hardupdate( 122 long offset 123 ) 124 { 125 long ltemp, mtemp; 126 127 time_offset = offset << SHIFT_UPDATE; 128 mtemp = timex.tv_sec - time_reftime; 129 time_reftime = timex.tv_sec; 130 if (mtemp > MAXSEC) 131 mtemp = 0; 132 133 /* ugly multiply should be replaced */ 134 if (offset < 0) 135 time_freq -= (-offset * mtemp) >> 136 (time_constant + time_constant); 137 else 138 time_freq += (offset * mtemp) >> 139 (time_constant + time_constant); 140 ltemp = time_tolerance << SHIFT_KF; 141 if (time_freq > ltemp) 142 time_freq = ltemp; 143 else if (time_freq < -ltemp) 144 time_freq = -ltemp; 145 if (time_status == TIME_BAD) 146 time_status = TIME_OK; 147 } 148 149 /* 150 * This routine simulates the timer interrupt 151 */ 152 void hardclock(void)153 hardclock(void) 154 { 155 int ltemp, time_update; 156 157 time_update = tick; /* computed by adjtime() */ 158 time_phase += time_adj; 159 if (time_phase < -FINEUSEC) { 160 ltemp = -time_phase >> SHIFT_SCALE; 161 time_phase += ltemp << SHIFT_SCALE; 162 time_update -= ltemp; 163 } 164 else if (time_phase > FINEUSEC) { 165 ltemp = time_phase >> SHIFT_SCALE; 166 time_phase -= ltemp << SHIFT_SCALE; 167 time_update += ltemp; 168 } 169 timex.tv_usec += time_update; 170 } 171 172 /* 173 * This routine simulates the overflow of the microsecond field 174 * 175 * With SHIFT_SCALE = 23, the maximum frequency adjustment is +-256 us 176 * per tick, or 25.6 ms/s at a clock frequency of 100 Hz. The time 177 * contribution is shifted right a minimum of two bits, while the frequency 178 * contribution is a right shift. Thus, overflow is prevented if the 179 * frequency contribution is limited to half the maximum or 15.625 ms/s. 180 */ 181 void second_overflow(void)182 second_overflow(void) 183 { 184 int ltemp; 185 186 time_maxerror += time_tolerance; 187 if (time_offset < 0) { 188 ltemp = -time_offset >> 189 (SHIFT_KG + time_constant); 190 time_offset += ltemp; 191 time_adj = -(ltemp << 192 (SHIFT_SCALE - SHIFT_HZ - SHIFT_UPDATE)); 193 } else { 194 ltemp = time_offset >> 195 (SHIFT_KG + time_constant); 196 time_offset -= ltemp; 197 time_adj = ltemp << 198 (SHIFT_SCALE - SHIFT_HZ - SHIFT_UPDATE); 199 } 200 if (time_freq < 0) 201 time_adj -= -time_freq >> (SHIFT_KF + SHIFT_HZ - SHIFT_SCALE); 202 else 203 time_adj += time_freq >> (SHIFT_KF + SHIFT_HZ - SHIFT_SCALE); 204 time_adj += fixtick << (SHIFT_SCALE - SHIFT_HZ); 205 206 /* ugly divide should be replaced */ 207 if (timex.tv_sec % 86400 == 0) { 208 switch (time_status) { 209 210 case TIME_INS: 211 timex.tv_sec--; /* !! */ 212 time_status = TIME_OOP; 213 break; 214 215 case TIME_DEL: 216 timex.tv_sec++; 217 time_status = TIME_OK; 218 break; 219 220 case TIME_OOP: 221 time_status = TIME_OK; 222 break; 223 } 224 } 225 } 226