优化spi日志，降低thread优先级，降低锁死nand操作几率。

diff --git a/code/sdk/zhihui/utils/custom_spi.c b/code/sdk/zhihui/utils/custom_spi.c
index 0830410..aa31d26 100644 (file)
--- a/code/sdk/zhihui/utils/custom_spi.c
+++ b/code/sdk/zhihui/utils/custom_spi.c
@@ -44,6 +44,10 @@ static uint32_t g_error_count = 0;     // 错误计数（用于异常次数判
 
 #define SPI_ERROR_RESET_LIMIT 20  // 当错误计数超过此阈值且g_error_triggered仍为0时，强制触发中断并重置计数
 
+// 日志控制：减少正常传输时的日志输出
+#define SPI_LOG_NORMAL_PACKET_INTERVAL 100  // 每N个正常包打印一次日志（0表示不打印正常包日志）
+static uint32_t g_last_logged_packet_seq = 0;  // 上次打印日志的包序号
+
 /* SPI数据接收回调函数指针 */
 static custom_spi_data_callback_t g_spi_data_callback = NULL;
 
@@ -195,13 +199,26 @@ static void custom_spi_read_normal(void)
         // 检查到正确位置的包：清除错误触发标志并重置错误计数
         // 第一个包（pkg_recv_cnt == 0）或包序号匹配期望序号时，表示收到正确位置的包
         if (packet_seq == g_expected_seq) {
+            uint8_t was_error = g_error_triggered;  // 记录之前是否有错误
             g_error_triggered = 0;
             g_error_count = 0;  // 重置错误计数
+            
+            // 只在以下情况打印日志：
+            // 1. 第一个包（会话开始）
+            // 2. 从错误状态恢复（was_error == 1）
+            // 3. 每N个包打印一次（如果设置了间隔）
             if (pkg_recv_cnt == 0) {
                 printf("SPI packet: first packet seq=%u detected, reset error trigger flag\n", packet_seq);
-            } else {
+                g_last_logged_packet_seq = packet_seq;
+            } else if (was_error) {
                 printf("SPI packet: correct sequence seq=%u (expected=%u) detected, reset error trigger flag\n", 
                        packet_seq, g_expected_seq);
+                g_last_logged_packet_seq = packet_seq;
+            } else if (SPI_LOG_NORMAL_PACKET_INTERVAL > 0 && 
+                       (packet_seq - g_last_logged_packet_seq) >= SPI_LOG_NORMAL_PACKET_INTERVAL) {
+                printf("SPI packet: correct sequence seq=%u (expected=%u), total_received=%u\n", 
+                       packet_seq, g_expected_seq, pkg_recv_cnt);
+                g_last_logged_packet_seq = packet_seq;
             }
         }
         
@@ -224,7 +241,7 @@ static void custom_spi_read_normal(void)
                                        0,
                                        data_len);
             } else {
-                // 错误已经触发，增加错误计数
+                // 错误已经触发，增加错误计数（静默处理，不打印日志）
                 g_error_count++;
                 // 如果错误计数超过上限，重置标志与计数，允许后续错误继续触发
                 if (g_error_count >= SPI_ERROR_RESET_LIMIT) {
@@ -232,9 +249,8 @@ static void custom_spi_read_normal(void)
                            g_error_count, SPI_ERROR_RESET_LIMIT);
                     g_error_triggered = 0;
                     g_error_count = 0;
-                } else {
-                    printf("SPI packet: error already triggered, skipping duplicate trigger and callback (seq=%u)\n", packet_seq);
                 }
+                // 移除重复的"error already triggered"日志，减少日志噪音
             }
 
             return;
