PageRenderTime 36ms CodeModel.GetById 11ms app.highlight 20ms RepoModel.GetById 1ms app.codeStats 0ms

/contrib/ntp/libparse/clk_rawdcf.c

https://bitbucket.org/freebsd/freebsd-head/
C | 658 lines | 406 code | 73 blank | 179 comment | 56 complexity | 202554d133a1a281aadeec284a471b69 MD5 | raw file
  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
104static u_long pps_rawdcf P((parse_t *, int, timestamp_t *));
105static u_long cvt_rawdcf P((unsigned char *, int, struct format *, clocktime_t *, void *));
106static u_long inp_rawdcf P((parse_t *, unsigned int, timestamp_t  *));
107
108typedef struct last_tcode {
109	time_t tcode;	/* last converted time code */
110} last_tcode_t;
111
112#define BUFFER_MAX	61
113
114clockformat_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
126static struct dcfparam
127{
128	unsigned char *onebits;
129	unsigned char *zerobits;
130} dcfparameter = 
131{
132	(unsigned char *)"###############RADMLS1248124P124812P1248121241248112481248P??", /* 'ONE' representation */
133	(unsigned char *)"--------------------s-------p------p----------------------p__"  /* 'ZERO' representation */
134};
135
136static 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
166static 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
181static u_long
182ext_bf(
183	unsigned char *buf,
184	int   idx,
185	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
201static unsigned
202pcheck(
203       unsigned char *buf,
204       int   idx,
205       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
219static u_long
220convert_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	unsigned char *b = dcfprm->onebits;
229	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\n", 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\"\n", 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 */
333static u_long
334cvt_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	unsigned char *b = dcfparameter.onebits;
346	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*/
518static u_long
519pps_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
534static u_long
535snt_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 */
562static u_long
563inp_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) */
598int 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 */