修复不关机补充

app.yaml

@@ -1,6 +1,6 @@
 id: t11
 name: t11
-version: 2.16.3
+version: 2.15.15
 author: t11
 icon: ''
 desc: t11
@@ -18,11 +18,14 @@ files:
   - laser_manager.py
   - logger_manager.py
   - main.py
+  - model_270139.cvimodel
+  - model_270139.mud
   - network.py
   - ota_curl.sh
   - ota_manager.py
   - power.py
   - server.pem
+  - set_autostart.py
   - shoot_manager.py
   - shot_id_generator.py
   - target_roi_yolo.py

at_client.py

@@ -76,11 +76,10 @@ class ATClient:
         """
         expect_b = expect.encode() if isinstance(expect, str) else expect
         with self._cmd_lock:
-            with self._q_lock:
-                # 初始化等待
-                self._waiting = True
-                self._expect = expect_b
-                self._resp = b""
+            # 初始化等待
+            self._waiting = True
+            self._expect = expect_b
+            self._resp = b""
 
             # 发送
             if cmd:
@@ -301,8 +300,8 @@ class ATClient:
                     if len(self._rx) > 512 * 1024:
                         self._rx = self._rx[-256 * 1024:]
                 else:
-                    if len(self._rx) > 32768:
-                        self._rx = self._rx[-16384:]
+                    if len(self._rx) > 16384:
+                        self._rx = self._rx[-4096:]
 
 
 

config.py

@@ -24,7 +24,7 @@ TRIANGLE_DETECT_SCALE = 0.4
 # SERVER_IP = "stcp.shelingxingqiu.com"
 SERVER_IP = "www.shelingxingqiu.com"
 SERVER_PORT = 50005
-HEARTBEAT_INTERVAL = 5  # 心跳间隔（秒）
+HEARTBEAT_INTERVAL = 15  # 心跳间隔（秒）
 
 # WiFi 质量评估（开机先尝试 WiFi；质量差且 4G 可用则切到 4G，本次上电直至关机锁定 4G）
 WIFI_QUALITY_RTT_SAMPLES = 3  # 到业务服务器 TCP 建连耗时采样次数，取中位数
@@ -317,7 +317,6 @@ MAX_CMD_THREADS = 10            # 并发命令线程上限（防止服务器下
 
 # ==================== 图像保存配置 ====================
 SAVE_IMAGE_ENABLED = False  # 是否保存图像（True=保存，False=不保存）
-SAVE_IMAGE_ON_FAILURE = True  # 检测失败时是否强制保存图像（供调试测试用）
 PHOTO_DIR = "/root/phot"    # 照片存储目录
 MAX_IMAGES = 1000
 # Stage2 调试目录（默认 PHOTO_DIR/stage2_roi）内 JPEG 最多保留张数；None 表示与 MAX_IMAGES 相同
@@ -342,7 +341,7 @@ PIN_MAPPINGS = {
 }
 
 # ==================== 电源配置 ====================
-AUTO_POWER_OFF_IN_SECONDS = 10 * 60  # 自动关机时间（秒），0表示不自动关机
+AUTO_POWER_OFF_IN_SECONDS = 0  # 自动关机时间（秒），0表示不自动关机
 
 BATTERY_SOC_LPF_ALPHA = 0.5
 BATTERY_SOC_AVG_WINDOW = 5

hardware.py

@@ -29,7 +29,7 @@ class HardwareManager:
         self._adc_obj = None             # ADC对象
         self._at_client = None            # AT客户端
 
-        self._last_active_time = 0       # 用于记录用户的最后一次活跃的时间
+        self._last_active_ticks = None   # 上次活跃时刻（ticks_ms，单调递增，不受校时影响）
         self._stop_timer = False         # 用于停止定时器的标志
 
         self._initialized = True
@@ -111,7 +111,7 @@ class HardwareManager:
 
     def start_idle_timer(self):
         self._stop_timer = False
-        self._last_active_time = time.time()
+        self._last_active_ticks = time.ticks_ms()
 
     def stop_idle_timer(self):
         self._stop_timer = True
@@ -119,12 +119,13 @@ class HardwareManager:
     def get_idle_time_in_sec(self):
         if self._stop_timer:
             return 0
-        diff = time.time() - self._last_active_time
-        if diff < 0:
-            # 时间可能被重置了，重新计时
-            self._last_active_time = time.time()
+        if self._last_active_ticks is None:
             return 0
-        return diff
+        diff_ms = time.ticks_diff(time.ticks_ms(), self._last_active_ticks)
+        if diff_ms < 0:
+            self._last_active_ticks = time.ticks_ms()
+            return 0
+        return diff_ms / 1000.0
 
 
 # 创建全局单例实例

main.py

@@ -120,9 +120,9 @@ def cmd_str():
 
     # ==================== 第二阶段：软件初始化 ====================
 
-    # 1. 初始化日志系统（WARNING级别，不打印/写入INFO和DEBUG日志，提高执行流畅度）
+    # 1. 初始化日志系统
     import logging
-    logger_manager.init_logging(log_level=logging.WARNING)
+    logger_manager.init_logging(log_level=logging.DEBUG)
     logger = logger_manager.logger
 
     # 补充：因为初始化的时候，激光会亮，先关了它
@@ -245,8 +245,8 @@ def cmd_str():
     # 4. 初始化设备ID（network_manager 内部会自动设置 device_id 和 password）
     network_manager.read_device_id()
 
-    # 5. 创建照片存储目录（如果启用图像保存或检测失败时强制保存）
-    if config.SAVE_IMAGE_ENABLED or getattr(config, "SAVE_IMAGE_ON_FAILURE", False):
+    # 5. 创建照片存储目录（如果启用图像保存）
+    if config.SAVE_IMAGE_ENABLED:
         photo_dir = config.PHOTO_DIR
         if photo_dir not in os.listdir("/root"):
             try:
@@ -275,45 +275,50 @@ def cmd_str():
     hardware_manager.start_idle_timer()
 
     if logger:
+        _auto_power_off = int(getattr(config, "AUTO_POWER_OFF_IN_SECONDS", 0) or 0)
+        if _auto_power_off <= 0:
+            logger.info("[MAIN] 自动关机已禁用 (AUTO_POWER_OFF_IN_SECONDS=0)")
+        else:
+            logger.info(f"[MAIN] 自动关机: {_auto_power_off} 秒无活动")
         logger.info("系统准备完成...")
 
     last_adc_trigger = 0
-    # 读取一次ADC初始值，防止开机时传感器已有压力导致误触发
-    try:
-        last_adc_val = hardware_manager.adc_obj.read()
-    except Exception:
-        last_adc_val = 0
-    peak_adc_val = 0  # 当前周期内的压力峰值
     # 气压采样：减少日志频率（每 N 个点输出一条），避免 logger.debug 拖慢采样
     PRESSURE_BATCH_SIZE = 100
 
     pressure_buf = []
     pressure_sum = 0
+    pressure_abs_sum = 0
     pressure_min = 4095
     pressure_max = 0
     pressure_t0_ms = None
+    last_avg_abs = 0
 
     def _flush_pressure_buf(reason: str):
-        nonlocal pressure_buf, pressure_sum, pressure_min, pressure_max, pressure_t0_ms, logger
+        nonlocal pressure_buf, pressure_sum, pressure_min, pressure_max, pressure_t0_ms, logger, pressure_abs_sum, last_avg_abs
         if not pressure_buf:
             return
         if config.AIR_PRESSURE_lOG:
             t1_ms = time.ticks_ms()
             n = len(pressure_buf)
             avg = (pressure_sum / n) if n else 0
+            avg_abs = (pressure_abs_sum / n) if n else 0
             line = (
                 f"[气压批量] reason={reason} "
                 f"t0={pressure_t0_ms} t1={t1_ms} n={n} "
-                f"min={pressure_min} max={pressure_max} avg={avg:.1f} "
+                f"min={pressure_min} max={pressure_max} avg={avg:.1f} avg_abs={avg_abs:.3f} "
                 f"values={','.join(map(str, pressure_buf))}"
+                f" convert value (kpa): {(max(pressure_buf, key=lambda x: x[1])[1] - last_avg_abs) / (5 - 2.5) * config.AIR_PRESSURE_HARDWARE_MAX:.1f}"
             )
             if logger:
                 logger.debug(line)
             else:
                 print(line)
+            last_avg_abs = avg_abs
         # 无论是否记录日志，都必须清空 buffer，否则内存泄漏
         pressure_buf = []
         pressure_sum = 0
+        pressure_abs_sum = 0
         pressure_min = 4095
         pressure_max = 0
         pressure_t0_ms = None
@@ -338,7 +343,10 @@ def cmd_str():
             # 不在 OTA 状态下，检测是否空闲足够长，自动关机
             # print(f"[MAIN] 空闲时间: {hardware_manager.get_idle_time_in_sec() }秒")
             # print(f"配置关机时间：{config.AUTO_POWER_OFF_IN_SECONDS} 秒")
-            if hardware_manager.get_idle_time_in_sec() > config.AUTO_POWER_OFF_IN_SECONDS:
+            if (
+                config.AUTO_POWER_OFF_IN_SECONDS > 0
+                and hardware_manager.get_idle_time_in_sec() > config.AUTO_POWER_OFF_IN_SECONDS
+            ):
                 logger.info("[MAIN] 超过设定时间未检测活动，自动关机")
                 network_manager.safe_enqueue({"poweroff": "超过设定时间未检测活动，自动关机"}, 2)
                 time.sleep_ms(100)
@@ -351,10 +359,12 @@ def cmd_str():
                 if network_manager.manual_trigger_flag:
                     network_manager.clear_manual_trigger()
                     adc_val = config.ADC_TRIGGER_THRESHOLD + 1
+                    adc_abs_val = 10
                     if logger:
                         logger.info("[TEST] TCP命令触发射箭")
                 else:
                     adc_val = hardware_manager.adc_obj.read()
+                    adc_abs_val = hardware_manager.adc_obj.read_vol()
             except Exception as e:
                 logger = logger_manager.logger
                 if logger:
@@ -365,29 +375,24 @@ def cmd_str():
             # ====== 气压采样缓存（每次循环都记录，批量输出日志）======
             if pressure_t0_ms is None:
                 pressure_t0_ms = current_time
-            pressure_buf.append(adc_val)
+            pressure_buf.append((adc_val, adc_abs_val))
             pressure_sum += adc_val
+            pressure_abs_sum += adc_abs_val
             if adc_val < pressure_min:
                 pressure_min = adc_val
             if adc_val > pressure_max:
                 pressure_max = adc_val
             if len(pressure_buf) >= PRESSURE_BATCH_SIZE:
                 _flush_pressure_buf("batch")
-            # 峰值检测：压力从峰值下降时触发，确保捕获到最大冲击时刻
-            if adc_val > peak_adc_val:
-                peak_adc_val = adc_val  # 更新峰值
-            if (peak_adc_val >= config.ADC_TRIGGER_THRESHOLD
-                    and adc_val < peak_adc_val
-                    and last_adc_val >= peak_adc_val):
-                # 封顶后下降沿触发：peak是最大值，当前值开始下降，且上次值还在peak位置
+            # if adc_val >= 2000:
+            # print(f"adc :{adc_val}")
+            if adc_val >= config.ADC_TRIGGER_THRESHOLD:
                 hardware_manager.start_idle_timer()  # 重新计时
                 diff_ms = current_time - last_adc_trigger
                 if diff_ms < 3000:
-                    peak_adc_val = 0  # 去抖期间重置峰值
-                    time.sleep_ms(5)
+                    logger.info(f"[MAIN] 扳机触发过于频繁, {diff_ms}ms")
                     continue
                 last_adc_trigger = current_time
-                peak_adc_val = 0  # 触发后重置峰值
                 # 触发前先把缓存刷出来，避免波形被长耗时处理截断
                 _flush_pressure_buf("before_trigger")
 
@@ -406,9 +411,10 @@ def cmd_str():
                     try:
                         camera_manager.show(camera_manager.read_frame())
                     except Exception as e:
-                        pass
+                        logger = logger_manager.logger
+                        if logger:
+                            logger.error(f"[MAIN] 显示异常: {e}")
                 time.sleep_ms(5)
-            last_adc_val = adc_val
 
         except Exception as e:
             # 主循环的顶层异常捕获，防止程序静默退出

network.py

@@ -18,7 +18,7 @@ import socket
 import config
 
 from hardware import hardware_manager
-from power import get_bus_voltage, voltage_to_percent, is_charging
+from power import get_bus_voltage, voltage_to_percent
 from logger_manager import logger_manager
 from wifi import wifi_manager
 import subprocess
@@ -624,11 +624,6 @@ class NetworkManager:
         password = inner_data.get("password")
         ota_res_url = inner_data.get("url")
         try:
-            for _f in ("/etc/wpa_supplicant.conf", "/boot/wpa_supplicant.conf", "/boot/wifi.ssid", "/boot/wifi.pass"):
-                try:
-                    os.remove(_f)
-                except OSError:
-                    pass
             w = network.wifi.Wifi()
             e = w.connect(ssid, password, wait=True, timeout=15)
             err.check_raise(e, "connect wifi failed")
@@ -669,14 +664,7 @@ class NetworkManager:
         self.logger.info(f"[conn wifi] cmd600 , data: {inner_data}")
         ssid = inner_data.get("ssid")
         password = inner_data.get("password")
-        # 停止旧的WiFi质量监测（无论当前是WiFi还是4G连接）
-        self._stop_wifi_quality_monitor()
         try:
-            for _f in ("/etc/wpa_supplicant.conf", "/boot/wpa_supplicant.conf", "/boot/wifi.ssid", "/boot/wifi.pass"):
-                try:
-                    os.remove(_f)
-                except OSError:
-                    pass
             w = network.wifi.Wifi()
             e = w.connect(ssid, password, wait=True, timeout=15)
             err.check_raise(e, "connect wifi failed")
@@ -690,11 +678,6 @@ class NetworkManager:
                 },
                 2,
             )
-            self._session_force_4g = False
-            self.disconnect_server()
-            self._tcp_connected = False
-            self._network_type = None
-            self.logger.info("[conn wifi] WiFi已连接，等待主循环重新登录")
         except Exception as e:
             self.logger.error(f"cmd600 失败: {e}")
             self.safe_enqueue(
@@ -723,7 +706,7 @@ class NetworkManager:
             if self._network_type == "wifi":
                 return self._check_wifi_connection()
             elif self._network_type == "4g":
-                return self._check_4g_connection()
+                return True  # 4G连接状态由AT命令维护
             return False
 
         # 自动选择网络
@@ -740,37 +723,6 @@ class NetworkManager:
             return self._connect_tcp_via_4g()
         return False
 
-    def _check_4g_connection(self):
-        """检查4G TCP连接是否仍然有效（通过查询PDP地址验证网络附着状态）"""
-        try:
-            atc = hardware_manager.at_client
-            if atc is None:
-                return False
-            if not self._uart4g_lock.acquire(timeout=3000):
-                # 获取锁超时说明有其他操作在进行，视为连接仍有效
-                return True
-            try:
-                r = atc.send("AT+CGPADDR=1", "OK", 3000)
-                m = re.search(r'\+CGPADDR:\s*1,"([^"]+)"', r)
-                ip = m.group(1) if m else ""
-                if ip and ip != "0.0.0.0":
-                    return True
-                # 无IP或IP无效，尝试重新激活PDP
-                self.logger.warning("[4G-TCP] PDP地址无效，尝试重新激活")
-                atc.send("AT+MIPCALL=1,1", "OK", 15000)
-                r2 = atc.send("AT+CGPADDR=1", "OK", 3000)
-                m2 = re.search(r'\+CGPADDR:\s*1,"([^"]+)"', r2)
-                ip2 = m2.group(1) if m2 else ""
-                if ip2 and ip2 != "0.0.0.0":
-                    return True
-                self.logger.error("[4G-TCP] 重新激活PDP仍无有效IP，连接已断开")
-                return False
-            finally:
-                self._uart4g_lock.release()
-        except Exception as e:
-            self.logger.warning(f"[4G-TCP] 连接检查异常: {e}")
-            return True  # 异常时不误判断线
-
     def _wrap_wifi_tls(self, plain_sock, hostname):
         """
         在已建立的 TCP socket 上做 TLS（WiFi 走主机 ssl 库；4G 仍用模组 AT+SSL）。
