Paparazzi UAS v7.1_unstable
Paparazzi is a free software Unmanned Aircraft System.
Loading...
Searching...
No Matches
gps_ubx.c
Go to the documentation of this file.
1/*
2 * Copyright (C) 2010 Antoine Drouin <poinix@gmail.com>
3 *
4 * This file is part of paparazzi.
5 *
6 * paparazzi is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or (at your option)
9 * any later version.
10 *
11 * paparazzi is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with paparazzi; see the file COPYING. If not, write to
18 * the Free Software Foundation, 59 Temple Place - Suite 330,
19 * Boston, MA 02111-1307, USA.
20 */
21
22
23#include "modules/gps/gps_ubx.h"
24#include "modules/core/abi.h"
25#include "pprzlink/dl_protocol.h"
26#include "led.h"
27
28#ifndef USE_GPS_UBX_RTCM
29#define USE_GPS_UBX_RTCM 0
30#endif
31
32
33#if USE_GPS_UBX_RTCM
35#define RTCM3_PREAMBLE 0xD3
36#define RTCM3_MSG_1005 0x69
37#define RTCM3_MSG_1077 0xB1
38#define RTCM3_MSG_4072 0x72
39#define RTCM3_MSG_1230 0xE6
40#define RTCM3_MSG_1087 0xBB
41#define RTCM3_MSG_1097 0xC5
42#endif
43
44#include <math.h>
45
46#if PRINT_DEBUG_GPS_UBX
47#include <stdio.h>
48#define DEBUG_PRINT(...) printf(__VA_ARGS__)
49#else
50#define DEBUG_PRINT(...) {}
51#endif
52
54#include "ubx_protocol.h"
55
56/* parser status */
57#define UNINIT 0
58#define GOT_SYNC1 1
59#define GOT_SYNC2 2
60#define GOT_CLASS 3
61#define GOT_ID 4
62#define GOT_LEN1 5
63#define GOT_LEN2 6
64#define GOT_PAYLOAD 7
65#define GOT_CHECKSUM1 8
66
67#define RXM_RTCM_VERSION 0x02
68#define NAV_RELPOSNED_VERSION 0x01
69#define NAV_DAHEADING_VERSION 0x02
70#define NAV_DAHEADING_REF_ID 0xFFFF
71
73#ifndef GPS_UBX_HEADING_BASELINE
74#define GPS_UBX_HEADING_BASELINE 0.
75#endif
76
78#ifndef GPS_UBX_HEADING_BASELINE_TOL
79#define GPS_UBX_HEADING_BASELINE_TOL 0.4
80#endif
81
83#ifndef GPS_UBX_HEADING_BASELINE_MAX
84#define GPS_UBX_HEADING_BASELINE_MAX 10.
85#endif
86/* last error type */
87#define GPS_UBX_ERR_NONE 0
88#define GPS_UBX_ERR_OVERRUN 1
89#define GPS_UBX_ERR_MSG_TOO_LONG 2
90#define GPS_UBX_ERR_CHECKSUM 3
91#define GPS_UBX_ERR_UNEXPECTED 4
92#define GPS_UBX_ERR_OUT_OF_SYNC 5
93
94#define UTM_HEM_NORTH 0
95#define UTM_HEM_SOUTH 1
96
99void gps_ubx_parse(struct GpsUbx *gubx, uint8_t c);
100void gps_ubx_msg(struct GpsUbx *gubx);
101
102#if USE_GPS_UBX_RTCM
103extern struct RtcmMan rtcm_man;
104
105#ifndef INJECT_BUFF_SIZE
106#define INJECT_BUFF_SIZE 1024 + 6
107#endif
108
109/* RTCM control struct type */
110struct rtcm_t {
111 uint32_t nbyte;
112 uint32_t len;
113 uint8_t buff[INJECT_BUFF_SIZE];
114};
115struct rtcm_t rtcm = { 0 };
116
117#endif
118
119/*
120 * GPS Reset
121 */
122#ifndef GPS_UBX_BOOTRESET
123#define GPS_UBX_BOOTRESET 0
124#endif
125
126#define CFG_RST_Reset_Hardware 0x00
127#define CFG_RST_Reset_Controlled 0x01
128#define CFG_RST_Reset_Controlled_GPS_only 0x02
129#define CFG_RST_Reset_Controlled_GPS_stop 0x08
130#define CFG_RST_Reset_Controlled_GPS_start 0x09
131
132#define CFG_RST_BBR_Hotstart 0x0000
133#define CFG_RST_BBR_Warmstart 0x0001
134#define CFG_RST_BBR_Coldstart 0xffff
135
136void gps_ubx_init(void)
137{
139
140 // Configure the devices
141 gps_ubx[0].state.comp_id = GPS_UBX_ID;
142 gps_ubx[0].dev = &(UBX_GPS_PORT).device;
143#if GPS_UBX_NB > 1
144 gps_ubx[1].state.comp_id = GPS_UBX2_ID;
145 gps_ubx[1].dev = &(UBX2_GPS_PORT).device;
146#endif
147
148 // Set the defaults
149 for(uint8_t i = 0; i < GPS_UBX_NB; i++) {
150 gps_ubx[i].status = UNINIT;
151 gps_ubx[i].msg_available = false;
152 gps_ubx[i].error_cnt = 0;
153 gps_ubx[i].error_last = GPS_UBX_ERR_NONE;
154 gps_ubx[i].pacc_valid = false;
155 }
156}
157
159{
160 for(uint8_t i = 0; i < GPS_UBX_NB; i++) {
161 struct link_device *dev = gps_ubx[i].dev;
162
163 // Read all available bytes from the device
164 while (dev->char_available(dev->periph)) {
165 gps_ubx_parse(&gps_ubx[i], dev->get_byte(dev->periph));
166 if (gps_ubx[i].msg_available) {
167 gps_ubx_msg(&gps_ubx[i]);
168 }
169 }
170
171 // Reset the GPS's if needed
172 if (gps_ubx_reset > 0) {
173 switch (gps_ubx_reset) {
177 default: DEBUG_PRINT("Unknown reset id: %i", gps_ubx_reset); break;
178 }
179 }
180 }
181
182 gps_ubx_reset = 0;
183}
184
186{
188 if (gps_ubx[0].msg_available) {
189 gps_ubx[0].error_cnt++;
190 gps_ubx[0].error_last = GPS_UBX_ERR_OVERRUN;
191 } else {
192 gps_ubx[0].msg_class = DL_HITL_UBX_class(buf);
193 gps_ubx[0].msg_id = DL_HITL_UBX_id(buf);
194 uint8_t l = DL_HITL_UBX_ubx_payload_length(buf);
195 uint8_t *ubx_payload = DL_HITL_UBX_ubx_payload(buf);
196 memcpy(gps_ubx[0].msg_buf, ubx_payload, l);
197 gps_ubx[0].msg_available = true;
198 }
199}
200
201static void gps_ubx_parse_nav_pvt(struct GpsUbx *gubx)
202{
203 uint8_t flags = UBX_NAV_PVT_flags(gubx->msg_buf);
204
205 // Copy fix information
206 uint8_t gnssFixOK = bit_is_set(flags, 0);
207 uint8_t diffSoln = bit_is_set(flags, 1);
208 uint8_t carrSoln = (flags & 0xC0) >> 6;
209 if (diffSoln && carrSoln == 2) {
210 gubx->state.fix = GPS_FIX_RTK;
211 } else if(diffSoln && carrSoln == 1) {
212 gubx->state.fix = GPS_FIX_DGPS;
213 } else if(gnssFixOK) {
214 gubx->state.fix = GPS_FIX_3D;
215 } else {
216 gubx->state.fix = GPS_FIX_NONE;
217 }
218
219 // Copy time information
220 gubx->state.tow = UBX_NAV_PVT_iTOW(gubx->msg_buf);
221 uint16_t year = UBX_NAV_PVT_year(gubx->msg_buf);
222 uint8_t month = UBX_NAV_PVT_month(gubx->msg_buf);
223 uint8_t day = UBX_NAV_PVT_day(gubx->msg_buf);
224 gubx->state.week = gps_week_number(year, month, day);
225 gubx->state.num_sv = UBX_NAV_PVT_numSV(gubx->msg_buf);
226
227 // Copy LLA position
228 gubx->state.lla_pos.lat = UBX_NAV_PVT_lat(gubx->msg_buf);
229 gubx->state.lla_pos.lon = UBX_NAV_PVT_lon(gubx->msg_buf);
230 gubx->state.lla_pos.alt = UBX_NAV_PVT_height(gubx->msg_buf);
232
233 // Ublox gives I4 heading in 1e-5 degrees, apparenty from 0 to 360 degrees (not -180 to 180)
234 // I4 max = 2^31 = 214 * 1e5 * 100 < 360 * 1e7: overflow on angles over 214 deg -> casted to -214 deg
235 // solution: First to radians, and then scale to 1e-7 radians
236 // First x 10 for loosing less resolution, then to radians, then multiply x 10 again
237 gubx->state.course = (RadOfDeg(UBX_NAV_PVT_headMot(gubx->msg_buf) * 10)) * 10;
239 gubx->state.cacc = (RadOfDeg(UBX_NAV_PVT_headAcc(gubx->msg_buf) * 10)) * 10;
240
241 // Copy HMSL and ground speed
242 gubx->state.hmsl = UBX_NAV_PVT_hMSL(gubx->msg_buf);
244 gubx->state.gspeed = UBX_NAV_PVT_gSpeed(gubx->msg_buf) / 10;
245
246 // Copy NED velocities
247 gubx->state.ned_vel.x = UBX_NAV_PVT_velN(gubx->msg_buf) / 10;
248 gubx->state.ned_vel.y = UBX_NAV_PVT_velE(gubx->msg_buf) / 10;
249 gubx->state.ned_vel.z = UBX_NAV_PVT_velD(gubx->msg_buf) / 10;
251
252 // Copy accuracy information
253 gubx->state.pdop = UBX_NAV_PVT_pDOP(gubx->msg_buf);
254 gubx->state.hacc = UBX_NAV_PVT_hAcc(gubx->msg_buf) / 10;
255 gubx->state.vacc = UBX_NAV_PVT_vAcc(gubx->msg_buf) / 10;
256 gubx->state.sacc = UBX_NAV_PVT_sAcc(gubx->msg_buf) / 10;
257
258 if (!gubx->pacc_valid) {
259 // workaround for PVT only
260 gubx->state.pacc = gubx->state.hacc; // report horizontal accuracy
261 }
262}
263
264static void gps_ubx_parse_nav_sol(struct GpsUbx *gubx)
265{
266 // Copy time and fix information
267 uint8_t fix = UBX_NAV_SOL_gpsFix(gubx->msg_buf);
268 if ((fix == GPS_FIX_3D && fix > gubx->state.fix) || fix < GPS_FIX_3D) {
269 // update only if fix is better than current or fix not 3D
270 // leaving fix if in GNSS or RTK mode
271 gubx->state.fix = fix;
272 }
273 gubx->state.tow = UBX_NAV_SOL_iTOW(gubx->msg_buf);
274 gubx->state.week = UBX_NAV_SOL_week(gubx->msg_buf);
275 gubx->state.num_sv = UBX_NAV_SOL_numSV(gubx->msg_buf);
276
277 // Copy ecef position
278 gubx->state.ecef_pos.x = UBX_NAV_SOL_ecefX(gubx->msg_buf);
279 gubx->state.ecef_pos.y = UBX_NAV_SOL_ecefY(gubx->msg_buf);
280 gubx->state.ecef_pos.z = UBX_NAV_SOL_ecefZ(gubx->msg_buf);
282
283 // Copy ecef velocity
284 gubx->state.ecef_vel.x = UBX_NAV_SOL_ecefVX(gubx->msg_buf);
285 gubx->state.ecef_vel.y = UBX_NAV_SOL_ecefVY(gubx->msg_buf);
286 gubx->state.ecef_vel.z = UBX_NAV_SOL_ecefVZ(gubx->msg_buf);
288
289 // Copy accuracy measurements
290 gubx->state.pacc = UBX_NAV_SOL_pAcc(gubx->msg_buf);
291 gubx->state.sacc = UBX_NAV_SOL_sAcc(gubx->msg_buf);
292 gubx->state.pdop = UBX_NAV_SOL_pDOP(gubx->msg_buf);
293 gubx->pacc_valid = true;
294}
295
296static void gps_ubx_parse_nav_posecef(struct GpsUbx *gubx)
297{
298 gubx->state.tow = UBX_NAV_POSECEF_iTOW(gubx->msg_buf);
299
300 // Copy ecef position
301 gubx->state.ecef_pos.x = UBX_NAV_POSECEF_ecefX(gubx->msg_buf);
302 gubx->state.ecef_pos.y = UBX_NAV_POSECEF_ecefY(gubx->msg_buf);
303 gubx->state.ecef_pos.z = UBX_NAV_POSECEF_ecefZ(gubx->msg_buf);
305
306 // Copy accuracy information
307 gubx->state.pacc = UBX_NAV_POSECEF_pAcc(gubx->msg_buf);
308 gubx->pacc_valid = true;
309}
310
311static void gps_ubx_parse_nav_posllh(struct GpsUbx *gubx)
312{
313 // Copy LLA position
314 gubx->state.lla_pos.lat = UBX_NAV_POSLLH_lat(gubx->msg_buf);
315 gubx->state.lla_pos.lon = UBX_NAV_POSLLH_lon(gubx->msg_buf);
316 gubx->state.lla_pos.alt = UBX_NAV_POSLLH_height(gubx->msg_buf);
318
319 // Copy HMSL
320 gubx->state.hmsl = UBX_NAV_POSLLH_hMSL(gubx->msg_buf);
322
323 // Copy accuracy information
324 gubx->state.hacc = UBX_NAV_POSLLH_hAcc(gubx->msg_buf) / 10;
325 gubx->state.vacc = UBX_NAV_POSLLH_vAcc(gubx->msg_buf) / 10;
326}
327
328static void gps_ubx_parse_nav_posutm(struct GpsUbx *gubx)
329{
330 uint8_t hem = UBX_NAV_POSUTM_hem(gubx->msg_buf);
331
332 // Copy UTM state
333 gubx->state.utm_pos.east = UBX_NAV_POSUTM_east(gubx->msg_buf);
334 gubx->state.utm_pos.north = UBX_NAV_POSUTM_north(gubx->msg_buf);
335 if (hem == UTM_HEM_SOUTH) {
336 gubx->state.utm_pos.north -= 1000000000; /* Subtract false northing: -10000km */
337 }
338 gubx->state.utm_pos.alt = UBX_NAV_POSUTM_alt(gubx->msg_buf) * 10;
339 gubx->state.utm_pos.zone = UBX_NAV_POSUTM_zone(gubx->msg_buf);
341
342 // Copy HMSL
343 gubx->state.hmsl = gubx->state.utm_pos.alt;
345}
346
347static void gps_ubx_parse_velecef(struct GpsUbx *gubx)
348{
349 gubx->state.tow = UBX_NAV_VELECEF_iTOW(gubx->msg_buf);
350
351 // Copy ecef velocity
352 gubx->state.ecef_vel.x = UBX_NAV_VELECEF_ecefVX(gubx->msg_buf);
353 gubx->state.ecef_vel.y = UBX_NAV_VELECEF_ecefVY(gubx->msg_buf);
354 gubx->state.ecef_vel.z = UBX_NAV_VELECEF_ecefVZ(gubx->msg_buf);
356
357 // Copy accuracy measurements
358 gubx->state.sacc = UBX_NAV_VELECEF_sAcc(gubx->msg_buf);
359}
360
361static void gps_ubx_parse_nav_velned(struct GpsUbx *gubx)
362{
363 // Copy groundspeed and total 3d speed
364 gubx->state.speed_3d = UBX_NAV_VELNED_speed(gubx->msg_buf);
365 gubx->state.gspeed = UBX_NAV_VELNED_gSpeed(gubx->msg_buf);
366
367 // Copy NED velocities
368 gubx->state.ned_vel.x = UBX_NAV_VELNED_velN(gubx->msg_buf);
369 gubx->state.ned_vel.y = UBX_NAV_VELNED_velE(gubx->msg_buf);
370 gubx->state.ned_vel.z = UBX_NAV_VELNED_velD(gubx->msg_buf);
372
373 // Copy course
374 gubx->state.course = (RadOfDeg(UBX_NAV_VELNED_heading(gubx->msg_buf) * 10)) * 10;
375 gubx->state.cacc = (RadOfDeg(UBX_NAV_VELNED_cAcc(gubx->msg_buf) * 10)) * 10;
377
378 // Copy time of week
379 gubx->state.tow = UBX_NAV_VELNED_iTOW(gubx->msg_buf);
380}
381
382static void gps_ubx_parse_nav_svinfo(struct GpsUbx *gubx)
383{
384 // Get the number of channels
385 gubx->state.nb_channels = Min(UBX_NAV_SVINFO_numCh(gubx->msg_buf), GPS_NB_CHANNELS);
386
387 // Go through all the different channels
388 for (uint8_t i = 0; i < gubx->state.nb_channels; i++) {
389 gubx->state.svinfos[i].svid = UBX_NAV_SVINFO_svid(gubx->msg_buf, i);
390 gubx->state.svinfos[i].flags = UBX_NAV_SVINFO_flags(gubx->msg_buf, i);
391 gubx->state.svinfos[i].qi = UBX_NAV_SVINFO_quality(gubx->msg_buf, i);
392 gubx->state.svinfos[i].cno = UBX_NAV_SVINFO_cno(gubx->msg_buf, i);
393 gubx->state.svinfos[i].elev = UBX_NAV_SVINFO_elev(gubx->msg_buf, i);
394 gubx->state.svinfos[i].azim = UBX_NAV_SVINFO_azim(gubx->msg_buf, i);
395 }
396}
397
398static void gps_ubx_parse_nav_sat(struct GpsUbx *gubx)
399{
400 // Get the number of channels(sattelites) and time of week
401 gubx->state.tow = UBX_NAV_SAT_iTOW(gubx->msg_buf);
402 gubx->state.nb_channels = Min(UBX_NAV_SAT_numSvs(gubx->msg_buf), GPS_NB_CHANNELS);
403
404 // Check the version
405 uint8_t version = UBX_NAV_SAT_version(gubx->msg_buf);
406 if (version != 1) {
407 return;
408 }
409
410 // Satellite systems used in the solution, over all satellites (also above GPS_NB_CHANNELS)
411 const uint16_t nb_sats = Min(UBX_NAV_SAT_numSvs(gubx->msg_buf), (gubx->len - 8) / 12);
412 uint8_t gnss = 0;
413 for (uint16_t i = 0; i < nb_sats; i++) {
414 if ((UBX_NAV_SAT_flags(gubx->msg_buf, i) >> 3) & 0x1) {
415 switch (UBX_NAV_SAT_gnssId(gubx->msg_buf, i)) {
416 case 0: gnss |= 0x01; break; // GPS
417 case 6: gnss |= 0x02; break; // GLONASS
418 case 3: gnss |= 0x04; break; // BeiDou
419 case 2: gnss |= 0x08; break; // Galileo
420 default: break; // SBAS, QZSS, NavIC
421 }
422 }
423 }
424 gubx->gnss_in_use = gnss;
425
426 // Go through all the different channels
427 for (uint8_t i = 0; i < gubx->state.nb_channels; i++) {
428 uint32_t flags = UBX_NAV_SAT_flags(gubx->msg_buf, i);
429 gubx->state.svinfos[i].svid = UBX_NAV_SAT_svId(gubx->msg_buf, i);
430 gubx->state.svinfos[i].cno = UBX_NAV_SAT_cno(gubx->msg_buf, i);
431 gubx->state.svinfos[i].elev = UBX_NAV_SAT_elev(gubx->msg_buf, i);
432 gubx->state.svinfos[i].azim = UBX_NAV_SAT_azim(gubx->msg_buf, i);
433 gubx->state.svinfos[i].qi = flags & 0x7;
434 gubx->state.svinfos[i].flags = (flags >> 3) & 0x1;
435 }
436}
437
438static void gps_ubx_parse_nav_status(struct GpsUbx *gubx)
439{
440 uint8_t fix = UBX_NAV_STATUS_gpsFix(gubx->msg_buf);
441 if ((fix == GPS_FIX_3D && fix > gubx->state.fix) || fix < GPS_FIX_3D) {
442 // update only if fix is better than current or fix not 3D
443 // leaving fix if in GNSS or RTK mode
444 gubx->state.fix = fix;
445 }
446 gubx->state.tow = UBX_NAV_STATUS_iTOW(gubx->msg_buf);
447 gubx->status_flags = UBX_NAV_STATUS_flags(gubx->msg_buf);
448}
449
454static bool gps_ubx_heading_baseline_ok(double distance)
455{
456 if (GPS_UBX_HEADING_BASELINE <= 0.) {
457 return distance < GPS_UBX_HEADING_BASELINE_MAX;
458 }
460}
461
462static void gps_ubx_parse_nav_relposned(struct GpsUbx *gubx)
463{
464#if USE_GPS_UBX_RTCM
465 uint8_t version = UBX_NAV_RELPOSNED_version(gubx->msg_buf);
466 if (version <= NAV_RELPOSNED_VERSION) {
467 uint32_t flags = UBX_NAV_RELPOSNED_flags(gubx->msg_buf);
468 uint8_t gnssFixOK = (flags >> 0) & 0x1;
469 uint8_t diffSoln = (flags >> 1) & 0x1;
470 uint8_t relPosValid = (flags >> 2) & 0x1;
471 uint8_t carrSoln = (flags >> 3) & 0x3;
472 uint8_t relPosHeadingValid = (flags >> 8) & 0x1;
473
474 /* Only save the latest valid relative position */
475 if (relPosValid) {
476 if (diffSoln && carrSoln == 2) {
477 gubx->state.fix = 5; // rtk
478 } else if(diffSoln && carrSoln == 1) {
479 gubx->state.fix = 4; // dgnss
480 } else if(gnssFixOK) {
481 gubx->state.fix = 3; // 3D
482 } else {
483 gubx->state.fix = 0;
484 }
485
486 uint32_t now_ts = get_sys_time_usec();
487 struct RelPosNED relpos = {0};
488 relpos.reference_id = UBX_NAV_RELPOSNED_refStationId(gubx->msg_buf);
489 relpos.tow = UBX_NAV_RELPOSNED_iTOW(gubx->msg_buf);
490 relpos.pos.x = UBX_NAV_RELPOSNED_relPosN(gubx->msg_buf) * 1e-2 + UBX_NAV_RELPOSNED_relPosHPN(gubx->msg_buf) * 1e-4;
491 relpos.pos.y = UBX_NAV_RELPOSNED_relPosE(gubx->msg_buf) * 1e-2 + UBX_NAV_RELPOSNED_relPosHPE(gubx->msg_buf) * 1e-4;
492 relpos.pos.z = UBX_NAV_RELPOSNED_relPosD(gubx->msg_buf) * 1e-2 + UBX_NAV_RELPOSNED_relPosHPD(gubx->msg_buf) * 1e-4;
493 relpos.distance = UBX_NAV_RELPOSNED_relPosLength(gubx->msg_buf) * 1e-2 + UBX_NAV_RELPOSNED_relPosHPLength(gubx->msg_buf) * 1e-4;
494 relpos.pos_acc.x = UBX_NAV_RELPOSNED_accN(gubx->msg_buf) * 1e-4;
495 relpos.pos_acc.y = UBX_NAV_RELPOSNED_accE(gubx->msg_buf) * 1e-4;
496 relpos.pos_acc.z = UBX_NAV_RELPOSNED_accD(gubx->msg_buf) * 1e-4;
497 relpos.distance_acc = UBX_NAV_RELPOSNED_accLength(gubx->msg_buf) * 1e-4;
498
499 // The heading is only valid when relPosHeadingValid is set and the antenna distance is right (NAN is ignored by the INS)
500 if (relPosHeadingValid && gps_ubx_heading_baseline_ok(relpos.distance)) {
501 relpos.heading = RadOfDeg(UBX_NAV_RELPOSNED_relPosHeading(gubx->msg_buf) * 1e-5);
502 relpos.heading_acc = RadOfDeg(UBX_NAV_RELPOSNED_accHeading(gubx->msg_buf) * 1e-5);
503 } else {
504 relpos.heading = NAN;
505 relpos.heading_acc = NAN;
506 }
507
508 AbiSendMsgRELPOS(gubx->state.comp_id, now_ts, &relpos);
509 }
510 }
511#else
512 (void)gubx;
513#endif
514}
515
516/* Dual-antenna heading (e.g. ZED-X20D) from antenna 1 to antenna 2, published as RELPOS */
517static void gps_ubx_parse_nav_daheading(struct GpsUbx *gubx)
518{
519 uint8_t version = UBX_NAV_DAHEADING_version(gubx->msg_buf);
520 if (version != NAV_DAHEADING_VERSION) {
521 return;
522 }
523
524 uint32_t flags = UBX_NAV_DAHEADING_flags(gubx->msg_buf);
525 bool relPosValid = (flags >> 2) & 0x1;
526 uint8_t carrSoln = (flags >> 3) & 0x3;
527 // As u-blox advises: the heading only with a fixed carrier phase solution
528 bool relPosHeadingValid = ((flags >> 6) & 0x1) && carrSoln == 2;
529 if (!relPosValid) {
530 return;
531 }
532
533 uint32_t now_ts = get_sys_time_usec();
534 struct RelPosNED relpos = {0};
536 relpos.tow = UBX_NAV_DAHEADING_iTOW(gubx->msg_buf);
537 relpos.pos.x = UBX_NAV_DAHEADING_relPosN(gubx->msg_buf) * 1e-3;
538 relpos.pos.y = UBX_NAV_DAHEADING_relPosE(gubx->msg_buf) * 1e-3;
539 relpos.pos.z = UBX_NAV_DAHEADING_relPosD(gubx->msg_buf) * 1e-3;
540 relpos.distance = UBX_NAV_DAHEADING_relPosLength(gubx->msg_buf) * 1e-3;
541 relpos.pos_acc.x = UBX_NAV_DAHEADING_accN(gubx->msg_buf) * 1e-3;
542 relpos.pos_acc.y = UBX_NAV_DAHEADING_accE(gubx->msg_buf) * 1e-3;
543 relpos.pos_acc.z = UBX_NAV_DAHEADING_accD(gubx->msg_buf) * 1e-3;
544 relpos.distance_acc = UBX_NAV_DAHEADING_accLength(gubx->msg_buf) * 1e-3;
545
546 // The heading is only valid when relPosHeadingValid is set and the antenna distance is right (NAN is ignored by the INS)
547 if (relPosHeadingValid && gps_ubx_heading_baseline_ok(relpos.distance)) {
548 relpos.heading = RadOfDeg(UBX_NAV_DAHEADING_relPosHeading(gubx->msg_buf) * 1e-5);
549 relpos.heading_acc = RadOfDeg(UBX_NAV_DAHEADING_accHeading(gubx->msg_buf) * 1e-5);
550 } else {
551 relpos.heading = NAN;
552 relpos.heading_acc = NAN;
553 }
554
555 AbiSendMsgRELPOS(gubx->state.comp_id, now_ts, &relpos);
556}
557
558void gps_ubx_read_message(struct GpsUbx *gubx);
559void gps_ubx_read_message(struct GpsUbx *gubx)
560{
561
562 if (gubx->msg_class == UBX_NAV_ID) {
563 switch (gubx->msg_id) {
564 case UBX_NAV_POSECEF_ID:
566 break;
567 case UBX_NAV_POSLLH_ID:
569 break;
570 case UBX_NAV_STATUS_ID:
572 break;
573 case UBX_NAV_SOL_ID:
575 break;
576 case UBX_NAV_PVT_ID:
578 break;
579 case UBX_NAV_POSUTM_ID:
581 break;
582 case UBX_NAV_VELECEF_ID:
584 break;
585 case UBX_NAV_VELNED_ID:
587 break;
588 case UBX_NAV_SVINFO_ID:
590 break;
591 case UBX_NAV_SAT_ID:
593 break;
594 case UBX_NAV_RELPOSNED_ID:
596 break;
597 case UBX_NAV_DAHEADING_ID:
599 break;
600 default:
601 break;
602 }
603 }
604 else if (gubx->msg_class == UBX_RXM_ID) {
605 switch (gubx->msg_id) {
606 // case UBX_RXM_RTCM_ID:
607 // gps_ubx_parse_rxm_rtcm(gubx);
608 // break;
609 default:
610 break;
611 }
612 }
613
614}
615
616#if LOG_RAW_GPS
618#endif
619
620/* UBX parsing */
621void gps_ubx_parse(struct GpsUbx *gubx, uint8_t c)
622{
623#if LOG_RAW_GPS
625#endif
626 if (gubx->status < GOT_PAYLOAD) {
627 gubx->ck_a += c;
628 gubx->ck_b += gubx->ck_a;
629 }
630 switch (gubx->status) {
631 case UNINIT:
632 if (c == UBX_SYNC1) {
633 gubx->status++;
634 }
635 break;
636 case GOT_SYNC1:
637 if (c != UBX_SYNC2) {
639 goto error;
640 }
641 gubx->ck_a = 0;
642 gubx->ck_b = 0;
643 gubx->status++;
644 break;
645 case GOT_SYNC2:
646 if (gubx->msg_available) {
647 /* Previous message has not yet been parsed: discard this one */
649 goto error;
650 }
651 gubx->msg_class = c;
652 gubx->status++;
653 break;
654 case GOT_CLASS:
655 gubx->msg_id = c;
656 gubx->status++;
657 break;
658 case GOT_ID:
659 gubx->len = c;
660 gubx->status++;
661 break;
662 case GOT_LEN1:
663 gubx->len |= (c << 8);
664 if (gubx->len > GPS_UBX_MAX_PAYLOAD) {
666 goto error;
667 }
668 gubx->msg_idx = 0;
669 gubx->status++;
670 break;
671 case GOT_LEN2:
672 gubx->msg_buf[gubx->msg_idx] = c;
673 gubx->msg_idx++;
674 if (gubx->msg_idx >= gubx->len) {
675 gubx->status++;
676 }
677 break;
678 case GOT_PAYLOAD:
679 if (c != gubx->ck_a) {
681 goto error;
682 }
683 gubx->status++;
684 break;
685 case GOT_CHECKSUM1:
686 if (c != gubx->ck_b) {
688 goto error;
689 }
690 gubx->msg_available = true;
691 goto restart;
692 break;
693 default:
695 goto error;
696 }
697 return;
698error:
699 gubx->error_cnt++;
700restart:
701 gubx->status = UNINIT;
702 return;
703}
704
705static void ubx_send_1byte(struct link_device *dev, uint8_t byte)
706{
707 dev->put_byte(dev->periph, 0, byte);
708 for(uint8_t i = 0; i < GPS_UBX_NB; i++) {
709 if(gps_ubx[i].dev == dev) {
710 gps_ubx[i].send_ck_a += byte;
711 gps_ubx[i].send_ck_b += gps_ubx[i].send_ck_a;
712 break;
713 }
714 }
715}
716
717void ubx_header(struct link_device *dev, uint8_t nav_id, uint8_t msg_id, uint16_t len)
718{
719 dev->put_byte(dev->periph, 0, UBX_SYNC1);
720 dev->put_byte(dev->periph, 0, UBX_SYNC2);
721 for(uint8_t i = 0; i < GPS_UBX_NB; i++) {
722 if(gps_ubx[i].dev == dev) {
723 gps_ubx[i].send_ck_a = 0;
724 gps_ubx[i].send_ck_b = 0;
725 break;
726 }
727 }
728 ubx_send_1byte(dev, nav_id);
729 ubx_send_1byte(dev, msg_id);
730 ubx_send_1byte(dev, (uint8_t)(len & 0xFF));
731 ubx_send_1byte(dev, (uint8_t)(len >> 8));
732}
733
734void ubx_trailer(struct link_device *dev)
735{
736 for(uint8_t i = 0; i < GPS_UBX_NB; i++) {
737 if(gps_ubx[i].dev == dev) {
738 dev->put_byte(dev->periph, 0, gps_ubx[i].send_ck_a);
739 dev->put_byte(dev->periph, 0, gps_ubx[i].send_ck_b);
740 break;
741 }
742 }
743 dev->send_message(dev->periph, 0);
744}
745
746void ubx_send_bytes(struct link_device *dev, uint8_t len, uint8_t *bytes)
747{
748 int i;
749 for (i = 0; i < len; i++) {
750 ubx_send_1byte(dev, bytes[i]);
751 }
752}
753
754void ubx_send_cfg_rst(struct link_device *dev, uint16_t bbr , UNUSED uint8_t reset_mode)
755{
756#ifdef UBX_GPS_PORT
757 UbxSend_CFG_RST(dev, bbr, reset_mode, 0x00);
758#endif /* else less harmful for HITL */
759}
760
761#ifndef GPS_UBX_UCENTER
762#define gps_ubx_ucenter_event() {}
763#else
765#endif
766
767void gps_ubx_msg(struct GpsUbx *gubx)
768{
769 // current timestamp
770 uint32_t now_ts = get_sys_time_usec();
771
776 if (gubx->msg_class == UBX_NAV_ID &&
777 (gubx->msg_id == UBX_NAV_VELNED_ID ||
778 gubx->msg_id == UBX_NAV_PVT_ID ||
779 (gubx->msg_id == UBX_NAV_SOL_ID &&
780 !bit_is_set(gubx->state.valid_fields, GPS_VALID_VEL_NED_BIT)))) {
781 if (gubx->state.fix >= GPS_FIX_3D) {
784#ifdef GPS_LED
785 LED_ON(GPS_LED);
786 } else {
787 LED_TOGGLE(GPS_LED);
788 }
789#else
790 }
791#endif
792 AbiSendMsgGPS(gubx->state.comp_id, now_ts, &gubx->state);
793 }
794 gubx->msg_available = false;
795}
796
798{
799 for(uint8_t i = 0; i < GPS_UBX_NB; i++) {
801 }
802}
803
804/*
805 * Write bytes to the ublox UART connection
806 * This is a wrapper functions used in the librtcm library
807 */
808void gps_ublox_write(struct link_device *dev, uint8_t *buff, uint32_t n);
809void gps_ublox_write(struct link_device *dev, uint8_t *buff, uint32_t n)
810{
811 uint32_t i = 0;
812 for (i = 0; i < n; i++) {
813 dev->put_byte(dev->periph, 0, buff[i]);
814 }
815 dev->send_message(dev->periph, 0);
816 return;
817}
818
822#if USE_GPS_UBX_RTCM
823void gps_inject_data(uint8_t packet_id, uint8_t length, uint8_t *data)
824{
825 uint8_t i;
826
827 // nothing to do
828 if (length == 0) {
829 return;
830 }
831
832#ifdef GPS_UBX_UCENTER
833 // not ready
834 if (gps_ubx_ucenter_get_status() != 0) {
835 return;
836 }
837#endif
838
839 // go through buffer
840 for (i = 0; i < length; i++) {
841 if (rtcm.nbyte == 0) {
842 // wait for frame start byte
843 if (data[i] == RTCM3_PREAMBLE) {
844 rtcm.buff[rtcm.nbyte++] = data[i];
845 }
846 } else {
847 // fill buffer
848 if (rtcm.nbyte < INJECT_BUFF_SIZE) {
849 rtcm.buff[rtcm.nbyte++] = data[i];
850 if (rtcm.nbyte == 3) {
851 // extract length
852 rtcm.len = RTCMgetbitu(rtcm.buff, 14, 10) + 3;
853 } else {
854 // wait complete frame
855 if (rtcm.nbyte == rtcm.len + 3) {
856 // check CRC
857 unsigned int crc1 = crc24q(rtcm.buff, rtcm.len);
858 unsigned int crc2 = RTCMgetbitu(rtcm.buff, rtcm.len * 8, 24);
859
860 if (crc1 == crc2) {
861 // write to GPS
862#ifdef UBX_GPS_PORT
863 gps_ublox_write(&(UBX_GPS_PORT).device, rtcm.buff, rtcm.len + 3);
864 DEBUG_PRINT("Inject message %i - %d\n", packet_id, rtcm.buff[0]);
865#endif
866 switch (packet_id) {
867 case RTCM3_MSG_1005 : break;
868 case RTCM3_MSG_1077 : break;
869 case RTCM3_MSG_1087 : break;
870 case RTCM3_MSG_1097 : break;
871 case RTCM3_MSG_4072 : break;
872 case RTCM3_MSG_1230 : break;
873 default: DEBUG_PRINT("Unknown type: %i", packet_id); break;
874 }
875 } else {
876 DEBUG_PRINT("Skipping message %i (CRC failed) - %d", packet_id, rtcm.buff[0]);
877 unsigned int j;
878 for (j = 1; j < rtcm.len; j++) {
879 DEBUG_PRINT(",%d", rtcm.buff[j]);
880 }
881 DEBUG_PRINT("\n");
882 }
883
884 // reset index
885 rtcm.nbyte = 0;
886 }
887 }
888 } else {
889 // reset index
890 rtcm.nbyte = 0;
891 }
892 }
893 }
894}
895
896#endif /* USE_GPS_UBX_RTCM */
unsigned int RTCMgetbitu(unsigned char *buff, int pos, int lenb)
Definition CRC24Q.h:54
unsigned int crc24q(const unsigned char *buff, int len)
Definition CRC24Q.h:44
Main include for ABI (AirBorneInterface).
#define GPS_UBX2_ID
#define GPS_UBX_ID
#define UNUSED(x)
#define LED_ON(i)
Definition led_hw.h:51
#define LED_TOGGLE(i)
Definition led_hw.h:53
uint32_t get_sys_time_usec(void)
Get the time in microseconds since startup.
static struct uart_periph * dev
#define Min(x, y)
Definition esc_dshot.c:110
uint16_t gps_week_number(uint16_t year, uint8_t month, uint8_t day)
Number of weeks since navigation epoch (6 January 1980).
Definition gps.c:663
void WEAK gps_inject_data(uint8_t packet_id, uint8_t length, uint8_t *data)
Default parser for GPS injected data.
Definition gps.c:432
void gps_periodic_check(struct GpsState *gps_s)
Periodic GPS check.
Definition gps.c:292
int16_t azim
azimuth in deg
Definition gps.h:86
uint32_t tow
GPS time of week in ms.
Definition gps.h:112
float distance_acc
Distance accuracy in meters.
Definition gps.h:140
uint8_t qi
quality bitfield (GPS receiver specific)
Definition gps.h:83
int32_t hmsl
height above mean sea level (MSL) in mm
Definition gps.h:97
int8_t elev
elevation in deg
Definition gps.h:85
struct LlaCoor_i lla_pos
position in LLA (lat,lon: deg*1e7; alt: mm over ellipsoid)
Definition gps.h:95
float heading
Relative heading to the reference station in radians.
Definition gps.h:137
uint32_t sacc
speed accuracy in cm/s
Definition gps.h:106
struct UtmCoor_i utm_pos
position in UTM (north,east: cm; alt: mm over MSL)
Definition gps.h:96
uint32_t cacc
course accuracy in rad*1e7
Definition gps.h:107
#define GPS_FIX_DGPS
DGPS fix.
Definition gps.h:45
int32_t course
GPS course over ground in rad*1e7, [0, 2*Pi]*1e7 (CW/north).
Definition gps.h:102
#define GPS_VALID_VEL_ECEF_BIT
Definition gps.h:51
#define GPS_VALID_VEL_NED_BIT
Definition gps.h:52
uint8_t cno
Carrier to Noise Ratio (Signal Strength) in dbHz.
Definition gps.h:84
float heading_acc
Heading accuracy in radians.
Definition gps.h:141
struct EcefCoor_i ecef_pos
position in ECEF in cm
Definition gps.h:94
uint32_t hacc
horizontal accuracy in cm
Definition gps.h:104
#define GPS_VALID_POS_LLA_BIT
Definition gps.h:49
double distance
Relative distance to the reference station in meters.
Definition gps.h:136
uint32_t last_3dfix_ticks
cpu time ticks at last valid 3D fix
Definition gps.h:117
struct EcefCoor_i ecef_vel
speed ECEF in cm/s
Definition gps.h:98
#define GPS_NB_CHANNELS
Definition gps.h:57
uint16_t pdop
position dilution of precision scaled by 100
Definition gps.h:108
uint32_t tow
Time of week (GPS) in ms.
Definition gps.h:133
#define GPS_FIX_NONE
No GPS fix.
Definition gps.h:42
#define GPS_VALID_POS_ECEF_BIT
Definition gps.h:48
#define GPS_VALID_HMSL_BIT
Definition gps.h:53
struct NedCoor_i ned_vel
speed NED in cm/s
Definition gps.h:99
uint32_t last_msg_time
cpu time in sec at last received GPS message
Definition gps.h:120
uint8_t svid
Satellite ID.
Definition gps.h:81
uint8_t nb_channels
Number of scanned satellites.
Definition gps.h:114
struct NedCoor_f pos_acc
Position accuracy in meters.
Definition gps.h:139
uint32_t last_3dfix_time
cpu time in sec at last valid 3D fix
Definition gps.h:118
uint32_t pacc
position accuracy in cm
Definition gps.h:103
uint16_t gspeed
norm of 2d ground speed in cm/s
Definition gps.h:100
uint8_t valid_fields
bitfield indicating valid fields (GPS_VALID_x_BIT)
Definition gps.h:91
uint8_t comp_id
id of current gps
Definition gps.h:92
uint32_t vacc
vertical accuracy in cm
Definition gps.h:105
struct NedCoor_d pos
Relative postion to the reference station in meters.
Definition gps.h:135
#define GPS_FIX_3D
3D GPS fix
Definition gps.h:44
uint16_t speed_3d
norm of 3d speed in cm/s
Definition gps.h:101
struct SVinfo svinfos[GPS_NB_CHANNELS]
holds information from the Space Vehicles (Satellites)
Definition gps.h:115
#define GPS_FIX_RTK
RTK GPS fix.
Definition gps.h:46
uint8_t flags
bitfield with GPS receiver specific flags
Definition gps.h:82
#define GPS_VALID_COURSE_BIT
Definition gps.h:54
uint32_t last_msg_ticks
cpu time ticks at last received GPS message
Definition gps.h:119
uint16_t reference_id
Reference station identification.
Definition gps.h:132
#define GPS_VALID_POS_UTM_BIT
Definition gps.h:50
uint8_t num_sv
number of sat in fix
Definition gps.h:109
uint16_t week
GPS week.
Definition gps.h:111
uint8_t fix
status of fix
Definition gps.h:110
#define GOT_CHECKSUM1
Definition gps_mtk.c:57
#define GOT_ID
Definition gps_mtk.c:55
#define GOT_SYNC2
Definition gps_skytraq.c:31
#define GOT_LEN1
Definition gps_skytraq.c:32
#define GOT_SYNC1
Definition gps_skytraq.c:30
#define GOT_LEN2
Definition gps_skytraq.c:33
#define GOT_CLASS
Definition gps_ubx.c:60
#define CFG_RST_BBR_Coldstart
Definition gps_ubx.c:134
static void gps_ubx_parse_nav_sat(struct GpsUbx *gubx)
Definition gps_ubx.c:398
void gps_ubx_periodic_check(void)
Definition gps_ubx.c:797
void ubx_trailer(struct link_device *dev)
Definition gps_ubx.c:734
void gps_ubx_parse_HITL_UBX(uint8_t *buf)
Definition gps_ubx.c:185
void ubx_header(struct link_device *dev, uint8_t nav_id, uint8_t msg_id, uint16_t len)
Definition gps_ubx.c:717
#define GPS_UBX_ERR_UNEXPECTED
Definition gps_ubx.c:91
void gps_ubx_read_message(struct GpsUbx *gubx)
Definition gps_ubx.c:559
#define GPS_UBX_ERR_OVERRUN
Definition gps_ubx.c:88
#define UTM_HEM_SOUTH
Definition gps_ubx.c:95
#define GPS_UBX_BOOTRESET
Definition gps_ubx.c:123
static void gps_ubx_parse_nav_posecef(struct GpsUbx *gubx)
Definition gps_ubx.c:296
#define NAV_RELPOSNED_VERSION
Definition gps_ubx.c:68
static void ubx_send_1byte(struct link_device *dev, uint8_t byte)
Definition gps_ubx.c:705
static void gps_ubx_parse_nav_pvt(struct GpsUbx *gubx)
Definition gps_ubx.c:201
#define GPS_UBX_ERR_NONE
Definition gps_ubx.c:87
static void gps_ubx_parse_nav_daheading(struct GpsUbx *gubx)
Definition gps_ubx.c:517
static void gps_ubx_parse_nav_posutm(struct GpsUbx *gubx)
Definition gps_ubx.c:328
void gps_ublox_write(struct link_device *dev, uint8_t *buff, uint32_t n)
Definition gps_ubx.c:809
#define GPS_UBX_ERR_MSG_TOO_LONG
Definition gps_ubx.c:89
#define CFG_RST_Reset_Controlled
Definition gps_ubx.c:127
#define CFG_RST_BBR_Hotstart
Definition gps_ubx.c:132
void gps_ubx_event(void)
Definition gps_ubx.c:158
#define DEBUG_PRINT(...)
Definition gps_ubx.c:50
#define GPS_UBX_ERR_CHECKSUM
Definition gps_ubx.c:90
void ubx_send_cfg_rst(struct link_device *dev, uint16_t bbr, UNUSED uint8_t reset_mode)
Definition gps_ubx.c:754
#define GPS_UBX_HEADING_BASELINE_TOL
Largest difference between the measured and the configured antenna distance [m].
Definition gps_ubx.c:79
static void gps_ubx_parse_nav_sol(struct GpsUbx *gubx)
Definition gps_ubx.c:264
#define NAV_DAHEADING_VERSION
Definition gps_ubx.c:69
void gps_ubx_msg(struct GpsUbx *gubx)
Definition gps_ubx.c:767
#define NAV_DAHEADING_REF_ID
RELPOS reference id used for the dual-antenna heading.
Definition gps_ubx.c:70
uint8_t gps_ubx_reset
Definition gps_ubx.c:98
struct GpsUbx gps_ubx[GPS_UBX_NB]
Definition gps_ubx.c:97
#define gps_ubx_ucenter_event()
Definition gps_ubx.c:762
void gps_ubx_init(void)
Definition gps_ubx.c:136
static void gps_ubx_parse_nav_posllh(struct GpsUbx *gubx)
Definition gps_ubx.c:311
#define GPS_UBX_HEADING_BASELINE
Distance between the two antennas of a heading receiver [m] (dual-antenna or moving base),...
Definition gps_ubx.c:74
#define CFG_RST_BBR_Warmstart
Definition gps_ubx.c:133
static void gps_ubx_parse_nav_velned(struct GpsUbx *gubx)
Definition gps_ubx.c:361
static void gps_ubx_parse_velecef(struct GpsUbx *gubx)
Definition gps_ubx.c:347
static void gps_ubx_parse_nav_svinfo(struct GpsUbx *gubx)
Definition gps_ubx.c:382
void gps_ubx_parse(struct GpsUbx *gubx, uint8_t c)
Definition gps_ubx.c:621
void ubx_send_bytes(struct link_device *dev, uint8_t len, uint8_t *bytes)
Definition gps_ubx.c:746
static void gps_ubx_parse_nav_status(struct GpsUbx *gubx)
Definition gps_ubx.c:438
static void gps_ubx_parse_nav_relposned(struct GpsUbx *gubx)
Definition gps_ubx.c:462
static bool gps_ubx_heading_baseline_ok(double distance)
A receiver can report a fixed and valid heading on a wrong carrier phase solution (seen indoors with ...
Definition gps_ubx.c:454
#define GPS_UBX_ERR_OUT_OF_SYNC
Definition gps_ubx.c:92
#define GPS_UBX_HEADING_BASELINE_MAX
Longest antenna distance for which a heading is used when GPS_UBX_HEADING_BASELINE is not set [m] (as...
Definition gps_ubx.c:84
UBX protocol specific code.
uint16_t len
Definition gps_ubx.h:63
uint8_t ck_b
Definition gps_ubx.h:65
struct GpsState state
Definition gps_ubx.h:75
uint8_t status_flags
Definition gps_ubx.h:70
uint8_t status
Definition gps_ubx.h:62
#define GPS_UBX_NB
Definition gps_ubx.h:39
uint8_t msg_class
Definition gps_ubx.h:60
uint8_t gnss_in_use
Satellite systems used in the solution (UBX-NAV-SAT): 1 GPS, 2 GLONASS, 4 BeiDou, 8 Galileo.
Definition gps_ubx.h:73
uint8_t msg_buf[GPS_UBX_MAX_PAYLOAD]
Definition gps_ubx.h:58
uint8_t error_cnt
Definition gps_ubx.h:67
bool pacc_valid
Definition gps_ubx.h:72
uint8_t msg_id
Definition gps_ubx.h:59
uint8_t error_last
Definition gps_ubx.h:68
#define GPS_UBX_MAX_PAYLOAD
e.g. UBX-NAV-SAT is 8 + 12 * numSvs bytes
Definition gps_ubx.h:52
bool msg_available
Definition gps_ubx.h:57
uint8_t ck_a
Definition gps_ubx.h:65
uint16_t msg_idx
Definition gps_ubx.h:64
int gps_ubx_ucenter_get_status(void)
Configure Ublox GPS.
double y
in meters
double z
in meters
double x
in meters
int32_t lat
in degrees*1e7
int32_t alt
in millimeters (above WGS84 reference ellipsoid or above MSL)
int32_t alt
in millimeters above WGS84 reference ellipsoid
int32_t z
Down.
int32_t z
in centimeters
uint8_t zone
UTM zone number.
int32_t x
in centimeters
int32_t y
East.
int32_t east
in centimeters
int32_t y
in centimeters
int32_t lon
in degrees*1e7
int32_t x
North.
int32_t north
in centimeters
struct State state
Definition state.c:36
arch independent LED (Light Emitting Diodes) API
static FILE * pprzLogFile
float z
in meters
float x
in meters
float y
in meters
#define GOT_PAYLOAD
Definition protocol.c:15
#define UNINIT
Receiving pprz messages.
Definition protocol.c:11
#define RTCM3_MSG_1005
Definition rtcm3.h:20
#define RTCM3_MSG_1077
Definition rtcm3.h:22
#define RTCM3_MSG_4072
Definition rtcm3.h:21
#define RTCM3_MSG_1230
Definition rtcm3.h:25
#define RTCM3_MSG_1087
Definition rtcm3.h:23
#define RTCM3_PREAMBLE
Definition rtcm3.h:19
#define RTCM3_MSG_1097
Definition rtcm3.h:24
SdioError sdLogWriteByte(const FileDes fd, const uint8_t value)
volatile uint32_t nb_sec
full seconds since startup
Definition sys_time.h:80
volatile uint32_t nb_sec_rem
remainder of seconds since startup in CPU_TICKS
Definition sys_time.h:81
unsigned short uint16_t
Typedef defining 16 bit unsigned short type.
unsigned int uint32_t
Typedef defining 32 bit unsigned int type.
unsigned char uint8_t
Typedef defining 8 bit unsigned char type.