diff options
Diffstat (limited to 'ntpd/refclock_ripencc.c')
| -rw-r--r-- | ntpd/refclock_ripencc.c | 5255 |
1 files changed, 5255 insertions, 0 deletions
diff --git a/ntpd/refclock_ripencc.c b/ntpd/refclock_ripencc.c new file mode 100644 index 0000000..75d8f38 --- /dev/null +++ b/ntpd/refclock_ripencc.c @@ -0,0 +1,5255 @@ +/* + * $Id: refclock_ripencc.c,v 1.13 2002/06/18 14:20:55 marks Exp marks $ + * + * Copyright (c) 2002 RIPE NCC + * + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notice appear in all copies and that + * both that copyright notice and this permission notice appear in + * supporting documentation, and that the name of the author not be + * used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. + * + * THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING + * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL + * AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY + * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * + * + * This driver was developed for use with the RIPE NCC TTM project. + * + * + * The initial driver was developed by Daniel Karrenberg <dfk@ripe.net> + * using the code made available by Trimble. This was for xntpd-3.x.x + * + * Rewrite of the driver for ntpd-4.x.x by Mark Santcroos <marks@ripe.net> + * + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif /* HAVE_CONFIG_H */ + +#if defined(REFCLOCK) && defined(CLOCK_RIPENCC) + +#include "ntp_stdlib.h" +#include "ntpd.h" +#include "ntp_refclock.h" +#include "ntp_unixtime.h" +#include "ntp_io.h" + +#ifdef HAVE_PPSAPI +# include "ppsapi_timepps.h" +#endif + +/* + * Definitions + */ + +/* we are on little endian */ +#define BYTESWAP + +/* + * DEBUG statements: uncomment if necessary + */ +/* #define DEBUG_NCC */ /* general debug statements */ +/* #define DEBUG_PPS */ /* debug pps */ +/* #define DEBUG_RAW */ /* print raw packets */ + +#define TRIMBLE_OUTPUT_FUNC +#define TSIP_VERNUM "7.12a" + +#ifndef FALSE +#define FALSE (0) +#define TRUE (!FALSE) +#endif /* FALSE */ + +#define GPS_PI (3.1415926535898) +#define GPS_C (299792458.) +#define D2R (GPS_PI/180.0) +#define R2D (180.0/GPS_PI) +#define WEEK (604800.) +#define MAXCHAN (8) + +/* control characters for TSIP packets */ +#define DLE (0x10) +#define ETX (0x03) + +#define MAX_RPTBUF (256) + +/* values of TSIPPKT.status */ +#define TSIP_PARSED_EMPTY 0 +#define TSIP_PARSED_FULL 1 +#define TSIP_PARSED_DLE_1 2 +#define TSIP_PARSED_DATA 3 +#define TSIP_PARSED_DLE_2 4 + +#define UTCF_UTC_AVAIL (unsigned char) (1) /* UTC available */ +#define UTCF_LEAP_SCHD (unsigned char) (1<<4) /* Leap scheduled */ +#define UTCF_LEAP_PNDG (unsigned char) (1<<5) /* Leap pending, will occur at end of day */ + +#define DEVICE "/dev/gps%d" /* name of radio device */ +#define PRECISION (-9) /* precision assumed (about 2 ms) */ +#define PPS_PRECISION (-20) /* precision assumed (about 1 us) */ +#define REFID "GPS\0" /* reference id */ +#define REFID_LEN 4 +#define DESCRIPTION "RIPE NCC GPS (Palisade)" /* Description */ +#define SPEED232 B9600 /* 9600 baud */ + +#define NSAMPLES 3 /* stages of median filter */ + +/* Structures */ + +/* TSIP packets have the following structure, whether report or command. */ +typedef struct { + short + counter, /* counter */ + len; /* size of buf; < MAX_RPTBUF unsigned chars */ + unsigned char + status, /* TSIP packet format/parse status */ + code, /* TSIP code */ + buf[MAX_RPTBUF]; /* report or command string */ +} TSIPPKT; + +/* TSIP binary data structures */ +typedef struct { + unsigned char + t_oa_raw, SV_health; + float + e, t_oa, i_0, OMEGADOT, sqrt_A, + OMEGA_0, omega, M_0, a_f0, a_f1, + Axis, n, OMEGA_n, ODOT_n, t_zc; + short + weeknum, wn_oa; +} ALM_INFO; + +typedef struct { /* Almanac health page (25) parameters */ + unsigned char + WN_a, SV_health[32], t_oa; +} ALH_PARMS; + +typedef struct { /* Universal Coordinated Time (UTC) parms */ + double + A_0; + float + A_1; + short + delta_t_LS; + float + t_ot; + short + WN_t, WN_LSF, DN, delta_t_LSF; +} UTC_INFO; + +typedef struct { /* Ionospheric info (float) */ + float + alpha_0, alpha_1, alpha_2, alpha_3, + beta_0, beta_1, beta_2, beta_3; +} ION_INFO; + +typedef struct { /* Subframe 1 info (float) */ + short + weeknum; + unsigned char + codeL2, L2Pdata, SVacc_raw, SV_health; + short + IODC; + float + T_GD, t_oc, a_f2, a_f1, a_f0, SVacc; +} EPHEM_CLOCK; + +typedef struct { /* Ephemeris info (float) */ + unsigned char + IODE, fit_interval; + float + C_rs, delta_n; + double + M_0; + float + C_uc; + double + e; + float + C_us; + double + sqrt_A; + float + t_oe, C_ic; + double + OMEGA_0; + float + C_is; + double + i_0; + float + C_rc; + double + omega; + float + OMEGADOT, IDOT; + double + Axis, n, r1me2, OMEGA_n, ODOT_n; +} EPHEM_ORBIT; + +typedef struct { /* Navigation data structure */ + short + sv_number; /* SV number (0 = no entry) */ + float + t_ephem; /* time of ephemeris collection */ + EPHEM_CLOCK + ephclk; /* subframe 1 data */ + EPHEM_ORBIT + ephorb; /* ephemeris data */ +} NAV_INFO; + +typedef struct { + unsigned char + bSubcode, + operating_mode, + dgps_mode, + dyn_code, + trackmode; + float + elev_mask, + cno_mask, + dop_mask, + dop_switch; + unsigned char + dgps_age_limit; +} TSIP_RCVR_CFG; + + +#ifdef TRIMBLE_OUTPUT_FUNC +static char + *dayname[7] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}, + old_baudnum[] = {0, 1, 4, 5, 6, 8, 9, 11, 28, 12}, + *st_baud_text_app [] = {"", "", " 300", " 600", " 1200", " 2400", + " 4800", " 9600", "19200", "38400"}, + *old_parity_text[] = {"EVEN", "ODD", "", "", "NONE"}, + *parity_text [] = {"NONE", "ODD", "EVEN"}, + *old_input_ch[] = { "TSIP", "RTCM (6 of 8 bits)"}, + *old_output_ch[] = { "TSIP", "No output", "", "", "", "NMEA 0183"}, + *protocols_in_text[] = { "", "TSIP", "", ""}, + *protocols_out_text[] = { "", "TSIP", "NMEA"}, + *rcvr_port_text [] = { "Port A ", "Port B ", "Current Port"}, + *dyn_text [] = {"Unchanged", "Land", "Sea", "Air", "Static"}, + *NavModeText0xBB[] = {"automatic", "time only (0-D)", "", "2-D", + "3-D", "", "", "OverDetermined Time"}, + *PPSTimeBaseText[] = {"GPS", "UTC", "USER"}, + *PPSPolarityText[] = {"Positive", "Negative"}, + *MaskText[] = { "Almanac ", "Ephemeris", "UTC ", "Iono ", + "GPS Msg ", "Alm Hlth ", "Time Fix ", "SV Select", + "Ext Event", "Pos Fix ", "Raw Meas "}; + +#endif /* TRIMBLE_OUTPUT_FUNC */ + +/* + * Unit control structure + */ +struct ripencc_unit { + int unit; /* unit number */ + int pollcnt; /* poll message counter */ + int polled; /* Hand in a sample? */ + char leapdelta; /* delta of next leap event */ + unsigned char utcflags; /* delta of next leap event */ + l_fp tstamp; /* timestamp of last poll */ + + struct timespec ts; /* last timestamp */ + pps_params_t pps_params; /* pps parameters */ + pps_info_t pps_info; /* last pps data */ + pps_handle_t handle; /* pps handlebars */ + +}; + + +/******************* PROTOYPES *****************/ + +/* prototypes for report parsing primitives */ +short rpt_0x3D (TSIPPKT *rpt, unsigned char *tx_baud_index, + unsigned char *rx_baud_index, unsigned char *char_format_index, + unsigned char *stop_bits, unsigned char *tx_mode_index, + unsigned char *rx_mode_index); +short rpt_0x40 (TSIPPKT *rpt, unsigned char *sv_prn, short *week_num, + float *t_zc, float *eccentricity, float *t_oa, float *i_0, + float *OMEGA_dot, float *sqrt_A, float *OMEGA_0, float *omega, + float *M_0); +short rpt_0x41 (TSIPPKT *rpt, float *time_of_week, float *UTC_offset, + short *week_num); +short rpt_0x42 (TSIPPKT *rpt, float ECEF_pos[3], float *time_of_fix); +short rpt_0x43 (TSIPPKT *rpt, float ECEF_vel[3], float *freq_offset, + float *time_of_fix); +short rpt_0x45 (TSIPPKT *rpt, unsigned char *major_nav_version, + unsigned char *minor_nav_version, unsigned char *nav_day, + unsigned char *nav_month, unsigned char *nav_year, + unsigned char *major_dsp_version, unsigned char *minor_dsp_version, + unsigned char *dsp_day, unsigned char *dsp_month, + unsigned char *dsp_year); +short rpt_0x46 (TSIPPKT *rpt, unsigned char *status1, unsigned char *status2); +short rpt_0x47 (TSIPPKT *rpt, unsigned char *nsvs, unsigned char *sv_prn, + float *snr); +short rpt_0x48 (TSIPPKT *rpt, unsigned char *message); +short rpt_0x49 (TSIPPKT *rpt, unsigned char *sv_health); +short rpt_0x4A (TSIPPKT *rpt, float *lat, float *lon, float *alt, + float *clock_bias, float *time_of_fix); +short rpt_0x4A_2 (TSIPPKT *rpt, float *alt, float *dummy, + unsigned char *alt_flag); +short rpt_0x4B (TSIPPKT *rpt, unsigned char *machine_id, + unsigned char *status3, unsigned char *status4); +short rpt_0x4C (TSIPPKT *rpt, unsigned char *dyn_code, float *el_mask, + float *snr_mask, float *dop_mask, float *dop_switch); +short rpt_0x4D (TSIPPKT *rpt, float *osc_offset); +short rpt_0x4E (TSIPPKT *rpt, unsigned char *response); +short rpt_0x4F (TSIPPKT *rpt, double *a0, float *a1, float *time_of_data, + short *dt_ls, short *wn_t, short *wn_lsf, short *dn, short *dt_lsf); +short rpt_0x54 (TSIPPKT *rpt, float *clock_bias, float *freq_offset, + float *time_of_fix); +short rpt_0x55 (TSIPPKT *rpt, unsigned char *pos_code, unsigned char *vel_code, + unsigned char *time_code, unsigned char *aux_code); +short rpt_0x56 (TSIPPKT *rpt, float vel_ENU[3], float *freq_offset, + float *time_of_fix); +short rpt_0x57 (TSIPPKT *rpt, unsigned char *source_code, + unsigned char *diag_code, short *week_num, float *time_of_fix); +short rpt_0x58 (TSIPPKT *rpt, unsigned char *op_code, unsigned char *data_type, + unsigned char *sv_prn, unsigned char *data_length, + unsigned char *data_packet); +short rpt_0x59 (TSIPPKT *rpt, unsigned char *code_type, + unsigned char status_code[32]); +short rpt_0x5A (TSIPPKT *rpt, unsigned char *sv_prn, float *sample_length, + float *signal_level, float *code_phase, float *Doppler, + double *time_of_fix); +short rpt_0x5B (TSIPPKT *rpt, unsigned char *sv_prn, unsigned char *sv_health, + unsigned char *sv_iode, unsigned char *fit_interval_flag, + float *time_of_collection, float *time_of_eph, float *sv_accy); +short rpt_0x5C (TSIPPKT *rpt, unsigned char *sv_prn, unsigned char *slot, + unsigned char *chan, unsigned char *acq_flag, unsigned char *eph_flag, + float *signal_level, float *time_of_last_msmt, float *elev, + float *azim, unsigned char *old_msmt_flag, + unsigned char *integer_msec_flag, unsigned char *bad_data_flag, + unsigned char *data_collect_flag); +short rpt_0x6D (TSIPPKT *rpt, unsigned char *manual_mode, unsigned char *nsvs, + unsigned char *ndim, unsigned char sv_prn[], float *pdop, + float *hdop, float *vdop, float *tdop); +short rpt_0x82 (TSIPPKT *rpt, unsigned char *diff_mode); +short rpt_0x83 (TSIPPKT *rpt, double ECEF_pos[3], double *clock_bias, + float *time_of_fix); +short rpt_0x84 (TSIPPKT *rpt, double *lat, double *lon, double *alt, + double *clock_bias, float *time_of_fix); +short rpt_Paly0xBB(TSIPPKT *rpt, TSIP_RCVR_CFG *TsipxBB); +short rpt_0xBC (TSIPPKT *rpt, unsigned char *port_num, + unsigned char *in_baud, unsigned char *out_baud, + unsigned char *data_bits, unsigned char *parity, + unsigned char *stop_bits, unsigned char *flow_control, + unsigned char *protocols_in, unsigned char *protocols_out, + unsigned char *reserved); + +/* prototypes for superpacket parsers */ + +short rpt_0x8F0B (TSIPPKT *rpt, unsigned short *event, double *tow, + unsigned char *date, unsigned char *month, short *year, + unsigned char *dim_mode, short *utc_offset, double *bias, double *drift, + float *bias_unc, float *dr_unc, double *lat, double *lon, double *alt, + char sv_id[8]); +short rpt_0x8F14 (TSIPPKT *rpt, short *datum_idx, double datum_coeffs[5]); +short rpt_0x8F15 (TSIPPKT *rpt, short *datum_idx, double datum_coeffs[5]); +short rpt_0x8F20 (TSIPPKT *rpt, unsigned char *info, double *lat, + double *lon, double *alt, double vel_enu[], double *time_of_fix, + short *week_num, unsigned char *nsvs, unsigned char sv_prn[], + short sv_IODC[], short *datum_index); +short rpt_0x8F41 (TSIPPKT *rpt, unsigned char *bSearchRange, + unsigned char *bBoardOptions, unsigned long *iiSerialNumber, + unsigned char *bBuildYear, unsigned char *bBuildMonth, + unsigned char *bBuildDay, unsigned char *bBuildHour, + float *fOscOffset, unsigned short *iTestCodeId); +short rpt_0x8F42 (TSIPPKT *rpt, unsigned char *bProdOptionsPre, + unsigned char *bProdNumberExt, unsigned short *iCaseSerialNumberPre, + unsigned long *iiCaseSerialNumber, unsigned long *iiProdNumber, + unsigned short *iPremiumOptions, unsigned short *iMachineID, + unsigned short *iKey); +short rpt_0x8F45 (TSIPPKT *rpt, unsigned char *bSegMask); +short rpt_0x8F4A_16 (TSIPPKT *rpt, unsigned char *pps_enabled, + unsigned char *pps_timebase, unsigned char *pos_polarity, + double *pps_offset, float *bias_unc_threshold); +short rpt_0x8F4B (TSIPPKT *rpt, unsigned long *decorr_max); +short rpt_0x8F4D (TSIPPKT *rpt, unsigned long *event_mask); +short rpt_0x8FA5 (TSIPPKT *rpt, unsigned char *spktmask); +short rpt_0x8FAD (TSIPPKT *rpt, unsigned short *COUNT, double *FracSec, + unsigned char *Hour, unsigned char *Minute, unsigned char *Second, + unsigned char *Day, unsigned char *Month, unsigned short *Year, + unsigned char *Status, unsigned char *Flags); + +/**/ +/* prototypes for command-encode primitives with suffix convention: */ +/* c = clear, s = set, q = query, e = enable, d = disable */ +void cmd_0x1F (TSIPPKT *cmd); +void cmd_0x26 (TSIPPKT *cmd); +void cmd_0x2F (TSIPPKT *cmd); +void cmd_0x35s (TSIPPKT *cmd, unsigned char pos_code, unsigned char vel_code, + unsigned char time_code, unsigned char opts_code); +void cmd_0x3C (TSIPPKT *cmd, unsigned char sv_prn); +void cmd_0x3Ds (TSIPPKT *cmd, unsigned char baud_out, unsigned char baud_inp, + unsigned char char_code, unsigned char stopbitcode, + unsigned char output_mode, unsigned char input_mode); +void cmd_0xBBq (TSIPPKT *cmd, unsigned char subcode) ; + +/* prototypes 8E commands */ +void cmd_0x8E0Bq (TSIPPKT *cmd); +void cmd_0x8E41q (TSIPPKT *cmd); +void cmd_0x8E42q (TSIPPKT *cmd); +void cmd_0x8E4Aq (TSIPPKT *cmd); +void cmd_0x8E4As (TSIPPKT *cmd, unsigned char PPSOnOff, unsigned char TimeBase, + unsigned char Polarity, double PPSOffset, float Uncertainty); +void cmd_0x8E4Bq (TSIPPKT *cmd); +void cmd_0x8E4Ds (TSIPPKT *cmd, unsigned long AutoOutputMask); +void cmd_0x8EADq (TSIPPKT *cmd); + +/* header/source border XXXXXXXXXXXXXXXXXXXXXXXXXX */ + +/* Trimble parse functions */ +static int parse0x8FAD (TSIPPKT *, struct peer *); +static int parse0x8F0B (TSIPPKT *, struct peer *); +#ifdef TRIMBLE_OUTPUT_FUNC +static int parseany (TSIPPKT *, struct peer *); +static void TranslateTSIPReportToText (TSIPPKT *, char *); +#endif /* TRIMBLE_OUTPUT_FUNC */ +static int parse0x5C (TSIPPKT *, struct peer *); +static int parse0x4F (TSIPPKT *, struct peer *); +static void tsip_input_proc (TSIPPKT *, int); + +/* Trimble helper functions */ +static void bPutFloat (float *, unsigned char *); +static void bPutDouble (double *, unsigned char *); +static void bPutULong (unsigned long *, unsigned char *); +static int print_msg_table_header (int rptcode, char *HdrStr, int force); +static char * show_time (float time_of_week); + +/* RIPE NCC functions */ +static void ripencc_control (int, const struct refclockstat *, + struct refclockstat *, struct peer *); +static int ripencc_ppsapi (struct peer *, int, int); +static int ripencc_get_pps_ts (struct ripencc_unit *, l_fp *); +static int ripencc_start (int, struct peer *); +static void ripencc_shutdown (int, struct peer *); +static void ripencc_poll (int, struct peer *); +static void ripencc_send (struct peer *, TSIPPKT spt); +static void ripencc_receive (struct recvbuf *); + +/* fill in reflock structure for our clock */ +struct refclock refclock_ripencc = { + ripencc_start, /* start up driver */ + ripencc_shutdown, /* shut down driver */ + ripencc_poll, /* transmit poll message */ + ripencc_control, /* control function */ + noentry, /* initialize driver */ + noentry, /* debug info */ + NOFLAGS /* clock flags */ +}; + +/* + * Tables to compute the ddd of year form icky dd/mm timecode. Viva la + * leap. + */ +static int day1tab[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; +static int day2tab[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; + + +/* + * ripencc_start - open the GPS devices and initialize data for processing + */ +static int +ripencc_start(int unit, struct peer *peer) +{ + register struct ripencc_unit *up; + struct refclockproc *pp; + char device[40]; + int fd; + struct termios tio; + TSIPPKT spt; + + pp = peer->procptr; + + /* + * Open serial port + */ + (void)snprintf(device, sizeof(device), DEVICE, unit); + fd = refclock_open(device, SPEED232, LDISC_RAW); + if (fd <= 0) { + pp->io.fd = -1; + return (0); + } + + pp->io.fd = fd; + + /* from refclock_palisade.c */ + if (tcgetattr(fd, &tio) < 0) { + msyslog(LOG_ERR, "Palisade(%d) tcgetattr(fd, &tio): %m",unit); + return (0); + } + + /* + * set flags + */ + tio.c_cflag |= (PARENB|PARODD); + tio.c_iflag &= ~ICRNL; + if (tcsetattr(fd, TCSANOW, &tio) == -1) { + msyslog(LOG_ERR, "Palisade(%d) tcsetattr(fd, &tio): %m",unit); + return (0); + } + + /* + * Allocate and initialize unit structure + */ + up = emalloc_zero(sizeof(*up)); + + pp->io.clock_recv = ripencc_receive; + pp->io.srcclock = peer; + pp->io.datalen = 0; + if (!io_addclock(&pp->io)) { + pp->io.fd = -1; + close(fd); + free(up); + return (0); + } + pp->unitptr = up; + + /* + * Initialize miscellaneous variables + */ + peer->precision = PRECISION; + pp->clockdesc = DESCRIPTION; + memcpy((char *)&pp->refid, REFID, REFID_LEN); + up->pollcnt = 2; + up->unit = unit; + up->leapdelta = 0; + up->utcflags = 0; + + /* + * Initialize the Clock + */ + + /* query software versions */ + cmd_0x1F(&spt); + ripencc_send(peer, spt); + + /* query receiver health */ + cmd_0x26(&spt); + ripencc_send(peer, spt); + + /* query serial numbers */ + cmd_0x8E42q(&spt); + ripencc_send(peer, spt); + + /* query manuf params */ + cmd_0x8E41q(&spt); + ripencc_send(peer, spt); + + /* i/o opts */ /* trimble manual page A30 */ + cmd_0x35s(&spt, + 0x1C, /* position */ + 0x00, /* velocity */ + 0x05, /* timing */ + 0x0a); /* auxilary */ + ripencc_send(peer, spt); + + /* turn off port A */ + cmd_0x3Ds (&spt, + 0x0B, /* baud_out */ + 0x0B, /* baud_inp */ + 0x07, /* char_code */ + 0x07, /* stopbitcode */ + 0x01, /* output_mode */ + 0x00); /* input_mode */ + ripencc_send(peer, spt); + + /* set i/o options */ + cmd_0x8E4As (&spt, + 0x01, /* PPS on */ + 0x01, /* Timebase UTC */ + 0x00, /* polarity positive */ + 0., /* 100 ft. cable XXX make flag */ + 1e-6 * GPS_C); /* turn of biasuncert. > (1us) */ + ripencc_send(peer,spt); + + /* all outomatic packet output off */ + cmd_0x8E4Ds(&spt, + 0x00000000); /* AutoOutputMask */ + ripencc_send(peer, spt); + + cmd_0xBBq (&spt, + 0x00); /* query primary configuration */ + ripencc_send(peer,spt); + + + /* query PPS parameters */ + cmd_0x8E4Aq (&spt); /* query PPS params */ + ripencc_send(peer,spt); + + /* query survey limit */ + cmd_0x8E4Bq (&spt); /* query survey limit */ + ripencc_send(peer,spt); + +#ifdef DEBUG_NCC + if (debug) + printf("ripencc_start: success\n"); +#endif /* DEBUG_NCC */ + + /* + * Start the PPSAPI interface if it is there. Default to use + * the assert edge and do not enable the kernel hardpps. + */ + if (time_pps_create(fd, &up->handle) < 0) { + up->handle = 0; + msyslog(LOG_ERR, "refclock_ripencc: time_pps_create failed: %m"); + return (1); + } + + return(ripencc_ppsapi(peer, 0, 0)); +} + +/* + * ripencc_control - fudge control + */ +static void +ripencc_control( + int unit, /* unit (not used) */ + const struct refclockstat *in, /* input parameters (not used) */ + struct refclockstat *out, /* output parameters (not used) */ + struct peer *peer /* peer structure pointer */ + ) +{ + struct refclockproc *pp; + +#ifdef DEBUG_NCC + msyslog(LOG_INFO,"%s()",__FUNCTION__); +#endif /* DEBUG_NCC */ + + pp = peer->procptr; + ripencc_ppsapi(peer, pp->sloppyclockflag & CLK_FLAG2, + pp->sloppyclockflag & CLK_FLAG3); +} + + +/* + * Initialize PPSAPI + */ +int +ripencc_ppsapi( + struct peer *peer, /* peer structure pointer */ + int enb_clear, /* clear enable */ + int enb_hardpps /* hardpps enable */ + ) +{ + struct refclockproc *pp; + struct ripencc_unit *up; + int capability; + + pp = peer->procptr; + up = pp->unitptr; + if (time_pps_getcap(up->handle, &capability) < 0) { + msyslog(LOG_ERR, + "refclock_ripencc: time_pps_getcap failed: %m"); + return (0); + } + memset(&up->pps_params, 0, sizeof(pps_params_t)); + if (enb_clear) + up->pps_params.mode = capability & PPS_CAPTURECLEAR; + else + up->pps_params.mode = capability & PPS_CAPTUREASSERT; + if (!up->pps_params.mode) { + msyslog(LOG_ERR, + "refclock_ripencc: invalid capture edge %d", + !enb_clear); + return (0); + } + up->pps_params.mode |= PPS_TSFMT_TSPEC; + if (time_pps_setparams(up->handle, &up->pps_params) < 0) { + msyslog(LOG_ERR, + "refclock_ripencc: time_pps_setparams failed: %m"); + return (0); + } + if (enb_hardpps) { + if (time_pps_kcbind(up->handle, PPS_KC_HARDPPS, + up->pps_params.mode & ~PPS_TSFMT_TSPEC, + PPS_TSFMT_TSPEC) < 0) { + msyslog(LOG_ERR, + "refclock_ripencc: time_pps_kcbind failed: %m"); + return (0); + } + pps_enable = 1; + } + peer->precision = PPS_PRECISION; + +#if DEBUG_NCC + if (debug) { + time_pps_getparams(up->handle, &up->pps_params); + printf( + "refclock_ripencc: capability 0x%x version %d mode 0x%x kern %d\n", + capability, up->pps_params.api_version, + up->pps_params.mode, enb_hardpps); + } +#endif /* DEBUG_NCC */ + + return (1); +} + +/* + * This function is called every 64 seconds from ripencc_receive + * It will fetch the pps time + * + * Return 0 on failure and 1 on success. + */ +static int +ripencc_get_pps_ts( + struct ripencc_unit *up, + l_fp *tsptr + ) +{ + pps_info_t pps_info; + struct timespec timeout, ts; + double dtemp; + l_fp tstmp; + +#ifdef DEBUG_PPS + msyslog(LOG_INFO,"ripencc_get_pps_ts"); +#endif /* DEBUG_PPS */ + + + /* + * Convert the timespec nanoseconds field to ntp l_fp units. + */ + if (up->handle == 0) + return (0); + timeout.tv_sec = 0; + timeout.tv_nsec = 0; + memcpy(&pps_info, &up->pps_info, sizeof(pps_info_t)); + if (time_pps_fetch(up->handle, PPS_TSFMT_TSPEC, &up->pps_info, + &timeout) < 0) + return (0); + if (up->pps_params.mode & PPS_CAPTUREASSERT) { + if (pps_info.assert_sequence == + up->pps_info.assert_sequence) + return (0); + ts = up->pps_info.assert_timestamp; + } else if (up->pps_params.mode & PPS_CAPTURECLEAR) { + if (pps_info.clear_sequence == + up->pps_info.clear_sequence) + return (0); + ts = up->pps_info.clear_timestamp; + } else { + return (0); + } + if ((up->ts.tv_sec == ts.tv_sec) && (up->ts.tv_nsec == ts.tv_nsec)) + return (0); + up->ts = ts; + + tstmp.l_ui = ts.tv_sec + JAN_1970; + dtemp = ts.tv_nsec * FRAC / 1e9; + tstmp.l_uf = (u_int32)dtemp; + +#ifdef DEBUG_PPS + msyslog(LOG_INFO,"ts.tv_sec: %d",(int)ts.tv_sec); + msyslog(LOG_INFO,"ts.tv_nsec: %ld",ts.tv_nsec); +#endif /* DEBUG_PPS */ + + *tsptr = tstmp; + return (1); +} + +/* + * ripencc_shutdown - shut down a GPS clock + */ +static void +ripencc_shutdown(int unit, struct peer *peer) +{ + register struct ripencc_unit *up; + struct refclockproc *pp; + + pp = peer->procptr; + up = pp->unitptr; + + if (up != NULL) { + if (up->handle != 0) + time_pps_destroy(up->handle); + free(up); + } + if (-1 != pp->io.fd) + io_closeclock(&pp->io); + + return; +} + +/* + * ripencc_poll - called by the transmit procedure + */ +static void +ripencc_poll(int unit, struct peer *peer) +{ + register struct ripencc_unit *up; + struct refclockproc *pp; + TSIPPKT spt; + +#ifdef DEBUG_NCC + if (debug) + fprintf(stderr, "ripencc_poll(%d)\n", unit); +#endif /* DEBUG_NCC */ + pp = peer->procptr; + up = pp->unitptr; + if (up->pollcnt == 0) + refclock_report(peer, CEVNT_TIMEOUT); + else + up->pollcnt--; + + pp->polls++; + up->polled = 1; + + /* poll for UTC superpacket */ + cmd_0x8EADq (&spt); + ripencc_send(peer,spt); +} + +/* + * ripencc_send - send message to clock + * use the structures being created by the trimble functions! + * makes the code more readable/clean + */ +static void +ripencc_send(struct peer *peer, TSIPPKT spt) +{ + unsigned char *ip, *op; + unsigned char obuf[512]; + +#ifdef DEBUG_RAW + { + register struct ripencc_unit *up; + register struct refclockproc *pp; + + pp = peer->procptr; + up = pp->unitptr; + if (debug) + printf("ripencc_send(%d, %02X)\n", up->unit, cmd); + } +#endif /* DEBUG_RAW */ + + ip = spt.buf; + op = obuf; + + *op++ = 0x10; + *op++ = spt.code; + + while (spt.len--) { + if (op-obuf > sizeof(obuf)-5) { + msyslog(LOG_ERR, "ripencc_send obuf overflow!"); + refclock_report(peer, CEVNT_FAULT); + return; + } + + if (*ip == 0x10) /* byte stuffing */ + *op++ = 0x10; + *op++ = *ip++; + } + + *op++ = 0x10; + *op++ = 0x03; + +#ifdef DEBUG_RAW + if (debug) { /* print raw packet */ + unsigned char *cp; + int i; + + printf("ripencc_send: len %d\n", op-obuf); + for (i=1, cp=obuf; cp<op; i++, cp++) { + printf(" %02X", *cp); + if (i%10 == 0) + printf("\n"); + } + printf("\n"); + } +#endif /* DEBUG_RAW */ + + if (write(peer->procptr->io.fd, obuf, op-obuf) == -1) { + refclock_report(peer, CEVNT_FAULT); + } +} + +/* + * ripencc_receive() + * + * called when a packet is received on the serial port + * takes care of further processing + * + */ +static void +ripencc_receive(struct recvbuf *rbufp) +{ + register struct ripencc_unit *up; + register struct refclockproc *pp; + struct peer *peer; + static TSIPPKT rpt; /* for current incoming TSIP report */ + TSIPPKT spt; /* send packet */ + int ns_since_pps; + int i; + char *cp; + /* these variables hold data until we decide it's worth keeping */ + char rd_lastcode[BMAX]; + l_fp rd_tmp; + u_short rd_lencode; + + /* msyslog(LOG_INFO, "%s",__FUNCTION__); */ + + /* + * Initialize pointers and read the timecode and timestamp + */ + peer = rbufp->recv_peer; + pp = peer->procptr; + up = pp->unitptr; + rd_lencode = refclock_gtlin(rbufp, rd_lastcode, BMAX, &rd_tmp); + +#ifdef DEBUG_RAW + if (debug) + fprintf(stderr, "ripencc_receive(%d)\n", up->unit); +#endif /* DEBUG_RAW */ + +#ifdef DEBUG_RAW + if (debug) { /* print raw packet */ + int i; + unsigned char *cp; + + printf("ripencc_receive: len %d\n", rbufp->recv_length); + for (i=1, cp=(char*)&rbufp->recv_space; + i <= rbufp->recv_length; + i++, cp++) { + printf(" %02X", *cp); + if (i%10 == 0) + printf("\n"); + } + printf("\n"); + } +#endif /* DEBUG_RAW */ + + cp = (char*) &rbufp->recv_space; + i=rbufp->recv_length; + + while (i--) { /* loop over received chars */ + + tsip_input_proc(&rpt, (unsigned char) *cp++); + + if (rpt.status != TSIP_PARSED_FULL) + continue; + + switch (rpt.code) { + + case 0x8F: /* superpacket */ + + switch (rpt.buf[0]) { + + case 0xAD: /* UTC Time */ + /* + ** When polling on port B the timecode is + ** the time of the previous PPS. If we + ** completed receiving the packet less than + ** 150ms after the turn of the second, it + ** may have the code of the previous second. + ** We do not trust that and simply poll + ** again without even parsing it. + ** + ** More elegant would be to re-schedule the + ** poll, but I do not know (yet) how to do + ** that cleanly. + ** + */ + /* BLA ns_since_pps = ncc_tstmp(rbufp, &trtmp); */ +/* if (up->polled && ns_since_pps > -1 && ns_since_pps < 150) { */ + + ns_since_pps = 200; + if (up->polled && ns_since_pps < 150) { + msyslog(LOG_INFO, "%s(): up->polled", + __FUNCTION__); + ripencc_poll(up->unit, peer); + break; + } + + /* + * Parse primary utc time packet + * and fill refclock structure + * from results. + */ + if (parse0x8FAD(&rpt, peer) < 0) { + msyslog(LOG_INFO, "%s(): parse0x8FAD < 0",__FUNCTION__); + refclock_report(peer, CEVNT_BADREPLY); + break; + } + /* + * If the PPSAPI is working, rather use its + * timestamps. + * assume that the PPS occurs on the second + * so blow any msec + */ + if (ripencc_get_pps_ts(up, &rd_tmp) == 1) { + pp->lastrec = up->tstamp = rd_tmp; + pp->nsec = 0; + } + else + msyslog(LOG_INFO, "%s(): ripencc_get_pps_ts returns failure",__FUNCTION__); + + + if (!up->polled) { + msyslog(LOG_INFO, "%s(): unrequested packet",__FUNCTION__); + /* unrequested packet */ + break; + } + + /* we have been polled ! */ + up->polled = 0; + up->pollcnt = 2; + + /* poll for next packet */ + cmd_0x8E0Bq(&spt); + ripencc_send(peer,spt); + + if (ns_since_pps < 0) { /* no PPS */ + msyslog(LOG_INFO, "%s(): ns_since_pps < 0",__FUNCTION__); + refclock_report(peer, CEVNT_BADTIME); + break; + } + + /* + ** Process the new sample in the median + ** filter and determine the reference clock + ** offset and dispersion. + */ + if (!refclock_process(pp)) { + msyslog(LOG_INFO, "%s(): !refclock_process",__FUNCTION__); + refclock_report(peer, CEVNT_BADTIME); + break; + } + + refclock_receive(peer); + break; + + case 0x0B: /* comprehensive time packet */ + parse0x8F0B(&rpt, peer); + break; + + default: /* other superpackets */ +#ifdef DEBUG_NCC + msyslog(LOG_INFO, "%s(): calling parseany", + __FUNCTION__); +#endif /* DEBUG_NCC */ +#ifdef TRIMBLE_OUTPUT_FUNC + parseany(&rpt, peer); +#endif /* TRIMBLE_OUTPUT_FUNC */ + break; + } + break; + + case 0x4F: /* UTC parameters, for leap info */ + parse0x4F(&rpt, peer); + break; + + case 0x5C: /* sat tracking data */ + parse0x5C(&rpt, peer); + break; + + default: /* other packets */ +#ifdef TRIMBLE_OUTPUT_FUNC + parseany(&rpt, peer); +#endif /* TRIMBLE_OUTPUT_FUNC */ + break; + } + rpt.status = TSIP_PARSED_EMPTY; + } +} + +/* + * All trimble functions that are directly referenced from driver code + * (so not from parseany) + */ + +/* request software versions */ +void +cmd_0x1F( + TSIPPKT *cmd + ) +{ + cmd->len = 0; + cmd->code = 0x1F; +} + +/* request receiver health */ +void +cmd_0x26( + TSIPPKT *cmd + ) +{ + cmd->len = 0; + cmd->code = 0x26; +} + +/* request UTC params */ +void +cmd_0x2F( + TSIPPKT *cmd + ) +{ + cmd->len = 0; + cmd->code = 0x2F; +} + +/* set serial I/O options */ +void +cmd_0x35s( + TSIPPKT *cmd, + unsigned char pos_code, + unsigned char vel_code, + unsigned char time_code, + unsigned char opts_code + ) +{ + cmd->buf[0] = pos_code; + cmd->buf[1] = vel_code; + cmd->buf[2] = time_code; + cmd->buf[3] = opts_code; + cmd->len = 4; + cmd->code = 0x35; +} + +/* request tracking status */ +void +cmd_0x3C( + TSIPPKT *cmd, + unsigned char sv_prn + ) +{ + cmd->buf[0] = sv_prn; + cmd->len = 1; + cmd->code = 0x3C; +} + +/* set Channel A configuration for dual-port operation */ +void +cmd_0x3Ds( + TSIPPKT *cmd, + unsigned char baud_out, + unsigned char baud_inp, + unsigned char char_code, + unsigned char stopbitcode, + unsigned char output_mode, + unsigned char input_mode + ) +{ + cmd->buf[0] = baud_out; /* XMT baud rate */ + cmd->buf[1] = baud_inp; /* RCV baud rate */ + cmd->buf[2] = char_code; /* parity and #bits per byte */ + cmd->buf[3] = stopbitcode; /* number of stop bits code */ + cmd->buf[4] = output_mode; /* Ch. A transmission mode */ + cmd->buf[5] = input_mode; /* Ch. A reception mode */ + cmd->len = 6; + cmd->code = 0x3D; +} + + +/* query primary configuration */ +void +cmd_0xBBq( + TSIPPKT *cmd, + unsigned char subcode + ) +{ + cmd->len = 1; + cmd->code = 0xBB; + cmd->buf[0] = subcode; +} + + +/**** Superpackets ****/ +/* 8E-0B to query 8F-0B controls */ +void +cmd_0x8E0Bq( + TSIPPKT *cmd + ) +{ + cmd->len = 1; + cmd->code = 0x8E; + cmd->buf[0] = 0x0B; +} + + +/* 8F-41 to query board serial number */ +void +cmd_0x8E41q( + TSIPPKT *cmd + ) +{ + cmd->len = 1; + cmd->code = 0x8E; + cmd->buf[0] = 0x41; +} + + +/* 8F-42 to query product serial number */ +void +cmd_0x8E42q( + TSIPPKT *cmd + ) +{ + cmd->len = 1; + cmd->code = 0x8E; + cmd->buf[0] = 0x42; +} + + +/* 8F-4A to query PPS parameters */ +void +cmd_0x8E4Aq( + TSIPPKT *cmd + ) +{ + cmd->len = 1; + cmd->code = 0x8E; + cmd->buf[0] = 0x4A; +} + + +/* set i/o options */ +void +cmd_0x8E4As( + TSIPPKT *cmd, + unsigned char PPSOnOff, + unsigned char TimeBase, + unsigned char Polarity, + double PPSOffset, + float Uncertainty + ) +{ + cmd->len = 16; + cmd->code = 0x8E; + cmd->buf[0] = 0x4A; + cmd->buf[1] = PPSOnOff; + cmd->buf[2] = TimeBase; + cmd->buf[3] = Polarity; + bPutDouble (&PPSOffset, &cmd->buf[4]); + bPutFloat (&Uncertainty, &cmd->buf[12]); +} + +/* 8F-4B query survey limit */ +void +cmd_0x8E4Bq( + TSIPPKT *cmd + ) +{ + cmd->len = 1; + cmd->code = 0x8E; + cmd->buf[0] = 0x4B; +} + +/* poll for UTC superpacket */ +/* 8E-AD to query 8F-AD controls */ +void +cmd_0x8EADq( + TSIPPKT *cmd + ) +{ + cmd->len = 1; + cmd->code = 0x8E; + cmd->buf[0] = 0xAD; +} + +/* all outomatic packet output off */ +void +cmd_0x8E4Ds( + TSIPPKT *cmd, + unsigned long AutoOutputMask + ) +{ + cmd->len = 5; + cmd->code = 0x8E; + cmd->buf[0] = 0x4D; + bPutULong (&AutoOutputMask, &cmd->buf[1]); +} + + +/* + * for DOS machines, reverse order of bytes as they come through the + * serial port. + */ +#ifdef BYTESWAP +static short +bGetShort( + unsigned char *bp + ) +{ + short outval; + unsigned char *optr; + + optr = (unsigned char*)&outval + 1; + *optr-- = *bp++; + *optr = *bp; + return outval; +} + +#ifdef TRIMBLE_OUTPUT_FUNC +static unsigned short +bGetUShort( + unsigned char *bp + ) +{ + unsigned short outval; + unsigned char *optr; + + optr = (unsigned char*)&outval + 1; + *optr-- = *bp++; + *optr = *bp; + return outval; +} + +static long +bGetLong( + unsigned char *bp + ) +{ + long outval; + unsigned char *optr; + + optr = (unsigned char*)&outval + 3; + *optr-- = *bp++; + *optr-- = *bp++; + *optr-- = *bp++; + *optr = *bp; + return outval; +} + +static unsigned long +bGetULong( + unsigned char *bp + ) +{ + unsigned long outval; + unsigned char *optr; + + optr = (unsigned char*)&outval + 3; + *optr-- = *bp++; + *optr-- = *bp++; + *optr-- = *bp++; + *optr = *bp; + return outval; +} +#endif /* TRIMBLE_OUTPUT_FUNC */ + +static float +bGetSingle( + unsigned char *bp + ) +{ + float outval; + unsigned char *optr; + + optr = (unsigned char*)&outval + 3; + *optr-- = *bp++; + *optr-- = *bp++; + *optr-- = *bp++; + *optr = *bp; + return outval; +} + +static double +bGetDouble( + unsigned char *bp + ) +{ + double outval; + unsigned char *optr; + + optr = (unsigned char*)&outval + 7; + *optr-- = *bp++; + *optr-- = *bp++; + *optr-- = *bp++; + *optr-- = *bp++; + *optr-- = *bp++; + *optr-- = *bp++; + *optr-- = *bp++; + *optr = *bp; + return outval; +} + +#else /* not BYTESWAP */ + +#define bGetShort(bp) (*(short*)(bp)) +#define bGetLong(bp) (*(long*)(bp)) +#define bGetULong(bp) (*(unsigned long*)(bp)) +#define bGetSingle(bp) (*(float*)(bp)) +#define bGetDouble(bp) (*(double*)(bp)) + +#endif /* BYTESWAP */ +/* + * Byte-reversal is necessary for little-endian (Intel-based) machines. + * TSIP streams are Big-endian (Motorola-based). + */ +#ifdef BYTESWAP + +void +bPutFloat( + float *in, + unsigned char *out + ) +{ + unsigned char *inptr; + + inptr = (unsigned char*)in + 3; + *out++ = *inptr--; + *out++ = *inptr--; + *out++ = *inptr--; + *out = *inptr; +} + +static void +bPutULong( + unsigned long *in, + unsigned char *out + ) +{ + unsigned char *inptr; + + inptr = (unsigned char*)in + 3; + *out++ = *inptr--; + *out++ = *inptr--; + *out++ = *inptr--; + *out = *inptr; +} + +static void +bPutDouble( + double *in, + unsigned char *out + ) +{ + unsigned char *inptr; + + inptr = (unsigned char*)in + 7; + *out++ = *inptr--; + *out++ = *inptr--; + *out++ = *inptr--; + *out++ = *inptr--; + *out++ = *inptr--; + *out++ = *inptr--; + *out++ = *inptr--; + *out = *inptr; +} + +#else /* not BYTESWAP */ + +void bPutShort (short a, unsigned char *cmdbuf) {*(short*) cmdbuf = a;} +void bPutULong (long a, unsigned char *cmdbuf) {*(long*) cmdbuf = a;} +void bPutFloat (float a, unsigned char *cmdbuf) {*(float*) cmdbuf = a;} +void bPutDouble (double a, unsigned char *cmdbuf){*(double*) cmdbuf = a;} + +#endif /* BYTESWAP */ + +/* + * Parse primary utc time packet + * and fill refclock structure + * from results. + * + * 0 = success + * -1 = errors + */ + +static int +parse0x8FAD( + TSIPPKT *rpt, + struct peer *peer + ) +{ + register struct refclockproc *pp; + register struct ripencc_unit *up; + + unsigned day, month, year; /* data derived from received timecode */ + unsigned hour, minute, second; + unsigned char trackstat, utcflags; + + static char logbuf[1024]; /* logging string buffer */ + int i; + unsigned char *buf; + + buf = rpt->buf; + pp = peer->procptr; + + if (rpt->len != 22) + return (-1); + + if (bGetShort(&buf[1]) != 0) { +#ifdef DEBUG_NCC + if (debug) + printf("parse0x8FAD: event count != 0\n"); +#endif /* DEBUG_NCC */ + return(-1); + } + + if (bGetDouble(&buf[3]) != 0.0) { +#ifdef DEBUG_NCC + if (debug) + printf("parse0x8FAD: fracsecs != 0\n"); +#endif /* DEBUG_NCC */ + return(-1); + } + + hour = (unsigned int) buf[11]; + minute = (unsigned int) buf[12]; + second = (unsigned int) buf[13]; + day = (unsigned int) buf[14]; + month = (unsigned int) buf[15]; + year = bGetShort(&buf[16]); + trackstat = buf[18]; + utcflags = buf[19]; + + + sprintf(logbuf, "U1 %d.%d.%d %02d:%02d:%02d %d %02x", + day, month, year, hour, minute, second, trackstat, utcflags); + +#ifdef DEBUG_NCC + if (debug) + puts(logbuf); +#endif /* DEBUG_NCC */ + + record_clock_stats(&peer->srcadr, logbuf); + + if (!utcflags & UTCF_UTC_AVAIL) + return(-1); + + /* poll for UTC parameters once and then if UTC flag changed */ + up = (struct ripencc_unit *) pp->unitptr; + if (utcflags != up->utcflags) { + TSIPPKT spt; /* local structure for send packet */ + cmd_0x2F (&spt); /* request UTC params */ + ripencc_send(peer,spt); + up->utcflags = utcflags; + } + + /* + * If we hit the leap second, we choose to skip this sample + * rather than rely on other code to be perfectly correct. + * No offense, just defense ;-). + */ + if (second == 60) + return(-1); + + /* now check and convert the time we received */ + + pp->year = year; + if (month < 1 || month > 12 || day < 1 || day > 31) + return(-1); + + if (pp->year % 4) { /* XXX: use is_leapyear() ? */ + if (day > day1tab[month - 1]) + return(-1); + for (i = 0; i < month - 1; i++) + day += day1tab[i]; + } else { + if (day > day2tab[month - 1]) + return(-1); + for (i = 0; i < month - 1; i++) + day += day2tab[i]; + } + pp->day = day; + pp->hour = hour; + pp->minute = minute; + pp-> second = second; + pp->nsec = 0; + + if ((utcflags&UTCF_LEAP_PNDG) && up->leapdelta != 0) + pp-> leap = (up->leapdelta > 0) + ? LEAP_ADDSECOND + : LEAP_DELSECOND; + else + pp-> leap = LEAP_NOWARNING; + + return (0); +} + +/* + * Parse comprehensive time packet + * + * 0 = success + * -1 = errors + */ + +int +parse0x8F0B( + TSIPPKT *rpt, + struct peer *peer + ) +{ + register struct refclockproc *pp; + + unsigned day, month, year; /* data derived from received timecode */ + unsigned hour, minute, second; + unsigned utcoff; + unsigned char mode; + double bias, rate; + float biasunc, rateunc; + double lat, lon, alt; + short lat_deg, lon_deg; + float lat_min, lon_min; + unsigned char north_south, east_west; + char sv[9]; + + static char logbuf[1024]; /* logging string buffer */ + unsigned char b; + int i; + unsigned char *buf; + double tow; + + buf = rpt->buf; + pp = peer->procptr; + + if (rpt->len != 74) + return (-1); + + if (bGetShort(&buf[1]) != 0) + return(-1);; + + tow = bGetDouble(&buf[3]); + + if (tow == -1.0) { + return(-1); + } + else if ((tow >= 604800.0) || (tow < 0.0)) { + return(-1); + } + else + { + if (tow < 604799.9) tow = tow + .00000001; + second = (unsigned int) fmod(tow, 60.); + minute = (unsigned int) fmod(tow/60., 60.); + hour = (unsigned int )fmod(tow / 3600., 24.); + } + + day = (unsigned int) buf[11]; + month = (unsigned int) buf[12]; + year = bGetShort(&buf[13]); + mode = buf[15]; + utcoff = bGetShort(&buf[16]); + bias = bGetDouble(&buf[18]) / GPS_C * 1e9; /* ns */ + rate = bGetDouble(&buf[26]) / GPS_C * 1e9; /* ppb */ + biasunc = bGetSingle(&buf[34]) / GPS_C * 1e9; /* ns */ + rateunc = bGetSingle(&buf[38]) / GPS_C * 1e9; /* ppb */ + lat = bGetDouble(&buf[42]) * R2D; + lon = bGetDouble(&buf[50]) * R2D; + alt = bGetDouble(&buf[58]); + + if (lat < 0.0) { + north_south = 'S'; + lat = -lat; + } + else { + north_south = 'N'; + } + lat_deg = (short)lat; + lat_min = (lat - lat_deg) * 60.0; + + if (lon < 0.0) { + east_west = 'W'; + lon = -lon; + } + else { + east_west = 'E'; + } + + lon_deg = (short)lon; + lon_min = (lon - lon_deg) * 60.0; + + for (i=0; i<8; i++) { + sv[i] = buf[i + 66]; + if (sv[i]) { + TSIPPKT spt; /* local structure for sendpacket */ + b = (unsigned char) (sv[i]<0 ? -sv[i] : sv[i]); + /* request tracking status */ + cmd_0x3C (&spt, b); + ripencc_send(peer,spt); + } + } + + + 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", + day, month, year, hour, minute, second, mode, bias, biasunc, + rate, rateunc, utcoff, lat_deg, lat_min, north_south, lon_deg, + lon_min, east_west, alt, sv[0], sv[1], sv[2], sv[3], sv[4], + sv[5], sv[6], sv[7]); + +#ifdef DEBUG_NCC + if (debug) + puts(logbuf); +#endif /* DEBUG_NCC */ + + record_clock_stats(&peer->srcadr, logbuf); + + return (0); +} + +#ifdef TRIMBLE_OUTPUT_FUNC +/* + * Parse any packet using Trimble machinery + */ +int +parseany( + TSIPPKT *rpt, + struct peer *peer + ) +{ + static char logbuf[1024]; /* logging string buffer */ + + TranslateTSIPReportToText (rpt, logbuf); /* anything else */ +#ifdef DEBUG_NCC + if (debug) + puts(&logbuf[1]); +#endif /* DEBUG_NCC */ + record_clock_stats(&peer->srcadr, &logbuf[1]); + return(0); +} +#endif /* TRIMBLE_OUTPUT_FUNC */ + + +/* + * Parse UTC Parameter Packet + * + * See the IDE for documentation! + * + * 0 = success + * -1 = errors + */ + +int +parse0x4F( + TSIPPKT *rpt, + struct peer *peer + ) +{ + register struct ripencc_unit *up; + + double a0; + float a1, tot; + int dt_ls, wn_t, wn_lsf, dn, dt_lsf; + + static char logbuf[1024]; /* logging string buffer */ + unsigned char *buf; + + buf = rpt->buf; + + if (rpt->len != 26) + return (-1); + a0 = bGetDouble (buf); + a1 = bGetSingle (&buf[8]); + dt_ls = bGetShort (&buf[12]); + tot = bGetSingle (&buf[14]); + wn_t = bGetShort (&buf[18]); + wn_lsf = bGetShort (&buf[20]); + dn = bGetShort (&buf[22]); + dt_lsf = bGetShort (&buf[24]); + + sprintf(logbuf, "L1 %d %d %d %g %g %g %d %d %d", + dt_lsf - dt_ls, dt_ls, dt_lsf, a0, a1, tot, wn_t, wn_lsf, dn); + +#ifdef DEBUG_NCC + if (debug) + puts(logbuf); +#endif /* DEBUG_NCC */ + + record_clock_stats(&peer->srcadr, logbuf); + + up = (struct ripencc_unit *) peer->procptr->unitptr; + up->leapdelta = dt_lsf - dt_ls; + + return (0); +} + +/* + * Parse Tracking Status packet + * + * 0 = success + * -1 = errors + */ + +int +parse0x5C( + TSIPPKT *rpt, + struct peer *peer + ) +{ + unsigned char prn, channel, aqflag, ephstat; + float snr, azinuth, elevation; + + static char logbuf[1024]; /* logging string buffer */ + unsigned char *buf; + + buf = rpt->buf; + + if (rpt->len != 24) + return(-1); + + prn = buf[0]; + channel = (unsigned char)(buf[1] >> 3); + if (channel == 0x10) + channel = 2; + else + channel++; + aqflag = buf[2]; + ephstat = buf[3]; + snr = bGetSingle(&buf[4]); + elevation = bGetSingle(&buf[12]) * R2D; + azinuth = bGetSingle(&buf[16]) * R2D; + + sprintf(logbuf, "S1 %02d %d %d %02x %4.1f %5.1f %4.1f", + prn, channel, aqflag, ephstat, snr, azinuth, elevation); + +#ifdef DEBUG_NCC + if (debug) + puts(logbuf); +#endif /* DEBUG_NCC */ + + record_clock_stats(&peer->srcadr, logbuf); + + return (0); +} + +/******* Code below is from Trimble Tsipchat *************/ + +/* + * ************************************************************************* + * + * Trimble Navigation, Ltd. + * OEM Products Development Group + * P.O. Box 3642 + * 645 North Mary Avenue + * Sunnyvale, California 94088-3642 + * + * Corporate Headquarter: + * Telephone: (408) 481-8000 + * Fax: (408) 481-6005 + * + * Technical Support Center: + * Telephone: (800) 767-4822 (U.S. and Canada) + * (408) 481-6940 (outside U.S. and Canada) + * Fax: (408) 481-6020 + * BBS: (408) 481-7800 + * e-mail: trimble_support@trimble.com + * ftp://ftp.trimble.com/pub/sct/embedded/bin + * + * ************************************************************************* + * + * ------- BYTE-SWAPPING ------- + * TSIP is big-endian (Motorola) protocol. To use on little-endian (Intel) + * systems, the bytes of all multi-byte types (shorts, floats, doubles, etc.) + * must be reversed. This is controlled by the MACRO BYTESWAP; if defined, it + * assumes little-endian protocol. + * -------------------------------- + * + * T_PARSER.C and T_PARSER.H contains primitive functions that interpret + * reports received from the receiver. A second source file pair, + * T_FORMAT.C and T_FORMAT.H, contin the matching TSIP command formatters. + * + * The module is in very portable, basic C language. It can be used as is, or + * with minimal changes if a TSIP communications application is needed separate + * from TSIPCHAT. The construction of most argument lists avoid the use of + * structures, but the developer is encouraged to reconstruct them using such + * definitions to meet project requirements. Declarations of T_PARSER.C + * functions are included in T_PARSER.H to provide prototyping definitions. + * + * There are two types of functions: a serial input processing routine, + * tsip_input_proc() + * which assembles incoming bytes into a TSIPPKT structure, and the + * report parsers, rpt_0x??(). + * + * 1) The function tsip_input_proc() accumulates bytes from the receiver, + * strips control bytes (DLE), and checks if the report end sequence (DLE ETX) + * has been received. rpt.status is defined as TSIP_PARSED_FULL (== 1) + * if a complete packet is available. + * + * 2) The functions rpt_0x??() are report string interpreters patterned after + * the document called "Trimble Standard Interface Protocol". It should be + * noted that if the report buffer is sent into the receiver with the wrong + * length (byte count), the rpt_0x??() returns the Boolean equivalence for + * TRUE. + * + * ************************************************************************* + * + */ + + +/* + * reads bytes until serial buffer is empty or a complete report + * has been received; end of report is signified by DLE ETX. + */ +static void +tsip_input_proc( + TSIPPKT *rpt, + int inbyte + ) +{ + unsigned char newbyte; + + if (inbyte < 0 || inbyte > 0xFF) return; + + newbyte = (unsigned char)(inbyte); + switch (rpt->status) + { + case TSIP_PARSED_DLE_1: + switch (newbyte) + { + case 0: + case ETX: + /* illegal TSIP IDs */ + rpt->len = 0; + rpt->status = TSIP_PARSED_EMPTY; + break; + case DLE: + /* try normal message start again */ + rpt->len = 0; + rpt->status = TSIP_PARSED_DLE_1; + break; + default: + /* legal TSIP ID; start message */ + rpt->code = newbyte; + rpt->len = 0; + rpt->status = TSIP_PARSED_DATA; + break; + } + break; + case TSIP_PARSED_DATA: + switch (newbyte) { + case DLE: + /* expect DLE or ETX next */ + rpt->status = TSIP_PARSED_DLE_2; + break; + default: + /* normal data byte */ + rpt->buf[rpt->len] = newbyte; + rpt->len++; + /* no change in rpt->status */ + break; + } + break; + case TSIP_PARSED_DLE_2: + switch (newbyte) { + case DLE: + /* normal data byte */ + rpt->buf[rpt->len] = newbyte; + rpt->len++; + rpt->status = TSIP_PARSED_DATA; + break; + case ETX: + /* end of message; return TRUE here. */ + rpt->status = TSIP_PARSED_FULL; + break; + default: + /* error: treat as TSIP_PARSED_DLE_1; start new report packet */ + rpt->code = newbyte; + rpt->len = 0; + rpt->status = TSIP_PARSED_DATA; + } + break; + case TSIP_PARSED_FULL: + case TSIP_PARSED_EMPTY: + default: + switch (newbyte) { + case DLE: + /* normal message start */ + rpt->len = 0; + rpt->status = TSIP_PARSED_DLE_1; + break; + default: + /* error: ignore newbyte */ + rpt->len = 0; + rpt->status = TSIP_PARSED_EMPTY; + } + break; + } + if (rpt->len > MAX_RPTBUF) { + /* error: start new report packet */ + rpt->status = TSIP_PARSED_EMPTY; + rpt->len = 0; + } +} + +#ifdef TRIMBLE_OUTPUT_FUNC + +/**/ +/* Channel A configuration for dual port operation */ +short +rpt_0x3D( + TSIPPKT *rpt, + unsigned char *tx_baud_index, + unsigned char *rx_baud_index, + unsigned char *char_format_index, + unsigned char *stop_bits, + unsigned char *tx_mode_index, + unsigned char *rx_mode_index + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 6) return TRUE; + *tx_baud_index = buf[0]; + *rx_baud_index = buf[1]; + *char_format_index = buf[2]; + *stop_bits = (unsigned char)((buf[3] == 0x07) ? 1 : 2); + *tx_mode_index = buf[4]; + *rx_mode_index = buf[5]; + return FALSE; +} + +/**/ +/* almanac data for specified satellite */ +short +rpt_0x40( + TSIPPKT *rpt, + unsigned char *sv_prn, + short *week_num, + float *t_zc, + float *eccentricity, + float *t_oa, + float *i_0, + float *OMEGA_dot, + float *sqrt_A, + float *OMEGA_0, + float *omega, + float *M_0 + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 39) return TRUE; + *sv_prn = buf[0]; + *t_zc = bGetSingle (&buf[1]); + *week_num = bGetShort (&buf[5]); + *eccentricity = bGetSingle (&buf[7]); + *t_oa = bGetSingle (&buf[11]); + *i_0 = bGetSingle (&buf[15]); + *OMEGA_dot = bGetSingle (&buf[19]); + *sqrt_A = bGetSingle (&buf[23]); + *OMEGA_0 = bGetSingle (&buf[27]); + *omega = bGetSingle (&buf[31]); + *M_0 = bGetSingle (&buf[35]); + return FALSE; +} + +/* GPS time */ +short +rpt_0x41( + TSIPPKT *rpt, + float *time_of_week, + float *UTC_offset, + short *week_num + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 10) return TRUE; + *time_of_week = bGetSingle (buf); + *week_num = bGetShort (&buf[4]); + *UTC_offset = bGetSingle (&buf[6]); + return FALSE; +} + +/* position in ECEF, single precision */ +short +rpt_0x42( + TSIPPKT *rpt, + float pos_ECEF[3], + float *time_of_fix + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 16) return TRUE; + pos_ECEF[0] = bGetSingle (buf); + pos_ECEF[1]= bGetSingle (&buf[4]); + pos_ECEF[2]= bGetSingle (&buf[8]); + *time_of_fix = bGetSingle (&buf[12]); + return FALSE; +} + +/* velocity in ECEF, single precision */ +short +rpt_0x43( + TSIPPKT *rpt, + float ECEF_vel[3], + float *freq_offset, + float *time_of_fix + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 20) return TRUE; + ECEF_vel[0] = bGetSingle (buf); + ECEF_vel[1] = bGetSingle (&buf[4]); + ECEF_vel[2] = bGetSingle (&buf[8]); + *freq_offset = bGetSingle (&buf[12]); + *time_of_fix = bGetSingle (&buf[16]); + return FALSE; +} + +/* software versions */ +short +rpt_0x45( + TSIPPKT *rpt, + unsigned char *major_nav_version, + unsigned char *minor_nav_version, + unsigned char *nav_day, + unsigned char *nav_month, + unsigned char *nav_year, + unsigned char *major_dsp_version, + unsigned char *minor_dsp_version, + unsigned char *dsp_day, + unsigned char *dsp_month, + unsigned char *dsp_year + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 10) return TRUE; + *major_nav_version = buf[0]; + *minor_nav_version = buf[1]; + *nav_day = buf[2]; + *nav_month = buf[3]; + *nav_year = buf[4]; + *major_dsp_version = buf[5]; + *minor_dsp_version = buf[6]; + *dsp_day = buf[7]; + *dsp_month = buf[8]; + *dsp_year = buf[9]; + return FALSE; +} + +/* receiver health and status */ +short +rpt_0x46( + TSIPPKT *rpt, + unsigned char *status1, + unsigned char *status2 + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 2) return TRUE; + *status1 = buf[0]; + *status2 = buf[1]; + return FALSE; +} + +/* signal levels for all satellites tracked */ +short +rpt_0x47( + TSIPPKT *rpt, + unsigned char *nsvs, + unsigned char *sv_prn, + float *snr + ) +{ + short isv; + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 1 + 5*buf[0]) return TRUE; + *nsvs = buf[0]; + for (isv = 0; isv < (*nsvs); isv++) { + sv_prn[isv] = buf[5*isv + 1]; + snr[isv] = bGetSingle (&buf[5*isv + 2]); + } + return FALSE; +} + +/* GPS system message */ +short +rpt_0x48( + TSIPPKT *rpt, + unsigned char *message + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 22) return TRUE; + memcpy (message, buf, 22); + message[22] = 0; + return FALSE; +} + +/* health for all satellites from almanac health page */ +short +rpt_0x49( + TSIPPKT *rpt, + unsigned char *sv_health + ) +{ + short i; + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 32) return TRUE; + for (i = 0; i < 32; i++) sv_health [i]= buf[i]; + return FALSE; +} + +/* position in lat-lon-alt, single precision */ +short +rpt_0x4A( + TSIPPKT *rpt, + float *lat, + float *lon, + float *alt, + float *clock_bias, + float *time_of_fix + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 20) return TRUE; + *lat = bGetSingle (buf); + *lon = bGetSingle (&buf[4]); + *alt = bGetSingle (&buf[8]); + *clock_bias = bGetSingle (&buf[12]); + *time_of_fix = bGetSingle (&buf[16]); + return FALSE; +} + +/* reference altitude parameters */ +short +rpt_0x4A_2( + TSIPPKT *rpt, + float *alt, + float *dummy, + unsigned char *alt_flag + ) +{ + unsigned char *buf; + + buf = rpt->buf; + + if (rpt->len != 9) return TRUE; + *alt = bGetSingle (buf); + *dummy = bGetSingle (&buf[4]); + *alt_flag = buf[8]; + return FALSE; +} + +/* machine ID code, status */ +short +rpt_0x4B( + TSIPPKT *rpt, + unsigned char *machine_id, + unsigned char *status3, + unsigned char *status4 + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 3) return TRUE; + *machine_id = buf[0]; + *status3 = buf[1]; + *status4 = buf[2]; + return FALSE; +} + +/* operating parameters and masks */ +short +rpt_0x4C( + TSIPPKT *rpt, + unsigned char *dyn_code, + float *el_mask, + float *snr_mask, + float *dop_mask, + float *dop_switch + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 17) return TRUE; + *dyn_code = buf[0]; + *el_mask = bGetSingle (&buf[1]); + *snr_mask = bGetSingle (&buf[5]); + *dop_mask = bGetSingle (&buf[9]); + *dop_switch = bGetSingle (&buf[13]); + return FALSE; +} + +/* oscillator offset */ +short +rpt_0x4D( + TSIPPKT *rpt, + float *osc_offset + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 4) return TRUE; + *osc_offset = bGetSingle (buf); + return FALSE; +} + +/* yes/no response to command to set GPS time */ +short +rpt_0x4E( + TSIPPKT *rpt, + unsigned char *response + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 1) return TRUE; + *response = buf[0]; + return FALSE; +} + +/* UTC data */ +short +rpt_0x4F( + TSIPPKT *rpt, + double *a0, + float *a1, + float *time_of_data, + short *dt_ls, + short *wn_t, + short *wn_lsf, + short *dn, + short *dt_lsf + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 26) return TRUE; + *a0 = bGetDouble (buf); + *a1 = bGetSingle (&buf[8]); + *dt_ls = bGetShort (&buf[12]); + *time_of_data = bGetSingle (&buf[14]); + *wn_t = bGetShort (&buf[18]); + *wn_lsf = bGetShort (&buf[20]); + *dn = bGetShort (&buf[22]); + *dt_lsf = bGetShort (&buf[24]); + return FALSE; +} + +/**/ +/* clock offset and frequency offset in 1-SV (0-D) mode */ +short +rpt_0x54( + TSIPPKT *rpt, + float *clock_bias, + float *freq_offset, + float *time_of_fix + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 12) return TRUE; + *clock_bias = bGetSingle (buf); + *freq_offset = bGetSingle (&buf[4]); + *time_of_fix = bGetSingle (&buf[8]); + return FALSE; +} + +/* I/O serial options */ +short +rpt_0x55( + TSIPPKT *rpt, + unsigned char *pos_code, + unsigned char *vel_code, + unsigned char *time_code, + unsigned char *aux_code + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 4) return TRUE; + *pos_code = buf[0]; + *vel_code = buf[1]; + *time_code = buf[2]; + *aux_code = buf[3]; + return FALSE; +} + +/* velocity in east-north-up coordinates */ +short +rpt_0x56( + TSIPPKT *rpt, + float vel_ENU[3], + float *freq_offset, + float *time_of_fix + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 20) return TRUE; + /* east */ + vel_ENU[0] = bGetSingle (buf); + /* north */ + vel_ENU[1] = bGetSingle (&buf[4]); + /* up */ + vel_ENU[2] = bGetSingle (&buf[8]); + *freq_offset = bGetSingle (&buf[12]); + *time_of_fix = bGetSingle (&buf[16]); + return FALSE; +} + +/* info about last computed fix */ +short +rpt_0x57( + TSIPPKT *rpt, + unsigned char *source_code, + unsigned char *diag_code, + short *week_num, + float *time_of_fix + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 8) return TRUE; + *source_code = buf[0]; + *diag_code = buf[1]; + *time_of_fix = bGetSingle (&buf[2]); + *week_num = bGetShort (&buf[6]); + return FALSE; +} + +/* GPS system data or acknowledgment of GPS system data load */ +short +rpt_0x58( + TSIPPKT *rpt, + unsigned char *op_code, + unsigned char *data_type, + unsigned char *sv_prn, + unsigned char *data_length, + unsigned char *data_packet + ) +{ + unsigned char *buf, *buf4; + short dl; + ALM_INFO* alminfo; + ION_INFO* ioninfo; + UTC_INFO* utcinfo; + NAV_INFO* navinfo; + + buf = rpt->buf; + + if (buf[0] == 2) { + if (rpt->len < 4) return TRUE; + if (rpt->len != 4+buf[3]) return TRUE; + } + else if (rpt->len != 3) { + return TRUE; + } + *op_code = buf[0]; + *data_type = buf[1]; + *sv_prn = buf[2]; + if (*op_code == 2) { + dl = buf[3]; + *data_length = (unsigned char)dl; + buf4 = &buf[4]; + switch (*data_type) { + case 2: + /* Almanac */ + if (*data_length != sizeof (ALM_INFO)) return TRUE; + alminfo = (ALM_INFO*)data_packet; + alminfo->t_oa_raw = buf4[0]; + alminfo->SV_health = buf4[1]; + alminfo->e = bGetSingle(&buf4[2]); + alminfo->t_oa = bGetSingle(&buf4[6]); + alminfo->i_0 = bGetSingle(&buf4[10]); + alminfo->OMEGADOT = bGetSingle(&buf4[14]); + alminfo->sqrt_A = bGetSingle(&buf4[18]); + alminfo->OMEGA_0 = bGetSingle(&buf4[22]); + alminfo->omega = bGetSingle(&buf4[26]); + alminfo->M_0 = bGetSingle(&buf4[30]); + alminfo->a_f0 = bGetSingle(&buf4[34]); + alminfo->a_f1 = bGetSingle(&buf4[38]); + alminfo->Axis = bGetSingle(&buf4[42]); + alminfo->n = bGetSingle(&buf4[46]); + alminfo->OMEGA_n = bGetSingle(&buf4[50]); + alminfo->ODOT_n = bGetSingle(&buf4[54]); + alminfo->t_zc = bGetSingle(&buf4[58]); + alminfo->weeknum = bGetShort(&buf4[62]); + alminfo->wn_oa = bGetShort(&buf4[64]); + break; + + case 3: + /* Almanac health page */ + if (*data_length != sizeof (ALH_PARMS) + 3) return TRUE; + + /* this record is returned raw */ + memcpy (data_packet, buf4, dl); + break; + + case 4: + /* Ionosphere */ + if (*data_length != sizeof (ION_INFO) + 8) return TRUE; + ioninfo = (ION_INFO*)data_packet; + ioninfo->alpha_0 = bGetSingle (&buf4[8]); + ioninfo->alpha_1 = bGetSingle (&buf4[12]); + ioninfo->alpha_2 = bGetSingle (&buf4[16]); + ioninfo->alpha_3 = bGetSingle (&buf4[20]); + ioninfo->beta_0 = bGetSingle (&buf4[24]); + ioninfo->beta_1 = bGetSingle (&buf4[28]); + ioninfo->beta_2 = bGetSingle (&buf4[32]); + ioninfo->beta_3 = bGetSingle (&buf4[36]); + break; + + case 5: + /* UTC */ + if (*data_length != sizeof (UTC_INFO) + 13) return TRUE; + utcinfo = (UTC_INFO*)data_packet; + utcinfo->A_0 = bGetDouble (&buf4[13]); + utcinfo->A_1 = bGetSingle (&buf4[21]); + utcinfo->delta_t_LS = bGetShort (&buf4[25]); + utcinfo->t_ot = bGetSingle(&buf4[27]); + utcinfo->WN_t = bGetShort (&buf4[31]); + utcinfo->WN_LSF = bGetShort (&buf4[33]); + utcinfo->DN = bGetShort (&buf4[35]); + utcinfo->delta_t_LSF = bGetShort (&buf4[37]); + break; + + case 6: + /* Ephemeris */ + if (*data_length != sizeof (NAV_INFO) - 1) return TRUE; + + navinfo = (NAV_INFO*)data_packet; + + navinfo->sv_number = buf4[0]; + navinfo->t_ephem = bGetSingle (&buf4[1]); + navinfo->ephclk.weeknum = bGetShort (&buf4[5]); + + navinfo->ephclk.codeL2 = buf4[7]; + navinfo->ephclk.L2Pdata = buf4[8]; + navinfo->ephclk.SVacc_raw = buf4[9]; + navinfo->ephclk.SV_health = buf4[10]; + navinfo->ephclk.IODC = bGetShort (&buf4[11]); + navinfo->ephclk.T_GD = bGetSingle (&buf4[13]); + navinfo->ephclk.t_oc = bGetSingle (&buf4[17]); + navinfo->ephclk.a_f2 = bGetSingle (&buf4[21]); + navinfo->ephclk.a_f1 = bGetSingle (&buf4[25]); + navinfo->ephclk.a_f0 = bGetSingle (&buf4[29]); + navinfo->ephclk.SVacc = bGetSingle (&buf4[33]); + + navinfo->ephorb.IODE = buf4[37]; + navinfo->ephorb.fit_interval = buf4[38]; + navinfo->ephorb.C_rs = bGetSingle (&buf4[39]); + navinfo->ephorb.delta_n = bGetSingle (&buf4[43]); + navinfo->ephorb.M_0 = bGetDouble (&buf4[47]); + navinfo->ephorb.C_uc = bGetSingle (&buf4[55]); + navinfo->ephorb.e = bGetDouble (&buf4[59]); + navinfo->ephorb.C_us = bGetSingle (&buf4[67]); + navinfo->ephorb.sqrt_A = bGetDouble (&buf4[71]); + navinfo->ephorb.t_oe = bGetSingle (&buf4[79]); + navinfo->ephorb.C_ic = bGetSingle (&buf4[83]); + navinfo->ephorb.OMEGA_0 = bGetDouble (&buf4[87]); + navinfo->ephorb.C_is = bGetSingle (&buf4[95]); + navinfo->ephorb.i_0 = bGetDouble (&buf4[99]); + navinfo->ephorb.C_rc = bGetSingle (&buf4[107]); + navinfo->ephorb.omega = bGetDouble (&buf4[111]); + navinfo->ephorb.OMEGADOT=bGetSingle (&buf4[119]); + navinfo->ephorb.IDOT = bGetSingle (&buf4[123]); + navinfo->ephorb.Axis = bGetDouble (&buf4[127]); + navinfo->ephorb.n = bGetDouble (&buf4[135]); + navinfo->ephorb.r1me2 = bGetDouble (&buf4[143]); + navinfo->ephorb.OMEGA_n=bGetDouble (&buf4[151]); + navinfo->ephorb.ODOT_n = bGetDouble (&buf4[159]); + break; + } + } + return FALSE; +} + +/* satellite enable/disable or health heed/ignore list */ +short +rpt_0x59( + TSIPPKT *rpt, + unsigned char *code_type, + unsigned char status_code[32] + ) +{ + short iprn; + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 33) return TRUE; + *code_type = buf[0]; + for (iprn = 0; iprn < 32; iprn++) + status_code[iprn] = buf[iprn + 1]; + return FALSE; +} + +/* raw measurement data - code phase/Doppler */ +short +rpt_0x5A( + TSIPPKT *rpt, + unsigned char *sv_prn, + float *sample_length, + float *signal_level, + float *code_phase, + float *Doppler, + double *time_of_fix + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 25) return TRUE; + *sv_prn = buf[0]; + *sample_length = bGetSingle (&buf[1]); + *signal_level = bGetSingle (&buf[5]); + *code_phase = bGetSingle (&buf[9]); + *Doppler = bGetSingle (&buf[13]); + *time_of_fix = bGetDouble (&buf[17]); + return FALSE; +} + +/* satellite ephorb status */ +short +rpt_0x5B( + TSIPPKT *rpt, + unsigned char *sv_prn, + unsigned char *sv_health, + unsigned char *sv_iode, + unsigned char *fit_interval_flag, + float *time_of_collection, + float *time_of_eph, + float *sv_accy + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 16) return TRUE; + *sv_prn = buf[0]; + *time_of_collection = bGetSingle (&buf[1]); + *sv_health = buf[5]; + *sv_iode = buf[6]; + *time_of_eph = bGetSingle (&buf[7]); + *fit_interval_flag = buf[11]; + *sv_accy = bGetSingle (&buf[12]); + return FALSE; +} + +/* satellite tracking status */ +short +rpt_0x5C( + TSIPPKT *rpt, + unsigned char *sv_prn, + unsigned char *slot, + unsigned char *chan, + unsigned char *acq_flag, + unsigned char *eph_flag, + float *signal_level, + float *time_of_last_msmt, + float *elev, + float *azim, + unsigned char *old_msmt_flag, + unsigned char *integer_msec_flag, + unsigned char *bad_data_flag, + unsigned char *data_collect_flag + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 24) return TRUE; + *sv_prn = buf[0]; + *slot = (unsigned char)((buf[1] & 0x07) + 1); + *chan = (unsigned char)(buf[1] >> 3); + if (*chan == 0x10) *chan = 2; + else (*chan)++; + *acq_flag = buf[2]; + *eph_flag = buf[3]; + *signal_level = bGetSingle (&buf[4]); + *time_of_last_msmt = bGetSingle (&buf[8]); + *elev = bGetSingle (&buf[12]); + *azim = bGetSingle (&buf[16]); + *old_msmt_flag = buf[20]; + *integer_msec_flag = buf[21]; + *bad_data_flag = buf[22]; + *data_collect_flag = buf[23]; + return FALSE; +} + +/**/ +/* over-determined satellite selection for position fixes, PDOP, fix mode */ +short +rpt_0x6D( + TSIPPKT *rpt, + unsigned char *manual_mode, + unsigned char *nsvs, + unsigned char *ndim, + unsigned char sv_prn[], + float *pdop, + float *hdop, + float *vdop, + float *tdop + ) +{ + short islot; + unsigned char *buf; + buf = rpt->buf; + + *nsvs = (unsigned char)((buf[0] & 0xF0) >> 4); + if ((*nsvs)>8) return TRUE; + if (rpt->len != 17 + (*nsvs) ) return TRUE; + + *manual_mode = (unsigned char)(buf[0] & 0x08); + *ndim = (unsigned char)((buf[0] & 0x07)); + *pdop = bGetSingle (&buf[1]); + *hdop = bGetSingle (&buf[5]); + *vdop = bGetSingle (&buf[9]); + *tdop = bGetSingle (&buf[13]); + for (islot = 0; islot < (*nsvs); islot++) + sv_prn[islot] = buf[islot + 17]; + return FALSE; +} + +/**/ +/* differential fix mode */ +short +rpt_0x82( + TSIPPKT *rpt, + unsigned char *diff_mode + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 1) return TRUE; + *diff_mode = buf[0]; + return FALSE; +} + +/* position, ECEF double precision */ +short +rpt_0x83( + TSIPPKT *rpt, + double ECEF_pos[3], + double *clock_bias, + float *time_of_fix + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 36) return TRUE; + ECEF_pos[0] = bGetDouble (buf); + ECEF_pos[1] = bGetDouble (&buf[8]); + ECEF_pos[2] = bGetDouble (&buf[16]); + *clock_bias = bGetDouble (&buf[24]); + *time_of_fix = bGetSingle (&buf[32]); + return FALSE; +} + +/* position, lat-lon-alt double precision */ +short +rpt_0x84( + TSIPPKT *rpt, + double *lat, + double *lon, + double *alt, + double *clock_bias, + float *time_of_fix + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 36) return TRUE; + *lat = bGetDouble (buf); + *lon = bGetDouble (&buf[8]); + *alt = bGetDouble (&buf[16]); + *clock_bias = bGetDouble (&buf[24]); + *time_of_fix = bGetSingle (&buf[32]); + return FALSE; +} + +short +rpt_Paly0xBB( + TSIPPKT *rpt, + TSIP_RCVR_CFG *TsipxBB + ) +{ + unsigned char *buf; + buf = rpt->buf; + + /* Palisade is inconsistent with other TSIP, which has a length of 40 */ + /* if (rpt->len != 40) return TRUE; */ + if (rpt->len != 43) return TRUE; + + TsipxBB->bSubcode = buf[0]; + TsipxBB->operating_mode = buf[1]; + TsipxBB->dyn_code = buf[3]; + TsipxBB->elev_mask = bGetSingle (&buf[5]); + TsipxBB->cno_mask = bGetSingle (&buf[9]); + TsipxBB->dop_mask = bGetSingle (&buf[13]); + TsipxBB->dop_switch = bGetSingle (&buf[17]); + return FALSE; +} + +/* Receiver serial port configuration */ +short +rpt_0xBC( + TSIPPKT *rpt, + unsigned char *port_num, + unsigned char *in_baud, + unsigned char *out_baud, + unsigned char *data_bits, + unsigned char *parity, + unsigned char *stop_bits, + unsigned char *flow_control, + unsigned char *protocols_in, + unsigned char *protocols_out, + unsigned char *reserved + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 10) return TRUE; + *port_num = buf[0]; + *in_baud = buf[1]; + *out_baud = buf[2]; + *data_bits = buf[3]; + *parity = buf[4]; + *stop_bits = buf[5]; + *flow_control = buf[6]; + *protocols_in = buf[7]; + *protocols_out = buf[8]; + *reserved = buf[9]; + + return FALSE; +} + +/**** Superpackets ****/ + +short +rpt_0x8F0B( + TSIPPKT *rpt, + unsigned short *event, + double *tow, + unsigned char *date, + unsigned char *month, + short *year, + unsigned char *dim_mode, + short *utc_offset, + double *bias, + double *drift, + float *bias_unc, + float *dr_unc, + double *lat, + double *lon, + double *alt, + char sv_id[8] + ) +{ + short local_index; + unsigned char *buf; + + buf = rpt->buf; + if (rpt->len != 74) return TRUE; + *event = bGetShort(&buf[1]); + *tow = bGetDouble(&buf[3]); + *date = buf[11]; + *month = buf[12]; + *year = bGetShort(&buf[13]); + *dim_mode = buf[15]; + *utc_offset = bGetShort(&buf[16]); + *bias = bGetDouble(&buf[18]); + *drift = bGetDouble(&buf[26]); + *bias_unc = bGetSingle(&buf[34]); + *dr_unc = bGetSingle(&buf[38]); + *lat = bGetDouble(&buf[42]); + *lon = bGetDouble(&buf[50]); + *alt = bGetDouble(&buf[58]); + + for (local_index=0; local_index<8; local_index++) sv_id[local_index] = buf[local_index + 66]; + return FALSE; +} + +/* datum index and coefficients */ +short +rpt_0x8F14( + TSIPPKT *rpt, + short *datum_idx, + double datum_coeffs[5] + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 43) return TRUE; + *datum_idx = bGetShort(&buf[1]); + datum_coeffs[0] = bGetDouble (&buf[3]); + datum_coeffs[1] = bGetDouble (&buf[11]); + datum_coeffs[2] = bGetDouble (&buf[19]); + datum_coeffs[3] = bGetDouble (&buf[27]); + datum_coeffs[4] = bGetDouble (&buf[35]); + return FALSE; +} + + +/* datum index and coefficients */ +short +rpt_0x8F15( + TSIPPKT *rpt, + short *datum_idx, + double datum_coeffs[5] + ) +{ + unsigned char *buf; + buf = rpt->buf; + + if (rpt->len != 43) return TRUE; + *datum_idx = bGetShort(&buf[1]); + datum_coeffs[0] = bGetDouble (&buf[3]); + datum_coeffs[1] = bGetDouble (&buf[11]); + datum_coeffs[2] = bGetDouble (&buf[19]); + datum_coeffs[3] = bGetDouble (&buf[27]); + datum_coeffs[4] = bGetDouble (&buf[35]); + return FALSE; +} + + +#define MAX_LONG (2147483648.) /* 2**31 */ + +short +rpt_0x8F20( + TSIPPKT *rpt, + unsigned char *info, + double *lat, + double *lon, + double *alt, + double vel_enu[], + double *time_of_fix, + short *week_num, + unsigned char *nsvs, + unsigned char sv_prn[], + short sv_IODC[], + short *datum_index + ) +{ + short + isv; + unsigned char + *buf, prnx, iode; + unsigned long + ulongtemp; + long + longtemp; + double + vel_scale; + + buf = rpt->buf; + + if (rpt->len != 56) return TRUE; + + vel_scale = (buf[24]&1)? 0.020 : 0.005; + vel_enu[0] = bGetShort (buf+2)*vel_scale; + vel_enu[1] = bGetShort (buf+4)*vel_scale; + vel_enu[2] = bGetShort (buf+6)*vel_scale; + + *time_of_fix = bGetULong (buf+8)*.001; + + longtemp = bGetLong (buf+12); + *lat = longtemp*(GPS_PI/MAX_LONG); + + ulongtemp = bGetULong (buf+16); + *lon = ulongtemp*(GPS_PI/MAX_LONG); + if (*lon > GPS_PI) *lon -= 2.0*GPS_PI; + + *alt = bGetLong (buf+20)*.001; + /* 25 blank; 29 = UTC */ + (*datum_index) = (short)((short)buf[26]-1); + *info = buf[27]; + *nsvs = buf[28]; + *week_num = bGetShort (&buf[30]); + for (isv = 0; isv < 8; isv++) { + prnx = buf[32+2*isv]; + sv_prn[isv] = (unsigned char)(prnx&0x3F); + iode = buf[33+2*isv]; + sv_IODC[isv] = (short)(iode | ((prnx>>6)<<8)); + } + return FALSE; +} + +short +rpt_0x8F41( + TSIPPKT *rpt, + unsigned char *bSearchRange, + unsigned char *bBoardOptions, + unsigned long *iiSerialNumber, + unsigned char *bBuildYear, + unsigned char *bBuildMonth, + unsigned char *bBuildDay, + unsigned char *bBuildHour, + float *fOscOffset, + unsigned short *iTestCodeId + ) +{ + if (rpt->len != 17) return FALSE; + *bSearchRange = rpt->buf[1]; + *bBoardOptions = rpt->buf[2]; + *iiSerialNumber = bGetLong(&rpt->buf[3]); + *bBuildYear = rpt->buf[7]; + *bBuildMonth = rpt->buf[8]; + *bBuildDay = rpt->buf[9]; + *bBuildHour = rpt->buf[10]; + *fOscOffset = bGetSingle(&rpt->buf[11]); + *iTestCodeId = bGetShort(&rpt->buf[15]); +/* Tsipx8E41Data = *Tsipx8E41; */ + return TRUE; +} + +short +rpt_0x8F42( + TSIPPKT *rpt, + unsigned char *bProdOptionsPre, + unsigned char *bProdNumberExt, + unsigned short *iCaseSerialNumberPre, + unsigned long *iiCaseSerialNumber, + unsigned long *iiProdNumber, + unsigned short *iPremiumOptions, + unsigned short *iMachineID, + unsigned short *iKey + ) +{ + if (rpt->len != 19) return FALSE; + *bProdOptionsPre = rpt->buf[1]; + *bProdNumberExt = rpt->buf[2]; + *iCaseSerialNumberPre = bGetShort(&rpt->buf[3]); + *iiCaseSerialNumber = bGetLong(&rpt->buf[5]); + *iiProdNumber = bGetLong(&rpt->buf[9]); + *iPremiumOptions = bGetShort(&rpt->buf[13]); + *iMachineID = bGetShort(&rpt->buf[15]); + *iKey = bGetShort(&rpt->buf[17]); + return TRUE; +} + +short +rpt_0x8F45( + TSIPPKT *rpt, + unsigned char *bSegMask + ) +{ + if (rpt->len != 2) return FALSE; + *bSegMask = rpt->buf[1]; + return TRUE; +} + +/* Stinger PPS definition */ +short +rpt_0x8F4A_16( + TSIPPKT *rpt, + unsigned char *pps_enabled, + unsigned char *pps_timebase, + unsigned char *pos_polarity, + double *pps_offset, + float *bias_unc_threshold + ) +{ + unsigned char + *buf; + + buf = rpt->buf; + if (rpt->len != 16) return TRUE; + *pps_enabled = buf[1]; + *pps_timebase = buf[2]; + *pos_polarity = buf[3]; + *pps_offset = bGetDouble(&buf[4]); + *bias_unc_threshold = bGetSingle(&buf[12]); + return FALSE; +} + +short +rpt_0x8F4B( + TSIPPKT *rpt, + unsigned long *decorr_max + ) +{ + unsigned char + *buf; + + buf = rpt->buf; + if (rpt->len != 5) return TRUE; + *decorr_max = bGetLong(&buf[1]); + return FALSE; +} + +short +rpt_0x8F4D( + TSIPPKT *rpt, + unsigned long *event_mask + ) +{ + unsigned char + *buf; + + buf = rpt->buf; + if (rpt->len != 5) return TRUE; + *event_mask = bGetULong (&buf[1]); + return FALSE; +} + +short +rpt_0x8FA5( + TSIPPKT *rpt, + unsigned char *spktmask + ) +{ + unsigned char + *buf; + + buf = rpt->buf; + if (rpt->len != 5) return TRUE; + spktmask[0] = buf[1]; + spktmask[1] = buf[2]; + spktmask[2] = buf[3]; + spktmask[3] = buf[4]; + return FALSE; +} + +short +rpt_0x8FAD( + TSIPPKT *rpt, + unsigned short *COUNT, + double *FracSec, + unsigned char *Hour, + unsigned char *Minute, + unsigned char *Second, + unsigned char *Day, + unsigned char *Month, + unsigned short *Year, + unsigned char *Status, + unsigned char *Flags + ) +{ + if (rpt->len != 22) return TRUE; + + *COUNT = bGetUShort(&rpt->buf[1]); + *FracSec = bGetDouble(&rpt->buf[3]); + *Hour = rpt->buf[11]; + *Minute = rpt->buf[12]; + *Second = rpt->buf[13]; + *Day = rpt->buf[14]; + *Month = rpt->buf[15]; + *Year = bGetUShort(&rpt->buf[16]); + *Status = rpt->buf[18]; + *Flags = rpt->buf[19]; + return FALSE; +} + + +/* + * ************************************************************************* + * + * Trimble Navigation, Ltd. + * OEM Products Development Group + * P.O. Box 3642 + * 645 North Mary Avenue + * Sunnyvale, California 94088-3642 + * + * Corporate Headquarter: + * Telephone: (408) 481-8000 + * Fax: (408) 481-6005 + * + * Technical Support Center: + * Telephone: (800) 767-4822 (U.S. and Canada) + * (408) 481-6940 (outside U.S. and Canada) + * Fax: (408) 481-6020 + * BBS: (408) 481-7800 + * e-mail: trimble_support@trimble.com + * ftp://ftp.trimble.com/pub/sct/embedded/bin + * + * ************************************************************************* + * + * T_REPORT.C consists of a primary function TranslateTSIPReportToText() + * called by main(). + * + * This function takes a character buffer that has been received as a report + * from a TSIP device and interprets it. The character buffer has been + * assembled using tsip_input_proc() in T_PARSER.C. + * + * A large case statement directs processing to one of many mid-level + * functions. The mid-level functions specific to the current report + * code passes the report buffer to the appropriate report decoder + * rpt_0x?? () in T_PARSER.C, which converts the byte stream in rpt.buf + * to data values approporaite for use. + * + * ************************************************************************* + * + */ + + +#define GOOD_PARSE 0 +#define BADID_PARSE 1 +#define BADLEN_PARSE 2 +#define BADDATA_PARSE 3 + +#define B_TSIP 0x02 +#define B_NMEA 0x04 + + +/* pbuf is the pointer to the current location of the text output */ +static char +*pbuf; + +/* keep track of whether the message has been successfully parsed */ +static short +parsed; + + +/* convert time of week into day-hour-minute-second and print */ +char * +show_time( + float time_of_week + ) +{ + short days, hours, minutes; + float seconds; + double tow = 0; + static char timestring [80]; + + if (time_of_week == -1.0) + { + sprintf(timestring, " <No time yet> "); + } + else if ((time_of_week >= 604800.0) || (time_of_week < 0.0)) + { + sprintf(timestring, " <Bad time> "); + } + else + { + if (time_of_week < 604799.9) + tow = time_of_week + .00000001; + seconds = (float)fmod(tow, 60.); + minutes = (short) fmod(tow/60., 60.); + hours = (short)fmod(tow / 3600., 24.); + days = (short)(tow / 86400.0); + sprintf(timestring, " %s %02d:%02d:%05.2f ", + dayname[days], hours, minutes, seconds); + } + return timestring; +} + +/**/ +/* 0x3D */ +static void +rpt_chan_A_config( + TSIPPKT *rpt + ) +{ + unsigned char + tx_baud_index, rx_baud_index, + char_format_index, stop_bits, + tx_mode_index, rx_mode_index, + databits, parity; + int + i, nbaud; + + /* unload rptbuf */ + if (rpt_0x3D (rpt, + &tx_baud_index, &rx_baud_index, &char_format_index, + &stop_bits, &tx_mode_index, &rx_mode_index)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nChannel A Configuration"); + + nbaud = sizeof(old_baudnum); + + for (i = 0; i < nbaud; ++i) if (tx_baud_index == old_baudnum[i]) break; + pbuf += sprintf(pbuf, "\n Transmit speed: %s at %s", + old_output_ch[tx_mode_index], st_baud_text_app[i]); + + for (i = 0; i < nbaud; ++i) if (rx_baud_index == old_baudnum[i]) break; + pbuf += sprintf(pbuf, "\n Receive speed: %s at %s", + old_input_ch[rx_mode_index], st_baud_text_app[i]); + + databits = (unsigned char)((char_format_index & 0x03) + 5); + + parity = (unsigned char)(char_format_index >> 2); + if (parity > 4) parity = 2; + + pbuf += sprintf(pbuf, "\n Character format (bits/char, parity, stop bits): %d-%s-%d", + databits, old_parity_text[parity], stop_bits); +} + +/**/ +/* 0x40 */ +static void +rpt_almanac_data_page( + TSIPPKT *rpt + ) +{ + unsigned char + sv_prn; + short + week_num; + float + t_zc, + eccentricity, + t_oa, + i_0, + OMEGA_dot, + sqrt_A, + OMEGA_0, + omega, + M_0; + + /* unload rptbuf */ + if (rpt_0x40 (rpt, + &sv_prn, &week_num, &t_zc, &eccentricity, &t_oa, + &i_0, &OMEGA_dot, &sqrt_A, &OMEGA_0, &omega, &M_0)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nAlmanac for SV %02d", sv_prn); + pbuf += sprintf(pbuf, "\n Captured:%15.0f %s", + t_zc, show_time (t_zc)); + pbuf += sprintf(pbuf, "\n week:%15d", week_num); + pbuf += sprintf(pbuf, "\n Eccentricity:%15g", eccentricity); + pbuf += sprintf(pbuf, "\n T_oa:%15.0f %s", + t_oa, show_time (t_oa)); + pbuf += sprintf(pbuf, "\n i 0:%15g", i_0); + pbuf += sprintf(pbuf, "\n OMEGA dot:%15g", OMEGA_dot); + pbuf += sprintf(pbuf, "\n sqrt A:%15g", sqrt_A); + pbuf += sprintf(pbuf, "\n OMEGA 0:%15g", OMEGA_0); + pbuf += sprintf(pbuf, "\n omega:%15g", omega); + pbuf += sprintf(pbuf, "\n M 0:%15g", M_0); +} + +/* 0x41 */ +static void +rpt_GPS_time( + TSIPPKT *rpt + ) +{ + float + time_of_week, UTC_offset; + short + week_num; + + /* unload rptbuf */ + if (rpt_0x41 (rpt, &time_of_week, &UTC_offset, &week_num)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nGPS time:%s GPS week: %d UTC offset %.1f", + show_time(time_of_week), week_num, UTC_offset); + +} + +/* 0x42 */ +static void +rpt_single_ECEF_position( + TSIPPKT *rpt + ) +{ + float + ECEF_pos[3], time_of_fix; + + /* unload rptbuf */ + if (rpt_0x42 (rpt, ECEF_pos, &time_of_fix)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nSXYZ: %15.0f %15.0f %15.0f %s", + ECEF_pos[0], ECEF_pos[1], ECEF_pos[2], + show_time(time_of_fix)); +} + +/* 0x43 */ +static void +rpt_single_ECEF_velocity( + TSIPPKT *rpt + ) +{ + + float + ECEF_vel[3], freq_offset, time_of_fix; + + /* unload rptbuf */ + if (rpt_0x43 (rpt, ECEF_vel, &freq_offset, &time_of_fix)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nVelECEF: %11.3f %11.3f %11.3f %12.3f%s", + ECEF_vel[0], ECEF_vel[1], ECEF_vel[2], freq_offset, + show_time(time_of_fix)); +} + +/* 0x45 */ +static void +rpt_SW_version( + TSIPPKT *rpt + ) +{ + unsigned char + major_nav_version, minor_nav_version, + nav_day, nav_month, nav_year, + major_dsp_version, minor_dsp_version, + dsp_day, dsp_month, dsp_year; + + /* unload rptbuf */ + if (rpt_0x45 (rpt, + &major_nav_version, &minor_nav_version, + &nav_day, &nav_month, &nav_year, + &major_dsp_version, &minor_dsp_version, + &dsp_day, &dsp_month, &dsp_year)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, + "\nFW Versions: Nav Proc %2d.%02d %2d/%2d/%2d Sig Proc %2d.%02d %2d/%2d/%2d", + major_nav_version, minor_nav_version, nav_day, nav_month, nav_year, + major_dsp_version, minor_dsp_version, dsp_day, dsp_month, dsp_year); +} + +/* 0x46 */ +static void +rpt_rcvr_health( + TSIPPKT *rpt + ) +{ + unsigned char + status1, status2; + const char + *text; + static const char const + *sc_text[] = { + "Doing position fixes", + "Don't have GPS time yet", + "Waiting for almanac collection", + "DOP too high ", + "No satellites available", + "Only 1 satellite available", + "Only 2 satellites available", + "Only 3 satellites available", + "No satellites usable ", + "Only 1 satellite usable", + "Only 2 satellites usable", + "Only 3 satellites usable", + "Chosen satellite unusable"}; + + + /* unload rptbuf */ + if (rpt_0x46 (rpt, &status1, &status2)) + { + parsed = BADLEN_PARSE; + return; + } + + text = (status1 < COUNTOF(sc_text)) + ? sc_text[status1] + : "(out of range)"; + pbuf += sprintf(pbuf, "\nRcvr status1: %s (%02Xh); ", + text, status1); + + pbuf += sprintf(pbuf, "status2: %s, %s (%02Xh)", + (status2 & 0x01)?"No BBRAM":"BBRAM OK", + (status2 & 0x10)?"No Ant":"Ant OK", + status2); +} + +/* 0x47 */ +static void +rpt_SNR_all_SVs( + TSIPPKT *rpt + ) +{ + unsigned char + nsvs, sv_prn[12]; + short + isv; + float + snr[12]; + + /* unload rptbuf */ + if (rpt_0x47 (rpt, &nsvs, sv_prn, snr)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nSNR for satellites: %d", nsvs); + for (isv = 0; isv < nsvs; isv++) + { + pbuf += sprintf(pbuf, "\n SV %02d %6.2f", + sv_prn[isv], snr[isv]); + } +} + +/* 0x48 */ +static void +rpt_GPS_system_message( + TSIPPKT *rpt + ) +{ + unsigned char + message[23]; + + /* unload rptbuf */ + if (rpt_0x48 (rpt, message)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nGPS message: %s", message); +} + +/* 0x49 */ +static void +rpt_almanac_health_page( + TSIPPKT *rpt + ) +{ + short + iprn; + unsigned char + sv_health [32]; + + /* unload rptbuf */ + if (rpt_0x49 (rpt, sv_health)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nAlmanac health page:"); + for (iprn = 0; iprn < 32; iprn++) + { + if (!(iprn%5)) *pbuf++ = '\n'; + pbuf += sprintf(pbuf, " SV%02d %2X", + (iprn+1) , sv_health[iprn]); + } +} + +/* 0x4A */ +static void +rpt_single_lla_position( + TSIPPKT *rpt + ) +{ + short + lat_deg, lon_deg; + float + lat, lon, + alt, clock_bias, time_of_fix; + double lat_min, lon_min; + unsigned char + north_south, east_west; + + if (rpt_0x4A (rpt, + &lat, &lon, &alt, &clock_bias, &time_of_fix)) + { + parsed = BADLEN_PARSE; + return; + } + + /* convert from radians to degrees */ + lat *= (float)R2D; + north_south = 'N'; + if (lat < 0.0) + { + north_south = 'S'; + lat = -lat; + } + lat_deg = (short)lat; + lat_min = (lat - lat_deg) * 60.0; + + lon *= (float)R2D; + east_west = 'E'; + if (lon < 0.0) + { + east_west = 'W'; + lon = -lon; + } + lon_deg = (short)lon; + lon_min = (lon - lon_deg) * 60.0; + + pbuf += sprintf(pbuf, "\nSLLA: %4d: %06.3f %c%5d:%06.3f %c%10.2f %12.2f%s", + lat_deg, lat_min, north_south, + lon_deg, lon_min, east_west, + alt, clock_bias, + show_time(time_of_fix)); +} + +/* 0x4A */ +static void +rpt_ref_alt( + TSIPPKT *rpt + ) +{ + float + alt, dummy; + unsigned char + alt_flag; + + if (rpt_0x4A_2 (rpt, &alt, &dummy, &alt_flag)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nReference Alt: %.1f m; %s", + alt, alt_flag?"ON":"OFF"); +} + +/* 0x4B */ +static void +rpt_rcvr_id_and_status( + TSIPPKT *rpt + ) +{ + + unsigned char + machine_id, status3, status4; + + /* unload rptbuf */ + if (rpt_0x4B (rpt, &machine_id, &status3, &status4)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nRcvr Machine ID: %d; Status3 = %s, %s (%02Xh)", + machine_id, + (status3 & 0x02)?"No RTC":"RTC OK", + (status3 & 0x08)?"No Alm":"Alm OK", + status3); +} + +/* 0x4C */ +static void +rpt_operating_parameters( + TSIPPKT *rpt + ) +{ + unsigned char + dyn_code; + float + el_mask, snr_mask, dop_mask, dop_switch; + + /* unload rptbuf */ + if (rpt_0x4C (rpt, &dyn_code, &el_mask, + &snr_mask, &dop_mask, &dop_switch)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nOperating Parameters:"); + pbuf += sprintf(pbuf, "\n Dynamics code = %d %s", + dyn_code, dyn_text[dyn_code]); + pbuf += sprintf(pbuf, "\n Elevation mask = %.2f", el_mask * R2D); + pbuf += sprintf(pbuf, "\n SNR mask = %.2f", snr_mask); + pbuf += sprintf(pbuf, "\n DOP mask = %.2f", dop_mask); + pbuf += sprintf(pbuf, "\n DOP switch = %.2f", dop_switch); +} + +/* 0x4D */ +static void +rpt_oscillator_offset( + TSIPPKT *rpt + ) +{ + float + osc_offset; + + /* unload rptbuf */ + if (rpt_0x4D (rpt, &osc_offset)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nOscillator offset: %.2f Hz = %.3f PPM", + osc_offset, osc_offset/1575.42); +} + +/* 0x4E */ +static void +rpt_GPS_time_set_response( + TSIPPKT *rpt + ) +{ + unsigned char + response; + + /* unload rptbuf */ + if (rpt_0x4E (rpt, &response)) + { + parsed = BADLEN_PARSE; + return; + } + + switch (response) + { + case 'Y': + pbuf += sprintf(pbuf, "\nTime set accepted"); + break; + + case 'N': + pbuf += sprintf(pbuf, "\nTime set rejected or not required"); + break; + + default: + parsed = BADDATA_PARSE; + } +} + +/* 0x4F */ +static void +rpt_UTC_offset( + TSIPPKT *rpt + ) +{ + double + a0; + float + a1, time_of_data; + short + dt_ls, wn_t, wn_lsf, dn, dt_lsf; + + /* unload rptbuf */ + if (rpt_0x4F (rpt, &a0, &a1, &time_of_data, + &dt_ls, &wn_t, &wn_lsf, &dn, &dt_lsf)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nUTC Correction Data"); + pbuf += sprintf(pbuf, "\n A_0 = %g ", a0); + pbuf += sprintf(pbuf, "\n A_1 = %g ", a1); + pbuf += sprintf(pbuf, "\n delta_t_LS = %d ", dt_ls); + pbuf += sprintf(pbuf, "\n t_ot = %.0f ", time_of_data); + pbuf += sprintf(pbuf, "\n WN_t = %d ", wn_t ); + pbuf += sprintf(pbuf, "\n WN_LSF = %d ", wn_lsf ); + pbuf += sprintf(pbuf, "\n DN = %d ", dn ); + pbuf += sprintf(pbuf, "\n delta_t_LSF = %d ", dt_lsf ); +} + +/**/ +/* 0x54 */ +static void +rpt_1SV_bias( + TSIPPKT *rpt + ) +{ + float + clock_bias, freq_offset, time_of_fix; + + /* unload rptbuf */ + if (rpt_0x54 (rpt, &clock_bias, &freq_offset, &time_of_fix)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf (pbuf, "\nTime Fix Clock Bias: %6.2f m Freq Bias: %6.2f m/s%s", + clock_bias, freq_offset, show_time (time_of_fix)); +} + +/* 0x55 */ +static void +rpt_io_opt( + TSIPPKT *rpt + ) +{ + unsigned char + pos_code, vel_code, time_code, aux_code; + + /* unload rptbuf */ + if (rpt_0x55 (rpt, + &pos_code, &vel_code, &time_code, &aux_code)) { + parsed = BADLEN_PARSE; + return; + } + /* rptbuf unloaded */ + + pbuf += sprintf(pbuf, "\nI/O Options: %2X %2X %2X %2X", + pos_code, vel_code, time_code, aux_code); + + if (pos_code & 0x01) { + pbuf += sprintf(pbuf, "\n ECEF XYZ position output"); + } + + if (pos_code & 0x02) { + pbuf += sprintf(pbuf, "\n LLA position output"); + } + + pbuf += sprintf(pbuf, (pos_code & 0x04)? + "\n MSL altitude output (Geoid height) ": + "\n WGS-84 altitude output"); + + pbuf += sprintf(pbuf, (pos_code & 0x08)? + "\n MSL altitude input": + "\n WGS-84 altitude input"); + + pbuf += sprintf(pbuf, (pos_code & 0x10)? + "\n Double precision": + "\n Single precision"); + + if (pos_code & 0x20) { + pbuf += sprintf(pbuf, "\n All Enabled Superpackets"); + } + + if (vel_code & 0x01) { + pbuf += sprintf(pbuf, "\n ECEF XYZ velocity output"); + } + + if (vel_code & 0x02) { + pbuf += sprintf(pbuf, "\n ENU velocity output"); + } + + pbuf += sprintf(pbuf, (time_code & 0x01)? + "\n Time tags in UTC": + "\n Time tags in GPS time"); + + if (time_code & 0x02) { + pbuf += sprintf(pbuf, "\n Fixes delayed to integer seconds"); + } + + if (time_code & 0x04) { + pbuf += sprintf(pbuf, "\n Fixes sent only on request"); + } + + if (time_code & 0x08) { + pbuf += sprintf(pbuf, "\n Synchronized measurements"); + } + + if (time_code & 0x10) { + pbuf += sprintf(pbuf, "\n Minimize measurement propagation"); + } + + pbuf += sprintf(pbuf, (time_code & 0x20) ? + "\n PPS output at all times" : + "\n PPS output during fixes"); + + if (aux_code & 0x01) { + pbuf += sprintf(pbuf, "\n Raw measurement output"); + } + + if (aux_code & 0x02) { + pbuf += sprintf(pbuf, "\n Code-phase smoothed before output"); + } + + if (aux_code & 0x04) { + pbuf += sprintf(pbuf, "\n Additional fix status"); + } + + pbuf += sprintf(pbuf, (aux_code & 0x08)? + "\n Signal Strength Output as dBHz" : + "\n Signal Strength Output as AMU"); +} + +/* 0x56 */ +static void +rpt_ENU_velocity( + TSIPPKT *rpt + ) +{ + float + vel_ENU[3], freq_offset, time_of_fix; + + /* unload rptbuf */ + if (rpt_0x56 (rpt, vel_ENU, &freq_offset, &time_of_fix)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nVel ENU: %11.3f %11.3f %11.3f %12.3f%s", + vel_ENU[0], vel_ENU[1], vel_ENU[2], freq_offset, + show_time (time_of_fix)); +} + +/* 0x57 */ +static void +rpt_last_fix_info( + TSIPPKT *rpt + ) +{ + unsigned char + source_code, diag_code; + short + week_num; + float + time_of_fix; + + /* unload rptbuf */ + if (rpt_0x57 (rpt, &source_code, &diag_code, &week_num, &time_of_fix)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\n source code %d; diag code: %2Xh", + source_code, diag_code); + pbuf += sprintf(pbuf, "\n Time of last fix:%s", show_time(time_of_fix)); + pbuf += sprintf(pbuf, "\n Week of last fix: %d", week_num); +} + +/* 0x58 */ +static void +rpt_GPS_system_data( + TSIPPKT *rpt + ) +{ + unsigned char + iprn, + op_code, data_type, sv_prn, + data_length, data_packet[250]; + ALM_INFO + *almanac; + ALH_PARMS + *almh; + UTC_INFO + *utc; + ION_INFO + *ionosphere; + EPHEM_CLOCK + *cdata; + EPHEM_ORBIT + *edata; + NAV_INFO + *nav_data; + unsigned char + curr_t_oa; + unsigned short + curr_wn_oa; + static char + *datname[] = + {"", "", "Almanac Orbit", + "Health Page & Ref Time", "Ionosphere", "UTC ", + "Ephemeris"}; + + /* unload rptbuf */ + if (rpt_0x58 (rpt, &op_code, &data_type, &sv_prn, + &data_length, data_packet)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nSystem data [%d]: %s SV%02d", + data_type, datname[data_type], sv_prn); + switch (op_code) + { + case 1: + pbuf += sprintf(pbuf, " Acknowledgment"); + break; + case 2: + pbuf += sprintf(pbuf, " length = %d bytes", data_length); + switch (data_type) { + case 2: + /* Almanac */ + if (sv_prn == 0 || sv_prn > 32) { + pbuf += sprintf(pbuf, " Binary PRN invalid"); + return; + } + almanac = (ALM_INFO*)data_packet; + pbuf += sprintf(pbuf, "\n t_oa_raw = % -12d SV_hlth = % -12d ", + almanac->t_oa_raw , almanac->SV_health ); + pbuf += sprintf(pbuf, "\n e = % -12g t_oa = % -12g ", + almanac->e , almanac->t_oa ); + pbuf += sprintf(pbuf, "\n i_0 = % -12g OMEGADOT = % -12g ", + almanac->i_0 , almanac->OMEGADOT ); + pbuf += sprintf(pbuf, "\n sqrt_A = % -12g OMEGA_0 = % -12g ", + almanac->sqrt_A , almanac->OMEGA_0 ); + pbuf += sprintf(pbuf, "\n omega = % -12g M_0 = % -12g ", + almanac->omega , almanac->M_0 ); + pbuf += sprintf(pbuf, "\n a_f0 = % -12g a_f1 = % -12g ", + almanac->a_f0 , almanac->a_f1 ); + pbuf += sprintf(pbuf, "\n Axis = % -12g n = % -12g ", + almanac->Axis , almanac->n ); + pbuf += sprintf(pbuf, "\n OMEGA_n = % -12g ODOT_n = % -12g ", + almanac->OMEGA_n , almanac->ODOT_n ); + pbuf += sprintf(pbuf, "\n t_zc = % -12g weeknum = % -12d ", + almanac->t_zc , almanac->weeknum ); + pbuf += sprintf(pbuf, "\n wn_oa = % -12d", almanac->wn_oa ); + break; + + case 3: + /* Almanac health page */ + almh = (ALH_PARMS*)data_packet; + pbuf += sprintf(pbuf, "\n t_oa = %d, wn_oa&0xFF = %d ", + almh->t_oa, almh->WN_a); + pbuf += sprintf(pbuf, "\nAlmanac health page:"); + for (iprn = 0; iprn < 32; iprn++) { + if (!(iprn%5)) *pbuf++ = '\n'; + pbuf += sprintf(pbuf, " SV%02d %2X", + (iprn+1) , almh->SV_health[iprn]); + } + curr_t_oa = data_packet[34]; + curr_wn_oa = (unsigned short)((data_packet[35]<<8) + data_packet[36]); + pbuf += sprintf(pbuf, "\n current t_oa = %d, wn_oa = %d ", + curr_t_oa, curr_wn_oa); + break; + + case 4: + /* Ionosphere */ + ionosphere = (ION_INFO*)data_packet; + pbuf += sprintf(pbuf, "\n alpha_0 = % -12g alpha_1 = % -12g ", + ionosphere->alpha_0, ionosphere->alpha_1); + pbuf += sprintf(pbuf, "\n alpha_2 = % -12g alpha_3 = % -12g ", + ionosphere->alpha_2, ionosphere->alpha_3); + pbuf += sprintf(pbuf, "\n beta_0 = % -12g beta_1 = % -12g ", + ionosphere->beta_0, ionosphere->beta_1); + pbuf += sprintf(pbuf, "\n beta_2 = % -12g beta_3 = % -12g ", + ionosphere->beta_2, ionosphere->beta_3); + break; + + case 5: + /* UTC */ + utc = (UTC_INFO*)data_packet; + pbuf += sprintf(pbuf, "\n A_0 = %g ", utc->A_0); + pbuf += sprintf(pbuf, "\n A_1 = %g ", utc->A_1); + pbuf += sprintf(pbuf, "\n delta_t_LS = %d ", utc->delta_t_LS); + pbuf += sprintf(pbuf, "\n t_ot = %.0f ", utc->t_ot ); + pbuf += sprintf(pbuf, "\n WN_t = %d ", utc->WN_t ); + pbuf += sprintf(pbuf, "\n WN_LSF = %d ", utc->WN_LSF ); + pbuf += sprintf(pbuf, "\n DN = %d ", utc->DN ); + pbuf += sprintf(pbuf, "\n delta_t_LSF = %d ", utc->delta_t_LSF ); + break; + + case 6: /* Ephemeris */ + if (sv_prn == 0 || sv_prn > 32) { + pbuf += sprintf(pbuf, " Binary PRN invalid"); + return; + } + nav_data = (NAV_INFO*)data_packet; + + pbuf += sprintf(pbuf, "\n SV_PRN = % -12d . t_ephem = % -12g . ", + nav_data->sv_number , nav_data->t_ephem ); + cdata = &(nav_data->ephclk); + pbuf += sprintf(pbuf, + "\n weeknum = % -12d . codeL2 = % -12d . L2Pdata = % -12d", + cdata->weeknum , cdata->codeL2 , cdata->L2Pdata ); + pbuf += sprintf(pbuf, + "\n SVacc_raw = % -12d .SV_health = % -12d . IODC = % -12d", + cdata->SVacc_raw, cdata->SV_health, cdata->IODC ); + pbuf += sprintf(pbuf, + "\n T_GD = % -12g . t_oc = % -12g . a_f2 = % -12g", + cdata->T_GD, cdata->t_oc, cdata->a_f2 ); + pbuf += sprintf(pbuf, + "\n a_f1 = % -12g . a_f0 = % -12g . SVacc = % -12g", + cdata->a_f1, cdata->a_f0, cdata->SVacc ); + edata = &(nav_data->ephorb); + pbuf += sprintf(pbuf, + "\n IODE = % -12d .fit_intvl = % -12d . C_rs = % -12g", + edata->IODE, edata->fit_interval, edata->C_rs ); + pbuf += sprintf(pbuf, + "\n delta_n = % -12g . M_0 = % -12g . C_uc = % -12g", + edata->delta_n, edata->M_0, edata->C_uc ); + pbuf += sprintf(pbuf, + "\n ecc = % -12g . C_us = % -12g . sqrt_A = % -12g", + edata->e, edata->C_us, edata->sqrt_A ); + pbuf += sprintf(pbuf, + "\n t_oe = % -12g . C_ic = % -12g . OMEGA_0 = % -12g", + edata->t_oe, edata->C_ic, edata->OMEGA_0 ); + pbuf += sprintf(pbuf, + "\n C_is = % -12g . i_0 = % -12g . C_rc = % -12g", + edata->C_is, edata->i_0, edata->C_rc ); + pbuf += sprintf(pbuf, + "\n omega = % -12g . OMEGADOT = % -12g . IDOT = % -12g", + edata->omega, edata->OMEGADOT, edata->IDOT ); + pbuf += sprintf(pbuf, + "\n Axis = % -12g . n = % -12g . r1me2 = % -12g", + edata->Axis, edata->n, edata->r1me2 ); + pbuf += sprintf(pbuf, + "\n OMEGA_n = % -12g . ODOT_n = % -12g", + edata->OMEGA_n, edata->ODOT_n ); + break; + } + } +} + + +/* 0x59: */ +static void +rpt_SVs_enabled( + TSIPPKT *rpt + ) +{ + unsigned char + numsvs, + code_type, + status_code[32]; + short + iprn; + + /* unload rptbuf */ + if (rpt_0x59 (rpt, &code_type, status_code)) + { + parsed = BADLEN_PARSE; + return; + } + switch (code_type) + { + case 3: pbuf += sprintf(pbuf, "\nSVs Disabled:\n"); break; + case 6: pbuf += sprintf(pbuf, "\nSVs with Health Ignored:\n"); break; + default: return; + } + numsvs = 0; + for (iprn = 0; iprn < 32; iprn++) + { + if (status_code[iprn]) + { + pbuf += sprintf(pbuf, " %02d", iprn+1); + numsvs++; + } + } + if (numsvs == 0) pbuf += sprintf(pbuf, "None"); +} + + +/* 0x5A */ +static void +rpt_raw_msmt( + TSIPPKT *rpt + ) +{ + unsigned char + sv_prn; + float + sample_length, signal_level, code_phase, Doppler; + double + time_of_fix; + + /* unload rptbuf */ + if (rpt_0x5A (rpt, &sv_prn, &sample_length, &signal_level, + &code_phase, &Doppler, &time_of_fix)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\n %02d %5.0f %7.1f %10.2f %10.2f %12.3f %s", + sv_prn, sample_length, signal_level, code_phase, Doppler, time_of_fix, + show_time ((float)time_of_fix)); +} + +/* 0x5B */ +static void +rpt_SV_ephemeris_status( + TSIPPKT *rpt + ) +{ + unsigned char + sv_prn, sv_health, sv_iode, fit_interval_flag; + float + time_of_collection, time_of_eph, sv_accy; + + /* unload rptbuf */ + if (rpt_0x5B (rpt, &sv_prn, &sv_health, &sv_iode, &fit_interval_flag, + &time_of_collection, &time_of_eph, &sv_accy)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\n SV%02d %s %2Xh %2Xh ", + sv_prn, show_time (time_of_collection), sv_health, sv_iode); + /* note: cannot use show_time twice in same call */ + pbuf += sprintf(pbuf, "%s %1d %4.1f", + show_time (time_of_eph), fit_interval_flag, sv_accy); +} + +/* 0x5C */ +static void +rpt_SV_tracking_status( + TSIPPKT *rpt + ) +{ + unsigned char + sv_prn, chan, slot, acq_flag, eph_flag, + old_msmt_flag, integer_msec_flag, bad_data_flag, + data_collect_flag; + float + signal_level, time_of_last_msmt, + elev, azim; + + /* unload rptbuf */ + if (rpt_0x5C (rpt, + &sv_prn, &slot, &chan, &acq_flag, &eph_flag, + &signal_level, &time_of_last_msmt, &elev, &azim, + &old_msmt_flag, &integer_msec_flag, &bad_data_flag, + &data_collect_flag)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, + "\n SV%2d %1d %1d %1d %4.1f %s %5.1f %5.1f", + sv_prn, chan, + acq_flag, eph_flag, signal_level, + show_time(time_of_last_msmt), + elev*R2D, azim*R2D); +} + +/**/ +/* 0x6D */ +static void +rpt_allSV_selection( + TSIPPKT *rpt + ) +{ + unsigned char + manual_mode, nsvs, sv_prn[8], ndim; + short + islot; + float + pdop, hdop, vdop, tdop; + + /* unload rptbuf */ + if (rpt_0x6D (rpt, + &manual_mode, &nsvs, &ndim, sv_prn, + &pdop, &hdop, &vdop, &tdop)) + { + parsed = BADLEN_PARSE; + return; + } + + switch (ndim) + { + case 0: + pbuf += sprintf(pbuf, "\nMode: Searching, %d-SV:", nsvs); + break; + case 1: + pbuf += sprintf(pbuf, "\nMode: One-SV Timing:"); + break; + case 3: case 4: + pbuf += sprintf(pbuf, "\nMode: %c-%dD, %d-SV:", + manual_mode ? 'M' : 'A', ndim - 1, nsvs); + break; + case 5: + pbuf += sprintf(pbuf, "\nMode: Timing, %d-SV:", nsvs); + break; + default: + pbuf += sprintf(pbuf, "\nMode: Unknown = %d:", ndim); + break; + } + + for (islot = 0; islot < nsvs; islot++) + { + if (sv_prn[islot]) pbuf += sprintf(pbuf, " %02d", sv_prn[islot]); + } + if (ndim == 3 || ndim == 4) + { + pbuf += sprintf(pbuf, "; DOPs: P %.1f H %.1f V %.1f T %.1f", + pdop, hdop, vdop, tdop); + } +} + +/**/ +/* 0x82 */ +static void +rpt_DGPS_position_mode( + TSIPPKT *rpt + ) +{ + unsigned char + diff_mode; + + /* unload rptbuf */ + if (rpt_0x82 (rpt, &diff_mode)) { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nFix is%s DGPS-corrected (%s mode) (%d)", + (diff_mode&1) ? "" : " not", + (diff_mode&2) ? "auto" : "manual", + diff_mode); +} + +/* 0x83 */ +static void +rpt_double_ECEF_position( + TSIPPKT *rpt + ) +{ + double + ECEF_pos[3], clock_bias; + float + time_of_fix; + + /* unload rptbuf */ + if (rpt_0x83 (rpt, ECEF_pos, &clock_bias, &time_of_fix)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nDXYZ:%12.2f %13.2f %13.2f %12.2f%s", + ECEF_pos[0], ECEF_pos[1], ECEF_pos[2], clock_bias, + show_time(time_of_fix)); +} + +/* 0x84 */ +static void +rpt_double_lla_position( + TSIPPKT *rpt + ) +{ + short + lat_deg, lon_deg; + double + lat, lon, lat_min, lon_min, + alt, clock_bias; + float + time_of_fix; + unsigned char + north_south, east_west; + + /* unload rptbuf */ + if (rpt_0x84 (rpt, + &lat, &lon, &alt, &clock_bias, &time_of_fix)) + { + parsed = BADLEN_PARSE; + return; + } + + lat *= R2D; + lon *= R2D; + if (lat < 0.0) { + north_south = 'S'; + lat = -lat; + } else { + north_south = 'N'; + } + lat_deg = (short)lat; + lat_min = (lat - lat_deg) * 60.0; + + if (lon < 0.0) { + east_west = 'W'; + lon = -lon; + } else { + east_west = 'E'; + } + lon_deg = (short)lon; + lon_min = (lon - lon_deg) * 60.0; + pbuf += sprintf(pbuf, "\nDLLA: %2d:%08.5f %c; %3d:%08.5f %c; %10.2f %12.2f%s", + lat_deg, lat_min, north_south, + lon_deg, lon_min, east_west, + alt, clock_bias, + show_time(time_of_fix)); +} + +/* 0xBB */ +static void +rpt_complete_rcvr_config( + TSIPPKT *rpt + ) +{ + TSIP_RCVR_CFG TsipxBB ; + /* unload rptbuf */ + if (rpt_Paly0xBB (rpt, &TsipxBB)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\n operating mode: %s", + NavModeText0xBB[TsipxBB.operating_mode]); + pbuf += sprintf(pbuf, "\n dynamics: %s", + dyn_text[TsipxBB.dyn_code]); + pbuf += sprintf(pbuf, "\n elev angle mask: %g deg", + TsipxBB.elev_mask * R2D); + pbuf += sprintf(pbuf, "\n SNR mask: %g AMU", + TsipxBB.cno_mask); + pbuf += sprintf(pbuf, "\n DOP mask: %g", + TsipxBB.dop_mask); + pbuf += sprintf(pbuf, "\n DOP switch: %g", + TsipxBB.dop_switch); + return ; +} + +/* 0xBC */ +static void +rpt_rcvr_serial_port_config( + TSIPPKT *rpt + ) +{ + unsigned char + port_num, in_baud, out_baud, data_bits, parity, stop_bits, flow_control, + protocols_in, protocols_out, reserved; + unsigned char known; + + /* unload rptbuf */ + if (rpt_0xBC (rpt, &port_num, &in_baud, &out_baud, &data_bits, &parity, + &stop_bits, &flow_control, &protocols_in, &protocols_out, &reserved)) { + parsed = BADLEN_PARSE; + return; + } + /* rptbuf unloaded */ + + pbuf += sprintf(pbuf, "\n RECEIVER serial port %s config:", + rcvr_port_text[port_num]); + + pbuf += sprintf(pbuf, "\n I/O Baud %s/%s, %d - %s - %d", + st_baud_text_app[in_baud], + st_baud_text_app[out_baud], + data_bits+5, + parity_text[parity], + stop_bits=1); + pbuf += sprintf(pbuf, "\n Input protocols: "); + known = FALSE; + if (protocols_in&B_TSIP) + { + pbuf += sprintf(pbuf, "%s ", protocols_in_text[1]); + known = TRUE; + } + if (known == FALSE) pbuf += sprintf(pbuf, "No known"); + + pbuf += sprintf(pbuf, "\n Output protocols: "); + known = FALSE; + if (protocols_out&B_TSIP) + { + pbuf += sprintf(pbuf, "%s ", protocols_out_text[1]); + known = TRUE; + } + if (protocols_out&B_NMEA) + { + pbuf += sprintf(pbuf, "%s ", protocols_out_text[2]); + known = TRUE; + } + if (known == FALSE) pbuf += sprintf(pbuf, "No known"); + reserved = reserved; + +} + +/* 0x8F */ +/* 8F0B */ +static void +rpt_8F0B( + TSIPPKT *rpt + ) +{ + const char + *oprtng_dim[7] = { + "horizontal (2-D)", + "full position (3-D)", + "single satellite (0-D)", + "automatic", + "N/A", + "N/A", + "overdetermined clock"}; + char + sv_id[8]; + unsigned char + month, + date, + dim_mode, + north_south, + east_west; + unsigned short + event; + short + utc_offset, + year, + local_index; + short + lat_deg, + lon_deg; + float + bias_unc, + dr_unc; + double + tow, + bias, + drift, + lat, + lon, + alt, + lat_min, + lon_min; + int + numfix, + numnotfix; + + if (rpt_0x8F0B(rpt, + &event, + &tow, + &date, + &month, + &year, + &dim_mode, + &utc_offset, + &bias, + &drift, + &bias_unc, + &dr_unc, + &lat, + &lon, + &alt, + sv_id)) + { + parsed = BADLEN_PARSE; + return; + } + + if (event == 0) + { + pbuf += sprintf(pbuf, "\nNew partial+full meas"); + } + else + { + pbuf += sprintf(pbuf, "\nEvent count: %5d", event); + } + + pbuf += sprintf(pbuf, "\nGPS time : %s %2d/%2d/%2d (DMY)", + show_time(tow), date, month, year); + pbuf += sprintf(pbuf, "\nMode : %s", oprtng_dim[dim_mode]); + pbuf += sprintf(pbuf, "\nUTC offset: %2d", utc_offset); + pbuf += sprintf(pbuf, "\nClock Bias: %6.2f m", bias); + pbuf += sprintf(pbuf, "\nFreq bias : %6.2f m/s", drift); + pbuf += sprintf(pbuf, "\nBias unc : %6.2f m", bias_unc); + pbuf += sprintf(pbuf, "\nFreq unc : %6.2f m/s", dr_unc); + + lat *= R2D; /* convert from radians to degrees */ + lon *= R2D; + if (lat < 0.0) + { + north_south = 'S'; + lat = -lat; + } + else + { + north_south = 'N'; + } + + lat_deg = (short)lat; + lat_min = (lat - lat_deg) * 60.0; + if (lon < 0.0) + { + east_west = 'W'; + lon = -lon; + } + else + { + east_west = 'E'; + } + + lon_deg = (short)lon; + lon_min = (lon - lon_deg) * 60.0; + pbuf += sprintf(pbuf, "\nPosition :"); + pbuf += sprintf(pbuf, " %4d %6.3f %c", lat_deg, lat_min, north_south); + pbuf += sprintf(pbuf, " %5d %6.3f %c", lon_deg, lon_min, east_west); + pbuf += sprintf(pbuf, " %10.2f", alt); + + numfix = numnotfix = 0; + for (local_index=0; local_index<8; local_index++) + { + if (sv_id[local_index] < 0) numnotfix++; + if (sv_id[local_index] > 0) numfix++; + } + if (numfix > 0) + { + pbuf += sprintf(pbuf, "\nSVs used in fix : "); + for (local_index=0; local_index<8; local_index++) + { + if (sv_id[local_index] > 0) + { + pbuf += sprintf(pbuf, "%2d ", sv_id[local_index]); + } + } + } + if (numnotfix > 0) + { + pbuf += sprintf(pbuf, "\nOther SVs tracked: "); + for (local_index=0; local_index<8; local_index++) + { + if (sv_id[local_index] < 0) + { + pbuf += sprintf(pbuf, "%2d ", sv_id[local_index]); + } + } + } +} + +/* 0x8F14 */ +/* Datum parameters */ +static void +rpt_8F14( + TSIPPKT *rpt + ) +{ + double + datum_coeffs[5]; + short + datum_idx; + + /* unload rptbuf */ + if (rpt_0x8F14 (rpt, &datum_idx, datum_coeffs)) + { + parsed = BADLEN_PARSE; + return; + } + + if (datum_idx == -1) + { + pbuf += sprintf(pbuf, "\nUser-Entered Datum:"); + pbuf += sprintf(pbuf, "\n dx = %6.1f", datum_coeffs[0]); + pbuf += sprintf(pbuf, "\n dy = %6.1f", datum_coeffs[1]); + pbuf += sprintf(pbuf, "\n dz = %6.1f", datum_coeffs[2]); + pbuf += sprintf(pbuf, "\n a-axis = %10.3f", datum_coeffs[3]); + pbuf += sprintf(pbuf, "\n e-squared = %16.14f", datum_coeffs[4]); + } + else if (datum_idx == 0) + { + pbuf += sprintf(pbuf, "\nWGS-84 datum, Index 0 "); + } + else + { + pbuf += sprintf(pbuf, "\nStandard Datum, Index %3d ", datum_idx); + } +} + +/* 0x8F15 */ +/* Datum parameters */ +static void +rpt_8F15( + TSIPPKT *rpt + ) +{ + double + datum_coeffs[5]; + short + datum_idx; + + /* unload rptbuf */ + if (rpt_0x8F15 (rpt, &datum_idx, datum_coeffs)) { + parsed = BADLEN_PARSE; + return; + } + + if (datum_idx == -1) + { + pbuf += sprintf(pbuf, "\nUser-Entered Datum:"); + pbuf += sprintf(pbuf, "\n dx = %6.1f", datum_coeffs[0]); + pbuf += sprintf(pbuf, "\n dy = %6.1f", datum_coeffs[1]); + pbuf += sprintf(pbuf, "\n dz = %6.1f", datum_coeffs[2]); + pbuf += sprintf(pbuf, "\n a-axis = %10.3f", datum_coeffs[3]); + pbuf += sprintf(pbuf, "\n e-squared = %16.14f", datum_coeffs[4]); + } + else if (datum_idx == 0) + { + pbuf += sprintf(pbuf, "\nWGS-84 datum, Index 0 "); + } + else + { + pbuf += sprintf(pbuf, "\nStandard Datum, Index %3d ", datum_idx); + } +} + +/* 0x8F20 */ +#define INFO_DGPS 0x02 +#define INFO_2D 0x04 +#define INFO_ALTSET 0x08 +#define INFO_FILTERED 0x10 +static void +rpt_8F20( + TSIPPKT *rpt + ) +{ + unsigned char + info, nsvs, sv_prn[32]; + short + week_num, datum_index, sv_IODC[32]; + double + lat, lon, alt, time_of_fix; + double + londeg, latdeg, vel[3]; + short + isv; + char + datum_string[20]; + + /* unload rptbuf */ + if (rpt_0x8F20 (rpt, + &info, &lat, &lon, &alt, vel, + &time_of_fix, + &week_num, &nsvs, sv_prn, sv_IODC, &datum_index)) + { + parsed = BADLEN_PARSE; + return; + } + pbuf += sprintf(pbuf, + "\nFix at: %04d:%3s:%02d:%02d:%06.3f GPS (=UTC+%2ds) FixType: %s%s%s", + week_num, + dayname[(short)(time_of_fix/86400.0)], + (short)fmod(time_of_fix/3600., 24.), + (short)fmod(time_of_fix/60., 60.), + fmod(time_of_fix, 60.), + (char)rpt->buf[29], /* UTC offset */ + (info & INFO_DGPS)?"Diff":"", + (info & INFO_2D)?"2D":"3D", + (info & INFO_FILTERED)?"-Filtrd":""); + + if (datum_index > 0) + { + sprintf(datum_string, "Datum%3d", datum_index); + } + else if (datum_index) + { + sprintf(datum_string, "Unknown "); + } + else + { + sprintf(datum_string, "WGS-84"); + } + + /* convert from radians to degrees */ + latdeg = R2D * fabs(lat); + londeg = R2D * fabs(lon); + pbuf += sprintf(pbuf, + "\n Pos: %4d:%09.6f %c %5d:%09.6f %c %10.2f m HAE (%s)", + (short)latdeg, fmod (latdeg, 1.)*60.0, + (lat<0.0)?'S':'N', + (short)londeg, fmod (londeg, 1.)*60.0, + (lon<0.0)?'W':'E', + alt, + datum_string); + pbuf += sprintf(pbuf, + "\n Vel: %9.3f E %9.3f N %9.3f U (m/sec)", + vel[0], vel[1], vel[2]); + + pbuf += sprintf(pbuf, + "\n SVs: "); + for (isv = 0; isv < nsvs; isv++) { + pbuf += sprintf(pbuf, " %02d", sv_prn[isv]); + } + pbuf += sprintf(pbuf, " (IODEs:"); + for (isv = 0; isv < nsvs; isv++) { + pbuf += sprintf(pbuf, " %02X", sv_IODC[isv]&0xFF); + } + pbuf += sprintf(pbuf, ")"); +} + +/* 0x8F41 */ +static void +rpt_8F41( + TSIPPKT *rpt + ) +{ + unsigned char + bSearchRange, + bBoardOptions, + bBuildYear, + bBuildMonth, + bBuildDay, + bBuildHour; + float + fOscOffset; + unsigned short + iTestCodeId; + unsigned long + iiSerialNumber; + + if (!rpt_0x8F41(rpt, + &bSearchRange, + &bBoardOptions, + &iiSerialNumber, + &bBuildYear, + &bBuildMonth, + &bBuildDay, + &bBuildHour, + &fOscOffset, + &iTestCodeId)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\n search range: %d", + bSearchRange); + pbuf += sprintf(pbuf, "\n board options: %d", + bBoardOptions); + pbuf += sprintf(pbuf, "\n board serial #: %ld", + iiSerialNumber); + pbuf += sprintf(pbuf, "\n build date/hour: %02d/%02d/%02d %02d:00", + bBuildDay, bBuildMonth, bBuildYear, bBuildHour); + pbuf += sprintf(pbuf, "\n osc offset: %.3f PPM (%.0f Hz)", + fOscOffset/1575.42, fOscOffset); + pbuf += sprintf(pbuf, "\n test code: %d", + iTestCodeId); +} + +/* 0x8F42 */ +static void +rpt_8F42( + TSIPPKT *rpt + ) +{ + unsigned char + bProdOptionsPre, + bProdNumberExt; + unsigned short + iCaseSerialNumberPre, + iPremiumOptions, + iMachineID, + iKey; + unsigned long + iiCaseSerialNumber, + iiProdNumber; + + if (!rpt_0x8F42(rpt, + &bProdOptionsPre, + &bProdNumberExt, + &iCaseSerialNumberPre, + &iiCaseSerialNumber, + &iiProdNumber, + &iPremiumOptions, + &iMachineID, + &iKey)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nProduct ID 8F42"); + pbuf += sprintf(pbuf, "\n extension: %d", bProdNumberExt); + pbuf += sprintf(pbuf, "\n case serial # prefix: %d", iCaseSerialNumberPre); + pbuf += sprintf(pbuf, "\n case serial #: %ld", iiCaseSerialNumber); + pbuf += sprintf(pbuf, "\n prod. #: %ld", iiProdNumber); + pbuf += sprintf(pbuf, "\n premium options: %Xh", iPremiumOptions); + pbuf += sprintf(pbuf, "\n machine ID: %d", iMachineID); + pbuf += sprintf(pbuf, "\n key: %Xh", iKey); +} + +/* 0x8F45 */ +static void +rpt_8F45( + TSIPPKT *rpt + ) +{ + unsigned char bSegMask; + + if (!rpt_0x8F45(rpt, + &bSegMask)) + { + parsed = BADLEN_PARSE; + return; + } + pbuf += sprintf(pbuf, "\nCleared Segment Mask: %Xh", bSegMask); +} + +/* Stinger PPS def */ +static void +rpt_8F4A( + TSIPPKT *rpt + ) +{ + unsigned char + pps_enabled, + pps_timebase, + pps_polarity; + float + bias_unc_threshold; + double + pps_offset; + + if (rpt_0x8F4A_16 (rpt, + &pps_enabled, + &pps_timebase, + &pps_polarity, + &pps_offset, + &bias_unc_threshold)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nPPS is %s", pps_enabled?"enabled":"disabled"); + pbuf += sprintf(pbuf, "\n timebase: %s", PPSTimeBaseText[pps_timebase]); + pbuf += sprintf(pbuf, "\n polarity: %s", PPSPolarityText[pps_polarity]); + pbuf += sprintf(pbuf, "\n offset: %.1f ns, ", pps_offset*1.e9); + pbuf += sprintf(pbuf, "\n biasunc: %.1f ns", bias_unc_threshold/GPS_C*1.e9); +} + +/* fast-SA decorrolation time for self-survey */ +static void +rpt_8F4B( + TSIPPKT *rpt + ) +{ + unsigned long + decorr_max; + + if (rpt_0x8F4B(rpt, &decorr_max)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, + "\nMax # of position fixes for self-survey : %ld", + decorr_max); +} + +static void +rpt_8F4D( + TSIPPKT *rpt + ) +{ + static char + *linestart; + unsigned long + OutputMask; + static unsigned long + MaskBit[] = { + 0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, + 0x00000020, + 0x00000100L, 0x00000800L, 0x00001000L, + 0x40000000L, 0x80000000L}; + int + ichoice, + numchoices; + + if (rpt_0x8F4D(rpt, &OutputMask)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nAuto-Report Mask: %02X %02X %02X %02X", + (unsigned char)(OutputMask>>24), + (unsigned char)(OutputMask>>16), + (unsigned char)(OutputMask>>8), + (unsigned char)OutputMask); + + numchoices = sizeof(MaskText)/sizeof(char*); + pbuf += sprintf(pbuf, "\nAuto-Reports scheduled for Output:"); + linestart = pbuf; + for (ichoice = 0; ichoice < numchoices; ichoice++) + { + if (OutputMask&MaskBit[ichoice]) + { + pbuf += sprintf(pbuf, "%s %s", + (pbuf==linestart)?"\n ":",", + MaskText[ichoice]); + if (pbuf-linestart > 60) linestart = pbuf; + } + } + + pbuf += sprintf(pbuf, "\nAuto-Reports NOT scheduled for Output:"); + linestart = pbuf; + for (ichoice = 0; ichoice < numchoices; ichoice++) + { + if (OutputMask&MaskBit[ichoice]) continue; + pbuf += sprintf(pbuf, "%s %s", + (pbuf==linestart)?"\n ":",", + MaskText[ichoice]); + if (pbuf-linestart > 60) linestart = pbuf; + } +} + +static void +rpt_8FA5( + TSIPPKT *rpt + ) +{ + unsigned char + spktmask[4]; + + if (rpt_0x8FA5(rpt, spktmask)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\nSuperpacket auto-output mask: %02X %02X %02X %02X", + spktmask[0], spktmask[1], spktmask[2], spktmask[3]); + + if (spktmask[0]&0x01) pbuf+= sprintf (pbuf, "\n PPS 8F-0B"); + if (spktmask[0]&0x02) pbuf+= sprintf (pbuf, "\n Event 8F-0B"); + if (spktmask[0]&0x10) pbuf+= sprintf (pbuf, "\n PPS 8F-AD"); + if (spktmask[0]&0x20) pbuf+= sprintf (pbuf, "\n Event 8F-AD"); + if (spktmask[2]&0x01) pbuf+= sprintf (pbuf, "\n ppos Fix 8F-20"); +} + +static void +rpt_8FAD( + TSIPPKT *rpt + ) +{ + unsigned short + Count, + Year; + double + FracSec; + unsigned char + Hour, + Minute, + Second, + Day, + Month, + Status, + Flags; + static char* Status8FADText[] = { + "CODE_DOING_FIXES", + "CODE_GOOD_1_SV", + "CODE_APPX_1SV", + "CODE_NEED_TIME", + "CODE_NEED_INITIALIZATION", + "CODE_PDOP_HIGH", + "CODE_BAD_1SV", + "CODE_0SVS", + "CODE_1SV", + "CODE_2SVS", + "CODE_3SVS", + "CODE_NO_INTEGRITY", + "CODE_DCORR_GEN", + "CODE_OVERDET_CLK", + "Invalid Status"}, + *LeapStatusText[] = { + " UTC Avail", " ", " ", " ", + " Scheduled", " Pending", " Warning", " In Progress"}; + int i; + + if (rpt_0x8FAD (rpt, + &Count, + &FracSec, + &Hour, + &Minute, + &Second, + &Day, + &Month, + &Year, + &Status, + &Flags)) + { + parsed = BADLEN_PARSE; + return; + } + + pbuf += sprintf(pbuf, "\n8FAD Count: %d Status: %s", + Count, Status8FADText[Status]); + + pbuf += sprintf(pbuf, "\n Leap Flags:"); + if (Flags) + { + for (i=0; i<8; i++) + { + if (Flags&(1<<i)) pbuf += sprintf(pbuf, LeapStatusText[i]); + } + } + else + { + pbuf += sprintf(pbuf, " UTC info not available"); + } + + pbuf += sprintf(pbuf, "\n %02d/%02d/%04d (DMY) %02d:%02d:%02d.%09ld UTC", + Day, Month, Year, Hour, Minute, Second, (long)(FracSec*1.e9)); +} + + +int +print_msg_table_header( + int rptcode, + char *HdrStr, + int force + ) +{ + /* force header is to help auto-output function */ + /* last_rptcode is to determine whether to print a header */ + /* for the first occurrence of a series of reports */ + static int + last_rptcode = 0; + int + numchars; + + numchars = 0; + if (force || rptcode!=last_rptcode) + { + /* supply a header in console output */ + switch (rptcode) + { + case 0x5A: + numchars = sprintf(HdrStr, "\nRaw Measurement Data"); + numchars += sprintf(HdrStr+numchars, + "\n SV Sample SNR Code Phase Doppler Seconds Time of Meas"); + break; + + case 0x5B: + numchars = sprintf(HdrStr, "\nEphemeris Status"); + numchars += sprintf(HdrStr+numchars, + "\n SV Time collected Health IODE t oe Fit URA"); + break; + + case 0x5C: + numchars = sprintf(HdrStr, "\nTracking Info"); + numchars += sprintf(HdrStr+numchars, + "\n SV C Acq Eph SNR Time of Meas Elev Azim "); + break; + + } + } + last_rptcode = rptcode; + return (short)numchars; +} + +static void +unknown_rpt( + TSIPPKT *rpt + ) +{ + int i; + + /* app-specific rpt packets */ + if (parsed == BADLEN_PARSE) + { + pbuf += sprintf(pbuf, "\nTSIP report packet ID %2Xh, length %d: Bad length", + rpt->code, rpt->len); + } + if (parsed == BADID_PARSE) + { + pbuf += sprintf(pbuf, + "\nTSIP report packet ID %2Xh, length %d: translation not supported", + rpt->code, rpt->len); + } + + if (parsed == BADDATA_PARSE) + { + pbuf += sprintf(pbuf, + "\nTSIP report packet ID %2Xh, length %d: data content incorrect", + rpt->code, rpt->len); + } + + for (i = 0; i < rpt->len; i++) { + if ((i % 20) == 0) *pbuf++ = '\n'; + pbuf += sprintf(pbuf, " %02X", rpt->buf[i]); + } +} +/**/ + +/* +** main subroutine, called from ProcessInputBytesWhileWaitingForKBHit() +*/ +void +TranslateTSIPReportToText( + TSIPPKT *rpt, + char *TextOutputBuffer + ) +{ + + /* pbuf is the pointer to the current location of the text output */ + pbuf = TextOutputBuffer; + + /* keep track of whether the message has been successfully parsed */ + parsed = GOOD_PARSE; + + /* print a header if this is the first of a series of messages */ + pbuf += print_msg_table_header (rpt->code, pbuf, FALSE); + + /* process incoming TSIP report according to code */ + switch (rpt->code) + { + case 0x3D: rpt_chan_A_config (rpt); break; + case 0x40: rpt_almanac_data_page (rpt); break; + case 0x41: rpt_GPS_time (rpt); break; + case 0x42: rpt_single_ECEF_position (rpt); break; + case 0x43: rpt_single_ECEF_velocity (rpt); break; + case 0x45: rpt_SW_version (rpt); break; + case 0x46: rpt_rcvr_health (rpt); break; + case 0x47: rpt_SNR_all_SVs (rpt); break; + case 0x48: rpt_GPS_system_message (rpt); break; + case 0x49: rpt_almanac_health_page (rpt); break; + case 0x4A: switch (rpt->len) { + /* + ** special case (=slip-up) in the TSIP protocol; + ** parsing method depends on length + */ + case 20: rpt_single_lla_position (rpt); break; + case 9: rpt_ref_alt (rpt); break; + } break; + case 0x4B: rpt_rcvr_id_and_status (rpt);break; + case 0x4C: rpt_operating_parameters (rpt); break; + case 0x4D: rpt_oscillator_offset (rpt); break; + case 0x4E: rpt_GPS_time_set_response (rpt); break; + case 0x4F: rpt_UTC_offset (rpt); break; + case 0x54: rpt_1SV_bias (rpt); break; + case 0x55: rpt_io_opt (rpt); break; + case 0x56: rpt_ENU_velocity (rpt); break; + case 0x57: rpt_last_fix_info (rpt); break; + case 0x58: rpt_GPS_system_data (rpt); break; + case 0x59: rpt_SVs_enabled (rpt); break; + case 0x5A: rpt_raw_msmt (rpt); break; + case 0x5B: rpt_SV_ephemeris_status (rpt); break; + case 0x5C: rpt_SV_tracking_status (rpt); break; + case 0x6D: rpt_allSV_selection (rpt); break; + case 0x82: rpt_DGPS_position_mode (rpt); break; + case 0x83: rpt_double_ECEF_position (rpt); break; + case 0x84: rpt_double_lla_position (rpt); break; + case 0xBB: rpt_complete_rcvr_config (rpt); break; + case 0xBC: rpt_rcvr_serial_port_config (rpt); break; + + case 0x8F: switch (rpt->buf[0]) + { + /* superpackets; parsed according to subcodes */ + case 0x0B: rpt_8F0B(rpt); break; + case 0x14: rpt_8F14(rpt); break; + case 0x15: rpt_8F15(rpt); break; + case 0x20: rpt_8F20(rpt); break; + case 0x41: rpt_8F41(rpt); break; + case 0x42: rpt_8F42(rpt); break; + case 0x45: rpt_8F45(rpt); break; + case 0x4A: rpt_8F4A(rpt); break; + case 0x4B: rpt_8F4B(rpt); break; + case 0x4D: rpt_8F4D(rpt); break; + case 0xA5: rpt_8FA5(rpt); break; + case 0xAD: rpt_8FAD(rpt); break; + default: parsed = BADID_PARSE; break; + } + break; + + default: parsed = BADID_PARSE; break; + } + + if (parsed != GOOD_PARSE) + { + /* + **The message has TSIP structure (DLEs, etc.) + ** but could not be parsed by above routines + */ + unknown_rpt (rpt); + } + + /* close TextOutputBuffer */ + pbuf = '\0'; +} + +#endif /* TRIMBLE_OUTPUT_FUNC */ + +#else /* defined(REFCLOCK) && defined(CLOCK_RIPENCC) */ +int refclock_ripencc_bs; +#endif /* defined(REFCLOCK) && defined(CLOCK_RIPENCC) */ + |