![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_palisade.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|
Return to refclock_palisade.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd |
1.1 misho 1: /*
2: * This software was developed by the Software and Component Technologies
3: * group of Trimble Navigation, Ltd.
4: *
5: * Copyright (c) 1997, 1998, 1999, 2000 Trimble Navigation Ltd.
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by Trimble Navigation, Ltd.
19: * 4. The name of Trimble Navigation Ltd. may not be used to endorse or
20: * promote products derived from this software without specific prior
21: * written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY TRIMBLE NAVIGATION LTD. ``AS IS'' AND
24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26: * ARE DISCLAIMED. IN NO EVENT SHALL TRIMBLE NAVIGATION LTD. BE LIABLE
27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33: * SUCH DAMAGE.
34: */
35:
36: /*
37: * refclock_palisade - clock driver for the Trimble Palisade GPS
38: * timing receiver
39: *
40: * For detailed information on this program, please refer to the html
41: * Refclock 29 page accompanying the NTP distribution.
42: *
43: * for questions / bugs / comments, contact:
44: * sven_dietrich@trimble.com
45: *
46: * Sven-Thorsten Dietrich
47: * 645 North Mary Avenue
48: * Post Office Box 3642
49: * Sunnyvale, CA 94088-3642
50: *
51: * Version 2.45; July 14, 1999
52: *
53: *
54: *
55: * 31/03/06: Added support for Thunderbolt GPS Disciplined Clock.
56: * Contact: Fernando Pablo Hauscarriaga
57: * E-mail: fernandoph@iar.unlp.edu.ar
58: * Home page: www.iar.unlp.edu.ar/~fernandoph
59: * Instituto Argentino de Radioastronomia
60: * www.iar.unlp.edu.ar
61: *
62: * 14/01/07: Conditinal compilation for Thunderbolt support no longer needed
63: * now we use mode 2 for decode thunderbolt packets.
64: * Fernando P. Hauscarriaga
65: *
66: * 30/08/09: Added support for Trimble Acutime Gold Receiver.
67: * Fernando P. Hauscarriaga (fernandoph@iar.unlp.edu.ar)
68: */
69:
70: #ifdef HAVE_CONFIG_H
71: # include "config.h"
72: #endif
73:
74: #if defined(REFCLOCK) && defined(CLOCK_PALISADE)
75:
76: #ifdef SYS_WINNT
77: extern int async_write(int, const void *, unsigned int);
78: #undef write
79: #define write(fd, data, octets) async_write(fd, data, octets)
80: #endif
81:
82: #include "refclock_palisade.h"
83: /* Table to get from month to day of the year */
84: const int days_of_year [12] = {
85: 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
86: };
87:
88: #ifdef DEBUG
89: const char * Tracking_Status[15][15] = {
90: { "Doing Fixes\0" }, { "Good 1SV\0" }, { "Approx. 1SV\0" },
91: {"Need Time\0" }, { "Need INIT\0" }, { "PDOP too High\0" },
92: { "Bad 1SV\0" }, { "0SV Usable\0" }, { "1SV Usable\0" },
93: { "2SV Usable\0" }, { "3SV Usable\0" }, { "No Integrity\0" },
94: { "Diff Corr\0" }, { "Overdet Clock\0" }, { "Invalid\0" } };
95: #endif
96:
97: /*
98: * Transfer vector
99: */
100: struct refclock refclock_palisade = {
101: palisade_start, /* start up driver */
102: palisade_shutdown, /* shut down driver */
103: palisade_poll, /* transmit poll message */
104: noentry, /* not used */
105: noentry, /* initialize driver (not used) */
106: noentry, /* not used */
107: NOFLAGS /* not used */
108: };
109:
110: int day_of_year (char *dt);
111:
112: /* Extract the clock type from the mode setting */
113: #define CLK_TYPE(x) ((int)(((x)->ttl) & 0x7F))
114:
115: /* Supported clock types */
116: #define CLK_TRIMBLE 0 /* Trimble Palisade */
117: #define CLK_PRAECIS 1 /* Endrun Technologies Praecis */
118: #define CLK_THUNDERBOLT 2 /* Trimble Thunderbolt GPS Receiver */
119: #define CLK_ACUTIME 3 /* Trimble Acutime Gold */
120: #define CLK_ACUTIMEB 4 /* Trimble Actutime Gold Port B */
121:
122: int praecis_msg;
123: static void praecis_parse(struct recvbuf *rbufp, struct peer *peer);
124:
125: /* These routines are for sending packets to the Thunderbolt receiver
126: * They are taken from Markus Prosch
127: */
128:
129: #ifdef PALISADE_SENDCMD_RESURRECTED
130: /*
131: * sendcmd - Build data packet for sending
132: */
133: static void
134: sendcmd (
135: struct packettx *buffer,
136: int c
137: )
138: {
139: *buffer->data = DLE;
140: *(buffer->data + 1) = (unsigned char)c;
141: buffer->size = 2;
142: }
143: #endif /* PALISADE_SENDCMD_RESURRECTED */
144:
145: /*
146: * sendsupercmd - Build super data packet for sending
147: */
148: static void
149: sendsupercmd (
150: struct packettx *buffer,
151: int c1,
152: int c2
153: )
154: {
155: *buffer->data = DLE;
156: *(buffer->data + 1) = (unsigned char)c1;
157: *(buffer->data + 2) = (unsigned char)c2;
158: buffer->size = 3;
159: }
160:
161: /*
162: * sendbyte -
163: */
164: static void
165: sendbyte (
166: struct packettx *buffer,
167: int b
168: )
169: {
170: if (b == DLE)
171: *(buffer->data+buffer->size++) = DLE;
172: *(buffer->data+buffer->size++) = (unsigned char)b;
173: }
174:
175: /*
176: * sendint -
177: */
178: static void
179: sendint (
180: struct packettx *buffer,
181: int a
182: )
183: {
184: sendbyte(buffer, (unsigned char)((a>>8) & 0xff));
185: sendbyte(buffer, (unsigned char)(a & 0xff));
186: }
187:
188: /*
189: * sendetx - Send packet or super packet to the device
190: */
191: static int
192: sendetx (
193: struct packettx *buffer,
194: int fd
195: )
196: {
197: int result;
198:
199: *(buffer->data+buffer->size++) = DLE;
200: *(buffer->data+buffer->size++) = ETX;
201: result = write(fd, buffer->data, (unsigned long)buffer->size);
202:
203: if (result != -1)
204: return (result);
205: else
206: return (-1);
207: }
208:
209: /*
210: * init_thunderbolt - Prepares Thunderbolt receiver to be used with
211: * NTP (also taken from Markus Prosch).
212: */
213: static void
214: init_thunderbolt (
215: int fd
216: )
217: {
218: struct packettx tx;
219:
220: tx.size = 0;
221: tx.data = (u_char *) malloc(100);
222:
223: /* set UTC time */
224: sendsupercmd (&tx, 0x8E, 0xA2);
225: sendbyte (&tx, 0x3);
226: sendetx (&tx, fd);
227:
228: /* activate packets 0x8F-AB and 0x8F-AC */
229: sendsupercmd (&tx, 0x8F, 0xA5);
230: sendint (&tx, 0x5);
231: sendetx (&tx, fd);
232:
233: free(tx.data);
234: }
235:
236: /*
237: * init_acutime - Prepares Acutime Receiver to be used with NTP
238: */
239: static void
240: init_acutime (
241: int fd
242: )
243: {
244: /* Disable all outputs, Enable Event-Polling on PortA so
245: we can ask for time packets */
246: struct packettx tx;
247:
248: tx.size = 0;
249: tx.data = (u_char *) malloc(100);
250:
251: sendsupercmd(&tx, 0x8E, 0xA5);
252: sendbyte(&tx, 0x02);
253: sendbyte(&tx, 0x00);
254: sendbyte(&tx, 0x00);
255: sendbyte(&tx, 0x00);
256: sendetx(&tx, fd);
257:
258: free(tx.data);
259: }
260:
261: /*
262: * palisade_start - open the devices and initialize data for processing
263: */
264: static int
265: palisade_start (
266: int unit,
267: struct peer *peer
268: )
269: {
270: struct palisade_unit *up;
271: struct refclockproc *pp;
272: int fd;
273: char gpsdev[20];
274: struct termios tio;
275:
276: snprintf(gpsdev, sizeof(gpsdev), DEVICE, unit);
277:
278: /*
279: * Open serial port.
280: */
281: fd = refclock_open(gpsdev, SPEED232, LDISC_RAW);
282: if (fd <= 0) {
283: #ifdef DEBUG
284: printf("Palisade(%d) start: open %s failed\n", unit, gpsdev);
285: #endif
286: return 0;
287: }
288:
289: msyslog(LOG_NOTICE, "Palisade(%d) fd: %d dev: %s", unit, fd,
290: gpsdev);
291:
292: if (tcgetattr(fd, &tio) < 0) {
293: msyslog(LOG_ERR,
294: "Palisade(%d) tcgetattr(fd, &tio): %m",unit);
295: #ifdef DEBUG
296: printf("Palisade(%d) tcgetattr(fd, &tio)\n",unit);
297: #endif
298: close(fd);
299: return (0);
300: }
301:
302: tio.c_cflag |= (PARENB|PARODD);
303: tio.c_iflag &= ~ICRNL;
304:
305: /*
306: * Allocate and initialize unit structure
307: */
308: up = (struct palisade_unit *) emalloc(sizeof(struct palisade_unit));
309:
310: memset((char *)up, 0, sizeof(struct palisade_unit));
311:
312: up->type = CLK_TYPE(peer);
313: switch (up->type) {
314: case CLK_TRIMBLE:
315: /* Normal mode, do nothing */
316: break;
317: case CLK_PRAECIS:
318: msyslog(LOG_NOTICE, "Palisade(%d) Praecis mode enabled\n"
319: ,unit);
320: break;
321: case CLK_THUNDERBOLT:
322: msyslog(LOG_NOTICE, "Palisade(%d) Thunderbolt mode enabled\n"
323: ,unit);
324: tio.c_cflag = (CS8|CLOCAL|CREAD);
325: break;
326: case CLK_ACUTIME:
327: msyslog(LOG_NOTICE, "Palisade(%d) Acutime Gold mode enabled\n"
328: ,unit);
329: break;
330: default:
331: msyslog(LOG_NOTICE, "Palisade(%d) mode unknown\n",unit);
332: break;
333: }
334: if (tcsetattr(fd, TCSANOW, &tio) == -1) {
335: msyslog(LOG_ERR, "Palisade(%d) tcsetattr(fd, &tio): %m",unit);
336: #ifdef DEBUG
337: printf("Palisade(%d) tcsetattr(fd, &tio)\n",unit);
338: #endif
339: close(fd);
340: free(up);
341: return 0;
342: }
343:
344: pp = peer->procptr;
345: pp->io.clock_recv = palisade_io;
346: pp->io.srcclock = (caddr_t)peer;
347: pp->io.datalen = 0;
348: pp->io.fd = fd;
349: if (!io_addclock(&pp->io)) {
350: #ifdef DEBUG
351: printf("Palisade(%d) io_addclock\n",unit);
352: #endif
353: close(fd);
354: pp->io.fd = -1;
355: free(up);
356: return (0);
357: }
358:
359: /*
360: * Initialize miscellaneous variables
361: */
362: pp->unitptr = (caddr_t)up;
363: pp->clockdesc = DESCRIPTION;
364:
365: peer->precision = PRECISION;
366: peer->sstclktype = CTL_SST_TS_UHF;
367: peer->minpoll = TRMB_MINPOLL;
368: peer->maxpoll = TRMB_MAXPOLL;
369: memcpy((char *)&pp->refid, REFID, 4);
370:
371: up->leap_status = 0;
372: up->unit = (short) unit;
373: up->rpt_status = TSIP_PARSED_EMPTY;
374: up->rpt_cnt = 0;
375:
376: if (up->type == CLK_THUNDERBOLT)
377: init_thunderbolt(fd);
378: if (up->type == CLK_ACUTIME)
379: init_acutime(fd);
380:
381: return 1;
382: }
383:
384:
385: /*
386: * palisade_shutdown - shut down the clock
387: */
388: static void
389: palisade_shutdown (
390: int unit,
391: struct peer *peer
392: )
393: {
394: struct palisade_unit *up;
395: struct refclockproc *pp;
396: pp = peer->procptr;
397: up = (struct palisade_unit *)pp->unitptr;
398: if (-1 != pp->io.fd)
399: io_closeclock(&pp->io);
400: if (NULL != up)
401: free(up);
402: }
403:
404:
405:
406: /*
407: * unpack_date - get day and year from date
408: */
409: int
410: day_of_year (
411: char * dt
412: )
413: {
414: int day, mon, year;
415:
416: mon = dt[1];
417: /* Check month is inside array bounds */
418: if ((mon < 1) || (mon > 12))
419: return -1;
420:
421: day = dt[0] + days_of_year[mon - 1];
422: year = getint((u_char *) (dt + 2));
423:
424: if ( !(year % 4) && ((year % 100) ||
425: (!(year % 100) && !(year%400)))
426: &&(mon > 2))
427: day ++; /* leap year and March or later */
428:
429: return day;
430: }
431:
432:
433: /*
434: * TSIP_decode - decode the TSIP data packets
435: */
436: int
437: TSIP_decode (
438: struct peer *peer
439: )
440: {
441: int st;
442: long secint;
443: double secs;
444: double secfrac;
445: unsigned short event = 0;
446:
447: struct palisade_unit *up;
448: struct refclockproc *pp;
449:
450: pp = peer->procptr;
451: up = (struct palisade_unit *)pp->unitptr;
452:
453: /*
454: * Check the time packet, decode its contents.
455: * If the timecode has invalid length or is not in
456: * proper format, declare bad format and exit.
457: */
458:
459: if ((up->type != CLK_THUNDERBOLT) & (up->type != CLK_ACUTIME)){
460: if ((up->rpt_buf[0] == (char) 0x41) ||
461: (up->rpt_buf[0] == (char) 0x46) ||
462: (up->rpt_buf[0] == (char) 0x54) ||
463: (up->rpt_buf[0] == (char) 0x4B) ||
464: (up->rpt_buf[0] == (char) 0x6D)) {
465:
466: /* standard time packet - GPS time and GPS week number */
467: #ifdef DEBUG
468: printf("Palisade Port B packets detected. Connect to Port A\n");
469: #endif
470:
471: return 0;
472: }
473: }
474:
475: /*
476: * We cast both to u_char to as 0x8f uses the sign bit on a char
477: */
478: if ((u_char) up->rpt_buf[0] == (u_char) 0x8f) {
479: /*
480: * Superpackets
481: */
482: event = (unsigned short) (getint((u_char *) &mb(1)) & 0xffff);
483: if (!((pp->sloppyclockflag & CLK_FLAG2) || event))
484: /* Ignore Packet */
485: return 0;
486:
487: switch (mb(0) & 0xff) {
488: int GPS_UTC_Offset;
489: long tow;
490:
491: case PACKET_8F0B:
492:
493: if (up->polled <= 0)
494: return 0;
495:
496: if (up->rpt_cnt != LENCODE_8F0B) /* check length */
497: break;
498:
499: #ifdef DEBUG
500: if (debug > 1) {
501: int ts;
502: double lat, lon, alt;
503: lat = getdbl((u_char *) &mb(42)) * R2D;
504: lon = getdbl((u_char *) &mb(50)) * R2D;
505: alt = getdbl((u_char *) &mb(58));
506:
507: printf("TSIP_decode: unit %d: Latitude: %03.4f Longitude: %03.4f Alt: %05.2f m\n",
508: up->unit, lat,lon,alt);
509: printf("TSIP_decode: unit %d: Sats:",
510: up->unit);
511: for (st = 66, ts = 0; st <= 73; st++)
512: if (mb(st)) {
513: if (mb(st) > 0) ts++;
514: printf(" %02d", mb(st));
515: }
516: printf(" : Tracking %d\n", ts);
517: }
518: #endif
519:
520: GPS_UTC_Offset = getint((u_char *) &mb(16));
521: if (GPS_UTC_Offset == 0) { /* Check UTC offset */
522: #ifdef DEBUG
523: printf("TSIP_decode: UTC Offset Unknown\n");
524: #endif
525: break;
526: }
527:
528: secs = getdbl((u_char *) &mb(3));
529: secint = (long) secs;
530: secfrac = secs - secint; /* 0.0 <= secfrac < 1.0 */
531:
532: pp->nsec = (long) (secfrac * 1000000000);
533:
534: secint %= 86400; /* Only care about today */
535: pp->hour = secint / 3600;
536: secint %= 3600;
537: pp->minute = secint / 60;
538: secint %= 60;
539: pp->second = secint % 60;
540:
541: if ((pp->day = day_of_year(&mb(11))) < 0) break;
542:
543: pp->year = getint((u_char *) &mb(13));
544:
545: #ifdef DEBUG
546: if (debug > 1)
547: printf("TSIP_decode: unit %d: %02X #%d %02d:%02d:%02d.%06ld %02d/%02d/%04d UTC %02d\n",
548: up->unit, mb(0) & 0xff, event, pp->hour, pp->minute,
549: pp->second, pp->nsec, mb(12), mb(11), pp->year, GPS_UTC_Offset);
550: #endif
551: /* Only use this packet when no
552: * 8F-AD's are being received
553: */
554:
555: if (up->leap_status) {
556: up->leap_status = 0;
557: return 0;
558: }
559:
560: return 2;
561: break;
562:
563: case PACKET_NTP:
564: /* Palisade-NTP Packet */
565:
566: if (up->rpt_cnt != LENCODE_NTP) /* check length */
567: break;
568:
569: up->leap_status = mb(19);
570:
571: if (up->polled <= 0)
572: return 0;
573:
574: /* Check Tracking Status */
575: st = mb(18);
576: if (st < 0 || st > 14)
577: st = 14;
578: if ((st >= 2 && st <= 7) || st == 11 || st == 12) {
579: #ifdef DEBUG
580: printf("TSIP_decode: Not Tracking Sats : %s\n",
581: *Tracking_Status[st]);
582: #endif
583: refclock_report(peer, CEVNT_BADTIME);
584: up->polled = -1;
585: return 0;
586: break;
587: }
588:
589: if (up->leap_status & PALISADE_LEAP_PENDING) {
590: if (up->leap_status & PALISADE_UTC_TIME)
591: pp->leap = LEAP_ADDSECOND;
592: else
593: pp->leap = LEAP_DELSECOND;
594: }
595: else if (up->leap_status)
596: pp->leap = LEAP_NOWARNING;
597:
598: else { /* UTC flag is not set:
599: * Receiver may have been reset, and lost
600: * its UTC almanac data */
601: pp->leap = LEAP_NOTINSYNC;
602: #ifdef DEBUG
603: printf("TSIP_decode: UTC Almanac unavailable: %d\n",
604: mb(19));
605: #endif
606: refclock_report(peer, CEVNT_BADTIME);
607: up->polled = -1;
608: return 0;
609: }
610:
611: pp->nsec = (long) (getdbl((u_char *) &mb(3))
612: * 1000000000);
613:
614: if ((pp->day = day_of_year(&mb(14))) < 0)
615: break;
616: pp->year = getint((u_char *) &mb(16));
617: pp->hour = mb(11);
618: pp->minute = mb(12);
619: pp->second = mb(13);
620:
621: #ifdef DEBUG
622: if (debug > 1)
623: printf("TSIP_decode: unit %d: %02X #%d %02d:%02d:%02d.%06ld %02d/%02d/%04d UTC %02x %s\n",
624: up->unit, mb(0) & 0xff, event, pp->hour, pp->minute,
625: pp->second, pp->nsec, mb(15), mb(14), pp->year,
626: mb(19), *Tracking_Status[st]);
627: #endif
628: return 1;
629: break;
630:
631: case PACKET_8FAC:
632: if (up->polled <= 0)
633: return 0;
634:
635: if (up->rpt_cnt != LENCODE_8FAC)/* check length */
636: break;
637:
638: #ifdef DEBUG
639: if (debug > 1) {
640: double lat, lon, alt;
641: lat = getdbl((u_char *) &mb(36)) * R2D;
642: lon = getdbl((u_char *) &mb(44)) * R2D;
643: alt = getdbl((u_char *) &mb(52));
644:
645: printf("TSIP_decode: unit %d: Latitude: %03.4f Longitude: %03.4f Alt: %05.2f m\n",
646: up->unit, lat,lon,alt);
647: printf("TSIP_decode: unit %d\n", up->unit);
648: }
649: #endif
650: if (getint((u_char *) &mb(10)) & 0x80)
651: pp->leap = LEAP_ADDSECOND; /* we ASSUME addsecond */
652: else
653: pp->leap = LEAP_NOWARNING;
654:
655: #ifdef DEBUG
656: if (debug > 1)
657: printf("TSIP_decode: unit %d: 0x%02x leap %d\n",
658: up->unit, mb(0) & 0xff, pp->leap);
659: if (debug > 1) {
660: printf("Receiver MODE: 0x%02X\n", (u_char)mb(1));
661: if (mb(1) == 0x00)
662: printf(" AUTOMATIC\n");
663: if (mb(1) == 0x01)
664: printf(" SINGLE SATELLITE\n");
665: if (mb(1) == 0x03)
666: printf(" HORIZONTAL(2D)\n");
667: if (mb(1) == 0x04)
668: printf(" FULL POSITION(3D)\n");
669: if (mb(1) == 0x05)
670: printf(" DGPR REFERENCE\n");
671: if (mb(1) == 0x06)
672: printf(" CLOCK HOLD(2D)\n");
673: if (mb(1) == 0x07)
674: printf(" OVERDETERMINED CLOCK\n");
675:
676: printf("\n** Disciplining MODE 0x%02X:\n", (u_char)mb(2));
677: if (mb(2) == 0x00)
678: printf(" NORMAL\n");
679: if (mb(2) == 0x01)
680: printf(" POWER-UP\n");
681: if (mb(2) == 0x02)
682: printf(" AUTO HOLDOVER\n");
683: if (mb(2) == 0x03)
684: printf(" MANUAL HOLDOVER\n");
685: if (mb(2) == 0x04)
686: printf(" RECOVERY\n");
687: if (mb(2) == 0x06)
688: printf(" DISCIPLINING DISABLED\n");
689: }
690: #endif
691: return 0;
692: break;
693:
694: case PACKET_8FAB:
695: /* Thunderbolt Primary Timing Packet */
696:
697: if (up->rpt_cnt != LENCODE_8FAB) /* check length */
698: break;
699:
700: if (up->polled <= 0)
701: return 0;
702:
703: GPS_UTC_Offset = getint((u_char *) &mb(7));
704:
705: if (GPS_UTC_Offset == 0){ /* Check UTC Offset */
706: #ifdef DEBUG
707: printf("TSIP_decode: UTC Offset Unknown\n");
708: #endif
709: break;
710: }
711:
712:
713: if ((mb(9) & 0x1d) == 0x0) {
714: /* if we know the GPS time and the UTC offset,
715: we expect UTC timing information !!! */
716:
717: pp->leap = LEAP_NOTINSYNC;
718: refclock_report(peer, CEVNT_BADTIME);
719: up->polled = -1;
720: return 0;
721: }
722:
723: pp->nsec = 0;
724: #ifdef DEBUG
725: printf("\nTiming Flags are:\n");
726: printf("Timing flag value is: 0x%X\n", mb(9));
727: if ((mb(9) & 0x01) != 0)
728: printf (" Getting UTC time\n");
729: else
730: printf (" Getting GPS time\n");
731: if ((mb(9) & 0x02) != 0)
732: printf (" PPS is from UTC\n");
733: else
734: printf (" PPS is from GPS\n");
735: if ((mb(9) & 0x04) != 0)
736: printf (" Time is not Set\n");
737: else
738: printf (" Time is Set\n");
739: if ((mb(9) & 0x08) != 0)
740: printf(" I dont have UTC info\n");
741: else
742: printf (" I have UTC info\n");
743: if ((mb(9) & 0x10) != 0)
744: printf (" Time is from USER\n\n");
745: else
746: printf (" Time is from GPS\n\n");
747: #endif
748:
749: if ((pp->day = day_of_year(&mb(13))) < 0)
750: break;
751: tow = getlong((u_char *) &mb(1));
752: #ifdef DEBUG
753: if (debug > 1) {
754: printf("pp->day: %d\n", pp->day);
755: printf("TOW: %ld\n", tow);
756: printf("DAY: %d\n", mb(13));
757: }
758: #endif
759: pp->year = getint((u_char *) &mb(15));
760: pp->hour = mb(12);
761: pp->minute = mb(11);
762: pp->second = mb(10);
763:
764:
765: #ifdef DEBUG
766: if (debug > 1)
767: printf("TSIP_decode: unit %d: %02X #%d %02d:%02d:%02d.%06ld %02d/%02d/%04d ",up->unit, mb(0) & 0xff, event, pp->hour, pp->minute, pp->second, pp->nsec, mb(14), mb(13), pp->year);
768: #endif
769: return 1;
770: break;
771:
772: default:
773: /* Ignore Packet */
774: return 0;
775: } /* switch */
776: } /* if 8F packets */
777:
778: else if (up->rpt_buf[0] == (u_char)0x42) {
779: printf("0x42\n");
780: return 0;
781: }
782: else if (up->rpt_buf[0] == (u_char)0x43) {
783: printf("0x43\n");
784: return 0;
785: }
786: else if ((up->rpt_buf[0] == PACKET_41) & (up->type == CLK_THUNDERBOLT)){
787: printf("Undocumented 0x41 packet on Thunderbolt\n");
788: return 0;
789: }
790: else if ((up->rpt_buf[0] == PACKET_41A) & (up->type == CLK_ACUTIME)) {
791: #ifdef DEBUG
792: printf("GPS TOW: %ld\n", getlong((u_char *) &mb(0)));
793: printf("GPS WN: %d\n", getint((u_char *) &mb(4)));
794: printf("GPS UTC-GPS Offser: %ld\n", getlong((u_char *) &mb(6)));
795: #endif
796: return 0;
797: }
798:
799: /* Health Status for Acutime Receiver */
800: else if ((up->rpt_buf[0] == PACKET_46) & (up->type == CLK_ACUTIME)) {
801: #ifdef DEBUG
802: if (debug > 1)
803: /* Status Codes */
804: switch (mb(0)) {
805: case 0x00:
806: printf ("Doing Position Fixes\n");
807: break;
808: case 0x01:
809: printf ("Do no have GPS time yet\n");
810: break;
811: case 0x03:
812: printf ("PDOP is too high\n");
813: break;
814: case 0x08:
815: printf ("No usable satellites\n");
816: break;
817: case 0x09:
818: printf ("Only 1 usable satellite\n");
819: break;
820: case 0x0A:
821: printf ("Only 2 usable satellites\n");
822: break;
823: case 0x0B:
824: printf ("Only 3 usable satellites\n");
825: break;
826: case 0x0C:
827: printf("The Chosen satellite is unusable\n");
828: break;
829: }
830: #endif
831: /* Error Codes */
832: if (mb(1) != 0) {
833:
834: refclock_report(peer, CEVNT_BADTIME);
835: up->polled = -1;
836: #ifdef DEBUG
837: if (debug > 1) {
838: if (mb(1) && 0x01)
839: printf ("Signal Processor Error, reset unit.\n");
840: if (mb(1) && 0x02)
841: printf ("Alignment error, channel or chip 1, reset unit.\n");
842: if (mb(1) && 0x03)
843: printf ("Alignment error, channel or chip 2, reset unit.\n");
844: if (mb(1) && 0x04)
845: printf ("Antenna feed line fault (open or short)\n");
846: if (mb(1) && 0x05)
847: printf ("Excessive reference frequency error, refer to packet 0x2D and packet 0x4D documentation for further information\n");
848: }
849: #endif
850:
851: return 0;
852: }
853: }
854: else if (up->rpt_buf[0] == 0x54)
855: return 0;
856:
857: else if (up->rpt_buf[0] == PACKET_6D) {
858: #ifdef DEBUG
859: int sats;
860:
861: if ((mb(0) & 0x01) && (mb(0) & 0x02))
862: printf("2d Fix Dimension\n");
863: if (mb(0) & 0x04)
864: printf("3d Fix Dimension\n");
865:
866: if (mb(0) & 0x08)
867: printf("Fix Mode is MANUAL\n");
868: else
869: printf("Fix Mode is AUTO\n");
870:
871: sats = mb(0) & 0xF0;
872: sats = sats >> 4;
873: printf("Tracking %d Satellites\n", sats);
874: #endif
875: return 0;
876: } /* else if not super packet */
877: refclock_report(peer, CEVNT_BADREPLY);
878: up->polled = -1;
879: #ifdef DEBUG
880: printf("TSIP_decode: unit %d: bad packet %02x-%02x event %d len %d\n",
881: up->unit, up->rpt_buf[0] & 0xff, mb(0) & 0xff,
882: event, up->rpt_cnt);
883: #endif
884: return 0;
885: }
886:
887: /*
888: * palisade__receive - receive data from the serial interface
889: */
890:
891: static void
892: palisade_receive (
893: struct peer * peer
894: )
895: {
896: struct palisade_unit *up;
897: struct refclockproc *pp;
898:
899: /*
900: * Initialize pointers and read the timecode and timestamp.
901: */
902: pp = peer->procptr;
903: up = (struct palisade_unit *)pp->unitptr;
904:
905: if (! TSIP_decode(peer)) return;
906:
907: if (up->polled <= 0)
908: return; /* no poll pending, already received or timeout */
909:
910: up->polled = 0; /* Poll reply received */
911: pp->lencode = 0; /* clear time code */
912: #ifdef DEBUG
913: if (debug)
914: printf(
915: "palisade_receive: unit %d: %4d %03d %02d:%02d:%02d.%06ld\n",
916: up->unit, pp->year, pp->day, pp->hour, pp->minute,
917: pp->second, pp->nsec);
918: #endif
919:
920: /*
921: * Process the sample
922: * Generate timecode: YYYY DoY HH:MM:SS.microsec
923: * report and process
924: */
925:
926: snprintf(pp->a_lastcode, sizeof(pp->a_lastcode),
927: "%4d %03d %02d:%02d:%02d.%06ld",
928: pp->year, pp->day,
929: pp->hour,pp->minute, pp->second, pp->nsec);
930: pp->lencode = 24;
931:
932: if (!refclock_process(pp)) {
933: refclock_report(peer, CEVNT_BADTIME);
934:
935: #ifdef DEBUG
936: printf("palisade_receive: unit %d: refclock_process failed!\n",
937: up->unit);
938: #endif
939: return;
940: }
941:
942: record_clock_stats(&peer->srcadr, pp->a_lastcode);
943:
944: #ifdef DEBUG
945: if (debug)
946: printf("palisade_receive: unit %d: %s\n",
947: up->unit, prettydate(&pp->lastrec));
948: #endif
949: pp->lastref = pp->lastrec;
950: refclock_receive(peer);
951: }
952:
953:
954: /*
955: * palisade_poll - called by the transmit procedure
956: *
957: */
958: static void
959: palisade_poll (
960: int unit,
961: struct peer *peer
962: )
963: {
964: struct palisade_unit *up;
965: struct refclockproc *pp;
966:
967: pp = peer->procptr;
968: up = (struct palisade_unit *)pp->unitptr;
969:
970: pp->polls++;
971: if (up->polled > 0) /* last reply never arrived or error */
972: refclock_report(peer, CEVNT_TIMEOUT);
973:
974: up->polled = 2; /* synchronous packet + 1 event */
975:
976: #ifdef DEBUG
977: if (debug)
978: printf("palisade_poll: unit %d: polling %s\n", unit,
979: (pp->sloppyclockflag & CLK_FLAG2) ?
980: "synchronous packet" : "event");
981: #endif
982:
983: if (pp->sloppyclockflag & CLK_FLAG2)
984: return; /* using synchronous packet input */
985:
986: if(up->type == CLK_PRAECIS) {
987: if(write(peer->procptr->io.fd,"SPSTAT\r\n",8) < 0)
988: msyslog(LOG_ERR, "Palisade(%d) write: %m:",unit);
989: else {
990: praecis_msg = 1;
991: return;
992: }
993: }
994:
995: if (HW_poll(pp) < 0)
996: refclock_report(peer, CEVNT_FAULT);
997: }
998:
999: static void
1000: praecis_parse (
1001: struct recvbuf *rbufp,
1002: struct peer *peer
1003: )
1004: {
1005: static char buf[100];
1006: static int p = 0;
1007: struct refclockproc *pp;
1008:
1009: pp = peer->procptr;
1010:
1011: memcpy(buf+p,rbufp->recv_space.X_recv_buffer, rbufp->recv_length);
1012: p += rbufp->recv_length;
1013:
1014: if(buf[p-2] == '\r' && buf[p-1] == '\n') {
1015: buf[p-2] = '\0';
1016: record_clock_stats(&peer->srcadr, buf);
1017:
1018: p = 0;
1019: praecis_msg = 0;
1020:
1021: if (HW_poll(pp) < 0)
1022: refclock_report(peer, CEVNT_FAULT);
1023:
1024: }
1025: }
1026:
1027: static void
1028: palisade_io (
1029: struct recvbuf *rbufp
1030: )
1031: {
1032: /*
1033: * Initialize pointers and read the timecode and timestamp.
1034: */
1035: struct palisade_unit *up;
1036: struct refclockproc *pp;
1037: struct peer *peer;
1038:
1039: char * c, * d;
1040:
1041: peer = (struct peer *)rbufp->recv_srcclock;
1042: pp = peer->procptr;
1043: up = (struct palisade_unit *)pp->unitptr;
1044:
1045: if(up->type == CLK_PRAECIS) {
1046: if(praecis_msg) {
1047: praecis_parse(rbufp,peer);
1048: return;
1049: }
1050: }
1051:
1052: c = (char *) &rbufp->recv_space;
1053: d = c + rbufp->recv_length;
1054:
1055: while (c != d) {
1056:
1057: /* Build time packet */
1058: switch (up->rpt_status) {
1059:
1060: case TSIP_PARSED_DLE_1:
1061: switch (*c)
1062: {
1063: case 0:
1064: case DLE:
1065: case ETX:
1066: up->rpt_status = TSIP_PARSED_EMPTY;
1067: break;
1068:
1069: default:
1070: up->rpt_status = TSIP_PARSED_DATA;
1071: /* save packet ID */
1072: up->rpt_buf[0] = *c;
1073: break;
1074: }
1075: break;
1076:
1077: case TSIP_PARSED_DATA:
1078: if (*c == DLE)
1079: up->rpt_status = TSIP_PARSED_DLE_2;
1080: else
1081: mb(up->rpt_cnt++) = *c;
1082: break;
1083:
1084: case TSIP_PARSED_DLE_2:
1085: if (*c == DLE) {
1086: up->rpt_status = TSIP_PARSED_DATA;
1087: mb(up->rpt_cnt++) =
1088: *c;
1089: }
1090: else if (*c == ETX)
1091: up->rpt_status = TSIP_PARSED_FULL;
1092: else {
1093: /* error: start new report packet */
1094: up->rpt_status = TSIP_PARSED_DLE_1;
1095: up->rpt_buf[0] = *c;
1096: }
1097: break;
1098:
1099: case TSIP_PARSED_FULL:
1100: case TSIP_PARSED_EMPTY:
1101: default:
1102: if ( *c != DLE)
1103: up->rpt_status = TSIP_PARSED_EMPTY;
1104: else
1105: up->rpt_status = TSIP_PARSED_DLE_1;
1106: break;
1107: }
1108:
1109: c++;
1110:
1111: if (up->rpt_status == TSIP_PARSED_DLE_1) {
1112: up->rpt_cnt = 0;
1113: if (pp->sloppyclockflag & CLK_FLAG2)
1114: /* stamp it */
1115: get_systime(&pp->lastrec);
1116: }
1117: else if (up->rpt_status == TSIP_PARSED_EMPTY)
1118: up->rpt_cnt = 0;
1119:
1120: else if (up->rpt_cnt > BMAX)
1121: up->rpt_status =TSIP_PARSED_EMPTY;
1122:
1123: if (up->rpt_status == TSIP_PARSED_FULL)
1124: palisade_receive(peer);
1125:
1126: } /* while chars in buffer */
1127: }
1128:
1129:
1130: /*
1131: * Trigger the Palisade's event input, which is driven off the RTS
1132: *
1133: * Take a system time stamp to match the GPS time stamp.
1134: *
1135: */
1136: long
1137: HW_poll (
1138: struct refclockproc * pp /* pointer to unit structure */
1139: )
1140: {
1141: int x; /* state before & after RTS set */
1142: struct palisade_unit *up;
1143:
1144: up = (struct palisade_unit *) pp->unitptr;
1145:
1146: /* read the current status, so we put things back right */
1147: if (ioctl(pp->io.fd, TIOCMGET, &x) < 0) {
1148: #ifdef DEBUG
1149: if (debug)
1150: printf("Palisade HW_poll: unit %d: GET %s\n", up->unit, strerror(errno));
1151: #endif
1152: msyslog(LOG_ERR, "Palisade(%d) HW_poll: ioctl(fd,GET): %m",
1153: up->unit);
1154: return -1;
1155: }
1156:
1157: x |= TIOCM_RTS; /* turn on RTS */
1158:
1159: /* Edge trigger */
1160: if (up->type == CLK_ACUTIME)
1161: write (pp->io.fd, "", 1);
1162:
1163: if (ioctl(pp->io.fd, TIOCMSET, &x) < 0) {
1164: #ifdef DEBUG
1165: if (debug)
1166: printf("Palisade HW_poll: unit %d: SET \n", up->unit);
1167: #endif
1168: msyslog(LOG_ERR,
1169: "Palisade(%d) HW_poll: ioctl(fd, SET, RTS_on): %m",
1170: up->unit);
1171: return -1;
1172: }
1173:
1174: x &= ~TIOCM_RTS; /* turn off RTS */
1175:
1176: /* poll timestamp */
1177: get_systime(&pp->lastrec);
1178:
1179: if (ioctl(pp->io.fd, TIOCMSET, &x) == -1) {
1180: #ifdef DEBUG
1181: if (debug)
1182: printf("Palisade HW_poll: unit %d: UNSET \n", up->unit);
1183: #endif
1184: msyslog(LOG_ERR,
1185: "Palisade(%d) HW_poll: ioctl(fd, UNSET, RTS_off): %m",
1186: up->unit);
1187: return -1;
1188: }
1189:
1190: return 0;
1191: }
1192:
1193: #if 0 /* unused */
1194: /*
1195: * this 'casts' a character array into a float
1196: */
1197: float
1198: getfloat (
1199: u_char *bp
1200: )
1201: {
1202: float sval;
1203: #ifdef WORDS_BIGENDIAN
1204: ((char *) &sval)[0] = *bp++;
1205: ((char *) &sval)[1] = *bp++;
1206: ((char *) &sval)[2] = *bp++;
1207: ((char *) &sval)[3] = *bp++;
1208: #else
1209: ((char *) &sval)[3] = *bp++;
1210: ((char *) &sval)[2] = *bp++;
1211: ((char *) &sval)[1] = *bp++;
1212: ((char *) &sval)[0] = *bp;
1213: #endif /* ! XNTP_BIG_ENDIAN */
1214: return sval;
1215: }
1216: #endif
1217:
1218: /*
1219: * this 'casts' a character array into a double
1220: */
1221: double
1222: getdbl (
1223: u_char *bp
1224: )
1225: {
1226: double dval;
1227: #ifdef WORDS_BIGENDIAN
1228: ((char *) &dval)[0] = *bp++;
1229: ((char *) &dval)[1] = *bp++;
1230: ((char *) &dval)[2] = *bp++;
1231: ((char *) &dval)[3] = *bp++;
1232: ((char *) &dval)[4] = *bp++;
1233: ((char *) &dval)[5] = *bp++;
1234: ((char *) &dval)[6] = *bp++;
1235: ((char *) &dval)[7] = *bp;
1236: #else
1237: ((char *) &dval)[7] = *bp++;
1238: ((char *) &dval)[6] = *bp++;
1239: ((char *) &dval)[5] = *bp++;
1240: ((char *) &dval)[4] = *bp++;
1241: ((char *) &dval)[3] = *bp++;
1242: ((char *) &dval)[2] = *bp++;
1243: ((char *) &dval)[1] = *bp++;
1244: ((char *) &dval)[0] = *bp;
1245: #endif /* ! XNTP_BIG_ENDIAN */
1246: return dval;
1247: }
1248:
1249: /*
1250: * cast a 16 bit character array into a short (16 bit) int
1251: */
1252: short
1253: getint (
1254: u_char *bp
1255: )
1256: {
1257: return (short) (bp[1] + (bp[0] << 8));
1258: }
1259:
1260: /*
1261: * cast a 32 bit character array into a long (32 bit) int
1262: */
1263: long
1264: getlong(
1265: u_char *bp
1266: )
1267: {
1268: return (long) (bp[0] << 24) |
1269: (bp[1] << 16) |
1270: (bp[2] << 8) |
1271: bp[3];
1272: }
1273:
1274: #else /* REFCLOCK && CLOCK_PALISADE*/
1275: int refclock_palisade_c_notempty;
1276: #endif