gnss-js 2.3.0 → 2.5.0

package/dist/{chunk-WW3DKCDN.js → chunk-74IVYOQV.js}

@@ -24,6 +24,7 @@ import {
   crc24q
 } from "./chunk-YUW33VXK.js";
 import {
+  GPS_PI,
   GpsLnavAssembler,
   getBitS,
   getBitU,
@@ -575,6 +576,173 @@ function parseSbfGpsNav(data) {
   return { ephemerides, badParity, messages };
 }
 
+// src/navbits/navic.ts
+var GPS_EPOCH_MS3 = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK2 = 604800;
+var DATA = 30;
+function navicSubframeCrcOk(sf) {
+  return crc24q(sf, 262) === getBitU(sf, 262, 24);
+}
+function navicSubframeId(sf) {
+  return getBitU(sf, 27, 2) + 1;
+}
+function decodeNavicSubframes(sf1, sf2, opts = {}) {
+  let i = DATA;
+  getBitU(sf1, i, 10);
+  i += 10;
+  const af0 = getBitS(sf1, i, 22) * 2 ** -31;
+  i += 22;
+  const af1 = getBitS(sf1, i, 16) * 2 ** -43;
+  i += 16;
+  const af2 = getBitS(sf1, i, 8) * 2 ** -55;
+  i += 8;
+  i += 4;
+  const tocSec = getBitU(sf1, i, 16) * 16;
+  i += 16;
+  const tgd = getBitS(sf1, i, 8) * 2 ** -31;
+  i += 8;
+  const deltaN = getBitS(sf1, i, 22) * 2 ** -41 * GPS_PI;
+  i += 22;
+  const iode = getBitU(sf1, i, 8);
+  i += 8;
+  i += 10;
+  const l5Health = getBitU(sf1, i, 1);
+  i += 1;
+  const sHealth = getBitU(sf1, i, 1);
+  i += 1;
+  const cuc = getBitS(sf1, i, 15) * 2 ** -28;
+  i += 15;
+  const cus = getBitS(sf1, i, 15) * 2 ** -28;
+  i += 15;
+  const cic = getBitS(sf1, i, 15) * 2 ** -28;
+  i += 15;
+  const cis = getBitS(sf1, i, 15) * 2 ** -28;
+  i += 15;
+  const crc = getBitS(sf1, i, 15) * 2 ** -4;
+  i += 15;
+  const crs = getBitS(sf1, i, 15) * 2 ** -4;
+  i += 15;
+  const idot = getBitS(sf1, i, 14) * 2 ** -43 * GPS_PI;
+  let j = DATA;
+  const m0 = getBitS(sf2, j, 32) * 2 ** -31 * GPS_PI;
+  j += 32;
+  const toeSec = getBitU(sf2, j, 16) * 16;
+  j += 16;
+  const e = getBitU(sf2, j, 32) * 2 ** -33;
+  j += 32;
+  const sqrtA = getBitU(sf2, j, 32) * 2 ** -19;
+  j += 32;
+  const omega0 = getBitS(sf2, j, 32) * 2 ** -31 * GPS_PI;
+  j += 32;
+  const omega = getBitS(sf2, j, 32) * 2 ** -31 * GPS_PI;
+  j += 32;
+  const omegaDot = getBitS(sf2, j, 22) * 2 ** -41 * GPS_PI;
+  j += 22;
+  const i0 = getBitS(sf2, j, 32) * 2 ** -31 * GPS_PI;
+  if (sqrtA <= 0 || e >= 1) return null;
+  const week = opts.refWeek ?? Math.floor((Date.now() - GPS_EPOCH_MS3) / 1e3 / SEC_PER_WEEK2);
+  const prn = opts.prn ?? "I00";
+  const tocDate = new Date(
+    GPS_EPOCH_MS3 + (week * SEC_PER_WEEK2 + tocSec) * 1e3
+  );
+  return {
+    system: "I",
+    prn,
+    tocDate,
+    toc: tocDate.getTime() / 1e3 % SEC_PER_WEEK2,
+    af0,
+    af1,
+    af2,
+    iode,
+    crs,
+    deltaN,
+    m0,
+    cuc,
+    e,
+    cus,
+    sqrtA,
+    toe: toeSec,
+    cic,
+    omega0,
+    cis,
+    i0,
+    crc,
+    omega,
+    omegaDot,
+    idot,
+    week,
+    svHealth: l5Health << 1 | sHealth,
+    tgd
+  };
+}
+var NavicAssembler = class {
+  sf1 = /* @__PURE__ */ new Map();
+  last = /* @__PURE__ */ new Map();
+  /**
+   * Push one CRC-valid subframe. Subframe 1 opens a master frame (subframe 2
+   * immediately follows it in the NavIC frame order), so an ephemeris is only
+   * emitted when a subframe 2 pairs with the subframe 1 that opened the *same*
+   * frame — never a stale subframe 1 left over across CRC drops.
+   */
+  push(prn, subframe, refWeek) {
+    if (getBitU(subframe, 25, 1)) return null;
+    const id = navicSubframeId(subframe);
+    if (id === 1) {
+      this.sf1.set(prn, subframe);
+      return null;
+    }
+    if (id !== 2) return null;
+    const a = this.sf1.get(prn);
+    if (!a) return null;
+    this.sf1.delete(prn);
+    const eph = decodeNavicSubframes(a, subframe, { prn, refWeek });
+    if (!eph) return null;
+    const key = `${eph.toc}|${eph.iode}`;
+    if (this.last.get(prn) === key) return null;
+    this.last.set(prn, key);
+    return eph;
+  }
+};
+
+// src/sbf/rawnav-navic.ts
+var WNC_DNU2 = 65535;
+function extractSbfNavicSubframe(view, b) {
+  const sf = new Uint8Array(40);
+  for (let k = 0; k < 10; k++) {
+    const w = view.getUint32(b + 20 + 4 * k, true);
+    sf[4 * k] = w >>> 24;
+    sf[4 * k + 1] = w >>> 16 & 255;
+    sf[4 * k + 2] = w >>> 8 & 255;
+    sf[4 * k + 3] = w & 255;
+  }
+  return sf;
+}
+function feedNavicBlock(view, b, assembler) {
+  const prn = svidToPrn(view.getUint8(b + 14));
+  if (!prn || prn[0] !== "I") return {};
+  const wnc = view.getUint16(b + 12, true);
+  if (wnc === WNC_DNU2) return {};
+  const sf = extractSbfNavicSubframe(view, b);
+  if (!navicSubframeCrcOk(sf)) return { badCrc: true };
+  const eph = assembler.push(prn, sf, wnc);
+  return eph ? { eph } : {};
+}
+function parseSbfNavic(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ephemerides = [];
+  const assembler = new NavicAssembler();
+  let badCrc = 0;
+  let messages = 0;
+  scanSbfFrames(data, view, (id, b, len) => {
+    if (id !== 4093 || len < 60) return;
+    messages++;
+    const r = feedNavicBlock(view, b, assembler);
+    if (r.eph) ephemerides.push(r.eph);
+    else if (r.badCrc) badCrc++;
+  });
+  return { ephemerides, badCrc, messages };
+}
+
 // src/sbf/rawnav.ts
 var CNAV_SIGNAL_OF_BLOCK = {
   4018: "L2C",
@@ -673,10 +841,10 @@ function isFnavDummy(page) {
 }
 
 // src/sbf/rawnav-bds.ts
-var GPS_EPOCH_MS3 = Date.UTC(1980, 0, 6);
+var GPS_EPOCH_MS4 = Date.UTC(1980, 0, 6);
 var MS_PER_WEEK2 = 7 * 86400 * 1e3;
 var TOW_DNU = 4294967295;
-var WNC_DNU2 = 65535;
+var WNC_DNU3 = 65535;
 function feedBdsBlock(view, b, assembler) {
   const prn = svidToPrn(view.getUint8(b + 14));
   if (!prn || prn[0] !== "C") return {};
@@ -716,7 +884,7 @@ function feedGloBlock(view, b, assembler) {
   if (!prn || prn[0] !== "R") return {};
   const towMs = view.getUint32(b + 8, true);
   const wnc = view.getUint16(b + 12, true);
-  if (towMs === TOW_DNU || wnc === WNC_DNU2) return {};
+  if (towMs === TOW_DNU || wnc === WNC_DNU3) return {};
   const str2 = new Uint8Array(11);
   for (let k = 0; k < 3; k++) {
     const w = view.getUint32(b + 20 + 4 * k, true);
@@ -734,7 +902,7 @@ function feedGloBlock(view, b, assembler) {
   const eph = assembler.push(
     prn,
     str2,
-    new Date(GPS_EPOCH_MS3 + wnc * MS_PER_WEEK2 + towMs),
+    new Date(GPS_EPOCH_MS4 + wnc * MS_PER_WEEK2 + towMs),
     view.getUint8(b + 18) - 8
     // FreqNr, offset by 8
   );
@@ -909,6 +1077,7 @@ function decodeSbfNavigation(data, opts = {}) {
     bdsRaw: 0,
     sbasRaw: 0,
     sbasL5Raw: 0,
+    navicRaw: 0,
     badFrames: 0
   };
   const dfmcByType = {};
@@ -918,6 +1087,7 @@ function decodeSbfNavigation(data, opts = {}) {
   const gloAsm = new GloStringAssembler();
   const bdsAsm = new BdsAssembler();
   const lnavAsm = new GpsLnavAssembler();
+  const navicAsm = new NavicAssembler();
   const addEph = (e) => {
     if (!e) return;
     const key = ephKey(e);
@@ -978,6 +1148,14 @@ function decodeSbfNavigation(data, opts = {}) {
         else if (r.badParity) counts.badFrames++;
         return;
       }
+      case 4093: {
+        if (len < 60) return;
+        counts.navicRaw++;
+        const r = feedNavicBlock(view, b, navicAsm);
+        if (r.eph) addEph(r.eph);
+        else if (r.badCrc) counts.badFrames++;
+        return;
+      }
       case 4018:
       // GPSRawL2C
       case 4019: {
@@ -1598,7 +1776,7 @@ function parseSbfHas(data) {
 
 // src/sbf/index.ts
 var CLIGHT = 299792458;
-var GPS_EPOCH_MS4 = Date.UTC(1980, 0, 6);
+var GPS_EPOCH_MS5 = Date.UTC(1980, 0, 6);
 var MS_PER_WEEK3 = 7 * 864e5;
 var M3_SYS = ["G", "R", "E", "C", "S", "J", "I"];
 var M3_PR_BASE = [19e6, 19e6, 22e6, 2e7, 34e6, 34e6, 34e6];
@@ -2252,7 +2430,7 @@ function parseSbfMeas(data) {
       const tow = view.getUint32(i + 8, true);
       const wnc = view.getUint16(i + 12, true);
       if (tow !== 4294967295 && wnc !== 65535) {
-        ensureEpoch(GPS_EPOCH_MS4 + wnc * MS_PER_WEEK3 + tow);
+        ensureEpoch(GPS_EPOCH_MS5 + wnc * MS_PER_WEEK3 + tow);
         if (id === 4109) decodeMeas3Ranges(i, tow);
         else if (id === 4110) decodeMeas3CN0(i, len);
         else if (id === 4111) decodeMeas3Doppler(i, len);
@@ -2273,6 +2451,9 @@ export {
   parseSbfReceiverSetup,
   parseSbfPvt,
   parseSbfGpsNav,
+  extractSbfNavicSubframe,
+  feedNavicBlock,
+  parseSbfNavic,
   parseSbfCnav,
   parseSbfGalNav,
   parseSbfBdsNav,

package/dist/{chunk-XPQ4BU6W.js → chunk-7GNRNKBR.js}

@@ -534,6 +534,70 @@ function decodeQzssEphemeris(payload) {
     fitInterval
   };
 }
+function decodeNavicEphemeris(payload) {
+  if (payload.length < 60) return null;
+  const r = new BitReader(payload);
+  r.skip(12);
+  const svId = r.readU(6);
+  const week = r.readU(10);
+  const af0 = r.readS(22) * 2 ** -31;
+  const af1 = r.readS(16) * 2 ** -43;
+  const af2 = r.readS(8) * 2 ** -55;
+  const ura = r.readU(4);
+  const toc = r.readU(16) * 16;
+  const tgd = r.readS(8) * 2 ** -31;
+  const deltaN = r.readS(22) * 2 ** -41 * PI;
+  const iode = r.readU(8);
+  r.skip(10);
+  const l5Health = r.readU(1);
+  const sHealth = r.readU(1);
+  const cuc = r.readS(15) * 2 ** -28;
+  const cus = r.readS(15) * 2 ** -28;
+  const cic = r.readS(15) * 2 ** -28;
+  const cis = r.readS(15) * 2 ** -28;
+  const crc = r.readS(15) * 2 ** -4;
+  const crs = r.readS(15) * 2 ** -4;
+  const idot = r.readS(14) * 2 ** -43 * PI;
+  const m0 = r.readS(32) * 2 ** -31 * PI;
+  const toe = r.readU(16) * 16;
+  const e = r.readU(32) * 2 ** -33;
+  const sqrtA = r.readU(32) * 2 ** -19;
+  const omega0 = r.readS(32) * 2 ** -31 * PI;
+  const argPerigee = r.readS(32) * 2 ** -31 * PI;
+  const omegaDot = r.readS(22) * 2 ** -41 * PI;
+  const i0 = r.readS(32) * 2 ** -31 * PI;
+  return {
+    prn: `I${String(svId).padStart(2, "0")}`,
+    constellation: "NavIC",
+    health: l5Health << 1 | sHealth,
+    lastReceived: Date.now(),
+    messageType: 1041,
+    week,
+    ura,
+    toc,
+    toe,
+    sqrtA,
+    eccentricity: e,
+    inclination: i0,
+    omega0,
+    omegaDot,
+    argPerigee,
+    meanAnomaly: m0,
+    deltaN,
+    idot,
+    crs,
+    crc,
+    cuc,
+    cus,
+    cic,
+    cis,
+    af0,
+    af1,
+    af2,
+    iode,
+    tgd
+  };
+}
 function decodeEphemeris(frame) {
   try {
     switch (frame.messageType) {
@@ -541,6 +605,8 @@ function decodeEphemeris(frame) {
         return decodeGpsEphemeris(frame.payload);
       case 1020:
         return decodeGlonassEphemeris(frame.payload);
+      case 1041:
+        return decodeNavicEphemeris(frame.payload);
       case 1042:
         return decodeBdsEphemeris(frame.payload);
       case 1043:

package/dist/{chunk-TYJNN77C.js → chunk-B2XWO4RP.js}

@@ -1649,6 +1649,10 @@ var SbasProcessor = class {
   tlat = 0;
   degr = null;
   mt27 = null;
+  /** MT28 clock-ephemeris covariance per PRN: the upper-triangular Cholesky
+   *  factor E (10 elements [E11,E22,E33,E44,E12,E13,E14,E23,E24,E34]) and its
+   *  scale exponent. Keyed by PRN; cleared on a mask change. */
+  mt28 = /* @__PURE__ */ new Map();
   ion = [];
   /** GEO PRN(s) whose messages have been ingested. */
   geoPrns = /* @__PURE__ */ new Set();
@@ -1679,6 +1683,8 @@ var SbasProcessor = class {
         return this.decodeMt10(msg) ? type : -1;
       case 27:
         return this.decodeMt27(msg) ? type : -1;
+      case 28:
+        return this.decodeMt28(msg) ? type : -1;
       case 18:
         return this.decodeIgpMask(msg) ? type : -1;
       case 24:
@@ -1705,6 +1711,7 @@ var SbasProcessor = class {
       return true;
     this.iodp = iodp;
     this.sats = prns.map((prn) => ({ prn }));
+    this.mt28.clear();
     this.satIdx.clear();
     this.sats.forEach((s, k) => {
       if (s.prn) this.satIdx.set(s.prn, k);
@@ -1770,7 +1777,9 @@ var SbasProcessor = class {
       iiono: u(117, 9) || 1,
       cionoRamp: u(126, 10) * 5e-6,
       rssUdre: u(136, 1) === 1,
-      rssIono: u(137, 1) === 1
+      rssIono: u(137, 1) === 1,
+      ccovariance: u(138, 7) * 0.1
+      // Table B-49: 0..12.7 m, 0.1 m
     };
     return true;
   }
@@ -1822,6 +1831,51 @@ var SbasProcessor = class {
     }
     return best ?? DELTA_UDRE[s.udreOutside] ?? 1;
   }
+  /** MT28 clock-ephemeris covariance (ICAO Annex 10 Vol I §3.5.4.7 / Table B-51):
+   *  two satellites per message, each an upper-triangular Cholesky factor E and a
+   *  scale exponent that together define the relative clock-ephemeris covariance
+   *  used for a geometry-dependent δUDRE (§3.5.5.6.2.5). Slots are indexed into
+   *  the current MT1 mask, so a mismatched IODP is dropped. */
+  decodeMt28(msg) {
+    if (this.iodp !== getBitU(msg, 14, 2)) return false;
+    for (const base of [16, 121]) {
+      const slot = getBitU(msg, base, 6);
+      const prn = this.sats[slot]?.prn;
+      const scaleExp = getBitU(msg, base + 6, 3);
+      const e = [
+        getBitU(msg, base + 9, 9),
+        getBitU(msg, base + 18, 9),
+        getBitU(msg, base + 27, 9),
+        getBitU(msg, base + 36, 9),
+        getBitS(msg, base + 45, 10),
+        getBitS(msg, base + 55, 10),
+        getBitS(msg, base + 65, 10),
+        getBitS(msg, base + 75, 10),
+        getBitS(msg, base + 85, 10),
+        getBitS(msg, base + 95, 10)
+      ];
+      if (prn && e.some((v) => v !== 0)) this.mt28.set(prn, { scaleExp, e });
+    }
+    return true;
+  }
+  /** Geometry-dependent δUDRE multiplier from MT28 (§3.5.5.6.2.5):
+   *  δUDRE = √(Iᵀ·C·I) + ε_c, with C = Rᵀ·R, R = E·2^(scaleExp−5),
+   *  I = [î_user→sat, 1], ε_c = C_covariance·2^(scaleExp−5). Since C = RᵀR,
+   *  Iᵀ·C·I = ‖R·I‖², so we form R·I directly. Null when no MT28 for `prn`. */
+  mt28DeltaUdre(prn, los) {
+    const m = this.mt28.get(prn);
+    if (!m) return null;
+    const sf = 2 ** (m.scaleExp - 5);
+    const [e11, e22, e33, e44, e12, e13, e14, e23, e24, e34] = m.e;
+    const [ix, iy, iz] = los;
+    const v0 = (e11 * ix + e12 * iy + e13 * iz + e14) * sf;
+    const v1 = (e22 * iy + e23 * iz + e24) * sf;
+    const v2 = (e33 * iz + e34) * sf;
+    const v3 = e44 * sf;
+    const iCi = v0 * v0 + v1 * v1 + v2 * v2 + v3 * v3;
+    const ec = (this.degr?.ccovariance ?? 0) * sf;
+    return Math.sqrt(iCi) + ec;
+  }
   decodeMixed(msg, week, tow) {
     if (this.iodp !== getBitU(msg, 110, 2)) return false;
     const blk = getBitU(msg, 112, 2);
@@ -2026,7 +2080,7 @@ var SbasProcessor = class {
    * no valid (unexpired) long-term + fast correction is available. Add `dPos`
    * to the satellite ECEF position and `dClkS` to its clock bias.
    */
-  satCorrection(prn, week, tow, userLatRad, userLonRad) {
+  satCorrection(prn, week, tow, userLatRad, userLonRad, losUnitEcef) {
     const idx = this.satIdx.get(prn);
     if (idx === void 0) return null;
     const s = this.sats[idx];
@@ -2048,7 +2102,8 @@ var SbasProcessor = class {
     const tf = now - s.fcorr.t0s + this.tlat;
     if (Math.abs(tf) > MAXSBSAGEF || s.fcorr.udre >= 15) return null;
     const prc = s.fcorr.prc;
-    const dudre = userLatRad != null && userLonRad != null ? this.deltaUdre(
+    const mt28 = losUnitEcef ? this.mt28DeltaUdre(prn, losUnitEcef) : null;
+    const dudre = mt28 != null ? mt28 : userLatRad != null && userLonRad != null ? this.deltaUdre(
       userLatRad * 180 / Math.PI,
       userLonRad * 180 / Math.PI
     ) : 1;
@@ -3768,7 +3823,10 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
       used.push(prn);
       azels.push(azel);
       if (sbas) {
-        const sc = sbas.satCorrection(prn, gpsWeek, gpsTow, rxLat, rxLon);
+        const dx = sat.x - x, dy = sat.y - y, dz = sat.z - z;
+        const dr = Math.hypot(dx, dy, dz) || 1;
+        const los = [dx / dr, dy / dr, dz / dr];
+        const sc = sbas.satCorrection(prn, gpsWeek, gpsTow, rxLat, rxLon, los);
         const si = sbas.ionoDelay(
           gpsWeek,
           gpsTow,