无线模块使用

---

前言

  主要介绍蓝牙模块、GSM模块以及GPS模块通讯驱动的实现

---

一、蓝牙

1.1 蓝牙模块简介

  以HC05模块为例，实际上HC05是通过串口与单片机进行通讯的，HC05 蓝牙串口模块所有功能都是通过AT指令集控制，然后再通过串口将处理后的数据传给单片机。

  HC-05 嵌入式蓝牙串口通讯模块（以下简称模块）具有两种工作模式：命令响应工作模式和自动连接工作模式，在自动连接工作模式下模块又可分为主（Master）、从（Slave）和回环（Loopback）三种工作角色。当模块处于自动连接工作模式时，将自动根据事先设定的方式连接的数据传输；当模块处于命令响应工作模式时能执行下述所有 AT 命令，用户可向模块发送各种 AT 指令，为模块设定控制参数或发布控制命令。通过控制模块外部引脚（PIO11）输入电平，可以实现模块工作状态的动态转换。

  串口模块用到的引脚定义：

1、PIO8 连接 LED，指示模块工作状态，模块上电后闪烁，不同的状态闪烁间隔不同。
2、PIO9 连接LED，指示模块连接成功，蓝牙串口匹配连接成功后，LED 长亮。
3、PIO11 模块状态切换脚，高电平–>AT命令响应工作状态，低电平或悬空–>蓝牙常规工 作状态。
4、模块上已带有复位电路，重新上电即完成复位。

  设置为主模块的步骤：

1、PIO11 置高。
2、上电，模块进入 AT 命令响应状态。
3、超级终端或其他串口工具，设置波特率 38400，数据位 8 位，停止位 1 位，无校验位，无流控制。
4、串口发送字符“AT+ROLE=1\r\n”，成功返回“OK\r\n”，其中\r\n 为回车换行。
5、PIO 置低，重新上电，模块为主模块，自动搜索从模块，建立连接。

1.2 蓝牙常用AT指令集

  模块的指令结构为：AT+<=PARAM>，其中 CMD（指令）和 PARAM（参数）都是可选的，不过切记在发送末尾添加回车符（\r\n），否则模块不响应，比如我们要查看模块的版本：
  串口发送：AT+VERSION?\r\n
  模块回应：+VERSION:2.0-20100601
       OK
注意：AT 指令不区分大小写，均以回车、换行字符结尾：\r\n

1. 测试指令

指令	响应	参数
AT	OK	无

2. 模块复位（重启）

指令	响应	参数
AT+RESET	OK	无

3. 设置/查询—模块角色
   
     AT+ROLE=0 或 1，该指令来设置模块为从机或主机，并且可以通过 AT+ROLE?来查看模块的主从状态

模块角色说明：
  Slave(从角色)——被动连接；
  Slave-Loop(回环角色)——被动连接，接收远程蓝牙主设备数据并将数据原样返回给远程蓝牙主设备；
  Master（主角色）——查询周围 SPP 蓝牙从设备，并主动发起连接，从而建立主、从蓝牙设备间的透明数据传输通道。

4. 设置/查询—连接模式
   

5. 设置/查询—串口参数
   
   举例：AT+UART=9600,0,0，则是设置通信波特率为 9600，1 位停止位，没有校验位

6. 设置/查询—配对码
   
   该指令用于设置模块的配对密码，password 必须为 4 个字节长度

7. 修改蓝牙模块名字
   
   例如：AT+NAME=HC-05\r\n ——设置模块设备名为：“HC-05”

8. 初始化 SPP 规范库
   

9. 查询蓝牙设备

指令	响应	参数
AT+INQ	+INQ: < Param1>，< Param2>，< Param3>， OK	Param1：蓝牙地址；Param2：设备类；Param3：RSSI 信号强度

10. 设置/查询—查询访问模式
    
    举例：AT+INQM=1,9,48\r\n——查询模式设置：带 RSSI 信号强度指示，超过 9 个蓝牙设备响应则终止查询，设定超时为 48xl. 28=61.44 秒

11. 取消查询蓝牙设备

指令	响应	参数
AT+INQC	OK	无

12. 设备配对
    
13. 设备连接
    
14. 设置/查询—设备类
    

1.3 示例代码

1. usart函数
   因为蓝牙模块与单片机是通过串口通信的，所以要对串口进行配置，这里主要列举中断处理函数，以及发送函数

#include "usart3.h"
#include "stdio.h"	 	 
#include "string.h"	

#define USART3_MAX_RECV_LEN		400					//最大接收缓存字节数
#define USART3_MAX_SEND_LEN		400					//最大发送缓存字节数

//串口发送缓存区 	
__align(8) u8 USART3_TX_BUF[USART3_MAX_SEND_LEN]; 	//发送缓冲,最大USART3_MAX_SEND_LEN字节
	  
//串口接收缓存区 	
u8 USART3_RX_BUF[USART3_MAX_RECV_LEN]; 				//接收缓冲,最大USART3_MAX_RECV_LEN个字节.
	
u16 USART3_RX_STA=0; 
void USART3_IRQHandler(void)
{
    if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    {
    	res =USART_ReceiveData(USART3);		
		if((USART3_RX_STA&(1<<15))==0)//接收完的一批数据,还没有被处理,则不再接收其他数据
		{ 
			if(USART3_RX_STA<USART3_MAX_RECV_LEN)		//还可以接收数据
			{
				USART3_RX_BUF[USART3_RX_STA++]=res;		//记录接收到的值	 
			}
			else 
			{
				USART3_RX_STA|=1<<15;					//强制标记接收完成
				USART_ClearITPendingBit(USART3, USART_IT_RXNE);	
			} 
		} 
    }
					 
} 

//串口3,printf 函数
//确保一次发送数据不超过USART3_MAX_SEND_LEN字节
void u3_printf(char* fmt,...)  
{  
	u16 i,j;
	va_list ap;
	va_start(ap,fmt);
	vsprintf((char*)USART3_TX_BUF,fmt,ap);
	va_end(ap);
	i=strlen((const char*)USART3_TX_BUF);//此次发送数据的长度
	for(j=0;j<i;j++)//循环发送数据
	{
	  while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET);  //等待上次传输完成 
		USART_SendData(USART3,(uint8_t)USART3_TX_BUF[j]); 	 //发送数据到串口3 
	}
}

void usart3_init(u32 bound)
{  
	NVIC_InitTypeDef NVIC_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
 
	USART_DeInit(USART3);  //复位串口3
	
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE); //使能GPIOB时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);//使能USART3时钟
	
 
	 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11 | GPIO_Pin_10; //GPIOB11和GPIOB10初始化
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	//速度50MHz
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
	GPIO_Init(GPIOB,&GPIO_InitStructure); //初始化GPIOB11，和GPIOB10
	
	
	GPIO_PinAFConfig(GPIOB,GPIO_PinSource11,GPIO_AF_USART3); //GPIOB11复用为USART3
	GPIO_PinAFConfig(GPIOB,GPIO_PinSource10,GPIO_AF_USART3); //GPIOB10复用为USART3	  
	
	USART_InitStructure.USART_BaudRate = bound;//波特率一般设置为9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
	USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
	USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//收发模式
	USART_Init(USART3, &USART_InitStructure); //初始化串口3
	
	USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启中断  

	USART_Cmd(USART3, ENABLE);                    //使能串口 
	
 
	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;//抢占优先级2
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//子优先级3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
}

//清理接收缓存
void clean_rebuff(void)
{
	uint16_t i=USART3_MAX_RECV_LEN+1;
    uart_p = 0;
	while(i)
		USART3_RX_BUF[--i]=0;
}

  接收中断只是很常规的数据处理方式，当然也可以用定时器或者DMA实现。u3_printf函数里，我们使用vsprintf函数，这样可以避免重复使用sprintf字符串格式化函数

2. HC05函数

#include "usart3.h" 			 
#include "hc05.h" 
#include "string.h"	 
#include "math.h"

#define HC05_KEY  	PFout(6) 	//蓝牙控制KEY信号
#define HC05_LED  	PCin(0)		//蓝牙连接状态信号

//初始化ATK-HC05模块
//返回值:0,成功;1,失败.
u8 HC05_Init(void)
{
	u8 retry=10,t;	  		 
	u8 temp=1;
	
	GPIO_InitTypeDef GPIO_InitStructure;
 
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF|RCC_AHB1Periph_GPIOC, ENABLE);//使能GPIOC,GPIOF时钟
 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; //LED对应引脚
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;//普通输入模式
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100M
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
  GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC0
 
	
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;//KEY对应引脚
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
  GPIO_Init(GPIOF, &GPIO_InitStructure); //根据设定参数初始化PF6

	GPIO_SetBits(GPIOF,GPIO_Pin_6);
 	
	usart3_init(9600);	//初始化串口3为:9600,波特率.
	
	while(retry--)
	{
		HC05_KEY=1;					//KEY置高,进入AT模式
		delay_ms(10);
		u3_printf("AT\r\n");		//发送AT测试指令
		HC05_KEY=0;					//KEY拉低,退出AT模式
		for(t=0;t<10;t++) 			//最长等待50ms,来接收HC05模块的回应
		{
			if(USART3_RX_STA&0X8000)break;
			delay_ms(5);
		}		
		if(USART3_RX_STA&0X8000)	//接收到一次数据了
		{
			temp=USART3_RX_STA&0X7FFF;	//得到数据长度
			USART3_RX_STA=0;			 
			if(temp==4&&USART3_RX_BUF[0]=='O'&&USART3_RX_BUF[1]=='K')
			{
				temp=0;//接收到OK响应
				break;
			}
		}			    		
	}		    
	if(retry==0)temp=1;	//检测失败
	return temp;	 
}	 
//获取ATK-HC05模块的角色
//返回值:0,从机;1,主机;0XFF,获取失败.							  
u8 HC05_Get_Role(void)
{	 		    
	u8 retry=0X0F;
	u8 temp,t;
	while(retry--)
	{
		HC05_KEY=1;					//KEY置高,进入AT模式
		delay_ms(10);
		u3_printf("AT+ROLE?\r\n");	//查询角色
		for(t=0;t<20;t++) 			//最长等待200ms,来接收HC05模块的回应
		{
			delay_ms(10);
			if(USART3_RX_STA&0X8000)break;
		}		
		HC05_KEY=0;					//KEY拉低,退出AT模式
		if(USART3_RX_STA&0X8000)	//接收到一次数据了
		{
			temp=USART3_RX_STA&0X7FFF;	//得到数据长度
			USART3_RX_STA=0;			 
			if(temp==13&&USART3_RX_BUF[0]=='+')//接收到正确的应答了
			{
				temp=USART3_RX_BUF[6]-'0';//得到主从模式值
				break;
			}
		}		
	}
	if(retry==0)temp=0XFF;//查询失败.
	return temp;
} 							   
//ATK-HC05设置命令
//此函数用于设置ATK-HC05,适用于仅返回OK应答的AT指令
//atstr:AT指令串.比如:"AT+RESET"/"AT+UART=9600,0,0"/"AT+ROLE=0"等字符串
//返回值:0,设置成功;其他,设置失败.							  
u8 HC05_Set_Cmd(u8* atstr)
{	 		    
	u8 retry=0X0F;
	u8 temp,t;
	while(retry--)
	{
		HC05_KEY=1;					//KEY置高,进入AT模式
		delay_ms(10);
		u3_printf("%s\r\n",atstr);	//发送AT字符串
		HC05_KEY=0;					//KEY拉低,退出AT模式
		for(t=0;t<20;t++) 			//最长等待100ms,来接收HC05模块的回应
		{
			if(USART3_RX_STA&0X8000)break;
			delay_ms(5);
		}		
		if(USART3_RX_STA&0X8000)	//接收到一次数据了
		{
			temp=USART3_RX_STA&0X7FFF;	//得到数据长度
			USART3_RX_STA=0;			 
			if(temp==4&&USART3_RX_BUF[0]=='O')//接收到正确的应答了
			{			
				temp=0;
				break;			 
			}
		}		
	}
	if(retry==0)temp=0XFF;//设置失败.
	return temp;
} 
///
//通过该函数,可以利用USMART,调试接在串口3上的ATK-HC05模块
//str:命令串.(这里注意不再需要再输入回车符)
void HC05_CFG_CMD(u8 *str)
{					  
	u8 temp;
	u8 t;		  
	HC05_KEY=1;						//KEY置高,进入AT模式
	delay_ms(10);
	u3_printf("%s\r\n",(char*)str); //发送指令
	for(t=0;t<50;t++) 				//最长等待500ms,来接收HC05模块的回应
	{
		if(USART3_RX_STA&0X8000)break;
		delay_ms(10);
	}									    
	HC05_KEY=0;						//KEY拉低,退出AT模式
	if(USART3_RX_STA&0X8000)		//接收到一次数据了
	{
		temp=USART3_RX_STA&0X7FFF;	//得到数据长度
		USART3_RX_STA=0;
		USART3_RX_BUF[temp]=0;		//加结束符		 
		printf("\r\n%s",USART3_RX_BUF);//发送回应数据到串口1
	} 				 
}

此部分代码总共 4 个函数：

1，HC05_Init 函数，该函数用于初始化与 ATK-HC05 连接
的 IO 口，并通过 AT 指令检测 ATK-HC05 蓝牙模块是否已经连接。
2 ，HC05_Get_Role 函数，该函数用于获取 ATK-HC05 蓝牙模块的主从状态，这里利用 AT+ROLE?指令获取模块的主从状态。
3，HC05_Set_Cmd 函数，该函数是一个 ATK-HC05 蓝牙模块的通用设置指令，通过调用该函数，可以方便的修改ATK-HC05蓝牙串口模块的各种设置。
4，HC05_CFG_CMD函数，该函数专为 USMART 调试组件提供，专用于 USMART 测试 ATK-HC05 蓝牙串口模块的AT指令，在不需要USMART调试的时候，该函数可以去掉。注意要将HC05_CFG_CMD添加到 usmart_nametab 里面，才能通过 USMART 调用该函数哦！

3. 主函数

int main(void)
{ 
	u8 t;
	u8 key;
	u8 sendmask=0;
	u8 sendcnt=0;
	u8 sendbuf[20];	  
	u8 reclen=0;  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
	delay_init(168);      //初始化延时函数
	uart_init(115200);		//初始化串口波特率为115200
	
	usmart_dev.init(84); 		//初始化USMART		
	LED_Init();					//初始化LED
	KEY_Init();					//初始化按键

	delay_ms(1000);			//等待蓝牙模块上电稳定
 	while(HC05_Init()) 		//初始化ATK-HC05模块  
	{
		LED1=0;
		delay_ms(500);
		LED1=1;
		delay_ms(100);
	}	 										   	   

	delay_ms(100);
	USART3_RX_STA=0;
 	while(1) 
	{		
		key=KEY_Scan(0);
		if(key==WKUP_PRES)						//切换模块主从设置
		{
   			key=HC05_Get_Role();
			if(key!=0XFF)
			{
				key=!key;  					//状态取反	   
				if(key==0)HC05_Set_Cmd("AT+ROLE=0");
				else HC05_Set_Cmd("AT+ROLE=1");
				HC05_Set_Cmd("AT+RESET");	//复位ATK-HC05模块
				delay_ms(200);
			}
		}else if(key==KEY0_PRES)
		{
			sendmask=!sendmask;				//发送/停止发送  	 
		}else delay_ms(10);	   
		if(t==50)
		{
			if(sendmask)					//定时发送
			{
				sprintf((char*)sendbuf,"ALIENTEK HC05 %d\r\n",sendcnt);

				u3_printf("ALIENTEK HC05 %d\r\n",sendcnt);		//发送到蓝牙模块
				sendcnt++;
				if(sendcnt>99)sendcnt=0;
			}	  
			t=0;
			LED0=!LED0; 	     
		}	  
		if(USART3_RX_STA&0X8000)			//接收到一次数据了
		{
 			reclen=USART3_RX_STA&0X7FFF;	//得到数据长度
		  	USART3_RX_BUF[reclen]=0;	 	//加入结束符
			if(reclen==9||reclen==8) 		//控制DS1检测
			{
				if(strcmp((const char*)USART3_RX_BUF,"+LED1 ON")==0)LED1=0;	//打开LED1
				if(strcmp((const char*)USART3_RX_BUF,"+LED1 OFF")==0)LED1=1;//关闭LED1
			}

 			USART3_RX_STA=0;	 
		}	 															     				   
		t++;	
	}											    
}

注意：

①执行 INIT 命令，把模块初始化为蓝牙的 SPP 规范，只有执行了这个命令后，蓝牙模块才能进行扫描、配对、连接、串口透传等操作。

②若模块未处于连接状态，根据主模式或从模式进行不同的操作（上电后默认为从模式，按下WKUP_PRES 后，模块会进入主模式）。主模式下，尝试扫描周边的蓝牙设备，若找到“HC05”名字的设备则进行主动连接。从模式下，执行 INQ 命令，只有执行这个命令，HC05 模块才会向周边发射蓝牙讯号，不然是不会被其它蓝牙设备找到的。

③若模块处于连接状态，定时检查接收缓冲区，判断接收到的字符串是否为“AT+LED1=ON”和“AT+LED1=OFF”命令，若是则进行相应的操作，若不是则把接收缓冲区的第一行字符串显示出来。在这里用户可参照该范例自定义其它的命令。

二、通信模块

2.1 模块简介

  GSM以SIM800C模块为例，SIM800C可通过串口传输标准的 AT 命令对模块进行控制，可为产品提供简单方便的 GSM 语音、短信、GPRS 的数据通讯（TCP 通信和 UDP 通信）、蓝牙（SPP 通信），本章主要介绍GPRS功能

2.2 AT指令简介

  AT 即 Attention，AT 指令集是从终端设备(Terminal Equipment，TE)或数据终端设备(Data Terminal Equipment，DTE)向终端适配器(Terminal Adapter， TA)或数据电路终端设备(Data Circuit Terminal Equipment，DCE)发送的。通过 TA，TE 发送 AT 指令来控制移动台(Mobile Station，MS)的功能，与 GSM 网络业务进行交互。用户可以通过 AT 指令进行呼叫、短信、电话本、数据业务、传真等方面的控制。
  AT 指令必须以"AT"或"at"开头，以回车（）结尾。模块的响应通常紧随其后，格式为：<回车><换行><响应内容><回车><换行>。

2.2.1 常用AT指令

1. AT+CPIN?
     该指令用于查询 SIM 卡的状态，主要是 PIN 码，如果该指令返回：+CPIN:READY,则表明SIM 卡状态正常，返回其他值，则有可能是没有 SIM 卡。
2. AT+CSQ
     该指令用于查询信号质量，返回 SIM800C 模块的接收信号强度，如返回：+CSQ：24,0，表示信号强度是 24（最大的有效值是 31）
3. AT+COPS?
     该指令用于查询当前运营商，该指令只有在连上网络后，才返回运营商，否则返回空，如返回：+COPS:0,0,”CHINA MOBILE”,表示当前选择的运营商是中国移动。
4. AT+CGMI
     该指令用于查询模块制造商，如返回：SIMCOM_Ltd，说明 SIM800C 模块是 SIMCOM 公司生产的。
5. AT+CGMM
     该指令用于查询模块型号，如返回：SIMCOM_SIM800C，说明模块型号是 SIM800C。
6. AT+CGSN
     该指令用于查询产品序列号（集 IMEI 号），每个模块的 IMEI 号都是不一样的，具有全球唯一性，如返回：866104023267696，说明模块的产品序列号是：866104023267696。
7. AT+CNUM
     该指令用于查询本机号码，必须在 SIM 卡在位的时候才可以查询，如返回：+CNUM:””,”136******”,”129”,7,4，则表明本机号码为：136******。另外，不是所有的 SIM卡都支持这个指令，有个别 SIM 卡无法通过此指令得到其号码。
8. ATE1
     该指令用于设置回显模式（默认开启），即模块将收到的 AT 指令完整的返回给发送端，启用该功能，有利于调试模块。如果不需要开启回显模式，则发送 ATE0 指令即可关闭，这样收到的指令将不再返回给发送端，这样方便程序控制。
9. AT+CGMR
     该指令用于查询固件版本序列号，如返回：Revision:1418B02SIM800C32_BT,说明模块的固件版本序列号是 1418B02SIM800C32_BT，flash 大小是 32Mbit、支持蓝牙通信功能。

2.2.2 拨打/接听电话

1. ATE0
     用于关闭回显，在通过电脑串口调试助手调试的时候，我们发送：ATE1，开启回显，可以方便调试，但是我们通过单片机程序控制的时候，用不到回显功能，所以发送：ATE0，将其关闭。
2. ATD
     用于拨打任意电话号码，格式为：ATD+号码+;，末尾的’;’一定要加上，否则不能成功拨号，如发送：ATD10086;，即可实现拨打 10086。
3. ATA
     用于应答电话，当收到来电的时候，给模块发送：ATA，即可接听来电。
4. ATH
     用于挂断电话，要想结束正在进行的通话，只需给模块发送：ATH，即可挂断。
5. AT+COLP
     用于设置被叫号码显示，这里我们通过发送：AT+COLP=1，开启被叫号码显示，当成功拨通的时候（被叫接听电话），模块会返回被叫号码。
6. AT+CLIP
     用于设置来电显示，通过发送：AT+CLIP=1，可以实现设置来电显示功能，模块接收到来电的时候，会返回来电号码。
7. AT+VTS
     产生 DTMF 音，该指令只有在通话进行中才有效，用于向对方发送 DTMF 音，比如在拨打 10086 查询的时候，我们可以通过发送：AT+VTS=1，模拟发送按键 1。

2.2.3 短信的读取与发送

1. AT+CNMI
     用于设置新消息指示。发送：AT+CNMI=2,1，设置新消息提示，当收到新消息，且 SIM 卡未满的时候，SIM800C 模块会通过串口输出数据，如：+CMTI: “SM”,2，表示收到接收到新消息，存储在 SIM 卡的位置 2。
2. AT+CMGF
     用于设置短消息模式，SIM800C 支持 PDU 模式和文本（TEXT）模式等 2 种模式，发送：AT+CMGF=1，即可设置为文本模式。
3. AT+CSCS
     用于设置 TE 字符集，默认的为 IRA,国际标准字符集，在发送纯英文短信的时候，发送：AT+CSCS=“GSM”，设置为缺省字符集即可。在发送中英文短信的时候，需要发送：AT+CSCS="UCS2"设置为 16 位通用 8 字节倍数编码字符集。
4. AT+CSMP
     用于设置短消息文本模式参数，在使用 UCS2 方式发送中文短信的时候，需要发送：AT+CSMP=17,167,2,25，设置文本模式参数。
5. AT+CMGR
     用于读取短信，比如发送：AT+CMGR=1，则可以读取 SIM 卡存储在位置 1的短信。
6. AT+CMGS
     用于发送短信，在"GSM"字符集下，最大可以发送 180 个字节的英文字符，在"UCS2"字符集下，最大可以发送 70 个汉字（包括字符/数字）。
7. AT+CPMS
     用于查询/设置优选消息存储器，通过发送：AT+CPMS?，可以查询当前 SIM 卡最大支持多少条短信存储，以及当前存储了多少条短信等信息。如返回：+CPMS:”SM_P”,1,50,”SM_P”,1,50,”SM_P”,1,50,表示当前 SIM 卡最大存储 50 条信息，目前已经有 1 条存储的信息。

2.3.4 GPRS 通信

1. AT+CGCLASS
     用于设置移动台类别。SIM800C 模块支持类别"B"、"CG"和”CC”，发送：AT+CGCLASS=“B”，设置移动台台类别为 B。即，模块支持包交换和电路交换模式，但不能同时支持。
2. AT+CGDCONT
     用于设置 PDP 上下文。发送AT+CGDCONT=1,“IP”,“CMNET”，设置 PDP上下文标标志为 1，采用互联网协议（IP），接入点为"CMNET"。
3. AT+CGATT
     用于设置附着和分离 GPRS 业务。发送：AT+CGATT=1，附着 GPRS 业务。
4. AT+CIPCSGP
     用于设置 CSD 或 GPRS 链接模式。发送：AT+CIPCSGP=1, “CMNET”，设置为GPRS 连接，接入点为”CMNET”。
5. AT+ CIPHEAD
     用于设置接收数据是否显示 IP 头。发送：AT+CIPHEAD=1，即设置显示 IP头，在收到 TCP/UDP 数据的时候，会在数据之前添加如：+IPD:28，表示是 TCP/UDP 数据，数据长度为 28 字节。通过这个头，可以方便我们在程序上区分数据来源。
6. AT+CLPORT
     用于设置本地端口号。发送：AT+CLPORT=“TCP”,“8888”，即设置 TCP 连接本地端口号为 8888。
7. AT+CIPSTART
     用于建立 TCP 连接或注册 UDP 端口号。发送： AT+CIPSTART=“TCP”,“219.137.88.114”,“8086”，模块将建立一个 TCP 连接，连接目标地址为：219.137.88.114，连接端口为 8086，连接成功会返回：CONNECT OK。
8. AT+CIPSEND
     用于发送数据。在连接成功以后发送：AT+CIPSEND，模块返回：>，此时可以输入要发送的数据，最大可以一次发送 1352 字节，数据输入完后，同发短信一样，输入十六进制的：1A（0X1A），启动发送数据。在数据发送完成后，模块返回：SEND OK，表示发送成功。
9. AT+CIPSTATUS
     用于查询当前连接状态。发送：AT+CIPSTATUS，模块即返回当前连接状态。
10. AT+CIPCLOSE
      用于关闭 TCP/UDP 连接。发送：AT+CIPCLOSE=1，即可快速关闭当前 TCP/UDP连接。
11. AT+CIPSHUT
      用于关闭移动场景。发送：AT+SHUT，则可以关闭移动场景，关闭场景后连接状态为：IP INITIAL，可以通过发送：AT+CIPSTATUS，查询。另外，在连接建立后，如果收到：+PDP: DEACT，则必须发送：AT+CIPSHUT，关闭场景后，才能实现重连。

2.3 TCP通信示例代码

1. usart函数
     串口配置见蓝牙部分，基本一致
     其中串口发送函数也可以作以下修改

static void USART3_SendByte(uint8_t dat)
{
	USART_SendData(USART3,dat);
	while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET);	//等待发送结束
}

///*****************发送字符串**********************/
void USART3_SendString(uint8_t *pstr)
{
	uint8_t *str;
	str=pstr;
	while(*str!='\0')
	{
		USART3_SendByte(*str);
		str++;
	}
}

//发送举例
uint8_t Request_Module_ID_CMD[] = "AT+CGMM\r\n";
USART3_SendString(Request_Module_ID_CMD);

2. SIMCOM函数

//usmart支持部分
//将收到的AT指令应答数据返回给电脑串口
//mode:0,不清零USART3_RX_STA;
//     1,清零USART3_RX_STA;
void sim_at_response(u8 mode)
{
	if(USART3_RX_STA&0X8000)		          //接收到一次数据了
	{ 
		USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;//添加结束符
		printf("%s",USART3_RX_BUF);	          //发送到串口
		if(mode)USART3_RX_STA=0;
	} 
}
//
//ATK-SIM800C 各项测试(拨号测试、短信测试、GPRS测试、蓝牙测试)共用代码
//SIM800C发送命令后,检测接收到的应答
//str:期待的应答结果
//返回值:0,没有得到期待的应答结果
//其他,期待应答结果的位置(str的位置)
u8* sim800c_check_cmd(u8 *str)
{
	char *strx=0;
	if(USART3_RX_STA&0X8000)  //接收到一次数据了
	{ 
		USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;//添加结束符
		strx=strstr((const char*)USART3_RX_BUF,(const char*)str);
	} 
	return (u8*)strx;
}

//向SIM800C发送命令
//cmd:发送的命令字符串(不需要添加回车了),当cmd<0XFF的时候,发送数字(比如发送0X1A),大于的时候发送字符串.
//ack:期待的应答结果,如果为空,则表示不需要等待应答
//waittime:等待时间(单位:10ms)
//返回值:0,发送成功(得到了期待的应答结果)
//       1,发送失败
u8 sim800c_send_cmd(u8 *cmd,u8 *ack,u16 waittime)
{
	u8 res=0; 
	USART3_RX_STA=0;
	if((u32)cmd<=0XFF)
	{
		while((USART3->SR&0X40)==0);//等待上一次数据发送完成  
		USART3->DR=(u32)cmd;
	}else u3_printf("%s\r\n",cmd);  //发送命令
	
	if(ack&&waittime)		        //需要等待应答
	{
		while(--waittime)	        //等待倒计时
		{ 
			delay_ms(10);
			if(USART3_RX_STA&0X8000)//接收到期待的应答结果
			{
				if(sim800c_check_cmd(ack))break;//得到有效数据 
				USART3_RX_STA=0;
			} 
		}
		if(waittime==0)res=1; 
	}
	return res;
}

//SIMCOM信息
void sim800c_device_info(void)
{
	if(sim800c_send_cmd("AT+CGMI","OK",200)==0)			 //查询制造商名称
	{ 
		printf("制造商:%s\r\n",USART3_RX_BUF+2);
		USART3_RX_STA=0;		
	} 
	if(sim800c_send_cmd("AT+CGMM","OK",200)==0)          //查询模块名字
	{ 
		printf("模块型号:%s\r\n",USART3_RX_BUF+2);
		USART3_RX_STA=0;		
	} 
	if(sim800c_send_cmd("AT+CGSN","OK",200)==0)          //查询产品序列号
	{ 
		printf("序列号:%s\r\n",USART3_RX_BUF+2);
		USART3_RX_STA=0;		
	}
	if(sim800c_send_cmd("AT+CNUM","+CNUM",200)==0)		 //查询本机号码
	{ 
		printf("本机号码:%s\r\n",USART3_RX_BUF+2);
		USART3_RX_STA=0;		
	}
}

//NTP网络同步时间
void ntp_update(void)
{  
	sim800c_send_cmd("AT+SAPBR=3,1,\"Contype\",\"GPRS\"","OK",200);//配置承载场景1
	sim800c_send_cmd("AT+SAPBR=3,1,\"APN\",\"CMNET\"","OK",200);
	sim800c_send_cmd("AT+SAPBR=1,1",0,200);//激活一个GPRS上下文
	delay_ms(5);
	sim800c_send_cmd("AT+CNTPCID=1","OK",200);//设置CNTP使用的CID
	sim800c_send_cmd("AT+CNTP=\"202.120.2.101\",32","OK",200);//设置NTP服务器和本地时区(32时区 时间最准确)
	sim800c_send_cmd("AT+CNTP","+CNTP: 1",600);//同步网络时间

}

//GSM信息显示(信号质量,电池电量,日期时间)
//返回值:0,正常
//其他,错误代码
void gsm_info(void)
{
	u8 res=0,*p;
	USART3_RX_STA=0;
	if(sim800c_send_cmd("AT+CPIN?","OK",200))res|=1<<0;	//查询SIM卡是否在位 
	USART3_RX_STA=0;  
	if(sim800c_send_cmd("AT+COPS?","OK",200)==0)		//查询运营商名字
	{ 
		p1=(u8*)strstr((const char*)(USART3_RX_BUF),"\""); 
		if(p1)//有有效数据
		{			
			printf("运营商:%s\r\n",p1+1);
		} 
		USART3_RX_STA=0;		
	}
	if(sim800c_send_cmd("AT+CSQ","+CSQ:",200)==0)		//查询信号质量
	{ 
		printf("信号质量:%s\r\n",p1+2);
		USART3_RX_STA=0;		
	}
	if(sim800c_send_cmd("AT+CBC","+CBC:",200)==0)		//查询电池电量
	{ 
		printf("电池电量:%s%%  %smV\r\n",p1+1,p2+1);
		USART3_RX_STA=0;		
	}
	if(sim800c_send_cmd("AT+CCLK?","+CCLK:",200)==0)	//查询电池电量
	{ 
		printf("日期时间:%s\r\n",p1+1);
		USART3_RX_STA=0;		
	}
	//return res;
}

//断开网络，关闭场景
void gsm_gprs_close(void)
{
	USART3_RX_STA=0;
	sim800c_send_cmd("AT+CIPCLOSE=1","CLOSE OK",500);	//关闭连接

	sim800c_send_cmd("AT+CIPSHUT","SHUT OK",500);		//关闭移动场景 
}

//初始化并检测模块
//0表示成功，其他表示失败
u8 gsm_init(void)
{
	usart3_init(115200);		//初始化串口
	USART3_RX_STA=0;
	//串口助手显示
	sim800c_device_info();
	ntp_update();
	gsm_info();

	USART3_RX_STA=0;
	gsm_gprs_close();
	if(sim800c_send_cmd("AT+CGCLASS=\"B\"","OK",1000))return 1;				//设置GPRS移动台类别为B,支持包交换和数据交换 
	if(sim800c_send_cmd("AT+CGDCONT=1,\"IP\",\"CMNET\"","OK",1000))return 2;//设置PDP上下文,互联网接协议,接入点等信息
	if(sim800c_send_cmd("AT+CGATT=1","OK",500))return 3;					//附着GPRS业务
	if(sim800c_send_cmd("AT+CIPCSGP=1,\"CMNET\"","OK",500))return 4;	 	//设置为GPRS连接模式
	if(sim800c_send_cmd("AT+CIPHEAD=1","OK",500))return 5;	 				//设置接收数据显示IP头(方便判断数据来源)

	return 0;
}

const u8 *modetbl[2]={"TCP","UDP"};//连接模式

//tcp/udp连接
//mode:0:TCP测试;1,UDP测试)
//localport:本地端口
//ipaddr:ip地址
//serverport:服务器端口
//连接成功返回0
u8 sim800c_tcpudp_link(u8 mode,char* localport,u8* ipaddr,char* serverport)
{ 
	char cmd_buf[100];
	u8 *p,connectcnt=0;			//0,正在连接;1,连接成功;2,连接关闭; 
 
	USART3_RX_STA=0;
	sprintf(cmd_buf,"AT+CLPORT=\"UDP\",\"%s\"\r",localport);
	if(sim800c_send_cmd(cmd_buf,"OK", 100))return 1;		//设置本地端口号，可以省略

	USART3_RX_STA=0;
	sprintf((char*)p,"AT+CIPSTART=\"%s\",\"%s\",\"%s\"",modetbl[mode],ipaddr,serverport);
	if(sim800c_send_cmd(p,"OK",500))return 2;				//发起连接
		
	return 0;
}

//使用GPRS发送数据，发送前需要先建立UDP或TCP连接
//str: 要发送的数据
//返回值：0成功，1失败
u8 gsm_gprs_send(const char * str)
{
	char end = 0x1A;
	u8 testSend=0;

	USART3_RX_STA=0;
	
	if(sim800c_send_cmd("AT+CIPSEND",">",500)==0)	//发送数据
	{
		printf("CIPSEND DATA:%s\r\n",str);	 	//发送数据打印到串口
		u3_printf("%s\r\n",str);
		delay_ms(10);

		USART3_RX_STA=0;		
		//检测是否发送完成
		if(sim800c_send_cmd((u8*)0X1A,"SEND OK",1000)==0)
		{	
			printf("数据发送成功!");//最长等待10s
			return 0;
		}
		else
		{		
			if(++testSend >200)//最长等待20秒
			{
				goto gprs_send_failure;
			}
			delay_ms(100); 		
		}	
	}
	else
	{
gprs_send_failure:
		printf("数据发送失败!");
		sim800c_send_cmd((u8*)0X1B,0,0);	//ESC,取消发送

	return 1;
	}
}

此部分总共包含个函数：

1，sim_at_response是串口调试函数
2，sim800c_check_cmd用来检测SIM800C 模块发送回来的应答/数据
3，sim800c_send_cmd该函数用于向SIM800C模块发送命令
4，gsm_init是模块初始化函数,其中包含了对SIMCOM信息、NTP网络同步时间以及信号信息的更新和显示
5，gsm_gprs_close用来断开网络，关闭场景
6，sim800c_tcpudp_link用来建立tcp/udp连接
7，gsm_gprs_send

3. 功能测试函数

//系统软件复位
void Soft_Reset(void)
{
  __set_FAULTMASK(1);   //关闭所有中断  
  NVIC_SystemReset();   //系统复位
}

//根据具体情况修改
#define		LOCALPORT	"2000"
#define		SERVERIP	"163.142.57.125"
#define		SERVERPORT	"5000"

const char *TESTBUFF="\r\nGSM模块TCP数据上传功能测试";

//SIM800C主测试程序
void sim800c_test(void)
{ 
	u8 timex=0;

	while(sim800c_send_cmd("AT","OK",100))//检测是否应答AT指令 
	{
		delay_ms(800);
	} 	 
	key+=sim800c_send_cmd("ATE0","OK",200);	//选择功能
	while(gsm_init()!= 0)					//检查模块初始化
    {
    	printf("\r\n模块响应测试不正常！\r\n");
		delay_ms(1000);          
	}
	while(1)
	{
		delay_ms(10); 
		sim_at_response(1);//检查GSM模块发送过来的数据,及时上传给电脑
		if(sim800c_tcpudp_link(1,LOCALPORT,SERVERIP,SERVERPORT)==0)//连接失败
		{
			if(gsm_gprs_send(TESTBUFF)==0)
				printf("\n发送数据成功\n");
			else
			{
				printf("\r\nTCP发送数据失败，请检测正确设置各个模块\r\n");
				GSM_DELAY(100);
				gsm_gprs_close();
			}
		}
		else
		{
			printf("\r\nTCP链接失败，请检测正确设置各个模块\r\n");
			delay_ms(1000);
			gsm_gprs_close();
			delay_ms(100);
			Soft_Reset();
		}	
		if((timex%20)==0)LED0=!LED0;//200ms闪烁 
		timex++;	 
	} 	
}

三、GPS模块

3.1 GPS模块简介

  GPS模块以NEO-6M为例，模块核心采用 UBLOX 公司的 NEO-6M 模组

  NEO-6M 模块各引脚功能描述：

  其中，PPS 引脚同时连接到了模块自带了的状态指示灯：PPS，该引脚连接在 UBLOX NEO-6M 模组的 TIMEPULSE 端口，该端口的输出特性可以通过程序设置。PPS 指示灯（即 PPS引脚），在默认条件下（没经过程序设置），有 2 个状态：
  1， 常亮，表示模块已开始工作，但还未实现定位。
  2， 闪烁（100ms 灭，900ms 亮），表示模块已经定位成功。

3.2 GPS常用通信协议

  ATK-NEO-6M 模块默认采用 NMEA-0183 协议输出 GPS 定位数据，并可以通过 UBX 协议对模块进行配置

3.2.1 NMEA-0183协议

  常用 NMEA-0183 语句的字段定义

该协议采用 ASCII 码,帧格式形如：

$aaccc,ddd,ddd,…,ddd*hh< CR >< LF >

“ $ ”——帧命令起始位
aaccc——地址域，前两位为识别符，后三位为语句名
ddd…ddd——数据
“ * ”——校验和前缀
hh——校验和（check sum），$ 与 *之间所有字符 ASCII 码的校验和（各字节做异或运算，得到校验和后，再转换 16进制格式的 ASCII 字符。）
< CR>< LF>——CR（Carriage Return） + LF（Line Feed）帧结束，回车和换行

1. GPGGA
   GPS 固定数据输出语句(Global positioning system fix data)
   格式：

