NB_APP_Code/src/hal_module_adapter.c

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

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

/*
	power control
*/
// back power
#define AON_GPS_POWER1 (8)
//main power
#define AON_GPS_POWER2 (4)
#define AON_RELAY_DRV (5)
#define AON_WAKEUP (8)
#define GPIO_MOS_DRV1 (14)
#define GPIO_MOS_DRV2 (15)
#define GPIO_POWER_LED (9)
/*GPS*/
#define FEM_GPS_RSTN (6)
#define FEM_GPS_BLK (7)
#define FEM_GPS_PPS (9)

/*CAN*/
#define GPIO_CAN_POWER (9)

/*
	I2C
*/
#define I2C_RECV_CONTROL_FLAG (0x1)
static UINT32 g_halI2CInitFlag = 0;
static osEventFlagsId_t g_i2CRecvFlag;
static StaticQueue_t i2c_recv_queue_cb;
static StaticTask_t i2c_recv_task;
static UINT8 i2c_recv_task_stack[I2C_RECV_TASK_STACK_SIZE];
static UINT8 i2c_recv_queue_buf[I2C_RECV_QUEUE_BUF_SIZE * sizeof(i2c_recv_msgqueue_obj_t)];
// message queue id
static osMessageQueueId_t i2c_recv_msgqueue;

/*
	adc
*/
#define GPIO_AIO3_SEL (19)
#define GPIO_AIO4_SEL (18)

#define ADC_TASK_STACK_SIZE (512)
#define ADC_MSG_MAX_NUM (7)
#define ADC_AioResDivRatioDefault (ADC_AioResDivRatio14Over16)
#define REV_AioResDivRatioDefault 16 / 14
//#define ADC_ChannelAioVbat										(1200)
static UINT32 ADC_ChannelAioVbat = 1200;
#define ADC_ChannelAioRes (15000)
#define NTC_FullAioValue (1200)
#define ADC_AioResDivRatioExtra (ADC_AioResDivRatio8Over16)
#define REV_AioResDivRatioExtra 16 / 8
#define NTC_REQ_UPDATE_DATA (0x01)
#define ADC_MSG_TIMEOUT (1000)
#define ADC_CALIBRATION_VALUE (50900)

static UINT32 ADC_InsideRES = 500000;

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

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

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

QueueHandle_t uartDataHandle = NULL;
/*
	gps
*/
static QueueHandle_t gpsHandle = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void UTCToBeijing(UTC8TimeType *UTC8Time, 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;
			}
		}
	}

	UTC8Time->year = year;
	UTC8Time->month = month;
	UTC8Time->day = day;
	UTC8Time->hour = hour;
	UTC8Time->minute = UTCminute;
	UTC8Time->second = UTCsecond;
}
#ifdef DEBUGLOG
static osMutexId_t DebugFileMux;
static void Debug_Write_Logfile(UINT8 *buf)
{
	UINT32 Count;
	OSAFILE file;
	osMutexAcquire(DebugFileMux, osWaitForever);
	file = OsaFopen("DebugFile", "wb");
	if (file != NULL)
	{
		if (OsaFseek(file, 0, SEEK_END) == 0)
		{
			Count = OsaFwrite(buf, 1, strlen(buf), file);
		}
		OsaFclose(file);
	}
	osMutexRelease(DebugFileMux);
	return;
}
void Debug_printf(const UINT8 *format, ...)
{
	UINT8 buf[128 + 1];
	va_list args;
	OsaUtcTimeTValue timeUtc;
	UINT16 year;
	UINT8 month, day, hour, minute, sec;
	appGetSystemTimeUtcSync(&timeUtc);
	year = (timeUtc.UTCtimer1 & 0xffff0000) >> 16;
	month = (timeUtc.UTCtimer1 & 0xff00) >> 8;
	day = timeUtc.UTCtimer1 & 0xff;
	hour = (timeUtc.UTCtimer2 & 0xff000000) >> 24;
	minute = (timeUtc.UTCtimer2 & 0xff0000) >> 16;
	sec = (timeUtc.UTCtimer2 & 0xff00) >> 8;
	memset(buf, 0, 128 + 1);
	UTC8TimeType UTC8TimeStruct;
	UTCToBeijing((UTC8TimeType *)&UTC8TimeStruct, year, month, day, hour, minute, sec);
	sprintf((char *)buf, "%02d:%02d:%02d-", UTC8TimeStruct.hour, UTC8TimeStruct.minute, UTC8TimeStruct.second);
	va_start(args, format);
	vsnprintf(buf + strlen(buf), 128 - strlen(buf), format, args);
	va_end(args);
	Debug_Write_Logfile(buf);
}
UINT16 Debug_GetSize()
{
	UINT16 FileSize;
	OSAFILE file;
	osMutexAcquire(DebugFileMux, osWaitForever);
	file = OsaFopen("DebugFile", "rb");
	FileSize = OsaFsize(file);
	OsaFclose(file);
	osMutexRelease(DebugFileMux);
	return FileSize;
}
void Debug_Read_Logfile(UINT8 *rbuf, UINT16 FileSize)
{
	UINT32 Count;
	OSAFILE file;
	printf("%s start\r\n", __FUNCTION__);
	osMutexAcquire(DebugFileMux, osWaitForever);
	file = OsaFopen("DebugFile", "rb");
	if (file != NULL)
	{
		if (OsaFseek(file, 0, SEEK_SET) == 0)
		{
			memset(rbuf, 0, FileSize);
			Count = OsaFread(rbuf, 1, FileSize, file);
			printf("%s", rbuf);
		}
		OsaFclose(file);
	}
	printf("%s end! \r\n", __FUNCTION__);
	osMutexRelease(DebugFileMux);
	return;
}
void Debug_Del_Logfile(void)
{
	osMutexAcquire(DebugFileMux, osWaitForever);
	OsaFremove("DebugFile");
	osMutexRelease(DebugFileMux);
}
#endif
#ifdef BL_FILE_LOG
static UINT8 blLogFileNux = 0;
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);
	UTC8TimeType UTC8TimeStruct;
	UTCToBeijing(UTC8TimeStruct, year, month, day, hour, minite, sec);
	sprintf((char *)buf, "%04d-%02d-%02d %02d:%02d:%02d ", UTC8TimeStruct.year, UTC8TimeStruct.month, UTC8TimeStruct.day, UTC8TimeStruct.hour, UTC8TimeStruct.minute, UTC8TimeStruct.second);
	va_start(args, format);
	vsnprintf(buf + strlen(buf), 128 - strlen(buf), format, args);
	va_end(args);
	//printf("%s", buf);
	bluejoy_write_logfile(buf);
}
#endif

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

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

	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

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

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

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

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

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

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