@@ -1118,8 +1070,6 @@ class NetworkManager:
                     total += n
 
                 hardware_manager.uart4g.write(b"\x1A")
-                with hardware_manager.at_client._q_lock:
-                    hardware_manager.at_client._rx = b""
                 r = hardware_manager.at_client.send("", "OK", 8000)
                 if ("SEND OK" in r) or ("OK" in r) or ("+MIPSEND" in r):
                     return True
@@ -1834,7 +1784,7 @@ class NetworkManager:
                     continue
 
                 if not self.connect_server():
-                    time.sleep_ms(1000)
+                    time.sleep_ms(5000)
                     continue
 
                 # 发送登录包
@@ -1855,7 +1805,7 @@ class NetworkManager:
                         self.disconnect_server()
                     except:
                         pass
-                    time.sleep_ms(500)
+                    time.sleep_ms(2000)
                     continue
 
                 self.logger.info("➡️ 登录包已发送，等待确认...")
@@ -2145,17 +2095,7 @@ class NetworkManager:
                                             "netType": self.network_type,
                                         }
                                         self.safe_enqueue(battery_data, 2)
-                                        self.logger.info(f"电量上报: {battery_percent}% 充电: {is_charging()}")
-                                        if is_charging():
-                                            self.safe_enqueue(
-                                                {
-                                                    "cmd": 700,
-                                                },
-                                                2,
-                                            )
-                                    elif inner_cmd == 700:
-                                        self.logger.warning("服务器下发关机！！！")
-                                        exit(-1)
+                                        self.logger.info(f"电量上报: {battery_percent}%")
                                     elif inner_cmd == 5:  # OTA 升级
                                         inner_data = data_obj.get("data", {}) if isinstance(data_obj, dict) else {}
                                         ssid = inner_data.get("ssid")
