diff options
Diffstat (limited to 'ntpd/refclock_ulink.c')
| -rw-r--r-- | ntpd/refclock_ulink.c | 568 |
1 files changed, 568 insertions, 0 deletions
diff --git a/ntpd/refclock_ulink.c b/ntpd/refclock_ulink.c new file mode 100644 index 0000000..d8f24a5 --- /dev/null +++ b/ntpd/refclock_ulink.c @@ -0,0 +1,568 @@ +/* + * refclock_ulink - clock driver for Ultralink WWVB receiver + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#if defined(REFCLOCK) && defined(CLOCK_ULINK) + +#include <stdio.h> +#include <ctype.h> + +#include "ntpd.h" +#include "ntp_io.h" +#include "ntp_refclock.h" +#include "ntp_stdlib.h" + +/* This driver supports ultralink Model 320,325,330,331,332 WWVB radios + * + * this driver was based on the refclock_wwvb.c driver + * in the ntp distribution. + * + * Fudge Factors + * + * fudge flag1 0 don't poll clock + * 1 send poll character + * + * revision history: + * 99/9/09 j.c.lang original edit's + * 99/9/11 j.c.lang changed timecode parse to + * match what the radio actually + * sends. + * 99/10/11 j.c.lang added support for continous + * time code mode (dipsw2) + * 99/11/26 j.c.lang added support for 320 decoder + * (taken from Dave Strout's + * Model 320 driver) + * 99/11/29 j.c.lang added fudge flag 1 to control + * clock polling + * 99/12/15 j.c.lang fixed 320 quality flag + * 01/02/21 s.l.smith fixed 33x quality flag + * added more debugging stuff + * updated 33x time code explanation + * 04/01/23 frank migge added support for 325 decoder + * (tested with ULM325.F) + * + * Questions, bugs, ideas send to: + * Joseph C. Lang + * tcnojl1@earthlink.net + * + * Dave Strout + * dstrout@linuxfoundry.com + * + * Frank Migge + * frank.migge@oracle.com + * + * + * on the Ultralink model 33X decoder Dip switch 2 controls + * polled or continous timecode + * set fudge flag1 if using polled (needed for model 320 and 325) + * dont set fudge flag1 if dip switch 2 is set on model 33x decoder +*/ + + +/* + * Interface definitions + */ +#define DEVICE "/dev/wwvb%d" /* device name and unit */ +#define SPEED232 B9600 /* uart speed (9600 baud) */ +#define PRECISION (-10) /* precision assumed (about 10 ms) */ +#define REFID "WWVB" /* reference ID */ +#define DESCRIPTION "Ultralink WWVB Receiver" /* WRU */ + +#define LEN33X 32 /* timecode length Model 33X and 325 */ +#define LEN320 24 /* timecode length Model 320 */ + +#define SIGLCHAR33x 'S' /* signal strength identifier char 325 */ +#define SIGLCHAR325 'R' /* signal strength identifier char 33x */ + +/* + * unit control structure + */ +struct ulinkunit { + u_char tcswitch; /* timecode switch */ + l_fp laststamp; /* last receive timestamp */ +}; + +/* + * Function prototypes + */ +static int ulink_start (int, struct peer *); +static void ulink_shutdown (int, struct peer *); +static void ulink_receive (struct recvbuf *); +static void ulink_poll (int, struct peer *); + +/* + * Transfer vector + */ +struct refclock refclock_ulink = { + ulink_start, /* start up driver */ + ulink_shutdown, /* shut down driver */ + ulink_poll, /* transmit poll message */ + noentry, /* not used */ + noentry, /* not used */ + noentry, /* not used */ + NOFLAGS +}; + + +/* + * ulink_start - open the devices and initialize data for processing + */ +static int +ulink_start( + int unit, + struct peer *peer + ) +{ + register struct ulinkunit *up; + struct refclockproc *pp; + int fd; + char device[20]; + + /* + * Open serial port. Use CLK line discipline, if available. + */ + snprintf(device, sizeof(device), DEVICE, unit); + fd = refclock_open(device, SPEED232, LDISC_CLK); + if (fd <= 0) + return (0); + + /* + * Allocate and initialize unit structure + */ + up = emalloc(sizeof(struct ulinkunit)); + memset(up, 0, sizeof(struct ulinkunit)); + pp = peer->procptr; + pp->io.clock_recv = ulink_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); + return (1); +} + + +/* + * ulink_shutdown - shut down the clock + */ +static void +ulink_shutdown( + int unit, + struct peer *peer + ) +{ + register struct ulinkunit *up; + struct refclockproc *pp; + + pp = peer->procptr; + up = pp->unitptr; + if (pp->io.fd != -1) + io_closeclock(&pp->io); + if (up != NULL) + free(up); +} + + +/* + * ulink_receive - receive data from the serial interface + */ +static void +ulink_receive( + struct recvbuf *rbufp + ) +{ + struct ulinkunit *up; + struct refclockproc *pp; + struct peer *peer; + + l_fp trtmp; /* arrival timestamp */ + int quality = INT_MAX; /* quality indicator */ + int temp; /* int temp */ + char syncchar; /* synchronization indicator */ + char leapchar; /* leap indicator */ + char modechar; /* model 320 mode flag */ + char siglchar; /* model difference between 33x/325 */ + char char_quality[2]; /* temp quality flag */ + + /* + * Initialize pointers and read the timecode and timestamp + */ + peer = rbufp->recv_peer; + pp = peer->procptr; + up = pp->unitptr; + temp = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &trtmp); + + /* + * Note we get a buffer and timestamp for both a <cr> and <lf>, + * but only the <cr> timestamp is retained. + */ + if (temp == 0) { + if (up->tcswitch == 0) { + up->tcswitch = 1; + up->laststamp = trtmp; + } else + up->tcswitch = 0; + return; + } + pp->lencode = temp; + pp->lastrec = up->laststamp; + up->laststamp = trtmp; + up->tcswitch = 1; +#ifdef DEBUG + if (debug) + printf("ulink: timecode %d %s\n", pp->lencode, + pp->a_lastcode); +#endif + + /* + * 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. + */ + syncchar = leapchar = modechar = siglchar = ' '; + switch (pp->lencode ) { + case LEN33X: + + /* + * First we check if the format is 33x or 325: + * <CR><LF>S9+D 00 YYYY+DDDUTCS HH:MM:SSL+5 (33x) + * <CR><LF>R5_1C00LYYYY+DDDUTCS HH:MM:SSL+5 (325) + * simply by comparing if the signal level is 'S' or 'R' + */ + + if (sscanf(pp->a_lastcode, "%c%*31c", + &siglchar) == 1) { + + if(siglchar == SIGLCHAR325) { + + /* + * decode for a Model 325 decoder. + * Timecode format from January 23, 2004 datasheet is: + * + * <CR><LF>R5_1C00LYYYY+DDDUTCS HH:MM:SSL+5 + * + * R WWVB decodersignal readability R1 - R5 + * 5 R1 is unreadable, R5 is best + * space a space (0x20) + * 1 Data bit 0, 1, M (pos mark), or ? (unknown). + * C Reception from either (C)olorado or (H)awaii + * 00 Hours since last good WWVB frame sync. Will + * be 00-99 + * space Space char (0x20) or (0xa5) if locked to wwvb + * YYYY Current year, 2000-2099 + * + Leap year indicator. '+' if a leap year, + * a space (0x20) if not. + * DDD Day of year, 000 - 365. + * UTC Timezone (always 'UTC'). + * S Daylight savings indicator + * S - standard time (STD) in effect + * O - during STD to DST day 0000-2400 + * D - daylight savings time (DST) in effect + * I - during DST to STD day 0000-2400 + * space Space character (0x20) + * HH Hours 00-23 + * : This is the REAL in sync indicator (: = insync) + * MM Minutes 00-59 + * : : = in sync ? = NOT in sync + * SS Seconds 00-59 + * L Leap second flag. Changes from space (0x20) + * to 'I' or 'D' during month preceding leap + * second adjustment. (I)nsert or (D)elete + * +5 UT1 correction (sign + digit )) + */ + + if (sscanf(pp->a_lastcode, + "%*2c %*2c%2c%*c%4d%*c%3d%*4c %2d%c%2d:%2d%c%*2c", + char_quality, &pp->year, &pp->day, + &pp->hour, &syncchar, &pp->minute, &pp->second, + &leapchar) == 8) { + + if (char_quality[0] == '0') { + quality = 0; + } else if (char_quality[0] == '0') { + quality = (char_quality[1] & 0x0f); + } else { + quality = 99; + } + + if (leapchar == 'I' ) leapchar = '+'; + if (leapchar == 'D' ) leapchar = '-'; + + /* + #ifdef DEBUG + if (debug) { + printf("ulink: char_quality %c %c\n", + char_quality[0], char_quality[1]); + printf("ulink: quality %d\n", quality); + printf("ulink: syncchar %x\n", syncchar); + printf("ulink: leapchar %x\n", leapchar); + } + #endif + */ + + } + + } + if(siglchar == SIGLCHAR33x) { + + /* + * We got a Model 33X decoder. + * Timecode format from January 29, 2001 datasheet is: + * <CR><LF>S9+D 00 YYYY+DDDUTCS HH:MM:SSL+5 + * S WWVB decoder sync indicator. S for in-sync(?) + * or N for noisy signal. + * 9+ RF signal level in S-units, 0-9 followed by + * a space (0x20). The space turns to '+' if the + * level is over 9. + * D Data bit 0, 1, 2 (position mark), or + * 3 (unknown). + * space Space character (0x20) + * 00 Hours since last good WWVB frame sync. Will + * be 00-23 hrs, or '1d' to '7d'. Will be 'Lk' + * if currently in sync. + * space Space character (0x20) + * YYYY Current year, 1990-2089 + * + Leap year indicator. '+' if a leap year, + * a space (0x20) if not. + * DDD Day of year, 001 - 366. + * UTC Timezone (always 'UTC'). + * S Daylight savings indicator + * S - standard time (STD) in effect + * O - during STD to DST day 0000-2400 + * D - daylight savings time (DST) in effect + * I - during DST to STD day 0000-2400 + * space Space character (0x20) + * HH Hours 00-23 + * : This is the REAL in sync indicator (: = insync) + * MM Minutes 00-59 + * : : = in sync ? = NOT in sync + * SS Seconds 00-59 + * L Leap second flag. Changes from space (0x20) + * to '+' or '-' during month preceding leap + * second adjustment. + * +5 UT1 correction (sign + digit )) + */ + + if (sscanf(pp->a_lastcode, + "%*4c %2c %4d%*c%3d%*4c %2d%c%2d:%2d%c%*2c", + char_quality, &pp->year, &pp->day, + &pp->hour, &syncchar, &pp->minute, &pp->second, + &leapchar) == 8) { + + if (char_quality[0] == 'L') { + quality = 0; + } else if (char_quality[0] == '0') { + quality = (char_quality[1] & 0x0f); + } else { + quality = 99; + } + + /* + #ifdef DEBUG + if (debug) { + printf("ulink: char_quality %c %c\n", + char_quality[0], char_quality[1]); + printf("ulink: quality %d\n", quality); + printf("ulink: syncchar %x\n", syncchar); + printf("ulink: leapchar %x\n", leapchar); + } + #endif + */ + + } + } + break; + } + + case LEN320: + + /* + * Model 320 Decoder + * The timecode format is: + * + * <cr><lf>SQRYYYYDDD+HH:MM:SS.mmLT<cr> + * + * where: + * + * S = 'S' -- sync'd in last hour, + * '0'-'9' - hours x 10 since last update, + * '?' -- not in sync + * Q = Number of correlating time-frames, from 0 to 5 + * R = 'R' -- reception in progress, + * 'N' -- Noisy reception, + * ' ' -- standby mode + * YYYY = year from 1990 to 2089 + * DDD = current day from 1 to 366 + * + = '+' if current year is a leap year, else ' ' + * HH = UTC hour 0 to 23 + * MM = Minutes of current hour from 0 to 59 + * SS = Seconds of current minute from 0 to 59 + * mm = 10's milliseconds of the current second from 00 to 99 + * L = Leap second pending at end of month + * 'I' = insert, 'D'= delete + * T = DST <-> STD transition indicators + * + */ + + if (sscanf(pp->a_lastcode, "%c%1d%c%4d%3d%*c%2d:%2d:%2d.%2ld%c", + &syncchar, &quality, &modechar, &pp->year, &pp->day, + &pp->hour, &pp->minute, &pp->second, + &pp->nsec, &leapchar) == 10) { + pp->nsec *= 10000000; /* M320 returns 10's of msecs */ + if (leapchar == 'I' ) leapchar = '+'; + if (leapchar == 'D' ) leapchar = '-'; + if (syncchar != '?' ) syncchar = ':'; + + break; + } + + default: + refclock_report(peer, CEVNT_BADREPLY); + return; + } + + /* + * Decode quality indicator + * For the 325 & 33x series, the lower the number the "better" + * the time is. I used the dispersion as the measure of time + * quality. The quality indicator in the 320 is the number of + * correlating time frames (the more the better) + */ + + /* + * The spec sheet for the 325 & 33x series states the clock will + * maintain +/-0.002 seconds accuracy when locked to WWVB. This + * is indicated by 'Lk' in the quality portion of the incoming + * string. When not in lock, a drift of +/-0.015 seconds should + * be allowed for. + * With the quality indicator decoding scheme above, the 'Lk' + * condition will produce a quality value of 0. If the quality + * indicator starts with '0' then the second character is the + * number of hours since we were last locked. If the first + * character is anything other than 'L' or '0' then we have been + * out of lock for more than 9 hours so we assume the worst and + * force a quality value that selects the 'default' maximum + * dispersion. The dispersion values below are what came with the + * driver. They're not unreasonable so they've not been changed. + */ + + if (pp->lencode == LEN33X) { + switch (quality) { + case 0 : + pp->disp=.002; + break; + case 1 : + pp->disp=.02; + break; + case 2 : + pp->disp=.04; + break; + case 3 : + pp->disp=.08; + break; + default: + pp->disp=MAXDISPERSE; + break; + } + } else { + switch (quality) { + case 5 : + pp->disp=.002; + break; + case 4 : + pp->disp=.02; + break; + case 3 : + pp->disp=.04; + break; + case 2 : + pp->disp=.08; + break; + case 1 : + pp->disp=.16; + break; + default: + pp->disp=MAXDISPERSE; + break; + } + + } + + /* + * Decode synchronization, and leap characters. If + * unsynchronized, set the leap bits accordingly and exit. + * Otherwise, set the leap bits according to the leap character. + */ + + if (syncchar != ':') + pp->leap = LEAP_NOTINSYNC; + else if (leapchar == '+') + pp->leap = LEAP_ADDSECOND; + else if (leapchar == '-') + pp->leap = LEAP_DELSECOND; + 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); + } + +} + +/* + * ulink_poll - called by the transmit procedure + */ + +static void +ulink_poll( + int unit, + struct peer *peer + ) +{ + struct refclockproc *pp; + char pollchar; + + pp = peer->procptr; + pollchar = 'T'; + if (pp->sloppyclockflag & CLK_FLAG1) { + if (write(pp->io.fd, &pollchar, 1) != 1) + refclock_report(peer, CEVNT_FAULT); + else + pp->polls++; + } + else + pp->polls++; + + if (pp->coderecv == pp->codeproc) { + refclock_report(peer, CEVNT_TIMEOUT); + return; + } + pp->lastref = pp->lastrec; + refclock_receive(peer); + record_clock_stats(&peer->srcadr, pp->a_lastcode); + +} + +#else +int refclock_ulink_bs; +#endif /* REFCLOCK */ |