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

网线热拔插-控制端口未复位

This commit is contained in:
王绪洁 2025-07-08 16:33:24 +08:00
parent 82a75d275a
commit 351e975c4d
5 changed files with 2911 additions and 2851 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
Core/Src/freertos.c
View File

@ -61,6 +61,7 @@ osThreadId ch438_taskHandle;
extern struct netif gnetif;
extern ETH_HandleTypeDef heth;
extern struct tcp_pcb *server_pcb_hart[TCP_MAX];
extern struct tcp_pcb *server_pcb_control;
/* USER CODE END FunctionPrototypes */
void start_lwip_task(void const *argument);
@ -171,6 +172,24 @@ void start_lwip_task(void const *argument)
}
}
}
if (tcp_echo_flags_control == 1)
{
if (((phyreg >> 2) & 0x1) != 0x1) // PHY_BSR寄存器的<E599A8>??2位表示PHY是否连接 PHY_LINKED_STATUS
{
/* When the netif link is down this function must be called */
netif_set_link_down(&gnetif);
netif_set_down(&gnetif); // 热插拔下线时调用
tcp_abort(server_pcb_control); // 热插拔下线时调用
tcp_echo_flags_control = 0;
}
else
{
/* When the netif is fully configured this function must be called */
netif_set_link_up(&gnetif);
netif_set_up(&gnetif); // 热插拔上线时调用
}
}
vTaskDelay(1000);
}

7
MDK-ARM/valve_debugging.uvoptx
View File

@ -255,6 +255,11 @@
<WinNumber>1</WinNumber>
<ItemText>current_buff</ItemText>
</Ww>
<Ww>
<count>21</count>
<WinNumber>1</WinNumber>
<ItemText>tcp_echo_flags_control</ItemText>
</Ww>
</WatchWindow1>
<WatchWindow2>
<Ww>
@ -285,7 +290,7 @@
<DebugFlag>
<trace>0</trace>
<periodic>1</periodic>
<aLwin>1</aLwin>
<aLwin>0</aLwin>
<aCover>0</aCover>
<aSer1>0</aSer1>
<aSer2>0</aSer2>

5653
MDK-ARM/valve_debugging/valve_debugging.hex
View File

File diff suppressed because it is too large Load Diff

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