#ifdef SPI_ANALOG
/**
* @brief      
* @param
* @return   
*/
UINT8 SPI_Read_Byte(void)
{
	UINT8 i = 0;
	UINT8 rByte = 0;
	SPI_Clk_Low();

	for (i = 0; i < 8; i++)
	{
		SPI_Clk_High();
		rByte <<= 1;
		rByte |= SPI_MISO_Read();
		SPI_Clk_Low();
	}

	return rByte;
}
#endif
/**
  \fn          INT32 CAN_ReadReg(UINT8 addr)
  \param[in]   addr    CAN register addr
  \brief       write can register
  \return     
*/
INT32 CAN_WriteReg(UINT8 addr, UINT8 value)
{
	SPI_CS_Low();
	SPI_Write_Byte(CAN_WRITE);
	SPI_Write_Byte(addr);
	SPI_Write_Byte(value);
	SPI_CS_High();
	return 0;
}
/**
  \fn    INT32 CAN_ReadReg(UINT8 reg, UINT8 len, UINT8 *buf)
  \param[in]   reg:  can register addr 
  \brief       read can register
  \return     
*/
INT32 CAN_ReadReg(UINT8 reg, UINT8 len, UINT8 *buf)
{
	UINT8 i = 0;
	UINT8 data = 0;
	INT32 res;
	if (buf == NULL)
		return -1;

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

/*******************************************************************************
* o����y??  : MCP2515_Init
* ?����?    : MCP25153?��??��????
* ��?��?    : ?T
* ��?3?    : ?T
* ����???��  : ?T
* ?��?��    : 3?��??���㨹������o����?t?��???��1�����2����??������???�������?��??��1?????�̨�?��
*******************************************************************************/
void HAL_Can_Init(Can_InitType param)
{
	UINT8 temp = 0, temp1 = 0;
	INT32 res = -1;

	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;
	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

	//POWER
	padConfig.mux = PAD_MuxAlt0;
	PAD_SetPinConfig(28, &padConfig);
	GPIO_PinWrite(0, 1 << GPIO_CAN_POWER, 1 << GPIO_CAN_POWER);

	HAL_Can_Reset(); //¡¤¡é?¨ª?¡ä????¨¢?¨¨¨ª?t?¡ä??MCP2515
	osDelay(100 / portTICK_PERIOD_MS);
	CAN_WriteReg(CANCTRL, OPMODE_CONFIG | CLKOUT_ENABLED);
	//  CAN_ReadReg(CANCTRL,1,&temp);//?¨¢¨¨?CAN¡Á¡ä¨¬???¡ä??¡Â¦Ì??¦Ì
#ifdef USING_PRINTF
	//printf("[%d] CANCTRL = %#x \r\n",__LINE__,temp);
#endif

	CAN_WriteReg(CNF1, param.baudrate);
	CAN_WriteReg(CNF2, BTLMODE_CNF3 | PHSEG1_3TQ | PRSEG_1TQ);
	CAN_WriteReg(CNF3, PHSEG2_3TQ);

	if (param.packType == STD_PACK)
	{
		/*?����???2��??��??��*/
		CAN_WriteReg(TXB0SIDH, 0xFF & (param.TxStdIDH)); //����?��?o3??��0������?������?��?????
		CAN_WriteReg(TXB0SIDL, 0xE0 & (param.TxStdIDL)); //����?��?o3??��0������?������?��?�̨�??

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

		/*?����???2��??��??��*/
		CAN_WriteReg(RXF0SIDH, 0xFF & (param.RxStdIDH[0]));
		CAN_WriteReg(RXF0SIDL, 0xE0 & (param.RxStdIDL[0]));

		CAN_WriteReg(RXF1SIDH, 0xFF & (param.RxStdIDH[1]));
		CAN_WriteReg(RXF1SIDL, 0xE0 & (param.RxStdIDL[1]));
#if 0
	CAN_WriteReg(RXF2SIDH,0x00);
	CAN_WriteReg(RXF2SIDL,0xa0);
	CAN_WriteReg(RXF3SIDH,0x00);
	CAN_WriteReg(RXF3SIDL,0x40);
	CAN_WriteReg(RXF4SIDH,0x00);
	CAN_WriteReg(RXF4SIDL,0x60);
	CAN_WriteReg(RXF5SIDH,0x00);
	CAN_WriteReg(RXF5SIDL,0x80);
#else
		CAN_WriteReg(RXF2SIDH, 0xFF & (param.RxStdIDH[2]));
		CAN_WriteReg(RXF2SIDL, 0xE0 & (param.RxStdIDL[2]));
		CAN_WriteReg(RXF3SIDH, 0xFF & (param.RxStdIDH[3]));
		CAN_WriteReg(RXF3SIDL, 0xE0 & (param.RxStdIDL[3]));
		CAN_WriteReg(RXF4SIDH, 0xFF & (param.RxStdIDH[4]));
		CAN_WriteReg(RXF4SIDL, 0xE0 & (param.RxStdIDL[4]));
		CAN_WriteReg(RXF5SIDH, 0xFF & (param.RxStdIDH[5]));
		CAN_WriteReg(RXF5SIDL, 0xE0 & (param.RxStdIDL[5]));
#endif

		CAN_WriteReg(RXB0CTRL, RXM_RCV_ALL | BUKT_ROLLOVER);
		CAN_WriteReg(RXB0DLC, DLC_8);

		CAN_WriteReg(RXB1CTRL, RXM_RCV_ALL);
		CAN_WriteReg(RXB1DLC, DLC_8);
	}
	else if (param.packType == EXT_PACK)
	{
		/*TXB0*/
		CAN_WriteReg(TXB0SIDH, 0xFF & (param.TxStdIDH));
		CAN_WriteReg(TXB0SIDL, (0xEB & (param.TxStdIDL)) | 0x08);
		CAN_WriteReg(TXB0EID8, 0xFF & (param.TxExtIDH));
		CAN_WriteReg(TXB0EID0, 0xFF & (param.TxExtIDL));

		/*?����???2��??��??��*/
		CAN_WriteReg(RXM0SIDH, 0x00); //FF->00 zhengchao
		CAN_WriteReg(RXM0SIDL, 0x00); //E3->00 zhengchao
		CAN_WriteReg(RXM0EID8, 0x00); //FF->00 zhengchao
		CAN_WriteReg(RXM0EID0, 0x00); //FF->00 zhengchao

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

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

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

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

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

		CAN_WriteReg(RXF5SIDH, 0xFF & (param.RxStdIDH[5]));
		CAN_WriteReg(RXF5SIDL, (0xEB & (param.RxStdIDL[5])) | 0x08);
		CAN_WriteReg(RXF5EID8, 0xFF & (param.RxExtIDH[5]));
		CAN_WriteReg(RXF5EID8, 0xFF & (param.RxExtIDL[5]));

		CAN_WriteReg(RXB0CTRL, RXM_VALID_EXT | BUKT_ROLLOVER);
		CAN_WriteReg(RXB0DLC, DLC_8);

		CAN_WriteReg(RXB1CTRL, RXM_VALID_EXT | FILHIT1_FLTR_2);
		CAN_WriteReg(RXB1DLC, DLC_8);
	}

	CAN_WriteReg(BFPCTRL, 0x3F);		  //zhengchao20210304  add
	CAN_WriteReg(CANINTE, RX0IF | RX1IF); //zhengchao20210304  0x43 -> 0x03
	CAN_WriteReg(CANINTF, 0x00);

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

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

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

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

	if ((TXB0CTRLvalue & TXREQ) == 0)
		TXBufferCase = 0;
	else if ((TXB1CTRLvalue & TXREQ) == 0)
		TXBufferCase = 1;
	else if ((TXB2CTRLvalue & TXREQ) == 0)
		TXBufferCase = 2;
	else
	{
		CAN_WriteReg(TXB0CTRL, TXB0CTRLvalue & (~TXREQ));
		TXBufferCase = 0;
	}

	switch (TXBufferCase)
	{

	case 0:
	{
		//tryTim=0;
		//CAN_RseadReg(TXB0CTRL,1,&value);

		//while((value&0x08) && (tryTim<50))//?��?��?��?3D?���䨬???��?,�̨���yTXREQ����????��?
		//{
		//	CAN_ReadReg(TXB0CTRL,1,&value);
		//	osDelay(1/portTICK_PERIOD_MS);
		//	tryTim++;
		//}

		/*TXB0*/
		CAN_WriteReg(TXB0SIDH, 0xFF & ((Can_TxMsg.Id) >> 3)); //����?��?o3??��0������?������?��?????
		CAN_WriteReg(TXB0SIDL, 0xE0 & ((Can_TxMsg.Id) << 5)); //����?��?o3??��0������?������?��?�̨�??
		for (i = 0; i < Can_TxMsg.DLC; i++)
		{
			CAN_WriteReg(TXB0D0 + i, Can_TxMsg.Data[i]); //??��y����?����?��y?YD�䨨?����?��?o3???��??��
		}
		CAN_WriteReg(TXB0DLC, Can_TxMsg.DLC); //??��???��y����?����?��y?Y3��?��D�䨨?����?��?o3??��0��?����?��3��?��??��??��
		SPI_CS_Low();
		CAN_WriteReg(TXB0CTRL, TXREQ); //???������?������??
		//SPI_CS_High();

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

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

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

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

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

	return ret;
}

/*******************************************************************************
* o����y??  :  HAL_Can_Receive(UINT8 *CAN_RX_Buf)
* ?����?    : CAN?����?��???��y?Y
* ��?��?    : *CAN_TX_Buf(��y?����?��y?Y?o3???????)
* ��?3?    : ?T
* ����???��  : len(?����?��?��y?Y��?3��?��,0~8��??��)
* ?��?��    : ?T
*******************************************************************************/
UINT8 HAL_Can_Receive(CAN_Msg_Type *CanRxMsgBuffer)
{

	UINT8 j = 0, len = 0, temp = 0;
	UINT8 SIdH, SIdL, EId8, EId0;
	//static UINT16 counterBuff0,counterBuff1 = 0;
	UINT8 ret = 0;

	CAN_ReadReg(CANINTF, 1, &temp);

	ret = temp & 0x03;

	switch (ret)
	{
	case 0x00:
		return ret;
		break;
	case 0x01:
		/*get the id information*/
		CAN_ReadReg(RXB0SIDH, 1, &SIdH);
		CAN_ReadReg(RXB0SIDL, 1, &SIdL);
		CAN_ReadReg(RXB0EID8, 1, &EId8);
		CAN_ReadReg(RXB0EID0, 1, &EId0);

		CAN_ReadReg(RXB0DLC, 1, &len);
		len = len & 0x0F;
		CanRxMsgBuffer[0].DLC = len;

		if (SIdL & 0x8) // if SIdL.3 = 1, the id belongs to ExtID
		{
			(CanRxMsgBuffer[0]).Id = ((SIdH << 5 | (SIdL >> 5) << 2 | SIdL & 0x3) << 16 | (EId8 << 8) | EId0);
		}
		else
		{
			(CanRxMsgBuffer[0]).Id = SIdH << 3 | SIdL >> 5;
		}

		j = 0;
		while (j < len)
		{
			CAN_ReadReg(RXB0D0 + j, 1, &((CanRxMsgBuffer[0]).Data[j]));
			j++;
		}
#ifdef USING_PRINTF1
		printf("buffer0 ID = %x\n", CanRxMsgBuffer[0].Id);
		for (j = 0; j < 8; j++)
		{
			printf("%x ", CanRxMsgBuffer[0].Data[j]);
		}
		printf("\n");
#endif
		CAN_WriteReg(CANINTF, temp & 0xFE);
		return ret;
		break;

	case 0x02:
		/*get the id information*/
		CAN_ReadReg(RXB1SIDH, 1, &SIdH);
		CAN_ReadReg(RXB1SIDL, 1, &SIdL);
		CAN_ReadReg(RXB1EID8, 1, &EId8);
		CAN_ReadReg(RXB1EID0, 1, &EId0);

		CAN_ReadReg(RXB1DLC, 1, &len);
		len = len & 0x0F;
		CanRxMsgBuffer[1].DLC = len;

		if (SIdL & 0x8) // SIdL.3 = 1, ExtID
		{
			(CanRxMsgBuffer[1]).Id = ((SIdH << 5 | (SIdL >> 5) << 2 | SIdL & 0x3) << 16 | (EId8 << 8) | EId0);
		}
		else
		{
			(CanRxMsgBuffer[1]).Id = SIdH << 3 | SIdL >> 5;
		}

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

#ifdef USING_PRINTF1
		printf("buffer1 ID = %x\n", CanRxMsgBuffer[1].Id);
		for (j = 0; j < 8; j++)
		{
			printf("%x ", CanRxMsgBuffer[1].Data[j]);
		}
		printf("\n");
#endif
		CAN_WriteReg(CANINTF, temp & 0xFD);
		return ret;
		break;
	case 0x03:
		/*get the id information*/
		CAN_ReadReg(RXB0SIDH, 1, &SIdH);
		CAN_ReadReg(RXB0SIDL, 1, &SIdL);
		CAN_ReadReg(RXB0EID8, 1, &EId8);
		CAN_ReadReg(RXB0EID0, 1, &EId0);

		CAN_ReadReg(RXB0DLC, 1, &len);
		len = len & 0x0F;
		CanRxMsgBuffer[0].DLC = len;

		if (SIdL & 0x8) // if SIdL.3 = 1, the id belongs to ExtID
		{
			(CanRxMsgBuffer[0]).Id = ((SIdH << 5 | (SIdL >> 5) << 2 | SIdL & 0x3) << 16 | (EId8 << 8) | EId0);
		}
		else
		{
			(CanRxMsgBuffer[0]).Id = SIdH << 3 | SIdL >> 5;
		}

		j = 0;
		while (j < len)
		{
			CAN_ReadReg(RXB0D0 + j, 1, &((CanRxMsgBuffer[0]).Data[j]));
			j++;
		}
#ifdef USING_PRINTF1
		printf("buffer0 ID = %x\n", CanRxMsgBuffer[0].Id);
		for (j = 0; j < 8; j++)
		{
			printf("%x ", CanRxMsgBuffer[0].Data[j]);
		}
		printf("\n");
#endif

		/*get the id information*/
		CAN_ReadReg(RXB1SIDH, 1, &SIdH);
		CAN_ReadReg(RXB1SIDL, 1, &SIdL);
		CAN_ReadReg(RXB1EID8, 1, &EId8);
		CAN_ReadReg(RXB1EID0, 1, &EId0);

		CAN_ReadReg(RXB1DLC, 1, &len);
		len = len & 0x0F;
		CanRxMsgBuffer[1].DLC = len;

		if (SIdL & 0x8) // SIdL.3 = 1, ExtID
		{
			(CanRxMsgBuffer[1]).Id = ((SIdH << 5 | (SIdL >> 5) << 2 | SIdL & 0x3) << 16 | (EId8 << 8) | EId0);
		}
		else
		{
			(CanRxMsgBuffer[1]).Id = SIdH << 3 | SIdL >> 5;
		}

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

#ifdef USING_PRINTF1
		printf("buffer1 ID = %x\n", CanRxMsgBuffer[1].Id);
		for (j = 0; j < 8; j++)
		{
			printf("%x ", CanRxMsgBuffer[1].Data[j]);
		}
		printf("\n");
#endif
		CAN_WriteReg(CANINTF, temp & 0xFC);
		return ret;
		break;

	default:
		break;
	}
	/*
		CAN_ReadReg(CANINTF,1, &temp1);
		if((temp1&0x03) == (temp&0x03))
		{
			CAN_WriteReg(CANINTF,temp&0xFC);
			break;
		}
*/
	return ret;
	//	CAN_ReadReg(CANINTF,1,&temp);
	//	printf("CANINTF_1 = 0x%x\n",temp);
}

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

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

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

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

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

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

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

	GPIO_PinConfig(SPI_MISO_GPIO_INSTANCE, SPI_MISO_GPIO_INDEX, &nGpioCfg);

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

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

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

	res = i2cDrvInstance->MasterTransmit(GSENSOR_DEVICE_ADDR, &reg, 1, true);

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

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

		break;
	case ARM_I2C_EVENT_TRANSFER_INCOMPLETE:

		break;
	case ARM_I2C_EVENT_ADDRESS_NACK:

		break;
	case ARM_I2C_EVENT_BUS_ERROR:

		break;
	case ARM_I2C_EVENT_BUS_CLEAR:

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

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

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

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

	if (evt & I2C_INT1_REQ_BITMAP)
	{
	}

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

	return 0;
}

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

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

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

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

			mask = SaveAndSetIRQMask();
			//handle data
			//I2CEvtProcess(msg.event);
#ifdef USING_PRINTF
			//printf("[%d]i2c recv event\r\n",__LINE__);
#else
			ECOMM_TRACE(UNILOG_PLA_DRIVER, I2C_GSENSOR_D, P_INFO, 0, "i2c recv event");
#endif
			RestoreIRQMask(mask);
		}
	}
}
static void HAL_I2C_CreateRecvTaskAndQueue(void)
{
	if (g_halI2CInitFlag & HAL_I2C_RECV_TASK_QUEUE_CREATED)
	{
		return;
	}
	/*
	    for task create
	*/
	osThreadId_t threadId;

	osThreadAttr_t task_attr;
	/*for msg queue create*/
	osMessageQueueAttr_t queue_attr;

	g_i2CRecvFlag = osEventFlagsNew(NULL);

	EC_ASSERT(g_i2CRecvFlag, g_i2CRecvFlag, 0, 0);

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

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

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

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

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

	EC_ASSERT(threadId, threadId, 0, 0);

	g_halI2CInitFlag |= HAL_I2C_RECV_TASK_QUEUE_CREATED;
}

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

