HAL UART DMA 数据收发

UART使用DMA进行数据收发,实现功能，串口2发送指令到上位机，上位机返回数据给串口2，串口2收到数据后由串口1进行转发，该功能为实验功能

１、UART与DMA通道进行绑定

 void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
 {

     GPIO_InitTypeDef GPIO_InitStruct = {};
     if(uartHandle->Instance==USART1)
     {
         /* USER CODE BEGIN USART1_MspInit 0 */

         /* USER CODE END USART1_MspInit 0 */
         /* USART1 clock enable */
         __HAL_RCC_USART1_CLK_ENABLE();

         __HAL_RCC_GPIOA_CLK_ENABLE();
         /**USART1 GPIO Configuration
         PA9     ------> USART1_TX
         PA10     ------> USART1_RX
         */
         GPIO_InitStruct.Pin = GPIO_PIN_9;
         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

         GPIO_InitStruct.Pin = GPIO_PIN_10;
         GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
         GPIO_InitStruct.Pull = GPIO_NOPULL;
         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

         /* USART1 DMA Init */
         /* USART1_TX Init */
         hdma_usart1_tx.Instance = DMA1_Channel4;
         hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
         hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
         hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
         hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
         hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
         hdma_usart1_tx.Init.Mode = DMA_NORMAL;
         hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;
         if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
         {
             Error_Handler();
         }

         __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart1_tx);

         /* USART1 interrupt Init */
         HAL_NVIC_SetPriority(USART1_IRQn, , );
         HAL_NVIC_EnableIRQ(USART1_IRQn);
         /* USER CODE BEGIN USART1_MspInit 1 */

         /* USER CODE END USART1_MspInit 1 */
     }
     else if(uartHandle->Instance==USART2)
     {
         /* USER CODE BEGIN USART2_MspInit 0 */

         /* USER CODE END USART2_MspInit 0 */
         /* USART2 clock enable */
         __HAL_RCC_USART2_CLK_ENABLE();

         __HAL_RCC_GPIOA_CLK_ENABLE();
         /**USART2 GPIO Configuration
         PA2     ------> USART2_TX
         PA3     ------> USART2_RX
         */
         GPIO_InitStruct.Pin = GPIO_PIN_2;
         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

         GPIO_InitStruct.Pin = GPIO_PIN_3;
         GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
         GPIO_InitStruct.Pull = GPIO_NOPULL;
         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

         /* USART2 DMA Init */
         /* USART2_RX Init */
         hdma_usart2_rx.Instance = DMA1_Channel6;
         hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
         hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
         hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;
         hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
         hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
         hdma_usart2_rx.Init.Mode = DMA_NORMAL;
         hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW;
         if (HAL_DMA_Init(&hdma_usart2_rx) != HAL_OK)
         {
             Error_Handler();
         }

         __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart2_rx);

         /* USART2_TX Init */
         hdma_usart2_tx.Instance = DMA1_Channel7;
         hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
         hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
         hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;
         hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
         hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
         hdma_usart2_tx.Init.Mode = DMA_NORMAL;
         hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;
         if (HAL_DMA_Init(&hdma_usart2_tx) != HAL_OK)
         {
             Error_Handler();
         }

         __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart2_tx);

         /* USART2 interrupt Init */
         HAL_NVIC_SetPriority(USART2_IRQn, , );
         HAL_NVIC_EnableIRQ(USART2_IRQn);
         /* USER CODE BEGIN USART2_MspInit 1 */

         /* USER CODE END USART2_MspInit 1 */
     }
 }

__HAL_LINKDMA(uartHandle,hdmarx,hdma_usartx_xx)为UART与DMA绑定核心代码

２、数据发送与接收

2.1 DMA中断进行数据收发

2.1.1　DMA中断

在HAL使用DMA方式进行串口数据传输时,DMA全局中断模式是必需打开的，因此在DMA方式进行数据传输时（收，发），在数据传输过半，完成均会触发DMA中断

void DMA1_Channel6_IRQHandler(void)
{
    /* USER CODE BEGIN DMA1_Channel6_IRQn 0 */

    /* USER CODE END DMA1_Channel6_IRQn 0 */
    HAL_DMA_IRQHandler(&hdma_usart2_rx);
    /* USER CODE BEGIN DMA1_Channel6_IRQn 1 */

    /* USER CODE END DMA1_Channel6_IRQn 1 */
}

/**
  * @brief This function handles DMA1 channel7 global interrupt.
  */
void DMA1_Channel7_IRQHandler(void)
{
    /* USER CODE BEGIN DMA1_Channel7_IRQn 0 */

    /* USER CODE END DMA1_Channel7_IRQn 0 */
    HAL_DMA_IRQHandler(&hdma_usart2_tx);
    /* USER CODE BEGIN DMA1_Channel7_IRQn 1 */

    /* USER CODE END DMA1_Channel7_IRQn 1 */
}

HAL_DMA_IRQHandler(&hdma_usart2_tx)会根据中断标识,调用传输过半/完成/错误,回调函数,如下: 

