1/* 2 * This software was developed by the Computer Systems Engineering group 3 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66. 4 * 5 * Copyright (c) 1992 The Regents of the University of California. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Lawrence Berkeley Laboratory. 20 * 4. The name of the University may not be used to endorse or promote 21 * products derived from this software without specific prior 22 * written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 */ 36 37/* 38 * Modified: Marc Brett <marc.brett@westgeo.com> Sept, 1999. 39 * 40 * 1. Added support for alternate PPS schemes, with code mostly 41 * copied from the Oncore driver (Thanks, Poul-Henning Kamp). 42 * This code runs on SunOS 4.1.3 with ppsclock-1.6a1 and Solaris 7. 43 */ 44 45 46#ifdef HAVE_CONFIG_H 47# include <config.h> 48#endif 49 50#if defined(REFCLOCK) && defined(CLOCK_MX4200) && defined(HAVE_PPSAPI) 51 52#include "ntpd.h" 53#include "ntp_io.h" 54#include "ntp_refclock.h" 55#include "ntp_unixtime.h" 56#include "ntp_stdlib.h" 57 58#include <stdio.h> 59#include <ctype.h> 60 61#include "mx4200.h" 62 63#ifdef HAVE_SYS_TERMIOS_H 64# include <sys/termios.h> 65#endif 66#ifdef HAVE_SYS_PPSCLOCK_H 67# include <sys/ppsclock.h> 68#endif 69 70#include "ntp_sprintf.h" 71 72#ifndef HAVE_STRUCT_PPSCLOCKEV 73struct ppsclockev { 74# ifdef HAVE_STRUCT_TIMESPEC 75 struct timespec tv; 76# else 77 struct timeval tv; 78# endif 79 u_int serial; 80}; 81#endif /* ! HAVE_STRUCT_PPSCLOCKEV */ 82 83#ifdef HAVE_PPSAPI 84# include "ppsapi_timepps.h" 85#endif /* HAVE_PPSAPI */ 86 87/* 88 * This driver supports the Magnavox Model MX 4200 GPS Receiver 89 * adapted to precision timing applications. It requires the 90 * ppsclock line discipline or streams module described in the 91 * Line Disciplines and Streams Drivers page. It also requires a 92 * gadget box and 1-PPS level converter, such as described in the 93 * Pulse-per-second (PPS) Signal Interfacing page. 94 * 95 * It's likely that other compatible Magnavox receivers such as the 96 * MX 4200D, MX 9212, MX 9012R, MX 9112 will be supported by this code. 97 */ 98 99/* 100 * Check this every time you edit the code! 101 */ 102#define YEAR_LAST_MODIFIED 2000 103 104/* 105 * GPS Definitions 106 */ 107#define DEVICE "/dev/gps%d" /* device name and unit */ 108#define SPEED232 B4800 /* baud */ 109 110/* 111 * Radio interface parameters 112 */ 113#define PRECISION (-18) /* precision assumed (about 4 us) */ 114#define REFID "GPS\0" /* reference id */ 115#define DESCRIPTION "Magnavox MX4200 GPS Receiver" /* who we are */ 116#define DEFFUDGETIME 0 /* default fudge time (ms) */ 117 118#define SLEEPTIME 32 /* seconds to wait for reconfig to complete */ 119 120/* 121 * Position Averaging. 122 */ 123#define INTERVAL 1 /* Interval between position measurements (s) */ 124#define AVGING_TIME 24 /* Number of hours to average */ 125#define NOT_INITIALIZED -9999. /* initial pivot longitude */ 126 127/* 128 * MX4200 unit control structure. 129 */ 130struct mx4200unit { 131 u_int pollcnt; /* poll message counter */ 132 u_int polled; /* Hand in a time sample? */ 133 u_int lastserial; /* last pps serial number */ 134 struct ppsclockev ppsev; /* PPS control structure */ 135 double avg_lat; /* average latitude */ 136 double avg_lon; /* average longitude */ 137 double avg_alt; /* average height */ 138 double central_meridian; /* central meridian */ 139 double N_fixes; /* Number of position measurements */ 140 int last_leap; /* leap second warning */ 141 u_int moving; /* mobile platform? */ 142 u_long sloppyclockflag; /* fudge flags */ 143 u_int known; /* position known yet? */ 144 u_long clamp_time; /* when to stop postion averaging */ 145 u_long log_time; /* when to print receiver status */ 146 pps_handle_t pps_h; 147 pps_params_t pps_p; 148 pps_info_t pps_i; 149}; 150 151static char pmvxg[] = "PMVXG"; 152 153/* XXX should be somewhere else */ 154#ifdef __GNUC__ 155#if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) 156#ifndef __attribute__ 157#define __attribute__(args) 158#endif /* __attribute__ */ 159#endif /* __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) */ 160#else 161#ifndef __attribute__ 162#define __attribute__(args) 163#endif /* __attribute__ */ 164#endif /* __GNUC__ */ 165/* XXX end */ 166 167/* 168 * Function prototypes 169 */ 170static int mx4200_start (int, struct peer *); 171static void mx4200_shutdown (int, struct peer *); 172static void mx4200_receive (struct recvbuf *); 173static void mx4200_poll (int, struct peer *); 174 175static char * mx4200_parse_t (struct peer *); 176static char * mx4200_parse_p (struct peer *); 177static char * mx4200_parse_s (struct peer *); 178#ifdef QSORT_USES_VOID_P 179int mx4200_cmpl_fp (const void *, const void *); 180#else 181int mx4200_cmpl_fp (const l_fp *, const l_fp *); 182#endif /* not QSORT_USES_VOID_P */ 183static int mx4200_config (struct peer *); 184static void mx4200_ref (struct peer *); 185static void mx4200_send (struct peer *, char *, ...) 186 __attribute__ ((format (printf, 2, 3))); 187static u_char mx4200_cksum (char *, int); 188static int mx4200_jday (int, int, int); 189static void mx4200_debug (struct peer *, char *, ...) 190 __attribute__ ((format (printf, 2, 3))); 191static int mx4200_pps (struct peer *); 192 193/* 194 * Transfer vector 195 */ 196struct refclock refclock_mx4200 = { 197 mx4200_start, /* start up driver */ 198 mx4200_shutdown, /* shut down driver */ 199 mx4200_poll, /* transmit poll message */ 200 noentry, /* not used (old mx4200_control) */ 201 noentry, /* initialize driver (not used) */ 202 noentry, /* not used (old mx4200_buginfo) */ 203 NOFLAGS /* not used */ 204}; 205 206 207 208/* 209 * mx4200_start - open the devices and initialize data for processing 210 */ 211static int 212mx4200_start( 213 int unit, 214 struct peer *peer 215 ) 216{ 217 register struct mx4200unit *up; 218 struct refclockproc *pp; 219 int fd; 220 char gpsdev[20]; 221 222 /* 223 * Open serial port 224 */ 225 (void)sprintf(gpsdev, DEVICE, unit); 226 if (!(fd = refclock_open(gpsdev, SPEED232, LDISC_PPS))) { 227 return (0); 228 } 229 230 /* 231 * Allocate unit structure 232 */ 233 if (!(up = (struct mx4200unit *) emalloc(sizeof(struct mx4200unit)))) { 234 perror("emalloc"); 235 (void) close(fd); 236 return (0); 237 } 238 memset((char *)up, 0, sizeof(struct mx4200unit)); 239 pp = peer->procptr; 240 pp->io.clock_recv = mx4200_receive; 241 pp->io.srcclock = (caddr_t)peer; 242 pp->io.datalen = 0; 243 pp->io.fd = fd; 244 if (!io_addclock(&pp->io)) { 245 (void) close(fd); 246 free(up); 247 return (0); 248 } 249 pp->unitptr = (caddr_t)up; 250 251 /* 252 * Initialize miscellaneous variables 253 */ 254 peer->precision = PRECISION; 255 pp->clockdesc = DESCRIPTION; 256 memcpy((char *)&pp->refid, REFID, 4); 257 258 /* Ensure the receiver is properly configured */ 259 return mx4200_config(peer); 260} 261 262 263/* 264 * mx4200_shutdown - shut down the clock 265 */ 266static void 267mx4200_shutdown( 268 int unit, 269 struct peer *peer 270 ) 271{ 272 register struct mx4200unit *up; 273 struct refclockproc *pp; 274 275 pp = peer->procptr; 276 up = (struct mx4200unit *)pp->unitptr; 277 io_closeclock(&pp->io); 278 free(up); 279} 280 281 282/* 283 * mx4200_config - Configure the receiver 284 */ 285static int 286mx4200_config( 287 struct peer *peer 288 ) 289{ 290 char tr_mode; 291 int add_mode; 292 register struct mx4200unit *up; 293 struct refclockproc *pp; 294 int mode; 295 296 pp = peer->procptr; 297 up = (struct mx4200unit *)pp->unitptr; 298 299 /* 300 * Initialize the unit variables 301 * 302 * STRANGE BEHAVIOUR WARNING: The fudge flags are not available 303 * at the time mx4200_start is called. These are set later, 304 * and so the code must be prepared to handle changing flags. 305 */ 306 up->sloppyclockflag = pp->sloppyclockflag; 307 if (pp->sloppyclockflag & CLK_FLAG2) { 308 up->moving = 1; /* Receiver on mobile platform */ 309 msyslog(LOG_DEBUG, "mx4200_config: mobile platform"); 310 } else { 311 up->moving = 0; /* Static Installation */ 312 } 313 up->pollcnt = 2; 314 up->polled = 0; 315 up->known = 0; 316 up->avg_lat = 0.0; 317 up->avg_lon = 0.0; 318 up->avg_alt = 0.0; 319 up->central_meridian = NOT_INITIALIZED; 320 up->N_fixes = 0.0; 321 up->last_leap = 0; /* LEAP_NOWARNING */ 322 up->clamp_time = current_time + (AVGING_TIME * 60 * 60); 323 up->log_time = current_time + SLEEPTIME; 324 325 if (time_pps_create(pp->io.fd, &up->pps_h) < 0) { 326 perror("time_pps_create"); 327 msyslog(LOG_ERR, 328 "mx4200_config: time_pps_create failed: %m"); 329 return (0); 330 } 331 if (time_pps_getcap(up->pps_h, &mode) < 0) { 332 msyslog(LOG_ERR, 333 "mx4200_config: time_pps_getcap failed: %m"); 334 return (0); 335 } 336 337 if (time_pps_getparams(up->pps_h, &up->pps_p) < 0) { 338 msyslog(LOG_ERR, 339 "mx4200_config: time_pps_getparams failed: %m"); 340 return (0); 341 } 342 343 /* nb. only turn things on, if someone else has turned something 344 * on before we get here, leave it alone! 345 */ 346 347 up->pps_p.mode = PPS_CAPTUREASSERT | PPS_TSFMT_TSPEC; 348 up->pps_p.mode &= mode; /* only set what is legal */ 349 350 if (time_pps_setparams(up->pps_h, &up->pps_p) < 0) { 351 perror("time_pps_setparams"); 352 msyslog(LOG_ERR, 353 "mx4200_config: time_pps_setparams failed: %m"); 354 exit(1); 355 } 356 357 if (time_pps_kcbind(up->pps_h, PPS_KC_HARDPPS, PPS_CAPTUREASSERT, 358 PPS_TSFMT_TSPEC) < 0) { 359 perror("time_pps_kcbind"); 360 msyslog(LOG_ERR, 361 "mx4200_config: time_pps_kcbind failed: %m"); 362 exit(1); 363 } 364 365 366 /* 367 * "007" Control Port Configuration 368 * Zero the output list (do it twice to flush possible junk) 369 */ 370 mx4200_send(peer, "%s,%03d,,%d,,,,,,", pmvxg, 371 PMVXG_S_PORTCONF, 372 /* control port output block Label */ 373 1); /* clear current output control list (1=yes) */ 374 /* add/delete sentences from list */ 375 /* must be null */ 376 /* sentence output rate (sec) */ 377 /* precision for position output */ 378 /* nmea version for cga & gll output */ 379 /* pass-through control */ 380 mx4200_send(peer, "%s,%03d,,%d,,,,,,", pmvxg, 381 PMVXG_S_PORTCONF, 1); 382 383 /* 384 * Request software configuration so we can syslog the firmware version 385 */ 386 mx4200_send(peer, "%s,%03d", "CDGPQ", PMVXG_D_SOFTCONF); 387 388 /* 389 * "001" Initialization/Mode Control, Part A 390 * Where ARE we? 391 */ 392 mx4200_send(peer, "%s,%03d,,,,,,,,,,", pmvxg, 393 PMVXG_S_INITMODEA); 394 /* day of month */ 395 /* month of year */ 396 /* year */ 397 /* gmt */ 398 /* latitude DDMM.MMMM */ 399 /* north/south */ 400 /* longitude DDDMM.MMMM */ 401 /* east/west */ 402 /* height */ 403 /* Altitude Reference 1=MSL */ 404 405 /* 406 * "001" Initialization/Mode Control, Part B 407 * Start off in 2d/3d coast mode, holding altitude to last known 408 * value if only 3 satellites available. 409 */ 410 mx4200_send(peer, "%s,%03d,%d,,%.1f,%.1f,%d,%d,%d,%c,%d", 411 pmvxg, PMVXG_S_INITMODEB, 412 3, /* 2d/3d coast */ 413 /* reserved */ 414 0.1, /* hor accel fact as per Steve (m/s**2) */ 415 0.1, /* ver accel fact as per Steve (m/s**2) */ 416 10, /* vdop */ 417 10, /* hdop limit as per Steve */ 418 5, /* elevation limit as per Steve (deg) */ 419 'U', /* time output mode (UTC) */ 420 0); /* local time offset from gmt (HHHMM) */ 421 422 /* 423 * "023" Time Recovery Configuration 424 * Get UTC time from a stationary receiver. 425 * (Set field 1 'D' == dynamic if we are on a moving platform). 426 * (Set field 1 'S' == static if we are not moving). 427 * (Set field 1 'K' == known position if we can initialize lat/lon/alt). 428 */ 429 430 if (pp->sloppyclockflag & CLK_FLAG2) 431 up->moving = 1; /* Receiver on mobile platform */ 432 else 433 up->moving = 0; /* Static Installation */ 434 435 up->pollcnt = 2; 436 if (up->moving) { 437 /* dynamic: solve for pos, alt, time, while moving */ 438 tr_mode = 'D'; 439 } else { 440 /* static: solve for pos, alt, time, while stationary */ 441 tr_mode = 'S'; 442 } 443 mx4200_send(peer, "%s,%03d,%c,%c,%c,%d,%d,%d,", pmvxg, 444 PMVXG_S_TRECOVCONF, 445 tr_mode, /* time recovery mode (see above ) */ 446 'U', /* synchronize to UTC */ 447 'A', /* always output a time pulse */ 448 500, /* max time error in ns */ 449 0, /* user bias in ns */ 450 1); /* output "830" sentences to control port */ 451 /* Multi-satellite mode */ 452 453 /* 454 * Output position information (to calculate fixed installation 455 * location) only if we are not moving 456 */ 457 if (up->moving) { 458 add_mode = 2; /* delete from list */ 459 } else { 460 add_mode = 1; /* add to list */ 461 } 462 463 464 /* 465 * "007" Control Port Configuration 466 * Output "021" position, height, velocity reports 467 */ 468 mx4200_send(peer, "%s,%03d,%03d,%d,%d,,%d,,,", pmvxg, 469 PMVXG_S_PORTCONF, 470 PMVXG_D_PHV, /* control port output block Label */ 471 0, /* clear current output control list (0=no) */ 472 add_mode, /* add/delete sentences from list (1=add, 2=del) */ 473 /* must be null */ 474 INTERVAL); /* sentence output rate (sec) */ 475 /* precision for position output */ 476 /* nmea version for cga & gll output */ 477 /* pass-through control */ 478 479 return (1); 480} 481 482/* 483 * mx4200_ref - Reconfigure unit as a reference station at a known position. 484 */ 485static void 486mx4200_ref( 487 struct peer *peer 488 ) 489{ 490 register struct mx4200unit *up; 491 struct refclockproc *pp; 492 double minute, lat, lon, alt; 493 char lats[16], lons[16]; 494 char nsc, ewc; 495 496 pp = peer->procptr; 497 up = (struct mx4200unit *)pp->unitptr; 498 499 /* Should never happen! */ 500 if (up->moving) return; 501 502 /* 503 * Set up to output status information in the near future 504 */ 505 up->log_time = current_time + SLEEPTIME; 506 507 /* 508 * "007" Control Port Configuration 509 * Stop outputting "021" position, height, velocity reports 510 */ 511 mx4200_send(peer, "%s,%03d,%03d,%d,%d,,,,,", pmvxg, 512 PMVXG_S_PORTCONF, 513 PMVXG_D_PHV, /* control port output block Label */ 514 0, /* clear current output control list (0=no) */ 515 2); /* add/delete sentences from list (2=delete) */ 516 /* must be null */ 517 /* sentence output rate (sec) */ 518 /* precision for position output */ 519 /* nmea version for cga & gll output */ 520 /* pass-through control */ 521 522 /* 523 * "001" Initialization/Mode Control, Part B 524 * Put receiver in fully-constrained 2d nav mode 525 */ 526 mx4200_send(peer, "%s,%03d,%d,,%.1f,%.1f,%d,%d,%d,%c,%d", 527 pmvxg, PMVXG_S_INITMODEB, 528 2, /* 2d nav */ 529 /* reserved */ 530 0.1, /* hor accel fact as per Steve (m/s**2) */ 531 0.1, /* ver accel fact as per Steve (m/s**2) */ 532 10, /* vdop */ 533 10, /* hdop limit as per Steve */ 534 5, /* elevation limit as per Steve (deg) */ 535 'U', /* time output mode (UTC) */ 536 0); /* local time offset from gmt (HHHMM) */ 537 538 /* 539 * "023" Time Recovery Configuration 540 * Get UTC time from a stationary receiver. Solve for time only. 541 * This should improve the time resolution dramatically. 542 */ 543 mx4200_send(peer, "%s,%03d,%c,%c,%c,%d,%d,%d,", pmvxg, 544 PMVXG_S_TRECOVCONF, 545 'K', /* known position: solve for time only */ 546 'U', /* synchronize to UTC */ 547 'A', /* always output a time pulse */ 548 500, /* max time error in ns */ 549 0, /* user bias in ns */ 550 1); /* output "830" sentences to control port */ 551 /* Multi-satellite mode */ 552 553 /* 554 * "000" Initialization/Mode Control - Part A 555 * Fix to our averaged position. 556 */ 557 if (up->central_meridian != NOT_INITIALIZED) { 558 up->avg_lon += up->central_meridian; 559 if (up->avg_lon < -180.0) up->avg_lon += 360.0; 560 if (up->avg_lon > 180.0) up->avg_lon -= 360.0; 561 } 562 563 if (up->avg_lat >= 0.0) { 564 lat = up->avg_lat; 565 nsc = 'N'; 566 } else { 567 lat = up->avg_lat * (-1.0); 568 nsc = 'S'; 569 } 570 if (up->avg_lon >= 0.0) { 571 lon = up->avg_lon; 572 ewc = 'E'; 573 } else { 574 lon = up->avg_lon * (-1.0); 575 ewc = 'W'; 576 } 577 alt = up->avg_alt; 578 minute = (lat - (double)(int)lat) * 60.0; 579 sprintf(lats,"%02d%02.4f", (int)lat, minute); 580 minute = (lon - (double)(int)lon) * 60.0; 581 sprintf(lons,"%03d%02.4f", (int)lon, minute); 582 583 mx4200_send(peer, "%s,%03d,,,,,%s,%c,%s,%c,%.2f,%d", pmvxg, 584 PMVXG_S_INITMODEA, 585 /* day of month */ 586 /* month of year */ 587 /* year */ 588 /* gmt */ 589 lats, /* latitude DDMM.MMMM */ 590 nsc, /* north/south */ 591 lons, /* longitude DDDMM.MMMM */ 592 ewc, /* east/west */ 593 alt, /* Altitude */ 594 1); /* Altitude Reference (0=WGS84 ellipsoid, 1=MSL geoid)*/ 595 596 msyslog(LOG_DEBUG, 597 "mx4200: reconfig to fixed location: %s %c, %s %c, %.2f m", 598 lats, nsc, lons, ewc, alt ); 599 600} 601 602/* 603 * mx4200_poll - mx4200 watchdog routine 604 */ 605static void 606mx4200_poll( 607 int unit, 608 struct peer *peer 609 ) 610{ 611 register struct mx4200unit *up; 612 struct refclockproc *pp; 613 614 pp = peer->procptr; 615 up = (struct mx4200unit *)pp->unitptr; 616 617 /* 618 * You don't need to poll this clock. It puts out timecodes 619 * once per second. If asked for a timestamp, take note. 620 * The next time a timecode comes in, it will be fed back. 621 */ 622 623 /* 624 * If we haven't had a response in a while, reset the receiver. 625 */ 626 if (up->pollcnt > 0) { 627 up->pollcnt--; 628 } else { 629 refclock_report(peer, CEVNT_TIMEOUT); 630 631 /* 632 * Request a "000" status message which should trigger a 633 * reconfig 634 */ 635 mx4200_send(peer, "%s,%03d", 636 "CDGPQ", /* query from CDU to GPS */ 637 PMVXG_D_STATUS); /* label of desired sentence */ 638 } 639 640 /* 641 * polled every 64 seconds. Ask mx4200_receive to hand in 642 * a timestamp. 643 */ 644 up->polled = 1; 645 pp->polls++; 646 647 /* 648 * Output receiver status information. 649 */ 650 if ((up->log_time > 0) && (current_time > up->log_time)) { 651 up->log_time = 0; 652 /* 653 * Output the following messages once, for debugging. 654 * "004" Mode Data 655 * "523" Time Recovery Parameters 656 */ 657 mx4200_send(peer, "%s,%03d", "CDGPQ", PMVXG_D_MODEDATA); 658 mx4200_send(peer, "%s,%03d", "CDGPQ", PMVXG_D_TRECOVUSEAGE); 659 } 660} 661 662static char char2hex[] = "0123456789ABCDEF"; 663 664/* 665 * mx4200_receive - receive gps data 666 */ 667static void 668mx4200_receive( 669 struct recvbuf *rbufp 670 ) 671{ 672 register struct mx4200unit *up; 673 struct refclockproc *pp; 674 struct peer *peer; 675 char *cp; 676 int sentence_type; 677 u_char ck; 678 679 /* 680 * Initialize pointers and read the timecode and timestamp. 681 */ 682 peer = (struct peer *)rbufp->recv_srcclock; 683 pp = peer->procptr; 684 up = (struct mx4200unit *)pp->unitptr; 685 686 /* 687 * If operating mode has been changed, then reinitialize the receiver 688 * before doing anything else. 689 */ 690 if ((pp->sloppyclockflag & CLK_FLAG2) != 691 (up->sloppyclockflag & CLK_FLAG2)) { 692 up->sloppyclockflag = pp->sloppyclockflag; 693 mx4200_debug(peer, 694 "mx4200_receive: mode switch: reset receiver\n"); 695 mx4200_config(peer); 696 return; 697 } 698 up->sloppyclockflag = pp->sloppyclockflag; 699 700 /* 701 * Read clock output. Automatically handles STREAMS, CLKLDISC. 702 */ 703 pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &pp->lastrec); 704 705 /* 706 * There is a case where <cr><lf> generates 2 timestamps. 707 */ 708 if (pp->lencode == 0) 709 return; 710 711 up->pollcnt = 2; 712 pp->a_lastcode[pp->lencode] = '\0'; 713 record_clock_stats(&peer->srcadr, pp->a_lastcode); 714 mx4200_debug(peer, "mx4200_receive: %d %s\n", 715 pp->lencode, pp->a_lastcode); 716 717 /* 718 * The structure of the control port sentences is based on the 719 * NMEA-0183 Standard for interfacing Marine Electronics 720 * Navigation Devices (Version 1.5) 721 * 722 * $PMVXG,XXX, ....................*CK<cr><lf> 723 * 724 * $ Sentence Start Identifier (reserved char) 725 * (Start-of-Sentence Identifier) 726 * P Special ID (Proprietary) 727 * MVX Originator ID (Magnavox) 728 * G Interface ID (GPS) 729 * , Field Delimiters (reserved char) 730 * XXX Sentence Type 731 * ...... Data 732 * * Checksum Field Delimiter (reserved char) 733 * CK Checksum 734 * <cr><lf> Carriage-Return/Line Feed (reserved chars) 735 * (End-of-Sentence Identifier) 736 * 737 * Reject if any important landmarks are missing. 738 */ 739 cp = pp->a_lastcode + pp->lencode - 3; 740 if (cp < pp->a_lastcode || *pp->a_lastcode != '$' || cp[0] != '*' ) { 741 mx4200_debug(peer, "mx4200_receive: bad format\n"); 742 refclock_report(peer, CEVNT_BADREPLY); 743 return; 744 } 745 746 /* 747 * Check and discard the checksum 748 */ 749 ck = mx4200_cksum(&pp->a_lastcode[1], pp->lencode - 4); 750 if (char2hex[ck >> 4] != cp[1] || char2hex[ck & 0xf] != cp[2]) { 751 mx4200_debug(peer, "mx4200_receive: bad checksum\n"); 752 refclock_report(peer, CEVNT_BADREPLY); 753 return; 754 } 755 *cp = '\0'; 756 757 /* 758 * Get the sentence type. 759 */ 760 sentence_type = 0; 761 if ((cp = strchr(pp->a_lastcode, ',')) == NULL) { 762 mx4200_debug(peer, "mx4200_receive: no sentence\n"); 763 refclock_report(peer, CEVNT_BADREPLY); 764 return; 765 } 766 cp++; 767 sentence_type = strtol(cp, &cp, 10); 768 769 /* 770 * Process the sentence according to its type. 771 */ 772 switch (sentence_type) { 773 774 /* 775 * "000" Status message 776 */ 777 case PMVXG_D_STATUS: 778 /* 779 * XXX 780 * Since we configure the receiver to not give us status 781 * messages and since the receiver outputs status messages by 782 * default after being reset to factory defaults when sent the 783 * "$PMVXG,018,C\r\n" message, any status message we get 784 * indicates the reciever needs to be initialized; thus, it is 785 * not necessary to decode the status message. 786 */ 787 if ((cp = mx4200_parse_s(peer)) != NULL) { 788 mx4200_debug(peer, 789 "mx4200_receive: status: %s\n", cp); 790 } 791 mx4200_debug(peer, "mx4200_receive: reset receiver\n"); 792 mx4200_config(peer); 793 break; 794 795 /* 796 * "021" Position, Height, Velocity message, 797 * if we are still averaging our position 798 */ 799 case PMVXG_D_PHV: 800 if (!up->known) { 801 /* 802 * Parse the message, calculating our averaged position. 803 */ 804 if ((cp = mx4200_parse_p(peer)) != NULL) { 805 mx4200_debug(peer, "mx4200_receive: pos: %s\n", cp); 806 return; 807 } 808 mx4200_debug(peer, 809 "mx4200_receive: position avg %f %.9f %.9f %.4f\n", 810 up->N_fixes, up->avg_lat, up->avg_lon, up->avg_alt); 811 /* 812 * Reinitialize as a reference station 813 * if position is well known. 814 */ 815 if (current_time > up->clamp_time) { 816 up->known++; 817 mx4200_debug(peer, "mx4200_receive: reconfiguring!\n"); 818 mx4200_ref(peer); 819 } 820 } 821 break; 822 823 /* 824 * Print to the syslog: 825 * "004" Mode Data 826 * "030" Software Configuration 827 * "523" Time Recovery Parameters Currently in Use 828 */ 829 case PMVXG_D_MODEDATA: 830 case PMVXG_D_SOFTCONF: 831 case PMVXG_D_TRECOVUSEAGE: 832 833 if ((cp = mx4200_parse_s(peer)) != NULL) { 834 mx4200_debug(peer, 835 "mx4200_receive: multi-record: %s\n", cp); 836 } 837 break; 838 839 /* 840 * "830" Time Recovery Results message 841 */ 842 case PMVXG_D_TRECOVOUT: 843 844 /* 845 * Capture the last PPS signal. 846 * Precision timestamp is returned in pp->lastrec 847 */ 848 if (mx4200_pps(peer) != NULL) { 849 mx4200_debug(peer, "mx4200_receive: pps failure\n"); 850 refclock_report(peer, CEVNT_FAULT); 851 return; 852 } 853 854 855 /* 856 * Parse the time recovery message, and keep the info 857 * to print the pretty billboards. 858 */ 859 if ((cp = mx4200_parse_t(peer)) != NULL) { 860 mx4200_debug(peer, "mx4200_receive: time: %s\n", cp); 861 refclock_report(peer, CEVNT_BADREPLY); 862 return; 863 } 864 865 /* 866 * Add the new sample to a median filter. 867 */ 868 if (!refclock_process(pp)) { 869 mx4200_debug(peer,"mx4200_receive: offset: %.6f\n", 870 pp->offset); 871 refclock_report(peer, CEVNT_BADTIME); 872 return; 873 } 874 875 /* 876 * The clock will blurt a timecode every second but we only 877 * want one when polled. If we havn't been polled, bail out. 878 */ 879 if (!up->polled) 880 return; 881 882 /* 883 * Return offset and dispersion to control module. We use 884 * lastrec as both the reference time and receive time in 885 * order to avoid being cute, like setting the reference time 886 * later than the receive time, which may cause a paranoid 887 * protocol module to chuck out the data. 888 */ 889 mx4200_debug(peer, "mx4200_receive: process time: "); 890 mx4200_debug(peer, "%4d-%03d %02d:%02d:%02d at %s, %.6f\n", 891 pp->year, pp->day, pp->hour, pp->minute, pp->second, 892 prettydate(&pp->lastrec), pp->offset); 893 pp->lastref = pp->lastrec; 894 refclock_receive(peer); 895 896 /* 897 * We have succeeded in answering the poll. 898 * Turn off the flag and return 899 */ 900 up->polled = 0; 901 break; 902 903 /* 904 * Ignore all other sentence types 905 */ 906 default: 907 break; 908 909 } /* switch (sentence_type) */ 910 911 return; 912} 913 914 915/* 916 * Parse a mx4200 time recovery message. Returns a string if error. 917 * 918 * A typical message looks like this. Checksum has already been stripped. 919 * 920 * $PMVXG,830,T,YYYY,MM,DD,HH:MM:SS,U,S,FFFFFF,PPPPP,BBBBBB,LL 921 * 922 * Field Field Contents 923 * ----- -------------- 924 * Block Label: $PMVXG 925 * Sentence Type: 830=Time Recovery Results 926 * This sentence is output approximately 1 second 927 * preceding the 1PPS output. It indicates the 928 * exact time of the next pulse, whether or not the 929 * time mark will be valid (based on operator-specified 930 * error tolerance), the time to which the pulse is 931 * synchronized, the receiver operating mode, 932 * and the time error of the *last* 1PPS output. 933 * 1 char Time Mark Valid: T=Valid, F=Not Valid 934 * 2 int Year: 1993- 935 * 3 int Month of Year: 1-12 936 * 4 int Day of Month: 1-31 937 * 5 int Time of Day: HH:MM:SS 938 * 6 char Time Synchronization: U=UTC, G=GPS 939 * 7 char Time Recovery Mode: D=Dynamic, S=Static, 940 * K=Known Position, N=No Time Recovery 941 * 8 int Oscillator Offset: The filter's estimate of the oscillator 942 * frequency error, in parts per billion (ppb). 943 * 9 int Time Mark Error: The computed error of the *last* pulse 944 * output, in nanoseconds. 945 * 10 int User Time Bias: Operator specified bias, in nanoseconds 946 * 11 int Leap Second Flag: Indicates that a leap second will 947 * occur. This value is usually zero, except during 948 * the week prior to the leap second occurrence, when 949 * this value will be set to +1 or -1. A value of 950 * +1 indicates that GPS time will be 1 second 951 * further ahead of UTC time. 952 * 953 */ 954static char * 955mx4200_parse_t( 956 struct peer *peer 957 ) 958{ 959 struct refclockproc *pp; 960 struct mx4200unit *up; 961 char time_mark_valid, time_sync, op_mode; 962 int sentence_type, valid; 963 int year, day_of_year, month, day_of_month; 964 int hour, minute, second, leapsec_warn; 965 int oscillator_offset, time_mark_error, time_bias; 966 967 pp = peer->procptr; 968 up = (struct mx4200unit *)pp->unitptr; 969 970 leapsec_warn = 0; /* Not all receivers output leap second warnings (!) */ 971 sscanf(pp->a_lastcode, 972 "$PMVXG,%d,%c,%d,%d,%d,%d:%d:%d,%c,%c,%d,%d,%d,%d", 973 &sentence_type, &time_mark_valid, &year, &month, &day_of_month, 974 &hour, &minute, &second, &time_sync, &op_mode, 975 &oscillator_offset, &time_mark_error, &time_bias, &leapsec_warn); 976 977 if (sentence_type != PMVXG_D_TRECOVOUT) 978 return ("wrong rec-type"); 979 980 switch (time_mark_valid) { 981 case 'T': 982 valid = 1; 983 break; 984 case 'F': 985 valid = 0; 986 break; 987 default: 988 return ("bad pulse-valid"); 989 } 990 991 switch (time_sync) { 992 case 'G': 993 return ("synchronized to GPS; should be UTC"); 994 case 'U': 995 break; /* UTC -> ok */ 996 default: 997 return ("not synchronized to UTC"); 998 } 999 1000 /* 1001 * Check for insane time (allow for possible leap seconds) 1002 */ 1003 if (second > 60 || minute > 59 || hour > 23 || 1004 second < 0 || minute < 0 || hour < 0) { 1005 mx4200_debug(peer, 1006 "mx4200_parse_t: bad time %02d:%02d:%02d", 1007 hour, minute, second); 1008 if (leapsec_warn != 0) 1009 mx4200_debug(peer, " (leap %+d\n)", leapsec_warn); 1010 mx4200_debug(peer, "\n"); 1011 refclock_report(peer, CEVNT_BADTIME); 1012 return ("bad time"); 1013 } 1014 if ( second == 60 ) { 1015 msyslog(LOG_DEBUG, 1016 "mx4200: leap second! %02d:%02d:%02d", 1017 hour, minute, second); 1018 } 1019 1020 /* 1021 * Check for insane date 1022 * (Certainly can't be any year before this code was last altered!) 1023 */ 1024 if (day_of_month > 31 || month > 12 || 1025 day_of_month < 1 || month < 1 || year < YEAR_LAST_MODIFIED) { 1026 mx4200_debug(peer, 1027 "mx4200_parse_t: bad date (%4d-%02d-%02d)\n", 1028 year, month, day_of_month); 1029 refclock_report(peer, CEVNT_BADDATE); 1030 return ("bad date"); 1031 } 1032 1033 /* 1034 * Silly Hack for MX4200: 1035 * ASCII message is for *next* 1PPS signal, but we have the 1036 * timestamp for the *last* 1PPS signal. So we have to subtract 1037 * a second. Discard if we are on a month boundary to avoid 1038 * possible leap seconds and leap days. 1039 */ 1040 second--; 1041 if (second < 0) { 1042 second = 59; 1043 minute--; 1044 if (minute < 0) { 1045 minute = 59; 1046 hour--; 1047 if (hour < 0) { 1048 hour = 23; 1049 day_of_month--; 1050 if (day_of_month < 1) { 1051 return ("sorry, month boundary"); 1052 } 1053 } 1054 } 1055 } 1056 1057 /* 1058 * Calculate Julian date 1059 */ 1060 if (!(day_of_year = mx4200_jday(year, month, day_of_month))) { 1061 mx4200_debug(peer, 1062 "mx4200_parse_t: bad julian date %d (%4d-%02d-%02d)\n", 1063 day_of_year, year, month, day_of_month); 1064 refclock_report(peer, CEVNT_BADDATE); 1065 return("invalid julian date"); 1066 } 1067 1068 /* 1069 * Setup leap second indicator 1070 */ 1071 switch (leapsec_warn) { 1072 case 0: 1073 pp->leap = LEAP_NOWARNING; 1074 break; 1075 case 1: 1076 pp->leap = LEAP_ADDSECOND; 1077 break; 1078 case -1: 1079 pp->leap = LEAP_DELSECOND; 1080 break; 1081 default: 1082 pp->leap = LEAP_NOTINSYNC; 1083 } 1084 1085 /* 1086 * Any change to the leap second warning status? 1087 */ 1088 if (leapsec_warn != up->last_leap ) { 1089 msyslog(LOG_DEBUG, 1090 "mx4200: leap second warning: %d to %d (%d)", 1091 up->last_leap, leapsec_warn, pp->leap); 1092 } 1093 up->last_leap = leapsec_warn; 1094 1095 /* 1096 * Copy time data for billboard monitoring. 1097 */ 1098 1099 pp->year = year; 1100 pp->day = day_of_year; 1101 pp->hour = hour; 1102 pp->minute = minute; 1103 pp->second = second; 1104 1105 /* 1106 * Toss if sentence is marked invalid 1107 */ 1108 if (!valid || pp->leap == LEAP_NOTINSYNC) { 1109 mx4200_debug(peer, "mx4200_parse_t: time mark not valid\n"); 1110 refclock_report(peer, CEVNT_BADTIME); 1111 return ("pulse invalid"); 1112 } 1113 1114 return (NULL); 1115} 1116 1117/* 1118 * Calculate the checksum 1119 */ 1120static u_char 1121mx4200_cksum( 1122 register char *cp, 1123 register int n 1124 ) 1125{ 1126 register u_char ck; 1127 1128 for (ck = 0; n-- > 0; cp++) 1129 ck ^= *cp; 1130 return (ck); 1131} 1132 1133/* 1134 * Tables to compute the day of year. Viva la leap. 1135 */ 1136static int day1tab[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 1137static int day2tab[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 1138 1139/* 1140 * Calculate the the Julian Day 1141 */ 1142static int 1143mx4200_jday( 1144 int year, 1145 int month, 1146 int day_of_month 1147 ) 1148{ 1149 register int day, i; 1150 int leap_year; 1151 1152 /* 1153 * Is this a leap year ? 1154 */ 1155 if (year % 4) { 1156 leap_year = 0; /* FALSE */ 1157 } else { 1158 if (year % 100) { 1159 leap_year = 1; /* TRUE */ 1160 } else { 1161 if (year % 400) { 1162 leap_year = 0; /* FALSE */ 1163 } else { 1164 leap_year = 1; /* TRUE */ 1165 } 1166 } 1167 } 1168 1169 /* 1170 * Calculate the Julian Date 1171 */ 1172 day = day_of_month; 1173 1174 if (leap_year) { 1175 /* a leap year */ 1176 if (day > day2tab[month - 1]) { 1177 return (0); 1178 } 1179 for (i = 0; i < month - 1; i++) 1180 day += day2tab[i]; 1181 } else { 1182 /* not a leap year */ 1183 if (day > day1tab[month - 1]) { 1184 return (0); 1185 } 1186 for (i = 0; i < month - 1; i++) 1187 day += day1tab[i]; 1188 } 1189 return (day); 1190} 1191 1192/* 1193 * Parse a mx4200 position/height/velocity sentence. 1194 * 1195 * A typical message looks like this. Checksum has already been stripped. 1196 * 1197 * $PMVXG,021,SSSSSS.SS,DDMM.MMMM,N,DDDMM.MMMM,E,HHHHH.H,GGGG.G,EEEE.E,WWWW.W,MM 1198 * 1199 * Field Field Contents 1200 * ----- -------------- 1201 * Block Label: $PMVXG 1202 * Sentence Type: 021=Position, Height Velocity Data 1203 * This sentence gives the receiver position, height, 1204 * navigation mode, and velocity north/east. 1205 * *This sentence is intended for post-analysis 1206 * applications.* 1207 * 1 float UTC measurement time (seconds into week) 1208 * 2 float WGS-84 Lattitude (degrees, minutes) 1209 * 3 char N=North, S=South 1210 * 4 float WGS-84 Longitude (degrees, minutes) 1211 * 5 char E=East, W=West 1212 * 6 float Altitude (meters above mean sea level) 1213 * 7 float Geoidal height (meters) 1214 * 8 float East velocity (m/sec) 1215 * 9 float West Velocity (m/sec) 1216 * 10 int Navigation Mode 1217 * Mode if navigating: 1218 * 1 = Position from remote device 1219 * 2 = 2-D position 1220 * 3 = 3-D position 1221 * 4 = 2-D differential position 1222 * 5 = 3-D differential position 1223 * 6 = Static 1224 * 8 = Position known -- reference station 1225 * 9 = Position known -- Navigator 1226 * Mode if not navigating: 1227 * 51 = Too few satellites 1228 * 52 = DOPs too large 1229 * 53 = Position STD too large 1230 * 54 = Velocity STD too large 1231 * 55 = Too many iterations for velocity 1232 * 56 = Too many iterations for position 1233 * 57 = 3 sat startup failed 1234 * 58 = Command abort 1235 */ 1236static char * 1237mx4200_parse_p( 1238 struct peer *peer 1239 ) 1240{ 1241 struct refclockproc *pp; 1242 struct mx4200unit *up; 1243 int sentence_type, mode; 1244 double mtime, lat, lon, alt, geoid, vele, veln; 1245 char north_south, east_west; 1246 1247 pp = peer->procptr; 1248 up = (struct mx4200unit *)pp->unitptr; 1249 1250 /* Should never happen! */ 1251 if (up->moving) return ("mobile platform - no pos!"); 1252 1253 sscanf ( pp->a_lastcode, 1254 "$PMVXG,%d,%lf,%lf,%c,%lf,%c,%lf,%lf,%lf,%lf,%d", 1255 &sentence_type, &mtime, &lat, &north_south, &lon, &east_west, 1256 &alt, &geoid, &vele, &veln, &mode); 1257 1258 /* Sentence type */ 1259 if (sentence_type != PMVXG_D_PHV) 1260 return ("wrong rec-type"); 1261 1262 /* 1263 * return if not navigating 1264 */ 1265 if (mode > 10) 1266 return ("not navigating"); 1267 if (mode != 3 && mode != 5) 1268 return ("not navigating in 3D"); 1269 1270 /* Latitude (always +ve) and convert DDMM.MMMM to decimal */ 1271 if (lat < 0.0) return ("negative latitude"); 1272 if (lat > 9000.0) lat = 9000.0; 1273 lat *= 0.01; 1274 lat = ((int)lat) + (((lat - (int)lat)) * 1.6666666666666666); 1275 1276 /* North/South */ 1277 switch (north_south) { 1278 case 'N': 1279 break; 1280 case 'S': 1281 lat *= -1.0; 1282 break; 1283 default: 1284 return ("invalid north/south indicator"); 1285 } 1286 1287 /* Longitude (always +ve) and convert DDDMM.MMMM to decimal */ 1288 if (lon < 0.0) return ("negative longitude"); 1289 if (lon > 180.0) lon = 180.0; 1290 lon *= 0.01; 1291 lon = ((int)lon) + (((lon - (int)lon)) * 1.6666666666666666); 1292 1293 /* East/West */ 1294 switch (east_west) { 1295 case 'E': 1296 break; 1297 case 'W': 1298 lon *= -1.0; 1299 break; 1300 default: 1301 return ("invalid east/west indicator"); 1302 } 1303 1304 /* 1305 * Normalize longitude to near 0 degrees. 1306 * Assume all data are clustered around first reading. 1307 */ 1308 if (up->central_meridian == NOT_INITIALIZED) { 1309 up->central_meridian = lon; 1310 mx4200_debug(peer, 1311 "mx4200_receive: central meridian = %.9f \n", 1312 up->central_meridian); 1313 } 1314 lon -= up->central_meridian; 1315 if (lon < -180.0) lon += 360.0; 1316 if (lon > 180.0) lon -= 360.0; 1317 1318 /* 1319 * Calculate running averages 1320 */ 1321 1322 up->avg_lon = (up->N_fixes * up->avg_lon) + lon; 1323 up->avg_lat = (up->N_fixes * up->avg_lat) + lat; 1324 up->avg_alt = (up->N_fixes * up->avg_alt) + alt; 1325 1326 up->N_fixes += 1.0; 1327 1328 up->avg_lon /= up->N_fixes; 1329 up->avg_lat /= up->N_fixes; 1330 up->avg_alt /= up->N_fixes; 1331 1332 mx4200_debug(peer, 1333 "mx4200_receive: position rdg %.0f: %.9f %.9f %.4f (CM=%.9f)\n", 1334 up->N_fixes, lat, lon, alt, up->central_meridian); 1335 1336 return (NULL); 1337} 1338 1339/* 1340 * Parse a mx4200 Status sentence 1341 * Parse a mx4200 Mode Data sentence 1342 * Parse a mx4200 Software Configuration sentence 1343 * Parse a mx4200 Time Recovery Parameters Currently in Use sentence 1344 * (used only for logging raw strings) 1345 * 1346 * A typical message looks like this. Checksum has already been stripped. 1347 * 1348 * $PMVXG,000,XXX,XX,X,HHMM,X 1349 * 1350 * Field Field Contents 1351 * ----- -------------- 1352 * Block Label: $PMVXG 1353 * Sentence Type: 000=Status. 1354 * Returns status of the receiver to the controller. 1355 * 1 Current Receiver Status: 1356 * ACQ = Satellite re-acquisition 1357 * ALT = Constellation selection 1358 * COR = Providing corrections (for reference stations only) 1359 * IAC = Initial acquisition 1360 * IDL = Idle, no satellites 1361 * NAV = Navigation 1362 * STS = Search the Sky (no almanac available) 1363 * TRK = Tracking 1364 * 2 Number of satellites that should be visible 1365 * 3 Number of satellites being tracked 1366 * 4 Time since last navigation status if not currently navigating 1367 * (hours, minutes) 1368 * 5 Initialization status: 1369 * 0 = Waiting for initialization parameters 1370 * 1 = Initialization completed 1371 * 1372 * A typical message looks like this. Checksum has already been stripped. 1373 * 1374 * $PMVXG,004,C,R,D,H.HH,V.VV,TT,HHHH,VVVV,T 1375 * 1376 * Field Field Contents 1377 * ----- -------------- 1378 * Block Label: $PMVXG 1379 * Sentence Type: 004=Software Configuration. 1380 * Defines the navigation mode and criteria for 1381 * acceptable navigation for the receiver. 1382 * 1 Constrain Altitude Mode: 1383 * 0 = Auto. Constrain altitude (2-D solution) and use 1384 * manual altitude input when 3 sats avalable. Do 1385 * not constrain altitude (3-D solution) when 4 sats 1386 * available. 1387 * 1 = Always constrain altitude (2-D solution). 1388 * 2 = Never constrain altitude (3-D solution). 1389 * 3 = Coast. Constrain altitude (2-D solution) and use 1390 * last GPS altitude calculation when 3 sats avalable. 1391 * Do not constrain altitude (3-D solution) when 4 sats 1392 * available. 1393 * 2 Altitude Reference: (always 0 for MX4200) 1394 * 0 = Ellipsoid 1395 * 1 = Geoid (MSL) 1396 * 3 Differential Navigation Control: 1397 * 0 = Disabled 1398 * 1 = Enabled 1399 * 4 Horizontal Acceleration Constant (m/sec**2) 1400 * 5 Vertical Acceleration Constant (m/sec**2) (0 for MX4200) 1401 * 6 Tracking Elevation Limit (degrees) 1402 * 7 HDOP Limit 1403 * 8 VDOP Limit 1404 * 9 Time Output Mode: 1405 * U = UTC 1406 * L = Local time 1407 * 10 Local Time Offset (minutes) (absent on MX4200) 1408 * 1409 * A typical message looks like this. Checksum has already been stripped. 1410 * 1411 * $PMVXG,030,NNNN,FFF 1412 * 1413 * Field Field Contents 1414 * ----- -------------- 1415 * Block Label: $PMVXG 1416 * Sentence Type: 030=Software Configuration. 1417 * This sentence contains the navigation processor 1418 * and baseband firmware version numbers. 1419 * 1 Nav Processor Version Number 1420 * 2 Baseband Firmware Version Number 1421 * 1422 * A typical message looks like this. Checksum has already been stripped. 1423 * 1424 * $PMVXG,523,M,S,M,EEEE,BBBBBB,C,R 1425 * 1426 * Field Field Contents 1427 * ----- -------------- 1428 * Block Label: $PMVXG 1429 * Sentence Type: 523=Time Recovery Parameters Currently in Use. 1430 * This sentence contains the configuration of the 1431 * time recovery feature of the receiver. 1432 * 1 Time Recovery Mode: 1433 * D = Dynamic; solve for position and time while moving 1434 * S = Static; solve for position and time while stationary 1435 * K = Known position input, solve for time only 1436 * N = No time recovery 1437 * 2 Time Synchronization: 1438 * U = UTC time 1439 * G = GPS time 1440 * 3 Time Mark Mode: 1441 * A = Always output a time pulse 1442 * V = Only output time pulse if time is valid (as determined 1443 * by Maximum Time Error) 1444 * 4 Maximum Time Error - the maximum error (in nanoseconds) for 1445 * which a time mark will be considered valid. 1446 * 5 User Time Bias - external bias in nanoseconds 1447 * 6 Time Message Control: 1448 * 0 = Do not output the time recovery message 1449 * 1 = Output the time recovery message (record 830) to 1450 * Control port 1451 * 2 = Output the time recovery message (record 830) to 1452 * Equipment port 1453 * 7 Reserved 1454 * 8 Position Known PRN (absent on MX 4200) 1455 * 1456 */ 1457static char * 1458mx4200_parse_s( 1459 struct peer *peer 1460 ) 1461{ 1462 struct refclockproc *pp; 1463 struct mx4200unit *up; 1464 int sentence_type; 1465 1466 pp = peer->procptr; 1467 up = (struct mx4200unit *)pp->unitptr; 1468 1469 sscanf ( pp->a_lastcode, "$PMVXG,%d", &sentence_type); 1470 1471 /* Sentence type */ 1472 switch (sentence_type) { 1473 1474 case PMVXG_D_STATUS: 1475 msyslog(LOG_DEBUG, 1476 "mx4200: status: %s", pp->a_lastcode); 1477 break; 1478 case PMVXG_D_MODEDATA: 1479 msyslog(LOG_DEBUG, 1480 "mx4200: mode data: %s", pp->a_lastcode); 1481 break; 1482 case PMVXG_D_SOFTCONF: 1483 msyslog(LOG_DEBUG, 1484 "mx4200: firmware configuration: %s", pp->a_lastcode); 1485 break; 1486 case PMVXG_D_TRECOVUSEAGE: 1487 msyslog(LOG_DEBUG, 1488 "mx4200: time recovery parms: %s", pp->a_lastcode); 1489 break; 1490 default: 1491 return ("wrong rec-type"); 1492 } 1493 1494 return (NULL); 1495} 1496 1497/* 1498 * Process a PPS signal, placing a timestamp in pp->lastrec. 1499 */ 1500static int 1501mx4200_pps( 1502 struct peer *peer 1503 ) 1504{ 1505 int temp_serial; 1506 struct refclockproc *pp; 1507 struct mx4200unit *up; 1508 1509 struct timespec timeout; 1510 1511 pp = peer->procptr; 1512 up = (struct mx4200unit *)pp->unitptr; 1513 1514 /* 1515 * Grab the timestamp of the PPS signal. 1516 */ 1517 temp_serial = up->pps_i.assert_sequence; 1518 timeout.tv_sec = 0; 1519 timeout.tv_nsec = 0; 1520 if (time_pps_fetch(up->pps_h, PPS_TSFMT_TSPEC, &(up->pps_i), 1521 &timeout) < 0) { 1522 mx4200_debug(peer, 1523 "mx4200_pps: time_pps_fetch: serial=%lu, %s\n", 1524 (unsigned long)up->pps_i.assert_sequence, strerror(errno)); 1525 refclock_report(peer, CEVNT_FAULT); 1526 return(1); 1527 } 1528 if (temp_serial == up->pps_i.assert_sequence) { 1529 mx4200_debug(peer, 1530 "mx4200_pps: assert_sequence serial not incrementing: %lu\n", 1531 (unsigned long)up->pps_i.assert_sequence); 1532 refclock_report(peer, CEVNT_FAULT); 1533 return(1); 1534 } 1535 /* 1536 * Check pps serial number against last one 1537 */ 1538 if (up->lastserial + 1 != up->pps_i.assert_sequence && 1539 up->lastserial != 0) { 1540 if (up->pps_i.assert_sequence == up->lastserial) { 1541 mx4200_debug(peer, "mx4200_pps: no new pps event\n"); 1542 } else { 1543 mx4200_debug(peer, "mx4200_pps: missed %lu pps events\n", 1544 up->pps_i.assert_sequence - up->lastserial - 1UL); 1545 } 1546 refclock_report(peer, CEVNT_FAULT); 1547 } 1548 up->lastserial = up->pps_i.assert_sequence; 1549 1550 /* 1551 * Return the timestamp in pp->lastrec 1552 */ 1553 1554 pp->lastrec.l_ui = up->pps_i.assert_timestamp.tv_sec + 1555 (u_int32) JAN_1970; 1556 pp->lastrec.l_uf = ((double)(up->pps_i.assert_timestamp.tv_nsec) * 1557 4.2949672960) + 0.5; 1558 1559 return(0); 1560} 1561 1562/* 1563 * mx4200_debug - print debug messages 1564 */ 1565#if defined(__STDC__) 1566static void 1567mx4200_debug(struct peer *peer, char *fmt, ...) 1568#else 1569static void 1570mx4200_debug(peer, fmt, va_alist) 1571 struct peer *peer; 1572 char *fmt; 1573#endif /* __STDC__ */ 1574{ 1575#ifdef DEBUG 1576 va_list ap; 1577 struct refclockproc *pp; 1578 struct mx4200unit *up; 1579 1580 if (debug) { 1581 1582#if defined(__STDC__) 1583 va_start(ap, fmt); 1584#else 1585 va_start(ap); 1586#endif /* __STDC__ */ 1587 1588 pp = peer->procptr; 1589 up = (struct mx4200unit *)pp->unitptr; 1590 1591 1592 /* 1593 * Print debug message to stdout 1594 * In the future, we may want to get get more creative... 1595 */ 1596 vprintf(fmt, ap); 1597 1598 va_end(ap); 1599 } 1600#endif 1601} 1602 1603/* 1604 * Send a character string to the receiver. Checksum is appended here. 1605 */ 1606#if defined(__STDC__) 1607static void 1608mx4200_send(struct peer *peer, char *fmt, ...) 1609#else 1610static void 1611mx4200_send(peer, fmt, va_alist) 1612 struct peer *peer; 1613 char *fmt; 1614 va_dcl 1615#endif /* __STDC__ */ 1616{ 1617 struct refclockproc *pp; 1618 struct mx4200unit *up; 1619 1620 register char *cp; 1621 register int n, m; 1622 va_list ap; 1623 char buf[1024]; 1624 u_char ck; 1625 1626#if defined(__STDC__) 1627 va_start(ap, fmt); 1628#else 1629 va_start(ap); 1630#endif /* __STDC__ */ 1631 1632 pp = peer->procptr; 1633 up = (struct mx4200unit *)pp->unitptr; 1634 1635 cp = buf; 1636 *cp++ = '$'; 1637 n = VSNPRINTF((cp, sizeof(buf) - 1, fmt, ap)); 1638 ck = mx4200_cksum(cp, n); 1639 cp += n; 1640 ++n; 1641 n += SNPRINTF((cp, sizeof(buf) - n - 5, "*%02X\r\n", ck)); 1642 1643 m = write(pp->io.fd, buf, (unsigned)n); 1644 if (m < 0) 1645 msyslog(LOG_ERR, "mx4200_send: write: %m (%s)", buf); 1646 mx4200_debug(peer, "mx4200_send: %d %s\n", m, buf); 1647 va_end(ap); 1648} 1649 1650#else 1651int refclock_mx4200_bs; 1652#endif /* REFCLOCK */ 1653