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