最近在把标准库的项目移植到HAL库中，同时使用freeRTOS进行任务管理，HAL库属于初学。
硬件：STM32F103RCT6+IRDA
简介：使用SMT32F103RCT6+IRDA模块作为上位机与STM32F103C8T6+IRDA下位机通过modbus通讯
软件：STM32CUBEIDE开发工具和生成的软件，freeRTOS

问题概要：正常运行时，收到命令A的回复，对回复进行解析后，再发送命令B，会出现命令发送失败的情况，但是单步调试时，发送可以成功，添加延时函数还是不行。

还请论坛各位同仁帮忙看看，提一下意见，谢谢

相关代码如下：

1. void HAL_IRDA_MspInit(IRDA_HandleTypeDef* irdaHandle)
   
2. {
   
3. 
   
4.   GPIO_InitTypeDef GPIO_InitStruct = {0};
   
5.   if(irdaHandle->Instance==USART1)
   
6.   {
   
7.   /* USER CODE BEGIN USART1_MspInit 0 */
   
8.   /* USER CODE END USART1_MspInit 0 */
   
9.     /* USART1 clock enable */
   
10.     __HAL_RCC_USART1_CLK_ENABLE();
    
11. 
    
12.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
13.     /**USART1 GPIO Configuration
    
14.     PA9     ------> USART1_TX
    
15.     PA10     ------> USART1_RX
    
16.     */
    
17.     GPIO_InitStruct.Pin = GPIO_PIN_9;
    
18.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
19.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    
20.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
21. 
    
22.     GPIO_InitStruct.Pin = GPIO_PIN_10;
    
23.     GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    
24.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
25.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
26. 
    
27.     /* USART1 DMA Init */
    
28.     /* USART1_RX Init */
    
29.     hdma_usart1_rx.Instance = DMA1_Channel5;
    
30.     hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    
31.     hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    
32.     hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
    
33.     hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    
34.     hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    
35.     hdma_usart1_rx.Init.Mode = DMA_NORMAL;
    
36.     hdma_usart1_rx.Init.Priority = DMA_PRIORITY_MEDIUM;
    
37.     if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
    
38.     {
    
39.       Error_Handler();
    
40.     }
    
41. 
    
42.     __HAL_LINKDMA(irdaHandle,hdmarx,hdma_usart1_rx);
    
43. 
    
44.     /* USART1_TX Init */
    
45.     hdma_usart1_tx.Instance = DMA1_Channel4;
    
46.     hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    
47.     hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    
48.     hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
    
49.     hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    
50.     hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    
51.     hdma_usart1_tx.Init.Mode = DMA_NORMAL;
    
52.     hdma_usart1_tx.Init.Priority = DMA_PRIORITY_MEDIUM;
    
53.     if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
    
54.     {
    
55.       Error_Handler();
    
56.     }
    
57. 
    
58.     __HAL_LINKDMA(irdaHandle,hdmatx,hdma_usart1_tx);
    
59.     /* USER CODE BEGIN USART1_MspInit 1 */
    
60.     HAL_IRDA_Receive_DMA(irdaHandle, irda1_rx_buffer, IRDA_UART_RX_SIZE);        //使能DMA接受，将接受到的数据放到irda1_rx_buffer
    
61.     /* USER CODE BEGIN USART1_MspInit 1 */
    
62. 
    
63.     /* USART1 interrupt Init */
    
64.     HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
    
65.     HAL_NVIC_EnableIRQ(USART1_IRQn);
    
66. 
    
67.   /* USER CODE BEGIN USART1_MspInit 1 */
    
68.     __HAL_UART_ENABLE_IT(irdaHandle, IRDA_IT_IDLE);                                                   //usart1, 使能空闲中断
    
69.                 __HAL_UART_CLEAR_IDLEFLAG(irdaHandle);
    
70.   /* USER CODE END USART1_MspInit 1 */
    
71.   }

复制代码

1. void USART1_IRQHandler(void)
   
2. {
   
3.   /* USER CODE BEGIN USART1_IRQn 0 */
   
4.         if (__HAL_UART_GET_FLAG(&hirda1, UART_FLAG_IDLE))
   
5.         {
   
6.                 __HAL_UART_CLEAR_IDLEFLAG(&hirda1);
   
7.                 HAL_IRDA_DMAStop (&hirda1);
   
8. 
   
9.                 irda1_data_cnt = IRDA_UART_RX_SIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   
10.                 if (irda1_data_cnt < 6)
    
11.                 {
    
12.                         print_hex(irda1_rx_buffer, irda1_data_cnt);
    
13.                 }
    
14.                 else
    
15.                 {
    
16.                         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
17.                         xEventGroupSetBitsFromISR (irda_event_gourpHandler,
    
18.                         EVENT_GROUP_BIT_IRDA1_DATA,
    
19.                                                                                                                                  &xHigherPriorityTaskWoken);
    
20.                 }
    
21. 
    
22.                 hdma_usart1_rx.Instance->CNDTR = IRDA_UART_RX_SIZE;
    
23.                 HAL_IRDA_Receive_DMA (&hirda1, irda1_rx_buffer, IRDA_UART_RX_SIZE);
    
24.         }
    
25.   /* USER CODE END USART1_IRQn 0 */
    
26.   HAL_IRDA_IRQHandler(&hirda1);
    
27.   /* USER CODE BEGIN USART1_IRQn 1 */
    
28. 
    
29.   /* USER CODE END USART1_IRQn 1 */
    
30. }

复制代码

1. void irda_modbus_parse_task(void const *argument)
   
2. {
   
3.         irda_event_gourpHandler = xEventGroupCreate();
   
4. 
   
5.         if(irda_event_gourpHandler == NULL)
   
6.         {
   
7.                 app_err("create irda_event_gourp fail!\r\n");
   
8.                 goto error;
   
9.         }
   
10. 
    
11.         xEventGroupClearBits(irda_event_gourpHandler, EVENT_GROUP_BIT_IRDA1_DATA|EVENT_GROUP_BIT_IRDA2_DATA);
    
12. 
    
13.         while(1)
    
14.         {
    
15.                 EventBits_t bits = xEventGroupWaitBits(irda_event_gourpHandler, EVENT_GROUP_BIT_IRDA1_DATA|EVENT_GROUP_BIT_IRDA2_DATA, pdFALSE, pdFALSE, portMAX_DELAY);
    
16. 
    
17.                 if(bits & EVENT_GROUP_BIT_IRDA1_DATA)
    
18.                 {
    
19.                         app_debug("irda1 recv data\r\n");
    
20.                         xEventGroupClearBits(irda_event_gourpHandler, EVENT_GROUP_BIT_IRDA1_DATA);
    
21.                         Modbus_Master_Service(irda1_rx_buffer, irda1_data_cnt, 1);
    
22.                         memset(irda1_rx_buffer, 0, sizeof(irda1_rx_buffer));
    
23.                 }
    
24.                 else if(bits & EVENT_GROUP_BIT_IRDA2_DATA)
    
25.                 {
    
26.                         app_debug("irda2 recv data\r\n");
    
27.                         xEventGroupClearBits(irda_event_gourpHandler, EVENT_GROUP_BIT_IRDA2_DATA);
    
28.                 }
    
29.                 else
    
30.                 {
    
31.                         xEventGroupClearBits(irda_event_gourpHandler, ~(EVENT_GROUP_BIT_IRDA1_DATA|EVENT_GROUP_BIT_IRDA2_DATA));
    
32.                         app_err("UNEXPECTED EVENT\r\n");
    
33.                 }
    
34.         }
    
35. 
    
36.         error:
    
37.         vEventGroupDelete(irda_event_gourpHandler);
    
38.         osThreadTerminate (irda_modbus_parseTaskHandle);
    
39. }

复制代码

1. void Modbus_SendData(uint8_t *buf, int len, char direction)
   
2. {
   
3.         int res  = 0;
   
4. 
   
5.          if(direction == 1)
   
6.          {
   
7.                  res = HAL_IRDA_Transmit_DMA(&hirda1, buf, len);
   
8.                  if(res != 0)
   
9.                  {
   
10.                          app_err("uart1 error: %d\r\n", res);
    
11.                  }
    
12.          }
    
13.          else if(direction == 2)
    
14.          {
    
15.                  HAL_IRDA_Transmit_DMA (&hirda2, buf, len);
    
16.          }
    
17.          else if(direction == 3)
    
18.          {
    
19.                  HAL_IRDA_Transmit_DMA (&hirda1, buf, len);
    
20.                  HAL_IRDA_Transmit_DMA (&hirda2, buf, len);
    
21.          }
    
22. }

复制代码

现象就是正常运行，命令A发送成功，收到回复，在解析回复并执行发送命令B后，出现B发送失败情况，且单步调试发送时，反而是正常的可以发送成功的

暂时搞定了，正在琢磨为什么，解决方法就是在串口发送数据前后各加20ms左右延时