完成部分对下数据接收，添加485发送后切换为读状态延时（未测试）

CH32V303-FreeRTOS/App/application/Inc/downUartParse.h

@@ -5,4 +5,16 @@
 
 extern uint16_t checkModebusCrc(uint8_t *arr_buff, uint8_t len);
 
+// void downSensorDataAnalysis(device_handle device);
+
+
+uint32_t getTickDiff(uint32_t lastTick);
+
+void J1_SensorDataAnalysis(void);
+void J2_SensorDataAnalysis(void);
+void J3_SensorDataAnalysis(void);
+void J4_SensorDataAnalysis(void);
+void J5_0_SensorDataAnalysis(void);
+
+
 #endif

CH32V303-FreeRTOS/App/application/Src/downUartParse.c

@@ -1,22 +1,390 @@
+#include "FreeRTOS.h"
+#include "task.h"
+
 #include "downUartParse.h"
+#include "upUartParse.h"
+#include "queueUart.h"
 
-/* 1秒的节拍数 */
+// /* 1秒的节拍数 */
-#define tick_1S configTICK_RATE_HZ
+// #define tick_1S configTICK_RATE_HZ
-
-/* 状态机 */
-typedef enum {
-    wait                        = 0,    /* 串口状态机初始状态 */
-    startFlag,                          /* 接收到帧头 */
-    // address,                            /* 设备地址 */
-    functionCode,                       /* 接收到功能码 */
-    dataLen,                            /* 接收到数据长度 */
-    crcCheckBitGW,                      /* 接收到校验位 */
-    endFlagGW,                          /* 接收到帧尾 */
-} uartStateMachine;
-
-
-
 
