Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
9a09fa34fb
NetBSD/dist/ntp/ntpd/refclock_irig.c
simonb 4ba759c886 Import ntp 4.0.99g
2000-03-29 12:38:44 +00:00

972 lines
28 KiB
C
Raw Blame History

/* $NetBSD: refclock_irig.c,v 1.1.1.1 2000/03/29 12:38:53 simonb Exp $ */
/*
* 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_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"
#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 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();
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, &ltemp);
L_SUB(&up->timestamp, &ltemp);
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,
&ltemp);
pp->lastrec = up->timestamp;
L_SUB(&pp->lastrec, &ltemp);
/*
* 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 */
Reference in New Issue View Git Blame Copy Permalink