更新：

1、modbus主站：完成了自定义超时时间的功能。
2、取消对DMA接收起始时刻的捕获，取消接收延迟的计算。

App/APP_WU/Inc/app_screen_setting.h

@@ -67,6 +67,12 @@ typedef enum
     COLOR_BLACK
 }COLORS;
 
+typedef enum
+{
+    SIG_SLAVE = 0,
+    SIG_MASTER
+}SIG_MODBUS_TYPE;
+
 typedef struct
 {
     ITEMS item_cursor;                      //选项卡游标，后续根据实际需求进行宏定义
@@ -109,6 +115,8 @@ typedef struct
     uint8_t hart_enable;                    //HART透传使能
     uint8_t bluetooth_enable;               //蓝牙透传使能
     uint8_t modbus_enable;                  //MODBUS使能
+    SIG_MODBUS_TYPE modbus_type;            //SIG在modbus中作为主或从
+    uint16_t modbus_timeout_period;         //SIG作为主设备时，等待从设备响应的超时时间上限（ms）
     
     //ITEMS_3
     uint8_t item3_page0_lightflag;          //照明状态标志，0熄灭，1开启

App/APP_WU/Inc/timer.h

@@ -20,6 +20,7 @@ extern int plot_ms_cnt;
 extern int twk_1000ms_flag;
 extern int twk_1000ms_cnt;
 extern int input_500ms_flag;
+extern uint16_t sig2slave_current_tick;
 
 void duty_tim3(void);
 void duty_tim6(void);

App/APP_WU/Src/app_screen_setting.c

@@ -46,6 +46,8 @@ void tab_data_init(void)
     tabdata.hart_enable = 0;                        //HART默认使能状态
     tabdata.bluetooth_enable = 0;                   //HART默认使能状态
     tabdata.modbus_enable = 0;                      //HART默认使能状态
+    tabdata.modbus_type = SIG_SLAVE;                //SIG默认作为从设备
+    tabdata.modbus_timeout_period = 1000;           //默认超时时间为1000ms
 
     //ITEMS_3（部分内容位于EERPOM读取）
     tabdata.item3_page0_lightflag = 0;              //照明状态标志，0熄灭，1开启

App/APP_WU/Src/timer.c

@@ -18,6 +18,8 @@ int twk_1000ms_flag = 0;
 int twk_1000ms_cnt = 0;
 int input_500ms_flag = 0;
 int input_500ms_cnt = 0;
+uint16_t sig2slave_previous_tick = 0;
+uint16_t sig2slave_current_tick = 0;
 
 void duty_tim3(void)
 {
@@ -62,6 +64,20 @@ void duty_tim6(void)
       input_500ms_cnt = 0;
       input_500ms_flag = 1;
     }
+
+    if(sig2slave_step == 1)
+    {
+      sig2slave_current_tick++;
+      if(sig2slave_current_tick > tabdata.modbus_timeout_period)
+      {
+        HAL_UART_DMAStop(&huart2);
+        __HAL_UART_CLEAR_IDLEFLAG(&huart2);
+    
+        sig2slave_current_tick = 0;
+        sig2slave_step++;
+        scom2_rs485.rx_flag = TRUE;
+      }
+    }
 }
 
 

App/MODBUS/Inc/modbus_485.h

@@ -3,17 +3,21 @@
 
 #include "apps_gather.h"
 
-#define TRANSPARENT_WAIT 0
+typedef enum
-#define TRANSPARENT_RECIEVE_START 1
+{
-#define TRANSPARENT_RECIEVE_FINISHED 2
+    TRANSPARENT_WAIT = 0,
-#define TRANSPARENT_TRANSMIT_END 3
+    TRANSPARENT_RECIEVE_START,
+    TRANSPARENT_RECIEVE_FINISHED,
+    TRANSPARENT_TRANSMIT_END
+}TRANS_PROCESS;
 
 extern uint32_t tick_start;
 extern uint32_t tick_middle;
 extern uint32_t tick_end;
 extern uint32_t trans_log_rx;
 extern uint32_t trans_log_tx;
-extern uint8_t st_flag;
+extern uint8_t sig2slave_step;
+extern TRANS_PROCESS st_flag;
 
 void parse_scom_485(st_scom *scom);
 
