NB_APP_Code/src/hal_module_adapter.c

#include "bsp.h"
#include "osasys.h"
#include "ostask.h"
#include "queue.h"
#include "debug_log.h"
#include "slpman_ec616.h"
#include "plat_config.h"
#include "hal_uart.h"
#include "hal_adc.h"
#include "adc_ec616.h"
#include "gpio_ec616.h"
#include "hal_module_adapter.h"
#include <stdarg.h>
/*
	gps
*/
static posGGACallBack gGPSDataCBfunc =NULL;
// GSENSOR device addr
#define GSENSOR_DEVICE_ADDR               						(SC7A20_IIC_ADDRESS)
#define ZM01_DEVICE_ADDR									(0x2a)

/*
	i2c
*/
#define HAL_I2C_RECV_TASK_QUEUE_CREATED          			 (0x1)
#define I2C_RECV_QUEUE_BUF_SIZE                        			 (0x10)
#define I2C_RECV_TASK_STACK_SIZE             					 (1536)

/*
	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)
#define GPIO_MOS_DRV1										 (14)
#define GPIO_MOS_DRV2										 (15)
#define GPIO_POWER_LED										 (9)
/*GPS*/
#define FEM_GPS_RSTN										 (6)
#define FEM_GPS_BLK											 (7)
#define FEM_GPS_PPS											 (9)

/*CAN*/
#define GPIO_CAN_POWER									 (9)

/*
	I2C
*/
#define I2C_RECV_CONTROL_FLAG         			 (0x1)
static UINT32 g_halI2CInitFlag = 0;
static osEventFlagsId_t  g_i2CRecvFlag;
static StaticQueue_t      i2c_recv_queue_cb;
static StaticTask_t  i2c_recv_task;
static UINT8  i2c_recv_task_stack[I2C_RECV_TASK_STACK_SIZE];
static UINT8   i2c_recv_queue_buf[I2C_RECV_QUEUE_BUF_SIZE*sizeof(i2c_recv_msgqueue_obj_t)];
// message queue id
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)
#define REV_AioResDivRatioDefault								 16/14
//#define ADC_ChannelAioVbat										(1200)
static UINT32 ADC_ChannelAioVbat=1200;
#define ADC_ChannelAioRes										(15000)
#define NTC_FullAioValue											(1200)
#define ADC_AioResDivRatioExtra                                              (ADC_AioResDivRatio8Over16)
#define REV_AioResDivRatioExtra								 16/8
#define NTC_REQ_UPDATE_DATA    							       (0x01)
#define ADC_MSG_TIMEOUT      								 (1000)
#define ADC_CALIBRATION_VALUE     								 (50900)

static UINT32 ADC_InsideRES=500000;

#define ADC_RECV_CONTROL_FLAG         						 (0x1)
typedef struct
{
    UINT32 request;
    UINT32 NTCvalue[7];
}NtcResult_t;

NtcResult_t gNtcDev;
volatile static UINT32 vbatChannelResult = 0;
volatile static UINT32 thermalChannelResult = 0;
volatile static UINT32  NTCChannelResult[NTC_ChannelMax];

QueueHandle_t adcMsgHandle = NULL;
static osEventFlagsId_t adcEvtHandle = NULL;
static osEventFlagsId_t adcTrigerHandle = NULL;
static osThreadId_t adcTaskHandle = NULL;
static StaticTask_t adcTask = NULL;
static UINT8 adcTaskStack[ADC_TASK_STACK_SIZE];


/*
	gps
*/
static QueueHandle_t gpsHandle = NULL;

/*
	can
*/
static osMessageQueueId_t can_recv_msgqueue;
static StaticQueue_t      can_recv_queue_cb;
#define CAN_RECV_QUEUE_BUF_SIZE                        			 (0x10)
static UINT8   can_recv_queue_buf[CAN_RECV_QUEUE_BUF_SIZE];

#define CAN_RECV_CONTROL_FLAG         						 (0x1)
//#define SPI_ANALOG	
#ifdef SPI_ANALOG
#define USING_SPI0							0
#endif
/*spi0*/
#ifdef SPI_ANALOG
#if USING_SPI0
#define SPI_SSN_GPIO_INSTANCE  				 RTE_SPI0_SSN_GPIO_INSTANCE
#define SPI_SSN_GPIO_INDEX      				 RTE_SPI0_SSN_GPIO_INDEX
#define SPI_SSN_GPIO_PAD_ADDR                      21

#define SPI_CLK_GPIO_INSTANCE				 0	
#define SPI_CLK_GPIO_INDEX                             15
#define SPI_CLK_GPIO_PAD_ADDR                      24

#define SPI_MOSI_GPIO_INSTANCE				 0
#define SPI_MOSI_GPIO_INDEX				 11
#define SPI_MOSI_GPIO_PAD_ADDR                    22

#define SPI_MISO_GPIO_INSTANCE				 0
#define SPI_MISO_GPIO_INDEX				 14
#define SPI_MISO_GPIO_PAD_ADDR			 23

#else //SPI1
#define SPI_SSN_GPIO_INSTANCE  				 RTE_SPI1_SSN_GPIO_INSTANCE
#define SPI_SSN_GPIO_INDEX      				 RTE_SPI1_SSN_GPIO_INDEX
#define SPI_SSN_GPIO_PAD_ADDR				 13

#define SPI_CLK_GPIO_INSTANCE				 0	
#define SPI_CLK_GPIO_INDEX                             5
#define SPI_CLK_GPIO_PAD_ADDR                      16

#define SPI_MOSI_GPIO_INSTANCE				 0
#define SPI_MOSI_GPIO_INDEX				 3
#define SPI_MOSI_GPIO_PAD_ADDR                    14

#define SPI_MISO_GPIO_INSTANCE				 0
#define SPI_MISO_GPIO_INDEX				 4
#define SPI_MISO_GPIO_PAD_ADDR			 15
#endif
#else
#define SPI_SSN_GPIO_INSTANCE  				 RTE_SPI1_SSN_GPIO_INSTANCE
#define SPI_SSN_GPIO_INDEX      				 RTE_SPI1_SSN_GPIO_INDEX
#endif
extern ARM_DRIVER_I2C Driver_I2C0;
extern ARM_DRIVER_SPI Driver_SPI0;
extern ARM_DRIVER_SPI Driver_SPI1;
extern ARM_DRIVER_USART Driver_USART2;
extern ARM_DRIVER_USART Driver_USART1;
uint8_t gps_uart_recv_buf[GPS_DATA_RECV_BUFFER_SIZE];
static ARM_DRIVER_SPI   *spiMasterDrv = &CREATE_SYMBOL(Driver_SPI, 1);
static ARM_DRIVER_I2C   *i2cDrvInstance = &CREATE_SYMBOL(Driver_I2C, 0);
static ARM_DRIVER_USART *usartHandle =  &CREATE_SYMBOL(Driver_USART, 2);
static ARM_DRIVER_USART *printfHandle =  &CREATE_SYMBOL(Driver_USART, 1);
//LED define pin index
#define LED_INX_MAX    										 (5)
#define LED_PORT_0      										 (0)
#define LED_PORT_1     										 (1)
/*
	pin1~pin4 for soc display
	pin5  for  fault display
*/
#define LED_GPIO_PIN_1  										 (6)
#define LED_PAD_INDEX1           								 (17)

#define LED_GPIO_PIN_2  										 (7)
#define LED_PAD_INDEX2								              (18)

#define LED_GPIO_PIN_3 										 (0)
#define LED_PAD_INDEX3           								 (21)

#define LED_GPIO_PIN_4 										 (11)
#define LED_PAD_INDEX4								              (22)

#define LED_GPIO_PIN_5   									 (1)
#define LED_PAD_INDEX5								              (27)

led_pin_config_t gLedCfg[LED_INX_MAX]={{LED_PORT_0,LED_GPIO_PIN_1,LED_PAD_INDEX1, PAD_MuxAlt0},\
									 {LED_PORT_0,LED_GPIO_PIN_2,LED_PAD_INDEX2, PAD_MuxAlt0},\
									 {LED_PORT_1,LED_GPIO_PIN_3,LED_PAD_INDEX3, PAD_MuxAlt0},\
									 {LED_PORT_0,LED_GPIO_PIN_4,LED_PAD_INDEX4, PAD_MuxAlt0},\
								       {LED_PORT_1,LED_GPIO_PIN_5,LED_PAD_INDEX5, PAD_MuxAlt0}};

#ifdef BL_FILE_LOG
#include <stdarg.h>
static UINT8 blLogFileNux=0;

//UTCת»»Îª±±¾©Ê±¼ä  º¯Êý¿ÉÖ±½Óµ÷ÓÃ
static void UTCToBeijing(unsigned char * bjttbuf,unsigned int UTCyear,unsigned char UTCmonth,unsigned char UTCday,unsigned int UTChour,unsigned char UTCminute,unsigned char UTCsecond)
{
	int year=0,month=0,day=0,hour=0;
    int lastday = 0;// ÔµÄ×îºóÒ»ÌìÈÕÆÚ
    int lastlastday = 0;//ÉÏÔµÄ×îºóÒ»ÌìÈÕÆÚ
	
	  year=UTCyear;
		month=UTCmonth;
	  day=UTCday;
	  hour=UTChour+8;//UTC+8ת»»Îª±±¾©Ê±¼ä
	
	  if(month==1 || month==3 || month==5 || month==7 || month==8 || month==10 || month==12)
		{
        lastday = 31;
        if(month == 3)
				{
            if((year%400 == 0)||(year%4 == 0 && year%100 != 0))//ÅжÏÊÇ·ñΪÈòÄê
                lastlastday = 29;//ÈòÄêµÄ2ÔÂΪ29Ì죬ƽÄêΪ28Ìì
            else
                lastlastday = 28;
        }
        if(month == 8)
            lastlastday = 31;
    }
    else 
		if(month == 4 || month == 6 || month == 9 || month == 11)
		{
        lastday = 30;
        lastlastday = 31;
    }
    else
		{
        lastlastday = 31;
        if((year%400 == 0)||(year%4 == 0 && year%100 != 0))//ÈòÄêµÄ2ÔÂΪ29Ì죬ƽÄêΪ28Ìì
            lastday = 29;
        else
            lastday = 28;
    }
		if(hour >= 24)//µ±Ëã³öµÄʱ´óÓÚ»òµÈÓÚ24£º00ʱ£¬Ó¦¼õÈ¥24£º00£¬ÈÕÆÚ¼ÓÒ»Ìì
		{
				hour -= 24;
				day += 1; 
				if(day > lastday)//µ±Ëã³öµÄÈÕÆÚ´óÓÚ¸ÃÔÂ×îºóÒ»Ììʱ£¬Ó¦¼õÈ¥¸ÃÔÂ×îºóÒ»ÌìµÄÈÕÆÚ£¬Ô·ݼÓÉÏÒ»¸öÔÂ
				{ 
						day -= lastday;
						month += 1;

						if(month > 12)//µ±Ëã³öµÄÔ·ݴóÓÚ12£¬Ó¦¼õÈ¥12£¬Äê·Ý¼ÓÉÏ1Äê
						{
								month -= 12;
								year += 1;
						}
				}
		}
		
		sprintf((char *)bjttbuf,"%04d-%02d-%02d %02d:%02d:%02d ",
							year,month,day,hour,UTCminute,UTCsecond);	//UTCÈÕÆÚʱ·ÖÃëת»»³É±±¾©Ê±¼ä
}