#define PRINTF_DATA_RECV_BUFFER_SIZE (200)
uint8_t printf_uart_recv_buf[PRINTF_DATA_RECV_BUFFER_SIZE];
/**
  \fn    void PrintfDataRecvCallback(uint32_t event, void* dataPtr, uint32_t dataLen)
  \param[in]  event   :Data receiving timeout processing and data receiving completion processing;
  \		    dataPtr : Point to receive data buff
  \		    dataLen : Received data length	
  \brief        i2c irq event ,callback function
  \return      
*/
void UartDataRecvCallback(UINT32 event, void *dataPtr, UINT32 dataLen)
{
	if ((event == ARM_USART_EVENT_RX_TIMEOUT) || (event == ARM_USART_EVENT_RECEIVE_COMPLETE))
	{
		if (uartDataHandle != NULL && dataLen > 0)
		{
			UartBuffer UartDataBuffer = {0};
			memcpy((UINT8 *)&UartDataBuffer, dataPtr, dataLen);
			UartDataBuffer.len = dataLen;
			osMessageQueuePut(uartDataHandle, &UartDataBuffer, 0, 10);
		}
	}
	slpManStartWaitATTimer();
}

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

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

	hal_uart_hardware_config_t hwConfig = {
		ARM_POWER_FULL,
		ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_8 |
			ARM_USART_PARITY_NONE | ARM_USART_STOP_BITS_1 |
			ARM_USART_FLOW_CONTROL_NONE,
		baudRate};
	halUartConfig.uartDriverHandler = printfHandle;
	halUartConfig.recv_cb = UartDataRecvCallback;
	halUartConfig.recvBuffPtr = printf_uart_recv_buf;
	halUartConfig.recvBuffSize = PRINTF_DATA_RECV_BUFFER_SIZE;
	halUartConfig.post_send_cb = printfPostSendCallback;
	HAL_UART_InitHandler(PORT_USART_1, &halUartConfig, &hwConfig, HAL_UART_TASK_CREATE_FLAG_SEND_RECV);
	HAL_UART_RecvFlowControl(false);
}
/**
  \fn         void GsensorI2CCallback(uint32_t event)
  \param[in]  event   : i2c irq event
  \brief        i2c irq event ,callback function
  \return      
*/
void GsensorI2CHandler(ARM_I2C_SignalEvent_t cb_event)
{
	// Initialize with callback
	i2cDrvInstance->Initialize(cb_event);
	// Power on
	i2cDrvInstance->PowerControl(ARM_POWER_FULL);
	// Configure I2C bus
	i2cDrvInstance->Control(ARM_I2C_BUS_SPEED, ARM_I2C_BUS_SPEED_STANDARD);
	i2cDrvInstance->Control(ARM_I2C_BUS_CLEAR, 0);
	HAL_I2C_CreateRecvTaskAndQueue();
#ifdef USING_PRINTF
	//printf("[%d] i2c config ok\r\n",__LINE__);
#else
	ECOMM_TRACE(UNILOG_PLA_DRIVER, I2C_GSENSOR_I, P_INFO, 0, "i2c config ok");
#endif
}

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

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

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

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

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

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

	if (ResvalueCount >= ADC_InsideRES)
		Resvalue = 1000000;
	else
		Resvalue = (long long)ADC_InsideRES * (long long)ResvalueCount / (ADC_InsideRES - ResvalueCount);

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

	return Resvalue;
}

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

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

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

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