@ -45,7 +45,7 @@ typedef enum
} tcp_port_e;
extern uint8_t tcp_echo_flags[TCP_MAX];
extern uint8_t tcp_echo_flags_control;
#define TCP_TRANSMIT_MAX 128
typedef struct
{

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

@ -24,6 +24,7 @@ struct tcp_pcb *server_pcb_control = NULL;
communication_ao_t *user_communication_ao = NULL;
uint8_t tcp_echo_flags[TCP_MAX] = {0};
uint8_t tcp_echo_flags_control = 0;
uart_t hart_uart[TCP_MAX] = {0};
/*接收回调函数*/
@ -32,7 +33,6 @@ static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART1] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART1] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART1].tx_data, 0, TCP_TRANSMIT_MAX);
@ -44,6 +44,7 @@ static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART1] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -54,7 +55,7 @@ static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART2] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART2] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART2].tx_data, 0, TCP_TRANSMIT_MAX);
@ -66,6 +67,7 @@ static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART2] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -76,7 +78,7 @@ static err_t tcpecho_recv_hart3(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART3] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART3] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART3].tx_data, 0, TCP_TRANSMIT_MAX);
@ -88,6 +90,7 @@ static err_t tcpecho_recv_hart3(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART3] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -98,7 +101,7 @@ static err_t tcpecho_recv_hart4(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART4] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART4] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART4].tx_data, 0, TCP_TRANSMIT_MAX);
@ -110,6 +113,7 @@ static err_t tcpecho_recv_hart4(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART4] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -120,7 +124,7 @@ static err_t tcpecho_recv_hart5(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART5] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART5] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART5].tx_data, 0, TCP_TRANSMIT_MAX);
@ -132,6 +136,7 @@ static err_t tcpecho_recv_hart5(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART5] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -142,7 +147,7 @@ static err_t tcpecho_recv_hart6(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART6] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART6] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART6].tx_data, 0, TCP_TRANSMIT_MAX);
@ -154,6 +159,7 @@ static err_t tcpecho_recv_hart6(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART6] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -164,7 +170,7 @@ static err_t tcpecho_recv_hart7(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART7] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART7] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART7].tx_data, 0, TCP_TRANSMIT_MAX);
@ -176,6 +182,7 @@ static err_t tcpecho_recv_hart7(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART7] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -186,7 +193,7 @@ static err_t tcpecho_recv_hart8(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART8] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART8] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART8].tx_data, 0, TCP_TRANSMIT_MAX);
@ -198,6 +205,7 @@ static err_t tcpecho_recv_hart8(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART8] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -208,7 +216,7 @@ static err_t tcpecho_recv_hart9(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART9] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART9] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART9].tx_data, 0, TCP_TRANSMIT_MAX);
@ -220,6 +228,7 @@ static err_t tcpecho_recv_hart9(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART9] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -230,7 +239,7 @@ static err_t tcpecho_recv_hart10(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART10] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART10] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART10].tx_data, 0, TCP_TRANSMIT_MAX);
@ -242,6 +251,7 @@ static err_t tcpecho_recv_hart10(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART10] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -252,7 +262,7 @@ static err_t tcpecho_recv_hart11(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART11] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART11] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART11].tx_data, 0, TCP_TRANSMIT_MAX);
@ -264,6 +274,7 @@ static err_t tcpecho_recv_hart11(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART11] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -274,7 +285,7 @@ static err_t tcpecho_recv_hart12(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART12] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART12] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART12].tx_data, 0, TCP_TRANSMIT_MAX);
@ -286,6 +297,7 @@ static err_t tcpecho_recv_hart12(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART12] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -296,7 +308,7 @@ static err_t tcpecho_recv_hart13(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART13] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART13] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART13].tx_data, 0, TCP_TRANSMIT_MAX);
@ -308,6 +320,7 @@ static err_t tcpecho_recv_hart13(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART13] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -318,7 +331,7 @@ static err_t tcpecho_recv_hart14(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART14] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART14] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART14].tx_data, 0, TCP_TRANSMIT_MAX);
@ -330,6 +343,7 @@ static err_t tcpecho_recv_hart14(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART14] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -340,7 +354,7 @@ static err_t tcpecho_recv_hart15(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART15] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART15] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART15].tx_data, 0, TCP_TRANSMIT_MAX);
@ -352,6 +366,7 @@ static err_t tcpecho_recv_hart15(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART15] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -362,7 +377,7 @@ static err_t tcpecho_recv_hart16(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
if (p != NULL)
{
/* 更新窗口*/
tcp_echo_flags[TCP_HART16] = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
server_pcb_hart[TCP_HART16] = tpcb; // 直接赋值
memset(hart_uart[TCP_HART16].tx_data, 0, TCP_TRANSMIT_MAX);
@ -374,6 +389,7 @@ static err_t tcpecho_recv_hart16(void *arg, struct tcp_pcb *tpcb, struct pbuf *p
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags[TCP_HART16] = 0;
return tcp_close(tpcb);
}
return ERR_OK;
@ -436,6 +452,7 @@ static err_t tcpecho_recv_control(void *arg, struct tcp_pcb *tpcb, struct pbuf *
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
tcp_echo_flags_control = 0;
return tcp_close(tpcb);
}
@ -446,14 +463,14 @@ static err_t tcpecho_accept_hart1(void *arg, struct tcp_pcb *newpcb, err_t err)
// 形参的数量和类型必须一致
{
tcp_recv(newpcb, tcpecho_recv_hart1); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART1] = 1;
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
tcp_echo_flags[TCP_HART2] = 1;
return ERR_OK;
}
@ -461,7 +478,7 @@ static err_t tcpecho_accept_hart3(void *arg, struct tcp_pcb *newpcb, err_t err)
// 形参的数量和类型必须一致
{
tcp_recv(newpcb, tcpecho_recv_hart3); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART3] = 1;
return ERR_OK;
}
@ -469,7 +486,7 @@ static err_t tcpecho_accept_hart4(void *arg, struct tcp_pcb *newpcb, err_t err)
// 形参的数量和类型必须一致
{
tcp_recv(newpcb, tcpecho_recv_hart4); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART4] = 1;
return ERR_OK;
}
@ -477,7 +494,7 @@ static err_t tcpecho_accept_hart5(void *arg, struct tcp_pcb *newpcb, err_t err)
// 形参的数量和类型必须一致
{
tcp_recv(newpcb, tcpecho_recv_hart5); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART5] = 1;
return ERR_OK;
}
@ -485,7 +502,7 @@ static err_t tcpecho_accept_hart6(void *arg, struct tcp_pcb *newpcb, err_t err)
// 形参的数量和类型必须一致
{
tcp_recv(newpcb, tcpecho_recv_hart6); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART6] = 1;
return ERR_OK;
}
@ -493,7 +510,7 @@ static err_t tcpecho_accept_hart7(void *arg, struct tcp_pcb *newpcb, err_t err)
// 形参的数量和类型必须一致
{
tcp_recv(newpcb, tcpecho_recv_hart7); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART7] = 1;
return ERR_OK;
}
@ -501,62 +518,64 @@ static err_t tcpecho_accept_hart8(void *arg, struct tcp_pcb *newpcb, err_t err)
// 形参的数量和类型必须一致
{
tcp_recv(newpcb, tcpecho_recv_hart8); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART8] = 1;
return ERR_OK;
}
static err_t tcpecho_accept_hart9(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_hart9); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART9] = 1;
return ERR_OK;
}
static err_t tcpecho_accept_hart10(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_hart10); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART10] = 1;
return ERR_OK;
}
static err_t tcpecho_accept_hart11(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_hart11); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART11] = 1;
return ERR_OK;
}
static err_t tcpecho_accept_hart12(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_hart12); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART12] = 1;
return ERR_OK;
}
static err_t tcpecho_accept_hart13(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_hart13); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART13] = 1;
return ERR_OK;
}
static err_t tcpecho_accept_hart14(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_hart14); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART14] = 1;
return ERR_OK;
}
static err_t tcpecho_accept_hart15(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_hart15); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART15] = 1;
return ERR_OK;
}
static err_t tcpecho_accept_hart16(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_hart16); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags[TCP_HART16] = 1;
return ERR_OK;
}
static err_t tcpecho_accept_control(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_control); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_echo_flags_control = 1;
return ERR_OK;
}
void tcp_echo_init(void)