1 /* $NetBSD: clk_rawdcf.c,v 1.2 2010/12/04 23:08:35 christos Exp $ */ 2 3 /* 4 * /src/NTP/REPOSITORY/ntp4-dev/libparse/clk_rawdcf.c,v 4.18 2006/06/22 18:40:01 kardel RELEASE_20060622_A 5 * 6 * clk_rawdcf.c,v 4.18 2006/06/22 18:40:01 kardel RELEASE_20060622_A 7 * 8 * Raw DCF77 pulse clock support 9 * 10 * Copyright (c) 1995-2006 by Frank Kardel <kardel <AT> ntp.org> 11 * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universit�t Erlangen-N�rnberg, Germany 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of the author nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 * 37 */ 38 39 #ifdef HAVE_CONFIG_H 40 # include <config.h> 41 #endif 42 43 #if defined(REFCLOCK) && defined(CLOCK_PARSE) && defined(CLOCK_RAWDCF) 44 45 #include "ntp_fp.h" 46 #include "ntp_unixtime.h" 47 #include "ntp_calendar.h" 48 49 #include "parse.h" 50 #ifdef PARSESTREAM 51 # include <sys/parsestreams.h> 52 #endif 53 54 #ifndef PARSEKERNEL 55 # include "ntp_stdlib.h" 56 #endif 57 58 /* 59 * DCF77 raw time code 60 * 61 * From "Zur Zeit", Physikalisch-Technische Bundesanstalt (PTB), Braunschweig 62 * und Berlin, Maerz 1989 63 * 64 * Timecode transmission: 65 * AM: 66 * time marks are send every second except for the second before the 67 * next minute mark 68 * time marks consist of a reduction of transmitter power to 25% 69 * of the nominal level 70 * the falling edge is the time indication (on time) 71 * time marks of a 100ms duration constitute a logical 0 72 * time marks of a 200ms duration constitute a logical 1 73 * FM: 74 * see the spec. (basically a (non-)inverted psuedo random phase shift) 75 * 76 * Encoding: 77 * Second Contents 78 * 0 - 10 AM: free, FM: 0 79 * 11 - 14 free 80 * 15 R - alternate antenna 81 * 16 A1 - expect zone change (1 hour before) 82 * 17 - 18 Z1,Z2 - time zone 83 * 0 0 illegal 84 * 0 1 MEZ (MET) 85 * 1 0 MESZ (MED, MET DST) 86 * 1 1 illegal 87 * 19 A2 - expect leap insertion/deletion (1 hour before) 88 * 20 S - start of time code (1) 89 * 21 - 24 M1 - BCD (lsb first) Minutes 90 * 25 - 27 M10 - BCD (lsb first) 10 Minutes 91 * 28 P1 - Minute Parity (even) 92 * 29 - 32 H1 - BCD (lsb first) Hours 93 * 33 - 34 H10 - BCD (lsb first) 10 Hours 94 * 35 P2 - Hour Parity (even) 95 * 36 - 39 D1 - BCD (lsb first) Days 96 * 40 - 41 D10 - BCD (lsb first) 10 Days 97 * 42 - 44 DW - BCD (lsb first) day of week (1: Monday -> 7: Sunday) 98 * 45 - 49 MO - BCD (lsb first) Month 99 * 50 MO0 - 10 Months 100 * 51 - 53 Y1 - BCD (lsb first) Years 101 * 54 - 57 Y10 - BCD (lsb first) 10 Years 102 * 58 P3 - Date Parity (even) 103 * 59 - usually missing (minute indication), except for leap insertion 104 */ 105 106 static u_long pps_rawdcf (parse_t *, int, timestamp_t *); 107 static u_long cvt_rawdcf (unsigned char *, int, struct format *, clocktime_t *, void *); 108 static u_long inp_rawdcf (parse_t *, unsigned int, timestamp_t *); 109 110 typedef struct last_tcode { 111 time_t tcode; /* last converted time code */ 112 } last_tcode_t; 113 114 #define BUFFER_MAX 61 115 116 clockformat_t clock_rawdcf = 117 { 118 inp_rawdcf, /* DCF77 input handling */ 119 cvt_rawdcf, /* raw dcf input conversion */ 120 pps_rawdcf, /* examining PPS information */ 121 0, /* no private configuration data */ 122 "RAW DCF77 Timecode", /* direct decoding / time synthesis */ 123 124 BUFFER_MAX, /* bit buffer */ 125 sizeof(last_tcode_t) 126 }; 127 128 static struct dcfparam 129 { 130 const unsigned char *onebits; 131 const unsigned char *zerobits; 132 } dcfparameter = 133 { 134 (const unsigned char *)"###############RADMLS1248124P124812P1248121241248112481248P??", /* 'ONE' representation */ 135 (const unsigned char *)"--------------------s-------p------p----------------------p__" /* 'ZERO' representation */ 136 }; 137 138 static struct rawdcfcode 139 { 140 char offset; /* start bit */ 141 } rawdcfcode[] = 142 { 143 { 0 }, { 15 }, { 16 }, { 17 }, { 19 }, { 20 }, { 21 }, { 25 }, { 28 }, { 29 }, 144 { 33 }, { 35 }, { 36 }, { 40 }, { 42 }, { 45 }, { 49 }, { 50 }, { 54 }, { 58 }, { 59 } 145 }; 146 147 #define DCF_M 0 148 #define DCF_R 1 149 #define DCF_A1 2 150 #define DCF_Z 3 151 #define DCF_A2 4 152 #define DCF_S 5 153 #define DCF_M1 6 154 #define DCF_M10 7 155 #define DCF_P1 8 156 #define DCF_H1 9 157 #define DCF_H10 10 158 #define DCF_P2 11 159 #define DCF_D1 12 160 #define DCF_D10 13 161 #define DCF_DW 14 162 #define DCF_MO 15 163 #define DCF_MO0 16 164 #define DCF_Y1 17 165 #define DCF_Y10 18 166 #define DCF_P3 19 167 168 static struct partab 169 { 170 char offset; /* start bit of parity field */ 171 } partab[] = 172 { 173 { 21 }, { 29 }, { 36 }, { 59 } 174 }; 175 176 #define DCF_P_P1 0 177 #define DCF_P_P2 1 178 #define DCF_P_P3 2 179 180 #define DCF_Z_MET 0x2 181 #define DCF_Z_MED 0x1 182 183 static u_long 184 ext_bf( 185 unsigned char *buf, 186 int idx, 187 const unsigned char *zero 188 ) 189 { 190 u_long sum = 0; 191 int i, first; 192 193 first = rawdcfcode[idx].offset; 194 195 for (i = rawdcfcode[idx+1].offset - 1; i >= first; i--) 196 { 197 sum <<= 1; 198 sum |= (buf[i] != zero[i]); 199 } 200 return sum; 201 } 202 203 static unsigned 204 pcheck( 205 unsigned char *buf, 206 int idx, 207 const unsigned char *zero 208 ) 209 { 210 int i,last; 211 unsigned psum = 1; 212 213 last = partab[idx+1].offset; 214 215 for (i = partab[idx].offset; i < last; i++) 216 psum ^= (buf[i] != zero[i]); 217 218 return psum; 219 } 220 221 static u_long 222 convert_rawdcf( 223 unsigned char *buffer, 224 int size, 225 struct dcfparam *dcfprm, 226 clocktime_t *clock_time 227 ) 228 { 229 unsigned char *s = buffer; 230 const unsigned char *b = dcfprm->onebits; 231 const unsigned char *c = dcfprm->zerobits; 232 int i; 233 234 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: \"%s\"\n", buffer)); 235 236 if (size < 57) 237 { 238 #ifndef PARSEKERNEL 239 msyslog(LOG_ERR, "parse: convert_rawdcf: INCOMPLETE DATA - time code only has %d bits\n", size); 240 #endif 241 return CVT_NONE; 242 } 243 244 for (i = 0; i < size; i++) 245 { 246 if ((*s != *b) && (*s != *c)) 247 { 248 /* 249 * we only have two types of bytes (ones and zeros) 250 */ 251 #ifndef PARSEKERNEL 252 msyslog(LOG_ERR, "parse: convert_rawdcf: BAD DATA - no conversion"); 253 #endif 254 return CVT_NONE; 255 } 256 if (*b) b++; 257 if (*c) c++; 258 s++; 259 } 260 261 /* 262 * check Start and Parity bits 263 */ 264 if ((ext_bf(buffer, DCF_S, dcfprm->zerobits) == 1) && 265 pcheck(buffer, DCF_P_P1, dcfprm->zerobits) && 266 pcheck(buffer, DCF_P_P2, dcfprm->zerobits) && 267 pcheck(buffer, DCF_P_P3, dcfprm->zerobits)) 268 { 269 /* 270 * buffer OK 271 */ 272 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: parity check passed\n")); 273 274 clock_time->flags = PARSEB_S_ANTENNA|PARSEB_S_LEAP; 275 clock_time->utctime= 0; 276 clock_time->usecond= 0; 277 clock_time->second = 0; 278 clock_time->minute = ext_bf(buffer, DCF_M10, dcfprm->zerobits); 279 clock_time->minute = TIMES10(clock_time->minute) + ext_bf(buffer, DCF_M1, dcfprm->zerobits); 280 clock_time->hour = ext_bf(buffer, DCF_H10, dcfprm->zerobits); 281 clock_time->hour = TIMES10(clock_time->hour) + ext_bf(buffer, DCF_H1, dcfprm->zerobits); 282 clock_time->day = ext_bf(buffer, DCF_D10, dcfprm->zerobits); 283 clock_time->day = TIMES10(clock_time->day) + ext_bf(buffer, DCF_D1, dcfprm->zerobits); 284 clock_time->month = ext_bf(buffer, DCF_MO0, dcfprm->zerobits); 285 clock_time->month = TIMES10(clock_time->month) + ext_bf(buffer, DCF_MO, dcfprm->zerobits); 286 clock_time->year = ext_bf(buffer, DCF_Y10, dcfprm->zerobits); 287 clock_time->year = TIMES10(clock_time->year) + ext_bf(buffer, DCF_Y1, dcfprm->zerobits); 288 289 switch (ext_bf(buffer, DCF_Z, dcfprm->zerobits)) 290 { 291 case DCF_Z_MET: 292 clock_time->utcoffset = -1*60*60; 293 break; 294 295 case DCF_Z_MED: 296 clock_time->flags |= PARSEB_DST; 297 clock_time->utcoffset = -2*60*60; 298 break; 299 300 default: 301 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: BAD TIME ZONE\n")); 302 return CVT_FAIL|CVT_BADFMT; 303 } 304 305 if (ext_bf(buffer, DCF_A1, dcfprm->zerobits)) 306 clock_time->flags |= PARSEB_ANNOUNCE; 307 308 if (ext_bf(buffer, DCF_A2, dcfprm->zerobits)) 309 clock_time->flags |= PARSEB_LEAPADD; /* default: DCF77 data format deficiency */ 310 311 if (ext_bf(buffer, DCF_R, dcfprm->zerobits)) 312 clock_time->flags |= PARSEB_ALTERNATE; 313 314 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: TIME CODE OK: %d:%d, %d.%d.%d, flags 0x%lx\n", 315 (int)clock_time->hour, (int)clock_time->minute, (int)clock_time->day, (int)clock_time->month,(int) clock_time->year, 316 (u_long)clock_time->flags)); 317 return CVT_OK; 318 } 319 else 320 { 321 /* 322 * bad format - not for us 323 */ 324 #ifndef PARSEKERNEL 325 msyslog(LOG_ERR, "parse: convert_rawdcf: parity check FAILED for \"%s\"\n", buffer); 326 #endif 327 return CVT_FAIL|CVT_BADFMT; 328 } 329 } 330 331 /* 332 * raw dcf input routine - needs to fix up 50 baud 333 * characters for 1/0 decision 334 */ 335 static u_long 336 cvt_rawdcf( 337 unsigned char *buffer, 338 int size, 339 struct format *param, 340 clocktime_t *clock_time, 341 void *local 342 ) 343 { 344 last_tcode_t *t = (last_tcode_t *)local; 345 unsigned char *s = (unsigned char *)buffer; 346 unsigned char *e = s + size; 347 const unsigned char *b = dcfparameter.onebits; 348 const unsigned char *c = dcfparameter.zerobits; 349 u_long rtc = CVT_NONE; 350 unsigned int i, lowmax, highmax, cutoff, span; 351 #define BITS 9 352 unsigned char histbuf[BITS]; 353 /* 354 * the input buffer contains characters with runs of consecutive 355 * bits set. These set bits are an indication of the DCF77 pulse 356 * length. We assume that we receive the pulse at 50 Baud. Thus 357 * a 100ms pulse would generate a 4 bit train (20ms per bit and 358 * start bit) 359 * a 200ms pulse would create all zeroes (and probably a frame error) 360 */ 361 362 for (i = 0; i < BITS; i++) 363 { 364 histbuf[i] = 0; 365 } 366 367 cutoff = 0; 368 lowmax = 0; 369 370 while (s < e) 371 { 372 unsigned int ch = *s ^ 0xFF; 373 /* 374 * these lines are left as an excercise to the reader 8-) 375 */ 376 if (!((ch+1) & ch) || !*s) 377 { 378 379 for (i = 0; ch; i++) 380 { 381 ch >>= 1; 382 } 383 384 *s = i; 385 histbuf[i]++; 386 cutoff += i; 387 lowmax++; 388 } 389 else 390 { 391 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: character check for 0x%x@%d FAILED\n", *s, (int)(s - (unsigned char *)buffer))); 392 *s = (unsigned char)~0; 393 rtc = CVT_FAIL|CVT_BADFMT; 394 } 395 s++; 396 } 397 398 if (lowmax) 399 { 400 cutoff /= lowmax; 401 } 402 else 403 { 404 cutoff = 4; /* doesn't really matter - it'll fail anyway, but gives error output */ 405 } 406 407 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: average bit count: %d\n", cutoff)); 408 409 lowmax = 0; 410 highmax = 0; 411 412 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: histogram:")); 413 for (i = 0; i <= cutoff; i++) 414 { 415 lowmax+=histbuf[i] * i; 416 highmax += histbuf[i]; 417 parseprintf(DD_RAWDCF,(" %d", histbuf[i])); 418 } 419 parseprintf(DD_RAWDCF, (" <M>")); 420 421 lowmax += highmax / 2; 422 423 if (highmax) 424 { 425 lowmax /= highmax; 426 } 427 else 428 { 429 lowmax = 0; 430 } 431 432 highmax = 0; 433 cutoff = 0; 434 435 for (; i < BITS; i++) 436 { 437 highmax+=histbuf[i] * i; 438 cutoff +=histbuf[i]; 439 parseprintf(DD_RAWDCF,(" %d", histbuf[i])); 440 } 441 parseprintf(DD_RAWDCF,("\n")); 442 443 if (cutoff) 444 { 445 highmax /= cutoff; 446 } 447 else 448 { 449 highmax = BITS-1; 450 } 451 452 span = cutoff = lowmax; 453 for (i = lowmax; i <= highmax; i++) 454 { 455 if (histbuf[cutoff] > histbuf[i]) 456 { 457 cutoff = i; 458 span = i; 459 } 460 else 461 if (histbuf[cutoff] == histbuf[i]) 462 { 463 span = i; 464 } 465 } 466 467 cutoff = (cutoff + span) / 2; 468 469 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: lower maximum %d, higher maximum %d, cutoff %d\n", lowmax, highmax, cutoff)); 470 471 s = (unsigned char *)buffer; 472 while (s < e) 473 { 474 if (*s == (unsigned char)~0) 475 { 476 *s = '?'; 477 } 478 else 479 { 480 *s = (*s >= cutoff) ? *b : *c; 481 } 482 s++; 483 if (*b) b++; 484 if (*c) c++; 485 } 486 487 if (rtc == CVT_NONE) 488 { 489 rtc = convert_rawdcf(buffer, size, &dcfparameter, clock_time); 490 if (rtc == CVT_OK) 491 { 492 time_t newtime; 493 494 newtime = parse_to_unixtime(clock_time, &rtc); 495 if ((rtc == CVT_OK) && t) 496 { 497 if ((newtime - t->tcode) == 60) /* guard against multi bit errors */ 498 { 499 clock_time->utctime = newtime; 500 } 501 else 502 { 503 rtc = CVT_FAIL|CVT_BADTIME; 504 } 505 t->tcode = newtime; 506 } 507 } 508 } 509 510 return rtc; 511 } 512 513 /* 514 * pps_rawdcf 515 * 516 * currently a very stupid version - should be extended to decode 517 * also ones and zeros (which is easy) 518 */ 519 /*ARGSUSED*/ 520 static u_long 521 pps_rawdcf( 522 parse_t *parseio, 523 int status, 524 timestamp_t *ptime 525 ) 526 { 527 if (!status) /* negative edge for simpler wiring (Rx->DCD) */ 528 { 529 parseio->parse_dtime.parse_ptime = *ptime; 530 parseio->parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS; 531 } 532 533 return CVT_NONE; 534 } 535 536 static u_long 537 snt_rawdcf( 538 parse_t *parseio, 539 timestamp_t *ptime 540 ) 541 { 542 if ((parseio->parse_dtime.parse_status & CVT_MASK) == CVT_OK) 543 { 544 parseio->parse_dtime.parse_stime = *ptime; 545 546 #ifdef PARSEKERNEL 547 parseio->parse_dtime.parse_time.tv.tv_sec++; 548 #else 549 parseio->parse_dtime.parse_time.fp.l_ui++; 550 #endif 551 552 parseprintf(DD_RAWDCF,("parse: snt_rawdcf: time stamp synthesized offset %d seconds\n", parseio->parse_index - 1)); 553 554 return updatetimeinfo(parseio, parseio->parse_lstate); 555 } 556 return CVT_NONE; 557 } 558 559 /* 560 * inp_rawdcf 561 * 562 * grab DCF77 data from input stream 563 */ 564 static u_long 565 inp_rawdcf( 566 parse_t *parseio, 567 unsigned int ch, 568 timestamp_t *tstamp 569 ) 570 { 571 static struct timeval timeout = { 1, 500000 }; /* 1.5 secongs denote second #60 */ 572 573 parseprintf(DD_PARSE, ("inp_rawdcf(0x%lx, 0x%x, ...)\n", (long)parseio, ch)); 574 575 parseio->parse_dtime.parse_stime = *tstamp; /* collect timestamp */ 576 577 if (parse_timedout(parseio, tstamp, &timeout)) 578 { 579 parseprintf(DD_PARSE, ("inp_rawdcf: time out seen\n")); 580 581 (void) parse_end(parseio); 582 (void) parse_addchar(parseio, ch); 583 return PARSE_INP_TIME; 584 } 585 else 586 { 587 unsigned int rtc; 588 589 rtc = parse_addchar(parseio, ch); 590 if (rtc == PARSE_INP_SKIP) 591 { 592 if (snt_rawdcf(parseio, tstamp) == CVT_OK) 593 return PARSE_INP_SYNTH; 594 } 595 return rtc; 596 } 597 } 598 599 #else /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */ 600 int clk_rawdcf_bs; 601 #endif /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */ 602 603 /* 604 * History: 605 * 606 * clk_rawdcf.c,v 607 * Revision 4.18 2006/06/22 18:40:01 kardel 608 * clean up signedness (gcc 4) 609 * 610 * Revision 4.17 2006/01/22 16:01:55 kardel 611 * update version information 612 * 613 * Revision 4.16 2006/01/22 15:51:22 kardel 614 * generate reasonable timecode output on invalid input 615 * 616 * Revision 4.15 2005/08/06 19:17:06 kardel 617 * clean log output 618 * 619 * Revision 4.14 2005/08/06 17:39:40 kardel 620 * cleanup size handling wrt/ to buffer boundaries 621 * 622 * Revision 4.13 2005/04/16 17:32:10 kardel 623 * update copyright 624 * 625 * Revision 4.12 2004/11/14 15:29:41 kardel 626 * support PPSAPI, upgrade Copyright to Berkeley style 627 * 628 * Revision 4.9 1999/12/06 13:42:23 kardel 629 * transfer correctly converted time codes always into tcode 630 * 631 * Revision 4.8 1999/11/28 09:13:50 kardel 632 * RECON_4_0_98F 633 * 634 * Revision 4.7 1999/04/01 20:07:20 kardel 635 * added checking for minutie increment of timestamps in clk_rawdcf.c 636 * 637 * Revision 4.6 1998/06/14 21:09:37 kardel 638 * Sun acc cleanup 639 * 640 * Revision 4.5 1998/06/13 12:04:16 kardel 641 * fix SYSV clock name clash 642 * 643 * Revision 4.4 1998/06/12 15:22:28 kardel 644 * fix prototypes 645 * 646 * Revision 4.3 1998/06/06 18:33:36 kardel 647 * simplified condidional compile expression 648 * 649 * Revision 4.2 1998/05/24 11:04:18 kardel 650 * triggering PPS on negative edge for simpler wiring (Rx->DCD) 651 * 652 * Revision 4.1 1998/05/24 09:39:53 kardel 653 * implementation of the new IO handling model 654 * 655 * Revision 4.0 1998/04/10 19:45:30 kardel 656 * Start 4.0 release version numbering 657 * 658 * from V3 3.24 log info deleted 1998/04/11 kardel 659 * 660 */ 661