feat: 1.json换为pb 2.wifi、ota 优化

- 新增 tcp_messages_pb2.py protobuf Python绑定
- msg_handler.cpp: 新增 make_packet_pb/raw bytes打包, parse_packet_raw/raw解析
- archery_netcore.cpp: 注册 make_packet_pb/parse_packet_raw
- network.py: 新增 _use_proto 标志，_make_send_packet/_parse_recv 自动选择proto/JSON
- 登录version加+proto后缀标识proto模式
- protobuf序列化/反序列化失败时自动回退JSON

.vscode/settings.json

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

4g.py

@@ -109,6 +109,7 @@
 from maix import app, uart, pinmap, time
 import hashlib
 import hmac
+import re
 import ujson
 
 # ========== 配置 ==========
@@ -130,53 +131,109 @@ 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 指令并等待 OK / ERROR"""
+    """发送 AT 指令并返回完整响应；超时返回已收到的内容。"""
     print("[AT] =>", cmd_str)
     http_serial.write((cmd_str + "\r\n").encode())
     buffer = b""
     start = time.ticks_ms()
-    while time.ticks_ms() - start < timeout_ms:
+    while time.ticks_diff(time.ticks_ms(), start) < timeout_ms:
         data = http_serial.read(128)
         if data:
             buffer += data
             try:
-                decoded = buffer.decode()
+                decoded = buffer.decode("utf-8", "ignore")
-                print("<= ", decoded.strip())
+                if "OK" in decoded or "+CME ERROR" in decoded or "ERROR" in decoded:
-                if "OK" in decoded:
+                    print("[AT] <=", decoded.strip())
-                    return True
+                    return decoded
-                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}"'
-    if send_cmd(cmd):
+    response = send_cmd(cmd, 8000)
-        # 尝试提取 instance ID（如果模块返回）
+    match = re.search(r"\+MHTTPCREATE:\s*(\d+)", response)
-        # 注意：部分模块不会返回 ID，可忽略，直接用 0 或 1
+    if not response_ok(response) or not match:
-        return True
+        print("❌ 创建 HTTP 实例失败，模组响应:", response.strip() or "<empty>")
-    return False
+        return None
+    return int(match.group(1))
 
 def send_http_request(url, api_path, token, device_id, json_data):
     # 1. 创建 HTTP 实例
-    if not create_http_instance(url):
+    instance_id = create_http_instance(url)
-        print("❌ 创建 HTTP 实例失败")
+    if instance_id is None:
         return False
 
-    # 2. 设置 Headers（假设实例 ID 为 0，或根据模块默认）
+    # 2. 设置 Headers
-    instance_id = 0  # 大多数模块默认实例为 0；若支持多实例，需解析返回值
+    commands = (
-    send_cmd(f'AT+MHTTPCFG="header",{instance_id},"Content-Type: application/json"')
+        f'AT+MHTTPCFG="header",{instance_id},"Content-Type: application/json"',
-    send_cmd(f'AT+MHTTPCFG="header",{instance_id},"Authorization: {token}"')
+        f'AT+MHTTPCFG="header",{instance_id},"Authorization: {token}"',
-    send_cmd(f'AT+MHTTPCFG="header",{instance_id},"DeviceId: {device_id}"')
+        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
 
     # 3. 发送 Body
     json_str = ujson.dumps(json_data)
-    send_cmd(f'AT+MHTTPCONTENT={instance_id},0,0,"{json_str}"')
+    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
 
     # 4. 发起 POST 请求
-    if send_cmd(f'AT+MHTTPREQUEST={instance_id},2,0,"{api_path}"'):
+    if response_ok(send_cmd(f'AT+MHTTPREQUEST={instance_id},2,0,"{api_path}"', 15000)):
         print("✅ HTTP 请求已发送")
         return True
     else:
@@ -199,7 +256,7 @@ def read_response(timeout_ms=5000):
 print("🚀 启动直接上传流程...")
 
 token = generate_token(device_id)
-print("🔑 Token:", token)
+print("🔑 Token 已生成:", token[:12] + "...")
 
 # 构造模拟数据
 timestamp = int(time.time() * 1000)
@@ -216,7 +273,14 @@ json_data = {
 }
 
 # 执行上传
-if send_http_request(url, api_path, token, device_id, 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:
     read_response()
 else:
     print("💥 上传流程失败")

app.yaml

@@ -1,6 +1,6 @@
 id: t11
 name: t11
-version: 2.15.35
+version: 3.1.15
 author: t11
 icon: ''
 desc: t11
@@ -25,9 +25,11 @@ files:
   - ota_manager.py
   - power.py
   - server.pem
+  - set_autostart.py
   - shoot_manager.py
   - shot_id_generator.py
   - target_roi_yolo.py
+  - tcp_messages_pb2.py
   - time_sync.py
   - triangle_positions.json
   - triangle_target.py

camera_manager.py

@@ -8,6 +8,15 @@ import threading
 import config
 from logger_manager import logger_manager
 
+_USE_CV = False
+try:
+    import cv2
+    import numpy as np
+    from maix import image as _maix_image
+    _USE_CV = True
+except ImportError:
+    pass
+
 
 class CameraManager:
     """相机管理器（单例）"""
@@ -57,6 +66,12 @@ class CameraManager:
         with self._camera_lock:
             if self._camera is None:
                 self._camera = camera.Camera(width, height)
+                v_flip = getattr(config, 'CAMERA_V_FLIP', False)
+                h_mirror = getattr(config, 'CAMERA_H_MIRROR', False)
+                if v_flip:
+                    self._camera.vflip(1)
+                if h_mirror:
+                    self._camera.hmirror(1)
         
         return self._camera
     
@@ -101,7 +116,8 @@ class CameraManager:
         with self._camera_lock:
             if self._camera is None:
                 self.init_camera()
-            return self._camera.read()
+            frame = self._camera.read()
+            return frame
     
     def show(self, image):
         """

config.py

@@ -15,6 +15,8 @@ LOCAL_FILENAME = APP_DIR + "/main_tmp.py"
 # 相机初始化分辨率（CameraManager / main.py 使用）
 CAMERA_WIDTH = 640
 CAMERA_HEIGHT = 480
+CAMERA_V_FLIP = True   # 摄像头垂直翻转（上下颠倒时设为 True）
+CAMERA_H_MIRROR = True  # 摄像头水平镜像（左右反了时设为 True）
 
 # 三角形检测缩图比例：默认按相机最长边缩到 1/2（性能更稳；可按需调整）
 # 取值范围建议 (0.25 ~ 1.0]；1.0 表示不缩图
@@ -48,7 +50,7 @@ WIFI_CONFIG_AP_IP = "192.168.66.1"         # 与 MaixPy Wifi.start_ap 默认一
 # ===== TCP over SSL(TLS) 配置 =====
 USE_TCP_SSL = True          # True=按手册走 MSSLCFG/MIPCFG 绑定 SSL
 TCP_LINK_ID = 2             # 
-TCP_SSL_PORT = 50006          # TLS 端口（不一定必须 443，以服务器为准）
+TCP_SSL_PORT = 50007          # TLS 端口（不一定必须 443，以服务器为准）
 
 # SSL profile
 SSL_ID = 1                  # ssl_id=1
@@ -96,6 +98,11 @@ 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])  # 激光测距查询命令
@@ -348,11 +355,29 @@ 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表示不自动关机
+AUTO_POWER_OFF_IN_SECONDS = 100 * 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