static void bluejoy_write_logfile(UINT8 * buf)
{
	int32_t err;
	UINT32 Count;
	OSAFILE file;
	while(blLogFileNux){
		 osDelay(10/portTICK_PERIOD_MS);
	}
	blLogFileNux=1;
	file = OsaFopen("blLog","wb");
	if(file==NULL){
		//printf("blLog open fail!\r\n");
		blLogFileNux=0;
		return;
	}
	if(OsaFseek(file, 0, SEEK_END) != 0)
	{
	    //printf("Seek file failed [%d] \r\n",__LINE__);
	    OsaFclose(file);
	    blLogFileNux=0;
	    return;
	}
	Count = OsaFwrite(buf, 1, strlen(buf), file);
	if(Count != (strlen(buf))){
		//printf("blLog write fail!\r\n");

	}
	OsaFclose(file);
	blLogFileNux=0;
}

void bluejoy_read_logfile(void)
{
	int32_t err;
	UINT32 Count;
	OSAFILE file;
	UINT8 rbuf[128+1]={0};
	UINT8 * flag_p;
	UINT16 pri_l; 
	
	printf("%s start\r\n",__FUNCTION__);
	while(blLogFileNux){
		 osDelay(10/portTICK_PERIOD_MS);
	}
	blLogFileNux=1;
	file = OsaFopen("blLog","rb");
	if(file==NULL){
		printf("blLog not exst!\r\n");
		blLogFileNux=0;
		return;
	}
	
	if(OsaFseek(file, 0, SEEK_SET) != 0)
	{
	    printf("Seek file failed [%d] \r\n",__LINE__);
	    OsaFclose(file);
	    blLogFileNux=0;
	    return;
	}
		
	do{	
		memset(rbuf,0,128);
		Count = OsaFread(rbuf, 1, 128, file);
		printf("%s",rbuf);
				
	}while(Count==128);
	
	OsaFclose(file);
	blLogFileNux=0;
	printf("%s end! \r\n",__FUNCTION__);
}

void bluejoy_del_logfile(void)
{
	UINT32 ret;
	//printf("%s start! \r\n",__FUNCTION__);
	while(blLogFileNux){
		 osDelay(10/portTICK_PERIOD_MS);
	}
	blLogFileNux=1;
	OsaFremove("blLog");
	blLogFileNux=0;
	FaultDisplay(LED_TURN_OFF);
	 osDelay(1000/portTICK_PERIOD_MS);
	FaultDisplay(LED_TURN_ON);
	 osDelay(1000/portTICK_PERIOD_MS);
	FaultDisplay(LED_TURN_OFF);
	 osDelay(1000/portTICK_PERIOD_MS);
	FaultDisplay(LED_TURN_ON);
}


void bluejoy_printf(BlLogLevel level, const UINT8 *format, ...)
 {
	UINT8 buf[128+1];
	va_list args;
	OsaUtcTimeTValue    timeUtc;
	UINT16 year;
	UINT8 month,day,hour,minite,sec;
	if(level<BL_LEVEL2)
		return;
	appGetSystemTimeUtcSync(&timeUtc);
	year=(timeUtc.UTCtimer1&0xffff0000)>>16;
	month=(timeUtc.UTCtimer1&0xff00)>>8;
	day=timeUtc.UTCtimer1&0xff;
	hour=(timeUtc.UTCtimer2&0xff000000)>>24;
	minite=(timeUtc.UTCtimer2&0xff0000)>>16;
	sec=(timeUtc.UTCtimer2&0xff00)>>8;
	memset(buf,0,128+1);
	UTCToBeijing(buf,year,month,day,hour,minite,sec);
	va_start(args, format);
	vsnprintf(buf+strlen(buf), 128-strlen(buf), format, args);
	va_end(args);
	//printf("%s", buf);
	bluejoy_write_logfile(buf);
}
#endif



#if 0
/**
  \fn        void NetSocDisplay(UINT8 soc)
  \param[in]  void
  \brief       RSSI display on led
  \return    
*/
#define RSSI_LEVEL_0										 (0)
#define RSSI_LEVEL_10										 (10)
#define RSSI_LEVEL_20										 (20)
#define RSSI_LEVEL_25										 (25)
#define RSSI_LEVEL_30										 (30)
void NetSocDisplay(UINT8 soc)
{
	UINT16 pinLevel[LED_INX_MAX-1] ={0};
	gpio_pin_config_t nGpioCfg={0};
	nGpioCfg.pinDirection = GPIO_DirectionOutput;
	nGpioCfg.misc.initOutput = 1;
	for(int8_t i=0;i< LED_INX_MAX-1;i++){
		GPIO_PinConfig(gLedCfg[i].pinPort, gLedCfg[i].pinInx, &nGpioCfg);
	}
	
	if(RSSI_LEVEL_0 < soc && soc <=RSSI_LEVEL_10)
	{
		pinLevel[0]=1;
		pinLevel[1]=pinLevel[2]=pinLevel[3]=0;
	}
	else if(RSSI_LEVEL_10 < soc && soc <=RSSI_LEVEL_20)
	{
		pinLevel[0]=pinLevel[1]=1;
		pinLevel[2]=pinLevel[3]=0;
	}
	else if(RSSI_LEVEL_20 < soc && soc <=RSSI_LEVEL_25)
	{
		pinLevel[0]=pinLevel[1]=pinLevel[2]=1;
		pinLevel[3]=0;
	}
	else if(RSSI_LEVEL_25 < soc && soc <=RSSI_LEVEL_30)
	{
		pinLevel[0]=pinLevel[1]=pinLevel[2]=pinLevel[3]=1;
	}
	for(UINT8 i=0; i<LED_INX_MAX-1; i++)
	{
		GPIO_PinWrite(gLedCfg[i].pinPort, 1<<gLedCfg[i].pinInx, pinLevel[i]<<gLedCfg[i].pinInx);
	}

}
#endif
void NetSocDisplay(ledInx_t  Inx , ledStaus_t level)
{
	UINT16 pinLevel[LED_INX_MAX-1] ={0};
	gpio_pin_config_t nGpioCfg={0};
	nGpioCfg.pinDirection = GPIO_DirectionOutput;
	nGpioCfg.misc.initOutput = 1;

	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

	padConfig.mux = gLedCfg[Inx].padMutex;
	PAD_SetPinConfig(gLedCfg[Inx].padInx, &padConfig);
      PAD_SetPinPullConfig(gLedCfg[Inx].padInx, PAD_InternalPullDown);

	GPIO_PinConfig(gLedCfg[Inx].pinPort, gLedCfg[Inx].pinInx, &nGpioCfg);
	GPIO_PinWrite(gLedCfg[Inx].pinPort, 1<<gLedCfg[Inx].pinInx, level <<gLedCfg[Inx].pinInx);
}

/**
  \fn      void FaultDisplay(ledStaus_t status)
  \param[in]  status equal to 1 ,turn on red led ; status equal to 0 ,turn off red led
  \brief       RSSI display on led
  \return    
*/
void FaultDisplay(ledStaus_t status)
{
	gpio_pin_config_t nGpioCfg={0};
	nGpioCfg.pinDirection = GPIO_DirectionOutput;
	nGpioCfg.misc.initOutput = 1;
 	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

	padConfig.mux = gLedCfg[4].padMutex;
	PAD_SetPinConfig(gLedCfg[4].padInx, &padConfig);
	PAD_SetPinPullConfig(gLedCfg[4].padInx, PAD_InternalPullDown);
	
	GPIO_PinConfig(gLedCfg[4].pinPort, gLedCfg[4].pinInx, &nGpioCfg);
	GPIO_PinWrite(gLedCfg[4].pinPort, 1<<gLedCfg[4].pinInx, status<<gLedCfg[4].pinInx);
}

/**
* @brief      
* @param
* @return   
*/
void SPI_CS_High(void)
{
    GPIO_PinWrite(SPI_SSN_GPIO_INSTANCE, 1 << SPI_SSN_GPIO_INDEX, 1 << SPI_SSN_GPIO_INDEX);
      
}
/**
* @brief      
* @param
* @return   
*/
void SPI_CS_Low(void)
{
    GPIO_PinWrite(SPI_SSN_GPIO_INSTANCE, 1 << SPI_SSN_GPIO_INDEX, 0);
}
#ifdef SPI_ANALOG
/**
* @brief      
* @param
* @return   
*/
void SPI_Clk_High(void)
{
   	GPIO_PinWrite(SPI_CLK_GPIO_INSTANCE, 1<<SPI_CLK_GPIO_INDEX,1<<SPI_CLK_GPIO_INDEX);      
}
/**
* @brief      
* @param
* @return   
*/
void SPI_Clk_Low(void)
{
   	GPIO_PinWrite(SPI_CLK_GPIO_INSTANCE, 1<<SPI_CLK_GPIO_INDEX,0);
}
/**
* @brief      
* @param
* @return   
*/
void SPI_Mosi_High(void)
{
   	GPIO_PinWrite(SPI_MOSI_GPIO_INSTANCE, 1<<SPI_MOSI_GPIO_INDEX,1<<SPI_MOSI_GPIO_INDEX);     
}
/**
* @brief      
* @param
* @return   
*/
void SPI_Mosi_Low(void)
{
   GPIO_PinWrite(SPI_MOSI_GPIO_INSTANCE, 1<<SPI_MOSI_GPIO_INDEX,0);
}
/**
* @brief      
* @param
* @return   
*/
UINT8 SPI_MISO_Read(void)
{
	return GPIO_PinRead(SPI_MISO_GPIO_INSTANCE,SPI_MISO_GPIO_INDEX);
}
#endif
/**
  * @brief Software SPI_Flash bus driver basic function, send a single byte to MOSI,
  *        and accept MISO data at the same time.
  * @param[in] u8Data:Data sent on the MOSI data line
  * @return    u8Out: Data received on the MISO data line
  */