void HAL_DMA_IRQHandler(DMA_HandleTypeDef *hdma)
{
  uint32_t flag_it = hdma->DmaBaseAddress->ISR;
  uint32_t source_it = hdma->Instance->CCR;

  /* Half Transfer Complete Interrupt management ******************************/
  if (((flag_it & (DMA_FLAG_HT1 << hdma->ChannelIndex)) != RESET) && ((source_it & DMA_IT_HT) != RESET))
  {
    /* Disable the half transfer interrupt if the DMA mode is not CIRCULAR */
    if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
    {
      /* Disable the half transfer interrupt */
      __HAL_DMA_DISABLE_IT(hdma, DMA_IT_HT);
    }
    /* Clear the half transfer complete flag */
    __HAL_DMA_CLEAR_FLAG(hdma, __HAL_DMA_GET_HT_FLAG_INDEX(hdma));

    /* DMA peripheral state is not updated in Half Transfer */
    /* but in Transfer Complete case */

    if(hdma->XferHalfCpltCallback != NULL)
    {
      /* Half transfer callback */
      hdma->XferHalfCpltCallback(hdma);//DMA传输过半回调
    }
  }

  /* Transfer Complete Interrupt management ***********************************/
  else if (((flag_it & (DMA_FLAG_TC1 << hdma->ChannelIndex)) != RESET) && ((source_it & DMA_IT_TC) != RESET))
  {
    if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
    {
      /* Disable the transfer complete and error interrupt */
      __HAL_DMA_DISABLE_IT(hdma, DMA_IT_TE | DMA_IT_TC);  

      /* Change the DMA state */
      hdma->State = HAL_DMA_STATE_READY;
    }
    /* Clear the transfer complete flag */
      __HAL_DMA_CLEAR_FLAG(hdma, __HAL_DMA_GET_TC_FLAG_INDEX(hdma));

    /* Process Unlocked */
    __HAL_UNLOCK(hdma);

    if(hdma->XferCpltCallback != NULL)
    {
      /* Transfer complete callback */
      hdma->XferCpltCallback(hdma);//DMA传输完成回调
    }
  }

  /* Transfer Error Interrupt management **************************************/
  else if (( RESET != (flag_it & (DMA_FLAG_TE1 << hdma->ChannelIndex))) && (RESET != (source_it & DMA_IT_TE)))
  {
    /* When a DMA transfer error occurs */
    /* A hardware clear of its EN bits is performed */
    /* Disable ALL DMA IT */
    __HAL_DMA_DISABLE_IT(hdma, (DMA_IT_TC | DMA_IT_HT | DMA_IT_TE));

    /* Clear all flags */
    hdma->DmaBaseAddress->IFCR = (DMA_ISR_GIF1 << hdma->ChannelIndex);

    /* Update error code */
    hdma->ErrorCode = HAL_DMA_ERROR_TE;

    /* Change the DMA state */
    hdma->State = HAL_DMA_STATE_READY;

    /* Process Unlocked */
    __HAL_UNLOCK(hdma);

    if (hdma->XferErrorCallback != NULL)
    {
      /* Transfer error callback */
      hdma->XferErrorCallback(hdma);//传输错误回调
    }
  }
  return;
}

DMA传输中断的回调函数是在哪被设置的呢?被这个问题困扰了几个小时,原来是在DMA发送／接收数据函数中默认设置的,如下:

HAL_UART_Transmit_DMA(&huart2,cmd1,);

HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  uint32_t *tmp;

  /* 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->pTxBuffPtr = pData;
    huart->TxXferSize = Size;
    huart->TxXferCount = Size;

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

    /* Set the UART DMA transfer complete callback */
    huart->hdmatx->XferCpltCallback = UART_DMATransmitCplt;

    /* Set the UART DMA Half transfer complete callback */
    huart->hdmatx->XferHalfCpltCallback = UART_DMATxHalfCplt;

    /* Set the DMA error callback */
    huart->hdmatx->XferErrorCallback = UART_DMAError;

    /* Set the DMA abort callback */
    huart->hdmatx->XferAbortCallback = NULL;

    /* Enable the UART transmit DMA channel */
    tmp = (uint32_t *)&pData;
    HAL_DMA_Start_IT(huart->hdmatx, *(uint32_t *)tmp, (uint32_t)&huart->Instance->DR, Size);

    /* Clear the TC flag in the SR register by writing 0 to it */
    __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);

    /* Process Unlocked */
    __HAL_UNLOCK(huart);

    /* Enable the DMA transfer for transmit request by setting the DMAT bit
       in the UART CR3 register */
    SET_BIT(huart->Instance->CR3, USART_CR3_DMAT);

    return HAL_OK;
  }
  else
  {
    return HAL_BUSY;
  }
}

HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  uint32_t *tmp;

  /* 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->ErrorCode = HAL_UART_ERROR_NONE;
    huart->RxState = HAL_UART_STATE_BUSY_RX;

    /* Set the UART DMA transfer complete callback */
    huart->hdmarx->XferCpltCallback = UART_DMAReceiveCplt;

    /* Set the UART DMA Half transfer complete callback */
    huart->hdmarx->XferHalfCpltCallback = UART_DMARxHalfCplt;

    /* Set the DMA error callback */
    huart->hdmarx->XferErrorCallback = UART_DMAError;

    /* Set the DMA abort callback */
    huart->hdmarx->XferAbortCallback = NULL;

    /* Enable the DMA channel */
    tmp = (uint32_t *)&pData;
    HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->DR, *(uint32_t *)tmp, Size);

    /* Clear the Overrun flag just before enabling the DMA Rx request: can be mandatory for the second transfer */
    __HAL_UART_CLEAR_OREFLAG(huart);

    /* Process Unlocked */
    __HAL_UNLOCK(huart);

    /* Enable the UART Parity Error Interrupt */
    SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);

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

    /* Enable the DMA transfer for the receiver request by setting the DMAR bit
    in the UART CR3 register */
    SET_BIT(huart->Instance->CR3, USART_CR3_DMAR);

    return HAL_OK;
  }
  else
  {
    return HAL_BUSY;
  }
}

就是说:只要你使用DMA发送／接收数据,就会自动设置DMA中断回调函数,