zhunk 2 месяцев назад
Родитель
Сommit
a72c632188

+ 1 - 1
Application_cbd_apm32f1/.settings/language.settings.xml

@@ -5,7 +5,7 @@
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
-			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="-446626834515254951" id="ilg.gnuarmeclipse.managedbuild.cross.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT ARM Cross GCC Built-in Compiler Settings " parameter="${COMMAND} ${FLAGS} ${cross_toolchain_flags} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="-467146910568853748" id="ilg.gnuarmeclipse.managedbuild.cross.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT ARM Cross GCC Built-in Compiler Settings " parameter="${COMMAND} ${FLAGS} ${cross_toolchain_flags} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
 				<language-scope id="org.eclipse.cdt.core.gcc"/>
 				<language-scope id="org.eclipse.cdt.core.g++"/>
 			</provider>

+ 3 - 2
Application_cbd_apm32f1/applications/control.c

@@ -708,12 +708,13 @@ void ctr_router(uint8_t status_router)
     if(status_router==ON)
     {
         rt_pin_write(ROUTER,ON);
-
+        ctr_Cold(ON);
     }
     else {
         rt_pin_write(ROUTER,OFF);
-
+        ctr_Cold(OFF);
     }
+
 }
 //清扫-推杆电机
 void ctr_TG_Clear(uint16_t clear_timeout)

+ 1 - 1
Application_cbd_apm32f1/applications/control.h

@@ -16,7 +16,7 @@
 //定制相关//////////////////////////////////////////////////////
 #define SENSOR_EN        0              //温湿度:0关闭,1打开
 ////////////////////////////////////////////////////////////////
-#define VERSION_BZY         "2.9.36"                   //孢子仪
+#define VERSION_BZY         "2.9.42"                   //孢子仪
 
 /* 对焦串口通信异常标志: 串口收到合法 JSON 且含 "focus" 字段时置1(定义于dtu_uart2.c) */
 extern volatile uint8_t focus_valid_flag;

+ 31 - 5
Application_cbd_apm32f1/applications/dtu_uart2.c

@@ -64,10 +64,13 @@ static uint8_t makejson_sta = 0;
 static lwjson_stream_parser_t lwparser;
 
 /* JSON 通信超时看门狗:记录上次成功解析一帧 JSON 的 tick,
+ * 若超过 DTU_UPLOAD_TIMEOUT_MS (1h) 仍未收到,则主动发送 UpLoad_Data 心跳探测对端;
  * 若超过 DTU_JSON_TIMEOUT_TICKS (2h) 仍未收到,则执行 ctr_Heat(OFF) -> 10s -> ctr_Heat(ON) 的心跳 */
+#define DTU_UPLOAD_TIMEOUT_MS   (1 * 60 * 60 * 1000UL)   /* 1 小时无数据主动上传 */
 #define DTU_JSON_TIMEOUT_MS     (2 * 60 * 60 * 1000UL)   /* 2 小时 */
 #define DTU_JSON_RESET_OFF_MS   (10 * 1000UL)              /* OFF 持续 10s */
 static volatile rt_tick_t g_dtu_json_last_tick = 0;       /* 上次成功解析 JSON 的时间 */
+static volatile rt_tick_t g_dtu_upload_last_tick = 0;     /* 上次主动上传心跳的时间(防止通信未恢复时每秒重复发) */
 
 static int DTU_uart2_init(void)
 {
@@ -137,20 +140,22 @@ static rt_err_t dtu_input(rt_device_t dev, rt_size_t size)
 }
 
 