@@ -246,9 +262,11 @@ static void custom_spi_read_normal(void)
         
         if (packet_seq != g_expected_seq) {
             if (packet_seq < g_expected_seq) {
-                // 收到重复包，忽略
-                printf("SPI packet: duplicate packet seq=%u (expected=%u), ignoring\n", 
-                        packet_seq, g_expected_seq);
+                // 收到重复包，忽略（仅在首次检测到或错误计数重置时打印日志）
+                if (g_error_triggered == 0) {
+                    printf("SPI packet: duplicate packet seq=%u (expected=%u), ignoring\n", 
+                            packet_seq, g_expected_seq);
+                }
                 // 触发错误回调（重复包，仅在未触发过或收到正确位置的包时触发）
                 if (g_error_triggered == 0 || packet_seq == g_expected_seq) {
                     g_error_count++;
@@ -258,7 +276,7 @@ static void custom_spi_read_normal(void)
                                             0,
                                             data_len);
                 } else {
-                    // 错误已经触发，增加错误计数
+                    // 错误已经触发，增加错误计数（静默处理，不打印日志）
                     g_error_count++;
                     // 如果错误计数超过上限，重置标志与计数，允许后续错误继续触发
                     if (g_error_count >= SPI_ERROR_RESET_LIMIT) {
@@ -288,7 +306,7 @@ static void custom_spi_read_normal(void)
                                             data_len);
                    
                 } else {
-                    // 错误已经触发，增加错误计数
+                    // 错误已经触发，增加错误计数（静默处理，不打印日志）
                     g_error_count++;
                     // 如果错误计数超过上限，重置标志与计数，允许后续错误继续触发
                     if (g_error_count >= SPI_ERROR_RESET_LIMIT) {
@@ -296,9 +314,8 @@ static void custom_spi_read_normal(void)
                                g_error_count, SPI_ERROR_RESET_LIMIT);
                         g_error_triggered = 0;
                         g_error_count = 0;
-                    } else {
-                        printf("SPI packet: error already triggered, skipping duplicate trigger and callback (seq=%u)\n", packet_seq);
                     }
+                    // 移除重复的"error already triggered"日志，减少日志噪音
                 }
                 return;
                 
@@ -355,11 +372,10 @@ static void custom_spi_read_normal(void)
                     if (g_error_count >= SPI_ERROR_RESET_LIMIT) {
                         printf("SPI packet: error count (%u) >= reset limit (%u), force reset error flag\n",
                                g_error_count, SPI_ERROR_RESET_LIMIT);
-                        g_error_triggered = 0;
-                        g_error_count = 0;
-                    } else {
-                        printf("SPI callback: error already triggered, skipping duplicate callback (seq=%u)\n", packet_seq);
-                    }
+                    g_error_triggered = 0;
+                    g_error_count = 0;
+                }
+                // 移除重复的"error already triggered"日志，减少日志噪音
                 }
             }
         } else {
@@ -385,7 +401,7 @@ static void custom_spi_read_normal(void)
                                   ret,  // 错误码
                                   0);   // 数据长度不可解析
         } else {
-            // 错误已经触发，增加错误计数
+            // 错误已经触发，增加错误计数（静默处理，不打印日志）
             g_error_count++;
             // 如果错误计数超过上限，重置标志与计数，允许后续错误继续触发
             if (g_error_count >= SPI_ERROR_RESET_LIMIT) {
@@ -393,9 +409,8 @@ static void custom_spi_read_normal(void)
                        g_error_count, SPI_ERROR_RESET_LIMIT);
                 g_error_triggered = 0;
                 g_error_count = 0;
-            } else {
-                printf("SPI read: error already triggered, skipping duplicate trigger and callback\n");
             }
+            // 移除重复的"error already triggered"日志，减少日志噪音
         }
     }
 }
@@ -570,7 +585,9 @@ void custom_spi_init(void)
     // taskcfg.create_queue_handle = create_ppg_queue;
     taskcfg.attr.name="custom_spi_service";
 
-    taskcfg.attr.priority = osPriorityHigh;
+    // 降低优先级，避免抢占 NAND Flash 操作（文件下载时会导致 QSPI 总线冲突）
+    // 从 osPriorityHigh (40) 降低到 osPriorityNormal (24)，与 sio_irq_proc 同级
+    taskcfg.attr.priority = osPriorityNormal;
 
     taskcfg.attr.stack_size = 0x2000;
     taskcfg.func = custom_spi_service_task;
@@ -617,6 +634,7 @@ void custom_spi_deinit(void)
     g_expected_seq = 0;  // 重置期望包序号
     g_error_triggered = 0;  // 重置错误触发标志
     g_error_count = 0;  // 重置错误计数
+    g_last_logged_packet_seq = 0;  // 重置日志记录序号
     errcode_t ret = 0;
 
     if(taskcfg.task_handle)