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
| 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", size, buffer));
| 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
| 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", size, buffer);
| 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 */
| 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 */
|