#include "bsp.h" #include "osasys.h" #include "ostask.h" #include "queue.h" #include "debug_log.h" #include "slpman_ec616.h" #include "plat_config.h" #include "hal_uart.h" #include "hal_adc.h" #include "adc_ec616.h" #include "gpio_ec616.h" #include "hal_module_adapter.h" #include /* gps */ static posGGACallBack gGPSDataCBfunc = NULL; // GSENSOR device addr #define GSENSOR_DEVICE_ADDR (SC7A20_IIC_ADDRESS) #define ZM01_DEVICE_ADDR (0x2a) /* i2c */ #define HAL_I2C_RECV_TASK_QUEUE_CREATED (0x1) #define I2C_RECV_QUEUE_BUF_SIZE (0x10) #define I2C_RECV_TASK_STACK_SIZE (1536) /* power control */ // back power #define AON_GPS_POWER1 (8) //main power #define AON_GPS_POWER2 (4) #define AON_RELAY_DRV (5) #define AON_WAKEUP (8) #define GPIO_MOS_DRV1 (14) #define GPIO_MOS_DRV2 (15) #define GPIO_POWER_LED (9) /*GPS*/ #define FEM_GPS_RSTN (6) #define FEM_GPS_BLK (7) #define FEM_GPS_PPS (9) /*CAN*/ #define GPIO_CAN_POWER (9) /* I2C */ #define I2C_RECV_CONTROL_FLAG (0x1) static UINT32 g_halI2CInitFlag = 0; static osEventFlagsId_t g_i2CRecvFlag; static StaticQueue_t i2c_recv_queue_cb; static StaticTask_t i2c_recv_task; static UINT8 i2c_recv_task_stack[I2C_RECV_TASK_STACK_SIZE]; static UINT8 i2c_recv_queue_buf[I2C_RECV_QUEUE_BUF_SIZE * sizeof(i2c_recv_msgqueue_obj_t)]; // message queue id static osMessageQueueId_t i2c_recv_msgqueue; /* adc */ #define GPIO_AIO3_SEL (19) #define GPIO_AIO4_SEL (18) #define ADC_TASK_STACK_SIZE (512) #define ADC_MSG_MAX_NUM (7) #define ADC_AioResDivRatioDefault (ADC_AioResDivRatio14Over16) #define REV_AioResDivRatioDefault 16 / 14 //#define ADC_ChannelAioVbat (1200) static UINT32 ADC_ChannelAioVbat = 1200; #define ADC_ChannelAioRes (15000) #define NTC_FullAioValue (1200) #define ADC_AioResDivRatioExtra (ADC_AioResDivRatio8Over16) #define REV_AioResDivRatioExtra 16 / 8 #define NTC_REQ_UPDATE_DATA (0x01) #define ADC_MSG_TIMEOUT (1000) #define ADC_CALIBRATION_VALUE (50900) static UINT32 ADC_InsideRES = 500000; #define ADC_RECV_CONTROL_FLAG (0x1) typedef struct { UINT32 request; UINT32 NTCvalue[7]; } NtcResult_t; NtcResult_t gNtcDev; volatile static UINT32 vbatChannelResult = 0; volatile static UINT32 thermalChannelResult = 0; volatile static UINT32 NTCChannelResult[NTC_ChannelMax]; QueueHandle_t adcMsgHandle = NULL; static osEventFlagsId_t adcEvtHandle = NULL; static osEventFlagsId_t adcTrigerHandle = NULL; static osThreadId_t adcTaskHandle = NULL; static StaticTask_t adcTask = NULL; static UINT8 adcTaskStack[ADC_TASK_STACK_SIZE]; QueueHandle_t uartDataHandle = NULL; /* gps */ static QueueHandle_t gpsHandle = NULL; /* can */ static osMessageQueueId_t can_recv_msgqueue; static StaticQueue_t can_recv_queue_cb; #define CAN_RECV_QUEUE_BUF_SIZE (0x10) static UINT8 can_recv_queue_buf[CAN_RECV_QUEUE_BUF_SIZE]; #define CAN_RECV_CONTROL_FLAG (0x1) //#define SPI_ANALOG #ifdef SPI_ANALOG #define USING_SPI0 0 #endif /*spi0*/ #ifdef SPI_ANALOG #if USING_SPI0 #define SPI_SSN_GPIO_INSTANCE RTE_SPI0_SSN_GPIO_INSTANCE #define SPI_SSN_GPIO_INDEX RTE_SPI0_SSN_GPIO_INDEX #define SPI_SSN_GPIO_PAD_ADDR 21 #define SPI_CLK_GPIO_INSTANCE 0 #define SPI_CLK_GPIO_INDEX 15 #define SPI_CLK_GPIO_PAD_ADDR 24 #define SPI_MOSI_GPIO_INSTANCE 0 #define SPI_MOSI_GPIO_INDEX 11 #define SPI_MOSI_GPIO_PAD_ADDR 22 #define SPI_MISO_GPIO_INSTANCE 0 #define SPI_MISO_GPIO_INDEX 14 #define SPI_MISO_GPIO_PAD_ADDR 23 #else //SPI1 #define SPI_SSN_GPIO_INSTANCE RTE_SPI1_SSN_GPIO_INSTANCE #define SPI_SSN_GPIO_INDEX RTE_SPI1_SSN_GPIO_INDEX #define SPI_SSN_GPIO_PAD_ADDR 13 #define SPI_CLK_GPIO_INSTANCE 0 #define SPI_CLK_GPIO_INDEX 5 #define SPI_CLK_GPIO_PAD_ADDR 16 #define SPI_MOSI_GPIO_INSTANCE 0 #define SPI_MOSI_GPIO_INDEX 3 #define SPI_MOSI_GPIO_PAD_ADDR 14 #define SPI_MISO_GPIO_INSTANCE 0 #define SPI_MISO_GPIO_INDEX 4 #define SPI_MISO_GPIO_PAD_ADDR 15 #endif #else #define SPI_SSN_GPIO_INSTANCE RTE_SPI1_SSN_GPIO_INSTANCE #define SPI_SSN_GPIO_INDEX RTE_SPI1_SSN_GPIO_INDEX #endif extern ARM_DRIVER_I2C Driver_I2C0; extern ARM_DRIVER_SPI Driver_SPI0; extern ARM_DRIVER_SPI Driver_SPI1; extern ARM_DRIVER_USART Driver_USART2; extern ARM_DRIVER_USART Driver_USART1; uint8_t gps_uart_recv_buf[GPS_DATA_RECV_BUFFER_SIZE]; static ARM_DRIVER_SPI *spiMasterDrv = &CREATE_SYMBOL(Driver_SPI, 1); static ARM_DRIVER_I2C *i2cDrvInstance = &CREATE_SYMBOL(Driver_I2C, 0); static ARM_DRIVER_USART *usartHandle = &CREATE_SYMBOL(Driver_USART, 2); static ARM_DRIVER_USART *printfHandle = &CREATE_SYMBOL(Driver_USART, 1); //LED define pin index #define LED_INX_MAX (5) #define LED_PORT_0 (0) #define LED_PORT_1 (1) /* pin1~pin4 for soc display pin5 for fault display */ #define LED_GPIO_PIN_1 (6) #define LED_PAD_INDEX1 (17) #define LED_GPIO_PIN_2 (7) #define LED_PAD_INDEX2 (18) #define LED_GPIO_PIN_3 (0) #define LED_PAD_INDEX3 (21) #define LED_GPIO_PIN_4 (11) #define LED_PAD_INDEX4 (22) #define LED_GPIO_PIN_5 (1) #define LED_PAD_INDEX5 (27) led_pin_config_t gLedCfg[LED_INX_MAX] = {{LED_PORT_0, LED_GPIO_PIN_1, LED_PAD_INDEX1, PAD_MuxAlt0}, {LED_PORT_0, LED_GPIO_PIN_2, LED_PAD_INDEX2, PAD_MuxAlt0}, {LED_PORT_1, LED_GPIO_PIN_3, LED_PAD_INDEX3, PAD_MuxAlt0}, {LED_PORT_0, LED_GPIO_PIN_4, LED_PAD_INDEX4, PAD_MuxAlt0}, {LED_PORT_1, LED_GPIO_PIN_5, LED_PAD_INDEX5, PAD_MuxAlt0}}; void UTCToBeijing(UTC8TimeType *UTC8Time, unsigned int UTCyear, unsigned char UTCmonth, unsigned char UTCday, unsigned int UTChour, unsigned char UTCminute, unsigned char UTCsecond) { int year = 0, month = 0, day = 0, hour = 0; int lastday = 0; // ÔµÄ×îºóÒ»ÌìÈÕÆÚ int lastlastday = 0; //ÉÏÔµÄ×îºóÒ»ÌìÈÕÆÚ year = UTCyear; month = UTCmonth; day = UTCday; hour = UTChour + 8; //UTC+8ת»»Îª±±¾©Ê±¼ä if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) { lastday = 31; if (month == 3) { if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) //ÅжÏÊÇ·ñΪÈòÄê lastlastday = 29; //ÈòÄêµÄ2ÔÂΪ29Ì죬ƽÄêΪ28Ìì else lastlastday = 28; } if (month == 8) lastlastday = 31; } else if (month == 4 || month == 6 || month == 9 || month == 11) { lastday = 30; lastlastday = 31; } else { lastlastday = 31; if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) //ÈòÄêµÄ2ÔÂΪ29Ì죬ƽÄêΪ28Ìì lastday = 29; else lastday = 28; } if (hour >= 24) //µ±Ëã³öµÄʱ´óÓÚ»òµÈÓÚ24£º00ʱ£¬Ó¦¼õÈ¥24£º00£¬ÈÕÆÚ¼ÓÒ»Ìì { hour -= 24; day += 1; if (day > lastday) //µ±Ëã³öµÄÈÕÆÚ´óÓÚ¸ÃÔÂ×îºóÒ»Ììʱ£¬Ó¦¼õÈ¥¸ÃÔÂ×îºóÒ»ÌìµÄÈÕÆÚ£¬Ô·ݼÓÉÏÒ»¸öÔ { day -= lastday; month += 1; if (month > 12) //µ±Ëã³öµÄÔ·ݴóÓÚ12£¬Ó¦¼õÈ¥12£¬Äê·Ý¼ÓÉÏ1Äê { month -= 12; year += 1; } } } UTC8Time->year = year; UTC8Time->month = month; UTC8Time->day = day; UTC8Time->hour = hour; UTC8Time->minute = UTCminute; UTC8Time->second = UTCsecond; } #ifdef DEBUGLOG static osMutexId_t DebugFileMux; static void Debug_Write_Logfile(UINT8 *buf) { UINT32 Count; OSAFILE file; osMutexAcquire(DebugFileMux, osWaitForever); file = OsaFopen("DebugFile", "wb"); if (file != NULL) { if (OsaFseek(file, 0, SEEK_END) == 0) { Count = OsaFwrite(buf, 1, strlen(buf), file); } OsaFclose(file); } osMutexRelease(DebugFileMux); return; } void Debug_printf(const UINT8 *format, ...) { UINT8 buf[128 + 1]; va_list args; OsaUtcTimeTValue timeUtc; UINT16 year; UINT8 month, day, hour, minute, sec; appGetSystemTimeUtcSync(&timeUtc); year = (timeUtc.UTCtimer1 & 0xffff0000) >> 16; month = (timeUtc.UTCtimer1 & 0xff00) >> 8; day = timeUtc.UTCtimer1 & 0xff; hour = (timeUtc.UTCtimer2 & 0xff000000) >> 24; minute = (timeUtc.UTCtimer2 & 0xff0000) >> 16; sec = (timeUtc.UTCtimer2 & 0xff00) >> 8; memset(buf, 0, 128 + 1); UTC8TimeType UTC8TimeStruct; UTCToBeijing((UTC8TimeType *)&UTC8TimeStruct, year, month, day, hour, minute, sec); sprintf((char *)buf, "%02d:%02d:%02d-", UTC8TimeStruct.hour, UTC8TimeStruct.minute, UTC8TimeStruct.second); va_start(args, format); vsnprintf(buf + strlen(buf), 128 - strlen(buf), format, args); va_end(args); Debug_Write_Logfile(buf); } UINT16 Debug_GetSize() { UINT16 FileSize; OSAFILE file; osMutexAcquire(DebugFileMux, osWaitForever); file = OsaFopen("DebugFile", "rb"); FileSize = OsaFsize(file); OsaFclose(file); osMutexRelease(DebugFileMux); return FileSize; } void Debug_Read_Logfile(UINT8 *rbuf, UINT16 FileSize) { UINT32 Count; OSAFILE file; printf("%s start\r\n", __FUNCTION__); osMutexAcquire(DebugFileMux, osWaitForever); file = OsaFopen("DebugFile", "rb"); if (file != NULL) { if (OsaFseek(file, 0, SEEK_SET) == 0) { memset(rbuf, 0, FileSize); Count = OsaFread(rbuf, 1, FileSize, file); printf("%s", rbuf); } OsaFclose(file); } printf("%s end! \r\n", __FUNCTION__); osMutexRelease(DebugFileMux); return; } void Debug_Del_Logfile(void) { osMutexAcquire(DebugFileMux, osWaitForever); OsaFremove("DebugFile"); osMutexRelease(DebugFileMux); } #endif #ifdef BL_FILE_LOG static UINT8 blLogFileNux = 0; static void bluejoy_write_logfile(UINT8 *buf) { int32_t err; UINT32 Count; OSAFILE file; while (blLogFileNux) { osDelay(10 / portTICK_PERIOD_MS); } blLogFileNux = 1; file = OsaFopen("blLog", "wb"); if (file == NULL) { //printf("blLog open fail!\r\n"); blLogFileNux = 0; return; } if (OsaFseek(file, 0, SEEK_END) != 0) { //printf("Seek file failed [%d] \r\n",__LINE__); OsaFclose(file); blLogFileNux = 0; return; } Count = OsaFwrite(buf, 1, strlen(buf), file); if (Count != (strlen(buf))) { //printf("blLog write fail!\r\n"); } OsaFclose(file); blLogFileNux = 0; } void bluejoy_read_logfile(void) { int32_t err; UINT32 Count; OSAFILE file; UINT8 rbuf[128 + 1] = {0}; UINT8 *flag_p; UINT16 pri_l; printf("%s start\r\n", __FUNCTION__); while (blLogFileNux) { osDelay(10 / portTICK_PERIOD_MS); } blLogFileNux = 1; file = OsaFopen("blLog", "rb"); if (file == NULL) { printf("blLog not exst!\r\n"); blLogFileNux = 0; return; } if (OsaFseek(file, 0, SEEK_SET) != 0) { printf("Seek file failed [%d] \r\n", __LINE__); OsaFclose(file); blLogFileNux = 0; return; } do { memset(rbuf, 0, 128); Count = OsaFread(rbuf, 1, 128, file); printf("%s", rbuf); } while (Count == 128); OsaFclose(file); blLogFileNux = 0; printf("%s end! \r\n", __FUNCTION__); } void bluejoy_del_logfile(void) { UINT32 ret; //printf("%s start! \r\n",__FUNCTION__); while (blLogFileNux) { osDelay(10 / portTICK_PERIOD_MS); } blLogFileNux = 1; OsaFremove("blLog"); blLogFileNux = 0; FaultDisplay(LED_TURN_OFF); osDelay(1000 / portTICK_PERIOD_MS); FaultDisplay(LED_TURN_ON); osDelay(1000 / portTICK_PERIOD_MS); FaultDisplay(LED_TURN_OFF); osDelay(1000 / portTICK_PERIOD_MS); FaultDisplay(LED_TURN_ON); } void bluejoy_printf(BlLogLevel level, const UINT8 *format, ...) { UINT8 buf[128 + 1]; va_list args; OsaUtcTimeTValue timeUtc; UINT16 year; UINT8 month, day, hour, minite, sec; if (level < BL_LEVEL2) return; appGetSystemTimeUtcSync(&timeUtc); year = (timeUtc.UTCtimer1 & 0xffff0000) >> 16; month = (timeUtc.UTCtimer1 & 0xff00) >> 8; day = timeUtc.UTCtimer1 & 0xff; hour = (timeUtc.UTCtimer2 & 0xff000000) >> 24; minite = (timeUtc.UTCtimer2 & 0xff0000) >> 16; sec = (timeUtc.UTCtimer2 & 0xff00) >> 8; memset(buf, 0, 128 + 1); UTC8TimeType UTC8TimeStruct; UTCToBeijing(UTC8TimeStruct, year, month, day, hour, minite, sec); sprintf((char *)buf, "%04d-%02d-%02d %02d:%02d:%02d ", UTC8TimeStruct.year, UTC8TimeStruct.month, UTC8TimeStruct.day, UTC8TimeStruct.hour, UTC8TimeStruct.minute, UTC8TimeStruct.second); va_start(args, format); vsnprintf(buf + strlen(buf), 128 - strlen(buf), format, args); va_end(args); //printf("%s", buf); bluejoy_write_logfile(buf); } #endif #if 0 /** \fn void NetSocDisplay(UINT8 soc) \param[in] void \brief RSSI display on led \return */ #define RSSI_LEVEL_0 (0) #define RSSI_LEVEL_10 (10) #define RSSI_LEVEL_20 (20) #define RSSI_LEVEL_25 (25) #define RSSI_LEVEL_30 (30) void NetSocDisplay(UINT8 soc) { UINT16 pinLevel[LED_INX_MAX-1] ={0}; gpio_pin_config_t nGpioCfg={0}; nGpioCfg.pinDirection = GPIO_DirectionOutput; nGpioCfg.misc.initOutput = 1; for(int8_t i=0;i< LED_INX_MAX-1;i++){ GPIO_PinConfig(gLedCfg[i].pinPort, gLedCfg[i].pinInx, &nGpioCfg); } if(RSSI_LEVEL_0 < soc && soc <=RSSI_LEVEL_10) { pinLevel[0]=1; pinLevel[1]=pinLevel[2]=pinLevel[3]=0; } else if(RSSI_LEVEL_10 < soc && soc <=RSSI_LEVEL_20) { pinLevel[0]=pinLevel[1]=1; pinLevel[2]=pinLevel[3]=0; } else if(RSSI_LEVEL_20 < soc && soc <=RSSI_LEVEL_25) { pinLevel[0]=pinLevel[1]=pinLevel[2]=1; pinLevel[3]=0; } else if(RSSI_LEVEL_25 < soc && soc <=RSSI_LEVEL_30) { pinLevel[0]=pinLevel[1]=pinLevel[2]=pinLevel[3]=1; } for(UINT8 i=0; 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; i < len; i++) { buf[i] = SPI_Read_Byte(); } #else for (i = 0; i < len; i++) { spiMasterDrv->Transfer(&data, &buf[i], 1); } #endif SPI_CS_High(); return i; } /** \fn UINT8 CanTriggerEvtInit(void) \param[in] \brief generate irq,then notify app \return 1 fail; 0 ok; */ UINT8 CanTriggerEvtInit(void) { /*for msg queue create*/ osMessageQueueAttr_t queue_attr; memset(&queue_attr, 0, sizeof(queue_attr)); queue_attr.cb_mem = &can_recv_queue_cb; queue_attr.cb_size = sizeof(can_recv_queue_cb); queue_attr.mq_mem = can_recv_queue_buf; queue_attr.mq_size = sizeof(can_recv_queue_buf); can_recv_msgqueue = osMessageQueueNew(I2C_RECV_QUEUE_BUF_SIZE, 1, &queue_attr); //printf("CanTriggerEvtInit \r\n"); return 0; } /** \fn void CanWaitEvt(UINT32 timeout) \param[in] \brief \return */ void CanWaitEvt(UINT32 timeout) { osStatus_t status; UINT8 msg = 0; UINT32 mask; status = osMessageQueueGet(can_recv_msgqueue, &msg, 0, osWaitForever); //printf("msg = %#x\r\n",msg); } /** \fn void CanTiggerEvt(UINT8 cmd) \param[in] \brief \return */ void CanTiggerEvt(UINT8 cmd) { osStatus_t status; UINT8 msg = cmd; status = osMessageQueuePut(can_recv_msgqueue, &msg, 0, 0); } /******************************************************************************* * o����y?? : MCP2515_Reset * ?����? : ����?��?��????��?����?t?��??MCP2515 * ��?��? : ?T * ��?3? : ?T * ����???�� : ?T * ?��?�� : ???��2???��??��?��???a������?���䨬?,2��???��?t����?��?a?????�꨺? *******************************************************************************/ INT32 HAL_Can_Reset(void) { SPI_CS_Low(); SPI_Write_Byte(CAN_RESET); SPI_CS_High(); return 0; } /******************************************************************************* * o����y?? : MCP2515_Init * ?����? : MCP25153?��??��???? * ��?��? : ?T * ��?3? : ?T * ����???�� : ?T * ?��?�� : 3?��??���㨹������o����?t?��???��1�����2����??������???�������?��??��1?????�̨�?�� *******************************************************************************/ void HAL_Can_Init(Can_InitType param) { UINT8 temp = 0, temp1 = 0; INT32 res = -1; gpio_pin_config_t config; config.pinDirection = GPIO_DirectionOutput; config.misc.initOutput = 1; pad_config_t padConfig; PAD_GetDefaultConfig(&padConfig); //POWER padConfig.mux = PAD_MuxAlt0; PAD_SetPinConfig(28, &padConfig); GPIO_PinWrite(0, 1 << GPIO_CAN_POWER, 1 << GPIO_CAN_POWER); HAL_Can_Reset(); //¡¤¡é?¨ª?¡ä????¨¢?¨¨¨ª?t?¡ä??MCP2515 osDelay(100 / portTICK_PERIOD_MS); CAN_WriteReg(CANCTRL, OPMODE_CONFIG | CLKOUT_ENABLED); // CAN_ReadReg(CANCTRL,1,&temp);//?¨¢¨¨?CAN¡Á¡ä¨¬???¡ä??¡Â¦Ì??¦Ì #ifdef USING_PRINTF //printf("[%d] CANCTRL = %#x \r\n",__LINE__,temp); #endif CAN_WriteReg(CNF1, param.baudrate); CAN_WriteReg(CNF2, BTLMODE_CNF3 | PHSEG1_3TQ | PRSEG_1TQ); CAN_WriteReg(CNF3, PHSEG2_3TQ); if (param.packType == STD_PACK) { /*?����???2��??��??��*/ CAN_WriteReg(TXB0SIDH, 0xFF & (param.TxStdIDH)); //����?��?o3??��0������?������?��????? CAN_WriteReg(TXB0SIDL, 0xE0 & (param.TxStdIDL)); //����?��?o3??��0������?������?��?�̨�?? CAN_WriteReg(RXM0SIDH, 0x00); CAN_WriteReg(RXM0SIDL, 0x00); CAN_WriteReg(RXM1SIDH, 0x00); CAN_WriteReg(RXM1SIDL, 0x00); /*?����???2��??��??��*/ CAN_WriteReg(RXF0SIDH, 0xFF & (param.RxStdIDH[0])); CAN_WriteReg(RXF0SIDL, 0xE0 & (param.RxStdIDL[0])); CAN_WriteReg(RXF1SIDH, 0xFF & (param.RxStdIDH[1])); CAN_WriteReg(RXF1SIDL, 0xE0 & (param.RxStdIDL[1])); #if 0 CAN_WriteReg(RXF2SIDH,0x00); CAN_WriteReg(RXF2SIDL,0xa0); CAN_WriteReg(RXF3SIDH,0x00); CAN_WriteReg(RXF3SIDL,0x40); CAN_WriteReg(RXF4SIDH,0x00); CAN_WriteReg(RXF4SIDL,0x60); CAN_WriteReg(RXF5SIDH,0x00); CAN_WriteReg(RXF5SIDL,0x80); #else CAN_WriteReg(RXF2SIDH, 0xFF & (param.RxStdIDH[2])); CAN_WriteReg(RXF2SIDL, 0xE0 & (param.RxStdIDL[2])); CAN_WriteReg(RXF3SIDH, 0xFF & (param.RxStdIDH[3])); CAN_WriteReg(RXF3SIDL, 0xE0 & (param.RxStdIDL[3])); CAN_WriteReg(RXF4SIDH, 0xFF & (param.RxStdIDH[4])); CAN_WriteReg(RXF4SIDL, 0xE0 & (param.RxStdIDL[4])); CAN_WriteReg(RXF5SIDH, 0xFF & (param.RxStdIDH[5])); CAN_WriteReg(RXF5SIDL, 0xE0 & (param.RxStdIDL[5])); #endif CAN_WriteReg(RXB0CTRL, RXM_RCV_ALL | BUKT_ROLLOVER); CAN_WriteReg(RXB0DLC, DLC_8); CAN_WriteReg(RXB1CTRL, RXM_RCV_ALL); CAN_WriteReg(RXB1DLC, DLC_8); } else if (param.packType == EXT_PACK) { /*TXB0*/ CAN_WriteReg(TXB0SIDH, 0xFF & (param.TxStdIDH)); CAN_WriteReg(TXB0SIDL, (0xEB & (param.TxStdIDL)) | 0x08); CAN_WriteReg(TXB0EID8, 0xFF & (param.TxExtIDH)); CAN_WriteReg(TXB0EID0, 0xFF & (param.TxExtIDL)); /*?����???2��??��??��*/ CAN_WriteReg(RXM0SIDH, 0x00); //FF->00 zhengchao CAN_WriteReg(RXM0SIDL, 0x00); //E3->00 zhengchao CAN_WriteReg(RXM0EID8, 0x00); //FF->00 zhengchao CAN_WriteReg(RXM0EID0, 0x00); //FF->00 zhengchao /*?����???2��??��??��*/ CAN_WriteReg(RXF0SIDH, 0xFF & (param.RxStdIDH[0])); CAN_WriteReg(RXF0SIDL, (0xEB & (param.RxStdIDL[0])) | 0x08); CAN_WriteReg(RXF0EID8, 0xFF & (param.RxExtIDH[0])); CAN_WriteReg(RXF0EID8, 0xFF & (param.RxExtIDL[0])); CAN_WriteReg(RXF1SIDH, 0xFF & (param.RxStdIDH[1])); CAN_WriteReg(RXF1SIDL, (0xEB & (param.RxStdIDL[1])) | 0x08); CAN_WriteReg(RXF1EID8, 0xFF & (param.RxExtIDH[1])); CAN_WriteReg(RXF1EID8, 0xFF & (param.RxExtIDL[1])); CAN_WriteReg(RXF2SIDH, 0xFF & (param.RxStdIDH[2])); CAN_WriteReg(RXF2SIDL, (0xEB & (param.RxStdIDL[2])) | 0x08); CAN_WriteReg(RXF2EID8, 0xFF & (param.RxExtIDH[2])); CAN_WriteReg(RXF2EID8, 0xFF & (param.RxExtIDL[2])); CAN_WriteReg(RXF3SIDH, 0xFF & (param.RxStdIDH[3])); CAN_WriteReg(RXF3SIDL, (0xEB & (param.RxStdIDL[3])) | 0x08); CAN_WriteReg(RXF3EID8, 0xFF & (param.RxExtIDH[3])); CAN_WriteReg(RXF3EID8, 0xFF & (param.RxExtIDL[3])); CAN_WriteReg(RXF4SIDH, 0xFF & (param.RxStdIDH[4])); CAN_WriteReg(RXF4SIDL, (0xEB & (param.RxStdIDL[4])) | 0x08); CAN_WriteReg(RXF4EID8, 0xFF & (param.RxExtIDH[4])); CAN_WriteReg(RXF4EID8, 0xFF & (param.RxExtIDL[4])); CAN_WriteReg(RXF5SIDH, 0xFF & (param.RxStdIDH[5])); CAN_WriteReg(RXF5SIDL, (0xEB & (param.RxStdIDL[5])) | 0x08); CAN_WriteReg(RXF5EID8, 0xFF & (param.RxExtIDH[5])); CAN_WriteReg(RXF5EID8, 0xFF & (param.RxExtIDL[5])); CAN_WriteReg(RXB0CTRL, RXM_VALID_EXT | BUKT_ROLLOVER); CAN_WriteReg(RXB0DLC, DLC_8); CAN_WriteReg(RXB1CTRL, RXM_VALID_EXT | FILHIT1_FLTR_2); CAN_WriteReg(RXB1DLC, DLC_8); } CAN_WriteReg(BFPCTRL, 0x3F); //zhengchao20210304 add CAN_WriteReg(CANINTE, RX0IF | RX1IF); //zhengchao20210304 0x43 -> 0x03 CAN_WriteReg(CANINTF, 0x00); CAN_WriteReg(CANCTRL, param.mode | CLKOUT_ENABLED); //??MCP2515¨¦¨¨???a?y3¡ê?¡ê¨º?,¨ª?3??????¡ê¨º? REQOP_NORMAL|CLKOUT_ENABLED CAN_ReadReg(CANSTAT, 1, &temp); //?¨¢¨¨?CAN¡Á¡ä¨¬???¡ä??¡Â¦Ì??¦Ì if (param.mode != (temp & 0xE0)) //?D??MCP2515¨º?¡¤?¨°??-??¨¨??y3¡ê?¡ê¨º? { CAN_WriteReg(CANCTRL, param.mode | CLKOUT_ENABLED); //?¨´¡ä???MCP2515¨¦¨¨???a?y3¡ê?¡ê¨º?,¨ª?3??????¡ê¨º?REQOP_NORMAL } } /******************************************************************************* * : HAL_Can_Sleep * * * * * *******************************************************************************/ void HAL_Can_Sleep(void) { UINT8 temp = 0, temp2 = 0, t = 0; do { CAN_WriteReg(CANCTRL, OPMODE_CONFIG); CAN_WriteReg(CANINTE, WAKIE | RX0IE | RX1IE); //CAN_WriteReg(CNF3, WAKFIL); CAN_ReadReg(CANSTAT, 1, &temp); CAN_WriteReg(CANCTRL, OPMODE_SLEEP | CLKOUT_DISABLED); #ifdef USING_PRINTF //printf("%s[%d] [%#x]\r\n",__FUNCTION__, __LINE__,temp); #endif if (OPMODE_SLEEP == (temp & 0xE0)) { #ifdef USING_PRINTF //printf("SLEEP SUC \r\n"); #endif break; } } while (t++ < 3); //POWER GPIO_PinWrite(0, 1 << GPIO_CAN_POWER, 0); } /******************************************************************************* * o¡¥¨ºy?? : HAL_Can_Transmit * ?¨¨¨º? : CAN¡¤¡é?¨ª???¡§3¡è?¨¨¦Ì?¨ºy?Y * ¨º?¨¨? : *CAN_TX_Buf(¡äy¡¤¡é?¨ª¨ºy?Y?o3???????),len(¡äy¡¤¡é?¨ª¨ºy?Y3¡è?¨¨) * ¨º?3? : ?T * ¡¤¦Ì???¦Ì : ?T * ?¦Ì?¡Â : ?T *******************************************************************************/ INT8 HAL_Can_Transmit(CAN_Msg_Type Can_TxMsg) { UINT8 tryTim, count, value, i, temp, TXBufferCase = 0; INT8 ret = 0; UINT8 TXB0CTRLvalue, TXB1CTRLvalue, TXB2CTRLvalue, CANINTFValue = 0; CAN_ReadReg(TXB0CTRL, 1, &TXB0CTRLvalue); CAN_ReadReg(TXB1CTRL, 1, &TXB1CTRLvalue); CAN_ReadReg(TXB2CTRL, 1, &TXB2CTRLvalue); if ((TXB0CTRLvalue & TXREQ) == 0) TXBufferCase = 0; else if ((TXB1CTRLvalue & TXREQ) == 0) TXBufferCase = 1; else if ((TXB2CTRLvalue & TXREQ) == 0) TXBufferCase = 2; else { CAN_WriteReg(TXB0CTRL, TXB0CTRLvalue & (~TXREQ)); TXBufferCase = 0; } switch (TXBufferCase) { case 0: { //tryTim=0; //CAN_RseadReg(TXB0CTRL,1,&value); //while((value&0x08) && (tryTim<50))//?��?��?��?3D?���䨬???��?,�̨���yTXREQ����????��? //{ // CAN_ReadReg(TXB0CTRL,1,&value); // osDelay(1/portTICK_PERIOD_MS); // tryTim++; //} /*TXB0*/ CAN_WriteReg(TXB0SIDH, 0xFF & ((Can_TxMsg.Id) >> 3)); //����?��?o3??��0������?������?��????? CAN_WriteReg(TXB0SIDL, 0xE0 & ((Can_TxMsg.Id) << 5)); //����?��?o3??��0������?������?��?�̨�?? for (i = 0; i < Can_TxMsg.DLC; i++) { CAN_WriteReg(TXB0D0 + i, Can_TxMsg.Data[i]); //??��y����?����?��y?YD�䨨?����?��?o3???��??�� } CAN_WriteReg(TXB0DLC, Can_TxMsg.DLC); //??��???��y����?����?��y?Y3��?��D�䨨?����?��?o3??��0��?����?��3��?��??��??�� SPI_CS_Low(); CAN_WriteReg(TXB0CTRL, TXREQ); //???������?������?? //SPI_CS_High(); ret = 0; break; } case 1: { /*TXB0*/ CAN_WriteReg(TXB1SIDH, 0xFF & ((Can_TxMsg.Id) >> 3)); //����?��?o3??��0������?������?��????? CAN_WriteReg(TXB1SIDL, 0xE0 & ((Can_TxMsg.Id) << 5)); //����?��?o3??��0������?������?��?�̨�?? for (i = 0; i < Can_TxMsg.DLC; i++) { CAN_WriteReg(TXB1D0 + i, Can_TxMsg.Data[i]); //??��y����?����?��y?YD�䨨?����?��?o3???��??�� } CAN_WriteReg(TXB1DLC, Can_TxMsg.DLC); //??��???��y����?����?��y?Y3��?��D�䨨?����?��?o3??��0��?����?��3��?��??��??�� SPI_CS_Low(); CAN_WriteReg(TXB1CTRL, TXREQ); //???������?������?? //SPI_CS_High(); ret = 1; break; } case 2: { /*TXB0*/ CAN_WriteReg(TXB2SIDH, 0xFF & ((Can_TxMsg.Id) >> 3)); //����?��?o3??��0������?������?��????? CAN_WriteReg(TXB2SIDL, 0xE0 & ((Can_TxMsg.Id) << 5)); //����?��?o3??��0������?������?��?�̨�?? for (i = 0; i < Can_TxMsg.DLC; i++) { CAN_WriteReg(TXB2D0 + i, Can_TxMsg.Data[i]); //??��y����?����?��y?YD�䨨?����?��?o3???��??�� } CAN_WriteReg(TXB2DLC, Can_TxMsg.DLC); //??��???��y����?����?��y?Y3��?��D�䨨?����?��?o3??��0��?����?��3��?��??��??�� SPI_CS_Low(); CAN_WriteReg(TXB2CTRL, TXREQ); //???������?������?? //SPI_CS_High(); ret = 2; break; } default: { ret = -1; break; } } CAN_ReadReg(TXB0CTRL, 1, &TXB0CTRLvalue); CAN_ReadReg(TXB1CTRL, 1, &TXB1CTRLvalue); CAN_ReadReg(TXB2CTRL, 1, &TXB2CTRLvalue); tryTim = 0; while ((TXB0CTRLvalue & TXREQ) && (TXB1CTRLvalue & TXREQ) && (TXB1CTRLvalue & TXREQ) && (tryTim < 50)) { //SPI_CS_High(); CAN_ReadReg(TXB0CTRL, 1, &TXB0CTRLvalue); CAN_ReadReg(TXB1CTRL, 1, &TXB1CTRLvalue); CAN_ReadReg(TXB2CTRL, 1, &TXB2CTRLvalue); osDelay(1); tryTim++; } CAN_ReadReg(CANINTF, 1, &CANINTFValue); SPI_CS_High(); if ((TXB0CTRLvalue & 0x20) || (TXB1CTRLvalue & 0x20) || (TXB2CTRLvalue & 0x20) || (CANINTFValue & 0x80)) { ret = -1; } return ret; } /******************************************************************************* * o����y?? : HAL_Can_Receive(UINT8 *CAN_RX_Buf) * ?����? : CAN?����?��???��y?Y * ��?��? : *CAN_TX_Buf(��y?����?��y?Y?o3???????) * ��?3? : ?T * ����???�� : len(?����?��?��y?Y��?3��?��,0~8��??��) * ?��?�� : ?T *******************************************************************************/ UINT8 HAL_Can_Receive(CAN_Msg_Type *CanRxMsgBuffer) { UINT8 j = 0, len = 0, temp = 0; UINT8 SIdH, SIdL, EId8, EId0; //static UINT16 counterBuff0,counterBuff1 = 0; UINT8 ret = 0; CAN_ReadReg(CANINTF, 1, &temp); ret = temp & 0x03; switch (ret) { case 0x00: return ret; break; case 0x01: /*get the id information*/ CAN_ReadReg(RXB0SIDH, 1, &SIdH); CAN_ReadReg(RXB0SIDL, 1, &SIdL); CAN_ReadReg(RXB0EID8, 1, &EId8); CAN_ReadReg(RXB0EID0, 1, &EId0); CAN_ReadReg(RXB0DLC, 1, &len); len = len & 0x0F; CanRxMsgBuffer[0].DLC = len; if (SIdL & 0x8) // if SIdL.3 = 1, the id belongs to ExtID { (CanRxMsgBuffer[0]).Id = ((SIdH << 5 | (SIdL >> 5) << 2 | SIdL & 0x3) << 16 | (EId8 << 8) | EId0); } else { (CanRxMsgBuffer[0]).Id = SIdH << 3 | SIdL >> 5; } j = 0; while (j < len) { CAN_ReadReg(RXB0D0 + j, 1, &((CanRxMsgBuffer[0]).Data[j])); j++; } #ifdef USING_PRINTF1 printf("buffer0 ID = %x\n", CanRxMsgBuffer[0].Id); for (j = 0; j < 8; j++) { printf("%x ", CanRxMsgBuffer[0].Data[j]); } printf("\n"); #endif CAN_WriteReg(CANINTF, temp & 0xFE); return ret; break; case 0x02: /*get the id information*/ CAN_ReadReg(RXB1SIDH, 1, &SIdH); CAN_ReadReg(RXB1SIDL, 1, &SIdL); CAN_ReadReg(RXB1EID8, 1, &EId8); CAN_ReadReg(RXB1EID0, 1, &EId0); CAN_ReadReg(RXB1DLC, 1, &len); len = len & 0x0F; CanRxMsgBuffer[1].DLC = len; if (SIdL & 0x8) // SIdL.3 = 1, ExtID { (CanRxMsgBuffer[1]).Id = ((SIdH << 5 | (SIdL >> 5) << 2 | SIdL & 0x3) << 16 | (EId8 << 8) | EId0); } else { (CanRxMsgBuffer[1]).Id = SIdH << 3 | SIdL >> 5; } j = 0; while (j < len) { CAN_ReadReg(RXB1D0 + j, 1, &((CanRxMsgBuffer[1]).Data[j])); j++; } #ifdef USING_PRINTF1 printf("buffer1 ID = %x\n", CanRxMsgBuffer[1].Id); for (j = 0; j < 8; j++) { printf("%x ", CanRxMsgBuffer[1].Data[j]); } printf("\n"); #endif CAN_WriteReg(CANINTF, temp & 0xFD); return ret; break; case 0x03: /*get the id information*/ CAN_ReadReg(RXB0SIDH, 1, &SIdH); CAN_ReadReg(RXB0SIDL, 1, &SIdL); CAN_ReadReg(RXB0EID8, 1, &EId8); CAN_ReadReg(RXB0EID0, 1, &EId0); CAN_ReadReg(RXB0DLC, 1, &len); len = len & 0x0F; CanRxMsgBuffer[0].DLC = len; if (SIdL & 0x8) // if SIdL.3 = 1, the id belongs to ExtID { (CanRxMsgBuffer[0]).Id = ((SIdH << 5 | (SIdL >> 5) << 2 | SIdL & 0x3) << 16 | (EId8 << 8) | EId0); } else { (CanRxMsgBuffer[0]).Id = SIdH << 3 | SIdL >> 5; } j = 0; while (j < len) { CAN_ReadReg(RXB0D0 + j, 1, &((CanRxMsgBuffer[0]).Data[j])); j++; } #ifdef USING_PRINTF1 printf("buffer0 ID = %x\n", CanRxMsgBuffer[0].Id); for (j = 0; j < 8; j++) { printf("%x ", CanRxMsgBuffer[0].Data[j]); } printf("\n"); #endif /*get the id information*/ CAN_ReadReg(RXB1SIDH, 1, &SIdH); CAN_ReadReg(RXB1SIDL, 1, &SIdL); CAN_ReadReg(RXB1EID8, 1, &EId8); CAN_ReadReg(RXB1EID0, 1, &EId0); CAN_ReadReg(RXB1DLC, 1, &len); len = len & 0x0F; CanRxMsgBuffer[1].DLC = len; if (SIdL & 0x8) // SIdL.3 = 1, ExtID { (CanRxMsgBuffer[1]).Id = ((SIdH << 5 | (SIdL >> 5) << 2 | SIdL & 0x3) << 16 | (EId8 << 8) | EId0); } else { (CanRxMsgBuffer[1]).Id = SIdH << 3 | SIdL >> 5; } j = 0; while (j < len) { CAN_ReadReg(RXB1D0 + j, 1, &((CanRxMsgBuffer[1]).Data[j])); j++; } #ifdef USING_PRINTF1 printf("buffer1 ID = %x\n", CanRxMsgBuffer[1].Id); for (j = 0; j < 8; j++) { printf("%x ", CanRxMsgBuffer[1].Data[j]); } printf("\n"); #endif CAN_WriteReg(CANINTF, temp & 0xFC); return ret; break; default: break; } /* CAN_ReadReg(CANINTF,1, &temp1); if((temp1&0x03) == (temp&0x03)) { CAN_WriteReg(CANINTF,temp&0xFC); break; } */ return ret; // CAN_ReadReg(CANINTF,1,&temp); // printf("CANINTF_1 = 0x%x\n",temp); } /** \fn void CanHandleDataCallback(UINT32 event) \param[in] event spi irq event \brief base on event,handle different situation \return */ void CanHandleDataCallback(UINT32 event) { if (event & ARM_SPI_EVENT_TRANSFER_COMPLETE) { } else if (event & ARM_SPI_EVENT_DATA_LOST) { } else if (event & ARM_SPI_EVENT_MODE_FAULT) { } #if 0 #ifdef USING_PRINTF //printf("[%d] CanHandleDataCallback :%d\r\n",__LINE__,event); #else ECOMM_TRACE(UNILOG_PLA_APP,CAN_CB1, P_INFO, 1, "SPI event [%u] coming!",event); #endif #endif } /** \fn void CanSPIHandler(ARM_SPI_SignalEvent_t cb_event) \param[in] cb_event : \brief init spi module \return */ void CanSPIHandler(ARM_SPI_SignalEvent_t cb_event, UINT8 mode, UINT8 dataBits, UINT32 spiRate) { #ifdef SPI_ANALOG gpio_pin_config_t nGpioCfg = {0}; nGpioCfg.pinDirection = GPIO_DirectionOutput; nGpioCfg.misc.initOutput = 1; pad_config_t padConfig; PAD_GetDefaultConfig(&padConfig); /*cs*/ padConfig.mux = PAD_MuxAlt0; PAD_SetPinConfig(SPI_SSN_GPIO_PAD_ADDR, &padConfig); PAD_SetPinPullConfig(SPI_SSN_GPIO_PAD_ADDR, PAD_InternalPullDown); GPIO_PinConfig(SPI_SSN_GPIO_INSTANCE, SPI_SSN_GPIO_INDEX, &nGpioCfg); GPIO_PinWrite(SPI_SSN_GPIO_INSTANCE, 1 << SPI_SSN_GPIO_INDEX, 0); /* clk */ padConfig.mux = PAD_MuxAlt0; PAD_SetPinConfig(SPI_CLK_GPIO_PAD_ADDR, &padConfig); PAD_SetPinPullConfig(SPI_CLK_GPIO_PAD_ADDR, PAD_InternalPullDown); GPIO_PinConfig(SPI_CLK_GPIO_INSTANCE, SPI_CLK_GPIO_INDEX, &nGpioCfg); GPIO_PinWrite(SPI_CLK_GPIO_INSTANCE, 1 << SPI_CLK_GPIO_INDEX, 0); /*mosi*/ padConfig.mux = PAD_MuxAlt0; PAD_SetPinConfig(SPI_MOSI_GPIO_PAD_ADDR, &padConfig); PAD_SetPinPullConfig(SPI_MOSI_GPIO_PAD_ADDR, PAD_InternalPullDown); GPIO_PinConfig(SPI_MOSI_GPIO_INSTANCE, SPI_MOSI_GPIO_INDEX, &nGpioCfg); GPIO_PinWrite(SPI_MOSI_GPIO_INSTANCE, 1 << SPI_MOSI_GPIO_INDEX, 0); /*miso*/ nGpioCfg.pinDirection = GPIO_DirectionInput; nGpioCfg.misc.initOutput = 0; padConfig.mux = PAD_MuxAlt0; padConfig.pullSelect = PAD_PullInternal; padConfig.pullUpEnable = PAD_PullUpDisable; padConfig.pullDownEnable = PAD_PullDownEnable; PAD_SetPinConfig(SPI_MISO_GPIO_PAD_ADDR, &padConfig); GPIO_PinConfig(SPI_MISO_GPIO_INSTANCE, SPI_MISO_GPIO_INDEX, &nGpioCfg); #else // Initialize master spi spiMasterDrv->Initialize(NULL); // Power on spiMasterDrv->PowerControl(ARM_POWER_FULL); // Configure slave spi bus spiMasterDrv->Control(ARM_SPI_MODE_MASTER | mode | ARM_SPI_DATA_BITS(dataBits) | ARM_SPI_MSB_LSB | ARM_SPI_SS_MASTER_SW, spiRate); #endif } /** \fn INT32 ZM01RecvParam(UINT8 *param) \param[in] \brief read ZM01 register \return execution_status */ INT32 ZM01RecvParam(UINT8 *param) { INT32 res = 0; UINT8 tempBuffer = 0xaa; if (param == NULL) return -7; res = i2cDrvInstance->MasterTransmit(ZM01_DEVICE_ADDR, &tempBuffer, 1, true); res = i2cDrvInstance->MasterReceive(ZM01_DEVICE_ADDR, param, 1, true); return res; } /** \fn INT32 GSENSOR_WriteReg(UINT8 addr, UINT8 value) \param[in] addr GSENSOR register addr \brief Write to GSENSOR register \return */ INT32 GSENSOR_WriteReg(UINT8 addr, UINT8 value) { UINT8 tempBuffer[2]; INT32 res = -1; tempBuffer[0] = addr; tempBuffer[1] = value; return (i2cDrvInstance->MasterTransmit(GSENSOR_DEVICE_ADDR, tempBuffer, sizeof(tempBuffer), true)); } /** \fn INT32 GSENSOR_ReadReg(UINT8 reg, UINT8 len, UINT8 *buf) \param[in] addr GSENSOR register addr \brief read GSENSOR register \return register value of GSENSOR */ INT32 GSENSOR_ReadReg(UINT8 reg, UINT8 len, UINT8 *buf) { INT32 res = -1; if (len > 8 || buf == NULL) return -1; res = i2cDrvInstance->MasterTransmit(GSENSOR_DEVICE_ADDR, ®, 1, true); res = i2cDrvInstance->MasterReceive(GSENSOR_DEVICE_ADDR, buf, len, true); return res; } /** \fn void GsensorI2CCallback(UINT32 event) \param[in] event : i2c irq event \brief i2c irq event ,callback function \return */ void GsensorI2CCallback(UINT32 event) { switch (event) { case ARM_I2C_EVENT_TRANSFER_DONE: break; case ARM_I2C_EVENT_TRANSFER_INCOMPLETE: break; case ARM_I2C_EVENT_ADDRESS_NACK: break; case ARM_I2C_EVENT_BUS_ERROR: break; case ARM_I2C_EVENT_BUS_CLEAR: break; default: break; } } /** \fn void HAL_I2C_CreateRecvTaskAndQueue(uint32_t event) \param[in] \brief RECV data \return */ void HAL_I2C_RecvControl(bool on) { EC_ASSERT(g_i2CRecvFlag, g_i2CRecvFlag, 0, 0); if (on == true) { osEventFlagsClear(g_i2CRecvFlag, I2C_RECV_CONTROL_FLAG); } else { osEventFlagsSet(g_i2CRecvFlag, I2C_RECV_CONTROL_FLAG); } } void GsensorTriggerEvent(UINT32 event, UINT32 data) { osStatus_t status; i2c_recv_msgqueue_obj_t msg = {0}; msg.event = event; msg.value = data; status = osMessageQueuePut(i2c_recv_msgqueue, &msg, 0, 0); if (status == osErrorResource) { ECOMM_TRACE(UNILOG_PLA_DRIVER, GsensorTriggerEvent_0, P_WARNING, 0, "I2C recv queue error"); } } static INT32 I2CEvtProcess(uint32_t evt) { INT32 ret; #if SL_SC7A20_16BIT_8BIT INT16 xyzData[7]; #else INT8 xyzData[7]; #endif HAL_I2C_RecvControl(true); if (evt & I2C_INT1_REQ_BITMAP) { } if (evt & I2C_INT2_REQ_BITMAP) { SL_SC7A20_Read_XYZ_Data(xyzData); } return 0; } static void HAL_I2C_RecvTaskEntry(void) { while (1) { uint32_t flag, mask; osStatus_t status; i2c_recv_msgqueue_obj_t msg; flag = osEventFlagsWait(g_i2CRecvFlag, I2C_RECV_CONTROL_FLAG, osFlagsNoClear | osFlagsWaitAll, osWaitForever); EC_ASSERT(flag == I2C_RECV_CONTROL_FLAG, flag, 0, 0); status = osMessageQueueGet(i2c_recv_msgqueue, &msg, 0, osWaitForever); if (status == osOK) { mask = SaveAndSetIRQMask(); //handle data //I2CEvtProcess(msg.event); #ifdef USING_PRINTF //printf("[%d]i2c recv event\r\n",__LINE__); #else ECOMM_TRACE(UNILOG_PLA_DRIVER, I2C_GSENSOR_D, P_INFO, 0, "i2c recv event"); #endif RestoreIRQMask(mask); } } } static void HAL_I2C_CreateRecvTaskAndQueue(void) { if (g_halI2CInitFlag & HAL_I2C_RECV_TASK_QUEUE_CREATED) { return; } /* for task create */ osThreadId_t threadId; osThreadAttr_t task_attr; /*for msg queue create*/ osMessageQueueAttr_t queue_attr; g_i2CRecvFlag = osEventFlagsNew(NULL); EC_ASSERT(g_i2CRecvFlag, g_i2CRecvFlag, 0, 0); memset(&queue_attr, 0, sizeof(queue_attr)); queue_attr.cb_mem = &i2c_recv_queue_cb; queue_attr.cb_size = sizeof(i2c_recv_queue_cb); queue_attr.mq_mem = i2c_recv_queue_buf; queue_attr.mq_size = sizeof(i2c_recv_queue_buf); i2c_recv_msgqueue = osMessageQueueNew(I2C_RECV_QUEUE_BUF_SIZE, sizeof(i2c_recv_msgqueue_obj_t), &queue_attr); EC_ASSERT(i2c_recv_msgqueue, i2c_recv_msgqueue, 0, 0); memset(&task_attr, 0, sizeof(task_attr)); memset(i2c_recv_task_stack, 0xA5, I2C_RECV_TASK_STACK_SIZE); task_attr.name = "GsensorRecv"; task_attr.stack_size = I2C_RECV_TASK_STACK_SIZE; task_attr.stack_mem = i2c_recv_task_stack; task_attr.priority = osPriorityNormal; task_attr.cb_mem = &i2c_recv_task; task_attr.cb_size = sizeof(StaticTask_t); threadId = osThreadNew(HAL_I2C_RecvTaskEntry, NULL, &task_attr); EC_ASSERT(threadId, threadId, 0, 0); g_halI2CInitFlag |= HAL_I2C_RECV_TASK_QUEUE_CREATED; } /** \fn void Usart1Handler(uint8_t* strPtr, uint16_t strLen) \param[in] PrintfSendStr for usart port; \brief config usart port \return */ void PrintfSendStr(const UINT8 *format, ...) { va_list args; UINT8 buf[128 + 1] = {0}; va_start(args, format); vsnprintf(buf + strlen(buf), 128 - strlen(buf), format, args); va_end(args); HAL_UART_SendStr(PORT_USART_1, buf, strlen(buf)); } #define PRINTF_DATA_RECV_BUFFER_SIZE (200) uint8_t printf_uart_recv_buf[PRINTF_DATA_RECV_BUFFER_SIZE]; /** \fn void PrintfDataRecvCallback(uint32_t event, void* dataPtr, uint32_t dataLen) \param[in] event :Data receiving timeout processing and data receiving completion processing; \ dataPtr : Point to receive data buff \ dataLen : Received data length \brief i2c irq event ,callback function \return */ void UartDataRecvCallback(UINT32 event, void *dataPtr, UINT32 dataLen) { if ((event == ARM_USART_EVENT_RX_TIMEOUT) || (event == ARM_USART_EVENT_RECEIVE_COMPLETE)) { if (uartDataHandle != NULL && dataLen > 0) { UartBuffer UartDataBuffer = {0}; memcpy((UINT8 *)&UartDataBuffer, dataPtr, dataLen); UartDataBuffer.len = dataLen; osMessageQueuePut(uartDataHandle, &UartDataBuffer, 0, 10); } } slpManStartWaitATTimer(); } void printfPostSendCallback(hal_uart_send_msg_type_t msgType, void *dataPtr, uint32_t dataLen) { // ECOMM_TRACE(UNILOG_PLA_APP, printfPostSendCallback, P_SIG, 3, "msgType=%d, dataPtr=%s, dataLen=%d",msgType,dataPtr,dataLen); } /** \fn void Usart1Handler(UINT32 baudRate) \param[in] baudRate for usart port; \brief config usart port \return */ void Usart1Handler(UINT32 baudRate) { hal_uart_config_t halUartConfig = {0}; hal_uart_hardware_config_t hwConfig = { ARM_POWER_FULL, ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_8 | ARM_USART_PARITY_NONE | ARM_USART_STOP_BITS_1 | ARM_USART_FLOW_CONTROL_NONE, baudRate}; halUartConfig.uartDriverHandler = printfHandle; halUartConfig.recv_cb = UartDataRecvCallback; halUartConfig.recvBuffPtr = printf_uart_recv_buf; halUartConfig.recvBuffSize = PRINTF_DATA_RECV_BUFFER_SIZE; halUartConfig.post_send_cb = printfPostSendCallback; HAL_UART_InitHandler(PORT_USART_1, &halUartConfig, &hwConfig, HAL_UART_TASK_CREATE_FLAG_SEND_RECV); HAL_UART_RecvFlowControl(false); } /** \fn void GsensorI2CCallback(uint32_t event) \param[in] event : i2c irq event \brief i2c irq event ,callback function \return */ void GsensorI2CHandler(ARM_I2C_SignalEvent_t cb_event) { // Initialize with callback i2cDrvInstance->Initialize(cb_event); // Power on i2cDrvInstance->PowerControl(ARM_POWER_FULL); // Configure I2C bus i2cDrvInstance->Control(ARM_I2C_BUS_SPEED, ARM_I2C_BUS_SPEED_STANDARD); i2cDrvInstance->Control(ARM_I2C_BUS_CLEAR, 0); HAL_I2C_CreateRecvTaskAndQueue(); #ifdef USING_PRINTF //printf("[%d] i2c config ok\r\n",__LINE__); #else ECOMM_TRACE(UNILOG_PLA_DRIVER, I2C_GSENSOR_I, P_INFO, 0, "i2c config ok"); #endif } /** \fn void GPSSendStr(uint8_t* strPtr, uint16_t strLen) \param[in] strPtr for gps usart port; \brief \return */ void GPSSendStr(uint8_t *strPtr, uint16_t strLen) { HAL_UART_SendStr(PORT_USART_2, strPtr, strLen); } /** \fn void GpsDataRecvCallback(uint32_t event, void* dataPtr, uint32_t dataLen) \param[in] event :Data receiving timeout processing and data receiving completion processing; \ dataPtr : Point to receive data buff \ dataLen : Received data length \brief i2c irq event ,callback function \return */ void GpsDataRecvCallback(UINT32 event, void *dataPtr, UINT32 dataLen) { if ((event == ARM_USART_EVENT_RX_TIMEOUT) || (event == ARM_USART_EVENT_RECEIVE_COMPLETE)) { #ifdef USING_PRINTF //printf("GpsDataRecvCallback [%d] %s\r\n",dataLen,dataPtr); #endif if (gpsHandle != NULL && dataLen > 0) { gpsReqMsg gpsInfo; gpsInfo.dataPtr = malloc(dataLen + 1); if (gpsInfo.dataPtr) { memcpy(gpsInfo.dataPtr, dataPtr, dataLen); gpsInfo.len = dataLen; osMessageQueuePut(gpsHandle, &gpsInfo, 0, 60000U); } } } slpManStartWaitATTimer(); } /** \fn void GPSUsartHandler(ARM_DRIVER_USART * uartDriverHandler, uint32_t baudRate) \param[in] baudRate for gps usart port; \brief config gps usart port \return */ void GPSUsartHandler(UINT32 baudRate) { hal_uart_config_t halUartConfig = {0}; hal_uart_hardware_config_t hwConfig = { ARM_POWER_FULL, ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_8 | ARM_USART_PARITY_NONE | ARM_USART_STOP_BITS_1 | ARM_USART_FLOW_CONTROL_NONE, baudRate}; halUartConfig.uartDriverHandler = usartHandle; halUartConfig.recv_cb = GpsDataRecvCallback; halUartConfig.recvBuffPtr = gps_uart_recv_buf; halUartConfig.recvBuffSize = GPS_DATA_RECV_BUFFER_SIZE; HAL_UART_InitHandler(PORT_USART_2, &halUartConfig, &hwConfig, HAL_UART_TASK_CREATE_FLAG_SEND_RECV); HAL_UART_RecvFlowControl(false); } /** \fn INT32 AdcGetRes(UINT32 NTCvalue) \param[in] req : NTCvalue \brief \return Resvalue */ static INT32 AdcGetRes(UINT32 NTCvalue) { UINT32 Resvalue; if (NTCvalue >= (ADC_ChannelAioVbat - 10)) Resvalue = 1000000; else { Resvalue = (long long)ADC_ChannelAioRes * (long long)NTCvalue / (ADC_ChannelAioVbat - NTCvalue); } return Resvalue; } /** \fn INT32 AdcGetRes(UINT32 NTCvalue) \param[in] req : NTCvalue \brief \return Resvalue */ static INT32 AdcGetResFromInres(UINT32 NTCvalue) { UINT32 Resvalue, ResvalueCount; if (NTCvalue >= (ADC_ChannelAioVbat - 10)) ResvalueCount = 1000000; else { ResvalueCount = ADC_ChannelAioRes * NTCvalue / (ADC_ChannelAioVbat - NTCvalue); } #ifdef USING_PRINTF //printf("%s[%d][%d][%d]\r\n",__FUNCTION__, __LINE__,ADC_InsideRES,ResvalueCount); #endif if (ResvalueCount >= ADC_InsideRES) Resvalue = 1000000; else Resvalue = (long long)ADC_InsideRES * (long long)ResvalueCount / (ADC_InsideRES - ResvalueCount); #ifdef USING_PRINTF //printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,Resvalue); #endif return Resvalue; } /** \fn INT32 AdcVbatCali(UINT32 NTCvalue) \param[in] req : NTCvalue \brief \return Resvalue */ static INT32 AdcVbatCali(UINT32 NTCvalue) { UINT32 Resvalue; if (NTCvalue >= (ADC_ChannelAioVbat - 10)) Resvalue = 1000000; else { Resvalue = (long long)(ADC_ChannelAioRes + ADC_CALIBRATION_VALUE) * (long long)NTCvalue / ADC_CALIBRATION_VALUE; //ADC_ChannelAioRes*NTCvalue/(ADC_ChannelAioVbat-NTCvalue); } if (Resvalue < 1300 && Resvalue > 1100) ADC_ChannelAioVbat = Resvalue; return Resvalue; } /** \fn INT32 AdcInresCali(UINT32 NTCvalue) \param[in] req : NTCvalue \brief \return Resvalue */ static INT32 AdcInresCali(UINT32 NTCvalue) { UINT32 Resvalue, ResvalueCount; if (NTCvalue >= (ADC_ChannelAioVbat - 10)) ResvalueCount = 1000000; else { ResvalueCount = ADC_ChannelAioRes * NTCvalue / (ADC_ChannelAioVbat - NTCvalue); } #ifdef USING_PRINTF //printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,ResvalueCount); #endif if (ResvalueCount >= ADC_CALIBRATION_VALUE) Resvalue = 1000000; else Resvalue = (long long)ADC_CALIBRATION_VALUE * (long long)ResvalueCount / (ADC_CALIBRATION_VALUE - ResvalueCount); if (Resvalue >= 200000 && Resvalue < 1000000) ADC_InsideRES = Resvalue; return Resvalue; } /** \fn INT32 AdcSendReq(UINT32 req,UINT32 * param ,UINT32 timeout) \param[in] req : ADC_REQ_BITMAP_VBAT ADC_REQ_BITMAP_TEMP; timeout = 0 at irq ,otherwize equal to ADC_MSG_TIMEOUT \brief return bat value ,trigger deinit \return 1 FAIL , 0 OK */ INT32 AdcSendReq(UINT32 req, UINT32 *param, UINT8 len, UINT32 timeout) { INT32 ret; adcReqMsg ReqMsg; ReqMsg.request = req; ReqMsg.param[NTC_Channel1] = ReqMsg.param[NTC_Channel2] = ReqMsg.param[NTC_Channel30] = ReqMsg.param[NTC_Channel31] = ReqMsg.param[NTC_Channel4] = ReqMsg.param[NTC_Channel4_InresCali] = ADC_AioResDivRatioDefault; ret = osMessageQueuePut(adcMsgHandle, &ReqMsg, 0, timeout); if (ret != osOK) { return ret; } else { ret = osEventFlagsWait(adcTrigerHandle, ADC_RECV_CONTROL_FLAG, osFlagsWaitAll, timeout); //to do switch (req) { case ADC_REQ_BITMAP_VBAT: param[0] = gNtcDev.NTCvalue[0]; break; case ADC_REQ_BITMAP_TEMP: param[0] = gNtcDev.NTCvalue[1]; break; case ADC_REQ_BITMAP_CH1: param[0] = AdcGetResFromInres(gNtcDev.NTCvalue[2 + NTC_Channel1]); break; case ADC_REQ_BITMAP_CH2: param[0] = AdcGetResFromInres(gNtcDev.NTCvalue[2 + NTC_Channel2]); break; case ADC_REQ_BITMAP_CH30: param[0] = AdcGetResFromInres(gNtcDev.NTCvalue[2 + NTC_Channel30]); break; case ADC_REQ_BITMAP_CH31: param[0] = AdcGetResFromInres(gNtcDev.NTCvalue[2 + NTC_Channel31]); break; case ADC_REQ_BITMAP_CH4: param[0] = gNtcDev.NTCvalue[2 + NTC_Channel4] * 101 + 600; break; case ADC_REQ_BITMAP_VBAT_CALI: param[0] = AdcVbatCali(gNtcDev.NTCvalue[2 + NTC_Channel4_VbatCali]); break; case ADC_REQ_BITMAP_INRES_CALI: param[0] = AdcInresCali(gNtcDev.NTCvalue[2 + NTC_Channel4_InresCali]); break; } osEventFlagsClear(adcTrigerHandle, ADC_RECV_CONTROL_FLAG); return ret; } } /** \fn static void ADC_VbatChannelCallback(uint32_t result) \param[in] \brief return bat value ,trigger deinit \return */ static void ADC_VbatChannelCallback(uint32_t result) { vbatChannelResult = result; osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_VBAT); } /** \fn static void ADC_ThermalChannelCallback(uint32_t result) \param[in] \brief return thermal value ,trigger deinit \return */ static void ADC_ThermalChannelCallback(uint32_t result) { thermalChannelResult = result; osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_TEMP); } static void ADC_NTC1ChannelCallback(uint32_t result) { NTCChannelResult[NTC_Channel1] = result; osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH1); } static void ADC_NTC2ChannelCallback(uint32_t result) { NTCChannelResult[NTC_Channel2] = result; osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH2); } static void ADC_NTC30ChannelCallback(uint32_t result) { NTCChannelResult[NTC_Channel30] = result; osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH30); } static void ADC_NTC31ChannelCallback(uint32_t result) { NTCChannelResult[NTC_Channel31] = result; osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH31); } static void ADC_NTC4ChannelCallback(uint32_t result) { NTCChannelResult[NTC_Channel4] = result; osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_CH4); } static void ADC_NTCVbatCaliChannelCallback(uint32_t result) { NTCChannelResult[NTC_Channel4_VbatCali] = result; osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_VBAT_CALI); } static void ADC_NTCInresCaliChannelCallback(uint32_t result) { NTCChannelResult[NTC_Channel4_InresCali] = result; osEventFlagsSet(adcEvtHandle, ADC_REQ_BITMAP_INRES_CALI); } /** \fn void AdcProcess(void* arg) \param[in] \brief handle adc init ,deinit and convert process \return */ static void AdcProcess(void *arg) { adcReqMsg regMsg; INT32 ret; while (1) { /* */ osMessageQueueGet(adcMsgHandle, ®Msg, 0, osWaitForever); /* handle event */ adc_config_t adcConfig; INT8 times = 1; ADC_GetDefaultConfig(&adcConfig); osEventFlagsClear(adcEvtHandle, regMsg.request); retry: if (regMsg.request & ADC_REQ_BITMAP_VBAT) { adcConfig.channelConfig.vbatResDiv = ADC_VbatResDivRatio3Over16; ADC_ChannelInit(ADC_ChannelVbat, ADC_UserAPP, &adcConfig, ADC_VbatChannelCallback); //delay_us(1000*1000); ADC_StartConversion(ADC_ChannelVbat, ADC_UserAPP); } else if (regMsg.request & ADC_REQ_BITMAP_TEMP) { adcConfig.channelConfig.thermalInput = ADC_ThermalInputVbat; ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_ThermalChannelCallback); //delay_us(1000*1000); ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP); } else if (regMsg.request & ADC_REQ_BITMAP_CH1) { if (regMsg.param[NTC_Channel1] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel1] <= ADC_AioResDivRatio1Over16) { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel1]; } else { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault; } ADC_ChannelInit(ADC_ChannelAio1, ADC_UserAPP, &adcConfig, ADC_NTC1ChannelCallback); //delay_us(1000*1000); ADC_StartConversion(ADC_ChannelAio1, ADC_UserAPP); } else if (regMsg.request & ADC_REQ_BITMAP_CH2) { if (regMsg.param[NTC_Channel2] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel2] <= ADC_AioResDivRatio1Over16) { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel2]; } else { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif } ADC_ChannelInit(ADC_ChannelAio2, ADC_UserAPP, &adcConfig, ADC_NTC2ChannelCallback); //delay_us(1000*1000); ADC_StartConversion(ADC_ChannelAio2, ADC_UserAPP); } else if (regMsg.request & ADC_REQ_BITMAP_CH30) { GPIO_PinWrite(GPIO_AIO3_SEL / 16, 1 << (GPIO_AIO3_SEL % 16), 0); if (regMsg.param[NTC_Channel30] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel30] <= ADC_AioResDivRatio1Over16) { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel30]; } else { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault; } ADC_ChannelInit(ADC_ChannelAio3, ADC_UserAPP, &adcConfig, ADC_NTC30ChannelCallback); //osDelay(2000/portTICK_PERIOD_MS); ADC_StartConversion(ADC_ChannelAio3, ADC_UserAPP); } else if (regMsg.request & ADC_REQ_BITMAP_CH31) { GPIO_PinWrite(GPIO_AIO3_SEL / 16, 1 << (GPIO_AIO3_SEL % 16), 1 << (GPIO_AIO3_SEL % 16)); if (regMsg.param[NTC_Channel31] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel31] <= ADC_AioResDivRatio1Over16) { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel31]; } else { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault; } ADC_ChannelInit(ADC_ChannelAio3, ADC_UserAPP, &adcConfig, ADC_NTC31ChannelCallback); //osDelay(2000/portTICK_PERIOD_MS); ADC_StartConversion(ADC_ChannelAio3, ADC_UserAPP); } else if (regMsg.request & ADC_REQ_BITMAP_CH4) { GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 0); ADC_GetDefaultConfig(&adcConfig); adcConfig.channelConfig.thermalInput = ADC_ThermalInputAio4; ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_NTC4ChannelCallback); osDelay(100 / portTICK_PERIOD_MS); //zhengchao 20210312 ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP); } else if (regMsg.request & ADC_REQ_BITMAP_VBAT_CALI) { GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 1 << (GPIO_AIO4_SEL % 16)); ADC_GetDefaultConfig(&adcConfig); adcConfig.channelConfig.thermalInput = ADC_ThermalInputAio4; ADC_ChannelInit(ADC_ChannelThermal, ADC_UserAPP, &adcConfig, ADC_NTCVbatCaliChannelCallback); //osDelay(2000/portTICK_PERIOD_MS); ADC_StartConversion(ADC_ChannelThermal, ADC_UserAPP); } else if (regMsg.request & ADC_REQ_BITMAP_INRES_CALI) { GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 1 << (GPIO_AIO4_SEL % 16)); if (regMsg.param[NTC_Channel4_InresCali] >= ADC_AioResDivRatio1 && regMsg.param[NTC_Channel4_InresCali] <= ADC_AioResDivRatio1Over16) { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif adcConfig.channelConfig.aioResDiv = regMsg.param[NTC_Channel4_InresCali]; } else { #ifdef USING_PRINTF //printf("%s[%d]\r\n",__FUNCTION__, __LINE__); #endif adcConfig.channelConfig.aioResDiv = ADC_AioResDivRatioDefault; } ADC_ChannelInit(ADC_ChannelAio4, ADC_UserAPP, &adcConfig, ADC_NTCInresCaliChannelCallback); //osDelay(2000/portTICK_PERIOD_MS); ADC_StartConversion(ADC_ChannelAio4, ADC_UserAPP); } ret = osEventFlagsWait(adcEvtHandle, regMsg.request, osFlagsWaitAll, ADC_GET_RESULT_TIMOUT); if (regMsg.request & ADC_REQ_BITMAP_VBAT) { ADC_ChannelDeInit(ADC_ChannelVbat, ADC_UserAPP); gNtcDev.NTCvalue[0] = HAL_ADC_CalibrateRawCode(vbatChannelResult) * 16 / 3; } else if (regMsg.request & ADC_REQ_BITMAP_TEMP) { ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP); gNtcDev.NTCvalue[1] = HAL_ADC_ConvertThermalRawCodeToTemperature(thermalChannelResult); } else if (regMsg.request & ADC_REQ_BITMAP_CH1) { ADC_ChannelDeInit(ADC_ChannelAio1, ADC_UserAPP); if (times == 1) { gNtcDev.NTCvalue[2 + NTC_Channel1] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel1]) * REV_AioResDivRatioDefault; #ifdef USING_PRINTF //printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel1]); #endif if (gNtcDev.NTCvalue[2 + NTC_Channel1] > (NTC_FullAioValue - 10)) { regMsg.param[NTC_Channel1] = ADC_AioResDivRatioExtra; times++; goto retry; } } else { gNtcDev.NTCvalue[2 + NTC_Channel1] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel1]) * REV_AioResDivRatioExtra; } } else if (regMsg.request & ADC_REQ_BITMAP_CH2) { ADC_ChannelDeInit(ADC_ChannelAio2, ADC_UserAPP); if (times == 1) { gNtcDev.NTCvalue[2 + NTC_Channel2] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel2]) * REV_AioResDivRatioDefault; #ifdef USING_PRINTF //printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel2]); #endif if (gNtcDev.NTCvalue[2 + NTC_Channel2] > (NTC_FullAioValue - 10)) { regMsg.param[NTC_Channel2] = ADC_AioResDivRatioExtra; times++; goto retry; } } else { gNtcDev.NTCvalue[2 + NTC_Channel2] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel2]) * REV_AioResDivRatioExtra; } } else if (regMsg.request & ADC_REQ_BITMAP_CH30) { GPIO_PinWrite(GPIO_AIO3_SEL / 16, 1 << (GPIO_AIO3_SEL % 16), 1 << (GPIO_AIO3_SEL % 16)); ADC_ChannelDeInit(ADC_ChannelAio3, ADC_UserAPP); if (times == 1) { gNtcDev.NTCvalue[2 + NTC_Channel30] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel30]) * REV_AioResDivRatioDefault; #ifdef USING_PRINTF //printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel30]); #endif if (gNtcDev.NTCvalue[2 + NTC_Channel30] > (NTC_FullAioValue - 10)) { regMsg.param[NTC_Channel30] = ADC_AioResDivRatioExtra; times++; goto retry; } } else { gNtcDev.NTCvalue[2 + NTC_Channel30] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel30]) * REV_AioResDivRatioExtra; } } else if (regMsg.request & ADC_REQ_BITMAP_CH31) { GPIO_PinWrite(GPIO_AIO3_SEL / 16, 1 << (GPIO_AIO3_SEL % 16), 0); ADC_ChannelDeInit(ADC_ChannelAio3, ADC_UserAPP); if (times == 1) { gNtcDev.NTCvalue[2 + NTC_Channel31] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel31]) * REV_AioResDivRatioDefault; #ifdef USING_PRINTF //printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel31]); #endif if (gNtcDev.NTCvalue[2 + NTC_Channel31] > (NTC_FullAioValue - 10)) { regMsg.param[NTC_Channel31] = ADC_AioResDivRatioExtra; times++; goto retry; } } else { gNtcDev.NTCvalue[2 + NTC_Channel31] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel31]) * REV_AioResDivRatioExtra; } } else if (regMsg.request & ADC_REQ_BITMAP_CH4) { GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 1 << (GPIO_AIO4_SEL % 16)); ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP); gNtcDev.NTCvalue[2 + NTC_Channel4] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4]); } else if (regMsg.request & ADC_REQ_BITMAP_VBAT_CALI) { GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 0); ADC_ChannelDeInit(ADC_ChannelThermal, ADC_UserAPP); if (times == 1) { gNtcDev.NTCvalue[2 + NTC_Channel4_VbatCali] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_VbatCali]); #ifdef USING_PRINTF //printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel4_VbatCali]); #endif if (gNtcDev.NTCvalue[2 + NTC_Channel4_VbatCali] > (NTC_FullAioValue - 10)) { regMsg.param[NTC_Channel4_VbatCali] = ADC_AioResDivRatioExtra; times++; goto retry; } } else { gNtcDev.NTCvalue[2 + NTC_Channel4_VbatCali] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_VbatCali]); } } else if (regMsg.request & ADC_REQ_BITMAP_INRES_CALI) { GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 0); ADC_ChannelDeInit(ADC_ChannelAio4, ADC_UserAPP); if (times == 1) { gNtcDev.NTCvalue[2 + NTC_Channel4_InresCali] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_InresCali]) * REV_AioResDivRatioDefault; #ifdef USING_PRINTF //printf("%s[%d][%d]\r\n",__FUNCTION__, __LINE__,gNtcDev.NTCvalue[2+NTC_Channel4_InresCali]); #endif if (gNtcDev.NTCvalue[2 + NTC_Channel4_InresCali] > (NTC_FullAioValue - 10)) { regMsg.param[NTC_Channel4_InresCali] = ADC_AioResDivRatioExtra; times++; goto retry; } } else { gNtcDev.NTCvalue[2 + NTC_Channel4_InresCali] = HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4_InresCali]) * REV_AioResDivRatioExtra; } } osEventFlagsSet(adcTrigerHandle, ADC_RECV_CONTROL_FLAG); } } /** \fn INT32 AdcTaskInit(void) \param[in] \brief create task for checking bat level \return */ INT32 AdcTaskInit(void) { gpio_pin_config_t config; config.pinDirection = GPIO_DirectionOutput; config.misc.initOutput = 1; pad_config_t padConfig; PAD_GetDefaultConfig(&padConfig); //power padConfig.mux = PAD_MuxAlt0; PAD_SetPinConfig(11, &padConfig); GPIO_PinConfig(0, 0, &config); GPIO_PinWrite(0, 1, 1); padConfig.mux = PAD_MuxAlt7; PAD_SetPinConfig(9, &padConfig); PAD_SetPinConfig(10, &padConfig); GPIO_PinConfig(GPIO_AIO3_SEL / 16, GPIO_AIO3_SEL % 16, &config); GPIO_PinConfig(GPIO_AIO4_SEL / 16, GPIO_AIO4_SEL % 16, &config); GPIO_PinWrite(GPIO_AIO3_SEL / 16, 1 << (GPIO_AIO3_SEL % 16), 0); GPIO_PinWrite(GPIO_AIO4_SEL / 16, 1 << (GPIO_AIO4_SEL % 16), 0); memset(&gNtcDev, 0, sizeof(NtcResult_t)); if (adcMsgHandle == NULL) { adcMsgHandle = osMessageQueueNew(ADC_MSG_MAX_NUM, sizeof(adcReqMsg), NULL); if (adcMsgHandle == NULL) return 1; } if (adcTrigerHandle == NULL) { adcTrigerHandle = osEventFlagsNew(NULL); if (adcTrigerHandle == NULL) return 1; } if (adcEvtHandle == NULL) { adcEvtHandle = osEventFlagsNew(NULL); if (adcEvtHandle == NULL) return 1; } if (adcTaskHandle == NULL) { osThreadAttr_t task_attr; memset(&task_attr, 0, sizeof(task_attr)); task_attr.name = "batAdc"; task_attr.priority = osPriorityNormal; task_attr.cb_mem = &adcTask; task_attr.cb_size = sizeof(StaticTask_t); task_attr.stack_mem = adcTaskStack; task_attr.stack_size = ADC_TASK_STACK_SIZE; memset(&adcTaskStack, 0xa5, ADC_TASK_STACK_SIZE); adcTaskHandle = osThreadNew(AdcProcess, NULL, &task_attr); if (adcTaskHandle == NULL) return 1; } return 0; } /** \fn void PowerPinConfig(IOType iotype) \param[in] \brief config PWR pin to gpiol \return */ void PowerPinConfig(IOType iotype) { gpio_pin_config_t config; config.pinDirection = GPIO_DirectionOutput; config.misc.initOutput = 1; pad_config_t padConfig; PAD_GetDefaultConfig(&padConfig); if (iotype == AON_IO) { slpManAONIOVoltSet(IOVOLT_3_30V); //zhengchao 20200412 add padConfig.mux = PAD_MuxAlt0; PAD_SetPinConfig(35, &padConfig); GPIO_PinConfig(1, AON_GPS_POWER1, &config); GPIO_PinWrite(1, 1 << AON_GPS_POWER1, 0); PAD_SetPinConfig(31, &padConfig); GPIO_PinConfig(1, AON_GPS_POWER2, &config); GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 1 << AON_GPS_POWER2); PAD_SetPinConfig(32, &padConfig); GPIO_PinConfig(1, AON_RELAY_DRV, &config); GPIO_PinWrite(1, 1 << AON_RELAY_DRV, 0 << AON_RELAY_DRV); //zhengchao 20200412 modify 1-->0 PAD_SetPinConfig(35, &padConfig); GPIO_PinConfig(1, AON_WAKEUP, &config); GPIO_PinWrite(1, 1 << AON_WAKEUP, 1 << AON_WAKEUP); padConfig.mux = PAD_MuxAlt7; PAD_SetPinConfig(5, &padConfig); GPIO_PinConfig(1, FEM_GPS_RSTN, &config); GPIO_PinWrite(1, 1 << FEM_GPS_RSTN, 1 << FEM_GPS_RSTN); #if 1 padConfig.mux = PAD_MuxAlt7; padConfig.pullSelect = PAD_PullInternal; padConfig.pullUpEnable = PAD_PullUpEnable; padConfig.pullDownEnable = PAD_PullDownDisable; PAD_SetPinConfig(8, &padConfig); config.pinDirection = GPIO_DirectionInput; config.misc.initOutput = 0; GPIO_PinConfig(1, FEM_GPS_PPS, &config); #else padConfig.mux = PAD_MuxAlt7; PAD_SetPinConfig(8, &padConfig); GPIO_PinWrite(1, 1 << FEM_GPS_PPS, 1 << FEM_GPS_PPS); #endif } else { /*Normal IO*/ #if 0 GPIO_PinConfig(0, GPIO_MOS_DRV1, &config); GPIO_PinWrite(0, 1 << GPIO_MOS_DRV1, 1 << GPIO_MOS_DRV1); GPIO_PinConfig(0, GPIO_MOS_DRV2, &config); GPIO_PinWrite(0, 1 << GPIO_MOS_DRV2, 1 << GPIO_MOS_DRV2); #endif padConfig.mux = PAD_MuxAlt0; PAD_SetPinConfig(28, &padConfig); GPIO_PinConfig(0, GPIO_POWER_LED, &config); GPIO_PinWrite(0, 1 << GPIO_POWER_LED, 1 << GPIO_POWER_LED); } } /** \fn void relayConfigInit(void) \param[in] \brief init the relay, while switch on default \return */ void relayConfigInit() { gpio_pin_config_t config; config.pinDirection = GPIO_DirectionOutput; config.misc.initOutput = 1; pad_config_t padConfig; PAD_GetDefaultConfig(&padConfig); PAD_SetPinConfig(32, &padConfig); GPIO_PinConfig(1, AON_RELAY_DRV, &config); GPIO_PinWrite(1, 1 << AON_RELAY_DRV, 0 << AON_RELAY_DRV); //the relay default is off(disconnected) //printf("switch off\n"); } /** \fn void relayControl(BOOL onOrOff) \param[in] onOrOff \brief switch the relay on or off \return */ void relayControl(BOOL onOrOff) { if (onOrOff == TRUE) { GPIO_PinWrite(1, 1 << AON_RELAY_DRV, 1 << AON_RELAY_DRV); //switch on printf("switcht on\n"); } else { GPIO_PinWrite(1, 1 << AON_RELAY_DRV, 0 << AON_RELAY_DRV); //switch off printf("switch off\n"); } } /** \fn void posGGAReset(void) \param[in] \brief reset gps \return */ void posGGAReset(void) { gpio_pin_config_t config; config.pinDirection = GPIO_DirectionOutput; config.misc.initOutput = 1; pad_config_t padConfig; PAD_GetDefaultConfig(&padConfig); padConfig.mux = PAD_MuxAlt7; PAD_SetPinConfig(5, &padConfig); GPIO_PinConfig(1, FEM_GPS_RSTN, &config); GPIO_PinWrite(1, 1 << FEM_GPS_RSTN, 0); osDelay(1000 / portTICK_PERIOD_MS); GPIO_PinConfig(1, FEM_GPS_RSTN, &config); GPIO_PinWrite(1, 1 << FEM_GPS_RSTN, 1 << FEM_GPS_RSTN); config.pinDirection = GPIO_DirectionInput; config.misc.initOutput = 0; GPIO_PinConfig(1, FEM_GPS_RSTN, &config); } /** \fn void GPSPowerCtr(bool ) \param[in] \brief reset gps \return */ void GPSPowerCtr(bool on) { gpio_pin_config_t config; config.pinDirection = GPIO_DirectionOutput; config.misc.initOutput = 1; pad_config_t padConfig; PAD_GetDefaultConfig(&padConfig); padConfig.mux = PAD_MuxAlt0; PAD_SetPinConfig(35, &padConfig); GPIO_PinConfig(1, AON_GPS_POWER1, &config); PAD_SetPinConfig(31, &padConfig); GPIO_PinConfig(1, AON_GPS_POWER2, &config); if (on) { GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 0); GPIO_PinWrite(1, 1 << AON_GPS_POWER1, 1 << AON_GPS_POWER1); } else { GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 1 << AON_GPS_POWER2); GPIO_PinWrite(1, 1 << AON_GPS_POWER1, 0); } } /** \fn void posGGAServiceStart(QueueHandle_t handle) \param[in] \brief powr on gps \return */ INT32 posGGAServiceStart(QueueHandle_t handle) { if (handle == NULL) { return -1; } else { GPSPowerCtr(true); gpsHandle = handle; return 0; } } /** \fn void posGGAServiceStop(void ) \param[in] \brief stop gps \return */ void posGGAServiceStop(void) { GPSPowerCtr(false); gpsHandle = NULL; } BOOL NB_ADC_Get(UINT32 *adcValue, ADC_CHANNEL_TYPE adcChannel) { //UINT32 NTCR2,NTCR3,NTCR4,NTCR5,Vbat = 0; //*adcValue = 0xFFFFFFFF; INT32 ret = 1; switch (adcChannel) { case FAST_CHARGE_TEMP: //P2-7 ret = AdcSendReq(ADC_REQ_BITMAP_CH1, adcValue, 01, ADC_GET_RESULT_TIMOUT); break; case NORMAL_CHARGE_TEMP: //P2-9 ret = AdcSendReq(ADC_REQ_BITMAP_CH2, adcValue, 01, ADC_GET_RESULT_TIMOUT); break; case OTHER_TEMP_1: //P2-11 ret = AdcSendReq(ADC_REQ_BITMAP_CH31, adcValue, 01, ADC_GET_RESULT_TIMOUT); break; case OTHER_TEMP_2: //P2-13 ret = AdcSendReq(ADC_REQ_BITMAP_CH30, adcValue, 01, ADC_GET_RESULT_TIMOUT); break; case VBAT: //Vbat ret = AdcSendReq(ADC_REQ_BITMAP_CH4, adcValue, 01, ADC_GET_RESULT_TIMOUT); break; default: break; } if (ret == 0) return TRUE; else return FALSE; }