Annotation of embedaddon/ntp/ntpd/refclock_irig.c, revision 1.1
1.1 ! misho 1: /*
! 2: * refclock_irig - audio IRIG-B/E demodulator/decoder
! 3: */
! 4: #ifdef HAVE_CONFIG_H
! 5: #include <config.h>
! 6: #endif
! 7:
! 8: #if defined(REFCLOCK) && defined(CLOCK_IRIG)
! 9:
! 10: #include "ntpd.h"
! 11: #include "ntp_io.h"
! 12: #include "ntp_refclock.h"
! 13: #include "ntp_calendar.h"
! 14: #include "ntp_stdlib.h"
! 15:
! 16: #include <stdio.h>
! 17: #include <ctype.h>
! 18: #include <math.h>
! 19: #ifdef HAVE_SYS_IOCTL_H
! 20: #include <sys/ioctl.h>
! 21: #endif /* HAVE_SYS_IOCTL_H */
! 22:
! 23: #include "audio.h"
! 24:
! 25: /*
! 26: * Audio IRIG-B/E demodulator/decoder
! 27: *
! 28: * This driver synchronizes the computer time using data encoded in
! 29: * IRIG-B/E signals commonly produced by GPS receivers and other timing
! 30: * devices. The IRIG signal is an amplitude-modulated carrier with
! 31: * pulse-width modulated data bits. For IRIG-B, the carrier frequency is
! 32: * 1000 Hz and bit rate 100 b/s; for IRIG-E, the carrier frequenchy is
! 33: * 100 Hz and bit rate 10 b/s. The driver automatically recognizes which
! 34: & format is in use.
! 35: *
! 36: * The driver requires an audio codec or sound card with sampling rate 8
! 37: * kHz and mu-law companding. This is the same standard as used by the
! 38: * telephone industry and is supported by most hardware and operating
! 39: * systems, including Solaris, SunOS, FreeBSD, NetBSD and Linux. In this
! 40: * implementation, only one audio driver and codec can be supported on a
! 41: * single machine.
! 42: *
! 43: * The program processes 8000-Hz mu-law companded samples using separate
! 44: * signal filters for IRIG-B and IRIG-E, a comb filter, envelope
! 45: * detector and automatic threshold corrector. Cycle crossings relative
! 46: * to the corrected slice level determine the width of each pulse and
! 47: * its value - zero, one or position identifier.
! 48: *
! 49: * The data encode 20 BCD digits which determine the second, minute,
! 50: * hour and day of the year and sometimes the year and synchronization
! 51: * condition. The comb filter exponentially averages the corresponding
! 52: * samples of successive baud intervals in order to reliably identify
! 53: * the reference carrier cycle. A type-II phase-lock loop (PLL) performs
! 54: * additional integration and interpolation to accurately determine the
! 55: * zero crossing of that cycle, which determines the reference
! 56: * timestamp. A pulse-width discriminator demodulates the data pulses,
! 57: * which are then encoded as the BCD digits of the timecode.
! 58: *
! 59: * The timecode and reference timestamp are updated once each second
! 60: * with IRIG-B (ten seconds with IRIG-E) and local clock offset samples
! 61: * saved for later processing. At poll intervals of 64 s, the saved
! 62: * samples are processed by a trimmed-mean filter and used to update the
! 63: * system clock.
! 64: *
! 65: * An automatic gain control feature provides protection against
! 66: * overdriven or underdriven input signal amplitudes. It is designed to
! 67: * maintain adequate demodulator signal amplitude while avoiding
! 68: * occasional noise spikes. In order to assure reliable capture, the
! 69: * decompanded input signal amplitude must be greater than 100 units and
! 70: * the codec sample frequency error less than 250 PPM (.025 percent).
! 71: *
! 72: * Monitor Data
! 73: *
! 74: * The timecode format used for debugging and data recording includes
! 75: * data helpful in diagnosing problems with the IRIG signal and codec
! 76: * connections. The driver produces one line for each timecode in the
! 77: * following format:
! 78: *
! 79: * 00 00 98 23 19:26:52 2782 143 0.694 10 0.3 66.5 3094572411.00027
! 80: *
! 81: * If clockstats is enabled, the most recent line is written to the
! 82: * clockstats file every 64 s. If verbose recording is enabled (fudge
! 83: * flag 4) each line is written as generated.
! 84: *
! 85: * The first field containes the error flags in hex, where the hex bits
! 86: * are interpreted as below. This is followed by the year of century,
! 87: * day of year and time of day. Note that the time of day is for the
! 88: * previous minute, not the current time. The status indicator and year
! 89: * are not produced by some IRIG devices and appear as zeros. Following
! 90: * these fields are the carrier amplitude (0-3000), codec gain (0-255),
! 91: * modulation index (0-1), time constant (4-10), carrier phase error
! 92: * +-.5) and carrier frequency error (PPM). The last field is the on-
! 93: * time timestamp in NTP format.
! 94: *
! 95: * The error flags are defined as follows in hex:
! 96: *
! 97: * x01 Low signal. The carrier amplitude is less than 100 units. This
! 98: * is usually the result of no signal or wrong input port.
! 99: * x02 Frequency error. The codec frequency error is greater than 250
! 100: * PPM. This may be due to wrong signal format or (rarely)
! 101: * defective codec.
! 102: * x04 Modulation error. The IRIG modulation index is less than 0.5.
! 103: * This is usually the result of an overdriven codec, wrong signal
! 104: * format or wrong input port.
! 105: * x08 Frame synch error. The decoder frame does not match the IRIG
! 106: * frame. This is usually the result of an overdriven codec, wrong
! 107: * signal format or noisy IRIG signal. It may also be the result of
! 108: * an IRIG signature check which indicates a failure of the IRIG
! 109: * signal synchronization source.
! 110: * x10 Data bit error. The data bit length is out of tolerance. This is
! 111: * usually the result of an overdriven codec, wrong signal format
! 112: * or noisy IRIG signal.
! 113: * x20 Seconds numbering discrepancy. The decoder second does not match
! 114: * the IRIG second. This is usually the result of an overdriven
! 115: * codec, wrong signal format or noisy IRIG signal.
! 116: * x40 Codec error (overrun). The machine is not fast enough to keep up
! 117: * with the codec.
! 118: * x80 Device status error (Spectracom).
! 119: *
! 120: *
! 121: * Once upon a time, an UltrSPARC 30 and Solaris 2.7 kept the clock
! 122: * within a few tens of microseconds relative to the IRIG-B signal.
! 123: * Accuracy with IRIG-E was about ten times worse. Unfortunately, Sun
! 124: * broke the 2.7 audio driver in 2.8, which has a 10-ms sawtooth
! 125: * modulation.
! 126: *
! 127: * Unlike other drivers, which can have multiple instantiations, this
! 128: * one supports only one. It does not seem likely that more than one
! 129: * audio codec would be useful in a single machine. More than one would
! 130: * probably chew up too much CPU time anyway.
! 131: *
! 132: * Fudge factors
! 133: *
! 134: * Fudge flag4 causes the dubugging output described above to be
! 135: * recorded in the clockstats file. Fudge flag2 selects the audio input
! 136: * port, where 0 is the mike port (default) and 1 is the line-in port.
! 137: * It does not seem useful to select the compact disc player port. Fudge
! 138: * flag3 enables audio monitoring of the input signal. For this purpose,
! 139: * the monitor gain is set t a default value. Fudgetime2 is used as a
! 140: * frequency vernier for broken codec sample frequency.
! 141: *
! 142: * Alarm codes
! 143: *
! 144: * CEVNT_BADTIME invalid date or time
! 145: * CEVNT_TIMEOUT no IRIG data since last poll
! 146: */
! 147: /*
! 148: * Interface definitions
! 149: */
! 150: #define DEVICE_AUDIO "/dev/audio" /* audio device name */
! 151: #define PRECISION (-17) /* precision assumed (about 10 us) */
! 152: #define REFID "IRIG" /* reference ID */
! 153: #define DESCRIPTION "Generic IRIG Audio Driver" /* WRU */
! 154: #define AUDIO_BUFSIZ 320 /* audio buffer size (40 ms) */
! 155: #define SECOND 8000 /* nominal sample rate (Hz) */
! 156: #define BAUD 80 /* samples per baud interval */
! 157: #define OFFSET 128 /* companded sample offset */
! 158: #define SIZE 256 /* decompanding table size */
! 159: #define CYCLE 8 /* samples per bit */
! 160: #define SUBFLD 10 /* bits per frame */
! 161: #define FIELD 100 /* bits per second */
! 162: #define MINTC 2 /* min PLL time constant */
! 163: #define MAXTC 10 /* max PLL time constant max */
! 164: #define MAXAMP 3000. /* maximum signal amplitude */
! 165: #define MINAMP 2000. /* minimum signal amplitude */
! 166: #define DRPOUT 100. /* dropout signal amplitude */
! 167: #define MODMIN 0.5 /* minimum modulation index */
! 168: #define MAXFREQ (250e-6 * SECOND) /* freq tolerance (.025%) */
! 169:
! 170: /*
! 171: * The on-time synchronization point is the positive-going zero crossing
! 172: * of the first cycle of the second. The IIR baseband filter phase delay
! 173: * is 1.03 ms for IRIG-B and 3.47 ms for IRIG-E. The fudge value 2.68 ms
! 174: * due to the codec and other causes was determined by calibrating to a
! 175: * PPS signal from a GPS receiver.
! 176: *
! 177: * The results with a 2.4-GHz P4 running FreeBSD 6.1 are generally
! 178: * within .02 ms short-term with .02 ms jitter. The processor load due
! 179: * to the driver is 0.51 percent.
! 180: */
! 181: #define IRIG_B ((1.03 + 2.68) / 1000) /* IRIG-B system delay (s) */
! 182: #define IRIG_E ((3.47 + 2.68) / 1000) /* IRIG-E system delay (s) */
! 183:
! 184: /*
! 185: * Data bit definitions
! 186: */
! 187: #define BIT0 0 /* zero */
! 188: #define BIT1 1 /* one */
! 189: #define BITP 2 /* position identifier */
! 190:
! 191: /*
! 192: * Error flags
! 193: */
! 194: #define IRIG_ERR_AMP 0x01 /* low carrier amplitude */
! 195: #define IRIG_ERR_FREQ 0x02 /* frequency tolerance exceeded */
! 196: #define IRIG_ERR_MOD 0x04 /* low modulation index */
! 197: #define IRIG_ERR_SYNCH 0x08 /* frame synch error */
! 198: #define IRIG_ERR_DECODE 0x10 /* frame decoding error */
! 199: #define IRIG_ERR_CHECK 0x20 /* second numbering discrepancy */
! 200: #define IRIG_ERR_ERROR 0x40 /* codec error (overrun) */
! 201: #define IRIG_ERR_SIGERR 0x80 /* IRIG status error (Spectracom) */
! 202:
! 203: static char hexchar[] = "0123456789abcdef";
! 204:
! 205: /*
! 206: * IRIG unit control structure
! 207: */
! 208: struct irigunit {
! 209: u_char timecode[2 * SUBFLD + 1]; /* timecode string */
! 210: l_fp timestamp; /* audio sample timestamp */
! 211: l_fp tick; /* audio sample increment */
! 212: l_fp refstamp; /* reference timestamp */
! 213: l_fp chrstamp; /* baud timestamp */
! 214: l_fp prvstamp; /* previous baud timestamp */
! 215: double integ[BAUD]; /* baud integrator */
! 216: double phase, freq; /* logical clock phase and frequency */
! 217: double zxing; /* phase detector integrator */
! 218: double yxing; /* cycle phase */
! 219: double exing; /* envelope phase */
! 220: double modndx; /* modulation index */
! 221: double irig_b; /* IRIG-B signal amplitude */
! 222: double irig_e; /* IRIG-E signal amplitude */
! 223: int errflg; /* error flags */
! 224: /*
! 225: * Audio codec variables
! 226: */
! 227: double comp[SIZE]; /* decompanding table */
! 228: double signal; /* peak signal for AGC */
! 229: int port; /* codec port */
! 230: int gain; /* codec gain */
! 231: int mongain; /* codec monitor gain */
! 232: int seccnt; /* second interval counter */
! 233:
! 234: /*
! 235: * RF variables
! 236: */
! 237: double bpf[9]; /* IRIG-B filter shift register */
! 238: double lpf[5]; /* IRIG-E filter shift register */
! 239: double envmin, envmax; /* envelope min and max */
! 240: double slice; /* envelope slice level */
! 241: double intmin, intmax; /* integrated envelope min and max */
! 242: double maxsignal; /* integrated peak amplitude */
! 243: double noise; /* integrated noise amplitude */
! 244: double lastenv[CYCLE]; /* last cycle amplitudes */
! 245: double lastint[CYCLE]; /* last integrated cycle amplitudes */
! 246: double lastsig; /* last carrier sample */
! 247: double fdelay; /* filter delay */
! 248: int decim; /* sample decimation factor */
! 249: int envphase; /* envelope phase */
! 250: int envptr; /* envelope phase pointer */
! 251: int envsw; /* envelope state */
! 252: int envxing; /* envelope slice crossing */
! 253: int tc; /* time constant */
! 254: int tcount; /* time constant counter */
! 255: int badcnt; /* decimation interval counter */
! 256:
! 257: /*
! 258: * Decoder variables
! 259: */
! 260: int pulse; /* cycle counter */
! 261: int cycles; /* carrier cycles */
! 262: int dcycles; /* data cycles */
! 263: int lastbit; /* last code element */
! 264: int second; /* previous second */
! 265: int bitcnt; /* bit count in frame */
! 266: int frmcnt; /* bit count in second */
! 267: int xptr; /* timecode pointer */
! 268: int bits; /* demodulated bits */
! 269: };
! 270:
! 271: /*
! 272: * Function prototypes
! 273: */
! 274: static int irig_start (int, struct peer *);
! 275: static void irig_shutdown (int, struct peer *);
! 276: static void irig_receive (struct recvbuf *);
! 277: static void irig_poll (int, struct peer *);
! 278:
! 279: /*
! 280: * More function prototypes
! 281: */
! 282: static void irig_base (struct peer *, double);
! 283: static void irig_rf (struct peer *, double);
! 284: static void irig_baud (struct peer *, int);
! 285: static void irig_decode (struct peer *, int);
! 286: static void irig_gain (struct peer *);
! 287:
! 288: /*
! 289: * Transfer vector
! 290: */
! 291: struct refclock refclock_irig = {
! 292: irig_start, /* start up driver */
! 293: irig_shutdown, /* shut down driver */
! 294: irig_poll, /* transmit poll message */
! 295: noentry, /* not used (old irig_control) */
! 296: noentry, /* initialize driver (not used) */
! 297: noentry, /* not used (old irig_buginfo) */
! 298: NOFLAGS /* not used */
! 299: };
! 300:
! 301:
! 302: /*
! 303: * irig_start - open the devices and initialize data for processing
! 304: */
! 305: static int
! 306: irig_start(
! 307: int unit, /* instance number (used for PCM) */
! 308: struct peer *peer /* peer structure pointer */
! 309: )
! 310: {
! 311: struct refclockproc *pp;
! 312: struct irigunit *up;
! 313:
! 314: /*
! 315: * Local variables
! 316: */
! 317: int fd; /* file descriptor */
! 318: int i; /* index */
! 319: double step; /* codec adjustment */
! 320:
! 321: /*
! 322: * Open audio device
! 323: */
! 324: fd = audio_init(DEVICE_AUDIO, AUDIO_BUFSIZ, unit);
! 325: if (fd < 0)
! 326: return (0);
! 327: #ifdef DEBUG
! 328: if (debug)
! 329: audio_show();
! 330: #endif
! 331:
! 332: /*
! 333: * Allocate and initialize unit structure
! 334: */
! 335: up = emalloc(sizeof(*up));
! 336: memset(up, 0, sizeof(*up));
! 337: pp = peer->procptr;
! 338: pp->unitptr = (caddr_t)up;
! 339: pp->io.clock_recv = irig_receive;
! 340: pp->io.srcclock = (caddr_t)peer;
! 341: pp->io.datalen = 0;
! 342: pp->io.fd = fd;
! 343: if (!io_addclock(&pp->io)) {
! 344: close(fd);
! 345: pp->io.fd = -1;
! 346: free(up);
! 347: pp->unitptr = NULL;
! 348: return (0);
! 349: }
! 350:
! 351: /*
! 352: * Initialize miscellaneous variables
! 353: */
! 354: peer->precision = PRECISION;
! 355: pp->clockdesc = DESCRIPTION;
! 356: memcpy((char *)&pp->refid, REFID, 4);
! 357: up->tc = MINTC;
! 358: up->decim = 1;
! 359: up->gain = 127;
! 360:
! 361: /*
! 362: * The companded samples are encoded sign-magnitude. The table
! 363: * contains all the 256 values in the interest of speed.
! 364: */
! 365: up->comp[0] = up->comp[OFFSET] = 0.;
! 366: up->comp[1] = 1; up->comp[OFFSET + 1] = -1.;
! 367: up->comp[2] = 3; up->comp[OFFSET + 2] = -3.;
! 368: step = 2.;
! 369: for (i = 3; i < OFFSET; i++) {
! 370: up->comp[i] = up->comp[i - 1] + step;
! 371: up->comp[OFFSET + i] = -up->comp[i];
! 372: if (i % 16 == 0)
! 373: step *= 2.;
! 374: }
! 375: DTOLFP(1. / SECOND, &up->tick);
! 376: return (1);
! 377: }
! 378:
! 379:
! 380: /*
! 381: * irig_shutdown - shut down the clock
! 382: */
! 383: static void
! 384: irig_shutdown(
! 385: int unit, /* instance number (not used) */
! 386: struct peer *peer /* peer structure pointer */
! 387: )
! 388: {
! 389: struct refclockproc *pp;
! 390: struct irigunit *up;
! 391:
! 392: pp = peer->procptr;
! 393: up = (struct irigunit *)pp->unitptr;
! 394: if (-1 != pp->io.fd)
! 395: io_closeclock(&pp->io);
! 396: if (NULL != up)
! 397: free(up);
! 398: }
! 399:
! 400:
! 401: /*
! 402: * irig_receive - receive data from the audio device
! 403: *
! 404: * This routine reads input samples and adjusts the logical clock to
! 405: * track the irig clock by dropping or duplicating codec samples.
! 406: */
! 407: static void
! 408: irig_receive(
! 409: struct recvbuf *rbufp /* receive buffer structure pointer */
! 410: )
! 411: {
! 412: struct peer *peer;
! 413: struct refclockproc *pp;
! 414: struct irigunit *up;
! 415:
! 416: /*
! 417: * Local variables
! 418: */
! 419: double sample; /* codec sample */
! 420: u_char *dpt; /* buffer pointer */
! 421: int bufcnt; /* buffer counter */
! 422: l_fp ltemp; /* l_fp temp */
! 423:
! 424: peer = (struct peer *)rbufp->recv_srcclock;
! 425: pp = peer->procptr;
! 426: up = (struct irigunit *)pp->unitptr;
! 427:
! 428: /*
! 429: * Main loop - read until there ain't no more. Note codec
! 430: * samples are bit-inverted.
! 431: */
! 432: DTOLFP((double)rbufp->recv_length / SECOND, <emp);
! 433: L_SUB(&rbufp->recv_time, <emp);
! 434: up->timestamp = rbufp->recv_time;
! 435: dpt = rbufp->recv_buffer;
! 436: for (bufcnt = 0; bufcnt < rbufp->recv_length; bufcnt++) {
! 437: sample = up->comp[~*dpt++ & 0xff];
! 438:
! 439: /*
! 440: * Variable frequency oscillator. The codec oscillator
! 441: * runs at the nominal rate of 8000 samples per second,
! 442: * or 125 us per sample. A frequency change of one unit
! 443: * results in either duplicating or deleting one sample
! 444: * per second, which results in a frequency change of
! 445: * 125 PPM.
! 446: */
! 447: up->phase += (up->freq + clock_codec) / SECOND;
! 448: up->phase += pp->fudgetime2 / 1e6;
! 449: if (up->phase >= .5) {
! 450: up->phase -= 1.;
! 451: } else if (up->phase < -.5) {
! 452: up->phase += 1.;
! 453: irig_rf(peer, sample);
! 454: irig_rf(peer, sample);
! 455: } else {
! 456: irig_rf(peer, sample);
! 457: }
! 458: L_ADD(&up->timestamp, &up->tick);
! 459: sample = fabs(sample);
! 460: if (sample > up->signal)
! 461: up->signal = sample;
! 462: up->signal += (sample - up->signal) /
! 463: 1000;
! 464:
! 465: /*
! 466: * Once each second, determine the IRIG format and gain.
! 467: */
! 468: up->seccnt = (up->seccnt + 1) % SECOND;
! 469: if (up->seccnt == 0) {
! 470: if (up->irig_b > up->irig_e) {
! 471: up->decim = 1;
! 472: up->fdelay = IRIG_B;
! 473: } else {
! 474: up->decim = 10;
! 475: up->fdelay = IRIG_E;
! 476: }
! 477: up->irig_b = up->irig_e = 0;
! 478: irig_gain(peer);
! 479:
! 480: }
! 481: }
! 482:
! 483: /*
! 484: * Set the input port and monitor gain for the next buffer.
! 485: */
! 486: if (pp->sloppyclockflag & CLK_FLAG2)
! 487: up->port = 2;
! 488: else
! 489: up->port = 1;
! 490: if (pp->sloppyclockflag & CLK_FLAG3)
! 491: up->mongain = MONGAIN;
! 492: else
! 493: up->mongain = 0;
! 494: }
! 495:
! 496:
! 497: /*
! 498: * irig_rf - RF processing
! 499: *
! 500: * This routine filters the RF signal using a bandass filter for IRIG-B
! 501: * and a lowpass filter for IRIG-E. In case of IRIG-E, the samples are
! 502: * decimated by a factor of ten. Note that the codec filters function as
! 503: * roofing filters to attenuate both the high and low ends of the
! 504: * passband. IIR filter coefficients were determined using Matlab Signal
! 505: * Processing Toolkit.
! 506: */
! 507: static void
! 508: irig_rf(
! 509: struct peer *peer, /* peer structure pointer */
! 510: double sample /* current signal sample */
! 511: )
! 512: {
! 513: struct refclockproc *pp;
! 514: struct irigunit *up;
! 515:
! 516: /*
! 517: * Local variables
! 518: */
! 519: double irig_b, irig_e; /* irig filter outputs */
! 520:
! 521: pp = peer->procptr;
! 522: up = (struct irigunit *)pp->unitptr;
! 523:
! 524: /*
! 525: * IRIG-B filter. Matlab 4th-order IIR elliptic, 800-1200 Hz
! 526: * bandpass, 0.3 dB passband ripple, -50 dB stopband ripple,
! 527: * phase delay 1.03 ms.
! 528: */
! 529: irig_b = (up->bpf[8] = up->bpf[7]) * 6.505491e-001;
! 530: irig_b += (up->bpf[7] = up->bpf[6]) * -3.875180e+000;
! 531: irig_b += (up->bpf[6] = up->bpf[5]) * 1.151180e+001;
! 532: irig_b += (up->bpf[5] = up->bpf[4]) * -2.141264e+001;
! 533: irig_b += (up->bpf[4] = up->bpf[3]) * 2.712837e+001;
! 534: irig_b += (up->bpf[3] = up->bpf[2]) * -2.384486e+001;
! 535: irig_b += (up->bpf[2] = up->bpf[1]) * 1.427663e+001;
! 536: irig_b += (up->bpf[1] = up->bpf[0]) * -5.352734e+000;
! 537: up->bpf[0] = sample - irig_b;
! 538: irig_b = up->bpf[0] * 4.952157e-003
! 539: + up->bpf[1] * -2.055878e-002
! 540: + up->bpf[2] * 4.401413e-002
! 541: + up->bpf[3] * -6.558851e-002
! 542: + up->bpf[4] * 7.462108e-002
! 543: + up->bpf[5] * -6.558851e-002
! 544: + up->bpf[6] * 4.401413e-002
! 545: + up->bpf[7] * -2.055878e-002
! 546: + up->bpf[8] * 4.952157e-003;
! 547: up->irig_b += irig_b * irig_b;
! 548:
! 549: /*
! 550: * IRIG-E filter. Matlab 4th-order IIR elliptic, 130-Hz lowpass,
! 551: * 0.3 dB passband ripple, -50 dB stopband ripple, phase delay
! 552: * 3.47 ms.
! 553: */
! 554: irig_e = (up->lpf[4] = up->lpf[3]) * 8.694604e-001;
! 555: irig_e += (up->lpf[3] = up->lpf[2]) * -3.589893e+000;
! 556: irig_e += (up->lpf[2] = up->lpf[1]) * 5.570154e+000;
! 557: irig_e += (up->lpf[1] = up->lpf[0]) * -3.849667e+000;
! 558: up->lpf[0] = sample - irig_e;
! 559: irig_e = up->lpf[0] * 3.215696e-003
! 560: + up->lpf[1] * -1.174951e-002
! 561: + up->lpf[2] * 1.712074e-002
! 562: + up->lpf[3] * -1.174951e-002
! 563: + up->lpf[4] * 3.215696e-003;
! 564: up->irig_e += irig_e * irig_e;
! 565:
! 566: /*
! 567: * Decimate by a factor of either 1 (IRIG-B) or 10 (IRIG-E).
! 568: */
! 569: up->badcnt = (up->badcnt + 1) % up->decim;
! 570: if (up->badcnt == 0) {
! 571: if (up->decim == 1)
! 572: irig_base(peer, irig_b);
! 573: else
! 574: irig_base(peer, irig_e);
! 575: }
! 576: }
! 577:
! 578: /*
! 579: * irig_base - baseband processing
! 580: *
! 581: * This routine processes the baseband signal and demodulates the AM
! 582: * carrier using a synchronous detector. It then synchronizes to the
! 583: * data frame at the baud rate and decodes the width-modulated data
! 584: * pulses.
! 585: */
! 586: static void
! 587: irig_base(
! 588: struct peer *peer, /* peer structure pointer */
! 589: double sample /* current signal sample */
! 590: )
! 591: {
! 592: struct refclockproc *pp;
! 593: struct irigunit *up;
! 594:
! 595: /*
! 596: * Local variables
! 597: */
! 598: double lope; /* integrator output */
! 599: double env; /* envelope detector output */
! 600: double dtemp;
! 601: int carphase; /* carrier phase */
! 602:
! 603: pp = peer->procptr;
! 604: up = (struct irigunit *)pp->unitptr;
! 605:
! 606: /*
! 607: * Synchronous baud integrator. Corresponding samples of current
! 608: * and past baud intervals are integrated to refine the envelope
! 609: * amplitude and phase estimate. We keep one cycle (1 ms) of the
! 610: * raw data and one baud (10 ms) of the integrated data.
! 611: */
! 612: up->envphase = (up->envphase + 1) % BAUD;
! 613: up->integ[up->envphase] += (sample - up->integ[up->envphase]) /
! 614: (5 * up->tc);
! 615: lope = up->integ[up->envphase];
! 616: carphase = up->envphase % CYCLE;
! 617: up->lastenv[carphase] = sample;
! 618: up->lastint[carphase] = lope;
! 619:
! 620: /*
! 621: * Phase detector. Find the negative-going zero crossing
! 622: * relative to sample 4 in the 8-sample sycle. A phase change of
! 623: * 360 degrees produces an output change of one unit.
! 624: */
! 625: if (up->lastsig > 0 && lope <= 0)
! 626: up->zxing += (double)(carphase - 4) / CYCLE;
! 627: up->lastsig = lope;
! 628:
! 629: /*
! 630: * End of the baud. Update signal/noise estimates and PLL
! 631: * phase, frequency and time constant.
! 632: */
! 633: if (up->envphase == 0) {
! 634: up->maxsignal = up->intmax; up->noise = up->intmin;
! 635: up->intmin = 1e6; up->intmax = -1e6;
! 636: if (up->maxsignal < DRPOUT)
! 637: up->errflg |= IRIG_ERR_AMP;
! 638: if (up->maxsignal > 0)
! 639: up->modndx = (up->maxsignal - up->noise) /
! 640: up->maxsignal;
! 641: else
! 642: up->modndx = 0;
! 643: if (up->modndx < MODMIN)
! 644: up->errflg |= IRIG_ERR_MOD;
! 645: if (up->errflg & (IRIG_ERR_AMP | IRIG_ERR_FREQ |
! 646: IRIG_ERR_MOD | IRIG_ERR_SYNCH)) {
! 647: up->tc = MINTC;
! 648: up->tcount = 0;
! 649: }
! 650:
! 651: /*
! 652: * Update PLL phase and frequency. The PLL time constant
! 653: * is set initially to stabilize the frequency within a
! 654: * minute or two, then increases to the maximum. The
! 655: * frequency is clamped so that the PLL capture range
! 656: * cannot be exceeded.
! 657: */
! 658: dtemp = up->zxing * up->decim / BAUD;
! 659: up->yxing = dtemp;
! 660: up->zxing = 0.;
! 661: up->phase += dtemp / up->tc;
! 662: up->freq += dtemp / (4. * up->tc * up->tc);
! 663: if (up->freq > MAXFREQ) {
! 664: up->freq = MAXFREQ;
! 665: up->errflg |= IRIG_ERR_FREQ;
! 666: } else if (up->freq < -MAXFREQ) {
! 667: up->freq = -MAXFREQ;
! 668: up->errflg |= IRIG_ERR_FREQ;
! 669: }
! 670: }
! 671:
! 672: /*
! 673: * Synchronous demodulator. There are eight samples in the cycle
! 674: * and ten cycles in the baud. Since the PLL has aligned the
! 675: * negative-going zero crossing at sample 4, the maximum
! 676: * amplitude is at sample 2 and minimum at sample 6. The
! 677: * beginning of the data pulse is determined from the integrated
! 678: * samples, while the end of the pulse is determined from the
! 679: * raw samples. The raw data bits are demodulated relative to
! 680: * the slice level and left-shifted in the decoding register.
! 681: */
! 682: if (carphase != 7)
! 683: return;
! 684:
! 685: lope = (up->lastint[2] - up->lastint[6]) / 2.;
! 686: if (lope > up->intmax)
! 687: up->intmax = lope;
! 688: if (lope < up->intmin)
! 689: up->intmin = lope;
! 690:
! 691: /*
! 692: * Pulse code demodulator and reference timestamp. The decoder
! 693: * looks for a sequence of ten bits; the first two bits must be
! 694: * one, the last two bits must be zero. Frame synch is asserted
! 695: * when three correct frames have been found.
! 696: */
! 697: up->pulse = (up->pulse + 1) % 10;
! 698: up->cycles <<= 1;
! 699: if (lope >= (up->maxsignal + up->noise) / 2.)
! 700: up->cycles |= 1;
! 701: if ((up->cycles & 0x303c0f03) == 0x300c0300) {
! 702: if (up->pulse != 0)
! 703: up->errflg |= IRIG_ERR_SYNCH;
! 704: up->pulse = 0;
! 705: }
! 706:
! 707: /*
! 708: * Assemble the baud and max/min to get the slice level for the
! 709: * next baud. The slice level is based on the maximum over the
! 710: * first two bits and the minimum over the last two bits, with
! 711: * the slice level halfway between the maximum and minimum.
! 712: */
! 713: env = (up->lastenv[2] - up->lastenv[6]) / 2.;
! 714: up->dcycles <<= 1;
! 715: if (env >= up->slice)
! 716: up->dcycles |= 1;
! 717: switch(up->pulse) {
! 718:
! 719: case 0:
! 720: irig_baud(peer, up->dcycles);
! 721: if (env < up->envmin)
! 722: up->envmin = env;
! 723: up->slice = (up->envmax + up->envmin) / 2;
! 724: up->envmin = 1e6; up->envmax = -1e6;
! 725: break;
! 726:
! 727: case 1:
! 728: up->envmax = env;
! 729: break;
! 730:
! 731: case 2:
! 732: if (env > up->envmax)
! 733: up->envmax = env;
! 734: break;
! 735:
! 736: case 9:
! 737: up->envmin = env;
! 738: break;
! 739: }
! 740: }
! 741:
! 742: /*
! 743: * irig_baud - update the PLL and decode the pulse-width signal
! 744: */
! 745: static void
! 746: irig_baud(
! 747: struct peer *peer, /* peer structure pointer */
! 748: int bits /* decoded bits */
! 749: )
! 750: {
! 751: struct refclockproc *pp;
! 752: struct irigunit *up;
! 753: double dtemp;
! 754: l_fp ltemp;
! 755:
! 756: pp = peer->procptr;
! 757: up = (struct irigunit *)pp->unitptr;
! 758:
! 759: /*
! 760: * The PLL time constant starts out small, in order to
! 761: * sustain a frequency tolerance of 250 PPM. It
! 762: * gradually increases as the loop settles down. Note
! 763: * that small wiggles are not believed, unless they
! 764: * persist for lots of samples.
! 765: */
! 766: up->exing = -up->yxing;
! 767: if (fabs(up->envxing - up->envphase) <= 1) {
! 768: up->tcount++;
! 769: if (up->tcount > 20 * up->tc) {
! 770: up->tc++;
! 771: if (up->tc > MAXTC)
! 772: up->tc = MAXTC;
! 773: up->tcount = 0;
! 774: up->envxing = up->envphase;
! 775: } else {
! 776: up->exing -= up->envxing - up->envphase;
! 777: }
! 778: } else {
! 779: up->tcount = 0;
! 780: up->envxing = up->envphase;
! 781: }
! 782:
! 783: /*
! 784: * Strike the baud timestamp as the positive zero crossing of
! 785: * the first bit, accounting for the codec delay and filter
! 786: * delay.
! 787: */
! 788: up->prvstamp = up->chrstamp;
! 789: dtemp = up->decim * (up->exing / SECOND) + up->fdelay;
! 790: DTOLFP(dtemp, <emp);
! 791: up->chrstamp = up->timestamp;
! 792: L_SUB(&up->chrstamp, <emp);
! 793:
! 794: /*
! 795: * The data bits are collected in ten-bit bauds. The first two
! 796: * bits are not used. The resulting patterns represent runs of
! 797: * 0-1 bits (0), 2-4 bits (1) and 5-7 bits (PI). The remaining
! 798: * 8-bit run represents a soft error and is treated as 0.
! 799: */
! 800: switch (up->dcycles & 0xff) {
! 801:
! 802: case 0x00: /* 0-1 bits (0) */
! 803: case 0x80:
! 804: irig_decode(peer, BIT0);
! 805: break;
! 806:
! 807: case 0xc0: /* 2-4 bits (1) */
! 808: case 0xe0:
! 809: case 0xf0:
! 810: irig_decode(peer, BIT1);
! 811: break;
! 812:
! 813: case 0xf8: /* (5-7 bits (PI) */
! 814: case 0xfc:
! 815: case 0xfe:
! 816: irig_decode(peer, BITP);
! 817: break;
! 818:
! 819: default: /* 8 bits (error) */
! 820: irig_decode(peer, BIT0);
! 821: up->errflg |= IRIG_ERR_DECODE;
! 822: }
! 823: }
! 824:
! 825:
! 826: /*
! 827: * irig_decode - decode the data
! 828: *
! 829: * This routine assembles bauds into digits, digits into frames and
! 830: * frames into the timecode fields. Bits can have values of zero, one
! 831: * or position identifier. There are four bits per digit, ten digits per
! 832: * frame and ten frames per second.
! 833: */
! 834: static void
! 835: irig_decode(
! 836: struct peer *peer, /* peer structure pointer */
! 837: int bit /* data bit (0, 1 or 2) */
! 838: )
! 839: {
! 840: struct refclockproc *pp;
! 841: struct irigunit *up;
! 842:
! 843: /*
! 844: * Local variables
! 845: */
! 846: int syncdig; /* sync digit (Spectracom) */
! 847: char sbs[6 + 1]; /* binary seconds since 0h */
! 848: char spare[2 + 1]; /* mulligan digits */
! 849: int temp;
! 850:
! 851: pp = peer->procptr;
! 852: up = (struct irigunit *)pp->unitptr;
! 853:
! 854: /*
! 855: * Assemble frame bits.
! 856: */
! 857: up->bits >>= 1;
! 858: if (bit == BIT1) {
! 859: up->bits |= 0x200;
! 860: } else if (bit == BITP && up->lastbit == BITP) {
! 861:
! 862: /*
! 863: * Frame sync - two adjacent position identifiers, which
! 864: * mark the beginning of the second. The reference time
! 865: * is the beginning of the second position identifier,
! 866: * so copy the character timestamp to the reference
! 867: * timestamp.
! 868: */
! 869: if (up->frmcnt != 1)
! 870: up->errflg |= IRIG_ERR_SYNCH;
! 871: up->frmcnt = 1;
! 872: up->refstamp = up->prvstamp;
! 873: }
! 874: up->lastbit = bit;
! 875: if (up->frmcnt % SUBFLD == 0) {
! 876:
! 877: /*
! 878: * End of frame. Encode two hexadecimal digits in
! 879: * little-endian timecode field. Note frame 1 is shifted
! 880: * right one bit to account for the marker PI.
! 881: */
! 882: temp = up->bits;
! 883: if (up->frmcnt == 10)
! 884: temp >>= 1;
! 885: if (up->xptr >= 2) {
! 886: up->timecode[--up->xptr] = hexchar[temp & 0xf];
! 887: up->timecode[--up->xptr] = hexchar[(temp >> 5) &
! 888: 0xf];
! 889: }
! 890: if (up->frmcnt == 0) {
! 891:
! 892: /*
! 893: * End of second. Decode the timecode and wind
! 894: * the clock. Not all IRIG generators have the
! 895: * year; if so, it is nonzero after year 2000.
! 896: * Not all have the hardware status bit; if so,
! 897: * it is lit when the source is okay and dim
! 898: * when bad. We watch this only if the year is
! 899: * nonzero. Not all are configured for signature
! 900: * control. If so, all BCD digits are set to
! 901: * zero if the source is bad. In this case the
! 902: * refclock_process() will reject the timecode
! 903: * as invalid.
! 904: */
! 905: up->xptr = 2 * SUBFLD;
! 906: if (sscanf((char *)up->timecode,
! 907: "%6s%2d%1d%2s%3d%2d%2d%2d", sbs, &pp->year,
! 908: &syncdig, spare, &pp->day, &pp->hour,
! 909: &pp->minute, &pp->second) != 8)
! 910: pp->leap = LEAP_NOTINSYNC;
! 911: else
! 912: pp->leap = LEAP_NOWARNING;
! 913: up->second = (up->second + up->decim) % 60;
! 914:
! 915: /*
! 916: * Raise an alarm if the day field is zero,
! 917: * which happens when signature control is
! 918: * enabled and the device has lost
! 919: * synchronization. Raise an alarm if the year
! 920: * field is nonzero and the sync indicator is
! 921: * zero, which happens when a Spectracom radio
! 922: * has lost synchronization. Raise an alarm if
! 923: * the expected second does not agree with the
! 924: * decoded second, which happens with a garbled
! 925: * IRIG signal. We are very particular.
! 926: */
! 927: if (pp->day == 0 || (pp->year != 0 && syncdig ==
! 928: 0))
! 929: up->errflg |= IRIG_ERR_SIGERR;
! 930: if (pp->second != up->second)
! 931: up->errflg |= IRIG_ERR_CHECK;
! 932: up->second = pp->second;
! 933:
! 934: /*
! 935: * Wind the clock only if there are no errors
! 936: * and the time constant has reached the
! 937: * maximum.
! 938: */
! 939: if (up->errflg == 0 && up->tc == MAXTC) {
! 940: pp->lastref = pp->lastrec;
! 941: pp->lastrec = up->refstamp;
! 942: if (!refclock_process(pp))
! 943: refclock_report(peer,
! 944: CEVNT_BADTIME);
! 945: }
! 946: snprintf(pp->a_lastcode, sizeof(pp->a_lastcode),
! 947: "%02x %02d %03d %02d:%02d:%02d %4.0f %3d %6.3f %2d %6.2f %6.1f %s",
! 948: up->errflg, pp->year, pp->day,
! 949: pp->hour, pp->minute, pp->second,
! 950: up->maxsignal, up->gain, up->modndx,
! 951: up->tc, up->exing * 1e6 / SECOND, up->freq *
! 952: 1e6 / SECOND, ulfptoa(&pp->lastrec, 6));
! 953: pp->lencode = strlen(pp->a_lastcode);
! 954: up->errflg = 0;
! 955: if (pp->sloppyclockflag & CLK_FLAG4) {
! 956: record_clock_stats(&peer->srcadr,
! 957: pp->a_lastcode);
! 958: #ifdef DEBUG
! 959: if (debug)
! 960: printf("irig %s\n",
! 961: pp->a_lastcode);
! 962: #endif /* DEBUG */
! 963: }
! 964: }
! 965: }
! 966: up->frmcnt = (up->frmcnt + 1) % FIELD;
! 967: }
! 968:
! 969:
! 970: /*
! 971: * irig_poll - called by the transmit procedure
! 972: *
! 973: * This routine sweeps up the timecode updates since the last poll. For
! 974: * IRIG-B there should be at least 60 updates; for IRIG-E there should
! 975: * be at least 6. If nothing is heard, a timeout event is declared.
! 976: */
! 977: static void
! 978: irig_poll(
! 979: int unit, /* instance number (not used) */
! 980: struct peer *peer /* peer structure pointer */
! 981: )
! 982: {
! 983: struct refclockproc *pp;
! 984: struct irigunit *up;
! 985:
! 986: pp = peer->procptr;
! 987: up = (struct irigunit *)pp->unitptr;
! 988:
! 989: if (pp->coderecv == pp->codeproc) {
! 990: refclock_report(peer, CEVNT_TIMEOUT);
! 991: return;
! 992:
! 993: }
! 994: refclock_receive(peer);
! 995: if (!(pp->sloppyclockflag & CLK_FLAG4)) {
! 996: record_clock_stats(&peer->srcadr, pp->a_lastcode);
! 997: #ifdef DEBUG
! 998: if (debug)
! 999: printf("irig %s\n", pp->a_lastcode);
! 1000: #endif /* DEBUG */
! 1001: }
! 1002: pp->polls++;
! 1003:
! 1004: }
! 1005:
! 1006:
! 1007: /*
! 1008: * irig_gain - adjust codec gain
! 1009: *
! 1010: * This routine is called at the end of each second. It uses the AGC to
! 1011: * bradket the maximum signal level between MINAMP and MAXAMP to avoid
! 1012: * hunting. The routine also jiggles the input port and selectively
! 1013: * mutes the monitor.
! 1014: */
! 1015: static void
! 1016: irig_gain(
! 1017: struct peer *peer /* peer structure pointer */
! 1018: )
! 1019: {
! 1020: struct refclockproc *pp;
! 1021: struct irigunit *up;
! 1022:
! 1023: pp = peer->procptr;
! 1024: up = (struct irigunit *)pp->unitptr;
! 1025:
! 1026: /*
! 1027: * Apparently, the codec uses only the high order bits of the
! 1028: * gain control field. Thus, it may take awhile for changes to
! 1029: * wiggle the hardware bits.
! 1030: */
! 1031: if (up->maxsignal < MINAMP) {
! 1032: up->gain += 4;
! 1033: if (up->gain > MAXGAIN)
! 1034: up->gain = MAXGAIN;
! 1035: } else if (up->maxsignal > MAXAMP) {
! 1036: up->gain -= 4;
! 1037: if (up->gain < 0)
! 1038: up->gain = 0;
! 1039: }
! 1040: audio_gain(up->gain, up->mongain, up->port);
! 1041: }
! 1042:
! 1043:
! 1044: #else
! 1045: int refclock_irig_bs;
! 1046: #endif /* REFCLOCK */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_irig.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd