GNSS seed data

// Load AltimeterCloud GNSS seed data into a u-blox SAM-M10Q from an ESP32 (Arduino).
// The receiver is on Serial2 at 9600 baud, the SAM-M10Q's factory default. WiFi is needed
// for the download, and NTP for the time the receiver must be given before the orbits.
#include <WiFi.h>
#include <HTTPClient.h>
#include <time.h>

const char* SSID = "your-wifi";
const char* PASS = "your-password";
const char* URL  = "http://altimetercloud.com/ubx/gnss_all.bin";   // all five systems, about 10 KB
HardwareSerial& gnss = Serial2;                                   // receiver TX to the ESP32's RX2, and back

// Send one UBX message: sync, class, id, length, payload, then the Fletcher checksum
void ubxSend(uint8_t cls, uint8_t id, const uint8_t* pl, uint16_t len) {
  uint8_t hdr[6] = {0xB5, 0x62, cls, id, (uint8_t)(len & 0xFF), (uint8_t)(len >> 8)};
  uint8_t a = 0, b = 0;
  for (int i = 2; i < 6; i++) { a += hdr[i]; b += a; }
  for (int i = 0; i < len; i++) { a += pl[i]; b += a; }
  gnss.write(hdr, 6); gnss.write(pl, len); gnss.write(a); gnss.write(b);
  gnss.flush();                                         // wait until it has all gone out
}

// Wait for UBX-MGA-ACK-DATA0 (0x13 0x60). Returns 1 accepted, 0 refused, -1 nothing heard
int waitAck(uint32_t ms) {
  uint8_t m[16]; int n = 0; uint32_t t0 = millis();
  while (millis() - t0 < ms) {
    if (!gnss.available()) { delay(1); continue; }
    uint8_t c = gnss.read();
    if (n == 0 && c != 0xB5) continue;                  // skips the NMEA in between
    if (n == 1 && c != 0x62) { n = (c == 0xB5); continue; }
    m[n++] = c;
    if (n == 4 && !(m[2] == 0x13 && m[3] == 0x60)) { n = 0; continue; }
    if (n == 16) return m[6];                           // m[8] holds the reason for a refusal
  }
  return -1;
}

void setup() {
  Serial.begin(115200);
  gnss.begin(9600);
  WiFi.begin(SSID, PASS);
  while (WiFi.status() != WL_CONNECTED) delay(200);
  configTime(0, 0, "pool.ntp.org");
  struct tm u;
  while (!getLocalTime(&u)) delay(200);                 // UTC, to the second

  // 1. Download the bundle into RAM
  HTTPClient http;
  http.begin(URL);
  if (http.GET() != 200) { Serial.println("Download failed"); return; }
  int len = http.getSize();
  if (len <= 0) { Serial.println("No length from the server"); return; }
  uint8_t* buf = (uint8_t*)malloc(len);
  if (!buf) { Serial.println("Not enough memory"); return; }
  WiFiClient* s = http.getStreamPtr();
  int got = 0; uint32_t t0 = millis();
  while (got < len && millis() - t0 < 10000) {
    if (s->available()) got += s->readBytes(buf + got, len - got); else delay(1);
  }
  http.end();

  // 2. Quieten the NMEA while we talk (CFG-UART1OUTPROT-NMEA off), and ask for an
  //    acknowledgement of each assistance message (CFG-NAVSPG-ACKAIDING on), both in RAM only
  const uint8_t nmeaOff[] = {0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x74, 0x10, 0x00};
  const uint8_t ackOn[]   = {0x00, 0x01, 0x00, 0x00, 0x25, 0x00, 0x11, 0x10, 0x01};
  ubxSend(0x06, 0x8A, nmeaOff, sizeof nmeaOff); delay(100);
  ubxSend(0x06, 0x8A, ackOn, sizeof ackOn); delay(100);
  while (gnss.available()) gnss.read();

  // 3. The time first (UBX-MGA-INI-TIME_UTC): without it the orbits are refused
  uint8_t t[24] = {0x10, 0x00, 0x00, 0x80};            // no time pulse reference, leap seconds unknown
  uint16_t y = u.tm_year + 1900;
  t[4] = y & 0xFF; t[5] = y >> 8; t[6] = u.tm_mon + 1; t[7] = u.tm_mday;
  t[8] = u.tm_hour; t[9] = u.tm_min; t[10] = u.tm_sec;
  t[16] = 2;                                            // good to about 2 seconds
  ubxSend(0x13, 0x40, t, sizeof t);
  waitAck(500);

  // 4. Every frame just as it is, one at a time, each answered before the next
  int ok = 0, refused = 0, silent = 0;
  for (int i = 0; i + 8 <= got; ) {
    if (buf[i] != 0xB5 || buf[i + 1] != 0x62) break;
    uint16_t n = buf[i + 4] | (buf[i + 5] << 8);
    if (i + 8 + n > got) break;
    gnss.write(buf + i, n + 8);
    gnss.flush();
    int r = waitAck(300);
    if (r == 1) ok++; else if (r == 0) refused++; else silent++;
    i += n + 8;
  }
  free(buf);
  const uint8_t nmeaOn[] = {0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x74, 0x10, 0x01};
  ubxSend(0x06, 0x8A, nmeaOn, sizeof nmeaOn);           // NMEA back on
  Serial.printf("%d accepted, %d refused, %d not answered\n", ok, refused, silent);
}