cpp_ext/archery_netcore.cpp

@@ -57,9 +57,16 @@ PYBIND11_MODULE(archery_netcore, m) {
           "Pack TCP packet: header (len+type+checksum) + JSON body",
           py::arg("msg_type"), py::arg("body_dict"));
 
+    m.def("make_packet_pb", &netcore::make_packet_pb,
+          "Pack TCP packet: header (len+type+checksum) + raw bytes body (for protobuf)",
+          py::arg("msg_type"), py::arg("body_bytes"));
+
     m.def("parse_packet", &netcore::parse_packet,
           "Parse TCP packet, return (msg_type, body_dict)");
 
+    m.def("parse_packet_raw", &netcore::parse_packet_raw,
+          "Parse TCP packet, return (msg_type, body_bytes) without JSON parsing");
+
     m.def("get_config", &get_config, "Get system configuration");
 
     m.def(

cpp_ext/msg_handler.cpp

@@ -51,6 +51,43 @@ namespace netcore {
         return py::bytes(reinterpret_cast<const char*>(packet.data()), packet.size());
     }
 
+    // 打包 TCP 数据包 (raw bytes body, 用于 protobuf)
+    py::bytes make_packet_pb(int msg_type, py::bytes body_bytes) {
+        netcore::log_debug(std::string("make_packet_pb msg_type=") + std::to_string(msg_type));
+
+        py::buffer_info buf = py::buffer(body_bytes).request();
+        uint32_t body_len = buf.size;
+        uint32_t checksum = body_len + msg_type;
+
+        std::vector<uint8_t> packet;
+        packet.reserve(12 + body_len);
+
+        // body_len (big-endian, 4 bytes)
+        packet.push_back((body_len >> 24) & 0xFF);
+        packet.push_back((body_len >> 16) & 0xFF);
+        packet.push_back((body_len >> 8) & 0xFF);
+        packet.push_back(body_len & 0xFF);
+
+        // msg_type (big-endian, 4 bytes)
+        packet.push_back((msg_type >> 24) & 0xFF);
+        packet.push_back((msg_type >> 16) & 0xFF);
+        packet.push_back((msg_type >> 8) & 0xFF);
+        packet.push_back(msg_type & 0xFF);
+
+        // checksum (big-endian, 4 bytes)
+        packet.push_back((checksum >> 24) & 0xFF);
+        packet.push_back((checksum >> 16) & 0xFF);
+        packet.push_back((checksum >> 8) & 0xFF);
+        packet.push_back(checksum & 0xFF);
+
+        // 追加 body bytes
+        const uint8_t* body_ptr = static_cast<const uint8_t*>(buf.ptr);
+        packet.insert(packet.end(), body_ptr, body_ptr + body_len);
+
+        netcore::log_debug(std::string("make_packet_pb done bytes=") + std::to_string(packet.size()));
+        return py::bytes(reinterpret_cast<const char*>(packet.data()), packet.size());
+    }
+
     // 解析 TCP 数据包
     py::tuple parse_packet(py::bytes data) {
         // 1) 转换为 bytes view
@@ -110,4 +147,26 @@ namespace netcore {
             return py::make_tuple(py::int_(msg_type), raw_dict);
         }
     }
+
+    // 解析 TCP 数据包 -> (msg_type, body_bytes) 不做 JSON 解析
+    py::tuple parse_packet_raw(py::bytes data) {
+        py::buffer_info buf = py::buffer(data).request();
+        if (buf.size < 12) {
+            return py::make_tuple(py::none(), py::none());
+        }
+
+        const uint8_t* ptr = static_cast<const uint8_t*>(buf.ptr);
+
+        uint32_t body_len = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
+        uint32_t msg_type = (ptr[4] << 24) | (ptr[5] << 16) | (ptr[6] << 8) | ptr[7];
+
+        uint32_t expected_len = 12 + body_len;
+        if (buf.size < expected_len) {
+            return py::make_tuple(py::none(), py::none());
+        }
+
+        // 返回原始 body bytes（不做 JSON 解析）
+        py::bytes body_bytes(reinterpret_cast<const char*>(ptr + 12), body_len);
+        return py::make_tuple(py::int_(msg_type), body_bytes);
+    }
 }

cpp_ext/msg_handler.hpp

@@ -7,8 +7,15 @@ namespace py = pybind11;
 
 namespace netcore {
 
-    // 打包 TCP 数据包
+    // 打包 TCP 数据包 (JSON body)
     py::bytes make_packet(int msg_type, py::dict body_dict);
-    // 解包 TCP 数据包
+
+    // 打包 TCP 数据包 (raw bytes body, 用于 protobuf)
+    py::bytes make_packet_pb(int msg_type, py::bytes body_bytes);
+
+    // 解包 TCP 数据包 -> (msg_type, body_dict)
     py::tuple parse_packet(py::bytes data);
+
+    // 解包 TCP 数据包 -> (msg_type, body_bytes) 不做 JSON 解析
+    py::tuple parse_packet_raw(py::bytes data);
 }

hardware.py

