1: /*
2: * refclock_zyfer - clock driver for the Zyfer GPSTarplus Clock
3: *
4: * Harlan Stenn, Jan 2002
5: */
6:
7: #ifdef HAVE_CONFIG_H
8: #include <config.h>
9: #endif
10:
11: #if defined(REFCLOCK) && defined(CLOCK_ZYFER)
12:
13: #include "ntpd.h"
14: #include "ntp_io.h"
15: #include "ntp_refclock.h"
16: #include "ntp_stdlib.h"
17: #include "ntp_unixtime.h"
18:
19: #include <stdio.h>
20: #include <ctype.h>
21:
22: #ifdef HAVE_SYS_TERMIOS_H
23: # include <sys/termios.h>
24: #endif
25: #ifdef HAVE_SYS_PPSCLOCK_H
26: # include <sys/ppsclock.h>
27: #endif
28:
29: /*
30: * This driver provides support for the TOD serial port of a Zyfer GPStarplus.
31: * This clock also provides PPS as well as IRIG outputs.
32: * Precision is limited by the serial driver, etc.
33: *
34: * If I was really brave I'd hack/generalize the serial driver to deal
35: * with arbitrary on-time characters. This clock *begins* the stream with
36: * `!`, the on-time character, and the string is *not* EOL-terminated.
37: *
38: * Configure the beast for 9600, 8N1. While I see leap-second stuff
39: * in the documentation, the published specs on the TOD format only show
40: * the seconds going to '59'. I see no leap warning in the TOD format.
41: *
42: * The clock sends the following message once per second:
43: *
44: * !TIME,2002,017,07,59,32,2,4,1
45: * YYYY DDD HH MM SS m T O
46: *
47: * ! On-time character
48: * YYYY Year
49: * DDD 001-366 Day of Year
50: * HH 00-23 Hour
51: * MM 00-59 Minute
52: * SS 00-59 Second (probably 00-60)
53: * m 1-5 Time Mode:
54: * 1 = GPS time
55: * 2 = UTC time
56: * 3 = LGPS time (Local GPS)
57: * 4 = LUTC time (Local UTC)
58: * 5 = Manual time
59: * T 4-9 Time Figure Of Merit:
60: * 4 x <= 1us
61: * 5 1us < x <= 10 us
62: * 6 10us < x <= 100us
63: * 7 100us < x <= 1ms
64: * 8 1ms < x <= 10ms
65: * 9 10ms < x
66: * O 0-4 Operation Mode:
67: * 0 Warm-up
68: * 1 Time Locked
69: * 2 Coasting
70: * 3 Recovering
71: * 4 Manual
72: *
73: */
74:
75: /*
76: * Interface definitions
77: */
78: #define DEVICE "/dev/zyfer%d" /* device name and unit */
79: #define SPEED232 B9600 /* uart speed (9600 baud) */
80: #define PRECISION (-20) /* precision assumed (about 1 us) */
81: #define REFID "GPS\0" /* reference ID */
82: #define DESCRIPTION "Zyfer GPStarplus" /* WRU */
83:
84: #define LENZYFER 29 /* timecode length */
85:
86: /*
87: * Unit control structure
88: */
89: struct zyferunit {
90: u_char Rcvbuf[LENZYFER + 1];
91: u_char polled; /* poll message flag */
92: int pollcnt;
93: l_fp tstamp; /* timestamp of last poll */
94: int Rcvptr;
95: };
96:
97: /*
98: * Function prototypes
99: */
100: static int zyfer_start (int, struct peer *);
101: static void zyfer_shutdown (int, struct peer *);
102: static void zyfer_receive (struct recvbuf *);
103: static void zyfer_poll (int, struct peer *);
104:
105: /*
106: * Transfer vector
107: */
108: struct refclock refclock_zyfer = {
109: zyfer_start, /* start up driver */
110: zyfer_shutdown, /* shut down driver */
111: zyfer_poll, /* transmit poll message */
112: noentry, /* not used (old zyfer_control) */
113: noentry, /* initialize driver (not used) */
114: noentry, /* not used (old zyfer_buginfo) */
115: NOFLAGS /* not used */
116: };
117:
118:
119: /*
120: * zyfer_start - open the devices and initialize data for processing
121: */
122: static int
123: zyfer_start(
124: int unit,
125: struct peer *peer
126: )
127: {
128: register struct zyferunit *up;
129: struct refclockproc *pp;
130: int fd;
131: char device[20];
132:
133: /*
134: * Open serial port.
135: * Something like LDISC_ACTS that looked for ! would be nice...
136: */
137: (void)sprintf(device, DEVICE, unit);
138: if ( !(fd = refclock_open(device, SPEED232, LDISC_RAW)) )
139: return (0);
140:
141: msyslog(LOG_NOTICE, "zyfer(%d) fd: %d dev <%s>", unit, fd, device);
142:
143: /*
144: * Allocate and initialize unit structure
145: */
146: if (!(up = (struct zyferunit *)
147: emalloc(sizeof(struct zyferunit)))) {
148: (void) close(fd);
149: return (0);
150: }
151: memset((char *)up, 0, sizeof(struct zyferunit));
152: pp = peer->procptr;
153: pp->io.clock_recv = zyfer_receive;
154: pp->io.srcclock = (caddr_t)peer;
155: pp->io.datalen = 0;
156: pp->io.fd = fd;
157: if (!io_addclock(&pp->io)) {
158: (void) close(fd);
159: free(up);
160: return (0);
161: }
162: pp->unitptr = (caddr_t)up;
163:
164: /*
165: * Initialize miscellaneous variables
166: */
167: peer->precision = PRECISION;
168: pp->clockdesc = DESCRIPTION;
169: memcpy((char *)&pp->refid, REFID, 4);
170: up->pollcnt = 2;
171: up->polled = 0; /* May not be needed... */
172:
173: return (1);
174: }
175:
176:
177: /*
178: * zyfer_shutdown - shut down the clock
179: */
180: static void
181: zyfer_shutdown(
182: int unit,
183: struct peer *peer
184: )
185: {
186: register struct zyferunit *up;
187: struct refclockproc *pp;
188:
189: pp = peer->procptr;
190: up = (struct zyferunit *)pp->unitptr;
191: io_closeclock(&pp->io);
192: free(up);
193: }
194:
195:
196: /*
197: * zyfer_receive - receive data from the serial interface
198: */
199: static void
200: zyfer_receive(
201: struct recvbuf *rbufp
202: )
203: {
204: register struct zyferunit *up;
205: struct refclockproc *pp;
206: struct peer *peer;
207: int tmode; /* Time mode */
208: int tfom; /* Time Figure Of Merit */
209: int omode; /* Operation mode */
210: u_char *p;
211: #ifdef PPS
212: struct ppsclockev ppsev;
213: int request;
214: #ifdef HAVE_CIOGETEV
215: request = CIOGETEV;
216: #endif
217: #ifdef HAVE_TIOCGPPSEV
218: request = TIOCGPPSEV;
219: #endif
220: #endif /* PPS */
221:
222: peer = (struct peer *)rbufp->recv_srcclock;
223: pp = peer->procptr;
224: up = (struct zyferunit *)pp->unitptr;
225: p = (u_char *) &rbufp->recv_space;
226: /*
227: * If lencode is 0:
228: * - if *rbufp->recv_space is !
229: * - - call refclock_gtlin to get things going
230: * - else flush
231: * else stuff it on the end of lastcode
232: * If we don't have LENZYFER bytes
233: * - wait for more data
234: * Crack the beast, and if it's OK, process it.
235: *
236: * We use refclock_gtlin() because we might use LDISC_CLK.
237: *
238: * Under FreeBSD, we get the ! followed by two 14-byte packets.
239: */
240:
241: if (pp->lencode >= LENZYFER)
242: pp->lencode = 0;
243:
244: if (!pp->lencode) {
245: if (*p == '!')
246: pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode,
247: BMAX, &pp->lastrec);
248: else
249: return;
250: } else {
251: memcpy(pp->a_lastcode + pp->lencode, p, rbufp->recv_length);
252: pp->lencode += rbufp->recv_length;
253: pp->a_lastcode[pp->lencode] = '\0';
254: }
255:
256: if (pp->lencode < LENZYFER)
257: return;
258:
259: record_clock_stats(&peer->srcadr, pp->a_lastcode);
260:
261: /*
262: * We get down to business, check the timecode format and decode
263: * its contents. If the timecode has invalid length or is not in
264: * proper format, we declare bad format and exit.
265: */
266:
267: if (pp->lencode != LENZYFER) {
268: refclock_report(peer, CEVNT_BADTIME);
269: return;
270: }
271:
272: /*
273: * Timecode sample: "!TIME,2002,017,07,59,32,2,4,1"
274: */
275: if (sscanf(pp->a_lastcode, "!TIME,%4d,%3d,%2d,%2d,%2d,%d,%d,%d",
276: &pp->year, &pp->day, &pp->hour, &pp->minute, &pp->second,
277: &tmode, &tfom, &omode) != 8) {
278: refclock_report(peer, CEVNT_BADREPLY);
279: return;
280: }
281:
282: if (tmode != 2) {
283: refclock_report(peer, CEVNT_BADTIME);
284: return;
285: }
286:
287: /* Should we make sure tfom is 4? */
288:
289: if (omode != 1) {
290: pp->leap = LEAP_NOTINSYNC;
291: return;
292: }
293: #ifdef PPS
294: if(ioctl(fdpps,request,(caddr_t) &ppsev) >=0) {
295: ppsev.tv.tv_sec += (u_int32) JAN_1970;
296: TVTOTS(&ppsev.tv,&up->tstamp);
297: }
298: /* record the last ppsclock event time stamp */
299: pp->lastrec = up->tstamp;
300: #endif /* PPS */
301: if (!refclock_process(pp)) {
302: refclock_report(peer, CEVNT_BADTIME);
303: return;
304: }
305:
306: /*
307: * Good place for record_clock_stats()
308: */
309: up->pollcnt = 2;
310:
311: if (up->polled) {
312: up->polled = 0;
313: refclock_receive(peer);
314: }
315: }
316:
317:
318: /*
319: * zyfer_poll - called by the transmit procedure
320: */
321: static void
322: zyfer_poll(
323: int unit,
324: struct peer *peer
325: )
326: {
327: register struct zyferunit *up;
328: struct refclockproc *pp;
329:
330: /*
331: * We don't really do anything here, except arm the receiving
332: * side to capture a sample and check for timeouts.
333: */
334: pp = peer->procptr;
335: up = (struct zyferunit *)pp->unitptr;
336: if (!up->pollcnt)
337: refclock_report(peer, CEVNT_TIMEOUT);
338: else
339: up->pollcnt--;
340: pp->polls++;
341: up->polled = 1;
342: }
343:
344: #else
345: int refclock_zyfer_bs;
346: #endif /* REFCLOCK */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_zyfer.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