gnss-js 2.4.0 → 2.6.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-B2XWO4RP.js → chunk-BWLLHLLS.js}

@@ -22,6 +22,7 @@ import {
 } from "./chunk-V2D5KUKH.js";
 import {
   C_LIGHT,
+  FREQ,
   OMEGA_E
 } from "./chunk-FIEWO4J4.js";
 
@@ -1463,6 +1464,162 @@ function postProcessRtk(base, rover, ephemerides, baseEcef, opts = {}) {
   return { track, solved, unmatched, fixRate: solved ? fixed / solved : 0 };
 }
 
+// src/positioning/zero-baseline.ts
+function carrierFreqHz2(sys, band, gloChannel) {
+  if (sys === "R") {
+    if (band === "1") return 1602e6 + (gloChannel ?? 0) * 562500;
+    if (band === "2") return 1246e6 + (gloChannel ?? 0) * 437500;
+    return FREQ.R?.[band] ?? 0;
+  }
+  return FREQ[sys]?.[band] ?? 0;
+}
+function median(a) {
+  if (a.length === 0) return 0;
+  const s = [...a].sort((x, y) => x - y);
+  const m = s.length >> 1;
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+var ZeroBaselineEngine = class {
+  ref;
+  refSys;
+  slip;
+  /** Per (receiver|prn|code) continuous phase-SD arc. */
+  arcs = /* @__PURE__ */ new Map();
+  /** Per receiver: integrated phase-smoothed clock (m). */
+  phaseClock = /* @__PURE__ */ new Map();
+  /** Per (receiver|system): accumulated ISB (m) + count. */
+  isb = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.ref = opts.reference;
+    this.refSys = opts.referenceSystem ?? "G";
+    this.slip = opts.slipThreshM ?? 0.05;
+  }
+  reset() {
+    this.arcs.clear();
+    this.phaseClock.clear();
+    this.isb.clear();
+  }
+  /** ISB/IFB estimates accumulated so far, per receiver × system. */
+  biases() {
+    const out = [];
+    for (const [key, { sum, n }] of this.isb) {
+      const [receiver, system] = key.split("|");
+      out.push({ receiver, system, biasM: sum / n, n });
+    }
+    return out;
+  }
+  /**
+   * Ingest one time-aligned instant: observations per receiver id. Returns one
+   * {@link ReceiverClockSample} per non-reference receiver present this epoch.
+   */
+  process(epoch) {
+    const refObs = epoch.obs[this.ref];
+    if (!refObs) return [];
+    const refByKey = /* @__PURE__ */ new Map();
+    for (const o of refObs)
+      if (o.pr != null && Number.isFinite(o.pr))
+        refByKey.set(`${o.prn}|${o.code}`, o);
+    const out = [];
+    for (const rx of Object.keys(epoch.obs)) {
+      if (rx === this.ref) continue;
+      out.push(
+        this.processReceiver(rx, epoch.obs[rx], refByKey, epoch.timeMs)
+      );
+    }
+    return out;
+  }
+  processReceiver(rx, obs, refByKey, t) {
+    const codeBySys = /* @__PURE__ */ new Map();
+    const phase = [];
+    for (const o of obs) {
+      if (o.pr == null || !Number.isFinite(o.pr)) continue;
+      const r = refByKey.get(`${o.prn}|${o.code}`);
+      if (!r || r.pr == null) continue;
+      const sys = o.prn[0];
+      (codeBySys.get(sys) ?? codeBySys.set(sys, []).get(sys)).push(
+        o.pr - r.pr
+      );
+      if (o.cp != null && r.cp != null) {
+        const f = carrierFreqHz2(
+          sys,
+          o.code[0],
+          o.gloChannel ?? r.gloChannel ?? null
+        );
+        if (f > 0)
+          phase.push({
+            key: `${rx}|${o.prn}|${o.code}`,
+            sdM: (o.cp - r.cp) * (C_LIGHT / f),
+            lock: o.lockTimeS
+          });
+      }
+    }
+    if (codeBySys.size === 0)
+      return {
+        t,
+        receiver: rx,
+        clockOffsetM: null,
+        clockOffsetPhaseM: this.phaseClock.get(rx) ?? null,
+        used: 0,
+        rejected: 0,
+        residualRmsM: 0
+      };
+    const sysMedian = /* @__PURE__ */ new Map();
+    for (const [sys, v] of codeBySys) sysMedian.set(sys, median(v));
+    const allSd = [];
+    for (const v of codeBySys.values()) allSd.push(...v);
+    const clk = sysMedian.get(this.refSys) ?? median(allSd);
+    for (const [sys, med] of sysMedian) {
+      if (sys === this.refSys) continue;
+      const cur = this.isb.get(`${rx}|${sys}`) ?? { sum: 0, n: 0 };
+      cur.sum += med - clk;
+      cur.n += 1;
+      this.isb.set(`${rx}|${sys}`, cur);
+    }
+    let ss = 0, used = 0, rejected = 0;
+    for (const [sys, v] of codeBySys) {
+      const isb = sys === this.refSys ? 0 : sysMedian.get(sys) - clk;
+      for (const sd of v) {
+        const res = sd - clk - isb;
+        if (Math.abs(res) > 5) {
+          rejected++;
+          continue;
+        }
+        ss += res * res;
+        used++;
+      }
+    }
+    const residualRmsM = used ? Math.sqrt(ss / used) : 0;
+    const deltas = [];
+    for (const p of phase) {
+      const arc = this.arcs.get(p.key);
+      this.arcs.set(p.key, { lastPhaseSdM: p.sdM, lastLock: p.lock });
+      if (!arc) continue;
+      const lockReset = p.lock != null && arc.lastLock != null && p.lock < arc.lastLock;
+      if (lockReset) continue;
+      deltas.push(p.sdM - arc.lastPhaseSdM);
+    }
+    let phaseClockM = this.phaseClock.get(rx) ?? null;
+    if (phaseClockM == null) {
+      phaseClockM = clk;
+    } else if (deltas.length) {
+      const md = median(deltas);
+      const good = deltas.filter((d) => Math.abs(d - md) < this.slip);
+      const step = good.length ? good.reduce((a, b) => a + b, 0) / good.length : md;
+      phaseClockM += step;
+    }
+    this.phaseClock.set(rx, phaseClockM);
+    return {
+      t,
+      receiver: rx,
+      clockOffsetM: clk,
+      clockOffsetPhaseM: phaseClockM,
+      used,
+      rejected,
+      residualRmsM
+    };
+  }
+};
+
 // src/positioning/sbas.ts
 var P2_11 = 2 ** -11;
 var P2_31 = 2 ** -31;
@@ -3874,6 +4031,7 @@ export {
   solveDgnss,
   RtkFloatEngine,
   postProcessRtk,
+  ZeroBaselineEngine,
   sbasLongTermDeg,
   sbasIonoDeg,
   SbasProcessor,