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