/* * refclock_irig - audio IRIG-B/E demodulator/decoder */ #ifdef HAVE_CONFIG_H #include <config.h> #endif #if defined(REFCLOCK) && defined(CLOCK_IRIG) #include "ntpd.h" #include "ntp_io.h" #include "ntp_refclock.h" #include "ntp_calendar.h" #include "ntp_stdlib.h" #include <stdio.h> #include <ctype.h> #include <math.h> #ifdef HAVE_SYS_IOCTL_H #include <sys/ioctl.h> #endif /* HAVE_SYS_IOCTL_H */ #include "audio.h" /* * Audio IRIG-B/E demodulator/decoder * * This driver receives, demodulates and decodes IRIG-B/E signals when * connected to the audio codec /dev/audio. The IRIG signal format is an * amplitude-modulated carrier with pulse-width modulated data bits. For * IRIG-B, the carrier frequency is 1000 Hz and bit rate 100 b/s; for * IRIG-E, the carrier frequenchy is 100 Hz and bit rate 10 b/s. The * driver automatically recognizes which format is in use. * * The program processes 8000-Hz mu-law companded samples using separate * signal filters for IRIG-B and IRIG-E, a comb filter, envelope * detector and automatic threshold corrector. Cycle crossings relative * to the corrected slice level determine the width of each pulse and * its value - zero, one or position identifier. The data encode 20 BCD * digits which determine the second, minute, hour and day of the year * and sometimes the year and synchronization condition. The comb filter * exponentially averages the corresponding samples of successive baud * intervals in order to reliably identify the reference carrier cycle. * A type-II phase-lock loop (PLL) performs additional integration and * interpolation to accurately determine the zero crossing of that * cycle, which determines the reference timestamp. A pulse-width * discriminator demodulates the data pulses, which are then encoded as * the BCD digits of the timecode. * * The timecode and reference timestamp are updated once each second * with IRIG-B (ten seconds with IRIG-E) and local clock offset samples * saved for later processing. At poll intervals of 64 s, the saved * samples are processed by a trimmed-mean filter and used to update the * system clock. * * An automatic gain control feature provides protection against * overdriven or underdriven input signal amplitudes. It is designed to * maintain adequate demodulator signal amplitude while avoiding * occasional noise spikes. In order to assure reliable capture, the * decompanded input signal amplitude must be greater than 100 units and * the codec sample frequency error less than 250 PPM (.025 percent). * * The program performs a number of error checks to protect against * overdriven or underdriven input signal levels, incorrect signal * format or improper hardware configuration. Specifically, if any of * the following errors occur for a time measurement, the data are * rejected. * * o The peak carrier amplitude is less than DRPOUT (100). This usually * means dead IRIG signal source, broken cable or wrong input port. * * o The frequency error is greater than MAXFREQ +-250 PPM (.025%). This * usually means broken codec hardware or wrong codec configuration. * * o The modulation index is less than MODMIN (0.5). This usually means * overdriven IRIG signal or wrong IRIG format. * * o A frame synchronization error has occurred. This usually means wrong * IRIG signal format or the IRIG signal source has lost * synchronization (signature control). * * o A data decoding error has occurred. This usually means wrong IRIG * signal format. * * o The current second of the day is not exactly one greater than the * previous one. This usually means a very noisy IRIG signal or * insufficient CPU resources. * * o An audio codec error (overrun) occurred. This usually means * insufficient CPU resources, as sometimes happens with Sun SPARC * IPCs when doing something useful. * * Note that additional checks are done elsewhere in the reference clock * interface routines. * * Debugging aids * * The timecode format used for debugging and data recording includes * data helpful in diagnosing problems with the IRIG signal and codec * connections. With debugging enabled (-d -d -d on the ntpd command * line), the driver produces one line for each timecode in the * following format: * * 00 1 98 23 19:26:52 721 143 0.694 47 20 0.083 66.5 3094572411.00027 * * The most recent line is also written to the clockstats file at 64-s * intervals. * * The first field contains the error flags in hex, where the hex bits * are interpreted as below. This is followed by the IRIG status * indicator, year of century, day of year and time of day. The status * indicator and year are not produced by some IRIG devices. Following * these fields are the signal amplitude (0-8100), codec gain (0-255), * field phase (0-79), time constant (2-20), modulation index (0-1), * carrier phase error (0+-0.5) and carrier frequency error (PPM). The * last field is the on-time timestamp in NTP format. * * The fraction part of the on-time timestamp is a good indicator of how * well the driver is doing. With an UltrSPARC 30, this thing can keep * the clock within a few tens of microseconds relative to the IRIG-B * signal. Accuracy with IRIG-E is about ten times worse. * * Unlike other drivers, which can have multiple instantiations, this * one supports only one. It does not seem likely that more than one * audio codec would be useful in a single machine. More than one would * probably chew up too much CPU time anyway. * * Fudge factors * * Fudge flag2 selects the audio input port, where 0 is the mike port * (default) and 1 is the line-in port. It does not seem useful to * select the compact disc player port. Fudge flag3 enables audio * monitoring of the input signal. For this purpose, the speaker volume * must be set before the driver is started. Fudge flag4 causes the * debugging output described above to be recorded in the clockstats * file. Any of these flags can be changed during operation with the * ntpdc program. */ /* * Interface definitions */ #define DEVICE_AUDIO "/dev/audio" /* audio device name */ #define PRECISION (-17) /* precision assumed (about 10 us) */ #define REFID "IRIG" /* reference ID */ #define DESCRIPTION "Generic IRIG Audio Driver" /* WRU */ #define SECOND 8000 /* nominal sample rate (Hz) */ #define BAUD 80 /* samples per baud interval */ #define OFFSET 128 /* companded sample offset */ #define SIZE 256 /* decompanding table size */ #define CYCLE 8 /* samples per carrier cycle */ #define SUBFLD 10 /* bits per subfield */ #define FIELD 10 /* subfields per field */ #define MINTC 2 /* min PLL time constant */ #define MAXTC 20 /* max PLL time constant max */ #define MAXSIG 6000. /* maximum signal level */ #define DRPOUT 100. /* dropout signal level */ #define MODMIN 0.5 /* minimum modulation index */ #define MAXFREQ (250e-6 * SECOND) /* freq tolerance (.025%) */ #define PI 3.1415926535 /* the real thing */ /* * Experimentally determined fudge factors */ #define IRIG_B .0019 /* IRIG-B phase delay */ #define IRIG_E .0019 /* IRIG-E phase delay */ /* * Data bit definitions */ #define BIT0 0 /* zero */ #define BIT1 1 /* one */ #define BITP 2 /* position identifier */ /* * Error flags (up->errflg) */ #define IRIG_ERR_AMP 0x01 /* low carrier amplitude */ #define IRIG_ERR_FREQ 0x02 /* frequency tolerance exceeded */ #define IRIG_ERR_MOD 0x04 /* low modulation index */ #define IRIG_ERR_SYNCH 0x08 /* frame synch error */ #define IRIG_ERR_DECODE 0x10 /* frame decoding error */ #define IRIG_ERR_CHECK 0x20 /* second numbering discrepancy */ #define IRIG_ERR_ERROR 0x40 /* codec error (overrun) */ /* * IRIG unit control structure */ struct irigunit { u_char timecode[21]; /* timecode string */ l_fp timestamp; /* audio sample timestamp */ l_fp tick; /* audio sample increment */ double comp[SIZE]; /* decompanding table */ double integ[BAUD]; /* baud integrator */ double phase, freq; /* logical clock phase and frequency */ double zxing; /* phase detector integrator */ double yxing; /* phase detector display */ double modndx; /* modulation index */ double irig_b; /* IRIG-B signal amplitude */ double irig_e; /* IRIG-E signal amplitude */ int errflg; /* error flags */ int bufcnt; /* samples in buffer */ int bufptr; /* buffer index pointer */ int pollcnt; /* poll counter */ int port; /* codec port */ int gain; /* codec gain */ int clipcnt; /* sample clipped count */ int seccnt; /* second interval counter */ int decim; /* sample decimation factor */ /* * RF variables */ double hpf[5]; /* IRIG-B filter shift register */ double lpf[5]; /* IRIG-E filter shift register */ double intmin, intmax; /* integrated envelope min and max */ double envmax; /* peak amplitude */ double envmin; /* noise amplitude */ double maxsignal; /* integrated peak amplitude */ double noise; /* integrated noise amplitude */ double lastenv[CYCLE]; /* last cycle amplitudes */ double lastint[CYCLE]; /* last integrated cycle amplitudes */ double lastsig; /* last carrier sample */ double xxing; /* phase detector interpolated output */ double fdelay; /* filter delay */ int envphase; /* envelope phase */ int envptr; /* envelope phase pointer */ int carphase; /* carrier phase */ int envsw; /* envelope state */ int envxing; /* envelope slice crossing */ int tc; /* time constant */ int tcount; /* time constant counter */ int badcnt; /* decimation interval counter */ /* * Decoder variables */ l_fp montime; /* reference timestamp for eyeball */ int timecnt; /* timecode counter */ int pulse; /* cycle counter */ int cycles; /* carrier cycles */ int dcycles; /* data cycles */ int xptr; /* translate table pointer */ int lastbit; /* last code element length */ int second; /* previous second */ int fieldcnt; /* subfield count in field */ int bits; /* demodulated bits */ int bitcnt; /* bit count in subfield */ }; /* * Function prototypes */ static int irig_start P((int, struct peer *)); static void irig_shutdown P((int, struct peer *)); static void irig_receive P((struct recvbuf *)); static void irig_poll P((int, struct peer *)); /* * More function prototypes */ static void irig_base P((struct peer *, double)); static void irig_rf P((struct peer *, double)); static void irig_decode P((struct peer *, int)); static void irig_gain P((struct peer *)); /* * Transfer vector */ struct refclock refclock_irig = { irig_start, /* start up driver */ irig_shutdown, /* shut down driver */ irig_poll, /* transmit poll message */ noentry, /* not used (old irig_control) */ noentry, /* initialize driver (not used) */ noentry, /* not used (old irig_buginfo) */ NOFLAGS /* not used */ }; /* * Global variables */ static char hexchar[] = { /* really quick decoding table */ '0', '8', '4', 'c', /* 0000 0001 0010 0011 */ '2', 'a', '6', 'e', /* 0100 0101 0110 0111 */ '1', '9', '5', 'd', /* 1000 1001 1010 1011 */ '3', 'b', '7', 'f' /* 1100 1101 1110 1111 */ }; /* * irig_start - open the devices and initialize data for processing */ static int irig_start( int unit, /* instance number (not used) */ struct peer *peer /* peer structure pointer */ ) { struct refclockproc *pp; struct irigunit *up; /* * Local variables */ int fd; /* file descriptor */ int i; /* index */ double step; /* codec adjustment */ /* * Open audio device */ fd = audio_init(DEVICE_AUDIO); if (fd < 0) return (0); #ifdef DEBUG if (debug) audio_show(); #endif /* * Allocate and initialize unit structure */ if (!(up = (struct irigunit *) emalloc(sizeof(struct irigunit)))) { (void) close(fd); return (0); } memset((char *)up, 0, sizeof(struct irigunit)); pp = peer->procptr; pp->unitptr = (caddr_t)up; pp->io.clock_recv = irig_receive; pp->io.srcclock = (caddr_t)peer; pp->io.datalen = 0; pp->io.fd = fd; if (!io_addclock(&pp->io)) { (void)close(fd); free(up); return (0); } /* * Initialize miscellaneous variables */ peer->precision = PRECISION; pp->clockdesc = DESCRIPTION; memcpy((char *)&pp->refid, REFID, 4); up->tc = MINTC; up->decim = 1; up->fdelay = IRIG_B; up->gain = 127; up->pollcnt = 2; /* * The companded samples are encoded sign-magnitude. The table * contains all the 256 values in the interest of speed. */ up->comp[0] = up->comp[OFFSET] = 0.; up->comp[1] = 1; up->comp[OFFSET + 1] = -1.; up->comp[2] = 3; up->comp[OFFSET + 2] = -3.; step = 2.; for (i = 3; i < OFFSET; i++) { up->comp[i] = up->comp[i - 1] + step; up->comp[OFFSET + i] = -up->comp[i]; if (i % 16 == 0) step *= 2.; } DTOLFP(1. / SECOND, &up->tick); return (1); } /* * irig_shutdown - shut down the clock */ static void irig_shutdown( int unit, /* instance number (not used) */ struct peer *peer /* peer structure pointer */ ) { struct refclockproc *pp; struct irigunit *up; pp = peer->procptr; up = (struct irigunit *)pp->unitptr; io_closeclock(&pp->io); free(up); } /* * irig_receive - receive data from the audio device * * This routine reads input samples and adjusts the logical clock to * track the irig clock by dropping or duplicating codec samples. */ static void irig_receive( struct recvbuf *rbufp /* receive buffer structure pointer */ ) { struct peer *peer; struct refclockproc *pp; struct irigunit *up; /* * Local variables */ double sample; /* codec sample */ u_char *dpt; /* buffer pointer */ l_fp ltemp; /* l_fp temp */ peer = (struct peer *)rbufp->recv_srcclock; pp = peer->procptr; up = (struct irigunit *)pp->unitptr; /* * Main loop - read until there ain't no more. Note codec * samples are bit-inverted. */ up->timestamp = rbufp->recv_time; up->bufcnt = rbufp->recv_length; DTOLFP((double)up->bufcnt / SECOND, <emp); L_SUB(&up->timestamp, <emp); dpt = rbufp->recv_buffer; for (up->bufptr = 0; up->bufptr < up->bufcnt; up->bufptr++) { sample = up->comp[~*dpt++ & 0xff]; /* * Clip noise spikes greater than MAXSIG. If no clips, * increase the gain a tad; if the clips are too high, * decrease a tad. Choose either IRIG-B or IRIG-E * according to the energy at the respective filter * output. */ if (sample > MAXSIG) { sample = MAXSIG; up->clipcnt++; } else if (sample < -MAXSIG) { sample = -MAXSIG; up->clipcnt++; } /* * Variable frequency oscillator. A phase change of one * unit produces a change of 360 degrees; a frequency * change of one unit produces a change of 1 Hz. */ up->phase += up->freq / SECOND; if (up->phase >= .5) { up->phase -= 1.; } else if (up->phase < -.5) { up->phase += 1.; irig_rf(peer, sample); irig_rf(peer, sample); } else { irig_rf(peer, sample); } L_ADD(&up->timestamp, &up->tick); /* * Once each second, determine the IRIG format, codec * port and gain. */ up->seccnt = (up->seccnt + 1) % SECOND; if (up->seccnt == 0) { if (up->irig_b > up->irig_e) { up->decim = 1; up->fdelay = IRIG_B; } else { up->decim = 10; up->fdelay = IRIG_E; } if (pp->sloppyclockflag & CLK_FLAG2) up->port = 2; else up->port = 1; irig_gain(peer); up->irig_b = up->irig_e = 0; } } /* * Squawk to the monitor speaker if enabled. */ if (pp->sloppyclockflag & CLK_FLAG3) if (write(pp->io.fd, (u_char *)&rbufp->recv_space, (u_int)up->bufcnt) < 0) perror("irig:"); } /* * irig_rf - RF processing * * This routine filters the RF signal using a highpass filter for IRIG-B * and a lowpass filter for IRIG-E. In case of IRIG-E, the samples are * decimated by a factor of ten. The lowpass filter functions also as a * decimation filter in this case. Note that the codec filters function * as roofing filters to attenuate both the high and low ends of the * passband. IIR filter coefficients were determined using Matlab Signal * Processing Toolkit. */ static void irig_rf( struct peer *peer, /* peer structure pointer */ double sample /* current signal sample */ ) { struct refclockproc *pp; struct irigunit *up; /* * Local variables */ double irig_b, irig_e; /* irig filter outputs */ pp = peer->procptr; up = (struct irigunit *)pp->unitptr; /* * IRIG-B filter. 4th-order elliptic, 800-Hz highpass, 0.3 dB * passband ripple, -50 dB stopband ripple, phase delay -.0022 * s) */ irig_b = (up->hpf[4] = up->hpf[3]) * 2.322484e-01; irig_b += (up->hpf[3] = up->hpf[2]) * -1.103929e+00; irig_b += (up->hpf[2] = up->hpf[1]) * 2.351081e+00; irig_b += (up->hpf[1] = up->hpf[0]) * -2.335036e+00; up->hpf[0] = sample - irig_b; irig_b = up->hpf[0] * 4.335855e-01 + up->hpf[1] * -1.695859e+00 + up->hpf[2] * 2.525004e+00 + up->hpf[3] * -1.695859e+00 + up->hpf[4] * 4.335855e-01; up->irig_b += irig_b * irig_b; /* * IRIG-E filter. 4th-order elliptic, 130-Hz lowpass, 0.3 dB * passband ripple, -50 dB stopband ripple, phase delay .0219 s. */ irig_e = (up->lpf[4] = up->lpf[3]) * 8.694604e-01; irig_e += (up->lpf[3] = up->lpf[2]) * -3.589893e+00; irig_e += (up->lpf[2] = up->lpf[1]) * 5.570154e+00; irig_e += (up->lpf[1] = up->lpf[0]) * -3.849667e+00; up->lpf[0] = sample - irig_e; irig_e = up->lpf[0] * 3.215696e-03 + up->lpf[1] * -1.174951e-02 + up->lpf[2] * 1.712074e-02 + up->lpf[3] * -1.174951e-02 + up->lpf[4] * 3.215696e-03; up->irig_e += irig_e * irig_e; /* * Decimate by a factor of either 1 (IRIG-B) or 10 (IRIG-E). */ up->badcnt = (up->badcnt + 1) % up->decim; if (up->badcnt == 0) { if (up->decim == 1) irig_base(peer, irig_b); else irig_base(peer, irig_e); } } /* * irig_base - baseband processing * * This routine processes the baseband signal and demodulates the AM * carrier using a synchronous detector. It then synchronizes to the * data frame at the baud rate and decodes the data pulses. */ static void irig_base( struct peer *peer, /* peer structure pointer */ double sample /* current signal sample */ ) { struct refclockproc *pp; struct irigunit *up; /* * Local variables */ double lope; /* integrator output */ double env; /* envelope detector output */ double dtemp; /* double temp */ int i; /* index temp */ pp = peer->procptr; up = (struct irigunit *)pp->unitptr; /* * Synchronous baud integrator. Corresponding samples of current * and past baud intervals are integrated to refine the envelope * amplitude and phase estimate. We keep one cycle of both the * raw and integrated data for later use. */ up->envphase = (up->envphase + 1) % BAUD; up->carphase = (up->carphase + 1) % CYCLE; up->integ[up->envphase] += (sample - up->integ[up->envphase]) / (5 * up->tc); lope = up->integ[up->envphase]; up->lastenv[up->carphase] = sample; up->lastint[up->carphase] = lope; /* * Phase detector. Sample amplitudes are integrated over the * baud interval. Cycle phase is determined from these * amplitudes using an eight-sample cyclic buffer. A phase * change of 360 degrees produces an output change of one unit. */ if (up->lastsig > 0 && lope <= 0) { up->xxing = lope / (up->lastsig - lope); up->zxing += (up->carphase - 4 + up->xxing) / 8.; } up->lastsig = lope; /* * Update signal/noise estimates and PLL phase/frequency. */ if (up->envphase == 0) { /* * Update envelope signal and noise estimates and mess * with error bits. */ up->maxsignal = up->intmax; up->noise = up->intmin; if (up->maxsignal < DRPOUT) up->errflg |= IRIG_ERR_AMP; if (up->intmax > 0) up->modndx = (up->intmax - up->intmin) / up->intmax; else up->modndx = 0; if (up->modndx < MODMIN) up->errflg |= IRIG_ERR_MOD; up->intmin = 1e6; up->intmax = 0; if (up->errflg & (IRIG_ERR_AMP | IRIG_ERR_FREQ | IRIG_ERR_MOD | IRIG_ERR_SYNCH)) { up->tc = MINTC; up->tcount = 0; } /* * Update PLL phase and frequency. The PLL time constant * is set initially to stabilize the frequency within a * minute or two, then increases to the maximum. The * frequency is clamped so that the PLL capture range * cannot be exceeded. */ dtemp = up->zxing * up->decim / BAUD; up->yxing = dtemp; up->zxing = 0.; up->phase += dtemp / up->tc; up->freq += dtemp / (4. * up->tc * up->tc); if (up->freq > MAXFREQ) { up->freq = MAXFREQ; up->errflg |= IRIG_ERR_FREQ; } else if (up->freq < -MAXFREQ) { up->freq = -MAXFREQ; up->errflg |= IRIG_ERR_FREQ; } } /* * Synchronous demodulator. There are eight samples in the cycle * and ten cycles in the baud interval. The amplitude of each * cycle is determined at the last sample in the cycle. The * beginning of the data pulse is determined from the integrated * samples, while the end of the pulse is determined from the * raw samples. The raw data bits are demodulated relative to * the slice level and left-shifted in the decoding register. */ if (up->carphase != 7) return; env = (up->lastenv[2] - up->lastenv[6]) / 2.; lope = (up->lastint[2] - up->lastint[6]) / 2.; if (lope > up->intmax) up->intmax = lope; if (lope < up->intmin) up->intmin = lope; /* * Pulse code demodulator and reference timestamp. The decoder * looks for a sequence of ten bits; the first two bits must be * one, the last two bits must be zero. Frame synch is asserted * when three correct frames have been found. */ up->pulse = (up->pulse + 1) % 10; if (up->pulse == 1) up->envmax = env; else if (up->pulse == 9) up->envmin = env; up->dcycles <<= 1; if (env >= (up->envmax + up->envmin) / 2.) up->dcycles |= 1; up->cycles <<= 1; if (lope >= (up->maxsignal + up->noise) / 2.) up->cycles |= 1; if ((up->cycles & 0x303c0f03) == 0x300c0300) { l_fp ltemp; int bitz; /* * The PLL time constant starts out small, in order to * sustain a frequency tolerance of 250 PPM. It * gradually increases as the loop settles down. Note * that small wiggles are not believed, unless they * persist for lots of samples. */ if (up->pulse != 9) up->errflg |= IRIG_ERR_SYNCH; up->pulse = 9; dtemp = BAUD - up->zxing; i = up->envxing - up->envphase; if (i < 0) i -= i; if (i <= 1) { up->tcount++; if (up->tcount > 50 * up->tc) { up->tc++; if (up->tc > MAXTC) up->tc = MAXTC; up->tcount = 0; up->envxing = up->envphase; } else { dtemp -= up->envxing - up->envphase; } } else { up->tcount = 0; up->envxing = up->envphase; } /* * Determine a reference timestamp, accounting for the * codec delay and filter delay. Note the timestamp is * for the previous frame, so we have to backtrack for * this plus the delay since the last carrier positive * zero crossing. */ DTOLFP(up->decim * (dtemp / SECOND + 1.) + up->fdelay, <emp); pp->lastrec = up->timestamp; L_SUB(&pp->lastrec, <emp); /* * The data bits are collected in ten-bit frames. The * first two and last two bits are determined by frame * sync and ignored here; the resulting patterns * represent zero (0-1 bits), one (2-4 bits) and * position identifier (5-6 bits). The remaining * patterns represent errors and are treated as zeros. */ bitz = up->dcycles & 0xfc; switch(bitz) { case 0x00: case 0x80: irig_decode(peer, BIT0); break; case 0xc0: case 0xe0: case 0xf0: irig_decode(peer, BIT1); break; case 0xf8: case 0xfc: irig_decode(peer, BITP); break; default: irig_decode(peer, 0); up->errflg |= IRIG_ERR_DECODE; } } } /* * irig_decode - decode the data * * This routine assembles bits into digits, digits into subfields and * subfields into the timecode field. Bits can have values of zero, one * or position identifier. There are four bits per digit, two digits per * subfield and ten subfields per field. The last bit in every subfield * and the first bit in the first subfield are position identifiers. */ static void irig_decode( struct peer *peer, /* peer structure pointer */ int bit /* data bit (0, 1 or 2) */ ) { struct refclockproc *pp; struct irigunit *up; /* * Local variables */ char syncchar; /* sync character (Spectracom only) */ char sbs[6]; /* binary seconds since 0h */ char spare[2]; /* mulligan digits */ pp = peer->procptr; up = (struct irigunit *)pp->unitptr; /* * Assemble subfield bits. */ up->bits <<= 1; if (bit == BIT1) { up->bits |= 1; } else if (bit == BITP && up->lastbit == BITP) { /* * Frame sync - two adjacent position identifiers. * Monitor the reference timestamp and wiggle the * clock, but only if no errors have occurred. */ up->bitcnt = 1; up->fieldcnt = 0; up->lastbit = 0; up->montime = pp->lastrec; if (up->errflg == 0) { up->timecnt++; refclock_process(pp); } if (up->timecnt >= MAXSTAGE) { refclock_receive(peer); up->timecnt = 0; up->pollcnt = 2; } up->errflg = 0; } up->bitcnt = (up->bitcnt + 1) % SUBFLD; if (up->bitcnt == 0) { /* * End of subfield. Encode two hexadecimal digits in * little-endian timecode field. */ if (up->fieldcnt == 0) up->bits <<= 1; if (up->xptr < 2) up->xptr = 2 * FIELD; up->timecode[--up->xptr] = hexchar[(up->bits >> 5) & 0xf]; up->timecode[--up->xptr] = hexchar[up->bits & 0xf]; up->fieldcnt = (up->fieldcnt + 1) % FIELD; if (up->fieldcnt == 0) { /* * End of field. Decode the timecode, adjust the * gain and set the input port. Set the port * here on the assumption somebody might even * change it on-wing. */ up->xptr = 2 * FIELD; if (sscanf((char *)up->timecode, "%6s%2d%c%2s%3d%2d%2d%2d", sbs, &pp->year, &syncchar, spare, &pp->day, &pp->hour, &pp->minute, &pp->second) != 8) pp->leap = LEAP_NOTINSYNC; else pp->leap = LEAP_NOWARNING; up->second = (up->second + up->decim) % 60; if (pp->second != up->second) up->errflg |= IRIG_ERR_CHECK; up->second = pp->second; sprintf(pp->a_lastcode, "%02x %c %2d %3d %02d:%02d:%02d %4.0f %3d %6.3f %2d %2d %6.3f %6.1f %s", up->errflg, syncchar, pp->year, pp->day, pp->hour, pp->minute, pp->second, up->maxsignal, up->gain, up->modndx, up->envxing, up->tc, up->yxing, up->freq * 1e6 / SECOND, ulfptoa(&up->montime, 6)); pp->lencode = strlen(pp->a_lastcode); if (up->timecnt == 0 || pp->sloppyclockflag & CLK_FLAG4) record_clock_stats(&peer->srcadr, pp->a_lastcode); #ifdef DEBUG if (debug > 2) printf("irig: %s\n", pp->a_lastcode); #endif /* DEBUG */ } } up->lastbit = bit; } /* * irig_poll - called by the transmit procedure * * This routine keeps track of status. If nothing is heard for two * successive poll intervals, a timeout event is declared and any * orphaned timecode updates are sent to foster care. */ static void irig_poll( int unit, /* instance number (not used) */ struct peer *peer /* peer structure pointer */ ) { struct refclockproc *pp; struct irigunit *up; pp = peer->procptr; up = (struct irigunit *)pp->unitptr; /* * Keep book for tattletales */ if (up->pollcnt == 0) { refclock_report(peer, CEVNT_TIMEOUT); up->timecnt = 0; return; } up->pollcnt--; pp->polls++; } /* * irig_gain - adjust codec gain * * This routine is called once each second. If the signal envelope * amplitude is too low, the codec gain is bumped up by four units; if * too high, it is bumped down. The decoder is relatively insensitive to * amplitude, so this crudity works just fine. The input port is set and * the error flag is cleared, mostly to be ornery. */ static void irig_gain( struct peer *peer /* peer structure pointer */ ) { struct refclockproc *pp; struct irigunit *up; pp = peer->procptr; up = (struct irigunit *)pp->unitptr; /* * Apparently, the codec uses only the high order bits of the * gain control field. Thus, it may take awhile for changes to * wiggle the hardware bits. */ if (up->clipcnt == 0) { up->gain += 4; if (up->gain > 255) up->gain = 255; } else if (up->clipcnt > SECOND / 100) { up->gain -= 4; if (up->gain < 0) up->gain = 0; } audio_gain(up->gain, up->port); up->clipcnt = 0; } #else int refclock_irig_bs; #endif /* REFCLOCK */