/* ****************************************************************************** * @file HAL_Uart.c * @version V1.0.0 * @date 2020 * @brief UART HAL module driver. * This file provides firmware functions to manage the following * functionalities of the Universal Asynchronous Receiver Transmitter Peripheral (UART). * @ Initialization and de-initialization functions * @ IO operation functions * @ Peripheral Control functions ****************************************************************************** */ #include "ACM32Fxx_HAL.h" /* If Use 'UART_MODE_TX_RX_DEBUG', Point to Debug Uart */ UART_TypeDef *Uart_Debug = NULL; /* Private function prototypes -----------------------------------------------*/ static void UART_Config_BaudRate(UART_HandleTypeDef *huart); static HAL_StatusTypeDef HAL_UART_Wait_Tx_Done(UART_HandleTypeDef *huart); __weak void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart); __weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart); __weak void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart); /********************************************************************************* * Function : HAL_UART_IRQHandler * Description : Handle UART interrupt request. * Input : huart: UART handle. * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ void HAL_UART_IRQHandler(UART_HandleTypeDef *huart) { uint32_t read_bytes_number; uint32_t isrflags, ieits, errorflags; #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return; #endif isrflags =READ_REG(huart->Instance->RIS); ieits =READ_REG(huart->Instance->IE); errorflags =0x00U; errorflags =(isrflags & (uint32_t)(UART_ICR_PEI|UART_ICR_OEI|UART_ICR_FEI|UART_ICR_BEI)); /* Enable TXI */ if (huart->Instance->IE & UART_IE_TXI) { if (huart->Instance->RIS & UART_RIS_TXI) { /* Clear TXI Status */ SET_BIT(huart->Instance->ICR , UART_ICR_TXI); for(;;) { if(huart->lu32_TxCount == huart->lu32_TxSize) { huart->lu8_TxBusy = false; /* Disable TX interrupt */ CLEAR_BIT(huart->Instance->IE, UART_IE_TXI); HAL_UART_TxCpltCallback(huart); break; } if (READ_BIT(huart->Instance->FR, UART_FR_TXFF)) { break; } huart->Instance->DR = huart->lu8_TxData[huart->lu32_TxCount++]; } } } /* RXI */ if ((huart->Instance->IE & UART_IE_RXI || huart->Instance->IE& UART_IE_RTI) && errorflags == 0) { if (huart->Instance->RIS & UART_RIS_RXI) { read_bytes_number = 0; /* Clear RXI Status */ SET_BIT(huart->Instance->ICR, UART_ICR_RXI); /* Receive end */ while(huart->lu32_RxCount <huart->lu32_RxSize ) { if(!READ_BIT(huart->Instance->FR, UART_FR_RXFE)) { /* Store Data in buffer */ huart->lu8_RxData[huart->lu32_RxCount++] = huart->Instance->DR; read_bytes_number++; } else { break; } if (read_bytes_number == huart->lu32_fifo_level_minus1) { break; } } if(huart->lu32_RxCount ==huart->lu32_RxSize ) { huart->lu8_RxBusy = false; /* Disable RX and RTI interrupt */ CLEAR_BIT(huart->Instance->IE, (UART_IE_RXI|UART_IE_RTI)); /* clear error interrupt */ CLEAR_BIT(huart->Instance->IE, UART_IE_OEI|UART_IE_BEI|UART_IE_PEI|UART_IE_FEI); HAL_UART_RxCpltCallback(huart); } } else if(huart->Instance->RIS & UART_RIS_RTI) { /*clear RTI Status */ SET_BIT(huart->Instance->ICR ,UART_ICR_RTI); while(!READ_BIT(huart->Instance->FR, UART_FR_RXFE)) { huart->lu8_RxData[huart->lu32_RxCount++] = huart->Instance->DR; } huart->lu8_RxBusy = false; /* Disable RX and RTI interrupt */ CLEAR_BIT(huart->Instance->IE, (UART_IE_RXI|UART_IE_RTI)); /* clear error interrupt */ CLEAR_BIT(huart->Instance->IE, UART_IE_OEI|UART_IE_BEI|UART_IE_PEI|UART_IE_FEI); HAL_UART_RxCpltCallback(huart); } } /* if some errors occurred */ if(errorflags != 0 &&(ieits & (UART_IE_OEI|UART_IE_BEI|UART_IE_PEI|UART_IE_FEI))) { /* UART parity error interrupt occurred */ if (((isrflags & UART_RIS_PEI) != 0) && ((ieits & UART_IE_PEI) != 0)) { /* Clear parity error status */ SET_BIT(huart->Instance->ICR, UART_ICR_PEI); huart->ErrorCode |= HAL_UART_ERROR_PE; } /* UART break error interrupt occurred */ if (((isrflags & UART_RIS_BEI) != 0) && ((ieits & UART_IE_BEI) != 0)) { SET_BIT(huart->Instance->ICR, UART_RIS_BEI); huart->ErrorCode |= HAL_UART_ERROR_NE; } /* UART frame error interrupt occurred */ if (((isrflags & UART_RIS_FEI) != 0) && ((ieits & UART_IE_FEI) != 0)) { SET_BIT(huart->Instance->ICR, UART_RIS_FEI); huart->ErrorCode |= HAL_UART_ERROR_FE; } /* UART Over-Run interrupt occurred */ if (((isrflags & UART_RIS_OEI) != 0) && ((ieits & UART_IE_OEI) != 0)) { SET_BIT(huart->Instance->ICR, UART_RIS_OEI); huart->ErrorCode |= HAL_UART_ERROR_ORE; } /* clear error interrupt */ CLEAR_BIT(huart->Instance->IE, UART_IE_OEI|UART_IE_BEI|UART_IE_PEI|UART_IE_FEI); HAL_UART_ErrorCallback(huart); } } /********************************************************************************* * Function : HAL_UART_Wait_Tx_Done * Description : wait Tx FIFO empty * Input : huart: UART handle. * Output : **********************************************************************************/ static HAL_StatusTypeDef HAL_UART_Wait_Tx_Done(UART_HandleTypeDef *huart) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif /* wait TX not busy*/ while(READ_BIT(huart->Instance->FR, UART_FR_BUSY)); return HAL_OK; } /********************************************************************************* * Function : HAL_UART_MspInit * Description : Initialize the UART MSP. * Input : huart: UART handle. * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ __weak void HAL_UART_MspInit(UART_HandleTypeDef *huart) { /* NOTE: This function should be modified, when the callback is needed, the HAL_UART_MspInit can be implemented in the user file. */ /* For Example */ GPIO_InitTypeDef GPIO_Uart1; if (huart->Instance == UART1) { /* Enable Clock */ System_Module_Enable(EN_UART1); /* Initialization GPIO */ /* A9:Tx A10:Rx */ GPIO_Uart1.Pin = GPIO_PIN_9 | GPIO_PIN_10; GPIO_Uart1.Mode = GPIO_MODE_AF_PP; GPIO_Uart1.Pull = GPIO_PULLUP; GPIO_Uart1.Alternate = GPIO_FUNCTION_2; HAL_GPIO_Init(GPIOA, &GPIO_Uart1); if (huart->Init.HwFlowCtl & UART_HWCONTROL_CTS) { /* A11:CTS */ GPIO_Uart1.Pin = GPIO_PIN_11; HAL_GPIO_Init(GPIOA, &GPIO_Uart1); } if (huart->Init.HwFlowCtl & UART_HWCONTROL_RTS) { /* A12:RTS */ GPIO_Uart1.Pin = GPIO_PIN_12; HAL_GPIO_Init(GPIOA, &GPIO_Uart1); } /* NVIC Config */ NVIC_ClearPendingIRQ(UART1_IRQn); NVIC_SetPriority(UART1_IRQn, 5); NVIC_EnableIRQ(UART1_IRQn); } } /********************************************************************************* * Function : HAL_UART_Init * Description : Initialize the UART mode according to the specified parameters * in the UART_InitTypeDef * Input : huart: UART handle. * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; if (!IS_UART_WORDLENGTH(huart->Init.WordLength)) return HAL_ERROR; if (!IS_UART_STOPBITS(huart->Init.StopBits)) return HAL_ERROR; if (!IS_UART_PARITY(huart->Init.Parity)) return HAL_ERROR; if (!IS_UART_MODE(huart->Init.Mode)) return HAL_ERROR; if (!IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl)) return HAL_ERROR; #endif /* Init the low level hardware : GPIO, CLOCK, NVIC */ HAL_UART_MspInit(huart); /* Config BaudRate */ UART_Config_BaudRate(huart); /* Set the UART Communication parameters */ huart->Instance->LCRH = huart->Init.WordLength | UART_LCRH_FEN | huart->Init.StopBits | huart->Init.Parity; huart->Instance->CR = huart->Init.HwFlowCtl | huart->Init.Mode | UART_CR_UARTEN; if (huart->Init.Mode == UART_MODE_TX_RX_DEBUG) { Uart_Debug = huart->Instance; } else if (huart->Init.Mode == UART_MODE_HALF_DUPLEX) { huart->Instance->CR2 = UART_CR2_TXOE_SEL; } return HAL_OK; } /********************************************************************************* * Function : HAL_UART_MspDeInit * Description : DeInitialize the UART MSP. * Input : huart: UART handle. * Output : **********************************************************************************/ __weak void HAL_UART_MspDeInit(UART_HandleTypeDef *huart) { /* NOTE: This function should be modified, when the callback is needed, the HAL_UART_MspDeInit can be implemented in the user file. */ if (huart->Instance == UART1) { /* Disable Clock */ System_Module_Disable(EN_UART1); /* DeInitialization GPIO */ /* A9:Tx A10:Rx */ HAL_GPIO_DeInit(GPIOA,GPIO_PIN_9 | GPIO_PIN_10); if (huart->Init.HwFlowCtl & UART_HWCONTROL_CTS) { /* A11:CTS */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11); } if (huart->Init.HwFlowCtl & UART_HWCONTROL_RTS) { /* A12:RTS */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_12); } /* NVIC DeInit */ NVIC_DisableIRQ(UART1_IRQn); } else if(huart->Instance == UART2) { } } /********************************************************************************* * Function : HAL_UART_Init * Description : Initialize the UART mode according to the specified parameters * in the UART_InitTypeDef * Input : huart: UART handle. * Output : **********************************************************************************/ HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif /* DeInit the low level hardware : GPIO, CLOCK, NVIC */ HAL_UART_MspDeInit(huart); return HAL_OK; } /********************************************************************************* * Function : HAL_UART_Transmit * Description : Send an amount of data in blocking mode. * Input : huart: UART handle. * Input : fu8_Data: Pointer to data buffer. * Input : fu32_Size: Amount of data elements to be sent. * Input : fu32_Timeout: Timeout duration. * Output : HAL status * Author : Chris_Kyle Data : 2020 **********************************************************************************/ HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *fu8_Data, uint32_t fu32_Size, uint32_t fu32_Timeout) { uint32_t lu32_Timeout; #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif huart->lu32_TxCount = 0; while (fu32_Size--) { huart->Instance->DR = *fu8_Data++; huart->lu32_TxCount++; /* have no timeout */ if (fu32_Timeout == 0) { while (huart->Instance->FR & UART_FR_TXFF); } else { lu32_Timeout = fu32_Timeout *256; while (huart->Instance->FR & UART_FR_TXFF) { if (lu32_Timeout-- == 0) { return HAL_TIMEOUT; } } } } HAL_UART_Wait_Tx_Done(huart); return HAL_OK; } /********************************************************************************* * Function : HAL_UART_Receive * Description : Receive an amount of data in blocking mode. * Input : huart: UART handle. * Input : fu8_Data: Pointer to data buffer. * Input : fu32_Size: Amount of data elements to be receive. * Input : fu32_Timeout: Timeout duration. * Output : HAL status * Author : Chris_Kyle Data : 2020 **********************************************************************************/ HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *fu8_Data, uint32_t fu32_Size, uint32_t fu32_Timeout) { uint32_t lu32_Timeout; #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif huart->lu32_RxCount = 0; /* Half duplex Use Tx GPIO Receive Data */ if (huart->Init.Mode == UART_MODE_HALF_DUPLEX) { huart->Instance->CR2 |= UART_CR2_RX_SEL; } while (fu32_Size--) { if (fu32_Timeout == 0) { while(huart->Instance->FR & UART_FR_RXFE); *fu8_Data++ = huart->Instance->DR; huart->lu32_RxCount++; } else { lu32_Timeout = fu32_Timeout * 256; while(huart->Instance->FR & UART_FR_RXFE) { if (lu32_Timeout-- == 0) { /* Clear Half duplex */ huart->Instance->CR2 &= ~UART_CR2_RX_SEL; return HAL_TIMEOUT; } } *fu8_Data++ = huart->Instance->DR; huart->lu32_RxCount++; } } /* Clear Half duplex */ huart->Instance->CR2 &= ~UART_CR2_RX_SEL; return HAL_OK; } /********************************************************************************* * Function : HAL_UART_Transmit_IT * Description : Send an amount of data in interrupt mode. * Input : huart: UART handle. * Input : fu8_Data: Pointer to data buffer. * Input : fu32_Size: Amount of data elements to be receive. * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *fu8_Data, uint32_t fu32_Size) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif if (huart->lu8_TxBusy == true) { return HAL_BUSY; } if (fu32_Size == 0 || fu8_Data == NULL) { return HAL_ERROR; } huart->lu32_TxSize = fu32_Size; huart->lu32_TxCount = 0; huart->lu8_TxData = fu8_Data; huart->lu8_TxBusy = true; /* Clear TXI Status */ huart->Instance->ICR = UART_ICR_TXI; /* FIFO Enable */ SET_BIT(huart->Instance->LCRH, UART_LCRH_FEN); /*FIFO Select*/ SET_BIT(huart->Instance->IFLS,UART_TX_FIFO_1_2); for(;;) { /*Data Size less than 16Byte */ if(fu32_Size == huart->lu32_TxCount) { huart->lu8_TxBusy = false; while ((huart->Instance->FR & UART_FR_BUSY)){} HAL_UART_TxCpltCallback(huart); return HAL_OK; } if(READ_BIT(huart->Instance->FR, UART_FR_TXFF)) { break; } huart->Instance->DR = huart->lu8_TxData[huart->lu32_TxCount++]; } /* Enable TX interrupt */ huart->Instance->IE |= UART_IE_TXI; return HAL_OK; } /********************************************************************************* * Function : HAL_UART_Receive_IT * Description : Receive an amount of data in interrupt mode. * Input : * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *fu8_Data, uint32_t fu32_Size) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif if (huart->lu8_RxBusy == true) { return HAL_BUSY; } if (fu32_Size == 0 || fu8_Data == NULL) { return HAL_ERROR; } huart->lu32_RxSize = fu32_Size; huart->lu32_RxCount = 0; huart->lu8_RxData = fu8_Data; huart->lu8_RxBusy = true; /* Clear RXI Status */ huart->Instance->ICR = UART_ICR_RXI; /* FIFO Enable */ SET_BIT(huart->Instance->LCRH, UART_LCRH_FEN); /*FIFO Select*/ MODIFY_REG(huart->Instance->IFLS, UART_IFLS_RXIFLSEL, UART_RX_FIFO_1_2); huart->lu32_fifo_level_minus1 = 8-1; // 16/2 - 1 /* Enable the UART Errors interrupt */ SET_BIT(huart->Instance->IE,UART_IE_OEI|UART_IE_BEI|UART_IE_PEI|UART_IE_FEI); /* Enable RX and RTI interrupt */ SET_BIT(huart->Instance->IE,UART_IE_RXI|UART_IE_RTI); return HAL_OK; } /********************************************************************************* * Function : HAL_UART_Transmit_DMA * Description : Send an amount of data in DMA mode. * Input : huart: UART handle. * Input : fu8_Data: Pointer to data buffer. * Input : fu32_Size: Amount of data elements to be Send. * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *fu8_Data, uint32_t fu32_Size) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif if (huart->lu8_TxBusy == true) { return HAL_BUSY; } if (fu32_Size == 0 || fu8_Data == NULL) { return HAL_ERROR; } huart->Instance->DMACR |= UART_DMACR_TXDMAE; if (HAL_DMA_Start_IT(huart->HDMA_Tx, (uint32_t)fu8_Data, (uint32_t)(&huart->Instance->DR), fu32_Size)) { return HAL_ERROR; } return HAL_OK; } /********************************************************************************* * Function : HAL_UART_Receive_DMA * Description : Receive an amount of data in DMA mode. * Input : huart: UART handle. * Input : fu8_Data: Pointer to data buffer. * Input : fu32_Size: Amount of data elements to be receive. * Output : **********************************************************************************/ HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *fu8_Data, uint32_t fu32_Size) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif if (huart->lu8_RxBusy == true) { return HAL_BUSY; } if (fu32_Size == 0 || fu8_Data == NULL) { return HAL_ERROR; } huart->Instance->DMACR |= UART_DMACR_RXDMAE; if (HAL_DMA_Start_IT(huart->HDMA_Rx, (uint32_t)(&huart->Instance->DR), (uint32_t)fu8_Data, fu32_Size)) { return HAL_ERROR; } return HAL_OK; } /********************************************************************************* * Function : HAL_UART_TxCpltCallback * Description : Tx Transfer completed callbacks. * Input : * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ __weak void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) { /* NOTE: This function Should be modified, when the callback is needed, the HAL_UART_TxCpltCallback could be implemented in the user file. */ } /********************************************************************************* * Function : HAL_UART_RxCpltCallback * Description : Rx Transfer completed callbacks. * Input : * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ __weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { /* NOTE: This function Should be modified, when the callback is needed, the HAL_UART_RxCpltCallback could be implemented in the user file. */ } /********************************************************************************* * Function : HAL_UART_ErrorCallBack * Description : Recv Error callbacks. * Input : * Output : **********************************************************************************/ __weak void HAL_UART_ErrorCallBack(UART_HandleTypeDef *huart) { /* NOTE: This function Should be modified, when the callback is needed, the HAL_UART_ErrorCallBack could be implemented in the user file. */ } /********************************************************************************* * Function : UART_Config_BaudRate * Description : Config BaudRate * Input : * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ static void UART_Config_BaudRate(UART_HandleTypeDef *huart) { uint32_t lu32_PCLK; uint32_t lu32_IBAUD, lu32_FBAUD; uint64_t lu64_TempValue; lu32_PCLK = System_Get_APBClock(); /* Integral part */ lu32_IBAUD = lu32_PCLK / (huart->Init.BaudRate * 16); /* Fractional part */ lu64_TempValue = lu32_PCLK % (huart->Init.BaudRate * 16); lu64_TempValue = (lu64_TempValue * 1000000) / (huart->Init.BaudRate * 16); lu32_FBAUD = (lu64_TempValue * 64 + 500000) / 1000000; if (lu32_FBAUD >= 64) { huart->Instance->IBRD = lu32_IBAUD + 1; huart->Instance->FBRD = 0; } else { huart->Instance->IBRD = lu32_IBAUD; huart->Instance->FBRD = lu32_FBAUD; } } /********************************************************************************* * Function : HAL_UART_GetState * Description : Return the uart State * Input : * Output : **********************************************************************************/ HAL_StatusTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif if(huart->lu8_TxBusy || huart->lu8_RxBusy) { return HAL_BUSY; } return HAL_OK; } /********************************************************************************* * Function : HAL_UART_GetError * Description : Return the uart Error * Input : * Output : **********************************************************************************/ uint32_t HAL_UART_GetError(UART_HandleTypeDef *huart) { return huart->ErrorCode; } /********************************************************************************* * Function : HAL_UART_Abort * Description : Abort ongoing transfers(blocking mode) * Input : UART handle * Output : **********************************************************************************/ HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif /*disble all interrupt*/ huart->Instance->IE =0x00; /* Disable the UART DMA Tx request if enable */ if(READ_BIT(huart->Instance->DMACR, UART_DMACR_TXDMAE)) { CLEAR_BIT(huart->Instance->DMACR, UART_DMACR_TXDMAE); /* Abort the UART Tx Channel */ if(huart->HDMA_Tx) { /*Set the UART DMA Abort callback to Null */ huart->HDMA_Tx->DMA_ITC_Callback =NULL; if(HAL_DMA_Abort(huart->HDMA_Tx)!=HAL_OK) { return HAL_TIMEOUT; } } } /* Disable the UART DMA Rx request if enable */ if(READ_BIT(huart->Instance->DMACR, UART_DMACR_RXDMAE)) { CLEAR_BIT(huart->Instance->DMACR, UART_DMACR_RXDMAE); /* Abort the UART Rx Channel */ if(huart->HDMA_Rx) { /*Set the UART DMA Abort callback to Null */ huart->HDMA_Rx->DMA_ITC_Callback =NULL; if(HAL_DMA_Abort(huart->HDMA_Rx)!=HAL_OK) { return HAL_TIMEOUT; } } } /*Reset Tx and Rx Transfer size*/ huart->lu32_TxSize = 0; huart->lu32_RxSize = 0; /* Restore huart->lu8_TxBusy and huart->lu8_RxBusy to Ready */ huart->lu8_TxBusy = false; huart->lu8_RxBusy = false; return HAL_OK; } /********************************************************************************* * Function : HAL_UART_DMAPause * Description : Pause the DMA Transfer * Input : UART handle * Output : **********************************************************************************/ HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif if(READ_BIT(huart->Instance->DMACR, UART_DMACR_TXDMAE)) { /* Disable the UART DMA Tx request */ CLEAR_BIT(huart->Instance->DMACR, UART_DMACR_TXDMAE); } if (READ_BIT(huart->Instance->DMACR, UART_DMACR_RXDMAE)) { /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */ CLEAR_BIT(huart->Instance->IE, UART_IE_OEI|UART_IE_BEI|UART_IE_FEI); /* Disable the UART DMA Rx request */ CLEAR_BIT(huart->Instance->DMACR, UART_DMACR_RXDMAE); } return HAL_OK; } /********************************************************************************* * Function : HAL_UART_DMAResume * Description : Resume the DMA Transfer * Input : UART handle * Output : **********************************************************************************/ HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart) { #if (USE_FULL_ASSERT == 1) if (!IS_UART_ALL_INSTANCE(huart->Instance)) return HAL_ERROR; #endif if (huart->lu8_TxBusy == false) { /* Enable the UART DMA Tx request */ SET_BIT(huart->Instance->DMACR, UART_DMACR_TXDMAE); } if (huart->lu8_RxBusy == false) { /* Reenable PE and ERR (Frame error, noise error, overrun error) interrupts */ SET_BIT(huart->Instance->IE, UART_IE_OEI|UART_IE_BEI|UART_IE_FEI); /* Enable the UART DMA Rx request */ SET_BIT(huart->Instance->DMACR, UART_DMACR_RXDMAE); } return HAL_OK; } #if 0 /********************************************************************************* * Function : fputc * Description : * Input : * Output : * Author : Chris_Kyle Data : 2020 **********************************************************************************/ int fputc(int ch, FILE *f) { if (Uart_Debug == NULL) { return 0; } Uart_Debug->DR = ch; while ((Uart_Debug->FR & UART_FR_BUSY)); return ch; } #endif