1/*
2 * refclock_arbiter - clock driver for Arbiter 1088A/B Satellite
3 *	Controlled Clock
4 */
5
6#ifdef HAVE_CONFIG_H
7#include <config.h>
8#endif
9
10#if defined(REFCLOCK) && defined(CLOCK_ARBITER)
11
12#include "ntpd.h"
13#include "ntp_io.h"
14#include "ntp_refclock.h"
15#include "ntp_stdlib.h"
16
17#include <stdio.h>
18#include <ctype.h>
19
20/*
21 * This driver supports the Arbiter 1088A/B Satellite Controlled Clock.
22 * The claimed accuracy of this clock is 100 ns relative to the PPS
23 * output when receiving four or more satellites.
24 *
25 * The receiver should be configured before starting the NTP daemon, in
26 * order to establish reliable position and operating conditions. It
27 * does not initiate surveying or hold mode. For use with NTP, the
28 * daylight savings time feature should be disables (D0 command) and the
29 * broadcast mode set to operate in UTC (BU command).
30 *
31 * The timecode format supported by this driver is selected by the poll
32 * sequence "B5", which initiates a line in the following format to be
33 * repeated once per second until turned off by the "B0" poll sequence.
34 *
35 * Format B5 (24 ASCII printing characters):
36 *
37 * <cr><lf>i yy ddd hh:mm:ss.000bbb
38 *
39 *	on-time = <cr>
40 *	i = synchronization flag (' ' = locked, '?' = unlocked)
41 *	yy = year of century
42 *	ddd = day of year
43 *	hh:mm:ss = hours, minutes, seconds
44 *	.000 = fraction of second (not used)
45 *	bbb = tailing spaces for fill
46 *
47 * The alarm condition is indicated by a '?' at i, which indicates the
48 * receiver is not synchronized. In normal operation, a line consisting
49 * of the timecode followed by the time quality character (TQ) followed
50 * by the receiver status string (SR) is written to the clockstats file.
51 * The time quality character is encoded in IEEE P1344 standard:
52 *
53 * Format TQ (IEEE P1344 estimated worst-case time quality)
54 *
55 *	0	clock locked, maximum accuracy
56 *	F	clock failure, time not reliable
57 *	4	clock unlocked, accuracy < 1 us
58 *	5	clock unlocked, accuracy < 10 us
59 *	6	clock unlocked, accuracy < 100 us
60 *	7	clock unlocked, accuracy < 1 ms
61 *	8	clock unlocked, accuracy < 10 ms
62 *	9	clock unlocked, accuracy < 100 ms
63 *	A	clock unlocked, accuracy < 1 s
64 *	B	clock unlocked, accuracy < 10 s
65 *
66 * The status string is encoded as follows:
67 *
68 * Format SR (25 ASCII printing characters)
69 *
70 *	V=vv S=ss T=t P=pdop E=ee
71 *
72 *	vv = satellites visible
73 *	ss = relative signal strength
74 *	t = satellites tracked
75 *	pdop = position dilution of precision (meters)
76 *	ee = hardware errors
77 *
78 * If flag4 is set, an additional line consisting of the receiver
79 * latitude (LA), longitude (LO), elevation (LH) (meters), and data
80 * buffer (DB) is written to this file. If channel B is enabled for
81 * deviation mode and connected to a 1-PPS signal, the last two numbers
82 * on the line are the deviation and standard deviation averaged over
83 * the last 15 seconds.
84 *
85 * PPS calibration fudge time1 .001240
86 */
87
88/*
89 * Interface definitions
90 */
91#define	DEVICE		"/dev/gps%d" /* device name and unit */
92#define	SPEED232	B9600	/* uart speed (9600 baud) */
93#define	PRECISION	(-20)	/* precision assumed (about 1 us) */
94#define	REFID		"GPS "	/* reference ID */
95#define	DESCRIPTION	"Arbiter 1088A/B GPS Receiver" /* WRU */
96#define	LENARB		24	/* format B5 timecode length */
97#define MAXSTA		40	/* max length of status string */
98#define MAXPOS		80	/* max length of position string */
99
100#ifdef PRE_NTP420
101#define MODE ttlmax
102#else
103#define MODE ttl
104#endif
105
106#define COMMAND_HALT_BCAST ( (peer->MODE % 2) ? "O0" : "B0" )
107#define COMMAND_START_BCAST ( (peer->MODE % 2) ? "O5" : "B5" )
108
109/*
110 * ARB unit control structure
111 */
112struct arbunit {
113	l_fp	laststamp;	/* last receive timestamp */
114	int	tcswitch;	/* timecode switch/counter */
115	char	qualchar;	/* IEEE P1344 quality (TQ command) */
116	char	status[MAXSTA];	/* receiver status (SR command) */
117	char	latlon[MAXPOS];	/* receiver position (lat/lon/alt) */
118};
119
120/*
121 * Function prototypes
122 */
123static	int	arb_start	(int, struct peer *);
124static	void	arb_shutdown	(int, struct peer *);
125static	void	arb_receive	(struct recvbuf *);
126static	void	arb_poll	(int, struct peer *);
127
128/*
129 * Transfer vector
130 */
131struct	refclock refclock_arbiter = {
132	arb_start,		/* start up driver */
133	arb_shutdown,		/* shut down driver */
134	arb_poll,		/* transmit poll message */
135	noentry,		/* not used (old arb_control) */
136	noentry,		/* initialize driver (not used) */
137	noentry,		/* not used (old arb_buginfo) */
138	NOFLAGS			/* not used */
139};
140
141
142/*
143 * arb_start - open the devices and initialize data for processing
144 */
145static int
146arb_start(
147	int unit,
148	struct peer *peer
149	)
150{
151	register struct arbunit *up;
152	struct refclockproc *pp;
153	int fd;
154	char device[20];
155
156	/*
157	 * Open serial port. Use CLK line discipline, if available.
158	 */
159	snprintf(device, sizeof(device), DEVICE, unit);
160	fd = refclock_open(&peer->srcadr, device, SPEED232, LDISC_CLK);
161	if (fd <= 0)
162		return (0);
163
164	/*
165	 * Allocate and initialize unit structure
166	 */
167	up = emalloc_zero(sizeof(*up));
168	pp = peer->procptr;
169	pp->io.clock_recv = arb_receive;
170	pp->io.srcclock = peer;
171	pp->io.datalen = 0;
172	pp->io.fd = fd;
173	if (!io_addclock(&pp->io)) {
174		close(fd);
175		pp->io.fd = -1;
176		free(up);
177		return (0);
178	}
179	pp->unitptr = up;
180
181	/*
182	 * Initialize miscellaneous variables
183	 */
184	peer->precision = PRECISION;
185	pp->clockdesc = DESCRIPTION;
186	memcpy((char *)&pp->refid, REFID, 4);
187	if (peer->MODE > 1) {
188		msyslog(LOG_NOTICE, "ARBITER: Invalid mode %d", peer->MODE);
189		close(fd);
190		pp->io.fd = -1;
191		free(up);
192		return (0);
193	}
194#ifdef DEBUG
195	if(debug) { printf("arbiter: mode = %d.\n", peer->MODE); }
196#endif
197	refclock_write(peer, COMMAND_HALT_BCAST, 2, "HALT_BCAST");
198	return (1);
199}
200
201
202/*
203 * arb_shutdown - shut down the clock
204 */
205static void
206arb_shutdown(
207	int unit,
208	struct peer *peer
209	)
210{
211	register struct arbunit *up;
212	struct refclockproc *pp;
213
214	pp = peer->procptr;
215	up = pp->unitptr;
216	if (-1 != pp->io.fd)
217		io_closeclock(&pp->io);
218	if (NULL != up)
219		free(up);
220}
221
222
223/*
224 * arb_receive - receive data from the serial interface
225 */
226static void
227arb_receive(
228	struct recvbuf *rbufp
229	)
230{
231	register struct arbunit *up;
232	struct refclockproc *pp;
233	struct peer *peer;
234	l_fp trtmp;
235	int temp;
236	u_char	syncchar;		/* synch indicator */
237	char	tbuf[BMAX];		/* temp buffer */
238
239	/*
240	 * Initialize pointers and read the timecode and timestamp
241	 */
242	peer = rbufp->recv_peer;
243	pp = peer->procptr;
244	up = pp->unitptr;
245	temp = refclock_gtlin(rbufp, tbuf, sizeof(tbuf), &trtmp);
246
247	/*
248	 * Note we get a buffer and timestamp for both a <cr> and <lf>,
249	 * but only the <cr> timestamp is retained. The program first
250	 * sends a TQ and expects the echo followed by the time quality
251	 * character. It then sends a B5 starting the timecode broadcast
252	 * and expects the echo followed some time later by the on-time
253	 * character <cr> and then the <lf> beginning the timecode
254	 * itself. Finally, at the <cr> beginning the next timecode at
255	 * the next second, the program sends a B0 shutting down the
256	 * timecode broadcast.
257	 *
258	 * If flag4 is set, the program snatches the latitude, longitude
259	 * and elevation and writes it to the clockstats file.
260	 */
261	if (temp == 0)
262		return;
263
264	pp->lastrec = up->laststamp;
265	up->laststamp = trtmp;
266	if (temp < 3)
267		return;
268
269	if (up->tcswitch == 0) {
270
271		/*
272		 * Collect statistics. If nothing is recogized, just
273		 * ignore; sometimes the clock doesn't stop spewing
274		 * timecodes for awhile after the B0 command.
275		 *
276		 * If flag4 is not set, send TQ, SR, B5. If flag4 is
277		 * sset, send TQ, SR, LA, LO, LH, DB, B5. When the
278		 * median filter is full, send B0.
279		 */
280		if (!strncmp(tbuf, "TQ", 2)) {
281			up->qualchar = tbuf[2];
282			refclock_write(peer, "SR", 2, "SR");
283			return;
284
285		} else if (!strncmp(tbuf, "SR", 2)) {
286			strlcpy(up->status, tbuf + 2,
287				sizeof(up->status));
288			if (pp->sloppyclockflag & CLK_FLAG4)
289			    refclock_write(peer, "LA", 2, "LA");
290			else
291			    refclock_write(peer, COMMAND_START_BCAST, 2,
292				COMMAND_START_BCAST);
293			return;
294
295		} else if (!strncmp(tbuf, "LA", 2)) {
296			strlcpy(up->latlon, tbuf + 2, sizeof(up->latlon));
297			refclock_write(peer, "LO", 2, "LO");
298			return;
299
300		} else if (!strncmp(tbuf, "LO", 2)) {
301			strlcat(up->latlon, " ", sizeof(up->latlon));
302			strlcat(up->latlon, tbuf + 2, sizeof(up->latlon));
303			refclock_write(peer, "LH", 2, "LH");
304			return;
305
306		} else if (!strncmp(tbuf, "LH", 2)) {
307			strlcat(up->latlon, " ", sizeof(up->latlon));
308			strlcat(up->latlon, tbuf + 2, sizeof(up->latlon));
309			refclock_write(peer, "DB", 2, "DB");
310			return;
311
312		} else if (!strncmp(tbuf, "DB", 2)) {
313			strlcat(up->latlon, " ", sizeof(up->latlon));
314			strlcat(up->latlon, tbuf + 2, sizeof(up->latlon));
315			record_clock_stats(&peer->srcadr, up->latlon);
316#ifdef DEBUG
317			if (debug)
318				printf("arbiter: %s\n", up->latlon);
319#endif
320			refclock_write(peer, COMMAND_START_BCAST, 2,
321				       COMMAND_START_BCAST);
322		}
323	}
324
325	/*
326	 * We get down to business, check the timecode format and decode
327	 * its contents. If the timecode has valid length, but not in
328	 * proper format, we declare bad format and exit. If the
329	 * timecode has invalid length, which sometimes occurs when the
330	 * B0 amputates the broadcast, we just quietly steal away. Note
331	 * that the time quality character and receiver status string is
332	 * tacked on the end for clockstats display.
333	 */
334	up->tcswitch++;
335	if (up->tcswitch <= 1 || temp < LENARB)
336		return;
337
338	/*
339	 * Timecode format B5: "i yy ddd hh:mm:ss.000   "
340	 */
341	strlcpy(pp->a_lastcode, tbuf, sizeof(pp->a_lastcode));
342	pp->a_lastcode[LENARB - 2] = up->qualchar;
343	strlcat(pp->a_lastcode, up->status, sizeof(pp->a_lastcode));
344	pp->lencode = strlen(pp->a_lastcode);
345	syncchar = ' ';
346	if (sscanf(pp->a_lastcode, "%c%2d %3d %2d:%2d:%2d",
347	    &syncchar, &pp->year, &pp->day, &pp->hour,
348	    &pp->minute, &pp->second) != 6) {
349		refclock_report(peer, CEVNT_BADREPLY);
350		refclock_write(peer, COMMAND_HALT_BCAST, 2, COMMAND_HALT_BCAST);
351		return;
352	}
353
354	/*
355	 * We decode the clock dispersion from the time quality
356	 * character.
357	 */
358	switch (up->qualchar) {
359
360	    case '0':		/* locked, max accuracy */
361		pp->disp = 1e-7;
362		pp->lastref = pp->lastrec;
363		break;
364
365	    case '4':		/* unlock accuracy < 1 us */
366		pp->disp = 1e-6;
367		break;
368
369	    case '5':		/* unlock accuracy < 10 us */
370		pp->disp = 1e-5;
371		break;
372
373	    case '6':		/* unlock accuracy < 100 us */
374		pp->disp = 1e-4;
375		break;
376
377	    case '7':		/* unlock accuracy < 1 ms */
378		pp->disp = .001;
379		break;
380
381	    case '8':		/* unlock accuracy < 10 ms */
382		pp->disp = .01;
383		break;
384
385	    case '9':		/* unlock accuracy < 100 ms */
386		pp->disp = .1;
387		break;
388
389	    case 'A':		/* unlock accuracy < 1 s */
390		pp->disp = 1;
391		break;
392
393	    case 'B':		/* unlock accuracy < 10 s */
394		pp->disp = 10;
395		break;
396
397	    case 'F':		/* clock failure */
398		pp->disp = MAXDISPERSE;
399		refclock_report(peer, CEVNT_FAULT);
400		refclock_write(peer, COMMAND_HALT_BCAST, 2,
401			       COMMAND_HALT_BCAST);
402		return;
403
404	    default:
405		pp->disp = MAXDISPERSE;
406		refclock_report(peer, CEVNT_BADREPLY);
407		refclock_write(peer, COMMAND_HALT_BCAST, 2,
408			       COMMAND_HALT_BCAST);
409		return;
410	}
411	if (syncchar != ' ')
412		pp->leap = LEAP_NOTINSYNC;
413	else
414		pp->leap = LEAP_NOWARNING;
415
416	/*
417	 * Process the new sample in the median filter and determine the
418	 * timecode timestamp.
419	 */
420	if (!refclock_process(pp))
421		refclock_report(peer, CEVNT_BADTIME);
422	else if (peer->disp > MAXDISTANCE)
423		refclock_receive(peer);
424
425	/* if (up->tcswitch >= MAXSTAGE) { */
426	refclock_write(peer, COMMAND_HALT_BCAST, 2, COMMAND_HALT_BCAST);
427	/* } */
428}
429
430
431/*
432 * arb_poll - called by the transmit procedure
433 */
434static void
435arb_poll(
436	int unit,
437	struct peer *peer
438	)
439{
440	register struct arbunit *up;
441	struct refclockproc *pp;
442
443	/*
444	 * Time to poll the clock. The Arbiter clock responds to a "B5"
445	 * by returning a timecode in the format specified above.
446	 * Transmission occurs once per second, unless turned off by a
447	 * "B0". Note there is no checking on state, since this may not
448	 * be the only customer reading the clock. Only one customer
449	 * need poll the clock; all others just listen in.
450	 */
451	pp = peer->procptr;
452	up = pp->unitptr;
453	pp->polls++;
454	up->tcswitch = 0;
455	if (refclock_write(peer, "TQ", 2, "TQ") != 2)
456		refclock_report(peer, CEVNT_FAULT);
457
458	/*
459	 * Process median filter samples. If none received, declare a
460	 * timeout and keep going.
461	 */
462	if (pp->coderecv == pp->codeproc) {
463		refclock_report(peer, CEVNT_TIMEOUT);
464		return;
465	}
466	refclock_receive(peer);
467	record_clock_stats(&peer->srcadr, pp->a_lastcode);
468#ifdef DEBUG
469	if (debug)
470		printf("arbiter: timecode %d %s\n",
471		   pp->lencode, pp->a_lastcode);
472#endif
473}
474
475#else
476NONEMPTY_TRANSLATION_UNIT
477#endif /* REFCLOCK */
478