1893 lines
66 KiB
Python
1893 lines
66 KiB
Python
# ====================================================================================
|
||
# K210 V11 (分时网络通信)
|
||
# 功能更新:
|
||
# - 继承V10所有功能
|
||
# - 【新功能】使用分时处理网络通信，每帧只做少量网络工作，避免长时间阻塞
|
||
# ====================================================================================
|
||
|
||
import sensor, image, lcd
|
||
import KPU as kpu
|
||
import time
|
||
from Maix import FPIOA, GPIO, utils
|
||
import gc
|
||
from fpioa_manager import fm
|
||
import utime
|
||
from machine import UART
|
||
import os
|
||
try:
|
||
import ubinascii
|
||
except:
|
||
ubinascii = None
|
||
try:
|
||
import ucryptolib as crypto_lib
|
||
except:
|
||
try:
|
||
import cryptolib as crypto_lib
|
||
except:
|
||
crypto_lib = None
|
||
|
||
# --- 增加堆内存大小 ---
|
||
# K210有8MB SRAM，默认堆较小，增加到512KB用于图像压缩
|
||
utils.gc_heap_size(1024 * 1024)
|
||
gc.collect()
|
||
print("[BOOT] Heap size set to 1MB")
|
||
|
||
# --- 配置参数（宏定义）---
|
||
SYNC_CHECK_INTERVAL_MS = 50000 # 检查同步请求的时间间隔（毫秒）
|
||
NETWORK_FRAME_INTERVAL = 300 # 每N帧检查一次网络任务（约1秒）
|
||
|
||
# --- 分时网络任务队列 ---
|
||
photo_upload_queue = [] # 照片上传队列 [face_id, ...]，JPEG先保存在SD卡
|
||
network_task_pending = False # 是否有网络任务待处理
|
||
frames_since_network = 0 # 距离上次网络操作的帧数
|
||
|
||
# --- 0. ESP8266 WiFi配置 ---
|
||
WIFI_SSID = "yzfh" # 修改为你的WiFi名称
|
||
WIFI_PASSWORD = "yzfhroot" # 修改为你的WiFi密码
|
||
SERVER_IP = "27.106.113.205" # 修改为服务器IP地址
|
||
SERVER_PORT = 8082 # 服务器HTTP端口
|
||
API_TOKEN = "atk_nKfVWLhMjL0RGSfRll3R_sdJS6IrIjuV" # 必须与服务端 ATTENDANCE_API_TOKEN 一致
|
||
ESP_DEBUG = True # 打印ESP8266 AT响应，便于排查WiFi连接问题
|
||
ESP_BAUD_RATES = (115200, 9600, 74880, 57600, 38400)
|
||
ESP_UART_BAUD = 115200
|
||
ESP_BOOT_WAIT_MS = 6000 # 等待ESP8266上电启动和自动连网
|
||
LOCAL_FACE_PHOTO_DIR = "/sd/face_photos" # 本地人脸照片缓存目录
|
||
AES_KEY = b"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c"
|
||
AES_IV = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
|
||
|
||
def crypto_ready():
|
||
return crypto_lib is not None and ubinascii is not None
|
||
|
||
def pkcs7_pad(data):
|
||
pad_len = 16 - (len(data) % 16)
|
||
return data + bytes([pad_len]) * pad_len
|
||
|
||
def pkcs7_unpad(data):
|
||
if not data:
|
||
return b""
|
||
pad_len = data[-1]
|
||
if pad_len < 1 or pad_len > 16 or pad_len > len(data):
|
||
return data
|
||
for b in data[-pad_len:]:
|
||
if b != pad_len:
|
||
return data
|
||
return data[:-pad_len]
|
||
|
||
def aes_cbc_crypt(data, encrypt=True):
|
||
if not crypto_ready():
|
||
print("[CRYPTO] ucryptolib/ubinascii unavailable, refuse plaintext HTTP")
|
||
return None
|
||
try:
|
||
cipher = crypto_lib.aes(AES_KEY, 2, AES_IV)
|
||
return cipher.encrypt(data) if encrypt else cipher.decrypt(data)
|
||
except Exception as e:
|
||
print("[CRYPTO] AES failed:", e)
|
||
return None
|
||
|
||
def encrypt_payload_base64(data):
|
||
if isinstance(data, str):
|
||
data = data.encode("utf-8")
|
||
encrypted = aes_cbc_crypt(pkcs7_pad(data), True)
|
||
if encrypted is None:
|
||
return None
|
||
encoded = ubinascii.b2a_base64(encrypted).strip()
|
||
try:
|
||
return encoded.decode("utf-8")
|
||
except:
|
||
return str(encoded, "utf-8")
|
||
|
||
def decrypt_payload_base64(data):
|
||
if data is None:
|
||
return None
|
||
if isinstance(data, str):
|
||
data = data.strip().encode("utf-8")
|
||
try:
|
||
encrypted = ubinascii.a2b_base64(data)
|
||
except Exception as e:
|
||
print("[CRYPTO] Base64 decode failed:", e)
|
||
return None
|
||
decrypted = aes_cbc_crypt(encrypted, False)
|
||
if decrypted is None:
|
||
return None
|
||
try:
|
||
return pkcs7_unpad(decrypted).decode("utf-8")
|
||
except Exception as e:
|
||
print("[CRYPTO] UTF-8 decode failed:", e)
|
||
return None
|
||
|
||
def extract_http_body(resp):
|
||
if not resp:
|
||
return ""
|
||
marker = "\r\n\r\n"
|
||
start = resp.find(marker)
|
||
if start == -1:
|
||
return ""
|
||
body = resp[start + len(marker):]
|
||
content_length = -1
|
||
cl_pos = resp.find("Content-Length:")
|
||
if cl_pos != -1:
|
||
cl_pos += len("Content-Length:")
|
||
while cl_pos < len(resp) and resp[cl_pos] == " ":
|
||
cl_pos += 1
|
||
cl_end = cl_pos
|
||
while cl_end < len(resp) and resp[cl_end].isdigit():
|
||
cl_end += 1
|
||
try:
|
||
content_length = int(resp[cl_pos:cl_end])
|
||
except:
|
||
content_length = -1
|
||
if content_length >= 0 and len(body) >= content_length:
|
||
return body[:content_length]
|
||
for marker in ("\r\nCLOSED", "CLOSED", "\r\nOK"):
|
||
pos = body.find(marker)
|
||
if pos != -1:
|
||
body = body[:pos]
|
||
return body.strip()
|
||
|
||
def http_body_complete(resp):
|
||
if not resp or "\r\n\r\n" not in resp:
|
||
return False
|
||
body = resp.split("\r\n\r\n", 1)[1]
|
||
cl_pos = resp.find("Content-Length:")
|
||
if cl_pos == -1:
|
||
return "CLOSED" in resp
|
||
cl_pos += len("Content-Length:")
|
||
while cl_pos < len(resp) and resp[cl_pos] == " ":
|
||
cl_pos += 1
|
||
cl_end = cl_pos
|
||
while cl_end < len(resp) and resp[cl_end].isdigit():
|
||
cl_end += 1
|
||
try:
|
||
return len(body) >= int(resp[cl_pos:cl_end])
|
||
except:
|
||
return "CLOSED" in resp
|
||
|
||
def decode_http_json_body(resp):
|
||
body = extract_http_body(resp)
|
||
if not body:
|
||
return None
|
||
if "X-Encrypted: AES128-CBC" in resp:
|
||
return decrypt_payload_base64(body)
|
||
if body.startswith("{") or body.startswith("["):
|
||
return body
|
||
return decrypt_payload_base64(body)
|
||
|
||
# 摄像头安装方向：当前实物画面上下左右都反，水平镜像+垂直翻转等价于旋转180度。
|
||
CAMERA_HMIRROR = 1
|
||
CAMERA_VFLIP = 1
|
||
|
||
# --- 1. UART通信初始化 ---
|
||
# UART1: 连接STM32（原有功能）
|
||
fm.register(24, fm.fpioa.UART1_TX, force=True)
|
||
fm.register(25, fm.fpioa.UART1_RX, force=True)
|
||
uart = UART(UART.UART1, 115200, 8, 0, 1, timeout=1000, read_buf_len=4096)
|
||
|
||
# UART2: 连接新ESP8266（照片上传功能）
|
||
fm.register(34, fm.fpioa.UART2_TX, force=True)
|
||
fm.register(35, fm.fpioa.UART2_RX, force=True)
|
||
uart2 = UART(UART.UART2, 115200, 8, 0, 1, timeout=2000, read_buf_len=4096)
|
||
|
||
# --- ESP8266 WiFi通信函数（优化版 - 减少阻塞）---
|
||
def esp_reopen_uart(baud):
|
||
"""按指定波特率重新打开ESP8266串口"""
|
||
global uart2, ESP_UART_BAUD
|
||
ESP_UART_BAUD = baud
|
||
try:
|
||
uart2.deinit()
|
||
except:
|
||
pass
|
||
uart2 = UART(UART.UART2, baud, 8, 0, 1, timeout=2000, read_buf_len=4096)
|
||
utime.sleep_ms(100)
|
||
|
||
def esp_clear_rx():
|
||
"""清空ESP8266串口残留数据"""
|
||
while uart2.any():
|
||
uart2.read()
|
||
utime.sleep_ms(10)
|
||
|
||
def esp_log_response(cmd, response):
|
||
if ESP_DEBUG:
|
||
text = response.replace('\r\n', ' ').strip() if response else "(空)"
|
||
print("[ESP] {} => {}".format(cmd, text[:180]))
|
||
|
||
def esp_send_cmd(cmd, timeout=1000, expected=None):
|
||
"""发送AT命令到ESP8266并等待响应"""
|
||
esp_clear_rx()
|
||
uart2.write(cmd + "\r\n")
|
||
utime.sleep_ms(50)
|
||
start = utime.ticks_ms()
|
||
response = ""
|
||
if expected is None:
|
||
expected = ("OK", "ERROR", "FAIL", "ready")
|
||
while utime.ticks_diff(utime.ticks_ms(), start) < timeout:
|
||
if uart2.any():
|
||
data = uart2.read()
|
||
if data:
|
||
response += data.decode('utf-8', 'ignore')
|
||
if any(token in response for token in expected):
|
||
break
|
||
utime.sleep_ms(5)
|
||
esp_log_response(cmd, response)
|
||
return response
|
||
|
||
def esp_probe_uart():
|
||
"""探测ESP8266实际AT波特率"""
|
||
print("[ESP] Probing UART baud rate...")
|
||
for baud in ESP_BAUD_RATES:
|
||
print("[ESP] Try baud:", baud)
|
||
esp_reopen_uart(baud)
|
||
for _ in range(2):
|
||
resp = esp_send_cmd("AT", 1500)
|
||
if "OK" in resp:
|
||
print("[ESP] UART baud detected:", baud)
|
||
return True
|
||
utime.sleep_ms(300)
|
||
esp_reopen_uart(115200)
|
||
print("[ESP] No AT response on tested baud rates")
|
||
return False
|
||
|
||
def esp_wait_boot():
|
||
"""等待ESP8266启动完成，避免K210太早发送AT命令"""
|
||
print("[ESP] Waiting for module boot...")
|
||
start = utime.ticks_ms()
|
||
boot_log = ""
|
||
while utime.ticks_diff(utime.ticks_ms(), start) < ESP_BOOT_WAIT_MS:
|
||
if uart2.any():
|
||
data = uart2.read()
|
||
if data:
|
||
boot_log += data.decode('utf-8', 'ignore')
|
||
utime.sleep_ms(100)
|
||
if ESP_DEBUG and boot_log:
|
||
print("[ESP] Boot log:", boot_log.replace('\r\n', ' ')[:180])
|
||
esp_clear_rx()
|
||
|
||
def esp_check_wifi_status():
|
||
"""检查WiFi连接状态（快速检查）"""
|
||
resp = esp_send_cmd("AT+CWJAP?", 1500)
|
||
return WIFI_SSID in resp
|
||
|
||
def esp_connect_wifi():
|
||
"""连接WiFi（单次尝试）"""
|
||
print("[ESP] Connecting to WiFi:", WIFI_SSID)
|
||
|
||
resp = esp_send_cmd("ATE0", 1000)
|
||
|
||
resp = esp_send_cmd("AT+CWMODE_CUR=1", 1500)
|
||
if "OK" not in resp:
|
||
resp = esp_send_cmd("AT+CWMODE=1", 1500)
|
||
|
||
if "OK" not in resp and "no change" not in resp:
|
||
print("[ESP] Set mode failed")
|
||
return False
|
||
|
||
if esp_check_wifi_status():
|
||
print("[ESP] WiFi already connected!")
|
||
return True
|
||
|
||
# 连接WiFi。部分路由器获取IP较慢，等待时间不能太短。
|
||
cmd = 'AT+CWJAP_CUR="{}","{}"'.format(WIFI_SSID, WIFI_PASSWORD)
|
||
resp = esp_send_cmd(cmd, 20000, ("WIFI GOT IP", "OK", "FAIL", "ERROR"))
|
||
|
||
if "OK" not in resp and "CONNECTED" not in resp and "WIFI GOT IP" not in resp:
|
||
cmd = 'AT+CWJAP="{}","{}"'.format(WIFI_SSID, WIFI_PASSWORD)
|
||
resp = esp_send_cmd(cmd, 20000, ("WIFI GOT IP", "OK", "FAIL", "ERROR"))
|
||
|
||
if "OK" in resp or "CONNECTED" in resp or "WIFI GOT IP" in resp:
|
||
utime.sleep_ms(1000)
|
||
status = esp_send_cmd("AT+CWJAP?", 1500)
|
||
ip = esp_send_cmd("AT+CIFSR", 1500)
|
||
if WIFI_SSID not in status and "STAIP" not in ip:
|
||
print("[ESP] WiFi command returned OK, but no station IP found")
|
||
return False
|
||
print("[ESP] WiFi connected!")
|
||
return True
|
||
|
||
print("[ESP] WiFi connect failed")
|
||
return False
|
||
|
||
def esp_init_wifi(max_retries=5):
|
||
"""初始化ESP8266并连接WiFi（减少重试次数）"""
|
||
print("[ESP] Initializing...")
|
||
esp_wait_boot()
|
||
esp_clear_rx()
|
||
|
||
# 测试AT响应
|
||
for i in range(max_retries):
|
||
resp = esp_send_cmd("AT", 2500)
|
||
if "OK" in resp:
|
||
print("[ESP] AT OK")
|
||
break
|
||
print("[ESP] AT retry {}/{}".format(i+1, max_retries))
|
||
utime.sleep_ms(500)
|
||
else:
|
||
if not esp_probe_uart():
|
||
print("[ESP] ESP8266 not responding!")
|
||
return False
|
||
|
||
# 连接WiFi
|
||
for i in range(max_retries):
|
||
if esp_connect_wifi():
|
||
return True
|
||
utime.sleep_ms(1000)
|
||
|
||
return False
|
||
|
||
def esp_ensure_wifi():
|
||
"""确保WiFi已连接（快速检查）"""
|
||
global wifi_connected
|
||
if not wifi_connected:
|
||
wifi_connected = esp_init_wifi(1)
|
||
return wifi_connected
|
||
return wifi_connected
|
||
|
||
def ensure_local_photo_dir():
|
||
"""确保SD卡本地照片目录存在"""
|
||
try:
|
||
os.listdir(LOCAL_FACE_PHOTO_DIR)
|
||
return True
|
||
except:
|
||
try:
|
||
os.mkdir(LOCAL_FACE_PHOTO_DIR)
|
||
print("[PHOTO] Created local dir:", LOCAL_FACE_PHOTO_DIR)
|
||
return True
|
||
except Exception as e:
|
||
print("[PHOTO] Create local dir failed:", e)
|
||
return False
|
||
|
||
def local_face_photo_path(face_id):
|
||
return "{}/{}.jpg".format(LOCAL_FACE_PHOTO_DIR, face_id)
|
||
|
||
def save_local_face_photo(face_id, jpeg_data):
|
||
"""先把人脸照片保存到SD卡，保证本地特征和照片一致"""
|
||
if not ensure_local_photo_dir():
|
||
return False
|
||
path = local_face_photo_path(face_id)
|
||
try:
|
||
with open(path, "wb") as f:
|
||
f.write(jpeg_data)
|
||
print("[PHOTO] Saved local photo:", path)
|
||
return True
|
||
except Exception as e:
|
||
print("[PHOTO] Save local photo failed:", e)
|
||
return False
|
||
|
||
def load_local_face_photo(face_id):
|
||
path = local_face_photo_path(face_id)
|
||
try:
|
||
with open(path, "rb") as f:
|
||
return f.read()
|
||
except Exception as e:
|
||
print("[PHOTO] Read local photo failed {}: {}".format(path, e))
|
||
return None
|
||
|
||
def remove_photo_from_queue(face_id):
|
||
global photo_upload_queue
|
||
face_id = str(face_id)
|
||
photo_upload_queue = [x for x in photo_upload_queue if x != face_id]
|
||
|
||
def delete_local_face_photo(face_id):
|
||
face_id = str(face_id)
|
||
remove_photo_from_queue(face_id)
|
||
path = local_face_photo_path(face_id)
|
||
try:
|
||
os.remove(path)
|
||
print("[PHOTO] Deleted local photo:", path)
|
||
return True
|
||
except:
|
||
return False
|
||
|
||
def delete_all_local_face_photos():
|
||
if not ensure_local_photo_dir():
|
||
return
|
||
try:
|
||
for name in os.listdir(LOCAL_FACE_PHOTO_DIR):
|
||
if name.endswith(".jpg"):
|
||
try:
|
||
os.remove("{}/{}".format(LOCAL_FACE_PHOTO_DIR, name))
|
||
except:
|
||
pass
|
||
photo_upload_queue[:] = []
|
||
print("[PHOTO] Deleted all local face photos")
|
||
except Exception as e:
|
||
print("[PHOTO] Delete all local photos failed:", e)
|
||
|
||
def esp_send_data(data, timeout=1500):
|
||
"""发送数据并等待SEND OK（优化超时）"""
|
||
cmd = "AT+CIPSEND={}".format(len(data))
|
||
uart2.write(cmd + "\r\n")
|
||
utime.sleep_ms(50)
|
||
|
||
# 等待 > 提示符（缩短超时）
|
||
start = utime.ticks_ms()
|
||
resp = ""
|
||
got_prompt = False
|
||
while utime.ticks_diff(utime.ticks_ms(), start) < 1000:
|
||
if uart2.any():
|
||
resp += uart2.read().decode('utf-8', 'ignore')
|
||
if ">" in resp:
|
||
got_prompt = True
|
||
break
|
||
if "ERROR" in resp or "link is not" in resp:
|
||
return False
|
||
utime.sleep_ms(5)
|
||
|
||
if not got_prompt:
|
||
return False
|
||
|
||
# 发送数据
|
||
uart2.write(data)
|
||
|
||
# 等待 SEND OK（缩短超时）
|
||
start = utime.ticks_ms()
|
||
resp = ""
|
||
while utime.ticks_diff(utime.ticks_ms(), start) < timeout:
|
||
if uart2.any():
|
||
resp += uart2.read().decode('utf-8', 'ignore')
|
||
if "SEND OK" in resp:
|
||
return True
|
||
if "SEND FAIL" in resp or "ERROR" in resp:
|
||
return False
|
||
utime.sleep_ms(10)
|
||
|
||
return False
|
||
|
||
def esp_http_post_photo(face_id, jpeg_data, max_retries=2):
|
||
"""通过ESP8266发送HTTP POST请求上传照片"""
|
||
# 直接使用face_id作为照片ID（不加时间戳）
|
||
print("[ESP] Uploading photo for face ID:", face_id, "size:", len(jpeg_data))
|
||
|
||
for attempt in range(max_retries):
|
||
# 确保WiFi连接
|
||
if not esp_ensure_wifi():
|
||
print("[ESP] No WiFi, retry {}/{}".format(attempt+1, max_retries))
|
||
utime.sleep_ms(2000)
|
||
continue
|
||
|
||
# 关闭之前的连接
|
||
esp_send_cmd("AT+CIPCLOSE", 500)
|
||
utime.sleep_ms(100)
|
||
|
||
# 设置单连接模式
|
||
esp_send_cmd("AT+CIPMUX=0", 500)
|
||
|
||
# 建立TCP连接
|
||
cmd = 'AT+CIPSTART="TCP","{}",{}'.format(SERVER_IP, SERVER_PORT)
|
||
resp = esp_send_cmd(cmd, 3000)
|
||
if "OK" not in resp and "CONNECT" not in resp:
|
||
print("[ESP] TCP failed, retry {}/{}".format(attempt+1, max_retries))
|
||
utime.sleep_ms(1000)
|
||
continue
|
||
|
||
print("[ESP] TCP connected, sending data...")
|
||
|
||
# 使用face_id作为文件名
|
||
http_header = "POST /api/v1/faces/photos/{} HTTP/1.1\r\n".format(face_id)
|
||
http_header += "Host: {}:{}\r\n".format(SERVER_IP, SERVER_PORT)
|
||
http_header += "Content-Type: image/jpeg\r\n"
|
||
http_header += "X-Api-Token: {}\r\n".format(API_TOKEN)
|
||
http_header += "Content-Length: {}\r\n".format(len(jpeg_data))
|
||
http_header += "Connection: close\r\n\r\n"
|
||
|
||
# 发送HTTP头
|
||
if not esp_send_data(http_header):
|
||
print("[ESP] Send header failed")
|
||
esp_send_cmd("AT+CIPCLOSE", 500)
|
||
continue
|
||
|
||
# 分块发送JPEG数据
|
||
CHUNK_SIZE = 1024
|
||
offset = 0
|
||
send_ok = True
|
||
|
||
while offset < len(jpeg_data):
|
||
chunk = jpeg_data[offset:offset + CHUNK_SIZE]
|
||
if not esp_send_data(chunk):
|
||
print("[ESP] Send chunk failed at", offset)
|
||
send_ok = False
|
||
break
|
||
offset += CHUNK_SIZE
|
||
print("[ESP] Sent {}/{}".format(min(offset, len(jpeg_data)), len(jpeg_data)))
|
||
|
||
if not send_ok:
|
||
esp_send_cmd("AT+CIPCLOSE", 500)
|
||
utime.sleep_ms(500)
|
||
continue
|
||
|
||
# 等待服务器响应
|
||
print("[ESP] Waiting for response...")
|
||
resp = ""
|
||
start = utime.ticks_ms()
|
||
while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
|
||
if uart2.any():
|
||
data = uart2.read()
|
||
if data:
|
||
resp += data.decode('utf-8', 'ignore')
|
||
if "200" in resp or "success" in resp or "HTTP/1.1" in resp:
|
||
print("[ESP] Got response!")
|
||
break
|
||
utime.sleep_ms(50)
|
||
|
||
esp_send_cmd("AT+CIPCLOSE", 300)
|
||
|
||
# 数据发送成功就算成功
|
||
if send_ok:
|
||
print("[ESP] Photo uploaded successfully!")
|
||
return True
|
||
else:
|
||
print("[ESP] Response:", resp[:100] if resp else "(empty)")
|
||
print("[ESP] Retry {}/{}".format(attempt+1, max_retries))
|
||
utime.sleep_ms(1000)
|
||
|
||
print("[ESP] Upload failed after {} retries".format(max_retries))
|
||
return False
|
||
|
||
def capture_and_upload_face(face_id, img):
|
||
"""拍摄人脸照片并加入上传队列（非阻塞）"""
|
||
try:
|
||
# 先复制图像，避免修改原图
|
||
img_copy = img.copy()
|
||
|
||
# 转换为RGB565格式（如果需要）后压缩为JPEG
|
||
try:
|
||
jpeg_img = img_copy.compress(quality=50) # 降低质量减小体积
|
||
jpeg_data = jpeg_img.to_bytes()
|
||
except Exception as e1:
|
||
print("[PHOTO] Compress method 1 failed:", e1)
|
||
# 尝试另一种方式
|
||
try:
|
||
jpeg_data = img_copy.to_bytes() # 直接尝试转换
|
||
except Exception as e2:
|
||
print("[PHOTO] Compress method 2 failed:", e2)
|
||
return False
|
||
|
||
print("[PHOTO] JPEG size:", len(jpeg_data), "bytes")
|
||
|
||
if len(jpeg_data) < 100:
|
||
print("[PHOTO] JPEG too small, skip upload")
|
||
return False
|
||
|
||
# 先保存本地，再加入上传队列（非阻塞）。上传失败也不会丢照片。
|
||
if not save_local_face_photo(face_id, jpeg_data):
|
||
return False
|
||
|
||
queue_photo_upload(face_id)
|
||
print("[PHOTO] Face {} saved locally and queued for upload".format(face_id))
|
||
return True
|
||
|
||
except Exception as e:
|
||
print("[PHOTO] Error:", e)
|
||
return False
|
||
|
||
# 初始化WiFi连接（启动时尝试连接）
|
||
wifi_connected = False
|
||
print("[BOOT] Starting ESP8266 WiFi init...")
|
||
try:
|
||
wifi_connected = esp_init_wifi()
|
||
print("[BOOT] WiFi status:", "connected" if wifi_connected else "not connected")
|
||
except Exception as e:
|
||
print("[BOOT] ESP8266 init error:", e)
|
||
|
||
# --- 人脸ID到真实学号的映射表 ---
|
||
face_id_mapping = {} # 格式: {"1": "20210001", "2": "20210002"}
|
||
MAPPING_FILE = "/sd/face_mapping.txt" # SD卡上的映射文件
|
||
SYNC_VERSION_FILE = "/sd/sync_version.txt" # 本地已应用的服务端同步版本
|
||
RECORD_PATH = "/sd/recordftr.txt" # 人脸特征记录文件路径
|
||
sync_last_version = 0
|
||
|
||
def load_local_mapping():
|
||
"""从SD卡加载本地映射配置"""
|
||
global face_id_mapping
|
||
face_id_mapping.clear()
|
||
try:
|
||
with open(MAPPING_FILE, "r") as f:
|
||
for line in f:
|
||
line = line.strip()
|
||
if '=' in line:
|
||
parts = line.split('=')
|
||
if len(parts) == 2:
|
||
face_id_mapping[parts[0]] = parts[1]
|
||
print("[LOCAL] Loaded {} mappings from SD".format(len(face_id_mapping)))
|
||
except:
|
||
print("[LOCAL] No local mapping file")
|
||
|
||
def save_local_mapping():
|
||
"""保存映射配置到SD卡"""
|
||
try:
|
||
with open(MAPPING_FILE, "w") as f:
|
||
for k, v in face_id_mapping.items():
|
||
f.write("{}={}\n".format(k, v))
|
||
print("[LOCAL] Saved {} mappings to SD".format(len(face_id_mapping)))
|
||
return True
|
||
except Exception as e:
|
||
print("[LOCAL] Save error:", e)
|
||
return False
|
||
|
||
def load_sync_version():
|
||
"""从SD卡加载本地已同步版本"""
|
||
global sync_last_version
|
||
try:
|
||
with open(SYNC_VERSION_FILE, "r") as f:
|
||
value = f.read().strip()
|
||
sync_last_version = int(value) if value else 0
|
||
except:
|
||
sync_last_version = 0
|
||
print("[LOCAL] Sync version:", sync_last_version)
|
||
|
||
def save_sync_version(version):
|
||
"""保存本地已同步版本"""
|
||
global sync_last_version
|
||
sync_last_version = version
|
||
try:
|
||
with open(SYNC_VERSION_FILE, "w") as f:
|
||
f.write(str(version))
|
||
except Exception as e:
|
||
print("[LOCAL] Save sync version error:", e)
|
||
|
||
def update_face_record(face_id, new_student_id):
|
||
"""保存face_id到学号的映射，保持recordftr.txt中的原始face_id不变。"""
|
||
global face_id_mapping, peoples
|
||
|
||
face_id = str(face_id)
|
||
new_student_id = str(new_student_id)
|
||
if not local_face_id_exists(face_id):
|
||
print("[UPDATE] Ignore mapping for missing local face_id {} -> {}".format(face_id, new_student_id))
|
||
return False
|
||
|
||
face_id_mapping[face_id] = new_student_id
|
||
save_local_mapping()
|
||
|
||
found = False
|
||
for p in peoples:
|
||
if p.name == "ID:{}".format(face_id) or p.name == face_id:
|
||
found = True
|
||
break
|
||
|
||
if found:
|
||
print("[UPDATE] Mapping saved: face_id {} -> student_id {}".format(face_id, new_student_id))
|
||
else:
|
||
print("[UPDATE] Mapping saved, local face feature not found yet: {}".format(face_id))
|
||
return True
|
||
|
||
def esp_http_get(url_path, timeout=8000):
|
||
"""发送HTTP GET请求并返回响应内容"""
|
||
if not wifi_connected:
|
||
print("[HTTP_GET] WiFi未连接")
|
||
return None
|
||
|
||
print("[HTTP_GET] 关闭旧连接...")
|
||
esp_send_cmd("AT+CIPCLOSE", 500)
|
||
utime.sleep_ms(300)
|
||
esp_send_cmd("AT+CIPMUX=0", 500)
|
||
utime.sleep_ms(100)
|
||
|
||
# 建立TCP连接
|
||
print("[HTTP_GET] 建立TCP连接: {}:{}".format(SERVER_IP, SERVER_PORT))
|
||
cmd = 'AT+CIPSTART="TCP","{}",{}'.format(SERVER_IP, SERVER_PORT)
|
||
resp = esp_send_cmd(cmd, 5000)
|
||
print("[HTTP_GET] TCP响应: {}".format(resp.replace('\r\n', ' ')[:80] if resp else "(空)"))
|
||
|
||
if "OK" not in resp and "CONNECT" not in resp:
|
||
print("[HTTP_GET] TCP连接失败")
|
||
return None
|
||
|
||
print("[HTTP_GET] TCP连接成功")
|
||
utime.sleep_ms(200)
|
||
|
||
# 构建HTTP GET请求
|
||
http_request = "GET {} HTTP/1.1\r\nHost: {}:{}\r\nX-Api-Token: {}\r\nX-Encrypted-Response: true\r\nConnection: close\r\n\r\n".format(
|
||
url_path, SERVER_IP, SERVER_PORT, API_TOKEN)
|
||
|
||
# 使用AT+CIPSEND发送
|
||
print("[HTTP_GET] 准备发送 {} bytes".format(len(http_request)))
|
||
cmd = "AT+CIPSEND={}".format(len(http_request))
|
||
uart2.write(cmd + "\r\n")
|
||
utime.sleep_ms(100)
|
||
|
||
# 等待 > 提示符
|
||
start = utime.ticks_ms()
|
||
prompt_resp = ""
|
||
while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
|
||
if uart2.any():
|
||
data = uart2.read()
|
||
if data:
|
||
prompt_resp += data.decode('utf-8', 'ignore')
|
||
if ">" in prompt_resp:
|
||
break
|
||
utime.sleep_ms(10)
|
||
|
||
if ">" not in prompt_resp:
|
||
print("[HTTP_GET] 未收到>提示符: {}".format(prompt_resp[:50]))
|
||
esp_send_cmd("AT+CIPCLOSE", 300)
|
||
return None
|
||
|
||
print("[HTTP_GET] 收到>提示符，发送请求...")
|
||
|
||
# 发送HTTP请求
|
||
uart2.write(http_request)
|
||
|
||
# 等待SEND OK
|
||
start = utime.ticks_ms()
|
||
send_resp = ""
|
||
while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
|
||
if uart2.any():
|
||
data = uart2.read()
|
||
if data:
|
||
send_resp += data.decode('utf-8', 'ignore')
|
||
if "SEND OK" in send_resp:
|
||
print("[HTTP_GET] SEND OK")
|
||
break
|
||
utime.sleep_ms(10)
|
||
|
||
if "SEND OK" not in send_resp:
|
||
print("[HTTP_GET] 发送失败: {}".format(send_resp[:50]))
|
||
esp_send_cmd("AT+CIPCLOSE", 300)
|
||
return None
|
||
|
||
# 等待服务器响应（关键：要等足够长的时间）
|
||
print("[HTTP_GET] 等待服务器响应...")
|
||
resp = send_resp # 继续累积数据
|
||
start = utime.ticks_ms()
|
||
|
||
while utime.ticks_diff(utime.ticks_ms(), start) < timeout:
|
||
if uart2.any():
|
||
data = uart2.read()
|
||
if data:
|
||
try:
|
||
resp += data.decode('utf-8', 'ignore')
|
||
print("[HTTP_GET] 累积数据: {} bytes".format(len(resp)))
|
||
except:
|
||
pass
|
||
# 加密响应是Base64文本，按Content-Length或连接关闭判断完整性。
|
||
if http_body_complete(resp):
|
||
if "CLOSED" in resp:
|
||
print("[HTTP_GET] 连接已关闭，数据完整")
|
||
break
|
||
# 继续等一下看有没有更多数据
|
||
utime.sleep_ms(500)
|
||
if uart2.any():
|
||
extra = uart2.read()
|
||
if extra:
|
||
resp += extra.decode('utf-8', 'ignore')
|
||
if "CLOSED" in resp or utime.ticks_diff(utime.ticks_ms(), start) > 3000:
|
||
break
|
||
utime.sleep_ms(30)
|
||
|
||
esp_send_cmd("AT+CIPCLOSE", 300)
|
||
|
||
print("[HTTP_GET] 原始响应长度: {}".format(len(resp)))
|
||
if len(resp) > 0:
|
||
print("[HTTP_GET] 响应片段: {}".format(resp[:300].replace('\r\n', '\\n')))
|
||
|
||
result = decode_http_json_body(resp)
|
||
if result:
|
||
print("[HTTP_GET] 解密JSON成功: {}".format(result[:100]))
|
||
return result
|
||
|
||
print("[HTTP_GET] 未找到可用JSON")
|
||
return None
|
||
|
||
def extract_face_id(face_name):
|
||
face_name = str(face_name)
|
||
if face_name.startswith("ID:"):
|
||
return face_name.split(":", 1)[1]
|
||
return face_name
|
||
|
||
def local_face_id_exists(face_id):
|
||
face_id = str(face_id)
|
||
for p in peoples:
|
||
if extract_face_id(p.name) == face_id:
|
||
return True
|
||
return False
|
||
|
||
def get_mapped_student_id(face_name):
|
||
face_id = extract_face_id(face_name)
|
||
return face_id_mapping.get(face_id, "")
|
||
|
||
def get_display_name(face_name):
|
||
"""显示学号映射；未绑定时显示原始face_id。"""
|
||
mapped = get_mapped_student_id(face_name)
|
||
return mapped if mapped else face_name
|
||
|
||
# 加载本地映射配置
|
||
load_local_mapping()
|
||
load_sync_version()
|
||
|
||
# 启动时同步将在所有函数定义后执行（见文件末尾）
|
||
|
||
# --- 定时同步配置 ---
|
||
last_sync_time = utime.ticks_ms()
|
||
sync_in_progress = False # 同步状态标志
|
||
sync_step = 0 # 同步步骤（分步执行避免长时间阻塞）
|
||
|
||
# --- 远程删除人脸功能 ---
|
||
def delete_face_by_id(face_id):
|
||
"""根据人脸ID删除本地人脸数据"""
|
||
global peoples
|
||
|
||
target_patterns = ["ID:{}".format(face_id)]
|
||
|
||
print("[DELETE] Looking for patterns:", target_patterns)
|
||
|
||
deleted_index = -1
|
||
for i, p in enumerate(peoples):
|
||
for pattern in target_patterns:
|
||
if p.name == pattern:
|
||
deleted_index = i
|
||
break
|
||
if deleted_index >= 0:
|
||
break
|
||
|
||
if deleted_index >= 0:
|
||
deleted_name = peoples[deleted_index].name
|
||
peoples.pop(deleted_index)
|
||
try:
|
||
write_face_record()
|
||
print("[DELETE] 删除人脸成功: {}".format(deleted_name))
|
||
|
||
# 同时删除本地照片，避免下次启动补传已删除的人脸照片
|
||
delete_local_face_photo(face_id)
|
||
if deleted_name.startswith("ID:"):
|
||
delete_local_face_photo(deleted_name.split(":", 1)[1])
|
||
else:
|
||
delete_local_face_photo(deleted_name)
|
||
for pattern in target_patterns:
|
||
if pattern.startswith("ID:"):
|
||
delete_local_face_photo(pattern.split(":", 1)[1])
|
||
else:
|
||
delete_local_face_photo(pattern)
|
||
|
||
# 同时删除映射
|
||
if face_id in face_id_mapping:
|
||
del face_id_mapping[face_id]
|
||
save_local_mapping()
|
||
|
||
# 重新加载
|
||
load_faces()
|
||
return True
|
||
except Exception as e:
|
||
print("[DELETE] 重写文件失败:", e)
|
||
load_faces()
|
||
return False
|
||
else:
|
||
print("[DELETE] 未找到人脸ID: {}".format(face_id))
|
||
return False
|
||
|
||
def esp_http_post_json(url_path, json_data, timeout=2000):
|
||
"""发送HTTP POST请求（优化版）"""
|
||
if not wifi_connected:
|
||
return None
|
||
encrypted_data = encrypt_payload_base64(json_data)
|
||
if encrypted_data is None:
|
||
return None
|
||
|
||
esp_send_cmd("AT+CIPCLOSE", 300)
|
||
utime.sleep_ms(50)
|
||
esp_send_cmd("AT+CIPMUX=0", 300)
|
||
|
||
cmd = 'AT+CIPSTART="TCP","{}",{}'.format(SERVER_IP, SERVER_PORT)
|
||
resp = esp_send_cmd(cmd, 2000)
|
||
if "OK" not in resp and "CONNECT" not in resp:
|
||
return None
|
||
|
||
http_request = "POST {} HTTP/1.1\r\nHost: {}:{}\r\nContent-Type: application/octet-stream\r\nX-Api-Token: {}\r\nX-Encrypted: AES128-CBC\r\nX-Encrypted-Response: true\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}".format(
|
||
url_path, SERVER_IP, SERVER_PORT, API_TOKEN, len(encrypted_data), encrypted_data)
|
||
|
||
if not esp_send_data(http_request, 1500):
|
||
esp_send_cmd("AT+CIPCLOSE", 300)
|
||
return None
|
||
|
||
resp = ""
|
||
start = utime.ticks_ms()
|
||
while utime.ticks_diff(utime.ticks_ms(), start) < timeout:
|
||
if uart2.any():
|
||
data = uart2.read()
|
||
if data:
|
||
resp += data.decode('utf-8', 'ignore')
|
||
if http_body_complete(resp):
|
||
break
|
||
utime.sleep_ms(10)
|
||
|
||
esp_send_cmd("AT+CIPCLOSE", 300)
|
||
return decode_http_json_body(resp)
|
||
|
||
def json_get_int(text, key, default=0):
|
||
marker = '"{}":'.format(key)
|
||
start = text.find(marker)
|
||
if start == -1:
|
||
return default
|
||
start += len(marker)
|
||
while start < len(text) and text[start] == ' ':
|
||
start += 1
|
||
end = start
|
||
while end < len(text) and text[end].isdigit():
|
||
end += 1
|
||
try:
|
||
return int(text[start:end])
|
||
except:
|
||
return default
|
||
|
||
def extract_json_block(text, key, open_ch, close_ch):
|
||
marker = '"{}":'.format(key)
|
||
pos = text.find(marker)
|
||
if pos == -1:
|
||
return ""
|
||
start = text.find(open_ch, pos + len(marker))
|
||
if start == -1:
|
||
return ""
|
||
depth = 0
|
||
for i in range(start, len(text)):
|
||
ch = text[i]
|
||
if ch == open_ch:
|
||
depth += 1
|
||
elif ch == close_ch:
|
||
depth -= 1
|
||
if depth == 0:
|
||
return text[start:i + 1]
|
||
return ""
|
||
|
||
def parse_string_array_block(arr_str):
|
||
values = []
|
||
pos = 0
|
||
while pos < len(arr_str):
|
||
start = arr_str.find('"', pos)
|
||
if start == -1:
|
||
break
|
||
end = arr_str.find('"', start + 1)
|
||
if end == -1:
|
||
break
|
||
values.append(arr_str[start + 1:end])
|
||
pos = end + 1
|
||
return values
|
||
|
||
def parse_delete_tasks(tasks_str):
|
||
tasks = []
|
||
pos = 0
|
||
while pos < len(tasks_str):
|
||
obj_start = tasks_str.find('{', pos)
|
||
if obj_start == -1:
|
||
break
|
||
obj_end = tasks_str.find('}', obj_start)
|
||
if obj_end == -1:
|
||
break
|
||
obj = tasks_str[obj_start:obj_end + 1]
|
||
task_id = json_get_string(obj, "task_id", "")
|
||
face_id = json_get_string(obj, "face_id", "")
|
||
if face_id:
|
||
tasks.append({"task_id": task_id, "face_id": face_id})
|
||
pos = obj_end + 1
|
||
return tasks
|
||
|
||
def json_get_string(text, key, default=""):
|
||
marker = '"{}":"'.format(key)
|
||
start = text.find(marker)
|
||
if start == -1:
|
||
return default
|
||
start += len(marker)
|
||
end = text.find('"', start)
|
||
if end == -1:
|
||
return default
|
||
return text[start:end]
|
||
|
||
def parse_photo_ids(response):
|
||
"""解析服务端 /api/v1/faces/photos 返回的照片ID列表"""
|
||
ids = {}
|
||
pos = 0
|
||
marker = '"id":"'
|
||
while pos < len(response):
|
||
start = response.find(marker, pos)
|
||
if start == -1:
|
||
break
|
||
start += len(marker)
|
||
end = response.find('"', start)
|
||
if end == -1:
|
||
break
|
||
photo_id = response[start:end]
|
||
if photo_id:
|
||
ids[photo_id] = 1
|
||
pos = end + 1
|
||
return ids
|
||
|
||
def parse_mapping_object(obj_str):
|
||
mappings = {}
|
||
if len(obj_str) < 2:
|
||
return mappings
|
||
inner = obj_str[1:-1].strip()
|
||
if not inner:
|
||
return mappings
|
||
parts = inner.split(',')
|
||
for part in parts:
|
||
if ':' not in part:
|
||
continue
|
||
kv = part.split(':', 1)
|
||
key = kv[0].strip().strip('"')
|
||
value = kv[1].strip().strip('"')
|
||
if key and value:
|
||
mappings[key] = value
|
||
return mappings
|
||
|
||
def apply_face_profiles(server_mappings):
|
||
global face_id_mapping
|
||
print("[SYNC_STATE] 服务器映射数量: {}".format(len(server_mappings)))
|
||
updated_count = 0
|
||
valid_mappings = {}
|
||
for face_id, student_id in face_id_mapping.items():
|
||
if local_face_id_exists(face_id) and student_id:
|
||
valid_mappings[face_id] = student_id
|
||
|
||
for face_id, student_id in server_mappings.items():
|
||
if not local_face_id_exists(face_id):
|
||
print("[SYNC_STATE] 跳过本地不存在的face_id映射: ID:{} -> {}".format(face_id, student_id))
|
||
continue
|
||
if student_id == "__PHOTO_ONLY__":
|
||
print("[SYNC_STATE] 服务端仅有照片占位，保留本地映射: ID:{}".format(face_id))
|
||
continue
|
||
if not student_id:
|
||
if face_id in valid_mappings:
|
||
del valid_mappings[face_id]
|
||
updated_count += 1
|
||
print("[SYNC_STATE] 解除本地face_id绑定: ID:{}".format(face_id))
|
||
continue
|
||
print("[SYNC_STATE] 映射: ID:{} -> {}".format(face_id, student_id))
|
||
if update_face_record(face_id, student_id):
|
||
updated_count += 1
|
||
valid_mappings[face_id] = student_id
|
||
face_id_mapping = valid_mappings
|
||
save_local_mapping()
|
||
print("[SYNC_STATE] 映射应用完成，更新 {} 条".format(updated_count))
|
||
|
||
def sync_unified_state():
|
||
"""按服务端统一版本号同步K210所需状态"""
|
||
global sync_last_version
|
||
if not wifi_connected:
|
||
print("[SYNC_STATE] WiFi未连接，跳过")
|
||
return False
|
||
|
||
path = "/api/v1/sync/state?client=k210&last_version={}".format(sync_last_version)
|
||
print("[SYNC_STATE] GET {}".format(path))
|
||
response = esp_http_get(path, 8000)
|
||
if response is None:
|
||
print("[SYNC_STATE] 服务器无响应")
|
||
return False
|
||
|
||
server_version = json_get_int(response, "version", sync_last_version)
|
||
changed = ('"changed":true' in response)
|
||
print("[SYNC_STATE] local={}, server={}, changed={}".format(sync_last_version, server_version, changed))
|
||
|
||
if not changed:
|
||
save_sync_version(server_version)
|
||
return True
|
||
|
||
profiles_arr = extract_json_block(response, "face_profiles", '[', ']')
|
||
server_mappings = {}
|
||
server_face_ids = {}
|
||
pos = 0
|
||
while profiles_arr and pos < len(profiles_arr):
|
||
obj_start = profiles_arr.find('{', pos)
|
||
if obj_start == -1:
|
||
break
|
||
obj_end = profiles_arr.find('}', obj_start)
|
||
if obj_end == -1:
|
||
break
|
||
obj = profiles_arr[obj_start:obj_end + 1]
|
||
face_id = json_get_string(obj, "face_id", "")
|
||
student_id = json_get_string(obj, "student_id", "")
|
||
status = json_get_string(obj, "status", "")
|
||
if face_id:
|
||
server_face_ids[face_id] = 1
|
||
if status == "photo_only" and not student_id:
|
||
student_id = "__PHOTO_ONLY__"
|
||
server_mappings[face_id] = student_id
|
||
pos = obj_end + 1
|
||
|
||
tasks_arr = extract_json_block(response, "delete_tasks", '[', ']')
|
||
delete_tasks = parse_delete_tasks(tasks_arr)
|
||
pending_arr = extract_json_block(response, "pending_delete", '[', ']')
|
||
pending_delete = parse_string_array_block(pending_arr)
|
||
if not delete_tasks:
|
||
delete_tasks = [{"task_id": "", "face_id": face_id} for face_id in pending_delete]
|
||
deleted_ids = []
|
||
deleted_task_ids = []
|
||
delete_failed = False
|
||
print("[SYNC_STATE] 待删除任务: {}".format(delete_tasks))
|
||
|
||
for task in delete_tasks:
|
||
face_id = task["face_id"]
|
||
if face_id in server_face_ids:
|
||
print("[SYNC_STATE] 忽略旧删除任务，服务端仍有人脸记录: {}".format(face_id))
|
||
deleted_ids.append(face_id)
|
||
if task["task_id"]:
|
||
deleted_task_ids.append(task["task_id"])
|
||
continue
|
||
if not local_face_id_exists(face_id):
|
||
print("[SYNC_STATE] 删除任务face_id本地不存在，跳过但ACK: {}".format(face_id))
|
||
deleted_ids.append(face_id)
|
||
if task["task_id"]:
|
||
deleted_task_ids.append(task["task_id"])
|
||
continue
|
||
if delete_face_by_id(face_id):
|
||
deleted_ids.append(face_id)
|
||
if task["task_id"]:
|
||
deleted_task_ids.append(task["task_id"])
|
||
else:
|
||
delete_failed = True
|
||
|
||
if deleted_ids:
|
||
deleted_json = ",".join(['"{}"'.format(x) for x in deleted_ids])
|
||
task_json = ",".join(['"{}"'.format(x) for x in deleted_task_ids])
|
||
ack_body = '{{"client":"k210","version":{},"deleted":[{}],"task_ids":[{}]}}'.format(server_version, deleted_json, task_json)
|
||
ack_resp = esp_http_post_json("/api/v1/sync/ack", ack_body, 3000)
|
||
print("[SYNC_STATE] ACK响应:", ack_resp[:120] if ack_resp else "(空)")
|
||
ack_compact = ack_resp.replace(" ", "").replace("\r", "").replace("\n", "") if ack_resp else ""
|
||
ack_ok = '"success":true' in ack_compact
|
||
if not ack_ok:
|
||
delete_failed = True
|
||
print("[SYNC_STATE] 删除ACK失败，暂不推进本地版本，等待下次重试")
|
||
|
||
apply_face_profiles(server_mappings)
|
||
|
||
if not delete_failed:
|
||
save_sync_version(server_version)
|
||
else:
|
||
print("[SYNC_STATE] 有删除失败项，暂不推进本地版本，等待下次重试")
|
||
|
||
return not delete_failed
|
||
|
||
# --- K210时间管理 ---
|
||
k210_base_timestamp = 0 # 基准时间戳（Unix时间戳）
|
||
k210_base_ticks = 0 # 基准时刻的ticks
|
||
|
||
def set_base_time(unix_timestamp):
|
||
"""设置K210的基准时间"""
|
||
global k210_base_timestamp, k210_base_ticks
|
||
k210_base_timestamp = unix_timestamp
|
||
k210_base_ticks = utime.ticks_ms()
|
||
print("[TIME] Base time set:", unix_timestamp)
|
||
|
||
def get_current_timestamp():
|
||
"""获取当前Unix时间戳"""
|
||
if k210_base_timestamp == 0:
|
||
# 如果还没设置基准时间，使用运行时间
|
||
return utime.ticks_ms() // 1000
|
||
else:
|
||
# 计算当前时间戳
|
||
elapsed_seconds = (utime.ticks_ms() - k210_base_ticks) // 1000
|
||
return k210_base_timestamp + elapsed_seconds
|
||
|
||
# --- 2. KPU模型和硬件初始化 ---
|
||
try:
|
||
task_fd = kpu.load("/sd/FaceDetection.smodel")
|
||
task_ld = kpu.load("/sd/FaceLandmarkDetection.smodel")
|
||
task_fe = kpu.load("/sd/FeatureExtraction.smodel")
|
||
except Exception as e:
|
||
print("Error loading KPU models:", e)
|
||
while True:
|
||
utime.sleep_ms(1000)
|
||
|
||
clock = time.clock()
|
||
fm.register(12, fm.fpioa.GPIO0)
|
||
fm.register(13, fm.fpioa.GPIO1)
|
||
fm.register(14, fm.fpioa.GPIO2)
|
||
LED_B = GPIO(GPIO.GPIO0, GPIO.OUT, value=1)
|
||
LED_G = GPIO(GPIO.GPIO1, GPIO.OUT, value=1)
|
||
LED_R = GPIO(GPIO.GPIO2, GPIO.OUT, value=1)
|
||
key_pin = 16
|
||
fm.register(key_pin, fm.fpioa.GPIOHS0)
|
||
KEY = GPIO(GPIO.GPIOHS0, GPIO.IN)
|
||
lcd.init()
|
||
sensor.reset()
|
||
sensor.set_pixformat(sensor.RGB565)
|
||
sensor.set_framesize(sensor.QVGA)
|
||
sensor.set_hmirror(CAMERA_HMIRROR)
|
||
sensor.set_vflip(CAMERA_VFLIP)
|
||
sensor.run(1)
|
||
anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437, 6.92275, 6.718375, 9.01025)
|
||
dst_point = [(44, 59), (84, 59), (64, 82), (47, 105), (81, 105)]
|
||
kpu.init_yolo2(task_fd, 0.5, 0.3, 5, anchor)
|
||
img_face = image.Image(size=(128, 128))
|
||
img_face.pix_to_ai()
|
||
|
||
# --- 3. 按键中断处理 ---
|
||
key_Flag = 0
|
||
key_pressed = 0 # 0=无, 1=短按, 2=长按(2秒), 3=超长按(5秒删除全部)
|
||
t_key = 0
|
||
def fun(KEY):
|
||
global key_Flag, key_pressed, t_key
|
||
utime.sleep_ms(10)
|
||
if KEY.value() == 0:
|
||
if key_Flag == 0:
|
||
key_Flag = 1
|
||
t_key = utime.ticks_ms()
|
||
else:
|
||
if key_Flag == 1:
|
||
press_duration = utime.ticks_diff(utime.ticks_ms(), t_key)
|
||
if press_duration > 5000:
|
||
key_pressed = 3 # 超长按5秒：删除全部人脸
|
||
elif press_duration > 2000:
|
||
key_pressed = 2 # 长按2秒：删除模式
|
||
else:
|
||
key_pressed = 1 # 短按：添加人脸
|
||
key_Flag = 0
|
||
KEY.irq(fun, GPIO.IRQ_BOTH)
|
||
|
||
def delete_all_faces():
|
||
"""删除全部人脸数据"""
|
||
global peoples, face_id_mapping
|
||
try:
|
||
# 清空人脸列表
|
||
peoples = []
|
||
# 清空记录文件
|
||
with open(record_path, "w") as f:
|
||
pass # 写入空文件
|
||
# 清空映射
|
||
face_id_mapping = {}
|
||
save_local_mapping()
|
||
delete_all_local_face_photos()
|
||
print("[DELETE_ALL] 已删除全部人脸数据")
|
||
return True
|
||
except Exception as e:
|
||
print("[DELETE_ALL] 删除失败:", e)
|
||
load_faces()
|
||
return False
|
||
|
||
# --- 4. 数据库和人脸管理函数 (已包含之前修复的bug) ---
|
||
class People:
|
||
def __init__(self, name="", feature=[]): self.name = name; self.feature = feature
|
||
def feature_max(self, feature):
|
||
if not self.feature: return 0
|
||
return kpu.face_compare(self.feature, feature)
|
||
peoples = []
|
||
record_path = "/sd/recordftr.txt"
|
||
|
||
def hex_value(ch):
|
||
if '0' <= ch <= '9':
|
||
return ord(ch) - ord('0')
|
||
if 'a' <= ch <= 'f':
|
||
return ord(ch) - ord('a') + 10
|
||
if 'A' <= ch <= 'F':
|
||
return ord(ch) - ord('A') + 10
|
||
return -1
|
||
|
||
def parse_bytes_literal(text):
|
||
"""安全解析 bytearray(b"...") / b"..." 文本，不使用 eval。"""
|
||
pos1 = text.find("b'")
|
||
pos2 = text.find('b"')
|
||
if pos1 < 0 and pos2 < 0:
|
||
raise ValueError("bytes literal not found")
|
||
if pos1 >= 0 and (pos2 < 0 or pos1 < pos2):
|
||
pos = pos1
|
||
quote = "'"
|
||
else:
|
||
pos = pos2
|
||
quote = '"'
|
||
|
||
i = pos + 2
|
||
values = []
|
||
while i < len(text):
|
||
ch = text[i]
|
||
if ch == quote:
|
||
if len(values) < 64:
|
||
raise ValueError("feature too short")
|
||
return bytearray(values)
|
||
|
||
if ch != "\\":
|
||
values.append(ord(ch))
|
||
i += 1
|
||
else:
|
||
i += 1
|
||
if i >= len(text):
|
||
raise ValueError("bad escape")
|
||
esc = text[i]
|
||
if esc == "x":
|
||
if i + 2 >= len(text):
|
||
raise ValueError("bad hex escape")
|
||
hi = hex_value(text[i + 1])
|
||
lo = hex_value(text[i + 2])
|
||
if hi < 0 or lo < 0:
|
||
raise ValueError("bad hex escape")
|
||
values.append(hi * 16 + lo)
|
||
i += 3
|
||
elif esc == "n":
|
||
values.append(10)
|
||
i += 1
|
||
elif esc == "r":
|
||
values.append(13)
|
||
i += 1
|
||
elif esc == "t":
|
||
values.append(9)
|
||
i += 1
|
||
elif esc == "b":
|
||
values.append(8)
|
||
i += 1
|
||
elif esc == "f":
|
||
values.append(12)
|
||
i += 1
|
||
elif esc == "v":
|
||
values.append(11)
|
||
i += 1
|
||
elif esc == "a":
|
||
values.append(7)
|
||
i += 1
|
||
elif esc == "\\":
|
||
values.append(92)
|
||
i += 1
|
||
elif esc == quote:
|
||
values.append(ord(quote))
|
||
i += 1
|
||
elif '0' <= esc <= '7':
|
||
val = ord(esc) - ord('0')
|
||
i += 1
|
||
count = 1
|
||
while count < 3 and i < len(text) and '0' <= text[i] <= '7':
|
||
val = val * 8 + ord(text[i]) - ord('0')
|
||
i += 1
|
||
count += 1
|
||
values.append(val & 0xff)
|
||
else:
|
||
values.append(ord(esc))
|
||
i += 1
|
||
|
||
if len(values) > 4096:
|
||
raise ValueError("feature too long")
|
||
|
||
raise ValueError("unterminated bytes literal")
|
||
|
||
def parse_number_list(text):
|
||
start = text.find("[")
|
||
end = text.rfind("]")
|
||
if start < 0 or end <= start:
|
||
raise ValueError("feature must be bytearray/list")
|
||
|
||
inner = text[start + 1:end].strip()
|
||
if not inner:
|
||
raise ValueError("empty feature")
|
||
|
||
values = []
|
||
has_float = False
|
||
all_byte = True
|
||
for token in inner.split(","):
|
||
token = token.strip()
|
||
if not token:
|
||
raise ValueError("empty number")
|
||
if "." in token or "e" in token or "E" in token:
|
||
value = float(token)
|
||
has_float = True
|
||
all_byte = False
|
||
else:
|
||
value = int(token)
|
||
if value < 0 or value > 255:
|
||
all_byte = False
|
||
values.append(value)
|
||
if len(values) > 4096:
|
||
raise ValueError("feature too long")
|
||
|
||
if len(values) < 64:
|
||
raise ValueError("feature too short")
|
||
if all_byte and not has_float:
|
||
return bytearray(values)
|
||
return values
|
||
|
||
def parse_feature_vector(text):
|
||
text = text.strip()
|
||
if text.startswith("bytearray(") or text.startswith("b'") or text.startswith('b"'):
|
||
return parse_bytes_literal(text)
|
||
return parse_number_list(text)
|
||
|
||
HEX_CHARS = "0123456789abcdef"
|
||
|
||
def byte_to_hex(v):
|
||
return HEX_CHARS[(v >> 4) & 15] + HEX_CHARS[v & 15]
|
||
|
||
def escape_byte_values(values):
|
||
out = ""
|
||
for v in values:
|
||
v = int(v) & 0xff
|
||
if v == 92:
|
||
out += "\\\\"
|
||
elif v == 34:
|
||
out += '\\"'
|
||
elif v == 10:
|
||
out += "\\n"
|
||
elif v == 13:
|
||
out += "\\r"
|
||
elif v == 9:
|
||
out += "\\t"
|
||
elif 32 <= v <= 126:
|
||
out += chr(v)
|
||
else:
|
||
out += "\\x" + byte_to_hex(v)
|
||
return out
|
||
|
||
def feature_to_record_text(feature):
|
||
type_text = str(type(feature))
|
||
if type_text.find("bytearray") >= 0 or type_text.find("bytes") >= 0:
|
||
values = []
|
||
for v in feature:
|
||
values.append(int(v) & 0xff)
|
||
return 'bytearray(b"' + escape_byte_values(values) + '")'
|
||
return str(feature)
|
||
|
||
def write_face_record():
|
||
with open(record_path, "w") as f:
|
||
for p in peoples:
|
||
f.write(str(p.name) + '#' + feature_to_record_text(p.feature) + "\n")
|
||
|
||
def load_faces():
|
||
global peoples; peoples = []
|
||
total_count = 0
|
||
bad_count = 0
|
||
print("[FACE_DB] Loading {}".format(record_path))
|
||
try:
|
||
with open(record_path, "r") as f:
|
||
for line in f:
|
||
line = line.strip()
|
||
if not line:
|
||
continue
|
||
total_count += 1
|
||
# 使用 maxsplit=1 参数，只按第一个 '#' 分割，防止特征数据中的'#'导致错误
|
||
parts = line.split('#', 1)
|
||
if len(parts) == 2 and parts[1]:
|
||
try:
|
||
peoples.append(People(parts[0], parse_feature_vector(parts[1])))
|
||
except Exception as e_eval:
|
||
bad_count += 1
|
||
print("Feature parse error on line {} for {}: {}".format(total_count, parts[0], e_eval))
|
||
else:
|
||
bad_count += 1
|
||
print("[FACE_DB] Bad line {}: missing feature".format(total_count))
|
||
if total_count == 0:
|
||
print("[FACE_DB] recordftr.txt is empty")
|
||
print("成功加载 %d 条人脸数据 (总行:%d, 失败:%d)" % (len(peoples), total_count, bad_count))
|
||
except Exception as e: print("读取人脸数据库失败:", e)
|
||
|
||
def collect_used_face_ids():
|
||
"""收集本地已经占用的K210原始face_id，避免新增时覆盖旧人脸。"""
|
||
used = {}
|
||
|
||
for p in peoples:
|
||
name = str(p.name)
|
||
if name.startswith("ID:") and name.split(":", 1)[1].isdigit():
|
||
used[name.split(":", 1)[1]] = 1
|
||
|
||
for face_id in face_id_mapping.keys():
|
||
face_id = str(face_id)
|
||
if face_id.isdigit():
|
||
used[face_id] = 1
|
||
|
||
if ensure_local_photo_dir():
|
||
try:
|
||
for filename in os.listdir(LOCAL_FACE_PHOTO_DIR):
|
||
if filename.endswith(".jpg"):
|
||
face_id = filename[:-4]
|
||
if face_id.isdigit():
|
||
used[face_id] = 1
|
||
except Exception as e:
|
||
print("[ADD] 扫描本地照片ID失败:", e)
|
||
|
||
return used
|
||
|
||
def allocate_next_face_id():
|
||
used = collect_used_face_ids()
|
||
next_id = 1
|
||
while str(next_id) in used:
|
||
next_id += 1
|
||
print("[ADD] 已占用face_id: {}, 新face_id: {}".format(sorted(used.keys()), next_id))
|
||
return next_id
|
||
|
||
def add_face(feature, face_img=None):
|
||
new_id_num = allocate_next_face_id()
|
||
new_name = "ID:{}".format(new_id_num)
|
||
peoples.append(People(new_name, feature))
|
||
try:
|
||
if face_img is not None:
|
||
print("[PHOTO] 正在保存人脸照片并加入上传队列...")
|
||
if not capture_and_upload_face(new_id_num, face_img):
|
||
print("[PHOTO] 本地照片保存失败，取消添加人脸")
|
||
peoples.pop()
|
||
return False
|
||
|
||
with open(record_path, "a") as f:
|
||
f.write(new_name + '#' + feature_to_record_text(feature) + "\n")
|
||
print("添加成功:", new_name)
|
||
|
||
return True
|
||
except Exception as e:
|
||
print("写入文件失败:", e)
|
||
delete_local_face_photo(new_id_num)
|
||
peoples.pop()
|
||
return False
|
||
def delete_face_by_index(idx):
|
||
if not (0 <= idx < len(peoples)): return False
|
||
deleted_name = peoples[idx].name
|
||
peoples.pop(idx)
|
||
try:
|
||
write_face_record()
|
||
if deleted_name.startswith("ID:"):
|
||
delete_local_face_photo(deleted_name.split(":", 1)[1])
|
||
else:
|
||
delete_local_face_photo(deleted_name)
|
||
print("删除 %s 成功" % deleted_name); return True
|
||
except Exception as e: print("重写文件失败:", e); load_faces(); return False
|
||
|
||
# --- 5. 支持多张人脸检测的函数 (保持不变) ---
|
||
def detect_and_recognize_faces(img):
|
||
codes = kpu.run_yolo2(task_fd, img)
|
||
if not codes: return []
|
||
results = []
|
||
for item in codes:
|
||
face_cut = img.cut(item.x(), item.y(), item.w(), item.h())
|
||
face_cut_128 = face_cut.resize(128, 128); face_cut_128.pix_to_ai()
|
||
fmap = kpu.forward(task_ld, face_cut_128)
|
||
plist = fmap[:]
|
||
le=(item.x()+int(plist[0]*item.w()-10), item.y()+int(plist[1]*item.h())); re=(item.x()+int(plist[2]*item.w()), item.y()+int(plist[3]*item.h())); nose=(item.x()+int(plist[4]*item.w()), item.y()+int(plist[5]*item.h())); lm=(item.x()+int(plist[6]*item.w()), item.y()+int(plist[7]*item.h())); rm=(item.x()+int(plist[8]*item.w()), item.y()+int(plist[9]*item.h()))
|
||
src_point = [le, re, nose, lm, rm]
|
||
T = image.get_affine_transform(src_point, dst_point)
|
||
image.warp_affine_ai(img, img_face, T)
|
||
del(face_cut); del(face_cut_128)
|
||
fmap = kpu.forward(task_fe, img_face)
|
||
feature = kpu.face_encode(fmap[:])
|
||
max_score = 0; match_index = -1
|
||
for i, p in enumerate(peoples):
|
||
score = p.feature_max(feature)
|
||
if score > max_score: max_score = score; match_index = i
|
||
result_item = {'score': max_score, 'rect': item.rect(), 'feature': feature}
|
||
if max_score > 85: result_item['state'] = peoples[match_index].name
|
||
else: result_item['state'] = "stranger"
|
||
results.append(result_item)
|
||
return results
|
||
|
||
# --- 6. 主程序启动前准备 - 添加发送逻辑所需变量 ---
|
||
load_faces()
|
||
last_send_time = 0
|
||
SEND_INTERVAL_MS = 1000
|
||
last_sent_data = "" # 改为记录完整数据而不是state
|
||
last_saved_id = "" # ✨ 添加：初始化上次保存的学号
|
||
|
||
# --- 分时网络：照片上传队列操作 ---
|
||
def queue_photo_upload(face_id):
|
||
"""将本地照片ID添加到上传队列（非阻塞）"""
|
||
global photo_upload_queue
|
||
face_id = str(face_id)
|
||
if face_id in photo_upload_queue:
|
||
print("[QUEUE] 照片已在队列中: ID={}".format(face_id))
|
||
return
|
||
photo_upload_queue.append(face_id)
|
||
print("[QUEUE] 照片已加入队列: ID={}，队列长度: {}".format(face_id, len(photo_upload_queue)))
|
||
|
||
def queue_local_photos_for_upload():
|
||
"""启动时扫描SD卡照片，补传可能遗漏到服务器的照片"""
|
||
if not ensure_local_photo_dir():
|
||
return
|
||
|
||
server_photo_ids = None
|
||
if wifi_connected:
|
||
print("[QUEUE] 正在获取服务端照片列表，用于判断缺失照片...")
|
||
response = esp_http_get("/api/v1/faces/photos", 8000)
|
||
if response:
|
||
server_photo_ids = parse_photo_ids(response)
|
||
print("[QUEUE] 服务端已有照片: {} 张".format(len(server_photo_ids)))
|
||
else:
|
||
print("[QUEUE] 服务端照片列表获取失败，将本地照片全部加入补传队列")
|
||
|
||
queued = 0
|
||
skipped = 0
|
||
try:
|
||
for name in os.listdir(LOCAL_FACE_PHOTO_DIR):
|
||
if name.endswith(".jpg"):
|
||
face_id = name[:-4]
|
||
if face_id:
|
||
if server_photo_ids is not None:
|
||
server_has_photo = face_id in server_photo_ids
|
||
if server_has_photo:
|
||
skipped += 1
|
||
continue
|
||
queue_photo_upload(face_id)
|
||
queued += 1
|
||
print("[QUEUE] 本地照片补传扫描完成: queued={}, skipped={}".format(queued, skipped))
|
||
except Exception as e:
|
||
print("[QUEUE] 扫描本地照片失败:", e)
|
||
|
||
def do_network_task():
|
||
"""执行一个网络任务（每次只做一件事）"""
|
||
global photo_upload_queue, last_sync_time
|
||
|
||
# 优先处理照片上传
|
||
if len(photo_upload_queue) > 0:
|
||
face_id = photo_upload_queue.pop(0)
|
||
jpeg_data = load_local_face_photo(face_id)
|
||
if jpeg_data is None or len(jpeg_data) < 100:
|
||
print("[NET] 本地照片无效，跳过上传: ID={}".format(face_id))
|
||
return True
|
||
|
||
print("[NET] 上传照片: ID={}".format(face_id))
|
||
try:
|
||
if esp_http_post_photo(face_id, jpeg_data):
|
||
print("[NET] 照片上传完成")
|
||
else:
|
||
print("[NET] 照片上传失败，保留队列等待重试")
|
||
queue_photo_upload(face_id)
|
||
except Exception as e:
|
||
print("[NET] 上传错误:", e)
|
||
queue_photo_upload(face_id)
|
||
return True
|
||
|
||
return False
|
||
|
||
# 启动时扫描本地照片，补传可能遗漏到服务器的照片
|
||
queue_local_photos_for_upload()
|
||
|
||
# 启动时执行一次同步
|
||
print("[BOOT] 启动同步...")
|
||
if wifi_connected:
|
||
try:
|
||
sync_unified_state()
|
||
except Exception as e:
|
||
print("[BOOT] 统一同步错误:", e)
|
||
print("[BOOT] 同步完成")
|
||
else:
|
||
print("[BOOT] WiFi未连接，跳过同步")
|
||
|
||
# QT触发同步标志
|
||
sync_requested = False
|
||
last_sync_check_time = 0
|
||
|
||
def check_sync_request():
|
||
"""检查服务器是否有同步请求"""
|
||
global sync_requested
|
||
if not wifi_connected:
|
||
return False
|
||
|
||
try:
|
||
response = esp_http_get("/api/v1/sync/request", 2000)
|
||
if response and '"sync":true' in response:
|
||
print("[SYNC] 收到服务器同步请求")
|
||
sync_requested = True
|
||
# 确认收到请求
|
||
esp_http_post_json("/api/v1/sync/request/ack", '{"ack":true}', 1000)
|
||
return True
|
||
except Exception as e:
|
||
print("[SYNC] 检查同步请求错误:", e)
|
||
return False
|
||
|
||
def trigger_sync():
|
||
"""执行一次完整同步（由QT端触发）"""
|
||
global sync_requested
|
||
if not wifi_connected:
|
||
print("[SYNC] WiFi未连接，无法同步")
|
||
return False
|
||
|
||
print("[SYNC] ========== QT触发同步开始 ==========")
|
||
try:
|
||
sync_unified_state()
|
||
except Exception as e:
|
||
print("[SYNC] 统一同步错误:", e)
|
||
|
||
print("[SYNC] ========== QT触发同步完成 ==========")
|
||
sync_requested = False
|
||
return True
|
||
|
||
# --- 7. 主循环 (状态机) ---
|
||
while True:
|
||
clock.tick()
|
||
# ------------------ 模式0：人脸识别与智能通信 (多人脸 & 无脸不发送) ------------------
|
||
if key_pressed == 0:
|
||
img = sensor.snapshot()
|
||
detected_faces = detect_and_recognize_faces(img)
|
||
current_state = ""
|
||
recognized_ids = []
|
||
if not detected_faces:
|
||
LED_G.value(1); LED_R.value(1)
|
||
else:
|
||
has_stranger = False; has_known_person = False
|
||
for face in detected_faces:
|
||
rect = face['rect']
|
||
img.draw_rectangle(rect)
|
||
if face['state'] == "stranger":
|
||
img.draw_string(rect[0], rect[1], "Stranger", color=(255, 0, 0), scale=2)
|
||
recognized_ids.append("0"); has_stranger = True
|
||
else:
|
||
# 使用映射后的学号显示
|
||
display_name = get_display_name(face['state'])
|
||
img.draw_string(rect[0], rect[1], display_name, color=(0, 255, 0), scale=2)
|
||
recognized_ids.append(face['state']); has_known_person = True
|
||
if has_known_person: LED_G.value(0); LED_R.value(1)
|
||
elif has_stranger: LED_G.value(1); LED_R.value(0)
|
||
recognized_ids.sort(); current_state = ",".join(recognized_ids)
|
||
time_now = utime.ticks_ms()
|
||
if utime.ticks_diff(time_now, last_send_time) > SEND_INTERVAL_MS:
|
||
if detected_faces:
|
||
# 发送第一个识别到的人脸数据（可以改为发送得分最高的）
|
||
best_face = max(detected_faces, key=lambda x: x['score'])
|
||
|
||
if best_face['state'] == "stranger":
|
||
# 陌生人，发送UNKNOWN
|
||
msg_to_send = "UNKNOWN\r\n"
|
||
|
||
# 陌生人不保存到SD卡
|
||
last_saved_id = "" # 重置保存记录
|
||
else:
|
||
# 已识别用户，发送完整信息（STM32期望的格式）
|
||
face_id = extract_face_id(best_face['state'])
|
||
mapped_student_id = get_mapped_student_id(best_face['state'])
|
||
if not mapped_student_id:
|
||
print("[UART SEND] Face {} has no student mapping, fallback to face_id".format(face_id))
|
||
student_id = mapped_student_id if mapped_student_id else face_id
|
||
student_name = mapped_student_id if mapped_student_id else "FACE_{}".format(face_id)
|
||
confidence = best_face['score'] / 100.0
|
||
|
||
# 构造STM32期望的格式；未绑定学号时默认使用K210原始face_id。
|
||
msg_to_send = "ID:{},NAME:{},CONF:{:.2f}\r\n".format(
|
||
student_id,
|
||
student_name,
|
||
confidence
|
||
)
|
||
|
||
if msg_to_send != last_sent_data:
|
||
uart.write(msg_to_send)
|
||
print("[UART SEND] -> {}".format(msg_to_send.strip()))
|
||
last_sent_data = msg_to_send
|
||
last_send_time = time_now
|
||
else:
|
||
# 没有检测到人脸
|
||
if last_sent_data != "":
|
||
print("[STATE CHANGE] Faces disappeared. No data sent.")
|
||
last_sent_data = ""
|
||
last_saved_id = "" # 重置保存记录
|
||
last_send_time = time_now
|
||
lcd.display(img)
|
||
|
||
# ------------------ 【核心修改】模式1：添加人脸 (添加了实时框) ------------------
|
||
elif key_pressed == 1:
|
||
key_pressed = 0
|
||
last_sent_data = "" # 修改变量名
|
||
last_saved_id = "" # 重置保存记录
|
||
last_send_time = 0
|
||
print("进入添加人脸模式...")
|
||
while True:
|
||
img = sensor.snapshot()
|
||
img.draw_string(0, 0, "Add Face Mode", color=(0, 0, 255), scale=2)
|
||
img.draw_string(0, 24, "Click to Confirm", color=(0, 0, 255), scale=2)
|
||
detected_faces = detect_and_recognize_faces(img)
|
||
best_face = None
|
||
if detected_faces:
|
||
# 选出最清晰（得分最高）的脸进行操作
|
||
best_face = max(detected_faces, key=lambda x: x['score'])
|
||
|
||
if best_face:
|
||
rect = best_face['rect'] # 获取目标人脸的框
|
||
if best_face['state'] != "stranger":
|
||
# 【新】如果是已存在的用户，画一个橙色的框
|
||
img.draw_rectangle(rect, color=(255, 128, 0), thickness=2)
|
||
img.draw_string(rect[0], rect[1], "Exists!", color=(255, 128, 0), scale=2)
|
||
else:
|
||
# 【新】如果是可以添加的陌生人，画一个绿色的框
|
||
img.draw_rectangle(rect, color=(0, 255, 0), thickness=2)
|
||
img.draw_string(rect[0], rect[1], "Ready", color=(0, 255, 0), scale=2)
|
||
|
||
# 按键确认逻辑 (保持不变)
|
||
if key_pressed == 1:
|
||
key_pressed = 0
|
||
if best_face:
|
||
if best_face['state'] != "stranger":
|
||
img.draw_string(best_face['rect'][0], best_face['rect'][1] + 24, "Already exists!", color=(255, 0, 0), scale=2); LED_R.value(0)
|
||
else:
|
||
if add_face(best_face['feature'], img):
|
||
img.draw_string(best_face['rect'][0], best_face['rect'][1] + 24, "Add OK!", color=(0, 255, 0), scale=2); LED_G.value(0)
|
||
else:
|
||
img.draw_string(best_face['rect'][0], best_face['rect'][1] + 24, "Add Failed!", color=(255, 0, 0), scale=2); LED_R.value(0)
|
||
else:
|
||
img.draw_string(10, 100, "No Face!", color=(255, 0, 0), scale=2); LED_R.value(0)
|
||
lcd.display(img); utime.sleep_ms(2000); LED_R.value(1); LED_G.value(1); break
|
||
if key_pressed == 2:
|
||
key_pressed = 0; break # 长按退出
|
||
lcd.display(img)
|
||
print("退出添加人脸模式")
|
||
|
||
# ------------------ 模式2：删除人脸 (保持不变) ------------------
|
||
elif key_pressed == 2:
|
||
key_pressed = 0
|
||
last_sent_data = "" # 修改变量名
|
||
last_saved_id = "" # 重置保存记录
|
||
last_send_time = 0
|
||
print("进入删除人脸模式...")
|
||
select_index = -1
|
||
while True:
|
||
img = image.Image(); img.clear()
|
||
img.draw_string(10, 10, "Delete Mode", color=(255, 0, 0), scale=2); img.draw_string(10, 40, "Click=Next, Long Press=Confirm", scale=1.8)
|
||
if key_pressed == 1:
|
||
key_pressed = 0; select_index += 1
|
||
if select_index >= len(peoples): select_index = -1
|
||
if select_index == -1: img.draw_string(50, 100, "-> Cancel", color=(0, 255, 0), scale=2)
|
||
else: img.draw_string(50, 100, "-> Del: {}".format(peoples[select_index].name), color=(255, 128, 0), scale=2)
|
||
if key_pressed == 2:
|
||
key_pressed = 0
|
||
if select_index != -1:
|
||
if delete_face_by_index(select_index):
|
||
img.clear(); img.draw_string(50, 100, "Delete Success!", color=(0, 255, 0), scale=2); LED_G.value(0)
|
||
else:
|
||
img.clear(); img.draw_string(50, 100, "Delete Failed!", color=(255, 0, 0), scale=2); LED_R.value(0)
|
||
else:
|
||
img.clear(); img.draw_string(50, 100, "Canceled", color=(255, 255, 0), scale=2)
|
||
lcd.display(img); utime.sleep_ms(2000); LED_G.value(1); LED_R.value(1); load_faces(); break
|
||
lcd.display(img)
|
||
print("退出删除人脸模式")
|
||
|
||
# ------------------ 模式3：删除全部人脸 (长按5秒) ------------------
|
||
elif key_pressed == 3:
|
||
key_pressed = 0
|
||
print("进入删除全部人脸模式...")
|
||
img = image.Image(); img.clear()
|
||
img.draw_string(10, 10, "DELETE ALL FACES?", color=(255, 0, 0), scale=2)
|
||
img.draw_string(10, 50, "Count: {}".format(len(peoples)), color=(255, 255, 0), scale=2)
|
||
img.draw_string(10, 90, "Click=Confirm", color=(255, 128, 0), scale=1.8)
|
||
img.draw_string(10, 120, "Long Press=Cancel", color=(0, 255, 0), scale=1.8)
|
||
lcd.display(img)
|
||
LED_R.value(0) # 红灯警告
|
||
|
||
# 等待用户确认
|
||
confirm_timeout = utime.ticks_ms()
|
||
while utime.ticks_diff(utime.ticks_ms(), confirm_timeout) < 10000: # 10秒超时
|
||
if key_pressed == 1: # 短按确认删除
|
||
key_pressed = 0
|
||
img.clear()
|
||
img.draw_string(30, 80, "Deleting...", color=(255, 0, 0), scale=2)
|
||
lcd.display(img)
|
||
if delete_all_faces():
|
||
img.clear()
|
||
img.draw_string(20, 80, "All Deleted!", color=(0, 255, 0), scale=2)
|
||
LED_R.value(1); LED_G.value(0)
|
||
else:
|
||
img.clear()
|
||
img.draw_string(20, 80, "Delete Failed!", color=(255, 0, 0), scale=2)
|
||
lcd.display(img)
|
||
utime.sleep_ms(2000)
|
||
break
|
||
elif key_pressed == 2 or key_pressed == 3: # 长按取消
|
||
key_pressed = 0
|
||
img.clear()
|
||
img.draw_string(50, 80, "Canceled", color=(255, 255, 0), scale=2)
|
||
lcd.display(img)
|
||
utime.sleep_ms(1500)
|
||
break
|
||
utime.sleep_ms(50)
|
||
|
||
LED_R.value(1); LED_G.value(1)
|
||
print("退出删除全部人脸模式")
|
||
|
||
# 分时网络处理：每N帧检查一次网络任务（只处理照片上传和同步请求）
|
||
frames_since_network += 1
|
||
if frames_since_network >= NETWORK_FRAME_INTERVAL:
|
||
frames_since_network = 0
|
||
# 优先处理照片上传队列
|
||
if len(photo_upload_queue) > 0:
|
||
do_network_task()
|
||
# 检查是否有同步请求待执行
|
||
elif sync_requested:
|
||
trigger_sync()
|
||
# 定期检查服务器是否有新的同步请求
|
||
elif wifi_connected and utime.ticks_diff(utime.ticks_ms(), last_sync_check_time) > SYNC_CHECK_INTERVAL_MS:
|
||
last_sync_check_time = utime.ticks_ms()
|
||
check_sync_request()
|
||
|
||
gc.collect()
|
||
|