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