GNSS

Module ID: 5 (MODULE_GNSS) Sensor: ZED-F9P (u-blox)

Moduł GNSS z obsługą RTK. Dostarcza pozycję, prędkość, heading i inne dane nawigacyjne. Dostępny w wariantach Base Station, Body Module i ETU.

Data Frame

Header (12B)
Module ID	Flags	Frame Nr	Sample Count	Timestamp First	Timestamp Last Δ
1B	1B	1B	1B	5B LE	3B LE
byte 0	byte 1	byte 2	byte 3	byte 4–8	byte 9–11

Pole	Wartość
Module ID	`5`
Flags	`0x00`

Payload — PVT (Position-Velocity-Time)

Każda próbka składa się z 55 bajtów (gnss_pvt_data_t, packed, little-endian):

Position (12B)

Position (12B)
Lat	Lon	Alt MSL
4B LE	4B LE	4B LE
byte 0–3	byte 4–7	byte 8–11

Offset	Rozmiar	Pole	Format	Opis
0	4B	`lat`	`int32_t LE`	Latitude [×10⁻⁷ deg]
4	4B	`lon`	`int32_t LE`	Longitude [×10⁻⁷ deg]
8	4B	`alt_msl`	`int32_t LE`	Altitude MSL [mm]

Velocity (16B)

Velocity (16B)
Vel N	Vel E	Vel D	Head Mot
4B LE	4B LE	4B LE	4B LE
byte 12–15	byte 16–19	byte 20–23	byte 24–27

Offset	Rozmiar	Pole	Format	Opis
12	4B	`vel_n`	`int32_t LE`	North velocity [mm/s]
16	4B	`vel_e`	`int32_t LE`	East velocity [mm/s]
20	4B	`vel_d`	`int32_t LE`	Down velocity [mm/s]
24	4B	`head_mot`	`int32_t LE`	Heading of motion [×10⁻⁵ deg]

Accuracy (8B)

Accuracy (8B)
H Acc	V Acc
4B LE	4B LE
byte 28–31	byte 32–35

Offset	Rozmiar	Pole	Format	Opis
28	4B	`h_acc`	`uint32_t LE`	Horizontal accuracy [mm]
32	4B	`v_acc`	`uint32_t LE`	Vertical accuracy [mm]

Geoid, Time & DOP (12B)

Geoid, Time & DOP (12B)
Geoid Sep	UTC Nano	pDOP	hDOP
4B LE	4B LE	2B LE	2B LE
byte 36–39	byte 40–43	byte 44–45	byte 46–47

Offset	Rozmiar	Pole	Format	Opis
36	4B	`geoid_sep`	`int32_t LE`	Separacja geoidy (height − hMSL) [mm]
40	4B	`utc_nano`	`int32_t LE`	Ułamek sekundy UTC [ns] (−1e9 … +1e9)
44	2B	`pdop`	`uint16_t LE`	Position DOP [×0.01]
46	2B	`hdop`	`uint16_t LE`	Horizontal DOP [×0.01]

Status (7B)

Status (7B)
Fix Type	Num SV	Flags	UTC H	UTC M	UTC S	GNSS State
1B	1B	1B	1B	1B	1B	1B
byte 48	byte 49	byte 50	byte 51	byte 52	byte 53	byte 54

Offset	Rozmiar	Pole	Format	Opis
48	1B	`fix_type`	`uint8_t`	Fix type (patrz niżej)
49	1B	`num_sv`	`uint8_t`	Liczba satelitów
50	1B	`flags`	`uint8_t`	Bit 0: gnssFixOK, Bit 1: diffSoln, Bit 2–3: carrSoln
51	1B	`utc_hour`	`uint8_t`	Godzina UTC (0–23)
52	1B	`utc_min`	`uint8_t`	Minuta UTC (0–59)
53	1B	`utc_sec`	`uint8_t`	Sekunda UTC (0–60)
54	1B	`gnss_state`	`uint8_t`	Zagregowany stan GNSS (patrz niżej)

Fix types

Wartość	Typ
0	No fix
2	2D fix
3	3D fix
4	GNSS + Dead Reckoning
5	Time only

GNSS State

Zagregowany stan modułu GNSS — łączy fix_type i flags w jedną wartość:

Wartość	Stan	Opis
0	`OFF`	Moduł wyłączony
1	`ACQUIRING`	Szukanie satelitów, brak fixu
2	`FIX_2D`	Fix 2D
3	`FIX_3D`	Fix 3D
4	`DGNSS`	3D + poprawki różnicowe (SBAS/DGNSS)
5	`RTK_FLOAT`	3D + RTK float (decymetrowa dokładność)
6	`RTK_FIXED`	3D + RTK fixed (centymetrowa dokładność)

Czas UTC z GNSS

Pełny czas UTC odczytu pozycji składa się z pól utc_hour, utc_min, utc_sec i utc_nano:

UTC = utc_hour:utc_min:utc_sec + utc_nano ns

Dla formatu NMEA GGA (hhmmss.ss): centisekundy = utc_nano / 10_000_000.

Parsowanie (TypeScript)

interface GnssPvt {
  lat: number;       // degrees
  lon: number;       // degrees
  altMsl: number;    // meters
  velN: number;      // m/s
  velE: number;      // m/s
  velD: number;      // m/s
  headMot: number;   // degrees
  hAcc: number;      // meters
  vAcc: number;      // meters
  geoidSep: number;  // meters
  utcNano: number;   // nanoseconds
  pdop: number;      // dimensionless
  hdop: number;      // dimensionless
  fixType: number;
  numSv: number;
  gnssFixOk: boolean;
  diffSoln: boolean;
  carrSoln: number;  // 0=none, 1=float, 2=fixed
  utcHour: number;
  utcMin: number;
  utcSec: number;
  gnssState: number; // 0=OFF..6=RTK_FIXED
}

function parseGnssPvt(view: DataView, offset: number): GnssPvt {
  const flags = view.getUint8(offset + 50);
  return {
    lat:        view.getInt32(offset + 0, true) * 1e-7,
    lon:        view.getInt32(offset + 4, true) * 1e-7,
    altMsl:     view.getInt32(offset + 8, true) / 1000,
    velN:       view.getInt32(offset + 12, true) / 1000,
    velE:       view.getInt32(offset + 16, true) / 1000,
    velD:       view.getInt32(offset + 20, true) / 1000,
    headMot:    view.getInt32(offset + 24, true) * 1e-5,
    hAcc:       view.getUint32(offset + 28, true) / 1000,
    vAcc:       view.getUint32(offset + 32, true) / 1000,
    geoidSep:   view.getInt32(offset + 36, true) / 1000,
    utcNano:    view.getInt32(offset + 40, true),
    pdop:       view.getUint16(offset + 44, true) * 0.01,
    hdop:       view.getUint16(offset + 46, true) * 0.01,
    fixType:    view.getUint8(offset + 48),
    numSv:      view.getUint8(offset + 49),
    gnssFixOk:  !!(flags & 0x01),
    diffSoln:   !!(flags & 0x02),
    carrSoln:   (flags >> 2) & 0x03,
    utcHour:    view.getUint8(offset + 51),
    utcMin:     view.getUint8(offset + 52),
    utcSec:     view.getUint8(offset + 53),
    gnssState:  view.getUint8(offset + 54),
  };
}

Control

Module-specific keys

Key	Wartość	Typ	Opis
`KEY_GNSS_UPDATE_RATE`	`0x80`	SET/GET	Częstotliwość aktualizacji [Hz], `uint8_t` (1–20)
`KEY_GNSS_DYNAMIC_MODEL`	`0x81`	SET/GET	UBX dynamic model (`uint8_t`)

Universal keys

KEY_CTRL_INFO (0x01) — informacje o module
KEY_CTRL_ENABLE (0x02) — włącz/wyłącz moduł

RTK — strumień korekcji RTCM

Moduł GNSS obsługuje tryb RTK (Real-Time Kinematic) dzięki dedykowanej charakterystyce BLE RTCM Stream (a204).

Aplikacja kliencka pobiera dane RTCM3 z serwera NTRIP i zapisuje je na charakterystykę RTCM Stream (Write Without Response). Firmware przekazuje je transparentnie na UART do ZED-F9P.

Po otrzymaniu korekcji odbiornik przechodzi kolejno w stany:

DGNSS (gnss_state = 4) — poprawki różnicowe
RTK Float (gnss_state = 5) — dokładność decymetrowa
RTK Fixed (gnss_state = 6) — dokładność centymetrowa

Stan RTK jest widoczny w polu flags ramki PVT: - bit 1 (diffSoln) = poprawki różnicowe aktywne - bity 2–3 (carrSoln) = 1 float RTK, 2 fixed RTK

Patrz: Perun Service — RTCM Stream.