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"
/*
	gps
*/
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
*/
#define HAL_I2C_RECV_TASK_QUEUE_CREATED          			 (0x1)
#define I2C_RECV_QUEUE_BUF_SIZE                        			 (0x10)
#define I2C_RECV_TASK_STACK_SIZE             					 (1536)

/*
	power control
*/
#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)
/*
	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 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
{
    UINT8 flagC4;
    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
*/
#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];

/*
	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;
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);
//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 begin! \r\n",__FUNCTION__);
	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;

	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,0xFF);
		CAN_WriteReg(RXM0SIDL,0xE0);
		CAN_WriteReg(RXM1SIDH,0xFF);
		CAN_WriteReg(RXM1SIDL,0xE0);

		/*?����???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_VALID_STD);
		CAN_WriteReg(RXB0DLC,DLC_8);
		
		CAN_WriteReg(RXB1CTRL,RXM_VALID_STD|FILHIT1_FLTR_2);
		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,0xFF);
		CAN_WriteReg(RXM0SIDL,0xE3);
		CAN_WriteReg(RXM0EID8,0xFF);
		CAN_WriteReg(RXM0EID0,0xFF);

		/*?����???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);
		CAN_WriteReg(RXB0DLC,DLC_8);
		
		CAN_WriteReg(RXB1CTRL,RXM_VALID_EXT|FILHIT1_FLTR_2);
		CAN_WriteReg(RXB1DLC,DLC_8);
	
	}

	CAN_WriteReg(CANINTE,0x43);
	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,t=0;
	do{
		CAN_WriteReg(CANCTRL,OPMODE_SLEEP |CLKOUT_DISABLED);
		CAN_ReadReg(CANSTAT,1,&temp);
		#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);
}


/*******************************************************************************
* o¡¥¨ºy??  : HAL_Can_Transmit
* ?¨¨¨º?    : CAN¡¤¡é?¨ª???¡§3¡è?¨¨¦Ì?¨ºy?Y
* ¨º?¨¨?    : *CAN_TX_Buf(¡äy¡¤¡é?¨ª¨ºy?Y?o3???????),len(¡äy¡¤¡é?¨ª¨ºy?Y3¡è?¨¨)
* ¨º?3?    : ?T
* ¡¤¦Ì???¦Ì  : ?T
* ?¦Ì?¡Â    : ?T
*******************************************************************************/
INT32  HAL_Can_Transmit(Can_TxMsgType Can_TxMsg)
{
	UINT8 tryTim,count,value,i;

	count=0;	
	while(count<Can_TxMsg.DLC)
	{
		tryTim=0;
		CAN_ReadReg(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.stdIDH));//����?��?o3??��0������?������?��?????
		CAN_WriteReg(TXB0SIDL,0xE0&(Can_TxMsg.stdIDL));//����?��?o3??��0������?������?��?�̨�??	
		for(i=0;i<8;)
		{
			CAN_WriteReg(TXB0D0+i,Can_TxMsg.Data[count++]);//??��y����?����?��y?YD�䨨?����?��?o3???��??��
			i++;
			if(count>=Can_TxMsg.DLC) break;
		}
		CAN_WriteReg(TXB0DLC,i);//??��???��y����?����?��y?Y3��?��D�䨨?����?��?o3??��0��?����?��3��?��??��??��
		SPI_CS_Low();
		CAN_WriteReg(TXB0CTRL,0x08);//???������?������??
		SPI_CS_High();
	}
}

/*******************************************************************************
* 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
*******************************************************************************/
UINT8  HAL_Can_Receive(UINT8 *CAN_RX_Buf)
{
	UINT8 i=0,len=0,temp=0;
 
	CAN_ReadReg(CANINTF,1,&temp);
	if(temp & 0x01)
	{
		CAN_ReadReg(RXB0DLC,1,&len);
		while(i<len)
		{	
			CAN_ReadReg(RXB0D0+i,1,&CAN_RX_Buf[i]);
			i++;
		}
		
	}else if(temp & 0x02){
		CAN_ReadReg(RXB1DLC,1,&len);
		while(i<len)
		{	
			CAN_ReadReg(RXB1D0+i,1,&CAN_RX_Buf[i]);
			i++;
		}
	}
	
	CAN_WriteReg(CANINTF,0);
	return len;
}