$GPGGA,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>,<10>,<11>,<12>,<13>,<14>*<15>< CR>< LF>

例子：$GPGGA,092725.00,4717.11399,N,00833.91590,E,1,8,1.01,499.6,M,48.0,M,0*5B
<1> UTC 时间，格式为 hhmmss.sss
<2> 纬度，格式为 ddmm.mmmm（前导位数不足则补 0）
<3> 纬度半球，N 或 S（北纬或南纬）
<4> 经度，格式为 dddmm.mmmm（前导位数不足则补 0）
<5> 经度半球，E 或 W（东经或西经）
<6> 定位质量指示，0=定位无效，1=标准定位，2=差分定位，6=估算
<7> 使用卫星数量，从 00 到 12（前导位数不足则补 0）
<8> 水平精确度，0.5 到 99.9
<9> 天线离海平面的高度，-9999.9 到 9999.9 米
<10> 高度单位，M 表示单位米
<11> 大地椭球面相对海平面的高度（-999.9 到 9999.9）
<12> 高度单位，M 表示单位米
<13> 差分 GPS 数据期限（RTCM SC-104），最后设立 RTCM 传送的秒数量
<14> 差分参考基站标号，从 0000 到 1023（前导位数不足则补 0）
<15> 校验和。

2. GPGSA
   GPS 精度指针及使用卫星 (GNSS DOP and Active Satellites)。格式：

$GPGSA,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>,<10>,<11>,<12>,<13>,<14>,<15>,<16>,<17>*<18>< CR>< LF>

例子：$GPGSA,A,3,23,29,07,08,09,18,26,28,1.94,1.18,1.54*0D
<1> 模式 2：M = 手动， A = 自动
<2> 模式 1：定位型式 1 = 未定位，2 = 二维定位，3 = 三维定位
<3> 第 1 信道正在使用的卫星 PRN 码编号（Pseudo Random Noise，伪随机噪声码），01至 32（前导位数不足则补 0，最多可接收 12 颗卫星信息）
<4> 第 2 信道正在使用的卫星 PRN 码编号
<5> 第 3 信道正在使用的卫星 PRN 码编号
<6> 第 4 信道正在使用的卫星 PRN 码编号
<7> 第 5 信道正在使用的卫星 PRN 码编号
<8> 第 6 信道正在使用的卫星 PRN 码编号
<9> 第 7 信道正在使用的卫星 PRN 码编号
<10> 第 8 信道正在使用的卫星 PRN 码编号
<11> 第 9 信道正在使用的卫星 PRN 码编号
<12> 第 10 信道正在使用的卫星 PRN 码编号
<13> 第 11 信道正在使用的卫星 PRN 码编号
<14> 第 12 信道正在使用的卫星 PRN 码编号
<15> PDOP 综合位置精度因子（0.5 - 99.9）
<16> HDOP 水平精度因子（0.5 - 99.9）
<17> VDOP 垂直精度因子（0.5 - 99.9）
<18> 校验和

3. GPGSV
   可视卫星状态输出语句 (GNSS Satellites in View)。格式：

$GPGSV, <1>,<2>,<3>,<4>,<5>,<6>,<7>,…,<4>,<5>,<6>,<7>*<8>< CR>< LF>

例子：$GPGSV,3,1,10,23,38,230,44,29,71,156,47,07,29,116,41,08,09,081,36*7F
<1> 总的 GSV 语句电文数
<2> 当前 GSV 语句号
<3> 可视卫星总数，00 至 12
<4> 卫星编号，01 至 32
<5> 卫星仰角，00 至 90 度
<6> 卫星方位角，000 至 359 度。实际值
<7> 信噪比（C/No），00 至 99dB；无表示未接收到讯号
<8> 校验和。

4. GPRMC
   推荐最小数据量的 GPS 信息(Recommended Minimum Specific GPS/TRANSIT Data)。格式：

$GPRMC,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>,<10>,<11>,<12>*<13>< CR>< LF>

例子：$GPRMC,083559.00,A,4717.11437,N,00833.91522,E,0.004,77.52,091202,A*57

<1> UTC（Coordinated Universal Time）时间，hhmmss（时分秒）格式
<2> 定位状态，A=有效定位，V=无效定位
<3> Latitude，纬度 ddmm.mmmm（度分）格式（前导位数不足则补 0）
<4> 纬度半球 N（北半球）或 S（南半球）
<5> Longitude，经度 dddmm.mmmm（度分）格式（前导位数不足则补 0
<6> 经度半球 E（东经）或 W（西经）
<7> 地面速率（000.0~999.9 节，Knot，前导位数不足则补 0）
<8> 地面航向（000.0~359.9 度，以真北为参考基准，前导位数不足则补 0）
<9> UTC 日期，ddmmyy（日月年）格式
<10> Magnetic Variation，磁偏角（000.0~180.0 度，前导位数不足则补 0）
<11> Declination，磁偏角方向，E（东）或 W（西）
<12> Mode Indicator，模式指示（仅 NMEA0183 3.00 版本输出，A=自主定位，D=差分，
E=估算，N=数据无效）
<13> 校验和。

5. GPVTG
   地面速度信息(Course over ground and Ground speed)。格式：

$GPVTG,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>*<10>< CR>< LF>

例子：$GPVTG,77.52,T,M,0.004,N,0.008,K,A*06

<1> 以真北为参考基准的地面航向
<2> T，表示“真”
<3> 以磁北为参考基准的地面航向
<4> M，表示“磁场”
<5> 地面速率
<6> N，表示“节”
<7> 地面速率
<8> K，表示“千米/小时”
<9> 模式指示（A=自主定位，D=差分，E=估算，N=数据无效）
<10> 校验和

6. GPGLL
   定位地理信息(Latitude and longitude, with time of position fix and status) 格式：

$GPGLL,<1>,<2>,<3>,<4>,<5>,<6>,<7>*<8>< CR>< LF>

例子：$GPGLL,4717.11364,N,00833.91565,E,092321.00,A,A*60

<1> 纬度 ddmm.mmmmm（度分）
<2> 纬度半球 N（北半球）或 S（南半球）
<3> 经度 dddmm.mmmmm（度分）
<4> 经度半球 E（东经）或 W（西经）
<5> UTC 时间：hhmmss（时分秒）
<6> 定位状态，A=有效定位，V=无效定位
<7> 模式指示（A=自主定位，D=差分，E=估算，N=数据无效）
<8> 校验和

7. GPZDA
   当前时间信息：(Time and Date)格式：

$GPZDA,<1>,<2>,<3>,<4>,<5>,<6>*<7>< CR>< LF>

例子：$GPZDA,082710.00,16,09,2002,00,00*64
<1> UTC 时间：hhmmss（时分秒，格林威治时间）
<2> 日
<3> 月
<4> 年
<5> 本地区域小时（NEO-6M 不支持，为 00）
<6> 本地区域分钟（NEO-6M 不支持，为 00）
<7> 校验和

3.2.2 UBX协议

  UBX协议是对模块进行配置的，此外也可以用u-blox 公司提供的 u-center 软件则具有配置模块工作方式的功能

3.3 示例代码

串口配置参照蓝牙部分

1. gps_dc.h
     对GPS NMEA-0183协议解码的结构体

#ifndef __GPS_H
#define __GPS_H	 
 
#include "stm32f4xx.h"
   


//GPS NMEA-0183协议重要参数结构体定义 
//卫星信息
__packed typedef struct  
{										    
 	u8 num;		//卫星编号
	u8 eledeg;	//卫星仰角
	u16 azideg;	//卫星方位角
	u8 sn;		//信噪比		   
}nmea_slmsg;  
//UTC时间信息
__packed typedef struct  
{										    
 	u16 year;	//年份
	u8 month;	//月份
	u8 date;	//日期
	u8 hour; 	//小时
	u8 min; 	//分钟
	u8 sec; 	//秒钟
}nmea_utc_time;   	   
//NMEA 0183 协议解析后数据存放结构体
__packed typedef struct  
{										    
 	u8 svnum;					//可见卫星数
	nmea_slmsg slmsg[12];		//最多12颗卫星
	nmea_utc_time utc;			//UTC时间
	u32 latitude;				//纬度 分扩大100000倍,实际要除以100000
	u8 nshemi;					//北纬/南纬,N:北纬;S:南纬				  
	u32 longitude;			    //经度 分扩大100000倍,实际要除以100000
	u8 ewhemi;					//东经/西经,E:东经;W:西经
	u8 gpssta;					//GPS状态:0,未定位;1,非差分定位;2,差分定位;6,正在估算.				  
 	u8 posslnum;				//用于定位的卫星数,0~12.
 	u8 possl[12];				//用于定位的卫星编号
	u8 fixmode;					//定位类型:1,没有定位;2,2D定位;3,3D定位
	u16 pdop;					//位置精度因子 0~500,对应实际值0~50.0
	u16 hdop;					//水平精度因子 0~500,对应实际值0~50.0
	u16 vdop;					//垂直精度因子 0~500,对应实际值0~50.0 

	int altitude;			 	//海拔高度,放大了10倍,实际除以10.单位:0.1m	 
	u16 speed;					//地面速率,放大了1000倍,实际除以10.单位:0.001公里/小时	 
}nmea_msg; 
 	
//UBLOX NEO-6M 配置(清除,保存,加载等)结构体
__packed typedef struct  
{										    
 	u16 header;					//cfg header,固定为0X62B5(小端模式)
	u16 id;						//CFG CFG ID:0X0906 (小端模式)
	u16 dlength;				//数据长度 12/13
	u32 clearmask;				//子区域清除掩码(1有效)
	u32 savemask;				//子区域保存掩码
	u32 loadmask;				//子区域加载掩码
	u8  devicemask; 		  	//目标器件选择掩码	b0:BK RAM;b1:FLASH;b2,EEPROM;b4,SPI FLASH
	u8  cka;		 			//校验CK_A 							 	 
	u8  ckb;			 		//校验CK_B							 	 
}_ublox_cfg_cfg; 

