1.摘要
GPS模块使用串口通信，那么它的的数据处理本质上还是串口通信处理，只是GPS模块的输出的有其特定的格式，需要字符串处理逻辑来解析其含义。如何高效的处理从GPS模块接收到的数据帧，是GPS驱动设计的重点，本文使用状态机的思想来处理GPS输出的串口数据流，相对于定时从串口环形bufer取数据包然后依次解析有更高的实时性并且单片机负荷更低。
2. GPS数据协议简介
常用的GPS模块大多采用NMEA-0183 协议，目前业已成了GPS导航设备统一的RTCM（Radio Technical Commission for Maritime services）标准协议。NMEA-0183 是美国国家海洋电子协会(National Marine Electronics Association)所指定的标准规格，这一标准制订所有航海电子仪器间的通讯标准，其中包含传输资料的格式以及传输资料的通讯协议。
GPS数据格式如下：
帧格式形如：$aaccc,ddd,ddd,?,ddd*hh(CR)(LF)
1、“$”：帧命令起始位
2、aaccc：地址域，前两位为识别符（aa），后三位为语句名（ccc）
3、ddd?ddd：数据
4、“*”：校验和前缀（也可以作为语句数据结束的标志）
5、hh：校验和，$与*之间所有字符ASCII码的校验和（各字节做异或运算，得到
校验和后，再转换16进制格式的ASCII字符）
6、(CR)(LF)：帧结束，回车和换行符
可以从串口抓数据帧：
$GPGSV,2,2,08,21,15,076,,23,52,270,,26,50,050,,27,52,179,*7D$GPRMC,132043.00,V,,,,,,,120116,,,N*7F$GPGSA,A,1,,,,,,,,,,,,,99.99,99.99,99.99*30$GPRMC,133308.00,A,3949.63002,N,11616.48641,E,1.101,,120116,,,A*70
3. GPS状态机接收
一般的应用中我们最关心的数据是GPRMC，即推荐定位信息。我们常见GPS数据接收方法主要是串口中断法，串口中断一直开着，然后定时从中断中取一包数据，解析这包数据，找到定位信息，常见的主要是找到GPRMC帧。
这有几个问题。
1. 一般而言，中断数据很快，而数据处理过程会发生丢接收中断。
2. 为了避免丢数据，可以使用双buffer来处理，读数据时候就把这个buffer锁定，然后再来了中断数据就往另外一个buffer放。
3. 如果取数据时刻刚好是一个有效定位信息，那么切换到第二个buffer后，就导致一条帧分成2份，两个buffer中该数据帧都不完整。
4.代码结构不清晰，应用层收到的数据可能不是完整的一条帧。
基于以上几点，改进方法使用状态机来接收，可以每次完整的给应用层发送一帧数据。
并且不需要关闭串口中断，接收过程一直进行。
接收到一个完整帧后就往上层送一次，上层负责解释数据的含义。
下面是在stm32平台上的接收GPS数据的处理过程。
1 //gps receive gps_state machine.
2 #define Start 0// $
3 #define G 1
4 #define P 2
5 #define R 3
6 #define M 4
7 #define C 5
8 #define Data 6
9 #define Check0 7 // *
10 #define Check1 8// *
11 void UART4_IRQHandler(void)
12 {
13 static uint8_t len = 0;
14 static uint8_t crc = 0;
15 static GPS_MSG_T GpsMsg;
16 uint8_t data = 0;
17 uint8_t tmp_flg = 0;
18 //$GPRMC,144601.00,A,3916.72973,N,11706.60267,E,0.719,,180117,,,A*76
19 if (USART_GetITStatus(GPS_UART, USART_IT_RXNE) != RESET)
20 {
21 data = (uint8_t)USART_ReceiveData(GPS_UART);
22
23 switch(gps_state) // find GPRMC
24 {
25 case Start:
26 if(data == ‘$‘) {
27 gps_state = G;
28 len = 0;
29 GpsMsg.maxLen = MaxGPSMsgLen;
30 memset(GpsMsg.buffer, 0, GpsMsg.maxLen);
31 GpsMsg.buffer[len++] = data;
32 crc = 0;
33 }
34 else gps_state = Start;
35 break;
36 case G:
37 if(data == ‘G‘){
38 gps_state = P;
39 GpsMsg.buffer[len++] = data;
40 crc ^= data;
41 }
42 else gps_state = Start;
43 break;
44 case P:
45 if(data == ‘P‘){
46 gps_state = R;
47 GpsMsg.buffer[len++] = data;
48 crc ^= data;
49 }
50 else gps_state = Start;
51 break;
52 case R:
53 if(data == ‘R‘){
54 gps_state = M;
55 GpsMsg.buffer[len++] = data;
56 crc ^= data;
57 }
58 else gps_state = Start;
59 break;
60 case M:
61 if(data == ‘M‘){
62 gps_state = C;
63 GpsMsg.buffer[len++] = data;
64 crc ^= data;
65 }
66 else gps_state = Start;
67 break;
68 case C:
69 if(data == ‘C‘){
70 gps_state = Data;
71 GpsMsg.buffer[len++] = data;
72 crc ^= data;
73 }
74 else gps_state = Start;
75 break;
76 case Data:
77 if(data == ‘*‘){
78 gps_state = Check0;
79 GpsMsg.buffer[len++] = data;
80 }
81 else{
82 gps_state = Data;
83 GpsMsg.buffer[len++] = data;
84 crc ^= data;
85 if(len>GpsMsg.maxLen) gps_state = Start;
86 }
87 break;
88
89 case Check0:
90 gps_state = Check1;
91 GpsMsg.buffer[len++] = data;
92 break;
93 case Check1: //*hh
94 gps_state = Start;
95 GpsMsg.buffer[len++] = data;
96 if(crc == ((GpsMsg.buffer[len-2]-‘0‘)*16 + (GpsMsg.buffer[len-1]-‘0‘)))
97 {
98 GpsMsg.buffer[len++] = ‘\r‘;
99 GpsMsg.buffer[len] = ‘\n‘;
100 GpsMsg.length = len;
101 //send to gps task
102 xQueueSendFromISR(GpsQueue, (void *) &GpsMsg, 0 );
103 }
104 }
105
106 USART_ClearITPendingBit(GPS_UART, USART_IT_RXNE);
107 }113 }
这段代码完成4个功能。1）串口接收数据；2）状态机切换；3）数据校验；4）把通过校验的数据发给应用层。
4. GPS数据解析
应用层已经收到数据了，剩下的工作就是字符串解析了。如果只关注GPRMC信息的话，上面已经做了校验，出错的概率极小，那么应用层就可以直接从收到的数据帧里提取经纬度了。
如果希望数据全部都处理，那么在串口接收部分就不能只保留GPRMC信息，应该全部都保留然后发给应用层，应用层解析数据帧。这里给出一个开源的例子，其中使用了多个c标准库字符处理函数，优点是通用性强功能完备，当然在嵌入式中可能比较占内存，如果资源紧张可以自己写该部分处理逻辑。
10
11 /*! \file tok.h */
12
13 //#include "nmea/tok.h"
14 #include "tok.h"
15 #include <stdarg.h>
16 #include <stdlib.h>
17 #include <stdio.h>
18 #include <ctype.h>
19 #include <string.h>
20 #include <limits.h>
21 //#include "config.h"
22
23 #define NMEA_TOKS_COMPARE (1)
24 #define NMEA_TOKS_PERCENT (2)
25 #define NMEA_TOKS_WIDTH (3)
26 #define NMEA_TOKS_TYPE (4)
27
28 /**
29 * \brief Calculate control sum of binary buffer
30 */
31 int nmea_calc_crc(const char *buff, int buff_sz)
32 {
33 int chsum = 0,
34 it;
35
36 for(it = 0; it < buff_sz; ++it)
37 chsum ^= (int)buff[it];
38
39 return chsum;
40 }
41
42 /**
43 * \brief Convert string to number
44 */
45 int nmea_atoi(const char *str, int str_sz, int radix)
46 {
47 char *tmp_ptr;
48 char buff[NMEA_CONVSTR_BUF];
49 int res = 0;
50
51 if(str_sz < NMEA_CONVSTR_BUF)
52 {
53 memcpy(&buff[0], str, str_sz);
54 buff[str_sz] = ‘\0‘;
55 res = strtol(&buff[0], &tmp_ptr, radix);
56 }
57
58 return res;
59 }
60
61 /**
62 * \brief Convert string to fraction number
63 */
64 double nmea_atof(const char *str, int str_sz)
65 {
66 char *tmp_ptr;
67 char buff[NMEA_CONVSTR_BUF];
68 double res = 0;
69
70 if(str_sz < NMEA_CONVSTR_BUF)
71 {
72 memcpy(&buff[0], str, str_sz);
73 buff[str_sz] = ‘\0‘;
74 res = strtod(&buff[0], &tmp_ptr);
75 }
76
77 return res;
78 }
79
80 /**
81 * \brief Analyse string (specificate for NMEA sentences)
82 */
83 int nmea_scanf(const char *buff, int buff_sz, const char *format, ...)
84 {
85 const char *beg_tok;
86 const char *end_buf = buff + buff_sz;
87
88 va_list arg_ptr;
89 int tok_type = NMEA_TOKS_COMPARE;
90 int width = 0;
91 const char *beg_fmt = 0;
92 int snum = 0, unum = 0;
93
94 int tok_count = 0;
95 void *parg_target;
96
97 va_start(arg_ptr, format);
98
99 for(; *format && buff < end_buf; ++format)
100 {
101 switch(tok_type)
102 {
103 case NMEA_TOKS_COMPARE:
104 if(‘%‘ == *format)
105 tok_type = NMEA_TOKS_PERCENT;
106 else if(*buff++ != *format)
107 goto fail;
108 break;
109 case NMEA_TOKS_PERCENT:
110 width = 0;
111 beg_fmt = format;
112 tok_type = NMEA_TOKS_WIDTH;
113 case NMEA_TOKS_WIDTH:
114 if(isdigit(*format))
115 break;
116 {
117 tok_type = NMEA_TOKS_TYPE;
118 if(format > beg_fmt)
119 width = nmea_atoi(beg_fmt, (int)(format - beg_fmt), 10);
120 }
121 case NMEA_TOKS_TYPE:
122 beg_tok = buff;
123
124 if(!width && (‘c‘ == *format || ‘C‘ == *format) && *buff != format[1])
125 width = 1;
126
127 if(width)
128 {
129 if(buff + width <= end_buf)
130 buff += width;
131 else
132 goto fail;
133 }
134 else
135 {
136 if(!format[1] || (0 == (buff = (char *)memchr(buff, format[1], end_buf - buff))))
137 buff = end_buf;
138 }
139
140 if(buff > end_buf)
141 goto fail;
142
143 tok_type = NMEA_TOKS_COMPARE;
144 tok_count++;
145
146 parg_target = 0; width = (int)(buff - beg_tok);
147
148 switch(*format)
149 {
150 case ‘c‘:
151 case ‘C‘:
152 parg_target = (void *)va_arg(arg_ptr, char *);
153 if(width && 0 != (parg_target))
154 *((char *)parg_target) = *beg_tok;
155 break;
156 case ‘s‘:
157 case ‘S‘:
158 parg_target = (void *)va_arg(arg_ptr, char *);
159 if(width && 0 != (parg_target))
160 {
161 memcpy(parg_target, beg_tok, width);
162 ((char *)parg_target)[width] = ‘\0‘;
163 }
164 break;
165 case ‘f‘:
166 case ‘g‘:
167 case ‘G‘:
168 case ‘e‘:
169 case ‘E‘:
170 parg_target = (void *)va_arg(arg_ptr, double *);
171 if(width && 0 != (parg_target))
172 *((double *)parg_target) = nmea_atof(beg_tok, width);
173 break;
174 };
175
176 if(parg_target)
177 break;
178 if(0 == (parg_target = (void *)va_arg(arg_ptr, int *)))
179 break;
180 if(!width)
181 break;
182
183 switch(*format)
184 {
185 case ‘d‘:
186 case ‘i‘:
187 snum = nmea_atoi(beg_tok, width, 10);
188 memcpy(parg_target, &snum, sizeof(int));
189 break;
190 case ‘u‘:
191 unum = nmea_atoi(beg_tok, width, 10);
192 memcpy(parg_target, &unum, sizeof(unsigned int));
193 break;
194 case ‘x‘:
195 case ‘X‘:
196 unum = nmea_atoi(beg_tok, width, 16);
197 memcpy(parg_target, &unum, sizeof(unsigned int));
198 break;
199 case ‘o‘:
200 unum = nmea_atoi(beg_tok, width, 8);
201 memcpy(parg_target, &unum, sizeof(unsigned int));
202 break;
203 default:
204 goto fail;
205 };
206
207 break;
208 };
209 }
210
211 fail:
212
213 va_end(arg_ptr);
214
215 return tok_count;
216 }
10
11 #ifndef __TOK_H__
12 #define __TOK_H__
13
14 //#include "config.h"
15
16 #ifdef __cplusplus
17 extern "C" {
18 #endif
19
20 #define NMEA_CONVSTR_BUF (256)
21
22 int nmea_calc_crc(const char *buff, int buff_sz);
23 int nmea_atoi(const char *str, int str_sz, int radix);
24 double nmea_atof(const char *str, int str_sz);
25 int nmea_printf(char *buff, int buff_sz, const char *format, ...);
26 int nmea_scanf(const char *buff, int buff_sz, const char *format, ...);
27
28 #ifdef __cplusplus
29 }
30 #endif
31
32 #endif /* __NMEA_TOK_H__ */
时间： 2024-11-10 01:34:54