-static dtu_thread_entry_send(void *parameter)
+static void dtu_thread_entry_send(void *parameter)
 {
     /* 安装信号 */
     rt_signal_install(SIGUSR2, parseDtu);
     rt_signal_unmask(SIGUSR2);
     /* 同时承担通信超时看门狗:每 1 秒轮询一次,
-     * 若超过 DTU_JSON_TIMEOUT_MS 仍未收到任何 JSON,
-     * 则执行 ctr_Heat(OFF) -> 10s -> ctr_Heat(ON) 的心跳 */
+     * 超过 DTU_UPLOAD_TIMEOUT_MS (1h) 未收到任何 JSON: 主动发送 UpLoad_Data 心跳探测对端;
+     * 超过 DTU_JSON_TIMEOUT_MS (2h) 仍未收到: 执行 ctr_Heat(OFF) -> 10s -> ctr_Heat(ON) */
     g_dtu_json_last_tick = rt_tick_get();   /* 启动时记一次,避免开机立刻触发 */
+    g_dtu_upload_last_tick = g_dtu_json_last_tick;
     while (1)
     {
         rt_thread_mdelay(1000);
         rt_tick_t now = rt_tick_get();
         rt_tick_t diff;
+        rt_tick_t upload_diff;
         if (now >= g_dtu_json_last_tick)
         {
             diff = now - g_dtu_json_last_tick;
@@ -160,7 +165,26 @@ static dtu_thread_entry_send(void *parameter)
             /* tick 计数回绕:把差值视为 0,避免误触发 */
             diff = 0;
         }
+        if (now >= g_dtu_upload_last_tick)
+        {
+            upload_diff = now - g_dtu_upload_last_tick;
+        }
+        else
+        {
+            upload_diff = 0;
+        }
         rt_ubase_t diff_ms = (rt_ubase_t)((diff * 1000UL) / RT_TICK_PER_SECOND);
+        rt_ubase_t upload_diff_ms = (rt_ubase_t)((upload_diff * 1000UL) / RT_TICK_PER_SECOND);
+        /* 1h 未收到任何数据且距上次主动上传也已满 1h: 主动上传一次心跳,
+         * 探测对端是否在线; 对端若回复任意合法 JSON, g_dtu_json_last_tick 会被刷新 */
+        if (diff_ms >= DTU_UPLOAD_TIMEOUT_MS &&
+            upload_diff_ms >= DTU_UPLOAD_TIMEOUT_MS)
+        {
+            LOG_W("DTU JSON timeout (>%lu ms), 主动发送 UpLoad_Data 心跳",
+                   (unsigned long)DTU_UPLOAD_TIMEOUT_MS);
+            g_dtu_upload_last_tick = now;
+            UpLoad_Data();
+        }
         if (diff_ms >= DTU_JSON_TIMEOUT_MS)
         {
             LOG_W("DTU JSON timeout (>%lu ms), Heart OFF -> 10s -> ON",
@@ -1057,12 +1081,10 @@ int parseDtu(char *json_string)
               }
               //补光灯开灯和关灯
               if(strstr(item_cmd->valuestring,"ledon")!=RT_NULL){
-                  ctr_Cold(ON);
                   ctr_led(ON);
               }
               if(strstr(item_cmd->valuestring,"ledoff")!=RT_NULL){
                   device_status.calibrate_slide = 0;
-                  ctr_Cold(OFF);
                   ctr_led(OFF);
                   slidelock();
                   device_status.autotakepic = 0;
@@ -1763,6 +1785,10 @@ int parseDtu(char *json_string)
 void UpLoad_Data(void)
 {
     char *updata = makeJson();
+    if (updata == RT_NULL) {
+        LOG_E("UpLoad_Data: makeJson failed, skip send");
+        return;
+    }
     DTU_Write(updata);
     rt_free(updata);
     //list_mem();

+ 276 - 59
Application_cbd_apm32f1/applications/hmi.c

@@ -215,16 +215,20 @@ void send_signal(int sig)
 
 /* ========== 自动对焦(Auto Focus)控制块 ==========
  * 两级对焦策略:
+ *   预热: 对焦开始后先原地微移动采样, 等相机AGC/曝光收敛(相邻帧变化
+ *         <AF_WARMUP_RATIO, 连续AF_WARMUP_STABLE帧或采满AF_WARMUP_MAX帧),
+ *         漂移期数据不参与任何对焦决策。
  *   粗扫: ±AF_COARSE_STEP 探测选定方向后, 以 AF_COARSE_STEP 步长在
  *         ±AF_SEARCH_LIMIT 范围内有界扫描, 全程跟踪全局最大清晰度,
  *         连续大幅跌落(明显变小)或连续未提升且最佳值显著高于本腿下限,
  *         即确认越过峰值; 一侧未找到峰值则换向扫另一侧。
  *   细扫: 回到粗扫最佳位置重新采样作基准, 爬山法沿单一方向以 AF_FINE_STEP
- *         步长移动, 上升则继续, 显著下降则调转方向, 且当前值跌破细扫最佳值
- *         *AF_FINE_CONFIRM_RATIO(处于峰后下降段)计一次确认, 峰前后各确认
- *         AF_FINE_CONFIRM_CNT 次即完成, 回到细扫实测最佳位置。
- * 注: 起点首帧清晰度可能异常(残留上一帧), 基准帧不计入最佳值,
- *     探测/扫描帧均在移动后采样, 数值可靠。 */
+ *         步长移动, 上升则继续, 显著下降则调转方向; 有效确认需调头后曾上升
+ *         且当前值跌破细扫最佳值*AF_FINE_CONFIRM_RATIO(处于峰后下降段),
+ *         峰前后各确认 AF_FINE_CONFIRM_CNT 次, 细扫最佳达到全局最佳值
+ *         *AF_FINE_VALID_RATIO 才完成, 回到细扫实测最佳位置; 边界处仍上升
+ *         允许越界追峰最多 AF_FINE_EXTEND 行程。
+ * 注: 探测/扫描帧均在移动后采样, 数值可靠。 */
 #define AF_FOCUS_TIMEOUT_MS   5000    /* 等待 focus 回复超时时间(ms) */
 #define AF_FOCUS_RETRY_MAX    3       /* 等待 focus 超时补发指令次数上限 */
 
@@ -240,16 +244,27 @@ void send_signal(int sig)
 #define AF_FINE_CONFIRM_CNT   2       /* 细扫: 越峰确认次数(峰前后各一次下降), 达到即完成 */
 #define AF_FINE_CONFIRM_RATIO 0.90f   /* 细扫: 当前值跌破细扫最佳值*该比例(已离开峰顶)才计为有效确认 */
 #define AF_FINE_VALID_RATIO   0.90f   /* 细扫: 确认完成时细扫最佳须达到全局最佳值*该比例才允许结束, 否则以细扫实测重新初始化基准 */
-#define AF_FINE_STEPS_MAX     24      /* 细扫最大采样步数(防振荡兜底) */
-#define AF_MAX_ITERATIONS     120     /* 采样总数安全上限 */
+#define AF_FINE_STEPS_MAX     32      /* 细扫最大采样步数(防振荡兜底, 含越界追峰扩展步) */
+#define AF_FINE_EXTEND        6       /* 细扫: 边界处仍上升时允许越界追峰的最大扩展行程 */
+#define AF_BACKLASH_OVERSHOOT 20      /* 回位消隙: 过冲行程(脉冲), 统一以负方向逼近终点消除丝杠反向间隙随机性 */
+#define AF_VERIFY_RATIO       0.90f   /* 回位校验: 回位帧清晰度不低于细扫最佳*该比例判合格 */
+#define AF_VERIFY_MAX         2       /* 回位校验不合格时允许就地补扫的最大次数 */
+#define AF_SPIKE_GUARD_RATIO  0.85f   /* 峰宽佐证: 单帧跳升超过前点/该比例(约+18%)先挂起观察, 下帧回落确认孤立尖峰则丢弃 */
+#define AF_FLAT_RATIO         0.10f   /* 平台检测: 细扫窗口内清晰度起伏低于最佳值*该比例判为平坦视场 */
+#define AF_PHOTO_SETTLE_MS    300     /* 拍照前稳定延时(ms): 回位到位后等机械振铃衰减再通知拍照 */
+#define AF_WARMUP_MAX         6       /* 预热: 最大采样帧数(等待相机AGC/曝光收敛) */
+#define AF_WARMUP_STABLE      2       /* 预热: 连续稳定帧数达到该值即提前结束预热 */
+#define AF_WARMUP_RATIO       0.20f   /* 预热: 相邻两帧清晰度变化在该比例内视为稳定 */
+#define AF_MAX_ITERATIONS     160     /* 采样总数安全上限(含回位校验/补扫帧) */
 
 /* 对焦阶段 */
 enum {
-    AF_STAGE_BASE,    /* 等待起点基准清晰度 */
+    AF_STAGE_WARMUP,  /* 预热: 等待相机AGC/曝光收敛, 漂移期数据不参与对焦决策 */
     AF_STAGE_PROBE_P, /* 等待 +AF_COARSE_STEP 探测点清晰度 */
     AF_STAGE_PROBE_M, /* 等待 -AF_COARSE_STEP 探测点清晰度 */
     AF_STAGE_COARSE,  /* 粗扫 */
     AF_STAGE_FINE,    /* 细扫 */
+    AF_STAGE_VERIFY,  /* 回位校验: 回位帧清晰度复核, 不合格则就地补扫 */
 };
 
 typedef struct {
@@ -269,8 +284,18 @@ typedef struct {
     float fine_last;             /* 细扫: 上一采样点清晰度, <0 表示等待中心基准帧 */
     float fine_best_sharpness;   /* 细扫: 阶段内最佳清晰度(只统计细扫期采样, 同一漂移基线互相可比) */
     int   fine_best_pos;         /* 细扫: 阶段内最佳位置(最终回位依据) */
+    float fine_min_sharpness;    /* 细扫: 阶段内最低清晰度(平台检测: 窗口起伏幅度) */
     int   fine_confirm;          /* 细扫: 越峰确认次数(峰前后各一次显著下降) */
     int   fine_step_cnt;         /* 细扫: 已采样步数 */
+    bool  fine_risen;            /* 细扫: 本次调头后曾上升过(纯下降段不计确认) */
+    int   fine_extend;           /* 细扫: 边界处已越界追峰的扩展行程 */
+    float fine_spike_pending;    /* 细扫: 挂起观察的疑似尖峰值, <0 表示无挂起 */
+    int   fine_spike_pos;        /* 细扫: 挂起尖峰所在位置 */
+    int   verify_cnt;            /* 回位校验: 不合格触发的补扫次数 */
+    float warm_last;             /* 预热: 上一帧清晰度 */
+    int   warm_cnt;              /* 预热: 已采样帧数 */
+    int   warm_stable;           /* 预热: 连续稳定帧数 */
+    int   warm_dir;              /* 预热: 微移动方向(0/1交替, 净位移0) */
     int   max_iterations;        /* 剩余采样数安全上限 */
     volatile bool sharpness_updated;  /* 信号处理程序置位: 有新清晰度值 */
     float new_sharpness;         /* 信号处理程序写入的新清晰度值 */
@@ -280,6 +305,12 @@ typedef struct {
 } auto_focus_t;
 
 static auto_focus_t g_af;
+
+/* 上一个点位最终对焦结果(跨对焦持久, 供平坦视场继承焦位; 不放g_af内以免被memset清零) */
+static int   g_prev_focus_pos = 0;
+static float g_prev_focus_sharpness = 0.0f;
+static bool  g_prev_focus_valid = false;
+
 /* 轻量级信号处理程序:仅存储清晰度值,不阻塞 */
 void thread1_signal_handler(int sig)
 {
@@ -294,8 +325,10 @@ static void auto_focus_init(void)
     memset(&g_af, 0, sizeof(g_af));
     g_af.best_sharpness = -FLT_MAX;
     g_af.fine_best_sharpness = -FLT_MAX;   /* 无细扫数据标志 */
+    g_af.fine_min_sharpness = FLT_MAX;     /* 平台检测: 窗口最低值 */
+    g_af.fine_spike_pending = -1.0f;       /* 峰宽佐证: 无挂起尖峰(memset清零值0.0f会被误判为挂起中) */
     g_af.current_pos = 0;
-    g_af.stage = AF_STAGE_BASE;
+    g_af.stage = AF_STAGE_WARMUP;
     g_af.max_iterations = AF_MAX_ITERATIONS;
     /* 超时重试状态 */
     g_af.active = true;
@@ -328,8 +361,25 @@ static void auto_focus_move_to(int target_pos)
     g_af.wait_start_tick = rt_tick_get();   /* 移动完成,开始等待 focus 回复 */
 }
 
-/* 完成对焦 */
-static void auto_focus_done(void)
+/* 真正收尾: 停表并上报对焦完成 */
+static void auto_focus_finish(void)
+{
+    /* 拍照前稳定延时: 回位到位后等机械振铃衰减再通知拍照, 避免运动模糊 */
+    rt_thread_delay(rt_tick_from_millisecond(AF_PHOTO_SETTLE_MS));
+    g_af.active = false;   /* 对焦完成,停止超时重试检测 */
+    char *c0 = makeJson_Warn("auto_focus","auto_focus");
+    DTU_Write("%s",c0);
+    rt_free(c0);
+}
+
+/* 完成对焦, 回位最佳点
+ * verify_en=true(正常收尾): 回位采用消隙策略 —— 统一以负方向逼近终点
+ *   (当前在终点负侧或相等时先过冲 +AF_BACKLASH_OVERSHOOT 再回落),
+ *   消除丝杠反向间隙导致的落点随机偏差; 回位后进入 AF_STAGE_VERIFY,
+ *   由回位移动触发的回位帧复核清晰度, 不合格则就地补扫;
+ * verify_en=false(采样耗尽等异常收尾): 直接回位结束, 不再校验
+ *   (校验帧会再次触发采样耗尽分支, 防止循环)。 */
+static void auto_focus_done(bool verify_en)
 {
     /* 最终回位位置: 细扫有采样数据则以细扫实测最佳为准(同一漂移基线, 可比);
      * 否则(粗扫阶段被采样上限中断等)回全局最佳位置 */
@@ -339,31 +389,72 @@ static void auto_focus_done(void)
         final_pos = g_af.fine_best_pos;
         final_sharpness = g_af.fine_best_sharpness;
     }
+
+    /* 平台检测: 细扫窗口内清晰度起伏(best-min)低于最佳值*AF_FLAT_RATIO,
+     * 判为平坦视场(无可对焦内容, 曲线无真峰), 继承上一个点位的焦位
+     * (相邻点位焦面接近), 避免停在噪声高点; 各点位对焦起点相同, 相对位置可比 */
+    if (g_af.fine_best_sharpness > -FLT_MAX &&
+        g_af.fine_min_sharpness < FLT_MAX &&
+        (g_af.fine_best_sharpness - g_af.fine_min_sharpness) <
+            g_af.fine_best_sharpness * AF_FLAT_RATIO &&
+        g_prev_focus_valid) {
+        LOG_W("[对焦] 平坦视场(起伏%.2f<%.2f的%.0f%%), 继承上点位焦位:%d",
+              g_af.fine_best_sharpness - g_af.fine_min_sharpness,
+              g_af.fine_best_sharpness, AF_FLAT_RATIO * 100.0f,
+              g_prev_focus_pos);
+        final_pos = g_prev_focus_pos;
+    }
+
+    /* 保存本点位对焦结果, 供下一点位平坦视场继承 */
+    g_prev_focus_pos = final_pos;
+    g_prev_focus_sharpness = final_sharpness;
+    g_prev_focus_valid = true;
+
     LOG_I("[对焦] 完成! 最佳位置:%d 清晰度:%.2f", final_pos, final_sharpness);
-    /* 回到最佳位置 */
+
+    if (!verify_en || g_af.fine_best_sharpness <= -FLT_MAX) {
+        /* 无细扫数据或不校验: 直接回位结束 */
+        if (g_af.current_pos != final_pos) {
+            LOG_I("[对焦] 回位到最佳位置:%d", final_pos);
+            auto_focus_move_to(final_pos);
+        }
+        auto_focus_finish();
+        return;
+    }
+
+    /* 消隙回位: 统一负方向逼近终点 */
+    if (g_af.current_pos <= final_pos) {
+        auto_focus_move_to(final_pos + AF_BACKLASH_OVERSHOOT);
+    }
     if (g_af.current_pos != final_pos) {
-        LOG_I("[对焦] 回位到最佳位置:%d", final_pos);
+        LOG_I("[对焦] 回位到最佳位置:%d(负向逼近)", final_pos);
         auto_focus_move_to(final_pos);
     }
-    g_af.active = false;   /* 对焦完成,停止超时重试检测 */
-    char *c0 = makeJson_Warn("auto_focus","auto_focus");
-    DTU_Write("%s",c0);
-    rt_free(c0);
+    /* 回位最后一段移动会触发相机回传 focus, 作为回位校验帧 */
+    g_af.stage = AF_STAGE_VERIFY;
 }
 
-/* 进入细扫阶段 */
-static void auto_focus_enter_fine(void)
+/* 进入细扫阶段(也用于回位校验不合格时的就地补扫)
+ * center: 细扫窗口中心; start_pos: 首个基准帧采样位置
+ *   —— 细扫首帧仅作趋势基准, start_pos 必须保证电机真实移动
+ *   (否则不产生 focus 回传, 只能等5s超时重试), 故补扫时取 center-2 */
+static void auto_focus_enter_fine(int center, int start_pos)
 {
-    LOG_I("[对焦] 进入细扫 最佳位置=%d 清晰度=%.2f", g_af.best_pos, g_af.best_sharpness);
+    LOG_I("[对焦] 进入细扫 中心=%d 起点=%d (全局最佳=%d/%.2f)",
+          center, start_pos, g_af.best_pos, g_af.best_sharpness);
     g_af.stage = AF_STAGE_FINE;
-    g_af.fine_center = g_af.best_pos;
+    g_af.fine_center = center;
     g_af.fine_dir = 1;
-    g_af.fine_last = -1.0f;    /* 等待中心基准帧(回到中心后重新采样作趋势基准) */
+    g_af.fine_last = -1.0f;    /* 等待基准帧(首帧仅作趋势基准) */
     g_af.fine_best_sharpness = -FLT_MAX;
-    g_af.fine_best_pos = g_af.best_pos;
+    g_af.fine_best_pos = center;
+    g_af.fine_min_sharpness = FLT_MAX;   /* 平台检测: 窗口最低值 */
+    g_af.fine_spike_pending = -1.0f;     /* 峰宽佐证: 无挂起尖峰 */
     g_af.fine_confirm = 0;
     g_af.fine_step_cnt = 0;
-    auto_focus_move_to(g_af.fine_center);
+    g_af.fine_risen = false;
+    g_af.fine_extend = 0;
+    auto_focus_move_to(start_pos);
 }
 
 /* 粗扫阶段: 处理一次清晰度采样
@@ -400,7 +491,7 @@ static void auto_focus_coarse_step(float current_sharpness)
             (g_af.confirm_cnt >= AF_PEAK_CONFIRM_CNT &&
              g_af.best_sharpness > g_af.coarse_floor * AF_PEAK_RISE_RATIO)) {
             LOG_I("[对焦] 粗扫确认越过峰值");
-            auto_focus_enter_fine();
+            auto_focus_enter_fine(g_af.best_pos, g_af.best_pos);
             return;
         }
     }
@@ -410,7 +501,7 @@ static void auto_focus_coarse_step(float current_sharpness)
         (!g_af.coarse_dir && g_af.current_pos <= g_af.coarse_limit)) {
         if (g_af.coarse_both_done) {
             LOG_I("[对焦] 粗扫双向完成");
-            auto_focus_enter_fine();
+            auto_focus_enter_fine(g_af.best_pos, g_af.best_pos);
         } else {
             LOG_I("[对焦] 粗扫本腿未找到峰值, 换向扫描");
             g_af.coarse_both_done = true;
@@ -434,25 +525,77 @@ static void auto_focus_coarse_step(float current_sharpness)
 /* 细扫阶段: 爬山法 + 峰前后双次下降确认
  * 回到中心重新采样作趋势基准, 然后沿当前方向以 AF_FINE_STEP 步长移动:
  *   上升/持平(不低于上次值*AF_FINE_TREND_RATIO) → 继续同方向找更清晰位置;
- *   显著下降 → 调转方向, 且当前值已跌破细扫最佳值*AF_FINE_CONFIRM_RATIO
- *              (确认已越过峰顶, 处于峰后下降段) → 计一次越峰确认;
+ *   显著下降 → 调转方向; 有效确认需同时满足: 本次调头后曾上升过(排除
+ *              AGC漂移期纯下降段误确认) 且当前值已跌破细扫最佳值*
+ *              AF_FINE_CONFIRM_RATIO(确认处于峰后下降段);
  *   峰的前后各确认一次(AF_FINE_CONFIRM_CNT 次) → 峰值确认完成, 回位最佳点;
- *   到达 ±AF_FINE_WINDOW 窗口边界强制调头; 步数上限兜底。 */
+ *   到达 ±AF_FINE_WINDOW 窗口边界时若仍在上升, 允许越界追峰最多
+ *   AF_FINE_EXTEND 行程(真峰可能在窗口外), 否则强制调头; 步数上限兜底。 */
 static void auto_focus_fine_step(float current_sharpness)
 {
-    /* 更新细扫阶段最佳(只统计细扫期采样, 与粗扫历史值不混用,
-     * 避免相机漂移导致早期虚高值掩盖当前真实峰位) */
-    if (current_sharpness > g_af.fine_best_sharpness) {
-        g_af.fine_best_sharpness = current_sharpness;
-        g_af.fine_best_pos = g_af.current_pos;
-        LOG_I("[对焦] 细扫新最佳:位置=%d 清晰度=%.2f",
-              g_af.fine_best_pos, g_af.fine_best_sharpness);
+    /* update_last: 是否将当前帧纳入趋势基准。孤立尖峰丢弃时置否,
+     * 使下一帧仍与尖峰前的正常值比较, 避免尖峰后误判下降 */
+    bool update_last = true;
+
+    /* 峰宽佐证(挂起观察): 单帧跳升超过前点/AF_SPIKE_GUARD_RATIO(约+18%)时不立即采信,
+     * 挂起等下一帧 —— 回落则确认孤立噪声尖峰予以丢弃, 仍高则确认真实陡峰予以采信。
+     * 真峰步长2相邻差异远小于该阈值, 不会误伤; 挂起期间趋势基准保持尖峰前的值 */
+    if (g_af.fine_spike_pending >= 0.0f) {
+        float pending = g_af.fine_spike_pending;
+        int pending_pos = g_af.fine_spike_pos;
+        g_af.fine_spike_pending = -1.0f;
+        if (current_sharpness >= pending * AF_SPIKE_GUARD_RATIO) {
+            /* 尖峰后仍维持高位: 真实陡峰, 采信挂起值与当前值 */
+            LOG_I("[对焦] 细扫尖峰确认为真实峰 %.2f@%d", pending, pending_pos);
+            if (pending > g_af.fine_best_sharpness) {
+                g_af.fine_best_sharpness = pending;
+                g_af.fine_best_pos = pending_pos;
+            }
+            if (current_sharpness > g_af.fine_best_sharpness) {
+                g_af.fine_best_sharpness = current_sharpness;
+                g_af.fine_best_pos = g_af.current_pos;
+            }
+            if (current_sharpness < g_af.fine_min_sharpness) {
+                g_af.fine_min_sharpness = current_sharpness;
+            }
+            g_af.fine_risen = true;
+        } else {
+            /* 尖峰后回落: 孤立噪声尖峰, 丢弃, 趋势基准仍为尖峰前的值 */
+            LOG_W("[对焦] 细扫孤立尖峰丢弃 %.2f@%d (当前 %.2f)",
+                  pending, pending_pos, current_sharpness);
+            update_last = false;
+        }
+    } else {
+        bool jump = (g_af.fine_last >= 0.0f) &&
+                    (current_sharpness > g_af.fine_last / AF_SPIKE_GUARD_RATIO);
+        if (jump) {
+            /* 显著跳升: 挂起观察, 不采信不更新基准, 照常移动等下一帧佐证 */
+            g_af.fine_spike_pending = current_sharpness;
+            g_af.fine_spike_pos = g_af.current_pos;
+            LOG_I("[对焦] 细扫疑似尖峰 %.2f@%d, 挂起观察",
+                  current_sharpness, g_af.current_pos);
+            g_af.fine_step_cnt++;
+            auto_focus_move_to(g_af.current_pos + (g_af.fine_dir ? AF_FINE_STEP : -AF_FINE_STEP));
+            return;
+        }
+        /* 正常帧: 更新细扫阶段最佳(只统计细扫期采样, 与粗扫历史值不混用,
+         * 避免相机漂移导致早期虚高值掩盖当前真实峰位) */
+        if (current_sharpness > g_af.fine_best_sharpness) {
+            g_af.fine_best_sharpness = current_sharpness;
+            g_af.fine_best_pos = g_af.current_pos;
+            LOG_I("[对焦] 细扫新最佳:位置=%d 清晰度=%.2f",
+                  g_af.fine_best_pos, g_af.fine_best_sharpness);
+        }
+        /* 维护窗口最低值(平台检测依据) */
+        if (current_sharpness < g_af.fine_min_sharpness) {
+            g_af.fine_min_sharpness = current_sharpness;
+        }
     }
 
     g_af.fine_step_cnt++;
     if (g_af.fine_step_cnt > AF_FINE_STEPS_MAX) {
         LOG_W("[对焦] 细扫步数达上限, 结束");
-        auto_focus_done();
+        auto_focus_done(true);
         return;
     }
 
@@ -464,17 +607,29 @@ static void auto_focus_fine_step(float current_sharpness)
     }
 
     int dir_sign = g_af.fine_dir ? 1 : -1;
-
-    if (current_sharpness >= g_af.fine_last * AF_FINE_TREND_RATIO) {
-        /* 上升/持平: 继续同方向 */
+    bool rising = (current_sharpness >= g_af.fine_last * AF_FINE_TREND_RATIO);
+    /* 当前是否在窗口外(越界追峰区) */
+    bool outside = (g_af.current_pos > g_af.fine_center + AF_FINE_WINDOW ||
+                    g_af.current_pos < g_af.fine_center - AF_FINE_WINDOW);
+
+    if (rising) {
+        /* 上升/持平: 继续同方向, 标记本轮经历过上升 */
+        g_af.fine_risen = true;
+    } else if (outside && g_af.fine_extend < AF_FINE_EXTEND) {
+        /* 扩展区单次下降视为噪声/抖动: 不调头不确认, 继续走完扩展行程 */
+        LOG_I("[对焦] 扩展区下降 %.2f->%.2f, 视为噪声继续追峰",
+              g_af.fine_last, current_sharpness);
     } else {
         /* 显著下降: 调转方向 */
         g_af.fine_dir = !g_af.fine_dir;
         dir_sign = -dir_sign;
-        /* 当前值已跌破峰顶(fine_best*AF_FINE_CONFIRM_RATIO), 确认处于峰后下降段,
-         * 计一次越峰确认; 峰的前后各确认一次即完成 */
-        if (current_sharpness < g_af.fine_best_sharpness * AF_FINE_CONFIRM_RATIO) {
+        /* 有效确认: 调头后曾上升过(先升后降才是越峰, 排除漂移期纯下降段),
+         * 且当前值已跌破峰顶(fine_best*AF_FINE_CONFIRM_RATIO);
+         * 峰的前后各确认一次即完成 */
+        if (g_af.fine_risen &&
+            current_sharpness < g_af.fine_best_sharpness * AF_FINE_CONFIRM_RATIO) {
             g_af.fine_confirm++;
+            g_af.fine_risen = false;   /* 本次上升段已用于确认 */
             LOG_I("[对焦] 细扫峰后下降确认[%d/%d] 清晰度=%.2f 峰顶=%.2f",
                   g_af.fine_confirm, AF_FINE_CONFIRM_CNT,
                   current_sharpness, g_af.fine_best_sharpness);
@@ -484,7 +639,7 @@ static void auto_focus_fine_step(float current_sharpness)
                  * 全局基准, 清零确认计数继续扫描验证 */
                 if (g_af.fine_best_sharpness >= g_af.best_sharpness * AF_FINE_VALID_RATIO) {
                     LOG_I("[对焦] 细扫峰值确认完成");
-                    auto_focus_done();
+                    auto_focus_done(true);
                     return;
                 }
                 LOG_I("[对焦] 细扫最佳%.2f低于全局最佳%.2f的0.9倍, 以细扫实测重新初始化基准",
@@ -497,16 +652,34 @@ static void auto_focus_fine_step(float current_sharpness)
         LOG_I("[对焦] 细扫下降 %.2f->%.2f, 调转方向:%d",
               g_af.fine_last, current_sharpness, g_af.fine_dir);
     }
-    g_af.fine_last = current_sharpness;
+    /* 孤立尖峰丢弃时不纳入趋势基准: 下一帧仍与尖峰前的正常值比较 */
+    if (update_last) {
+        g_af.fine_last = current_sharpness;
+    }
 
-    /* 计算下一步位置, 窗口边界强制调头 */
+    /* 计算下一步位置; 越界处理:
+     * 朝界内走(回窗口途中) → 放行, 不再误判为出界调头;
+     * 向外走且扩展行程未用完 → 越界追峰(无论升降, 扩展区噪声由上升分支过滤);
+     * 向外走且扩展已用尽 → 强制调头回界内。 */
     int next = g_af.current_pos + dir_sign * AF_FINE_STEP;
-    if (next > g_af.fine_center + AF_FINE_WINDOW ||
-        next < g_af.fine_center - AF_FINE_WINDOW) {
-        g_af.fine_dir = !g_af.fine_dir;
-        dir_sign = -dir_sign;
-        next = g_af.current_pos + dir_sign * AF_FINE_STEP;
-        LOG_I("[对焦] 细扫到达窗口边界, 调转方向:%d", g_af.fine_dir);
+    int win_hi = g_af.fine_center + AF_FINE_WINDOW;
+    int win_lo = g_af.fine_center - AF_FINE_WINDOW;
+    if (next > win_hi || next < win_lo) {
+        bool outward = (dir_sign > 0 && next > win_hi) ||
+                       (dir_sign < 0 && next < win_lo);
+        if (!outward) {
+            /* 越界但朝界内走: 放行, 逐步回到窗口内 */
+        } else if (g_af.fine_extend < AF_FINE_EXTEND) {
+            /* 向外越界追峰: 走完扩展行程, 单次下降视为噪声不打断 */
+            g_af.fine_extend += AF_FINE_STEP;
+            LOG_I("[对焦] 细扫越界追峰 扩展[%d/%d]",
+                  g_af.fine_extend, AF_FINE_EXTEND);
+        } else {
+            g_af.fine_dir = !g_af.fine_dir;
+            dir_sign = -dir_sign;
+            next = g_af.current_pos + dir_sign * AF_FINE_STEP;
+            LOG_I("[对焦] 细扫扩展行程用尽, 调转方向:%d", g_af.fine_dir);
+        }
     }
     auto_focus_move_to(next);
 }
@@ -532,16 +705,40 @@ static void auto_focus_process(void)
     g_af.max_iterations--;
     if (g_af.max_iterations <= 0) {
         LOG_W("[对焦] 采样次数耗尽, 结束对焦");
-        auto_focus_done();
+        /* 直接收尾不做回位校验: 校验帧会再次触发本分支, 防止循环 */
+        auto_focus_done(false);
         return;
     }
 
     switch (g_af.stage) {
-    case AF_STAGE_BASE:
-        /* 起点基准帧: 首帧清晰度可能异常(残留上一帧), 仅记录不纳入最佳值 */
-        LOG_I("[对焦] 基准清晰度:%.2f", current_sharpness);
-        g_af.stage = AF_STAGE_PROBE_P;
-        auto_focus_move_to(AF_COARSE_STEP);
+    case AF_STAGE_WARMUP:
+        /* 预热: 等相机AGC/曝光收敛, 漂移期数据不纳入任何对焦决策。
+         * 相邻两帧清晰度变化在±AF_WARMUP_RATIO内计一帧稳定, 连续稳定
+         * AF_WARMUP_STABLE帧或采满AF_WARMUP_MAX帧后进入探测。
+         * 帧间以±AF_FINE_STEP微移动交替触发采样, 净位移为0。 */
+        g_af.warm_cnt++;
+        if (g_af.warm_cnt > 1) {
+            float lo = g_af.warm_last * (1.0f - AF_WARMUP_RATIO);
+            float hi = g_af.warm_last * (1.0f + AF_WARMUP_RATIO);
+            if (current_sharpness >= lo && current_sharpness <= hi) {
+                g_af.warm_stable++;
+            } else {
+                g_af.warm_stable = 0;
+            }
+            LOG_I("[对焦] 预热[%d/%d] 清晰度:%.2f 稳定计数:%d",
+                  g_af.warm_cnt, AF_WARMUP_MAX, current_sharpness, g_af.warm_stable);
+        } else {
+            LOG_I("[对焦] 预热首帧:%.2f", current_sharpness);
+        }
+        g_af.warm_last = current_sharpness;
+        if (g_af.warm_stable >= AF_WARMUP_STABLE || g_af.warm_cnt >= AF_WARMUP_MAX) {
+            LOG_I("[对焦] 预热完成, 基准清晰度:%.2f", current_sharpness);
+            g_af.stage = AF_STAGE_PROBE_P;
+            auto_focus_move_to(AF_COARSE_STEP);
+            break;
+        }
+        g_af.warm_dir = !g_af.warm_dir;
+        auto_focus_move_to(g_af.warm_dir ? AF_FINE_STEP : 0);
         break;
 
     case AF_STAGE_PROBE_P:
@@ -588,6 +785,26 @@ static void auto_focus_process(void)
     case AF_STAGE_FINE:
         auto_focus_fine_step(current_sharpness);
         break;
+
+    case AF_STAGE_VERIFY:
+        /* 回位校验帧: 与细扫实测最佳比较(同一漂移基线, 互相可比) */
+        if (current_sharpness >= g_af.fine_best_sharpness * AF_VERIFY_RATIO) {
+            LOG_I("[对焦] 回位校验通过 %.2f (最佳%.2f@%d)",
+                  current_sharpness, g_af.fine_best_sharpness, g_af.fine_best_pos);
+            auto_focus_finish();
+        } else if (g_af.verify_cnt >= AF_VERIFY_MAX) {
+            LOG_W("[对焦] 回位校验%d次仍不合格(%.2f<最佳%.2f*0.9), 按当前位置结束",
+                  g_af.verify_cnt, current_sharpness, g_af.fine_best_sharpness);
+            auto_focus_finish();
+        } else {
+            /* 回位后清晰度显著偏低(回位偏差/假峰/漂移): 以当前点为中心就地补扫 */
+            g_af.verify_cnt++;
+            LOG_W("[对焦] 回位校验不合格 %.2f<最佳%.2f*0.9, 就地补扫[%d/%d]",
+                  current_sharpness, g_af.fine_best_sharpness,
+                  g_af.verify_cnt, AF_VERIFY_MAX);
+            auto_focus_enter_fine(g_af.current_pos, g_af.current_pos - AF_FINE_STEP);
+        }
+        break;
     }
 }
 
@@ -700,7 +917,7 @@ void report_takephoto_duration(void)
     rt_uint32_t duration_s = (rt_tick_get() - takephoto_start_tick) / RT_TICK_PER_SECOND;
     LOG_I("[拍照] 结束, 持续时间 %u 秒", duration_s);
     char duration_str[16];
-    rt_sprintf(duration_str, "%dS", duration_s);
+    rt_sprintf(duration_str, "%d 秒", duration_s);
     char *dur_warn = makeJson_Warn("takephoto_duration", duration_str);
     if(dur_warn != RT_NULL) {
         DTU_Write("%s", dur_warn);

+ 46 - 37
Application_cbd_apm32f1/drivers/drv_usart_v2.c

@@ -375,7 +375,19 @@ static rt_size_t stm32_transmit(struct rt_serial_device     *serial,
 
     if (uart->uart_dma_flag & RT_DEVICE_FLAG_DMA_TX)
     {
-        HAL_UART_Transmit_DMA(&uart->handle, buf, size);
+        if (HAL_UART_Transmit_DMA(&uart->handle, buf, size) != HAL_OK)
+        {
+            /* 启动失败(典型为 gState 卡在上次传输的 BUSY_TX): 中止残留传输后重试一次 */
+            HAL_UART_AbortTransmit(&uart->handle);
+            if (HAL_UART_Transmit_DMA(&uart->handle, buf, size) != HAL_OK)
+            {
+                /* 仍失败: 主动上报 TX_DMADONE, 防止 serial_v2 框架永久阻塞在 tx_cpt 上
+                 * (阻塞期间持有应用层互斥锁, 会导致该串口发送整体瘫痪) */
+                LOG_E("%s tx dma start failed, drop %d bytes", uart->config->name, size);
+                rt_hw_serial_isr(serial, RT_SERIAL_EVENT_TX_DMADONE);
+                return 0;
+            }
+        }
         return size;
     }
 
@@ -395,38 +407,24 @@ static void dma_recv_isr(struct rt_serial_device *serial, rt_uint8_t isr_flag)
     uart = rt_container_of(serial, struct stm32_uart, serial);
 
     level = rt_hw_interrupt_disable();
-    recv_len = 0;
     counter = __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
 
-    switch (isr_flag)
-    {
-    case UART_RX_DMA_IT_IDLE_FLAG:
-        if (counter <= uart->dma_rx.remaining_cnt)
-            recv_len = uart->dma_rx.remaining_cnt - counter;
-        else
-            recv_len = serial->config.rx_bufsz + uart->dma_rx.remaining_cnt - counter;
-        break;
+    /* 统一按环形距离计算新增数据量: (bufsz + 上次计数 - 当前计数) % bufsz
+     * 修复原 TC(回绕) 分支的竞态: ISR 被延迟(如片内 flash 擦写长时间关中断)时
+     * counter 已回绕越过 remaining_cnt, 原判断导致整段数据丢失且索引永久错位/多报重复 */
+    recv_len = (serial->config.rx_bufsz + uart->dma_rx.remaining_cnt - counter)
+               % serial->config.rx_bufsz;
 
-    case UART_RX_DMA_IT_HT_FLAG:
-        if (counter < uart->dma_rx.remaining_cnt)
-            recv_len = uart->dma_rx.remaining_cnt - counter;
-        break;
-
-    case UART_RX_DMA_IT_TC_FLAG:
-        if(counter >= uart->dma_rx.remaining_cnt)
-            recv_len = serial->config.rx_bufsz + uart->dma_rx.remaining_cnt - counter;
-
-    default:
-        break;
-    }
+    /* 无论 recv_len 是否为 0 都必须同步计数, 否则后续事件全部错算 */
+    uart->dma_rx.remaining_cnt = counter;
 
     if (recv_len)
     {
-        uart->dma_rx.remaining_cnt = counter;
         rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_DMADONE | (recv_len << 8));
     }
     rt_hw_interrupt_enable(level);
 
+    UNUSED(isr_flag);
 }
 #endif  /* RT_SERIAL_USING_DMA */
 
@@ -530,18 +528,8 @@ static void uart_isr(struct rt_serial_device *serial)
         {
             UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_CTS);
         }
-        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TXE) != RESET)
-        {
-            UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TXE);
-        }
-        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) != RESET)
-        {
-            UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TC);
-        }
-        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_RXNE) != RESET)
-        {
-            UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_RXNE);
-        }
+        /* 注意: 不在此清 TXE/TC/RXNE 正常收发标志 —— 极端时序下误清 TC 会导致
+         * DMA 发送完成回调丢失, 发送线程永久阻塞; RXNE 由 DMA/正常分支处理 */
     }
 }
 
