1: /*
2: * refclock_nmea.c - clock driver for an NMEA GPS CLOCK
3: * Michael Petry Jun 20, 1994
4: * based on refclock_heathn.c
5: *
6: * Updated to add support for Accord GPS Clock
7: * Venu Gopal Dec 05, 2007
8: * neo.venu@gmail.com, venugopal_d@pgad.gov.in
9: *
10: * Updated to process 'time1' fudge factor
11: * Venu Gopal May 05, 2008
12: *
13: * Converted to common PPSAPI code, separate PPS fudge time1
14: * from serial timecode fudge time2.
15: * Dave Hart July 1, 2009
16: * hart@ntp.org, davehart@davehart.com
17: */
18:
19: #ifdef HAVE_CONFIG_H
20: #include <config.h>
21: #endif
22:
23: #if defined(REFCLOCK) && defined(CLOCK_NMEA)
24:
25: #include <sys/stat.h>
26: #include <stdio.h>
27: #include <ctype.h>
28:
29: #include "ntpd.h"
30: #include "ntp_io.h"
31: #include "ntp_unixtime.h"
32: #include "ntp_refclock.h"
33: #include "ntp_stdlib.h"
34: #include "ntp_calendar.h"
35:
36: #ifdef HAVE_PPSAPI
37: # include "ppsapi_timepps.h"
38: # include "refclock_atom.h"
39: #endif /* HAVE_PPSAPI */
40:
41: #ifdef SYS_WINNT
42: #undef write /* ports/winnt/include/config.h: #define write _write */
43: extern int async_write(int, const void *, unsigned int);
44: #define write(fd, data, octets) async_write(fd, data, octets)
45: #endif
46:
47: #ifndef TIMESPECTOTS
48: #define TIMESPECTOTS(ptspec, pts) \
49: do { \
50: DTOLFP((ptspec)->tv_nsec * 1.0e-9, pts); \
51: (pts)->l_ui += (u_int32)((ptspec)->tv_sec) + JAN_1970; \
52: } while (0)
53: #endif
54:
55:
56: /*
57: * This driver supports NMEA-compatible GPS receivers
58: *
59: * Prototype was refclock_trak.c, Thanks a lot.
60: *
61: * The receiver used spits out the NMEA sentences for boat navigation.
62: * And you thought it was an information superhighway. Try a raging river
63: * filled with rapids and whirlpools that rip away your data and warp time.
64: *
65: * If HAVE_PPSAPI is defined code to use the PPSAPI will be compiled in.
66: * On startup if initialization of the PPSAPI fails, it will fall back
67: * to the "normal" timestamps.
68: *
69: * The PPSAPI part of the driver understands fudge flag2 and flag3. If
70: * flag2 is set, it will use the clear edge of the pulse. If flag3 is
71: * set, kernel hardpps is enabled.
72: *
73: * GPS sentences other than RMC (the default) may be enabled by setting
74: * the relevent bits of 'mode' in the server configuration line
75: * server 127.127.20.x mode X
76: *
77: * bit 0 - enables RMC (1)
78: * bit 1 - enables GGA (2)
79: * bit 2 - enables GLL (4)
80: * bit 3 - enables ZDA (8) - Standard Time & Date
81: * bit 3 - enables ZDG (8) - Accord GPS Clock's custom sentence with GPS time
82: * very close to standard ZDA
83: *
84: * Multiple sentences may be selected except when ZDG/ZDA is selected.
85: *
86: * bit 4/5/6 - selects the baudrate for serial port :
87: * 0 for 4800 (default)
88: * 1 for 9600
89: * 2 for 19200
90: * 3 for 38400
91: * 4 for 57600
92: * 5 for 115200
93: */
94: #define NMEA_MESSAGE_MASK_OLD 0x07
95: #define NMEA_MESSAGE_MASK_SINGLE 0x08
96: #define NMEA_MESSAGE_MASK (NMEA_MESSAGE_MASK_OLD | NMEA_MESSAGE_MASK_SINGLE)
97:
98: #define NMEA_BAUDRATE_MASK 0x70
99: #define NMEA_BAUDRATE_SHIFT 4
100:
101: /*
102: * Definitions
103: */
104: #define DEVICE "/dev/gps%d" /* GPS serial device */
105: #define PPSDEV "/dev/gpspps%d" /* PPSAPI device override */
106: #define SPEED232 B4800 /* uart speed (4800 bps) */
107: #define PRECISION (-9) /* precision assumed (about 2 ms) */
108: #define PPS_PRECISION (-20) /* precision assumed (about 1 us) */
109: #define REFID "GPS\0" /* reference id */
110: #define DESCRIPTION "NMEA GPS Clock" /* who we are */
111: #ifndef O_NOCTTY
112: #define M_NOCTTY 0
113: #else
114: #define M_NOCTTY O_NOCTTY
115: #endif
116: #ifndef O_NONBLOCK
117: #define M_NONBLOCK 0
118: #else
119: #define M_NONBLOCK O_NONBLOCK
120: #endif
121: #define PPSOPENMODE (O_RDWR | M_NOCTTY | M_NONBLOCK)
122:
123: /* NMEA sentence array indexes for those we use */
124: #define NMEA_GPRMC 0 /* recommended min. nav. */
125: #define NMEA_GPGGA 1 /* fix and quality */
126: #define NMEA_GPGLL 2 /* geo. lat/long */
127: #define NMEA_GPZDA 3 /* date/time */
128: /*
129: * $GPZDG is a proprietary sentence that violates the spec, by not
130: * using $P and an assigned company identifier to prefix the sentence
131: * identifier. When used with this driver, the system needs to be
132: * isolated from other NTP networks, as it operates in GPS time, not
133: * UTC as is much more common. GPS time is >15 seconds different from
134: * UTC due to not respecting leap seconds since 1970 or so. Other
135: * than the different timebase, $GPZDG is similar to $GPZDA.
136: */
137: #define NMEA_GPZDG 4
138: #define NMEA_ARRAY_SIZE (NMEA_GPZDG + 1)
139:
140: /*
141: * Sentence selection mode bits
142: */
143: #define USE_ALL 0 /* any/all */
144: #define USE_GPRMC 1
145: #define USE_GPGGA 2
146: #define USE_GPGLL 4
147: #define USE_GPZDA_ZDG 8 /* affects both */
148:
149: /* mapping from sentence index to controlling mode bit */
150: u_char sentence_mode[NMEA_ARRAY_SIZE] =
151: {
152: USE_GPRMC,
153: USE_GPGGA,
154: USE_GPGLL,
155: USE_GPZDA_ZDG,
156: USE_GPZDA_ZDG
157: };
158:
159: /*
160: * Unit control structure
161: */
162: struct nmeaunit {
163: #ifdef HAVE_PPSAPI
164: struct refclock_atom atom; /* PPSAPI structure */
165: int ppsapi_tried; /* attempt PPSAPI once */
166: int ppsapi_lit; /* time_pps_create() worked */
167: int ppsapi_fd; /* fd used with PPSAPI */
168: int ppsapi_gate; /* allow edge detection processing */
169: int tcount; /* timecode sample counter */
170: int pcount; /* PPS sample counter */
171: #endif /* HAVE_PPSAPI */
172: l_fp tstamp; /* timestamp of last poll */
173: int gps_time; /* 0 UTC, 1 GPS time */
174: /* per sentence checksum seen flag */
175: struct calendar used; /* hh:mm:ss of used sentence */
176: u_char cksum_seen[NMEA_ARRAY_SIZE];
177: };
178:
179: /*
180: * Function prototypes
181: */
182: static int nmea_start (int, struct peer *);
183: static void nmea_shutdown (int, struct peer *);
184: static void nmea_receive (struct recvbuf *);
185: static void nmea_poll (int, struct peer *);
186: #ifdef HAVE_PPSAPI
187: static void nmea_control (int, struct refclockstat *,
188: struct refclockstat *, struct peer *);
189: static void nmea_timer (int, struct peer *);
190: #define NMEA_CONTROL nmea_control
191: #define NMEA_TIMER nmea_timer
192: #else
193: #define NMEA_CONTROL noentry
194: #define NMEA_TIMER noentry
195: #endif /* HAVE_PPSAPI */
196: static void gps_send (int, const char *, struct peer *);
197: static char * field_parse (char *, int);
198: static int nmea_checksum_ok(const char *);
199: static void nmea_day_unfold(struct calendar*);
200: static void nmea_century_unfold(struct calendar*);
201:
202: /*
203: * Transfer vector
204: */
205: struct refclock refclock_nmea = {
206: nmea_start, /* start up driver */
207: nmea_shutdown, /* shut down driver */
208: nmea_poll, /* transmit poll message */
209: NMEA_CONTROL, /* fudge control */
210: noentry, /* initialize driver */
211: noentry, /* buginfo */
212: NMEA_TIMER /* called once per second */
213: };
214:
215: /*
216: * nmea_start - open the GPS devices and initialize data for processing
217: */
218: static int
219: nmea_start(
220: int unit,
221: struct peer *peer
222: )
223: {
224: register struct nmeaunit *up;
225: struct refclockproc *pp;
226: int fd;
227: char device[20];
228: int baudrate;
229: char *baudtext;
230:
231: pp = peer->procptr;
232:
233: /*
234: * Open serial port. Use CLK line discipline, if available.
235: */
236: snprintf(device, sizeof(device), DEVICE, unit);
237:
238: /*
239: * Opening the serial port with appropriate baudrate
240: * based on the value of bit 4/5/6
241: */
242: switch ((peer->ttl & NMEA_BAUDRATE_MASK) >> NMEA_BAUDRATE_SHIFT) {
243: case 0:
244: case 6:
245: case 7:
246: default:
247: baudrate = SPEED232;
248: baudtext = "4800";
249: break;
250: case 1:
251: baudrate = B9600;
252: baudtext = "9600";
253: break;
254: case 2:
255: baudrate = B19200;
256: baudtext = "19200";
257: break;
258: case 3:
259: baudrate = B38400;
260: baudtext = "38400";
261: break;
262: #ifdef B57600
263: case 4:
264: baudrate = B57600;
265: baudtext = "57600";
266: break;
267: #endif
268: #ifdef B115200
269: case 5:
270: baudrate = B115200;
271: baudtext = "115200";
272: break;
273: #endif
274: }
275:
276: fd = refclock_open(device, baudrate, LDISC_CLK);
277:
278: if (fd <= 0) {
279: #ifdef HAVE_READLINK
280: /* nmead support added by Jon Miner (cp_n18@yahoo.com)
281: *
282: * See http://home.hiwaay.net/~taylorc/gps/nmea-server/
283: * for information about nmead
284: *
285: * To use this, you need to create a link from /dev/gpsX
286: * to the server:port where nmead is running. Something
287: * like this:
288: *
289: * ln -s server:port /dev/gps1
290: */
291: char buffer[80];
292: char *nmea_host, *nmea_tail;
293: int nmea_port;
294: int len;
295: struct hostent *he;
296: struct protoent *p;
297: struct sockaddr_in so_addr;
298:
299: if ((len = readlink(device,buffer,sizeof(buffer))) == -1)
300: return(0);
301: buffer[len] = 0;
302:
303: if ((nmea_host = strtok(buffer,":")) == NULL)
304: return(0);
305: if ((nmea_tail = strtok(NULL,":")) == NULL)
306: return(0);
307:
308: nmea_port = atoi(nmea_tail);
309:
310: if ((he = gethostbyname(nmea_host)) == NULL)
311: return(0);
312: if ((p = getprotobyname("tcp")) == NULL)
313: return(0);
314: memset(&so_addr, 0, sizeof(so_addr));
315: so_addr.sin_family = AF_INET;
316: so_addr.sin_port = htons(nmea_port);
317: so_addr.sin_addr = *((struct in_addr *) he->h_addr);
318:
319: if ((fd = socket(PF_INET,SOCK_STREAM,p->p_proto)) == -1)
320: return(0);
321: if (connect(fd,(struct sockaddr *)&so_addr, sizeof(so_addr)) == -1) {
322: close(fd);
323: return (0);
324: }
325: #else
326: pp->io.fd = -1;
327: return (0);
328: #endif
329: }
330:
331: msyslog(LOG_NOTICE, "%s serial %s open at %s bps",
332: refnumtoa(&peer->srcadr), device, baudtext);
333:
334: /*
335: * Allocate and initialize unit structure
336: */
337: up = emalloc(sizeof(*up));
338: memset(up, 0, sizeof(*up));
339: pp->io.clock_recv = nmea_receive;
340: pp->io.srcclock = (caddr_t)peer;
341: pp->io.datalen = 0;
342: pp->io.fd = fd;
343: if (!io_addclock(&pp->io)) {
344: pp->io.fd = -1;
345: close(fd);
346: free(up);
347: return (0);
348: }
349: pp->unitptr = (caddr_t)up;
350:
351: /*
352: * Initialize miscellaneous variables
353: */
354: peer->precision = PRECISION;
355: pp->clockdesc = DESCRIPTION;
356: memcpy(&pp->refid, REFID, 4);
357:
358: gps_send(fd,"$PMOTG,RMC,0000*1D\r\n", peer);
359:
360: return (1);
361: }
362:
363:
364: /*
365: * nmea_shutdown - shut down a GPS clock
366: *
367: * NOTE this routine is called after nmea_start() returns failure,
368: * as well as during a normal shutdown due to ntpq :config unpeer.
369: */
370: static void
371: nmea_shutdown(
372: int unit,
373: struct peer *peer
374: )
375: {
376: register struct nmeaunit *up;
377: struct refclockproc *pp;
378:
379: UNUSED_ARG(unit);
380:
381: pp = peer->procptr;
382: up = (struct nmeaunit *)pp->unitptr;
383: if (up != NULL) {
384: #ifdef HAVE_PPSAPI
385: if (up->ppsapi_lit) {
386: time_pps_destroy(up->atom.handle);
387: if (up->ppsapi_fd != pp->io.fd)
388: close(up->ppsapi_fd);
389: }
390: #endif
391: free(up);
392: }
393: if (-1 != pp->io.fd)
394: io_closeclock(&pp->io);
395: }
396:
397: /*
398: * nmea_control - configure fudge params
399: */
400: #ifdef HAVE_PPSAPI
401: static void
402: nmea_control(
403: int unit,
404: struct refclockstat *in_st,
405: struct refclockstat *out_st,
406: struct peer *peer
407: )
408: {
409: char device[32];
410: register struct nmeaunit *up;
411: struct refclockproc *pp;
412: int pps_fd;
413:
414: UNUSED_ARG(in_st);
415: UNUSED_ARG(out_st);
416:
417: pp = peer->procptr;
418: up = (struct nmeaunit *)pp->unitptr;
419:
420: if (!(CLK_FLAG1 & pp->sloppyclockflag)) {
421: if (!up->ppsapi_tried)
422: return;
423: up->ppsapi_tried = 0;
424: if (!up->ppsapi_lit)
425: return;
426: peer->flags &= ~FLAG_PPS;
427: peer->precision = PRECISION;
428: time_pps_destroy(up->atom.handle);
429: if (up->ppsapi_fd != pp->io.fd)
430: close(up->ppsapi_fd);
431: up->atom.handle = 0;
432: up->ppsapi_lit = 0;
433: up->ppsapi_fd = -1;
434: return;
435: }
436:
437: if (up->ppsapi_tried)
438: return;
439: /*
440: * Light up the PPSAPI interface.
441: */
442: up->ppsapi_tried = 1;
443:
444: /*
445: * if /dev/gpspps$UNIT can be opened that will be used for
446: * PPSAPI. Otherwise, the GPS serial device /dev/gps$UNIT
447: * already opened is used for PPSAPI as well.
448: */
449: snprintf(device, sizeof(device), PPSDEV, unit);
450:
451: pps_fd = open(device, PPSOPENMODE, S_IRUSR | S_IWUSR);
452:
453: if (-1 == pps_fd)
454: pps_fd = pp->io.fd;
455:
456: if (refclock_ppsapi(pps_fd, &up->atom)) {
457: up->ppsapi_lit = 1;
458: up->ppsapi_fd = pps_fd;
459: /* prepare to use the PPS API for our own purposes now. */
460: refclock_params(pp->sloppyclockflag, &up->atom);
461: return;
462: }
463:
464: NLOG(NLOG_CLOCKINFO)
465: msyslog(LOG_WARNING, "%s flag1 1 but PPSAPI fails",
466: refnumtoa(&peer->srcadr));
467: }
468: #endif /* HAVE_PPSAPI */
469:
470:
471: /*
472: * nmea_timer - called once per second, fetches PPS
473: * timestamp and stuffs in median filter.
474: */
475: #ifdef HAVE_PPSAPI
476: static void
477: nmea_timer(
478: int unit,
479: struct peer * peer
480: )
481: {
482: struct nmeaunit *up;
483: struct refclockproc *pp;
484:
485: UNUSED_ARG(unit);
486:
487: pp = peer->procptr;
488: up = (struct nmeaunit *)pp->unitptr;
489:
490: if (up->ppsapi_lit && up->ppsapi_gate &&
491: refclock_pps(peer, &up->atom, pp->sloppyclockflag) > 0) {
492: up->pcount++,
493: peer->flags |= FLAG_PPS;
494: peer->precision = PPS_PRECISION;
495: }
496: }
497: #endif /* HAVE_PPSAPI */
498:
499: #ifdef HAVE_PPSAPI
500: /*
501: * This function is used to correlate a receive time stamp and a
502: * reference time with a PPS edge time stamp. It applies the necessary
503: * fudges (fudge1 for PPS, fudge2 for receive time) and then tries to
504: * move the receive time stamp to the corresponding edge. This can
505: * warp into future, if a transmission delay of more than 500ms is not
506: * compensated with a corresponding fudge time2 value, because then
507: * the next PPS edge is nearer than the last. (Similiar to what the
508: * PPS ATOM driver does, but we deal with full time stamps here, not
509: * just phase shift information.) Likewise, a negative fudge time2
510: * value must be used if the reference time stamp correlates with the
511: * *following* PPS pulse.
512: *
513: * Note that the receive time fudge value only needs to move the receive
514: * stamp near a PPS edge but that close proximity is not required;
515: * +/-100ms precision should be enough. But since the fudge value will
516: * probably also be used to compensate the transmission delay when no PPS
517: * edge can be related to the time stamp, it's best to get it as close
518: * as possible.
519: *
520: * It should also be noted that the typical use case is matching to
521: * the preceeding edge, as most units relate their sentences to the
522: * current second.
523: *
524: * The function returns PPS_RELATE_NONE (0) if no PPS edge correlation
525: * can be fixed; PPS_RELATE_EDGE (1) when a PPS edge could be fixed, but
526: * the distance to the reference time stamp is too big (exceeds +/-400ms)
527: * and the ATOM driver PLL cannot be used to fix the phase; and
528: * PPS_RELATE_PHASE (2) when the ATOM driver PLL code can be used.
529: *
530: * On output, the receive time stamp is replaced with the
531: * corresponding PPS edge time if a fix could be made; the PPS fudge
532: * is updated to reflect the proper fudge time to apply. (This implies
533: * that 'refclock_process_f()' must be used!)
534: */
535: #define PPS_RELATE_NONE 0 /* no pps correlation possible */
536: #define PPS_RELATE_EDGE 1 /* recv time fixed, no phase lock */
537: #define PPS_RELATE_PHASE 2 /* recv time fixed, phase lock ok */
538:
539: static int
540: refclock_ppsrelate(
541: const struct refclockproc *pp , /* for sanity */
542: const struct refclock_atom *ap , /* for PPS io */
543: const l_fp *reftime ,
544: l_fp *rd_stamp, /* i/o read stamp */
545: double pp_fudge, /* pps fudge */
546: double *rd_fudge) /* i/o read fudge */
547: {
548: pps_info_t pps_info;
549: struct timespec timeout;
550: l_fp pp_stamp, pp_delta;
551: double delta, idelta;
552:
553: if (pp->leap == LEAP_NOTINSYNC)
554: return PPS_RELATE_NONE; /* clock is insane, no chance */
555:
556: memset(&timeout, 0, sizeof(timeout));
557: memset(&pps_info, 0, sizeof(pps_info_t));
558:
559: if (time_pps_fetch(ap->handle, PPS_TSFMT_TSPEC,
560: &pps_info, &timeout) < 0)
561: return PPS_RELATE_NONE;
562:
563: /* get last active PPS edge before receive */
564: if (ap->pps_params.mode & PPS_CAPTUREASSERT)
565: timeout = pps_info.assert_timestamp;
566: else if (ap->pps_params.mode & PPS_CAPTURECLEAR)
567: timeout = pps_info.clear_timestamp;
568: else
569: return PPS_RELATE_NONE;
570:
571: /* get delta between receive time and PPS time */
572: TIMESPECTOTS(&timeout, &pp_stamp);
573: pp_delta = *rd_stamp;
574: L_SUB(&pp_delta, &pp_stamp);
575: LFPTOD(&pp_delta, delta);
576: delta += pp_fudge - *rd_fudge;
577: if (fabs(delta) > 1.5)
578: return PPS_RELATE_NONE; /* PPS timeout control */
579:
580: /* eventually warp edges, check phase */
581: idelta = floor(delta + 0.5);
582: pp_fudge -= idelta;
583: delta -= idelta;
584: if (fabs(delta) > 0.45)
585: return PPS_RELATE_NONE; /* dead band control */
586:
587: /* we actually have a PPS edge to relate with! */
588: *rd_stamp = pp_stamp;
589: *rd_fudge = pp_fudge;
590:
591: /* if whole system out-of-sync, do not try to PLL */
592: if (sys_leap == LEAP_NOTINSYNC)
593: return PPS_RELATE_EDGE; /* cannot PLL with atom code */
594:
595: /* check against reftime if ATOM PLL can be used */
596: pp_delta = *reftime;
597: L_SUB(&pp_delta, &pp_stamp);
598: LFPTOD(&pp_delta, delta);
599: delta += pp_fudge;
600: if (fabs(delta) > 0.45)
601: return PPS_RELATE_EDGE; /* cannot PLL with atom code */
602:
603: /* all checks passed, gets an AAA rating here! */
604: return PPS_RELATE_PHASE; /* can PLL with atom code */
605: }
606: #endif /* HAVE_PPSAPI */
607:
608: /*
609: * nmea_receive - receive data from the serial interface
610: */
611: static void
612: nmea_receive(
613: struct recvbuf *rbufp
614: )
615: {
616: register struct nmeaunit *up;
617: struct refclockproc *pp;
618: struct peer *peer;
619: char *cp, *dp, *msg;
620: u_char sentence;
621: /* Use these variables to hold data until we decide its worth
622: * keeping */
623: char rd_lastcode[BMAX];
624: l_fp rd_timestamp, reftime;
625: int rd_lencode;
626: double rd_fudge;
627: struct calendar date;
628:
629: /*
630: * Initialize pointers and read the timecode and timestamp
631: */
632: peer = rbufp->recv_peer;
633: pp = peer->procptr;
634: up = (struct nmeaunit *)pp->unitptr;
635:
636: rd_lencode = refclock_gtlin(
637: rbufp,
638: rd_lastcode,
639: sizeof(rd_lastcode),
640: &rd_timestamp);
641:
642: /*
643: * There is a case that a <CR><LF> gives back a "blank" line.
644: * We can't have a well-formed sentence with less than 8 chars.
645: */
646: if (0 == rd_lencode)
647: return;
648:
649: if (rd_lencode < 8) {
650: refclock_report(peer, CEVNT_BADREPLY);
651: return;
652: }
653:
654: DPRINTF(1, ("nmea: gpsread %d %s\n", rd_lencode, rd_lastcode));
655:
656: /*
657: * We check the timecode format and decode its contents. The
658: * we only care about a few of them. The most important being
659: * the $GPRMC format
660: * $GPRMC,hhmmss,a,fddmm.xx,n,dddmmm.xx,w,zz.z,yyy.,ddmmyy,dd,v*CC
661: * mode (0,1,2,3) selects sentence ANY/ALL, RMC, GGA, GLL, ZDA
662: * $GPGLL,3513.8385,S,14900.7851,E,232420.594,A*21
663: * $GPGGA,232420.59,3513.8385,S,14900.7851,E,1,05,3.4,00519,M,,,,*3F
664: * $GPRMC,232418.19,A,3513.8386,S,14900.7853,E,00.0,000.0,121199,12.,E*77
665: *
666: * Defining GPZDA to support Standard Time & Date
667: * sentence. The sentence has the following format
668: *
669: * $--ZDA,HHMMSS.SS,DD,MM,YYYY,TH,TM,*CS<CR><LF>
670: *
671: * Apart from the familiar fields,
672: * 'TH' Time zone Hours
673: * 'TM' Time zone Minutes
674: *
675: * Defining GPZDG to support Accord GPS Clock's custom NMEA
676: * sentence. The sentence has the following format
677: *
678: * $GPZDG,HHMMSS.S,DD,MM,YYYY,AA.BB,V*CS<CR><LF>
679: *
680: * It contains the GPS timestamp valid for next PPS pulse.
681: * Apart from the familiar fields,
682: * 'AA.BB' denotes the signal strength( should be < 05.00 )
683: * 'V' denotes the GPS sync status :
684: * '0' indicates INVALID time,
685: * '1' indicates accuracy of +/-20 ms
686: * '2' indicates accuracy of +/-100 ns
687: */
688:
689: cp = rd_lastcode;
690: if (cp[0] == '$') {
691: /* Allow for GLGGA and GPGGA etc. */
692: msg = cp + 3;
693:
694: if (strncmp(msg, "RMC", 3) == 0)
695: sentence = NMEA_GPRMC;
696: else if (strncmp(msg, "GGA", 3) == 0)
697: sentence = NMEA_GPGGA;
698: else if (strncmp(msg, "GLL", 3) == 0)
699: sentence = NMEA_GPGLL;
700: else if (strncmp(msg, "ZDG", 3) == 0)
701: sentence = NMEA_GPZDG;
702: else if (strncmp(msg, "ZDA", 3) == 0)
703: sentence = NMEA_GPZDA;
704: else
705: return;
706: } else
707: return;
708:
709: /* See if I want to process this message type */
710: if ((peer->ttl & NMEA_MESSAGE_MASK) &&
711: !(peer->ttl & sentence_mode[sentence]))
712: return;
713:
714: /*
715: * $GPZDG provides GPS time not UTC, and the two mix poorly.
716: * Once have processed a $GPZDG, do not process any further
717: * UTC sentences (all but $GPZDG currently).
718: */
719: if (up->gps_time && NMEA_GPZDG != sentence)
720: return;
721:
722: /*
723: * Apparently, older NMEA specifications (which are expensive)
724: * did not require the checksum for all sentences. $GPMRC is
725: * the only one so far identified which has always been required
726: * to include a checksum.
727: *
728: * Today, most NMEA GPS receivers checksum every sentence. To
729: * preserve its error-detection capabilities with modern GPSes
730: * while allowing operation without checksums on all but $GPMRC,
731: * we keep track of whether we've ever seen a checksum on a
732: * given sentence, and if so, reject future checksum failures.
733: */
734: if (nmea_checksum_ok(rd_lastcode)) {
735: up->cksum_seen[sentence] = TRUE;
736: } else if (NMEA_GPRMC == sentence || up->cksum_seen[sentence]) {
737: refclock_report(peer, CEVNT_BADREPLY);
738: return;
739: }
740:
741: cp = rd_lastcode;
742:
743: /* Grab field depending on clock string type */
744: memset(&date, 0, sizeof(date));
745: switch (sentence) {
746:
747: case NMEA_GPRMC:
748: /*
749: * Test for synchronization. Check for quality byte.
750: */
751: dp = field_parse(cp, 2);
752: if (dp[0] != 'A')
753: pp->leap = LEAP_NOTINSYNC;
754: else
755: pp->leap = LEAP_NOWARNING;
756:
757: /* Now point at the time field */
758: dp = field_parse(cp, 1);
759: break;
760:
761: case NMEA_GPGGA:
762: /*
763: * Test for synchronization. Check for quality byte.
764: */
765: dp = field_parse(cp, 6);
766: if (dp[0] == '0')
767: pp->leap = LEAP_NOTINSYNC;
768: else
769: pp->leap = LEAP_NOWARNING;
770:
771: /* Now point at the time field */
772: dp = field_parse(cp, 1);
773: break;
774:
775: case NMEA_GPGLL:
776: /*
777: * Test for synchronization. Check for quality byte.
778: */
779: dp = field_parse(cp, 6);
780: if (dp[0] != 'A')
781: pp->leap = LEAP_NOTINSYNC;
782: else
783: pp->leap = LEAP_NOWARNING;
784:
785: /* Now point at the time field */
786: dp = field_parse(cp, 5);
787: break;
788:
789: case NMEA_GPZDG:
790: /* For $GPZDG check for validity of GPS time. */
791: dp = field_parse(cp, 6);
792: if (dp[0] == '0')
793: pp->leap = LEAP_NOTINSYNC;
794: else
795: pp->leap = LEAP_NOWARNING;
796: /* fall through to NMEA_GPZDA */
797:
798: case NMEA_GPZDA:
799: if (NMEA_GPZDA == sentence)
800: pp->leap = LEAP_NOWARNING;
801:
802: /* Now point at the time field */
803: dp = field_parse(cp, 1);
804: break;
805:
806: default:
807: return;
808: }
809:
810: /*
811: * Check time code format of NMEA
812: */
813: if (!isdigit((int)dp[0]) ||
814: !isdigit((int)dp[1]) ||
815: !isdigit((int)dp[2]) ||
816: !isdigit((int)dp[3]) ||
817: !isdigit((int)dp[4]) ||
818: !isdigit((int)dp[5])) {
819:
820: DPRINTF(1, ("NMEA time code %c%c%c%c%c%c non-numeric",
821: dp[0], dp[1], dp[2], dp[3], dp[4], dp[5]));
822: refclock_report(peer, CEVNT_BADTIME);
823: return;
824: }
825:
826: /*
827: * Convert time and check values.
828: */
829: date.hour = ((dp[0] - '0') * 10) + dp[1] - '0';
830: date.minute = ((dp[2] - '0') * 10) + dp[3] - '0';
831: date.second = ((dp[4] - '0') * 10) + dp[5] - '0';
832: /*
833: * Default to 0 milliseconds, if decimal convert milliseconds in
834: * one, two or three digits
835: */
836: pp->nsec = 0;
837: if (dp[6] == '.') {
838: if (isdigit((int)dp[7])) {
839: pp->nsec = (dp[7] - '0') * 100000000;
840: if (isdigit((int)dp[8])) {
841: pp->nsec += (dp[8] - '0') * 10000000;
842: if (isdigit((int)dp[9])) {
843: pp->nsec += (dp[9] - '0') * 1000000;
844: }
845: }
846: }
847: }
848:
849: if (date.hour > 23 || date.minute > 59 ||
850: date.second > 59 || pp->nsec > 1000000000) {
851:
852: DPRINTF(1, ("NMEA hour/min/sec/nsec range %02d:%02d:%02d.%09ld\n",
853: pp->hour, pp->minute, pp->second, pp->nsec));
854: refclock_report(peer, CEVNT_BADTIME);
855: return;
856: }
857:
858: /*
859: * Used only the first recognized sentence each second.
860: */
861: if (date.hour == up->used.hour &&
862: date.minute == up->used.minute &&
863: date.second == up->used.second)
864: return;
865:
866: pp->lencode = (u_short)rd_lencode;
867: memcpy(pp->a_lastcode, rd_lastcode, pp->lencode + 1);
868: up->tstamp = rd_timestamp;
869: pp->lastrec = up->tstamp;
870: DPRINTF(1, ("nmea: timecode %d %s\n", pp->lencode, pp->a_lastcode));
871:
872: /*
873: * Convert date and check values.
874: */
875: if (NMEA_GPRMC == sentence) {
876:
877: dp = field_parse(cp,9);
878: date.monthday = 10 * (dp[0] - '0') + (dp[1] - '0');
879: date.month = 10 * (dp[2] - '0') + (dp[3] - '0');
880: date.year = 10 * (dp[4] - '0') + (dp[5] - '0');
881: nmea_century_unfold(&date);
882:
883: } else if (NMEA_GPZDA == sentence || NMEA_GPZDG == sentence) {
884:
885: dp = field_parse(cp, 2);
886: date.monthday = 10 * (dp[0] - '0') + (dp[1] - '0');
887: dp = field_parse(cp, 3);
888: date.month = 10 * (dp[0] - '0') + (dp[1] - '0');
889: dp = field_parse(cp, 4);
890: date.year = 1000 * (dp[0] - '0') + 100 * (dp[1] - '0')
891: + 10 * (dp[2] - '0') + (dp[3] - '0');
892:
893: } else
894: nmea_day_unfold(&date);
895:
896: if (date.month < 1 || date.month > 12 ||
897: date.monthday < 1 || date.monthday > 31) {
898: refclock_report(peer, CEVNT_BADDATE);
899: return;
900: }
901:
902: up->used.hour = date.hour;
903: up->used.minute = date.minute;
904: up->used.second = date.second;
905:
906: /*
907: * If "fudge 127.127.20.__ flag4 1" is configured in ntp.conf,
908: * remove the location and checksum from the NMEA sentence
909: * recorded as the last timecode and visible to remote users
910: * with:
911: *
912: * ntpq -c clockvar <server>
913: *
914: * Note that this also removes the location from the clockstats
915: * log (if it is enabled). Some NTP operators monitor their
916: * NMEA GPS using the change in location in clockstats over
917: * time as as a proxy for the quality of GPS reception and
918: * thereby time reported.
919: */
920: if (CLK_FLAG4 & pp->sloppyclockflag) {
921: /*
922: * Start by pointing cp and dp at the fields with
923: * longitude and latitude in the last timecode.
924: */
925: switch (sentence) {
926:
927: case NMEA_GPGLL:
928: cp = field_parse(pp->a_lastcode, 1);
929: dp = field_parse(cp, 2);
930: break;
931:
932: case NMEA_GPGGA:
933: cp = field_parse(pp->a_lastcode, 2);
934: dp = field_parse(cp, 2);
935: break;
936:
937: case NMEA_GPRMC:
938: cp = field_parse(pp->a_lastcode, 3);
939: dp = field_parse(cp, 2);
940: break;
941:
942: case NMEA_GPZDA:
943: case NMEA_GPZDG:
944: default:
945: cp = dp = NULL;
946: }
947:
948: /* Blank the entire latitude & longitude. */
949: while (cp) {
950: while (',' != *cp) {
951: if ('.' != *cp)
952: *cp = '_';
953: cp++;
954: }
955:
956: /* Longitude at cp then latitude at dp */
957: if (cp < dp)
958: cp = dp;
959: else
960: cp = NULL;
961: }
962:
963: /* Blank the checksum, the last two characters */
964: if (dp) {
965: cp = pp->a_lastcode + pp->lencode - 2;
966: if (0 == cp[2])
967: cp[0] = cp[1] = '_';
968: }
969:
970: }
971:
972: /*
973: * Get the reference time stamp from the calendar buffer.
974: * Process the new sample in the median filter and determine
975: * the timecode timestamp, but only if the PPS is not in
976: * control.
977: */
978: rd_fudge = pp->fudgetime2;
979: date.yearday = 0; /* make sure it's not used */
980: DTOLFP(pp->nsec * 1.0e-9, &reftime);
981: reftime.l_ui += caltontp(&date);
982:
983: /* $GPZDG postprocessing first... */
984: if (NMEA_GPZDG == sentence) {
985: /*
986: * Note if we're only using GPS timescale from now on.
987: */
988: if (!up->gps_time) {
989: up->gps_time = 1;
990: NLOG(NLOG_CLOCKINFO)
991: msyslog(LOG_INFO, "%s using only $GPZDG",
992: refnumtoa(&peer->srcadr));
993: }
994: /*
995: * $GPZDG indicates the second after the *next* PPS
996: * pulse. So we remove 1 second from the reference
997: * time now.
998: */
999: reftime.l_ui--;
1000: }
1001:
1002: #ifdef HAVE_PPSAPI
1003: up->tcount++;
1004: /*
1005: * If we have PPS running, we try to associate the sentence with
1006: * the last active edge of the PPS signal.
1007: */
1008: if (up->ppsapi_lit)
1009: switch (refclock_ppsrelate(pp, &up->atom, &reftime,
1010: &rd_timestamp, pp->fudgetime1,
1011: &rd_fudge))
1012: {
1013: case PPS_RELATE_EDGE:
1014: up->ppsapi_gate = 0;
1015: break;
1016: case PPS_RELATE_PHASE:
1017: up->ppsapi_gate = 1;
1018: break;
1019: default:
1020: break;
1021: }
1022: else
1023: up->ppsapi_gate = 0;
1024:
1025: if (up->ppsapi_gate && (peer->flags & FLAG_PPS))
1026: return;
1027: #endif /* HAVE_PPSAPI */
1028:
1029: refclock_process_offset(pp, reftime, rd_timestamp, rd_fudge);
1030: }
1031:
1032:
1033: /*
1034: * nmea_poll - called by the transmit procedure
1035: *
1036: * We go to great pains to avoid changing state here, since there may be
1037: * more than one eavesdropper receiving the same timecode.
1038: */
1039: static void
1040: nmea_poll(
1041: int unit,
1042: struct peer *peer
1043: )
1044: {
1045: register struct nmeaunit *up;
1046: struct refclockproc *pp;
1047:
1048: pp = peer->procptr;
1049: up = (struct nmeaunit *)pp->unitptr;
1050:
1051: /*
1052: * Process median filter samples. If none received, declare a
1053: * timeout and keep going.
1054: */
1055: #ifdef HAVE_PPSAPI
1056: if (up->pcount == 0) {
1057: peer->flags &= ~FLAG_PPS;
1058: peer->precision = PRECISION;
1059: }
1060: if (up->tcount == 0) {
1061: pp->coderecv = pp->codeproc;
1062: refclock_report(peer, CEVNT_TIMEOUT);
1063: return;
1064: }
1065: up->pcount = up->tcount = 0;
1066: #else /* HAVE_PPSAPI */
1067: if (pp->coderecv == pp->codeproc) {
1068: refclock_report(peer, CEVNT_TIMEOUT);
1069: return;
1070: }
1071: #endif /* HAVE_PPSAPI */
1072:
1073: pp->polls++;
1074: pp->lastref = pp->lastrec;
1075: refclock_receive(peer);
1076: record_clock_stats(&peer->srcadr, pp->a_lastcode);
1077:
1078: /*
1079: * usually nmea_receive can get a timestamp every second,
1080: * but at least one Motorola unit needs prompting each
1081: * time.
1082: */
1083:
1084: gps_send(pp->io.fd,"$PMOTG,RMC,0000*1D\r\n", peer);
1085: }
1086:
1087:
1088: /*
1089: *
1090: * gps_send(fd,cmd, peer) Sends a command to the GPS receiver.
1091: * as gps_send(fd,"rqts,u\r", peer);
1092: *
1093: * We don't currently send any data, but would like to send
1094: * RTCM SC104 messages for differential positioning. It should
1095: * also give us better time. Without a PPS output, we're
1096: * Just fooling ourselves because of the serial code paths
1097: *
1098: */
1099: static void
1100: gps_send(
1101: int fd,
1102: const char *cmd,
1103: struct peer *peer
1104: )
1105: {
1106: if (write(fd, cmd, strlen(cmd)) == -1) {
1107: refclock_report(peer, CEVNT_FAULT);
1108: }
1109: }
1110:
1111:
1112: static char *
1113: field_parse(
1114: char *cp,
1115: int fn
1116: )
1117: {
1118: char *tp;
1119: int i = fn;
1120:
1121: for (tp = cp; i && *tp; tp++)
1122: if (*tp == ',')
1123: i--;
1124:
1125: return tp;
1126: }
1127:
1128:
1129: /*
1130: * nmea_checksum_ok verifies 8-bit XOR checksum is correct then returns 1
1131: *
1132: * format is $XXXXX,1,2,3,4*ML
1133: *
1134: * 8-bit XOR of characters between $ and * noninclusive is transmitted
1135: * in last two chars M and L holding most and least significant nibbles
1136: * in hex representation such as:
1137: *
1138: * $GPGLL,5057.970,N,00146.110,E,142451,A*27
1139: * $GPVTG,089.0,T,,,15.2,N,,*7F
1140: */
1141: int
1142: nmea_checksum_ok(
1143: const char *sentence
1144: )
1145: {
1146: u_char my_cs;
1147: u_long input_cs;
1148: const char *p;
1149:
1150: my_cs = 0;
1151: p = sentence;
1152:
1153: if ('$' != *p++)
1154: return 0;
1155:
1156: for ( ; *p && '*' != *p; p++) {
1157:
1158: my_cs ^= *p;
1159: }
1160:
1161: if ('*' != *p++)
1162: return 0;
1163:
1164: if (0 == p[0] || 0 == p[1] || 0 != p[2])
1165: return 0;
1166:
1167: if (0 == hextoint(p, &input_cs))
1168: return 0;
1169:
1170: if (my_cs != input_cs)
1171: return 0;
1172:
1173: return 1;
1174: }
1175:
1176: /*
1177: * -------------------------------------------------------------------
1178: * funny calendar-oriented stuff -- a bit hard to grok.
1179: * -------------------------------------------------------------------
1180: */
1181: /*
1182: * Do a periodic unfolding of a truncated value around a given pivot
1183: * value.
1184: * The result r will hold to pivot <= r < pivot+period (period>0) or
1185: * pivot+period < r <= pivot (period < 0) and value % period == r % period,
1186: * using floor division convention.
1187: */
1188: static time_t
1189: nmea_periodic_unfold(
1190: time_t pivot,
1191: time_t value,
1192: time_t period)
1193: {
1194: /*
1195: * This will only work as long as 'value - pivot%period' does
1196: * not create a signed overflow condition.
1197: */
1198: value = (value - (pivot % period)) % period;
1199: if (value && (value ^ period) < 0)
1200: value += period;
1201: return pivot + value;
1202: }
1203:
1204: /*
1205: * Unfold a time-of-day (seconds since midnight) around the current
1206: * system time in a manner that guarantees an absolute difference of
1207: * less than 12hrs.
1208: *
1209: * This function is used for NMEA sentences that contain no date
1210: * information. This requires the system clock to be in +/-12hrs
1211: * around the true time, or the clock will synchronize the system 1day
1212: * off if not augmented with a time sources that also provide the
1213: * necessary date information.
1214: *
1215: * The function updates the refclockproc structure is also uses as
1216: * input to fetch the time from.
1217: */
1218: static void
1219: nmea_day_unfold(
1220: struct calendar *jd)
1221: {
1222: time_t value, pivot;
1223: struct tm *tdate;
1224:
1225: value = ((time_t)jd->hour * MINSPERHR
1226: + (time_t)jd->minute) * SECSPERMIN
1227: + (time_t)jd->second;
1228: pivot = time(NULL) - SECSPERDAY/2;
1229:
1230: value = nmea_periodic_unfold(pivot, value, SECSPERDAY);
1231: tdate = gmtime(&value);
1232: if (tdate) {
1233: jd->year = tdate->tm_year + 1900;
1234: jd->yearday = tdate->tm_yday + 1;
1235: jd->month = tdate->tm_mon + 1;
1236: jd->monthday = tdate->tm_mday;
1237: jd->hour = tdate->tm_hour;
1238: jd->minute = tdate->tm_min;
1239: jd->second = tdate->tm_sec;
1240: } else {
1241: jd->year = 0;
1242: jd->yearday = 0;
1243: jd->month = 0;
1244: jd->monthday = 0;
1245: }
1246: }
1247:
1248: /*
1249: * Unfold a 2-digit year into full year spec around the current year
1250: * of the system time. This requires the system clock to be in -79/+19
1251: * years around the true time, or the result will be off by
1252: * 100years. The assymetric behaviour was chosen to enable inital sync
1253: * for systems that do not have a battery-backup-clock and start with
1254: * a date that is typically years in the past.
1255: *
1256: * The function updates the calendar structure that is also used as
1257: * input to fetch the year from.
1258: */
1259: static void
1260: nmea_century_unfold(
1261: struct calendar *jd)
1262: {
1263: time_t pivot_time;
1264: struct tm *pivot_date;
1265: time_t pivot_year;
1266:
1267: /* get warp limit and century start of pivot from system time */
1268: pivot_time = time(NULL);
1269: pivot_date = gmtime(&pivot_time);
1270: pivot_year = pivot_date->tm_year + 1900 - 20;
1271: jd->year = nmea_periodic_unfold(pivot_year, jd->year, 100);
1272: }
1273:
1274: #else
1275: int refclock_nmea_bs;
1276: #endif /* REFCLOCK && CLOCK_NMEA */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_nmea.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