contrib/ntp/ntpd/refclock_ulink.c

   1 /*
   2  * refclock_ulink - clock driver for Ultralink  WWVB receiver
   3  *
   4  */
   5
   6 /***********************************************************************
   7  *                                                                     *
   8  * Copyright (c) David L. Mills 1992-1998                              *
   9  *                                                                     *
  10  * Permission to use, copy, modify, and distribute this software and   *
  11  * its documentation for any purpose and without fee is hereby         *
  12  * granted, provided that the above copyright notice appears in all    *
  13  * copies and that both the copyright notice and this permission       *
  14  * notice appear in supporting documentation, and that the name        *
  15  * University of Delaware not be used in advertising or publicity      *
  16  * pertaining to distribution of the software without specific,        *
  17  * written prior permission. The University of Delaware makes no       *
  18  * representations about the suitability this software for any         *
  19  * purpose. It is provided "as is" without express or implied          *
  20  * warranty.                                                           *
  21  **********************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #if defined(REFCLOCK) && defined(CLOCK_ULINK)
  28
  29 #include <stdio.h>
  30 #include <ctype.h>
  31
  32 #include "ntpd.h"
  33 #include "ntp_io.h"
  34 #include "ntp_refclock.h"
  35 #include "ntp_calendar.h"
  36 #include "ntp_stdlib.h"
  37
  38 /*
  39  * This driver supports ultralink Model 320,330,331,332 WWVB radios
  40  *
  41  * this driver was based on the refclock_wwvb.c driver
  42  * in the ntp distribution.
  43  *
  44  * Fudge Factors
  45  *
  46  * fudge flag1 0 don't poll clock
  47  *             1 send poll character
  48  *
  49  * revision history:
  50  *              99/9/09 j.c.lang        original edit's
  51  *              99/9/11 j.c.lang        changed timecode parse to
  52  *                                      match what the radio actually
  53  *                                      sends.
  54  *              99/10/11 j.c.lang       added support for continous
  55  *                                      time code mode (dipsw2)
  56  *              99/11/26 j.c.lang       added support for 320 decoder
  57  *                                      (taken from Dave Strout's
  58  *                                      Model 320 driver)
  59  *              99/11/29 j.c.lang       added fudge flag 1 to control
  60  *                                      clock polling
  61  *              99/12/15 j.c.lang       fixed 320 quality flag
  62  *              01/02/21 s.l.smith      fixed 33x quality flag
  63  *                                      added more debugging stuff
  64  *                                      updated 33x time code explanation
  65  *
  66  * Questions, bugs, ideas send to:
  67  *      Joseph C. Lang
  68  *      tcnojl1@earthlink.net
  69  *
  70  *      Dave Strout
  71  *      dstrout@linuxfoundry.com
  72  *
  73  *
  74  * on the Ultralink model 33X decoder Dip switch 2 controls
  75  * polled or continous timecode
  76  * set fudge flag1 if using polled (needed for model 320)
  77  * dont set fudge flag1 if dip switch 2 is set on model 33x decoder
  78 */
  79
  80
  81 /*
  82  * Interface definitions
  83  */
  84 #define DEVICE          "/dev/wwvb%d" /* device name and unit */
  85 #define SPEED232        B9600   /* uart speed (9600 baud) */
  86 #define PRECISION       (-10)   /* precision assumed (about 10 ms) */
  87 #define REFID           "WWVB"  /* reference ID */
  88 #define DESCRIPTION     "Ultralink WWVB Receiver" /* WRU */
  89
  90 #define LEN33X          32      /* timecode length Model 325 & 33X */
  91 #define LEN320          24      /* timecode length Model 320 */
  92
  93 /*
  94  *  unit control structure
  95  */
  96 struct ulinkunit {
  97         u_char  tcswitch;       /* timecode switch */
  98         l_fp    laststamp;      /* last receive timestamp */
  99 };
 100
 101 /*
 102  * Function prototypes
 103  */
 104 static  int     ulink_start     P((int, struct peer *));
 105 static  void    ulink_shutdown  P((int, struct peer *));
 106 static  void    ulink_receive   P((struct recvbuf *));
 107 static  void    ulink_poll      P((int, struct peer *));
 108
 109 /*
 110  * Transfer vector
 111  */
 112 struct  refclock refclock_ulink = {
 113         ulink_start,            /* start up driver */
 114         ulink_shutdown,         /* shut down driver */
 115         ulink_poll,             /* transmit poll message */
 116         noentry,                /* not used  */
 117         noentry,                /* not used  */
 118         noentry,                /* not used  */
 119         NOFLAGS
 120 };
 121
 122
 123 /*
 124  * ulink_start - open the devices and initialize data for processing
 125  */
 126 static int
 127 ulink_start(
 128         int unit,
 129         struct peer *peer
 130         )
 131 {
 132         register struct ulinkunit *up;
 133         struct refclockproc *pp;
 134         int fd;
 135         char device[20];
 136
 137         /*
 138          * Open serial port. Use CLK line discipline, if available.
 139          */
 140         (void)sprintf(device, DEVICE, unit);
 141         if (!(fd = refclock_open(device, SPEED232, LDISC_CLK)))
 142                 return (0);
 143
 144         /*
 145          * Allocate and initialize unit structure
 146          */
 147         if (!(up = (struct ulinkunit *)
 148               emalloc(sizeof(struct ulinkunit)))) {
 149                 (void) close(fd);
 150                 return (0);
 151         }
 152         memset((char *)up, 0, sizeof(struct ulinkunit));
 153         pp = peer->procptr;
 154         pp->unitptr = (caddr_t)up;
 155         pp->io.clock_recv = ulink_receive;
 156         pp->io.srcclock = (caddr_t)peer;
 157         pp->io.datalen = 0;
 158         pp->io.fd = fd;
 159         if (!io_addclock(&pp->io)) {
 160                 (void) close(fd);
 161                 free(up);
 162                 return (0);
 163         }
 164
 165         /*
 166          * Initialize miscellaneous variables
 167          */
 168         peer->precision = PRECISION;
 169         peer->burst = NSTAGE;
 170         pp->clockdesc = DESCRIPTION;
 171         memcpy((char *)&pp->refid, REFID, 4);
 172         return (1);
 173 }
 174
 175
 176 /*
 177  * ulink_shutdown - shut down the clock
 178  */
 179 static void
 180 ulink_shutdown(
 181         int unit,
 182         struct peer *peer
 183         )
 184 {
 185         register struct ulinkunit *up;
 186         struct refclockproc *pp;
 187
 188         pp = peer->procptr;
 189         up = (struct ulinkunit *)pp->unitptr;
 190         io_closeclock(&pp->io);
 191         free(up);
 192 }
 193
 194
 195 /*
 196  * ulink_receive - receive data from the serial interface
 197  */
 198 static void
 199 ulink_receive(
 200         struct recvbuf *rbufp
 201         )
 202 {
 203         struct ulinkunit *up;
 204         struct refclockproc *pp;
 205         struct peer *peer;
 206
 207         l_fp    trtmp;          /* arrival timestamp */
 208         int     quality;        /* quality indicator */
 209         int     temp;           /* int temp */
 210         char    syncchar;       /* synchronization indicator */
 211         char    leapchar;       /* leap indicator */
 212         char    modechar;       /* model 320 mode flag */
 213         char    char_quality[2];        /* temp quality flag */
 214
 215         /*
 216          * Initialize pointers and read the timecode and timestamp
 217          */
 218         peer = (struct peer *)rbufp->recv_srcclock;
 219         pp = peer->procptr;
 220         up = (struct ulinkunit *)pp->unitptr;
 221         temp = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &trtmp);
 222
 223         /*
 224          * Note we get a buffer and timestamp for both a <cr> and <lf>,
 225          * but only the <cr> timestamp is retained.
 226          */
 227         if (temp == 0) {
 228                 if (up->tcswitch == 0) {
 229                         up->tcswitch = 1;
 230                         up->laststamp = trtmp;
 231                 } else
 232                     up->tcswitch = 0;
 233                 return;
 234         }
 235         pp->lencode = temp;
 236         pp->lastrec = up->laststamp;
 237         up->laststamp = trtmp;
 238         up->tcswitch = 1;
 239 #ifdef DEBUG
 240         if (debug)
 241                 printf("ulink: timecode %d %s\n", pp->lencode,
 242                     pp->a_lastcode);
 243 #endif
 244
 245         /*
 246          * We get down to business, check the timecode format and decode
 247          * its contents. If the timecode has invalid length or is not in
 248          * proper format, we declare bad format and exit.
 249          */
 250         syncchar = leapchar = modechar = ' ';
 251         pp->msec = 0;
 252
 253         switch (pp->lencode ) {
 254                 case LEN33X:
 255                 /*
 256                  * Model 33X decoder:
 257                  * Timecode format from January 29, 2001 datasheet is:
 258                  *   <CR><LF>S9+D 00 YYYY+DDDUTCS HH:MM:SSL+5
 259                  *   S      WWVB decoder sync indicator. S for in-sync(?)
 260                  *          or N for noisy signal.
 261                  *   9+     RF signal level in S-units, 0-9 followed by
 262                  *          a space (0x20). The space turns to '+' if the
 263                  *          level is over 9.
 264                  *   D      Data bit 0, 1, 2 (position mark), or
 265                  *          3 (unknown).
 266                  *   space  Space character (0x20)
 267                  *   00     Hours since last good WWVB frame sync. Will
 268                  *          be 00-23 hrs, or '1d' to '7d'. Will be 'Lk'
 269                  *          if currently in sync.
 270                  *   space  Space character (0x20)
 271                  *   YYYY   Current year, 1990-2089
 272                  *   +      Leap year indicator. '+' if a leap year,
 273                  *          a space (0x20) if not.
 274                  *   DDD    Day of year, 001 - 366.
 275                  *   UTC    Timezone (always 'UTC').
 276                  *   S      Daylight savings indicator
 277                  *             S - standard time (STD) in effect
 278                  *             O - during STD to DST day 0000-2400
 279                  *             D - daylight savings time (DST) in effect
 280                  *             I - during DST to STD day 0000-2400
 281                  *   space  Space character (0x20)
 282                  *   HH     Hours 00-23
 283                  *   :      This is the REAL in sync indicator (: = insync)
 284                  *   MM     Minutes 00-59
 285                  *   :      : = in sync ? = NOT in sync
 286                  *   SS     Seconds 00-59
 287                  *   L      Leap second flag. Changes from space (0x20)
 288                  *          to '+' or '-' during month preceding leap
 289                  *          second adjustment.
 290                  *   +5     UT1 correction (sign + digit ))
 291                  */
 292
 293                 if (sscanf(pp->a_lastcode,
 294                     "%*4c %2c %4d%*c%3d%*4c %2d%c%2d:%2d%c%*2c",
 295                     char_quality, &pp->year, &pp->day,
 296                     &pp->hour, &syncchar, &pp->minute, &pp->second,
 297                     &leapchar) == 8) {
 298
 299                         if (char_quality[0] == 'L') {
 300                                 quality = 0;
 301                         } else if (char_quality[0] == '0') {
 302                                 quality = (char_quality[1] & 0x0f);
 303                         } else  {
 304                                 quality = 99;
 305                         }
 306
 307 /*
 308 #ifdef DEBUG
 309                 if (debug) {
 310                         printf("ulink: char_quality %c %c\n",
 311                                char_quality[0], char_quality[1]);
 312                         printf("ulink: quality %d\n", quality);
 313                         printf("ulink: syncchar %x\n", syncchar);
 314                         printf("ulink: leapchar %x\n", leapchar);
 315                 }
 316 #endif
 317 */
 318
 319                         break;
 320                 }
 321
 322                 case LEN320:
 323                 /*
 324                  * Model 320 Decoder
 325                  * The timecode format is:
 326                  *
 327                  *  <cr><lf>SQRYYYYDDD+HH:MM:SS.mmLT<cr>
 328                  *
 329                  * where:
 330                  *
 331                  * S = 'S' -- sync'd in last hour,
 332                  *     '0'-'9' - hours x 10 since last update,
 333                  *     '?' -- not in sync
 334                  * Q = Number of correlating time-frames, from 0 to 5
 335                  * R = 'R' -- reception in progress,
 336                  *     'N' -- Noisy reception,
 337                  *     ' ' -- standby mode
 338                  * YYYY = year from 1990 to 2089
 339                  * DDD = current day from 1 to 366
 340                  * + = '+' if current year is a leap year, else ' '
 341                  * HH = UTC hour 0 to 23
 342                  * MM = Minutes of current hour from 0 to 59
 343                  * SS = Seconds of current minute from 0 to 59
 344                  * mm = 10's milliseconds of the current second from 00 to 99
 345                  * L  = Leap second pending at end of month
 346                  *     'I' = insert, 'D'= delete
 347                  * T  = DST <-> STD transition indicators
 348                  *
 349                  */
 350                 if (sscanf(pp->a_lastcode, "%c%1d%c%4d%3d%*c%2d:%2d:%2d.%2d%c",
 351                        &syncchar, &quality, &modechar, &pp->year, &pp->day,
 352                        &pp->hour, &pp->minute, &pp->second,
 353                         &pp->msec,&leapchar) == 10) {
 354                 pp->msec *= 10; /* M320 returns 10's of msecs */
 355                 if (leapchar == 'I' ) leapchar = '+';
 356                 if (leapchar == 'D' ) leapchar = '-';
 357                 if (syncchar != '?' ) syncchar = ':';
 358
 359                 break;
 360                 }
 361
 362                 default:
 363                 refclock_report(peer, CEVNT_BADREPLY);
 364                 return;
 365         }
 366
 367
 368         /*
 369          * Decode quality indicator
 370          * For the 325 & 33x series, the lower the number the "better"
 371          * the time is. I used the dispersion as the measure of time
 372          * quality. The quality indicator in the 320 is the number of
 373          * correlating time frames (the more the better)
 374          */
 375
 376         /*
 377          * The spec sheet for the 325 & 33x series states the clock will
 378          * maintain +/-0.002 seconds accuracy when locked to WWVB. This
 379          * is indicated by 'Lk' in the quality portion of the incoming
 380          * string. When not in lock, a drift of +/-0.015 seconds should
 381          * be allowed for.
 382          * With the quality indicator decoding scheme above, the 'Lk'
 383          * condition will produce a quality value of 0. If the quality
 384          * indicator starts with '0' then the second character is the
 385          * number of hours since we were last locked. If the first
 386          * character is anything other than 'L' or '0' then we have been
 387          * out of lock for more than 9 hours so we assume the worst and
 388          * force a quality value that selects the 'default' maximum
 389          * dispersion. The dispersion values below are what came with the
 390          * driver. They're not unreasonable so they've not been changed.
 391          */
 392
 393         if (pp->lencode == LEN33X) {
 394                 switch (quality) {
 395                         case 0 :
 396                                 pp->disp=.002;
 397                                 break;
 398                         case 1 :
 399                                 pp->disp=.02;
 400                                 break;
 401                         case 2 :
 402                                 pp->disp=.04;
 403                                 break;
 404                         case 3 :
 405                                 pp->disp=.08;
 406                                 break;
 407                         default:
 408                                 pp->disp=MAXDISPERSE;
 409                                 break;
 410                 }
 411         } else {
 412                 switch (quality) {
 413                         case 5 :
 414                                 pp->disp=.002;
 415                                 break;
 416                         case 4 :
 417                                 pp->disp=.02;
 418                                 break;
 419                         case 3 :
 420                                 pp->disp=.04;
 421                                 break;
 422                         case 2 :
 423                                 pp->disp=.08;
 424                                 break;
 425                         case 1 :
 426                                 pp->disp=.16;
 427                                 break;
 428                         default:
 429                                 pp->disp=MAXDISPERSE;
 430                                 break;
 431                 }
 432
 433         }
 434
 435         /*
 436          * Decode synchronization, and leap characters. If
 437          * unsynchronized, set the leap bits accordingly and exit.
 438          * Otherwise, set the leap bits according to the leap character.
 439          */
 440
 441         if (syncchar != ':')
 442                 pp->leap = LEAP_NOTINSYNC;
 443         else if (leapchar == '+')
 444                 pp->leap = LEAP_ADDSECOND;
 445         else if (leapchar == '-')
 446                 pp->leap = LEAP_DELSECOND;
 447         else
 448                 pp->leap = LEAP_NOWARNING;
 449
 450         /*
 451          * Process the new sample in the median filter and determine the
 452          * timecode timestamp.
 453          */
 454         if (!refclock_process(pp)) {
 455                 refclock_report(peer, CEVNT_BADTIME);
 456         }
 457
 458 }
 459
 460
 461 /*
 462  * ulink_poll - called by the transmit procedure
 463  */
 464 static void
 465 ulink_poll(
 466         int unit,
 467         struct peer *peer
 468         )
 469 {
 470         struct refclockproc *pp;
 471         char pollchar;
 472
 473         pp = peer->procptr;
 474         pollchar = 'T';
 475         if (pp->sloppyclockflag & CLK_FLAG1) {
 476                 if (write(pp->io.fd, &pollchar, 1) != 1)
 477                         refclock_report(peer, CEVNT_FAULT);
 478                 else
 479                     pp->polls++;
 480         }
 481         else
 482                     pp->polls++;
 483
 484         if (peer->burst > 0)
 485                 return;
 486         if (pp->coderecv == pp->codeproc) {
 487                 refclock_report(peer, CEVNT_TIMEOUT);
 488                 return;
 489         }
 490         record_clock_stats(&peer->srcadr, pp->a_lastcode);
 491         refclock_receive(peer);
 492         peer->burst = NSTAGE;
 493
 494 }
 495
 496 #else
 497 int refclock_ulink_bs;
 498 #endif /* REFCLOCK */