/**
  \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 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(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);
			}
		}
   }
    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_Channel3] =  ReqMsg.param[NTC_Channel4] =  ReqMsg.param[NTC_Channel5] = ReqMsg.param[NTC_Channel5_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_CH3:
		param[0] =AdcGetResFromInres(gNtcDev.NTCvalue[2+NTC_Channel3]);	
		break;
		case ADC_REQ_BITMAP_CH4:
		param[0] = AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel4]);	
		break;
		case ADC_REQ_BITMAP_CH5:
		param[0] = AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel5]);	
		break;
		case ADC_REQ_BITMAP_VBAT_CALI:
		param[0] = AdcVbatCali(gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]);	
		break;
		case ADC_REQ_BITMAP_INRES_CALI:
		param[0] = AdcInresCali(gNtcDev.NTCvalue[2+NTC_Channel5_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_NTC3ChannelCallback(uint32_t result)
{
    NTCChannelResult[NTC_Channel3] = result;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH3);
}
static void ADC_NTC4OR5ChannelCallback(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;
    osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_VBAT_CALI);
}

static void ADC_NTCInresCaliChannelCallback(uint32_t result)
{
    NTCChannelResult[NTC_Channel5_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);
		ADC_StartConversion(ADC_ChannelVbat, ADC_UserAPP);
	}

	if(regMsg.request & ADC_REQ_BITMAP_TEMP)
	{
		adcConfig.channelConfig.thermalInput = ADC_ThermalInputVbat;
		ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_ThermalChannelCallback);
		ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
	}

	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);
	  	ADC_StartConversion(ADC_ChannelAio1, ADC_UserAPP);
	}
	
	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);
		ADC_StartConversion(ADC_ChannelAio2, ADC_UserAPP);
	}
	
	if(regMsg.request & ADC_REQ_BITMAP_CH3)
	{
		if(regMsg.param[NTC_Channel3]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel3]<=ADC_AioResDivRatio1Over16){
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
		    #endif
			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel3];
		}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_StartConversion(ADC_ChannelAio3, ADC_UserAPP);
	}
	if(regMsg.request & ADC_REQ_BITMAP_CH4 ||regMsg.request & ADC_REQ_BITMAP_CH5)
	{
		if(regMsg.request & ADC_REQ_BITMAP_CH4){
			gNtcDev.flagC4 = 1;
			GPIO_PinWrite(0, 1, 1);
		}else{
			GPIO_PinWrite(0, 1, 0);
			gNtcDev.flagC4 = 0;
		}
	        ADC_GetDefaultConfig(&adcConfig);
	        adcConfig.channelConfig.thermalInput = ADC_ThermalInputAio4;
	        ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_NTC4OR5ChannelCallback);
		ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
	}

	if(regMsg.request & ADC_REQ_BITMAP_VBAT_CALI)
	{
		GPIO_PinWrite(0, 1, 0);
		gNtcDev.flagC4 = 0;
	        ADC_GetDefaultConfig(&adcConfig);
	        adcConfig.channelConfig.thermalInput = ADC_ThermalInputAio4;
	        ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_NTCVbatCaliChannelCallback);
		ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
	}

	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){
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
		    #endif
			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel5_InresCali];
		}else{
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
		    #endif
			adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
		}
		
		gNtcDev.flagC4 = 0;
		ADC_ChannelInit(ADC_ChannelAio4, ADC_UserAPP, &adcConfig, ADC_NTCInresCaliChannelCallback);
		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;
	}

	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)
	{
	 	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;
		}
			
	}
	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;
		}	
	}
	if(regMsg.request & ADC_REQ_BITMAP_CH3)
	{
		ADC_ChannelDeInit(ADC_ChannelAio3, ADC_UserAPP);
		if(times==1){
			gNtcDev.NTCvalue[2+NTC_Channel3]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel3])*REV_AioResDivRatioDefault;
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel3]);
		    #endif
			if(gNtcDev.NTCvalue[2+NTC_Channel3]>(NTC_FullAioValue-10)){
				regMsg.param[NTC_Channel3]=ADC_AioResDivRatioExtra;
				times++;
				goto retry;
			}			
		}else{
			gNtcDev.NTCvalue[2+NTC_Channel3]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel3])*REV_AioResDivRatioExtra;
		}
	}
	if(regMsg.request & ADC_REQ_BITMAP_CH4 ||regMsg.request & ADC_REQ_BITMAP_CH5)
	{
		ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP);
		if(gNtcDev.flagC4){
			gNtcDev.NTCvalue[2+NTC_Channel4]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4]);
		}else{
			gNtcDev.NTCvalue[2+NTC_Channel5]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5]);
		}
	}
	if(regMsg.request & ADC_REQ_BITMAP_VBAT_CALI)
	{
		ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP);
		if(times==1){
			gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5_VbatCali]);
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]);
		    #endif
			if(gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]>(NTC_FullAioValue-10)){
				regMsg.param[NTC_Channel5_VbatCali]=ADC_AioResDivRatioExtra;
				times++;
				goto retry;
			}			
		}else{
			gNtcDev.NTCvalue[2+NTC_Channel5_VbatCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5_VbatCali]);
		}
	}
	if(regMsg.request & ADC_REQ_BITMAP_INRES_CALI)
	{
		ADC_ChannelDeInit(ADC_ChannelAio4, ADC_UserAPP);
		if(times==1){
			gNtcDev.NTCvalue[2+NTC_Channel5_InresCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5_InresCali])*REV_AioResDivRatioDefault;
		    #ifdef USING_PRINTF	
		    	//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel5_InresCali]);
		    #endif
			if(gNtcDev.NTCvalue[2+NTC_Channel5_InresCali]>(NTC_FullAioValue-10)){
				regMsg.param[NTC_Channel5_InresCali]=ADC_AioResDivRatioExtra;
				times++;
				goto retry;
			}			
		}else{
			gNtcDev.NTCvalue[2+NTC_Channel5_InresCali]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5_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);

	padConfig.mux = PAD_MuxAlt0;
	PAD_SetPinConfig(11, &padConfig);
		
	GPIO_PinConfig(0, 0, &config);
	GPIO_PinWrite(0, 1, 1);
	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 = osPriorityNormal1;
		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(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 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(31, &padConfig);
	GPIO_PinConfig(1, AON_GPS_POWER2, &config);
	if(on){
		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 0);
	}else{
		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 1<<AON_GPS_POWER2);
	}
}
/**
  \fn   void posGGAServiceStart(posGGACallBack )
  \param[in]  
  \brief    powr on gps
  \return      
*/
INT32 posGGAServiceStart( posGGACallBack callBack)
{
	if(callBack == NULL){
		return -1;
	}else{
		GPSPowerCtr(true);
		gGPSDataCBfunc = callBack;
		return 0;
	}
}
/**
  \fn   void posGGAServiceStop(void )
  \param[in]  
  \brief    stop gps
  \return      
*/
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, 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();
			while (true)
			{
				osDelay(10000);
			}
			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 = osPriorityBelowNormal7;
		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;
}