wandering1/STM32F4-Base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改一些注释

Browse Source
This commit is contained in:
wandering1
2026-08-25 11:49:31 +08:00
parent 4375873083
commit d6bc3f6253
6 changed files with 496 additions and 347 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Drivers/BSP/CH395F/ch395f.c
View File

@@ -332,9 +332,9 @@ void ch395f_set_fun_para(uint32_t para) {
}
/*
* 函数功能：设置TCP最大分段大小（MSS）
* 函数功能：设置 TCP 最大分段大小（MSS）
* 入口参数：mss - MSS值 uint16_t 60 - 1460
* 限定条件：必须在ch395f_init()之前调用
* 限定条件：必须在 ch395f_init() 之前调用
*/
void ch395f_set_tcp_mss(uint16_t mss) {
/* 启动SPI事务 */

157
Drivers/BSP/NET/net_select.c
View File

@@ -34,17 +34,18 @@ static int check_socket_error(int sockfd);
/*
* 函数功能：I/O 多路复用（select 模式），等待多个 Socket 的读写事件就绪
* 入口参数：nfds - 最大文件描述符数 +1 int > 0
* readfds - 读事件集合指针 net_fd_set *（可为 NULL）
* writefds - 写事件集合指针 net_fd_set *（可为 NULL）
* exceptfds- 异常事件集合指针 net_fd_set *（可为 NULL）
* timeout - 超时时间结构体指针 net_timeval *（NULL=无限等待）
* 返回值：就绪的 Socket 数量 int >= 0 || -1
* -1 - 参数无效 int
* 入口参数：nfds - 最大文件描述符数 +1 int > 0
* readfds - 读事件集合指针 net_fd_set *（可为 NULL）
* writefds - 写事件集合指针 net_fd_set *（可为 NULL）
* exceptfds- 异常事件集合指针 net_fd_set *（可为 NULL）
* timeout - 超时时间结构体指针 net_timeval *（NULL=无限等待）
* 出口参数：readfds/writefds/exceptfds - 仅保留就绪的 Socket 位 net_fd_set *
* 返回值：就绪的 Socket 数量（>= 0）；-1 表示参数无效 int
* 限定条件：net_init() + MX_FREERTOS_Init() 已执行；必须在 netTask 上下文中调用
* 函数说明：轮询所有 Socket，检查读/写/异常事件是否就绪。阻塞等待直到有事件或超时
* 函数说明：1. 轮询所有 Socket，检查读/写/异常事件是否就绪
* 2. 阻塞等待直到有事件就绪或超时
* 3. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率
*/
int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
net_fd_set *exceptfds, net_timeval *timeout) {
uint32_t start_tick;
@@ -55,8 +56,13 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
int ready_count = 0;
int i;
/* 计算超时时间 */
if (timeout != NULL) {
/* 检查输入参数合法性 */
if ((0 >= nfds) || (NET_MAX_SOCKETS < nfds)) {
return -1;
}
/* 计算超时时间（毫秒） */
if (NULL != timeout) {
timeout_ms = (uint32_t)(timeout->tv_sec * 1000) +
(uint32_t)(timeout->tv_usec / 1000);
}
@@ -64,37 +70,37 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
start_tick = HAL_GetTick();
while (1) {
/* 轮询所<EFBFBD>?Socket */
/* 轮询所有 Socket */
net_poll();
ready_count = 0;
/* 检查哪<EFBFBD>?Socket 有事<EFBFBD>?*/
/* 检查哪个 Socket 有事件 */
for (i = 0; i < nfds && i < NET_MAX_SOCKETS; i++) {
net_sock_t *p_sock = net_get_sock(i);
if (p_sock == NULL) {
if (NULL == p_sock) {
continue;
}
/* 检查可读事<EFBFBD>?*/
if (readfds != NULL && NET_FD_ISSET(i, readfds)) {
/* 检查可读事件 */
if ((NULL != readfds) && NET_FD_ISSET(i, readfds)) {
if (check_socket_readable(i)) {
NET_FD_SET(i, &result_read);
ready_count++;
}
}
/* 检查可写事<EFBFBD>?*/
if (writefds != NULL && NET_FD_ISSET(i, writefds)) {
/* 检查可写事件 */
if ((NULL != writefds) && NET_FD_ISSET(i, writefds)) {
if (check_socket_writable(i)) {
NET_FD_SET(i, &result_write);
ready_count++;
}
}
/* 检查异常事<EFBFBD>?*/
if (exceptfds != NULL && NET_FD_ISSET(i, exceptfds)) {
/* 检查异常事件 */
if ((NULL != exceptfds) && NET_FD_ISSET(i, exceptfds)) {
if (check_socket_error(i)) {
NET_FD_SET(i, &result_except);
ready_count++;
@@ -103,14 +109,14 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
}
/* 有事件就绪，返回 */
if (ready_count > 0) {
if (0 < ready_count) {
break;
}
/* 超时检<EFBFBD>?*/
if (timeout != NULL) {
if (timeout_ms > 0 &&
(HAL_GetTick() - start_tick) >= timeout_ms) {
/* 超时检测 */
if (NULL != timeout) {
if ((0 < timeout_ms) &&
((HAL_GetTick() - start_tick) >= timeout_ms)) {
break; /* 超时返回 0 */
}
}
@@ -119,14 +125,14 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
osDelay(1); /* 1ms 周期轮询，平衡实时性和 CPU 利用率 */
}
/* 复制结果 */
if (readfds != NULL) {
/* 复制结果集合 */
if (NULL != readfds) {
readfds->fd_bits = result_read.fd_bits;
}
if (writefds != NULL) {
if (NULL != writefds) {
writefds->fd_bits = result_write.fd_bits;
}
if (exceptfds != NULL) {
if (NULL != exceptfds) {
exceptfds->fd_bits = result_except.fd_bits;
}
@@ -135,20 +141,22 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
/*
* 函数功能：I/O 多路复用（poll 模式），等待多个 Socket 的读写事件就绪
* 入口参数：fds - pollfd 数组指针 net_pollfd *
* nfds - 数组元素数量 int > 0
* timeout - 超时时间（毫秒） int >= 0
* 返回值：就绪的 fd 数量 int >= 0 || -1
* -1 - 参数无效 int
* 入口参数：fds - pollfd 数组指针 net_pollfd *
* nfds - 数组元素数量 int > 0
* timeout - 超时时间（毫秒） int >= 0（-1=无限等待，但本实现按 >=0 处理）
* 出口参数：fds[i].revents - 填充实际发生的事件掩码 short
* 返回值：就绪的 fd 数量（>= 0）；-1 表示参数无效 int
* 限定条件：net_init() + MX_FREERTOS_Init() 已执行；必须在 netTask 上下文中调用
* 函数说明：轮询所有 Socket，检查读/写/错误/挂起事件是否就绪。阻塞等待直到有事件或超时
* 函数说明：1. 轮询所有 Socket，检查读/写/错误/挂起事件是否就绪
* 2. 阻塞等待直到有事件就绪或超时
* 3. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率
*/
int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
uint32_t start_tick;
int ready = 0;
int i;
if (fds == NULL || nfds <= 0) {
if ((NULL == fds) || (0 >= nfds)) {
return -1;
}
@@ -163,8 +171,8 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
for (i = 0; i < nfds; i++) {
fds[i].revents = 0;
/* 检<EFBFBD>?fd 有效<EFBFBD>?*/
if (fds[i].fd < 0 || fds[i].fd >= NET_MAX_SOCKETS) {
/* 检查 fd 有效性 */
if ((0 > fds[i].fd) || (NET_MAX_SOCKETS <= fds[i].fd)) {
fds[i].revents |= NET_POLLNVAL;
ready++;
continue;
@@ -172,13 +180,13 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
net_sock_t *p_sock = net_get_sock(fds[i].fd);
if (p_sock == NULL) {
if (NULL == p_sock) {
fds[i].revents |= NET_POLLNVAL;
ready++;
continue;
}
/* 检查可<EFBFBD>?*/
/* 检查可读 */
if (fds[i].events & NET_POLLIN) {
if (check_socket_readable(fds[i].fd)) {
fds[i].revents |= NET_POLLIN;
@@ -186,7 +194,7 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
}
}
/* 检查可<EFBFBD>?*/
/* 检查可写 */
if (fds[i].events & NET_POLLOUT) {
if (check_socket_writable(fds[i].fd)) {
fds[i].revents |= NET_POLLOUT;
@@ -194,26 +202,26 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
}
}
/* 检查错<EFBFBD>?*/
/* 检查错误 */
if (check_socket_error(fds[i].fd)) {
fds[i].revents |= NET_POLLERR;
ready++;
}
/* 检查挂起（连接断开<EFBFBD>?*/
if (p_sock->state == NET_SOCK_STATE_TCP_ACCEPT ||
p_sock->state == NET_SOCK_STATE_CLOSED) {
/* 检查挂起（连接断开） */
if ((NET_SOCK_STATE_TCP_ACCEPT == p_sock->state) ||
(NET_SOCK_STATE_CLOSED == p_sock->state)) {
fds[i].revents |= NET_POLLHUP;
ready++;
}
}
if (ready > 0) {
if (0 < ready) {
break;
}
/* 超时检<EFBFBD>?*/
if (timeout >= 0) {
/* 超时检测 */
if (0 <= timeout) {
if ((HAL_GetTick() - start_tick) >= (uint32_t)timeout) {
break;
}
@@ -227,29 +235,36 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
}
/*
* 私有函数实现<EFBFBD>? */
* 私有函数实现区
*/
/*
* 函数功能：检<EFBFBD>?Socket 是否可读
* 返回值：1 可读<E58FAF>? 不可<E4B88D>? */
* 函数功能：检查指定 Socket 当前是否可读
* 入口参数：sockfd - 待检查的 Socket 描述符 int 0 - NET_MAX_SOCKETS-1
* 出口参数：无
* 返回值：1 - 可读（监听态有新连接，或已连接态接收缓冲非空）；0 - 不可读或描述符无效 int
* 限定条件：net_init() 已调用
* 函数说明：1. 监听态 Socket 视为可读（存在可 accept 的新连接）
* 2. 已建立连接且接收缓冲区长度大于 0 时视为可读
*/
static int check_socket_readable(int sockfd) {
net_sock_t *p_sock;
uint16_t recv_len;
p_sock = net_get_sock(sockfd);
if (p_sock == NULL) {
if (NULL == p_sock) {
return 0;
}
/* 监听 Socket 有新连接时可<EFBFBD>?*/
if (p_sock->state == NET_SOCK_STATE_LISTENING) {
/* 监听 Socket 有新连接时可读 */
if (NET_SOCK_STATE_LISTENING == p_sock->state) {
return 1;
}
/* 已建立连接的 Socket 有数据可<EFBFBD>?*/
if (p_sock->state == NET_SOCK_STATE_ESTABLISHED) {
/* 已建立连接的 Socket 有数据可读 */
if (NET_SOCK_STATE_ESTABLISHED == p_sock->state) {
recv_len = ch395f_get_recv_len(sockfd);
if (recv_len > 0) {
if (0 < recv_len) {
return 1;
}
}
@@ -258,18 +273,23 @@ static int check_socket_readable(int sockfd) {
}
/*
* 函数功能：检<EFBFBD>?Socket 是否可写
* 返回值：1 可写<E58FAF>? 不可<E4B88D>? */
* 函数功能：检查指定 Socket 当前是否可写
* 入口参数：sockfd - 待检查的 Socket 描述符 int 0 - NET_MAX_SOCKETS-1
* 出口参数：无
* 返回值：1 - 可写（已连接且发送缓冲空闲）；0 - 不可写或描述符无效 int
* 限定条件：net_init() 已调用
* 函数说明：1. 仅已建立连接且 send_ready 标志置位的 Socket 视为可写
*/
static int check_socket_writable(int sockfd) {
net_sock_t *p_sock;
p_sock = net_get_sock(sockfd);
if (p_sock == NULL) {
if (NULL == p_sock) {
return 0;
}
/* 已建立连接的 Socket 发送缓冲区空闲时可<EFBFBD>?*/
if (p_sock->state == NET_SOCK_STATE_ESTABLISHED) {
/* 已建立连接的 Socket 发送缓冲区空闲时可写 */
if (NET_SOCK_STATE_ESTABLISHED == p_sock->state) {
if (p_sock->send_ready) {
return 1;
}
@@ -279,17 +299,24 @@ static int check_socket_writable(int sockfd) {
}
/*
* 函数功能：检<EFBFBD>?Socket 是否有错<EFBFBD>? * 返回值：1 有错误，0 无错<E697A0>? */
* 函数功能：检查指定 Socket 是否存在错误状态
* 入口参数：sockfd - 待检查的 Socket 描述符 int 0 - NET_MAX_SOCKETS-1
* 出口参数：无
* 返回值：1 - 有错误（含描述符越界或 Socket 未分配）；0 - 无错误 int
* 限定条件：无
* 函数说明：1. 描述符越界视为错误
* 2. 未分配（net_get_sock 返回 NULL）的 Socket 视为错误
*/
static int check_socket_error(int sockfd) {
net_sock_t *p_sock;
/* 无效 fd 视为错误 */
if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) {
if ((0 > sockfd) || (NET_MAX_SOCKETS <= sockfd)) {
return 1;
}
p_sock = net_get_sock(sockfd);
if (p_sock == NULL) {
if (NULL == p_sock) {
return 1; /* 未使用的 Socket 视为错误 */
}

400
Drivers/BSP/NET/net_socket.c
View File

@@ -34,7 +34,7 @@
/*
* 全局变量定义区 - 尽量避免使用全局变量
*/
static net_sock_t s_net_socks[NET_MAX_SOCKETS]; /* Socket 控制块数组 */
static net_sock_t s_net_socks[NET_MAX_SOCKETS]; /* Socket 控制块数组 */
static int s_net_errno = 0; /* 最后错误码 */
static uint8_t s_net_initialized = 0; /* 初始化标志 */
static uint8_t s_local_ip[4]; /* 本机 IP 缓存（网络序，net_getsockname 用） */
@@ -50,9 +50,6 @@ extern osMessageQueueId_t netMsgQueueHandle; /* CubeMX 生成的消息
/*
* 私有函数声明区
*/
@@ -115,17 +112,17 @@ int net_init(const char *ip, const char *mask, const char *gateway) {
/* 设置 TCP MSS */
ch395f_set_tcp_mss(1460);
/* 设置 TCP 重传参数（必须在 INIT_CH395 之前<EFBFBD>?*/
ch395f_set_retrans_count(8); /* 重传 8 <EFBFBD>?*/
/* 设置 TCP 重传参数（必须在 INIT_CH395 之前调用*/
ch395f_set_retrans_count(8); /* 重传 8 次*/
ch395f_set_retrans_period(500); /* 每次间隔 500ms，总计 4s 重传窗口 */
/* 设置 TCP KeepAlive 参数（必须在 INIT_CH395 之前，单<EFBFBD>?ms，必须为 500 的倍数，IDLE > INTVL<56>?*/
ch395f_set_keepalive_idle(60000); /* 空闲 60 秒后开始探<EFBFBD>?*/
ch395f_set_keepalive_intvl(5000); /* <EFBFBD>?5 秒探测一<EFBFBD>?*/
ch395f_set_keepalive_cnt(3); /* 最多探<EFBFBD>?3 <20>?*/
/* 设置 TCP KeepAlive 参数（必须在 INIT_CH395 之前，单位 ms，必须为 500 的倍数，IDLE > INTVL<56>?*/
ch395f_set_keepalive_idle(60000); /* 空闲 60 秒后开始探测*/
ch395f_set_keepalive_intvl(5000); /* 5 秒探测一次*/
ch395f_set_keepalive_cnt(3); /* 最多探 3 次*/
/* 设置网络参数（必须在 INIT_CH395 之前<EFBFBD>?*/
if (ip != NULL) {
/* 设置网络参数（必须在 INIT_CH395 之前调用 */
if (NULL != ip) {
uint8_t ip_arr[4];
uint8_t mask_arr[4];
uint8_t gw_arr[4];
@@ -144,7 +141,7 @@ int net_init(const char *ip, const char *mask, const char *gateway) {
ch395f_set_dhcp(1);
}
/* 初始<EFBFBD>?CH395F 协议栈（先不配置 buffer，测试默认值是否工作） */
/* 初始化 CH395F 协议栈（先不配置 buffer，测试默认值是否工作） */
ret = ch395f_init();
if (ret != CH395F_STATUS_OK) {
s_net_errno = NET_ERR;
@@ -169,94 +166,86 @@ int net_init(const char *ip, const char *mask, const char *gateway) {
* 4. RECV 中断为电平触发，每次 net_poll() 只处理一批中断，避免主循环饿死
*/
int net_poll(void) {
/* 本次轮询累计发生的事件数（连接/断开/接收/发送/超时各计 1） */
int event_count = 0;
int i;
/* 全局中断状态寄存器值（CH395F GET_GLOB_INT_STATUS_ALL 为 16 位） */
uint16_t int_status;
/* 防御性检查：尚未初始化则不处理任何中断，直接返回 */
if (!s_net_initialized) {
return 0;
}
/*
* GPIO 轮询模式：仅当 INT# 有效（低电平）时读取中断状态。
* 读取 GET_GLOB_INT_STATUS_ALL，CH395F 拉高 INT#；若仍有中断则再次拉低。
* 采用 do-while(0) 实现“单次批处理”：
* 本函数每被调用一次只读取并处理一批中断，处理完立即返回，不循环等待，
* 避免 RECV 电平中断导致主循环（如 echo）饿死。
* 循环体内部用 break 提前退出（INT# 无效或无中断时）。
*/
do
{
/*
* GPIO 轮询 INT# 引脚：低电平有效（有中断待处理）。
* 采用 GPIO 轮询而非 EXTI 边沿中断，仅当 INT# 为低电平时才读取状态，减少不必要 SPI 事务。
* 若 INT# 为高（无效），直接退出本次轮询。
*/
if (HAL_GPIO_ReadPin(CH395_INT_GPIO_Port, CH395_INT_Pin) == GPIO_PIN_SET) {
break;
}
/* 读取全局中断状态（2 字节）：读操作本身会清除 CH395F 中断并使其拉高 INT#，
* 若此后仍有新中断，CH395F 会再次拉低 INT#，由下一次 net_poll() 处理 */
int_status = ch395f_get_glob_int_status_all();
/* 无有效中断（读到的状态为 0），提前退出 */
if (int_status == 0) {
break;
}
/* 诊断：每 3 秒打印一次全局中断状态和 Socket 状态。
* 注意：使用已读取的 int_status，不要再读 GINT（读即清除）。 */
// static uint32_t s_last_diag = 0;
// uint32_t now_diag = HAL_GetTick();
// if ((now_diag - s_last_diag >= 3000) || s_last_diag == 0) {
// s_last_diag = now_diag;
// DBG_INFO("GINT=0x%04X", int_status);
// for (int di = 0; di < NET_MAX_SOCKETS; di++) {
// DBG_INFO(" s%d: in_use=%d state=%d",
// di, s_net_socks[di].in_use, s_net_socks[di].state);
// }
// }
if (int_status & CH395F_GINT_STAT_PHY_CHANGE) {
uint8_t phy = ch395f_get_phy_status();
DBG_INFO("PHY_CHANGE: 0x%02X", phy);
if (phy == CH395F_PHY_DISCONN) {
DBG_ERROR("PHY disconnected, sockets may need recovery");
}
}
/* 处理每个 Socket */
for (i = 0; i < NET_MAX_SOCKETS; i++) {
/* 遍历所有 Socket，处理各自的中断 */
for (int i = 0; i < NET_MAX_SOCKETS; i++) {
/* 取本 Socket 控制块（直接用数组下标，无需 net_get_sock 的越界判断） */
net_sock_t *p_sock = &s_net_socks[i];
/* 检查该 Socket 是否有中断（全局中断状<EFBFBD>?bit4~bit11 对应 socket0~7<EFBFBD>?*/
/* 全局中断状态 bit4~bit11 分别对应 socket0~socket7 的中断标志，
* 对应位为 0 说明该 Socket 无中断，跳过以节省时间 */
if (!(int_status & (1U << (i + 4)))) {
continue;
}
/* 读取 Socket 中断状<EFBFBD>?*/
/* 读取该 Socket 的中断状态寄存器（SINT） */
uint8_t sock_int = ch395f_get_sock_int_status(i);
//DBG_INFO("s%d int=0x%02X", i, sock_int);
/* 连接事件 */
/* 连接建立事件：交给状态机处理（监听态/客户端/数据 Socket 分别处理） */
if (sock_int & CH395F_SINT_STAT_CONNECT) {
handle_connect_event(p_sock);
event_count++;
}
/* 断开事件 */
/* 连接断开事件：更新状态机并触发断开回调 */
if (sock_int & CH395F_SINT_STAT_DISCONNECT) {
handle_disconnect_event(p_sock);
event_count++;
}
/* 数据接收事件 */
/* 接收数据就绪事件：仅通知上层，实际数据由 net_recv_locked 读出（避免重复读 recv_len） */
if (sock_int & CH395F_SINT_STAT_RECV_OK) {
handle_recv_event(p_sock);
event_count++;
}
/* 发送完成事<EFBFBD>?*/
/* 发送完成事件：通知上层发送缓冲已空，可继续发送 */
if (sock_int & CH395F_SINT_STAT_SEND_OK) {
handle_send_event(p_sock);
event_count++;
}
/* 发送缓冲区空闲 */
/* 发送缓冲区空闲：置 send_ready 标志，唤醒等待发送的逻辑 */
if (sock_int & CH395F_SINT_STAT_SENBUF_FREE) {
p_sock->send_ready = 1;
}
/* 超时事件 */
/* 超时事件：连接超时或收发超时，更新状态机 */
if (sock_int & CH395F_SINT_STAT_SOCK_TIMEOUT) {
handle_timeout_event(p_sock);
event_count++;
@@ -264,31 +253,14 @@ int net_poll(void) {
}
/*
* 处理完毕后检查 INT# 是否仍为低电平。如果是，说明在处理期间有新中断产生，需要再次读取。
* 注意：CH395F 的 RECV 中断是电平触发的（只要接收缓冲区有数据就保持低电平）。
* 如果不跳出循环，net_poll() 会无限循环处理 RECV 中断，导致主循环中的应用代码（如 echo）永远无法执行。
* 因此每次 net_poll() 调用只处理一批中断，由主循环负责读取数据。 */
* 处理完本批中断后退出 do-while(0)：
* CH395F 的 RECV 中断为电平触发，只要接收缓冲区仍有数据就保持 INT# 低电平，
* 若此处继续循环会反复处理 RECV 中断，导致主循环中的应用代码（如 echo 回显）得不到执行。
* 因此每次 net_poll() 只处理“一批”，剩余数据由主循环/recv 逻辑在后续轮询中读取。
*/
} while (0);
// /* 2 秒打印一次诊断信息（调试用） */
// {
// static uint32_t s_last_dbg = 0;
// uint32_t now = HAL_GetTick();
// if (now - s_last_dbg >= 2000) {
// s_last_dbg = now;
// uint8_t int_level = (HAL_GPIO_ReadPin(CH395_INT_GPIO_Port, CH395_INT_Pin) == GPIO_PIN_RESET) ? 1 : 0;
// DBG_DEBUG("INT#=%d", int_level);
// for (i = 0; i < NET_MAX_SOCKETS; i++) {
// if (s_net_socks[i].in_use) {
// uint8_t st[2];
// ch395f_get_socket_status((uint8_t)i, st);
// uint16_t rl = ch395f_get_recv_len((uint8_t)i);
// DBG_DEBUG(" s%d:sw%d/tcp%d rl%d", i, st[0], st[1], rl);
// }
// }
// }
// }
/* 返回本次累计发生的事件数量（0 表示无事件） */
return event_count;
}
@@ -301,7 +273,7 @@ int net_poll(void) {
void net_process_messages(void) {
net_msg_t msg;
if (netMsgQueueHandle == NULL) {
if (NULL == netMsgQueueHandle) {
return;
}
@@ -309,7 +281,7 @@ void net_process_messages(void) {
switch (msg.type) {
case NET_MSG_SEND: {
net_sock_t *p_sock = net_get_sock(msg.sockfd);
if (p_sock == NULL || p_sock->state != NET_SOCK_STATE_ESTABLISHED) {
if (NULL == p_sock || p_sock->state != NET_SOCK_STATE_ESTABLISHED) {
msg.result = -1;
} else {
msg.result = net_send_locked(p_sock, msg.buf, msg.len);
@@ -318,7 +290,7 @@ void net_process_messages(void) {
}
case NET_MSG_RECV: {
net_sock_t *p_sock = net_get_sock(msg.sockfd);
if (p_sock == NULL) {
if (NULL == p_sock) {
msg.result = -1;
} else {
msg.result = net_recv_locked(p_sock, msg.buf, msg.len, msg.flags);
@@ -327,7 +299,7 @@ void net_process_messages(void) {
}
case NET_MSG_CLOSE: {
net_sock_t *p_sock = net_get_sock(msg.sockfd);
if (p_sock == NULL) {
if (NULL == p_sock) {
msg.result = -1;
} else {
msg.result = net_close_locked(p_sock);
@@ -347,7 +319,7 @@ void net_process_messages(void) {
case NET_MSG_ACCEPT: {
struct net_sockaddr *p_addr = (struct net_sockaddr *)msg.buf;
int addrlen = msg.len;
int *p_addrlen = (p_addr != NULL && addrlen > 0) ? &addrlen : NULL;
int *p_addrlen = (NULL != p_addr && addrlen > 0) ? &addrlen : NULL;
msg.result = net_accept_locked(msg.sockfd, p_addr, p_addrlen);
break;
}
@@ -424,7 +396,7 @@ int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen) {
return -1;
}
if (addr == NULL || addrlen < (int)sizeof(struct net_sockaddr_in)) {
if (NULL == addr || addrlen < (int)sizeof(struct net_sockaddr_in)) {
s_net_errno = NET_ERR_INVAL;
return -1;
}
@@ -456,7 +428,7 @@ int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen) {
ch395f_set_proto_type((uint8_t)sockfd, CH395F_PROTO_TYPE_UDP);
ch395f_set_sour_port((uint8_t)sockfd, p_sock->local_port);
/* DesIP=0xFFFFFFFF <EFBFBD>?UDP Server 模式（接受任意来源） */
/* DesIP=0xFFFFFFFF UDP Server 模式（接受任意来源） */
{
uint8_t broadcast[4] = {0xFF, 0xFF, 0xFF, 0xFF};
ch395f_set_des_ip((uint8_t)sockfd, broadcast);
@@ -480,77 +452,102 @@ int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen) {
/*
* 函数功能：启动 TCP Server 监听（内部版本，必须在 netTask 上下文调用）
* 入口参数：sockfd - Socket 描述符 (0~7) int
* backlog - 数据 Socket 数量（0=单连接模式） int
* 返回值：0 - 成功，-1 - 失败 int
* 入口参数：sockfd - Socket 描述符 (0~7) int
* backlog - 数据 Socket 数量（0=单连接模式） int
* 返回值：0 - 成功，-1 - 失败 int
* 限定条件：sockfd 已绑定且为 TCP；netTask 上下文
*/
int net_listen_locked(int sockfd, int backlog) {
/* 取监听 Socket 控制块（直接下标访问，sockfd 已在上层 net_listen 校验过范围） */
net_sock_t *p_sock = &s_net_socks[sockfd];
/* CH395F 打开 Socket 的返回状态 */
uint8_t status;
/* 合法性检查：Socket 必须已创建且为 TCP 流类型 */
if (!p_sock->in_use || p_sock->type != NET_SOCK_STREAM) {
s_net_errno = NET_ERR_INVAL;
return -1;
}
/* 状态检查：仅允许在 BOUND（已 bind）或 CREATED（未 bind 直接用随机端口）状态下启动监听 */
if (p_sock->state != NET_SOCK_STATE_BOUND &&
p_sock->state != NET_SOCK_STATE_CREATED) {
s_net_errno = NET_ERR_INVAL;
return -1;
}
/* 多连接模式：按 backlog 分配数据 Socket */
/* 多连接模式（backlog > 0）：为数据 Socket 分配并初始化 CH395F 资源 */
if (backlog > 0) {
/* 数据 Socket 编号范围：[NET_TCP_SERVER_DATA_SOCK_START, max_ds) */
int max_ds = NET_TCP_SERVER_DATA_SOCK_START + backlog;
/* 越界保护：不超过 Socket 总数 */
if (max_ds > NET_MAX_SOCKETS) {
max_ds = NET_MAX_SOCKETS;
}
/* 逐个配置数据 Socket，供后续 accept 时承接新连接 */
for (int ds = NET_TCP_SERVER_DATA_SOCK_START; ds < max_ds; ds++) {
/* 以 4 块为单位划出该 Socket 的发送/接收缓冲（发送占前 2 块，接收占后 2 块） */
uint8_t base = (uint8_t)(ds * 4);
ch395f_set_send_buf((uint8_t)ds, base, 2);
ch395f_set_recv_buf((uint8_t)ds, base + 2, 2);
/* 数据 Socket 监听同一本地端口，协议类型为 TCP */
ch395f_set_sour_port((uint8_t)ds, p_sock->local_port);
ch395f_set_proto_type((uint8_t)ds, CH395F_PROTO_TYPE_TCP);
/* 登记数据 Socket 控制块：标记已用、等待连接态、流类型、绑定硬件 Socket 号 */
s_net_socks[ds].in_use = 1;
s_net_socks[ds].state = NET_SOCK_STATE_TCP_ACCEPT;
s_net_socks[ds].type = NET_SOCK_STREAM;
s_net_socks[ds].ch395_sock = (uint8_t)ds;
s_net_socks[ds].send_ready = 1;
/* 记录到监听 Socket 的数据 Socket 列表，供 net_accept_locked 查表 */
p_sock->data_socks[p_sock->data_sock_count++] = ds;
}
}
/* 配置监听 Socket：单连接模式使用 CH395F 默认缓冲区（socket 0-3 已互不重叠），
* 多连接模式显式分配（socket 4-7 默认无缓冲区）*/
/*
* 配置监听 Socket 自身的缓冲：
* - 单连接模式（backlog==0，通常用 Socket 0~3）：CH395F 默认缓冲已互不重叠，无需重设；
* - 多连接模式（Socket 4~7 默认无收发缓冲）：显式按 4 块划分发送/接收缓冲。
*/
if (backlog > 0) {
uint8_t base = (uint8_t)(sockfd * 4);
ch395f_set_send_buf((uint8_t)sockfd, base, 2);
ch395f_set_recv_buf((uint8_t)sockfd, base + 2, 2);
}
/* 监听 Socket 协议类型为 TCP，并绑定本地端口 */
ch395f_set_proto_type(sockfd, CH395F_PROTO_TYPE_TCP);
ch395f_set_sour_port(sockfd, p_sock->local_port);
/* CH395F 关 socket 后需要时间才能重新打开，重试 3 次（Trap 09） */
/* CH395F 关闭 Socket 后需延时才能重新打开（Trap 09），故失败重试最多 3 次 */
for (int open_try = 0; open_try < 3; open_try++) {
status = ch395f_open_socket(sockfd);
if (status == CH395F_ERR_SUCCESS) break;
ch395f_close_socket(sockfd);
if (status == CH395F_ERR_SUCCESS) {
break; /* 打开成功，退出重试 */
}
ch395f_close_socket(sockfd); /* 打开失败先关闭，再延时后重试 */
HAL_Delay(500);
}
/* 3 次仍失败，返回错误 */
if (status != CH395F_ERR_SUCCESS) {
s_net_errno = NET_ERR_BUSY;
return -1;
}
/* 下发 TCP LISTEN 命令，进入监听状态 */
ch395f_tcp_listen(sockfd);
/* 监听 Socket 进入 LISTENING 态 */
p_sock->state = NET_SOCK_STATE_LISTENING;
/* 单连接模式标记为 standalone_accept：CONNECT 中断直接作用于本 Socket 自身 */
if (backlog == 0) {
p_sock->standalone_accept = 1;
}
/*
* 启动监听前清空各 Socket 及全局中断状态寄存器（读即清除），
* 避免历史残留/伪中断在监听刚开始时误触发连接或断开事件。
*/
for (int j = 0; j < NET_MAX_SOCKETS; j++) {
(void)ch395f_get_sock_int_status((uint8_t)j);
}
@@ -575,7 +572,7 @@ int net_listen(int sockfd, int backlog) {
return -1;
}
if (netMsgQueueHandle == NULL) {
if (NULL == netMsgQueueHandle) {
s_net_errno = NET_ERR;
return -1;
}
@@ -635,7 +632,7 @@ static int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen
net_sock_t *p_data_cb = &s_net_socks[data_sock];
if (p_data_cb->state == NET_SOCK_STATE_ESTABLISHED) {
if (addr != NULL && addrlen != NULL) {
if (NULL != addr &&NULL != addrlen) {
struct net_sockaddr_in *p_addr_in = (struct net_sockaddr_in *)addr;
p_addr_in->sin_family = NET_AF_INET;
p_addr_in->sin_port = net_htons(p_data_cb->remote_port);
@@ -649,7 +646,7 @@ static int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen
/* 单连接模式（PASV）：查 standalone 监听者是否已 ESTABLISHED */
if (p_listen_sock->standalone_accept &&
p_listen_sock->state == NET_SOCK_STATE_ESTABLISHED) {
if (addr != NULL && addrlen != NULL) {
if (NULL != addr &&NULL != addrlen) {
struct net_sockaddr_in *p_addr_in = (struct net_sockaddr_in *)addr;
p_addr_in->sin_family = NET_AF_INET;
p_addr_in->sin_port = net_htons(p_listen_sock->remote_port);
@@ -680,7 +677,7 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) {
return -1;
}
if (netMsgQueueHandle == NULL) {
if (NULL == netMsgQueueHandle) {
s_net_errno = NET_ERR;
return -1;
}
@@ -688,7 +685,7 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) {
msg.type = NET_MSG_ACCEPT;
msg.sockfd = sockfd;
msg.buf = (void *)addr;
msg.len = (addrlen != NULL) ? *addrlen : 0;
msg.len = (NULL != addrlen) ? *addrlen : 0;
msg.caller = xTaskGetCurrentTaskHandle();
msg.result = -1;
@@ -703,7 +700,7 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) {
msg.result = (int)s_notified;
}
if (addrlen != NULL && addr != NULL) {
if (NULL != addrlen &&NULL != addr) {
*addrlen = sizeof(struct net_sockaddr_in);
}
@@ -741,7 +738,7 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) {
return -1;
}
if (addr == NULL || addrlen < (int)sizeof(struct net_sockaddr_in)) {
if (NULL == addr || addrlen < (int)sizeof(struct net_sockaddr_in)) {
s_net_errno = NET_ERR_INVAL;
return -1;
}
@@ -785,12 +782,24 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) {
/*
* 函数功能：发送数据（内部锁定版本，必须在 netTask 上下文调用）
*/
/*
* 函数功能：发送数据（内部锁定版本，必须在 netTask 上下文调用）
* 入口参数：p_sock - Socket 控制块指针 net_sock_t *
* buf - 待发送数据缓冲区指针 const void *
* len - 数据长度 int > 0
* 出口参数：无
* 返回值：实际发送字节数（>= 0）；-1 表示参数无效或 Socket 未连接 int
* 限定条件：p_sock 非空；Socket 处于 ESTABLISHED 状态；netTask 上下文
* 函数说明：1. 按 NET_DMA_MAX_PAYLOAD 分块写入 CH395F 发送缓冲区
* 2. 发送前等待 send_ready 置位，超时返回已发送字节数
* 3. 每写完一块等待 SEND_OK 中断（send_ready 清零后重新置位）
*/
static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
int sent = 0;
uint32_t tick_start;
int sockfd = (int)(p_sock - s_net_socks);
if (buf == NULL || len <= 0) {
if (NULL == buf || len <= 0) {
s_net_errno = NET_ERR_INVAL;
return -1;
}
@@ -839,12 +848,25 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
/*
* 函数功能：接收数据（内部锁定版本，必须在 netTask 上下文调用）
*/
/*
* 函数功能：接收数据（内部锁定版本，必须在 netTask 上下文调用）
* 入口参数：p_sock - Socket 控制块指针 net_sock_t *
* buf - 接收缓冲区指针 void *
* len - 缓冲区大小 int > 0
* flags - 标志位，NET_MSG_DONTWAIT 表示非阻塞 int
* 出口参数：buf - 填充接收到的数据
* 返回值：实际接收字节数（> 0）；0 表示对端关闭；-1 表示出错/超时/非阻塞无数据 int
* 限定条件：p_sock 非空；netTask 上下文
* 函数说明：1. 循环调用 net_poll() 检查接收长度，有数据即读出
* 2. 非阻塞模式下无数据立即返回 -1（NET_ERR_WOULDBLOCK）
* 3. CLOSED 状态尝试排空接收缓冲区残余数据（Trap 13：FIN 可能先于数据到达）
*/
static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags) {
uint16_t recv_len;
uint32_t tick_start;
int sockfd = (int)(p_sock - s_net_socks);
if (buf == NULL || len <= 0) {
if (NULL == buf || len <= 0) {
s_net_errno = NET_ERR_INVAL;
return -1;
}
@@ -895,6 +917,15 @@ static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags) {
/*
* 函数功能：关闭 socket（内部锁定版本，必须在 netTask 上下文调用）
*/
/*
* 函数功能：关闭 Socket（内部锁定版本，必须在 netTask 上下文调用）
* 入口参数：p_sock - Socket 控制块指针 net_sock_t *
* 出口参数：无
* 返回值：0 - 关闭成功 int
* 限定条件：p_sock 非空；netTask 上下文
* 函数说明：1. 调用 ch395f_close_socket 关闭 CH395F 硬件 Socket
* 2. 清空整个控制块（memset 0），释放该 Socket 资源
*/
static int net_close_locked(net_sock_t *p_sock) {
int sockfd = (int)(p_sock - s_net_socks);
@@ -924,7 +955,7 @@ int net_send(int sockfd, const void *buf, int len, int flags) {
return -1;
}
if (netMsgQueueHandle == NULL) {
if (NULL == netMsgQueueHandle) {
s_net_errno = NET_ERR;
return -1;
}
@@ -974,7 +1005,7 @@ int net_recv(int sockfd, void *buf, int len, int flags) {
return -1;
}
if (netMsgQueueHandle == NULL) {
if (NULL == netMsgQueueHandle) {
s_net_errno = NET_ERR;
return -1;
}
@@ -1021,7 +1052,7 @@ int net_close(int sockfd) {
return -1;
}
if (netMsgQueueHandle == NULL) {
if (NULL == netMsgQueueHandle) {
s_net_errno = NET_ERR;
return -1;
}
@@ -1079,13 +1110,13 @@ int net_sendto(int sockfd, const void *buf, int len, int flags,
return -1;
}
if (buf == NULL || len <= 0) {
if (NULL == buf || len <= 0) {
s_net_errno = NET_ERR_INVAL;
return -1;
}
/* UDP 模式：设置目标地址 */
if (dest_addr != NULL && addrlen >= (int)sizeof(struct net_sockaddr_in)) {
if (NULL != dest_addr && addrlen >= (int)sizeof(struct net_sockaddr_in)) {
p_addr_in = (const struct net_sockaddr_in *)dest_addr;
/* 转换 IP 为数组格<E7BB84>?*/
@@ -1168,7 +1199,7 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
return -1;
}
if (buf == NULL || len <= 0) {
if (NULL == buf || len <= 0) {
s_net_errno = NET_ERR_INVAL;
return -1;
}
@@ -1187,7 +1218,7 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
recv_len -= 8;
/* 填充来源地址 */
if (src_addr != NULL && addrlen != NULL &&
if (NULL != src_addr &&NULL != addrlen &&
*addrlen >= (int)sizeof(struct net_sockaddr_in)) {
struct net_sockaddr_in *p_addr_in = (struct net_sockaddr_in *)src_addr;
p_addr_in->sin_family = NET_AF_INET;
@@ -1228,8 +1259,18 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
/*
* 函数功能：发送数据（内部版本，绕过消息队列，供 netTask 直接使用）
*/
/*
* 函数功能：发送数据（内部版本，绕过消息队列，供 netTask 直接使用）
* 入口参数：p_sock - Socket 控制块指针 net_sock_t *
* buf - 待发送数据缓冲区指针 const void *
* len - 数据长度 int > 0
* 出口参数：无
* 返回值：实际发送字节数（>= 0）；-1 表示参数无效 int
* 限定条件：p_sock 非空；netTask 上下文（避免向自身发送消息造成死锁）
* 函数说明：直接调用 net_send_locked 完成发送
*/
int net_send_sock(net_sock_t *p_sock, const void *buf, int len) {
if (p_sock == NULL) {
if (NULL == p_sock) {
s_net_errno = NET_ERR_BADF;
return -1;
}
@@ -1248,7 +1289,7 @@ int net_send_sock(net_sock_t *p_sock, const void *buf, int len) {
* 函数说明：直接操作 Socket 控制块，不经过消息队列。避免 netTask 向自身发送消息造成死锁
*/
int net_recv_sock(net_sock_t *p_sock, void *buf, int len, int flags) {
if (p_sock == NULL) {
if (NULL == p_sock) {
s_net_errno = NET_ERR_BADF;
return -1;
}
@@ -1263,7 +1304,7 @@ int net_recv_sock(net_sock_t *p_sock, void *buf, int len, int flags) {
* 函数说明：直接操作 Socket 控制块，不经过消息队列。TCP Socket 先断开连接再释放控制块
*/
int net_close_sock(net_sock_t *p_sock) {
if (p_sock == NULL) {
if (NULL == p_sock) {
s_net_errno = NET_ERR_BADF;
return -1;
}
@@ -1311,14 +1352,20 @@ int net_get_errno(void) {
}
/*
* 函数功能：将 IP 地址字符串转为网络字节序
* 函数功能：将点分十进制 IP 地址字符串转换为网络字节序的 32 位地址
* 入口参数：cp - 点分十进制 IP 字符串（如 "192.168.1.100"） const char *
* 出口参数：无
* 返回值：网络字节序的 32 位 IP 地址（0 表示参数无效） uint32_t
* 限定条件：无
* 函数说明：1. 逐段解析十进制数与并小端组装为 32 位值
* 2. 转换结果经 NET_htonl 转为网络字节序
*/
uint32_t net_inet_addr(const char *cp) {
uint32_t addr = 0;
uint32_t val;
int i;
if (cp == NULL) {
if (NULL == cp) {
return 0;
}
@@ -1338,11 +1385,18 @@ uint32_t net_inet_addr(const char *cp) {
}
/*
* 函数功能：将网络字节<EFBFBD>?IP 转为字符<E5AD97>? */
* 函数功能：将网络字节序的 32 位地址转换为点分十进制字符串
* 入口参数：addr - 网络字节序的 32 位 IP 地址 uint32_t
* buf - 输出缓冲区（至少 16 字节） char *
* 出口参数：buf - 填充点分十进制字符串
* 返回值：成功返回 buf 指针；buf 为 NULL 时返回 NULL char *
* 限定条件：buf 非空且长度足够（>= 16 字节）
* 函数说明：1. 先经 NET_ntohl 转为主机字节序再格式化输出
*/
char *net_inet_ntoa(uint32_t addr, char *buf) {
uint32_t naddr = NET_ntohl(addr);
if (buf == NULL) {
if (NULL == buf) {
return NULL;
}
@@ -1355,40 +1409,64 @@ char *net_inet_ntoa(uint32_t addr, char *buf) {
return buf;
}
/*
* 函数功能：端口字节序转换（主机序 -> 网络序）
* 入口参数：hostshort - 主机字节序的 16 位端口 uint16_t
* 出口参数：无
* 返回值：网络字节序的 16 位端口 uint16_t
* 限定条件：无
* 函数说明：直接调用 NET_htons 完成转换
*/
uint16_t net_htons(uint16_t hostshort) {
return NET_htons(hostshort);
}
/*
* 函数功能：端口字节序转换（网络序 -> 主机序）
* 入口参数：netshort - 网络字节序的 16 位端口 uint16_t
* 出口参数：无
* 返回值：主机字节序的 16 位端口 uint16_t
* 限定条件：无
* 函数说明：直接调用 NET_ntohs 完成转换
*/
uint16_t net_ntohs(uint16_t netshort) {
return NET_ntohs(netshort);
}
/*
* 函数功能：IP 地址字节序转换（主机<EFBFBD>?-> 网络序）
* 函数功能：IP 地址字节序转换（主机序 -> 网络序）
* 入口参数：hostlong - 主机字节序的 32 位 IP 地址 uint32_t
* 出口参数：无
* 返回值：网络字节序的 32 位 IP 地址 uint32_t
* 限定条件：无
* 函数说明：直接调用 NET_htonl 完成转换
*/
uint32_t net_htonl(uint32_t hostlong) {
return NET_htonl(hostlong);
}
/*
* 函数功能：IP 地址字节序转换（网络<EFBFBD>?-> 主机序）
* 函数功能：IP 地址字节序转换（网络序 -> 主机序）
* 入口参数：netlong - 网络字节序的 32 位 IP 地址 uint32_t
* 出口参数：无
* 返回值：主机字节序的 32 位 IP 地址 uint32_t
* 限定条件：无
* 函数说明：直接调用 NET_ntohl 完成转换
*/
uint32_t net_ntohl(uint32_t netlong) {
return NET_ntohl(netlong);
}
/*
* 私有函数实现<EFBFBD>? */
/*
* 函数功能：分配空<EFBFBD>?Socket
* 返回值：Socket 索引，失败返<E8B4A5>?-1
* 函数功能：分配一个空闲的 Socket 控制块
* 入口参数：无
* 出口参数：无
* 返回值：空闲 Socket 索引（0~NET_MAX_SOCKETS-1）；-1 表示无空闲 Socket int
* 限定条件：s_net_socks 已定义
* 函数说明：1. 线性扫描 s_net_socks，返回首个 in_use == 0 的控制块索引
* 2. 调用方负责初始化该控制块
*/
static int alloc_socket(void) {
int i;
@@ -1403,7 +1481,17 @@ static int alloc_socket(void) {
}
/*
* 函数功能：处理连接事<EFBFBD>? */
* 入口参数：p_sock - 发生连接事件的 Socket 控制块指针 net_sock_t *
* 出口参数：无
* 返回值：无
* 限定条件：net_poll() 检测到 CONNECT 中断后调用；netTask 上下文
* 函数说明：1. 独立监听模式（standalone_accept）：自身转 ESTABLISHED 并读取对端地址
* 2. 多连接监听模式：Socket 0 保持 LISTENING，由数据 Socket 承接连接
* 3. 多连接模式自动打开的数据 Socket：首次 CONNECT 时初始化并置 ESTABLISHED
* 4. TCP Client（CONNECTING）：连接成功，读取对端地址并置 ESTABLISHED
* 5. 数据 Socket（TCP_ACCEPT）：被分配连接，置 ESTABLISHED
* 6. 连接成功后使能 KeepAlive 并触发 NET_EVENT_CONNECTED 回调
*/
static void handle_connect_event(net_sock_t *p_sock) {
if (p_sock->state == NET_SOCK_STATE_LISTENING) {
if (p_sock->standalone_accept) {
@@ -1488,9 +1576,16 @@ static void handle_connect_event(net_sock_t *p_sock) {
}
/*
* 函数功能：处理断开事件
* 函数说明：CH395F <20>?DISCONNECT 中断后自动关<E58AA8>?Socket（默<EFBC88>?FUN_PARA_FLAG_SOCKET_CLOSE=0），
* 必须重新 OPEN_SOCKET + TCP_LISTEN 才能接受新连<E696B0>? */
* 函数功能：处理 Socket 断开（DISCONNECT）事件，更新 Socket 状态机
* 入口参数：p_sock - 发生断开事件的 Socket 控制块指针 net_sock_t *
* 出口参数：无
* 返回值：无
* 限定条件：net_poll() 检测到 DISCONNECT 中断后调用；netTask 上下文
* 函数说明：1. CH395F 在 DISCONNECT 后自动关闭 Socket（FUN_PARA 默认），需重新 OPEN + LISTEN
* 2. 独立监听模式：置 CLOSED，交由 net_recv_locked 排空剩余数据后再关
* 3. 多连接数据 Socket：回到 TCP_ACCEPT 状态等待新连接
* 4. 触发 NET_EVENT_DISCONNECTED 回调
*/
static void handle_disconnect_event(net_sock_t *p_sock) {
if (p_sock->state == NET_SOCK_STATE_LISTENING) {
DBG_ERROR("WARNING: listen sock%d got disconnect", p_sock->ch395_sock);
@@ -1524,7 +1619,15 @@ static void handle_disconnect_event(net_sock_t *p_sock) {
}
/*
* 函数功能：处理数据接收事<EFBFBD>? */
* 函数功能：处理数据接收事件
* 函数功能：处理 Socket 数据接收（RECV_OK）事件
* 入口参数：p_sock - 发生接收事件的 Socket 控制块指针 net_sock_t *
* 出口参数：无
* 返回值：无
* 限定条件：net_poll() 检测到 RECV_OK 中断后调用；netTask 上下文
* 函数说明：1. 仅触发 NET_EVENT_DATA_RECEIVED 回调通知上层
* 2. 不在此读取 recv_len，避免与 net_recv_locked 中的读取冲突（Trap 13）
*/
static void handle_recv_event(net_sock_t *p_sock) {
/* RECV_OK 中断已触发，直接通知上层。不在此读 recv_len，
* 避免和 net_recv_locked 里面的 ch395f_get_recv_len 冲突（Trap 13） */
@@ -1532,13 +1635,28 @@ static void handle_recv_event(net_sock_t *p_sock) {
}
/*
* 函数功能：处理发送完成事<EFBFBD>? */
* 函数功能：处理 Socket 发送完成（SEND_OK）事件
* 入口参数：p_sock - 发生发送完成事件的 Socket 控制块指针 net_sock_t *
* 出口参数：无
* 返回值：无
* 限定条件：net_poll() 检测到 SEND_OK 中断后调用；netTask 上下文
* 函数说明：触发 NET_EVENT_SEND_COMPLETE 回调通知上层
*/
static void handle_send_event(net_sock_t *p_sock) {
fire_event(p_sock, NET_EVENT_SEND_COMPLETE);
}
/*
* 函数功能：处理超时事<EFBFBD>? * 函数说明：CH395F <20>?TIMEOUT 中断后同样自动关<E58AA8>?Socket<65>? * 需要重新打开并恢复监<E5A48D>? */
* 函数功能：处理 Socket 超时（SOCK_TIMEOUT）事件，更新 Socket 状态机
* 入口参数：p_sock - 发生超时事件的 Socket 控制块指针 net_sock_t *
* 出口参数：无
* 返回值：无
* 限定条件：net_poll() 检测到 SOCK_TIMEOUT 中断后调用；netTask 上下文
* 函数说明：1. TCP Client（CONNECTING）：连接超时，回到 CREATED 状态
* 2. 已建立连接：回到 CLOSED（独立模式）或 TCP_ACCEPT（多连接模式）
* 3. 监听态：异常超时，记录错误日志
* 4. 触发 NET_EVENT_TIMEOUT 回调
*/
static void handle_timeout_event(net_sock_t *p_sock) {
if (p_sock->state == NET_SOCK_STATE_CONNECTING) {
/* TCP Client 连接超时 */
@@ -1558,21 +1676,36 @@ static void handle_timeout_event(net_sock_t *p_sock) {
}
/*
* 函数功能：触发事件回<EFBFBD>? */
* 函数功能：触发 Socket 事件回调（若已注册）
* 入口参数：p_sock - 触发事件的 Socket 控制块指针 net_sock_t *
* event - 事件类型 net_event_t
* 出口参数：无
* 返回值：无
* 限定条件：net_init() 已调用
* 函数说明：1. 仅当 p_sock->event_cb 非空时调用回调
* 2. 回调参数为 ch395_sock、event、event_arg
*/
static void fire_event(net_sock_t *p_sock, net_event_t event) {
if (p_sock->event_cb != NULL) {
if (NULL != p_sock->event_cb) {
p_sock->event_cb(p_sock->ch395_sock, event, p_sock->event_arg);
}
}
/*
* 函数功能：解<EFBFBD>?IP 地址字符串为数组
* 函数功能：将点分十进制 IP 地址字符串解析为 4 字节数组
* 入口参数：str - 点分十进制 IP 字符串（如 "192.168.1.100"） const char *
* ip_arr - 输出：4 字节 IP 数组（网络序，低字节在前） uint8_t *
* 出口参数：ip_arr - 填充解析后的 IP 地址
* 返回值：无
* 限定条件：str 与 ip_arr 均非空
* 函数说明：1. 逐段解析十进制数写入 ip_arr[0..3]
* 2. 参数非法（NULL）时直接返回，不做解析
*/
static void parse_ip_string(const char *str, uint8_t *ip_arr) {
uint32_t val;
int i;
if (str == NULL || ip_arr == NULL) {
if (NULL == str ||NULL == ip_arr) {
return;
}
@@ -1590,7 +1723,14 @@ static void parse_ip_string(const char *str, uint8_t *ip_arr) {
}
/*
* 函数功能：获<EFBFBD>?Socket 控制块指针（内部使用<EFBFBD>? */
* 函数功能：根据描述符获取 Socket 控制块指针（内部使用）
* 入口参数：sockfd - Socket 描述符 int 0 - NET_MAX_SOCKETS-1
* 出口参数：无
* 返回值：Socket 控制块指针；描述符越界或未分配时返回 NULL net_sock_t *
* 限定条件：无
* 函数说明：1. 描述符越界（<0 或 >= NET_MAX_SOCKETS）返回 NULL
* 2. 未使用（in_use == 0）的 Socket 返回 NULL
*/
net_sock_t *net_get_sock(int sockfd) {
if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) {
return NULL;
@@ -1624,7 +1764,7 @@ int net_getsockname(int sockfd, struct net_sockaddr *addr, int *addrlen) {
return -1;
}
if (addr == NULL || addrlen == NULL || *addrlen < (int)sizeof(struct net_sockaddr_in)) {
if (NULL == addr ||NULL == addrlen || *addrlen < (int)sizeof(struct net_sockaddr_in)) {
s_net_errno = NET_ERR_INVAL;
return -1;
}