@@ -35,6 +39,7 @@ void trans_pc2ble(void);
 
 void trans_modbus_pc2sig(void);
 
+//SIG作为主设备，向外发送数据之后，等待从机应答，持续一段时间（超时时间）无数据后停止接收，并对收到的数据进行解析
 void trans_modbus_sig2slave(void);
 
 //DMA接收只有半满中断、空闲中断和完成（溢出）中断，因此用以下函数尝试进行捕获

App/MODBUS/Src/modbus_485.c

@@ -5,7 +5,7 @@ uint32_t tick_middle = 0;
 uint32_t tick_end = 0;
 uint32_t trans_log_rx = 0;
 uint32_t trans_log_tx = 0;
-uint8_t st_flag = 0;
+TRANS_PROCESS st_flag = TRANSPARENT_WAIT;
 
 //static void scom_485_send(UART_HandleTypeDef *huart, char *str)
 //{
@@ -154,7 +154,6 @@ void transparent_tim(void)
         default:
         break;
     }
-
 }
 
 void trans_hart2pc(void)
@@ -294,13 +293,82 @@ void trans_modbus_pc2sig(void)
     }
 }
 
+uint8_t sig2slave_step = 0;
+uint8_t sig2slave_data_length_total = 0;
+uint8_t buffer_size_temp = BUFFER_SIZE;
 void trans_modbus_sig2slave(void)
 {
+    if (scom2_rs485.rx_flag == TRUE)
+    {
+        scom2_rs485.rx_flag = FALSE;
+
+        switch (sig2slave_step)
+        {
+            case 0:
+            {
+                //进入此处说明已经接收完成一部分数据，开始超时计时
+
+                //记录第一次接收到的数据长度
+                sig2slave_data_length_total = scom2_rs485.rx_len;
+ 
+                //修改剩余buff长度，继续接收
+                buffer_size_temp -= scom2_rs485.rx_len;
+                HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff + sig2slave_data_length_total, buffer_size_temp);
+
+                sig2slave_step++;
+            }
+            break;
+
+            case 1:
+            {
+                //超时时间内再次收到数据，重新开始超时计时
+                sig2slave_current_tick = 0;
+
+                //本次收到的数据长度
+                uint8_t sig2slave_data_length_temp = buffer_size_temp - __HAL_DMA_GET_COUNTER(huart2.hdmarx);
+
+                //累计收到的数据长度
+                sig2slave_data_length_total += sig2slave_data_length_temp;
+                scom2_rs485.rx_len = sig2slave_data_length_total;
+
+                if(scom2_rs485.rx_len < BUFFER_SIZE)
+                {
+                    //继续接收
+                    buffer_size_temp -= sig2slave_data_length_temp;
+                    HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff + sig2slave_data_length_total, buffer_size_temp);
+                }
+            }
+            break;
+
+            case 2:
+            {
+                //进入此处说明超时计时结束，对接收到的数据进行处理
+
+                //数据处理完成
+                sig2slave_step = 0;
+                sig_trans = TRANS_NONE;
+                memset(scom2_rs485.rx_buff, 0, scom2_rs485.rx_len);
+                scom2_rs485.rx_len = 0;
+                sig2slave_data_length_total = 0;
+                buffer_size_temp = BUFFER_SIZE;
+
+                HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
+            }
+            break;
+        
+            default:
+            break;
+        }
+    }
 }
 
 void trans_start_capture(void)
 {
-    if( ( 1 <= (BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart1.hdmarx)) )&&( (BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart1.hdmarx)) <= 3) )
+    uint8_t data_len1 = BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart1.hdmarx);
+    uint8_t data_len2 = BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart2.hdmarx);
+    uint8_t data_len6 = BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart6.hdmarx);
+
+    if( (1 <= data_len1 )&&( data_len1 <= 3) )
     {
         if(tabdata.hart_enable)
         {
@@ -312,7 +380,7 @@ void trans_start_capture(void)
         }
     }
 
-    if( ( 1 <= (BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart6.hdmarx)) )&&( (BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart6.hdmarx)) <= 3) )
+    if( (1 <= data_len2 )&&( data_len2 <= 3) )
     {
         if(tabdata.bluetooth_enable)
         {
@@ -324,7 +392,7 @@ void trans_start_capture(void)
         }
     }
 
