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