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
ext_bf(unsigned char * buf,int idx,const unsigned char * zero)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
pcheck(unsigned char * buf,int idx,const unsigned char * zero)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*/
zeller_expand(clocktime_t * clock_time,unsigned int wd)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
convert_rawdcf(unsigned char * buffer,int size,struct dcfparam * dcfprm,clocktime_t * clock_time)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
cvt_rawdcf(unsigned char * buffer,int size,struct format * param,clocktime_t * clock_time,void * local)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
pps_rawdcf(parse_t * parseio,int status,timestamp_t * ptime)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
calc_usecdiff(timestamp_t * ref,timestamp_t * base,long offset)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
snt_rawdcf(parse_t * parseio,timestamp_t * ptime)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
inp_rawdcf(parse_t * parseio,char ch,timestamp_t * tstamp)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 NONEMPTY_TRANSLATION_UNIT
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