/* * refclock_chu - clock driver for Canadian CHU time/frequency station */ #ifdef HAVE_CONFIG_H #include <config.h> #endif #if defined(REFCLOCK) && defined(CLOCK_CHU) #include "ntpd.h" #include "ntp_io.h" #include "ntp_refclock.h" #include "ntp_calendar.h" #include "ntp_stdlib.h" #include <stdio.h> #include <ctype.h> #include <math.h> #ifdef HAVE_AUDIO #include "audio.h" #endif /* HAVE_AUDIO */ #define ICOM 1 /* undefine to suppress ICOM code */ #ifdef ICOM #include "icom.h" #endif /* ICOM */ /* * Audio CHU demodulator/decoder * * This driver synchronizes the computer time using data encoded in * radio transmissions from Canadian time/frequency station CHU in * Ottawa, Ontario. Transmissions are made continuously on 3330 kHz, * 7335 kHz and 14670 kHz in upper sideband, compatible AM mode. An * ordinary shortwave receiver can be tuned manually to one of these * frequencies or, in the case of ICOM receivers, the receiver can be * tuned automatically using this program as propagation conditions * change throughout the day and night. * * The driver receives, demodulates and decodes the radio signals when * connected to the audio codec of a suported workstation hardware and * operating system. These include Solaris, SunOS, FreeBSD, NetBSD and * Linux. In this implementation, only one audio driver and codec can be * supported on a single machine. * * The driver can be compiled to use a Bell 103 compatible modem or * modem chip to receive the radio signal and demodulate the data. * Alternatively, the driver can be compiled to use the audio codec of * the Sun workstation or another with compatible audio drivers. In the * latter case, the driver implements the modem using DSP routines, so * the radio can be connected directly to either the microphone on line * input port. In either case, the driver decodes the data using a * maximum likelihood technique which exploits the considerable degree * of redundancy available to maximize accuracy and minimize errors. * * The CHU time broadcast includes an audio signal compatible with the * Bell 103 modem standard (mark = 2225 Hz, space = 2025 Hz). It consist * of nine, ten-character bursts transmitted at 300 bps and beginning * each second from second 31 to second 39 of the minute. Each character * consists of eight data bits plus one start bit and two stop bits to * encode two hex digits. The burst data consist of five characters (ten * hex digits) followed by a repeat of these characters. In format A, * the characters are repeated in the same polarity; in format B, the * characters are repeated in the opposite polarity. * * Format A bursts are sent at seconds 32 through 39 of the minute in * hex digits * * 6dddhhmmss6dddhhmmss * * The first ten digits encode a frame marker (6) followed by the day * (ddd), hour (hh in UTC), minute (mm) and the second (ss). Since * format A bursts are sent during the third decade of seconds the tens * digit of ss is always 3. The driver uses this to determine correct * burst synchronization. These digits are then repeated with the same * polarity. * * Format B bursts are sent at second 31 of the minute in hex digits * * xdyyyyttaaxdyyyyttaa * * The first ten digits encode a code (x described below) followed by * the DUT1 (d in deciseconds), Gregorian year (yyyy), difference TAI - * UTC (tt) and daylight time indicator (aa) peculiar to Canada. These * digits are then repeated with inverted polarity. * * The x is coded * * 1 Sign of DUT (0 = +) * 2 Leap second warning. One second will be added. * 4 Leap second warning. One second will be subtracted. * 8 Even parity bit for this nibble. * * By design, the last stop bit of the last character in the burst * coincides with 0.5 second. Since characters have 11 bits and are * transmitted at 300 bps, the last stop bit of the first character * coincides with 0.5 - 10 * 11/300 = 0.133 second. Depending on the * UART, character interrupts can vary somewhere between the beginning * of bit 9 and end of bit 11. These eccentricities can be corrected * along with the radio propagation delay using fudge time 1. * * Debugging aids * * The timecode format used for debugging and data recording includes * data helpful in diagnosing problems with the radio signal and serial * connections. With debugging enabled (-d on the ntpd command line), * the driver produces one line for each burst in two formats * corresponding to format A and B. Following is format A: * * n b f s m code * * where n is the number of characters in the burst (0-11), b the burst * distance (0-40), f the field alignment (-1, 0, 1), s the * synchronization distance (0-16), m the burst number (2-9) and code * the burst characters as received. Note that the hex digits in each * character are reversed, so the burst * * 10 38 0 16 9 06851292930685129293 * * is interpreted as containing 11 characters with burst distance 38, * field alignment 0, synchronization distance 16 and burst number 9. * The nibble-swapped timecode shows day 58, hour 21, minute 29 and * second 39. * * When the audio driver is compiled, format A is preceded by * the current gain (0-255) and relative signal level (0-9999). The * receiver folume control should be set so that the gain is somewhere * near the middle of the range 0-255, which results in a signal level * near 1000. * * Following is format B: * * n b s code * * where n is the number of characters in the burst (0-11), b the burst * distance (0-40), s the synchronization distance (0-40) and code the * burst characters as received. Note that the hex digits in each * character are reversed and the last ten digits inverted, so the burst * * 11 40 1091891300ef6e76ecff * * is interpreted as containing 11 characters with burst distance 40. * The nibble-swapped timecode shows DUT1 +0.1 second, year 1998 and TAI * - UTC 31 seconds. * * In addition to the above, the reference timecode is updated and * written to the clockstats file and debug score after the last burst * received in the minute. The format is * * qq yyyy ddd hh:mm:ss nn dd tt * * where qq are the error flags, as described below, yyyy is the year, * ddd the day, hh:mm:ss the time of day, nn the number of format A * bursts received during the previous minute, dd the decoding distance * and tt the number of timestamps. The error flags are cleared after * every update. * * Fudge factors * * For accuracies better than the low millisceconds, fudge time1 can be * set to the radio propagation delay from CHU to the receiver. This can * be done conviently using the minimuf program. * * Fudge flag4 causes the dubugging output described above to be * recorded in the clockstats file. When the audio driver is compiled, * fudge flag2 selects the audio input port, where 0 is the mike port * (default) and 1 is the line-in port. It does not seem useful to * select the compact disc player port. Fudge flag3 enables audio * monitoring of the input signal. For this purpose, the monitor gain is * set to a default value. * * The audio codec code is normally compiled in the driver if the * architecture supports it (HAVE_AUDIO defined), but is used only if * the link /dev/chu_audio is defined and valid. The serial port code is * always compiled in the driver, but is used only if the autdio codec * is not available and the link /dev/chu%d is defined and valid. * * The ICOM code is normally compiled in the driver if selected (ICOM * defined), but is used only if the link /dev/icom%d is defined and * valid and the mode keyword on the server configuration command * specifies a nonzero mode (ICOM ID select code). The C-IV speed is * 9600 bps if the high order 0x80 bit of the mode is zero and 1200 bps * if one. The C-IV trace is turned on if the debug level is greater * than one. */ /* * Interface definitions */ #define SPEED232 B300 /* uart speed (300 baud) */ #define PRECISION (-10) /* precision assumed (about 1 ms) */ #define REFID "CHU" /* reference ID */ #define DEVICE "/dev/chu%d" /* device name and unit */ #define SPEED232 B300 /* UART speed (300 baud) */ #ifdef ICOM #define TUNE .001 /* offset for narrow filter (kHz) */ #define DWELL 5 /* minutes in a probe cycle */ #define NCHAN 3 /* number of channels */ #define ISTAGE 3 /* number of integrator stages */ #endif /* ICOM */ #ifdef HAVE_AUDIO /* * Audio demodulator definitions */ #define SECOND 8000 /* nominal sample rate (Hz) */ #define BAUD 300 /* modulation rate (bps) */ #define OFFSET 128 /* companded sample offset */ #define SIZE 256 /* decompanding table size */ #define MAXSIG 6000. /* maximum signal level */ #define MAXCLP 100 /* max clips above reference per s */ #define LIMIT 1000. /* soft limiter threshold */ #define AGAIN 6. /* baseband gain */ #define LAG 10 /* discriminator lag */ #define DEVICE_AUDIO "/dev/chu_audio" /* device name */ #define DESCRIPTION "CHU Audio/Modem Receiver" /* WRU */ #define AUDIO_BUFSIZ 240 /* audio buffer size (30 ms) */ #else #define DESCRIPTION "CHU Modem Receiver" /* WRU */ #endif /* HAVE_AUDIO */ /* * Decoder definitions */ #define CHAR (11. / 300.) /* character time (s) */ #define FUDGE .185 /* offset to first stop bit (s) */ #define BURST 11 /* max characters per burst */ #define MINCHAR 9 /* min characters per burst */ #define MINDIST 28 /* min burst distance (of 40) */ #define MINBURST 4 /* min bursts in minute */ #define MINSYNC 8 /* min sync distance (of 16) */ #define MINSTAMP 20 /* min timestamps (of 60) */ #define METRIC 50. /* min channel metric */ #define PANIC 1440 /* panic timeout (m) */ #define HOLD 30 /* reach hold (m) */ /* * Hex extension codes (>= 16) */ #define HEX_MISS 16 /* miss _ */ #define HEX_SOFT 17 /* soft error * */ #define HEX_HARD 18 /* hard error = */ /* * Status bits (status) */ #define RUNT 0x0001 /* runt burst */ #define NOISE 0x0002 /* noise burst */ #define BFRAME 0x0004 /* invalid format B frame sync */ #define BFORMAT 0x0008 /* invalid format B data */ #define AFRAME 0x0010 /* invalid format A frame sync */ #define AFORMAT 0x0020 /* invalid format A data */ #define DECODE 0x0040 /* invalid data decode */ #define STAMP 0x0080 /* too few timestamps */ #define AVALID 0x0100 /* valid A frame */ #define BVALID 0x0200 /* valid B frame */ #define INSYNC 0x0400 /* clock synchronized */ /* * Alarm status bits (alarm) * * These alarms are set at the end of a minute in which at least one * burst was received. SYNERR is raised if the AFRAME or BFRAME status * bits are set during the minute, FMTERR is raised if the AFORMAT or * BFORMAT status bits are set, DECERR is raised if the DECODE status * bit is set and TSPERR is raised if the STAMP status bit is set. */ #define SYNERR 0x01 /* frame sync error */ #define FMTERR 0x02 /* data format error */ #define DECERR 0x04 /* data decoding error */ #define TSPERR 0x08 /* insufficient data */ #ifdef HAVE_AUDIO /* * Maximum likelihood UART structure. There are eight of these * corresponding to the number of phases. */ struct surv { double shift[12]; /* mark register */ double es_max, es_min; /* max/min envelope signals */ double dist; /* sample distance */ int uart; /* decoded character */ }; #endif /* HAVE_AUDIO */ #ifdef ICOM /* * CHU station structure. There are three of these corresponding to the * three frequencies. */ struct xmtr { double integ[ISTAGE]; /* circular integrator */ double metric; /* integrator sum */ int iptr; /* integrator pointer */ int probe; /* dwells since last probe */ }; #endif /* ICOM */ /* * CHU unit control structure */ struct chuunit { u_char decode[20][16]; /* maximum likelihood decoding matrix */ l_fp cstamp[BURST]; /* character timestamps */ l_fp tstamp[MAXSTAGE]; /* timestamp samples */ l_fp timestamp; /* current buffer timestamp */ l_fp laststamp; /* last buffer timestamp */ l_fp charstamp; /* character time as a l_fp */ int errflg; /* error flags */ int status; /* status bits */ char ident[5]; /* station ID and channel */ #ifdef ICOM int fd_icom; /* ICOM file descriptor */ int chan; /* data channel */ int achan; /* active channel */ int dwell; /* dwell cycle */ struct xmtr xmtr[NCHAN]; /* station metric */ #endif /* ICOM */ /* * Character burst variables */ int cbuf[BURST]; /* character buffer */ int ntstamp; /* number of timestamp samples */ int ndx; /* buffer start index */ int prevsec; /* previous burst second */ int burdist; /* burst distance */ int syndist; /* sync distance */ int burstcnt; /* format A bursts this minute */ /* * Format particulars */ int leap; /* leap/dut code */ int dut; /* UTC1 correction */ int tai; /* TAI - UTC correction */ int dst; /* Canadian DST code */ #ifdef HAVE_AUDIO /* * Audio codec variables */ int fd_audio; /* audio port file descriptor */ double comp[SIZE]; /* decompanding table */ int port; /* codec port */ int gain; /* codec gain */ int mongain; /* codec monitor gain */ int clipcnt; /* sample clip count */ int seccnt; /* second interval counter */ /* * Modem variables */ l_fp tick; /* audio sample increment */ double bpf[9]; /* IIR bandpass filter */ double disc[LAG]; /* discriminator shift register */ double lpf[27]; /* FIR lowpass filter */ double monitor; /* audio monitor */ double maxsignal; /* signal level */ int discptr; /* discriminator pointer */ /* * Maximum likelihood UART variables */ double baud; /* baud interval */ struct surv surv[8]; /* UART survivor structures */ int decptr; /* decode pointer */ int dbrk; /* holdoff counter */ #endif /* HAVE_AUDIO */ }; /* * Function prototypes */ static int chu_start P((int, struct peer *)); static void chu_shutdown P((int, struct peer *)); static void chu_receive P((struct recvbuf *)); static void chu_poll P((int, struct peer *)); /* * More function prototypes */ static void chu_decode P((struct peer *, int)); static void chu_burst P((struct peer *)); static void chu_clear P((struct peer *)); static void chu_a P((struct peer *, int)); static void chu_b P((struct peer *, int)); static int chu_dist P((int, int)); static double chu_major P((struct peer *)); #ifdef HAVE_AUDIO static void chu_uart P((struct surv *, double)); static void chu_rf P((struct peer *, double)); static void chu_gain P((struct peer *)); static void chu_audio_receive P((struct recvbuf *rbufp)); #endif /* HAVE_AUDIO */ #ifdef ICOM static int chu_newchan P((struct peer *, double)); #endif /* ICOM */ static void chu_serial_receive P((struct recvbuf *rbufp)); /* * Global variables */ static char hexchar[] = "0123456789abcdef_*="; #ifdef ICOM /* * Note the tuned frequencies are 1 kHz higher than the carrier. CHU * transmits on USB with carrier so we can use AM and the narrow SSB * filter. */ static double qsy[NCHAN] = {3.330, 7.335, 14.670}; /* freq (MHz) */ #endif /* ICOM */ /* * Transfer vector */ struct refclock refclock_chu = { chu_start, /* start up driver */ chu_shutdown, /* shut down driver */ chu_poll, /* transmit poll message */ noentry, /* not used (old chu_control) */ noentry, /* initialize driver (not used) */ noentry, /* not used (old chu_buginfo) */ NOFLAGS /* not used */ }; /* * chu_start - open the devices and initialize data for processing */ static int chu_start( int unit, /* instance number (not used) */ struct peer *peer /* peer structure pointer */ ) { struct chuunit *up; struct refclockproc *pp; char device[20]; /* device name */ int fd; /* file descriptor */ #ifdef ICOM int temp; #endif /* ICOM */ #ifdef HAVE_AUDIO int fd_audio; /* audio port file descriptor */ int i; /* index */ double step; /* codec adjustment */ /* * Open audio device. */ fd_audio = audio_init(DEVICE_AUDIO, AUDIO_BUFSIZ, unit); #ifdef DEBUG if (fd_audio > 0 && debug) audio_show(); #endif /* * Open serial port in raw mode. */ if (fd_audio > 0) { fd = fd_audio; } else { sprintf(device, DEVICE, unit); fd = refclock_open(device, SPEED232, LDISC_RAW); } #else /* HAVE_AUDIO */ /* * Open serial port in raw mode. */ sprintf(device, DEVICE, unit); fd = refclock_open(device, SPEED232, LDISC_RAW); #endif /* HAVE_AUDIO */ if (fd <= 0) return (0); /* * Allocate and initialize unit structure */ if (!(up = (struct chuunit *) emalloc(sizeof(struct chuunit)))) { close(fd); return (0); } memset((char *)up, 0, sizeof(struct chuunit)); pp = peer->procptr; pp->unitptr = (caddr_t)up; pp->io.clock_recv = chu_receive; pp->io.srcclock = (caddr_t)peer; pp->io.datalen = 0; pp->io.fd = fd; if (!io_addclock(&pp->io)) { close(fd); free(up); return (0); } /* * Initialize miscellaneous variables */ peer->precision = PRECISION; pp->clockdesc = DESCRIPTION; strcpy(up->ident, "CHU"); memcpy(&peer->refid, up->ident, 4); DTOLFP(CHAR, &up->charstamp); #ifdef HAVE_AUDIO /* * The companded samples are encoded sign-magnitude. The table * contains all the 256 values in the interest of speed. We do * this even if the audio codec is not available. C'est la lazy. */ up->fd_audio = fd_audio; up->gain = 127; up->comp[0] = up->comp[OFFSET] = 0.; up->comp[1] = 1; up->comp[OFFSET + 1] = -1.; up->comp[2] = 3; up->comp[OFFSET + 2] = -3.; step = 2.; for (i = 3; i < OFFSET; i++) { up->comp[i] = up->comp[i - 1] + step; up->comp[OFFSET + i] = -up->comp[i]; if (i % 16 == 0) step *= 2.; } DTOLFP(1. / SECOND, &up->tick); #endif /* HAVE_AUDIO */ #ifdef ICOM temp = 0; #ifdef DEBUG if (debug > 1) temp = P_TRACE; #endif if (peer->ttl > 0) { if (peer->ttl & 0x80) up->fd_icom = icom_init("/dev/icom", B1200, temp); else up->fd_icom = icom_init("/dev/icom", B9600, temp); } if (up->fd_icom > 0) { if (chu_newchan(peer, 0) != 0) { NLOG(NLOG_SYNCEVENT | NLOG_SYSEVENT) msyslog(LOG_NOTICE, "icom: radio not found"); up->errflg = CEVNT_FAULT; close(up->fd_icom); up->fd_icom = 0; } else { NLOG(NLOG_SYNCEVENT | NLOG_SYSEVENT) msyslog(LOG_NOTICE, "icom: autotune enabled"); } } #endif /* ICOM */ return (1); } /* * chu_shutdown - shut down the clock */ static void chu_shutdown( int unit, /* instance number (not used) */ struct peer *peer /* peer structure pointer */ ) { struct chuunit *up; struct refclockproc *pp; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; if (up == NULL) return; io_closeclock(&pp->io); #ifdef ICOM if (up->fd_icom > 0) close(up->fd_icom); #endif /* ICOM */ free(up); } /* * chu_receive - receive data from the audio or serial device */ static void chu_receive( struct recvbuf *rbufp /* receive buffer structure pointer */ ) { #ifdef HAVE_AUDIO struct chuunit *up; struct refclockproc *pp; struct peer *peer; peer = (struct peer *)rbufp->recv_srcclock; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * If the audio codec is warmed up, the buffer contains codec * samples which need to be demodulated and decoded into CHU * characters using the software UART. Otherwise, the buffer * contains CHU characters from the serial port, so the software * UART is bypassed. In this case the CPU will probably run a * few degrees cooler. */ if (up->fd_audio > 0) chu_audio_receive(rbufp); else chu_serial_receive(rbufp); #else chu_serial_receive(rbufp); #endif /* HAVE_AUDIO */ } #ifdef HAVE_AUDIO /* * chu_audio_receive - receive data from the audio device */ static void chu_audio_receive( struct recvbuf *rbufp /* receive buffer structure pointer */ ) { struct chuunit *up; struct refclockproc *pp; struct peer *peer; double sample; /* codec sample */ u_char *dpt; /* buffer pointer */ int bufcnt; /* buffer counter */ l_fp ltemp; /* l_fp temp */ peer = (struct peer *)rbufp->recv_srcclock; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * Main loop - read until there ain't no more. Note codec * samples are bit-inverted. */ DTOLFP((double)rbufp->recv_length / SECOND, <emp); L_SUB(&rbufp->recv_time, <emp); up->timestamp = rbufp->recv_time; dpt = rbufp->recv_buffer; for (bufcnt = 0; bufcnt < rbufp->recv_length; bufcnt++) { sample = up->comp[~*dpt++ & 0xff]; /* * Clip noise spikes greater than MAXSIG. If no clips, * increase the gain a tad; if the clips are too high, * decrease a tad. */ if (sample > MAXSIG) { sample = MAXSIG; up->clipcnt++; } else if (sample < -MAXSIG) { sample = -MAXSIG; up->clipcnt++; } chu_rf(peer, sample); L_ADD(&up->timestamp, &up->tick); /* * Once each second ride gain. */ up->seccnt = (up->seccnt + 1) % SECOND; if (up->seccnt == 0) { pp->second = (pp->second + 1) % 60; chu_gain(peer); } } /* * Set the input port and monitor gain for the next buffer. */ if (pp->sloppyclockflag & CLK_FLAG2) up->port = 2; else up->port = 1; if (pp->sloppyclockflag & CLK_FLAG3) up->mongain = MONGAIN; else up->mongain = 0; } /* * chu_rf - filter and demodulate the FSK signal * * This routine implements a 300-baud Bell 103 modem with mark 2225 Hz * and space 2025 Hz. It uses a bandpass filter followed by a soft * limiter, FM discriminator and lowpass filter. A maximum likelihood * decoder samples the baseband signal at eight times the baud rate and * detects the start bit of each character. * * The filters are built for speed, which explains the rather clumsy * code. Hopefully, the compiler will efficiently implement the move- * and-muiltiply-and-add operations. */ static void chu_rf( struct peer *peer, /* peer structure pointer */ double sample /* analog sample */ ) { struct refclockproc *pp; struct chuunit *up; struct surv *sp; /* * Local variables */ double signal; /* bandpass signal */ double limit; /* limiter signal */ double disc; /* discriminator signal */ double lpf; /* lowpass signal */ double span; /* UART signal span */ double dist; /* UART signal distance */ int i, j; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * Bandpass filter. 4th-order elliptic, 500-Hz bandpass centered * at 2125 Hz. Passband ripple 0.3 dB, stopband ripple 50 dB. */ signal = (up->bpf[8] = up->bpf[7]) * 5.844676e-01; signal += (up->bpf[7] = up->bpf[6]) * 4.884860e-01; signal += (up->bpf[6] = up->bpf[5]) * 2.704384e+00; signal += (up->bpf[5] = up->bpf[4]) * 1.645032e+00; signal += (up->bpf[4] = up->bpf[3]) * 4.644557e+00; signal += (up->bpf[3] = up->bpf[2]) * 1.879165e+00; signal += (up->bpf[2] = up->bpf[1]) * 3.522634e+00; signal += (up->bpf[1] = up->bpf[0]) * 7.315738e-01; up->bpf[0] = sample - signal; signal = up->bpf[0] * 6.176213e-03 + up->bpf[1] * 3.156599e-03 + up->bpf[2] * 7.567487e-03 + up->bpf[3] * 4.344580e-03 + up->bpf[4] * 1.190128e-02 + up->bpf[5] * 4.344580e-03 + up->bpf[6] * 7.567487e-03 + up->bpf[7] * 3.156599e-03 + up->bpf[8] * 6.176213e-03; up->monitor = signal / 4.; /* note monitor after filter */ /* * Soft limiter/discriminator. The 11-sample discriminator lag * interval corresponds to three cycles of 2125 Hz, which * requires the sample frequency to be 2125 * 11 / 3 = 7791.7 * Hz. The discriminator output varies +-0.5 interval for input * frequency 2025-2225 Hz. However, we don't get to sample at * this frequency, so the discriminator output is biased. Life * at 8000 Hz sucks. */ limit = signal; if (limit > LIMIT) limit = LIMIT; else if (limit < -LIMIT) limit = -LIMIT; disc = up->disc[up->discptr] * -limit; up->disc[up->discptr] = limit; up->discptr = (up->discptr + 1 ) % LAG; if (disc >= 0) disc = SQRT(disc); else disc = -SQRT(-disc); /* * Lowpass filter. Raised cosine, Ts = 1 / 300, beta = 0.1. */ lpf = (up->lpf[26] = up->lpf[25]) * 2.538771e-02; lpf += (up->lpf[25] = up->lpf[24]) * 1.084671e-01; lpf += (up->lpf[24] = up->lpf[23]) * 2.003159e-01; lpf += (up->lpf[23] = up->lpf[22]) * 2.985303e-01; lpf += (up->lpf[22] = up->lpf[21]) * 4.003697e-01; lpf += (up->lpf[21] = up->lpf[20]) * 5.028552e-01; lpf += (up->lpf[20] = up->lpf[19]) * 6.028795e-01; lpf += (up->lpf[19] = up->lpf[18]) * 6.973249e-01; lpf += (up->lpf[18] = up->lpf[17]) * 7.831828e-01; lpf += (up->lpf[17] = up->lpf[16]) * 8.576717e-01; lpf += (up->lpf[16] = up->lpf[15]) * 9.183463e-01; lpf += (up->lpf[15] = up->lpf[14]) * 9.631951e-01; lpf += (up->lpf[14] = up->lpf[13]) * 9.907208e-01; lpf += (up->lpf[13] = up->lpf[12]) * 1.000000e+00; lpf += (up->lpf[12] = up->lpf[11]) * 9.907208e-01; lpf += (up->lpf[11] = up->lpf[10]) * 9.631951e-01; lpf += (up->lpf[10] = up->lpf[9]) * 9.183463e-01; lpf += (up->lpf[9] = up->lpf[8]) * 8.576717e-01; lpf += (up->lpf[8] = up->lpf[7]) * 7.831828e-01; lpf += (up->lpf[7] = up->lpf[6]) * 6.973249e-01; lpf += (up->lpf[6] = up->lpf[5]) * 6.028795e-01; lpf += (up->lpf[5] = up->lpf[4]) * 5.028552e-01; lpf += (up->lpf[4] = up->lpf[3]) * 4.003697e-01; lpf += (up->lpf[3] = up->lpf[2]) * 2.985303e-01; lpf += (up->lpf[2] = up->lpf[1]) * 2.003159e-01; lpf += (up->lpf[1] = up->lpf[0]) * 1.084671e-01; lpf += up->lpf[0] = disc * 2.538771e-02; /* * Maximum likelihood decoder. The UART updates each of the * eight survivors and determines the span, slice level and * tentative decoded character. Valid 11-bit characters are * framed so that bit 1 and bit 11 (stop bits) are mark and bit * 2 (start bit) is space. When a valid character is found, the * survivor with maximum distance determines the final decoded * character. */ up->baud += 1. / SECOND; if (up->baud > 1. / (BAUD * 8.)) { up->baud -= 1. / (BAUD * 8.); sp = &up->surv[up->decptr]; span = sp->es_max - sp->es_min; up->maxsignal += (span - up->maxsignal) / 80.; if (up->dbrk > 0) { up->dbrk--; } else if ((sp->uart & 0x403) == 0x401 && span > 1000.) { dist = 0; j = 0; for (i = 0; i < 8; i++) { if (up->surv[i].dist > dist) { dist = up->surv[i].dist; j = i; } } chu_decode(peer, (up->surv[j].uart >> 2) & 0xff); up->dbrk = 80; } up->decptr = (up->decptr + 1) % 8; chu_uart(sp, -lpf * AGAIN); } } /* * chu_uart - maximum likelihood UART * * This routine updates a shift register holding the last 11 envelope * samples. It then computes the slice level and span over these samples * and determines the tentative data bits and distance. The calling * program selects over the last eight survivors the one with maximum * distance to determine the decoded character. */ static void chu_uart( struct surv *sp, /* survivor structure pointer */ double sample /* baseband signal */ ) { double es_max, es_min; /* max/min envelope */ double slice; /* slice level */ double dist; /* distance */ double dtemp; int i; /* * Save the sample and shift right. At the same time, measure * the maximum and minimum over all eleven samples. */ es_max = -1e6; es_min = 1e6; sp->shift[0] = sample; for (i = 11; i > 0; i--) { sp->shift[i] = sp->shift[i - 1]; if (sp->shift[i] > es_max) es_max = sp->shift[i]; if (sp->shift[i] < es_min) es_min = sp->shift[i]; } /* * Determine the slice level midway beteen the maximum and * minimum and the span as the maximum less the minimum. Compute * the distance on the assumption the first and last bits must * be mark, the second space and the rest either mark or space. */ slice = (es_max + es_min) / 2.; dist = 0; sp->uart = 0; for (i = 1; i < 12; i++) { sp->uart <<= 1; dtemp = sp->shift[i]; if (dtemp > slice) sp->uart |= 0x1; if (i == 1 || i == 11) { dist += dtemp - es_min; } else if (i == 10) { dist += es_max - dtemp; } else { if (dtemp > slice) dist += dtemp - es_min; else dist += es_max - dtemp; } } sp->es_max = es_max; sp->es_min = es_min; sp->dist = dist / (11 * (es_max - es_min)); } #endif /* HAVE_AUDIO */ /* * chu_serial_receive - receive data from the serial device */ static void chu_serial_receive( struct recvbuf *rbufp /* receive buffer structure pointer */ ) { struct chuunit *up; struct refclockproc *pp; struct peer *peer; u_char *dpt; /* receive buffer pointer */ peer = (struct peer *)rbufp->recv_srcclock; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * Initialize pointers and read the timecode and timestamp. */ up->timestamp = rbufp->recv_time; dpt = (u_char *)&rbufp->recv_space; chu_decode(peer, *dpt); } /* * chu_decode - decode the character data */ static void chu_decode( struct peer *peer, /* peer structure pointer */ int hexhex /* data character */ ) { struct refclockproc *pp; struct chuunit *up; l_fp tstmp; /* timestamp temp */ double dtemp; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * If the interval since the last character is greater than the * longest burst, process the last burst and start a new one. If * the interval is less than this but greater than two * characters, consider this a noise burst and reject it. */ tstmp = up->timestamp; if (L_ISZERO(&up->laststamp)) up->laststamp = up->timestamp; L_SUB(&tstmp, &up->laststamp); up->laststamp = up->timestamp; LFPTOD(&tstmp, dtemp); if (dtemp > BURST * CHAR) { chu_burst(peer); up->ndx = 0; } else if (dtemp > 2.5 * CHAR) { up->ndx = 0; } /* * Append the character to the current burst and append the * timestamp to the timestamp list. */ if (up->ndx < BURST) { up->cbuf[up->ndx] = hexhex & 0xff; up->cstamp[up->ndx] = up->timestamp; up->ndx++; } } /* * chu_burst - search for valid burst format */ static void chu_burst( struct peer *peer ) { struct chuunit *up; struct refclockproc *pp; int i; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * Correlate a block of five characters with the next block of * five characters. The burst distance is defined as the number * of bits that match in the two blocks for format A and that * match the inverse for format B. */ if (up->ndx < MINCHAR) { up->status |= RUNT; return; } up->burdist = 0; for (i = 0; i < 5 && i < up->ndx - 5; i++) up->burdist += chu_dist(up->cbuf[i], up->cbuf[i + 5]); /* * If the burst distance is at least MINDIST, this must be a * format A burst; if the value is not greater than -MINDIST, it * must be a format B burst. If the B burst is perfect, we * believe it; otherwise, it is a noise burst and of no use to * anybody. */ if (up->burdist >= MINDIST) { chu_a(peer, up->ndx); } else if (up->burdist <= -MINDIST) { chu_b(peer, up->ndx); } else { up->status |= NOISE; return; } /* * If this is a valid burst, wait a guard time of ten seconds to * allow for more bursts, then arm the poll update routine to * process the minute. Don't do this if this is called from the * timer interrupt routine. */ if (peer->outdate != current_time) peer->nextdate = current_time + 10; } /* * chu_b - decode format B burst */ static void chu_b( struct peer *peer, int nchar ) { struct refclockproc *pp; struct chuunit *up; u_char code[11]; /* decoded timecode */ char tbuf[80]; /* trace buffer */ l_fp offset; /* timestamp offset */ int i; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * In a format B burst, a character is considered valid only if * the first occurrence matches the last occurrence. The burst * is considered valid only if all characters are valid; that * is, only if the distance is 40. Note that once a valid frame * has been found errors are ignored. */ sprintf(tbuf, "chuB %04x %2d %2d ", up->status, nchar, -up->burdist); for (i = 0; i < nchar; i++) sprintf(&tbuf[strlen(tbuf)], "%02x", up->cbuf[i]); if (pp->sloppyclockflag & CLK_FLAG4) record_clock_stats(&peer->srcadr, tbuf); #ifdef DEBUG if (debug) printf("%s\n", tbuf); #endif if (up->burdist > -40) { up->status |= BFRAME; return; } up->status |= BVALID; /* * Convert the burst data to internal format. If this succeeds, * save the timestamps for later. */ for (i = 0; i < 5; i++) { code[2 * i] = hexchar[up->cbuf[i] & 0xf]; code[2 * i + 1] = hexchar[(up->cbuf[i] >> 4) & 0xf]; } if (sscanf((char *)code, "%1x%1d%4d%2d%2x", &up->leap, &up->dut, &pp->year, &up->tai, &up->dst) != 5) { up->status |= BFORMAT; return; } if (up->leap & 0x8) up->dut = -up->dut; offset.l_ui = 31; offset.l_f = 0; for (i = 0; i < nchar && i < 10; i++) { up->tstamp[up->ntstamp] = up->cstamp[i]; L_SUB(&up->tstamp[up->ntstamp], &offset); L_ADD(&offset, &up->charstamp); if (up->ntstamp < MAXSTAGE) up->ntstamp++; } } /* * chu_a - decode format A burst */ static void chu_a( struct peer *peer, int nchar ) { struct refclockproc *pp; struct chuunit *up; char tbuf[80]; /* trace buffer */ l_fp offset; /* timestamp offset */ int val; /* distance */ int temp; int i, j, k; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * Determine correct burst phase. There are three cases * corresponding to in-phase, one character early or one * character late. These cases are distinguished by the position * of the framing digits x6 at positions 0 and 5 and x3 at * positions 4 and 9. The correct phase is when the distance * relative to the framing digits is maximum. The burst is valid * only if the maximum distance is at least MINSYNC. */ up->syndist = k = 0; val = -16; for (i = -1; i < 2; i++) { temp = up->cbuf[i + 4] & 0xf; if (i >= 0) temp |= (up->cbuf[i] & 0xf) << 4; val = chu_dist(temp, 0x63); temp = (up->cbuf[i + 5] & 0xf) << 4; if (i + 9 < nchar) temp |= up->cbuf[i + 9] & 0xf; val += chu_dist(temp, 0x63); if (val > up->syndist) { up->syndist = val; k = i; } } temp = (up->cbuf[k + 4] >> 4) & 0xf; if (temp > 9 || k + 9 >= nchar || temp != ((up->cbuf[k + 9] >> 4) & 0xf)) temp = 0; #ifdef HAVE_AUDIO if (up->fd_audio) sprintf(tbuf, "chuA %04x %4.0f %2d %2d %2d %2d %1d ", up->status, up->maxsignal, nchar, up->burdist, k, up->syndist, temp); else sprintf(tbuf, "chuA %04x %2d %2d %2d %2d %1d ", up->status, nchar, up->burdist, k, up->syndist, temp); #else sprintf(tbuf, "chuA %04x %2d %2d %2d %2d %1d ", up->status, nchar, up->burdist, k, up->syndist, temp); #endif /* HAVE_AUDIO */ for (i = 0; i < nchar; i++) sprintf(&tbuf[strlen(tbuf)], "%02x", up->cbuf[i]); if (pp->sloppyclockflag & CLK_FLAG4) record_clock_stats(&peer->srcadr, tbuf); #ifdef DEBUG if (debug) printf("%s\n", tbuf); #endif if (up->syndist < MINSYNC) { up->status |= AFRAME; return; } /* * A valid burst requires the first seconds number to match the * last seconds number. If so, the burst timestamps are * corrected to the current minute and saved for later * processing. In addition, the seconds decode is advanced from * the previous burst to the current one. */ if (temp != 0) { pp->second = 30 + temp; offset.l_ui = 30 + temp; offset.l_f = 0; i = 0; if (k < 0) offset = up->charstamp; else if (k > 0) i = 1; for (; i < nchar && i < k + 10; i++) { up->tstamp[up->ntstamp] = up->cstamp[i]; L_SUB(&up->tstamp[up->ntstamp], &offset); L_ADD(&offset, &up->charstamp); if (up->ntstamp < MAXSTAGE) up->ntstamp++; } while (temp > up->prevsec) { for (j = 15; j > 0; j--) { up->decode[9][j] = up->decode[9][j - 1]; up->decode[19][j] = up->decode[19][j - 1]; } up->decode[9][j] = up->decode[19][j] = 0; up->prevsec++; } } i = -(2 * k); for (j = 0; j < nchar; j++) { if (i < 0 || i > 19) { i += 2; continue; } up->decode[i][up->cbuf[j] & 0xf]++; i++; up->decode[i][(up->cbuf[j] >> 4) & 0xf]++; i++; } up->status |= AVALID; up->burstcnt++; } /* * chu_poll - called by the transmit procedure */ static void chu_poll( int unit, struct peer *peer /* peer structure pointer */ ) { struct refclockproc *pp; struct chuunit *up; l_fp offset; char synchar, qual, leapchar; int minset, i; double dtemp; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; if (pp->coderecv == pp->codeproc) up->errflg = CEVNT_TIMEOUT; else pp->polls++; /* * If once in sync and the radio has not been heard for awhile * (30 m), it is no longer reachable. If not heard in a long * while (one day), turn out the lights and start from scratch. */ minset = ((current_time - peer->update) + 30) / 60; if (up->status & INSYNC) { if (minset > PANIC) up->status = 0; else if (minset <= HOLD) peer->reach |= 1; } /* * Process the last burst, if still in the burst buffer. * Don't mess with anything if nothing has been heard. If the * minute contains a valid A frame and valid B frame, assume * synchronized; however, believe the time only if within metric * threshold. Note the quality indicator is only for * diagnostics; the data are used only if in sync and above * metric threshold. */ chu_burst(peer); if (up->burstcnt == 0) { #ifdef ICOM chu_newchan(peer, 0); #endif /* ICOM */ return; } dtemp = chu_major(peer); qual = 0; if (up->status & (BFRAME | AFRAME)) qual |= SYNERR; if (up->status & (BFORMAT | AFORMAT)) qual |= FMTERR; if (up->status & DECODE) qual |= DECERR; if (up->status & STAMP) qual |= TSPERR; if (up->status & AVALID && up->status & BVALID) up->status |= INSYNC; synchar = leapchar = ' '; if (!(up->status & INSYNC)) { pp->leap = LEAP_NOTINSYNC; synchar = '?'; } else if (up->leap & 0x2) { pp->leap = LEAP_ADDSECOND; leapchar = 'L'; } else if (up->leap & 0x4) { pp->leap = LEAP_DELSECOND; leapchar = 'l'; } else { pp->leap = LEAP_NOWARNING; } #ifdef HAVE_AUDIO if (up->fd_audio) sprintf(pp->a_lastcode, "%c%1X %04d %3d %02d:%02d:%02d %c%x %+d %d %d %s %.0f %d", synchar, qual, pp->year, pp->day, pp->hour, pp->minute, pp->second, leapchar, up->dst, up->dut, minset, up->gain, up->ident, dtemp, up->ntstamp); else sprintf(pp->a_lastcode, "%c%1X %04d %3d %02d:%02d:%02d %c%x %+d %d %s %.0f %d", synchar, qual, pp->year, pp->day, pp->hour, pp->minute, pp->second, leapchar, up->dst, up->dut, minset, up->ident, dtemp, up->ntstamp); #else sprintf(pp->a_lastcode, "%c%1X %04d %3d %02d:%02d:%02d %c%x %+d %d %s %.0f %d", synchar, qual, pp->year, pp->day, pp->hour, pp->minute, pp->second, leapchar, up->dst, up->dut, minset, up->ident, dtemp, up->ntstamp); #endif /* HAVE_AUDIO */ pp->lencode = strlen(pp->a_lastcode); /* * If in sync and the signal metric is above threshold, the * timecode is ipso fatso valid and can be selected to * discipline the clock. Be sure not to leave stray timestamps * around if signals are too weak or the clock time is invalid. */ if (up->status & INSYNC && dtemp > METRIC) { if (!clocktime(pp->day, pp->hour, pp->minute, 0, GMT, up->tstamp[0].l_ui, &pp->yearstart, &offset.l_ui)) { up->errflg = CEVNT_BADTIME; } else { offset.l_uf = 0; for (i = 0; i < up->ntstamp; i++) refclock_process_offset(pp, offset, up->tstamp[i], FUDGE + pp->fudgetime1); pp->lastref = up->timestamp; refclock_receive(peer); } record_clock_stats(&peer->srcadr, pp->a_lastcode); } else if (pp->sloppyclockflag & CLK_FLAG4) { record_clock_stats(&peer->srcadr, pp->a_lastcode); } #ifdef DEBUG if (debug) printf("chu: timecode %d %s\n", pp->lencode, pp->a_lastcode); #endif #ifdef ICOM chu_newchan(peer, dtemp); #endif /* ICOM */ chu_clear(peer); if (up->errflg) refclock_report(peer, up->errflg); up->errflg = 0; } /* * chu_major - majority decoder */ static double chu_major( struct peer *peer /* peer structure pointer */ ) { struct refclockproc *pp; struct chuunit *up; u_char code[11]; /* decoded timecode */ int mindist; /* minimum distance */ int val1, val2; /* maximum distance */ int synchar; /* stray cat */ int temp; int i, j, k; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * Majority decoder. Each burst encodes two replications at each * digit position in the timecode. Each row of the decoding * matrix encodes the number of occurrences of each digit found * at the corresponding position. The maximum over all * occurrences at each position is the distance for this * position and the corresponding digit is the maximum * likelihood candidate. If the distance is zero, assume a miss * '_'; if the distance is not more than half the total number * of occurrences, assume a soft error '*'; if two different * digits with the same distance are found, assume a hard error * '='. These will later cause a format error when the timecode * is interpreted. The decoding distance is defined as the * minimum distance over the first nine digits. The tenth digit * varies over the seconds, so we don't count it. */ mindist = 16; for (i = 0; i < 9; i++) { val1 = val2 = 0; k = 0; for (j = 0; j < 16; j++) { temp = up->decode[i][j] + up->decode[i + 10][j]; if (temp > val1) { val2 = val1; val1 = temp; k = j; } } if (val1 == 0) code[i] = HEX_MISS; else if (val1 == val2) code[i] = HEX_HARD; else if (val1 <= up->burstcnt) code[i] = HEX_SOFT; else code[i] = k; if (val1 < mindist) mindist = val1; code[i] = hexchar[code[i]]; } code[i] = 0; /* * A valid timecode requires a minimum distance at least half * the total number of occurrences. A valid timecode also * requires at least 20 valid timestamps. */ if (up->burstcnt < MINBURST || mindist < up->burstcnt) up->status |= DECODE; if (up->ntstamp < MINSTAMP) up->status |= STAMP; /* * Compute the timecode timestamp from the days, hours and * minutes of the timecode. Use clocktime() for the aggregate * minutes and the minute offset computed from the burst * seconds. Note that this code relies on the filesystem time * for the years and does not use the years of the timecode. */ if (sscanf((char *)code, "%1x%3d%2d%2d", &synchar, &pp->day, &pp->hour, &pp->minute) != 4) { up->status |= AFORMAT; return (0); } if (up->status & (DECODE | STAMP)) { up->errflg = CEVNT_BADREPLY; return (0); } return (mindist * 100. / (2. * up->burstcnt)); } /* * chu_clear - clear decoding matrix */ static void chu_clear( struct peer *peer /* peer structure pointer */ ) { struct refclockproc *pp; struct chuunit *up; int i, j; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * Clear stuff for the minute. */ up->ndx = up->prevsec = 0; up->burstcnt = up->ntstamp = 0; up->status &= INSYNC; for (i = 0; i < 20; i++) { for (j = 0; j < 16; j++) up->decode[i][j] = 0; } } #ifdef ICOM /* * chu_newchan - called once per minute to find the best channel; * returns zero on success, nonzero if ICOM error. */ static int chu_newchan( struct peer *peer, double met ) { struct chuunit *up; struct refclockproc *pp; struct xmtr *sp; char tbuf[80]; /* trace buffer */ int rval; double metric; int i, j; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * The radio can be tuned to three channels: 0 (3330 kHz), 1 * (7335 kHz) and 2 (14670 kHz). There are five one-minute * dwells in each cycle. During the first dwell the radio is * tuned to one of three probe channels; during the remaining * four dwells the radio is tuned to the data channel. The probe * channel is selects as the least recently used. At the end of * each dwell the channel metrics are measured and the highest * one is selected as the data channel. */ if (up->fd_icom <= 0) return (0); sp = &up->xmtr[up->achan]; sp->metric -= sp->integ[sp->iptr]; sp->integ[sp->iptr] = met; sp->metric += sp->integ[sp->iptr]; sp->iptr = (sp->iptr + 1) % ISTAGE; metric = 0; j = 0; for (i = 0; i < NCHAN; i++) { up->xmtr[i].probe++; if (i == up->achan) up->xmtr[i].probe = 0; if (up->xmtr[i].metric < metric) continue; metric = up->xmtr[i].metric; j = i; } if (j != up->chan && metric > 0) { up->chan = j; sprintf(tbuf, "chu: QSY to %.3f MHz metric %.0f", qsy[up->chan], metric); if (pp->sloppyclockflag & CLK_FLAG4) record_clock_stats(&peer->srcadr, tbuf); #ifdef DEBUG if (debug) printf("%s\n", tbuf); #endif } /* * Start the next dwell. We speed up the initial sync a little. * If not in sync and no bursts were heard the previous dwell, * restart the probe. */ rval = 0; if (up->burstcnt == 0 && !(up->status & INSYNC)) up->dwell = 0; #ifdef DEBUG if (debug) printf( "chu: at %ld dwell %d achan %d metric %.0f chan %d\n", current_time, up->dwell, up->achan, sp->metric, up->chan); #endif if (up->dwell == 0) { rval = 0; for (i = 0; i < NCHAN; i++) { if (up->xmtr[i].probe < rval) continue; rval = up->xmtr[i].probe; up->achan = i; } rval = icom_freq(up->fd_icom, peer->ttl & 0x7f, qsy[up->achan] + TUNE); #ifdef DEBUG if (debug) printf("chu: at %ld probe channel %d\n", current_time, up->achan); #endif } else { if (up->achan != up->chan) { rval = icom_freq(up->fd_icom, peer->ttl & 0x7f, qsy[up->chan] + TUNE); up->achan = up->chan; } } sprintf(up->ident, "CHU%d", up->achan); memcpy(&peer->refid, up->ident, 4); up->dwell = (up->dwell + 1) % DWELL; return (rval); } #endif /* ICOM */ /* * chu_dist - determine the distance of two octet arguments */ static int chu_dist( int x, /* an octet of bits */ int y /* another octet of bits */ ) { int val; /* bit count */ int temp; int i; /* * The distance is determined as the weight of the exclusive OR * of the two arguments. The weight is determined by the number * of one bits in the result. Each one bit increases the weight, * while each zero bit decreases it. */ temp = x ^ y; val = 0; for (i = 0; i < 8; i++) { if ((temp & 0x1) == 0) val++; else val--; temp >>= 1; } return (val); } #ifdef HAVE_AUDIO /* * chu_gain - adjust codec gain * * This routine is called once each second. If the signal envelope * amplitude is too low, the codec gain is bumped up by four units; if * too high, it is bumped down. The decoder is relatively insensitive to * amplitude, so this crudity works just fine. The input port is set and * the error flag is cleared, mostly to be ornery. */ static void chu_gain( struct peer *peer /* peer structure pointer */ ) { struct refclockproc *pp; struct chuunit *up; pp = peer->procptr; up = (struct chuunit *)pp->unitptr; /* * Apparently, the codec uses only the high order bits of the * gain control field. Thus, it may take awhile for changes to * wiggle the hardware bits. */ if (up->clipcnt == 0) { up->gain += 4; if (up->gain > MAXGAIN) up->gain = MAXGAIN; } else if (up->clipcnt > MAXCLP) { up->gain -= 4; if (up->gain < 0) up->gain = 0; } audio_gain(up->gain, up->mongain, up->port); up->clipcnt = 0; } #endif /* HAVE_AUDIO */ #else int refclock_chu_bs; #endif /* REFCLOCK */