2007 lines
83 KiB
Python
2007 lines
83 KiB
Python
"""硬件测试治具 v2 - 多产品 Profile 架构
|
||
|
||
- 顶部产品下拉切换不同被测产品
|
||
- 测试项可在 UI 内增删改、改类型、改正则
|
||
- 5 种测试项类型：自动关键词 / 自动抓值 / 人工勾选 / 人工多选 / 人工文本
|
||
- 报告按产品+日期分文件存到 reports/
|
||
"""
|
||
|
||
import csv
|
||
import json
|
||
import os
|
||
import queue
|
||
import re
|
||
import shutil
|
||
import sys
|
||
import threading
|
||
import tkinter as tk
|
||
from datetime import datetime
|
||
from pathlib import Path
|
||
from tkinter import filedialog, messagebox, scrolledtext, simpledialog, ttk
|
||
|
||
import serial
|
||
import serial.tools.list_ports
|
||
|
||
try:
|
||
from openpyxl import Workbook
|
||
from openpyxl.styles import Alignment, Font
|
||
HAS_OPENPYXL = True
|
||
except ImportError:
|
||
HAS_OPENPYXL = False
|
||
|
||
APP_VERSION = "v2.1.1"
|
||
|
||
if getattr(sys, "frozen", False):
|
||
BASE = Path(sys.executable).parent
|
||
else:
|
||
BASE = Path(__file__).parent
|
||
|
||
PROFILES_DIR = BASE / "profiles"
|
||
REPORTS_DIR = BASE / "reports"
|
||
SETTINGS_FILE = BASE / "settings.json"
|
||
|
||
PROFILES_DIR.mkdir(exist_ok=True)
|
||
REPORTS_DIR.mkdir(exist_ok=True)
|
||
|
||
TYPE_LABELS = {
|
||
"auto": "自动-关键词命中",
|
||
"auto_value": "自动-抓取数值",
|
||
"manual": "人工-勾选 ✓/✗",
|
||
"manual_choice": "人工-多选下拉",
|
||
"manual_text": "人工-填写文本",
|
||
}
|
||
TYPES_ORDER = ["auto", "auto_value", "manual", "manual_choice", "manual_text"]
|
||
|
||
FONT_SIZES = {"小": 10, "中": 12, "大": 14, "特大": 18, "超大": 22}
|
||
|
||
DEFAULT_PROFILE = {
|
||
"product_name": "ESP32-S3-Airhub",
|
||
"mac_pattern": r"Wi-Fi MAC Address:\s+([0-9a-fA-F:]+)",
|
||
"sn": {"prefix": "SN", "next_number": 1, "digits": 6, "step": 1},
|
||
"tests": [
|
||
{"id": "test_mode", "name": "进入测试模式", "type": "auto",
|
||
"pattern": r"生产测试模式已启用"},
|
||
{"id": "story_btn", "name": "故事按键", "type": "auto",
|
||
"pattern": r"故事按键.*?被按下"},
|
||
{"id": "boot_btn", "name": "BOOT/打断按键", "type": "auto",
|
||
"pattern": r"BOOT按键.*?被按下"},
|
||
{"id": "audio_done", "name": "音频播放完成（自动）", "type": "auto",
|
||
"pattern": r"音频播放完成"},
|
||
{"id": "speaker", "name": "喇叭音质", "type": "manual",
|
||
"hint": "听播报是否清晰、无杂音"},
|
||
{"id": "mic_wakeup", "name": "麦克风唤醒", "type": "manual",
|
||
"hint": "喊唤醒词，板载 LED 应闪烁"},
|
||
{"id": "touch", "name": "触摸", "type": "manual",
|
||
"hint": "摸触摸板，听喇叭播报「触摸被按下」"},
|
||
{"id": "battery", "name": "电量", "type": "manual_text",
|
||
"hint": "听喇叭播报「电量：xx%」，填写听到的百分比"},
|
||
{"id": "gyro", "name": "陀螺仪", "type": "manual",
|
||
"hint": "晃动设备，听喇叭播报「陀螺仪正常」"},
|
||
{"id": "charge", "name": "充电灯", "type": "manual_choice",
|
||
"choices": ["红-充电中", "绿-已充满", "无-异常"]},
|
||
]
|
||
}
|
||
|
||
DEFAULT_SETTINGS = {
|
||
"current_profile": "ESP32-S3-Airhub",
|
||
"serial": {"port": "", "baudrate": 115200},
|
||
"operator": "",
|
||
"font_size_label": "中",
|
||
"batch_no": "1",
|
||
"batch_size": 600,
|
||
"auto_clear_log_on_disconnect": False,
|
||
}
|
||
|
||
|
||
# ----- 配置 IO -----
|
||
def load_settings():
|
||
if SETTINGS_FILE.exists():
|
||
with open(SETTINGS_FILE, "r", encoding="utf-8") as f:
|
||
s = json.load(f)
|
||
for k, v in DEFAULT_SETTINGS.items():
|
||
s.setdefault(k, v)
|
||
return s
|
||
save_settings(DEFAULT_SETTINGS)
|
||
return json.loads(json.dumps(DEFAULT_SETTINGS))
|
||
|
||
|
||
def save_settings(s):
|
||
with open(SETTINGS_FILE, "w", encoding="utf-8") as f:
|
||
json.dump(s, f, ensure_ascii=False, indent=2)
|
||
|
||
|
||
def profile_path(name):
|
||
safe = re.sub(r"[^\w\-.]+", "_", name)
|
||
return PROFILES_DIR / f"{safe}.json"
|
||
|
||
|
||
def list_profiles():
|
||
names = []
|
||
for p in PROFILES_DIR.glob("*.json"):
|
||
try:
|
||
with open(p, "r", encoding="utf-8") as f:
|
||
d = json.load(f)
|
||
names.append(d.get("product_name", p.stem))
|
||
except Exception:
|
||
continue
|
||
names.sort()
|
||
return names
|
||
|
||
|
||
def load_profile(name):
|
||
p = profile_path(name)
|
||
if p.exists():
|
||
with open(p, "r", encoding="utf-8") as f:
|
||
d = json.load(f)
|
||
d.setdefault("product_name", name)
|
||
d.setdefault("mac_pattern", DEFAULT_PROFILE["mac_pattern"])
|
||
d.setdefault("sn", dict(DEFAULT_PROFILE["sn"]))
|
||
d.setdefault("tests", [])
|
||
return d
|
||
return None
|
||
|
||
|
||
def save_profile(prof):
|
||
p = profile_path(prof["product_name"])
|
||
with open(p, "w", encoding="utf-8") as f:
|
||
json.dump(prof, f, ensure_ascii=False, indent=2)
|
||
|
||
|
||
def ensure_default_profile():
|
||
if not list_profiles():
|
||
save_profile(DEFAULT_PROFILE)
|
||
|
||
|
||
# ----- 测试项编辑对话框 -----
|
||
class TestEditor(tk.Toplevel):
|
||
def __init__(self, parent, profile, on_save):
|
||
super().__init__(parent)
|
||
self.title(f"编辑测试项 - {profile['product_name']}（所有修改实时同步到主界面）")
|
||
self.minsize(1100, 600)
|
||
self.transient(parent)
|
||
self.profile = json.loads(json.dumps(profile))
|
||
self.on_save = on_save
|
||
self.current_idx = None
|
||
|
||
self._build()
|
||
self._refresh_list()
|
||
self.protocol("WM_DELETE_WINDOW", self._save_close)
|
||
|
||
# 默认尺寸 + 屏幕居中（屏幕较小则占 90% 宽度）
|
||
self.update_idletasks()
|
||
sw = self.winfo_screenwidth()
|
||
sh = self.winfo_screenheight()
|
||
w = min(1500, int(sw * 0.92))
|
||
h = min(800, int(sh * 0.85))
|
||
x = max(0, (sw - w) // 2)
|
||
y = max(0, (sh - h) // 2)
|
||
self.geometry(f"{w}x{h}+{x}+{y}")
|
||
|
||
def _build(self):
|
||
left = ttk.Frame(self, padding=8)
|
||
left.pack(side="left", fill="both", expand=True)
|
||
|
||
cols = ("name", "type", "pattern_or_choices")
|
||
self.tree = ttk.Treeview(left, columns=cols, show="headings", height=20)
|
||
self.tree.heading("name", text="名称")
|
||
self.tree.heading("type", text="类型")
|
||
self.tree.heading("pattern_or_choices", text="正则 / 选项 / 提示")
|
||
self.tree.column("name", width=180)
|
||
self.tree.column("type", width=130)
|
||
self.tree.column("pattern_or_choices", width=340)
|
||
self.tree.pack(fill="both", expand=True)
|
||
self.tree.bind("<<TreeviewSelect>>", self._on_select)
|
||
|
||
btns = ttk.Frame(left)
|
||
btns.pack(fill="x", pady=6)
|
||
ttk.Button(btns, text="+ 新增", command=self._add).pack(side="left", padx=2)
|
||
ttk.Button(btns, text="- 删除", command=self._del).pack(side="left", padx=2)
|
||
ttk.Button(btns, text="↑ 上移", command=lambda: self._move(-1)).pack(side="left", padx=2)
|
||
ttk.Button(btns, text="↓ 下移", command=lambda: self._move(1)).pack(side="left", padx=2)
|
||
ttk.Label(btns, text=" MAC 提取正则:").pack(side="left", padx=(10, 2))
|
||
self.mac_var = tk.StringVar(value=self.profile.get("mac_pattern", ""))
|
||
mac_entry = ttk.Entry(btns, textvariable=self.mac_var)
|
||
mac_entry.pack(side="left", padx=2, fill="x", expand=True)
|
||
mac_entry.bind("<FocusOut>", lambda _e: self._save_mac())
|
||
|
||
right = ttk.LabelFrame(self, text=" 编辑当前项 ", padding=10)
|
||
right.pack(side="right", fill="y", padx=8, pady=8)
|
||
|
||
ttk.Label(right, text="ID（英文，唯一）:").grid(row=0, column=0, sticky="w", pady=3)
|
||
self.id_var = tk.StringVar()
|
||
ttk.Entry(right, textvariable=self.id_var, width=26).grid(row=0, column=1, pady=3)
|
||
|
||
ttk.Label(right, text="名称（显示在测试列表）:").grid(row=1, column=0, sticky="w", pady=3)
|
||
self.name_var = tk.StringVar()
|
||
ttk.Entry(right, textvariable=self.name_var, width=26).grid(row=1, column=1, pady=3)
|
||
|
||
ttk.Label(right, text="类型:").grid(row=2, column=0, sticky="w", pady=3)
|
||
self.type_var = tk.StringVar()
|
||
self.type_cb = ttk.Combobox(right, textvariable=self.type_var,
|
||
values=[TYPE_LABELS[t] for t in TYPES_ORDER],
|
||
state="readonly", width=24)
|
||
self.type_cb.grid(row=2, column=1, pady=3)
|
||
self.type_cb.bind("<<ComboboxSelected>>", self._on_type_change)
|
||
|
||
ttk.Label(right, text="正则（自动类型用）:").grid(row=3, column=0, sticky="nw", pady=3)
|
||
self.pattern_var = tk.StringVar()
|
||
self.pattern_entry = ttk.Entry(right, textvariable=self.pattern_var, width=26)
|
||
self.pattern_entry.grid(row=3, column=1, pady=3)
|
||
|
||
ttk.Label(right, text="测试匹配:").grid(row=4, column=0, sticky="nw", pady=3)
|
||
tm = ttk.Frame(right)
|
||
tm.grid(row=4, column=1, sticky="we", pady=3)
|
||
self.test_input_var = tk.StringVar()
|
||
ttk.Entry(tm, textvariable=self.test_input_var, width=18).pack(side="left")
|
||
ttk.Button(tm, text="试", width=4, command=self._test_regex).pack(side="left", padx=4)
|
||
self.test_result_var = tk.StringVar(value="（输入一行日志测试）")
|
||
ttk.Label(right, textvariable=self.test_result_var,
|
||
foreground="darkgreen", wraplength=220).grid(row=5, column=1, sticky="w")
|
||
|
||
ttk.Label(right, text="选项（多选下拉用，|分隔）:").grid(row=6, column=0, sticky="w", pady=3)
|
||
self.choices_var = tk.StringVar()
|
||
ttk.Entry(right, textvariable=self.choices_var, width=26).grid(row=6, column=1, pady=3)
|
||
|
||
ttk.Label(right, text="提示语（可选）:").grid(row=7, column=0, sticky="w", pady=3)
|
||
self.hint_var = tk.StringVar()
|
||
ttk.Entry(right, textvariable=self.hint_var, width=26).grid(row=7, column=1, pady=3)
|
||
|
||
ttk.Button(right, text="💾 保存此项修改",
|
||
command=self._apply).grid(row=8, column=1, pady=8, sticky="e")
|
||
ttk.Label(right, text="（每次改完点这里立即同步主界面）",
|
||
foreground="gray", font=("Segoe UI", 8)).grid(row=9, column=1, sticky="e")
|
||
|
||
bottom = ttk.Frame(self)
|
||
bottom.pack(side="bottom", fill="x", padx=8, pady=8)
|
||
ttk.Button(bottom, text="完成 / 关闭",
|
||
command=self._save_close).pack(side="right", padx=(8, 0))
|
||
|
||
def _type_value_to_key(self, label):
|
||
for k, v in TYPE_LABELS.items():
|
||
if v == label:
|
||
return k
|
||
return "auto"
|
||
|
||
def _on_type_change(self, _e=None):
|
||
# 根据类型置灰对应输入
|
||
self._toggle_inputs()
|
||
|
||
def _toggle_inputs(self):
|
||
t = self._type_value_to_key(self.type_var.get())
|
||
self.pattern_entry.config(state="normal" if t in ("auto", "auto_value") else "disabled")
|
||
|
||
def _refresh_list(self):
|
||
for it in self.tree.get_children():
|
||
self.tree.delete(it)
|
||
for i, t in enumerate(self.profile["tests"]):
|
||
extra = ""
|
||
if t["type"] in ("auto", "auto_value"):
|
||
extra = t.get("pattern", "")
|
||
elif t["type"] == "manual_choice":
|
||
extra = " | ".join(t.get("choices", []))
|
||
elif t["type"] in ("manual", "manual_text"):
|
||
extra = t.get("hint", "")
|
||
self.tree.insert("", "end", iid=str(i),
|
||
values=(t.get("name", ""), TYPE_LABELS.get(t["type"], t["type"]), extra))
|
||
|
||
def _on_select(self, _e=None):
|
||
sel = self.tree.selection()
|
||
if not sel:
|
||
return
|
||
idx = int(sel[0])
|
||
# 切到另一项前，先静默保存当前正在编辑的项
|
||
if self.current_idx is not None and self.current_idx != idx:
|
||
try:
|
||
self._apply_silent()
|
||
except Exception:
|
||
pass
|
||
self.current_idx = idx
|
||
t = self.profile["tests"][idx]
|
||
self.id_var.set(t.get("id", ""))
|
||
self.name_var.set(t.get("name", ""))
|
||
self.type_var.set(TYPE_LABELS.get(t["type"], TYPE_LABELS["auto"]))
|
||
self.pattern_var.set(t.get("pattern", ""))
|
||
self.choices_var.set("|".join(t.get("choices", [])))
|
||
self.hint_var.set(t.get("hint", ""))
|
||
self.test_result_var.set("（输入一行日志测试）")
|
||
self._toggle_inputs()
|
||
|
||
def _push(self):
|
||
"""把当前编辑后的 profile 推送到主程序"""
|
||
self.profile["mac_pattern"] = self.mac_var.get().strip() or DEFAULT_PROFILE["mac_pattern"]
|
||
self.on_save(json.loads(json.dumps(self.profile)))
|
||
|
||
def _save_mac(self):
|
||
self._push()
|
||
|
||
def _add(self):
|
||
existing = {t["id"] for t in self.profile["tests"]}
|
||
n = len(self.profile["tests"]) + 1
|
||
new_id = f"item_{n}"
|
||
while new_id in existing:
|
||
n += 1
|
||
new_id = f"item_{n}"
|
||
self.profile["tests"].append({"id": new_id, "name": "新测试项", "type": "manual", "hint": ""})
|
||
self._refresh_list()
|
||
self.tree.selection_set(str(len(self.profile["tests"]) - 1))
|
||
self._on_select()
|
||
self._push()
|
||
|
||
def _del(self):
|
||
if self.current_idx is None:
|
||
return
|
||
if not messagebox.askyesno("确认", "删除当前测试项？", parent=self):
|
||
return
|
||
del self.profile["tests"][self.current_idx]
|
||
self.current_idx = None
|
||
self._refresh_list()
|
||
self._push()
|
||
|
||
def _move(self, delta):
|
||
if self.current_idx is None:
|
||
return
|
||
new_idx = self.current_idx + delta
|
||
tests = self.profile["tests"]
|
||
if 0 <= new_idx < len(tests):
|
||
tests[self.current_idx], tests[new_idx] = tests[new_idx], tests[self.current_idx]
|
||
self.current_idx = new_idx
|
||
self._refresh_list()
|
||
self.tree.selection_set(str(new_idx))
|
||
self._push()
|
||
|
||
def _apply_silent(self):
|
||
"""切换列表项前的静默保存，错误不弹窗"""
|
||
if self.current_idx is None:
|
||
return
|
||
tid = self.id_var.get().strip()
|
||
name = self.name_var.get().strip()
|
||
if not tid or not name:
|
||
return
|
||
ttype = self._type_value_to_key(self.type_var.get())
|
||
for i, t in enumerate(self.profile["tests"]):
|
||
if i != self.current_idx and t["id"] == tid:
|
||
return
|
||
item = {"id": tid, "name": name, "type": ttype}
|
||
if ttype in ("auto", "auto_value"):
|
||
pat = self.pattern_var.get().strip()
|
||
if not pat:
|
||
return
|
||
try:
|
||
re.compile(pat)
|
||
except re.error:
|
||
return
|
||
item["pattern"] = pat
|
||
if ttype == "manual_choice":
|
||
choices = [c.strip() for c in self.choices_var.get().split("|") if c.strip()]
|
||
if len(choices) < 2:
|
||
return
|
||
item["choices"] = choices
|
||
hint = self.hint_var.get().strip()
|
||
if hint:
|
||
item["hint"] = hint
|
||
self.profile["tests"][self.current_idx] = item
|
||
self._refresh_list()
|
||
self._push()
|
||
|
||
def _apply(self):
|
||
if self.current_idx is None:
|
||
messagebox.showinfo("提示", "请先选中左边列表中的项", parent=self)
|
||
return
|
||
tid = self.id_var.get().strip()
|
||
name = self.name_var.get().strip()
|
||
if not tid or not name:
|
||
messagebox.showwarning("提示", "ID 和名称不能为空", parent=self)
|
||
return
|
||
ttype = self._type_value_to_key(self.type_var.get())
|
||
# 检查 ID 唯一
|
||
for i, t in enumerate(self.profile["tests"]):
|
||
if i != self.current_idx and t["id"] == tid:
|
||
messagebox.showwarning("提示", f"ID '{tid}' 已被其他项使用", parent=self)
|
||
return
|
||
item = {"id": tid, "name": name, "type": ttype}
|
||
if ttype in ("auto", "auto_value"):
|
||
pat = self.pattern_var.get().strip()
|
||
if not pat:
|
||
messagebox.showwarning("提示", "自动类型必须填正则", parent=self)
|
||
return
|
||
try:
|
||
re.compile(pat)
|
||
except re.error as e:
|
||
messagebox.showwarning("正则错误", str(e), parent=self)
|
||
return
|
||
item["pattern"] = pat
|
||
if ttype == "manual_choice":
|
||
choices = [c.strip() for c in self.choices_var.get().split("|") if c.strip()]
|
||
if len(choices) < 2:
|
||
messagebox.showwarning("提示", "至少需要 2 个选项，用 | 分隔", parent=self)
|
||
return
|
||
item["choices"] = choices
|
||
hint = self.hint_var.get().strip()
|
||
if hint:
|
||
item["hint"] = hint
|
||
self.profile["tests"][self.current_idx] = item
|
||
self._refresh_list()
|
||
self.tree.selection_set(str(self.current_idx))
|
||
self._push()
|
||
|
||
def _test_regex(self):
|
||
pat = self.pattern_var.get().strip()
|
||
line = self.test_input_var.get()
|
||
if not pat or not line:
|
||
return
|
||
try:
|
||
m = re.search(pat, line)
|
||
if m:
|
||
self.test_result_var.set(f"✅ 命中: {m.groups() if m.groups() else m.group(0)}")
|
||
else:
|
||
self.test_result_var.set("❌ 未命中")
|
||
except re.error as e:
|
||
self.test_result_var.set(f"正则错误: {e}")
|
||
|
||
def _save_close(self):
|
||
# 关闭前如果右边面板有未点"保存此项修改"的改动，尝试自动保存
|
||
if self.current_idx is not None:
|
||
try:
|
||
self._apply()
|
||
except Exception:
|
||
pass
|
||
self._push()
|
||
self.destroy()
|
||
|
||
|
||
class QuickItemEditor(tk.Toplevel):
|
||
"""单条测试项快速编辑器 - 从主界面 + / ✏ 按钮调起"""
|
||
|
||
def __init__(self, parent, profile, item, on_save, index=None, on_delete=None):
|
||
super().__init__(parent)
|
||
self.title("编辑测试项" if item else "添加测试项")
|
||
self.geometry("500x430")
|
||
self.transient(parent)
|
||
self.grab_set()
|
||
self.profile = profile
|
||
self.index = index
|
||
self.on_save = on_save
|
||
self.on_delete = on_delete
|
||
|
||
if item:
|
||
self.orig_id = item["id"]
|
||
init = item
|
||
else:
|
||
self.orig_id = None
|
||
existing = {t["id"] for t in profile["tests"]}
|
||
n = len(profile["tests"]) + 1
|
||
new_id = f"item_{n}"
|
||
while new_id in existing:
|
||
n += 1
|
||
new_id = f"item_{n}"
|
||
init = {"id": new_id, "name": "新测试项", "type": "manual", "hint": ""}
|
||
|
||
self._build(init)
|
||
|
||
def _build(self, init):
|
||
f = ttk.Frame(self, padding=12)
|
||
f.pack(fill="both", expand=True)
|
||
|
||
ttk.Label(f, text="名称（显示在测试列表）:").grid(row=0, column=0, sticky="w", pady=4)
|
||
self.name_var = tk.StringVar(value=init.get("name", ""))
|
||
ttk.Entry(f, textvariable=self.name_var, width=36).grid(row=0, column=1, pady=4, sticky="we")
|
||
|
||
ttk.Label(f, text="ID（内部唯一，英文）:").grid(row=1, column=0, sticky="w", pady=4)
|
||
self.id_var = tk.StringVar(value=init.get("id", ""))
|
||
ttk.Entry(f, textvariable=self.id_var, width=36).grid(row=1, column=1, pady=4, sticky="we")
|
||
|
||
ttk.Label(f, text="类型:").grid(row=2, column=0, sticky="w", pady=4)
|
||
self.type_var = tk.StringVar(value=TYPE_LABELS.get(init.get("type", "manual")))
|
||
type_cb = ttk.Combobox(f, textvariable=self.type_var,
|
||
values=[TYPE_LABELS[t] for t in TYPES_ORDER],
|
||
state="readonly", width=34)
|
||
type_cb.grid(row=2, column=1, pady=4, sticky="we")
|
||
type_cb.bind("<<ComboboxSelected>>", lambda _e: self._toggle_fields())
|
||
|
||
ttk.Label(f, text="正则（自动类型用）:").grid(row=3, column=0, sticky="w", pady=4)
|
||
self.pattern_var = tk.StringVar(value=init.get("pattern", ""))
|
||
self.pattern_entry = ttk.Entry(f, textvariable=self.pattern_var, width=36)
|
||
self.pattern_entry.grid(row=3, column=1, pady=4, sticky="we")
|
||
|
||
ttk.Label(f, text="试匹配（贴一行日志）:").grid(row=4, column=0, sticky="w", pady=4)
|
||
tm = ttk.Frame(f)
|
||
tm.grid(row=4, column=1, pady=4, sticky="we")
|
||
self.test_input_var = tk.StringVar()
|
||
ttk.Entry(tm, textvariable=self.test_input_var, width=24).pack(side="left")
|
||
ttk.Button(tm, text="试", width=4, command=self._test_regex).pack(side="left", padx=4)
|
||
self.test_result_var = tk.StringVar(value="")
|
||
ttk.Label(f, textvariable=self.test_result_var, foreground="darkgreen",
|
||
wraplength=300).grid(row=5, column=1, sticky="w")
|
||
|
||
ttk.Label(f, text="多选项（| 分隔）:").grid(row=6, column=0, sticky="w", pady=4)
|
||
self.choices_var = tk.StringVar(value="|".join(init.get("choices", [])))
|
||
self.choices_entry = ttk.Entry(f, textvariable=self.choices_var, width=36)
|
||
self.choices_entry.grid(row=6, column=1, pady=4, sticky="we")
|
||
|
||
ttk.Label(f, text="提示语（可选）:").grid(row=7, column=0, sticky="w", pady=4)
|
||
self.hint_var = tk.StringVar(value=init.get("hint", ""))
|
||
ttk.Entry(f, textvariable=self.hint_var, width=36).grid(row=7, column=1, pady=4, sticky="we")
|
||
|
||
# 按钮
|
||
btns = ttk.Frame(f)
|
||
btns.grid(row=8, column=0, columnspan=2, sticky="we", pady=12)
|
||
if self.on_delete is not None:
|
||
ttk.Button(btns, text="🗑 删除此项", command=self._delete).pack(side="left")
|
||
ttk.Button(btns, text="取消", command=self.destroy).pack(side="right", padx=4)
|
||
ttk.Button(btns, text="✅ 保存", command=self._save).pack(side="right", padx=4)
|
||
|
||
f.columnconfigure(1, weight=1)
|
||
self._toggle_fields()
|
||
|
||
def _type_key(self):
|
||
for k, v in TYPE_LABELS.items():
|
||
if v == self.type_var.get():
|
||
return k
|
||
return "manual"
|
||
|
||
def _toggle_fields(self):
|
||
t = self._type_key()
|
||
self.pattern_entry.config(state="normal" if t in ("auto", "auto_value") else "disabled")
|
||
self.choices_entry.config(state="normal" if t == "manual_choice" else "disabled")
|
||
|
||
def _test_regex(self):
|
||
pat = self.pattern_var.get().strip()
|
||
line = self.test_input_var.get()
|
||
if not pat or not line:
|
||
self.test_result_var.set("（要先填正则和一行日志）")
|
||
return
|
||
try:
|
||
m = re.search(pat, line)
|
||
if m:
|
||
groups = m.groups() if m.groups() else (m.group(0),)
|
||
self.test_result_var.set(f"✅ 命中: {groups}")
|
||
else:
|
||
self.test_result_var.set("❌ 未命中")
|
||
except re.error as e:
|
||
self.test_result_var.set(f"正则错误: {e}")
|
||
|
||
def _save(self):
|
||
name = self.name_var.get().strip()
|
||
tid = self.id_var.get().strip()
|
||
if not name or not tid:
|
||
messagebox.showwarning("提示", "名称和 ID 不能为空", parent=self)
|
||
return
|
||
# ID 唯一性
|
||
for t in self.profile["tests"]:
|
||
if t["id"] == tid and t["id"] != self.orig_id:
|
||
messagebox.showwarning("提示", f"ID '{tid}' 已被其他项使用", parent=self)
|
||
return
|
||
|
||
ttype = self._type_key()
|
||
item = {"id": tid, "name": name, "type": ttype}
|
||
|
||
if ttype in ("auto", "auto_value"):
|
||
pat = self.pattern_var.get().strip()
|
||
if not pat:
|
||
messagebox.showwarning("提示", "自动类型必须填正则", parent=self)
|
||
return
|
||
try:
|
||
re.compile(pat)
|
||
except re.error as e:
|
||
messagebox.showwarning("正则错误", str(e), parent=self)
|
||
return
|
||
item["pattern"] = pat
|
||
if ttype == "manual_choice":
|
||
choices = [c.strip() for c in self.choices_var.get().split("|") if c.strip()]
|
||
if len(choices) < 2:
|
||
messagebox.showwarning("提示", "至少要 2 个选项，用 | 分隔", parent=self)
|
||
return
|
||
item["choices"] = choices
|
||
|
||
hint = self.hint_var.get().strip()
|
||
if hint:
|
||
item["hint"] = hint
|
||
|
||
self.on_save(item, self.index)
|
||
self.destroy()
|
||
|
||
def _delete(self):
|
||
if not messagebox.askyesno("确认", "删除此测试项？\n（不会影响已保存的报告 CSV）", parent=self):
|
||
return
|
||
if self.on_delete:
|
||
self.on_delete()
|
||
self.destroy()
|
||
|
||
|
||
# ----- 主程序 -----
|
||
class TestJig:
|
||
def __init__(self, root):
|
||
self.root = root
|
||
self.root.title("产品-硬件入库测试工具")
|
||
self._set_window_icon()
|
||
self.root.geometry("1240x820")
|
||
|
||
ensure_default_profile()
|
||
self.settings = load_settings()
|
||
self.font_size_pt = FONT_SIZES.get(self.settings.get("font_size_label", "中"), 12)
|
||
|
||
names = list_profiles()
|
||
cur = self.settings.get("current_profile")
|
||
if cur not in names:
|
||
cur = names[0]
|
||
self.settings["current_profile"] = cur
|
||
save_settings(self.settings)
|
||
self.profile = load_profile(cur)
|
||
|
||
self.ser = None
|
||
self.ser_running = False
|
||
self.log_q = queue.Queue()
|
||
|
||
self.current_mac = None
|
||
self.test_widgets = {}
|
||
self._replace_mac = None # 标记本台保存时要覆盖的旧 MAC（维修重测）
|
||
self._replace_sn = None # 标记本台保存时要覆盖的旧 SN（复用失败 SN）
|
||
self._mac_seen_in_session = set() # 本会话已询问过的 MAC，避免反复弹窗
|
||
|
||
self._build_ui()
|
||
self.reset_state()
|
||
self.root.after(80, self._drain_log_queue)
|
||
self.root.protocol("WM_DELETE_WINDOW", self._on_close)
|
||
|
||
# ---------- UI ----------
|
||
def _build_ui(self):
|
||
# 第一条：产品切换
|
||
prod_bar = ttk.Frame(self.root, padding=(8, 6, 8, 3))
|
||
prod_bar.pack(fill="x")
|
||
ttk.Label(prod_bar, text="产品:", font=("Segoe UI", 10, "bold")).pack(side="left")
|
||
self.profile_var = tk.StringVar(value=self.profile["product_name"])
|
||
self.profile_cb = ttk.Combobox(prod_bar, textvariable=self.profile_var,
|
||
values=list_profiles(), state="readonly", width=22)
|
||
self.profile_cb.pack(side="left", padx=6)
|
||
self.profile_cb.bind("<<ComboboxSelected>>", self._on_profile_change)
|
||
ttk.Button(prod_bar, text="📝 编辑测试项",
|
||
command=self._open_editor).pack(side="left", padx=4)
|
||
ttk.Button(prod_bar, text="➕ 新建产品",
|
||
command=self._new_profile).pack(side="left", padx=4)
|
||
ttk.Button(prod_bar, text="📋 复制当前",
|
||
command=self._copy_profile).pack(side="left", padx=4)
|
||
ttk.Button(prod_bar, text="✏ 重命名",
|
||
command=self._rename_profile).pack(side="left", padx=4)
|
||
ttk.Button(prod_bar, text="🗑 删除当前",
|
||
command=self._delete_profile).pack(side="left", padx=4)
|
||
ttk.Button(prod_bar, text="📤 导出 JSON",
|
||
command=self._export_profile).pack(side="left", padx=4)
|
||
ttk.Button(prod_bar, text="📥 导入 JSON",
|
||
command=self._import_profile).pack(side="left", padx=4)
|
||
ttk.Label(prod_bar, text=APP_VERSION, foreground="#888",
|
||
font=("Segoe UI", 10, "bold")).pack(side="right", padx=8)
|
||
|
||
# 第二条：串口
|
||
ser_outer = ttk.Frame(self.root, padding=(8, 3, 8, 3))
|
||
ser_outer.pack(fill="x")
|
||
ser_bar = ttk.Frame(ser_outer)
|
||
ser_bar.pack(fill="x")
|
||
ttk.Label(ser_bar, text="串口:").pack(side="left")
|
||
ports = self._list_ports()
|
||
saved_port = self.settings["serial"].get("port", "")
|
||
init_port = saved_port if saved_port in ports else (ports[0] if ports else "")
|
||
self.port_var = tk.StringVar(value=init_port)
|
||
self.port_cb = ttk.Combobox(ser_bar, textvariable=self.port_var, width=10,
|
||
values=ports, state="readonly")
|
||
self.port_cb.pack(side="left", padx=4)
|
||
self.port_cb.bind("<<ComboboxSelected>>", lambda _e: self._update_port_hint())
|
||
ttk.Button(ser_bar, text="刷新", width=6, command=self._refresh_ports).pack(side="left")
|
||
ttk.Label(ser_bar, text=" 波特率:").pack(side="left")
|
||
self.baud_var = tk.StringVar(value=str(self.settings["serial"].get("baudrate", 115200)))
|
||
baud_cb = ttk.Combobox(ser_bar, textvariable=self.baud_var, width=10,
|
||
values=["9600", "19200", "38400", "57600",
|
||
"115200", "230400", "460800", "921600"],
|
||
state="readonly")
|
||
baud_cb.pack(side="left", padx=4)
|
||
self.connect_btn = ttk.Button(ser_bar, text="连接", command=self._toggle_serial)
|
||
self.connect_btn.pack(side="left", padx=10)
|
||
ttk.Label(ser_bar, text=" 测试员:").pack(side="left")
|
||
self.operator_var = tk.StringVar(value=self.settings.get("operator", ""))
|
||
ttk.Entry(ser_bar, textvariable=self.operator_var, width=10).pack(side="left", padx=4)
|
||
self.status_var = tk.StringVar(value="● 未连接")
|
||
self.status_lbl = ttk.Label(ser_bar, textvariable=self.status_var,
|
||
foreground="gray", font=("Segoe UI", 10, "bold"))
|
||
self.status_lbl.pack(side="right")
|
||
# 端口下小灰字：USB 描述 + 序列号
|
||
self.port_hint_var = tk.StringVar(value="")
|
||
ttk.Label(ser_outer, textvariable=self.port_hint_var,
|
||
foreground="gray", font=("Segoe UI", 8)).pack(anchor="w", padx=(40, 0))
|
||
|
||
# 第三条：SN
|
||
sn_bar = ttk.LabelFrame(self.root, text=" SN 序列号 ", padding=8)
|
||
sn_bar.pack(fill="x", padx=8, pady=3)
|
||
ttk.Label(sn_bar, text="前缀:").grid(row=0, column=0, sticky="w")
|
||
self.sn_prefix_var = tk.StringVar()
|
||
ttk.Entry(sn_bar, textvariable=self.sn_prefix_var, width=12).grid(row=0, column=1, padx=4)
|
||
ttk.Label(sn_bar, text="位数:").grid(row=0, column=2, sticky="w", padx=(10, 0))
|
||
self.sn_digits_var = tk.IntVar()
|
||
ttk.Spinbox(sn_bar, from_=1, to=12, textvariable=self.sn_digits_var, width=5).grid(row=0, column=3, padx=4)
|
||
ttk.Label(sn_bar, text="下一个编号:").grid(row=0, column=4, sticky="w", padx=(10, 0))
|
||
self.sn_number_var = tk.IntVar()
|
||
ttk.Spinbox(sn_bar, from_=0, to=999999999, textvariable=self.sn_number_var, width=10).grid(row=0, column=5, padx=4)
|
||
ttk.Label(sn_bar, text="步长:").grid(row=0, column=6, sticky="w", padx=(10, 0))
|
||
self.sn_step_var = tk.IntVar()
|
||
ttk.Spinbox(sn_bar, from_=-100, to=100, textvariable=self.sn_step_var, width=5).grid(row=0, column=7, padx=4)
|
||
self.sn_preview_var = tk.StringVar()
|
||
ttk.Label(sn_bar, textvariable=self.sn_preview_var, foreground="darkgreen",
|
||
font=("Consolas", 12, "bold")).grid(row=0, column=8, padx=15)
|
||
for v in (self.sn_prefix_var, self.sn_digits_var, self.sn_number_var):
|
||
v.trace_add("write", lambda *_: self._refresh_sn_preview())
|
||
|
||
# 第四条：当前设备 - 极简
|
||
dev = ttk.Frame(self.root, padding=(8, 6, 8, 6))
|
||
dev.pack(fill="x")
|
||
ttk.Label(dev, text="MAC:", font=("Segoe UI", 10, "bold")).pack(side="left")
|
||
self.mac_var = tk.StringVar(value="(等待捕获...)")
|
||
ttk.Label(dev, textvariable=self.mac_var, font=("Consolas", 12),
|
||
foreground="blue", width=22).pack(side="left", padx=6)
|
||
self.mac_match_var = tk.StringVar(value="")
|
||
ttk.Label(dev, textvariable=self.mac_match_var,
|
||
font=("Segoe UI", 11, "bold"), width=4).pack(side="left")
|
||
ttk.Button(dev, text="手动输入", command=self._manual_mac).pack(side="left", padx=2)
|
||
ttk.Button(dev, text="清除", command=self._clear_mac).pack(side="left", padx=2)
|
||
ttk.Button(dev, text="+ 添加测试项",
|
||
command=self._add_test_item).pack(side="left", padx=(20, 2))
|
||
# 内部跟踪 USB SN，UI 不显示（已在端口栏下方显示）
|
||
self.usb_sn_var = tk.StringVar(value="")
|
||
|
||
# 主体（中间可拖动分隔条）
|
||
body = ttk.PanedWindow(self.root, orient="horizontal")
|
||
body.pack(fill="both", expand=True, padx=8, pady=3)
|
||
self.tests_outer = ttk.LabelFrame(body, text=" 测试项 ", padding=4)
|
||
body.add(self.tests_outer, weight=2)
|
||
|
||
self.canvas = tk.Canvas(self.tests_outer, highlightthickness=0)
|
||
self.canvas_sb = ttk.Scrollbar(self.tests_outer, orient="vertical", command=self.canvas.yview)
|
||
self.tests_frame = ttk.Frame(self.canvas)
|
||
self.tests_frame.bind("<Configure>",
|
||
lambda e: self.canvas.configure(scrollregion=self.canvas.bbox("all")))
|
||
self._canvas_window = self.canvas.create_window((0, 0), window=self.tests_frame, anchor="nw")
|
||
self.canvas.bind("<Configure>",
|
||
lambda e: self.canvas.itemconfig(self._canvas_window, width=e.width))
|
||
self.canvas.configure(yscrollcommand=self.canvas_sb.set)
|
||
|
||
# 统计汇总面板（测试项列表下方）
|
||
stats = ttk.LabelFrame(self.tests_outer, text=" 统计-汇总 ", padding=8)
|
||
stats.pack(side="bottom", fill="x", pady=(6, 0))
|
||
|
||
# 行 1：批次号 / 数量 / 累计 / 未测
|
||
row1 = ttk.Frame(stats)
|
||
row1.pack(fill="x")
|
||
ttk.Label(row1, text="批次号:", font=("Segoe UI", 11, "bold")).pack(side="left")
|
||
self.batch_no_var = tk.StringVar(value=str(self.settings.get("batch_no", "1")))
|
||
ttk.Entry(row1, textvariable=self.batch_no_var, width=12,
|
||
font=("Segoe UI", 11)).pack(side="left", padx=(4, 15))
|
||
self.batch_no_var.trace_add("write", lambda *_: self._on_batch_no_changed())
|
||
ttk.Label(row1, text="数量:", font=("Segoe UI", 11, "bold")).pack(side="left")
|
||
self.batch_size_var = tk.IntVar(value=int(self.settings.get("batch_size", 600)))
|
||
ttk.Spinbox(row1, from_=1, to=999999, textvariable=self.batch_size_var,
|
||
width=6, command=self._on_batch_changed).pack(side="left", padx=(4, 2))
|
||
ttk.Label(row1, text="套",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left", padx=(2, 15))
|
||
self.batch_size_var.trace_add("write", lambda *_: self._on_batch_changed())
|
||
ttk.Label(row1, text="累计:", font=("Segoe UI", 11, "bold")).pack(side="left")
|
||
self.stats_total_var = tk.StringVar(value="0")
|
||
ttk.Label(row1, textvariable=self.stats_total_var,
|
||
font=("Segoe UI", 16, "bold"),
|
||
foreground="#222").pack(side="left", padx=(4, 0))
|
||
ttk.Label(row1, text="台",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left", padx=(2, 0))
|
||
ttk.Label(row1, text=" ⏱ 未测:",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left", padx=(15, 0))
|
||
self.stats_remain_var = tk.StringVar(value="0")
|
||
ttk.Label(row1, textvariable=self.stats_remain_var,
|
||
font=("Segoe UI", 16, "bold"),
|
||
foreground="#0080c0").pack(side="left", padx=(4, 0))
|
||
ttk.Label(row1, text="台",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left", padx=(2, 0))
|
||
|
||
# 行 2：合格 + 合格率 / 不合格 + 不良率
|
||
row2 = ttk.Frame(stats)
|
||
row2.pack(fill="x", pady=(4, 0))
|
||
ttk.Label(row2, text="✅ 合格:",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left")
|
||
self.stats_pass_var = tk.StringVar(value="0")
|
||
ttk.Label(row2, textvariable=self.stats_pass_var,
|
||
font=("Segoe UI", 16, "bold"),
|
||
foreground="darkgreen").pack(side="left", padx=(4, 0))
|
||
ttk.Label(row2, text="台",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left", padx=(2, 0))
|
||
ttk.Label(row2, text=" 合格率:",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left", padx=(8, 0))
|
||
self.stats_pass_rate_var = tk.StringVar(value="—")
|
||
ttk.Label(row2, textvariable=self.stats_pass_rate_var,
|
||
font=("Segoe UI", 16, "bold"),
|
||
foreground="darkgreen").pack(side="left", padx=(4, 0))
|
||
ttk.Label(row2, text=" ❌ 不合格:",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left", padx=(10, 0))
|
||
self.stats_fail_var = tk.StringVar(value="0")
|
||
ttk.Label(row2, textvariable=self.stats_fail_var,
|
||
font=("Segoe UI", 16, "bold"),
|
||
foreground="red").pack(side="left", padx=(4, 0))
|
||
ttk.Label(row2, text="台",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left", padx=(2, 0))
|
||
ttk.Label(row2, text=" 不良率:",
|
||
font=("Segoe UI", 11, "bold")).pack(side="left", padx=(8, 0))
|
||
self.stats_rate_var = tk.StringVar(value="—")
|
||
ttk.Label(row2, textvariable=self.stats_rate_var,
|
||
font=("Segoe UI", 16, "bold"),
|
||
foreground="#d97706").pack(side="left", padx=(4, 0))
|
||
|
||
ttk.Label(stats,
|
||
text="⚠ 所有测试项必须全部通过才算合格；任一项 FAIL 即不合格，需返厂或维修",
|
||
font=("Segoe UI", 10, "bold"), anchor="w",
|
||
wraplength=520, justify="left").pack(fill="x", pady=(4, 0))
|
||
|
||
self.canvas.pack(side="left", fill="both", expand=True)
|
||
self.canvas_sb.pack(side="right", fill="y")
|
||
# 鼠标只在测试项区域内才响应滚轮，避免在其他区域滚动时误触
|
||
self.canvas.bind("<Enter>",
|
||
lambda _e: self.canvas.bind_all("<MouseWheel>", self._on_tests_mousewheel))
|
||
self.canvas.bind("<Leave>",
|
||
lambda _e: self.canvas.unbind_all("<MouseWheel>"))
|
||
|
||
|
||
# 日志
|
||
right = ttk.LabelFrame(body, text=" 串口日志 ", padding=4)
|
||
body.add(right, weight=3)
|
||
self.log_widget = scrolledtext.ScrolledText(right, wrap="word", font=("Consolas", 9))
|
||
self.log_widget.pack(fill="both", expand=True)
|
||
self.log_widget.tag_config("hit", background="#fffbcc")
|
||
self.log_widget.tag_config("mac", foreground="blue", font=("Consolas", 9, "bold"))
|
||
self.log_widget.tag_config("ts", foreground="#1a8a2e")
|
||
lb = ttk.Frame(right)
|
||
lb.pack(fill="x")
|
||
self.autoscroll_var = tk.BooleanVar(value=True)
|
||
ttk.Checkbutton(lb, text="自动滚动", variable=self.autoscroll_var).pack(side="left")
|
||
self.auto_clear_log_var = tk.BooleanVar(
|
||
value=bool(self.settings.get("auto_clear_log_on_disconnect", False)))
|
||
ttk.Checkbutton(lb, text="断开时自动清空日志",
|
||
variable=self.auto_clear_log_var,
|
||
command=self._save_global_settings).pack(side="left", padx=(15, 0))
|
||
ttk.Button(lb, text="清空日志", command=lambda: self.log_widget.delete(1.0, "end")).pack(side="right")
|
||
|
||
# 底部
|
||
bottom = ttk.Frame(self.root, padding=8)
|
||
bottom.pack(fill="x")
|
||
ttk.Button(bottom, text="🔄 重置本台", command=self.reset_state).pack(side="left", padx=4)
|
||
ttk.Button(bottom, text="💾 保存本台数据",
|
||
command=self._save_and_next).pack(side="left", padx=4)
|
||
ttk.Button(bottom, text="📂 打开报告 CSV", command=self._open_report).pack(side="left", padx=4)
|
||
ttk.Button(bottom, text="📊 导出统计汇总", command=self._export_summary).pack(side="left", padx=4)
|
||
ttk.Button(bottom, text="📁 打开 reports 目录", command=lambda: os.startfile(REPORTS_DIR)).pack(side="left", padx=4)
|
||
|
||
# 字号下拉
|
||
ttk.Label(bottom, text=" 字号:").pack(side="left", padx=(20, 2))
|
||
self.font_size_var = tk.StringVar(value=self.settings.get("font_size_label", "中"))
|
||
font_cb = ttk.Combobox(bottom, textvariable=self.font_size_var,
|
||
values=list(FONT_SIZES.keys()),
|
||
state="readonly", width=6)
|
||
font_cb.pack(side="left")
|
||
font_cb.bind("<<ComboboxSelected>>", lambda _e: self._on_font_changed())
|
||
|
||
self.count_var = tk.StringVar()
|
||
ttk.Label(bottom, textvariable=self.count_var,
|
||
font=("Segoe UI", 10, "bold")).pack(side="right", padx=8)
|
||
|
||
# 加载 profile 到 UI + 初始读取端口信息
|
||
self._apply_font_style()
|
||
self._apply_profile_to_ui()
|
||
self._update_port_hint()
|
||
|
||
# ---------- Profile ----------
|
||
def _on_tests_mousewheel(self, event):
|
||
"""测试项 Canvas 滚轮：只在内容超出可视区时滚动，到顶/到底自动停"""
|
||
try:
|
||
first, last = self.canvas.yview()
|
||
if first <= 0.0 and last >= 1.0:
|
||
return # 内容没超出，无需滚
|
||
delta = int(-1 * (event.delta / 120))
|
||
if delta < 0 and first <= 0.0:
|
||
return # 已到顶
|
||
if delta > 0 and last >= 1.0:
|
||
return # 已到底
|
||
self.canvas.yview_scroll(delta, "units")
|
||
except Exception:
|
||
pass
|
||
|
||
def _refresh_stats(self):
|
||
"""读取当前产品当日 CSV，统计 PASS/FAIL/累计/不良率（基于批次）"""
|
||
if not hasattr(self, "stats_total_var"):
|
||
return
|
||
rf = self._report_file()
|
||
total = pass_n = fail_n = 0
|
||
if rf.exists():
|
||
try:
|
||
with open(rf, "r", encoding="utf-8-sig", newline="") as f:
|
||
reader = csv.DictReader(f)
|
||
for row in reader:
|
||
total += 1
|
||
r = row.get("整体结果", "").strip()
|
||
if r == "PASS":
|
||
pass_n += 1
|
||
elif r == "FAIL":
|
||
fail_n += 1
|
||
except Exception:
|
||
pass
|
||
self.stats_total_var.set(str(total))
|
||
self.stats_pass_var.set(str(pass_n))
|
||
self.stats_fail_var.set(str(fail_n))
|
||
# 未测 = 批次 - 已测（不小于 0）
|
||
try:
|
||
batch = max(1, int(self.batch_size_var.get()))
|
||
except (tk.TclError, ValueError):
|
||
batch = 1
|
||
self.stats_remain_var.set(str(max(0, batch - total)))
|
||
# 合格率 / 不良率 都基于已测台数；未测台数不计入分母
|
||
if total > 0:
|
||
self.stats_pass_rate_var.set(f"{pass_n / total * 100:.1f}%")
|
||
self.stats_rate_var.set(f"{fail_n / total * 100:.1f}%")
|
||
else:
|
||
self.stats_pass_rate_var.set("—")
|
||
self.stats_rate_var.set("—")
|
||
|
||
def _calc_defect_rate(self, n, f):
|
||
"""CSV 累计不良率列用：基于已测台数"""
|
||
if n == 0:
|
||
return "—"
|
||
return f"{f / n * 100:.1f}%"
|
||
|
||
def _on_batch_changed(self):
|
||
try:
|
||
self.settings["batch_size"] = int(self.batch_size_var.get())
|
||
save_settings(self.settings)
|
||
except (tk.TclError, ValueError):
|
||
pass
|
||
self._refresh_stats()
|
||
|
||
def _on_batch_no_changed(self):
|
||
self.settings["batch_no"] = self.batch_no_var.get()
|
||
save_settings(self.settings)
|
||
# 切换批次号 = 切换 CSV 文件 → 刷新累计/合格/不合格等；MAC 询问表也清空
|
||
self._mac_seen_in_session.clear()
|
||
self._refresh_stats()
|
||
if hasattr(self, "count_var"):
|
||
self.count_var.set(f"{self.profile['product_name']} 已记录: {self._count_records()} 台")
|
||
|
||
def _apply_font_style(self):
|
||
"""让 ttk Button/Entry 用当前字号"""
|
||
style = ttk.Style()
|
||
btn_fs = max(self.font_size_pt - 1, 9)
|
||
style.configure("Test.TButton", font=("Segoe UI", btn_fs))
|
||
|
||
def _on_font_changed(self):
|
||
label = self.font_size_var.get()
|
||
self.font_size_pt = FONT_SIZES.get(label, 12)
|
||
self.settings["font_size_label"] = label
|
||
save_settings(self.settings)
|
||
self._apply_font_style()
|
||
self._rebuild_tests()
|
||
|
||
def _apply_profile_to_ui(self):
|
||
self.sn_prefix_var.set(self.profile["sn"]["prefix"])
|
||
self.sn_digits_var.set(self.profile["sn"]["digits"])
|
||
self.sn_number_var.set(self.profile["sn"]["next_number"])
|
||
self.sn_step_var.set(self.profile["sn"]["step"])
|
||
self._refresh_sn_preview()
|
||
self._rebuild_tests()
|
||
self.count_var.set(f"{self.profile['product_name']} 已记录: {self._count_records()} 台")
|
||
self._refresh_stats()
|
||
|
||
def _rebuild_tests(self):
|
||
for c in self.tests_frame.winfo_children():
|
||
c.destroy()
|
||
self.test_widgets = {}
|
||
for test in self.profile["tests"]:
|
||
self._build_test_row(test)
|
||
|
||
def _build_test_row(self, test):
|
||
fs = self.font_size_pt
|
||
hint_fs = max(fs - 3, 8)
|
||
row = ttk.Frame(self.tests_frame)
|
||
row.pack(fill="x", pady=2)
|
||
|
||
# ✏ 编辑按钮放在最左（沙漏/状态标识之前）
|
||
ttk.Button(row, text="✏", width=3, style="Test.TButton",
|
||
command=lambda i=test["id"]: self._quick_edit_item(i)).pack(side="left", padx=2)
|
||
|
||
state_var = tk.StringVar()
|
||
ttk.Label(row, textvariable=state_var, width=28, anchor="w",
|
||
font=("Segoe UI", fs)).pack(side="left")
|
||
|
||
w = {"test": test, "state_var": state_var,
|
||
"result": None, "value": None, "hits": 0,
|
||
"base_name": test["name"]}
|
||
|
||
ttype = test["type"]
|
||
if ttype == "manual_choice":
|
||
cv = tk.StringVar(value="")
|
||
cb = ttk.Combobox(row, textvariable=cv, values=test.get("choices", []),
|
||
width=14, state="readonly")
|
||
cb.pack(side="left", padx=2)
|
||
cb.bind("<<ComboboxSelected>>",
|
||
lambda _e, i=test["id"], v=cv: self._set_choice(i, v.get()))
|
||
# 选完状态后，再人工 ✓/✗ 判定（避免程序按关键词误判）
|
||
ttk.Button(row, text="✓", width=3, style="Test.TButton",
|
||
command=lambda i=test["id"]: self._set_manual(i, True)).pack(side="left", padx=2)
|
||
ttk.Button(row, text="✗", width=3, style="Test.TButton",
|
||
command=lambda i=test["id"]: self._set_manual(i, False)).pack(side="left", padx=2)
|
||
w["choice_var"] = cv
|
||
elif ttype == "manual_text":
|
||
tv = tk.StringVar()
|
||
ttk.Entry(row, textvariable=tv, width=16,
|
||
font=("Segoe UI", fs)).pack(side="left", padx=2)
|
||
ttk.Button(row, text="✓填入", width=6, style="Test.TButton",
|
||
command=lambda i=test["id"], v=tv: self._set_text(i, v.get(), True)).pack(side="left", padx=2)
|
||
ttk.Button(row, text="✗", width=3, style="Test.TButton",
|
||
command=lambda i=test["id"]: self._set_manual(i, False)).pack(side="left", padx=2)
|
||
w["text_var"] = tv
|
||
else:
|
||
ttk.Button(row, text="✓", width=3, style="Test.TButton",
|
||
command=lambda i=test["id"]: self._set_manual(i, True)).pack(side="left", padx=2)
|
||
ttk.Button(row, text="✗", width=3, style="Test.TButton",
|
||
command=lambda i=test["id"]: self._set_manual(i, False)).pack(side="left", padx=2)
|
||
|
||
hint = test.get("hint", "")
|
||
if hint:
|
||
ttk.Label(row, text=f"💡{hint}", foreground="gray",
|
||
font=("Segoe UI", hint_fs)).pack(side="left", padx=6)
|
||
|
||
self.test_widgets[test["id"]] = w
|
||
self._refresh_label(test["id"])
|
||
|
||
def _on_profile_change(self, _e=None):
|
||
# 保存当前 profile SN 进度
|
||
self._sync_sn_to_profile()
|
||
save_profile(self.profile)
|
||
# 切换
|
||
name = self.profile_var.get()
|
||
new = load_profile(name)
|
||
if not new:
|
||
return
|
||
self.profile = new
|
||
self.settings["current_profile"] = name
|
||
save_settings(self.settings)
|
||
self._mac_seen_in_session.clear()
|
||
self.reset_state()
|
||
self._apply_profile_to_ui()
|
||
|
||
def _open_editor(self):
|
||
def on_save(new_prof):
|
||
new_prof["sn"] = self.profile["sn"] # 保留 SN 状态
|
||
self.profile = new_prof
|
||
save_profile(self.profile)
|
||
self._apply_profile_to_ui()
|
||
TestEditor(self.root, self.profile, on_save)
|
||
|
||
def _new_profile(self):
|
||
name = simpledialog.askstring("新建产品", "产品名称（英文字母数字+短横线）:", parent=self.root)
|
||
if not name:
|
||
return
|
||
name = name.strip()
|
||
if not name or name in list_profiles():
|
||
messagebox.showwarning("提示", "名称为空或已存在")
|
||
return
|
||
prof = json.loads(json.dumps(DEFAULT_PROFILE))
|
||
prof["product_name"] = name
|
||
prof["tests"] = [] # 新产品空白起步
|
||
save_profile(prof)
|
||
self.profile_cb["values"] = list_profiles()
|
||
self.profile_var.set(name)
|
||
self._on_profile_change()
|
||
messagebox.showinfo("已新建", f"产品 '{name}' 已新建。\n点 '编辑测试项' 添加测试项。")
|
||
|
||
def _copy_profile(self):
|
||
new_name = simpledialog.askstring(
|
||
"复制当前", f"基于 '{self.profile['product_name']}' 复制，新名称:",
|
||
initialvalue=self.profile["product_name"] + "_copy", parent=self.root)
|
||
if not new_name:
|
||
return
|
||
new_name = new_name.strip()
|
||
if new_name in list_profiles():
|
||
messagebox.showwarning("提示", "名称已存在")
|
||
return
|
||
prof = json.loads(json.dumps(self.profile))
|
||
prof["product_name"] = new_name
|
||
prof["sn"]["next_number"] = 1
|
||
save_profile(prof)
|
||
self.profile_cb["values"] = list_profiles()
|
||
self.profile_var.set(new_name)
|
||
self._on_profile_change()
|
||
|
||
def _rename_profile(self):
|
||
old = self.profile["product_name"]
|
||
new_name = simpledialog.askstring("重命名", "新名称:", initialvalue=old, parent=self.root)
|
||
if not new_name or new_name == old:
|
||
return
|
||
new_name = new_name.strip()
|
||
if new_name in list_profiles():
|
||
messagebox.showwarning("提示", "名称已存在")
|
||
return
|
||
old_path = profile_path(old)
|
||
self.profile["product_name"] = new_name
|
||
save_profile(self.profile)
|
||
try:
|
||
old_path.unlink()
|
||
except Exception:
|
||
pass
|
||
self.profile_cb["values"] = list_profiles()
|
||
self.profile_var.set(new_name)
|
||
self.settings["current_profile"] = new_name
|
||
save_settings(self.settings)
|
||
|
||
def _delete_profile(self):
|
||
names = list_profiles()
|
||
if len(names) <= 1:
|
||
messagebox.showwarning("提示", "至少保留一个产品配置")
|
||
return
|
||
if not messagebox.askyesno("确认",
|
||
f"删除产品 '{self.profile['product_name']}' 的配置？\n（已生成的报告 CSV 不会被删除）"):
|
||
return
|
||
try:
|
||
profile_path(self.profile["product_name"]).unlink()
|
||
except Exception:
|
||
pass
|
||
names = list_profiles()
|
||
self.profile_cb["values"] = names
|
||
self.profile_var.set(names[0])
|
||
self._on_profile_change()
|
||
|
||
def _export_profile(self):
|
||
f = filedialog.asksaveasfilename(
|
||
defaultextension=".json",
|
||
initialfile=f"{self.profile['product_name']}.json",
|
||
filetypes=[("JSON", "*.json")])
|
||
if not f:
|
||
return
|
||
with open(f, "w", encoding="utf-8") as fp:
|
||
json.dump(self.profile, fp, ensure_ascii=False, indent=2)
|
||
messagebox.showinfo("已导出", f)
|
||
|
||
def _import_profile(self):
|
||
f = filedialog.askopenfilename(filetypes=[("JSON", "*.json")])
|
||
if not f:
|
||
return
|
||
try:
|
||
with open(f, "r", encoding="utf-8") as fp:
|
||
prof = json.load(fp)
|
||
name = prof.get("product_name") or Path(f).stem
|
||
prof["product_name"] = name
|
||
if name in list_profiles():
|
||
if not messagebox.askyesno("覆盖", f"产品 '{name}' 已存在，覆盖？"):
|
||
return
|
||
save_profile(prof)
|
||
except Exception as e:
|
||
messagebox.showerror("导入失败", str(e))
|
||
return
|
||
self.profile_cb["values"] = list_profiles()
|
||
self.profile_var.set(name)
|
||
self._on_profile_change()
|
||
|
||
# ---------- 状态 ----------
|
||
def reset_state(self):
|
||
self.current_mac = None
|
||
self._replace_mac = None
|
||
self._replace_sn = None
|
||
self.mac_var.set("(等待捕获 MAC...)")
|
||
for tid, w in self.test_widgets.items():
|
||
w["result"] = None
|
||
w["value"] = None
|
||
w["hits"] = 0
|
||
if "choice_var" in w:
|
||
w["choice_var"].set("")
|
||
if "text_var" in w:
|
||
w["text_var"].set("")
|
||
self._refresh_label(tid)
|
||
|
||
def _refresh_label(self, tid):
|
||
w = self.test_widgets[tid]
|
||
name = w["base_name"]
|
||
hits = f" [{w['hits']}次]" if w["hits"] > 0 else ""
|
||
if w["result"] is None:
|
||
if w["value"] not in (None, ""):
|
||
text = f"⏳ {name} = {w['value']} (待判定)"
|
||
else:
|
||
text = f"⏳ {name}{hits}"
|
||
elif w["result"] is True:
|
||
extra = f" = {w['value']}" if w["value"] not in (None, "") else hits
|
||
text = f"✅ {name}{extra}"
|
||
else:
|
||
extra = f" = {w['value']}" if w["value"] not in (None, "") else hits
|
||
text = f"❌ {name}{extra}"
|
||
w["state_var"].set(text)
|
||
|
||
def _set_manual(self, tid, ok):
|
||
self.test_widgets[tid]["result"] = ok
|
||
self._refresh_label(tid)
|
||
|
||
def _set_choice(self, tid, choice):
|
||
"""只记录选了什么状态；PASS/FAIL 由人工 ✓/✗ 决定，避免按关键词误判"""
|
||
w = self.test_widgets[tid]
|
||
w["value"] = choice
|
||
self._refresh_label(tid)
|
||
|
||
def _set_text(self, tid, text, mark_pass):
|
||
w = self.test_widgets[tid]
|
||
w["value"] = text.strip()
|
||
w["result"] = mark_pass and bool(text.strip())
|
||
if not text.strip():
|
||
messagebox.showinfo("提示", "请先填写文本再点 ✓填入")
|
||
return
|
||
self._refresh_label(tid)
|
||
|
||
def _refresh_sn_preview(self):
|
||
try:
|
||
prefix = self.sn_prefix_var.get()
|
||
digits = max(1, int(self.sn_digits_var.get()))
|
||
n = int(self.sn_number_var.get())
|
||
sn = f"{prefix}{n:0{digits}d}"
|
||
self.sn_preview_var.set(f"下一台入库 SN ➜ {sn}（PASS 才占用，FAIL 不占）")
|
||
except (ValueError, tk.TclError):
|
||
self.sn_preview_var.set("(SN 格式无效)")
|
||
|
||
def _current_sn(self):
|
||
prefix = self.sn_prefix_var.get()
|
||
digits = max(1, int(self.sn_digits_var.get()))
|
||
return f"{prefix}{int(self.sn_number_var.get()):0{digits}d}"
|
||
|
||
def _sync_sn_to_profile(self):
|
||
try:
|
||
self.profile["sn"] = {
|
||
"prefix": self.sn_prefix_var.get(),
|
||
"digits": int(self.sn_digits_var.get()),
|
||
"next_number": int(self.sn_number_var.get()),
|
||
"step": int(self.sn_step_var.get()),
|
||
}
|
||
except (ValueError, tk.TclError):
|
||
pass
|
||
|
||
# ---------- 串口 ----------
|
||
def _list_ports(self):
|
||
return [p.device for p in serial.tools.list_ports.comports()]
|
||
|
||
def _refresh_ports(self):
|
||
ports = self._list_ports()
|
||
self.port_cb["values"] = ports
|
||
# 当前选中的端口已拔掉，自动切到第一个可用端口
|
||
if self.port_var.get() not in ports:
|
||
self.port_var.set(ports[0] if ports else "")
|
||
self._update_port_hint()
|
||
|
||
def _update_port_hint(self):
|
||
"""端口栏下方的小灰字：描述 + 序列号（适配任意串口类型）"""
|
||
if not hasattr(self, "port_hint_var"):
|
||
return
|
||
ports = self._list_ports()
|
||
if not ports:
|
||
self.port_hint_var.set(" ⚠ 未检测到任何串口（检查 USB 是否插好 / 驱动是否安装）")
|
||
if hasattr(self, "usb_sn_var"):
|
||
self.usb_sn_var.set("")
|
||
self._update_mac_match()
|
||
return
|
||
port = self.port_var.get().strip()
|
||
if not port:
|
||
self.port_hint_var.set("")
|
||
if hasattr(self, "usb_sn_var"):
|
||
self.usb_sn_var.set("")
|
||
self._update_mac_match()
|
||
return
|
||
for p in serial.tools.list_ports.comports():
|
||
if p.device == port:
|
||
parts = []
|
||
if p.description and p.description.lower() != "n/a":
|
||
parts.append(p.description)
|
||
if p.manufacturer and p.manufacturer.lower() != "n/a":
|
||
parts.append(p.manufacturer)
|
||
sn = (p.serial_number or "").strip()
|
||
if sn:
|
||
norm = self._normalize_mac(sn)
|
||
if len(norm) == 12:
|
||
sn = ":".join(norm[i:i + 2].upper() for i in range(0, 12, 2))
|
||
parts.append(sn)
|
||
self.port_hint_var.set(" " + " · ".join(parts) if parts else f" {port} (无额外信息)")
|
||
if hasattr(self, "usb_sn_var"):
|
||
self.usb_sn_var.set(p.serial_number or "")
|
||
self._update_mac_match()
|
||
return
|
||
self.port_hint_var.set("")
|
||
|
||
def _toggle_serial(self):
|
||
if self.ser_running:
|
||
self._disconnect()
|
||
else:
|
||
self._connect()
|
||
|
||
def _connect(self):
|
||
port = self.port_var.get().strip()
|
||
if not port:
|
||
messagebox.showwarning("提示", "请先选择串口")
|
||
return
|
||
try:
|
||
baud = int(self.baud_var.get())
|
||
self.ser = serial.Serial(port, baud, timeout=0.5)
|
||
self.ser_running = True
|
||
threading.Thread(target=self._serial_loop, daemon=True).start()
|
||
self.connect_btn.config(text="断开")
|
||
self.status_var.set(f"● 已连接 {port}@{baud}")
|
||
self.status_lbl.config(foreground="#1a8a2e")
|
||
self._read_usb_sn()
|
||
self._save_global_settings()
|
||
except Exception as e:
|
||
messagebox.showerror("连接失败", str(e))
|
||
|
||
def _disconnect(self):
|
||
self.ser_running = False
|
||
if self.ser:
|
||
try:
|
||
self.ser.close()
|
||
except Exception:
|
||
pass
|
||
self.ser = None
|
||
self.connect_btn.config(text="连接")
|
||
self.status_var.set("● 未连接")
|
||
self.status_lbl.config(foreground="gray")
|
||
self._mac_seen_in_session.clear()
|
||
if getattr(self, "auto_clear_log_var", None) and self.auto_clear_log_var.get():
|
||
try:
|
||
self.log_widget.delete(1.0, "end")
|
||
except Exception:
|
||
pass
|
||
|
||
def _read_usb_sn(self):
|
||
self._update_port_hint()
|
||
|
||
@staticmethod
|
||
def _normalize_mac(s):
|
||
if not s:
|
||
return ""
|
||
return re.sub(r"[^0-9a-fA-F]", "", s).lower()
|
||
|
||
def _update_mac_match(self):
|
||
usb = self._normalize_mac(self.usb_sn_var.get())
|
||
ser = self._normalize_mac(self.current_mac or "")
|
||
if len(usb) != 12 or len(ser) != 12:
|
||
self.mac_match_var.set("")
|
||
return
|
||
if usb == ser:
|
||
self.mac_match_var.set("✅ 一致")
|
||
else:
|
||
self.mac_match_var.set("❌ 不一致!")
|
||
|
||
def _check_and_warn_duplicate(self, mac):
|
||
"""新 MAC 进入流程：
|
||
- 同会话同 MAC 反复来 → 忽略（避免设备没拔反复触发）
|
||
- CSV 中已有 PASS 行匹配此 MAC → 弹窗确认是否重测覆盖
|
||
- 其他（无记录 / 只有 FAIL 行） → 当新设备，重算下一个可用 SN
|
||
"""
|
||
if not mac:
|
||
return
|
||
norm = self._normalize_mac(mac) or mac.strip().lower()
|
||
if not norm:
|
||
return
|
||
if norm in self._mac_seen_in_session:
|
||
return
|
||
self._mac_seen_in_session.add(norm)
|
||
|
||
rf = self._report_file()
|
||
pass_match = None
|
||
if rf.exists():
|
||
try:
|
||
with open(rf, "r", encoding="utf-8-sig", newline="") as f:
|
||
reader = csv.DictReader(f)
|
||
for row in reader:
|
||
csv_mac = row.get("MAC", "")
|
||
nm = self._normalize_mac(csv_mac) or csv_mac.strip().lower()
|
||
if nm != norm:
|
||
continue
|
||
if row.get("整体结果", "").strip() == "PASS":
|
||
pass_match = row
|
||
break
|
||
except Exception:
|
||
pass
|
||
|
||
if pass_match:
|
||
sn_v = pass_match.get("SN", "")
|
||
t_v = pass_match.get("时间", "")
|
||
ans = messagebox.askyesno(
|
||
"⚠ 该 MAC 已入库",
|
||
f"MAC: {mac}\n"
|
||
f"已作为合格设备入库：\n"
|
||
f" SN: {sn_v}\n"
|
||
f" 时间: {t_v}\n\n"
|
||
f"是否确认是同一台设备？\n"
|
||
f" 是 = 重测并覆盖原 PASS 记录\n"
|
||
f" 否 = 清除 MAC，跳过这台"
|
||
)
|
||
if ans:
|
||
self._replace_mac = mac
|
||
else:
|
||
self.current_mac = None
|
||
self.mac_var.set("(等待捕获...)")
|
||
self._update_mac_match()
|
||
self._replace_mac = None
|
||
return
|
||
|
||
# 全新设备 或 之前只 FAIL 过 → 当新设备，把 SN 改为最小可用
|
||
try:
|
||
self.sn_number_var.set(self._next_available_sn())
|
||
self._refresh_sn_preview()
|
||
except (tk.TclError, ValueError):
|
||
pass
|
||
|
||
def _next_available_sn(self):
|
||
"""扫主 CSV 的 PASS 行 SN 集合，返回最小未被占用的正整数（FAIL 行不占用）"""
|
||
rf = self._report_file()
|
||
used = set()
|
||
if rf.exists():
|
||
try:
|
||
with open(rf, "r", encoding="utf-8-sig", newline="") as f:
|
||
reader = csv.DictReader(f)
|
||
for row in reader:
|
||
if row.get("整体结果", "").strip() != "PASS":
|
||
continue
|
||
sn = row.get("SN", "").strip()
|
||
m = re.search(r"\d+", sn)
|
||
if m:
|
||
used.add(int(m.group(0)))
|
||
except Exception:
|
||
pass
|
||
# 从 1 开始找最小不在 used 中的（用户改了起始也按这逻辑，避免再被改）
|
||
n = 1
|
||
while n in used:
|
||
n += 1
|
||
return n
|
||
|
||
def _remove_csv_row_by_mac(self, mac):
|
||
"""从当前批次 CSV 删除匹配 MAC 的旧行（维修重测覆盖用）"""
|
||
rf = self._report_file()
|
||
if not rf.exists() or not mac:
|
||
return
|
||
norm = self._normalize_mac(mac) or mac.strip().lower()
|
||
try:
|
||
with open(rf, "r", encoding="utf-8-sig", newline="") as f:
|
||
reader = csv.reader(f)
|
||
headers = next(reader, None)
|
||
if headers is None:
|
||
return
|
||
try:
|
||
mac_idx = headers.index("MAC")
|
||
except ValueError:
|
||
return
|
||
kept = []
|
||
for r in reader:
|
||
if mac_idx < len(r):
|
||
nm = self._normalize_mac(r[mac_idx]) or r[mac_idx].strip().lower()
|
||
if nm == norm:
|
||
continue
|
||
kept.append(r)
|
||
with open(rf, "w", encoding="utf-8-sig", newline="") as f:
|
||
w = csv.writer(f)
|
||
w.writerow(headers)
|
||
for r in kept:
|
||
w.writerow(r)
|
||
except Exception as e:
|
||
messagebox.showwarning("覆盖旧记录失败", str(e))
|
||
|
||
def _use_usb_as_mac(self):
|
||
sn = self.usb_sn_var.get()
|
||
norm = self._normalize_mac(sn)
|
||
if len(norm) != 12:
|
||
messagebox.showwarning("提示",
|
||
f"USB SN '{sn}' 不像 MAC（需 12 位 hex）。\n"
|
||
f"如果板子用了 CH340/CP2102 等桥接芯片，USB SN 就不是 MAC。")
|
||
return
|
||
mac = ":".join(norm[i:i + 2] for i in range(0, 12, 2))
|
||
self.current_mac = mac
|
||
self.mac_var.set(mac)
|
||
self._update_mac_match()
|
||
|
||
def _serial_loop(self):
|
||
buf = bytearray()
|
||
while self.ser_running and self.ser:
|
||
try:
|
||
data = self.ser.read(512)
|
||
if not data:
|
||
continue
|
||
buf.extend(data)
|
||
while b"\n" in buf:
|
||
line, _, buf = buf.partition(b"\n")
|
||
text = line.decode("utf-8", errors="replace").rstrip("\r")
|
||
if text:
|
||
self.log_q.put(text)
|
||
except Exception as e:
|
||
self.log_q.put(f"[串口异常] {e}")
|
||
break
|
||
|
||
def _drain_log_queue(self):
|
||
try:
|
||
while True:
|
||
self._handle_line(self.log_q.get_nowait())
|
||
except queue.Empty:
|
||
pass
|
||
self.root.after(80, self._drain_log_queue)
|
||
|
||
def _handle_line(self, line):
|
||
ts = datetime.now().strftime("%H:%M:%S")
|
||
|
||
hit_any = False
|
||
mac_hit = False
|
||
|
||
try:
|
||
m = re.search(self.profile["mac_pattern"], line)
|
||
if m:
|
||
mac = m.group(1).lower()
|
||
if mac != self.current_mac:
|
||
self.current_mac = mac
|
||
self.mac_var.set(mac)
|
||
self._update_mac_match()
|
||
self._check_and_warn_duplicate(mac)
|
||
mac_hit = True
|
||
except re.error:
|
||
pass
|
||
|
||
for test in self.profile["tests"]:
|
||
ttype = test["type"]
|
||
pat = test.get("pattern")
|
||
if not pat:
|
||
continue
|
||
try:
|
||
if ttype == "auto":
|
||
if re.search(pat, line):
|
||
w = self.test_widgets.get(test["id"])
|
||
if w:
|
||
w["hits"] += 1
|
||
if w["result"] is None:
|
||
w["result"] = True
|
||
self._refresh_label(test["id"])
|
||
hit_any = True
|
||
elif ttype == "auto_value":
|
||
mm = re.search(pat, line)
|
||
if mm:
|
||
w = self.test_widgets.get(test["id"])
|
||
if w:
|
||
val = ", ".join(mm.groups()) if len(mm.groups()) > 1 else mm.group(1)
|
||
w["result"] = True
|
||
w["value"] = val
|
||
w["hits"] += 1
|
||
self._refresh_label(test["id"])
|
||
hit_any = True
|
||
except re.error:
|
||
continue
|
||
|
||
# 时间戳单独用绿色 tag，内容保留原有 tag
|
||
self.log_widget.insert("end", f"{ts} ", "ts")
|
||
if mac_hit:
|
||
self.log_widget.insert("end", f"{line}\n", "mac")
|
||
elif hit_any:
|
||
self.log_widget.insert("end", f"{line}\n", "hit")
|
||
else:
|
||
self.log_widget.insert("end", f"{line}\n")
|
||
if self.autoscroll_var.get():
|
||
self.log_widget.see("end")
|
||
|
||
# ---------- MAC / 临时项 ----------
|
||
def _manual_mac(self):
|
||
v = simpledialog.askstring("手动输入 MAC", "MAC 地址:", initialvalue=self.current_mac or "", parent=self.root)
|
||
if v:
|
||
self.current_mac = v.strip().lower()
|
||
self.mac_var.set(self.current_mac)
|
||
self._update_mac_match()
|
||
self._check_and_warn_duplicate(self.current_mac)
|
||
|
||
def _clear_mac(self):
|
||
# 主动清除 → 允许该 MAC 下次再被询问
|
||
if self.current_mac:
|
||
norm = self._normalize_mac(self.current_mac) or self.current_mac.strip().lower()
|
||
self._mac_seen_in_session.discard(norm)
|
||
self.current_mac = None
|
||
self._replace_mac = None
|
||
self._replace_sn = None
|
||
self.mac_var.set("(等待捕获...)")
|
||
self._update_mac_match()
|
||
self._refresh_sn_preview()
|
||
|
||
def _add_test_item(self):
|
||
"""+ 按钮 - 加一条测试项到当前 profile（立即保存）"""
|
||
QuickItemEditor(self.root, profile=self.profile, item=None, on_save=self._on_item_saved)
|
||
|
||
def _quick_edit_item(self, tid):
|
||
"""✏ 按钮 - 编辑现有测试项"""
|
||
for i, t in enumerate(self.profile["tests"]):
|
||
if t["id"] == tid:
|
||
QuickItemEditor(self.root, profile=self.profile, item=t, index=i,
|
||
on_save=self._on_item_saved,
|
||
on_delete=lambda idx=i: self._delete_item(idx))
|
||
return
|
||
|
||
def _on_item_saved(self, item, index):
|
||
"""快速编辑器保存回调"""
|
||
if index is None:
|
||
self.profile["tests"].append(item)
|
||
else:
|
||
self.profile["tests"][index] = item
|
||
save_profile(self.profile)
|
||
self._rebuild_tests()
|
||
|
||
def _delete_item(self, idx):
|
||
del self.profile["tests"][idx]
|
||
save_profile(self.profile)
|
||
self._rebuild_tests()
|
||
|
||
# ---------- 保存 ----------
|
||
def _report_file(self):
|
||
date = datetime.now().strftime("%Y-%m-%d")
|
||
safe_name = re.sub(r"[^\w\-.]+", "_", self.profile["product_name"])
|
||
batch_no = getattr(self, "batch_no_var", None)
|
||
if batch_no is not None:
|
||
bn = batch_no.get().strip() or "1"
|
||
safe_bn = re.sub(r"[^\w\-.]+", "_", bn)
|
||
return REPORTS_DIR / f"{safe_name}_{date}_批次{safe_bn}.csv"
|
||
return REPORTS_DIR / f"{safe_name}_{date}.csv"
|
||
|
||
def _save_and_next(self):
|
||
sn = self._current_sn()
|
||
if not self.current_mac:
|
||
if not messagebox.askyesno("提示", f"SN={sn} 尚未捕获到 MAC，仍要保存吗？"):
|
||
return
|
||
|
||
all_results = [w["result"] for w in self.test_widgets.values()]
|
||
if any(r is False for r in all_results):
|
||
overall = "FAIL"
|
||
elif any(r is None for r in all_results):
|
||
overall = "未完成"
|
||
else:
|
||
overall = "PASS"
|
||
|
||
rf = self._report_file()
|
||
# 当前表头
|
||
headers = ["时间", "SN", "MAC", "测试员", "产品"]
|
||
for test in self.profile["tests"]:
|
||
headers.append(test["name"])
|
||
headers += ["整体结果", "备注"]
|
||
|
||
# 表头一致性检查：若已有 CSV 列结构不同，归档旧文件
|
||
if rf.exists():
|
||
with open(rf, "r", encoding="utf-8-sig", newline="") as fr:
|
||
old_headers = next(csv.reader(fr), [])
|
||
if old_headers != headers:
|
||
ts = datetime.now().strftime("%H%M%S")
|
||
archived = rf.with_name(rf.stem + f"_archived_{ts}.csv")
|
||
rf.rename(archived)
|
||
messagebox.showinfo("CSV 表头已变",
|
||
f"测试项有变动，旧 CSV 已归档为:\n{archived.name}\n\n新数据将写入新 CSV。")
|
||
|
||
# 已入库重测：先删除原同 MAC 行（用户确认是同一台设备）
|
||
replaced = bool(self._replace_mac)
|
||
if replaced:
|
||
self._remove_csv_row_by_mac(self._replace_mac)
|
||
|
||
new_file = not rf.exists()
|
||
with open(rf, "a", newline="", encoding="utf-8-sig") as f:
|
||
writer = csv.writer(f)
|
||
if new_file:
|
||
writer.writerow(headers)
|
||
|
||
# FAIL 不占 SN，SN 列留空
|
||
sn_field = sn if overall == "PASS" else ""
|
||
row = [
|
||
datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
|
||
sn_field,
|
||
self.current_mac or "",
|
||
self.operator_var.get(),
|
||
self.profile["product_name"],
|
||
]
|
||
for test in self.profile["tests"]:
|
||
w = self.test_widgets[test["id"]]
|
||
if w["result"] is None:
|
||
cell = "—"
|
||
elif w["result"] is True:
|
||
if w["value"] not in (None, ""):
|
||
cell = f"PASS ({w['value']})"
|
||
elif w["hits"] > 0:
|
||
cell = f"PASS ({w['hits']}次)"
|
||
else:
|
||
cell = "PASS"
|
||
else:
|
||
cell = f"FAIL ({w['value']})" if w["value"] else "FAIL"
|
||
row.append(cell)
|
||
|
||
row.append(overall)
|
||
row.append("")
|
||
writer.writerow(row)
|
||
|
||
# 保存后重算下一个可用 SN（PASS 占用 +1；FAIL 不占用所以 spinbox 不变）
|
||
try:
|
||
self.sn_number_var.set(self._next_available_sn())
|
||
except (tk.TclError, ValueError):
|
||
pass
|
||
self._sync_sn_to_profile()
|
||
save_profile(self.profile)
|
||
self._save_global_settings()
|
||
self.count_var.set(f"{self.profile['product_name']} 已记录: {self._count_records()} 台")
|
||
self._refresh_stats()
|
||
replace_tag = "（已覆盖原记录）" if replaced else ""
|
||
messagebox.showinfo("已保存",
|
||
f"产品: {self.profile['product_name']}\nSN: {sn}\n"
|
||
f"MAC: {self.current_mac or '(无)'}\n结果: {overall}{replace_tag}\n\n"
|
||
f"已写入: {rf.name}\n准备下一台")
|
||
|
||
# 批次测满自动提示生成汇总
|
||
try:
|
||
batch = max(1, int(self.batch_size_var.get()))
|
||
except (tk.TclError, ValueError):
|
||
batch = 0
|
||
if batch and self._count_records() >= batch:
|
||
if messagebox.askyesno("批次已完成",
|
||
f"本批次 {batch} 套已全部测完！\n是否立即生成汇总报告？"):
|
||
self._export_summary()
|
||
|
||
# 保存完自动断开串口：本台测试结束，等测试员拔设备装下一台再连
|
||
if self.ser_running:
|
||
self._disconnect()
|
||
|
||
self.reset_state()
|
||
|
||
def _count_records(self):
|
||
rf = self._report_file()
|
||
if not rf.exists():
|
||
return 0
|
||
with open(rf, "r", encoding="utf-8-sig") as f:
|
||
return max(sum(1 for _ in f) - 1, 0)
|
||
|
||
def _open_report(self):
|
||
rf = self._report_file()
|
||
if rf.exists():
|
||
os.startfile(rf)
|
||
else:
|
||
messagebox.showinfo("提示", f"今日 {self.profile['product_name']} 还没有报告\n（{rf.name} 不存在）")
|
||
|
||
def _export_summary(self, silent=False):
|
||
"""生成统计汇总文件：弹对话框让用户选 .xlsx（居中）或 .csv（纯文本）"""
|
||
rf = self._report_file()
|
||
if not rf.exists():
|
||
if not silent:
|
||
messagebox.showinfo("提示", "今日还没有任何测试数据，先保存几台再导出汇总")
|
||
return None
|
||
|
||
total = pass_n = fail_n = 0
|
||
detail_rows = []
|
||
detail_headers = None
|
||
op_counts = {}
|
||
try:
|
||
with open(rf, "r", encoding="utf-8-sig", newline="") as f:
|
||
reader = csv.reader(f)
|
||
detail_headers = next(reader, None)
|
||
if detail_headers is None:
|
||
return None
|
||
try:
|
||
res_idx = detail_headers.index("整体结果")
|
||
except ValueError:
|
||
res_idx = None
|
||
try:
|
||
op_idx = detail_headers.index("测试员")
|
||
except ValueError:
|
||
op_idx = None
|
||
for r in reader:
|
||
detail_rows.append(r)
|
||
total += 1
|
||
if res_idx is not None and res_idx < len(r):
|
||
v = r[res_idx].strip()
|
||
if v == "PASS":
|
||
pass_n += 1
|
||
elif v == "FAIL":
|
||
fail_n += 1
|
||
if op_idx is not None and op_idx < len(r):
|
||
op = r[op_idx].strip()
|
||
if op:
|
||
op_counts[op] = op_counts.get(op, 0) + 1
|
||
except Exception as e:
|
||
messagebox.showerror("读取明细失败", str(e))
|
||
return None
|
||
|
||
# 测试员汇总：从明细去重统计每人测了多少台（追责依据，跟明细一致）
|
||
if op_counts:
|
||
ops_str = ", ".join(f"{k}({v}台)" for k, v in op_counts.items())
|
||
else:
|
||
ops_str = self.operator_var.get() or "—"
|
||
|
||
try:
|
||
batch = max(1, int(self.batch_size_var.get()))
|
||
except (tk.TclError, ValueError):
|
||
batch = 1
|
||
remain = max(0, batch - total)
|
||
pass_rate = f"{pass_n / total * 100:.2f}%" if total else "—"
|
||
fail_rate = f"{fail_n / total * 100:.2f}%" if total else "—"
|
||
|
||
ts = datetime.now().strftime("%H%M%S")
|
||
safe = re.sub(r"[^\w\-.]+", "_", self.profile["product_name"])
|
||
date = datetime.now().strftime("%Y-%m-%d")
|
||
default_name = f"{safe}_{date}_汇总_{ts}"
|
||
|
||
# 弹保存对话框，让用户选格式
|
||
types = []
|
||
if HAS_OPENPYXL:
|
||
types.append(("Excel (.xlsx) — 居中、可保留格式", "*.xlsx"))
|
||
types.append(("CSV (.csv) — 纯文本", "*.csv"))
|
||
fpath = filedialog.asksaveasfilename(
|
||
title="导出统计汇总 — 选择格式",
|
||
initialdir=str(REPORTS_DIR),
|
||
initialfile=default_name,
|
||
defaultextension=".xlsx" if HAS_OPENPYXL else ".csv",
|
||
filetypes=types,
|
||
)
|
||
if not fpath:
|
||
return None
|
||
sumf = Path(fpath)
|
||
|
||
batch_no = (self.batch_no_var.get().strip() if hasattr(self, "batch_no_var") else "") or "—"
|
||
summary_pairs = [
|
||
("产品", self.profile["product_name"]),
|
||
("日期", date),
|
||
("测试员", ops_str),
|
||
("批次号", batch_no),
|
||
("数量", batch),
|
||
("累计已测", total),
|
||
("合格", pass_n),
|
||
("不合格", fail_n),
|
||
("未测", remain),
|
||
("合格率", pass_rate),
|
||
("不良率", fail_rate),
|
||
("生成时间", datetime.now().strftime("%Y-%m-%d %H:%M:%S")),
|
||
]
|
||
|
||
try:
|
||
if sumf.suffix.lower() == ".xlsx" and HAS_OPENPYXL:
|
||
self._write_summary_xlsx(sumf, summary_pairs, detail_headers, detail_rows)
|
||
else:
|
||
self._write_summary_csv(sumf, summary_pairs, detail_headers, detail_rows)
|
||
except Exception as e:
|
||
messagebox.showerror("写入失败", str(e))
|
||
return None
|
||
|
||
if not silent:
|
||
if messagebox.askyesno("汇总已生成",
|
||
f"已生成: {sumf.name}\n\n"
|
||
f"批次 {batch} 累计 {total} 合格 {pass_n} 不合格 {fail_n} 未测 {remain}\n"
|
||
f"合格率 {pass_rate} 不良率 {fail_rate}\n\n是否立即打开？"):
|
||
os.startfile(sumf)
|
||
return sumf
|
||
|
||
def _write_summary_csv(self, sumf, pairs, detail_headers, detail_rows):
|
||
with open(sumf, "w", encoding="utf-8-sig", newline="") as f:
|
||
w = csv.writer(f)
|
||
w.writerow(["=== 测试汇总 ==="])
|
||
for k, v in pairs:
|
||
w.writerow([k, v])
|
||
w.writerow([])
|
||
w.writerow(["=== 明细数据 ==="])
|
||
if detail_headers:
|
||
w.writerow(detail_headers)
|
||
for r in detail_rows:
|
||
w.writerow(r)
|
||
|
||
def _write_summary_xlsx(self, sumf, pairs, detail_headers, detail_rows):
|
||
wb = Workbook()
|
||
center = Alignment(horizontal="center", vertical="center")
|
||
bold = Font(bold=True)
|
||
fail_font = Font(bold=True, color="FFD32F2F")
|
||
|
||
# 找列索引以分类 + 高亮
|
||
sn_col = mac_col = res_col = None
|
||
if detail_headers:
|
||
for name, attr in (("SN", "sn_col"), ("MAC", "mac_col"), ("整体结果", "res_col")):
|
||
try:
|
||
if attr == "sn_col":
|
||
sn_col = detail_headers.index(name) + 1
|
||
elif attr == "mac_col":
|
||
mac_col = detail_headers.index(name) + 1
|
||
elif attr == "res_col":
|
||
res_col = detail_headers.index(name) + 1
|
||
except ValueError:
|
||
pass
|
||
|
||
pass_rows, fail_rows = [], []
|
||
if res_col is not None:
|
||
idx = res_col - 1
|
||
for r in detail_rows:
|
||
v = r[idx].strip() if idx < len(r) else ""
|
||
if v == "PASS":
|
||
pass_rows.append(r)
|
||
elif v == "FAIL":
|
||
fail_rows.append(r)
|
||
else:
|
||
pass_rows = list(detail_rows)
|
||
|
||
# Sheet 1：测试汇总
|
||
ws1 = wb.active
|
||
ws1.title = "测试汇总"
|
||
for k, v in pairs:
|
||
ws1.append([k, v])
|
||
ws1.cell(row=ws1.max_row, column=1).font = bold
|
||
|
||
# Sheet 2：PASS 明细（已入库）
|
||
ws2 = wb.create_sheet("PASS 明细")
|
||
if detail_headers:
|
||
ws2.append(detail_headers)
|
||
for c in range(1, len(detail_headers) + 1):
|
||
ws2.cell(row=1, column=c).font = bold
|
||
for r in pass_rows:
|
||
ws2.append(r)
|
||
|
||
# Sheet 3：FAIL 明细（未入库，SN/MAC 红字加粗）
|
||
ws3 = wb.create_sheet("FAIL 明细")
|
||
if detail_headers:
|
||
ws3.append(detail_headers)
|
||
for c in range(1, len(detail_headers) + 1):
|
||
ws3.cell(row=1, column=c).font = bold
|
||
for r in fail_rows:
|
||
ws3.append(r)
|
||
for i in range(2, ws3.max_row + 1):
|
||
if sn_col is not None:
|
||
ws3.cell(row=i, column=sn_col).font = fail_font
|
||
if mac_col is not None:
|
||
ws3.cell(row=i, column=mac_col).font = fail_font
|
||
|
||
# 通用样式：所有单元格居中 + 自适应列宽
|
||
for ws in (ws1, ws2, ws3):
|
||
for row in ws.iter_rows():
|
||
for cell in row:
|
||
cell.alignment = center
|
||
for col_cells in ws.columns:
|
||
col_letter = col_cells[0].column_letter
|
||
max_len = 0
|
||
for cell in col_cells:
|
||
val = str(cell.value) if cell.value is not None else ""
|
||
length = sum(2 if ord(c) > 127 else 1 for c in val)
|
||
if length > max_len:
|
||
max_len = length
|
||
ws.column_dimensions[col_letter].width = min(50, max(10, max_len + 2))
|
||
|
||
wb.save(sumf)
|
||
|
||
def _save_global_settings(self):
|
||
self.settings["serial"]["port"] = self.port_var.get()
|
||
try:
|
||
self.settings["serial"]["baudrate"] = int(self.baud_var.get())
|
||
except ValueError:
|
||
pass
|
||
self.settings["operator"] = self.operator_var.get()
|
||
if hasattr(self, "auto_clear_log_var"):
|
||
self.settings["auto_clear_log_on_disconnect"] = self.auto_clear_log_var.get()
|
||
save_settings(self.settings)
|
||
|
||
def _set_window_icon(self):
|
||
"""设置窗口标题栏图标（兼容 PyInstaller --onefile 打包后从临时目录读取）"""
|
||
try:
|
||
if getattr(sys, "frozen", False):
|
||
ico = Path(sys._MEIPASS) / "icon.ico"
|
||
else:
|
||
ico = Path(__file__).parent / "icon.ico"
|
||
if ico.exists():
|
||
self.root.iconbitmap(str(ico))
|
||
except Exception:
|
||
pass
|
||
|
||
def _on_close(self):
|
||
self._sync_sn_to_profile()
|
||
save_profile(self.profile)
|
||
self._save_global_settings()
|
||
self._disconnect()
|
||
self.root.destroy()
|
||
|
||
|
||
def main():
|
||
root = tk.Tk()
|
||
try:
|
||
style = ttk.Style()
|
||
if "vista" in style.theme_names():
|
||
style.theme_use("vista")
|
||
except Exception:
|
||
pass
|
||
TestJig(root)
|
||
root.mainloop()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|