diff options
Diffstat (limited to 'contrib/ntp/ntpd/refclock_irig.c')
| -rw-r--r-- | contrib/ntp/ntpd/refclock_irig.c | 1079 |
1 files changed, 1079 insertions, 0 deletions
diff --git a/contrib/ntp/ntpd/refclock_irig.c b/contrib/ntp/ntpd/refclock_irig.c new file mode 100644 index 0000000..eccbda8 --- /dev/null +++ b/contrib/ntp/ntpd/refclock_irig.c @@ -0,0 +1,1079 @@ +/* + * refclock_irig - audio IRIG-B/E demodulator/decoder + */ +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#if defined(REFCLOCK) && defined(CLOCK_IRIG) + +#include <stdio.h> +#include <ctype.h> +#include <sys/time.h> +#include <math.h> +#ifdef HAVE_SYS_AUDIOIO_H +#include <sys/audioio.h> +#endif /* HAVE_SYS_AUDIOIO_H */ +#ifdef HAVE_SUN_AUDIOIO_H +#include <sun/audioio.h> +#endif /* HAVE_SUN_AUDIOIO_H */ +#ifdef HAVE_SYS_IOCTL_H +#include <sys/ioctl.h> +#endif /* HAVE_SYS_IOCTL_H */ + +#include "ntpd.h" +#include "ntp_io.h" +#include "ntp_refclock.h" +#include "ntp_calendar.h" +#include "ntp_stdlib.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 PRECISION (-17) /* precision assumed (about 10 us) */ +#define REFID "IRIG" /* reference ID */ +#define DESCRIPTION "Generic IRIG Audio Driver" /* WRU */ + +#define AUDIO_BUFSIZ 160 /* codec buffer size (Solaris only) */ +#define SAMPLES 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 * SAMPLES) /* 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 *)); +static int irig_audio P((void)); +static void irig_debug P((void)); + +/* + * 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 + */ +#ifdef HAVE_SYS_AUDIOIO_H +struct audio_device device; /* audio device ident */ +#endif /* HAVE_SYS_AUDIOIO_H */ +static struct audio_info info; /* audio device info */ +static int irig_ctl_fd; /* audio control file descriptor */ +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 = open("/dev/audio", O_RDWR | O_NONBLOCK, 0777); + if (fd == -1) { + perror("audio"); + return (0); + } + + /* + * 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 = (AUDIO_MAX_GAIN - AUDIO_MIN_GAIN) / 2; + if (irig_audio() < 0) { + io_closeclock(&pp->io); + return(0); + } + 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. / SAMPLES, &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 / SAMPLES, <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 / SAMPLES; + 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) % SAMPLES; + 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 = AUDIO_LINE_IN; + else + up->port = AUDIO_MICROPHONE; + irig_gain(peer); + up->clipcnt = 0; + 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 / SAMPLES + 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, info.record.gain, up->modndx, + up->envxing, up->tc, up->yxing, up->freq * + 1e6 / SAMPLES, 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. Set the new bits in the structure + * and call AUDIO_SETINFO. Upon return, the old bits are in the + * structure. + */ + if (up->clipcnt == 0) { + up->gain += 4; + if (up->gain > AUDIO_MAX_GAIN) + up->gain = AUDIO_MAX_GAIN; + } else if (up->clipcnt > SAMPLES / 100) { + up->gain -= 4; + if (up->gain < AUDIO_MIN_GAIN) + up->gain = AUDIO_MIN_GAIN; + } + AUDIO_INITINFO(&info); + info.record.port = up->port; + info.record.gain = up->gain; + info.record.error = 0; + ioctl(irig_ctl_fd, (int)AUDIO_SETINFO, &info); + if (info.record.error) + up->errflg |= IRIG_ERR_ERROR; +} + + +/* + * irig_audio - initialize audio device + * + * This code works with SunOS 4.1.3 and Solaris 2.6; however, it is + * believed generic and applicable to other systems with a minor twid + * or two. All it does is open the device, set the buffer size (Solaris + * only), preset the gain and set the input port. It assumes that the + * codec sample rate (8000 Hz), precision (8 bits), number of channels + * (1) and encoding (ITU-T G.711 mu-law companded) have been set by + * default. + */ +static int +irig_audio( + ) +{ + /* + * Open audio control device + */ + if ((irig_ctl_fd = open("/dev/audioctl", O_RDWR)) < 0) { + perror("audioctl"); + return(-1); + } +#ifdef HAVE_SYS_AUDIOIO_H + /* + * Set audio device parameters. + */ + AUDIO_INITINFO(&info); + info.record.buffer_size = AUDIO_BUFSIZ; + if (ioctl(irig_ctl_fd, (int)AUDIO_SETINFO, &info) < 0) { + perror("AUDIO_SETINFO"); + close(irig_ctl_fd); + return(-1); + } +#endif /* HAVE_SYS_AUDIOIO_H */ +#ifdef DEBUG + irig_debug(); +#endif /* DEBUG */ + return(0); +} + + +#ifdef DEBUG +/* + * irig_debug - display audio parameters + * + * This code doesn't really do anything, except satisfy curiousity and + * verify the ioctl's work. + */ +static void +irig_debug( + ) +{ + if (debug == 0) + return; +#ifdef HAVE_SYS_AUDIOIO_H + ioctl(irig_ctl_fd, (int)AUDIO_GETDEV, &device); + printf("irig: name %s, version %s, config %s\n", + device.name, device.version, device.config); +#endif /* HAVE_SYS_AUDIOIO_H */ + ioctl(irig_ctl_fd, (int)AUDIO_GETINFO, &info); + printf( + "irig: samples %d, channels %d, precision %d, encoding %d\n", + info.record.sample_rate, info.record.channels, + info.record.precision, info.record.encoding); +#ifdef HAVE_SYS_AUDIOIO_H + printf("irig: gain %d, port %d, buffer %d\n", + info.record.gain, info.record.port, + info.record.buffer_size); +#else /* HAVE_SYS_AUDIOIO_H */ + printf("irig: gain %d, port %d\n", + info.record.gain, info.record.port); +#endif /* HAVE_SYS_AUDIOIO_H */ + printf( + "irig: samples %d, eof %d, pause %d, error %d, waiting %d, balance %d\n", + info.record.samples, info.record.eof, + info.record.pause, info.record.error, + info.record.waiting, info.record.balance); +#ifdef __NetBSD__ + printf("irig: monitor %d, blocksize %d, hiwat %d, lowat %d, mode %d\n", + info.monitor_gain, info.blocksize, info.hiwat, info.lowat, info.mode); +#else /* __NetBSD__ */ + printf("irig: monitor %d, muted %d\n", + info.monitor_gain, info.output_muted); +#endif /* __NetBSD__ */ +} +#endif /* DEBUG */ + +#else +int refclock_irig_bs; +#endif /* REFCLOCK */ |
