网络OTA更新，GPS线程移动，但是无法正常运行

inc/hal_module_adapter.h

@@ -18,9 +18,9 @@ extern "C" {
 #define ADC_REQ_BITMAP_TEMP   							       (0x02)
 #define ADC_REQ_BITMAP_CH1								 (0x04)
 #define ADC_REQ_BITMAP_CH2								 (0x08)
-#define ADC_REQ_BITMAP_CH3								 (0x10)
-#define ADC_REQ_BITMAP_CH4								 (0x20)
-#define ADC_REQ_BITMAP_CH5								 (0x40)
+#define ADC_REQ_BITMAP_CH30								 (0x10)
+#define ADC_REQ_BITMAP_CH31								 (0x20)
+#define ADC_REQ_BITMAP_CH4								 (0x40)
 #define ADC_REQ_BITMAP_VBAT_CALI					 			(0x80)
 #define ADC_REQ_BITMAP_INRES_CALI					 			(0x100)
 #define ADC_GET_RESULT_TIMOUT 								 (2000)
@@ -28,11 +28,11 @@ typedef enum _ntc_channel
 {
     NTC_Channel1 ,	         
     NTC_Channel2 ,                
-    NTC_Channel3 ,               
+    NTC_Channel30 ,               
+    NTC_Channel31 ,               
     NTC_Channel4 ,               
-    NTC_Channel5 ,           
-    NTC_Channel5_VbatCali ,           
-    NTC_Channel5_InresCali ,           
+    NTC_Channel4_VbatCali ,           
+    NTC_Channel4_InresCali ,           
     NTC_ChannelMax	
 } ntc_channel_t;
 
@@ -138,7 +138,6 @@ typedef struct  _GPS_INFO
 typedef void (*posGGACallBack )(UINT8 res, UINT8 * params);
 void PowerPinConfig(IOType iotype);
 
-INT32 posGGAServiceStart( posGGACallBack callBack);
 void posGGAServiceStop( void);
 void posGGAReset(void);
 

src/app.c

@@ -27,6 +27,7 @@
 #define PROC_UART_TASK_STACK_SIZE           (1024)
 #define PROC_CAN_TASK_STACK_SIZE           (1024)
 #define PROC_TCP_TASK_STACK_SIZE           (1024)
+#define GPS_TASK_STACK_SIZE   				(2048)
 #define APP_EVENT_QUEUE_SIZE    (10)
 uint8_t deepslpTimerID          = DEEPSLP_TIMER_ID7;
 uint8_t MainSlpHandler          = 0xff;
@@ -42,7 +43,9 @@ extern ARM_DRIVER_USART Driver_USART1;
 static ARM_DRIVER_USART *USARTdrv = &Driver_USART1;
 volatile bool isRecvTimeout = false;
 volatile bool isRecvComplete = false;
-QueueHandle_t gpsMsgQueue = NULL;
+static QueueHandle_t gpsMsgQueue = NULL;
+static QueueHandle_t norGpsHandle = NULL;
+static osThreadId_t gpsTaskHandle = NULL;
 GPS_INFO Gps_Data;
 static volatile UINT32          Event;
 static QueueHandle_t            psEventQueueHandle;
@@ -127,13 +130,15 @@ static process_TCP 		    gProcess_Tcp_Task = PROCESS_TCP_STATE_IDLE;
 #define PROC_TCP_STATE_SWITCH(a)  (gProcess_Tcp_Task = a)
 //堆栈申请
 static StaticTask_t             gProcess_Main_Task_t;
-static UINT8                  gProcess_Main_TaskStack[PROC_UART_TASK_STACK_SIZE];
+static UINT8                  gProcess_Main_TaskStack[PROC_MAIN_TASK_STACK_SIZE];
 static StaticTask_t             gProcess_Uart_Task_t;
 static UINT8                  gProcess_Uart_TaskStack[PROC_UART_TASK_STACK_SIZE];
 static StaticTask_t             gProcess_Can_Task_t;
 static UINT8                  gProcess_Can_TaskStack[PROC_CAN_TASK_STACK_SIZE];
 static StaticTask_t             gProcess_Tcp_Task_t;
 static UINT8                  gProcess_Tcp_TaskStack[PROC_TCP_TASK_STACK_SIZE];
+static UINT8                            gpsTaskStack[GPS_TASK_STACK_SIZE];
+static StaticTask_t gpsTask = NULL;
 //睡眠进出函数
 static void appBeforeHib(void *pdata, slpManLpState state)
 {
@@ -715,7 +720,7 @@ static void Can_Task(void* arg)
     slpManPlatVoteDisableSleep(CanSlpHandler, SLP_SLP2_STATE);
     volatile bool Can_Flag=false;
     PROC_CAN_STATE_SWITCH(PROCESS_CAN_STATE_IDLE);
-    posGGAServiceStart(GGACallBack);
+    posGGAServiceStart(norGpsHandle);
 
     while(1)
     {
@@ -1413,6 +1418,130 @@ static void Tcp_Task(void* arg)
         }
     }
 }