UINT8 SPI_Write_Byte(UINT8 u8Data)
{
  UINT8 data = u8Data;
#ifdef SPI_ANALOG
	UINT8 i=0;
      for(i=0;i<8;i++){
		SPI_Clk_Low();
		if((u8Data<<i)&0x80)
			SPI_Mosi_High();
		else
			SPI_Mosi_Low();
		SPI_Clk_High();
	}
	SPI_Clk_Low();
#else
	spiMasterDrv->Transfer(&u8Data,&data,1);
#endif
    return 0;
}

#ifdef SPI_ANALOG
/**
* @brief      
* @param
* @return   
*/
UINT8 SPI_Read_Byte(void)
{
	UINT8 i=0;
	UINT8 rByte=0;
	SPI_Clk_Low();
		  
      for(i=0;i<8;i++){
		SPI_Clk_High();
		rByte<<=1;
		rByte |= SPI_MISO_Read();
		SPI_Clk_Low();
	}

    return rByte;
}
#endif
/**
  \fn          INT32 CAN_ReadReg(UINT8 addr)
  \param[in]   addr    CAN register addr
  \brief       write can register
  \return     
*/
INT32 CAN_WriteReg(UINT8 addr, UINT8 value)
{
	SPI_CS_Low();
	SPI_Write_Byte(CAN_WRITE);
	SPI_Write_Byte(addr);
	SPI_Write_Byte(value);
	SPI_CS_High();
   	return 0;
}
/**
  \fn    INT32 CAN_ReadReg(UINT8 reg, UINT8 len, UINT8 *buf)
  \param[in]   reg:  can register addr 
  \brief       read can register
  \return     
*/
INT32 CAN_ReadReg(UINT8 reg, UINT8 len, UINT8 *buf)
{
	UINT8 i =0;
	UINT8 data=0;
	INT32 res;
	if(buf == NULL) return -1;
	
	SPI_CS_Low();
	SPI_Write_Byte(CAN_READ);
	SPI_Write_Byte(reg);
#ifdef SPI_ANALOG
	for(i=0;i<len;i++){
  		buf[i]= SPI_Read_Byte();
	}
#else
	for(i=0;i<len;i++){
		spiMasterDrv->Transfer(&data,&buf[i],1);
	}
#endif
	SPI_CS_High();
	return i;
}
/**
  \fn   UINT8 CanTriggerEvtInit(void)
  \param[in] 
  \brief       generate irq,then notify app
  \return     1 fail; 0 ok;
*/
UINT8 CanTriggerEvtInit(void)
{
	/*for msg queue create*/
	osMessageQueueAttr_t queue_attr;
	memset(&queue_attr, 0, sizeof(queue_attr));
	queue_attr.cb_mem = &can_recv_queue_cb;
	queue_attr.cb_size    = sizeof(can_recv_queue_cb);
	queue_attr.mq_mem  = can_recv_queue_buf;
	queue_attr.mq_size   = sizeof(can_recv_queue_buf);
	can_recv_msgqueue = osMessageQueueNew(I2C_RECV_QUEUE_BUF_SIZE,1, &queue_attr);
	//printf("CanTriggerEvtInit \r\n");
	return 0;
}
/**
  \fn   void CanWaitEvt(UINT32 timeout)
  \param[in]  
  \brief       
  \return     
*/
void CanWaitEvt(UINT32 timeout)
{
	osStatus_t status;
	UINT8 msg = 0;
	UINT32 mask;
	status = osMessageQueueGet(can_recv_msgqueue, &msg, 0 , osWaitForever);
	//printf("msg = %#x\r\n",msg);
}
/**
  \fn    void CanTiggerEvt(UINT8 cmd)
  \param[in]  
  \brief      
  \return     
*/
void CanTiggerEvt(UINT8 cmd)
{
	 osStatus_t status;
	 UINT8 msg = cmd;
	 status = osMessageQueuePut(can_recv_msgqueue, &msg, 0, 0);
}
/*******************************************************************************
* o����y??  : MCP2515_Reset
* ?����?    : ����?��?��????��?����?t?��??MCP2515
* ��?��?    : ?T
* ��?3?    : ?T
* ����???��  : ?T
* ?��?��    : ???��2???��??��?��???a������?���䨬?,2��???��?t����?��?a?????�꨺?
*******************************************************************************/
INT32  HAL_Can_Reset(void)
{
	SPI_CS_Low();
	SPI_Write_Byte(CAN_RESET);
	SPI_CS_High();
	return 0;
}

/*******************************************************************************
* o����y??  : MCP2515_Init
* ?����?    : MCP25153?��??��????
* ��?��?    : ?T
* ��?3?    : ?T
* ����???��  : ?T
* ?��?��    : 3?��??���㨹������o����?t?��???��1�����2����??������???�������?��??��1?????�̨�?��
*******************************************************************************/
void HAL_Can_Init(Can_InitType param)
{
	UINT8 temp=0,temp1=0;
      INT32 res = -1;
	  
	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;
	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

	//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(CNF1,param.baudrate);
	CAN_WriteReg(CNF2,0x80|PHSEG1_3TQ|PRSEG_1TQ);
	CAN_WriteReg(CNF3,PHSEG2_3TQ);
	
	if(param.packType == STD_PACK){
		 /*?����???2��??��??��*/
		CAN_WriteReg(TXB0SIDH,0xFF&(param.TxStdIDH));//����?��?o3??��0������?������?��?????
		CAN_WriteReg(TXB0SIDL,0xE0&(param.TxStdIDL));//����?��?o3??��0������?������?��?�̨�??		

		CAN_WriteReg(RXM0SIDH,0x00);
		CAN_WriteReg(RXM0SIDL,0x00);
		CAN_WriteReg(RXM1SIDH,0x00);
		CAN_WriteReg(RXM1SIDL,0x00);

		/*?����???2��??��??��*/
		CAN_WriteReg(RXF0SIDH,0xFF&(param.RxStdIDH[0]));
		CAN_WriteReg(RXF0SIDL,0xE0&(param.RxStdIDL[0]));
		
		CAN_WriteReg(RXF1SIDH,0xFF&(param.RxStdIDH[1]));
		CAN_WriteReg(RXF1SIDL,0xE0&(param.RxStdIDL[1]));
#if 0
	CAN_WriteReg(RXF2SIDH,0x00);
	CAN_WriteReg(RXF2SIDL,0xa0);
	CAN_WriteReg(RXF3SIDH,0x00);
	CAN_WriteReg(RXF3SIDL,0x40);
	CAN_WriteReg(RXF4SIDH,0x00);
	CAN_WriteReg(RXF4SIDL,0x60);
	CAN_WriteReg(RXF5SIDH,0x00);
	CAN_WriteReg(RXF5SIDL,0x80);
#else
		CAN_WriteReg(RXF2SIDH,0xFF&(param.RxStdIDH[2]));
		CAN_WriteReg(RXF2SIDL,0xE0&(param.RxStdIDL[2]));
		CAN_WriteReg(RXF3SIDH,0xFF&(param.RxStdIDH[3]));
		CAN_WriteReg(RXF3SIDL,0xE0&(param.RxStdIDL[3]));
		CAN_WriteReg(RXF4SIDH,0xFF&(param.RxStdIDH[4]));
		CAN_WriteReg(RXF4SIDL,0xE0&(param.RxStdIDL[4]));
		CAN_WriteReg(RXF5SIDH,0xFF&(param.RxStdIDH[5]));
		CAN_WriteReg(RXF5SIDL,0xE0&(param.RxStdIDL[5]));
#endif
	
		CAN_WriteReg(RXB0CTRL,RXM_RCV_ALL);
		CAN_WriteReg(RXB0DLC,DLC_8);
		
		CAN_WriteReg(RXB1CTRL,RXM_RCV_ALL);
		CAN_WriteReg(RXB1DLC,DLC_8);
	
	}
	else if(param.packType == EXT_PACK)
	{
		/*TXB0*/
		CAN_WriteReg(TXB0SIDH,0xFF&(param.TxStdIDH));
		CAN_WriteReg(TXB0SIDL,(0xEB&(param.TxStdIDL))|0x08);
		CAN_WriteReg(TXB0EID8,0xFF&(param.TxExtIDH));
		CAN_WriteReg(TXB0EID0,0xFF&(param.TxExtIDL));
		
		 /*?����???2��??��??��*/
		CAN_WriteReg(RXM0SIDH,0x00);  //FF->00 zhengchao
		CAN_WriteReg(RXM0SIDL,0x00);  //E3->00 zhengchao
		CAN_WriteReg(RXM0EID8,0x00);  //FF->00 zhengchao
		CAN_WriteReg(RXM0EID0,0x00);  //FF->00 zhengchao

		/*?����???2��??��??��*/
		CAN_WriteReg(RXF0SIDH,0xFF&(param.RxStdIDH[0]));
		CAN_WriteReg(RXF0SIDL,(0xEB&(param.RxStdIDL[0]))|0x08);
		CAN_WriteReg(RXF0EID8,0xFF&(param.RxExtIDH[0]));
		CAN_WriteReg(RXF0EID8,0xFF&(param.RxExtIDL[0]));

		CAN_WriteReg(RXF1SIDH,0xFF&(param.RxStdIDH[1]));
		CAN_WriteReg(RXF1SIDL,(0xEB&(param.RxStdIDL[1]))|0x08);
		CAN_WriteReg(RXF1EID8,0xFF&(param.RxExtIDH[1]));
		CAN_WriteReg(RXF1EID8,0xFF&(param.RxExtIDL[1]));

		CAN_WriteReg(RXF2SIDH,0xFF&(param.RxStdIDH[2]));
		CAN_WriteReg(RXF2SIDL,(0xEB&(param.RxStdIDL[2]))|0x08);
		CAN_WriteReg(RXF2EID8,0xFF&(param.RxExtIDH[2]));
		CAN_WriteReg(RXF2EID8,0xFF&(param.RxExtIDL[2]));

		CAN_WriteReg(RXF3SIDH,0xFF&(param.RxStdIDH[3]));
		CAN_WriteReg(RXF3SIDL,(0xEB&(param.RxStdIDL[3]))|0x08);
		CAN_WriteReg(RXF3EID8,0xFF&(param.RxExtIDH[3]));
		CAN_WriteReg(RXF3EID8,0xFF&(param.RxExtIDL[3]));

		CAN_WriteReg(RXF4SIDH,0xFF&(param.RxStdIDH[4]));
		CAN_WriteReg(RXF4SIDL,(0xEB&(param.RxStdIDL[4]))|0x08);
		CAN_WriteReg(RXF4EID8,0xFF&(param.RxExtIDH[4]));
		CAN_WriteReg(RXF4EID8,0xFF&(param.RxExtIDL[4]));

		CAN_WriteReg(RXF5SIDH,0xFF&(param.RxStdIDH[5]));
		CAN_WriteReg(RXF5SIDL,(0xEB&(param.RxStdIDL[5]))|0x08);
		CAN_WriteReg(RXF5EID8,0xFF&(param.RxExtIDH[5]));
		CAN_WriteReg(RXF5EID8,0xFF&(param.RxExtIDL[5]));
		
	
		CAN_WriteReg(RXB0CTRL,RXM_VALID_EXT|BUKT_ROLLOVER);
		CAN_WriteReg(RXB0DLC,DLC_8);
		
		CAN_WriteReg(RXB1CTRL,RXM_VALID_EXT|FILHIT1_FLTR_2);
		CAN_WriteReg(RXB1DLC,DLC_8);
	
	}

	//CAN_WriteReg(BFPCTRL,0x0F);//zhengchao20210304  add
	CAN_WriteReg(CANINTE,0x43); //zhengchao20210304  0x43 -> 0x03
	CAN_WriteReg(CANINTF,0x00);
	
	CAN_WriteReg(CANCTRL,param.mode |CLKOUT_ENABLED);//??MCP2515¨¦¨¨???a?y3¡ê?¡ê¨º?,¨ª?3??????¡ê¨º? REQOP_NORMAL|CLKOUT_ENABLED
      CAN_ReadReg(CANSTAT,1,&temp);//?¨¢¨¨?CAN¡Á¡ä¨¬???¡ä??¡Â¦Ì??¦Ì
	if(param.mode !=(temp&0xE0))//?D??MCP2515¨º?¡¤?¨°??-??¨¨??y3¡ê?¡ê¨º?
	{
    		CAN_WriteReg(CANCTRL,param.mode|CLKOUT_ENABLED);//?¨´¡ä???MCP2515¨¦¨¨???a?y3¡ê?¡ê¨º?,¨ª?3??????¡ê¨º?REQOP_NORMAL
	}
}

