Cubemx与HAL库系列教程|串口DMA收发详解

/** @defgroup DMA_Exported_Types DMA Exported Types
  * @{
  */

/**
  * @brief  DMA Configuration Structure definition
  */
typedef struct
{
  uint32_t Direction;                 /*!< Specifies if the data will be transferred from memory to peripheral, 
                                           from memory to memory or from peripheral to memory.
                                           This parameter can be a value of @ref DMA_Data_transfer_direction */

  uint32_t PeriphInc;                 /*!< Specifies whether the Peripheral address register should be incremented or not.
                                           This parameter can be a value of @ref DMA_Peripheral_incremented_mode */

  uint32_t MemInc;                    /*!< Specifies whether the memory address register should be incremented or not.
                                           This parameter can be a value of @ref DMA_Memory_incremented_mode */

  uint32_t PeriphDataAlignment;       /*!< Specifies the Peripheral data width.
                                           This parameter can be a value of @ref DMA_Peripheral_data_size */

  uint32_t MemDataAlignment;          /*!< Specifies the Memory data width.
                                           This parameter can be a value of @ref DMA_Memory_data_size */

  uint32_t Mode;                      /*!< Specifies the operation mode of the DMAy Channelx.
                                           This parameter can be a value of @ref DMA_mode
                                           @note The circular buffer mode cannot be used if the memory-to-memory
                                                 data transfer is configured on the selected Channel */

  uint32_t Priority;                  /*!< Specifies the software priority for the DMAy Channelx.
                                           This parameter can be a value of @ref DMA_Priority_level */
} DMA_InitTypeDef;

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  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 = User_UART_TX_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(User_UART_TX_GPIO_Port, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = User_UART_RX_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(User_UART_RX_GPIO_Port, &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_CIRCULAR;
    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_MEDIUM;
    if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart1_tx);

    /* USART1_RX Init */
    hdma_usart1_rx.Instance = DMA1_Channel5;
    hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_rx.Init.Mode = DMA_CIRCULAR;
    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_MEDIUM;
    if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx);

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

  /* USER CODE END USART1_MspInit 1 */
  }
}

/******************************************************
* Brief     : DMA传输函数
* Parameter : 
*           *pData: 要传输的数据
* Return    : None.
*******************************************************/
void User_uartdma_Transmit(const char *pData)
{ 
 HAL_UART_Transmit_DMA(&huart1,(uint8_t *)pData,strlen(pData));
}

/******************************************************
* Brief     : 串口DMA 初始化，初始化除了cubemx配置之外的部分
* Parameter : 
*           : 
* Return    : None.
*******************************************************/
void User_uartdma_Init(void)
{
 //失能串口DMA传输
 HAL_UART_DMAStop(&huart1);
 //使能串口1接收中断
 __HAL_UART_ENABLE_IT(&huart1,UART_IT_RXNE);
 //使能串口1空闲中断
 __HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);
 //使能串口DMA接收
 HAL_UART_Receive_DMA(&huart1,UserUartDma.RxBuffer,Max_RecLen);
}

/**
  * @brief  DMA接收函数
  * @param  htim TIM Base handle
  * @retval HAL status
  */
void User_uartdma_Receive(uint8_t *recData,uint16_t rec_len)
{
 HAL_UART_Receive_DMA(&huart1,recData,rec_len);
}

/**
  * @brief This function handles USART1 global interrupt.
  */
void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */
 uint32_t idle_flag_temp = 0;
 uint16_t len_temp = 0;
  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */
 idle_flag_temp = __HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE);
 
 if(idle_flag_temp)
 {
  __HAL_UART_CLEAR_FLAG(&huart1,UART_FLAG_IDLE);
  HAL_UART_DMAStop(&huart1);
  
  len_temp = __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
  
  UserUartDma.RecDat_len = Max_RecLen - len_temp;  
  UserUartDma.rec_endFlag = 1;
  
 }
  __HAL_UART_ENABLE_IT(&huart1,UART_IT_RXNE);
  HAL_UART_Receive_DMA(&huart1,UserUartDma.RxBuffer,Max_RecLen);  
  /* USER CODE END USART1_IRQn 1 */
}

 while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  if(UserUartDma.rec_endFlag)
  {
   UserUartDma.rec_endFlag = 0;
   User_uart_Transmit((char *)UserUartDma.RxBuffer);
   
   memset(UserUartDma.RxBuffer,0,UserUartDma.RecDat_len);
   UserUartDma.RecDat_len = 0;
  }
//  if(__HAL_DMA_GET_FLAG(&huart1,DMA_FLAG_TC4))
//  {
//   memset(UserUartDma.RxBuffer,0,UserUartDma.RecDat_len);
//   UserUartDma.RecDat_len = 0;
//   
//   HAL_UART_DMAStop(&huart1);
//  }  
  }