@@ -5,6 +5,7 @@
 提供硬件对象的统一管理和访问
 """
 from maix import time
+import _thread
 import config
 from at_client import ATClient
 
@@ -28,6 +29,7 @@ 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         # 用于停止定时器的标志
@@ -104,11 +106,87 @@ 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_manager.py

@@ -31,6 +31,7 @@ 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()
@@ -69,10 +70,21 @@ 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 开关 + 测距串口）
-        初始化完成后主动发送关闭命令，防止 UART 初始化噪声误触发激光
+        初始化时先将 A14 拉高关闭激光，防止开机误触发
         
         Args:
             serial_device: 串口设备路径，默认使用 config.DISTANCE_SERIAL_DEVICE
@@ -82,23 +94,11 @@ 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):
@@ -147,66 +147,38 @@ class LaserManager:
             return False
     
     def turn_on_laser(self):
-        """发送指令开启激光，并读取回包（部分模块支持）"""
+        """A14 输出低电平，开启激光。"""
-        if self._serial is None:
+        if self._laser_gpio is None:
-            self.logger.error("[LASER] 激光串口未初始化，请先调用 init()")
+            if self.logger:
-            return None
+                self.logger.error("[LASER] A14 GPIO 未初始化，请先调用 init()")
-        
+            return False
-        # 打印调试信息
-        self.logger.info(f"[LASER] 发送开启命令: {config.LASER_ON_CMD.hex()}")
-        
-        # 清空接收缓冲区
         try:
-            self._serial.read(-1)  # 清空缓冲区
+            self._laser_gpio.value(config.LASER_CONTROL_ON_LEVEL)
-        except:
+            self._laser_turned_on = True
-            pass
+            if self.logger:
-        
+                self.logger.info("[LASER] A14=LOW，激光开启")
-        # 发送命令
+            return True
-        written = self._serial.write(config.LASER_ON_CMD)
+        except Exception as e:
-        self.logger.info(f"[LASER] 写入字节数: {written}")
+            if self.logger:
-        
+                self.logger.error(f"[LASER] A14 开启激光失败: {e}")
-        time.sleep_ms(60)
+            return False
-
-        # 读取回包
-        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._serial is None:
+        if self._laser_gpio is None:
-            self.logger.error("[LASER] 激光串口未初始化，请先调用 init()")
+            if self.logger:
-            return None
+                self.logger.error("[LASER] A14 GPIO 未初始化，请先调用 init()")
-        
+            return False
-        # 打印调试信息
-        self.logger.info(f"[LASER] 发送关闭命令: {config.LASER_OFF_CMD.hex()}")
-        
-        # 清空接收缓冲区
         try:
-            self._serial.read(-1)
+            self._laser_gpio.value(config.LASER_CONTROL_OFF_LEVEL)
-        except:
+            self._laser_turned_on = False
-            pass
+            if self.logger:
-        
+                self.logger.info("[LASER] A14=HIGH，激光关闭")
-        # 发送命令
+            return True
-        written = self._serial.write(config.LASER_OFF_CMD)
+        except Exception as e:
-        self.logger.info(f"[LASER] 写入字节数: {written}")
+            if self.logger:
-
+                self.logger.error(f"[LASER] A14 关闭激光失败: {e}")
-        time.sleep_ms(60)
+            return False
-        
-        # 读取回包
-        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):
         """闪一下激光（非阻塞版本）"""

main.py

@@ -13,7 +13,9 @@ from maix import camera, display, image, app, time, uart, pinmap, i2c
 from maix.peripheral import adc
 import _thread
 import os
+import sys
 import json
+import shutil
 import time as wall_time
 
 # 导入新模块
@@ -76,12 +78,14 @@ 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:
@@ -103,6 +107,8 @@ 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()
@@ -122,7 +128,7 @@ def cmd_str():
 
     # 1. 初始化日志系统（WARNING级别，不打印/写入INFO和DEBUG日志，提高执行流畅度）
     import logging
-    logger_manager.init_logging(log_level=logging.WARNING)
+    logger_manager.init_logging(log_level=logging.DEBUG)
     logger = logger_manager.logger
 
     # 补充：因为初始化的时候，激光会亮，先关了它
@@ -132,6 +138,7 @@ def cmd_str():
     sync_system_time_from_4g()
 
     # 2.1 WiFi 热点配网兜底：仅当 STA 与 4G 均不可用时起 AP + HTTP；提交后删 /boot/wifi.ap、建 wifi.sta 并 reboot
+    _ota_pending_path = f"{config.APP_DIR}/ota_pending.json"
     try:
         from wifi_config_httpd import maybe_start_wifi_ap_fallback
 
@@ -249,6 +256,55 @@ def cmd_str():
     # 4. 初始化设备ID（network_manager 内部会自动设置 device_id 和 password）
     network_manager.read_device_id()
 
+    # 4.1 检查是否有 OTA 待更新文件（从临时目录移动到实际目录）
+    staging_dir = f"{config.APP_DIR}/ota_staging"
+    if os.path.exists(staging_dir):
+        try:
+            moved_count = 0
+            for root, dirs, files in os.walk(staging_dir):
+                for f in files:
+                    src = os.path.join(root, f)
+                    rel = os.path.relpath(src, staging_dir)
+                    dest = os.path.join(config.APP_DIR, rel)
+                    dest_dir = os.path.dirname(dest)
+                    if dest_dir:
+                        try:
+                            os.makedirs(dest_dir, exist_ok=True)
+                        except:
+                            pass
+                    try:
+                        shutil.copy2(src, dest)
+                        moved_count += 1
+                    except Exception as e:
+                        if logger:
+                            logger.error(f"[OTA] 移动文件失败 {rel}: {e}")
+            # 删除临时目录
+            try:
+                shutil.rmtree(staging_dir, ignore_errors=True)
+            except:
+                pass
+            if logger:
+                logger.info(f"[OTA] 已从临时目录更新 {moved_count} 个文件，重启应用...")
+            # 清理硬件资源，然后重启应用
+            try:
+                laser_manager.turn_off_laser()
+            except:
+                pass
+            try:
+                camera_manager.release()
+            except:
+                pass
+            try:
+                os.sync()
+            except:
+                pass
+            import sys
+            os.execv(sys.executable, [sys.executable, os.path.join(config.APP_DIR, "main.py")])
+            return
+        except Exception as e:
+            if logger:
+                logger.error(f"[OTA] 处理临时目录失败: {e}")
+
     # 5. 创建照片存储目录（如果启用图像保存或检测失败时强制保存）
     if config.SAVE_IMAGE_ENABLED or getattr(config, "SAVE_IMAGE_ON_FAILURE", False):
         photo_dir = config.PHOTO_DIR
@@ -282,12 +338,14 @@ def cmd_str():
         logger.info("系统准备完成...")
 
     last_adc_trigger = 0
+    trigger_adc_val = 0  # 触发时的气压值，气压需降回此值以下才能再次触发
     # 读取一次ADC初始值，防止开机时传感器已有压力导致误触发
+    enable_check = True
+    _should_reboot = False
     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
 
@@ -339,6 +397,14 @@ def cmd_str():
                 time.sleep_ms(250)
                 continue
 
+            # OTA 完成后需要重启，从主循环退出（由启动时 staging 检测处理重启）
+            if network_manager.ota_restart_pending:
+                network_manager.ota_restart_pending = False
+                _should_reboot = True
+                if logger:
+                    logger.info("[MAIN] OTA重启标志已设置，退出主循环...")
+                break
+
             # 不在 OTA 状态下，检测是否空闲足够长，自动关机
             # print(f"[MAIN] 空闲时间: {hardware_manager.get_idle_time_in_sec() }秒")
             # print(f"配置关机时间：{config.AUTO_POWER_OFF_IN_SECONDS} 秒")
@@ -377,22 +443,16 @@ def cmd_str():
                 pressure_max = adc_val
             if len(pressure_buf) >= PRESSURE_BATCH_SIZE:
                 _flush_pressure_buf("batch")
-            # 峰值检测：压力从峰值下降时触发，确保捕获到最大冲击时刻
+            # 突变增量检测：压力增量大于300时触发
-            if adc_val > peak_adc_val:
+            # 触发后需等气压降到触发值以下才重新检测增量
-                peak_adc_val = adc_val  # 更新峰值
+            if adc_val < trigger_adc_val :
-            if (peak_adc_val >= config.ADC_TRIGGER_THRESHOLD
+                enable_check = True
-                    and adc_val < peak_adc_val
+            if (adc_val - last_adc_val) > 200 and enable_check:
-                    and last_adc_val >= peak_adc_val):
-                # 封顶后下降沿触发：peak是最大值，当前值开始下降，且上次值还在peak位置
                 hardware_manager.start_idle_timer()  # 重新计时
-                diff_ms = current_time - last_adc_trigger
-                if diff_ms < 3000:
-                    peak_adc_val = 0  # 去抖期间重置峰值
-                    time.sleep_ms(5)
-                    continue
                 last_adc_trigger = current_time
-                peak_adc_val = 0  # 触发后重置峰值
+                trigger_adc_val = adc_val  # 记录触发时的气压值
-                # 触发前先把缓存刷出来，避免波形被长耗时处理截断
+                last_adc_val = adc_val  # 更新基准值，防止连续增量误触发
+                enable_check = False
                 _flush_pressure_buf("before_trigger")
 
                 try:
@@ -411,7 +471,7 @@ def cmd_str():
                         camera_manager.show(camera_manager.read_frame())
                     except Exception as e:
                         pass
-                time.sleep_ms(5)
+                time.sleep_ms(1)
             last_adc_val = adc_val
 
         except Exception as e:
@@ -430,10 +490,62 @@ def cmd_str():
                 _flush_pressure_buf("exception")
             except:
                 pass
-            time.sleep_ms(1000)  # 等待1秒后继续
+            time.sleep_ms(1000)  # 等待1秒后 continue
-
-
 
+    # 主循环退出后，如果是由 OTA 触发的，移动 staging 文件并重启应用
+    if _should_reboot:
+        staging_dir = f"{config.APP_DIR}/ota_staging"
+        if os.path.exists(staging_dir):
+            try:
+                moved_count = 0
+                for root, dirs, files in os.walk(staging_dir):
+                    for f in files:
+                        src = os.path.join(root, f)
+                        rel = os.path.relpath(src, staging_dir)
+                        dest = os.path.join(config.APP_DIR, rel)
+                        dest_dir = os.path.dirname(dest)
+                        if dest_dir:
+                            try:
+                                os.makedirs(dest_dir, exist_ok=True)
+                            except:
+                                pass
+                        try:
+                            shutil.copy2(src, dest)
+                            moved_count += 1
+                        except Exception as e:
+                            if logger:
+                                logger.error(f"[OTA] 移动文件失败 {rel}: {e}")
+                try:
+                    shutil.rmtree(staging_dir, ignore_errors=True)
+                except:
+                    pass
+                if logger:
+                    logger.info(f"[MAIN] OTA 更新完成，已应用 {moved_count} 个文件，重启应用...")
+            except Exception as e:
+                if logger:
+                    logger.error(f"[OTA] 处理 staging 目录失败: {e}")
+        else:
+            if logger:
+                logger.info("[MAIN] OTA 更新完成，重启应用...")
+        # 清理硬件资源，然后重启应用（不重启设备）
+        try:
+            laser_manager.turn_off_laser()
+        except:
+            pass
+        try:
+            camera_manager.release()
+        except:
+            pass
+        try:
+            hardware_manager.stop_idle_timer()
+        except:
+            pass
+        try:
+            os.sync()
+        except:
+            pass
+        import sys
+        os.execv(sys.executable, [sys.executable, os.path.join(config.APP_DIR, "main.py")])
 
 
 # 主程序入口

model_270139.mud

@@ -1,13 +0,0 @@
-
-[basic]
-type = cvimodel
-model = model_270139.cvimodel
-
-[extra]
-model_type = yolov5
-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 = 黑三角和圆环
-

model_270820.mud

@@ -1,13 +0,0 @@
-
-[basic]
-type = cvimodel
-model = model_270820.cvimodel
-
-[extra]
-model_type = yolov5
-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 = triangle
-

network.py

@@ -13,6 +13,7 @@ import hmac
 import hashlib
 import ujson
 import os
+import sys
 import threading
 import socket
 import config
@@ -21,7 +22,13 @@ from hardware import hardware_manager
 from power import get_bus_voltage, voltage_to_percent, is_charging
 from logger_manager import logger_manager
 from wifi import wifi_manager
-import subprocess
+
+# protobuf 支持（纯 proto 协议，必须可用）
+try:
+    import tcp_messages_pb2 as pb
+except ImportError:
+    print("[NET] tcp_messages_pb2 not found, protobuf disabled")
+    raise
 
 
 def _wifi_tls_would_block(exc):
@@ -69,9 +76,18 @@ class NetworkManager:
         self._uart4g_lock = threading.Lock()
         self._device_id = None
         self._password = None
-        self._raw_line_data = []
+
         self._manual_trigger_flag = False
 
+        # OTA 防重复：上次 OTA 完成时间戳，30秒内不重复 OTA
+        self._last_ota_time = 0
+        self._ota_cooldown_sec = 30
+
+        # OTA 重启标志：OTA线程设置，主循环检测到后从主循环退出再重启
+        self.ota_restart_pending = False
+
+        # protobuf 协议（纯 proto，无 JSON 兼容）
+
         # 限制并发命令线程数
         self._cmd_thread_lock = threading.Lock()
         self._cmd_thread_count = 0
@@ -190,13 +206,7 @@ class NetworkManager:
                 return self._normal_send_queue.pop(0)
             return None
 
-    def _set_raw_line_data(self, data):
-        """设置原始行数据（内部方法）"""
-        self._raw_line_data = data
 
-    def _get_raw_line_data(self):
-        """获取原始行数据（内部方法）"""
-        return self._raw_line_data
 
     def get_uart_lock(self):
         """获取UART锁（用于with语句）"""
@@ -615,53 +625,113 @@ class NetworkManager:
         except Exception as e:
             self.logger.error(f"[LASER] cmd200 检测异常: {e}")
 
+    def _cmd5_ota(self, ota_url):
+        """后台线程执行 cmd5 OTA"""
+        hardware_manager.start_idle_timer()
+        self.logger.info(f"[Ota] cmd5 开始OTA: {ota_url}")
+        self.safe_enqueue({"result": "ota start..."}, 2)
+
+        try:
+            from ota_manager import ota_manager
+            ok, msg = ota_manager.perform_ota(ota_url)
+            if ok:
+                self.safe_enqueue({"result": "success"}, 2)
+                time.sleep_ms(500)
+                os.execv(sys.executable, [sys.executable, os.path.join(config.APP_DIR, "main.py")])
+            else:
+                self.logger.error(f"[ota] cmd5 失败: {msg}")
+                self.safe_enqueue({"result": "ota fail", "reason": msg}, 2)
+        except Exception as e:
+            self.logger.error(f"[ota] cmd5 异常: {e}")
+            self.safe_enqueue({"result": "ota fail", "reason": str(e)}, 2)
+
     def _cmd300_ota(self, data_obj):
-        """后台线程执行 cmd300 OTA，避免阻塞主循环"""
+        """后台线程执行 cmd300 OTA，避免阻塞主循环
+        流程：检查WiFi → 下载ZIP → 解压覆盖项目 → 重启程序
+        """
         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"):
+        if not ota_res_url:
+            self.logger.error("[ota] cmd300 缺少 url 参数")
+            self.safe_enqueue({"cmd": 300, "result": "ota fail", "reason": "missing url"}, 2)
+            return
+
+        # OTA 冷却期检查：防止服务器重复下发导致无限 OTA 循环
+        now = time.time()
+        if self._last_ota_time > 0:
+            elapsed = int(now - self._last_ota_time)
+            if elapsed < self._ota_cooldown_sec:
+                remaining = self._ota_cooldown_sec - elapsed
+                self.logger.warning(f"[ota] cmd300 冷却期内，跳过 (剩余 {remaining}s)")
                 try:
-                    os.remove(_f)
+                    pkt = self._make_send_packet(2, {"cmd": 300, "result": "ota skip", "reason": f"cooldown {remaining}s"})
-                except OSError:
+                    self.tcp_send_raw(pkt)
+                except Exception:
                     pass
-            w = network.wifi.Wifi()
+                return
-            e = w.connect(ssid, password, wait=True, timeout=15)
+
-            err.check_raise(e, "connect wifi failed")
+        if not wifi_manager.is_wifi_connected():
-            if self.logger:
+            self.logger.warning("[ota] cmd300 当前未连接WiFi，拒绝OTA")
-                self.logger.info(f"[ota] Connect success, got ip{w.get_ip()}")
+            self.safe_enqueue({"cmd": 300, "result": "ota fail", "reason": "wifi not connected"}, 2)
-            self.safe_enqueue(
+            return
-                {
+
+        self.logger.info(f"[ota] WiFi已连接，开始OTA: {ota_res_url}")
+        self.safe_enqueue({"cmd": 300, "result": "ota start..."}, 2)
+
+        def _ota_progress(phase, progress):
+            """OTA进度回调，通过tcp_send_raw直接发送（绕过被暂停的发送队列）"""
+            try:
+                if not self._tcp_connected:
+                    self.logger.warning(f"[ota] 进度发送跳过: tcp未连接 phase={phase} progress={progress}")
+                    return
+                pkt = self._make_send_packet(2, {
                     "cmd": 300,
-                    "result": "ota start...",
+                    "result": f"ota {phase}",
-                    "wifi": w.get_ip(),
+                    "progress": progress,
-                },
+                    "phase": phase,
-                2,
+                })
-            )
+                ok = self.tcp_send_raw(pkt)
-            subprocess.run(
+                if not ok:
-                ["sh", "/maixapp/apps/t11/ota_curl.sh", ota_res_url])
+                    self.logger.warning(f"[ota] 进度发送失败: phase={phase} progress={progress}")
-            self.safe_enqueue(
+            except Exception as e:
-                {
+                self.logger.error(f"[ota] 发送进度异常: {e}")
-                    "cmd": 300,
+
-                    "result": "success",
+        try:
-                    "wifi": w.get_ip(),
+            from ota_manager import ota_manager
-                },
+            ok, msg = ota_manager.perform_ota(ota_res_url, progress_callback=_ota_progress)
-                2,
+            self._last_ota_time = time.time()
-            )
+            if ok:
+                self.logger.info("[ota] OTA成功，准备重启程序...")
+                # 直接通过tcp发送success，不走发送队列（主循环可能未drain）
+                try:
+                    pkt = self._make_send_packet(2, {"cmd": 300, "result": "success", "progress": 51, "phase": "rebooting"})
+                    ok_send = self.tcp_send_raw(pkt)
+                    self.logger.info(f"[ota] success包发送结果: {ok_send}, tcp_connected={self._tcp_connected}")
+                except Exception as e:
+                    self.logger.error(f"[ota] 发送success失败: {e}")
+                # 设置重启标志，由主循环检测到后从主循环退出再重启
+                # （后台线程调 os.execv 会导致 ISP 线程残留，新进程摄像头初始化失败）
+                self.logger.info("[ota] 设置重启标志，等待主循环退出...")
+                self.ota_restart_pending = True
+            else:
+                self.logger.error(f"[ota] cmd300 失败: {msg}")
+                self._last_ota_time = time.time()
+                try:
+                    pkt = self._make_send_packet(2, {"cmd": 300, "result": "ota fail", "reason": msg})
+                    self.tcp_send_raw(pkt)
+                except Exception as e:
+                    self.logger.error(f"[ota] 发送失败结果异常: {e}")
         except Exception as e:
-            self.logger.error(f"[ota] cmd300 失败: {e}")
+            self.logger.error(f"[ota] cmd300 异常: {e}")
-            self.safe_enqueue(
+            self._last_ota_time = time.time()
-                {
+            try:
-                    "cmd": 300,
+                pkt = self._make_send_packet(2, {"cmd": 300, "result": "ota fail", "reason": str(e)})
-                    "result": "ota fail",
+                self.tcp_send_raw(pkt)
-                    "reason": str(e),
+            except Exception as ex:
-                },
+                self.logger.error(f"[ota] 发送失败结果异常: {ex}")
-                2,
-            )
 
     def _cmd600_conn_wifi(self, data_obj):
         hardware_manager.start_idle_timer()
@@ -669,6 +739,7 @@ class NetworkManager:
         self.logger.info(f"[conn wifi] cmd600 , data: {inner_data}")
         ssid = inner_data.get("ssid")
         password = inner_data.get("password")
+        prev_network_type = self._network_type
         # 停止旧的WiFi质量监测（无论当前是WiFi还是4G连接）
         self._stop_wifi_quality_monitor()
         try:
@@ -678,18 +749,10 @@ class NetworkManager:
                 except OSError:
                     pass
             w = network.wifi.Wifi()
-            e = w.connect(ssid, password, wait=True, timeout=15)
+            e = w.connect(ssid, password, wait=True, timeout=5)
             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
@@ -697,20 +760,186 @@ class NetworkManager:
             self.logger.info("[conn wifi] WiFi已连接，等待主循环重新登录")
         except Exception as e:
             self.logger.error(f"cmd600 失败: {e}")
-            self.safe_enqueue(
+            # 同步发送失败结果（旧连接仍存活时直接发送）
-                {
+            if prev_network_type == "4g":
-                    "cmd": 600,
+                pkt = self._make_send_packet(2, {"cmd": 600, "result": "conn fail", "reason": str(e)})
-                    "result": "conn fail",
+                self.tcp_send_raw(pkt)
-                    "reason": str(e),
+            else:
-                },
+                self.safe_enqueue(
-                2,
+                    {
-            )
+                        "cmd": 600,
-            self._switch_to_4g_due_to_poor_wifi()
+                        "result": "conn fail",
+                        "reason": str(e),
+                    },
+                    2,
+                )
+            # 当前是4G在线，旧连接未断，无需切换；当前是WiFi，旧WiFi已被w.connect()断开，需回退4G
+            if prev_network_type == "wifi":
+                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 _make_send_packet(self, msg_type, data_dict):
+        """使用 protobuf 构造发送数据包"""
+        return self._make_proto_packet(msg_type, data_dict)
+
+    def _build_logic_body(self, cmd, data_dict):
+        """根据 cmd 构造对应的 LogicBody oneof payload"""
+        d = data_dict.get("data", data_dict) if isinstance(data_dict.get("data"), dict) else data_dict
+
+        if cmd == 1:
+            return pb.LogicBody(
+                cmd=cmd,
+                shoot_data=pb.ShootData(
+                    shot_id=d.get("shot_id", ""),
+                    x=d.get("x", 0.0),
+                    y=d.get("y", 0.0),
+                    r=d.get("r", 0.0),
+                    d=d.get("d", 0.0),
+                    adc=d.get("adc", 0.0),
+                    target_class=str(d.get("target_class", "")),
+                    target_class_confidence=d.get("target_class_confidence", 0.0),
+                    d_laser=d.get("d_laser", 0.0),
+                    d_laser_quality=d.get("d_laser_quality", 0.0),
+                    m=d.get("m", ""),
+                    laser_method=d.get("laser_method", ""),
+                    target_x=d.get("target_x", 0.0),
+                    target_y=d.get("target_y", 0.0),
+                    offset_method=d.get("offset_method", ""),
+                    distance_method=d.get("distance_method", ""),
+                )
+            )
+        elif cmd == 4:
+            return pb.LogicBody(
+                cmd=cmd,
+                battery_report=pb.BatteryReport(
+                    battery=d.get("battery", 0.0),
+                    voltage=d.get("voltage", 0.0),
+                    net_type=d.get("netType", ""),
+                    charging=d.get("charging", False),
+                )
+            )
+        elif cmd == 200:
+            return pb.LogicBody(
+                cmd=cmd,
+                center_point_result=pb.CenterPointResult(
+                    result=d.get("result", ""),
+                    x=d.get("x", 0.0),
+                    y=d.get("y", 0.0),
+                )
+            )
+        elif cmd == 201:
+            return pb.LogicBody(
+                cmd=cmd,
+                center_point_set=pb.CenterPointSet(
+                    x=d.get("x", 0.0),
+                    y=d.get("y", 0.0),
+                )
+            )
+
+        elif cmd == 300:
+            return pb.LogicBody(
+                cmd=cmd,
+                ota_result=pb.OtaResult(
+                    result=d.get("result", ""),
+                    url=d.get("wifi", ""),
+                    progress=d.get("progress", 0),
+                    phase=d.get("phase", ""),
+                )
+            )
+        elif cmd == 700:
+            return pb.LogicBody(
+                cmd=cmd,
+                charging_report=pb.ChargingReport(),
+            )
+        else:
+            result_str = d.get("result", "")
+            if isinstance(result_str, dict):
+                import ujson
+                result_str = ujson.dumps(result_str)
+            elif not isinstance(result_str, str):
+                result_str = str(result_str)
+            return pb.LogicBody(
+                cmd=cmd,
+                generic_result=pb.GenericResult(result=result_str),
+            )
+
+    def _make_proto_packet(self, msg_type, data_dict):
+        """使用 protobuf 序列化构造数据包"""
+        if msg_type == 1:
+            msg = pb.LoginRequest(
+                device_id=data_dict.get("deviceId", ""),
+                password=data_dict.get("password", ""),
+                if_admin=data_dict.get("ifAdmin", False),
+                version=data_dict.get("version", ""),
+                vol=data_dict.get("vol", 0),
+                vol_per=data_dict.get("vol_per", 0),
+                iccid=data_dict.get("iccid", ""),
+            )
+        elif msg_type == 4:
+            msg = pb.Heartbeat(
+                t=data_dict.get("t", 0),
+                vol=data_dict.get("vol", 0),
+                vol_per=data_dict.get("vol_per", 0),
+            )
+        elif msg_type == 2:
+            cmd = data_dict.get("cmd", 0)
+            msg = self._build_logic_body(cmd, data_dict)
+        else:
+            return b""
+
+        body_bytes = msg.SerializeToString()
+        return self._netcore.make_packet_pb(msg_type, body_bytes)
+
+    def _parse_recv(self, payload):
+        """解析接收的数据包，返回 (msg_type, body_dict)"""
+        msg_type, body_bytes = self._netcore.parse_packet_raw(payload)
+        if msg_type is None:
+            return None, None
+        try:
+            body_dict = self._parse_proto_body(msg_type, body_bytes)
+            return msg_type, body_dict
+        except Exception as e:
+            self.logger.error(f"[NET] protobuf 反序列化失败: {e}")
+            return None, None
+
+    def _parse_proto_body(self, msg_type, body_bytes):
+        """将 protobuf body bytes 反序列化为 dict"""
+        if msg_type == 1:
+            msg = pb.LoginResponse()
+            msg.ParseFromString(body_bytes)
+            return {"cmd": msg.code, "data": msg.msg}
+        elif msg_type == 4:
+            return {}
+        elif msg_type == 2:
+            msg = pb.LogicBody()
+            msg.ParseFromString(body_bytes)
+            result = {"cmd": msg.cmd}
+            payload_name = msg.WhichOneof('payload')
+            if payload_name:
+                payload_msg = getattr(msg, payload_name)
+                data = {}
+                for field in payload_msg.DESCRIPTOR.fields:
+                    val = getattr(payload_msg, field.name)
+                    if isinstance(val, bytes):
+                        val = val.hex()
+                    data[field.name] = val
+                result["data"] = data
+            return result
+
+        elif msg_type == 100:
+            msg = pb.ImageUploadCommand()
+            msg.ParseFromString(body_bytes)
+            return {"uploadUrl": msg.upload_url, "token": msg.token, "shootId": msg.shoot_id, "outlink": msg.outlink}
+        elif msg_type == 101:
+            msg = pb.LogUploadCommand()
+            msg.ParseFromString(body_bytes)
+            return {"uploadUrl": msg.upload_url, "token": msg.token, "key": msg.key, "outlink": msg.outlink, "archive": msg.archive}
+        else:
+            return {"raw": body_bytes.hex()}
+
     def connect_server(self):
         """
         连接到服务器（自动选择WiFi或4G）