/*******************************************************************************
* : HAL_Can_Sleep
* 
* 
* 
* 
* 
*******************************************************************************/
void HAL_Can_Sleep(void)
{
	UINT8 temp=0,temp2=0,t=0;
	do{
		CAN_WriteReg(CANCTRL,OPMODE_CONFIG);
		CAN_WriteReg(CANINTE,WAKIE|RX0IE|RX1IE);
		//CAN_WriteReg(CNF3, WAKFIL);		
		CAN_ReadReg(CANSTAT,1,&temp);
		CAN_WriteReg(CANCTRL,OPMODE_SLEEP |CLKOUT_DISABLED);
		#ifdef USING_PRINTF
		//printf("%s[%d] [%#x]\r\n",__FUNCTION__, __LINE__,temp);
		#endif		
		if(OPMODE_SLEEP ==(temp&0xE0)){
			#ifdef USING_PRINTF
				//printf("SLEEP SUC \r\n");
			#endif	
			break;
		}
	}while(t++<3);

	//POWER
	GPIO_PinWrite(0, 1 << GPIO_CAN_POWER, 0);
}


/*******************************************************************************
* o¡¥¨ºy??  : HAL_Can_Transmit
* ?¨¨¨º?    : CAN¡¤¡é?¨ª???¡§3¡è?¨¨¦Ì?¨ºy?Y
* ¨º?¨¨?    : *CAN_TX_Buf(¡äy¡¤¡é?¨ª¨ºy?Y?o3???????),len(¡äy¡¤¡é?¨ª¨ºy?Y3¡è?¨¨)
* ¨º?3?    : ?T
* ¡¤¦Ì???¦Ì  : ?T
* ?¦Ì?¡Â    : ?T
*******************************************************************************/
INT8  HAL_Can_Transmit(CAN_Msg_Type Can_TxMsg)
{
	UINT8 tryTim,count,value,i,temp,TXBufferCase = 0;
	INT8 ret = 0;
	UINT8 TXB0CTRLvalue,TXB1CTRLvalue,TXB2CTRLvalue,CANINTFValue=0;
	CAN_ReadReg(TXB0CTRL, 1, &TXB0CTRLvalue);
	CAN_ReadReg(TXB1CTRL, 1, &TXB1CTRLvalue);
	CAN_ReadReg(TXB2CTRL, 1, &TXB2CTRLvalue);

	if((TXB0CTRLvalue&TXREQ)==0)
		TXBufferCase = 0;
	else if((TXB1CTRLvalue&TXREQ)==0)
		TXBufferCase =1;
	else if((TXB2CTRLvalue&TXREQ)==0)
		TXBufferCase =2;
	
	switch(TXBufferCase)
	{

		case 0:
		{
			//tryTim=0;
			//CAN_RseadReg(TXB0CTRL,1,&value);
			
			//while((value&0x08) && (tryTim<50))//?��?��?��?3D?���䨬???��?,�̨���yTXREQ����????��?
			//{
			//	CAN_ReadReg(TXB0CTRL,1,&value);
			//	osDelay(1/portTICK_PERIOD_MS);
			//	tryTim++;
			//}
			
			/*TXB0*/
			CAN_WriteReg(TXB0SIDH,0xFF&((Can_TxMsg.Id)>>3));//����?��?o3??��0������?������?��?????
			CAN_WriteReg(TXB0SIDL,0xE0&((Can_TxMsg.Id)<<5));//����?��?o3??��0������?������?��?�̨�??	
			for(i=0;i<Can_TxMsg.DLC;i++)
			{
				CAN_WriteReg(TXB0D0+i,Can_TxMsg.Data[i]);//??��y����?����?��y?YD�䨨?����?��?o3???��??��
				
			}
			CAN_WriteReg(TXB0DLC,Can_TxMsg.DLC);//??��???��y����?����?��y?Y3��?��D�䨨?����?��?o3??��0��?����?��3��?��??��??��
			SPI_CS_Low();
			CAN_WriteReg(TXB0CTRL,TXREQ);//???������?������??
			//SPI_CS_High();

			ret = 0;
			break;
		}
		case 1:
		{
			/*TXB0*/
			CAN_WriteReg(TXB1SIDH,0xFF&((Can_TxMsg.Id)>>3));//����?��?o3??��0������?������?��?????
			CAN_WriteReg(TXB1SIDL,0xE0&((Can_TxMsg.Id)<<5));//����?��?o3??��0������?������?��?�̨�??	
			for(i=0;i<Can_TxMsg.DLC;i++)
			{
				CAN_WriteReg(TXB1D0+i,Can_TxMsg.Data[i]);//??��y����?����?��y?YD�䨨?����?��?o3???��??��
				
			}
			CAN_WriteReg(TXB1DLC,Can_TxMsg.DLC);//??��???��y����?����?��y?Y3��?��D�䨨?����?��?o3??��0��?����?��3��?��??��??��
			SPI_CS_Low();
			CAN_WriteReg(TXB1CTRL,TXREQ);//???������?������??
			//SPI_CS_High();

			
			ret = 1;
			break;
		}
		case 2:
		{	
			/*TXB0*/
			CAN_WriteReg(TXB2SIDH,0xFF&((Can_TxMsg.Id)>>3));//����?��?o3??��0������?������?��?????
			CAN_WriteReg(TXB2SIDL,0xE0&((Can_TxMsg.Id)<<5));//����?��?o3??��0������?������?��?�̨�??	
			for(i=0;i<Can_TxMsg.DLC;i++)
			{
				CAN_WriteReg(TXB2D0+i,Can_TxMsg.Data[i]);//??��y����?����?��y?YD�䨨?����?��?o3???��??��
				
			}
			CAN_WriteReg(TXB2DLC,Can_TxMsg.DLC);//??��???��y����?����?��y?Y3��?��D�䨨?����?��?o3??��0��?����?��3��?��??��??��
			SPI_CS_Low();
			CAN_WriteReg(TXB2CTRL,TXREQ);//???������?������??
			//SPI_CS_High();

			
			ret = 2;
			break;
		}
		default:
		{
			ret = -1;
			break;
		}
	}

	CAN_ReadReg(TXB0CTRL, 1, &TXB0CTRLvalue);
	CAN_ReadReg(TXB1CTRL, 1, &TXB1CTRLvalue);
	CAN_ReadReg(TXB2CTRL, 1, &TXB2CTRLvalue);

	tryTim = 0;
	while((TXB0CTRLvalue&TXREQ) && (TXB1CTRLvalue&TXREQ) && (TXB1CTRLvalue&TXREQ) && (tryTim<50))
	{
		//SPI_CS_High();
		CAN_ReadReg(TXB0CTRL, 1, &TXB0CTRLvalue);
		CAN_ReadReg(TXB1CTRL, 1, &TXB1CTRLvalue);
		CAN_ReadReg(TXB2CTRL, 1, &TXB2CTRLvalue);
		osDelay(1);
		tryTim++;
	}
	CAN_ReadReg(CANINTF, 1, &CANINTFValue);
	SPI_CS_High();
	if((TXB0CTRLvalue&0x20)||(TXB1CTRLvalue&0x20)||(TXB2CTRLvalue&0x20)||(CANINTFValue&0x80))
	{
		ret = -1;
		
	}
	
	
	return ret;
}

