![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_ripencc.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_ripencc.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd |
1.1 misho 1: /*
2: * $Id: refclock_ripencc.c,v 1.13 2002/06/18 14:20:55 marks Exp marks $
3: *
4: * Copyright (c) 2002 RIPE NCC
5: *
6: * All Rights Reserved
7: *
8: * Permission to use, copy, modify, and distribute this software and its
9: * documentation for any purpose and without fee is hereby granted,
10: * provided that the above copyright notice appear in all copies and that
11: * both that copyright notice and this permission notice appear in
12: * supporting documentation, and that the name of the author not be
13: * used in advertising or publicity pertaining to distribution of the
14: * software without specific, written prior permission.
15: *
16: * THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
17: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
18: * AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
19: * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
20: * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
21: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22: *
23: *
24: *
25: * This driver was developed for use with the RIPE NCC TTM project.
26: *
27: *
28: * The initial driver was developed by Daniel Karrenberg <dfk@ripe.net>
29: * using the code made available by Trimble. This was for xntpd-3.x.x
30: *
31: * Rewrite of the driver for ntpd-4.x.x by Mark Santcroos <marks@ripe.net>
32: *
33: */
34:
35: #ifdef HAVE_CONFIG_H
36: #include <config.h>
37: #endif /* HAVE_CONFIG_H */
38:
39: #if defined(REFCLOCK) && defined(CLOCK_RIPENCC)
40:
41: #include "ntp_stdlib.h"
42: #include "ntpd.h"
43: #include "ntp_refclock.h"
44: #include "ntp_unixtime.h"
45: #include "ntp_io.h"
46:
47: #ifdef HAVE_PPSAPI
48: # include "ppsapi_timepps.h"
49: #endif
50:
51: /*
52: * Definitions
53: */
54:
55: /* we are on little endian */
56: #define BYTESWAP
57:
58: /*
59: * DEBUG statements: uncomment if necessary
60: */
61: /* #define DEBUG_NCC */ /* general debug statements */
62: /* #define DEBUG_PPS */ /* debug pps */
63: /* #define DEBUG_RAW */ /* print raw packets */
64:
65: #define TRIMBLE_OUTPUT_FUNC
66: #define TSIP_VERNUM "7.12a"
67:
68: #ifndef FALSE
69: #define FALSE (0)
70: #define TRUE (!FALSE)
71: #endif /* FALSE */
72:
73: #define GPS_PI (3.1415926535898)
74: #define GPS_C (299792458.)
75: #define D2R (GPS_PI/180.0)
76: #define R2D (180.0/GPS_PI)
77: #define WEEK (604800.)
78: #define MAXCHAN (8)
79:
80: /* control characters for TSIP packets */
81: #define DLE (0x10)
82: #define ETX (0x03)
83:
84: #define MAX_RPTBUF (256)
85:
86: /* values of TSIPPKT.status */
87: #define TSIP_PARSED_EMPTY 0
88: #define TSIP_PARSED_FULL 1
89: #define TSIP_PARSED_DLE_1 2
90: #define TSIP_PARSED_DATA 3
91: #define TSIP_PARSED_DLE_2 4
92:
93: #define UTCF_UTC_AVAIL (unsigned char) (1) /* UTC available */
94: #define UTCF_LEAP_SCHD (unsigned char) (1<<4) /* Leap scheduled */
95: #define UTCF_LEAP_PNDG (unsigned char) (1<<5) /* Leap pending, will occur at end of day */
96:
97: #define DEVICE "/dev/gps%d" /* name of radio device */
98: #define PRECISION (-9) /* precision assumed (about 2 ms) */
99: #define PPS_PRECISION (-20) /* precision assumed (about 1 us) */
100: #define REFID "GPS\0" /* reference id */
101: #define REFID_LEN 4
102: #define DESCRIPTION "RIPE NCC GPS (Palisade)" /* Description */
103: #define SPEED232 B9600 /* 9600 baud */
104:
105: #define NSAMPLES 3 /* stages of median filter */
106:
107: /* Structures */
108:
109: /* TSIP packets have the following structure, whether report or command. */
110: typedef struct {
111: short
112: counter, /* counter */
113: len; /* size of buf; < MAX_RPTBUF unsigned chars */
114: unsigned char
115: status, /* TSIP packet format/parse status */
116: code, /* TSIP code */
117: buf[MAX_RPTBUF]; /* report or command string */
118: } TSIPPKT;
119:
120: /* TSIP binary data structures */
121: typedef struct {
122: unsigned char
123: t_oa_raw, SV_health;
124: float
125: e, t_oa, i_0, OMEGADOT, sqrt_A,
126: OMEGA_0, omega, M_0, a_f0, a_f1,
127: Axis, n, OMEGA_n, ODOT_n, t_zc;
128: short
129: weeknum, wn_oa;
130: } ALM_INFO;
131:
132: typedef struct { /* Almanac health page (25) parameters */
133: unsigned char
134: WN_a, SV_health[32], t_oa;
135: } ALH_PARMS;
136:
137: typedef struct { /* Universal Coordinated Time (UTC) parms */
138: double
139: A_0;
140: float
141: A_1;
142: short
143: delta_t_LS;
144: float
145: t_ot;
146: short
147: WN_t, WN_LSF, DN, delta_t_LSF;
148: } UTC_INFO;
149:
150: typedef struct { /* Ionospheric info (float) */
151: float
152: alpha_0, alpha_1, alpha_2, alpha_3,
153: beta_0, beta_1, beta_2, beta_3;
154: } ION_INFO;
155:
156: typedef struct { /* Subframe 1 info (float) */
157: short
158: weeknum;
159: unsigned char
160: codeL2, L2Pdata, SVacc_raw, SV_health;
161: short
162: IODC;
163: float
164: T_GD, t_oc, a_f2, a_f1, a_f0, SVacc;
165: } EPHEM_CLOCK;
166:
167: typedef struct { /* Ephemeris info (float) */
168: unsigned char
169: IODE, fit_interval;
170: float
171: C_rs, delta_n;
172: double
173: M_0;
174: float
175: C_uc;
176: double
177: e;
178: float
179: C_us;
180: double
181: sqrt_A;
182: float
183: t_oe, C_ic;
184: double
185: OMEGA_0;
186: float
187: C_is;
188: double
189: i_0;
190: float
191: C_rc;
192: double
193: omega;
194: float
195: OMEGADOT, IDOT;
196: double
197: Axis, n, r1me2, OMEGA_n, ODOT_n;
198: } EPHEM_ORBIT;
199:
200: typedef struct { /* Navigation data structure */
201: short
202: sv_number; /* SV number (0 = no entry) */
203: float
204: t_ephem; /* time of ephemeris collection */
205: EPHEM_CLOCK
206: ephclk; /* subframe 1 data */
207: EPHEM_ORBIT
208: ephorb; /* ephemeris data */
209: } NAV_INFO;
210:
211: typedef struct {
212: unsigned char
213: bSubcode,
214: operating_mode,
215: dgps_mode,
216: dyn_code,
217: trackmode;
218: float
219: elev_mask,
220: cno_mask,
221: dop_mask,
222: dop_switch;
223: unsigned char
224: dgps_age_limit;
225: } TSIP_RCVR_CFG;
226:
227:
228: #ifdef TRIMBLE_OUTPUT_FUNC
229: static char
230: *dayname[7] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"},
231: old_baudnum[] = {0, 1, 4, 5, 6, 8, 9, 11, 28, 12},
232: *st_baud_text_app [] = {"", "", " 300", " 600", " 1200", " 2400",
233: " 4800", " 9600", "19200", "38400"},
234: *old_parity_text[] = {"EVEN", "ODD", "", "", "NONE"},
235: *parity_text [] = {"NONE", "ODD", "EVEN"},
236: *old_input_ch[] = { "TSIP", "RTCM (6 of 8 bits)"},
237: *old_output_ch[] = { "TSIP", "No output", "", "", "", "NMEA 0183"},
238: *protocols_in_text[] = { "", "TSIP", "", ""},
239: *protocols_out_text[] = { "", "TSIP", "NMEA"},
240: *rcvr_port_text [] = { "Port A ", "Port B ", "Current Port"},
241: *dyn_text [] = {"Unchanged", "Land", "Sea", "Air", "Static"},
242: *NavModeText0xBB[] = {"automatic", "time only (0-D)", "", "2-D",
243: "3-D", "", "", "OverDetermined Time"},
244: *PPSTimeBaseText[] = {"GPS", "UTC", "USER"},
245: *PPSPolarityText[] = {"Positive", "Negative"},
246: *MaskText[] = { "Almanac ", "Ephemeris", "UTC ", "Iono ",
247: "GPS Msg ", "Alm Hlth ", "Time Fix ", "SV Select",
248: "Ext Event", "Pos Fix ", "Raw Meas "};
249:
250: #endif /* TRIMBLE_OUTPUT_FUNC */
251:
252: /*
253: * Unit control structure
254: */
255: struct ripencc_unit {
256: int unit; /* unit number */
257: int pollcnt; /* poll message counter */
258: int polled; /* Hand in a sample? */
259: char leapdelta; /* delta of next leap event */
260: unsigned char utcflags; /* delta of next leap event */
261: l_fp tstamp; /* timestamp of last poll */
262:
263: struct timespec ts; /* last timestamp */
264: pps_params_t pps_params; /* pps parameters */
265: pps_info_t pps_info; /* last pps data */
266: pps_handle_t handle; /* pps handlebars */
267:
268: };
269:
270:
271: /******************* PROTOYPES *****************/
272:
273: /* prototypes for report parsing primitives */
274: short rpt_0x3D (TSIPPKT *rpt, unsigned char *tx_baud_index,
275: unsigned char *rx_baud_index, unsigned char *char_format_index,
276: unsigned char *stop_bits, unsigned char *tx_mode_index,
277: unsigned char *rx_mode_index);
278: short rpt_0x40 (TSIPPKT *rpt, unsigned char *sv_prn, short *week_num,
279: float *t_zc, float *eccentricity, float *t_oa, float *i_0,
280: float *OMEGA_dot, float *sqrt_A, float *OMEGA_0, float *omega,
281: float *M_0);
282: short rpt_0x41 (TSIPPKT *rpt, float *time_of_week, float *UTC_offset,
283: short *week_num);
284: short rpt_0x42 (TSIPPKT *rpt, float ECEF_pos[3], float *time_of_fix);
285: short rpt_0x43 (TSIPPKT *rpt, float ECEF_vel[3], float *freq_offset,
286: float *time_of_fix);
287: short rpt_0x45 (TSIPPKT *rpt, unsigned char *major_nav_version,
288: unsigned char *minor_nav_version, unsigned char *nav_day,
289: unsigned char *nav_month, unsigned char *nav_year,
290: unsigned char *major_dsp_version, unsigned char *minor_dsp_version,
291: unsigned char *dsp_day, unsigned char *dsp_month,
292: unsigned char *dsp_year);
293: short rpt_0x46 (TSIPPKT *rpt, unsigned char *status1, unsigned char *status2);
294: short rpt_0x47 (TSIPPKT *rpt, unsigned char *nsvs, unsigned char *sv_prn,
295: float *snr);
296: short rpt_0x48 (TSIPPKT *rpt, unsigned char *message);
297: short rpt_0x49 (TSIPPKT *rpt, unsigned char *sv_health);
298: short rpt_0x4A (TSIPPKT *rpt, float *lat, float *lon, float *alt,
299: float *clock_bias, float *time_of_fix);
300: short rpt_0x4A_2 (TSIPPKT *rpt, float *alt, float *dummy,
301: unsigned char *alt_flag);
302: short rpt_0x4B (TSIPPKT *rpt, unsigned char *machine_id,
303: unsigned char *status3, unsigned char *status4);
304: short rpt_0x4C (TSIPPKT *rpt, unsigned char *dyn_code, float *el_mask,
305: float *snr_mask, float *dop_mask, float *dop_switch);
306: short rpt_0x4D (TSIPPKT *rpt, float *osc_offset);
307: short rpt_0x4E (TSIPPKT *rpt, unsigned char *response);
308: short rpt_0x4F (TSIPPKT *rpt, double *a0, float *a1, float *time_of_data,
309: short *dt_ls, short *wn_t, short *wn_lsf, short *dn, short *dt_lsf);
310: short rpt_0x54 (TSIPPKT *rpt, float *clock_bias, float *freq_offset,
311: float *time_of_fix);
312: short rpt_0x55 (TSIPPKT *rpt, unsigned char *pos_code, unsigned char *vel_code,
313: unsigned char *time_code, unsigned char *aux_code);
314: short rpt_0x56 (TSIPPKT *rpt, float vel_ENU[3], float *freq_offset,
315: float *time_of_fix);
316: short rpt_0x57 (TSIPPKT *rpt, unsigned char *source_code,
317: unsigned char *diag_code, short *week_num, float *time_of_fix);
318: short rpt_0x58 (TSIPPKT *rpt, unsigned char *op_code, unsigned char *data_type,
319: unsigned char *sv_prn, unsigned char *data_length,
320: unsigned char *data_packet);
321: short rpt_0x59 (TSIPPKT *rpt, unsigned char *code_type,
322: unsigned char status_code[32]);
323: short rpt_0x5A (TSIPPKT *rpt, unsigned char *sv_prn, float *sample_length,
324: float *signal_level, float *code_phase, float *Doppler,
325: double *time_of_fix);
326: short rpt_0x5B (TSIPPKT *rpt, unsigned char *sv_prn, unsigned char *sv_health,
327: unsigned char *sv_iode, unsigned char *fit_interval_flag,
328: float *time_of_collection, float *time_of_eph, float *sv_accy);
329: short rpt_0x5C (TSIPPKT *rpt, unsigned char *sv_prn, unsigned char *slot,
330: unsigned char *chan, unsigned char *acq_flag, unsigned char *eph_flag,
331: float *signal_level, float *time_of_last_msmt, float *elev,
332: float *azim, unsigned char *old_msmt_flag,
333: unsigned char *integer_msec_flag, unsigned char *bad_data_flag,
334: unsigned char *data_collect_flag);
335: short rpt_0x6D (TSIPPKT *rpt, unsigned char *manual_mode, unsigned char *nsvs,
336: unsigned char *ndim, unsigned char sv_prn[], float *pdop,
337: float *hdop, float *vdop, float *tdop);
338: short rpt_0x82 (TSIPPKT *rpt, unsigned char *diff_mode);
339: short rpt_0x83 (TSIPPKT *rpt, double ECEF_pos[3], double *clock_bias,
340: float *time_of_fix);
341: short rpt_0x84 (TSIPPKT *rpt, double *lat, double *lon, double *alt,
342: double *clock_bias, float *time_of_fix);
343: short rpt_Paly0xBB(TSIPPKT *rpt, TSIP_RCVR_CFG *TsipxBB);
344: short rpt_0xBC (TSIPPKT *rpt, unsigned char *port_num,
345: unsigned char *in_baud, unsigned char *out_baud,
346: unsigned char *data_bits, unsigned char *parity,
347: unsigned char *stop_bits, unsigned char *flow_control,
348: unsigned char *protocols_in, unsigned char *protocols_out,
349: unsigned char *reserved);
350:
351: /* prototypes for superpacket parsers */
352:
353: short rpt_0x8F0B (TSIPPKT *rpt, unsigned short *event, double *tow,
354: unsigned char *date, unsigned char *month, short *year,
355: unsigned char *dim_mode, short *utc_offset, double *bias, double *drift,
356: float *bias_unc, float *dr_unc, double *lat, double *lon, double *alt,
357: char sv_id[8]);
358: short rpt_0x8F14 (TSIPPKT *rpt, short *datum_idx, double datum_coeffs[5]);
359: short rpt_0x8F15 (TSIPPKT *rpt, short *datum_idx, double datum_coeffs[5]);
360: short rpt_0x8F20 (TSIPPKT *rpt, unsigned char *info, double *lat,
361: double *lon, double *alt, double vel_enu[], double *time_of_fix,
362: short *week_num, unsigned char *nsvs, unsigned char sv_prn[],
363: short sv_IODC[], short *datum_index);
364: short rpt_0x8F41 (TSIPPKT *rpt, unsigned char *bSearchRange,
365: unsigned char *bBoardOptions, unsigned long *iiSerialNumber,
366: unsigned char *bBuildYear, unsigned char *bBuildMonth,
367: unsigned char *bBuildDay, unsigned char *bBuildHour,
368: float *fOscOffset, unsigned short *iTestCodeId);
369: short rpt_0x8F42 (TSIPPKT *rpt, unsigned char *bProdOptionsPre,
370: unsigned char *bProdNumberExt, unsigned short *iCaseSerialNumberPre,
371: unsigned long *iiCaseSerialNumber, unsigned long *iiProdNumber,
372: unsigned short *iPremiumOptions, unsigned short *iMachineID,
373: unsigned short *iKey);
374: short rpt_0x8F45 (TSIPPKT *rpt, unsigned char *bSegMask);
375: short rpt_0x8F4A_16 (TSIPPKT *rpt, unsigned char *pps_enabled,
376: unsigned char *pps_timebase, unsigned char *pos_polarity,
377: double *pps_offset, float *bias_unc_threshold);
378: short rpt_0x8F4B (TSIPPKT *rpt, unsigned long *decorr_max);
379: short rpt_0x8F4D (TSIPPKT *rpt, unsigned long *event_mask);
380: short rpt_0x8FA5 (TSIPPKT *rpt, unsigned char *spktmask);
381: short rpt_0x8FAD (TSIPPKT *rpt, unsigned short *COUNT, double *FracSec,
382: unsigned char *Hour, unsigned char *Minute, unsigned char *Second,
383: unsigned char *Day, unsigned char *Month, unsigned short *Year,
384: unsigned char *Status, unsigned char *Flags);
385:
386: /**/
387: /* prototypes for command-encode primitives with suffix convention: */
388: /* c = clear, s = set, q = query, e = enable, d = disable */
389: void cmd_0x1F (TSIPPKT *cmd);
390: void cmd_0x26 (TSIPPKT *cmd);
391: void cmd_0x2F (TSIPPKT *cmd);
392: void cmd_0x35s (TSIPPKT *cmd, unsigned char pos_code, unsigned char vel_code,
393: unsigned char time_code, unsigned char opts_code);
394: void cmd_0x3C (TSIPPKT *cmd, unsigned char sv_prn);
395: void cmd_0x3Ds (TSIPPKT *cmd, unsigned char baud_out, unsigned char baud_inp,
396: unsigned char char_code, unsigned char stopbitcode,
397: unsigned char output_mode, unsigned char input_mode);
398: void cmd_0xBBq (TSIPPKT *cmd, unsigned char subcode) ;
399:
400: /* prototypes 8E commands */
401: void cmd_0x8E0Bq (TSIPPKT *cmd);
402: void cmd_0x8E41q (TSIPPKT *cmd);
403: void cmd_0x8E42q (TSIPPKT *cmd);
404: void cmd_0x8E4Aq (TSIPPKT *cmd);
405: void cmd_0x8E4As (TSIPPKT *cmd, unsigned char PPSOnOff, unsigned char TimeBase,
406: unsigned char Polarity, double PPSOffset, float Uncertainty);
407: void cmd_0x8E4Bq (TSIPPKT *cmd);
408: void cmd_0x8E4Ds (TSIPPKT *cmd, unsigned long AutoOutputMask);
409: void cmd_0x8EADq (TSIPPKT *cmd);
410:
411: /* header/source border XXXXXXXXXXXXXXXXXXXXXXXXXX */
412:
413: /* Trimble parse functions */
414: static int parse0x8FAD (TSIPPKT *, struct peer *);
415: static int parse0x8F0B (TSIPPKT *, struct peer *);
416: #ifdef TRIMBLE_OUTPUT_FUNC
417: static int parseany (TSIPPKT *, struct peer *);
418: static void TranslateTSIPReportToText (TSIPPKT *, char *);
419: #endif /* TRIMBLE_OUTPUT_FUNC */
420: static int parse0x5C (TSIPPKT *, struct peer *);
421: static int parse0x4F (TSIPPKT *, struct peer *);
422: static void tsip_input_proc (TSIPPKT *, int);
423:
424: /* Trimble helper functions */
425: static void bPutFloat (float *, unsigned char *);
426: static void bPutDouble (double *, unsigned char *);
427: static void bPutULong (unsigned long *, unsigned char *);
428: static int print_msg_table_header (int rptcode, char *HdrStr, int force);
429: static char * show_time (float time_of_week);
430:
431: /* RIPE NCC functions */
432: static void ripencc_control (int, const struct refclockstat *,
433: struct refclockstat *, struct peer *);
434: static int ripencc_ppsapi (struct peer *, int, int);
435: static int ripencc_get_pps_ts (struct ripencc_unit *, l_fp *);
436: static int ripencc_start (int, struct peer *);
437: static void ripencc_shutdown (int, struct peer *);
438: static void ripencc_poll (int, struct peer *);
439: static void ripencc_send (struct peer *, TSIPPKT spt);
440: static void ripencc_receive (struct recvbuf *);
441:
442: /* fill in reflock structure for our clock */
443: struct refclock refclock_ripencc = {
444: ripencc_start, /* start up driver */
445: ripencc_shutdown, /* shut down driver */
446: ripencc_poll, /* transmit poll message */
447: ripencc_control, /* control function */
448: noentry, /* initialize driver */
449: noentry, /* debug info */
450: NOFLAGS /* clock flags */
451: };
452:
453: /*
454: * Tables to compute the ddd of year form icky dd/mm timecode. Viva la
455: * leap.
456: */
457: static int day1tab[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
458: static int day2tab[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
459:
460:
461: /*
462: * ripencc_start - open the GPS devices and initialize data for processing
463: */
464: static int
465: ripencc_start(int unit, struct peer *peer)
466: {
467: register struct ripencc_unit *up;
468: struct refclockproc *pp;
469: char device[40];
470: int fd;
471: struct termios tio;
472: TSIPPKT spt;
473:
474: pp = peer->procptr;
475:
476: /*
477: * Open serial port
478: */
479: (void)snprintf(device, sizeof(device), DEVICE, unit);
480: if (!(fd = refclock_open(device, SPEED232, LDISC_RAW))) {
481: pp->io.fd = -1;
482: return (0);
483: }
484:
485: pp->io.fd = fd;
486:
487: /* from refclock_palisade.c */
488: if (tcgetattr(fd, &tio) < 0) {
489: msyslog(LOG_ERR, "Palisade(%d) tcgetattr(fd, &tio): %m",unit);
490: return (0);
491: }
492:
493: /*
494: * set flags
495: */
496: tio.c_cflag |= (PARENB|PARODD);
497: tio.c_iflag &= ~ICRNL;
498: if (tcsetattr(fd, TCSANOW, &tio) == -1) {
499: msyslog(LOG_ERR, "Palisade(%d) tcsetattr(fd, &tio): %m",unit);
500: return (0);
501: }
502:
503: /*
504: * Allocate and initialize unit structure
505: */
506: if (!(up = (struct ripencc_unit *)
507: emalloc(sizeof(struct ripencc_unit)))) {
508: (void) close(fd);
509: return (0);
510: }
511: memset((char *)up, 0, sizeof(struct ripencc_unit));
512:
513: pp->io.clock_recv = ripencc_receive;
514: pp->io.srcclock = (caddr_t)peer;
515: pp->io.datalen = 0;
516: if (!io_addclock(&pp->io)) {
517: pp->io.fd = -1;
518: (void) close(fd);
519: free(up);
520: return (0);
521: }
522: pp->unitptr = (caddr_t)up;
523:
524: /*
525: * Initialize miscellaneous variables
526: */
527: peer->precision = PRECISION;
528: pp->clockdesc = DESCRIPTION;
529: memcpy((char *)&pp->refid, REFID, REFID_LEN);
530: up->pollcnt = 2;
531: up->unit = unit;
532: up->leapdelta = 0;
533: up->utcflags = 0;
534:
535: /*
536: * Initialize the Clock
537: */
538:
539: /* query software versions */
540: cmd_0x1F(&spt);
541: ripencc_send(peer, spt);
542:
543: /* query receiver health */
544: cmd_0x26(&spt);
545: ripencc_send(peer, spt);
546:
547: /* query serial numbers */
548: cmd_0x8E42q(&spt);
549: ripencc_send(peer, spt);
550:
551: /* query manuf params */
552: cmd_0x8E41q(&spt);
553: ripencc_send(peer, spt);
554:
555: /* i/o opts */ /* trimble manual page A30 */
556: cmd_0x35s(&spt,
557: 0x1C, /* position */
558: 0x00, /* velocity */
559: 0x05, /* timing */
560: 0x0a); /* auxilary */
561: ripencc_send(peer, spt);
562:
563: /* turn off port A */
564: cmd_0x3Ds (&spt,
565: 0x0B, /* baud_out */
566: 0x0B, /* baud_inp */
567: 0x07, /* char_code */
568: 0x07, /* stopbitcode */
569: 0x01, /* output_mode */
570: 0x00); /* input_mode */
571: ripencc_send(peer, spt);
572:
573: /* set i/o options */
574: cmd_0x8E4As (&spt,
575: 0x01, /* PPS on */
576: 0x01, /* Timebase UTC */
577: 0x00, /* polarity positive */
578: 0., /* 100 ft. cable XXX make flag */
579: 1e-6 * GPS_C); /* turn of biasuncert. > (1us) */
580: ripencc_send(peer,spt);
581:
582: /* all outomatic packet output off */
583: cmd_0x8E4Ds(&spt,
584: 0x00000000); /* AutoOutputMask */
585: ripencc_send(peer, spt);
586:
587: cmd_0xBBq (&spt,
588: 0x00); /* query primary configuration */
589: ripencc_send(peer,spt);
590:
591:
592: /* query PPS parameters */
593: cmd_0x8E4Aq (&spt); /* query PPS params */
594: ripencc_send(peer,spt);
595:
596: /* query survey limit */
597: cmd_0x8E4Bq (&spt); /* query survey limit */
598: ripencc_send(peer,spt);
599:
600: #ifdef DEBUG_NCC
601: if (debug)
602: printf("ripencc_start: success\n");
603: #endif /* DEBUG_NCC */
604:
605: /*
606: * Start the PPSAPI interface if it is there. Default to use
607: * the assert edge and do not enable the kernel hardpps.
608: */
609: if (time_pps_create(fd, &up->handle) < 0) {
610: up->handle = 0;
611: msyslog(LOG_ERR, "refclock_ripencc: time_pps_create failed: %m");
612: return (1);
613: }
614:
615: return(ripencc_ppsapi(peer, 0, 0));
616: }
617:
618: /*
619: * ripencc_control - fudge control
620: */
621: static void
622: ripencc_control(
623: int unit, /* unit (not used) */
624: const struct refclockstat *in, /* input parameters (not used) */
625: struct refclockstat *out, /* output parameters (not used) */
626: struct peer *peer /* peer structure pointer */
627: )
628: {
629: struct refclockproc *pp;
630:
631: #ifdef DEBUG_NCC
632: msyslog(LOG_INFO,"%s()",__FUNCTION__);
633: #endif /* DEBUG_NCC */
634:
635: pp = peer->procptr;
636: ripencc_ppsapi(peer, pp->sloppyclockflag & CLK_FLAG2,
637: pp->sloppyclockflag & CLK_FLAG3);
638: }
639:
640:
641: /*
642: * Initialize PPSAPI
643: */
644: int
645: ripencc_ppsapi(
646: struct peer *peer, /* peer structure pointer */
647: int enb_clear, /* clear enable */
648: int enb_hardpps /* hardpps enable */
649: )
650: {
651: struct refclockproc *pp;
652: struct ripencc_unit *up;
653: int capability;
654:
655: pp = peer->procptr;
656: up = (struct ripencc_unit *)pp->unitptr;
657: if (time_pps_getcap(up->handle, &capability) < 0) {
658: msyslog(LOG_ERR,
659: "refclock_ripencc: time_pps_getcap failed: %m");
660: return (0);
661: }
662: memset(&up->pps_params, 0, sizeof(pps_params_t));
663: if (enb_clear)
664: up->pps_params.mode = capability & PPS_CAPTURECLEAR;
665: else
666: up->pps_params.mode = capability & PPS_CAPTUREASSERT;
667: if (!up->pps_params.mode) {
668: msyslog(LOG_ERR,
669: "refclock_ripencc: invalid capture edge %d",
670: !enb_clear);
671: return (0);
672: }
673: up->pps_params.mode |= PPS_TSFMT_TSPEC;
674: if (time_pps_setparams(up->handle, &up->pps_params) < 0) {
675: msyslog(LOG_ERR,
676: "refclock_ripencc: time_pps_setparams failed: %m");
677: return (0);
678: }
679: if (enb_hardpps) {
680: if (time_pps_kcbind(up->handle, PPS_KC_HARDPPS,
681: up->pps_params.mode & ~PPS_TSFMT_TSPEC,
682: PPS_TSFMT_TSPEC) < 0) {
683: msyslog(LOG_ERR,
684: "refclock_ripencc: time_pps_kcbind failed: %m");
685: return (0);
686: }
687: pps_enable = 1;
688: }
689: peer->precision = PPS_PRECISION;
690:
691: #if DEBUG_NCC
692: if (debug) {
693: time_pps_getparams(up->handle, &up->pps_params);
694: printf(
695: "refclock_ripencc: capability 0x%x version %d mode 0x%x kern %d\n",
696: capability, up->pps_params.api_version,
697: up->pps_params.mode, enb_hardpps);
698: }
699: #endif /* DEBUG_NCC */
700:
701: return (1);
702: }
703:
704: /*
705: * This function is called every 64 seconds from ripencc_receive
706: * It will fetch the pps time
707: *
708: * Return 0 on failure and 1 on success.
709: */
710: static int
711: ripencc_get_pps_ts(
712: struct ripencc_unit *up,
713: l_fp *tsptr
714: )
715: {
716: pps_info_t pps_info;
717: struct timespec timeout, ts;
718: double dtemp;
719: l_fp tstmp;
720:
721: #ifdef DEBUG_PPS
722: msyslog(LOG_INFO,"ripencc_get_pps_ts\n");
723: #endif /* DEBUG_PPS */
724:
725:
726: /*
727: * Convert the timespec nanoseconds field to ntp l_fp units.
728: */
729: if (up->handle == 0)
730: return (0);
731: timeout.tv_sec = 0;
732: timeout.tv_nsec = 0;
733: memcpy(&pps_info, &up->pps_info, sizeof(pps_info_t));
734: if (time_pps_fetch(up->handle, PPS_TSFMT_TSPEC, &up->pps_info,
735: &timeout) < 0)
736: return (0);
737: if (up->pps_params.mode & PPS_CAPTUREASSERT) {
738: if (pps_info.assert_sequence ==
739: up->pps_info.assert_sequence)
740: return (0);
741: ts = up->pps_info.assert_timestamp;
742: } else if (up->pps_params.mode & PPS_CAPTURECLEAR) {
743: if (pps_info.clear_sequence ==
744: up->pps_info.clear_sequence)
745: return (0);
746: ts = up->pps_info.clear_timestamp;
747: } else {
748: return (0);
749: }
750: if ((up->ts.tv_sec == ts.tv_sec) && (up->ts.tv_nsec == ts.tv_nsec))
751: return (0);
752: up->ts = ts;
753:
754: tstmp.l_ui = ts.tv_sec + JAN_1970;
755: dtemp = ts.tv_nsec * FRAC / 1e9;
756: tstmp.l_uf = (u_int32)dtemp;
757:
758: #ifdef DEBUG_PPS
759: msyslog(LOG_INFO,"ts.tv_sec: %d\n",(int)ts.tv_sec);
760: msyslog(LOG_INFO,"ts.tv_nsec: %ld\n",ts.tv_nsec);
761: #endif /* DEBUG_PPS */
762:
763: *tsptr = tstmp;
764: return (1);
765: }
766:
767: /*
768: * ripencc_shutdown - shut down a GPS clock
769: */
770: static void
771: ripencc_shutdown(int unit, struct peer *peer)
772: {
773: register struct ripencc_unit *up;
774: struct refclockproc *pp;
775:
776: pp = peer->procptr;
777: up = (struct ripencc_unit *)pp->unitptr;
778:
779: if (up != NULL) {
780: if (up->handle != 0)
781: time_pps_destroy(up->handle);
782: free(up);
783: }
784: if (-1 != pp->io.fd)
785: io_closeclock(&pp->io);
786:
787: return;
788: }
789:
790: /*
791: * ripencc_poll - called by the transmit procedure
792: */
793: static void
794: ripencc_poll(int unit, struct peer *peer)
795: {
796: register struct ripencc_unit *up;
797: struct refclockproc *pp;
798: TSIPPKT spt;
799:
800: #ifdef DEBUG_NCC
801: if (debug)
802: fprintf(stderr, "ripencc_poll(%d)\n", unit);
803: #endif /* DEBUG_NCC */
804: pp = peer->procptr;
805: up = (struct ripencc_unit *)pp->unitptr;
806: if (up->pollcnt == 0)
807: refclock_report(peer, CEVNT_TIMEOUT);
808: else
809: up->pollcnt--;
810:
811: pp->polls++;
812: up->polled = 1;
813:
814: /* poll for UTC superpacket */
815: cmd_0x8EADq (&spt);
816: ripencc_send(peer,spt);
817: }
818:
819: /*
820: * ripencc_send - send message to clock
821: * use the structures being created by the trimble functions!
822: * makes the code more readable/clean
823: */
824: static void
825: ripencc_send(struct peer *peer, TSIPPKT spt)
826: {
827: unsigned char *ip, *op;
828: unsigned char obuf[512];
829:
830: #ifdef DEBUG_RAW
831: {
832: register struct ripencc_unit *up;
833: register struct refclockproc *pp;
834:
835: pp = peer->procptr;
836: up = (struct ripencc_unit *)pp->unitptr;
837: if (debug)
838: printf("ripencc_send(%d, %02X)\n", up->unit, cmd);
839: }
840: #endif /* DEBUG_RAW */
841:
842: ip = spt.buf;
843: op = obuf;
844:
845: *op++ = 0x10;
846: *op++ = spt.code;
847:
848: while (spt.len--) {
849: if (op-obuf > sizeof(obuf)-5) {
850: msyslog(LOG_ERR, "ripencc_send obuf overflow!");
851: refclock_report(peer, CEVNT_FAULT);
852: return;
853: }
854:
855: if (*ip == 0x10) /* byte stuffing */
856: *op++ = 0x10;
857: *op++ = *ip++;
858: }
859:
860: *op++ = 0x10;
861: *op++ = 0x03;
862:
863: #ifdef DEBUG_RAW
864: if (debug) { /* print raw packet */
865: unsigned char *cp;
866: int i;
867:
868: printf("ripencc_send: len %d\n", op-obuf);
869: for (i=1, cp=obuf; cp<op; i++, cp++) {
870: printf(" %02X", *cp);
871: if (i%10 == 0)
872: printf("\n");
873: }
874: printf("\n");
875: }
876: #endif /* DEBUG_RAW */
877:
878: if (write(peer->procptr->io.fd, obuf, op-obuf) == -1) {
879: refclock_report(peer, CEVNT_FAULT);
880: }
881: }
882:
883: /*
884: * ripencc_receive()
885: *
886: * called when a packet is received on the serial port
887: * takes care of further processing
888: *
889: */
890: static void
891: ripencc_receive(struct recvbuf *rbufp)
892: {
893: register struct ripencc_unit *up;
894: register struct refclockproc *pp;
895: struct peer *peer;
896: static TSIPPKT rpt; /* for current incoming TSIP report */
897: TSIPPKT spt; /* send packet */
898: int ns_since_pps;
899: int i;
900: char *cp;
901: /* these variables hold data until we decide it's worth keeping */
902: char rd_lastcode[BMAX];
903: l_fp rd_tmp;
904: u_short rd_lencode;
905:
906: /* msyslog(LOG_INFO, "%s",__FUNCTION__); */
907:
908: /*
909: * Initialize pointers and read the timecode and timestamp
910: */
911: peer = (struct peer *)rbufp->recv_srcclock;
912: pp = peer->procptr;
913: up = (struct ripencc_unit *)pp->unitptr;
914: rd_lencode = refclock_gtlin(rbufp, rd_lastcode, BMAX, &rd_tmp);
915:
916: #ifdef DEBUG_RAW
917: if (debug)
918: fprintf(stderr, "ripencc_receive(%d)\n", up->unit);
919: #endif /* DEBUG_RAW */
920:
921: #ifdef DEBUG_RAW
922: if (debug) { /* print raw packet */
923: int i;
924: unsigned char *cp;
925:
926: printf("ripencc_receive: len %d\n", rbufp->recv_length);
927: for (i=1, cp=(char*)&rbufp->recv_space;
928: i <= rbufp->recv_length;
929: i++, cp++) {
930: printf(" %02X", *cp);
931: if (i%10 == 0)
932: printf("\n");
933: }
934: printf("\n");
935: }
936: #endif /* DEBUG_RAW */
937:
938: cp = (char*) &rbufp->recv_space;
939: i=rbufp->recv_length;
940:
941: while (i--) { /* loop over received chars */
942:
943: tsip_input_proc(&rpt, (unsigned char) *cp++);
944:
945: if (rpt.status != TSIP_PARSED_FULL)
946: continue;
947:
948: switch (rpt.code) {
949:
950: case 0x8F: /* superpacket */
951:
952: switch (rpt.buf[0]) {
953:
954: case 0xAD: /* UTC Time */
955: /*
956: ** When polling on port B the timecode is
957: ** the time of the previous PPS. If we
958: ** completed receiving the packet less than
959: ** 150ms after the turn of the second, it
960: ** may have the code of the previous second.
961: ** We do not trust that and simply poll
962: ** again without even parsing it.
963: **
964: ** More elegant would be to re-schedule the
965: ** poll, but I do not know (yet) how to do
966: ** that cleanly.
967: **
968: */
969: /* BLA ns_since_pps = ncc_tstmp(rbufp, &trtmp); */
970: /* if (up->polled && ns_since_pps > -1 && ns_since_pps < 150) { */
971:
972: ns_since_pps = 200;
973: if (up->polled && ns_since_pps < 150) {
974: msyslog(LOG_INFO, "%s(): up->polled",
975: __FUNCTION__);
976: ripencc_poll(up->unit, peer);
977: break;
978: }
979:
980: /*
981: * Parse primary utc time packet
982: * and fill refclock structure
983: * from results.
984: */
985: if (parse0x8FAD(&rpt, peer) < 0) {
986: msyslog(LOG_INFO, "%s(): parse0x8FAD < 0",__FUNCTION__);
987: refclock_report(peer, CEVNT_BADREPLY);
988: break;
989: }
990: /*
991: * If the PPSAPI is working, rather use its
992: * timestamps.
993: * assume that the PPS occurs on the second
994: * so blow any msec
995: */
996: if (ripencc_get_pps_ts(up, &rd_tmp) == 1) {
997: pp->lastrec = up->tstamp = rd_tmp;
998: pp->nsec = 0;
999: }
1000: else
1001: msyslog(LOG_INFO, "%s(): ripencc_get_pps_ts returns failure\n",__FUNCTION__);
1002:
1003:
1004: if (!up->polled) {
1005: msyslog(LOG_INFO, "%s(): unrequested packet\n",__FUNCTION__);
1006: /* unrequested packet */
1007: break;
1008: }
1009:
1010: /* we have been polled ! */
1011: up->polled = 0;
1012: up->pollcnt = 2;
1013:
1014: /* poll for next packet */
1015: cmd_0x8E0Bq(&spt);
1016: ripencc_send(peer,spt);
1017:
1018: if (ns_since_pps < 0) { /* no PPS */
1019: msyslog(LOG_INFO, "%s(): ns_since_pps < 0",__FUNCTION__);
1020: refclock_report(peer, CEVNT_BADTIME);
1021: break;
1022: }
1023:
1024: /*
1025: ** Process the new sample in the median
1026: ** filter and determine the reference clock
1027: ** offset and dispersion.
1028: */
1029: if (!refclock_process(pp)) {
1030: msyslog(LOG_INFO, "%s(): !refclock_process",__FUNCTION__);
1031: refclock_report(peer, CEVNT_BADTIME);
1032: break;
1033: }
1034:
1035: refclock_receive(peer);
1036: break;
1037:
1038: case 0x0B: /* comprehensive time packet */
1039: parse0x8F0B(&rpt, peer);
1040: break;
1041:
1042: default: /* other superpackets */
1043: #ifdef DEBUG_NCC
1044: msyslog(LOG_INFO, "%s(): calling parseany",
1045: __FUNCTION__);
1046: #endif /* DEBUG_NCC */
1047: #ifdef TRIMBLE_OUTPUT_FUNC
1048: parseany(&rpt, peer);
1049: #endif /* TRIMBLE_OUTPUT_FUNC */
1050: break;
1051: }
1052: break;
1053:
1054: case 0x4F: /* UTC parameters, for leap info */
1055: parse0x4F(&rpt, peer);
1056: break;
1057:
1058: case 0x5C: /* sat tracking data */
1059: parse0x5C(&rpt, peer);
1060: break;
1061:
1062: default: /* other packets */
1063: #ifdef TRIMBLE_OUTPUT_FUNC
1064: parseany(&rpt, peer);
1065: #endif /* TRIMBLE_OUTPUT_FUNC */
1066: break;
1067: }
1068: rpt.status = TSIP_PARSED_EMPTY;
1069: }
1070: }
1071:
1072: /*
1073: * All trimble functions that are directly referenced from driver code
1074: * (so not from parseany)
1075: */
1076:
1077: /* request software versions */
1078: void
1079: cmd_0x1F(
1080: TSIPPKT *cmd
1081: )
1082: {
1083: cmd->len = 0;
1084: cmd->code = 0x1F;
1085: }
1086:
1087: /* request receiver health */
1088: void
1089: cmd_0x26(
1090: TSIPPKT *cmd
1091: )
1092: {
1093: cmd->len = 0;
1094: cmd->code = 0x26;
1095: }
1096:
1097: /* request UTC params */
1098: void
1099: cmd_0x2F(
1100: TSIPPKT *cmd
1101: )
1102: {
1103: cmd->len = 0;
1104: cmd->code = 0x2F;
1105: }
1106:
1107: /* set serial I/O options */
1108: void
1109: cmd_0x35s(
1110: TSIPPKT *cmd,
1111: unsigned char pos_code,
1112: unsigned char vel_code,
1113: unsigned char time_code,
1114: unsigned char opts_code
1115: )
1116: {
1117: cmd->buf[0] = pos_code;
1118: cmd->buf[1] = vel_code;
1119: cmd->buf[2] = time_code;
1120: cmd->buf[3] = opts_code;
1121: cmd->len = 4;
1122: cmd->code = 0x35;
1123: }
1124:
1125: /* request tracking status */
1126: void
1127: cmd_0x3C(
1128: TSIPPKT *cmd,
1129: unsigned char sv_prn
1130: )
1131: {
1132: cmd->buf[0] = sv_prn;
1133: cmd->len = 1;
1134: cmd->code = 0x3C;
1135: }
1136:
1137: /* set Channel A configuration for dual-port operation */
1138: void
1139: cmd_0x3Ds(
1140: TSIPPKT *cmd,
1141: unsigned char baud_out,
1142: unsigned char baud_inp,
1143: unsigned char char_code,
1144: unsigned char stopbitcode,
1145: unsigned char output_mode,
1146: unsigned char input_mode
1147: )
1148: {
1149: cmd->buf[0] = baud_out; /* XMT baud rate */
1150: cmd->buf[1] = baud_inp; /* RCV baud rate */
1151: cmd->buf[2] = char_code; /* parity and #bits per byte */
1152: cmd->buf[3] = stopbitcode; /* number of stop bits code */
1153: cmd->buf[4] = output_mode; /* Ch. A transmission mode */
1154: cmd->buf[5] = input_mode; /* Ch. A reception mode */
1155: cmd->len = 6;
1156: cmd->code = 0x3D;
1157: }
1158:
1159:
1160: /* query primary configuration */
1161: void
1162: cmd_0xBBq(
1163: TSIPPKT *cmd,
1164: unsigned char subcode
1165: )
1166: {
1167: cmd->len = 1;
1168: cmd->code = 0xBB;
1169: cmd->buf[0] = subcode;
1170: }
1171:
1172:
1173: /**** Superpackets ****/
1174: /* 8E-0B to query 8F-0B controls */
1175: void
1176: cmd_0x8E0Bq(
1177: TSIPPKT *cmd
1178: )
1179: {
1180: cmd->len = 1;
1181: cmd->code = 0x8E;
1182: cmd->buf[0] = 0x0B;
1183: }
1184:
1185:
1186: /* 8F-41 to query board serial number */
1187: void
1188: cmd_0x8E41q(
1189: TSIPPKT *cmd
1190: )
1191: {
1192: cmd->len = 1;
1193: cmd->code = 0x8E;
1194: cmd->buf[0] = 0x41;
1195: }
1196:
1197:
1198: /* 8F-42 to query product serial number */
1199: void
1200: cmd_0x8E42q(
1201: TSIPPKT *cmd
1202: )
1203: {
1204: cmd->len = 1;
1205: cmd->code = 0x8E;
1206: cmd->buf[0] = 0x42;
1207: }
1208:
1209:
1210: /* 8F-4A to query PPS parameters */
1211: void
1212: cmd_0x8E4Aq(
1213: TSIPPKT *cmd
1214: )
1215: {
1216: cmd->len = 1;
1217: cmd->code = 0x8E;
1218: cmd->buf[0] = 0x4A;
1219: }
1220:
1221:
1222: /* set i/o options */
1223: void
1224: cmd_0x8E4As(
1225: TSIPPKT *cmd,
1226: unsigned char PPSOnOff,
1227: unsigned char TimeBase,
1228: unsigned char Polarity,
1229: double PPSOffset,
1230: float Uncertainty
1231: )
1232: {
1233: cmd->len = 16;
1234: cmd->code = 0x8E;
1235: cmd->buf[0] = 0x4A;
1236: cmd->buf[1] = PPSOnOff;
1237: cmd->buf[2] = TimeBase;
1238: cmd->buf[3] = Polarity;
1239: bPutDouble (&PPSOffset, &cmd->buf[4]);
1240: bPutFloat (&Uncertainty, &cmd->buf[12]);
1241: }
1242:
1243: /* 8F-4B query survey limit */
1244: void
1245: cmd_0x8E4Bq(
1246: TSIPPKT *cmd
1247: )
1248: {
1249: cmd->len = 1;
1250: cmd->code = 0x8E;
1251: cmd->buf[0] = 0x4B;
1252: }
1253:
1254: /* poll for UTC superpacket */
1255: /* 8E-AD to query 8F-AD controls */
1256: void
1257: cmd_0x8EADq(
1258: TSIPPKT *cmd
1259: )
1260: {
1261: cmd->len = 1;
1262: cmd->code = 0x8E;
1263: cmd->buf[0] = 0xAD;
1264: }
1265:
1266: /* all outomatic packet output off */
1267: void
1268: cmd_0x8E4Ds(
1269: TSIPPKT *cmd,
1270: unsigned long AutoOutputMask
1271: )
1272: {
1273: cmd->len = 5;
1274: cmd->code = 0x8E;
1275: cmd->buf[0] = 0x4D;
1276: bPutULong (&AutoOutputMask, &cmd->buf[1]);
1277: }
1278:
1279:
1280: /*
1281: * for DOS machines, reverse order of bytes as they come through the
1282: * serial port.
1283: */
1284: #ifdef BYTESWAP
1285: static short
1286: bGetShort(
1287: unsigned char *bp
1288: )
1289: {
1290: short outval;
1291: unsigned char *optr;
1292:
1293: optr = (unsigned char*)&outval + 1;
1294: *optr-- = *bp++;
1295: *optr = *bp;
1296: return outval;
1297: }
1298:
1299: #ifdef TRIMBLE_OUTPUT_FUNC
1300: static unsigned short
1301: bGetUShort(
1302: unsigned char *bp
1303: )
1304: {
1305: unsigned short outval;
1306: unsigned char *optr;
1307:
1308: optr = (unsigned char*)&outval + 1;
1309: *optr-- = *bp++;
1310: *optr = *bp;
1311: return outval;
1312: }
1313:
1314: static long
1315: bGetLong(
1316: unsigned char *bp
1317: )
1318: {
1319: long outval;
1320: unsigned char *optr;
1321:
1322: optr = (unsigned char*)&outval + 3;
1323: *optr-- = *bp++;
1324: *optr-- = *bp++;
1325: *optr-- = *bp++;
1326: *optr = *bp;
1327: return outval;
1328: }
1329:
1330: static unsigned long
1331: bGetULong(
1332: unsigned char *bp
1333: )
1334: {
1335: unsigned long outval;
1336: unsigned char *optr;
1337:
1338: optr = (unsigned char*)&outval + 3;
1339: *optr-- = *bp++;
1340: *optr-- = *bp++;
1341: *optr-- = *bp++;
1342: *optr = *bp;
1343: return outval;
1344: }
1345: #endif /* TRIMBLE_OUTPUT_FUNC */
1346:
1347: static float
1348: bGetSingle(
1349: unsigned char *bp
1350: )
1351: {
1352: float outval;
1353: unsigned char *optr;
1354:
1355: optr = (unsigned char*)&outval + 3;
1356: *optr-- = *bp++;
1357: *optr-- = *bp++;
1358: *optr-- = *bp++;
1359: *optr = *bp;
1360: return outval;
1361: }
1362:
1363: static double
1364: bGetDouble(
1365: unsigned char *bp
1366: )
1367: {
1368: double outval;
1369: unsigned char *optr;
1370:
1371: optr = (unsigned char*)&outval + 7;
1372: *optr-- = *bp++;
1373: *optr-- = *bp++;
1374: *optr-- = *bp++;
1375: *optr-- = *bp++;
1376: *optr-- = *bp++;
1377: *optr-- = *bp++;
1378: *optr-- = *bp++;
1379: *optr = *bp;
1380: return outval;
1381: }
1382:
1383: #else /* not BYTESWAP */
1384:
1385: #define bGetShort(bp) (*(short*)(bp))
1386: #define bGetLong(bp) (*(long*)(bp))
1387: #define bGetULong(bp) (*(unsigned long*)(bp))
1388: #define bGetSingle(bp) (*(float*)(bp))
1389: #define bGetDouble(bp) (*(double*)(bp))
1390:
1391: #endif /* BYTESWAP */
1392: /*
1393: * Byte-reversal is necessary for little-endian (Intel-based) machines.
1394: * TSIP streams are Big-endian (Motorola-based).
1395: */
1396: #ifdef BYTESWAP
1397:
1398: void
1399: bPutFloat(
1400: float *in,
1401: unsigned char *out
1402: )
1403: {
1404: unsigned char *inptr;
1405:
1406: inptr = (unsigned char*)in + 3;
1407: *out++ = *inptr--;
1408: *out++ = *inptr--;
1409: *out++ = *inptr--;
1410: *out = *inptr;
1411: }
1412:
1413: static void
1414: bPutULong(
1415: unsigned long *in,
1416: unsigned char *out
1417: )
1418: {
1419: unsigned char *inptr;
1420:
1421: inptr = (unsigned char*)in + 3;
1422: *out++ = *inptr--;
1423: *out++ = *inptr--;
1424: *out++ = *inptr--;
1425: *out = *inptr;
1426: }
1427:
1428: static void
1429: bPutDouble(
1430: double *in,
1431: unsigned char *out
1432: )
1433: {
1434: unsigned char *inptr;
1435:
1436: inptr = (unsigned char*)in + 7;
1437: *out++ = *inptr--;
1438: *out++ = *inptr--;
1439: *out++ = *inptr--;
1440: *out++ = *inptr--;
1441: *out++ = *inptr--;
1442: *out++ = *inptr--;
1443: *out++ = *inptr--;
1444: *out = *inptr;
1445: }
1446:
1447: #else /* not BYTESWAP */
1448:
1449: void bPutShort (short a, unsigned char *cmdbuf) {*(short*) cmdbuf = a;}
1450: void bPutULong (long a, unsigned char *cmdbuf) {*(long*) cmdbuf = a;}
1451: void bPutFloat (float a, unsigned char *cmdbuf) {*(float*) cmdbuf = a;}
1452: void bPutDouble (double a, unsigned char *cmdbuf){*(double*) cmdbuf = a;}
1453:
1454: #endif /* BYTESWAP */
1455:
1456: /*
1457: * Parse primary utc time packet
1458: * and fill refclock structure
1459: * from results.
1460: *
1461: * 0 = success
1462: * -1 = errors
1463: */
1464:
1465: static int
1466: parse0x8FAD(
1467: TSIPPKT *rpt,
1468: struct peer *peer
1469: )
1470: {
1471: register struct refclockproc *pp;
1472: register struct ripencc_unit *up;
1473:
1474: unsigned day, month, year; /* data derived from received timecode */
1475: unsigned hour, minute, second;
1476: unsigned char trackstat, utcflags;
1477:
1478: static char logbuf[1024]; /* logging string buffer */
1479: int i;
1480: unsigned char *buf;
1481:
1482: buf = rpt->buf;
1483: pp = peer->procptr;
1484:
1485: if (rpt->len != 22)
1486: return (-1);
1487:
1488: if (bGetShort(&buf[1]) != 0) {
1489: #ifdef DEBUG_NCC
1490: if (debug)
1491: printf("parse0x8FAD: event count != 0\n");
1492: #endif /* DEBUG_NCC */
1493: return(-1);
1494: }
1495:
1496: if (bGetDouble(&buf[3]) != 0.0) {
1497: #ifdef DEBUG_NCC
1498: if (debug)
1499: printf("parse0x8FAD: fracsecs != 0\n");
1500: #endif /* DEBUG_NCC */
1501: return(-1);
1502: }
1503:
1504: hour = (unsigned int) buf[11];
1505: minute = (unsigned int) buf[12];
1506: second = (unsigned int) buf[13];
1507: day = (unsigned int) buf[14];
1508: month = (unsigned int) buf[15];
1509: year = bGetShort(&buf[16]);
1510: trackstat = buf[18];
1511: utcflags = buf[19];
1512:
1513:
1514: sprintf(logbuf, "U1 %d.%d.%d %02d:%02d:%02d %d %02x",
1515: day, month, year, hour, minute, second, trackstat, utcflags);
1516:
1517: #ifdef DEBUG_NCC
1518: if (debug)
1519: puts(logbuf);
1520: #endif /* DEBUG_NCC */
1521:
1522: record_clock_stats(&peer->srcadr, logbuf);
1523:
1524: if (!utcflags & UTCF_UTC_AVAIL)
1525: return(-1);
1526:
1527: /* poll for UTC parameters once and then if UTC flag changed */
1528: up = (struct ripencc_unit *) pp->unitptr;
1529: if (utcflags != up->utcflags) {
1530: TSIPPKT spt; /* local structure for send packet */
1531: cmd_0x2F (&spt); /* request UTC params */
1532: ripencc_send(peer,spt);
1533: up->utcflags = utcflags;
1534: }
1535:
1536: /*
1537: * If we hit the leap second, we choose to skip this sample
1538: * rather than rely on other code to be perfectly correct.
1539: * No offense, just defense ;-).
1540: */
1541: if (second == 60)
1542: return(-1);
1543:
1544: /* now check and convert the time we received */
1545:
1546: pp->year = year;
1547: if (month < 1 || month > 12 || day < 1 || day > 31)
1548: return(-1);
1549:
1550: if (pp->year % 4) { /* XXX: use is_leapyear() ? */
1551: if (day > day1tab[month - 1])
1552: return(-1);
1553: for (i = 0; i < month - 1; i++)
1554: day += day1tab[i];
1555: } else {
1556: if (day > day2tab[month - 1])
1557: return(-1);
1558: for (i = 0; i < month - 1; i++)
1559: day += day2tab[i];
1560: }
1561: pp->day = day;
1562: pp->hour = hour;
1563: pp->minute = minute;
1564: pp-> second = second;
1565: pp->nsec = 0;
1566:
1567: if ((utcflags&UTCF_LEAP_PNDG) && up->leapdelta != 0)
1568: pp-> leap = (up->leapdelta > 0)
1569: ? LEAP_ADDSECOND
1570: : LEAP_DELSECOND;
1571: else
1572: pp-> leap = LEAP_NOWARNING;
1573:
1574: return (0);
1575: }
1576:
1577: /*
1578: * Parse comprehensive time packet
1579: *
1580: * 0 = success
1581: * -1 = errors
1582: */
1583:
1584: int
1585: parse0x8F0B(
1586: TSIPPKT *rpt,
1587: struct peer *peer
1588: )
1589: {
1590: register struct refclockproc *pp;
1591:
1592: unsigned day, month, year; /* data derived from received timecode */
1593: unsigned hour, minute, second;
1594: unsigned utcoff;
1595: unsigned char mode;
1596: double bias, rate;
1597: float biasunc, rateunc;
1598: double lat, lon, alt;
1599: short lat_deg, lon_deg;
1600: float lat_min, lon_min;
1601: unsigned char north_south, east_west;
1602: char sv[9];
1603:
1604: static char logbuf[1024]; /* logging string buffer */
1605: unsigned char b;
1606: int i;
1607: unsigned char *buf;
1608: double tow;
1609:
1610: buf = rpt->buf;
1611: pp = peer->procptr;
1612:
1613: if (rpt->len != 74)
1614: return (-1);
1615:
1616: if (bGetShort(&buf[1]) != 0)
1617: return(-1);;
1618:
1619: tow = bGetDouble(&buf[3]);
1620:
1621: if (tow == -1.0) {
1622: return(-1);
1623: }
1624: else if ((tow >= 604800.0) || (tow < 0.0)) {
1625: return(-1);
1626: }
1627: else
1628: {
1629: if (tow < 604799.9) tow = tow + .00000001;
1630: second = (unsigned int) fmod(tow, 60.);
1631: minute = (unsigned int) fmod(tow/60., 60.);
1632: hour = (unsigned int )fmod(tow / 3600., 24.);
1633: }
1634:
1635: day = (unsigned int) buf[11];
1636: month = (unsigned int) buf[12];
1637: year = bGetShort(&buf[13]);
1638: mode = buf[15];
1639: utcoff = bGetShort(&buf[16]);
1640: bias = bGetDouble(&buf[18]) / GPS_C * 1e9; /* ns */
1641: rate = bGetDouble(&buf[26]) / GPS_C * 1e9; /* ppb */
1642: biasunc = bGetSingle(&buf[34]) / GPS_C * 1e9; /* ns */
1643: rateunc = bGetSingle(&buf[38]) / GPS_C * 1e9; /* ppb */
1644: lat = bGetDouble(&buf[42]) * R2D;
1645: lon = bGetDouble(&buf[50]) * R2D;
1646: alt = bGetDouble(&buf[58]);
1647:
1648: if (lat < 0.0) {
1649: north_south = 'S';
1650: lat = -lat;
1651: }
1652: else {
1653: north_south = 'N';
1654: }
1655: lat_deg = (short)lat;
1656: lat_min = (lat - lat_deg) * 60.0;
1657:
1658: if (lon < 0.0) {
1659: east_west = 'W';
1660: lon = -lon;
1661: }
1662: else {
1663: east_west = 'E';
1664: }
1665:
1666: lon_deg = (short)lon;
1667: lon_min = (lon - lon_deg) * 60.0;
1668:
1669: for (i=0; i<8; i++) {
1670: sv[i] = buf[i + 66];
1671: if (sv[i]) {
1672: TSIPPKT spt; /* local structure for sendpacket */
1673: b = (unsigned char) (sv[i]<0 ? -sv[i] : sv[i]);
1674: /* request tracking status */
1675: cmd_0x3C (&spt, b);
1676: ripencc_send(peer,spt);
1677: }
1678: }
1679:
1680:
1681: sprintf(logbuf, "C1 %02d%02d%04d %02d%02d%02d %d %7.0f %.1f %.0f %.1f %d %02d%09.6f %c %02d%09.6f %c %.0f %d %d %d %d %d %d %d %d",
1682: day, month, year, hour, minute, second, mode, bias, biasunc,
1683: rate, rateunc, utcoff, lat_deg, lat_min, north_south, lon_deg,
1684: lon_min, east_west, alt, sv[0], sv[1], sv[2], sv[3], sv[4],
1685: sv[5], sv[6], sv[7]);
1686:
1687: #ifdef DEBUG_NCC
1688: if (debug)
1689: puts(logbuf);
1690: #endif /* DEBUG_NCC */
1691:
1692: record_clock_stats(&peer->srcadr, logbuf);
1693:
1694: return (0);
1695: }
1696:
1697: #ifdef TRIMBLE_OUTPUT_FUNC
1698: /*
1699: * Parse any packet using Trimble machinery
1700: */
1701: int
1702: parseany(
1703: TSIPPKT *rpt,
1704: struct peer *peer
1705: )
1706: {
1707: static char logbuf[1024]; /* logging string buffer */
1708:
1709: TranslateTSIPReportToText (rpt, logbuf); /* anything else */
1710: #ifdef DEBUG_NCC
1711: if (debug)
1712: puts(&logbuf[1]);
1713: #endif /* DEBUG_NCC */
1714: record_clock_stats(&peer->srcadr, &logbuf[1]);
1715: return(0);
1716: }
1717: #endif /* TRIMBLE_OUTPUT_FUNC */
1718:
1719:
1720: /*
1721: * Parse UTC Parameter Packet
1722: *
1723: * See the IDE for documentation!
1724: *
1725: * 0 = success
1726: * -1 = errors
1727: */
1728:
1729: int
1730: parse0x4F(
1731: TSIPPKT *rpt,
1732: struct peer *peer
1733: )
1734: {
1735: register struct ripencc_unit *up;
1736:
1737: double a0;
1738: float a1, tot;
1739: int dt_ls, wn_t, wn_lsf, dn, dt_lsf;
1740:
1741: static char logbuf[1024]; /* logging string buffer */
1742: unsigned char *buf;
1743:
1744: buf = rpt->buf;
1745:
1746: if (rpt->len != 26)
1747: return (-1);
1748: a0 = bGetDouble (buf);
1749: a1 = bGetSingle (&buf[8]);
1750: dt_ls = bGetShort (&buf[12]);
1751: tot = bGetSingle (&buf[14]);
1752: wn_t = bGetShort (&buf[18]);
1753: wn_lsf = bGetShort (&buf[20]);
1754: dn = bGetShort (&buf[22]);
1755: dt_lsf = bGetShort (&buf[24]);
1756:
1757: sprintf(logbuf, "L1 %d %d %d %g %g %g %d %d %d",
1758: dt_lsf - dt_ls, dt_ls, dt_lsf, a0, a1, tot, wn_t, wn_lsf, dn);
1759:
1760: #ifdef DEBUG_NCC
1761: if (debug)
1762: puts(logbuf);
1763: #endif /* DEBUG_NCC */
1764:
1765: record_clock_stats(&peer->srcadr, logbuf);
1766:
1767: up = (struct ripencc_unit *) peer->procptr->unitptr;
1768: up->leapdelta = dt_lsf - dt_ls;
1769:
1770: return (0);
1771: }
1772:
1773: /*
1774: * Parse Tracking Status packet
1775: *
1776: * 0 = success
1777: * -1 = errors
1778: */
1779:
1780: int
1781: parse0x5C(
1782: TSIPPKT *rpt,
1783: struct peer *peer
1784: )
1785: {
1786: unsigned char prn, channel, aqflag, ephstat;
1787: float snr, azinuth, elevation;
1788:
1789: static char logbuf[1024]; /* logging string buffer */
1790: unsigned char *buf;
1791:
1792: buf = rpt->buf;
1793:
1794: if (rpt->len != 24)
1795: return(-1);
1796:
1797: prn = buf[0];
1798: channel = (unsigned char)(buf[1] >> 3);
1799: if (channel == 0x10)
1800: channel = 2;
1801: else
1802: channel++;
1803: aqflag = buf[2];
1804: ephstat = buf[3];
1805: snr = bGetSingle(&buf[4]);
1806: elevation = bGetSingle(&buf[12]) * R2D;
1807: azinuth = bGetSingle(&buf[16]) * R2D;
1808:
1809: sprintf(logbuf, "S1 %02d %d %d %02x %4.1f %5.1f %4.1f",
1810: prn, channel, aqflag, ephstat, snr, azinuth, elevation);
1811:
1812: #ifdef DEBUG_NCC
1813: if (debug)
1814: puts(logbuf);
1815: #endif /* DEBUG_NCC */
1816:
1817: record_clock_stats(&peer->srcadr, logbuf);
1818:
1819: return (0);
1820: }
1821:
1822: /******* Code below is from Trimble Tsipchat *************/
1823:
1824: /*
1825: * *************************************************************************
1826: *
1827: * Trimble Navigation, Ltd.
1828: * OEM Products Development Group
1829: * P.O. Box 3642
1830: * 645 North Mary Avenue
1831: * Sunnyvale, California 94088-3642
1832: *
1833: * Corporate Headquarter:
1834: * Telephone: (408) 481-8000
1835: * Fax: (408) 481-6005
1836: *
1837: * Technical Support Center:
1838: * Telephone: (800) 767-4822 (U.S. and Canada)
1839: * (408) 481-6940 (outside U.S. and Canada)
1840: * Fax: (408) 481-6020
1841: * BBS: (408) 481-7800
1842: * e-mail: trimble_support@trimble.com
1843: * ftp://ftp.trimble.com/pub/sct/embedded/bin
1844: *
1845: * *************************************************************************
1846: *
1847: * ------- BYTE-SWAPPING -------
1848: * TSIP is big-endian (Motorola) protocol. To use on little-endian (Intel)
1849: * systems, the bytes of all multi-byte types (shorts, floats, doubles, etc.)
1850: * must be reversed. This is controlled by the MACRO BYTESWAP; if defined, it
1851: * assumes little-endian protocol.
1852: * --------------------------------
1853: *
1854: * T_PARSER.C and T_PARSER.H contains primitive functions that interpret
1855: * reports received from the receiver. A second source file pair,
1856: * T_FORMAT.C and T_FORMAT.H, contin the matching TSIP command formatters.
1857: *
1858: * The module is in very portable, basic C language. It can be used as is, or
1859: * with minimal changes if a TSIP communications application is needed separate
1860: * from TSIPCHAT. The construction of most argument lists avoid the use of
1861: * structures, but the developer is encouraged to reconstruct them using such
1862: * definitions to meet project requirements. Declarations of T_PARSER.C
1863: * functions are included in T_PARSER.H to provide prototyping definitions.
1864: *
1865: * There are two types of functions: a serial input processing routine,
1866: * tsip_input_proc()
1867: * which assembles incoming bytes into a TSIPPKT structure, and the
1868: * report parsers, rpt_0x??().
1869: *
1870: * 1) The function tsip_input_proc() accumulates bytes from the receiver,
1871: * strips control bytes (DLE), and checks if the report end sequence (DLE ETX)
1872: * has been received. rpt.status is defined as TSIP_PARSED_FULL (== 1)
1873: * if a complete packet is available.
1874: *
1875: * 2) The functions rpt_0x??() are report string interpreters patterned after
1876: * the document called "Trimble Standard Interface Protocol". It should be
1877: * noted that if the report buffer is sent into the receiver with the wrong
1878: * length (byte count), the rpt_0x??() returns the Boolean equivalence for
1879: * TRUE.
1880: *
1881: * *************************************************************************
1882: *
1883: */
1884:
1885:
1886: /*
1887: * reads bytes until serial buffer is empty or a complete report
1888: * has been received; end of report is signified by DLE ETX.
1889: */
1890: static void
1891: tsip_input_proc(
1892: TSIPPKT *rpt,
1893: int inbyte
1894: )
1895: {
1896: unsigned char newbyte;
1897:
1898: if (inbyte < 0 || inbyte > 0xFF) return;
1899:
1900: newbyte = (unsigned char)(inbyte);
1901: switch (rpt->status)
1902: {
1903: case TSIP_PARSED_DLE_1:
1904: switch (newbyte)
1905: {
1906: case 0:
1907: case ETX:
1908: /* illegal TSIP IDs */
1909: rpt->len = 0;
1910: rpt->status = TSIP_PARSED_EMPTY;
1911: break;
1912: case DLE:
1913: /* try normal message start again */
1914: rpt->len = 0;
1915: rpt->status = TSIP_PARSED_DLE_1;
1916: break;
1917: default:
1918: /* legal TSIP ID; start message */
1919: rpt->code = newbyte;
1920: rpt->len = 0;
1921: rpt->status = TSIP_PARSED_DATA;
1922: break;
1923: }
1924: break;
1925: case TSIP_PARSED_DATA:
1926: switch (newbyte) {
1927: case DLE:
1928: /* expect DLE or ETX next */
1929: rpt->status = TSIP_PARSED_DLE_2;
1930: break;
1931: default:
1932: /* normal data byte */
1933: rpt->buf[rpt->len] = newbyte;
1934: rpt->len++;
1935: /* no change in rpt->status */
1936: break;
1937: }
1938: break;
1939: case TSIP_PARSED_DLE_2:
1940: switch (newbyte) {
1941: case DLE:
1942: /* normal data byte */
1943: rpt->buf[rpt->len] = newbyte;
1944: rpt->len++;
1945: rpt->status = TSIP_PARSED_DATA;
1946: break;
1947: case ETX:
1948: /* end of message; return TRUE here. */
1949: rpt->status = TSIP_PARSED_FULL;
1950: break;
1951: default:
1952: /* error: treat as TSIP_PARSED_DLE_1; start new report packet */
1953: rpt->code = newbyte;
1954: rpt->len = 0;
1955: rpt->status = TSIP_PARSED_DATA;
1956: }
1957: break;
1958: case TSIP_PARSED_FULL:
1959: case TSIP_PARSED_EMPTY:
1960: default:
1961: switch (newbyte) {
1962: case DLE:
1963: /* normal message start */
1964: rpt->len = 0;
1965: rpt->status = TSIP_PARSED_DLE_1;
1966: break;
1967: default:
1968: /* error: ignore newbyte */
1969: rpt->len = 0;
1970: rpt->status = TSIP_PARSED_EMPTY;
1971: }
1972: break;
1973: }
1974: if (rpt->len > MAX_RPTBUF) {
1975: /* error: start new report packet */
1976: rpt->status = TSIP_PARSED_EMPTY;
1977: rpt->len = 0;
1978: }
1979: }
1980:
1981: #ifdef TRIMBLE_OUTPUT_FUNC
1982:
1983: /**/
1984: /* Channel A configuration for dual port operation */
1985: short
1986: rpt_0x3D(
1987: TSIPPKT *rpt,
1988: unsigned char *tx_baud_index,
1989: unsigned char *rx_baud_index,
1990: unsigned char *char_format_index,
1991: unsigned char *stop_bits,
1992: unsigned char *tx_mode_index,
1993: unsigned char *rx_mode_index
1994: )
1995: {
1996: unsigned char *buf;
1997: buf = rpt->buf;
1998:
1999: if (rpt->len != 6) return TRUE;
2000: *tx_baud_index = buf[0];
2001: *rx_baud_index = buf[1];
2002: *char_format_index = buf[2];
2003: *stop_bits = (unsigned char)((buf[3] == 0x07) ? 1 : 2);
2004: *tx_mode_index = buf[4];
2005: *rx_mode_index = buf[5];
2006: return FALSE;
2007: }
2008:
2009: /**/
2010: /* almanac data for specified satellite */
2011: short
2012: rpt_0x40(
2013: TSIPPKT *rpt,
2014: unsigned char *sv_prn,
2015: short *week_num,
2016: float *t_zc,
2017: float *eccentricity,
2018: float *t_oa,
2019: float *i_0,
2020: float *OMEGA_dot,
2021: float *sqrt_A,
2022: float *OMEGA_0,
2023: float *omega,
2024: float *M_0
2025: )
2026: {
2027: unsigned char *buf;
2028: buf = rpt->buf;
2029:
2030: if (rpt->len != 39) return TRUE;
2031: *sv_prn = buf[0];
2032: *t_zc = bGetSingle (&buf[1]);
2033: *week_num = bGetShort (&buf[5]);
2034: *eccentricity = bGetSingle (&buf[7]);
2035: *t_oa = bGetSingle (&buf[11]);
2036: *i_0 = bGetSingle (&buf[15]);
2037: *OMEGA_dot = bGetSingle (&buf[19]);
2038: *sqrt_A = bGetSingle (&buf[23]);
2039: *OMEGA_0 = bGetSingle (&buf[27]);
2040: *omega = bGetSingle (&buf[31]);
2041: *M_0 = bGetSingle (&buf[35]);
2042: return FALSE;
2043: }
2044:
2045: /* GPS time */
2046: short
2047: rpt_0x41(
2048: TSIPPKT *rpt,
2049: float *time_of_week,
2050: float *UTC_offset,
2051: short *week_num
2052: )
2053: {
2054: unsigned char *buf;
2055: buf = rpt->buf;
2056:
2057: if (rpt->len != 10) return TRUE;
2058: *time_of_week = bGetSingle (buf);
2059: *week_num = bGetShort (&buf[4]);
2060: *UTC_offset = bGetSingle (&buf[6]);
2061: return FALSE;
2062: }
2063:
2064: /* position in ECEF, single precision */
2065: short
2066: rpt_0x42(
2067: TSIPPKT *rpt,
2068: float pos_ECEF[3],
2069: float *time_of_fix
2070: )
2071: {
2072: unsigned char *buf;
2073: buf = rpt->buf;
2074:
2075: if (rpt->len != 16) return TRUE;
2076: pos_ECEF[0] = bGetSingle (buf);
2077: pos_ECEF[1]= bGetSingle (&buf[4]);
2078: pos_ECEF[2]= bGetSingle (&buf[8]);
2079: *time_of_fix = bGetSingle (&buf[12]);
2080: return FALSE;
2081: }
2082:
2083: /* velocity in ECEF, single precision */
2084: short
2085: rpt_0x43(
2086: TSIPPKT *rpt,
2087: float ECEF_vel[3],
2088: float *freq_offset,
2089: float *time_of_fix
2090: )
2091: {
2092: unsigned char *buf;
2093: buf = rpt->buf;
2094:
2095: if (rpt->len != 20) return TRUE;
2096: ECEF_vel[0] = bGetSingle (buf);
2097: ECEF_vel[1] = bGetSingle (&buf[4]);
2098: ECEF_vel[2] = bGetSingle (&buf[8]);
2099: *freq_offset = bGetSingle (&buf[12]);
2100: *time_of_fix = bGetSingle (&buf[16]);
2101: return FALSE;
2102: }
2103:
2104: /* software versions */
2105: short
2106: rpt_0x45(
2107: TSIPPKT *rpt,
2108: unsigned char *major_nav_version,
2109: unsigned char *minor_nav_version,
2110: unsigned char *nav_day,
2111: unsigned char *nav_month,
2112: unsigned char *nav_year,
2113: unsigned char *major_dsp_version,
2114: unsigned char *minor_dsp_version,
2115: unsigned char *dsp_day,
2116: unsigned char *dsp_month,
2117: unsigned char *dsp_year
2118: )
2119: {
2120: unsigned char *buf;
2121: buf = rpt->buf;
2122:
2123: if (rpt->len != 10) return TRUE;
2124: *major_nav_version = buf[0];
2125: *minor_nav_version = buf[1];
2126: *nav_day = buf[2];
2127: *nav_month = buf[3];
2128: *nav_year = buf[4];
2129: *major_dsp_version = buf[5];
2130: *minor_dsp_version = buf[6];
2131: *dsp_day = buf[7];
2132: *dsp_month = buf[8];
2133: *dsp_year = buf[9];
2134: return FALSE;
2135: }
2136:
2137: /* receiver health and status */
2138: short
2139: rpt_0x46(
2140: TSIPPKT *rpt,
2141: unsigned char *status1,
2142: unsigned char *status2
2143: )
2144: {
2145: unsigned char *buf;
2146: buf = rpt->buf;
2147:
2148: if (rpt->len != 2) return TRUE;
2149: *status1 = buf[0];
2150: *status2 = buf[1];
2151: return FALSE;
2152: }
2153:
2154: /* signal levels for all satellites tracked */
2155: short
2156: rpt_0x47(
2157: TSIPPKT *rpt,
2158: unsigned char *nsvs,
2159: unsigned char *sv_prn,
2160: float *snr
2161: )
2162: {
2163: short isv;
2164: unsigned char *buf;
2165: buf = rpt->buf;
2166:
2167: if (rpt->len != 1 + 5*buf[0]) return TRUE;
2168: *nsvs = buf[0];
2169: for (isv = 0; isv < (*nsvs); isv++) {
2170: sv_prn[isv] = buf[5*isv + 1];
2171: snr[isv] = bGetSingle (&buf[5*isv + 2]);
2172: }
2173: return FALSE;
2174: }
2175:
2176: /* GPS system message */
2177: short
2178: rpt_0x48(
2179: TSIPPKT *rpt,
2180: unsigned char *message
2181: )
2182: {
2183: unsigned char *buf;
2184: buf = rpt->buf;
2185:
2186: if (rpt->len != 22) return TRUE;
2187: memcpy (message, buf, 22);
2188: message[22] = 0;
2189: return FALSE;
2190: }
2191:
2192: /* health for all satellites from almanac health page */
2193: short
2194: rpt_0x49(
2195: TSIPPKT *rpt,
2196: unsigned char *sv_health
2197: )
2198: {
2199: short i;
2200: unsigned char *buf;
2201: buf = rpt->buf;
2202:
2203: if (rpt->len != 32) return TRUE;
2204: for (i = 0; i < 32; i++) sv_health [i]= buf[i];
2205: return FALSE;
2206: }
2207:
2208: /* position in lat-lon-alt, single precision */
2209: short
2210: rpt_0x4A(
2211: TSIPPKT *rpt,
2212: float *lat,
2213: float *lon,
2214: float *alt,
2215: float *clock_bias,
2216: float *time_of_fix
2217: )
2218: {
2219: unsigned char *buf;
2220: buf = rpt->buf;
2221:
2222: if (rpt->len != 20) return TRUE;
2223: *lat = bGetSingle (buf);
2224: *lon = bGetSingle (&buf[4]);
2225: *alt = bGetSingle (&buf[8]);
2226: *clock_bias = bGetSingle (&buf[12]);
2227: *time_of_fix = bGetSingle (&buf[16]);
2228: return FALSE;
2229: }
2230:
2231: /* reference altitude parameters */
2232: short
2233: rpt_0x4A_2(
2234: TSIPPKT *rpt,
2235: float *alt,
2236: float *dummy,
2237: unsigned char *alt_flag
2238: )
2239: {
2240: unsigned char *buf;
2241:
2242: buf = rpt->buf;
2243:
2244: if (rpt->len != 9) return TRUE;
2245: *alt = bGetSingle (buf);
2246: *dummy = bGetSingle (&buf[4]);
2247: *alt_flag = buf[8];
2248: return FALSE;
2249: }
2250:
2251: /* machine ID code, status */
2252: short
2253: rpt_0x4B(
2254: TSIPPKT *rpt,
2255: unsigned char *machine_id,
2256: unsigned char *status3,
2257: unsigned char *status4
2258: )
2259: {
2260: unsigned char *buf;
2261: buf = rpt->buf;
2262:
2263: if (rpt->len != 3) return TRUE;
2264: *machine_id = buf[0];
2265: *status3 = buf[1];
2266: *status4 = buf[2];
2267: return FALSE;
2268: }
2269:
2270: /* operating parameters and masks */
2271: short
2272: rpt_0x4C(
2273: TSIPPKT *rpt,
2274: unsigned char *dyn_code,
2275: float *el_mask,
2276: float *snr_mask,
2277: float *dop_mask,
2278: float *dop_switch
2279: )
2280: {
2281: unsigned char *buf;
2282: buf = rpt->buf;
2283:
2284: if (rpt->len != 17) return TRUE;
2285: *dyn_code = buf[0];
2286: *el_mask = bGetSingle (&buf[1]);
2287: *snr_mask = bGetSingle (&buf[5]);
2288: *dop_mask = bGetSingle (&buf[9]);
2289: *dop_switch = bGetSingle (&buf[13]);
2290: return FALSE;
2291: }
2292:
2293: /* oscillator offset */
2294: short
2295: rpt_0x4D(
2296: TSIPPKT *rpt,
2297: float *osc_offset
2298: )
2299: {
2300: unsigned char *buf;
2301: buf = rpt->buf;
2302:
2303: if (rpt->len != 4) return TRUE;
2304: *osc_offset = bGetSingle (buf);
2305: return FALSE;
2306: }
2307:
2308: /* yes/no response to command to set GPS time */
2309: short
2310: rpt_0x4E(
2311: TSIPPKT *rpt,
2312: unsigned char *response
2313: )
2314: {
2315: unsigned char *buf;
2316: buf = rpt->buf;
2317:
2318: if (rpt->len != 1) return TRUE;
2319: *response = buf[0];
2320: return FALSE;
2321: }
2322:
2323: /* UTC data */
2324: short
2325: rpt_0x4F(
2326: TSIPPKT *rpt,
2327: double *a0,
2328: float *a1,
2329: float *time_of_data,
2330: short *dt_ls,
2331: short *wn_t,
2332: short *wn_lsf,
2333: short *dn,
2334: short *dt_lsf
2335: )
2336: {
2337: unsigned char *buf;
2338: buf = rpt->buf;
2339:
2340: if (rpt->len != 26) return TRUE;
2341: *a0 = bGetDouble (buf);
2342: *a1 = bGetSingle (&buf[8]);
2343: *dt_ls = bGetShort (&buf[12]);
2344: *time_of_data = bGetSingle (&buf[14]);
2345: *wn_t = bGetShort (&buf[18]);
2346: *wn_lsf = bGetShort (&buf[20]);
2347: *dn = bGetShort (&buf[22]);
2348: *dt_lsf = bGetShort (&buf[24]);
2349: return FALSE;
2350: }
2351:
2352: /**/
2353: /* clock offset and frequency offset in 1-SV (0-D) mode */
2354: short
2355: rpt_0x54(
2356: TSIPPKT *rpt,
2357: float *clock_bias,
2358: float *freq_offset,
2359: float *time_of_fix
2360: )
2361: {
2362: unsigned char *buf;
2363: buf = rpt->buf;
2364:
2365: if (rpt->len != 12) return TRUE;
2366: *clock_bias = bGetSingle (buf);
2367: *freq_offset = bGetSingle (&buf[4]);
2368: *time_of_fix = bGetSingle (&buf[8]);
2369: return FALSE;
2370: }
2371:
2372: /* I/O serial options */
2373: short
2374: rpt_0x55(
2375: TSIPPKT *rpt,
2376: unsigned char *pos_code,
2377: unsigned char *vel_code,
2378: unsigned char *time_code,
2379: unsigned char *aux_code
2380: )
2381: {
2382: unsigned char *buf;
2383: buf = rpt->buf;
2384:
2385: if (rpt->len != 4) return TRUE;
2386: *pos_code = buf[0];
2387: *vel_code = buf[1];
2388: *time_code = buf[2];
2389: *aux_code = buf[3];
2390: return FALSE;
2391: }
2392:
2393: /* velocity in east-north-up coordinates */
2394: short
2395: rpt_0x56(
2396: TSIPPKT *rpt,
2397: float vel_ENU[3],
2398: float *freq_offset,
2399: float *time_of_fix
2400: )
2401: {
2402: unsigned char *buf;
2403: buf = rpt->buf;
2404:
2405: if (rpt->len != 20) return TRUE;
2406: /* east */
2407: vel_ENU[0] = bGetSingle (buf);
2408: /* north */
2409: vel_ENU[1] = bGetSingle (&buf[4]);
2410: /* up */
2411: vel_ENU[2] = bGetSingle (&buf[8]);
2412: *freq_offset = bGetSingle (&buf[12]);
2413: *time_of_fix = bGetSingle (&buf[16]);
2414: return FALSE;
2415: }
2416:
2417: /* info about last computed fix */
2418: short
2419: rpt_0x57(
2420: TSIPPKT *rpt,
2421: unsigned char *source_code,
2422: unsigned char *diag_code,
2423: short *week_num,
2424: float *time_of_fix
2425: )
2426: {
2427: unsigned char *buf;
2428: buf = rpt->buf;
2429:
2430: if (rpt->len != 8) return TRUE;
2431: *source_code = buf[0];
2432: *diag_code = buf[1];
2433: *time_of_fix = bGetSingle (&buf[2]);
2434: *week_num = bGetShort (&buf[6]);
2435: return FALSE;
2436: }
2437:
2438: /* GPS system data or acknowledgment of GPS system data load */
2439: short
2440: rpt_0x58(
2441: TSIPPKT *rpt,
2442: unsigned char *op_code,
2443: unsigned char *data_type,
2444: unsigned char *sv_prn,
2445: unsigned char *data_length,
2446: unsigned char *data_packet
2447: )
2448: {
2449: unsigned char *buf, *buf4;
2450: short dl;
2451: ALM_INFO* alminfo;
2452: ION_INFO* ioninfo;
2453: UTC_INFO* utcinfo;
2454: NAV_INFO* navinfo;
2455:
2456: buf = rpt->buf;
2457:
2458: if (buf[0] == 2) {
2459: if (rpt->len < 4) return TRUE;
2460: if (rpt->len != 4+buf[3]) return TRUE;
2461: }
2462: else if (rpt->len != 3) {
2463: return TRUE;
2464: }
2465: *op_code = buf[0];
2466: *data_type = buf[1];
2467: *sv_prn = buf[2];
2468: if (*op_code == 2) {
2469: dl = buf[3];
2470: *data_length = (unsigned char)dl;
2471: buf4 = &buf[4];
2472: switch (*data_type) {
2473: case 2:
2474: /* Almanac */
2475: if (*data_length != sizeof (ALM_INFO)) return TRUE;
2476: alminfo = (ALM_INFO*)data_packet;
2477: alminfo->t_oa_raw = buf4[0];
2478: alminfo->SV_health = buf4[1];
2479: alminfo->e = bGetSingle(&buf4[2]);
2480: alminfo->t_oa = bGetSingle(&buf4[6]);
2481: alminfo->i_0 = bGetSingle(&buf4[10]);
2482: alminfo->OMEGADOT = bGetSingle(&buf4[14]);
2483: alminfo->sqrt_A = bGetSingle(&buf4[18]);
2484: alminfo->OMEGA_0 = bGetSingle(&buf4[22]);
2485: alminfo->omega = bGetSingle(&buf4[26]);
2486: alminfo->M_0 = bGetSingle(&buf4[30]);
2487: alminfo->a_f0 = bGetSingle(&buf4[34]);
2488: alminfo->a_f1 = bGetSingle(&buf4[38]);
2489: alminfo->Axis = bGetSingle(&buf4[42]);
2490: alminfo->n = bGetSingle(&buf4[46]);
2491: alminfo->OMEGA_n = bGetSingle(&buf4[50]);
2492: alminfo->ODOT_n = bGetSingle(&buf4[54]);
2493: alminfo->t_zc = bGetSingle(&buf4[58]);
2494: alminfo->weeknum = bGetShort(&buf4[62]);
2495: alminfo->wn_oa = bGetShort(&buf4[64]);
2496: break;
2497:
2498: case 3:
2499: /* Almanac health page */
2500: if (*data_length != sizeof (ALH_PARMS) + 3) return TRUE;
2501:
2502: /* this record is returned raw */
2503: memcpy (data_packet, buf4, dl);
2504: break;
2505:
2506: case 4:
2507: /* Ionosphere */
2508: if (*data_length != sizeof (ION_INFO) + 8) return TRUE;
2509: ioninfo = (ION_INFO*)data_packet;
2510: ioninfo->alpha_0 = bGetSingle (&buf4[8]);
2511: ioninfo->alpha_1 = bGetSingle (&buf4[12]);
2512: ioninfo->alpha_2 = bGetSingle (&buf4[16]);
2513: ioninfo->alpha_3 = bGetSingle (&buf4[20]);
2514: ioninfo->beta_0 = bGetSingle (&buf4[24]);
2515: ioninfo->beta_1 = bGetSingle (&buf4[28]);
2516: ioninfo->beta_2 = bGetSingle (&buf4[32]);
2517: ioninfo->beta_3 = bGetSingle (&buf4[36]);
2518: break;
2519:
2520: case 5:
2521: /* UTC */
2522: if (*data_length != sizeof (UTC_INFO) + 13) return TRUE;
2523: utcinfo = (UTC_INFO*)data_packet;
2524: utcinfo->A_0 = bGetDouble (&buf4[13]);
2525: utcinfo->A_1 = bGetSingle (&buf4[21]);
2526: utcinfo->delta_t_LS = bGetShort (&buf4[25]);
2527: utcinfo->t_ot = bGetSingle(&buf4[27]);
2528: utcinfo->WN_t = bGetShort (&buf4[31]);
2529: utcinfo->WN_LSF = bGetShort (&buf4[33]);
2530: utcinfo->DN = bGetShort (&buf4[35]);
2531: utcinfo->delta_t_LSF = bGetShort (&buf4[37]);
2532: break;
2533:
2534: case 6:
2535: /* Ephemeris */
2536: if (*data_length != sizeof (NAV_INFO) - 1) return TRUE;
2537:
2538: navinfo = (NAV_INFO*)data_packet;
2539:
2540: navinfo->sv_number = buf4[0];
2541: navinfo->t_ephem = bGetSingle (&buf4[1]);
2542: navinfo->ephclk.weeknum = bGetShort (&buf4[5]);
2543:
2544: navinfo->ephclk.codeL2 = buf4[7];
2545: navinfo->ephclk.L2Pdata = buf4[8];
2546: navinfo->ephclk.SVacc_raw = buf4[9];
2547: navinfo->ephclk.SV_health = buf4[10];
2548: navinfo->ephclk.IODC = bGetShort (&buf4[11]);
2549: navinfo->ephclk.T_GD = bGetSingle (&buf4[13]);
2550: navinfo->ephclk.t_oc = bGetSingle (&buf4[17]);
2551: navinfo->ephclk.a_f2 = bGetSingle (&buf4[21]);
2552: navinfo->ephclk.a_f1 = bGetSingle (&buf4[25]);
2553: navinfo->ephclk.a_f0 = bGetSingle (&buf4[29]);
2554: navinfo->ephclk.SVacc = bGetSingle (&buf4[33]);
2555:
2556: navinfo->ephorb.IODE = buf4[37];
2557: navinfo->ephorb.fit_interval = buf4[38];
2558: navinfo->ephorb.C_rs = bGetSingle (&buf4[39]);
2559: navinfo->ephorb.delta_n = bGetSingle (&buf4[43]);
2560: navinfo->ephorb.M_0 = bGetDouble (&buf4[47]);
2561: navinfo->ephorb.C_uc = bGetSingle (&buf4[55]);
2562: navinfo->ephorb.e = bGetDouble (&buf4[59]);
2563: navinfo->ephorb.C_us = bGetSingle (&buf4[67]);
2564: navinfo->ephorb.sqrt_A = bGetDouble (&buf4[71]);
2565: navinfo->ephorb.t_oe = bGetSingle (&buf4[79]);
2566: navinfo->ephorb.C_ic = bGetSingle (&buf4[83]);
2567: navinfo->ephorb.OMEGA_0 = bGetDouble (&buf4[87]);
2568: navinfo->ephorb.C_is = bGetSingle (&buf4[95]);
2569: navinfo->ephorb.i_0 = bGetDouble (&buf4[99]);
2570: navinfo->ephorb.C_rc = bGetSingle (&buf4[107]);
2571: navinfo->ephorb.omega = bGetDouble (&buf4[111]);
2572: navinfo->ephorb.OMEGADOT=bGetSingle (&buf4[119]);
2573: navinfo->ephorb.IDOT = bGetSingle (&buf4[123]);
2574: navinfo->ephorb.Axis = bGetDouble (&buf4[127]);
2575: navinfo->ephorb.n = bGetDouble (&buf4[135]);
2576: navinfo->ephorb.r1me2 = bGetDouble (&buf4[143]);
2577: navinfo->ephorb.OMEGA_n=bGetDouble (&buf4[151]);
2578: navinfo->ephorb.ODOT_n = bGetDouble (&buf4[159]);
2579: break;
2580: }
2581: }
2582: return FALSE;
2583: }
2584:
2585: /* satellite enable/disable or health heed/ignore list */
2586: short
2587: rpt_0x59(
2588: TSIPPKT *rpt,
2589: unsigned char *code_type,
2590: unsigned char status_code[32]
2591: )
2592: {
2593: short iprn;
2594: unsigned char *buf;
2595: buf = rpt->buf;
2596:
2597: if (rpt->len != 33) return TRUE;
2598: *code_type = buf[0];
2599: for (iprn = 0; iprn < 32; iprn++)
2600: status_code[iprn] = buf[iprn + 1];
2601: return FALSE;
2602: }
2603:
2604: /* raw measurement data - code phase/Doppler */
2605: short
2606: rpt_0x5A(
2607: TSIPPKT *rpt,
2608: unsigned char *sv_prn,
2609: float *sample_length,
2610: float *signal_level,
2611: float *code_phase,
2612: float *Doppler,
2613: double *time_of_fix
2614: )
2615: {
2616: unsigned char *buf;
2617: buf = rpt->buf;
2618:
2619: if (rpt->len != 25) return TRUE;
2620: *sv_prn = buf[0];
2621: *sample_length = bGetSingle (&buf[1]);
2622: *signal_level = bGetSingle (&buf[5]);
2623: *code_phase = bGetSingle (&buf[9]);
2624: *Doppler = bGetSingle (&buf[13]);
2625: *time_of_fix = bGetDouble (&buf[17]);
2626: return FALSE;
2627: }
2628:
2629: /* satellite ephorb status */
2630: short
2631: rpt_0x5B(
2632: TSIPPKT *rpt,
2633: unsigned char *sv_prn,
2634: unsigned char *sv_health,
2635: unsigned char *sv_iode,
2636: unsigned char *fit_interval_flag,
2637: float *time_of_collection,
2638: float *time_of_eph,
2639: float *sv_accy
2640: )
2641: {
2642: unsigned char *buf;
2643: buf = rpt->buf;
2644:
2645: if (rpt->len != 16) return TRUE;
2646: *sv_prn = buf[0];
2647: *time_of_collection = bGetSingle (&buf[1]);
2648: *sv_health = buf[5];
2649: *sv_iode = buf[6];
2650: *time_of_eph = bGetSingle (&buf[7]);
2651: *fit_interval_flag = buf[11];
2652: *sv_accy = bGetSingle (&buf[12]);
2653: return FALSE;
2654: }
2655:
2656: /* satellite tracking status */
2657: short
2658: rpt_0x5C(
2659: TSIPPKT *rpt,
2660: unsigned char *sv_prn,
2661: unsigned char *slot,
2662: unsigned char *chan,
2663: unsigned char *acq_flag,
2664: unsigned char *eph_flag,
2665: float *signal_level,
2666: float *time_of_last_msmt,
2667: float *elev,
2668: float *azim,
2669: unsigned char *old_msmt_flag,
2670: unsigned char *integer_msec_flag,
2671: unsigned char *bad_data_flag,
2672: unsigned char *data_collect_flag
2673: )
2674: {
2675: unsigned char *buf;
2676: buf = rpt->buf;
2677:
2678: if (rpt->len != 24) return TRUE;
2679: *sv_prn = buf[0];
2680: *slot = (unsigned char)((buf[1] & 0x07) + 1);
2681: *chan = (unsigned char)(buf[1] >> 3);
2682: if (*chan == 0x10) *chan = 2;
2683: else (*chan)++;
2684: *acq_flag = buf[2];
2685: *eph_flag = buf[3];
2686: *signal_level = bGetSingle (&buf[4]);
2687: *time_of_last_msmt = bGetSingle (&buf[8]);
2688: *elev = bGetSingle (&buf[12]);
2689: *azim = bGetSingle (&buf[16]);
2690: *old_msmt_flag = buf[20];
2691: *integer_msec_flag = buf[21];
2692: *bad_data_flag = buf[22];
2693: *data_collect_flag = buf[23];
2694: return FALSE;
2695: }
2696:
2697: /**/
2698: /* over-determined satellite selection for position fixes, PDOP, fix mode */
2699: short
2700: rpt_0x6D(
2701: TSIPPKT *rpt,
2702: unsigned char *manual_mode,
2703: unsigned char *nsvs,
2704: unsigned char *ndim,
2705: unsigned char sv_prn[],
2706: float *pdop,
2707: float *hdop,
2708: float *vdop,
2709: float *tdop
2710: )
2711: {
2712: short islot;
2713: unsigned char *buf;
2714: buf = rpt->buf;
2715:
2716: *nsvs = (unsigned char)((buf[0] & 0xF0) >> 4);
2717: if ((*nsvs)>8) return TRUE;
2718: if (rpt->len != 17 + (*nsvs) ) return TRUE;
2719:
2720: *manual_mode = (unsigned char)(buf[0] & 0x08);
2721: *ndim = (unsigned char)((buf[0] & 0x07));
2722: *pdop = bGetSingle (&buf[1]);
2723: *hdop = bGetSingle (&buf[5]);
2724: *vdop = bGetSingle (&buf[9]);
2725: *tdop = bGetSingle (&buf[13]);
2726: for (islot = 0; islot < (*nsvs); islot++)
2727: sv_prn[islot] = buf[islot + 17];
2728: return FALSE;
2729: }
2730:
2731: /**/
2732: /* differential fix mode */
2733: short
2734: rpt_0x82(
2735: TSIPPKT *rpt,
2736: unsigned char *diff_mode
2737: )
2738: {
2739: unsigned char *buf;
2740: buf = rpt->buf;
2741:
2742: if (rpt->len != 1) return TRUE;
2743: *diff_mode = buf[0];
2744: return FALSE;
2745: }
2746:
2747: /* position, ECEF double precision */
2748: short
2749: rpt_0x83(
2750: TSIPPKT *rpt,
2751: double ECEF_pos[3],
2752: double *clock_bias,
2753: float *time_of_fix
2754: )
2755: {
2756: unsigned char *buf;
2757: buf = rpt->buf;
2758:
2759: if (rpt->len != 36) return TRUE;
2760: ECEF_pos[0] = bGetDouble (buf);
2761: ECEF_pos[1] = bGetDouble (&buf[8]);
2762: ECEF_pos[2] = bGetDouble (&buf[16]);
2763: *clock_bias = bGetDouble (&buf[24]);
2764: *time_of_fix = bGetSingle (&buf[32]);
2765: return FALSE;
2766: }
2767:
2768: /* position, lat-lon-alt double precision */
2769: short
2770: rpt_0x84(
2771: TSIPPKT *rpt,
2772: double *lat,
2773: double *lon,
2774: double *alt,
2775: double *clock_bias,
2776: float *time_of_fix
2777: )
2778: {
2779: unsigned char *buf;
2780: buf = rpt->buf;
2781:
2782: if (rpt->len != 36) return TRUE;
2783: *lat = bGetDouble (buf);
2784: *lon = bGetDouble (&buf[8]);
2785: *alt = bGetDouble (&buf[16]);
2786: *clock_bias = bGetDouble (&buf[24]);
2787: *time_of_fix = bGetSingle (&buf[32]);
2788: return FALSE;
2789: }
2790:
2791: short
2792: rpt_Paly0xBB(
2793: TSIPPKT *rpt,
2794: TSIP_RCVR_CFG *TsipxBB
2795: )
2796: {
2797: unsigned char *buf;
2798: buf = rpt->buf;
2799:
2800: /* Palisade is inconsistent with other TSIP, which has a length of 40 */
2801: /* if (rpt->len != 40) return TRUE; */
2802: if (rpt->len != 43) return TRUE;
2803:
2804: TsipxBB->bSubcode = buf[0];
2805: TsipxBB->operating_mode = buf[1];
2806: TsipxBB->dyn_code = buf[3];
2807: TsipxBB->elev_mask = bGetSingle (&buf[5]);
2808: TsipxBB->cno_mask = bGetSingle (&buf[9]);
2809: TsipxBB->dop_mask = bGetSingle (&buf[13]);
2810: TsipxBB->dop_switch = bGetSingle (&buf[17]);
2811: return FALSE;
2812: }
2813:
2814: /* Receiver serial port configuration */
2815: short
2816: rpt_0xBC(
2817: TSIPPKT *rpt,
2818: unsigned char *port_num,
2819: unsigned char *in_baud,
2820: unsigned char *out_baud,
2821: unsigned char *data_bits,
2822: unsigned char *parity,
2823: unsigned char *stop_bits,
2824: unsigned char *flow_control,
2825: unsigned char *protocols_in,
2826: unsigned char *protocols_out,
2827: unsigned char *reserved
2828: )
2829: {
2830: unsigned char *buf;
2831: buf = rpt->buf;
2832:
2833: if (rpt->len != 10) return TRUE;
2834: *port_num = buf[0];
2835: *in_baud = buf[1];
2836: *out_baud = buf[2];
2837: *data_bits = buf[3];
2838: *parity = buf[4];
2839: *stop_bits = buf[5];
2840: *flow_control = buf[6];
2841: *protocols_in = buf[7];
2842: *protocols_out = buf[8];
2843: *reserved = buf[9];
2844:
2845: return FALSE;
2846: }
2847:
2848: /**** Superpackets ****/
2849:
2850: short
2851: rpt_0x8F0B(
2852: TSIPPKT *rpt,
2853: unsigned short *event,
2854: double *tow,
2855: unsigned char *date,
2856: unsigned char *month,
2857: short *year,
2858: unsigned char *dim_mode,
2859: short *utc_offset,
2860: double *bias,
2861: double *drift,
2862: float *bias_unc,
2863: float *dr_unc,
2864: double *lat,
2865: double *lon,
2866: double *alt,
2867: char sv_id[8]
2868: )
2869: {
2870: short local_index;
2871: unsigned char *buf;
2872:
2873: buf = rpt->buf;
2874: if (rpt->len != 74) return TRUE;
2875: *event = bGetShort(&buf[1]);
2876: *tow = bGetDouble(&buf[3]);
2877: *date = buf[11];
2878: *month = buf[12];
2879: *year = bGetShort(&buf[13]);
2880: *dim_mode = buf[15];
2881: *utc_offset = bGetShort(&buf[16]);
2882: *bias = bGetDouble(&buf[18]);
2883: *drift = bGetDouble(&buf[26]);
2884: *bias_unc = bGetSingle(&buf[34]);
2885: *dr_unc = bGetSingle(&buf[38]);
2886: *lat = bGetDouble(&buf[42]);
2887: *lon = bGetDouble(&buf[50]);
2888: *alt = bGetDouble(&buf[58]);
2889:
2890: for (local_index=0; local_index<8; local_index++) sv_id[local_index] = buf[local_index + 66];
2891: return FALSE;
2892: }
2893:
2894: /* datum index and coefficients */
2895: short
2896: rpt_0x8F14(
2897: TSIPPKT *rpt,
2898: short *datum_idx,
2899: double datum_coeffs[5]
2900: )
2901: {
2902: unsigned char *buf;
2903: buf = rpt->buf;
2904:
2905: if (rpt->len != 43) return TRUE;
2906: *datum_idx = bGetShort(&buf[1]);
2907: datum_coeffs[0] = bGetDouble (&buf[3]);
2908: datum_coeffs[1] = bGetDouble (&buf[11]);
2909: datum_coeffs[2] = bGetDouble (&buf[19]);
2910: datum_coeffs[3] = bGetDouble (&buf[27]);
2911: datum_coeffs[4] = bGetDouble (&buf[35]);
2912: return FALSE;
2913: }
2914:
2915:
2916: /* datum index and coefficients */
2917: short
2918: rpt_0x8F15(
2919: TSIPPKT *rpt,
2920: short *datum_idx,
2921: double datum_coeffs[5]
2922: )
2923: {
2924: unsigned char *buf;
2925: buf = rpt->buf;
2926:
2927: if (rpt->len != 43) return TRUE;
2928: *datum_idx = bGetShort(&buf[1]);
2929: datum_coeffs[0] = bGetDouble (&buf[3]);
2930: datum_coeffs[1] = bGetDouble (&buf[11]);
2931: datum_coeffs[2] = bGetDouble (&buf[19]);
2932: datum_coeffs[3] = bGetDouble (&buf[27]);
2933: datum_coeffs[4] = bGetDouble (&buf[35]);
2934: return FALSE;
2935: }
2936:
2937:
2938: #define MAX_LONG (2147483648.) /* 2**31 */
2939:
2940: short
2941: rpt_0x8F20(
2942: TSIPPKT *rpt,
2943: unsigned char *info,
2944: double *lat,
2945: double *lon,
2946: double *alt,
2947: double vel_enu[],
2948: double *time_of_fix,
2949: short *week_num,
2950: unsigned char *nsvs,
2951: unsigned char sv_prn[],
2952: short sv_IODC[],
2953: short *datum_index
2954: )
2955: {
2956: short
2957: isv;
2958: unsigned char
2959: *buf, prnx, iode;
2960: unsigned long
2961: ulongtemp;
2962: long
2963: longtemp;
2964: double
2965: vel_scale;
2966:
2967: buf = rpt->buf;
2968:
2969: if (rpt->len != 56) return TRUE;
2970:
2971: vel_scale = (buf[24]&1)? 0.020 : 0.005;
2972: vel_enu[0] = bGetShort (buf+2)*vel_scale;
2973: vel_enu[1] = bGetShort (buf+4)*vel_scale;
2974: vel_enu[2] = bGetShort (buf+6)*vel_scale;
2975:
2976: *time_of_fix = bGetULong (buf+8)*.001;
2977:
2978: longtemp = bGetLong (buf+12);
2979: *lat = longtemp*(GPS_PI/MAX_LONG);
2980:
2981: ulongtemp = bGetULong (buf+16);
2982: *lon = ulongtemp*(GPS_PI/MAX_LONG);
2983: if (*lon > GPS_PI) *lon -= 2.0*GPS_PI;
2984:
2985: *alt = bGetLong (buf+20)*.001;
2986: /* 25 blank; 29 = UTC */
2987: (*datum_index) = (short)((short)buf[26]-1);
2988: *info = buf[27];
2989: *nsvs = buf[28];
2990: *week_num = bGetShort (&buf[30]);
2991: for (isv = 0; isv < 8; isv++) {
2992: prnx = buf[32+2*isv];
2993: sv_prn[isv] = (unsigned char)(prnx&0x3F);
2994: iode = buf[33+2*isv];
2995: sv_IODC[isv] = (short)(iode | ((prnx>>6)<<8));
2996: }
2997: return FALSE;
2998: }
2999:
3000: short
3001: rpt_0x8F41(
3002: TSIPPKT *rpt,
3003: unsigned char *bSearchRange,
3004: unsigned char *bBoardOptions,
3005: unsigned long *iiSerialNumber,
3006: unsigned char *bBuildYear,
3007: unsigned char *bBuildMonth,
3008: unsigned char *bBuildDay,
3009: unsigned char *bBuildHour,
3010: float *fOscOffset,
3011: unsigned short *iTestCodeId
3012: )
3013: {
3014: if (rpt->len != 17) return FALSE;
3015: *bSearchRange = rpt->buf[1];
3016: *bBoardOptions = rpt->buf[2];
3017: *iiSerialNumber = bGetLong(&rpt->buf[3]);
3018: *bBuildYear = rpt->buf[7];
3019: *bBuildMonth = rpt->buf[8];
3020: *bBuildDay = rpt->buf[9];
3021: *bBuildHour = rpt->buf[10];
3022: *fOscOffset = bGetSingle(&rpt->buf[11]);
3023: *iTestCodeId = bGetShort(&rpt->buf[15]);
3024: /* Tsipx8E41Data = *Tsipx8E41; */
3025: return TRUE;
3026: }
3027:
3028: short
3029: rpt_0x8F42(
3030: TSIPPKT *rpt,
3031: unsigned char *bProdOptionsPre,
3032: unsigned char *bProdNumberExt,
3033: unsigned short *iCaseSerialNumberPre,
3034: unsigned long *iiCaseSerialNumber,
3035: unsigned long *iiProdNumber,
3036: unsigned short *iPremiumOptions,
3037: unsigned short *iMachineID,
3038: unsigned short *iKey
3039: )
3040: {
3041: if (rpt->len != 19) return FALSE;
3042: *bProdOptionsPre = rpt->buf[1];
3043: *bProdNumberExt = rpt->buf[2];
3044: *iCaseSerialNumberPre = bGetShort(&rpt->buf[3]);
3045: *iiCaseSerialNumber = bGetLong(&rpt->buf[5]);
3046: *iiProdNumber = bGetLong(&rpt->buf[9]);
3047: *iPremiumOptions = bGetShort(&rpt->buf[13]);
3048: *iMachineID = bGetShort(&rpt->buf[15]);
3049: *iKey = bGetShort(&rpt->buf[17]);
3050: return TRUE;
3051: }
3052:
3053: short
3054: rpt_0x8F45(
3055: TSIPPKT *rpt,
3056: unsigned char *bSegMask
3057: )
3058: {
3059: if (rpt->len != 2) return FALSE;
3060: *bSegMask = rpt->buf[1];
3061: return TRUE;
3062: }
3063:
3064: /* Stinger PPS definition */
3065: short
3066: rpt_0x8F4A_16(
3067: TSIPPKT *rpt,
3068: unsigned char *pps_enabled,
3069: unsigned char *pps_timebase,
3070: unsigned char *pos_polarity,
3071: double *pps_offset,
3072: float *bias_unc_threshold
3073: )
3074: {
3075: unsigned char
3076: *buf;
3077:
3078: buf = rpt->buf;
3079: if (rpt->len != 16) return TRUE;
3080: *pps_enabled = buf[1];
3081: *pps_timebase = buf[2];
3082: *pos_polarity = buf[3];
3083: *pps_offset = bGetDouble(&buf[4]);
3084: *bias_unc_threshold = bGetSingle(&buf[12]);
3085: return FALSE;
3086: }
3087:
3088: short
3089: rpt_0x8F4B(
3090: TSIPPKT *rpt,
3091: unsigned long *decorr_max
3092: )
3093: {
3094: unsigned char
3095: *buf;
3096:
3097: buf = rpt->buf;
3098: if (rpt->len != 5) return TRUE;
3099: *decorr_max = bGetLong(&buf[1]);
3100: return FALSE;
3101: }
3102:
3103: short
3104: rpt_0x8F4D(
3105: TSIPPKT *rpt,
3106: unsigned long *event_mask
3107: )
3108: {
3109: unsigned char
3110: *buf;
3111:
3112: buf = rpt->buf;
3113: if (rpt->len != 5) return TRUE;
3114: *event_mask = bGetULong (&buf[1]);
3115: return FALSE;
3116: }
3117:
3118: short
3119: rpt_0x8FA5(
3120: TSIPPKT *rpt,
3121: unsigned char *spktmask
3122: )
3123: {
3124: unsigned char
3125: *buf;
3126:
3127: buf = rpt->buf;
3128: if (rpt->len != 5) return TRUE;
3129: spktmask[0] = buf[1];
3130: spktmask[1] = buf[2];
3131: spktmask[2] = buf[3];
3132: spktmask[3] = buf[4];
3133: return FALSE;
3134: }
3135:
3136: short
3137: rpt_0x8FAD(
3138: TSIPPKT *rpt,
3139: unsigned short *COUNT,
3140: double *FracSec,
3141: unsigned char *Hour,
3142: unsigned char *Minute,
3143: unsigned char *Second,
3144: unsigned char *Day,
3145: unsigned char *Month,
3146: unsigned short *Year,
3147: unsigned char *Status,
3148: unsigned char *Flags
3149: )
3150: {
3151: if (rpt->len != 22) return TRUE;
3152:
3153: *COUNT = bGetUShort(&rpt->buf[1]);
3154: *FracSec = bGetDouble(&rpt->buf[3]);
3155: *Hour = rpt->buf[11];
3156: *Minute = rpt->buf[12];
3157: *Second = rpt->buf[13];
3158: *Day = rpt->buf[14];
3159: *Month = rpt->buf[15];
3160: *Year = bGetUShort(&rpt->buf[16]);
3161: *Status = rpt->buf[18];
3162: *Flags = rpt->buf[19];
3163: return FALSE;
3164: }
3165:
3166:
3167: /*
3168: * *************************************************************************
3169: *
3170: * Trimble Navigation, Ltd.
3171: * OEM Products Development Group
3172: * P.O. Box 3642
3173: * 645 North Mary Avenue
3174: * Sunnyvale, California 94088-3642
3175: *
3176: * Corporate Headquarter:
3177: * Telephone: (408) 481-8000
3178: * Fax: (408) 481-6005
3179: *
3180: * Technical Support Center:
3181: * Telephone: (800) 767-4822 (U.S. and Canada)
3182: * (408) 481-6940 (outside U.S. and Canada)
3183: * Fax: (408) 481-6020
3184: * BBS: (408) 481-7800
3185: * e-mail: trimble_support@trimble.com
3186: * ftp://ftp.trimble.com/pub/sct/embedded/bin
3187: *
3188: * *************************************************************************
3189: *
3190: * T_REPORT.C consists of a primary function TranslateTSIPReportToText()
3191: * called by main().
3192: *
3193: * This function takes a character buffer that has been received as a report
3194: * from a TSIP device and interprets it. The character buffer has been
3195: * assembled using tsip_input_proc() in T_PARSER.C.
3196: *
3197: * A large case statement directs processing to one of many mid-level
3198: * functions. The mid-level functions specific to the current report
3199: * code passes the report buffer to the appropriate report decoder
3200: * rpt_0x?? () in T_PARSER.C, which converts the byte stream in rpt.buf
3201: * to data values approporaite for use.
3202: *
3203: * *************************************************************************
3204: *
3205: */
3206:
3207:
3208: #define GOOD_PARSE 0
3209: #define BADID_PARSE 1
3210: #define BADLEN_PARSE 2
3211: #define BADDATA_PARSE 3
3212:
3213: #define B_TSIP 0x02
3214: #define B_NMEA 0x04
3215:
3216:
3217: /* pbuf is the pointer to the current location of the text output */
3218: static char
3219: *pbuf;
3220:
3221: /* keep track of whether the message has been successfully parsed */
3222: static short
3223: parsed;
3224:
3225:
3226: /* convert time of week into day-hour-minute-second and print */
3227: char *
3228: show_time(
3229: float time_of_week
3230: )
3231: {
3232: short days, hours, minutes;
3233: float seconds;
3234: double tow = 0;
3235: static char timestring [80];
3236:
3237: if (time_of_week == -1.0)
3238: {
3239: sprintf(timestring, " <No time yet> ");
3240: }
3241: else if ((time_of_week >= 604800.0) || (time_of_week < 0.0))
3242: {
3243: sprintf(timestring, " <Bad time> ");
3244: }
3245: else
3246: {
3247: if (time_of_week < 604799.9)
3248: tow = time_of_week + .00000001;
3249: seconds = (float)fmod(tow, 60.);
3250: minutes = (short) fmod(tow/60., 60.);
3251: hours = (short)fmod(tow / 3600., 24.);
3252: days = (short)(tow / 86400.0);
3253: sprintf(timestring, " %s %02d:%02d:%05.2f ",
3254: dayname[days], hours, minutes, seconds);
3255: }
3256: return timestring;
3257: }
3258:
3259: /**/
3260: /* 0x3D */
3261: static void
3262: rpt_chan_A_config(
3263: TSIPPKT *rpt
3264: )
3265: {
3266: unsigned char
3267: tx_baud_index, rx_baud_index,
3268: char_format_index, stop_bits,
3269: tx_mode_index, rx_mode_index,
3270: databits, parity;
3271: int
3272: i, nbaud;
3273:
3274: /* unload rptbuf */
3275: if (rpt_0x3D (rpt,
3276: &tx_baud_index, &rx_baud_index, &char_format_index,
3277: &stop_bits, &tx_mode_index, &rx_mode_index)) {
3278: parsed = BADLEN_PARSE;
3279: return;
3280: }
3281:
3282: pbuf += sprintf(pbuf, "\nChannel A Configuration");
3283:
3284: nbaud = sizeof(old_baudnum);
3285:
3286: for (i = 0; i < nbaud; ++i) if (tx_baud_index == old_baudnum[i]) break;
3287: pbuf += sprintf(pbuf, "\n Transmit speed: %s at %s",
3288: old_output_ch[tx_mode_index], st_baud_text_app[i]);
3289:
3290: for (i = 0; i < nbaud; ++i) if (rx_baud_index == old_baudnum[i]) break;
3291: pbuf += sprintf(pbuf, "\n Receive speed: %s at %s",
3292: old_input_ch[rx_mode_index], st_baud_text_app[i]);
3293:
3294: databits = (unsigned char)((char_format_index & 0x03) + 5);
3295:
3296: parity = (unsigned char)(char_format_index >> 2);
3297: if (parity > 4) parity = 2;
3298:
3299: pbuf += sprintf(pbuf, "\n Character format (bits/char, parity, stop bits): %d-%s-%d",
3300: databits, old_parity_text[parity], stop_bits);
3301: }
3302:
3303: /**/
3304: /* 0x40 */
3305: static void
3306: rpt_almanac_data_page(
3307: TSIPPKT *rpt
3308: )
3309: {
3310: unsigned char
3311: sv_prn;
3312: short
3313: week_num;
3314: float
3315: t_zc,
3316: eccentricity,
3317: t_oa,
3318: i_0,
3319: OMEGA_dot,
3320: sqrt_A,
3321: OMEGA_0,
3322: omega,
3323: M_0;
3324:
3325: /* unload rptbuf */
3326: if (rpt_0x40 (rpt,
3327: &sv_prn, &week_num, &t_zc, &eccentricity, &t_oa,
3328: &i_0, &OMEGA_dot, &sqrt_A, &OMEGA_0, &omega, &M_0)) {
3329: parsed = BADLEN_PARSE;
3330: return;
3331: }
3332:
3333: pbuf += sprintf(pbuf, "\nAlmanac for SV %02d", sv_prn);
3334: pbuf += sprintf(pbuf, "\n Captured:%15.0f %s",
3335: t_zc, show_time (t_zc));
3336: pbuf += sprintf(pbuf, "\n week:%15d", week_num);
3337: pbuf += sprintf(pbuf, "\n Eccentricity:%15g", eccentricity);
3338: pbuf += sprintf(pbuf, "\n T_oa:%15.0f %s",
3339: t_oa, show_time (t_oa));
3340: pbuf += sprintf(pbuf, "\n i 0:%15g", i_0);
3341: pbuf += sprintf(pbuf, "\n OMEGA dot:%15g", OMEGA_dot);
3342: pbuf += sprintf(pbuf, "\n sqrt A:%15g", sqrt_A);
3343: pbuf += sprintf(pbuf, "\n OMEGA 0:%15g", OMEGA_0);
3344: pbuf += sprintf(pbuf, "\n omega:%15g", omega);
3345: pbuf += sprintf(pbuf, "\n M 0:%15g", M_0);
3346: }
3347:
3348: /* 0x41 */
3349: static void
3350: rpt_GPS_time(
3351: TSIPPKT *rpt
3352: )
3353: {
3354: float
3355: time_of_week, UTC_offset;
3356: short
3357: week_num;
3358:
3359: /* unload rptbuf */
3360: if (rpt_0x41 (rpt, &time_of_week, &UTC_offset, &week_num)) {
3361: parsed = BADLEN_PARSE;
3362: return;
3363: }
3364:
3365: pbuf += sprintf(pbuf, "\nGPS time:%s GPS week: %d UTC offset %.1f",
3366: show_time(time_of_week), week_num, UTC_offset);
3367:
3368: }
3369:
3370: /* 0x42 */
3371: static void
3372: rpt_single_ECEF_position(
3373: TSIPPKT *rpt
3374: )
3375: {
3376: float
3377: ECEF_pos[3], time_of_fix;
3378:
3379: /* unload rptbuf */
3380: if (rpt_0x42 (rpt, ECEF_pos, &time_of_fix)) {
3381: parsed = BADLEN_PARSE;
3382: return;
3383: }
3384:
3385: pbuf += sprintf(pbuf, "\nSXYZ: %15.0f %15.0f %15.0f %s",
3386: ECEF_pos[0], ECEF_pos[1], ECEF_pos[2],
3387: show_time(time_of_fix));
3388: }
3389:
3390: /* 0x43 */
3391: static void
3392: rpt_single_ECEF_velocity(
3393: TSIPPKT *rpt
3394: )
3395: {
3396:
3397: float
3398: ECEF_vel[3], freq_offset, time_of_fix;
3399:
3400: /* unload rptbuf */
3401: if (rpt_0x43 (rpt, ECEF_vel, &freq_offset, &time_of_fix)) {
3402: parsed = BADLEN_PARSE;
3403: return;
3404: }
3405:
3406: pbuf += sprintf(pbuf, "\nVelECEF: %11.3f %11.3f %11.3f %12.3f%s",
3407: ECEF_vel[0], ECEF_vel[1], ECEF_vel[2], freq_offset,
3408: show_time(time_of_fix));
3409: }
3410:
3411: /* 0x45 */
3412: static void
3413: rpt_SW_version(
3414: TSIPPKT *rpt
3415: )
3416: {
3417: unsigned char
3418: major_nav_version, minor_nav_version,
3419: nav_day, nav_month, nav_year,
3420: major_dsp_version, minor_dsp_version,
3421: dsp_day, dsp_month, dsp_year;
3422:
3423: /* unload rptbuf */
3424: if (rpt_0x45 (rpt,
3425: &major_nav_version, &minor_nav_version,
3426: &nav_day, &nav_month, &nav_year,
3427: &major_dsp_version, &minor_dsp_version,
3428: &dsp_day, &dsp_month, &dsp_year)) {
3429: parsed = BADLEN_PARSE;
3430: return;
3431: }
3432:
3433: pbuf += sprintf(pbuf,
3434: "\nFW Versions: Nav Proc %2d.%02d %2d/%2d/%2d Sig Proc %2d.%02d %2d/%2d/%2d",
3435: major_nav_version, minor_nav_version, nav_day, nav_month, nav_year,
3436: major_dsp_version, minor_dsp_version, dsp_day, dsp_month, dsp_year);
3437: }
3438:
3439: /* 0x46 */
3440: static void
3441: rpt_rcvr_health(
3442: TSIPPKT *rpt
3443: )
3444: {
3445: unsigned char
3446: status1, status2;
3447: const char
3448: *text;
3449: static const char const
3450: *sc_text[] = {
3451: "Doing position fixes",
3452: "Don't have GPS time yet",
3453: "Waiting for almanac collection",
3454: "DOP too high ",
3455: "No satellites available",
3456: "Only 1 satellite available",
3457: "Only 2 satellites available",
3458: "Only 3 satellites available",
3459: "No satellites usable ",
3460: "Only 1 satellite usable",
3461: "Only 2 satellites usable",
3462: "Only 3 satellites usable",
3463: "Chosen satellite unusable"};
3464:
3465:
3466: /* unload rptbuf */
3467: if (rpt_0x46 (rpt, &status1, &status2))
3468: {
3469: parsed = BADLEN_PARSE;
3470: return;
3471: }
3472:
3473: text = (status1 < COUNTOF(sc_text))
3474: ? sc_text[status1]
3475: : "(out of range)";
3476: pbuf += sprintf(pbuf, "\nRcvr status1: %s (%02Xh); ",
3477: text, status1);
3478:
3479: pbuf += sprintf(pbuf, "status2: %s, %s (%02Xh)",
3480: (status2 & 0x01)?"No BBRAM":"BBRAM OK",
3481: (status2 & 0x10)?"No Ant":"Ant OK",
3482: status2);
3483: }
3484:
3485: /* 0x47 */
3486: static void
3487: rpt_SNR_all_SVs(
3488: TSIPPKT *rpt
3489: )
3490: {
3491: unsigned char
3492: nsvs, sv_prn[12];
3493: short
3494: isv;
3495: float
3496: snr[12];
3497:
3498: /* unload rptbuf */
3499: if (rpt_0x47 (rpt, &nsvs, sv_prn, snr))
3500: {
3501: parsed = BADLEN_PARSE;
3502: return;
3503: }
3504:
3505: pbuf += sprintf(pbuf, "\nSNR for satellites: %d", nsvs);
3506: for (isv = 0; isv < nsvs; isv++)
3507: {
3508: pbuf += sprintf(pbuf, "\n SV %02d %6.2f",
3509: sv_prn[isv], snr[isv]);
3510: }
3511: }
3512:
3513: /* 0x48 */
3514: static void
3515: rpt_GPS_system_message(
3516: TSIPPKT *rpt
3517: )
3518: {
3519: unsigned char
3520: message[23];
3521:
3522: /* unload rptbuf */
3523: if (rpt_0x48 (rpt, message))
3524: {
3525: parsed = BADLEN_PARSE;
3526: return;
3527: }
3528:
3529: pbuf += sprintf(pbuf, "\nGPS message: %s", message);
3530: }
3531:
3532: /* 0x49 */
3533: static void
3534: rpt_almanac_health_page(
3535: TSIPPKT *rpt
3536: )
3537: {
3538: short
3539: iprn;
3540: unsigned char
3541: sv_health [32];
3542:
3543: /* unload rptbuf */
3544: if (rpt_0x49 (rpt, sv_health))
3545: {
3546: parsed = BADLEN_PARSE;
3547: return;
3548: }
3549:
3550: pbuf += sprintf(pbuf, "\nAlmanac health page:");
3551: for (iprn = 0; iprn < 32; iprn++)
3552: {
3553: if (!(iprn%5)) *pbuf++ = '\n';
3554: pbuf += sprintf(pbuf, " SV%02d %2X",
3555: (iprn+1) , sv_health[iprn]);
3556: }
3557: }
3558:
3559: /* 0x4A */
3560: static void
3561: rpt_single_lla_position(
3562: TSIPPKT *rpt
3563: )
3564: {
3565: short
3566: lat_deg, lon_deg;
3567: float
3568: lat, lon,
3569: alt, clock_bias, time_of_fix;
3570: double lat_min, lon_min;
3571: unsigned char
3572: north_south, east_west;
3573:
3574: if (rpt_0x4A (rpt,
3575: &lat, &lon, &alt, &clock_bias, &time_of_fix))
3576: {
3577: parsed = BADLEN_PARSE;
3578: return;
3579: }
3580:
3581: /* convert from radians to degrees */
3582: lat *= (float)R2D;
3583: north_south = 'N';
3584: if (lat < 0.0)
3585: {
3586: north_south = 'S';
3587: lat = -lat;
3588: }
3589: lat_deg = (short)lat;
3590: lat_min = (lat - lat_deg) * 60.0;
3591:
3592: lon *= (float)R2D;
3593: east_west = 'E';
3594: if (lon < 0.0)
3595: {
3596: east_west = 'W';
3597: lon = -lon;
3598: }
3599: lon_deg = (short)lon;
3600: lon_min = (lon - lon_deg) * 60.0;
3601:
3602: pbuf += sprintf(pbuf, "\nSLLA: %4d: %06.3f %c%5d:%06.3f %c%10.2f %12.2f%s",
3603: lat_deg, lat_min, north_south,
3604: lon_deg, lon_min, east_west,
3605: alt, clock_bias,
3606: show_time(time_of_fix));
3607: }
3608:
3609: /* 0x4A */
3610: static void
3611: rpt_ref_alt(
3612: TSIPPKT *rpt
3613: )
3614: {
3615: float
3616: alt, dummy;
3617: unsigned char
3618: alt_flag;
3619:
3620: if (rpt_0x4A_2 (rpt, &alt, &dummy, &alt_flag))
3621: {
3622: parsed = BADLEN_PARSE;
3623: return;
3624: }
3625:
3626: pbuf += sprintf(pbuf, "\nReference Alt: %.1f m; %s",
3627: alt, alt_flag?"ON":"OFF");
3628: }
3629:
3630: /* 0x4B */
3631: static void
3632: rpt_rcvr_id_and_status(
3633: TSIPPKT *rpt
3634: )
3635: {
3636:
3637: unsigned char
3638: machine_id, status3, status4;
3639:
3640: /* unload rptbuf */
3641: if (rpt_0x4B (rpt, &machine_id, &status3, &status4))
3642: {
3643: parsed = BADLEN_PARSE;
3644: return;
3645: }
3646:
3647: pbuf += sprintf(pbuf, "\nRcvr Machine ID: %d; Status3 = %s, %s (%02Xh)",
3648: machine_id,
3649: (status3 & 0x02)?"No RTC":"RTC OK",
3650: (status3 & 0x08)?"No Alm":"Alm OK",
3651: status3);
3652: }
3653:
3654: /* 0x4C */
3655: static void
3656: rpt_operating_parameters(
3657: TSIPPKT *rpt
3658: )
3659: {
3660: unsigned char
3661: dyn_code;
3662: float
3663: el_mask, snr_mask, dop_mask, dop_switch;
3664:
3665: /* unload rptbuf */
3666: if (rpt_0x4C (rpt, &dyn_code, &el_mask,
3667: &snr_mask, &dop_mask, &dop_switch))
3668: {
3669: parsed = BADLEN_PARSE;
3670: return;
3671: }
3672:
3673: pbuf += sprintf(pbuf, "\nOperating Parameters:");
3674: pbuf += sprintf(pbuf, "\n Dynamics code = %d %s",
3675: dyn_code, dyn_text[dyn_code]);
3676: pbuf += sprintf(pbuf, "\n Elevation mask = %.2f", el_mask * R2D);
3677: pbuf += sprintf(pbuf, "\n SNR mask = %.2f", snr_mask);
3678: pbuf += sprintf(pbuf, "\n DOP mask = %.2f", dop_mask);
3679: pbuf += sprintf(pbuf, "\n DOP switch = %.2f", dop_switch);
3680: }
3681:
3682: /* 0x4D */
3683: static void
3684: rpt_oscillator_offset(
3685: TSIPPKT *rpt
3686: )
3687: {
3688: float
3689: osc_offset;
3690:
3691: /* unload rptbuf */
3692: if (rpt_0x4D (rpt, &osc_offset))
3693: {
3694: parsed = BADLEN_PARSE;
3695: return;
3696: }
3697:
3698: pbuf += sprintf(pbuf, "\nOscillator offset: %.2f Hz = %.3f PPM",
3699: osc_offset, osc_offset/1575.42);
3700: }
3701:
3702: /* 0x4E */
3703: static void
3704: rpt_GPS_time_set_response(
3705: TSIPPKT *rpt
3706: )
3707: {
3708: unsigned char
3709: response;
3710:
3711: /* unload rptbuf */
3712: if (rpt_0x4E (rpt, &response))
3713: {
3714: parsed = BADLEN_PARSE;
3715: return;
3716: }
3717:
3718: switch (response)
3719: {
3720: case 'Y':
3721: pbuf += sprintf(pbuf, "\nTime set accepted");
3722: break;
3723:
3724: case 'N':
3725: pbuf += sprintf(pbuf, "\nTime set rejected or not required");
3726: break;
3727:
3728: default:
3729: parsed = BADDATA_PARSE;
3730: }
3731: }
3732:
3733: /* 0x4F */
3734: static void
3735: rpt_UTC_offset(
3736: TSIPPKT *rpt
3737: )
3738: {
3739: double
3740: a0;
3741: float
3742: a1, time_of_data;
3743: short
3744: dt_ls, wn_t, wn_lsf, dn, dt_lsf;
3745:
3746: /* unload rptbuf */
3747: if (rpt_0x4F (rpt, &a0, &a1, &time_of_data,
3748: &dt_ls, &wn_t, &wn_lsf, &dn, &dt_lsf)) {
3749: parsed = BADLEN_PARSE;
3750: return;
3751: }
3752:
3753: pbuf += sprintf(pbuf, "\nUTC Correction Data");
3754: pbuf += sprintf(pbuf, "\n A_0 = %g ", a0);
3755: pbuf += sprintf(pbuf, "\n A_1 = %g ", a1);
3756: pbuf += sprintf(pbuf, "\n delta_t_LS = %d ", dt_ls);
3757: pbuf += sprintf(pbuf, "\n t_ot = %.0f ", time_of_data);
3758: pbuf += sprintf(pbuf, "\n WN_t = %d ", wn_t );
3759: pbuf += sprintf(pbuf, "\n WN_LSF = %d ", wn_lsf );
3760: pbuf += sprintf(pbuf, "\n DN = %d ", dn );
3761: pbuf += sprintf(pbuf, "\n delta_t_LSF = %d ", dt_lsf );
3762: }
3763:
3764: /**/
3765: /* 0x54 */
3766: static void
3767: rpt_1SV_bias(
3768: TSIPPKT *rpt
3769: )
3770: {
3771: float
3772: clock_bias, freq_offset, time_of_fix;
3773:
3774: /* unload rptbuf */
3775: if (rpt_0x54 (rpt, &clock_bias, &freq_offset, &time_of_fix)) {
3776: parsed = BADLEN_PARSE;
3777: return;
3778: }
3779:
3780: pbuf += sprintf (pbuf, "\nTime Fix Clock Bias: %6.2f m Freq Bias: %6.2f m/s%s",
3781: clock_bias, freq_offset, show_time (time_of_fix));
3782: }
3783:
3784: /* 0x55 */
3785: static void
3786: rpt_io_opt(
3787: TSIPPKT *rpt
3788: )
3789: {
3790: unsigned char
3791: pos_code, vel_code, time_code, aux_code;
3792:
3793: /* unload rptbuf */
3794: if (rpt_0x55 (rpt,
3795: &pos_code, &vel_code, &time_code, &aux_code)) {
3796: parsed = BADLEN_PARSE;
3797: return;
3798: }
3799: /* rptbuf unloaded */
3800:
3801: pbuf += sprintf(pbuf, "\nI/O Options: %2X %2X %2X %2X",
3802: pos_code, vel_code, time_code, aux_code);
3803:
3804: if (pos_code & 0x01) {
3805: pbuf += sprintf(pbuf, "\n ECEF XYZ position output");
3806: }
3807:
3808: if (pos_code & 0x02) {
3809: pbuf += sprintf(pbuf, "\n LLA position output");
3810: }
3811:
3812: pbuf += sprintf(pbuf, (pos_code & 0x04)?
3813: "\n MSL altitude output (Geoid height) ":
3814: "\n WGS-84 altitude output");
3815:
3816: pbuf += sprintf(pbuf, (pos_code & 0x08)?
3817: "\n MSL altitude input":
3818: "\n WGS-84 altitude input");
3819:
3820: pbuf += sprintf(pbuf, (pos_code & 0x10)?
3821: "\n Double precision":
3822: "\n Single precision");
3823:
3824: if (pos_code & 0x20) {
3825: pbuf += sprintf(pbuf, "\n All Enabled Superpackets");
3826: }
3827:
3828: if (vel_code & 0x01) {
3829: pbuf += sprintf(pbuf, "\n ECEF XYZ velocity output");
3830: }
3831:
3832: if (vel_code & 0x02) {
3833: pbuf += sprintf(pbuf, "\n ENU velocity output");
3834: }
3835:
3836: pbuf += sprintf(pbuf, (time_code & 0x01)?
3837: "\n Time tags in UTC":
3838: "\n Time tags in GPS time");
3839:
3840: if (time_code & 0x02) {
3841: pbuf += sprintf(pbuf, "\n Fixes delayed to integer seconds");
3842: }
3843:
3844: if (time_code & 0x04) {
3845: pbuf += sprintf(pbuf, "\n Fixes sent only on request");
3846: }
3847:
3848: if (time_code & 0x08) {
3849: pbuf += sprintf(pbuf, "\n Synchronized measurements");
3850: }
3851:
3852: if (time_code & 0x10) {
3853: pbuf += sprintf(pbuf, "\n Minimize measurement propagation");
3854: }
3855:
3856: pbuf += sprintf(pbuf, (time_code & 0x20) ?
3857: "\n PPS output at all times" :
3858: "\n PPS output during fixes");
3859:
3860: if (aux_code & 0x01) {
3861: pbuf += sprintf(pbuf, "\n Raw measurement output");
3862: }
3863:
3864: if (aux_code & 0x02) {
3865: pbuf += sprintf(pbuf, "\n Code-phase smoothed before output");
3866: }
3867:
3868: if (aux_code & 0x04) {
3869: pbuf += sprintf(pbuf, "\n Additional fix status");
3870: }
3871:
3872: pbuf += sprintf(pbuf, (aux_code & 0x08)?
3873: "\n Signal Strength Output as dBHz" :
3874: "\n Signal Strength Output as AMU");
3875: }
3876:
3877: /* 0x56 */
3878: static void
3879: rpt_ENU_velocity(
3880: TSIPPKT *rpt
3881: )
3882: {
3883: float
3884: vel_ENU[3], freq_offset, time_of_fix;
3885:
3886: /* unload rptbuf */
3887: if (rpt_0x56 (rpt, vel_ENU, &freq_offset, &time_of_fix)) {
3888: parsed = BADLEN_PARSE;
3889: return;
3890: }
3891:
3892: pbuf += sprintf(pbuf, "\nVel ENU: %11.3f %11.3f %11.3f %12.3f%s",
3893: vel_ENU[0], vel_ENU[1], vel_ENU[2], freq_offset,
3894: show_time (time_of_fix));
3895: }
3896:
3897: /* 0x57 */
3898: static void
3899: rpt_last_fix_info(
3900: TSIPPKT *rpt
3901: )
3902: {
3903: unsigned char
3904: source_code, diag_code;
3905: short
3906: week_num;
3907: float
3908: time_of_fix;
3909:
3910: /* unload rptbuf */
3911: if (rpt_0x57 (rpt, &source_code, &diag_code, &week_num, &time_of_fix)) {
3912: parsed = BADLEN_PARSE;
3913: return;
3914: }
3915:
3916: pbuf += sprintf(pbuf, "\n source code %d; diag code: %2Xh",
3917: source_code, diag_code);
3918: pbuf += sprintf(pbuf, "\n Time of last fix:%s", show_time(time_of_fix));
3919: pbuf += sprintf(pbuf, "\n Week of last fix: %d", week_num);
3920: }
3921:
3922: /* 0x58 */
3923: static void
3924: rpt_GPS_system_data(
3925: TSIPPKT *rpt
3926: )
3927: {
3928: unsigned char
3929: iprn,
3930: op_code, data_type, sv_prn,
3931: data_length, data_packet[250];
3932: ALM_INFO
3933: *almanac;
3934: ALH_PARMS
3935: *almh;
3936: UTC_INFO
3937: *utc;
3938: ION_INFO
3939: *ionosphere;
3940: EPHEM_CLOCK
3941: *cdata;
3942: EPHEM_ORBIT
3943: *edata;
3944: NAV_INFO
3945: *nav_data;
3946: unsigned char
3947: curr_t_oa;
3948: unsigned short
3949: curr_wn_oa;
3950: static char
3951: *datname[] =
3952: {"", "", "Almanac Orbit",
3953: "Health Page & Ref Time", "Ionosphere", "UTC ",
3954: "Ephemeris"};
3955:
3956: /* unload rptbuf */
3957: if (rpt_0x58 (rpt, &op_code, &data_type, &sv_prn,
3958: &data_length, data_packet))
3959: {
3960: parsed = BADLEN_PARSE;
3961: return;
3962: }
3963:
3964: pbuf += sprintf(pbuf, "\nSystem data [%d]: %s SV%02d",
3965: data_type, datname[data_type], sv_prn);
3966: switch (op_code)
3967: {
3968: case 1:
3969: pbuf += sprintf(pbuf, " Acknowledgment");
3970: break;
3971: case 2:
3972: pbuf += sprintf(pbuf, " length = %d bytes", data_length);
3973: switch (data_type) {
3974: case 2:
3975: /* Almanac */
3976: if (sv_prn == 0 || sv_prn > 32) {
3977: pbuf += sprintf(pbuf, " Binary PRN invalid");
3978: return;
3979: }
3980: almanac = (ALM_INFO*)data_packet;
3981: pbuf += sprintf(pbuf, "\n t_oa_raw = % -12d SV_hlth = % -12d ",
3982: almanac->t_oa_raw , almanac->SV_health );
3983: pbuf += sprintf(pbuf, "\n e = % -12g t_oa = % -12g ",
3984: almanac->e , almanac->t_oa );
3985: pbuf += sprintf(pbuf, "\n i_0 = % -12g OMEGADOT = % -12g ",
3986: almanac->i_0 , almanac->OMEGADOT );
3987: pbuf += sprintf(pbuf, "\n sqrt_A = % -12g OMEGA_0 = % -12g ",
3988: almanac->sqrt_A , almanac->OMEGA_0 );
3989: pbuf += sprintf(pbuf, "\n omega = % -12g M_0 = % -12g ",
3990: almanac->omega , almanac->M_0 );
3991: pbuf += sprintf(pbuf, "\n a_f0 = % -12g a_f1 = % -12g ",
3992: almanac->a_f0 , almanac->a_f1 );
3993: pbuf += sprintf(pbuf, "\n Axis = % -12g n = % -12g ",
3994: almanac->Axis , almanac->n );
3995: pbuf += sprintf(pbuf, "\n OMEGA_n = % -12g ODOT_n = % -12g ",
3996: almanac->OMEGA_n , almanac->ODOT_n );
3997: pbuf += sprintf(pbuf, "\n t_zc = % -12g weeknum = % -12d ",
3998: almanac->t_zc , almanac->weeknum );
3999: pbuf += sprintf(pbuf, "\n wn_oa = % -12d", almanac->wn_oa );
4000: break;
4001:
4002: case 3:
4003: /* Almanac health page */
4004: almh = (ALH_PARMS*)data_packet;
4005: pbuf += sprintf(pbuf, "\n t_oa = %d, wn_oa&0xFF = %d ",
4006: almh->t_oa, almh->WN_a);
4007: pbuf += sprintf(pbuf, "\nAlmanac health page:");
4008: for (iprn = 0; iprn < 32; iprn++) {
4009: if (!(iprn%5)) *pbuf++ = '\n';
4010: pbuf += sprintf(pbuf, " SV%02d %2X",
4011: (iprn+1) , almh->SV_health[iprn]);
4012: }
4013: curr_t_oa = data_packet[34];
4014: curr_wn_oa = (unsigned short)((data_packet[35]<<8) + data_packet[36]);
4015: pbuf += sprintf(pbuf, "\n current t_oa = %d, wn_oa = %d ",
4016: curr_t_oa, curr_wn_oa);
4017: break;
4018:
4019: case 4:
4020: /* Ionosphere */
4021: ionosphere = (ION_INFO*)data_packet;
4022: pbuf += sprintf(pbuf, "\n alpha_0 = % -12g alpha_1 = % -12g ",
4023: ionosphere->alpha_0, ionosphere->alpha_1);
4024: pbuf += sprintf(pbuf, "\n alpha_2 = % -12g alpha_3 = % -12g ",
4025: ionosphere->alpha_2, ionosphere->alpha_3);
4026: pbuf += sprintf(pbuf, "\n beta_0 = % -12g beta_1 = % -12g ",
4027: ionosphere->beta_0, ionosphere->beta_1);
4028: pbuf += sprintf(pbuf, "\n beta_2 = % -12g beta_3 = % -12g ",
4029: ionosphere->beta_2, ionosphere->beta_3);
4030: break;
4031:
4032: case 5:
4033: /* UTC */
4034: utc = (UTC_INFO*)data_packet;
4035: pbuf += sprintf(pbuf, "\n A_0 = %g ", utc->A_0);
4036: pbuf += sprintf(pbuf, "\n A_1 = %g ", utc->A_1);
4037: pbuf += sprintf(pbuf, "\n delta_t_LS = %d ", utc->delta_t_LS);
4038: pbuf += sprintf(pbuf, "\n t_ot = %.0f ", utc->t_ot );
4039: pbuf += sprintf(pbuf, "\n WN_t = %d ", utc->WN_t );
4040: pbuf += sprintf(pbuf, "\n WN_LSF = %d ", utc->WN_LSF );
4041: pbuf += sprintf(pbuf, "\n DN = %d ", utc->DN );
4042: pbuf += sprintf(pbuf, "\n delta_t_LSF = %d ", utc->delta_t_LSF );
4043: break;
4044:
4045: case 6: /* Ephemeris */
4046: if (sv_prn == 0 || sv_prn > 32) {
4047: pbuf += sprintf(pbuf, " Binary PRN invalid");
4048: return;
4049: }
4050: nav_data = (NAV_INFO*)data_packet;
4051:
4052: pbuf += sprintf(pbuf, "\n SV_PRN = % -12d . t_ephem = % -12g . ",
4053: nav_data->sv_number , nav_data->t_ephem );
4054: cdata = &(nav_data->ephclk);
4055: pbuf += sprintf(pbuf,
4056: "\n weeknum = % -12d . codeL2 = % -12d . L2Pdata = % -12d",
4057: cdata->weeknum , cdata->codeL2 , cdata->L2Pdata );
4058: pbuf += sprintf(pbuf,
4059: "\n SVacc_raw = % -12d .SV_health = % -12d . IODC = % -12d",
4060: cdata->SVacc_raw, cdata->SV_health, cdata->IODC );
4061: pbuf += sprintf(pbuf,
4062: "\n T_GD = % -12g . t_oc = % -12g . a_f2 = % -12g",
4063: cdata->T_GD, cdata->t_oc, cdata->a_f2 );
4064: pbuf += sprintf(pbuf,
4065: "\n a_f1 = % -12g . a_f0 = % -12g . SVacc = % -12g",
4066: cdata->a_f1, cdata->a_f0, cdata->SVacc );
4067: edata = &(nav_data->ephorb);
4068: pbuf += sprintf(pbuf,
4069: "\n IODE = % -12d .fit_intvl = % -12d . C_rs = % -12g",
4070: edata->IODE, edata->fit_interval, edata->C_rs );
4071: pbuf += sprintf(pbuf,
4072: "\n delta_n = % -12g . M_0 = % -12g . C_uc = % -12g",
4073: edata->delta_n, edata->M_0, edata->C_uc );
4074: pbuf += sprintf(pbuf,
4075: "\n ecc = % -12g . C_us = % -12g . sqrt_A = % -12g",
4076: edata->e, edata->C_us, edata->sqrt_A );
4077: pbuf += sprintf(pbuf,
4078: "\n t_oe = % -12g . C_ic = % -12g . OMEGA_0 = % -12g",
4079: edata->t_oe, edata->C_ic, edata->OMEGA_0 );
4080: pbuf += sprintf(pbuf,
4081: "\n C_is = % -12g . i_0 = % -12g . C_rc = % -12g",
4082: edata->C_is, edata->i_0, edata->C_rc );
4083: pbuf += sprintf(pbuf,
4084: "\n omega = % -12g . OMEGADOT = % -12g . IDOT = % -12g",
4085: edata->omega, edata->OMEGADOT, edata->IDOT );
4086: pbuf += sprintf(pbuf,
4087: "\n Axis = % -12g . n = % -12g . r1me2 = % -12g",
4088: edata->Axis, edata->n, edata->r1me2 );
4089: pbuf += sprintf(pbuf,
4090: "\n OMEGA_n = % -12g . ODOT_n = % -12g",
4091: edata->OMEGA_n, edata->ODOT_n );
4092: break;
4093: }
4094: }
4095: }
4096:
4097:
4098: /* 0x59: */
4099: static void
4100: rpt_SVs_enabled(
4101: TSIPPKT *rpt
4102: )
4103: {
4104: unsigned char
4105: numsvs,
4106: code_type,
4107: status_code[32];
4108: short
4109: iprn;
4110:
4111: /* unload rptbuf */
4112: if (rpt_0x59 (rpt, &code_type, status_code))
4113: {
4114: parsed = BADLEN_PARSE;
4115: return;
4116: }
4117: switch (code_type)
4118: {
4119: case 3: pbuf += sprintf(pbuf, "\nSVs Disabled:\n"); break;
4120: case 6: pbuf += sprintf(pbuf, "\nSVs with Health Ignored:\n"); break;
4121: default: return;
4122: }
4123: numsvs = 0;
4124: for (iprn = 0; iprn < 32; iprn++)
4125: {
4126: if (status_code[iprn])
4127: {
4128: pbuf += sprintf(pbuf, " %02d", iprn+1);
4129: numsvs++;
4130: }
4131: }
4132: if (numsvs == 0) pbuf += sprintf(pbuf, "None");
4133: }
4134:
4135:
4136: /* 0x5A */
4137: static void
4138: rpt_raw_msmt(
4139: TSIPPKT *rpt
4140: )
4141: {
4142: unsigned char
4143: sv_prn;
4144: float
4145: sample_length, signal_level, code_phase, Doppler;
4146: double
4147: time_of_fix;
4148:
4149: /* unload rptbuf */
4150: if (rpt_0x5A (rpt, &sv_prn, &sample_length, &signal_level,
4151: &code_phase, &Doppler, &time_of_fix))
4152: {
4153: parsed = BADLEN_PARSE;
4154: return;
4155: }
4156:
4157: pbuf += sprintf(pbuf, "\n %02d %5.0f %7.1f %10.2f %10.2f %12.3f %s",
4158: sv_prn, sample_length, signal_level, code_phase, Doppler, time_of_fix,
4159: show_time ((float)time_of_fix));
4160: }
4161:
4162: /* 0x5B */
4163: static void
4164: rpt_SV_ephemeris_status(
4165: TSIPPKT *rpt
4166: )
4167: {
4168: unsigned char
4169: sv_prn, sv_health, sv_iode, fit_interval_flag;
4170: float
4171: time_of_collection, time_of_eph, sv_accy;
4172:
4173: /* unload rptbuf */
4174: if (rpt_0x5B (rpt, &sv_prn, &sv_health, &sv_iode, &fit_interval_flag,
4175: &time_of_collection, &time_of_eph, &sv_accy))
4176: {
4177: parsed = BADLEN_PARSE;
4178: return;
4179: }
4180:
4181: pbuf += sprintf(pbuf, "\n SV%02d %s %2Xh %2Xh ",
4182: sv_prn, show_time (time_of_collection), sv_health, sv_iode);
4183: /* note: cannot use show_time twice in same call */
4184: pbuf += sprintf(pbuf, "%s %1d %4.1f",
4185: show_time (time_of_eph), fit_interval_flag, sv_accy);
4186: }
4187:
4188: /* 0x5C */
4189: static void
4190: rpt_SV_tracking_status(
4191: TSIPPKT *rpt
4192: )
4193: {
4194: unsigned char
4195: sv_prn, chan, slot, acq_flag, eph_flag,
4196: old_msmt_flag, integer_msec_flag, bad_data_flag,
4197: data_collect_flag;
4198: float
4199: signal_level, time_of_last_msmt,
4200: elev, azim;
4201:
4202: /* unload rptbuf */
4203: if (rpt_0x5C (rpt,
4204: &sv_prn, &slot, &chan, &acq_flag, &eph_flag,
4205: &signal_level, &time_of_last_msmt, &elev, &azim,
4206: &old_msmt_flag, &integer_msec_flag, &bad_data_flag,
4207: &data_collect_flag))
4208: {
4209: parsed = BADLEN_PARSE;
4210: return;
4211: }
4212:
4213: pbuf += sprintf(pbuf,
4214: "\n SV%2d %1d %1d %1d %4.1f %s %5.1f %5.1f",
4215: sv_prn, chan,
4216: acq_flag, eph_flag, signal_level,
4217: show_time(time_of_last_msmt),
4218: elev*R2D, azim*R2D);
4219: }
4220:
4221: /**/
4222: /* 0x6D */
4223: static void
4224: rpt_allSV_selection(
4225: TSIPPKT *rpt
4226: )
4227: {
4228: unsigned char
4229: manual_mode, nsvs, sv_prn[8], ndim;
4230: short
4231: islot;
4232: float
4233: pdop, hdop, vdop, tdop;
4234:
4235: /* unload rptbuf */
4236: if (rpt_0x6D (rpt,
4237: &manual_mode, &nsvs, &ndim, sv_prn,
4238: &pdop, &hdop, &vdop, &tdop))
4239: {
4240: parsed = BADLEN_PARSE;
4241: return;
4242: }
4243:
4244: switch (ndim)
4245: {
4246: case 0:
4247: pbuf += sprintf(pbuf, "\nMode: Searching, %d-SV:", nsvs);
4248: break;
4249: case 1:
4250: pbuf += sprintf(pbuf, "\nMode: One-SV Timing:");
4251: break;
4252: case 3: case 4:
4253: pbuf += sprintf(pbuf, "\nMode: %c-%dD, %d-SV:",
4254: manual_mode ? 'M' : 'A', ndim - 1, nsvs);
4255: break;
4256: case 5:
4257: pbuf += sprintf(pbuf, "\nMode: Timing, %d-SV:", nsvs);
4258: break;
4259: default:
4260: pbuf += sprintf(pbuf, "\nMode: Unknown = %d:", ndim);
4261: break;
4262: }
4263:
4264: for (islot = 0; islot < nsvs; islot++)
4265: {
4266: if (sv_prn[islot]) pbuf += sprintf(pbuf, " %02d", sv_prn[islot]);
4267: }
4268: if (ndim == 3 || ndim == 4)
4269: {
4270: pbuf += sprintf(pbuf, "; DOPs: P %.1f H %.1f V %.1f T %.1f",
4271: pdop, hdop, vdop, tdop);
4272: }
4273: }
4274:
4275: /**/
4276: /* 0x82 */
4277: static void
4278: rpt_DGPS_position_mode(
4279: TSIPPKT *rpt
4280: )
4281: {
4282: unsigned char
4283: diff_mode;
4284:
4285: /* unload rptbuf */
4286: if (rpt_0x82 (rpt, &diff_mode)) {
4287: parsed = BADLEN_PARSE;
4288: return;
4289: }
4290:
4291: pbuf += sprintf(pbuf, "\nFix is%s DGPS-corrected (%s mode) (%d)",
4292: (diff_mode&1) ? "" : " not",
4293: (diff_mode&2) ? "auto" : "manual",
4294: diff_mode);
4295: }
4296:
4297: /* 0x83 */
4298: static void
4299: rpt_double_ECEF_position(
4300: TSIPPKT *rpt
4301: )
4302: {
4303: double
4304: ECEF_pos[3], clock_bias;
4305: float
4306: time_of_fix;
4307:
4308: /* unload rptbuf */
4309: if (rpt_0x83 (rpt, ECEF_pos, &clock_bias, &time_of_fix))
4310: {
4311: parsed = BADLEN_PARSE;
4312: return;
4313: }
4314:
4315: pbuf += sprintf(pbuf, "\nDXYZ:%12.2f %13.2f %13.2f %12.2f%s",
4316: ECEF_pos[0], ECEF_pos[1], ECEF_pos[2], clock_bias,
4317: show_time(time_of_fix));
4318: }
4319:
4320: /* 0x84 */
4321: static void
4322: rpt_double_lla_position(
4323: TSIPPKT *rpt
4324: )
4325: {
4326: short
4327: lat_deg, lon_deg;
4328: double
4329: lat, lon, lat_min, lon_min,
4330: alt, clock_bias;
4331: float
4332: time_of_fix;
4333: unsigned char
4334: north_south, east_west;
4335:
4336: /* unload rptbuf */
4337: if (rpt_0x84 (rpt,
4338: &lat, &lon, &alt, &clock_bias, &time_of_fix))
4339: {
4340: parsed = BADLEN_PARSE;
4341: return;
4342: }
4343:
4344: lat *= R2D;
4345: lon *= R2D;
4346: if (lat < 0.0) {
4347: north_south = 'S';
4348: lat = -lat;
4349: } else {
4350: north_south = 'N';
4351: }
4352: lat_deg = (short)lat;
4353: lat_min = (lat - lat_deg) * 60.0;
4354:
4355: if (lon < 0.0) {
4356: east_west = 'W';
4357: lon = -lon;
4358: } else {
4359: east_west = 'E';
4360: }
4361: lon_deg = (short)lon;
4362: lon_min = (lon - lon_deg) * 60.0;
4363: pbuf += sprintf(pbuf, "\nDLLA: %2d:%08.5f %c; %3d:%08.5f %c; %10.2f %12.2f%s",
4364: lat_deg, lat_min, north_south,
4365: lon_deg, lon_min, east_west,
4366: alt, clock_bias,
4367: show_time(time_of_fix));
4368: }
4369:
4370: /* 0xBB */
4371: static void
4372: rpt_complete_rcvr_config(
4373: TSIPPKT *rpt
4374: )
4375: {
4376: TSIP_RCVR_CFG TsipxBB ;
4377: /* unload rptbuf */
4378: if (rpt_Paly0xBB (rpt, &TsipxBB))
4379: {
4380: parsed = BADLEN_PARSE;
4381: return;
4382: }
4383:
4384: pbuf += sprintf(pbuf, "\n operating mode: %s",
4385: NavModeText0xBB[TsipxBB.operating_mode]);
4386: pbuf += sprintf(pbuf, "\n dynamics: %s",
4387: dyn_text[TsipxBB.dyn_code]);
4388: pbuf += sprintf(pbuf, "\n elev angle mask: %g deg",
4389: TsipxBB.elev_mask * R2D);
4390: pbuf += sprintf(pbuf, "\n SNR mask: %g AMU",
4391: TsipxBB.cno_mask);
4392: pbuf += sprintf(pbuf, "\n DOP mask: %g",
4393: TsipxBB.dop_mask);
4394: pbuf += sprintf(pbuf, "\n DOP switch: %g",
4395: TsipxBB.dop_switch);
4396: return ;
4397: }
4398:
4399: /* 0xBC */
4400: static void
4401: rpt_rcvr_serial_port_config(
4402: TSIPPKT *rpt
4403: )
4404: {
4405: unsigned char
4406: port_num, in_baud, out_baud, data_bits, parity, stop_bits, flow_control,
4407: protocols_in, protocols_out, reserved;
4408: unsigned char known;
4409:
4410: /* unload rptbuf */
4411: if (rpt_0xBC (rpt, &port_num, &in_baud, &out_baud, &data_bits, &parity,
4412: &stop_bits, &flow_control, &protocols_in, &protocols_out, &reserved)) {
4413: parsed = BADLEN_PARSE;
4414: return;
4415: }
4416: /* rptbuf unloaded */
4417:
4418: pbuf += sprintf(pbuf, "\n RECEIVER serial port %s config:",
4419: rcvr_port_text[port_num]);
4420:
4421: pbuf += sprintf(pbuf, "\n I/O Baud %s/%s, %d - %s - %d",
4422: st_baud_text_app[in_baud],
4423: st_baud_text_app[out_baud],
4424: data_bits+5,
4425: parity_text[parity],
4426: stop_bits=1);
4427: pbuf += sprintf(pbuf, "\n Input protocols: ");
4428: known = FALSE;
4429: if (protocols_in&B_TSIP)
4430: {
4431: pbuf += sprintf(pbuf, "%s ", protocols_in_text[1]);
4432: known = TRUE;
4433: }
4434: if (known == FALSE) pbuf += sprintf(pbuf, "No known");
4435:
4436: pbuf += sprintf(pbuf, "\n Output protocols: ");
4437: known = FALSE;
4438: if (protocols_out&B_TSIP)
4439: {
4440: pbuf += sprintf(pbuf, "%s ", protocols_out_text[1]);
4441: known = TRUE;
4442: }
4443: if (protocols_out&B_NMEA)
4444: {
4445: pbuf += sprintf(pbuf, "%s ", protocols_out_text[2]);
4446: known = TRUE;
4447: }
4448: if (known == FALSE) pbuf += sprintf(pbuf, "No known");
4449: reserved = reserved;
4450:
4451: }
4452:
4453: /* 0x8F */
4454: /* 8F0B */
4455: static void
4456: rpt_8F0B(
4457: TSIPPKT *rpt
4458: )
4459: {
4460: const char
4461: *oprtng_dim[7] = {
4462: "horizontal (2-D)",
4463: "full position (3-D)",
4464: "single satellite (0-D)",
4465: "automatic",
4466: "N/A",
4467: "N/A",
4468: "overdetermined clock"};
4469: char
4470: sv_id[8];
4471: unsigned char
4472: month,
4473: date,
4474: dim_mode,
4475: north_south,
4476: east_west;
4477: unsigned short
4478: event;
4479: short
4480: utc_offset,
4481: year,
4482: local_index;
4483: short
4484: lat_deg,
4485: lon_deg;
4486: float
4487: bias_unc,
4488: dr_unc;
4489: double
4490: tow,
4491: bias,
4492: drift,
4493: lat,
4494: lon,
4495: alt,
4496: lat_min,
4497: lon_min;
4498: int
4499: numfix,
4500: numnotfix;
4501:
4502: if (rpt_0x8F0B(rpt,
4503: &event,
4504: &tow,
4505: &date,
4506: &month,
4507: &year,
4508: &dim_mode,
4509: &utc_offset,
4510: &bias,
4511: &drift,
4512: &bias_unc,
4513: &dr_unc,
4514: &lat,
4515: &lon,
4516: &alt,
4517: sv_id))
4518: {
4519: parsed = BADLEN_PARSE;
4520: return;
4521: }
4522:
4523: if (event == 0)
4524: {
4525: pbuf += sprintf(pbuf, "\nNew partial+full meas");
4526: }
4527: else
4528: {
4529: pbuf += sprintf(pbuf, "\nEvent count: %5d", event);
4530: }
4531:
4532: pbuf += sprintf(pbuf, "\nGPS time : %s %2d/%2d/%2d (DMY)",
4533: show_time(tow), date, month, year);
4534: pbuf += sprintf(pbuf, "\nMode : %s", oprtng_dim[dim_mode]);
4535: pbuf += sprintf(pbuf, "\nUTC offset: %2d", utc_offset);
4536: pbuf += sprintf(pbuf, "\nClock Bias: %6.2f m", bias);
4537: pbuf += sprintf(pbuf, "\nFreq bias : %6.2f m/s", drift);
4538: pbuf += sprintf(pbuf, "\nBias unc : %6.2f m", bias_unc);
4539: pbuf += sprintf(pbuf, "\nFreq unc : %6.2f m/s", dr_unc);
4540:
4541: lat *= R2D; /* convert from radians to degrees */
4542: lon *= R2D;
4543: if (lat < 0.0)
4544: {
4545: north_south = 'S';
4546: lat = -lat;
4547: }
4548: else
4549: {
4550: north_south = 'N';
4551: }
4552:
4553: lat_deg = (short)lat;
4554: lat_min = (lat - lat_deg) * 60.0;
4555: if (lon < 0.0)
4556: {
4557: east_west = 'W';
4558: lon = -lon;
4559: }
4560: else
4561: {
4562: east_west = 'E';
4563: }
4564:
4565: lon_deg = (short)lon;
4566: lon_min = (lon - lon_deg) * 60.0;
4567: pbuf += sprintf(pbuf, "\nPosition :");
4568: pbuf += sprintf(pbuf, " %4d %6.3f %c", lat_deg, lat_min, north_south);
4569: pbuf += sprintf(pbuf, " %5d %6.3f %c", lon_deg, lon_min, east_west);
4570: pbuf += sprintf(pbuf, " %10.2f", alt);
4571:
4572: numfix = numnotfix = 0;
4573: for (local_index=0; local_index<8; local_index++)
4574: {
4575: if (sv_id[local_index] < 0) numnotfix++;
4576: if (sv_id[local_index] > 0) numfix++;
4577: }
4578: if (numfix > 0)
4579: {
4580: pbuf += sprintf(pbuf, "\nSVs used in fix : ");
4581: for (local_index=0; local_index<8; local_index++)
4582: {
4583: if (sv_id[local_index] > 0)
4584: {
4585: pbuf += sprintf(pbuf, "%2d ", sv_id[local_index]);
4586: }
4587: }
4588: }
4589: if (numnotfix > 0)
4590: {
4591: pbuf += sprintf(pbuf, "\nOther SVs tracked: ");
4592: for (local_index=0; local_index<8; local_index++)
4593: {
4594: if (sv_id[local_index] < 0)
4595: {
4596: pbuf += sprintf(pbuf, "%2d ", sv_id[local_index]);
4597: }
4598: }
4599: }
4600: }
4601:
4602: /* 0x8F14 */
4603: /* Datum parameters */
4604: static void
4605: rpt_8F14(
4606: TSIPPKT *rpt
4607: )
4608: {
4609: double
4610: datum_coeffs[5];
4611: short
4612: datum_idx;
4613:
4614: /* unload rptbuf */
4615: if (rpt_0x8F14 (rpt, &datum_idx, datum_coeffs))
4616: {
4617: parsed = BADLEN_PARSE;
4618: return;
4619: }
4620:
4621: if (datum_idx == -1)
4622: {
4623: pbuf += sprintf(pbuf, "\nUser-Entered Datum:");
4624: pbuf += sprintf(pbuf, "\n dx = %6.1f", datum_coeffs[0]);
4625: pbuf += sprintf(pbuf, "\n dy = %6.1f", datum_coeffs[1]);
4626: pbuf += sprintf(pbuf, "\n dz = %6.1f", datum_coeffs[2]);
4627: pbuf += sprintf(pbuf, "\n a-axis = %10.3f", datum_coeffs[3]);
4628: pbuf += sprintf(pbuf, "\n e-squared = %16.14f", datum_coeffs[4]);
4629: }
4630: else if (datum_idx == 0)
4631: {
4632: pbuf += sprintf(pbuf, "\nWGS-84 datum, Index 0 ");
4633: }
4634: else
4635: {
4636: pbuf += sprintf(pbuf, "\nStandard Datum, Index %3d ", datum_idx);
4637: }
4638: }
4639:
4640: /* 0x8F15 */
4641: /* Datum parameters */
4642: static void
4643: rpt_8F15(
4644: TSIPPKT *rpt
4645: )
4646: {
4647: double
4648: datum_coeffs[5];
4649: short
4650: datum_idx;
4651:
4652: /* unload rptbuf */
4653: if (rpt_0x8F15 (rpt, &datum_idx, datum_coeffs)) {
4654: parsed = BADLEN_PARSE;
4655: return;
4656: }
4657:
4658: if (datum_idx == -1)
4659: {
4660: pbuf += sprintf(pbuf, "\nUser-Entered Datum:");
4661: pbuf += sprintf(pbuf, "\n dx = %6.1f", datum_coeffs[0]);
4662: pbuf += sprintf(pbuf, "\n dy = %6.1f", datum_coeffs[1]);
4663: pbuf += sprintf(pbuf, "\n dz = %6.1f", datum_coeffs[2]);
4664: pbuf += sprintf(pbuf, "\n a-axis = %10.3f", datum_coeffs[3]);
4665: pbuf += sprintf(pbuf, "\n e-squared = %16.14f", datum_coeffs[4]);
4666: }
4667: else if (datum_idx == 0)
4668: {
4669: pbuf += sprintf(pbuf, "\nWGS-84 datum, Index 0 ");
4670: }
4671: else
4672: {
4673: pbuf += sprintf(pbuf, "\nStandard Datum, Index %3d ", datum_idx);
4674: }
4675: }
4676:
4677: /* 0x8F20 */
4678: #define INFO_DGPS 0x02
4679: #define INFO_2D 0x04
4680: #define INFO_ALTSET 0x08
4681: #define INFO_FILTERED 0x10
4682: static void
4683: rpt_8F20(
4684: TSIPPKT *rpt
4685: )
4686: {
4687: unsigned char
4688: info, nsvs, sv_prn[32];
4689: short
4690: week_num, datum_index, sv_IODC[32];
4691: double
4692: lat, lon, alt, time_of_fix;
4693: double
4694: londeg, latdeg, vel[3];
4695: short
4696: isv;
4697: char
4698: datum_string[20];
4699:
4700: /* unload rptbuf */
4701: if (rpt_0x8F20 (rpt,
4702: &info, &lat, &lon, &alt, vel,
4703: &time_of_fix,
4704: &week_num, &nsvs, sv_prn, sv_IODC, &datum_index))
4705: {
4706: parsed = BADLEN_PARSE;
4707: return;
4708: }
4709: pbuf += sprintf(pbuf,
4710: "\nFix at: %04d:%3s:%02d:%02d:%06.3f GPS (=UTC+%2ds) FixType: %s%s%s",
4711: week_num,
4712: dayname[(short)(time_of_fix/86400.0)],
4713: (short)fmod(time_of_fix/3600., 24.),
4714: (short)fmod(time_of_fix/60., 60.),
4715: fmod(time_of_fix, 60.),
4716: (char)rpt->buf[29], /* UTC offset */
4717: (info & INFO_DGPS)?"Diff":"",
4718: (info & INFO_2D)?"2D":"3D",
4719: (info & INFO_FILTERED)?"-Filtrd":"");
4720:
4721: if (datum_index > 0)
4722: {
4723: sprintf(datum_string, "Datum%3d", datum_index);
4724: }
4725: else if (datum_index)
4726: {
4727: sprintf(datum_string, "Unknown ");
4728: }
4729: else
4730: {
4731: sprintf(datum_string, "WGS-84");
4732: }
4733:
4734: /* convert from radians to degrees */
4735: latdeg = R2D * fabs(lat);
4736: londeg = R2D * fabs(lon);
4737: pbuf += sprintf(pbuf,
4738: "\n Pos: %4d:%09.6f %c %5d:%09.6f %c %10.2f m HAE (%s)",
4739: (short)latdeg, fmod (latdeg, 1.)*60.0,
4740: (lat<0.0)?'S':'N',
4741: (short)londeg, fmod (londeg, 1.)*60.0,
4742: (lon<0.0)?'W':'E',
4743: alt,
4744: datum_string);
4745: pbuf += sprintf(pbuf,
4746: "\n Vel: %9.3f E %9.3f N %9.3f U (m/sec)",
4747: vel[0], vel[1], vel[2]);
4748:
4749: pbuf += sprintf(pbuf,
4750: "\n SVs: ");
4751: for (isv = 0; isv < nsvs; isv++) {
4752: pbuf += sprintf(pbuf, " %02d", sv_prn[isv]);
4753: }
4754: pbuf += sprintf(pbuf, " (IODEs:");
4755: for (isv = 0; isv < nsvs; isv++) {
4756: pbuf += sprintf(pbuf, " %02X", sv_IODC[isv]&0xFF);
4757: }
4758: pbuf += sprintf(pbuf, ")");
4759: }
4760:
4761: /* 0x8F41 */
4762: static void
4763: rpt_8F41(
4764: TSIPPKT *rpt
4765: )
4766: {
4767: unsigned char
4768: bSearchRange,
4769: bBoardOptions,
4770: bBuildYear,
4771: bBuildMonth,
4772: bBuildDay,
4773: bBuildHour;
4774: float
4775: fOscOffset;
4776: unsigned short
4777: iTestCodeId;
4778: unsigned long
4779: iiSerialNumber;
4780:
4781: if (!rpt_0x8F41(rpt,
4782: &bSearchRange,
4783: &bBoardOptions,
4784: &iiSerialNumber,
4785: &bBuildYear,
4786: &bBuildMonth,
4787: &bBuildDay,
4788: &bBuildHour,
4789: &fOscOffset,
4790: &iTestCodeId))
4791: {
4792: parsed = BADLEN_PARSE;
4793: return;
4794: }
4795:
4796: pbuf += sprintf(pbuf, "\n search range: %d",
4797: bSearchRange);
4798: pbuf += sprintf(pbuf, "\n board options: %d",
4799: bBoardOptions);
4800: pbuf += sprintf(pbuf, "\n board serial #: %ld",
4801: iiSerialNumber);
4802: pbuf += sprintf(pbuf, "\n build date/hour: %02d/%02d/%02d %02d:00",
4803: bBuildDay, bBuildMonth, bBuildYear, bBuildHour);
4804: pbuf += sprintf(pbuf, "\n osc offset: %.3f PPM (%.0f Hz)",
4805: fOscOffset/1575.42, fOscOffset);
4806: pbuf += sprintf(pbuf, "\n test code: %d",
4807: iTestCodeId);
4808: }
4809:
4810: /* 0x8F42 */
4811: static void
4812: rpt_8F42(
4813: TSIPPKT *rpt
4814: )
4815: {
4816: unsigned char
4817: bProdOptionsPre,
4818: bProdNumberExt;
4819: unsigned short
4820: iCaseSerialNumberPre,
4821: iPremiumOptions,
4822: iMachineID,
4823: iKey;
4824: unsigned long
4825: iiCaseSerialNumber,
4826: iiProdNumber;
4827:
4828: if (!rpt_0x8F42(rpt,
4829: &bProdOptionsPre,
4830: &bProdNumberExt,
4831: &iCaseSerialNumberPre,
4832: &iiCaseSerialNumber,
4833: &iiProdNumber,
4834: &iPremiumOptions,
4835: &iMachineID,
4836: &iKey))
4837: {
4838: parsed = BADLEN_PARSE;
4839: return;
4840: }
4841:
4842: pbuf += sprintf(pbuf, "\nProduct ID 8F42");
4843: pbuf += sprintf(pbuf, "\n extension: %d", bProdNumberExt);
4844: pbuf += sprintf(pbuf, "\n case serial # prefix: %d", iCaseSerialNumberPre);
4845: pbuf += sprintf(pbuf, "\n case serial #: %ld", iiCaseSerialNumber);
4846: pbuf += sprintf(pbuf, "\n prod. #: %ld", iiProdNumber);
4847: pbuf += sprintf(pbuf, "\n premium options: %Xh", iPremiumOptions);
4848: pbuf += sprintf(pbuf, "\n machine ID: %d", iMachineID);
4849: pbuf += sprintf(pbuf, "\n key: %Xh", iKey);
4850: }
4851:
4852: /* 0x8F45 */
4853: static void
4854: rpt_8F45(
4855: TSIPPKT *rpt
4856: )
4857: {
4858: unsigned char bSegMask;
4859:
4860: if (!rpt_0x8F45(rpt,
4861: &bSegMask))
4862: {
4863: parsed = BADLEN_PARSE;
4864: return;
4865: }
4866: pbuf += sprintf(pbuf, "\nCleared Segment Mask: %Xh", bSegMask);
4867: }
4868:
4869: /* Stinger PPS def */
4870: static void
4871: rpt_8F4A(
4872: TSIPPKT *rpt
4873: )
4874: {
4875: unsigned char
4876: pps_enabled,
4877: pps_timebase,
4878: pps_polarity;
4879: float
4880: bias_unc_threshold;
4881: double
4882: pps_offset;
4883:
4884: if (rpt_0x8F4A_16 (rpt,
4885: &pps_enabled,
4886: &pps_timebase,
4887: &pps_polarity,
4888: &pps_offset,
4889: &bias_unc_threshold))
4890: {
4891: parsed = BADLEN_PARSE;
4892: return;
4893: }
4894:
4895: pbuf += sprintf(pbuf, "\nPPS is %s", pps_enabled?"enabled":"disabled");
4896: pbuf += sprintf(pbuf, "\n timebase: %s", PPSTimeBaseText[pps_timebase]);
4897: pbuf += sprintf(pbuf, "\n polarity: %s", PPSPolarityText[pps_polarity]);
4898: pbuf += sprintf(pbuf, "\n offset: %.1f ns, ", pps_offset*1.e9);
4899: pbuf += sprintf(pbuf, "\n biasunc: %.1f ns", bias_unc_threshold/GPS_C*1.e9);
4900: }
4901:
4902: /* fast-SA decorrolation time for self-survey */
4903: static void
4904: rpt_8F4B(
4905: TSIPPKT *rpt
4906: )
4907: {
4908: unsigned long
4909: decorr_max;
4910:
4911: if (rpt_0x8F4B(rpt, &decorr_max))
4912: {
4913: parsed = BADLEN_PARSE;
4914: return;
4915: }
4916:
4917: pbuf += sprintf(pbuf,
4918: "\nMax # of position fixes for self-survey : %ld",
4919: decorr_max);
4920: }
4921:
4922: static void
4923: rpt_8F4D(
4924: TSIPPKT *rpt
4925: )
4926: {
4927: static char
4928: *linestart;
4929: unsigned long
4930: OutputMask;
4931: static unsigned long
4932: MaskBit[] = {
4933: 0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010,
4934: 0x00000020,
4935: 0x00000100L, 0x00000800L, 0x00001000L,
4936: 0x40000000L, 0x80000000L};
4937: int
4938: ichoice,
4939: numchoices;
4940:
4941: if (rpt_0x8F4D(rpt, &OutputMask))
4942: {
4943: parsed = BADLEN_PARSE;
4944: return;
4945: }
4946:
4947: pbuf += sprintf(pbuf, "\nAuto-Report Mask: %02X %02X %02X %02X",
4948: (unsigned char)(OutputMask>>24),
4949: (unsigned char)(OutputMask>>16),
4950: (unsigned char)(OutputMask>>8),
4951: (unsigned char)OutputMask);
4952:
4953: numchoices = sizeof(MaskText)/sizeof(char*);
4954: pbuf += sprintf(pbuf, "\nAuto-Reports scheduled for Output:");
4955: linestart = pbuf;
4956: for (ichoice = 0; ichoice < numchoices; ichoice++)
4957: {
4958: if (OutputMask&MaskBit[ichoice])
4959: {
4960: pbuf += sprintf(pbuf, "%s %s",
4961: (pbuf==linestart)?"\n ":",",
4962: MaskText[ichoice]);
4963: if (pbuf-linestart > 60) linestart = pbuf;
4964: }
4965: }
4966:
4967: pbuf += sprintf(pbuf, "\nAuto-Reports NOT scheduled for Output:");
4968: linestart = pbuf;
4969: for (ichoice = 0; ichoice < numchoices; ichoice++)
4970: {
4971: if (OutputMask&MaskBit[ichoice]) continue;
4972: pbuf += sprintf(pbuf, "%s %s",
4973: (pbuf==linestart)?"\n ":",",
4974: MaskText[ichoice]);
4975: if (pbuf-linestart > 60) linestart = pbuf;
4976: }
4977: }
4978:
4979: static void
4980: rpt_8FA5(
4981: TSIPPKT *rpt
4982: )
4983: {
4984: unsigned char
4985: spktmask[4];
4986:
4987: if (rpt_0x8FA5(rpt, spktmask))
4988: {
4989: parsed = BADLEN_PARSE;
4990: return;
4991: }
4992:
4993: pbuf += sprintf(pbuf, "\nSuperpacket auto-output mask: %02X %02X %02X %02X",
4994: spktmask[0], spktmask[1], spktmask[2], spktmask[3]);
4995:
4996: if (spktmask[0]&0x01) pbuf+= sprintf (pbuf, "\n PPS 8F-0B");
4997: if (spktmask[0]&0x02) pbuf+= sprintf (pbuf, "\n Event 8F-0B");
4998: if (spktmask[0]&0x10) pbuf+= sprintf (pbuf, "\n PPS 8F-AD");
4999: if (spktmask[0]&0x20) pbuf+= sprintf (pbuf, "\n Event 8F-AD");
5000: if (spktmask[2]&0x01) pbuf+= sprintf (pbuf, "\n ppos Fix 8F-20");
5001: }
5002:
5003: static void
5004: rpt_8FAD(
5005: TSIPPKT *rpt
5006: )
5007: {
5008: unsigned short
5009: Count,
5010: Year;
5011: double
5012: FracSec;
5013: unsigned char
5014: Hour,
5015: Minute,
5016: Second,
5017: Day,
5018: Month,
5019: Status,
5020: Flags;
5021: static char* Status8FADText[] = {
5022: "CODE_DOING_FIXES",
5023: "CODE_GOOD_1_SV",
5024: "CODE_APPX_1SV",
5025: "CODE_NEED_TIME",
5026: "CODE_NEED_INITIALIZATION",
5027: "CODE_PDOP_HIGH",
5028: "CODE_BAD_1SV",
5029: "CODE_0SVS",
5030: "CODE_1SV",
5031: "CODE_2SVS",
5032: "CODE_3SVS",
5033: "CODE_NO_INTEGRITY",
5034: "CODE_DCORR_GEN",
5035: "CODE_OVERDET_CLK",
5036: "Invalid Status"},
5037: *LeapStatusText[] = {
5038: " UTC Avail", " ", " ", " ",
5039: " Scheduled", " Pending", " Warning", " In Progress"};
5040: int i;
5041:
5042: if (rpt_0x8FAD (rpt,
5043: &Count,
5044: &FracSec,
5045: &Hour,
5046: &Minute,
5047: &Second,
5048: &Day,
5049: &Month,
5050: &Year,
5051: &Status,
5052: &Flags))
5053: {
5054: parsed = BADLEN_PARSE;
5055: return;
5056: }
5057:
5058: pbuf += sprintf(pbuf, "\n8FAD Count: %d Status: %s",
5059: Count, Status8FADText[Status]);
5060:
5061: pbuf += sprintf(pbuf, "\n Leap Flags:");
5062: if (Flags)
5063: {
5064: for (i=0; i<8; i++)
5065: {
5066: if (Flags&(1<<i)) pbuf += sprintf(pbuf, LeapStatusText[i]);
5067: }
5068: }
5069: else
5070: {
5071: pbuf += sprintf(pbuf, " UTC info not available");
5072: }
5073:
5074: pbuf += sprintf(pbuf, "\n %02d/%02d/%04d (DMY) %02d:%02d:%02d.%09ld UTC",
5075: Day, Month, Year, Hour, Minute, Second, (long)(FracSec*1.e9));
5076: }
5077:
5078:
5079: int
5080: print_msg_table_header(
5081: int rptcode,
5082: char *HdrStr,
5083: int force
5084: )
5085: {
5086: /* force header is to help auto-output function */
5087: /* last_rptcode is to determine whether to print a header */
5088: /* for the first occurrence of a series of reports */
5089: static int
5090: last_rptcode = 0;
5091: int
5092: numchars;
5093:
5094: numchars = 0;
5095: if (force || rptcode!=last_rptcode)
5096: {
5097: /* supply a header in console output */
5098: switch (rptcode)
5099: {
5100: case 0x5A:
5101: numchars = sprintf(HdrStr, "\nRaw Measurement Data");
5102: numchars += sprintf(HdrStr+numchars,
5103: "\n SV Sample SNR Code Phase Doppler Seconds Time of Meas");
5104: break;
5105:
5106: case 0x5B:
5107: numchars = sprintf(HdrStr, "\nEphemeris Status");
5108: numchars += sprintf(HdrStr+numchars,
5109: "\n SV Time collected Health IODE t oe Fit URA");
5110: break;
5111:
5112: case 0x5C:
5113: numchars = sprintf(HdrStr, "\nTracking Info");
5114: numchars += sprintf(HdrStr+numchars,
5115: "\n SV C Acq Eph SNR Time of Meas Elev Azim ");
5116: break;
5117:
5118: }
5119: }
5120: last_rptcode = rptcode;
5121: return (short)numchars;
5122: }
5123:
5124: static void
5125: unknown_rpt(
5126: TSIPPKT *rpt
5127: )
5128: {
5129: int i;
5130:
5131: /* app-specific rpt packets */
5132: if (parsed == BADLEN_PARSE)
5133: {
5134: pbuf += sprintf(pbuf, "\nTSIP report packet ID %2Xh, length %d: Bad length",
5135: rpt->code, rpt->len);
5136: }
5137: if (parsed == BADID_PARSE)
5138: {
5139: pbuf += sprintf(pbuf,
5140: "\nTSIP report packet ID %2Xh, length %d: translation not supported",
5141: rpt->code, rpt->len);
5142: }
5143:
5144: if (parsed == BADDATA_PARSE)
5145: {
5146: pbuf += sprintf(pbuf,
5147: "\nTSIP report packet ID %2Xh, length %d: data content incorrect",
5148: rpt->code, rpt->len);
5149: }
5150:
5151: for (i = 0; i < rpt->len; i++) {
5152: if ((i % 20) == 0) *pbuf++ = '\n';
5153: pbuf += sprintf(pbuf, " %02X", rpt->buf[i]);
5154: }
5155: }
5156: /**/
5157:
5158: /*
5159: ** main subroutine, called from ProcessInputBytesWhileWaitingForKBHit()
5160: */
5161: void
5162: TranslateTSIPReportToText(
5163: TSIPPKT *rpt,
5164: char *TextOutputBuffer
5165: )
5166: {
5167:
5168: /* pbuf is the pointer to the current location of the text output */
5169: pbuf = TextOutputBuffer;
5170:
5171: /* keep track of whether the message has been successfully parsed */
5172: parsed = GOOD_PARSE;
5173:
5174: /* print a header if this is the first of a series of messages */
5175: pbuf += print_msg_table_header (rpt->code, pbuf, FALSE);
5176:
5177: /* process incoming TSIP report according to code */
5178: switch (rpt->code)
5179: {
5180: case 0x3D: rpt_chan_A_config (rpt); break;
5181: case 0x40: rpt_almanac_data_page (rpt); break;
5182: case 0x41: rpt_GPS_time (rpt); break;
5183: case 0x42: rpt_single_ECEF_position (rpt); break;
5184: case 0x43: rpt_single_ECEF_velocity (rpt); break;
5185: case 0x45: rpt_SW_version (rpt); break;
5186: case 0x46: rpt_rcvr_health (rpt); break;
5187: case 0x47: rpt_SNR_all_SVs (rpt); break;
5188: case 0x48: rpt_GPS_system_message (rpt); break;
5189: case 0x49: rpt_almanac_health_page (rpt); break;
5190: case 0x4A: switch (rpt->len) {
5191: /*
5192: ** special case (=slip-up) in the TSIP protocol;
5193: ** parsing method depends on length
5194: */
5195: case 20: rpt_single_lla_position (rpt); break;
5196: case 9: rpt_ref_alt (rpt); break;
5197: } break;
5198: case 0x4B: rpt_rcvr_id_and_status (rpt);break;
5199: case 0x4C: rpt_operating_parameters (rpt); break;
5200: case 0x4D: rpt_oscillator_offset (rpt); break;
5201: case 0x4E: rpt_GPS_time_set_response (rpt); break;
5202: case 0x4F: rpt_UTC_offset (rpt); break;
5203: case 0x54: rpt_1SV_bias (rpt); break;
5204: case 0x55: rpt_io_opt (rpt); break;
5205: case 0x56: rpt_ENU_velocity (rpt); break;
5206: case 0x57: rpt_last_fix_info (rpt); break;
5207: case 0x58: rpt_GPS_system_data (rpt); break;
5208: case 0x59: rpt_SVs_enabled (rpt); break;
5209: case 0x5A: rpt_raw_msmt (rpt); break;
5210: case 0x5B: rpt_SV_ephemeris_status (rpt); break;
5211: case 0x5C: rpt_SV_tracking_status (rpt); break;
5212: case 0x6D: rpt_allSV_selection (rpt); break;
5213: case 0x82: rpt_DGPS_position_mode (rpt); break;
5214: case 0x83: rpt_double_ECEF_position (rpt); break;
5215: case 0x84: rpt_double_lla_position (rpt); break;
5216: case 0xBB: rpt_complete_rcvr_config (rpt); break;
5217: case 0xBC: rpt_rcvr_serial_port_config (rpt); break;
5218:
5219: case 0x8F: switch (rpt->buf[0])
5220: {
5221: /* superpackets; parsed according to subcodes */
5222: case 0x0B: rpt_8F0B(rpt); break;
5223: case 0x14: rpt_8F14(rpt); break;
5224: case 0x15: rpt_8F15(rpt); break;
5225: case 0x20: rpt_8F20(rpt); break;
5226: case 0x41: rpt_8F41(rpt); break;
5227: case 0x42: rpt_8F42(rpt); break;
5228: case 0x45: rpt_8F45(rpt); break;
5229: case 0x4A: rpt_8F4A(rpt); break;
5230: case 0x4B: rpt_8F4B(rpt); break;
5231: case 0x4D: rpt_8F4D(rpt); break;
5232: case 0xA5: rpt_8FA5(rpt); break;
5233: case 0xAD: rpt_8FAD(rpt); break;
5234: default: parsed = BADID_PARSE; break;
5235: }
5236: break;
5237:
5238: default: parsed = BADID_PARSE; break;
5239: }
5240:
5241: if (parsed != GOOD_PARSE)
5242: {
5243: /*
5244: **The message has TSIP structure (DLEs, etc.)
5245: ** but could not be parsed by above routines
5246: */
5247: unknown_rpt (rpt);
5248: }
5249:
5250: /* close TextOutputBuffer */
5251: pbuf = '\0';
5252: }
5253:
5254: #endif /* TRIMBLE_OUTPUT_FUNC */
5255:
5256: #else /* defined(REFCLOCK) && defined(CLOCK_RIPENCC) */
5257: int refclock_ripencc_bs;
5258: #endif /* defined(REFCLOCK) && defined(CLOCK_RIPENCC) */
5259: