#include #include "bsp.h" #include "Debug.h" #include "hc32f460_efm.h" #include "CS1237_LEFTUP.h" #include "CS1237_LEFTLOW.h" #include "CS1237_RIGHTUP.h" #include "CS1237_RIGHTLOW.h" #include "dc_motor.h" #define SPI_MASTER_MODE #define SPI3_MASTER_MODE #define FLASH_WRITE_ADDR (0x0003C000u) static void SystemClockConfig(void); uint16_t m_au16Adc1SaValue[ADC_CH_NUM * ADC_COLL]; void FlashWrite(uint32_t *wData, uint32_t wLen) { EFM_Unlock(); /* Enable flash. */ EFM_FlashCmd(Enable); /* Wait flash ready. */ while(Set != EFM_GetFlagStatus(EFM_FLAG_RDY)) { ; } /* Erase sector. */ EFM_SectorErase(FLASH_WRITE_ADDR); /* Sequence program. */ //EFM_SequenceProgram(FLASH_WRITE_ADDR, wLen, wData); for(int i = 0; i < wLen; i++) { EFM_SingleProgram(FLASH_WRITE_ADDR + i * 4, wData[i]); } /* Lock EFM. */ EFM_Lock(); } void FlashRead(uint32_t *rData, uint32_t wLen) { for(int i = 0; i < wLen; i++) rData[i] = *(uint32_t *)(FLASH_WRITE_ADDR + i * 4); } /** ******************************************************************************* ** \brief Configuring a new system clock. ** System clock frequency: 200MHz. ** System clock source: MPLL. ** MPLL clock source: XTAL(8MHz). ** ******************************************************************************/ static void SystemClockConfig(void) { stc_clk_sysclk_cfg_t stcSysClkCfg; stc_clk_xtal_cfg_t stcXtalCfg; stc_clk_mpll_cfg_t stcMpllCfg; stc_sram_config_t stcSramConfig; MEM_ZERO_STRUCT(stcSysClkCfg); MEM_ZERO_STRUCT(stcXtalCfg); MEM_ZERO_STRUCT(stcMpllCfg); MEM_ZERO_STRUCT(stcSramConfig); /* Set bus clk div. */ stcSysClkCfg.enHclkDiv = ClkSysclkDiv1; stcSysClkCfg.enExclkDiv = ClkSysclkDiv2; stcSysClkCfg.enPclk0Div = ClkSysclkDiv1; stcSysClkCfg.enPclk1Div = ClkSysclkDiv2; stcSysClkCfg.enPclk2Div = ClkSysclkDiv4; stcSysClkCfg.enPclk3Div = ClkSysclkDiv4; stcSysClkCfg.enPclk4Div = ClkSysclkDiv2; CLK_SysClkConfig(&stcSysClkCfg); /* Config Xtal and Enable Xtal */ stcXtalCfg.enMode = ClkXtalModeOsc; stcXtalCfg.enDrv = ClkXtalLowDrv; stcXtalCfg.enFastStartup = Disable; CLK_XtalConfig(&stcXtalCfg); CLK_XtalCmd(Disable); /* Config Hrc and enable HRC */ CLK_HrcTrim(SystemCoreClock); CLK_HrcCmd(Enable); /* sram init include read/write wait cycle setting */ stcSramConfig.u8SramIdx = Sram12Idx | Sram3Idx | SramHsIdx | SramRetIdx; stcSramConfig.enSramRC = SramCycle2; stcSramConfig.enSramWC = SramCycle2; SRAM_Init(&stcSramConfig); /* flash read wait cycle setting */ EFM_Unlock(); EFM_SetLatency(EFM_LATENCY_5); EFM_Lock(); /* MPLL config (HRC / pllmDiv * plln / PllpDiv = 200M). */ stcMpllCfg.pllmDiv = 1ul; stcMpllCfg.plln = 25ul; stcMpllCfg.PllpDiv = 2ul; stcMpllCfg.PllqDiv = 2ul; stcMpllCfg.PllrDiv = 2ul; CLK_SetPllSource(ClkPllSrcHRC); CLK_MpllConfig(&stcMpllCfg); /* Enable MPLL. */ CLK_MpllCmd(Enable); /* Wait MPLL ready. */ while(Set != CLK_GetFlagStatus(ClkFlagMPLLRdy)) { ; } /* Switch driver ability */ PWC_HS2HP(); /* Switch system clock source to MPLL. */ CLK_SetSysClkSource(CLKSysSrcMPLL); } void FeedDog(void) { #if (USE_WDT == 1) SWDT_RefreshCounter(); #endif } /***************************************************************************************** * 函数名称: Xtal32_ClockConfig * 功能描述: 外部低速时钟配置 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ static void Xtal32_ClockConfig(void) { stc_clk_xtal32_cfg_t stcXtal32Cfg; /* configure structure initialization */ MEM_ZERO_STRUCT(stcXtal32Cfg); /* Stop xtal32 */ CLK_Xtal32Cmd(Disable); Ddl_Delay1ms(100u); /* Configuration xtal32 structure */ stcXtal32Cfg.enDrv = ClkXtal32HighDrv; stcXtal32Cfg.enFilterMode = ClkXtal32FilterModeFull; CLK_Xtal32Config(&stcXtal32Cfg); /* Startup xtal32 */ CLK_Xtal32Cmd(Enable); /* wait for xtal32 running */ Ddl_Delay1ms(100u); } void delay_5ns(uint32_t ns) { for(uint32_t i = 0; i < ns; i++) { __NOP(); } } #if(USE_RS485 == 1) /***************************************************************************************** * 函数名称: RS485Uart_Config * 功能描述: RS485串口初始化 * 参 数: BaudRate 波特率 * 返 回 值: 无 *****************************************************************************************/ static void RS485Uart_Config(uint32_t BaudRate) { stc_usart_uart_init_t stcInitCfg; stc_irq_regi_conf_t stcIrqRegiCfg; en_result_t enRet; stc_port_init_t stcPortInit; MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enPinOType = Pin_OType_Cmos; PORT_Init(RS485_USART_RX_PORT, RS485_USART_RX_PIN, &stcPortInit); PORT_Init(RS485_USART_TX_PORT, RS485_USART_TX_PIN, &stcPortInit); stcInitCfg.enClkMode = UsartIntClkCkNoOutput; stcInitCfg.enClkDiv = UsartClkDiv_16; stcInitCfg.enDataLength = UsartDataBits8; stcInitCfg.enDirection = UsartDataLsbFirst; stcInitCfg.enStopBit = UsartOneStopBit; stcInitCfg.enParity = UsartParityNone; stcInitCfg.enSampleMode = UsartSampleBit8; stcInitCfg.enDetectMode = UsartStartBitFallEdge; stcInitCfg.enHwFlow = UsartRtsEnable; PWC_Fcg1PeriphClockCmd(RS485_FCG1_PERIPH, Enable); PORT_SetFunc(RS485_USART_RX_PORT, RS485_USART_RX_PIN, RS485_USART_RX_FUNC, Disable); PORT_SetFunc(RS485_USART_TX_PORT, RS485_USART_TX_PIN, RS485_USART_TX_FUNC, Disable); enRet = USART_UART_Init(RS485_USART_CH, &stcInitCfg); if(enRet != Ok) { Error_Handler(); } enRet = USART_SetBaudrate(RS485_USART_CH, BaudRate); if(enRet != Ok) { Error_Handler(); } stcIrqRegiCfg.enIRQn = RS485UART_IRQn; stcIrqRegiCfg.pfnCallback = &RS485UsartRxIrqCallback; stcIrqRegiCfg.enIntSrc = RS485_USART_RI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); /* Set USART RX error IRQ */ stcIrqRegiCfg.enIRQn = RS485UART_EI_IRQn; stcIrqRegiCfg.pfnCallback = &RS485UsartErrIrqCallback; stcIrqRegiCfg.enIntSrc = RS485_USART_EI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); #if 0 /* Set USART TX IRQ */ stcIrqRegiCfg.enIRQn = Int002_IRQn; stcIrqRegiCfg.pfnCallback = &UsartTxIrqCallback; stcIrqRegiCfg.enIntSrc = USART_TI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); /* Set USART TX complete IRQ */ stcIrqRegiCfg.enIRQn = Int003_IRQn; stcIrqRegiCfg.pfnCallback = &UsartTxCmpltIrqCallback; stcIrqRegiCfg.enIntSrc = USART_TCI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); #endif USART_FuncCmd(RS485_USART_CH, UsartTx, Enable); USART_FuncCmd(RS485_USART_CH, UsartRx, Enable); USART_FuncCmd(RS485_USART_CH, UsartRxInt, Enable); } void RS485UartSend(uint8_t *sData, uint16_t sLen) { RS485_TX(); for(int i = 0; i < sLen; i++) { USART_SendData(RS485_USART_CH, sData[i]); while(USART_GetStatus(RS485_USART_CH, UsartTxComplete) == Reset); } RS485_RX(); } uint8_t RS485UartRec(void) { uint16_t u16Data = USART_RecData(RS485_USART_CH); return (uint8_t)u16Data; } void RS485UsartRxIrqCallback(void) { } static void RS485RxWakeupInit(void) { stc_port_init_t stcPortInit; stc_port_pub_set_t stcPortPub; stc_exint_config_t stcExtiConfig; stc_irq_regi_conf_t stcIrqRegiConf; MEM_ZERO_STRUCT(stcPortInit); MEM_ZERO_STRUCT(stcPortPub); stcPortPub.enReadWait = WaitCycle3; PORT_PubSetting(&stcPortPub); stcPortInit.enPinMode = Pin_Mode_In; stcPortInit.enPullUp = Enable; stcPortInit.enExInt =Enable; PORT_Init(RS485_USART_RX_PORT, RS485_USART_RX_PIN, &stcPortInit); stcExtiConfig.enExitCh = RS485_RXPIN_EXIT_CH; stcExtiConfig.enFilterEn = Enable; stcExtiConfig.enFltClk = Pclk3Div8; stcExtiConfig.enExtiLvl = ExIntRisingEdge; EXINT_Init(&stcExtiConfig); stcIrqRegiConf.enIntSrc = RS485_RXPIN_EXIT_SRC; /* Select External Int Ch.1 */ stcIrqRegiConf.enIRQn = RS485_RXPIN_IRQn; /* Register External Int to Vect.No.000 */ stcIrqRegiConf.pfnCallback = &RS485_RxPinIntCallBack; /* Callback function */ enIrqRegistration(&stcIrqRegiConf); /* Registration IRQ */ NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn); /* Clear pending */ NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); /* Set priority */ NVIC_EnableIRQ(stcIrqRegiConf.enIRQn); /* Enable NVIC */ enIntWakeupEnable(Extint2WU); } #endif #if(USE_DEBUG == 1) static void DbgUart_Config(uint32_t BaudRate) { stc_usart_uart_init_t stcInitCfg; stc_irq_regi_conf_t stcIrqRegiCfg; en_result_t enRet; stc_port_init_t stcPortInit; MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enPinOType = Pin_OType_Cmos; PORT_Init(DBG_USART_RX_PORT, DBG_USART_RX_PIN, &stcPortInit); PORT_Init(DBG_USART_TX_PORT, DBG_USART_TX_PIN, &stcPortInit); stcInitCfg.enClkMode = UsartIntClkCkNoOutput; stcInitCfg.enClkDiv = UsartClkDiv_16; stcInitCfg.enDataLength = UsartDataBits8; stcInitCfg.enDirection = UsartDataLsbFirst; stcInitCfg.enStopBit = UsartOneStopBit; stcInitCfg.enParity = UsartParityNone; stcInitCfg.enSampleMode = UsartSampleBit8; stcInitCfg.enDetectMode = UsartStartBitFallEdge; stcInitCfg.enHwFlow = UsartRtsEnable; PWC_Fcg1PeriphClockCmd(DBG_FCG1_PERIPH, Enable); PORT_SetFunc(DBG_USART_RX_PORT, DBG_USART_RX_PIN, DBG_USART_RX_FUNC, Disable); PORT_SetFunc(DBG_USART_TX_PORT, DBG_USART_TX_PIN, DBG_USART_TX_FUNC, Disable); enRet = USART_UART_Init(DBG_USART_CH, &stcInitCfg); if(enRet != Ok) { Error_Handler(); } enRet = USART_SetBaudrate(DBG_USART_CH, BaudRate); if(enRet != Ok) { Error_Handler(); } stcIrqRegiCfg.enIRQn = DBG_RX_IRQn; stcIrqRegiCfg.pfnCallback = &DbgUsartRxIrqCallback; stcIrqRegiCfg.enIntSrc = DBG_USART_RI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); /* Set USART RX error IRQ */ stcIrqRegiCfg.enIRQn = DBG_ER_IRQn; stcIrqRegiCfg.pfnCallback = &DBGUsartErrIrqCallback; stcIrqRegiCfg.enIntSrc = DBG_USART_EI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); #if 0 /* Set USART TX IRQ */ stcIrqRegiCfg.enIRQn = Int002_IRQn; stcIrqRegiCfg.pfnCallback = &UsartTxIrqCallback; stcIrqRegiCfg.enIntSrc = USART_TI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); /* Set USART TX complete IRQ */ stcIrqRegiCfg.enIRQn = Int003_IRQn; stcIrqRegiCfg.pfnCallback = &UsartTxCmpltIrqCallback; stcIrqRegiCfg.enIntSrc = USART_TCI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); #endif USART_FuncCmd(DBG_USART_CH, UsartTx, Enable); USART_FuncCmd(DBG_USART_CH, UsartRx, Enable); USART_FuncCmd(DBG_USART_CH, UsartRxInt, Enable); } void DebugUartSend(uint8_t *sData, uint16_t sLen) { for(int i = 0; i < sLen; i++) { USART_SendData(DBG_USART_CH, sData[i]); while(USART_GetStatus(DBG_USART_CH, UsartTxComplete) == Reset); } } uint8_t DbgUartRec(void) { uint16_t u16Data = USART_RecData(DBG_USART_CH); return (uint8_t)u16Data; } static void DBGRxWakeupInit(void) { stc_port_init_t stcPortInit; stc_port_pub_set_t stcPortPub; stc_exint_config_t stcExtiConfig; stc_irq_regi_conf_t stcIrqRegiConf; MEM_ZERO_STRUCT(stcPortInit); MEM_ZERO_STRUCT(stcPortPub); stcPortPub.enReadWait = WaitCycle3; PORT_PubSetting(&stcPortPub); stcPortInit.enPinMode = Pin_Mode_In; stcPortInit.enPullUp = Enable; stcPortInit.enExInt =Enable; PORT_Init(DBG_USART_RX_PORT, DBG_USART_RX_PIN, &stcPortInit); stcExtiConfig.enExitCh = DBG_RXPIN_EXIT_CH; stcExtiConfig.enFilterEn = Enable; stcExtiConfig.enFltClk = Pclk3Div8; stcExtiConfig.enExtiLvl = ExIntRisingEdge; EXINT_Init(&stcExtiConfig); stcIrqRegiConf.enIntSrc = DBG_RXPIN_EXIT_SRC; /* Select External Int Ch.1 */ stcIrqRegiConf.enIRQn = DBG_RX_IRQn; /* Register External Int to Vect.No.000 */ stcIrqRegiConf.pfnCallback = &DBG_RxPinIntCallBack; /* Callback function */ enIrqRegistration(&stcIrqRegiConf); /* Registration IRQ */ NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn); /* Clear pending */ NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); /* Set priority */ NVIC_EnableIRQ(stcIrqRegiConf.enIRQn); /* Enable NVIC */ enIntWakeupEnable(Extint2WU); } #endif #if(USE_USART3 == 1) static void Uart3_Config(uint32_t BaudRate) { stc_usart_uart_init_t stcInitCfg; stc_irq_regi_conf_t stcIrqRegiCfg; en_result_t enRet; stc_port_init_t stcPortInit; MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enPinOType = Pin_OType_Cmos; PORT_Init(USART3_RX_PORT, USART3_RX_PIN, &stcPortInit); stcInitCfg.enClkMode = UsartIntClkCkNoOutput; stcInitCfg.enClkDiv = UsartClkDiv_16; stcInitCfg.enDataLength = UsartDataBits8; stcInitCfg.enDirection = UsartDataLsbFirst; stcInitCfg.enStopBit = UsartOneStopBit; stcInitCfg.enParity = UsartParityNone; stcInitCfg.enSampleMode = UsartSampleBit8; stcInitCfg.enDetectMode = UsartStartBitFallEdge; stcInitCfg.enHwFlow = UsartRtsEnable; PWC_Fcg1PeriphClockCmd(USART3_FCG1_PERIPH, Enable); PORT_SetFunc(USART3_RX_PORT, USART3_RX_PIN, USART3_RX_FUNC, Disable); enRet = USART_UART_Init(USART3_CH, &stcInitCfg); if(enRet != Ok) { Error_Handler(); } enRet = USART_SetBaudrate(USART3_CH, BaudRate); if(enRet != Ok) { Error_Handler(); } stcIrqRegiCfg.enIRQn = USART3_RX_IRQn; stcIrqRegiCfg.pfnCallback = &Usart3RxIrqCallback; stcIrqRegiCfg.enIntSrc = USART3_USART_RI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); /* Set USART RX error IRQ */ stcIrqRegiCfg.enIRQn = USART3_ER_IRQn; stcIrqRegiCfg.pfnCallback = &Usart3ErrIrqCallback; stcIrqRegiCfg.enIntSrc = USART3_USART_EI_NUM; enIrqRegistration(&stcIrqRegiCfg); NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn); NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn); USART_FuncCmd(USART3_CH, UsartRx, Enable); USART_FuncCmd(USART3_CH, UsartRxInt, Enable); } void Uart3Send(uint8_t *sData, uint16_t sLen) { for(int i = 0; i < sLen; i++) { USART_SendData(USART3_CH, sData[i]); while(USART_GetStatus(USART3_CH, UsartTxComplete) == Reset); } } uint8_t Uart3Rec(void) { uint16_t u16Data = USART_RecData(USART3_CH); return (uint8_t)u16Data; } #endif static void GPIO_Config(void) { stc_port_init_t stcPortInit; MEM_ZERO_STRUCT(stcPortInit); /********************************** GPIO输出 ****************************************/ stcPortInit.enPinMode = Pin_Mode_Out; stcPortInit.enPinOType = Pin_OType_Cmos; stcPortInit.enPinDrv = Pin_Drv_H; stcPortInit.enPullUp = Disable;//无上拉 PORT_Init(LEFTUP_CS1237_SCLK_PORTx, LEFTUP_CS1237_SCLK_PINx, &stcPortInit); PORT_Init(LEFTLOW_CS1237_SCLK_PORTx, LEFTLOW_CS1237_SCLK_PINx, &stcPortInit); PORT_Init(RIGHTUP_CS1237_SCLK_PORTx, RIGHTUP_CS1237_SCLK_PINx, &stcPortInit); PORT_Init(RIGHTLOW_CS1237_SCLK_PORTx, RIGHTLOW_CS1237_SCLK_PINx, &stcPortInit); stcPortInit.enPullUp = Enable;//上拉 PORT_Init(TWIN_BIT0_PORTx, TWIN_BIT0_PINx, &stcPortInit); PORT_Init(TWIN_BIT1_PORTx, TWIN_BIT1_PINx, &stcPortInit); SET_TWIN_BIT0(); SET_TWIN_BIT1(); } /*********************************左上传感器 ******************************************************************************* ** \brief ExtInt00 callback function ** ** \param None ** ** \retval None ** ******************************************************************************/ void ExtInt10_Callback(void) { if (Set == EXINT_IrqFlgGet(ExtiCh10)) { LEFTUP_CS1237_IrqCallBack(); EXINT_IrqFlgClr(ExtiCh10); } } void ExtiCh10_Init(void) { stc_exint_config_t stcExtiConfig; stc_irq_regi_conf_t stcIrqRegiConf; stc_port_init_t stcPortInit; /* configuration structure initialization */ MEM_ZERO_STRUCT(stcExtiConfig); MEM_ZERO_STRUCT(stcIrqRegiConf); MEM_ZERO_STRUCT(stcPortInit); /**************************************************************************/ /* External Int Ch.10 */ /**************************************************************************/ stcExtiConfig.enExitCh = ExtiCh10; /* Filter setting */ stcExtiConfig.enFilterEn = Enable; stcExtiConfig.enFltClk = Pclk3Div8; stcExtiConfig.enExtiLvl = ExIntFallingEdge; EXINT_Init(&stcExtiConfig); /* Set External Int */ MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enExInt = Enable; PORT_Init(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx, &stcPortInit); /* Select External Int Ch.10 */ stcIrqRegiConf.enIntSrc = INT_PORT_EIRQ10; /* Register External Int to Vect.No.004 */ stcIrqRegiConf.enIRQn = LEFTUP_CS1237_IRQn; /* Callback function */ stcIrqRegiConf.pfnCallback = &ExtInt10_Callback; /* Registration IRQ */ enIrqRegistration(&stcIrqRegiConf); /* Clear pending */ NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn); /* Set priority */ NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); } void ExtInt10IntEnable(void) { /* Enable NVIC */ NVIC_EnableIRQ(LEFTUP_CS1237_IRQn); } void ExtInt10IntDisable(void) { /* Disable NVIC */ NVIC_DisableIRQ(LEFTUP_CS1237_IRQn); } /*******************************左下传感器 ******************************************************************************* ** \brief ExtInt01 callback function ** ** \param None ** ** \retval None ** ******************************************************************************/ void ExtInt01_Callback(void) { if (Set == EXINT_IrqFlgGet(ExtiCh01)) { LEFTLOW_CS1237_IrqCallBack(); EXINT_IrqFlgClr(ExtiCh01); } } void ExtiCh01_Init(void) { stc_exint_config_t stcExtiConfig; stc_irq_regi_conf_t stcIrqRegiConf; stc_port_init_t stcPortInit; /* configuration structure initialization */ MEM_ZERO_STRUCT(stcExtiConfig); MEM_ZERO_STRUCT(stcIrqRegiConf); MEM_ZERO_STRUCT(stcPortInit); /**************************************************************************/ /* External Int Ch.1 */ /**************************************************************************/ stcExtiConfig.enExitCh = ExtiCh01; /* Filter setting */ stcExtiConfig.enFilterEn = Enable; stcExtiConfig.enFltClk = Pclk3Div8; stcExtiConfig.enExtiLvl = ExIntFallingEdge; EXINT_Init(&stcExtiConfig); /* Set External Int */ MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enExInt = Enable; PORT_Init(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx, &stcPortInit); /* Select External Int Ch.1 */ stcIrqRegiConf.enIntSrc = INT_PORT_EIRQ1; /* Register External Int to Vect.No.005 */ stcIrqRegiConf.enIRQn = LEFTLOW_CS1237_IRQn; /* Callback function */ stcIrqRegiConf.pfnCallback = &ExtInt01_Callback; /* Registration IRQ */ enIrqRegistration(&stcIrqRegiConf); /* Clear pending */ NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn); /* Set priority */ NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); } void ExtInt01IntEnable(void) { /* Enable NVIC */ NVIC_EnableIRQ(LEFTLOW_CS1237_IRQn); } void ExtInt01IntDisable(void) { /* Disable NVIC */ NVIC_DisableIRQ(LEFTLOW_CS1237_IRQn); } /*******************************右上传感器 ******************************************************************************* ** \brief ExtInt04 callback function ** ** \param None ** ** \retval None ** ******************************************************************************/ void ExtInt04_Callback(void) { if (Set == EXINT_IrqFlgGet(ExtiCh04)) { RIGHTUP_CS1237_IrqCallBack(); EXINT_IrqFlgClr(ExtiCh04); } } void ExtiCh04_Init(void) { stc_exint_config_t stcExtiConfig; stc_irq_regi_conf_t stcIrqRegiConf; stc_port_init_t stcPortInit; /* configuration structure initialization */ MEM_ZERO_STRUCT(stcExtiConfig); MEM_ZERO_STRUCT(stcIrqRegiConf); MEM_ZERO_STRUCT(stcPortInit); /**************************************************************************/ /* External Int Ch.4 */ /**************************************************************************/ stcExtiConfig.enExitCh = ExtiCh04; /* Filter setting */ stcExtiConfig.enFilterEn = Enable; stcExtiConfig.enFltClk = Pclk3Div8; stcExtiConfig.enExtiLvl = ExIntFallingEdge; EXINT_Init(&stcExtiConfig); /* Set External Int */ MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enExInt = Enable; PORT_Init(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx, &stcPortInit); /* Select External Int Ch.4 */ stcIrqRegiConf.enIntSrc = INT_PORT_EIRQ4; /* Register External Int to Vect.No.006 */ stcIrqRegiConf.enIRQn = RIGHTUP_CS1237_IRQn; /* Callback function */ stcIrqRegiConf.pfnCallback = &ExtInt04_Callback; /* Registration IRQ */ enIrqRegistration(&stcIrqRegiConf); /* Clear pending */ NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn); /* Set priority */ NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); } void ExtInt04IntEnable(void) { /* Enable NVIC */ NVIC_EnableIRQ(RIGHTUP_CS1237_IRQn); } void ExtInt04IntDisable(void) { /* Disable NVIC */ NVIC_DisableIRQ(RIGHTUP_CS1237_IRQn); } /*******************************右下传感器 ******************************************************************************* ** \brief ExtInt04 callback function ** ** \param None ** ** \retval None ** ******************************************************************************/ void ExtInt06_Callback(void) { if (Set == EXINT_IrqFlgGet(ExtiCh06)) { RIGHTLOW_CS1237_IrqCallBack(); EXINT_IrqFlgClr(ExtiCh06); } } void ExtiCh06_Init(void) { stc_exint_config_t stcExtiConfig; stc_irq_regi_conf_t stcIrqRegiConf; stc_port_init_t stcPortInit; /* configuration structure initialization */ MEM_ZERO_STRUCT(stcExtiConfig); MEM_ZERO_STRUCT(stcIrqRegiConf); MEM_ZERO_STRUCT(stcPortInit); /**************************************************************************/ /* External Int Ch.6 */ /**************************************************************************/ stcExtiConfig.enExitCh = ExtiCh06; /* Filter setting */ stcExtiConfig.enFilterEn = Enable; stcExtiConfig.enFltClk = Pclk3Div8; stcExtiConfig.enExtiLvl = ExIntFallingEdge; EXINT_Init(&stcExtiConfig); /* Set External Int */ MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enExInt = Enable; PORT_Init(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx, &stcPortInit); /* Select External Int Ch.6 */ stcIrqRegiConf.enIntSrc = INT_PORT_EIRQ6; /* Register External Int to Vect.No.006 */ stcIrqRegiConf.enIRQn = RIGHTLOW_CS1237_IRQn; /* Callback function */ stcIrqRegiConf.pfnCallback = &ExtInt06_Callback; /* Registration IRQ */ enIrqRegistration(&stcIrqRegiConf); /* Clear pending */ NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn); /* Set priority */ NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); } void ExtInt06IntEnable(void) { /* Enable NVIC */ NVIC_EnableIRQ(RIGHTLOW_CS1237_IRQn); } void ExtInt06IntDisable(void) { /* Disable NVIC */ NVIC_DisableIRQ(RIGHTLOW_CS1237_IRQn); } #if(USE_SPI1 == 1) static void Spi_Config(void) { stc_spi_init_t stcSpiInit; stc_port_init_t stcPortInit; MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enPinOType = Pin_OType_Cmos; PORT_Init(SPI_SCK_PORT, SPI_SCK_PIN, &stcPortInit); PORT_Init(SPI_MOSI_PORT, SPI_MOSI_PIN, &stcPortInit); PORT_Init(SPI_MISO_PORT, SPI_MISO_PIN, &stcPortInit); stcPortInit.enPinMode = Pin_Mode_Out; stcPortInit.enPinOType = Pin_OType_Cmos; stcPortInit.enPinDrv = Pin_Drv_H; stcPortInit.enPullUp = Disable; PORT_Init(SPI_NSS_PORT, SPI_NSS_PIN, &stcPortInit); SPI_NSS_SET(); /* configuration structure initialization */ MEM_ZERO_STRUCT(stcSpiInit); /* Configuration peripheral clock */ PWC_Fcg1PeriphClockCmd(SPI_UNIT_CLOCK, Enable); /* Configuration SPI pin */ PORT_SetFunc(SPI_SCK_PORT, SPI_SCK_PIN, SPI_SCK_FUNC, Disable); PORT_SetFunc(SPI_MOSI_PORT, SPI_MOSI_PIN, SPI_MOSI_FUNC, Disable); PORT_SetFunc(SPI_MISO_PORT, SPI_MISO_PIN, SPI_MISO_FUNC, Disable); //PORT_SetFunc(SPI_NSS_PORT, SPI_NSS_PIN, SPI_NSS_FUNC, Disable); /* Configuration SPI structure */ stcSpiInit.enClkDiv = SpiClkDiv16; stcSpiInit.enFrameNumber = SpiFrameNumber1; stcSpiInit.enDataLength = SpiDataLengthBit16; stcSpiInit.enFirstBitPosition = SpiFirstBitPositionMSB; stcSpiInit.enSckPolarity = SpiSckIdleLevelHigh; stcSpiInit.enSckPhase = SpiSckOddSampleEvenChange; stcSpiInit.enReadBufferObject = SpiReadReceiverBuffer; stcSpiInit.enWorkMode = SpiWorkMode4Line; stcSpiInit.enTransMode = SpiTransFullDuplex; stcSpiInit.enCommAutoSuspendEn = Disable; stcSpiInit.enModeFaultErrorDetectEn = Disable; stcSpiInit.enParitySelfDetectEn = Disable; stcSpiInit.enParityEn = Disable; stcSpiInit.enParity = SpiParityEven; #ifdef SPI_MASTER_MODE stcSpiInit.enMasterSlaveMode = SpiModeMaster; stcSpiInit.stcDelayConfig.enSsSetupDelayOption = SpiSsSetupDelayCustomValue; stcSpiInit.stcDelayConfig.enSsSetupDelayTime = SpiSsSetupDelaySck1; stcSpiInit.stcDelayConfig.enSsHoldDelayOption = SpiSsHoldDelayCustomValue; stcSpiInit.stcDelayConfig.enSsHoldDelayTime = SpiSsHoldDelaySck1; stcSpiInit.stcDelayConfig.enSsIntervalTimeOption = SpiSsIntervalCustomValue; stcSpiInit.stcDelayConfig.enSsIntervalTime = SpiSsIntervalSck8PlusPck2; stcSpiInit.stcSsConfig.enSsValidBit = SpiSsValidChannel0; stcSpiInit.stcSsConfig.enSs0Polarity = SpiSsLowValid; #endif #ifdef SPI_SLAVE_MODE stcSpiInit.enMasterSlaveMode = SpiModeSlave; stcSpiInit.stcSsConfig.enSsValidBit = SpiSsValidChannel0; stcSpiInit.stcSsConfig.enSs0Polarity = SpiSsLowValid; #endif SPI_Init(SPI_UNIT, &stcSpiInit); SPI_Cmd(SPI_UNIT, Enable); } uint16_t SpiSendReceive(uint16_t sData) { uint16_t retry = 0; uint16_t rData; /* Wait tx buffer empty */ while (Reset == SPI_GetFlag(SPI_UNIT, SpiFlagSendBufferEmpty)) { retry++; if(retry > 0x4000) return 0; } /* Send data */ SPI_SendData16(SPI_UNIT, sData); /* Wait rx buffer full */ retry = 0; while (Reset == SPI_GetFlag(SPI_UNIT, SpiFlagReceiveBufferFull)) { retry++; if(retry > 0x4000) return 0; } /* Receive data */ rData = SPI_ReceiveData16(SPI_UNIT); return rData; } #endif #if(USE_SPI3 == 1) static void Spi3_Config(void) { stc_spi_init_t stcSpiInit; stc_port_init_t stcPortInit; MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enPinOType = Pin_OType_Cmos; PORT_Init(SPI3_SCK_PORT, SPI3_SCK_PIN, &stcPortInit); PORT_Init(SPI3_MOSI_PORT, SPI3_MOSI_PIN, &stcPortInit); PORT_Init(SPI3_MISO_PORT, SPI3_MISO_PIN, &stcPortInit); stcPortInit.enPinMode = Pin_Mode_Out; stcPortInit.enPinOType = Pin_OType_Cmos; stcPortInit.enPinDrv = Pin_Drv_H; stcPortInit.enPullUp = Disable; PORT_Init(SPI3_NSS_PORT, SPI3_NSS_PIN, &stcPortInit); SPI3_NSS_SET(); /* configuration structure initialization */ MEM_ZERO_STRUCT(stcSpiInit); /* Configuration peripheral clock */ PWC_Fcg1PeriphClockCmd(SPI3_UNIT_CLOCK, Enable); /* Configuration SPI pin */ PORT_SetFunc(SPI3_SCK_PORT, SPI3_SCK_PIN, SPI3_SCK_FUNC, Disable); PORT_SetFunc(SPI3_MOSI_PORT, SPI3_MOSI_PIN, SPI3_MOSI_FUNC, Disable); PORT_SetFunc(SPI3_MISO_PORT, SPI3_MISO_PIN, SPI3_MISO_FUNC, Disable); // PORT_SetFunc(SPI3_NSS_PORT, SPI3_NSS_PIN, SPI3_NSS_FUNC, Disable); /* Configuration SPI structure */ stcSpiInit.enClkDiv = SpiClkDiv8; stcSpiInit.enFrameNumber = SpiFrameNumber1; stcSpiInit.enDataLength = SpiDataLengthBit8; stcSpiInit.enFirstBitPosition = SpiFirstBitPositionMSB; stcSpiInit.enSckPolarity = SpiSckIdleLevelHigh; stcSpiInit.enSckPhase = SpiSckOddChangeEvenSample; stcSpiInit.enReadBufferObject = SpiReadReceiverBuffer; stcSpiInit.enWorkMode = SpiWorkMode4Line; stcSpiInit.enTransMode = SpiTransFullDuplex; stcSpiInit.enCommAutoSuspendEn = Disable; stcSpiInit.enModeFaultErrorDetectEn = Disable; stcSpiInit.enParitySelfDetectEn = Disable; stcSpiInit.enParityEn = Disable; stcSpiInit.enParity = SpiParityOdd; #ifdef SPI3_MASTER_MODE stcSpiInit.enMasterSlaveMode = SpiModeMaster; stcSpiInit.stcDelayConfig.enSsSetupDelayOption = SpiSsSetupDelayCustomValue; stcSpiInit.stcDelayConfig.enSsSetupDelayTime = SpiSsSetupDelaySck1; stcSpiInit.stcDelayConfig.enSsHoldDelayOption = SpiSsHoldDelayCustomValue; stcSpiInit.stcDelayConfig.enSsHoldDelayTime = SpiSsHoldDelaySck1; stcSpiInit.stcDelayConfig.enSsIntervalTimeOption = SpiSsIntervalCustomValue; stcSpiInit.stcDelayConfig.enSsIntervalTime = SpiSsIntervalSck8PlusPck2; stcSpiInit.stcSsConfig.enSsValidBit = SpiSsValidChannel0; stcSpiInit.stcSsConfig.enSs0Polarity = SpiSsLowValid; #endif #ifdef SPI3_SLAVE_MODE stcSpiInit.enMasterSlaveMode = SpiModeSlave; stcSpiInit.stcSsConfig.enSsValidBit = SpiSsValidChannel0; stcSpiInit.stcSsConfig.enSs0Polarity = SpiSsLowValid; #endif SPI_Init(SPI3_UNIT, &stcSpiInit); SPI_Cmd(SPI3_UNIT, Enable); } uint16_t Spi3SendReceive(uint8_t sData) { uint16_t retry = 0; uint16_t rData; /* Wait tx buffer empty */ while (Reset == SPI_GetFlag(SPI3_UNIT, SpiFlagSendBufferEmpty)) { retry++; if(retry > 0x4000) return 0; } /* Send data */ SPI_SendData16(SPI3_UNIT, sData); /* Wait rx buffer full */ retry = 0; while (Reset == SPI_GetFlag(SPI3_UNIT, SpiFlagReceiveBufferFull)) { retry++; if(retry > 0x4000) return 0; } /* Receive data */ rData = SPI_ReceiveData16(SPI3_UNIT); return rData; } /** ****************************************************************************** ** \brief SPI 读/写一字节函数 ** ** \param [in] SPIx 通道选择 ** \param [in] u8Data 发送一字节数据 ** ** \retval 接收一字节数据 ** ******************************************************************************/ uint8_t Spi3_RWByte(M4_SPI_TypeDef *SPIx, uint8_t u8Data) { uint16_t Dly = 0xffff; while(false == SPIx->SR_f.TDEF) { Dly--; if(Dly == 0) break; } Dly = 0xffff; SPIx->DR = u8Data; while(false == SPIx->SR_f.RDFF) { Dly--; if(Dly == 0) break; } return SPIx->DR; } #endif #if(USE_RTC == 1) /***************************************************************************************** * 函数名称: Rtc_Config * 功能描述: RTC配置 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ static void Rtc_Config(void) { stc_rtc_init_t stcRtcInit; stc_irq_regi_conf_t stcIrqRegiConf; /* configuration structure initialization */ MEM_ZERO_STRUCT(stcRtcInit); MEM_ZERO_STRUCT(stcIrqRegiConf); /* Reset rtc counter */ if (RTC_DeInit() == ErrorTimeout) { DBG_LOG("Reset RTC Failed!\r\n"); } else { /* Configuration rtc structure */ // stcRtcInit.enClkSource = RtcClkXtal32; stcRtcInit.enClkSource = RtcClkLrc; stcRtcInit.enPeriodInt = RtcPeriodIntHalfSec; stcRtcInit.enTimeFormat = RtcTimeFormat24Hour; stcRtcInit.enCompenWay = RtcOutputCompenDistributed; stcRtcInit.enCompenEn = Disable; stcRtcInit.u16CompenVal = 0u; RTC_Init(&stcRtcInit); /* Configure interrupt of rtc period */ stcIrqRegiConf.enIntSrc = INT_RTC_PRD; stcIrqRegiConf.enIRQn = RTC_IRQn; stcIrqRegiConf.pfnCallback = &RtcPeriod_IrqCallback; enIrqRegistration(&stcIrqRegiConf); NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn); NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); NVIC_EnableIRQ(stcIrqRegiConf.enIRQn); enIntWakeupEnable(RtcPeriodWU); /* Enable period interrupt */ RTC_IrqCmd(RtcIrqPeriod, Enable); /* Startup rtc count */ RTC_Cmd(Enable); } } /***************************************************************************************** * 函数名称: TimeGet * 功能描述: 获取系统时间 * 参 数: tm 读取时间入口 * 返 回 值: 无 *****************************************************************************************/ void TimeGet(struct tm *cTime) { stc_rtc_date_time_t RtcDateTime; RTC_GetDateTime(RtcDataFormatDec, &RtcDateTime); cTime->tm_year = RtcDateTime.u8Year + 100; cTime->tm_mon = RtcDateTime.u8Month - 1; cTime->tm_mday = RtcDateTime.u8Day; cTime->tm_hour = RtcDateTime.u8Hour; cTime->tm_min = RtcDateTime.u8Minute; cTime->tm_sec = RtcDateTime.u8Second; cTime->tm_isdst = 0; } /***************************************************************************************** * 函数名称: TimeTs * 功能描述: 系统时间转换时间戳 * 参 数: 无 * 返 回 值: 返回时间戳 *****************************************************************************************/ int TimeTs(void) { struct tm cTime; TimeGet(&cTime); time_t cTimet = mktime(&cTime); return cTimet; } /***************************************************************************************** * 函数名称: TimeShow * 功能描述: 将时间输出到DBG串口 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ void TimeShow(uint32_t dwStamp) { struct tm *stime; stime = localtime(&dwStamp); DBG_LOG("%d/",stime->tm_year + 1900); DBG_LOG("%d/",stime->tm_mon + 1); DBG_LOG("%d-",stime->tm_mday); DBG_LOG("%d:",stime->tm_hour); DBG_LOG("%d:",stime->tm_min); DBG_LOG("%d\r\n",stime->tm_sec); } /***************************************************************************************** * 函数名称: TimeSync * 功能描述: 通过时间戳同步 * 参 数: ts 时间入口 * 返 回 值: 无 *****************************************************************************************/ void TimeSync(time_t ts) { struct tm *td; // time_t ts_Utc = ts + 28800; stc_rtc_date_time_t RtcDateTime; // td = localtime(&ts_Utc); td = localtime(&ts); RtcDateTime.u8Year = td->tm_year - 100; RtcDateTime.u8Month = td->tm_mon + 1; RtcDateTime.u8Day = td->tm_mday; RtcDateTime.u8Weekday = td->tm_wday; RtcDateTime.u8Hour = td->tm_hour; RtcDateTime.u8Minute = td->tm_min; RtcDateTime.u8Second = td->tm_sec; RTC_SetDateTime(RtcDataFormatDec, &RtcDateTime, Enable, Enable); RTC_GetDateTime(RtcDataFormatDec, &RtcDateTime); DBG_LOG("TimeSync = %d-%d-%d %d:%d:%d\n", RtcDateTime.u8Year, RtcDateTime.u8Month, \ RtcDateTime.u8Day, RtcDateTime.u8Hour, RtcDateTime.u8Minute, RtcDateTime.u8Second); } #endif #if(USE_AD == 1) /***************************************************************************************** * 函数名称: AdcInitConfig * 功能描述: ADC初始化配置 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ static void AdcInitConfig(void) { stc_adc_init_t stcAdcInit; MEM_ZERO_STRUCT(stcAdcInit); stcAdcInit.enResolution = AdcResolution_12Bit; stcAdcInit.enDataAlign = AdcDataAlign_Right; stcAdcInit.enAutoClear = AdcClren_Enable; stcAdcInit.enScanMode = AdcMode_SAOnce; stcAdcInit.enRschsel = AdcRschsel_Restart; /* 1. Enable ADC1. */ PWC_Fcg3PeriphClockCmd(PWC_FCG3_PERIPH_ADC1, Enable); /* 2. Initialize ADC1. */ ADC_Init(M4_ADC1, &stcAdcInit); } /***************************************************************************************** * 函数名称: AdcSetChannelPinMode * 功能描述: ADC通道引脚配置 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ static void AdcSetChannelPinMode(uint32_t u32Channel) { en_port_t enPort; en_pin_t enPin; stc_port_init_t stcPortInit; MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enPinMode = Pin_Mode_Ana; stcPortInit.enPullUp = Disable; switch (u32Channel) { case ADC1_CH0: enPort = PortA; enPin = Pin00; break; case ADC1_CH1: enPort = PortA; enPin = Pin01; break; case ADC1_CH2: enPort = PortA; enPin = Pin02; break; case ADC1_CH3: enPort = PortA; enPin = Pin03; break; case ADC1_CH4: enPort = PortA; enPin = Pin04; break; case ADC1_CH5: enPort = PortA; enPin = Pin05; break; case ADC1_CH6: enPort = PortA; enPin = Pin06; break; case ADC1_CH7: enPort = PortA; enPin = Pin07; break; case ADC1_CH8: enPort = PortB; enPin = Pin00; break; case ADC1_CH9: enPort = PortB; enPin = Pin01; break; case ADC1_CH10: enPort = PortC; enPin = Pin00; break; case ADC1_CH11: enPort = PortC; enPin = Pin01; break; case ADC1_CH12: enPort = PortC; enPin = Pin02; break; case ADC1_CH13: enPort = PortC; enPin = Pin03; break; case ADC1_CH14: enPort = PortC; enPin = Pin04; break; case ADC1_CH15: enPort = PortC; enPin = Pin05; break; default: return; } PORT_Init(enPort, enPin, &stcPortInit); } /***************************************************************************************** * 函数名称: AdcChannelConfig * 功能描述: ADC通道配置 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ static void AdcChannelConfig(void) { stc_adc_ch_cfg_t stcChCfg; uint8_t au8Adc1SaSampTime[3] = {2255, 255, 255}; MEM_ZERO_STRUCT(stcChCfg); stcChCfg.u32Channel = ADC1_CH1 | ADC1_CH2 | ADC1_CH3; stcChCfg.u8Sequence = ADC_SEQ_A; stcChCfg.pu8SampTime = au8Adc1SaSampTime; // AdcSetChannelPinMode(ADC1_CH0); AdcSetChannelPinMode(ADC1_CH1); AdcSetChannelPinMode(ADC1_CH2); AdcSetChannelPinMode(ADC1_CH3); /* 2. Add ADC channel. */ ADC_AddAdcChannel(M4_ADC1, &stcChCfg); /* 3. Configure the average channel if you need. */ ADC_ConfigAvg(M4_ADC1, AdcAvcnt_2); //平均通道配置，多次采样后输出平均值 /* 4. Add average channel if you need. */ ADC_AddAvgChannel(M4_ADC1, stcChCfg.u32Channel); } /***************************************************************************************** * 函数名称: Adc1_Config * 功能描述: ADC1配置 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ static void Adc1_Config(void) { CLK_SetPeriClkSource(ClkPeriSrcPclk); AdcInitConfig(); AdcChannelConfig(); } /***************************************************************************************** * 函数名称: AdcDmaConfig * 功能描述: ADC DMA配置 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ static void AdcDmaConfig(void) { stc_dma_config_t stcDmaCfg; MEM_ZERO_STRUCT(stcDmaCfg); stcDmaCfg.u16BlockSize = 3; stcDmaCfg.u16TransferCnt = 0u; stcDmaCfg.u32SrcAddr = (uint32_t)(&M4_ADC1->DR1); stcDmaCfg.u32DesAddr = (uint32_t)(m_au16Adc1SaValue); stcDmaCfg.u16DesRptSize = ADC_SUM; stcDmaCfg.u16SrcRptSize = 3; stcDmaCfg.u32DmaLlp = 0u; stcDmaCfg.stcSrcNseqCfg.u16Cnt = 0u; stcDmaCfg.stcSrcNseqCfg.u32Offset = 0u; stcDmaCfg.stcDesNseqCfg.u16Cnt = 0u; stcDmaCfg.stcDesNseqCfg.u32Offset = 0u; stcDmaCfg.stcDmaChCfg.enSrcInc = AddressIncrease; stcDmaCfg.stcDmaChCfg.enDesInc = AddressIncrease; stcDmaCfg.stcDmaChCfg.enSrcRptEn = Enable; stcDmaCfg.stcDmaChCfg.enDesRptEn = Enable; stcDmaCfg.stcDmaChCfg.enSrcNseqEn = Disable; stcDmaCfg.stcDmaChCfg.enDesNseqEn = Disable; stcDmaCfg.stcDmaChCfg.enTrnWidth = Dma16Bit; stcDmaCfg.stcDmaChCfg.enLlpEn = Enable; /* Enable DMA interrupt. */ stcDmaCfg.stcDmaChCfg.enIntEn = Enable; PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_DMA1, Enable); DMA_InitChannel(M4_DMA1, DmaCh0, &stcDmaCfg); DMA_Cmd(M4_DMA1, Enable); DMA_ChannelCmd(M4_DMA1, DmaCh0, Enable); DMA_ClearIrqFlag(M4_DMA1, DmaCh0, TrnCpltIrq); /* AOS must be enabled to use DMA */ /* AOS enabled at first. */ /* If you have enabled AOS before, then the following statement is not needed. */ PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_AOS, Enable); DMA_SetTriggerSrc(M4_DMA1, DmaCh0, EVT_ADC1_EOCA); } #endif #if(USE_DMA == 1) /***************************************************************************************** * 函数名称: DmaIrqRegister * 功能描述: DMA中断寄存器配置 * 参 数: pstcCfg， 中断参数 u32Priority， 中断优先级 * 返 回 值: 无 *****************************************************************************************/ static void DmaIrqRegister(stc_irq_regi_conf_t *pstcCfg, uint32_t u32Priority) { int16_t s16Vnum = pstcCfg->enIRQn; if (((s16Vnum >= Int000_IRQn) && (s16Vnum <= Int031_IRQn)) || ((s16Vnum >= Int038_IRQn) && (s16Vnum <= Int043_IRQn))) { if (Ok != enIrqRegistration(pstcCfg)) return; } else if (Int129_IRQn == s16Vnum) enShareIrqEnable(pstcCfg->enIntSrc); else return; NVIC_ClearPendingIRQ(pstcCfg->enIRQn); NVIC_SetPriority(pstcCfg->enIRQn, u32Priority); NVIC_EnableIRQ(pstcCfg->enIRQn); } /***************************************************************************************** * 函数名称: DmaIrqRegister * 功能描述: DMA中断配置 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ static void DmaIrqConfig(void) { stc_irq_regi_conf_t stcAdcIrqCfg; stcAdcIrqCfg.enIntSrc = INT_DMA1_BTC0; stcAdcIrqCfg.enIRQn = Int030_IRQn; stcAdcIrqCfg.pfnCallback = Dma1Btc0_IrqHandler; DmaIrqRegister(&stcAdcIrqCfg, DDL_IRQ_PRIORITY_03); } /***************************************************************************************** * 函数名称: DmaIrqRegister * 功能描述: DMA配置 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ static void Dma_Config(void) { AdcDmaConfig(); DmaIrqConfig(); } #endif /***************************************************************************************** * 函数名称: ReadAdcValue * 功能描述: 读取AD值 * 参 数: 无 * 返 回 值: AD值 *****************************************************************************************/ uint16_t *GetADCBuffPoint(void) { return m_au16Adc1SaValue; } /***************************************************************************************** * 函数名称: ADC_Start * 功能描述: 启动ADC转换 * 参 数: 无 * 返 回 值: AD值 *****************************************************************************************/ void ADC_Start(void) { ADC_StartConvert(M4_ADC1); } void ADC_Stop(void) { ADC_StopConvert(M4_ADC1); } /***************************************************************************************** * 函数名称: ReadAdcValue * 功能描述: 读取AD值 * 参 数: 无 * 返 回 值: AD值 *****************************************************************************************/ void ReadAdcValue(uint16_t *ADValue) { ADC_PollingSa(M4_ADC1, ADValue, 4, 100); } void BSP_Init(void) { stc_clk_freq_t Freq; SystemClockConfig(); SystemCoreClockUpdate(); //Xtal32_ClockConfig(); GPIO_Config(); ExtiCh10_Init(); ExtiCh01_Init(); ExtiCh06_Init(); ExtiCh04_Init(); DbgUart_Config(700000); #if(USE_USART3 == 1) Uart3_Config(9600); #endif //RS485Uart_Config(9600); //Rtc_Config(); //SdioInit(); //Spi_Config(); // Spi3_Config(); // dcmotor_init(); // Adc1_Config(); // Dma_Config(); //FeedDog(); SysTick_Init(1000u); SysTick_Delay(1000); CLK_GetClockFreq(&Freq); //DBG_LOG("SysFreq = %d\r\n", Freq.sysclkFreq); } /***************************************************************************************** * 函数名称: EnterStop * 功能描述: 进入低功耗状态 * 参 数: SleepStatus 设备低功耗状态 * 返 回 值: 无 *****************************************************************************************/ void EnterStop(void) { stc_pwc_stop_mode_cfg_t stcPwcStopCfg; stc_port_init_t stcPortInit; uint16_t AnaPin; //PWC_Fcg1PeriphClockCmd(SPI3_UNIT_CLOCK, Disable); PWC_Fcg1PeriphClockCmd(DBG_FCG1_PERIPH, Disable); DBGRxWakeupInit(); MEM_ZERO_STRUCT(stcPortInit); stcPortInit.enPinMode = Pin_Mode_Ana; AnaPin = PinAll & (~(Pin13|Pin14)); PORT_Init(PortA, AnaPin, &stcPortInit); AnaPin = PinAll & (~Pin02); PORT_Init(PortB, AnaPin, &stcPortInit); AnaPin = PinAll & (~(Pin03)); PORT_Init(PortC, AnaPin, &stcPortInit); AnaPin = Pin02; PORT_Init(PortH, AnaPin, &stcPortInit); SysTick_Suspend(); stcPwcStopCfg.enStpDrvAbi = StopUlowspeed; stcPwcStopCfg.enStopClk = ClkFix; stcPwcStopCfg.enStopFlash = Wait; stcPwcStopCfg.enPll = Enable; while(Ok != PWC_StopModeCfg(&stcPwcStopCfg)){;} while(1ul != M4_EFM->FSR_f.RDY){;} PWC_EnterStopMd(); } extern uint8_t BDRxData[256]; /***************************************************************************************** * 函数名称: Wakeup * 功能描述: 设备唤醒 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ void Wakeup(void) { NVIC_DisableIRQ(DBG_RX_IRQn); PWC_ClkRecover(); //SystemClockConfig(); //Spi3_Config(); DbgUart_Config(700000); #if(USE_USART3 == 1) Uart3_Config(9600); #endif // RS485Uart_Config(9600); //GPIO_Config(); //SysTick_Resume(); SysTick_Init(1000); } void Error_Handler(void) { while(1){ ; } } #if(USE_RS485 == 1) __WEAK void RS485UsartErrIrqCallback(void) { if(RS485_USART_CH->SR_f.ORE) { RS485_USART_CH->CR1_f.CORE = 1; USART_RecData(RS485_USART_CH); } if(RS485_USART_CH->SR_f.PE) RS485_USART_CH->CR1_f.CPE = 1; if(RS485_USART_CH->SR_f.FE) RS485_USART_CH->CR1_f.CFE = 1; } __WEAK void RS485_RxPinIntCallBack(void) { } #endif #if(USE_DEBUG == 1) __WEAK void DBGUsartErrIrqCallback(void) { if(DBG_USART_CH->SR_f.ORE) { DBG_USART_CH->CR1_f.CORE = 1; USART_RecData(DBG_USART_CH); } if(DBG_USART_CH->SR_f.PE) DBG_USART_CH->CR1_f.CPE = 1; if(DBG_USART_CH->SR_f.FE) DBG_USART_CH->CR1_f.CFE = 1; } __WEAK void DbgUsartRxIrqCallback(void) { } __WEAK void DBG_RxPinIntCallBack(void) { } #endif #if(USE_USART3 == 1) void Usart3ErrIrqCallback(void) { if(USART3_CH->SR_f.ORE) { USART3_CH->CR1_f.CORE = 1; USART_RecData(USART3_CH); } if(USART3_CH->SR_f.PE) USART3_CH->CR1_f.CPE = 1; if(USART3_CH->SR_f.FE) USART3_CH->CR1_f.CFE = 1; } __WEAK void Usart3RxIrqCallback(void) { } __WEAK void Usart3_RxPinIntCallBack(void) { } #endif /***************************************************************************************** * 函数名称: RtcPeriod_IrqCallback * 功能描述: RTC中断回调 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ __WEAK void RtcPeriod_IrqCallback(void) { } /***************************************************************************************** * 函数名称: Dma1Btc0_IrqHandler * 功能描述: DMA中断外部重定向回调函数 * 参 数: 无 * 返 回 值: 无 *****************************************************************************************/ extern void ADC_DMA_CallBack(void); //int test = 0; __WEAK void Dma1Btc0_IrqHandler(void) { DMA_ClearIrqFlag(M4_DMA1, DmaCh0, BlkTrnCpltIrq); ADC_DMA_CallBack(); // test++; }