Paparazzi UAS  v5.15_devel-46-gd23ed71
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);
158  gps_ubx.state.hacc = UBX_NAV_POSLLH_Hacc(gps_ubx.msg_buf);
159  gps_ubx.state.vacc = UBX_NAV_POSLLH_Vacc(gps_ubx.msg_buf);
161  gps_ubx.state.hmsl = UBX_NAV_POSLLH_HMSL(gps_ubx.msg_buf);
163  } else if (gps_ubx.msg_id == UBX_NAV_POSUTM_ID) {
164  gps_ubx.state.utm_pos.east = UBX_NAV_POSUTM_EAST(gps_ubx.msg_buf);
165  gps_ubx.state.utm_pos.north = UBX_NAV_POSUTM_NORTH(gps_ubx.msg_buf);
166  uint8_t hem = UBX_NAV_POSUTM_HEM(gps_ubx.msg_buf);
167  if (hem == UTM_HEM_SOUTH) {
168  gps_ubx.state.utm_pos.north -= 1000000000; /* Subtract false northing: -10000km */
169  }
170  gps_ubx.state.utm_pos.alt = UBX_NAV_POSUTM_ALT(gps_ubx.msg_buf) * 10;
171  gps_ubx.state.utm_pos.zone = UBX_NAV_POSUTM_ZONE(gps_ubx.msg_buf);
173 
176  } else if (gps_ubx.msg_id == UBX_NAV_VELNED_ID) {
177  gps_ubx.state.speed_3d = UBX_NAV_VELNED_Speed(gps_ubx.msg_buf);
178  gps_ubx.state.gspeed = UBX_NAV_VELNED_GSpeed(gps_ubx.msg_buf);
179  gps_ubx.state.ned_vel.x = UBX_NAV_VELNED_VEL_N(gps_ubx.msg_buf);
180  gps_ubx.state.ned_vel.y = UBX_NAV_VELNED_VEL_E(gps_ubx.msg_buf);
181  gps_ubx.state.ned_vel.z = UBX_NAV_VELNED_VEL_D(gps_ubx.msg_buf);
183  // Ublox gives I4 heading in 1e-5 degrees, apparenty from 0 to 360 degrees (not -180 to 180)
184  // I4 max = 2^31 = 214 * 1e5 * 100 < 360 * 1e7: overflow on angles over 214 deg -> casted to -214 deg
185  // solution: First to radians, and then scale to 1e-7 radians
186  // First x 10 for loosing less resolution, then to radians, then multiply x 10 again
187  gps_ubx.state.course = (RadOfDeg(UBX_NAV_VELNED_Heading(gps_ubx.msg_buf) * 10)) * 10;
189  gps_ubx.state.cacc = (RadOfDeg(UBX_NAV_VELNED_CAcc(gps_ubx.msg_buf) * 10)) * 10;
190  gps_ubx.state.tow = UBX_NAV_VELNED_ITOW(gps_ubx.msg_buf);
191  } else if (gps_ubx.msg_id == UBX_NAV_SVINFO_ID) {
192  gps_ubx.state.nb_channels = Min(UBX_NAV_SVINFO_NCH(gps_ubx.msg_buf), GPS_NB_CHANNELS);
193  uint8_t i;
194  for (i = 0; i < gps_ubx.state.nb_channels; i++) {
195  gps_ubx.state.svinfos[i].svid = UBX_NAV_SVINFO_SVID(gps_ubx.msg_buf, i);
196  gps_ubx.state.svinfos[i].flags = UBX_NAV_SVINFO_Flags(gps_ubx.msg_buf, i);
197  gps_ubx.state.svinfos[i].qi = UBX_NAV_SVINFO_QI(gps_ubx.msg_buf, i);
198  gps_ubx.state.svinfos[i].cno = UBX_NAV_SVINFO_CNO(gps_ubx.msg_buf, i);
199  gps_ubx.state.svinfos[i].elev = UBX_NAV_SVINFO_Elev(gps_ubx.msg_buf, i);
200  gps_ubx.state.svinfos[i].azim = UBX_NAV_SVINFO_Azim(gps_ubx.msg_buf, i);
201  }
202  } else if (gps_ubx.msg_id == UBX_NAV_STATUS_ID) {
203 #if !USE_GPS_UBX_RTCM
204  gps_ubx.state.fix = UBX_NAV_STATUS_GPSfix(gps_ubx.msg_buf);
205 #endif
206  gps_ubx.status_flags = UBX_NAV_STATUS_Flags(gps_ubx.msg_buf);
207  gps_ubx.sol_flags = UBX_NAV_SOL_Flags(gps_ubx.msg_buf);
208  } else if (gps_ubx.msg_id == UBX_NAV_RELPOSNED_ID) {
209 #if USE_GPS_UBX_RTCM
210  uint8_t version = UBX_NAV_RELPOSNED_VERSION(gps_ubx.msg_buf);
211  if (version == NAV_RELPOSNED_VERSION) {
212  gps_relposned.iTOW = UBX_NAV_RELPOSNED_ITOW(gps_ubx.msg_buf);
213  gps_relposned.refStationId = UBX_NAV_RELPOSNED_refStationId(gps_ubx.msg_buf);
214  gps_relposned.relPosN = UBX_NAV_RELPOSNED_RELPOSN(gps_ubx.msg_buf);
215  gps_relposned.relPosE = UBX_NAV_RELPOSNED_RELPOSE(gps_ubx.msg_buf);
216  gps_relposned.relPosD = UBX_NAV_RELPOSNED_RELPOSD(gps_ubx.msg_buf) ;
217  gps_relposned.relPosHPN = UBX_NAV_RELPOSNED_RELPOSNHP(gps_ubx.msg_buf);
218  gps_relposned.relPosHPE = UBX_NAV_RELPOSNED_RELPOSEHP(gps_ubx.msg_buf);
219  gps_relposned.relPosHPD = UBX_NAV_RELPOSNED_RELPOSDHP(gps_ubx.msg_buf);
220  gps_relposned.accN = UBX_NAV_RELPOSNED_Nacc(gps_ubx.msg_buf);
221  gps_relposned.accE = UBX_NAV_RELPOSNED_Eacc(gps_ubx.msg_buf);
222  gps_relposned.accD = UBX_NAV_RELPOSNED_Dacc(gps_ubx.msg_buf);
223  uint8_t flags = UBX_NAV_RELPOSNED_Flags(gps_ubx.msg_buf);
224  gps_relposned.carrSoln = RTCMgetbitu(&flags, 3, 2);
225  gps_relposned.relPosValid = RTCMgetbitu(&flags, 5, 1);
226  gps_relposned.diffSoln = RTCMgetbitu(&flags, 6, 1);
227  gps_relposned.gnssFixOK = RTCMgetbitu(&flags, 7, 1);
228  if (gps_relposned.gnssFixOK > 0) {
229  if (gps_relposned.diffSoln > 0) {
230  if (gps_relposned.carrSoln == 2) {
231  gps_ubx.state.fix = 5; // rtk
232  } else {
233  gps_ubx.state.fix = 4; // dgnss
234  }
235  } else {
236  gps_ubx.state.fix = 3; // 3D
237  }
238  } else {
239  gps_ubx.state.fix = 0;
240  }
241  DEBUG_PRINT("GNSS Fix OK: %i\tDGNSS: %i\tRTK: %i\trelPosValid: %i\trefStationId: %i\n", gps_relposned.gnssFixOK,
243  }
244 #endif // USE_GPS_UBX_RTCM
245  }
246  } else if (gps_ubx.msg_class == UBX_RXM_ID) {
247  if (gps_ubx.msg_id == UBX_RXM_RAW_ID) {
248 #if USE_GPS_UBX_RXM_RAW
249  gps_ubx_raw.iTOW = UBX_RXM_RAW_iTOW(gps_ubx.msg_buf);
250  gps_ubx_raw.week = UBX_RXM_RAW_week(gps_ubx.msg_buf);
251  gps_ubx_raw.numSV = UBX_RXM_RAW_numSV(gps_ubx.msg_buf);
252  uint8_t i;
253  uint8_t max_SV = Min(gps_ubx_raw.numSV, GPS_UBX_NB_CHANNELS);
254  for (i = 0; i < max_SV; i++) {
255  gps_ubx_raw.measures[i].cpMes = UBX_RXM_RAW_cpMes(gps_ubx.msg_buf, i);
256  gps_ubx_raw.measures[i].prMes = UBX_RXM_RAW_prMes(gps_ubx.msg_buf, i);
257  gps_ubx_raw.measures[i].doMes = UBX_RXM_RAW_doMes(gps_ubx.msg_buf, i);
258  gps_ubx_raw.measures[i].sv = UBX_RXM_RAW_sv(gps_ubx.msg_buf, i);
259  gps_ubx_raw.measures[i].mesQI = UBX_RXM_RAW_mesQI(gps_ubx.msg_buf, i);
260  gps_ubx_raw.measures[i].cno = UBX_RXM_RAW_cno(gps_ubx.msg_buf, i);
261  gps_ubx_raw.measures[i].lli = UBX_RXM_RAW_lli(gps_ubx.msg_buf, i);
262  }
263 #endif // USE_GPS_UBX_RXM_RAW
264  } else if (gps_ubx.msg_id == UBX_RXM_RTCM_ID) {
265 #if USE_GPS_UBX_RTCM
266  uint8_t version = UBX_RXM_RTCM_version(gps_ubx.msg_buf);
267  if (version == RXM_RTCM_VERSION) {
268  // uint8_t flags = UBX_RXM_RTCM_flags(gps_ubx.msg_buf);
269  // bool crcFailed = RTCMgetbitu(&flags, 7, 1);
270  // uint16_t refStation = UBX_RXM_RTCM_refStation(gps_ubx.msg_buf);
271  // uint16_t msgType = UBX_RXM_RTCM_msgType(gps_ubx.msg_buf);
272  // DEBUG_PRINT("Message %i from refStation %i processed (CRCfailed: %i)\n", msgType, refStation, crcFailed);
273 
274  rtcm_man.RefStation = UBX_RXM_RTCM_refStation(gps_ubx.msg_buf);
275  rtcm_man.MsgType = UBX_RXM_RTCM_msgType(gps_ubx.msg_buf);
276  uint8_t flags = UBX_RXM_RTCM_flags(gps_ubx.msg_buf);
277  bool crcFailed = RTCMgetbitu(&flags, 7, 1);
278  switch (rtcm_man.MsgType) {
279  case 1005:
280  rtcm_man.Cnt105 += 1;
281  rtcm_man.Crc105 += crcFailed;
282  break;
283  case 1077:
284  rtcm_man.Cnt177 += 1;
285  rtcm_man.Crc177 += crcFailed;;
286  break;
287  case 1087:
288  rtcm_man.Cnt187 += 1;
289  rtcm_man.Crc187 += crcFailed;;
290  break;
291  default:
292  break;
293  }
294  } else {
295  DEBUG_PRINT("Unknown RXM_RTCM version: %i\n", version);
296  }
297 #endif // USE_GPS_UBX_RTCM
298  }
299  }
300 }
301 
302 #if LOG_RAW_GPS
304 #endif
305 
306 /* UBX parsing */
308 {
309 #if LOG_RAW_GPS
310  sdLogWriteByte(pprzLogFile, c);
311 #endif
312  if (gps_ubx.status < GOT_PAYLOAD) {
313  gps_ubx.ck_a += c;
315  }
316  switch (gps_ubx.status) {
317  case UNINIT:
318  if (c == UBX_SYNC1) {
319  gps_ubx.status++;
320  }
321  break;
322  case GOT_SYNC1:
323  if (c != UBX_SYNC2) {
325  goto error;
326  }
327  gps_ubx.ck_a = 0;
328  gps_ubx.ck_b = 0;
329  gps_ubx.status++;
330  break;
331  case GOT_SYNC2:
332  if (gps_ubx.msg_available) {
333  /* Previous message has not yet been parsed: discard this one */
335  goto error;
336  }
337  gps_ubx.msg_class = c;
338  gps_ubx.status++;
339  break;
340  case GOT_CLASS:
341  gps_ubx.msg_id = c;
342  gps_ubx.status++;
343  break;
344  case GOT_ID:
345  gps_ubx.len = c;
346  gps_ubx.status++;
347  break;
348  case GOT_LEN1:
349  gps_ubx.len |= (c << 8);
352  goto error;
353  }
354  gps_ubx.msg_idx = 0;
355  gps_ubx.status++;
356  break;
357  case GOT_LEN2:
359  gps_ubx.msg_idx++;
360  if (gps_ubx.msg_idx >= gps_ubx.len) {
361  gps_ubx.status++;
362  }
363  break;
364  case GOT_PAYLOAD:
365  if (c != gps_ubx.ck_a) {
367  goto error;
368  }
369  gps_ubx.status++;
370  break;
371  case GOT_CHECKSUM1:
372  if (c != gps_ubx.ck_b) {
374  goto error;
375  }
376  gps_ubx.msg_available = true;
377  goto restart;
378  break;
379  default:
381  goto error;
382  }
383  return;
384 error:
385  gps_ubx.error_cnt++;
386 restart:
388  return;
389 }
390 
391 static void ubx_send_1byte(struct link_device *dev, uint8_t byte)
392 {
393  dev->put_byte(dev->periph, 0, byte);
396 }
397 
398 void ubx_header(struct link_device *dev, uint8_t nav_id, uint8_t msg_id, uint16_t len)
399 {
400  dev->put_byte(dev->periph, 0, UBX_SYNC1);
401  dev->put_byte(dev->periph, 0, UBX_SYNC2);
402  gps_ubx.send_ck_a = 0;
403  gps_ubx.send_ck_b = 0;
404  ubx_send_1byte(dev, nav_id);
405  ubx_send_1byte(dev, msg_id);
406  ubx_send_1byte(dev, (uint8_t)(len&0xFF));
407  ubx_send_1byte(dev, (uint8_t)(len>>8));
408 }
409 
410 void ubx_trailer(struct link_device *dev)
411 {
412  dev->put_byte(dev->periph, 0, gps_ubx.send_ck_a);
413  dev->put_byte(dev->periph, 0, gps_ubx.send_ck_b);
414  dev->send_message(dev->periph, 0);
415 }
416 
417 void ubx_send_bytes(struct link_device *dev, uint8_t len, uint8_t *bytes)
418 {
419  int i;
420  for (i = 0; i < len; i++) {
421  ubx_send_1byte(dev, bytes[i]);
422  }
423 }
424 
425 void ubx_send_cfg_rst(struct link_device *dev, uint16_t bbr , uint8_t reset_mode)
426 {
427 #ifdef UBX_GPS_LINK
428  UbxSend_CFG_RST(dev, bbr, reset_mode, 0x00);
429 #endif /* else less harmful for HITL */
430 }
431 
432 #ifndef GPS_UBX_UCENTER
433 #define gps_ubx_ucenter_event() {}
434 #else
436 #endif
437 
438 void gps_ubx_msg(void)
439 {
440  // current timestamp
441  uint32_t now_ts = get_sys_time_usec();
442 
447  if (gps_ubx.msg_class == UBX_NAV_ID &&
448  (gps_ubx.msg_id == UBX_NAV_VELNED_ID ||
449  (gps_ubx.msg_id == UBX_NAV_SOL_ID &&
451  if (gps_ubx.state.fix >= GPS_FIX_3D) {
454  }
455  AbiSendMsgGPS(GPS_UBX_ID, now_ts, &gps_ubx.state);
456  }
457  gps_ubx.msg_available = false;
458 }
459 
460 /*
461  * Write bytes to the ublox UART connection
462  * This is a wrapper functions used in the librtcm library
463  */
464 void gps_ublox_write(struct link_device *dev, uint8_t *buff, uint32_t n);
465 void gps_ublox_write(struct link_device *dev, uint8_t *buff, uint32_t n)
466 {
467  uint32_t i = 0;
468  for (i = 0; i < n; i++) {
469  dev->put_byte(dev->periph, 0, buff[i]);
470  }
471  dev->send_message(dev->periph, 0);
472  return;
473 }
474 
478 #if USE_GPS_UBX_RTCM
479 void gps_inject_data(uint8_t packet_id, uint8_t length, uint8_t *data)
480 {
481  uint8_t i;
482 
483  // nothing to do
484  if (length == 0) {
485  return;
486  }
487 
488 #ifdef GPS_UBX_UCENTER
489  // not ready
490  if (gps_ubx_ucenter_get_status() != 0) {
491  return;
492  }
493 #endif
494 
495  // go through buffer
496  for (i = 0; i < length; i++) {
497  if (rtcm.nbyte == 0) {
498  // wait for frame start byte
499  if (data[i] == RTCM3_PREAMBLE) {
500  rtcm.buff[rtcm.nbyte++] = data[i];
501  }
502  } else {
503  // fill buffer
504  if (rtcm.nbyte < INJECT_BUFF_SIZE) {
505  rtcm.buff[rtcm.nbyte++] = data[i];
506  if (rtcm.nbyte == 3) {
507  // extract length
508  rtcm.len = RTCMgetbitu(rtcm.buff, 14, 10) + 3;
509  } else {
510  // wait complete frame
511  if (rtcm.nbyte == rtcm.len + 3) {
512  // check CRC
513  unsigned int crc1 = crc24q(rtcm.buff, rtcm.len);
514  unsigned int crc2 = RTCMgetbitu(rtcm.buff, rtcm.len * 8, 24);
515 
516  if (crc1 == crc2) {
517  // write to GPS
518  gps_ublox_write(&(UBX_GPS_LINK).device, rtcm.buff, rtcm.len + 3);
519  switch (packet_id) {
520  case RTCM3_MSG_1005 : break;
521  case RTCM3_MSG_1077 : break;
522  case RTCM3_MSG_1087 : break;
523  default: DEBUG_PRINT("Unknown type: %i", packet_id); break;
524  }
525  } else {
526  DEBUG_PRINT("Skipping message %i (CRC failed) - %d", packet_id, rtcm.buff[0]);
527  unsigned int j;
528  for (j = 1; j < rtcm.len; j++) {
529  DEBUG_PRINT(",%d", rtcm.buff[j]);
530  }
531  DEBUG_PRINT("\n");
532  }
533 
534  // reset index
535  rtcm.nbyte = 0;
536  }
537  }
538  } else {
539  // reset index
540  rtcm.nbyte = 0;
541  }
542  }
543  }
544 }
545 
546 #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:117
int32_t north
in centimeters
struct SVinfo svinfos[GPS_NB_CHANNELS]
holds information from the Space Vehicles (Satellites)
Definition: gps.h:106
int16_t azim
azimuth in deg
Definition: gps.h:77
#define Min(x, y)
Definition: esc_dshot.c:85
#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:410
#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:417
#define gps_ubx_ucenter_event()
Definition: gps_ubx.c:433
void gps_ubx_event(void)
Definition: gps_ubx.c:109
uint8_t nb_channels
Number of scanned satellites.
Definition: gps.h:105
uint32_t Cnt187
Definition: gps.h:146
uint32_t t0_ticks
hw clock ticks when GPS message is received
Definition: gps.h:119
#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:135
uint32_t hacc
horizontal accuracy in cm
Definition: gps.h:95
uint16_t week
GPS week.
Definition: gps.h:102
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:307
int32_t relPosE
Definition: gps.h:127
#define GPS_UBX_ID
Main include for ABI (AirBorneInterface).
uint32_t vacc
vertical accuracy in cm
Definition: gps.h:96
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:131
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:391
uint8_t diffSoln
Definition: gps.h:137
uint32_t Crc187
Definition: gps.h:149
#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:108
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:132
uint32_t sacc
speed accuracy in cm/s
Definition: gps.h:97
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:111
uint32_t cacc
course accuracy in rad*1e7
Definition: gps.h:98
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:130
uint32_t Crc105
Definition: gps.h:147
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:103
uint32_t Cnt177
Definition: gps.h:145
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:465
uint16_t pdop
position dilution of precision scaled by 100
Definition: gps.h:99
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:398
#define RTCM3_MSG_1087
Definition: rtcm3.h:22
bool safeToInject
Definition: gps_ubx.c:96
int32_t x
North.
Definition: gps.h:141
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:425
#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:124
#define GPS_UBX_ERR_MSG_TOO_LONG
Definition: gps_ubx.c:65
int32_t relPosD
Definition: gps.h:128
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:126
bool msg_available
Definition: gps_ubx.h:55
uint8_t relPosValid
Definition: gps.h:136
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:129
uint32_t last_3dfix_time
cpu time in sec at last valid 3D fix
Definition: gps.h:109
int32_t alt
in millimeters (above WGS84 reference ellipsoid or above MSL)
uint32_t accE
Definition: gps.h:133
#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:143
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:118
#define GPS_VALID_POS_ECEF_BIT
Definition: gps.h:48
data structures for GPS with RTK capabilities
Definition: gps.h:123
uint32_t accD
Definition: gps.h:134
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:110
#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:100
uint8_t gnssFixOK
Definition: gps.h:138
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:144
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:116
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:148
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:438
#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:101
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:142
#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:125
#define GPS_UBX_ERR_CHECKSUM
Definition: gps_ubx.c:66