更新：

1、接收部分函数封装与精简；
2、透传逻辑调整；

App/MODBUS/Inc/modbus_485.h

@@ -3,6 +3,11 @@
 
 #include "apps_gather.h"
 
+#define TRANSPARENT_WAIT 0
+#define TRANSPARENT_RECIEVE_START 1
+#define TRANSPARENT_RECIEVE_FINISHED 2
+#define TRANSPARENT_TRANSMIT_END 3
+
 extern uint32_t tick_start;
 extern uint32_t tick_middle;
 extern uint32_t tick_end;
@@ -36,4 +41,6 @@ void trans_modbus_sig2slave(void);
 //该函数放置于TIM2的中断内，1ms为周期，尝试捕获前3帧
 void trans_start_capture(void);
 
+uint8_t trans_enable_check(st_scom *scom);
+
 #endif

App/MODBUS/Src/modbus_485.c

@@ -154,6 +154,7 @@ void transparent_tim(void)
         default:
         break;
     }
+
 }
 
 void trans_hart2pc(void)
@@ -303,9 +304,9 @@ void trans_start_capture(void)
     {
         if(tabdata.hart_enable)
         {
-            if (st_flag == 0)
+            if (st_flag == TRANSPARENT_WAIT)
             {
-                st_flag = 1;
+                st_flag = TRANSPARENT_RECIEVE_START;
                 tick_start = xTaskGetTickCountFromISR();
             }
         }
@@ -315,9 +316,9 @@ void trans_start_capture(void)
     {
         if(tabdata.bluetooth_enable)
         {
-            if (st_flag == 0)
+            if (st_flag == TRANSPARENT_WAIT)
             {
-                st_flag = 1;
+                st_flag = TRANSPARENT_RECIEVE_START;
                 tick_start = xTaskGetTickCountFromISR();
             }
         }
@@ -327,13 +328,55 @@ void trans_start_capture(void)
     {
         if(tabdata.hart_enable||tabdata.bluetooth_enable||tabdata.modbus_enable)
         {
-            if (st_flag == 0)
+            if (st_flag == TRANSPARENT_WAIT)
             {
-                st_flag = 1;
+                st_flag = TRANSPARENT_RECIEVE_START;
                 tick_start = xTaskGetTickCountFromISR();
             }
         }
     }
 }
 
+uint8_t trans_enable_check(st_scom *scom)
+{
+    uint8_t result = 0;
 
+    if( scom == &scom1_hart )
+    {
+        if(tabdata.hart_enable)
+        {
+            result = 1;
+            sig_trans = TRANS_HART_TO_PC;
+        }
+    }
+
+    if( scom == &scom6_ble )
+    {
+        if(tabdata.bluetooth_enable)
+        {
+            result = 1;
+            sig_trans = TRANS_BLE_TO_PC;
+        }
+    }
+
+    if( scom == &scom2_rs485 )
+    {
+        if(tabdata.hart_enable)
+        {
+            result = 1;
+            sig_trans = TRANS_PC_TO_HART;
+        }
+        else if(tabdata.bluetooth_enable)
+        {
+            result = 1;
+            sig_trans = TRANS_PC_TO_BLE;
+        }
+        else if(tabdata.modbus_enable)
+        {
+            result = 1;
+            sig_trans = TRANS_MODBUS_PC_TO_SIG;
+        }
+    }
+
+    return result;
+}

Core/Src/main.c

@@ -222,13 +222,12 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
 
   if (htim->Instance == TIM2)
   {
-    //无通讯的情况下直接返回，或者对DMA的起始时刻尝试进行捕获
+    //无通讯的情况下直接返回，开启DMA时尝试对第1~3个字节的数据进行捕获
     if(sig_trans == TRANS_NONE)
     {
       #if RX_DMA_ENABLE
         trans_start_capture();
       #endif
-
       return;
     }
 

Core/Src/stm32f4xx_it.c

@@ -436,6 +436,16 @@ void USART6_IRQHandler(void)
 /* USER CODE BEGIN 1 */
 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
 {
+  //记录发送完成的时间点
+  st_flag = TRANSPARENT_TRANSMIT_END;
+  tick_end = xTaskGetTickCountFromISR();
+
+  //计算延迟，捕获失败时清零（速度过快，小于1ms）
+  trans_log_rx = tick_middle - tick_start;
+  trans_log_tx = tick_end - tick_middle;
+  if(trans_log_rx > 1000) trans_log_rx = 0;
+  if(trans_log_tx > 1000) trans_log_tx = 0;
+
   //发送完成后将相关数组清零
   if(huart == &huart1)
   {
@@ -444,21 +454,32 @@ void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
     
     memset(scom1_hart.tx_buff, 0, scom1_hart.tx_len);
     scom1_hart.tx_len = 0;
+
+    //PC--->SIG--->HART，重新开启485的DMA
+    HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
   }
 
   if(huart == &huart2)
   {
     memset(scom2_rs485.tx_buff, 0, scom2_rs485.tx_len);
     scom2_rs485.tx_len = 0;
+
+    //开启对应的DMA
+    if(sig_trans == TRANS_HART_TO_PC) HAL_UART_Receive_DMA(&huart1, scom1_hart.rx_buff, BUFFER_SIZE);
+    if(sig_trans == TRANS_BLE_TO_PC) HAL_UART_Receive_DMA(&huart6, scom6_ble.rx_buff, BUFFER_SIZE);
+    if(sig_trans == TRANS_MODBUS_PC_TO_SIG) HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
   }
 
   if(huart == &huart6)
   {
     memset(scom6_ble.tx_buff, 0, scom6_ble.tx_len);
     scom6_ble.tx_len = 0;
+
+    //PC--->SIG--->BLE，重新开启485的DMA
+    HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
   }
 
-  //接收完成后通讯模式清空，等待下一次接收
+  //通讯模式清空，等待下一次接收
   sig_trans = TRANS_NONE;
 
   //如果显示任务被挂起，则在此处释放（无DMA的情况）
@@ -468,16 +489,6 @@ void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
     xTaskResumeFromISR(task_menuHandle);
     screen_suspend_flag = 0;
   }
-
-  //记录发送完成的时间点
-  st_flag = 3;
-  tick_end = xTaskGetTickCountFromISR();
-
-  //计算延迟，捕获失败时清零（速度过快，小于1ms）
-  trans_log_rx = tick_middle - tick_start;
-  trans_log_tx = tick_end - tick_middle;
-  if(trans_log_rx > 1000) trans_log_rx = 0;
-  if(trans_log_tx > 1000) trans_log_tx = 0;
 }
 
 /* USER CODE END 1 */

Core/Src/usart.c

@@ -205,7 +205,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
     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;
+    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
     hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
     if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
     {
@@ -223,7 +223,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
     hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
     hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
     hdma_usart1_rx.Init.Mode = DMA_NORMAL;
-    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
+    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
     hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
     if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
     {
@@ -269,7 +269,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
     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;
+    hdma_usart2_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
     hdma_usart2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
     if (HAL_DMA_Init(&hdma_usart2_tx) != HAL_OK)
     {
@@ -287,7 +287,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
     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;
+    hdma_usart2_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
     hdma_usart2_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
     if (HAL_DMA_Init(&hdma_usart2_rx) != HAL_OK)
     {
@@ -360,7 +360,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
     hdma_usart6_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
     hdma_usart6_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
     hdma_usart6_tx.Init.Mode = DMA_NORMAL;
-    hdma_usart6_tx.Init.Priority = DMA_PRIORITY_LOW;
+    hdma_usart6_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
     hdma_usart6_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
     if (HAL_DMA_Init(&hdma_usart6_tx) != HAL_OK)
     {
@@ -378,7 +378,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
     hdma_usart6_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
     hdma_usart6_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
     hdma_usart6_rx.Init.Mode = DMA_NORMAL;
-    hdma_usart6_rx.Init.Priority = DMA_PRIORITY_LOW;
+    hdma_usart6_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
     hdma_usart6_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
     if (HAL_DMA_Init(&hdma_usart6_rx) != HAL_OK)
     {
@@ -519,88 +519,32 @@ void usart_printf(UART_HandleTypeDef *huart, char *fmt, ...)
 void proc_huart_it(UART_HandleTypeDef *huart)
 { 
   //不对发送中断进行处理
-  if(st_flag == 3)
+  if(st_flag == TRANSPARENT_TRANSMIT_END)
   {
-    st_flag = 0;
+    st_flag = TRANSPARENT_WAIT;
     return;
   }
 
+  //端口选择
   st_scom *scom;
+  if(huart == &huart1) scom = &scom1_hart;
+  if(huart == &huart6) scom = &scom6_ble;
+  if(huart == &huart2) scom = &scom2_rs485;
+  if( !scom ) return;
 
-  //根据huart句柄和使能标志，判断即将进行的通讯方向
+  //对应功能是否使能
-  if(huart == &huart1)
+  if(trans_enable_check(scom) == 0)
   {
-    scom = &scom1_hart;
-
-    if(tabdata.hart_enable == 0)
-    {
-      //HART未使能的情况下接收到数据，清空数组并返回
     scom->rx_len = 0;
     memset(scom->rx_buff, 0, BUFFER_SIZE);
 
-      __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE);
-      __HAL_UART_CLEAR_IDLEFLAG(huart);
-
-      return;
-    }
-    else
-    {
-      sig_trans = TRANS_HART_TO_PC;
-    }
-  }
-
-  if(huart == &huart6)
-  {
-    scom = &scom6_ble;
-
-    if(tabdata.bluetooth_enable == 0)
-    {
-      //蓝牙未使能的情况下接收到数据，清空数组并返回
-      scom->rx_len = 0;
-      memset(scom->rx_buff, 0, BUFFER_SIZE);
-
-      __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE);
-      __HAL_UART_CLEAR_IDLEFLAG(huart);
-
-      return;
-    }
-    else
-    {
-      sig_trans = TRANS_BLE_TO_PC;
-    }
-  }
-
-  if(huart == &huart2)
-  {
-    scom = &scom2_rs485;
-
-    if(tabdata.hart_enable)
-    {
-      sig_trans = TRANS_PC_TO_HART;
-    }
-    else if(tabdata.bluetooth_enable)
-    {
-      sig_trans = TRANS_PC_TO_BLE;
-    }
-    else if(tabdata.modbus_enable)
-    {
-      sig_trans = TRANS_MODBUS_PC_TO_SIG;
-    }
-    else
-    {
-      //所有通讯均未使能的情况下接收到数据，清空数组并返回
     sig_trans = TRANS_NONE;
-      scom->rx_len = 0;
-      memset(scom->rx_buff, 0, BUFFER_SIZE);
-
-      __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE);
     __HAL_UART_CLEAR_IDLEFLAG(huart);
+    HAL_UART_DMAStop(huart);
+    HAL_UART_Receive_DMA(huart, scom->rx_buff, BUFFER_SIZE);
 
     return;
   }
-  }
-
-  if (!scom) return;
 
   //进入此处说明接收到数据，并且对应通道使能
 
@@ -608,9 +552,9 @@ void proc_huart_it(UART_HandleTypeDef *huart)
   screen_suspend_flag = 1;
 
   //记录起始时刻
-  if(st_flag == 0)
+  if(st_flag == TRANSPARENT_WAIT)
   {
-    st_flag = 1;
+    st_flag = TRANSPARENT_RECIEVE_START;
     tick_start = xTaskGetTickCountFromISR();
   }
 
@@ -631,7 +575,7 @@ void proc_huart_it(UART_HandleTypeDef *huart)
     scom->rx_flag = TRUE;
 
     //记录中间时刻
-    st_flag = 2;
+    st_flag = TRANSPARENT_RECIEVE_FINISHED;
     tick_middle = xTaskGetTickCountFromISR();
 
     __HAL_UART_CLEAR_IDLEFLAG(huart);
@@ -645,19 +589,21 @@ void proc_huart_it(UART_HandleTypeDef *huart)
 void proc_huart_it_dma(UART_HandleTypeDef *huart)
 {
   //不对发送中断进行处理
-  if(st_flag == 3)
+  if(st_flag == TRANSPARENT_TRANSMIT_END)
   {
-    st_flag = 0;
+    st_flag = TRANSPARENT_WAIT;
     return;
   }
 
+  //端口选择
   st_scom *scom;
+  if(huart == &huart1) scom = &scom1_hart;
+  if(huart == &huart6) scom = &scom6_ble;
+  if(huart == &huart2) scom = &scom2_rs485;
+  if( !scom ) return;
 
-  if(huart == &huart1)
+  //对应功能是否使能
-  {
+  if(trans_enable_check(scom) == 0)
-    scom = &scom1_hart;
-
-    if(tabdata.hart_enable == 0)
   {
     scom->rx_len = 0;
     memset(scom->rx_buff, 0, BUFFER_SIZE);
@@ -669,65 +615,6 @@ void proc_huart_it_dma(UART_HandleTypeDef *huart)
 
     return;
   }
-    else
-    {
-      sig_trans = TRANS_HART_TO_PC;
-    }
-  }
-
-  if(huart == &huart6)
-  {
-    scom = &scom6_ble;
-
-    if(tabdata.bluetooth_enable == 0)
-    {
-      scom->rx_len = 0;
-      memset(scom->rx_buff, 0, BUFFER_SIZE);
-
-      sig_trans = TRANS_NONE;
-      __HAL_UART_CLEAR_IDLEFLAG(huart);
-      HAL_UART_DMAStop(huart);
-      HAL_UART_Receive_DMA(huart, scom->rx_buff, BUFFER_SIZE);
-
-      return;
-    }
-    else
-    {
-      sig_trans = TRANS_BLE_TO_PC;
-    }
-  }
-
-  if(huart == &huart2)
-  {
-    scom = &scom2_rs485;
-
-    if(tabdata.hart_enable)
-    {
-      sig_trans = TRANS_PC_TO_HART;
-    }
-    else if(tabdata.bluetooth_enable)
-    {
-      sig_trans = TRANS_PC_TO_BLE;
-    }
-    else if(tabdata.modbus_enable)
-    {
-      sig_trans = TRANS_MODBUS_PC_TO_SIG;
-    }
-    else
-    {
-      sig_trans = TRANS_NONE;
-      scom->rx_len = 0;
-      memset(scom->rx_buff, 0, BUFFER_SIZE);
-
-      __HAL_UART_CLEAR_IDLEFLAG(huart);
-      HAL_UART_DMAStop(huart);
-      HAL_UART_Receive_DMA(huart, scom->rx_buff, BUFFER_SIZE);
-
-      return;
-    }
-  }
-
-  if (!scom) return;
 
   //进入此处说明DMA接收已经完成
   if (__HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE) != RESET)
@@ -748,10 +635,11 @@ void proc_huart_it_dma(UART_HandleTypeDef *huart)
       scom->rx_len = 0;
     }
 
+    st_flag = TRANSPARENT_RECIEVE_FINISHED; 
     tick_middle = xTaskGetTickCountFromISR();
 
     //等待下一次接收
-    HAL_UART_Receive_DMA(huart, scom->rx_buff, BUFFER_SIZE);
+    //HAL_UART_Receive_DMA(huart, scom->rx_buff, BUFFER_SIZE);
   }
 }
 /* USER CODE END 1 */

MDK-ARM/signal_generator.uvoptx

@@ -280,6 +280,11 @@
           <WinNumber>1</WinNumber>
           <ItemText>trans_log_tx,0x0A</ItemText>
         </Ww>
+        <Ww>
+          <count>25</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>st_flag,0x0A</ItemText>
+        </Ww>
       </WatchWindow1>
       <WatchWindow2>
         <Ww>

signal_generator.ioc

@@ -36,7 +36,7 @@ Dma.USART1_RX.4.MemInc=DMA_MINC_ENABLE
 Dma.USART1_RX.4.Mode=DMA_NORMAL
 Dma.USART1_RX.4.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
 Dma.USART1_RX.4.PeriphInc=DMA_PINC_DISABLE
-Dma.USART1_RX.4.Priority=DMA_PRIORITY_LOW
+Dma.USART1_RX.4.Priority=DMA_PRIORITY_VERY_HIGH
 Dma.USART1_RX.4.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
 Dma.USART1_TX.1.Direction=DMA_MEMORY_TO_PERIPH
 Dma.USART1_TX.1.FIFOMode=DMA_FIFOMODE_DISABLE
@@ -46,7 +46,7 @@ Dma.USART1_TX.1.MemInc=DMA_MINC_ENABLE
 Dma.USART1_TX.1.Mode=DMA_NORMAL
 Dma.USART1_TX.1.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
 Dma.USART1_TX.1.PeriphInc=DMA_PINC_DISABLE
-Dma.USART1_TX.1.Priority=DMA_PRIORITY_LOW
+Dma.USART1_TX.1.Priority=DMA_PRIORITY_VERY_HIGH
 Dma.USART1_TX.1.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
 Dma.USART2_RX.5.Direction=DMA_PERIPH_TO_MEMORY
 Dma.USART2_RX.5.FIFOMode=DMA_FIFOMODE_DISABLE
@@ -56,7 +56,7 @@ Dma.USART2_RX.5.MemInc=DMA_MINC_ENABLE
 Dma.USART2_RX.5.Mode=DMA_NORMAL
 Dma.USART2_RX.5.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
 Dma.USART2_RX.5.PeriphInc=DMA_PINC_DISABLE
-Dma.USART2_RX.5.Priority=DMA_PRIORITY_LOW
+Dma.USART2_RX.5.Priority=DMA_PRIORITY_VERY_HIGH
 Dma.USART2_RX.5.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
 Dma.USART2_TX.2.Direction=DMA_MEMORY_TO_PERIPH
 Dma.USART2_TX.2.FIFOMode=DMA_FIFOMODE_DISABLE
@@ -66,7 +66,7 @@ Dma.USART2_TX.2.MemInc=DMA_MINC_ENABLE
 Dma.USART2_TX.2.Mode=DMA_NORMAL
 Dma.USART2_TX.2.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
 Dma.USART2_TX.2.PeriphInc=DMA_PINC_DISABLE
-Dma.USART2_TX.2.Priority=DMA_PRIORITY_LOW
+Dma.USART2_TX.2.Priority=DMA_PRIORITY_VERY_HIGH
 Dma.USART2_TX.2.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
 Dma.USART6_RX.6.Direction=DMA_PERIPH_TO_MEMORY
 Dma.USART6_RX.6.FIFOMode=DMA_FIFOMODE_DISABLE
@@ -76,7 +76,7 @@ Dma.USART6_RX.6.MemInc=DMA_MINC_ENABLE
 Dma.USART6_RX.6.Mode=DMA_NORMAL
 Dma.USART6_RX.6.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
 Dma.USART6_RX.6.PeriphInc=DMA_PINC_DISABLE
-Dma.USART6_RX.6.Priority=DMA_PRIORITY_LOW
+Dma.USART6_RX.6.Priority=DMA_PRIORITY_VERY_HIGH
 Dma.USART6_RX.6.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
 Dma.USART6_TX.3.Direction=DMA_MEMORY_TO_PERIPH
 Dma.USART6_TX.3.FIFOMode=DMA_FIFOMODE_DISABLE
@@ -86,7 +86,7 @@ Dma.USART6_TX.3.MemInc=DMA_MINC_ENABLE
 Dma.USART6_TX.3.Mode=DMA_NORMAL
 Dma.USART6_TX.3.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
 Dma.USART6_TX.3.PeriphInc=DMA_PINC_DISABLE
-Dma.USART6_TX.3.Priority=DMA_PRIORITY_LOW
+Dma.USART6_TX.3.Priority=DMA_PRIORITY_VERY_HIGH
 Dma.USART6_TX.3.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
 FREERTOS.FootprintOK=true
 FREERTOS.INCLUDE_uxTaskGetStackHighWaterMark=1