604 lines
16 KiB
C
604 lines
16 KiB
C
/*
|
|
* refclock_wwvb - clock driver for Spectracom WWVB and GPS receivers
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#if defined(REFCLOCK) && defined(CLOCK_SPECTRACOM)
|
|
|
|
#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>
|
|
|
|
#ifdef HAVE_PPSAPI
|
|
#include "ppsapi_timepps.h"
|
|
#include "refclock_atom.h"
|
|
#endif /* HAVE_PPSAPI */
|
|
|
|
/*
|
|
* This driver supports the Spectracom Model 8170 and Netclock/2 WWVB
|
|
* Synchronized Clocks and the Netclock/GPS Master Clock. Both the WWVB
|
|
* and GPS clocks have proven reliable sources of time; however, the
|
|
* WWVB clocks have proven vulnerable to high ambient conductive RF
|
|
* interference. The claimed accuracy of the WWVB clocks is 100 us
|
|
* relative to the broadcast signal, while the claimed accuracy of the
|
|
* GPS clock is 50 ns; however, in most cases the actual accuracy is
|
|
* limited by the resolution of the timecode and the latencies of the
|
|
* serial interface and operating system.
|
|
*
|
|
* The WWVB and GPS clocks should be configured for 24-hour display,
|
|
* AUTO DST off, time zone 0 (UTC), data format 0 or 2 (see below) and
|
|
* baud rate 9600. If the clock is to used as the source for the IRIG
|
|
* Audio Decoder (refclock_irig.c in this distribution), it should be
|
|
* configured for AM IRIG output and IRIG format 1 (IRIG B with
|
|
* signature control). The GPS clock can be configured either to respond
|
|
* to a 'T' poll character or left running continuously.
|
|
*
|
|
* There are two timecode formats used by these clocks. Format 0, which
|
|
* is available with both the Netclock/2 and 8170, and format 2, which
|
|
* is available only with the Netclock/2, specially modified 8170 and
|
|
* GPS.
|
|
*
|
|
* Format 0 (22 ASCII printing characters):
|
|
*
|
|
* <cr><lf>i ddd hh:mm:ss TZ=zz<cr><lf>
|
|
*
|
|
* on-time = first <cr>
|
|
* hh:mm:ss = hours, minutes, seconds
|
|
* i = synchronization flag (' ' = in synch, '?' = out of synch)
|
|
*
|
|
* The alarm condition is indicated by other than ' ' at i, which occurs
|
|
* during initial synchronization and when received signal is lost for
|
|
* about ten hours.
|
|
*
|
|
* Format 2 (24 ASCII printing characters):
|
|
*
|
|
* <cr><lf>iqyy ddd hh:mm:ss.fff ld
|
|
*
|
|
* on-time = <cr>
|
|
* i = synchronization flag (' ' = in synch, '?' = out of synch)
|
|
* q = quality indicator (' ' = locked, 'A'...'D' = unlocked)
|
|
* yy = year (as broadcast)
|
|
* ddd = day of year
|
|
* hh:mm:ss.fff = hours, minutes, seconds, milliseconds
|
|
*
|
|
* The alarm condition is indicated by other than ' ' at i, which occurs
|
|
* during initial synchronization and when received signal is lost for
|
|
* about ten hours. The unlock condition is indicated by other than ' '
|
|
* at q.
|
|
*
|
|
* The q is normally ' ' when the time error is less than 1 ms and a
|
|
* character in the set 'A'...'D' when the time error is less than 10,
|
|
* 100, 500 and greater than 500 ms respectively. The l is normally ' ',
|
|
* but is set to 'L' early in the month of an upcoming UTC leap second
|
|
* and reset to ' ' on the first day of the following month. The d is
|
|
* set to 'S' for standard time 'I' on the day preceding a switch to
|
|
* daylight time, 'D' for daylight time and 'O' on the day preceding a
|
|
* switch to standard time. The start bit of the first <cr> is
|
|
* synchronized to the indicated time as returned.
|
|
*
|
|
* This driver does not need to be told which format is in use - it
|
|
* figures out which one from the length of the message. The driver
|
|
* makes no attempt to correct for the intrinsic jitter of the radio
|
|
* itself, which is a known problem with the older radios.
|
|
*
|
|
* PPS Signal Processing
|
|
*
|
|
* When PPS signal processing is enabled, and when the system clock has
|
|
* been set by this or another driver and the PPS signal offset is
|
|
* within 0.4 s of the system clock offset, the PPS signal replaces the
|
|
* timecode for as long as the PPS signal is active. If for some reason
|
|
* the PPS signal fails for one or more poll intervals, the driver
|
|
* reverts to the timecode. If the timecode fails for one or more poll
|
|
* intervals, the PPS signal is disconnected.
|
|
*
|
|
* Fudge Factors
|
|
*
|
|
* This driver can retrieve a table of quality data maintained
|
|
* internally by the Netclock/2 clock. If flag4 of the fudge
|
|
* configuration command is set to 1, the driver will retrieve this
|
|
* table and write it to the clockstats file when the first timecode
|
|
* message of a new day is received.
|
|
*
|
|
* PPS calibration fudge time 1: format 0 .003134, format 2 .004034
|
|
*/
|
|
/*
|
|
* Interface definitions
|
|
*/
|
|
#define DEVICE "/dev/wwvb%d" /* device name and unit */
|
|
#define SPEED232 B9600 /* uart speed (9600 baud) */
|
|
#define PRECISION (-13) /* precision assumed (about 100 us) */
|
|
#define PPS_PRECISION (-13) /* precision assumed (about 100 us) */
|
|
#define REFID "WWVB" /* reference ID */
|
|
#define DESCRIPTION "Spectracom WWVB/GPS Receiver" /* WRU */
|
|
|
|
#define LENWWVB0 22 /* format 0 timecode length */
|
|
#define LENWWVB2 24 /* format 2 timecode length */
|
|
#define LENWWVB3 29 /* format 3 timecode length */
|
|
#define MONLIN 15 /* number of monitoring lines */
|
|
|
|
/*
|
|
* WWVB unit control structure
|
|
*/
|
|
struct wwvbunit {
|
|
#ifdef HAVE_PPSAPI
|
|
struct refclock_atom atom; /* PPSAPI structure */
|
|
int ppsapi_tried; /* attempt PPSAPI once */
|
|
int ppsapi_lit; /* time_pps_create() worked */
|
|
int tcount; /* timecode sample counter */
|
|
int pcount; /* PPS sample counter */
|
|
#endif /* HAVE_PPSAPI */
|
|
l_fp laststamp; /* last <CR> timestamp */
|
|
int prev_eol_cr; /* was last EOL <CR> (not <LF>)? */
|
|
u_char lasthour; /* last hour (for monitor) */
|
|
u_char linect; /* count ignored lines (for monitor */
|
|
};
|
|
|
|
/*
|
|
* Function prototypes
|
|
*/
|
|
static int wwvb_start (int, struct peer *);
|
|
static void wwvb_shutdown (int, struct peer *);
|
|
static void wwvb_receive (struct recvbuf *);
|
|
static void wwvb_poll (int, struct peer *);
|
|
static void wwvb_timer (int, struct peer *);
|
|
#ifdef HAVE_PPSAPI
|
|
static void wwvb_control (int, const struct refclockstat *,
|
|
struct refclockstat *, struct peer *);
|
|
#define WWVB_CONTROL wwvb_control
|
|
#else
|
|
#define WWVB_CONTROL noentry
|
|
#endif /* HAVE_PPSAPI */
|
|
|
|
/*
|
|
* Transfer vector
|
|
*/
|
|
struct refclock refclock_wwvb = {
|
|
wwvb_start, /* start up driver */
|
|
wwvb_shutdown, /* shut down driver */
|
|
wwvb_poll, /* transmit poll message */
|
|
WWVB_CONTROL, /* fudge set/change notification */
|
|
noentry, /* initialize driver (not used) */
|
|
noentry, /* not used (old wwvb_buginfo) */
|
|
wwvb_timer /* called once per second */
|
|
};
|
|
|
|
|
|
/*
|
|
* wwvb_start - open the devices and initialize data for processing
|
|
*/
|
|
static int
|
|
wwvb_start(
|
|
int unit,
|
|
struct peer *peer
|
|
)
|
|
{
|
|
register struct wwvbunit *up;
|
|
struct refclockproc *pp;
|
|
int fd;
|
|
char device[20];
|
|
|
|
/*
|
|
* Open serial port. Use CLK line discipline, if available.
|
|
*/
|
|
snprintf(device, sizeof(device), DEVICE, unit);
|
|
fd = refclock_open(device, SPEED232, LDISC_CLK);
|
|
if (fd <= 0)
|
|
return (0);
|
|
|
|
/*
|
|
* Allocate and initialize unit structure
|
|
*/
|
|
up = emalloc_zero(sizeof(*up));
|
|
pp = peer->procptr;
|
|
pp->io.clock_recv = wwvb_receive;
|
|
pp->io.srcclock = peer;
|
|
pp->io.datalen = 0;
|
|
pp->io.fd = fd;
|
|
if (!io_addclock(&pp->io)) {
|
|
close(fd);
|
|
pp->io.fd = -1;
|
|
free(up);
|
|
return (0);
|
|
}
|
|
pp->unitptr = up;
|
|
|
|
/*
|
|
* Initialize miscellaneous variables
|
|
*/
|
|
peer->precision = PRECISION;
|
|
pp->clockdesc = DESCRIPTION;
|
|
memcpy(&pp->refid, REFID, 4);
|
|
return (1);
|
|
}
|
|
|
|
|
|
/*
|
|
* wwvb_shutdown - shut down the clock
|
|
*/
|
|
static void
|
|
wwvb_shutdown(
|
|
int unit,
|
|
struct peer *peer
|
|
)
|
|
{
|
|
struct refclockproc * pp;
|
|
struct wwvbunit * up;
|
|
|
|
pp = peer->procptr;
|
|
up = pp->unitptr;
|
|
if (-1 != pp->io.fd)
|
|
io_closeclock(&pp->io);
|
|
if (NULL != up)
|
|
free(up);
|
|
}
|
|
|
|
|
|
/*
|
|
* wwvb_receive - receive data from the serial interface
|
|
*/
|
|
static void
|
|
wwvb_receive(
|
|
struct recvbuf *rbufp
|
|
)
|
|
{
|
|
struct wwvbunit *up;
|
|
struct refclockproc *pp;
|
|
struct peer *peer;
|
|
|
|
l_fp trtmp; /* arrival timestamp */
|
|
int tz; /* time zone */
|
|
int day, month; /* ddd conversion */
|
|
int temp; /* int temp */
|
|
char syncchar; /* synchronization indicator */
|
|
char qualchar; /* quality indicator */
|
|
char leapchar; /* leap indicator */
|
|
char dstchar; /* daylight/standard indicator */
|
|
char tmpchar; /* trashbin */
|
|
|
|
/*
|
|
* Initialize pointers and read the timecode and timestamp
|
|
*/
|
|
peer = rbufp->recv_peer;
|
|
pp = peer->procptr;
|
|
up = pp->unitptr;
|
|
temp = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &trtmp);
|
|
|
|
/*
|
|
* Note we get a buffer and timestamp for both a <cr> and <lf>,
|
|
* but only the <cr> timestamp is retained. Note: in format 0 on
|
|
* a Netclock/2 or upgraded 8170 the start bit is delayed 100
|
|
* +-50 us relative to the pps; however, on an unmodified 8170
|
|
* the start bit can be delayed up to 10 ms. In format 2 the
|
|
* reading precision is only to the millisecond. Thus, unless
|
|
* you have a PPS gadget and don't have to have the year, format
|
|
* 0 provides the lowest jitter.
|
|
* Save the timestamp of each <CR> in up->laststamp. Lines with
|
|
* no characters occur for every <LF>, and for some <CR>s when
|
|
* format 0 is used. Format 0 starts and ends each cycle with a
|
|
* <CR><LF> pair, format 2 starts each cycle with its only pair.
|
|
* The preceding <CR> is the on-time character for both formats.
|
|
* The timestamp provided with non-empty lines corresponds to
|
|
* the <CR> following the timecode, which is ultimately not used
|
|
* with format 0 and is used for the following timecode for
|
|
* format 2.
|
|
*/
|
|
if (temp == 0) {
|
|
if (up->prev_eol_cr) {
|
|
DPRINTF(2, ("wwvb: <LF> @ %s\n",
|
|
prettydate(&trtmp)));
|
|
} else {
|
|
up->laststamp = trtmp;
|
|
DPRINTF(2, ("wwvb: <CR> @ %s\n",
|
|
prettydate(&trtmp)));
|
|
}
|
|
up->prev_eol_cr = !up->prev_eol_cr;
|
|
return;
|
|
}
|
|
pp->lencode = temp;
|
|
pp->lastrec = up->laststamp;
|
|
up->laststamp = trtmp;
|
|
up->prev_eol_cr = TRUE;
|
|
DPRINTF(2, ("wwvb: code @ %s\n"
|
|
" using %s minus one char\n",
|
|
prettydate(&trtmp), prettydate(&pp->lastrec)));
|
|
if (L_ISZERO(&pp->lastrec))
|
|
return;
|
|
|
|
/*
|
|
* We get down to business, check the timecode format and decode
|
|
* its contents. This code uses the timecode length to determine
|
|
* format 0, 2 or 3. If the timecode has invalid length or is
|
|
* not in proper format, we declare bad format and exit.
|
|
*/
|
|
syncchar = qualchar = leapchar = dstchar = ' ';
|
|
tz = 0;
|
|
switch (pp->lencode) {
|
|
|
|
case LENWWVB0:
|
|
|
|
/*
|
|
* Timecode format 0: "I ddd hh:mm:ss DTZ=nn"
|
|
*/
|
|
if (sscanf(pp->a_lastcode,
|
|
"%c %3d %2d:%2d:%2d%c%cTZ=%2d",
|
|
&syncchar, &pp->day, &pp->hour, &pp->minute,
|
|
&pp->second, &tmpchar, &dstchar, &tz) == 8) {
|
|
pp->nsec = 0;
|
|
break;
|
|
}
|
|
goto bad_format;
|
|
|
|
case LENWWVB2:
|
|
|
|
/*
|
|
* Timecode format 2: "IQyy ddd hh:mm:ss.mmm LD" */
|
|
if (sscanf(pp->a_lastcode,
|
|
"%c%c %2d %3d %2d:%2d:%2d.%3ld %c",
|
|
&syncchar, &qualchar, &pp->year, &pp->day,
|
|
&pp->hour, &pp->minute, &pp->second, &pp->nsec,
|
|
&leapchar) == 9) {
|
|
pp->nsec *= 1000000;
|
|
break;
|
|
}
|
|
goto bad_format;
|
|
|
|
case LENWWVB3:
|
|
|
|
/*
|
|
* Timecode format 3: "0003I yyyymmdd hhmmss+0000SL#"
|
|
* WARNING: Undocumented, and the on-time character # is
|
|
* not yet handled correctly by this driver. It may be
|
|
* as simple as compensating for an additional 1/960 s.
|
|
*/
|
|
if (sscanf(pp->a_lastcode,
|
|
"0003%c %4d%2d%2d %2d%2d%2d+0000%c%c",
|
|
&syncchar, &pp->year, &month, &day, &pp->hour,
|
|
&pp->minute, &pp->second, &dstchar, &leapchar) == 8)
|
|
{
|
|
pp->day = ymd2yd(pp->year, month, day);
|
|
pp->nsec = 0;
|
|
break;
|
|
}
|
|
goto bad_format;
|
|
|
|
default:
|
|
bad_format:
|
|
|
|
/*
|
|
* Unknown format: If dumping internal table, record
|
|
* stats; otherwise, declare bad format.
|
|
*/
|
|
if (up->linect > 0) {
|
|
up->linect--;
|
|
record_clock_stats(&peer->srcadr,
|
|
pp->a_lastcode);
|
|
} else {
|
|
refclock_report(peer, CEVNT_BADREPLY);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Decode synchronization, quality and leap characters. If
|
|
* unsynchronized, set the leap bits accordingly and exit.
|
|
* Otherwise, set the leap bits according to the leap character.
|
|
* Once synchronized, the dispersion depends only on the
|
|
* quality character.
|
|
*/
|
|
switch (qualchar) {
|
|
|
|
case ' ':
|
|
pp->disp = .001;
|
|
pp->lastref = pp->lastrec;
|
|
break;
|
|
|
|
case 'A':
|
|
pp->disp = .01;
|
|
break;
|
|
|
|
case 'B':
|
|
pp->disp = .1;
|
|
break;
|
|
|
|
case 'C':
|
|
pp->disp = .5;
|
|
break;
|
|
|
|
case 'D':
|
|
pp->disp = MAXDISPERSE;
|
|
break;
|
|
|
|
default:
|
|
pp->disp = MAXDISPERSE;
|
|
refclock_report(peer, CEVNT_BADREPLY);
|
|
break;
|
|
}
|
|
if (syncchar != ' ')
|
|
pp->leap = LEAP_NOTINSYNC;
|
|
else if (leapchar == 'L')
|
|
pp->leap = LEAP_ADDSECOND;
|
|
else
|
|
pp->leap = LEAP_NOWARNING;
|
|
|
|
/*
|
|
* Process the new sample in the median filter and determine the
|
|
* timecode timestamp, but only if the PPS is not in control.
|
|
*/
|
|
#ifdef HAVE_PPSAPI
|
|
up->tcount++;
|
|
if (peer->flags & FLAG_PPS)
|
|
return;
|
|
|
|
#endif /* HAVE_PPSAPI */
|
|
if (!refclock_process_f(pp, pp->fudgetime2))
|
|
refclock_report(peer, CEVNT_BADTIME);
|
|
}
|
|
|
|
|
|
/*
|
|
* wwvb_timer - called once per second by the transmit procedure
|
|
*/
|
|
static void
|
|
wwvb_timer(
|
|
int unit,
|
|
struct peer *peer
|
|
)
|
|
{
|
|
register struct wwvbunit *up;
|
|
struct refclockproc *pp;
|
|
char pollchar; /* character sent to clock */
|
|
#ifdef DEBUG
|
|
l_fp now;
|
|
#endif
|
|
|
|
/*
|
|
* Time to poll the clock. The Spectracom clock responds to a
|
|
* 'T' by returning a timecode in the format(s) specified above.
|
|
* Note there is no checking on state, since this may not be the
|
|
* only customer reading the clock. Only one customer need poll
|
|
* the clock; all others just listen in.
|
|
*/
|
|
pp = peer->procptr;
|
|
up = pp->unitptr;
|
|
if (up->linect > 0)
|
|
pollchar = 'R';
|
|
else
|
|
pollchar = 'T';
|
|
if (write(pp->io.fd, &pollchar, 1) != 1)
|
|
refclock_report(peer, CEVNT_FAULT);
|
|
#ifdef DEBUG
|
|
get_systime(&now);
|
|
if (debug)
|
|
printf("%c poll at %s\n", pollchar, prettydate(&now));
|
|
#endif
|
|
#ifdef HAVE_PPSAPI
|
|
if (up->ppsapi_lit &&
|
|
refclock_pps(peer, &up->atom, pp->sloppyclockflag) > 0) {
|
|
up->pcount++,
|
|
peer->flags |= FLAG_PPS;
|
|
peer->precision = PPS_PRECISION;
|
|
}
|
|
#endif /* HAVE_PPSAPI */
|
|
}
|
|
|
|
|
|
/*
|
|
* wwvb_poll - called by the transmit procedure
|
|
*/
|
|
static void
|
|
wwvb_poll(
|
|
int unit,
|
|
struct peer *peer
|
|
)
|
|
{
|
|
register struct wwvbunit *up;
|
|
struct refclockproc *pp;
|
|
|
|
/*
|
|
* Sweep up the samples received since the last poll. If none
|
|
* are received, declare a timeout and keep going.
|
|
*/
|
|
pp = peer->procptr;
|
|
up = pp->unitptr;
|
|
pp->polls++;
|
|
|
|
/*
|
|
* If the monitor flag is set (flag4), we dump the internal
|
|
* quality table at the first timecode beginning the day.
|
|
*/
|
|
if (pp->sloppyclockflag & CLK_FLAG4 && pp->hour <
|
|
(int)up->lasthour)
|
|
up->linect = MONLIN;
|
|
up->lasthour = (u_char)pp->hour;
|
|
|
|
/*
|
|
* Process median filter samples. If none received, declare a
|
|
* timeout and keep going.
|
|
*/
|
|
#ifdef HAVE_PPSAPI
|
|
if (up->pcount == 0) {
|
|
peer->flags &= ~FLAG_PPS;
|
|
peer->precision = PRECISION;
|
|
}
|
|
if (up->tcount == 0) {
|
|
pp->coderecv = pp->codeproc;
|
|
refclock_report(peer, CEVNT_TIMEOUT);
|
|
return;
|
|
}
|
|
up->pcount = up->tcount = 0;
|
|
#else /* HAVE_PPSAPI */
|
|
if (pp->coderecv == pp->codeproc) {
|
|
refclock_report(peer, CEVNT_TIMEOUT);
|
|
return;
|
|
}
|
|
#endif /* HAVE_PPSAPI */
|
|
refclock_receive(peer);
|
|
record_clock_stats(&peer->srcadr, pp->a_lastcode);
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("wwvb: timecode %d %s\n", pp->lencode,
|
|
pp->a_lastcode);
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
* wwvb_control - fudge parameters have been set or changed
|
|
*/
|
|
#ifdef HAVE_PPSAPI
|
|
static void
|
|
wwvb_control(
|
|
int unit,
|
|
const struct refclockstat *in_st,
|
|
struct refclockstat *out_st,
|
|
struct peer *peer
|
|
)
|
|
{
|
|
register struct wwvbunit *up;
|
|
struct refclockproc *pp;
|
|
|
|
pp = peer->procptr;
|
|
up = pp->unitptr;
|
|
|
|
if (!(pp->sloppyclockflag & CLK_FLAG1)) {
|
|
if (!up->ppsapi_tried)
|
|
return;
|
|
up->ppsapi_tried = 0;
|
|
if (!up->ppsapi_lit)
|
|
return;
|
|
peer->flags &= ~FLAG_PPS;
|
|
peer->precision = PRECISION;
|
|
time_pps_destroy(up->atom.handle);
|
|
up->atom.handle = 0;
|
|
up->ppsapi_lit = 0;
|
|
return;
|
|
}
|
|
|
|
if (up->ppsapi_tried)
|
|
return;
|
|
/*
|
|
* Light up the PPSAPI interface.
|
|
*/
|
|
up->ppsapi_tried = 1;
|
|
if (refclock_ppsapi(pp->io.fd, &up->atom)) {
|
|
up->ppsapi_lit = 1;
|
|
return;
|
|
}
|
|
|
|
msyslog(LOG_WARNING, "%s flag1 1 but PPSAPI fails",
|
|
refnumtoa(&peer->srcadr));
|
|
}
|
|
#endif /* HAVE_PPSAPI */
|
|
|
|
#else
|
|
int refclock_wwvb_bs;
|
|
#endif /* REFCLOCK */
|