contrib/ntp/ntpd/refclock_ulink.c

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