@@ -2208,7 +2148,7 @@ class NetworkManager:
                                                 self.logger.info(f"password: {password}")
                                                 ota_manager._start_update_thread()
                                                 self._spawn_cmd_thread(ota_manager.handle_wifi_and_update,
-                                                                       (ssid, password, ota_url))
+                                                                         (ssid, password, ota_url))
                                     elif inner_cmd == 6:
                                         try:
                                             ip = os.popen(
@@ -2354,8 +2294,8 @@ class NetworkManager:
                                     pass
                                 break
                             else:
-                                # 不立即断开，让下一轮心跳再试
-                                time.sleep_ms(50)
+                                # 不立即断开，让下一轮心跳再试；同时缩短一点等待，提升恢复速度
+                                time.sleep_ms(200)
                                 continue
                         else:
                             send_hartbeat_fail_count = 0
@@ -2385,8 +2325,8 @@ class NetworkManager:
                     self._send_event.clear()
 
                 self._tcp_connected = False
-                self.logger.error("连接异常，50ms后重连...")
-                time.sleep_ms(50)
+                self.logger.error("连接异常，2秒后重连...")
+                time.sleep_ms(200)
 
             except Exception as e:
                 # TCP主循环的顶层异常捕获，防止线程静默退出

shoot_manager.py

@@ -320,10 +320,8 @@ def process_shot(adc_val):
     logger = logger_manager.logger
 
     try:
-        frame = camera_manager.read_frame()
-
-        # 网络事件移到拍照之后，避免阻塞拍照
         network_manager.safe_enqueue({"shoot_event": "start"}, msg_type=2, high=True)
+        frame = camera_manager.read_frame()
 
         # 调用算法分析
         analysis_result = analyze_shot(frame)
@@ -520,7 +518,6 @@ def process_shot(adc_val):
             laser_manager.flash_laser(config.FLASH_LASER_DURATION_MS)
 
         # 保存图像（异步队列，与 main.py 一致）
-        _force_save = (dx is None and dy is None) and getattr(config, "SAVE_IMAGE_ON_FAILURE", False)
         enqueue_save_shot(
             result_img,
             center,
@@ -530,9 +527,8 @@ def process_shot(adc_val):
             (x, y),
             distance_m,
             shot_id=shot_id,
-            photo_dir=config.PHOTO_DIR if (config.SAVE_IMAGE_ENABLED or _force_save) else None,
+            photo_dir=config.PHOTO_DIR if config.SAVE_IMAGE_ENABLED else None,
             yolo_roi_xyxy=yolo_roi_xyxy if draw_yolo_roi else None,
-            force_save=_force_save,
         )
 
         if logger:

test/test_decect_circle_v4.py

@@ -154,11 +154,11 @@ def detect_circle_v3(frame, laser_point=None):
                                     max_r = max(red_radius, yellow_radius)
                                     size_ratio = min_r / max_r if max_r > 0 else 0
                                     print(f"Debug -> 圆心距={distance:.1f}(阈值={max_distance:.1f}), "
-                                          f"大小比={size_ratio:.2f}(阈值=0.4), "
-                                          f"距离OK={distance < max_distance}, 大小OK={size_ratio >= 0.4}")
+                                          f"大小比={size_ratio:.2f}(阈值=0.5), "
+                                          f"距离OK={distance < max_distance}, 大小OK={size_ratio > 0.5}")
 
                                     # 允许红圈在黄圈外侧或内侧，只要大小相近（较小/较大 >= 0.5）
