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-2015 by Frank Kardel <kardel <AT> ntp.org> 9 * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universitaet Erlangen-Nuernberg, 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 "timevalops.h" 45 #include "ntp_unixtime.h" 46 #include "ntp_calendar.h" 47 48 #include "parse.h" 49 #ifdef PARSESTREAM 50 # include <sys/parsestreams.h> 51 #endif 52 53 #ifndef PARSEKERNEL 54 # include "ntp_stdlib.h" 55 #endif 56 57 /* 58 * DCF77 raw time code 59 * 60 * From "Zur Zeit", Physikalisch-Technische Bundesanstalt (PTB), Braunschweig 61 * und Berlin, Maerz 1989 62 * 63 * Timecode transmission: 64 * AM: 65 * time marks are send every second except for the second before the 66 * next minute mark 67 * time marks consist of a reduction of transmitter power to 25% 68 * of the nominal level 69 * the falling edge is the time indication (on time) 70 * time marks of a 100ms duration constitute a logical 0 71 * time marks of a 200ms duration constitute a logical 1 72 * FM: 73 * see the spec. (basically a (non-)inverted psuedo random phase shift) 74 * 75 * Encoding: 76 * Second Contents 77 * 0 - 10 AM: free, FM: 0 78 * 11 - 14 free 79 * 15 R - "call bit" used to signalize irregularities in the control facilities 80 * (until 2003 indicated transmission via 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 parse_pps_fnc_t pps_rawdcf; 107 static parse_cvt_fnc_t cvt_rawdcf; 108 static parse_inp_fnc_t inp_rawdcf; 109 110 typedef struct last_tcode { 111 time_t tcode; /* last converted time code */ 112 timestamp_t tminute; /* sample time for minute start */ 113 timestamp_t timeout; /* last timeout timestamp */ 114 } last_tcode_t; 115 116 #define BUFFER_MAX 61 117 118 clockformat_t clock_rawdcf = 119 { 120 inp_rawdcf, /* DCF77 input handling */ 121 cvt_rawdcf, /* raw dcf input conversion */ 122 pps_rawdcf, /* examining PPS information */ 123 0, /* no private configuration data */ 124 "RAW DCF77 Timecode", /* direct decoding / time synthesis */ 125 126 BUFFER_MAX, /* bit buffer */ 127 sizeof(last_tcode_t) 128 }; 129 130 static struct dcfparam 131 { 132 const unsigned char *onebits; 133 const unsigned char *zerobits; 134 } dcfparameter = 135 { 136 (const unsigned char *)"###############RADMLS1248124P124812P1248121241248112481248P??", /* 'ONE' representation */ 137 (const unsigned char *)"--------------------s-------p------p----------------------p__" /* 'ZERO' representation */ 138 }; 139 140 static struct rawdcfcode 141 { 142 char offset; /* start bit */ 143 } rawdcfcode[] = 144 { 145 { 0 }, { 15 }, { 16 }, { 17 }, { 19 }, { 20 }, { 21 }, { 25 }, { 28 }, { 29 }, 146 { 33 }, { 35 }, { 36 }, { 40 }, { 42 }, { 45 }, { 49 }, { 50 }, { 54 }, { 58 }, { 59 } 147 }; 148 149 #define DCF_M 0 150 #define DCF_R 1 151 #define DCF_A1 2 152 #define DCF_Z 3 153 #define DCF_A2 4 154 #define DCF_S 5 155 #define DCF_M1 6 156 #define DCF_M10 7 157 #define DCF_P1 8 158 #define DCF_H1 9 159 #define DCF_H10 10 160 #define DCF_P2 11 161 #define DCF_D1 12 162 #define DCF_D10 13 163 #define DCF_DW 14 164 #define DCF_MO 15 165 #define DCF_MO0 16 166 #define DCF_Y1 17 167 #define DCF_Y10 18 168 #define DCF_P3 19 169 170 static struct partab 171 { 172 char offset; /* start bit of parity field */ 173 } partab[] = 174 { 175 { 21 }, { 29 }, { 36 }, { 59 } 176 }; 177 178 #define DCF_P_P1 0 179 #define DCF_P_P2 1 180 #define DCF_P_P3 2 181 182 #define DCF_Z_MET 0x2 183 #define DCF_Z_MED 0x1 184 185 static u_long 186 ext_bf( 187 unsigned char *buf, 188 int idx, 189 const unsigned char *zero 190 ) 191 { 192 u_long sum = 0; 193 int i, first; 194 195 first = rawdcfcode[idx].offset; 196 197 for (i = rawdcfcode[idx+1].offset - 1; i >= first; i--) 198 { 199 sum <<= 1; 200 sum |= (buf[i] != zero[i]); 201 } 202 return sum; 203 } 204 205 static unsigned 206 pcheck( 207 unsigned char *buf, 208 int idx, 209 const unsigned char *zero 210 ) 211 { 212 int i,last; 213 unsigned psum = 1; 214 215 last = partab[idx+1].offset; 216 217 for (i = partab[idx].offset; i < last; i++) 218 psum ^= (buf[i] != zero[i]); 219 220 return psum; 221 } 222 223 static int/*BOOL*/ 224 zeller_expand( 225 clocktime_t *clock_time, 226 unsigned int wd 227 ) 228 { 229 unsigned int y = (unsigned int)clock_time->year; 230 unsigned int m = (unsigned int)clock_time->month - 1u; 231 unsigned int d = (unsigned int)clock_time->day - 1u; 232 unsigned int c; 233 234 /* Check basic constraints first. */ 235 if ((y >= 100u) || (m >= 12u) || (d >= 31u) || (--wd >= 7u)) 236 return FALSE; 237 238 /* Get weekday of date in 1st century by a variation on Zeller's 239 * congruence. All operands are non-negative, and the month 240 * formula is adjusted to use a divider of 32, so we can do a 241 * shift instead of a 'true' division: 242 */ 243 if ((m += 10u) >= 12u) /* shift base to 0000-03-01 */ 244 m -= 12u; 245 else if (--y >= 100u) 246 y += 100; 247 d += y + (y >> 2) + 2u; /* year-related share */ 248 d += (m * 83u + 16u) >> 5; /* month-related share */ 249 250 /* The next step combines the exact division by modular inverse 251 * with the (mod 7) step in such way that no true division and 252 * only one multiplication is needed. The multiplier is 253 * M <- ceil((3*8)/7 * 2**29) 254 * and combines multiplication by invmod(5, 7) -> 3 and modulus 255 * by 7 transformation to (mod 8) in one step. 256 * Note that 252 == 0 (mod 7) and that 'd' is less than 185, 257 * so the number to invert and reduce is strictly positive. In 258 * the end, 'c' is number of centuries since start of a great 259 * cycle and must be in [0..3] or we had bad input. 260 */ 261 c = (((252u + wd - d) * 0x6db6db6eU) >> 29) & 7u; 262 if (c >= 4) 263 return FALSE; 264 /* undo calendar base shift now */ 265 if ((m > 9u) && (++y >= 100u)) { 266 y -= 100u; 267 c = (c + 1u) & 3u; 268 } 269 /* combine year with centuries & map to [1970..2369] */ 270 y += (c * 100u); 271 clock_time->year = (int)y + ((y < 370u) ? 2000 : 1600); 272 return TRUE; 273 } 274 275 static u_long 276 convert_rawdcf( 277 unsigned char *buffer, 278 int size, 279 struct dcfparam *dcfprm, 280 clocktime_t *clock_time 281 ) 282 { 283 unsigned char *s = buffer; 284 const unsigned char *b = dcfprm->onebits; 285 const unsigned char *c = dcfprm->zerobits; 286 int i; 287 288 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: \"%.*s\"\n", size, buffer)); 289 290 if (size < 57) 291 { 292 #ifndef PARSEKERNEL 293 msyslog(LOG_ERR, "parse: convert_rawdcf: INCOMPLETE DATA - time code only has %d bits", size); 294 #endif 295 return CVT_FAIL|CVT_BADFMT; 296 } 297 298 for (i = 0; i < size; i++) 299 { 300 if ((*s != *b) && (*s != *c)) 301 { 302 /* 303 * we only have two types of bytes (ones and zeros) 304 */ 305 #ifndef PARSEKERNEL 306 msyslog(LOG_ERR, "parse: convert_rawdcf: BAD DATA - no conversion"); 307 #endif 308 return CVT_FAIL|CVT_BADFMT; 309 } 310 if (*b) b++; 311 if (*c) c++; 312 s++; 313 } 314 315 /* 316 * check Start and Parity bits 317 */ 318 if ((ext_bf(buffer, DCF_S, dcfprm->zerobits) == 1) && 319 pcheck(buffer, DCF_P_P1, dcfprm->zerobits) && 320 pcheck(buffer, DCF_P_P2, dcfprm->zerobits) && 321 pcheck(buffer, DCF_P_P3, dcfprm->zerobits)) 322 { 323 /* 324 * buffer OK 325 */ 326 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: parity check passed\n")); 327 328 clock_time->flags = PARSEB_S_CALLBIT|PARSEB_S_LEAP; 329 clock_time->utctime= 0; 330 clock_time->usecond= 0; 331 clock_time->second = 0; 332 clock_time->minute = ext_bf(buffer, DCF_M10, dcfprm->zerobits); 333 clock_time->minute = TIMES10(clock_time->minute) + ext_bf(buffer, DCF_M1, dcfprm->zerobits); 334 clock_time->hour = ext_bf(buffer, DCF_H10, dcfprm->zerobits); 335 clock_time->hour = TIMES10(clock_time->hour) + ext_bf(buffer, DCF_H1, dcfprm->zerobits); 336 clock_time->day = ext_bf(buffer, DCF_D10, dcfprm->zerobits); 337 clock_time->day = TIMES10(clock_time->day) + ext_bf(buffer, DCF_D1, dcfprm->zerobits); 338 clock_time->month = ext_bf(buffer, DCF_MO0, dcfprm->zerobits); 339 clock_time->month = TIMES10(clock_time->month) + ext_bf(buffer, DCF_MO, dcfprm->zerobits); 340 clock_time->year = ext_bf(buffer, DCF_Y10, dcfprm->zerobits); 341 clock_time->year = TIMES10(clock_time->year) + ext_bf(buffer, DCF_Y1, dcfprm->zerobits); 342 343 if (!zeller_expand(clock_time, ext_bf(buffer, DCF_DW, dcfprm->zerobits))) 344 return CVT_FAIL|CVT_BADFMT; 345 346 switch (ext_bf(buffer, DCF_Z, dcfprm->zerobits)) 347 { 348 case DCF_Z_MET: 349 clock_time->utcoffset = -1*60*60; 350 break; 351 352 case DCF_Z_MED: 353 clock_time->flags |= PARSEB_DST; 354 clock_time->utcoffset = -2*60*60; 355 break; 356 357 default: 358 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: BAD TIME ZONE\n")); 359 return CVT_FAIL|CVT_BADFMT; 360 } 361 362 if (ext_bf(buffer, DCF_A1, dcfprm->zerobits)) 363 clock_time->flags |= PARSEB_ANNOUNCE; 364 365 if (ext_bf(buffer, DCF_A2, dcfprm->zerobits)) 366 clock_time->flags |= PARSEB_LEAPADD; /* default: DCF77 data format deficiency */ 367 368 if (ext_bf(buffer, DCF_R, dcfprm->zerobits)) 369 clock_time->flags |= PARSEB_CALLBIT; 370 371 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: TIME CODE OK: %02d:%02d, %02d.%02d.%02d, flags 0x%lx\n", 372 (int)clock_time->hour, (int)clock_time->minute, (int)clock_time->day, (int)clock_time->month,(int) clock_time->year, 373 (u_long)clock_time->flags)); 374 return CVT_OK; 375 } 376 else 377 { 378 /* 379 * bad format - not for us 380 */ 381 #ifndef PARSEKERNEL 382 msyslog(LOG_ERR, "parse: convert_rawdcf: start bit / parity check FAILED for \"%.*s\"", size, buffer); 383 #endif 384 return CVT_FAIL|CVT_BADFMT; 385 } 386 } 387 388 /* 389 * parse_cvt_fnc_t cvt_rawdcf 390 * raw dcf input routine - needs to fix up 50 baud 391 * characters for 1/0 decision 392 */ 393 static u_long 394 cvt_rawdcf( 395 unsigned char *buffer, 396 int size, 397 struct format *param, 398 clocktime_t *clock_time, 399 void *local 400 ) 401 { 402 last_tcode_t *t = (last_tcode_t *)local; 403 unsigned char *s = (unsigned char *)buffer; 404 unsigned char *e = s + size; 405 const unsigned char *b = dcfparameter.onebits; 406 const unsigned char *c = dcfparameter.zerobits; 407 u_long rtc = CVT_NONE; 408 unsigned int i, lowmax, highmax, cutoff, span; 409 #define BITS 9 410 unsigned char histbuf[BITS]; 411 /* 412 * the input buffer contains characters with runs of consecutive 413 * bits set. These set bits are an indication of the DCF77 pulse 414 * length. We assume that we receive the pulse at 50 Baud. Thus 415 * a 100ms pulse would generate a 4 bit train (20ms per bit and 416 * start bit) 417 * a 200ms pulse would create all zeroes (and probably a frame error) 418 */ 419 420 for (i = 0; i < BITS; i++) 421 { 422 histbuf[i] = 0; 423 } 424 425 cutoff = 0; 426 lowmax = 0; 427 428 while (s < e) 429 { 430 unsigned int ch = *s ^ 0xFF; 431 /* 432 * these lines are left as an excercise to the reader 8-) 433 */ 434 if (!((ch+1) & ch) || !*s) 435 { 436 437 for (i = 0; ch; i++) 438 { 439 ch >>= 1; 440 } 441 442 *s = (unsigned char) i; 443 histbuf[i]++; 444 cutoff += i; 445 lowmax++; 446 } 447 else 448 { 449 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: character check for 0x%x@%d FAILED\n", *s, (int)(s - (unsigned char *)buffer))); 450 *s = (unsigned char)~0; 451 rtc = CVT_FAIL|CVT_BADFMT; 452 } 453 s++; 454 } 455 456 if (lowmax) 457 { 458 cutoff /= lowmax; 459 } 460 else 461 { 462 cutoff = 4; /* doesn't really matter - it'll fail anyway, but gives error output */ 463 } 464 465 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: average bit count: %d\n", cutoff)); 466 467 lowmax = 0; 468 highmax = 0; 469 470 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: histogram:")); 471 for (i = 0; i <= cutoff; i++) 472 { 473 lowmax+=histbuf[i] * i; 474 highmax += histbuf[i]; 475 parseprintf(DD_RAWDCF,(" %d", histbuf[i])); 476 } 477 parseprintf(DD_RAWDCF, (" <M>")); 478 479 lowmax += highmax / 2; 480 481 if (highmax) 482 { 483 lowmax /= highmax; 484 } 485 else 486 { 487 lowmax = 0; 488 } 489 490 highmax = 0; 491 cutoff = 0; 492 493 for (; i < BITS; i++) 494 { 495 highmax+=histbuf[i] * i; 496 cutoff +=histbuf[i]; 497 parseprintf(DD_RAWDCF,(" %d", histbuf[i])); 498 } 499 parseprintf(DD_RAWDCF,("\n")); 500 501 if (cutoff) 502 { 503 highmax /= cutoff; 504 } 505 else 506 { 507 highmax = BITS-1; 508 } 509 510 span = cutoff = lowmax; 511 for (i = lowmax; i <= highmax; i++) 512 { 513 if (histbuf[cutoff] > histbuf[i]) 514 { 515 cutoff = i; 516 span = i; 517 } 518 else 519 if (histbuf[cutoff] == histbuf[i]) 520 { 521 span = i; 522 } 523 } 524 525 cutoff = (cutoff + span) / 2; 526 527 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: lower maximum %d, higher maximum %d, cutoff %d\n", lowmax, highmax, cutoff)); 528 529 s = (unsigned char *)buffer; 530 while (s < e) 531 { 532 if (*s == (unsigned char)~0) 533 { 534 *s = '?'; 535 } 536 else 537 { 538 *s = (*s >= cutoff) ? *b : *c; 539 } 540 s++; 541 if (*b) b++; 542 if (*c) c++; 543 } 544 545 *s = '\0'; 546 547 if (rtc == CVT_NONE) 548 { 549 rtc = convert_rawdcf(buffer, size, &dcfparameter, clock_time); 550 if (rtc == CVT_OK) 551 { 552 time_t newtime; 553 554 newtime = parse_to_unixtime(clock_time, &rtc); 555 if ((rtc == CVT_OK) && t) 556 { 557 if ((newtime - t->tcode) <= 600) /* require a successful telegram within last 10 minutes */ 558 { 559 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: recent timestamp check OK\n")); 560 clock_time->utctime = newtime; 561 } 562 else 563 { 564 parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: recent timestamp check FAIL - ignore timestamp\n")); 565 rtc = CVT_SKIP; 566 } 567 t->tcode = newtime; 568 } 569 } 570 } 571 572 return rtc; 573 } 574 575 /* 576 * parse_pps_fnc_t pps_rawdcf 577 * 578 * currently a very stupid version - should be extended to decode 579 * also ones and zeros (which is easy) 580 */ 581 /*ARGSUSED*/ 582 static u_long 583 pps_rawdcf( 584 parse_t *parseio, 585 int status, 586 timestamp_t *ptime 587 ) 588 { 589 if (!status) /* negative edge for simpler wiring (Rx->DCD) */ 590 { 591 parseio->parse_dtime.parse_ptime = *ptime; 592 parseio->parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS; 593 } 594 595 return CVT_NONE; 596 } 597 598 static long 599 calc_usecdiff( 600 timestamp_t *ref, 601 timestamp_t *base, 602 long offset 603 ) 604 { 605 struct timeval delta; 606 long delta_usec = 0; 607 608 #ifdef PARSEKERNEL 609 delta.tv_sec = ref->tv.tv_sec - offset - base->tv.tv_sec; 610 delta.tv_usec = ref->tv.tv_usec - base->tv.tv_usec; 611 if (delta.tv_usec < 0) 612 { 613 delta.tv_sec -= 1; 614 delta.tv_usec += 1000000; 615 } 616 #else 617 l_fp delt; 618 619 delt = ref->fp; 620 delt.l_i -= offset; 621 L_SUB(&delt, &base->fp); 622 TSTOTV(&delt, &delta); 623 #endif 624 625 delta_usec = 1000000 * (int32_t)delta.tv_sec + delta.tv_usec; 626 return delta_usec; 627 } 628 629 static u_long 630 snt_rawdcf( 631 parse_t *parseio, 632 timestamp_t *ptime 633 ) 634 { 635 /* 636 * only synthesize if all of following conditions are met: 637 * - CVT_OK parse_status (we have a time stamp base) 638 * - ABS(ptime - tminute - (parse_index - 1) sec) < 500ms (spaced by 1 sec +- 500ms) 639 * - minute marker is available (confirms minute raster as base) 640 */ 641 last_tcode_t *t = (last_tcode_t *)parseio->parse_pdata; 642 long delta_usec = -1; 643 644 if (t != NULL && t->tminute.tv.tv_sec != 0) { 645 delta_usec = calc_usecdiff(ptime, &t->tminute, parseio->parse_index - 1); 646 if (delta_usec < 0) 647 delta_usec = -delta_usec; 648 } 649 650 parseprintf(DD_RAWDCF,("parse: snt_rawdcf: synth for offset %d seconds - absolute usec error %ld\n", 651 parseio->parse_index - 1, delta_usec)); 652 653 if (((parseio->parse_dtime.parse_status & CVT_MASK) == CVT_OK) && 654 (delta_usec < 500000 && delta_usec >= 0)) /* only if minute marker is available */ 655 { 656 parseio->parse_dtime.parse_stime = *ptime; 657 658 #ifdef PARSEKERNEL 659 parseio->parse_dtime.parse_time.tv.tv_sec++; 660 #else 661 parseio->parse_dtime.parse_time.fp.l_ui++; 662 #endif 663 664 parseprintf(DD_RAWDCF,("parse: snt_rawdcf: time stamp synthesized offset %d seconds\n", parseio->parse_index - 1)); 665 666 return updatetimeinfo(parseio, parseio->parse_lstate); 667 } 668 return CVT_NONE; 669 } 670 671 /* 672 * parse_inp_fnc_t inp_rawdcf 673 * 674 * grab DCF77 data from input stream 675 */ 676 static u_long 677 inp_rawdcf( 678 parse_t *parseio, 679 char ch, 680 timestamp_t *tstamp 681 ) 682 { 683 static struct timeval timeout = { 1, 500000 }; /* 1.5 secongs denote second #60 */ 684 685 parseprintf(DD_PARSE, ("inp_rawdcf(0x%p, 0x%x, ...)\n", (void*)parseio, ch)); 686 687 parseio->parse_dtime.parse_stime = *tstamp; /* collect timestamp */ 688 689 if (parse_timedout(parseio, tstamp, &timeout)) 690 { 691 last_tcode_t *t = (last_tcode_t *)parseio->parse_pdata; 692 long delta_usec; 693 694 parseprintf(DD_RAWDCF, ("inp_rawdcf: time out seen\n")); 695 /* finish collection */ 696 (void) parse_end(parseio); 697 698 if (t != NULL) 699 { 700 /* remember minute start sample time if timeouts occur in minute raster */ 701 if (t->timeout.tv.tv_sec != 0) 702 { 703 delta_usec = calc_usecdiff(tstamp, &t->timeout, 60); 704 if (delta_usec < 0) 705 delta_usec = -delta_usec; 706 } 707 else 708 { 709 delta_usec = -1; 710 } 711 712 if (delta_usec < 500000 && delta_usec >= 0) 713 { 714 parseprintf(DD_RAWDCF, ("inp_rawdcf: timeout time difference %ld usec - minute marker set\n", delta_usec)); 715 /* collect minute markers only if spaced by 60 seconds */ 716 t->tminute = *tstamp; 717 } 718 else 719 { 720 parseprintf(DD_RAWDCF, ("inp_rawdcf: timeout time difference %ld usec - minute marker cleared\n", delta_usec)); 721 memset((char *)&t->tminute, 0, sizeof(t->tminute)); 722 } 723 t->timeout = *tstamp; 724 } 725 (void) parse_addchar(parseio, ch); 726 727 /* pass up to higher layers */ 728 return PARSE_INP_TIME; 729 } 730 else 731 { 732 unsigned int rtc; 733 734 rtc = parse_addchar(parseio, ch); 735 if (rtc == PARSE_INP_SKIP) 736 { 737 if (snt_rawdcf(parseio, tstamp) == CVT_OK) 738 return PARSE_INP_SYNTH; 739 } 740 return rtc; 741 } 742 } 743 744 #else /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */ 745 int clk_rawdcf_bs; 746 #endif /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */ 747 748 /* 749 * History: 750 * 751 * clk_rawdcf.c,v 752 * Revision 4.18 2006/06/22 18:40:01 kardel 753 * clean up signedness (gcc 4) 754 * 755 * Revision 4.17 2006/01/22 16:01:55 kardel 756 * update version information 757 * 758 * Revision 4.16 2006/01/22 15:51:22 kardel 759 * generate reasonable timecode output on invalid input 760 * 761 * Revision 4.15 2005/08/06 19:17:06 kardel 762 * clean log output 763 * 764 * Revision 4.14 2005/08/06 17:39:40 kardel 765 * cleanup size handling wrt/ to buffer boundaries 766 * 767 * Revision 4.13 2005/04/16 17:32:10 kardel 768 * update copyright 769 * 770 * Revision 4.12 2004/11/14 15:29:41 kardel 771 * support PPSAPI, upgrade Copyright to Berkeley style 772 * 773 * Revision 4.9 1999/12/06 13:42:23 kardel 774 * transfer correctly converted time codes always into tcode 775 * 776 * Revision 4.8 1999/11/28 09:13:50 kardel 777 * RECON_4_0_98F 778 * 779 * Revision 4.7 1999/04/01 20:07:20 kardel 780 * added checking for minutie increment of timestamps in clk_rawdcf.c 781 * 782 * Revision 4.6 1998/06/14 21:09:37 kardel 783 * Sun acc cleanup 784 * 785 * Revision 4.5 1998/06/13 12:04:16 kardel 786 * fix SYSV clock name clash 787 * 788 * Revision 4.4 1998/06/12 15:22:28 kardel 789 * fix prototypes 790 * 791 * Revision 4.3 1998/06/06 18:33:36 kardel 792 * simplified condidional compile expression 793 * 794 * Revision 4.2 1998/05/24 11:04:18 kardel 795 * triggering PPS on negative edge for simpler wiring (Rx->DCD) 796 * 797 * Revision 4.1 1998/05/24 09:39:53 kardel 798 * implementation of the new IO handling model 799 * 800 * Revision 4.0 1998/04/10 19:45:30 kardel 801 * Start 4.0 release version numbering 802 * 803 * from V3 3.24 log info deleted 1998/04/11 kardel 804 * 805 */ 806