修复多连接的问题

2026-07-19 15:27:49 +08:00
parent 9ed4c22022
commit e06d849007
38 changed files with 2475 additions and 1953 deletions
--- a/Drivers/BSP/CH395F/ch395f.c
+++ b/Drivers/BSP/CH395F/ch395f.c
--- a/Drivers/BSP/CH395F/ch395f_test.c
+++ b/Drivers/BSP/CH395F/ch395f_test.c
@@ -2,26 +2,23 @@
 * æ¨¡å<C2A1>—å<E28094><C3A5>ç§°ï¼šCH395F Driver Test Suite
 * æ¨¡å<C2A1>—åŠŸèƒ½ï¼šCH395F é©±åŠ¨å<C2A8>„åŠŸèƒ½æ¨¡å<C2A1>—çš„æµ‹è¯•å…¥å<C2A5>£ï¼Œåˆ†é˜¶æ®µç»„ç»‡æµ‹è¯•ç”¨ä¾‹
 * é€‚ç”¨å¹³å<C2B3>°ï¼šSTM32F4 ç³»åˆ—ï¼ˆCH395F ä»¥å¤ªç½‘èŠ¯ç‰‡ï¼‰
- * 作者：王建锋
- * 创建日期：2026-07-19
- * 修改记录：
- *     2026-07-19  Phase 1/2/3 implemented
+ * ä½œè€…ï¼šçŽ‹å»ºï¿? * åˆ›å»ºæ—¥æœŸï¿?026-07-19
+ * ä¿®æ”¹è®°å½•ï¿? *     2026-07-19  Phase 1/2/3 implemented
 */

 /* å¤´æ–‡ä»¶åŒ…å<E280A6>«åŒº */
+#include <string.h>
+#include <stdio.h>
 #include "ch395f_test.h"
 #include "ch395f.h"
 #include "net_socket.h"
 #define DBG_TAG "[CH395T]"
 #include "dbg_log.h"
-#include <string.h>
-#include <stdio.h>

 test_stats_t g_test_stats;

 /*
- * Phase 2 配置默认值
- */
+ * Phase 2 é…<EFBFBD>ç½®é»˜è®¤ï¿? */
 #ifndef PHASE2_REMOTE_IP
 #define PHASE2_REMOTE_IP        "192.168.1.2"
 #endif
@@ -39,8 +36,7 @@ test_stats_t g_test_stats;
 #endif

 /*
- * Phase 3 配置默认值
- */
+ * Phase 3 é…<EFBFBD>ç½®é»˜è®¤ï¿? */
 #ifndef PHASE3_REMOTE_IP
 #define PHASE3_REMOTE_IP        "192.168.1.2"
 #endif