@@ -1833,6 +2062,11 @@ class NetworkManager:
                     time.sleep_ms(200)
                     continue
 
+                # OTA 完成后需要重启，从主循环退出（由 main.py 执行重启）
+                if self.ota_restart_pending:
+                    self.logger.info("[ota] 主循环退出，准备重启...")
+                    break
+
                 if not self.connect_server():
                     time.sleep_ms(1000)
                     continue
@@ -1848,8 +2082,7 @@ class NetworkManager:
                 }
                 iccid_pending_marker = self._maybe_add_iccid_to_login(login_data)
                 print(f"login_data: {login_data}")
-                # if not self.tcp_send_raw(self.make_packet(1, login_data)):
+                if not self.tcp_send_raw(self._make_send_packet(1, login_data)):
-                if not self.tcp_send_raw(self._netcore.make_packet(1, login_data)):
                     self._tcp_connected = False
                     try:
                         self.disconnect_server()
@@ -1880,6 +2113,10 @@ class NetworkManager:
                         time.sleep_ms(200)
                         continue
 
+                    # OTA 完成后需要重启，跳出内层循环
+                    if self.ota_restart_pending:
+                        break
+
                     # 接收数据（根据网络类型选择接收方式）
                     # WiFi 粘包：一次 recv 可能含多条完整包；也可能缓冲里已有完整包但本轮 recv 超时为空
                     rx_items = []
