/**
* @brief DMA UART communication error callback.
* @param hdma: DMA handle
* @retval None
*/
static void h_UART_DMAError(DMA_HandleTypeDef *hdma)
{
UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
huart->RxXferCount = 0;
huart->TxXferCount = 0;
huart->gState= HAL_UART_STATE_READY;
huart->ErrorCode |= HAL_UART_ERROR_DMA;
HAL_UART_ErrorCallback(huart);
}
void HardwareSerial::write(unsigned char ch) {
tx_in_progress = true;
if ( HAL_UART_Transmit_IT(&huart6, &ch, 1) != HAL_OK ) {
tx_in_progress = false;
} else {
serial_write_start_timestamp = HAL_GetTick();
while ( tx_in_progress ) {
if ( (HAL_GetTick() - serial_write_start_timestamp) > (unsigned long)SERIAL_WRITE_TIMEOUT_MS) {
tx_in_progress = false;
HAL_UART_ErrorCallback(&huart6);
}
}
}
}
void UART_ProcessStatus(UART_HandleTypeDef* pUart) {
/* UART parity error interrupt occurred ------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_PE) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_PE) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_PEF);
pUart->ErrorCode |= HAL_UART_ERROR_PE;
}
/* UART frame error interrupt occurred --------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_FE) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_FEF);
pUart->ErrorCode |= HAL_UART_ERROR_FE;
}
/* UART noise error interrupt occurred --------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_NE) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_NEF);
pUart->ErrorCode |= HAL_UART_ERROR_NE;
}
/* UART Over-Run interrupt occurred -----------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_ORE) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_OREF);
pUart->ErrorCode |= HAL_UART_ERROR_ORE;
}
/* Call UART Error Call back function if need be --------------------------*/
if (pUart->ErrorCode != HAL_UART_ERROR_NONE)
{
HAL_UART_ErrorCallback(pUart);
}
/* UART Wake Up interrupt occurred ------------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_WUF) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_WUF) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_WUF);
HAL_UARTEx_WakeupCallback(pUart);
}
}
void UART_IRQProc(UART_CCB *uccb, UART_HandleTypeDef *UARTx)
{
uint32_t tmp1 = 0, tmp2 = 0;
tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_PE);
tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_PE);
/* UART parity error interrupt occurred ------------------------------------*/
if((tmp1 != RESET) && (tmp2 != RESET))
{
__HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_PE);
UARTx->ErrorCode |= HAL_UART_ERROR_PE;
}
tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_FE);
tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_ERR);
/* UART frame error interrupt occurred -------------------------------------*/
if((tmp1 != RESET) && (tmp2 != RESET))
{
__HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_FE);
UARTx->ErrorCode |= HAL_UART_ERROR_FE;
}
tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_NE);
tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_ERR);
/* UART noise error interrupt occurred -------------------------------------*/
if((tmp1 != RESET) && (tmp2 != RESET))
{
__HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_NE);
UARTx->ErrorCode |= HAL_UART_ERROR_NE;
}
tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_ORE);
tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_ERR);
/* UART Over-Run interrupt occurred ----------------------------------------*/
if((tmp1 != RESET) && (tmp2 != RESET))
{
__HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_ORE);
UARTx->ErrorCode |= HAL_UART_ERROR_ORE;
}
tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_RXNE);
tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_RXNE);
/* UART in mode Receiver ---------------------------------------------------*/
if((tmp1 != RESET) && (tmp2 != RESET))
{
//UART_Receive_IT(UARTx);
*uccb->gpUartRxAddress++ = (uint8_t)(UARTx->Instance->DR & (uint8_t)0x00FF);
if(uccb->gpUartRxAddress == uccb->gpUartRxEndAddress)
{
//回头
uccb->gpUartRxAddress = uccb->gpUartRxStartAddress;
}
if(uccb->gpUartRxReadAddress == uccb->gpUartRxAddress)
{
//可以考虑加错误统计
}
__HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_RXNE);
#if (LED_UART_EN > 0u)
LED_UART_ON();
#endif
}
tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_TXE);
tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_TXE);
/* UART in mode Transmitter ------------------------------------------------*/
if((tmp1 != RESET) && (tmp2 != RESET))
{
//UART_Transmit_IT(UARTx);
if(uccb->gUartTxCnt > 0)
{
UARTx->Instance->DR = (uint8_t)(*uccb->gpUartTxAddress++ & (uint8_t)0x00FF);
uccb->gUartTxCnt--;
}
else
{
__HAL_UART_DISABLE_IT(UARTx, UART_IT_TXE);
}
__HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_TXE);
#if (LED_UART_EN > 0u)
LED_UART_ON();
#endif
}
if(UARTx->ErrorCode != HAL_UART_ERROR_NONE)
{
/* Set the UART state ready to be able to start again the process */
UARTx->State = HAL_UART_STATE_READY;
HAL_UART_ErrorCallback(UARTx);
}
}
void CommUartIrqHandler(UART_HandleTypeDef *huart)
{
uint32_t tmp_flag = 0, tmp_it_source = 0;
tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_PE);
tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_PE);
/* UART parity error interrupt occurred ------------------------------------*/
if ((tmp_flag != RESET) && (tmp_it_source != RESET))
{
__HAL_UART_CLEAR_PEFLAG(huart);
huart->ErrorCode |= HAL_UART_ERROR_PE;
}
tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_FE);
tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR);
/* UART frame error interrupt occurred -------------------------------------*/
if ((tmp_flag != RESET) && (tmp_it_source != RESET))
{
__HAL_UART_CLEAR_FEFLAG(huart);
huart->ErrorCode |= HAL_UART_ERROR_FE;
}
tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_NE);
/* UART noise error interrupt occurred -------------------------------------*/
if ((tmp_flag != RESET) && (tmp_it_source != RESET))
{
__HAL_UART_CLEAR_NEFLAG(huart);
huart->ErrorCode |= HAL_UART_ERROR_NE;
}
tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_ORE);
/* UART Over-Run interrupt occurred ----------------------------------------*/
if ((tmp_flag != RESET) && (tmp_it_source != RESET))
{
__HAL_UART_CLEAR_OREFLAG(huart);
huart->ErrorCode |= HAL_UART_ERROR_ORE;
}
tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE);
tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE);
/* UART in mode Receiver ---------------------------------------------------*/
if ((tmp_flag != RESET) && (tmp_it_source != RESET))
{
CommUartRxIrqProcess(huart);
}
tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_TXE);
tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_TXE);
/* UART in mode Transmitter ------------------------------------------------*/
if ((tmp_flag != RESET) && (tmp_it_source != RESET))
{
CommUartTxIrqProcess(huart);
}
tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_TC);
tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC);
/* UART in mode Transmitter end --------------------------------------------*/
if ((tmp_flag != RESET) && (tmp_it_source != RESET))
{
}
if (huart->ErrorCode != HAL_UART_ERROR_NONE)
{
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
HAL_UART_ErrorCallback(huart);
}
}
/**
* @brief This function handles UART interrupt request.
* @param huart: uart handle
* @retval None
*/
void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
{
/* UART parity error interrupt occurred -------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_PE) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF);
huart->ErrorCode |= HAL_UART_ERROR_PE;
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
}
/* UART frame error interrupt occured --------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
huart->ErrorCode |= HAL_UART_ERROR_FE;
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
}
/* UART noise error interrupt occured --------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_NE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF);
huart->ErrorCode |= HAL_UART_ERROR_NE;
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
}
/* UART Over-Run interrupt occured -----------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
huart->ErrorCode |= HAL_UART_ERROR_ORE;
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
}
/* Call UART Error Call back function if need be --------------------------*/
if(huart->ErrorCode != HAL_UART_ERROR_NONE)
{
HAL_UART_ErrorCallback(huart);
}
#if !defined(STM32F030x6) && !defined(STM32F030x8)
/* UART wakeup from Stop mode interrupt occurred -------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_WUF) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_WUF) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_WUF);
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
HAL_UART_WakeupCallback(huart);
}
#endif /* !defined(STM32F030x6) && !defined(STM32F030x8) */
/* UART in mode Receiver ---------------------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET))
{
UART_Receive_IT(huart);
/* Clear RXNE interrupt flag */
__HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
}
/* UART in mode Transmitter ------------------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) &&(__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET))
{
UART_Transmit_IT(huart);
}
}