@@ -58,13 +54,12 @@ test_stats_t g_test_stats;
 #endif

 /*
- * 恢复 TCP Server 多连接模式的数据 Socket 配置
- */
-static void restore_data_sockets(uint16_t port)
-{
-    int i;
-    for (i = NET_TCP_SERVER_DATA_SOCK_START; i < NET_MAX_SOCKETS; i++)
-    {
+ * å‡½æ•°åŠŸèƒ½ï¼šæ<EFBFBD>¢ï¿?TCP Server å¤šè¿žæŽ¥æ¨¡å¼<C3A5>çš„æ•°æ<C2B0>® Socket é…<EFBFBD>ç½®
+ * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šport - TCP æº<C3A6>ç«¯å<C2AF>£å<C2A3>·
+ * ï¿?ï¿?å€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šCH395F å<><C3A5>è®®æ ˆå·²åˆ<C3A5>å§‹ï¿? * å‡½æ•°è¯´æ˜Žï¼šé‡<C3A9>æ–°è®¾ç½®æ•°ï¿?Socket çš„å<E2809E><C3A5>è®®ç±»åž‹å’Œæº<C3A6>ç«¯ï¿? */
+static void restore_data_sockets(uint16_t port) {
+    int i = 0;
+    for (i = NET_TCP_SERVER_DATA_SOCK_START; i < NET_MAX_SOCKETS; i++) {
        ch395f_set_proto_type((uint8_t)i, CH395F_PROTO_TYPE_TCP);
        ch395f_set_sour_port((uint8_t)i, port);
    }
@@ -73,12 +68,14 @@ static void restore_data_sockets(uint16_t port)

 /*
 * ============================ Phase 1 ============================
- */
+ * å‡½æ•°åŠŸèƒ½ï¼šå¯„å˜å™¨è¯»å†™ + ä¸æ–ä¸€è‡´æ€§åŸºç¡€æµ‹è¯•
+ * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šæ— 
+ * ï¿?ï¿?å€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šCH395F èŠ¯ç‰‡æ£å¸¸åº”ç”
+ * å‡½æ•°è¯´æ˜Žï¼šåŒ…ï¿?GET_VERSION / GET_CMD_STATUS / GET_IP_INF ï¿?9 ï¿? */

-void ch395f_phase1_tests(void)
-{
-    uint8_t i;
-    int ver;
+void ch395f_phase1_tests(void) {
+    uint8_t i = 0;
+    int ver = 0;

    DBG_INFO("=== CH395F Phase 1 Tests ===");

@@ -115,7 +112,7 @@ void ch395f_phase1_tests(void)
               "GINT_STATUS_ALL: 0x%04X (lo=0x%02X hi=0x%02X)",
               gint_all, gint_all & 0xFF, (gint_all >> 8) & 0xFF);

-    /* Test 5: GINT_STATUS (1-byte version) — read-clear check */
+    /* Test 5: GINT_STATUS (1-byte version) ï¿?read-clear check */
    uint8_t gint_1b = ch395f_get_glob_int_status();
    TEST_CHECK(gint_1b == 0x00,
               "GINT_STATUS_1byte: 0x%02X (expect 0x00 after read-clear)", gint_1b);
@@ -139,8 +136,7 @@ void ch395f_phase1_tests(void)
    /* Test 9: CLEAR_RECV_BUF + SOCK_INT poll */
    ch395f_clear_recv_buf(0);
    TEST_CHECK(1, "CLEAR_RECV_BUF(sock=0): OK");
-    for (i = 0; i < 8; i++)
-    {
+    for (i = 0; i < 8; i++) {
        uint8_t si = ch395f_get_sock_int_status(i);
        TEST_CHECK(si == 0x00, "SOCK_INT(%d): 0x%02X", i, si);
    }
@@ -150,17 +146,17 @@ void ch395f_phase1_tests(void)

 /*
 * ============================ Phase 2 ============================
- */
+ * å‡½æ•°åŠŸèƒ½ï¼šTCP Client æ”¶å<C2B6>‘ + å…³é—é‡<C3A9>è¿ž Ã—3 ï¿? * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šæ— 
+ * ï¿?ï¿?å€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šPC ç«¯å·²å<C2B2>¯åŠ¨ TCP Serverï¼ˆé»˜ï¿?192.168.1.2:8081ï¿? * å‡½æ•°è¯´æ˜Žï¼šæ¯<C3A6>è½®è¿žæŽ¥â†’å<E28099>‘é€<C3A9>â†’æŽ¥æ”¶â†’å…³é—ï¼Œè¿žç» 3 ï¿? */

-void ch395f_phase2_tests(void)
-{
-    uint8_t sock;
-    uint8_t sock_int;
-    uint8_t rx_buf[300];
-    int i;
-    uint32_t tick;
-    uint16_t int_st;
-    int iter_pass;
+void ch395f_phase2_tests(void) {
+    uint8_t sock = 0;
+    uint8_t sock_int = 0;
+    uint8_t rx_buf[300] = {0};
+    int i = 0;
+    uint32_t tick = 0;
+    uint16_t int_st = 0;
+    int iter_pass = 0;

    DBG_INFO("=== CH395F Phase 2 Tests (TCP Client - Direct Driver) ===");

@@ -178,15 +174,14 @@ void ch395f_phase2_tests(void)

    sock = (uint8_t)(NET_MAX_SOCKETS - 1);

-    /* 一次性配置 */
+    /* ä¸€æ¬¡æ€§é…<EFBFBD>ï¿?*/
    ch395f_set_proto_type(sock, CH395F_PROTO_TYPE_TCP);
    ch395f_set_send_buf(sock, 28, 2);
    ch395f_set_recv_buf(sock, 30, 2);
    ch395f_set_des_ip(sock, ip_arr);
    ch395f_set_des_port(sock, PHASE2_REMOTE_PORT);

-    for (i = 0; i < PHASE2_LOOP_COUNT; i++)
-    {
+    for (i = 0; i < PHASE2_LOOP_COUNT; i++) {
        DBG_INFO("--- Iteration %d/%d ---", i + 1, PHASE2_LOOP_COUNT);
        iter_pass = 1;

@@ -197,11 +192,9 @@ void ch395f_phase2_tests(void)

        /* ç‰å¾… CONNECT */
        tick = HAL_GetTick();
-        while (HAL_GetTick() - tick < PHASE2_TIMEOUT_MS)
-        {
+        while (HAL_GetTick() - tick < PHASE2_TIMEOUT_MS) {
            int_st = ch395f_get_glob_int_status_all();
-            if (int_st & (1U << (sock + 4)))
-            {
+            if (int_st & (1U << (sock + 4))) {
                sock_int = ch395f_get_sock_int_status(sock);
                if (sock_int & CH395F_SINT_STAT_CONNECT) break;
            }
@@ -211,9 +204,9 @@ void ch395f_phase2_tests(void)

        HAL_Delay(100);

-        /* 发送测试数据 */
+        /* å<EFBFBD>‘é€<EFBFBD>æµ‹è¯•æ•°ï¿?*/
        {
-            uint8_t test_buf[64];
+            uint8_t test_buf[64] = {0};
            const char *msg = "HelloFromCH395F_TCP_Client! This is a 64-byte test message.";
            int p, mlen = (int)strlen(msg);
            memcpy(test_buf, msg, mlen);
@@ -221,15 +214,13 @@ void ch395f_phase2_tests(void)
            ch395f_write_send_buf(sock, test_buf, 64);
        }

-        /* Echo 循环：收数据 → 回发 */
+        /* Echo å¾ªçŽ¯ï¼šæ”¶æ•°æ<EFBFBD>® ï¿?å›žå<C5BE>‘ */
        {
            int got_echo = 0;
            tick = HAL_GetTick();
-            while (HAL_GetTick() - tick < 10000)
-            {
+            while (HAL_GetTick() - tick < 10000) {
                uint16_t rlen = ch395f_get_recv_len(sock);
-                if (rlen > 0)
-                {
+                if (rlen > 0) {
                    uint16_t read_len = (rlen > sizeof(rx_buf)) ? (uint16_t)sizeof(rx_buf) : rlen;
                    memset(rx_buf, 0, sizeof(rx_buf));
                    ch395f_read_recv_buf(sock, rx_buf, read_len);
@@ -239,8 +230,7 @@ void ch395f_phase2_tests(void)
                    break;
                }
                int_st = ch395f_get_glob_int_status_all();
-                if (int_st & (1U << (sock + 4)))
-                {
+                if (int_st & (1U << (sock + 4))) {
                    sock_int = ch395f_get_sock_int_status(sock);
                    if (sock_int & CH395F_SINT_STAT_DISCONNECT) { DBG_INFO("DISCONNECT"); break; }
                    if (sock_int & CH395F_SINT_STAT_SOCK_TIMEOUT) { DBG_INFO("SOCK_TIMEOUT"); break; }
@@ -258,8 +248,7 @@ phase2_iter_done:
        {
            uint8_t st[2];
            uint32_t wait = HAL_GetTick();
-            while (HAL_GetTick() - wait < 5000)
-            {
+            while (HAL_GetTick() - wait < 5000) {
                ch395f_get_socket_status(sock, st);
                if (st[0] == CH395F_SOCKET_CLOSED) break;
                HAL_Delay(50);
@@ -275,21 +264,22 @@ phase2_iter_done:

 /*
 * ============================ Phase 3 ============================
- */
+ * å‡½æ•°åŠŸèƒ½ï¼šUDP Server Echo + PING + å¤§åŒ…æµ‹è¯•
+ * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šæ— 
+ * ï¿?ï¿?å€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šPC ç«¯å·²å<C2B2>¯åŠ¨ UDP Clientï¼ˆé»˜ï¿?192.168.1.2:8082ï¿? * å‡½æ•°è¯´æ˜Žï¼šåŒ…ï¿?20 æ¬¡å›žæ˜¾ï¿½? ï¿?PINGï¿?0 æ¬¡å¤§åŒ…æ”¶ï¿? */

-void ch395f_phase3_tests(void)
-{
-    uint8_t sock;
-    uint8_t rx_buf[300];
-    uint32_t tick;
-    int i;
-    int echo_ok;
+void ch395f_phase3_tests(void) {
+    uint8_t sock = 0;
+    uint8_t rx_buf[300] = {0};
+    uint32_t tick = 0;
+    int i = 0;
+    int echo_ok = 0;

    DBG_INFO("=== CH395F Phase 3 Tests (UDP) ===");

    sock = (uint8_t)(NET_MAX_SOCKETS - 1);

-    /* UDP Server 模式：DesIP=0xFFFFFFFF → 接受任意来源 */
+    /* UDP Server æ¨¡å¼<EFBFBD>ï¼šDesIP=0xFFFFFFFF ï¿?æŽ¥å<C2A5>—ä»»æ„<C3A6>æ<EFBFBD>¥æº<C3A6> */
    ch395f_set_proto_type(sock, CH395F_PROTO_TYPE_UDP);
    ch395f_set_send_buf(sock, 28, 2);
    ch395f_set_recv_buf(sock, 30, 2);
@@ -305,16 +295,13 @@ void ch395f_phase3_tests(void)

    HAL_Delay(200);

-    /* Echo 循环：收到 → 解析来源 → 回显 */
-    for (i = 0; i < PHASE3_ECHO_COUNT; i++)
-    {
+    /* Echo å¾ªçŽ¯ï¼šæ”¶ï¿?ï¿?è§£æž<C3A6>æ<EFBFBD>¥æº<C3A6> ï¿?å›žæ˜¾ */
+    for (i = 0; i < PHASE3_ECHO_COUNT; i++) {
        tick = HAL_GetTick();
        echo_ok = 0;
-        while (HAL_GetTick() - tick < PHASE3_TIMEOUT_MS)
-        {
+        while (HAL_GetTick() - tick < PHASE3_TIMEOUT_MS) {
            uint16_t rlen = ch395f_get_recv_len(sock);
-            if (rlen > 8)
-            {
+            if (rlen > 8) {
                memset(rx_buf, 0, sizeof(rx_buf));
                ch395f_read_recv_buf(sock, rx_buf, rlen);

@@ -334,11 +321,9 @@ void ch395f_phase3_tests(void)

                {
                    uint32_t swait = HAL_GetTick();
-                    while (HAL_GetTick() - swait < 2000)
-                    {
+                    while (HAL_GetTick() - swait < 2000) {
                        uint16_t gs = ch395f_get_glob_int_status_all();
-                        if (gs & (1U << (sock + 4)))
-                        {
+                        if (gs & (1U << (sock + 4))) {
                            if (ch395f_get_sock_int_status(sock) & CH395F_SINT_STAT_SENBUF_FREE)
                                break;
                        }
@@ -363,27 +348,28 @@ void ch395f_phase3_tests(void)

 /*
 * ============================ Phase 4 ============================
- * NET 层 TCP Echo：在主循环中调用，用 net_recv + net_send 回显
+ * NET ï¿?TCP Echoï¼šåœ¨ä¸»å¾ªçŽ¯ä¸è°ƒç”¨ï¼Œç”¨ net_recv + net_send å›žæ˜¾
 */

 #ifdef ENABLE_PHASE4_TESTS
 static char s_phase4_buf[2048];
 #endif

-void ch395f_phase4_tests(void)
-{
+/*
+ * å‡½æ•°åŠŸèƒ½ï¼šNET ï¿?TCP Echo æµ‹è¯•
+ * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šæ— 
+ * ï¿?ï¿?å€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šnet_init å·²å®Œï¿? * å‡½æ•°è¯´æ˜Žï¼šåœ¨ netTask ä¸è¿<C3A8>è¡Œï¼Œè½®è¯¢ Socket 1~7 å›žæ˜¾æŽ¥æ”¶æ•°æ<C2B0>®
+ */
+void ch395f_phase4_tests(void) {
 #ifdef ENABLE_PHASE4_TESTS
-    for (int i = NET_TCP_SERVER_DATA_SOCK_START; i < NET_MAX_SOCKETS; i++)
-    {
+    for (int i = NET_TCP_SERVER_DATA_SOCK_START; i < NET_MAX_SOCKETS; i++) {
        net_sock_t *sk = net_get_sock(i);
-        if (sk == NULL || !sk->in_use || sk->state != NET_SOCK_STATE_ESTABLISHED)
-        {
+        if (sk == NULL || !sk->in_use || sk->state != NET_SOCK_STATE_ESTABLISHED) {
            continue;
        }

        int n = net_recv(i, s_phase4_buf, sizeof(s_phase4_buf), NET_MSG_DONTWAIT);
-        if (n > 0)
-        {
+        if (n > 0) {
            net_send(i, s_phase4_buf, n, 0);
        }
    }
@@ -392,7 +378,7 @@ void ch395f_phase4_tests(void)

 /*
 * ============================ Phase 5 ============================
- * NET 层 UDP Echo：netTask 中运行，用 net_recvfrom + net_sendto 回显
+ * NET ï¿?UDP Echoï¼šnetTask ä¸è¿<EFBFBD>è¡Œï¼Œï¿?net_recvfrom + net_sendto å›žæ˜¾
 */

 #ifndef PHASE5_LOCAL_PORT
@@ -405,14 +391,15 @@ static char    s_phase5_buf[2048];
 static uint32_t s_phase5_count = 0;
 #endif

-void ch395f_phase5_init(void)
-{
+/*
+ * å‡½æ•°åŠŸèƒ½ï¼šNET ï¿?UDP Echo åˆ<C3A5>å§‹ï¿? * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šæ— 
+ * ï¿?ï¿?å€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šnet_init å·²å®Œï¿? * å‡½æ•°è¯´æ˜Žï¼šåˆ›ï¿?UDP Socket å¹¶ç»‘å®šæœ¬åœ°ç«¯ï¿? */
+void ch395f_phase5_init(void) {
 #ifdef ENABLE_PHASE5_TESTS
    struct net_sockaddr_in addr;

    s_phase5_sock = net_socket(NET_AF_INET, NET_SOCK_DGRAM, 0);
-    if (s_phase5_sock < 0)
-    {
+    if (s_phase5_sock < 0) {
        DBG_ERROR("Phase5: net_socket failed");
        return;
    }
@@ -421,8 +408,7 @@ void ch395f_phase5_init(void)
    addr.sin_family = NET_AF_INET;
    addr.sin_port   = net_htons(PHASE5_LOCAL_PORT);

-    if (net_bind(s_phase5_sock, (struct net_sockaddr *)&addr, sizeof(addr)) < 0)
-    {
+    if (net_bind(s_phase5_sock, (struct net_sockaddr *)&addr, sizeof(addr)) < 0) {
        DBG_ERROR("Phase5: net_bind failed");
        net_close(s_phase5_sock);
        s_phase5_sock = -1;
@@ -434,8 +420,12 @@ void ch395f_phase5_init(void)
 #endif
 }

-void ch395f_phase5_tests(void)
-{
+/*
+ * å‡½æ•°åŠŸèƒ½ï¼šNET ï¿?UDP Echo æµ‹è¯•
+ * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šæ— 
+ * ï¿?ï¿?å€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šch395f_phase5_init å·²æˆ<C3A6>åŠŸè°ƒï¿? * å‡½æ•°è¯´æ˜Žï¼šåœ¨ netTask ä¸è¿<C3A8>è¡Œï¼Œå›žæ˜¾ UDP æŽ¥æ”¶æ•°æ<C2B0>®
+ */
+void ch395f_phase5_tests(void) {
 #ifdef ENABLE_PHASE5_TESTS
    if (s_phase5_sock < 0) return;

@@ -445,8 +435,7 @@ void ch395f_phase5_tests(void)
    int n = net_recvfrom(s_phase5_sock, s_phase5_buf, sizeof(s_phase5_buf),
                         NET_MSG_DONTWAIT,
                         (struct net_sockaddr *)&src, &addrlen);
-    if (n > 0)
-    {
+    if (n > 0) {
        net_sendto(s_phase5_sock, s_phase5_buf, n, 0,
                   (struct net_sockaddr *)&src, sizeof(src));
        s_phase5_count++;
@@ -456,8 +445,7 @@ void ch395f_phase5_tests(void)
 }

 /*
- * Phase 6 配置默认值
- */
+ * Phase 6 é…<EFBFBD>ç½®é»˜è®¤ï¿? */
 #ifndef PHASE6_ANNOUNCE_PORT
 #define PHASE6_ANNOUNCE_PORT    60001
 #endif
@@ -467,15 +455,17 @@ void ch395f_phase5_tests(void)

 /*
 * ============================ Phase 6 ============================
- * DHCP 自动获取 IP 测试
+ * å‡½æ•°åŠŸèƒ½ï¼šDHCP è‡ªåŠ¨èŽ·å<C2B7>– IP æµ‹è¯•
+ * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šæ— 
+ * ï¿?ï¿?å€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šå±€åŸŸç½‘å†…å˜ï¿?DHCP Server
+ * å‡½æ•°è¯´æ˜Žï¼šå<C5A1>¯ï¿?DHCP ï¿?è½®è¯¢ç‰å¾… IP ï¿?æ‰“å<E2809C>°ç»“æžœ ï¿?å¹¿æ’å®£å‘Š ï¿?HELLO å›žæ˜¾
 */

-void ch395f_phase6_tests(void)
-{
+void ch395f_phase6_tests(void) {
 #ifdef ENABLE_PHASE6_TESTS
-    uint8_t status;
-    uint8_t ip_info[20];
-    uint32_t tick;
+    uint8_t status = 0;
+    uint8_t ip_info[20] = {0};
+    uint32_t tick = 0;

    DBG_INFO("=== CH395F Phase 6 Tests (DHCP) ===");

@@ -486,17 +476,14 @@ void ch395f_phase6_tests(void)
    /* 2. è½®è¯¢ç‰å¾… DHCP å®Œæˆ<C3A6> */
    HAL_Delay(500);
    tick = HAL_GetTick();
-    while (HAL_GetTick() - tick < 30000)
-    {
+    while (HAL_GetTick() - tick < 30000) {
        uint16_t gint = ch395f_get_glob_int_status_all();
-        if (gint & CH395F_GINT_STAT_DHCP)
-        {
+        if (gint & CH395F_GINT_STAT_DHCP) {
            DBG_INFO("DHCP interrupt");
        }

        status = ch395f_get_dhcp_status();
-        if (status == 0x00)
-        {
+        if (status == 0x00) {
            TEST_CHECK(1, "DHCP: SUCCESS");
            break;
        }
@@ -507,12 +494,11 @@ void ch395f_phase6_tests(void)
    TEST_CHECK(HAL_GetTick() - tick < 30000,
               "DHCP completed within 30s (status=0x%02X)", status);

-    if (HAL_GetTick() - tick >= 30000)
-    {
+    if (HAL_GetTick() - tick >= 30000) {
        goto phase6_end;
    }

-    /* 3. 读取获取的 IP */
+    /* 3. è¯»å<EFBFBD>–èŽ·å<EFBFBD>–ï¿?IP */
    ch395f_get_ip_inf(ip_info);
    DBG_INFO("  IP:   %d.%d.%d.%d", ip_info[0], ip_info[1], ip_info[2], ip_info[3]);
    DBG_INFO("  GW:   %d.%d.%d.%d", ip_info[4], ip_info[5], ip_info[6], ip_info[7]);
@@ -527,9 +513,9 @@ void ch395f_phase6_tests(void)
 #define PHASE6_HELLO_PORT       60000
        uint8_t anno_sock = PHASE6_ANNOUNCE_SOCK;
        uint8_t bcast_ip[4] = {0xFF, 0xFF, 0xFF, 0xFF};
-        uint8_t rx_buf[64];
+        uint8_t rx_buf[64] = {0};

-        /* UDP Server 模式：本地端口 60000（接收 HELLO），DesIP=0xFFFFFFFF */
+        /* UDP Server æ¨¡å¼<EFBFBD>ï¼šæœ¬åœ°ç«¯ï¿?60000ï¼ˆæŽ¥ï¿?HELLOï¼‰ï¼ŒDesIP=0xFFFFFFFF */
        ch395f_set_proto_type(anno_sock, CH395F_PROTO_TYPE_UDP);
        ch395f_set_send_buf(anno_sock, 24, 2);
        ch395f_set_recv_buf(anno_sock, 26, 2);
@@ -537,9 +523,8 @@ void ch395f_phase6_tests(void)
        ch395f_set_des_ip(anno_sock, bcast_ip);
        ch395f_set_des_port(anno_sock, 0);

-        if (ch395f_open_socket(anno_sock) == CH395F_ERR_SUCCESS)
-        {
-            /* 发送广播宣告（宣告端口 = 60001，来源端口 = 60000） */
+        if (ch395f_open_socket(anno_sock) == CH395F_ERR_SUCCESS) {
+            /* å<>‘é€<C3A9>å¹¿æ’å®£å‘Šï¼ˆå®£å‘Šç«¯å<C2AF>£ = 60001ï¼Œæ<C592>¥æº<C3A6>ç«¯ï¿?= 60000ï¿?*/
            ch395f_set_des_ip(anno_sock, bcast_ip);
            ch395f_set_des_port(anno_sock, PHASE6_ANNOUNCE_PORT);
            ch395f_write_send_buf(anno_sock, ip_info, 4);
@@ -547,11 +532,9 @@ void ch395f_phase6_tests(void)
            /* ç‰å¾… SENDBUF_FREEï¼ˆæ‰‹å†Œè¦<C3A8>æ±‚ï¼šæ¯<C3A6>æ¬¡ write_send_buf å<>Žå¿…é¡»ç‰å¾…ï¼‰ */
            {
                uint32_t swait = HAL_GetTick();
-                while (HAL_GetTick() - swait < 2000)
-                {
+                while (HAL_GetTick() - swait < 2000) {
                    uint16_t gs = ch395f_get_glob_int_status_all();
-                    if (gs & (1U << (anno_sock + 4)))
-                    {
+                    if (gs & (1U << (anno_sock + 4))) {
                        if (ch395f_get_sock_int_status(anno_sock) & CH395F_SINT_STAT_SENBUF_FREE)
                            break;
                    }
@@ -563,26 +546,23 @@ void ch395f_phase6_tests(void)
                     PHASE6_HELLO_PORT, PHASE6_ANNOUNCE_PORT);
            TEST_CHECK(1, "DHCP announcement sent");

-            /* 重置 Server 模式，等待 PC 发送 HELLO */
+            /* é‡<EFBFBD>ç½® Server æ¨¡å¼<EFBFBD>ï¼Œç‰ï¿?PC å<>‘ï¿½?HELLO */
            ch395f_set_des_ip(anno_sock, bcast_ip);
            ch395f_set_des_port(anno_sock, 0);

            uint32_t wait = HAL_GetTick();
            uint8_t hello_ok = 0;
-            while (HAL_GetTick() - wait < 5000)
-            {
-                /* 读取全局中断（刷新 socket 中断状态） */
+            while (HAL_GetTick() - wait < 5000) {
+                /* è¯»å<C2BB>–å…¨å±€ä¸æ–ï¼ˆåˆ·ï¿?socket ä¸æ–çŠ¶æ€<C3A6>ï¼‰ */
                ch395f_get_glob_int_status_all();
                uint16_t rlen = ch395f_get_recv_len(anno_sock);
-                if (rlen > 8)
-                {
+                if (rlen > 8) {
                    memset(rx_buf, 0, sizeof(rx_buf));
                    ch395f_read_recv_buf(anno_sock, rx_buf, rlen);
                    uint16_t payload_len = rlen - 8;
                    uint8_t *payload = &rx_buf[8];

-                    if (payload_len == 5 && memcmp(payload, "HELLO", 5) == 0)
-                    {
+                    if (payload_len == 5 && memcmp(payload, "HELLO", 5) == 0) {
                        uint8_t *src_ip = &rx_buf[4];
                        uint16_t src_port = (uint16_t)rx_buf[2] | ((uint16_t)rx_buf[3] << 8);
                        ch395f_set_des_ip(anno_sock, src_ip);
@@ -601,9 +581,7 @@ void ch395f_phase6_tests(void)
            TEST_CHECK(hello_ok, "HELLO echo within 5s");

            ch395f_close_socket(anno_sock);
-        }
-        else
-        {
+        } else {
            TEST_CHECK(0, "DHCP announcement: open socket failed");
        }
    }
@@ -615,7 +593,7 @@ phase6_end:

 /*
 * ============================ Phase 7 ============================
- * Select/Poll I/O 多路复用测试 — net_select() + net_recv/send echo
+ * Select/Poll I/O å¤šè·¯å¤<EFBFBD>ç”¨æµ‹è¯• ï¿?net_select() + net_recv/send echo
 */

 #include "net_select.h"
@@ -624,20 +602,23 @@ phase6_end:
 static char s_phase7_buf[2048];
 #endif

-void ch395f_phase7_tests(void)
-{
+/*
+ * å‡½æ•°åŠŸèƒ½ï¼šSelect/Poll I/O å¤šè·¯å¤<C3A5>ç”¨æµ‹è¯•
+ * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šæ— 
+ * ï¿?ï¿?å€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šnet_init å·²å®Œæˆ<C3A6>ï¼Œå¤šè¿žï¿?TCP Server å·²å<C2B2>¯ï¿? * å‡½æ•°è¯´æ˜Žï¼šåœ¨ netTask ä¸è¿<C3A8>è¡Œï¼ŒéªŒè¯<C3A8> select/poll æ£ç¡®è¿”å›žè¯»å†™äº‹ä»¶
+ */
+void ch395f_phase7_tests(void) {
 #ifdef ENABLE_PHASE7_TESTS
    static uint32_t s_phase7_count = 0;
    net_fd_set readfds;
    net_timeval tv;
+    FD_ZERO

    NET_FD_ZERO(&readfds);

-    for (int i = NET_TCP_SERVER_DATA_SOCK_START; i < NET_MAX_SOCKETS; i++)
-    {
+    for (int i = NET_TCP_SERVER_DATA_SOCK_START; i < NET_MAX_SOCKETS; i++) {
        net_sock_t *sk = net_get_sock(i);
-        if (sk && sk->in_use && sk->state == NET_SOCK_STATE_ESTABLISHED)
-        {
+        if (sk && sk->in_use && sk->state == NET_SOCK_STATE_ESTABLISHED) {
            NET_FD_SET(i, &readfds);
        }
    }
@@ -648,13 +629,11 @@ void ch395f_phase7_tests(void)
    int n = net_select(NET_MAX_SOCKETS, &readfds, NULL, NULL, &tv);
    if (n <= 0) return;

-    for (int i = 0; i < NET_MAX_SOCKETS; i++)
-    {
+    for (int i = 0; i < NET_MAX_SOCKETS; i++) {
        if (!NET_FD_ISSET(i, &readfds)) continue;

        int len = net_recv(i, s_phase7_buf, sizeof(s_phase7_buf), NET_MSG_DONTWAIT);
-        if (len > 0)
-        {
+        if (len > 0) {
            net_send(i, s_phase7_buf, len, 0);
            s_phase7_count++;
            TEST_CHECK(1, "Phase7: select echo #%lu (sock=%d, %d bytes)", s_phase7_count, i, len);
@@ -662,3 +641,4 @@ void ch395f_phase7_tests(void)
    }
 #endif
 }
+
--- a/Drivers/BSP/CH395F/ch395f_test.h
+++ b/Drivers/BSP/CH395F/ch395f_test.h
@@ -60,12 +60,12 @@ extern test_stats_t g_test_stats;
        g_test_stats.failed++; \
        DBG_ERROR("[FAIL] " fmt, ##__VA_ARGS__); \
    } \
-} while(0)
+} while (0)

 #define TEST_REPORT(name) do { \
    DBG_INFO("=== %s: %d/%d PASSED (failed=%d) ===", \
             name, g_test_stats.passed, g_test_stats.total, g_test_stats.failed); \
-} while(0)
+} while (0)

 /*
 * Phase 1: 底层寄存器测试
--- a/Drivers/BSP/GD5F2GQ5UE/fal_cfg.h
+++ b/Drivers/BSP/GD5F2GQ5UE/fal_cfg.h
@@ -3,34 +3,31 @@

 /*
 * æ¨¡å<C2A1>—å<E28094><C3A5>ç§°ï¼šFAL é…<C3A9>ç½®
- * 模块功能：定义 FAL Flash 设备表和分区表
- * 适用平台：STM32F407ZGT6
- * 作者：王建锋
- * 创建日期：2026-07-16
- * 修改记录：
- *     2026-07-16  王建锋  创建初始版本
+ * æ¨¡å<EFBFBD>—åŠŸèƒ½ï¼šå®šä¹?FAL Flash è®¾å¤‡è¡¨å’Œåˆ†åŒºè¡? * é€‚ç”¨å¹³å<C2B3>°ï¼šSTM32F407ZGT6
+ * ä½œè€…ï¼šçŽ‹å»ºé”? * åˆ›å»ºæ—¥æœŸï¼?026-07-16
+ * ä¿®æ”¹è®°å½•ï¼? *     2026-07-16  çŽ‹å»ºé”? åˆ›å»ºåˆ<C3A5>å§‹ç‰ˆæœ¬
 */

 #ifdef __cplusplus
 extern "C" {
 #endif

-/* FAL 调试开关：0-关闭，1-开启 */
+/* FAL è°ƒè¯•å¼€å…³ï¼š0-å…³é—ï¼?-å¼€å<E282AC>?*/
 #define FAL_DEBUG 0

-/* 启用分区表配置 */
+/* å<EFBFBD>¯ç”¨åˆ†åŒºè¡¨é…<EFBFBD>ç½?*/
 #define FAL_PART_HAS_TABLE_CFG

-/* ======================== Flash 设备表 ======================== */
+/* ======================== Flash è®¾å¤‡è¡?======================== */

-extern const struct fal_flash_dev gd5f2gq5ue_flash;
+extern const struct fal_flash_dev g_gd5f2gq5ue_flash;

 #define FAL_FLASH_DEV_TABLE          \
 {                                    \
-    &gd5f2gq5ue_flash,              \
+    &g_gd5f2gq5ue_flash,              \
 }

-/* ======================== 分区表 ======================== */
+/* ======================== åˆ†åŒºè¡?======================== */
 /*
 *  åˆ†åŒºå<C2BA><C3A5>ç§°       è®¾å¤‡å<E280A1><C3A5>ç§°        å<><C3A5>ç§»             å¤§å°<C3A5>
 *  KVDB: 64MB @ 0
@@ -49,3 +46,4 @@ extern const struct fal_flash_dev gd5f2gq5ue_flash;
 #endif

 #endif /* __FAL_CFG_H */
+
--- a/Drivers/BSP/GD5F2GQ5UE/fal_flash_gd5f2gq5ue.c
+++ b/Drivers/BSP/GD5F2GQ5UE/fal_flash_gd5f2gq5ue.c
@@ -1,11 +1,9 @@
 /*
 * 讓｡蝮怜錐遘ｰ<E98198>哥AL Flash 隶ｾ螟<EFBDBE>る<C280>
- * 模块功能：将 GD5F2GQ5UE 驱动接口适配到 FAL 框架
+ * 讓｡蝮怜粥閭ｽ<EFBFBD>壼ｰ<EFBFBD> GD5F2GQ5UE 鬩ｱ蜉ｨ謗･蜿｣騾る<EFBFBD><EFBFBD>?FAL 譯<EFBFBD>楔
 * 騾ら畑蟷ｳ蜿ｰ<E89CBF>售TM32F407ZGT6
- * 作者：王建锋
- * 创建日期：2026-07-16
- * 修改记录：
- *     2026-07-16  王建锋  创建初始版本
+ * 菴懆<EFBFBD>ｼ夂視蟒ｺ<EFBFBD>? * 蛻帛ｻｺ譌･譛滂ｿ?026-07-16
+ * 菫ｮ謾ｹ隶ｰ蠖包ｿ? *     2026-07-16  邇句ｻｺ<EFBDBB>? 蛻帛ｻｺ蛻晏ｧ狗沿譛ｬ
 */

 /* 螟ｴ譁<EFBDB4>ｻｶ蛹<EFBDB6>性蛹ｺ */
@@ -17,60 +15,45 @@
 /*
 * 蜃ｽ謨ｰ蜉溯<E89C89><E6BAAF>哥lash 隶ｾ螟<EFBDBE><E89E9F>蟋句喧騾る<E9A8BE>
 * 蜈･蜿｣蜿よ焚<E38288>壽裏
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：SPI 和 GPIO 已由 CubeMX 初始化完成
- * 函数说明：调用底层驱动的初始化函数
- */
-static int gd5f_fal_init(void)
-{
+ * 霑泌屓蛟ｼ<EFBFBD><EFBFBD>0 - 謌仙粥<E4BB99>悟<EFBFBD><E6829F>?- 髞呵ｯｯ<EFBDAF>? * 髯仙ｮ壽擅莉ｶ<E88E89>售PI <20>?GPIO 蟾ｲ逕ｱ CubeMX 蛻晏ｧ句喧螳鯉ｿ? * 蜃ｽ謨ｰ隸ｴ譏趣ｼ夊ｰ<E5A48A>畑蠎募ｱるｩｱ蜉ｨ逧<EFBDA8><E980A7>蟋句喧蜃ｽ<E89C83>? */
+static int gd5f_fal_init(void) {
    return gd5f2gq5ue_init();
 }

 /*
 * 蜃ｽ謨ｰ蜉溯<E89C89><E6BAAF>哥lash 隸ｻ蜿夜る<C280>
 * 蜈･蜿｣蜿よ焚<E38288>嗤ffset - 襍ｷ蟋句ｭ苓鰍蛛冗ｧｻ  long
- *           p_buf  - 数据缓冲区     uint8_t*
- *           size   - 读取字节数     size_t
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：gd5f_fal_init() 已成功调用
- * 函数说明：直接转发到底层驱动的读取函数
- */
-static int gd5f_fal_read(long offset, uint8_t *p_buf, size_t size)
-{
+ *           p_buf  - 謨ｰ謐ｮ郛灘<EFBFBD><EFBFBD>?    uint8_t*
+ *           size   - 隸ｻ蜿門ｭ苓鰍<EFBFBD>?    size_t
+ * 霑泌屓蛟ｼ<EFBFBD><EFBFBD>0 - 謌仙粥<E4BB99>悟<EFBFBD><E6829F>?- 髞呵ｯｯ<EFBDAF>? * 髯仙ｮ壽擅莉ｶ<E88E89>喩d5f_fal_init() 蟾ｲ謌仙粥隹<E7B2A5>ｿ? * 蜃ｽ謨ｰ隸ｴ譏趣ｼ夂峩謗･霓ｬ蜿大芦蠎募ｱるｩｱ蜉ｨ逧<EFBDA8>ｯｻ蜿門<E89CBF><E99680>? */
+static int gd5f_fal_read(long offset, uint8_t *p_buf, size_t size) {
    return gd5f2gq5ue_read(offset, p_buf, size);
 }

 /*
 * 蜃ｽ謨ｰ蜉溯<E89C89><E6BAAF>哥lash 蜀吝<E89C80>騾る<E9A8BE>
 * 蜈･蜿｣蜿よ焚<E38288>嗤ffset - 襍ｷ蟋句ｭ苓鰍蛛冗ｧｻ  long
- *           p_buf  - 数据缓冲区     const uint8_t*
- *           size   - 写入字节数     size_t
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：目标区域已擦除
- * 函数说明：直接转发到底层驱动的写入函数
- */
-static int gd5f_fal_write(long offset, const uint8_t *p_buf, size_t size)
-{
+ *           p_buf  - 謨ｰ謐ｮ郛灘<EFBFBD><EFBFBD>?    const uint8_t*
+ *           size   - 蜀吝<EFBFBD>蟄苓鰍<EFBFBD>?    size_t
+ * 霑泌屓蛟ｼ<EFBFBD><EFBFBD>0 - 謌仙粥<E4BB99>悟<EFBFBD><E6829F>?- 髞呵ｯｯ<EFBDAF>? * 髯仙ｮ壽擅莉ｶ<E88E89>夂岼譬<E5B2BC>玄蝓溷ｷｲ謫ｦ髯､
+ * 蜃ｽ謨ｰ隸ｴ譏趣ｼ夂峩謗･霓ｬ蜿大芦蠎募ｱるｩｱ蜉ｨ逧<EFBFBD><EFBFBD>蜈･蜃ｽ<EFBFBD>? */
+static int gd5f_fal_write(long offset, const uint8_t *p_buf, size_t size) {
    return gd5f2gq5ue_write(offset, p_buf, size);
 }

 /*
 * 蜃ｽ謨ｰ蜉溯<E89C89><E6BAAF>哥lash 謫ｦ髯､騾る<E9A8BE>
 * 蜈･蜿｣蜿よ焚<E38288>嗤ffset - 襍ｷ蟋句ｭ苓鰍蛛冗ｧｻ  long
- *           size   - 擦除字节数    size_t
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：gd5f_fal_init() 已成功调用
- * 函数说明：直接转发到底层驱动的擦除函数
- */
-static int gd5f_fal_erase(long offset, size_t size)
-{
+ *           size   - 謫ｦ髯､蟄苓鰍<EFBFBD>?   size_t
+ * 霑泌屓蛟ｼ<EFBFBD><EFBFBD>0 - 謌仙粥<E4BB99>悟<EFBFBD><E6829F>?- 髞呵ｯｯ<EFBDAF>? * 髯仙ｮ壽擅莉ｶ<E88E89>喩d5f_fal_init() 蟾ｲ謌仙粥隹<E7B2A5>ｿ? * 蜃ｽ謨ｰ隸ｴ譏趣ｼ夂峩謗･霓ｬ蜿大芦蠎募ｱるｩｱ蜉ｨ逧<EFBDA8>逃髯､蜃ｽ<E89C83>? */
+static int gd5f_fal_erase(long offset, size_t size) {
    return gd5f2gq5ue_erase(offset, size);
 }

 /* ======================== FAL Flash 隶ｾ螟<EFBDBE>ｮ壻ｹ<E5A3BB> ======================== */

-/* GD5F2GQ5UE FAL 设备实例，总容量256MB，块大小128KB */
-const struct fal_flash_dev gd5f2gq5ue_flash = {
+/* GD5F2GQ5UE FAL 隶ｾ螟<EFBFBD>ｮ樔ｾ具ｼ梧ｻ螳ｹ<EFBFBD>?56MB<4D>悟摎螟ｧ蟆<EFBDA7>128KB */
+const struct fal_flash_dev g_gd5f2gq5ue_flash = {
    .name       = "gd5f2gq5ue",
    .addr       = 0,
    .len        = GD5F_TOTAL_SIZE,
@@ -83,3 +66,4 @@ const struct fal_flash_dev gd5f2gq5ue_flash = {
    },
    .write_gran = 8,
 };
+
--- a/Drivers/BSP/GD5F2GQ5UE/gd5f2gq5ue.c
+++ b/Drivers/BSP/GD5F2GQ5UE/gd5f2gq5ue.c
@@ -1,17 +1,14 @@
 /*
 * 妯″潡鍚嶇О锛欸D5F2GQ5UE SPI NAND Flash 椹卞姩
- * 模块功能：提供 GD5F2GQ5UE SPI NAND Flash 的初始化、读、写、擦除接口
- * 适用平台：STM32F407ZGT6 + SPI1 硬件 SPI
- * 作者：王建锋
- * 创建日期：2026-07-16
- * 修改记录：
- *     2026-07-16  王建锋  创建初始版本
- *     2026-07-17  王建锋  切换硬件 SPI，修正擦除地址，参考 NuttX 驱动
+ * 妯″潡鍔熻兘锛氭彁锟?GD5F2GQ5UE SPI NAND Flash 鐨勫垵濮嬪寲銆佽<EFBFBD>銆佸啓銆佹摝闄ゆ帴锟? * 閫傜敤骞冲彴锛歋TM32F407ZGT6 + SPI1 纭<>欢 SPI
+ * 浣滆€咃細鐜嬪缓锟? * 鍒涘缓鏃ユ湡锟?026-07-16
+ * 淇<EFBFBD>敼璁板綍锟? *     2026-07-16  鐜嬪缓锟? 鍒涘缓鍒濆<E98D92>鐗堟湰
+ *     2026-07-17  鐜嬪缓锟? 鍒囨崲纭<E5B4B2>欢 SPI锛屼慨姝ｆ摝闄ゅ湴鍧€锛屽弬锟?NuttX 椹卞姩
 */

 /* 澶存枃浠跺寘鍚<E5AF98>尯 */
-#include "gd5f2gq5ue.h"
 #include <string.h>
+#include "gd5f2gq5ue.h"

 /*
 * 璋冭瘯杈撳嚭閰嶇疆
@@ -43,12 +40,11 @@ static int gd5f_block_erase(uint32_t block_addr);
 /*
 * 鍑芥暟鍔熻兘锛氱瓑寰呰姱鐗囨搷浣滃畬鎴愶紙杞<E7B499><E69D9E> OIP 浣嶏級
 * 鍏ュ彛鍙傛暟锛歵imeout_ms - 瓒呮椂鏃堕棿  uint32_t  > 0
- * 返回值：0 - 操作完成，-2 - 超时
+ * 杩斿洖鍊硷細0 - 鎿嶄綔瀹屾垚锟?2 - 瓒呮椂
 * 闄愬畾鏉′欢锛歋PI 宸插垵濮嬪寲
 * 鍑芥暟璇存槑锛氬惊鐜<E6838A><E9909C>鍙栫姸鎬佸瘎瀛樺櫒鐩村埌 OIP 浣嶆竻闆舵垨瓒呮椂
 */
-static int gd5f_wait_busy(uint32_t timeout_ms)
-{
+static int gd5f_wait_busy(uint32_t timeout_ms) {
    uint8_t cmd = GD5F_CMD_GET_FEATURE;
    uint8_t addr = GD5F_REG_STATUS;
    uint8_t status = 0;
@@ -75,10 +71,8 @@ static int gd5f_wait_busy(uint32_t timeout_ms)
 * 鍏ュ彛鍙傛暟锛氭棤
 * 杩斿洖鍊硷細0 - 鎴愬姛
 * 闄愬畾鏉′欢锛歋PI 宸插垵濮嬪寲
- * 函数说明：CS# 拉低后发送 06h 命令再拉高
- */
-static int gd5f_write_enable(void)
-{
+ * 鍑芥暟璇存槑锛欳S# 鎷変綆鍚庡彂锟?06h 鍛戒护鍐嶆媺锟? */
+static int gd5f_write_enable(void) {
    uint8_t cmd = GD5F_CMD_WRITE_ENABLE;

    GD5F_CS_LOW();
@@ -90,13 +84,11 @@ static int gd5f_write_enable(void)

 /*
 * 鍑芥暟鍔熻兘锛氳<E9949B>鍙栫姸鎬佸瘎瀛樺櫒
- * 入口参数：p_status - 状态值输出指针  uint8_t*  不为 NULL
+ * 鍏ュ彛鍙傛暟锛歱_status - 鐘舵€佸€艰緭鍑烘寚锟? uint8_t*  涓嶄负 NULL
 * 杩斿洖鍊硷細0 - 鎴愬姛
 * 闄愬畾鏉′欢锛歋PI 宸插垵濮嬪寲
- * 函数说明：发送 0Fh + C0h 地址后读取1字节状态值
- */
-static int gd5f_read_status(uint8_t *p_status)
-{
+ * 鍑芥暟璇存槑锛氬彂锟?0Fh + C0h 鍦板潃鍚庤<E98D9A>锟?瀛楄妭鐘舵€侊拷? */
+static int gd5f_read_status(uint8_t *p_status) {
    uint8_t cmd = GD5F_CMD_GET_FEATURE;
    uint8_t addr = GD5F_REG_STATUS;

@@ -110,15 +102,12 @@ static int gd5f_read_status(uint8_t *p_status)
 }

 /*
- * 函数功能：页读取（将数据从存储阵列加载到内部缓存）
- * 入口参数：page_addr - 页地址  uint32_t
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：SPI 已初始化
- * 函数说明：发送 13h + 3字节行地址，等待 OIP 清零
+ * 鍑芥暟鍔熻兘锛氶〉璇诲彇锛堝皢鏁版嵁浠庡瓨鍌ㄩ樀鍒楀姞杞藉埌鍐呴儴缂撳瓨锟? * 鍏ュ彛鍙傛暟锛歱age_addr - 椤靛湴鍧€  uint32_t
+ * 杩斿洖鍊硷細0 - 鎴愬姛锛屽叾锟?- 閿欒<E996BF>锟? * 闄愬畾鏉′欢锛歋PI 宸插垵濮嬪寲
+ * 鍑芥暟璇存槑锛氬彂锟?13h + 3瀛楄妭琛屽湴鍧€锛岀瓑锟?OIP 娓呴浂
 */
-static int gd5f_page_read(uint32_t page_addr)
-{
-    uint8_t cmd[4];
+static int gd5f_page_read(uint32_t page_addr) {
+    uint8_t cmd[4] = {0};

    cmd[0] = GD5F_CMD_PAGE_READ;
    cmd[1] = (page_addr >> 16) & 0xFF;
@@ -135,16 +124,14 @@ static int gd5f_page_read(uint32_t page_addr)
 /*
 * 鍑芥暟鍔熻兘锛氫粠鍐呴儴缂撳瓨璇诲彇鏁版嵁
 * 鍏ュ彛鍙傛暟锛歝olumn - 鍒楀湴鍧€锛堥〉鍐呭亸绉伙級  uint16_t  0 - 2047
- *           p_buf  - 数据输出缓冲区       uint8_t*  不为 NULL
- *           size   - 读取字节数           size_t    > 0
+ *           p_buf  - 鏁版嵁杈撳嚭缂撳啿锟?      uint8_t*  涓嶄负 NULL
+ *           size   - 璇诲彇瀛楄妭锟?          size_t    > 0
 * 杩斿洖鍊硷細0 - 鎴愬姛
 * 闄愬畾鏉′欢锛氬繀椤诲厛璋冪敤 gd5f_page_read 瀹屾垚鏁版嵁鍔犺浇
- * 函数说明：发送 0Bh + 2字节列地址 +1字节 dummy 后读取数据
- */
+ * 鍑芥暟璇存槑锛氬彂锟?0Bh + 2瀛楄妭鍒楀湴鍧€ +1瀛楄妭 dummy 鍚庤<E98D9A>鍙栨暟锟? */
 static int gd5f_read_from_cache(uint16_t column, uint8_t *p_buf,
-                                 size_t size)
-{
-    uint8_t cmd[4];
+                                 size_t size) {
+    uint8_t cmd[4] = {0};

    cmd[0] = GD5F_CMD_READ_FROM_CACHE;
    cmd[1] = (column >> 8) & 0xFF;
@@ -163,16 +150,13 @@ static int gd5f_read_from_cache(uint16_t column, uint8_t *p_buf,
 * 鍑芥暟鍔熻兘锛氶〉缂栫▼锛堝皢鏁版嵁鍐欏叆鎸囧畾椤碉級
 * 鍏ュ彛鍙傛暟锛歱age_addr - 椤靛湴鍧€   uint32_t
 *           column    - 鍒楀湴鍧€   uint16_t  0 - 2047
- *           p_buf     - 数据缓冲区  const uint8_t*
- *           size      - 写入字节数  size_t    > 0
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：目标区域已擦除
- * 函数说明：1. 写使能 - 02h 加载数据 - 10h 执行编程 - 等待完成
- *           2. 编程完成后检查 P_FAIL 位
- */
+ *           p_buf     - 鏁版嵁缂撳啿锟? const uint8_t*
+ *           size      - 鍐欏叆瀛楄妭锟? size_t    > 0
+ * 杩斿洖鍊硷細0 - 鎴愬姛锛屽叾锟?- 閿欒<E996BF>锟? * 闄愬畾鏉′欢锛氱洰鏍囧尯鍩熷凡鎿﹂櫎
+ * 鍑芥暟璇存槑锟?. 鍐欎娇锟?- 02h 鍔犺浇鏁版嵁 - 10h 鎵ц<E98EB5>缂栫▼ - 绛夊緟瀹屾垚
+ *           2. 缂栫▼瀹屾垚鍚庢<E98D9A>锟?P_FAIL 锟? */
 static int gd5f_page_program(uint32_t page_addr, uint16_t column,
-                              const uint8_t *p_buf, size_t size)
-{
+                              const uint8_t *p_buf, size_t size) {
    int ret = GD5F_OK;
    uint8_t cmd[4];
    uint8_t status = 0;
@@ -212,15 +196,12 @@ static int gd5f_page_program(uint32_t page_addr, uint16_t column,
 }

 /*
- * 函数功能：设置 Feature 寄存器
- * 入口参数：addr - 寄存器地址  uint8_t
+ * 鍑芥暟鍔熻兘锛氳<EFBFBD>锟?Feature 瀵勫瓨锟? * 鍏ュ彛鍙傛暟锛歛ddr - 瀵勫瓨鍣ㄥ湴鍧€  uint8_t
 *           data - 鍐欏叆鏁版嵁    uint8_t
 * 杩斿洖鍊硷細0 - 鎴愬姛
 * 闄愬畾鏉′欢锛歋PI 宸插垵濮嬪寲
- * 函数说明：先写使能，发送 1Fh + 地址 + 数据，等待操作完成
- */
-static int gd5f_set_feature(uint8_t addr, uint8_t data)
-{
+ * 鍑芥暟璇存槑锛氬厛鍐欎娇鑳斤紝鍙戯拷?1Fh + 鍦板潃 + 鏁版嵁锛岀瓑寰呮搷浣滃畬锟? */
+static int gd5f_set_feature(uint8_t addr, uint8_t data) {
    uint8_t cmd[3];

    gd5f_write_enable();
@@ -239,15 +220,11 @@ static int gd5f_set_feature(uint8_t addr, uint8_t data)
 }

 /*
- * 函数功能：块擦除（擦除128KB块）
- * 入口参数：block_addr - 块编号  uint32_t  0 - 2047
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：gd5f2gq5ue_init() 已调用
- * 函数说明：1. 写使能 - D8h + 3字节字节地址 - 等待完成
- *           2. 擦除完成后检查 E_FAIL 位
- */
-static int gd5f_block_erase(uint32_t block_addr)
-{
+ * 鍑芥暟鍔熻兘锛氬潡鎿﹂櫎锛堟摝锟?28KB鍧楋級
+ * 鍏ュ彛鍙傛暟锛歜lock_addr - 鍧楃紪锟? uint32_t  0 - 2047
+ * 杩斿洖鍊硷細0 - 鎴愬姛锛屽叾锟?- 閿欒<E996BF>锟? * 闄愬畾鏉′欢锛歡d5f2gq5ue_init() 宸茶皟锟? * 鍑芥暟璇存槑锟?. 鍐欎娇锟?- D8h + 3瀛楄妭瀛楄妭鍦板潃 - 绛夊緟瀹屾垚
+ *           2. 鎿﹂櫎瀹屾垚鍚庢<E98D9A>锟?E_FAIL 锟? */
+static int gd5f_block_erase(uint32_t block_addr) {
    int ret = GD5F_OK;
    uint8_t cmd[4];
    uint8_t status = 0;
@@ -282,15 +259,11 @@ static int gd5f_block_erase(uint32_t block_addr)
 /*
 * 鍑芥暟鍔熻兘锛氬垵濮嬪寲 GD5F2GQ5UE
 * 鍏ュ彛鍙傛暟锛氭棤
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：SPI1 和相关 GPIO 已由 CubeMX 初始化完成
- * 函数说明：1. 发送复位命令并等待完成
- *           2. 读取芯片 ID 并校验
- *           3. 使能内部 ECC (B0h bit4)
+ * 杩斿洖鍊硷細0 - 鎴愬姛锛屽叾锟?- 閿欒<E996BF>锟? * 闄愬畾鏉′欢锛歋PI1 鍜岀浉锟?GPIO 宸茬敱 CubeMX 鍒濆<E98D92>鍖栧畬锟? * 鍑芥暟璇存槑锟?. 鍙戦€佸<E282AC>浣嶅懡浠ゅ苟绛夊緟瀹屾垚
+ *           2. 璇诲彇鑺<E5BD87>墖 ID 骞舵牎锟? *           3. 浣胯兘鍐呴儴 ECC (B0h bit4)
 *           4. 瑙ｉ櫎鎵€鏈夊潡淇濇姢 (A0h = 0x00)
 */
-int gd5f2gq5ue_init(void)
-{
+int gd5f2gq5ue_init(void) {
    int ret = GD5F_OK;
    uint8_t mid = 0;
    uint8_t did = 0;
@@ -338,15 +311,13 @@ int gd5f2gq5ue_init(void)
 }

 /*
- * 函数功能：读取芯片 ID（MID + DID）
- * 入口参数：mid - 制造商 ID 输出指针  uint8_t*  不为 NULL
+ * 鍑芥暟鍔熻兘锛氳<EFBFBD>鍙栬姱锟?ID锛圡ID + DID锟? * 鍏ュ彛鍙傛暟锛歮id - 鍒堕€犲晢 ID 杈撳嚭鎸囬拡  uint8_t*  涓嶄负 NULL
 *           did - 璁惧<E79281> ID 杈撳嚭鎸囬拡    uint8_t*  涓嶄负 NULL
 * 杩斿洖鍊硷細0 - 鎴愬姛
 * 闄愬畾鏉′欢锛歋PI 宸插垵濮嬪寲
- * 函数说明：发送 9Fh 命令后接收1个 dummy + MID + DID
+ * 鍑芥暟璇存槑锛氬彂锟?9Fh 鍛戒护鍚庢帴锟?锟?dummy + MID + DID
 */
-int gd5f2gq5ue_read_id(uint8_t *mid, uint8_t *did)
-{
+int gd5f2gq5ue_read_id(uint8_t *p_mid, uint8_t *p_did) {
    uint8_t cmd = GD5F_CMD_READ_ID;
    uint8_t id_buf[3] = {0};

@@ -355,23 +326,19 @@ int gd5f2gq5ue_read_id(uint8_t *mid, uint8_t *did)
    HAL_SPI_Receive(&hspi1, id_buf, 3, GD5F_SPI_TIMEOUT);
    GD5F_CS_HIGH();

-    *mid = id_buf[1];
-    *did = id_buf[2];
+    *p_mid = id_buf[1];
+    *p_did = id_buf[2];

    return GD5F_OK;
 }

 /*
 * 鍑芥暟鍔熻兘锛氫粠 NAND 璇诲彇鏁版嵁锛堟敮鎸佽法椤碉級
- * 入口参数：offset - 起始字节偏移  long      0 ~ 总容量-1
- *           p_buf  - 数据缓冲区     uint8_t*  不为 NULL
- *           size   - 读取字节数     size_t    > 0
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：gd5f2gq5ue_init() 已成功调用
- * 函数说明：自动处理跨页读取
- */
-int gd5f2gq5ue_read(long offset, uint8_t *p_buf, size_t size)
-{
+ * 鍏ュ彛鍙傛暟锛歰ffset - 璧峰<E792A7>瀛楄妭鍋忕Щ  long      0 ~ 鎬诲<EFBFBD>锟?1
+ *           p_buf  - 鏁版嵁缂撳啿锟?    uint8_t*  涓嶄负 NULL
+ *           size   - 璇诲彇瀛楄妭锟?    size_t    > 0
+ * 杩斿洖鍊硷細0 - 鎴愬姛锛屽叾锟?- 閿欒<E996BF>锟? * 闄愬畾鏉′欢锛歡d5f2gq5ue_init() 宸叉垚鍔熻皟锟? * 鍑芥暟璇存槑锛氳嚜鍔ㄥ<E98D94>鐞嗚法椤佃<E6A4A4>锟? */
+int gd5f2gq5ue_read(long offset, uint8_t *p_buf, size_t size) {
    int ret = GD5F_OK;

    while (size > 0) {
@@ -403,15 +370,11 @@ int gd5f2gq5ue_read(long offset, uint8_t *p_buf, size_t size)

 /*
 * 鍑芥暟鍔熻兘锛氬悜 NAND 鍐欏叆鏁版嵁锛堟敮鎸佽法椤碉級
- * 入口参数：offset - 起始字节偏移  long          0 ~ 总容量-1
- *           p_buf  - 数据缓冲区     const uint8_t*  不为 NULL
- *           size   - 写入字节数     size_t        > 0
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：gd5f2gq5ue_init() 已成功调用，目标区域已擦除
- * 函数说明：自动处理跨页写入
- */
-int gd5f2gq5ue_write(long offset, const uint8_t *p_buf, size_t size)
-{
+ * 鍏ュ彛鍙傛暟锛歰ffset - 璧峰<E792A7>瀛楄妭鍋忕Щ  long          0 ~ 鎬诲<EFBFBD>锟?1
+ *           p_buf  - 鏁版嵁缂撳啿锟?    const uint8_t*  涓嶄负 NULL
+ *           size   - 鍐欏叆瀛楄妭锟?    size_t        > 0
+ * 杩斿洖鍊硷細0 - 鎴愬姛锛屽叾锟?- 閿欒<E996BF>锟? * 闄愬畾鏉′欢锛歡d5f2gq5ue_init() 宸叉垚鍔熻皟鐢<E79A9F>紝鐩<E7B49D>爣鍖哄煙宸叉摝锟? * 鍑芥暟璇存槑锛氳嚜鍔ㄥ<E98D94>鐞嗚法椤靛啓锟? */
+int gd5f2gq5ue_write(long offset, const uint8_t *p_buf, size_t size) {
    int ret = GD5F_OK;

    while (size > 0) {
@@ -437,15 +400,9 @@ int gd5f2gq5ue_write(long offset, const uint8_t *p_buf, size_t size)
 }

 /*
- * 函数功能：擦除块（按块擦除，最小单位 128KB）
- * 入口参数：offset - 起始字节偏移  long    必须块对齐
- *           size   - 擦除字节数    size_t  必须块大小整数倍
- * 返回值：0 - 成功，其他 - 错误码
- * 限定条件：gd5f2gq5ue_init() 已成功调用
- * 函数说明：擦除操作以块为单位
+ * 鍑芥暟鍔熻兘锛氭摝闄ゅ潡锛堟寜鍧楁摝闄わ紝鏈€灏忓崟锟?128KB锟? * 鍏ュ彛鍙傛暟锛歰ffset - 璧峰<E792A7>瀛楄妭鍋忕Щ  long    蹇呴』鍧楀<E98DA7>锟? *           size   - 鎿﹂櫎瀛楄妭锟?   size_t  蹇呴』鍧楀ぇ灏忔暣鏁帮拷? * 杩斿洖鍊硷細0 - 鎴愬姛锛屽叾锟?- 閿欒<E996BF>锟? * 闄愬畾鏉′欢锛歡d5f2gq5ue_init() 宸叉垚鍔熻皟锟? * 鍑芥暟璇存槑锛氭摝闄ゆ搷浣滀互鍧椾负鍗曚綅
 */
-int gd5f2gq5ue_erase(long offset, size_t size)
-{
+int gd5f2gq5ue_erase(long offset, size_t size) {
    int ret = GD5F_OK;

    if (offset % GD5F_BLOCK_SIZE != 0) {
@@ -471,14 +428,12 @@ int gd5f2gq5ue_erase(long offset, size_t size)
 }

 /*
- * 函数功能：复位芯片
- * 入口参数：无
+ * 鍑芥暟鍔熻兘锛氬<EFBFBD>浣嶈姱锟? * 鍏ュ彛鍙傛暟锛氭棤
 * 杩斿洖鍊硷細0 - 鎴愬姛
 * 闄愬畾鏉′欢锛歋PI 宸插垵濮嬪寲
- * 函数说明：发送 FFh 复位命令后等待 5ms
+ * 鍑芥暟璇存槑锛氬彂锟?FFh 澶嶄綅鍛戒护鍚庣瓑锟?5ms
 */
-int gd5f2gq5ue_reset(void)
-{
+int gd5f2gq5ue_reset(void) {
    uint8_t cmd = GD5F_CMD_RESET;

    GD5F_CS_LOW();
@@ -489,3 +444,4 @@ int gd5f2gq5ue_reset(void)

    return GD5F_OK;
 }
+
--- a/Drivers/BSP/GD5F2GQ5UE/gd5f2gq5ue.h
+++ b/Drivers/BSP/GD5F2GQ5UE/gd5f2gq5ue.h
@@ -101,7 +101,7 @@ int gd5f2gq5ue_init(void);
 * 限定条件：SPI 已初始化
 * 函数说明：发送 9Fh 命令后接收1个 dummy + MID + DID
 */
-int gd5f2gq5ue_read_id(uint8_t *mid, uint8_t *did);
+int gd5f2gq5ue_read_id(uint8_t *p_mid, uint8_t *p_did);

 /*
 * 函数功能：从 NAND 读取数据（支持跨页）
--- a/Drivers/BSP/NET/net_select.c
+++ b/Drivers/BSP/NET/net_select.c
@@ -1,34 +1,26 @@
 /*
 * 模块名称：Network Select Implementation
- * 模块功能：I/O 多路复用实现，包括 select 和 poll 模式，
- *          用于同时监控多个 Socket 的读写事件
- * 适用平台：STM32F4 系列（CH395F 以太网芯片）
- * 作者：王建锋
- * 创建日期：2026-07-18
- * 修改记录：
- */
+ * 模块功能：I/O 多路复用实现，包<EFBFBD>?select <EFBFBD>?poll 模式<EFBFBD>? *          用于同时监控多个 Socket 的读写事<E58699>? * 适用平台：STM32F4 系列（CH395F 以太网芯片）
+ * 作者：王建<EFBFBD>? * 创建日期<E697A5>?026-07-18
+ * 修改记录<EFBFBD>? */

 #include "net_select.h"
 #include "net_socket.h"
 #include "ch395f.h"

 /*
- * 私有函数声明区
- */
+ * 私有函数声明<EFBFBD>? */
 static int check_socket_readable(int sockfd);
 static int check_socket_writable(int sockfd);
 static int check_socket_error(int sockfd);

 /*
- * 公共函数实现区
- */
+ * 公共函数实现<EFBFBD>? */

 /*
- * 函数功能：I/O 多路复用（select 模式）
- */
+ * 函数功能：I/O 多路复用（select 模式<EFBFBD>? */
 int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
-               net_fd_set *exceptfds, net_timeval *timeout)
-{
+               net_fd_set *exceptfds, net_timeval *timeout) {
    uint32_t start_tick;
    uint32_t timeout_ms = 0;
    net_fd_set result_read = {0};
@@ -38,56 +30,46 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
    int i;

    /* 计算超时时间 */
-    if (timeout != NULL)
-    {
+    if (timeout != NULL) {
        timeout_ms = (uint32_t)(timeout->tv_sec * 1000) +
                     (uint32_t)(timeout->tv_usec / 1000);
    }

    start_tick = HAL_GetTick();

-    while (1)
-    {
-        /* 轮询所有 Socket */
+    while (1) {
+        /* 轮询所<E8AFA2>?Socket */
        net_poll();

        ready_count = 0;

-        /* 检查哪些 Socket 有事件 */
-        for (i = 0; i < nfds && i < NET_MAX_SOCKETS; i++)
-        {
-            net_sock_t *sock = net_get_sock(i);
+        /* 检查哪<EFBFBD>?Socket 有事<EFBFBD>?*/
+        for (i = 0; i < nfds && i < NET_MAX_SOCKETS; i++) {
+            net_sock_t *p_sock = net_get_sock(i);

-            if (sock == NULL)
-            {
+            if (p_sock == NULL) {
                continue;
            }

-            /* 检查可读事件 */
-            if (readfds != NULL && NET_FD_ISSET(i, readfds))
-            {
-                if (check_socket_readable(i))
-                {
+            /* 检查可读事<EFBFBD>?*/
+            if (readfds != NULL && NET_FD_ISSET(i, readfds)) {
+                if (check_socket_readable(i)) {
                    NET_FD_SET(i, &result_read);
                    ready_count++;
                }
            }

-            /* 检查可写事件 */
-            if (writefds != NULL && NET_FD_ISSET(i, writefds))
-            {
-                if (check_socket_writable(i))
-                {
+            /* 检查可写事<EFBFBD>?*/
+            if (writefds != NULL && NET_FD_ISSET(i, writefds)) {
+                if (check_socket_writable(i)) {
                    NET_FD_SET(i, &result_write);
                    ready_count++;
                }
            }

-            /* 检查异常事件 */
-            if (exceptfds != NULL && NET_FD_ISSET(i, exceptfds))
-            {
-                if (check_socket_error(i))
-                {
+            /* 检查异常事<EFBFBD>?*/
+            if (exceptfds != NULL && NET_FD_ISSET(i, exceptfds)) {
+                if (check_socket_error(i)) {
                    NET_FD_SET(i, &result_except);
                    ready_count++;
                }
@@ -95,17 +77,14 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
        }

        /* 有事件就绪，返回 */
-        if (ready_count > 0)
-        {
+        if (ready_count > 0) {
            break;
        }

-        /* 超时检查 */
-        if (timeout != NULL)
-        {
+        /* 超时检<EFBFBD>?*/
+        if (timeout != NULL) {
            if (timeout_ms > 0 &&
-                (HAL_GetTick() - start_tick) >= timeout_ms)
-            {
+                (HAL_GetTick() - start_tick) >= timeout_ms) {
                break;  /* 超时返回 0 */
            }
        }
@@ -115,16 +94,13 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
    }

    /* 复制结果 */
-    if (readfds != NULL)
-    {
+    if (readfds != NULL) {
        readfds->fd_bits = result_read.fd_bits;
    }
-    if (writefds != NULL)
-    {
+    if (writefds != NULL) {
        writefds->fd_bits = result_write.fd_bits;
    }
-    if (exceptfds != NULL)
-    {
+    if (exceptfds != NULL) {
        exceptfds->fd_bits = result_except.fd_bits;
    }

@@ -132,95 +108,79 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
 }

 /*
- * 函数功能：I/O 多路复用（poll 模式）
- */
-int net_poll_events(net_pollfd *fds, int nfds, int timeout)
-{
+ * 函数功能：I/O 多路复用（poll 模式<EFBFBD>? */
+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 (fds == NULL || nfds <= 0) {
        return -1;
    }

    start_tick = HAL_GetTick();

-    while (1)
-    {
+    while (1) {
        /* 轮询 */
        net_poll();

        ready = 0;

-        for (i = 0; i < nfds; i++)
-        {
+        for (i = 0; i < nfds; i++) {
            fds[i].revents = 0;

-            /* 检查 fd 有效性 */
-            if (fds[i].fd < 0 || fds[i].fd >= NET_MAX_SOCKETS)
-            {
+            /* 检<EFBFBD>?fd 有效<EFBFBD>?*/
+            if (fds[i].fd < 0 || fds[i].fd >= NET_MAX_SOCKETS) {
                fds[i].revents |= NET_POLLNVAL;
                ready++;
                continue;
            }

-            net_sock_t *sock = net_get_sock(fds[i].fd);
+            net_sock_t *p_sock = net_get_sock(fds[i].fd);

-            if (sock == NULL)
-            {
+            if (p_sock == NULL) {
                fds[i].revents |= NET_POLLNVAL;
                ready++;
                continue;
            }

-            /* 检查可读 */
-            if (fds[i].events & NET_POLLIN)
-            {
-                if (check_socket_readable(fds[i].fd))
-                {
+            /* 检查可<EFBFBD>?*/
+            if (fds[i].events & NET_POLLIN) {
+                if (check_socket_readable(fds[i].fd)) {
                    fds[i].revents |= NET_POLLIN;
                    ready++;
                }
            }

-            /* 检查可写 */
-            if (fds[i].events & NET_POLLOUT)
-            {
-                if (check_socket_writable(fds[i].fd))
-                {
+            /* 检查可<EFBFBD>?*/
+            if (fds[i].events & NET_POLLOUT) {
+                if (check_socket_writable(fds[i].fd)) {
                    fds[i].revents |= NET_POLLOUT;
                    ready++;
                }
            }

-            /* 检查错误 */
-            if (check_socket_error(fds[i].fd))
-            {
+            /* 检查错<EFBFBD>?*/
+            if (check_socket_error(fds[i].fd)) {
                fds[i].revents |= NET_POLLERR;
                ready++;
            }

-            /* 检查挂起（连接断开） */
-            if (sock->state == NET_SOCK_STATE_TCP_ACCEPT ||
-                sock->state == NET_SOCK_STATE_CLOSED)
-            {
+            /* 检查挂起（连接断开<EFBFBD>?*/
+            if (p_sock->state == NET_SOCK_STATE_TCP_ACCEPT ||
+                p_sock->state == NET_SOCK_STATE_CLOSED) {
                fds[i].revents |= NET_POLLHUP;
                ready++;
            }
        }

-        if (ready > 0)
-        {
+        if (ready > 0) {
            break;
        }

-        /* 超时检查 */
-        if (timeout >= 0)
-        {
-            if ((HAL_GetTick() - start_tick) >= (uint32_t)timeout)
-            {
+        /* 超时检<EFBFBD>?*/
+        if (timeout >= 0) {
+            if ((HAL_GetTick() - start_tick) >= (uint32_t)timeout) {
                break;
            }
        }
@@ -232,36 +192,29 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout)
 }

 /*
- * 私有函数实现区
- */
+ * 私有函数实现<EFBFBD>? */

 /*
- * 函数功能：检查 Socket 是否可读
- * 返回值：1 可读，0 不可读
- */
-static int check_socket_readable(int sockfd)
-{
-    net_sock_t *sock;
+ * 函数功能：检<EFBFBD>?Socket 是否可读
+ * 返回值：1 可读<EFBFBD>? 不可<EFBFBD>? */
+static int check_socket_readable(int sockfd) {
+    net_sock_t *p_sock;
    uint16_t recv_len;

-    sock = net_get_sock(sockfd);
-    if (sock == NULL)
-    {
+    p_sock = net_get_sock(sockfd);
+    if (p_sock == NULL) {
        return 0;
    }

-    /* 监听 Socket 有新连接时可读 */
-    if (sock->state == NET_SOCK_STATE_LISTENING)
-    {
+    /* 监听 Socket 有新连接时可<EFBFBD>?*/
+    if (p_sock->state == NET_SOCK_STATE_LISTENING) {
        return 1;
    }

-    /* 已建立连接的 Socket 有数据可读 */
-    if (sock->state == NET_SOCK_STATE_ESTABLISHED)
-    {
+    /* 已建立连接的 Socket 有数据可<EFBFBD>?*/
+    if (p_sock->state == NET_SOCK_STATE_ESTABLISHED) {
        recv_len = ch395f_get_recv_len(sockfd);
-        if (recv_len > 0)
-        {
+        if (recv_len > 0) {
            return 1;
        }
    }
@@ -270,24 +223,19 @@ static int check_socket_readable(int sockfd)
 }

 /*
- * 函数功能：检查 Socket 是否可写
- * 返回值：1 可写，0 不可写
- */
-static int check_socket_writable(int sockfd)
-{
-    net_sock_t *sock;
+ * 函数功能：检<EFBFBD>?Socket 是否可写
+ * 返回值：1 可写<EFBFBD>? 不可<EFBFBD>? */
+static int check_socket_writable(int sockfd) {
+    net_sock_t *p_sock;

-    sock = net_get_sock(sockfd);
-    if (sock == NULL)
-    {
+    p_sock = net_get_sock(sockfd);
+    if (p_sock == NULL) {
        return 0;
    }

-    /* 已建立连接的 Socket 发送缓冲区空闲时可写 */
-    if (sock->state == NET_SOCK_STATE_ESTABLISHED)
-    {
-        if (sock->send_ready)
-        {
+    /* 已建立连接的 Socket 发送缓冲区空闲时可<EFBFBD>?*/
+    if (p_sock->state == NET_SOCK_STATE_ESTABLISHED) {
+        if (p_sock->send_ready) {
            return 1;
        }
    }
@@ -296,22 +244,17 @@ static int check_socket_writable(int sockfd)
 }

 /*
- * 函数功能：检查 Socket 是否有错误
- * 返回值：1 有错误，0 无错误
- */
-static int check_socket_error(int sockfd)
-{
-    net_sock_t *sock;
+ * 函数功能：检<EFBFBD>?Socket 是否有错<EFBFBD>? * 返回值：1 有错误，0 无错<E697A0>? */
+static int check_socket_error(int sockfd) {
+    net_sock_t *p_sock;

    /* 无效 fd 视为错误 */
-    if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS)
-    {
+    if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) {
        return 1;
    }

-    sock = net_get_sock(sockfd);
-    if (sock == NULL)
-    {
+    p_sock = net_get_sock(sockfd);
+    if (p_sock == NULL) {
        return 1;  /* 未使用的 Socket 视为错误 */
    }

--- a/Drivers/BSP/NET/net_socket.c
+++ b/Drivers/BSP/NET/net_socket.c
--- a/Drivers/BSP/NET/net_socket.h
+++ b/Drivers/BSP/NET/net_socket.h
@@ -52,6 +52,7 @@ int net_poll(void);
 *          protocol - 通常为 0
 * 返回值：socket 描述符 (0~7)，失败返回 -1
 * 限定条件：net_init() 已调用
+ * 函数说明：自动分配空闲 Socket 控制块
 */
 int net_socket(int domain, int type, int protocol);

@@ -61,6 +62,8 @@ int net_socket(int domain, int type, int protocol);
 *          addr     - 本地地址结构体指针
 *          addrlen  - 地址结构体长度
 * 返回值：0 成功，-1 失败
+ * 限定条件：socket 已创建且未绑定
+ * 函数说明：设置 CH395F 源端口
 */
 int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen);

@@ -70,6 +73,7 @@ int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen);
 *          backlog  - 最大等待连接数（多连接模式下为数据 Socket 数量）
 * 返回值：0 成功，-1 失败
 * 限定条件：socket 已绑定
+ * 函数说明：内部调用 ch395f_tcp_listen，多连接模式自动配置数据 Socket
 */
 int net_listen(int sockfd, int backlog);

@@ -104,7 +108,8 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen);
 *          len     - 数据长度
 *          flags   - 通常为 0
 * 返回值：实际发送字节数，失败返回 -1
- * 限定条件：TCP 连接已建立
+ * 限定条件：TCP 连接已建立，指针非空
+ * 函数说明：阻塞等待发送缓冲区空闲，拷贝数据后触发发送
 */
 int net_send(int sockfd, const void *buf, int len, int flags);

@@ -124,13 +129,15 @@ int net_recv(int sockfd, void *buf, int len, int flags);

 /*
 * 函数功能：发送 UDP 数据
- * 入口参数：sockfd   - socket 描述符
- *          buf      - 数据缓冲区
- *          len      - 数据长度
- *          flags    - 通常为 0
+ * 入口参数：sockfd    - socket 描述符
+ *          buf       - 数据缓冲区
+ *          len       - 数据长度
+ *          flags     - 通常为 0
 *          dest_addr - 目标地址
- *          addrlen  - 地址长度
+ *          addrlen   - 地址长度
 * 返回值：实际发送字节数，失败返回 -1
+ * 限定条件：socket 已创建，指针非空
+ * 函数说明：设置目标地址后调用 CH395F 发送
 */
 int net_sendto(int sockfd, const void *buf, int len, int flags,
               const struct net_sockaddr *dest_addr, int addrlen);
@@ -144,6 +151,8 @@ int net_sendto(int sockfd, const void *buf, int len, int flags,
 *          src_addr - 输出：发送方地址
 *          addrlen  - 输入输出：地址长度
 * 返回值：实际接收字节数，失败返回 -1
+ * 限定条件：socket 已创建，指针非空
+ * 函数说明：读取 CH395F 接收缓冲区，获取对端地址
 */
 int net_recvfrom(int sockfd, void *buf, int len, int flags,
                 struct net_sockaddr *src_addr, int *addrlen);
@@ -152,6 +161,8 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
 * 函数功能：关闭 socket
 * 入口参数：sockfd - socket 描述符
 * 返回值：0 成功，-1 失败
+ * 限定条件：socket 已打开
+ * 函数说明：释放 Socket 控制块，TCP 先断开连接
 */
 int net_close(int sockfd);

@@ -165,6 +176,8 @@ int net_close(int sockfd);
 *          cb     - 回调函数
 *          arg    - 用户参数
 * 返回值：0 成功，-1 失败
+ * 限定条件：socket 已创建
+ * 函数说明：回调在 net_poll 上下文中触发
 */
 int net_set_event_cb(int sockfd, net_event_cb_t cb, void *arg);

@@ -181,7 +194,9 @@ int net_get_errno(void);
 /*
 * 函数功能：将 IP 地址字符串转为网络字节序
 * 入口参数：cp - 点分十进制字符串 "192.168.1.100"
- * 返回值：网络字节序 IP
+ * 返回值：网络字节序 IP，失败返回 0
+ * 限定条件：cp 指针非空
+ * 函数说明：不支持域名解析
 */
 uint32_t net_inet_addr(const char *cp);

@@ -190,26 +205,43 @@ uint32_t net_inet_addr(const char *cp);
 * 入口参数：addr - 网络字节序 IP
 *          buf  - 输出缓冲区（至少 16 字节）
 * 返回值：buf 指针
+ * 限定条件：buf 指针非空
 */
 char *net_inet_ntoa(uint32_t addr, char *buf);

 /*
 * 函数功能：端口字节序转换（主机序 -> 网络序）
+ * 入口参数：hostshort - 主机序端口
+ * 返回值：网络序端口
+ * 限定条件：无
+ * 函数说明：小端 → 大端
 */
 uint16_t net_htons(uint16_t hostshort);

 /*
 * 函数功能：端口字节序转换（网络序 -> 主机序）
+ * 入口参数：netshort - 网络序端口
+ * 返回值：主机序端口
+ * 限定条件：无
+ * 函数说明：大端 → 小端
 */
 uint16_t net_ntohs(uint16_t netshort);

 /*
 * 函数功能：IP 地址字节序转换（主机序 -> 网络序）
+ * 入口参数：hostlong - 主机序 IP
+ * 返回值：网络序 IP
+ * 限定条件：无
+ * 函数说明：小端 → 大端
 */
 uint32_t net_htonl(uint32_t hostlong);

 /*
 * 函数功能：IP 地址字节序转换（网络序 -> 主机序）
+ * 入口参数：netlong - 网络序 IP
+ * 返回值：主机序 IP
+ * 限定条件：无
+ * 函数说明：大端 → 小端
 */
 uint32_t net_ntohl(uint32_t netlong);

--- a/Drivers/BSP/RS485/rs485.c
+++ b/Drivers/BSP/RS485/rs485.c
@@ -2,21 +2,18 @@
 * æ¨¡å<C2A1>—å<E28094><C3A5>ç§°ï¼šRS-485 å<>Šå<C5A0>Œå·¥é€šä¿¡é©±åŠ¨
 * æ¨¡å<C2A1>—åŠŸèƒ½ï¼šRS-485 å<>Šå<C5A0>Œå·¥é€šä¿¡é©±åŠ¨å®žçŽ°ï¼Œæ ¸å¿ƒè¦<C3A8>ç‚¹ï¼š
 *          1. å<>‘é€<C3A9>å‰<C3A5>æ‹‰é«˜ DEï¼ˆåˆ‡æ<E280A1>¢åˆ°å<C2B0>‘é€<C3A9>æ€<C3A6>ï¼‰
- *          2. HAL_UART_Transmit 内部已等待 TC（发送完成）标志
+ *          2. HAL_UART_Transmit å†…éƒ¨å·²ç‰ï¿?TCï¼ˆå<CB86>‘é€<C3A9>å®Œæˆ<C3A6>ï¼‰æ ‡å¿—
 *          3. å<>‘é€<C3A9>å®Œæ¯•å<E280A2>Žæ‹‰ä½Ž DEï¼ˆåˆ‡å›žæŽ¥æ”¶æ€<C3A6>ï¼‰
- *          4. 使用 HAL_UARTEx_ReceiveToIdle_IT 实现变长帧接收
- *          参考：ST AN3070 应用笔记、controllerstech.com RS485 教程
+ *          4. ä½¿ç”¨ HAL_UARTEx_ReceiveToIdle_IT å®žçŽ°å<EFBFBD>˜é•¿å¸§æŽ¥ï¿? *          å<>‚è€ƒï¼šST AN3070 åº”ç”¨ç¬”è®°ã€<C3A3>controllerstech.com RS485 æ•™ç¨‹
 * é€‚ç”¨å¹³å<C2B3>°ï¼šSTM32F4 ç³»åˆ—
- * 作者：王建锋
- * 创建日期：2026-07-18
- * 修改记录：
- *     2026-07-18  王建锋  创建初始版本
+ * ä½œè€…ï¼šçŽ‹å»ºï¿? * åˆ›å»ºæ—¥æœŸï¿?026-07-18
+ * ä¿®æ”¹è®°å½•ï¿? *     2026-07-18  çŽ‹å»ºï¿? åˆ›å»ºåˆ<C3A5>å§‹ç‰ˆæœ¬
 */

 #include "rs485.h"

 /*
- * 内部辅助宏 - 方向控制
+ * å†…éƒ¨è¾…åŠ©ï¿?- æ–¹å<C2B9>‘æŽ§åˆ¶
 */
 #define RS485_DIR_TX(h)  HAL_GPIO_WritePin((h)->dir_port, (h)->dir_pin, GPIO_PIN_SET)
 #define RS485_DIR_RX(h)  HAL_GPIO_WritePin((h)->dir_port, (h)->dir_pin, GPIO_PIN_RESET)
@@ -31,60 +28,49 @@
 *           huart    - UART å¤–è®¾å<C2BE>¥æŸ„
 *           dir_port - DE å¼•è„š GPIO ç«¯å<C2AF>£
 *           dir_pin  - DE å¼•è„š GPIO ç¼–å<E28093>·
- * 返回值：无
- * 限定条件：UART 和 GPIO 须先由 CubeMX 完成初始化
- * 函数说明：初始化后立即将 DE 拉低，使 RS-485 收发器处于接收状态
- */
-void rs485_init(rs485_handle_t *handle,
-                UART_HandleTypeDef *huart,
-                GPIO_TypeDef *dir_port,
-                uint16_t dir_pin)
-{
-    handle->huart    = huart;
-    handle->dir_port = dir_port;
-    handle->dir_pin  = dir_pin;
-    handle->rx_size  = 0;
+ * è¿”å›žå€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šUART ï¿?GPIO é¡»å…ˆï¿?CubeMX å®Œæˆ<C3A6>åˆ<C3A5>å§‹ï¿? * å‡½æ•°è¯´æ˜Žï¼šåˆ<C3A5>å§‹åŒ–å<E28093>Žç«‹å<E280B9>³å°† DE æ‹‰ä½Žï¼Œä½¿ RS-485 æ”¶å<C2B6>‘å™¨å¤„äºŽæŽ¥æ”¶çŠ¶ï¿? */
+void rs485_init(rs485_handle_t *p_handle,
+                UART_HandleTypeDef *p_huart,
+                GPIO_TypeDef *p_dir_port,
+                uint16_t dir_pin) {
+    p_handle->huart    = p_huart;
+    p_handle->dir_port = p_dir_port;
+    p_handle->dir_pin  = dir_pin;
+    p_handle->rx_size  = 0;

-    /* 默认进入接收状态 */
-    RS485_DIR_RX(handle);
+    /* é»˜è®¤è¿›å…¥æŽ¥æ”¶çŠ¶ï¿½?*/
+    RS485_DIR_RX(p_handle);
 }

 /*
- * 函数功能：阻塞方式发送数据
- * 入口参数：handle  - RS-485 句柄指针
+ * å‡½æ•°åŠŸèƒ½ï¼šé˜»å¡žæ–¹å¼<EFBFBD>å<EFBFBD>‘é€<EFBFBD>æ•°ï¿? * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šhandle  - RS-485 å<>¥æŸ„æŒ‡é’ˆ
 *           data    - å¾…å<E280A6>‘é€<C3A9>æ•°æ<C2B0>®ç¼“å†²åŒº
 *           len     - å¾…å<E280A6>‘é€<C3A9>å—èŠ‚æ•°
- *           timeout - 发送超时（ms），传 0 使用默认值
- * 返回值：HAL_OK / HAL_TIMEOUT / HAL_ERROR
- * 限定条件：须在主循环或 RTOS 任务中调用，不可在 UART 中断中调用
- * 函数说明：
- *   时序：DE=HIGH → UART 发送 N 字节 → 等 TC → DE=LOW
- *   HAL_UART_Transmit 内部会等待 TXE（发送寄存器空）逐字节搬数据，
- *   最后还会等待 TC（发送完成）标志，确保最后一字节的停止位已移出。
- *   因此返回后再拉低 DE 是安全的
+ *           timeout - å<EFBFBD>‘é€<EFBFBD>è¶…æ—¶ï¼ˆmsï¼‰ï¼Œï¿?0 ä½¿ç”¨é»˜è®¤ï¿? * è¿”å›žå€¼ï¼šHAL_OK / HAL_TIMEOUT / HAL_ERROR
+ * é™<EFBFBD>å®šæ<EFBFBD>¡ä»¶ï¼šé¡»åœ¨ä¸»å¾ªçŽ¯ï¿?RTOS ä»»åŠ¡ä¸è°ƒç”¨ï¼Œä¸<C3A4>å<EFBFBD>¯ï¿?UART ä¸æ–ä¸è°ƒï¿? * å‡½æ•°è¯´æ˜Žï¿? *   æ—¶åº<C3A5>ï¼šDE=HIGH ï¿?UART å<>‘ï¿½?N å—èŠ‚ ï¿?ï¿?TC ï¿?DE=LOW
+ *   HAL_UART_Transmit å†…éƒ¨ä¼šç‰ï¿?TXEï¼ˆå<CB86>‘é€<C3A9>å¯„å˜å™¨ç©ºï¼‰é€<C3A9>å—èŠ‚æ<E2809A>¬æ•°æ<C2B0>®ï¿? *   æœ€å<E282AC>Žè¿˜ä¼šç‰ï¿?TCï¼ˆå<CB86>‘é€<C3A9>å®Œæˆ<C3A6>ï¼‰æ ‡å¿—ï¼Œç¡®ä¿<C3A4>æœ€å<E282AC>Žä¸€å—èŠ‚çš„å<E2809E>œæ¢ä½<C3A4>å·²ç§»å‡ºï¿½? *   å› æ¤è¿”å›žå<C5BE>Žå†<C3A5>æ‹‰ä½Ž DE æ˜¯å®‰å…¨çš„
 */
-HAL_StatusTypeDef rs485_transmit(rs485_handle_t *handle,
-                                  const uint8_t *data,
+HAL_StatusTypeDef rs485_transmit(rs485_handle_t *p_handle,
+                                  const uint8_t *p_data,
                                  uint16_t len,
-                                  uint32_t timeout)
-{
-    HAL_StatusTypeDef status;
+                                  uint32_t timeout) {
+    HAL_StatusTypeDef status = HAL_OK;

    if (timeout == 0U) {
        timeout = RS485_TIMEOUT_DEFAULT;
    }

-    /* 1. 切换到发送状态 */
-    RS485_DIR_TX(handle);
+    /* 1. åˆ‡æ<EFBFBD>¢åˆ°å<EFBFBD>‘é€<EFBFBD>çŠ¶ï¿?*/
+    RS485_DIR_TX(p_handle);

-    /* 2. 阻塞发送（内部等待 TC） */
-    status = HAL_UART_Transmit(handle->huart,
-                                (uint8_t *)data,
+    /* 2. é˜»å¡žå<EFBFBD>‘é€<EFBFBD>ï¼ˆå†…éƒ¨ç‰å¾… TCï¿?*/
+    status = HAL_UART_Transmit(p_handle->huart,
+                                (uint8_t *)p_data,
                                len,
                                timeout);

-    /* 3. 发送完毕或超时，切回接收状态 */
-    RS485_DIR_RX(handle);
+    /* 3. å<EFBFBD>‘é€<EFBFBD>å®Œæ¯•æˆ–è¶…æ—¶ï¼Œåˆ‡å›žæŽ¥æ”¶çŠ¶ï¿?*/
+    RS485_DIR_RX(p_handle);

    return status;
 }
@@ -92,42 +78,27 @@ HAL_StatusTypeDef rs485_transmit(rs485_handle_t *handle,
 /*
 * å‡½æ•°åŠŸèƒ½ï¼šå<C5A1>¯åŠ¨ä¸æ–æ–¹å¼<C3A5>æŽ¥æ”¶ï¼ˆIDLE ç©ºé—²å¸§æ£€æµ‹ï¼‰
 * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šhandle    - RS-485 å<>¥æŸ„æŒ‡é’ˆ
- *           buf       - 接收缓冲区
- *           buf_size  - 缓冲区最大容量
- * 返回值：HAL_OK / HAL_ERROR
- * 限定条件：UART 须已开启全局中断（NVIC 使能）
- * 函数说明：
- *   使用 HAL_UARTEx_ReceiveToIdle_IT 实现变长帧接收。
- *   当 UART 总线空闲超过 1 个字符时间后，硬件触发 IDLE 中断，
- *   HAL 自动调用 HAL_UARTEx_RxEventCallback 并返回已接收字节数。
- *   用户须在该回调中重新调用本函数重新开启接收
- */
-HAL_StatusTypeDef rs485_receive_start(rs485_handle_t *handle,
-                                       uint8_t *buf,
-                                       uint16_t buf_size)
-{
-    handle->rx_size = 0;
-    return HAL_UARTEx_ReceiveToIdle_IT(handle->huart, buf, buf_size);
+ *           buf       - æŽ¥æ”¶ç¼“å†²ï¿? *           buf_size  - ç¼“å†²åŒºæœ€å¤§å®¹ï¿? * è¿”å›žå€¼ï¼šHAL_OK / HAL_ERROR
+ * é™<EFBFBD>å®šæ<EFBFBD>¡ä»¶ï¼šUART é¡»å·²å¼€å<E282AC>¯å…¨å±€ä¸æ–ï¼ˆNVIC ä½¿èƒ½ï¿? * å‡½æ•°è¯´æ˜Žï¿? *   ä½¿ç”¨ HAL_UARTEx_ReceiveToIdle_IT å®žçŽ°å<C2B0>˜é•¿å¸§æŽ¥æ”¶ï¿½? *   ï¿?UART æ€»çº¿ç©ºé—²è¶…è¿‡ 1 ä¸ªå—ç¬¦æ—¶é—´å<C2B4>Žï¼Œç¡¬ä»¶è§¦ï¿?IDLE ä¸æ–ï¿? *   HAL è‡ªåŠ¨è°ƒç”¨ HAL_UARTEx_RxEventCallback å¹¶è¿”å›žå·²æŽ¥æ”¶å—èŠ‚æ•°ï¿½? *   ç”¨æˆ·é¡»åœ¨è¯¥å›žè°ƒä¸é‡<C3A9>æ–°è°ƒç”¨æœ¬å‡½æ•°é‡<C3A9>æ–°å¼€å<E282AC>¯æŽ¥ï¿? */
+HAL_StatusTypeDef rs485_receive_start(rs485_handle_t *p_handle,
+                                       uint8_t *p_buf,
+                                       uint16_t buf_size) {
+    p_handle->rx_size = 0;
+    return HAL_UARTEx_ReceiveToIdle_IT(p_handle->huart, p_buf, buf_size);
 }

 /*
- * 函数功能：缓存最近一次接收的字节数
- * 入口参数：handle - RS-485 句柄指针
- *           size   - 本次接收到的字节数
- * 返回值：无
- * 限定条件：须在 HAL_UARTEx_RxEventCallback 中调用
- */
-void rs485_rx_set_size(rs485_handle_t *handle, uint16_t size)
-{
-    handle->rx_size = size;
+ * å‡½æ•°åŠŸèƒ½ï¼šç¼“å˜æœ€è¿‘ä¸€æ¬¡æŽ¥æ”¶çš„å—èŠ‚ï¿? * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šhandle - RS-485 å<>¥æŸ„æŒ‡é’ˆ
+ *           size   - æœ¬æ¬¡æŽ¥æ”¶åˆ°çš„å—èŠ‚ï¿? * è¿”å›žå€¼ï¼šï¿? * é™<C3A9>å®šæ<C5A1>¡ä»¶ï¼šé¡»ï¿?HAL_UARTEx_RxEventCallback ä¸è°ƒï¿? */
+void rs485_rx_set_size(rs485_handle_t *p_handle, uint16_t size) {
+    p_handle->rx_size = size;
 }

 /*
- * 函数功能：获取最近一次接收的字节数
- * 入口参数：handle - RS-485 句柄指针
- * 返回值：字节数
- */
-uint16_t rs485_rx_get_size(const rs485_handle_t *handle)
-{
-    return handle->rx_size;
+ * å‡½æ•°åŠŸèƒ½ï¼šèŽ·å<EFBFBD>–æœ€è¿‘ä¸€æ¬¡æŽ¥æ”¶çš„å—èŠ‚ï¿? * å…¥å<C2A5>£å<C2A3>‚æ•°ï¼šhandle - RS-485 å<>¥æŸ„æŒ‡é’ˆ
+ * è¿”å›žå€¼ï¼šå—èŠ‚ï¿? */
+uint16_t rs485_rx_get_size(const rs485_handle_t *p_handle) {
+    return p_handle->rx_size;
 }
+
+
--- a/Drivers/BSP/RS485/rs485.h
+++ b/Drivers/BSP/RS485/rs485.h
@@ -50,9 +50,9 @@ typedef struct {
 * 限定条件：UART 和 GPIO 须先由 CubeMX 完成初始化
 * 函数说明：初始化后默认处于接收状态（DE 引脚拉低）
 */
-void rs485_init(rs485_handle_t *handle,
-                UART_HandleTypeDef *huart,
-                GPIO_TypeDef *dir_port,
+void rs485_init(rs485_handle_t *p_handle,
+                UART_HandleTypeDef *p_huart,
+                GPIO_TypeDef *p_dir_port,
                uint16_t dir_pin);

 /*
@@ -66,8 +66,8 @@ void rs485_init(rs485_handle_t *handle,
 * 函数说明：发送前自动拉高 DE，发送完成后等待 TC 标志再拉低 DE，
 *          确保最后一字节完全移出后再切换到接收状态
 */
-HAL_StatusTypeDef rs485_transmit(rs485_handle_t *handle,
-                                  const uint8_t *data,
+HAL_StatusTypeDef rs485_transmit(rs485_handle_t *p_handle,
+                                  const uint8_t *p_data,
                                  uint16_t len,
                                  uint32_t timeout);

@@ -82,8 +82,8 @@ HAL_StatusTypeDef rs485_transmit(rs485_handle_t *handle,
 *          收到完整帧后在 RxEventCallback 中通知用户。
 *          用户须在回调中重新调用本函数重新开启接收
 */
-HAL_StatusTypeDef rs485_receive_start(rs485_handle_t *handle,
-                                       uint8_t *buf,
+HAL_StatusTypeDef rs485_receive_start(rs485_handle_t *p_handle,
+                                       uint8_t *p_buf,
                                       uint16_t buf_size);

 /*
@@ -93,7 +93,7 @@ HAL_StatusTypeDef rs485_receive_start(rs485_handle_t *handle,
 * 限定条件：须在 HAL_UART_RxCpltCallback / HAL_UARTEx_RxEventCallback 中调用
 * 函数说明：将 HAL 回调中接收到的数据大小回写到句柄的 rx_size 字段
 */
-void rs485_rx_set_size(rs485_handle_t *handle, uint16_t size);
+void rs485_rx_set_size(rs485_handle_t *p_handle, uint16_t size);

 /*
 * 函数功能：获取最近一次接收的字节数
@@ -101,7 +101,7 @@ void rs485_rx_set_size(rs485_handle_t *handle, uint16_t size);
 * 返回值：最近一次接收的字节数
 * 限定条件：须在 HAL_UARTEx_RxEventCallback 触发后调用
 */
-uint16_t rs485_rx_get_size(const rs485_handle_t *handle);
+uint16_t rs485_rx_get_size(const rs485_handle_t *p_handle);

 #ifdef __cplusplus
 }
--- a/Drivers/BSP/SD2506/sd2506.c
+++ b/Drivers/BSP/SD2506/sd2506.c
@@ -1,39 +1,43 @@
 /*
 * 模块名称：SD2506API-G RTC 实时时钟驱动
- * 模块功能：SD2506API-G 高精度温补实时时钟模块 I2C 驱动
+ * 模块功能：SD2506API-G 高精度温补实时时钟模<EFBFBD>?I2C 驱动
 * 适用平台：STM32F407ZGT6，I2C1 接口 (PB6-SCL, PB7-SDA)
- * 作者：王建锋
- * 创建日期：2026-07-17
- * 修改记录：
- *     2026-07-17  王建锋  创建初始版本，参考 SD2506API-G Ver2.0 手册
+ * 作者：王建<EFBFBD>? * 创建日期<E697A5>?026-07-17
+ * 修改记录<EFBFBD>? *     2026-07-17  王建<E78E8B>? 创建初始版本，参<EFBC8C>?SD2506API-G Ver2.0 手册
 */

+#include <string.h>
 #include "sd2506.h"
 #include "i2c.h"
-#include <string.h>

 extern I2C_HandleTypeDef hi2c1;

 /* ======================== 内部辅助函数 ======================== */

-uint8_t sd2506_bcd_to_dec(uint8_t bcd)
-{
+/*
+ * 函数功能：BCD 码转十进<E58D81>? * 入口参数：bcd - BCD 编码<E7BC96>? uint8_t  0x00 - 0x99
+ * <20>?<3F>?值：十进制数<E588B6>? * 限定条件：输入为合法 BCD <20>? * 函数说明：高 4 位为十位，低 4 位为个位
+ */
+uint8_t sd2506_bcd_to_dec(uint8_t bcd) {
    return ((bcd >> 4) * 10) + (bcd & 0x0FU);
 }

-uint8_t sd2506_dec_to_bcd(uint8_t dec)
-{
+/*
+ * 函数功能：十进制<E8BF9B>?BCD <20>? * 入口参数：dec - 十进制数<E588B6>? uint8_t  0 - 99
+ * <20>?<3F>?值：BCD 编码<E7BC96>? * 限定条件：输入值在 0 - 99 范围<E88C83>? * 函数说明：十位存入高 4 位，个位存入<E5AD98>?4 <20>? */
+uint8_t sd2506_dec_to_bcd(uint8_t dec) {
    return ((dec / 10) << 4) | (dec % 10);
 }

 /*
- * 写单字节寄存器
- * reg: 寄存器地址 (00H~79H)
- * val: 写入值
- * 返回: 0=成功, -2=I2C错误
+ * 函数功能：写单字节寄存器
+ * 入口参数：reg - 寄存器地址  uint8_t  00H - 79H
+ *           val - 写入<EFBFBD>?  uint8_t  0x00 - 0xFF
+ * <EFBFBD>?<3F>?值：0 - 成功<E68890>?2 - I2C 错误
+ * 限定条件：I2C 外设已初始化
+ * 函数说明：通过 I2C 向指定地址写入 1 字节
 */
-static int sd2506_write_reg(uint8_t reg, uint8_t val)
-{
+static int sd2506_write_reg(uint8_t reg, uint8_t val) {
    if (HAL_I2C_Mem_Write(&hi2c1, SD2506_I2C_ADDR_WRITE, reg,
                          I2C_MEMADD_SIZE_8BIT, &val, 1,
                          SD2506_I2C_TIMEOUT_MS) != HAL_OK) {
@@ -43,15 +47,15 @@ static int sd2506_write_reg(uint8_t reg, uint8_t val)
 }

 /*
- * 读单字节寄存器
- * reg: 寄存器地址 (00H~79H)
- * val: 读取值指针
- * 返回: 0=成功, -2=I2C错误
+ * 函数功能：读单字节寄存器
+ * 入口参数：reg - 寄存器地址  uint8_t  00H - 79H
+ *           val - 读取值指<EFBFBD>? uint8_t*
+ * <EFBFBD>?<3F>?值：0 - 成功<E68890>?2 - I2C 错误
+ * 限定条件：I2C 外设已初始化，val 为非空指<E7A9BA>? * 函数说明：通过 I2C 从指定地址读取 1 字节
 */
-static int sd2506_read_reg(uint8_t reg, uint8_t *val)
-{
+static int sd2506_read_reg(uint8_t reg, uint8_t *p_val) {
    if (HAL_I2C_Mem_Read(&hi2c1, SD2506_I2C_ADDR_READ, reg,
-                         I2C_MEMADD_SIZE_8BIT, val, 1,
+                         I2C_MEMADD_SIZE_8BIT, p_val, 1,
                         SD2506_I2C_TIMEOUT_MS) != HAL_OK) {
        return SD2506_I2C_ERROR;
    }
@@ -59,16 +63,16 @@ static int sd2506_read_reg(uint8_t reg, uint8_t *val)
 }

 /*
- * 写多字节寄存器 (从 reg 开始连续写入 len 字节)
- * reg: 起始寄存器地址
- * data: 数据缓冲区
- * len: 数据长度
- * 返回: 0=成功, -2=I2C错误
+ * 函数功能：写多字节寄存器
+ * 入口参数：reg  - 起始寄存器地址  uint8_t  00H - 79H
+ *           data - 数据缓冲区指<EFBFBD>?  uint8_t*
+ *           len  - 数据长度        uint8_t  1 - N
+ * <EFBFBD>?<3F>?值：0 - 成功<E68890>?2 - I2C 错误
+ * 限定条件：I2C 外设已初始化，data 为非空指<E7A9BA>? * 函数说明：从 reg 开始连续写<E7BBAD>?len 字节
 */
-static int sd2506_write_regs(uint8_t reg, const uint8_t *data, uint8_t len)
-{
+static int sd2506_write_regs(uint8_t reg, const uint8_t *p_data, uint8_t len) {
    if (HAL_I2C_Mem_Write(&hi2c1, SD2506_I2C_ADDR_WRITE, reg,
-                          I2C_MEMADD_SIZE_8BIT, (uint8_t *)data, len,
+                          I2C_MEMADD_SIZE_8BIT, (uint8_t *)p_data, len,
                          SD2506_I2C_TIMEOUT_MS) != HAL_OK) {
        return SD2506_I2C_ERROR;
    }
@@ -76,16 +80,16 @@ static int sd2506_write_regs(uint8_t reg, const uint8_t *data, uint8_t len)
 }

 /*
- * 读多字节寄存器 (从 reg 开始连续读取 len 字节)
- * reg: 起始寄存器地址
- * data: 数据缓冲区
- * len: 数据长度
- * 返回: 0=成功, -2=I2C错误
+ * 函数功能：读多字节寄存器
+ * 入口参数：reg  - 起始寄存器地址  uint8_t  00H - 79H
+ *           data - 数据缓冲区指<EFBFBD>?  uint8_t*
+ *           len  - 数据长度        uint8_t  1 - N
+ * <EFBFBD>?<3F>?值：0 - 成功<E68890>?2 - I2C 错误
+ * 限定条件：I2C 外设已初始化，data 为非空指<E7A9BA>? * 函数说明：从 reg 开始连续读<E7BBAD>?len 字节
 */
-static int sd2506_read_regs(uint8_t reg, uint8_t *data, uint8_t len)
-{
+static int sd2506_read_regs(uint8_t reg, uint8_t *p_data, uint8_t len) {
    if (HAL_I2C_Mem_Read(&hi2c1, SD2506_I2C_ADDR_READ, reg,
-                         I2C_MEMADD_SIZE_8BIT, data, len,
+                         I2C_MEMADD_SIZE_8BIT, p_data, len,
                         SD2506_I2C_TIMEOUT_MS) != HAL_OK) {
        return SD2506_I2C_ERROR;
    }
@@ -93,14 +97,16 @@ static int sd2506_read_regs(uint8_t reg, uint8_t *data, uint8_t len)
 }

 /*
- * 开启写保护 (允许写入 00H~71H 寄存器)
- * 顺序: 先写 WRTC1=1, 再写 WRTC2=1 + WRTC3=1
+ * 函数功能：开启写保护（允许写<EFBFBD>?00H~71H 寄存器）
+ * 入口参数：无
+ * 返回值：0 - 成功<E68890>?2 - I2C 错误
+ * 限定条件：I2C 外设已初始化
+ * 函数说明：顺序：先写 WRTC1=1, 再写 WRTC2=1 + WRTC3=1
 */
-static int sd2506_write_enable(void)
-{
-    int ret;
+static int sd2506_write_enable(void) {
+    int ret = 0;

-    /* 先置 WRTC1=1 (bit6=1), 其它位参考手册: 0x84 */
+    /* 先置 WRTC1=1 (bit6=1), 其它位参考手<EFBFBD>? 0x84 */
    ret = sd2506_write_reg(SD2506_REG_CTR1, 0x84U);
    if (ret != SD2506_OK) return ret;

@@ -112,12 +118,14 @@ static int sd2506_write_enable(void)
 }

 /*
- * 关闭写保护 (禁止写入 00H~71H 寄存器)
- * 顺序: 先写 WRTC2=0 + WRTC3=0, 再写 WRTC1=0
+ * 函数功能：关闭写保护（禁止写<EFBFBD>?00H~71H 寄存器）
+ * 入口参数：无
+ * 返回值：0 - 成功<E68890>?2 - I2C 错误
+ * 限定条件：I2C 外设已初始化
+ * 函数说明：顺序：先写 WRTC2=0 + WRTC3=0, 再写 WRTC1=0
 */
-static int sd2506_write_disable(void)
-{
-    int ret;
+static int sd2506_write_disable(void) {
+    int ret = 0;

    /* 先清 WRTC2=0, WRTC3=0: 0x00 */
    ret = sd2506_write_reg(SD2506_REG_CTR2, 0x00U);
@@ -132,28 +140,36 @@ static int sd2506_write_disable(void)

 /* ======================== 公共 API 实现 ======================== */

-int sd2506_init(void)
-{
-    int ret;
-    uint8_t id[8];
+/*
+ * 函数功能：初始化 SD2506API-G RTC
+ * 入口参数：无
+ * 返回值：0 - 成功<E68890>?2 - I2C 错误
+ * 限定条件：CubeMX 已完<E5B7B2>?I2C1 初始<E5889D>?
+ * 函数说明<E8AFB4>?. 读取芯片 ID 验证通信
+ *           2. 上电重置充电寄存<E5AF84>?18H=82H
+ *           3. 配置 24 小时制、开自动复位
+ */
+int sd2506_init(void) {
+    int ret = 0;
+    uint8_t a_id[8] = {0};

    /* 验证 I2C 通信: 尝试读取 8 字节 ID */
-    ret = sd2506_read_regs(SD2506_REG_ID_START, id, SD2506_ID_SIZE);
+    ret = sd2506_read_regs(SD2506_REG_ID_START, a_id, SD2506_ID_SIZE);
    if (ret != SD2506_OK) {
        return ret;
    }

-    /* 上电重置充电寄存器 18H = 82H (开启充电, 5K电阻)
-     * 手册强烈建议每次上电时重置此值 */
+    /* 上电重置充电寄存<EFBFBD>?18H = 82H (开启充<EFBFBD>? 5K电阻)
+     * 手册强烈建议每次上电时重置此<EFBFBD>?*/
    ret = sd2506_write_reg(SD2506_REG_CHARGE, 0x82U);
    if (ret != SD2506_OK) {
        return ret;
    }

-    /* 配置: 24小时制, 自动复位使能
-     * 0FH = 0x20 (bit5=ARST=1, 其它标志位清零)
-     * 写入时需注意: 写允许状态下 0FH 的 WRTC 位必须为1
-     * 此处直接写入 0x20 即可 (ARST=1, 无 WRTC 位) */
+    /* 配置: 24小时<EFBFBD>? 自动复位使能
+     * 0FH = 0x20 (bit5=ARST=1, 其它标志位清<EFBFBD>?
+     * 写入时需注意: 写允许状态下 0FH <EFBFBD>?WRTC 位必须为1
+     * 此处直接写入 0x20 即可 (ARST=1, <EFBFBD>?WRTC <EFBFBD>? */
    ret = sd2506_write_reg(SD2506_REG_CTR1, SD2506_CTR1_WRITE_OFF);
    if (ret != SD2506_OK) {
        return ret;
@@ -162,73 +178,91 @@ int sd2506_init(void)
    return SD2506_OK;
 }

-int sd2506_set_time(const sd2506_time_t *time)
-{
-    int ret;
-    uint8_t buf[7];
+/*
+ * 函数功能：设<EFBC9A>?RTC 时间日期
+ * 入口参数：p_time - 时间结构体指针，包含要设置的时间
+ * 返回值：0 - 成功<E68890>?2 - I2C 错误
+ * 限定条件：sd2506_init() 已调<E5B7B2>?
+ * 函数说明<E8AFB4>?. 先开写保<E58699>?
+ *           2. 一次性写<E680A7>?7 字节时间数据 (00H~06H)
+ *           3. 关闭写保<E58699>?
+ */
+int sd2506_set_time(const sd2506_time_t *p_time) {
+    int ret = 0;
+    uint8_t buf[7] = {0};

-    if (time == NULL) {
+    if (p_time == NULL) {
        return SD2506_ERROR;
    }

-    /* 组装 7 字节时间数据 (BCD 码) */
-    buf[0] = sd2506_dec_to_bcd(time->second);          /* 00H: 秒 */
-    buf[1] = sd2506_dec_to_bcd(time->minute);          /* 01H: 分 */
-    buf[2] = sd2506_dec_to_bcd(time->hour) | 0x80U;    /* 02H: 时 (bit7=1, 24小时制) */
-    buf[3] = sd2506_dec_to_bcd(time->week);            /* 03H: 星期 */
-    buf[4] = sd2506_dec_to_bcd(time->day);             /* 04H: 日 */
-    buf[5] = sd2506_dec_to_bcd(time->month);           /* 05H: 月 */
-    buf[6] = sd2506_dec_to_bcd(time->year - 2000U);    /* 06H: 年 */
+    /* 组装 7 字节时间数据 (BCD <EFBFBD>? */
+    buf[0] = sd2506_dec_to_bcd(p_time->second);          /* 00H: <EFBFBD>?*/
+    buf[1] = sd2506_dec_to_bcd(p_time->minute);          /* 01H: <EFBFBD>?*/
+    buf[2] = sd2506_dec_to_bcd(p_time->hour) | 0x80U;    /* 02H: <EFBFBD>?(bit7=1, 24小时<EFBFBD>? */
+    buf[3] = sd2506_dec_to_bcd(p_time->week);            /* 03H: 星期 */
+    buf[4] = sd2506_dec_to_bcd(p_time->day);             /* 04H: <EFBFBD>?*/
+    buf[5] = sd2506_dec_to_bcd(p_time->month);           /* 05H: <EFBFBD>?*/
+    buf[6] = sd2506_dec_to_bcd(p_time->year - 2000U);    /* 06H: <EFBFBD>?*/

    /* 开启写保护 */
    ret = sd2506_write_enable();
    if (ret != SD2506_OK) return ret;

-    /* 一次性写入 7 字节时间数据 (00H~06H)
-     * 手册要求: 不可单独写某一个时间寄存器，否则可能引起错误进位 */
+    /* 一次性写<EFBFBD>?7 字节时间数据 (00H~06H)
+     * 手册要求: 不可单独写某一个时间寄存器，否则可能引起错误进<EFBFBD>?*/
    ret = sd2506_write_regs(SD2506_REG_SEC, buf, 7);
    if (ret != SD2506_OK) return ret;

-    /* 关闭写保护 */
+    /* 关闭写保<EFBFBD>?*/
    ret = sd2506_write_disable();
    if (ret != SD2506_OK) return ret;

    return SD2506_OK;
 }

-int sd2506_get_time(sd2506_time_t *time)
-{
-    int ret;
-    uint8_t buf[7];
+/*
+ *  function: read RTC time
+ *  param: p_time - output time struct
+ *  return: 0=OK, -2=I2C error
+ *  note: sd2506_init() must be called first
+ */
+int sd2506_get_time(sd2506_time_t *p_time) {
+    int ret = 0;
+    uint8_t buf[7] = {0};

-    if (time == NULL) {
+    if (p_time == NULL) {
        return SD2506_ERROR;
    }

-    /* 一次读取 7 字节时间数据 (00H~06H)
-     * 手册说明: 读取时所有实时数据被锁存，避免错读 */
+    /* 一次读<EFBFBD>?7 字节时间数据 (00H~06H)
+     * 手册说明: 读取时所有实时数据被锁存，避免错<EFBFBD>?*/
    ret = sd2506_read_regs(SD2506_REG_SEC, buf, 7);
    if (ret != SD2506_OK) {
        return ret;
    }

-    time->second = sd2506_bcd_to_dec(buf[0] & 0x7FU);     /* 00H: 秒 */
-    time->minute = sd2506_bcd_to_dec(buf[1] & 0x7FU);     /* 01H: 分 */
-    time->hour   = sd2506_bcd_to_dec(buf[2] & 0x7FU);     /* 02H: 屏蔽 bit7 (12/24标志) */
-    time->week   = sd2506_bcd_to_dec(buf[3] & 0x07U);     /* 03H: 星期 */
-    time->day    = sd2506_bcd_to_dec(buf[4] & 0x3FU);     /* 04H: 日 */
-    time->month  = sd2506_bcd_to_dec(buf[5] & 0x1FU);     /* 05H: 月 */
-    time->year   = sd2506_bcd_to_dec(buf[6]) + 2000U;     /* 06H: 年 */
+    p_time->second = sd2506_bcd_to_dec(buf[0] & 0x7FU);     /* 00H: <EFBFBD>?*/
+    p_time->minute = sd2506_bcd_to_dec(buf[1] & 0x7FU);     /* 01H: <EFBFBD>?*/
+    p_time->hour   = sd2506_bcd_to_dec(buf[2] & 0x7FU);     /* 02H: 屏蔽 bit7 (12/24标志) */
+    p_time->week   = sd2506_bcd_to_dec(buf[3] & 0x07U);     /* 03H: 星期 */
+    p_time->day    = sd2506_bcd_to_dec(buf[4] & 0x3FU);     /* 04H: <EFBFBD>?*/
+    p_time->month  = sd2506_bcd_to_dec(buf[5] & 0x1FU);     /* 05H: <EFBFBD>?*/
+    p_time->year   = sd2506_bcd_to_dec(buf[6]) + 2000U;     /* 06H: <EFBFBD>?*/

    return SD2506_OK;
 }

-int sd2506_get_temperature(int8_t *temp)
-{
-    int ret;
-    uint8_t val;
+/*
+ *  function: read internal temperature
+ *  param: p_temp - output temperature
+ *  return: 0=OK, -2=I2C error
+ *  note: reads register 0x16
+ */
+int sd2506_get_temperature(int8_t *p_temp) {
+    int ret = 0;
+    uint8_t val = 0;

-    if (temp == NULL) {
+    if (p_temp == NULL) {
        return SD2506_ERROR;
    }

@@ -237,54 +271,72 @@ int sd2506_get_temperature(int8_t *temp)
        return ret;
    }

-    /* bit7 为符号位, 其余为温度值 */
+    /* bit7 为符号位, 其余为温度<EFBFBD>?*/
    if (val & 0x80U) {
-        /* 负温度: 取补码 */
-        *temp = (int8_t)(val | 0xF0U);
+        /* 负温<EFBFBD>? 取补<EFBFBD>?*/
+        *p_temp = (int8_t)(val | 0xF0U);
    } else {
-        /* 正温度 */
-        *temp = (int8_t)(val & 0x7FU);
+        /* 正温<EFBFBD>?*/
+        *p_temp = (int8_t)(val & 0x7FU);
    }

    return SD2506_OK;
 }

-int sd2506_get_battery_voltage(uint16_t *voltage)
-{
-    int ret;
-    uint8_t val_high, val_low;
+/*
+ *  function: read battery voltage (mV)
+ *  param: p_voltage - output voltage
+ *  return: 0=OK, -2=I2C error
+ *  note: combines 9-bit value
+ */
+int sd2506_get_battery_voltage(uint16_t *p_voltage) {
+    int ret = 0;
+    uint8_t val_high = 0;
+    uint8_t val_low = 0;

-    if (voltage == NULL) {
+    if (p_voltage == NULL) {
        return SD2506_ERROR;
    }

-    /* 读取 1AH bit7 (BAT8_VAL) 和 1BH (BAT_VL) */
+    /* 读取 1AH bit7 (BAT8_VAL) <EFBFBD>?1BH (BAT_VL) */
    ret = sd2506_read_reg(SD2506_REG_CTR5, &val_high);
    if (ret != SD2506_OK) return ret;

    ret = sd2506_read_reg(SD2506_REG_BAT_VAL, &val_low);
    if (ret != SD2506_OK) return ret;

-    /* 组合 9 位: bit8=BAT8_VAL(1AH bit7), bit7~0=BAT_VL(1BH)
-     * 如 1AH=80H, 1BH=30H => 电压 = 0x130 = 304 => 3.04V => 3040mV */
+    /* 组合 9 <EFBFBD>? bit8=BAT8_VAL(1AH bit7), bit7~0=BAT_VL(1BH)
+     * <EFBFBD>?1AH=80H, 1BH=30H => 电压 = 0x130 = 304 => 3.04V => 3040mV */
    uint16_t raw = ((val_high & 0x80U) << 1) | val_low;
-    *voltage = raw * 10;  /* 转换为毫伏 (raw 单位 0.01V) */
+    *p_voltage = raw * 10;  /* 转换为毫<EFBFBD>?(raw 单位 0.01V) */

    return SD2506_OK;
 }

-int sd2506_get_id(uint8_t id[8])
-{
-    if (id == NULL) {
+/*
+ *  function: read 8-byte chip ID
+ *  param: p_id - 8-byte output buffer
+ *  return: 0=OK, -2=I2C error
+ *  note: reads registers 0x72-0x79
+ */
+int sd2506_get_id(uint8_t p_id[8]) {
+    if (p_id == NULL) {
        return SD2506_ERROR;
    }

-    return sd2506_read_regs(SD2506_REG_ID_START, id, SD2506_ID_SIZE);
+    return sd2506_read_regs(SD2506_REG_ID_START, p_id, SD2506_ID_SIZE);
 }

-int sd2506_read_sram(uint8_t addr, uint8_t *buf, uint8_t len)
-{
-    if (buf == NULL || len == 0 || addr >= SD2506_SRAM_SIZE) {
+/*
+ *  function: read SRAM data
+ *  param: addr - start address (0-69)
+ *         p_buf - output buffer
+ *         len - read length
+ *  return: 0=OK, -1=param err, -2=I2C err
+ *  note: SRAM range 0x2C-0x71
+ */
+int sd2506_read_sram(uint8_t addr, uint8_t *p_buf, uint8_t len) {
+    if (p_buf == NULL || len == 0 || addr >= SD2506_SRAM_SIZE) {
        return SD2506_ERROR;
    }

@@ -292,12 +344,18 @@ int sd2506_read_sram(uint8_t addr, uint8_t *buf, uint8_t len)
        return SD2506_ERROR;
    }

-    return sd2506_read_regs(SD2506_REG_SRAM_START + addr, buf, len);
+    return sd2506_read_regs(SD2506_REG_SRAM_START + addr, p_buf, len);
 }

-int sd2506_write_sram(uint8_t addr, const uint8_t *buf, uint8_t len)
-{
-    if (buf == NULL || len == 0 || addr >= SD2506_SRAM_SIZE) {
+/*
+ *  function: write SRAM data
+ *  param: addr - start address (0-69)
+ *         p_buf - input data
+ *         len - write length
+ *  return: 0=OK, -1=param err, -2=I2C err
+ */
+int sd2506_write_sram(uint8_t addr, const uint8_t *p_buf, uint8_t len) {
+    if (p_buf == NULL || len == 0 || addr >= SD2506_SRAM_SIZE) {
        return SD2506_ERROR;
    }

@@ -305,64 +363,74 @@ int sd2506_write_sram(uint8_t addr, const uint8_t *buf, uint8_t len)
        return SD2506_ERROR;
    }

-    /* SRAM 无需开写保护即可写入 (写保护仅对 00H~71H 有效, SRAM 是 2CH~71H)
-     * 但为安全起见, SRAM 写入也走写保护流程 */
-    int ret;
+    /* SRAM 无需开写保护即可写<EFBFBD>?(写保护仅<EFBFBD>?00H~71H 有效, SRAM <EFBFBD>?2CH~71H)
+     * 但为安全起见, SRAM 写入也走写保护流<EFBFBD>?*/
+    int ret = 0;
    ret = sd2506_write_enable();
    if (ret != SD2506_OK) return ret;

-    ret = sd2506_write_regs(SD2506_REG_SRAM_START + addr, buf, len);
+    ret = sd2506_write_regs(SD2506_REG_SRAM_START + addr, p_buf, len);
    if (ret != SD2506_OK) return ret;

    ret = sd2506_write_disable();
    return ret;
 }

-int sd2506_set_alarm(const sd2506_time_t *time, uint8_t mask)
-{
-    int ret;
-    uint8_t buf[8];
+/*
+ *  function: set alarm interrupt
+ *  param: p_time - alarm time struct
+ *         mask - alarm match mask
+ *  return: 0=OK, -2=I2C error
+ */
+int sd2506_set_alarm(const sd2506_time_t *p_time, uint8_t mask) {
+    int ret = 0;
+    uint8_t buf[8] = {0};

-    if (time == NULL) {
+    if (p_time == NULL) {
        return SD2506_ERROR;
    }

    /* 组装 8 字节报警数据 (07H~0EH) */
-    buf[0] = sd2506_dec_to_bcd(time->second) & 0x7FU;     /* 07H: 秒报警 */
-    buf[1] = sd2506_dec_to_bcd(time->minute) & 0x7FU;     /* 08H: 分报警 */
-    buf[2] = sd2506_dec_to_bcd(time->hour) & 0x3FU;       /* 09H: 时报警 (最高位始终为0) */
+    buf[0] = sd2506_dec_to_bcd(p_time->second) & 0x7FU;     /* 07H: 秒报<EFBFBD>?*/
+    buf[1] = sd2506_dec_to_bcd(p_time->minute) & 0x7FU;     /* 08H: 分报<EFBFBD>?*/
+    buf[2] = sd2506_dec_to_bcd(p_time->hour) & 0x3FU;       /* 09H: 时报<EFBFBD>?(最高位始终<EFBFBD>?) */
    buf[3] = 0x00U;                                         /* 0AH: 星期报警 */
-    buf[4] = sd2506_dec_to_bcd(time->day) & 0x3FU;        /* 0BH: 日报警 */
-    buf[5] = sd2506_dec_to_bcd(time->month) & 0x1FU;      /* 0CH: 月报警 */
-    buf[6] = sd2506_dec_to_bcd(time->year - 2000U);       /* 0DH: 年报警 */
+    buf[4] = sd2506_dec_to_bcd(p_time->day) & 0x3FU;        /* 0BH: 日报<EFBFBD>?*/
+    buf[5] = sd2506_dec_to_bcd(p_time->month) & 0x1FU;      /* 0CH: 月报<EFBFBD>?*/
+    buf[6] = sd2506_dec_to_bcd(p_time->year - 2000U);       /* 0DH: 年报<EFBFBD>?*/
    buf[7] = mask;                                          /* 0EH: 报警允许 */

    /* 开启写保护 */
    ret = sd2506_write_enable();
    if (ret != SD2506_OK) return ret;

-    /* 写入报警寄存器 (07H~0EH) */
+    /* 写入报警寄存<EFBFBD>?(07H~0EH) */
    ret = sd2506_write_regs(SD2506_REG_AL_SEC, buf, 8);
    if (ret != SD2506_OK) return ret;

-    /* 使能报警中断: CTR2 的 INTAE=1, INTS1=0, INTS0=1, IM=1 (周期性) */
+    /* 使能报警中断: CTR2 <EFBFBD>?INTAE=1, INTS1=0, INTS0=1, IM=1 (周期<EFBFBD>? */
    ret = sd2506_write_reg(SD2506_REG_CTR2,
                           SD2506_CTR2_INTAE | SD2506_CTR2_INTS0 | SD2506_CTR2_IM);
    if (ret != SD2506_OK) return ret;

-    /* 关闭写保护 */
+    /* 关闭写保<EFBFBD>?*/
    ret = sd2506_write_disable();
    if (ret != SD2506_OK) return ret;

    return SD2506_OK;
 }

-int sd2506_clear_alarm(void)
-{
-    int ret;
-    uint8_t val;
+/*
+ *  function: clear alarm interrupt flag
+ *  param: none
+ *  return: 0=OK, -2=I2C error
+ *  note: reading CTR1 clears INTAF
+ */
+int sd2506_clear_alarm(void) {
+    int ret = 0;
+    uint8_t val = 0;

-    /* 读取 CTR1, ARST=1 时自动清除 INTAF */
+    /* 读取 CTR1, ARST=1 时自动清<EFBFBD>?INTAF */
    ret = sd2506_read_reg(SD2506_REG_CTR1, &val);
    if (ret != SD2506_OK) {
        return ret;
@@ -371,11 +439,16 @@ int sd2506_clear_alarm(void)
    return SD2506_OK;
 }

-int sd2506_read_ctr1(uint8_t *val)
-{
-    if (val == NULL) {
+/*
+ *  function: read control register 1
+ *  param: p_val - output value
+ *  return: 0=OK, -2=I2C error
+ */
+int sd2506_read_ctr1(uint8_t *p_val) {
+    if (p_val == NULL) {
        return SD2506_ERROR;
    }

-    return sd2506_read_reg(SD2506_REG_CTR1, val);
+    return sd2506_read_reg(SD2506_REG_CTR1, p_val);
 }
+
--- a/Drivers/BSP/SD2506/sd2506.h
+++ b/Drivers/BSP/SD2506/sd2506.h
@@ -180,7 +180,7 @@ int sd2506_init(void);
 *           3. 关闭写保护
 *           注意：不可单独写某一个时间寄存器
 */
-int sd2506_set_time(const sd2506_time_t *time);
+int sd2506_set_time(const sd2506_time_t *p_time);

 /*
 * 函数功能：读取 RTC 时间日期
@@ -191,7 +191,7 @@ int sd2506_set_time(const sd2506_time_t *time);
 *           2. BCD 转十进制
 *           3. 屏蔽小时 bit7 (12/24标志位)
 */
-int sd2506_get_time(sd2506_time_t *time);
+int sd2506_get_time(sd2506_time_t *p_time);

 /*
 * 函数功能：读取芯片内部温度
@@ -200,7 +200,7 @@ int sd2506_get_time(sd2506_time_t *time);
 * 限定条件：sd2506_init() 已调用
 * 函数说明：读取 16H 寄存器，bit7 为符号位，范围 -40~+85
 */
-int sd2506_get_temperature(int8_t *temp);
+int sd2506_get_temperature(int8_t *p_temp);

 /*
 * 函数功能：读取电池电压 (毫伏)
@@ -210,7 +210,7 @@ int sd2506_get_temperature(int8_t *temp);
 * 函数说明：1. 读取 1AH bit7 (BAT8_VAL) 和 1BH (BAT_VL)
 *           2. 组合 9 位数据得到电压值 (如 0x135 = 309 = 3.09V)
 */
-int sd2506_get_battery_voltage(uint16_t *voltage);
+int sd2506_get_battery_voltage(uint16_t *p_voltage);

 /*
 * 函数功能：读取芯片 8 字节 ID
@@ -219,7 +219,7 @@ int sd2506_get_battery_voltage(uint16_t *voltage);
 * 限定条件：sd2506_init() 已调用
 * 函数说明：读取 72H~79H 共 8 字节唯一 ID
 */
-int sd2506_get_id(uint8_t id[8]);
+int sd2506_get_id(uint8_t p_id[8]);

 /*
 * 函数功能：读取用户 SRAM 数据
@@ -230,7 +230,7 @@ int sd2506_get_id(uint8_t id[8]);
 * 限定条件：sd2506_init() 已调用
 * 函数说明：SRAM 地址范围 0~69，对应寄存器 2CH~71H
 */
-int sd2506_read_sram(uint8_t addr, uint8_t *buf, uint8_t len);
+int sd2506_read_sram(uint8_t addr, uint8_t *p_buf, uint8_t len);

 /*
 * 函数功能：写入用户 SRAM 数据
@@ -242,7 +242,7 @@ int sd2506_read_sram(uint8_t addr, uint8_t *buf, uint8_t len);
 * 函数说明：SRAM 地址范围 0~69，对应寄存器 2CH~71H
 *           SRAM 无需开写保护即可写入
 */
-int sd2506_write_sram(uint8_t addr, const uint8_t *buf, uint8_t len);
+int sd2506_write_sram(uint8_t addr, const uint8_t *p_buf, uint8_t len);

 /*
 * 函数功能：设置报警中断
@@ -255,7 +255,7 @@ int sd2506_write_sram(uint8_t addr, const uint8_t *buf, uint8_t len);
 *           3. 使能报警中断 INTAE
 *           4. 关写保护
 */
-int sd2506_set_alarm(const sd2506_time_t *time, uint8_t mask);
+int sd2506_set_alarm(const sd2506_time_t *p_time, uint8_t mask);

 /*
 * 函数功能：清除报警中断标志
@@ -271,7 +271,7 @@ int sd2506_clear_alarm(void);
 * 入口参数：val - 输出值指针
 * 返回值：0 - 成功，-2 - I2C 通信错误
 */
-int sd2506_read_ctr1(uint8_t *val);
+int sd2506_read_ctr1(uint8_t *p_val);

 /*
 * 函数功能：BCD 码转十进制
--- a/Drivers/BSP/TPAFE5160/tpafe5160.c
+++ b/Drivers/BSP/TPAFE5160/tpafe5160.c
@@ -1,12 +1,9 @@
 /*
- * 模块名称：TPAFE5160 16位8通道同步采样ADC驱动
- * 模块功能：提供 TPAFE5160 并行接口模式下的初始化、过采样设置、转换启动、数据读取接口
- * 适用平台：STM32F407ZGT6，并行16位数据总线接 GPIOG[15:0]
- * 作者：王建锋
- * 创建日期：2026-07-17
- * 修改记录：
- *     2026-07-17  王建锋  创建初始版本，参考 AD7606 并行驱动及 TPAFE5160 手册
- *     2026-07-17  王建锋  增加 EXTI 中断读取模式
+ * 模块名称：TPAFE5160 16<EFBFBD>?通道同步采样ADC驱动
+ * 模块功能：提<EFBFBD>?TPAFE5160 并行接口模式下的初始化、过采样设置、转换启动、数据读取接<EFBFBD>? * 适用平台：STM32F407ZGT6，并<EFBC8C>?6位数据总线<E680BB>?GPIOG[15:0]
+ * 作者：王建<EFBFBD>? * 创建日期<E697A5>?026-07-17
+ * 修改记录<EFBFBD>? *     2026-07-17  王建<E78E8B>? 创建初始版本，参<EFBC8C>?AD7606 并行驱动<E9A9B1>?TPAFE5160 手册
+ *     2026-07-17  王建<E78E8B>? 增加 EXTI 中断读取模式
 */

 /* 头文件包含区 */
@@ -19,35 +16,31 @@
 #define DBG_TAG "[ADC]"
 #include "dbg_log.h"

-/* ======================== 私有宏定义 ======================== */
+/* ======================== 私有宏定<EFBFBD>?======================== */

 /*
- * 并行读取时序延时 (168MHz 主频，1 NOP ≈ 5.95ns)
+ * 并行读取时序延时 (168MHz 主频<EFBFBD>? NOP <EFBFBD>?5.95ns)
 *
- * TPAFE5160 并行时序要求 (VDRIVE > 2.7V)：
- *   t10 (RD 低脉宽)   ≥ 22ns
- *   t11 (RD 高脉宽)   ≥ 10ns
- *   t14 (数据访问时间) ≤ 21ns (从 RD 下降沿算起)
- *   t15 (数据保持时间) ≥ 6ns  (从 RD 下降沿算起)
+ * TPAFE5160 并行时序要求 (VDRIVE > 2.7V)<EFBFBD>? *   t10 (RD 低脉<E4BD8E>?   <20>?22ns
+ *   t11 (RD 高脉<EFBFBD>?   <20>?10ns
+ *   t14 (数据访问时间) <20>?21ns (<28>?RD 下降沿算<E6B2BF>?
+ *   t15 (数据保持时间) <EFBFBD>?6ns  (<EFBFBD>?RD 下降沿算<EFBFBD>?
 *
- * GPIO 写操作本身约 1 个 AHB 周期 (~6ns)，
- * 加上端口延迟 (~12-18ns)，实际 RD 引脚翻转滞后约 18-24ns。
- * 因此 NOP 延时只需覆盖数据建立时间即可。
- */
-#define TP_NOP_5()      __NOP(); __NOP(); __NOP(); __NOP(); __NOP()
+ * GPIO 写操作本身约 1 <EFBFBD>?AHB 周期 (~6ns)<EFBFBD>? * 加上端口延迟 (~12-18ns)，实<EFBC8C>?RD 引脚翻转滞后<E6BB9E>?18-24ns<6E>? * 因此 NOP 延时只需覆盖数据建立时间即可<E58DB3>? */
+#define TPAFE5160_NOP_5()      __NOP(); __NOP(); __NOP(); __NOP(); __NOP()

-/* RD 低脉宽延时：GPIO写(~6ns) + 5NOP(~30ns) > 22ns */
-#define TP_RD_LOW_DLY() do { TPAFE5160_RD_LOW();  TP_NOP_5(); } while (0)
+/* RD 低脉宽延时：GPIO<EFBFBD>?~6ns) + 5NOP(~30ns) > 22ns */
+#define TPAFE5160_RD_LOW_DLY() do { TPAFE5160_RD_LOW();  TPAFE5160_NOP_5(); } while (0)

-/* RD 高脉宽延时：GPIO写(~6ns) + 3NOP(~18ns) > 10ns */
-#define TP_RD_HIGH_DLY() do { TPAFE5160_RD_HIGH(); __NOP(); __NOP(); __NOP(); } while (0)
+/* RD 高脉宽延时：GPIO<EFBFBD>?~6ns) + 3NOP(~18ns) > 10ns */
+#define TPAFE5160_RD_HIGH_DLY() do { TPAFE5160_RD_HIGH(); __NOP(); __NOP(); __NOP(); } while (0)

-/* CONVST 脉冲延时：上升沿前需保证低电平，5NOP 覆盖 t5 ≥ 20ns */
-#define TP_CONVST_PULSE() do { \
+/* CONVST 脉冲延时：上升沿前需保证低电平，5NOP 覆盖 t5 <EFBFBD>?20ns */
+#define TPAFE5160_CONVST_PULSE() do { \
    TPAFE5160_CONVST_LOW(); \
-    TP_NOP_5(); \
+    TPAFE5160_NOP_5(); \
    TPAFE5160_CONVST_HIGH(); \
-    TP_NOP_5(); \
+    TPAFE5160_NOP_5(); \
 } while (0)

 /* ======================== 私有函数声明 ======================== */
@@ -59,22 +52,20 @@ static void tpafe5160_read_channels(uint8_t count, int16_t *buf);
 /*
 * 函数功能：初始化 TPAFE5160（设置过采样、等待就绪）
 * 入口参数：无
- * 返回值：0 - 成功，-2 - BUSY 超时
- * 限定条件：CubeMX 已完成 GPIO 初始化
- * 函数说明：1. 设置过采样为无过采样 (000)
+ * 返回值：0 - 成功<EFBFBD>?2 - BUSY 超时
+ * 限定条件：CubeMX 已完<EFBFBD>?GPIO 初始<EFBFBD>? * 函数说明<E8AFB4>?. 设置过采样为无过采样 (000)
 *           2. 确保 RD 为高、CONVST 为低
 *           3. 等待 BUSY 释放（转换空闲）
 */
-int tpafe5160_init(void)
-{
+int tpafe5160_init(void) {
    /* 设置默认过采样：无过采样 (OS[2:0] = 000) */
-    tpafe5160_set_os(TP_OS_NONE);
+    tpafe5160_set_os(TPAFE5160_OS_NONE);

-    /* 确保控制引脚处于空闲状态 */
+    /* 确保控制引脚处于空闲状<EFBFBD>?*/
    TPAFE5160_RD_HIGH();
    TPAFE5160_CONVST_LOW();

-    /* 等待 BUSY 释放，确保上电后无残留转换 */
+    /* 等待 BUSY 释放，确保上电后无残留转<EFBFBD>?*/
    int ret = tpafe5160_wait_busy(TPAFE5160_CONV_TIMEOUT_MS);
    if (ret != TPAFE5160_OK) {
        DBG_ERROR("Init wait BUSY timeout");
@@ -85,14 +76,10 @@ int tpafe5160_init(void)
 }

 /*
- * 函数功能：设置过采样率
- * 入口参数：os - 过采样率枚举值  tpafe5160_os_t
- * 返回值：无
- * 限定条件：GPIO 已初始化
- * 函数说明：通过 OS[2:0] 引脚设置过采样率，在下一次 BUSY 下降沿锁存生效
- */
-void tpafe5160_set_os(tpafe5160_os_t os)
-{
+ * 函数功能：设置过采样<EFBFBD>? * 入口参数：os - 过采样率枚举<E69E9A>? tpafe5160_os_t
+ * 返回值：<EFBFBD>? * 限定条件：GPIO 已初始化
+ * 函数说明：通过 OS[2:0] 引脚设置过采样率，在下一<E4B88B>?BUSY 下降沿锁存生<E5AD98>? */
+void tpafe5160_set_os(tpafe5160_os_t os) {
    TPAFE5160_OS0(os & 0x01);       /* OS0 = bit0 */
    TPAFE5160_OS1((os >> 1) & 0x01); /* OS1 = bit1 */
    TPAFE5160_OS2((os >> 2) & 0x01); /* OS2 = bit2 */
@@ -101,27 +88,22 @@ void tpafe5160_set_os(tpafe5160_os_t os)
 /*
 * 函数功能：启动一次转换（CONVST 上升沿触发）
 * 入口参数：无
- * 返回值：无
- * 限定条件：GPIO 已初始化
- * 函数说明：产生 CONVST 脉冲上升沿，启动全部8通道同步采样与转换
- */
-void tpafe5160_start_conv(void)
-{
-    TP_CONVST_PULSE();
+ * 返回值：<EFBFBD>? * 限定条件：GPIO 已初始化
+ * 函数说明：产<EFBFBD>?CONVST 脉冲上升沿，启动全部8通道同步采样与转<E4B88E>? */
+void tpafe5160_start_conv(void) {
+    TPAFE5160_CONVST_PULSE();
 }

 /*
- * 函数功能：等待转换完成
- * 入口参数：timeout_ms - 超时时间  uint32_t  > 0
- * 返回值：0 - 转换完成，-2 - 超时
+
+ * 函数功能：等待转换完<E68DA2>? * 入口参数：timeout_ms - 超时时间  uint32_t  > 0
+ * 返回值：0 - 转换完成<EFBFBD>?2 - 超时
 * 限定条件：已调用 tpafe5160_start_conv()
- * 函数说明：轮询 BUSY 引脚等待下降沿
- */
-int tpafe5160_wait_busy(uint32_t timeout_ms)
-{
+ * 函数说明：轮<EFBFBD>?BUSY 引脚等待下降<EFBFBD>? */
+int tpafe5160_wait_busy(uint32_t timeout_ms) {
    uint32_t tick_start = HAL_GetTick();

-    /* 等待 BUSY 释放（低电平表示空闲） */
+    /* 等待 BUSY 释放（低电平表示空闲<EFBFBD>?*/
    while (TPAFE5160_BUSY_READ() == GPIO_PIN_SET) {
        if ((HAL_GetTick() - tick_start) >= timeout_ms) {
            return TPAFE5160_BUSY_TIMEOUT;
@@ -132,29 +114,26 @@ int tpafe5160_wait_busy(uint32_t timeout_ms)
 }

 /*
- * 函数功能：查询当前是否正在转换
- * 入口参数：无
- * 返回值：1 - 正在转换，0 - 空闲
+ * 函数功能：查询当前是否正在转<EFBFBD>? * 入口参数：无
+ * 返回值：1 - 正在转换<E8BDAC>? - 空闲
 * 限定条件：GPIO 已初始化
- * 函数说明：读取 BUSY 引脚电平
+ * 函数说明：读<EFBFBD>?BUSY 引脚电平
 */
-uint8_t tpafe5160_is_busy(void)
-{
+uint8_t tpafe5160_is_busy(void) {
    return (TPAFE5160_BUSY_READ() == GPIO_PIN_SET) ? 1 : 0;
 }

 /*
- * 函数功能：读取全部8通道转换结果
+ * 函数功能：读取全<EFBFBD>?通道转换结果
 * 入口参数：buf - 8个int16_t的输出缓冲区  int16_t*  不为 NULL
- * 返回值：0 - 成功，-2 - BUSY 超时
+ * 返回值：0 - 成功<EFBFBD>?2 - BUSY 超时
 * 限定条件：GPIO 已初始化
- * 函数说明：1. 启动转换并等待 BUSY 释放
+ * 函数说明<EFBFBD>?. 启动转换并等<EFBFBD>?BUSY 释放
 *           2. 连续8次拉低RD读取各通道数据
 *           3. 通过 FRSTDATA 验证第一通道
 */
-int tpafe5160_read_all(int16_t *buf)
-{
-    int ret;
+int tpafe5160_read_all(int16_t *buf) {
+    int ret = 0;

    /* 启动转换 */
    tpafe5160_start_conv();
@@ -173,17 +152,15 @@ int tpafe5160_read_all(int16_t *buf)
 }

 /*
- * 函数功能：读取指定通道的转换结果
- * 入口参数：channel - 通道号  uint8_t  0 - 7
+ * 函数功能：读取指定通道的转换结<EFBFBD>? * 入口参数：channel - 通道<E9809A>? uint8_t  0 - 7
 *           value   - 输出指针 int16_t*  不为 NULL
- * 返回值：0 - 成功，-1 - 通道号无效，-2 - BUSY 超时
+ * 返回值：0 - 成功<EFBFBD>?1 - 通道号无效，-2 - BUSY 超时
 * 限定条件：GPIO 已初始化
 * 函数说明：启动转换并等待完成后，连续读取至指定通道
 */
-int tpafe5160_read_channel(uint8_t channel, int16_t *value)
-{
-    int ret;
-    int16_t buf[TPAFE5160_CH_NUM];
+int tpafe5160_read_channel(uint8_t channel, int16_t *value) {
+    int ret = 0;
+    int16_t buf[TPAFE5160_CH_NUM] = {0};

    if (channel >= TPAFE5160_CH_NUM || value == NULL) {
        return TPAFE5160_ERROR;
@@ -199,29 +176,23 @@ int tpafe5160_read_channel(uint8_t channel, int16_t *value)
 }

 /*
- * 函数功能：原始ADC值转电压值
- * 入口参数：raw - ADC原始值  int16_t  有符号补码
- * 返回值：电压值  float  单位 V
+ * 函数功能：原始ADC值转电压<EFBFBD>? * 入口参数：raw - ADC原始<E58E9F>? int16_t  有符号补<E58FB7>? * 返回值：电压<E794B5>? float  单位 V
 * 限定条件：无
- * 函数说明：±5V量程时 LSB = 10V / 65536 ≈ 152.59μV
- *           ±10V量程时 LSB = 20V / 65536 ≈ 305.18μV
- *           硬件 RANGE 引脚接 GND，默认 ±5V 量程
+ * 函数说明：<EFBFBD>?V量程<EFBFBD>?LSB = 10V / 65536 <EFBFBD>?152.59μV
+ *           ±10V量程<EFBFBD>?LSB = 20V / 65536 <EFBFBD>?305.18μV
+ *           硬件 RANGE 引脚<EFBFBD>?GND，默<EFBFBD>?±5V 量程
 */
-float tpafe5160_to_voltage(int16_t raw)
-{
-    /* RANGE 接 GND → ±5V 量程，满量程 10V */
+float tpafe5160_to_voltage(int16_t raw) {
+    /* RANGE <20>?GND <20>?±5V 量程，满量程 10V */
    return (float)raw * (10.0f / 65536.0f);
 }

 /*
- * 函数功能：直接读取并行数据总线（不启动转换）
- * 入口参数：无
- * 返回值：16位原始数据  uint16_t
- * 限定条件：RD 为低或 CS 与 RD 已拉低
- * 函数说明：读取 GPIOG->IDR 低16位，对应 DB[15:0]
+ * 函数功能：直接读取并行数据总线（不启动转换<EFBFBD>? * 入口参数：无
+ * 返回值：16位原始数<EFBFBD>? uint16_t
+ * 限定条件：RD 为低<E4B8BA>?CS <20>?RD 已拉<E5B7B2>? * 函数说明：读<EFBC9A>?GPIOG->IDR <20>?6位，对应 DB[15:0]
 */
-uint16_t tpafe5160_read_bus(void)
-{
+uint16_t tpafe5160_read_bus(void) {
    return TPAFE5160_READ_BUS();
 }

@@ -229,100 +200,82 @@ uint16_t tpafe5160_read_bus(void)

 /*
 * 函数功能：通过 RD 脉冲连续读取多个通道数据
- * 入口参数：count - 要读取的通道数  uint8_t  1 - 8
- *           buf   - 输出缓冲区       int16_t* 不为 NULL
- * 返回值：无
- * 限定条件：转换已完成（BUSY 为低），RD 初始为高
- * 函数说明：每次 RD 下降沿输出一个通道数据，按通道1~8顺序输出
- *           DB[15:0] 直接接 GPIOG[15:0]，通过 IDR 寄存器一次读取
- *
- * 时序关键点 (VDRIVE > 2.7V, 168MHz 主频)：
- *   GPIO 写操作 ~6ns + 端口延迟 ~18ns → RD 引脚实际翻转约 24ns 后
- *   t14 数据建立 ≤ 21ns → 数据在 RD 下降沿后 21ns 内有效
- *   5 个 NOP (~30ns) 覆盖建立时间
+ * 入口参数：count - 要读取的通道<EFBFBD>? uint8_t  1 - 8
+ *           buf   - 输出缓冲<EFBFBD>?      int16_t* 不为 NULL
+ * 返回值：<EFBFBD>? * 限定条件：转换已完成（BUSY 为低），RD 初始为高
+ * 函数说明：每<EFBFBD>?RD 下降沿输出一个通道数据，按通道1~8顺序输出
+ *           DB[15:0] 直接<E79BB4>?GPIOG[15:0]，通过 IDR 寄存器一次读<E6ACA1>? *
+ * 时序关键<EFBFBD>?(VDRIVE > 2.7V, 168MHz 主频)<29>? *   GPIO 写操<E58699>?~6ns + 端口延迟 ~18ns <20>?RD 引脚实际翻转<E7BFBB>?24ns <20>? *   t14 数据建立 <20>?21ns <20>?数据<E695B0>?RD 下降沿后 21ns 内有<E58685>? *   5 <20>?NOP (~30ns) 覆盖建立时间
 */
-static void tpafe5160_read_channels(uint8_t count, int16_t *buf)
-{
+static void tpafe5160_read_channels(uint8_t count, int16_t *buf) {
    uint8_t i;

    for (i = 0; i < count; i++) {
-        /* RD 下降沿：ADC 输出当前通道数据到 DB[15:0] */
-        TP_RD_LOW_DLY();
+        /* RD 下降沿：ADC 输出当前通道数据<EFBFBD>?DB[15:0] */
+        TPAFE5160_RD_LOW_DLY();

-        /* 读取16位并行数据 */
+        /* 读取16位并行数<EFBFBD>?*/
        buf[i] = (int16_t)TPAFE5160_READ_BUS();

        /* RD 上升沿：准备下一通道 */
-        TP_RD_HIGH_DLY();
+        TPAFE5160_RD_HIGH_DLY();
    }
 }

 /* ======================== 中断模式实现 ======================== */

-/* 双缓冲区：ISR 写 s_buf_b，主循环读 s_buf_a */
+/* 双缓冲区：ISR <EFBFBD>?s_buf_b，主循环<EFBFBD>?s_buf_a */
 static int16_t s_buf_a[TPAFE5160_CH_NUM];
 static int16_t s_buf_b[TPAFE5160_CH_NUM];
 static volatile uint8_t s_ready = 0;
-static volatile uint8_t s_buf_sel = 0;   /* 0 = 写 B / 读 A, 1 = 写 A / 读 B */
+static volatile uint8_t s_buf_sel = 0;   /* 0 = <EFBFBD>?B / <EFBFBD>?A, 1 = <EFBFBD>?A / <EFBFBD>?B */

 /*
- * 函数功能：使能 BUSY EXTI 中断（运行时重使能用）
- * 入口参数：无
- * 返回值：无
- * 限定条件：CubeMX 已完成 GPIO 和 NVIC 配置
- * 函数说明：正常启动流程无需调用，仅在 irq_disable() 后需要重新使能时使用
+ * 函数功能：使<EFBFBD>?BUSY EXTI 中断（运行时重使能用<EFBFBD>? * 入口参数：无
+ * 返回值：<EFBFBD>? * 限定条件：CubeMX 已完<E5B7B2>?GPIO <20>?NVIC 配置
+ * 函数说明：正常启动流程无需调用，仅<EFBFBD>?irq_disable() 后需要重新使能时使用
 */
-void tpafe5160_irq_enable(void)
-{
+void tpafe5160_irq_enable(void) {
    HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);
 }

 /*
- * 函数功能：关闭 BUSY EXTI 中断
+ * 函数功能：关<EFBFBD>?BUSY EXTI 中断
 * 入口参数：无
- * 返回值：无
- * 限定条件：已调用 tpafe5160_irq_enable()
+ * 返回值：<EFBFBD>? * 限定条件：已调用 tpafe5160_irq_enable()
 * 函数说明：仅禁用 NVIC 中断，GPIO 配置保持 CubeMX 设定
 */
-void tpafe5160_irq_disable(void)
-{
+void tpafe5160_irq_disable(void) {
    HAL_NVIC_DisableIRQ(EXTI9_5_IRQn);
 }

 /*
- * 函数功能：启动转换（中断模式）
- * 入口参数：无
- * 返回值：无
- * 限定条件：已调用 tpafe5160_irq_enable()
- * 函数说明：产生 CONVST 脉冲，转换完成后由 EXTI 中断自动读取 8 通道数据
+ * 函数功能：启动转换（中断模式<EFBFBD>? * 入口参数：无
+ * 返回值：<EFBFBD>? * 限定条件：已调用 tpafe5160_irq_enable()
+ * 函数说明：产<EFBFBD>?CONVST 脉冲，转换完成后<E68890>?EXTI 中断自动读取 8 通道数据
 */
-void tpafe5160_start_conv_irq(void)
-{
+void tpafe5160_start_conv_irq(void) {
    s_ready = 0;
-    TP_CONVST_PULSE();
+    TPAFE5160_CONVST_PULSE();
 }

 /*
 * 函数功能：检查是否有新的转换数据
 * 入口参数：无
- * 返回值：1 - 数据就绪，0 - 无新数据
+ * 返回值：1 - 数据就绪<EFBFBD>? - 无新数据
 * 限定条件：中断模式已启用
 * 函数说明：在 EXTI 回调中置位，主循环读取后需调用 tpafe5160_clear_ready() 清除
 */
-uint8_t tpafe5160_data_ready(void)
-{
+uint8_t tpafe5160_data_ready(void) {
    return s_ready;
 }

 /*
- * 函数功能：清除数据就绪标志
- * 入口参数：无
- * 返回值：无
- * 限定条件：中断模式已启用
+ * 函数功能：清除数据就绪标<EFBFBD>? * 入口参数：无
+ * 返回值：<EFBFBD>? * 限定条件：中断模式已启用
 * 函数说明：主循环处理完数据后调用
 */
-void tpafe5160_clear_ready(void)
-{
+void tpafe5160_clear_ready(void) {
    s_ready = 0;
 }

@@ -330,23 +283,16 @@ void tpafe5160_clear_ready(void)
 * 函数功能：获取数据缓冲区指针
 * 入口参数：无
 * 返回值：int16_t[8] 数据缓冲区的 const 指针
- * 限定条件：tpafe5160_data_ready() 返回 1 时调用
- * 函数说明：双缓冲切换，ISR 写另一个缓冲区，主循环安全读取当前缓冲区
- */
-const int16_t* tpafe5160_get_buf(void)
-{
+ * 限定条件：tpafe5160_data_ready() 返回 1 时调<EFBFBD>? * 函数说明：双缓冲切换，ISR 写另一个缓冲区，主循环安全读取当前缓冲<E7BC93>? */
+const int16_t* tpafe5160_get_buf(void) {
    return (s_buf_sel == 0) ? s_buf_a : s_buf_b;
 }

 /*
- * 函数功能：BUSY 下降沿 EXTI 处理（由 HAL_GPIO_EXTI_Callback 调用）
- * 入口参数：GPIO_Pin - 触发中断的引脚号
- * 返回值：无
- * 限定条件：BUSY EXTI 已使能
- * 函数说明：转换完成后自动读取 8 通道数据到缓冲区，耗时约 0.5µs (168MHz)
+ * 函数功能：BUSY 下降<EFBFBD>?EXTI 处理（由 HAL_GPIO_EXTI_Callback 调用<EFBFBD>? * 入口参数：GPIO_Pin - 触发中断的引脚号
+ * 返回值：<EFBFBD>? * 限定条件：BUSY EXTI 已使<E5B7B2>? * 函数说明：转换完成后自动读取 8 通道数据到缓冲区，耗时<E88097>?0.5µs (168MHz)
 */
-void tpafe5160_exti_handler(uint16_t GPIO_Pin)
-{
+void tpafe5160_exti_handler(uint16_t GPIO_Pin) {
    if (GPIO_Pin != TP_BUSY_Pin) {
        return;
    }
@@ -357,9 +303,9 @@ void tpafe5160_exti_handler(uint16_t GPIO_Pin)
    /* 连续读取8个通道，约 0.5µs @ 168MHz */
    uint8_t i;
    for (i = 0; i < TPAFE5160_CH_NUM; i++) {
-        TP_RD_LOW_DLY();
+        TPAFE5160_RD_LOW_DLY();
        p_wr[i] = (int16_t)TPAFE5160_READ_BUS();
-        TP_RD_HIGH_DLY();
+        TPAFE5160_RD_HIGH_DLY();
    }

    /* 切换缓冲区并标记就绪 */
--- a/Drivers/BSP/TPAFE5160/tpafe5160.h
+++ b/Drivers/BSP/TPAFE5160/tpafe5160.h
@@ -48,20 +48,20 @@ extern "C" {

 /* 过采样率枚举 (OS[2:0] 编码，OS2为MSB, OS0为LSB) */
 typedef enum {
-    TP_OS_NONE  = 0,    /* 000 — 无过采样，350 kSPS */
-    TP_OS_X2    = 1,    /* 001 — 2倍过采样，175 kSPS */
-    TP_OS_X4    = 2,    /* 010 — 4倍过采样，87.5 kSPS */
-    TP_OS_X8    = 3,    /* 011 — 8倍过采样，43.75 kSPS */
-    TP_OS_X16   = 4,    /* 100 — 16倍过采样，21.875 kSPS */
-    TP_OS_X32   = 5,    /* 101 — 32倍过采样，10.94 kSPS */
-    TP_OS_X64   = 6,    /* 110 — 64倍过采样，5.47 kSPS */
-    TP_OS_HBW   = 7     /* 111 — 高带宽模式 (~30kHz)，350 kSPS */
+    TPAFE5160_OS_NONE  = 0,    /* 000 — 无过采样，350 kSPS */
+    TPAFE5160_OS_X2    = 1,    /* 001 — 2倍过采样，175 kSPS */
+    TPAFE5160_OS_X4    = 2,    /* 010 — 4倍过采样，87.5 kSPS */
+    TPAFE5160_OS_X8    = 3,    /* 011 — 8倍过采样，43.75 kSPS */
+    TPAFE5160_OS_X16   = 4,    /* 100 — 16倍过采样，21.875 kSPS */
+    TPAFE5160_OS_X32   = 5,    /* 101 — 32倍过采样，10.94 kSPS */
+    TPAFE5160_OS_X64   = 6,    /* 110 — 64倍过采样，5.47 kSPS */
+    TPAFE5160_OS_HBW   = 7     /* 111 — 高带宽模式 (~30kHz)，350 kSPS */
 } tpafe5160_os_t;

 /* 输入量程枚举 */
 typedef enum {
-    TP_RANGE_5V  = 0,   /* ±5V  (RANGE = LOW) */
-    TP_RANGE_10V = 1    /* ±10V (RANGE = HIGH) */
+    TPAFE5160_RANGE_5V  = 0,   /* ±5V  (RANGE = LOW) */
+    TPAFE5160_RANGE_10V = 1    /* ±10V (RANGE = HIGH) */
 } tpafe5160_range_t;

 /* 返回值定义 */
--- a/Drivers/BSP/dbg_cfg.h
+++ b/Drivers/BSP/dbg_cfg.h
@@ -8,6 +8,11 @@
 *   - 两者都不定义：所有 DBG_* 宏为空操作（release 版本）
 *
 * 用户可在本文件中直接控制，也可在编译器预定义中覆盖
+ * 适用平台：所有 BSP 驱动
+ * 作者：王建锋
+ * 创建日期：2026-07-18
+ * 修改记录：
+ *     2026-07-18  王建锋  创建初始版本
 */

 #ifndef __DBG_CFG_H
--- a/Drivers/BSP/dbg_log.h
+++ b/Drivers/BSP/dbg_log.h
@@ -8,6 +8,10 @@
 *      #define DBG_TAG "[CH395]"
 *      #include "dbg_log.h"
 * 适用平台：所有 BSP 驱动
+ * 作者：王建锋
+ * 创建日期：2026-07-18
+ * 修改记录：
+ *     2026-07-18  王建锋  创建初始版本
 */

 #ifndef __DBG_LOG_H
@@ -49,14 +53,14 @@ extern "C" {
 */
 #define DBG_ERROR(fmt, ...) do { \
    DBG_PRINT("[ERR]" DBG_TAG " " fmt "\r\n", ##__VA_ARGS__); \
-} while(0)
+} while (0)

 /*
 * DBG_INFO - 信息输出，受 DBG_ENABLE 控制
 */
 #define DBG_INFO(fmt, ...) do { \
    DBG_PRINT(DBG_TAG " " fmt "\r\n", ##__VA_ARGS__); \
-} while(0)
+} while (0)

 /*
 * DBG_DEBUG - 调试输出，需 DBG_ENABLE + DBG_DEBUG_ENABLE 同时定义
@@ -64,7 +68,7 @@ extern "C" {
 #ifdef DBG_DEBUG_ENABLE
 #define DBG_DEBUG(fmt, ...) do { \
    DBG_PRINT(DBG_TAG "(%s:%d) " fmt "\r\n", __func__, __LINE__, ##__VA_ARGS__); \
-} while(0)
+} while (0)
 #else
 #define DBG_DEBUG(fmt, ...)
 #endif