/**
  \fn  INT32 AdcSendReq(UINT32 req,UINT32 * param ,UINT32 timeout)
  \param[in]  req : ADC_REQ_BITMAP_VBAT ADC_REQ_BITMAP_TEMP; timeout = 0 at irq ,otherwize equal to ADC_MSG_TIMEOUT
  \brief     return bat value ,trigger deinit
  \return    1 FAIL  , 0 OK
*/
INT32 AdcSendReq(UINT32 req, UINT32 *param, UINT8 len, UINT32 timeout)
{
	INT32 ret;
	adcReqMsg ReqMsg;

	ReqMsg.request = req;
	ReqMsg.param[NTC_Channel1] = ReqMsg.param[NTC_Channel2] = ReqMsg.param[NTC_Channel30] = ReqMsg.param[NTC_Channel31] = ReqMsg.param[NTC_Channel4] = ReqMsg.param[NTC_Channel4_InresCali] = ADC_AioResDivRatioDefault;
	ret = osMessageQueuePut(adcMsgHandle, &ReqMsg, 0, timeout);

	if (ret != osOK)
	{
		return ret;
	}
	else
	{
		ret = osEventFlagsWait(adcTrigerHandle, ADC_RECV_CONTROL_FLAG, osFlagsWaitAll, timeout);
		//to do
		switch (req)
		{
		case ADC_REQ_BITMAP_VBAT:
			param[0] = gNtcDev.NTCvalue[0];
			break;
		case ADC_REQ_BITMAP_TEMP:
			param[0] = gNtcDev.NTCvalue[1];
			break;
		case ADC_REQ_BITMAP_CH1:
			param[0] = AdcGetResFromInres(gNtcDev.NTCvalue[2 + NTC_Channel1]);
			break;
		case ADC_REQ_BITMAP_CH2:
			param[0] = AdcGetResFromInres(gNtcDev.NTCvalue[2 + NTC_Channel2]);
			break;
		case ADC_REQ_BITMAP_CH30:
			param[0] = AdcGetResFromInres(gNtcDev.NTCvalue[2 + NTC_Channel30]);
			break;
		case ADC_REQ_BITMAP_CH31:
			param[0] = AdcGetResFromInres(gNtcDev.NTCvalue[2 + NTC_Channel31]);
			break;
		case ADC_REQ_BITMAP_CH4:
			param[0] = gNtcDev.NTCvalue[2 + NTC_Channel4] * 101 + 600;
			break;
		case ADC_REQ_BITMAP_VBAT_CALI:
			param[0] = AdcVbatCali(gNtcDev.NTCvalue[2 + NTC_Channel4_VbatCali]);
			break;
		case ADC_REQ_BITMAP_INRES_CALI:
			param[0] = AdcInresCali(gNtcDev.NTCvalue[2 + NTC_Channel4_InresCali]);
			break;
		}
		osEventFlagsClear(adcTrigerHandle, ADC_RECV_CONTROL_FLAG);
		return ret;
	}
}
/**
  \fn   static void ADC_VbatChannelCallback(uint32_t result)
  \param[in]  
  \brief     return bat value ,trigger deinit
  \return      
*/
static void ADC_VbatChannelCallback(uint32_t result)
{
	vbatChannelResult = result;
	osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_VBAT);
}
/**
  \fn   static void ADC_ThermalChannelCallback(uint32_t result)
  \param[in]  
  \brief     return thermal value ,trigger deinit
  \return      
*/
static void ADC_ThermalChannelCallback(uint32_t result)
{
	thermalChannelResult = result;
	osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_TEMP);
}

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

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

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

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

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

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

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

		osEventFlagsClear(adcEvtHandle, regMsg.request);
	retry:

		if (regMsg.request & ADC_REQ_BITMAP_VBAT)
		{
			adcConfig.channelConfig.vbatResDiv = ADC_VbatResDivRatio3Over16;
			ADC_ChannelInit(ADC_ChannelVbat, ADC_UserAPP, &adcConfig, ADC_VbatChannelCallback);
			//delay_us(1000*1000);
			ADC_StartConversion(ADC_ChannelVbat, ADC_UserAPP);
		}
		else if (regMsg.request & ADC_REQ_BITMAP_TEMP)
		{
			adcConfig.channelConfig.thermalInput = ADC_ThermalInputVbat;
			ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_ThermalChannelCallback);
			//delay_us(1000*1000);
			ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
		}

		else if (regMsg.request & ADC_REQ_BITMAP_CH1)
		{
			if (regMsg.param[NTC_Channel1] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel1] <= ADC_AioResDivRatio1Over16)
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
				adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel1];
			}
			else
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
				adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
			}
			ADC_ChannelInit(ADC_ChannelAio1, ADC_UserAPP, &adcConfig, ADC_NTC1ChannelCallback);
			//delay_us(1000*1000);
			ADC_StartConversion(ADC_ChannelAio1, ADC_UserAPP);
		}

		else if (regMsg.request & ADC_REQ_BITMAP_CH2)
		{
			if (regMsg.param[NTC_Channel2] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel2] <= ADC_AioResDivRatio1Over16)
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
				adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel2];
			}
			else
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
			}
			ADC_ChannelInit(ADC_ChannelAio2, ADC_UserAPP, &adcConfig, ADC_NTC2ChannelCallback);
			//delay_us(1000*1000);
			ADC_StartConversion(ADC_ChannelAio2, ADC_UserAPP);
		}

		else if (regMsg.request & ADC_REQ_BITMAP_CH30)
		{
			GPIO_PinWrite(GPIO_AIO3_SEL / 16, 1 << (GPIO_AIO3_SEL % 16), 0);
			if (regMsg.param[NTC_Channel30] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel30] <= ADC_AioResDivRatio1Over16)
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
				adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel30];
			}
			else
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
				adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
			}
			ADC_ChannelInit(ADC_ChannelAio3, ADC_UserAPP, &adcConfig, ADC_NTC30ChannelCallback);
			//osDelay(2000/portTICK_PERIOD_MS);
			ADC_StartConversion(ADC_ChannelAio3, ADC_UserAPP);
		}

		else if (regMsg.request & ADC_REQ_BITMAP_CH31)
		{
			GPIO_PinWrite(GPIO_AIO3_SEL / 16, 1 << (GPIO_AIO3_SEL % 16), 1 << (GPIO_AIO3_SEL % 16));
			if (regMsg.param[NTC_Channel31] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel31] <= ADC_AioResDivRatio1Over16)
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
				adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel31];
			}
			else
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
				adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
			}
			ADC_ChannelInit(ADC_ChannelAio3, ADC_UserAPP, &adcConfig, ADC_NTC31ChannelCallback);
			//osDelay(2000/portTICK_PERIOD_MS);
			ADC_StartConversion(ADC_ChannelAio3, ADC_UserAPP);
		}

		else if (regMsg.request & ADC_REQ_BITMAP_CH4)
		{
			GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 0);
			ADC_GetDefaultConfig(&adcConfig);
			adcConfig.channelConfig.thermalInput = ADC_ThermalInputAio4;
			ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_NTC4ChannelCallback);
			osDelay(100 / portTICK_PERIOD_MS); //zhengchao 20210312
			ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
		}

		else if (regMsg.request & ADC_REQ_BITMAP_VBAT_CALI)
		{
			GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 1 << (GPIO_AIO4_SEL % 16));
			ADC_GetDefaultConfig(&adcConfig);
			adcConfig.channelConfig.thermalInput = ADC_ThermalInputAio4;
			ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_NTCVbatCaliChannelCallback);
			//osDelay(2000/portTICK_PERIOD_MS);
			ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP);
		}

		else if (regMsg.request & ADC_REQ_BITMAP_INRES_CALI)
		{
			GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 1 << (GPIO_AIO4_SEL % 16));
			if (regMsg.param[NTC_Channel4_InresCali] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel4_InresCali] <= ADC_AioResDivRatio1Over16)
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
				adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel4_InresCali];
			}
			else
			{
#ifdef USING_PRINTF
				//printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
#endif
				adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault;
			}

			ADC_ChannelInit(ADC_ChannelAio4, ADC_UserAPP, &adcConfig, ADC_NTCInresCaliChannelCallback);
			//osDelay(2000/portTICK_PERIOD_MS);
			ADC_StartConversion(ADC_ChannelAio4, ADC_UserAPP);
		}

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

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

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

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

		else if (regMsg.request & ADC_REQ_BITMAP_CH31)
		{
			GPIO_PinWrite(GPIO_AIO3_SEL / 16, 1 << (GPIO_AIO3_SEL % 16), 0);
			ADC_ChannelDeInit(ADC_ChannelAio3, ADC_UserAPP);
			if (times == 1)
			{
				gNtcDev.NTCvalue[2 + NTC_Channel31] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel31]) * REV_AioResDivRatioDefault;
