tcp多端口绑定两路蓝牙

Core/Inc/main.h

@@ -41,8 +41,10 @@ extern "C"
 
 /* Exported types ------------------------------------------------------------*/
 /* USER CODE BEGIN ET */
-extern uint8_t tcp_echo_flags; // 标志位，连接成功置1
+extern uint8_t tcp_echo_flags_hart1; // 标志位，连接成功置1
 extern uint8_t tcp_echo_flags_hart2; // 标志位，连接成功置1
+extern uint8_t tcp_echo_flags_ble1;
+extern uint8_t tcp_echo_flags_ble2;
 #define ARRAY_LEN(arr) (sizeof(arr)) / (sizeof(arr[0]))
 typedef struct
 {

Core/Src/main.c

@@ -70,8 +70,10 @@ uart_t ble2_uart3 = {0};
 uart_t hart2_uart2 = {0};
 uart_t hart1_uart5 = {0};
 float current_buff[2] = {12.0f, 12.0f};
-uint8_t tcp_echo_flags = 0;
+uint8_t tcp_echo_flags_hart1 = 0;
 uint8_t tcp_echo_flags_hart2 = 0;
+uint8_t tcp_echo_flags_ble1 = 0;
+uint8_t tcp_echo_flags_ble2 = 0;
 /* USER CODE END 0 */
 
 /**
@@ -135,7 +137,7 @@ int main(void)
 
     /* USER CODE BEGIN 3 */
     MX_LWIP_Process();
-    ad7124_get_analog(STOP_NC_ADC);
+    // ad7124_get_analog(STOP_NC_ADC);
 
     dac161s997_output(DAC161S997_1, current_buff[0]);
     dac161s997_output(DAC161S997_2, current_buff[1]);
@@ -197,23 +199,16 @@ void SystemClock_Config(void)
 ******************************************************************************/
 void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
 {
-  if (huart == &huart4)
-  {
-    __HAL_UNLOCK(huart);
-    lcd_uart4.rx_num = Size;
-    memset(lcd_uart4.rx_data, 0, ARRAY_LEN(lcd_uart4.rx_data));
-    memcpy(lcd_uart4.rx_data, lcd_uart4.rx_data_temp, Size);
-    // 网口透传
-    user_send_data(lcd_uart4.rx_data, Size);
-    HAL_UARTEx_ReceiveToIdle_DMA(&huart4, lcd_uart4.rx_data_temp, ARRAY_LEN(lcd_uart4.rx_data_temp));
-  }
   if (huart == &huart6)
   {
     __HAL_UNLOCK(huart);
     ble1_uart6.rx_num = Size;
     memset(ble1_uart6.rx_data, 0, ARRAY_LEN(ble1_uart6.rx_data));
     memcpy(ble1_uart6.rx_data, ble1_uart6.rx_data_temp, Size);
-    user_send_data(ble1_uart6.rx_data, Size);
+    if (tcp_echo_flags_ble1 == 1)
+    {
+      user_send_data_ble1(ble1_uart6.rx_data, Size);
+    }
     HAL_UARTEx_ReceiveToIdle_DMA(&huart6, ble1_uart6.rx_data_temp, ARRAY_LEN(ble1_uart6.rx_data_temp));
   }
   if (huart == &huart3)
@@ -222,7 +217,10 @@ void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
     ble2_uart3.rx_num = Size;
     memset(ble2_uart3.rx_data, 0, ARRAY_LEN(ble2_uart3.rx_data));
     memcpy(ble2_uart3.rx_data, ble2_uart3.rx_data_temp, Size);
-    user_send_data(ble2_uart3.rx_data, Size);
+    if (tcp_echo_flags_ble2 == 1)
+    {
+      user_send_data_ble2(ble2_uart3.rx_data, Size);
+    }
     HAL_UARTEx_ReceiveToIdle_DMA(&huart3, ble2_uart3.rx_data_temp, ARRAY_LEN(ble2_uart3.rx_data_temp));
   }
 }

Core/Src/stm32f4xx_it.c

@@ -33,8 +33,10 @@
 
 /* Private define ------------------------------------------------------------*/
 /* USER CODE BEGIN PD */
-extern struct tcp_pcb *server_pcb1;
+extern struct tcp_pcb *server_pcb_hart1;
-extern struct tcp_pcb *server_pcb2;
+extern struct tcp_pcb *server_pcb_hart2;
+extern struct tcp_pcb *server_pcb_ble1;
+extern struct tcp_pcb *server_pcb_ble2;
 /* USER CODE END PD */
 
 /* Private macro -------------------------------------------------------------*/
@@ -386,7 +388,10 @@ void UART5_IRQHandler(void)
   // 空闲中断
   if (__HAL_UART_GET_FLAG(&huart5, UART_FLAG_IDLE) != RESET)
   {
-    user_send_data(hart1_uart5.rx_data, hart1_uart5.rx_num);
+    if (tcp_echo_flags_hart1 == 1)
+    {
+      user_send_data_hart1(hart1_uart5.rx_data, hart1_uart5.rx_num);
+    }
     hart1_uart5.rx_num = 0;
     __HAL_UART_CLEAR_IDLEFLAG(&huart5);
   }

MDK-ARM/TEST2.uvprojx

@@ -81,7 +81,7 @@
           </BeforeMake>
           <AfterMake>
             <RunUserProg1>0</RunUserProg1>
-            <RunUserProg2>1</RunUserProg2>
+            <RunUserProg2>0</RunUserProg2>
             <UserProg1Name></UserProg1Name>
             <UserProg2Name></UserProg2Name>
             <UserProg1Dos16Mode>0</UserProg1Dos16Mode>

User/application/inc/tcpserverc.h

@@ -5,8 +5,12 @@
 
 #define TCP_PORT_HART1 5001
 #define TCP_PORT_HART2 5002
+#define TCP_PORT_BLE1 5003
+#define TCP_PORT_BLE2 5004
 
 extern void tcp_echo_init(void);
-extern void user_send_data(uint8_t *data, uint16_t len);
+extern void user_send_data_hart1(uint8_t *data, uint16_t len);
 extern void user_send_data_hart2(uint8_t *data, uint16_t len);
+extern void user_send_data_ble1(uint8_t *data, uint16_t len);
+extern void user_send_data_ble2(uint8_t *data, uint16_t len);
 #endif

User/application/src/tcpserverc.c

@@ -11,19 +11,23 @@
 #include "usart.h"
 #include "main.h"
 #include "ht1200m.h"
-struct tcp_pcb *server_pcb1 = NULL;
+struct tcp_pcb *server_pcb_hart1 = NULL;
-struct tcp_pcb *server_pcb2 = NULL;
+struct tcp_pcb *server_pcb_hart2 = NULL;
-extern uint8_t tcp_echo_flags;
+struct tcp_pcb *server_pcb_ble1 = NULL;
+struct tcp_pcb *server_pcb_ble2 = NULL;
+extern uint8_t tcp_echo_flags_hart1;
 extern uint8_t tcp_echo_flags_hart2;
+extern uint8_t tcp_echo_flags_ble1;
+extern uint8_t tcp_echo_flags_ble2;
 /*接收回调函数*/
-static err_t tcpecho_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
+static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
 { // 对应接收数据连接的控制块   接收到的数据
     if (p != NULL)
     {
         /* 更新窗口*/
-        tcp_echo_flags = 1;
+        tcp_echo_flags_hart1 = 1;
         tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
-        memcpy(&server_pcb1, &tpcb, sizeof(struct tcp_pcb *));
+        memcpy(&server_pcb_hart1, &tpcb, sizeof(struct tcp_pcb *));
 #if 0
         memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len);
         HART2_RTS_SEND;
@@ -33,7 +37,7 @@ static err_t tcpecho_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t
 #if 1
         memcpy(hart1_uart5.tx_data, (int *)p->payload, p->tot_len);
         HART1_RTS_SEND;
-        HAL_UART_Transmit(&huart5, hart1_uart5.tx_data, p->tot_len, 1000);
+        HAL_UART_Transmit(&huart5, hart1_uart5.tx_data, p->tot_len, 500);
         HART1_RTS_RECEIVE;
 #endif
 #if 0
@@ -65,11 +69,11 @@ static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
         /* 更新窗口*/
         tcp_echo_flags_hart2 = 1;
         tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
-        memcpy(&server_pcb2, &tpcb, sizeof(struct tcp_pcb *));
+        memcpy(&server_pcb_hart2, &tpcb, sizeof(struct tcp_pcb *));
 #if 1
         memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len);
         HART2_RTS_SEND;
