wxsmart-test
/
signal_generator
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tcp多端口绑定两路蓝牙

This commit is contained in:
王绪洁 2025-01-23 16:22:52 +08:00
parent f7b2b40310
commit ef179c9c81
6 changed files with 163 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Core/Inc/main.h
View File

@ -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
{

26
Core/Src/main.c
View File

@ -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));
}
}

11
Core/Src/stm32f4xx_it.c
View File

@ -33,8 +33,10 @@
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
extern struct tcp_pcb *server_pcb1;
extern struct tcp_pcb *server_pcb2;
extern struct tcp_pcb *server_pcb_hart1;
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);
}

2
MDK-ARM/TEST2.uvprojx
View File

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

6
User/application/inc/tcpserverc.h
View File

@ -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

159
User/application/src/tcpserverc.c
View File

@ -11,19 +11,23 @@
#include "usart.h"
#include "main.h"
#include "ht1200m.h"
struct tcp_pcb *server_pcb1 = NULL;
struct tcp_pcb *server_pcb2 = NULL;
extern uint8_t tcp_echo_flags;
struct tcp_pcb *server_pcb_hart1 = NULL;
struct tcp_pcb *server_pcb_hart2 = NULL;
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_pcb_hart2 = NULL;
struct tcp_pcb *server_hart1 = 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控制块 */
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);
}
}