@@ -1926,11 +2163,11 @@ class NetworkManager:
                                     pass
 
                             # msg_type, body = self.parse_packet(payload)
-                            msg_type, body = self._netcore.parse_packet(payload)
+                            msg_type, body = self._parse_recv(payload)
 
                             # 处理登录响应
                             if not logged_in and msg_type == 1:
-                                if body and body.get("cmd") == 1 and body.get("data") == "登录成功":
+                                if body and body.get("cmd") == 0 and body.get("data") == "登录成功":
                                     logged_in = True
                                     last_heartbeat_ack_time = time.ticks_ms()
                                     self.logger.info("登录成功")
@@ -1961,32 +2198,7 @@ class NetworkManager:
                                 last_heartbeat_ack_time = time.ticks_ms()
                                 self.logger.debug("✅ 收到心跳确认")
 
-                            # 处理命令40（分片下载）
+
-                            elif logged_in and msg_type == 40:
-                                if isinstance(body, dict):
-                                    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):
-                                        self._raw_line_data.clear()
-                                    # 或者更简单：每次收到命令40时，如果版本号不同，清空缓存
-                                    if len(self._raw_line_data) > 0:
-                                        first_v = self._raw_line_data[0].get('v')
-                                        if first_v and first_v != v:
-                                            self._raw_line_data.clear()
-                                    self._raw_line_data.append(body)
-                                    if len(self._raw_line_data) >= int(t):
-                                        self.logger.info(f"下载完成")
-                                        from ota_manager import ota_manager
-                                        stock_array = list(map(lambda x: x.get('d'), self._raw_line_data))
-                                        local_filename = config.LOCAL_FILENAME
-                                        with open(local_filename, 'w', encoding='utf-8') as file:
-                                            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.logger.info(f"已下载{len(self._raw_line_data)} 全部：{t} 版本：{v}")
 
                             elif logged_in and msg_type == 100:
                                 self.logger.info(f"[IMAGE_UPLOAD] 收到图片上传命令 {body}")