@@ -1087,8 +1075,29 @@ void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
 {
     RT_ASSERT(huart != NULL);
     struct stm32_uart *uart = (struct stm32_uart *)huart;
-    LOG_D("%s: %s %d\n", __FUNCTION__, uart->config->name, huart->ErrorCode);
-    UNUSED(uart);
+    LOG_E("%s uart error: 0x%x", uart->config->name, huart->ErrorCode);
+
+    /* 复位 HAL 状态机: 否则 gState 卡在 BUSY 会导致后续发送全部失败且无任何日志 */
+    __HAL_UNLOCK(huart);
+    huart->gState    = HAL_UART_STATE_READY;
+    huart->RxState   = HAL_UART_STATE_READY;
+    huart->ErrorCode = HAL_UART_ERROR_NONE;
+
+#ifdef RT_SERIAL_USING_DMA
+    /* RX DMA 为循环模式常开: 若被错误中止则重启接收, 保证接收链路自愈 */
+    if (uart->uart_dma_flag & RT_DEVICE_FLAG_DMA_RX)
+    {
+        if (HAL_DMA_GetState(&uart->dma_rx.handle) != HAL_DMA_STATE_BUSY)
+        {
+            struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *)uart->serial.serial_rx;
+            if (rx_fifo != RT_NULL &&
+                HAL_UART_Receive_DMA(huart, rx_fifo->buffer, uart->serial.config.rx_bufsz) == HAL_OK)
+            {
+                uart->dma_rx.remaining_cnt = uart->serial.config.rx_bufsz;
+            }
+        }
+    }
+#endif
 }
 
 /**

Разница между файлами не показана из-за своего большого размера
+ 27 - 5
Application_cbd_apm32f1/readme.md


+ 1 - 1
CBD_FOTA_BootLoader/.settings/language.settings.xml

@@ -5,7 +5,7 @@
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
-			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="1369183061114295484" id="ilg.gnuarmeclipse.managedbuild.cross.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT ARM Cross GCC Built-in Compiler Settings " parameter="${COMMAND} ${FLAGS} ${cross_toolchain_flags} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="1302267756298846076" id="ilg.gnuarmeclipse.managedbuild.cross.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT ARM Cross GCC Built-in Compiler Settings " parameter="${COMMAND} ${FLAGS} ${cross_toolchain_flags} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
 				<language-scope id="org.eclipse.cdt.core.gcc"/>
 				<language-scope id="org.eclipse.cdt.core.g++"/>
 			</provider>