Annotation of embedaddon/ntp/ntpd/refclock_oncore.c, revision 1.1
1.1 ! misho 1: /*
! 2: * ----------------------------------------------------------------------------
! 3: * "THE BEER-WARE LICENSE" (Revision 42):
! 4: * <phk@FreeBSD.ORG> wrote this file. As long as you retain this notice you
! 5: * can do whatever you want with this stuff. If we meet some day, and you think
! 6: * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
! 7: * ----------------------------------------------------------------------------
! 8: *
! 9: * refclock_oncore.c
! 10: *
! 11: * Driver for some of the various the Motorola Oncore GPS receivers.
! 12: * should work with Basic, PVT6, VP, UT, UT+, GT, GT+, SL, M12, M12+T
! 13: * The receivers with TRAIM (VP, UT, UT+, M12+T), will be more accurate
! 14: * than the others.
! 15: * The receivers without position hold (GT, GT+) will be less accurate.
! 16: *
! 17: * Tested with:
! 18: *
! 19: * (UT) (VP)
! 20: * COPYRIGHT 1991-1997 MOTOROLA INC. COPYRIGHT 1991-1996 MOTOROLA INC.
! 21: * SFTW P/N # 98-P36848P SFTW P/N # 98-P36830P
! 22: * SOFTWARE VER # 2 SOFTWARE VER # 8
! 23: * SOFTWARE REV # 2 SOFTWARE REV # 8
! 24: * SOFTWARE DATE APR 24 1998 SOFTWARE DATE 06 Aug 1996
! 25: * MODEL # R1121N1114 MODEL # B4121P1155
! 26: * HWDR P/N # 1 HDWR P/N # _
! 27: * SERIAL # R0010A SERIAL # SSG0226478
! 28: * MANUFACTUR DATE 6H07 MANUFACTUR DATE 7E02
! 29: * OPTIONS LIST IB
! 30: *
! 31: * (Basic) (M12)
! 32: * COPYRIGHT 1991-1994 MOTOROLA INC. COPYRIGHT 1991-2000 MOTOROLA INC.
! 33: * SFTW P/N # 98-P39949M SFTW P/N # 61-G10002A
! 34: * SOFTWARE VER # 5 SOFTWARE VER # 1
! 35: * SOFTWARE REV # 0 SOFTWARE REV # 3
! 36: * SOFTWARE DATE 20 JAN 1994 SOFTWARE DATE Mar 13 2000
! 37: * MODEL # A11121P116 MODEL # P143T12NR1
! 38: * HDWR P/N # _ HWDR P/N # 1
! 39: * SERIAL # SSG0049809 SERIAL # P003UD
! 40: * MANUFACTUR DATE 417AMA199 MANUFACTUR DATE 0C27
! 41: * OPTIONS LIST AB
! 42: *
! 43: * (M12+T) (M12+T later version)
! 44: * COPYRIGHT 1991-2002 MOTOROLA INC. COPYRIGHT 1991-2003 MOTOROLA INC.
! 45: * SFTW P/N # 61-G10268A SFTW P/N # 61-G10268A
! 46: * SOFTWARE VER # 2 SOFTWARE VER # 2
! 47: * SOFTWARE REV # 0 SOFTWARE REV # 1
! 48: * SOFTWARE DATE AUG 14 2002 SOFTWARE DATE APR 16 2003
! 49: * MODEL # P283T12T11 MODEL # P273T12T12
! 50: * HWDR P/N # 2 HWDR P/N # 2
! 51: * SERIAL # P04DC2 SERIAL # P05Z7Z
! 52: * MANUFACTUR DATE 2J17 MANUFACTUR DATE 3G15
! 53: *
! 54: * --------------------------------------------------------------------------
! 55: * Reg Clemens (June 2009)
! 56: * BUG[1220] OK, big patch, but mostly done mechanically. Change direct calls to write
! 57: * to clockstats to a call to oncore_log, which now calls the old routine plus msyslog.
! 58: * Have to set the LOG_LEVELS of the calls for msyslog, and this was done by hand. New
! 59: * routine oncore_log.
! 60: * --------------------------------------------------------------------------
! 61: * Reg Clemens (June 2009)
! 62: * BUG[1218] The comment on where the oncore driver gets its input file does not
! 63: * agree with the code. Change the comment.
! 64: * --------------------------------------------------------------------------
! 65: * Reg Clemens (June 2009)
! 66: * change exit statements to return(0) in main program. I had assumed that if the
! 67: * PPS driver did not start for some reason, we shuould stop NTPD itelf. Others
! 68: * disagree. We now give an ERR log message and stop this driver.
! 69: * --------------------------------------------------------------------------
! 70: * Reg Clemens (June 2009)
! 71: * A bytes available message for the input subsystem (Debug message).
! 72: * --------------------------------------------------------------------------
! 73: * Reg Clemens (Nov 2008)
! 74: * This code adds a message for TRAIM messages. Users often worry about the
! 75: * driver not starting up, and it is often because of signal strength being low.
! 76: * Low signal strength will give TRAIM messages.
! 77: * --------------------------------------------------------------------------
! 78: * Reg Clemens (Nov 2008)
! 79: * Add waiting on Almanac Message.
! 80: * --------------------------------------------------------------------------
! 81: * Reg Clemens (Nov 2008)
! 82: * Add back in @@Bl code to do the @@Bj/@@Gj that is in later ONCOREs
! 83: * LEAP SECONDS: All of the ONCORE receivers, VP -> M12T have the @@Bj command
! 84: * that says 'Leap Pending'. As documented it only becomes true in the month
! 85: * before the leap second is to be applied, but in practice at least some of
! 86: * the receivers turn this indicator on as soon as the message is posted, which
! 87: * can be 6months early. As such, we use the Bj command to turn on the
! 88: * instance->pp->leap indicator but only run this test in December and June for
! 89: * updates on 1Jan and 1July.
! 90: *
! 91: * The @@Gj command exists in later ONCOREs, and it gives the exact date
! 92: * and size of the Leap Update. It can be emulated in the VP using the @@Bl
! 93: * command which reads the raw Satellite Broadcast Messages.
! 94: * We use these two commands to print informative messages in the clockstats
! 95: * file once per day as soon as the message appears on the satellites.
! 96: * --------------------------------------------------------------------------
! 97: * Reg Clemens (Feb 2006)
! 98: * Fix some gcc4 compiler complaints
! 99: * Fix possible segfault in oncore_init_shmem
! 100: * change all (possible) fprintf(stderr, to record_clock_stats
! 101: * Apply patch from Russell J. Yount <rjy@cmu.edu> Fixed (new) MT12+T UTC not correct
! 102: * immediately after new Almanac Read.
! 103: * Apply patch for new PPS implementation by Rodolfo Giometti <giometti@linux.it>
! 104: * now code can use old Ulrich Windl <Ulrich.Windl@rz.uni-regensburg.de> or
! 105: * the new one. Compiles depending on timepps.h seen.
! 106: * --------------------------------------------------------------------------
! 107: * Luis Batanero Guerrero <luisba@rao.es> (Dec 2005) Patch for leap seconds
! 108: * (the oncore driver was setting the wrong ntpd variable)
! 109: * --------------------------------------------------------------------------
! 110: * Reg.Clemens (Mar 2004)
! 111: * Support for interfaces other than PPSAPI removed, for Solaris, SunOS,
! 112: * SCO, you now need to use one of the timepps.h files in the root dir.
! 113: * this driver will 'grab' it for you if you dont have one in /usr/include
! 114: * --------------------------------------------------------------------------
! 115: * This code uses the two devices
! 116: * /dev/oncore.serial.n
! 117: * /dev/oncore.pps.n
! 118: * which may be linked to the same device.
! 119: * and can read initialization data from the file
! 120: * /etc/ntp.oncoreN, /etc/ntp.oncore.N, or /etc/ntp.oncore, where
! 121: * n or N are the unit number, viz 127.127.30.N.
! 122: * --------------------------------------------------------------------------
! 123: * Reg.Clemens <reg@dwf.com> Sep98.
! 124: * Original code written for FreeBSD.
! 125: * With these mods it works on FreeBSD, SunOS, Solaris and Linux
! 126: * (SunOS 4.1.3 + ppsclock)
! 127: * (Solaris7 + MU4)
! 128: * (RedHat 5.1 2.0.35 + PPSKit, 2.1.126 + or later).
! 129: *
! 130: * Lat,Long,Ht, cable-delay, offset, and the ReceiverID (along with the
! 131: * state machine state) are printed to CLOCKSTATS if that file is enabled
! 132: * in /etc/ntp.conf.
! 133: *
! 134: * --------------------------------------------------------------------------
! 135: *
! 136: * According to the ONCORE manual (TRM0003, Rev 3.2, June 1998, page 3.13)
! 137: * doing an average of 10000 valid 2D and 3D fixes is what the automatic
! 138: * site survey mode does. Looking at the output from the receiver
! 139: * it seems like it is only using 3D fixes.
! 140: * When we do it ourselves, take 10000 3D fixes.
! 141: */
! 142:
! 143: #define POS_HOLD_AVERAGE 10000 /* nb, 10000s ~= 2h45m */
! 144:
! 145: /*
! 146: * ONCORE_SHMEM_STATUS will create a mmap(2)'ed file named according to a
! 147: * "STATUS" line in the oncore config file, which contains the most recent
! 148: * copy of all types of messages we recognize. This file can be mmap(2)'ed
! 149: * by monitoring and statistics programs.
! 150: *
! 151: * See separate HTML documentation for this option.
! 152: */
! 153:
! 154: #ifdef HAVE_CONFIG_H
! 155: #include <config.h>
! 156: #endif
! 157:
! 158: #if defined(REFCLOCK) && defined(CLOCK_ONCORE)
! 159:
! 160: #include "ntpd.h"
! 161: #include "ntp_io.h"
! 162: #include "ntp_unixtime.h"
! 163: #include "ntp_refclock.h"
! 164: #include "ntp_stdlib.h"
! 165:
! 166: #include <stdio.h>
! 167: #include <ctype.h>
! 168: #include <sys/stat.h>
! 169: #ifdef ONCORE_SHMEM_STATUS
! 170: # ifdef HAVE_SYS_MMAN_H
! 171: # include <sys/mman.h>
! 172: # ifndef MAP_FAILED
! 173: # define MAP_FAILED ((u_char *) -1)
! 174: # endif /* MAP_FAILED */
! 175: # endif /* HAVE_SYS_MMAN_H */
! 176: #endif /* ONCORE_SHMEM_STATUS */
! 177:
! 178: #ifdef HAVE_PPSAPI
! 179: # include "ppsapi_timepps.h"
! 180: #endif
! 181:
! 182: #ifdef HAVE_SYS_SIO_H
! 183: # include <sys/sio.h>
! 184: #endif
! 185:
! 186: struct Bl {
! 187: int dt_ls;
! 188: int dt_lsf;
! 189: int WN;
! 190: int DN;
! 191: int WN_lsf;
! 192: int DN_lsf;
! 193: int wn_flg;
! 194: int lsf_flg;
! 195: int Bl_day;
! 196: } Bl;
! 197:
! 198: enum receive_state {
! 199: ONCORE_NO_IDEA,
! 200: ONCORE_CHECK_ID,
! 201: ONCORE_CHECK_CHAN,
! 202: ONCORE_HAVE_CHAN,
! 203: ONCORE_RESET_SENT,
! 204: ONCORE_TEST_SENT,
! 205: ONCORE_INIT,
! 206: ONCORE_ALMANAC,
! 207: ONCORE_RUN
! 208: };
! 209:
! 210: enum site_survey_state {
! 211: ONCORE_SS_UNKNOWN,
! 212: ONCORE_SS_TESTING,
! 213: ONCORE_SS_HW,
! 214: ONCORE_SS_SW,
! 215: ONCORE_SS_DONE
! 216: };
! 217:
! 218: enum antenna_state {
! 219: ONCORE_ANTENNA_UNKNOWN = -1,
! 220: ONCORE_ANTENNA_OK = 0,
! 221: ONCORE_ANTENNA_OC = 1,
! 222: ONCORE_ANTENNA_UC = 2,
! 223: ONCORE_ANTENNA_NV = 3
! 224: };
! 225:
! 226: /* Model Name, derived from the @@Cj message.
! 227: * Used to initialize some variables.
! 228: */
! 229:
! 230: enum oncore_model {
! 231: ONCORE_BASIC,
! 232: ONCORE_PVT6,
! 233: ONCORE_VP,
! 234: ONCORE_UT,
! 235: ONCORE_UTPLUS,
! 236: ONCORE_GT,
! 237: ONCORE_GTPLUS,
! 238: ONCORE_SL,
! 239: ONCORE_M12,
! 240: ONCORE_UNKNOWN
! 241: };
! 242:
! 243: /* the bits that describe these properties are in the same place
! 244: * on the VP/UT, but have moved on the M12. As such we extract
! 245: * them, and use them from this struct.
! 246: *
! 247: */
! 248:
! 249: struct RSM {
! 250: u_char posn0D;
! 251: u_char posn2D;
! 252: u_char posn3D;
! 253: u_char bad_almanac;
! 254: u_char bad_fix;
! 255: };
! 256:
! 257: /* It is possible to test the VP/UT each cycle (@@Ea or equivalent) to
! 258: * see what mode it is in. The bits on the M12 are multiplexed with
! 259: * other messages, so we have to 'keep' the last known mode here.
! 260: */
! 261:
! 262: enum posn_mode {
! 263: MODE_UNKNOWN,
! 264: MODE_0D,
! 265: MODE_2D,
! 266: MODE_3D
! 267: };
! 268:
! 269: struct instance {
! 270: int unit; /* 127.127.30.unit */
! 271: struct refclockproc *pp;
! 272: struct peer *peer;
! 273:
! 274: int ttyfd; /* TTY file descriptor */
! 275: int ppsfd; /* PPS file descriptor */
! 276: int shmemfd; /* Status shm descriptor */
! 277: pps_handle_t pps_h;
! 278: pps_params_t pps_p;
! 279: enum receive_state o_state; /* Receive state */
! 280: enum posn_mode mode; /* 0D, 2D, 3D */
! 281: enum site_survey_state site_survey; /* Site Survey state */
! 282: enum antenna_state ant_state; /* antenna state */
! 283:
! 284: int Bj_day;
! 285:
! 286: u_long delay; /* ns */
! 287: long offset; /* ns */
! 288:
! 289: u_char *shmem;
! 290: char *shmem_fname;
! 291: u_int shmem_Cb;
! 292: u_int shmem_Ba;
! 293: u_int shmem_Ea;
! 294: u_int shmem_Ha;
! 295: u_char shmem_reset;
! 296: u_char shmem_Posn;
! 297: u_char shmem_bad_Ea;
! 298: u_char almanac_from_shmem;
! 299:
! 300: double ss_lat;
! 301: double ss_long;
! 302: double ss_ht;
! 303: double dH;
! 304: int ss_count;
! 305: u_char posn_set;
! 306:
! 307: enum oncore_model model;
! 308: u_int version;
! 309: u_int revision;
! 310:
! 311: u_char chan; /* 6 for PVT6 or BASIC, 8 for UT/VP, 12 for m12, 0 if unknown */
! 312: s_char traim; /* do we have traim? yes UT/VP, M12+T, no BASIC, GT, M12, -1 unknown, 0 no, +1 yes */
! 313: /* the following 7 are all timing counters */
! 314: u_char traim_delay; /* seconds counter, waiting for reply */
! 315: u_char count; /* cycles thru Ea before starting */
! 316: u_char count1; /* cycles thru Ea after SS_TESTING, waiting for SS_HW */
! 317: u_char count2; /* cycles thru Ea after count, to check for @@Ea */
! 318: u_char count3; /* cycles thru Ea checking for # channels */
! 319: u_char count4; /* cycles thru leap after Gj to issue Bj */
! 320: u_char count5; /* cycles thru get_timestamp waiting for valid UTC correction */
! 321: u_char count5_set; /* only set count5 once */
! 322: u_char counta; /* count for waiting on almanac message */
! 323: u_char pollcnt;
! 324: u_char timeout; /* count to retry Cj after Fa self-test */
! 325: u_char max_len; /* max length message seen by oncore_log, for debugging */
! 326: u_char max_count; /* count for message statistics */
! 327:
! 328: struct RSM rsm; /* bits extracted from Receiver Status Msg in @@Ea */
! 329: struct Bl Bl; /* Satellite Broadcast Data Message */
! 330: u_char printed;
! 331: u_char polled;
! 332: u_long ev_serial;
! 333: int Rcvptr;
! 334: u_char Rcvbuf[500];
! 335: u_char BEHa[160]; /* Ba, Ea or Ha */
! 336: u_char BEHn[80]; /* Bn , En , or Hn */
! 337: u_char Cj[300];
! 338: u_char Ag; /* Satellite mask angle */
! 339: u_char saw_At;
! 340: u_char saw_Ay;
! 341: u_char saw_Az;
! 342: s_char saw_Bj;
! 343: s_char saw_Gj;
! 344: u_char have_dH;
! 345: u_char init_type;
! 346: s_char saw_tooth;
! 347: s_char chan_in; /* chan number from INPUT, will always use it */
! 348: u_char chan_id; /* chan number determined from part number */
! 349: u_char chan_ck; /* chan number determined by sending commands to hardware */
! 350: s_char traim_in; /* TRAIM from INPUT, will always use ON/OFF specified */
! 351: s_char traim_id; /* TRAIM determined from part number */
! 352: u_char traim_ck; /* TRAIM determined by sending commands to hardware */
! 353: u_char once; /* one pass code at top of BaEaHa */
! 354: s_char assert;
! 355: u_char hardpps;
! 356: };
! 357:
! 358: #define rcvbuf instance->Rcvbuf
! 359: #define rcvptr instance->Rcvptr
! 360:
! 361: static int oncore_start (int, struct peer *);
! 362: static void oncore_poll (int, struct peer *);
! 363: static void oncore_shutdown (int, struct peer *);
! 364: static void oncore_consume (struct instance *);
! 365: static void oncore_read_config (struct instance *);
! 366: static void oncore_receive (struct recvbuf *);
! 367: static int oncore_ppsapi (struct instance *);
! 368: static void oncore_get_timestamp (struct instance *, long, long);
! 369: static void oncore_init_shmem (struct instance *);
! 370:
! 371: static void oncore_antenna_report (struct instance *, enum antenna_state);
! 372: static void oncore_chan_test (struct instance *);
! 373: static void oncore_check_almanac (struct instance *);
! 374: static void oncore_check_antenna (struct instance *);
! 375: static void oncore_check_leap_sec (struct instance *);
! 376: static int oncore_checksum_ok (u_char *, int);
! 377: static void oncore_compute_dH (struct instance *);
! 378: static void oncore_load_almanac (struct instance *);
! 379: static void oncore_log (struct instance *, int, const char *);
! 380: static void oncore_print_Cb (struct instance *, u_char *);
! 381: /* static void oncore_print_array (u_char *, int); */
! 382: static void oncore_print_posn (struct instance *);
! 383: static void oncore_sendmsg (struct instance *, u_char *, size_t);
! 384: static void oncore_set_posn (struct instance *);
! 385: static void oncore_set_traim (struct instance *);
! 386: static void oncore_shmem_get_3D (struct instance *);
! 387: static void oncore_ss (struct instance *);
! 388: static int oncore_wait_almanac (struct instance *);
! 389:
! 390: static void oncore_msg_any (struct instance *, u_char *, size_t, int);
! 391: static void oncore_msg_Adef (struct instance *, u_char *, size_t);
! 392: static void oncore_msg_Ag (struct instance *, u_char *, size_t);
! 393: static void oncore_msg_As (struct instance *, u_char *, size_t);
! 394: static void oncore_msg_At (struct instance *, u_char *, size_t);
! 395: static void oncore_msg_Ay (struct instance *, u_char *, size_t);
! 396: static void oncore_msg_Az (struct instance *, u_char *, size_t);
! 397: static void oncore_msg_BaEaHa (struct instance *, u_char *, size_t);
! 398: static void oncore_msg_Bd (struct instance *, u_char *, size_t);
! 399: static void oncore_msg_Bj (struct instance *, u_char *, size_t);
! 400: static void oncore_msg_Bl (struct instance *, u_char *, size_t);
! 401: static void oncore_msg_BnEnHn (struct instance *, u_char *, size_t);
! 402: static void oncore_msg_CaFaIa (struct instance *, u_char *, size_t);
! 403: static void oncore_msg_Cb (struct instance *, u_char *, size_t);
! 404: static void oncore_msg_Cf (struct instance *, u_char *, size_t);
! 405: static void oncore_msg_Cj (struct instance *, u_char *, size_t);
! 406: static void oncore_msg_Cj_id (struct instance *, u_char *, size_t);
! 407: static void oncore_msg_Cj_init (struct instance *, u_char *, size_t);
! 408: static void oncore_msg_Ga (struct instance *, u_char *, size_t);
! 409: static void oncore_msg_Gb (struct instance *, u_char *, size_t);
! 410: static void oncore_msg_Gj (struct instance *, u_char *, size_t);
! 411: static void oncore_msg_Sz (struct instance *, u_char *, size_t);
! 412:
! 413: struct refclock refclock_oncore = {
! 414: oncore_start, /* start up driver */
! 415: oncore_shutdown, /* shut down driver */
! 416: oncore_poll, /* transmit poll message */
! 417: noentry, /* not used */
! 418: noentry, /* not used */
! 419: noentry, /* not used */
! 420: NOFLAGS /* not used */
! 421: };
! 422:
! 423: /*
! 424: * Understanding the next bit here is not easy unless you have a manual
! 425: * for the the various Oncore Models.
! 426: */
! 427:
! 428: static struct msg_desc {
! 429: const char flag[3];
! 430: const int len;
! 431: void (*handler) (struct instance *, u_char *, size_t);
! 432: const char *fmt;
! 433: int shmem;
! 434: } oncore_messages[] = {
! 435: /* Ea and En first since they're most common */
! 436: { "Ea", 76, oncore_msg_BaEaHa, "mdyyhmsffffaaaaoooohhhhmmmmvvhhddtntimsdimsdimsdimsdimsdimsdimsdimsdsC" },
! 437: { "Ba", 68, oncore_msg_BaEaHa, "mdyyhmsffffaaaaoooohhhhmmmmvvhhddtntimsdimsdimsdimsdimsdimsdsC" },
! 438: { "Ha", 154, oncore_msg_BaEaHa, "mdyyhmsffffaaaaoooohhhhmmmmaaaaoooohhhhmmmmVVvvhhddntimsiddimsiddimsiddimsiddimsiddimsiddimsiddimsiddimsiddimsiddimsiddimsiddssrrccooooTTushmvvvvvvC" },
! 439: { "Bn", 59, oncore_msg_BnEnHn, "otaapxxxxxxxxxxpysreensffffsffffsffffsffffsffffsffffC" },
! 440: { "En", 69, oncore_msg_BnEnHn, "otaapxxxxxxxxxxpysreensffffsffffsffffsffffsffffsffffsffffsffffC" },
! 441: { "Hn", 78, oncore_msg_BnEnHn, "" },
! 442: { "Ab", 10, 0, "" },
! 443: { "Ac", 11, 0, "" },
! 444: { "Ad", 11, oncore_msg_Adef, "" },
! 445: { "Ae", 11, oncore_msg_Adef, "" },
! 446: { "Af", 15, oncore_msg_Adef, "" },
! 447: { "Ag", 8, oncore_msg_Ag, "" }, /* Satellite mask angle */
! 448: { "As", 20, oncore_msg_As, "" },
! 449: { "At", 8, oncore_msg_At, "" },
! 450: { "Au", 12, 0, "" },
! 451: { "Av", 8, 0, "" },
! 452: { "Aw", 8, 0, "" },
! 453: { "Ay", 11, oncore_msg_Ay, "" },
! 454: { "Az", 11, oncore_msg_Az, "" },
! 455: { "AB", 8, 0, "" },
! 456: { "Bb", 92, 0, "" },
! 457: { "Bd", 23, oncore_msg_Bd, "" },
! 458: { "Bj", 8, oncore_msg_Bj, "" },
! 459: { "Bl", 41, oncore_msg_Bl, "" },
! 460: { "Ca", 9, oncore_msg_CaFaIa, "" },
! 461: { "Cb", 33, oncore_msg_Cb, "" },
! 462: { "Cf", 7, oncore_msg_Cf, "" },
! 463: { "Cg", 8, 0, "" },
! 464: { "Ch", 9, 0, "" },
! 465: { "Cj", 294, oncore_msg_Cj, "" },
! 466: { "Ek", 71, 0, "" },
! 467: { "Fa", 9, oncore_msg_CaFaIa, "" },
! 468: { "Ga", 20, oncore_msg_Ga, "" },
! 469: { "Gb", 17, oncore_msg_Gb, "" },
! 470: { "Gc", 8, 0, "" },
! 471: { "Gd", 8, 0, "" },
! 472: { "Ge", 8, 0, "" },
! 473: { "Gj", 21, oncore_msg_Gj, "" },
! 474: { "Ia", 10, oncore_msg_CaFaIa, "" },
! 475: { "Sz", 8, oncore_msg_Sz, "" },
! 476: { {0}, 7, 0, "" }
! 477: };
! 478:
! 479:
! 480: static u_char oncore_cmd_Aa[] = { 'A', 'a', 0, 0, 0 }; /* 6/8 Time of Day */
! 481: static u_char oncore_cmd_Ab[] = { 'A', 'b', 0, 0, 0 }; /* 6/8 GMT Correction */
! 482: static u_char oncore_cmd_AB[] = { 'A', 'B', 4 }; /* VP Application Type: Static */
! 483: static u_char oncore_cmd_Ac[] = { 'A', 'c', 0, 0, 0, 0 }; /* 6/8 Date */
! 484: static u_char oncore_cmd_Ad[] = { 'A', 'd', 0,0,0,0 }; /* 6/8 Latitude */
! 485: static u_char oncore_cmd_Ae[] = { 'A', 'e', 0,0,0,0 }; /* 6/8 Longitude */
! 486: static u_char oncore_cmd_Af[] = { 'A', 'f', 0,0,0,0, 0 }; /* 6/8 Height */
! 487: static u_char oncore_cmd_Ag[] = { 'A', 'g', 0 }; /* 6/8/12 Satellite Mask Angle */
! 488: static u_char oncore_cmd_Agx[] = { 'A', 'g', 0xff }; /* 6/8/12 Satellite Mask Angle: read */
! 489: static u_char oncore_cmd_As[] = { 'A', 's', 0,0,0,0, 0,0,0,0, 0,0,0,0, 0 }; /* 6/8/12 Posn Hold Parameters */
! 490: static u_char oncore_cmd_Asx[] = { 'A', 's', 0x7f,0xff,0xff,0xff, /* 6/8/12 Posn Hold Readback */
! 491: 0x7f,0xff,0xff,0xff, /* on UT+ this doesnt work with 0xff */
! 492: 0x7f,0xff,0xff,0xff, 0xff }; /* but does work with 0x7f (sigh). */
! 493: static u_char oncore_cmd_At0[] = { 'A', 't', 0 }; /* 6/8 Posn Hold: off */
! 494: static u_char oncore_cmd_At1[] = { 'A', 't', 1 }; /* 6/8 Posn Hold: on */
! 495: static u_char oncore_cmd_At2[] = { 'A', 't', 2 }; /* 6/8 Posn Hold: Start Site Survey */
! 496: static u_char oncore_cmd_Atx[] = { 'A', 't', 0xff }; /* 6/8 Posn Hold: Read Back */
! 497: static u_char oncore_cmd_Au[] = { 'A', 'u', 0,0,0,0, 0 }; /* GT/M12 Altitude Hold Ht. */
! 498: static u_char oncore_cmd_Av0[] = { 'A', 'v', 0 }; /* VP/GT Altitude Hold: off */
! 499: static u_char oncore_cmd_Av1[] = { 'A', 'v', 1 }; /* VP/GT Altitude Hold: on */
! 500: static u_char oncore_cmd_Aw[] = { 'A', 'w', 1 }; /* 6/8/12 UTC/GPS time selection */
! 501: static u_char oncore_cmd_Ay[] = { 'A', 'y', 0, 0, 0, 0 }; /* Timing 1PPS time offset: set */
! 502: static u_char oncore_cmd_Ayx[] = { 'A', 'y', 0xff, 0xff, 0xff, 0xff }; /* Timing 1PPS time offset: Read */
! 503: static u_char oncore_cmd_Az[] = { 'A', 'z', 0, 0, 0, 0 }; /* 6/8UT/12 1PPS Cable Delay: set */
! 504: static u_char oncore_cmd_Azx[] = { 'A', 'z', 0xff, 0xff, 0xff, 0xff }; /* 6/8UT/12 1PPS Cable Delay: Read */
! 505: static u_char oncore_cmd_Ba0[] = { 'B', 'a', 0 }; /* 6 Position/Data/Status: off */
! 506: static u_char oncore_cmd_Ba[] = { 'B', 'a', 1 }; /* 6 Position/Data/Status: on */
! 507: static u_char oncore_cmd_Bb[] = { 'B', 'b', 1 }; /* 6/8/12 Visible Satellites */
! 508: static u_char oncore_cmd_Bd[] = { 'B', 'd', 1 }; /* 6/8/12? Almanac Status Msg. */
! 509: static u_char oncore_cmd_Be[] = { 'B', 'e', 1 }; /* 6/8/12 Request Almanac Data */
! 510: static u_char oncore_cmd_Bj[] = { 'B', 'j', 0 }; /* 6/8 Leap Second Pending */
! 511: static u_char oncore_cmd_Bl[] = { 'B', 'l', 1 }; /* VP Satellite Broadcast Data Msg */
! 512: static u_char oncore_cmd_Bn0[] = { 'B', 'n', 0, 1, 0,10, 2, 0,0,0, 0,0,0,0,0,0,0 }; /* 6 TRAIM setup/status: msg off, traim on */
! 513: static u_char oncore_cmd_Bn[] = { 'B', 'n', 1, 1, 0,10, 2, 0,0,0, 0,0,0,0,0,0,0 }; /* 6 TRAIM setup/status: msg on, traim on */
! 514: static u_char oncore_cmd_Bnx[] = { 'B', 'n', 0, 0, 0,10, 2, 0,0,0, 0,0,0,0,0,0,0 }; /* 6 TRAIM setup/status: msg off, traim off */
! 515: static u_char oncore_cmd_Ca[] = { 'C', 'a' }; /* 6 Self Test */
! 516: static u_char oncore_cmd_Cf[] = { 'C', 'f' }; /* 6/8/12 Set to Defaults */
! 517: static u_char oncore_cmd_Cg[] = { 'C', 'g', 1 }; /* VP Posn Fix/Idle Mode */
! 518: static u_char oncore_cmd_Cj[] = { 'C', 'j' }; /* 6/8/12 Receiver ID */
! 519: static u_char oncore_cmd_Ea0[] = { 'E', 'a', 0 }; /* 8 Position/Data/Status: off */
! 520: static u_char oncore_cmd_Ea[] = { 'E', 'a', 1 }; /* 8 Position/Data/Status: on */
! 521: static u_char oncore_cmd_Ek[] = { 'E', 'k', 0 }; /* just turn off */ /* 8 Posn/Status/Data - extension */
! 522: static u_char oncore_cmd_En0[] = { 'E', 'n', 0, 1, 0,10, 2, 0,0,0, 0,0,0,0,0,0,0 }; /* 8/GT TRAIM setup/status: msg off, traim on */
! 523: static u_char oncore_cmd_En[] = { 'E', 'n', 1, 1, 0,10, 2, 0,0,0, 0,0,0,0,0,0,0 }; /* 8/GT TRAIM setup/status: msg on, traim on */
! 524: static u_char oncore_cmd_Enx[] = { 'E', 'n', 0, 0, 0,10, 2, 0,0,0, 0,0,0,0,0,0,0 }; /* 8/GT TRAIM setup/status: msg off, traim off */
! 525: static u_char oncore_cmd_Fa[] = { 'F', 'a' }; /* 8 Self Test */
! 526: static u_char oncore_cmd_Ga[] = { 'G', 'a', 0,0,0,0, 0,0,0,0, 0,0,0,0, 0 }; /* 12 Position Set */
! 527: static u_char oncore_cmd_Gax[] = { 'G', 'a', 0xff, 0xff, 0xff, 0xff, /* 12 Position Set: Read */
! 528: 0xff, 0xff, 0xff, 0xff, /* */
! 529: 0xff, 0xff, 0xff, 0xff, 0xff }; /* */
! 530: static u_char oncore_cmd_Gb[] = { 'G', 'b', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; /* 12 set Date/Time */
! 531: static u_char oncore_cmd_Gc[] = { 'G', 'c', 1 }; /* 12 PPS Control: On Cont */
! 532: static u_char oncore_cmd_Gd0[] = { 'G', 'd', 0 }; /* 12 Position Control: 3D (no hold) */
! 533: static u_char oncore_cmd_Gd1[] = { 'G', 'd', 1 }; /* 12 Position Control: 0D (3D hold) */
! 534: static u_char oncore_cmd_Gd2[] = { 'G', 'd', 2 }; /* 12 Position Control: 2D (Alt Hold) */
! 535: static u_char oncore_cmd_Gd3[] = { 'G', 'd', 3 }; /* 12 Position Coltrol: Start Site Survey */
! 536: static u_char oncore_cmd_Ge0[] = { 'G', 'e', 0 }; /* M12+T TRAIM: off */
! 537: static u_char oncore_cmd_Ge[] = { 'G', 'e', 1 }; /* M12+T TRAIM: on */
! 538: static u_char oncore_cmd_Gj[] = { 'G', 'j' }; /* 8?/12 Leap Second Pending */
! 539: static u_char oncore_cmd_Ha0[] = { 'H', 'a', 0 }; /* 12 Position/Data/Status: off */
! 540: static u_char oncore_cmd_Ha[] = { 'H', 'a', 1 }; /* 12 Position/Data/Status: on */
! 541: static u_char oncore_cmd_Hn0[] = { 'H', 'n', 0 }; /* 12 TRAIM Status: off */
! 542: static u_char oncore_cmd_Hn[] = { 'H', 'n', 1 }; /* 12 TRAIM Status: on */
! 543: static u_char oncore_cmd_Ia[] = { 'I', 'a' }; /* 12 Self Test */
! 544:
! 545: /* it appears that as of 1997/1998, the UT had As,At, but not Au,Av
! 546: * the GT had Au,Av, but not As,At
! 547: * This was as of v2.0 of both firmware sets. possibly 1.3 for UT.
! 548: * Bj in UT at v1.3
! 549: * dont see Bd in UT/GT thru 1999
! 550: * Gj in UT as of 3.0, 1999 , Bj as of 1.3
! 551: */
! 552:
! 553: static char *Month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jly",
! 554: "Aug", "Sep", "Oct", "Nov", "Dec" };
! 555:
! 556: #define DEVICE1 "/dev/oncore.serial.%d" /* name of serial device */
! 557: #define DEVICE2 "/dev/oncore.pps.%d" /* name of pps device */
! 558:
! 559: #define SPEED B9600 /* Oncore Binary speed (9600 bps) */
! 560:
! 561: /*
! 562: * Assemble and disassemble 32bit signed quantities from a buffer.
! 563: *
! 564: */
! 565:
! 566: /* to buffer, int w, u_char *buf */
! 567: #define w32_buf(buf,w) { u_int i_tmp; \
! 568: i_tmp = (w<0) ? (~(-w)+1) : (w); \
! 569: (buf)[0] = (i_tmp >> 24) & 0xff; \
! 570: (buf)[1] = (i_tmp >> 16) & 0xff; \
! 571: (buf)[2] = (i_tmp >> 8) & 0xff; \
! 572: (buf)[3] = (i_tmp ) & 0xff; \
! 573: }
! 574:
! 575: #define w32(buf) (((buf)[0]&0xff) << 24 | \
! 576: ((buf)[1]&0xff) << 16 | \
! 577: ((buf)[2]&0xff) << 8 | \
! 578: ((buf)[3]&0xff) )
! 579:
! 580: /* from buffer, char *buf, result to an int */
! 581: #define buf_w32(buf) (((buf)[0]&0200) ? (-(~w32(buf)+1)) : w32(buf))
! 582:
! 583:
! 584: /*
! 585: * oncore_start - initialize data for processing
! 586: */
! 587:
! 588: static int
! 589: oncore_start(
! 590: int unit,
! 591: struct peer *peer
! 592: )
! 593: {
! 594: #define STRING_LEN 32
! 595: register struct instance *instance;
! 596: struct refclockproc *pp;
! 597: int fd1, fd2;
! 598: char device1[STRING_LEN], device2[STRING_LEN], Msg[160];
! 599: struct stat stat1, stat2;
! 600:
! 601: /* create instance structure for this unit */
! 602:
! 603: instance = emalloc(sizeof(*instance));
! 604: memset(instance, 0, sizeof(*instance));
! 605:
! 606: /* initialize miscellaneous variables */
! 607:
! 608: pp = peer->procptr;
! 609: pp->unitptr = (caddr_t) instance;
! 610: instance->pp = pp;
! 611: instance->unit = unit;
! 612: instance->peer = peer;
! 613: instance->assert = 1;
! 614: instance->once = 1;
! 615:
! 616: instance->Bj_day = -1;
! 617: instance->traim = -1;
! 618: instance->traim_in = -1;
! 619: instance->chan_in = -1;
! 620: instance->model = ONCORE_UNKNOWN;
! 621: instance->mode = MODE_UNKNOWN;
! 622: instance->site_survey = ONCORE_SS_UNKNOWN;
! 623: instance->Ag = 0xff; /* Satellite mask angle, unset by user */
! 624: instance->ant_state = ONCORE_ANTENNA_UNKNOWN;
! 625:
! 626: peer->precision = -26;
! 627: peer->minpoll = 4;
! 628: peer->maxpoll = 4;
! 629: pp->clockdesc = "Motorola Oncore GPS Receiver";
! 630: memcpy((char *)&pp->refid, "GPS\0", (size_t) 4);
! 631:
! 632: oncore_log(instance, LOG_NOTICE, "ONCORE DRIVER -- CONFIGURING");
! 633: instance->o_state = ONCORE_NO_IDEA;
! 634: oncore_log(instance, LOG_NOTICE, "state = ONCORE_NO_IDEA");
! 635:
! 636: /* Now open files.
! 637: * This is a bit complicated, a we dont want to open the same file twice
! 638: * (its a problem on some OS), and device2 may not exist for the new PPS
! 639: */
! 640:
! 641: (void)snprintf(device1, sizeof(device1), DEVICE1, unit);
! 642: (void)snprintf(device2, sizeof(device2), DEVICE2, unit);
! 643:
! 644: /* OPEN DEVICES */
! 645: /* opening different devices for fd1 and fd2 presents no problems */
! 646: /* opening the SAME device twice, seems to be OS dependent.
! 647: (a) on Linux (no streams) no problem
! 648: (b) on SunOS (and possibly Solaris, untested), (streams)
! 649: never see the line discipline.
! 650: Since things ALWAYS work if we only open the device once, we check
! 651: to see if the two devices are in fact the same, then proceed to
! 652: do one open or two.
! 653:
! 654: For use with linuxPPS we assume that the N_TTY file has been opened
! 655: and that the line discipline has been changed to N_PPS by another
! 656: program (say ppsldisc) so that the two files expected by the oncore
! 657: driver can be opened.
! 658:
! 659: Note that the linuxPPS N_PPS file is just like a N_TTY, so we can do
! 660: the stat below without error even though the file has already had its
! 661: line discipline changed by another process.
! 662:
! 663: The Windows port of ntpd arranges to return duplicate handles for
! 664: multiple opens of the same serial device, and doesn't have inodes
! 665: for serial handles, so we just open both on Windows.
! 666: */
! 667: #ifndef SYS_WINNT
! 668: if (stat(device1, &stat1)) {
! 669: snprintf(Msg, sizeof(Msg), "Can't stat fd1 (%s)",
! 670: device1);
! 671: oncore_log(instance, LOG_ERR, Msg);
! 672: return(0); /* exit, no file, can't start driver */
! 673: }
! 674:
! 675: if (stat(device2, &stat2)) {
! 676: stat2.st_dev = stat2.st_ino = -2;
! 677: snprintf(Msg, sizeof(Msg),
! 678: "Can't stat fd2 (%s) errno = %d",
! 679: device2, errno);
! 680: oncore_log(instance, LOG_ERR, Msg);
! 681: }
! 682: #endif /* !SYS_WINNT */
! 683:
! 684: if (!(fd1 = refclock_open(device1, SPEED, LDISC_RAW))) {
! 685: snprintf(Msg, sizeof(Msg), "Can't open fd1 (%s)",
! 686: device1);
! 687: oncore_log(instance, LOG_ERR, Msg);
! 688: return(0); /* exit, can't open file, can't start driver */
! 689: }
! 690:
! 691: /* for LINUX the PPS device is the result of a line discipline.
! 692: It seems simplest to let an external program create the appropriate
! 693: /dev/pps<n> file, and only check (carefully) for its existance here
! 694: */
! 695:
! 696: #ifndef SYS_WINNT
! 697: if ((stat1.st_dev == stat2.st_dev) && (stat1.st_ino == stat2.st_ino)) /* same device here */
! 698: fd2 = fd1;
! 699: else
! 700: #endif /* !SYS_WINNT */
! 701: { /* different devices here */
! 702: if ((fd2=tty_open(device2, O_RDWR, 0777)) < 0) {
! 703: snprintf(Msg, sizeof(Msg),
! 704: "Can't open fd2 (%s)", device2);
! 705: oncore_log(instance, LOG_ERR, Msg);
! 706: return(0); /* exit, can't open PPS file, can't start driver */
! 707: }
! 708: }
! 709:
! 710: /* open ppsapi source */
! 711:
! 712: if (time_pps_create(fd2, &instance->pps_h) < 0) {
! 713: oncore_log(instance, LOG_ERR, "exit, PPSAPI not found in kernel");
! 714: return(0); /* exit, don't find PPSAPI in kernel */
! 715: }
! 716:
! 717: /* continue initialization */
! 718:
! 719: instance->ttyfd = fd1;
! 720: instance->ppsfd = fd2;
! 721:
! 722: /* go read any input data in /etc/ntp.oncoreX or /etc/ntp/oncore.X */
! 723:
! 724: oncore_read_config(instance);
! 725:
! 726: if (!oncore_ppsapi(instance))
! 727: return(0);
! 728:
! 729: pp->io.clock_recv = oncore_receive;
! 730: pp->io.srcclock = (caddr_t)peer;
! 731: pp->io.datalen = 0;
! 732: pp->io.fd = fd1;
! 733: if (!io_addclock(&pp->io)) {
! 734: oncore_log(instance, LOG_ERR, "can't do io_addclock");
! 735: (void) close(fd1);
! 736: free(instance);
! 737: return (0);
! 738: }
! 739:
! 740: #ifdef ONCORE_SHMEM_STATUS
! 741: /*
! 742: * Before starting ONCORE, lets setup SHMEM
! 743: * This will include merging an old SHMEM into the new one if
! 744: * an old one is found.
! 745: */
! 746:
! 747: oncore_init_shmem(instance);
! 748: #endif
! 749:
! 750: /*
! 751: * This will return the Model of the Oncore receiver.
! 752: * and start the Initialization loop in oncore_msg_Cj.
! 753: */
! 754:
! 755: instance->o_state = ONCORE_CHECK_ID;
! 756: oncore_log(instance, LOG_NOTICE, "state = ONCORE_CHECK_ID");
! 757:
! 758: instance->timeout = 4;
! 759: oncore_sendmsg(instance, oncore_cmd_Cg, sizeof(oncore_cmd_Cg)); /* Set Posn Fix mode (not Idle (VP)) */
! 760: oncore_sendmsg(instance, oncore_cmd_Cj, sizeof(oncore_cmd_Cj));
! 761:
! 762: instance->pollcnt = 2;
! 763: return (1);
! 764: }
! 765:
! 766:
! 767: /*
! 768: * oncore_shutdown - shut down the clock
! 769: */
! 770:
! 771: static void
! 772: oncore_shutdown(
! 773: int unit,
! 774: struct peer *peer
! 775: )
! 776: {
! 777: register struct instance *instance;
! 778: struct refclockproc *pp;
! 779:
! 780: pp = peer->procptr;
! 781: instance = (struct instance *) pp->unitptr;
! 782:
! 783: io_closeclock(&pp->io);
! 784:
! 785: time_pps_destroy (instance->pps_h);
! 786:
! 787: close(instance->ttyfd);
! 788:
! 789: if ((instance->ppsfd != -1) && (instance->ppsfd != instance->ttyfd))
! 790: close(instance->ppsfd);
! 791:
! 792: if (instance->shmemfd)
! 793: close(instance->shmemfd);
! 794:
! 795: free(instance);
! 796: }
! 797:
! 798:
! 799:
! 800: /*
! 801: * oncore_poll - called by the transmit procedure
! 802: */
! 803:
! 804: static void
! 805: oncore_poll(
! 806: int unit,
! 807: struct peer *peer
! 808: )
! 809: {
! 810: struct instance *instance;
! 811:
! 812: instance = (struct instance *) peer->procptr->unitptr;
! 813: if (instance->timeout) {
! 814: instance->timeout--;
! 815: if (instance->timeout == 0) {
! 816: oncore_log(instance, LOG_ERR,
! 817: "Oncore: No response from @@Cj, shutting down driver");
! 818: oncore_shutdown(unit, peer);
! 819: } else {
! 820: oncore_sendmsg(instance, oncore_cmd_Cj, sizeof(oncore_cmd_Cj));
! 821: oncore_log(instance, LOG_WARNING, "Oncore: Resend @@Cj");
! 822: }
! 823: return;
! 824: }
! 825:
! 826: if (!instance->pollcnt)
! 827: refclock_report(peer, CEVNT_TIMEOUT);
! 828: else
! 829: instance->pollcnt--;
! 830: peer->procptr->polls++;
! 831: instance->polled = 1;
! 832: }
! 833:
! 834:
! 835:
! 836: /*
! 837: * Initialize PPSAPI
! 838: */
! 839:
! 840: static int
! 841: oncore_ppsapi(
! 842: struct instance *instance
! 843: )
! 844: {
! 845: int cap, mode, mode1;
! 846: char *cp, Msg[160];
! 847:
! 848: if (time_pps_getcap(instance->pps_h, &cap) < 0) {
! 849: msnprintf(Msg, sizeof(Msg), "time_pps_getcap failed: %m");
! 850: oncore_log(instance, LOG_ERR, Msg);
! 851: return (0);
! 852: }
! 853:
! 854: if (time_pps_getparams(instance->pps_h, &instance->pps_p) < 0) {
! 855: msnprintf(Msg, sizeof(Msg), "time_pps_getparams failed: %m");
! 856: oncore_log(instance, LOG_ERR, Msg);
! 857: return (0);
! 858: }
! 859:
! 860: /* nb. only turn things on, if someone else has turned something
! 861: * on before we get here, leave it alone!
! 862: */
! 863:
! 864: if (instance->assert) {
! 865: cp = "Assert";
! 866: mode = PPS_CAPTUREASSERT;
! 867: mode1 = PPS_OFFSETASSERT;
! 868: } else {
! 869: cp = "Clear";
! 870: mode = PPS_CAPTURECLEAR;
! 871: mode1 = PPS_OFFSETCLEAR;
! 872: }
! 873: snprintf(Msg, sizeof(Msg), "Initializing timing to %s.", cp);
! 874: oncore_log(instance, LOG_INFO, Msg);
! 875:
! 876: if (!(mode & cap)) {
! 877: snprintf(Msg, sizeof(Msg),
! 878: "Can't set timing to %s, exiting...", cp);
! 879: oncore_log(instance, LOG_ERR, Msg);
! 880: return(0);
! 881: }
! 882:
! 883: if (!(mode1 & cap)) {
! 884: snprintf(Msg, sizeof(Msg),
! 885: "Can't set %s, this will increase jitter.", cp);
! 886: oncore_log(instance, LOG_NOTICE, Msg);
! 887: mode1 = 0;
! 888: }
! 889:
! 890: /* only set what is legal */
! 891:
! 892: instance->pps_p.mode = (mode | mode1 | PPS_TSFMT_TSPEC) & cap;
! 893:
! 894: if (time_pps_setparams(instance->pps_h, &instance->pps_p) < 0) {
! 895: oncore_log(instance, LOG_ERR, "ONCORE: time_pps_setparams fails");
! 896: return(0); /* exit, can't do time_pps_setparans on PPS file */
! 897: }
! 898:
! 899: /* If HARDPPS is on, we tell kernel */
! 900:
! 901: if (instance->hardpps) {
! 902: int i;
! 903:
! 904: oncore_log(instance, LOG_INFO, "HARDPPS Set.");
! 905:
! 906: if (instance->assert)
! 907: i = PPS_CAPTUREASSERT;
! 908: else
! 909: i = PPS_CAPTURECLEAR;
! 910:
! 911: /* we know that 'i' is legal from above */
! 912:
! 913: if (time_pps_kcbind(instance->pps_h, PPS_KC_HARDPPS, i,
! 914: PPS_TSFMT_TSPEC) < 0) {
! 915: msnprintf(Msg, sizeof(Msg), "time_pps_kcbind failed: %m");
! 916: oncore_log(instance, LOG_ERR, Msg);
! 917: oncore_log(instance, LOG_ERR, "HARDPPS failed, abort...");
! 918: return (0);
! 919: }
! 920:
! 921: pps_enable = 1;
! 922: }
! 923: return(1);
! 924: }
! 925:
! 926:
! 927:
! 928: #ifdef ONCORE_SHMEM_STATUS
! 929: static void
! 930: oncore_init_shmem(
! 931: struct instance *instance
! 932: )
! 933: {
! 934: int i, l, n, fd, shmem_old_size, n1;
! 935: char Msg[160];
! 936: u_char *cp, *cp1, *buf, *shmem_old;
! 937: struct msg_desc *mp;
! 938: struct stat sbuf;
! 939: size_t shmem_length;
! 940:
! 941: /*
! 942: * The first thing we do is see if there is an instance->shmem_fname file (still)
! 943: * out there from a previous run. If so, we copy it in and use it to initialize
! 944: * shmem (so we won't lose our almanac if we need it).
! 945: */
! 946:
! 947: shmem_old = 0;
! 948: shmem_old_size = 0;
! 949: if ((fd = open(instance->shmem_fname, O_RDONLY)) < 0)
! 950: oncore_log(instance, LOG_WARNING, "ONCORE: Can't open SHMEM file");
! 951: else {
! 952: fstat(fd, &sbuf);
! 953: shmem_old_size = sbuf.st_size;
! 954: if (shmem_old_size != 0) {
! 955: shmem_old = emalloc((unsigned) sbuf.st_size);
! 956: read(fd, shmem_old, shmem_old_size);
! 957: }
! 958: close(fd);
! 959: }
! 960:
! 961: /* OK, we now create the NEW SHMEM. */
! 962:
! 963: if ((instance->shmemfd = open(instance->shmem_fname, O_RDWR|O_CREAT|O_TRUNC, 0644)) < 0) {
! 964: oncore_log(instance, LOG_WARNING, "ONCORE: Can't open shmem");
! 965: if (shmem_old)
! 966: free(shmem_old);
! 967:
! 968: return;
! 969: }
! 970:
! 971: /* see how big it needs to be */
! 972:
! 973: n = 1;
! 974: for (mp=oncore_messages; mp->flag[0]; mp++) {
! 975: mp->shmem = n;
! 976: /* Allocate space for multiplexed almanac, and 0D/2D/3D @@Ea records */
! 977: if (!strcmp(mp->flag, "Cb")) {
! 978: instance->shmem_Cb = n;
! 979: n += (mp->len + 3) * 34;
! 980: }
! 981: if (!strcmp(mp->flag, "Ba")) {
! 982: instance->shmem_Ba = n;
! 983: n += (mp->len + 3) * 3;
! 984: }
! 985: if (!strcmp(mp->flag, "Ea")) {
! 986: instance->shmem_Ea = n;
! 987: n += (mp->len + 3) * 3;
! 988: }
! 989: if (!strcmp(mp->flag, "Ha")) {
! 990: instance->shmem_Ha = n;
! 991: n += (mp->len + 3) * 3;
! 992: }
! 993: n += (mp->len + 3);
! 994: }
! 995: shmem_length = n + 2;
! 996:
! 997: buf = emalloc(shmem_length);
! 998: memset(buf, 0, shmem_length);
! 999:
! 1000: /* next build the new SHMEM buffer in memory */
! 1001:
! 1002: for (mp=oncore_messages; mp->flag[0]; mp++) {
! 1003: l = mp->shmem;
! 1004: buf[l + 0] = mp->len >> 8;
! 1005: buf[l + 1] = mp->len & 0xff;
! 1006: buf[l + 2] = 0;
! 1007: buf[l + 3] = '@';
! 1008: buf[l + 4] = '@';
! 1009: buf[l + 5] = mp->flag[0];
! 1010: buf[l + 6] = mp->flag[1];
! 1011: if (!strcmp(mp->flag, "Cb") || !strcmp(mp->flag, "Ba") || !strcmp(mp->flag, "Ea") || !strcmp(mp->flag, "Ha")) {
! 1012: if (!strcmp(mp->flag, "Cb"))
! 1013: n = 35;
! 1014: else
! 1015: n = 4;
! 1016: for (i=1; i<n; i++) {
! 1017: buf[l + i * (mp->len+3) + 0] = mp->len >> 8;
! 1018: buf[l + i * (mp->len+3) + 1] = mp->len & 0xff;
! 1019: buf[l + i * (mp->len+3) + 2] = 0;
! 1020: buf[l + i * (mp->len+3) + 3] = '@';
! 1021: buf[l + i * (mp->len+3) + 4] = '@';
! 1022: buf[l + i * (mp->len+3) + 5] = mp->flag[0];
! 1023: buf[l + i * (mp->len+3) + 6] = mp->flag[1];
! 1024: }
! 1025: }
! 1026: }
! 1027:
! 1028: /* we now walk thru the two buffers (shmem_old and buf, soon to become shmem)
! 1029: * copying the data in shmem_old to buf.
! 1030: * When we are done we write it out and free both buffers.
! 1031: * If the structure sizes dont agree, I will not copy.
! 1032: * This could be due to an addition/deletion or a problem with the disk file.
! 1033: */
! 1034:
! 1035: if (shmem_old) {
! 1036: if (shmem_old_size == shmem_length) {
! 1037: for (cp=buf+4, cp1=shmem_old+4; (n = 256*(*(cp-3)) + *(cp-2)); cp+=(n+3), cp1+=(n+3)) {
! 1038: n1 = 256*(*(cp1-3)) + *(cp1-2);
! 1039: if (n == 0 || n1 != n || strncmp((char *) cp, (char *) cp1, 4))
! 1040: break;
! 1041:
! 1042: memcpy(cp, cp1, (size_t) n);
! 1043: }
! 1044: }
! 1045: free(shmem_old);
! 1046: }
! 1047:
! 1048: i = write(instance->shmemfd, buf, shmem_length);
! 1049: free(buf);
! 1050:
! 1051: if (i != shmem_length) {
! 1052: oncore_log(instance, LOG_ERR, "ONCORE: error writing shmem");
! 1053: close(instance->shmemfd);
! 1054: return;
! 1055: }
! 1056:
! 1057: instance->shmem = (u_char *) mmap(0, shmem_length,
! 1058: PROT_READ | PROT_WRITE,
! 1059: #ifdef MAP_HASSEMAPHORE
! 1060: MAP_HASSEMAPHORE |
! 1061: #endif
! 1062: MAP_SHARED, instance->shmemfd, (off_t)0);
! 1063:
! 1064: if (instance->shmem == (u_char *)MAP_FAILED) {
! 1065: instance->shmem = 0;
! 1066: close(instance->shmemfd);
! 1067: return;
! 1068: }
! 1069:
! 1070: snprintf(Msg, sizeof(Msg),
! 1071: "SHMEM (size = %ld) is CONFIGURED and available as %s",
! 1072: (u_long) shmem_length, instance->shmem_fname);
! 1073: oncore_log(instance, LOG_NOTICE, Msg);
! 1074: }
! 1075: #endif /* ONCORE_SHMEM_STATUS */
! 1076:
! 1077:
! 1078:
! 1079: /*
! 1080: * Read Input file if it exists.
! 1081: */
! 1082:
! 1083: static void
! 1084: oncore_read_config(
! 1085: struct instance *instance
! 1086: )
! 1087: {
! 1088: /*
! 1089: * First we try to open the configuration file
! 1090: * /etc/ntp.oncore.N
! 1091: * where N is the unit number viz 127.127.30.N.
! 1092: * If we don't find it we try
! 1093: * /etc/ntp.oncoreN
! 1094: * and then
! 1095: * /etc/ntp.oncore
! 1096: *
! 1097: * If we don't find any then we don't have the cable delay or PPS offset
! 1098: * and we choose MODE (4) below.
! 1099: *
! 1100: * Five Choices for MODE
! 1101: * (0) ONCORE is preinitialized, don't do anything to change it.
! 1102: * nb, DON'T set 0D mode, DON'T set Delay, position...
! 1103: * (1) NO RESET, Read Position, delays from data file, lock it in, go to 0D mode.
! 1104: * (2) NO RESET, Read Delays from data file, do SITE SURVEY to get position,
! 1105: * lock this in, go to 0D mode.
! 1106: * (3) HARD RESET, Read Position, delays from data file, lock it in, go to 0D mode.
! 1107: * (4) HARD RESET, Read Delays from data file, do SITE SURVEY to get position,
! 1108: * lock this in, go to 0D mode.
! 1109: * NB. If a POSITION is specified in the config file with mode=(2,4) [SITE SURVEY]
! 1110: * then this position is set as the INITIAL position of the ONCORE.
! 1111: * This can reduce the time to first fix.
! 1112: * -------------------------------------------------------------------------------
! 1113: * Note that an Oncore UT without a battery backup retains NO information if it is
! 1114: * power cycled, with a Battery Backup it remembers the almanac, etc.
! 1115: * For an Oncore VP, there is an eeprom that will contain this data, along with the
! 1116: * option of Battery Backup.
! 1117: * So a UT without Battery Backup is equivalent to doing a HARD RESET on each
! 1118: * power cycle, since there is nowhere to store the data.
! 1119: * -------------------------------------------------------------------------------
! 1120: *
! 1121: * If we open one or the other of the files, we read it looking for
! 1122: * MODE, LAT, LON, (HT, HTGPS, HTMSL), DELAY, OFFSET, ASSERT, CLEAR, HARDPPS,
! 1123: * STATUS, POSN3D, POSN2D, CHAN, TRAIM
! 1124: * then initialize using method MODE. For Mode = (1,3) all of (LAT, LON, HT) must
! 1125: * be present or mode reverts to (2,4).
! 1126: *
! 1127: * Read input file.
! 1128: *
! 1129: * # is comment to end of line
! 1130: * = allowed between 1st and 2nd fields.
! 1131: *
! 1132: * Expect to see one line with 'MODE' as first field, followed by an integer
! 1133: * in the range 0-4 (default = 4).
! 1134: *
! 1135: * Expect to see two lines with 'LONG', 'LAT' followed by 1-3 fields.
! 1136: * All numbers are floating point.
! 1137: * DDD.ddd
! 1138: * DDD MMM.mmm
! 1139: * DDD MMM SSS.sss
! 1140: *
! 1141: * Expect to see one line with 'HT' as first field,
! 1142: * followed by 1-2 fields. First is a number, the second is 'FT' or 'M'
! 1143: * for feet or meters. HT is the height above the GPS ellipsoid.
! 1144: * If the receiver reports height in both GPS and MSL, then we will report
! 1145: * the difference GPS-MSL on the clockstats file.
! 1146: *
! 1147: * There is an optional line, starting with DELAY, followed
! 1148: * by 1 or two fields. The first is a number (a time) the second is
! 1149: * 'MS', 'US' or 'NS' for miliseconds, microseconds or nanoseconds.
! 1150: * DELAY is cable delay, typically a few tens of ns.
! 1151: *
! 1152: * There is an optional line, starting with OFFSET, followed
! 1153: * by 1 or two fields. The first is a number (a time) the second is
! 1154: * 'MS', 'US' or 'NS' for miliseconds, microseconds or nanoseconds.
! 1155: * OFFSET is the offset of the PPS pulse from 0. (only fully implemented
! 1156: * with the PPSAPI, we need to be able to tell the Kernel about this
! 1157: * offset if the Kernel PLL is in use, but can only do this presently
! 1158: * when using the PPSAPI interface. If not using the Kernel PLL,
! 1159: * then there is no problem.
! 1160: *
! 1161: * There is an optional line, with either ASSERT or CLEAR on it, which
! 1162: * determine which transition of the PPS signal is used for timing by the
! 1163: * PPSAPI. If neither is present, then ASSERT is assumed.
! 1164: * ASSERT/CLEAR can also be set with FLAG2 of the ntp.conf input.
! 1165: * For Flag2, ASSERT=0, and hence is default.
! 1166: *
! 1167: * There is an optional line, with HARDPPS on it. Including this line causes
! 1168: * the PPS signal to control the kernel PLL.
! 1169: * HARDPPS can also be set with FLAG3 of the ntp.conf input.
! 1170: * For Flag3, 0 is disabled, and the default.
! 1171: *
! 1172: * There are three options that have to do with using the shared memory option.
! 1173: * First, to enable the option there must be a SHMEM line with a file name.
! 1174: * The file name is the file associated with the shared memory.
! 1175: *
! 1176: * In shared memory, there is one 'record' for each returned variable.
! 1177: * For the @@Ea data there are three 'records' containing position data.
! 1178: * There will always be data in the record corresponding to the '0D' @@Ea record,
! 1179: * and the user has a choice of filling the '3D' record by specifying POSN3D,
! 1180: * or the '2D' record by specifying POSN2D. In either case the '2D' or '3D'
! 1181: * record is filled once every 15s.
! 1182: *
! 1183: * Two additional variables that can be set are CHAN and TRAIM. These should be
! 1184: * set correctly by the code examining the @@Cj record, but we bring them out here
! 1185: * to allow the user to override either the # of channels, or the existence of TRAIM.
! 1186: * CHAN expects to be followed by in integer: 6, 8, or 12. TRAIM expects to be
! 1187: * followed by YES or NO.
! 1188: *
! 1189: * There is an optional line with MASK on it followed by one integer field in the
! 1190: * range 0 to 89. This sets the satellite mask angle and will determine the minimum
! 1191: * elevation angle for satellites to be tracked by the receiver. The default value
! 1192: * is 10 deg for the VP and 0 deg for all other receivers.
! 1193: *
! 1194: * So acceptable input would be
! 1195: * # these are my coordinates (RWC)
! 1196: * LON -106 34.610
! 1197: * LAT 35 08.999
! 1198: * HT 1589 # could equally well say HT 5215 FT
! 1199: * DELAY 60 ns
! 1200: */
! 1201:
! 1202: FILE *fd;
! 1203: char *cp, *cc, *ca, line[100], units[2], device[64], Msg[160], **cpp;
! 1204: char *dirs[] = { "/etc/ntp", "/etc", 0 };
! 1205: int i, sign, lat_flg, long_flg, ht_flg, mode, mask;
! 1206: double f1, f2, f3;
! 1207:
! 1208: fd = NULL; /* just to shutup gcc complaint */
! 1209: for (cpp=dirs; *cpp; cpp++) {
! 1210: cp = *cpp;
! 1211: snprintf(device, sizeof(device), "%s/ntp.oncore.%d",
! 1212: cp, instance->unit); /* try "ntp.oncore.0 */
! 1213: if ((fd=fopen(device, "r")))
! 1214: break;
! 1215: snprintf(device, sizeof(device), "%s/ntp.oncore%d",
! 1216: cp, instance->unit); /* try "ntp.oncore0" */
! 1217: if ((fd=fopen(device, "r")))
! 1218: break;
! 1219: snprintf(device, sizeof(device), "%s/ntp.oncore", cp);
! 1220: if ((fd=fopen(device, "r"))) /* last try "ntp.oncore" */
! 1221: break;
! 1222: }
! 1223:
! 1224: if (!fd) { /* no inputfile, default to the works ... */
! 1225: instance->init_type = 4;
! 1226: return;
! 1227: }
! 1228:
! 1229: mode = mask = 0;
! 1230: lat_flg = long_flg = ht_flg = 0;
! 1231: while (fgets(line, 100, fd)) {
! 1232:
! 1233: /* Remove comments */
! 1234: if ((cp = strchr(line, '#')))
! 1235: *cp = '\0';
! 1236:
! 1237: /* Remove trailing space */
! 1238: for (i = strlen(line);
! 1239: i > 0 && isascii((int)line[i - 1]) && isspace((int)line[i - 1]);
! 1240: )
! 1241: line[--i] = '\0';
! 1242:
! 1243: /* Remove leading space */
! 1244: for (cc = line; *cc && isascii((int)*cc) && isspace((int)*cc); cc++)
! 1245: continue;
! 1246:
! 1247: /* Stop if nothing left */
! 1248: if (!*cc)
! 1249: continue;
! 1250:
! 1251: /* Uppercase the command and find the arg */
! 1252: for (ca = cc; *ca; ca++) {
! 1253: if (isascii((int)*ca)) {
! 1254: if (islower((int)*ca)) {
! 1255: *ca = toupper(*ca);
! 1256: } else if (isspace((int)*ca) || (*ca == '='))
! 1257: break;
! 1258: }
! 1259: }
! 1260:
! 1261: /* Remove space (and possible =) leading the arg */
! 1262: for (; *ca && isascii((int)*ca) && (isspace((int)*ca) || (*ca == '=')); ca++)
! 1263: continue;
! 1264:
! 1265: if (!strncmp(cc, "STATUS", (size_t) 6) || !strncmp(cc, "SHMEM", (size_t) 5)) {
! 1266: instance->shmem_fname = estrdup(ca);
! 1267: continue;
! 1268: }
! 1269:
! 1270: /* Uppercase argument as well */
! 1271: for (cp = ca; *cp; cp++)
! 1272: if (isascii((int)*cp) && islower((int)*cp))
! 1273: *cp = toupper(*cp);
! 1274:
! 1275: if (!strncmp(cc, "LAT", (size_t) 3)) {
! 1276: f1 = f2 = f3 = 0;
! 1277: sscanf(ca, "%lf %lf %lf", &f1, &f2, &f3);
! 1278: sign = 1;
! 1279: if (f1 < 0) {
! 1280: f1 = -f1;
! 1281: sign = -1;
! 1282: }
! 1283: instance->ss_lat = sign*1000*(fabs(f3) + 60*(fabs(f2) + 60*f1)); /*miliseconds*/
! 1284: lat_flg++;
! 1285: } else if (!strncmp(cc, "LON", (size_t) 3)) {
! 1286: f1 = f2 = f3 = 0;
! 1287: sscanf(ca, "%lf %lf %lf", &f1, &f2, &f3);
! 1288: sign = 1;
! 1289: if (f1 < 0) {
! 1290: f1 = -f1;
! 1291: sign = -1;
! 1292: }
! 1293: instance->ss_long = sign*1000*(fabs(f3) + 60*(fabs(f2) + 60*f1)); /*miliseconds*/
! 1294: long_flg++;
! 1295: } else if (!strncmp(cc, "HT", (size_t) 2)) {
! 1296: f1 = 0;
! 1297: units[0] = '\0';
! 1298: sscanf(ca, "%lf %1s", &f1, units);
! 1299: if (units[0] == 'F')
! 1300: f1 = 0.3048 * f1;
! 1301: instance->ss_ht = 100 * f1; /* cm */
! 1302: ht_flg++;
! 1303: } else if (!strncmp(cc, "DELAY", (size_t) 5)) {
! 1304: f1 = 0;
! 1305: units[0] = '\0';
! 1306: sscanf(ca, "%lf %1s", &f1, units);
! 1307: if (units[0] == 'N')
! 1308: ;
! 1309: else if (units[0] == 'U')
! 1310: f1 = 1000 * f1;
! 1311: else if (units[0] == 'M')
! 1312: f1 = 1000000 * f1;
! 1313: else
! 1314: f1 = 1000000000 * f1;
! 1315: if (f1 < 0 || f1 > 1.e9)
! 1316: f1 = 0;
! 1317: if (f1 < 0 || f1 > 999999) {
! 1318: snprintf(Msg, sizeof(Msg),
! 1319: "PPS Cable delay of %fns out of Range, ignored",
! 1320: f1);
! 1321: oncore_log(instance, LOG_WARNING, Msg);
! 1322: } else
! 1323: instance->delay = f1; /* delay in ns */
! 1324: } else if (!strncmp(cc, "OFFSET", (size_t) 6)) {
! 1325: f1 = 0;
! 1326: units[0] = '\0';
! 1327: sscanf(ca, "%lf %1s", &f1, units);
! 1328: if (units[0] == 'N')
! 1329: ;
! 1330: else if (units[0] == 'U')
! 1331: f1 = 1000 * f1;
! 1332: else if (units[0] == 'M')
! 1333: f1 = 1000000 * f1;
! 1334: else
! 1335: f1 = 1000000000 * f1;
! 1336: if (f1 < 0 || f1 > 1.e9)
! 1337: f1 = 0;
! 1338: if (f1 < 0 || f1 > 999999999.) {
! 1339: snprintf(Msg, sizeof(Msg),
! 1340: "PPS Offset of %fns out of Range, ignored",
! 1341: f1);
! 1342: oncore_log(instance, LOG_WARNING, Msg);
! 1343: } else
! 1344: instance->offset = f1; /* offset in ns */
! 1345: } else if (!strncmp(cc, "MODE", (size_t) 4)) {
! 1346: sscanf(ca, "%d", &mode);
! 1347: if (mode < 0 || mode > 4)
! 1348: mode = 4;
! 1349: } else if (!strncmp(cc, "ASSERT", (size_t) 6)) {
! 1350: instance->assert = 1;
! 1351: } else if (!strncmp(cc, "CLEAR", (size_t) 5)) {
! 1352: instance->assert = 0;
! 1353: } else if (!strncmp(cc, "HARDPPS", (size_t) 7)) {
! 1354: instance->hardpps = 1;
! 1355: } else if (!strncmp(cc, "POSN2D", (size_t) 6)) {
! 1356: instance->shmem_Posn = 2;
! 1357: } else if (!strncmp(cc, "POSN3D", (size_t) 6)) {
! 1358: instance->shmem_Posn = 3;
! 1359: } else if (!strncmp(cc, "CHAN", (size_t) 4)) {
! 1360: sscanf(ca, "%d", &i);
! 1361: if ((i == 6) || (i == 8) || (i == 12))
! 1362: instance->chan_in = i;
! 1363: } else if (!strncmp(cc, "TRAIM", (size_t) 5)) {
! 1364: instance->traim_in = 1; /* so TRAIM alone is YES */
! 1365: if (!strcmp(ca, "NO") || !strcmp(ca, "OFF")) /* Yes/No, On/Off */
! 1366: instance->traim_in = 0;
! 1367: } else if (!strncmp(cc, "MASK", (size_t) 4)) {
! 1368: sscanf(ca, "%d", &mask);
! 1369: if (mask > -1 && mask < 90)
! 1370: instance->Ag = mask; /* Satellite mask angle */
! 1371: }
! 1372: }
! 1373: fclose(fd);
! 1374:
! 1375: /*
! 1376: * OK, have read all of data file, and extracted the good stuff.
! 1377: * If lat/long/ht specified they ALL must be specified for mode = (1,3).
! 1378: */
! 1379:
! 1380: instance->posn_set = 1;
! 1381: if (!( lat_flg && long_flg && ht_flg )) {
! 1382: snprintf(Msg, sizeof(Msg),
! 1383: "ONCORE: incomplete data on %s", device);
! 1384: oncore_log (instance, LOG_WARNING, Msg);
! 1385: instance->posn_set = 0;
! 1386: if (mode == 1 || mode == 3) {
! 1387: snprintf(Msg, sizeof(Msg),
! 1388: "Input Mode = %d, but no/incomplete position, mode set to %d",
! 1389: mode, mode+1);
! 1390: oncore_log(instance, LOG_WARNING, Msg);
! 1391: mode++;
! 1392: }
! 1393: }
! 1394: instance->init_type = mode;
! 1395:
! 1396: snprintf(Msg, sizeof(Msg), "Input mode = %d", mode);
! 1397: oncore_log(instance, LOG_INFO, Msg);
! 1398: }
! 1399:
! 1400:
! 1401:
! 1402: /*
! 1403: * move data from NTP to buffer (toss the extra in the unlikely case it won't fit)
! 1404: */
! 1405:
! 1406: static void
! 1407: oncore_receive(
! 1408: struct recvbuf *rbufp
! 1409: )
! 1410: {
! 1411: size_t i;
! 1412: u_char *p;
! 1413: struct peer *peer;
! 1414: struct instance *instance;
! 1415:
! 1416: peer = (struct peer *)rbufp->recv_srcclock;
! 1417: instance = (struct instance *) peer->procptr->unitptr;
! 1418: p = (u_char *) &rbufp->recv_space;
! 1419:
! 1420: #ifdef ONCORE_VERBOSE_RECEIVE
! 1421: if (debug > 4) {
! 1422: int i;
! 1423: char Msg[120], Msg2[10];
! 1424:
! 1425: snprintf(Msg, sizeof(Msg), ">>> %d bytes available",
! 1426: rbufp->recv_length);
! 1427: oncore_log(instance, LOG_DEBUG, Msg);
! 1428: strncpy(Msg, ">>>", sizeof(Msg));
! 1429: for (i = 0; i < rbufp->recv_length; i++) {
! 1430: snprintf(Msg2, sizeof(Msg2), "%02x ", p[i]);
! 1431: strncat(Msg, Msg2, sizeof(Msg));
! 1432: }
! 1433: oncore_log(instance, LOG_DEBUG, Msg);
! 1434:
! 1435: strncpy(Msg, ">>>", sizeof(Msg));
! 1436: for (i = 0; i < rbufp->recv_length; i++) {
! 1437: snprintf(Msg2, sizeof(Msg2), "%03o ", p[i]);
! 1438: strncat(Msg, Msg2, sizeof(Msg));
! 1439: }
! 1440: oncore_log(instance, LOG_DEBUG, Msg);
! 1441: }
! 1442: #endif
! 1443:
! 1444: i = rbufp->recv_length;
! 1445: if (rcvbuf+rcvptr+i > &rcvbuf[sizeof rcvbuf])
! 1446: i = sizeof(rcvbuf) - rcvptr; /* and some char will be lost */
! 1447: memcpy(rcvbuf+rcvptr, p, i);
! 1448: rcvptr += i;
! 1449: oncore_consume(instance);
! 1450: }
! 1451:
! 1452:
! 1453:
! 1454: /*
! 1455: * Deal with any complete messages
! 1456: */
! 1457:
! 1458: static void
! 1459: oncore_consume(
! 1460: struct instance *instance
! 1461: )
! 1462: {
! 1463: int i, m;
! 1464: unsigned l;
! 1465:
! 1466: while (rcvptr >= 7) {
! 1467: if (rcvbuf[0] != '@' || rcvbuf[1] != '@') {
! 1468: /* We're not in sync, lets try to get there */
! 1469: for (i=1; i < rcvptr-1; i++)
! 1470: if (rcvbuf[i] == '@' && rcvbuf[i+1] == '@')
! 1471: break;
! 1472: #ifdef ONCORE_VERBOSE_CONSUME
! 1473: if (debug > 4) {
! 1474: char Msg[120];
! 1475:
! 1476: snprintf(Msg, sizeof(Msg),
! 1477: ">>> skipping %d chars", i);
! 1478: oncore_log(instance, LOG_DEBUG, Msg);
! 1479: }
! 1480: #endif
! 1481: if (i != rcvptr)
! 1482: memcpy(rcvbuf, rcvbuf+i, (size_t)(rcvptr-i));
! 1483: rcvptr -= i;
! 1484: continue;
! 1485: }
! 1486:
! 1487: /* Ok, we have a header now */
! 1488: l = sizeof(oncore_messages)/sizeof(oncore_messages[0]) -1;
! 1489: for(m=0; m<l; m++)
! 1490: if (!strncmp(oncore_messages[m].flag, (char *)(rcvbuf+2), (size_t) 2))
! 1491: break;
! 1492: if (m == l) {
! 1493: #ifdef ONCORE_VERBOSE_CONSUME
! 1494: if (debug > 4) {
! 1495: char Msg[120];
! 1496:
! 1497: snprintf(Msg, sizeof(Msg),
! 1498: ">>> Unknown MSG, skipping 4 (%c%c)",
! 1499: rcvbuf[2], rcvbuf[3]);
! 1500: oncore_log(instance, LOG_DEBUG, Msg);
! 1501: }
! 1502: #endif
! 1503: memcpy(rcvbuf, rcvbuf+4, (size_t) 4);
! 1504: rcvptr -= 4;
! 1505: continue;
! 1506: }
! 1507:
! 1508: l = oncore_messages[m].len;
! 1509: #ifdef ONCORE_VERBOSE_CONSUME
! 1510: if (debug > 3) {
! 1511: char Msg[120];
! 1512:
! 1513: snprintf(Msg, sizeof(Msg),
! 1514: "GOT: %c%c %d of %d entry %d",
! 1515: instance->unit, rcvbuf[2], rcvbuf[3],
! 1516: rcvptr, l, m);
! 1517: oncore_log(instance, LOG_DEBUG, Msg);
! 1518: }
! 1519: #endif
! 1520: /* Got the entire message ? */
! 1521:
! 1522: if (rcvptr < l)
! 1523: return;
! 1524:
! 1525: /* are we at the end of message? should be <Cksum><CR><LF> */
! 1526:
! 1527: if (rcvbuf[l-2] != '\r' || rcvbuf[l-1] != '\n') {
! 1528: #ifdef ONCORE_VERBOSE_CONSUME
! 1529: if (debug)
! 1530: oncore_log(instance, LOG_DEBUG, "NO <CR><LF> at end of message");
! 1531: #endif
! 1532: } else { /* check the CheckSum */
! 1533: if (oncore_checksum_ok(rcvbuf, l)) {
! 1534: if (instance->shmem != NULL) {
! 1535: instance->shmem[oncore_messages[m].shmem + 2]++;
! 1536: memcpy(instance->shmem + oncore_messages[m].shmem + 3,
! 1537: rcvbuf, (size_t) l);
! 1538: }
! 1539: oncore_msg_any(instance, rcvbuf, (size_t) (l-3), m);
! 1540: if (oncore_messages[m].handler)
! 1541: oncore_messages[m].handler(instance, rcvbuf, (size_t) (l-3));
! 1542: }
! 1543: #ifdef ONCORE_VERBOSE_CONSUME
! 1544: else if (debug) {
! 1545: char Msg[120], Msg2[10];
! 1546:
! 1547: oncore_log(instance, LOG_ERR, "Checksum mismatch!");
! 1548: snprintf(Msg, sizeof(Msg), "@@%c%c ", rcvbuf[2], rcvbuf[3]);
! 1549: for (i = 4; i < l; i++) {
! 1550: snprintf(Msg2, sizeof(Msg2),
! 1551: "%03o ", rcvbuf[i]);
! 1552: strncat(Msg, Msg2, sizeof(Msg));
! 1553: }
! 1554: oncore_log(instance, LOG_DEBUG, Msg);
! 1555: }
! 1556: #endif
! 1557: }
! 1558:
! 1559: if (l != rcvptr)
! 1560: memcpy(rcvbuf, rcvbuf+l, (size_t) (rcvptr-l));
! 1561: rcvptr -= l;
! 1562: }
! 1563: }
! 1564:
! 1565:
! 1566:
! 1567: static void
! 1568: oncore_get_timestamp(
! 1569: struct instance *instance,
! 1570: long dt1, /* tick offset THIS time step */
! 1571: long dt2 /* tick offset NEXT time step */
! 1572: )
! 1573: {
! 1574: int Rsm;
! 1575: u_long j;
! 1576: l_fp ts, ts_tmp;
! 1577: double dmy;
! 1578: #ifdef HAVE_STRUCT_TIMESPEC
! 1579: struct timespec *tsp = 0;
! 1580: #else
! 1581: struct timeval *tsp = 0;
! 1582: #endif
! 1583: int current_mode;
! 1584: pps_params_t current_params;
! 1585: struct timespec timeout;
! 1586: struct peer *peer;
! 1587: pps_info_t pps_i;
! 1588: char Msg[140];
! 1589:
! 1590: peer = instance->peer;
! 1591:
! 1592: #if 1
! 1593: /* If we are in SiteSurvey mode, then we are in 3D mode, and we fall thru.
! 1594: * If we have Finished the SiteSurvey, then we fall thru for the 14/15
! 1595: * times we get here in 0D mode (the 1/15 is in 3D for SHMEM).
! 1596: * This gives good time, which gets better when the SS is done.
! 1597: */
! 1598:
! 1599: if ((instance->site_survey == ONCORE_SS_DONE) && (instance->mode != MODE_0D)) {
! 1600: #else
! 1601: /* old check, only fall thru for SS_DONE and 0D mode, 2h45m wait for ticks */
! 1602:
! 1603: if ((instance->site_survey != ONCORE_SS_DONE) || (instance->mode != MODE_0D)) {
! 1604: #endif
! 1605: peer->flags &= ~FLAG_PPS;
! 1606: return;
! 1607: }
! 1608:
! 1609: /* Don't do anything without an almanac to define the GPS->UTC delta */
! 1610:
! 1611: if (instance->rsm.bad_almanac) {
! 1612: peer->flags &= ~FLAG_PPS;
! 1613: return;
! 1614: }
! 1615:
! 1616: /* Once the Almanac is valid, the M12+T does not produce valid UTC
! 1617: * immediately.
! 1618: * Wait for UTC offset decode valid, then wait one message more
! 1619: * so we are not off by 13 seconds after reset.
! 1620: */
! 1621:
! 1622: if (instance->count5) {
! 1623: instance->count5--;
! 1624: peer->flags &= ~FLAG_PPS;
! 1625: return;
! 1626: }
! 1627:
! 1628: j = instance->ev_serial;
! 1629: timeout.tv_sec = 0;
! 1630: timeout.tv_nsec = 0;
! 1631: if (time_pps_fetch(instance->pps_h, PPS_TSFMT_TSPEC, &pps_i,
! 1632: &timeout) < 0) {
! 1633: oncore_log(instance, LOG_ERR, "time_pps_fetch failed");
! 1634: peer->flags &= ~FLAG_PPS;
! 1635: return;
! 1636: }
! 1637:
! 1638: if (instance->assert) {
! 1639: tsp = &pps_i.assert_timestamp;
! 1640:
! 1641: #ifdef ONCORE_VERBOSE_GET_TIMESTAMP
! 1642: if (debug > 2) {
! 1643: u_long i;
! 1644:
! 1645: i = (u_long) pps_i.assert_sequence;
! 1646: # ifdef HAVE_STRUCT_TIMESPEC
! 1647: snprintf(Msg, sizeof(Msg),
! 1648: "serial/j (%lu, %lu) %ld.%09ld", i, j,
! 1649: (long)tsp->tv_sec, (long)tsp->tv_nsec);
! 1650: # else
! 1651: snprintf(Msg, sizeof(Msg),
! 1652: "serial/j (%lu, %lu) %ld.%06ld", i, j,
! 1653: (long)tsp->tv_sec, (long)tsp->tv_usec);
! 1654: # endif
! 1655: oncore_log(instance, LOG_DEBUG, Msg);
! 1656: }
! 1657: #endif
! 1658:
! 1659: if (pps_i.assert_sequence == j) {
! 1660: oncore_log(instance, LOG_NOTICE, "ONCORE: oncore_get_timestamp, error serial pps");
! 1661: peer->flags &= ~FLAG_PPS;
! 1662: return;
! 1663: }
! 1664:
! 1665: instance->ev_serial = pps_i.assert_sequence;
! 1666: } else {
! 1667: tsp = &pps_i.clear_timestamp;
! 1668:
! 1669: #if 0
! 1670: if (debug > 2) {
! 1671: u_long i;
! 1672:
! 1673: i = (u_long) pps_i.clear_sequence;
! 1674: # ifdef HAVE_STRUCT_TIMESPEC
! 1675: snprintf(Msg, sizeof(Msg),
! 1676: "serial/j (%lu, %lu) %ld.%09ld", i, j,
! 1677: (long)tsp->tv_sec, (long)tsp->tv_nsec);
! 1678: # else
! 1679: snprintf(Msg. sizeof(Msg),
! 1680: "serial/j (%lu, %lu) %ld.%06ld", i, j,
! 1681: (long)tsp->tv_sec, (long)tsp->tv_usec);
! 1682: # endif
! 1683: oncore_log(instance, LOG_DEBUG, Msg);
! 1684: }
! 1685: #endif
! 1686:
! 1687: if (pps_i.clear_sequence == j) {
! 1688: oncore_log(instance, LOG_ERR, "oncore_get_timestamp, error serial pps");
! 1689: peer->flags &= ~FLAG_PPS;
! 1690: return;
! 1691: }
! 1692: instance->ev_serial = pps_i.clear_sequence;
! 1693: }
! 1694:
! 1695: /* convert timespec -> ntp l_fp */
! 1696:
! 1697: dmy = tsp->tv_nsec;
! 1698: dmy /= 1e9;
! 1699: ts.l_uf = dmy * 4294967296.0;
! 1700: ts.l_ui = tsp->tv_sec;
! 1701:
! 1702: #if 0
! 1703: alternate code for previous 4 lines is
! 1704: dmy = 1.0e-9*tsp->tv_nsec; /* fractional part */
! 1705: DTOLFP(dmy, &ts);
! 1706: dmy = tsp->tv_sec; /* integer part */
! 1707: DTOLFP(dmy, &ts_tmp);
! 1708: L_ADD(&ts, &ts_tmp);
! 1709: or more simply
! 1710: dmy = 1.0e-9*tsp->tv_nsec; /* fractional part */
! 1711: DTOLFP(dmy, &ts);
! 1712: ts.l_ui = tsp->tv_sec;
! 1713: #endif /* 0 */
! 1714:
! 1715: /* now have timestamp in ts */
! 1716: /* add in saw_tooth and offset, these will be ZERO if no TRAIM */
! 1717: /* they will be IGNORED if the PPSAPI cant do PPS_OFFSET/ASSERT/CLEAR */
! 1718: /* we just try to add them in and dont test for that here */
! 1719:
! 1720: /* saw_tooth not really necessary if using TIMEVAL */
! 1721: /* since its only precise to us, but do it anyway. */
! 1722:
! 1723: /* offset in ns, and is positive (late), we subtract */
! 1724: /* to put the PPS time transition back where it belongs */
! 1725:
! 1726: /* must hand the offset for the NEXT sec off to the Kernel to do */
! 1727: /* the addition, so that the Kernel PLL sees the offset too */
! 1728:
! 1729: if (instance->assert)
! 1730: instance->pps_p.assert_offset.tv_nsec = -dt2;
! 1731: else
! 1732: instance->pps_p.clear_offset.tv_nsec = -dt2;
! 1733:
! 1734: /* The following code is necessary, and not just a time_pps_setparams,
! 1735: * using the saved instance->pps_p, since some other process on the
! 1736: * machine may have diddled with the mode bits (say adding something
! 1737: * that it needs). We take what is there and ADD what we need.
! 1738: * [[ The results from the time_pps_getcap is unlikely to change so
! 1739: * we could probably just save it, but I choose to do the call ]]
! 1740: * Unfortunately, there is only ONE set of mode bits in the kernel per
! 1741: * interface, and not one set for each open handle.
! 1742: *
! 1743: * There is still a race condition here where we might mess up someone
! 1744: * elses mode, but if he is being careful too, he should survive.
! 1745: */
! 1746:
! 1747: if (time_pps_getcap(instance->pps_h, ¤t_mode) < 0) {
! 1748: msnprintf(Msg, sizeof(Msg), "time_pps_getcap failed: %m");
! 1749: oncore_log(instance, LOG_ERR, Msg);
! 1750: peer->flags &= ~FLAG_PPS;
! 1751: return;
! 1752: }
! 1753:
! 1754: if (time_pps_getparams(instance->pps_h, ¤t_params) < 0) {
! 1755: msnprintf(Msg, sizeof(Msg), "time_pps_getparams failed: %m");
! 1756: oncore_log(instance, LOG_ERR, Msg);
! 1757: peer->flags &= ~FLAG_PPS;
! 1758: return;
! 1759: }
! 1760:
! 1761: /* or current and mine */
! 1762: current_params.mode |= instance->pps_p.mode;
! 1763: /* but only set whats legal */
! 1764: current_params.mode &= current_mode;
! 1765:
! 1766: current_params.assert_offset.tv_sec = 0;
! 1767: current_params.assert_offset.tv_nsec = -dt2;
! 1768: current_params.clear_offset.tv_sec = 0;
! 1769: current_params.clear_offset.tv_nsec = -dt2;
! 1770:
! 1771: if (time_pps_setparams(instance->pps_h, ¤t_params))
! 1772: oncore_log(instance, LOG_ERR, "ONCORE: Error doing time_pps_setparams");
! 1773:
! 1774: /* have time from UNIX origin, convert to NTP origin. */
! 1775:
! 1776: ts.l_ui += JAN_1970;
! 1777: instance->pp->lastrec = ts;
! 1778:
! 1779: /* print out information about this timestamp (long line) */
! 1780:
! 1781: ts_tmp = ts;
! 1782: ts_tmp.l_ui = 0; /* zero integer part */
! 1783: LFPTOD(&ts_tmp, dmy); /* convert fractional part to a double */
! 1784: j = 1.0e9*dmy; /* then to integer ns */
! 1785:
! 1786: Rsm = 0;
! 1787: if (instance->chan == 6)
! 1788: Rsm = instance->BEHa[64];
! 1789: else if (instance->chan == 8)
! 1790: Rsm = instance->BEHa[72];
! 1791: else if (instance->chan == 12)
! 1792: Rsm = ((instance->BEHa[129]<<8) | instance->BEHa[130]);
! 1793:
! 1794: if (instance->chan == 6 || instance->chan == 8) {
! 1795: char f1[5], f2[5], f3[5], f4[5];
! 1796: if (instance->traim) {
! 1797: snprintf(f1, sizeof(f1), "%d",
! 1798: instance->BEHn[21]);
! 1799: snprintf(f2, sizeof(f2), "%d",
! 1800: instance->BEHn[22]);
! 1801: snprintf(f3, sizeof(f3), "%2d",
! 1802: instance->BEHn[23] * 256 +
! 1803: instance->BEHn[24]);
! 1804: snprintf(f4, sizeof(f4), "%3d",
! 1805: (s_char)instance->BEHn[25]);
! 1806: } else {
! 1807: strncpy(f1, "x", sizeof(f1));
! 1808: strncpy(f2, "x", sizeof(f2));
! 1809: strncpy(f3, "xx", sizeof(f3));
! 1810: strncpy(f4, "xxx", sizeof(f4));
! 1811: }
! 1812: snprintf(Msg, sizeof(Msg), /* MAX length 128, currently at 127 */
! 1813: "%u.%09lu %d %d %2d %2d %2d %2ld rstat %02x dop %4.1f nsat %2d,%d traim %d,%s,%s sigma %s neg-sawtooth %s sat %d%d%d%d%d%d%d%d",
! 1814: ts.l_ui, j,
! 1815: instance->pp->year, instance->pp->day,
! 1816: instance->pp->hour, instance->pp->minute, instance->pp->second,
! 1817: (long) tsp->tv_sec % 60,
! 1818: Rsm, 0.1*(256*instance->BEHa[35]+instance->BEHa[36]),
! 1819: /*rsat dop */
! 1820: instance->BEHa[38], instance->BEHa[39], instance->traim, f1, f2,
! 1821: /* nsat visible, nsat tracked, traim,traim,traim */
! 1822: f3, f4,
! 1823: /* sigma neg-sawtooth */
! 1824: /*sat*/ instance->BEHa[41], instance->BEHa[45], instance->BEHa[49], instance->BEHa[53],
! 1825: instance->BEHa[57], instance->BEHa[61], instance->BEHa[65], instance->BEHa[69]
! 1826: ); /* will be 0 for 6 chan */
! 1827: } else if (instance->chan == 12) {
! 1828: char f1[5], f2[5], f3[5], f4[5];
! 1829: if (instance->traim) {
! 1830: snprintf(f1, sizeof(f1), "%d",
! 1831: instance->BEHn[6]);
! 1832: snprintf(f2, sizeof(f2), "%d",
! 1833: instance->BEHn[7]);
! 1834: snprintf(f3, sizeof(f3), "%d",
! 1835: instance->BEHn[12] * 256 +
! 1836: instance->BEHn[13]);
! 1837: snprintf(f4, sizeof(f4), "%3d",
! 1838: (s_char)instance->BEHn[14]);
! 1839: } else {
! 1840: strncpy(f1, "x", sizeof(f1));
! 1841: strncpy(f2, "x", sizeof(f2));
! 1842: strncpy(f3, "xx", sizeof(f3));
! 1843: strncpy(f4, "xxx", sizeof(f4));
! 1844: }
! 1845: snprintf(Msg, sizeof(Msg),
! 1846: "%u.%09lu %d %d %2d %2d %2d %2ld rstat %02x dop %4.1f nsat %2d,%d traim %d,%s,%s sigma %s neg-sawtooth %s sat %d%d%d%d%d%d%d%d%d%d%d%d",
! 1847: ts.l_ui, j,
! 1848: instance->pp->year, instance->pp->day,
! 1849: instance->pp->hour, instance->pp->minute, instance->pp->second,
! 1850: (long) tsp->tv_sec % 60,
! 1851: Rsm, 0.1*(256*instance->BEHa[53]+instance->BEHa[54]),
! 1852: /*rsat dop */
! 1853: instance->BEHa[55], instance->BEHa[56], instance->traim, f1, f2,
! 1854: /* nsat visible, nsat tracked traim,traim,traim */
! 1855: f3, f4,
! 1856: /* sigma neg-sawtooth */
! 1857: /*sat*/ instance->BEHa[58], instance->BEHa[64], instance->BEHa[70], instance->BEHa[76],
! 1858: instance->BEHa[82], instance->BEHa[88], instance->BEHa[94], instance->BEHa[100],
! 1859: instance->BEHa[106], instance->BEHa[112], instance->BEHa[118], instance->BEHa[124]
! 1860: );
! 1861: }
! 1862:
! 1863: /* and some things I dont understand (magic ntp things) */
! 1864:
! 1865: if (!refclock_process(instance->pp)) {
! 1866: refclock_report(instance->peer, CEVNT_BADTIME);
! 1867: peer->flags &= ~FLAG_PPS;
! 1868: return;
! 1869: }
! 1870:
! 1871: oncore_log(instance, LOG_INFO, Msg); /* this is long message above */
! 1872: instance->pollcnt = 2;
! 1873:
! 1874: if (instance->polled) {
! 1875: instance->polled = 0;
! 1876: /* instance->pp->dispersion = instance->pp->skew = 0; */
! 1877: instance->pp->lastref = instance->pp->lastrec;
! 1878: refclock_receive(instance->peer);
! 1879: }
! 1880: peer->flags |= FLAG_PPS;
! 1881: }
! 1882:
! 1883:
! 1884: /*************** oncore_msg_XX routines start here *******************/
! 1885:
! 1886:
! 1887: /*
! 1888: * print Oncore response message.
! 1889: */
! 1890:
! 1891: static void
! 1892: oncore_msg_any(
! 1893: struct instance *instance,
! 1894: u_char *buf,
! 1895: size_t len,
! 1896: int idx
! 1897: )
! 1898: {
! 1899: #ifdef ONCORE_VERBOSE_MSG_ANY
! 1900: int i;
! 1901: const char *fmt = oncore_messages[idx].fmt;
! 1902: const char *p;
! 1903: char *q;
! 1904: char *qlim;
! 1905: #ifdef HAVE_GETCLOCK
! 1906: struct timespec ts;
! 1907: #endif
! 1908: struct timeval tv;
! 1909: char Msg[120], Msg2[10];
! 1910:
! 1911: if (debug > 3) {
! 1912: # ifdef HAVE_GETCLOCK
! 1913: (void) getclock(TIMEOFDAY, &ts);
! 1914: tv.tv_sec = ts.tv_sec;
! 1915: tv.tv_usec = ts.tv_nsec / 1000;
! 1916: # else
! 1917: GETTIMEOFDAY(&tv, 0);
! 1918: # endif
! 1919: snprintf(Msg, sizeof(Msg), "%ld.%06ld",
! 1920: (long)tv.tv_sec, (long)tv.tv_usec);
! 1921: oncore_log(instance, LOG_DEBUG, Msg);
! 1922:
! 1923: if (!*fmt) {
! 1924: snprintf(Msg, sizeof(Msg), ">>@@%c%c ", buf[2],
! 1925: buf[3]);
! 1926: for(i = 2; i < len && i < 2400 ; i++) {
! 1927: snprintf(Msg2, sizeof(Msg2), "%02x",
! 1928: buf[i]);
! 1929: strncpy(Msg, Msg2, sizeof(Msg));
! 1930:
! 1931: }
! 1932: oncore_log(instance, LOG_DEBUG, Msg);
! 1933: return;
! 1934: } else {
! 1935: strncat(Msg, "##", sizeof(Msg));
! 1936: qlim = Msg + sizeof(Msg) - 3;
! 1937: for (p = fmt, q = Msg + 2; q < qlim && *p; ) {
! 1938: *q++ = *p++;
! 1939: *q++ = '_';
! 1940: }
! 1941: *q = '\0';
! 1942: oncore_log(instance, LOG_DEBUG, Msg);
! 1943: snprintf(Msg, sizeof(Msg), "%c%c", buf[2],
! 1944: buf[3]);
! 1945: i = 4;
! 1946: for (p = fmt; *p; p++) {
! 1947: snprintf(Msg2, "%02x", buf[i++]);
! 1948: strncat(Msg, Msg2, sizeof(Msg));
! 1949: }
! 1950: oncore_log(instance, LOG_DEBUG, Msg);
! 1951: }
! 1952: }
! 1953: #endif
! 1954: }
! 1955:
! 1956:
! 1957:
! 1958: /* Latitude, Longitude, Height */
! 1959:
! 1960: static void
! 1961: oncore_msg_Adef(
! 1962: struct instance *instance,
! 1963: u_char *buf,
! 1964: size_t len
! 1965: )
! 1966: {
! 1967: }
! 1968:
! 1969:
! 1970:
! 1971: /* Mask Angle */
! 1972:
! 1973: static void
! 1974: oncore_msg_Ag(
! 1975: struct instance *instance,
! 1976: u_char *buf,
! 1977: size_t len
! 1978: )
! 1979: { char Msg[160], *cp;
! 1980:
! 1981: cp = "set to";
! 1982: if (instance->o_state == ONCORE_RUN)
! 1983: cp = "is";
! 1984:
! 1985: instance->Ag = buf[4];
! 1986: snprintf(Msg, sizeof(Msg),
! 1987: "Satellite mask angle %s %d degrees", cp,
! 1988: (int)instance->Ag);
! 1989: oncore_log(instance, LOG_INFO, Msg);
! 1990: }
! 1991:
! 1992:
! 1993:
! 1994: /*
! 1995: * get Position hold position
! 1996: */
! 1997:
! 1998: static void
! 1999: oncore_msg_As(
! 2000: struct instance *instance,
! 2001: u_char *buf,
! 2002: size_t len
! 2003: )
! 2004: {
! 2005: instance->ss_lat = buf_w32(&buf[4]);
! 2006: instance->ss_long = buf_w32(&buf[8]);
! 2007: instance->ss_ht = buf_w32(&buf[12]);
! 2008:
! 2009: /* Print out Position */
! 2010: oncore_print_posn(instance);
! 2011: }
! 2012:
! 2013:
! 2014:
! 2015: /*
! 2016: * Try to use Oncore UT+ Auto Survey Feature
! 2017: * If its not there (VP), set flag to do it ourselves.
! 2018: */
! 2019:
! 2020: static void
! 2021: oncore_msg_At(
! 2022: struct instance *instance,
! 2023: u_char *buf,
! 2024: size_t len
! 2025: )
! 2026: {
! 2027: instance->saw_At = 1;
! 2028: if (instance->site_survey == ONCORE_SS_TESTING) {
! 2029: if (buf[4] == 2) {
! 2030: oncore_log(instance, LOG_NOTICE,
! 2031: "Initiating hardware 3D site survey");
! 2032:
! 2033: oncore_log(instance, LOG_NOTICE, "SSstate = ONCORE_SS_HW");
! 2034: instance->site_survey = ONCORE_SS_HW;
! 2035: }
! 2036: }
! 2037: }
! 2038:
! 2039:
! 2040:
! 2041: /*
! 2042: * get PPS Offset
! 2043: * Nb. @@Ay is not supported for early UT (no plus) model
! 2044: */
! 2045:
! 2046: static void
! 2047: oncore_msg_Ay(
! 2048: struct instance *instance,
! 2049: u_char *buf,
! 2050: size_t len
! 2051: )
! 2052: {
! 2053: char Msg[120];
! 2054:
! 2055: if (instance->saw_Ay)
! 2056: return;
! 2057:
! 2058: instance->saw_Ay = 1;
! 2059:
! 2060: instance->offset = buf_w32(&buf[4]);
! 2061:
! 2062: snprintf(Msg, sizeof(Msg), "PPS Offset is set to %ld ns",
! 2063: instance->offset);
! 2064: oncore_log(instance, LOG_INFO, Msg);
! 2065: }
! 2066:
! 2067:
! 2068:
! 2069: /*
! 2070: * get Cable Delay
! 2071: */
! 2072:
! 2073: static void
! 2074: oncore_msg_Az(
! 2075: struct instance *instance,
! 2076: u_char *buf,
! 2077: size_t len
! 2078: )
! 2079: {
! 2080: char Msg[120];
! 2081:
! 2082: if (instance->saw_Az)
! 2083: return;
! 2084:
! 2085: instance->saw_Az = 1;
! 2086:
! 2087: instance->delay = buf_w32(&buf[4]);
! 2088:
! 2089: snprintf(Msg, sizeof(Msg), "Cable delay is set to %ld ns",
! 2090: instance->delay);
! 2091: oncore_log(instance, LOG_INFO, Msg);
! 2092: }
! 2093:
! 2094:
! 2095:
! 2096: /* Ba, Ea and Ha come here, these contain Position */
! 2097:
! 2098: static void
! 2099: oncore_msg_BaEaHa(
! 2100: struct instance *instance,
! 2101: u_char *buf,
! 2102: size_t len
! 2103: )
! 2104: {
! 2105: const char *cp;
! 2106: char Msg[160];
! 2107: int mode;
! 2108:
! 2109: /* OK, we are close to the RUN state now.
! 2110: * But we have a few more items to initialize first.
! 2111: *
! 2112: * At the beginning of this routine there are several 'timers'.
! 2113: * We enter this routine 1/sec, and since the upper levels of NTP have usurped
! 2114: * the use of timers, we use the 1/sec entry to do things that
! 2115: * we would normally do with timers...
! 2116: */
! 2117:
! 2118: if (instance->o_state == ONCORE_CHECK_CHAN) { /* here while checking for the # chan */
! 2119: if (buf[2] == 'B') { /* 6chan */
! 2120: if (instance->chan_ck < 6) instance->chan_ck = 6;
! 2121: } else if (buf[2] == 'E') { /* 8chan */
! 2122: if (instance->chan_ck < 8) instance->chan_ck = 8;
! 2123: } else if (buf[2] == 'H') { /* 12chan */
! 2124: if (instance->chan_ck < 12) instance->chan_ck = 12;
! 2125: }
! 2126:
! 2127: if (instance->count3++ < 5)
! 2128: return;
! 2129:
! 2130: instance->count3 = 0;
! 2131:
! 2132: if (instance->chan_in != -1) /* set in Input */
! 2133: instance->chan = instance->chan_in;
! 2134: else /* set from test */
! 2135: instance->chan = instance->chan_ck;
! 2136:
! 2137: snprintf(Msg, sizeof(Msg), "Input says chan = %d",
! 2138: instance->chan_in);
! 2139: oncore_log(instance, LOG_INFO, Msg);
! 2140: snprintf(Msg, sizeof(Msg), "Model # says chan = %d",
! 2141: instance->chan_id);
! 2142: oncore_log(instance, LOG_INFO, Msg);
! 2143: snprintf(Msg, sizeof(Msg), "Testing says chan = %d",
! 2144: instance->chan_ck);
! 2145: oncore_log(instance, LOG_INFO, Msg);
! 2146: snprintf(Msg, sizeof(Msg), "Using chan = %d",
! 2147: instance->chan);
! 2148: oncore_log(instance, LOG_INFO, Msg);
! 2149:
! 2150: instance->o_state = ONCORE_HAVE_CHAN;
! 2151: oncore_log(instance, LOG_NOTICE, "state = ONCORE_HAVE_CHAN");
! 2152:
! 2153: instance->timeout = 4;
! 2154: oncore_sendmsg(instance, oncore_cmd_Cj, sizeof(oncore_cmd_Cj));
! 2155: return;
! 2156: }
! 2157:
! 2158: if (instance->o_state != ONCORE_ALMANAC && instance->o_state != ONCORE_RUN)
! 2159: return;
! 2160:
! 2161: /* PAUSE 5sec - make sure results are stable, before using position */
! 2162:
! 2163: if (instance->count) {
! 2164: if (instance->count++ < 5)
! 2165: return;
! 2166: instance->count = 0;
! 2167: }
! 2168:
! 2169: memcpy(instance->BEHa, buf, (size_t) (len+3)); /* Ba, Ea or Ha */
! 2170:
! 2171: /* check the antenna (did it get unplugged) and almanac (is it ready) for changes. */
! 2172:
! 2173: oncore_check_almanac(instance);
! 2174: oncore_check_antenna(instance);
! 2175:
! 2176: /* If we are in Almanac mode, waiting for Almanac, we can't do anything till we have it */
! 2177: /* When we have an almanac, we will start the Bn/En/@@Hn messages */
! 2178:
! 2179: if (instance->o_state == ONCORE_ALMANAC)
! 2180: if (oncore_wait_almanac(instance))
! 2181: return;
! 2182:
! 2183: /* do some things once when we get this far in BaEaHa */
! 2184:
! 2185: if (instance->once) {
! 2186: instance->once = 0;
! 2187: instance->count2 = 1;
! 2188:
! 2189: /* Have we seen an @@At (position hold) command response */
! 2190: /* if not, message out */
! 2191:
! 2192: if (instance->chan != 12 && !instance->saw_At) {
! 2193: oncore_log(instance, LOG_NOTICE,
! 2194: "Not Good, no @@At command (no Position Hold), must be a GT/GT+");
! 2195: oncore_sendmsg(instance, oncore_cmd_Av1, sizeof(oncore_cmd_Av1));
! 2196: }
! 2197:
! 2198: /* have an Almanac, can start the SiteSurvey
! 2199: * (actually only need to get past the almanac_load where we diddle with At
! 2200: * command,- we can't change it after we start the HW_SS below
! 2201: */
! 2202:
! 2203: mode = instance->init_type;
! 2204: switch (mode) {
! 2205: case 0: /* NO initialization, don't change anything */
! 2206: case 1: /* Use given Position */
! 2207: case 3:
! 2208: instance->site_survey = ONCORE_SS_DONE;
! 2209: oncore_log(instance, LOG_NOTICE, "SSstate = ONCORE_SS_DONE");
! 2210: break;
! 2211:
! 2212: case 2:
! 2213: case 4: /* Site Survey */
! 2214: oncore_log(instance, LOG_NOTICE, "SSstate = ONCORE_SS_TESTING");
! 2215: instance->site_survey = ONCORE_SS_TESTING;
! 2216: instance->count1 = 1;
! 2217: if (instance->chan == 12)
! 2218: oncore_sendmsg(instance, oncore_cmd_Gd3, sizeof(oncore_cmd_Gd3)); /* M12+T */
! 2219: else
! 2220: oncore_sendmsg(instance, oncore_cmd_At2, sizeof(oncore_cmd_At2)); /* not GT, arg not VP */
! 2221: break;
! 2222: }
! 2223:
! 2224: /* Read back PPS Offset for Output */
! 2225: /* Nb. This will fail silently for early UT (no plus) and M12 models */
! 2226:
! 2227: oncore_sendmsg(instance, oncore_cmd_Ayx, sizeof(oncore_cmd_Ayx));
! 2228:
! 2229: /* Read back Cable Delay for Output */
! 2230:
! 2231: oncore_sendmsg(instance, oncore_cmd_Azx, sizeof(oncore_cmd_Azx));
! 2232:
! 2233: /* Read back Satellite Mask Angle for Output */
! 2234:
! 2235: oncore_sendmsg(instance, oncore_cmd_Agx, sizeof(oncore_cmd_Agx));
! 2236: }
! 2237:
! 2238:
! 2239: /* Unfortunately, the Gd3 command returns '3' for the M12 v1.3 firmware where it is
! 2240: * out-of-range and it should return 0-2. (v1.3 can't do a HW Site Survey)
! 2241: * We must do the Gd3, and then wait a cycle or two for things to settle,
! 2242: * then check Ha[130]&0x10 to see if a SS is in progress.
! 2243: * We will set SW if HW has not been set after an appropriate delay.
! 2244: */
! 2245:
! 2246: if (instance->site_survey == ONCORE_SS_TESTING) {
! 2247: if (instance->chan == 12) {
! 2248: if (instance->count1) {
! 2249: if (instance->count1++ > 5 || instance->BEHa[130]&0x10) {
! 2250: instance->count1 = 0;
! 2251: if (instance->BEHa[130]&0x10) {
! 2252: oncore_log(instance, LOG_NOTICE,
! 2253: "Initiating hardware 3D site survey");
! 2254:
! 2255: oncore_log(instance, LOG_NOTICE, "SSstate = ONCORE_SS_HW");
! 2256: instance->site_survey = ONCORE_SS_HW;
! 2257: } else {
! 2258: oncore_log(instance, LOG_NOTICE, "SSstate = ONCORE_SS_SW");
! 2259: instance->site_survey = ONCORE_SS_SW;
! 2260: }
! 2261: }
! 2262: }
! 2263: } else {
! 2264: if (instance->count1) {
! 2265: if (instance->count1++ > 5) {
! 2266: instance->count1 = 0;
! 2267: /*
! 2268: * For instance->site_survey to still be ONCORE_SS_TESTING, then after a 5sec
! 2269: * wait after the @@At2/@@Gd3 command we have not changed the state to
! 2270: * ONCORE_SS_HW. If the Hardware is capable of doing a Site Survey, then
! 2271: * the variable would have been changed by now.
! 2272: * There are three possibilities:
! 2273: * 6/8chan
! 2274: * (a) We did not get a response to the @@At0 or @@At2 commands,
! 2275: * and it must be a GT/GT+/SL with no position hold mode.
! 2276: * We will have to do it ourselves.
! 2277: * (b) We saw the @@At0, @@At2 commands, but @@At2 failed,
! 2278: * must be a VP or older UT which doesn't have Site Survey mode.
! 2279: * We will have to do it ourselves.
! 2280: * 12chan
! 2281: * (c) We saw the @@Gd command, and saw H[13]*0x10
! 2282: * We will have to do it ourselves (done above)
! 2283: */
! 2284:
! 2285: snprintf(Msg, sizeof(Msg),
! 2286: "Initiating software 3D site survey (%d samples)",
! 2287: POS_HOLD_AVERAGE);
! 2288: oncore_log(instance, LOG_INFO, Msg);
! 2289:
! 2290: oncore_log(instance, LOG_NOTICE, "SSstate = ONCORE_SS_SW");
! 2291: instance->site_survey = ONCORE_SS_SW;
! 2292:
! 2293: instance->ss_lat = instance->ss_long = instance->ss_ht = 0;
! 2294: if (instance->chan == 12)
! 2295: oncore_sendmsg(instance, oncore_cmd_Gd0, sizeof(oncore_cmd_Gd0)); /* disable */
! 2296: else {
! 2297: oncore_sendmsg(instance, oncore_cmd_At0, sizeof(oncore_cmd_At0)); /* disable */
! 2298: oncore_sendmsg(instance, oncore_cmd_Av0, sizeof(oncore_cmd_Av0)); /* disable */
! 2299: }
! 2300: }
! 2301: }
! 2302: }
! 2303: }
! 2304:
! 2305: /* check the mode we are in 0/2/3D */
! 2306:
! 2307: if (instance->chan == 6) {
! 2308: if (instance->BEHa[64]&0x8)
! 2309: instance->mode = MODE_0D;
! 2310: else if (instance->BEHa[64]&0x10)
! 2311: instance->mode = MODE_2D;
! 2312: else if (instance->BEHa[64]&0x20)
! 2313: instance->mode = MODE_3D;
! 2314: } else if (instance->chan == 8) {
! 2315: if (instance->BEHa[72]&0x8)
! 2316: instance->mode = MODE_0D;
! 2317: else if (instance->BEHa[72]&0x10)
! 2318: instance->mode = MODE_2D;
! 2319: else if (instance->BEHa[72]&0x20)
! 2320: instance->mode = MODE_3D;
! 2321: } else if (instance->chan == 12) {
! 2322: int bits;
! 2323:
! 2324: bits = (instance->BEHa[129]>>5) & 0x7; /* actually Ha */
! 2325: if (bits == 0x4)
! 2326: instance->mode = MODE_0D;
! 2327: else if (bits == 0x6)
! 2328: instance->mode = MODE_2D;
! 2329: else if (bits == 0x7)
! 2330: instance->mode = MODE_3D;
! 2331: }
! 2332:
! 2333: /* copy the record to the (extra) location in SHMEM */
! 2334:
! 2335: if (instance->shmem) {
! 2336: int i;
! 2337: u_char *smp; /* pointer to start of shared mem for Ba/Ea/Ha */
! 2338:
! 2339: switch(instance->chan) {
! 2340: case 6: smp = &instance->shmem[instance->shmem_Ba]; break;
! 2341: case 8: smp = &instance->shmem[instance->shmem_Ea]; break;
! 2342: case 12: smp = &instance->shmem[instance->shmem_Ha]; break;
! 2343: default: smp = (u_char *) NULL; break;
! 2344: }
! 2345:
! 2346: switch (instance->mode) {
! 2347: case MODE_0D: i = 1; break; /* 0D, Position Hold */
! 2348: case MODE_2D: i = 2; break; /* 2D, Altitude Hold */
! 2349: case MODE_3D: i = 3; break; /* 3D fix */
! 2350: default: i = 0; break;
! 2351: }
! 2352:
! 2353: if (i && smp != NULL) {
! 2354: i *= (len+6);
! 2355: smp[i + 2]++;
! 2356: memcpy(&smp[i+3], buf, (size_t) (len+3));
! 2357: }
! 2358: }
! 2359:
! 2360: /*
! 2361: * check if traim timer active
! 2362: * if it hasn't been cleared, then @@Bn/@@En/@@Hn did not respond
! 2363: */
! 2364:
! 2365: if (instance->traim_delay) {
! 2366: if (instance->traim_delay++ > 5) {
! 2367: instance->traim = 0;
! 2368: instance->traim_delay = 0;
! 2369: cp = "ONCORE: Did not detect TRAIM response, TRAIM = OFF";
! 2370: oncore_log(instance, LOG_INFO, cp);
! 2371:
! 2372: oncore_set_traim(instance);
! 2373: } else
! 2374: return;
! 2375:
! 2376: }
! 2377:
! 2378: /* by now should have a @@Ba/@@Ea/@@Ha with good data in it */
! 2379:
! 2380: if (!instance->have_dH && !instance->traim_delay)
! 2381: oncore_compute_dH(instance);
! 2382:
! 2383: /*
! 2384: * must be ONCORE_RUN if we are here.
! 2385: * Have # chan and TRAIM by now.
! 2386: */
! 2387:
! 2388: instance->pp->year = buf[6]*256+buf[7];
! 2389: instance->pp->day = ymd2yd(buf[6]*256+buf[7], buf[4], buf[5]);
! 2390: instance->pp->hour = buf[8];
! 2391: instance->pp->minute = buf[9];
! 2392: instance->pp->second = buf[10];
! 2393:
! 2394: /*
! 2395: * Are we doing a Hardware or Software Site Survey?
! 2396: */
! 2397:
! 2398: if (instance->site_survey == ONCORE_SS_HW || instance->site_survey == ONCORE_SS_SW)
! 2399: oncore_ss(instance);
! 2400:
! 2401: /* see if we ever saw a response from the @@Ayx above */
! 2402:
! 2403: if (instance->count2) {
! 2404: if (instance->count2++ > 5) { /* this delay to check on @@Ay command */
! 2405: instance->count2 = 0;
! 2406:
! 2407: /* Have we seen an Ay (1PPS time offset) command response */
! 2408: /* if not, and non-zero offset, zero the offset, and send message */
! 2409:
! 2410: if (!instance->saw_Ay && instance->offset) {
! 2411: oncore_log(instance, LOG_INFO, "No @@Ay command, PPS OFFSET ignored");
! 2412: instance->offset = 0;
! 2413: }
! 2414: }
! 2415: }
! 2416:
! 2417: /*
! 2418: * Check the leap second status once per day.
! 2419: */
! 2420:
! 2421: oncore_check_leap_sec(instance);
! 2422:
! 2423: /*
! 2424: * if SHMEM active, every 15s, steal one 'tick' to get 2D or 3D posn.
! 2425: */
! 2426:
! 2427: if (instance->shmem && !instance->shmem_bad_Ea && instance->shmem_Posn && (instance->site_survey == ONCORE_SS_DONE))
! 2428: oncore_shmem_get_3D(instance);
! 2429:
! 2430: if (!instance->traim) /* NO traim, no BnEnHn, go get tick */
! 2431: oncore_get_timestamp(instance, instance->offset, instance->offset);
! 2432: }
! 2433:
! 2434:
! 2435:
! 2436: /* Almanac Status */
! 2437:
! 2438: static void
! 2439: oncore_msg_Bd(
! 2440: struct instance *instance,
! 2441: u_char *buf,
! 2442: size_t len
! 2443: )
! 2444: {
! 2445: char Msg[160];
! 2446:
! 2447: snprintf(Msg, sizeof(Msg),
! 2448: "Bd: Almanac %s, week = %d, t = %d, %d SVs: %x",
! 2449: ((buf[4]) ? "LOADED" : "(NONE)"), buf[5], buf[6],
! 2450: buf[7], w32(&buf[8]));
! 2451: oncore_log(instance, LOG_NOTICE, Msg);
! 2452: }
! 2453:
! 2454:
! 2455:
! 2456: /* get leap-second warning message */
! 2457:
! 2458: /*
! 2459: * @@Bj does NOT behave as documented in current Oncore firmware.
! 2460: * It turns on the LEAP indicator when the data is set, and does not,
! 2461: * as documented, wait until the beginning of the month when the
! 2462: * leap second will occur.
! 2463: * Since this firmware bug will never be fixed in all the outstanding Oncore receivers
! 2464: * @@Bj is only called in June/December.
! 2465: */
! 2466:
! 2467: static void
! 2468: oncore_msg_Bj(
! 2469: struct instance *instance,
! 2470: u_char *buf,
! 2471: size_t len
! 2472: )
! 2473: {
! 2474: const char *cp;
! 2475:
! 2476: instance->saw_Bj = 1;
! 2477:
! 2478: switch(buf[4]) {
! 2479: case 1:
! 2480: instance->pp->leap = LEAP_ADDSECOND;
! 2481: cp = "Set pp.leap to LEAP_ADDSECOND";
! 2482: break;
! 2483: case 2:
! 2484: instance->pp->leap = LEAP_DELSECOND;
! 2485: cp = "Set pp.leap to LEAP_DELSECOND";
! 2486: break;
! 2487: case 0:
! 2488: default:
! 2489: instance->pp->leap = LEAP_NOWARNING;
! 2490: cp = "Set pp.leap to LEAP_NOWARNING";
! 2491: break;
! 2492: }
! 2493: oncore_log(instance, LOG_NOTICE, cp);
! 2494: }
! 2495:
! 2496:
! 2497:
! 2498: static void
! 2499: oncore_msg_Bl(
! 2500: struct instance *instance,
! 2501: u_char *buf,
! 2502: size_t len
! 2503: )
! 2504: {
! 2505: int chan, id, subframe, valid, page, i, j, tow;
! 2506: int day_now, day_lsf;
! 2507: char *cp, Msg[120];
! 2508: enum {
! 2509: WARN_NOT_YET,
! 2510: WARN_0,
! 2511: WARN_PLUS,
! 2512: WARN_MINUS
! 2513: } warn;
! 2514:
! 2515: day_now = day_lsf = 0;
! 2516: cp = NULL; /* keep gcc happy */
! 2517:
! 2518: chan = buf[4] & 0377;
! 2519: id = buf[5] & 0377;
! 2520: subframe = buf[6] & 017;
! 2521: valid = (buf[6] >> 4) & 017;
! 2522: page = buf[7];
! 2523:
! 2524: if ((!instance->Bl.lsf_flg && !instance->Bl.wn_flg) && (subframe == 4 && page == 18 && valid == 10)) {
! 2525: instance->Bl.dt_ls = buf[32];
! 2526: instance->Bl.WN_lsf = buf[33];
! 2527: instance->Bl.DN_lsf = buf[34];
! 2528: instance->Bl.dt_lsf = buf[35];
! 2529: instance->Bl.lsf_flg++;
! 2530: }
! 2531: if ((instance->Bl.lsf_flg && !instance->Bl.wn_flg) && (subframe == 1 && valid == 10)) {
! 2532: i = (buf[7+7]<<8) + buf[7+8];
! 2533: instance->Bl.WN = i >> 6;
! 2534: tow = (buf[7+4]<<16) + (buf[7+5]<<8) + buf[7+6];
! 2535: tow >>= 7;
! 2536: tow = tow & 0377777;
! 2537: tow <<= 2;
! 2538: instance->Bl.DN = tow/57600L + 1;
! 2539: instance->Bl.wn_flg++;
! 2540: }
! 2541: if (instance->Bl.wn_flg && instance->Bl.lsf_flg) {
! 2542: instance->Bl.wn_flg = instance->Bl.lsf_flg = 0;
! 2543: oncore_cmd_Bl[2] = 0;
! 2544: oncore_sendmsg(instance, oncore_cmd_Bl, sizeof oncore_cmd_Bl);
! 2545: oncore_cmd_Bl[2] = 1;
! 2546:
! 2547: i = instance->Bl.WN&01400;
! 2548: instance->Bl.WN_lsf |= i;
! 2549:
! 2550: /* have everything I need, doit */
! 2551:
! 2552: i = (instance->Bl.WN_lsf - instance->Bl.WN);
! 2553: if (i < 0)
! 2554: i += 1024;
! 2555: day_now = instance->Bl.DN;
! 2556: day_lsf = 7*i + instance->Bl.DN_lsf;
! 2557:
! 2558: /* ignore if in past or more than a month in future */
! 2559:
! 2560: warn = WARN_NOT_YET;
! 2561: if (day_lsf >= day_now && day_lsf - day_now < 32) {
! 2562: /* if < 28d, doit, if 28-31, ck day-of-month < 20 (not at end of prev month) */
! 2563: if (day_lsf - day_now < 28 || instance->BEHa[5] < 20) {
! 2564: i = instance->Bl.dt_lsf - instance->Bl.dt_ls;
! 2565: switch (i) {
! 2566: case -1:
! 2567: warn = WARN_MINUS;
! 2568: break;
! 2569: case 0:
! 2570: warn = WARN_0;
! 2571: break;
! 2572: case 1:
! 2573: warn = WARN_PLUS;
! 2574: break;
! 2575: }
! 2576: }
! 2577: }
! 2578:
! 2579: switch (warn) {
! 2580: case WARN_0:
! 2581: case WARN_NOT_YET:
! 2582: instance->peer->leap = LEAP_NOWARNING;
! 2583: cp = "Set peer.leap to LEAP_NOWARNING";
! 2584: break;
! 2585: case WARN_MINUS:
! 2586: instance->peer->leap = LEAP_DELSECOND;
! 2587: cp = "Set peer.leap to LEAP_DELSECOND";
! 2588: break;
! 2589: case WARN_PLUS:
! 2590: instance->peer->leap = LEAP_ADDSECOND;
! 2591: cp = "Set peer.leap to LEAP_ADDSECOND";
! 2592: break;
! 2593: }
! 2594: oncore_log(instance, LOG_NOTICE, cp);
! 2595:
! 2596: i = instance->Bl.dt_lsf-instance->Bl.dt_ls;
! 2597: if (i) {
! 2598: j = (i >= 0) ? i : -i; /* abs(i) */
! 2599: snprintf(Msg, sizeof(Msg),
! 2600: "see Leap_Second (%c%d) in %d days",
! 2601: ((i >= 0) ? '+' : '-'), j,
! 2602: day_lsf-day_now);
! 2603: oncore_log(instance, LOG_NOTICE, Msg);
! 2604: }
! 2605: }
! 2606: snprintf(Msg, sizeof(Msg),
! 2607: "dt_ls = %d dt_lsf = %d WN = %d DN = %d WN_lsf = %d DNlsf = %d wn_flg = %d lsf_flg = %d Bl_day = %d",
! 2608: instance->Bl.dt_ls, instance->Bl.dt_lsf,
! 2609: instance->Bl.WN, instance->Bl.DN,
! 2610: instance->Bl.WN_lsf, instance->Bl.DN_lsf,
! 2611: instance->Bl.wn_flg, instance->Bl.lsf_flg,
! 2612: instance->Bl.Bl_day);
! 2613: oncore_log(instance, LOG_INFO, Msg);
! 2614: }
! 2615:
! 2616:
! 2617: static void
! 2618: oncore_msg_BnEnHn(
! 2619: struct instance *instance,
! 2620: u_char *buf,
! 2621: size_t len
! 2622: )
! 2623: {
! 2624: long dt1, dt2;
! 2625:
! 2626: if (instance->o_state != ONCORE_RUN)
! 2627: return;
! 2628:
! 2629: if (instance->traim_delay) { /* flag that @@Bn/@@En/Hn returned */
! 2630: instance->traim_ck = 1;
! 2631: instance->traim_delay = 0;
! 2632: oncore_log(instance, LOG_NOTICE, "ONCORE: Detected TRAIM, TRAIM = ON");
! 2633:
! 2634: oncore_set_traim(instance);
! 2635: }
! 2636:
! 2637: memcpy(instance->BEHn, buf, (size_t) len); /* Bn or En or Hn */
! 2638:
! 2639: if (!instance->traim) /* BnEnHn will be turned off in any case */
! 2640: return;
! 2641:
! 2642: /* If Time RAIM doesn't like it, don't trust it */
! 2643:
! 2644: if (buf[2] == 'H') {
! 2645: if (instance->BEHn[6]) { /* bad TRAIM */
! 2646: oncore_log(instance, LOG_WARNING, "BAD TRAIM");
! 2647: return;
! 2648: }
! 2649:
! 2650: dt1 = instance->saw_tooth + instance->offset; /* dt this time step */
! 2651: instance->saw_tooth = (s_char) instance->BEHn[14]; /* update for next time Hn[14] */
! 2652: dt2 = instance->saw_tooth + instance->offset; /* dt next time step */
! 2653: } else {
! 2654: if (instance->BEHn[21]) /* bad TRAIM */
! 2655: return;
! 2656:
! 2657: dt1 = instance->saw_tooth + instance->offset; /* dt this time step */
! 2658: instance->saw_tooth = (s_char) instance->BEHn[25]; /* update for next time Bn[25], En[25] */
! 2659: dt2 = instance->saw_tooth + instance->offset; /* dt next time step */
! 2660: }
! 2661:
! 2662: oncore_get_timestamp(instance, dt1, dt2);
! 2663: }
! 2664:
! 2665:
! 2666:
! 2667: /* Here for @@Ca, @@Fa and @@Ia messages */
! 2668:
! 2669: /* These are Self test Commands for 6, 8, and 12 chan receivers.
! 2670: * There are good reasons NOT to do a @@Ca, @@Fa or @@Ia command with the ONCORE.
! 2671: * It was found that under some circumstances the following
! 2672: * command would fail if issued immediately after the return from the
! 2673: * @@Fa, but a 2sec delay seemed to fix things. Since simply calling
! 2674: * sleep(2) is wasteful, and may cause trouble for some OS's, repeating
! 2675: * itimer, we set a flag, and test it at the next POLL. If it hasn't
! 2676: * been cleared, we reissue the @@Cj that is issued below.
! 2677: * Note that we do a @@Cj at the beginning, and again here.
! 2678: * The first is to get the info, the 2nd is just used as a safe command
! 2679: * after the @@Fa for all Oncores (and it was in this posn in the
! 2680: * original code).
! 2681: */
! 2682:
! 2683: static void
! 2684: oncore_msg_CaFaIa(
! 2685: struct instance *instance,
! 2686: u_char *buf,
! 2687: size_t len
! 2688: )
! 2689: {
! 2690: char Msg[120];
! 2691: int i;
! 2692:
! 2693: if (instance->o_state == ONCORE_TEST_SENT) {
! 2694: enum antenna_state antenna;
! 2695:
! 2696: instance->timeout = 0;
! 2697:
! 2698: #if ONCORE_VERBOSE_SELF_TEST
! 2699: if (debug > 2) {
! 2700: if (buf[2] == 'I')
! 2701: snprintf(Msg, sizeof(Msg),
! 2702: ">>@@%ca %x %x %x", buf[2],
! 2703: buf[4], buf[5], buf[6]);
! 2704: else
! 2705: snprintf(Msg, sizeof(Msg),
! 2706: ">>@@%ca %x %x", buf[2],
! 2707: buf[4], buf[5]);
! 2708: oncore_log(instance, LOG_DEBUG, Msg);
! 2709: }
! 2710: #endif
! 2711:
! 2712: antenna = (buf[4] & 0xc0) >> 6;
! 2713: buf[4] &= ~0xc0;
! 2714:
! 2715: i = buf[4] || buf[5];
! 2716: if (buf[2] == 'I') i = i || buf[6];
! 2717: if (i) {
! 2718: if (buf[2] == 'I')
! 2719: snprintf(Msg, sizeof(Msg),
! 2720: "self test failed: result %02x %02x %02x",
! 2721: buf[4], buf[5], buf[6]);
! 2722: else
! 2723: snprintf(Msg, sizeof(Msg),
! 2724: "self test failed: result %02x %02x",
! 2725: buf[4], buf[5]);
! 2726: oncore_log(instance, LOG_ERR, Msg);
! 2727:
! 2728: oncore_log(instance, LOG_ERR,
! 2729: "ONCORE: self test failed, shutting down driver");
! 2730:
! 2731: refclock_report(instance->peer, CEVNT_FAULT);
! 2732: oncore_shutdown(instance->unit, instance->peer);
! 2733: return;
! 2734: }
! 2735:
! 2736: /* report the current antenna state */
! 2737:
! 2738: oncore_antenna_report(instance, antenna);
! 2739:
! 2740: instance->o_state = ONCORE_INIT;
! 2741: oncore_log(instance, LOG_NOTICE, "state = ONCORE_INIT");
! 2742:
! 2743: instance->timeout = 4;
! 2744: oncore_sendmsg(instance, oncore_cmd_Cj, sizeof(oncore_cmd_Cj));
! 2745: }
! 2746: }
! 2747:
! 2748:
! 2749:
! 2750: /*
! 2751: * Demultiplex the almanac into shmem
! 2752: */
! 2753:
! 2754: static void
! 2755: oncore_msg_Cb(
! 2756: struct instance *instance,
! 2757: u_char *buf,
! 2758: size_t len
! 2759: )
! 2760: {
! 2761: int i;
! 2762:
! 2763: if (instance->shmem == NULL)
! 2764: return;
! 2765:
! 2766: if (buf[4] == 5 && buf[5] > 0 && buf[5] < 26)
! 2767: i = buf[5];
! 2768: else if (buf[4] == 4 && buf[5] <= 5)
! 2769: i = buf[5] + 24;
! 2770: else if (buf[4] == 4 && buf[5] <= 10)
! 2771: i = buf[5] + 23;
! 2772: else if (buf[4] == 4 && buf[5] == 25)
! 2773: i = 34;
! 2774: else {
! 2775: oncore_log(instance, LOG_NOTICE, "Cb: Response is NO ALMANAC");
! 2776: return;
! 2777: }
! 2778:
! 2779: i *= 36;
! 2780: instance->shmem[instance->shmem_Cb + i + 2]++;
! 2781: memcpy(instance->shmem + instance->shmem_Cb + i + 3, buf, (size_t) (len + 3));
! 2782:
! 2783: #ifdef ONCORE_VERBOSE_MSG_CB
! 2784: {
! 2785: char Msg[160];
! 2786:
! 2787: snprintf(Msg, sizeof(Msg), "See Cb [%d,%d]", buf[4],
! 2788: buf[5]);
! 2789: oncore_log(instance, LOG_DEBUG, Msg);
! 2790: }
! 2791: #endif
! 2792: }
! 2793:
! 2794:
! 2795:
! 2796: /*
! 2797: * Set to Factory Defaults (Reasonable for UT w/ no Battery Backup
! 2798: * not so for VP (eeprom) or any unit with a battery
! 2799: */
! 2800:
! 2801: static void
! 2802: oncore_msg_Cf(
! 2803: struct instance *instance,
! 2804: u_char *buf,
! 2805: size_t len
! 2806: )
! 2807: {
! 2808: if (instance->o_state == ONCORE_RESET_SENT) {
! 2809: oncore_sendmsg(instance, oncore_cmd_Cg, sizeof(oncore_cmd_Cg)); /* Return to Posn Fix mode */
! 2810: /* Reset set VP to IDLE */
! 2811: instance->o_state = ONCORE_TEST_SENT;
! 2812: oncore_log(instance, LOG_NOTICE, "state = ONCORE_TEST_SENT");
! 2813:
! 2814: oncore_sendmsg(instance, oncore_cmd_Cj, sizeof(oncore_cmd_Cj));
! 2815: }
! 2816: }
! 2817:
! 2818:
! 2819:
! 2820: /*
! 2821: * This is the Grand Central Station for the Preliminary Initialization.
! 2822: * Once done here we move on to oncore_msg_BaEaHa for final Initialization and Running.
! 2823: *
! 2824: * We do an @@Cj whenever we need a safe command for all Oncores.
! 2825: * The @@Cj gets us back here where we can switch to the next phase of setup.
! 2826: *
! 2827: * o Once at the very beginning (in start) to get the Model number.
! 2828: * This info is printed, but no longer used.
! 2829: * o Again after we have determined the number of Channels in the receiver.
! 2830: * o And once later after we have done a reset and test, (which may hang),
! 2831: * as we are about to initialize the Oncore and start it running.
! 2832: * o We have one routine below for each case.
! 2833: */
! 2834:
! 2835: static void
! 2836: oncore_msg_Cj(
! 2837: struct instance *instance,
! 2838: u_char *buf,
! 2839: size_t len
! 2840: )
! 2841: {
! 2842: int mode;
! 2843:
! 2844: memcpy(instance->Cj, buf, len);
! 2845:
! 2846: instance->timeout = 0;
! 2847: if (instance->o_state == ONCORE_CHECK_ID) {
! 2848: oncore_msg_Cj_id(instance, buf, len);
! 2849: oncore_chan_test(instance);
! 2850: } else if (instance->o_state == ONCORE_HAVE_CHAN) {
! 2851: mode = instance->init_type;
! 2852: if (mode == 3 || mode == 4) { /* Cf will return here to check for TEST */
! 2853: instance->o_state = ONCORE_RESET_SENT;
! 2854: oncore_log(instance, LOG_NOTICE, "state = ONCORE_RESET_SENT");
! 2855: oncore_sendmsg(instance, oncore_cmd_Cf, sizeof(oncore_cmd_Cf));
! 2856: } else {
! 2857: instance->o_state = ONCORE_TEST_SENT;
! 2858: oncore_log(instance, LOG_NOTICE, "state = ONCORE_TEST_SENT");
! 2859: }
! 2860: }
! 2861:
! 2862: if (instance->o_state == ONCORE_TEST_SENT) {
! 2863: if (instance->chan == 6)
! 2864: oncore_sendmsg(instance, oncore_cmd_Ca, sizeof(oncore_cmd_Ca));
! 2865: else if (instance->chan == 8)
! 2866: oncore_sendmsg(instance, oncore_cmd_Fa, sizeof(oncore_cmd_Fa));
! 2867: else if (instance->chan == 12)
! 2868: oncore_sendmsg(instance, oncore_cmd_Ia, sizeof(oncore_cmd_Ia));
! 2869: } else if (instance->o_state == ONCORE_INIT)
! 2870: oncore_msg_Cj_init(instance, buf, len);
! 2871: }
! 2872:
! 2873:
! 2874:
! 2875: /* The information on determining a Oncore 'Model', viz VP, UT, etc, from
! 2876: * the Model Number comes from "Richard M. Hambly" <rick@cnssys.com>
! 2877: * and from Motorola. Until recently Rick was the only source of
! 2878: * this information as Motorola didn't give the information out.
! 2879: *
! 2880: * Determine the Type from the Model #, this determines #chan and if TRAIM is
! 2881: * available.
! 2882: *
! 2883: * The Information from this routine is NO LONGER USED.
! 2884: * The RESULTS are PRINTED, BUT NOT USED, and the routine COULD BE DELETED
! 2885: */
! 2886:
! 2887: static void
! 2888: oncore_msg_Cj_id(
! 2889: struct instance *instance,
! 2890: u_char *buf,
! 2891: size_t len
! 2892: )
! 2893: {
! 2894: char *cp, *cp1, *cp2, Model[21], Msg[160];
! 2895:
! 2896: /* Write Receiver ID message to clockstats file */
! 2897:
! 2898: instance->Cj[294] = '\0';
! 2899: for (cp=(char *)instance->Cj; cp< (char *) &instance->Cj[294]; ) {
! 2900: cp1 = strchr(cp, '\r');
! 2901: if (!cp1)
! 2902: cp1 = (char *)&instance->Cj[294];
! 2903: *cp1 = '\0';
! 2904: oncore_log(instance, LOG_NOTICE, cp);
! 2905: *cp1 = '\r';
! 2906: cp = cp1+2;
! 2907: }
! 2908:
! 2909: /* next, the Firmware Version and Revision numbers */
! 2910:
! 2911: instance->version = atoi((char *) &instance->Cj[83]);
! 2912: instance->revision = atoi((char *) &instance->Cj[111]);
! 2913:
! 2914: /* from model number decide which Oncore this is,
! 2915: and then the number of channels */
! 2916:
! 2917: for (cp= (char *) &instance->Cj[160]; *cp == ' '; cp++) /* start right after 'Model #' */
! 2918: ;
! 2919: cp1 = cp;
! 2920: cp2 = Model;
! 2921: for (; !isspace((int)*cp) && cp-cp1 < 20; cp++, cp2++)
! 2922: *cp2 = *cp;
! 2923: *cp2 = '\0';
! 2924:
! 2925: cp = 0;
! 2926: if (!strncmp(Model, "PVT6", (size_t) 4)) {
! 2927: cp = "PVT6";
! 2928: instance->model = ONCORE_PVT6;
! 2929: } else if (Model[0] == 'A') {
! 2930: cp = "Basic";
! 2931: instance->model = ONCORE_BASIC;
! 2932: } else if (Model[0] == 'B' || !strncmp(Model, "T8", (size_t) 2)) {
! 2933: cp = "VP";
! 2934: instance->model = ONCORE_VP;
! 2935: } else if (Model[0] == 'P') {
! 2936: cp = "M12";
! 2937: instance->model = ONCORE_M12;
! 2938: } else if (Model[0] == 'R' || Model[0] == 'D' || Model[0] == 'S') {
! 2939: if (Model[5] == 'N') {
! 2940: cp = "GT";
! 2941: instance->model = ONCORE_GT;
! 2942: } else if ((Model[1] == '3' || Model[1] == '4') && Model[5] == 'G') {
! 2943: cp = "GT+";
! 2944: instance->model = ONCORE_GTPLUS;
! 2945: } else if ((Model[1] == '5' && Model[5] == 'U') || (Model[1] == '1' && Model[5] == 'A')) {
! 2946: cp = "UT";
! 2947: instance->model = ONCORE_UT;
! 2948: } else if (Model[1] == '5' && Model[5] == 'G') {
! 2949: cp = "UT+";
! 2950: instance->model = ONCORE_UTPLUS;
! 2951: } else if (Model[1] == '6' && Model[5] == 'G') {
! 2952: cp = "SL";
! 2953: instance->model = ONCORE_SL;
! 2954: } else {
! 2955: cp = "Unknown";
! 2956: instance->model = ONCORE_UNKNOWN;
! 2957: }
! 2958: } else {
! 2959: cp = "Unknown";
! 2960: instance->model = ONCORE_UNKNOWN;
! 2961: }
! 2962:
! 2963: /* use MODEL to set CHAN and TRAIM and possibly zero SHMEM */
! 2964:
! 2965: snprintf(Msg, sizeof(Msg),
! 2966: "This looks like an Oncore %s with version %d.%d firmware.",
! 2967: cp, instance->version, instance->revision);
! 2968: oncore_log(instance, LOG_INFO, Msg);
! 2969:
! 2970: instance->chan_id = 8; /* default */
! 2971: if (instance->model == ONCORE_BASIC || instance->model == ONCORE_PVT6)
! 2972: instance->chan_id = 6;
! 2973: else if (instance->model == ONCORE_VP || instance->model == ONCORE_UT || instance->model == ONCORE_UTPLUS)
! 2974: instance->chan_id = 8;
! 2975: else if (instance->model == ONCORE_M12)
! 2976: instance->chan_id = 12;
! 2977:
! 2978: instance->traim_id = 0; /* default */
! 2979: if (instance->model == ONCORE_BASIC || instance->model == ONCORE_PVT6)
! 2980: instance->traim_id = 0;
! 2981: else if (instance->model == ONCORE_VP || instance->model == ONCORE_UT || instance->model == ONCORE_UTPLUS)
! 2982: instance->traim_id = 1;
! 2983: else if (instance->model == ONCORE_M12)
! 2984: instance->traim_id = -1;
! 2985:
! 2986: snprintf(Msg, sizeof(Msg), "Channels = %d, TRAIM = %s",
! 2987: instance->chan_id,
! 2988: ((instance->traim_id < 0)
! 2989: ? "UNKNOWN"
! 2990: : (instance->traim_id > 0)
! 2991: ? "ON"
! 2992: : "OFF"));
! 2993: oncore_log(instance, LOG_INFO, Msg);
! 2994: }
! 2995:
! 2996:
! 2997:
! 2998: /* OK, know type of Oncore, have possibly reset it, and have tested it.
! 2999: * We know the number of channels.
! 3000: * We will determine whether we have TRAIM before we actually start.
! 3001: * Now initialize.
! 3002: */
! 3003:
! 3004: static void
! 3005: oncore_msg_Cj_init(
! 3006: struct instance *instance,
! 3007: u_char *buf,
! 3008: size_t len
! 3009: )
! 3010: {
! 3011: char Msg[160];
! 3012: u_char Cmd[20];
! 3013: int mode;
! 3014:
! 3015:
! 3016: /* The M12 with 1.3 or 2.0 Firmware, loses track of all Satellites and has to
! 3017: * start again if we go from 0D -> 3D, then loses them again when we
! 3018: * go from 3D -> 0D. We do this to get a @@Ea message for SHMEM.
! 3019: * For NOW we will turn this aspect of filling SHMEM off for the M12
! 3020: */
! 3021:
! 3022: if (instance->chan == 12) {
! 3023: instance->shmem_bad_Ea = 1;
! 3024: snprintf(Msg, sizeof(Msg),
! 3025: "*** SHMEM partially enabled for ONCORE M12 s/w v%d.%d ***",
! 3026: instance->version, instance->revision);
! 3027: oncore_log(instance, LOG_NOTICE, Msg);
! 3028: }
! 3029:
! 3030: oncore_sendmsg(instance, oncore_cmd_Cg, sizeof(oncore_cmd_Cg)); /* Return to Posn Fix mode */
! 3031: oncore_sendmsg(instance, oncore_cmd_Bb, sizeof(oncore_cmd_Bb)); /* turn on for shmem (6/8/12) */
! 3032: oncore_sendmsg(instance, oncore_cmd_Ek, sizeof(oncore_cmd_Ek)); /* turn off (VP) */
! 3033: oncore_sendmsg(instance, oncore_cmd_Aw, sizeof(oncore_cmd_Aw)); /* UTC time (6/8/12) */
! 3034: oncore_sendmsg(instance, oncore_cmd_AB, sizeof(oncore_cmd_AB)); /* Appl type static (VP) */
! 3035: oncore_sendmsg(instance, oncore_cmd_Be, sizeof(oncore_cmd_Be)); /* Tell us the Almanac for shmem (6/8/12) */
! 3036: oncore_sendmsg(instance, oncore_cmd_Bd, sizeof(oncore_cmd_Bd)); /* Tell us when Almanac changes */
! 3037:
! 3038: mode = instance->init_type;
! 3039:
! 3040: /* If there is Position input in the Config file
! 3041: * and mode = (1,3) set it as posn hold posn, goto 0D mode.
! 3042: * or mode = (2,4) set it as INITIAL position, and do Site Survey.
! 3043: */
! 3044:
! 3045: if (instance->posn_set) {
! 3046: oncore_log(instance, LOG_INFO, "Setting Posn from input data");
! 3047: oncore_set_posn(instance); /* this should print posn indirectly thru the As cmd */
! 3048: } else /* must issue an @@At here to check on 6/8 Position Hold, set_posn would have */
! 3049: if (instance->chan != 12)
! 3050: oncore_sendmsg(instance, oncore_cmd_Atx, sizeof(oncore_cmd_Atx));
! 3051:
! 3052: if (mode != 0) {
! 3053: /* cable delay in ns */
! 3054: memcpy(Cmd, oncore_cmd_Az, (size_t) sizeof(oncore_cmd_Az));
! 3055: w32_buf(&Cmd[-2+4], instance->delay);
! 3056: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Az)); /* 6,8,12 */
! 3057:
! 3058: /* PPS offset in ns */
! 3059: if (instance->offset) {
! 3060: memcpy(Cmd, oncore_cmd_Ay, (size_t) sizeof(oncore_cmd_Ay)); /* some have it, some don't */
! 3061: w32_buf(&Cmd[-2+4], instance->offset); /* will check for hw response */
! 3062: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Ay));
! 3063: }
! 3064:
! 3065: /* Satellite mask angle */
! 3066:
! 3067: if (instance->Ag != 0xff) { /* will have 0xff in it if not set by user */
! 3068: memcpy(Cmd, oncore_cmd_Ag, (size_t) sizeof(oncore_cmd_Ag));
! 3069: Cmd[-2+4] = instance->Ag;
! 3070: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Ag));
! 3071: }
! 3072: }
! 3073:
! 3074: /* 6, 8 12 chan - Position/Status/Data Output Message, 1/s
! 3075: * now we're really running
! 3076: * these were ALL started in the chan test,
! 3077: * However, if we had mode=3,4 then commands got turned off, so we turn
! 3078: * them on again here just in case
! 3079: */
! 3080:
! 3081: if (instance->chan == 6) { /* start 6chan, kill 8,12chan commands, possibly testing VP in 6chan mode */
! 3082: oncore_sendmsg(instance, oncore_cmd_Ea0, sizeof(oncore_cmd_Ea0));
! 3083: oncore_sendmsg(instance, oncore_cmd_En0, sizeof(oncore_cmd_En0));
! 3084: oncore_sendmsg(instance, oncore_cmd_Ha0, sizeof(oncore_cmd_Ha0));
! 3085: oncore_sendmsg(instance, oncore_cmd_Hn0, sizeof(oncore_cmd_Hn0));
! 3086: oncore_sendmsg(instance, oncore_cmd_Ba, sizeof(oncore_cmd_Ba ));
! 3087: } else if (instance->chan == 8) { /* start 8chan, kill 6,12chan commands */
! 3088: oncore_sendmsg(instance, oncore_cmd_Ba0, sizeof(oncore_cmd_Ba0));
! 3089: oncore_sendmsg(instance, oncore_cmd_Bn0, sizeof(oncore_cmd_Bn0));
! 3090: oncore_sendmsg(instance, oncore_cmd_Ha0, sizeof(oncore_cmd_Ha0));
! 3091: oncore_sendmsg(instance, oncore_cmd_Hn0, sizeof(oncore_cmd_Hn0));
! 3092: oncore_sendmsg(instance, oncore_cmd_Ea, sizeof(oncore_cmd_Ea ));
! 3093: } else if (instance->chan == 12){ /* start 12chan, kill 6,12chan commands */
! 3094: oncore_sendmsg(instance, oncore_cmd_Ba0, sizeof(oncore_cmd_Ba0));
! 3095: oncore_sendmsg(instance, oncore_cmd_Bn0, sizeof(oncore_cmd_Bn0));
! 3096: oncore_sendmsg(instance, oncore_cmd_Ea0, sizeof(oncore_cmd_Ea0));
! 3097: oncore_sendmsg(instance, oncore_cmd_En0, sizeof(oncore_cmd_En0));
! 3098: oncore_sendmsg(instance, oncore_cmd_Ha, sizeof(oncore_cmd_Ha ));
! 3099: }
! 3100:
! 3101: instance->count = 1;
! 3102: instance->o_state = ONCORE_ALMANAC;
! 3103: oncore_log(instance, LOG_NOTICE, "state = ONCORE_ALMANAC");
! 3104: }
! 3105:
! 3106:
! 3107:
! 3108: /* 12chan position */
! 3109:
! 3110: static void
! 3111: oncore_msg_Ga(
! 3112: struct instance *instance,
! 3113: u_char *buf,
! 3114: size_t len
! 3115: )
! 3116: {
! 3117: char Msg[160];
! 3118: long lat, lon, ht;
! 3119: double Lat, Lon, Ht;
! 3120:
! 3121:
! 3122: lat = buf_w32(&buf[4]);
! 3123: lon = buf_w32(&buf[8]);
! 3124: ht = buf_w32(&buf[12]); /* GPS ellipsoid */
! 3125:
! 3126: Lat = lat;
! 3127: Lon = lon;
! 3128: Ht = ht;
! 3129:
! 3130: Lat /= 3600000;
! 3131: Lon /= 3600000;
! 3132: Ht /= 100;
! 3133:
! 3134:
! 3135: snprintf(Msg, sizeof(Msg),
! 3136: "Ga Posn Lat = %.7f, Lon = %.7f, Ht = %.2f", Lat,
! 3137: Lon, Ht);
! 3138: oncore_log(instance, LOG_NOTICE, Msg);
! 3139:
! 3140: instance->ss_lat = lat;
! 3141: instance->ss_long = lon;
! 3142: instance->ss_ht = ht;
! 3143:
! 3144: oncore_print_posn(instance);
! 3145: }
! 3146:
! 3147:
! 3148:
! 3149: /* 12 chan time/date */
! 3150:
! 3151: static void
! 3152: oncore_msg_Gb(
! 3153: struct instance *instance,
! 3154: u_char *buf,
! 3155: size_t len
! 3156: )
! 3157: {
! 3158: char Msg[160], *gmts;
! 3159: int mo, d, y, h, m, s, gmth, gmtm;
! 3160:
! 3161: mo = buf[4];
! 3162: d = buf[5];
! 3163: y = 256*buf[6]+buf[7];
! 3164:
! 3165: h = buf[8];
! 3166: m = buf[9];
! 3167: s = buf[10];
! 3168:
! 3169: gmts = ((buf[11] == 0) ? "+" : "-");
! 3170: gmth = buf[12];
! 3171: gmtm = buf[13];
! 3172:
! 3173: snprintf(Msg, sizeof(Msg),
! 3174: "Date/Time set to: %d%s%d %2d:%02d:%02d GMT (GMT offset is %s%02d:%02d)",
! 3175: d, Month[mo-1], y, h, m, s, gmts, gmth, gmtm);
! 3176: oncore_log(instance, LOG_NOTICE, Msg);
! 3177: }
! 3178:
! 3179:
! 3180:
! 3181: /* Leap Second for M12, gives all info from satellite message */
! 3182: /* also in UT v3.0 */
! 3183:
! 3184: static void
! 3185: oncore_msg_Gj(
! 3186: struct instance *instance,
! 3187: u_char *buf,
! 3188: size_t len
! 3189: )
! 3190: {
! 3191: int dt;
! 3192: char Msg[160], *cp;
! 3193:
! 3194: instance->saw_Gj = 1; /* flag, saw_Gj, dont need to try Bj in check_leap */
! 3195:
! 3196: /* print the message to verify whats there */
! 3197:
! 3198: dt = buf[5] - buf[4];
! 3199:
! 3200: snprintf(Msg, sizeof(Msg),
! 3201: "Leap Sec Msg: %d %d %d %d %d %d %d %d %d %d", buf[4],
! 3202: buf[5], 256 * buf[6] + buf[7], buf[8], buf[9], buf[10],
! 3203: (buf[14] + 256 *
! 3204: (buf[13] + 256 * (buf[12] + 256 * buf[11]))),
! 3205: buf[15], buf[16], buf[17]);
! 3206: oncore_log(instance, LOG_INFO, Msg);
! 3207:
! 3208: if (dt) {
! 3209: snprintf(Msg, sizeof(Msg),
! 3210: "Leap second (%d) scheduled for %d%s%d at %d:%d:%d",
! 3211: dt, buf[9], Month[buf[8] - 1],
! 3212: 256 * buf[6] + buf[7], buf[15], buf[16],
! 3213: buf[17]);
! 3214: oncore_log(instance, LOG_NOTICE, Msg);
! 3215: }
! 3216:
! 3217: /* Only raise warning within a month of the leap second */
! 3218:
! 3219: instance->pp->leap = LEAP_NOWARNING;
! 3220: cp = "Set pp.leap to LEAP_NOWARNING";
! 3221:
! 3222: if (buf[6] == instance->BEHa[6] && buf[7] == instance->BEHa[7] && /* year */
! 3223: buf[8] == instance->BEHa[4]) { /* month */
! 3224: if (dt) {
! 3225: if (dt < 0) {
! 3226: instance->pp->leap = LEAP_DELSECOND;
! 3227: cp = "Set pp.leap to LEAP_DELSECOND";
! 3228: } else {
! 3229: instance->pp->leap = LEAP_ADDSECOND;
! 3230: cp = "Set pp.leap to LEAP_ADDSECOND";
! 3231: }
! 3232: }
! 3233: }
! 3234: oncore_log(instance, LOG_INFO, cp);
! 3235: }
! 3236:
! 3237:
! 3238:
! 3239: /* Power on failure */
! 3240:
! 3241: static void
! 3242: oncore_msg_Sz(
! 3243: struct instance *instance,
! 3244: u_char *buf,
! 3245: size_t len
! 3246: )
! 3247: {
! 3248: if (instance && instance->peer) {
! 3249: oncore_log(instance, LOG_ERR, "Oncore: System Failure at Power On");
! 3250: oncore_shutdown(instance->unit, instance->peer);
! 3251: }
! 3252: }
! 3253:
! 3254: /************** Small Subroutines ***************/
! 3255:
! 3256:
! 3257: static void
! 3258: oncore_antenna_report(
! 3259: struct instance *instance,
! 3260: enum antenna_state new_state)
! 3261: {
! 3262: char *cp;
! 3263:
! 3264: if (instance->ant_state == new_state)
! 3265: return;
! 3266:
! 3267: switch (new_state) {
! 3268: case ONCORE_ANTENNA_OK: cp = "GPS antenna: OK"; break;
! 3269: case ONCORE_ANTENNA_OC: cp = "GPS antenna: short (overcurrent)"; break;
! 3270: case ONCORE_ANTENNA_UC: cp = "GPS antenna: open (not connected)"; break;
! 3271: case ONCORE_ANTENNA_NV: cp = "GPS antenna: short (no voltage)"; break;
! 3272: default: cp = "GPS antenna: ?"; break;
! 3273: }
! 3274:
! 3275: instance->ant_state = new_state;
! 3276: oncore_log(instance, LOG_NOTICE, cp);
! 3277: }
! 3278:
! 3279:
! 3280:
! 3281: static void
! 3282: oncore_chan_test(
! 3283: struct instance *instance
! 3284: )
! 3285: {
! 3286: /* subroutine oncore_Cj_id has determined the number of channels from the
! 3287: * model number of the attached oncore. This is not always correct since
! 3288: * the oncore could have non-standard firmware. Here we check (independently) by
! 3289: * trying a 6, 8, and 12 chan command, and see which responds.
! 3290: * Caution: more than one CAN respond.
! 3291: *
! 3292: * This #chan is used by the code rather than that calculated from the model number.
! 3293: */
! 3294:
! 3295: instance->o_state = ONCORE_CHECK_CHAN;
! 3296: oncore_log(instance, LOG_NOTICE, "state = ONCORE_CHECK_CHAN");
! 3297:
! 3298: instance->count3 = 1;
! 3299: oncore_sendmsg(instance, oncore_cmd_Ba, sizeof(oncore_cmd_Ba));
! 3300: oncore_sendmsg(instance, oncore_cmd_Ea, sizeof(oncore_cmd_Ea));
! 3301: oncore_sendmsg(instance, oncore_cmd_Ha, sizeof(oncore_cmd_Ha));
! 3302: }
! 3303:
! 3304:
! 3305:
! 3306: /* check for a GOOD Almanac, have we got one yet? */
! 3307:
! 3308: static void
! 3309: oncore_check_almanac(
! 3310: struct instance *instance
! 3311: )
! 3312: {
! 3313: if (instance->chan == 6) {
! 3314: instance->rsm.bad_almanac = instance->BEHa[64]&0x1;
! 3315: instance->rsm.bad_fix = instance->BEHa[64]&0x52;
! 3316: } else if (instance->chan == 8) {
! 3317: instance->rsm.bad_almanac = instance->BEHa[72]&0x1;
! 3318: instance->rsm.bad_fix = instance->BEHa[72]&0x52;
! 3319: } else if (instance->chan == 12) {
! 3320: int bits1, bits2, bits3;
! 3321:
! 3322: bits1 = (instance->BEHa[129]>>5) & 0x7; /* actually Ha */
! 3323: bits2 = instance->BEHa[130];
! 3324: instance->rsm.bad_almanac = (bits2 & 0x80);
! 3325: instance->rsm.bad_fix = (bits2 & 0x8) || (bits1 == 0x2);
! 3326: /* too few sat Bad Geom */
! 3327:
! 3328: bits3 = instance->BEHa[141]; /* UTC parameters */
! 3329: if (!instance->count5_set && (bits3 & 0xC0)) {
! 3330: instance->count5 = 2;
! 3331: instance->count5_set = 1;
! 3332: }
! 3333: #ifdef ONCORE_VERBOSE_CHECK_ALMANAC
! 3334: {
! 3335: char Msg[160];
! 3336:
! 3337: snprintf(Msg, sizeof(Msg),
! 3338: "DEBUG BITS: (%x %x), (%x %x %x), %x %x %x %x %x",
! 3339: instance->BEHa[129],
! 3340: instance->BEHa[130], bits1, bits2,
! 3341: bits3, instance->mode == MODE_0D,
! 3342: instance->mode == MODE_2D,
! 3343: instance->mode == MODE_3D,
! 3344: instance->rsm.bad_almanac,
! 3345: instance->rsm.bad_fix);
! 3346: oncore_log(instance, LOG_DEBUG, Msg);
! 3347: }
! 3348: #endif
! 3349: }
! 3350: }
! 3351:
! 3352:
! 3353:
! 3354: /* check the antenna for changes (did it get unplugged?) */
! 3355:
! 3356: static void
! 3357: oncore_check_antenna(
! 3358: struct instance *instance
! 3359: )
! 3360: {
! 3361: enum antenna_state antenna; /* antenna state */
! 3362:
! 3363: antenna = instance->ant_state;
! 3364: if (instance->chan == 12)
! 3365: antenna = (instance->BEHa[130] & 0x6 ) >> 1;
! 3366: else
! 3367: antenna = (instance->BEHa[37] & 0xc0) >> 6; /* prob unset 6, set GT, UT unset VP */
! 3368:
! 3369: oncore_antenna_report (instance, antenna);
! 3370: }
! 3371:
! 3372:
! 3373:
! 3374: /*
! 3375: * Check the leap second status once per day.
! 3376: *
! 3377: * Note that the ONCORE firmware for the Bj command is wrong at
! 3378: * least in the VP.
! 3379: * It starts advertising a LEAP SECOND as soon as the GPS satellite
! 3380: * data message (page 18, subframe 4) is updated to a date in the
! 3381: * future, and does not wait for the month that it will occur.
! 3382: * The event will usually be advertised several months in advance.
! 3383: * Since there is a one bit flag, there is no way to tell if it is
! 3384: * this month, or when...
! 3385: *
! 3386: * As such, we have the workaround below, of only checking for leap
! 3387: * seconds with the Bj command in June/December.
! 3388: *
! 3389: * The Gj command gives more information, and we can tell in which
! 3390: * month to apply the correction.
! 3391: *
! 3392: * Note that with the VP we COULD read the raw data message, and
! 3393: * interpret it ourselves, but since this is specific to this receiver
! 3394: * only, and the above workaround is adequate, we don't bother.
! 3395: */
! 3396:
! 3397: static void
! 3398: oncore_check_leap_sec(
! 3399: struct instance *instance
! 3400: )
! 3401: {
! 3402: oncore_cmd_Bl[2] = 1; /* just to be sure */
! 3403: if (instance->Bj_day != instance->BEHa[5]) { /* do this 1/day */
! 3404: instance->Bj_day = instance->BEHa[5];
! 3405:
! 3406: if (instance->saw_Gj < 0) { /* -1 DONT have Gj use Bj */
! 3407: if ((instance->BEHa[4] == 6) || (instance->BEHa[4] == 12))
! 3408: oncore_sendmsg(instance, oncore_cmd_Bj, sizeof(oncore_cmd_Bj));
! 3409: oncore_sendmsg(instance, oncore_cmd_Bl, sizeof(oncore_cmd_Bl));
! 3410: return;
! 3411: }
! 3412:
! 3413: if (instance->saw_Gj == 0) /* 0 is dont know if we have Gj */
! 3414: instance->count4 = 1;
! 3415:
! 3416: oncore_sendmsg(instance, oncore_cmd_Gj, sizeof(oncore_cmd_Gj));
! 3417: return;
! 3418: }
! 3419:
! 3420: /* Gj works for some 6/8 chan UT and the M12 */
! 3421: /* if no response from Gj in 5 sec, we try Bj */
! 3422: /* which isnt implemented in all the GT/UT either */
! 3423:
! 3424: if (instance->count4) { /* delay, waiting for Gj response */
! 3425: if (instance->saw_Gj == 1)
! 3426: instance->count4 = 0;
! 3427: else if (instance->count4++ > 5) { /* delay, waiting for Gj response */
! 3428: instance->saw_Gj = -1; /* didnt see it, will use Bj */
! 3429: instance->count4 = 0;
! 3430: if ((instance->BEHa[4] == 6) || (instance->BEHa[4] == 12))
! 3431: oncore_sendmsg(instance, oncore_cmd_Bj, sizeof(oncore_cmd_Bj));
! 3432: oncore_sendmsg(instance, oncore_cmd_Bl, sizeof(oncore_cmd_Bl));
! 3433: }
! 3434: }
! 3435: }
! 3436:
! 3437:
! 3438:
! 3439: /* check the message checksum,
! 3440: * buf points to START of message ( @@ )
! 3441: * len is length WITH CR/LF.
! 3442: */
! 3443:
! 3444: static int
! 3445: oncore_checksum_ok(
! 3446: u_char *buf,
! 3447: int len
! 3448: )
! 3449: {
! 3450: int i, j;
! 3451:
! 3452: j = 0;
! 3453: for (i = 2; i < len-3; i++)
! 3454: j ^= buf[i];
! 3455:
! 3456: return(j == buf[len-3]);
! 3457: }
! 3458:
! 3459:
! 3460:
! 3461: static void
! 3462: oncore_compute_dH(
! 3463: struct instance *instance
! 3464: )
! 3465: {
! 3466: int GPS, MSL;
! 3467: char Msg[160];
! 3468:
! 3469: /* Here calculate dH = GPS - MSL for output message */
! 3470: /* also set Altitude Hold mode if GT */
! 3471:
! 3472: instance->have_dH = 1;
! 3473: if (instance->chan == 12) {
! 3474: GPS = buf_w32(&instance->BEHa[39]);
! 3475: MSL = buf_w32(&instance->BEHa[43]);
! 3476: } else {
! 3477: GPS = buf_w32(&instance->BEHa[23]);
! 3478: MSL = buf_w32(&instance->BEHa[27]);
! 3479: }
! 3480: instance->dH = GPS - MSL;
! 3481: instance->dH /= 100.;
! 3482:
! 3483: /* if MSL is not set, the calculation is meaningless */
! 3484:
! 3485: if (MSL) { /* not set ! */
! 3486: snprintf(Msg, sizeof(Msg), "dH = (GPS - MSL) = %.2fm",
! 3487: instance->dH);
! 3488: oncore_log(instance, LOG_INFO, Msg);
! 3489: }
! 3490: }
! 3491:
! 3492:
! 3493:
! 3494: /*
! 3495: * try loading Almanac from shmem (where it was copied from shmem_old
! 3496: */
! 3497:
! 3498: static void
! 3499: oncore_load_almanac(
! 3500: struct instance *instance
! 3501: )
! 3502: {
! 3503: u_char *cp, Cmd[20];
! 3504: int n;
! 3505: struct timeval tv;
! 3506: struct tm *tm;
! 3507:
! 3508: if (!instance->shmem)
! 3509: return;
! 3510:
! 3511: #ifndef ONCORE_VERBOSE_LOAD_ALMANAC
! 3512: for (cp = instance->shmem + 4; (n = 256 * (*(cp-3)) + *(cp-2));
! 3513: cp += (n + 3)) {
! 3514: if (!strncmp((char *) cp, "@@Cb", 4) &&
! 3515: oncore_checksum_ok(cp, 33) &&
! 3516: (*(cp+4) == 4 || *(cp+4) == 5)) {
! 3517: write(instance->ttyfd, cp, n);
! 3518: oncore_print_Cb(instance, cp);
! 3519: }
! 3520: }
! 3521: #else /* ONCORE_VERBOSE_LOAD_ALMANAC follows */
! 3522: for (cp = instance->shmem + 4; (n = 256 * (*(cp-3)) + *(cp-2));
! 3523: cp += (n+3)) {
! 3524: char Msg[160];
! 3525:
! 3526: snprintf(Msg, sizeof(Msg), "See %c%c%c%c %d", *(cp),
! 3527: *(cp+1), *(cp+2), *(cp+3), *(cp+4));
! 3528: oncore_log(instance, LOG_DEBUG, Msg);
! 3529:
! 3530: if (!strncmp(cp, "@@Cb", 4)) {
! 3531: oncore_print_Cb(instance, cp);
! 3532: if (oncore_checksum_ok(cp, 33)) {
! 3533: if (*(cp+4) == 4 || *(cp+4) == 5) {
! 3534: oncore_log(instance, LOG_DEBUG, "GOOD SF");
! 3535: write(instance->ttyfd, cp, n);
! 3536: } else
! 3537: oncore_log(instance, LOG_DEBUG, "BAD SF");
! 3538: } else
! 3539: oncore_log(instance, LOG_DEBUG, "BAD CHECKSUM");
! 3540: }
! 3541: }
! 3542: #endif
! 3543:
! 3544: /* Must load position and time or the Almanac doesn't do us any good */
! 3545:
! 3546: if (!instance->posn_set) { /* if we input a posn use it, else from SHMEM */
! 3547: oncore_log(instance, LOG_NOTICE, "Loading Posn from SHMEM");
! 3548: for (cp=instance->shmem+4; (n = 256*(*(cp-3)) + *(cp-2)); cp+=(n+3)) {
! 3549: if ((instance->chan == 6 && (!strncmp((char *) cp, "@@Ba", 4) && oncore_checksum_ok(cp, 68))) ||
! 3550: (instance->chan == 8 && (!strncmp((char *) cp, "@@Ea", 4) && oncore_checksum_ok(cp, 76))) ||
! 3551: (instance->chan == 12 && (!strncmp((char *) cp, "@@Ha", 4) && oncore_checksum_ok(cp, 154)))) {
! 3552: int ii, jj, kk;
! 3553:
! 3554: instance->posn_set = 1;
! 3555: ii = buf_w32(cp + 15);
! 3556: jj = buf_w32(cp + 19);
! 3557: kk = buf_w32(cp + 23);
! 3558: #ifdef ONCORE_VERBOSE_LOAD_ALMANAC
! 3559: {
! 3560: char Msg[160];
! 3561: snprintf(Msg, sizeof(Msg),
! 3562: "SHMEM posn = %ld (%d, %d, %d)",
! 3563: (long)(cp-instance->shmem),
! 3564: ii, jj, kk);
! 3565: oncore_log(instance, LOG_DEBUG, Msg);
! 3566: }
! 3567: #endif
! 3568: if (ii != 0 || jj != 0 || kk != 0) { /* phk asked for this test */
! 3569: instance->ss_lat = ii;
! 3570: instance->ss_long = jj;
! 3571: instance->ss_ht = kk;
! 3572: }
! 3573: }
! 3574: }
! 3575: }
! 3576: oncore_set_posn(instance);
! 3577:
! 3578: /* and set time to time from Computer clock */
! 3579:
! 3580: GETTIMEOFDAY(&tv, 0);
! 3581: tm = gmtime((const time_t *) &tv.tv_sec);
! 3582:
! 3583: #ifdef ONCORE_VERBOSE_LOAD_ALMANAC
! 3584: {
! 3585: char Msg[160];
! 3586: snprintf(Msg, sizeof(Msg), "DATE %d %d %d, %d %d %d",
! 3587: 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
! 3588: tm->tm_hour, tm->tm_min, tm->tm_sec);
! 3589: oncore_log(instance, LOG_DEBUG, Msg);
! 3590: }
! 3591: #endif
! 3592: if (instance->chan == 12) {
! 3593: memcpy(Cmd, oncore_cmd_Gb, (size_t) sizeof(oncore_cmd_Gb));
! 3594: Cmd[-2+4] = tm->tm_mon + 1;
! 3595: Cmd[-2+5] = tm->tm_mday;
! 3596: Cmd[-2+6] = (1900+tm->tm_year)/256;
! 3597: Cmd[-2+7] = (1900+tm->tm_year)%256;
! 3598: Cmd[-2+8] = tm->tm_hour;
! 3599: Cmd[-2+9] = tm->tm_min;
! 3600: Cmd[-2+10] = tm->tm_sec;
! 3601: Cmd[-2+11] = 0;
! 3602: Cmd[-2+12] = 0;
! 3603: Cmd[-2+13] = 0;
! 3604: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Gb));
! 3605: } else {
! 3606: /* First set GMT offset to zero */
! 3607:
! 3608: oncore_sendmsg(instance, oncore_cmd_Ab, sizeof(oncore_cmd_Ab));
! 3609:
! 3610: memcpy(Cmd, oncore_cmd_Ac, (size_t) sizeof(oncore_cmd_Ac));
! 3611: Cmd[-2+4] = tm->tm_mon + 1;
! 3612: Cmd[-2+5] = tm->tm_mday;
! 3613: Cmd[-2+6] = (1900+tm->tm_year)/256;
! 3614: Cmd[-2+7] = (1900+tm->tm_year)%256;
! 3615: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Ac));
! 3616:
! 3617: memcpy(Cmd, oncore_cmd_Aa, (size_t) sizeof(oncore_cmd_Aa));
! 3618: Cmd[-2+4] = tm->tm_hour;
! 3619: Cmd[-2+5] = tm->tm_min;
! 3620: Cmd[-2+6] = tm->tm_sec;
! 3621: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Aa));
! 3622: }
! 3623:
! 3624: oncore_log(instance, LOG_INFO, "Setting Posn and Time after Loading Almanac");
! 3625: }
! 3626:
! 3627:
! 3628:
! 3629: /* Almanac data input */
! 3630:
! 3631: static void
! 3632: oncore_print_Cb(
! 3633: struct instance *instance,
! 3634: u_char *cp
! 3635: )
! 3636: {
! 3637: #ifdef ONCORE_VERBOSE_CB
! 3638: int ii;
! 3639: char Msg[160], Msg2[10];
! 3640:
! 3641: snprintf(Msg, sizeof(Msg), "DEBUG: See: %c%c%c%c", *(cp),
! 3642: *(cp+1), *(cp+2), *(cp+3));
! 3643: oncore_log(instance, LOG_DEBUG, Msg);
! 3644: snprintf(Msg, sizeof(Msg), "DEBUG: Cb: [%d,%d]", *(cp+4),
! 3645: *(cp+5));
! 3646: for(ii = 0; ii < 33; ii++) {
! 3647: snprintf(Msg2, sizeof(Msg2), " %d", *(cp+ii));
! 3648: strncat(Msg, Msg2, sizeof(Msg));
! 3649: }
! 3650: oncore_log(instance, LOG_DEBUG, Msg);
! 3651:
! 3652: snprintf(Msg, sizeof(Msg), "Debug: Cb: [%d,%d]", *(cp+4),
! 3653: *(cp+5));
! 3654: oncore_log(instance, LOG_DEBUG, Msg);
! 3655: #endif
! 3656: }
! 3657:
! 3658:
! 3659: #if 0
! 3660: static void
! 3661: oncore_print_array(
! 3662: u_char *cp,
! 3663: int n
! 3664: )
! 3665: {
! 3666: int jj, i, j, nn;
! 3667:
! 3668: nn = 0;
! 3669: printf("\nTOP\n");
! 3670: jj = n/16;
! 3671: for (j=0; j<jj; j++) {
! 3672: printf("%4d: ", nn);
! 3673: nn += 16;
! 3674: for (i=0; i<16; i++)
! 3675: printf(" %o", *cp++);
! 3676: printf("\n");
! 3677: }
! 3678: }
! 3679: #endif
! 3680:
! 3681:
! 3682: static void
! 3683: oncore_print_posn(
! 3684: struct instance *instance
! 3685: )
! 3686: {
! 3687: char Msg[120], ew, ns;
! 3688: double xd, xm, xs, yd, ym, ys, hm, hft;
! 3689: int idx, idy, is, imx, imy;
! 3690: long lat, lon;
! 3691:
! 3692: oncore_log(instance, LOG_INFO, "Posn:");
! 3693: ew = 'E';
! 3694: lon = instance->ss_long;
! 3695: if (lon < 0) {
! 3696: ew = 'W';
! 3697: lon = -lon;
! 3698: }
! 3699:
! 3700: ns = 'N';
! 3701: lat = instance->ss_lat;
! 3702: if (lat < 0) {
! 3703: ns = 'S';
! 3704: lat = -lat;
! 3705: }
! 3706:
! 3707: hm = instance->ss_ht/100.;
! 3708: hft= hm/0.3048;
! 3709:
! 3710: xd = lat/3600000.; /* lat, lon in int msec arc, ht in cm. */
! 3711: yd = lon/3600000.;
! 3712: snprintf(Msg, sizeof(Msg),
! 3713: "Lat = %c %11.7fdeg, Long = %c %11.7fdeg, Alt = %5.2fm (%5.2fft) GPS",
! 3714: ns, xd, ew, yd, hm, hft);
! 3715: oncore_log(instance, LOG_INFO, Msg);
! 3716:
! 3717: idx = xd;
! 3718: idy = yd;
! 3719: imx = lat%3600000;
! 3720: imy = lon%3600000;
! 3721: xm = imx/60000.;
! 3722: ym = imy/60000.;
! 3723: snprintf(Msg, sizeof(Msg),
! 3724: "Lat = %c %3ddeg %7.4fm, Long = %c %3ddeg %8.5fm, Alt = %7.2fm (%7.2fft) GPS", ns, idx, xm, ew, idy, ym, hm, hft);
! 3725: oncore_log(instance, LOG_INFO, Msg);
! 3726:
! 3727: imx = xm;
! 3728: imy = ym;
! 3729: is = lat%60000;
! 3730: xs = is/1000.;
! 3731: is = lon%60000;
! 3732: ys = is/1000.;
! 3733: snprintf(Msg, sizeof(Msg),
! 3734: "Lat = %c %3ddeg %2dm %5.2fs, Long = %c %3ddeg %2dm %5.2fs, Alt = %7.2fm (%7.2fft) GPS",
! 3735: ns, idx, imx, xs, ew, idy, imy, ys, hm, hft);
! 3736: oncore_log(instance, LOG_INFO, Msg);
! 3737: }
! 3738:
! 3739:
! 3740:
! 3741: /*
! 3742: * write message to Oncore.
! 3743: */
! 3744:
! 3745: static void
! 3746: oncore_sendmsg(
! 3747: struct instance *instance,
! 3748: u_char *ptr,
! 3749: size_t len
! 3750: )
! 3751: {
! 3752: int fd;
! 3753: u_char cs = 0;
! 3754:
! 3755: fd = instance->ttyfd;
! 3756: #ifdef ONCORE_VERBOSE_SENDMSG
! 3757: if (debug > 4) {
! 3758: char Msg[120];
! 3759:
! 3760: snprintf(Msg, sizeof(Msg), "ONCORE: Send @@%c%c %d",
! 3761: ptr[0], ptr[1], (int)len);
! 3762: oncore_log(instance, LOG_DEBUG, Msg);
! 3763: }
! 3764: #endif
! 3765: write(fd, "@@", (size_t) 2);
! 3766: write(fd, ptr, len);
! 3767: while (len--)
! 3768: cs ^= *ptr++;
! 3769: write(fd, &cs, (size_t) 1);
! 3770: write(fd, "\r\n", (size_t) 2);
! 3771: }
! 3772:
! 3773:
! 3774:
! 3775: static void
! 3776: oncore_set_posn(
! 3777: struct instance *instance
! 3778: )
! 3779: {
! 3780: int mode;
! 3781: u_char Cmd[20];
! 3782:
! 3783: /* Turn OFF position hold, it needs to be off to set position (for some units),
! 3784: will get set ON in @@Ea later */
! 3785:
! 3786: if (instance->chan == 12)
! 3787: oncore_sendmsg(instance, oncore_cmd_Gd0, sizeof(oncore_cmd_Gd0)); /* (12) */
! 3788: else {
! 3789: oncore_sendmsg(instance, oncore_cmd_At0, sizeof(oncore_cmd_At0)); /* (6/8) */
! 3790: oncore_sendmsg(instance, oncore_cmd_Av0, sizeof(oncore_cmd_Av0)); /* (6/8) */
! 3791: }
! 3792:
! 3793: mode = instance->init_type;
! 3794:
! 3795: if (mode != 0) { /* first set posn hold position */
! 3796: memcpy(Cmd, oncore_cmd_As, (size_t) sizeof(oncore_cmd_As)); /* don't modify static variables */
! 3797: w32_buf(&Cmd[-2+4], (int) instance->ss_lat);
! 3798: w32_buf(&Cmd[-2+8], (int) instance->ss_long);
! 3799: w32_buf(&Cmd[-2+12], (int) instance->ss_ht);
! 3800: Cmd[-2+16] = 0;
! 3801: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_As)); /* posn hold 3D posn (6/8/12) */
! 3802:
! 3803: memcpy(Cmd, oncore_cmd_Au, (size_t) sizeof(oncore_cmd_Au));
! 3804: w32_buf(&Cmd[-2+4], (int) instance->ss_ht);
! 3805: Cmd[-2+8] = 0;
! 3806: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Au)); /* altitude hold (6/8/12 not UT, M12T) */
! 3807:
! 3808: /* next set current position */
! 3809:
! 3810: if (instance->chan == 12) {
! 3811: memcpy(Cmd, oncore_cmd_Ga, (size_t) sizeof(oncore_cmd_Ga));
! 3812: w32_buf(&Cmd[-2+4], (int) instance->ss_lat);
! 3813: w32_buf(&Cmd[-2+8], (int) instance->ss_long);
! 3814: w32_buf(&Cmd[-2+12],(int) instance->ss_ht);
! 3815: Cmd[-2+16] = 0;
! 3816: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Ga)); /* 3d posn (12) */
! 3817: } else {
! 3818: memcpy(Cmd, oncore_cmd_Ad, (size_t) sizeof(oncore_cmd_Ad));
! 3819: w32_buf(&Cmd[-2+4], (int) instance->ss_lat);
! 3820: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Ad)); /* lat (6/8) */
! 3821:
! 3822: memcpy(Cmd, oncore_cmd_Ae, (size_t) sizeof(oncore_cmd_Ae));
! 3823: w32_buf(&Cmd[-2+4], (int) instance->ss_long);
! 3824: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Ae)); /* long (6/8) */
! 3825:
! 3826: memcpy(Cmd, oncore_cmd_Af, (size_t) sizeof(oncore_cmd_Af));
! 3827: w32_buf(&Cmd[-2+4], (int) instance->ss_ht);
! 3828: Cmd[-2+8] = 0;
! 3829: oncore_sendmsg(instance, Cmd, sizeof(oncore_cmd_Af)); /* ht (6/8) */
! 3830: }
! 3831:
! 3832: /* Finally, turn on position hold */
! 3833:
! 3834: if (instance->chan == 12)
! 3835: oncore_sendmsg(instance, oncore_cmd_Gd1, sizeof(oncore_cmd_Gd1));
! 3836: else
! 3837: oncore_sendmsg(instance, oncore_cmd_At1, sizeof(oncore_cmd_At1));
! 3838: }
! 3839: }
! 3840:
! 3841:
! 3842:
! 3843: static void
! 3844: oncore_set_traim(
! 3845: struct instance *instance
! 3846: )
! 3847: {
! 3848: char Msg[160];
! 3849:
! 3850: if (instance->traim_in != -1) /* set in Input */
! 3851: instance->traim = instance->traim_in;
! 3852: else
! 3853: instance->traim = instance->traim_ck;
! 3854:
! 3855: snprintf(Msg, sizeof(Msg), "Input says TRAIM = %d",
! 3856: instance->traim_in);
! 3857: oncore_log(instance, LOG_INFO, Msg);
! 3858: snprintf(Msg, sizeof(Msg), "Model # says TRAIM = %d",
! 3859: instance->traim_id);
! 3860: oncore_log(instance, LOG_INFO, Msg);
! 3861: snprintf(Msg, sizeof(Msg), "Testing says TRAIM = %d",
! 3862: instance->traim_ck);
! 3863: oncore_log(instance, LOG_INFO, Msg);
! 3864: snprintf(Msg, sizeof(Msg), "Using TRAIM = %d",
! 3865: instance->traim);
! 3866: oncore_log(instance, LOG_INFO, Msg);
! 3867:
! 3868: if (instance->traim_ck == 1 && instance->traim == 0) {
! 3869: /* if it should be off, and I turned it on during testing,
! 3870: then turn it off again */
! 3871: if (instance->chan == 6)
! 3872: oncore_sendmsg(instance, oncore_cmd_Bnx, sizeof(oncore_cmd_Bnx));
! 3873: else if (instance->chan == 8)
! 3874: oncore_sendmsg(instance, oncore_cmd_Enx, sizeof(oncore_cmd_Enx));
! 3875: else /* chan == 12 */
! 3876: oncore_sendmsg(instance, oncore_cmd_Ge0, sizeof(oncore_cmd_Ge0));
! 3877: oncore_sendmsg(instance, oncore_cmd_Hn0, sizeof(oncore_cmd_Hn0));
! 3878: }
! 3879: }
! 3880:
! 3881:
! 3882:
! 3883: /*
! 3884: * if SHMEM active, every 15s, steal one 'tick' to get 2D or 3D posn.
! 3885: */
! 3886:
! 3887: static void
! 3888: oncore_shmem_get_3D(
! 3889: struct instance *instance
! 3890: )
! 3891: {
! 3892: if (instance->pp->second%15 == 3) { /* start the sequence */ /* by changing mode */
! 3893: instance->shmem_reset = 1;
! 3894: if (instance->chan == 12) {
! 3895: if (instance->shmem_Posn == 2)
! 3896: oncore_sendmsg(instance, oncore_cmd_Gd2, sizeof(oncore_cmd_Gd2)); /* 2D */
! 3897: else
! 3898: oncore_sendmsg(instance, oncore_cmd_Gd0, sizeof(oncore_cmd_Gd0)); /* 3D */
! 3899: } else {
! 3900: if (instance->saw_At) { /* out of 0D -> 3D mode */
! 3901: oncore_sendmsg(instance, oncore_cmd_At0, sizeof(oncore_cmd_At0));
! 3902: if (instance->shmem_Posn == 2) /* 3D -> 2D mode */
! 3903: oncore_sendmsg(instance, oncore_cmd_Av1, sizeof(oncore_cmd_Av1));
! 3904: } else
! 3905: oncore_sendmsg(instance, oncore_cmd_Av0, sizeof(oncore_cmd_Av0));
! 3906: }
! 3907: } else if (instance->shmem_reset || (instance->mode != MODE_0D)) {
! 3908: instance->shmem_reset = 0;
! 3909: if (instance->chan == 12)
! 3910: oncore_sendmsg(instance, oncore_cmd_Gd1, sizeof(oncore_cmd_Gd1)); /* 0D */
! 3911: else {
! 3912: if (instance->saw_At) {
! 3913: if (instance->mode == MODE_2D) /* 2D -> 3D or 0D mode */
! 3914: oncore_sendmsg(instance, oncore_cmd_Av0, sizeof(oncore_cmd_Av0));
! 3915: oncore_sendmsg(instance, oncore_cmd_At1, sizeof(oncore_cmd_At1)); /* to 0D mode */
! 3916: } else
! 3917: oncore_sendmsg(instance, oncore_cmd_Av1, sizeof(oncore_cmd_Av1));
! 3918: }
! 3919: }
! 3920: }
! 3921:
! 3922:
! 3923:
! 3924: /*
! 3925: * Here we do the Software SiteSurvey.
! 3926: * We have to average our own position for the Position Hold Mode
! 3927: * We use Heights from the GPS ellipsoid.
! 3928: * We check for the END of either HW or SW SiteSurvey.
! 3929: */
! 3930:
! 3931: static void
! 3932: oncore_ss(
! 3933: struct instance *instance
! 3934: )
! 3935: {
! 3936: char Msg[160];
! 3937: double lat, lon, ht;
! 3938:
! 3939:
! 3940: if (instance->site_survey == ONCORE_SS_HW) {
! 3941: /*
! 3942: * Check to see if Hardware SiteSurvey has Finished.
! 3943: */
! 3944:
! 3945: if ((instance->chan == 8 && !(instance->BEHa[37] & 0x20)) ||
! 3946: (instance->chan == 12 && !(instance->BEHa[130] & 0x10))) {
! 3947: oncore_log(instance, LOG_INFO, "Now in 0D mode");
! 3948:
! 3949: if (instance->chan == 12)
! 3950: oncore_sendmsg(instance, oncore_cmd_Gax, sizeof(oncore_cmd_Gax));
! 3951: else
! 3952: oncore_sendmsg(instance, oncore_cmd_Asx, sizeof(oncore_cmd_Asx));
! 3953:
! 3954: oncore_log(instance, LOG_NOTICE, "SSstate = ONCORE_SS_DONE");
! 3955: instance->site_survey = ONCORE_SS_DONE;
! 3956: }
! 3957: } else {
! 3958: /*
! 3959: * Must be a Software Site Survey.
! 3960: */
! 3961:
! 3962: if (instance->rsm.bad_fix) /* Not if poor geometry or less than 3 sats */
! 3963: return;
! 3964:
! 3965: if (instance->mode != MODE_3D) /* Use only 3D Fixes */
! 3966: return;
! 3967:
! 3968: instance->ss_lat += buf_w32(&instance->BEHa[15]);
! 3969: instance->ss_long += buf_w32(&instance->BEHa[19]);
! 3970: instance->ss_ht += buf_w32(&instance->BEHa[23]); /* GPS ellipsoid */
! 3971: instance->ss_count++;
! 3972:
! 3973: if (instance->ss_count != POS_HOLD_AVERAGE)
! 3974: return;
! 3975:
! 3976: instance->ss_lat /= POS_HOLD_AVERAGE;
! 3977: instance->ss_long /= POS_HOLD_AVERAGE;
! 3978: instance->ss_ht /= POS_HOLD_AVERAGE;
! 3979:
! 3980: snprintf(Msg, sizeof(Msg),
! 3981: "Surveyed posn: lat %.3f (mas) long %.3f (mas) ht %.3f (cm)",
! 3982: instance->ss_lat, instance->ss_long,
! 3983: instance->ss_ht);
! 3984: oncore_log(instance, LOG_NOTICE, Msg);
! 3985: lat = instance->ss_lat/3600000.;
! 3986: lon = instance->ss_long/3600000.;
! 3987: ht = instance->ss_ht/100;
! 3988: snprintf(Msg, sizeof(Msg),
! 3989: "Surveyed posn: lat %.7f (deg) long %.7f (deg) ht %.2f (m)",
! 3990: lat, lon, ht);
! 3991: oncore_log(instance, LOG_NOTICE, Msg);
! 3992:
! 3993: oncore_set_posn(instance);
! 3994:
! 3995: oncore_log(instance, LOG_INFO, "Now in 0D mode");
! 3996:
! 3997: oncore_log(instance, LOG_NOTICE, "SSstate = ONCORE_SS_DONE");
! 3998: instance->site_survey = ONCORE_SS_DONE;
! 3999: }
! 4000: }
! 4001:
! 4002:
! 4003:
! 4004: static int
! 4005: oncore_wait_almanac(
! 4006: struct instance *instance
! 4007: )
! 4008: {
! 4009: if (instance->rsm.bad_almanac) {
! 4010: instance->counta++;
! 4011: if (instance->counta%5 == 0)
! 4012: oncore_log(instance, LOG_INFO, "Waiting for Almanac");
! 4013:
! 4014: /*
! 4015: * If we get here (first time) then we don't have an almanac in memory.
! 4016: * Check if we have a SHMEM, and if so try to load whatever is there.
! 4017: */
! 4018:
! 4019: if (!instance->almanac_from_shmem) {
! 4020: instance->almanac_from_shmem = 1;
! 4021: oncore_load_almanac(instance);
! 4022: }
! 4023: return(1);
! 4024: } else { /* Here we have the Almanac, we will be starting the @@Bn/@@En/@@Hn
! 4025: commands, and can finally check for TRAIM. Again, we set a delay
! 4026: (5sec) and wait for things to settle down */
! 4027:
! 4028: if (instance->chan == 6)
! 4029: oncore_sendmsg(instance, oncore_cmd_Bn, sizeof(oncore_cmd_Bn));
! 4030: else if (instance->chan == 8)
! 4031: oncore_sendmsg(instance, oncore_cmd_En, sizeof(oncore_cmd_En));
! 4032: else if (instance->chan == 12) {
! 4033: oncore_sendmsg(instance, oncore_cmd_Gc, sizeof(oncore_cmd_Gc)); /* 1PPS on, continuous */
! 4034: oncore_sendmsg(instance, oncore_cmd_Ge, sizeof(oncore_cmd_Ge)); /* TRAIM on */
! 4035: oncore_sendmsg(instance, oncore_cmd_Hn, sizeof(oncore_cmd_Hn)); /* TRAIM status 1/s */
! 4036: }
! 4037: instance->traim_delay = 1;
! 4038:
! 4039: oncore_log(instance, LOG_NOTICE, "Have now loaded an ALMANAC");
! 4040:
! 4041: instance->o_state = ONCORE_RUN;
! 4042: oncore_log(instance, LOG_NOTICE, "state = ONCORE_RUN");
! 4043: }
! 4044: return(0);
! 4045: }
! 4046:
! 4047:
! 4048:
! 4049: static void
! 4050: oncore_log (
! 4051: struct instance *instance,
! 4052: int log_level,
! 4053: const char *msg
! 4054: )
! 4055: {
! 4056: int i;
! 4057: char Msg[200];
! 4058:
! 4059: snprintf(Msg, sizeof(Msg), "ONCORE[%d]: %s", instance->unit,
! 4060: msg);
! 4061: syslog(log_level, Msg);
! 4062:
! 4063: i = strlen(msg);
! 4064:
! 4065: if (i > 127) {
! 4066: snprintf(Msg, sizeof(Msg),
! 4067: "Internal Error: max error msg length exceeded in clockstats file (%d)",
! 4068: i);
! 4069: record_clock_stats(&(instance->peer->srcadr), Msg);
! 4070: record_clock_stats(&(instance->peer->srcadr), "Start of message was");
! 4071: strncpy(Msg, msg, 120);
! 4072: record_clock_stats(&(instance->peer->srcadr), Msg);
! 4073: } else { /* now put ONCORE[n]: ahead of message if it will fit */
! 4074: if (i < 110) {
! 4075: snprintf(Msg, sizeof(Msg), "ONCORE[%d]: %s",
! 4076: instance->unit, msg);
! 4077: record_clock_stats(&(instance->peer->srcadr), Msg);
! 4078: } else
! 4079: record_clock_stats(&(instance->peer->srcadr), msg);
! 4080: }
! 4081:
! 4082: #ifdef ONCORE_VERBOSE_ONCORE_LOG
! 4083: instance->max_len = max(i, instance->max_len);
! 4084: instance->max_count++;
! 4085: if (instance->max_count % 100 == 0) {
! 4086: snprintf(Msg, sizeof(Msg),
! 4087: "Max Message Length so far is %d",
! 4088: instance->max_len);
! 4089: oncore_log(instance, LOG_INFO, Msg);
! 4090: }
! 4091: #endif
! 4092: }
! 4093:
! 4094: #else
! 4095: int refclock_oncore_bs;
! 4096: #endif /* REFCLOCK && CLOCK_ONCORE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_oncore.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd