#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]; /* 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; } #include #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>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;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; 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>3));//����?��?o3??��0������?������?��????? CAN_WriteReg(TXB1SIDL,0xE0&((Can_TxMsg.Id)<<5));//����?��?o3??��0������?������?��?�̨�?? for(i=0;i>3));//����?��?o3??��0������?������?��????? CAN_WriteReg(TXB2SIDL,0xE0&((Can_TxMsg.Id)<<5));//����?��?o3??��0������?������?��?�̨�?? for(i=0;i>5)<<2 | SIdL&0x3 )<<16 | (EId8<<8) | EId0); } else { (CanRxMsgBuffer[0]).Id = SIdH<<3 | SIdL>>5; } j = 0; while(j>5)<<2 | SIdL&0x3 )<<16 | (EId8<<8) | EId0); } else { (CanRxMsgBuffer[1]).Id = SIdH<<3 | SIdL>>5; } j = 0 ; while(j>5)<<2 | SIdL&0x3 )<<16 | (EId8<<8) | EId0); } else { (CanRxMsgBuffer[0]).Id = SIdH<<3 | SIdL>>5; } j = 0; while(j>5)<<2 | SIdL&0x3 )<<16 | (EId8<<8) | EId0); } else { (CanRxMsgBuffer[1]).Id = SIdH<<3 | SIdL>>5; } j = 0 ; while(jInitialize(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 (64) 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 PrintfDataRecvCallback(UINT32 event, void* dataPtr, UINT32 dataLen) { //ECOMM_TRACE(UNILOG_PLA_APP, PrintfDataRecvCallback, P_SIG, 3, "event=%d, dataPtr=%s, dataLen=%d",event,dataPtr,dataLen); 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 = PrintfDataRecvCallback; 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, 2000); } } } 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<R_Table2[0]) { if(R_value<=R_Table1[22])//判断是否超出表尾 { return Temp_Table1[22]; } else if(R_value>=R_Table1[0])//判断是否超出表头 { return Temp_Table1[0]; } else { for(int i=0;i<23-1;i++) { if ((R_value<=R_Table1[i])&&(R_value>R_Table1[i+1]))//中间判断 { return Temp_Table1[i]; } else { continue; } } } }//R-1 else { if(R_value<=R_Table2[216])//判断是否超出表尾 { return Temp_Table2[216]; } else if(R_value>=R_Table2[0])//判断是否超出表头 { return Temp_Table2[0]; } else { for(int i=0;i<217-1;i++) { if ((R_value=R_Table2[i+1]))//中间判断 { return Temp_Table2[i+1]; } else { continue; } } } }//R-2 } UINT16 GetErrorNum(UINT16 *ErrorArray,UINT8 Errorlen) { UINT16 OutNum; OutNum = *(ErrorArray); for(int i=0;i