1 /* $NetBSD: refclock_chu.c,v 1.11 2024/08/18 20:47:18 christos Exp $ */
2
3 /*
4 * refclock_chu - clock driver for Canadian CHU time/frequency station
5 */
6 #ifdef HAVE_CONFIG_H
7 #include <config.h>
8 #endif
9
10 #include "ntp_types.h"
11
12 #if defined(REFCLOCK) && defined(CLOCK_CHU)
13
14 #include "ntpd.h"
15 #include "ntp_io.h"
16 #include "ntp_refclock.h"
17 #include "ntp_calendar.h"
18 #include "ntp_stdlib.h"
19
20 #include <stdio.h>
21 #include <ctype.h>
22 #include <math.h>
23
24 #ifdef HAVE_AUDIO
25 #include "audio.h"
26 #endif /* HAVE_AUDIO */
27
28 #define ICOM 1 /* undefine to suppress ICOM code */
29
30 #ifdef ICOM
31 #include "icom.h"
32 #endif /* ICOM */
33 /*
34 * Audio CHU demodulator/decoder
35 *
36 * This driver synchronizes the computer time using data encoded in
37 * radio transmissions from Canadian time/frequency station CHU in
38 * Ottawa, Ontario. Transmissions are made continuously on 3330 kHz,
39 * 7850 kHz and 14670 kHz in upper sideband, compatible AM mode. An
40 * ordinary shortwave receiver can be tuned manually to one of these
41 * frequencies or, in the case of ICOM receivers, the receiver can be
42 * tuned automatically as propagation conditions change throughout the
43 * day and season.
44 *
45 * The driver requires an audio codec or sound card with sampling rate 8
46 * kHz and mu-law companding. This is the same standard as used by the
47 * telephone industry and is supported by most hardware and operating
48 * systems, including Solaris, SunOS, FreeBSD, NetBSD and Linux. In this
49 * implementation, only one audio driver and codec can be supported on a
50 * single machine.
51 *
52 * The driver can be compiled to use a Bell 103 compatible modem or
53 * modem chip to receive the radio signal and demodulate the data.
54 * Alternatively, the driver can be compiled to use the audio codec of
55 * the workstation or another with compatible audio drivers. In the
56 * latter case, the driver implements the modem using DSP routines, so
57 * the radio can be connected directly to either the microphone on line
58 * input port. In either case, the driver decodes the data using a
59 * maximum-likelihood technique which exploits the considerable degree
60 * of redundancy available to maximize accuracy and minimize errors.
61 *
62 * The CHU time broadcast includes an audio signal compatible with the
63 * Bell 103 modem standard (mark = 2225 Hz, space = 2025 Hz). The signal
64 * consists of nine, ten-character bursts transmitted at 300 bps between
65 * seconds 31 and 39 of each minute. Each character consists of eight
66 * data bits plus one start bit and two stop bits to encode two hex
67 * digits. The burst data consist of five characters (ten hex digits)
68 * followed by a repeat of these characters. In format A, the characters
69 * are repeated in the same polarity; in format B, the characters are
70 * repeated in the opposite polarity.
71 *
72 * Format A bursts are sent at seconds 32 through 39 of the minute in
73 * hex digits (nibble swapped)
74 *
75 * 6dddhhmmss6dddhhmmss
76 *
77 * The first ten digits encode a frame marker (6) followed by the day
78 * (ddd), hour (hh in UTC), minute (mm) and the second (ss). Since
79 * format A bursts are sent during the third decade of seconds the tens
80 * digit of ss is always 3. The driver uses this to determine correct
81 * burst synchronization. These digits are then repeated with the same
82 * polarity.
83 *
84 * Format B bursts are sent at second 31 of the minute in hex digits
85 *
86 * xdyyyyttaaxdyyyyttaa
87 *
88 * The first ten digits encode a code (x described below) followed by
89 * the DUT1 (d in deciseconds), Gregorian year (yyyy), difference TAI -
90 * UTC (tt) and daylight time indicator (aa) peculiar to Canada. These
91 * digits are then repeated with inverted polarity.
92 *
93 * The x is coded
94 *
95 * 1 Sign of DUT (0 = +)
96 * 2 Leap second warning. One second will be added.
97 * 4 Leap second warning. One second will be subtracted.
98 * 8 Even parity bit for this nibble.
99 *
100 * By design, the last stop bit of the last character in the burst
101 * coincides with 0.5 second. Since characters have 11 bits and are
102 * transmitted at 300 bps, the last stop bit of the first character
103 * coincides with 0.5 - 9 * 11/300 = 0.170 second. Depending on the
104 * UART, character interrupts can vary somewhere between the end of bit
105 * 9 and end of bit 11. These eccentricities can be corrected along with
106 * the radio propagation delay using fudge time 1.
107 *
108 * Debugging aids
109 *
110 * The timecode format used for debugging and data recording includes
111 * data helpful in diagnosing problems with the radio signal and serial
112 * connections. With debugging enabled (-d on the ntpd command line),
113 * the driver produces one line for each burst in two formats
114 * corresponding to format A and B.Each line begins with the format code
115 * chuA or chuB followed by the status code and signal level (0-9999).
116 * The remainder of the line is as follows.
117 *
118 * Following is format A:
119 *
120 * n b f s m code
121 *
122 * where n is the number of characters in the burst (0-10), b the burst
123 * distance (0-40), f the field alignment (-1, 0, 1), s the
124 * synchronization distance (0-16), m the burst number (2-9) and code
125 * the burst characters as received. Note that the hex digits in each
126 * character are reversed, so the burst
127 *
128 * 10 38 0 16 9 06851292930685129293
129 *
130 * is interpreted as containing 10 characters with burst distance 38,
131 * field alignment 0, synchronization distance 16 and burst number 9.
132 * The nibble-swapped timecode shows day 58, hour 21, minute 29 and
133 * second 39.
134 *
135 * Following is format B:
136 *
137 * n b s code
138 *
139 * where n is the number of characters in the burst (0-10), b the burst
140 * distance (0-40), s the synchronization distance (0-40) and code the
141 * burst characters as received. Note that the hex digits in each
142 * character are reversed and the last ten digits inverted, so the burst
143 *
144 * 10 40 1091891300ef6e76ec
145 *
146 * is interpreted as containing 10 characters with burst distance 40.
147 * The nibble-swapped timecode shows DUT1 +0.1 second, year 1998 and TAI
148 * - UTC 31 seconds.
149 *
150 * Each line is preceeded by the code chuA or chuB, as appropriate. If
151 * the audio driver is compiled, the current gain (0-255) and relative
152 * signal level (0-9999) follow the code. The receiver volume control
153 * should be set so that the gain is somewhere near the middle of the
154 * range 0-255, which results in a signal level near 1000.
155 *
156 * In addition to the above, the reference timecode is updated and
157 * written to the clockstats file and debug score after the last burst
158 * received in the minute. The format is
159 *
160 * sq yyyy ddd hh:mm:ss l s dd t agc ident m b
161 *
162 * s '?' before first synchronized and ' ' after that
163 * q status code (see below)
164 * yyyy year
165 * ddd day of year
166 * hh:mm:ss time of day
167 * l leap second indicator (space, L or D)
168 * dst Canadian daylight code (opaque)
169 * t number of minutes since last synchronized
170 * agc audio gain (0 - 255)
171 * ident identifier (CHU0 3330 kHz, CHU1 7850 kHz, CHU2 14670 kHz)
172 * m signal metric (0 - 100)
173 * b number of timecodes for the previous minute (0 - 59)
174 *
175 * Fudge factors
176 *
177 * For accuracies better than the low millisceconds, fudge time1 can be
178 * set to the radio propagation delay from CHU to the receiver. This can
179 * be done conviently using the minimuf program.
180 *
181 * Fudge flag4 causes the dubugging output described above to be
182 * recorded in the clockstats file. When the audio driver is compiled,
183 * fudge flag2 selects the audio input port, where 0 is the mike port
184 * (default) and 1 is the line-in port. It does not seem useful to
185 * select the compact disc player port. Fudge flag3 enables audio
186 * monitoring of the input signal. For this purpose, the monitor gain is
187 * set to a default value.
188 *
189 * The audio codec code is normally compiled in the driver if the
190 * architecture supports it (HAVE_AUDIO defined), but is used only if
191 * the link /dev/chu_audio is defined and valid. The serial port code is
192 * always compiled in the driver, but is used only if the autdio codec
193 * is not available and the link /dev/chu%d is defined and valid.
194 *
195 * The ICOM code is normally compiled in the driver if selected (ICOM
196 * defined), but is used only if the link /dev/icom%d is defined and
197 * valid and the mode keyword on the server configuration command
198 * specifies a nonzero mode (ICOM ID select code). The C-IV speed is
199 * 9600 bps if the high order 0x80 bit of the mode is zero and 1200 bps
200 * if one. The C-IV trace is turned on if the debug level is greater
201 * than one.
202 *
203 * Alarm codes
204 *
205 * CEVNT_BADTIME invalid date or time
206 * CEVNT_PROP propagation failure - no stations heard
207 */
208 /*
209 * Interface definitions
210 */
211 #define SPEED232 B300 /* uart speed (300 baud) */
212 #define PRECISION (-10) /* precision assumed (about 1 ms) */
213 #define REFID "CHU" /* reference ID */
214 #define DEVICE "/dev/chu%d" /* device name and unit */
215 #define SPEED232 B300 /* UART speed (300 baud) */
216 #ifdef ICOM
217 #define TUNE .001 /* offset for narrow filter (MHz) */
218 #define DWELL 5 /* minutes in a dwell */
219 #define NCHAN 3 /* number of channels */
220 #define ISTAGE 3 /* number of integrator stages */
221 #endif /* ICOM */
222
223 #ifdef HAVE_AUDIO
224 /*
225 * Audio demodulator definitions
226 */
227 #define SECOND 8000 /* nominal sample rate (Hz) */
228 #define BAUD 300 /* modulation rate (bps) */
229 #define OFFSET 128 /* companded sample offset */
230 #define SIZE 256 /* decompanding table size */
231 #define MAXAMP 6000. /* maximum signal level */
232 #define MAXCLP 100 /* max clips above reference per s */
233 #define SPAN 800. /* min envelope span */
234 #define LIMIT 1000. /* soft limiter threshold */
235 #define AGAIN 6. /* baseband gain */
236 #define LAG 10 /* discriminator lag */
237 #define DEVICE_AUDIO "/dev/audio" /* device name */
238 #define DESCRIPTION "CHU Audio/Modem Receiver" /* WRU */
239 #define AUDIO_BUFSIZ 240 /* audio buffer size (30 ms) */
240 #else
241 #define DESCRIPTION "CHU Modem Receiver" /* WRU */
242 #endif /* HAVE_AUDIO */
243
244 /*
245 * Decoder definitions
246 */
247 #define CHAR (11. / 300.) /* character time (s) */
248 #define BURST 11 /* max characters per burst */
249 #define MINCHARS 9 /* min characters per burst */
250 #define MINDIST 28 /* min burst distance (of 40) */
251 #define MINSYNC 8 /* min sync distance (of 16) */
252 #define MINSTAMP 20 /* min timestamps (of 60) */
253 #define MINMETRIC 50 /* min channel metric (of 160) */
254
255 /*
256 * The on-time synchronization point for the driver is the last stop bit
257 * of the first character 170 ms. The modem delay is 0.8 ms, while the
258 * receiver delay is approxmately 4.7 ms at 2125 Hz. The fudge value 1.3
259 * ms due to the codec and other causes was determined by calibrating to
260 * a PPS signal from a GPS receiver. The additional propagation delay
261 * specific to each receiver location can be programmed in the fudge
262 * time1.
263 *
264 * The resulting offsets with a 2.4-GHz P4 running FreeBSD 6.1 are
265 * generally within 0.5 ms short term with 0.3 ms jitter. The long-term
266 * offsets vary up to 0.3 ms due to ionospheric layer height variations.
267 * The processor load due to the driver is 0.4 percent.
268 */
269 #define PDELAY ((170 + .8 + 4.7 + 1.3) / 1000) /* system delay (s) */
270
271 /*
272 * Status bits (status)
273 */
274 #define RUNT 0x0001 /* runt burst */
275 #define NOISE 0x0002 /* noise burst */
276 #define BFRAME 0x0004 /* invalid format B frame sync */
277 #define BFORMAT 0x0008 /* invalid format B data */
278 #define AFRAME 0x0010 /* invalid format A frame sync */
279 #define AFORMAT 0x0020 /* invalid format A data */
280 #define DECODE 0x0040 /* invalid data decode */
281 #define STAMP 0x0080 /* too few timestamps */
282 #define AVALID 0x0100 /* valid A frame */
283 #define BVALID 0x0200 /* valid B frame */
284 #define INSYNC 0x0400 /* clock synchronized */
285 #define METRIC 0x0800 /* one or more stations heard */
286
287 /*
288 * Alarm status bits (alarm)
289 *
290 * These alarms are set at the end of a minute in which at least one
291 * burst was received. SYNERR is raised if the AFRAME or BFRAME status
292 * bits are set during the minute, FMTERR is raised if the AFORMAT or
293 * BFORMAT status bits are set, DECERR is raised if the DECODE status
294 * bit is set and TSPERR is raised if the STAMP status bit is set.
295 */
296 #define SYNERR 0x01 /* frame sync error */
297 #define FMTERR 0x02 /* data format error */
298 #define DECERR 0x04 /* data decoding error */
299 #define TSPERR 0x08 /* insufficient data */
300
301 #ifdef HAVE_AUDIO
302 /*
303 * Maximum-likelihood UART structure. There are eight of these
304 * corresponding to the number of phases.
305 */
306 struct surv {
307 l_fp cstamp; /* last bit timestamp */
308 double shift[12]; /* sample shift register */
309 double span; /* shift register envelope span */
310 double dist; /* sample distance */
311 int uart; /* decoded character */
312 };
313 #endif /* HAVE_AUDIO */
314
315 #ifdef ICOM
316 /*
317 * CHU station structure. There are three of these corresponding to the
318 * three frequencies.
319 */
320 struct xmtr {
321 double integ[ISTAGE]; /* circular integrator */
322 double metric; /* integrator sum */
323 int iptr; /* integrator pointer */
324 int probe; /* dwells since last probe */
325 };
326 #endif /* ICOM */
327
328 /*
329 * CHU unit control structure
330 */
331 struct chuunit {
332 u_char decode[20][16]; /* maximum-likelihood decoding matrix */
333 l_fp cstamp[BURST]; /* character timestamps */
334 l_fp tstamp[MAXSTAGE]; /* timestamp samples */
335 l_fp timestamp; /* current buffer timestamp */
336 l_fp laststamp; /* last buffer timestamp */
337 l_fp charstamp; /* character time as a l_fp */
338 int second; /* counts the seconds of the minute */
339 int errflg; /* error flags */
340 int status; /* status bits */
341 char ident[5]; /* station ID and channel */
342 #ifdef ICOM
343 int fd_icom; /* ICOM file descriptor */
344 int chan; /* radio channel */
345 int dwell; /* dwell cycle */
346 struct xmtr xmtr[NCHAN]; /* station metric */
347 #endif /* ICOM */
348
349 /*
350 * Character burst variables
351 */
352 int cbuf[BURST]; /* character buffer */
353 int ntstamp; /* number of timestamp samples */
354 int ndx; /* buffer start index */
355 int prevsec; /* previous burst second */
356 int burdist; /* burst distance */
357 int syndist; /* sync distance */
358 int burstcnt; /* format A bursts this minute */
359 double maxsignal; /* signal level (modem only) */
360 int gain; /* codec gain (modem only) */
361
362 /*
363 * Format particulars
364 */
365 int leap; /* leap/dut code */
366 int dut; /* UTC1 correction */
367 int tai; /* TAI - UTC correction */
368 int dst; /* Canadian DST code */
369
370 #ifdef HAVE_AUDIO
371 /*
372 * Audio codec variables
373 */
374 int fd_audio; /* audio port file descriptor */
375 double comp[SIZE]; /* decompanding table */
376 int port; /* codec port */
377 int mongain; /* codec monitor gain */
378 int clipcnt; /* sample clip count */
379 int seccnt; /* second interval counter */
380
381 /*
382 * Modem variables
383 */
384 l_fp tick; /* audio sample increment */
385 double bpf[9]; /* IIR bandpass filter */
386 double disc[LAG]; /* discriminator shift register */
387 double lpf[27]; /* FIR lowpass filter */
388 double monitor; /* audio monitor */
389 int discptr; /* discriminator pointer */
390
391 /*
392 * Maximum-likelihood UART variables
393 */
394 double baud; /* baud interval */
395 struct surv surv[8]; /* UART survivor structures */
396 int decptr; /* decode pointer */
397 int decpha; /* decode phase */
398 int dbrk; /* holdoff counter */
399 #endif /* HAVE_AUDIO */
400 };
401
402 /*
403 * Function prototypes
404 */
405 static int chu_start (int, struct peer *);
406 static void chu_shutdown (int, struct peer *);
407 static void chu_receive (struct recvbuf *);
408 static void chu_second (int, struct peer *);
409 static void chu_poll (int, struct peer *);
410
411 /*
412 * More function prototypes
413 */
414 static void chu_decode (struct peer *, int, l_fp);
415 static void chu_burst (struct peer *);
416 static void chu_clear (struct peer *);
417 static void chu_a (struct peer *, int);
418 static void chu_b (struct peer *, int);
419 static int chu_dist (int, int);
420 static double chu_major (struct peer *);
421 #ifdef HAVE_AUDIO
422 static void chu_uart (struct surv *, double);
423 static void chu_rf (struct peer *, double);
424 static void chu_gain (struct peer *);
425 static void chu_audio_receive (struct recvbuf *rbufp);
426 #endif /* HAVE_AUDIO */
427 #ifdef ICOM
428 static int chu_newchan (struct peer *, double);
429 #endif /* ICOM */
430 static void chu_serial_receive (struct recvbuf *rbufp);
431
432 /*
433 * Global variables
434 */
435 static char hexchar[] = "0123456789abcdef_*=";
436
437 #ifdef ICOM
438 /*
439 * Note the tuned frequencies are 1 kHz higher than the carrier. CHU
440 * transmits on USB with carrier so we can use AM and the narrow SSB
441 * filter.
442 */
443 static double qsy[NCHAN] = {3.330, 7.850, 14.670}; /* freq (MHz) */
444 #endif /* ICOM */
445
446 /*
447 * Transfer vector
448 */
449 struct refclock refclock_chu = {
450 chu_start, /* start up driver */
451 chu_shutdown, /* shut down driver */
452 chu_poll, /* transmit poll message */
453 noentry, /* not used (old chu_control) */
454 noentry, /* initialize driver (not used) */
455 noentry, /* not used (old chu_buginfo) */
456 chu_second /* housekeeping timer */
457 };
458
459
460 /*
461 * chu_start - open the devices and initialize data for processing
462 */
463 static int
chu_start(int unit,struct peer * peer)464 chu_start(
465 int unit, /* instance number (not used) */
466 struct peer *peer /* peer structure pointer */
467 )
468 {
469 struct chuunit *up;
470 struct refclockproc *pp;
471 char device[20]; /* device name */
472 int fd; /* file descriptor */
473 #ifdef ICOM
474 int temp;
475 #endif /* ICOM */
476 #ifdef HAVE_AUDIO
477 int fd_audio; /* audio port file descriptor */
478 int i; /* index */
479 double step; /* codec adjustment */
480
481 /*
482 * Open audio device. Don't complain if not there.
483 */
484 fd_audio = audio_init(DEVICE_AUDIO, AUDIO_BUFSIZ, unit);
485
486 #ifdef DEBUG
487 if (fd_audio >= 0 && debug)
488 audio_show();
489 #endif
490
491 /*
492 * If audio is unavailable, Open serial port in raw mode.
493 */
494 if (fd_audio >= 0) {
495 fd = fd_audio;
496 } else {
497 snprintf(device, sizeof(device), DEVICE, unit);
498 fd = refclock_open(&peer->srcadr, device, SPEED232, LDISC_RAW);
499 }
500 #else /* HAVE_AUDIO */
501
502 /*
503 * Open serial port in raw mode.
504 */
505 snprintf(device, sizeof(device), DEVICE, unit);
506 fd = refclock_open(&peer->srcadr, device, SPEED232, LDISC_RAW);
507 #endif /* HAVE_AUDIO */
508
509 if (fd < 0)
510 return (0);
511
512 /*
513 * Allocate and initialize unit structure
514 */
515 up = emalloc_zero(sizeof(*up));
516 pp = peer->procptr;
517 pp->unitptr = up;
518 pp->io.clock_recv = chu_receive;
519 pp->io.srcclock = peer;
520 pp->io.datalen = 0;
521 pp->io.fd = fd;
522 if (!io_addclock(&pp->io)) {
523 close(fd);
524 pp->io.fd = -1;
525 free(up);
526 pp->unitptr = NULL;
527 return (0);
528 }
529
530 /*
531 * Initialize miscellaneous variables
532 */
533 peer->precision = PRECISION;
534 pp->clockdesc = DESCRIPTION;
535 strlcpy(up->ident, "CHU", sizeof(up->ident));
536 memcpy(&pp->refid, up->ident, 4);
537 DTOLFP(CHAR, &up->charstamp);
538 #ifdef HAVE_AUDIO
539
540 /*
541 * The companded samples are encoded sign-magnitude. The table
542 * contains all the 256 values in the interest of speed. We do
543 * this even if the audio codec is not available. C'est la lazy.
544 */
545 up->fd_audio = fd_audio;
546 up->gain = 127;
547 up->comp[0] = up->comp[OFFSET] = 0.;
548 up->comp[1] = 1; up->comp[OFFSET + 1] = -1.;
549 up->comp[2] = 3; up->comp[OFFSET + 2] = -3.;
550 step = 2.;
551 for (i = 3; i < OFFSET; i++) {
552 up->comp[i] = up->comp[i - 1] + step;
553 up->comp[OFFSET + i] = -up->comp[i];
554 if (i % 16 == 0)
555 step *= 2.;
556 }
557 DTOLFP(1. / SECOND, &up->tick);
558 #endif /* HAVE_AUDIO */
559 #ifdef ICOM
560 temp = 0;
561 #ifdef DEBUG
562 if (debug > 1)
563 temp = P_TRACE;
564 #endif
565 if (peer->ttl > 0) {
566 if (peer->ttl & 0x80)
567 up->fd_icom = icom_init("/dev/icom", B1200,
568 temp);
569 else
570 up->fd_icom = icom_init("/dev/icom", B9600,
571 temp);
572 }
573 if (up->fd_icom > 0) {
574 if (chu_newchan(peer, 0) != 0) {
575 msyslog(LOG_NOTICE, "icom: radio not found");
576 close(up->fd_icom);
577 up->fd_icom = 0;
578 } else {
579 msyslog(LOG_NOTICE, "icom: autotune enabled");
580 }
581 }
582 #endif /* ICOM */
583 return (1);
584 }
585
586
587 /*
588 * chu_shutdown - shut down the clock
589 */
590 static void
chu_shutdown(int unit,struct peer * peer)591 chu_shutdown(
592 int unit, /* instance number (not used) */
593 struct peer *peer /* peer structure pointer */
594 )
595 {
596 struct chuunit *up;
597 struct refclockproc *pp;
598
599 pp = peer->procptr;
600 up = pp->unitptr;
601 if (up == NULL)
602 return;
603
604 io_closeclock(&pp->io);
605 #ifdef ICOM
606 if (up->fd_icom > 0)
607 close(up->fd_icom);
608 #endif /* ICOM */
609 free(up);
610 }
611
612
613 /*
614 * chu_receive - receive data from the audio or serial device
615 */
616 static void
chu_receive(struct recvbuf * rbufp)617 chu_receive(
618 struct recvbuf *rbufp /* receive buffer structure pointer */
619 )
620 {
621 #ifdef HAVE_AUDIO
622 struct chuunit *up;
623 struct refclockproc *pp;
624 struct peer *peer;
625
626 peer = rbufp->recv_peer;
627 pp = peer->procptr;
628 up = pp->unitptr;
629
630 /*
631 * If the audio codec is warmed up, the buffer contains codec
632 * samples which need to be demodulated and decoded into CHU
633 * characters using the software UART. Otherwise, the buffer
634 * contains CHU characters from the serial port, so the software
635 * UART is bypassed. In this case the CPU will probably run a
636 * few degrees cooler.
637 */
638 if (up->fd_audio > 0)
639 chu_audio_receive(rbufp);
640 else
641 chu_serial_receive(rbufp);
642 #else
643 chu_serial_receive(rbufp);
644 #endif /* HAVE_AUDIO */
645 }
646
647
648 #ifdef HAVE_AUDIO
649 /*
650 * chu_audio_receive - receive data from the audio device
651 */
652 static void
chu_audio_receive(struct recvbuf * rbufp)653 chu_audio_receive(
654 struct recvbuf *rbufp /* receive buffer structure pointer */
655 )
656 {
657 struct chuunit *up;
658 struct refclockproc *pp;
659 struct peer *peer;
660
661 double sample; /* codec sample */
662 u_char *dpt; /* buffer pointer */
663 int bufcnt; /* buffer counter */
664 l_fp ltemp; /* l_fp temp */
665
666 peer = rbufp->recv_peer;
667 pp = peer->procptr;
668 up = pp->unitptr;
669
670 /*
671 * Main loop - read until there ain't no more. Note codec
672 * samples are bit-inverted.
673 */
674 DTOLFP((double)rbufp->recv_length / SECOND, <emp);
675 L_SUB(&rbufp->recv_time, <emp);
676 up->timestamp = rbufp->recv_time;
677 dpt = rbufp->recv_buffer;
678 for (bufcnt = 0; bufcnt < rbufp->recv_length; bufcnt++) {
679 sample = up->comp[~*dpt++ & 0xff];
680
681 /*
682 * Clip noise spikes greater than MAXAMP. If no clips,
683 * increase the gain a tad; if the clips are too high,
684 * decrease a tad.
685 */
686 if (sample > MAXAMP) {
687 sample = MAXAMP;
688 up->clipcnt++;
689 } else if (sample < -MAXAMP) {
690 sample = -MAXAMP;
691 up->clipcnt++;
692 }
693 chu_rf(peer, sample);
694 L_ADD(&up->timestamp, &up->tick);
695
696 /*
697 * Once each second ride gain.
698 */
699 up->seccnt = (up->seccnt + 1) % SECOND;
700 if (up->seccnt == 0) {
701 chu_gain(peer);
702 }
703 }
704
705 /*
706 * Set the input port and monitor gain for the next buffer.
707 */
708 if (pp->sloppyclockflag & CLK_FLAG2)
709 up->port = 2;
710 else
711 up->port = 1;
712 if (pp->sloppyclockflag & CLK_FLAG3)
713 up->mongain = MONGAIN;
714 else
715 up->mongain = 0;
716 }
717
718
719 /*
720 * chu_rf - filter and demodulate the FSK signal
721 *
722 * This routine implements a 300-baud Bell 103 modem with mark 2225 Hz
723 * and space 2025 Hz. It uses a bandpass filter followed by a soft
724 * limiter, FM discriminator and lowpass filter. A maximum-likelihood
725 * decoder samples the baseband signal at eight times the baud rate and
726 * detects the start bit of each character.
727 *
728 * The filters are built for speed, which explains the rather clumsy
729 * code. Hopefully, the compiler will efficiently implement the move-
730 * and-muiltiply-and-add operations.
731 */
732 static void
chu_rf(struct peer * peer,double sample)733 chu_rf(
734 struct peer *peer, /* peer structure pointer */
735 double sample /* analog sample */
736 )
737 {
738 struct refclockproc *pp;
739 struct chuunit *up;
740 struct surv *sp;
741
742 /*
743 * Local variables
744 */
745 double signal; /* bandpass signal */
746 double limit; /* limiter signal */
747 double disc; /* discriminator signal */
748 double lpf; /* lowpass signal */
749 double dist; /* UART signal distance */
750 int i, j;
751
752 pp = peer->procptr;
753 up = pp->unitptr;
754
755 /*
756 * Bandpass filter. 4th-order elliptic, 500-Hz bandpass centered
757 * at 2125 Hz. Passband ripple 0.3 dB, stopband ripple 50 dB,
758 * phase delay 0.24 ms.
759 */
760 signal = (up->bpf[8] = up->bpf[7]) * 5.844676e-01;
761 signal += (up->bpf[7] = up->bpf[6]) * 4.884860e-01;
762 signal += (up->bpf[6] = up->bpf[5]) * 2.704384e+00;
763 signal += (up->bpf[5] = up->bpf[4]) * 1.645032e+00;
764 signal += (up->bpf[4] = up->bpf[3]) * 4.644557e+00;
765 signal += (up->bpf[3] = up->bpf[2]) * 1.879165e+00;
766 signal += (up->bpf[2] = up->bpf[1]) * 3.522634e+00;
767 signal += (up->bpf[1] = up->bpf[0]) * 7.315738e-01;
768 up->bpf[0] = sample - signal;
769 signal = up->bpf[0] * 6.176213e-03
770 + up->bpf[1] * 3.156599e-03
771 + up->bpf[2] * 7.567487e-03
772 + up->bpf[3] * 4.344580e-03
773 + up->bpf[4] * 1.190128e-02
774 + up->bpf[5] * 4.344580e-03
775 + up->bpf[6] * 7.567487e-03
776 + up->bpf[7] * 3.156599e-03
777 + up->bpf[8] * 6.176213e-03;
778
779 up->monitor = signal / 4.; /* note monitor after filter */
780
781 /*
782 * Soft limiter/discriminator. The 11-sample discriminator lag
783 * interval corresponds to three cycles of 2125 Hz, which
784 * requires the sample frequency to be 2125 * 11 / 3 = 7791.7
785 * Hz. The discriminator output varies +-0.5 interval for input
786 * frequency 2025-2225 Hz. However, we don't get to sample at
787 * this frequency, so the discriminator output is biased. Life
788 * at 8000 Hz sucks.
789 */
790 limit = signal;
791 if (limit > LIMIT)
792 limit = LIMIT;
793 else if (limit < -LIMIT)
794 limit = -LIMIT;
795 disc = up->disc[up->discptr] * -limit;
796 up->disc[up->discptr] = limit;
797 up->discptr = (up->discptr + 1 ) % LAG;
798 if (disc >= 0)
799 disc = SQRT(disc);
800 else
801 disc = -SQRT(-disc);
802
803 /*
804 * Lowpass filter. Raised cosine FIR, Ts = 1 / 300, beta = 0.1.
805 */
806 lpf = (up->lpf[26] = up->lpf[25]) * 2.538771e-02;
807 lpf += (up->lpf[25] = up->lpf[24]) * 1.084671e-01;
808 lpf += (up->lpf[24] = up->lpf[23]) * 2.003159e-01;
809 lpf += (up->lpf[23] = up->lpf[22]) * 2.985303e-01;
810 lpf += (up->lpf[22] = up->lpf[21]) * 4.003697e-01;
811 lpf += (up->lpf[21] = up->lpf[20]) * 5.028552e-01;
812 lpf += (up->lpf[20] = up->lpf[19]) * 6.028795e-01;
813 lpf += (up->lpf[19] = up->lpf[18]) * 6.973249e-01;
814 lpf += (up->lpf[18] = up->lpf[17]) * 7.831828e-01;
815 lpf += (up->lpf[17] = up->lpf[16]) * 8.576717e-01;
816 lpf += (up->lpf[16] = up->lpf[15]) * 9.183463e-01;
817 lpf += (up->lpf[15] = up->lpf[14]) * 9.631951e-01;
818 lpf += (up->lpf[14] = up->lpf[13]) * 9.907208e-01;
819 lpf += (up->lpf[13] = up->lpf[12]) * 1.000000e+00;
820 lpf += (up->lpf[12] = up->lpf[11]) * 9.907208e-01;
821 lpf += (up->lpf[11] = up->lpf[10]) * 9.631951e-01;
822 lpf += (up->lpf[10] = up->lpf[9]) * 9.183463e-01;
823 lpf += (up->lpf[9] = up->lpf[8]) * 8.576717e-01;
824 lpf += (up->lpf[8] = up->lpf[7]) * 7.831828e-01;
825 lpf += (up->lpf[7] = up->lpf[6]) * 6.973249e-01;
826 lpf += (up->lpf[6] = up->lpf[5]) * 6.028795e-01;
827 lpf += (up->lpf[5] = up->lpf[4]) * 5.028552e-01;
828 lpf += (up->lpf[4] = up->lpf[3]) * 4.003697e-01;
829 lpf += (up->lpf[3] = up->lpf[2]) * 2.985303e-01;
830 lpf += (up->lpf[2] = up->lpf[1]) * 2.003159e-01;
831 lpf += (up->lpf[1] = up->lpf[0]) * 1.084671e-01;
832 lpf += up->lpf[0] = disc * 2.538771e-02;
833
834 /*
835 * Maximum-likelihood decoder. The UART updates each of the
836 * eight survivors and determines the span, slice level and
837 * tentative decoded character. Valid 11-bit characters are
838 * framed so that bit 10 and bit 11 (stop bits) are mark and bit
839 * 1 (start bit) is space. When a valid character is found, the
840 * survivor with maximum distance determines the final decoded
841 * character.
842 */
843 up->baud += 1. / SECOND;
844 if (up->baud > 1. / (BAUD * 8.)) {
845 up->baud -= 1. / (BAUD * 8.);
846 up->decptr = (up->decptr + 1) % 8;
847 sp = &up->surv[up->decptr];
848 sp->cstamp = up->timestamp;
849 chu_uart(sp, -lpf * AGAIN);
850 if (up->dbrk > 0) {
851 up->dbrk--;
852 if (up->dbrk > 0)
853 return;
854
855 up->decpha = up->decptr;
856 }
857 if (up->decptr != up->decpha)
858 return;
859
860 dist = 0;
861 j = -1;
862 for (i = 0; i < 8; i++) {
863
864 /*
865 * The timestamp is taken at the last bit, so
866 * for correct decoding we reqire sufficient
867 * span and correct start bit and two stop bits.
868 */
869 if ((up->surv[i].uart & 0x601) != 0x600 ||
870 up->surv[i].span < SPAN)
871 continue;
872
873 if (up->surv[i].dist > dist) {
874 dist = up->surv[i].dist;
875 j = i;
876 }
877 }
878 if (j < 0)
879 return;
880
881 /*
882 * Process the character, then blank the decoder until
883 * the end of the next character.This sets the decoding
884 * phase of the entire burst from the phase of the first
885 * character.
886 */
887 up->maxsignal = up->surv[j].span;
888 chu_decode(peer, (up->surv[j].uart >> 1) & 0xff,
889 up->surv[j].cstamp);
890 up->dbrk = 88;
891 }
892 }
893
894
895 /*
896 * chu_uart - maximum-likelihood UART
897 *
898 * This routine updates a shift register holding the last 11 envelope
899 * samples. It then computes the slice level and span over these samples
900 * and determines the tentative data bits and distance. The calling
901 * program selects over the last eight survivors the one with maximum
902 * distance to determine the decoded character.
903 */
904 static void
chu_uart(struct surv * sp,double sample)905 chu_uart(
906 struct surv *sp, /* survivor structure pointer */
907 double sample /* baseband signal */
908 )
909 {
910 double es_max, es_min; /* max/min envelope */
911 double slice; /* slice level */
912 double dist; /* distance */
913 double dtemp;
914 int i;
915
916 /*
917 * Save the sample and shift right. At the same time, measure
918 * the maximum and minimum over all eleven samples.
919 */
920 es_max = -1e6;
921 es_min = 1e6;
922 sp->shift[0] = sample;
923 for (i = 11; i > 0; i--) {
924 sp->shift[i] = sp->shift[i - 1];
925 if (sp->shift[i] > es_max)
926 es_max = sp->shift[i];
927 if (sp->shift[i] < es_min)
928 es_min = sp->shift[i];
929 }
930
931 /*
932 * Determine the span as the maximum less the minimum and the
933 * slice level as the minimum plus a fraction of the span. Note
934 * the slight bias toward mark to correct for the modem tendency
935 * to make more mark than space errors. Compute the distance on
936 * the assumption the last two bits must be mark, the first
937 * space and the rest either mark or space.
938 */
939 sp->span = es_max - es_min;
940 slice = es_min + .45 * sp->span;
941 dist = 0;
942 sp->uart = 0;
943 for (i = 1; i < 12; i++) {
944 sp->uart <<= 1;
945 dtemp = sp->shift[i];
946 if (dtemp > slice)
947 sp->uart |= 0x1;
948 if (i == 1 || i == 2) {
949 dist += dtemp - es_min;
950 } else if (i == 11) {
951 dist += es_max - dtemp;
952 } else {
953 if (dtemp > slice)
954 dist += dtemp - es_min;
955 else
956 dist += es_max - dtemp;
957 }
958 }
959 sp->dist = dist / (11 * sp->span);
960 }
961 #endif /* HAVE_AUDIO */
962
963
964 /*
965 * chu_serial_receive - receive data from the serial device
966 */
967 static void
chu_serial_receive(struct recvbuf * rbufp)968 chu_serial_receive(
969 struct recvbuf *rbufp /* receive buffer structure pointer */
970 )
971 {
972 struct peer *peer;
973
974 u_char *dpt; /* receive buffer pointer */
975
976 peer = rbufp->recv_peer;
977
978 dpt = (u_char *)&rbufp->recv_space;
979 chu_decode(peer, *dpt, rbufp->recv_time);
980 }
981
982
983 /*
984 * chu_decode - decode the character data
985 */
986 static void
chu_decode(struct peer * peer,int hexhex,l_fp cstamp)987 chu_decode(
988 struct peer *peer, /* peer structure pointer */
989 int hexhex, /* data character */
990 l_fp cstamp /* data character timestamp */
991 )
992 {
993 struct refclockproc *pp;
994 struct chuunit *up;
995
996 l_fp tstmp; /* timestamp temp */
997 double dtemp;
998
999 pp = peer->procptr;
1000 up = pp->unitptr;
1001
1002 /*
1003 * If the interval since the last character is greater than the
1004 * longest burst, process the last burst and start a new one. If
1005 * the interval is less than this but greater than two
1006 * characters, consider this a noise burst and reject it.
1007 */
1008 tstmp = up->timestamp;
1009 if (L_ISZERO(&up->laststamp))
1010 up->laststamp = up->timestamp;
1011 L_SUB(&tstmp, &up->laststamp);
1012 up->laststamp = up->timestamp;
1013 LFPTOD(&tstmp, dtemp);
1014 if (dtemp > BURST * CHAR) {
1015 chu_burst(peer);
1016 up->ndx = 0;
1017 } else if (dtemp > 2.5 * CHAR) {
1018 up->ndx = 0;
1019 }
1020
1021 /*
1022 * Append the character to the current burst and append the
1023 * character timestamp to the timestamp list.
1024 */
1025 if (up->ndx < BURST) {
1026 up->cbuf[up->ndx] = hexhex & 0xff;
1027 up->cstamp[up->ndx] = cstamp;
1028 up->ndx++;
1029
1030 }
1031 }
1032
1033
1034 /*
1035 * chu_burst - search for valid burst format
1036 */
1037 static void
chu_burst(struct peer * peer)1038 chu_burst(
1039 struct peer *peer
1040 )
1041 {
1042 struct chuunit *up;
1043 struct refclockproc *pp;
1044
1045 int i;
1046
1047 pp = peer->procptr;
1048 up = pp->unitptr;
1049
1050 /*
1051 * Correlate a block of five characters with the next block of
1052 * five characters. The burst distance is defined as the number
1053 * of bits that match in the two blocks for format A and that
1054 * match the inverse for format B.
1055 */
1056 if (up->ndx < MINCHARS) {
1057 up->status |= RUNT;
1058 return;
1059 }
1060 up->burdist = 0;
1061 for (i = 0; i < 5 && i < up->ndx - 5; i++)
1062 up->burdist += chu_dist(up->cbuf[i], up->cbuf[i + 5]);
1063
1064 /*
1065 * If the burst distance is at least MINDIST, this must be a
1066 * format A burst; if the value is not greater than -MINDIST, it
1067 * must be a format B burst. If the B burst is perfect, we
1068 * believe it; otherwise, it is a noise burst and of no use to
1069 * anybody.
1070 */
1071 if (up->burdist >= MINDIST) {
1072 chu_a(peer, up->ndx);
1073 } else if (up->burdist <= -MINDIST) {
1074 chu_b(peer, up->ndx);
1075 } else {
1076 up->status |= NOISE;
1077 return;
1078 }
1079
1080 /*
1081 * If this is a valid burst, wait a guard time of ten seconds to
1082 * allow for more bursts, then arm the poll update routine to
1083 * process the minute. Don't do this if this is called from the
1084 * timer interrupt routine.
1085 */
1086 if (peer->outdate != current_time)
1087 peer->nextdate = current_time + 10;
1088 }
1089
1090
1091 /*
1092 * chu_b - decode format B burst
1093 */
1094 static void
chu_b(struct peer * peer,int nchar)1095 chu_b(
1096 struct peer *peer,
1097 int nchar
1098 )
1099 {
1100 struct refclockproc *pp;
1101 struct chuunit *up;
1102
1103 u_char code[11]; /* decoded timecode */
1104 char tbuf[80]; /* trace buffer */
1105 char * p;
1106 size_t chars;
1107 size_t cb;
1108 int i;
1109
1110 pp = peer->procptr;
1111 up = pp->unitptr;
1112
1113 /*
1114 * In a format B burst, a character is considered valid only if
1115 * the first occurence matches the last occurence. The burst is
1116 * considered valid only if all characters are valid; that is,
1117 * only if the distance is 40. Note that once a valid frame has
1118 * been found errors are ignored.
1119 */
1120 snprintf(tbuf, sizeof(tbuf), "chuB %04x %4.0f %2d %2d ",
1121 up->status, up->maxsignal, nchar, -up->burdist);
1122 cb = sizeof(tbuf);
1123 p = tbuf;
1124 for (i = 0; i < nchar; i++) {
1125 chars = strlen(p);
1126 if (cb < chars + 1) {
1127 msyslog(LOG_ERR, "chu_b() fatal out buffer");
1128 exit(1);
1129 }
1130 cb -= chars;
1131 p += chars;
1132 snprintf(p, cb, "%02x", up->cbuf[i]);
1133 }
1134 if (pp->sloppyclockflag & CLK_FLAG4)
1135 record_clock_stats(&peer->srcadr, tbuf);
1136 #ifdef DEBUG
1137 if (debug)
1138 printf("%s\n", tbuf);
1139 #endif
1140 if (up->burdist > -40) {
1141 up->status |= BFRAME;
1142 return;
1143 }
1144
1145 /*
1146 * Convert the burst data to internal format. Don't bother with
1147 * the timestamps.
1148 */
1149 for (i = 0; i < 5; i++) {
1150 code[2 * i] = hexchar[up->cbuf[i] & 0xf];
1151 code[2 * i + 1] = hexchar[(up->cbuf[i] >>
1152 4) & 0xf];
1153 }
1154 if (sscanf((char *)code, "%1x%1d%4d%2d%2x", &up->leap, &up->dut,
1155 &pp->year, &up->tai, &up->dst) != 5) {
1156 up->status |= BFORMAT;
1157 return;
1158 }
1159 up->status |= BVALID;
1160 if (up->leap & 0x8)
1161 up->dut = -up->dut;
1162 }
1163
1164
1165 /*
1166 * chu_a - decode format A burst
1167 */
1168 static void
chu_a(struct peer * peer,int nchar)1169 chu_a(
1170 struct peer *peer,
1171 int nchar
1172 )
1173 {
1174 struct refclockproc *pp;
1175 struct chuunit *up;
1176
1177 char tbuf[80]; /* trace buffer */
1178 char * p;
1179 size_t chars;
1180 size_t cb;
1181 l_fp offset; /* timestamp offset */
1182 int val; /* distance */
1183 int temp;
1184 int i, j, k;
1185
1186 pp = peer->procptr;
1187 up = pp->unitptr;
1188
1189 /*
1190 * Determine correct burst phase. There are three cases
1191 * corresponding to in-phase, one character early or one
1192 * character late. These cases are distinguished by the position
1193 * of the framing digits 0x6 at positions 0 and 5 and 0x3 at
1194 * positions 4 and 9. The correct phase is when the distance
1195 * relative to the framing digits is maximum. The burst is valid
1196 * only if the maximum distance is at least MINSYNC.
1197 */
1198 up->syndist = k = 0;
1199 // val = -16;
1200 for (i = -1; i < 2; i++) {
1201 temp = up->cbuf[i + 4] & 0xf;
1202 if (i >= 0)
1203 temp |= (up->cbuf[i] & 0xf) << 4;
1204 val = chu_dist(temp, 0x63);
1205 temp = (up->cbuf[i + 5] & 0xf) << 4;
1206 if (i + 9 < nchar)
1207 temp |= up->cbuf[i + 9] & 0xf;
1208 val += chu_dist(temp, 0x63);
1209 if (val > up->syndist) {
1210 up->syndist = val;
1211 k = i;
1212 }
1213 }
1214
1215 /*
1216 * Extract the second number; it must be in the range 2 through
1217 * 9 and the two repititions must be the same.
1218 */
1219 temp = (up->cbuf[k + 4] >> 4) & 0xf;
1220 if (temp < 2 || temp > 9 || k + 9 >= nchar || temp !=
1221 ((up->cbuf[k + 9] >> 4) & 0xf))
1222 temp = 0;
1223 snprintf(tbuf, sizeof(tbuf),
1224 "chuA %04x %4.0f %2d %2d %2d %2d %1d ", up->status,
1225 up->maxsignal, nchar, up->burdist, k, up->syndist,
1226 temp);
1227 cb = sizeof(tbuf);
1228 p = tbuf;
1229 for (i = 0; i < nchar; i++) {
1230 chars = strlen(p);
1231 if (cb < chars + 1) {
1232 msyslog(LOG_ERR, "chu_a() fatal out buffer");
1233 exit(1);
1234 }
1235 cb -= chars;
1236 p += chars;
1237 snprintf(p, cb, "%02x", up->cbuf[i]);
1238 }
1239 if (pp->sloppyclockflag & CLK_FLAG4)
1240 record_clock_stats(&peer->srcadr, tbuf);
1241 #ifdef DEBUG
1242 if (debug)
1243 printf("%s\n", tbuf);
1244 #endif
1245 if (up->syndist < MINSYNC) {
1246 up->status |= AFRAME;
1247 return;
1248 }
1249
1250 /*
1251 * A valid burst requires the first seconds number to match the
1252 * last seconds number. If so, the burst timestamps are
1253 * corrected to the current minute and saved for later
1254 * processing. In addition, the seconds decode is advanced from
1255 * the previous burst to the current one.
1256 */
1257 if (temp == 0) {
1258 up->status |= AFORMAT;
1259 } else {
1260 up->status |= AVALID;
1261 up->second = pp->second = 30 + temp;
1262 offset.l_ui = 30 + temp;
1263 offset.l_uf = 0;
1264 i = 0;
1265 if (k < 0)
1266 offset = up->charstamp;
1267 else if (k > 0)
1268 i = 1;
1269 for (; i < nchar && (i - 10) < k; i++) {
1270 up->tstamp[up->ntstamp] = up->cstamp[i];
1271 L_SUB(&up->tstamp[up->ntstamp], &offset);
1272 L_ADD(&offset, &up->charstamp);
1273 if (up->ntstamp < MAXSTAGE - 1)
1274 up->ntstamp++;
1275 }
1276 while (temp > up->prevsec) {
1277 for (j = 15; j > 0; j--) {
1278 up->decode[9][j] = up->decode[9][j - 1];
1279 up->decode[19][j] =
1280 up->decode[19][j - 1];
1281 }
1282 up->decode[9][j] = up->decode[19][j] = 0;
1283 up->prevsec++;
1284 }
1285 }
1286
1287 /*
1288 * Stash the data in the decoding matrix.
1289 */
1290 i = -(2 * k);
1291 for (j = 0; j < nchar; j++) {
1292 if (i < 0 || i > 18) {
1293 i += 2;
1294 continue;
1295 }
1296 up->decode[i][up->cbuf[j] & 0xf]++;
1297 i++;
1298 up->decode[i][(up->cbuf[j] >> 4) & 0xf]++;
1299 i++;
1300 }
1301 up->burstcnt++;
1302 }
1303
1304
1305 /*
1306 * chu_poll - called by the transmit procedure
1307 */
1308 static void
chu_poll(int unit,struct peer * peer)1309 chu_poll(
1310 int unit,
1311 struct peer *peer /* peer structure pointer */
1312 )
1313 {
1314 struct refclockproc *pp;
1315
1316 pp = peer->procptr;
1317 pp->polls++;
1318 }
1319
1320
1321 /*
1322 * chu_second - process minute data
1323 */
1324 static void
chu_second(int unit,struct peer * peer)1325 chu_second(
1326 int unit,
1327 struct peer *peer /* peer structure pointer */
1328 )
1329 {
1330 struct refclockproc *pp;
1331 struct chuunit *up;
1332 l_fp offset;
1333 char synchar, qual, leapchar;
1334 int minset, i;
1335 double dtemp;
1336
1337 pp = peer->procptr;
1338 up = pp->unitptr;
1339
1340 /*
1341 * This routine is called once per minute to process the
1342 * accumulated burst data. We do a bit of fancy footwork so that
1343 * this doesn't run while burst data are being accumulated.
1344 */
1345 up->second = (up->second + 1) % 60;
1346 if (up->second != 0)
1347 return;
1348
1349 /*
1350 * Process the last burst, if still in the burst buffer.
1351 * If the minute contains a valid B frame with sufficient A
1352 * frame metric, it is considered valid. However, the timecode
1353 * is sent to clockstats even if invalid.
1354 */
1355 chu_burst(peer);
1356 minset = ((current_time - peer->update) + 30) / 60;
1357 dtemp = chu_major(peer);
1358 qual = 0;
1359 if (up->status & (BFRAME | AFRAME))
1360 qual |= SYNERR;
1361 if (up->status & (BFORMAT | AFORMAT))
1362 qual |= FMTERR;
1363 if (up->status & DECODE)
1364 qual |= DECERR;
1365 if (up->status & STAMP)
1366 qual |= TSPERR;
1367 if (up->status & BVALID && dtemp >= MINMETRIC)
1368 up->status |= INSYNC;
1369 synchar = leapchar = ' ';
1370 if (!(up->status & INSYNC)) {
1371 pp->leap = LEAP_NOTINSYNC;
1372 synchar = '?';
1373 } else if (up->leap & 0x2) {
1374 pp->leap = LEAP_ADDSECOND;
1375 leapchar = 'L';
1376 } else if (up->leap & 0x4) {
1377 pp->leap = LEAP_DELSECOND;
1378 leapchar = 'l';
1379 } else {
1380 pp->leap = LEAP_NOWARNING;
1381 }
1382 snprintf(pp->a_lastcode, sizeof(pp->a_lastcode),
1383 "%c%1X %04d %03d %02d:%02d:%02d %c%x %+d %d %d %s %.0f %d",
1384 synchar, qual, pp->year, pp->day, pp->hour, pp->minute,
1385 pp->second, leapchar, up->dst, up->dut, minset, up->gain,
1386 up->ident, dtemp, up->ntstamp);
1387 pp->lencode = strlen(pp->a_lastcode);
1388
1389 /*
1390 * If in sync and the signal metric is above threshold, the
1391 * timecode is ipso fatso valid and can be selected to
1392 * discipline the clock.
1393 */
1394 if (up->status & INSYNC && !(up->status & (DECODE | STAMP)) &&
1395 dtemp > MINMETRIC) {
1396 if (!clocktime(pp->day, pp->hour, pp->minute, 0, GMT,
1397 up->tstamp[0].l_ui, &pp->yearstart, &offset.l_ui)) {
1398 up->errflg = CEVNT_BADTIME;
1399 } else {
1400 offset.l_uf = 0;
1401 for (i = 0; i < up->ntstamp; i++)
1402 refclock_process_offset(pp, offset,
1403 up->tstamp[i], PDELAY +
1404 pp->fudgetime1);
1405 pp->lastref = up->timestamp;
1406 refclock_receive(peer);
1407 }
1408 }
1409 if (dtemp > 0)
1410 record_clock_stats(&peer->srcadr, pp->a_lastcode);
1411 #ifdef DEBUG
1412 if (debug)
1413 printf("chu: timecode %d %s\n", pp->lencode,
1414 pp->a_lastcode);
1415 #endif
1416 #ifdef ICOM
1417 chu_newchan(peer, dtemp);
1418 #endif /* ICOM */
1419 chu_clear(peer);
1420 if (up->errflg)
1421 refclock_report(peer, up->errflg);
1422 up->errflg = 0;
1423 }
1424
1425
1426 /*
1427 * chu_major - majority decoder
1428 */
1429 static double
chu_major(struct peer * peer)1430 chu_major(
1431 struct peer *peer /* peer structure pointer */
1432 )
1433 {
1434 struct refclockproc *pp;
1435 struct chuunit *up;
1436
1437 u_char code[11]; /* decoded timecode */
1438 int metric; /* distance metric */
1439 int val1; /* maximum distance */
1440 int synchar; /* stray cat */
1441 int temp;
1442 int i, j, k;
1443
1444 pp = peer->procptr;
1445 up = pp->unitptr;
1446
1447 /*
1448 * Majority decoder. Each burst encodes two replications at each
1449 * digit position in the timecode. Each row of the decoding
1450 * matrix encodes the number of occurences of each digit found
1451 * at the corresponding position. The maximum over all
1452 * occurrences at each position is the distance for this
1453 * position and the corresponding digit is the maximum-
1454 * likelihood candidate. If the distance is not more than half
1455 * the total number of occurences, a majority has not been found
1456 * and the data are discarded. The decoding distance is defined
1457 * as the sum of the distances over the first nine digits. The
1458 * tenth digit varies over the seconds, so we don't count it.
1459 */
1460 metric = 0;
1461 for (i = 0; i < 9; i++) {
1462 val1 = 0;
1463 k = 0;
1464 for (j = 0; j < 16; j++) {
1465 temp = up->decode[i][j] + up->decode[i + 10][j];
1466 if (temp > val1) {
1467 val1 = temp;
1468 k = j;
1469 }
1470 }
1471 if (val1 <= up->burstcnt)
1472 up->status |= DECODE;
1473 metric += val1;
1474 code[i] = hexchar[k];
1475 }
1476
1477 /*
1478 * Compute the timecode timestamp from the days, hours and
1479 * minutes of the timecode. Use clocktime() for the aggregate
1480 * minutes and the minute offset computed from the burst
1481 * seconds. Note that this code relies on the filesystem time
1482 * for the years and does not use the years of the timecode.
1483 */
1484 if (sscanf((char *)code, "%1x%3d%2d%2d", &synchar, &pp->day,
1485 &pp->hour, &pp->minute) != 4)
1486 up->status |= DECODE;
1487 if (up->ntstamp < MINSTAMP)
1488 up->status |= STAMP;
1489 return (metric);
1490 }
1491
1492
1493 /*
1494 * chu_clear - clear decoding matrix
1495 */
1496 static void
chu_clear(struct peer * peer)1497 chu_clear(
1498 struct peer *peer /* peer structure pointer */
1499 )
1500 {
1501 struct refclockproc *pp;
1502 struct chuunit *up;
1503 int i, j;
1504
1505 pp = peer->procptr;
1506 up = pp->unitptr;
1507
1508 /*
1509 * Clear stuff for the minute.
1510 */
1511 up->ndx = up->prevsec = 0;
1512 up->burstcnt = up->ntstamp = 0;
1513 up->status &= INSYNC | METRIC;
1514 for (i = 0; i < 20; i++) {
1515 for (j = 0; j < 16; j++)
1516 up->decode[i][j] = 0;
1517 }
1518 }
1519
1520 #ifdef ICOM
1521 /*
1522 * chu_newchan - called once per minute to find the best channel;
1523 * returns zero on success, nonzero if ICOM error.
1524 */
1525 static int
chu_newchan(struct peer * peer,double met)1526 chu_newchan(
1527 struct peer *peer,
1528 double met
1529 )
1530 {
1531 struct chuunit *up;
1532 struct refclockproc *pp;
1533 struct xmtr *sp;
1534 int rval;
1535 double metric;
1536 int i;
1537
1538 pp = peer->procptr;
1539 up = pp->unitptr;
1540
1541 /*
1542 * The radio can be tuned to three channels: 0 (3330 kHz), 1
1543 * (7850 kHz) and 2 (14670 kHz). There are five one-minute
1544 * dwells in each cycle. During the first dwell the radio is
1545 * tuned to one of the three channels to measure the channel
1546 * metric. The channel is selected as the one least recently
1547 * measured. During the remaining four dwells the radio is tuned
1548 * to the channel with the highest channel metric.
1549 */
1550 if (up->fd_icom <= 0)
1551 return (0);
1552
1553 /*
1554 * Update the current channel metric and age of all channels.
1555 * Scan all channels for the highest metric.
1556 */
1557 sp = &up->xmtr[up->chan];
1558 sp->metric -= sp->integ[sp->iptr];
1559 sp->integ[sp->iptr] = met;
1560 sp->metric += sp->integ[sp->iptr];
1561 sp->probe = 0;
1562 sp->iptr = (sp->iptr + 1) % ISTAGE;
1563 metric = 0;
1564 for (i = 0; i < NCHAN; i++) {
1565 up->xmtr[i].probe++;
1566 if (up->xmtr[i].metric > metric) {
1567 up->status |= METRIC;
1568 metric = up->xmtr[i].metric;
1569 up->chan = i;
1570 }
1571 }
1572
1573 /*
1574 * Start the next dwell. If the first dwell or no stations have
1575 * been heard, continue round-robin scan.
1576 */
1577 up->dwell = (up->dwell + 1) % DWELL;
1578 if (up->dwell == 0 || metric == 0) {
1579 rval = 0;
1580 for (i = 0; i < NCHAN; i++) {
1581 if (up->xmtr[i].probe > rval) {
1582 rval = up->xmtr[i].probe;
1583 up->chan = i;
1584 }
1585 }
1586 }
1587
1588 /* Retune the radio at each dwell in case somebody nudges the
1589 * tuning knob.
1590 */
1591 rval = icom_freq(up->fd_icom, peer->ttl & 0x7f, qsy[up->chan] +
1592 TUNE);
1593 snprintf(up->ident, sizeof(up->ident), "CHU%d", up->chan);
1594 memcpy(&pp->refid, up->ident, 4);
1595 memcpy(&peer->refid, up->ident, 4);
1596 if (metric == 0 && up->status & METRIC) {
1597 up->status &= ~METRIC;
1598 refclock_report(peer, CEVNT_PROP);
1599 }
1600 return (rval);
1601 }
1602 #endif /* ICOM */
1603
1604
1605 /*
1606 * chu_dist - determine the distance of two octet arguments
1607 */
1608 static int
chu_dist(int x,int y)1609 chu_dist(
1610 int x, /* an octet of bits */
1611 int y /* another octet of bits */
1612 )
1613 {
1614 int val; /* bit count */
1615 int temp;
1616 int i;
1617
1618 /*
1619 * The distance is determined as the weight of the exclusive OR
1620 * of the two arguments. The weight is determined by the number
1621 * of one bits in the result. Each one bit increases the weight,
1622 * while each zero bit decreases it.
1623 */
1624 temp = x ^ y;
1625 val = 0;
1626 for (i = 0; i < 8; i++) {
1627 if ((temp & 0x1) == 0)
1628 val++;
1629 else
1630 val--;
1631 temp >>= 1;
1632 }
1633 return (val);
1634 }
1635
1636
1637 #ifdef HAVE_AUDIO
1638 /*
1639 * chu_gain - adjust codec gain
1640 *
1641 * This routine is called at the end of each second. During the second
1642 * the number of signal clips above the MAXAMP threshold (6000). If
1643 * there are no clips, the gain is bumped up; if there are more than
1644 * MAXCLP clips (100), it is bumped down. The decoder is relatively
1645 * insensitive to amplitude, so this crudity works just peachy. The
1646 * routine also jiggles the input port and selectively mutes the
1647 */
1648 static void
chu_gain(struct peer * peer)1649 chu_gain(
1650 struct peer *peer /* peer structure pointer */
1651 )
1652 {
1653 struct refclockproc *pp;
1654 struct chuunit *up;
1655
1656 pp = peer->procptr;
1657 up = pp->unitptr;
1658
1659 /*
1660 * Apparently, the codec uses only the high order bits of the
1661 * gain control field. Thus, it may take awhile for changes to
1662 * wiggle the hardware bits.
1663 */
1664 if (up->clipcnt == 0) {
1665 up->gain += 4;
1666 if (up->gain > MAXGAIN)
1667 up->gain = MAXGAIN;
1668 } else if (up->clipcnt > MAXCLP) {
1669 up->gain -= 4;
1670 if (up->gain < 0)
1671 up->gain = 0;
1672 }
1673 audio_gain(up->gain, up->mongain, up->port);
1674 up->clipcnt = 0;
1675 }
1676 #endif /* HAVE_AUDIO */
1677
1678
1679 #else
1680 NONEMPTY_TRANSLATION_UNIT
1681 #endif /* REFCLOCK */
1682