-                                    if distance < max_distance and size_ratio >= 0.4:
+                                    if distance < max_distance and size_ratio > 0.5:
                                         found_valid_red = True
                                         print(
                                             f"[target] -> 找到匹配的红圈: 黄心({yellow_center}), 红心({red_center}), 距离:{distance:.1f}, 黄半径:{yellow_radius}, 红半径:{red_radius}")
@@ -598,7 +598,7 @@ if __name__ == "__main__":
 
     # 1. 设置要测试的图片路径
     # 建议将图片放在与脚本同级目录，或者使用绝对路径
-    TARGET_IMAGE = "/root/phot/shot_1830921_0_no_target.jpg"
+    TARGET_IMAGE = "/root/phot/None_314_258_0_0041.bmp"
 
     TARGET_DIR = "/root/phot"  # 修改为你想要读取的目录路径
 

version.md

@@ -26,6 +26,4 @@
 # 2.15.13 优化算法
 # 2.15.14 优化算法
 # 2.15.15 优化wifi连接
-# 2.15.16 修复wifi连接问题
-# 2.15.17 修复wifi连接问题
-# 2.15.18 wifi连接成功重新登录
+# 2.15.16 修复不关机，空闲计时改用 ticks_ms（不受校时影响），启动时打印自动关机配置

