Annotation of embedaddon/ntp/ntpd/refclock_datum.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** refclock_datum - clock driver for the Datum Programmable Time Server
! 3: **
! 4: ** Important note: This driver assumes that you have termios. If you have
! 5: ** a system that does not have termios, you will have to modify this driver.
! 6: **
! 7: ** Sorry, I have only tested this driver on SUN and HP platforms.
! 8: */
! 9:
! 10: #ifdef HAVE_CONFIG_H
! 11: # include <config.h>
! 12: #endif
! 13:
! 14: #if defined(REFCLOCK) && defined(CLOCK_DATUM)
! 15:
! 16: /*
! 17: ** Include Files
! 18: */
! 19:
! 20: #include "ntpd.h"
! 21: #include "ntp_io.h"
! 22: #include "ntp_refclock.h"
! 23: #include "ntp_unixtime.h"
! 24: #include "ntp_stdlib.h"
! 25:
! 26: #include <stdio.h>
! 27: #include <ctype.h>
! 28:
! 29: #if defined(HAVE_BSD_TTYS)
! 30: #include <sgtty.h>
! 31: #endif /* HAVE_BSD_TTYS */
! 32:
! 33: #if defined(HAVE_SYSV_TTYS)
! 34: #include <termio.h>
! 35: #endif /* HAVE_SYSV_TTYS */
! 36:
! 37: #if defined(HAVE_TERMIOS)
! 38: #include <termios.h>
! 39: #endif
! 40: #if defined(STREAM)
! 41: #include <stropts.h>
! 42: #if defined(WWVBCLK)
! 43: #include <sys/clkdefs.h>
! 44: #endif /* WWVBCLK */
! 45: #endif /* STREAM */
! 46:
! 47: #include "ntp_stdlib.h"
! 48:
! 49: /*
! 50: ** This driver supports the Datum Programmable Time System (PTS) clock.
! 51: ** The clock works in very straight forward manner. When it receives a
! 52: ** time code request (e.g., the ascii string "//k/mn"), it responds with
! 53: ** a seven byte BCD time code. This clock only responds with a
! 54: ** time code after it first receives the "//k/mn" message. It does not
! 55: ** periodically send time codes back at some rate once it is started.
! 56: ** the returned time code can be broken down into the following fields.
! 57: **
! 58: ** _______________________________
! 59: ** Bit Index | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
! 60: ** ===============================
! 61: ** byte 0: | - - - - | H D |
! 62: ** ===============================
! 63: ** byte 1: | T D | U D |
! 64: ** ===============================
! 65: ** byte 2: | - - | T H | U H |
! 66: ** ===============================
! 67: ** byte 3: | - | T M | U M |
! 68: ** ===============================
! 69: ** byte 4: | - | T S | U S |
! 70: ** ===============================
! 71: ** byte 5: | t S | h S |
! 72: ** ===============================
! 73: ** byte 6: | m S | - - - - |
! 74: ** ===============================
! 75: **
! 76: ** In the table above:
! 77: **
! 78: ** "-" means don't care
! 79: ** "H D", "T D", and "U D" means Hundreds, Tens, and Units of Days
! 80: ** "T H", and "UH" means Tens and Units of Hours
! 81: ** "T M", and "U M" means Tens and Units of Minutes
! 82: ** "T S", and "U S" means Tens and Units of Seconds
! 83: ** "t S", "h S", and "m S" means tenths, hundredths, and thousandths
! 84: ** of seconds
! 85: **
! 86: ** The Datum PTS communicates throught the RS232 port on your machine.
! 87: ** Right now, it assumes that you have termios. This driver has been tested
! 88: ** on SUN and HP workstations. The Datum PTS supports various IRIG and
! 89: ** NASA input codes. This driver assumes that the name of the device is
! 90: ** /dev/datum. You will need to make a soft link to your RS232 device or
! 91: ** create a new driver to use this refclock.
! 92: */
! 93:
! 94: /*
! 95: ** Datum PTS defines
! 96: */
! 97:
! 98: /*
! 99: ** Note that if GMT is defined, then the Datum PTS must use Greenwich
! 100: ** time. Otherwise, this driver allows the Datum PTS to use the current
! 101: ** wall clock for its time. It determines the time zone offset by minimizing
! 102: ** the error after trying several time zone offsets. If the Datum PTS
! 103: ** time is Greenwich time and GMT is not defined, everything should still
! 104: ** work since the time zone will be found to be 0. What this really means
! 105: ** is that your system time (at least to start with) must be within the
! 106: ** correct time by less than +- 30 minutes. The default is for GMT to not
! 107: ** defined. If you really want to force GMT without the funny +- 30 minute
! 108: ** stuff then you must define (uncomment) GMT below.
! 109: */
! 110:
! 111: /*
! 112: #define GMT
! 113: #define DEBUG_DATUM_PTC
! 114: #define LOG_TIME_ERRORS
! 115: */
! 116:
! 117:
! 118: #define PRECISION (-10) /* precision assumed 1/1024 ms */
! 119: #define REFID "DATM" /* reference id */
! 120: #define DATUM_DISPERSION 0 /* fixed dispersion = 0 ms */
! 121: #define DATUM_MAX_ERROR 0.100 /* limits on sigma squared */
! 122: #define DATUM_DEV "/dev/datum" /* device name */
! 123:
! 124: #define DATUM_MAX_ERROR2 (DATUM_MAX_ERROR*DATUM_MAX_ERROR)
! 125:
! 126: /*
! 127: ** The Datum PTS structure
! 128: */
! 129:
! 130: /*
! 131: ** I don't use a fixed array of MAXUNITS like everyone else just because
! 132: ** I don't like to program that way. Sorry if this bothers anyone. I assume
! 133: ** that you can use any id for your unit and I will search for it in a
! 134: ** dynamic array of units until I find it. I was worried that users might
! 135: ** enter a bad id in their configuration file (larger than MAXUNITS) and
! 136: ** besides, it is just cleaner not to have to assume that you have a fixed
! 137: ** number of anything in a program.
! 138: */
! 139:
! 140: struct datum_pts_unit {
! 141: struct peer *peer; /* peer used by ntp */
! 142: struct refclockio io; /* io structure used by ntp */
! 143: int PTS_fd; /* file descriptor for PTS */
! 144: u_int unit; /* id for unit */
! 145: u_long timestarted; /* time started */
! 146: l_fp lastrec; /* time tag for the receive time (system) */
! 147: l_fp lastref; /* reference time (Datum time) */
! 148: u_long yearstart; /* the year that this clock started */
! 149: int coderecv; /* number of time codes received */
! 150: int day; /* day */
! 151: int hour; /* hour */
! 152: int minute; /* minutes */
! 153: int second; /* seconds */
! 154: int msec; /* miliseconds */
! 155: int usec; /* miliseconds */
! 156: u_char leap; /* funny leap character code */
! 157: char retbuf[8]; /* returned time from the datum pts */
! 158: char nbytes; /* number of bytes received from datum pts */
! 159: double sigma2; /* average squared error (roughly) */
! 160: int tzoff; /* time zone offest from GMT */
! 161: };
! 162:
! 163: /*
! 164: ** PTS static constant variables for internal use
! 165: */
! 166:
! 167: static char TIME_REQUEST[6]; /* request message sent to datum for time */
! 168: static int nunits; /* number of active units */
! 169: static struct datum_pts_unit
! 170: **datum_pts_unit; /* dynamic array of datum PTS structures */
! 171:
! 172: /*
! 173: ** Callback function prototypes that ntpd needs to know about.
! 174: */
! 175:
! 176: static int datum_pts_start (int, struct peer *);
! 177: static void datum_pts_shutdown (int, struct peer *);
! 178: static void datum_pts_poll (int, struct peer *);
! 179: static void datum_pts_control (int, struct refclockstat *,
! 180: struct refclockstat *, struct peer *);
! 181: static void datum_pts_init (void);
! 182: static void datum_pts_buginfo (int, struct refclockbug *, struct peer *);
! 183:
! 184: /*
! 185: ** This is the call back function structure that ntpd actually uses for
! 186: ** this refclock.
! 187: */
! 188:
! 189: struct refclock refclock_datum = {
! 190: datum_pts_start, /* start up a new Datum refclock */
! 191: datum_pts_shutdown, /* shutdown a Datum refclock */
! 192: datum_pts_poll, /* sends out the time request */
! 193: datum_pts_control, /* not used */
! 194: datum_pts_init, /* initialization (called first) */
! 195: datum_pts_buginfo, /* not used */
! 196: NOFLAGS /* we are not setting any special flags */
! 197: };
! 198:
! 199: /*
! 200: ** The datum_pts_receive callback function is handled differently from the
! 201: ** rest. It is passed to the ntpd io data structure. Basically, every
! 202: ** 64 seconds, the datum_pts_poll() routine is called. It sends out the time
! 203: ** request message to the Datum Programmable Time System. Then, ntpd
! 204: ** waits on a select() call to receive data back. The datum_pts_receive()
! 205: ** function is called as data comes back. We expect a seven byte time
! 206: ** code to be returned but the datum_pts_receive() function may only get
! 207: ** a few bytes passed to it at a time. In other words, this routine may
! 208: ** get called by the io stuff in ntpd a few times before we get all seven
! 209: ** bytes. Once the last byte is received, we process it and then pass the
! 210: ** new time measurement to ntpd for updating the system time. For now,
! 211: ** there is no 3 state filtering done on the time measurements. The
! 212: ** jitter may be a little high but at least for its current use, it is not
! 213: ** a problem. We have tried to keep things as simple as possible. This
! 214: ** clock should not jitter more than 1 or 2 mseconds at the most once
! 215: ** things settle down. It is important to get the right drift calibrated
! 216: ** in the ntpd.drift file as well as getting the right tick set up right
! 217: ** using tickadj for SUNs. Tickadj is not used for the HP but you need to
! 218: ** remember to bring up the adjtime daemon because HP does not support
! 219: ** the adjtime() call.
! 220: */
! 221:
! 222: static void datum_pts_receive (struct recvbuf *);
! 223:
! 224: /*......................................................................*/
! 225: /* datum_pts_start - start up the datum PTS. This means open the */
! 226: /* RS232 device and set up the data structure for my unit. */
! 227: /*......................................................................*/
! 228:
! 229: static int
! 230: datum_pts_start(
! 231: int unit,
! 232: struct peer *peer
! 233: )
! 234: {
! 235: struct datum_pts_unit **temp_datum_pts_unit;
! 236: struct datum_pts_unit *datum_pts;
! 237: int fd;
! 238: #ifdef HAVE_TERMIOS
! 239: struct termios arg;
! 240: #endif
! 241:
! 242: #ifdef DEBUG_DATUM_PTC
! 243: if (debug)
! 244: printf("Starting Datum PTS unit %d\n", unit);
! 245: #endif
! 246:
! 247: /*
! 248: ** Open the Datum PTS device
! 249: */
! 250: fd = open(DATUM_DEV, O_RDWR);
! 251:
! 252: if (fd < 0) {
! 253: msyslog(LOG_ERR, "Datum_PTS: open(\"%s\", O_RDWR) failed: %m", DATUM_DEV);
! 254: return 0;
! 255: }
! 256:
! 257: /*
! 258: ** Create the memory for the new unit
! 259: */
! 260:
! 261: temp_datum_pts_unit = (struct datum_pts_unit **)
! 262: emalloc((nunits+1)*sizeof(struct datum_pts_unit *));
! 263: if (nunits > 0) memcpy(temp_datum_pts_unit, datum_pts_unit,
! 264: nunits*sizeof(struct datum_pts_unit *));
! 265: free(datum_pts_unit);
! 266: datum_pts_unit = temp_datum_pts_unit;
! 267: datum_pts_unit[nunits] = (struct datum_pts_unit *)
! 268: emalloc(sizeof(struct datum_pts_unit));
! 269: datum_pts = datum_pts_unit[nunits];
! 270:
! 271: datum_pts->unit = unit; /* set my unit id */
! 272: datum_pts->yearstart = 0; /* initialize the yearstart to 0 */
! 273: datum_pts->sigma2 = 0.0; /* initialize the sigma2 to 0 */
! 274:
! 275: datum_pts->PTS_fd = fd;
! 276:
! 277: fcntl(datum_pts->PTS_fd, F_SETFL, 0); /* clear the descriptor flags */
! 278:
! 279: #ifdef DEBUG_DATUM_PTC
! 280: if (debug)
! 281: printf("Opening RS232 port with file descriptor %d\n",
! 282: datum_pts->PTS_fd);
! 283: #endif
! 284:
! 285: /*
! 286: ** Set up the RS232 terminal device information. Note that we assume that
! 287: ** we have termios. This code has only been tested on SUNs and HPs. If your
! 288: ** machine does not have termios this driver cannot be initialized. You can change this
! 289: ** if you want by editing this source. Please give the changes back to the
! 290: ** ntp folks so that it can become part of their regular distribution.
! 291: */
! 292:
! 293: #ifdef HAVE_TERMIOS
! 294:
! 295: memset(&arg, 0, sizeof(arg));
! 296:
! 297: arg.c_iflag = IGNBRK;
! 298: arg.c_oflag = 0;
! 299: arg.c_cflag = B9600 | CS8 | CREAD | PARENB | CLOCAL;
! 300: arg.c_lflag = 0;
! 301: arg.c_cc[VMIN] = 0; /* start timeout timer right away (not used) */
! 302: arg.c_cc[VTIME] = 30; /* 3 second timout on reads (not used) */
! 303:
! 304: tcsetattr(datum_pts->PTS_fd, TCSANOW, &arg);
! 305:
! 306: #else
! 307:
! 308: msyslog(LOG_ERR, "Datum_PTS: Termios not supported in this driver");
! 309: (void)close(datum_pts->PTS_fd);
! 310:
! 311: peer->precision = PRECISION;
! 312: pp->clockdesc = DESCRIPTION;
! 313: memcpy((char *)&pp->refid, REFID, 4);
! 314:
! 315: return 0;
! 316:
! 317: #endif
! 318:
! 319: /*
! 320: ** Initialize the ntpd IO structure
! 321: */
! 322:
! 323: datum_pts->peer = peer;
! 324: datum_pts->io.clock_recv = datum_pts_receive;
! 325: datum_pts->io.srcclock = (caddr_t)datum_pts;
! 326: datum_pts->io.datalen = 0;
! 327: datum_pts->io.fd = datum_pts->PTS_fd;
! 328:
! 329: if (!io_addclock(&(datum_pts->io))) {
! 330:
! 331: #ifdef DEBUG_DATUM_PTC
! 332: if (debug)
! 333: printf("Problem adding clock\n");
! 334: #endif
! 335:
! 336: msyslog(LOG_ERR, "Datum_PTS: Problem adding clock");
! 337: (void)close(datum_pts->PTS_fd);
! 338:
! 339: return 0;
! 340: }
! 341:
! 342: /*
! 343: ** Now add one to the number of units and return a successful code
! 344: */
! 345:
! 346: nunits++;
! 347: return 1;
! 348:
! 349: }
! 350:
! 351:
! 352: /*......................................................................*/
! 353: /* datum_pts_shutdown - this routine shuts doen the device and */
! 354: /* removes the memory for the unit. */
! 355: /*......................................................................*/
! 356:
! 357: static void
! 358: datum_pts_shutdown(
! 359: int unit,
! 360: struct peer *peer
! 361: )
! 362: {
! 363: int i,j;
! 364: struct datum_pts_unit **temp_datum_pts_unit;
! 365:
! 366: #ifdef DEBUG_DATUM_PTC
! 367: if (debug)
! 368: printf("Shutdown Datum PTS\n");
! 369: #endif
! 370:
! 371: msyslog(LOG_ERR, "Datum_PTS: Shutdown Datum PTS");
! 372:
! 373: /*
! 374: ** First we have to find the right unit (i.e., the one with the same id).
! 375: ** We do this by looping through the dynamic array of units intil we find
! 376: ** it. Note, that I don't simply use an array with a maximimum number of
! 377: ** Datum PTS units. Everything is completely dynamic.
! 378: */
! 379:
! 380: for (i=0; i<nunits; i++) {
! 381: if (datum_pts_unit[i]->unit == unit) {
! 382:
! 383: /*
! 384: ** We found the unit so close the file descriptor and free up the memory used
! 385: ** by the structure.
! 386: */
! 387:
! 388: io_closeclock(&datum_pts_unit[i]->io);
! 389: close(datum_pts_unit[i]->PTS_fd);
! 390: free(datum_pts_unit[i]);
! 391:
! 392: /*
! 393: ** Now clean up the datum_pts_unit dynamic array so that there are no holes.
! 394: ** This may mean moving pointers around, etc., to keep things compact.
! 395: */
! 396:
! 397: if (nunits > 1) {
! 398:
! 399: temp_datum_pts_unit = (struct datum_pts_unit **)
! 400: emalloc((nunits-1)*sizeof(struct datum_pts_unit *));
! 401: if (i!= 0) memcpy(temp_datum_pts_unit, datum_pts_unit,
! 402: i*sizeof(struct datum_pts_unit *));
! 403:
! 404: for (j=i+1; j<nunits; j++) {
! 405: temp_datum_pts_unit[j-1] = datum_pts_unit[j];
! 406: }
! 407:
! 408: free(datum_pts_unit);
! 409: datum_pts_unit = temp_datum_pts_unit;
! 410:
! 411: }else{
! 412:
! 413: free(datum_pts_unit);
! 414: datum_pts_unit = NULL;
! 415:
! 416: }
! 417:
! 418: return;
! 419:
! 420: }
! 421: }
! 422:
! 423: #ifdef DEBUG_DATUM_PTC
! 424: if (debug)
! 425: printf("Error, could not shut down unit %d\n",unit);
! 426: #endif
! 427:
! 428: msyslog(LOG_ERR, "Datum_PTS: Could not shut down Datum PTS unit %d",unit);
! 429:
! 430: }
! 431:
! 432: /*......................................................................*/
! 433: /* datum_pts_poll - this routine sends out the time request to the */
! 434: /* Datum PTS device. The time will be passed back in the */
! 435: /* datum_pts_receive() routine. */
! 436: /*......................................................................*/
! 437:
! 438: static void
! 439: datum_pts_poll(
! 440: int unit,
! 441: struct peer *peer
! 442: )
! 443: {
! 444: int i;
! 445: int unit_index;
! 446: int error_code;
! 447: struct datum_pts_unit *datum_pts;
! 448:
! 449: #ifdef DEBUG_DATUM_PTC
! 450: if (debug)
! 451: printf("Poll Datum PTS\n");
! 452: #endif
! 453:
! 454: /*
! 455: ** Find the right unit and send out a time request once it is found.
! 456: */
! 457:
! 458: unit_index = -1;
! 459: for (i=0; i<nunits; i++) {
! 460: if (datum_pts_unit[i]->unit == unit) {
! 461: unit_index = i;
! 462: datum_pts = datum_pts_unit[i];
! 463: error_code = write(datum_pts->PTS_fd, TIME_REQUEST, 6);
! 464: if (error_code != 6) perror("TIME_REQUEST");
! 465: datum_pts->nbytes = 0;
! 466: break;
! 467: }
! 468: }
! 469:
! 470: /*
! 471: ** Print out an error message if we could not find the right unit.
! 472: */
! 473:
! 474: if (unit_index == -1) {
! 475:
! 476: #ifdef DEBUG_DATUM_PTC
! 477: if (debug)
! 478: printf("Error, could not poll unit %d\n",unit);
! 479: #endif
! 480:
! 481: msyslog(LOG_ERR, "Datum_PTS: Could not poll unit %d",unit);
! 482: return;
! 483:
! 484: }
! 485:
! 486: }
! 487:
! 488:
! 489: /*......................................................................*/
! 490: /* datum_pts_control - not used */
! 491: /*......................................................................*/
! 492:
! 493: static void
! 494: datum_pts_control(
! 495: int unit,
! 496: struct refclockstat *in,
! 497: struct refclockstat *out,
! 498: struct peer *peer
! 499: )
! 500: {
! 501:
! 502: #ifdef DEBUG_DATUM_PTC
! 503: if (debug)
! 504: printf("Control Datum PTS\n");
! 505: #endif
! 506:
! 507: }
! 508:
! 509:
! 510: /*......................................................................*/
! 511: /* datum_pts_init - initializes things for all possible Datum */
! 512: /* time code generators that might be used. In practice, this is */
! 513: /* only called once at the beginning before anything else is */
! 514: /* called. */
! 515: /*......................................................................*/
! 516:
! 517: static void
! 518: datum_pts_init(void)
! 519: {
! 520:
! 521: /* */
! 522: /*...... open up the log file if we are debugging ......................*/
! 523: /* */
! 524:
! 525: /*
! 526: ** Open up the log file if we are debugging. For now, send data out to the
! 527: ** screen (stdout).
! 528: */
! 529:
! 530: #ifdef DEBUG_DATUM_PTC
! 531: if (debug)
! 532: printf("Init Datum PTS\n");
! 533: #endif
! 534:
! 535: /*
! 536: ** Initialize the time request command string. This is the only message
! 537: ** that we ever have to send to the Datum PTS (although others are defined).
! 538: */
! 539:
! 540: memcpy(TIME_REQUEST, "//k/mn",6);
! 541:
! 542: /*
! 543: ** Initialize the number of units to 0 and set the dynamic array of units to
! 544: ** NULL since there are no units defined yet.
! 545: */
! 546:
! 547: datum_pts_unit = NULL;
! 548: nunits = 0;
! 549:
! 550: }
! 551:
! 552:
! 553: /*......................................................................*/
! 554: /* datum_pts_buginfo - not used */
! 555: /*......................................................................*/
! 556:
! 557: static void
! 558: datum_pts_buginfo(
! 559: int unit,
! 560: register struct refclockbug *bug,
! 561: register struct peer *peer
! 562: )
! 563: {
! 564:
! 565: #ifdef DEBUG_DATUM_PTC
! 566: if (debug)
! 567: printf("Buginfo Datum PTS\n");
! 568: #endif
! 569:
! 570: }
! 571:
! 572:
! 573: /*......................................................................*/
! 574: /* datum_pts_receive - receive the time buffer that was read in */
! 575: /* by the ntpd io handling routines. When 7 bytes have been */
! 576: /* received (it may take several tries before all 7 bytes are */
! 577: /* received), then the time code must be unpacked and sent to */
! 578: /* the ntpd clock_receive() routine which causes the systems */
! 579: /* clock to be updated (several layers down). */
! 580: /*......................................................................*/
! 581:
! 582: static void
! 583: datum_pts_receive(
! 584: struct recvbuf *rbufp
! 585: )
! 586: {
! 587: int i;
! 588: l_fp tstmp;
! 589: struct datum_pts_unit *datum_pts;
! 590: char *dpt;
! 591: int dpend;
! 592: int tzoff;
! 593: int timerr;
! 594: double ftimerr, abserr;
! 595: #ifdef DEBUG_DATUM_PTC
! 596: double dispersion;
! 597: #endif
! 598: int goodtime;
! 599: /*double doffset;*/
! 600:
! 601: /*
! 602: ** Get the time code (maybe partial) message out of the rbufp buffer.
! 603: */
! 604:
! 605: datum_pts = (struct datum_pts_unit *)rbufp->recv_srcclock;
! 606: dpt = (char *)&rbufp->recv_space;
! 607: dpend = rbufp->recv_length;
! 608:
! 609: #ifdef DEBUG_DATUM_PTC
! 610: if (debug)
! 611: printf("Receive Datum PTS: %d bytes\n", dpend);
! 612: #endif
! 613:
! 614: /* */
! 615: /*...... save the ntp system time when the first byte is received ......*/
! 616: /* */
! 617:
! 618: /*
! 619: ** Save the ntp system time when the first byte is received. Note that
! 620: ** because it may take several calls to this routine before all seven
! 621: ** bytes of our return message are finally received by the io handlers in
! 622: ** ntpd, we really do want to use the time tag when the first byte is
! 623: ** received to reduce the jitter.
! 624: */
! 625:
! 626: if (datum_pts->nbytes == 0) {
! 627: datum_pts->lastrec = rbufp->recv_time;
! 628: }
! 629:
! 630: /*
! 631: ** Increment our count to the number of bytes received so far. Return if we
! 632: ** haven't gotten all seven bytes yet.
! 633: */
! 634:
! 635: for (i=0; i<dpend; i++) {
! 636: datum_pts->retbuf[datum_pts->nbytes+i] = dpt[i];
! 637: }
! 638:
! 639: datum_pts->nbytes += dpend;
! 640:
! 641: if (datum_pts->nbytes != 7) {
! 642: return;
! 643: }
! 644:
! 645: /*
! 646: ** Convert the seven bytes received in our time buffer to day, hour, minute,
! 647: ** second, and msecond values. The usec value is not used for anything
! 648: ** currently. It is just the fractional part of the time stored in units
! 649: ** of microseconds.
! 650: */
! 651:
! 652: datum_pts->day = 100*(datum_pts->retbuf[0] & 0x0f) +
! 653: 10*((datum_pts->retbuf[1] & 0xf0)>>4) +
! 654: (datum_pts->retbuf[1] & 0x0f);
! 655:
! 656: datum_pts->hour = 10*((datum_pts->retbuf[2] & 0x30)>>4) +
! 657: (datum_pts->retbuf[2] & 0x0f);
! 658:
! 659: datum_pts->minute = 10*((datum_pts->retbuf[3] & 0x70)>>4) +
! 660: (datum_pts->retbuf[3] & 0x0f);
! 661:
! 662: datum_pts->second = 10*((datum_pts->retbuf[4] & 0x70)>>4) +
! 663: (datum_pts->retbuf[4] & 0x0f);
! 664:
! 665: datum_pts->msec = 100*((datum_pts->retbuf[5] & 0xf0) >> 4) +
! 666: 10*(datum_pts->retbuf[5] & 0x0f) +
! 667: ((datum_pts->retbuf[6] & 0xf0)>>4);
! 668:
! 669: datum_pts->usec = 1000*datum_pts->msec;
! 670:
! 671: #ifdef DEBUG_DATUM_PTC
! 672: if (debug)
! 673: printf("day %d, hour %d, minute %d, second %d, msec %d\n",
! 674: datum_pts->day,
! 675: datum_pts->hour,
! 676: datum_pts->minute,
! 677: datum_pts->second,
! 678: datum_pts->msec);
! 679: #endif
! 680:
! 681: /*
! 682: ** Get the GMT time zone offset. Note that GMT should be zero if the Datum
! 683: ** reference time is using GMT as its time base. Otherwise we have to
! 684: ** determine the offset if the Datum PTS is using time of day as its time
! 685: ** base.
! 686: */
! 687:
! 688: goodtime = 0; /* We are not sure about the time and offset yet */
! 689:
! 690: #ifdef GMT
! 691:
! 692: /*
! 693: ** This is the case where the Datum PTS is using GMT so there is no time
! 694: ** zone offset.
! 695: */
! 696:
! 697: tzoff = 0; /* set time zone offset to 0 */
! 698:
! 699: #else
! 700:
! 701: /*
! 702: ** This is the case where the Datum PTS is using regular time of day for its
! 703: ** time so we must compute the time zone offset. The way we do it is kind of
! 704: ** funny but it works. We loop through different time zones (0 to 24) and
! 705: ** pick the one that gives the smallest error (+- one half hour). The time
! 706: ** zone offset is stored in the datum_pts structure for future use. Normally,
! 707: ** the clocktime() routine is only called once (unless the time zone offset
! 708: ** changes due to daylight savings) since the goodtime flag is set when a
! 709: ** good time is found (with a good offset). Note that even if the Datum
! 710: ** PTS is using GMT, this mechanism will still work since it should come up
! 711: ** with a value for tzoff = 0 (assuming that your system clock is within
! 712: ** a half hour of the Datum time (even with time zone differences).
! 713: */
! 714:
! 715: for (tzoff=0; tzoff<24; tzoff++) {
! 716: if (clocktime( datum_pts->day,
! 717: datum_pts->hour,
! 718: datum_pts->minute,
! 719: datum_pts->second,
! 720: (tzoff + datum_pts->tzoff) % 24,
! 721: datum_pts->lastrec.l_ui,
! 722: &datum_pts->yearstart,
! 723: &datum_pts->lastref.l_ui) ) {
! 724:
! 725: datum_pts->lastref.l_uf = 0;
! 726: error = datum_pts->lastref.l_ui - datum_pts->lastrec.l_ui;
! 727:
! 728: #ifdef DEBUG_DATUM_PTC
! 729: printf("Time Zone (clocktime method) = %d, error = %d\n", tzoff, error);
! 730: #endif
! 731:
! 732: if ((error < 1799) && (error > -1799)) {
! 733: tzoff = (tzoff + datum_pts->tzoff) % 24;
! 734: datum_pts->tzoff = tzoff;
! 735: goodtime = 1;
! 736:
! 737: #ifdef DEBUG_DATUM_PTC
! 738: printf("Time Zone found (clocktime method) = %d\n",tzoff);
! 739: #endif
! 740:
! 741: break;
! 742: }
! 743:
! 744: }
! 745: }
! 746:
! 747: #endif
! 748:
! 749: /*
! 750: ** Make sure that we have a good time from the Datum PTS. Clocktime() also
! 751: ** sets yearstart and lastref.l_ui. We will have to set astref.l_uf (i.e.,
! 752: ** the fraction of a second) stuff later.
! 753: */
! 754:
! 755: if (!goodtime) {
! 756:
! 757: if (!clocktime( datum_pts->day,
! 758: datum_pts->hour,
! 759: datum_pts->minute,
! 760: datum_pts->second,
! 761: tzoff,
! 762: datum_pts->lastrec.l_ui,
! 763: &datum_pts->yearstart,
! 764: &datum_pts->lastref.l_ui) ) {
! 765:
! 766: #ifdef DEBUG_DATUM_PTC
! 767: if (debug)
! 768: {
! 769: printf("Error: bad clocktime\n");
! 770: printf("GMT %d, lastrec %d, yearstart %d, lastref %d\n",
! 771: tzoff,
! 772: datum_pts->lastrec.l_ui,
! 773: datum_pts->yearstart,
! 774: datum_pts->lastref.l_ui);
! 775: }
! 776: #endif
! 777:
! 778: msyslog(LOG_ERR, "Datum_PTS: Bad clocktime");
! 779:
! 780: return;
! 781:
! 782: }else{
! 783:
! 784: #ifdef DEBUG_DATUM_PTC
! 785: if (debug)
! 786: printf("Good clocktime\n");
! 787: #endif
! 788:
! 789: }
! 790:
! 791: }
! 792:
! 793: /*
! 794: ** We have datum_pts->lastref.l_ui set (which is the integer part of the
! 795: ** time. Now set the microseconds field.
! 796: */
! 797:
! 798: TVUTOTSF(datum_pts->usec, datum_pts->lastref.l_uf);
! 799:
! 800: /*
! 801: ** Compute the time correction as the difference between the reference
! 802: ** time (i.e., the Datum time) minus the receive time (system time).
! 803: */
! 804:
! 805: tstmp = datum_pts->lastref; /* tstmp is the datum ntp time */
! 806: L_SUB(&tstmp, &datum_pts->lastrec); /* tstmp is now the correction */
! 807: datum_pts->coderecv++; /* increment a counter */
! 808:
! 809: #ifdef DEBUG_DATUM_PTC
! 810: dispersion = DATUM_DISPERSION; /* set the dispersion to 0 */
! 811: ftimerr = dispersion;
! 812: ftimerr /= (1024.0 * 64.0);
! 813: if (debug)
! 814: printf("dispersion = %d, %f\n", dispersion, ftimerr);
! 815: #endif
! 816:
! 817: /*
! 818: ** Pass the new time to ntpd through the refclock_receive function. Note
! 819: ** that we are not trying to make any corrections due to the time it takes
! 820: ** for the Datum PTS to send the message back. I am (erroneously) assuming
! 821: ** that the time for the Datum PTS to send the time back to us is negligable.
! 822: ** I suspect that this time delay may be as much as 15 ms or so (but probably
! 823: ** less). For our needs at JPL, this kind of error is ok so it is not
! 824: ** necessary to use fudge factors in the ntp.conf file. Maybe later we will.
! 825: */
! 826: /*LFPTOD(&tstmp, doffset);*/
! 827: datum_pts->lastref = datum_pts->lastrec;
! 828: refclock_receive(datum_pts->peer);
! 829:
! 830: /*
! 831: ** Compute sigma squared (not used currently). Maybe later, this could be
! 832: ** used for the dispersion estimate. The problem is that ntpd does not link
! 833: ** in the math library so sqrt() is not available. Anyway, this is useful
! 834: ** for debugging. Maybe later I will just use absolute values for the time
! 835: ** error to come up with my dispersion estimate. Anyway, for now my dispersion
! 836: ** is set to 0.
! 837: */
! 838:
! 839: timerr = tstmp.l_ui<<20;
! 840: timerr |= (tstmp.l_uf>>12) & 0x000fffff;
! 841: ftimerr = timerr;
! 842: ftimerr /= 1024*1024;
! 843: abserr = ftimerr;
! 844: if (ftimerr < 0.0) abserr = -ftimerr;
! 845:
! 846: if (datum_pts->sigma2 == 0.0) {
! 847: if (abserr < DATUM_MAX_ERROR) {
! 848: datum_pts->sigma2 = abserr*abserr;
! 849: }else{
! 850: datum_pts->sigma2 = DATUM_MAX_ERROR2;
! 851: }
! 852: }else{
! 853: if (abserr < DATUM_MAX_ERROR) {
! 854: datum_pts->sigma2 = 0.95*datum_pts->sigma2 + 0.05*abserr*abserr;
! 855: }else{
! 856: datum_pts->sigma2 = 0.95*datum_pts->sigma2 + 0.05*DATUM_MAX_ERROR2;
! 857: }
! 858: }
! 859:
! 860: #ifdef DEBUG_DATUM_PTC
! 861: if (debug)
! 862: printf("Time error = %f seconds\n", ftimerr);
! 863: #endif
! 864:
! 865: #if defined(DEBUG_DATUM_PTC) || defined(LOG_TIME_ERRORS)
! 866: if (debug)
! 867: printf("PTS: day %d, hour %d, minute %d, second %d, msec %d, Time Error %f\n",
! 868: datum_pts->day,
! 869: datum_pts->hour,
! 870: datum_pts->minute,
! 871: datum_pts->second,
! 872: datum_pts->msec,
! 873: ftimerr);
! 874: #endif
! 875:
! 876: }
! 877: #else
! 878: int refclock_datum_bs;
! 879: #endif /* REFCLOCK */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_datum.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd