Paparazzi UAS  v5.14.0_stable-0-g3f680d1
Paparazzi is a free software Unmanned Aircraft System.
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 "subsystems/gps/gps_ubx.h"
24 #include "subsystems/abi.h"
25 #include "led.h"
26 
27 #ifndef USE_GPS_UBX_RTCM
28 #define USE_GPS_UBX_RTCM 0
29 #endif
30 
31 
32 #if USE_GPS_UBX_RTCM
34 #define RTCM3_PREAMBLE 0xD3
35 #define RTCM3_MSG_1005 0x69
36 #define RTCM3_MSG_1077 0xB1
37 #define RTCM3_MSG_1087 0xBB
38 #endif
39 
40 #if PRINT_DEBUG_GPS_UBX
41 #define DEBUG_PRINT(...) printf(__VA_ARGS__)
42 #else
43 #define DEBUG_PRINT(...) {}
44 #endif
45 
47 #include "ubx_protocol.h"
48 
49 /* parser status */
50 #define UNINIT 0
51 #define GOT_SYNC1 1
52 #define GOT_SYNC2 2
53 #define GOT_CLASS 3
54 #define GOT_ID 4
55 #define GOT_LEN1 5
56 #define GOT_LEN2 6
57 #define GOT_PAYLOAD 7
58 #define GOT_CHECKSUM1 8
59 
60 #define RXM_RTCM_VERSION 0x02
61 #define NAV_RELPOSNED_VERSION 0x00
62 /* last error type */
63 #define GPS_UBX_ERR_NONE 0
64 #define GPS_UBX_ERR_OVERRUN 1
65 #define GPS_UBX_ERR_MSG_TOO_LONG 2
66 #define GPS_UBX_ERR_CHECKSUM 3
67 #define GPS_UBX_ERR_UNEXPECTED 4
68 #define GPS_UBX_ERR_OUT_OF_SYNC 5
69 
70 #define UTM_HEM_NORTH 0
71 #define UTM_HEM_SOUTH 1
72 
73 struct GpsUbx gps_ubx;
74 
75 #if USE_GPS_UBX_RXM_RAW
76 struct GpsUbxRaw gps_ubx_raw;
77 #endif
78 
79 #if USE_GPS_UBX_RTCM
80 extern struct GpsRelposNED gps_relposned;
81 extern struct RtcmMan rtcm_man;
82 
83 #ifndef INJECT_BUFF_SIZE
84 #define INJECT_BUFF_SIZE 512
85 #endif
86 /* RTCM control struct type */
87 struct rtcm_t {
88  uint32_t nbyte;
89  uint32_t len;
90  uint8_t buff[INJECT_BUFF_SIZE+1];
91 };
92 struct rtcm_t rtcm = { 0 };
93 
94 #endif
95 
96 bool safeToInject = true;
98 
99 void gps_ubx_init(void)
100 {
102  gps_ubx.msg_available = false;
103  gps_ubx.error_cnt = 0;
105 
107 }
108 
109 void gps_ubx_event(void)
110 {
111  struct link_device *dev = &((UBX_GPS_LINK).device);
112 
113  while (dev->char_available(dev->periph)) {
114  gps_ubx_parse(dev->get_byte(dev->periph));
115  if (gps_ubx.msg_available) {
116  gps_ubx_msg();
117  }
118  }
119 }
120 
122 {
123 
124  if (gps_ubx.msg_class == UBX_NAV_ID) {
125  if (gps_ubx.msg_id == UBX_NAV_SOL_ID) {
126  /* get hardware clock ticks */
128  gps_ubx_time_sync.t0_tow = UBX_NAV_SOL_ITOW(gps_ubx.msg_buf);
129  gps_ubx_time_sync.t0_tow_frac = UBX_NAV_SOL_Frac(gps_ubx.msg_buf);
130  gps_ubx.state.tow = UBX_NAV_SOL_ITOW(gps_ubx.msg_buf);
131  gps_ubx.state.week = UBX_NAV_SOL_week(gps_ubx.msg_buf);
132 #if ! USE_GPS_UBX_RTCM
133  gps_ubx.state.fix = UBX_NAV_SOL_GPSfix(gps_ubx.msg_buf);
134 #endif
135  gps_ubx.state.ecef_pos.x = UBX_NAV_SOL_ECEF_X(gps_ubx.msg_buf);
136  gps_ubx.state.ecef_pos.y = UBX_NAV_SOL_ECEF_Y(gps_ubx.msg_buf);
137  gps_ubx.state.ecef_pos.z = UBX_NAV_SOL_ECEF_Z(gps_ubx.msg_buf);
139  gps_ubx.state.pacc = UBX_NAV_SOL_Pacc(gps_ubx.msg_buf);
140  gps_ubx.state.ecef_vel.x = UBX_NAV_SOL_ECEFVX(gps_ubx.msg_buf);
141  gps_ubx.state.ecef_vel.y = UBX_NAV_SOL_ECEFVY(gps_ubx.msg_buf);
142  gps_ubx.state.ecef_vel.z = UBX_NAV_SOL_ECEFVZ(gps_ubx.msg_buf);
144  gps_ubx.state.sacc = UBX_NAV_SOL_Sacc(gps_ubx.msg_buf);
145  gps_ubx.state.pdop = UBX_NAV_SOL_PDOP(gps_ubx.msg_buf);
146  gps_ubx.state.num_sv = UBX_NAV_SOL_numSV(gps_ubx.msg_buf);
147 #ifdef GPS_LED
148  if (gps_ubx.state.fix == GPS_FIX_3D) {
149  LED_ON(GPS_LED);
150  } else {
151  LED_TOGGLE(GPS_LED);
152  }
153 #endif
154  } else if (gps_ubx.msg_id == UBX_NAV_POSLLH_ID) {
155  gps_ubx.state.lla_pos.lat = UBX_NAV_POSLLH_LAT(gps_ubx.msg_buf);
156  gps_ubx.state.lla_pos.lon = UBX_NAV_POSLLH_LON(gps_ubx.msg_buf);
157  gps_ubx.state.lla_pos.alt = UBX_NAV_POSLLH_HEIGHT(gps_ubx.msg_buf);
159  gps_ubx.state.hmsl = UBX_NAV_POSLLH_HMSL(gps_ubx.msg_buf);
161  } else if (gps_ubx.msg_id == UBX_NAV_POSUTM_ID) {
162  gps_ubx.state.utm_pos.east = UBX_NAV_POSUTM_EAST(gps_ubx.msg_buf);
163  gps_ubx.state.utm_pos.north = UBX_NAV_POSUTM_NORTH(gps_ubx.msg_buf);
164  uint8_t hem = UBX_NAV_POSUTM_HEM(gps_ubx.msg_buf);
165  if (hem == UTM_HEM_SOUTH) {
166  gps_ubx.state.utm_pos.north -= 1000000000; /* Subtract false northing: -10000km */
167  }
168  gps_ubx.state.utm_pos.alt = UBX_NAV_POSUTM_ALT(gps_ubx.msg_buf) * 10;
169  gps_ubx.state.utm_pos.zone = UBX_NAV_POSUTM_ZONE(gps_ubx.msg_buf);
171 
174  } else if (gps_ubx.msg_id == UBX_NAV_VELNED_ID) {
175  gps_ubx.state.speed_3d = UBX_NAV_VELNED_Speed(gps_ubx.msg_buf);
176  gps_ubx.state.gspeed = UBX_NAV_VELNED_GSpeed(gps_ubx.msg_buf);
177  gps_ubx.state.ned_vel.x = UBX_NAV_VELNED_VEL_N(gps_ubx.msg_buf);
178  gps_ubx.state.ned_vel.y = UBX_NAV_VELNED_VEL_E(gps_ubx.msg_buf);
179  gps_ubx.state.ned_vel.z = UBX_NAV_VELNED_VEL_D(gps_ubx.msg_buf);
181  // Ublox gives I4 heading in 1e-5 degrees, apparenty from 0 to 360 degrees (not -180 to 180)
182  // I4 max = 2^31 = 214 * 1e5 * 100 < 360 * 1e7: overflow on angles over 214 deg -> casted to -214 deg
183  // solution: First to radians, and then scale to 1e-7 radians
184  // First x 10 for loosing less resolution, then to radians, then multiply x 10 again
185  gps_ubx.state.course = (RadOfDeg(UBX_NAV_VELNED_Heading(gps_ubx.msg_buf) * 10)) * 10;
187  gps_ubx.state.cacc = (RadOfDeg(UBX_NAV_VELNED_CAcc(gps_ubx.msg_buf) * 10)) * 10;
188  gps_ubx.state.tow = UBX_NAV_VELNED_ITOW(gps_ubx.msg_buf);
189  } else if (gps_ubx.msg_id == UBX_NAV_SVINFO_ID) {
190  gps_ubx.state.nb_channels = Min(UBX_NAV_SVINFO_NCH(gps_ubx.msg_buf), GPS_NB_CHANNELS);
191  uint8_t i;
192  for (i = 0; i < gps_ubx.state.nb_channels; i++) {
193  gps_ubx.state.svinfos[i].svid = UBX_NAV_SVINFO_SVID(gps_ubx.msg_buf, i);
194  gps_ubx.state.svinfos[i].flags = UBX_NAV_SVINFO_Flags(gps_ubx.msg_buf, i);
195  gps_ubx.state.svinfos[i].qi = UBX_NAV_SVINFO_QI(gps_ubx.msg_buf, i);
196  gps_ubx.state.svinfos[i].cno = UBX_NAV_SVINFO_CNO(gps_ubx.msg_buf, i);
197  gps_ubx.state.svinfos[i].elev = UBX_NAV_SVINFO_Elev(gps_ubx.msg_buf, i);
198  gps_ubx.state.svinfos[i].azim = UBX_NAV_SVINFO_Azim(gps_ubx.msg_buf, i);
199  }
200  } else if (gps_ubx.msg_id == UBX_NAV_STATUS_ID) {
201 #if !USE_GPS_UBX_RTCM
202  gps_ubx.state.fix = UBX_NAV_STATUS_GPSfix(gps_ubx.msg_buf);
203 #endif
204  gps_ubx.status_flags = UBX_NAV_STATUS_Flags(gps_ubx.msg_buf);
205  gps_ubx.sol_flags = UBX_NAV_SOL_Flags(gps_ubx.msg_buf);
206  } else if (gps_ubx.msg_id == UBX_NAV_RELPOSNED_ID) {
207 #if USE_GPS_UBX_RTCM
208  uint8_t version = UBX_NAV_RELPOSNED_VERSION(gps_ubx.msg_buf);
209  if (version == NAV_RELPOSNED_VERSION) {
210  gps_relposned.iTOW = UBX_NAV_RELPOSNED_ITOW(gps_ubx.msg_buf);
211  gps_relposned.refStationId = UBX_NAV_RELPOSNED_refStationId(gps_ubx.msg_buf);
212  gps_relposned.relPosN = UBX_NAV_RELPOSNED_RELPOSN(gps_ubx.msg_buf);
213  gps_relposned.relPosE = UBX_NAV_RELPOSNED_RELPOSE(gps_ubx.msg_buf);
214  gps_relposned.relPosD = UBX_NAV_RELPOSNED_RELPOSD(gps_ubx.msg_buf) ;
215  gps_relposned.relPosHPN = UBX_NAV_RELPOSNED_RELPOSNHP(gps_ubx.msg_buf);
216  gps_relposned.relPosHPE = UBX_NAV_RELPOSNED_RELPOSEHP(gps_ubx.msg_buf);
217  gps_relposned.relPosHPD = UBX_NAV_RELPOSNED_RELPOSDHP(gps_ubx.msg_buf);
218  gps_relposned.accN = UBX_NAV_RELPOSNED_Nacc(gps_ubx.msg_buf);
219  gps_relposned.accE = UBX_NAV_RELPOSNED_Eacc(gps_ubx.msg_buf);
220  gps_relposned.accD = UBX_NAV_RELPOSNED_Dacc(gps_ubx.msg_buf);
221  uint8_t flags = UBX_NAV_RELPOSNED_Flags(gps_ubx.msg_buf);
222  gps_relposned.carrSoln = RTCMgetbitu(&flags, 3, 2);
223  gps_relposned.relPosValid = RTCMgetbitu(&flags, 5, 1);
224  gps_relposned.diffSoln = RTCMgetbitu(&flags, 6, 1);
225  gps_relposned.gnssFixOK = RTCMgetbitu(&flags, 7, 1);
226  if (gps_relposned.gnssFixOK > 0) {
227  if (gps_relposned.diffSoln > 0) {
228  if (gps_relposned.carrSoln == 2) {
229  gps_ubx.state.fix = 5; // rtk
230  } else {
231  gps_ubx.state.fix = 4; // dgnss
232  }
233  } else {
234  gps_ubx.state.fix = 3; // 3D
235  }
236  } else {
237  gps_ubx.state.fix = 0;
238  }
239  DEBUG_PRINT("GNSS Fix OK: %i\tDGNSS: %i\tRTK: %i\trelPosValid: %i\trefStationId: %i\n", gps_relposned.gnssFixOK,
241  }
242 #endif // USE_GPS_UBX_RTCM
243  }
244  } else if (gps_ubx.msg_class == UBX_RXM_ID) {
245  if (gps_ubx.msg_id == UBX_RXM_RAW_ID) {
246 #if USE_GPS_UBX_RXM_RAW
247  gps_ubx_raw.iTOW = UBX_RXM_RAW_iTOW(gps_ubx.msg_buf);
248  gps_ubx_raw.week = UBX_RXM_RAW_week(gps_ubx.msg_buf);
249  gps_ubx_raw.numSV = UBX_RXM_RAW_numSV(gps_ubx.msg_buf);
250  uint8_t i;
251  uint8_t max_SV = Min(gps_ubx_raw.numSV, GPS_UBX_NB_CHANNELS);
252  for (i = 0; i < max_SV; i++) {
253  gps_ubx_raw.measures[i].cpMes = UBX_RXM_RAW_cpMes(gps_ubx.msg_buf, i);
254  gps_ubx_raw.measures[i].prMes = UBX_RXM_RAW_prMes(gps_ubx.msg_buf, i);
255  gps_ubx_raw.measures[i].doMes = UBX_RXM_RAW_doMes(gps_ubx.msg_buf, i);
256  gps_ubx_raw.measures[i].sv = UBX_RXM_RAW_sv(gps_ubx.msg_buf, i);
257  gps_ubx_raw.measures[i].mesQI = UBX_RXM_RAW_mesQI(gps_ubx.msg_buf, i);
258  gps_ubx_raw.measures[i].cno = UBX_RXM_RAW_cno(gps_ubx.msg_buf, i);
259  gps_ubx_raw.measures[i].lli = UBX_RXM_RAW_lli(gps_ubx.msg_buf, i);
260  }
261 #endif // USE_GPS_UBX_RXM_RAW
262  } else if (gps_ubx.msg_id == UBX_RXM_RTCM_ID) {
263 #if USE_GPS_UBX_RTCM
264  uint8_t version = UBX_RXM_RTCM_version(gps_ubx.msg_buf);
265  if (version == RXM_RTCM_VERSION) {
266  // uint8_t flags = UBX_RXM_RTCM_flags(gps_ubx.msg_buf);
267  // bool crcFailed = RTCMgetbitu(&flags, 7, 1);
268  // uint16_t refStation = UBX_RXM_RTCM_refStation(gps_ubx.msg_buf);
269  // uint16_t msgType = UBX_RXM_RTCM_msgType(gps_ubx.msg_buf);
270  // DEBUG_PRINT("Message %i from refStation %i processed (CRCfailed: %i)\n", msgType, refStation, crcFailed);
271 
272  rtcm_man.RefStation = UBX_RXM_RTCM_refStation(gps_ubx.msg_buf);
273  rtcm_man.MsgType = UBX_RXM_RTCM_msgType(gps_ubx.msg_buf);
274  uint8_t flags = UBX_RXM_RTCM_flags(gps_ubx.msg_buf);
275  bool crcFailed = RTCMgetbitu(&flags, 7, 1);
276  switch (rtcm_man.MsgType) {
277  case 1005:
278  rtcm_man.Cnt105 += 1;
279  rtcm_man.Crc105 += crcFailed;
280  break;
281  case 1077:
282  rtcm_man.Cnt177 += 1;
283  rtcm_man.Crc177 += crcFailed;;
284  break;
285  case 1087:
286  rtcm_man.Cnt187 += 1;
287  rtcm_man.Crc187 += crcFailed;;
288  break;
289  default:
290  break;
291  }
292  } else {
293  DEBUG_PRINT("Unknown RXM_RTCM version: %i\n", version);
294  }
295 #endif // USE_GPS_UBX_RTCM
296  }
297  }
298 }
299 
300 #if LOG_RAW_GPS
302 #endif
303 
304 /* UBX parsing */
306 {
307 #if LOG_RAW_GPS
308  sdLogWriteByte(pprzLogFile, c);
309 #endif
310  if (gps_ubx.status < GOT_PAYLOAD) {
311  gps_ubx.ck_a += c;
313  }
314  switch (gps_ubx.status) {
315  case UNINIT:
316  if (c == UBX_SYNC1) {
317  gps_ubx.status++;
318  }
319  break;
320  case GOT_SYNC1:
321  if (c != UBX_SYNC2) {
323  goto error;
324  }
325  gps_ubx.ck_a = 0;
326  gps_ubx.ck_b = 0;
327  gps_ubx.status++;
328  break;
329  case GOT_SYNC2:
330  if (gps_ubx.msg_available) {
331  /* Previous message has not yet been parsed: discard this one */
333  goto error;
334  }
335  gps_ubx.msg_class = c;
336  gps_ubx.status++;
337  break;
338  case GOT_CLASS:
339  gps_ubx.msg_id = c;
340  gps_ubx.status++;
341  break;
342  case GOT_ID:
343  gps_ubx.len = c;
344  gps_ubx.status++;
345  break;
346  case GOT_LEN1:
347  gps_ubx.len |= (c << 8);
350  goto error;
351  }
352  gps_ubx.msg_idx = 0;
353  gps_ubx.status++;
354  break;
355  case GOT_LEN2:
357  gps_ubx.msg_idx++;
358  if (gps_ubx.msg_idx >= gps_ubx.len) {
359  gps_ubx.status++;
360  }
361  break;
362  case GOT_PAYLOAD:
363  if (c != gps_ubx.ck_a) {
365  goto error;
366  }
367  gps_ubx.status++;
368  break;
369  case GOT_CHECKSUM1:
370  if (c != gps_ubx.ck_b) {
372  goto error;
373  }
374  gps_ubx.msg_available = true;
375  goto restart;
376  break;
377  default:
379  goto error;
380  }
381  return;
382 error:
383  gps_ubx.error_cnt++;
384 restart:
386  return;
387 }
388 
389 static void ubx_send_1byte(struct link_device *dev, uint8_t byte)
390 {
391  dev->put_byte(dev->periph, 0, byte);
394 }
395 
396 void ubx_header(struct link_device *dev, uint8_t nav_id, uint8_t msg_id, uint16_t len)
397 {
398  dev->put_byte(dev->periph, 0, UBX_SYNC1);
399  dev->put_byte(dev->periph, 0, UBX_SYNC2);
400  gps_ubx.send_ck_a = 0;
401  gps_ubx.send_ck_b = 0;
402  ubx_send_1byte(dev, nav_id);
403  ubx_send_1byte(dev, msg_id);
404  ubx_send_1byte(dev, (uint8_t)(len&0xFF));
405  ubx_send_1byte(dev, (uint8_t)(len>>8));
406 }
407 
408 void ubx_trailer(struct link_device *dev)
409 {
410  dev->put_byte(dev->periph, 0, gps_ubx.send_ck_a);
411  dev->put_byte(dev->periph, 0, gps_ubx.send_ck_b);
412  dev->send_message(dev->periph, 0);
413 }
414 
415 void ubx_send_bytes(struct link_device *dev, uint8_t len, uint8_t *bytes)
416 {
417  int i;
418  for (i = 0; i < len; i++) {
419  ubx_send_1byte(dev, bytes[i]);
420  }
421 }
422 
423 void ubx_send_cfg_rst(struct link_device *dev, uint16_t bbr , uint8_t reset_mode)
424 {
425 #ifdef UBX_GPS_LINK
426  UbxSend_CFG_RST(dev, bbr, reset_mode, 0x00);
427 #endif /* else less harmful for HITL */
428 }
429 
430 #ifndef GPS_UBX_UCENTER
431 #define gps_ubx_ucenter_event() {}
432 #else
434 #endif
435 
436 void gps_ubx_msg(void)
437 {
438  // current timestamp
439  uint32_t now_ts = get_sys_time_usec();
440 
445  if (gps_ubx.msg_class == UBX_NAV_ID &&
446  (gps_ubx.msg_id == UBX_NAV_VELNED_ID ||
447  (gps_ubx.msg_id == UBX_NAV_SOL_ID &&
449  if (gps_ubx.state.fix >= GPS_FIX_3D) {
452  }
453  AbiSendMsgGPS(GPS_UBX_ID, now_ts, &gps_ubx.state);
454  }
455  gps_ubx.msg_available = false;
456 }
457 
458 /*
459  * Write bytes to the ublox UART connection
460  * This is a wrapper functions used in the librtcm library
461  */
462 void gps_ublox_write(struct link_device *dev, uint8_t *buff, uint32_t n);
463 void gps_ublox_write(struct link_device *dev, uint8_t *buff, uint32_t n)
464 {
465  uint32_t i = 0;
466  for (i = 0; i < n; i++) {
467  dev->put_byte(dev->periph, 0, buff[i]);
468  }
469  dev->send_message(dev->periph, 0);
470  return;
471 }
472 
476 #if USE_GPS_UBX_RTCM
477 void gps_inject_data(uint8_t packet_id, uint8_t length, uint8_t *data)
478 {
479  uint8_t i;
480 
481  // nothing to do
482  if (length == 0) {
483  return;
484  }
485 
486 #ifdef GPS_UBX_UCENTER
487  // not ready
488  if (gps_ubx_ucenter_get_status() != 0) {
489  return;
490  }
491 #endif
492 
493  // go through buffer
494  for (i = 0; i < length; i++) {
495  if (rtcm.nbyte == 0) {
496  // wait for frame start byte
497  if (data[i] == RTCM3_PREAMBLE) {
498  rtcm.buff[rtcm.nbyte++] = data[i];
499  }
500  } else {
501  // fill buffer
502  if (rtcm.nbyte < INJECT_BUFF_SIZE) {
503  rtcm.buff[rtcm.nbyte++] = data[i];
504  if (rtcm.nbyte == 3) {
505  // extract length
506  rtcm.len = RTCMgetbitu(rtcm.buff, 14, 10) + 3;
507  } else {
508  // wait complete frame
509  if (rtcm.nbyte == rtcm.len + 3) {
510  // check CRC
511  unsigned int crc1 = crc24q(rtcm.buff, rtcm.len);
512  unsigned int crc2 = RTCMgetbitu(rtcm.buff, rtcm.len * 8, 24);
513 
514  if (crc1 == crc2) {
515  // write to GPS
516  gps_ublox_write(&(UBX_GPS_LINK).device, rtcm.buff, rtcm.len + 3);
517  switch (packet_id) {
518  case RTCM3_MSG_1005 : break;
519  case RTCM3_MSG_1077 : break;
520  case RTCM3_MSG_1087 : break;
521  default: DEBUG_PRINT("Unknown type: %i", packet_id); break;
522  }
523  } else {
524  DEBUG_PRINT("Skipping message %i (CRC failed) - %d", packet_id, rtcm.buff[0]);
525  unsigned int j;
526  for (j = 1; j < rtcm.len; j++) {
527  DEBUG_PRINT(",%d", rtcm.buff[j]);
528  }
529  DEBUG_PRINT("\n");
530  }
531 
532  // reset index
533  rtcm.nbyte = 0;
534  }
535  }
536  } else {
537  // reset index
538  rtcm.nbyte = 0;
539  }
540  }
541  }
542 }
543 
544 #endif
uint8_t qi
quality bitfield (GPS receiver specific)
Definition: gps.h:74
unsigned short uint16_t
Definition: types.h:16
#define GOT_CLASS
Definition: gps_ubx.c:53
int32_t z
in centimeters
unsigned int RTCMgetbitu(unsigned char *buff, int pos, int lenb)
Definition: CRC24Q.h:54
#define UTM_HEM_SOUTH
Definition: gps_ubx.c:71
uint32_t t0_tow
GPS time of week in ms from last message.
Definition: gps.h:115
int32_t north
in centimeters
struct SVinfo svinfos[GPS_NB_CHANNELS]
holds information from the Space Vehicles (Satellites)
Definition: gps.h:104
int16_t azim
azimuth in deg
Definition: gps.h:77
#define GOT_CHECKSUM1
Definition: gps_ubx.c:58
uint32_t pacc
position accuracy in cm
Definition: gps.h:94
#define GOT_ID
Definition: gps_ubx.c:54
void ubx_trailer(struct link_device *dev)
Definition: gps_ubx.c:408
#define RXM_RTCM_VERSION
Definition: gps_ubx.c:60
void ubx_send_bytes(struct link_device *dev, uint8_t len, uint8_t *bytes)
Definition: gps_ubx.c:415
#define gps_ubx_ucenter_event()
Definition: gps_ubx.c:431
void gps_ubx_event(void)
Definition: gps_ubx.c:109
uint8_t nb_channels
Number of scanned satellites.
Definition: gps.h:103
uint32_t Cnt187
Definition: gps.h:144
uint32_t t0_ticks
hw clock ticks when GPS message is received
Definition: gps.h:117
#define GPS_VALID_VEL_NED_BIT
Definition: gps.h:52
uint8_t sol_flags
Definition: gps_ubx.h:69
uint8_t valid_fields
bitfield indicating valid fields (GPS_VALID_x_BIT)
Definition: gps.h:82
int32_t y
in centimeters
uint8_t carrSoln
Definition: gps.h:133
uint16_t week
GPS week.
Definition: gps.h:100
UBX protocol specific code.
Definition: gps_ubx.h:54
#define GPS_NB_CHANNELS
Definition: gps.h:57
#define RTCM3_MSG_1077
Definition: rtcm3.h:21
void gps_ubx_parse(uint8_t c)
Definition: gps_ubx.c:305
int32_t relPosE
Definition: gps.h:125
#define GPS_UBX_ID
Main include for ABI (AirBorneInterface).
struct RtcmMan rtcm_man
Definition: gps.c:79
void gps_ubx_init(void)
Definition: gps_ubx.c:99
#define RTCM3_PREAMBLE
Definition: rtcm3.h:19
uint16_t len
Definition: gps_ubx.h:61
struct GpsUbx gps_ubx
Definition: gps_ubx.c:73
uint8_t msg_buf[GPS_UBX_MAX_PAYLOAD]
Definition: gps_ubx.h:56
int32_t east
in centimeters
int8_t relPosHPD
Definition: gps.h:129
uint8_t svid
Satellite ID.
Definition: gps.h:72
volatile uint32_t nb_tick
SYS_TIME_TICKS since startup.
Definition: sys_time.h:74
uint16_t speed_3d
norm of 3d speed in cm/s
Definition: gps.h:92
#define GPS_FIX_3D
3D GPS fix
Definition: gps.h:39
int32_t z
Down.
struct UtmCoor_i utm_pos
position in UTM (north,east: cm; alt: mm over MSL)
Definition: gps.h:87
static void ubx_send_1byte(struct link_device *dev, uint8_t byte)
Definition: gps_ubx.c:389
uint8_t diffSoln
Definition: gps.h:135
uint32_t Crc187
Definition: gps.h:147
#define GPS_UBX_ERR_OUT_OF_SYNC
Definition: gps_ubx.c:68
uint8_t msg_id
Definition: gps_ubx.h:57
uint8_t error_cnt
Definition: gps_ubx.h:65
uint32_t last_3dfix_ticks
cpu time ticks at last valid 3D fix
Definition: gps.h:106
int8_t elev
elevation in deg
Definition: gps.h:76
int32_t alt
in millimeters above WGS84 reference ellipsoid
#define GPS_UBX_MAX_PAYLOAD
Definition: gps_ubx.h:53
uint32_t accN
Definition: gps.h:130
uint32_t sacc
speed accuracy in cm/s
Definition: gps.h:95
struct GpsTimeSync gps_ubx_time_sync
Definition: gps_ubx.c:97
#define NAV_RELPOSNED_VERSION
Definition: gps_ubx.c:61
int32_t y
East.
#define GOT_SYNC2
Definition: gps_ubx.c:52
uint32_t last_msg_time
cpu time in sec at last received GPS message
Definition: gps.h:109
uint32_t cacc
course accuracy in rad*1e7
Definition: gps.h:96
uint8_t zone
UTM zone number.
#define GPS_VALID_COURSE_BIT
Definition: gps.h:54
Configure Ublox GPS.
#define GPS_UBX_ERR_UNEXPECTED
Definition: gps_ubx.c:67
int8_t relPosHPE
Definition: gps.h:128
uint32_t Crc105
Definition: gps.h:145
int32_t hmsl
height above mean sea level (MSL) in mm
Definition: gps.h:88
uint8_t cno
Carrier to Noise Ratio (Signal Strength) in dbHz.
Definition: gps.h:75
uint32_t tow
GPS time of week in ms.
Definition: gps.h:101
uint32_t Cnt177
Definition: gps.h:143
uint8_t ck_b
Definition: gps_ubx.h:63
unsigned int crc24q(const unsigned char *buff, int len)
Definition: CRC24Q.h:44
void gps_ublox_write(struct link_device *dev, uint8_t *buff, uint32_t n)
Definition: gps_ubx.c:463
uint16_t pdop
position dilution of precision scaled by 100
Definition: gps.h:97
uint8_t ck_a
Definition: gps_ubx.h:63
void ubx_header(struct link_device *dev, uint8_t nav_id, uint8_t msg_id, uint16_t len)
Definition: gps_ubx.c:396
#define RTCM3_MSG_1087
Definition: rtcm3.h:22
bool safeToInject
Definition: gps_ubx.c:96
int32_t x
North.
Definition: gps.h:139
unsigned long uint32_t
Definition: types.h:18
#define GPS_UBX_NB_CHANNELS
Definition: gps_ubx.h:51
struct EcefCoor_i ecef_pos
position in ECEF in cm
Definition: gps.h:85
void ubx_send_cfg_rst(struct link_device *dev, uint16_t bbr, uint8_t reset_mode)
Definition: gps_ubx.c:423
#define GPS_VALID_HMSL_BIT
Definition: gps.h:53
uint8_t msg_idx
Definition: gps_ubx.h:62
int32_t lon
in degrees*1e7
FileDes pprzLogFile
Definition: sdlog_chibios.c:85
uint32_t iTOW
Definition: gps.h:122
#define GPS_UBX_ERR_MSG_TOO_LONG
Definition: gps_ubx.c:65
int32_t relPosD
Definition: gps.h:126
#define Min(x, y)
Definition: main_fbw.c:52
volatile uint32_t nb_sec_rem
remainder of seconds since startup in CPU_TICKS
Definition: sys_time.h:73
#define LED_TOGGLE(i)
Definition: led_hw.h:52
uint8_t send_ck_b
Definition: gps_ubx.h:64
int32_t relPosN
Definition: gps.h:124
bool msg_available
Definition: gps_ubx.h:55
uint8_t relPosValid
Definition: gps.h:134
uint8_t status
Definition: gps_ubx.h:60
struct GpsRelposNED gps_relposned
Definition: gps.c:78
static const struct usb_device_descriptor dev
Definition: usb_ser_hw.c:73
void gps_ubx_read_message(void)
Definition: gps_ubx.c:121
uint8_t status_flags
Definition: gps_ubx.h:68
int gps_ubx_ucenter_get_status(void)
int8_t relPosHPN
Definition: gps.h:127
uint32_t last_3dfix_time
cpu time in sec at last valid 3D fix
Definition: gps.h:107
int32_t alt
in millimeters (above WGS84 reference ellipsoid or above MSL)
uint32_t accE
Definition: gps.h:131
#define GOT_LEN1
Definition: gps_ubx.c:55
unsigned char uint8_t
Definition: types.h:14
#define GPS_UBX_ERR_OVERRUN
Definition: gps_ubx.c:64
int32_t course
GPS course over ground in rad*1e7, [0, 2*Pi]*1e7 (CW/north)
Definition: gps.h:93
#define GOT_PAYLOAD
Definition: gps_ubx.c:57
uint16_t MsgType
Definition: gps.h:141
uint8_t comp_id
id of current gps
Definition: gps.h:83
#define byte
volatile uint32_t nb_sec
full seconds since startup
Definition: sys_time.h:72
int32_t t0_tow_frac
fractional ns remainder of tow [ms], range -500000 .. 500000
Definition: gps.h:116
#define GPS_VALID_POS_ECEF_BIT
Definition: gps.h:48
data structures for GPS with RTK capabilities
Definition: gps.h:121
uint32_t accD
Definition: gps.h:132
struct GpsState state
Definition: gps_ubx.h:71
uint8_t flags
bitfield with GPS receiver specific flags
Definition: gps.h:73
uint32_t last_msg_ticks
cpu time ticks at last received GPS message
Definition: gps.h:108
#define GPS_VALID_POS_LLA_BIT
Definition: gps.h:49
#define GOT_LEN2
Definition: gps_ubx.c:56
uint8_t num_sv
number of sat in fix
Definition: gps.h:98
uint8_t gnssFixOK
Definition: gps.h:136
arch independent LED (Light Emitting Diodes) API
int32_t x
in centimeters
#define UNINIT
Includes macros generated from ubx.xml.
Definition: gps_ubx.c:50
uint32_t Cnt105
Definition: gps.h:142
uint16_t gspeed
norm of 2d ground speed in cm/s
Definition: gps.h:91
#define LED_ON(i)
Definition: led_hw.h:50
struct EcefCoor_i ecef_vel
speed ECEF in cm/s
Definition: gps.h:89
data structure for GPS time sync
Definition: gps.h:114
uint8_t send_ck_a
Definition: gps_ubx.h:64
#define GPS_VALID_VEL_ECEF_BIT
Definition: gps.h:51
uint32_t Crc177
Definition: gps.h:146
void gps_inject_data(uint8_t packet_id, uint8_t length, uint8_t *data)
Override the default GPS packet injector to inject the data trough UART.
Definition: gps_piksi.c:408
struct LlaCoor_i lla_pos
position in LLA (lat,lon: deg*1e7; alt: mm over ellipsoid)
Definition: gps.h:86
#define RTCM3_MSG_1005
Definition: rtcm3.h:20
void gps_ubx_msg(void)
Definition: gps_ubx.c:436
#define DEBUG_PRINT(...)
Definition: gps_ubx.c:43
uint32_t get_sys_time_usec(void)
Get the time in microseconds since startup.
Definition: sys_time_arch.c:68
int32_t lat
in degrees*1e7
uint8_t fix
status of fix
Definition: gps.h:99
uint8_t error_last
Definition: gps_ubx.h:66
#define GPS_VALID_POS_UTM_BIT
Definition: gps.h:50
#define GOT_SYNC1
Definition: gps_ubx.c:51
struct NedCoor_i ned_vel
speed NED in cm/s
Definition: gps.h:90
uint16_t RefStation
Definition: gps.h:140
#define GPS_UBX_ERR_NONE
Definition: gps_ubx.c:63
uint8_t msg_class
Definition: gps_ubx.h:58
uint8_t buff[25]
Buffer used for general comunication over SPI (in buffer)
uint16_t refStationId
Definition: gps.h:123
#define GPS_UBX_ERR_CHECKSUM
Definition: gps_ubx.c:66