-        HAL_UART_Transmit(&huart2, hart2_uart2.tx_data, p->tot_len, 1000);
+        HAL_UART_Transmit(&huart2, hart2_uart2.tx_data, p->tot_len, 500);
         HART2_RTS_RECEIVE;
 #endif
 #if 0
@@ -100,61 +104,162 @@ static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
     return ERR_OK;
 }
 
-static err_t tcpecho_accept(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
+static err_t tcpecho_recv_ble1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
-                                                                          // 形参的数量和类型必须一致
+{ // 对应接收数据连接的控制块   接收到的数据
+    if (p != NULL)
+    {
+        /* 更新窗口*/
+        tcp_echo_flags_ble1 = 1;
+        tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
+        memcpy(&server_pcb_ble1, &tpcb, sizeof(struct tcp_pcb *));
+
+        memcpy(ble1_uart6.tx_data, (int *)p->payload, p->tot_len);
+        HART2_RTS_SEND;
+        HAL_UART_Transmit(&huart6, ble1_uart6.tx_data, p->tot_len, 500);
+        HART2_RTS_RECEIVE;
+
+        memset(p->payload, 0, p->tot_len);
+        pbuf_free(p);
+    }
+    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
+    {
+        return tcp_close(tpcb);
+    }
+    return ERR_OK;
+}
+
+static err_t tcpecho_recv_ble2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
+{ // 对应接收数据连接的控制块   接收到的数据
+    if (p != NULL)
+    {
+        /* 更新窗口*/
+        tcp_echo_flags_ble2 = 1;
+        tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
+        memcpy(&server_pcb_ble2, &tpcb, sizeof(struct tcp_pcb *));
+
+        memcpy(ble2_uart3.tx_data, (int *)p->payload, p->tot_len);
+        HART2_RTS_SEND;
+        HAL_UART_Transmit(&huart3, ble2_uart3.tx_data, p->tot_len, 500);
+        HART2_RTS_RECEIVE;
+
+        memset(p->payload, 0, p->tot_len);
+        pbuf_free(p);
+    }
+    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
+    {
+        return tcp_close(tpcb);
+    }
+    return ERR_OK;
+}
+static err_t tcpecho_accept_hart1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
+                                                                                // 形参的数量和类型必须一致
 {
-    tcp_recv(newpcb, tcpecho_recv); // 当收到数据时，回调用户自己写的tcpecho_recv
+    tcp_recv(newpcb, tcpecho_recv_hart1); // 当收到数据时，回调用户自己写的tcpecho_recv
 
     return ERR_OK;
 }
 
 static err_t tcpecho_accept_hart2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
-                                                                                // 形参的数量和类型必须一致
 {
     tcp_recv(newpcb, tcpecho_recv_hart2); // 当收到数据时，回调用户自己写的tcpecho_recv
 
     return ERR_OK;
 }
+
+static err_t tcpecho_accept_ble1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
+{
+    tcp_recv(newpcb, tcpecho_recv_ble1); // 当收到数据时，回调用户自己写的tcpecho_recv
+
+    return ERR_OK;
+}
+static err_t tcpecho_accept_ble2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
+{
+    tcp_recv(newpcb, tcpecho_recv_ble2); // 当收到数据时，回调用户自己写的tcpecho_recv
+
+    return ERR_OK;
+}
 void tcp_echo_init(void)
 {
-    struct tcp_pcb *server_pcb_hart1 = NULL;
+    struct tcp_pcb *server_hart1 = NULL;
-    struct tcp_pcb *server_pcb_hart2 = NULL;
+    struct tcp_pcb *server_hart2 = NULL;
+    struct tcp_pcb *server_ble1 = NULL;
+    struct tcp_pcb *server_ble2 = NULL;
+
     /* 创建一个TCP控制块  */
-    server_pcb_hart1 = tcp_new();
+    server_hart1 = tcp_new();
 
     /* 绑定TCP控制块 */
-    tcp_bind(server_pcb_hart1, IP_ADDR_ANY, TCP_PORT_HART1);
+    tcp_bind(server_hart1, IP_ADDR_ANY, TCP_PORT_HART1);
 
     /* 进入监听状态 */
-    server_pcb_hart1 = tcp_listen(server_pcb_hart1);
+    server_hart1 = tcp_listen(server_hart1);
 
     /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
-    tcp_accept(server_pcb_hart1, tcpecho_accept); // 侦听到连接后，回调用户编写的tcpecho_accept
+    tcp_accept(server_hart1, tcpecho_accept_hart1); // 侦听到连接后，回调用户编写的tcpecho_accept
-                                                  /*************************************************************************/
+
-                                                  /* 创建一个TCP控制块  */
+    /* 创建一个TCP控制块  */
-    server_pcb_hart2 = tcp_new();
+    server_hart2 = tcp_new();
 
     /* 绑定TCP控制块 */
-    tcp_bind(server_pcb_hart2, IP_ADDR_ANY, TCP_PORT_HART2);
+    tcp_bind(server_hart2, IP_ADDR_ANY, TCP_PORT_HART2);
 
     /* 进入监听状态 */
-    server_pcb_hart2 = tcp_listen(server_pcb_hart2);
+    server_hart2 = tcp_listen(server_hart2);
 
     /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
-    tcp_accept(server_pcb_hart2, tcpecho_accept_hart2); // 侦听到连接后，回调用户编写的tcpecho_accept
+    tcp_accept(server_hart2, tcpecho_accept_hart2); // 侦听到连接后，回调用户编写的tcpecho_accept
+
+    /* 创建一个TCP控制块  */
+    server_ble1 = tcp_new();
+
+    /* 绑定TCP控制块 */
+    tcp_bind(server_ble1, IP_ADDR_ANY, TCP_PORT_BLE1);
+
+    /* 进入监听状态 */
+    server_ble1 = tcp_listen(server_ble1);
+
+    /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
+    tcp_accept(server_ble1, tcpecho_accept_ble1); // 侦听到连接后，回调用户编写的tcpecho_accept
+
+    /* 创建一个TCP控制块  */
+    server_ble2 = tcp_new();
+
+    /* 绑定TCP控制块 */
+    tcp_bind(server_ble2, IP_ADDR_ANY, TCP_PORT_BLE2);
+
+    /* 进入监听状态 */
+    server_ble2 = tcp_listen(server_ble2);
+
+    /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
+    tcp_accept(server_ble2, tcpecho_accept_ble2); // 侦听到连接后，回调用户编写的tcpecho_accept
 }
 
-void user_send_data(uint8_t *data, uint16_t len)
+void user_send_data_hart1(uint8_t *data, uint16_t len)
 {
-    if (tcp_echo_flags == 1)
+    if (tcp_echo_flags_hart1 == 1)
     {
-        tcp_write(server_pcb1, data, len, 1);
+        tcp_write(server_pcb_hart1, data, len, 1);
     }
 }
 void user_send_data_hart2(uint8_t *data, uint16_t len)
 {
     if (tcp_echo_flags_hart2 == 1)
     {
-        tcp_write(server_pcb2, data, len, 1);
+        tcp_write(server_pcb_hart2, data, len, 1);
+    }
+}
+
+void user_send_data_ble1(uint8_t *data, uint16_t len)
+{
+    if (tcp_echo_flags_ble1 == 1)
+    {
+        tcp_write(server_pcb_ble1, data, len, 1);
+    }
+}
+void user_send_data_ble2(uint8_t *data, uint16_t len)
+{
+    if (tcp_echo_flags_ble2 == 1)
+    {
+        tcp_write(server_pcb_ble2, data, len, 1);
     }
 }