|
@@ -1,1512 +0,0 @@
|
|
|
-#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
|
|
|
-*/
|
|
|
-#define GPS_DATA_RECV_BUFFER_SIZE (256)
|
|
|
-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
|
|
|
-*/
|
|
|
-#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_AioResDivRatio10Over16)
|
|
|
-#define REV_AioResDivRatioDefault 16/10
|
|
|
-#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];
|
|
|
-/*
|
|
|
- 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, ®, 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 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)
|
|
|
-{
|
|
|
- UINT8 GPS[256];
|
|
|
- slpManStartWaitATTimer();
|
|
|
- if((event == ARM_USART_EVENT_RX_TIMEOUT) || (event == ARM_USART_EVENT_RECEIVE_COMPLETE))
|
|
|
- {
|
|
|
- //parse data
|
|
|
- memcpy(GPS, dataPtr, dataLen);
|
|
|
- gGPSDataCBfunc(dataLen,GPS);
|
|
|
-#if 0
|
|
|
-#ifdef USING_PRINTF
|
|
|
- printf("GPS:len=%d,data=%s\r\n",datalen,GPS);
|
|
|
-#else
|
|
|
- ECOMM_STRING(UNILOG_PLA_STRING, GPS_RECV_DATA, P_INFO, "GPS:%s", GPS);
|
|
|
-#endif
|
|
|
-#endif
|
|
|
- }
|
|
|
-}
|
|
|
-/**
|
|
|
- \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);
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- \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_AioResDivRatio10Over16 ;
|
|
|
- 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] = gNtcDev.NTCvalue[2+NTC_Channel1];
|
|
|
- break;
|
|
|
- case ADC_REQ_BITMAP_CH2:
|
|
|
- param[0] = gNtcDev.NTCvalue[2+NTC_Channel2];
|
|
|
- break;
|
|
|
- case ADC_REQ_BITMAP_CH3:
|
|
|
- param[0] = gNtcDev.NTCvalue[2+NTC_Channel3];
|
|
|
- break;
|
|
|
- case ADC_REQ_BITMAP_CH4:
|
|
|
- param[0] = gNtcDev.NTCvalue[2+NTC_Channel4];
|
|
|
- break;
|
|
|
- case ADC_REQ_BITMAP_CH5:
|
|
|
- param[0] = 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, ®Msg, 0, osWaitForever);
|
|
|
- /*
|
|
|
- handle event
|
|
|
- */
|
|
|
- adc_config_t adcConfig;
|
|
|
-
|
|
|
- ADC_GetDefaultConfig(&adcConfig);
|
|
|
-
|
|
|
- osEventFlagsClear(adcEvtHandle, regMsg.request);
|
|
|
-
|
|
|
- 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);
|
|
|
- gNtcDev.NTCvalue[2+NTC_Channel1]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel1])*REV_AioResDivRatioDefault;
|
|
|
- }
|
|
|
- if(regMsg.request & ADC_REQ_BITMAP_CH2)
|
|
|
- {
|
|
|
- ADC_ChannelDeInit(ADC_ChannelAio2, ADC_UserAPP);
|
|
|
- gNtcDev.NTCvalue[2+NTC_Channel2]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel2])*REV_AioResDivRatioDefault;
|
|
|
- }
|
|
|
- if(regMsg.request & ADC_REQ_BITMAP_CH3)
|
|
|
- {
|
|
|
- ADC_ChannelDeInit(ADC_ChannelAio3, ADC_UserAPP);
|
|
|
- gNtcDev.NTCvalue[2+NTC_Channel3]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel3])*REV_AioResDivRatioDefault;
|
|
|
- }
|
|
|
- if(regMsg.request & ADC_REQ_BITMAP_CH4 ||regMsg.request & ADC_REQ_BITMAP_CH5)
|
|
|
- {
|
|
|
- ADC_ChannelDeInit(ADC_ChannelAio4, ADC_UserAPP);
|
|
|
- if(gNtcDev.flagC4){
|
|
|
- gNtcDev.NTCvalue[2+NTC_Channel4]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4])*REV_AioResDivRatioDefault;
|
|
|
- }else{
|
|
|
- gNtcDev.NTCvalue[2+NTC_Channel5]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5])*REV_AioResDivRatioDefault;
|
|
|
- }
|
|
|
- }
|
|
|
- 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, 0);
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|