feat: 根据激光找出图片中心点坐标

.idea/.gitignore

@@ -0,0 +1,8 @@
+# 默认忽略的文件
+/shelf/
+/workspace.xml
+# 基于编辑器的 HTTP 客户端请求
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/.name

@@ -0,0 +1 @@
+network.py

.idea/archery.iml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module version="4">
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.13 virtualenv at H:\iot\racingiot_v1\.venv" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="maixcam" project-jdk-type="Python SDK" />
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-    "cmake.sourceDirectory": "E:/code/code/code/new/new/new/new/new/nw/archery - 副本/cpp_ext"
-}

4g.py

@@ -109,7 +109,6 @@
 from maix import app, uart, pinmap, time
 import hashlib
 import hmac
-import re
 import ujson
 
 # ========== 配置 ==========
@@ -131,109 +130,53 @@ def generate_token(device_id):
     return "Arrow_" + hmac.new((SALT + device_id).encode(), SALT2.encode(), hashlib.sha256).hexdigest()
 
 def send_cmd(cmd_str, timeout_ms=3000):
-    """发送 AT 指令并返回完整响应；超时返回已收到的内容。"""
+    """发送 AT 指令并等待 OK / ERROR"""
     print("[AT] =>", cmd_str)
     http_serial.write((cmd_str + "\r\n").encode())
     buffer = b""
     start = time.ticks_ms()
-    while time.ticks_diff(time.ticks_ms(), start) < timeout_ms:
+    while time.ticks_ms() - start < timeout_ms:
         data = http_serial.read(128)
         if data:
             buffer += data
             try:
-                decoded = buffer.decode("utf-8", "ignore")
-                if "OK" in decoded or "+CME ERROR" in decoded or "ERROR" in decoded:
-                    print("[AT] <=", decoded.strip())
-                    return decoded
+                decoded = buffer.decode()
+                print("<= ", decoded.strip())
+                if "OK" in decoded:
+                    return True
+                if "+CME ERROR" in decoded or "ERROR" in decoded:
+                    return False
             except:
                 pass
         time.sleep_ms(10)
-    decoded = buffer.decode("utf-8", "ignore")
-    print("[AT] !! timeout", timeout_ms, "ms, response:", decoded.strip() or "<empty>")
-    return decoded
-
-
-def response_ok(response):
-    return "OK" in response and "ERROR" not in response
-
-
-def wait_modem_ready():
-    """等待模组响应，并确认 PDP 上下文已经获得 IP。"""
-    for attempt in range(15):
-        if response_ok(send_cmd("AT", 1000)):
-            break
-        print("[4G] 等待模组启动", attempt + 1, "/15")
-        time.sleep_ms(1000)
-    else:
-        print("[4G] UART2 无 AT 响应，请检查模组供电、A28/A29 接线和串口占用")
-        return False
-
-    send_cmd("ATE0", 1000)
-    cpin = send_cmd("AT+CPIN?", 3000)
-    if "READY" not in cpin:
-        print("[4G] SIM 卡未就绪:", cpin.strip())
-        return False
-
-    addr = send_cmd("AT+CGPADDR=1", 3000)
-    match = re.search(r'\+CGPADDR:\s*1,"([^\"]+)"', addr)
-    if match and match.group(1) != "0.0.0.0":
-        print("[4G] PDP ready, IP:", match.group(1))
-        return True
-
-    send_cmd("AT+MIPCALL=1,1", 15000)
-    for _ in range(20):
-        addr = send_cmd("AT+CGPADDR=1", 3000)
-        match = re.search(r'\+CGPADDR:\s*1,"([^\"]+)"', addr)
-        if match and match.group(1) != "0.0.0.0":
-            print("[4G] PDP ready, IP:", match.group(1))
-            return True
-        time.sleep_ms(1000)
-
-    print("[4G] PDP 未获得 IP，请检查 SIM 流量、信号和 APN")
     return False
 
-
-def clear_http_instances():
-    for instance_id in range(6):
-        send_cmd(f"AT+MHTTPDEL={instance_id}", 1200)
-
 def create_http_instance(url):
     cmd = f'AT+MHTTPCREATE="{url}"'
-    response = send_cmd(cmd, 8000)
-    match = re.search(r"\+MHTTPCREATE:\s*(\d+)", response)
-    if not response_ok(response) or not match:
-        print("❌ 创建 HTTP 实例失败，模组响应:", response.strip() or "<empty>")
-        return None
-    return int(match.group(1))
+    if send_cmd(cmd):
+        # 尝试提取 instance ID（如果模块返回）
+        # 注意：部分模块不会返回 ID，可忽略，直接用 0 或 1
+        return True
+    return False
 
 def send_http_request(url, api_path, token, device_id, json_data):
     # 1. 创建 HTTP 实例
-    instance_id = create_http_instance(url)
-    if instance_id is None:
+    if not create_http_instance(url):
+        print("❌ 创建 HTTP 实例失败")
         return False
 
-    # 2. 设置 Headers
-    commands = (
-        f'AT+MHTTPCFG="header",{instance_id},"Content-Type: application/json"',
-        f'AT+MHTTPCFG="header",{instance_id},"Authorization: {token}"',
-        f'AT+MHTTPCFG="header",{instance_id},"DeviceId: {device_id}"',
-    )
-    for command in commands:
-        if not response_ok(send_cmd(command)):
-            print("❌ HTTP Header 配置失败")
-            send_cmd(f"AT+MHTTPDEL={instance_id}", 2000)
-            return False
+    # 2. 设置 Headers（假设实例 ID 为 0，或根据模块默认）
+    instance_id = 0  # 大多数模块默认实例为 0；若支持多实例，需解析返回值
+    send_cmd(f'AT+MHTTPCFG="header",{instance_id},"Content-Type: application/json"')
+    send_cmd(f'AT+MHTTPCFG="header",{instance_id},"Authorization: {token}"')
+    send_cmd(f'AT+MHTTPCFG="header",{instance_id},"DeviceId: {device_id}"')
 
     # 3. 发送 Body
     json_str = ujson.dumps(json_data)
-    at_json = json_str.replace("\\", "\\\\").replace('"', '\\"')
-    if not response_ok(send_cmd(f'AT+MHTTPCONTENT={instance_id},0,0,"{at_json}"', 8000)):
-        print("❌ HTTP Body 配置失败")
-        send_cmd(f"AT+MHTTPDEL={instance_id}", 2000)
-        return False
+    send_cmd(f'AT+MHTTPCONTENT={instance_id},0,0,"{json_str}"')
 
     # 4. 发起 POST 请求
-    if response_ok(send_cmd(f'AT+MHTTPREQUEST={instance_id},2,0,"{api_path}"', 15000)):
+    if send_cmd(f'AT+MHTTPREQUEST={instance_id},2,0,"{api_path}"'):
         print("✅ HTTP 请求已发送")
         return True
     else:
@@ -256,7 +199,7 @@ def read_response(timeout_ms=5000):
 print("🚀 启动直接上传流程...")
 
 token = generate_token(device_id)
-print("🔑 Token 已生成:", token[:12] + "...")
+print("🔑 Token:", token)
 
 # 构造模拟数据
 timestamp = int(time.time() * 1000)
@@ -273,14 +216,7 @@ json_data = {
 }
 
 # 执行上传
-upload_ok = False
-if not wait_modem_ready():
-    print("💥 4G 模组未就绪")
-else:
-    clear_http_instances()
-    upload_ok = send_http_request(url, api_path, token, device_id, json_data)
-
-if upload_ok:
+if send_http_request(url, api_path, token, device_id, json_data):
     read_response()
 else:
     print("💥 上传流程失败")

4g_download_manager.py

@@ -0,0 +1,403 @@
+import re
+import hashlib
+import binascii
+from maix import time
+from power import get_bus_voltage, voltage_to_percent
+from urllib.parse import urlparse
+from hardware import hardware_manager
+
+
+class DownloadManager4G:
+    """4g下载管理器（单例）"""
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(DownloadManager4G, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+
+        # 私有状态
+        self.FRAG_SIZE = 1024
+        self.FRAG_DELAY = 10
+        self._initialized = True
+
+    def _log(self, *a):
+        if debug:
+            self.logger.debug(" ".join(str(x) for x in a))
+
+    def _pwr_log(self, prefix=""):
+        """debug 用：输出电压/电量"""
+        if not debug:
+            return
+        try:
+            v = get_bus_voltage()
+            p = voltage_to_percent(v)
+            self.logger.debug(f"[PWR]{prefix} v={v:.3f}V p={p}%")
+        except Exception as e:
+            try:
+                self.logger.debug(f"[PWR]{prefix} read_failed: {e}")
+            except:
+                pass
+
+    def _clear_http_events(self):
+        if hardware_manager.at_client:
+            while hardware_manager.at_client.pop_http_event() is not None:
+                pass
+
+    def _parse_httpid(self, resp: str):
+        m = re.search(r"\+MHTTPCREATE:\s*(\d+)", resp)
+        return int(m.group(1)) if m else None
+
+    def _get_ip(self, ):
+        r = hardware_manager.at_client.send("AT+CGPADDR=1", "OK", 3000)
+        m = re.search(r'\+CGPADDR:\s*1,"([^"]+)"', r)
+        return m.group(1) if m else ""
+
+    def _ensure_pdp(self, ):
+        ip = self._get_ip()
+        if ip and ip != "0.0.0.0":
+            return True, ip
+        hardware_manager.at_client.send("AT+MIPCALL=1,1", "OK", 15000)
+        for _ in range(10):
+            ip = self._get_ip()
+            if ip and ip != "0.0.0.0":
+                return True, ip
+            time.sleep(1)
+        return False, ip
+
+    def _extract_hdr_fields(self, hdr_text: str):
+        mlen = re.search(r"Content-Length:\s*(\d+)", hdr_text, re.IGNORECASE)
+        clen = int(mlen.group(1)) if mlen else None
+        mmd5 = re.search(r"Content-Md5:\s*([A-Za-z0-9+/=]+)", hdr_text, re.IGNORECASE)
+        md5_b64 = mmd5.group(1).strip() if mmd5 else None
+        return clen, md5_b64
+
+    def _extract_content_range(self, hdr_text: str):
+        m = re.search(r"Content-Range:\s*bytes\s*(\d+)\s*-\s*(\d+)\s*/\s*(\d+)", hdr_text, re.IGNORECASE)
+        if not m:
+            return None, None, None
+        try:
+            return int(m.group(1)), int(m.group(2)), int(m.group(3))
+        except:
+            return None, None, None
+
+    def _hard_reset_http(self, ):
+        """模块进入"坏状态"时的保守清场"""
+        self._clear_http_events()
+        for i in range(0, 6):
+            try:
+                hardware_manager.at_client.send(f"AT+MHTTPDEL={i}", "OK", 1200)
+            except:
+                pass
+        self._clear_http_events()
+
+    def _create_httpid(self, full_reset=False):
+        self._clear_http_events()
+        if hardware_manager.at_client:
+            hardware_manager.at_client.flush()
+        if full_reset:
+            self._hard_reset_http()
+        resp = hardware_manager.at_client.send(f'AT+MHTTPCREATE="{base_url}"', "OK", 8000)
+        hid = self._parse_httpid(resp)
+        if self._is_https:
+            resp = hardware_manager.at_client.send(f'AT+MHTTPCFG="ssl",{hid},1,1', "OK", 2000)
+            if "ERROR" in resp or "CME ERROR" in resp:
+                self.logger.error(f"MHTTPCFG SSL failed: {resp}")
+                # 尝试https 降级到http
+                downgraded_base_url = base_url.replace("https://", "http://")
+                resp = hardware_manager.at_client.send(f'AT+MHTTPCREATE="{downgraded_base_url}"', "OK", 8000)
+                hid = self._parse_httpid(resp)
+
+        return hid, resp
+
+    def _fetch_range_into_buf(self, start, want_len, out_buf, path, full_reset=False):
+        """
+        请求 Range [start, start+want_len)，写入 out_buf（bytearray，长度=want_len）
+        返回 (ok, msg, total_len, md5_b64, got_len)
+        """
+        end_incl = start + want_len - 1
+        hid, cresp = self._create_httpid(full_reset=full_reset)
+        if hid is None:
+            return False, f"MHTTPCREATE failed: {cresp}", None, None, 0
+
+        # 降低 URC 压力（分片/延迟）
+        hardware_manager.at_client.send(f'AT+MHTTPCFG="fragment",{hid},{self.FRAG_SIZE},{self.FRAG_DELAY}', "OK", 1500)
+        # 设置 Range header（inclusive）
+        hardware_manager.at_client.send(f'AT+MHTTPCFG="header",{hid},"Range: bytes={start}-{end_incl}"', "OK", 3000)
+
+        req = hardware_manager.at_client.send(f'AT+MHTTPREQUEST={hid},1,0,"{path}"', "OK", 15000)
+        if "ERROR" in req or "CME ERROR" in req:
+            hardware_manager.at_client.send(f"AT+MHTTPDEL={hid}", "OK", 2000)
+            return False, f"MHTTPREQUEST failed: {req}", None, None, 0
+
+        # 等 header + content
+        hdr_text = None
+        hdr_accum = ""
+        code = None
+        resp_total = None
+        total_len = None
+        md5_b64 = None
+
+        got_ranges = set()
+        last_sum = 0
+        t0 = time.ticks_ms()
+        timeout_ms = 9000
+        logged_hdr = False
+
+        while time.ticks_ms() - t0 < timeout_ms:
+            ev = hardware_manager.at_client.pop_http_event() if hardware_manager.at_client else None
+            if not ev:
+                time.sleep_ms(5)
+                continue
+
+            if ev[0] == "header":
+                _, ehid, ecode, ehdr = ev
+                if ehid != hid:
+                    continue
+                code = ecode
+                hdr_text = ehdr
+                if ehdr:
+                    hdr_accum = (hdr_accum + "\n" + ehdr) if hdr_accum else ehdr
+
+                resp_total_tmp, md5_tmp = self._extract_hdr_fields(hdr_accum)
+                if md5_tmp:
+                    md5_b64 = md5_tmp
+                cr_s, cr_e, cr_total = self._extract_content_range(hdr_accum)
+                if cr_total is not None:
+                    total_len = cr_total
+                if resp_total_tmp is not None:
+                    resp_total = resp_total_tmp
+                elif resp_total is None and (cr_s is not None) and (cr_e is not None) and (cr_e >= cr_s):
+                    resp_total = (cr_e - cr_s + 1)
+                if (not logged_hdr) and (resp_total is not None or total_len is not None):
+                    self._log(f"[HDR] id={hid} code={code} clen={resp_total} cr={cr_s}-{cr_e}/{cr_total}")
+                    logged_hdr = True
+                continue
+
+            if ev[0] == "content":
+                _, ehid, _total, _sum, _cur, payload = ev
+                if ehid != hid:
+                    continue
+                if resp_total is None:
+                    resp_total = _total
+                if resp_total is None or resp_total <= 0:
+                    continue
+                start_rel = _sum - _cur
+                end_rel = _sum
+                if start_rel < 0 or start_rel >= resp_total:
+                    continue
+                if end_rel > resp_total:
+                    end_rel = resp_total
+                actual_len = min(len(payload), end_rel - start_rel)
+                if actual_len <= 0:
+                    continue
+                out_buf[start_rel:start_rel + actual_len] = payload[:actual_len]
+                got_ranges.add((start_rel, start_rel + actual_len))
+                if _sum > last_sum:
+                    last_sum = _sum
+                if debug and (last_sum >= resp_total or (last_sum % 512 == 0)):
+                    self._log(f"[CHUNK] {start}+{last_sum}/{resp_total}")
+
+                if last_sum >= resp_total:
+                    break
+
+        # 清理实例（快路径：只删当前 hid）
+        try:
+            hardware_manager.at_client.send(f"AT+MHTTPDEL={hid}", "OK", 2000)
+        except:
+            pass
+
+        if resp_total is None:
+            return False, "no_header_or_total", total_len, md5_b64, 0
+
+        # 计算实际填充长度
+        merged = sorted(got_ranges)
+        merged2 = []
+        for s, e in merged:
+            if not merged2 or s > merged2[-1][1]:
+                merged2.append((s, e))
+            else:
+                merged2[-1] = (merged2[-1][0], max(merged2[-1][1], e))
+        filled = sum(e - s for s, e in merged2)
+
+        if filled < resp_total:
+            return False, f"incomplete_chunk got={filled} expected={resp_total} code={code}", total_len, md5_b64, filled
+
+        got_len = resp_total
+        return True, "OK", total_len, md5_b64, got_len
+
+    def download_file_via_4g(self, url, filename,
+                             total_timeout_ms=600000,
+                             retries=3,
+                             debug=False):
+        """
+        ML307R HTTP 下载（更稳的"固定小块 Range 顺序下载"，基于main109.py）：
+        - 只依赖 +MHTTPURC:"header"/"content"（不依赖 MHTTPREAD/cached）
+        - 每次只请求一个小块 Range（默认 10240B），失败就重试同一块，必要时缩小块大小
+        - 每个 chunk 都重新 MHTTPCREATE/MHTTPREQUEST，避免卡在"206 header 但不吐 content"的坏状态
+        - 使用二进制模式下载，确保文件完整性
+        """
+
+
+        # 小块策略（与main109.py保持一致）
+        CHUNK_MAX = 10240
+        CHUNK_MIN = 128
+        CHUNK_RETRIES = 12
+
+
+        t_func0 = time.ticks_ms()
+
+        parsed = urlparse(url)
+        host = parsed.hostname
+        path = parsed.path or "/"
+        if parsed.query:
+            path = f"{path}?{parsed.query}"
+        if parsed.fragment:
+            path = f"{path}#{parsed.fragment}"
+        if not host:
+            return False, "bad_url (no host)"
+
+        if isinstance(url, str) and url.startswith("https://static.shelingxingqiu.com/"):
+            base_url = "https://static.shelingxingqiu.com"
+            # TODO：使用https，看看是否能成功
+            self._is_https = True
+        else:
+            base_url = f"http://{host}"
+            self._is_https = False
+
+
+        try:
+            self._begin_ota()
+        except:
+            pass
+
+        from network import network_manager
+        with network_manager.get_uart_lock():
+            try:
+                ok_pdp, ip = self._ensure_pdp()
+                if not ok_pdp:
+                    return False, f"PDP not ready (ip={ip})"
+
+                # 先清空旧事件，避免串台
+                self._clear_http_events()
+
+                # 为了支持随机写入，先创建空文件
+                try:
+                    with open(filename, "wb") as f:
+                        f.write(b"")
+                except Exception as e:
+                    return False, f"open_file_failed: {e}"
+
+                total_len = None
+                expect_md5_b64 = None
+
+                offset = 0
+                chunk = CHUNK_MAX
+                t_start = time.ticks_ms()
+                last_progress_ms = t_start
+                STALL_TIMEOUT_MS = 60000
+                last_pwr_ms = t_start
+                self._pwr_log(prefix=" ota_start")
+                bad_http_state = 0
+
+                while True:
+                    now = time.ticks_ms()
+                    if debug and time.ticks_diff(now, last_pwr_ms) >= 5000:
+                        last_pwr_ms = now
+                        self._pwr_log(prefix=f" off={offset}/{total_len or '?'}")
+                    if time.ticks_diff(now, t_start) > total_timeout_ms:
+                        return False, f"timeout overall after {total_timeout_ms}ms offset={offset} total={total_len}"
+
+                    if time.ticks_diff(now, last_progress_ms) > STALL_TIMEOUT_MS:
+                        return False, f"timeout stalled {STALL_TIMEOUT_MS}ms offset={offset} total={total_len}"
+
+                    if total_len is not None and offset >= total_len:
+                        break
+
+                    want = chunk
+                    if total_len is not None:
+                        remain = total_len - offset
+                        if remain <= 0:
+                            break
+                        if want > remain:
+                            want = remain
+
+                    # 本 chunk 的 buffer（长度=want）
+                    buf = bytearray(want)
+
+                    success = False
+                    last_err = "unknown"
+                    md5_seen = None
+                    got_len = 0
+                    for k in range(1, CHUNK_RETRIES + 1):
+                        do_full_reset = (bad_http_state >= 2)
+                        ok, msg, tlen, md5_b64, got = self._fetch_range_into_buf(offset, want, buf, base_url, path, full_reset=do_full_reset)
+                        last_err = msg
+                        if tlen is not None and total_len is None:
+                            total_len = tlen
+                        if md5_b64 and not expect_md5_b64:
+                            expect_md5_b64 = md5_b64
+                        if ok:
+                            success = True
+                            got_len = got
+                            bad_http_state = 0
+                            break
+
+                        try:
+                            if ("no_header_or_total" in msg) or ("MHTTPREQUEST failed" in msg) or (
+                                    "MHTTPCREATE failed" in msg):
+                                bad_http_state += 1
+                            else:
+                                bad_http_state = max(0, bad_http_state - 1)
+                        except:
+                            pass
+
+                        if chunk > CHUNK_MIN:
+                            chunk = max(CHUNK_MIN, chunk // 2)
+                            want = min(chunk, want)
+                            buf = bytearray(want)
+                        self._log(f"[RETRY] off={offset} want={want} try={k} err={msg}")
+                        self._pwr_log(prefix=f" retry{k} off={offset}")
+                        time.sleep_ms(120)
+
+                    if not success:
+                        return False, f"chunk_failed off={offset} want={want} err={last_err} total={total_len}"
+
+                    # 写入文件（二进制模式）
+                    try:
+                        with open(filename, "r+b") as f:
+                            f.seek(offset)
+                            f.write(bytes(buf))
+                    except Exception as e:
+                        return False, f"write_failed off={offset}: {e}"
+
+                    offset += len(buf)
+                    last_progress_ms = time.ticks_ms()
+                    chunk = CHUNK_MAX
+                    if debug:
+                        self._log(f"[OK] offset={offset}/{total_len or '?'}")
+
+                # MD5 校验
+                if expect_md5_b64 and hashlib is not None:
+                    try:
+                        with open(filename, "rb") as f:
+                            data = f.read()
+                        digest = hashlib.md5(data).digest()
+                        got_b64 = binascii.b2a_base64(digest).decode().strip()
+                        if got_b64 != expect_md5_b64:
+                            return False, f"md5_mismatch got={got_b64} expected={expect_md5_b64}"
+                        self.logger.debug(f"[4G-DL] MD5 verified: {got_b64}")
+                    except Exception as e:
+                        return False, f"md5_check_failed: {e}"
+
+                t_cost = time.ticks_diff(time.ticks_ms(), t_func0)
+                self.logger.info(f"[4G-DL] download complete: size={offset} ip={ip} cost_ms={t_cost}")
+                return True, f"OK size={offset} ip={ip} cost_ms={t_cost}"
+
+            finally:
+                self._end_ota()

4g_upload_manager.py

@@ -0,0 +1,450 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+4G Image Upload Manager
+Uploads images to Qiniu cloud via ML307R 4G module TCP socket (MIPOPEN + MIPSEND).
+
+AT Command Sequence (ML307R TCP socket POST):
+  AT+MIPCALL=1,1                                  // Ensure PDP context active
+  AT+MIPCLOSE=<id>                                // Close old socket (ignore error)
+  AT+MIPOPEN=<id>,"TCP","<host>",80              // Open TCP socket
+  // Wait for +MIPOPEN: <id>,0 (success)
+  AT+MIPSEND=<id>,<len>                           // Send data
+  // Wait for ">" prompt, then write raw bytes
+  // Repeat MIPSEND for all chunks
+  // Wait for +MIPURC: "rtcp" response
+  AT+MIPCLOSE=<id>                                // Close socket
+"""
+
+import re
+import os
+import json
+from maix import time
+from urllib.parse import urlparse
+from logger_manager import logger_manager
+from hardware import hardware_manager
+
+# Multipart form boundary (simple alphanumeric to avoid AT command parser issues)
+BOUNDARY = "QiniuFormBoundary" + hex(int(time.time()))[2:]
+# Chunk size for MIPSEND (max 1024 to avoid AT line buffer limits)
+SEND_CHUNK = 1024
+# Socket ID for upload (dedicated to avoid conflict with main app TCP)
+UPLOAD_SOCK_ID = 3
+
+
+class FourGUploadManager:
+    """4G image upload manager using ML307R TCP socket (MIPOPEN + MIPSEND)"""
+
+    def __init__(self, at_client):
+        """Initialize with AT client instance"""
+        self.at = at_client
+        self.logger = logger_manager.logger
+
+    # ------------------------------------------------------------------ logging
+    def _log(self, msg):
+        try:
+            self.logger.debug("[4G-UL] " + msg)
+        except Exception:
+            print("[4G-UL] " + msg)
+
+    def _log_info(self, msg):
+        try:
+            self.logger.info("[4G-UL] " + msg)
+        except Exception:
+            print("[4G-UL] " + msg)
+
+    def _log_error(self, msg):
+        try:
+            self.logger.error("[4G-UL] " + msg)
+        except Exception:
+            print("[4G-UL] " + msg)
+
+    # --------------------------------------------------------------- helpers
+    def _ensure_pdp(self):
+        """Ensure PDP context is active; returns (ok, ip)"""
+        r = self.at.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
+        self.at.send("AT+MIPCALL=1,1", "OK", 15000)
+        for _ in range(10):
+            r = self.at.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
+            time.sleep(1)
+        return False, ip
+
+    def _is_error(self, resp):
+        """Check AT response for any error indicators"""
+        return "ERROR" in resp or "CME ERROR" in resp
+
+    # --------------------------------------------------------- multipart body
+    def _build_multipart_body(self, image_path, upload_token, key):
+        """
+        Build multipart/form-data body as bytes for Qiniu upload.
+
+        Fields:
+          - token : Qiniu upload token
+          - key   : object key in bucket
+          - file  : binary image data
+        """
+        boundary = BOUNDARY.encode()
+
+        with open(image_path, "rb") as f:
+            file_data = f.read()
+
+        filename = os.path.basename(image_path)
+        ext = os.path.splitext(image_path)[1].lower()
+        ct_map = {
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".bmp": "image/bmp",
+            ".webp": "image/webp",
+        }
+        content_type = ct_map.get(ext, "application/octet-stream")
+
+        body = bytearray()
+
+        # -- token field --
+        body += b"--" + boundary + b"\r\n"
+        body += b'Content-Disposition: form-data; name="token"\r\n'
+        body += b"\r\n"
+        body += upload_token.encode("utf-8") + b"\r\n"
+
+        # -- key field --
+        body += b"--" + boundary + b"\r\n"
+        body += b'Content-Disposition: form-data; name="key"\r\n'
+        body += b"\r\n"
+        body += key.encode("utf-8") + b"\r\n"
+
+        # -- file field --
+        body += b"--" + boundary + b"\r\n"
+        body += (
+            b'Content-Disposition: form-data; name="file"; filename="'
+            + filename.encode("utf-8")
+            + b'"\r\n'
+        )
+        body += b"Content-Type: " + content_type.encode("utf-8") + b"\r\n"
+        body += b"\r\n"
+        body += file_data + b"\r\n"
+
+        # -- closing boundary --
+        body += b"--" + boundary + b"--\r\n"
+
+        return bytes(body)
+
+    # --------------------------------------------------- TCP socket helpers
+    def _close_socket(self, sock_id):
+        """Close socket, ignore CME ERROR 55 (already closed)"""
+        try:
+            resp = self.at.send("AT+MIPCLOSE=" + str(sock_id), "OK", 5000)
+            self._log("socket " + str(sock_id) + " closed: " + resp)
+        except Exception as e:
+            # Ignore CME ERROR 55 (socket not open)
+            self._log("socket close (may already be closed): " + str(e))
+
+    def _open_socket(self, sock_id, host, port):
+        """
+        Open TCP socket to host:port.
+        Returns (success, error_msg)
+        """
+        cmd = 'AT+MIPOPEN=' + str(sock_id) + ',"TCP","' + host + '",' + str(port)
+        resp = self.at.send(cmd, "OK", 15000)
+
+        if self._is_error(resp):
+            return False, "MIPOPEN failed: " + resp
+
+        # Wait for +MIPOPEN: <id>,0 (success) or +MIPOPEN: <id>,<error_code>
+        # The URC may come in the same response or separately
+        mipopen_pattern = r"\+MIPOPEN:\s*" + str(sock_id) + r",(\d+)"
+        m = re.search(mipopen_pattern, resp)
+
+        if m:
+            result_code = int(m.group(1))
+            if result_code == 0:
+                return True, ""
+            else:
+                return False, "MIPOPEN error code: " + str(result_code)
+
+        # If not in initial response, wait for URC
+        try:
+            urc_resp = self.at.send("", "+MIPOPEN:", 15000)
+            m = re.search(mipopen_pattern, urc_resp)
+            if m:
+                result_code = int(m.group(1))
+                if result_code == 0:
+                    return True, ""
+                else:
+                    return False, "MIPOPEN error code: " + str(result_code)
+        except Exception as e:
+            return False, "MIPOPEN URC timeout: " + str(e)
+
+        return False, "MIPOPEN no response"
+
+    def _send_chunk(self, sock_id, chunk):
+        """
+        Send a single chunk via MIPSEND.
+        Thread safety is provided by the outer network_manager.get_uart_lock().
+        NOTE: Do NOT add self.at._cmd_lock here — self.at.send() already
+        acquires it internally and threading.Lock is not reentrant.
+        Returns (success, error_msg)
+        """
+        chunk_len = len(chunk)
+
+        # Step 1: Send AT+MIPSEND command and wait for ">" prompt
+        cmd = "AT+MIPSEND=" + str(sock_id) + "," + str(chunk_len)
+        try:
+            resp = self.at.send(cmd, ">", 3000)
+            if ">" not in resp:
+                return False, "MIPSEND no > prompt: " + resp
+        except Exception as e:
+            return False, "MIPSEND > prompt error: " + str(e)
+
+        # Step 2: Write raw binary bytes directly to UART
+        # Must be done immediately after ">" prompt, no lock re-acquisition
+        try:
+            self.at.uart.write(chunk)
+        except Exception as e:
+            return False, "MIPSEND write error: " + str(e)
+
+        # Step 3: Wait for OK or SEND OK confirmation
+        try:
+            confirm_resp = self.at.send("", "OK", 8000)
+            if self._is_error(confirm_resp):
+                return False, "MIPSEND confirmation error: " + confirm_resp
+        except Exception as e:
+            return False, "MIPSEND confirmation timeout: " + str(e)
+
+        return True, ""
+
+    def _send_data(self, sock_id, data):
+        """
+        Send data in chunks via MIPSEND.
+        Returns (success, error_msg)
+        """
+        total_len = len(data)
+        offset = 0
+        chunk_num = 0
+
+        while offset < total_len:
+            end = min(offset + SEND_CHUNK, total_len)
+            chunk = data[offset:end]
+
+            ok, err = self._send_chunk(sock_id, chunk)
+            if not ok:
+                return False, "Chunk " + str(chunk_num) + " failed: " + err
+
+            chunk_num += 1
+            offset = end
+
+            if chunk_num % 10 == 0 or offset >= total_len:
+                self._log(
+                    "send progress: "
+                    + str(offset) + "/" + str(total_len)
+                    + " bytes (" + str(chunk_num) + " chunks)"
+                )
+
+        self._log("all data sent: " + str(chunk_num) + " chunks, " + str(total_len) + " bytes")
+        return True, ""
+
+    def _wait_for_response(self, sock_id, timeout_ms=30000):
+        """
+        Wait for +MIPURC: "rtcp" response.
+        Returns (success, status_code, body, error_msg)
+        """
+        pattern = r'\+MIPURC:\s*"rtcp",\s*' + str(sock_id) + r',\s*(\d+),'
+        t0 = time.ticks_ms()
+
+        while time.ticks_diff(time.ticks_ms(), t0) < timeout_ms:
+            try:
+                # Try to get response with short timeout
+                resp = self.at.send("", "+MIPURC:", 1000)
+                m = re.search(pattern, resp)
+                if m:
+                    data_len = int(m.group(1))
+                    # Extract HTTP response data after the URC header
+                    # Format: +MIPURC: "rtcp",<sock_id>,<len>,<data>
+                    urc_end = resp.find("+MIPURC:")
+                    if urc_end >= 0:
+                        # Find the data after the length field
+                        match_end = m.end()
+                        http_data = resp[match_end:match_end + data_len]
+
+                        # Parse HTTP status line
+                        status_match = re.search(r"HTTP/\d\.\d\s+(\d+)", http_data)
+                        status_code = int(status_match.group(1)) if status_match else None
+
+                        # Extract body (after headers)
+                        header_end = http_data.find("\r\n\r\n")
+                        if header_end >= 0:
+                            body = http_data[header_end + 4:]
+                        else:
+                            body = http_data
+
+                        return True, status_code, body, ""
+            except Exception:
+                pass
+
+            time.sleep_ms(100)
+
+        return False, None, "", "Response timeout"
+
+    def _build_http_request(self, host, body_bytes):
+        """
+        Build full HTTP POST request as bytes.
+        """
+        headers = (
+            "POST / HTTP/1.1\r\n"
+            "Host: " + host + "\r\n"
+            "Content-Type: multipart/form-data; boundary=" + BOUNDARY + "\r\n"
+            "Content-Length: " + str(len(body_bytes)) + "\r\n"
+            "Connection: close\r\n"
+            "\r\n"
+        )
+        return headers.encode("utf-8") + body_bytes
+
+    # ============================================================ public API
+    def upload_file(self, file_path, upload_url, upload_token, key):
+        """Generic file upload to Qiniu cloud via 4G TCP socket POST.
+
+        Args:
+            file_path: Local path to any file
+            upload_url: Qiniu upload URL
+            upload_token: Qiniu upload token
+            key: File key in Qiniu bucket
+
+        Returns:
+            dict with 'success' bool and 'key'/'error' fields
+        """
+        return self.upload_image(file_path, upload_url, upload_token, key)
+
+    def upload_image(self, image_path, upload_url, upload_token, key):
+        """
+        Upload image to Qiniu cloud via 4G TCP socket POST.
+
+        Args:
+            image_path: Local path to image file
+            upload_url: Qiniu upload URL (e.g., "https://upload.qiniup.com")
+            upload_token: Qiniu upload token
+            key: File key in Qiniu (e.g., "shootPic/device01/shoot01.png")
+
+        Returns:
+            dict with 'success' bool and 'key'/'error' fields
+        """
+        if not self.at:
+            return {"success": False, "error": "AT client not available"}
+
+        if not os.path.exists(image_path):
+            return {"success": False, "error": "Image file not found: " + image_path}
+
+        # Force HTTP for 4G module (extract hostname, use port 80)
+        parsed = urlparse(upload_url)
+        host = parsed.hostname
+        if not host:
+            return {"success": False, "error": "Invalid upload URL: " + upload_url}
+
+        if upload_url.lower().startswith("https://"):
+            self._log_info("Converted HTTPS->HTTP for 4G module")
+
+        file_size = os.path.getsize(image_path)
+        self._log_info(
+            "upload: " + image_path + " (" + str(file_size) + "B) -> "
+            + host + " key=" + key
+        )
+
+        from network import network_manager
+        with network_manager.get_uart_lock():
+            try:
+                # ---- Step 1: Ensure PDP context ----
+                ok_pdp, ip = self._ensure_pdp()
+                if not ok_pdp:
+                    return {"success": False, "error": "PDP not ready (ip=" + str(ip) + ")"}
+
+                # ---- Step 2: Close old socket ----
+                self._close_socket(UPLOAD_SOCK_ID)
+
+                # ---- Step 3: Open TCP socket ----
+                ok, err = self._open_socket(UPLOAD_SOCK_ID, host, 80)
+                if not ok:
+                    return {"success": False, "error": "Socket open failed: " + err}
+
+                try:
+                    # ---- Step 4: Build multipart body and HTTP request ----
+                    body = self._build_multipart_body(image_path, upload_token, key)
+                    http_request = self._build_http_request(host, body)
+                    self._log("HTTP request size: " + str(len(http_request)) + " bytes")
+
+                    # ---- Step 5: Send data via MIPSEND ----
+                    ok, err = self._send_data(UPLOAD_SOCK_ID, http_request)
+                    if not ok:
+                        return {"success": False, "error": "Send failed: " + err}
+
+                    # ---- Step 6: Wait for response ----
+                    ok, status_code, resp_body, err = self._wait_for_response(UPLOAD_SOCK_ID)
+                    if not ok:
+                        return {"success": False, "error": "Response error: " + err}
+
+                    # ---- Step 7: Parse response ----
+                    if status_code is None:
+                        return {"success": False, "error": "No HTTP status in response"}
+
+                    if 200 <= status_code < 300:
+                        try:
+                            resp_json = json.loads(resp_body)
+                            resp_key = resp_json.get("key", key)
+                            self._log_info("upload success: key=" + resp_key + " code=" + str(status_code))
+                            return {"success": True, "key": resp_key}
+                        except Exception as e:
+                            self._log_error("response parse error: " + str(e))
+                            return {
+                                "success": True,
+                                "key": key,
+                                "raw": resp_body,
+                            }
+                    else:
+                        self._log_error(
+                            "HTTP error: code=" + str(status_code) + " body=" + resp_body[:200]
+                        )
+                        return {
+                            "success": False,
+                            "error": "HTTP " + str(status_code),
+                            "response": resp_body,
+                        }
+
+                finally:
+                    # ---- Step 8: Always close socket ----
+                    self._close_socket(UPLOAD_SOCK_ID)
+
+            except Exception as e:
+                self._log_error("upload exception: " + str(e))
+                return {"success": False, "error": str(e)}
+
+
+# ====================================================================== demo
+if __name__ == "__main__":
+    # Demo usage — requires actual ML307R 4G module hardware to run.
+    print("FourGUploadManager - requires ML307R 4G module hardware")
+    print()
+    print("Usage:")
+    print("  from hardware import hardware_manager")
+    print("  from at_client import ATClient")
+    print("  from maix import uart")
+    print()
+    print("  # Initialize UART and AT client (normally done in hardware init)")
+    print("  uart4g = uart.UART('/dev/ttyS1', 115200, ...)")
+    print("  at_client = ATClient(uart4g)")
+    print("  at_client.start()")
+    print()
+    print("  # Upload image to Qiniu")
+    print("  uploader = FourGUploadManager(at_client)")
+    print("  result = uploader.upload_image(")
+    print("      image_path='/maixapp/apps/t11/shoot.png',")
+    print("      upload_url='https://upload.qiniup.com',")
+    print("      upload_token='<qiniu_upload_token>',")
+    print("      key='shootPic/device01/shoot01.png'")
+    print("  )")
+    print("  print('Upload result:', result)")

Untitled

@@ -0,0 +1 @@
+v1.2.15.1] [ERROR] main.py:416 - [MAIN] 显示异常: 'LaserManager' object has no attribute 'remote_detect_tick'

adc.py

@@ -4,12 +4,12 @@ from maix import time
 a = adc.ADC(0, adc.RES_BIT_12)
 
 while True:
-    # raw_data = a.read()
-    # print(f"ADC raw data:{raw_data}")
-    # if raw_data > 2450:
-    #     print(f"ADC raw data:{raw_data}")
-    # elif raw_data < 2000:
-    #     print(f"ADC raw data:{raw_data}")
+    raw_data = a.read()
+    print(f"ADC raw data:{raw_data}")
+    if raw_data > 2450:
+        print(f"ADC raw data:{raw_data}")
+    elif raw_data < 2000:
+        print(f"ADC raw data:{raw_data}")
     time.sleep_ms(1)
 
     vol = int(a.read_vol() * 10) / 10

app.yaml

@@ -1,10 +1,12 @@
 id: t11
 name: t11
-version: 3.0.3
+version: 2.1.1
 author: t11
 icon: ''
 desc: t11
 files:
+  - 4g_download_manager.py
+  - 4g_upload_manager.py
   - app.yaml
   - archery_netcore.cpython-311-riscv64-linux-gnu.so
   - at_client.py
@@ -12,14 +14,12 @@ files:
   - cameraParameters.xml
   - config.py
   - hardware.py
-  - laser_detector.py
   - laser_manager.py
   - logger_manager.py
   - main.py
-  - model_317828.cvimodel
-  - model_317828.mud
+  - model_270139.cvimodel
+  - model_270139.mud
   - network.py
-  - ota_curl.sh
   - ota_manager.py
   - power.py
   - server.pem

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 建连耗时采样次数，取中位数
@@ -96,11 +96,6 @@ ADC_LASER_THRESHOLD = 3000
 
 # ==================== 激光配置 ====================
 MODULE_ADDR = 0x00
-# 激光开关改由 A14 GPIO 控制：低电平开启，高电平关闭。
-LASER_CONTROL_PIN = "A14"
-LASER_CONTROL_GPIO = "GPIOA14"
-LASER_CONTROL_ON_LEVEL = 0
-LASER_CONTROL_OFF_LEVEL = 1
 LASER_ON_CMD = bytes([0xAA, MODULE_ADDR, 0x01, 0xBE, 0x00, 0x01, 0x00, 0x01, 0xC1])
 LASER_OFF_CMD = bytes([0xAA, MODULE_ADDR, 0x01, 0xBE, 0x00, 0x01, 0x00, 0x00, 0xC0])
 DISTANCE_QUERY_CMD = bytes([0xAA, MODULE_ADDR, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x21])  # 激光测距查询命令
@@ -111,6 +106,14 @@ DEFAULT_LASER_POINT =  (320, 245)   # 默认激光中心点
 HARDCODE_LASER_POINT = True  # 是否使用硬编码的激光点（True=使用硬编码值，False=使用校准值）
 HARDCODE_LASER_POINT_VALUE = (320, 296) # 硬编码的激光点坐标(315, 245) #   # 硬编码的激光点坐标 (x, y)
 
+# 远程激光点识别（TCP cmd=200）：画面内找红点，稳定 N 秒且无明显跳动后上报坐标
+LASER_REMOTE_DETECT_STABLE_SEC = 3.0       # 连续稳定时长（秒）
+LASER_REMOTE_DETECT_MAX_MOVE_PX = 12.0     # 窗口内最大位移超过此值视为大幅移动，重新计时
+LASER_REMOTE_DETECT_SAMPLE_MS = 80         # 采样间隔
+LASER_REMOTE_DETECT_MIN_SAMPLES = 8        # 判定稳定前窗口内最少样本数
+LASER_REMOTE_DETECT_WARMUP_MS = 500        # cmd=200 开激光后等待稳定再采样
+# 远程识别会话无总超时：cmd=200 启动后持续检测并上报，直至 cmd=201 停止
+
 # 激光点检测配置
 LASER_DETECTION_THRESHOLD = 140  # 红色通道阈值（默认120，可调整，范围建议：100-150）
 LASER_RED_RATIO = 1.5  # 红色相对于绿色/蓝色的倍数要求（默认1.5，可调整，范围建议：1.3-2.0）
@@ -139,7 +142,7 @@ IMAGE_CENTER_Y = 240  # 图像中心 Y 坐标
 # ==================== 三角形四角标记：单应性偏移 + PnP 估距 ====================
 # 依赖 cameraParameters.xml（相机内参）与 triangle_positions.json（四角物方坐标，厘米或毫米见 JSON 约定）。
 # 部署时请把这两个文件放到 APP_DIR（与 main 同应用目录），或改下面路径为设备上的实际绝对路径。
-USE_TRIANGLE_OFFSET = False  # False 时仅走黄心圆/椭圆 + 半径估距，不使用三角形路径
+USE_TRIANGLE_OFFSET = True  # False 时仅走黄心圆/椭圆 + 半径估距，不使用三角形路径
 CAMERA_CALIB_XML = APP_DIR + "/cameraParameters.xml"
 TRIANGLE_POSITIONS_JSON = APP_DIR + "/triangle_positions.json"
 # 检测到的三角形边长在图像中的像素范围，分辨率或靶纸占比变化时可微调
@@ -149,6 +152,13 @@ TRIANGLE_SIZE_RANGE = (8, 500)
 # 如果射箭距离很固定，可设具体范围（如 min=2.5, max=6.0）作为额外保险
 TRIANGLE_DISTANCE_MIN_M = 0.0   # 0=不启用下限检查
 TRIANGLE_DISTANCE_MAX_M = 0.0   # 0=不启用上限检查
+# 三角形方向校验：四角黑三角应为 ◤ ◥ / ◣ ◢，即三角形从外角指向靶心；用于过滤相邻靶混入/跨靶组合
+TRIANGLE_DIRECTION_VALIDATE_ENABLE = False
+TRIANGLE_DIRECTION_MIN_PASS = 3  # 至少多少个真实三角方向正确才认为该组有效；3点补全时推荐3，误检多可设2
+TRIANGLE_DIRECTION_DOT_MIN = 0.0  # 方向点积阈值；0=只要求同向半平面，0.35≈夹角<70°，0.5≈夹角<60°
+TRIANGLE_DIRECTION_TO_CENTER_DOT_MIN = 0.35  # 必须指向候选靶心；0.35≈夹角<70°，用于过滤相邻靶混入
+TRIANGLE_CENTER_DISTANCE_VALIDATE_ENABLE = True  # 四角三角到候选靶心距离需近似一致，过滤跨靶组合
+TRIANGLE_CENTER_DISTANCE_RATIO_TOL = 0.45  # (max_dist-min_dist)/mean_dist 最大允许值；越小越严格
 # 三角形检测兜底增强：CLAHE（更鲁棒但更慢）。颜色阈值修复后通常不需要，保持关闭以优先速度。
 TRIANGLE_ENABLE_CLAHE_FALLBACK = False
 # 三角形检测调试：保存 Otsu 二值化图像（临时调试用，定位后关闭）
@@ -174,6 +184,7 @@ TRIANGLE_SHAPE_COS_TOLERANCE = 0.25    # 直角余弦绝对值上限（原 0.20
 # 建议设为实测最坏耗时的 1.2 倍；超时后圆心检测仍会并行跑完，跑完后若三角形已结束则优先用三角形。
 TRIANGLE_TIMEOUT_MS = 1000
 # True=打印各阶段耗时(ms)，用于定位瓶颈；稳定后可 False 减少日志
+ARCHERY_TIMING_ENABLE = False  # 总开关：False 关闭所有算法耗时统计（shoot_manager + triangle_target + vision）
 TRIANGLE_TIMING_LOG = True
 # True=Stage2 每个子框内传统三角失败时打一条统计（Otsu/Adaptive 下轮廓数与各拒绝原因计数）
 TRIANGLE_LOG_STAGE2_PATCH_REJECT = True
@@ -261,21 +272,15 @@ TRIANGLE_CROP_ROI_MIN_SIDE_PX = 64
 # 射箭保存图 / 预览上绘制 YOLO 靶环 ROI 矩形 (x0,y0,x1,y1)，核对是否裁准；不需要时改 False
 TRIANGLE_YOLO_DRAW_ROI_ON_SHOT = True
 # 物方采样调试：以靶心为中心，取半径 15cm 的圆周样本点，用于黑/白颜色对比
+TRIANGLE_SAMPLE_ENABLE = True
+TRIANGLE_SAMPLE_TIMING_ENABLE = True  # 仅统计物方采样耗时（其他 timing 可关）
 TRIANGLE_SAMPLE_RADIUS_CM = 15.0
 TRIANGLE_SAMPLE_ANGLES_DEG = (0, 90, 180, 270)
 TRIANGLE_SAMPLE_PATCH_HALF_PX = 2
+# 物方采样判断黑白阈值（R/G/B 均小于此值视为黑）；40cm 黑靶在靶面位置全黑，20cm 白靶则 R/G/B 偏高
+TRIANGLE_SAMPLE_BLACK_THRESH = 30.0
 # 开机阶段预加载 YOLO detector；detect 使用 dual_buff=False，避免返回上一帧结果。
-TRIANGLE_YOLO_PRELOAD_ON_BOOT = False
-
-# YOLO target size classification: class 0=20cm, class 1=40cm.
-TARGET_CLASS_YOLO_ENABLE = True
-TARGET_CLASS_YOLO_MODEL_PATH = APP_DIR + "/model_317828.mud"
-TARGET_CLASS_YOLO_LABELS = (20, 40)
-TARGET_CLASS_YOLO_CONF_TH = 0.50
-TARGET_CLASS_YOLO_IOU_TH = 0.45
-TARGET_CLASS_YOLO_RETRY_ON_EMPTY = False
-TARGET_CLASS_YOLO_RETRY_CONF_TH = 0.25
-TARGET_CLASS_YOLO_PRELOAD_ON_BOOT = True
+TRIANGLE_YOLO_PRELOAD_ON_BOOT = True
 
 # ── 第二段 YOLO：仅在 Stage1 裁切出的靶环图上推理（与合成 stage2 训练数据一致）→ 子框内传统算法取直角点 ──
 # Stage1 靶环裁切内如何找黑三角标记（对比耗时时可切换）：
@@ -323,22 +328,16 @@ LASER_COLOR = (0, 255, 0)  # RGB颜色
 LASER_THICKNESS = 1
 LASER_LENGTH = 2
 
-# ==================== 队列大小限制（防止内存泄漏） ====================
-MAX_SEND_QUEUE_SIZE = 500       # 发送队列上限
-MAX_TCP_PAYLOADS = 500          # AT TCP 载荷缓存上限
-MAX_HTTP_EVENTS = 200           # AT HTTP 事件缓存上限
-LOG_QUEUE_MAXSIZE = 10000       # 日志队列上限
-MAX_CMD_THREADS = 10            # 并发命令线程上限（防止服务器下发命令时无限创建线程）
-
 # ==================== 图像保存配置 ====================
-SAVE_IMAGE_ENABLED = False  # 是否保存图像（True=保存，False=不保存）
-SAVE_IMAGE_ON_FAILURE = True  # 检测失败时是否强制保存图像（供调试测试用）
+SAVE_IMAGE_ENABLED = True  # 是否保存图像（True=保存，False=不保存）
+SAVE_RAW_SHOT_IMAGE_ENABLED = False  # 是否额外保存射箭原图；可通过 TCP cmd=46 动态开关
+VISION_TIMING_ENABLE = True  # 视觉圆检测耗时统计（detect_circle_v3 内部各步骤耗时）
 PHOTO_DIR = "/root/phot"    # 照片存储目录
 MAX_IMAGES = 1000
 # Stage2 调试目录（默认 PHOTO_DIR/stage2_roi）内 JPEG 最多保留张数；None 表示与 MAX_IMAGES 相同
 TRIANGLE_BLACK_YOLO_STAGE2_ROI_MAX_IMAGES = None
 
-SHOW_CAMERA_PHOTO_WHILE_SHOOTING = False  # 是否在拍摄时显示摄像头图像（True=显示，False=不显示），建议在连着USB测试过程中打开
+SHOW_CAMERA_PHOTO_WHILE_SHOOTING = True  # 是否在拍摄时显示摄像头图像（True=显示，False=不显示），建议在连着USB测试过程中打开
 
 # ==================== OTA配置 ====================
 MAX_BACKUPS = 5
@@ -353,29 +352,11 @@ PIN_MAPPINGS = {
     "A28": "UART2_TX",
     "A15": "I2C5_SCL",
     "A27": "I2C5_SDA",
-    "A14": "GPIOA14",  # 激光开关：低开、高关
     "A24": "GPIOA24",  # 电源板关机控制
-    "A25": "GPIOA25",  # 电源状态绿灯
-    "A23": "GPIOA23",  # 电源状态红灯
 }
 
 # ==================== 电源配置 ====================
 AUTO_POWER_OFF_IN_SECONDS = 10 * 60  # 自动关机时间（秒），0表示不自动关机
-# 充电时自动关机暂时禁用；需要恢复时改为 True。
-CHARGING_AUTO_POWER_OFF_ENABLED = False
-
-# 一代电源控制：A24 由电源板负责按键/关机信号，软件关机时输出高电平。
-
-# 电源状态指示灯
-STATUS_LED_GREEN_GPIO = "GPIOA25"
-STATUS_LED_RED_GPIO = "GPIOA23"
-STATUS_LED_GREEN_ENABLED = True
-STATUS_LED_RED_ENABLED = True
-STATUS_LED_ACTIVE_LEVEL = 1
-STATUS_LED_LOW_BATTERY_PERCENT = 10
-STATUS_LED_FULL_BATTERY_PERCENT = 90
-STATUS_LED_CHARGING_BLINK_MS = 500
-STATUS_LED_POLL_MS = 1000
 
 BATTERY_SOC_LPF_ALPHA = 0.5
 BATTERY_SOC_AVG_WINDOW = 5

hardware.py

@@ -5,7 +5,6 @@
 提供硬件对象的统一管理和访问
 """
 from maix import time
-import _thread
 import config
 from at_client import ATClient
 
@@ -29,7 +28,6 @@ class HardwareManager:
         self._bus = None                 # I2C总线
         self._adc_obj = None             # ADC对象
         self._at_client = None            # AT客户端
-        self._status_led_monitor_started = False
 
         self._last_active_time = 0       # 用于记录用户的最后一次活跃的时间
         self._stop_timer = False         # 用于停止定时器的标志
@@ -106,87 +104,11 @@ class HardwareManager:
             # 物理引脚是 A24，对应 GPIO 功能是 GPIOA24
             # 注意：这里需要先在 config.PIN_MAPPINGS 中配置好 "A24": "GPIOA24"
             from maix import gpio
-            # 一代电源板关机信号为高电平
+            # 输出高电平关闭
             gpio.GPIO("GPIOA24", gpio.Mode.OUT).value(1)
         except Exception as e:
             print(f"关机失败: {e}")
 
-    def start_status_led_monitor(self):
-        """后台更新状态灯：正常/充满绿常亮、充电绿闪烁、低电量红常亮。"""
-        if self._status_led_monitor_started:
-            return
-        self._status_led_monitor_started = True
-        _thread.start_new_thread(self._status_led_loop, ())
-
-    def _status_led_loop(self):
-        from maix import gpio
-        from power import get_bus_voltage, is_charging, voltage_to_percent
-
-        try:
-            green = None
-            if getattr(config, "STATUS_LED_GREEN_ENABLED", True):
-                green = gpio.GPIO(config.STATUS_LED_GREEN_GPIO, gpio.Mode.OUT)
-            red = None
-            if getattr(config, "STATUS_LED_RED_ENABLED", True):
-                red = gpio.GPIO(config.STATUS_LED_RED_GPIO, gpio.Mode.OUT)
-            active = int(config.STATUS_LED_ACTIVE_LEVEL)
-            inactive = 0 if active else 1
-            if green is not None:
-                green.value(inactive)
-            if red is not None:
-                red.value(inactive)
-            last_state = None
-            blink_on = False
-            blink_period = max(100, int(config.STATUS_LED_CHARGING_BLINK_MS))
-            poll_ms = max(100, int(config.STATUS_LED_POLL_MS))
-            tick_ms = min(blink_period, poll_ms)
-            sensor_elapsed = poll_ms
-            blink_elapsed = blink_period
-            state = "normal"
-            percent = None
-            charging = False
-
-            while self._status_led_monitor_started:
-                if sensor_elapsed >= poll_ms:
-                    voltage = get_bus_voltage()
-                    percent = voltage_to_percent(voltage) if voltage > 0 else None
-                    charging = is_charging()
-                    low = percent is not None and percent <= int(config.STATUS_LED_LOW_BATTERY_PERCENT)
-                    full = percent is not None and percent >= int(config.STATUS_LED_FULL_BATTERY_PERCENT)
-                    if charging:
-                        state = "full" if full else "charging"
-                    else:
-                        state = "low" if low else "normal"
-                    sensor_elapsed = 0
-
-                if state == "low":
-                    if green is not None:
-                        green.value(inactive)
-                    if red is not None:
-                        red.value(active)
-                elif state == "charging":
-                    if blink_elapsed >= blink_period:
-                        blink_on = not blink_on
-                        blink_elapsed = 0
-                    if green is not None:
-                        green.value(active if blink_on else inactive)
-                    if red is not None:
-                        red.value(inactive)
-                else:  # normal or full
-                    if green is not None:
-                        green.value(active)
-                    if red is not None:
-                        red.value(inactive)
-                if state != last_state:
-                    print(f"[STATUS_LED] state={state} percent={percent} charging={charging}")
-                    last_state = state
-                time.sleep_ms(tick_ms)
-                sensor_elapsed += tick_ms
-                blink_elapsed += tick_ms
-        except Exception as e:
-            self._status_led_monitor_started = False
-            print(f"[STATUS_LED] monitor failed: {e}")
-
     def start_idle_timer(self):
         self._stop_timer = False
         self._last_active_time = time.time()

laser_detector.py

@@ -1,248 +0,0 @@
-from maix import image, time
-from logger_manager import logger_manager
-from camera_manager import camera_manager
-
-_USE_CV = False
-try:
-    import cv2
-    import numpy as np
-
-    _USE_CV = True
-except ImportError:
-    pass
-
-WIDTH = 640
-HEIGHT = 480
-THRESHOLD = 100
-RED_RATIO = 1.5
-SEARCH_RADIUS = 80
-TRACK_RADIUS = 30
-MIN_PIXELS = 3
-COARSE_STEP = 2
-STABLE_COUNT = 2
-MAX_SKIP_FRAMES = 5
-
-# Temporal smoothing
-_EMA_ALPHA = 0.35
-_GATE_PX = 10
-_FRAME_INTERVAL_MS = 50
-
-_prev_smoothed = None
-
-
-def _red_weighted_centroid(r_ch, g_ch, b_ch, mask, x0, y0):
-    y_ids, x_ids = np.where(mask)
-    if len(y_ids) == 0:
-        return None
-    r_vals = r_ch[y_ids, x_ids].astype(np.float64)
-    g_vals = g_ch[y_ids, x_ids].astype(np.float64)
-    b_vals = b_ch[y_ids, x_ids].astype(np.float64)
-    w = r_vals - np.maximum(g_vals, b_vals)
-    w = np.clip(w, 0, None)
-    w = w * w
-    total_w = w.sum()
-    if total_w < 1e-6:
-        return None
-    cx = (x_ids.astype(np.float64) * w).sum() / total_w + x0
-    cy = (y_ids.astype(np.float64) * w).sum() / total_w + y0
-    return (float(cx), float(cy))
-
-
-def find_ellipse(img_cv, cx, cy, roi_r, th, ratio):
-    x1 = max(0, cx - roi_r)
-    x2 = min(WIDTH, cx + roi_r)
-    y1 = max(0, cy - roi_r)
-    y2 = min(HEIGHT, cy + roi_r)
-    roi = img_cv[y1:y2, x1:x2]
-    if roi.size == 0:
-        return None
-    r = roi[:, :, 0].astype(np.int32)
-    g = roi[:, :, 1].astype(np.int32)
-    b = roi[:, :, 2].astype(np.int32)
-    mask = (r > th) & (r > g * ratio) & (r > b * ratio)
-    oe = (r > 200) & (g > 200) & (b > 200) & (r >= g) & (r >= b) & ((r - g) > 10) & ((r - b) > 10)
-    combined = (mask | oe).astype(np.uint8) * 255
-    contours, _ = cv2.findContours(combined, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        return None
-    largest = max(contours, key=cv2.contourArea)
-    if cv2.contourArea(largest) < 5:
-        return None
-    cnt = largest.copy()
-    for pt in cnt:
-        pt[0][0] += x1
-        pt[0][1] += y1
-    ellipse_valid = len(cnt) >= 5
-    if ellipse_valid:
-        (ex, ey), (ew, eh), ang = cv2.fitEllipse(cnt)
-        mask_ellipse = np.zeros((HEIGHT, WIDTH), dtype=np.uint8)
-        cv2.ellipse(mask_ellipse, (int(ex), int(ey)), (int(ew / 2), int(eh / 2)), ang, 0, 360, 255, -1)
-        return _red_weighted_centroid(
-            img_cv[:, :, 0], img_cv[:, :, 1], img_cv[:, :, 2],
-            mask_ellipse > 0, 0, 0
-        )
-    M = cv2.moments(cnt)
-    if M["m00"] > 0:
-        return (float(M["m10"] / M["m00"]), float(M["m01"] / M["m00"]))
-    return None
-
-
-def is_red(r, g, b, th, ratio):
-    if r > th and r > g * ratio and r > b * ratio:
-        return True
-    if (r > 200 and g > 200 and b > 200 and r >= g and r >= b
-            and (r - g) > 10 and (r - b) > 10):
-        return True
-    return False
-
-
-def find_brightest_bytes(frame, cx, cy, roi_r, th, ratio):
-    x1 = max(0, cx - roi_r)
-    x2 = min(WIDTH, cx + roi_r)
-    y1 = max(0, cy - roi_r)
-    y2 = min(HEIGHT, cy + roi_r)
-    data = frame.to_bytes()
-
-    best_score = 0
-    best_x = (x1 + x2) // 2
-    best_y = (y1 + y2) // 2
-    found_any = False
-    for y in range(y1, y2, COARSE_STEP):
-        for x in range(x1, x2, COARSE_STEP):
-            idx = (y * WIDTH + x) * 3
-            r = data[idx]
-            g = data[idx + 1]
-            b = data[idx + 2]
-            if is_red(r, g, b, th, ratio):
-                score = r + g + b
-                dx = x - cx
-                dy = y - cy
-                dist_decay = max(0.5, 1.0 - ((dx * dx + dy * dy) ** 0.5 / roi_r) * 0.5)
-                score *= dist_decay
-                if score > best_score:
-                    best_score = score
-                    best_x = x
-                    best_y = y
-                    found_any = True
-
-    if not found_any:
-        return None
-
-    sf = 4
-    fx1 = max(x1, best_x - sf)
-    fx2 = min(x2, best_x + sf + 1)
-    fy1 = max(y1, best_y - sf)
-    fy2 = min(y2, best_y + sf + 1)
-
-    sum_x = 0.0
-    sum_y = 0.0
-    total_w = 0.0
-    count = 0
-    for y in range(fy1, fy2):
-        for x in range(fx1, fx2):
-            idx = (y * WIDTH + x) * 3
-            r = data[idx]
-            g = data[idx + 1]
-            b = data[idx + 2]
-            if is_red(r, g, b, th, ratio):
-                w = r + g + b
-                sum_x += x * w
-                sum_y += y * w
-                total_w += w
-                count += 1
-
-    if count < MIN_PIXELS:
-        return (float(best_x), float(best_y))
-
-    return (float(sum_x / total_w), float(sum_y / total_w))
-
-
-def _ema_filter(pos, alpha=_EMA_ALPHA):
-    global _prev_smoothed
-    if _prev_smoothed is None:
-        _prev_smoothed = pos
-        return pos
-    sx = alpha * pos[0] + (1 - alpha) * _prev_smoothed[0]
-    sy = alpha * pos[1] + (1 - alpha) * _prev_smoothed[1]
-    _prev_smoothed = (sx, sy)
-    return _prev_smoothed
-
-
-def _gated(pos, gate_px=_GATE_PX):
-    global _prev_smoothed
-    if _prev_smoothed is None:
-        return True
-    dx = pos[0] - _prev_smoothed[0]
-    dy = pos[1] - _prev_smoothed[1]
-    return (dx * dx + dy * dy) <= gate_px * gate_px
-
-
-def get_stable_laser_point(timeout_ms=15000, stable_count=STABLE_COUNT):
-    global _prev_smoothed
-    _prev_smoothed = None
-    try:
-        last_raw = None
-        stable = 0
-        start = time.ticks_ms()
-        cx, cy = WIDTH // 2, HEIGHT // 2
-        track_count = 0
-        skip_count = 0
-        while True:
-            if abs(time.ticks_diff(time.ticks_ms(), start)) > timeout_ms:
-                _prev_smoothed = None
-                return None
-            frame = camera_manager.read_frame()
-            if frame is None:
-                time.sleep_ms(10)
-                continue
-
-            if track_count > 0 and _prev_smoothed is not None:
-                search_cx = int(_prev_smoothed[0])
-                search_cy = int(_prev_smoothed[1])
-                search_r = TRACK_RADIUS
-            else:
-                search_cx = cx
-                search_cy = cy
-                search_r = SEARCH_RADIUS
-
-            pos_bright = find_brightest_bytes(frame, search_cx, search_cy, search_r, THRESHOLD, RED_RATIO)
-            pos = pos_bright
-            if _USE_CV:
-                img_cv = image.image2cv(frame, False, False)
-                pos_ellipse = find_ellipse(img_cv, search_cx, search_cy, search_r, THRESHOLD, RED_RATIO)
-                if pos_ellipse is not None:
-                    pos = pos_ellipse
-
-            if pos is not None:
-                skip_count = 0
-                track_count += 1
-                filtered = _ema_filter(pos)
-                if last_raw is not None:
-                    dx = abs(filtered[0] - last_raw[0])
-                    dy = abs(filtered[1] - last_raw[1])
-                    if dx <= 2 and dy <= 2:
-                        stable += 1
-                    else:
-                        stable = 1
-                else:
-                    stable = 1
-                last_raw = filtered
-                if logger_manager.logger:
-                    logger_manager.logger.info(f"pos:{pos},filtered:{filtered},stable:{stable}")
-                if stable >= stable_count:
-                    result = (int(filtered[0]), int(filtered[1]))
-                    _prev_smoothed = None
-                    return result
-            else:
-                skip_count += 1
-                if logger_manager.logger:
-                    logger_manager.logger.info(f"find_brightest_bytes None, skip={skip_count}, track={track_count}, search_center=({search_cx},{search_cy}), search_r={search_r}")
-                if skip_count > MAX_SKIP_FRAMES:
-                    _prev_smoothed = None
-                    track_count = 0
-                    stable = 0
-                    last_raw = None
-
-            time.sleep_ms(_FRAME_INTERVAL_MS)
-    finally:
-        _prev_smoothed = None

laser_manager.py

@@ -6,6 +6,7 @@
 """
 import _thread
 import json
+import math
 import os
 import binascii
 from maix import time
@@ -31,13 +32,16 @@ class LaserManager:
         
         # 私有状态
         self._serial = None  # 激光串口，由 laser_manager 自己持有
-        self._laser_gpio = None  # A14 激光开关，低电平开启、高电平关闭
         self._calibration_active = False
         self._calibration_result = None
         self._calibration_lock = threading.Lock()
+        self._remote_detect_active = False
+        self._remote_detect_lock = threading.Lock()
+        self._remote_detect_result = None
         self._laser_point = None
         self._laser_turned_on = False
         self._last_frame_with_ellipse = None  # 保存绘制了椭圆的图像（用于调试/显示）
+        self._remote_detect_last_pos = None
         self._initialized = True
     
     # ==================== 状态访问（只读属性）====================
@@ -55,8 +59,8 @@ class LaserManager:
     @property
     def laser_point(self):
         """当前激光点（如果启用硬编码，则返回硬编码值）"""
-        # if config.HARDCODE_LASER_POINT:
-        #     return config.HARDCODE_LASER_POINT_VALUE
+        if config.HARDCODE_LASER_POINT:
+            return config.HARDCODE_LASER_POINT_VALUE
         return self._laser_point
     
     def get_last_frame_with_ellipse(self):
@@ -70,21 +74,10 @@ class LaserManager:
     
     # ==================== 初始化方法 ====================
 
-    def init_control_gpio(self):
-        """尽早初始化 A14，并拉高确保激光关闭。"""
-        from maix import gpio, pinmap
-
-        pinmap.set_pin_function(config.LASER_CONTROL_PIN, config.LASER_CONTROL_GPIO)
-        if self._laser_gpio is None:
-            self._laser_gpio = gpio.GPIO(config.LASER_CONTROL_GPIO, gpio.Mode.OUT)
-        self._laser_gpio.value(config.LASER_CONTROL_OFF_LEVEL)
-        self._laser_turned_on = False
-        print(f"[LASER] {config.LASER_CONTROL_PIN}=HIGH，激光已关闭")
-
     def init(self, serial_device=None, baudrate=None):
         """
-        初始化激光模块（A14 开关 + 测距串口）
-        初始化时先将 A14 拉高关闭激光，防止开机误触发
+        初始化激光模块（包括串口）
+        初始化完成后主动发送关闭命令，防止 UART 初始化噪声误触发激光
         
         Args:
             serial_device: 串口设备路径，默认使用 config.DISTANCE_SERIAL_DEVICE
@@ -94,38 +87,282 @@ class LaserManager:
         device = serial_device or config.DISTANCE_SERIAL_DEVICE
         baud = baudrate or config.DISTANCE_SERIAL_BAUDRATE
 
-        self.init_control_gpio()
-
         self._serial = uart.UART(device, baud)
         print(f"[LASER] 激光串口初始化完成: device={device}, baudrate={baud}")
 
+        # 等待串口稳定后主动关闭激光，防止初始化噪声误触发
+        time.sleep_ms(100)
+        try:
+            self._serial.read(-1)  # 清空接收缓冲区
+        except Exception:
+            pass
+        self._serial.write(config.LASER_OFF_CMD)
+        time.sleep_ms(60)
+        try:
+            self._serial.read(-1)  # 清空回包
+        except Exception:
+            pass
+        print("[LASER] 已发送关闭命令（防止开机误触发）")
+
     # ==================== 业务方法 ====================
     
     def load_laser_point(self):
-        """加载激光中心点：优先使用本地保存的坐标，其次硬编码值，最后默认值"""
-        # 优先：从本地持久化文件加载（由 cmd 201 保存）
-        try:
-            if "laser_config.json" in os.listdir("/root"):
-                with open(config.CONFIG_FILE, "r") as f:
-                    data = json.load(f)
-                    if isinstance(data, list) and len(data) == 2:
-                        self._laser_point = (int(data[0]), int(data[1]))
-                        self.logger.info(f"[LASER] 从本地加载激光点: {self._laser_point}")
-                        return self._laser_point
-        except Exception:
-            pass
-
-        # 其次：硬编码值
+        """从配置文件加载激光中心点，失败则使用默认值
+        如果启用硬编码模式，则直接使用硬编码值
+        """
         if config.HARDCODE_LASER_POINT:
+            # 硬编码模式：直接使用硬编码值
             self._laser_point = config.HARDCODE_LASER_POINT_VALUE
             self.logger.info(f"[LASER] 使用硬编码激光点: {self._laser_point}")
             return self._laser_point
         
-        # 最后：默认值
-        self._laser_point = config.DEFAULT_LASER_POINT
-        self.logger.info(f"[LASER] 使用默认激光点: {self._laser_point}")
+        # 正常模式：从配置文件加载
+        try:
+            if os.path.exists(config.CONFIG_FILE):
+                with open(config.CONFIG_FILE, "r") as f:
+                    data = json.load(f)
+                    if isinstance(data, list) and len(data) == 2:
+                        self._laser_point = (int(data[0]), int(data[1]))
+                        self.logger.debug(f"[INFO] 加载激光点: {self._laser_point}")
+                        return self._laser_point
+                    else:
+                        raise ValueError
+            else:
+                self._laser_point = config.DEFAULT_LASER_POINT
+        except Exception as e:
+            if self.logger:
+                self.logger.warning(f"[LASER] 加载激光点失败，使用默认值: {e}")
+            self._laser_point = config.DEFAULT_LASER_POINT
+        
         return self._laser_point
     
+    @property
+    def remote_detect_active(self):
+        with self._remote_detect_lock:
+            return self._remote_detect_active
+
+    def get_remote_detect_result(self):
+        """获取并清除远程激光识别结果 (x, y) 或 None。"""
+        with self._remote_detect_lock:
+            result = self._remote_detect_result
+            self._remote_detect_result = None
+            return result
+
+    def remote_detect_tick(self, frame):
+        """
+        主循环显示路径调用的轻量 tick。
+        兼容旧调用点：当前远程识别由后台线程处理，这里不做重计算，
+        仅保留接口避免 AttributeError。
+        """
+        return None
+
+    def overlay_remote_detect_preview(self, frame):
+        """
+        在预览画面叠加远程识别点与坐标文本。
+        """
+        try:
+            import cv2
+            from maix import image
+            with self._remote_detect_lock:
+                pos = self._remote_detect_last_pos
+            if not pos:
+                return frame
+
+            img_cv = image.image2cv(frame, False, False)
+            if img_cv is None or img_cv.size == 0:
+                return frame
+
+            x, y = int(pos[0]), int(pos[1])
+            h, w = img_cv.shape[:2]
+            if x < 0 or y < 0 or x >= w or y >= h:
+                return frame
+
+            color = (255, 0, 0)  # RGB
+            cv2.circle(img_cv, (x, y), 8, color, 2)
+            cv2.line(img_cv, (x - 12, y), (x + 12, y), color, 1)
+            cv2.line(img_cv, (x, y - 12), (x, y + 12), color, 1)
+            cv2.putText(img_cv, f"laser=({x},{y})", (max(5, x + 10), max(20, y - 10)),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.55, color, 1, cv2.LINE_AA)
+
+            return image.cv2image(img_cv, False, False)
+        except Exception as e:
+            if self.logger:
+                self.logger.debug(f"[LASER-REMOTE] overlay 绘制失败: {e}")
+            return frame
+
+    def _set_remote_detect_result(self, result):
+        with self._remote_detect_lock:
+            self._remote_detect_result = result
+
+    def set_hardcoded_laser_point(self, x, y):
+        """更新 config.HARDCODE_LASER_POINT_VALUE（TCP cmd=201）。"""
+        try:
+            ix = int(round(float(x)))
+            iy = int(round(float(y)))
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"invalid laser point ({x!r}, {y!r})") from e
+        config.HARDCODE_LASER_POINT = True
+        config.HARDCODE_LASER_POINT_VALUE = (ix, iy)
+        self._laser_point = (ix, iy)
+        try:
+            with open(config.CONFIG_FILE, "w") as f:
+                json.dump([ix, iy], f)
+        except Exception as e:
+            if self.logger:
+                self.logger.warning(f"[LASER] 保存硬编码激光点到本地失败: {e}")
+            raise
+        if self.logger:
+            self.logger.info(
+                f"[LASER] 已设置硬编码激光点 HARDCODE_LASER_POINT_VALUE=({ix}, {iy}) 并已保存到 {config.CONFIG_FILE}"
+            )
+        return ix, iy
+
+    def start_remote_laser_detect(self):
+        """
+        启动远程激光识别会话（TCP cmd=200）：开激光后持续检测。
+        每次稳定 3s 上报一次坐标，外循环直到 cmd=201 调用 stop_remote_laser_detect()。
+        Returns:
+            True 已启动；False 会话已在运行
+        """
+        with self._remote_detect_lock:
+            if self._remote_detect_active:
+                return False
+            self._remote_detect_active = True
+            self._remote_detect_result = None
+            self._remote_detect_last_pos = None
+        _thread.start_new_thread(self._remote_laser_detect_worker, ())
+        if self.logger:
+            self.logger.info("[LASER] 远程激光识别已启动 (cmd=200)")
+        return True
+
+    def stop_remote_laser_detect(self):
+        with self._remote_detect_lock:
+            self._remote_detect_active = False
+
+    def _remote_laser_detect_worker(self):
+        from camera_manager import camera_manager
+
+        stable_sec = float(getattr(config, "LASER_REMOTE_DETECT_STABLE_SEC", 3.0))
+        max_move = float(getattr(config, "LASER_REMOTE_DETECT_MAX_MOVE_PX", 12.0))
+        sample_ms = int(getattr(config, "LASER_REMOTE_DETECT_SAMPLE_MS", 80))
+        min_samples = int(getattr(config, "LASER_REMOTE_DETECT_MIN_SAMPLES", 8))
+        warmup_ms = int(getattr(config, "LASER_REMOTE_DETECT_WARMUP_MS", 500))
+        stable_ms = int(max(500, stable_sec * 1000))
+
+        samples = []
+        miss_count = 0
+        stable_hit_count = 0
+        reported = False
+
+        try:
+            if not self._laser_turned_on:
+                try:
+                    self.turn_on_laser()
+                except Exception as e:
+                    if self.logger:
+                        self.logger.warning(f"[LASER] cmd200 worker 开激光失败: {e}")
+            if warmup_ms > 0:
+                if self.logger:
+                    self.logger.info(f"[LASER] cmd200 激光预热 {warmup_ms}ms …")
+                time.sleep_ms(warmup_ms)
+
+            if self.logger:
+                self.logger.info("[LASER] 远程识别外循环已启动，直至 cmd=201 停止")
+
+            while True:
+                with self._remote_detect_lock:
+                    if not self._remote_detect_active:
+                        if self.logger:
+                            self.logger.info("[LASER] 远程识别会话结束 (cmd=201 或取消)")
+                        return
+
+                try:
+                    frame = camera_manager.read_frame()
+                    pos = self.find_red_laser_remote(frame)
+                except Exception as e:
+                    if self.logger:
+                        self.logger.warning(f"[LASER] 远程识别帧异常: {e}")
+                    pos = None
+                    time.sleep_ms(sample_ms)
+                    continue
+
+                now_ms = time.ticks_ms()
+                if pos is None:
+                    miss_count += 1
+                    samples.clear()
+                    stable_hit_count = 0
+                    if miss_count == 1 or miss_count % 40 == 0:
+                        if self.logger:
+                            self.logger.info(
+                                f"[LASER-REMOTE] 本帧未检出激光点（累计 {miss_count} 帧），"
+                                f"全图多策略搜索中…"
+                            )
+                    time.sleep_ms(sample_ms)
+                    continue
+
+                miss_count = 0
+                x, y = float(pos[0]), float(pos[1])
+                samples.append((now_ms, x, y))
+                cutoff = now_ms - stable_ms
+                samples = [(t, px, py) for t, px, py in samples if t >= cutoff]
+
+                if len(samples) < 2:
+                    time.sleep_ms(sample_ms)
+                    continue
+
+                xs = [s[1] for s in samples]
+                ys = [s[2] for s in samples]
+                span = max(
+                    max(xs) - min(xs),
+                    max(ys) - min(ys),
+                )
+                for i in range(len(samples)):
+                    for j in range(i + 1, len(samples)):
+                        d = math.hypot(
+                            samples[i][1] - samples[j][1],
+                            samples[i][2] - samples[j][2],
+                        )
+                        span = max(span, d)
+
+                if span > max_move:
+                    if self.logger:
+                        self.logger.debug(
+                            f"[LASER] 检测到大幅位移 span={span:.1f}px>{max_move}，重新计时"
+                        )
+                    samples.clear()
+                    stable_hit_count = 0
+                    time.sleep_ms(sample_ms)
+                    continue
+
+                window_ms = samples[-1][0] - samples[0][0]
+                if window_ms >= stable_ms and len(samples) >= min_samples:
+                    fx = int(round(sum(xs) / len(xs)))
+                    fy = int(round(sum(ys) / len(ys)))
+                    stable_hit_count += 1
+                    if self.logger:
+                        self.logger.info(
+                            f"[LASER] 远程识别稳定命中 {stable_hit_count}/3 span={span:.1f}px → ({fx}, {fy})"
+                        )
+                    samples.clear()
+                    if stable_hit_count >= 3 and not reported:
+                        reported = True
+                        self._set_remote_detect_result(
+                            {"result":"laser_detect_ok", "x": fx, "y": fy}
+                        )
+                        if self.logger:
+                            self.logger.info(
+                                f"[LASER] 已连续3次坐标稳定，完成上报，继续等待 cmd=201 关闭会话"
+                            )
+                    time.sleep_ms(sample_ms)
+                    continue
+
+                time.sleep_ms(sample_ms)
+        finally:
+            if self.logger:
+                self.logger.info("[LASER] 远程识别线程退出，等待下一次 cmd=200")
+            with self._remote_detect_lock:
+                self._remote_detect_active = False
+
     def save_laser_point(self, point):
         """保存激光中心点到配置文件
         如果启用硬编码模式，则不保存（直接返回 True）
@@ -147,38 +384,66 @@ class LaserManager:
             return False
     
     def turn_on_laser(self):
-        """A14 输出低电平，开启激光。"""
-        if self._laser_gpio is None:
-            if self.logger:
-                self.logger.error("[LASER] A14 GPIO 未初始化，请先调用 init()")
-            return False
+        """发送指令开启激光，并读取回包（部分模块支持）"""
+        if self._serial is None:
+            self.logger.error("[LASER] 激光串口未初始化，请先调用 init()")
+            return None
+        
+        # 打印调试信息
+        self.logger.info(f"[LASER] 发送开启命令: {config.LASER_ON_CMD.hex()}")
+        
+        # 清空接收缓冲区
         try:
-            self._laser_gpio.value(config.LASER_CONTROL_ON_LEVEL)
-            self._laser_turned_on = True
-            if self.logger:
-                self.logger.info("[LASER] A14=LOW，激光开启")
-            return True
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"[LASER] A14 开启激光失败: {e}")
-            return False
+            self._serial.read(-1)  # 清空缓冲区
+        except:
+            pass
+        
+        # 发送命令
+        written = self._serial.write(config.LASER_ON_CMD)
+        self.logger.info(f"[LASER] 写入字节数: {written}")
+        
+        time.sleep_ms(60)
+
+        # 读取回包
+        resp = self._serial.read(len=20, timeout=10)
+        if resp:
+            self.logger.info(f"[LASER] 收到回包 ({len(resp)}字节): {resp.hex()}")
+            if resp == config.LASER_ON_CMD:
+                self.logger.info("✅ 激光开启指令已确认")
+        else:
+            self.logger.warning("🔇 无回包（可能正常或模块不支持回包）")
+        self._laser_turned_on = True
+        return resp
     
     def turn_off_laser(self):
-        """A14 输出高电平，关闭激光。"""
-        if self._laser_gpio is None:
-            if self.logger:
-                self.logger.error("[LASER] A14 GPIO 未初始化，请先调用 init()")
-            return False
+        """发送指令关闭激光"""
+        if self._serial is None:
+            self.logger.error("[LASER] 激光串口未初始化，请先调用 init()")
+            return None
+        
+        # 打印调试信息
+        self.logger.info(f"[LASER] 发送关闭命令: {config.LASER_OFF_CMD.hex()}")
+        
+        # 清空接收缓冲区
         try:
-            self._laser_gpio.value(config.LASER_CONTROL_OFF_LEVEL)
-            self._laser_turned_on = False
-            if self.logger:
-                self.logger.info("[LASER] A14=HIGH，激光关闭")
-            return True
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"[LASER] A14 关闭激光失败: {e}")
-            return False
+            self._serial.read(-1)
+        except:
+            pass
+        
+        # 发送命令
+        written = self._serial.write(config.LASER_OFF_CMD)
+        self.logger.info(f"[LASER] 写入字节数: {written}")
+
+        time.sleep_ms(60)
+        
+        # 读取回包
+        resp = self._serial.read(20)
+        if resp:
+            self.logger.info(f"[LASER] 收到回包 ({len(resp)}字节): {resp.hex()}")
+        else:
+            self.logger.warning("🔇 无回包")
+        self._laser_turned_on = False
+        return resp
 
     def flash_laser(self, duration_ms=1000):
         """闪一下激光（非阻塞版本）"""
@@ -800,6 +1065,172 @@ class LaserManager:
             # 使用原来的最亮点方法
             return self._find_red_laser_brightest(frame, threshold, search_radius, ellipse_params)
 
+    def find_red_laser_remote(self, frame):
+        """
+        cmd=200 远程识别专用：全图搜索、多策略、放宽阈值，不限距画面中心距离。
+        常规 find_red_laser 仅搜中心 ±LASER_SEARCH_RADIUS 且距中心 >50px 会丢弃。
+        """
+        import cv2
+        import numpy as np
+        from maix import image
+
+        img_cv = image.image2cv(frame, False, False)
+        if img_cv is None or img_cv.size == 0:
+            return None
+        h, w = img_cv.shape[:2]
+
+        r = img_cv[:, :, 0].astype(np.int32)
+        g = img_cv[:, :, 1].astype(np.int32)
+        b = img_cv[:, :, 2].astype(np.int32)
+        brightness = r + g + b
+        red_ratio = float(getattr(config, "LASER_RED_RATIO", 1.5))
+        ratio_lo = max(1.15, red_ratio - 0.35)
+
+        strategies = []
+        base_th = int(getattr(config, "LASER_DETECTION_THRESHOLD", 140))
+        for th in (base_th, 120, 100, 80, 60):
+            mask = (
+                (r > th)
+                & (r > g * ratio_lo)
+                & (r > b * ratio_lo)
+            )
+            strategies.append(("rgb", th, mask))
+
+        oe_th = int(getattr(config, "LASER_OVEREXPOSED_THRESHOLD", 200))
+        oe_diff = int(getattr(config, "LASER_OVEREXPOSED_DIFF", 10))
+        mask_oe = (
+            (r > oe_th - 30)
+            & (g > oe_th - 40)
+            & (b > oe_th - 40)
+            & (r >= g)
+            & (r >= b)
+            & ((r - g) > max(5, oe_diff - 5))
+            & ((r - b) > max(5, oe_diff - 5))
+        )
+        strategies.append(("overexposed", oe_th, mask_oe))
+
+        mask_bright = (brightness > 380) & (r >= g) & (r >= b) & ((r - g) > 3)
+        strategies.append(("bright", 0, mask_bright))
+
+        hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV)
+        hc, sc, vc = cv2.split(hsv)
+        mask_hsv = ((hc <= 18) | (hc >= 162)) & (sc >= 60) & (vc >= 60)
+        strategies.append(("hsv", 0, mask_hsv))
+
+        best_pos = None
+        best_score = -1.0
+        best_tag = None
+
+        max_area = float(getattr(config, "LASER_REMOTE_MAX_AREA", 300.0))
+        min_circularity = float(getattr(config, "LASER_REMOTE_MIN_CIRCULARITY", 0.25))
+
+        for name, th, mask in strategies:
+            m = (mask.astype(np.uint8)) * 255
+            if cv2.countNonZero(m) == 0:
+                continue
+            contours, _ = cv2.findContours(m, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            if not contours:
+                continue
+            for cnt in contours:
+                area = cv2.contourArea(cnt)
+                if area < 1.5 or area > max_area:
+                    continue
+                peri = cv2.arcLength(cnt, True)
+                if peri <= 0:
+                    continue
+                circularity = float(4.0 * math.pi * area / (peri * peri))
+                if circularity < min_circularity:
+                    continue
+                M = cv2.moments(cnt)
+                if M["m00"] <= 0:
+                    continue
+                cx = float(M["m10"] / M["m00"])
+                cy = float(M["m01"] / M["m00"])
+                ix, iy = int(round(cx)), int(round(cy))
+                if ix < 0 or iy < 0 or ix >= w or iy >= h:
+                    continue
+                local_r = float(r[iy, ix])
+                score = area * local_r * (1.0 + local_r / 255.0) * (0.5 + circularity)
+                if score > best_score:
+                    best_score = score
+                    best_pos = (ix, iy)
+                    best_tag = (name, th, area)
+
+        if best_pos is not None:
+            with self._remote_detect_lock:
+                self._remote_detect_last_pos = best_pos
+            self._save_remote_detect_debug_image(frame, best_pos, best_tag)
+            if self.logger:
+                self.logger.info(
+                    f"[LASER-REMOTE] 检测到激光点 {best_pos} "
+                    f"strategy={best_tag[0]} th={best_tag[1]} area={best_tag[2]:.1f}"
+                )
+        elif self.logger:
+            self.logger.debug("[LASER-REMOTE] 未通过面积/圆度过滤")
+        return best_pos
+
+    def _save_remote_detect_debug_image(self, frame, pos, tag=None):
+        """保存远程识别调试图：叠加激光坐标并落盘。"""
+        try:
+            if not bool(getattr(config, "SAVE_IMAGE_ENABLED", True)):
+                return
+            import cv2
+            from maix import image
+
+            img_cv = image.image2cv(frame, False, False)
+            if img_cv is None or img_cv.size == 0:
+                return
+
+            x, y = int(pos[0]), int(pos[1])
+            h, w = img_cv.shape[:2]
+            if x < 0 or y < 0 or x >= w or y >= h:
+                return
+
+            cv2.circle(img_cv, (x, y), 8, (255, 0, 0), 2)
+            cv2.line(img_cv, (x - 12, y), (x + 12, y), (255, 0, 0), 1)
+            cv2.line(img_cv, (x, y - 12), (x, y + 12), (255, 0, 0), 1)
+
+            desc = ""
+            if tag:
+                desc = f" {tag[0]} th={tag[1]} area={tag[2]:.1f}"
+            cv2.putText(
+                img_cv,
+                f"laser=({x},{y}){desc}",
+                (10, 24),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.55,
+                (255, 0, 0),
+                1,
+                cv2.LINE_AA,
+            )
+
+            base_dir = getattr(config, "PHOTO_DIR", "/root/phot")
+            debug_dir = f"{base_dir}/laser_remote"
+            try:
+                if debug_dir not in os.listdir("/root") and "/" not in debug_dir.replace("/root/", ""):
+                    os.mkdir(debug_dir)
+                else:
+                    try:
+                        os.makedirs(debug_dir, exist_ok=True)
+                    except Exception:
+                        pass
+            except Exception:
+                try:
+                    os.makedirs(debug_dir, exist_ok=True)
+                except Exception:
+                    return
+
+            ts = int(time.ticks_ms())
+            filename = f"{debug_dir}/remote_{x}_{y}_{ts}.jpg"
+            out = image.cv2image(img_cv, False, False)
+            out.save(filename)
+
+            if self.logger:
+                self.logger.info(f"[LASER-REMOTE] 调试图已保存: {filename}")
+        except Exception as e:
+            if self.logger:
+                self.logger.warning(f"[LASER-REMOTE] 保存调试图失败: {e}")
+
     def calibrate_laser_position(self, timeout_ms=8000, check_sharpness=True):
         """
         执行激光校准：循环拍照 → 检测靶心 → 检查激光点清晰度 → 找红点 → 保存坐标
@@ -1233,28 +1664,6 @@ class LaserManager:
                 except Exception as e:
                     self.logger.error(f"[LASER] 关闭激光失败: {e}")
 
-    def set_hardcoded_laser_point(self, raw_x, raw_y):
-        """
-        设置服务下发的硬编码激光点坐标，并保存到本地持久化文件。
-        下次启动时 load_laser_point() 会优先使用此保存的值。
-
-        Args:
-            raw_x: 服务下发的 x 坐标
-            raw_y: 服务下发的 y 坐标
-
-        Returns:
-            (int_x, int_y) 元组
-        """
-        ix = int(raw_x)
-        iy = int(raw_y)
-        self._laser_point = (ix, iy)
-        try:
-            with open(config.CONFIG_FILE, "w") as f:
-                json.dump([ix, iy], f)
-            self.logger.info(f"[LASER] 设置并持久化激光点: ({ix}, {iy})")
-        except Exception as e:
-            self.logger.error(f"[LASER] 持久化激光点失败: {e}")
-        return ix, iy
 
 # 创建全局单例实例
 laser_manager = LaserManager()

logger_manager.py

@@ -65,8 +65,8 @@ class LoggerManager:
             backup_count = config.LOG_BACKUP_COUNT
         
         try:
-            # 创建日志队列（有界队列，防止内存泄漏；满时自动丢弃旧日志）
-            self._log_queue = queue.Queue(maxsize=config.LOG_QUEUE_MAXSIZE)
+            # 创建日志队列（无界队列）
+            self._log_queue = queue.Queue(-1)
             
             # 确保日志文件所在的目录存在
             log_dir = os.path.dirname(log_file)

main.py

@@ -76,14 +76,12 @@ def laser_calibration_worker():
                 import traceback
                 traceback.print_exc()
             time.sleep_ms(1000)  # 等待1秒后继续
+
 def cmd_str():
     """主程序入口"""
     # ==================== 第一阶段：硬件初始化 ====================
     # 按照 main104.py 的顺序，先完成所有硬件初始化
 
-    # 开机第一步先拉高 A14 关闭激光，避免其他硬件初始化期间误亮。
-    laser_manager.init_control_gpio()
-
     # 1. 引脚功能映射
     for pin, func in config.PIN_MAPPINGS.items():
         try:
@@ -105,8 +103,6 @@ def cmd_str():
     print(f"[BOOT] init_ina226 开始 wall_s={_w_boot:.3f}")
     init_ina226()
     print(f"[BOOT] init_ina226 结束 wall +{int(round((wall_time.time() - _w_boot) * 1000))} ms")
-    # 启动 A25 绿灯和 A23 红灯状态指示。
-    hardware_manager.start_status_led_monitor()
 
     # 4. 初始化显示和相机
     _w_boot = wall_time.time()
@@ -124,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
 
     # 补充：因为初始化的时候，激光会亮，先关了它
@@ -166,11 +162,7 @@ def cmd_str():
             and _loc_black == "yolo"
             and bool(getattr(config, "TRIANGLE_BLACK_YOLO_PRELOAD_ON_BOOT", True))
         )
-        _need_target_preload = (
-            bool(getattr(config, "TARGET_CLASS_YOLO_ENABLE", False))
-            and bool(getattr(config, "TARGET_CLASS_YOLO_PRELOAD_ON_BOOT", True))
-        )
-        _preload_yolo = _preload_yolo or _need_black_preload or _need_target_preload
+        _preload_yolo = _preload_yolo or _need_black_preload
         if _preload_yolo:
             preload_yolo_detector(logger)
     except Exception as e:
@@ -253,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:
@@ -286,45 +278,46 @@ def cmd_str():
         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
+        if not config.AIR_PRESSURE_lOG:
+            return
+        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
-            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"values={','.join(map(str, pressure_buf))}"
-            )
-            if logger:
-                logger.debug(line)
-            else:
-                print(line)
-        # 无论是否记录日志，都必须清空 buffer，否则内存泄漏
+        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} 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)
         pressure_buf = []
         pressure_sum = 0
+        pressure_abs_sum = 0
         pressure_min = 4095
         pressure_max = 0
         pressure_t0_ms = None
+        last_avg_abs = avg_abs
 
     # 主循环：检测扳机触发 → 拍照 → 分析 → 上报
     while not app.need_exit():
@@ -359,10 +352,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:
@@ -373,29 +368,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")
 
@@ -412,11 +402,19 @@ def cmd_str():
             else:
                 if config.SHOW_CAMERA_PHOTO_WHILE_SHOOTING:
                     try:
-                        camera_manager.show(camera_manager.read_frame())
+                        frame = camera_manager.read_frame()
+                        laser_manager.remote_detect_tick(frame)
+                        if (
+                            laser_manager.remote_detect_active
+                            and getattr(config, "LASER_REMOTE_DETECT_DRAW_PREVIEW", False)
+                        ):
+                            frame = laser_manager.overlay_remote_detect_preview(frame)
+                        camera_manager.show(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:
             # 主循环的顶层异常捕获，防止程序静默退出

model_270139.mud

@@ -1,7 +1,7 @@
 
 [basic]
 type = cvimodel
-model = model_317828.cvimodel
+model = model_270139.cvimodel
 
 [extra]
 model_type = yolov5
@@ -9,5 +9,5 @@ input_type = rgb
 mean = 0, 0, 0
 scale = 0.00392156862745098, 0.00392156862745098, 0.00392156862745098
 anchors = 10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326
-labels = 20, 40
+labels = 黑三角和圆环
 

network.py

@@ -8,7 +8,7 @@ import json
 import re
 from math import e
 import struct
-from maix import time, network, err
+from maix import time
 import hmac
 import hashlib
 import ujson
@@ -18,10 +18,11 @@ 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
+
+
 
 
 def _wifi_tls_would_block(exc):
@@ -36,8 +37,8 @@ def _wifi_tls_would_block(exc):
     if _ssl is not None and isinstance(exc, _ssl.SSLError):
         err = getattr(exc, "errno", None)
         if err in (
-                getattr(_ssl, "SSL_ERROR_WANT_READ", 2),
-                getattr(_ssl, "SSL_ERROR_WANT_WRITE", 3),
+            getattr(_ssl, "SSL_ERROR_WANT_READ", 2),
+            getattr(_ssl, "SSL_ERROR_WANT_WRITE", 3),
         ):
             return True
     msg = str(exc).lower()
@@ -72,10 +73,6 @@ class NetworkManager:
         self._raw_line_data = []
         self._manual_trigger_flag = False
         
-        # 限制并发命令线程数
-        self._cmd_thread_lock = threading.Lock()
-        self._cmd_thread_count = 0
-
         # 网络类型状态
         self._network_type = None  # "wifi" 或 "4G" 或 None
         # 本次上电曾因 WiFi 质量差切换到 4G 后，直至关机不再改回 WiFi
@@ -87,8 +84,7 @@ class NetworkManager:
         try:
             import archery_netcore as _netcore
             self._netcore = _netcore
-            if hasattr(self._netcore, "parse_packet") and hasattr(self._netcore, "make_packet") and hasattr(
-                    self._netcore, "actions_for_inner_cmd"):
+            if hasattr(self._netcore, "parse_packet") and hasattr(self._netcore, "make_packet") and hasattr(self._netcore, "actions_for_inner_cmd"):
                 print("[NET] archery_netcore found")
             else:
                 print("[NET] archery_netcore not found parse_packet or make_packet")
@@ -151,6 +147,7 @@ class NetworkManager:
 
     # ==================== 内部状态管理方法 ====================
 
+    
     def set_manual_trigger(self, value=True):
         """设置手动触发标志（公共方法）"""
         self._manual_trigger_flag = value
@@ -169,15 +166,11 @@ class NetworkManager:
         self._password = password
     
     def _enqueue(self, item, high=False):
-        """线程安全地加入队列（内部方法），队列满时丢弃最旧消息"""
+        """线程安全地加入队列（内部方法）"""
         with self._queue_lock:
             if high:
-                if len(self._high_send_queue) >= config.MAX_SEND_QUEUE_SIZE:
-                    self._high_send_queue.pop(0)
                 self._high_send_queue.append(item)
             else:
-                if len(self._normal_send_queue) >= config.MAX_SEND_QUEUE_SIZE:
-                    self._normal_send_queue.pop(0)
                 self._normal_send_queue.append(item)
         self._send_event.set()
     
@@ -206,34 +199,10 @@ class NetworkManager:
         """获取队列锁（用于with语句）"""
         return self._queue_lock
     
-    def _spawn_cmd_thread(self, target, args=()):
-        """安全创建命令线程，限制并发数，防止无限创建导致内存耗尽"""
-        with self._cmd_thread_lock:
-            if self._cmd_thread_count >= config.MAX_CMD_THREADS:
-                self.logger.warning(
-                    f"[NET] 并发命令线程已达上限({config.MAX_CMD_THREADS})，跳过: {getattr(target, '__name__', str(target))}"
-                )
-                return False
-            self._cmd_thread_count += 1
-
-        def _wrapper(*a):
-            try:
-                target(*a)
-            except Exception as e:
-                self.logger.error(f"[NET] 命令线程异常: {e}")
-            finally:
-                with self._cmd_thread_lock:
-                    self._cmd_thread_count -= 1
-
-        import _thread
-        _thread.start_new_thread(_wrapper, args)
-        return True
-
     # ==================== 业务方法 ====================
     
     def read_device_id(self):
         """从 /device_key 文件读取设备唯一 ID，失败则使用默认值"""
-
         def _set_password_for_device_id(device_id):
             if getattr(config, "USE_TCP_SSL", False):
                 iccid = self.get_4g_mccid()
@@ -273,7 +242,6 @@ class NetworkManager:
         连接 Wi-Fi：委托 ``wifi_manager.connect_wifi``。
         未指定 ``verify_host``/``verify_port`` 时，可达性校验使用本管理器配置的 ``_server_ip``/``_server_port``。
         """
-
         def _verify(ip: str):
             v_host = verify_host if verify_host is not None else self._server_ip
             v_port = verify_port if verify_port is not None else self._server_port
@@ -331,10 +299,7 @@ class NetworkManager:
             if atc is None:
                 return False
 
-            if not self._uart4g_lock.acquire(timeout=3000):
-                self.logger.warning("[4G] 获取 uart4g_lock 超时，跳过 4G 可用性检查")
-                return False
-            try:
+            with self.get_uart_lock():
                 # 1) SIM 就绪
                 r = atc.send("AT+CPIN?", "READY", 3000)
                 if "READY" not in r:
@@ -375,8 +340,6 @@ class NetworkManager:
                 if ip2:
                     return True
                 return False
-            finally:
-                self._uart4g_lock.release()
         except Exception:
             return False
 
@@ -392,13 +355,8 @@ class NetworkManager:
             atc = hardware_manager.at_client
             if atc is None:
                 return None
-            if not self._uart4g_lock.acquire(timeout=3000):
-                self.logger.warning("[4G] get_4g_phone_number 获取锁超时")
-                return None
-            try:
+            with self.get_uart_lock():
                 resp = atc.send("AT+CNUM", "OK", 3000)
-            finally:
-                self._uart4g_lock.release()
             if not resp:
                 return None
             # 可能多行 +CNUM，取第一个非空号码
@@ -421,13 +379,8 @@ class NetworkManager:
             atc = hardware_manager.at_client
             if atc is None:
                 return None
-            if not self._uart4g_lock.acquire(timeout=3000):
-                self.logger.warning("[4G] get_4g_mccid 获取锁超时")
-                return None
-            try:
+            with self.get_uart_lock():
                 resp = atc.send("AT+MCCID", "OK", 3000)
-            finally:
-                self._uart4g_lock.release()
             if not resp or "ERROR" in resp.upper():
                 return None
             m = re.search(r"\+MCCID:\s*(.+)", resp, re.IGNORECASE)
@@ -584,133 +537,14 @@ class NetworkManager:
             self._session_force_4g = False
             return False
 
-    def _cmd200_detect_laser(self):
-        """后台线程执行 cmd200 激光检测，避免阻塞主循环"""
-        from laser_manager import laser_manager
-        try:
-            laser_manager.turn_on_laser()
-            self.logger.info("[LASER] cmd200 已发送开激光指令")
-        except Exception as e:
-            self.logger.warning(f"[LASER] cmd200 开激光异常: {e}")
-
-        try:
-            from laser_detector import get_stable_laser_point
-            time.sleep_ms(500)
-            result = get_stable_laser_point(timeout_ms=60000)
-            if result:
-                x, y = result
-                self.safe_enqueue({
-                    "cmd": 200,
-                    "result": "laser_detect_ok",
-                    "x": x,
-                    "y": y,
-                }, 2)
-                self.logger.info(f"[LASER] cmd200 检测结果: ({x}, {y})")
-            else:
-                self.safe_enqueue({
-                    "cmd": 200,
-                    "result": "laser_detect_failed",
-                }, 2)
-                self.logger.warning("[LASER] cmd200 检测失败")
-        except Exception as e:
-            self.logger.error(f"[LASER] cmd200 检测异常: {e}")
-
-    def _cmd300_ota(self, data_obj):
-        """后台线程执行 cmd300 OTA，避免阻塞主循环"""
-        hardware_manager.start_idle_timer()
-        inner_data = data_obj.get("data", {}) if isinstance(data_obj, dict) else {}
-        self.logger.info(f"[New Ota] cmd300 , data: {inner_data}")
-        ssid = inner_data.get("ssid")
-        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")
-            if self.logger:
-                self.logger.info(f"[ota] Connect success, got ip{w.get_ip()}")
-            self.safe_enqueue(
-                {
-                    "cmd": 300,
-                    "result": "ota start...",
-                    "wifi": w.get_ip(),
-                },
-                2,
-            )
-            subprocess.run(
-                ["sh", "/maixapp/apps/t11/ota_curl.sh", ota_res_url])
-            self.safe_enqueue(
-                {
-                    "cmd": 300,
-                    "result": "success",
-                    "wifi": w.get_ip(),
-                },
-                2,
-            )
-        except Exception as e:
-            self.logger.error(f"[ota] cmd300 失败: {e}")
-            self.safe_enqueue(
-                {
-                    "cmd": 300,
-                    "result": "ota fail",
-                    "reason": str(e),
-                },
-                2,
-            )
-
-    def _cmd600_conn_wifi(self, data_obj):
-        hardware_manager.start_idle_timer()
-        inner_data = data_obj.get("data", {}) if isinstance(data_obj, dict) else {}
-        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")
-            if self.logger:
-                self.logger.info(f"[ota] Connect success, got ip{w.get_ip()}")
-            self.safe_enqueue(
-                {
-                    "cmd": 600,
-                    "result": "success",
-                    "wifi": w.get_ip(),
-                },
-                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(
-                {
-                    "cmd": 600,
-                    "result": "conn fail",
-                    "reason": str(e),
-                },
-                2,
-            )
-            self._switch_to_4g_due_to_poor_wifi()
     
     def safe_enqueue(self, data_dict, msg_type=2, high=False):
         """线程安全地将消息加入队列（公共方法）"""
         self._enqueue((msg_type, data_dict), high)
     
+
+    
+
     def connect_server(self):
         """
         连接到服务器（自动选择WiFi或4G）
@@ -723,7 +557,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 +574,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）。
@@ -869,10 +672,7 @@ class NetworkManager:
         host = self._server_ip
         port = getattr(config, "TCP_SSL_PORT", 443) if use_ssl else config.SERVER_PORT
         tail = getattr(config, "MIPOPEN_TAIL", "")
-        if not self._uart4g_lock.acquire(timeout=15000):
-            self.logger.warning("[4G-TCP] 连接：获取 uart4g_lock 超时")
-            return False
-        try:
+        with self.get_uart_lock():
             resp = hardware_manager.at_client.send(f"AT+MIPCLOSE={link_id}", "OK", 1000)
             self.logger.info(f"[4G-TCP] AT+MIPCLOSE={link_id} response: {resp}")
 
@@ -886,8 +686,6 @@ class NetworkManager:
             cmd = f'AT+MIPOPEN={link_id},"TCP","{host}",{port}'
             res = hardware_manager.at_client.send(cmd, "+MIPOPEN", 8000)
             self.logger.info(f"[4G-TCP] {cmd} response: {res}")
-        finally:
-            self._uart4g_lock.release()
         if f"+MIPOPEN: {link_id},0" in res:
             self._tcp_connected = True
             return True
@@ -1010,13 +808,9 @@ class NetworkManager:
     
     def _disconnect_tcp_via_4g(self):
         link_id = getattr(config, "TCP_LINK_ID", 0)
-        if not self._uart4g_lock.acquire(timeout=2000):
-            self.logger.warning("[4G-TCP] 断开连接：获取 uart4g_lock 超时")
-            return
-        try:
+        with self.get_uart_lock():
             hardware_manager.at_client.send(f"AT+MIPCLOSE={link_id}", "OK", 1000)
-        finally:
-            self._uart4g_lock.release()
+
 
     def tcp_send_raw(self, data: bytes, max_retries=2) -> bool:
         """
@@ -1065,7 +859,7 @@ class NetworkManager:
                             raise
                         if sent == 0:
                             # socket连接已断开
-                            self.logger.warning(f"[WIFI-TCP] 发送失败，socket已断开（尝试 {attempt + 1}/{max_retries}）")
+                            self.logger.warning(f"[WIFI-TCP] 发送失败，socket已断开（尝试 {attempt+1}/{max_retries}）")
                             raise OSError("wifi socket closed (send returned 0)")
                         total_sent += sent
                     
@@ -1076,7 +870,7 @@ class NetworkManager:
                     time.sleep_ms(50)
                     
                 except OSError as e:
-                    self.logger.error(f"[WIFI-TCP] 发送异常: {e}（尝试 {attempt + 1}/{max_retries}）")
+                    self.logger.error(f"[WIFI-TCP] 发送异常: {e}（尝试 {attempt+1}/{max_retries}）")
                     # 发送异常通常意味着连接已不可用，主动关闭以触发重连
                     try:
                         wifi_manager.wifi_socket.close()
@@ -1086,7 +880,7 @@ class NetworkManager:
                     self._tcp_connected = False
                     return False
                 except Exception as e:
-                    self.logger.error(f"[WIFI-TCP] 未知错误: {e}（尝试 {attempt + 1}/{max_retries}）")
+                    self.logger.error(f"[WIFI-TCP] 未知错误: {e}（尝试 {attempt+1}/{max_retries}）")
                     try:
                         wifi_manager.wifi_socket.close()
                     except:
@@ -1099,10 +893,7 @@ class NetworkManager:
     
     def _tcp_send_raw_via_4g(self, data: bytes, max_retries=2) -> bool:
         link_id = getattr(config, "TCP_LINK_ID", 0)
-        if not self._uart4g_lock.acquire(timeout=2000):
-            self.logger.warning("[4G-TCP] 获取 uart4g_lock 超时（其他线程持有），跳过本次发送")
-            return False
-        try:
+        with self.get_uart_lock():
             for _ in range(max_retries):
                 cmd = f'AT+MIPSEND={link_id},{len(data)}'
                 if ">" not in hardware_manager.at_client.send(cmd, ">", 2000):
@@ -1118,15 +909,11 @@ 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
                 time.sleep_ms(50)
             return False
-        finally:
-            self._uart4g_lock.release()
 
     def _configure_ssl_before_connect(self, link_id: int) -> bool:
         """按手册：MSSLCFG(auth) -> (可选) MSSLCERTWR -> MSSLCFG(cert) -> MIPCFG(ssl)"""
@@ -1179,6 +966,7 @@ class NetworkManager:
             r = hardware_manager.at_client.send(f'AT+MSSLCERTRD="{cert_filename}"', "OK", 3000)
             self.logger.info(f"[4G-TCP] AT+MSSLCERTRD=\"{cert_filename}\" response: {r}")
         
+
             # 3) 引用根证书
             r = hardware_manager.at_client.send(f'AT+MSSLCFG="cert",{ssl_id},"{cert_filename}"', "OK", 3000)
             if "OK" not in r:
@@ -1236,8 +1024,7 @@ class NetworkManager:
             self.logger.error(f"[WIFI-TCP] 接收数据异常: {e}")
             return b""
 
-    def _upload_log_file(self, upload_url, wifi_ssid=None, wifi_password=None, include_rotated=True, max_files=None,
-                         archive_format="tgz"):
+    def _upload_log_file(self, upload_url, wifi_ssid=None, wifi_password=None, include_rotated=True, max_files=None, archive_format="tgz"):
         """上传日志文件到指定URL
         
         Args:
@@ -1370,8 +1157,7 @@ class NetworkManager:
                     staged_paths.append(dst)
             except Exception as e:
                 self.logger.error(f"[LOG_UPLOAD] 复制日志快照失败: {e}")
-                self.safe_enqueue({"result": "log_upload_failed", "reason": "snapshot_failed", "detail": str(e)[:100]},
-                                  2)
+                self.safe_enqueue({"result": "log_upload_failed", "reason": "snapshot_failed", "detail": str(e)[:100]}, 2)
                 try:
                     shutil.rmtree(staging_dir)
                 except:
@@ -1399,8 +1185,7 @@ class NetworkManager:
                 self.logger.info(f"[LOG_UPLOAD] 日志压缩包已生成: {archive_path}")
             except Exception as e:
                 self.logger.error(f"[LOG_UPLOAD] 打包压缩失败: {e}")
-                self.safe_enqueue({"result": "log_upload_failed", "reason": "archive_failed", "detail": str(e)[:100]},
-                                  2)
+                self.safe_enqueue({"result": "log_upload_failed", "reason": "archive_failed", "detail": str(e)[:100]}, 2)
                 try:
                     shutil.rmtree(staging_dir)
                 except:
@@ -1449,8 +1234,7 @@ class NetworkManager:
                         "status_code": response.status_code
                     }, 2)
                 else:
-                    self.logger.error(
-                        f"[LOG_UPLOAD] 上传失败! 状态码: {response.status_code}, 响应: {response.text[:200]}")
+                    self.logger.error(f"[LOG_UPLOAD] 上传失败! 状态码: {response.status_code}, 响应: {response.text[:200]}")
                     self.safe_enqueue({
                         "result": "log_upload_failed",
                         "reason": f"http_{response.status_code}",
@@ -1586,8 +1370,7 @@ class NetworkManager:
         except Exception as e:
             return None, f"prepare_exception: {e}"
 
-    def _upload_log_file_v2(self, upload_url, upload_token, key, outlink="", include_rotated=True, max_files=None,
-                            archive_format="tgz"):
+    def _upload_log_file_v2(self, upload_url, upload_token, key, outlink="", include_rotated=True, max_files=None, archive_format="tgz"):
         """上传日志到 Qiniu（支持 WiFi 和 4G 双路径）
 
         流程：准备日志归档 -> 自动检测网络 -> WiFi(requests) 或 4G(AT命令) 上传
@@ -1809,6 +1592,8 @@ class NetworkManager:
 
     def tcp_main(self):
         """TCP 主通信循环：登录、心跳、处理指令、发送数据"""
+        import _thread
+        
         self.logger.info("[NET] TCP主线程启动")
         
         send_hartbeat_fail_count = 0
@@ -1834,7 +1619,7 @@ class NetworkManager:
                     continue
 
                 if not self.connect_server():
-                    time.sleep_ms(1000)
+                    time.sleep_ms(5000)
                     continue
 
                 # 发送登录包
@@ -1855,7 +1640,7 @@ class NetworkManager:
                         self.disconnect_server()
                     except:
                         pass
-                    time.sleep_ms(500)
+                    time.sleep_ms(2000)
                     continue
 
                 self.logger.info("➡️ 登录包已发送，等待确认...")
@@ -1920,8 +1705,7 @@ class NetworkManager:
     
                             if not logged_in:
                                 try:
-                                    self.logger.debug(
-                                        f"[TCP] rx link={link_id} len={len(payload)} head={payload[:12].hex()}")
+                                    self.logger.debug(f"[TCP] rx link={link_id} len={len(payload)} head={payload[:12].hex()}")
                                 except:
                                     pass
     
@@ -1947,8 +1731,7 @@ class NetworkManager:
                                                     pending_obj = json.load(f)
                                             except:
                                                 pending_obj = {}
-                                            self.safe_enqueue({"result": "ota_ok", "url": pending_obj.get("url", "")},
-                                                              2)
+                                            self.safe_enqueue({"result": "ota_ok", "url": pending_obj.get("url", "")}, 2)
                                             self.logger.info("[OTA] 已上报 ota_ok，等待心跳确认后删除 pending")
                                     except Exception as e:
                                         self.logger.error(f"[OTA] ota_ok 上报失败: {e}")
@@ -1967,8 +1750,7 @@ class NetworkManager:
                                     t = body.get('t', 0)
                                     v = body.get('v')
                                     # 如果是第一个分片，清空之前的缓存
-                                    if len(self._raw_line_data) == 0 or (
-                                            len(self._raw_line_data) > 0 and self._raw_line_data[0].get('v') != v):
+                                    if len(self._raw_line_data) == 0 or (len(self._raw_line_data) > 0 and self._raw_line_data[0].get('v') != v):
                                         self._raw_line_data.clear()
                                     # 或者更简单：每次收到命令40时，如果版本号不同，清空缓存
                                     if len(self._raw_line_data) > 0:
@@ -1985,7 +1767,7 @@ class NetworkManager:
                                             file.write("\n".join(stock_array))
                                         ota_manager.apply_ota_and_reboot(None, local_filename)
                                     else:
-                                        self.safe_enqueue({'data': {'l': len(self._raw_line_data), 'v': v}, 'cmd': 41})
+                                        self.safe_enqueue({'data':{'l': len(self._raw_line_data), 'v': v}, 'cmd': 41})
                                     self.logger.info(f"已下载{len(self._raw_line_data)} 全部：{t} 版本：{v}")
     
                             elif logged_in and msg_type == 100:
@@ -2002,8 +1784,7 @@ class NetworkManager:
                                     # 验证必需字段
                                     if not upload_url or not upload_token or not shoot_id:
                                         self.logger.error("[IMAGE_UPLOAD] 缺少必需参数: uploadUrl, token 或 shootId")
-                                        self.safe_enqueue({"result": "image_upload_failed", "reason": "missing_params"},
-                                                          2)
+                                        self.safe_enqueue({"result": "image_upload_failed", "reason": "missing_params"}, 2)
                                     else:
                                         self.logger.info(f"[IMAGE_UPLOAD] 收到图片上传命令，shootId: {shoot_id}")
                                         # 查找文件名中包含 shoot_id 的图片文件（文件名格式：shot_{shoot_id}_*.bmp）
@@ -2024,19 +1805,15 @@ class NetworkManager:
                                                         reverse=True
                                                     )
                                                     target_image = os.path.join(photo_dir, matched_images[0])
-                                                    self.logger.info(
-                                                        f"[IMAGE_UPLOAD] 找到匹配shootId的图片: {matched_images[0]}")
+                                                    self.logger.info(f"[IMAGE_UPLOAD] 找到匹配shootId的图片: {matched_images[0]}")
                                                 else:
-                                                    self.logger.warning(
-                                                        f"[IMAGE_UPLOAD] 未找到包含shootId={shoot_id}的图片文件")
+                                                    self.logger.warning(f"[IMAGE_UPLOAD] 未找到包含shootId={shoot_id}的图片文件")
                                         except Exception as e:
                                             self.logger.error(f"[IMAGE_UPLOAD] 查找图片失败: {e}")
 
                                         if not target_image:
                                             self.logger.error(f"[IMAGE_UPLOAD] 未找到shootId={shoot_id}对应的图片文件")
-                                            self.safe_enqueue(
-                                                {"result": "image_upload_failed", "reason": "no_image_found",
-                                                 "shootId": shoot_id}, 2)
+                                            self.safe_enqueue({"result": "image_upload_failed", "reason": "no_image_found", "shootId": shoot_id}, 2)
                                         else:
                                             # 构建上传key
                                             ext = os.path.splitext(target_image)[1].lower()
@@ -2044,7 +1821,8 @@ class NetworkManager:
                                             self.logger.info(f"[IMAGE_UPLOAD] 准备上传: {target_image} -> {key}")
 
                                             # 在新线程中执行上传，避免阻塞主循环
-                                            self._spawn_cmd_thread(
+                                            import _thread
+                                            _thread.start_new_thread(
                                                 self._upload_image_file,
                                                 (target_image, upload_url, upload_token, key, shoot_id, outlink)
                                             )
@@ -2067,51 +1845,18 @@ class NetworkManager:
                                     # 验证必需字段
                                     if not upload_url or not upload_token or not key:
                                         self.logger.error("[LOG_UPLOAD] 缺少必需参数: uploadUrl, token 或 key")
-                                        self.safe_enqueue({"result": "log_upload_failed", "reason": "missing_params"},
-                                                          2)
+                                        self.safe_enqueue({"result": "log_upload_failed", "reason": "missing_params"}, 2)
                                     else:
                                         self.logger.info(f"[LOG_UPLOAD] 收到日志上传命令，key: {key}")
                                         # 在新线程中执行上传，避免阻塞主循环
-                                        self._spawn_cmd_thread(
+                                        import _thread
+                                        _thread.start_new_thread(
                                             self._upload_log_file_v2,
-                                            (upload_url, upload_token, key, outlink, include_rotated, max_files,
-                                             archive_format)
+                                            (upload_url, upload_token, key, outlink, include_rotated, max_files, archive_format)
                                         )
                                         # 立即返回已入队确认
                                         self.safe_enqueue({"result": "log_upload_queued"}, 2)
-                            elif logged_in and msg_type == 201:
-                                if self.logger:
-                                    self.logger.info(f"[LASER] cmd201:{body}")
-                                raw_x = body.get("x")
-                                raw_y = body.get("y")
-                                try:
-                                    from laser_manager import laser_manager
-                                    ix, iy = laser_manager.set_hardcoded_laser_point(
-                                        raw_x, raw_y
-                                    )
-                                    self.safe_enqueue(
-                                        {
-                                            "cmd": 201,
-                                            "result": "laser_point_set",
-                                            "x": ix,
-                                            "y": iy,
-                                        },
-                                        2,
-                                    )
-                                    self.logger.info(
-                                        f"[LASER] cmd201 硬编码激光点=({ix}, {iy})"
-                                    )
-                                except Exception as e:
-                                    self.logger.error(f"[LASER] cmd201 失败: {e}")
-                                    self.safe_enqueue(
-                                        {
-                                            "cmd": 201,
-                                            "result": "laser_point_set_failed",
-                                            "reason": str(e),
-                                        },
-                                        2,
-                                    )
-                                hardware_manager.start_idle_timer()
+
                             # 处理业务指令
                             elif logged_in and isinstance(body, dict):
                                 inner_cmd = None
@@ -2123,7 +1868,7 @@ class NetworkManager:
                                         if not laser_manager.calibration_active:
                                             laser_manager.turn_on_laser()
                                             time.sleep_ms(100)
-                                            hardware_manager.stop_idle_timer()  # 停表
+                                            hardware_manager.stop_idle_timer() # 停表
                                             if not config.HARDCODE_LASER_POINT:
                                                 laser_manager.start_calibration()
                                                 self.safe_enqueue({"result": "calibrating"}, 2)
@@ -2134,7 +1879,8 @@ class NetworkManager:
                                         from laser_manager import laser_manager
                                         laser_manager.turn_off_laser()
                                         laser_manager.stop_calibration()
-                                        hardware_manager.start_idle_timer()  # 开表
+                                        laser_manager.stop_remote_laser_detect()
+                                        hardware_manager.start_idle_timer() # 开表
                                         self.safe_enqueue({"result": "laser_off"}, 2)
                                     elif inner_cmd == 4:  # 上报电量
                                         voltage = get_bus_voltage()
@@ -2142,20 +1888,9 @@ class NetworkManager:
                                         battery_data = {
                                             "battery": battery_percent,
                                             "voltage": round(float(voltage), 3),
-                                            "netType": self.network_type,
                                         }
                                         self.safe_enqueue(battery_data, 2)
-                                        self.logger.info(f"电量上报: {battery_percent}% 充电: {is_charging()}")
-                                        if getattr(config, "CHARGING_AUTO_POWER_OFF_ENABLED", False) and 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")
@@ -2186,19 +1921,17 @@ class NetworkManager:
                                                 # 只有同时满足：WiFi已连接 且 提供了WiFi凭证，才使用WiFi
                                                 if self.is_wifi_connected() and ssid and password:
                                                     mode = "wifi"
-                                                    self.logger.info(
-                                                        "ota auto-selected: wifi (WiFi connected and credentials provided)")
+                                                    self.logger.info("ota auto-selected: wifi (WiFi connected and credentials provided)")
                                                 else:
                                                     mode = "4g"
-                                                    self.logger.info(
-                                                        "ota auto-selected: 4g (WiFi not available or no credentials)")
+                                                    self.logger.info("ota auto-selected: 4g (WiFi not available or no credentials)")
     
                                         hardware_manager.stop_idle_timer()  # 停表，注意OTA停表之后，就没有再开表，因为OTA后面会重启，会重新开表
     
                                         if mode == "4g":
                                             ota_manager._set_ota_url(ota_url)  # 记录 OTA URL，供命令7使用
                                             ota_manager._start_update_thread()
-                                            self._spawn_cmd_thread(ota_manager.direct_ota_download_via_4g, (ota_url,))
+                                            _thread.start_new_thread(ota_manager.direct_ota_download_via_4g, (ota_url,))
                                         else:  # mode == "wifi"
                                             if not ssid or not password:
                                                 self.logger.error("ota wifi mode requires ssid and password")
@@ -2207,12 +1940,10 @@ class NetworkManager:
                                                 self.logger.info(f"ssid: {ssid}")
                                                 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))
+                                                _thread.start_new_thread(ota_manager.handle_wifi_and_update, (ssid, password, ota_url))
                                     elif inner_cmd == 6:
                                         try:
-                                            ip = os.popen(
-                                                "ifconfig wlan0 2>/dev/null | grep 'inet ' | awk '{print $2}'").read().strip()
+                                            ip = os.popen("ifconfig wlan0 2>/dev/null | grep 'inet ' | awk '{print $2}'").read().strip()
                                             ip = ip if ip else "no_ip"
                                         except:
                                             ip = "error_getting_ip"
@@ -2220,18 +1951,91 @@ class NetworkManager:
                                     elif inner_cmd == 44:  # 读 4G 本机号码（AT+CNUM）
                                         cnum = self.get_4g_phone_number()
                                         self.logger.info(f"4G 本机号码: {cnum}")
-                                        self.safe_enqueue(
-                                            {"result": "cnum", "number": cnum if cnum is not None else ""}, 2)
+                                        self.safe_enqueue({"result": "cnum", "number": cnum if cnum is not None else ""}, 2)
                                     elif inner_cmd == 45:  # 读 MCCID（AT+MCCID）
                                         mccid = self.get_4g_mccid()
                                         self.logger.info(f"4G MCCID: {mccid}")
-                                        self.safe_enqueue(
-                                            {"result": "mccid", "mccid": mccid if mccid is not None else ""}, 2)
+                                        self.safe_enqueue({"result": "mccid", "mccid": mccid if mccid is not None else ""}, 2)
+                                    elif inner_cmd == 200:  # 远程激光点识别：稳定 3s 后上报 (x,y)
+                                        from laser_manager import laser_manager
+                                        # 远程激光识别期间不能停掉心跳/空闲计时，否则会影响数据上报与连接保持
+                                        # 这里仅启动远程识别，不停止网络侧心跳。
+                                        try:
+                                            laser_manager.turn_on_laser()
+                                            if self.logger:
+                                                self.logger.info("[LASER] cmd200 已发送开激光指令")
+                                        except Exception as e:
+                                            if self.logger:
+                                                self.logger.warning(
+                                                    f"[LASER] cmd200 开激光异常: {e}"
+                                                )
+                                        if not laser_manager.start_remote_laser_detect():
+                                            self.safe_enqueue(
+                                                {
+                                                    "cmd": 200,
+                                                    "result": "laser_detect_busy",
+                                                },
+                                                2,
+                                            )
+                                        else:
+                                            self.safe_enqueue(
+                                                {
+                                                    "cmd": 200,
+                                                    "result": "laser_detect_started",
+                                                },
+                                                2,
+                                            )
+                                    elif inner_cmd == 201:  # 设置硬编码激光点并结束远程识别会话
+                                        from laser_manager import laser_manager
+                                        laser_manager.stop_remote_laser_detect()
+                                        inner_data = (
+                                            data_obj.get("data", {})
+                                            if isinstance(data_obj.get("data"), dict)
+                                            else {}
+                                        )
+                                        raw_x = data_obj.get("x", inner_data.get("x"))
+                                        raw_y = data_obj.get("y", inner_data.get("y"))
+                                        try:
+                                            ix, iy = laser_manager.set_hardcoded_laser_point(
+                                                raw_x, raw_y
+                                            )
+                                            self.safe_enqueue(
+                                                {
+                                                    "cmd": 201,
+                                                    "result": "laser_point_set",
+                                                    "x": ix,
+                                                    "y": iy,
+                                                },
+                                                2,
+                                            )
+                                            self.logger.info(
+                                                f"[LASER] cmd201 硬编码激光点=({ix}, {iy})"
+                                            )
+                                        except Exception as e:
+                                            self.logger.error(f"[LASER] cmd201 失败: {e}")
+                                            self.safe_enqueue(
+                                                {
+                                                    "cmd": 201,
+                                                    "result": "laser_point_set_failed",
+                                                    "reason": str(e),
+                                                },
+                                                2,
+                                            )
+                                        hardware_manager.start_idle_timer()
+                                    elif inner_cmd == 46:  # 开关射箭原图保存
+                                        inner_data = data_obj.get("data", {}) if isinstance(data_obj, dict) else {}
+                                        enabled = True
+                                        if isinstance(inner_data, dict) and "enable" in inner_data:
+                                            enabled = bool(inner_data.get("enable"))
+                                        config.SAVE_RAW_SHOT_IMAGE_ENABLED = enabled
+                                        self.logger.info(f"[RAW_IMAGE] 射箭原图保存开关: {enabled}")
+                                        self.safe_enqueue({"result": "raw_image_save", "enabled": enabled}, 2)
+                                        hardware_manager.start_idle_timer()  # 重新计时
                                     elif inner_cmd == 41:
                                         self.logger.info(f"[TEST] 收到TCP射箭触发命令, {time.time()}")
                                         self._manual_trigger_flag = True
                                         self.safe_enqueue({"result": "trigger_ack"}, 2)
-                                        hardware_manager.start_idle_timer()  # 重新计时
+                                        hardware_manager.start_idle_timer() # 重新计时
                                     elif inner_cmd == 42:  # 关机命令
                                         self.logger.info("[SHUTDOWN] 收到TCP关机命令，准备关机...")
                                         self.safe_enqueue({"result": "shutdown_ack"}, 2)
@@ -2263,28 +2067,17 @@ class NetworkManager:
     
                                         if not upload_url:
                                             self.logger.error("[LOG_UPLOAD] 缺少 url 参数")
-                                            self.safe_enqueue({"result": "log_upload_failed", "reason": "missing_url"},
-                                                              2)
+                                            self.safe_enqueue({"result": "log_upload_failed", "reason": "missing_url"}, 2)
                                         else:
                                             self.logger.info(f"[LOG_UPLOAD] 收到日志上传命令，目标URL: {upload_url}")
-                                        # 在新线程中执行上传，避免阻塞主循环
-                                        self._spawn_cmd_thread(
-                                            self._upload_log_file,
-                                            (upload_url, wifi_ssid, wifi_password, include_rotated, max_files,
-                                             archive_format)
-                                        )
-                                    elif inner_cmd == 200:
-                                        self.logger.info("[LASER] cmd200 在后台线程执行检测")
-                                        self._spawn_cmd_thread(self._cmd200_detect_laser, ())
-                                    elif inner_cmd == 300:
-                                        self.logger.info("[New Ota] cmd300 在后台线程执行OTA")
-                                        self._spawn_cmd_thread(self._cmd300_ota, (data_obj,))
-                                    elif inner_cmd == 600:
-                                        self.logger.info("[conn wifi] cmd600 在后台线程执行连接wifi: {data_obj}")
-                                        self._spawn_cmd_thread(self._cmd600_conn_wifi, (data_obj,))
-                                    elif inner_cmd == 601:
-                                        pass
-                                else:  # data的结构不是 dict
+                                            # 在新线程中执行上传，避免阻塞主循环
+                                            import _thread
+                                            _thread.start_new_thread(
+                                                self._upload_log_file,
+                                                (upload_url, wifi_ssid, wifi_password, include_rotated, max_files, archive_format)
+                                            )
+                                    
+                                else: # data的结构不是 dict
                                     self.logger.info(f"[NET] body={body}, {time.time()}")
                             else:
                                 self.logger.info(f"[NET] 未知数据 {body}, {time.time()}")
@@ -2312,14 +2105,12 @@ class NetworkManager:
                             msg_type, data_dict = item
                             pkt = self._netcore.make_packet(msg_type, data_dict)
                             if not self.tcp_send_raw(pkt):
-                                # 发送失败：将消息放回队首（队列满则丢弃）
+                                # 发送失败：将消息放回队首，触发重连（避免丢消息）
                                 with self.get_queue_lock():
                                     if item_is_high:
-                                        if len(self._high_send_queue) < config.MAX_SEND_QUEUE_SIZE:
-                                            self._high_send_queue.insert(0, item)
+                                        self._high_send_queue.insert(0, item)
                                     else:
-                                        if len(self._normal_send_queue) < config.MAX_SEND_QUEUE_SIZE:
-                                            self._normal_send_queue.insert(0, item)
+                                        self._normal_send_queue.insert(0, item)
                                 self._tcp_connected = False
                                 try:
                                     self.disconnect_server()
@@ -2327,7 +2118,7 @@ class NetworkManager:
                                     pass
                                 break
 
-                    # 发送激光校准结果
+                    # 发送激光校准结果（cmd=2 等传统校准）
                     if logged_in:
                         from laser_manager import laser_manager
                         result = laser_manager.get_calibration_result()
@@ -2335,13 +2126,27 @@ class NetworkManager:
                             x, y = result
                             self.safe_enqueue({"result": "ok", "x": x, "y": y}, 2)
 
+                    # 发送远程激光识别结果（cmd=200，会话持续至 cmd=201）
+                    if logged_in:
+                        from laser_manager import laser_manager
+                        rd = laser_manager.get_remote_detect_result()
+                        if rd and isinstance(rd, dict) and rd.get("status") == "ok":
+                            self.safe_enqueue(
+                                {
+                                    "cmd": 200,
+                                    "result": "laser_detect_ok",
+                                    "x": rd.get("x"),
+                                    "y": rd.get("y"),
+                                },
+                                2,
+                            )
+
                     # 定期发送心跳
                     current_time = time.ticks_ms()
                     if logged_in and current_time - last_heartbeat_send_time > config.HEARTBEAT_INTERVAL * 1000:
                         vol_val = get_bus_voltage()
-                        if not self.tcp_send_raw(
-                                self._netcore.make_packet(4, {"vol": vol_val, "vol_per": voltage_to_percent(vol_val)})):
-                            # if not self.tcp_send_raw(self.make_packet(4, {"vol": vol_val, "vol_per": voltage_to_percent(vol_val)})):
+                        if not self.tcp_send_raw(self._netcore.make_packet(4, {"vol": vol_val, "vol_per": voltage_to_percent(vol_val)})):
+                        # if not self.tcp_send_raw(self.make_packet(4, {"vol": vol_val, "vol_per": voltage_to_percent(vol_val)})):
                             send_hartbeat_fail_count += 1
                             # 短暂波动可能导致一次发送失败：连续失败达到阈值才重连，避免重连风暴
                             self.logger.error(f"心跳发送失败({send_hartbeat_fail_count}/3)，准备重试")
@@ -2354,8 +2159,8 @@ class NetworkManager:
                                     pass
                                 break
                             else:
-                                # 不立即断开，让下一轮心跳再试
-                                time.sleep_ms(50)
+                                # 不立即断开，让下一轮心跳再试；同时缩短一点等待，提升恢复速度
+                                time.sleep_ms(200)
                                 continue
                         else:
                             send_hartbeat_fail_count = 0
@@ -2385,8 +2190,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(2000)
                 
             except Exception as e:
                 # TCP主循环的顶层异常捕获，防止线程静默退出
@@ -2394,50 +2199,44 @@ class NetworkManager:
                 import traceback
                 self.logger.error(traceback.format_exc())
                 self._tcp_connected = False
-                time.sleep_ms(500)  # 等待5秒后重试连接
+                time.sleep_ms(5000)  # 等待5秒后重试连接
 
 
 # 创建全局单例实例
 network_manager = NetworkManager()
 
-
 # ==================== 向后兼容的函数接口 ====================
 
 def tcp_main():
     """TCP主循环（向后兼容接口）"""
     return network_manager.tcp_main()
 
-
 def read_device_id():
     """读取设备ID（向后兼容接口）"""
     return network_manager.read_device_id()
 
-
 def safe_enqueue(data_dict, msg_type=2, high=False):
     """线程安全地加入队列（向后兼容接口）"""
     return network_manager.safe_enqueue(data_dict, msg_type, high)
 
-
 def connect_server():
     """连接服务器（向后兼容接口）"""
     return network_manager.connect_server()
 
-
 def disconnet_server():
     """断开服务器连接（向后兼容接口）"""
     return network_manager.disconnect_server()
 
-
 def is_wifi_connected():
     """检查WiFi是否已连接（向后兼容接口）"""
     return network_manager.is_wifi_connected()
 
-
 def connect_wifi(ssid, password):
     """连接WiFi（向后兼容接口）"""
     return network_manager.connect_wifi(ssid, password)
 
-
 def is_server_reachable(host, port=80, timeout=5):
     """检查服务器是否可达（向后兼容接口）"""
     return network_manager.is_server_reachable(host, port, timeout)
+
+

official_pack_fip.py

@@ -1,603 +0,0 @@
-#!/usr/bin/env python3
-# PYTHON_ARGCOMPLETE_OK
-
-import sys
-import logging
-import os
-import re
-import os.path
-import collections
-import uuid
-import argparse
-import tarfile
-import io
-from struct import pack, unpack
-
-
-PYTHON_MIN_VERSION = (3, 5, 2)  # Ubuntu 16.04 LTS contains Python v3.5.2 by default
-
-
-if sys.version_info < PYTHON_MIN_VERSION:
-    print("Python >= %r is required" % (PYTHON_MIN_VERSION,))
-    sys.exit(-1)
-
-
-try:
-    import coloredlogs
-except ImportError:
-    coloredlogs = None
-
-try:
-    import argcomplete
-except ImportError:
-    argcomplete = None
-
-TOC_HEADER_NAME = 0xAA640001
-FIP_MAX_SIZE = 0xA0000
-FIP_ALIGN_SIZE = 2 * 1024
-ENTRY_SIZE = 0x28
-
-IV_ZERO = b"\0" * 16
-
-
-class FIP_HEADER_FLAG:
-    BitRange = collections.namedtuple("BitRange", "shift, bits")
-
-    REE_SCS = BitRange(0, 2)
-    REE_ENCRYPTION = BitRange(2, 2)
-
-    @classmethod
-    def test(cls, value, flag):
-        v = value >> flag.shift
-        v &= (1 << flag.bits) - 1
-        return v
-
-    @classmethod
-    def value(cls, flag):
-        v = (1 << flag.bits) - 1
-        v <<= flag.shift
-        return v
-
-
-class FIP_UUID:
-    # from arm-trusted-firmware/include/tools_share/firmware_image_package.h
-    uuid_c_define = """
-/* ToC Entry UUIDs */
-#define UUID_LICENSE_FILE \
-    {0x25360c62, 0x5151, 0x48ad, 0xb5, 0x91, {0x2d, 0x35, 0x67, 0x26, 0x85, 0xa5} }
-#define UUID_TRUSTED_UPDATE_FIRMWARE_SCP_BL2U \
-    {0x03279265, 0x742f, 0x44e6, 0x8d, 0xff, {0x57, 0x9a, 0xc1, 0xff, 0x06, 0x10} }
-#define UUID_TRUSTED_UPDATE_FIRMWARE_BL2U \
-    {0x37ebb360, 0xe5c1, 0x41ea, 0x9d, 0xf3, {0x19, 0xed, 0xa1, 0x1f, 0x68, 0x01} }
-#define UUID_TRUSTED_UPDATE_FIRMWARE_NS_BL2U \
-    {0x111d514f, 0xe52b, 0x494e, 0xb4, 0xc5, {0x83, 0xc2, 0xf7, 0x15, 0x84, 0x0a} }
-#define UUID_TRUSTED_FWU_CERT \
-    {0xb28a4071, 0xd618, 0x4c87, 0x8b, 0x2e, {0xc6, 0xdc, 0xcd, 0x50, 0xf0, 0x96} }
-#define UUID_TRUSTED_BOOT_FIRMWARE_BL2 \
-    {0x0becf95f, 0x224d, 0x4d3e, 0xa5, 0x44, {0xc3, 0x9d, 0x81, 0xc7, 0x3f, 0x0a} }
-#define UUID_BLD \
-    {0x3dfd6697, 0xbe89, 0x49e8, 0xae, 0x5d, {0x78, 0xa1, 0x40, 0x60, 0x82, 0x13} }
-#define UUID_EL3_RUNTIME_FIRMWARE_BL31 \
-    {0x6d08d447, 0xfe4c, 0x4698, 0x9b, 0x95, {0x29, 0x50, 0xcb, 0xbd, 0x5a, 0x00} }
-#define UUID_SECURE_PAYLOAD_BL32 \
-    {0x89e1d005, 0xdc53, 0x4713, 0x8d, 0x2b, {0x50, 0x0a, 0x4b, 0x7a, 0x3e, 0x38} }
-#define UUID_NON_TRUSTED_FIRMWARE_BL33 \
-    {0xa7eed0d6, 0xeafc, 0x4bd5, 0x97, 0x82, {0x99, 0x34, 0xf2, 0x34, 0xb6, 0xe4} }
-/* Key certificates */
-#define UUID_ROT_KEY_CERT \
-    {0x721d2d86, 0x60f8, 0x11e4, 0x92, 0x0b, {0x8b, 0xe7, 0x62, 0x16, 0x0f, 0x24} }
-#define UUID_BLD1_KEY_CERT \
-    {0x90e87e82, 0x60f8, 0x11e4, 0xa1, 0xb4, {0x77, 0x7a, 0x21, 0xb4, 0xf9, 0x4c} }
-#define UUID_BLD2_KEY_CERT \
-    {0xa1214202, 0x60f8, 0x11e4, 0x8d, 0x9b, {0xf3, 0x3c, 0x0e, 0x15, 0xa0, 0x14} }
-#define UUID_SOC_FW_KEY_CERT \
-    {0xccbeb88a, 0x60f9, 0x11e4, 0x9a, 0xd0, {0xeb, 0x48, 0x22, 0xd8, 0xdc, 0xf8} }
-#define UUID_TRUSTED_OS_FW_KEY_CERT \
-    {0x03d67794, 0x60fb, 0x11e4, 0x85, 0xdd, {0xb7, 0x10, 0x5b, 0x8c, 0xee, 0x04} }
-#define UUID_BL33_KEY_CERT \
-    {0x2a83d58a, 0x60fb, 0x11e4, 0x8a, 0xaf, {0xdf, 0x30, 0xbb, 0xc4, 0x98, 0x59} }
-/* Content certificates */
-#define UUID_TRUSTED_BOOT_FW_CERT \
-    {0xea69e2d6, 0x635d, 0x11e4, 0x8d, 0x8c, {0x9f, 0xba, 0xbe, 0x99, 0x56, 0xa5} }
-#define UUID_BLD_CONTENT_CERT \
-    {0x046fbe44, 0x635e, 0x11e4, 0xb2, 0x8b, {0x73, 0xd8, 0xea, 0xae, 0x96, 0x56} }
-#define UUID_SOC_FW_CONTENT_CERT \
-    {0x200cb2e2, 0x635e, 0x11e4, 0x9c, 0xe8, {0xab, 0xcc, 0xf9, 0x2b, 0xb6, 0x66} }
-#define UUID_TRUSTED_OS_FW_CONTENT_CERT \
-    {0x11449fa4, 0x635e, 0x11e4, 0x87, 0x28, {0x3f, 0x05, 0x72, 0x2a, 0xf3, 0x3d} }
-#define UUID_BL33_CONTENT_CERT \
-    {0xf3c1c48e, 0x635d, 0x11e4, 0xa7, 0xa9, {0x87, 0xee, 0x40, 0xb2, 0x3f, 0xa7} }
-/* CV keys */
-#define UUID_CV_TRUSTED_KEY_CERT \
-    {0x64fbfc49, 0x4b8c, 0x4ad3, 0xb9, 0x92, {0x93, 0x55, 0x89, 0xee, 0xf0, 0x12} }
-#define UUID_CV_NON_TRUSTED_KEY_CERT \
-    {0xcb48bf0d, 0x7012, 0x4201, 0xbc, 0x35, {0x8a, 0x51, 0xc4, 0x90, 0x90, 0x94} }
-
-/* DDR init*/
-#define UUID_CV_DDRINIT_KEY_CERT \
-    {0xa61c53c9, 0x886c, 0x484f, 0x96, 0x5d, {0xd2, 0xda, 0xd7, 0xc3, 0xeb, 0x13} }
-#define UUID_CV_DDRINIT_CONTENT_CERT \
-    {0x9dfaabd2, 0x7f1b, 0x47e6, 0xa8, 0xa6, {0x6a, 0xc3, 0x10, 0xcc, 0xac, 0x91} }
-#define UUID_CV_DDRINIT \
-    {0x5888a5cd, 0x38fc, 0x4f66, 0xae, 0x3d, {0x2e, 0x18, 0x6d, 0x69, 0x41, 0xfb} }
-
-/* Fast boot */
-#define UUID_CV_FASTBOOT_KEY_CERT \
-    {0x285df54e, 0x7b50, 0x4309, 0x9b, 0x52, {0x4b, 0xc4, 0x92, 0x82, 0x60, 0xdd} }
-#define UUID_CV_FASTBOOT_CONTENT_CERT \
-    {0x61f7595b, 0x8d77, 0x4e13, 0x91, 0x2a, {0x63, 0x6e, 0x58, 0xda, 0x5b, 0x69} }
-#define UUID_CV_FASTBOOT \
-    {0x43766198, 0xc363, 0x48db, 0xa9, 0x97, {0xf1, 0x0e, 0x93, 0x80, 0x4f, 0xea} }
-"""
-
-    @classmethod
-    def cls_init(cls):
-        txt = cls.uuid_c_define
-        txt = txt.replace("\r\n", "\n")
-        txt = txt.replace("\\\n", "\n")
-        rx = r"""
-            \#define\s+
-            (?P<name>\S+)\s+
-            {
-                \s*(?P<u0>0x\S+)\s*,\s*
-                \s*(?P<u1>0x\S+)\s*,\s*
-                \s*(?P<u2>0x\S+)\s*,\s*
-                \s*(?P<u3>0x\S+)\s*,\s*
-                \s*(?P<u4>0x\S+)\s*,\s*
-                {
-                    \s*(?P<u5>0x\S+)\s*,\s*
-                    \s*(?P<u6>0x\S+)\s*,\s*
-                    \s*(?P<u7>0x\S+)\s*,\s*
-                    \s*(?P<u8>0x\S+)\s*,\s*
-                    \s*(?P<u9>0x\S+)\s*,\s*
-                    \s*(?P<u10>0x\S+)\s*
-                }\s*,?\s*
-            }
-        """
-        for m in re.finditer(rx, txt, flags=re.X):
-            name = m.group("name")
-            u = m.group(*["u%d" % i for i in range(11)])
-            u = [int(i, 0) for i in u]
-            u = pack("<IHHBBBBBBBB", *u)
-            u = uuid.UUID(bytes=u)
-            setattr(cls, name, u)
-
-
-class Entry:
-    __slots__ = ["name", "loc", "uuid", "address", "flag", "content"]
-
-    def __init__(self):
-        self.loc = 0
-        self.uuid = uuid.UUID(int=0)
-        self.address = 0
-        self.flag = 0
-        self.content = b""
-
-    @classmethod
-    def make(cls, uuid, content):
-        entry = cls()
-        entry.uuid = uuid
-        entry.content = content
-        return entry
-
-    @classmethod
-    def from_fip(cls, name, loc, fip_bin):
-        data = fip_bin[loc : loc + ENTRY_SIZE]
-        uuid_bytes, address, size, flag = unpack("<16sQQQ", data)
-        content = fip_bin[address : address + size]
-
-        entry = cls()
-        entry.name = name
-        entry.loc = loc
-        entry.uuid = uuid.UUID(bytes=uuid_bytes)
-        entry.address = address
-        entry.flag = flag
-        entry.content = content
-        return entry
-
-    def to_bytes(self):
-        return pack("<16sQQQ", self.uuid.bytes, self.address, self.size, self.flag)
-
-    @property
-    def size(self):
-        return len(self.content)
-
-    @property
-    def end(self):
-        return self.address + self.size
-
-    def __str__(self):
-        return "<%-31s loc=0x%03x U=%s a=0x%05x,0x%05x,0x%05x f=0x%x>" % (
-            self.name,
-            self.loc,
-            self.uuid.hex[:8],
-            self.address,
-            self.end,
-            self.size,
-            self.flag,
-        )
-
-
-class FIP:
-    ENTRY_NAMES = collections.OrderedDict(
-        [
-            ("LICENSE_FILE", "UUID_LICENSE_FILE"),
-            ("BL2", "UUID_TRUSTED_BOOT_FIRMWARE_BL2"),
-            ("BLD", "UUID_BLD"),
-            ("BL31", "UUID_EL3_RUNTIME_FIRMWARE_BL31"),
-            ("BL32", "UUID_SECURE_PAYLOAD_BL32"),
-            ("BL33", "UUID_NON_TRUSTED_FIRMWARE_BL33"),
-            ("BLD1_KEY_CERT", "UUID_BLD1_KEY_CERT"),
-            ("BLD2_KEY_CERT", "UUID_BLD2_KEY_CERT"),
-            ("CV_TRUSTED_KEY_CERT", "UUID_CV_TRUSTED_KEY_CERT"),
-            ("SOC_FW_KEY_CERT", "UUID_SOC_FW_KEY_CERT"),
-            ("TRUSTED_OS_FW_KEY_CERT", "UUID_TRUSTED_OS_FW_KEY_CERT"),
-            ("CV_NON_TRUSTED_KEY_CERT", "UUID_CV_NON_TRUSTED_KEY_CERT"),
-            ("BL33_KEY_CERT", "UUID_BL33_KEY_CERT"),
-            ("TRUSTED_BOOT_FW_CERT", "UUID_TRUSTED_BOOT_FW_CERT"),
-            ("BLD_CONTENT_CERT", "UUID_BLD_CONTENT_CERT"),
-            ("SOC_FW_CONTENT_CERT", "UUID_SOC_FW_CONTENT_CERT"),
-            ("TRUSTED_OS_FW_CONTENT_CERT", "UUID_TRUSTED_OS_FW_CONTENT_CERT"),
-            ("BL33_CONTENT_CERT", "UUID_BL33_CONTENT_CERT"),
-            ("CV_DDRINIT", "UUID_CV_DDRINIT"),
-            ("CV_FASTBOOT", "UUID_CV_FASTBOOT"),
-        ]
-    )
-
-    TOC_Header = collections.namedtuple(
-        "TOC_Header", "name, serial, flag_res, flag_plat, flag_res2"
-    )
-
-    def __init__(self, path):
-        logging.info("FIP_BIN: %s", path)
-        self.path = path
-
-    def load(self):
-        with open(self.path, "rb") as fp:
-            self.binary = fp.read(FIP_MAX_SIZE)
-        logging.info("%s is %d bytes", self.path, len(self.binary))
-
-        self.header = self.TOC_Header(*unpack("<IIIHH", self.binary[0x00:0x10]))
-        if self.header.name != TOC_HEADER_NAME:
-            raise ValueError(
-                "FIP header is 0x%08x but should be 0x%08x"
-                % (self.header[0], TOC_HEADER_NAME)
-            )
-
-        logging.info("TOC header: flag_plat=0x%04x", self.header.flag_plat)
-        logging.info(
-            "  REE_SCS: %r",
-            FIP_HEADER_FLAG.test(self.header.flag_plat, FIP_HEADER_FLAG.REE_SCS),
-        )
-        logging.info(
-            "  REE_ENCRYPTION: %r",
-            FIP_HEADER_FLAG.test(self.header.flag_plat, FIP_HEADER_FLAG.REE_ENCRYPTION),
-        )
-
-        ents = []
-        for k, v in self.ENTRY_NAMES.items():
-            try:
-                ents.append((k, self.find_entry(v)))
-            except ValueError as err:
-                logging.warning("%s", err)
-
-        ents.sort(key=lambda x: x[1].address)
-        for n, (k, v) in enumerate(ents):
-            logging.debug("%s", v)
-            if n > 0:
-                pk, pv = ents[n - 1]
-                if v.loc != pv.loc + ENTRY_SIZE or v.address != pv.address + pv.size:
-                    raise Exception("Invalid FIP")
-
-        rest = self.binary[ents[-1][1].end :]
-        loc = rest.find(b"APLB")
-        if loc < 0:
-            raise Exception("No BLD/DDRC")
-        self.blp_ddrc_binary = rest[loc:]
-        logging.debug("blp_ddrc: 0x%04x at 0x%08x", len(self.blp_ddrc_binary), loc)
-
-        self.ents = collections.OrderedDict(ents)
-
-    def make_fip(self, output_path=None):
-        logging.info("New TOC header: flag_plat=0x%04x", self.header.flag_plat)
-        header_bin = pack("<IIIHH", *self.header)
-        fip_bin = header_bin
-
-        # Sort self.ents by the order of FIP.ENTRY_NAMES
-        sorted_ents = collections.OrderedDict()
-        for name in self.ENTRY_NAMES:
-            try:
-                sorted_ents[name] = self.ents[name]
-            except KeyError:
-                pass
-        self.ents = sorted_ents
-
-        offset = (len(self.ents) + 1) * ENTRY_SIZE + 0x10
-
-        for k, v in self.ents.items():
-            v.address = offset
-            fip_bin += v.to_bytes()
-            offset += v.size
-
-        null_entry = Entry()
-        null_entry.address = offset
-        fip_bin += null_entry.to_bytes()
-
-        for k, v in self.ents.items():
-            fip_bin += v.content
-
-        if (len(fip_bin) % FIP_ALIGN_SIZE) > 0:
-            fip_bin += b"\x00" * (FIP_ALIGN_SIZE - len(fip_bin) % FIP_ALIGN_SIZE)
-        fip_bin += self.blp_ddrc_binary
-
-        if output_path:
-            path = output_path
-        else:
-            path = os.path.splitext(self.path)
-            path = path[0] + "_signed_encrypted" + path[1]
-        logging.info("Save new FIP image to %s", path)
-        with open(path, "wb") as fp:
-            fp.write(fip_bin)
-
-    def dump_uuids(self):
-        for k, v in vars(FIP_UUID).items():
-            if k.startswith("UUID_"):
-                print("%-38s" % k, v.hex)
-
-    def find_entry(self, name):
-        # UUID=0, offset=any, size=0, flags=0
-        nullm = re.search(rb"\0{16}.{8}\0{16}", self.binary, flags=re.DOTALL)
-        if nullm is None:
-            raise Exception("NULL TOC entry is not found")
-
-        max_toc_size = nullm.start(0)
-        uuid = getattr(FIP_UUID, name)
-        loc = self.binary.find(uuid.bytes, 0, max_toc_size)
-        if loc < 0:
-            raise ValueError("%s is not found" % name)
-        return Entry.from_fip(name, loc, self.binary)
-
-
-def entry(args):
-    logging.debug("cmd_fip")
-
-
-def init_logging(log_file=None, file_level="DEBUG", stdout_level="WARNING"):
-
-    root_logger = logging.getLogger()
-    root_logger.setLevel(logging.NOTSET)
-
-    fmt = "%(asctime)s %(levelname)8s:%(name)s:%(message)s"
-
-    if log_file is not None:
-        file_handler = logging.FileHandler(log_file, encoding="utf-8")
-        file_handler.setFormatter(logging.Formatter(fmt))
-        file_handler.setLevel(file_level)
-        root_logger.addHandler(file_handler)
-
-    if coloredlogs:
-        os.environ["COLOREDLOGS_DATE_FORMAT"] = "%H:%M:%S"
-
-        field_styles = {
-            "asctime": {"color": "green"},
-            "hostname": {"color": "magenta"},
-            "levelname": {"color": "black", "bold": True},
-            "name": {"color": "blue"},
-            "programname": {"color": "cyan"},
-        }
-
-        level_styles = coloredlogs.DEFAULT_LEVEL_STYLES
-        level_styles["debug"]["color"] = "cyan"
-
-        coloredlogs.install(
-            level=stdout_level,
-            fmt=fmt,
-            field_styles=field_styles,
-            level_styles=level_styles,
-            milliseconds=True,
-        )
-
-
-def parse_fip(fip_path):
-    logging.debug("parse_fip: %s", fip_path)
-    fip = FIP(fip_path)
-    fip.load()
-
-
-def unpack_fip(fip_path):
-    logging.debug("unpack_fip: %s", fip_path)
-    fip = FIP(fip_path)
-    fip.load()
-
-    def save(name, content):
-        fn = os.path.splitext(fip_path)
-        fn = "%s_%s%s" % (fn[0], name, fn[1])
-        logging.info("Save %s", fn)
-        with open(fn, "wb") as fp:
-            fp.write(content)
-
-    for k, v in fip.ents.items():
-        save(k, v.content)
-
-    save("BLP_DDRC", fip.blp_ddrc_binary)
-
-
-def tar_bld(fip_path, output_path, multibin):
-    logging.debug("tar_bld: %s multibin=%r", fip_path, multibin)
-    fip = FIP(fip_path)
-    fip.load()
-
-    members = [
-        "BLD_CONTENT_CERT",
-        "BLD2_KEY_CERT",
-        "BLD1_KEY_CERT",
-        "CV_DDRINIT" if multibin else "BLD",
-    ]
-
-    if not output_path:
-        output_path = os.path.join(os.path.dirname(fip_path), "bld.tar")
-
-    logging.info("bld_tar_path=%s", output_path)
-
-    with tarfile.open(output_path, "w") as tf:
-        for m in members:
-            logging.debug("Tar %s", m)
-            try:
-                fp = io.BytesIO(fip.ents[m].content)
-            except KeyError:
-                logging.warning("%s doesn't exist", m)
-                continue
-            info = tarfile.TarInfo(name=m + ".bin")
-            info.size = len(fp.getbuffer())
-            tf.addfile(tarinfo=info, fileobj=fp)
-
-
-def merge_fip(fip_path, inputs, output_path):
-    logging.debug("merge_fip: %s", fip_path)
-    fip = FIP(fip_path)
-    fip.load()
-
-    for name in FIP.ENTRY_NAMES:
-        binary = inputs.get(name)
-        if not binary:
-            continue
-
-        logging.debug("merge %s", name)
-        ent = fip.ents.get(name)
-        if ent:
-            ent.content = binary
-        else:
-            ent = Entry.make(getattr(FIP_UUID, "UUID_" + name), binary)
-            fip.ents[name] = ent
-
-    binary = inputs.get("BLP_DDRC")
-    if binary:
-        fip.blp_ddrc_binary = binary
-
-    if not output_path:
-        fn = os.path.splitext(fip_path)
-        fn = "%s_%s%s" % (fn[0], "merged", fn[1])
-        output_path = fn
-
-    fip.make_fip(output_path)
-
-
-def round_up(n, k):
-    return (n + k - 1) // k * k
-
-
-def read_blp_and_ddrc(inputs, blp_path, ddrc_path):
-    logging.info("Open %s and %s", blp_path, ddrc_path)
-    with open(blp_path, "rb") as fp:
-        blp_bin = fp.read()
-
-    logging.info("Open %s", ddrc_path)
-    with open(ddrc_path, "rb") as fp:
-        ddrc_bin = fp.read()
-
-    blp_bin += b"\0" * (round_up(len(blp_bin), FIP_ALIGN_SIZE) - len(blp_bin))
-    ddrc_bin += b"\0" * (round_up(len(ddrc_bin), FIP_ALIGN_SIZE) - len(ddrc_bin))
-
-    inputs["BLP_DDRC"] = blp_bin + ddrc_bin
-
-
-def read_bld_tar(inputs, bld_tar_path, multibin):
-    logging.info("Open %s multibin=%r", bld_tar_path, multibin)
-    members = [
-        "BLD_CONTENT_CERT.bin",
-        "BLD2_KEY_CERT.bin",
-        "BLD1_KEY_CERT.bin",
-        "CV_DDRINIT.bin" if multibin else "BLD.bin",
-    ]
-
-    with tarfile.open(bld_tar_path, "r") as tf:
-        for member in members:
-            try:
-                fp = tf.extractfile(member)
-                inputs[os.path.splitext(member)[0]] = fp.read()
-            except KeyError:
-                logging.warning("%s does not exist", member)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="FIP packer")
-
-    for name in FIP.ENTRY_NAMES:
-        parser.add_argument(
-            "--add-%s" % name.lower(),
-            dest=name,
-            type=str,
-            help="Merge %s into FIP" % name,
-        )
-    parser.add_argument(
-        "--add-blp-ddrc", dest="BLP_DDRC", type=str, help="Merge BLP+DDRC into FIP"
-    )
-    parser.add_argument("--add-blp", dest="BLP", type=str, help="Merge BLP into FIP")
-    parser.add_argument("--add-ddrc", dest="DDRC", type=str, help="Merge DDRC into FIP")
-    parser.add_argument(
-        "--add-bld-tar", dest="BLD_TAR", type=str, help="Merge BLD.tar into FIP"
-    )
-
-    parser.add_argument("--multibin", action="store_true", help="Use multibin")
-
-    parser.add_argument("FIP_BIN", type=str, nargs=1, help="Input FIP binary")
-    parser.add_argument("--output", type=str, help="Output filename")
-
-    parser.add_argument(
-        "--version", action="store_true", help="Output version information and exit"
-    )
-    parser.add_argument(
-        "--verbose",
-        help="Increase output verbosity",
-        action="store_const",
-        const=logging.DEBUG,
-        default=logging.DEBUG,
-    )
-
-    parser.add_argument("--unpack", action="store_true", help="Unpack FIP.bin")
-    parser.add_argument("--parse", action="store_true", help="Parse FIP.bin")
-    parser.add_argument(
-        "--tar-bld", action="store_true", help="Extrace BLD.bin and tar"
-    )
-
-    if argcomplete:
-        argcomplete.autocomplete(parser)
-
-    args = parser.parse_args()
-
-    init_logging(stdout_level=args.verbose)
-
-    logging.debug("args=%r", args)
-
-    FIP_UUID.cls_init()
-
-    if args.parse:
-        parse_fip(args.FIP_BIN[0])
-
-    if args.unpack:
-        unpack_fip(args.FIP_BIN[0])
-
-    if args.tar_bld:
-        tar_bld(args.FIP_BIN[0], args.output, args.multibin)
-
-    inputs = collections.OrderedDict()
-    for name in list(FIP.ENTRY_NAMES) + ["BLP_DDRC"]:
-        fn = getattr(args, name)
-        if not fn:
-            continue
-        logging.info("Open %s", fn)
-        with open(fn, "rb") as fp:
-            inputs[name] = fp.read()
-
-    if args.BLP or args.DDRC:
-        read_blp_and_ddrc(inputs, args.BLP, args.DDRC)
-
-    if args.BLD_TAR:
-        read_bld_tar(inputs, args.BLD_TAR, args.multibin)
-
-    if len(inputs):
-        merge_fip(args.FIP_BIN[0], inputs, args.output)
-
-
-if __name__ == "__main__":
-    main()

ota_curl.sh

@@ -1,57 +0,0 @@
-#!/bin/sh
-# OTA 更新脚本 - 使用 curl 断点下载
-# 用法: sh ota_curl.sh <下载URL>
-# 示例: sh ota_curl.sh http://example.com/maix-t11-v2.15.1.zip
-
-set -e
-
-APP_DIR="/maixapp/apps/t11"
-BACKUP_BASE="$APP_DIR/backups"
-TMP_DIR="/tmp/ota_curl"
-PENDING_FILE="$APP_DIR/ota_pending.json"
-
-if [ $# -lt 1 ]; then
-    echo "用法: $0 <下载URL>"
-    exit 1
-fi
-
-OTA_URL="$1"
-FILENAME=$(basename "$OTA_URL" | sed 's/?.*//')
-[ -z "$FILENAME" ] && FILENAME="update.zip"
-
-mkdir -p "$TMP_DIR" "$BACKUP_BASE"
-
-# 1. 断点下载
-echo "[OTA] 开始下载: $OTA_URL"
-echo "[OTA] 保存到: $TMP_DIR/$FILENAME"
-curl -C - -L --retry 3 --retry-delay 5 -o "$TMP_DIR/$FILENAME" "$OTA_URL"
-echo "[OTA] 下载完成"
-
-# 2. 备份当前目录
-TIMESTAMP=$(date +%Y%m%d_%H%M%S 2>/dev/null || echo "00000000_000000")
-BACKUP_DIR="$BACKUP_BASE/backup_$TIMESTAMP"
-mkdir -p "$BACKUP_DIR"
-echo "[OTA] 备份到: $BACKUP_DIR"
-for f in "$APP_DIR"/*.py "$APP_DIR"/*.json "$APP_DIR"/*.xml "$APP_DIR"/*.yaml "$APP_DIR"/*.pem "$APP_DIR"/*.mud "$APP_DIR"/*.so "$APP_DIR"/S99archery; do
-    [ -f "$f" ] && cp "$f" "$BACKUP_DIR/"
-done
-echo "[OTA] 备份完成"
-
-# 3. 解压并替换文件
-echo "[OTA] 开始更新..."
-if echo "$FILENAME" | grep -qi '\.zip$'; then
-    unzip -q -o "$TMP_DIR/$FILENAME" -d "$APP_DIR/"
-else
-    cp "$TMP_DIR/$FILENAME" "$APP_DIR/"
-fi
-sync
-
-# 4. 写入 pending 文件（用于崩溃恢复）
-echo '{"ts":0,"url":"'"$OTA_URL"'","backup_dir":"'"$BACKUP_DIR"'","restart_count":0,"max_restarts":3}' > "$PENDING_FILE"
-sync
-
-echo "[OTA] 更新完成，准备重启..."
-
-# 5. 重启
-sleep 1
-reboot

power.py

@@ -5,14 +5,11 @@
 提供电压、电流监测和充电状态检测
 """
 import config
-import os
-import subprocess
-import _thread
 from logger_manager import logger_manager
 from maix import time as maix_time
 
+
 _INA226_PRESENT = None
-_INA226_LOCK = _thread.allocate_lock()
 
 
 def _ina226_ready() -> bool:
@@ -34,11 +31,7 @@ def write_register(reg, value):
     data = [(value >> 8) & 0xFF, value & 0xFF]
     # 某些底层驱动在失败时只打印 “write failed” 并返回 -1，而不是抛异常；
     # 为避免误判“初始化成功”导致后续 readfrom_mem SIGSEGV，这里把失败显式转成异常。
-    _INA226_LOCK.acquire()
-    try:
-        ret = hardware_manager.bus.writeto_mem(config.INA226_ADDR, reg, bytes(data))
-    finally:
-        _INA226_LOCK.release()
+    ret = hardware_manager.bus.writeto_mem(config.INA226_ADDR, reg, bytes(data))
     if isinstance(ret, int) and ret < 0:
         if logger:
             logger.error(f"[INA226] writeto_mem 失败: addr=0x{config.INA226_ADDR:02X} reg=0x{reg:02X} ret={ret}")
@@ -48,11 +41,7 @@ def write_register(reg, value):
 def read_register(reg):
     """读取INA226寄存器"""
     from hardware import hardware_manager
-    _INA226_LOCK.acquire()
-    try:
-        data = hardware_manager.bus.readfrom_mem(config.INA226_ADDR, reg, 2)
-    finally:
-        _INA226_LOCK.release()
+    data = hardware_manager.bus.readfrom_mem(config.INA226_ADDR, reg, 2)
     return (data[0] << 8) | data[1]
 
 
@@ -96,7 +85,7 @@ def get_bus_voltage():
 def get_current():
     """
     读取电流（单位：mA）
-    当前电源板实测：正数表示放电，负数表示充电。
+    正数表示充电，负数表示放电
     
     INA226 电流计算公式：
     Current = (Current Register Value) × Current_LSB
@@ -107,13 +96,13 @@ def get_current():
             return 0.0
         raw = read_register(config.REG_CURRENT)
         # INA226 电流寄存器是16位有符号整数
-        # 最高位是符号位；电流方向含义取决于电源板的采样电阻接线方向。
+        # 最高位是符号位：0=正（充电），1=负（放电）
         # 计算 Current_LSB（根据 CALIBRATION_VALUE）
         current_lsb = 0.001 * config.CALIBRATION_VALUE / 4096  # 单位：A
         # 处理有符号数：如果最高位为1，转换为负数
-        if raw & 0x8000:
+        if raw & 0x8000:  # 最高位为1，表示负数（放电）
             signed_raw = raw - 0x10000  # 转换为有符号整数
-        else:
+        else:  # 最高位为0，表示正数（充电）
             signed_raw = raw
         # 转换为毫安
         current_ma = signed_raw * current_lsb * 1000
@@ -140,7 +129,7 @@ def is_charging(threshold_ma=10.0):
     """
     try:
         current = get_current()
-        is_charge = current < -abs(float(threshold_ma))
+        is_charge = current > threshold_ma
         return is_charge
     except Exception as e:
         logger = logger_manager.logger
@@ -170,7 +159,7 @@ def voltage_to_percent(voltage):
         return 0
     if v <= 0:
         return 0
-    return int(int(_BATTERY_MONITOR.get_soc(v) * 10) / 10)  # 截断而不是四舍五入
+    return int(int(_BATTERY_MONITOR.get_soc(v) * 10) / 10) # 截断而不是四舍五入
 
 
 class BatteryMonitor:

shoot_manager.py

@@ -8,7 +8,7 @@ from laser_manager import laser_manager
 from logger_manager import logger_manager
 from network import network_manager
 from triangle_target import load_camera_from_xml, load_triangle_positions, try_triangle_scoring
-from vision import estimate_distance, detect_circle_v3, enqueue_save_shot
+from vision import estimate_distance, detect_circle_v3, enqueue_save_shot, enqueue_save_raw_shot
 from maix import image, time
 
 # 缓存相机标定与三角形位置，避免每次射箭重复读磁盘
@@ -58,6 +58,7 @@ def analyze_shot(frame, laser_point=None):
     # ── Step 1: 确定激光点 ────────────────────────────────────────────────────
     laser_point_method = None
     distance_m_first = None
+    best_radius1_temp = None
 
     if config.HARDCODE_LASER_POINT:
         laser_point = laser_manager.laser_point
@@ -102,9 +103,22 @@ def analyze_shot(frame, laser_point=None):
         r_img, center, radius, method, best_radius1, ellipse_params = cdata
         dx, dy = None, None
         d_m = distance_m_first
+        tri_h = None
         if center and radius:
             dx, dy = laser_manager.compute_laser_position(center, (x, y), radius, method)
             d_m = estimate_distance(best_radius1) if best_radius1 else distance_m_first
+            try:
+                import numpy as _np
+                px_per_cm = float(radius) / 10.0
+                if px_per_cm > 1e-6:
+                    cxp, cyp = float(center[0]), float(center[1])
+                    tri_h = _np.array([
+                        [1.0 / px_per_cm, 0.0, -cxp / px_per_cm],
+                        [0.0, 1.0 / px_per_cm, -cyp / px_per_cm],
+                        [0.0, 0.0, 1.0],
+                    ], dtype=float)
+            except Exception:
+                tri_h = None
         out = {
             "success": True,
             "result_img": r_img,
@@ -114,6 +128,7 @@ def analyze_shot(frame, laser_point=None):
             "laser_point": laser_point, "laser_point_method": laser_point_method,
             "offset_method": "yellow_ellipse" if ellipse_params else "yellow_circle",
             "distance_method": "yellow_radius",
+            "tri_homography": tri_h,
         }
         if yolo_roi_xyxy is not None:
             out["yolo_roi_xyxy"] = yolo_roi_xyxy
@@ -129,8 +144,10 @@ def analyze_shot(frame, laser_point=None):
     roi_xyxy = None
     yolo_ring_ms = 0.0
     yolo_black_ms = 0.0
+    _timing_on = bool(getattr(config, "ARCHERY_TIMING_ENABLE", True))
+    _sample_on = bool(getattr(config, "TRIANGLE_SAMPLE_ENABLE", False))
     if getattr(config, "TRIANGLE_YOLO_ROI_ENABLE", False):
-        _t_yolo_ring = time_std.perf_counter()
+        _t_yolo_ring = time_std.perf_counter() if _timing_on else None
         try:
             from target_roi_yolo import try_get_triangle_roi_from_yolo
             roi_xyxy = try_get_triangle_roi_from_yolo(
@@ -140,7 +157,8 @@ def analyze_shot(frame, laser_point=None):
             if logger:
                 logger.warning(f"[YOLO-ROI] {e}")
         finally:
-            yolo_ring_ms = (time_std.perf_counter() - _t_yolo_ring) * 1000.0
+            if _timing_on and _t_yolo_ring is not None:
+                yolo_ring_ms = (time_std.perf_counter() - _t_yolo_ring) * 1000.0
 
     _loc_mode = str(
         getattr(config, "TRIANGLE_BLACK_TRIANGLE_LOCATE_MODE", "yolo")
@@ -155,7 +173,7 @@ def analyze_shot(frame, laser_point=None):
         and roi_xyxy is not None
     )
     if _run_stage2_black_yolo:
-        _t_yolo_black = time_std.perf_counter()
+        _t_yolo_black = time_std.perf_counter() if _timing_on else None
         try:
             from target_roi_yolo import try_black_triangle_boxes_work
 
@@ -166,7 +184,8 @@ def analyze_shot(frame, laser_point=None):
             if logger:
                 logger.warning(f"[YOLO-BLACK] {e}")
         finally:
-            yolo_black_ms = (time_std.perf_counter() - _t_yolo_black) * 1000.0
+            if _timing_on and _t_yolo_black is not None:
+                yolo_black_ms = (time_std.perf_counter() - _t_yolo_black) * 1000.0
     elif (
         logger
         and _loc_mode == "traditional"
@@ -184,7 +203,7 @@ def analyze_shot(frame, laser_point=None):
         try:
             logger.info(f"[TRI] begin {datetime.now()}")
             logger.info(f"[TRI] K: {K}, dist: {dist_coef}, pos: {pos},  {datetime.now()}")
-            _t_wall_try = time_std.perf_counter()
+            _t_wall_try = time_std.perf_counter() if _timing_on else None
             tri = try_triangle_scoring(
                 img_cv, (x, y), pos, K, dist_coef,
                 size_range=getattr(config, "TRIANGLE_SIZE_RANGE", (8, 500)),
@@ -193,8 +212,8 @@ def analyze_shot(frame, laser_point=None):
                 yolo_ring_ms=yolo_ring_ms,
                 yolo_black_ms=yolo_black_ms,
             )
-            _wall_try_ms = (time_std.perf_counter() - _t_wall_try) * 1000.0
-            if logger and bool(getattr(config, "TRIANGLE_LOG_E2E_TIMING", True)):
+            _wall_try_ms = (time_std.perf_counter() - _t_wall_try) * 1000.0 if _timing_on else 0.0
+            if logger and bool(getattr(config, "TRIANGLE_LOG_E2E_TIMING", True)) and _timing_on:
                 _e2e = float(yolo_ring_ms) + float(yolo_black_ms) + float(_wall_try_ms)
                 logger.info(
                     f"[TRI] timing_e2e_triangle_ms={_e2e:.1f} "
@@ -280,6 +299,16 @@ def analyze_shot(frame, laser_point=None):
             "tri_markers_completed": tri.get("markers_completed", []),
             "tri_homography": tri.get("homography"),
         }
+        try:
+            import numpy as _np
+            _H = tri.get("homography")
+            if _H is not None and _np.all(_np.isfinite(_H)):
+                _H_inv = _np.linalg.inv(_H)
+                _pt = _np.array([[[0.0, 0.0]]], dtype=_np.float32)
+                _center_pt = cv2.perspectiveTransform(_pt, _H_inv)[0][0]
+                out["tri_center_px"] = [float(_center_pt[0]), float(_center_pt[1])]
+        except Exception:
+            pass
         if yolo_roi_xyxy is not None:
             out["yolo_roi_xyxy"] = yolo_roi_xyxy
         return out
@@ -318,24 +347,21 @@ def process_shot(adc_val):
     :return: None
     """
     logger = logger_manager.logger
+    _timing_on = bool(getattr(config, "ARCHERY_TIMING_ENABLE", True))
 
     try:
+        network_manager.safe_enqueue({"shoot_event": "start"}, msg_type=2, high=True)
         frame = camera_manager.read_frame()
 
-        # 网络事件移到拍照之后，避免阻塞拍照
-        network_manager.safe_enqueue({"shoot_event": "start"}, msg_type=2, high=True)
+        from shot_id_generator import shot_id_generator
+        shot_id = shot_id_generator.generate_id()
 
-        # Classify only the current shot frame; never reuse a previous result.
-        target_class_result = None
-        try:
-            from target_roi_yolo import try_get_target_class_from_yolo
-
-            target_class_result = try_get_target_class_from_yolo(frame, logger=logger)
-            if logger:
-                logger.info(f"[YOLO-TARGET] 当前箭业务结果: {target_class_result}")
-        except Exception as exc:
-            if logger:
-                logger.warning(f"[YOLO-TARGET] 当前箭分类失败，按未知处理: {exc}")
+        if getattr(config, "SAVE_RAW_SHOT_IMAGE_ENABLED", False):
+            enqueue_save_raw_shot(
+                frame,
+                shot_id=shot_id,
+                photo_dir=config.PHOTO_DIR if config.SAVE_IMAGE_ENABLED else None,
+            )
 
         # 调用算法分析
         analysis_result = analyze_shot(frame)
@@ -370,6 +396,107 @@ def process_shot(adc_val):
         )
         x, y = laser_point
 
+        # 物方采样调试（config.TRIANGLE_SAMPLE_ENABLE）：靶心为原点，取两个对称点判断黑白来区分 40/20 标靶
+        # 逻辑：若两个采样点 RGB 均 < 阈值 → 全黑 → 40cm 标靶；否则 → 20cm 标靶
+        sample_target_type = None
+        _t_sample = time_std.perf_counter() if _timing_on else None
+        _t_sample_ms = 0.0
+        sample_points = []
+        sample_patch_half = 2
+        if bool(getattr(config, "TRIANGLE_SAMPLE_ENABLE", False)):
+            sample_obj_radius_cm = float(getattr(config, "TRIANGLE_SAMPLE_RADIUS_CM", 15.0))
+            sample_obj_angles_deg = (0, 180)  # 只取两个对称点：+X 和 -X
+            sample_patch_half = int(getattr(config, "TRIANGLE_SAMPLE_PATCH_HALF_PX", 2))
+            sample_black_thresh = float(getattr(config, "TRIANGLE_SAMPLE_BLACK_THRESH", 30.0))
+            try:
+                import math as _math
+                import numpy as _np
+                import cv2 as _cv2
+
+                if tri_homography is not None:
+                    _H_inv = _np.linalg.inv(tri_homography)
+                    for _ang in sample_obj_angles_deg:
+                        _rad = _math.radians(float(_ang))
+                        _pt_obj = _np.array([
+                            [[sample_obj_radius_cm * _math.cos(_rad), sample_obj_radius_cm * _math.sin(_rad)]]
+                        ], dtype=_np.float32)
+                        _pt_img = _cv2.perspectiveTransform(_pt_obj, _H_inv)[0][0]
+                        _px, _py = float(_pt_img[0]), float(_pt_img[1])
+                        sample_points.append({
+                            "angle_deg": float(_ang),
+                            "obj_cm": (float(sample_obj_radius_cm * _math.cos(_rad)), float(sample_obj_radius_cm * _math.sin(_rad))),
+                            "img_px": (int(round(_px)), int(round(_py))),
+                        })
+                elif center and radius:
+                    _px_per_cm = float(radius) / 10.0
+                    for _ang in sample_obj_angles_deg:
+                        _rad = _math.radians(float(_ang))
+                        _px = float(center[0]) + sample_obj_radius_cm * _math.cos(_rad) * _px_per_cm
+                        _py = float(center[1]) + sample_obj_radius_cm * _math.sin(_rad) * _px_per_cm
+                        sample_points.append({
+                            "angle_deg": float(_ang),
+                            "obj_cm": (float(sample_obj_radius_cm * _math.cos(_rad)), float(sample_obj_radius_cm * _math.sin(_rad))),
+                            "img_px": (int(round(_px)), int(round(_py))),
+                        })
+
+                # 取样后立即读像素并判断黑白：三角成功用 H_inv；三角失败但圆心成功用 center/radius 近似物方半径
+                _all_black = False
+                _sample_infos = []
+                if sample_points:
+                    _img_cv_for_sample = image.image2cv(result_img, False, False)
+                    _all_black = True
+                    for _sp in sample_points:
+                        _sx, _sy = _sp["img_px"]
+                        _hh = max(1, sample_patch_half)
+                        _patch = []
+                        for _yy in range(_sy - _hh, _sy + _hh + 1):
+                            if _yy < 0 or _yy >= _img_cv_for_sample.shape[0]:
+                                continue
+                            for _xx in range(_sx - _hh, _sx + _hh + 1):
+                                if _xx < 0 or _xx >= _img_cv_for_sample.shape[1]:
+                                    continue
+                                _patch.append(_img_cv_for_sample[_yy, _xx].astype(float))
+                        if _patch:
+                            _mean_rgb = _np.mean(_patch, axis=0)
+                            _is_black = bool(_mean_rgb[0] < sample_black_thresh
+                                           and _mean_rgb[1] < sample_black_thresh
+                                           and _mean_rgb[2] < sample_black_thresh)
+                            if not _is_black:
+                                _all_black = False
+                            _sample_infos.append(
+                                f"{int(_sp['angle_deg'])}°@{_sx},{_sy} rgb=({int(_mean_rgb[0])},{int(_mean_rgb[1])},{int(_mean_rgb[2])})"
+                            )
+                    sample_target_type = "40cm_black" if _all_black else "20cm"
+                if _sample_infos:
+                    logger.info("[采样] " + " | ".join(_sample_infos) + f" → {sample_target_type}")
+            except Exception as _e_sample:
+                sample_points = []
+                if logger:
+                    logger.warning(f"[采样] 标靶类型判断失败: {_e_sample}")
+        if _timing_on and _t_sample is not None:
+            _t_sample_ms = (time_std.perf_counter() - _t_sample) * 1000.0
+
+        # 采样提前完成后，先确定靶型对应的物理半径，供后续距离/偏移/上报使用。
+        # 40cm_black 表示直径40cm，半径20cm；20cm 表示直径20cm，半径10cm。
+        target_radius_cm = 20.0 if sample_target_type == "40cm_black" else (10.0 if sample_target_type == "20cm" else 20.0)
+        target_type_value = 40 if sample_target_type == "40cm_black" else (20 if sample_target_type == "20cm" else None)
+
+        # 圆心分支原算法默认按40cm靶半径20cm换算；若采样判定为20cm靶，在上报前修正距离和偏移。
+        # 三角分支使用 triangle_positions.json 的物方坐标，不在这里二次缩放，避免影响三角单应性结果。
+        if sample_target_type == "20cm" and center and radius and not tri_markers:
+            try:
+                distance_m = (target_radius_cm * config.FOCAL_LENGTH_PIX) / float(radius) / 100.0
+                _scale = target_radius_cm / 20.0
+                if dx is not None:
+                    dx = float(dx) * _scale
+                if dy is not None:
+                    dy = float(dy) * _scale
+                if logger:
+                    logger.info(f"[采样] 20cm靶修正圆心测距/偏移: distance={distance_m:.2f}m scale={_scale:.2f}")
+            except Exception as _e_fix:
+                if logger:
+                    logger.warning(f"[采样] 20cm靶修正失败: {_e_fix}")
+
         # 三角形路径成功时 center/radius 为空是正常的；此时用 triangle 方法名用于保存文件名与上报字段 m
         if (not method) and tri_markers:
             method = "triangle_homography"
@@ -380,10 +507,6 @@ def process_shot(adc_val):
         if dx is None and dy is None and logger:
             logger.warning("[MAIN] 未检测到偏移量（三角形与圆形均失败），但会保存图像")
 
-        # 生成射箭ID
-        from shot_id_generator import shot_id_generator
-        shot_id = shot_id_generator.generate_id()
-
         if logger:
             logger.info(f"[MAIN] 射箭ID: {shot_id}")
 
@@ -396,25 +519,11 @@ def process_shot(adc_val):
         srv_y = round(float(dy), 4) if dy is not None else 200.0
 
         # 构造上报数据
-        target_label = (
-            target_class_result.get("label")
-            if isinstance(target_class_result, dict)
-            else None
-        )
-        target_confidence = (
-            target_class_result.get("confidence")
-            if isinstance(target_class_result, dict)
-            else None
-        )
         inner_data = {
             "shot_id": shot_id,
             "x": srv_x,
             "y": srv_y,
-            "r": 20.0,  # 保留字段（服务端当前忽略，物理外环半径 cm）
-            "target_class": target_label,
-            "target_class_confidence": (
-                float(target_confidence) if target_confidence is not None else None
-            ),
+            "r": target_radius_cm,  # 物理靶半径 cm：40cm靶=20，20cm靶=10
             "d": round((distance_m or 0.0) * 100),
             "d_laser": round((laser_distance_m or 0.0) * 100),
             "d_laser_quality": laser_signal_quality,
@@ -425,6 +534,7 @@ def process_shot(adc_val):
             "target_y": float(y),
             "offset_method": offset_method,
             "distance_method": distance_method,
+            "target_type": target_type_value,
         }
 
         if ellipse_params:
@@ -442,11 +552,6 @@ def process_shot(adc_val):
             inner_data["ellipse_center_y"] = None
 
         report_data = {"cmd": 1, "data": inner_data}
-        if logger:
-            logger.info(
-                f"[REPORT-TARGET] enqueue shot_id={shot_id}, "
-                f"target_class={target_label}, confidence={target_confidence}"
-            )
         network_manager.safe_enqueue(report_data, msg_type=2, high=True)
 
         # 数据上报后再画标注，不干扰检测阶段的原始画面
@@ -504,6 +609,11 @@ def process_shot(adc_val):
                     except Exception:
                         pass
 
+                # 物方采样标靶类型判断耗时（合并在上面采样块内，单独统计）
+                if _timing_on and bool(getattr(config, "TRIANGLE_SAMPLE_ENABLE", False)) and sample_target_type is not None:
+                    logger.info(f"[采样] 标靶类型: {sample_target_type}  耗时: {_t_sample_ms:.2f}ms")
+
+
                 # 叠加信息：落点-圆心距离 / 相机-靶距离等
                 try:
                     import math as _math
@@ -551,7 +661,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,
@@ -561,9 +670,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:

target_roi_yolo.py

@@ -89,29 +89,6 @@ def _stage2_roi_crop_save_worker(
 _detector_by_path = {}
 
 
-def _resolve_model_path(model_path: str):
-    """Resolve a model in either the installed app or MaixVision run directory."""
-    model_path = (model_path or "").strip()
-    if model_path and os.path.isfile(model_path):
-        return model_path
-    if not model_path:
-        return ""
-    name = os.path.basename(model_path)
-    module_dir = os.path.dirname(os.path.abspath(__file__))
-    candidates = (
-        os.path.join(module_dir, name),
-        os.path.join(module_dir, "test", name),
-        os.path.join("/tmp/maixpy_run", name),
-        os.path.join("/tmp/maixpy_run", "test", name),
-        os.path.join(os.getcwd(), name),
-        os.path.join(os.getcwd(), "test", name),
-    )
-    for candidate in candidates:
-        if os.path.isfile(candidate):
-            return candidate
-    return model_path
-
-
 def reset_yolo_detector_cache():
     """切换模型路径时可调用（通常不必）。"""
     global _detector_by_path
@@ -198,23 +175,6 @@ def preload_yolo_detector(logger=None):
                 % (_loc_black,)
             )
 
-    if bool(getattr(cfg, "TARGET_CLASS_YOLO_ENABLE", False)) and bool(
-        getattr(cfg, "TARGET_CLASS_YOLO_PRELOAD_ON_BOOT", True)
-    ):
-        class_model_path = _resolve_model_path(
-            getattr(cfg, "TARGET_CLASS_YOLO_MODEL_PATH", "") or ""
-        )
-        class_detector = _get_detector(class_model_path)
-        if class_detector is None:
-            if logger:
-                logger.warning(
-                    f"[YOLO-TARGET] 预加载失败：无法加载模型 {class_model_path}"
-                )
-        else:
-            ok = True
-            if logger:
-                logger.info(f"[YOLO-TARGET] 靶规格模型已预加载: {class_model_path}")
-
     return ok
 
 
@@ -246,10 +206,8 @@ def _det_obj_class_id(o):
             if v is None:
                 continue
             try:
-                if callable(v):
-                    v = v()
                 return int(float(v))
-            except (TypeError, ValueError, AttributeError):
+            except (TypeError, ValueError):
                 continue
     return None
 
@@ -284,106 +242,6 @@ def _normalize_objs(objs):
     return out
 
 
-def _det_obj_score(o):
-    """Return confidence across supported Maix YOLO result formats."""
-    for key in ("score", "confidence", "conf", "prob"):
-        if hasattr(o, key):
-            try:
-                value = getattr(o, key)
-                if callable(value):
-                    value = value()
-                value = float(value)
-                if value == value:
-                    return value
-            except (TypeError, ValueError, AttributeError):
-                pass
-    return 0.0
-
-
-def try_get_target_class_from_yolo(maix_frame, logger=None):
-    """Classify the current target as 20cm or 40cm; return None if unknown."""
-    try:
-        import config as cfg
-    except Exception:
-        return None
-
-    if not bool(getattr(cfg, "TARGET_CLASS_YOLO_ENABLE", False)):
-        return None
-    model_path = _resolve_model_path(
-        getattr(cfg, "TARGET_CLASS_YOLO_MODEL_PATH", "") or ""
-    )
-    if not os.path.isfile(model_path):
-        if logger:
-            logger.warning(f"[YOLO-TARGET] 模型文件不存在: {model_path}")
-        return None
-    detector = _get_detector(model_path)
-    if detector is None:
-        if logger:
-            logger.warning("[YOLO-TARGET] 无法加载 nn.YOLOv5")
-        return None
-
-    conf_th = float(getattr(cfg, "TARGET_CLASS_YOLO_CONF_TH", 0.5))
-    iou_th = float(getattr(cfg, "TARGET_CLASS_YOLO_IOU_TH", 0.45))
-    labels = getattr(cfg, "TARGET_CLASS_YOLO_LABELS", (20, 40))
-    if isinstance(labels, str):
-        labels = tuple(x.strip() for x in labels.split(",") if x.strip())
-    labels = tuple(labels)
-
-    def _detect(threshold):
-        try:
-            raw = detector.detect(maix_frame, conf_th=threshold, iou_th=iou_th)
-        except Exception as exc:
-            if logger:
-                logger.warning(f"[YOLO-TARGET] detect 异常: {exc}")
-            return []
-        return _normalize_objs(raw if raw is not None else [])
-
-    def _candidates(objs):
-        found = []
-        for obj in objs:
-            class_id = _det_obj_class_id(obj)
-            if class_id is None or class_id < 0 or class_id >= len(labels):
-                continue
-            try:
-                label = int(float(labels[class_id]))
-            except (TypeError, ValueError):
-                continue
-            if label in (20, 40):
-                found.append((label, class_id, _det_obj_score(obj)))
-        return found
-
-    objects = _detect(conf_th)
-    candidates = _candidates(objects)
-    if logger and objects:
-        logger.info(
-            "[YOLO-TARGET] 原始框=%d, 解析类别=%s"
-            % (
-                len(objects),
-                [(_det_obj_class_id(o), _det_obj_score(o)) for o in objects[:8]],
-            )
-        )
-    if not candidates and bool(
-        getattr(cfg, "TARGET_CLASS_YOLO_RETRY_ON_EMPTY", False)
-    ):
-        retry_th = float(getattr(cfg, "TARGET_CLASS_YOLO_RETRY_CONF_TH", conf_th))
-        if 0 < retry_th < conf_th:
-            candidates = _candidates(_detect(retry_th))
-
-    if not candidates:
-        if logger:
-            logger.warning("[YOLO-TARGET] 当前帧未识别到 20/40，按未知处理")
-        return None
-
-    label, class_id, confidence = max(candidates, key=lambda item: item[2])
-    result = {"label": label, "class_id": class_id, "confidence": confidence}
-    if logger:
-        logger.info(
-            f"[YOLO-TARGET] 当前帧分类={label}, class_id={class_id}, "
-            f"conf={confidence:.3f}"
-        )
-    return result
-
-
 def _det_to_src_xyxy(o, coord_mode: str, src_w: int, src_h: int, net_w: int, net_h: int):
     """把单个检测框转为全图坐标系下的 xyxy（半开区间语义与后续 clip 一致）。"""
     x, y, w, h = float(o.x), float(o.y), float(o.w), float(o.h)

test/gpio_high.py

@@ -1,27 +0,0 @@
-"""Run independently and keep A24 at a high logic level."""
-
-from maix import app, gpio, pinmap, time
-
-
-PIN = "P19"
-GPIO_NAME = "GPIOP19"
-
-
-def main():
-    pinmap.set_pin_function(PIN, GPIO_NAME)
-    output = gpio.GPIO(GPIO_NAME, gpio.Mode.OUT)
-    output.value(1)
-    print(f"{PIN} is HIGH. Stop the script to set it LOW.")
-
-    try:
-        while not app.need_exit():
-            # Refresh the output in case another component changes its state.
-            output.value(1)
-            time.sleep_ms(100)
-    finally:
-        output.value(0)
-        print(f"{PIN} is LOW.")
-
-
-if __name__ == "__main__":
-    main()

test/test_algo_preview_live.py

@@ -0,0 +1,403 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+实时摄像头预览：叠加与射箭存图相同的算法标注（YOLO ROI、三角/圆心、激光十字等），默认不写盘。
+
+在 MaixCAM 上从项目根目录运行：
+  python3 test/test_algo_preview_live.py
+  python3 test/test_algo_preview_live.py --interval 1.5
+  python3 test/test_algo_preview_live.py --every-frame
+
+说明：
+  - 完整算法走 shoot_manager.analyze_shot（与 process_shot 一致，含 YOLO + 三角/圆心）。
+  - 画面标注对齐 process_shot 存图前绘制 + vision._draw_yolo_roi_on_rgb_numpy / 圆心存图线。
+  - 预览模式会关闭 Stage2 裁切 JPEG 落盘，避免写满 /root/phot。
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+import os
+import sys
+import threading
+import time
+
+_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _ROOT not in sys.path:
+    sys.path.insert(0, _ROOT)
+
+import cv2
+import numpy as np
+from maix import image, time as maix_time
+
+import config
+from camera_manager import camera_manager
+from laser_manager import laser_manager
+from shoot_manager import analyze_shot, preload_triangle_calib
+from target_roi_yolo import preload_yolo_detector
+from vision import _draw_yolo_roi_on_rgb_numpy
+
+
+def _copy_maix_frame(frame):
+    """相机下一帧可能复用缓冲区，异步分析前先复制。"""
+    img_cv = image.image2cv(frame, False, False)
+    return image.cv2image(np.ascontiguousarray(img_cv), False, False)
+
+
+def _patch_preview_config():
+    """预览不写调试 JPEG，避免刷屏占存储。"""
+    config.TRIANGLE_BLACK_YOLO_SAVE_ROI_CROP = False
+    config.TRIANGLE_SAVE_DEBUG_IMAGE = False
+
+
+def _annotate_like_saved_shot(analysis: dict):
+    """
+    将 analyze_shot 结果绘制成与 process_shot -> enqueue_save_shot 存盘前一致的 Maix 图。
+    """
+    result_img = analysis.get("result_img")
+    if result_img is None:
+        return None
+
+    center = analysis.get("center")
+    radius = analysis.get("radius")
+    method = analysis.get("method")
+    ellipse_params = analysis.get("ellipse_params")
+    laser_point = analysis.get("laser_point")
+    dx = analysis.get("dx")
+    dy = analysis.get("dy")
+    distance_m = analysis.get("distance_m")
+    offset_method = analysis.get("offset_method", "")
+    distance_method = analysis.get("distance_method", "")
+    tri_markers = analysis.get("tri_markers") or []
+    tri_markers_completed = analysis.get("tri_markers_completed") or []
+    tri_homography = analysis.get("tri_homography")
+    yolo_roi_xyxy = analysis.get("yolo_roi_xyxy")
+
+    if laser_point is None:
+        return result_img
+
+    x, y = laser_point
+    draw_yolo_roi = (
+        yolo_roi_xyxy is not None
+        and getattr(config, "TRIANGLE_YOLO_DRAW_ROI_ON_SHOT", True)
+    )
+
+    if tri_markers:
+        img_cv = image.image2cv(result_img, False, False).copy()
+
+        if draw_yolo_roi:
+            _draw_yolo_roi_on_rgb_numpy(img_cv, yolo_roi_xyxy)
+
+        for m in tri_markers:
+            corners = np.array(m["corners"], dtype=np.int32)
+            cv2.polylines(img_cv, [corners], True, (0, 255, 0), 2)
+            cx, cy = int(m["center"][0]), int(m["center"][1])
+            cv2.circle(img_cv, (cx, cy), 4, (0, 0, 255), -1)
+            cv2.putText(
+                img_cv,
+                f"T{m['id']}",
+                (cx - 18, cy - 12),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.55,
+                (0, 255, 0),
+                1,
+            )
+
+        for m in tri_markers_completed:
+            if not m.get("is_virtual"):
+                continue
+            cx, cy = int(m["center"][0]), int(m["center"][1])
+            cv2.circle(img_cv, (cx, cy), 6, (255, 0, 255), 2)
+            cv2.putText(
+                img_cv,
+                f"VT{m['id']}",
+                (cx - 22, cy - 12),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.55,
+                (255, 0, 255),
+                1,
+            )
+
+        if tri_homography is not None:
+            try:
+                H_inv = np.linalg.inv(tri_homography)
+                c_img = cv2.perspectiveTransform(
+                    np.array([[[0.0, 0.0]]], dtype=np.float32), H_inv
+                )[0][0]
+                ocx, ocy = int(c_img[0]), int(c_img[1])
+                cv2.circle(img_cv, (ocx, ocy), 5, (0, 0, 255), -1)
+                cv2.circle(img_cv, (ocx, ocy), 9, (0, 0, 255), 1)
+            except Exception:
+                pass
+
+        lines = []
+        if dx is not None and dy is not None:
+            r_cm = math.hypot(float(dx), float(dy))
+            lines.append(f"offset=({float(dx):.2f},{float(dy):.2f})cm |r|={r_cm:.2f}cm")
+        if distance_m is not None:
+            lines.append(f"cam_dist={float(distance_m):.2f}m ({distance_method})")
+        if method:
+            lines.append(f"method={method} ({offset_method})")
+        y0 = 22
+        for i, t in enumerate(lines):
+            cv2.putText(
+                img_cv,
+                t,
+                (10, y0 + i * 18),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.5,
+                (0, 255, 0),
+                1,
+            )
+
+        out = image.cv2image(img_cv, False, False)
+    else:
+        img_cv = image.image2cv(result_img, False, False).copy()
+        if draw_yolo_roi:
+            _draw_yolo_roi_on_rgb_numpy(img_cv, yolo_roi_xyxy)
+
+        if center and radius:
+            cx, cy = center
+            if ellipse_params:
+                (ell_center, (width, height), angle) = ellipse_params
+                cx_ell, cy_ell = int(ell_center[0]), int(ell_center[1])
+                cv2.ellipse(
+                    img_cv,
+                    (cx_ell, cy_ell),
+                    (int(width / 2), int(height / 2)),
+                    angle,
+                    0,
+                    360,
+                    (0, 255, 0),
+                    2,
+                )
+                cv2.circle(img_cv, (cx_ell, cy_ell), 3, (255, 0, 0), -1)
+                minor_length = min(width, height) / 2
+                minor_angle = angle + 90 if width >= height else angle
+                minor_angle_rad = math.radians(minor_angle)
+                dx_minor = minor_length * math.cos(minor_angle_rad)
+                dy_minor = minor_length * math.sin(minor_angle_rad)
+                pt1 = (int(cx_ell - dx_minor), int(cy_ell - dy_minor))
+                pt2 = (int(cx_ell + dx_minor), int(cy_ell + dy_minor))
+                cv2.line(img_cv, pt1, pt2, (0, 0, 255), 2)
+            else:
+                cv2.circle(img_cv, (int(cx), int(cy)), int(radius), (0, 0, 255), 2)
+                cv2.circle(img_cv, (int(cx), int(cy)), 2, (0, 0, 255), -1)
+            cv2.line(img_cv, (int(x), int(y)), (int(cx), int(cy)), (255, 255, 0), 1)
+
+        lines = []
+        if dx is not None and dy is not None:
+            lines.append(f"offset=({float(dx):.2f},{float(dy):.2f})cm")
+        if distance_m is not None:
+            lines.append(f"dist={float(distance_m):.2f}m ({distance_method})")
+        if method:
+            lines.append(f"method={method}")
+        for i, t in enumerate(lines):
+            cv2.putText(
+                img_cv,
+                t,
+                (10, 22 + i * 18),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.5,
+                (0, 255, 0),
+                1,
+            )
+        out = image.cv2image(img_cv, False, False)
+
+    lc = image.Color(config.LASER_COLOR[0], config.LASER_COLOR[1], config.LASER_COLOR[2])
+    out.draw_line(
+        int(x - config.LASER_LENGTH),
+        int(y),
+        int(x + config.LASER_LENGTH),
+        int(y),
+        lc,
+        config.LASER_THICKNESS,
+    )
+    out.draw_line(
+        int(x),
+        int(y - config.LASER_LENGTH),
+        int(x),
+        int(y + config.LASER_LENGTH),
+        lc,
+        config.LASER_THICKNESS,
+    )
+    out.draw_circle(int(x), int(y), 1, lc, config.LASER_THICKNESS)
+    return out
+
+
+class _AlgoWorker:
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._busy = False
+        self._latest_preview = None
+        self._latest_meta = ""
+        self._last_ms = 0.0
+
+    @property
+    def busy(self):
+        with self._lock:
+            return self._busy
+
+    @property
+    def last_ms(self):
+        with self._lock:
+            return self._last_ms
+
+    def get_preview(self):
+        with self._lock:
+            return self._latest_preview, self._latest_meta
+
+    def run_async(self, frame):
+        with self._lock:
+            if self._busy:
+                return False
+            self._busy = True
+
+        def _job():
+            t0 = time.perf_counter()
+            meta = ""
+            preview = None
+            try:
+                analysis = analyze_shot(frame)
+                if not analysis.get("success"):
+                    reason = analysis.get("reason", "unknown")
+                    meta = f"fail:{reason}"
+                else:
+                    preview = _annotate_like_saved_shot(analysis)
+                    dx, dy = analysis.get("dx"), analysis.get("dy")
+                    method = analysis.get("method") or "?"
+                    if dx is not None and dy is not None:
+                        meta = f"ok {method} ({dx:.2f},{dy:.2f})cm"
+                    else:
+                        meta = f"ok {method} no_offset"
+            except Exception as e:
+                meta = f"err:{e}"
+            elapsed = (time.perf_counter() - t0) * 1000.0
+            with self._lock:
+                self._latest_preview = preview
+                self._latest_meta = f"{meta} {elapsed:.0f}ms"
+                self._last_ms = elapsed
+                self._busy = False
+
+        threading.Thread(target=_job, daemon=True).start()
+        return True
+
+
+def _draw_status(frame, lines, color=None):
+    if color is None:
+        color = image.COLOR_YELLOW
+    y = 4
+    for line in lines:
+        frame.draw_string(4, y, line, color=color)
+        y += 16
+
+
+def _save_preview_jpeg(maix_img, out_dir):
+    os.makedirs(out_dir, exist_ok=True)
+    fn = os.path.join(out_dir, f"preview_{int(time.time() * 1000)}.jpg")
+    maix_img.save(fn)
+    return fn
+
+
+def main():
+    parser = argparse.ArgumentParser(description="实时预览射箭算法存图效果")
+    parser.add_argument(
+        "--interval",
+        type=float,
+        default=2.0,
+        help="两次完整 analyze_shot 的最小间隔（秒）；--every-frame 时忽略",
+    )
+    parser.add_argument(
+        "--every-frame",
+        action="store_true",
+        help="每帧都触发算法（很慢，仅调试用）",
+    )
+    parser.add_argument(
+        "--width",
+        type=int,
+        default=getattr(config, "CAMERA_WIDTH", 640),
+    )
+    parser.add_argument(
+        "--height",
+        type=int,
+        default=getattr(config, "CAMERA_HEIGHT", 480),
+    )
+    parser.add_argument(
+        "--save-dir",
+        default=config.PHOTO_DIR,
+        help="按板子按键无；用 --save-every N 每 N 次成功分析存一张",
+    )
+    parser.add_argument(
+        "--save-every",
+        type=int,
+        default=0,
+        help="每成功分析 N 次自动存一张到 --save-dir（0=不自动存）",
+    )
+    args = parser.parse_args()
+
+    _patch_preview_config()
+    print("[INFO] 预览模式：已关闭 TRIANGLE_BLACK_YOLO_SAVE_ROI_CROP / TRIANGLE_SAVE_DEBUG_IMAGE")
+
+    laser_manager.load_laser_point()
+    preload_triangle_calib()
+    if getattr(config, "TRIANGLE_YOLO_PRELOAD_ON_BOOT", False) or getattr(
+        config, "TRIANGLE_BLACK_YOLO_PRELOAD_ON_BOOT", False
+    ):
+        print("[INFO] 预加载 YOLO …")
+        preload_yolo_detector()
+
+    camera_manager.init_camera(args.width, args.height)
+    camera_manager.init_display()
+    worker = _AlgoWorker()
+
+    interval_s = 0.0 if args.every_frame else max(0.3, float(args.interval))
+    last_trigger = 0.0
+    ok_count = 0
+    frame_idx = 0
+
+    print(
+        f"[INFO] 摄像头 {args.width}x{args.height} "
+        f"interval={'每帧' if args.every_frame else f'{interval_s}s'}"
+    )
+    print("[INFO] 退出：Ctrl+C")
+
+    try:
+        while True:
+            frame = camera_manager.read_frame()
+            frame_idx += 1
+            now = time.perf_counter()
+
+            due = args.every_frame or (now - last_trigger >= interval_s)
+            if due and not worker.busy:
+                last_trigger = now
+                worker.run_async(_copy_maix_frame(frame))
+
+            preview, meta = worker.get_preview()
+            if preview is not None:
+                show_img = preview
+                status = [f"#{frame_idx}", meta]
+                if args.save_every > 0 and meta.startswith("ok"):
+                    ok_count += 1
+                    if ok_count % args.save_every == 0:
+                        try:
+                            fn = _save_preview_jpeg(preview, args.save_dir)
+                            status.append(f"saved:{fn}")
+                        except Exception as e:
+                            status.append(f"save_err:{e}")
+            else:
+                show_img = frame
+                if worker.busy:
+                    status = [f"#{frame_idx}", "analyzing…"]
+                else:
+                    status = [f"#{frame_idx}", "waiting…"]
+
+            _draw_status(show_img, status)
+            camera_manager.show(show_img)
+            maix_time.sleep_ms(1)
+    except KeyboardInterrupt:
+        print("[INFO] 已退出")
+
+
+if __name__ == "__main__":
+    main()

test/test_decect.py

@@ -1,330 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-离线测试脚本：直接复用 detect_circle 逻辑进行测试
-运行环境：MaixPy (Sipeed MAIX)
-"""
-import sys
-import os
-# import time
-from maix import image, time
-import cv2
-import numpy as np
-import math
-
-# ==================== 全局配置 (与 test_main.py 保持一致) ====================
-REAL_RADIUS_CM = 20  # 靶心实际半径（厘米）
-
-def detect_circle_v3(frame, laser_point=None, img_cv=None):
-    """检测图像中的靶心（优先清晰轮廓，其次黄色区域）- 返回椭圆参数版本
-    增加红色圆圈检测，验证黄色圆圈是否为真正的靶心
-    如果提供 laser_point，会选择最接近激光点的目标
-    优化：
-      1. 缩图到 MAX_DET_DIM 后再做 HSV/形态学，最长边 640->320 可获得 ~4x 加速
-      2. 红色掩码在黄色轮廓循环外只计算一次，避免 N 次重复计算
-      3. img_cv 可由外部传入（与其他线程共享转换结果），为 None 时自动转换
-    Args:
-        frame: 图像帧（img_cv 为 None 时使用）
-        laser_point: 激光点坐标 (x, y)，用于多目标场景下的目标选择
-        img_cv: 已转换的 numpy BGR/RGB 图像；不为 None 时跳过 image2cv 转换
-    Returns:
-        (result_img, best_center, best_radius, method, best_radius1, ellipse_params)
-    """
-    if img_cv is None:
-        img_cv = image.image2cv(frame, False, False)
-    from datetime import datetime
-    print(f"[detect_circle_v3] begin {datetime.now()}")
-    # -- 1. 缩图加速（与三角形路径保持一致）
-    h_orig, w_orig = img_cv.shape[:2]
-    MAX_DET_DIM = 480
-    long_side = max(h_orig, w_orig)
-    if long_side > MAX_DET_DIM:
-        det_scale = MAX_DET_DIM / long_side
-        img_det = cv2.resize(img_cv, (int(w_orig * det_scale), int(h_orig * det_scale)),
-                             interpolation=cv2.INTER_LINEAR)
-        inv_scale = 1.0 / det_scale  # 检测坐标 -> 原始坐标的倍率
-    else:
-        img_det = img_cv
-        inv_scale = 1.0
-
-    # 激光点映射到检测分辨率
-    lp_det = None
-    if laser_point is not None:
-        lp_det = (laser_point[0] / inv_scale, laser_point[1] / inv_scale)
-    best_center = best_radius = best_radius1 = method = None
-    ellipse_params = None
-
-    print(f"[detect_circle_v3] step 1 fin {datetime.now()}")
-
-    # -- 2. HSV + 黄色掩码
-    hsv = cv2.cvtColor(img_det, cv2.COLOR_RGB2HSV)
-    h, s, v = cv2.split(hsv)
-    s = np.clip(s * 1.1, 0, 255).astype(np.uint8)
-    hsv = cv2.merge((h, s, v))
-    lower_yellow = np.array([7, 80, 0])
-    upper_yellow = np.array([32, 255, 255])
-    mask_yellow = cv2.inRange(hsv, lower_yellow, upper_yellow)
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    mask_yellow = cv2.morphologyEx(mask_yellow, cv2.MORPH_CLOSE, kernel)
-
-    print(f"[detect_circle_v3] step 2 fin {datetime.now()}")
-
-    # -- 3. 红色掩码：在循环外只算一次
-    mask_red = cv2.bitwise_or(
-        cv2.inRange(hsv, np.array([0, 50, 40]), np.array([10, 255, 255])),
-        cv2.inRange(hsv, np.array([170, 50, 40]), np.array([180, 255, 255])),
-    )
-    kernel_red = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    mask_red = cv2.morphologyEx(mask_red, cv2.MORPH_CLOSE, kernel_red)
-    contours_red, _ = cv2.findContours(mask_red, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    # 预先把红色轮廓筛选成 (center, radius) 列表，后续直接查表
-    red_candidates = []
-    for cnt_r in contours_red:
-        ar = cv2.contourArea(cnt_r)
-        if ar <= 10:
-            continue
-        pr = cv2.arcLength(cnt_r, True)
-        if pr <= 0 or (4 * np.pi * ar) / (pr * pr) <= 0.3:
-            continue
-        if len(cnt_r) >= 5:
-            (xr, yr), (wr, hr), _ = cv2.fitEllipse(cnt_r)
-            red_candidates.append({"center": (int(xr), int(yr)), "radius": int(min(wr, hr) / 2)})
-        else:
-            (xr, yr), rr = cv2.minEnclosingCircle(cnt_r)
-            red_candidates.append({"center": (int(xr), int(yr)), "radius": int(rr)})
-
-    print(f"[detect_circle_v3] step 3 fin {datetime.now()}")
-
-    # -- 4. 黄色轮廓循环（复用上面的红色候选列表）
-    contours_yellow, _ = cv2.findContours(mask_yellow, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    valid_targets = []
-    for cnt_yellow in contours_yellow:
-        area = cv2.contourArea(cnt_yellow)
-        if area <= 15:
-            continue
-        perimeter = cv2.arcLength(cnt_yellow, True)
-        if perimeter <= 0:
-            continue
-        circularity = (4 * np.pi * area) / (perimeter * perimeter)
-        if circularity <= 0.5:
-            continue
-        print(f"[target] -> 面积:{area:.1f}, 圆度:{circularity:.2f}")
-        if len(cnt_yellow) >= 5:
-            (x, y), (width, height), angle = cv2.fitEllipse(cnt_yellow)
-            yellow_ellipse = ((x, y), (width, height), angle)
-            yellow_center = (int(x), int(y))
-            yellow_radius = int(min(width, height) / 2)
-        else:
-            (x, y), radius = cv2.minEnclosingCircle(cnt_yellow)
-            yellow_center = (int(x), int(y))
-            yellow_radius = int(radius)
-            yellow_ellipse = None
-        # 在预筛好的红色候选中匹配
-        matched = False
-        for rc in red_candidates:
-            ddx = yellow_center[0] - rc["center"][0]
-            ddy = yellow_center[1] - rc["center"][1]
-            dist_centers = math.hypot(ddx, ddy)
-            if dist_centers < yellow_radius * 1.5 and rc["radius"] > yellow_radius * 0.7:
-                print(f"[target] -> 找到匹配的红圈: 黄心({yellow_center}), "
-                                f"红心({rc['center']}), 距离:{dist_centers:.1f}, "
-                                f"黄半径:{yellow_radius}, 红半径:{rc['radius']}")
-                valid_targets.append({
-                    "center": yellow_center,
-                    "radius": yellow_radius,
-                    "ellipse": yellow_ellipse,
-                    "area": area,
-                })
-                matched = True
-                break
-        if not matched :
-            print("Debug -> 未找到匹配的红色圆圈，可能是误识别")
-
-    print(f"[detect_circle_v3] step 4 fin {datetime.now()}")
-
-    # -- 5. 选最佳目标，坐标还原到原始分辨率
-    if valid_targets:
-        if lp_det:
-            best_target = min(valid_targets,
-                              key=lambda t: (t["center"][0] - lp_det[0]) ** 2
-                                            + (t["center"][1] - lp_det[1]) ** 2)
-            method = "v3_ellipse_red_validated_laser_selected"
-        else:
-            best_target = max(valid_targets, key=lambda t: t["area"])
-            method = "v3_ellipse_red_validated"
-        bc = best_target["center"]
-        br = best_target["radius"]
-        be = best_target["ellipse"]
-        if inv_scale != 1.0:
-            best_center = (int(bc[0] * inv_scale), int(bc[1] * inv_scale))
-            best_radius = int(br * inv_scale)
-            if be is not None:
-                (ex, ey), (ew, eh), ea = be
-                be = ((ex * inv_scale, ey * inv_scale),
-                      (ew * inv_scale, eh * inv_scale), ea)
-        else:
-            best_center = bc
-            best_radius = br
-        ellipse_params = be
-        best_radius1 = best_radius * 5
-    result_img = image.cv2image(img_cv, False, False)
-    print(f"[detect_circle_v3] step 5 fin {datetime.now()}")
-    return result_img, best_center, best_radius, method, best_radius1, ellipse_params
-
-
-def run_offline_test(image_path):
-    """读取图片，检测圆，绘制结果，保存图片"""
-
-    # 1. 检查文件是否存在
-    if not os.path.exists(image_path):
-        print(f"[ERROR] 找不到图片文件: {image_path}")
-        return
-
-    # 2. 使用 maix.image 读取图片 (适配 MaixPy v4)
-    try:
-        # 使用 image.load 读取文件，返回 Image 对象
-        img = image.load(image_path)
-        print(f"[INFO] 成功读取图片: {image_path} (尺寸: {img.width()}x{img.height()})")
-    except Exception as e:
-        print(f"[ERROR] 读取图片失败: {e}")
-        print("提示：请确认 MaixPy 版本是否为 v4，且图片路径正确。")
-        return
-
-    # 3. 调用 detect_circle_v3 函数
-    print("[INFO] 正在调用 detect_circle_v3 进行检测...")
-    start_time = time.ticks_ms()
-
-    result_img, center, radius, method, radius1, ellipse_params = detect_circle_v3(img)
-
-    cost_time = time.ticks_ms() - start_time
-    print(f"[INFO] 检测完成，耗时: {cost_time}ms")
-    print(f"       结果 -> 圆心: {center}, 半径: {radius}, 方法: {method}")
-    if ellipse_params:
-        (ell_center, (width, height), angle) = ellipse_params
-        print(
-            f"       椭圆 -> 中心: ({ell_center[0]:.1f}, {ell_center[1]:.1f}), 长轴: {max(width, height):.1f}, 短轴: {min(width, height):.1f}, 角度: {angle:.1f}°")
-
-    # 4. 绘制辅助线（可选，用于调试）
-    if center and radius:
-        # 为了绘制椭圆，需要转换回 cv2 图像
-        img_cv = image.image2cv(result_img, False, False)
-
-        cx, cy = center
-
-        # 如果有椭圆参数，绘制椭圆
-        if ellipse_params:
-            (ell_center, (width, height), angle) = ellipse_params
-            cx_ell, cy_ell = int(ell_center[0]), int(ell_center[1])
-
-            # 确定长轴和短轴
-            if width >= height:
-                # width 是长轴，height 是短轴
-                axes_major = width
-                axes_minor = height
-                major_angle = angle  # 长轴角度就是 angle
-                minor_angle = angle + 90  # 短轴角度 = 长轴角度 + 90度
-            else:
-                # height 是长轴，width 是短轴
-                axes_major = height
-                axes_minor = width
-                major_angle = angle + 90  # 长轴角度 = width角度 + 90度
-                minor_angle = angle  # 短轴角度就是 angle
-
-            # 使用 OpenCV 绘制椭圆（绿色，线宽2）
-            cv2.ellipse(img_cv,
-                        (cx_ell, cy_ell),  # 中心点
-                        (int(width / 2), int(height / 2)),  # 半宽、半高
-                        angle,  # 旋转角度（OpenCV需要原始angle）
-                        0, 360,  # 起始和结束角度
-                        (0, 255, 0),  # 绿色 (RGB格式)
-                        2)  # 线宽
-
-            # 绘制椭圆中心点（红色）
-            cv2.circle(img_cv, (cx_ell, cy_ell), 3, (255, 0, 0), -1)
-
-            import math
-            # 绘制短轴（蓝色线条）
-            minor_length = axes_minor / 2
-            minor_angle_rad = math.radians(minor_angle)
-            dx_minor = minor_length * math.cos(minor_angle_rad)
-            dy_minor = minor_length * math.sin(minor_angle_rad)
-            pt1_minor = (int(cx_ell - dx_minor), int(cy_ell - dy_minor))
-            pt2_minor = (int(cx_ell + dx_minor), int(cy_ell + dy_minor))
-            cv2.line(img_cv, pt1_minor, pt2_minor, (0, 0, 255), 2)  # 蓝色 (RGB格式)
-        else:
-            # 如果没有椭圆参数，绘制圆形（红色）
-            cv2.circle(img_cv, (cx, cy), radius, (0, 0, 255), 2)
-            cv2.circle(img_cv, (cx, cy), 2, (0, 0, 255), -1)
-
-        # 转换回 maix image
-        result_img = image.cv2image(img_cv, False, False)
-
-        # 定义颜色对象用于文字
-        try:
-            color_black = image.Color.from_rgb(0, 0, 0)
-        except AttributeError:
-            color_black = image.Color(0, 0, 0)
-
-        # D. 添加文字信息
-        FOCAL_LENGTH_PIX = 1900
-        d = (REAL_RADIUS_CM * FOCAL_LENGTH_PIX) / radius1 / 100.0
-        info_str = f"R:{radius} M:{method} D:{d:.2f}"
-        print(info_str)
-
-        # 计算文字位置，防止超出图片边界
-        r_outer = int(radius * 11.0) if radius else 100
-        text_y = cy - r_outer - 20 if cy > r_outer + 20 else cy + r_outer + 20
-
-        # 调用 draw_string
-        result_img.draw_string(0, 0, info_str, color=color_black, scale=1.0)
-
-    # 5. 保存结果图片
-    base, ext = os.path.splitext(image_path)
-    output_path = f"{base}_result{ext}"
-    try:
-        result_img.save(output_path, quality=100)
-        print(f"[SUCCESS] 结果已保存至: {output_path}")
-    except Exception as e:
-        print(f"[ERROR] 保存图片失败: {e}")
-
-
-if __name__ == "__main__":
-    # ================= 配置区域 =================
-
-    # 1. 设置要测试的图片路径
-    # 建议将图片放在与脚本同级目录，或者使用绝对路径
-    TARGET_IMAGE = "/root/phot/None_314_258_0_0041.bmp"
-
-    TARGET_DIR = "/root/phot"  # 修改为你想要读取的目录路径
-
-    # 支持的图片格式
-    IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
-
-    # ================= 执行区域 =================
-    if 'TARGET_DIR' in locals():
-        # 读取目录下所有图片文件，过滤掉 _result.jpg 后缀的文件
-        image_files = []
-        if os.path.exists(TARGET_DIR) and os.path.isdir(TARGET_DIR):
-            for filename in os.listdir(TARGET_DIR):
-                # 检查文件扩展名
-                if any(filename.lower().endswith(ext) for ext in IMAGE_EXTENSIONS):
-                    # 过滤掉 _result.jpg 后缀的文件
-                    if not filename.endswith('_result.jpg'):
-                        filepath = os.path.join(TARGET_DIR, filename)
-                        if os.path.isfile(filepath):
-                            image_files.append(filepath)
-
-            # 按文件名排序（可选）
-            image_files.sort()
-
-            print(f"[INFO] 在目录 {TARGET_DIR} 中找到 {len(image_files)} 张图片")
-
-            # 处理每张图片
-            for img_path in image_files:
-                print(f"\n{'=' * 10} 开始处理: {img_path} {'=' * 10}")
-                run_offline_test(img_path)
-        else:
-            print(f"[ERROR] 目录不存在或不是有效目录: {TARGET_DIR}")
-
-    else:
-        run_offline_test(TARGET_IMAGE)

test/test_decect_circle_v4.py

@@ -1,635 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-离线测试脚本：直接复用 detect_circle 逻辑进行测试
-运行环境：MaixPy (Sipeed MAIX)
-"""
-import sys
-import os
-# import time
-from maix import image, time
-import cv2
-import numpy as np
-
-# ==================== 全局配置 (与 test_main.py 保持一致) ====================
-REAL_RADIUS_CM = 20  # 靶心实际半径（厘米）
-
-
-# ==================== 复制的核心算法 ====================
-# 注意：这里直接复制了 detect_circle 的逻辑，避免 import main 导致的冲突
-
-
-def detect_circle_v3(frame, laser_point=None):
-    """检测图像中的靶心（优先清晰轮廓，其次黄色区域）- 返回椭圆参数版本
-    增加红色圆圈检测，验证黄色圆圈是否为真正的靶心
-    如果提供 laser_point，会选择最接近激光点的目标
-    
-    Args:
-        frame: 图像帧
-        laser_point: 激光点坐标 (x, y)，用于多目标场景下的目标选择
-    
-    Returns:
-        (result_img, best_center, best_radius, method, best_radius1, ellipse_params)
-    """
-    img_cv = image.image2cv(frame, False, False)
-
-    best_center = best_radius = best_radius1 = method = None
-    ellipse_params = None
-
-    # HSV 黄色掩码检测（模糊靶心）
-    hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV)
-    h, s, v = cv2.split(hsv)
-
-    # 调整饱和度策略：稍微增强，不要过度
-    s = np.clip(s * 1.1, 0, 255).astype(np.uint8)
-
-    hsv = cv2.merge((h, s, v))
-
-    # 放宽 HSV 阈值范围（针对模糊图像的关键调整）
-    lower_yellow = np.array([7, 80, 0])  # 饱和度下限降低，捕捉淡黄色
-    upper_yellow = np.array([32, 255, 255])  # 亮度上限拉满
-
-    mask_yellow = cv2.inRange(hsv, lower_yellow, upper_yellow)
-
-    # 调整形态学操作
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    mask_yellow = cv2.morphologyEx(mask_yellow, cv2.MORPH_CLOSE, kernel)
-
-    contours_yellow, _ = cv2.findContours(mask_yellow, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-
-    # 存储所有有效的黄色-红色组合
-    valid_targets = []
-
-    if contours_yellow:
-        for cnt_yellow in contours_yellow:
-            area = cv2.contourArea(cnt_yellow)
-            perimeter = cv2.arcLength(cnt_yellow, True)
-
-            # 计算圆度
-            if perimeter > 0:
-                circularity = (4 * np.pi * area) / (perimeter * perimeter)
-            else:
-                circularity = 0
-
-            if area > 50 and circularity > 0.7:
-                print(f"[target] -> 面积:{area}, 圆度:{circularity:.2f}")
-                # 尝试拟合椭圆
-                yellow_center = None
-                yellow_radius = None
-                yellow_ellipse = None
-
-                if len(cnt_yellow) >= 5:
-                    (x, y), (width, height), angle = cv2.fitEllipse(cnt_yellow)
-                    yellow_ellipse = ((x, y), (width, height), angle)
-                    axes_minor = min(width, height)
-                    radius = axes_minor / 2
-                    yellow_center = (int(x), int(y))
-                    yellow_radius = int(radius)
-                else:
-                    (x, y), radius = cv2.minEnclosingCircle(cnt_yellow)
-                    yellow_center = (int(x), int(y))
-                    yellow_radius = int(radius)
-                    yellow_ellipse = None
-
-                # 如果检测到黄色圆圈，再检测红色圆圈进行验证
-                if yellow_center and yellow_radius:
-                    # HSV 红色掩码检测（红色在HSV中跨越0度，需要两个范围）
-                    # 红色范围1: 0-12度（接近0度的红色）
-                    # 放宽S/V阈值：S>=30, V>=20 以捕获淡红/暗红
-                    lower_red1 = np.array([0, 30, 20])
-                    upper_red1 = np.array([12, 255, 255])
-                    mask_red1 = cv2.inRange(hsv, lower_red1, upper_red1)
-
-                    # 红色范围2: 168-180度（接近180度的红色）
-                    lower_red2 = np.array([168, 30, 20])
-                    upper_red2 = np.array([180, 255, 255])
-                    mask_red2 = cv2.inRange(hsv, lower_red2, upper_red2)
-
-                    # 合并两个红色掩码
-                    mask_red = cv2.bitwise_or(mask_red1, mask_red2)
-
-                    # 形态学操作：先CLOSE填充空洞，再DILATE加厚环状区域
-                    kernel_red = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-                    mask_red = cv2.morphologyEx(mask_red, cv2.MORPH_CLOSE, kernel_red)
-                    mask_red = cv2.dilate(mask_red, kernel_red, iterations=1)
-
-                    contours_red, _ = cv2.findContours(mask_red, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-
-                    red_pixel_count = np.sum(mask_red > 0)
-                    print(f"Debug -> 红色掩码: {red_pixel_count} 像素, {len(contours_red)} 个轮廓")
-
-                    found_valid_red = False
-
-                    if contours_red:
-                        for cnt_red in contours_red:
-                            area_red = cv2.contourArea(cnt_red)
-                            perimeter_red = cv2.arcLength(cnt_red, True)
-
-                            if perimeter_red > 0:
-                                circularity_red = (4 * np.pi * area_red) / (perimeter_red * perimeter_red)
-                            else:
-                                circularity_red = 0
-
-                            # 环状轮廓圆度可能偏低，放宽到0.2
-                            print(f"Debug -> 红轮廓: 面积={area_red:.1f}, 圆度={circularity_red:.2f}" +
-                                  f" (面积>15={area_red > 15}, 圆度>0.2={circularity_red > 0.2})")
-                            if area_red > 15 and circularity_red > 0.2:
-                                if len(cnt_red) >= 5:
-                                    (x_red, y_red), (w_red, h_red), angle_red = cv2.fitEllipse(cnt_red)
-                                    radius_red = min(w_red, h_red) / 2
-                                    red_center = (int(x_red), int(y_red))
-                                    red_radius = int(radius_red)
-                                else:
-                                    (x_red, y_red), radius_red = cv2.minEnclosingCircle(cnt_red)
-                                    red_center = (int(x_red), int(y_red))
-                                    red_radius = int(radius_red)
-
-                                if red_center:
-                                    dx = yellow_center[0] - red_center[0]
-                                    dy = yellow_center[1] - red_center[1]
-                                    distance = np.sqrt(dx * dx + dy * dy)
-
-                                    max_distance = yellow_radius * 2.0
-                                    min_r = min(red_radius, yellow_radius)
-                                    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}")
-
-                                    # 允许红圈在黄圈外侧或内侧，只要大小相近（较小/较大 >= 0.5）
-                                    if distance < max_distance and size_ratio >= 0.4:
-                                        found_valid_red = True
-                                        print(
-                                            f"[target] -> 找到匹配的红圈: 黄心({yellow_center}), 红心({red_center}), 距离:{distance:.1f}, 黄半径:{yellow_radius}, 红半径:{red_radius}")
-
-                                        valid_targets.append({
-                                            'center': yellow_center,
-                                            'radius': yellow_radius,
-                                            'ellipse': yellow_ellipse,
-                                            'area': area
-                                        })
-                                        break
-
-                    if not found_valid_red:
-                        # 如果黄圈非常可靠（大且圆），在没有红圈验证时仍接受
-                        if area > 30 and circularity > 0.85:
-                            print(f"[target] -> 黄圈高置信度(面积:{area:.0f}, 圆度:{circularity:.2f})，跳过红圈验证直接接受")
-                            valid_targets.append({
-                                'center': yellow_center,
-                                'radius': yellow_radius,
-                                'ellipse': yellow_ellipse,
-                                'area': area
-                            })
-                        else:
-                            print("Debug -> 未找到匹配的红色圆圈，可能是误识别")
-
-    # 从所有有效目标中选择最佳目标
-    if valid_targets:
-        if laser_point:
-            # 如果有激光点，选择最接近激光点的目标
-            best_target = None
-            min_distance = float('inf')
-            for target in valid_targets:
-                dx = target['center'][0] - laser_point[0]
-                dy = target['center'][1] - laser_point[1]
-                distance = np.sqrt(dx * dx + dy * dy)
-                if distance < min_distance:
-                    min_distance = distance
-                    best_target = target
-            if best_target:
-                best_center = best_target['center']
-                best_radius = best_target['radius']
-                ellipse_params = best_target['ellipse']
-                method = "v3_ellipse_red_validated_laser_selected"
-                best_radius1 = best_radius * 5
-        else:
-            # 如果没有激光点，选择面积最大的目标
-            best_target = max(valid_targets, key=lambda t: t['area'])
-            best_center = best_target['center']
-            best_radius = best_target['radius']
-            ellipse_params = best_target['ellipse']
-            method = "v3_ellipse_red_validated"
-            best_radius1 = best_radius * 5
-
-    result_img = image.cv2image(img_cv, False, False)
-    return result_img, best_center, best_radius, method, best_radius1, ellipse_params
-
-
-def detect_circle(frame):
-    """检测图像中的靶心（优先清晰轮廓，其次黄色区域）"""
-    img_cv = image.image2cv(frame, False, False)
-    # gray = cv2.cvtColor(img_cv, cv2.COLOR_RGB2GRAY)
-    # blurred = cv2.GaussianBlur(gray, (5, 5), 0)
-    # edged = cv2.Canny(blurred, 50, 150)
-    # kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    # ceroded = cv2.erode(cv2.dilate(edged, kernel), kernel)
-
-    # contours, _ = cv2.findContours(ceroded, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
-    # best_center = best_radius = best_radius1 = method = None
-
-    # hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV)
-    # h, s, v = cv2.split(hsv)
-    # s = np.clip(s * 2, 0, 255).astype(np.uint8)
-    # hsv = cv2.merge((h, s, v))
-    # lower_yellow = np.array([7, 80, 0])
-    # upper_yellow = np.array([32, 255, 182])
-    # mask = cv2.inRange(hsv, lower_yellow, upper_yellow)
-    # kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    # mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
-    # mask = cv2.morphologyEx(mask, cv2.MORPH_DILATE, kernel)
-    # contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    # if contours:
-    #     largest = max(contours, key=cv2.contourArea)
-    #     if cv2.contourArea(largest) > 50:
-    #         (x, y), radius = cv2.minEnclosingCircle(largest)
-    #         best_center = (int(x), int(y))
-    #         best_radius = int(radius)
-    #         best_radius1 = radius * 5
-    #         method = "v2"
-
-    # auto
-    # R:31 M:v2 D:2.410110127692767
-    # hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV)
-    # h, s, v = cv2.split(hsv)
-
-    # # 1. 增强饱和度（模糊照片需要更强的增强）
-    # s = np.clip(s * 2.5, 0, 255).astype(np.uint8)  # 从2.0改为2.5
-
-    # # 2. 增强亮度（模糊照片可能偏暗）
-    # v = np.clip(v * 1.2, 0, 255).astype(np.uint8)  # 新增：提升亮度
-
-    # hsv = cv2.merge((h, s, v))
-
-    # # 3. 放宽HSV颜色范围（特别是模糊照片）
-    # # 降低饱和度下限，提高亮度上限
-    # lower_yellow = np.array([5, 50, 30])   # H:5-35, S:50-255, V:30-255
-    # upper_yellow = np.array([35, 255, 255])
-
-    # mask = cv2.inRange(hsv, lower_yellow, upper_yellow)
-
-    # # 4. 增强形态学操作（连接被分割的区域）
-    # kernel_small = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    # kernel_large = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9))  # 更大的核
-
-    # # 先开运算去除噪声
-    # mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel_small)
-    # # 多次膨胀连接区域（模糊照片需要更多膨胀）
-    # mask = cv2.dilate(mask, kernel_large, iterations=2)  # 增加迭代次数
-    # mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel_large)  # 闭运算填充空洞
-
-    # contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    # if contours:
-    #     largest = max(contours, key=cv2.contourArea)
-    #     area = cv2.contourArea(largest)
-    #     if area > 50:
-    #         # 5. 使用面积计算等效半径（更准确）
-    #         equivalent_radius = np.sqrt(area / np.pi)
-
-    #         # 6. 同时使用minEnclosingCircle作为备选（取较大值）
-    #         (x, y), enclosing_radius = cv2.minEnclosingCircle(largest)
-
-    #         # 取两者中的较大值，确保不遗漏
-    #         radius = max(equivalent_radius, enclosing_radius)
-
-    #         best_center = (int(x), int(y))
-    #         best_radius = int(radius)
-    #         best_radius1 = radius * 5
-    #         method = "v2"
-
-    # codegee
-    # R:24 M:v2 D:3.061493895819174
-    # R:22 M:v2 D:3.3644971681267077  np.clip(s * 1.1, 0, 255)
-    hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV)
-    h, s, v = cv2.split(hsv)
-
-    # 2. 调整饱和度策略：
-    # 不要暴力翻倍，可以尝试稍微增强，或者使用 CLAHE 增强亮度/对比度
-    # 这里我们稍微增加一点饱和度，并确保不溢出
-    s = np.clip(s * 1.1, 0, 255).astype(np.uint8)
-    # 对亮度通道 v 也可以做一点 CLAHE 处理来增强对比度（可选）
-    # clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-    # v = clahe.apply(v)
-
-    hsv = cv2.merge((h, s, v))
-
-    # 3. 放宽 HSV 阈值范围（针对模糊图像的关键调整）
-    # 降低 S 的下限 (80 -> 35)，提高 V 的上限 (182 -> 255)
-    lower_yellow = np.array([7, 80, 0])  # 饱和度下限降低，捕捉淡黄色
-    upper_yellow = np.array([32, 255, 255])  # 亮度上限拉满
-
-    mask = cv2.inRange(hsv, lower_yellow, upper_yellow)
-
-    # 4. 调整形态学操作
-    # 去掉 MORPH_OPEN，因为它会减小面积。
-    # 使用 MORPH_CLOSE (先膨胀后腐蚀) 来填充内部小黑洞，连接近邻区域
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
-    # 再进行一次膨胀，确保边缘被包含进来
-    # mask = cv2.dilate(mask, kernel, iterations=1) 
-
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-
-    if contours:
-        largest = max(contours, key=cv2.contourArea)
-
-        # 这里可以适当降低面积阈值，或者保持不变
-        if cv2.contourArea(largest) > 50:
-            # (x, y), radius = cv2.minEnclosingCircle(largest)
-            # best_center = (int(x), int(y))
-            # best_radius = int(radius)
-
-            # --- 核心修改开始 ---
-            # 1. 尝试拟合椭圆 (需要轮廓点至少为5个)
-            if len(largest) >= 5:
-                # 返回值: ((中心x, 中心y), (长轴, 短轴), 旋转角度)
-                (x, y), (axes_major, axes_minor), angle = cv2.fitEllipse(largest)
-
-                # 2. 计算半径
-                # 选项A：取长短轴的平均值 (比较稳健)
-                # radius = (axes_major + axes_minor) / 4
-
-                # 选项B：直接取短轴的一半 (抗模糊最强，推荐)
-                radius = axes_minor / 2
-
-                best_center = (int(x), int(y))
-                best_radius = int(radius)
-                method = "v2_ellipse"
-            else:
-                # 如果点太少无法拟合椭圆，降级回 minEnclosingCircle
-                (x, y), radius = cv2.minEnclosingCircle(largest)
-                best_center = (int(x), int(y))
-                best_radius = int(radius)
-                method = "v2"
-            # --- 核心修改结束 ---
-
-            # 你的后续逻辑
-            best_radius1 = radius * 5
-
-    # operas 4.5
-    # R:25 M:v2 D:2.9554872521538527
-    # hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV)
-    # h, s, v = cv2.split(hsv)
-
-    # # 1. 适度增强饱和度（不要过度，否则噪声也会增强）
-    # s = np.clip(s * 1.5, 0, 255).astype(np.uint8)
-    # hsv = cv2.merge((h, s, v))
-
-    # # 2. 放宽 HSV 阈值范围（关键改动）
-    # # - 饱和度下限从 80 降到 40（捕捉淡黄色）
-    # # - 亮度上限从 182 提高到 255（允许更亮的黄色）
-    # lower_yellow = np.array([7, 40, 30])
-    # upper_yellow = np.array([35, 255, 255])
-
-    # mask = cv2.inRange(hsv, lower_yellow, upper_yellow)
-
-    # # 3. 调整形态学操作：用 CLOSE 替代 OPEN
-    # # CLOSE（先膨胀后腐蚀）：填充内部空洞，连接相邻区域
-    # # OPEN（先腐蚀后膨胀）：会缩小区域，不适合模糊图像
-    # kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))  # 稍大的核
-    # mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
-    # mask = cv2.dilate(mask, kernel, iterations=1)  # 额外膨胀，确保边缘被包含
-
-    # contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    # if contours:
-    #     largest = max(contours, key=cv2.contourArea)
-    #     if cv2.contourArea(largest) > 50:
-    #         (x, y), radius = cv2.minEnclosingCircle(largest)
-    #         best_center = (int(x), int(y))
-    #         best_radius = int(radius)
-    #         best_radius1 = radius * 5
-    #         method = "v2"
-
-    # # --- 新增：将 Mask 叠加到原图上用于调试 ---
-    # # 创建一个彩色掩码（红色通道为255，其他为0）
-    # mask_overlay = np.zeros_like(img_cv)
-    # mask_overlay[:, :, 2] = mask  # 将掩码放在红色通道 (BGR中的R)
-    #
-    # cv2.addWeighted(img_cv, 0.6, mask_overlay, 0.4, 0, img_cv)
-
-    result_img = image.cv2image(img_cv, False, False)
-    return result_img, best_center, best_radius, method, best_radius1
-
-
-def detect_circle_v2(frame):
-    """检测图像中的靶心（优先清晰轮廓，其次黄色区域）- 返回椭圆参数版本"""
-    global REAL_RADIUS_CM
-    img_cv = image.image2cv(frame, False, False)
-
-    best_center = best_radius = best_radius1 = method = None
-    ellipse_params = None  # 存储椭圆参数 ((x, y), (axes_major, axes_minor), angle)
-
-    # HSV 黄色掩码检测（模糊靶心）
-    hsv = cv2.cvtColor(img_cv, cv2.COLOR_RGB2HSV)
-    h, s, v = cv2.split(hsv)
-
-    # 调整饱和度策略：稍微增强，不要过度
-    s = np.clip(s * 1.1, 0, 255).astype(np.uint8)
-
-    hsv = cv2.merge((h, s, v))
-
-    # 放宽 HSV 阈值范围（针对模糊图像的关键调整）
-    lower_yellow = np.array([7, 80, 0])  # 饱和度下限降低，捕捉淡黄色
-    upper_yellow = np.array([32, 255, 255])  # 亮度上限拉满
-
-    mask = cv2.inRange(hsv, lower_yellow, upper_yellow)
-
-    # 调整形态学操作
-    # 使用 MORPH_CLOSE (先膨胀后腐蚀) 来填充内部小黑洞，连接近邻区域
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
-
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-
-    if contours:
-        largest = max(contours, key=cv2.contourArea)
-
-        if cv2.contourArea(largest) > 50:
-            # 尝试拟合椭圆 (需要轮廓点至少为5个)
-            if len(largest) >= 5:
-                # 返回值: ((中心x, 中心y), (width, height), 旋转角度)
-                # 注意：width 和 height 是外接矩形的尺寸，不是长轴和短轴
-                (x, y), (width, height), angle = cv2.fitEllipse(largest)
-
-                # 保存椭圆参数（保持原始顺序，用于绘制）
-                ellipse_params = ((x, y), (width, height), angle)
-
-                # 计算半径：使用较小的尺寸作为短轴
-                axes_minor = min(width, height)
-                radius = axes_minor / 2
-
-                best_center = (int(x), int(y))
-                best_radius = int(radius)
-                method = "v2_ellipse"
-            else:
-                # 如果点太少无法拟合椭圆，降级回 minEnclosingCircle
-                (x, y), radius = cv2.minEnclosingCircle(largest)
-                best_center = (int(x), int(y))
-                best_radius = int(radius)
-                method = "v2"
-                ellipse_params = None  # 圆形，没有椭圆参数
-
-            best_radius1 = radius * 5
-
-    result_img = image.cv2image(img_cv, False, False)
-    return result_img, best_center, best_radius, method, best_radius1, ellipse_params
-
-
-# ==================== 测试逻辑 ====================
-
-def run_offline_test(image_path):
-    """读取图片，检测圆，绘制结果，保存图片"""
-
-    # 1. 检查文件是否存在
-    if not os.path.exists(image_path):
-        print(f"[ERROR] 找不到图片文件: {image_path}")
-        return
-
-    # 2. 使用 maix.image 读取图片 (适配 MaixPy v4)
-    try:
-        # 使用 image.load 读取文件，返回 Image 对象
-        img = image.load(image_path)
-        print(f"[INFO] 成功读取图片: {image_path} (尺寸: {img.width()}x{img.height()})")
-    except Exception as e:
-        print(f"[ERROR] 读取图片失败: {e}")
-        print("提示：请确认 MaixPy 版本是否为 v4，且图片路径正确。")
-        return
-
-    # 3. 调用 detect_circle_v2 函数
-    print("[INFO] 正在调用 detect_circle_v2 进行检测...")
-    start_time = time.ticks_ms()
-
-    result_img, center, radius, method, radius1, ellipse_params = detect_circle_v3(img)
-
-    cost_time = time.ticks_ms() - start_time
-    print(f"[INFO] 检测完成，耗时: {cost_time}ms")
-    print(f"       结果 -> 圆心: {center}, 半径: {radius}, 方法: {method}")
-    if ellipse_params:
-        (ell_center, (width, height), angle) = ellipse_params
-        print(
-            f"       椭圆 -> 中心: ({ell_center[0]:.1f}, {ell_center[1]:.1f}), 长轴: {max(width, height):.1f}, 短轴: {min(width, height):.1f}, 角度: {angle:.1f}°")
-
-    # 4. 绘制辅助线（可选，用于调试）
-    if center and radius:
-        # 为了绘制椭圆，需要转换回 cv2 图像
-        img_cv = image.image2cv(result_img, False, False)
-
-        cx, cy = center
-
-        # 如果有椭圆参数，绘制椭圆
-        if ellipse_params:
-            (ell_center, (width, height), angle) = ellipse_params
-            cx_ell, cy_ell = int(ell_center[0]), int(ell_center[1])
-
-            # 确定长轴和短轴
-            if width >= height:
-                # width 是长轴，height 是短轴
-                axes_major = width
-                axes_minor = height
-                major_angle = angle  # 长轴角度就是 angle
-                minor_angle = angle + 90  # 短轴角度 = 长轴角度 + 90度
-            else:
-                # height 是长轴，width 是短轴
-                axes_major = height
-                axes_minor = width
-                major_angle = angle + 90  # 长轴角度 = width角度 + 90度
-                minor_angle = angle  # 短轴角度就是 angle
-
-            # 使用 OpenCV 绘制椭圆（绿色，线宽2）
-            cv2.ellipse(img_cv,
-                        (cx_ell, cy_ell),  # 中心点
-                        (int(width / 2), int(height / 2)),  # 半宽、半高
-                        angle,  # 旋转角度（OpenCV需要原始angle）
-                        0, 360,  # 起始和结束角度
-                        (0, 255, 0),  # 绿色 (RGB格式)
-                        2)  # 线宽
-
-            # 绘制椭圆中心点（红色）
-            cv2.circle(img_cv, (cx_ell, cy_ell), 3, (255, 0, 0), -1)
-
-            import math
-            # 绘制短轴（蓝色线条）
-            minor_length = axes_minor / 2
-            minor_angle_rad = math.radians(minor_angle)
-            dx_minor = minor_length * math.cos(minor_angle_rad)
-            dy_minor = minor_length * math.sin(minor_angle_rad)
-            pt1_minor = (int(cx_ell - dx_minor), int(cy_ell - dy_minor))
-            pt2_minor = (int(cx_ell + dx_minor), int(cy_ell + dy_minor))
-            cv2.line(img_cv, pt1_minor, pt2_minor, (0, 0, 255), 2)  # 蓝色 (RGB格式)
-        else:
-            # 如果没有椭圆参数，绘制圆形（红色）
-            cv2.circle(img_cv, (cx, cy), radius, (0, 0, 255), 2)
-            cv2.circle(img_cv, (cx, cy), 2, (0, 0, 255), -1)
-
-        # 转换回 maix image
-        result_img = image.cv2image(img_cv, False, False)
-
-        # 定义颜色对象用于文字
-        try:
-            color_black = image.Color.from_rgb(0, 0, 0)
-        except AttributeError:
-            color_black = image.Color(0, 0, 0)
-
-        # D. 添加文字信息
-        FOCAL_LENGTH_PIX = 1900
-        d = (REAL_RADIUS_CM * FOCAL_LENGTH_PIX) / radius1 / 100.0
-        info_str = f"R:{radius} M:{method} D:{d:.2f}"
-        print(info_str)
-
-        # 计算文字位置，防止超出图片边界
-        r_outer = int(radius * 11.0) if radius else 100
-        text_y = cy - r_outer - 20 if cy > r_outer + 20 else cy + r_outer + 20
-
-        # 调用 draw_string
-        result_img.draw_string(0, 0, info_str, color=color_black, scale=1.0)
-
-    # 5. 保存结果图片
-    output_path = image_path.replace(".bmp", "_result.bmp")
-    output_path = image_path.replace(".jpg", "_result.jpg")
-    try:
-        result_img.save(output_path, quality=100)
-        print(f"[SUCCESS] 结果已保存至: {output_path}")
-    except Exception as e:
-        print(f"[ERROR] 保存图片失败: {e}")
-
-
-if __name__ == "__main__":
-    # ================= 配置区域 =================
-
-    # 1. 设置要测试的图片路径
-    # 建议将图片放在与脚本同级目录，或者使用绝对路径
-    TARGET_IMAGE = "/root/phot/shot_1830921_0_no_target.jpg"
-
-    TARGET_DIR = "/root/phot"  # 修改为你想要读取的目录路径
-
-    # 支持的图片格式
-    IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
-
-    # ================= 执行区域 =================
-    if 'TARGET_DIR' in locals():
-        # 读取目录下所有图片文件，过滤掉 _result.jpg 后缀的文件
-        image_files = []
-        if os.path.exists(TARGET_DIR) and os.path.isdir(TARGET_DIR):
-            for filename in os.listdir(TARGET_DIR):
-                # 检查文件扩展名
-                if any(filename.lower().endswith(ext) for ext in IMAGE_EXTENSIONS):
-                    # 过滤掉 _result.jpg 后缀的文件
-                    if filename.endswith('no_target.jpg'):
-                        filepath = os.path.join(TARGET_DIR, filename)
-                        if os.path.isfile(filepath):
-                            image_files.append(filepath)
-
-            # 按文件名排序（可选）
-            image_files.sort()
-
-            print(f"[INFO] 在目录 {TARGET_DIR} 中找到 {len(image_files)} 张图片")
-
-            # 处理每张图片
-            for img_path in image_files:
-                print(f"\n{'=' * 10} 开始处理: {img_path} {'=' * 10}")
-                run_offline_test(img_path)
-        else:
-            print(f"[ERROR] 目录不存在或不是有效目录: {TARGET_DIR}")
-
-    else:
-        run_offline_test(TARGET_IMAGE)

test/test_gpio_a14.py

@@ -1,62 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""Interactive GPIO test for physical pin A14."""
-
-import sys
-
-from maix import gpio, pinmap
-
-
-PIN = "A14"
-GPIO_NAME = "GPIOA14"
-
-
-def set_level(output, command):
-    if command == "1":
-        output.value(1)
-        print("A14 = HIGH, laser OFF")
-        return True
-    if command == "0":
-        output.value(0)
-        print("A14 = LOW, laser ON")
-        return True
-    return False
-
-
-def main():
-    pinmap.set_pin_function(PIN, GPIO_NAME)
-    output = gpio.GPIO(GPIO_NAME, gpio.Mode.OUT)
-
-    # One-shot mode for SSH/serial shells: python3 test_gpio_a14.py 1|0
-    if len(sys.argv) > 1:
-        command = sys.argv[1].strip()
-        if not set_level(output, command):
-            print("Invalid argument. Use 1 or 0.")
-            return
-        return
-
-    output.value(1)
-    print("A14 laser test: input 0 for ON, 1 for OFF, q to quit.")
-
-    try:
-        while True:
-            try:
-                command = input("A14> ").strip().lower()
-            except EOFError:
-                print("This runner has no stdin. Run from an SSH/serial shell with argument 1 or 0.")
-                return
-            if set_level(output, command):
-                continue
-            elif command in ("q", "quit", "exit"):
-                break
-            elif command:
-                print("Invalid input. Use 1, 0, or q.")
-    except KeyboardInterrupt:
-        print()
-    finally:
-        output.value(1)
-        print("A14 = HIGH, laser OFF, test stopped.")
-
-
-if __name__ == "__main__":
-    main()

test/test_laser_center_point.py

@@ -0,0 +1,541 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+激光中心点检测单元测试（单文件，无项目依赖）
+直接使用 maix 标准库，实现红色激光点坐标检测
+
+运行方式：
+  python3 test/test_laser_center_point.py
+
+Ctrl+C 退出，按 s 保存截图
+"""
+
+from maix import camera, display, image, time, app, uart, pinmap
+import os
+import struct
+import select
+
+_USE_CV = False
+try:
+    import cv2
+    import numpy as np
+    _USE_CV = True
+except ImportError:
+    pass
+
+WIDTH = 640
+HEIGHT = 480
+THRESHOLD = 140
+SEARCH_RADIUS = 50
+
+
+def read_key_ev():
+    """非阻塞读取 /dev/input/event0 按键（返回 key_code 或 -1）"""
+    try:
+        r, _, _ = select.select([_key_fd], [], [], 0)
+        if r:
+            event = _key_fd.read(16)
+            if len(event) == 16:
+                _, _, etype, code, value = struct.unpack("IIHHI", event)
+                if etype == 1 and value == 1:
+                    return code
+    except Exception:
+        pass
+    return -1
+
+
+def find_ellipse(img_cv, cx, cy, roi_r, th):
+    x1 = max(0, cx - roi_r)
+    x2 = min(WIDTH, cx + roi_r)
+    y1 = max(0, cy - roi_r)
+    y2 = min(HEIGHT, cy + roi_r)
+    roi = img_cv[y1:y2, x1:x2]
+    if roi.size == 0:
+        return None
+    r = roi[:, :, 0].astype(np.int32)
+    g = roi[:, :, 1].astype(np.int32)
+    b = roi[:, :, 2].astype(np.int32)
+    mask = (r > th) & (r > g * 1.5) & (r > b * 1.5)
+    oe = (r > 200) & (g > 200) & (b > 200) & (r >= g) & (r >= b) & ((r - g) > 10) & ((r - b) > 10)
+    combined = (mask | oe).astype(np.uint8) * 255
+    contours, _ = cv2.findContours(combined, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return None
+    largest = max(contours, key=cv2.contourArea)
+    if cv2.contourArea(largest) < 5:
+        return None
+    cnt = largest.copy()
+    for pt in cnt:
+        pt[0][0] += x1
+        pt[0][1] += y1
+    if len(cnt) >= 5:
+        (ex, ey), (ew, eh), ang = cv2.fitEllipse(cnt)
+        mask_ellipse = np.zeros((HEIGHT, WIDTH), dtype=np.uint8)
+        cv2.ellipse(mask_ellipse, (int(ex), int(ey)), (int(ew / 2), int(eh / 2)), ang, 0, 360, 255, -1)
+        brightness = img_cv[:, :, 0].astype(np.int32) + img_cv[:, :, 1].astype(np.int32) + img_cv[:, :, 2].astype(np.int32)
+        masked = np.where(mask_ellipse > 0, brightness, 0)
+        vals = masked[masked > 0]
+        if len(vals) > 0:
+            bth = np.percentile(vals, 90)
+            bmask = (masked >= bth).astype(np.uint8) * 255
+            bcontours, _ = cv2.findContours(bmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            if bcontours:
+                blargest = max(bcontours, key=cv2.contourArea)
+                if cv2.contourArea(blargest) >= 3 and len(blargest) >= 5:
+                    (ix, iy), _, _ = cv2.fitEllipse(blargest)
+                    return (float(ix), float(iy))
+                M = cv2.moments(blargest)
+                if M["m00"] > 0:
+                    return (float(M["m10"] / M["m00"]), float(M["m01"] / M["m00"]))
+        return (float(ex), float(ey))
+    M = cv2.moments(cnt)
+    if M["m00"] > 0:
+        return (float(M["m10"] / M["m00"]), float(M["m01"] / M["m00"]))
+    return None
+
+
+def find_brightest(img_cv, cx, cy, roi_r, th):
+    x1 = max(0, cx - roi_r)
+    x2 = min(WIDTH, cx + roi_r)
+    y1 = max(0, cy - roi_r)
+    y2 = min(HEIGHT, cy + roi_r)
+    best_score = 0
+    best_pos = None
+    for y in range(y1, y2):
+        for x in range(x1, x2):
+            r, g, b = int(img_cv[y, x, 0]), int(img_cv[y, x, 1]), int(img_cv[y, x, 2])
+            is_red = (r > th and r > g * 1.5 and r > b * 1.5)
+            is_oe = (r > 200 and g > 200 and b > 200 and r >= g and r >= b and (r - g) > 10 and (r - b) > 10)
+            if is_red or is_oe:
+                score = r + g + b
+                dx, dy = x - cx, y - cy
+                dist = (dx * dx + dy * dy) ** 0.5
+                score *= max(0.5, 1.0 - (dist / roi_r) * 0.5)
+                if score > best_score:
+                    best_score = score
+                    best_pos = (float(x), float(y))
+    return best_pos
+
+
+# 打开键盘输入设备
+_key_fd = None
+try:
+    _key_fd = open("/dev/input/event0", "rb")
+except Exception:
+    try:
+        _key_fd = open("/dev/input/event1", "rb")
+    except Exception:
+        _key_fd = None
+
+print("=" * 50)
+print("激光中心点检测单元测试")
+print("=" * 50)
+print()
+
+cam = camera.Camera(WIDTH, HEIGHT)
+disp = display.Display()
+print("[OK] 摄像头和显示初始化完成")
+
+# 初始化激光串口
+_laser_on = False
+_laser_uart = None
+try:
+    pinmap.set_pin_function("A18", "UART1_RX")
+    pinmap.set_pin_function("A19", "UART1_TX")
+    _laser_uart = uart.UART("/dev/ttyS1", 9600)
+    _laser_uart.read(-1)
+    print("[OK] 激光串口初始化完成")
+except Exception as e:
+    print(f"[WARN] 激光串口初始化失败: {e}")
+
+LASER_ON = bytes([0xAA, 0x00, 0x01, 0xBE, 0x00, 0x01, 0x00, 0x01, 0xC1])
+LASER_OFF = bytes([0xAA, 0x00, 0x01, 0xBE, 0x00, 0x01, 0x00, 0x00, 0xC0])
+
+# 默认开启激光
+if _laser_uart:
+    try:
+        _laser_uart.write(LASER_ON)
+        time.sleep_ms(50)
+        _laser_uart.read(-1)
+        _laser_on = True
+        print("[OK] 激光已开启")
+    except Exception as e:
+        print(f"[WARN] 开启激光失败: {e}")
+print()
+
+pos_ellipse = None
+pos_bright = None
+frame_count = 0
+use_ellipse = True
+
+while not app.need_exit():
+    frame = cam.read()
+    if frame is None:
+        time.sleep_ms(10)
+        continue
+
+    frame_count += 1
+
+    if _USE_CV:
+        img_cv = image.image2cv(frame, False, False)
+        cx, cy = WIDTH // 2, HEIGHT // 2
+
+        t0 = time.ticks_ms()
+        pos_ellipse = find_ellipse(img_cv, cx, cy, SEARCH_RADIUS, THRESHOLD)
+        t1 = time.ticks_ms()
+        pos_bright = find_brightest(img_cv, cx, cy, SEARCH_RADIUS, THRESHOLD)
+        t2 = time.ticks_ms()
+
+        dt_e = abs(time.ticks_diff(t0, t1))
+        dt_b = abs(time.ticks_diff(t1, t2))
+
+        if frame_count % 5 == 0:
+            e_str = f"({pos_ellipse[0]:.1f},{pos_ellipse[1]:.1f})" if pos_ellipse else "None"
+            b_str = f"({pos_bright[0]:.1f},{pos_bright[1]:.1f})" if pos_bright else "None"
+            print(f"[LASER] ellipse={e_str} ({dt_e}ms)  brightest={b_str} ({dt_b}ms)  "
+                  f"th={THRESHOLD}  radius={SEARCH_RADIUS}")
+
+        # 叠加显示
+        pos = pos_ellipse if use_ellipse else pos_bright
+        h, w = img_cv.shape[:2]
+        cv2.circle(img_cv, (cx, cy), SEARCH_RADIUS, (0, 255, 0), 1)
+        cv2.circle(img_cv, (cx, cy), 2, (0, 255, 0), -1)
+        if pos:
+            x, y = int(pos[0]), int(pos[1])
+            cv2.circle(img_cv, (x, y), 6, (0, 0, 255), 2)
+            cv2.line(img_cv, (x - 14, y), (x + 14, y), (0, 0, 255), 1)
+            cv2.line(img_cv, (x, y - 14), (x, y + 14), (0, 0, 255), 1)
+            cv2.putText(img_cv, f"({x},{y})", (x + 10, y - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+        info = [
+            f"pos={pos if pos else 'None'}",
+            f"method={'ellipse' if use_ellipse else 'brightest'}  th={THRESHOLD}",
+            f"laser={'ON' if _laser_on else 'OFF'}",
+        ]
+        for i, line in enumerate(info):
+            cv2.putText(img_cv, line, (8, 20 + i * 22),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1, cv2.LINE_AA)
+
+        display_frame = image.cv2image(img_cv, False, False)
+    else:
+        display_frame = frame
+
+    disp.show(display_frame)
+
+    # 按键处理（非阻塞）
+    key = read_key_ev()
+    if key > 0:
+        c = chr(key & 0xFF) if key < 256 else ""
+        if key == 113 or key == 81 or key == 0x1b:  # q/Q/ESC
+            break
+        if c == "e" or key == 18:  # e
+            use_ellipse = not use_ellipse
+            print(f"[KEY] Method: {'ellipse' if use_ellipse else 'brightest'}")
+        if c == "l" or key == 12:  # l
+            _laser_on = not _laser_on
+            if _laser_uart:
+                try:
+                    _laser_uart.write(LASER_ON if _laser_on else LASER_OFF)
+                    time.sleep_ms(30)
+                    _laser_uart.read(-1)
+                    print(f"[KEY] Laser: {'ON' if _laser_on else 'OFF'}")
+                except Exception as e:
+                    print(f"[KEY] Laser error: {e}")
+            else:
+                print("[KEY] Laser UART not available")
+    time.sleep_ms(30)
+
+# 关闭激光
+if _laser_on and _laser_uart:
+    try:
+        _laser_uart.write(LASER_OFF)
+        _laser_uart.read(-1)
+        print("[EXIT] 激光已关闭")
+    except Exception:
+        pass
+print("[EXIT] 测试结束")
+if _key_fd:
+    _key_fd.close()
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+激光中心点检测单元测试（单文件，无项目依赖）
+直接使用 maix 标准库，实现红色激光点坐标检测
+
+运行方式：
+  python3 test/test_laser_center_point.py
+
+Ctrl+C 退出，按 s 保存截图
+"""
+
+from maix import camera, display, image, time, app, uart, pinmap
+import os
+import struct
+import select
+
+_USE_CV = False
+try:
+    import cv2
+    import numpy as np
+    _USE_CV = True
+except ImportError:
+    pass
+
+WIDTH = 640
+HEIGHT = 480
+THRESHOLD = 120
+RED_RATIO = 1.3
+SEARCH_RADIUS = 60
+
+
+def read_key_ev():
+    """非阻塞读取 /dev/input/event0 按键（返回 key_code 或 -1）"""
+    try:
+        r, _, _ = select.select([_key_fd], [], [], 0)
+        if r:
+            event = _key_fd.read(16)
+            if len(event) == 16:
+                _, _, etype, code, value = struct.unpack("IIHHI", event)
+                if etype == 1 and value == 1:
+                    return code
+    except Exception:
+        pass
+    return -1
+
+
+def find_ellipse(img_cv, cx, cy, roi_r, th, ratio):
+    x1 = max(0, cx - roi_r)
+    x2 = min(WIDTH, cx + roi_r)
+    y1 = max(0, cy - roi_r)
+    y2 = min(HEIGHT, cy + roi_r)
+    roi = img_cv[y1:y2, x1:x2]
+    if roi.size == 0:
+        return None
+    r = roi[:, :, 0].astype(np.int32)
+    g = roi[:, :, 1].astype(np.int32)
+    b = roi[:, :, 2].astype(np.int32)
+    mask = (r > th) & (r > g * ratio) & (r > b * ratio)
+    oe = (r > 200) & (g > 200) & (b > 200) & (r >= g) & (r >= b) & ((r - g) > 10) & ((r - b) > 10)
+    combined = (mask | oe).astype(np.uint8) * 255
+    contours, _ = cv2.findContours(combined, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return None
+    largest = max(contours, key=cv2.contourArea)
+    if cv2.contourArea(largest) < 5:
+        return None
+    cnt = largest.copy()
+    for pt in cnt:
+        pt[0][0] += x1
+        pt[0][1] += y1
+    if len(cnt) >= 5:
+        (ex, ey), (ew, eh), ang = cv2.fitEllipse(cnt)
+        mask_ellipse = np.zeros((HEIGHT, WIDTH), dtype=np.uint8)
+        cv2.ellipse(mask_ellipse, (int(ex), int(ey)), (int(ew / 2), int(eh / 2)), ang, 0, 360, 255, -1)
+        brightness = img_cv[:, :, 0].astype(np.int32) + img_cv[:, :, 1].astype(np.int32) + img_cv[:, :, 2].astype(np.int32)
+        masked = np.where(mask_ellipse > 0, brightness, 0)
+        vals = masked[masked > 0]
+        if len(vals) > 0:
+            bth = np.percentile(vals, 90)
+            bmask = (masked >= bth).astype(np.uint8) * 255
+            bcontours, _ = cv2.findContours(bmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            if bcontours:
+                blargest = max(bcontours, key=cv2.contourArea)
+                if cv2.contourArea(blargest) >= 3 and len(blargest) >= 5:
+                    (ix, iy), _, _ = cv2.fitEllipse(blargest)
+                    return (float(ix), float(iy))
+                M = cv2.moments(blargest)
+                if M["m00"] > 0:
+                    return (float(M["m10"] / M["m00"]), float(M["m01"] / M["m00"]))
+        return (float(ex), float(ey))
+    M = cv2.moments(cnt)
+    if M["m00"] > 0:
+        return (float(M["m10"] / M["m00"]), float(M["m01"] / M["m00"]))
+    return None
+
+
+def find_brightest_bytes(frame, cx, cy, roi_r, th, ratio):
+    """使用 frame.to_bytes() 两阶段搜索，避免 cv2 转换"""
+    x1 = max(0, cx - roi_r)
+    x2 = min(WIDTH, cx + roi_r)
+    y1 = max(0, cy - roi_r)
+    y2 = min(HEIGHT, cy + roi_r)
+    data = frame.to_bytes()
+    best_score = 0
+    best_pos = None
+    # 第一阶段：隔点粗搜
+    for y in range(y1, y2, 2):
+        for x in range(x1, x2, 2):
+            idx = (y * WIDTH + x) * 3
+            r = data[idx]; g = data[idx+1]; b = data[idx+2]
+            if (r > th and r > g * ratio and r > b * ratio) or \
+               (r > 200 and g > 200 and b > 200 and r >= g and r >= b and (r - g) > 10 and (r - b) > 10):
+                score = r + g + b
+                dx = x - cx; dy = y - cy
+                score *= max(0.5, 1.0 - ((dx*dx + dy*dy) ** 0.5 / roi_r) * 0.5)
+                if score > best_score:
+                    best_score = score
+                    best_pos = (x, y)
+    if best_pos is None:
+        return None
+    # 第二阶段：候选点 7x7 精细搜索
+    fx, fy = best_pos
+    x1f = max(0, fx - 3); x2f = min(WIDTH, fx + 4)
+    y1f = max(0, fy - 3); y2f = min(HEIGHT, fy + 4)
+    best_bright = 0
+    final_pos = best_pos
+    for y in range(y1f, y2f):
+        for x in range(x1f, x2f):
+            idx = (y * WIDTH + x) * 3
+            r = data[idx]; g = data[idx+1]; b = data[idx+2]
+            if (r > th and r > g * ratio and r > b * ratio) or \
+               (r > 200 and g > 200 and b > 200 and r >= g and r >= b and (r - g) > 10 and (r - b) > 10):
+                rgb_sum = r + g + b
+                if rgb_sum > best_bright:
+                    best_bright = rgb_sum
+                    final_pos = (float(x), float(y))
+    return final_pos
+
+
+# 打开键盘输入设备
+_key_fd = None
+try:
+    _key_fd = open("/dev/input/event0", "rb")
+except Exception:
+    try:
+        _key_fd = open("/dev/input/event1", "rb")
+    except Exception:
+        _key_fd = None
+
+print("=" * 50)
+print("激光中心点检测单元测试")
+print("=" * 50)
+print()
+
+cam = camera.Camera(WIDTH, HEIGHT)
+disp = display.Display()
+print("[OK] 摄像头和显示初始化完成")
+
+# 初始化激光串口
+_laser_on = False
+_laser_uart = None
+try:
+    pinmap.set_pin_function("A18", "UART1_RX")
+    pinmap.set_pin_function("A19", "UART1_TX")
+    _laser_uart = uart.UART("/dev/ttyS1", 9600)
+    _laser_uart.read(-1)
+    print("[OK] 激光串口初始化完成")
+except Exception as e:
+    print(f"[WARN] 激光串口初始化失败: {e}")
+
+LASER_ON = bytes([0xAA, 0x00, 0x01, 0xBE, 0x00, 0x01, 0x00, 0x01, 0xC1])
+LASER_OFF = bytes([0xAA, 0x00, 0x01, 0xBE, 0x00, 0x01, 0x00, 0x00, 0xC0])
+
+# 默认开启激光
+if _laser_uart:
+    try:
+        _laser_uart.write(LASER_ON)
+        time.sleep_ms(50)
+        _laser_uart.read(-1)
+        _laser_on = True
+        print("[OK] 激光已开启")
+    except Exception as e:
+        print(f"[WARN] 开启激光失败: {e}")
+print()
+
+pos_ellipse = None
+pos_bright = None
+frame_count = 0
+use_ellipse = True
+
+while not app.need_exit():
+    frame = cam.read()
+    if frame is None:
+        time.sleep_ms(10)
+        continue
+
+    frame_count += 1
+
+    cx, cy = WIDTH // 2, HEIGHT // 2
+
+    t0 = time.ticks_ms()
+    pos_bright = find_brightest_bytes(frame, cx, cy, SEARCH_RADIUS, THRESHOLD, RED_RATIO)
+    t1 = time.ticks_ms()
+
+    pos_ellipse = None
+    if _USE_CV:
+        img_cv = image.image2cv(frame, False, False)
+        t2 = time.ticks_ms()
+        pos_ellipse = find_ellipse(img_cv, cx, cy, SEARCH_RADIUS, THRESHOLD, RED_RATIO)
+        t3 = time.ticks_ms()
+    else:
+        img_cv = None
+        t3 = t2 = t1
+
+    dt_b = abs(time.ticks_diff(t0, t1))
+    dt_e = abs(time.ticks_diff(t2, t3))
+
+    if frame_count % 5 == 0:
+        e_str = f"({pos_ellipse[0]:.1f},{pos_ellipse[1]:.1f})" if pos_ellipse else "None"
+        b_str = f"({pos_bright[0]:.1f},{pos_bright[1]:.1f})" if pos_bright else "None"
+        print(f"[LASER] ellipse={e_str} ({dt_e}ms)  brightest={b_str} ({dt_b}ms)  "
+              f"th={THRESHOLD}  ratio={RED_RATIO}  radius={SEARCH_RADIUS}")
+
+    pos = pos_ellipse if use_ellipse else pos_bright
+    if img_cv is not None:
+        cv2.circle(img_cv, (cx, cy), SEARCH_RADIUS, (0, 255, 0), 1)
+        cv2.circle(img_cv, (cx, cy), 2, (0, 255, 0), -1)
+        if pos:
+            x, y = int(pos[0]), int(pos[1])
+            cv2.circle(img_cv, (x, y), 6, (0, 0, 255), 2)
+            cv2.line(img_cv, (x - 14, y), (x + 14, y), (0, 0, 255), 1)
+            cv2.line(img_cv, (x, y - 14), (x, y + 14), (0, 0, 255), 1)
+            cv2.putText(img_cv, f"({x},{y})", (x + 10, y - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+        info = [
+            f"pos={pos if pos else 'None'}",
+            f"method={'ellipse' if use_ellipse else 'brightest'}  th={THRESHOLD}  ratio={RED_RATIO}",
+            f"laser={'ON' if _laser_on else 'OFF'}",
+        ]
+        for i, line in enumerate(info):
+            cv2.putText(img_cv, line, (8, 20 + i * 22),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1, cv2.LINE_AA)
+        display_frame = image.cv2image(img_cv, False, False)
+    else:
+        display_frame = frame
+
+    disp.show(display_frame)
+
+    # 按键处理（非阻塞）
+    key = read_key_ev()
+    if key > 0:
+        c = chr(key & 0xFF) if key < 256 else ""
+        if key == 113 or key == 81 or key == 0x1b:  # q/Q/ESC
+            break
+        if c == "e" or key == 18:  # e
+            use_ellipse = not use_ellipse
+            print(f"[KEY] Method: {'ellipse' if use_ellipse else 'brightest'}")
+        if c == "l" or key == 12:  # l
+            _laser_on = not _laser_on
+            if _laser_uart:
+                try:
+                    _laser_uart.write(LASER_ON if _laser_on else LASER_OFF)
+                    time.sleep_ms(30)
+                    _laser_uart.read(-1)
+                    print(f"[KEY] Laser: {'ON' if _laser_on else 'OFF'}")
+                except Exception as e:
+                    print(f"[KEY] Laser error: {e}")
+            else:
+                print("[KEY] Laser UART not available")
+    time.sleep_ms(30)
+
+# 关闭激光
+if _laser_on and _laser_uart:
+    try:
+        _laser_uart.write(LASER_OFF)
+        _laser_uart.read(-1)
+        print("[EXIT] 激光已关闭")
+    except Exception:
+        pass
+print("[EXIT] 测试结束")
+if _key_fd:
+    _key_fd.close()

test/test_yolo26.py

@@ -0,0 +1,18 @@
+from maix import camera, display, image, nn, app
+
+# 1. 初始化模型 (请确保模型文件 .mud 路径正确)
+detector = nn.YOLOv5(model="/root/model_279350.mud", dual_buff=True)
+
+# 2. 初始化摄像头，分辨率与模型输入匹配
+cam = camera.Camera(detector.input_width(), detector.input_height(), detector.input_format())
+disp = display.Display()
+
+# 3. 主循环：实时检测与显示
+while not app.need_exit():
+    img = cam.read()                         # 从摄像头读取一帧
+    objs = detector.detect(img, conf_th=0.5, iou_th=0.45) # 执行YOLO11推理
+    for obj in objs:                         # 绘制所有检测到的目标
+        img.draw_rect(obj.x, obj.y, obj.w, obj.h, color=image.COLOR_RED)
+        msg = f'{detector.labels[obj.class_id]}: {obj.score:.2f}'
+        img.draw_string(obj.x, obj.y, msg, color=image.COLOR_RED)
+    disp.show(img)                           # 更新屏幕显示

test/test_yolo_camera_simple.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+摄像头实时 YOLOv5 简易测试脚本。
+
+特点：
+- 完全独立脚本，直接 python test/test_yolo_camera_simple.py 运行，不需要传参。
+- 不 import config，不依赖项目模块。
+- 直接调用 maix.nn.YOLOv5(model=..., dual_buff=False)。
+- camera.read() 得到的 Maix image 直接送 det.detect()。
+- 在画面上画检测框、类别、置信度，并显示到屏幕。
+
+运行环境：MaixCAM / MaixPy。
+"""
+
+import os
+
+
+CAMERA_WIDTH = 640
+CAMERA_HEIGHT = 480
+# 默认与主项目 config.TRIANGLE_YOLO_MODEL_PATH 一致（勿用 /root/yolo26_int8.mud，那是占位路径）
+_MODEL_DEFAULT = "/maixapp/apps/t11/model_270139.mud"
+try:
+    import config as _cfg
+
+    MODEL_PATH = getattr(_cfg, "TRIANGLE_YOLO_MODEL_PATH", _MODEL_DEFAULT) or _MODEL_DEFAULT
+except Exception:
+    MODEL_PATH = _MODEL_DEFAULT
+CONF_TH = 0.7
+IOU_TH = 0.45
+# native: Maix detect 返回框已映射到 camera.read() 图像坐标；letterbox: 需要从网络输入坐标反算
+COORD_MODE = "native"
+# 只用于 DRAW_ONLY_CLASS_IDS=True 时过滤显示；默认画所有框
+CLASS_IDS = (0,)
+DRAW_ONLY_CLASS_IDS = False  # True=只画 CLASS_IDS 里的类别；False=画所有 YOLO 返回框
+
+
+def _det_obj_class_id(o):
+    for key in ("class_id", "cls", "label", "category", "cat_id", "id"):
+        if hasattr(o, key):
+            v = getattr(o, key)
+            if v is None:
+                continue
+            try:
+                return int(float(v))
+            except (TypeError, ValueError):
+                continue
+    return None
+
+
+def _det_obj_from_seq(t):
+    if not isinstance(t, (list, tuple)) or len(t) < 6:
+        return None
+
+    class Box:
+        pass
+
+    b = Box()
+    b.x = float(t[0])
+    b.y = float(t[1])
+    b.w = float(t[2])
+    b.h = float(t[3])
+    b.score = float(t[4])
+    b.class_id = int(float(t[5]))
+    return b
+
+
+def _normalize_objs(objs):
+    out = []
+    for o in objs or []:
+        if isinstance(o, (list, tuple)):
+            m = _det_obj_from_seq(o)
+            if m is not None:
+                out.append(m)
+        else:
+            out.append(o)
+    return out
+
+
+def _letterbox_net_to_src_xyxy(x, y, w, h, src_w, src_h, net_w, net_h):
+    scale = min(net_w / float(src_w), net_h / float(src_h))
+    new_w = src_w * scale
+    new_h = src_h * scale
+    pad_x = (net_w - new_w) * 0.5
+    pad_y = (net_h - new_h) * 0.5
+    x0 = (x - pad_x) / scale
+    y0 = (y - pad_y) / scale
+    x1 = (x + w - pad_x) / scale
+    y1 = (y + h - pad_y) / scale
+    return x0, y0, x1, y1
+
+
+def _det_to_src_xyxy(o, coord_mode, src_w, src_h, net_w, net_h):
+    x = float(getattr(o, "x", 0.0))
+    y = float(getattr(o, "y", 0.0))
+    w = float(getattr(o, "w", 0.0))
+    h = float(getattr(o, "h", 0.0))
+    if coord_mode in ("native", "source", "camera", "full"):
+        return x, y, x + w, y + h
+    return _letterbox_net_to_src_xyxy(x, y, w, h, src_w, src_h, net_w, net_h)
+
+
+def _clip_xywh(x0, y0, x1, y1, src_w, src_h):
+    x0 = max(0, min(int(round(x0)), src_w - 1))
+    y0 = max(0, min(int(round(y0)), src_h - 1))
+    x1 = max(x0 + 1, min(int(round(x1)), src_w))
+    y1 = max(y0 + 1, min(int(round(y1)), src_h))
+    return x0, y0, x1 - x0, y1 - y0
+
+
+def _label(det, cid):
+    labels = getattr(det, "labels", None)
+    if labels is None:
+        return str(cid)
+    try:
+        return str(labels[int(cid)])
+    except Exception:
+        return str(cid)
+
+
+def main():
+    from maix import camera, display, nn, time, image
+
+    if not MODEL_PATH or not os.path.isfile(MODEL_PATH):
+        print("[ERR] 模型文件不存在:", MODEL_PATH)
+        return
+
+    print("[INFO] 初始化 YOLO 模型:", MODEL_PATH)
+    det = nn.YOLOv26(model=MODEL_PATH, dual_buff=False)
+    net_w = int(det.input_width())
+    net_h = int(det.input_height())
+    print(
+        "[INFO] net_in=%dx%d conf=%.2f iou=%.2f coord=%s class_ids=%s"
+        % (net_w, net_h, CONF_TH, IOU_TH, COORD_MODE, str(CLASS_IDS))
+    )
+
+    print("[INFO] 初始化摄像头: %dx%d" % (CAMERA_WIDTH, CAMERA_HEIGHT))
+    cam = camera.Camera(CAMERA_WIDTH, CAMERA_HEIGHT)
+    disp = display.Display()
+
+    color_cycle = []
+    for name in ("RED", "GREEN", "BLUE", "ORANGE", "YELLOW", "CYAN", "MAGENTA"):
+        c = getattr(image, "COLOR_" + name, None)
+        if c is not None:
+            color_cycle.append(c)
+    if not color_cycle:
+        color_cycle = [getattr(image, "COLOR_RED", 0)]
+
+    frame_idx = 0
+    last_log_ms = time.ticks_ms()
+    fps_count = 0
+
+    while True:
+        frame = cam.read()
+        src_w = frame.width()
+        src_h = frame.height()
+
+        t0 = time.ticks_ms()
+        raw = det.detect(frame, conf_th=CONF_TH, iou_th=IOU_TH)
+        detect_ms = time.ticks_ms() - t0
+        objs = _normalize_objs(raw if raw is not None else [])
+
+        draw_count = 0
+        for i, o in enumerate(objs):
+            cid = _det_obj_class_id(o)
+            if cid is None:
+                cid = -1
+            if DRAW_ONLY_CLASS_IDS and cid not in CLASS_IDS:
+                continue
+            try:
+                score = float(getattr(o, "score", 0.0))
+            except Exception:
+                score = 0.0
+
+            x0, y0, x1, y1 = _det_to_src_xyxy(o, COORD_MODE, src_w, src_h, net_w, net_h)
+            ix, iy, iw, ih = _clip_xywh(x0, y0, x1, y1, src_w, src_h)
+            col = color_cycle[cid % len(color_cycle)] if cid >= 0 else color_cycle[0]
+            frame.draw_rect(ix, iy, iw, ih, color=col)
+            frame.draw_string(ix, max(0, iy - 16), "%s %.2f" % (_label(det, cid), score), color=col)
+            draw_count += 1
+
+        frame.draw_string(4, 4, "YOLO boxes:%d draw:%d %dms" % (len(objs), draw_count, detect_ms), color=color_cycle[0])
+        disp.show(frame)
+
+        frame_idx += 1
+        fps_count += 1
+        now = time.ticks_ms()
+        if now - last_log_ms >= 1000:
+            print(
+                "[INFO] frame=%d fps=%d raw_boxes=%d draw_boxes=%d detect_ms=%d"
+                % (frame_idx, fps_count, len(objs), draw_count, detect_ms)
+            )
+            fps_count = 0
+            last_log_ms = now
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("[INFO] exit")
+    except Exception as e:
+        print("[ERR]", e)
+        try:
+            import traceback
+
+            traceback.print_exc()
+        except Exception:
+            pass

test/test_yolov8.py

@@ -0,0 +1,29 @@
+from maix import image, nn, display
+
+# 1. 加载模型
+detector = nn.YOLOv8(model="/root/279350.mud", dual_buff=False)
+# 2. 加载指定图片（根据模型输入尺寸自动缩放宽高）
+img = image.load("/root/tes.jpg")
+if img is None:
+    raise FileNotFoundError("图片加载失败，请检查路径")
+
+# 3. 调整图片尺寸到模型输入要求（可选，detect内部会处理，但提前缩放可提高速度）
+# img = img.resize(detector.input_width(), detector.input_height())
+
+# 4. 检测
+objs = detector.detect(img, conf_th=0.5, iou_th=0.45)
+
+# 5. 在图片上绘制结果
+for obj in objs:
+    img.draw_rect(obj.x, obj.y, obj.w, obj.h, color=image.COLOR_RED)
+    msg = f'{detector.labels[obj.class_id]}: {obj.score:.2f}'
+    img.draw_string(obj.x, obj.y, msg, color=image.COLOR_RED)
+
+# 6. 显示结果（如果设备有屏幕）
+disp = display.Display()
+disp.show(img)
+
+# 7. 保存结果（可选）
+img.save("/root/result.jpg")
+
+print("识别完成，结果已显示并保存为 result.jpg")

test/wifi_gpio_ina_isolation.py

@@ -1,122 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""Standalone WiFi/GPIO/INA226 isolation test for the official MaixPy tool.
-
-This file intentionally does not import project modules or start project
-threads. Select TEST_MODE below, then run the file directly.
-"""
-
-import time
-
-from maix import gpio, i2c, network, pinmap
-
-
-# Change only this value before each run.
-# wifi       WiFi only
-# a25        A25 only
-# a23        A23 only
-# gpio       A23/A26 only
-# ina        INA226 only
-# gpio_ina   GPIOs, then INA226
-# a25_wifi   A25, then WiFi
-# a23_wifi   A23, then WiFi
-# all        GPIOs, INA226, then WiFi
-TEST_MODE = "a25_wifi"
-
-WIFI_SSID = "sheling4b02-5G"
-WIFI_PASSWORD = "Aa12345678"
-WIFI_TIMEOUT_S = 20
-I2C_BUS_NUM = 5
-INA226_ADDR = 0x40
-
-
-def init_leds():
-    return init_selected_leds(True, True)
-
-
-def init_selected_leds(use_a26, use_a23):
-    outputs = []
-    if use_a26:
-        print("Initializing A25 -> GPIOA25")
-        pinmap.set_pin_function("A25", "GPIOA25")
-        green = gpio.GPIO("GPIOA25", gpio.Mode.OUT)
-        green.value(0)
-        outputs.append(("GPIOA25", green))
-        print("GPIOA25 initialized LOW")
-    if use_a23:
-        print("Initializing A23 -> GPIOA23")
-        pinmap.set_pin_function("A23", "GPIOA23")
-        red = gpio.GPIO("GPIOA23", gpio.Mode.OUT)
-        red.value(0)
-        outputs.append(("GPIOA23", red))
-        print("GPIOA23 initialized LOW")
-    return outputs
-
-
-def test_ina226():
-    # Match the board mapping used by the application before opening I2C5.
-    pinmap.set_pin_function("A15", "I2C5_SCL")
-    pinmap.set_pin_function("A27", "I2C5_SDA")
-    print("A15/A27 configured for I2C5")
-    print("Initializing I2C bus", I2C_BUS_NUM)
-    bus = i2c.I2C(I2C_BUS_NUM, i2c.Mode.MASTER)
-    print("Reading INA226 at 0x%02X" % INA226_ADDR)
-    config = bus.readfrom_mem(INA226_ADDR, 0x00, 2)
-    voltage_raw = bus.readfrom_mem(INA226_ADDR, 0x02, 2)
-    voltage = ((voltage_raw[0] << 8) | voltage_raw[1]) * 1.25 / 1000
-    print("INA226 config=0x%02X%02X voltage=%.3fV" % (config[0], config[1], voltage))
-    return bus
-
-
-def test_wifi():
-    print("Starting MaixPy WiFi connection...")
-    wifi = network.wifi.Wifi()
-    result = wifi.connect(WIFI_SSID, WIFI_PASSWORD, wait=True, timeout=WIFI_TIMEOUT_S)
-    print("WiFi connect result:", result)
-    print("WiFi connected:", wifi.is_connected())
-    try:
-        print("WiFi IP:", wifi.get_ip())
-    except Exception as exc:
-        print("WiFi status query failed:", exc)
-
-
-def main():
-    valid = ("wifi", "a25", "a23", "gpio", "ina", "gpio_ina", "a25_wifi", "a23_wifi", "all")
-    mode = TEST_MODE.lower()
-    if mode not in valid:
-        print("TEST_MODE must be one of:", ", ".join(valid))
-        return 1
-
-    leds = []
-    try:
-        print("=== Standalone WiFi/GPIO/INA226 isolation ===")
-        print("mode:", mode)
-        if mode in ("a25", "a25_wifi"):
-            leds = init_selected_leds(True, False)
-            time.sleep(1)
-        elif mode in ("a23", "a23_wifi"):
-            leds = init_selected_leds(False, True)
-            time.sleep(1)
-        elif mode in ("gpio", "gpio_ina", "all"):
-            leds = init_leds()
-            time.sleep(1)
-        if mode in ("ina", "gpio_ina", "all"):
-            test_ina226()
-            time.sleep(1)
-        if mode in ("wifi", "a25_wifi", "a23_wifi", "all"):
-            test_wifi()
-        print("TEST COMPLETE")
-        return 0
-    except Exception as exc:
-        print("TEST FAILED:", repr(exc))
-        return 1
-    finally:
-        for name, led in leds:
-            try:
-                led.value(0)
-                print(name, "LOW")
-            except Exception as exc:
-                print(name, "cleanup failed:", exc)
-
-
-main()

test/wifi_gpio_isolation.py

@@ -1,88 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""Standalone WiFi/GPIO isolation test.
-
-This script intentionally does not import any project module. It only tests
-MaixPy WiFi startup with optional A23/A26 GPIO initialization.
-"""
-
-import time
-
-from maix import gpio, network, pinmap
-
-
-GREEN_PIN = "A26"
-GREEN_GPIO = "GPIOA26"
-RED_PIN = "A23"
-RED_GPIO = "GPIOA23"
-
-# Run this file directly from the official MaixPy tool.
-# Change only TEST_MODE between runs: none -> a26 -> a23 -> both.
-TEST_MODE = "none"
-WIFI_SSID = "sheling4b02-5G"
-WIFI_PASSWORD = "Aa12345678"
-WIFI_TIMEOUT_S = 20
-
-
-def init_gpio(mode):
-    outputs = []
-    if mode in ("a26", "both"):
-        pinmap.set_pin_function(GREEN_PIN, GREEN_GPIO)
-        green = gpio.GPIO(GREEN_GPIO, gpio.Mode.OUT)
-        green.value(1)
-        outputs.append((GREEN_GPIO, green))
-        print("GPIOA26 initialized HIGH")
-    if mode in ("a23", "both"):
-        pinmap.set_pin_function(RED_PIN, RED_GPIO)
-        red = gpio.GPIO(RED_GPIO, gpio.Mode.OUT)
-        red.value(1)
-        outputs.append((RED_GPIO, red))
-        print("GPIOA23 initialized HIGH")
-    return outputs
-
-
-def connect_wifi(ssid, password, timeout_s):
-    print("Starting MaixPy WiFi connection...")
-    wifi = network.wifi.Wifi()
-    result = wifi.connect(ssid, password, wait=True, timeout=timeout_s)
-    print("WiFi connect result:", result)
-    try:
-        print("WiFi connected:", wifi.is_connected())
-        print("WiFi IP:", wifi.get_ip())
-    except Exception as exc:
-        print("WiFi status query failed:", exc)
-    return result
-
-
-def main():
-    mode = TEST_MODE.lower()
-    if mode not in ("none", "a26", "a23", "both"):
-        print("TEST_MODE must be none, a26, a23, or both")
-        return 1
-    ssid = WIFI_SSID
-    password = WIFI_PASSWORD
-    timeout_s = WIFI_TIMEOUT_S
-
-    print("=== Standalone WiFi/GPIO isolation ===")
-    print("mode:", mode)
-    print("ssid:", ssid)
-    outputs = []
-    try:
-        outputs = init_gpio(mode)
-        time.sleep(1)
-        connect_wifi(ssid, password, timeout_s)
-        return 0
-    except Exception as exc:
-        print("TEST FAILED:", repr(exc))
-        return 1
-    finally:
-        for gpio_name, output in outputs:
-            try:
-                output.value(0)
-                print(gpio_name, "LOW")
-            except Exception as exc:
-                print(gpio_name, "cleanup failed:", exc)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

triangle_target.py

@@ -22,6 +22,143 @@ def _log(msg):
         pass
 
 
+def _read_triangle_direction_cfg():
+    """读取 config 中三角形方向/中心距校验参数。"""
+    try:
+        import config as cfg
+        return {
+            "enable": bool(getattr(cfg, "TRIANGLE_DIRECTION_VALIDATE_ENABLE", True)),
+            "min_pass": int(getattr(cfg, "TRIANGLE_DIRECTION_MIN_PASS", 3)),
+            "dot_min": float(getattr(cfg, "TRIANGLE_DIRECTION_DOT_MIN", 0.0)),
+            "to_center_dot_min": float(
+                getattr(cfg, "TRIANGLE_DIRECTION_TO_CENTER_DOT_MIN", 0.35)
+            ),
+            "center_dist_enable": bool(
+                getattr(cfg, "TRIANGLE_CENTER_DISTANCE_VALIDATE_ENABLE", True)
+            ),
+            "center_dist_tol": float(
+                getattr(cfg, "TRIANGLE_CENTER_DISTANCE_RATIO_TOL", 0.45)
+            ),
+        }
+    except Exception:
+        return {
+            "enable": True,
+            "min_pass": 3,
+            "dot_min": 0.0,
+            "to_center_dot_min": 0.35,
+            "center_dist_enable": True,
+            "center_dist_tol": 0.45,
+        }
+
+
+def _quad_combo_orient_penalty(cands_4):
+    """
+    四点组合评分用的方向惩罚（原 _score_quad 内 orient_pen 逻辑）。
+    TRIANGLE_DIRECTION_VALIDATE_ENABLE=False 时调用方应跳过（不加罚）。
+    """
+    orient_pen = 0.0
+    orient_vote = []
+    for c in cands_4:
+        cen = np.array(c["center_px"], dtype=np.float32)
+        rpt = np.array(c["right_pt"], dtype=np.float32)
+        vx = float(cen[0] - rpt[0])
+        vy = float(cen[1] - rpt[1])
+        if abs(vx) < 1e-6 or abs(vy) < 1e-6:
+            orient_pen += 1.0
+            orient_vote.append(None)
+            continue
+        if abs(vx) < abs(vy) * 0.15 or abs(vy) < abs(vx) * 0.15:
+            orient_pen += 0.5
+        if vx > 0 and vy > 0:
+            orient_vote.append(0)
+        elif vx < 0 and vy > 0:
+            orient_vote.append(1)
+        elif vx > 0 and vy < 0:
+            orient_vote.append(2)
+        else:
+            orient_vote.append(3)
+    valid_votes = [v for v in orient_vote if v is not None]
+    if valid_votes:
+        from collections import Counter
+        vc = Counter(valid_votes)
+        orient_pen += max(0, max(vc.values()) - 1) * 0.8
+    return orient_pen
+
+
+def _marker_inward_unit(marker):
+    """从直角顶点指向三角内部的单位向量；marker['center'] 为直角顶点。"""
+    right = np.array(marker["center"], dtype=np.float64)
+    corners = marker.get("corners")
+    if not corners or len(corners) < 3:
+        return None
+    cen = np.mean(np.array(corners, dtype=np.float64), axis=0)
+    inv = cen - right
+    n = float(np.linalg.norm(inv))
+    if n < 1e-6:
+        return None
+    return inv / n
+
+
+def _validate_triangle_direction(marker_centers, tri_markers, cfg):
+    """
+    校验：四角到候选靶心距离近似一致；各真实黑三角朝向靶心。
+    仅统计 tri_markers 中真实检出的角（不含几何补全的虚拟点）。
+    Returns:
+        (ok: bool, reason: str)
+    """
+    if not cfg.get("enable", True):
+        return True, ""
+
+    pts = np.array(marker_centers, dtype=np.float64).reshape(-1, 2)
+    if len(pts) < 3:
+        return True, ""
+
+    quad_center = np.mean(pts, axis=0)
+
+    if cfg.get("center_dist_enable", True) and len(pts) >= 3:
+        dists = np.linalg.norm(pts - quad_center, axis=1)
+        mean_d = float(np.mean(dists))
+        if mean_d > 1e-6:
+            ratio = (float(np.max(dists)) - float(np.min(dists))) / mean_d
+            tol = float(cfg.get("center_dist_tol", 0.45))
+            if ratio > tol:
+                return False, f"center_dist_ratio={ratio:.2f}>{tol:.2f}"
+
+    dot_need = max(
+        float(cfg.get("dot_min", 0.0)),
+        float(cfg.get("to_center_dot_min", 0.35)),
+    )
+    pass_n = 0
+    check_n = 0
+    for m in tri_markers or []:
+        if m.get("center") is None:
+            continue
+        check_n += 1
+        right = np.array(m["center"], dtype=np.float64)
+        to_center = quad_center - right
+        nc = float(np.linalg.norm(to_center))
+        if nc < 1e-6:
+            continue
+        inward = _marker_inward_unit(m)
+        if inward is None:
+            continue
+        dot_tc = float(np.dot(inward, to_center / nc))
+        if dot_tc >= dot_need:
+            pass_n += 1
+
+    if check_n == 0:
+        return True, ""
+
+    min_pass = int(cfg.get("min_pass", 3))
+    min_pass = max(1, min(min_pass, check_n))
+    if pass_n < min_pass:
+        return False, (
+            f"direction_pass={pass_n}/{check_n} need>={min_pass} "
+            f"(dot>={dot_need:.2f})"
+        )
+    return True, ""
+
+
 def _gray_suppress_bright_by_v(img_rgb, v_above: int):
     """
     RGB 输入：在 HSV 的 V 上，将亮度 >= v_above 的像素灰度置为 255。
@@ -224,7 +361,7 @@ def detect_triangle_markers(
         blackhat_kernel_frac = 0.018
     try:
         import config as _tcfg
-        _timing_log = bool(getattr(_tcfg, "TRIANGLE_TIMING_LOG", True))
+        _timing_log = bool(getattr(_tcfg, "ARCHERY_TIMING_ENABLE", True)) and bool(getattr(_tcfg, "TRIANGLE_TIMING_LOG", True))
     except Exception:
         _timing_log = True
 
@@ -622,6 +759,8 @@ def detect_triangle_markers(
         bot_pair = sorted(by_y[2:], key=lambda i: pts_4[i][0])
         return top_pair[0], bot_pair[0], bot_pair[1], top_pair[1]
 
+    _dir_cfg_combo = _read_triangle_direction_cfg()
+
     def _score_quad(cands_4):
         pts = [np.array(c["center_px"]) for c in cands_4]
         legs = [c["avg_leg"] for c in cands_4]
@@ -641,7 +780,13 @@ def detect_triangle_markers(
         med_l = float(np.median(legs))
         leg_dev = max(abs(l - med_l) / (med_l + 1e-6) for l in legs)
 
-        score = (diag_ratio - 1.0) * 3.0 + (h_ratio - 1.0) + (v_ratio - 1.0) + leg_dev * 2.0
+        orient_pen = (
+            _quad_combo_orient_penalty(cands_4)
+            if _dir_cfg_combo.get("enable", True)
+            else 0.0
+        )
+
+        score = (diag_ratio - 1.0) * 3.0 + (h_ratio - 1.0) + (v_ratio - 1.0) + leg_dev * 2.0 + orient_pen
         return score, (tl, bl, br, tr)
 
     assigned = None
@@ -932,6 +1077,8 @@ def _assign_marker_ids_from_filtered(filtered, verbose=True):
         bot_pair = sorted(by_y[2:], key=lambda i: pts_4[i][0])
         return top_pair[0], bot_pair[0], bot_pair[1], top_pair[1]
 
+    _dir_cfg_combo = _read_triangle_direction_cfg()
+
     def _score_quad(cands_4):
         pts = [np.array(c["center_px"]) for c in cands_4]
         legs = [c["avg_leg"] for c in cands_4]
@@ -947,7 +1094,12 @@ def _assign_marker_ids_from_filtered(filtered, verbose=True):
         v_ratio = max(s_left, s_right) / (min(s_left, s_right) + 1e-6)
         med_l = float(np.median(legs))
         leg_dev = max(abs(l - med_l) / (med_l + 1e-6) for l in legs)
-        score = (diag_ratio - 1.0) * 3.0 + (h_ratio - 1.0) + (v_ratio - 1.0) + leg_dev * 2.0
+        orient_pen = (
+            _quad_combo_orient_penalty(cands_4)
+            if _dir_cfg_combo.get("enable", True)
+            else 0.0
+        )
+        score = (diag_ratio - 1.0) * 3.0 + (h_ratio - 1.0) + (v_ratio - 1.0) + leg_dev * 2.0 + orient_pen
         return score, (tl, bl, br, tr)
 
     assigned = None
@@ -1113,7 +1265,7 @@ def try_triangle_scoring(
 
     try:
         import config as _cfg_tl
-        _try_timing_log = bool(getattr(_cfg_tl, "TRIANGLE_TIMING_LOG", True))
+        _try_timing_log = bool(getattr(_cfg_tl, "ARCHERY_TIMING_ENABLE", True)) and bool(getattr(_cfg_tl, "TRIANGLE_TIMING_LOG", True))
         _crop_min_side = int(getattr(_cfg_tl, "TRIANGLE_CROP_ROI_MIN_SIDE_PX", 64))
     except Exception:
         _try_timing_log = True
@@ -1733,6 +1885,21 @@ def try_triangle_scoring(
             "is_virtual": bool(_is_virtual),
         })
 
+    # ---------- 方向 / 中心距校验（config.TRIANGLE_DIRECTION_*） ----------
+    _dir_cfg = _read_triangle_direction_cfg()
+    _dir_ok, _dir_reason = _validate_triangle_direction(
+        marker_centers, tri_markers, _dir_cfg
+    )
+    if not _dir_ok:
+        _log(f"[TRI] 方向校验失败: {_dir_reason}")
+        if _try_timing_log:
+            _log(
+                f"[TRI] timing_ms(try_triangle): {_tri_yolo_part} "
+                f"geometry={(time.perf_counter() - _t_seg) * 1000:.1f} "
+                f"total_try={(time.perf_counter() - _t_try0) * 1000:.1f} (方向校验失败)"
+            )
+        return out
+
     # ---------- 结果有效性校验（防 nan/inf 与退化角点） ----------
     try:
         import config as _cfg

version.md

@@ -1,34 +0,0 @@
-# 1.2.0 开始使用C++编译成.so，替换部分代码
-# 1.2.1 ota使用加密包
-# 1.2.2 支持wifi ota，并且设定时区，并使用单独线程保存图片
-# 1.2.3 修改ADC_TRIGGER_THRESHOLD 为2300，支持上传日志到服务器
-# 1.2.4 修改ADC_TRIGGER_THRESHOLD 为3000，并默认关闭摄像头的显示，并把ADC的采样间隔从50ms降低到10ms
-# 1.2.5 支持空气传感器采样，并默认关闭日志。优化断网时的发送队列丢消息问题，解决 WiFi 断线检测不可靠问题。
-# 1.2.6 在链接 wifi 前先判断 wifi 的可用性，假如不可用，则不落盘。增加日志批量压缩上传功能
-# 1.2.7 修复OTA失败的bug, 空气压力传感器的阈值是2500
-# 1.2.8 （1） 加快 wifi 下数据传输的速度。（2） 调整射箭时处理的逻辑，优先上报数据，再存照片之类的操作。（3）假如是用户打开激光的，射箭触发后不再关闭激光，因为是调瞄阶段
-# 1.2.9 增加电源板的控制和自动关机的功能
-# 1.2.10 config formal
-# 1.2.11 增加三角形的单应性算法，适配对应的靶纸
-# 1.2.110 关掉了黑色三角形算法，只用于测试
-# 1.2.13 修改wifi连接
-# 1.2.14 修改了icc登录部分
-# 2.15.3 新版本ota，去除ai算环数方法
-# 2.15.4 更新版本号
-# 2.15.5 打印ota进度
-# 2.15.6 更新版本号
-# 2.15.7 更新版本号
-# 2.15.8 启动不加载预加载yolo
-# 2.15.9 20cm
-# 2.15.10 不保存图片
-# 2.15.11 优化内存
-# 2.15.12 优化算法
-# 2.15.13 优化算法
-# 2.15.14 优化算法
-# 2.15.15 优化wifi连接
-# 2.15.16 修复wifi连接问题
-# 2.15.17 修复wifi连接问题
-# 2.15.18 wifi连接成功重新登录
-# 2.16.4  优化射箭延迟
-# 2.17.0  yolo标靶类别识别
-# 3.0.4 26-09-03 9:36 引脚修改：A23 -> P19 red light 

version.py

@@ -4,6 +4,28 @@
 应用版本号
 每次 OTA 更新时，只需要更新这个文件中的版本号
 """
-VERSION = '2.18.4'
+VERSION = '1.2.15.1'
+
+
+# 1.2.0 开始使用C++编译成.so，替换部分代码
+# 1.2.1 ota使用加密包
+# 1.2.2 支持wifi ota，并且设定时区，并使用单独线程保存图片
+# 1.2.3 修改ADC_TRIGGER_THRESHOLD 为2300，支持上传日志到服务器
+# 1.2.4 修改ADC_TRIGGER_THRESHOLD 为3000，并默认关闭摄像头的显示，并把ADC的采样间隔从50ms降低到10ms
+# 1.2.5 支持空气传感器采样，并默认关闭日志。优化断网时的发送队列丢消息问题，解决 WiFi 断线检测不可靠问题。
+# 1.2.6 在链接 wifi 前先判断 wifi 的可用性，假如不可用，则不落盘。增加日志批量压缩上传功能
+# 1.2.7 修复OTA失败的bug, 空气压力传感器的阈值是2500
+# 1.2.8 （1） 加快 wifi 下数据传输的速度。（2） 调整射箭时处理的逻辑，优先上报数据，再存照片之类的操作。（3）假如是用户打开激光的，射箭触发后不再关闭激光，因为是调瞄阶段
+# 1.2.9 增加电源板的控制和自动关机的功能
+# 1.2.10 config formal
+# 1.2.11 增加三角形的单应性算法，适配对应的靶纸
+# 1.2.110 关掉了黑色三角形算法，只用于测试
+# 1.2.13 修改wifi连接
+# 1.2.14 修改了icc登录部分
+# 1.2.15.1 增加了标靶判断 20 40 
+# 1.2.16.1 增加激光校准，三角形方向判断，时间开关
+
+
+
 
 

vision.py

@@ -10,6 +10,7 @@ import os
 import math
 import threading
 import queue
+import time
 from maix import image
 import config
 from logger_manager import logger_manager
@@ -531,11 +532,14 @@ def detect_circle_v3(frame, laser_point=None, img_cv=None):
     if img_cv is None:
         img_cv = image.image2cv(frame, False, False)
     logger = logger_manager.logger
+    _timing_on = bool(getattr(config, "VISION_TIMING_ENABLE", True))
+    _t0 = time.perf_counter() if _timing_on else None
+    _t1 = _t2 = _t3 = _t4 = _t5 = None
     from datetime import datetime
     logger.debug(f"[detect_circle_v3] begin {datetime.now()}")
     # -- 1. 缩图加速（与三角形路径保持一致）
     h_orig, w_orig = img_cv.shape[:2]
-    MAX_DET_DIM = 480
+    MAX_DET_DIM = 320
     long_side = max(h_orig, w_orig)
     if long_side > MAX_DET_DIM:
         det_scale = MAX_DET_DIM / long_side
@@ -554,6 +558,8 @@ def detect_circle_v3(frame, laser_point=None, img_cv=None):
     ellipse_params = None
     
     logger.debug(f"[detect_circle_v3] step 1 fin {datetime.now()}")
+    if _timing_on:
+        _t1 = time.perf_counter()
 
     # -- 2. HSV + 黄色掩码
     hsv = cv2.cvtColor(img_det, cv2.COLOR_RGB2HSV)
@@ -567,25 +573,26 @@ def detect_circle_v3(frame, laser_point=None, img_cv=None):
     mask_yellow = cv2.morphologyEx(mask_yellow, cv2.MORPH_CLOSE, kernel)
 
     logger.debug(f"[detect_circle_v3] step 2 fin {datetime.now()}")
+    if _timing_on:
+        _t2 = time.perf_counter()
+        _t3 = time.perf_counter()
 
     # -- 3. 红色掩码：在循环外只算一次
     mask_red = cv2.bitwise_or(
-        cv2.inRange(hsv, np.array([0, 30, 20]),   np.array([12,  255, 255])),
-        cv2.inRange(hsv, np.array([168, 30, 20]), np.array([180, 255, 255])),
+        cv2.inRange(hsv, np.array([0, 80, 0]),   np.array([10,  255, 255])),
+        cv2.inRange(hsv, np.array([170, 80, 0]), np.array([180, 255, 255])),
     )
     kernel_red = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
     mask_red = cv2.morphologyEx(mask_red, cv2.MORPH_CLOSE, kernel_red)
-    # 再加一次膨胀，加厚环状区域避免碎片化
-    mask_red = cv2.dilate(mask_red, kernel_red, iterations=1)
     contours_red, _ = cv2.findContours(mask_red, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     # 预先把红色轮廓筛选成 (center, radius) 列表，后续直接查表
     red_candidates = []
     for cnt_r in contours_red:
         ar = cv2.contourArea(cnt_r)
-        if ar <= 10:
+        if ar <= 50:
             continue
         pr = cv2.arcLength(cnt_r, True)
-        if pr <= 0 or (4 * np.pi * ar) / (pr * pr) <= 0.2:
+        if pr <= 0 or (4 * np.pi * ar) / (pr * pr) <= 0.6:
             continue
         if len(cnt_r) >= 5:
             (xr, yr), (wr, hr), _ = cv2.fitEllipse(cnt_r)
@@ -595,19 +602,22 @@ def detect_circle_v3(frame, laser_point=None, img_cv=None):
             red_candidates.append({"center": (int(xr), int(yr)), "radius": int(rr)})
 
     logger.debug(f"[detect_circle_v3] step 3 fin {datetime.now()}")
+    if _timing_on:
+        _t3 = time.perf_counter()
+        _t4 = time.perf_counter()
 
     # -- 4. 黄色轮廓循环（复用上面的红色候选列表）
     contours_yellow, _ = cv2.findContours(mask_yellow, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     valid_targets = []
     for cnt_yellow in contours_yellow:
         area = cv2.contourArea(cnt_yellow)
-        if area <= 15:
+        if area <= 50:
             continue
         perimeter = cv2.arcLength(cnt_yellow, True)
         if perimeter <= 0:
             continue
         circularity = (4 * np.pi * area) / (perimeter * perimeter)
-        if circularity <= 0.5:
+        if circularity <= 0.7:
             continue
         if logger:
             logger.info(f"[target] -> 面积:{area:.1f}, 圆度:{circularity:.2f}")
@@ -627,11 +637,7 @@ def detect_circle_v3(frame, laser_point=None, img_cv=None):
             ddx = yellow_center[0] - rc["center"][0]
             ddy = yellow_center[1] - rc["center"][1]
             dist_centers = math.hypot(ddx, ddy)
-            max_dist = yellow_radius * 2.0
-            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 < yellow_radius * 1.5 and rc["radius"] > yellow_radius * 0.8:
                 if logger:
                     logger.info(f"[target] -> 找到匹配的红圈: 黄心({yellow_center}), "
                                 f"红心({rc['center']}), 距离:{dist_centers:.1f}, "
@@ -644,19 +650,13 @@ def detect_circle_v3(frame, laser_point=None, img_cv=None):
                 })
                 matched = True
                 break
-        if not matched:
-            # 黄圈高置信度兜底：大且圆时跳过红圈验证
-            if area > 30 and circularity > 0.8:
-                valid_targets.append({
-                    "center": yellow_center,
-                    "radius": yellow_radius,
-                    "ellipse": yellow_ellipse,
-                    "area": area,
-                })
-            elif logger:
-                logger.debug("Debug -> 未找到匹配的红色圆圈，可能是误识别")
+        if not matched and logger:
+            logger.debug("Debug -> 未找到匹配的红色圆圈，可能是误识别")
 
     logger.debug(f"[detect_circle_v3] step 4 fin {datetime.now()}")
+    if _timing_on:
+        _t4 = time.perf_counter()
+        _t5 = time.perf_counter()
 
     # -- 5. 选最佳目标，坐标还原到原始分辨率
     if valid_targets:
@@ -684,7 +684,20 @@ def detect_circle_v3(frame, laser_point=None, img_cv=None):
         ellipse_params = be
         best_radius1 = best_radius * 5
     result_img = image.cv2image(img_cv, False, False)
-    logger.debug(f"[detect_circle_v3] step 5 fin {datetime.now()}")
+    if _timing_on:
+        _t5 = time.perf_counter()
+        _t_all = (_t5 - _t0) * 1000
+        _ms1 = (_t1 - _t0) * 1000
+        _ms2 = (_t2 - _t1) * 1000
+        _ms3 = (_t3 - _t2) * 1000
+        _ms4 = (_t4 - _t3) * 1000
+        _ms5 = (_t5 - _t4) * 1000
+        logger.info(
+            f"[VISION timing] total={_t_all:.1f}ms  "
+            f"resize={_ms1:.1f}  hsv_yellow={_ms2:.1f}  "
+            f"red_mask={_ms3:.1f}  yellow_loop={_ms4:.1f}  "
+            f"select_cv2img={_ms5:.1f}"
+        )
     return result_img, best_center, best_radius, method, best_radius1, ellipse_params
 
 def estimate_distance(pixel_radius):
@@ -797,12 +810,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
@@ -936,14 +949,58 @@ def start_save_shot_worker():
         logger.info("[VISION] 存图 worker 线程已启动")
 
 
+def enqueue_save_raw_shot(frame, shot_id=None, photo_dir=None):
+    """
+    异步保存射箭原图（无算法标注）。需 SAVE_IMAGE_ENABLED 且 SAVE_RAW_SHOT_IMAGE_ENABLED。
+    文件名：{photo_dir}/shot_{shot_id}_raw.jpg
+    """
+    if not getattr(config, "SAVE_RAW_SHOT_IMAGE_ENABLED", False):
+        return
+    if not getattr(config, "SAVE_IMAGE_ENABLED", True):
+        return
+    if not shot_id:
+        return
+    if photo_dir is None:
+        photo_dir = config.PHOTO_DIR
+
+    try:
+        img_cv = image.image2cv(frame, False, False)
+        img_copy = np.copy(img_cv)
+    except Exception as e:
+        logger = logger_manager.logger
+        if logger:
+            logger.error(f"[VISION] enqueue_save_raw_shot 复制图像失败: {e}")
+        return
+
+    def _job():
+        try:
+            try:
+                if photo_dir not in os.listdir("/root"):
+                    os.mkdir(photo_dir)
+            except Exception:
+                pass
+            filename = f"{photo_dir}/shot_{shot_id}_raw.jpg"
+            out = image.cv2image(img_copy, False, False)
+            out.save(filename)
+            logger = logger_manager.logger
+            if logger:
+                logger.info(f"[VISION] 已保存射箭原图: {filename}")
+            prune_old_images_in_dir(photo_dir, config.MAX_IMAGES, logger, "[VISION]")
+        except Exception as e:
+            logger = logger_manager.logger
+            if logger:
+                logger.error(f"[VISION] 保存射箭原图失败: {e}")
+
+    threading.Thread(target=_job, daemon=True).start()
+
+
 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 +1023,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 +1034,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 +1056,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
@@ -1028,3 +1083,63 @@ def detect_target(frame, laser_point=None):
         logger.debug("[VISION] 使用传统黄色靶心检测")
     return detect_circle_v3(frame, laser_point)
 
+
+def sample_target_rgb_at_physical_radius(frame, target_center, target_radius_px, radius_cm=None, angles_deg=None, patch_half_px=None, black_thresh=None, timing=False):
+    """
+    在物方半径位置采样 RGB，判断黑/白靶。
+    返回: dict {ok, is_black, mean_rgb, samples, black_ratio, elapsed_ms}
+    """
+    logger = logger_manager.logger
+    if target_center is None or target_radius_px is None:
+        return {"ok": False, "reason": "no_target", "is_black": None, "elapsed_ms": 0.0}
+
+    radius_cm = float(radius_cm if radius_cm is not None else getattr(config, "TRIANGLE_SAMPLE_RADIUS_CM", 15.0))
+    angles_deg = tuple(angles_deg if angles_deg is not None else getattr(config, "TRIANGLE_SAMPLE_ANGLES_DEG", (0, 90, 180, 270)))
+    patch_half_px = int(patch_half_px if patch_half_px is not None else getattr(config, "TRIANGLE_SAMPLE_PATCH_HALF_PX", 2))
+    black_thresh = float(black_thresh if black_thresh is not None else getattr(config, "TRIANGLE_SAMPLE_BLACK_THRESH", 30.0))
+    timing_on = bool(timing) and bool(getattr(config, "TRIANGLE_SAMPLE_TIMING_ENABLE", True))
+    t0 = time.perf_counter() if timing_on else None
+
+    try:
+        img_cv = image.image2cv(frame, False, False)
+        h, w = img_cv.shape[:2]
+        cx, cy = float(target_center[0]), float(target_center[1])
+        scale = float(target_radius_px) / max(radius_cm, 1e-6)
+        samples = []
+        black_count = 0
+        for ang in angles_deg:
+            rad = math.radians(float(ang))
+            sx = int(round(cx + math.cos(rad) * radius_cm * scale))
+            sy = int(round(cy + math.sin(rad) * radius_cm * scale))
+            x0 = max(0, sx - patch_half_px)
+            y0 = max(0, sy - patch_half_px)
+            x1 = min(w, sx + patch_half_px + 1)
+            y1 = min(h, sy + patch_half_px + 1)
+            if x1 <= x0 or y1 <= y0:
+                continue
+            patch = img_cv[y0:y1, x0:x1]
+            mean_rgb = patch.reshape(-1, 3).mean(axis=0)
+            is_black = bool(np.all(mean_rgb < black_thresh))
+            black_count += 1 if is_black else 0
+            samples.append({"angle": float(ang), "xy": (sx, sy), "mean_rgb": tuple(float(v) for v in mean_rgb), "is_black": is_black})
+        black_ratio = float(black_count) / float(len(samples) or 1)
+        out = {
+            "ok": len(samples) > 0,
+            "is_black": black_ratio >= 0.5,
+            "mean_rgb": tuple(float(v) for v in (np.mean([s["mean_rgb"] for s in samples], axis=0) if samples else (0, 0, 0))),
+            "samples": samples,
+            "black_ratio": black_ratio,
+            "elapsed_ms": (time.perf_counter() - t0) * 1000.0 if timing_on else 0.0,
+        }
+        if logger:
+            logger.info(
+                f"[TRI-SAMPLE] radius_cm={radius_cm:.1f} black_thresh={black_thresh:.1f} "
+                f"black_ratio={black_ratio:.2f} is_black={out['is_black']} "
+                f"elapsed_ms={out['elapsed_ms']:.1f} samples={len(samples)}"
+            )
+        return out
+    except Exception as e:
+        if logger:
+            logger.error(f"[TRI-SAMPLE] 采样失败: {e}")
+        return {"ok": False, "reason": str(e), "is_black": None, "elapsed_ms": 0.0}
+

wifi.py

@@ -41,7 +41,6 @@ class WiFiManager:
         # WiFi 质量监测（后台线程）
         self._wifi_quality_monitor_thread = None
         self._wifi_quality_stop_event = threading.Event()
-        self._wifi_quality_lock = threading.Lock()
         self._last_wifi_rtt_ms = None  # 最近一次测量的 RTT
         self._last_wifi_rssi_dbm = None  # 最近一次测量的 RSSI
         
@@ -239,6 +238,7 @@ class WiFiManager:
         old_conf = _read_text(conf_path)
         old_boot_ssid = _read_text(ssid_file)
         old_boot_pass = _read_text(pass_file)
+        old_boot_wpa = _read_text(boot_wpa_path) if os.path.exists(boot_wpa_path) else None
 
         try:
             try:
@@ -250,13 +250,9 @@ class WiFiManager:
                 _write_text(conf_path, full_conf)
             except Exception:
                 pass
-            # 删除 wpa_supplicant.conf，让 S30wifi 回退读 ssid/pass
-            try:
-                if os.path.exists(boot_wpa_path):
-                    os.remove(boot_wpa_path)
-            except Exception:
-                pass
+            _write_text(boot_wpa_path, full_conf)
 
+            # 仍写入 ssid/pass，便于其它脚本/人工查看；S30wifi 优先使用 wpa_supplicant.conf
             _write_text(ssid_file, ssid.strip())
             _write_text(pass_file, password.strip())
 
@@ -296,6 +292,7 @@ class WiFiManager:
                     if not persist:
                         # 不持久化：把 /boot 恢复成旧值（不重启，当前连接保持不变）
                         _restore_boot(old_boot_ssid, old_boot_pass)
+                        _restore_boot_wpa(old_boot_wpa)
                         self.logger.info("[WIFI] 网络验证通过，但按 persist=False 回滚 /boot 凭证（不重启）")
                     else:
                         self.logger.info("[WIFI] 网络验证通过，/boot 凭证已保留（持久化）")
@@ -309,6 +306,7 @@ class WiFiManager:
         except Exception as e:
             # 失败：回滚 /boot 和 /etc，重启 WiFi 恢复旧网络
             _restore_boot(old_boot_ssid, old_boot_pass)
+            _restore_boot_wpa(old_boot_wpa)
             try:
                 if old_conf is not None:
                     _write_text(conf_path, old_conf)
@@ -353,11 +351,7 @@ class WiFiManager:
             else:
                 full_conf = build_sta_conf_open(ssid)
             _write_text(conf_path, full_conf)
-            try:
-                if os.path.exists(boot_wpa_path):
-                    os.remove(boot_wpa_path)
-            except Exception:
-                pass
+            _write_text(boot_wpa_path, full_conf)
         except ValueError as e:
             return False, str(e)
         except Exception as e:
@@ -548,45 +542,34 @@ class WiFiManager:
             network_type_callback: 获取当前网络类型的回调函数
             on_poor_quality_callback: WiFi质量差时的回调函数
         """
-        with self._wifi_quality_lock:
-            if self._wifi_quality_monitor_thread is not None and self._wifi_quality_monitor_thread.is_alive():
-                self.logger.warning("[WiFi Monitor] 监测线程已在运行")
-                return
+        if self._wifi_quality_monitor_thread is not None:
+            self.logger.warning("[WiFi Monitor] 监测线程已在运行")
+            return
         
-            self._network_type_callback = network_type_callback
-            self._on_poor_quality_callback = on_poor_quality_callback
-            self._wifi_quality_stop_event.clear()
-            self._wifi_quality_monitor_thread = threading.Thread(
-                target=self._quality_monitor_loop,
-                daemon=True,
-                name="wifi_quality_monitor"
-            )
-            self._wifi_quality_monitor_thread.start()
-            self.logger.info("[WiFi Monitor] 已启动后台监测线程")
+        self._network_type_callback = network_type_callback
+        self._on_poor_quality_callback = on_poor_quality_callback
+        self._wifi_quality_stop_event.clear()
+        self._wifi_quality_monitor_thread = threading.Thread(
+            target=self._quality_monitor_loop,
+            daemon=True,
+            name="wifi_quality_monitor"
+        )
+        self._wifi_quality_monitor_thread.start()
+        self.logger.info("[WiFi Monitor] 已启动后台监测线程")
     
     def stop_quality_monitor(self):
         """停止 WiFi 质量监测线程"""
-        with self._wifi_quality_lock:
-            t = self._wifi_quality_monitor_thread
-            if t is None:
-                return
-            if not t.is_alive():
-                self._wifi_quality_monitor_thread = None
-                return
+        if self._wifi_quality_monitor_thread is None:
+            return
         
         self._wifi_quality_stop_event.set()
         try:
-            t.join(timeout=2.0)
+            self._wifi_quality_monitor_thread.join(timeout=2.0)
         except Exception as e:
             self.logger.error(f"[WiFi Monitor] 停止线程失败：{e}")
-        
-        with self._wifi_quality_lock:
-            if t is self._wifi_quality_monitor_thread:
-                if t.is_alive():
-                    self.logger.warning("[WiFi Monitor] 线程未在超时内退出，保留引用防止重复创建")
-                else:
-                    self._wifi_quality_monitor_thread = None
-                    self.logger.info("[WiFi Monitor] 已停止后台监测线程")
+        finally:
+            self._wifi_quality_monitor_thread = None
+            self.logger.info("[WiFi Monitor] 已停止后台监测线程")
     
     def _quality_monitor_loop(self):
         """

yolo_te.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Standalone live camera + single YOLO runner.
+
+不复用项目内的 `camera_manager` / `target_roi_yolo` / `config` / `logger_manager`。
+
+功能：
+- 独立初始化摄像头
+- 实时读取帧
+- 独立加载单个 YOLO 模型并推理
+- 画出检测框、ROI、FPS
+
+适用场景：
+- 单独验证一个模型是否能跑
+- 验证实时帧率
+- 验证 ROI 是否裁对
+- 不进入主业务射箭流程
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass
+
+
+@dataclass
+class RunnerConfig:
+    camera_width: int = 640
+    camera_height: int = 480
+    model_path: str = "/root/model_278702.mud"
+    conf_th: float = 0.7
+    retry_conf_th: float = 0.5
+    class_ids: tuple = (0,)
+    merge_mode: str = "union"
+    coord_mode: str = "native"
+    roi_margin_frac: float = 0.11
+    min_box_side_px: int = 8
+
+
+def log(msg: str):
+    print(msg)
+
+
+class DummyLogger:
+    def info(self, msg):
+        log(msg)
+
+    def warning(self, msg):
+        log(msg)
+
+    def error(self, msg):
+        log(msg)
+
+
+class StandaloneYOLORunner:
+    def __init__(self, cfg: RunnerConfig):
+        self.cfg = cfg
+        self.logger = DummyLogger()
+        self._last_fps_t = time.perf_counter()
+        self._frames = 0
+        self._fps = 0.0
+        self._camera = None
+        self._det = None
+
+    def _import_maix(self):
+        try:
+            from maix import camera, image, nn
+            return camera, image, nn
+        except Exception as e:
+            raise RuntimeError(f"maix import failed: {e}")
+
+    def _init_camera(self):
+        camera, _, _ = self._import_maix()
+        if self._camera is not None:
+            return self._camera
+        try:
+            self._camera = camera.Camera(
+                width=self.cfg.camera_width,
+                height=self.cfg.camera_height,
+                format=camera.RGB888,
+            )
+        except Exception:
+            self._camera = camera.Camera(width=self.cfg.camera_width, height=self.cfg.camera_height)
+        return self._camera
+
+    def _load_detector(self, model_path: str):
+        _, _, nn = self._import_maix()
+        if not model_path or not os.path.isfile(model_path):
+            return None
+        return nn.YOLOv5(model=model_path, dual_buff=False)
+
+    @staticmethod
+    def _get_class_id(obj):
+        for key in ("class_id", "cls", "label", "category", "cat_id", "id"):
+            if hasattr(obj, key):
+                v = getattr(obj, key)
+                if v is None:
+                    continue
+                try:
+                    return int(float(v))
+                except Exception:
+                    pass
+        return None
+
+    @staticmethod
+    def _normalize_boxes(raw):
+        out = []
+        for o in raw or []:
+            if isinstance(o, (list, tuple)) and len(o) >= 6:
+                class Box:
+                    pass
+                b = Box()
+                b.x, b.y, b.w, b.h, b.score, b.class_id = map(float, o[:6])
+                out.append(b)
+            else:
+                out.append(o)
+        return out
+
+    def _det_to_xyxy(self, det, obj):
+        x = float(getattr(obj, "x", 0.0))
+        y = float(getattr(obj, "y", 0.0))
+        w = float(getattr(obj, "w", 0.0))
+        h = float(getattr(obj, "h", 0.0))
+        return x, y, x + w, y + h
+
+    def _run_detector(self, det, img, conf_th, class_ids):
+        if det is None:
+            return []
+        raw = det.detect(img, conf_th=conf_th)
+        objs = self._normalize_boxes(raw if raw is not None else [])
+        out = []
+        for o in objs:
+            cid = self._get_class_id(o)
+            if cid is not None and cid not in class_ids:
+                continue
+            out.append(o)
+        return out
+
+    def _calc_fps(self):
+        self._frames += 1
+        now = time.perf_counter()
+        dt = now - self._last_fps_t
+        if dt >= 1.0:
+            self._fps = self._frames / dt
+            self._frames = 0
+            self._last_fps_t = now
+        return self._fps
+
+    def _draw_text(self, img, lines):
+        try:
+            import cv2
+            y = 24
+            for line in lines:
+                cv2.putText(img, line, (10, y), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (0, 255, 0), 1, cv2.LINE_AA)
+                y += 20
+        except Exception:
+            pass
+
+    def _clip_roi(self, x0, y0, x1, y1, w, h):
+        x0 = max(0, min(int(x0), w - 1))
+        y0 = max(0, min(int(y0), h - 1))
+        x1 = max(x0 + 1, min(int(x1), w))
+        y1 = max(y0 + 1, min(int(y1), h))
+        return x0, y0, x1, y1
+
+    def _merge_boxes(self, boxes):
+        if not boxes:
+            return None
+        x0 = min(b[0] for b in boxes)
+        y0 = min(b[1] for b in boxes)
+        x1 = max(b[2] for b in boxes)
+        y1 = max(b[3] for b in boxes)
+        return x0, y0, x1, y1
+
+    def _run_single_yolo(self, frame, img_cv):
+        h, w = int(img_cv.shape[0]), int(img_cv.shape[1])
+        if self._det is None:
+            self._det = self._load_detector(self.cfg.model_path)
+        det = self._det
+        if det is None:
+            return []
+
+        boxes = self._run_detector(det, frame, self.cfg.conf_th, self.cfg.class_ids)
+        if not boxes and self.cfg.retry_conf_th < self.cfg.conf_th:
+            boxes = self._run_detector(det, frame, self.cfg.retry_conf_th, self.cfg.class_ids)
+
+        xyxy = []
+        for obj in boxes:
+            x0, y0, x1, y1 = self._det_to_xyxy(det, obj)
+            if (x1 - x0) < self.cfg.min_box_side_px or (y1 - y0) < self.cfg.min_box_side_px:
+                continue
+            if self.cfg.coord_mode == "native":
+                x0, y0, x1, y1 = self._clip_roi(x0, y0, x1, y1, w, h)
+            xyxy.append((x0, y0, x1, y1))
+        return xyxy
+
+    def run(self):
+        _, image, _ = self._import_maix()
+        cam = self._init_camera()
+        log("[YOLOTE] standalone runner started")
+
+        while True:
+            try:
+                frame = cam.read()
+            except Exception as e:
+                log(f"[YOLOTE] camera read failed: {e}")
+                time.sleep(0.02)
+                continue
+
+            if frame is None:
+                time.sleep(0.01)
+                continue
+
+            try:
+                img_cv = image.image2cv(frame, False, False)
+            except Exception as e:
+                log(f"[YOLOTE] image2cv failed: {e}")
+                time.sleep(0.01)
+                continue
+
+            import cv2
+            t0 = time.perf_counter()
+            boxes = self._run_single_yolo(frame, img_cv)
+            t1 = time.perf_counter()
+
+            for i, (bx0, by0, bx1, by1) in enumerate(boxes):
+                cv2.rectangle(img_cv, (int(bx0), int(by0)), (int(bx1) - 1, int(by1) - 1), (0, 255, 0), 2)
+                cv2.putText(img_cv, f"B{i}", (int(bx0), max(0, int(by0) - 4)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1, cv2.LINE_AA)
+
+            fps = self._calc_fps()
+            self._draw_text(
+                img_cv,
+                [
+                    f"FPS: {fps:.1f}",
+                    f"YOLO: {(t1 - t0)*1000.0:.1f} ms",
+                    f"Boxes: {len(boxes)}",
+                    "Ctrl+C to exit",
+                ],
+            )
+
+            try:
+                frame_out = image.cv2image(img_cv, False, False)
+                if hasattr(cam, "show"):
+                    cam.show(frame_out)
+                else:
+                    try:
+                        frame_out.show()
+                    except Exception:
+                        pass
+            except Exception as e:
+                log(f"[YOLOTE] show failed: {e}")
+
+            time.sleep(0.001)
+
+
+def main():
+    cfg = RunnerConfig()
+    runner = StandaloneYOLORunner(cfg)
+    try:
+        runner.run()
+    except KeyboardInterrupt:
+        log("[YOLOTE] interrupted")
+
+
+if __name__ == "__main__":
+    main()