#ifdef USING_PRINTF
				//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel31]);
#endif
				if (gNtcDev.NTCvalue[2 + NTC_Channel31] > (NTC_FullAioValue - 10))
				{
					regMsg.param[NTC_Channel31] = ADC_AioResDivRatioExtra;
					times++;
					goto retry;
				}
			}
			else
			{
				gNtcDev.NTCvalue[2 + NTC_Channel31] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel31]) * REV_AioResDivRatioExtra;
			}
		}

		else if (regMsg.request & ADC_REQ_BITMAP_CH4)
		{
			GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 1 << (GPIO_AIO4_SEL % 16));
			ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP);
			gNtcDev.NTCvalue[2 + NTC_Channel4] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4]);
		}
		else if (regMsg.request & ADC_REQ_BITMAP_VBAT_CALI)
		{
			GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 0);
			ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP);
			if (times == 1)
			{
				gNtcDev.NTCvalue[2 + NTC_Channel4_VbatCali] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_VbatCali]);
#ifdef USING_PRINTF
				//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel4_VbatCali]);
#endif
				if (gNtcDev.NTCvalue[2 + NTC_Channel4_VbatCali] > (NTC_FullAioValue - 10))
				{
					regMsg.param[NTC_Channel4_VbatCali] = ADC_AioResDivRatioExtra;
					times++;
					goto retry;
				}
			}
			else
			{
				gNtcDev.NTCvalue[2 + NTC_Channel4_VbatCali] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_VbatCali]);
			}
		}
		else if (regMsg.request & ADC_REQ_BITMAP_INRES_CALI)
		{
			GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 0);
			ADC_ChannelDeInit(ADC_ChannelAio4, ADC_UserAPP);
			if (times == 1)
			{
				gNtcDev.NTCvalue[2 + NTC_Channel4_InresCali] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_InresCali]) * REV_AioResDivRatioDefault;
