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