+// 字符串删除函数
+void strdel(char * str,char c)
+{
+	char *p = str;
+	while(*str)
+	{
+		if(*str!=c)
+			*p++ = *str;
+		str++;
+	}
+	*p = '\0';
+}
+uint32_t location_handle(char *in1)
+{
+	uint32_t location_temp;
+	uint32_t location_degree;
+	uint32_t location_min;
+	location_temp = atol(in1);
+	location_degree = location_temp/(1e7);
+	location_degree = location_degree*(1e6);
+	location_min = location_temp-location_degree*10;
+	location_min = location_min/6;
+	location_temp = location_degree+location_min;
+	return location_temp;
+} 
+/**
+  \fn   void gpsProcess(void* arg)
+  \param[in]  
+  \brief       handle gps init ,deinit and convert process
+  \return      
+*/
+static void GpsProcess(void* arg)
+{
+    gpsReqMsg msg;
+	GPS_INFO Gps_buffer;
+	Gps_buffer.latitude = 0xffffffff;
+	Gps_buffer.longitude = 0xffffffff;
+	char *p=NULL;
+	const char *delim = "\n";
+	char *databuffer[14];
+	/**
+	 *databuffer内容格式：
+	 *  定位标识，时间，位置有效标识，纬度，纬度指示，经度，经度指示，地面速率，地面航向，日期
+	 **/
+
+    #ifdef USING_PRINTF	
+    	printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
+    #endif
+    while(1)
+    {
+		//char temp[] = "$GNGGA,082626.00,2939.91801,N,10637.09500,E,1,03,2.34,-20.3,M,,M,,*40";
+		char temp[] = "$GNRMC,082626.000,A,2939.91801,N,10637.09500,E,0.543,30.254,261120,,,A,V*17";
+		osMessageQueueGet(norGpsHandle, &msg, 0, osWaitForever);
+		if (msg.dataPtr)
+		{		
+			void  *msgtemp = msg.dataPtr;//取指针
+			// #ifdef USING_PRINTF	
+			// 	printf("\nGpsProcess msgptr data:%s\r\n",msg.dataPtr);
+			// #endif
+			p = strtok(msg.dataPtr,delim);//将信息进行分割
+			// #ifdef USING_PRINTF	
+			// 	printf("\nP msgptr data:%s\r\n",p);
+			// #endif
+			int i=0;
+			p = strtok(p,",");//只取第1行的信息RMC
+			//p = strtok(temp,",");//模拟测试
+			if (strcmp(p,"$GNRMC")==0)
+			{			
+				while (p)
+				{	
+					// #ifdef USING_PRINTF	
+					// 	printf("p:%s\r\n",p);
+					// #endif
+					databuffer[i]=p;
+					p = strtok(NULL,",");
+					i++;;
+				}
+				if (strcmp(databuffer[1],"V")==0|strcmp(databuffer[2],"V")==0)
+				{
+
+					#ifdef USING_PRINTF	
+						printf("Gpsdata invalide\n");
+					#endif 
+					Gps_buffer.status = 0x00;
+					Gps_buffer.speed = 0xffff;
+					Gps_buffer.direction= 0xffff;
+
+				}
+				else if (strcmp(databuffer[2],"A")==0)
+				{
+					uint32_t speedtemp;
+					#ifdef USING_PRINTF	
+						printf("Gpsdata valide\n");
+					#endif 
+					Gps_buffer.status = 0x01;//有效，东经，北纬写定
+					Gps_buffer.satellite_num = 03;//卫星数目写入1
+					strdel(databuffer[3],'.');
+					strdel(databuffer[5],'.');
+					strdel(databuffer[7],'.');
+					speedtemp = atol(databuffer[7])*1852;//节换算单位，1节=1.852km每小时
+					Gps_buffer.speed = speedtemp/1e5;
+					Gps_buffer.latitude = location_handle(databuffer[3]);
+					Gps_buffer.longitude = location_handle(databuffer[5]);
+					Gps_buffer.altitude = 00;
+					if(Gps_buffer.speed>=100)//大于10km/h才输出方位
+					{
+						Gps_buffer.direction = atol(databuffer[8]);
+					}
+					Gps_buffer.direction = 0xfffe;
+				}
+				osMessageQueuePut(gpsMsgQueue, &Gps_buffer, 0, 1000);
+			}
+			free(msgtemp);
+			msgtemp=NULL;
+		}
+		msg.dataPtr=NULL;
+		if (Sleep_Flag)
+		{
+			osThreadExit();
+			break;
+		}
+    }
+}
+
 //主任务线程初始化
 void Main_Task_Init()
 {
@@ -1485,6 +1614,42 @@ void Tcp_Task_Init()
     osThreadNew(Tcp_Task, NULL, &task_attr);
 
 }
+
+/**
+  \fn    INT32 GpsTaskInit(void)
+  \param[in]  
+  \brief       create task for checking gps data
+  \return      
+*/
+INT32 GpsTaskInit(void)
+{
+
+	if(norGpsHandle == NULL)
+	{
+		norGpsHandle = osMessageQueueNew(1,sizeof(gpsReqMsg), NULL);
+		if(norGpsHandle == NULL)
+			return 1;
+	}
+	
+
+	if(gpsTaskHandle == NULL)
+	{
+		osThreadAttr_t task_attr;
+		memset(&task_attr , 0 , sizeof(task_attr));
+		task_attr.name = "GPS";
+		task_attr.priority = osPriorityNormal1;
+		task_attr.cb_mem = &gpsTask;
+		task_attr.cb_size = sizeof(StaticTask_t);
+		task_attr.stack_mem = gpsTaskStack;
+		task_attr.stack_size =GPS_TASK_STACK_SIZE;
+		memset(& gpsTaskStack, 0xa5, GPS_TASK_STACK_SIZE);
+		gpsTaskHandle = osThreadNew(GpsProcess , NULL,&task_attr);
+		if(gpsTaskHandle == NULL)
+			return 1;
+	}
+	
+	return 0;
+}
 void appInit(void *arg)
 {
     Main_Task_Init();

src/bsp_custom.c

@@ -139,7 +139,7 @@ void BSP_CustomInit(void)
     BSP_LoadPlatConfigFromRawFlash();
     rawFlashPlatConfig = BSP_GetRawFlashPlatConfig();
 #ifdef USING_PRINTF
-	SetPrintUart(PORT_USART_1);
+	SetPrintUart(PORT_USART_0);
 #else
     if(rawFlashPlatConfig && (rawFlashPlatConfig->logControl != 0 ))
     {
@@ -155,6 +155,9 @@ void BSP_CustomInit(void)
 	NVIC_DisableIRQ(PadWakeup0_IRQn);
 	NVIC_DisableIRQ(PadWakeup1_IRQn);
 	NVIC_EnableIRQ(PadWakeup2_IRQn);
+	NVIC_DisableIRQ(PadWakeup3_IRQn);
+	NVIC_DisableIRQ(PadWakeup4_IRQn);
+	NVIC_DisableIRQ(PadWakeup5_IRQn);
 	CheckLockOutState();
 	slpManStartWaitATTimer();
 

src/cisAsynEntry.c

@@ -602,7 +602,7 @@ static void prvUpdateObserveContext()
         ECOMM_TRACE(UNILOG_PLA_APP, x1_prvUpdateObserveContext_3, P_ERROR, 0, "write flash error!!!");
     }
 }