version.py

@@ -4,6 +4,6 @@
 应用版本号
 每次 OTA 更新时，只需要更新这个文件中的版本号
 """
-VERSION = '2.16.3'
+VERSION = '2.15.16'
 
 

vision.py

@@ -631,7 +631,7 @@ def detect_circle_v3(frame, laser_point=None, img_cv=None):
             min_r = min(rc["radius"], yellow_radius)
             max_r = max(rc["radius"], yellow_radius)
             size_ratio = min_r / max_r if max_r > 0 else 0
-            if dist_centers < max_dist and size_ratio >= 0.4:
+            if dist_centers < max_dist and size_ratio > 0.5:
                 if logger:
                     logger.info(f"[target] -> 找到匹配的红圈: 黄心({yellow_center}), "
                                 f"红心({rc['center']}), 距离:{dist_centers:.1f}, "
@@ -797,12 +797,12 @@ def estimate_pixel(physical_distance_cm, target_distance_m):
 
 def _save_shot_image_impl(img_cv, center, radius, method, ellipse_params,
                           laser_point, distance_m, shot_id=None, photo_dir=None,
-                          yolo_roi_xyxy=None, force_save=False):
+                          yolo_roi_xyxy=None):
     """
     内部实现：在 img_cv (numpy HWC RGB) 上绘制标注并保存。
     由 save_shot_image（同步）和存图 worker（异步）调用。
     """
-    if not config.SAVE_IMAGE_ENABLED and not force_save:
+    if not config.SAVE_IMAGE_ENABLED:
         return None
     if photo_dir is None:
         photo_dir = config.PHOTO_DIR
@@ -938,12 +938,11 @@ def start_save_shot_worker():
 
 def enqueue_save_shot(result_img, center, radius, method, ellipse_params,
                       laser_point, distance_m, shot_id=None, photo_dir=None,
-                      yolo_roi_xyxy=None, force_save=False):
+                      yolo_roi_xyxy=None):
     """
     将存图任务放入队列，由 worker 异步保存。主线程传入 result_img 的复制，不阻塞。