+// /* 状态机 */
+// typedef enum {
+//     wait                        = 0,    /* 串口状态机初始状态 */
+//     startFlag,                          /* 接收到帧头 */
+//     // address,                            /* 设备地址 */
+//     functionCode,                       /* 接收到功能码 */
+//     dataLen,                            /* 接收到数据长度 */
+//     crcCheckBitGW,                      /* 接收到校验位 */
+//     endFlagGW,                          /* 接收到帧尾 */
+// } uartStateMachine;
+
+
+/* 储存gw485数据 */
+static uint8_t J1_485RxBuffer[128];
+static uint16_t J1_485RxBufferIndex = 0;
+static uint8_t J2_485RxBuffer[128];
+static uint16_t J2_485RxBufferIndex = 0;
+static uint8_t J3_485RxBuffer[128];
+static uint16_t J3_485RxBufferIndex = 0;
+static uint8_t J4_485RxBuffer[128];
+static uint16_t J4_485RxBufferIndex = 0;
+static uint8_t J5_0_485RxBuffer[128];
+static uint16_t J5_0_485RxBufferIndex = 0;
+
+/* 100ms */
+#define delayTick 50
+#define maxdataLen 100
+
+/**
+  * @brief  接收J1口传来的数据
+  * @param 
+  * @retval
+  */
+void J1_SensorDataAnalysis(void)
+{
+    static uint32_t tick;
+
+    if (J1_485RxBufferIndex == 0) {
+        tick = xTaskGetTickCount();
+    }
+
+    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
+    uint32_t nowTick = xTaskGetTickCount();
+    while ((getTickDiff(nowTick) < 3)
+            && (uart_dev_char_present(g_J1_uart6_handle) == 1)
+            && (maxdataLen > J1_485RxBufferIndex)) {
+        J1_485RxBuffer[J1_485RxBufferIndex++] = uart_dev_in_char(g_J1_uart6_handle);
+    }
+
+    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
+    if ((J1_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
+        uint32_t tempLen = 6 + J1_485RxBufferIndex + queueUartSendInfoSize;
+        if (xPortGetFreeHeapSize() < tempLen + 1024) {
+            J1_485RxBufferIndex = 0;
+            return;
+        }
+
+        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);
+        queueUartSendInfo *sendBuff = (queueUartSendInfo *)Buff;
+        sendBuff->length = 6 + J1_485RxBufferIndex;        
+        sendBuff->data = Buff + sizeof(queueUartSendInfo);
+        uint8_t *send = sendBuff->data;
+
+        /* 起始标志 */
+        *send = 'S';
+        *(send + 1) = 'L';
+
+        /* 端口号 */
+        send += 2;
+        *send = 1;
+
+        /* 数据包长度 */
+        send += 1;
+        *send = (uint8_t)(J1_485RxBufferIndex >> 8);
+        *(send + 1) = (uint8_t)(J1_485RxBufferIndex);
+
+        /* 数据包 */
+        send += 2;
+        strlcpy((char *)send, (char *)J1_485RxBuffer, J1_485RxBufferIndex);
+
+        /* 结束标志 */
+        send += J1_485RxBufferIndex;
+        *send = 0x17;
+
+        /* 队列中有空间，则将发送数据 */
+        if (uxQueueSpacesAvailable(upward_uart_Queue)) {
+            xQueueSend(upward_uart_Queue, &Buff, 10);
+        }
+        /* 队列无空间，将数据丢弃 */
+        else {
+            vPortFree(Buff);
+        }
+
+        /* 发送完成或遇到问题，将buff中的数据清零 */
+        J1_485RxBufferIndex = 0;
+    }
+}
+
+/**
+  * @brief  接收J2口传来的数据
+  * @param 
+  * @retval
+  */
+void J2_SensorDataAnalysis(void)
+{
+    static uint32_t tick;
+
+    if (J2_485RxBufferIndex == 0) {
+        tick = xTaskGetTickCount();
+    }
+
+    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
+    uint32_t nowTick = xTaskGetTickCount();
+    while ((getTickDiff(nowTick) < 3)
+            && (uart_dev_char_present(g_J2_uart7_handle) == 1)
+            && (maxdataLen > J2_485RxBufferIndex)) {
+        J2_485RxBuffer[J2_485RxBufferIndex++] = uart_dev_in_char(g_J2_uart7_handle);
+    }
+
+    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
+    if ((J2_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
+
+        uint32_t tempLen = 6 + J2_485RxBufferIndex + queueUartSendInfoSize;
+        if (xPortGetFreeHeapSize() < tempLen + 1024) {
+            J2_485RxBufferIndex = 0;
+            return;
+        }
+
+        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);        
+        queueUartSendInfo *sendBuff = (queueUartSendInfo *)Buff;
+        sendBuff->length = 6 + J2_485RxBufferIndex;        
+        sendBuff->data = Buff + sizeof(queueUartSendInfo);
+        uint8_t *send = sendBuff->data;
+
+        /* 起始标志 */
+        *send = 'S';
+        *(send + 1) = 'L';
+
+        /* 端口号 */
+        send += 2;
+        *send = 2;
+
+        /* 数据包长度 */
+        send += 1;
+        *send = (uint8_t)(J2_485RxBufferIndex >> 8);
+        *(send + 1) = (uint8_t)(J2_485RxBufferIndex);
+
+        /* 数据包 */
+        send += 2;
+        strlcpy((char *)send, (char *)J2_485RxBuffer, J2_485RxBufferIndex);
+
+        /* 结束标志 */
+        send += J2_485RxBufferIndex;
+        *send = 0x17;
+
+        /* 队列中有空间，则将发送数据 */
+        if (uxQueueSpacesAvailable(upward_uart_Queue)) {
+            xQueueSend(upward_uart_Queue, &Buff, 10);
+        }
+        /* 队列无空间，将数据丢弃 */
+        else {
+            vPortFree(Buff);
+        }
+
+        J2_485RxBufferIndex = 0;
+    }
+}
+
+/**
+  * @brief  接收J3口传来的数据
+  * @param 
+  * @retval
+  */
+void J3_SensorDataAnalysis(void)
+{
+    static uint32_t tick;
+
+    if (J3_485RxBufferIndex == 0) {
+        tick = xTaskGetTickCount();
+    }
+
+    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
+    uint32_t nowTick = xTaskGetTickCount();
+    while ((getTickDiff(nowTick) < 3)
+            && (uart_dev_char_present(g_J3_usart2_handle) == 1)
+            && (maxdataLen > J3_485RxBufferIndex)) {
+        J3_485RxBuffer[J3_485RxBufferIndex++] = uart_dev_in_char(g_J3_usart2_handle);
+    }
+
+    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
+    if ((J3_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
+
+        uint32_t tempLen = 6 + J3_485RxBufferIndex + queueUartSendInfoSize;
+        if (xPortGetFreeHeapSize() < tempLen + 1024) {
+            J3_485RxBufferIndex = 0;
+            return;
+        }
+
+        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);        
+        queueUartSendInfo *sendBuff = (queueUartSendInfo *)Buff;
+        sendBuff->length = 6 + J3_485RxBufferIndex;        
+        sendBuff->data = Buff + sizeof(queueUartSendInfo);
+        uint8_t *send = sendBuff->data;
+
+        /* 起始标志 */
+        *send = 'S';
+        *(send + 1) = 'L';
+
+        /* 端口号 */
+        send += 2;
+        *send = 3;
+
+        /* 数据包长度 */
+        send += 1;
+        *send = (uint8_t)(J3_485RxBufferIndex >> 8);
+        *(send + 1) = (uint8_t)(J3_485RxBufferIndex);
+
+        /* 数据包 */
+        send += 2;
+        strlcpy((char *)send, (char *)J3_485RxBuffer, J3_485RxBufferIndex);
+
+        /* 结束标志 */
+        send += J3_485RxBufferIndex;
+        *send = 0x17;
+
+        /* 队列中有空间，则将发送数据 */
+        if (uxQueueSpacesAvailable(upward_uart_Queue)) {
+            xQueueSend(upward_uart_Queue, &Buff, 10);
+        }
+        /* 队列无空间，将数据丢弃 */
+        else {
+            vPortFree(Buff);
+        }
+        
+        J3_485RxBufferIndex = 0;
+    }
+}
+
+/**
+  * @brief  接收J4口传来的数据
+  * @param 
+  * @retval
+  */
+void J4_SensorDataAnalysis(void)
+{
+    static uint32_t tick;
+
+    if (J4_485RxBufferIndex == 0) {
+        tick = xTaskGetTickCount();
+    }
+
+    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
+    uint32_t nowTick = xTaskGetTickCount();
+    while ((getTickDiff(nowTick) < 3)
+            && (uart_dev_char_present(g_J4_uart8_handle) == 1)
+            && (maxdataLen > J4_485RxBufferIndex)) {
+        J4_485RxBuffer[J4_485RxBufferIndex++] = uart_dev_in_char(g_J4_uart8_handle);
+    }
+
+    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
+    if ((J4_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
+
+        uint32_t tempLen = 6 + J4_485RxBufferIndex + queueUartSendInfoSize;
+        if (xPortGetFreeHeapSize() < tempLen + 1024) {
+            J4_485RxBufferIndex = 0;
+            return;
+        }
+
+        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);        
+        queueUartSendInfo *sendBuff = (queueUartSendInfo *)Buff;
+        sendBuff->length = 6 + J4_485RxBufferIndex;        
+        sendBuff->data = Buff + sizeof(queueUartSendInfo);
+        uint8_t *send = sendBuff->data;
+
+        /* 起始标志 */
+        *send = 'S';
+        *(send + 1) = 'L';
+
+        /* 端口号 */
+        send += 2;
+        *send = 4;
+
+        /* 数据包长度 */
+        send += 1;
+        *send = (uint8_t)(J4_485RxBufferIndex >> 8);
+        *(send + 1) = (uint8_t)(J4_485RxBufferIndex);
+
+        /* 数据包 */
+        send += 2;
+        strlcpy((char *)send, (char *)J4_485RxBuffer, J4_485RxBufferIndex);
+
+        /* 结束标志 */
+        send += J4_485RxBufferIndex;
+        *send = 0x17;
+
+        /* 队列中有空间，则将发送数据 */
+        if (uxQueueSpacesAvailable(upward_uart_Queue)) {
+            xQueueSend(upward_uart_Queue, &Buff, 10);
+        }
+        /* 队列无空间，将数据丢弃 */
+        else {
+            vPortFree(Buff);
+        }
+        
+        J4_485RxBufferIndex = 0;
+    }
+}
+
+/**
+  * @brief  接收J5_0口传来的数据
+  * @param 
+  * @retval
+  */
+void J5_0_SensorDataAnalysis(void)
+{
+    static uint32_t tick;
+
+    if (J5_0_485RxBufferIndex == 0) {
+        tick = xTaskGetTickCount();
+    }
+
+    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
+    uint32_t nowTick = xTaskGetTickCount();
+    while ((getTickDiff(nowTick) < 3)
+            && (uart_dev_char_present(g_J5_0_usart3_handle) == 1)
+            && (maxdataLen > J5_0_485RxBufferIndex)) {
+        J5_0_485RxBuffer[J5_0_485RxBufferIndex++] = uart_dev_in_char(g_J5_0_usart3_handle);
+    }
+
+    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
+    if ((J5_0_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
+
+        uint32_t tempLen = 6 + J5_0_485RxBufferIndex + queueUartSendInfoSize;
+        if (xPortGetFreeHeapSize() < tempLen + 1024) {
+            J5_0_485RxBufferIndex = 0;
+            return;
+        }
+
+        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);        
+        queueUartSendInfo *sendBuff = (queueUartSendInfo *)Buff;
+        sendBuff->length = 6 + J5_0_485RxBufferIndex;        
+        sendBuff->data = Buff + sizeof(queueUartSendInfo);
+        uint8_t *send = sendBuff->data;
+
+        /* 起始标志 */
+        *send = 'S';
+        *(send + 1) = 'L';
+
+        /* 端口号 */
+        send += 2;
+        *send = getConnectPort();
+
+        /* 数据包长度 */
+        send += 1;
+        *send = (uint8_t)(J5_0_485RxBufferIndex >> 8);
+        *(send + 1) = (uint8_t)(J5_0_485RxBufferIndex);
+
+        /* 数据包 */
+        send += 2;
+        strlcpy((char *)send, (char *)J5_0_485RxBuffer, J5_0_485RxBufferIndex);
+
+        /* 结束标志 */
+        send += J5_0_485RxBufferIndex;
+        *send = 0x17;
+
+        /* 队列中有空间，则将发送数据 */
+        if (uxQueueSpacesAvailable(upward_uart_Queue)) {
+            xQueueSend(upward_uart_Queue, &Buff, 10);
+        }
+        /* 队列无空间，将数据丢弃 */
+        else {
+            vPortFree(Buff);
+        }
+
+        J5_0_485RxBufferIndex = 0;
+    }
+}
 
 
 

