389 lines
11 KiB
C
389 lines
11 KiB
C
/*
|
|
* refclock_as2201 - clock driver for the Austron 2201A GPS
|
|
* Timing Receiver
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#if defined(REFCLOCK) && defined(CLOCK_AS2201)
|
|
|
|
#include "ntpd.h"
|
|
#include "ntp_io.h"
|
|
#include "ntp_refclock.h"
|
|
#include "ntp_unixtime.h"
|
|
#include "ntp_stdlib.h"
|
|
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
|
|
/*
|
|
* This driver supports the Austron 2200A/2201A GPS Receiver with
|
|
* Buffered RS-232-C Interface Module. Note that the original 2200/2201
|
|
* receivers will not work reliably with this driver, since the older
|
|
* design cannot accept input commands at any reasonable data rate.
|
|
*
|
|
* The program sends a "*toc\r" to the radio and expects a response of
|
|
* the form "yy:ddd:hh:mm:ss.mmm\r" where yy = year of century, ddd =
|
|
* day of year, hh:mm:ss = second of day and mmm = millisecond of
|
|
* second. Then, it sends statistics commands to the radio and expects
|
|
* a multi-line reply showing the corresponding statistics or other
|
|
* selected data. Statistics commands are sent in order as determined by
|
|
* a vector of commands; these might have to be changed with different
|
|
* radio options. If flag4 of the fudge configuration command is set to
|
|
* 1, the statistics data are written to the clockstats file for later
|
|
* processing.
|
|
*
|
|
* In order for this code to work, the radio must be placed in non-
|
|
* interactive mode using the "off" command and with a single <cr>
|
|
* response using the "term cr" command. The setting of the "echo"
|
|
* and "df" commands does not matter. The radio should select UTC
|
|
* timescale using the "ts utc" command.
|
|
*
|
|
* There are two modes of operation for this driver. The first with
|
|
* default configuration is used with stock kernels and serial-line
|
|
* drivers and works with almost any machine. In this mode the driver
|
|
* assumes the radio captures a timestamp upon receipt of the "*" that
|
|
* begins the driver query. Accuracies in this mode are in the order of
|
|
* a millisecond or two and the receiver can be connected to only one
|
|
* host.
|
|
*
|
|
* The second mode of operation can be used for SunOS kernels that have
|
|
* been modified with the ppsclock streams module included in this
|
|
* distribution. The mode is enabled if flag3 of the fudge configuration
|
|
* command has been set to 1. In this mode a precise timestamp is
|
|
* available using a gadget box and 1-pps signal from the receiver. This
|
|
* improves the accuracy to the order of a few tens of microseconds. In
|
|
* addition, the serial output and 1-pps signal can be bussed to more
|
|
* than one hosts, but only one of them should be connected to the
|
|
* radio input data line.
|
|
*/
|
|
|
|
/*
|
|
* GPS Definitions
|
|
*/
|
|
#define SMAX 200 /* statistics buffer length */
|
|
#define DEVICE "/dev/gps%d" /* device name and unit */
|
|
#define SPEED232 B9600 /* uart speed (9600 baud) */
|
|
#define PRECISION (-20) /* precision assumed (about 1 us) */
|
|
#define REFID "GPS\0" /* reference ID */
|
|
#define DESCRIPTION "Austron 2201A GPS Receiver" /* WRU */
|
|
|
|
#define LENTOC 19 /* yy:ddd:hh:mm:ss.mmm timecode lngth */
|
|
|
|
/*
|
|
* AS2201 unit control structure.
|
|
*/
|
|
struct as2201unit {
|
|
char *lastptr; /* statistics buffer pointer */
|
|
char stats[SMAX]; /* statistics buffer */
|
|
int linect; /* count of lines remaining */
|
|
int index; /* current statistics command */
|
|
};
|
|
|
|
/*
|
|
* Radio commands to extract statitistics
|
|
*
|
|
* A command consists of an ASCII string terminated by a <cr> (\r). The
|
|
* command list consist of a sequence of commands terminated by a null
|
|
* string ("\0"). One command from the list is sent immediately
|
|
* following each received timecode (*toc\r command) and the ASCII
|
|
* strings received from the radio are saved along with the timecode in
|
|
* the clockstats file. Subsequent commands are sent at each timecode,
|
|
* with the last one in the list followed by the first one. The data
|
|
* received from the radio consist of ASCII strings, each terminated by
|
|
* a <cr> (\r) character. The number of strings for each command is
|
|
* specified as the first line of output as an ASCII-encode number. Note
|
|
* that the ETF command requires the Input Buffer Module and the LORAN
|
|
* commands require the LORAN Assist Module. However, if these modules
|
|
* are not installed, the radio and this driver will continue to operate
|
|
* successfuly, but no data will be captured for these commands.
|
|
*/
|
|
static char stat_command[][30] = {
|
|
"ITF\r", /* internal time/frequency */
|
|
"ETF\r", /* external time/frequency */
|
|
"LORAN ENSEMBLE\r", /* GPS/LORAN ensemble statistics */
|
|
"LORAN TDATA\r", /* LORAN signal data */
|
|
"ID;OPT;VER\r", /* model; options; software version */
|
|
|
|
"ITF\r", /* internal time/frequency */
|
|
"ETF\r", /* external time/frequency */
|
|
"LORAN ENSEMBLE\r", /* GPS/LORAN ensemble statistics */
|
|
"TRSTAT\r", /* satellite tracking status */
|
|
"POS;PPS;PPSOFF\r", /* position, pps source, offsets */
|
|
|
|
"ITF\r", /* internal time/frequency */
|
|
"ETF\r", /* external time/frequency */
|
|
"LORAN ENSEMBLE\r", /* GPS/LORAN ensemble statistics */
|
|
"LORAN TDATA\r", /* LORAN signal data */
|
|
"UTC\r", /* UTC leap info */
|
|
|
|
"ITF\r", /* internal time/frequency */
|
|
"ETF\r", /* external time/frequency */
|
|
"LORAN ENSEMBLE\r", /* GPS/LORAN ensemble statistics */
|
|
"TRSTAT\r", /* satellite tracking status */
|
|
"OSC;ET;TEMP\r", /* osc type; tune volts; oven temp */
|
|
"\0" /* end of table */
|
|
};
|
|
|
|
/*
|
|
* Function prototypes
|
|
*/
|
|
static int as2201_start (int, struct peer *);
|
|
static void as2201_shutdown (int, struct peer *);
|
|
static void as2201_receive (struct recvbuf *);
|
|
static void as2201_poll (int, struct peer *);
|
|
|
|
/*
|
|
* Transfer vector
|
|
*/
|
|
struct refclock refclock_as2201 = {
|
|
as2201_start, /* start up driver */
|
|
as2201_shutdown, /* shut down driver */
|
|
as2201_poll, /* transmit poll message */
|
|
noentry, /* not used (old as2201_control) */
|
|
noentry, /* initialize driver (not used) */
|
|
noentry, /* not used (old as2201_buginfo) */
|
|
NOFLAGS /* not used */
|
|
};
|
|
|
|
|
|
/*
|
|
* as2201_start - open the devices and initialize data for processing
|
|
*/
|
|
static int
|
|
as2201_start(
|
|
int unit,
|
|
struct peer *peer
|
|
)
|
|
{
|
|
register struct as2201unit *up;
|
|
struct refclockproc *pp;
|
|
int fd;
|
|
char gpsdev[20];
|
|
|
|
/*
|
|
* Open serial port. Use CLK line discipline, if available.
|
|
*/
|
|
snprintf(gpsdev, sizeof(gpsdev), DEVICE, unit);
|
|
fd = refclock_open(gpsdev, 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 = as2201_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((char *)&pp->refid, REFID, 4);
|
|
up->lastptr = up->stats;
|
|
up->index = 0;
|
|
return (1);
|
|
}
|
|
|
|
|
|
/*
|
|
* as2201_shutdown - shut down the clock
|
|
*/
|
|
static void
|
|
as2201_shutdown(
|
|
int unit,
|
|
struct peer *peer
|
|
)
|
|
{
|
|
register struct as2201unit *up;
|
|
struct refclockproc *pp;
|
|
|
|
pp = peer->procptr;
|
|
up = pp->unitptr;
|
|
if (-1 != pp->io.fd)
|
|
io_closeclock(&pp->io);
|
|
if (NULL != up)
|
|
free(up);
|
|
}
|
|
|
|
|
|
/*
|
|
* as2201__receive - receive data from the serial interface
|
|
*/
|
|
static void
|
|
as2201_receive(
|
|
struct recvbuf *rbufp
|
|
)
|
|
{
|
|
register struct as2201unit *up;
|
|
struct refclockproc *pp;
|
|
struct peer *peer;
|
|
l_fp trtmp;
|
|
size_t octets;
|
|
|
|
/*
|
|
* Initialize pointers and read the timecode and timestamp.
|
|
*/
|
|
peer = rbufp->recv_peer;
|
|
pp = peer->procptr;
|
|
up = pp->unitptr;
|
|
pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &trtmp);
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("gps: timecode %d %d %s\n",
|
|
up->linect, pp->lencode, pp->a_lastcode);
|
|
#endif
|
|
if (pp->lencode == 0)
|
|
return;
|
|
|
|
/*
|
|
* If linect is greater than zero, we must be in the middle of a
|
|
* statistics operation, so simply tack the received data at the
|
|
* end of the statistics string. If not, we could either have
|
|
* just received the timecode itself or a decimal number
|
|
* indicating the number of following lines of the statistics
|
|
* reply. In the former case, write the accumulated statistics
|
|
* data to the clockstats file and continue onward to process
|
|
* the timecode; in the later case, save the number of lines and
|
|
* quietly return.
|
|
*/
|
|
if (pp->sloppyclockflag & CLK_FLAG2)
|
|
pp->lastrec = trtmp;
|
|
if (up->linect > 0) {
|
|
up->linect--;
|
|
if ((int)(up->lastptr - up->stats + pp->lencode) > SMAX - 2)
|
|
return;
|
|
*up->lastptr++ = ' ';
|
|
memcpy(up->lastptr, pp->a_lastcode, 1 + pp->lencode);
|
|
up->lastptr += pp->lencode;
|
|
return;
|
|
} else {
|
|
if (pp->lencode == 1) {
|
|
up->linect = atoi(pp->a_lastcode);
|
|
return;
|
|
} else {
|
|
record_clock_stats(&peer->srcadr, up->stats);
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("gps: stat %s\n", up->stats);
|
|
#endif
|
|
}
|
|
}
|
|
up->lastptr = up->stats;
|
|
*up->lastptr = '\0';
|
|
|
|
/*
|
|
* We get down to business, check the timecode format and decode
|
|
* its contents. If the timecode has invalid length or is not in
|
|
* proper format, we declare bad format and exit.
|
|
*/
|
|
if (pp->lencode < LENTOC) {
|
|
refclock_report(peer, CEVNT_BADREPLY);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Timecode format: "yy:ddd:hh:mm:ss.mmm"
|
|
*/
|
|
if (sscanf(pp->a_lastcode, "%2d:%3d:%2d:%2d:%2d.%3ld", &pp->year,
|
|
&pp->day, &pp->hour, &pp->minute, &pp->second, &pp->nsec)
|
|
!= 6) {
|
|
refclock_report(peer, CEVNT_BADREPLY);
|
|
return;
|
|
}
|
|
pp->nsec *= 1000000;
|
|
|
|
/*
|
|
* Test for synchronization (this is a temporary crock).
|
|
*/
|
|
if (pp->a_lastcode[2] != ':')
|
|
pp->leap = LEAP_NOTINSYNC;
|
|
else
|
|
pp->leap = LEAP_NOWARNING;
|
|
|
|
/*
|
|
* Process the new sample in the median filter and determine the
|
|
* timecode timestamp.
|
|
*/
|
|
if (!refclock_process(pp)) {
|
|
refclock_report(peer, CEVNT_BADTIME);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If CLK_FLAG4 is set, initialize the statistics buffer and
|
|
* send the next command. If not, simply write the timecode to
|
|
* the clockstats file.
|
|
*/
|
|
if ((int)(up->lastptr - up->stats + pp->lencode) > SMAX - 2)
|
|
return;
|
|
memcpy(up->lastptr, pp->a_lastcode, pp->lencode);
|
|
up->lastptr += pp->lencode;
|
|
if (pp->sloppyclockflag & CLK_FLAG4) {
|
|
octets = strlen(stat_command[up->index]);
|
|
if ((int)(up->lastptr - up->stats + 1 + octets) > SMAX - 2)
|
|
return;
|
|
*up->lastptr++ = ' ';
|
|
memcpy(up->lastptr, stat_command[up->index], octets);
|
|
up->lastptr += octets - 1;
|
|
*up->lastptr = '\0';
|
|
(void)write(pp->io.fd, stat_command[up->index],
|
|
strlen(stat_command[up->index]));
|
|
up->index++;
|
|
if (*stat_command[up->index] == '\0')
|
|
up->index = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* as2201_poll - called by the transmit procedure
|
|
*
|
|
* We go to great pains to avoid changing state here, since there may be
|
|
* more than one eavesdropper receiving the same timecode.
|
|
*/
|
|
static void
|
|
as2201_poll(
|
|
int unit,
|
|
struct peer *peer
|
|
)
|
|
{
|
|
struct refclockproc *pp;
|
|
|
|
/*
|
|
* Send a "\r*toc\r" to get things going. We go to great pains
|
|
* to avoid changing state, since there may be more than one
|
|
* eavesdropper watching the radio.
|
|
*/
|
|
pp = peer->procptr;
|
|
if (write(pp->io.fd, "\r*toc\r", 6) != 6) {
|
|
refclock_report(peer, CEVNT_FAULT);
|
|
} else {
|
|
pp->polls++;
|
|
if (!(pp->sloppyclockflag & CLK_FLAG2))
|
|
get_systime(&pp->lastrec);
|
|
}
|
|
if (pp->coderecv == pp->codeproc) {
|
|
refclock_report(peer, CEVNT_TIMEOUT);
|
|
return;
|
|
}
|
|
refclock_receive(peer);
|
|
}
|
|
|
|
#else
|
|
int refclock_as2201_bs;
|
|
#endif /* REFCLOCK */
|