2 * refclock_arc - clock driver for ARCRON MSF/DCF/WWVB receivers
9 #if defined(REFCLOCK) && defined(CLOCK_ARCRON_MSF)
10 static const char arc_version[] = { "V1.3 2003/02/21" };
12 /* define PRE_NTP420 for compatibility to previous versions of NTP (at least
16 #ifndef ARCRON_NOT_KEEN
17 #define ARCRON_KEEN 1 /* Be keen, and trusting of the clock, if defined. */
20 #ifndef ARCRON_NOT_MULTIPLE_SAMPLES
21 #define ARCRON_MULTIPLE_SAMPLES 1 /* Use all timestamp bytes as samples. */
24 #ifndef ARCRON_NOT_LEAPSECOND_KEEN
25 #ifndef ARCRON_LEAPSECOND_KEEN
26 #undef ARCRON_LEAPSECOND_KEEN /* Respond quickly to leap seconds: doesn't work yet. */
31 Code by Derek Mulcahy, <derek@toybox.demon.co.uk>, 1997.
32 Modifications by Damon Hart-Davis, <d@hd.org>, 1997.
33 Modifications by Paul Alfille, <palfille@partners.org>, 2003.
34 Modifications by Christopher Price, <cprice@cs-home.com>, 2003.
37 THIS CODE IS SUPPLIED AS IS, WITH NO WARRANTY OF ANY KIND. USE AT
40 Orginally developed and used with ntp3-5.85 by Derek Mulcahy.
42 Built against ntp3-5.90 on Solaris 2.5 using gcc 2.7.2.
44 This code may be freely copied and used and incorporated in other
45 systems providing the disclaimer and notice of authorship are
48 -------------------------------------------------------------------------------
52 MAJOR CHANGES SINCE V1.2
53 ========================
54 1) Applied patch by Andrey Bray <abuse@madhouse.demon.co.uk>
55 2001-02-17 comp.protocols.time.ntp
57 2) Added WWVB support via clock mode command, localtime/UTC time configured
58 via flag1=(0=UTC, 1=localtime)
60 3) Added ignore resync request via flag2=(0=resync, 1=ignore resync)
62 4) Added simplified conversion from localtime to UTC with dst/bst translation
64 5) Added average signal quality poll
66 6) Fixed a badformat error when no code is available due to stripping
69 7) Fixed a badformat error when clearing lencode & memset a_lastcode in poll
72 8) Lots of code cleanup, including standardized DEBUG macros and removal
75 -------------------------------------------------------------------------------
77 Author's original note:
79 I enclose my ntp driver for the Galleon Systems Arc MSF receiver.
81 It works (after a fashion) on both Solaris-1 and Solaris-2.
83 I am currently using ntp3-5.85. I have been running the code for
84 about 7 months without any problems. Even coped with the change to BST!
86 I had to do some funky things to read from the clock because it uses the
87 power from the receive lines to drive the transmit lines. This makes the
88 code look a bit stupid but it works. I also had to put in some delays to
89 allow for the turnaround time from receive to transmit. These delays
90 are between characters when requesting a time stamp so that shouldn't affect
91 the results too drastically.
95 The bottom line is that it works but could easily be improved. You are
96 free to do what you will with the code. I haven't been able to determine
97 how good the clock is. I think that this requires a known good clock
98 to compare it against.
100 -------------------------------------------------------------------------------
102 Damon's notes for adjustments:
104 MAJOR CHANGES SINCE V1.0
105 ========================
106 1) Removal of pollcnt variable that made the clock go permanently
107 off-line once two time polls failed to gain responses.
109 2) Avoiding (at least on Solaris-2) terminal becoming the controlling
110 terminal of the process when we do a low-level open().
112 3) Additional logic (conditional on ARCRON_LEAPSECOND_KEEN being
113 defined) to try to resync quickly after a potential leap-second
114 insertion or deletion.
116 4) Code significantly slimmer at run-time than V1.0.
122 1) The C preprocessor symbol to have the clock built has been changed
123 from ARC to ARCRON_MSF to CLOCK_ARCRON_MSF to minimise the
124 possiblity of clashes with other symbols in the future.
126 2) PRECISION should be -4/-5 (63ms/31ms) for the following reasons:
128 a) The ARC documentation claims the internal clock is (only)
129 accurate to about 20ms relative to Rugby (plus there must be
130 noticable drift and delay in the ms range due to transmission
131 delays and changing atmospheric effects). This clock is not
132 designed for ms accuracy as NTP has spoilt us all to expect.
134 b) The clock oscillator looks like a simple uncompensated quartz
135 crystal of the sort used in digital watches (ie 32768Hz) which
136 can have large temperature coefficients and drifts; it is not
137 clear if this oscillator is properly disciplined to the MSF
138 transmission, but as the default is to resync only once per
139 *day*, we can imagine that it is not, and is free-running. We
140 can minimise drift by resyncing more often (at the cost of
141 reduced battery life), but drift/wander may still be
144 c) Note that the bit time of 3.3ms adds to the potential error in
145 the the clock timestamp, since the bit clock of the serial link
146 may effectively be free-running with respect to the host clock
147 and the MSF clock. Actually, the error is probably 1/16th of
148 the above, since the input data is probably sampled at at least
151 By keeping the clock marked as not very precise, it will have a
152 fairly large dispersion, and thus will tend to be used as a
153 `backup' time source and sanity checker, which this clock is
154 probably ideal for. For an isolated network without other time
155 sources, this clock can probably be expected to provide *much*
156 better than 1s accuracy, which will be fine.
158 By default, PRECISION is set to -4, but experience, especially at a
159 particular geographic location with a particular clock, may allow
160 this to be altered to -5. (Note that skews of +/- 10ms are to be
161 expected from the clock from time-to-time.) This improvement of
162 reported precision can be instigated by setting flag3 to 1, though
163 the PRECISION will revert to the normal value while the clock
164 signal quality is unknown whatever the flag3 setting.
166 IN ANY CASE, BE SURE TO SET AN APPROPRIATE FUDGE FACTOR TO REMOVE
167 ANY RESIDUAL SKEW, eg:
169 server 127.127.27.0 # ARCRON MSF radio clock unit 0.
170 # Fudge timestamps by about 20ms.
171 fudge 127.127.27.0 time1 0.020
173 You will need to observe your system's behaviour, assuming you have
174 some other NTP source to compare it with, to work out what the
175 fudge factor should be. For my Sun SS1 running SunOS 4.1.3_U1 with
176 my MSF clock with my distance from the MSF transmitter, +20ms
177 seemed about right, after some observation.
179 3) REFID has been made "MSFa" to reflect the MSF time source and the
182 4) DEFAULT_RESYNC_TIME is the time in seconds (by default) before
183 forcing a resync since the last attempt. This is picked to give a
184 little less than an hour between resyncs and to try to avoid
185 clashing with any regular event at a regular time-past-the-hour
186 which might cause systematic errors.
188 The INITIAL_RESYNC_DELAY is to avoid bothering the clock and
189 running down its batteries unnecesarily if ntpd is going to crash
190 or be killed or reconfigured quickly. If ARCRON_KEEN is defined
191 then this period is long enough for (with normal polling rates)
192 enough time samples to have been taken to allow ntpd to sync to
193 the clock before the interruption for the clock to resync to MSF.
194 This avoids ntpd syncing to another peer first and then
195 almost immediately hopping to the MSF clock.
197 The RETRY_RESYNC_TIME is used before rescheduling a resync after a
198 resync failed to reveal a statisfatory signal quality (too low or
201 5) The clock seems quite jittery, so I have increased the
202 median-filter size from the typical (previous) value of 3. I
203 discard up to half the results in the filter. It looks like maybe
204 1 sample in 10 or so (maybe less) is a spike, so allow the median
205 filter to discard at least 10% of its entries or 1 entry, whichever
208 6) Sleeping *before* each character sent to the unit to allow required
209 inter-character time but without introducting jitter and delay in
210 handling the response if possible.
212 7) If the flag ARCRON_KEEN is defined, take time samples whenever
213 possible, even while resyncing, etc. We rely, in this case, on the
214 clock always giving us a reasonable time or else telling us in the
215 status byte at the end of the timestamp that it failed to sync to
216 MSF---thus we should never end up syncing to completely the wrong
219 8) If the flag ARCRON_OWN_FILTER is defined, use own versions of
220 refclock median-filter routines to get round small bug in 3-5.90
221 code which does not return the median offset. XXX Removed this
222 bit due NTP Version 4 upgrade - dlm.
224 9) We would appear to have a year-2000 problem with this clock since
225 it returns only the two least-significant digits of the year. But
226 ntpd ignores the year and uses the local-system year instead, so
227 this is in fact not a problem. Nevertheless, we attempt to do a
228 sensible thing with the dates, wrapping them into a 100-year
231 10)Logs stats information that can be used by Derek's Tcl/Tk utility
232 to show the status of the clock.
234 11)The clock documentation insists that the number of bits per
235 character to be sent to the clock, and sent by it, is 11, including
236 one start bit and two stop bits. The data format is either 7+even
243 * Eliminate use of scanf(), and maybe sprintf().
245 * Allow user setting of resync interval to trade battery life for
246 accuracy; maybe could be done via fudge factor or unit number.
248 * Possibly note the time since the last resync of the MSF clock to
249 MSF as the age of the last reference timestamp, ie trust the
250 clock's oscillator not very much...
252 * Add very slow auto-adjustment up to a value of +/- time2 to correct
253 for long-term errors in the clock value (time2 defaults to 0 so the
254 correction would be disabled by default).
256 * Consider trying to use the tty_clk/ppsclock support.
258 * Possibly use average or maximum signal quality reported during
259 resync, rather than just the last one, which may be atypical.
264 /* Notes for HKW Elektronik GmBH Radio clock driver */
265 /* Author Lyndon David, Sentinet Ltd, Feb 1997 */
266 /* These notes seem also to apply usefully to the ARCRON clock. */
268 /* The HKW clock module is a radio receiver tuned into the Rugby */
269 /* MSF time signal tranmitted on 60 kHz. The clock module connects */
270 /* to the computer via a serial line and transmits the time encoded */
271 /* in 15 bytes at 300 baud 7 bits two stop bits even parity */
273 /* Clock communications, from the datasheet */
274 /* All characters sent to the clock are echoed back to the controlling */
276 /* Transmit time/date information */
277 /* syntax ASCII o<cr> */
278 /* Character o may be replaced if neccesary by a character whose code */
279 /* contains the lowest four bits f(hex) eg */
280 /* syntax binary: xxxx1111 00001101 */
283 You have to wait for character echo + 10ms before sending next character.
286 /* The clock replies to this command with a sequence of 15 characters */
287 /* which contain the complete time and a final <cr> making 16 characters */
289 /* The RC computer clock will not reply immediately to this command because */
290 /* the start bit edge of the first reply character marks the beginning of */
291 /* the second. So the RC Computer Clock will reply to this command at the */
292 /* start of the next second */
293 /* The characters have the following meaning */
296 /* 3. minutes tens */
297 /* 4. minutes units */
298 /* 5. seconds tens */
299 /* 6. seconds units */
300 /* 7. day of week 1-monday 7-sunday */
301 /* 8. day of month tens */
302 /* 9. day of month units */
304 /* 11. month units */
307 /* 14. BST/UTC status */
313 /* bit 2 =1 if UTC is in effect, complementary to the BST bit */
314 /* bit 1 =1 if BST is in effect, according to the BST bit */
315 /* bit 0 BST/UTC change impending bit=1 in case of change impending */
321 /* bit 3 =1 if low battery is detected */
322 /* bit 2 =1 if the very last reception attempt failed and a valid */
323 /* time information already exists (bit0=1) */
324 /* =0 if the last reception attempt was successful */
325 /* bit 1 =1 if at least one reception since 2:30 am was successful */
326 /* =0 if no reception attempt since 2:30 am was successful */
327 /* bit 0 =1 if the RC Computer Clock contains valid time information */
328 /* This bit is zero after reset and one after the first */
329 /* successful reception attempt */
332 Also note g<cr> command which confirms that a resync is in progress, and
333 if so what signal quality (0--5) is available.
334 Also note h<cr> command which starts a resync to MSF signal.
340 #include "ntp_refclock.h"
341 #include "ntp_calendar.h"
342 #include "ntp_stdlib.h"
347 #if defined(HAVE_BSD_TTYS)
349 #endif /* HAVE_BSD_TTYS */
351 #if defined(HAVE_SYSV_TTYS)
353 #endif /* HAVE_SYSV_TTYS */
355 #if defined(HAVE_TERMIOS)
360 * This driver supports the ARCRON MSF/DCF/WWVB Radio Controlled Clock
364 * Interface definitions
366 #define DEVICE "/dev/arc%d" /* Device name and unit. */
367 #define SPEED B300 /* UART speed (300 baud) */
368 #define PRECISION (-4) /* Precision (~63 ms). */
369 #define HIGHPRECISION (-5) /* If things are going well... */
370 #define REFID "MSFa" /* Reference ID. */
371 #define REFID_MSF "MSF" /* Reference ID. */
372 #define REFID_DCF77 "DCF" /* Reference ID. */
373 #define REFID_WWVB "WWVB" /* Reference ID. */
374 #define DESCRIPTION "ARCRON MSF/DCF/WWVB Receiver"
382 #define LENARC 16 /* Format `o' timecode length. */
384 #define BITSPERCHAR 11 /* Bits per character. */
385 #define BITTIME 0x0DA740E /* Time for 1 bit at 300bps. */
386 #define CHARTIME10 0x8888888 /* Time for 10-bit char at 300bps. */
387 #define CHARTIME11 0x962FC96 /* Time for 11-bit char at 300bps. */
388 #define CHARTIME /* Time for char at 300bps. */ \
389 ( (BITSPERCHAR == 11) ? CHARTIME11 : ( (BITSPERCHAR == 10) ? CHARTIME10 : \
390 (BITSPERCHAR * BITTIME) ) )
392 /* Allow for UART to accept char half-way through final stop bit. */
393 #define INITIALOFFSET (u_int32)(-BITTIME/2)
396 charoffsets[x] is the time after the start of the second that byte
397 x (with the first byte being byte 1) is received by the UART,
398 assuming that the initial edge of the start bit of the first byte
399 is on-time. The values are represented as the fractional part of
402 We store enough values to have the offset of each byte including
403 the trailing \r, on the assumption that the bytes follow one
404 another without gaps.
406 static const u_int32 charoffsets[LENARC+1] = {
407 #if BITSPERCHAR == 11 /* Usual case. */
408 /* Offsets computed as accurately as possible... */
410 INITIALOFFSET + 0x0962fc96, /* 1 chars, 11 bits */
411 INITIALOFFSET + 0x12c5f92c, /* 2 chars, 22 bits */
412 INITIALOFFSET + 0x1c28f5c3, /* 3 chars, 33 bits */
413 INITIALOFFSET + 0x258bf259, /* 4 chars, 44 bits */
414 INITIALOFFSET + 0x2eeeeeef, /* 5 chars, 55 bits */
415 INITIALOFFSET + 0x3851eb85, /* 6 chars, 66 bits */
416 INITIALOFFSET + 0x41b4e81b, /* 7 chars, 77 bits */
417 INITIALOFFSET + 0x4b17e4b1, /* 8 chars, 88 bits */
418 INITIALOFFSET + 0x547ae148, /* 9 chars, 99 bits */
419 INITIALOFFSET + 0x5dddddde, /* 10 chars, 110 bits */
420 INITIALOFFSET + 0x6740da74, /* 11 chars, 121 bits */
421 INITIALOFFSET + 0x70a3d70a, /* 12 chars, 132 bits */
422 INITIALOFFSET + 0x7a06d3a0, /* 13 chars, 143 bits */
423 INITIALOFFSET + 0x8369d037, /* 14 chars, 154 bits */
424 INITIALOFFSET + 0x8ccccccd, /* 15 chars, 165 bits */
425 INITIALOFFSET + 0x962fc963 /* 16 chars, 176 bits */
427 /* Offsets computed with a small rounding error... */
429 INITIALOFFSET + 1 * CHARTIME,
430 INITIALOFFSET + 2 * CHARTIME,
431 INITIALOFFSET + 3 * CHARTIME,
432 INITIALOFFSET + 4 * CHARTIME,
433 INITIALOFFSET + 5 * CHARTIME,
434 INITIALOFFSET + 6 * CHARTIME,
435 INITIALOFFSET + 7 * CHARTIME,
436 INITIALOFFSET + 8 * CHARTIME,
437 INITIALOFFSET + 9 * CHARTIME,
438 INITIALOFFSET + 10 * CHARTIME,
439 INITIALOFFSET + 11 * CHARTIME,
440 INITIALOFFSET + 12 * CHARTIME,
441 INITIALOFFSET + 13 * CHARTIME,
442 INITIALOFFSET + 14 * CHARTIME,
443 INITIALOFFSET + 15 * CHARTIME,
444 INITIALOFFSET + 16 * CHARTIME
448 #define DEFAULT_RESYNC_TIME (57*60) /* Gap between resync attempts (s). */
449 #define RETRY_RESYNC_TIME (27*60) /* Gap to emergency resync attempt. */
451 #define INITIAL_RESYNC_DELAY 500 /* Delay before first resync. */
453 #define INITIAL_RESYNC_DELAY 50 /* Delay before first resync. */
456 static const int moff[12] =
457 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
458 /* Flags for a raw open() of the clock serial device. */
459 #ifdef O_NOCTTY /* Good, we can avoid tty becoming controlling tty. */
460 #define OPEN_FLAGS (O_RDWR | O_NOCTTY)
461 #else /* Oh well, it may not matter... */
462 #define OPEN_FLAGS (O_RDWR)
466 /* Length of queue of command bytes to be sent. */
467 #define CMDQUEUELEN 4 /* Enough for two cmds + each \r. */
468 /* Queue tick time; interval in seconds between chars taken off queue. */
469 /* Must be >= 2 to allow o\r response to come back uninterrupted. */
470 #define QUEUETICK 2 /* Allow o\r reply to finish. */
473 * ARC unit control structure
476 l_fp lastrec; /* Time tag for the receive time (system). */
477 int status; /* Clock status. */
479 int quality; /* Quality of reception 0--5 for unit. */
480 /* We may also use the values -1 or 6 internally. */
481 u_long quality_stamp; /* Next time to reset quality average. */
483 u_long next_resync; /* Next resync time (s) compared to current_time. */
484 int resyncing; /* Resync in progress if true. */
486 /* In the outgoing queue, cmdqueue[0] is next to be sent. */
487 char cmdqueue[CMDQUEUELEN+1]; /* Queue of outgoing commands + \0. */
489 u_long saved_flags; /* Saved fudge flags. */
492 #ifdef ARCRON_LEAPSECOND_KEEN
493 /* The flag `possible_leap' is set non-zero when any MSF unit
494 thinks a leap-second may have happened.
496 Set whenever we receive a valid time sample in the first hour of
497 the first day of the first/seventh months.
499 Outside the special hour this value is unconditionally set
500 to zero by the receive routine.
502 On finding itself in this timeslot, as long as the value is
503 non-negative, the receive routine sets it to a positive value to
504 indicate a resync to MSF should be performed.
506 In the poll routine, if this value is positive and we are not
507 already resyncing (eg from a sync that started just before
508 midnight), start resyncing and set this value negative to
509 indicate that a leap-triggered resync has been started. Having
510 set this negative prevents the receive routine setting it
511 positive and thus prevents multiple resyncs during the witching
514 static int possible_leap = 0; /* No resync required by default. */
518 static void dummy_event_handler P((struct peer *));
519 static void arc_event_handler P((struct peer *));
522 #define QUALITY_UNKNOWN -1 /* Indicates unknown clock quality. */
523 #define MIN_CLOCK_QUALITY 0 /* Min quality clock will return. */
524 #define MIN_CLOCK_QUALITY_OK 3 /* Min quality for OK reception. */
525 #define MAX_CLOCK_QUALITY 5 /* Max quality clock will return. */
528 * Function prototypes
530 static int arc_start P((int, struct peer *));
531 static void arc_shutdown P((int, struct peer *));
532 static void arc_receive P((struct recvbuf *));
533 static void arc_poll P((int, struct peer *));
538 struct refclock refclock_arc = {
539 arc_start, /* start up driver */
540 arc_shutdown, /* shut down driver */
541 arc_poll, /* transmit poll message */
542 noentry, /* not used (old arc_control) */
543 noentry, /* initialize driver (not used) */
544 noentry, /* not used (old arc_buginfo) */
545 NOFLAGS /* not used */
548 /* Queue us up for the next tick. */
549 #define ENQUEUE(up) \
551 peer->nextaction = current_time + QUEUETICK; \
554 /* Placeholder event handler---does nothing safely---soaks up loose tick. */
561 if(debug) { printf("arc: dummy_event_handler() called.\n"); }
566 Normal event handler.
568 Take first character off queue and send to clock if not a null.
570 Shift characters down and put a null on the end.
572 We assume that there is no parallelism so no race condition, but even
573 if there is nothing bad will happen except that we might send some bad
574 data to the clock once in a while.
581 struct refclockproc *pp = peer->procptr;
582 register struct arcunit *up = (struct arcunit *)pp->unitptr;
586 if(debug > 2) { printf("arc: arc_event_handler() called.\n"); }
589 c = up->cmdqueue[0]; /* Next char to be sent. */
590 /* Shift down characters, shifting trailing \0 in at end. */
591 for(i = 0; i < CMDQUEUELEN; ++i)
592 { up->cmdqueue[i] = up->cmdqueue[i+1]; }
594 /* Don't send '\0' characters. */
596 if(write(pp->io.fd, &c, 1) != 1) {
597 msyslog(LOG_NOTICE, "ARCRON: write to fd %d failed", pp->io.fd);
600 else if(debug) { printf("arc: sent `%2.2x', fd %d.\n", c, pp->io.fd); }
608 * arc_start - open the devices and initialize data for processing
616 register struct arcunit *up;
617 struct refclockproc *pp;
624 msyslog(LOG_NOTICE, "ARCRON: %s: opening unit %d", arc_version, unit);
627 printf("arc: %s: attempt to open unit %d.\n", arc_version, unit);
631 /* Prevent a ridiculous device number causing overflow of device[]. */
632 if((unit < 0) || (unit > 255)) { return(0); }
635 * Open serial port. Use CLK line discipline, if available.
637 (void)sprintf(device, DEVICE, unit);
638 if (!(fd = refclock_open(device, SPEED, LDISC_CLK)))
641 if(debug) { printf("arc: unit %d using open().\n", unit); }
643 fd = open(device, OPEN_FLAGS);
646 if(debug) { printf("arc: failed [open()] to open %s.\n", device); }
651 fcntl(fd, F_SETFL, 0); /* clear the descriptor flags */
654 { printf("arc: opened RS232 port with file descriptor %d.\n", fd); }
659 arg.c_iflag = IGNBRK | ISTRIP;
661 arg.c_cflag = B300 | CS8 | CREAD | CLOCAL | CSTOPB;
666 tcsetattr(fd, TCSANOW, &arg);
670 msyslog(LOG_ERR, "ARCRON: termios not supported in this driver");
677 up = (struct arcunit *) emalloc(sizeof(struct arcunit));
678 if(!up) { (void) close(fd); return(0); }
679 /* Set structure to all zeros... */
680 memset((char *)up, 0, sizeof(struct arcunit));
682 pp->io.clock_recv = arc_receive;
683 pp->io.srcclock = (caddr_t)peer;
686 if(!io_addclock(&pp->io)) { (void) close(fd); free(up); return(0); }
687 pp->unitptr = (caddr_t)up;
690 * Initialize miscellaneous variables
692 peer->precision = PRECISION;
693 peer->stratum = 2; /* Default to stratum 2 not 0. */
694 pp->clockdesc = DESCRIPTION;
695 if (peer->MODE > 3) {
696 msyslog(LOG_NOTICE, "ARCRON: Invalid mode %d", peer->MODE);
700 if(debug) { printf("arc: mode = %d.\n", peer->MODE); }
702 switch (peer->MODE) {
704 memcpy((char *)&pp->refid, REFID_MSF, 4);
707 memcpy((char *)&pp->refid, REFID_DCF77, 4);
710 memcpy((char *)&pp->refid, REFID_WWVB, 4);
713 memcpy((char *)&pp->refid, REFID, 4);
716 /* Spread out resyncs so that they should remain separated. */
717 up->next_resync = current_time + INITIAL_RESYNC_DELAY + (67*unit)%1009;
719 #if 0 /* Not needed because of zeroing of arcunit structure... */
720 up->resyncing = 0; /* Not resyncing yet. */
721 up->saved_flags = 0; /* Default is all flags off. */
722 /* Clear send buffer out... */
725 for(i = CMDQUEUELEN; i >= 0; --i) { up->cmdqueue[i] = '\0'; }
730 up->quality = QUALITY_UNKNOWN; /* Trust the clock immediately. */
732 up->quality = MIN_CLOCK_QUALITY;/* Don't trust the clock yet. */
735 peer->action = arc_event_handler;
744 * arc_shutdown - shut down the clock
752 register struct arcunit *up;
753 struct refclockproc *pp;
755 peer->action = dummy_event_handler;
758 up = (struct arcunit *)pp->unitptr;
759 io_closeclock(&pp->io);
764 Compute space left in output buffer.
768 register struct arcunit *up
773 /* Compute space left in buffer after any pending output. */
774 for(spaceleft = 0; spaceleft < CMDQUEUELEN; ++spaceleft)
775 { if(up->cmdqueue[CMDQUEUELEN - 1 - spaceleft] != '\0') { break; } }
780 Send command by copying into command buffer as far forward as possible,
781 after any pending output.
783 Indicate an error by returning 0 if there is not space for the command.
787 register struct arcunit *up,
793 int spaceleft = space_left(up);
796 if(debug > 1) { printf("arc: spaceleft = %d.\n", spaceleft); }
798 if(spaceleft < sl) { /* Should not normally happen... */
800 msyslog(LOG_NOTICE, "ARCRON: send-buffer overrun (%d/%d)",
803 return(0); /* FAILED! */
806 /* Copy in the command to be sent. */
807 while(*s) { up->cmdqueue[CMDQUEUELEN - spaceleft--] = *s++; }
813 /* Macro indicating action we will take for different quality values. */
814 #define quality_action(q) \
815 (((q) == QUALITY_UNKNOWN) ? "UNKNOWN, will use clock anyway" : \
816 (((q) < MIN_CLOCK_QUALITY_OK) ? "TOO POOR, will not use clock" : \
817 "OK, will use clock"))
820 * arc_receive - receive data from the serial interface
824 struct recvbuf *rbufp
827 register struct arcunit *up;
828 struct refclockproc *pp;
831 int i, n, wday, month, flags, status;
833 static int quality_average = 0;
834 static int quality_sum = 0;
835 static int quality_polls = 0;
838 * Initialize pointers and read the timecode and timestamp
840 peer = (struct peer *)rbufp->recv_srcclock;
842 up = (struct arcunit *)pp->unitptr;
846 If the command buffer is empty, and we are resyncing, insert a
847 g\r quality request into it to poll for signal quality again.
849 if((up->resyncing) && (space_left(up) == CMDQUEUELEN)) {
851 if(debug > 1) { printf("arc: inserting signal-quality poll.\n"); }
853 send_slow(up, pp->io.fd, "g\r");
857 The `arc_last_offset' is the offset in lastcode[] of the last byte
858 received, and which we assume actually received the input
861 (When we get round to using tty_clk and it is available, we
862 assume that we will receive the whole timecode with the
863 trailing \r, and that that \r will be timestamped. But this
864 assumption also works if receive the characters one-by-one.)
866 arc_last_offset = pp->lencode+rbufp->recv_length - 1;
869 We catch a timestamp iff:
871 * The command code is `o' for a timestamp.
873 * If ARCRON_MULTIPLE_SAMPLES is undefined then we must have
874 exactly char in the buffer (the command code) so that we
875 only sample the first character of the timecode as our
878 * The first character in the buffer is not the echoed `\r'
879 from the `o` command (so if we are to timestamp an `\r' it
880 must not be first in the receive buffer with lencode==1.
881 (Even if we had other characters following it, we probably
882 would have a premature timestamp on the '\r'.)
884 * We have received at least one character (I cannot imagine
885 how it could be otherwise, but anyway...).
887 c = rbufp->recv_buffer[0];
888 if((pp->a_lastcode[0] == 'o') &&
889 #ifndef ARCRON_MULTIPLE_SAMPLES
890 (pp->lencode == 1) &&
892 ((pp->lencode != 1) || (c != '\r')) &&
893 (arc_last_offset >= 1)) {
894 /* Note that the timestamp should be corrected if >1 char rcvd. */
896 timestamp = rbufp->recv_time;
898 if(debug) { /* Show \r as `R', other non-printing char as `?'. */
899 printf("arc: stamp -->%c<-- (%d chars rcvd)\n",
900 ((c == '\r') ? 'R' : (isgraph((int)c) ? c : '?')),
906 Now correct timestamp by offset of last byte received---we
907 subtract from the receive time the delay implied by the
908 extra characters received.
910 Reject the input if the resulting code is too long, but
911 allow for the trailing \r, normally not used but a good
912 handle for tty_clk or somesuch kernel timestamper.
914 if(arc_last_offset > LENARC) {
917 printf("arc: input code too long (%d cf %d); rejected.\n",
918 arc_last_offset, LENARC);
922 refclock_report(peer, CEVNT_BADREPLY);
926 L_SUBUF(×tamp, charoffsets[arc_last_offset]);
930 "arc: %s%d char(s) rcvd, the last for lastcode[%d]; -%sms offset applied.\n",
931 ((rbufp->recv_length > 1) ? "*** " : ""),
934 mfptoms((unsigned long)0,
935 charoffsets[arc_last_offset],
940 #ifdef ARCRON_MULTIPLE_SAMPLES
942 If taking multiple samples, capture the current adjusted
945 * No timestamp has yet been captured (it is zero), OR
947 * This adjusted timestamp is earlier than the one already
948 captured, on the grounds that this one suffered less
949 delay in being delivered to us and is more accurate.
952 if(L_ISZERO(&(up->lastrec)) ||
953 L_ISGEQ(&(up->lastrec), ×tamp))
958 printf("arc: system timestamp captured.\n");
959 #ifdef ARCRON_MULTIPLE_SAMPLES
960 if(!L_ISZERO(&(up->lastrec))) {
963 L_SUB(&diff, ×tamp);
964 printf("arc: adjusted timestamp by -%sms.\n",
965 mfptoms(diff.l_i, diff.l_f, 3));
970 up->lastrec = timestamp;
975 /* Just in case we still have lots of rubbish in the buffer... */
976 /* ...and to avoid the same timestamp being reused by mistake, */
977 /* eg on receipt of the \r coming in on its own after the */
979 if(pp->lencode >= LENARC) {
981 if(debug && (rbufp->recv_buffer[0] != '\r'))
982 { printf("arc: rubbish in pp->a_lastcode[].\n"); }
988 /* Append input to code buffer, avoiding overflow. */
989 for(i = 0; i < rbufp->recv_length; i++) {
990 if(pp->lencode >= LENARC) { break; } /* Avoid overflow... */
991 c = rbufp->recv_buffer[i];
993 /* Drop trailing '\r's and drop `h' command echo totally. */
994 if(c != '\r' && c != 'h') { pp->a_lastcode[pp->lencode++] = c; }
997 If we've just put an `o' in the lastcode[0], clear the
998 timestamp in anticipation of a timecode arriving soon.
1000 We would expect to get to process this before any of the
1003 if((c == 'o') && (pp->lencode == 1)) {
1004 L_CLR(&(up->lastrec));
1006 if(debug > 1) { printf("arc: clearing timestamp.\n"); }
1010 if (pp->lencode == 0) return;
1012 /* Handle a quality message. */
1013 if(pp->a_lastcode[0] == 'g') {
1016 if(pp->lencode < 3) { return; } /* Need more data... */
1017 r = (pp->a_lastcode[1] & 0x7f); /* Strip parity. */
1018 q = (pp->a_lastcode[2] & 0x7f); /* Strip parity. */
1019 if(((q & 0x70) != 0x30) || ((q & 0xf) > MAX_CLOCK_QUALITY) ||
1020 ((r & 0x70) != 0x30)) {
1021 /* Badly formatted response. */
1023 if(debug) { printf("arc: bad `g' response %2x %2x.\n", r, q); }
1027 if(r == '3') { /* Only use quality value whilst sync in progress. */
1028 if (up->quality_stamp < current_time) {
1029 struct calendar cal;
1032 get_systime (&new_stamp);
1033 caljulian (new_stamp.l_ui, &cal);
1035 current_time + 60 - cal.second + 5;
1039 quality_sum += (q & 0xf);
1041 quality_average = (quality_sum / quality_polls);
1043 if(debug) { printf("arc: signal quality %d (%d).\n", quality_average, (q & 0xf)); }
1045 } else if( /* (r == '2') && */ up->resyncing) {
1046 up->quality = quality_average;
1050 printf("arc: sync finished, signal quality %d: %s\n",
1052 quality_action(up->quality));
1056 "ARCRON: sync finished, signal quality %d: %s",
1058 quality_action(up->quality));
1059 up->resyncing = 0; /* Resync is over. */
1060 quality_average = 0;
1065 /* Clock quality dubious; resync earlier than usual. */
1066 if((up->quality == QUALITY_UNKNOWN) ||
1067 (up->quality < MIN_CLOCK_QUALITY_OK))
1068 { up->next_resync = current_time + RETRY_RESYNC_TIME; }
1075 /* Stop now if this is not a timecode message. */
1076 if(pp->a_lastcode[0] != 'o') {
1078 refclock_report(peer, CEVNT_BADREPLY);
1082 /* If we don't have enough data, wait for more... */
1083 if(pp->lencode < LENARC) { return; }
1086 /* WE HAVE NOW COLLECTED ONE TIMESTAMP (phew)... */
1088 if(debug > 1) { printf("arc: NOW HAVE TIMESTAMP...\n"); }
1091 /* But check that we actually captured a system timestamp on it. */
1092 if(L_ISZERO(&(up->lastrec))) {
1094 if(debug) { printf("arc: FAILED TO GET SYSTEM TIMESTAMP\n"); }
1097 refclock_report(peer, CEVNT_BADREPLY);
1101 Append a mark of the clock's received signal quality for the
1102 benefit of Derek Mulcahy's Tcl/Tk utility (we map the `unknown'
1103 quality value to `6' for his s/w) and terminate the string for
1104 sure. This should not go off the buffer end.
1106 pp->a_lastcode[pp->lencode] = ((up->quality == QUALITY_UNKNOWN) ?
1107 '6' : ('0' + up->quality));
1108 pp->a_lastcode[pp->lencode + 1] = '\0'; /* Terminate for printf(). */
1111 /* We don't use the micro-/milli- second part... */
1115 /* We don't use the nano-second part... */
1118 n = sscanf(pp->a_lastcode, "o%2d%2d%2d%1d%2d%2d%2d%1d%1d",
1119 &pp->hour, &pp->minute, &pp->second,
1120 &wday, &pp->day, &month, &pp->year, &flags, &status);
1122 /* Validate format and numbers. */
1125 /* Would expect to have caught major problems already... */
1126 if(debug) { printf("arc: badly formatted data.\n"); }
1129 refclock_report(peer, CEVNT_BADREPLY);
1133 Validate received values at least enough to prevent internal
1134 array-bounds problems, etc.
1136 if((pp->hour < 0) || (pp->hour > 23) ||
1137 (pp->minute < 0) || (pp->minute > 59) ||
1138 (pp->second < 0) || (pp->second > 60) /*Allow for leap seconds.*/ ||
1139 (wday < 1) || (wday > 7) ||
1140 (pp->day < 1) || (pp->day > 31) ||
1141 (month < 1) || (month > 12) ||
1142 (pp->year < 0) || (pp->year > 99)) {
1143 /* Data out of range. */
1145 refclock_report(peer, CEVNT_BADREPLY);
1150 if(peer->MODE == 0) { /* compatiblity to original version */
1152 /* Check that BST/UTC bits are the complement of one another. */
1153 if(!(bst & 2) == !(bst & 4)) {
1155 refclock_report(peer, CEVNT_BADREPLY);
1159 if(status & 0x8) { msyslog(LOG_NOTICE, "ARCRON: battery low"); }
1161 /* Year-2000 alert! */
1162 /* Attempt to wrap 2-digit date into sensible window. */
1163 if(pp->year < YEAR_PIVOT) { pp->year += 100; } /* Y2KFixes */
1164 pp->year += 1900; /* use full four-digit year */ /* Y2KFixes */
1166 Attempt to do the right thing by screaming that the code will
1167 soon break when we get to the end of its useful life. What a
1168 hero I am... PLEASE FIX LEAP-YEAR AND WRAP CODE IN 209X!
1170 if(pp->year >= YEAR_PIVOT+2000-2 ) { /* Y2KFixes */
1171 /*This should get attention B^> */
1173 "ARCRON: fix me! EITHER YOUR DATE IS BADLY WRONG or else I will break soon!");
1177 printf("arc: n=%d %02d:%02d:%02d %02d/%02d/%04d %1d %1d\n",
1179 pp->hour, pp->minute, pp->second,
1180 pp->day, month, pp->year, flags, status);
1185 The status value tested for is not strictly supported by the
1186 clock spec since the value of bit 2 (0x4) is claimed to be
1187 undefined for MSF, yet does seem to indicate if the last resync
1188 was successful or not.
1190 pp->leap = LEAP_NOWARNING;
1193 if(status != up->status)
1194 { msyslog(LOG_NOTICE, "ARCRON: signal acquired"); }
1196 if(status != up->status) {
1197 msyslog(LOG_NOTICE, "ARCRON: signal lost");
1198 pp->leap = LEAP_NOTINSYNC; /* MSF clock is free-running. */
1199 up->status = status;
1201 refclock_report(peer, CEVNT_FAULT);
1205 up->status = status;
1207 if (peer->MODE == 0) { /* compatiblity to original version */
1210 pp->day += moff[month - 1];
1212 if(isleap_4(pp->year) && month > 2) { pp->day++; }/* Y2KFixes */
1214 /* Convert to UTC if required */
1220 /* If we try to wrap round the year
1221 * (BST on 1st Jan), reject.*/
1224 refclock_report(peer, CEVNT_BADTIME);
1231 if(peer->MODE > 0) {
1232 if(pp->sloppyclockflag & CLK_FLAG1) {
1238 * Convert to GMT for sites that distribute localtime.
1239 * This means we have to do Y2K conversion on the
1240 * 2-digit year; otherwise, we get the time wrong.
1243 local.tm_year = pp->year-1900;
1244 local.tm_mon = month-1;
1245 local.tm_mday = pp->day;
1246 local.tm_hour = pp->hour;
1247 local.tm_min = pp->minute;
1248 local.tm_sec = pp->second;
1249 switch (peer->MODE) {
1251 local.tm_isdst = (flags & 2);
1254 local.tm_isdst = (flags & 2);
1257 switch (flags & 3) {
1258 case 0: /* It is unclear exactly when the
1259 Arcron changes from DST->ST and
1260 ST->DST. Testing has shown this
1261 to be irregular. For the time
1262 being, let the OS decide. */
1266 printf ("arc: DST = 00 (0)\n");
1269 case 1: /* dst->st time */
1270 local.tm_isdst = -1;
1273 printf ("arc: DST = 01 (1)\n");
1276 case 2: /* st->dst time */
1277 local.tm_isdst = -1;
1280 printf ("arc: DST = 10 (2)\n");
1283 case 3: /* dst time */
1287 printf ("arc: DST = 11 (3)\n");
1293 msyslog(LOG_NOTICE, "ARCRON: Invalid mode %d",
1298 unixtime = mktime (&local);
1299 if ((gmtp = gmtime (&unixtime)) == NULL)
1302 refclock_report (peer, CEVNT_FAULT);
1305 pp->year = gmtp->tm_year+1900;
1306 month = gmtp->tm_mon+1;
1307 pp->day = ymd2yd(pp->year,month,gmtp->tm_mday);
1308 /* pp->day = gmtp->tm_yday; */
1309 pp->hour = gmtp->tm_hour;
1310 pp->minute = gmtp->tm_min;
1311 pp->second = gmtp->tm_sec;
1315 printf ("arc: time is %04d/%02d/%02d %02d:%02d:%02d UTC\n",
1316 pp->year,month,gmtp->tm_mday,pp->hour,pp->minute,
1323 * For more rational sites distributing UTC
1325 pp->day = ymd2yd(pp->year,month,pp->day);
1329 if (peer->MODE == 0) { /* compatiblity to original version */
1330 /* If clock signal quality is
1331 * unknown, revert to default PRECISION...*/
1332 if(up->quality == QUALITY_UNKNOWN) {
1333 peer->precision = PRECISION;
1334 } else { /* ...else improve precision if flag3 is set... */
1335 peer->precision = ((pp->sloppyclockflag & CLK_FLAG3) ?
1336 HIGHPRECISION : PRECISION);
1339 if ((status == 0x3) && (pp->sloppyclockflag & CLK_FLAG2)) {
1340 peer->precision = ((pp->sloppyclockflag & CLK_FLAG3) ?
1341 HIGHPRECISION : PRECISION);
1342 } else if (up->quality == QUALITY_UNKNOWN) {
1343 peer->precision = PRECISION;
1345 peer->precision = ((pp->sloppyclockflag & CLK_FLAG3) ?
1346 HIGHPRECISION : PRECISION);
1350 /* Notice and log any change (eg from initial defaults) for flags. */
1351 if(up->saved_flags != pp->sloppyclockflag) {
1353 msyslog(LOG_NOTICE, "ARCRON: flags enabled: %s%s%s%s",
1354 ((pp->sloppyclockflag & CLK_FLAG1) ? "1" : "."),
1355 ((pp->sloppyclockflag & CLK_FLAG2) ? "2" : "."),
1356 ((pp->sloppyclockflag & CLK_FLAG3) ? "3" : "."),
1357 ((pp->sloppyclockflag & CLK_FLAG4) ? "4" : "."));
1358 /* Note effects of flags changing... */
1360 printf("arc: PRECISION = %d.\n", peer->precision);
1363 up->saved_flags = pp->sloppyclockflag;
1366 /* Note time of last believable timestamp. */
1367 pp->lastrec = up->lastrec;
1369 #ifdef ARCRON_LEAPSECOND_KEEN
1370 /* Find out if a leap-second might just have happened...
1371 (ie is this the first hour of the first day of Jan or Jul?)
1373 if((pp->hour == 0) &&
1375 ((month == 1) || (month == 7))) {
1376 if(possible_leap >= 0) {
1377 /* A leap may have happened, and no resync has started yet...*/
1381 /* Definitely not leap-second territory... */
1386 if (!refclock_process(pp)) {
1388 refclock_report(peer, CEVNT_BADTIME);
1391 record_clock_stats(&peer->srcadr, pp->a_lastcode);
1392 refclock_receive(peer);
1396 /* request_time() sends a time request to the clock with given peer. */
1397 /* This automatically reports a fault if necessary. */
1398 /* No data should be sent after this until arc_poll() returns. */
1399 static void request_time P((int, struct peer *));
1406 struct refclockproc *pp = peer->procptr;
1407 register struct arcunit *up = (struct arcunit *)pp->unitptr;
1409 if(debug) { printf("arc: unit %d: requesting time.\n", unit); }
1411 if (!send_slow(up, pp->io.fd, "o\r")) {
1414 printf("arc: unit %d: problem sending", unit);
1418 refclock_report(peer, CEVNT_FAULT);
1425 * arc_poll - called by the transmit procedure
1433 register struct arcunit *up;
1434 struct refclockproc *pp;
1435 int resync_needed; /* Should we start a resync? */
1438 up = (struct arcunit *)pp->unitptr;
1441 memset(pp->a_lastcode, 0, sizeof(pp->a_lastcode));
1446 tcflush(pp->io.fd, TCIFLUSH);
1449 /* Resync if our next scheduled resync time is here or has passed. */
1450 resync_needed = ( !(pp->sloppyclockflag & CLK_FLAG2) &&
1451 (up->next_resync <= current_time) );
1453 #ifdef ARCRON_LEAPSECOND_KEEN
1455 Try to catch a potential leap-second insertion or deletion quickly.
1457 In addition to the normal NTP fun of clocks that don't report
1458 leap-seconds spooking their hosts, this clock does not even
1459 sample the radio sugnal the whole time, so may miss a
1460 leap-second insertion or deletion for up to a whole sample
1463 To try to minimise this effect, if in the first few minutes of
1464 the day immediately following a leap-second-insertion point
1465 (ie in the first hour of the first day of the first and sixth
1466 months), and if the last resync was in the previous day, and a
1467 resync is not already in progress, resync the clock
1471 if((possible_leap > 0) && /* Must be 00:XX 01/0{1,7}/XXXX. */
1472 (!up->resyncing)) { /* No resync in progress yet. */
1474 possible_leap = -1; /* Prevent multiple resyncs. */
1475 msyslog(LOG_NOTICE,"ARCRON: unit %d: checking for leap second",unit);
1479 /* Do a resync if required... */
1481 /* First, reset quality value to `unknown' so we can detect */
1482 /* when a quality message has been responded to by this */
1483 /* being set to some other value. */
1484 up->quality = QUALITY_UNKNOWN;
1486 /* Note that we are resyncing... */
1489 /* Now actually send the resync command and an immediate poll. */
1491 if(debug) { printf("arc: sending resync command (h\\r).\n"); }
1493 msyslog(LOG_NOTICE, "ARCRON: unit %d: sending resync command", unit);
1494 send_slow(up, pp->io.fd, "h\r");
1496 /* Schedule our next resync... */
1497 up->next_resync = current_time + DEFAULT_RESYNC_TIME;
1499 /* Drop through to request time if appropriate. */
1502 /* If clock quality is too poor to trust, indicate a fault. */
1503 /* If quality is QUALITY_UNKNOWN and ARCRON_KEEN is defined,*/
1504 /* we'll cross our fingers and just hope that the thing */
1505 /* synced so quickly we did not catch it---we'll */
1506 /* double-check the clock is OK elsewhere. */
1509 (up->quality != QUALITY_UNKNOWN) &&
1511 (up->quality == QUALITY_UNKNOWN) ||
1513 (up->quality < MIN_CLOCK_QUALITY_OK)) {
1516 printf("arc: clock quality %d too poor.\n", up->quality);
1520 refclock_report(peer, CEVNT_FAULT);
1523 /* This is the normal case: request a timestamp. */
1524 request_time(unit, peer);
1528 int refclock_arc_bs;