CH32V303-FreeRTOS/App/application/Src/freerotsTask.c

@@ -11,6 +11,7 @@
 #include "flash.h"
 #include "parameter.h"
 #include "busIdleDetection.h"
+#include "downUartParse.h"
 
 
 #define Common_TASK_PRIO     2
@@ -23,7 +24,7 @@
 #define UpReceive_STK_SIZE      256
 
 #define DownReceive_TASK_PRIO     4
-#define DownReceive_STK_SIZE      256
+#define DownReceive_STK_SIZE      1024
 
 #define FreeMemory_TASK_PRIO     5
 #define FreeMemory_STK_SIZE      256
@@ -137,14 +138,19 @@ static void UpReceive_Task(void *pvParameters)
 }
 
 /**
-  * @brief  解析传感率发送来的数据
+  * @brief  解析传感器发送来的数据
   * @param
   * @retval
   */
 static void DownReceive_Task(void *pvParameters)
 {
     while (1) {
-        vTaskDelay(1000);
+        J1_SensorDataAnalysis();
+        J2_SensorDataAnalysis();
+        J3_SensorDataAnalysis();
+        J4_SensorDataAnalysis();
+        J5_0_SensorDataAnalysis();
+        vTaskDelay(5);
     }    
 }
 
@@ -190,6 +196,11 @@ void startApp(void)
     binarySemaphoreInit();
     softwareTimeInit();
 