-    force_save=True 时，忽略 SAVE_IMAGE_ENABLED 配置强制保存（用于检测失败时的调试图像）。
     """
-    if not config.SAVE_IMAGE_ENABLED and not force_save:
+    if not config.SAVE_IMAGE_ENABLED:
         return
     if photo_dir is None:
         photo_dir = config.PHOTO_DIR
@@ -966,7 +965,6 @@ def enqueue_save_shot(result_img, center, radius, method, ellipse_params,
         shot_id,
         photo_dir,
         yolo_roi_xyxy,
-        force_save,
     )
     try:
         _save_queue.put_nowait(task)
@@ -978,12 +976,12 @@ def enqueue_save_shot(result_img, center, radius, method, ellipse_params,
 
 def save_shot_image(result_img, center, radius, method, ellipse_params,
                     laser_point, distance_m, shot_id=None, photo_dir=None,
-                    yolo_roi_xyxy=None, force_save=False):
+                    yolo_roi_xyxy=None):
     """
     保存射击图像（带标注）。同步调用，会阻塞。
     主流程建议使用 enqueue_save_shot；此处保留供校准、测试等场景使用。
     """
-    if not config.SAVE_IMAGE_ENABLED and not force_save:
+    if not config.SAVE_IMAGE_ENABLED:
         return None
     if photo_dir is None:
         photo_dir = config.PHOTO_DIR
@@ -1000,7 +998,6 @@ def save_shot_image(result_img, center, radius, method, ellipse_params,
             shot_id,
             photo_dir,
             yolo_roi_xyxy,
-            force_save,
         )
     except Exception as e:
         logger = logger_manager.logger