static void display_nav_svinfo(unsigned char *buf, size_t data_len)
{
int i, nchan;
if (data_len < 152)
return;
nchan = (int)getub(buf, 4);
if (nchan > 16)
nchan = 16;
for (i = 0; i < nchan; i++) {
int off = 8 + 12 * i;
unsigned char ss, prn;
char el;
short az;
unsigned short fl;
prn = (unsigned char)getub(buf, off + 1);
fl = (unsigned short)getleu16(buf, off + 2);
ss = (unsigned char)getub(buf, off + 4);
el = (char)getsb(buf, off + 5);
az = (short)getles16(buf, off + 6);
(void)wmove(satwin, (int)(i + 2), 4);
(void)wprintw(satwin, "%3d %3d %3d %2d %04x %c",
prn, az, el, ss, fl, (fl & UBX_SAT_USED) ? 'Y' : ' ');
}
(void)wnoutrefresh(satwin);
return;
}
static void ledumpall(void)
{
(void)printf("getsb: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
(uint64_t) sb1, (uint64_t) sb2,
(uint64_t) getsb(buf, 0), (uint64_t) getsb(buf, 8));
(void)printf("getub: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
(uint64_t) ub1, (uint64_t) ub2,
(uint64_t) getub(buf, 0), (uint64_t) getub(buf, 8));
(void)printf("getles16: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
(uint64_t) sw1, (uint64_t) sw2,
(uint64_t) getles16(buf, 0), (uint64_t) getles16(buf, 8));
(void)printf("getleu16: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
(uint64_t) uw1, (uint64_t) uw2,
(uint64_t) getleu16(buf, 0), (uint64_t) getleu16(buf, 8));
(void)printf("getles32: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
(uint64_t) sl1, (uint64_t) sl2,
(uint64_t) getles32(buf, 0), (uint64_t) getles32(buf, 8));
(void)printf("getleu32: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
(uint64_t) ul1, (uint64_t) ul2,
(uint64_t) getleu32(buf, 0), (uint64_t) getleu32(buf, 8));
(void)printf("getles64: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
(uint64_t) sL1, (uint64_t) sL2,
(uint64_t) getles64(buf, 0), (uint64_t) getles64(buf, 8));
(void)printf("getleu64: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
(uint64_t) uL1, (uint64_t) uL2,
(uint64_t) getleu64(buf, 0), (uint64_t) getleu64(buf, 8));
(void)printf("getlef32: %f %f\n", f1, getlef32((const char *)buf, 24));
(void)printf("getled64: %.16f %.16f\n", d1, getled64((const char *)buf, 16));
}
/*
* pretend to decode MID 0xE3, Beiduo D2 Subframe data
*
* from Beidou Standard BDS-SIS-ICD-2.0
* D2, with the data rate of 500 bps, is broadcasted by the GEO satellites.
*
* len 31 bytes
*
*/
static gps_mask_t sky_msg_E3(struct gps_device_t *session,
unsigned char *buf, size_t len)
{
int i;
unsigned int prn; /* BeidouPS sat PRN 201-205 */
unsigned int subf; /* subframe 1-5 */
/* the words are preprocessed, not raw, just the 28 bytes of data */
uint8_t bytes[28]; /* raw data */
if ( 31 != len)
return 0;
prn = (unsigned int)getub(buf, 1);
subf = (unsigned int)getub(buf, 2);
for ( i = 0; i < 28; i++ ) {
bytes[i] = getub(buf, 3 + i);
}
/* extra guard prevents expensive hexdump calls */
if (session->context->errout.debug >= LOG_PROG) {
gpsd_log(&session->context->errout, LOG_PROG,
"Skytraq: Beidou D2 subframe PRN %d Subframe %d "
"length %zd byte:%s\n",
prn, subf,
len,
gpsd_hexdump(session->msgbuf, sizeof(session->msgbuf),
(char *)bytes, 28));
}
return ONLINE_SET;
}
/*
* decode MID 0xDD, Raw Measurements
*
*/
static gps_mask_t sky_msg_DD(struct gps_device_t *session,
unsigned char *buf, size_t len UNUSED)
{
unsigned int iod; /* Issue of data 0 - 255 */
unsigned int nmeas; /* number of measurements */
iod = (unsigned int)getub(buf, 1);
nmeas = (unsigned int)getub(buf, 2);
gpsd_log(&session->context->errout, LOG_DATA,
"Skytraq: MID 0xDD: iod=%u, nmeas=%u\n",
iod, nmeas);
return 0;
}
/*
* decode MID 0xDC, Measurement Time
*
* 10 bytes
*/
static gps_mask_t sky_msg_DC(struct gps_device_t *session,
unsigned char *buf, size_t len)
{
unsigned int iod; /* Issue of data 0 - 255 */
unsigned int wn; /* week number 0 - 65535 */
unsigned int tow; /* receiver tow 0 - 604799999 in mS */
unsigned int mp; /* measurement period 1 - 1000 ms */
/* calculated */
double f_tow; /* tow in seconds */
unsigned int msec; /* mSec part of tow */
if ( 10 != len)
return 0;
iod = (unsigned int)getub(buf, 1);
wn = getbeu16(buf, 2);
tow = getbeu32(buf, 4);
f_tow = (double)(tow / 1000);
msec = tow % 1000;
mp = getbeu16(buf, 8);
/* should this be newdata.skyview_time? */
session->gpsdata.skyview_time = gpsd_gpstime_resolve(session, wn, f_tow );
gpsd_log(&session->context->errout, LOG_DATA,
"Skytraq: MID 0xDC: iod=%u, wn=%u, tow=%u, mp=%u, t=%lld.%03u\n",
iod, wn, tow, mp,
(long long)session->gpsdata.skyview_time, msec);
return 0;
}
static void display_superstar2_svinfo(unsigned char *buf, size_t data_len)
{
int i;
if (data_len != 67)
return;
for (i = 0; i < 12; i++) {
/* get info for one channel/satellite */
int off = i * 5 + 5;
unsigned char fl, p**n, ss;
char el;
unsigned short az;
if ((p**n = (unsigned char)getub(buf, off) & 0x1f) == 0)
p**n = ((unsigned char)getub(buf, off + 3) >> 1) + 87;
ss = (unsigned char)getub(buf, off + 4);
el = (char)getsb(buf, off + 1);
az = (unsigned short)(getub(buf, off + 2) +
((getub(buf, off + 3) & 0x1) << 1));
fl = (unsigned char)getub(buf, off) & 0xe0;
(void)wmove(satwin, i + 2, 4);
(void)wprintw(satwin, "%3u %3d %2d %02d %02x %c",
p**n, az, el, ss, fl,
((fl & 0x60) == 0x60) ? 'Y' : ' ');
}
(void)wnoutrefresh(satwin);
return;
}
/**
* GPS Satellite Info
*/
static gps_mask_t
oncore_msg_svinfo(struct gps_device_t *session, unsigned char *buf,
size_t data_len)
{
unsigned int i, nchan;
int j;
if (data_len != 92)
return 0;
gpsd_log(&session->context->errout, LOG_DATA,
"oncore SVINFO - satellite data\n");
nchan = (unsigned int)getub(buf, 4);
gpsd_log(&session->context->errout, LOG_DATA,
"oncore SVINFO - %d satellites:\n", nchan);
/* Then we clamp the value to not read outside the table. */
if (nchan > 12)
nchan = 12;
session->driver.oncore.visible = (int)nchan;
for (i = 0; i < nchan; i++) {
/* get info for one channel/satellite */
unsigned int off = 5 + 7 * i;
int sv = (int)getub(buf, off);
int el = (int)getub(buf, off + 3);
int az = (int)getbeu16(buf, off + 4);
gpsd_log(&session->context->errout, LOG_DATA,
"%2d %2d %2d %3d\n", i, sv, el, az);
/* Store for use when Ea messages come. */
session->driver.oncore.PRN[i] = sv;
session->driver.oncore.elevation[i] = el;
session->driver.oncore.azimuth[i] = az;
/* If it has an entry in the satellite list, update it! */
for (j = 0; j < session->gpsdata.satellites_visible; j++)
if (session->gpsdata.skyview[j].PRN == (short)sv) {
session->gpsdata.skyview[j].elevation = (short)el;
session->gpsdata.skyview[j].azimuth = (short)az;
}
}
gpsd_log(&session->context->errout, LOG_DATA,
"SVINFO: mask={SATELLITE}\n");
return SATELLITE_SET;
}
/*
* decode MID 0xE0, GPS Subframe data
*
* len 33 bytes
*
*/
static gps_mask_t sky_msg_E0(struct gps_device_t *session,
unsigned char *buf, size_t len UNUSED)
{
int i;
unsigned int prn; /* GPS sat PRN */
unsigned int subf; /* subframe 1-5 */
/* the words are preprocessed, not raw, just the 24bits of data */
uint32_t words[10]; /* subframe 1-5 */
if ( 33 != len)
return 0;
prn = (unsigned int)getub(buf, 1);
subf = (unsigned int)getub(buf, 2);
for ( i = 0; i < 10; i++ ) {
words[i] = (uint32_t)getbeu24(buf, 3 + (i * 3));
}
gpsd_log(&session->context->errout, LOG_DATA,
"Skytraq: 50B MID 0xE0: prn=%u, subf=%u\n",
prn, subf);
return gpsd_interpret_subframe(session, prn, words);
}
/**
* GPS Leap Seconds = UTC offset
*/
static gps_mask_t
oncore_msg_utc_offset(struct gps_device_t *session, unsigned char *buf,
size_t data_len)
{
int utc_offset;
if (data_len != 8)
return 0;
gpsd_log(&session->context->errout, LOG_DATA,
"oncore UTCTIME - leap seconds\n");
utc_offset = (int)getub(buf, 4);
if (utc_offset == 0)
return 0; /* that part of almanac not received yet */
session->context->leap_seconds = utc_offset;
session->context->valid |= LEAP_SECOND_VALID;
return 0; /* no flag for leap seconds update */
}
static void italk_update(void)
{
unsigned char *buf;
size_t len;
unsigned char type;
buf = session.packet.outbuffer;
len = session.packet.outbuflen;
type = (unsigned char)getub(buf, 4);
switch (type) {
case ITALK_NAV_FIX:
display_itk_navfix(buf, len);
break;
case ITALK_PRN_STATUS:
display_itk_prnstatus(buf, len);
break;
default:
break;
}
}
/*
* decode MID 0x*), Software Version
*
* 10 bytes
*/
static gps_mask_t sky_msg_80(struct gps_device_t *session,
unsigned char *buf, size_t len)
{
unsigned int kver_x; /* kernel version */
unsigned int kver_y; /* kernel version */
unsigned int kver_z; /* kernel version */
unsigned int over_x; /* ODM version */
unsigned int over_y; /* ODM version */
unsigned int over_z; /* ODM version */
unsigned int rev_yy; /* revision */
unsigned int rev_mm; /* revision */
unsigned int rev_dd; /* revision */
if ( 14 != len)
return 0;
kver_x = getbeu16(buf, 2);
kver_y = getub(buf, 4);
kver_z = getub(buf, 5);
over_x = getbeu16(buf, 6);
over_y = getub(buf, 8);
over_z = getub(buf, 9);
rev_yy = getbeu16(buf, 10);
rev_mm = getub(buf, 12);
rev_dd = getub(buf, 13);
(void)snprintf(session->subtype, sizeof(session->subtype) - 1,
"Skytraq: kver=%u.%u,%u, over=%u.%u,%u, rev=%u.%u.%u",
kver_x, kver_y, kver_z,
over_x, over_y, over_z,
rev_yy, rev_mm, rev_dd);
gpsd_log(&session->context->errout, LOG_DATA,
"Skytraq: MID 0x80: kver=%u.%u,%u, over=%u.%u,%u, rev=%u.%u.%u\n",
kver_x, kver_y, kver_z,
over_x, over_y, over_z,
rev_yy, rev_mm, rev_dd);
return 0;
}
/*@ +charint @*/
static gps_mask_t italk_parse(struct gps_device_t *session,
unsigned char *buf, size_t len)
{
unsigned int type;
gps_mask_t mask = 0;
if (len == 0)
return 0;
type = (uint) getub(buf, 4);
/* we may need to dump the raw packet */
gpsd_report(LOG_RAW, "raw italk packet type 0x%02x\n", type);
session->cycle_end_reliable = true;
switch (type) {
case ITALK_NAV_FIX:
gpsd_report(LOG_IO, "iTalk NAV_FIX len %zu\n", len);
mask = decode_itk_navfix(session, buf, len) | (CLEAR_IS | REPORT_IS);
break;
case ITALK_PRN_STATUS:
gpsd_report(LOG_IO, "iTalk PRN_STATUS len %zu\n", len);
mask = decode_itk_prnstatus(session, buf, len);
break;
case ITALK_UTC_IONO_MODEL:
gpsd_report(LOG_IO, "iTalk UTC_IONO_MODEL len %zu\n", len);
mask = decode_itk_utcionomodel(session, buf, len);
break;
case ITALK_ACQ_DATA:
gpsd_report(LOG_IO, "iTalk ACQ_DATA len %zu\n", len);
break;
case ITALK_TRACK:
gpsd_report(LOG_IO, "iTalk TRACK len %zu\n", len);
break;
case ITALK_PSEUDO:
gpsd_report(LOG_IO, "iTalk PSEUDO len %zu\n", len);
mask = decode_itk_pseudo(session, buf, len);
break;
case ITALK_RAW_ALMANAC:
gpsd_report(LOG_IO, "iTalk RAW_ALMANAC len %zu\n", len);
break;
case ITALK_RAW_EPHEMERIS:
gpsd_report(LOG_IO, "iTalk RAW_EPHEMERIS len %zu\n", len);
break;
case ITALK_SUBFRAME:
mask = decode_itk_subframe(session, buf, len);
break;
case ITALK_BIT_STREAM:
gpsd_report(LOG_IO, "iTalk BIT_STREAM len %zu\n", len);
break;
case ITALK_AGC:
case ITALK_SV_HEALTH:
case ITALK_PRN_PRED:
case ITALK_FREQ_PRED:
case ITALK_DBGTRACE:
case ITALK_START:
case ITALK_STOP:
case ITALK_SLEEP:
case ITALK_STATUS:
case ITALK_ITALK_CONF:
case ITALK_SYSINFO:
case ITALK_ITALK_TASK_ROUTE:
case ITALK_PARAM_CTRL:
case ITALK_PARAMS_CHANGED:
case ITALK_START_COMPLETED:
case ITALK_STOP_COMPLETED:
case ITALK_LOG_CMD:
case ITALK_SYSTEM_START:
case ITALK_STOP_SEARCH:
case ITALK_SEARCH:
case ITALK_PRED_SEARCH:
case ITALK_SEARCH_DONE:
case ITALK_TRACK_DROP:
case ITALK_TRACK_STATUS:
case ITALK_HANDOVER_DATA:
case ITALK_CORE_SYNC:
case ITALK_WAAS_RAWDATA:
case ITALK_ASSISTANCE:
case ITALK_PULL_FIX:
case ITALK_MEMCTRL:
case ITALK_STOP_TASK:
gpsd_report(LOG_IO,
"iTalk not processing packet: id 0x%02x length %zu\n",
type, len);
break;
default:
gpsd_report(LOG_IO, "iTalk unknown packet: id 0x%02x length %zu\n",
type, len);
}
(void)snprintf(session->gpsdata.tag, sizeof(session->gpsdata.tag),
"ITK-%02x", type);
return mask | ONLINE_SET;
}
/*
* Decode the navigation solution message
*/
static gps_mask_t
oncore_msg_navsol(struct gps_device_t *session, unsigned char *buf,
size_t data_len)
{
gps_mask_t mask;
unsigned char flags;
double lat, lon, alt;
float speed, track, dop;
unsigned int i, j, st, nsv;
int Bbused;
struct tm unpacked_date;
if (data_len != 76)
return 0;
mask = ONLINE_SET;
gpsd_log(&session->context->errout, LOG_DATA,
"oncore NAVSOL - navigation data\n");
flags = (unsigned char)getub(buf, 72);
/*@ -predboolothers @*/
if (flags & 0x20) {
session->gpsdata.status = STATUS_FIX;
session->newdata.mode = MODE_3D;
} else if (flags & 0x10) {
session->gpsdata.status = STATUS_FIX;
session->newdata.mode = MODE_2D;
} else {
gpsd_log(&session->context->errout, LOG_WARN,
"oncore NAVSOL no fix - flags 0x%02x\n", flags);
session->newdata.mode = MODE_NO_FIX;
session->gpsdata.status = STATUS_NO_FIX;
}
mask |= MODE_SET;
/*@ +predboolothers @*/
/* Unless we have seen non-zero utc offset data, the time is GPS time
* and not UTC time. Do not use it.
*/
if (session->context->leap_seconds) {
unsigned int nsec;
unpacked_date.tm_mon = (int)getub(buf, 4) - 1;
unpacked_date.tm_mday = (int)getub(buf, 5);
unpacked_date.tm_year = (int)getbeu16(buf, 6) - 1900;
unpacked_date.tm_hour = (int)getub(buf, 8);
unpacked_date.tm_min = (int)getub(buf, 9);
unpacked_date.tm_sec = (int)getub(buf, 10);
unpacked_date.tm_isdst = 0;
#ifdef S_SPLINT_S
unpacked_date.tm_wday = unpacked_date.tm_yday = 0;
#endif /* S_SPLINT_S */
nsec = (uint) getbeu32(buf, 11);
/*@ -unrecog */
session->newdata.time = (timestamp_t)mkgmtime(&unpacked_date) + nsec * 1e-9;
/*@ +unrecog */
mask |= TIME_SET;
gpsd_log(&session->context->errout, LOG_DATA,
"oncore NAVSOL - time: %04d-%02d-%02d %02d:%02d:%02d.%09d\n",
unpacked_date.tm_year + 1900, unpacked_date.tm_mon + 1,
unpacked_date.tm_mday, unpacked_date.tm_hour,
unpacked_date.tm_min, unpacked_date.tm_sec, nsec);
}
/*@-type@*/
lat = getbes32(buf, 15) / 3600000.0f;
lon = getbes32(buf, 19) / 3600000.0f;
alt = getbes32(buf, 23) / 100.0f;
speed = getbeu16(buf, 31) / 100.0f;
track = getbeu16(buf, 33) / 10.0f;
dop = getbeu16(buf, 35) / 10.0f;
/*@+type@*/
gpsd_log(&session->context->errout, LOG_DATA,
"oncore NAVSOL - %lf %lf %.2lfm-%.2lfm | %.2fm/s %.1fdeg dop=%.1f\n",
lat, lon, alt, wgs84_separation(lat, lon), speed, track,
(float)dop);
session->newdata.latitude = lat;
session->newdata.longitude = lon;
session->gpsdata.separation =
wgs84_separation(session->newdata.latitude,
session->newdata.longitude);
session->newdata.altitude = alt - session->gpsdata.separation;
session->newdata.speed = speed;
session->newdata.track = track;
mask |= LATLON_SET | ALTITUDE_SET | SPEED_SET | TRACK_SET;
gpsd_zero_satellites(&session->gpsdata);
/* Merge the satellite information from the Bb message. */
Bbused = 0;
nsv = 0;
for (i = st = 0; i < 8; i++) {
int sv, mode, sn, status;
unsigned int off;
off = 40 + 4 * i;
sv = (int)getub(buf, off);
mode = (int)getub(buf, off + 1);
sn = (int)getub(buf, off + 2);
status = (int)getub(buf, off + 3);
gpsd_log(&session->context->errout, LOG_DATA,
"%2d %2d %2d %3d %02x\n", i, sv, mode, sn, status);
if (sn) {
session->gpsdata.skyview[st].PRN = (short)sv;
session->gpsdata.skyview[st].ss = (double)sn;
for (j = 0; (int)j < session->driver.oncore.visible; j++)
if (session->driver.oncore.PRN[j] == sv) {
session->gpsdata.skyview[st].elevation =
(short)session->driver.oncore.elevation[j];
session->gpsdata.skyview[st].azimuth =
(short)session->driver.oncore.azimuth[j];
Bbused |= 1 << j;
break;
}
/* bit 7 of the status word: sat used for position */
session->gpsdata.skyview[st].used = false;
if (status & 0x80) {
session->gpsdata.skyview[st].used = true;
nsv++;
}
/* bit 2 of the status word: using for time solution */
if (status & 0x02)
mask |= PPSTIME_IS;
/*
* The PPSTIME_IS mask bit exists distinctly from TIME_SET exactly
* so an OnCore running in time-service mode (and other GPS clocks)
* can signal that it's returning time even though no position fixes
* have been available.
*/
st++;
}
}
for (j = 0; (int)j < session->driver.oncore.visible; j++)
/*@ -boolops @*/
if (!(Bbused & (1 << j))) {
session->gpsdata.skyview[st].PRN = (short)session->driver.oncore.PRN[j];
session->gpsdata.skyview[st].elevation =
(short)session->driver.oncore.elevation[j];
session->gpsdata.skyview[st].azimuth =
(short)session->driver.oncore.azimuth[j];
st++;
}
/*@ +boolops @*/
session->gpsdata.skyview_time = session->newdata.time;
session->gpsdata.satellites_used = (int)nsv;
session->gpsdata.satellites_visible = (int)st;
mask |= SATELLITE_SET | USED_IS;
/* Some messages can only be polled. As they are not so
* important, would be enough to poll e.g. one message per cycle.
*/
(void)oncore_control_send(session, (char *)pollAs, sizeof(pollAs));
(void)oncore_control_send(session, (char *)pollAt, sizeof(pollAt));
(void)oncore_control_send(session, (char *)pollAy, sizeof(pollAy));
(void)oncore_control_send(session, (char *)pollBo, sizeof(pollBo));
(void)oncore_control_send(session, (char *)pollEn, sizeof(pollEn));
gpsd_log(&session->context->errout, LOG_DATA,
"NAVSOL: time=%.2f lat=%.2f lon=%.2f alt=%.2f speed=%.2f track=%.2f mode=%d status=%d visible=%d used=%d\n",
session->newdata.time, session->newdata.latitude,
session->newdata.longitude, session->newdata.altitude,
session->newdata.speed, session->newdata.track,
session->newdata.mode, session->gpsdata.status,
session->gpsdata.satellites_used,
session->gpsdata.satellites_visible);
return mask;
}
/*@ +charint @*/
gps_mask_t evermore_parse(struct gps_device_t *session, unsigned char *buf, size_t len)
{
unsigned char buf2[MAX_PACKET_LENGTH], *cp, *tp;
size_t i, datalen;
unsigned int used, visible, satcnt;
double version;
gps_mask_t mask = 0;
if (len == 0)
return 0;
/* time to unstuff it and discard the header and footer */
cp = buf + 2;
tp = buf2;
if (*cp == 0x10) cp++;
datalen = (size_t)*cp++;
gpsd_report(LOG_RAW, "raw EverMore packet type 0x%02x, length %d: %s\n", *cp, len, gpsd_hexdump(buf, len));
datalen -= 2;
for (i = 0; i < (size_t)datalen; i++) {
*tp = *cp++;
if (*tp == 0x10) cp++;
tp++;
}
/*@ -usedef -compdef @*/
gpsd_report(LOG_RAW, "EverMore packet type 0x%02x, length %d: %s\n", buf2[0], datalen, gpsd_hexdump(buf2, datalen));
/*@ +usedef +compdef @*/
(void)snprintf(session->gpsdata.tag, sizeof(session->gpsdata.tag),
"EID%d",(int)buf2[0]);
switch (getub(buf2, 1))
{
case 0x02: /* Navigation Data Output */
session->gpsdata.fix.time = session->gpsdata.sentence_time
= gpstime_to_unix((int)getuw(buf2, 2), getul(buf2, 4)*0.01) - session->context->leap_seconds;
ecef_to_wgs84fix(&session->gpsdata,
getsl(buf2, 8)*1.0, getsl(buf2, 12)*1.0, getsl(buf2, 16)*1.0,
getsw(buf2, 20)/10.0, getsw(buf2, 22)/10.0, getsw(buf2, 24)/10.0);
used = getub(buf2, 26) & 0x0f;
visible = (getub(buf2, 26) & 0xf0) >> 4;
version = getuw(buf2, 27)/100.0;
/* that's all the information in this packet */
if (used < 3)
session->gpsdata.fix.mode = MODE_NO_FIX;
else if (used == 3)
session->gpsdata.fix.mode = MODE_2D;
else {
session->gpsdata.fix.mode = MODE_3D;
mask |= ALTITUDE_SET | CLIMB_SET;
}
gpsd_report(LOG_PROG, "NDO 0x02: version %3.2f, mode=%d, status=%d, visible=%d, used=%d\n",
version,
session->gpsdata.fix.mode,
session->gpsdata.status,
visible,
used);
mask |= TIME_SET | LATLON_SET | TRACK_SET | SPEED_SET | MODE_SET | CYCLE_START_SET;
if (session->subtype[0] == '\0') {
(void)snprintf(session->subtype, sizeof(session->subtype),
"%3.2f", version);
mask |= DEVICEID_SET;
}
return mask;
case 0x04: /* DOP Data Output */
session->gpsdata.fix.time = session->gpsdata.sentence_time
= gpstime_to_unix((int)getuw(buf2, 2), getul(buf2, 4)*0.01) - session->context->leap_seconds;
session->gpsdata.gdop = (double)getub(buf2, 8)*0.1;
session->gpsdata.pdop = (double)getub(buf2, 9)*0.1;
session->gpsdata.hdop = (double)getub(buf2, 10)*0.1;
session->gpsdata.vdop = (double)getub(buf2, 11)*0.1;
session->gpsdata.tdop = (double)getub(buf2, 12)*0.1;
switch (getub(buf2, 13)) {
case 0: /* no position fix */
case 1: /* manual calls this "1D navigation" */
session->gpsdata.status = STATUS_NO_FIX;
session->gpsdata.fix.mode = MODE_NO_FIX;
break;
case 2: /* 2D navigation */
session->gpsdata.status = STATUS_FIX;
session->gpsdata.fix.mode = MODE_2D;
break;
case 3: /* 3D navigation */
session->gpsdata.status = STATUS_FIX;
session->gpsdata.fix.mode = MODE_3D;
break;
case 4: /* 3D navigation with DGPS */
session->gpsdata.status = STATUS_DGPS_FIX;
session->gpsdata.fix.mode = MODE_3D;
break;
}
/* that's all the information in this packet */
gpsd_report(LOG_PROG, "DDO 0x04: mode=%d, status=%d\n",
session->gpsdata.fix.mode,
session->gpsdata.status);
return TIME_SET | DOP_SET | MODE_SET | STATUS_SET;
case 0x06: /* Channel Status Output */
session->gpsdata.fix.time = session->gpsdata.sentence_time
= gpstime_to_unix((int)getuw(buf2, 2), getul(buf2, 4)*0.01) - session->context->leap_seconds;
session->gpsdata.satellites = (int)getub(buf2, 8);
session->gpsdata.satellites_used = 0;
memset(session->gpsdata.used, 0, sizeof(session->gpsdata.used));
if (session->gpsdata.satellites > 12) {
gpsd_report(LOG_WARN, "Warning: EverMore packet has information about %d satellites!\n",
session->gpsdata.satellites);
}
if (session->gpsdata.satellites > EVERMORE_CHANNELS) session->gpsdata.satellites = EVERMORE_CHANNELS;
satcnt = 0;
for (i = 0; i < (size_t)session->gpsdata.satellites; i++) {
int prn;
// channel = getub(buf2, 7*i+7+2)
prn = (int)getub(buf2, 7*i+7+3);
if (prn == 0) continue; /* satellite record is not valid */
session->gpsdata.PRN[satcnt] = prn;
session->gpsdata.azimuth[satcnt] = (int)getuw(buf2, 7*i+7+4);
session->gpsdata.elevation[satcnt] = (int)getub(buf2, 7*i+7+6);
session->gpsdata.ss[satcnt] = (int)getub(buf2, 7*i+7+7);
/*
* Status bits at offset 8:
* bit0 = 1 satellite acquired
* bit1 = 1 code-tracking loop locked
* bit2 = 1 carrier-tracking loop locked
* bit3 = 1 data-bit synchronization done
* bit4 = 1 frame synchronization done
* bit5 = 1 ephemeris data collected
* bit6 = 1 used for position fix
*/
if (getub(buf2, 7*i+7+8) & 0x40) {
session->gpsdata.used[session->gpsdata.satellites_used++]=prn;
}
satcnt++;
}
session->gpsdata.satellites = (int)satcnt;
/* that's all the information in this packet */
gpsd_report(LOG_PROG, "CSO 0x04: %d satellites used\n",
session->gpsdata.satellites_used);
return TIME_SET | SATELLITE_SET | USED_SET;
case 0x08: /* Measurement Data Output */
/* clock offset is a manufacturer diagnostic */
/* (int)getuw(buf2, 8); clock offset, 29000..29850 ?? */
session->gpsdata.fix.time = session->gpsdata.sentence_time
= gpstime_to_unix((int)getuw(buf2, 2), getul(buf2, 4)*0.01) - session->context->leap_seconds;
visible = getub(buf2, 10);
/* FIXME: read full statellite status for each channel */
/* we can get pseudo range (m), delta-range (m/s), doppler (Hz) and status for each channel */
/* gpsd_report(LOG_PROG, "MDO 0x04: visible=%d\n", visible); */
gpsd_report(LOG_PROG, "MDO 0x04:\n");
return TIME_SET;
case 0x20: /* LogConfig Info, could be used as a probe for EverMore GPS */
gpsd_report(LOG_IO, "LogConfig EverMore packet, length %d: %s\n", datalen, gpsd_hexdump(buf2, datalen));
return ONLINE_SET;
case 0x22: /* LogData */
gpsd_report(LOG_IO, "LogData EverMore packet, length %d: %s\n", datalen, gpsd_hexdump(buf2, datalen));
return ONLINE_SET;
case 0x38: /* ACK */
gpsd_report(LOG_PROG, "EverMore command %02X ACK\n", getub(buf2, 2));
return ONLINE_SET;
default:
gpsd_report(LOG_WARN, "unknown EverMore packet id 0x%02x, length %d: %s\n", buf2[0], datalen, gpsd_hexdump(buf2, datalen));
return 0;
}
}
static void display_nav_sol(unsigned char *buf, size_t data_len)
{
unsigned short gw = 0;
unsigned int tow = 0, flags;
double epx, epy, epz, evx, evy, evz;
unsigned char navmode;
struct gps_data_t g;
double separation;
if (data_len != 52)
return;
navmode = (unsigned char)getub(buf, 10);
flags = (unsigned int)getub(buf, 11);
if ((flags & (UBX_SOL_VALID_WEEK | UBX_SOL_VALID_TIME)) != 0) {
tow = (unsigned int)getleu32(buf, 0);
gw = (unsigned short)getles16(buf, 8);
}
epx = (double)(getles32(buf, 12) / 100.0);
epy = (double)(getles32(buf, 16) / 100.0);
epz = (double)(getles32(buf, 20) / 100.0);
evx = (double)(getles32(buf, 28) / 100.0);
evy = (double)(getles32(buf, 32) / 100.0);
evz = (double)(getles32(buf, 36) / 100.0);
ecef_to_wgs84fix(&g.fix, &separation, epx, epy, epz, evx, evy, evz);
g.fix.epx = g.fix.epy = (double)(getles32(buf, 24) / 100.0);
g.fix.eps = (double)(getles32(buf, 40) / 100.0);
g.dop.pdop = (double)(getleu16(buf, 44) / 100.0);
g.satellites_used = (int)getub(buf, 47);
(void)wmove(navsolwin, 1, 11);
(void)wprintw(navsolwin, "%+10.2fm %+10.2fm %+10.2fm", epx, epy, epz);
(void)wmove(navsolwin, 2, 11);
(void)wprintw(navsolwin, "%+9.2fm/s %+9.2fm/s %+9.2fm/s", evx, evy, evz);
(void)wmove(navsolwin, 4, 11);
(void)wattrset(navsolwin, A_UNDERLINE);
(void)wprintw(navsolwin, "%12.9f %13.9f %8.2fm",
g.fix.latitude, g.fix.longitude, g.fix.altitude);
(void)mvwaddch(navsolwin, 4, 23, ACS_DEGREE);
(void)mvwaddch(navsolwin, 4, 38, ACS_DEGREE);
(void)wmove(navsolwin, 5, 11);
(void)wprintw(navsolwin, "%6.2fm/s %5.1fo %6.2fm/s",
g.fix.speed, g.fix.track, g.fix.climb);
(void)mvwaddch(navsolwin, 5, 26, ACS_DEGREE);
(void)wattrset(navsolwin, A_NORMAL);
(void)wmove(navsolwin, 7, 7);
{
unsigned int day = tow / 8640000;
unsigned int tod = tow % 8640000;
unsigned int h = tod / 360000;
unsigned int m = tod % 360000;
unsigned int s = m % 6000;
m = (m - s) / 6000;
(void)wattrset(navsolwin, A_UNDERLINE);
(void)wprintw(navsolwin, "%u %02u:%02u:%05.2f", day, h, m, (double)s / 100);
(void)wattrset(navsolwin, A_NORMAL);
}
(void)wmove(navsolwin, 8, 11);
if ((flags & (UBX_SOL_VALID_WEEK | UBX_SOL_VALID_TIME)) != 0) {
(void)wprintw(navsolwin, "%d+%10.3lf", gw, (double)(tow / 1000.0));
(void)wmove(navsolwin, 8, 36);
(void)wprintw(navsolwin, "%d", (tow / 86400000));
}
/* relies on the fact that epx and epy are set to same value */
(void)wmove(navsolwin, 10, 12);
(void)wprintw(navsolwin, "%7.2f", g.fix.epx);
(void)wmove(navsolwin, 10, 33);
(void)wprintw(navsolwin, "%6.2f", g.fix.epv);
(void)wmove(navsolwin, 11, 7);
(void)wprintw(navsolwin, "%2d", g.satellites_used);
(void)wmove(navsolwin, 11, 15);
(void)wprintw(navsolwin, "%5.1f", g.dop.pdop);
(void)wmove(navsolwin, 11, 25);
(void)wprintw(navsolwin, "0x%02x", navmode);
(void)wmove(navsolwin, 11, 36);
(void)wprintw(navsolwin, "0x%02x", flags);
(void)wnoutrefresh(navsolwin);
}
/*@ -duplicatequals +ignorequals @*/
int main(int argc, char *argv[])
{
bool failures = false;
bool quiet = (argc > 1) && (strcmp(argv[1], "--quiet") == 0);
/*@ -observertrans -usereleased @*/
struct unsigned_test *up, unsigned_tests[] = {
/* tests using the big buffer */
{buf, 0, 1, 0, false, "first bit of first byte"},
{buf, 0, 8, 0x01, false, "first 8 bits"},
{buf, 32, 7, 0x02, false, "first seven bits of fifth byte (0x05)"},
{buf, 56, 12, 0x8f, false, "12 bits crossing 7th to 8th bytes (0x08ff)"},
{buf, 78, 4, 0xb, false, "4 bits crossing 8th to 9th byte (0xfefd)"},
{buf, 0, 1, 0, true, "first bit of first byte"},
{buf, 0, 8, 0x80, true, "first 8 bits"},
{buf, 32, 7, 0x20, true, "first seven bits of fifth byte (0x05)"},
{buf, 56, 12, 0xf10,true, "12 bits crossing 7th to 8th bytes (0x08ff)"},
{buf, 78, 4, 0xd, true, "4 bits crossing 8th to 9th byte (0xfefd)"},
/* sporadic tests based on found bugs */
{(unsigned char *)"\x19\x23\f6",
7, 2, 2, false, "2 bits crossing 1st to 2nd byte (0x1923)"},
};
unsigned char *sp;
memcpy(buf, "\x01\x02\x03\x04\x05\x06\x07\x08", 8);
memcpy(buf + 8, "\xff\xfe\xfd\xfc\xfb\xfa\xf9\xf8", 8);
memcpy(buf + 16, "\x40\x09\x21\xfb\x54\x44\x2d\x18", 8);
memcpy(buf + 24, "\x40\x49\x0f\xdb", 4);
/*@ +observertrans +usereleased @*/
/*@-type@*/
sb1 = getsb(buf, 0);
sb2 = getsb(buf, 8);
ub1 = getub(buf, 0);
ub2 = getub(buf, 8);
sw1 = getbes16(buf, 0);
sw2 = getbes16(buf, 8);
uw1 = getbeu16(buf, 0);
uw2 = getbeu16(buf, 8);
sl1 = getbes32(buf, 0);
sl2 = getbes32(buf, 8);
ul1 = getbeu32(buf, 0);
ul2 = getbeu32(buf, 8);
sL1 = getbes64(buf, 0);
sL2 = getbes64(buf, 8);
uL1 = getbeu64(buf, 0);
uL2 = getbeu64(buf, 8);
f1 = getbef32((const char *)buf, 24);
d1 = getbed64((const char *)buf, 16);
sb1 = getsb(buf, 0);
sb2 = getsb(buf, 8);
ub1 = getub(buf, 0);
ub2 = getub(buf, 8);
sw1 = getles16(buf, 0);
sw2 = getles16(buf, 8);
uw1 = getleu16(buf, 0);
uw2 = getleu16(buf, 8);
sl1 = getles32(buf, 0);
sl2 = getles32(buf, 8);
ul1 = getleu32(buf, 0);
ul2 = getleu32(buf, 8);
sL1 = getles64(buf, 0);
sL2 = getles64(buf, 8);
uL1 = getleu64(buf, 0);
uL2 = getleu64(buf, 8);
f1 = getlef32((const char *)buf, 24);
d1 = getled64((const char *)buf, 16);
/*@+type@*/
if (!quiet) {
(void)fputs("Test data:", stdout);
for (sp = buf; sp < buf + 28; sp++)
(void)printf(" %02x", *sp);
(void)putc('\n', stdout);
/* big-endian test */
printf("Big-endian:\n");
bedumpall();
/* little-endian test */
printf("Little-endian:\n");
ledumpall();
}
if (sb1 != 1) printf("getsb(buf, 0) FAILED\n");
if (sb2 != -1) printf("getsb(buf, 8) FAILED\n");
if (ub1 != 1) printf("getub(buf, 0) FAILED\n");
if (ub2 != 0xff) printf("getub(buf, 8) FAILED\n");
(void)printf("Testing bitfield extraction\n");
for (up = unsigned_tests;
up <
unsigned_tests + sizeof(unsigned_tests) / sizeof(unsigned_tests[0]);
up++) {
uint64_t res = ubits((unsigned char *)buf, up->start, up->width, up->le);
bool success = (res == up->expected);
if (!success)
failures = true;
if (!success || !quiet)
(void)printf("ubits(%s, %d, %d, %s) %s should be %" PRIx64 ", is %" PRIx64 ": %s\n",
hexdump(buf, strlen((char *)buf)),
up->start, up->width, up->le ? "true" : "false",
up->description, up->expected, res,
success ? "succeeded" : "FAILED");
}
exit(failures ? EXIT_FAILURE : EXIT_SUCCESS);
}
static void sirf_update(void)
{
int i, j, ch, sv;
unsigned char *buf;
size_t len;
uint8_t dgps;
char tbuf[JSON_DATE_MAX+1];
buf = session.lexer.outbuffer + 4;
len = session.lexer.outbuflen - 8;
switch (buf[0]) {
case 0x02: /* Measured Navigation Data */
(void)wmove(mid2win, 1, 6); /* ECEF position */
(void)wprintw(mid2win, "%8d %8d %8d", getbes32(buf, 1),
getbes32(buf, 5), getbes32(buf, 9));
(void)wmove(mid2win, 2, 6); /* ECEF velocity */
(void)wprintw(mid2win, "%8.1f %8.1f %8.1f",
(double)getbes16(buf, 13) / 8, (double)getbes16(buf,
15) / 8,
(double)getbes16(buf, 17) / 8);
decode_ecef((double)getbes32(buf, 1), (double)getbes32(buf, 5),
(double)getbes32(buf, 9), (double)getbes16(buf, 13) / 8,
(double)getbes16(buf, 15) / 8, (double)getbes16(buf,
17) / 8);
/* line 3 */
(void)wmove(mid2win, 3, 7);
(void)wprintw(mid2win, "%-24s",
unix_to_iso8601(session.gpsdata.fix.time, tbuf, sizeof(tbuf))
);
(void)wmove(mid2win, 3, 38);
(void)wattrset(mid2win, A_UNDERLINE);
if (ppstime_enabled)
(void)wprintw(mid2win, "%02d", leapseconds);
else
(void)wprintw(mid2win, "??");
(void)wattrset(mid2win, A_NORMAL);
/* line 4 */
/* HDOP */
(void)wmove(mid2win, 4, 59);
(void)wprintw(mid2win, "%4.1f", (double)getub(buf, 20) / 5);
/* Mode 1 */
(void)wmove(mid2win, 4, 69);
(void)wprintw(mid2win, "%02x", getub(buf, 19));
/* Mode 2 */
(void)wmove(mid2win, 4, 77);
(void)wprintw(mid2win, "%02x", getub(buf, 21));
/* SVs in fix */
(void)wmove(mid2win, 4, 6);
(void)wprintw(mid2win, "%2d = ",
(int)getub(buf, 28));
/* SV list */
(void)wmove(mid2win, 4, 10);
/* coverity_submit[tainted_data] */
for (i = 0; i < (int)getub(buf, 28); i++)
(void)wprintw(mid2win, " %2d", (int)getub(buf, 29 + i));
monitor_log("MND 0x02=");
break;
case 0x04: /* Measured Tracking Data */
ch = (int)getub(buf, 7);
for (i = 0; i < ch; i++) {
int az, el, state, off;
double cn;
off = 8 + 15 * i;
(void)wmove(mid4win, i + 2, 3);
sv = (int)getub(buf, off);
az = (int)getub(buf, off + 1) * 3 / 2;
el = (int)getub(buf, off + 2) / 2;
state = (int)getbeu16(buf, off + 3);
cn = 0;
for (j = 0; j < 10; j++)
cn += (int)getub(buf, off + 5 + j);
cn /= 10;
(void)wprintw(mid4win, " %3d %3d %2d %04x %4.1f %c",
sv, az, el, state, cn, state == 0xbf ? 'T' : ' ');
}
monitor_log("MTD 0x04=");
break;
#ifdef __UNUSED__
case 0x05: /* raw track data */
for (off = 1; off < len; off += 51) {
ch = getbeu32(buf, off);
(void)wmove(mid4win, ch + 2, 19);
cn = 0;
for (j = 0; j < 10; j++)
cn += getub(buf, off + 34 + j);
printw("%5.1f", (double)cn / 10);
printw("%9d%3d%5d", getbeu32(buf, off + 8),
(int)getbeu16(buf, off + 12), (int)getbeu16(buf, off + 14));
printw("%8.5f %10.5f", (double)getbeu32(buf, off + 16) / 65536,
(double)getbeu32(buf, off + 20) / 1024);
}
monitor_log("RTD 0x05=");
break;
#endif /* __UNUSED */
case 0x06: /* firmware version */
display(mid6win, 1, 1, "%s", buf + 1);
monitor_log("FV 0x06=");
break;
case 0x07: /* Response - Clock Status Data */
display(mid7win, 1, 5, "%2d", getub(buf, 7)); /* SVs */
display(mid7win, 1, 16, "%lu", getbeu32(buf, 8)); /* Clock ppstimes */
display(mid7win, 1, 29, "%lu", getbeu32(buf, 12)); /* Clock Bias */
display(mid7win, 2, 11, "%lu", getbeu32(buf, 16)); /* Estimated Time */
monitor_log("CSD 0x07=");
break;
case 0x08: /* 50 BPS data */
ch = (int)getub(buf, 1);
sv = (int)getub(buf, 2);
display(mid4win, ch + 2, 27, "%2d", sv);
subframe_enabled = true;
monitor_log("50B 0x08=");
break;
case 0x09: /* Throughput */
display(mid9win, 1, 6, "%.3f", (double)getbeu16(buf, 1) / 186); /*SegStatMax */
display(mid9win, 1, 18, "%.3f", (double)getbeu16(buf, 3) / 186); /*SegStatLat */
display(mid9win, 1, 31, "%.3f", (double)getbeu16(buf, 5) / 186); /*SegStatTime */
display(mid9win, 1, 42, "%3d", (int)getbeu16(buf, 7)); /* Last Millisecond */
monitor_log("THR 0x09=");
break;
case 0x0b: /* Command Acknowledgement */
monitor_log("ACK 0x0b=");
break;
case 0x0c: /* Command NAcknowledgement */
monitor_log("NAK 0x0c=");
break;
case 0x0d: /* Visible List */
display(mid13win, 1, 1, "%02d = ",
getub(buf, 1));
(void)wmove(mid13win, 1, 5);
for (i = 0; i < (int)getub(buf, 1); i++)
(void)wprintw(mid13win, " %d", getub(buf, 2 + 5 * i));
monitor_log("VL 0x0d=");
break;
case 0x13:
#define YESNO(n) (((int)getub(buf, n) != 0)?'Y':'N')
display(mid19win, 1, 20, "%d", getub(buf, 5)); /* Alt. hold mode */
display(mid19win, 2, 20, "%d", getub(buf, 6)); /* Alt. hold source */
display(mid19win, 3, 20, "%dm", (int)getbeu16(buf, 7)); /* Alt. source input */
if (getub(buf, 9) != (uint8_t) '\0')
display(mid19win, 4, 20, "%dsec", getub(buf, 10)); /* Degraded timeout */
else
display(mid19win, 4, 20, "N/A ");
display(mid19win, 5, 20, "%dsec", getub(buf, 11)); /* DR timeout */
display(mid19win, 6, 20, "%c", YESNO(12)); /* Track smooth mode */
display(mid19win, 7, 20, "%c", YESNO(13)); /* Static Nav. */
display(mid19win, 8, 20, "0x%x", getub(buf, 14)); /* 3SV Least Squares */
display(mid19win, 9, 20, "0x%x", getub(buf, 19)); /* DOP Mask mode */
display(mid19win, 10, 20, "0x%x", (int)getbeu16(buf, 20)); /* Nav. Elev. mask */
display(mid19win, 11, 20, "0x%x", getub(buf, 22)); /* Nav. Power mask */
display(mid19win, 12, 20, "0x%x", getub(buf, 27)); /* DGPS Source */
display(mid19win, 13, 20, "0x%x", getub(buf, 28)); /* DGPS Mode */
display(mid19win, 14, 20, "%dsec", getub(buf, 29)); /* DGPS Timeout */
display(mid19win, 1, 42, "%c", YESNO(34)); /* LP Push-to-Fix */
display(mid19win, 2, 42, "%dms", getbeu32(buf, 35)); /* LP On Time */
display(mid19win, 3, 42, "%d", getbeu32(buf, 39)); /* LP Interval */
display(mid19win, 4, 42, "%c", YESNO(43)); /* User Tasks enabled */
display(mid19win, 5, 42, "%d", getbeu32(buf, 44)); /* User Task Interval */
display(mid19win, 6, 42, "%c", YESNO(48)); /* LP Power Cycling Enabled */
display(mid19win, 7, 42, "%d", getbeu32(buf, 49)); /* LP Max Acq Search Time */
display(mid19win, 8, 42, "%d", getbeu32(buf, 53)); /* LP Max Off Time */
display(mid19win, 9, 42, "%c", YESNO(57)); /* APM Enabled */
display(mid19win, 10, 42, "%d", (int)getbeu16(buf, 58)); /* # of fixes */
display(mid19win, 11, 42, "%d", (int)getbeu16(buf, 60)); /* Time Between fixes */
display(mid19win, 12, 42, "%d", getub(buf, 62)); /* H/V Error Max */
display(mid19win, 13, 42, "%d", getub(buf, 63)); /* Response Time Max */
display(mid19win, 14, 42, "%d", getub(buf, 64)); /* Time/Accu & Duty Cycle Priority */
#undef YESNO
monitor_log("NP 0x13=");
break;
case 0x1b:
/******************************************************************
Not actually documented in any published materials before the
1.6 version of the SiRF binary protocol manual.
Here is what Chris Kuethe got from the SiRF folks,
(plus some corrections from the GpsPaSsion forums):
Start of message
----------------
Message ID 1 byte 27
Correction Source 1 byte 0=None, 1=SBAS, 2=Serial, 3=Beacon,
4=Software
total: 2 bytes
Middle part of message varies if using beacon or other:
-------------------------------------------------------
If Beacon:
Receiver Freq Hz 4 bytes
Bit rate BPS 1 byte
Status bit map 1 byte 01=Signal Valid,
02=Auto frequency detect
04=Auto bit rate detect
Signal Magnitude 4 bytes Note: in internal units
Signal Strength dB 2 bytes derived from Signal Magnitude
SNR dB 2 bytes
total: 14 bytes
If Not Beacon:
Correction Age[12] 1 byte x 12 Age in seconds in same order as follows
Reserved 2 bytes
total: 14 bytes
End of Message
--------------
Repeated 12 times (pad with 0 if less than 12 SV corrections):
SVID 1 byte
Correction (cm) 2 bytes (signed short)
total 3 x 12 = 36 bytes
******************************************************************/
dgps = getub(buf, 1);
display(mid27win, 1, 1, "%8s = ",
(CHECK_RANGE(dgpsvec, dgps) ? dgpsvec[dgps] : "???"));
(void)wmove(mid27win, 1, 11);
for (ch = 0; ch < SIRF_CHANNELS; ch++)
if (getub(buf, 16 + 3 * ch) != '\0')
(void)wprintw(mid27win, " %d", getub(buf, 16 + 3 * ch));
monitor_log("DST 0x1b=");
break;
case 0x1c: /* NL Measurement Data */
case 0x1d: /* NL DGPS Data */
case 0x1e: /* NL SV State Data */
case 0x1f: /* NL Initialized Data */
subframe_enabled = true;
monitor_log("NL 0x%02x=", buf[0]);
break;
case 0x29: /* Geodetic Navigation Data */
monitor_log("GND 0x29=");
break;
case 0x32: /* SBAS Parameters */
monitor_log("SBP 0x32=");
break;
case 0x34: /* PPS Time */
ppstime_enabled = true;
leapseconds = (int)getbeu16(buf, 8);
monitor_log("PPS 0x34=");
break;
case 0xff: /* Development Data */
while (len > 0 && buf[len - 1] == '\n')
len--;
while (len > 0 && buf[len - 1] == ' ')
len--;
buf[len] = '\0';
j = 1;
for (i = 0; verbpat[i] != NULL; i++)
if (str_starts_with((char *)(buf + 1), verbpat[i])) {
j = 0;
break;
}
if (j != 0)
monitor_log("%s\n", buf + 1);
monitor_log("DD 0xff=");
break;
default:
monitor_log("UNK 0x%02x=", buf[0]);
break;
}
#ifdef CONTROLSEND_ENABLE
/* elicit navigation parameters */
if (dispmode && (time(NULL) % 10 == 0)) {
(void)monitor_control_send((unsigned char *)"\x98\x00", 2);
}
#endif /* CONTROLSEND_ENABLE */
/* clear the 50bps data field every 6 seconds */
if (subframe_enabled && (time(NULL) % 6 == 0)) {
for (ch = 0; ch < SIRF_CHANNELS; ch++)
display(mid4win, ch + 2, 27, " ");
}
if (dispmode) {
(void)touchwin(mid19win);
(void)wnoutrefresh(mid19win);
}
#ifdef PPS_ENABLE
pps_update(mid7win, 2, 32);
#endif /* PPS_ENABLE */
}
/*@ +charint @*/
gps_mask_t evermore_parse(struct gps_device_t * session, unsigned char *buf,
size_t len)
{
unsigned char buf2[MAX_PACKET_LENGTH], *cp, *tp;
size_t i, datalen;
unsigned int type, used, visible, satcnt, j, k;
double version;
gps_mask_t mask = 0;
if (len == 0)
return 0;
/* time to unstuff it and discard the header and footer */
cp = buf + 2;
tp = buf2;
if (*cp == 0x10)
cp++;
datalen = (size_t) * cp++;
gpsd_report(LOG_RAW, "raw EverMore packet type 0x%02x, length %zd: %s\n",
*cp, len, gpsd_hexdump_wrapper(buf, len, LOG_RAW));
datalen -= 2;
/*@ -usedef @*/
for (i = 0; i < (size_t) datalen; i++) {
*tp = *cp++;
if (*tp == 0x10)
cp++;
tp++;
}
type = (unsigned char)getub(buf2, 1);
/*@ +usedef @*/
/*@ -usedef -compdef @*/
gpsd_report(LOG_RAW, "EverMore packet type 0x%02x, length %zd: %s\n",
type, datalen, gpsd_hexdump_wrapper(buf2, datalen, LOG_RAW));
/*@ +usedef +compdef @*/
(void)snprintf(session->gpsdata.tag, sizeof(session->gpsdata.tag),
"EID%u", type);
session->cycle_end_reliable = true;
switch (type) {
case 0x02: /* Navigation Data Output */
session->context->gps_week = (unsigned short)getleuw(buf2, 2);
session->context->gps_tow = (double)getleul(buf2, 4) * 0.01;
/*@ ignore @*//*@ splint is confused @ */
session->newdata.time =
gpstime_to_unix(session->context->gps_week,
session->context->gps_tow) -
session->context->leap_seconds;
/*@ end @*/
ecef_to_wgs84fix(&session->newdata, &session->gpsdata.separation,
getlesl(buf2, 8) * 1.0, getlesl(buf2, 12) * 1.0,
getlesl(buf2, 16) * 1.0, getlesw(buf2, 20) / 10.0,
getlesw(buf2, 22) / 10.0, getlesw(buf2, 24) / 10.0);
used = (unsigned char)getub(buf2, 26) & 0x0f;
//visible = (getub(buf2, 26) & 0xf0) >> 4;
version = (uint) getleuw(buf2, 27) / 100.0;
/* that's all the information in this packet */
if (used < 3)
session->newdata.mode = MODE_NO_FIX;
else if (used == 3)
session->newdata.mode = MODE_2D;
else {
session->newdata.mode = MODE_3D;
mask |= ALTITUDE_IS | CLIMB_IS;
}
mask |= TIME_IS | LATLON_IS | TRACK_IS | SPEED_IS | MODE_IS;
if (session->subtype[0] == '\0') {
(void)snprintf(session->subtype, sizeof(session->subtype),
"%3.2f", version);
mask |= DEVICEID_IS;
}
gpsd_report(LOG_DATA,
"NDO 0x02: time=%.2f, lat=%.2f lon=%.2f alt=%.2f speed=%.2f track=%.2f climb=%.2f mode=%d subtype='%s' mask=%s\n",
session->newdata.time, session->newdata.latitude,
session->newdata.longitude, session->newdata.altitude,
session->newdata.speed, session->newdata.track,
session->newdata.climb, session->newdata.mode,
session->gpsdata.dev.subtype, gpsd_maskdump(mask));
return mask | CLEAR_IS | REPORT_IS;
case 0x04: /* DOP Data Output */
session->context->gps_week = (unsigned short)getleuw(buf2, 2);
session->context->gps_tow = (double)getleul(buf2, 4) * 0.01;
/*@ ignore @*//*@ splint is confused @ */
session->newdata.time =
gpstime_to_unix(session->context->gps_week,
session->context->gps_tow) -
session->context->leap_seconds;
/*@ end @*/
/*
* We make a deliberate choice not to clear DOPs from the
* last skyview here, but rather to treat this as a supplement
* to our calculations from the visiniolity matrix, trusting
* the firmware algorithms over ours.
*/
session->gpsdata.dop.gdop = (double)getub(buf2, 8) * 0.1;
session->gpsdata.dop.pdop = (double)getub(buf2, 9) * 0.1;
session->gpsdata.dop.hdop = (double)getub(buf2, 10) * 0.1;
session->gpsdata.dop.vdop = (double)getub(buf2, 11) * 0.1;
session->gpsdata.dop.tdop = (double)getub(buf2, 12) * 0.1;
switch (getub(buf2, 13)) {
case 0: /* no position fix */
case 1: /* manual calls this "1D navigation" */
session->gpsdata.status = STATUS_NO_FIX;
session->newdata.mode = MODE_NO_FIX;
break;
case 2: /* 2D navigation */
session->gpsdata.status = STATUS_FIX;
session->newdata.mode = MODE_2D;
break;
case 3: /* 3D navigation */
session->gpsdata.status = STATUS_FIX;
session->newdata.mode = MODE_3D;
break;
case 4: /* 3D navigation with DGPS */
session->gpsdata.status = STATUS_DGPS_FIX;
session->newdata.mode = MODE_3D;
break;
}
/* that's all the information in this packet */
mask = TIME_IS | DOP_IS | MODE_IS | STATUS_IS;
gpsd_report(LOG_DATA,
"DDO 0x04: gdop=%.2f pdop=%.2f hdop=%.2f vdop=%.2f tdop=%.2f mode=%d, status=%d mask={TIME| DOP|MODE|STATUS}\n",
session->gpsdata.dop.gdop, session->gpsdata.dop.pdop,
session->gpsdata.dop.hdop, session->gpsdata.dop.vdop,
session->gpsdata.dop.tdop, session->newdata.mode,
session->gpsdata.status);
return mask;
case 0x06: /* Channel Status Output */
session->context->gps_week = (unsigned short)getleuw(buf2, 2);
session->context->gps_tow = (double)getleul(buf2, 4) * 0.01;
/*@ ignore @*//*@ splint is confused @ */
session->gpsdata.skyview_time =
gpstime_to_unix(session->context->gps_week,
session->context->gps_tow) -
session->context->leap_seconds;
/*@ end @*/
session->gpsdata.satellites_visible = (int)getub(buf2, 8);
gpsd_zero_satellites(&session->gpsdata);
memset(session->gpsdata.used, 0, sizeof(session->gpsdata.used));
if (session->gpsdata.satellites_visible > 12) {
gpsd_report(LOG_WARN,
"Warning: EverMore packet has information about %d satellites!\n",
session->gpsdata.satellites_visible);
}
if (session->gpsdata.satellites_visible > EVERMORE_CHANNELS)
session->gpsdata.satellites_visible = EVERMORE_CHANNELS;
satcnt = 0;
for (i = 0; i < (size_t) session->gpsdata.satellites_visible; i++) {
int prn;
// channel = getub(buf2, 7*i+7+2)
prn = (int)getub(buf2, 7 * i + 7 + 3);
if (prn == 0)
continue; /* satellite record is not valid */
session->gpsdata.PRN[satcnt] = prn;
session->gpsdata.azimuth[satcnt] =
(int)getleuw(buf2, 7 * i + 7 + 4);
session->gpsdata.elevation[satcnt] =
(int)getub(buf2, 7 * i + 7 + 6);
session->gpsdata.ss[satcnt] = (float)getub(buf2, 7 * i + 7 + 7);
/*
* Status bits at offset 8:
* bit0 = 1 satellite acquired
* bit1 = 1 code-tracking loop locked
* bit2 = 1 carrier-tracking loop locked
* bit3 = 1 data-bit synchronization done
* bit4 = 1 frame synchronization done
* bit5 = 1 ephemeris data collected
* bit6 = 1 used for position fix
*/
if (getub(buf2, 7 * i + 7 + 8) & 0x40) {
session->gpsdata.used[session->gpsdata.satellites_used++] =
prn;
}
satcnt++;
}
session->gpsdata.satellites_visible = (int)satcnt;
/* that's all the information in this packet */
mask = SATELLITE_IS | USED_IS;
gpsd_report(LOG_DATA,
"CSO 0x06: time=%.2f used=%d visible=%d mask={TIME|SATELLITE|USED}\n",
session->newdata.time, session->gpsdata.satellites_used,
session->gpsdata.satellites_visible);
return mask;
case 0x08: /* Measurement Data Output */
/* clock offset is a manufacturer diagnostic */
/* (int)getleuw(buf2, 8); clock offset, 29000..29850 ?? */
session->context->gps_week = (unsigned short)getleuw(buf2, 2);
session->context->gps_tow = (double)getleul(buf2, 4) * 0.01;
/*@ ignore @*//*@ splint is confused @ */
session->newdata.time =
gpstime_to_unix(session->context->gps_week,
session->context->gps_tow) -
session->context->leap_seconds;
/*@ end @*/
visible = (unsigned char)getub(buf2, 10);
/*
* Note: This code is untested. It was written from the manual.
* The results need to be sanity-checked against a GPS with
* known-good raw decoding and the same skyview.
*
* We can get pseudo range (m), delta-range (m/s), doppler (Hz)
* and status for each channel from the chip. We cannot get
* codephase or carrierphase.
*/
#define SBITS(sat, s, l) sbits((char *)buf, 10 + (sat*14) + s, l)
#define UBITS(sat, s, l) ubits((char *)buf, 10 + (sat*14) + s, l)
for (k = 0; k < visible; k++) {
int prn = (int)UBITS(k, 4, 5);
/* this is so we can tell which never got set */
for (j = 0; j < MAXCHANNELS; j++)
session->gpsdata.raw.mtime[j] = 0;
for (j = 0; j < MAXCHANNELS; j++) {
if (session->gpsdata.PRN[j] == prn) {
session->gpsdata.raw.codephase[j] = NAN;
session->gpsdata.raw.carrierphase[j] = NAN;
session->gpsdata.raw.mtime[j] = session->newdata.time;
session->gpsdata.raw.satstat[j] = (unsigned)UBITS(k, 24, 8);
session->gpsdata.raw.pseudorange[j] = (double)SBITS(k,40,32);
session->gpsdata.raw.deltarange[j] = (double)SBITS(k,72,32);
session->gpsdata.raw.doppler[j] = (double)SBITS(k, 104, 16);
}
}
}
#undef SBITS
#undef UBITS
gpsd_report(LOG_DATA, "MDO 0x04: time=%.2f mask={TIME|RAW}\n",
session->newdata.time);
return TIME_IS | RAW_IS;
case 0x20: /* LogConfig Info, could be used as a probe for EverMore GPS */
gpsd_report(LOG_IO, "LogConfig EverMore packet, length %zd: %s\n",
datalen, gpsd_hexdump_wrapper(buf2, datalen, LOG_IO));
return ONLINE_IS;
case 0x22: /* LogData */
gpsd_report(LOG_IO, "LogData EverMore packet, length %zd: %s\n",
datalen, gpsd_hexdump_wrapper(buf2, datalen, LOG_IO));
return ONLINE_IS;
case 0x38: /* ACK */
gpsd_report(LOG_PROG, "EverMore command %02X ACK\n", getub(buf2, 2));
return ONLINE_IS;
default:
gpsd_report(LOG_WARN,
"unknown EverMore packet EID 0x%02x, length %zd: %s\n",
buf2[0], datalen, gpsd_hexdump_wrapper(buf2, datalen,
LOG_IO));
return 0;
}
}
/*
* decode MID 0xDE, SV and channel status
*
* max payload: 3 + (Num_sats * 10) = 483 bytes
*/
static gps_mask_t sky_msg_DE(struct gps_device_t *session,
unsigned char *buf, size_t len UNUSED)
{
int st, nsv;
unsigned int i;
unsigned int iod; /* Issue of data 0 - 255 */
unsigned int nsvs; /* number of SVs in this packet */
iod = (unsigned int)getub(buf, 1);
nsvs = (unsigned int)getub(buf, 2);
/* too many sats? */
if ( SKY_CHANNELS < nsvs )
return 0;
gpsd_zero_satellites(&session->gpsdata);
for (i = st = nsv = 0; i < nsvs; i++) {
int off = 3 + (10 * i); /* offset into buffer of start of this sat */
bool good; /* do we have a good record ? */
unsigned short sv_stat;
unsigned short chan_stat;
unsigned short ura;
session->gpsdata.skyview[st].PRN = (short)getub(buf, off + 1);
sv_stat = (unsigned short)getub(buf, off + 2);
ura = (unsigned short)getub(buf, off + 3);
session->gpsdata.skyview[st].ss = (float)getub(buf, off + 4);
session->gpsdata.skyview[st].elevation =
(short)getbes16(buf, off + 5);
session->gpsdata.skyview[st].azimuth =
(short)getbes16(buf, off + 7);
chan_stat = (unsigned short)getub(buf, off + 9);
session->gpsdata.skyview[st].used = (bool)(chan_stat & 0x30);
good = session->gpsdata.skyview[st].PRN != 0 &&
session->gpsdata.skyview[st].azimuth != 0 &&
session->gpsdata.skyview[st].elevation != 0;
gpsd_log(&session->context->errout, LOG_DATA,
"Skytraq: PRN=%2d El=%d Az=%d ss=%3.2f stat=%02x,%02x ura=%d %c\n",
session->gpsdata.skyview[st].PRN,
session->gpsdata.skyview[st].elevation,
session->gpsdata.skyview[st].azimuth,
session->gpsdata.skyview[st].ss,
chan_stat, sv_stat, ura,
good ? '*' : ' ');
if ( good ) {
st += 1;
if (session->gpsdata.skyview[st].used)
nsv++;
}
}
session->gpsdata.satellites_visible = st;
session->gpsdata.satellites_used = nsv;
gpsd_log(&session->context->errout, LOG_DATA,
"Skytraq: MID 0xDE: nsvs=%u visible=%u iod=%u\n", nsvs,
session->gpsdata.satellites_visible, iod);
return SATELLITE_SET | USED_IS;
}
/*
* decode MID 0xDF, Nav status (PVT)
*
* 81 bytes
*/
static gps_mask_t sky_msg_DF(struct gps_device_t *session,
unsigned char *buf, size_t len)
{
unsigned int iod; /* Issue of data 0 - 255 */
unsigned short navstat;
unsigned int wn; /* week number 0 - 65535 */
double f_tow; /* receiver tow Sec */
double clock_bias;
double clock_drift;
gps_mask_t mask = 0;
if ( 81 != len)
return 0;
iod = (unsigned int)getub(buf, 1);
/* fix status is byte 2 */
navstat = (unsigned short)getub(buf, 2);
session->gpsdata.status = STATUS_NO_FIX;
session->newdata.mode = MODE_NO_FIX;
switch ( navstat ) {
case 1:
/* fix prediction, ignore */
break;
case 2:
session->gpsdata.status = STATUS_FIX;
session->newdata.mode = MODE_2D;
break;
case 3:
session->gpsdata.status = STATUS_FIX;
session->newdata.mode = MODE_3D;
mask |= ALTITUDE_SET | CLIMB_SET;
break;
case 4:
session->gpsdata.status = STATUS_DGPS_FIX;
session->newdata.mode = MODE_3D;
mask |= ALTITUDE_SET | CLIMB_SET;
break;
default:
break;
}
wn = getbeu16(buf, 3);
f_tow = getbed64((const char *)buf, 5);
/* position/velocity is bytes 13-48, meters and m/s */
ecef_to_wgs84fix(&session->newdata, &session->gpsdata.separation,
(double)getbed64((const char *)buf, 13),
(double)getbed64((const char *)buf, 21),
(double)getbed64((const char *)buf, 29),
(double)getbef32((const char *)buf, 37),
(double)getbef32((const char *)buf, 41),
(double)getbef32((const char *)buf, 46));
clock_bias = getbed64((const char *)buf, 49);
clock_drift = getbes32(buf, 57);
session->gpsdata.dop.gdop = getbef32((const char *)buf, 61);
session->gpsdata.dop.pdop = getbef32((const char *)buf, 65);
session->gpsdata.dop.hdop = getbef32((const char *)buf, 69);
session->gpsdata.dop.vdop = getbef32((const char *)buf, 73);
session->gpsdata.dop.tdop = getbef32((const char *)buf, 77);
session->newdata.time = gpsd_gpstime_resolve(session, wn, f_tow );
gpsd_log(&session->context->errout, LOG_DATA,
"Skytraq: MID 0xDF: iod=%u, stat=%u, wn=%u, tow=%f, t=%.6f "
"cb: %f, cd: %f "
"gdop: %.2f, pdop: %.2f, hdop: %.2f, vdop: %.2f, tdop: %.2f\n",
iod, navstat, wn, f_tow,
session->newdata.time,
clock_bias, clock_drift,
session->gpsdata.dop.gdop,
session->gpsdata.dop.pdop,
session->gpsdata.dop.hdop,
session->gpsdata.dop.vdop,
session->gpsdata.dop.tdop);
mask |= TIME_SET | LATLON_SET | TRACK_SET |
SPEED_SET | STATUS_SET | MODE_SET | DOP_SET | CLEAR_IS | REPORT_IS;
return mask;
}