/*******************************************************************************
* o����y??  :  HAL_Can_Receive(UINT8 *CAN_RX_Buf)
* ?����?    : CAN?����?��???��y?Y
* ��?��?    : *CAN_TX_Buf(��y?����?��y?Y?o3???????)
* ��?3?    : ?T
* ����???��  : len(?����?��?��y?Y��?3��?��,0~8��??��)
* ?��?��    : ?T
*******************************************************************************/
void  HAL_Can_Receive(CAN_Msg_Type* CanRxMsgBuffer)
{
	
	UINT8 i=0,len=0,temp=0;
	UINT8 SIdH,SIdL,EId8,EId0;
	//static UINT16 counterBuff0,counterBuff1 = 0;
	
	CAN_ReadReg(CANINTF,1,&temp);
#ifdef USING_PRINTF
	//printf("CANINTF = 0x%x\n",temp);
	//USARTdrv->Send(&temp,1);
#endif
	if(temp & 0x01)  //Rx Buffer 0
	{	
		/*get the id information*/
		CAN_ReadReg(RXB0SIDH,1,&SIdH);
		CAN_ReadReg(RXB0SIDL,1,&SIdL);
		CAN_ReadReg(RXB0EID8,1,&EId8);
		CAN_ReadReg(RXB0EID0,1,&EId0);
		
		CAN_ReadReg(RXB0DLC,1,&len);		
		len = len&0x0F;
		CanRxMsgBuffer[0].DLC = len;

		if(SIdL & 0x8)  // if SIdL.3 = 1, the id belongs to ExtID
		{
			(CanRxMsgBuffer[0]).Id = ((SIdH<<5 | (SIdL>>5)<<2 | SIdL&0x3 )<<16 | (EId8<<8) | EId0);
		}
		else
		{
			(CanRxMsgBuffer[0]).Id = SIdH<<3 | SIdL>>5;
		}
		
		i = 0;
		while(i<len)
		{	
			CAN_ReadReg(RXB0D0+i,1,&((CanRxMsgBuffer[0]).Data[i]));
			i++;
		}	
	#ifdef USING_PRINTF1		
		printf("buffer0 ID = %x\n",CanRxMsgBuffer[0].Id);
		for(i=0;i<8;i++)
		{
			printf("%x ",CanRxMsgBuffer[0].Data[i]);
		}
		printf("\n");
	#endif
		
	}
	if(temp & 0x02)  //RX Buffer 1
	{
		/*get the id information*/
		CAN_ReadReg(RXB1SIDH,1,&SIdH);
		CAN_ReadReg(RXB1SIDL,1,&SIdL);
		CAN_ReadReg(RXB1EID8,1,&EId8);
		CAN_ReadReg(RXB1EID0,1,&EId0);
		
		CAN_ReadReg(RXB1DLC,1,&len);		
		len = len & 0x0F;
		CanRxMsgBuffer[1].DLC = len;
	
		if(SIdL & 0x8)  // SIdL.3 = 1, ExtID
		{
			(CanRxMsgBuffer[1]).Id = ((SIdH<<5 | (SIdL>>5)<<2 | SIdL&0x3 )<<16 | (EId8<<8) | EId0);
		}
		else
		{
			(CanRxMsgBuffer[1]).Id = SIdH<<3 | SIdL>>5;
		}

		i = 0 ;
		while(i<len)
		{	
			CAN_ReadReg(RXB1D0+i,1,&((CanRxMsgBuffer[1]).Data[i]));
			i++;			
		}

	#ifdef USING_PRINTF1		
		printf("buffer1 ID = %x\n",CanRxMsgBuffer[1].Id);
		for(i=0;i<8;i++)
		{
			printf("%x ",CanRxMsgBuffer[1].Data[i]);
		}
		printf("\n");
	#endif
		
	}
	CAN_WriteReg(CANINTF,0);
//	CAN_ReadReg(CANINTF,1,&temp);
//	printf("CANINTF_1 = 0x%x\n",temp);
	
}

/**
  \fn          void CanHandleDataCallback(UINT32 event)
  \param[in]  event    spi irq event
  \brief         base on event,handle different situation
  \return      
*/
void CanHandleDataCallback(UINT32 event)
{
    if(event & ARM_SPI_EVENT_TRANSFER_COMPLETE)
    {
       
    }
   else if(event & ARM_SPI_EVENT_DATA_LOST)
   {

   }
   else if(event & ARM_SPI_EVENT_MODE_FAULT)
   {

   }
#if 0
#ifdef USING_PRINTF
		//printf("[%d] CanHandleDataCallback :%d\r\n",__LINE__,event);
#else				
    		ECOMM_TRACE(UNILOG_PLA_APP,CAN_CB1, P_INFO, 1, "SPI event [%u] coming!",event);
#endif
#endif
}
/**
  \fn          void CanSPIHandler(ARM_SPI_SignalEvent_t cb_event)
  \param[in]  cb_event   :
  \brief        init spi module
  \return      
*/
void CanSPIHandler(ARM_SPI_SignalEvent_t cb_event,UINT8 mode,UINT8 dataBits, UINT32 spiRate )
{
#ifdef SPI_ANALOG
	gpio_pin_config_t nGpioCfg={0};
	nGpioCfg.pinDirection = GPIO_DirectionOutput;
	nGpioCfg.misc.initOutput = 1;

	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);
	/*cs*/
	padConfig.mux = PAD_MuxAlt0;
	PAD_SetPinConfig(SPI_SSN_GPIO_PAD_ADDR, &padConfig);
      PAD_SetPinPullConfig(SPI_SSN_GPIO_PAD_ADDR, PAD_InternalPullDown);

	GPIO_PinConfig(SPI_SSN_GPIO_INSTANCE, SPI_SSN_GPIO_INDEX, &nGpioCfg);
	GPIO_PinWrite(SPI_SSN_GPIO_INSTANCE, 1<<SPI_SSN_GPIO_INDEX,0);
	/*
		clk
	*/
	padConfig.mux = PAD_MuxAlt0;
	PAD_SetPinConfig(SPI_CLK_GPIO_PAD_ADDR, &padConfig);
      PAD_SetPinPullConfig(SPI_CLK_GPIO_PAD_ADDR, PAD_InternalPullDown);

	GPIO_PinConfig(SPI_CLK_GPIO_INSTANCE, SPI_CLK_GPIO_INDEX, &nGpioCfg);
	GPIO_PinWrite(SPI_CLK_GPIO_INSTANCE, 1<<SPI_CLK_GPIO_INDEX,0);

	/*mosi*/
	padConfig.mux = PAD_MuxAlt0;
	PAD_SetPinConfig(SPI_MOSI_GPIO_PAD_ADDR, &padConfig);
      PAD_SetPinPullConfig(SPI_MOSI_GPIO_PAD_ADDR, PAD_InternalPullDown);

	GPIO_PinConfig(SPI_MOSI_GPIO_INSTANCE, SPI_MOSI_GPIO_INDEX, &nGpioCfg);
	GPIO_PinWrite(SPI_MOSI_GPIO_INSTANCE, 1<<SPI_MOSI_GPIO_INDEX,0);
	/*miso*/
	nGpioCfg.pinDirection = GPIO_DirectionInput;
	nGpioCfg.misc.initOutput = 0;

	padConfig.mux = PAD_MuxAlt0;
	padConfig.pullSelect = PAD_PullInternal;
	padConfig.pullUpEnable = PAD_PullUpDisable;
	padConfig.pullDownEnable = PAD_PullDownEnable;
	PAD_SetPinConfig(SPI_MISO_GPIO_PAD_ADDR, &padConfig);

	GPIO_PinConfig(SPI_MISO_GPIO_INSTANCE, SPI_MISO_GPIO_INDEX, &nGpioCfg);
		
#else
    // Initialize master spi
   spiMasterDrv->Initialize(NULL);
    // Power on
    spiMasterDrv->PowerControl(ARM_POWER_FULL);	
	// Configure slave spi bus
    spiMasterDrv->Control(ARM_SPI_MODE_MASTER | mode | ARM_SPI_DATA_BITS(dataBits) |ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_SW, spiRate);
#endif
}
/**
  \fn   INT32 ZM01RecvParam(UINT8 *param)
  \param[in]   
  \brief       read ZM01 register
  \return    execution_status
*/
INT32 ZM01RecvParam(UINT8 *param)
{
    INT32 res = 0;
    UINT8 tempBuffer = 0xaa;
   if(param == NULL) return -7;
   res = i2cDrvInstance->MasterTransmit(ZM01_DEVICE_ADDR, &tempBuffer, 1, true);

    res = i2cDrvInstance->MasterReceive(ZM01_DEVICE_ADDR, param, 1, true);

    return res;
}
/**
  \fn         INT32 GSENSOR_WriteReg(UINT8 addr, UINT8 value)
  \param[in]   addr    GSENSOR register addr
  \brief       Write to GSENSOR register
  \return     
*/
INT32 GSENSOR_WriteReg(UINT8 addr, UINT8 value)
{
    UINT8 tempBuffer[2];
    INT32 res = -1;
    tempBuffer[0] = addr;
    tempBuffer[1] = value;
    return (i2cDrvInstance->MasterTransmit(GSENSOR_DEVICE_ADDR, tempBuffer, sizeof(tempBuffer), true));
}
/**
  \fn         INT32 GSENSOR_ReadReg(UINT8 reg, UINT8 len, UINT8 *buf)
  \param[in]   addr    GSENSOR register addr
  \brief       read GSENSOR register
  \return      register value of GSENSOR
*/
INT32 GSENSOR_ReadReg(UINT8 reg, UINT8 len, UINT8 *buf)
{
    INT32 res = -1;
    if(len > 8 || buf == NULL) return -1;
	
    res = i2cDrvInstance->MasterTransmit(GSENSOR_DEVICE_ADDR, &reg, 1, true);

    res = i2cDrvInstance->MasterReceive(GSENSOR_DEVICE_ADDR, buf, len, true);

    return res;

}
/**
  \fn         void GsensorI2CCallback(UINT32 event)
  \param[in]  event   : i2c irq event
  \brief        i2c irq event ,callback function
  \return      
*/
void GsensorI2CCallback(UINT32 event)
{
	switch(event)
	{
		case ARM_I2C_EVENT_TRANSFER_DONE:

		break;
		case ARM_I2C_EVENT_TRANSFER_INCOMPLETE:

		break;
		case ARM_I2C_EVENT_ADDRESS_NACK:

		break;
		case ARM_I2C_EVENT_BUS_ERROR:

		break;
		case ARM_I2C_EVENT_BUS_CLEAR:

		break;
		default:
		break;
	}

}
/**
  \fn  void HAL_I2C_CreateRecvTaskAndQueue(uint32_t event)
  \param[in]  
  \brief       RECV data
  \return      
*/
void HAL_I2C_RecvControl(bool on)
{
    EC_ASSERT(g_i2CRecvFlag, g_i2CRecvFlag, 0, 0);

    if(on == true)
    {
        osEventFlagsClear(g_i2CRecvFlag, I2C_RECV_CONTROL_FLAG);
    }
    else
    {
        osEventFlagsSet(g_i2CRecvFlag, I2C_RECV_CONTROL_FLAG);
    }
}
void GsensorTriggerEvent(UINT32 event ,UINT32 data)
{
	 osStatus_t status;
	 i2c_recv_msgqueue_obj_t msg={0};

	 msg.event = event;
	 msg.value = data;
	 status = osMessageQueuePut(i2c_recv_msgqueue, &msg, 0, 0);
        if(status == osErrorResource)
        {
            ECOMM_TRACE(UNILOG_PLA_DRIVER, GsensorTriggerEvent_0, P_WARNING, 0, "I2C recv queue error");
        }

}

