#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; iTransfer(&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;iTransfer(&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) 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(iInitialize(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<