+    Delay_Ms(1000);
+    set_485_Read();
+
+    writePwrCtrlState(Android_PwrCtrl, GPIO_SET);
+
     /* create task */
     xTaskCreate((TaskFunction_t )common_Task,
                     (const char*    )"commonTask",
@@ -226,7 +237,6 @@ void startApp(void)
                     (UBaseType_t    )FreeMemory_TASK_PRIO,
                     (TaskHandle_t*  )&FreeMemory_Handler);
 
-
     vTaskStartScheduler();
 }
 

CH32V303-FreeRTOS/App/application/Src/parameter.c

@@ -48,7 +48,8 @@ void readConfigParameter(void)
         parameter.J2_485_Baud = 9600;
         parameter.J3_485_Baud = 9600;
         parameter.J4_485_Baud = 9600;
-        parameter.J5_0_485_Baud = 9600;
+        // parameter.J5_0_485_Baud = 9600;
+        parameter.J5_0_485_Baud = 115200;
         parameter.upWard_Uart_Baud = 115200;
     }
 }

CH32V303-FreeRTOS/App/application/Src/queueUart.c

@@ -215,6 +215,8 @@ void binarySemaphoreFreeMemory(void)
     if (xActivatedMember == J1_BinarySemaphore) {
         // 执行相关逻辑
         vPortFree(queueRecvData.J1_485_data);
+        vTaskDelay(1);
+        readJ1_485;
         setJ1_485_SendState(0);
         // 处理二值信号量事件
         xSemaphoreTake(J1_BinarySemaphore, 0);
@@ -222,24 +224,32 @@ void binarySemaphoreFreeMemory(void)
 
     else if (xActivatedMember == J2_BinarySemaphore) {
         vPortFree(queueRecvData.J2_485_data);
+        vTaskDelay(1);
+        readJ2_485;
         setJ2_485_SendState(0);
         xSemaphoreTake(J2_BinarySemaphore, 0);
     }
 
     else if (xActivatedMember == J3_BinarySemaphore) {
         vPortFree(queueRecvData.J3_485_data);
+        vTaskDelay(1);
+        readJ3_485;
         setJ3_485_SendState(0);
         xSemaphoreTake(J3_BinarySemaphore, 0);
     }
 
     else if (xActivatedMember == J4_BinarySemaphore) {
         vPortFree(queueRecvData.J4_485_data);
+        vTaskDelay(1);
+        readJ4_485;
         setJ4_485_SendState(0);
         xSemaphoreTake(J4_BinarySemaphore, 0);
     }
     
     else if (xActivatedMember == J5_0_BinarySemaphore) {
         vPortFree(queueRecvData.J5_0_485_data);
+        vTaskDelay(1);
+        readJ5_0_485;
         setJ5_0_485_SendState(0);
         xSemaphoreTake(J5_0_BinarySemaphore, 0);
     }

CH32V303-FreeRTOS/App/application/Src/upUartParse.c

@@ -897,21 +897,37 @@ uint8_t analysisEndFlagSL(void)
         if (uxQueueSpacesAvailable(J1_485_Queue)) {
             xQueueSend(J1_485_Queue, &Buff, 10);
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
     else if (gw485RxBuffer[2] == 2) {
         if (uxQueueSpacesAvailable(J2_485_Queue)) {
             xQueueSend(J2_485_Queue, &Buff, 10);    
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
     else if (gw485RxBuffer[2] == 3) {
         if (uxQueueSpacesAvailable(J3_485_Queue)) {
             xQueueSend(J3_485_Queue, &Buff, 10);    
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
     else if (gw485RxBuffer[2] == 4) {
         if (uxQueueSpacesAvailable(J4_485_Queue)) {
             xQueueSend(J4_485_Queue, &Buff, 10);    
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
     else if (gw485RxBuffer[2] == 5) {
         queueTimeShareSendInfo *sendBuff = (queueTimeShareSendInfo *)Buff;
@@ -919,6 +935,10 @@ uint8_t analysisEndFlagSL(void)
         if (uxQueueSpacesAvailable(J5_0_485_Queue)) {
             xQueueSend(J5_0_485_Queue, &Buff, 10);    
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
     else if (gw485RxBuffer[2] == 6) {
         queueTimeShareSendInfo *sendBuff = (queueTimeShareSendInfo *)Buff;
@@ -926,6 +946,10 @@ uint8_t analysisEndFlagSL(void)
         if (uxQueueSpacesAvailable(J5_0_485_Queue)) {
             xQueueSend(J5_0_485_Queue, &Buff, 10);    
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
     else if (gw485RxBuffer[2] == 7) {
         queueTimeShareSendInfo *sendBuff = (queueTimeShareSendInfo *)Buff;
@@ -933,6 +957,10 @@ uint8_t analysisEndFlagSL(void)
         if (uxQueueSpacesAvailable(J5_0_485_Queue)) {
             xQueueSend(J5_0_485_Queue, &Buff, 10);    
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
     else if (gw485RxBuffer[2] == 8) {
         queueTimeShareSendInfo *sendBuff = (queueTimeShareSendInfo *)Buff;
@@ -940,6 +968,10 @@ uint8_t analysisEndFlagSL(void)
         if (uxQueueSpacesAvailable(J5_0_485_Queue)) {
             xQueueSend(J5_0_485_Queue, &Buff, 10);    
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
     else if (gw485RxBuffer[2] == 9) {
         queueTimeShareSendInfo *sendBuff = (queueTimeShareSendInfo *)Buff;
@@ -947,6 +979,10 @@ uint8_t analysisEndFlagSL(void)
         if (uxQueueSpacesAvailable(J5_0_485_Queue)) {
             xQueueSend(J5_0_485_Queue, &Buff, 10);    
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
     else if (gw485RxBuffer[2] == 0) {
         queueTimeShareSendInfo *sendBuff = (queueTimeShareSendInfo *)Buff;
@@ -954,6 +990,10 @@ uint8_t analysisEndFlagSL(void)
         if (uxQueueSpacesAvailable(J5_0_485_Queue)) {
             xQueueSend(J5_0_485_Queue, &Buff, 10);    
         }
+        /* 队列中无空间，释放内存，退出 */
+        else {
+            vPortFree(Buff);
+        }
     }
 
 err:
@@ -1034,6 +1074,9 @@ void GW_MsgProcFunc_Read_Register(device_handle device,uint8_t *buff, uint16_t b
     if (uxQueueSpacesAvailable(upward_uart_Queue)) {
         xQueueSend(upward_uart_Queue, &Buff, 10);    
     }
+    else {
+        vPortFree(Buff);
+    }
 }
 
 /**

CH32V303-FreeRTOS/App/functionalModule/Inc/uart_dev.h

@@ -102,8 +102,8 @@ void setUpward_uart_SendState(uint8_t state);
 
 /* J5_0连接到哪个端口 */
 typedef enum _connectPortEnum {
-    connectJ0 = 1,
+    connectJ0 = 0,
-    connectJ5,
+    connectJ5 = 5,
     connectJ6,
     connectJ7,
     connectJ8,

CH32V303-FreeRTOS/App/functionalModule/Src/uart_dev.c

@@ -490,7 +490,6 @@ void J3_Interrupt()
             USART_ITConfig(J3_USART, USART_IT_TXE, DISABLE);
             // setJ3_485_SendState(0);
             J3_485_IN_TXE();
-            readJ3_485;
             return;
         }        
         USART_SendData(J3_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
@@ -500,6 +499,8 @@ void J3_Interrupt()
 #ifdef RS485BUSIDLE1
     /* 空闲中断 */
     if (USART_GetITStatus(J3_USART, USART_IT_IDLE) != RESET) {
+        J3_USART->STATR;
+        J3_USART->DATAR;
         J3_485_IN_IDLE();
     }
 #endif
@@ -529,7 +530,6 @@ void J5_0_Interrupt()
             USART_ITConfig(J5_0_USART, USART_IT_TXE, DISABLE);
             // setJ5_0_485_SendState(0);
             J5_0_485_IN_TXE();
-            readJ5_0_485;
             return;
         }
         USART_SendData(J5_0_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
@@ -539,6 +539,8 @@ void J5_0_Interrupt()
 #ifdef RS485BUSIDLE1
     /* 空闲中断 */
     if (USART_GetITStatus(J5_0_USART, USART_IT_IDLE) != RESET) {
+        J5_0_USART->STATR;
+        J5_0_USART->DATAR;
         J5_0_485_IN_IDLE();
     }
 #endif
@@ -594,7 +596,6 @@ void J1_Interrupt()
             USART_ITConfig(J1_USART, USART_IT_TXE, DISABLE);
             // setJ1_485_SendState(0);
             J1_485_IN_TXE();
-            readJ1_485;
             return;
         }
         USART_SendData(J1_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
@@ -604,6 +605,8 @@ void J1_Interrupt()
 #ifdef RS485BUSIDLE1
     /* 空闲中断 */
     if (USART_GetITStatus(J1_USART, USART_IT_IDLE) != RESET) {
+        J1_USART->STATR;
+        J1_USART->DATAR;
         J1_485_IN_IDLE();
     }
 #endif
@@ -633,7 +636,6 @@ void J2_Interrupt()
             USART_ITConfig(J2_USART, USART_IT_TXE, DISABLE);
             // setJ2_485_SendState(0);
             J2_485_IN_TXE();
-            readJ2_485;
             return;
         }
         USART_SendData(J2_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
@@ -643,6 +645,8 @@ void J2_Interrupt()
 #ifdef RS485BUSIDLE1
     /* 空闲中断 */
     if (USART_GetITStatus(J2_USART, USART_IT_IDLE) != RESET) {
+        J2_USART->STATR;
+        J2_USART->DATAR;
         J2_485_IN_IDLE();
     }
 #endif
@@ -672,7 +676,6 @@ void J4_Interrupt()
             USART_ITConfig(J4_USART, USART_IT_TXE, DISABLE);
             // setJ4_485_SendState(0);
             J4_485_IN_TXE();
-            readJ4_485;
             return;
         }
         USART_SendData(J4_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
@@ -682,6 +685,8 @@ void J4_Interrupt()
 #ifdef RS485BUSIDLE1
     /* 空闲中断 */
     if (USART_GetITStatus(J4_USART, USART_IT_IDLE) != RESET) {
+        J4_USART->STATR;
+        J4_USART->DATAR;
         J4_485_IN_IDLE();
     }
 #endif

CH32V303-FreeRTOS/App/hardwareDriver/Inc/HD_UART.h

@@ -51,6 +51,9 @@
 #define write485 Bit_SET
 #define read485 Bit_RESET
 
+
+void set_485_Read(void);
+
 /* J1_UART6 */
 void J1_485_Init(uint32_t baud);
 #define readJ1_485 GPIO_WriteBit(J1_DE_PROT, J1_DE_PIN, read485);

CH32V303-FreeRTOS/App/hardwareDriver/Src/HD_UART.c

@@ -14,6 +14,22 @@ void UART8_IRQHandler(void) __attribute__((interrupt()));
 #define write Bit_SET
 #define read Bit_RESET
 
+
+/*
+ * @brief   设置所有485状态为读
+ * @param   
+ * @retval
+ *
+ */
+void set_485_Read(void)
+{
+    readJ1_485;
+    readJ2_485;
+    readJ3_485;
+    readJ4_485;
+    readJ5_0_485;
+}
+
 /*
  * @brief   初始化UART6对应的J1_485,默认为接收
  * @param   baud    波特率
@@ -29,7 +45,8 @@ void J1_485_Init(uint32_t baud)
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
     GPIO_Init(J1_DE_PROT, &GPIO_InitStructure);
-    readJ1_485;
+    // readJ1_485;
+    writeJ1_485;
 
     USART_InitTypeDef  USART_InitStructure;
     NVIC_InitTypeDef   NVIC_InitStructure;
@@ -83,7 +100,8 @@ void J2_485_Init(uint32_t baud)
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
     GPIO_Init(J2_DE_PROT, &GPIO_InitStructure);
-    readJ2_485;
+    // readJ2_485;
+    writeJ2_485;
 
     USART_InitTypeDef  USART_InitStructure;
     NVIC_InitTypeDef   NVIC_InitStructure;
@@ -136,7 +154,8 @@ void J3_485_Init(uint32_t baud)
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
     GPIO_Init(J3_DE_PROT, &GPIO_InitStructure);
-    readJ3_485;
+    // readJ3_485;
+    writeJ3_485;
     
     USART_InitTypeDef  USART_InitStructure;
     NVIC_InitTypeDef   NVIC_InitStructure;
@@ -189,7 +208,8 @@ void J4_485_Init(uint32_t baud)
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
     GPIO_Init(J4_DE_PROT, &GPIO_InitStructure);
-    readJ4_485;
+    // readJ4_485;
+    writeJ4_485;
 
     USART_InitTypeDef  USART_InitStructure;
     NVIC_InitTypeDef   NVIC_InitStructure;
@@ -242,7 +262,8 @@ void J5_0_485_Init(uint32_t baud)
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
     GPIO_Init(J5_0_DE_PROT, &GPIO_InitStructure);
-    readJ5_0_485;
+    // readJ5_0_485;
+    writeJ5_0_485;
     // writeJ5_0_485;
     GPIO_InitStructure.GPIO_Pin = J5_0_A_PIN;
     GPIO_Init(J5_0_DE_PROT, &GPIO_InitStructure);

README.md

@@ -113,7 +113,7 @@ uint8_t *Buff = (uint8_t *)pvPortMalloc(200);
 
 ## 串口接收传感器数据
 
-
+100ms后，向上丢数据，或者空闲中断后向上丢数据