static INT32 	I2CEvtProcess(uint32_t evt)
{
    INT32 ret;
#if SL_SC7A20_16BIT_8BIT
    INT16 xyzData[7];
#else
    INT8 xyzData[7];
#endif
    HAL_I2C_RecvControl(true);

    if(evt & I2C_INT1_REQ_BITMAP)
    {

    }

    if(evt & I2C_INT2_REQ_BITMAP)
    {
	SL_SC7A20_Read_XYZ_Data(xyzData);
    }
   
    return 0;
}

static void HAL_I2C_RecvTaskEntry(void)
{
	while(1)
	{
		uint32_t flag,mask;
		osStatus_t status;
		i2c_recv_msgqueue_obj_t msg;

		flag = osEventFlagsWait(g_i2CRecvFlag, I2C_RECV_CONTROL_FLAG, osFlagsNoClear | osFlagsWaitAll, osWaitForever);

 		EC_ASSERT(flag == I2C_RECV_CONTROL_FLAG, flag, 0, 0);

		status = osMessageQueueGet(i2c_recv_msgqueue, &msg, 0 , osWaitForever);
		if(status == osOK)
		{

		      mask = SaveAndSetIRQMask();
			//handle data
			//I2CEvtProcess(msg.event);
#ifdef USING_PRINTF
			//printf("[%d]i2c recv event\r\n",__LINE__);
#else				
    			ECOMM_TRACE(UNILOG_PLA_DRIVER, I2C_GSENSOR_D, P_INFO, 0, "i2c recv event");
#endif
			RestoreIRQMask(mask);  
		}
	}

}
static void HAL_I2C_CreateRecvTaskAndQueue(void)
{
	if(g_halI2CInitFlag & HAL_I2C_RECV_TASK_QUEUE_CREATED)
	{
		return;
	}
	/*
	    for task create
	*/
	osThreadId_t threadId;
	
	osThreadAttr_t task_attr;
	/*for msg queue create*/
	osMessageQueueAttr_t queue_attr;
	
	g_i2CRecvFlag =  osEventFlagsNew(NULL);

   	EC_ASSERT(g_i2CRecvFlag, g_i2CRecvFlag, 0, 0);

	memset(&queue_attr, 0, sizeof(queue_attr));
	queue_attr.cb_mem = &i2c_recv_queue_cb;
	queue_attr.cb_size    = sizeof(i2c_recv_queue_cb);
	queue_attr.mq_mem  = i2c_recv_queue_buf;
	queue_attr.mq_size   = sizeof(i2c_recv_queue_buf);

	i2c_recv_msgqueue = osMessageQueueNew(I2C_RECV_QUEUE_BUF_SIZE,sizeof(i2c_recv_msgqueue_obj_t), &queue_attr);
	EC_ASSERT(i2c_recv_msgqueue, i2c_recv_msgqueue, 0, 0);

	memset(& task_attr, 0, sizeof(task_attr));
	memset(i2c_recv_task_stack, 0xA5, I2C_RECV_TASK_STACK_SIZE);

	task_attr.name = "GsensorRecv";
	task_attr.stack_size = I2C_RECV_TASK_STACK_SIZE;
	task_attr.stack_mem = i2c_recv_task_stack;
	task_attr.priority = osPriorityNormal;
	task_attr.cb_mem = &i2c_recv_task;
	task_attr.cb_size = sizeof(StaticTask_t);

	threadId =  osThreadNew(HAL_I2C_RecvTaskEntry, NULL, &task_attr);

	EC_ASSERT(threadId, threadId, 0, 0);
	
	g_halI2CInitFlag |=  HAL_I2C_RECV_TASK_QUEUE_CREATED;
	
}



/**
  \fn     void Usart1Handler(uint8_t* strPtr, uint16_t strLen)
  \param[in]  PrintfSendStr for  usart port;
  \brief       config  usart port
  \return      
*/
void PrintfSendStr(const UINT8 *format, ...)
{
	va_list args;
	UINT8 buf[128+1]={0};
	va_start(args, format);
	vsnprintf(buf+strlen(buf), 128-strlen(buf), format, args);
	va_end(args);
	HAL_UART_SendStr(PORT_USART_1,buf,strlen(buf));

}

#define PRINTF_DATA_RECV_BUFFER_SIZE     						(64)
uint8_t printf_uart_recv_buf[PRINTF_DATA_RECV_BUFFER_SIZE];
/**
  \fn    void PrintfDataRecvCallback(uint32_t event, void* dataPtr, uint32_t dataLen)
  \param[in]  event   :Data receiving timeout processing and data receiving completion processing;
  \		    dataPtr : Point to receive data buff
  \		    dataLen : Received data length	
  \brief        i2c irq event ,callback function
  \return      
*/
void PrintfDataRecvCallback(UINT32 event, void* dataPtr, UINT32 dataLen)
{
	//ECOMM_TRACE(UNILOG_PLA_APP, PrintfDataRecvCallback, P_SIG, 3, "event=%d, dataPtr=%s, dataLen=%d",event,dataPtr,dataLen);
    slpManStartWaitATTimer(); 
}

void printfPostSendCallback(hal_uart_send_msg_type_t msgType, void* dataPtr, uint32_t dataLen){
	// ECOMM_TRACE(UNILOG_PLA_APP, printfPostSendCallback, P_SIG, 3, "msgType=%d, dataPtr=%s, dataLen=%d",msgType,dataPtr,dataLen);
}

/**
  \fn     void Usart1Handler(UINT32 baudRate)
  \param[in]  baudRate for  usart port;
  \brief       config  usart port
  \return      
*/
void Usart1Handler(UINT32 baudRate)
{
	hal_uart_config_t halUartConfig = {0};

	hal_uart_hardware_config_t hwConfig = {
	                                        ARM_POWER_FULL,
	                                        ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_8 |
	                                        ARM_USART_PARITY_NONE       | ARM_USART_STOP_BITS_1 |
	                                        ARM_USART_FLOW_CONTROL_NONE,
	                                        baudRate
	                                       };



	halUartConfig.uartDriverHandler = printfHandle;
	halUartConfig.recv_cb = PrintfDataRecvCallback;
	halUartConfig.recvBuffPtr = printf_uart_recv_buf;
	halUartConfig.recvBuffSize = PRINTF_DATA_RECV_BUFFER_SIZE;
       halUartConfig.post_send_cb = printfPostSendCallback;
	HAL_UART_InitHandler(PORT_USART_1, &halUartConfig, &hwConfig, HAL_UART_TASK_CREATE_FLAG_SEND_RECV);
	HAL_UART_RecvFlowControl(false);
}



/**
  \fn         void GsensorI2CCallback(uint32_t event)
  \param[in]  event   : i2c irq event
  \brief        i2c irq event ,callback function
  \return      
*/
void GsensorI2CHandler(ARM_I2C_SignalEvent_t cb_event)
{
    // Initialize with callback
     i2cDrvInstance->Initialize(cb_event);
    // Power on
     i2cDrvInstance->PowerControl(ARM_POWER_FULL);
     // Configure I2C bus
     i2cDrvInstance->Control(ARM_I2C_BUS_SPEED, ARM_I2C_BUS_SPEED_STANDARD);
     i2cDrvInstance->Control(ARM_I2C_BUS_CLEAR, 0);
     HAL_I2C_CreateRecvTaskAndQueue();	 
#ifdef USING_PRINTF
   //printf("[%d] i2c config ok\r\n",__LINE__);
#else	 
     ECOMM_TRACE(UNILOG_PLA_DRIVER, I2C_GSENSOR_I, P_INFO, 0, "i2c config ok");
#endif
}

/**
  \fn     void GPSSendStr(uint8_t* strPtr, uint16_t strLen)
  \param[in]  strPtr for gps usart port;
  \brief    
  \return      
*/
void GPSSendStr(uint8_t* strPtr, uint16_t strLen)
{
	HAL_UART_SendStr(PORT_USART_2,strPtr,strLen);

}
/**
  \fn    void GpsDataRecvCallback(uint32_t event, void* dataPtr, uint32_t dataLen)
  \param[in]  event   :Data receiving timeout processing and data receiving completion processing;
  \		    dataPtr : Point to receive data buff
  \		    dataLen : Received data length	
  \brief        i2c irq event ,callback function
  \return      
*/
void GpsDataRecvCallback(UINT32 event, void* dataPtr, UINT32 dataLen)
{
   if((event == ARM_USART_EVENT_RX_TIMEOUT) || (event == ARM_USART_EVENT_RECEIVE_COMPLETE)){
	    #ifdef USING_PRINTF	
	    //	//printf("GpsDataRecvCallback [%d] %s\r\n",dataLen,dataPtr);
	    #endif 
		if(gpsHandle!=NULL && dataLen>0){
			gpsReqMsg gpsInfo;
			gpsInfo.dataPtr=malloc(dataLen+1);
			if(gpsInfo.dataPtr){
				memcpy(gpsInfo.dataPtr,dataPtr,dataLen);	
				gpsInfo.len=dataLen;
				osMessageQueuePut(gpsHandle, &gpsInfo, 0, 2000);
			}
		}
   }
    slpManStartWaitATTimer(); 
}
/**
  \fn     void GPSUsartHandler(ARM_DRIVER_USART * uartDriverHandler, uint32_t baudRate)
  \param[in]  baudRate for gps usart port;
  \brief       config gps usart port
  \return      
*/
void GPSUsartHandler(UINT32 baudRate)
{
	hal_uart_config_t halUartConfig = {0};

	hal_uart_hardware_config_t hwConfig = {
	                                        ARM_POWER_FULL,
	                                        ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_8 |
	                                        ARM_USART_PARITY_NONE       | ARM_USART_STOP_BITS_1 |
	                                        ARM_USART_FLOW_CONTROL_NONE,
	                                        baudRate
	                                       };



	halUartConfig.uartDriverHandler = usartHandle;
	halUartConfig.recv_cb = GpsDataRecvCallback;
	halUartConfig.recvBuffPtr = gps_uart_recv_buf;
	halUartConfig.recvBuffSize = GPS_DATA_RECV_BUFFER_SIZE;
	HAL_UART_InitHandler(PORT_USART_2, &halUartConfig, &hwConfig, HAL_UART_TASK_CREATE_FLAG_SEND_RECV);
	HAL_UART_RecvFlowControl(false);
}

