Annotation of embedaddon/ntp/ntpd/refclock_heath.c, revision 1.1
1.1 ! misho 1: /*
! 2: * refclock_heath - clock driver for Heath GC-1000
! 3: * (but no longer the GC-1001 Model II, which apparently never worked)
! 4: */
! 5:
! 6: #ifdef HAVE_CONFIG_H
! 7: # include <config.h>
! 8: #endif
! 9:
! 10: #if defined(REFCLOCK) && defined(CLOCK_HEATH)
! 11:
! 12: #include "ntpd.h"
! 13: #include "ntp_io.h"
! 14: #include "ntp_refclock.h"
! 15: #include "ntp_stdlib.h"
! 16:
! 17: #include <stdio.h>
! 18: #include <ctype.h>
! 19:
! 20: #ifdef HAVE_SYS_IOCTL_H
! 21: # include <sys/ioctl.h>
! 22: #endif /* not HAVE_SYS_IOCTL_H */
! 23:
! 24: /*
! 25: * This driver supports the Heath GC-1000 Most Accurate Clock, with
! 26: * RS232C Output Accessory. This is a WWV/WWVH receiver somewhat less
! 27: * robust than other supported receivers. Its claimed accuracy is 100 ms
! 28: * when actually synchronized to the broadcast signal, but this doesn't
! 29: * happen even most of the time, due to propagation conditions, ambient
! 30: * noise sources, etc. When not synchronized, the accuracy is at the
! 31: * whim of the internal clock oscillator, which can wander into the
! 32: * sunset without warning. Since the indicated precision is 100 ms,
! 33: * expect a host synchronized only to this thing to wander to and fro,
! 34: * occasionally being rudely stepped when the offset exceeds the default
! 35: * clock_max of 128 ms.
! 36: *
! 37: * There were two GC-1000 versions supported by this driver. The original
! 38: * GC-1000 with RS-232 output first appeared in 1983, but dissapeared
! 39: * from the market a few years later. The GC-1001 II with RS-232 output
! 40: * first appeared circa 1990, but apparently is no longer manufactured.
! 41: * The two models differ considerably, both in interface and commands.
! 42: * The GC-1000 has a pseudo-bipolar timecode output triggered by a RTS
! 43: * transition. The timecode includes both the day of year and time of
! 44: * day. The GC-1001 II has a true bipolar output and a complement of
! 45: * single character commands. The timecode includes only the time of
! 46: * day.
! 47: *
! 48: * The GC-1001 II was apparently never tested and, based on a Coverity
! 49: * scan, apparently never worked [Bug 689]. Related code has been disabled.
! 50: *
! 51: * GC-1000
! 52: *
! 53: * The internal DIPswitches should be set to operate in MANUAL mode. The
! 54: * external DIPswitches should be set to GMT and 24-hour format.
! 55: *
! 56: * In MANUAL mode the clock responds to a rising edge of the request to
! 57: * send (RTS) modem control line by sending the timecode. Therefore, it
! 58: * is necessary that the operating system implement the TIOCMBIC and
! 59: * TIOCMBIS ioctl system calls and TIOCM_RTS control bit. Present
! 60: * restrictions require the use of a POSIX-compatible programming
! 61: * interface, although other interfaces may work as well.
! 62: *
! 63: * A simple hardware modification to the clock can be made which
! 64: * prevents the clock hearing the request to send (RTS) if the HI SPEC
! 65: * lamp is out. Route the HISPEC signal to the tone decoder board pin
! 66: * 19, from the display, pin 19. Isolate pin 19 of the decoder board
! 67: * first, but maintain connection with pin 10. Also isolate pin 38 of
! 68: * the CPU on the tone board, and use half an added 7400 to gate the
! 69: * original signal to pin 38 with that from pin 19.
! 70: *
! 71: * The clock message consists of 23 ASCII printing characters in the
! 72: * following format:
! 73: *
! 74: * hh:mm:ss.f AM dd/mm/yr<cr>
! 75: *
! 76: * hh:mm:ss.f = hours, minutes, seconds
! 77: * f = deciseconds ('?' when out of spec)
! 78: * AM/PM/bb = blank in 24-hour mode
! 79: * dd/mm/yr = day, month, year
! 80: *
! 81: * The alarm condition is indicated by '?', rather than a digit, at f.
! 82: * Note that 0?:??:??.? is displayed before synchronization is first
! 83: * established and hh:mm:ss.? once synchronization is established and
! 84: * then lost again for about a day.
! 85: *
! 86: * GC-1001 II
! 87: *
! 88: * Commands consist of a single letter and are case sensitive. When
! 89: * enterred in lower case, a description of the action performed is
! 90: * displayed. When enterred in upper case the action is performed.
! 91: * Following is a summary of descriptions as displayed by the clock:
! 92: *
! 93: * The clock responds with a command The 'A' command returns an ASCII
! 94: * local time string: HH:MM:SS.T xx<CR>, where
! 95: *
! 96: * HH = hours
! 97: * MM = minutes
! 98: * SS = seconds
! 99: * T = tenths-of-seconds
! 100: * xx = 'AM', 'PM', or ' '
! 101: * <CR> = carriage return
! 102: *
! 103: * The 'D' command returns 24 pairs of bytes containing the variable
! 104: * divisor value at the end of each of the previous 24 hours. This
! 105: * allows the timebase trimming process to be observed. UTC hour 00 is
! 106: * always returned first. The first byte of each pair is the high byte
! 107: * of (variable divisor * 16); the second byte is the low byte of
! 108: * (variable divisor * 16). For example, the byte pair 3C 10 would be
! 109: * returned for a divisor of 03C1 hex (961 decimal).
! 110: *
! 111: * The 'I' command returns: | TH | TL | ER | DH | DL | U1 | I1 | I2 | ,
! 112: * where
! 113: *
! 114: * TH = minutes since timebase last trimmed (high byte)
! 115: * TL = minutes since timebase last trimmed (low byte)
! 116: * ER = last accumulated error in 1.25 ms increments
! 117: * DH = high byte of (current variable divisor * 16)
! 118: * DL = low byte of (current variable divisor * 16)
! 119: * U1 = UT1 offset (/.1 s): | + | 4 | 2 | 1 | 0 | 0 | 0 | 0 |
! 120: * I1 = information byte 1: | W | C | D | I | U | T | Z | 1 | ,
! 121: * where
! 122: *
! 123: * W = set by WWV(H)
! 124: * C = CAPTURE LED on
! 125: * D = TRIM DN LED on
! 126: * I = HI SPEC LED on
! 127: * U = TRIM UP LED on
! 128: * T = DST switch on
! 129: * Z = UTC switch on
! 130: * 1 = UT1 switch on
! 131: *
! 132: * I2 = information byte 2: | 8 | 8 | 4 | 2 | 1 | D | d | S | ,
! 133: * where
! 134: *
! 135: * 8, 8, 4, 2, 1 = TIME ZONE switch settings
! 136: * D = DST bit (#55) in last-received frame
! 137: * d = DST bit (#2) in last-received frame
! 138: * S = clock is in simulation mode
! 139: *
! 140: * The 'P' command returns 24 bytes containing the number of frames
! 141: * received without error during UTC hours 00 through 23, providing an
! 142: * indication of hourly propagation. These bytes are updated each hour
! 143: * to reflect the previous 24 hour period. UTC hour 00 is always
! 144: * returned first.
! 145: *
! 146: * The 'T' command returns the UTC time: | HH | MM | SS | T0 | , where
! 147: * HH = tens-of-hours and hours (packed BCD)
! 148: * MM = tens-of-minutes and minutes (packed BCD)
! 149: * SS = tens-of-seconds and seconds (packed BCD)
! 150: * T = tenths-of-seconds (BCD)
! 151: *
! 152: * Fudge Factors
! 153: *
! 154: * A fudge time1 value of .04 s appears to center the clock offset
! 155: * residuals. The fudge time2 parameter is the local time offset east of
! 156: * Greenwich, which depends on DST. Sorry about that, but the clock
! 157: * gives no hint on what the DIPswitches say.
! 158: */
! 159:
! 160: /*
! 161: * Interface definitions
! 162: */
! 163: #define DEVICE "/dev/heath%d" /* device name and unit */
! 164: #define PRECISION (-4) /* precision assumed (about 100 ms) */
! 165: #define REFID "WWV\0" /* reference ID */
! 166: #define DESCRIPTION "Heath GC-1000 Most Accurate Clock" /* WRU */
! 167:
! 168: #define LENHEATH1 23 /* min timecode length */
! 169: #if 0 /* BUG 689 */
! 170: #define LENHEATH2 13 /* min timecode length */
! 171: #endif
! 172:
! 173: /*
! 174: * Tables to compute the ddd of year form icky dd/mm timecode. Viva la
! 175: * leap.
! 176: */
! 177: static int day1tab[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
! 178: static int day2tab[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
! 179:
! 180: /*
! 181: * Baud rate table. The GC-1000 supports 1200, 2400 and 4800; the
! 182: * GC-1001 II supports only 9600.
! 183: */
! 184: static int speed[] = {B1200, B2400, B4800, B9600};
! 185:
! 186: /*
! 187: * Function prototypes
! 188: */
! 189: static int heath_start (int, struct peer *);
! 190: static void heath_shutdown (int, struct peer *);
! 191: static void heath_receive (struct recvbuf *);
! 192: static void heath_poll (int, struct peer *);
! 193:
! 194: /*
! 195: * Transfer vector
! 196: */
! 197: struct refclock refclock_heath = {
! 198: heath_start, /* start up driver */
! 199: heath_shutdown, /* shut down driver */
! 200: heath_poll, /* transmit poll message */
! 201: noentry, /* not used (old heath_control) */
! 202: noentry, /* initialize driver */
! 203: noentry, /* not used (old heath_buginfo) */
! 204: NOFLAGS /* not used */
! 205: };
! 206:
! 207:
! 208: /*
! 209: * heath_start - open the devices and initialize data for processing
! 210: */
! 211: static int
! 212: heath_start(
! 213: int unit,
! 214: struct peer *peer
! 215: )
! 216: {
! 217: struct refclockproc *pp;
! 218: int fd;
! 219: char device[20];
! 220:
! 221: /*
! 222: * Open serial port
! 223: */
! 224: snprintf(device, sizeof(device), DEVICE, unit);
! 225: if (!(fd = refclock_open(device, speed[peer->ttl & 0x3],
! 226: LDISC_REMOTE)))
! 227: return (0);
! 228: pp = peer->procptr;
! 229: pp->io.clock_recv = heath_receive;
! 230: pp->io.srcclock = (caddr_t)peer;
! 231: pp->io.datalen = 0;
! 232: pp->io.fd = fd;
! 233: if (!io_addclock(&pp->io)) {
! 234: close(fd);
! 235: pp->io.fd = -1;
! 236: return (0);
! 237: }
! 238:
! 239: /*
! 240: * Initialize miscellaneous variables
! 241: */
! 242: peer->precision = PRECISION;
! 243: peer->burst = NSTAGE;
! 244: pp->clockdesc = DESCRIPTION;
! 245: memcpy(&pp->refid, REFID, 4);
! 246: return (1);
! 247: }
! 248:
! 249:
! 250: /*
! 251: * heath_shutdown - shut down the clock
! 252: */
! 253: static void
! 254: heath_shutdown(
! 255: int unit,
! 256: struct peer *peer
! 257: )
! 258: {
! 259: struct refclockproc *pp;
! 260:
! 261: pp = peer->procptr;
! 262: if (-1 != pp->io.fd)
! 263: io_closeclock(&pp->io);
! 264: }
! 265:
! 266:
! 267: /*
! 268: * heath_receive - receive data from the serial interface
! 269: */
! 270: static void
! 271: heath_receive(
! 272: struct recvbuf *rbufp
! 273: )
! 274: {
! 275: struct refclockproc *pp;
! 276: struct peer *peer;
! 277: l_fp trtmp;
! 278: int month, day;
! 279: int i;
! 280: char dsec, a[5];
! 281:
! 282: /*
! 283: * Initialize pointers and read the timecode and timestamp
! 284: */
! 285: peer = (struct peer *)rbufp->recv_srcclock;
! 286: pp = peer->procptr;
! 287: pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode, BMAX,
! 288: &trtmp);
! 289:
! 290: /*
! 291: * We get down to business, check the timecode format and decode
! 292: * its contents. If the timecode has invalid length or is not in
! 293: * proper format, we declare bad format and exit.
! 294: */
! 295: switch (pp->lencode) {
! 296:
! 297: /*
! 298: * GC-1000 timecode format: "hh:mm:ss.f AM mm/dd/yy"
! 299: * GC-1001 II timecode format: "hh:mm:ss.f "
! 300: */
! 301: case LENHEATH1:
! 302: if (sscanf(pp->a_lastcode,
! 303: "%2d:%2d:%2d.%c%5c%2d/%2d/%2d", &pp->hour,
! 304: &pp->minute, &pp->second, &dsec, a, &month, &day,
! 305: &pp->year) != 8) {
! 306: refclock_report(peer, CEVNT_BADREPLY);
! 307: return;
! 308: }
! 309: break;
! 310:
! 311: #if 0 /* BUG 689 */
! 312: /*
! 313: * GC-1001 II timecode format: "hh:mm:ss.f "
! 314: */
! 315: case LENHEATH2:
! 316: if (sscanf(pp->a_lastcode, "%2d:%2d:%2d.%c", &pp->hour,
! 317: &pp->minute, &pp->second, &dsec) != 4) {
! 318: refclock_report(peer, CEVNT_BADREPLY);
! 319: return;
! 320: } else {
! 321: struct tm *tm_time_p;
! 322: time_t now;
! 323:
! 324: time(&now); /* we should grab 'now' earlier */
! 325: tm_time_p = gmtime(&now);
! 326: /*
! 327: * There is a window of time around midnight
! 328: * where this will Do The Wrong Thing.
! 329: */
! 330: if (tm_time_p) {
! 331: month = tm_time_p->tm_mon + 1;
! 332: day = tm_time_p->tm_mday;
! 333: } else {
! 334: refclock_report(peer, CEVNT_FAULT);
! 335: return;
! 336: }
! 337: }
! 338: break;
! 339: #endif
! 340:
! 341: default:
! 342: refclock_report(peer, CEVNT_BADREPLY);
! 343: return;
! 344: }
! 345:
! 346: /*
! 347: * We determine the day of the year from the DIPswitches. This
! 348: * should be fixed, since somebody might forget to set them.
! 349: * Someday this hazard will be fixed by a fiendish scheme that
! 350: * looks at the timecode and year the radio shows, then computes
! 351: * the residue of the seconds mod the seconds in a leap cycle.
! 352: * If in the third year of that cycle and the third and later
! 353: * months of that year, add one to the day. Then, correct the
! 354: * timecode accordingly. Icky pooh. This bit of nonsense could
! 355: * be avoided if the engineers had been required to write a
! 356: * device driver before finalizing the timecode format.
! 357: */
! 358: if (month < 1 || month > 12 || day < 1) {
! 359: refclock_report(peer, CEVNT_BADTIME);
! 360: return;
! 361: }
! 362: if (pp->year % 4) {
! 363: if (day > day1tab[month - 1]) {
! 364: refclock_report(peer, CEVNT_BADTIME);
! 365: return;
! 366: }
! 367: for (i = 0; i < month - 1; i++)
! 368: day += day1tab[i];
! 369: } else {
! 370: if (day > day2tab[month - 1]) {
! 371: refclock_report(peer, CEVNT_BADTIME);
! 372: return;
! 373: }
! 374: for (i = 0; i < month - 1; i++)
! 375: day += day2tab[i];
! 376: }
! 377: pp->day = day;
! 378:
! 379: /*
! 380: * Determine synchronization and last update
! 381: */
! 382: if (!isdigit((int)dsec))
! 383: pp->leap = LEAP_NOTINSYNC;
! 384: else {
! 385: pp->nsec = (dsec - '0') * 100000000;
! 386: pp->leap = LEAP_NOWARNING;
! 387: }
! 388: if (!refclock_process(pp))
! 389: refclock_report(peer, CEVNT_BADTIME);
! 390: }
! 391:
! 392:
! 393: /*
! 394: * heath_poll - called by the transmit procedure
! 395: */
! 396: static void
! 397: heath_poll(
! 398: int unit,
! 399: struct peer *peer
! 400: )
! 401: {
! 402: struct refclockproc *pp;
! 403: int bits = TIOCM_RTS;
! 404:
! 405: /*
! 406: * At each poll we check for timeout and toggle the RTS modem
! 407: * control line, then take a timestamp. Presumably, this is the
! 408: * event the radio captures to generate the timecode.
! 409: * Apparently, the radio takes about a second to make up its
! 410: * mind to send a timecode, so the receive timestamp is
! 411: * worthless.
! 412: */
! 413: pp = peer->procptr;
! 414:
! 415: /*
! 416: * We toggle the RTS modem control lead (GC-1000) and sent a T
! 417: * (GC-1001 II) to kick a timecode loose from the radio. This
! 418: * code works only for POSIX and SYSV interfaces. With bsd you
! 419: * are on your own. We take a timestamp between the up and down
! 420: * edges to lengthen the pulse, which should be about 50 usec on
! 421: * a Sun IPC. With hotshot CPUs, the pulse might get too short.
! 422: * Later.
! 423: *
! 424: * Bug 689: Even though we no longer support the GC-1001 II,
! 425: * I'm leaving the 'T' write in for timing purposes.
! 426: */
! 427: if (ioctl(pp->io.fd, TIOCMBIC, (char *)&bits) < 0)
! 428: refclock_report(peer, CEVNT_FAULT);
! 429: get_systime(&pp->lastrec);
! 430: if (write(pp->io.fd, "T", 1) != 1)
! 431: refclock_report(peer, CEVNT_FAULT);
! 432: ioctl(pp->io.fd, TIOCMBIS, (char *)&bits);
! 433: if (peer->burst > 0)
! 434: return;
! 435: if (pp->coderecv == pp->codeproc) {
! 436: refclock_report(peer, CEVNT_TIMEOUT);
! 437: return;
! 438: }
! 439: pp->lastref = pp->lastrec;
! 440: refclock_receive(peer);
! 441: record_clock_stats(&peer->srcadr, pp->a_lastcode);
! 442: #ifdef DEBUG
! 443: if (debug)
! 444: printf("heath: timecode %d %s\n", pp->lencode,
! 445: pp->a_lastcode);
! 446: #endif
! 447: peer->burst = MAXSTAGE;
! 448: pp->polls++;
! 449: }
! 450:
! 451: #else
! 452: int refclock_heath_bs;
! 453: #endif /* REFCLOCK */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_heath.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd