summaryrefslogtreecommitdiffstats
path: root/contrib/ntp/libparse/clk_rawdcf.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/ntp/libparse/clk_rawdcf.c')
-rw-r--r--contrib/ntp/libparse/clk_rawdcf.c581
1 files changed, 581 insertions, 0 deletions
diff --git a/contrib/ntp/libparse/clk_rawdcf.c b/contrib/ntp/libparse/clk_rawdcf.c
new file mode 100644
index 0000000..ac854c5
--- /dev/null
+++ b/contrib/ntp/libparse/clk_rawdcf.c
@@ -0,0 +1,581 @@
+/*
+ * /src/NTP/ntp-4/libparse/clk_rawdcf.c,v 4.6 1998/06/14 21:09:37 kardel RELEASE_19990228_A
+ *
+ * clk_rawdcf.c,v 4.6 1998/06/14 21:09:37 kardel RELEASE_19990228_A
+ *
+ * Raw DCF77 pulse clock support
+ *
+ * Copyright (C) 1992-1998 by Frank Kardel
+ * Friedrich-Alexander Universität Erlangen-Nürnberg, Germany
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if defined(REFCLOCK) && defined(CLOCK_PARSE) && defined(CLOCK_RAWDCF)
+
+#include <sys/types.h>
+#include <sys/time.h>
+
+#include "ntp_fp.h"
+#include "ntp_unixtime.h"
+#include "ntp_calendar.h"
+
+#include "parse.h"
+#ifdef PARSESTREAM
+# include <sys/parsestreams.h>
+#endif
+
+#ifndef PARSEKERNEL
+# include "ntp_stdlib.h"
+#endif
+
+/*
+ * DCF77 raw time code
+ *
+ * From "Zur Zeit", Physikalisch-Technische Bundesanstalt (PTB), Braunschweig
+ * und Berlin, Maerz 1989
+ *
+ * Timecode transmission:
+ * AM:
+ * time marks are send every second except for the second before the
+ * next minute mark
+ * time marks consist of a reduction of transmitter power to 25%
+ * of the nominal level
+ * the falling edge is the time indication (on time)
+ * time marks of a 100ms duration constitute a logical 0
+ * time marks of a 200ms duration constitute a logical 1
+ * FM:
+ * see the spec. (basically a (non-)inverted psuedo random phase shift)
+ *
+ * Encoding:
+ * Second Contents
+ * 0 - 10 AM: free, FM: 0
+ * 11 - 14 free
+ * 15 R - alternate antenna
+ * 16 A1 - expect zone change (1 hour before)
+ * 17 - 18 Z1,Z2 - time zone
+ * 0 0 illegal
+ * 0 1 MEZ (MET)
+ * 1 0 MESZ (MED, MET DST)
+ * 1 1 illegal
+ * 19 A2 - expect leap insertion/deletion (1 hour before)
+ * 20 S - start of time code (1)
+ * 21 - 24 M1 - BCD (lsb first) Minutes
+ * 25 - 27 M10 - BCD (lsb first) 10 Minutes
+ * 28 P1 - Minute Parity (even)
+ * 29 - 32 H1 - BCD (lsb first) Hours
+ * 33 - 34 H10 - BCD (lsb first) 10 Hours
+ * 35 P2 - Hour Parity (even)
+ * 36 - 39 D1 - BCD (lsb first) Days
+ * 40 - 41 D10 - BCD (lsb first) 10 Days
+ * 42 - 44 DW - BCD (lsb first) day of week (1: Monday -> 7: Sunday)
+ * 45 - 49 MO - BCD (lsb first) Month
+ * 50 MO0 - 10 Months
+ * 51 - 53 Y1 - BCD (lsb first) Years
+ * 54 - 57 Y10 - BCD (lsb first) 10 Years
+ * 58 P3 - Date Parity (even)
+ * 59 - usually missing (minute indication), except for leap insertion
+ */
+
+static u_long pps_rawdcf P((parse_t *, int, timestamp_t *));
+static u_long cvt_rawdcf P((unsigned char *, int, struct format *, clocktime_t *, void *));
+static u_long inp_rawdcf P((parse_t *, unsigned int, timestamp_t *));
+
+clockformat_t clock_rawdcf =
+{
+ inp_rawdcf, /* DCF77 input handling */
+ cvt_rawdcf, /* raw dcf input conversion */
+ pps_rawdcf, /* examining PPS information */
+ 0, /* no private configuration data */
+ "RAW DCF77 Timecode", /* direct decoding / time synthesis */
+
+ 61, /* bit buffer */
+ 0 /* no private data (currently in input buffer) */
+};
+
+static struct dcfparam
+{
+ unsigned char onebits[60];
+ unsigned char zerobits[60];
+} dcfparameter =
+{
+ "###############RADMLS1248124P124812P1248121241248112481248P", /* 'ONE' representation */
+ "--------------------s-------p------p----------------------p" /* 'ZERO' representation */
+};
+
+static struct rawdcfcode
+{
+ char offset; /* start bit */
+} rawdcfcode[] =
+{
+ { 0 }, { 15 }, { 16 }, { 17 }, { 19 }, { 20 }, { 21 }, { 25 }, { 28 }, { 29 },
+ { 33 }, { 35 }, { 36 }, { 40 }, { 42 }, { 45 }, { 49 }, { 50 }, { 54 }, { 58 }, { 59 }
+};
+
+#define DCF_M 0
+#define DCF_R 1
+#define DCF_A1 2
+#define DCF_Z 3
+#define DCF_A2 4
+#define DCF_S 5
+#define DCF_M1 6
+#define DCF_M10 7
+#define DCF_P1 8
+#define DCF_H1 9
+#define DCF_H10 10
+#define DCF_P2 11
+#define DCF_D1 12
+#define DCF_D10 13
+#define DCF_DW 14
+#define DCF_MO 15
+#define DCF_MO0 16
+#define DCF_Y1 17
+#define DCF_Y10 18
+#define DCF_P3 19
+
+static struct partab
+{
+ char offset; /* start bit of parity field */
+} partab[] =
+{
+ { 21 }, { 29 }, { 36 }, { 59 }
+};
+
+#define DCF_P_P1 0
+#define DCF_P_P2 1
+#define DCF_P_P3 2
+
+#define DCF_Z_MET 0x2
+#define DCF_Z_MED 0x1
+
+static u_long
+ext_bf(
+ register unsigned char *buf,
+ register int idx,
+ register unsigned char *zero
+ )
+{
+ register u_long sum = 0;
+ register int i, first;
+
+ first = rawdcfcode[idx].offset;
+
+ for (i = rawdcfcode[idx+1].offset - 1; i >= first; i--)
+ {
+ sum <<= 1;
+ sum |= (buf[i] != zero[i]);
+ }
+ return sum;
+}
+
+static unsigned
+pcheck(
+ unsigned char *buf,
+ int idx,
+ unsigned char *zero
+ )
+{
+ int i,last;
+ unsigned psum = 1;
+
+ last = partab[idx+1].offset;
+
+ for (i = partab[idx].offset; i < last; i++)
+ psum ^= (buf[i] != zero[i]);
+
+ return psum;
+}
+
+static u_long
+convert_rawdcf(
+ unsigned char *buffer,
+ int size,
+ struct dcfparam *dcfprm,
+ clocktime_t *clock_time
+ )
+{
+ register unsigned char *s = buffer;
+ register unsigned char *b = dcfprm->onebits;
+ register unsigned char *c = dcfprm->zerobits;
+ register int i;
+
+ parseprintf(DD_RAWDCF,("parse: convert_rawdcf: \"%s\"\n", buffer));
+
+ if (size < 57)
+ {
+#ifndef PARSEKERNEL
+ msyslog(LOG_ERR, "parse: convert_rawdcf: INCOMPLETE DATA - time code only has %d bits\n", size);
+#endif
+ return CVT_NONE;
+ }
+
+ for (i = 0; i < 58; i++)
+ {
+ if ((*s != *b) && (*s != *c))
+ {
+ /*
+ * we only have two types of bytes (ones and zeros)
+ */
+#ifndef PARSEKERNEL
+ msyslog(LOG_ERR, "parse: convert_rawdcf: BAD DATA - no conversion for \"%s\"\n", buffer);
+#endif
+ return CVT_NONE;
+ }
+ b++;
+ c++;
+ s++;
+ }
+
+ /*
+ * check Start and Parity bits
+ */
+ if ((ext_bf(buffer, DCF_S, dcfprm->zerobits) == 1) &&
+ pcheck(buffer, DCF_P_P1, dcfprm->zerobits) &&
+ pcheck(buffer, DCF_P_P2, dcfprm->zerobits) &&
+ pcheck(buffer, DCF_P_P3, dcfprm->zerobits))
+ {
+ /*
+ * buffer OK
+ */
+ parseprintf(DD_RAWDCF,("parse: convert_rawdcf: parity check passed\n"));
+
+ clock_time->flags = PARSEB_S_ANTENNA|PARSEB_S_LEAP;
+ clock_time->utctime= 0;
+ clock_time->usecond= 0;
+ clock_time->second = 0;
+ clock_time->minute = ext_bf(buffer, DCF_M10, dcfprm->zerobits);
+ clock_time->minute = TIMES10(clock_time->minute) + ext_bf(buffer, DCF_M1, dcfprm->zerobits);
+ clock_time->hour = ext_bf(buffer, DCF_H10, dcfprm->zerobits);
+ clock_time->hour = TIMES10(clock_time->hour) + ext_bf(buffer, DCF_H1, dcfprm->zerobits);
+ clock_time->day = ext_bf(buffer, DCF_D10, dcfprm->zerobits);
+ clock_time->day = TIMES10(clock_time->day) + ext_bf(buffer, DCF_D1, dcfprm->zerobits);
+ clock_time->month = ext_bf(buffer, DCF_MO0, dcfprm->zerobits);
+ clock_time->month = TIMES10(clock_time->month) + ext_bf(buffer, DCF_MO, dcfprm->zerobits);
+ clock_time->year = ext_bf(buffer, DCF_Y10, dcfprm->zerobits);
+ clock_time->year = TIMES10(clock_time->year) + ext_bf(buffer, DCF_Y1, dcfprm->zerobits);
+
+ switch (ext_bf(buffer, DCF_Z, dcfprm->zerobits))
+ {
+ case DCF_Z_MET:
+ clock_time->utcoffset = -1*60*60;
+ break;
+
+ case DCF_Z_MED:
+ clock_time->flags |= PARSEB_DST;
+ clock_time->utcoffset = -2*60*60;
+ break;
+
+ default:
+ parseprintf(DD_RAWDCF,("parse: convert_rawdcf: BAD TIME ZONE\n"));
+ return CVT_FAIL|CVT_BADFMT;
+ }
+
+ if (ext_bf(buffer, DCF_A1, dcfprm->zerobits))
+ clock_time->flags |= PARSEB_ANNOUNCE;
+
+ if (ext_bf(buffer, DCF_A2, dcfprm->zerobits))
+ clock_time->flags |= PARSEB_LEAPADD; /* default: DCF77 data format deficiency */
+
+ if (ext_bf(buffer, DCF_R, dcfprm->zerobits))
+ clock_time->flags |= PARSEB_ALTERNATE;
+
+ parseprintf(DD_RAWDCF,("parse: convert_rawdcf: TIME CODE OK: %d:%d, %d.%d.%d, flags 0x%lx\n",
+ (int)clock_time->hour, (int)clock_time->minute, (int)clock_time->day, (int)clock_time->month,(int) clock_time->year,
+ (u_long)clock_time->flags));
+ return CVT_OK;
+ }
+ else
+ {
+ /*
+ * bad format - not for us
+ */
+#ifndef PARSEKERNEL
+ msyslog(LOG_ERR, "parse: convert_rawdcf: parity check FAILED for \"%s\"\n", buffer);
+#endif
+ return CVT_FAIL|CVT_BADFMT;
+ }
+}
+
+/*
+ * raw dcf input routine - needs to fix up 50 baud
+ * characters for 1/0 decision
+ */
+static u_long
+cvt_rawdcf(
+ unsigned char *buffer,
+ int size,
+ struct format *param,
+ clocktime_t *clock_time,
+ void *local
+ )
+{
+ register unsigned char *s = (unsigned char *)buffer;
+ register unsigned char *e = s + size;
+ register unsigned char *b = dcfparameter.onebits;
+ register unsigned char *c = dcfparameter.zerobits;
+ register unsigned rtc = CVT_NONE;
+ register unsigned int i, lowmax, highmax, cutoff, span;
+#define BITS 9
+ unsigned char histbuf[BITS];
+ /*
+ * the input buffer contains characters with runs of consecutive
+ * bits set. These set bits are an indication of the DCF77 pulse
+ * length. We assume that we receive the pulse at 50 Baud. Thus
+ * a 100ms pulse would generate a 4 bit train (20ms per bit and
+ * start bit)
+ * a 200ms pulse would create all zeroes (and probably a frame error)
+ */
+
+ for (i = 0; i < BITS; i++)
+ {
+ histbuf[i] = 0;
+ }
+
+ cutoff = 0;
+ lowmax = 0;
+
+ while (s < e)
+ {
+ register unsigned int ch = *s ^ 0xFF;
+ /*
+ * these lines are left as an excercise to the reader 8-)
+ */
+ if (!((ch+1) & ch) || !*s)
+ {
+
+ for (i = 0; ch; i++)
+ {
+ ch >>= 1;
+ }
+
+ *s = i;
+ histbuf[i]++;
+ cutoff += i;
+ lowmax++;
+ }
+ else
+ {
+ parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: character check for 0x%x@%d FAILED\n", *s, (int)(s - (unsigned char *)buffer)));
+ *s = (unsigned char)~0;
+ rtc = CVT_FAIL|CVT_BADFMT;
+ }
+ s++;
+ }
+
+ if (lowmax)
+ {
+ cutoff /= lowmax;
+ }
+ else
+ {
+ cutoff = 4; /* doesn't really matter - it'll fail anyway, but gives error output */
+ }
+
+ parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: average bit count: %d\n", cutoff));
+
+ lowmax = 0;
+ highmax = 0;
+
+ parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: histogram:"));
+ for (i = 0; i <= cutoff; i++)
+ {
+ lowmax+=histbuf[i] * i;
+ highmax += histbuf[i];
+ parseprintf(DD_RAWDCF,(" %d", histbuf[i]));
+ }
+ parseprintf(DD_RAWDCF, (" <M>"));
+
+ lowmax += highmax / 2;
+
+ if (highmax)
+ {
+ lowmax /= highmax;
+ }
+ else
+ {
+ lowmax = 0;
+ }
+
+ highmax = 0;
+ cutoff = 0;
+
+ for (; i < BITS; i++)
+ {
+ highmax+=histbuf[i] * i;
+ cutoff +=histbuf[i];
+ parseprintf(DD_RAWDCF,(" %d", histbuf[i]));
+ }
+ parseprintf(DD_RAWDCF,("\n"));
+
+ if (cutoff)
+ {
+ highmax /= cutoff;
+ }
+ else
+ {
+ highmax = BITS-1;
+ }
+
+ span = cutoff = lowmax;
+ for (i = lowmax; i <= highmax; i++)
+ {
+ if (histbuf[cutoff] > histbuf[i])
+ {
+ cutoff = i;
+ span = i;
+ }
+ else
+ if (histbuf[cutoff] == histbuf[i])
+ {
+ span = i;
+ }
+ }
+
+ cutoff = (cutoff + span) / 2;
+
+ parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: lower maximum %d, higher maximum %d, cutoff %d\n", lowmax, highmax, cutoff));
+
+ s = (unsigned char *)buffer;
+ while ((s < e) && *c && *b)
+ {
+ if (*s == (unsigned char)~0)
+ {
+ *s = '?';
+ }
+ else
+ {
+ *s = (*s >= cutoff) ? *b : *c;
+ }
+ s++;
+ b++;
+ c++;
+ }
+
+ return (rtc == CVT_NONE) ? convert_rawdcf(buffer, size, &dcfparameter, clock_time) : rtc;
+}
+
+/*
+ * pps_rawdcf
+ *
+ * currently a very stupid version - should be extended to decode
+ * also ones and zeros (which is easy)
+ */
+/*ARGSUSED*/
+static u_long
+pps_rawdcf(
+ register parse_t *parseio,
+ register int status,
+ register timestamp_t *ptime
+ )
+{
+ if (!status) /* negative edge for simpler wiring (Rx->DCD) */
+ {
+ parseio->parse_dtime.parse_ptime = *ptime;
+ parseio->parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
+ }
+
+ return CVT_NONE;
+}
+
+static u_long
+snt_rawdcf(
+ register parse_t *parseio,
+ register timestamp_t *ptime
+ )
+{
+ if ((parseio->parse_dtime.parse_status & CVT_MASK) == CVT_OK)
+ {
+ parseio->parse_dtime.parse_stime = *ptime;
+
+#ifdef PARSEKERNEL
+ parseio->parse_dtime.parse_time.tv.tv_sec++;
+#else
+ parseio->parse_dtime.parse_time.fp.l_ui++;
+#endif
+
+ parseprintf(DD_RAWDCF,("parse: snt_rawdcf: time stamp synthesized offset %d seconds\n", parseio->parse_index - 1));
+
+ return updatetimeinfo(parseio, parseio->parse_lstate);
+ }
+ return CVT_NONE;
+}
+
+/*
+ * inp_rawdcf
+ *
+ * grep DCF77 data from input stream
+ */
+static u_long
+inp_rawdcf(
+ parse_t *parseio,
+ unsigned int ch,
+ timestamp_t *tstamp
+ )
+{
+ static struct timeval timeout = { 1, 500000 }; /* 1.5 secongs denote second #60 */
+
+ parseprintf(DD_PARSE, ("inp_rawdcf(0x%x, 0x%x, ...)\n", (int)parseio, (int)ch));
+
+ parseio->parse_dtime.parse_stime = *tstamp; /* collect timestamp */
+
+ if (parse_timedout(parseio, tstamp, &timeout))
+ {
+ parseprintf(DD_PARSE, ("inp_rawdcf: time out seen\n"));
+
+ (void) parse_end(parseio);
+ (void) parse_addchar(parseio, ch);
+ return PARSE_INP_TIME;
+ }
+ else
+ {
+ unsigned int rtc;
+
+ rtc = parse_addchar(parseio, ch);
+ if (rtc == PARSE_INP_SKIP)
+ {
+ if (snt_rawdcf(parseio, tstamp) == CVT_OK)
+ return PARSE_INP_SYNTH;
+ }
+ return rtc;
+ }
+}
+
+#else /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */
+int clk_rawdcf_bs;
+#endif /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */
+
+/*
+ * History:
+ *
+ * clk_rawdcf.c,v
+ * Revision 4.6 1998/06/14 21:09:37 kardel
+ * Sun acc cleanup
+ *
+ * Revision 4.5 1998/06/13 12:04:16 kardel
+ * fix SYSV clock name clash
+ *
+ * Revision 4.4 1998/06/12 15:22:28 kardel
+ * fix prototypes
+ *
+ * Revision 4.3 1998/06/06 18:33:36 kardel
+ * simplified condidional compile expression
+ *
+ * Revision 4.2 1998/05/24 11:04:18 kardel
+ * triggering PPS on negative edge for simpler wiring (Rx->DCD)
+ *
+ * Revision 4.1 1998/05/24 09:39:53 kardel
+ * implementation of the new IO handling model
+ *
+ * Revision 4.0 1998/04/10 19:45:30 kardel
+ * Start 4.0 release version numbering
+ *
+ * from V3 3.24 log info deleted 1998/04/11 kardel
+ *
+ */
OpenPOWER on IntegriCloud