1: /*
2: * refclock_wwvb - clock driver for Spectracom WWVB and GPS receivers
3: */
4:
5: #ifdef HAVE_CONFIG_H
6: #include <config.h>
7: #endif
8:
9: #if defined(REFCLOCK) && defined(CLOCK_SPECTRACOM)
10:
11: #include "ntpd.h"
12: #include "ntp_io.h"
13: #include "ntp_refclock.h"
14: #include "ntp_calendar.h"
15: #include "ntp_stdlib.h"
16:
17: #include <stdio.h>
18: #include <ctype.h>
19:
20: #ifdef HAVE_PPSAPI
21: #include "ppsapi_timepps.h"
22: #include "refclock_atom.h"
23: #endif /* HAVE_PPSAPI */
24:
25: /*
26: * This driver supports the Spectracom Model 8170 and Netclock/2 WWVB
27: * Synchronized Clocks and the Netclock/GPS Master Clock. Both the WWVB
28: * and GPS clocks have proven reliable sources of time; however, the
29: * WWVB clocks have proven vulnerable to high ambient conductive RF
30: * interference. The claimed accuracy of the WWVB clocks is 100 us
31: * relative to the broadcast signal, while the claimed accuracy of the
32: * GPS clock is 50 ns; however, in most cases the actual accuracy is
33: * limited by the resolution of the timecode and the latencies of the
34: * serial interface and operating system.
35: *
36: * The WWVB and GPS clocks should be configured for 24-hour display,
37: * AUTO DST off, time zone 0 (UTC), data format 0 or 2 (see below) and
38: * baud rate 9600. If the clock is to used as the source for the IRIG
39: * Audio Decoder (refclock_irig.c in this distribution), it should be
40: * configured for AM IRIG output and IRIG format 1 (IRIG B with
41: * signature control). The GPS clock can be configured either to respond
42: * to a 'T' poll character or left running continuously.
43: *
44: * There are two timecode formats used by these clocks. Format 0, which
45: * is available with both the Netclock/2 and 8170, and format 2, which
46: * is available only with the Netclock/2, specially modified 8170 and
47: * GPS.
48: *
49: * Format 0 (22 ASCII printing characters):
50: *
51: * <cr><lf>i ddd hh:mm:ss TZ=zz<cr><lf>
52: *
53: * on-time = first <cr>
54: * hh:mm:ss = hours, minutes, seconds
55: * i = synchronization flag (' ' = in synch, '?' = out of synch)
56: *
57: * The alarm condition is indicated by other than ' ' at i, which occurs
58: * during initial synchronization and when received signal is lost for
59: * about ten hours.
60: *
61: * Format 2 (24 ASCII printing characters):
62: *
63: * <cr><lf>iqyy ddd hh:mm:ss.fff ld
64: *
65: * on-time = <cr>
66: * i = synchronization flag (' ' = in synch, '?' = out of synch)
67: * q = quality indicator (' ' = locked, 'A'...'D' = unlocked)
68: * yy = year (as broadcast)
69: * ddd = day of year
70: * hh:mm:ss.fff = hours, minutes, seconds, milliseconds
71: *
72: * The alarm condition is indicated by other than ' ' at i, which occurs
73: * during initial synchronization and when received signal is lost for
74: * about ten hours. The unlock condition is indicated by other than ' '
75: * at q.
76: *
77: * The q is normally ' ' when the time error is less than 1 ms and a
78: * character in the set 'A'...'D' when the time error is less than 10,
79: * 100, 500 and greater than 500 ms respectively. The l is normally ' ',
80: * but is set to 'L' early in the month of an upcoming UTC leap second
81: * and reset to ' ' on the first day of the following month. The d is
82: * set to 'S' for standard time 'I' on the day preceding a switch to
83: * daylight time, 'D' for daylight time and 'O' on the day preceding a
84: * switch to standard time. The start bit of the first <cr> is
85: * synchronized to the indicated time as returned.
86: *
87: * This driver does not need to be told which format is in use - it
88: * figures out which one from the length of the message. The driver
89: * makes no attempt to correct for the intrinsic jitter of the radio
90: * itself, which is a known problem with the older radios.
91: *
92: * PPS Signal Processing
93: *
94: * When PPS signal processing is enabled, and when the system clock has
95: * been set by this or another driver and the PPS signal offset is
96: * within 0.4 s of the system clock offset, the PPS signal replaces the
97: * timecode for as long as the PPS signal is active. If for some reason
98: * the PPS signal fails for one or more poll intervals, the driver
99: * reverts to the timecode. If the timecode fails for one or more poll
100: * intervals, the PPS signal is disconnected.
101: *
102: * Fudge Factors
103: *
104: * This driver can retrieve a table of quality data maintained
105: * internally by the Netclock/2 clock. If flag4 of the fudge
106: * configuration command is set to 1, the driver will retrieve this
107: * table and write it to the clockstats file when the first timecode
108: * message of a new day is received.
109: *
110: * PPS calibration fudge time 1: format 0 .003134, format 2 .004034
111: */
112: /*
113: * Interface definitions
114: */
115: #define DEVICE "/dev/wwvb%d" /* device name and unit */
116: #define SPEED232 B9600 /* uart speed (9600 baud) */
117: #define PRECISION (-13) /* precision assumed (about 100 us) */
118: #define PPS_PRECISION (-13) /* precision assumed (about 100 us) */
119: #define REFID "WWVB" /* reference ID */
120: #define DESCRIPTION "Spectracom WWVB/GPS Receiver" /* WRU */
121:
122: #define LENWWVB0 22 /* format 0 timecode length */
123: #define LENWWVB2 24 /* format 2 timecode length */
124: #define LENWWVB3 29 /* format 3 timecode length */
125: #define MONLIN 15 /* number of monitoring lines */
126:
127: /*
128: * WWVB unit control structure
129: */
130: struct wwvbunit {
131: #ifdef HAVE_PPSAPI
132: struct refclock_atom atom; /* PPSAPI structure */
133: int ppsapi_tried; /* attempt PPSAPI once */
134: int ppsapi_lit; /* time_pps_create() worked */
135: int tcount; /* timecode sample counter */
136: int pcount; /* PPS sample counter */
137: #endif /* HAVE_PPSAPI */
138: l_fp laststamp; /* last <CR> timestamp */
139: int prev_eol_cr; /* was last EOL <CR> (not <LF>)? */
140: u_char lasthour; /* last hour (for monitor) */
141: u_char linect; /* count ignored lines (for monitor */
142: };
143:
144: /*
145: * Function prototypes
146: */
147: static int wwvb_start (int, struct peer *);
148: static void wwvb_shutdown (int, struct peer *);
149: static void wwvb_receive (struct recvbuf *);
150: static void wwvb_poll (int, struct peer *);
151: static void wwvb_timer (int, struct peer *);
152: #ifdef HAVE_PPSAPI
153: static void wwvb_control (int, const struct refclockstat *,
154: struct refclockstat *, struct peer *);
155: #define WWVB_CONTROL wwvb_control
156: #else
157: #define WWVB_CONTROL noentry
158: #endif /* HAVE_PPSAPI */
159:
160: /*
161: * Transfer vector
162: */
163: struct refclock refclock_wwvb = {
164: wwvb_start, /* start up driver */
165: wwvb_shutdown, /* shut down driver */
166: wwvb_poll, /* transmit poll message */
167: WWVB_CONTROL, /* fudge set/change notification */
168: noentry, /* initialize driver (not used) */
169: noentry, /* not used (old wwvb_buginfo) */
170: wwvb_timer /* called once per second */
171: };
172:
173:
174: /*
175: * wwvb_start - open the devices and initialize data for processing
176: */
177: static int
178: wwvb_start(
179: int unit,
180: struct peer *peer
181: )
182: {
183: register struct wwvbunit *up;
184: struct refclockproc *pp;
185: int fd;
186: char device[20];
187:
188: /*
189: * Open serial port. Use CLK line discipline, if available.
190: */
191: snprintf(device, sizeof(device), DEVICE, unit);
192: fd = refclock_open(device, SPEED232, LDISC_CLK);
193: if (fd <= 0)
194: return (0);
195:
196: /*
197: * Allocate and initialize unit structure
198: */
199: up = emalloc_zero(sizeof(*up));
200: pp = peer->procptr;
201: pp->io.clock_recv = wwvb_receive;
202: pp->io.srcclock = (void *)peer;
203: pp->io.datalen = 0;
204: pp->io.fd = fd;
205: if (!io_addclock(&pp->io)) {
206: close(fd);
207: pp->io.fd = -1;
208: free(up);
209: return (0);
210: }
211: pp->unitptr = up;
212:
213: /*
214: * Initialize miscellaneous variables
215: */
216: peer->precision = PRECISION;
217: pp->clockdesc = DESCRIPTION;
218: memcpy(&pp->refid, REFID, 4);
219: return (1);
220: }
221:
222:
223: /*
224: * wwvb_shutdown - shut down the clock
225: */
226: static void
227: wwvb_shutdown(
228: int unit,
229: struct peer *peer
230: )
231: {
232: register struct wwvbunit *up;
233: struct refclockproc *pp;
234:
235: pp = peer->procptr;
236: up = pp->unitptr;
237: if (-1 != pp->io.fd)
238: io_closeclock(&pp->io);
239: if (NULL != up)
240: free(up);
241: }
242:
243:
244: /*
245: * wwvb_receive - receive data from the serial interface
246: */
247: static void
248: wwvb_receive(
249: struct recvbuf *rbufp
250: )
251: {
252: struct wwvbunit *up;
253: struct refclockproc *pp;
254: struct peer *peer;
255:
256: l_fp trtmp; /* arrival timestamp */
257: int tz; /* time zone */
258: int day, month; /* ddd conversion */
259: int temp; /* int temp */
260: char syncchar; /* synchronization indicator */
261: char qualchar; /* quality indicator */
262: char leapchar; /* leap indicator */
263: char dstchar; /* daylight/standard indicator */
264: char tmpchar; /* trashbin */
265:
266: /*
267: * Initialize pointers and read the timecode and timestamp
268: */
269: peer = rbufp->recv_peer;
270: pp = peer->procptr;
271: up = pp->unitptr;
272: temp = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &trtmp);
273:
274: /*
275: * Note we get a buffer and timestamp for both a <cr> and <lf>,
276: * but only the <cr> timestamp is retained. Note: in format 0 on
277: * a Netclock/2 or upgraded 8170 the start bit is delayed 100
278: * +-50 us relative to the pps; however, on an unmodified 8170
279: * the start bit can be delayed up to 10 ms. In format 2 the
280: * reading precision is only to the millisecond. Thus, unless
281: * you have a PPS gadget and don't have to have the year, format
282: * 0 provides the lowest jitter.
283: * Save the timestamp of each <CR> in up->laststamp. Lines with
284: * no characters occur for every <LF>, and for some <CR>s when
285: * format 0 is used. Format 0 starts and ends each cycle with a
286: * <CR><LF> pair, format 2 starts each cycle with its only pair.
287: * The preceding <CR> is the on-time character for both formats.
288: * The timestamp provided with non-empty lines corresponds to
289: * the <CR> following the timecode, which is ultimately not used
290: * with format 0 and is used for the following timecode for
291: * format 2.
292: */
293: if (temp == 0) {
294: if (up->prev_eol_cr) {
295: DPRINTF(2, ("wwvb: <LF> @ %s\n",
296: prettydate(&trtmp)));
297: } else {
298: up->laststamp = trtmp;
299: DPRINTF(2, ("wwvb: <CR> @ %s\n",
300: prettydate(&trtmp)));
301: }
302: up->prev_eol_cr = !up->prev_eol_cr;
303: return;
304: }
305: pp->lencode = temp;
306: pp->lastrec = up->laststamp;
307: up->laststamp = trtmp;
308: up->prev_eol_cr = TRUE;
309: DPRINTF(2, ("wwvb: code @ %s\n"
310: " using %s minus one char\n",
311: prettydate(&trtmp), prettydate(&pp->lastrec)));
312: if (L_ISZERO(&pp->lastrec))
313: return;
314:
315: /*
316: * We get down to business, check the timecode format and decode
317: * its contents. This code uses the timecode length to determine
318: * format 0, 2 or 3. If the timecode has invalid length or is
319: * not in proper format, we declare bad format and exit.
320: */
321: syncchar = qualchar = leapchar = dstchar = ' ';
322: tz = 0;
323: switch (pp->lencode) {
324:
325: case LENWWVB0:
326:
327: /*
328: * Timecode format 0: "I ddd hh:mm:ss DTZ=nn"
329: */
330: if (sscanf(pp->a_lastcode,
331: "%c %3d %2d:%2d:%2d%c%cTZ=%2d",
332: &syncchar, &pp->day, &pp->hour, &pp->minute,
333: &pp->second, &tmpchar, &dstchar, &tz) == 8) {
334: pp->nsec = 0;
335: break;
336: }
337: goto bad_format;
338:
339: case LENWWVB2:
340:
341: /*
342: * Timecode format 2: "IQyy ddd hh:mm:ss.mmm LD" */
343: if (sscanf(pp->a_lastcode,
344: "%c%c %2d %3d %2d:%2d:%2d.%3ld %c",
345: &syncchar, &qualchar, &pp->year, &pp->day,
346: &pp->hour, &pp->minute, &pp->second, &pp->nsec,
347: &leapchar) == 9) {
348: pp->nsec *= 1000000;
349: break;
350: }
351: goto bad_format;
352:
353: case LENWWVB3:
354:
355: /*
356: * Timecode format 3: "0003I yyyymmdd hhmmss+0000SL#"
357: * WARNING: Undocumented, and the on-time character # is
358: * not yet handled correctly by this driver. It may be
359: * as simple as compensating for an additional 1/960 s.
360: */
361: if (sscanf(pp->a_lastcode,
362: "0003%c %4d%2d%2d %2d%2d%2d+0000%c%c",
363: &syncchar, &pp->year, &month, &day, &pp->hour,
364: &pp->minute, &pp->second, &dstchar, &leapchar) == 8)
365: {
366: pp->day = ymd2yd(pp->year, month, day);
367: pp->nsec = 0;
368: break;
369: }
370: goto bad_format;
371:
372: default:
373: bad_format:
374:
375: /*
376: * Unknown format: If dumping internal table, record
377: * stats; otherwise, declare bad format.
378: */
379: if (up->linect > 0) {
380: up->linect--;
381: record_clock_stats(&peer->srcadr,
382: pp->a_lastcode);
383: } else {
384: refclock_report(peer, CEVNT_BADREPLY);
385: }
386: return;
387: }
388:
389: /*
390: * Decode synchronization, quality and leap characters. If
391: * unsynchronized, set the leap bits accordingly and exit.
392: * Otherwise, set the leap bits according to the leap character.
393: * Once synchronized, the dispersion depends only on the
394: * quality character.
395: */
396: switch (qualchar) {
397:
398: case ' ':
399: pp->disp = .001;
400: pp->lastref = pp->lastrec;
401: break;
402:
403: case 'A':
404: pp->disp = .01;
405: break;
406:
407: case 'B':
408: pp->disp = .1;
409: break;
410:
411: case 'C':
412: pp->disp = .5;
413: break;
414:
415: case 'D':
416: pp->disp = MAXDISPERSE;
417: break;
418:
419: default:
420: pp->disp = MAXDISPERSE;
421: refclock_report(peer, CEVNT_BADREPLY);
422: break;
423: }
424: if (syncchar != ' ')
425: pp->leap = LEAP_NOTINSYNC;
426: else if (leapchar == 'L')
427: pp->leap = LEAP_ADDSECOND;
428: else
429: pp->leap = LEAP_NOWARNING;
430:
431: /*
432: * Process the new sample in the median filter and determine the
433: * timecode timestamp, but only if the PPS is not in control.
434: */
435: #ifdef HAVE_PPSAPI
436: up->tcount++;
437: if (peer->flags & FLAG_PPS)
438: return;
439:
440: #endif /* HAVE_PPSAPI */
441: if (!refclock_process_f(pp, pp->fudgetime2))
442: refclock_report(peer, CEVNT_BADTIME);
443: }
444:
445:
446: /*
447: * wwvb_timer - called once per second by the transmit procedure
448: */
449: static void
450: wwvb_timer(
451: int unit,
452: struct peer *peer
453: )
454: {
455: register struct wwvbunit *up;
456: struct refclockproc *pp;
457: char pollchar; /* character sent to clock */
458: l_fp now;
459:
460: /*
461: * Time to poll the clock. The Spectracom clock responds to a
462: * 'T' by returning a timecode in the format(s) specified above.
463: * Note there is no checking on state, since this may not be the
464: * only customer reading the clock. Only one customer need poll
465: * the clock; all others just listen in.
466: */
467: pp = peer->procptr;
468: up = pp->unitptr;
469: if (up->linect > 0)
470: pollchar = 'R';
471: else
472: pollchar = 'T';
473: if (write(pp->io.fd, &pollchar, 1) != 1)
474: refclock_report(peer, CEVNT_FAULT);
475: #ifdef DEBUG
476: get_systime(&now);
477: if (debug)
478: printf("%c poll at %s\n", pollchar, prettydate(&now));
479: #endif
480: #ifdef HAVE_PPSAPI
481: if (up->ppsapi_lit &&
482: refclock_pps(peer, &up->atom, pp->sloppyclockflag) > 0) {
483: up->pcount++,
484: peer->flags |= FLAG_PPS;
485: peer->precision = PPS_PRECISION;
486: }
487: #endif /* HAVE_PPSAPI */
488: }
489:
490:
491: /*
492: * wwvb_poll - called by the transmit procedure
493: */
494: static void
495: wwvb_poll(
496: int unit,
497: struct peer *peer
498: )
499: {
500: register struct wwvbunit *up;
501: struct refclockproc *pp;
502:
503: /*
504: * Sweep up the samples received since the last poll. If none
505: * are received, declare a timeout and keep going.
506: */
507: pp = peer->procptr;
508: up = pp->unitptr;
509: pp->polls++;
510:
511: /*
512: * If the monitor flag is set (flag4), we dump the internal
513: * quality table at the first timecode beginning the day.
514: */
515: if (pp->sloppyclockflag & CLK_FLAG4 && pp->hour <
516: (int)up->lasthour)
517: up->linect = MONLIN;
518: up->lasthour = (u_char)pp->hour;
519:
520: /*
521: * Process median filter samples. If none received, declare a
522: * timeout and keep going.
523: */
524: #ifdef HAVE_PPSAPI
525: if (up->pcount == 0) {
526: peer->flags &= ~FLAG_PPS;
527: peer->precision = PRECISION;
528: }
529: if (up->tcount == 0) {
530: pp->coderecv = pp->codeproc;
531: refclock_report(peer, CEVNT_TIMEOUT);
532: return;
533: }
534: up->pcount = up->tcount = 0;
535: #else /* HAVE_PPSAPI */
536: if (pp->coderecv == pp->codeproc) {
537: refclock_report(peer, CEVNT_TIMEOUT);
538: return;
539: }
540: #endif /* HAVE_PPSAPI */
541: refclock_receive(peer);
542: record_clock_stats(&peer->srcadr, pp->a_lastcode);
543: #ifdef DEBUG
544: if (debug)
545: printf("wwvb: timecode %d %s\n", pp->lencode,
546: pp->a_lastcode);
547: #endif
548: }
549:
550:
551: /*
552: * wwvb_control - fudge parameters have been set or changed
553: */
554: #ifdef HAVE_PPSAPI
555: static void
556: wwvb_control(
557: int unit,
558: const struct refclockstat *in_st,
559: struct refclockstat *out_st,
560: struct peer *peer
561: )
562: {
563: register struct wwvbunit *up;
564: struct refclockproc *pp;
565:
566: pp = peer->procptr;
567: up = pp->unitptr;
568:
569: if (!(pp->sloppyclockflag & CLK_FLAG1)) {
570: if (!up->ppsapi_tried)
571: return;
572: up->ppsapi_tried = 0;
573: if (!up->ppsapi_lit)
574: return;
575: peer->flags &= ~FLAG_PPS;
576: peer->precision = PRECISION;
577: time_pps_destroy(up->atom.handle);
578: up->atom.handle = 0;
579: up->ppsapi_lit = 0;
580: return;
581: }
582:
583: if (up->ppsapi_tried)
584: return;
585: /*
586: * Light up the PPSAPI interface.
587: */
588: up->ppsapi_tried = 1;
589: if (refclock_ppsapi(pp->io.fd, &up->atom)) {
590: up->ppsapi_lit = 1;
591: return;
592: }
593:
594: NLOG(NLOG_CLOCKINFO)
595: msyslog(LOG_WARNING, "%s flag1 1 but PPSAPI fails",
596: refnumtoa(&peer->srcadr));
597: }
598: #endif /* HAVE_PPSAPI */
599:
600: #else
601: int refclock_wwvb_bs;
602: #endif /* REFCLOCK */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_wwvb.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