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_AioResDivRatio1)
#define REV_AioResDivRatioDefault								 1
#define ADC_ChannelAioVbat										(1800)
#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_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}};

#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(OPMODE_NORMAL !=(temp&0xE0))//?D??MCP2515��?��?��??-??��??y3��?�꨺?
	{
    		CAN_WriteReg(CANCTRL,param.mode|CLKOUT_ENABLED);//?����???MCP2515����???a?y3��?�꨺?,��?3??????�꨺?REQOP_NORMAL
	}
}

/*******************************************************************************
* 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-100))
		Resvalue=1000000;
	else{
		Resvalue=ADC_ChannelAioRes*NTCvalue/(ADC_ChannelAioVbat-NTCvalue);
	}
	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] =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] = AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel1]);	
		break;
		case ADC_REQ_BITMAP_CH2:
		param[0] =AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel2]);	
		break;
		case ADC_REQ_BITMAP_CH3:
		param[0] =AdcGetRes(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;
	  }
	  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);
    }
}

/**
  \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){
			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel1];
		}else{
			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){
			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel2];
		}else{
			adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
		}
		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){
			adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel3];
		}else{
			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);
			
			if(regMsg.param[NTC_Channel4]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel4]<=ADC_AioResDivRatio1Over16){
				adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel4];
			}else{
				adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
			}

			
		}else{
			GPIO_PinWrite(0, 1, 0);
			gNtcDev.flagC4 = 0;
			if(regMsg.param[NTC_Channel5]>=ADC_AioResDivRatio1 && regMsg.param[NTC_Channel5]<=ADC_AioResDivRatio1Over16){
				adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel5];
			}else{
				adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
			}

		}
		ADC_ChannelInit(ADC_ChannelAio4, ADC_UserAPP, &adcConfig, ADC_NTC4OR5ChannelCallback);
		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;
			if(gNtcDev.NTCvalue[2+NTC_Channel1]>(NTC_FullAioValue-100)){
				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;
			if(gNtcDev.NTCvalue[2+NTC_Channel2]>(NTC_FullAioValue-100)){
				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;
			if(gNtcDev.NTCvalue[2+NTC_Channel3]>(NTC_FullAioValue-100)){
				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_ChannelAio4, ADC_UserAPP);
		if(gNtcDev.flagC4){
			if(times==1){
				gNtcDev.NTCvalue[2+NTC_Channel4]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4])*REV_AioResDivRatioDefault;
				if(gNtcDev.NTCvalue[2+NTC_Channel4]>(NTC_FullAioValue-100)){
					regMsg.param[NTC_Channel4]=ADC_AioResDivRatioExtra;
					times++;
					goto retry;
				}			
			}else{
				gNtcDev.NTCvalue[2+NTC_Channel4]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4])*REV_AioResDivRatioExtra;
			}			
		}else{
			if(times==1){
				gNtcDev.NTCvalue[2+NTC_Channel5]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5])*REV_AioResDivRatioDefault;
				if(gNtcDev.NTCvalue[2+NTC_Channel5]>(NTC_FullAioValue-100)){
					regMsg.param[NTC_Channel5]=ADC_AioResDivRatioExtra;
					times++;
					goto retry;
				}			
			}else{
				gNtcDev.NTCvalue[2+NTC_Channel5]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5])*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_RELAY_DRV);

		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);
	
}
/**
  \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);
		GPSUsartHandler(9600);
		gGPSDataCBfunc = callBack;
		return 0;
	}
}
/**
  \fn   void posGGAServiceStop(void )
  \param[in]  
  \brief    stop gps
  \return      
*/
void posGGAServiceStop( void)
{	
	HAL_UART_DeInitHandler(PORT_USART_2);
	GPSPowerCtr(false);
	gGPSDataCBfunc = NULL;
}


/**
  \fn   void gpsProcess(void* arg)
  \param[in]  
  \brief       handle gps init ,deinit and convert process
  \return      
*/
static void GpsProcess(void* arg)
{
    gpsReqMsg msg;
    #ifdef USING_PRINTF	
    	printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
    #endif
    while(1)
    {
    	/*
		
	*/
	osMessageQueueGet(gpsMsgHandle, &msg, 0, osWaitForever);
	#ifdef USING_PRINTF	
	    printf("GpsProcess Gpstask [%d] %s\r\n",msg.len,msg.dataPtr);
	#endif 
	osMessageQueuePut(gpsMsgQueue, &msg, 0, 2000);
		 if(msg.dataPtr)
		 	free(msg.dataPtr);
	  	msg.dataPtr=NULL;
		if (Sleep_Flag)
		{
			osThreadExit();
			break;
		}
    }
}

/**
  \fn    INT32 GpsTaskInit(void)
  \param[in]  
  \brief       create task for checking gps data
  \return      
*/
INT32 GpsTaskInit(void)
{

	if(gpsMsgHandle == NULL)
	{
		gpsMsgHandle = osMessageQueueNew(1,sizeof(gpsReqMsg), NULL);
		if(gpsMsgHandle == NULL)
			return 1;
	}
	

	if(gpsTaskHandle == NULL)
	{
		osThreadAttr_t task_attr;
		memset(&task_attr , 0 , sizeof(task_attr));
		task_attr.name = "GPS";
		task_attr.priority = osPriorityNormal1;
		task_attr.cb_mem = &gpsTask;
		task_attr.cb_size = sizeof(StaticTask_t);
		task_attr.stack_mem = gpsTaskStack;
		task_attr.stack_size =GPS_TASK_STACK_SIZE;
		memset(& gpsTaskStack, 0xa5, GPS_TASK_STACK_SIZE);
		gpsTaskHandle = osThreadNew(GpsProcess , NULL,&task_attr);
		if(gpsTaskHandle == NULL)
			return 1;
	}
	
	return 0;
}