-    if( ( 1 <= (BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart2.hdmarx)) )&&( (BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart2.hdmarx)) <= 3) )
+    if( (1 <= data_len6 )&&( data_len6 <= 3) )
     {
         if(tabdata.hart_enable||tabdata.bluetooth_enable||tabdata.modbus_enable)
         {
@@ -374,8 +442,25 @@ uint8_t trans_enable_check(st_scom *scom)
         else if(tabdata.modbus_enable)
         {
             result = 1;
+
+            switch (tabdata.modbus_type)
+            {
+                case SIG_SLAVE:
+                {
                     sig_trans = TRANS_MODBUS_PC_TO_SIG;
                 }
+                break;
+
+                case SIG_MASTER:
+                {
+                    sig_trans = TRANS_MODBUS_SIG_TO_SLAVE;
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
     }
 
     return result;

Core/Src/main.c

@@ -225,17 +225,18 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
     //无通讯的情况下直接返回，开启DMA时尝试对第1~3个字节的数据进行捕获
     if(sig_trans == TRANS_NONE)
     {
-      #if RX_DMA_ENABLE
+      // #if RX_DMA_ENABLE
-        trans_start_capture();
+      //   trans_start_capture();
-      #endif
+      // #endif
       return;
     }
 
     HAL_TIM_Base_Stop(&htim2);
 
-    //DMA发送
+    //数据传输
     transparent_tim();
 
+    __HAL_TIM_SET_COUNTER(&htim2, 0);
     HAL_TIM_Base_Start(&htim2);
   }
 

Core/Src/stm32f4xx_it.c

@@ -441,9 +441,9 @@ void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
   tick_end = xTaskGetTickCountFromISR();
 
   //计算延迟，捕获失败时清零（速度过快，小于1ms）
-  trans_log_rx = tick_middle - tick_start;
+  //trans_log_rx = tick_middle - tick_start;
+  //if(trans_log_rx > 1000) trans_log_rx = 0;
   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;
 
   //发送完成后将相关数组清零

MDK-ARM/signal_generator.uvoptx

@@ -273,17 +273,17 @@
         <Ww>
           <count>23</count>
           <WinNumber>1</WinNumber>
-          <ItemText>trans_log_rx,0x0A</ItemText>
+          <ItemText>st_flag,0x0A</ItemText>
         </Ww>
         <Ww>
           <count>24</count>
           <WinNumber>1</WinNumber>
-          <ItemText>trans_log_tx,0x0A</ItemText>
+          <ItemText>trans_log_rx,0x0A</ItemText>
         </Ww>
         <Ww>
           <count>25</count>
           <WinNumber>1</WinNumber>
-          <ItemText>st_flag,0x0A</ItemText>
+          <ItemText>trans_log_tx,0x0A</ItemText>
         </Ww>
       </WatchWindow1>
       <WatchWindow2>
@@ -539,7 +539,7 @@
 
   <Group>
     <GroupName>Application/User/App/LCD</GroupName>
-    <tvExp>1</tvExp>
+    <tvExp>0</tvExp>
     <tvExpOptDlg>0</tvExpOptDlg>
     <cbSel>0</cbSel>
     <RteFlg>0</RteFlg>
@@ -559,7 +559,7 @@
 
   <Group>
     <GroupName>Application/User/App/HART</GroupName>
-    <tvExp>1</tvExp>
+    <tvExp>0</tvExp>
     <tvExpOptDlg>0</tvExpOptDlg>
     <cbSel>0</cbSel>
     <RteFlg>0</RteFlg>
@@ -579,7 +579,7 @@
 
   <Group>
     <GroupName>Application/User/App/BLE</GroupName>
-    <tvExp>1</tvExp>
+    <tvExp>0</tvExp>
     <tvExpOptDlg>0</tvExpOptDlg>
     <cbSel>0</cbSel>
     <RteFlg>0</RteFlg>
@@ -631,7 +631,7 @@
 
   <Group>
     <GroupName>Application/User/App/MUX_SIGNAL</GroupName>
-    <tvExp>1</tvExp>
+    <tvExp>0</tvExp>
     <tvExpOptDlg>0</tvExpOptDlg>
     <cbSel>0</cbSel>
     <RteFlg>0</RteFlg>