/**
  \fn  INT32 AdcGetRes(UINT32 NTCvalue)
  \param[in]  req : NTCvalue
  \brief     
  \return    Resvalue
*/
static INT32 AdcGetRes(UINT32 NTCvalue){
	UINT32 Resvalue;
	if(NTCvalue>=(ADC_ChannelAioVbat-10))
		Resvalue=1000000;
	else{
		Resvalue=(long long)ADC_ChannelAioRes*(long long)NTCvalue/(ADC_ChannelAioVbat-NTCvalue);
	}
	return Resvalue;
}

/**
  \fn  INT32 AdcGetRes(UINT32 NTCvalue)
  \param[in]  req : NTCvalue
  \brief     
  \return    Resvalue
*/
static INT32 AdcGetResFromInres(UINT32 NTCvalue){
	UINT32 Resvalue,ResvalueCount;
	if(NTCvalue>=(ADC_ChannelAioVbat-10))
		ResvalueCount=1000000;
	else{
		ResvalueCount=ADC_ChannelAioRes*NTCvalue/(ADC_ChannelAioVbat-NTCvalue);
	}

    #ifdef USING_PRINTF	
    	//printf("%s[%d][%d][%d]\r\n",__FUNCTION__, __LINE__,ADC_InsideRES,ResvalueCount);
    #endif

	if(ResvalueCount>=ADC_InsideRES)
		Resvalue=1000000;
	else
		Resvalue=(long long)ADC_InsideRES*(long long)ResvalueCount/(ADC_InsideRES-ResvalueCount);
	
    #ifdef USING_PRINTF	
    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,Resvalue);
    #endif
	
	return Resvalue;
}


/**
  \fn  INT32 AdcVbatCali(UINT32 NTCvalue)
  \param[in]  req : NTCvalue
  \brief     
  \return    Resvalue
*/
static INT32 AdcVbatCali(UINT32 NTCvalue){
	UINT32 Resvalue;
	if(NTCvalue>=(ADC_ChannelAioVbat-10))
		Resvalue=1000000;
	else{
		Resvalue=(long long)(ADC_ChannelAioRes+ADC_CALIBRATION_VALUE)*(long long)NTCvalue/ADC_CALIBRATION_VALUE;				//ADC_ChannelAioRes*NTCvalue/(ADC_ChannelAioVbat-NTCvalue);
	}
	if(Resvalue<1300&&Resvalue>1100)
		ADC_ChannelAioVbat=Resvalue;
	return Resvalue;
}

/**
  \fn  INT32 AdcInresCali(UINT32 NTCvalue)
  \param[in]  req : NTCvalue
  \brief     
  \return    Resvalue
*/
static INT32 AdcInresCali(UINT32 NTCvalue){
	UINT32 Resvalue,ResvalueCount;
	if(NTCvalue>=(ADC_ChannelAioVbat-10))
		ResvalueCount=1000000;
	else{
		ResvalueCount=ADC_ChannelAioRes*NTCvalue/(ADC_ChannelAioVbat-NTCvalue);
	}

    #ifdef USING_PRINTF	
    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,ResvalueCount);
    #endif

	if(ResvalueCount>=ADC_CALIBRATION_VALUE)
		Resvalue=1000000;
	else
		Resvalue=(long long)ADC_CALIBRATION_VALUE*(long long)ResvalueCount/(ADC_CALIBRATION_VALUE-ResvalueCount);
	if(Resvalue>=200000&&Resvalue<1000000)
		ADC_InsideRES=Resvalue;
	return Resvalue;
}


/**
  \fn  INT32 AdcSendReq(UINT32 req,UINT32 * param ,UINT32 timeout)
  \param[in]  req : ADC_REQ_BITMAP_VBAT ADC_REQ_BITMAP_TEMP; timeout = 0 at irq ,otherwize equal to ADC_MSG_TIMEOUT
  \brief     return bat value ,trigger deinit
  \return    1 FAIL  , 0 OK
*/
INT32 AdcSendReq(UINT32 req,UINT32 * param , UINT8 len ,UINT32 timeout)
{
    INT32 ret;
    adcReqMsg ReqMsg;
	
    ReqMsg.request = req;
    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)
    {
        return ret;
    }
    else
    {
  	 ret = osEventFlagsWait(adcTrigerHandle, ADC_RECV_CONTROL_FLAG, osFlagsWaitAll, timeout);
	   //to do 	  
	  switch(req)
	  {
		case ADC_REQ_BITMAP_VBAT:
		param[0] = gNtcDev.NTCvalue[0];
		break;
	      case ADC_REQ_BITMAP_TEMP:
 		param[0] = gNtcDev.NTCvalue[1];
		break;
		case ADC_REQ_BITMAP_CH1:
		param[0] = AdcGetResFromInres(gNtcDev.NTCvalue[2+NTC_Channel1]);	
		break;
		case ADC_REQ_BITMAP_CH2:
		param[0] =AdcGetResFromInres(gNtcDev.NTCvalue[2+NTC_Channel2]);	
		break;
		case ADC_REQ_BITMAP_CH30:
		param[0] =AdcGetResFromInres(gNtcDev.NTCvalue[2+NTC_Channel30]);	
		break;
		case ADC_REQ_BITMAP_CH31:
		param[0] =AdcGetResFromInres(gNtcDev.NTCvalue[2+NTC_Channel31]);	
		break;
		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_Channel4_VbatCali]);	
		break;
		case ADC_REQ_BITMAP_INRES_CALI:
		param[0] = AdcInresCali(gNtcDev.NTCvalue[2+NTC_Channel4_InresCali]);	
		break;
	  }
	  osEventFlagsClear(adcTrigerHandle, ADC_RECV_CONTROL_FLAG);
        return ret;
    }
}
/**
  \fn   static void ADC_VbatChannelCallback(uint32_t result)
  \param[in]  
  \brief     return bat value ,trigger deinit
  \return      
*/
static void ADC_VbatChannelCallback(uint32_t result)
{
    vbatChannelResult = result;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_VBAT);
}
/**
  \fn   static void ADC_ThermalChannelCallback(uint32_t result)
  \param[in]  
  \brief     return thermal value ,trigger deinit
  \return      
*/
static void ADC_ThermalChannelCallback(uint32_t result)
{
    thermalChannelResult = result;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_TEMP);
}

static void ADC_NTC1ChannelCallback(uint32_t result)
{
    NTCChannelResult[NTC_Channel1] = result;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH1);
}
static void ADC_NTC2ChannelCallback(uint32_t result)
{
    NTCChannelResult[NTC_Channel2] = result;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH2);
}

static void ADC_NTC30ChannelCallback(uint32_t result)
{
    NTCChannelResult[NTC_Channel30] = result;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH30);
}

static void ADC_NTC31ChannelCallback(uint32_t result)
{
    NTCChannelResult[NTC_Channel31] = result;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH31);
}


static void ADC_NTC4ChannelCallback(uint32_t result)
{
	    NTCChannelResult[NTC_Channel4] = result;
	    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH4);
}
static void ADC_NTCVbatCaliChannelCallback(uint32_t result)
{
    NTCChannelResult[NTC_Channel4_VbatCali] = result;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_VBAT_CALI);
}

static void ADC_NTCInresCaliChannelCallback(uint32_t result)
{
    NTCChannelResult[NTC_Channel4_InresCali] = result;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_INRES_CALI);
}


