1 /* $NetBSD: refclock_as2201.c,v 1.6 2024/08/18 20:47:18 christos Exp $ */
2
3 /*
4 * refclock_as2201 - clock driver for the Austron 2201A GPS
5 * Timing Receiver
6 */
7 #ifdef HAVE_CONFIG_H
8 #include <config.h>
9 #endif
10
11 #if defined(REFCLOCK) && defined(CLOCK_AS2201)
12
13 #include "ntpd.h"
14 #include "ntp_io.h"
15 #include "ntp_refclock.h"
16 #include "ntp_unixtime.h"
17 #include "ntp_stdlib.h"
18
19 #include <stdio.h>
20 #include <ctype.h>
21
22 /*
23 * This driver supports the Austron 2200A/2201A GPS Receiver with
24 * Buffered RS-232-C Interface Module. Note that the original 2200/2201
25 * receivers will not work reliably with this driver, since the older
26 * design cannot accept input commands at any reasonable data rate.
27 *
28 * The program sends a "*toc\r" to the radio and expects a response of
29 * the form "yy:ddd:hh:mm:ss.mmm\r" where yy = year of century, ddd =
30 * day of year, hh:mm:ss = second of day and mmm = millisecond of
31 * second. Then, it sends statistics commands to the radio and expects
32 * a multi-line reply showing the corresponding statistics or other
33 * selected data. Statistics commands are sent in order as determined by
34 * a vector of commands; these might have to be changed with different
35 * radio options. If flag4 of the fudge configuration command is set to
36 * 1, the statistics data are written to the clockstats file for later
37 * processing.
38 *
39 * In order for this code to work, the radio must be placed in non-
40 * interactive mode using the "off" command and with a single <cr>
41 * response using the "term cr" command. The setting of the "echo"
42 * and "df" commands does not matter. The radio should select UTC
43 * timescale using the "ts utc" command.
44 *
45 * There are two modes of operation for this driver. The first with
46 * default configuration is used with stock kernels and serial-line
47 * drivers and works with almost any machine. In this mode the driver
48 * assumes the radio captures a timestamp upon receipt of the "*" that
49 * begins the driver query. Accuracies in this mode are in the order of
50 * a millisecond or two and the receiver can be connected to only one
51 * host.
52 *
53 * The second mode of operation can be used for SunOS kernels that have
54 * been modified with the ppsclock streams module included in this
55 * distribution. The mode is enabled if flag3 of the fudge configuration
56 * command has been set to 1. In this mode a precise timestamp is
57 * available using a gadget box and 1-pps signal from the receiver. This
58 * improves the accuracy to the order of a few tens of microseconds. In
59 * addition, the serial output and 1-pps signal can be bussed to more
60 * than one hosts, but only one of them should be connected to the
61 * radio input data line.
62 */
63
64 /*
65 * GPS Definitions
66 */
67 #define SMAX 200 /* statistics buffer length */
68 #define DEVICE "/dev/gps%d" /* device name and unit */
69 #define SPEED232 B9600 /* uart speed (9600 baud) */
70 #define PRECISION (-20) /* precision assumed (about 1 us) */
71 #define REFID "GPS\0" /* reference ID */
72 #define DESCRIPTION "Austron 2201A GPS Receiver" /* WRU */
73
74 #define LENTOC 19 /* yy:ddd:hh:mm:ss.mmm timecode lngth */
75
76 /*
77 * AS2201 unit control structure.
78 */
79 struct as2201unit {
80 char *lastptr; /* statistics buffer pointer */
81 char stats[SMAX]; /* statistics buffer */
82 int linect; /* count of lines remaining */
83 int index; /* current statistics command */
84 };
85
86 /*
87 * Radio commands to extract statitistics
88 *
89 * A command consists of an ASCII string terminated by a <cr> (\r). The
90 * command list consist of a sequence of commands terminated by a null
91 * string ("\0"). One command from the list is sent immediately
92 * following each received timecode (*toc\r command) and the ASCII
93 * strings received from the radio are saved along with the timecode in
94 * the clockstats file. Subsequent commands are sent at each timecode,
95 * with the last one in the list followed by the first one. The data
96 * received from the radio consist of ASCII strings, each terminated by
97 * a <cr> (\r) character. The number of strings for each command is
98 * specified as the first line of output as an ASCII-encode number. Note
99 * that the ETF command requires the Input Buffer Module and the LORAN
100 * commands require the LORAN Assist Module. However, if these modules
101 * are not installed, the radio and this driver will continue to operate
102 * successfuly, but no data will be captured for these commands.
103 */
104 static char stat_command[][30] = {
105 "ITF\r", /* internal time/frequency */
106 "ETF\r", /* external time/frequency */
107 "LORAN ENSEMBLE\r", /* GPS/LORAN ensemble statistics */
108 "LORAN TDATA\r", /* LORAN signal data */
109 "ID;OPT;VER\r", /* model; options; software version */
110
111 "ITF\r", /* internal time/frequency */
112 "ETF\r", /* external time/frequency */
113 "LORAN ENSEMBLE\r", /* GPS/LORAN ensemble statistics */
114 "TRSTAT\r", /* satellite tracking status */
115 "POS;PPS;PPSOFF\r", /* position, pps source, offsets */
116
117 "ITF\r", /* internal time/frequency */
118 "ETF\r", /* external time/frequency */
119 "LORAN ENSEMBLE\r", /* GPS/LORAN ensemble statistics */
120 "LORAN TDATA\r", /* LORAN signal data */
121 "UTC\r", /* UTC leap info */
122
123 "ITF\r", /* internal time/frequency */
124 "ETF\r", /* external time/frequency */
125 "LORAN ENSEMBLE\r", /* GPS/LORAN ensemble statistics */
126 "TRSTAT\r", /* satellite tracking status */
127 "OSC;ET;TEMP\r", /* osc type; tune volts; oven temp */
128 "\0" /* end of table */
129 };
130
131 /*
132 * Function prototypes
133 */
134 static int as2201_start (int, struct peer *);
135 static void as2201_shutdown (int, struct peer *);
136 static void as2201_receive (struct recvbuf *);
137 static void as2201_poll (int, struct peer *);
138
139 /*
140 * Transfer vector
141 */
142 struct refclock refclock_as2201 = {
143 as2201_start, /* start up driver */
144 as2201_shutdown, /* shut down driver */
145 as2201_poll, /* transmit poll message */
146 noentry, /* not used (old as2201_control) */
147 noentry, /* initialize driver (not used) */
148 noentry, /* not used (old as2201_buginfo) */
149 NOFLAGS /* not used */
150 };
151
152
153 /*
154 * as2201_start - open the devices and initialize data for processing
155 */
156 static int
as2201_start(int unit,struct peer * peer)157 as2201_start(
158 int unit,
159 struct peer *peer
160 )
161 {
162 register struct as2201unit *up;
163 struct refclockproc *pp;
164 int fd;
165 char gpsdev[20];
166
167 /*
168 * Open serial port. Use CLK line discipline, if available.
169 */
170 snprintf(gpsdev, sizeof(gpsdev), DEVICE, unit);
171 fd = refclock_open(&peer->srcadr, gpsdev, SPEED232, LDISC_CLK);
172 if (fd <= 0)
173 return (0);
174
175 /*
176 * Allocate and initialize unit structure
177 */
178 up = emalloc_zero(sizeof(*up));
179 pp = peer->procptr;
180 pp->io.clock_recv = as2201_receive;
181 pp->io.srcclock = peer;
182 pp->io.datalen = 0;
183 pp->io.fd = fd;
184 if (!io_addclock(&pp->io)) {
185 close(fd);
186 pp->io.fd = -1;
187 free(up);
188 return (0);
189 }
190 pp->unitptr = up;
191
192 /*
193 * Initialize miscellaneous variables
194 */
195 peer->precision = PRECISION;
196 pp->clockdesc = DESCRIPTION;
197 memcpy((char *)&pp->refid, REFID, 4);
198 up->lastptr = up->stats;
199 up->index = 0;
200 return (1);
201 }
202
203
204 /*
205 * as2201_shutdown - shut down the clock
206 */
207 static void
as2201_shutdown(int unit,struct peer * peer)208 as2201_shutdown(
209 int unit,
210 struct peer *peer
211 )
212 {
213 register struct as2201unit *up;
214 struct refclockproc *pp;
215
216 pp = peer->procptr;
217 up = pp->unitptr;
218 if (-1 != pp->io.fd)
219 io_closeclock(&pp->io);
220 if (NULL != up)
221 free(up);
222 }
223
224
225 /*
226 * as2201__receive - receive data from the serial interface
227 */
228 static void
as2201_receive(struct recvbuf * rbufp)229 as2201_receive(
230 struct recvbuf *rbufp
231 )
232 {
233 register struct as2201unit *up;
234 struct refclockproc *pp;
235 struct peer *peer;
236 l_fp trtmp;
237 size_t octets;
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 pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &trtmp);
246 #ifdef DEBUG
247 if (debug)
248 printf("gps: timecode %d %d %s\n",
249 up->linect, pp->lencode, pp->a_lastcode);
250 #endif
251 if (pp->lencode == 0)
252 return;
253
254 /*
255 * If linect is greater than zero, we must be in the middle of a
256 * statistics operation, so simply tack the received data at the
257 * end of the statistics string. If not, we could either have
258 * just received the timecode itself or a decimal number
259 * indicating the number of following lines of the statistics
260 * reply. In the former case, write the accumulated statistics
261 * data to the clockstats file and continue onward to process
262 * the timecode; in the later case, save the number of lines and
263 * quietly return.
264 */
265 if (pp->sloppyclockflag & CLK_FLAG2)
266 pp->lastrec = trtmp;
267 if (up->linect > 0) {
268 up->linect--;
269 if ((int)(up->lastptr - up->stats + pp->lencode) > SMAX - 2)
270 return;
271 *up->lastptr++ = ' ';
272 memcpy(up->lastptr, pp->a_lastcode, 1 + pp->lencode);
273 up->lastptr += pp->lencode;
274 return;
275 } else {
276 if (pp->lencode == 1) {
277 up->linect = atoi(pp->a_lastcode);
278 return;
279 } else {
280 record_clock_stats(&peer->srcadr, up->stats);
281 #ifdef DEBUG
282 if (debug)
283 printf("gps: stat %s\n", up->stats);
284 #endif
285 }
286 }
287 up->lastptr = up->stats;
288 *up->lastptr = '\0';
289
290 /*
291 * We get down to business, check the timecode format and decode
292 * its contents. If the timecode has invalid length or is not in
293 * proper format, we declare bad format and exit.
294 */
295 if (pp->lencode < LENTOC) {
296 refclock_report(peer, CEVNT_BADREPLY);
297 return;
298 }
299
300 /*
301 * Timecode format: "yy:ddd:hh:mm:ss.mmm"
302 */
303 if (sscanf(pp->a_lastcode, "%2d:%3d:%2d:%2d:%2d.%3ld", &pp->year,
304 &pp->day, &pp->hour, &pp->minute, &pp->second, &pp->nsec)
305 != 6) {
306 refclock_report(peer, CEVNT_BADREPLY);
307 return;
308 }
309 pp->nsec *= 1000000;
310
311 /*
312 * Test for synchronization (this is a temporary crock).
313 */
314 if (pp->a_lastcode[2] != ':')
315 pp->leap = LEAP_NOTINSYNC;
316 else
317 pp->leap = LEAP_NOWARNING;
318
319 /*
320 * Process the new sample in the median filter and determine the
321 * timecode timestamp.
322 */
323 if (!refclock_process(pp)) {
324 refclock_report(peer, CEVNT_BADTIME);
325 return;
326 }
327
328 /*
329 * If CLK_FLAG4 is set, initialize the statistics buffer and
330 * send the next command. If not, simply write the timecode to
331 * the clockstats file.
332 */
333 if ((int)(up->lastptr - up->stats + pp->lencode) > SMAX - 2)
334 return;
335 memcpy(up->lastptr, pp->a_lastcode, pp->lencode);
336 up->lastptr += pp->lencode;
337 if (pp->sloppyclockflag & CLK_FLAG4) {
338 octets = strlen(stat_command[up->index]);
339 if ((int)(up->lastptr - up->stats + 1 + octets) > SMAX - 2)
340 return;
341 *up->lastptr++ = ' ';
342 memcpy(up->lastptr, stat_command[up->index], octets);
343 up->lastptr += octets - 1;
344 *up->lastptr = '\0';
345 refclock_write(peer, stat_command[up->index],
346 strlen(stat_command[up->index]),
347 "command");
348 up->index++;
349 if (*stat_command[up->index] == '\0')
350 up->index = 0;
351 }
352 }
353
354
355 /*
356 * as2201_poll - called by the transmit procedure
357 *
358 * We go to great pains to avoid changing state here, since there may be
359 * more than one eavesdropper receiving the same timecode.
360 */
361 static void
as2201_poll(int unit,struct peer * peer)362 as2201_poll(
363 int unit,
364 struct peer *peer
365 )
366 {
367 struct refclockproc *pp;
368
369 /*
370 * Send a "\r*toc\r" to get things going. We go to great pains
371 * to avoid changing state, since there may be more than one
372 * eavesdropper watching the radio.
373 */
374 pp = peer->procptr;
375 if (write(pp->io.fd, "\r*toc\r", 6) != 6) {
376 refclock_report(peer, CEVNT_FAULT);
377 } else {
378 pp->polls++;
379 if (!(pp->sloppyclockflag & CLK_FLAG2))
380 get_systime(&pp->lastrec);
381 }
382 if (pp->coderecv == pp->codeproc) {
383 refclock_report(peer, CEVNT_TIMEOUT);
384 return;
385 }
386 refclock_receive(peer);
387 }
388
389 #else
390 NONEMPTY_TRANSLATION_UNIT
391 #endif /* REFCLOCK */
392