@@ -2079,215 +2291,151 @@ class NetworkManager:
                                         )
                                         # 立即返回已入队确认
                                         self.safe_enqueue({"result": "log_upload_queued"}, 2)
-                            elif logged_in and msg_type == 201:
+                            # 处理业务指令（纯 proto: cmd 在 body 顶层）
-                                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
+                                cmd = body.get("cmd")
-                                data_obj = body.get("data")
+                                data_obj = body.get("data") or {}
-                                if isinstance(data_obj, dict):
+                                if cmd == 2:  # AimRequest 开启激光并校准
-                                    inner_cmd = data_obj.get("cmd")
+                                    from laser_manager import laser_manager
-                                    if inner_cmd == 2:  # 开启激光并校准
+                                    if not laser_manager.calibration_active:
-                                        from laser_manager import laser_manager
+                                        laser_manager.turn_on_laser()
-                                        if not laser_manager.calibration_active:
+                                        time.sleep_ms(100)
-                                            laser_manager.turn_on_laser()
+                                        hardware_manager.stop_idle_timer()
-                                            time.sleep_ms(100)
+                                        if not config.HARDCODE_LASER_POINT:
-                                            hardware_manager.stop_idle_timer()  # 停表
+                                            laser_manager.start_calibration()
-                                            if not config.HARDCODE_LASER_POINT:
+                                            self.safe_enqueue({"result": "calibrating"}, 2)
-                                                laser_manager.start_calibration()
-                                                self.safe_enqueue({"result": "calibrating"}, 2)
-                                            else:
-                                                # 写死的逻辑，不需要校准激光点
-                                                self.safe_enqueue({"result": "laser pos set by hard code"}, 2)
-                                    elif inner_cmd == 3:  # 关闭激光
-                                        from laser_manager import laser_manager
-                                        laser_manager.turn_off_laser()
-                                        laser_manager.stop_calibration()
-                                        hardware_manager.start_idle_timer()  # 开表
-                                        self.safe_enqueue({"result": "laser_off"}, 2)
-                                    elif inner_cmd == 4:  # 上报电量
-                                        voltage = get_bus_voltage()
-                                        battery_percent = voltage_to_percent(voltage)
-                                        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 is_charging():
-                                            self.safe_enqueue(
-                                                {
-                                                    "cmd": 700,
-                                                },
-                                                2,
-                                            )
-                                    elif inner_cmd == 700:
-                                        self.logger.warning("服务器下发关机！！！")
-                                        exit(-1)
-                                    elif inner_cmd == 5:  # OTA 升级
-                                        inner_data = data_obj.get("data", {}) if isinstance(data_obj, dict) else {}
-                                        ssid = inner_data.get("ssid")
-                                        password = inner_data.get("password")
-                                        ota_url = inner_data.get("url")
-                                        mode = (inner_data.get("mode") or "").strip().lower()
-
-                                        if not ota_url:
-                                            self.logger.error("ota missing_url")
-                                            self.safe_enqueue({"result": "missing_url"}, 2)
-                                            _rx_skip_tcp_iteration = True
-                                            break
-
-                                        from ota_manager import ota_manager
-                                        if ota_manager.update_thread_started:
-                                            self.safe_enqueue({"result": "update_already_started"}, 2)
-                                            _rx_skip_tcp_iteration = True
-                                            break
-
-                                        # 自动判断模式：如果没有明确指定，根据WiFi连接状态和凭证决定
-                                        if mode not in ("4g", "wifi"):
-                                            self.logger.info("ota missing mode, auto-detecting...")
-                                            # 若本次会话已锁定 4G，则 OTA 自动也走 4G，避免后续回切导致体验不一致
-                                            if self._session_force_4g:
-                                                mode = "4g"
-                                                self.logger.info("ota auto-selected: 4g (session locked on 4g)")
-                                            else:
-                                                # 只有同时满足：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)")
-                                                else:
-                                                    mode = "4g"
-                                                    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,))
-                                        else:  # mode == "wifi"
-                                            if not ssid or not password:
-                                                self.logger.error("ota wifi mode requires ssid and password")
-                                                self.safe_enqueue({"result": "missing_ssid_or_password"}, 2)
-                                            else:
-                                                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))
-                                    elif inner_cmd == 6:
-                                        try:
-                                            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"
-                                        self.safe_enqueue({"result": "current_ip", "ip": ip}, 2)
-                                    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)
-                                    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)
-                                    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()  # 重新计时
-                                    elif inner_cmd == 42:  # 关机命令
-                                        self.logger.info("[SHUTDOWN] 收到TCP关机命令，准备关机...")
-                                        self.safe_enqueue({"result": "shutdown_ack"}, 2)
-                                        time.sleep_ms(1000)
-                                        self.disconnect_server()
-                                        # 尝试关闭4G模块
-                                        try:
-                                            with self.get_uart_lock():
-                                                hardware_manager.at_client.send("AT+CFUN=0", "OK", 5000)
-                                        except:
-                                            pass
-                                        time.sleep_ms(2000)
-                                        os.system("sync")  # 刷新文件系统缓存到磁盘，防止数据丢失
-                                        time.sleep_ms(500)
-                                        # os.system("poweroff")
-                                        hardware_manager.power_off()
-                                        return
-                                    elif inner_cmd == 43:  # 上传日志命令
-                                        # 格式: {"cmd":43, "data":{"ssid":"xxx","password":"xxx","url":"xxx", ...}}
-                                        inner_data = data_obj.get("data", {})
-                                        upload_url = inner_data.get("url")
-                                        wifi_ssid = inner_data.get("ssid")
-                                        wifi_password = inner_data.get("password")
-                                        include_rotated = inner_data.get("include_rotated", True)
-                                        max_files = inner_data.get("max_files")
-                                        archive_format = inner_data.get("archive", "tgz")  # tgz 或 zip
-
-                                        hardware_manager.start_idle_timer()  # 重新计时
-
-                                        if not upload_url:
-                                            self.logger.error("[LOG_UPLOAD] 缺少 url 参数")
-                                            self.safe_enqueue({"result": "log_upload_failed", "reason": "missing_url"},
-                                                              2)
                                         else:
-                                            self.logger.info(f"[LOG_UPLOAD] 收到日志上传命令，目标URL: {upload_url}")
+                                            self.safe_enqueue({"result": "laser pos set by hard code"}, 2)
-                                        # 在新线程中执行上传，避免阻塞主循环
+                                elif cmd == 3:  # CloseAimRequest 关闭激光
+                                    from laser_manager import laser_manager
+                                    laser_manager.turn_off_laser()
+                                    laser_manager.stop_calibration()
+                                    hardware_manager.start_idle_timer()
+                                    self.safe_enqueue({"result": "laser_off"}, 2)
+                                elif cmd == 4:  # GetBatteryRequest 上报电量
+                                    voltage = get_bus_voltage()
+                                    battery_percent = voltage_to_percent(voltage)
+                                    charging = is_charging()
+                                    self.safe_enqueue({
+                                        "cmd": 4,
+                                        "battery": battery_percent,
+                                        "voltage": round(float(voltage), 3),
+                                        "netType": self.network_type,
+                                        "charging": charging,
+                                    }, 2)
+                                    self.logger.info(f"电量上报: {battery_percent}% 充电: {charging}")
+                                elif cmd == 700:
+                                    self.logger.warning("服务器下发关机！！！")
+                                    exit(-1)
+                                elif cmd == 5:  # OtaRequest OTA 升级
+                                    ota_url = data_obj.get("url", "")
+
+                                    if not ota_url:
+                                        self.logger.error("ota missing_url")
+                                        self.safe_enqueue({"result": "missing_url"}, 2)
+                                        _rx_skip_tcp_iteration = True
+                                        break
+
+                                    from ota_manager import ota_manager
+                                    if ota_manager.update_thread_started:
+                                        self.safe_enqueue({"result": "update_already_started"}, 2)
+                                        _rx_skip_tcp_iteration = True
+                                        break
+
+                                    if not wifi_manager.is_wifi_connected():
+                                        self.logger.warning("[ota] cmd5 当前未连接WiFi，拒绝OTA")
+                                        self.safe_enqueue({"result": "ota fail", "reason": "wifi not connected"}, 2)
+                                        _rx_skip_tcp_iteration = True
+                                        break
+
+                                    hardware_manager.stop_idle_timer()
+                                    self._spawn_cmd_thread(self._cmd5_ota, (ota_url,))
+                                elif cmd == 41:  # Ota4gSubCodeRequest 射箭触发
+                                    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()
+                                elif cmd == 42:  # ShutdownCommand 关机命令
+                                    self.logger.info("[SHUTDOWN] 收到TCP关机命令，准备关机...")
+                                    self.safe_enqueue({"result": "shutdown_ack"}, 2)
+                                    time.sleep_ms(1000)
+                                    self.disconnect_server()
+                                    try:
+                                        with self.get_uart_lock():
+                                            hardware_manager.at_client.send("AT+CFUN=0", "OK", 5000)
+                                    except:
+                                        pass
+                                    time.sleep_ms(2000)
+                                    os.system("sync")
+                                    time.sleep_ms(500)
+                                    hardware_manager.power_off()
+                                    return
+                                elif cmd == 44:  # 读 4G 本机号码
+                                    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)
+                                elif cmd == 45:  # 读 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)
+                                elif cmd == 43:  # 上传日志命令
+                                    upload_url = data_obj.get("url")
+                                    wifi_ssid = data_obj.get("ssid")
+                                    wifi_password = data_obj.get("password")
+                                    include_rotated = data_obj.get("include_rotated", True)
+                                    max_files = data_obj.get("max_files")
+                                    archive_format = data_obj.get("archive", "tgz")
+
+                                    hardware_manager.start_idle_timer()
+
+                                    if not upload_url:
+                                        self.logger.error("[LOG_UPLOAD] 缺少 url 参数")
+                                        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:
+                                elif cmd == 200:  # GenericResult "init_center_point" 触发激光检测
-                                        self.logger.info("[LASER] cmd200 在后台线程执行检测")
+                                    self.logger.info("[LASER] cmd200 在后台线程执行检测")
-                                        self._spawn_cmd_thread(self._cmd200_detect_laser, ())
+                                    self._spawn_cmd_thread(self._cmd200_detect_laser, ())
-                                    elif inner_cmd == 300:
+                                elif cmd == 201:  # SetCenterPointRequest 设置中心点
-                                        self.logger.info("[New Ota] cmd300 在后台线程执行OTA")
+                                    if self.logger:
-                                        self._spawn_cmd_thread(self._cmd300_ota, (data_obj,))
+                                        self.logger.info(f"[LASER] cmd201:{body}")
-                                    elif inner_cmd == 600:
+                                    raw_x = data_obj.get("x")
-                                        self.logger.info("[conn wifi] cmd600 在后台线程执行连接wifi: {data_obj}")
+                                    raw_y = data_obj.get("y")
-                                        self._spawn_cmd_thread(self._cmd600_conn_wifi, (data_obj,))
+                                    try:
-                                    elif inner_cmd == 601:
+                                        from laser_manager import laser_manager
-                                        pass
+                                        ix, iy = laser_manager.set_hardcoded_laser_point(raw_x, raw_y)
-                                else:  # data的结构不是 dict
+                                        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 cmd == 300:  # OtaRequest 新版OTA
+                                    self.logger.info("[New Ota] cmd300 在后台线程执行OTA")
+                                    self._spawn_cmd_thread(self._cmd300_ota, ({"data": data_obj},))
+                                elif cmd == 600:  # WifiConnectRequest 连接wifi
+                                    self.logger.info(f"[conn wifi] cmd600 在后台线程执行连接wifi: {data_obj}")
+                                    self._spawn_cmd_thread(self._cmd600_conn_wifi, ({"data": data_obj},))
+                                elif cmd == 601:
+                                    pass
+                                else:
                                     self.logger.info(f"[NET] body={body}, {time.time()}")
