|
|
@@ -0,0 +1,1512 @@
|
|
|
+#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;
|
|
|
+}
|
Rivendeller