//UBLOX NEO-6M 消息设置结构体
__packed typedef struct  
{										    
 	u16 header;					//cfg header,固定为0X62B5(小端模式)
	u16 id;						//CFG MSG ID:0X0106 (小端模式)
	u16 dlength;				//数据长度 8
	u8  msgclass;				//消息类型(F0 代表NMEA消息格式)
	u8  msgid;					//消息 ID 
								//00,GPGGA;01,GPGLL;02,GPGSA;
								//03,GPGSV;04,GPRMC;05,GPVTG;
								//06,GPGRS;07,GPGST;08,GPZDA;
								//09,GPGBS;0A,GPDTM;0D,GPGNS;
	u8  iicset;					//IIC消输出设置    0,关闭;1,使能.
	u8  uart1set;				//UART1输出设置	   0,关闭;1,使能.
	u8  uart2set;				//UART2输出设置	   0,关闭;1,使能.
	u8  usbset;					//USB输出设置	   0,关闭;1,使能.
	u8  spiset;					//SPI输出设置	   0,关闭;1,使能.
	u8  ncset;					//未知输出设置	   默认为1即可.
 	u8  cka;			 		//校验CK_A 							 	 
	u8  ckb;			    	//校验CK_B							 	 
}_ublox_cfg_msg; 

//UBLOX NEO-6M UART端口设置结构体
__packed typedef struct  
{										    
 	u16 header;					//cfg header,固定为0X62B5(小端模式)
	u16 id;						//CFG PRT ID:0X0006 (小端模式)
	u16 dlength;				//数据长度 20
	u8  portid;					//端口号,0=IIC;1=UART1;2=UART2;3=USB;4=SPI;
	u8  reserved;				//保留,设置为0
	u16 txready;				//TX Ready引脚设置,默认为0
	u32 mode;					//串口工作模式设置,奇偶校验,停止位,字节长度等的设置.
 	u32 baudrate;				//波特率设置
 	u16 inprotomask;		 	//输入协议激活屏蔽位  默认设置为0X07 0X00即可.
 	u16 outprotomask;		 	//输出协议激活屏蔽位  默认设置为0X07 0X00即可.
 	u16 reserved4; 				//保留,设置为0
 	u16 reserved5; 				//保留,设置为0 
 	u8  cka;			 		//校验CK_A 							 	 
	u8  ckb;			    	//校验CK_B							 	 
}_ublox_cfg_prt; 

//UBLOX NEO-6M 时钟脉冲配置结构体
__packed typedef struct  
{										    
 	u16 header;					//cfg header,固定为0X62B5(小端模式)
	u16 id;						//CFG TP ID:0X0706 (小端模式)
	u16 dlength;				//数据长度
	u32 interval;				//时钟脉冲间隔,单位为us
	u32 length;				 	//脉冲宽度,单位为us
	signed char status;			//时钟脉冲配置:1,高电平有效;0,关闭;-1,低电平有效.			  
	u8 timeref;			   		//参考时间:0,UTC时间;1,GPS时间;2,当地时间.
	u8 flags;					//时间脉冲设置标志
	u8 reserved;				//保留			  
 	signed short antdelay;	 	//天线延时
 	signed short rfdelay;		//RF延时
	signed int userdelay; 	 	//用户延时	
	u8 cka;						//校验CK_A 							 	 
	u8 ckb;						//校验CK_B							 	 
}_ublox_cfg_tp; 

//UBLOX NEO-6M 刷新速率配置结构体
__packed typedef struct  
{										    
 	u16 header;					//cfg header,固定为0X62B5(小端模式)
	u16 id;						//CFG RATE ID:0X0806 (小端模式)
	u16 dlength;				//数据长度
	u16 measrate;				//测量时间间隔，单位为ms，最少不能小于200ms（5Hz）
	u16 navrate;				//导航速率（周期），固定为1
	u16 timeref;				//参考时间：0=UTC Time；1=GPS Time；
 	u8  cka;					//校验CK_A 							 	 
	u8  ckb;					//校验CK_B							 	 
}_ublox_cfg_rate; 
				 
int NMEA_Str2num(u8 *buf,u8*dx);
void GPS_Analysis(nmea_msg *gpsx,u8 *buf);
void NMEA_GPGSV_Analysis(nmea_msg *gpsx,u8 *buf);
void NMEA_GPGGA_Analysis(nmea_msg *gpsx,u8 *buf);
void NMEA_GPGSA_Analysis(nmea_msg *gpsx,u8 *buf);
void NMEA_GPGSA_Analysis(nmea_msg *gpsx,u8 *buf);
void NMEA_GPRMC_Analysis(nmea_msg *gpsx,u8 *buf);
void NMEA_GPVTG_Analysis(nmea_msg *gpsx,u8 *buf);
u8 Ublox_Cfg_Cfg_Save(void);
u8 Ublox_Cfg_Msg(u8 msgid,u8 uart1set);
u8 Ublox_Cfg_Prt(u32 baudrate);
u8 Ublox_Cfg_Tp(u32 interval,u32 length,signed char status);
u8 Ublox_Cfg_Rate(u16 measrate,u8 reftime);
void Ublox_Send_Date(u8* dbuf,u16 len);
#endif  

2. gps_dc.c

#include "gps.h" 
#include "delay.h" 								   
#include "usart3.h" 								   
#include "stdio.h"	 
#include "stdarg.h"	 
#include "string.h"	 
#include "math.h"
 