-void prvMakeUserdata()
+void normal_prvMakeUserdata()
 {
     int i = 0;
     cis_instcount_t instIndex;

src/hal_module_adapter.c

@@ -10,6 +10,7 @@
 #include "adc_ec616.h"
 #include "gpio_ec616.h"
 #include "hal_module_adapter.h"
+#include <stdarg.h>
 /*
 	gps
 */
@@ -17,8 +18,7 @@ static posGGACallBack gGPSDataCBfunc =NULL;
 // GSENSOR device addr
 #define GSENSOR_DEVICE_ADDR               						(SC7A20_IIC_ADDRESS)
 #define ZM01_DEVICE_ADDR									(0x2a)
-extern  QueueHandle_t gpsMsgQueue;
-extern  bool Sleep_Flag;
+
 /*
 	i2c
 */
@@ -29,6 +29,9 @@ extern  bool Sleep_Flag;
 /*
 	power control
 */
+// back power
+#define AON_GPS_POWER1									 (8)
+//main power
 #define AON_GPS_POWER2									 (4)
 #define AON_RELAY_DRV										 (5)
 #define AON_WAKEUP											 (8)
@@ -39,6 +42,10 @@ extern  bool Sleep_Flag;
 #define FEM_GPS_RSTN										 (6)
 #define FEM_GPS_BLK											 (7)
 #define FEM_GPS_PPS											 (9)
+
+/*CAN*/
+#define GPIO_CAN_POWER									 (9)
+
 /*
 	I2C
 */
@@ -55,6 +62,9 @@ static osMessageQueueId_t i2c_recv_msgqueue;
 /*
 	adc
 */
+#define GPIO_AIO3_SEL										 (19)
+#define GPIO_AIO4_SEL										 (18)
+
 #define ADC_TASK_STACK_SIZE   								 (512)
 #define ADC_MSG_MAX_NUM        								 (7)
 #define ADC_AioResDivRatioDefault                                              (ADC_AioResDivRatio14Over16)
@@ -74,7 +84,6 @@ static UINT32 ADC_InsideRES=500000;
 #define ADC_RECV_CONTROL_FLAG         						 (0x1)
 typedef struct
 {
-    UINT8 flagC4;
     UINT32 request;
     UINT32 NTCvalue[7];
 }NtcResult_t;
@@ -95,11 +104,7 @@ static UINT8 adcTaskStack[ADC_TASK_STACK_SIZE];
 /*
 	gps
 */
-#define GPS_TASK_STACK_SIZE   								 (2048)
-QueueHandle_t gpsMsgHandle = NULL;
-static osThreadId_t gpsTaskHandle = NULL;
-static StaticTask_t gpsTask = NULL;
-static UINT8 gpsTaskStack[GPS_TASK_STACK_SIZE];
+static QueueHandle_t gpsHandle = NULL;
 
 /*
 	can
@@ -508,15 +513,26 @@ INT32  HAL_Can_Reset(void)
 void HAL_Can_Init(Can_InitType param)
 {
 	UINT8 temp=0,temp1=0;
-    INT32 res = -1;
+      INT32 res = -1;
+	  
+	gpio_pin_config_t config;
+	config.pinDirection = GPIO_DirectionOutput;
+	config.misc.initOutput = 1;
+	pad_config_t padConfig;
+	PAD_GetDefaultConfig(&padConfig);
 
-	HAL_Can_Reset();	//����?��?��????��?����?t?��??MCP2515
+	//POWER
+	padConfig.mux = PAD_MuxAlt0;
+	PAD_SetPinConfig(28, &padConfig);
+	GPIO_PinWrite(0, 1 << GPIO_CAN_POWER, 1 << GPIO_CAN_POWER);
+	
+	HAL_Can_Reset();	//¡¤¡é?¨ª?¡ä????¨¢?¨¨¨ª?t?¡ä??MCP2515
 	osDelay(100/portTICK_PERIOD_MS);		
-    CAN_WriteReg(CANCTRL,OPMODE_CONFIG |CLKOUT_ENABLED);
-    CAN_ReadReg(CANCTRL,1,&temp);//?����?CAN���䨬???��??�¦�??��
-//    #ifdef USING_PRINTF   
-// 	printf("[%d] CANCTRL = %#x \r\n",__LINE__,temp);
-//    #endif  
+      CAN_WriteReg(CANCTRL,OPMODE_CONFIG |CLKOUT_ENABLED);
+      CAN_ReadReg(CANCTRL,1,&temp);//?¨¢¨¨?CAN¡Á¡ä¨¬???¡ä??¡Â¦Ì??¦Ì
+   #ifdef USING_PRINTF   
+	//printf("[%d] CANCTRL = %#x \r\n",__LINE__,temp);
+   #endif  
 	CAN_WriteReg(CNF1,param.baudrate);
 	CAN_WriteReg(CNF2,0x80|PHSEG1_3TQ|PRSEG_1TQ);
 	CAN_WriteReg(CNF3,PHSEG2_3TQ);
@@ -653,6 +669,9 @@ void HAL_Can_Sleep(void)
 			break;
 		}
 	}while(t++<3);
+
+	//POWER
+	GPIO_PinWrite(0, 1 << GPIO_CAN_POWER, 0);
 }
 
 
@@ -1076,13 +1095,13 @@ void GpsDataRecvCallback(UINT32 event, void* dataPtr, UINT32 dataLen)
 	    #ifdef USING_PRINTF	
 	    //	//printf("GpsDataRecvCallback [%d] %s\r\n",dataLen,dataPtr);
 	    #endif 
-		if(dataLen>0){
+		if(gpsHandle!=NULL && dataLen>0){
 			gpsReqMsg gpsInfo;
 			gpsInfo.dataPtr=malloc(dataLen+1);
 			if(gpsInfo.dataPtr){
 				memcpy(gpsInfo.dataPtr,dataPtr,dataLen);	
 				gpsInfo.len=dataLen;
-				osMessageQueuePut(gpsMsgHandle, &gpsInfo, 0, 2000);
+				osMessageQueuePut(gpsHandle, &gpsInfo, 0, 2000);
 			}
 		}
    }
@@ -1221,7 +1240,7 @@ INT32 AdcSendReq(UINT32 req,UINT32 * param , UINT8 len ,UINT32 timeout)
     adcReqMsg ReqMsg;
 	
     ReqMsg.request = req;
-    ReqMsg.param[NTC_Channel1] =   ReqMsg.param[NTC_Channel2] =  ReqMsg.param[NTC_Channel3] =  ReqMsg.param[NTC_Channel4] =  ReqMsg.param[NTC_Channel5] = ReqMsg.param[NTC_Channel5_InresCali] =ADC_AioResDivRatioDefault  ;
+    ReqMsg.param[NTC_Channel1] =   ReqMsg.param[NTC_Channel2] =  ReqMsg.param[NTC_Channel30] = ReqMsg.param[NTC_Channel31] =  ReqMsg.param[NTC_Channel4] =  ReqMsg.param[NTC_Channel4_InresCali] =ADC_AioResDivRatioDefault  ;
     ret = osMessageQueuePut(adcMsgHandle, &ReqMsg, 0, timeout);
 
     if(ret != osOK)
@@ -1246,20 +1265,20 @@ INT32 AdcSendReq(UINT32 req,UINT32 * param , UINT8 len ,UINT32 timeout)
 		case ADC_REQ_BITMAP_CH2:
 		param[0] =AdcGetResFromInres(gNtcDev.NTCvalue[2+NTC_Channel2]);	
 		break;
-		case ADC_REQ_BITMAP_CH3:
-		param[0] =AdcGetResFromInres(gNtcDev.NTCvalue[2+NTC_Channel3]);	
+		case ADC_REQ_BITMAP_CH30:
+		param[0] =AdcGetResFromInres(gNtcDev.NTCvalue[2+NTC_Channel30]);	
 		break;
-		case ADC_REQ_BITMAP_CH4:
-		param[0] = AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel4]);	
+		case ADC_REQ_BITMAP_CH31:
+		param[0] =AdcGetResFromInres(gNtcDev.NTCvalue[2+NTC_Channel31]);	
 		break;
-		case ADC_REQ_BITMAP_CH5:
-		param[0] = AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel5]);	
+		case ADC_REQ_BITMAP_CH4:
+		param[0] = gNtcDev.NTCvalue[2+NTC_Channel4]*101+600;	
 		break;
 		case ADC_REQ_BITMAP_VBAT_CALI:
-		param[0] = AdcVbatCali(gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]);	
+		param[0] = AdcVbatCali(gNtcDev.NTCvalue[2+NTC_Channel4_VbatCali]);	
 		break;
 		case ADC_REQ_BITMAP_INRES_CALI:
-		param[0] = AdcInresCali(gNtcDev.NTCvalue[2+NTC_Channel5_InresCali]);	
+		param[0] = AdcInresCali(gNtcDev.NTCvalue[2+NTC_Channel4_InresCali]);	
 		break;
 	  }
 	  osEventFlagsClear(adcTrigerHandle, ADC_RECV_CONTROL_FLAG);
@@ -1299,30 +1318,34 @@ static void ADC_NTC2ChannelCallback(uint32_t result)
     NTCChannelResult[NTC_Channel2] = result;
     osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH2);
 }
-static void ADC_NTC3ChannelCallback(uint32_t result)
+
+static void ADC_NTC30ChannelCallback(uint32_t result)
 {
-    NTCChannelResult[NTC_Channel3] = result;
-    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH3);
+    NTCChannelResult[NTC_Channel30] = result;
+    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH30);
 }
-static void ADC_NTC4OR5ChannelCallback(uint32_t result)
+
+static void ADC_NTC31ChannelCallback(uint32_t result)
+{
+    NTCChannelResult[NTC_Channel31] = result;
+    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH31);
+}
+
+
+static void ADC_NTC4ChannelCallback(uint32_t result)
 {
-    if(gNtcDev.flagC4){
 	    NTCChannelResult[NTC_Channel4] = result;
 	    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH4);
-    }else{
-	    NTCChannelResult[NTC_Channel5] = result;
-	    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH5);
-    }
 }
 static void ADC_NTCVbatCaliChannelCallback(uint32_t result)
 {
-    NTCChannelResult[NTC_Channel5_VbatCali] = result;
+    NTCChannelResult[NTC_Channel4_VbatCali] = result;
     osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_VBAT_CALI);
 }
 
 static void ADC_NTCInresCaliChannelCallback(uint32_t result)
 {
-    NTCChannelResult[NTC_Channel5_InresCali] = result;
+    NTCChannelResult[NTC_Channel4_InresCali] = result;
     osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_INRES_CALI);
 }
 
@@ -1358,17 +1381,18 @@ static void AdcProcess(void* arg)
 	{
 		adcConfig.channelConfig.vbatResDiv = ADC_VbatResDivRatio3Over16;
 		ADC_ChannelInit(ADC_ChannelVbat, ADC_UserAPP, &adcConfig, ADC_VbatChannelCallback);
+		//delay_us(1000*1000);
 		ADC_StartConversion(ADC_ChannelVbat, ADC_UserAPP);
 	}
-
-	if(regMsg.request & ADC_REQ_BITMAP_TEMP)
+	else if(regMsg.request & ADC_REQ_BITMAP_TEMP)
 	{
 		adcConfig.channelConfig.thermalInput = ADC_ThermalInputVbat;
 		ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_ThermalChannelCallback);
+		//delay_us(1000*1000);
 		ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
 	}
 
-	if(regMsg.request & ADC_REQ_BITMAP_CH1)
+	else if(regMsg.request & ADC_REQ_BITMAP_CH1)
 	{
 		if(regMsg.param[NTC_Channel1]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel1]<=ADC_AioResDivRatio1Over16){
 		    #ifdef USING_PRINTF	
@@ -1382,10 +1406,11 @@ static void AdcProcess(void* arg)
 			adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
 		}
 	  	ADC_ChannelInit(ADC_ChannelAio1, ADC_UserAPP, &adcConfig, ADC_NTC1ChannelCallback);
+		//delay_us(1000*1000);
 	  	ADC_StartConversion(ADC_ChannelAio1, ADC_UserAPP);
 	}
 	
-	if(regMsg.request & ADC_REQ_BITMAP_CH2)
+	else if(regMsg.request & ADC_REQ_BITMAP_CH2)
 	{
 		if(regMsg.param[NTC_Channel2]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel2]<=ADC_AioResDivRatio1Over16){
 		    #ifdef USING_PRINTF	
@@ -1398,58 +1423,76 @@ static void AdcProcess(void* arg)
 		    #endif
 		}
 		ADC_ChannelInit(ADC_ChannelAio2, ADC_UserAPP, &adcConfig, ADC_NTC2ChannelCallback);
+		//delay_us(1000*1000);
 		ADC_StartConversion(ADC_ChannelAio2, ADC_UserAPP);
 	}
 	
-	if(regMsg.request & ADC_REQ_BITMAP_CH3)
+	else if(regMsg.request & ADC_REQ_BITMAP_CH30)
 	{
-		if(regMsg.param[NTC_Channel3]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel3]<=ADC_AioResDivRatio1Over16){
+		GPIO_PinWrite(GPIO_AIO3_SEL/16, 1<<(GPIO_AIO3_SEL%16), 0);
+		if(regMsg.param[NTC_Channel30]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel30]<=ADC_AioResDivRatio1Over16){
 		    #ifdef USING_PRINTF	
 		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
 		    #endif
-			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel3];
+			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel30];
 		}else{
 		    #ifdef USING_PRINTF	
 		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
 		    #endif
 			adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
 		}
-		ADC_ChannelInit(ADC_ChannelAio3, ADC_UserAPP, &adcConfig, ADC_NTC3ChannelCallback);
+		ADC_ChannelInit(ADC_ChannelAio3, ADC_UserAPP, &adcConfig, ADC_NTC30ChannelCallback);
+              //osDelay(2000/portTICK_PERIOD_MS);
 		ADC_StartConversion(ADC_ChannelAio3, ADC_UserAPP);
 	}
-	if(regMsg.request & ADC_REQ_BITMAP_CH4 ||regMsg.request & ADC_REQ_BITMAP_CH5)
+	
+	else if(regMsg.request & ADC_REQ_BITMAP_CH31)
 	{
-		if(regMsg.request & ADC_REQ_BITMAP_CH4){
-			gNtcDev.flagC4 = 1;
-			GPIO_PinWrite(0, 1, 1);
+		GPIO_PinWrite(GPIO_AIO3_SEL/16, 1<<(GPIO_AIO3_SEL%16), 1<<(GPIO_AIO3_SEL%16));
+		if(regMsg.param[NTC_Channel31]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel31]<=ADC_AioResDivRatio1Over16){
+		    #ifdef USING_PRINTF	
+		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
+		    #endif
+			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel31];
 		}else{
-			GPIO_PinWrite(0, 1, 0);
-			gNtcDev.flagC4 = 0;
+		    #ifdef USING_PRINTF	
+		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
+		    #endif
+			adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
 		}
+		ADC_ChannelInit(ADC_ChannelAio3, ADC_UserAPP, &adcConfig, ADC_NTC31ChannelCallback);
+              //osDelay(2000/portTICK_PERIOD_MS);
+		ADC_StartConversion(ADC_ChannelAio3, ADC_UserAPP);
+	}
+	
+	else if(regMsg.request & ADC_REQ_BITMAP_CH4)
+	{
+		GPIO_PinWrite(GPIO_AIO4_SEL/16, 1<<(GPIO_AIO4_SEL%16), 0);
 	        ADC_GetDefaultConfig(&adcConfig);
 	        adcConfig.channelConfig.thermalInput = ADC_ThermalInputAio4;
-	        ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_NTC4OR5ChannelCallback);
+	        ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_NTC4ChannelCallback);
+              //osDelay(2000/portTICK_PERIOD_MS);
 		ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
 	}
 
-	if(regMsg.request & ADC_REQ_BITMAP_VBAT_CALI)
+	else if(regMsg.request & ADC_REQ_BITMAP_VBAT_CALI)
 	{
-		GPIO_PinWrite(0, 1, 0);
-		gNtcDev.flagC4 = 0;
+		GPIO_PinWrite(GPIO_AIO4_SEL/16, 1<<(GPIO_AIO4_SEL%16), 1<<(GPIO_AIO4_SEL%16));
 	        ADC_GetDefaultConfig(&adcConfig);
 	        adcConfig.channelConfig.thermalInput = ADC_ThermalInputAio4;
 	        ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_NTCVbatCaliChannelCallback);
+              //osDelay(2000/portTICK_PERIOD_MS);
 		ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
 	}
 
-	if(regMsg.request & ADC_REQ_BITMAP_INRES_CALI)
+	else if(regMsg.request & ADC_REQ_BITMAP_INRES_CALI)
 	{
-		GPIO_PinWrite(0, 1, 0);
-		if(regMsg.param[NTC_Channel5_InresCali]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel5_InresCali]<=ADC_AioResDivRatio1Over16){
+		GPIO_PinWrite(GPIO_AIO4_SEL/16, 1<<(GPIO_AIO4_SEL%16), 1<<(GPIO_AIO4_SEL%16));
+		if(regMsg.param[NTC_Channel4_InresCali]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel4_InresCali]<=ADC_AioResDivRatio1Over16){
 		    #ifdef USING_PRINTF	
 		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
 		    #endif
-			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel5_InresCali];
+			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel4_InresCali];
 		}else{
 		    #ifdef USING_PRINTF	
 		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
@@ -1457,8 +1500,8 @@ static void AdcProcess(void* arg)
 			adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
 		}
 		
-		gNtcDev.flagC4 = 0;
 		ADC_ChannelInit(ADC_ChannelAio4, ADC_UserAPP, &adcConfig, ADC_NTCInresCaliChannelCallback);
+              //osDelay(2000/portTICK_PERIOD_MS);
 		ADC_StartConversion(ADC_ChannelAio4, ADC_UserAPP);
 	}
 	
@@ -1472,13 +1515,13 @@ static void AdcProcess(void* arg)
 	   gNtcDev.NTCvalue[0] = HAL_ADC_CalibrateRawCode(vbatChannelResult) * 16 / 3;
 	}
 
-	if(regMsg.request & ADC_REQ_BITMAP_TEMP)
+	else if(regMsg.request & ADC_REQ_BITMAP_TEMP)
 	{
 	    ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP);
 	    gNtcDev.NTCvalue[1] = HAL_ADC_ConvertThermalRawCodeToTemperature(thermalChannelResult);
 	}
 
-	if(regMsg.request & ADC_REQ_BITMAP_CH1)
+	else if(regMsg.request & ADC_REQ_BITMAP_CH1)
 	{
 	 	ADC_ChannelDeInit(ADC_ChannelAio1, ADC_UserAPP);
 		if(times==1){
@@ -1496,7 +1539,7 @@ static void AdcProcess(void* arg)
 		}
 			
 	}
-	if(regMsg.request & ADC_REQ_BITMAP_CH2)
+	else if(regMsg.request & ADC_REQ_BITMAP_CH2)
 	{
 		ADC_ChannelDeInit(ADC_ChannelAio2, ADC_UserAPP);
 		if(times==1){
@@ -1513,64 +1556,84 @@ static void AdcProcess(void* arg)
 			gNtcDev.NTCvalue[2+NTC_Channel2]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel2])*REV_AioResDivRatioExtra;
 		}	
 	}
-	if(regMsg.request & ADC_REQ_BITMAP_CH3)
+	else if(regMsg.request & ADC_REQ_BITMAP_CH30)
 	{
+		GPIO_PinWrite(GPIO_AIO3_SEL/16, 1<<(GPIO_AIO3_SEL%16), 1<<(GPIO_AIO3_SEL%16));
 		ADC_ChannelDeInit(ADC_ChannelAio3, ADC_UserAPP);
 		if(times==1){
-			gNtcDev.NTCvalue[2+NTC_Channel3]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel3])*REV_AioResDivRatioDefault;
+			gNtcDev.NTCvalue[2+NTC_Channel30]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel30])*REV_AioResDivRatioDefault;
 		    #ifdef USING_PRINTF	
-		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel3]);
+		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel30]);
 		    #endif
-			if(gNtcDev.NTCvalue[2+NTC_Channel3]>(NTC_FullAioValue-10)){
-				regMsg.param[NTC_Channel3]=ADC_AioResDivRatioExtra;
+			if(gNtcDev.NTCvalue[2+NTC_Channel30]>(NTC_FullAioValue-10)){
+				regMsg.param[NTC_Channel30]=ADC_AioResDivRatioExtra;
 				times++;
 				goto retry;
 			}			
 		}else{
-			gNtcDev.NTCvalue[2+NTC_Channel3]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel3])*REV_AioResDivRatioExtra;
+			gNtcDev.NTCvalue[2+NTC_Channel30]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel30])*REV_AioResDivRatioExtra;
 		}
 	}
-	if(regMsg.request & ADC_REQ_BITMAP_CH4 ||regMsg.request & ADC_REQ_BITMAP_CH5)
+
+	else if(regMsg.request & ADC_REQ_BITMAP_CH31)
 	{
-		ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP);
-		if(gNtcDev.flagC4){
-			gNtcDev.NTCvalue[2+NTC_Channel4]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4]);
+		GPIO_PinWrite(GPIO_AIO3_SEL/16, 1<<(GPIO_AIO3_SEL%16), 0);
+		ADC_ChannelDeInit(ADC_ChannelAio3, ADC_UserAPP);
+		if(times==1){
+			gNtcDev.NTCvalue[2+NTC_Channel31]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel31])*REV_AioResDivRatioDefault;
+		    #ifdef USING_PRINTF	
+		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel31]);
+		    #endif
+			if(gNtcDev.NTCvalue[2+NTC_Channel31]>(NTC_FullAioValue-10)){
+				regMsg.param[NTC_Channel31]=ADC_AioResDivRatioExtra;
+				times++;
+				goto retry;
+			}			
 		}else{
-			gNtcDev.NTCvalue[2+NTC_Channel5]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5]);
+			gNtcDev.NTCvalue[2+NTC_Channel31]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel31])*REV_AioResDivRatioExtra;
 		}
 	}
-	if(regMsg.request & ADC_REQ_BITMAP_VBAT_CALI)
+	
+	else if(regMsg.request & ADC_REQ_BITMAP_CH4)
 	{
+		GPIO_PinWrite(GPIO_AIO4_SEL/16, 1<<(GPIO_AIO4_SEL%16), 1<<(GPIO_AIO4_SEL%16));
+		ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP);
+		gNtcDev.NTCvalue[2+NTC_Channel4]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4]);
+	}
+	else if(regMsg.request & ADC_REQ_BITMAP_VBAT_CALI)
+	{
+		GPIO_PinWrite(GPIO_AIO4_SEL/16, 1<<(GPIO_AIO4_SEL%16), 0);
 		ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP);
 		if(times==1){
-			gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5_VbatCali]);
+			gNtcDev.NTCvalue[2+NTC_Channel4_VbatCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_VbatCali]);
 		    #ifdef USING_PRINTF	
-		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]);
+		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel4_VbatCali]);
 		    #endif
-			if(gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]>(NTC_FullAioValue-10)){
-				regMsg.param[NTC_Channel5_VbatCali]=ADC_AioResDivRatioExtra;
+			if(gNtcDev.NTCvalue[2+NTC_Channel4_VbatCali]>(NTC_FullAioValue-10)){
+				regMsg.param[NTC_Channel4_VbatCali]=ADC_AioResDivRatioExtra;
 				times++;
 				goto retry;
 			}			
 		}else{
-			gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5_VbatCali]);
+			gNtcDev.NTCvalue[2+NTC_Channel4_VbatCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_VbatCali]);
 		}
 	}
-	if(regMsg.request & ADC_REQ_BITMAP_INRES_CALI)
+	else if(regMsg.request & ADC_REQ_BITMAP_INRES_CALI)
 	{
+		GPIO_PinWrite(GPIO_AIO4_SEL/16, 1<<(GPIO_AIO4_SEL%16), 0);
 		ADC_ChannelDeInit(ADC_ChannelAio4, ADC_UserAPP);
 		if(times==1){
-			gNtcDev.NTCvalue[2+NTC_Channel5_InresCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5_InresCali])*REV_AioResDivRatioDefault;
+			gNtcDev.NTCvalue[2+NTC_Channel4_InresCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_InresCali])*REV_AioResDivRatioDefault;
 		    #ifdef USING_PRINTF	
-		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel5_InresCali]);
+		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel4_InresCali]);
 		    #endif
-			if(gNtcDev.NTCvalue[2+NTC_Channel5_InresCali]>(NTC_FullAioValue-10)){
-				regMsg.param[NTC_Channel5_InresCali]=ADC_AioResDivRatioExtra;
+			if(gNtcDev.NTCvalue[2+NTC_Channel4_InresCali]>(NTC_FullAioValue-10)){
+				regMsg.param[NTC_Channel4_InresCali]=ADC_AioResDivRatioExtra;
 				times++;
 				goto retry;
 			}			
 		}else{
-			gNtcDev.NTCvalue[2+NTC_Channel5_InresCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5_InresCali])*REV_AioResDivRatioExtra;
+			gNtcDev.NTCvalue[2+NTC_Channel4_InresCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_InresCali])*REV_AioResDivRatioExtra;
 		}
 	}
 	 osEventFlagsSet(adcTrigerHandle, ADC_RECV_CONTROL_FLAG);
@@ -1592,11 +1655,21 @@ INT32 AdcTaskInit(void)
 	pad_config_t padConfig;
 	PAD_GetDefaultConfig(&padConfig);
 
+//power
 	padConfig.mux = PAD_MuxAlt0;
 	PAD_SetPinConfig(11, &padConfig);
-		
 	GPIO_PinConfig(0, 0, &config);
-	GPIO_PinWrite(0, 1, 1);
+	GPIO_PinWrite(0, 1,  1);
+	
+	padConfig.mux = PAD_MuxAlt7;
+	PAD_SetPinConfig(9, &padConfig);
+	PAD_SetPinConfig(10, &padConfig);
+		
+	GPIO_PinConfig(GPIO_AIO3_SEL/16, GPIO_AIO3_SEL%16, &config);
+	GPIO_PinConfig(GPIO_AIO4_SEL/16, GPIO_AIO4_SEL%16, &config);
+	GPIO_PinWrite(GPIO_AIO3_SEL/16, 1<<(GPIO_AIO3_SEL%16), 0);
+	GPIO_PinWrite(GPIO_AIO4_SEL/16, 1<<(GPIO_AIO4_SEL%16), 0);
+	
 	memset(&gNtcDev , 0 ,sizeof(NtcResult_t));
 	
 	if(adcMsgHandle == NULL)
@@ -1657,6 +1730,10 @@ void PowerPinConfig(IOType iotype)
       if(iotype == AON_IO)
 	{
 		padConfig.mux = PAD_MuxAlt0;
+
+		PAD_SetPinConfig(35, &padConfig);
+		GPIO_PinConfig(1, AON_GPS_POWER1, &config);
+		GPIO_PinWrite(1, 1 << AON_GPS_POWER1, 0);
 		
 		PAD_SetPinConfig(31, &padConfig);
 		GPIO_PinConfig(1, AON_GPS_POWER2, &config);
@@ -1732,6 +1809,12 @@ void posGGAReset(void)
 	
 	GPIO_PinConfig(1, FEM_GPS_RSTN, &config);
 	GPIO_PinWrite(1, 1 << FEM_GPS_RSTN, 1 << FEM_GPS_RSTN);
+
+
+	config.pinDirection = GPIO_DirectionInput;
+	config.misc.initOutput = 0;
+	GPIO_PinConfig(1, FEM_GPS_RSTN, &config);
+	
 	
 }
 /**
@@ -1752,27 +1835,33 @@ void GPSPowerCtr(bool on)
 
 	padConfig.mux = PAD_MuxAlt0;
 
+	PAD_SetPinConfig(35, &padConfig);
+	GPIO_PinConfig(1, AON_GPS_POWER1, &config);
+
 	PAD_SetPinConfig(31, &padConfig);
 	GPIO_PinConfig(1, AON_GPS_POWER2, &config);
+	
 	if(on){
 		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 0);
+		GPIO_PinWrite(1, 1 << AON_GPS_POWER1, 1 << AON_GPS_POWER1);
 	}else{
 		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 1<<AON_GPS_POWER2);
+		GPIO_PinWrite(1, 1 << AON_GPS_POWER1, 0);
 	}
 }
 /**
-  \fn   void posGGAServiceStart(posGGACallBack )
+  \fn   void posGGAServiceStart(QueueHandle_t handle)
   \param[in]  
   \brief    powr on gps
   \return      
 */
-INT32 posGGAServiceStart( posGGACallBack callBack)
+INT32 posGGAServiceStart(QueueHandle_t handle)
 {
-	if(callBack == NULL){
+	if(handle == NULL){
 		return -1;
 	}else{
 		GPSPowerCtr(true);
-		gGPSDataCBfunc = callBack;
+		gpsHandle = handle;
 		return 0;
 	}
 }
@@ -1786,166 +1875,4 @@ void posGGAServiceStop( void)
 {	
 	GPSPowerCtr(false);
 	gGPSDataCBfunc = NULL;
-}
-// 字符串删除函数
-void strdel(char * str,char c)
-{
-	char *p = str;
-	while(*str)
-	{
-		if(*str!=c)
-			*p++ = *str;
-		str++;
-	}
-	*p = '\0';
-}
-uint32_t location_handle(char *in1)
-{
-	uint32_t location_temp;
-	uint32_t location_degree;
-	uint32_t location_min;
-	location_temp = atol(in1);
-	location_degree = location_temp/(1e7);
-	location_degree = location_degree*(1e6);
-	location_min = location_temp-location_degree*10;
-	location_min = location_min/6;
-	location_temp = location_degree+location_min;
-	return location_temp;
-} 
-/**
-  \fn   void gpsProcess(void* arg)
-  \param[in]  
-  \brief       handle gps init ,deinit and convert process
-  \return      
-*/
-static void GpsProcess(void* arg)
-{
-    gpsReqMsg msg;
-	GPS_INFO Gps_buffer;
-	Gps_buffer.latitude = 0xffffffff;
-	Gps_buffer.longitude = 0xffffffff;
-	char *p=NULL;
-	const char *delim = "\n";
-	char *databuffer[14];
-	/**
-	 *databuffer内容格式：
-	 *  定位标识，时间，位置有效标识，纬度，纬度指示，经度，经度指示，地面速率，地面航向，日期
-	 **/
-
-    #ifdef USING_PRINTF	
-    	printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
-    #endif
-    while(1)
-    {
-		//char temp[] = "$GNGGA,082626.00,2939.91801,N,10637.09500,E,1,03,2.34,-20.3,M,,M,,*40";
-		char temp[] = "$GNRMC,082626.000,A,2939.91801,N,10637.09500,E,0.543,30.254,261120,,,A,V*17";
-		osMessageQueueGet(gpsMsgHandle, &msg, 0, 5000);
-		if (msg.dataPtr)
-		{		
-			void  *msgtemp = msg.dataPtr;//取指针
-			// #ifdef USING_PRINTF	
-			// 	printf("\nGpsProcess msgptr data:%s\r\n",msg.dataPtr);
-			// #endif
-			p = strtok(msg.dataPtr,delim);//将信息进行分割
-			// #ifdef USING_PRINTF	
-			// 	printf("\nP msgptr data:%s\r\n",p);
-			// #endif
-			int i=0;
-			p = strtok(p,",");//只取第1行的信息RMC
-			//p = strtok(temp,",");//模拟测试
-			if (strcmp(p,"$GNRMC")==0)
-			{			
-				while (p)
-				{	
-					// #ifdef USING_PRINTF	
-					// 	printf("p:%s\r\n",p);
-					// #endif
-					databuffer[i]=p;
-					p = strtok(NULL,",");
-					i++;;
-				}
-				if (strcmp(databuffer[1],"V")==0|strcmp(databuffer[2],"V")==0)
-				{
-
-					#ifdef USING_PRINTF	
-						printf("Gpsdata invalide\n");
-					#endif 
-					Gps_buffer.status = 0x00;
-					Gps_buffer.speed = 0xffff;
-					Gps_buffer.direction= 0xffff;
-
-				}
-				else if (strcmp(databuffer[2],"A")==0)
-				{
-					uint32_t speedtemp;
-					#ifdef USING_PRINTF	
-						printf("Gpsdata valide\n");
-					#endif 
-					Gps_buffer.status = 0x01;//有效，东经，北纬写定
-					Gps_buffer.satellite_num = 03;//卫星数目写入1
-					strdel(databuffer[3],'.');
-					strdel(databuffer[5],'.');
-					strdel(databuffer[7],'.');
-					speedtemp = atol(databuffer[7])*1852;//节换算单位，1节=1.852km每小时
-					Gps_buffer.speed = speedtemp/1e5;
-					Gps_buffer.latitude = location_handle(databuffer[3]);
-					Gps_buffer.longitude = location_handle(databuffer[5]);
-					Gps_buffer.altitude = 00;
-					if(Gps_buffer.speed>=100)//大于10km/h才输出方位
-					{
-						Gps_buffer.direction = atol(databuffer[8]);
-					}
-					Gps_buffer.direction = 0xfffe;
-				}
-				osMessageQueuePut(gpsMsgQueue, &Gps_buffer, 0, 1000);
-			}
-			free(msgtemp);
-			msgtemp=NULL;
-		}
-		msg.dataPtr=NULL;
-		
-		if (Sleep_Flag)
-		{
-			osThreadExit();
-			break;
-		}
-    }
-}
-
-/**
-  \fn    INT32 GpsTaskInit(void)
-  \param[in]  
-  \brief       create task for checking gps data
-  \return      
-*/
-INT32 GpsTaskInit(void)
-{
-
-	if(gpsMsgHandle == NULL)
-	{
-		gpsMsgHandle = osMessageQueueNew(1,sizeof(gpsReqMsg), NULL);
-		if(gpsMsgHandle == NULL)
-			return 1;
-	}
-	
-
-	if(gpsTaskHandle == NULL)
-	{
-		osThreadAttr_t task_attr;
-		memset(&task_attr , 0 , sizeof(task_attr));
-		task_attr.name = "GPS";
-		task_attr.priority = osPriorityNormal1;
-		task_attr.cb_mem = &gpsTask;
-		task_attr.cb_size = sizeof(StaticTask_t);
-		task_attr.stack_mem = gpsTaskStack;
-		task_attr.stack_size =GPS_TASK_STACK_SIZE;
-		memset(& gpsTaskStack, 0xa5, GPS_TASK_STACK_SIZE);
-		gpsTaskHandle = osThreadNew(GpsProcess , NULL,&task_attr);
-		if(gpsTaskHandle == NULL)
-			return 1;
-	}
-	
-	return 0;
-}
-
-
+}