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