//从buf里面得到第cx个逗号所在的位置
//返回值:0~0XFE,代表逗号所在位置的偏移.
//       0XFF,代表不存在第cx个逗号							  
u8 NMEA_Comma_Pos(u8 *buf,u8 cx)
{	 		    
	u8 *p=buf;
	while(cx)
	{		 
		if(*buf=='*'||*buf<' '||*buf>'z')return 0XFF;//遇到'*'或者非法字符,则不存在第cx个逗号
		if(*buf==',')cx--;
		buf++;
	}
	return buf-p;	 
}
//m^n函数
//返回值:m^n次方.
u32 NMEA_Pow(u8 m,u8 n)
{
	u32 result=1;	 
	while(n--)result*=m;    
	return result;
}
//str转换为数字,以','或者'*'结束
//buf:数字存储区
//dx:小数点位数,返回给调用函数
//返回值:转换后的数值
int NMEA_Str2num(u8 *buf,u8*dx)
{
	u8 *p=buf;
	u32 ires=0,fres=0;
	u8 ilen=0,flen=0,i;
	u8 mask=0;
	int res;
	while(1) //得到整数和小数的长度
	{
		if(*p=='-'){mask|=0X02;p++;}//是负数
		if(*p==','||(*p=='*'))break;//遇到结束了
		if(*p=='.'){mask|=0X01;p++;}//遇到小数点了
		else if(*p>'9'||(*p<'0'))	//有非法字符
		{	
			ilen=0;
			flen=0;
			break;
		}	
		if(mask&0X01)flen++;
		else ilen++;
		p++;
	}
	if(mask&0X02)buf++;	//去掉负号
	for(i=0;i<ilen;i++)	//得到整数部分数据
	{  
		ires+=NMEA_Pow(10,ilen-1-i)*(buf[i]-'0');
	}
	if(flen>5)flen=5;	//最多取5位小数
	*dx=flen;	 		//小数点位数
	for(i=0;i<flen;i++)	//得到小数部分数据
	{  
		fres+=NMEA_Pow(10,flen-1-i)*(buf[ilen+1+i]-'0');
	} 
	res=ires*NMEA_Pow(10,flen)+fres;
	if(mask&0X02)res=-res;		   
	return res;
}	  							 
//分析GPGSV信息
//gpsx:nmea信息结构体
//buf:接收到的GPS数据缓冲区首地址
void NMEA_GPGSV_Analysis(nmea_msg *gpsx,u8 *buf)
{
	u8 *p,*p1,dx;
	u8 len,i,j,slx=0;
	u8 posx;   	 
	p=buf;
	p1=(u8*)strstr((const char *)p,"$GPGSV");
	len=p1[7]-'0';								//得到GPGSV的条数
	posx=NMEA_Comma_Pos(p1,3); 					//得到可见卫星总数
	if(posx!=0XFF)gpsx->svnum=NMEA_Str2num(p1+posx,&dx);
	for(i=0;i<len;i++)
	{	 
		p1=(u8*)strstr((const char *)p,"$GPGSV");  
		for(j=0;j<4;j++)
		{	  
			posx=NMEA_Comma_Pos(p1,4+j*4);
			if(posx!=0XFF)gpsx->slmsg[slx].num=NMEA_Str2num(p1+posx,&dx);	//得到卫星编号
			else break; 
			posx=NMEA_Comma_Pos(p1,5+j*4);
			if(posx!=0XFF)gpsx->slmsg[slx].eledeg=NMEA_Str2num(p1+posx,&dx);//得到卫星仰角 
			else break;
			posx=NMEA_Comma_Pos(p1,6+j*4);
			if(posx!=0XFF)gpsx->slmsg[slx].azideg=NMEA_Str2num(p1+posx,&dx);//得到卫星方位角
			else break; 
			posx=NMEA_Comma_Pos(p1,7+j*4);
			if(posx!=0XFF)gpsx->slmsg[slx].sn=NMEA_Str2num(p1+posx,&dx);	//得到卫星信噪比
			else break;
			slx++;	   
		}   
 		p=p1+1;//切换到下一个GPGSV信息
	}   
}
//分析GPGGA信息
//gpsx:nmea信息结构体
//buf:接收到的GPS数据缓冲区首地址
void NMEA_GPGGA_Analysis(nmea_msg *gpsx,u8 *buf)
{
	u8 *p1,dx;			 
	u8 posx;    
	p1=(u8*)strstr((const char *)buf,"$GPGGA");
	posx=NMEA_Comma_Pos(p1,6);								//得到GPS状态
	if(posx!=0XFF)gpsx->gpssta=NMEA_Str2num(p1+posx,&dx);	
	posx=NMEA_Comma_Pos(p1,7);								//得到用于定位的卫星数
	if(posx!=0XFF)gpsx->posslnum=NMEA_Str2num(p1+posx,&dx); 
	posx=NMEA_Comma_Pos(p1,9);								//得到海拔高度
	if(posx!=0XFF)gpsx->altitude=NMEA_Str2num(p1+posx,&dx);  
}
//分析GPGSA信息
//gpsx:nmea信息结构体
//buf:接收到的GPS数据缓冲区首地址
void NMEA_GPGSA_Analysis(nmea_msg *gpsx,u8 *buf)
{
	u8 *p1,dx;			 
	u8 posx; 
	u8 i;   
	p1=(u8*)strstr((const char *)buf,"$GPGSA");
	posx=NMEA_Comma_Pos(p1,2);								//得到定位类型
	if(posx!=0XFF)gpsx->fixmode=NMEA_Str2num(p1+posx,&dx);	
	for(i=0;i<12;i++)										//得到定位卫星编号
	{
		posx=NMEA_Comma_Pos(p1,3+i);					 
		if(posx!=0XFF)gpsx->possl[i]=NMEA_Str2num(p1+posx,&dx);
		else break; 
	}				  
	posx=NMEA_Comma_Pos(p1,15);								//得到PDOP位置精度因子
	if(posx!=0XFF)gpsx->pdop=NMEA_Str2num(p1+posx,&dx);  
	posx=NMEA_Comma_Pos(p1,16);								//得到HDOP位置精度因子
	if(posx!=0XFF)gpsx->hdop=NMEA_Str2num(p1+posx,&dx);  
	posx=NMEA_Comma_Pos(p1,17);								//得到VDOP位置精度因子
	if(posx!=0XFF)gpsx->vdop=NMEA_Str2num(p1+posx,&dx);  
}
//分析GPRMC信息
//gpsx:nmea信息结构体
//buf:接收到的GPS数据缓冲区首地址
void NMEA_GPRMC_Analysis(nmea_msg *gpsx,u8 *buf)
{
	u8 *p1,dx;			 
	u8 posx;     
	u32 temp;	   
	float rs;  
	p1=(u8*)strstr((const char *)buf,"GPRMC");//"$GPRMC",经常有&和GPRMC分开的情况,故只判断GPRMC.
	posx=NMEA_Comma_Pos(p1,1);								//得到UTC时间
	if(posx!=0XFF)
	{
		temp=NMEA_Str2num(p1+posx,&dx)/NMEA_Pow(10,dx);	 	//得到UTC时间,去掉ms
		gpsx->utc.hour=temp/10000;
		gpsx->utc.min=(temp/100)%100;
		gpsx->utc.sec=temp%100;	 	 
	}	
	posx=NMEA_Comma_Pos(p1,3);								//得到纬度
	if(posx!=0XFF)
	{
		temp=NMEA_Str2num(p1+posx,&dx);		 	 
		gpsx->latitude=temp/NMEA_Pow(10,dx+2);	//得到°
		rs=temp%NMEA_Pow(10,dx+2);				//得到'		 
		gpsx->latitude=gpsx->latitude*NMEA_Pow(10,5)+(rs*NMEA_Pow(10,5-dx))/60;//转换为° 
	}
	posx=NMEA_Comma_Pos(p1,4);								//南纬还是北纬 
	if(posx!=0XFF)gpsx->nshemi=*(p1+posx);					 
 	posx=NMEA_Comma_Pos(p1,5);								//得到经度
	if(posx!=0XFF)
	{												  
		temp=NMEA_Str2num(p1+posx,&dx);		 	 
		gpsx->longitude=temp/NMEA_Pow(10,dx+2);	//得到°
		rs=temp%NMEA_Pow(10,dx+2);				//得到'		 
		gpsx->longitude=gpsx->longitude*NMEA_Pow(10,5)+(rs*NMEA_Pow(10,5-dx))/60;//转换为° 
	}
	posx=NMEA_Comma_Pos(p1,6);								//东经还是西经
	if(posx!=0XFF)gpsx->ewhemi=*(p1+posx);		 
	posx=NMEA_Comma_Pos(p1,9);								//得到UTC日期
	if(posx!=0XFF)
	{
		temp=NMEA_Str2num(p1+posx,&dx);		 				//得到UTC日期
		gpsx->utc.date=temp/10000;
		gpsx->utc.month=(temp/100)%100;
		gpsx->utc.year=2000+temp%100;	 	 
	} 
}
//分析GPVTG信息
//gpsx:nmea信息结构体
//buf:接收到的GPS数据缓冲区首地址
void NMEA_GPVTG_Analysis(nmea_msg *gpsx,u8 *buf)
{
	u8 *p1,dx;			 
	u8 posx;    
	p1=(u8*)strstr((const char *)buf,"$GPVTG");							 
	posx=NMEA_Comma_Pos(p1,7);								//得到地面速率
	if(posx!=0XFF)
	{
		gpsx->speed=NMEA_Str2num(p1+posx,&dx);
		if(dx<3)gpsx->speed*=NMEA_Pow(10,3-dx);	 	 		//确保扩大1000倍
	}
}  
//提取NMEA-0183信息
//gpsx:nmea信息结构体
//buf:接收到的GPS数据缓冲区首地址
void GPS_Analysis(nmea_msg *gpsx,u8 *buf)
{
	NMEA_GPGSV_Analysis(gpsx,buf);	//GPGSV解析
	NMEA_GPGGA_Analysis(gpsx,buf);	//GPGGA解析 	
	NMEA_GPGSA_Analysis(gpsx,buf);	//GPGSA解析
	NMEA_GPRMC_Analysis(gpsx,buf);	//GPRMC解析
	NMEA_GPVTG_Analysis(gpsx,buf);	//GPVTG解析
}

  NMEA-0183 协议都是以类似$ GPGSV 的开头，而且都会以‘*’作为有效数据的结尾，就可以通过数逗号的方法，来解析数据了。本代码实现了对 NMEA-0183 协议的 $ GPGGA、$ GPGSA、$ GPGSV、 $ GPRMC 和$ GPVTG 等 5 类帧的解析
3. gps_cfg.c
GPS模块配置部分

//GPS校验和计算
//buf:数据缓存区首地址
//len:数据长度
//cka,ckb:两个校验结果.
void Ublox_CheckSum(u8 *buf,u16 len,u8* cka,u8*ckb)
{
	u16 i;
	*cka=0;*ckb=0;
	for(i=0;i<len;i++)
	{
		*cka=*cka+buf[i];
		*ckb=*ckb+*cka;
	}
}