-                            else:
-                                self.logger.info(f"[NET] 未知数据 {body}, {time.time()}")
                         if _rx_login_fail:
                             break
                         if _rx_skip_tcp_iteration:
@@ -2310,7 +2458,7 @@ class NetworkManager:
 
                         if item:
                             msg_type, data_dict = item
-                            pkt = self._netcore.make_packet(msg_type, data_dict)
+                            pkt = self._make_send_packet(msg_type, data_dict)
                             if not self.tcp_send_raw(pkt):
                                 # 发送失败：将消息放回队首（队列满则丢弃）
                                 with self.get_queue_lock():
@@ -2339,8 +2487,8 @@ class NetworkManager:
                     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(
+                        heartbeat_pkt = self._make_send_packet(4, {"vol": vol_val, "vol_per": voltage_to_percent(vol_val)})
-                                self._netcore.make_packet(4, {"vol": vol_val, "vol_per": voltage_to_percent(vol_val)})):
+                        if not self.tcp_send_raw(heartbeat_pkt):
                             # 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
                             # 短暂波动可能导致一次发送失败：连续失败达到阈值才重连，避免重连风暴

official_pack_fip.py

@@ -0,0 +1,603 @@
+#!/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()

power.py

@@ -7,10 +7,12 @@
 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:
@@ -32,7 +34,11 @@ def write_register(reg, value):
     data = [(value >> 8) & 0xFF, value & 0xFF]
     # 某些底层驱动在失败时只打印 “write failed” 并返回 -1，而不是抛异常；
     # 为避免误判“初始化成功”导致后续 readfrom_mem SIGSEGV，这里把失败显式转成异常。
-    ret = hardware_manager.bus.writeto_mem(config.INA226_ADDR, reg, bytes(data))
+    _INA226_LOCK.acquire()
+    try:
+        ret = hardware_manager.bus.writeto_mem(config.INA226_ADDR, reg, bytes(data))
+    finally:
+        _INA226_LOCK.release()
     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}")
@@ -42,7 +48,11 @@ def write_register(reg, value):
 def read_register(reg):
     """读取INA226寄存器"""
     from hardware import hardware_manager
-    data = hardware_manager.bus.readfrom_mem(config.INA226_ADDR, reg, 2)
+    _INA226_LOCK.acquire()
+    try:
+        data = hardware_manager.bus.readfrom_mem(config.INA226_ADDR, reg, 2)
+    finally:
+        _INA226_LOCK.release()
     return (data[0] << 8) | data[1]
 
 

test/gpio_high.py

@@ -0,0 +1,27 @@
+"""Run independently and keep A24 at a high logic level."""
+
+from maix import app, gpio, pinmap, time
+
+
+PIN = "A17"
+GPIO_NAME = "GPIOA17"
+
+
+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_gpio_a14.py

@@ -0,0 +1,62 @@
+#!/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/wifi_gpio_ina_isolation.py

@@ -0,0 +1,122 @@
+#!/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

@@ -0,0 +1,88 @@
+#!/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())

version.py

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