#ifdef USING_PRINTF
				//printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel4_InresCali]);
#endif
				if (gNtcDev.NTCvalue[2 + NTC_Channel4_InresCali] > (NTC_FullAioValue - 10))
				{
					regMsg.param[NTC_Channel4_InresCali] = ADC_AioResDivRatioExtra;
					times++;
					goto retry;
				}
			}
			else
			{
				gNtcDev.NTCvalue[2 + NTC_Channel4_InresCali] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_InresCali]) * REV_AioResDivRatioExtra;
			}
		}
		osEventFlagsSet(adcTrigerHandle, ADC_RECV_CONTROL_FLAG);
	}
}

/**
  \fn    INT32 AdcTaskInit(void)
  \param[in]  
  \brief       create task for checking bat level
  \return      
*/
INT32 AdcTaskInit(void)
{
	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;
	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

	//power
	padConfig.mux = PAD_MuxAlt0;
	PAD_SetPinConfig(11, &padConfig);
	GPIO_PinConfig(0, 0, &config);
	GPIO_PinWrite(0, 1, 1);

	padConfig.mux = PAD_MuxAlt7;
	PAD_SetPinConfig(9, &padConfig);
	PAD_SetPinConfig(10, &padConfig);

	GPIO_PinConfig(GPIO_AIO3_SEL / 16, GPIO_AIO3_SEL % 16, &config);
	GPIO_PinConfig(GPIO_AIO4_SEL / 16, GPIO_AIO4_SEL % 16, &config);
	GPIO_PinWrite(GPIO_AIO3_SEL / 16, 1 << (GPIO_AIO3_SEL % 16), 0);
	GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 0);

	memset(&gNtcDev, 0, sizeof(NtcResult_t));

	if (adcMsgHandle == NULL)
	{
		adcMsgHandle = osMessageQueueNew(ADC_MSG_MAX_NUM, sizeof(adcReqMsg), NULL);
		if (adcMsgHandle == NULL)
			return 1;
	}

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

	if (adcTaskHandle == NULL)
	{
		osThreadAttr_t task_attr;
		memset(&task_attr, 0, sizeof(task_attr));
		task_attr.name = "batAdc";
		task_attr.priority = osPriorityNormal;
		task_attr.cb_mem = &adcTask;
		task_attr.cb_size = sizeof(StaticTask_t);
		task_attr.stack_mem = adcTaskStack;
		task_attr.stack_size = ADC_TASK_STACK_SIZE;
		memset(&adcTaskStack, 0xa5, ADC_TASK_STACK_SIZE);
		adcTaskHandle = osThreadNew(AdcProcess, NULL, &task_attr);
		if (adcTaskHandle == NULL)
			return 1;
	}

	return 0;
}
/**
  \fn   void PowerPinConfig(IOType iotype)
  \param[in]  
  \brief    config PWR pin to gpiol
  \return      
*/
void PowerPinConfig(IOType iotype)
{
	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;

	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

	if (iotype == AON_IO)
	{
		slpManAONIOVoltSet(IOVOLT_3_30V); //zhengchao 20200412 add

		padConfig.mux = PAD_MuxAlt0;

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

		PAD_SetPinConfig(31, &padConfig);
		GPIO_PinConfig(1, AON_GPS_POWER2, &config);
		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 1 << AON_GPS_POWER2);

		PAD_SetPinConfig(32, &padConfig);
		GPIO_PinConfig(1, AON_RELAY_DRV, &config);
		GPIO_PinWrite(1, 1 << AON_RELAY_DRV, 0 << AON_RELAY_DRV); //zhengchao 20200412 modify 1-->0

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

		padConfig.mux = PAD_MuxAlt7;
		PAD_SetPinConfig(5, &padConfig);

		GPIO_PinConfig(1, FEM_GPS_RSTN, &config);
		GPIO_PinWrite(1, 1 << FEM_GPS_RSTN, 1 << FEM_GPS_RSTN);
#if 1
		padConfig.mux = PAD_MuxAlt7;
		padConfig.pullSelect = PAD_PullInternal;
		padConfig.pullUpEnable = PAD_PullUpEnable;
		padConfig.pullDownEnable = PAD_PullDownDisable;
		PAD_SetPinConfig(8, &padConfig);

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

	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

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

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

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

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

	padConfig.mux = PAD_MuxAlt7;
	PAD_SetPinConfig(5, &padConfig);

	GPIO_PinConfig(1, FEM_GPS_RSTN, &config);
	GPIO_PinWrite(1, 1 << FEM_GPS_RSTN, 0);

	osDelay(1000 / portTICK_PERIOD_MS);

	GPIO_PinConfig(1, FEM_GPS_RSTN, &config);
	GPIO_PinWrite(1, 1 << FEM_GPS_RSTN, 1 << FEM_GPS_RSTN);

	config.pinDirection = GPIO_DirectionInput;
	config.misc.initOutput = 0;
	GPIO_PinConfig(1, FEM_GPS_RSTN, &config);
}
/**
  \fn   void GPSPowerCtr(bool )
  \param[in]  
  \brief    reset gps
  \return      
*/
void GPSPowerCtr(bool on)
{
	gpio_pin_config_t config;
	config.pinDirection = GPIO_DirectionOutput;
	config.misc.initOutput = 1;

	pad_config_t padConfig;
	PAD_GetDefaultConfig(&padConfig);

	padConfig.mux = PAD_MuxAlt0;

	PAD_SetPinConfig(35, &padConfig);
	GPIO_PinConfig(1, AON_GPS_POWER1, &config);

	PAD_SetPinConfig(31, &padConfig);
	GPIO_PinConfig(1, AON_GPS_POWER2, &config);

	if (on)
	{
		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 0);
		GPIO_PinWrite(1, 1 << AON_GPS_POWER1, 1 << AON_GPS_POWER1);
	}
	else
	{
		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 1 << AON_GPS_POWER2);
		GPIO_PinWrite(1, 1 << AON_GPS_POWER1, 0);
	}
}
/**
  \fn   void posGGAServiceStart(QueueHandle_t handle)
  \param[in]  
  \brief    powr on gps
  \return      
*/
INT32 posGGAServiceStart(QueueHandle_t handle)
{
	if (handle == NULL)
	{
		return -1;
	}
	else
	{
		GPSPowerCtr(true);
		gpsHandle = handle;
		return 0;
	}
}
/**
  \fn   void posGGAServiceStop(void )
  \param[in]  
  \brief    stop gps
  \return      
*/
void posGGAServiceStop(void)
{
	GPSPowerCtr(false);
	gpsHandle = NULL;
}
BOOL NB_ADC_Get(UINT32 *adcValue, ADC_CHANNEL_TYPE adcChannel)
{
	//UINT32 NTCR2,NTCR3,NTCR4,NTCR5,Vbat = 0;
	//*adcValue = 0xFFFFFFFF;
	INT32 ret = 1;
	switch (adcChannel)
	{
	case FAST_CHARGE_TEMP: //P2-7
		ret = AdcSendReq(ADC_REQ_BITMAP_CH1, adcValue, 01, ADC_GET_RESULT_TIMOUT);
		break;
	case NORMAL_CHARGE_TEMP: //P2-9
		ret = AdcSendReq(ADC_REQ_BITMAP_CH2, adcValue, 01, ADC_GET_RESULT_TIMOUT);
		break;
	case OTHER_TEMP_1: //P2-11
		ret = AdcSendReq(ADC_REQ_BITMAP_CH31, adcValue, 01, ADC_GET_RESULT_TIMOUT);
		break;
	case OTHER_TEMP_2: //P2-13
		ret = AdcSendReq(ADC_REQ_BITMAP_CH30, adcValue, 01, ADC_GET_RESULT_TIMOUT);
		break;
	case VBAT: //Vbat
		ret = AdcSendReq(ADC_REQ_BITMAP_CH4, adcValue, 01, ADC_GET_RESULT_TIMOUT);
		break;
	default:
		break;
	}
	if (ret == 0)
		return TRUE;
	else
		return FALSE;
}