/**
  \fn   void AdcProcess(void* arg)
  \param[in]  
  \brief       handle adc init ,deinit and convert process
  \return      
*/
static void AdcProcess(void* arg)
{
    adcReqMsg regMsg;
    INT32 ret;

    while(1)
    {
    	/*
		
	*/
	 osMessageQueueGet(adcMsgHandle, &regMsg, 0, osWaitForever);
	 /*
			handle event
	 */
	adc_config_t adcConfig;
	INT8 times=1;
	ADC_GetDefaultConfig(&adcConfig);

	osEventFlagsClear(adcEvtHandle, regMsg.request);
	retry:

	if(regMsg.request & ADC_REQ_BITMAP_VBAT)
	{
		adcConfig.channelConfig.vbatResDiv = ADC_VbatResDivRatio3Over16;
		ADC_ChannelInit(ADC_ChannelVbat, ADC_UserAPP, &adcConfig, ADC_VbatChannelCallback);
		//delay_us(1000*1000);
		ADC_StartConversion(ADC_ChannelVbat, ADC_UserAPP);
	}
	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);
	}

	else if(regMsg.request & ADC_REQ_BITMAP_CH1)
	{
		if(regMsg.param[NTC_Channel1]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel1]<=ADC_AioResDivRatio1Over16){
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
		    #endif
			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel1];
		}else{
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
		    #endif
			adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
		}
	  	ADC_ChannelInit(ADC_ChannelAio1, ADC_UserAPP, &adcConfig, ADC_NTC1ChannelCallback);
		//delay_us(1000*1000);
	  	ADC_StartConversion(ADC_ChannelAio1, ADC_UserAPP);
	}
	
	else if(regMsg.request & ADC_REQ_BITMAP_CH2)
	{
		if(regMsg.param[NTC_Channel2]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel2]<=ADC_AioResDivRatio1Over16){
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
		    #endif
			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel2];
		}else{
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
		    #endif
		}
		ADC_ChannelInit(ADC_ChannelAio2, ADC_UserAPP, &adcConfig, ADC_NTC2ChannelCallback);
		//delay_us(1000*1000);
		ADC_StartConversion(ADC_ChannelAio2, ADC_UserAPP);
	}
	
	else if(regMsg.request & ADC_REQ_BITMAP_CH30)
	{
		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_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_NTC30ChannelCallback);
              //osDelay(2000/portTICK_PERIOD_MS);
		ADC_StartConversion(ADC_ChannelAio3, ADC_UserAPP);
	}
	
	else if(regMsg.request & ADC_REQ_BITMAP_CH31)
	{
		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{
		    #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_NTC4ChannelCallback);
            osDelay(100/portTICK_PERIOD_MS);  //zhengchao 20210312
		ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
	}

	else if(regMsg.request & ADC_REQ_BITMAP_VBAT_CALI)
	{
		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);
	}

	else if(regMsg.request & ADC_REQ_BITMAP_INRES_CALI)
	{
		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_Channel4_InresCali];
		}else{
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
		    #endif
			adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
		}
		
		ADC_ChannelInit(ADC_ChannelAio4, ADC_UserAPP, &adcConfig, ADC_NTCInresCaliChannelCallback);
              //osDelay(2000/portTICK_PERIOD_MS);
		ADC_StartConversion(ADC_ChannelAio4, ADC_UserAPP);
	}
	

	
	ret = osEventFlagsWait(adcEvtHandle, regMsg.request, osFlagsWaitAll, ADC_GET_RESULT_TIMOUT);

	if(regMsg.request & ADC_REQ_BITMAP_VBAT)
	{
	    ADC_ChannelDeInit(ADC_ChannelVbat, ADC_UserAPP);
	   gNtcDev.NTCvalue[0] = HAL_ADC_CalibrateRawCode(vbatChannelResult) * 16 / 3;
	}

	else if(regMsg.request & ADC_REQ_BITMAP_TEMP)
	{
	    ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP);
	    gNtcDev.NTCvalue[1] = HAL_ADC_ConvertThermalRawCodeToTemperature(thermalChannelResult);
	}

	else if(regMsg.request & ADC_REQ_BITMAP_CH1)
	{
	 	ADC_ChannelDeInit(ADC_ChannelAio1, ADC_UserAPP);
		if(times==1){
			gNtcDev.NTCvalue[2+NTC_Channel1]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel1])*REV_AioResDivRatioDefault;
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel1]);
		    #endif
			if(gNtcDev.NTCvalue[2+NTC_Channel1]>(NTC_FullAioValue-10)){
				regMsg.param[NTC_Channel1]=ADC_AioResDivRatioExtra;
				times++;
				goto retry;
			}			
		}else{
			gNtcDev.NTCvalue[2+NTC_Channel1]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel1])*REV_AioResDivRatioExtra;
		}
			
	}
	else if(regMsg.request & ADC_REQ_BITMAP_CH2)
	{
		ADC_ChannelDeInit(ADC_ChannelAio2, ADC_UserAPP);
		if(times==1){
			gNtcDev.NTCvalue[2+NTC_Channel2]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel2])*REV_AioResDivRatioDefault;
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel2]);
		    #endif
			if(gNtcDev.NTCvalue[2+NTC_Channel2]>(NTC_FullAioValue-10)){
				regMsg.param[NTC_Channel2]=ADC_AioResDivRatioExtra;
				times++;
				goto retry;
			}			
		}else{
			gNtcDev.NTCvalue[2+NTC_Channel2]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel2])*REV_AioResDivRatioExtra;
		}	
	}
	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_Channel30]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel30])*REV_AioResDivRatioDefault;
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel30]);
		    #endif
			if(gNtcDev.NTCvalue[2+NTC_Channel30]>(NTC_FullAioValue-10)){
				regMsg.param[NTC_Channel30]=ADC_AioResDivRatioExtra;
				times++;
				goto retry;
			}			
		}else{
			gNtcDev.NTCvalue[2+NTC_Channel30]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel30])*REV_AioResDivRatioExtra;
		}
	}

	else if(regMsg.request & ADC_REQ_BITMAP_CH31)
	{
		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_Channel31]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel31])*REV_AioResDivRatioExtra;
		}
	}
	
	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_Channel4_VbatCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_VbatCali]);
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel4_VbatCali]);
		    #endif
			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_Channel4_VbatCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_VbatCali]);
		}
	}
	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_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_Channel4_InresCali]);
		    #endif
			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_Channel4_InresCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_InresCali])*REV_AioResDivRatioExtra;
		}
	}
	 osEventFlagsSet(adcTrigerHandle, ADC_RECV_CONTROL_FLAG);
	  	
    }
}

/**
  \fn    INT32 AdcTaskInit(void)
  \param[in]  
  \brief       create task for checking bat level
  \return      
*/
INT32 AdcTaskInit(void)
{
	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;
	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);
	
	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)
	{
		adcMsgHandle = osMessageQueueNew(ADC_MSG_MAX_NUM,sizeof(adcReqMsg), NULL);
		if(adcMsgHandle == NULL)
			return 1;
	}

	if(adcTrigerHandle == NULL)
	{
		adcTrigerHandle = osEventFlagsNew(NULL);
		if(adcTrigerHandle == NULL)
			return 1;
	}
	if(adcEvtHandle == NULL)
	{
		adcEvtHandle = osEventFlagsNew(NULL);
		if(adcEvtHandle == NULL)
			return 1;
	}

	if(adcTaskHandle == NULL)
	{
		osThreadAttr_t task_attr;
		memset(&task_attr , 0 , sizeof(task_attr));
		task_attr.name = "batAdc";
		task_attr.priority = osPriorityNormal;
		task_attr.cb_mem = &adcTask;
		task_attr.cb_size = sizeof(StaticTask_t);
		task_attr.stack_mem = adcTaskStack;
		task_attr.stack_size =ADC_TASK_STACK_SIZE;
		memset(& adcTaskStack, 0xa5, ADC_TASK_STACK_SIZE);
		adcTaskHandle = osThreadNew(AdcProcess , NULL,&task_attr);
		if(adcTaskHandle == NULL)
			return 1;
	}
	
	return 0;
}
/**
  \fn   void PowerPinConfig(IOType iotype)
  \param[in]  
  \brief    config PWR pin to gpiol
  \return      
*/
void PowerPinConfig(IOType iotype)
{
	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;

	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);
	
	
	
      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);
		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 1 << AON_GPS_POWER2);

		PAD_SetPinConfig(32, &padConfig);
		GPIO_PinConfig(1, AON_RELAY_DRV, &config);
		GPIO_PinWrite(1, 1 << AON_RELAY_DRV, 1 << AON_RELAY_DRV);

		PAD_SetPinConfig(35, &padConfig);
		GPIO_PinConfig(1, AON_WAKEUP, &config);
		GPIO_PinWrite(1, 1 << AON_WAKEUP, 1 << AON_WAKEUP);

		padConfig.mux = PAD_MuxAlt7;
		PAD_SetPinConfig(5, &padConfig);
	
		GPIO_PinConfig(1, FEM_GPS_RSTN, &config);
		GPIO_PinWrite(1, 1 << FEM_GPS_RSTN, 1 << FEM_GPS_RSTN);
#if 1		
		padConfig.mux = PAD_MuxAlt7;
		padConfig.pullSelect = PAD_PullInternal;
		padConfig.pullUpEnable = PAD_PullUpEnable;
		padConfig.pullDownEnable = PAD_PullDownDisable;
		PAD_SetPinConfig(8, &padConfig);
		
		config.pinDirection = GPIO_DirectionInput;
       	config.misc.initOutput = 0;
		GPIO_PinConfig(1, FEM_GPS_PPS, &config);
#else
		padConfig.mux = PAD_MuxAlt7;
		PAD_SetPinConfig(8, &padConfig);
		GPIO_PinWrite(1, 1 << FEM_GPS_PPS, 1 << FEM_GPS_PPS);
#endif
	
      	}
	else
	{
	      	/*Normal IO*/
#if 0			
		GPIO_PinConfig(0, GPIO_MOS_DRV1, &config);
		GPIO_PinWrite(0, 1 << GPIO_MOS_DRV1, 1 << GPIO_MOS_DRV1);
		
		GPIO_PinConfig(0, GPIO_MOS_DRV2, &config);
		GPIO_PinWrite(0, 1 << GPIO_MOS_DRV2, 1 << GPIO_MOS_DRV2);
#endif		
		padConfig.mux = PAD_MuxAlt0;
		PAD_SetPinConfig(28, &padConfig);
		GPIO_PinConfig(0, GPIO_POWER_LED, &config);
		GPIO_PinWrite(0, 1 << GPIO_POWER_LED, 1 << GPIO_POWER_LED);
      	}
}
/**
  \fn   void relayConfigInit(void)
  \param[in]  
  \brief    init the relay, while switch on default
  \return      
*/
void relayConfigInit()
{
	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;

	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

	PAD_SetPinConfig(32, &padConfig);
	GPIO_PinConfig(1, AON_RELAY_DRV, &config);
	GPIO_PinWrite(1, 1 << AON_RELAY_DRV, 0 << AON_RELAY_DRV);  //the relay default is off(disconnected)
	printf("switch off\n");
}

/**
  \fn   void relayControl(BOOL onOrOff)
  \param[in] onOrOff 
  \brief    switch the relay on or off
  \return      
*/

void relayControl(BOOL onOrOff)
{
	if(onOrOff == TRUE)
	{
		GPIO_PinWrite(1, 1 << AON_RELAY_DRV, 1 << AON_RELAY_DRV);  //switch on
		printf("switcht on\n");
	}
	else
	{
		GPIO_PinWrite(1, 1 << AON_RELAY_DRV, 0 << AON_RELAY_DRV); //switch off
		printf("switch off\n");
	}
}

/**
  \fn   void posGGAReset(void)
  \param[in]  
  \brief    reset gps
  \return      
*/
void posGGAReset(void)
{
	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;
	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

	padConfig.mux = PAD_MuxAlt7;
	PAD_SetPinConfig(5, &padConfig);
		
	GPIO_PinConfig(1, FEM_GPS_RSTN, &config);
	GPIO_PinWrite(1, 1 << FEM_GPS_RSTN, 0);
	
	osDelay(1000/portTICK_PERIOD_MS);
	
	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);
	
	
}
/**
  \fn   void GPSPowerCtr(bool )
  \param[in]  
  \brief    reset gps
  \return      
*/
void GPSPowerCtr(bool on)
{
	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;

	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);


	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(QueueHandle_t handle)
  \param[in]  
  \brief    powr on gps
  \return      
*/
INT32 posGGAServiceStart(QueueHandle_t handle)
{
	if(handle == NULL){
		return -1;
	}else{
		GPSPowerCtr(true);
		gpsHandle = handle;
		return 0;
	}
}
/**
  \fn   void posGGAServiceStop(void )
  \param[in]  
  \brief    stop gps
  \return      
*/
void posGGAServiceStop( void)
{	
	GPSPowerCtr(false);
	gpsHandle = NULL;
}