/* * This software was developed by the Computer Systems Engineering group * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66. * * Copyright (c) 1992 The Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Lawrence Berkeley Laboratory. * 4. The name of the University may not be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Modified: Marc Brett <marc.brett@westgeo.com> Sept, 1999. * * 1. Added support for alternate PPS schemes, with code mostly * copied from the Oncore driver (Thanks, Poul-Henning Kamp). * This code runs on SunOS 4.1.3 with ppsclock-1.6a1 and Solaris 7. */ #ifdef HAVE_CONFIG_H # include <config.h> #endif #if defined(REFCLOCK) && defined(CLOCK_MX4200) && defined(HAVE_PPSAPI) #include "ntpd.h" #include "ntp_io.h" #include "ntp_refclock.h" #include "ntp_unixtime.h" #include "ntp_stdlib.h" #include <stdio.h> #include <ctype.h> #include "mx4200.h" #ifdef HAVE_SYS_TERMIOS_H # include <sys/termios.h> #endif #ifdef HAVE_SYS_PPSCLOCK_H # include <sys/ppsclock.h> #endif #include "ntp_sprintf.h" #ifndef HAVE_STRUCT_PPSCLOCKEV struct ppsclockev { # ifdef HAVE_STRUCT_TIMESPEC struct timespec tv; # else struct timeval tv; # endif u_int serial; }; #endif /* ! HAVE_STRUCT_PPSCLOCKEV */ #ifdef HAVE_PPSAPI # include "ppsapi_timepps.h" #endif /* HAVE_PPSAPI */ /* * This driver supports the Magnavox Model MX 4200 GPS Receiver * adapted to precision timing applications. It requires the * ppsclock line discipline or streams module described in the * Line Disciplines and Streams Drivers page. It also requires a * gadget box and 1-PPS level converter, such as described in the * Pulse-per-second (PPS) Signal Interfacing page. * * It's likely that other compatible Magnavox receivers such as the * MX 4200D, MX 9212, MX 9012R, MX 9112 will be supported by this code. */ /* * Check this every time you edit the code! */ #define YEAR_LAST_MODIFIED 2000 /* * GPS Definitions */ #define DEVICE "/dev/gps%d" /* device name and unit */ #define SPEED232 B4800 /* baud */ /* * Radio interface parameters */ #define PRECISION (-18) /* precision assumed (about 4 us) */ #define REFID "GPS\0" /* reference id */ #define DESCRIPTION "Magnavox MX4200 GPS Receiver" /* who we are */ #define DEFFUDGETIME 0 /* default fudge time (ms) */ #define SLEEPTIME 32 /* seconds to wait for reconfig to complete */ /* * Position Averaging. */ #define INTERVAL 1 /* Interval between position measurements (s) */ #define AVGING_TIME 24 /* Number of hours to average */ #define NOT_INITIALIZED -9999. /* initial pivot longitude */ /* * MX4200 unit control structure. */ struct mx4200unit { u_int pollcnt; /* poll message counter */ u_int polled; /* Hand in a time sample? */ u_int lastserial; /* last pps serial number */ struct ppsclockev ppsev; /* PPS control structure */ double avg_lat; /* average latitude */ double avg_lon; /* average longitude */ double avg_alt; /* average height */ double central_meridian; /* central meridian */ double N_fixes; /* Number of position measurements */ int last_leap; /* leap second warning */ u_int moving; /* mobile platform? */ u_long sloppyclockflag; /* fudge flags */ u_int known; /* position known yet? */ u_long clamp_time; /* when to stop postion averaging */ u_long log_time; /* when to print receiver status */ pps_handle_t pps_h; pps_params_t pps_p; pps_info_t pps_i; }; static char pmvxg[] = "PMVXG"; /* XXX should be somewhere else */ #ifdef __GNUC__ #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) #ifndef __attribute__ #define __attribute__(args) #endif /* __attribute__ */ #endif /* __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) */ #else #ifndef __attribute__ #define __attribute__(args) #endif /* __attribute__ */ #endif /* __GNUC__ */ /* XXX end */ /* * Function prototypes */ static int mx4200_start P((int, struct peer *)); static void mx4200_shutdown P((int, struct peer *)); static void mx4200_receive P((struct recvbuf *)); static void mx4200_poll P((int, struct peer *)); static char * mx4200_parse_t P((struct peer *)); static char * mx4200_parse_p P((struct peer *)); static char * mx4200_parse_s P((struct peer *)); #ifdef QSORT_USES_VOID_P int mx4200_cmpl_fp P((const void *, const void *)); #else int mx4200_cmpl_fp P((const l_fp *, const l_fp *)); #endif /* not QSORT_USES_VOID_P */ static int mx4200_config P((struct peer *)); static void mx4200_ref P((struct peer *)); static void mx4200_send P((struct peer *, char *, ...)) __attribute__ ((format (printf, 2, 3))); static u_char mx4200_cksum P((char *, int)); static int mx4200_jday P((int, int, int)); static void mx4200_debug P((struct peer *, char *, ...)) __attribute__ ((format (printf, 2, 3))); static int mx4200_pps P((struct peer *)); /* * Transfer vector */ struct refclock refclock_mx4200 = { mx4200_start, /* start up driver */ mx4200_shutdown, /* shut down driver */ mx4200_poll, /* transmit poll message */ noentry, /* not used (old mx4200_control) */ noentry, /* initialize driver (not used) */ noentry, /* not used (old mx4200_buginfo) */ NOFLAGS /* not used */ }; /* * mx4200_start - open the devices and initialize data for processing */ static int mx4200_start( int unit, struct peer *peer ) { register struct mx4200unit *up; struct refclockproc *pp; int fd; char gpsdev[20]; /* * Open serial port */ (void)sprintf(gpsdev, DEVICE, unit); if (!(fd = refclock_open(gpsdev, SPEED232, LDISC_PPS))) { return (0); } /* * Allocate unit structure */ if (!(up = (struct mx4200unit *) emalloc(sizeof(struct mx4200unit)))) { perror("emalloc"); (void) close(fd); return (0); } memset((char *)up, 0, sizeof(struct mx4200unit)); pp = peer->procptr; pp->io.clock_recv = mx4200_receive; pp->io.srcclock = (caddr_t)peer; pp->io.datalen = 0; pp->io.fd = fd; if (!io_addclock(&pp->io)) { (void) close(fd); free(up); return (0); } pp->unitptr = (caddr_t)up; /* * Initialize miscellaneous variables */ peer->precision = PRECISION; pp->clockdesc = DESCRIPTION; memcpy((char *)&pp->refid, REFID, 4); /* Ensure the receiver is properly configured */ return mx4200_config(peer); } /* * mx4200_shutdown - shut down the clock */ static void mx4200_shutdown( int unit, struct peer *peer ) { register struct mx4200unit *up; struct refclockproc *pp; pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; io_closeclock(&pp->io); free(up); } /* * mx4200_config - Configure the receiver */ static int mx4200_config( struct peer *peer ) { char tr_mode; int add_mode; register struct mx4200unit *up; struct refclockproc *pp; int mode; pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; /* * Initialize the unit variables * * STRANGE BEHAVIOUR WARNING: The fudge flags are not available * at the time mx4200_start is called. These are set later, * and so the code must be prepared to handle changing flags. */ up->sloppyclockflag = pp->sloppyclockflag; if (pp->sloppyclockflag & CLK_FLAG2) { up->moving = 1; /* Receiver on mobile platform */ msyslog(LOG_DEBUG, "mx4200_config: mobile platform"); } else { up->moving = 0; /* Static Installation */ } up->pollcnt = 2; up->polled = 0; up->known = 0; up->avg_lat = 0.0; up->avg_lon = 0.0; up->avg_alt = 0.0; up->central_meridian = NOT_INITIALIZED; up->N_fixes = 0.0; up->last_leap = 0; /* LEAP_NOWARNING */ up->clamp_time = current_time + (AVGING_TIME * 60 * 60); up->log_time = current_time + SLEEPTIME; if (time_pps_create(pp->io.fd, &up->pps_h) < 0) { perror("time_pps_create"); msyslog(LOG_ERR, "mx4200_config: time_pps_create failed: %m"); return (0); } if (time_pps_getcap(up->pps_h, &mode) < 0) { msyslog(LOG_ERR, "mx4200_config: time_pps_getcap failed: %m"); return (0); } if (time_pps_getparams(up->pps_h, &up->pps_p) < 0) { msyslog(LOG_ERR, "mx4200_config: time_pps_getparams failed: %m"); return (0); } /* nb. only turn things on, if someone else has turned something * on before we get here, leave it alone! */ up->pps_p.mode = PPS_CAPTUREASSERT | PPS_TSFMT_TSPEC; up->pps_p.mode &= mode; /* only set what is legal */ if (time_pps_setparams(up->pps_h, &up->pps_p) < 0) { perror("time_pps_setparams"); msyslog(LOG_ERR, "mx4200_config: time_pps_setparams failed: %m"); exit(1); } if (time_pps_kcbind(up->pps_h, PPS_KC_HARDPPS, PPS_CAPTUREASSERT, PPS_TSFMT_TSPEC) < 0) { perror("time_pps_kcbind"); msyslog(LOG_ERR, "mx4200_config: time_pps_kcbind failed: %m"); exit(1); } /* * "007" Control Port Configuration * Zero the output list (do it twice to flush possible junk) */ mx4200_send(peer, "%s,%03d,,%d,,,,,,", pmvxg, PMVXG_S_PORTCONF, /* control port output block Label */ 1); /* clear current output control list (1=yes) */ /* add/delete sentences from list */ /* must be null */ /* sentence output rate (sec) */ /* precision for position output */ /* nmea version for cga & gll output */ /* pass-through control */ mx4200_send(peer, "%s,%03d,,%d,,,,,,", pmvxg, PMVXG_S_PORTCONF, 1); /* * Request software configuration so we can syslog the firmware version */ mx4200_send(peer, "%s,%03d", "CDGPQ", PMVXG_D_SOFTCONF); /* * "001" Initialization/Mode Control, Part A * Where ARE we? */ mx4200_send(peer, "%s,%03d,,,,,,,,,,", pmvxg, PMVXG_S_INITMODEA); /* day of month */ /* month of year */ /* year */ /* gmt */ /* latitude DDMM.MMMM */ /* north/south */ /* longitude DDDMM.MMMM */ /* east/west */ /* height */ /* Altitude Reference 1=MSL */ /* * "001" Initialization/Mode Control, Part B * Start off in 2d/3d coast mode, holding altitude to last known * value if only 3 satellites available. */ mx4200_send(peer, "%s,%03d,%d,,%.1f,%.1f,%d,%d,%d,%c,%d", pmvxg, PMVXG_S_INITMODEB, 3, /* 2d/3d coast */ /* reserved */ 0.1, /* hor accel fact as per Steve (m/s**2) */ 0.1, /* ver accel fact as per Steve (m/s**2) */ 10, /* vdop */ 10, /* hdop limit as per Steve */ 5, /* elevation limit as per Steve (deg) */ 'U', /* time output mode (UTC) */ 0); /* local time offset from gmt (HHHMM) */ /* * "023" Time Recovery Configuration * Get UTC time from a stationary receiver. * (Set field 1 'D' == dynamic if we are on a moving platform). * (Set field 1 'S' == static if we are not moving). * (Set field 1 'K' == known position if we can initialize lat/lon/alt). */ if (pp->sloppyclockflag & CLK_FLAG2) up->moving = 1; /* Receiver on mobile platform */ else up->moving = 0; /* Static Installation */ up->pollcnt = 2; if (up->moving) { /* dynamic: solve for pos, alt, time, while moving */ tr_mode = 'D'; } else { /* static: solve for pos, alt, time, while stationary */ tr_mode = 'S'; } mx4200_send(peer, "%s,%03d,%c,%c,%c,%d,%d,%d,", pmvxg, PMVXG_S_TRECOVCONF, tr_mode, /* time recovery mode (see above ) */ 'U', /* synchronize to UTC */ 'A', /* always output a time pulse */ 500, /* max time error in ns */ 0, /* user bias in ns */ 1); /* output "830" sentences to control port */ /* Multi-satellite mode */ /* * Output position information (to calculate fixed installation * location) only if we are not moving */ if (up->moving) { add_mode = 2; /* delete from list */ } else { add_mode = 1; /* add to list */ } /* * "007" Control Port Configuration * Output "021" position, height, velocity reports */ mx4200_send(peer, "%s,%03d,%03d,%d,%d,,%d,,,", pmvxg, PMVXG_S_PORTCONF, PMVXG_D_PHV, /* control port output block Label */ 0, /* clear current output control list (0=no) */ add_mode, /* add/delete sentences from list (1=add, 2=del) */ /* must be null */ INTERVAL); /* sentence output rate (sec) */ /* precision for position output */ /* nmea version for cga & gll output */ /* pass-through control */ return (1); } /* * mx4200_ref - Reconfigure unit as a reference station at a known position. */ static void mx4200_ref( struct peer *peer ) { register struct mx4200unit *up; struct refclockproc *pp; double minute, lat, lon, alt; char lats[16], lons[16]; char nsc, ewc; pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; /* Should never happen! */ if (up->moving) return; /* * Set up to output status information in the near future */ up->log_time = current_time + SLEEPTIME; /* * "007" Control Port Configuration * Stop outputting "021" position, height, velocity reports */ mx4200_send(peer, "%s,%03d,%03d,%d,%d,,,,,", pmvxg, PMVXG_S_PORTCONF, PMVXG_D_PHV, /* control port output block Label */ 0, /* clear current output control list (0=no) */ 2); /* add/delete sentences from list (2=delete) */ /* must be null */ /* sentence output rate (sec) */ /* precision for position output */ /* nmea version for cga & gll output */ /* pass-through control */ /* * "001" Initialization/Mode Control, Part B * Put receiver in fully-constrained 2d nav mode */ mx4200_send(peer, "%s,%03d,%d,,%.1f,%.1f,%d,%d,%d,%c,%d", pmvxg, PMVXG_S_INITMODEB, 2, /* 2d nav */ /* reserved */ 0.1, /* hor accel fact as per Steve (m/s**2) */ 0.1, /* ver accel fact as per Steve (m/s**2) */ 10, /* vdop */ 10, /* hdop limit as per Steve */ 5, /* elevation limit as per Steve (deg) */ 'U', /* time output mode (UTC) */ 0); /* local time offset from gmt (HHHMM) */ /* * "023" Time Recovery Configuration * Get UTC time from a stationary receiver. Solve for time only. * This should improve the time resolution dramatically. */ mx4200_send(peer, "%s,%03d,%c,%c,%c,%d,%d,%d,", pmvxg, PMVXG_S_TRECOVCONF, 'K', /* known position: solve for time only */ 'U', /* synchronize to UTC */ 'A', /* always output a time pulse */ 500, /* max time error in ns */ 0, /* user bias in ns */ 1); /* output "830" sentences to control port */ /* Multi-satellite mode */ /* * "000" Initialization/Mode Control - Part A * Fix to our averaged position. */ if (up->central_meridian != NOT_INITIALIZED) { up->avg_lon += up->central_meridian; if (up->avg_lon < -180.0) up->avg_lon += 360.0; if (up->avg_lon > 180.0) up->avg_lon -= 360.0; } if (up->avg_lat >= 0.0) { lat = up->avg_lat; nsc = 'N'; } else { lat = up->avg_lat * (-1.0); nsc = 'S'; } if (up->avg_lon >= 0.0) { lon = up->avg_lon; ewc = 'E'; } else { lon = up->avg_lon * (-1.0); ewc = 'W'; } alt = up->avg_alt; minute = (lat - (double)(int)lat) * 60.0; sprintf(lats,"%02d%02.4f", (int)lat, minute); minute = (lon - (double)(int)lon) * 60.0; sprintf(lons,"%03d%02.4f", (int)lon, minute); mx4200_send(peer, "%s,%03d,,,,,%s,%c,%s,%c,%.2f,%d", pmvxg, PMVXG_S_INITMODEA, /* day of month */ /* month of year */ /* year */ /* gmt */ lats, /* latitude DDMM.MMMM */ nsc, /* north/south */ lons, /* longitude DDDMM.MMMM */ ewc, /* east/west */ alt, /* Altitude */ 1); /* Altitude Reference (0=WGS84 ellipsoid, 1=MSL geoid)*/ msyslog(LOG_DEBUG, "mx4200: reconfig to fixed location: %s %c, %s %c, %.2f m", lats, nsc, lons, ewc, alt ); } /* * mx4200_poll - mx4200 watchdog routine */ static void mx4200_poll( int unit, struct peer *peer ) { register struct mx4200unit *up; struct refclockproc *pp; pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; /* * You don't need to poll this clock. It puts out timecodes * once per second. If asked for a timestamp, take note. * The next time a timecode comes in, it will be fed back. */ /* * If we haven't had a response in a while, reset the receiver. */ if (up->pollcnt > 0) { up->pollcnt--; } else { refclock_report(peer, CEVNT_TIMEOUT); /* * Request a "000" status message which should trigger a * reconfig */ mx4200_send(peer, "%s,%03d", "CDGPQ", /* query from CDU to GPS */ PMVXG_D_STATUS); /* label of desired sentence */ } /* * polled every 64 seconds. Ask mx4200_receive to hand in * a timestamp. */ up->polled = 1; pp->polls++; /* * Output receiver status information. */ if ((up->log_time > 0) && (current_time > up->log_time)) { up->log_time = 0; /* * Output the following messages once, for debugging. * "004" Mode Data * "523" Time Recovery Parameters */ mx4200_send(peer, "%s,%03d", "CDGPQ", PMVXG_D_MODEDATA); mx4200_send(peer, "%s,%03d", "CDGPQ", PMVXG_D_TRECOVUSEAGE); } } static char char2hex[] = "0123456789ABCDEF"; /* * mx4200_receive - receive gps data */ static void mx4200_receive( struct recvbuf *rbufp ) { register struct mx4200unit *up; struct refclockproc *pp; struct peer *peer; char *cp; int sentence_type; u_char ck; /* * Initialize pointers and read the timecode and timestamp. */ peer = (struct peer *)rbufp->recv_srcclock; pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; /* * If operating mode has been changed, then reinitialize the receiver * before doing anything else. */ if ((pp->sloppyclockflag & CLK_FLAG2) != (up->sloppyclockflag & CLK_FLAG2)) { up->sloppyclockflag = pp->sloppyclockflag; mx4200_debug(peer, "mx4200_receive: mode switch: reset receiver\n"); mx4200_config(peer); return; } up->sloppyclockflag = pp->sloppyclockflag; /* * Read clock output. Automatically handles STREAMS, CLKLDISC. */ pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &pp->lastrec); /* * There is a case where <cr><lf> generates 2 timestamps. */ if (pp->lencode == 0) return; up->pollcnt = 2; pp->a_lastcode[pp->lencode] = '\0'; record_clock_stats(&peer->srcadr, pp->a_lastcode); mx4200_debug(peer, "mx4200_receive: %d %s\n", pp->lencode, pp->a_lastcode); /* * The structure of the control port sentences is based on the * NMEA-0183 Standard for interfacing Marine Electronics * Navigation Devices (Version 1.5) * * $PMVXG,XXX, ....................*CK<cr><lf> * * $ Sentence Start Identifier (reserved char) * (Start-of-Sentence Identifier) * P Special ID (Proprietary) * MVX Originator ID (Magnavox) * G Interface ID (GPS) * , Field Delimiters (reserved char) * XXX Sentence Type * ...... Data * * Checksum Field Delimiter (reserved char) * CK Checksum * <cr><lf> Carriage-Return/Line Feed (reserved chars) * (End-of-Sentence Identifier) * * Reject if any important landmarks are missing. */ cp = pp->a_lastcode + pp->lencode - 3; if (cp < pp->a_lastcode || *pp->a_lastcode != '$' || cp[0] != '*' ) { mx4200_debug(peer, "mx4200_receive: bad format\n"); refclock_report(peer, CEVNT_BADREPLY); return; } /* * Check and discard the checksum */ ck = mx4200_cksum(&pp->a_lastcode[1], pp->lencode - 4); if (char2hex[ck >> 4] != cp[1] || char2hex[ck & 0xf] != cp[2]) { mx4200_debug(peer, "mx4200_receive: bad checksum\n"); refclock_report(peer, CEVNT_BADREPLY); return; } *cp = '\0'; /* * Get the sentence type. */ sentence_type = 0; if ((cp = strchr(pp->a_lastcode, ',')) == NULL) { mx4200_debug(peer, "mx4200_receive: no sentence\n"); refclock_report(peer, CEVNT_BADREPLY); return; } cp++; sentence_type = strtol(cp, &cp, 10); /* * Process the sentence according to its type. */ switch (sentence_type) { /* * "000" Status message */ case PMVXG_D_STATUS: /* * XXX * Since we configure the receiver to not give us status * messages and since the receiver outputs status messages by * default after being reset to factory defaults when sent the * "$PMVXG,018,C\r\n" message, any status message we get * indicates the reciever needs to be initialized; thus, it is * not necessary to decode the status message. */ if ((cp = mx4200_parse_s(peer)) != NULL) { mx4200_debug(peer, "mx4200_receive: status: %s\n", cp); } mx4200_debug(peer, "mx4200_receive: reset receiver\n"); mx4200_config(peer); break; /* * "021" Position, Height, Velocity message, * if we are still averaging our position */ case PMVXG_D_PHV: if (!up->known) { /* * Parse the message, calculating our averaged position. */ if ((cp = mx4200_parse_p(peer)) != NULL) { mx4200_debug(peer, "mx4200_receive: pos: %s\n", cp); return; } mx4200_debug(peer, "mx4200_receive: position avg %f %.9f %.9f %.4f\n", up->N_fixes, up->avg_lat, up->avg_lon, up->avg_alt); /* * Reinitialize as a reference station * if position is well known. */ if (current_time > up->clamp_time) { up->known++; mx4200_debug(peer, "mx4200_receive: reconfiguring!\n"); mx4200_ref(peer); } } break; /* * Print to the syslog: * "004" Mode Data * "030" Software Configuration * "523" Time Recovery Parameters Currently in Use */ case PMVXG_D_MODEDATA: case PMVXG_D_SOFTCONF: case PMVXG_D_TRECOVUSEAGE: if ((cp = mx4200_parse_s(peer)) != NULL) { mx4200_debug(peer, "mx4200_receive: multi-record: %s\n", cp); } break; /* * "830" Time Recovery Results message */ case PMVXG_D_TRECOVOUT: /* * Capture the last PPS signal. * Precision timestamp is returned in pp->lastrec */ if (mx4200_pps(peer) != NULL) { mx4200_debug(peer, "mx4200_receive: pps failure\n"); refclock_report(peer, CEVNT_FAULT); return; } /* * Parse the time recovery message, and keep the info * to print the pretty billboards. */ if ((cp = mx4200_parse_t(peer)) != NULL) { mx4200_debug(peer, "mx4200_receive: time: %s\n", cp); refclock_report(peer, CEVNT_BADREPLY); return; } /* * Add the new sample to a median filter. */ if (!refclock_process(pp)) { mx4200_debug(peer,"mx4200_receive: offset: %.6f\n", pp->offset); refclock_report(peer, CEVNT_BADTIME); return; } /* * The clock will blurt a timecode every second but we only * want one when polled. If we havn't been polled, bail out. */ if (!up->polled) return; /* * Return offset and dispersion to control module. We use * lastrec as both the reference time and receive time in * order to avoid being cute, like setting the reference time * later than the receive time, which may cause a paranoid * protocol module to chuck out the data. */ mx4200_debug(peer, "mx4200_receive: process time: "); mx4200_debug(peer, "%4d-%03d %02d:%02d:%02d at %s, %.6f\n", pp->year, pp->day, pp->hour, pp->minute, pp->second, prettydate(&pp->lastrec), pp->offset); pp->lastref = pp->lastrec; refclock_receive(peer); /* * We have succeeded in answering the poll. * Turn off the flag and return */ up->polled = 0; break; /* * Ignore all other sentence types */ default: break; } /* switch (sentence_type) */ return; } /* * Parse a mx4200 time recovery message. Returns a string if error. * * A typical message looks like this. Checksum has already been stripped. * * $PMVXG,830,T,YYYY,MM,DD,HH:MM:SS,U,S,FFFFFF,PPPPP,BBBBBB,LL * * Field Field Contents * ----- -------------- * Block Label: $PMVXG * Sentence Type: 830=Time Recovery Results * This sentence is output approximately 1 second * preceding the 1PPS output. It indicates the * exact time of the next pulse, whether or not the * time mark will be valid (based on operator-specified * error tolerance), the time to which the pulse is * synchronized, the receiver operating mode, * and the time error of the *last* 1PPS output. * 1 char Time Mark Valid: T=Valid, F=Not Valid * 2 int Year: 1993- * 3 int Month of Year: 1-12 * 4 int Day of Month: 1-31 * 5 int Time of Day: HH:MM:SS * 6 char Time Synchronization: U=UTC, G=GPS * 7 char Time Recovery Mode: D=Dynamic, S=Static, * K=Known Position, N=No Time Recovery * 8 int Oscillator Offset: The filter's estimate of the oscillator * frequency error, in parts per billion (ppb). * 9 int Time Mark Error: The computed error of the *last* pulse * output, in nanoseconds. * 10 int User Time Bias: Operator specified bias, in nanoseconds * 11 int Leap Second Flag: Indicates that a leap second will * occur. This value is usually zero, except during * the week prior to the leap second occurrence, when * this value will be set to +1 or -1. A value of * +1 indicates that GPS time will be 1 second * further ahead of UTC time. * */ static char * mx4200_parse_t( struct peer *peer ) { struct refclockproc *pp; struct mx4200unit *up; char time_mark_valid, time_sync, op_mode; int sentence_type, valid; int year, day_of_year, month, day_of_month; int hour, minute, second, leapsec; int oscillator_offset, time_mark_error, time_bias; pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; leapsec = 0; /* Not all receivers output leap second warnings (!) */ sscanf(pp->a_lastcode, "$PMVXG,%d,%c,%d,%d,%d,%d:%d:%d,%c,%c,%d,%d,%d,%d", &sentence_type, &time_mark_valid, &year, &month, &day_of_month, &hour, &minute, &second, &time_sync, &op_mode, &oscillator_offset, &time_mark_error, &time_bias, &leapsec); if (sentence_type != PMVXG_D_TRECOVOUT) return ("wrong rec-type"); switch (time_mark_valid) { case 'T': valid = 1; break; case 'F': valid = 0; break; default: return ("bad pulse-valid"); } switch (time_sync) { case 'G': return ("synchronized to GPS; should be UTC"); case 'U': break; /* UTC -> ok */ default: return ("not synchronized to UTC"); } /* * Check for insane time (allow for possible leap seconds) */ if (second > 60 || minute > 59 || hour > 23 || second < 0 || minute < 0 || hour < 0) { mx4200_debug(peer, "mx4200_parse_t: bad time %02d:%02d:%02d", hour, minute, second); if (leapsec != 0) mx4200_debug(peer, " (leap %+d\n)", leapsec); mx4200_debug(peer, "\n"); refclock_report(peer, CEVNT_BADTIME); return ("bad time"); } if ( second == 60 ) { msyslog(LOG_DEBUG, "mx4200: leap second! %02d:%02d:%02d", hour, minute, second); } /* * Check for insane date * (Certainly can't be any year before this code was last altered!) */ if (day_of_month > 31 || month > 12 || day_of_month < 1 || month < 1 || year < YEAR_LAST_MODIFIED) { mx4200_debug(peer, "mx4200_parse_t: bad date (%4d-%02d-%02d)\n", year, month, day_of_month); refclock_report(peer, CEVNT_BADDATE); return ("bad date"); } /* * Silly Hack for MX4200: * ASCII message is for *next* 1PPS signal, but we have the * timestamp for the *last* 1PPS signal. So we have to subtract * a second. Discard if we are on a month boundary to avoid * possible leap seconds and leap days. */ second--; if (second < 0) { second = 59; minute--; if (minute < 0) { minute = 59; hour--; if (hour < 0) { hour = 23; day_of_month--; if (day_of_month < 1) { return ("sorry, month boundary"); } } } } /* * Calculate Julian date */ if (!(day_of_year = mx4200_jday(year, month, day_of_month))) { mx4200_debug(peer, "mx4200_parse_t: bad julian date %d (%4d-%02d-%02d)\n", day_of_year, year, month, day_of_month); refclock_report(peer, CEVNT_BADDATE); return("invalid julian date"); } /* * Setup leap second indicator */ switch (leapsec) { case 0: pp->leap = LEAP_NOWARNING; break; case 1: pp->leap = LEAP_ADDSECOND; break; case -1: pp->leap = LEAP_DELSECOND; break; default: pp->leap = LEAP_NOTINSYNC; } /* * Any change to the leap second warning status? */ if (leapsec != up->last_leap ) { msyslog(LOG_DEBUG, "mx4200: leap second warning: %d to %d (%d)", up->last_leap, leapsec, pp->leap); } up->last_leap = leapsec; /* * Copy time data for billboard monitoring. */ pp->year = year; pp->day = day_of_year; pp->hour = hour; pp->minute = minute; pp->second = second; /* * Toss if sentence is marked invalid */ if (!valid || pp->leap == LEAP_NOTINSYNC) { mx4200_debug(peer, "mx4200_parse_t: time mark not valid\n"); refclock_report(peer, CEVNT_BADTIME); return ("pulse invalid"); } return (NULL); } /* * Calculate the checksum */ static u_char mx4200_cksum( register char *cp, register int n ) { register u_char ck; for (ck = 0; n-- > 0; cp++) ck ^= *cp; return (ck); } /* * Tables to compute the day of year. 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}; /* * Calculate the the Julian Day */ static int mx4200_jday( int year, int month, int day_of_month ) { register int day, i; int leap_year; /* * Is this a leap year ? */ if (year % 4) { leap_year = 0; /* FALSE */ } else { if (year % 100) { leap_year = 1; /* TRUE */ } else { if (year % 400) { leap_year = 0; /* FALSE */ } else { leap_year = 1; /* TRUE */ } } } /* * Calculate the Julian Date */ day = day_of_month; if (leap_year) { /* a leap year */ if (day > day2tab[month - 1]) { return (0); } for (i = 0; i < month - 1; i++) day += day2tab[i]; } else { /* not a leap year */ if (day > day1tab[month - 1]) { return (0); } for (i = 0; i < month - 1; i++) day += day1tab[i]; } return (day); } /* * Parse a mx4200 position/height/velocity sentence. * * A typical message looks like this. Checksum has already been stripped. * * $PMVXG,021,SSSSSS.SS,DDMM.MMMM,N,DDDMM.MMMM,E,HHHHH.H,GGGG.G,EEEE.E,WWWW.W,MM * * Field Field Contents * ----- -------------- * Block Label: $PMVXG * Sentence Type: 021=Position, Height Velocity Data * This sentence gives the receiver position, height, * navigation mode, and velocity north/east. * *This sentence is intended for post-analysis * applications.* * 1 float UTC measurement time (seconds into week) * 2 float WGS-84 Lattitude (degrees, minutes) * 3 char N=North, S=South * 4 float WGS-84 Longitude (degrees, minutes) * 5 char E=East, W=West * 6 float Altitude (meters above mean sea level) * 7 float Geoidal height (meters) * 8 float East velocity (m/sec) * 9 float West Velocity (m/sec) * 10 int Navigation Mode * Mode if navigating: * 1 = Position from remote device * 2 = 2-D position * 3 = 3-D position * 4 = 2-D differential position * 5 = 3-D differential position * 6 = Static * 8 = Position known -- reference station * 9 = Position known -- Navigator * Mode if not navigating: * 51 = Too few satellites * 52 = DOPs too large * 53 = Position STD too large * 54 = Velocity STD too large * 55 = Too many iterations for velocity * 56 = Too many iterations for position * 57 = 3 sat startup failed * 58 = Command abort */ static char * mx4200_parse_p( struct peer *peer ) { struct refclockproc *pp; struct mx4200unit *up; int sentence_type, mode; double mtime, lat, lon, alt, geoid, vele, veln; char north_south, east_west; pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; /* Should never happen! */ if (up->moving) return ("mobile platform - no pos!"); sscanf ( pp->a_lastcode, "$PMVXG,%d,%lf,%lf,%c,%lf,%c,%lf,%lf,%lf,%lf,%d", &sentence_type, &mtime, &lat, &north_south, &lon, &east_west, &alt, &geoid, &vele, &veln, &mode); /* Sentence type */ if (sentence_type != PMVXG_D_PHV) return ("wrong rec-type"); /* * return if not navigating */ if (mode > 10) return ("not navigating"); if (mode != 3 && mode != 5) return ("not navigating in 3D"); /* Latitude (always +ve) and convert DDMM.MMMM to decimal */ if (lat < 0.0) return ("negative latitude"); if (lat > 9000.0) lat = 9000.0; lat *= 0.01; lat = ((int)lat) + (((lat - (int)lat)) * 1.6666666666666666); /* North/South */ switch (north_south) { case 'N': break; case 'S': lat *= -1.0; break; default: return ("invalid north/south indicator"); } /* Longitude (always +ve) and convert DDDMM.MMMM to decimal */ if (lon < 0.0) return ("negative longitude"); if (lon > 180.0) lon = 180.0; lon *= 0.01; lon = ((int)lon) + (((lon - (int)lon)) * 1.6666666666666666); /* East/West */ switch (east_west) { case 'E': break; case 'W': lon *= -1.0; break; default: return ("invalid east/west indicator"); } /* * Normalize longitude to near 0 degrees. * Assume all data are clustered around first reading. */ if (up->central_meridian == NOT_INITIALIZED) { up->central_meridian = lon; mx4200_debug(peer, "mx4200_receive: central meridian = %.9f \n", up->central_meridian); } lon -= up->central_meridian; if (lon < -180.0) lon += 360.0; if (lon > 180.0) lon -= 360.0; /* * Calculate running averages */ up->avg_lon = (up->N_fixes * up->avg_lon) + lon; up->avg_lat = (up->N_fixes * up->avg_lat) + lat; up->avg_alt = (up->N_fixes * up->avg_alt) + alt; up->N_fixes += 1.0; up->avg_lon /= up->N_fixes; up->avg_lat /= up->N_fixes; up->avg_alt /= up->N_fixes; mx4200_debug(peer, "mx4200_receive: position rdg %.0f: %.9f %.9f %.4f (CM=%.9f)\n", up->N_fixes, lat, lon, alt, up->central_meridian); return (NULL); } /* * Parse a mx4200 Status sentence * Parse a mx4200 Mode Data sentence * Parse a mx4200 Software Configuration sentence * Parse a mx4200 Time Recovery Parameters Currently in Use sentence * (used only for logging raw strings) * * A typical message looks like this. Checksum has already been stripped. * * $PMVXG,000,XXX,XX,X,HHMM,X * * Field Field Contents * ----- -------------- * Block Label: $PMVXG * Sentence Type: 000=Status. * Returns status of the receiver to the controller. * 1 Current Receiver Status: * ACQ = Satellite re-acquisition * ALT = Constellation selection * COR = Providing corrections (for reference stations only) * IAC = Initial acquisition * IDL = Idle, no satellites * NAV = Navigation * STS = Search the Sky (no almanac available) * TRK = Tracking * 2 Number of satellites that should be visible * 3 Number of satellites being tracked * 4 Time since last navigation status if not currently navigating * (hours, minutes) * 5 Initialization status: * 0 = Waiting for initialization parameters * 1 = Initialization completed * * A typical message looks like this. Checksum has already been stripped. * * $PMVXG,004,C,R,D,H.HH,V.VV,TT,HHHH,VVVV,T * * Field Field Contents * ----- -------------- * Block Label: $PMVXG * Sentence Type: 004=Software Configuration. * Defines the navigation mode and criteria for * acceptable navigation for the receiver. * 1 Constrain Altitude Mode: * 0 = Auto. Constrain altitude (2-D solution) and use * manual altitude input when 3 sats avalable. Do * not constrain altitude (3-D solution) when 4 sats * available. * 1 = Always constrain altitude (2-D solution). * 2 = Never constrain altitude (3-D solution). * 3 = Coast. Constrain altitude (2-D solution) and use * last GPS altitude calculation when 3 sats avalable. * Do not constrain altitude (3-D solution) when 4 sats * available. * 2 Altitude Reference: (always 0 for MX4200) * 0 = Ellipsoid * 1 = Geoid (MSL) * 3 Differential Navigation Control: * 0 = Disabled * 1 = Enabled * 4 Horizontal Acceleration Constant (m/sec**2) * 5 Vertical Acceleration Constant (m/sec**2) (0 for MX4200) * 6 Tracking Elevation Limit (degrees) * 7 HDOP Limit * 8 VDOP Limit * 9 Time Output Mode: * U = UTC * L = Local time * 10 Local Time Offset (minutes) (absent on MX4200) * * A typical message looks like this. Checksum has already been stripped. * * $PMVXG,030,NNNN,FFF * * Field Field Contents * ----- -------------- * Block Label: $PMVXG * Sentence Type: 030=Software Configuration. * This sentence contains the navigation processor * and baseband firmware version numbers. * 1 Nav Processor Version Number * 2 Baseband Firmware Version Number * * A typical message looks like this. Checksum has already been stripped. * * $PMVXG,523,M,S,M,EEEE,BBBBBB,C,R * * Field Field Contents * ----- -------------- * Block Label: $PMVXG * Sentence Type: 523=Time Recovery Parameters Currently in Use. * This sentence contains the configuration of the * time recovery feature of the receiver. * 1 Time Recovery Mode: * D = Dynamic; solve for position and time while moving * S = Static; solve for position and time while stationary * K = Known position input, solve for time only * N = No time recovery * 2 Time Synchronization: * U = UTC time * G = GPS time * 3 Time Mark Mode: * A = Always output a time pulse * V = Only output time pulse if time is valid (as determined * by Maximum Time Error) * 4 Maximum Time Error - the maximum error (in nanoseconds) for * which a time mark will be considered valid. * 5 User Time Bias - external bias in nanoseconds * 6 Time Message Control: * 0 = Do not output the time recovery message * 1 = Output the time recovery message (record 830) to * Control port * 2 = Output the time recovery message (record 830) to * Equipment port * 7 Reserved * 8 Position Known PRN (absent on MX 4200) * */ static char * mx4200_parse_s( struct peer *peer ) { struct refclockproc *pp; struct mx4200unit *up; int sentence_type; pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; sscanf ( pp->a_lastcode, "$PMVXG,%d", &sentence_type); /* Sentence type */ switch (sentence_type) { case PMVXG_D_STATUS: msyslog(LOG_DEBUG, "mx4200: status: %s", pp->a_lastcode); break; case PMVXG_D_MODEDATA: msyslog(LOG_DEBUG, "mx4200: mode data: %s", pp->a_lastcode); break; case PMVXG_D_SOFTCONF: msyslog(LOG_DEBUG, "mx4200: firmware configuration: %s", pp->a_lastcode); break; case PMVXG_D_TRECOVUSEAGE: msyslog(LOG_DEBUG, "mx4200: time recovery parms: %s", pp->a_lastcode); break; default: return ("wrong rec-type"); } return (NULL); } /* * Process a PPS signal, placing a timestamp in pp->lastrec. */ static int mx4200_pps( struct peer *peer ) { int temp_serial; struct refclockproc *pp; struct mx4200unit *up; struct timespec timeout; pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; /* * Grab the timestamp of the PPS signal. */ temp_serial = up->pps_i.assert_sequence; timeout.tv_sec = 0; timeout.tv_nsec = 0; if (time_pps_fetch(up->pps_h, PPS_TSFMT_TSPEC, &(up->pps_i), &timeout) < 0) { mx4200_debug(peer, "mx4200_pps: time_pps_fetch: serial=%ul, %s\n", (unsigned long)up->pps_i.assert_sequence, strerror(errno)); refclock_report(peer, CEVNT_FAULT); return(1); } if (temp_serial == up->pps_i.assert_sequence) { mx4200_debug(peer, "mx4200_pps: assert_sequence serial not incrementing: %ul\n", (unsigned long)up->pps_i.assert_sequence); refclock_report(peer, CEVNT_FAULT); return(1); } /* * Check pps serial number against last one */ if (up->lastserial + 1 != up->pps_i.assert_sequence && up->lastserial != 0) { if (up->pps_i.assert_sequence == up->lastserial) { mx4200_debug(peer, "mx4200_pps: no new pps event\n"); } else { mx4200_debug(peer, "mx4200_pps: missed %ul pps events\n", up->pps_i.assert_sequence - up->lastserial - 1UL); } refclock_report(peer, CEVNT_FAULT); } up->lastserial = up->pps_i.assert_sequence; /* * Return the timestamp in pp->lastrec */ pp->lastrec.l_ui = up->pps_i.assert_timestamp.tv_sec + (u_int32) JAN_1970; pp->lastrec.l_uf = ((double)(up->pps_i.assert_timestamp.tv_nsec) * 4.2949672960) + 0.5; return(0); } /* * mx4200_debug - print debug messages */ #if defined(__STDC__) static void mx4200_debug(struct peer *peer, char *fmt, ...) #else static void mx4200_debug(peer, fmt, va_alist) struct peer *peer; char *fmt; #endif /* __STDC__ */ { #ifdef DEBUG va_list ap; struct refclockproc *pp; struct mx4200unit *up; if (debug) { #if defined(__STDC__) va_start(ap, fmt); #else va_start(ap); #endif /* __STDC__ */ pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; /* * Print debug message to stdout * In the future, we may want to get get more creative... */ vprintf(fmt, ap); va_end(ap); } #endif } /* * Send a character string to the receiver. Checksum is appended here. */ #if defined(__STDC__) static void mx4200_send(struct peer *peer, char *fmt, ...) #else static void mx4200_send(peer, fmt, va_alist) struct peer *peer; char *fmt; va_dcl #endif /* __STDC__ */ { struct refclockproc *pp; struct mx4200unit *up; register char *cp; register int n, m; va_list ap; char buf[1024]; u_char ck; #if defined(__STDC__) va_start(ap, fmt); #else va_start(ap); #endif /* __STDC__ */ pp = peer->procptr; up = (struct mx4200unit *)pp->unitptr; cp = buf; *cp++ = '$'; n = VSNPRINTF((cp, sizeof(buf) - 1, fmt, ap)); ck = mx4200_cksum(cp, n); cp += n; ++n; n += SNPRINTF((cp, sizeof(buf) - n - 5, "*%02X\r\n", ck)); m = write(pp->io.fd, buf, (unsigned)n); if (m < 0) msyslog(LOG_ERR, "mx4200_send: write: %m (%s)", buf); mx4200_debug(peer, "mx4200_send: %d %s\n", m, buf); va_end(ap); } #else int refclock_mx4200_bs; #endif /* REFCLOCK */