• STM32 HAL 用DMA+空闲中断接收不定长数据

    1. static uint8_t   Rxd1Data[512];
    2. static uint16_t  Tx_length;
    1. void MX_USART1_UART_Init(void)
    2. {
    3.  
    4.   /* USER CODE BEGIN USART1_Init 0 */
    5.  
    6.   /* USER CODE END USART1_Init 0 */
    7.  
    8.   /* USER CODE BEGIN USART1_Init 1 */
    9.  
    10.   /* USER CODE END USART1_Init 1 */
    11.   huart1.Instance = USART1;
    12.   huart1.Init.BaudRate = 115200;
    13.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
    14.   huart1.Init.StopBits = UART_STOPBITS_1;
    15.   huart1.Init.Parity = UART_PARITY_NONE;
    16.   huart1.Init.Mode = UART_MODE_TX_RX;
    17.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    18.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    19.   if (HAL_UART_Init(&huart1) != HAL_OK)
    20.   {
    21.     Error_Handler();
    22.   }
    23.   /* USER CODE BEGIN USART1_Init 2 */
    24.  
    25.   /* USER CODE END USART1_Init 2 */
    26.  
    27. }
    1. void MX_USART2_UART_Init(void)
    2. {
    3.  
    4.   /* USER CODE BEGIN USART2_Init 0 */
    5.  
    6.   /* USER CODE END USART2_Init 0 */
    7.  
    8.   /* USER CODE BEGIN USART2_Init 1 */
    9.  
    10.   /* USER CODE END USART2_Init 1 */
    11.   huart2.Instance = USART2;
    12.   huart2.Init.BaudRate = 115200;
    13.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
    14.   huart2.Init.StopBits = UART_STOPBITS_1;
    15.   huart2.Init.Parity = UART_PARITY_NONE;
    16.   huart2.Init.Mode = UART_MODE_TX_RX;
    17.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    18.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    19.   if (HAL_UART_Init(&huart2) != HAL_OK)
    20.   {
    21.     Error_Handler();
    22.   }
    23.   /* USER CODE BEGIN USART2_Init 2 */
    24.  
    25.   /* USER CODE END USART2_Init 2 */
    26.  
    27. }
    1. if(uartHandle->Instance==USART1)
    2.   {
    3.   /* USER CODE BEGIN USART1_MspInit 0 */
    4.  
    5.   /* USER CODE END USART1_MspInit 0 */
    6.     /* USART1 clock enable */
    7.     __HAL_RCC_USART1_CLK_ENABLE();
    8.  
    9.     __HAL_RCC_GPIOA_CLK_ENABLE();
    10.     /**USART1 GPIO Configuration
    11.     PA9     ------> USART1_TX
    12.     PA10     ------> USART1_RX
    13.     */
    14.     GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;
    15.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    16.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    17.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    18.     GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    19.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    20.  
    21.     /* USART1 DMA Init */
    22.     /* USART1_TX Init */
    23.     hdma_usart1_tx.Instance = DMA2_Stream7;
    24.     hdma_usart1_tx.Init.Channel = DMA_CHANNEL_4;
    25.     hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    26.     hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    27.     hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
    28.     hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    29.     hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    30.     hdma_usart1_tx.Init.Mode = DMA_NORMAL;
    31.     hdma_usart1_tx.Init.Priority = DMA_PRIORITY_HIGH;
    32.     hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    33.     if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
    34.     {
    35.       Error_Handler();
    36.     }
    37.  
    38.     __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart1_tx);
    39.  
    40.     /* USART1_RX Init */
    41.     hdma_usart1_rx.Instance = DMA2_Stream2;
    42.     hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4;
    43.     hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    44.     hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    45.     hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
    46.     hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    47.     hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    48.     hdma_usart1_rx.Init.Mode = DMA_NORMAL;
    49.     hdma_usart1_rx.Init.Priority = DMA_PRIORITY_HIGH;
    50.     hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    51.     if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
    52.     {
    53.       Error_Handler();
    54.     }
    55.  
    56.     __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx);
    57.  
    58.     /* USART1 interrupt Init */
    59.     HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
    60.     HAL_NVIC_EnableIRQ(USART1_IRQn);
    61.   /* USER CODE BEGIN USART1_MspInit 1 */
    62.     
    63.     UART_Start_Receive_DMA(&huart1, Rxd1Data, 512);
    64.     
    65.     __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    66.     
    67.  
    68.     
    69.     
    70.  
    71.   /* USER CODE END USART1_MspInit 1 */
    72.   }
    73.   else if(uartHandle->Instance==USART2)
    74.   {
    75.   /* USER CODE BEGIN USART2_MspInit 0 */
    76.  
    77.   /* USER CODE END USART2_MspInit 0 */
    78.     /* USART2 clock enable */
    79.     __HAL_RCC_USART2_CLK_ENABLE();
    80.  
    81.     __HAL_RCC_GPIOD_CLK_ENABLE();
    82.     /**USART2 GPIO Configuration
    83.     PD5     ------> USART2_TX
    84.     PD6     ------> USART2_RX
    85.     */
    86.     GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6;
    87.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    88.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    89.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    90.     GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
    91.     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    92.  
    93.     /* USART2 DMA Init */
    94.     /* USART2_RX Init */
    95.     hdma_usart2_rx.Instance = DMA1_Stream5;
    96.     hdma_usart2_rx.Init.Channel = DMA_CHANNEL_4;
    97.     hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    98.     hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    99.     hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;
    100.     hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    101.     hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    102.     hdma_usart2_rx.Init.Mode = DMA_NORMAL;
    103.     hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW;
    104.     hdma_usart2_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    105.     if (HAL_DMA_Init(&hdma_usart2_rx) != HAL_OK)
    106.     {
    107.       Error_Handler();
    108.     }
    109.  
    110.     __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart2_rx);
    111.  
    112.     /* USART2_TX Init */
    113.     hdma_usart2_tx.Instance = DMA1_Stream6;
    114.     hdma_usart2_tx.Init.Channel = DMA_CHANNEL_4;
    115.     hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    116.     hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    117.     hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;
    118.     hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    119.     hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    120.     hdma_usart2_tx.Init.Mode = DMA_NORMAL;
    121.     hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;
    122.     hdma_usart2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    123.     if (HAL_DMA_Init(&hdma_usart2_tx) != HAL_OK)
    124.     {
    125.       Error_Handler();
    126.     }
    127.  
    128.     __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart2_tx);
    129.  
    130.     /* USART2 interrupt Init */
    131.     HAL_NVIC_SetPriority(USART2_IRQn, 5, 0);
    132.     HAL_NVIC_EnableIRQ(USART2_IRQn);
    133.   /* USER CODE BEGIN USART2_MspInit 1 */
    134.  
    135.   /* USER CODE END USART2_MspInit 1 */
    136.   }

    这里的 这二行比较关键， 

    第一：是禁止DMA 这里才能设置DNTR. 

    第二：还必须等待设置成功  里面有这么一句

     while((hdma->Instance->CR & DMA_SxCR_EN) != RESET){};

    /* Clear all interrupt flags at correct offset within the register */
        regs->IFCR = 0x3FU << hdma->StreamIndex;

    如果不要HAL_DMA_Abort（），测试发现  发二帧，第一帧会收不到，第二帧可以。

                HAL_DMA_Abort(huart->hdmarx);  //__HAL_DMA_DISABLE(huart->hdmarx);

                __HAL_DMA_SET_COUNTER(huart->hdmarx, 512);  

    下面实现一个UART1接收  UART2 转发出去。

    1. void HAL_UART_RxIdleCallback(UART_HandleTypeDef *huart)
    2. {
    3.     if (huart->Instance == USART1)
    4.     {
    5.         if (huart->ErrorCode == HAL_UART_ERROR_NONE)
    6.         {
    7.             Tx_length = 512 - __HAL_DMA_GET_COUNTER(huart->hdmarx);
    8.             
    9.             HAL_UART_Transmit_DMA(&huart2, Rxd1Data, Tx_length);
    10.             
    11.             
    12.             //__HAL_DMA_DISABLE(huart->hdmarx);
    13.             HAL_DMA_Abort(huart->hdmarx);
    14.             
    15.             __HAL_DMA_SET_COUNTER(huart->hdmarx, 512);            
    16.             
    17.             UART_Start_Receive_DMA(huart, Rxd1Data, 512);
    18.         }
    19.     }
    20. }

     

  • 相关阅读:
    算法与数据结构 --- 栈的表示和操作的实现
    CommonAPI SomeIP Runtime 交叉编译
    YoloV8改进策略：Inner-IoU+clou，YoloV8的涨点明珠
    一分钟学习数据安全—自主管理身份SSI可验证凭证
    MybatisPlus
    Eureka的Ribbon负载均衡
    Flex 布局项目实战，好像没那么难！
    RTU远程终端控制系统S274
    SQL行列转换
    企业IP地址管理（IPAM）
  • 原文地址：https://blog.csdn.net/eydj2008/article/details/125556296