void loop() {}

# Load AltimeterCloud GNSS seed data into a u-blox SAM-M10Q from a PC or Raspberry Pi.
# pip install pyserial requests
import datetime, lzma, struct, time
import requests, serial

PORT, BAUD = "/dev/ttyUSB0", 9600         # the SAM-M10Q's factory default

index = requests.get("https://altimetercloud.com/ubx/index.json", timeout=10).json()
bundle = next(x for x in index["bundles"] if x["name"] == "gnss_all")
data = lzma.decompress(requests.get(bundle["lzma"]["url"], timeout=10).content, format=lzma.FORMAT_ALONE)

def ubx(cls, mid, payload):
    """One UBX message: sync, class, id, length, payload, Fletcher checksum."""
    body = bytes([cls, mid]) + struct.pack("<H", len(payload)) + payload
    a = b = 0
    for c in body:
        a = (a + c) & 0xFF
        b = (b + a) & 0xFF
    return b"\xb5\x62" + body + bytes([a, b])

def wait_ack(port, secs=0.3):
    """UBX-MGA-ACK-DATA0: 1 accepted, 0 refused, None nothing heard."""
    end, buf = time.time() + secs, b""
    while time.time() < end:
        buf += port.read(port.in_waiting or 1)
        k = buf.find(b"\xb5\x62\x13\x60")
        if k >= 0 and len(buf) >= k + 16:
            return buf[k + 6]             # buf[k + 8] holds the reason for a refusal
    return None

with serial.Serial(PORT, BAUD, timeout=0.05) as gps:
    # quieten the NMEA while we talk (CFG-UART1OUTPROT-NMEA off), and acknowledge
    # each assistance message (CFG-NAVSPG-ACKAIDING on), both in RAM only
    def valset(key, value):
        gps.write(ubx(0x06, 0x8A, bytes([0, 1, 0, 0]) + struct.pack("<IB", key, value)))
        gps.flush()
        time.sleep(0.1)
    valset(0x10740002, 0)
    valset(0x10110025, 1)
    gps.reset_input_buffer()

    # the time first (UBX-MGA-INI-TIME_UTC): without it the orbits are refused
    now = datetime.datetime.now(datetime.timezone.utc)
    t = struct.pack("<BBBbHBBBBBBIHHI", 0x10, 0, 0, -128, now.year, now.month, now.day,
                    now.hour, now.minute, now.second, 0, now.microsecond * 1000, 1, 0, 0)
    gps.write(ubx(0x13, 0x40, t))
    gps.flush()
    wait_ack(gps, 0.5)

    # every frame just as it is, one at a time, each answered before the next
    counts = {1: 0, 0: 0, None: 0}
    i = 0
    while i + 8 <= len(data):
        n = struct.unpack_from("<H", data, i + 4)[0]
        gps.write(data[i:i + 8 + n])
        gps.flush()
        counts[wait_ack(gps)] += 1
        i += 8 + n
    valset(0x10740002, 1)                 # NMEA back on
    print(counts[1], "accepted,", counts[0], "refused,", counts[None], "not answered")