/* * refclock_arbiter - clock driver for Arbiter 1088A/B Satellite * Controlled Clock */ #ifdef HAVE_CONFIG_H #include <config.h> #endif #if defined(REFCLOCK) && defined(CLOCK_ARBITER) #include "ntpd.h" #include "ntp_io.h" #include "ntp_refclock.h" #include "ntp_stdlib.h" #include <stdio.h> #include <ctype.h> /* * This driver supports the Arbiter 1088A/B Satellite Controlled Clock. * The claimed accuracy of this clock is 100 ns relative to the PPS * output when receiving four or more satellites. * * The receiver should be configured before starting the NTP daemon, in * order to establish reliable position and operating conditions. It * does not initiate surveying or hold mode. For use with NTP, the * daylight savings time feature should be disables (D0 command) and the * broadcast mode set to operate in UTC (BU command). * * The timecode format supported by this driver is selected by the poll * sequence "B5", which initiates a line in the following format to be * repeated once per second until turned off by the "B0" poll sequence. * * Format B5 (24 ASCII printing characters): * * <cr><lf>i yy ddd hh:mm:ss.000bbb * * on-time = <cr> * i = synchronization flag (' ' = locked, '?' = unlocked) * yy = year of century * ddd = day of year * hh:mm:ss = hours, minutes, seconds * .000 = fraction of second (not used) * bbb = tailing spaces for fill * * The alarm condition is indicated by a '?' at i, which indicates the * receiver is not synchronized. In normal operation, a line consisting * of the timecode followed by the time quality character (TQ) followed * by the receiver status string (SR) is written to the clockstats file. * The time quality character is encoded in IEEE P1344 standard: * * Format TQ (IEEE P1344 estimated worst-case time quality) * * 0 clock locked, maximum accuracy * F clock failure, time not reliable * 4 clock unlocked, accuracy < 1 us * 5 clock unlocked, accuracy < 10 us * 6 clock unlocked, accuracy < 100 us * 7 clock unlocked, accuracy < 1 ms * 8 clock unlocked, accuracy < 10 ms * 9 clock unlocked, accuracy < 100 ms * A clock unlocked, accuracy < 1 s * B clock unlocked, accuracy < 10 s * * The status string is encoded as follows: * * Format SR (25 ASCII printing characters) * * V=vv S=ss T=t P=pdop E=ee * * vv = satellites visible * ss = relative signal strength * t = satellites tracked * pdop = position dilution of precision (meters) * ee = hardware errors * * If flag4 is set, an additional line consisting of the receiver * latitude (LA), longitude (LO), elevation (LH) (meters), and data * buffer (DB) is written to this file. If channel B is enabled for * deviation mode and connected to a 1-PPS signal, the last two numbers * on the line are the deviation and standard deviation averaged over * the last 15 seconds. * * PPS calibration fudge time1 .001240 */ /* * Interface definitions */ #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 " /* reference ID */ #define DESCRIPTION "Arbiter 1088A/B GPS Receiver" /* WRU */ #define LENARB 24 /* format B5 timecode length */ #define MAXSTA 40 /* max length of status string */ #define MAXPOS 80 /* max length of position string */ /* * ARB unit control structure */ struct arbunit { l_fp laststamp; /* last receive timestamp */ int tcswitch; /* timecode switch/counter */ char qualchar; /* IEEE P1344 quality (TQ command) */ char status[MAXSTA]; /* receiver status (SR command) */ char latlon[MAXPOS]; /* receiver position (lat/lon/alt) */ }; /* * Function prototypes */ static int arb_start (int, struct peer *); static void arb_shutdown (int, struct peer *); static void arb_receive (struct recvbuf *); static void arb_poll (int, struct peer *); /* * Transfer vector */ struct refclock refclock_arbiter = { arb_start, /* start up driver */ arb_shutdown, /* shut down driver */ arb_poll, /* transmit poll message */ noentry, /* not used (old arb_control) */ noentry, /* initialize driver (not used) */ noentry, /* not used (old arb_buginfo) */ NOFLAGS /* not used */ }; /* * arb_start - open the devices and initialize data for processing */ static int arb_start( int unit, struct peer *peer ) { register struct arbunit *up; struct refclockproc *pp; int fd; char device[20]; /* * Open serial port. Use CLK line discipline, if available. */ (void)sprintf(device, DEVICE, unit); if (!(fd = refclock_open(device, SPEED232, LDISC_CLK))) return (0); /* * Allocate and initialize unit structure */ if (!(up = (struct arbunit *)emalloc(sizeof(struct arbunit)))) { (void) close(fd); return (0); } memset((char *)up, 0, sizeof(struct arbunit)); pp = peer->procptr; pp->io.clock_recv = arb_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); } pp->unitptr = (caddr_t)up; /* * Initialize miscellaneous variables */ peer->precision = PRECISION; pp->clockdesc = DESCRIPTION; memcpy((char *)&pp->refid, REFID, 4); write(pp->io.fd, "B0", 2); return (1); } /* * arb_shutdown - shut down the clock */ static void arb_shutdown( int unit, struct peer *peer ) { register struct arbunit *up; struct refclockproc *pp; pp = peer->procptr; up = (struct arbunit *)pp->unitptr; io_closeclock(&pp->io); free(up); } /* * arb_receive - receive data from the serial interface */ static void arb_receive( struct recvbuf *rbufp ) { register struct arbunit *up; struct refclockproc *pp; struct peer *peer; l_fp trtmp; int temp; u_char syncchar; /* synch indicator */ char tbuf[BMAX]; /* temp buffer */ /* * Initialize pointers and read the timecode and timestamp */ peer = (struct peer *)rbufp->recv_srcclock; pp = peer->procptr; up = (struct arbunit *)pp->unitptr; temp = refclock_gtlin(rbufp, tbuf, BMAX, &trtmp); /* * Note we get a buffer and timestamp for both a <cr> and <lf>, * but only the <cr> timestamp is retained. The program first * sends a TQ and expects the echo followed by the time quality * character. It then sends a B5 starting the timecode broadcast * and expects the echo followed some time later by the on-time * character <cr> and then the <lf> beginning the timecode * itself. Finally, at the <cr> beginning the next timecode at * the next second, the program sends a B0 shutting down the * timecode broadcast. * * If flag4 is set, the program snatches the latitude, longitude * and elevation and writes it to the clockstats file. */ if (temp == 0) return; pp->lastrec = up->laststamp; up->laststamp = trtmp; if (temp < 3) return; if (up->tcswitch == 0) { /* * Collect statistics. If nothing is recogized, just * ignore; sometimes the clock doesn't stop spewing * timecodes for awhile after the B0 command. * * If flag4 is not set, send TQ, SR, B5. If flag4 is * sset, send TQ, SR, LA, LO, LH, DB, B5. When the * median filter is full, send B0. */ if (!strncmp(tbuf, "TQ", 2)) { up->qualchar = tbuf[2]; write(pp->io.fd, "SR", 2); return; } else if (!strncmp(tbuf, "SR", 2)) { strcpy(up->status, tbuf + 2); if (pp->sloppyclockflag & CLK_FLAG4) write(pp->io.fd, "LA", 2); else write(pp->io.fd, "B5", 2); return; } else if (!strncmp(tbuf, "LA", 2)) { strcpy(up->latlon, tbuf + 2); write(pp->io.fd, "LO", 2); return; } else if (!strncmp(tbuf, "LO", 2)) { strcat(up->latlon, " "); strcat(up->latlon, tbuf + 2); write(pp->io.fd, "LH", 2); return; } else if (!strncmp(tbuf, "LH", 2)) { strcat(up->latlon, " "); strcat(up->latlon, tbuf + 2); write(pp->io.fd, "DB", 2); return; } else if (!strncmp(tbuf, "DB", 2)) { strcat(up->latlon, " "); strcat(up->latlon, tbuf + 2); record_clock_stats(&peer->srcadr, up->latlon); #ifdef DEBUG if (debug) printf("arbiter: %s\n", up->latlon); #endif write(pp->io.fd, "B5", 2); } } /* * We get down to business, check the timecode format and decode * its contents. If the timecode has valid length, but not in * proper format, we declare bad format and exit. If the * timecode has invalid length, which sometimes occurs when the * B0 amputates the broadcast, we just quietly steal away. Note * that the time quality character and receiver status string is * tacked on the end for clockstats display. */ up->tcswitch++; if (up->tcswitch <= 1 || temp < LENARB) return; /* * Timecode format B5: "i yy ddd hh:mm:ss.000 " */ strncpy(pp->a_lastcode, tbuf, BMAX); pp->a_lastcode[LENARB - 2] = up->qualchar; strcat(pp->a_lastcode, up->status); pp->lencode = strlen(pp->a_lastcode); syncchar = ' '; if (sscanf(pp->a_lastcode, "%c%2d %3d %2d:%2d:%2d", &syncchar, &pp->year, &pp->day, &pp->hour, &pp->minute, &pp->second) != 6) { refclock_report(peer, CEVNT_BADREPLY); write(pp->io.fd, "B0", 2); return; } /* * We decode the clock dispersion from the time quality * character. */ switch (up->qualchar) { case '0': /* locked, max accuracy */ pp->disp = 1e-7; pp->lastref = pp->lastrec; break; case '4': /* unlock accuracy < 1 us */ pp->disp = 1e-6; break; case '5': /* unlock accuracy < 10 us */ pp->disp = 1e-5; break; case '6': /* unlock accuracy < 100 us */ pp->disp = 1e-4; break; case '7': /* unlock accuracy < 1 ms */ pp->disp = .001; break; case '8': /* unlock accuracy < 10 ms */ pp->disp = .01; break; case '9': /* unlock accuracy < 100 ms */ pp->disp = .1; break; case 'A': /* unlock accuracy < 1 s */ pp->disp = 1; break; case 'B': /* unlock accuracy < 10 s */ pp->disp = 10; break; case 'F': /* clock failure */ pp->disp = MAXDISPERSE; refclock_report(peer, CEVNT_FAULT); write(pp->io.fd, "B0", 2); return; default: pp->disp = MAXDISPERSE; refclock_report(peer, CEVNT_BADREPLY); write(pp->io.fd, "B0", 2); return; } if (syncchar != ' ') 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); else if (peer->disp > MAXDISTANCE) refclock_receive(peer); if (up->tcswitch >= MAXSTAGE) { write(pp->io.fd, "B0", 2); } } /* * arb_poll - called by the transmit procedure */ static void arb_poll( int unit, struct peer *peer ) { register struct arbunit *up; struct refclockproc *pp; /* * Time to poll the clock. The Arbiter clock responds to a "B5" * by returning a timecode in the format specified above. * Transmission occurs once per second, unless turned off by a * "B0". 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 = (struct arbunit *)pp->unitptr; pp->polls++; up->tcswitch = 0; if (write(pp->io.fd, "TQ", 2) != 2) refclock_report(peer, CEVNT_FAULT); /* * Process median filter samples. If none received, declare a * timeout and keep going. */ if (pp->coderecv == pp->codeproc) { refclock_report(peer, CEVNT_TIMEOUT); return; } refclock_receive(peer); record_clock_stats(&peer->srcadr, pp->a_lastcode); #ifdef DEBUG if (debug) printf("arbiter: timecode %d %s\n", pp->lencode, pp->a_lastcode); #endif } #else int refclock_arbiter_bs; #endif /* REFCLOCK */