//检查CFG配置执行情况
//返回值:0,ACK成功
//       1,接收超时错误
//       2,没有找到同步字符
//       3,接收到NACK应答
u8 Ublox_Cfg_Ack_Check(void)
{			 
	u16 len=0,i;
	u8 rval=0;
	while((USART3_RX_STA&0X8000)==0 && len<100)//等待接收到应答   
	{
		len++;
		delay_ms(5);
	}		 
	if(len<250)   	//超时错误.
	{
		len=USART3_RX_STA&0X7FFF;	//此次接收到的数据长度 
		for(i=0;i<len;i++)if(USART3_RX_BUF[i]==0XB5)break;//查找同步字符 0XB5
		if(i==len)rval=2;						//没有找到同步字符
		else if(USART3_RX_BUF[i+3]==0X00)rval=3;//接收到NACK应答
		else rval=0;	   						//接收到ACK应答
	}else rval=1;								//接收超时错误
    USART3_RX_STA=0;							//清除接收
	return rval;  
}
//配置保存
//将当前配置保存在外部EEPROM里面
//返回值:0,执行成功;1,执行失败.
u8 Ublox_Cfg_Cfg_Save(void)
{
	u8 i;
	_ublox_cfg_cfg *cfg_cfg=(_ublox_cfg_cfg *)USART3_TX_BUF;
	cfg_cfg->header=0X62B5;		//cfg header
	cfg_cfg->id=0X0906;			//cfg cfg id
	cfg_cfg->dlength=13;		//数据区长度为13个字节.		 
	cfg_cfg->clearmask=0;		//清除掩码为0
	cfg_cfg->savemask=0XFFFF; 	//保存掩码为0XFFFF
	cfg_cfg->loadmask=0; 		//加载掩码为0 
	cfg_cfg->devicemask=4; 		//保存在EEPROM里面		 
	Ublox_CheckSum((u8*)(&cfg_cfg->id),sizeof(_ublox_cfg_cfg)-4,&cfg_cfg->cka,&cfg_cfg->ckb);
	Ublox_Send_Date((u8*)cfg_cfg,sizeof(_ublox_cfg_cfg));//发送数据给NEO-6M     
	for(i=0;i<6;i++)if(Ublox_Cfg_Ack_Check()==0)break;		//EEPROM写入需要比较久时间,所以连续判断多次
	return i==6?1:0;
}
//配置NMEA输出信息格式
//msgid:要操作的NMEA消息条目,具体见下面的参数表
//      00,GPGGA;01,GPGLL;02,GPGSA;
//		03,GPGSV;04,GPRMC;05,GPVTG;
//		06,GPGRS;07,GPGST;08,GPZDA;
//		09,GPGBS;0A,GPDTM;0D,GPGNS;
//uart1set:0,输出关闭;1,输出开启.	  
//返回值:0,执行成功;其他,执行失败.
u8 Ublox_Cfg_Msg(u8 msgid,u8 uart1set)
{
	_ublox_cfg_msg *cfg_msg=(_ublox_cfg_msg *)USART3_TX_BUF;
	cfg_msg->header=0X62B5;		//cfg header
	cfg_msg->id=0X0106;			//cfg msg id
	cfg_msg->dlength=8;			//数据区长度为8个字节.	
	cfg_msg->msgclass=0XF0;  	//NMEA消息
	cfg_msg->msgid=msgid; 		//要操作的NMEA消息条目
	cfg_msg->iicset=1; 			//默认开启
	cfg_msg->uart1set=uart1set; //开关设置
	cfg_msg->uart2set=1; 	 	//默认开启
	cfg_msg->usbset=1; 			//默认开启
	cfg_msg->spiset=1; 			//默认开启
	cfg_msg->ncset=1; 			//默认开启	  
	Ublox_CheckSum((u8*)(&cfg_msg->id),sizeof(_ublox_cfg_msg)-4,&cfg_msg->cka,&cfg_msg->ckb);
	Ublox_Send_Date((u8*)cfg_msg,sizeof(_ublox_cfg_msg));//发送数据给NEO-6M    
	return Ublox_Cfg_Ack_Check();
}
//配置NMEA输出信息格式
//baudrate:波特率,4800/9600/19200/38400/57600/115200/230400	  
//返回值:0,执行成功;其他,执行失败(这里不会返回0了)
u8 Ublox_Cfg_Prt(u32 baudrate)
{
	_ublox_cfg_prt *cfg_prt=(_ublox_cfg_prt *)USART3_TX_BUF;
	cfg_prt->header=0X62B5;		//cfg header
	cfg_prt->id=0X0006;			//cfg prt id
	cfg_prt->dlength=20;		//数据区长度为20个字节.	
	cfg_prt->portid=1;			//操作串口1
	cfg_prt->reserved=0;	 	//保留字节,设置为0
	cfg_prt->txready=0;	 		//TX Ready设置为0
	cfg_prt->mode=0X08D0; 		//8位,1个停止位,无校验位
	cfg_prt->baudrate=baudrate; //波特率设置
	cfg_prt->inprotomask=0X0007;//0+1+2
	cfg_prt->outprotomask=0X0007;//0+1+2
 	cfg_prt->reserved4=0; 		//保留字节,设置为0
 	cfg_prt->reserved5=0; 		//保留字节,设置为0 
	Ublox_CheckSum((u8*)(&cfg_prt->id),sizeof(_ublox_cfg_prt)-4,&cfg_prt->cka,&cfg_prt->ckb);
	Ublox_Send_Date((u8*)cfg_prt,sizeof(_ublox_cfg_prt));//发送数据给NEO-6M   
	delay_ms(200);				//等待发送完成 
	usart3_init(baudrate);	//重新初始化串口3  
	return Ublox_Cfg_Ack_Check();//这里不会反回0,因为UBLOX发回来的应答在串口重新初始化的时候已经被丢弃了.
} 
//配置UBLOX NEO-6的时钟脉冲输出
//interval:脉冲间隔(us)
//length:脉冲宽度(us)
//status:脉冲配置:1,高电平有效;0,关闭;-1,低电平有效.
//返回值:0,发送成功;其他,发送失败.
u8 Ublox_Cfg_Tp(u32 interval,u32 length,signed char status)
{
	_ublox_cfg_tp *cfg_tp=(_ublox_cfg_tp *)USART3_TX_BUF;
	cfg_tp->header=0X62B5;		//cfg header
	cfg_tp->id=0X0706;			//cfg tp id
	cfg_tp->dlength=20;			//数据区长度为20个字节.
	cfg_tp->interval=interval;	//脉冲间隔,us
	cfg_tp->length=length;		//脉冲宽度,us
	cfg_tp->status=status;	   	//时钟脉冲配置
	cfg_tp->timeref=0;			//参考UTC 时间
	cfg_tp->flags=0;			//flags为0
	cfg_tp->reserved=0;		 	//保留位为0
	cfg_tp->antdelay=820;    	//天线延时为820ns
	cfg_tp->rfdelay=0;    		//RF延时为0ns
	cfg_tp->userdelay=0;    	//用户延时为0ns
	Ublox_CheckSum((u8*)(&cfg_tp->id),sizeof(_ublox_cfg_tp)-4,&cfg_tp->cka,&cfg_tp->ckb);
	Ublox_Send_Date((u8*)cfg_tp,sizeof(_ublox_cfg_tp));//发送数据给NEO-6M  
	return Ublox_Cfg_Ack_Check();
}
//配置UBLOX NEO-6的更新速率	    
//measrate:测量时间间隔，单位为ms，最少不能小于200ms（5Hz）
//reftime:参考时间，0=UTC Time；1=GPS Time（一般设置为1）
//返回值:0,发送成功;其他,发送失败.
u8 Ublox_Cfg_Rate(u16 measrate,u8 reftime)
{
	_ublox_cfg_rate *cfg_rate=(_ublox_cfg_rate *)USART3_TX_BUF;
 	if(measrate<200)return 1;	//小于200ms，直接退出
 	cfg_rate->header=0X62B5;	//cfg header
	cfg_rate->id=0X0806;	 	//cfg rate id
	cfg_rate->dlength=6;	 	//数据区长度为6个字节.
	cfg_rate->measrate=measrate;//脉冲间隔,us
	cfg_rate->navrate=1;		//导航速率（周期），固定为1
	cfg_rate->timeref=reftime; 	//参考时间为GPS时间
	Ublox_CheckSum((u8*)(&cfg_rate->id),sizeof(_ublox_cfg_rate)-4,&cfg_rate->cka,&cfg_rate->ckb);
	Ublox_Send_Date((u8*)cfg_rate,sizeof(_ublox_cfg_rate));//发送数据给NEO-6M 
	return Ublox_Cfg_Ack_Check();
}
//发送一批数据给Ublox NEO-6M，这里通过串口3发送
//dbuf：数据缓存首地址
//len：要发送的字节数
void Ublox_Send_Date(u8* dbuf,u16 len)
{
	u16 j;
	for(j=0;j<len;j++)//循环发送数据
	{
		while((USART3->SR&0X40)==0);//循环发送,直到发送完毕   
		USART3->DR=dbuf[j];  
	}	
}

  UBX 协议控制部分，此部分我们只实现了 NEO-6M 模组常用的 5 个配置：保存设置、输出信息设置、串口波特率设置、时钟脉冲设置和输出频率设置。
4. 主函数测试

u8 USART1_TX_BUF[USART3_MAX_RECV_LEN]; 					//串口1,发送缓存区
nmea_msg gpsx; 											//GPS信息
__align(4) u8 dtbuf[50];   								//打印缓存器
const u8*fixmode_tbl[4]={"Fail","Fail"," 2D "," 3D "};	//fix mode字符串 
	  
//显示GPS定位信息 
void Gps_Msg_Show(void)
{
 	float tp;		   
	POINT_COLOR=BLUE;  	 
	tp=gpsx.longitude;	   
	printf("Longitude:%.5f %1c   ",tp/=100000,gpsx.ewhemi);	//得到经度字符串
	 	   
	tp=gpsx.latitude;	   
	printf("Latitude:%.5f %1c   ",tp/=100000,gpsx.nshemi);	//得到纬度字符串
 	 
	tp=gpsx.altitude;	   
 	printf("Altitude:%.1fm     ",tp/=10);	    			//得到高度字符串
	 			   
	tp=gpsx.speed;	   
 	printf("Speed:%.3fkm/h     ",tp/=1000);		    		//得到速度字符串	 
 				    
	if(gpsx.fixmode<=3)														//定位状态
	{  
		printf("Fix Mode:%s",fixmode_tbl[gpsx.fixmode]);			   
	}	 	   
	printf("Valid satellite:%02d",gpsx.posslnum);	 		//用于定位的卫星数
    
	printf("Visible satellite:%02d",gpsx.svnum%100);	 		//可见卫星数
	 
	printf("UTC Date:%04d/%02d/%02d   ",gpsx.utc.year,gpsx.utc.month,gpsx.utc.date);	//显示UTC日期
	    
	printf("UTC Time:%02d:%02d:%02d   ",gpsx.utc.hour,gpsx.utc.min,gpsx.utc.sec);	//显示UTC时间
}	 


int main(void)
{ 
	u16 i,rxlen;
	u16 lenx;
	u8 key=0XFF;
	u8 upload=0;
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
	delay_init(168);      	//初始化延时函数
	uart_init(115200);			//初始化串口波特率为115200 
	usart3_init(38400);			//初始化串口3波特率为38400
//	usmart_dev.init(84); 		//初始化USMART		
	LED_Init();					//初始化LED
	KEY_Init();					//初始化按键
	usmart_dev.init(72); 		//初始化USMART 	  
  
	if(Ublox_Cfg_Rate(1000,1)!=0)	//设置定位信息更新速度为1000ms,顺便判断GPS模块是否在位. 
	{
   		printf("NEO-6M Setting...");
		while((Ublox_Cfg_Rate(1000,1)!=0)&&key)	//持续判断,直到可以检查到NEO-6M,且数据保存成功
		{
			usart3_init(9600);				//初始化串口3波特率为9600(EEPROM没有保存数据的时候,波特率为9600.)
	  	Ublox_Cfg_Prt(38400);			//重新设置模块的波特率为38400
			usart3_init(38400);				//初始化串口3波特率为38400
			Ublox_Cfg_Tp(1000000,100000,1);	//设置PPS为1秒钟输出1次,脉冲宽度为100ms	    
			key=Ublox_Cfg_Cfg_Save();		//保存配置  
		}	  					 
	   	printf("NEO-6M Set Done!!");
	}
	while(1) 
	{		
		delay_ms(1);
		if(USART3_RX_STA&0X8000)		//接收到一次数据了
		{
			rxlen=USART3_RX_STA&0X7FFF;	//得到数据长度
			for(i=0;i<rxlen;i++)USART1_TX_BUF[i]=USART3_RX_BUF[i];	   
 			USART3_RX_STA=0;		   	//启动下一次接收
			USART1_TX_BUF[i]=0;			//自动添加结束符
			GPS_Analysis(&gpsx,(u8*)USART1_TX_BUF);//分析字符串
			Gps_Msg_Show();				//显示信息	
			if(upload)printf("\r\n%s\r\n",USART1_TX_BUF);//发送接收到的数据到串口1
 		}
		key=KEY_Scan(0);
		if(key==KEY0_PRES)
		{
			upload=!upload;
			POINT_COLOR=RED;
			if(upload)printf("NMEA Data Upload:ON ");
			else printf("NMEA Data Upload:OFF");
 		}
		if((lenx%500)==0)LED0=!LED0; 	    				 
		lenx++;	
	}									    
}