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数据的处理过程。
//gps receive gps_state machine.
#define Start 0// $
#define G 1
#define P 2
#define R 3
#define M 4
#define C 5
#define Data 6
#define Check0 7 // *
#define Check1 8// *
void UART4_IRQHandler(void)
{
static uint8_t len = ;
static uint8_t crc = ;
static GPS_MSG_T GpsMsg;
uint8_t data = ;
uint8_t tmp_flg = ;
//$GPRMC,144601.00,A,3916.72973,N,11706.60267,E,0.719,,180117,,,A*76
if (USART_GetITStatus(GPS_UART, USART_IT_RXNE) != RESET)
{
data = (uint8_t)USART_ReceiveData(GPS_UART); switch(gps_state) // find GPRMC
{
case Start:
if(data == '$') {
gps_state = G;
len = ;
GpsMsg.maxLen = MaxGPSMsgLen;
memset(GpsMsg.buffer, , GpsMsg.maxLen);
GpsMsg.buffer[len++] = data;
crc = ;
}
else gps_state = Start;
break;
case G:
if(data == 'G'){
gps_state = P;
GpsMsg.buffer[len++] = data;
crc ^= data;
}
else gps_state = Start;
break;
case P:
if(data == 'P'){
gps_state = R;
GpsMsg.buffer[len++] = data;
crc ^= data;
}
else gps_state = Start;
break;
case R:
if(data == 'R'){
gps_state = M;
GpsMsg.buffer[len++] = data;
crc ^= data;
}
else gps_state = Start;
break;
case M:
if(data == 'M'){
gps_state = C;
GpsMsg.buffer[len++] = data;
crc ^= data;
}
else gps_state = Start;
break;
case C:
if(data == 'C'){
gps_state = Data;
GpsMsg.buffer[len++] = data;
crc ^= data;
}
else gps_state = Start;
break;
case Data:
if(data == '*'){
gps_state = Check0;
GpsMsg.buffer[len++] = data;
}
else{
gps_state = Data;
GpsMsg.buffer[len++] = data;
crc ^= data;
if(len>GpsMsg.maxLen) gps_state = Start;
}
break; case Check0:
gps_state = Check1;
GpsMsg.buffer[len++] = data;
break;
case Check1: //*hh
gps_state = Start;
GpsMsg.buffer[len++] = data;
if(crc == ((GpsMsg.buffer[len-]-'')* + (GpsMsg.buffer[len-]-'')))
{
GpsMsg.buffer[len++] = '\r';
GpsMsg.buffer[len] = '\n';
GpsMsg.length = len;
//send to gps task
xQueueSendFromISR(GpsQueue, (void *) &GpsMsg, );
}
} USART_ClearITPendingBit(GPS_UART, USART_IT_RXNE);
}
}
这段代码完成4个功能。1）串口接收数据；2）状态机切换；3）数据校验；4）把通过校验的数据发给应用层。
4. GPS数据解析
应用层已经收到数据了，剩下的工作就是字符串解析了。如果只关注GPRMC信息的话，上面已经做了校验，出错的概率极小，那么应用层就可以直接从收到的数据帧里提取经纬度了。
如果希望数据全部都处理，那么在串口接收部分就不能只保留GPRMC信息，应该全部都保留然后发给应用层，应用层解析数据帧。这里给出一个开源的例子，其中使用了多个c标准库字符处理函数，优点是通用性强功能完备，当然在嵌入式中可能比较占内存，如果资源紧张可以自己写该部分处理逻辑。
/*! \file tok.h */ //#include "nmea/tok.h"
#include "tok.h"
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>
//#include "config.h" #define NMEA_TOKS_COMPARE (1)
#define NMEA_TOKS_PERCENT (2)
#define NMEA_TOKS_WIDTH (3)
#define NMEA_TOKS_TYPE (4) /**
* \brief Calculate control sum of binary buffer
*/
int nmea_calc_crc(const char *buff, int buff_sz)
{
int chsum = ,
it; for(it = ; it < buff_sz; ++it)
chsum ^= (int)buff[it]; return chsum;
} /**
* \brief Convert string to number
*/
int nmea_atoi(const char *str, int str_sz, int radix)
{
char *tmp_ptr;
char buff[NMEA_CONVSTR_BUF];
int res = ; if(str_sz < NMEA_CONVSTR_BUF)
{
memcpy(&buff[], str, str_sz);
buff[str_sz] = '\0';
res = strtol(&buff[], &tmp_ptr, radix);
} return res;
} /**
* \brief Convert string to fraction number
*/
double nmea_atof(const char *str, int str_sz)
{
char *tmp_ptr;
char buff[NMEA_CONVSTR_BUF];
double res = ; if(str_sz < NMEA_CONVSTR_BUF)
{
memcpy(&buff[], str, str_sz);
buff[str_sz] = '\0';
res = strtod(&buff[], &tmp_ptr);
} return res;
} /**
* \brief Analyse string (specificate for NMEA sentences)
*/
int nmea_scanf(const char *buff, int buff_sz, const char *format, ...)
{
const char *beg_tok;
const char *end_buf = buff + buff_sz; va_list arg_ptr;
int tok_type = NMEA_TOKS_COMPARE;
int width = ;
const char *beg_fmt = ;
int snum = , unum = ; int tok_count = ;
void *parg_target; va_start(arg_ptr, format); for(; *format && buff < end_buf; ++format)
{
switch(tok_type)
{
case NMEA_TOKS_COMPARE:
if('%' == *format)
tok_type = NMEA_TOKS_PERCENT;
else if(*buff++ != *format)
goto fail;
break;
case NMEA_TOKS_PERCENT:
width = ;
beg_fmt = format;
tok_type = NMEA_TOKS_WIDTH;
case NMEA_TOKS_WIDTH:
if(isdigit(*format))
break;
{
tok_type = NMEA_TOKS_TYPE;
if(format > beg_fmt)
width = nmea_atoi(beg_fmt, (int)(format - beg_fmt), );
}
case NMEA_TOKS_TYPE:
beg_tok = buff; if(!width && ('c' == *format || 'C' == *format) && *buff != format[])
width = ; if(width)
{
if(buff + width <= end_buf)
buff += width;
else
goto fail;
}
else
{
if(!format[] || ( == (buff = (char *)memchr(buff, format[], end_buf - buff))))
buff = end_buf;
} if(buff > end_buf)
goto fail; tok_type = NMEA_TOKS_COMPARE;
tok_count++; parg_target = ; width = (int)(buff - beg_tok); switch(*format)
{
case 'c':
case 'C':
parg_target = (void *)va_arg(arg_ptr, char *);
if(width && != (parg_target))
*((char *)parg_target) = *beg_tok;
break;
case 's':
case 'S':
parg_target = (void *)va_arg(arg_ptr, char *);
if(width && != (parg_target))
{
memcpy(parg_target, beg_tok, width);
((char *)parg_target)[width] = '\0';
}
break;
case 'f':
case 'g':
case 'G':
case 'e':
case 'E':
parg_target = (void *)va_arg(arg_ptr, double *);
if(width && != (parg_target))
*((double *)parg_target) = nmea_atof(beg_tok, width);
break;
}; if(parg_target)
break;
if( == (parg_target = (void *)va_arg(arg_ptr, int *)))
break;
if(!width)
break; switch(*format)
{
case 'd':
case 'i':
snum = nmea_atoi(beg_tok, width, );
memcpy(parg_target, &snum, sizeof(int));
break;
case 'u':
unum = nmea_atoi(beg_tok, width, );
memcpy(parg_target, &unum, sizeof(unsigned int));
break;
case 'x':
case 'X':
unum = nmea_atoi(beg_tok, width, );
memcpy(parg_target, &unum, sizeof(unsigned int));
break;
case 'o':
unum = nmea_atoi(beg_tok, width, );
memcpy(parg_target, &unum, sizeof(unsigned int));
break;
default:
goto fail;
}; break;
};
} fail: va_end(arg_ptr); return tok_count;
}
#ifndef __TOK_H__
#define __TOK_H__ //#include "config.h" #ifdef __cplusplus
extern "C" {
#endif #define NMEA_CONVSTR_BUF (256) int nmea_calc_crc(const char *buff, int buff_sz);
int nmea_atoi(const char *str, int str_sz, int radix);
double nmea_atof(const char *str, int str_sz);
int nmea_printf(char *buff, int buff_sz, const char *format, ...);
int nmea_scanf(const char *buff, int buff_sz, const char *format, ...); #ifdef __cplusplus
}
#endif #endif /* __NMEA_TOK_H__ */