STM32 HAL库串口库分析

这里不对基本操作分析，仅仅讨论一种方式，能让我们稳定的用串口，本文会对HAL库进行些微的修改。

HAL库的串口大致可以分解为2个部分，一个是寄存器控制部分，一个是数据传输部分。我接下来的只修改寄存器控制部分一点点内容，数据传输部分不变，任然采用其回调函数形式，下面具体说明。

一般来说最常用的是发送数据HAL_UART_Transmit，中断接收数据HAL_UART_Transmit_IT。串口其余，如DMA什么的不做分析。

研究一下会发现，HAL库中强制对串口进行了半双工限制，其实STM32的串口是全双工的，很多时候卡死，是因为我们做了全双工操作导致的卡死,卡死在HAL_LOCK(huart),HAL_UART_Transmit是阻塞是调用,阻塞中收到中断后就会卡死,可以用HAL_UART_Transmit_IT和HAL_UART_Transmit_IT成对处理,这样程序逻辑会更复杂，一定要实现处理收发传输完成回调函数

20220301添加："修改过后的库BUG依然存在，不过概率小很多，如果跑了OS建议还是成对使用收发API，实践起来也不是很复杂，构造收发fifo即可，如果跑裸机，实现起来稍微困难"

HAL_UART_Transmit修改后如下，

HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
{
  uint16_t* tmp;
  uint32_t tickstart = 0U;

  /* Check that a Tx process is not already ongoing */
//  if(huart->gState == HAL_UART_STATE_READY)
  {
    if((pData == NULL ) || (Size == 0U))
    {
      return  HAL_ERROR;
    }

    /* Process Locked */
   // __HAL_LOCK(huart);

    huart->ErrorCode = HAL_UART_ERROR_NONE;
    huart->gState = HAL_UART_STATE_BUSY_TX;

    /* Init tickstart for timeout managment*/
    tickstart = HAL_GetTick();

    huart->TxXferSize = Size;
    huart->TxXferCount = Size;
    while(huart->TxXferCount > 0U)
    {
      huart->TxXferCount--;
      if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
      {
        return HAL_TIMEOUT;
      }
      if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
      {
        tmp = (uint16_t*) pData;
        huart->Instance->TDR = (*tmp & (uint16_t)0x01FFU);
        pData += 2;
      }
      else
      {
        huart->Instance->TDR = (*pData++ & (uint8_t)0xFFU);
      }
    }
    if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    {
      return HAL_TIMEOUT;
    }

    /* At end of Tx process, restore huart->gState to Ready */
    huart->gState = HAL_UART_STATE_READY;

    /* Process Unlocked */
   // __HAL_UNLOCK(huart);

    return HAL_OK;
  }
//  else
//  {
//    return HAL_BUSY;
//  }
}

HAL_UART_Receive_IT修改如下，除了祛除限制，还屏蔽了中断使能，这个后面再说原因

HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  /* Check that a Rx process is not already ongoing */
 // if(huart->RxState == HAL_UART_STATE_READY)
  {
    if((pData == NULL ) || (Size == 0U))
    {
      return HAL_ERROR;
    }

    /* Process Locked */
   // __HAL_LOCK(huart);

    huart->pRxBuffPtr = pData;
    huart->RxXferSize = Size;
    huart->RxXferCount = Size;

    /* Computation of UART mask to apply to RDR register */
    UART_MASK_COMPUTATION(huart);

    huart->ErrorCode = HAL_UART_ERROR_NONE;
    huart->RxState = HAL_UART_STATE_BUSY_RX;

    /* Process Unlocked */
  //  __HAL_UNLOCK(huart);

    /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
   // SET_BIT(huart->Instance->CR3, USART_CR3_EIE);

    /* Enable the UART Parity Error and Data Register not empty Interrupts */
  //  SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);

    return HAL_OK;
  }
//  else
//  {
//    return HAL_BUSY;
//  }
}

接收中断，屏蔽了清除中断的两行，中断开启后就不再清除了

static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
{
  uint16_t* tmp;
  uint16_t uhMask = huart->Mask;

  /* Check that a Rx process is ongoing */
  if(huart->RxState == HAL_UART_STATE_BUSY_RX)
  {

    if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    {
      tmp = (uint16_t*) huart->pRxBuffPtr ;
      *tmp = (uint16_t)(huart->Instance->RDR & uhMask);
      huart->pRxBuffPtr +=2;
    }
    else
    {
      *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->RDR & (uint8_t)uhMask);
    }

    if(--huart->RxXferCount == 0)
    {
      /* Disable the UART Parity Error Interrupt and RXNE interrupt*/
   //   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));

      /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
   //   CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);

      /* Rx process is completed, restore huart->RxState to Ready */
      huart->RxState = HAL_UART_STATE_READY;

      HAL_UART_RxCpltCallback(huart);

      return HAL_OK;
    }

    return HAL_OK;
  }
  else
  {
    /* Clear RXNE interrupt flag */
    __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);

    return HAL_BUSY;
  }
}

在usart.c添加如下代码，

StartUART_Rx：开启中断，同时开启HAL数据流。本来调用HAL_UART_Receive_IT会重新开启中断，不过前面我把它屏蔽了，这样，这里初始化开一次就行了，上面关中断已经屏蔽了

HAL_UART_RxCpltCallback:接收中断回调函数

HAL_UART_ErrorCallback:错误中断回调函数

/* USER CODE BEGIN 1 */
uint8_t a=0;
void (*UART3_Callback)(uint8_t)=NULL;
void StartUART_Rx(UART_HandleTypeDef *uartHandle)
{
	if(uartHandle->Instance==USART3)
	{
		if(HAL_OK!=HAL_UART_Receive_IT(uartHandle,&a,1))
		{
			assert("HAL_UART_Receive_IT",__FILE__,__LINE__);
		}	
		SET_BIT(uartHandle->Instance->CR3, USART_CR3_EIE);	
		SET_BIT(uartHandle->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);		
	}
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *uartHandle)
{
	if(uartHandle->Instance==USART3)
	{
		if(UART3_Callback!=NULL)
		{
			UART3_Callback(a);
		}
		if(HAL_OK!=HAL_UART_Receive_IT(uartHandle,&a,1))
		{
			assert("HAL_UART_Receive_IT",__FILE__,__LINE__);
		}			
	}
}
void HAL_UART_ErrorCallback(UART_HandleTypeDef *uartHandle)
{
	uartHandle->RxState = HAL_UART_STATE_READY;
	if(uartHandle->Instance==USART3)
	{
		if(HAL_OK!=HAL_UART_Receive_IT(uartHandle,&a,1))
		{
			assert("HAL_UART_Receive_IT",__FILE__,__LINE__);
		}
	}
}



/* USER CODE END 1 */

基本这样改就能应付大部分应用了，

当然有另外一种方式，就是开一个检测任务，定期检测串口状态，如果发现串口卡死，则重新初始化即可。