feat: 加入了一系列调试和分析工具,包括 SCPI REPL、示波器数据查看器、声速检测器等,方便开发和实验调试。
fix: 修复实验页面中实验状态未正确更新的问题,确保实验状态在前端和后端之间保持一致。 docs: 添加了SCPI文档和总程序设计架构
这个提交包含在:
2838
backend/SCPI.md
普通文件
2838
backend/SCPI.md
普通文件
文件差异内容过多而无法显示
加载差异
@ -139,3 +139,28 @@ async def clear_all_field_values(x_session_id: str | None = Header(default=None)
|
||||
session_id = resolve_session_id(x_session_id)
|
||||
removed_count = session_store.clear(session_id)
|
||||
return {"message": f"cleared {removed_count} field values", "success": True, "session_id": session_id}
|
||||
|
||||
|
||||
@router.post("/reset")
|
||||
async def reset_experiment(
|
||||
experiment: str = Query(default="cn.edu.muc.lxy.phyexp.voicespeed"),
|
||||
x_session_id: str | None = Header(default=None),
|
||||
):
|
||||
session_id = resolve_session_id(x_session_id)
|
||||
session_store.clear(session_id)
|
||||
reading_guard_manager.reset_session(session_id)
|
||||
all_fields = list_fields(experiment)
|
||||
guard_fields = [
|
||||
f.fieldId for f in all_fields
|
||||
if f.readingGuard is not None and f.readingGuard.enabled
|
||||
]
|
||||
ctrl = _peak_monitor_status_text(session_id)
|
||||
return {
|
||||
"success": True,
|
||||
"message": "experiment state reset",
|
||||
"session_id": session_id,
|
||||
"pending_field": guard_fields[0] if guard_fields else None,
|
||||
"cursor": 0,
|
||||
"total": len(guard_fields),
|
||||
"control_status": ctrl,
|
||||
}
|
||||
|
||||
@ -67,6 +67,10 @@ class ReadingGuardManager:
|
||||
src = state.source.value if isinstance(state.source, ReadingGuardSource) else str(state.source)
|
||||
return (state.pending_field, src, state.tolerance)
|
||||
|
||||
def reset_session(self, session_id: str) -> None:
|
||||
with self._lock:
|
||||
self._sessions.pop(session_id, None)
|
||||
|
||||
def get_cursor(self, session_id: str) -> tuple[int, int]:
|
||||
with self._lock:
|
||||
state = self._sessions.get(session_id)
|
||||
@ -233,8 +237,19 @@ class ReadingGuardManager:
|
||||
state.pending_answer = self._capture_answer(state.source, current_field.fieldId, state)
|
||||
|
||||
if state.pending_answer is None:
|
||||
source_label = "OCR" if state.source == ReadingGuardSource.PEAK_OCR else "standard reading"
|
||||
return {"accept": False, "message": f"{source_label} not yet captured, please wait for peak detection or retry", "severity": "error", "reference": None}
|
||||
if state.source in (ReadingGuardSource.DEVICE_PEAK, ReadingGuardSource.DEVICE_FREQUENCY):
|
||||
state.cursor += 1
|
||||
fields_map = {f.fieldId: f for f in all_fields}
|
||||
self._arm_next(state, fields_map)
|
||||
return {
|
||||
"accept": True,
|
||||
"message": f"设备离线,无法获取参考读数,已直接记录。等待下一个: {state.pending_field or '完成'}",
|
||||
"severity": "warning",
|
||||
"reference": None,
|
||||
}
|
||||
if state.source == ReadingGuardSource.PEAK_OCR:
|
||||
return {"accept": False, "message": "OCR not yet captured, please wait for peak detection or retry", "severity": "error", "reference": None}
|
||||
return {"accept": False, "message": f"manual reference for '{current_field.fieldId}' not yet set", "severity": "error", "reference": None}
|
||||
|
||||
try:
|
||||
student_value = float(current_value)
|
||||
|
||||
二进制
backend/chart.png
普通文件
二进制
backend/chart.png
普通文件
二进制文件未显示。
|
之后 宽度: | 高度: | 大小: 44 KiB |
二进制
backend/chart2.png
普通文件
二进制
backend/chart2.png
普通文件
二进制文件未显示。
|
之后 宽度: | 高度: | 大小: 58 KiB |
@ -7,7 +7,13 @@ requires-python = ">=3.10"
|
||||
dependencies = [
|
||||
"fastapi[standard]>=0.116.1",
|
||||
"libusb>=1.0.29.post7",
|
||||
"matplotlib>=3.10.9",
|
||||
"numpy>=2.2.6",
|
||||
"pillow>=12.2.0",
|
||||
"pydantic>=2.11.3",
|
||||
"pyqt5>=5.15.11",
|
||||
"pyqtgraph>=0.14.0",
|
||||
"pyusb>=1.3.1",
|
||||
"scipy>=1.15.3",
|
||||
"uvicorn>=0.35.0",
|
||||
]
|
||||
|
||||
304
backend/tools/ch2_plotter.py
普通文件
304
backend/tools/ch2_plotter.py
普通文件
@ -0,0 +1,304 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
CH2 实时数据绘图器 — 接收 ch2_recorder.py 的 stdout 管道,实时绘制测量值曲线。
|
||||
|
||||
用法:
|
||||
python ch2_recorder.py -i 200 -n 100 | python ch2_plotter.py
|
||||
python ch2_recorder.py -i 200 | python ch2_plotter.py --fields pkpk_v,avg_v,rms_v
|
||||
python ch2_recorder.py -i 200 -n 50 | python ch2_plotter.py -o chart.png
|
||||
python ch2_plotter.py --file ch2_log.jsonl # 读取已有日志
|
||||
|
||||
特性:
|
||||
- 从 stdin 逐行读取 JSON,实时更新多子图曲线
|
||||
- 支持 --fields 选择绘图字段,默认全绘
|
||||
- 支持 --window 设置滚动窗口(秒),0 表示不滚动
|
||||
- 支持 --output 保存最终图像
|
||||
- 支持 --file 读取已有日志文件回放
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import select
|
||||
import sys
|
||||
import time
|
||||
from collections import defaultdict
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Optional
|
||||
|
||||
import matplotlib
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
|
||||
# ─── 字段分组 ────────────────────────────────────────────────────
|
||||
|
||||
# 字段 → (子图标题, 单位)
|
||||
FIELD_GROUPS: dict[str, tuple[str, str]] = {
|
||||
# Voltage group
|
||||
"max_v": ("Voltage (V)", "V"),
|
||||
"min_v": ("Voltage (V)", "V"),
|
||||
"pkpk_v": ("Voltage (V)", "V"),
|
||||
"vtop_v": ("Voltage (V)", "V"),
|
||||
"vbase_v": ("Voltage (V)", "V"),
|
||||
"vamp_v": ("Voltage (V)", "V"),
|
||||
"avg_v": ("Voltage (V)", "V"),
|
||||
"rms_v": ("Voltage (V)", "V"),
|
||||
"cycrms_v": ("Voltage (V)", "V"),
|
||||
"curs_rms_v": ("Voltage (V)", "V"),
|
||||
"std_v": ("Voltage (V)", "V"),
|
||||
# Time/Freq group
|
||||
"period": ("Time / Freq", "s"),
|
||||
"freq": ("Time / Freq", "Hz"),
|
||||
# Misc
|
||||
"num_points": ("Points", ""),
|
||||
"vdiv": ("Scale", "V/div"),
|
||||
"offset_v": ("Offset (V)", "V"),
|
||||
}
|
||||
|
||||
# 默认颜色循环
|
||||
_COLORS = [
|
||||
"#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
|
||||
"#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf",
|
||||
]
|
||||
|
||||
# 字段 → 颜色(保持稳定)
|
||||
_field_colors: dict[str, str] = {}
|
||||
_color_idx = 0
|
||||
|
||||
|
||||
def _get_color(field: str) -> str:
|
||||
global _color_idx
|
||||
if field not in _field_colors:
|
||||
_field_colors[field] = _COLORS[_color_idx % len(_COLORS)]
|
||||
_color_idx += 1
|
||||
return _field_colors[field]
|
||||
|
||||
|
||||
# ─── 数据结构 ────────────────────────────────────────────────────
|
||||
|
||||
|
||||
@dataclass
|
||||
class PlotterState:
|
||||
window_sec: float = 0.0
|
||||
times: list[float] = field(default_factory=list)
|
||||
data: dict = field(default_factory=lambda: defaultdict(list))
|
||||
start_time: Optional[float] = None
|
||||
fig: Optional[object] = None # plt.Figure
|
||||
axes: dict = field(default_factory=dict) # {str: plt.Axes}
|
||||
lines: dict = field(default_factory=dict) # {str: plt.Line2D}
|
||||
fields: list[str] = field(default_factory=list)
|
||||
|
||||
def init_figure(self):
|
||||
group_names = []
|
||||
seen = set()
|
||||
for f in self.fields:
|
||||
g = FIELD_GROUPS.get(f, ("其他", ""))[0]
|
||||
if g not in seen:
|
||||
group_names.append(g)
|
||||
seen.add(g)
|
||||
|
||||
nrows = len(group_names)
|
||||
self.fig, axs = plt.subplots(nrows, 1, figsize=(14, 2.5 * nrows),
|
||||
sharex=True, squeeze=False)
|
||||
self.fig.canvas.manager.set_window_title("CH2 Real-time Monitor")
|
||||
for i, gname in enumerate(group_names):
|
||||
ax = axs[i][0]
|
||||
ax.set_ylabel(gname)
|
||||
ax.grid(True, alpha=0.3)
|
||||
self.axes[gname] = ax
|
||||
|
||||
if group_names:
|
||||
axs[-1][0].set_xlabel("Time (s)")
|
||||
|
||||
# 初始化空线
|
||||
for f in self.fields:
|
||||
gname = FIELD_GROUPS.get(f, ("其他", ""))[0]
|
||||
unit = FIELD_GROUPS.get(f, ("", ""))[1]
|
||||
label = f"{f}"
|
||||
if unit:
|
||||
label += f" [{unit}]"
|
||||
(line,) = self.axes[gname].plot(
|
||||
[], [], label=label, color=_get_color(f), linewidth=1.2
|
||||
)
|
||||
self.lines[f] = line
|
||||
self.axes[gname].legend(loc="upper right", fontsize=7)
|
||||
|
||||
plt.tight_layout()
|
||||
|
||||
def append(self, record: dict) -> int:
|
||||
ts = record.get("timestamp", time.time())
|
||||
if self.start_time is None:
|
||||
self.start_time = ts
|
||||
rel_time = ts - self.start_time
|
||||
|
||||
self.times.append(rel_time)
|
||||
for f in self.fields:
|
||||
val = record.get(f)
|
||||
self.data[f].append(val if val is not None else np.nan)
|
||||
|
||||
if self.window_sec > 0 and len(self.times) > 1:
|
||||
cutoff = rel_time - self.window_sec
|
||||
while len(self.times) > 1 and self.times[0] < cutoff:
|
||||
self.times.pop(0)
|
||||
for f in self.fields:
|
||||
self.data[f].pop(0)
|
||||
|
||||
return len(self.times)
|
||||
|
||||
def update_plot(self) -> bool:
|
||||
if not self.fig or not self.times:
|
||||
return False
|
||||
|
||||
for f in self.fields:
|
||||
line = self.lines.get(f)
|
||||
if line is None:
|
||||
continue
|
||||
xs = np.array(self.times)
|
||||
ys = np.array(self.data[f], dtype=np.float64)
|
||||
line.set_data(xs, ys)
|
||||
|
||||
for ax in self.axes.values():
|
||||
ax.relim()
|
||||
ax.autoscale_view(scaley=True)
|
||||
|
||||
gname = list(self.axes.keys())[-1] if self.axes else None
|
||||
if gname:
|
||||
self.axes[gname].relim()
|
||||
self.axes[gname].autoscale_view(scalex=True)
|
||||
|
||||
self.fig.canvas.draw_idle()
|
||||
self.fig.canvas.flush_events()
|
||||
return True
|
||||
|
||||
|
||||
# ─── 主逻辑 ──────────────────────────────────────────────────────
|
||||
|
||||
|
||||
def _parse_fields_arg(raw: Optional[str]) -> list[str]:
|
||||
if raw is None:
|
||||
# 默认绘制所有电压 + 时间/频率字段
|
||||
defaults = ["pkpk_v", "avg_v", "rms_v", "max_v", "min_v"]
|
||||
return defaults
|
||||
return [f.strip() for f in raw.split(",") if f.strip()]
|
||||
|
||||
|
||||
def _is_interactive() -> bool:
|
||||
return matplotlib.get_backend().lower() != "agg"
|
||||
|
||||
|
||||
def _read_stream(stream, state: PlotterState, pause_sec: float = 0.05):
|
||||
"""从流中逐行读取 JSON,实时更新绘图。"""
|
||||
buf = ""
|
||||
update_every = 3 # 每 N 条数据刷新一次图
|
||||
|
||||
interactive = _is_interactive()
|
||||
if interactive:
|
||||
plt.ion()
|
||||
state.init_figure()
|
||||
plt.show(block=False)
|
||||
else:
|
||||
state.init_figure()
|
||||
|
||||
count = 0
|
||||
try:
|
||||
while True:
|
||||
if stream is sys.stdin:
|
||||
# 用 select 检查是否有数据可读
|
||||
ready, _, _ = select.select([sys.stdin], [], [], 0.1)
|
||||
if not ready:
|
||||
# 无数据时也刷新图
|
||||
if count > 0:
|
||||
state.update_plot()
|
||||
continue
|
||||
chunk = sys.stdin.read(4096)
|
||||
if not chunk:
|
||||
break
|
||||
else:
|
||||
chunk = stream.read(4096)
|
||||
if not chunk:
|
||||
break
|
||||
|
||||
buf += chunk
|
||||
while "\n" in buf:
|
||||
line, buf = buf.split("\n", 1)
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
try:
|
||||
record = json.loads(line)
|
||||
except json.JSONDecodeError:
|
||||
# 跳过分隔行 (如 stderr 的日志混入)
|
||||
continue
|
||||
|
||||
count = state.append(record)
|
||||
if count % update_every == 0:
|
||||
state.update_plot()
|
||||
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
finally:
|
||||
state.update_plot()
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="CH2 实时数据绘图器 — 接收 ch2_recorder.py 管道输出并实时绘图",
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
epilog="""
|
||||
示例:
|
||||
python ch2_recorder.py -i 200 | python ch2_plotter.py
|
||||
python ch2_recorder.py -i 200 | python ch2_plotter.py -f pkpk_v,avg_v,rms_v,freq
|
||||
python ch2_plotter.py --file ch2_log.jsonl -o chart.png
|
||||
python ch2_recorder.py -i 200 -n 500 | python ch2_plotter.py -w 30 -o result.png
|
||||
""",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-f", "--fields", type=str, default=None,
|
||||
help="要绘制的字段,逗号分隔 (默认: pkpk_v,avg_v,rms_v,max_v,min_v)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-w", "--window", type=float, default=0.0,
|
||||
help="滚动时间窗口 (秒),0 表示显示全部数据 (默认 0)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-o", "--output", type=str, default=None,
|
||||
help="保存最终图像到文件 (PNG/SVG/PDF),不指定则仅显示",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--file", type=str, default=None,
|
||||
help="读取已有 JSONL 日志文件(而非 stdin 管道)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--backend", type=str, default=None,
|
||||
help="matplotlib 后端 (如 TkAgg, Qt5Agg, Agg),默认自动选择",
|
||||
)
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.backend:
|
||||
matplotlib.use(args.backend)
|
||||
|
||||
fields = _parse_fields_arg(args.fields)
|
||||
state = PlotterState(window_sec=args.window, fields=fields)
|
||||
|
||||
if args.file:
|
||||
with open(args.file, "r") as f:
|
||||
_read_stream(f, state)
|
||||
else:
|
||||
_read_stream(sys.stdin, state)
|
||||
|
||||
if args.output:
|
||||
state.fig.savefig(args.output, dpi=150, bbox_inches="tight")
|
||||
print(f"\n[INFO] Chart saved: {args.output}", file=sys.stderr)
|
||||
|
||||
print(f"\n[INFO] Total data points: {len(state.times)}", file=sys.stderr)
|
||||
|
||||
if _is_interactive():
|
||||
try:
|
||||
plt.show(block=True)
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
746
backend/tools/ch2_recorder.py
普通文件
746
backend/tools/ch2_recorder.py
普通文件
@ -0,0 +1,746 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
CH2 通道实时数据采集记录器 (NDS202E / NDS102U 兼容)
|
||||
|
||||
通过原生 PyUSB (libusb) + SCPI 协议与 OWON 示波器通信,
|
||||
按可配置的采样间隔获取 CH2 通道的测量值 (min/max/pkpk/avg/rms 等),
|
||||
并打上时间戳记录。
|
||||
|
||||
基于实际 NDS202E (V5.1.0) 固件调研结果,适配了真实返回格式:
|
||||
- 所有响应以 "->\\n" 结尾
|
||||
- HEAD JSON 使用全大写 key (TIMEBASE/CHANNEL/...)
|
||||
- :MEASUrement 单项返回格式如 "Ma : 12.00V->"
|
||||
- :MEASUrement:CH2? 返回 JSON (含 \\t? 表示无效值)
|
||||
|
||||
用法:
|
||||
python ch2_recorder.py # 默认 500ms 间隔,stdout (JSON)
|
||||
python ch2_recorder.py -i 200 -o ch2.csv # 200ms 间隔,CSV 文件
|
||||
python ch2_recorder.py -i 100 -n 100 # 100ms 间隔,采集 100 次
|
||||
python ch2_recorder.py --mode measure # 硬件测量模式 (实时,推荐)
|
||||
python ch2_recorder.py --mode waveform # 数据接口 + 软件计算 (需强制触发)
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import csv
|
||||
import json
|
||||
import re
|
||||
import signal
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
from typing import Optional
|
||||
|
||||
import numpy as np
|
||||
import usb.core
|
||||
import usb.util
|
||||
|
||||
# ─── 常量 ─────────────────────────────────────────────────────────
|
||||
|
||||
DEFAULT_VID = 0x5345
|
||||
DEFAULT_PID = 0x1234
|
||||
DEFAULT_TIMEOUT_MS = 5000
|
||||
_DEFAULT_INTERVAL_MS = 500
|
||||
|
||||
# 电压换算
|
||||
_SCREEN_DIVS_V = 8 # 垂直分度数
|
||||
_ADC_MAX = 0x1000 # 12-bit = 4096
|
||||
|
||||
# 响应后缀: NDS202E V5.1.0 所有查询响应以 "->\\n" 结尾
|
||||
_RESP_SUFFIX = re.compile(rb'\s*->\s*$')
|
||||
|
||||
_SCALE_RE = re.compile(r"([\d.]+)\s*([numk]?[sv])\s*", re.IGNORECASE)
|
||||
_UNIT_MULTIPLIERS: dict[str, float] = {
|
||||
"nv": 1e-9, "uv": 1e-6, "mv": 1e-3, "v": 1.0, "kv": 1e3,
|
||||
"ns": 1e-9, "us": 1e-6, "ms": 1e-3, "s": 1.0, "ks": 1e3,
|
||||
}
|
||||
_NUMERIC_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
|
||||
|
||||
# ─── 解析工具 ────────────────────────────────────────────────────
|
||||
|
||||
|
||||
def parse_scale_str(raw: str) -> float:
|
||||
m = _SCALE_RE.search(raw.lower().strip())
|
||||
if m:
|
||||
return float(m.group(1)) * _UNIT_MULTIPLIERS.get(m.group(2), 1.0)
|
||||
try:
|
||||
return float(raw)
|
||||
except (ValueError, TypeError):
|
||||
return 1.0
|
||||
|
||||
|
||||
def parse_probe_ratio(raw: str) -> float:
|
||||
try:
|
||||
return float(raw.strip().lower().rstrip("x"))
|
||||
except (ValueError, TypeError):
|
||||
return 1.0
|
||||
|
||||
|
||||
def strip_resp_suffix(data: bytes) -> bytes:
|
||||
"""去除 NDS202E 响应末尾的 '->' 后缀。"""
|
||||
return _RESP_SUFFIX.sub(b'', data)
|
||||
|
||||
|
||||
def extract_numeric(text: str) -> Optional[float]:
|
||||
m = _NUMERIC_RE.search(text)
|
||||
if m is None:
|
||||
return None
|
||||
try:
|
||||
return float(m.group())
|
||||
except (ValueError, OverflowError):
|
||||
return None
|
||||
|
||||
|
||||
def clean_meas_text(text: str) -> str:
|
||||
"""清理测量响应文本: 去掉前缀标签 + 单位后缀, 仅保留数值。"""
|
||||
# 格式如 "Ma : 12.00V->" → "12.00"
|
||||
# "Vpp: 24.00V->" → "24.00"
|
||||
# "V : 1.892V->" → "1.892"
|
||||
# "T: 26.920us->" → "26.920"
|
||||
# "F: 37.15KHz->" → "37.15"
|
||||
# "Vt : \t?->" → None (无有效值)
|
||||
text = text.strip()
|
||||
# 去掉 "->" 后缀
|
||||
if text.endswith("->"):
|
||||
text = text[:-2].strip()
|
||||
# 提取数值部分
|
||||
val = extract_numeric(text)
|
||||
return str(val) if val is not None else ""
|
||||
|
||||
|
||||
# ─── USB SCPI 通信(原生 PyUSB)─────────────────────────────────
|
||||
|
||||
|
||||
class ScpiDevice:
|
||||
"""原生 PyUSB SCPI 通信器 — 直接操作 USB 批量端点。"""
|
||||
|
||||
def __init__(self, vid: int = DEFAULT_VID, pid: int = DEFAULT_PID):
|
||||
self._vid = vid
|
||||
self._pid = pid
|
||||
self._dev: Optional[usb.core.Device] = None
|
||||
self._ep_out: Optional[usb.core.Endpoint] = None
|
||||
self._ep_in: Optional[usb.core.Endpoint] = None
|
||||
self._max_pkt: int = 512
|
||||
self._detached: list[int] = []
|
||||
|
||||
def open(self):
|
||||
dev = usb.core.find(idVendor=self._vid, idProduct=self._pid)
|
||||
if dev is None:
|
||||
raise RuntimeError(
|
||||
f"设备未找到 (VID=0x{self._vid:04X}, PID=0x{self._pid:04X})"
|
||||
)
|
||||
self._dev = dev
|
||||
|
||||
for cfg in self._dev:
|
||||
for intf in cfg:
|
||||
ifn = intf.bInterfaceNumber
|
||||
if self._dev.is_kernel_driver_active(ifn):
|
||||
self._dev.detach_kernel_driver(ifn)
|
||||
self._detached.append(ifn)
|
||||
|
||||
self._dev.set_configuration()
|
||||
|
||||
intf = self._dev.get_active_configuration()[(0, 0)]
|
||||
for ep in intf:
|
||||
dir_ = usb.util.endpoint_direction(ep.bEndpointAddress)
|
||||
if dir_ == usb.util.ENDPOINT_OUT:
|
||||
self._ep_out = ep
|
||||
elif dir_ == usb.util.ENDPOINT_IN:
|
||||
self._ep_in = ep
|
||||
|
||||
if not self._ep_out or not self._ep_in:
|
||||
raise RuntimeError("未找到批量端点")
|
||||
self._max_pkt = self._ep_in.wMaxPacketSize
|
||||
|
||||
def close(self):
|
||||
if self._dev is None:
|
||||
return
|
||||
for ifn in self._detached:
|
||||
try:
|
||||
self._dev.attach_kernel_driver(ifn)
|
||||
except usb.core.USBError:
|
||||
pass
|
||||
self._detached.clear()
|
||||
try:
|
||||
usb.util.dispose_resources(self._dev)
|
||||
except Exception:
|
||||
pass
|
||||
self._dev = None
|
||||
self._ep_out = None
|
||||
self._ep_in = None
|
||||
|
||||
def __enter__(self):
|
||||
self.open()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.close()
|
||||
|
||||
def write(self, cmd: bytes, timeout: int = DEFAULT_TIMEOUT_MS) -> None:
|
||||
self._dev.write(self._ep_out, cmd, timeout=timeout)
|
||||
|
||||
def read(self, timeout: int = DEFAULT_TIMEOUT_MS) -> bytes:
|
||||
resp = b""
|
||||
while True:
|
||||
try:
|
||||
data = self._dev.read(self._ep_in, self._max_pkt, timeout=timeout)
|
||||
if not data:
|
||||
break
|
||||
resp += data.tobytes()
|
||||
if len(data) < self._max_pkt:
|
||||
break
|
||||
except usb.core.USBError as e:
|
||||
if e.errno == 110:
|
||||
break
|
||||
raise
|
||||
return resp
|
||||
|
||||
def flush_input(self) -> None:
|
||||
try:
|
||||
while True:
|
||||
self._dev.read(self._ep_in, self._max_pkt, timeout=50)
|
||||
except usb.core.USBError:
|
||||
pass
|
||||
|
||||
def send(self, scpi: str, timeout: int = DEFAULT_TIMEOUT_MS) -> bytes:
|
||||
"""发送 SCPI 命令,返回去除后缀的原始响应。"""
|
||||
if not scpi.endswith("\n"):
|
||||
scpi += "\n"
|
||||
self.flush_input()
|
||||
self.write(scpi.encode("ascii"), timeout=timeout)
|
||||
raw = self.read(timeout=timeout)
|
||||
return strip_resp_suffix(raw)
|
||||
|
||||
def send_text(self, scpi: str, timeout: int = DEFAULT_TIMEOUT_MS) -> str:
|
||||
"""发送 SCPI 查询命令,返回解码后的文本。"""
|
||||
return self.send(scpi, timeout).decode("ascii", errors="ignore").strip()
|
||||
|
||||
def write_cmd(self, scpi: str, timeout: int = DEFAULT_TIMEOUT_MS) -> None:
|
||||
"""发送 SCPI 设置命令(无返回值,不等待响应)。"""
|
||||
if not scpi.endswith("\n"):
|
||||
scpi += "\n"
|
||||
self.flush_input()
|
||||
self.write(scpi.encode("ascii"), timeout=timeout)
|
||||
|
||||
def idn(self) -> str:
|
||||
return self.send_text("*IDN?")
|
||||
|
||||
|
||||
# ─── HEAD 解析 (适配 NDS202E 全大写 JSON) ───────────────────────
|
||||
|
||||
|
||||
@dataclass
|
||||
class ChannelParams:
|
||||
name: str = ""
|
||||
display: bool = True
|
||||
coupling: str = "dc"
|
||||
probe: str = "1x"
|
||||
scale: str = "1v"
|
||||
offset_head: int = 0 # HEAD 中的 OFFSET (单位: 1/250 div, NDS202E)
|
||||
offset_volts: float = 0.0 # SCPI 查询得到的实际电压偏移
|
||||
inverse: bool = False
|
||||
|
||||
@property
|
||||
def vdiv(self) -> float:
|
||||
return parse_scale_str(self.scale)
|
||||
|
||||
@property
|
||||
def probe_ratio(self) -> float:
|
||||
return parse_probe_ratio(self.probe)
|
||||
|
||||
|
||||
def fetch_head(dev: ScpiDevice) -> Optional[dict]:
|
||||
resp = dev.send(":DATA:WAVE:SCREen:HEAD?")
|
||||
if not resp or len(resp) < 4:
|
||||
return None
|
||||
payload_len = struct.unpack("<I", resp[:4])[0]
|
||||
payload = resp[4:]
|
||||
if len(payload) != payload_len:
|
||||
return None
|
||||
try:
|
||||
return json.loads(payload.decode("ascii", errors="ignore"))
|
||||
except (json.JSONDecodeError, UnicodeDecodeError):
|
||||
return None
|
||||
|
||||
|
||||
def get_channel_params(head: dict, dev: ScpiDevice,
|
||||
ch_name: str = "CH2") -> Optional[ChannelParams]:
|
||||
"""从 HEAD 提取通道参数,并用 SCPI 查询补全实际 offset。"""
|
||||
for ch in head.get("CHANNEL", []):
|
||||
if ch.get("NAME", "").upper() == ch_name.upper():
|
||||
# 通过 SCPI 查询获取实际电压偏移 (比 HEAD OFFSET 更准确)
|
||||
offset_v = 0.0
|
||||
try:
|
||||
offset_text = dev.send_text(f":{ch_name}:OFFSET?")
|
||||
offset_v = extract_numeric(offset_text) or 0.0
|
||||
except Exception:
|
||||
pass
|
||||
return ChannelParams(
|
||||
name=ch.get("NAME", ""),
|
||||
display=ch.get("DISPLAY", "ON").upper() == "ON",
|
||||
coupling=ch.get("COUPLING", "DC"),
|
||||
probe=ch.get("PROBE", "1X"),
|
||||
scale=ch.get("SCALE", "1V"),
|
||||
offset_head=int(ch.get("OFFSET", 0)),
|
||||
offset_volts=offset_v,
|
||||
inverse=ch.get("INVERSE", "OFF").upper() == "ON",
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
# ─── 波形数据采集与解析 ─────────────────────────────────────────
|
||||
|
||||
|
||||
def fetch_waveform_raw(dev: ScpiDevice, channel: int = 2) -> Optional[bytes]:
|
||||
cmd = f":DATA:WAVE:SCREen:CH{channel}?"
|
||||
return dev.send(cmd)
|
||||
|
||||
|
||||
def parse_waveform(data: bytes) -> np.ndarray:
|
||||
"""解析 12-bit 有符号 ADC 波形 (4 字节 LE 长度前缀)。"""
|
||||
if len(data) < 4:
|
||||
raise ValueError(f"数据不足 4 字节 (实际 {len(data)})")
|
||||
payload_len = struct.unpack("<I", data[:4])[0]
|
||||
payload = data[4:]
|
||||
if len(payload) != payload_len:
|
||||
raise ValueError(
|
||||
f"载荷长度不匹配: 声明 {payload_len} != 实际 {len(payload)}"
|
||||
)
|
||||
if len(payload) % 2 != 0:
|
||||
raise ValueError(f"载荷字节数为奇数: {len(payload)}")
|
||||
num_points = len(payload) // 2
|
||||
if num_points == 0:
|
||||
raise ValueError("空载荷")
|
||||
raw = np.frombuffer(payload, dtype="<u2", count=num_points) & 0x0FFF
|
||||
signed = np.where(raw >= 0x0800, raw.astype(np.float64) - _ADC_MAX,
|
||||
raw.astype(np.float64))
|
||||
return signed
|
||||
|
||||
|
||||
def adc_to_voltage(adc: np.ndarray, vdiv: float,
|
||||
offset_volts: float = 0.0) -> np.ndarray:
|
||||
return adc * (_SCREEN_DIVS_V * vdiv / _ADC_MAX) - offset_volts
|
||||
|
||||
|
||||
# ─── 统计分析 ────────────────────────────────────────────────────
|
||||
|
||||
|
||||
@dataclass
|
||||
class Ch2Stats:
|
||||
timestamp: float
|
||||
datetime: str
|
||||
min_v: float
|
||||
max_v: float
|
||||
pkpk_v: float
|
||||
avg_v: float
|
||||
rms_v: float
|
||||
std_v: float
|
||||
vtop_v: float
|
||||
vbase_v: float
|
||||
vamp_v: float
|
||||
num_points: int
|
||||
vdiv: float
|
||||
offset_v: float
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return {
|
||||
"timestamp": self.timestamp,
|
||||
"datetime": self.datetime,
|
||||
"min_v": round(self.min_v, 6),
|
||||
"max_v": round(self.max_v, 6),
|
||||
"pkpk_v": round(self.pkpk_v, 6),
|
||||
"avg_v": round(self.avg_v, 6),
|
||||
"rms_v": round(self.rms_v, 6),
|
||||
"std_v": round(self.std_v, 6),
|
||||
"vtop_v": round(self.vtop_v, 6),
|
||||
"vbase_v": round(self.vbase_v, 6),
|
||||
"vamp_v": round(self.vamp_v, 6),
|
||||
"num_points": self.num_points,
|
||||
"vdiv": self.vdiv,
|
||||
"offset_v": round(self.offset_v, 6),
|
||||
}
|
||||
|
||||
|
||||
def compute_histogram_top_base(voltages: np.ndarray,
|
||||
nbins: int = 100) -> tuple[float, float]:
|
||||
hist, edges = np.histogram(voltages, bins=nbins)
|
||||
vmin, vmax = edges[0], edges[-1]
|
||||
low_thresh = vmin + (vmax - vmin) * 0.1
|
||||
high_thresh = vmin + (vmax - vmin) * 0.9
|
||||
mid = (edges[:-1] + edges[1:]) / 2
|
||||
low_mask = mid < low_thresh
|
||||
high_mask = mid > high_thresh
|
||||
if low_mask.any() and high_mask.any():
|
||||
vbase = float(np.average(mid[low_mask], weights=hist[low_mask] + 1e-12))
|
||||
vtop = float(np.average(mid[high_mask], weights=hist[high_mask] + 1e-12))
|
||||
else:
|
||||
vbase = float(np.min(voltages))
|
||||
vtop = float(np.max(voltages))
|
||||
return vtop, vbase
|
||||
|
||||
|
||||
def analyze_waveform(adc: np.ndarray, ch: ChannelParams) -> Ch2Stats:
|
||||
vdiv = ch.vdiv
|
||||
offset_v = ch.offset_volts
|
||||
voltages = adc_to_voltage(adc, vdiv, offset_v)
|
||||
vtop, vbase = compute_histogram_top_base(voltages)
|
||||
now = time.time()
|
||||
return Ch2Stats(
|
||||
timestamp=now,
|
||||
datetime=datetime.fromtimestamp(now, tz=timezone.utc).isoformat(),
|
||||
min_v=float(np.min(voltages)),
|
||||
max_v=float(np.max(voltages)),
|
||||
pkpk_v=float(np.max(voltages) - np.min(voltages)),
|
||||
avg_v=float(np.mean(voltages)),
|
||||
rms_v=float(np.sqrt(np.mean(np.square(voltages)))),
|
||||
std_v=float(np.std(voltages, ddof=0)),
|
||||
vtop_v=vtop,
|
||||
vbase_v=vbase,
|
||||
vamp_v=vtop - vbase,
|
||||
num_points=len(adc),
|
||||
vdiv=vdiv,
|
||||
offset_v=offset_v,
|
||||
)
|
||||
|
||||
|
||||
# ─── 硬件测量模式 ────────────────────────────────────────────────
|
||||
|
||||
# 单项测量查询: SCPI 命令后缀 + 响应解析
|
||||
_SINGLE_MEAS_ITEMS = [
|
||||
("max_v", "MAX"),
|
||||
("min_v", "MIN"),
|
||||
("pkpk_v", "PKPK"),
|
||||
("vtop_v", "VTOP"),
|
||||
("vbase_v", "VBASe"),
|
||||
("vamp_v", "VAMP"),
|
||||
("avg_v", "AVERage"),
|
||||
("rms_v", "SQUAresum"),
|
||||
("cycrms_v", "CYCRms"),
|
||||
("period", "PERiod"),
|
||||
("freq", "FREQuency"),
|
||||
]
|
||||
|
||||
|
||||
def sample_measure_single(dev: ScpiDevice) -> dict:
|
||||
"""逐项查询 :MEASUrement:CH2:<item>?,返回 dict。"""
|
||||
result: dict = {}
|
||||
now = time.time()
|
||||
result["timestamp"] = now
|
||||
result["datetime"] = datetime.fromtimestamp(now, tz=timezone.utc).isoformat()
|
||||
for key, item in _SINGLE_MEAS_ITEMS:
|
||||
resp = dev.send_text(f":MEASUrement:CH2:{item}?")
|
||||
cleaned = clean_meas_text(resp)
|
||||
if cleaned:
|
||||
try:
|
||||
result[key] = round(float(cleaned), 6)
|
||||
except ValueError:
|
||||
pass
|
||||
return result
|
||||
|
||||
|
||||
def sample_measure_json(dev: ScpiDevice) -> dict:
|
||||
"""通过 :MEASUrement:CH2? 一次获取全部测量项 (JSON)。"""
|
||||
resp = dev.send(":MEASUrement:CH2?")
|
||||
result: dict = {}
|
||||
now = time.time()
|
||||
result["timestamp"] = now
|
||||
result["datetime"] = datetime.fromtimestamp(now, tz=timezone.utc).isoformat()
|
||||
if not resp or len(resp) < 4:
|
||||
return result
|
||||
|
||||
payload_len = struct.unpack("<I", resp[:4])[0]
|
||||
if payload_len + 4 > len(resp):
|
||||
return result
|
||||
|
||||
payload = resp[4:4 + payload_len]
|
||||
raw_text = payload.decode("ascii", errors="replace")
|
||||
clean_text = raw_text.replace("\t", "") # 去掉 tab 控制字符
|
||||
|
||||
try:
|
||||
parsed = json.loads(clean_text)
|
||||
except json.JSONDecodeError:
|
||||
return result
|
||||
|
||||
ch2_data = parsed.get("CH2", {})
|
||||
# 映射 JSON key → 输出 key
|
||||
key_map = {
|
||||
"MAX": "max_v", "MIN": "min_v", "PKPK": "pkpk_v",
|
||||
"VTOP": "vtop_v", "VBASe": "vbase_v", "VAMP": "vamp_v",
|
||||
"AVERage": "avg_v", "SQUAresum": "rms_v", "CYCRms": "cycrms_v",
|
||||
"CURSorrms": "curs_rms_v",
|
||||
"PERiod": "period", "FREQuency": "freq",
|
||||
}
|
||||
for json_key, out_key in key_map.items():
|
||||
raw_val = ch2_data.get(json_key, "")
|
||||
# 去掉 "? ,OFF ,ON" 等后缀
|
||||
clean_val = raw_val.rstrip("?").rstrip(",").rstrip(",OFF").rstrip(",ON").strip()
|
||||
if clean_val:
|
||||
num = extract_numeric(clean_val)
|
||||
if num is not None:
|
||||
result[out_key] = round(num, 6)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
# ─── 采样循环 ────────────────────────────────────────────────────
|
||||
|
||||
|
||||
def _setup_output(path: Optional[str], fieldnames: list[str]):
|
||||
out_f = None
|
||||
csv_writer = None
|
||||
if path:
|
||||
if path.endswith(".csv"):
|
||||
out_f = open(path, "w", newline="")
|
||||
csv_writer = csv.DictWriter(out_f, fieldnames=fieldnames)
|
||||
csv_writer.writeheader()
|
||||
else:
|
||||
out_f = open(path, "w")
|
||||
return out_f, csv_writer
|
||||
|
||||
|
||||
def _output_record(record: dict, csv_writer, out_f,
|
||||
csv_fieldnames: Optional[list[str]] = None):
|
||||
line = json.dumps(record, ensure_ascii=False)
|
||||
if csv_writer and csv_fieldnames:
|
||||
row = {k: record.get(k, "") for k in csv_fieldnames}
|
||||
csv_writer.writerow(row)
|
||||
out_f.flush()
|
||||
elif out_f:
|
||||
out_f.write(line + "\n")
|
||||
out_f.flush()
|
||||
else:
|
||||
print(line)
|
||||
|
||||
|
||||
def _setup_signal_handler() -> list:
|
||||
running = [True]
|
||||
|
||||
def _handler(signum, frame):
|
||||
running[0] = False
|
||||
|
||||
signal.signal(signal.SIGINT, _handler)
|
||||
signal.signal(signal.SIGTERM, _handler)
|
||||
return running
|
||||
|
||||
|
||||
def run_measure_mode(dev: ScpiDevice, interval_ms: int,
|
||||
max_samples: int, output_path: Optional[str]):
|
||||
"""硬件测量模式 — 逐项查询或 JSON 批量查询。"""
|
||||
csv_fields = [
|
||||
"timestamp", "datetime",
|
||||
"max_v", "min_v", "pkpk_v", "vtop_v", "vbase_v", "vamp_v",
|
||||
"avg_v", "rms_v", "cycrms_v", "period", "freq",
|
||||
]
|
||||
out_f, csv_writer = _setup_output(output_path, csv_fields)
|
||||
|
||||
running = _setup_signal_handler()
|
||||
count = 0
|
||||
t0 = time.monotonic()
|
||||
|
||||
use_json = (len(_SINGLE_MEAS_ITEMS) > 5) # 项多时 JSON 模式更高效
|
||||
print(f"[INFO] 开始采集 CH2 — 间隔 {interval_ms}ms, 模式 measure"
|
||||
f"{' (JSON)' if use_json else ' (single)'}",
|
||||
file=sys.stderr)
|
||||
|
||||
while running[0] and (max_samples == 0 or count < max_samples):
|
||||
cycle_start = time.monotonic()
|
||||
|
||||
try:
|
||||
if use_json:
|
||||
record = sample_measure_json(dev)
|
||||
else:
|
||||
record = sample_measure_single(dev)
|
||||
except Exception as e:
|
||||
print(f"[WARN] 第 {count + 1} 次: 测量失败: {e}", file=sys.stderr)
|
||||
record = None
|
||||
|
||||
if record:
|
||||
count += 1
|
||||
_output_record(record, csv_writer, out_f, csv_fields)
|
||||
if count % 10 == 0:
|
||||
elapsed = time.monotonic() - t0
|
||||
print(f"[INFO] 已采集 {count} 条 ({elapsed:.1f}s)", file=sys.stderr)
|
||||
|
||||
elapsed_since = (time.monotonic() - cycle_start) * 1000
|
||||
sleep_ms = max(0, interval_ms - elapsed_since)
|
||||
if sleep_ms > 0 and running[0]:
|
||||
time.sleep(sleep_ms / 1000.0)
|
||||
|
||||
elapsed_total = time.monotonic() - t0
|
||||
print(f"[INFO] 采集结束 — 共 {count} 条, 耗时 {elapsed_total:.1f}s, "
|
||||
f"实际频率 {count/elapsed_total:.1f} Hz" if elapsed_total > 0 else "",
|
||||
file=sys.stderr)
|
||||
if out_f:
|
||||
out_f.close()
|
||||
|
||||
|
||||
def run_waveform_mode(dev: ScpiDevice, interval_ms: int,
|
||||
max_samples: int, output_path: Optional[str]):
|
||||
"""数据接口模式 — 强制触发 + HEAD + CH2 波形,软件计算。
|
||||
|
||||
注意: NDS202E 在 RUN 模式下 :DATA:WAVE 返回的是冻结数据。
|
||||
需要通过 :TRIGger:SINGLE 强制触发新采集后再读数据。
|
||||
"""
|
||||
head = fetch_head(dev)
|
||||
if head is None:
|
||||
print("[FATAL] 无法获取 HEAD 信息", file=sys.stderr)
|
||||
return
|
||||
ch2 = get_channel_params(head, dev)
|
||||
if ch2 is None:
|
||||
print("[FATAL] HEAD 中未找到 CH2 通道", file=sys.stderr)
|
||||
return
|
||||
|
||||
csv_fields = [
|
||||
"timestamp", "datetime",
|
||||
"min_v", "max_v", "pkpk_v", "avg_v", "rms_v", "std_v",
|
||||
"vtop_v", "vbase_v", "vamp_v",
|
||||
"num_points", "vdiv", "offset_v",
|
||||
]
|
||||
out_f, csv_writer = _setup_output(output_path, csv_fields)
|
||||
|
||||
running = _setup_signal_handler()
|
||||
count = 0
|
||||
t0 = time.monotonic()
|
||||
|
||||
# 确保示波器在 RUN 模式
|
||||
dev.write_cmd(":RUNning RUN")
|
||||
|
||||
print(f"[INFO] 开始采集 CH2 — 间隔 {interval_ms}ms, 模式 waveform"
|
||||
f" (TRIG:SINGLE), 档位 {ch2.scale}, 探头 {ch2.probe}",
|
||||
file=sys.stderr)
|
||||
|
||||
while running[0] and (max_samples == 0 or count < max_samples):
|
||||
cycle_start = time.monotonic()
|
||||
|
||||
try:
|
||||
# 1. 强制单次触发采集新波形
|
||||
dev.write_cmd(":TRIGger:SINGLE")
|
||||
# :TRIGger:SINGLE 完成采集后示波器自动 STOP,等待固定时间
|
||||
# (依赖信号存在触发条件;若无触发则等待超时)
|
||||
time.sleep(1.5)
|
||||
|
||||
# 2. 读取波形数据
|
||||
raw = fetch_waveform_raw(dev, channel=2)
|
||||
if raw is None or len(raw) < 6:
|
||||
print(f"[WARN] 第 {count + 1} 次: 波形数据为空", file=sys.stderr)
|
||||
record = None
|
||||
else:
|
||||
adc = parse_waveform(raw)
|
||||
stats = analyze_waveform(adc, ch2)
|
||||
record = stats.to_dict()
|
||||
|
||||
# 3. 恢复 RUN
|
||||
dev.write_cmd(":RUNning RUN")
|
||||
|
||||
except Exception as e:
|
||||
print(f"[WARN] 第 {count + 1} 次: 失败: {e}", file=sys.stderr)
|
||||
record = None
|
||||
|
||||
if record:
|
||||
count += 1
|
||||
_output_record(record, csv_writer, out_f, csv_fields)
|
||||
if count % 10 == 0:
|
||||
elapsed = time.monotonic() - t0
|
||||
print(f"[INFO] 已采集 {count} 条 ({elapsed:.1f}s)", file=sys.stderr)
|
||||
|
||||
elapsed_since = (time.monotonic() - cycle_start) * 1000
|
||||
sleep_ms = max(0, interval_ms - elapsed_since)
|
||||
if sleep_ms > 0 and running[0]:
|
||||
time.sleep(sleep_ms / 1000.0)
|
||||
|
||||
elapsed_total = time.monotonic() - t0
|
||||
print(f"[INFO] 采集结束 — 共 {count} 条, 耗时 {elapsed_total:.1f}s",
|
||||
file=sys.stderr)
|
||||
dev.write_cmd(":RUNning RUN")
|
||||
if out_f:
|
||||
out_f.close()
|
||||
|
||||
|
||||
# ─── 入口 ────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="CH2 通道实时数据采集记录器 (原生 PyUSB + SCPI, NDS202E/NDS102U)",
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
epilog="""
|
||||
示例:
|
||||
python ch2_recorder.py # 500ms 间隔,stdout (JSON)
|
||||
python ch2_recorder.py -i 200 -o ch2.csv # 200ms 间隔,CSV 文件
|
||||
python ch2_recorder.py -i 100 -n 1000 # 100ms 间隔,采集 1000 次
|
||||
python ch2_recorder.py --mode measure -o m.csv # 硬件测量模式 (实时,推荐)
|
||||
python ch2_recorder.py --mode waveform # 数据接口 + TRIG:SINGLE
|
||||
""",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-i", "--interval", type=int, default=_DEFAULT_INTERVAL_MS,
|
||||
help=f"采样间隔 (毫秒),默认 {_DEFAULT_INTERVAL_MS}",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-n", "--count", type=int, default=0,
|
||||
help="最大采样次数,0 表示不限(Ctrl-C 停止)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-o", "--output", type=str, default=None,
|
||||
help="输出文件路径 (.csv 或 .jsonl),默认 stdout (JSON 每行一条)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--mode", type=str, choices=("measure", "waveform"),
|
||||
default="measure",
|
||||
help="采样模式: measure=硬件测量接口(实时,推荐), waveform=数据接口+软件计算 (默认 measure)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--vid", type=str, default=None,
|
||||
help=f"USB Vendor ID (十六进制),默认 0x{DEFAULT_VID:04X}",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--pid", type=str, default=None,
|
||||
help=f"USB Product ID (十六进制),默认 0x{DEFAULT_PID:04X}",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--json-mode", action="store_true", default=True,
|
||||
help="measure 模式下使用 :MEASUrement:CH2? JSON 批量获取 (更快,默认)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--single-mode", action="store_true", default=False,
|
||||
help="measure 模式下使用逐项 :MEASUrement:CH2:<item>? 查询",
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
vid = int(args.vid, 16) if args.vid else DEFAULT_VID
|
||||
pid = int(args.pid, 16) if args.pid else DEFAULT_PID
|
||||
|
||||
if args.interval < 10:
|
||||
print("[WARN] 采样间隔过小 (< 10ms)", file=sys.stderr)
|
||||
|
||||
print(f"[INFO] 连接 USB 设备 (VID=0x{vid:04X}, PID=0x{pid:04X})...",
|
||||
file=sys.stderr)
|
||||
|
||||
try:
|
||||
with ScpiDevice(vid, pid) as dev:
|
||||
idn = dev.idn()
|
||||
print(f"[INFO] 设备: {idn}", file=sys.stderr)
|
||||
|
||||
if args.mode == "waveform":
|
||||
run_waveform_mode(dev, args.interval, args.count, args.output)
|
||||
else:
|
||||
# measure 模式
|
||||
if args.single_mode:
|
||||
global _SINGLE_MEAS_ITEMS
|
||||
_SINGLE_MEAS_ITEMS = _SINGLE_MEAS_ITEMS[:5] # 逐项时只取核心项
|
||||
run_measure_mode(dev, args.interval, args.count, args.output)
|
||||
|
||||
except RuntimeError as e:
|
||||
print(f"[FATAL] {e}", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
except KeyboardInterrupt:
|
||||
print("\n[INFO] 用户中断", file=sys.stderr)
|
||||
finally:
|
||||
print("[INFO] 退出", file=sys.stderr)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
82
backend/tools/check_data.py
普通文件
82
backend/tools/check_data.py
普通文件
@ -0,0 +1,82 @@
|
||||
#!/usr/bin/env python3
|
||||
"""绕过封装 + 尝试多种方式强制刷新采集后再读。"""
|
||||
import hashlib, sys, os, time
|
||||
import usb.core, usb.util
|
||||
|
||||
VID, PID = 0x5345, 0x1234
|
||||
|
||||
dev = usb.core.find(idVendor=VID, idProduct=PID)
|
||||
assert dev, "设备未找到"
|
||||
for cfg in dev:
|
||||
for intf in cfg:
|
||||
if dev.is_kernel_driver_active(intf.bInterfaceNumber):
|
||||
dev.detach_kernel_driver(intf.bInterfaceNumber)
|
||||
dev.set_configuration()
|
||||
intf = dev.get_active_configuration()[(0, 0)]
|
||||
ep_out = ep_in = None
|
||||
for ep in intf:
|
||||
d = usb.util.endpoint_direction(ep.bEndpointAddress)
|
||||
if d == usb.util.ENDPOINT_OUT: ep_out = ep
|
||||
elif d == usb.util.ENDPOINT_IN: ep_in = ep
|
||||
assert ep_out and ep_in
|
||||
MAXPKT = ep_in.wMaxPacketSize
|
||||
|
||||
def send(cmd: bytes, timeout=5000) -> bytes:
|
||||
dev.write(ep_out, cmd, timeout=timeout)
|
||||
resp = b''
|
||||
while True:
|
||||
try:
|
||||
data = dev.read(ep_in, MAXPKT, timeout=timeout)
|
||||
if not data: break
|
||||
resp += data.tobytes()
|
||||
if len(data) < MAXPKT: break
|
||||
except usb.core.USBError as e:
|
||||
if e.errno == 110: break
|
||||
raise
|
||||
return resp
|
||||
|
||||
def m5(d): return hashlib.md5(d).hexdigest()[:8] if d else "None"
|
||||
|
||||
# ── 初始状态 ──
|
||||
idn = send(b'*IDN?\n').decode('ascii','ignore').strip()
|
||||
print(f"设备: {idn}")
|
||||
print(f"max_pkt={MAXPKT}")
|
||||
|
||||
# ── 初读(当前冻结数据) ──
|
||||
ch1 = send(b":DATA:WAVE:SCREen:CH1?\n")
|
||||
_init_md5 = m5(ch1)
|
||||
print(f"\n[初始] CH1={len(ch1)}B md5={_init_md5}")
|
||||
|
||||
# ── 测试 1: STOP + RUN 再读 ──
|
||||
print("\n--- 测试1: STOP->RUN ---")
|
||||
send(b":RUNning STOP\n")
|
||||
time.sleep(0.5)
|
||||
send(b":RUNning RUN\n")
|
||||
time.sleep(1.0)
|
||||
ch1 = send(b":DATA:WAVE:SCREen:CH1?\n")
|
||||
print(f"CH1={len(ch1)}B md5={m5(ch1)} 变化={'YES' if m5(ch1) != _init_md5 else 'NO'}")
|
||||
|
||||
# ── 测试 2: TRIGger:SINGLE 再读 ──
|
||||
print("\n--- 测试2: TRIG:SINGLE ---")
|
||||
for i in range(3):
|
||||
send(b":TRIGger:SINGLE\n")
|
||||
time.sleep(1.0)
|
||||
ch1 = send(b":DATA:WAVE:SCREen:CH1?\n")
|
||||
print(f" [{i+1}] CH1={len(ch1)}B md5={m5(ch1)} "
|
||||
f"变化={'YES' if m5(ch1) != _init_md5 else 'NO'}")
|
||||
|
||||
# ── 测试 3: AUTOset 再读 ──
|
||||
print("\n--- 测试3: AUTOset ---")
|
||||
send(b":AUTOset ON\n")
|
||||
time.sleep(2.0)
|
||||
ch1 = send(b":DATA:WAVE:SCREen:CH1?\n")
|
||||
print(f"CH1={len(ch1)}B md5={m5(ch1)} 变化={'YES' if m5(ch1) != _init_md5 else 'NO'}")
|
||||
|
||||
# ── 测试 4: 读 measurement 值看是否变化 ──
|
||||
print("\n--- 测试4: MEASurement (对比) ---")
|
||||
for i in range(5):
|
||||
r = send(b":MEASUrement:CH1:PKPK?\n")
|
||||
print(f" [{i+1}] CH1_PKPK={r.decode('ascii','ignore').strip()}")
|
||||
|
||||
print("\nDone")
|
||||
usb.util.dispose_resources(dev)
|
||||
398
backend/tools/oscilloscope_data.py
普通文件
398
backend/tools/oscilloscope_data.py
普通文件
@ -0,0 +1,398 @@
|
||||
"""
|
||||
示波器数据层 — 可复用的 USB SCPI 通信与数据解析模块
|
||||
|
||||
提供 OscilloscopeData 类用于连接、获取 BMP/HEAD/波形,以及独立的数据解析函数。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import struct
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Optional
|
||||
|
||||
import numpy as np
|
||||
from PIL import Image
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
from app.hardware.oscilloscope import Oscilloscope
|
||||
|
||||
# ─── 常量 ────────────────────────────────────────────────────────
|
||||
|
||||
_SCALE_RE = re.compile(r"([\d.]+)\s*([numk]?[sv])\s*", re.IGNORECASE)
|
||||
|
||||
_UNIT_MULTIPLIERS: dict[str, float] = {
|
||||
"nv": 1e-9, "uv": 1e-6, "mv": 1e-3, "v": 1.0, "kv": 1e3,
|
||||
"ns": 1e-9, "us": 1e-6, "ms": 1e-3, "s": 1.0, "ks": 1e3,
|
||||
}
|
||||
|
||||
_SCREEN_DIVS_H = 10 # 水平分度数
|
||||
_SCREEN_DIVS_V = 8 # 垂直分度数
|
||||
_ADC_MAX = 0x1000 # 12-bit = 4096
|
||||
|
||||
|
||||
# ─── 数据结构 ────────────────────────────────────────────────────
|
||||
|
||||
|
||||
@dataclass
|
||||
class ChannelInfo:
|
||||
name: str = ""
|
||||
display: bool = True
|
||||
coupling: str = "dc"
|
||||
probe: str = "1x"
|
||||
scale: str = "1v"
|
||||
offset: int = 0
|
||||
inverse: bool = False
|
||||
|
||||
@property
|
||||
def vdiv(self) -> float:
|
||||
"""电压档位 (V/div),已考虑探头比例。"""
|
||||
return parse_scale_str(self.scale)
|
||||
|
||||
@property
|
||||
def probe_ratio(self) -> float:
|
||||
return parse_probe_ratio(self.probe)
|
||||
|
||||
@property
|
||||
def offset_volts(self) -> float:
|
||||
"""垂直偏移电压 (V)。offset 单位为 0.01 格。"""
|
||||
return self.offset / 100.0 * self.vdiv
|
||||
|
||||
|
||||
@dataclass
|
||||
class TimebaseInfo:
|
||||
scale: str = "1.0ms"
|
||||
hoffset: int = 0
|
||||
|
||||
@property
|
||||
def scale_sec(self) -> float:
|
||||
return parse_timebase(self.scale)
|
||||
|
||||
|
||||
@dataclass
|
||||
class SampleInfo:
|
||||
fullscreen: int = 1520
|
||||
datalen: int = 1520
|
||||
samplerate: str = "500ks/s"
|
||||
type: str = "sample"
|
||||
depmem: str = "10k"
|
||||
|
||||
|
||||
@dataclass
|
||||
class HeadInfo:
|
||||
timebase: TimebaseInfo = field(default_factory=TimebaseInfo)
|
||||
sample: SampleInfo = field(default_factory=SampleInfo)
|
||||
channels: list[ChannelInfo] = field(default_factory=list)
|
||||
datatype: str = "screen"
|
||||
runstatus: str = "auto"
|
||||
|
||||
def get_channel(self, name: str) -> Optional[ChannelInfo]:
|
||||
for ch in self.channels:
|
||||
if ch.name == name:
|
||||
return ch
|
||||
return None
|
||||
|
||||
|
||||
@dataclass
|
||||
class WaveformSnapshot:
|
||||
"""一次完整的数据快照。"""
|
||||
idn: Optional[str] = None
|
||||
bmp_img: Optional[Image.Image] = None
|
||||
head: Optional[HeadInfo] = None
|
||||
ch1_adc: Optional[np.ndarray] = None
|
||||
ch2_adc: Optional[np.ndarray] = None
|
||||
|
||||
|
||||
# ─── 单位字符串解析 ──────────────────────────────────────────────
|
||||
|
||||
|
||||
def parse_scale_str(raw: str) -> float:
|
||||
"""解析电压档位字符串,如 '5.00mv' → 0.005, '1v' → 1.0。"""
|
||||
m = _SCALE_RE.search(raw.lower().strip())
|
||||
if m:
|
||||
return float(m.group(1)) * _UNIT_MULTIPLIERS.get(m.group(2), 1.0)
|
||||
try:
|
||||
return float(raw)
|
||||
except (ValueError, TypeError):
|
||||
return 1.0
|
||||
|
||||
|
||||
def parse_timebase(raw: str) -> float:
|
||||
"""解析时基字符串,如 '1.0ms' → 0.001, '500us' → 0.0005。"""
|
||||
return parse_scale_str(raw)
|
||||
|
||||
|
||||
def parse_probe_ratio(raw: str) -> float:
|
||||
"""解析探头比例,如 '10x' → 10.0, '1x' → 1.0。"""
|
||||
try:
|
||||
return float(raw.strip().lower().rstrip("x"))
|
||||
except (ValueError, TypeError):
|
||||
return 1.0
|
||||
|
||||
|
||||
# ─── 数据包解析 ──────────────────────────────────────────────────
|
||||
|
||||
|
||||
def _strip_length_header(data: bytes) -> bytes:
|
||||
"""去除 4 字节小端长度前缀,返回纯载荷。
|
||||
|
||||
若声明长度与实不一致,说明 USB 响应串扰,抛出异常由调用方丢弃。
|
||||
"""
|
||||
if len(data) < 4:
|
||||
raise ValueError(f"响应不足 4 字节 (实际 {len(data)})")
|
||||
payload_len = struct.unpack("<I", data[:4])[0]
|
||||
payload = data[4:]
|
||||
if len(payload) != payload_len:
|
||||
raise ValueError(
|
||||
f"声明长度 {payload_len} != 实际 {len(payload)},丢弃脏数据")
|
||||
return payload
|
||||
|
||||
|
||||
def _parse_waveform_raw(payload: bytes) -> np.ndarray:
|
||||
"""从纯二进制载荷解析 12-bit 有符号波形数据。"""
|
||||
num_points = len(payload) // 2
|
||||
if num_points == 0:
|
||||
raise ValueError("空载荷")
|
||||
raw = np.frombuffer(payload, dtype="<u2", count=num_points) & 0x0FFF
|
||||
signed = np.where(raw >= 0x0800, raw.astype(np.float64) - _ADC_MAX,
|
||||
raw.astype(np.float64))
|
||||
return signed
|
||||
|
||||
|
||||
def parse_waveform(data: bytes) -> np.ndarray:
|
||||
"""解析 CH<x> 波形数据。
|
||||
|
||||
尝试两种格式,自动选择成功的:
|
||||
1) 4 字节长度前缀 + 12-bit 数据(SCPI 规范)
|
||||
2) 纯 12-bit 数据无前缀(某些固件版本)
|
||||
奇数长度时丢弃末尾 1 字节。
|
||||
"""
|
||||
_N = len(data)
|
||||
|
||||
# 格式 1:4 字节前缀
|
||||
if _N >= 4:
|
||||
hdr = struct.unpack("<I", data[:4])[0]
|
||||
payload = data[4:]
|
||||
if len(payload) == hdr and len(payload) % 2 == 0:
|
||||
return _parse_waveform_raw(payload)
|
||||
|
||||
# 格式 2:无前缀,整个响应即数据
|
||||
usable = _N if _N % 2 == 0 else _N - 1
|
||||
if usable >= 4:
|
||||
return _parse_waveform_raw(data[:usable])
|
||||
|
||||
raise ValueError(f"无法解析波形数据: {_N} bytes")
|
||||
|
||||
|
||||
def parse_bmp(data: bytes) -> bytes:
|
||||
"""解析 BMP 响应,返回纯 BMP 字节流。"""
|
||||
return _strip_length_header(data)
|
||||
|
||||
|
||||
def _get_key(obj: dict, *keys: str, default=None):
|
||||
"""兼容大小写 key: 先查原始 key,再查 .upper() 和 .lower()。"""
|
||||
for k in keys:
|
||||
if k in obj:
|
||||
return obj[k]
|
||||
ku = k.upper()
|
||||
if ku in obj:
|
||||
return obj[ku]
|
||||
kl = k.lower()
|
||||
if kl in obj:
|
||||
return obj[kl]
|
||||
return default
|
||||
|
||||
|
||||
def parse_head(data: bytes) -> HeadInfo:
|
||||
"""解析 HEAD JSON 响应,返回 HeadInfo 对象。
|
||||
|
||||
兼容 OWON NDS102U (小写 key) 和 NDS202E (全大写 key) 固件版本。
|
||||
格式: 4 字节长度前缀 + JSON 文本(与 BMP / 波形一致,DATA 子系统统一)。"""
|
||||
payload = _strip_length_header(data)
|
||||
text = payload.decode("ascii", errors="ignore").strip()
|
||||
raw = json.loads(text)
|
||||
|
||||
tb = _get_key(raw, "timebase", default={})
|
||||
timebase = TimebaseInfo(
|
||||
scale=_get_key(tb, "scale", default="1.0ms"),
|
||||
hoffset=_get_key(tb, "hoffset", default=0),
|
||||
)
|
||||
|
||||
sp = _get_key(raw, "sample", default={})
|
||||
sample = SampleInfo(
|
||||
fullscreen=_get_key(sp, "fullscreen", default=1520),
|
||||
datalen=_get_key(sp, "datalen", default=1520),
|
||||
samplerate=_get_key(sp, "samplerate", default="500ks/s"),
|
||||
type=_get_key(sp, "type", default="sample"),
|
||||
depmem=_get_key(sp, "depmem", default="10k"),
|
||||
)
|
||||
|
||||
channels = []
|
||||
ch_list = _get_key(raw, "channel", default=[])
|
||||
for ch in ch_list:
|
||||
display_raw = _get_key(ch, "display", default="on")
|
||||
inverse_raw = _get_key(ch, "inverse", default="off")
|
||||
channels.append(ChannelInfo(
|
||||
name=_get_key(ch, "name", default=""),
|
||||
display=str(display_raw).lower() == "on",
|
||||
coupling=_get_key(ch, "coupling", default="dc"),
|
||||
probe=_get_key(ch, "probe", default="1x"),
|
||||
scale=_get_key(ch, "scale", default="1v"),
|
||||
offset=_get_key(ch, "offset", default=0),
|
||||
inverse=str(inverse_raw).lower() == "on",
|
||||
))
|
||||
|
||||
return HeadInfo(
|
||||
timebase=timebase,
|
||||
sample=sample,
|
||||
channels=channels,
|
||||
datatype=_get_key(raw, "datatype", default="screen"),
|
||||
runstatus=_get_key(raw, "runstatus", default="auto"),
|
||||
)
|
||||
|
||||
|
||||
# ─── 电压与时间轴 ────────────────────────────────────────────────
|
||||
|
||||
|
||||
def adc_to_voltage(adc: np.ndarray, vdiv: float,
|
||||
offset_volts: float = 0.0) -> np.ndarray:
|
||||
"""有符号 12-bit ADC 值转为电压 (V)。
|
||||
|
||||
adc: 范围 [-2048, 2047] 的 float64 数组
|
||||
vdiv: 垂直档位 V/div
|
||||
offset_volts: 垂直偏移电压 (V)
|
||||
"""
|
||||
return adc * (_SCREEN_DIVS_V * vdiv / _ADC_MAX) - offset_volts
|
||||
|
||||
|
||||
def build_time_axis(num_points: int, tb_scale_sec: float) -> np.ndarray:
|
||||
"""根据数据点数和时基构建时间轴 (s)。"""
|
||||
if num_points <= 0:
|
||||
return np.array([])
|
||||
return np.arange(num_points) * (_SCREEN_DIVS_H * tb_scale_sec / num_points)
|
||||
|
||||
|
||||
# ─── 示波器数据获取器 ────────────────────────────────────────────
|
||||
|
||||
|
||||
class OscilloscopeData:
|
||||
"""OWON NDS102U 示波器 USB SCPI 数据获取封装。
|
||||
|
||||
用法:
|
||||
with OscilloscopeData() as od:
|
||||
snap = od.snapshot() # 完整快照 (BMP + HEAD + CH1 + CH2)
|
||||
bmp_img = od.fetch_bmp() # 仅 BMP
|
||||
head = od.fetch_head() # 仅 HEAD
|
||||
ch1 = od.fetch_waveform(1) # 仅 CH1
|
||||
"""
|
||||
|
||||
def __init__(self, vid: int = 0x5345, pid: int = 0x1234):
|
||||
self._osc = Oscilloscope(vid, pid)
|
||||
self._connected = False
|
||||
self._lock = threading.Lock()
|
||||
|
||||
# ── 连接管理 ──
|
||||
|
||||
def connect(self):
|
||||
self._osc.connect()
|
||||
self._connected = True
|
||||
|
||||
def disconnect(self):
|
||||
if self._connected:
|
||||
self._osc.disconnect()
|
||||
self._connected = False
|
||||
|
||||
def __enter__(self):
|
||||
self.connect()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.disconnect()
|
||||
|
||||
@property
|
||||
def is_connected(self) -> bool:
|
||||
return self._connected
|
||||
|
||||
# ── 原始命令(线程安全) ──
|
||||
|
||||
def _cmd(self, scpi: str, timeout: int = 5000) -> Optional[bytes]:
|
||||
with self._lock:
|
||||
return self._osc.send_command(scpi, timeout=timeout)
|
||||
|
||||
# ── 高层获取方法 ──
|
||||
|
||||
def fetch_idn(self) -> Optional[str]:
|
||||
resp = self._cmd("*IDN?")
|
||||
if resp:
|
||||
return resp.decode("ascii", errors="ignore").strip()
|
||||
return None
|
||||
|
||||
def fetch_bmp(self, timeout: int = 15000) -> Optional[Image.Image]:
|
||||
resp = self._cmd(":DATA:WAVE:SCREen:BMP?", timeout=timeout)
|
||||
if resp is None:
|
||||
return None
|
||||
try:
|
||||
bmp_bytes = parse_bmp(resp)
|
||||
return Image.open(io.BytesIO(bmp_bytes))
|
||||
except Exception as e:
|
||||
print(f" BMP 解析失败: {e}")
|
||||
return None
|
||||
|
||||
def fetch_head(self) -> Optional[HeadInfo]:
|
||||
resp = self._cmd(":DATA:WAVE:SCREen:HEAD?")
|
||||
if resp is None:
|
||||
return None
|
||||
try:
|
||||
return parse_head(resp)
|
||||
except (json.JSONDecodeError, Exception) as e:
|
||||
print(f" HEAD 解析失败: {e}")
|
||||
return None
|
||||
|
||||
def fetch_waveform(self, channel: int) -> Optional[np.ndarray]:
|
||||
"""获取指定通道波形数据。channel: 1 或 2。"""
|
||||
cmd = f":DATA:WAVE:SCREen:CH{channel}?"
|
||||
resp = self._cmd(cmd)
|
||||
if resp is None:
|
||||
return None
|
||||
try:
|
||||
return parse_waveform(resp)
|
||||
except Exception as e:
|
||||
print(f" CH{channel} 解析失败: {e}")
|
||||
return None
|
||||
|
||||
def snapshot_light(self) -> WaveformSnapshot:
|
||||
"""轻量快照 (HEAD + CH1 + CH2),不含 BMP。用于实时刷新。"""
|
||||
snap = WaveformSnapshot()
|
||||
snap.head = self.fetch_head()
|
||||
if snap.head:
|
||||
snap.ch1_adc = self.fetch_waveform(1)
|
||||
snap.ch2_adc = self.fetch_waveform(2)
|
||||
return snap
|
||||
|
||||
def snapshot(self) -> WaveformSnapshot:
|
||||
"""完整快照 (IDN + BMP + HEAD + CH1 + CH2)。"""
|
||||
snap = WaveformSnapshot()
|
||||
snap.idn = self.fetch_idn()
|
||||
if snap.idn:
|
||||
print(f" 设备: {snap.idn}")
|
||||
snap.bmp_img = self.fetch_bmp()
|
||||
if snap.bmp_img:
|
||||
print(f" BMP: {snap.bmp_img.size[0]}x{snap.bmp_img.size[1]}")
|
||||
snap.head = self.fetch_head()
|
||||
if snap.head:
|
||||
for ch in snap.head.channels:
|
||||
print(f" {ch.name}: {ch.scale} ({ch.probe}), offset={ch.offset}")
|
||||
print(f" 时基: {snap.head.timebase.scale}, 点数: {snap.head.sample.datalen}")
|
||||
snap.ch1_adc = self.fetch_waveform(1)
|
||||
if snap.ch1_adc is not None:
|
||||
print(f" CH1: {len(snap.ch1_adc)} 点")
|
||||
snap.ch2_adc = self.fetch_waveform(2)
|
||||
if snap.ch2_adc is not None:
|
||||
print(f" CH2: {len(snap.ch2_adc)} 点")
|
||||
return snap
|
||||
419
backend/tools/oscilloscope_viewer.py
普通文件
419
backend/tools/oscilloscope_viewer.py
普通文件
@ -0,0 +1,419 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
示波器屏幕截图与波形渲染工具 (PyQtGraph 版)
|
||||
|
||||
依赖 oscilloscope_data.py 提供数据层,本模块专注 PyQtGraph 渲染。
|
||||
|
||||
用法:
|
||||
python oscilloscope_viewer.py # 单次快照 (BMP + 时域 + XY)
|
||||
python oscilloscope_viewer.py snapshot # 同上
|
||||
python oscilloscope_viewer.py live # 连续实时波形 (时域 + XY)
|
||||
python oscilloscope_viewer.py live --interval 300
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import io
|
||||
import queue
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
from typing import Optional
|
||||
|
||||
import numpy as np
|
||||
from PIL import Image
|
||||
|
||||
from PyQt5 import QtWidgets, QtCore, QtGui
|
||||
import pyqtgraph as pg
|
||||
|
||||
from oscilloscope_data import (
|
||||
OscilloscopeData,
|
||||
WaveformSnapshot,
|
||||
HeadInfo,
|
||||
adc_to_voltage,
|
||||
build_time_axis,
|
||||
)
|
||||
|
||||
# ─── 常量 ────────────────────────────────────────────────────────
|
||||
|
||||
CH_COLORS = {"CH1": (255, 179, 71), "CH2": (119, 221, 119)} # RGB
|
||||
XY_COLOR = (100, 149, 237)
|
||||
BG_COLOR = "#1e1e1e"
|
||||
GRID_COLOR = "#444444"
|
||||
_SCREEN_DIVS = 10
|
||||
|
||||
|
||||
def _pil_to_qpixmap(pil_img: Image.Image) -> QtGui.QPixmap:
|
||||
"""PIL Image → QPixmap,绕过 Pillow 12.x 的 ImageQt 兼容性问题。"""
|
||||
buf = io.BytesIO()
|
||||
pil_img.save(buf, format="BMP")
|
||||
pix = QtGui.QPixmap()
|
||||
pix.loadFromData(buf.getvalue())
|
||||
return pix
|
||||
|
||||
|
||||
def _channel_params(head: Optional[HeadInfo]) -> dict:
|
||||
ch1_vdiv, ch1_off = 1.0, 0.0
|
||||
ch2_vdiv, ch2_off = 1.0, 0.0
|
||||
tb_scale = 0.001
|
||||
if head:
|
||||
for ch in head.channels:
|
||||
if ch.name == "ch1":
|
||||
ch1_vdiv, ch1_off = ch.vdiv, ch.offset_volts
|
||||
elif ch.name == "ch2":
|
||||
ch2_vdiv, ch2_off = ch.vdiv, ch.offset_volts
|
||||
tb_scale = head.timebase.scale_sec
|
||||
return dict(ch1_vdiv=ch1_vdiv, ch1_off=ch1_off,
|
||||
ch2_vdiv=ch2_vdiv, ch2_off=ch2_off,
|
||||
tb_scale=tb_scale)
|
||||
|
||||
|
||||
# ─── QApplication 单例 ───────────────────────────────────────────
|
||||
|
||||
_app: Optional[QtWidgets.QApplication] = None
|
||||
|
||||
|
||||
def _get_app() -> QtWidgets.QApplication:
|
||||
global _app
|
||||
if _app is None:
|
||||
_app = QtWidgets.QApplication(sys.argv)
|
||||
return _app
|
||||
|
||||
|
||||
# ─── 快照窗口 ────────────────────────────────────────────────────
|
||||
|
||||
|
||||
class SnapshotWindow(QtWidgets.QMainWindow):
|
||||
"""单次快照:BMP 截图 + 时域波形 + XY 模式。"""
|
||||
|
||||
def __init__(self, snap: WaveformSnapshot):
|
||||
super().__init__()
|
||||
self.snap = snap
|
||||
self.params = _channel_params(snap.head)
|
||||
self._setup()
|
||||
|
||||
def _setup(self):
|
||||
self.setWindowTitle("示波器 — 快照 — OWON NDS102U")
|
||||
self.resize(1400, 900)
|
||||
|
||||
cw = QtWidgets.QWidget()
|
||||
self.setCentralWidget(cw)
|
||||
layout = QtWidgets.QGridLayout(cw)
|
||||
layout.setSpacing(6)
|
||||
|
||||
has_bmp = self.snap.bmp_img is not None
|
||||
has_wave = self.snap.ch1_adc is not None or self.snap.ch2_adc is not None
|
||||
|
||||
row = 0
|
||||
# BMP
|
||||
if has_bmp:
|
||||
pix = _pil_to_qpixmap(self.snap.bmp_img)
|
||||
lbl = QtWidgets.QLabel()
|
||||
lbl.setPixmap(pix)
|
||||
lbl.setAlignment(QtCore.Qt.AlignCenter)
|
||||
gb = QtWidgets.QGroupBox("屏幕截图")
|
||||
gb_layout = QtWidgets.QVBoxLayout(gb)
|
||||
gb_layout.addWidget(lbl)
|
||||
layout.addWidget(gb, row, 0)
|
||||
row += 1
|
||||
|
||||
# 时域 + XY
|
||||
if has_wave:
|
||||
pw_time = self._make_time_plot()
|
||||
pw_xy = self._make_xy_plot()
|
||||
layout.addWidget(pw_time, 0, 1, max(row, 1), 1)
|
||||
layout.addWidget(pw_xy, row, 0 if not has_bmp else 0, 1, 1)
|
||||
|
||||
# 信息
|
||||
info_text = self._info_text()
|
||||
info_lbl = QtWidgets.QLabel(info_text)
|
||||
info_lbl.setStyleSheet("background:#fffef0;padding:8px;font-family:monospace;")
|
||||
layout.addWidget(info_lbl, row, 1, 1, 1)
|
||||
|
||||
def _make_time_plot(self):
|
||||
pw = pg.PlotWidget(title="时域波形")
|
||||
pw.setBackground(BG_COLOR)
|
||||
pw.showGrid(x=True, y=True, alpha=0.3)
|
||||
pw.setLabel("bottom", "时间", units="s")
|
||||
pw.setLabel("left", "电压", units="V")
|
||||
pw.addLegend()
|
||||
|
||||
tb = self.params["tb_scale"]
|
||||
for adc, vdiv, off, label, color in [
|
||||
(self.snap.ch1_adc, self.params["ch1_vdiv"],
|
||||
self.params["ch1_off"], "CH1", CH_COLORS["CH1"]),
|
||||
(self.snap.ch2_adc, self.params["ch2_vdiv"],
|
||||
self.params["ch2_off"], "CH2", CH_COLORS["CH2"]),
|
||||
]:
|
||||
if adc is not None and len(adc) > 0:
|
||||
t = build_time_axis(len(adc), tb)
|
||||
v = adc_to_voltage(adc, vdiv, off)
|
||||
pen = pg.mkPen(color=color, width=1.2)
|
||||
pw.plot(t, v, pen=pen, name=label)
|
||||
return pw
|
||||
|
||||
def _make_xy_plot(self):
|
||||
pw = pg.PlotWidget(title="XY 模式 (李萨如图)")
|
||||
pw.setBackground(BG_COLOR)
|
||||
pw.showGrid(x=True, y=True, alpha=0.3)
|
||||
pw.setLabel("bottom", "CH1", units="V")
|
||||
pw.setLabel("left", "CH2", units="V")
|
||||
pw.setAspectLocked(True)
|
||||
|
||||
ch1, ch2 = self.snap.ch1_adc, self.snap.ch2_adc
|
||||
if ch1 is not None and ch2 is not None:
|
||||
n = min(len(ch1), len(ch2))
|
||||
if n > 1:
|
||||
v1 = adc_to_voltage(ch1[:n], self.params["ch1_vdiv"],
|
||||
self.params["ch1_off"])
|
||||
v2 = adc_to_voltage(ch2[:n], self.params["ch2_vdiv"],
|
||||
self.params["ch2_off"])
|
||||
pen = pg.mkPen(color=XY_COLOR, width=1.0)
|
||||
pw.plot(v1, v2, pen=pen)
|
||||
return pw
|
||||
|
||||
def _info_text(self) -> str:
|
||||
p = self.params
|
||||
lines = [
|
||||
f"设备: {self.snap.idn or 'N/A'}",
|
||||
f"CH1: {p['ch1_vdiv'] * 1e3:.1f}mV/div",
|
||||
f"CH2: {p['ch2_vdiv'] * 1e3:.1f}mV/div",
|
||||
f"时基: {p['tb_scale'] * 1e3:.3g}ms/div",
|
||||
]
|
||||
if self.snap.ch1_adc is not None:
|
||||
lines.append(f"CH1: {len(self.snap.ch1_adc)} 点")
|
||||
if self.snap.ch2_adc is not None:
|
||||
lines.append(f"CH2: {len(self.snap.ch2_adc)} 点")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
# ─── 实时窗口 ────────────────────────────────────────────────────
|
||||
|
||||
|
||||
class LiveWindow(QtWidgets.QMainWindow):
|
||||
"""连续实时波形:后台线程取 USB → QTimer 定时刷新曲线。"""
|
||||
|
||||
def __init__(self, interval_ms: int = 300):
|
||||
super().__init__()
|
||||
self.interval_ms = interval_ms
|
||||
self.dev: Optional[OscilloscopeData] = None
|
||||
self.params: dict = {}
|
||||
self._frame_count = 0
|
||||
|
||||
# 队列与线程
|
||||
self._data_queue: queue.Queue = queue.Queue(maxsize=1)
|
||||
self._stop_event = threading.Event()
|
||||
self._fetch_thread: Optional[threading.Thread] = None
|
||||
|
||||
# 曲线引用
|
||||
self._curve1: Optional[pg.PlotDataItem] = None
|
||||
self._curve2: Optional[pg.PlotDataItem] = None
|
||||
self._curve_xy: Optional[pg.PlotDataItem] = None
|
||||
|
||||
self._setup_ui()
|
||||
|
||||
# ── UI ───────────────────────────────────────────────────
|
||||
|
||||
def _setup_ui(self):
|
||||
self.setWindowTitle("示波器 — 实时波形 — OWON NDS102U")
|
||||
self.resize(1400, 650)
|
||||
|
||||
cw = QtWidgets.QWidget()
|
||||
self.setCentralWidget(cw)
|
||||
hbox = QtWidgets.QHBoxLayout(cw)
|
||||
|
||||
# 时域
|
||||
self._pw_time = pg.PlotWidget(title="时域波形")
|
||||
self._pw_time.setBackground(BG_COLOR)
|
||||
self._pw_time.showGrid(x=True, y=True, alpha=0.3)
|
||||
self._pw_time.setLabel("bottom", "时间", units="s")
|
||||
self._pw_time.setLabel("left", "电压", units="V")
|
||||
self._pw_time.addLegend()
|
||||
pen1 = pg.mkPen(color=CH_COLORS["CH1"], width=1.2)
|
||||
pen2 = pg.mkPen(color=CH_COLORS["CH2"], width=1.2)
|
||||
self._curve1 = self._pw_time.plot([], [], pen=pen1, name="CH1")
|
||||
self._curve2 = self._pw_time.plot([], [], pen=pen2, name="CH2")
|
||||
hbox.addWidget(self._pw_time)
|
||||
|
||||
# XY
|
||||
self._pw_xy = pg.PlotWidget(title="XY 模式 (李萨如图)")
|
||||
self._pw_xy.setBackground(BG_COLOR)
|
||||
self._pw_xy.showGrid(x=True, y=True, alpha=0.3)
|
||||
self._pw_xy.setLabel("bottom", "CH1", units="V")
|
||||
self._pw_xy.setLabel("left", "CH2", units="V")
|
||||
self._pw_xy.setAspectLocked(True)
|
||||
pen_xy = pg.mkPen(color=XY_COLOR, width=1.0)
|
||||
self._curve_xy = self._pw_xy.plot([], [], pen=pen_xy)
|
||||
hbox.addWidget(self._pw_xy)
|
||||
|
||||
# 状态栏
|
||||
self.statusBar().showMessage("就绪")
|
||||
|
||||
# 定时器
|
||||
self._timer = QtCore.QTimer()
|
||||
self._timer.timeout.connect(self._on_timer)
|
||||
self._timer.start(self.interval_ms)
|
||||
|
||||
# ── 启动 ─────────────────────────────────────────────────
|
||||
|
||||
def start(self):
|
||||
print("[实时模式] 正在连接示波器...")
|
||||
self.dev = OscilloscopeData()
|
||||
try:
|
||||
self.dev.connect()
|
||||
except RuntimeError as e:
|
||||
print(f"连接失败: {e}")
|
||||
return
|
||||
|
||||
print("已连接,关闭窗口退出")
|
||||
head = self.dev.fetch_head()
|
||||
self.params = _channel_params(head)
|
||||
|
||||
# 初始 X 轴范围
|
||||
if self._curve1 is not None:
|
||||
self._pw_time.setXRange(0, _SCREEN_DIVS * self.params["tb_scale"])
|
||||
|
||||
# 后台取数线程
|
||||
self._fetch_thread = threading.Thread(target=self._fetch_loop, daemon=True)
|
||||
self._fetch_thread.start()
|
||||
|
||||
# ── 后台线程 ─────────────────────────────────────────────
|
||||
|
||||
def _fetch_loop(self):
|
||||
while not self._stop_event.is_set():
|
||||
try:
|
||||
ch1 = self.dev.fetch_waveform(1) # type: ignore[union-attr]
|
||||
time.sleep(0.05)
|
||||
ch2 = self.dev.fetch_waveform(2) # type: ignore[union-attr]
|
||||
self.dev._cmd(":RUNning RUN") # type: ignore[union-attr]
|
||||
except Exception:
|
||||
time.sleep(0.1)
|
||||
continue
|
||||
# 只保留最新一帧
|
||||
while not self._data_queue.empty():
|
||||
try:
|
||||
self._data_queue.get_nowait()
|
||||
except queue.Empty:
|
||||
break
|
||||
try:
|
||||
self._data_queue.put_nowait((ch1, ch2))
|
||||
except queue.Full:
|
||||
pass
|
||||
|
||||
# ── 定时回调 (主线程) ────────────────────────────────────
|
||||
|
||||
def _on_timer(self):
|
||||
try:
|
||||
ch1_adc, ch2_adc = self._data_queue.get_nowait()
|
||||
except queue.Empty:
|
||||
return # 无新数据,跳过
|
||||
|
||||
self._frame_count += 1
|
||||
self.statusBar().showMessage(
|
||||
f"帧 #{self._frame_count} ({self.interval_ms}ms 刷新)")
|
||||
|
||||
tb = self.params["tb_scale"]
|
||||
n1 = len(ch1_adc) if ch1_adc is not None else 0
|
||||
n2 = len(ch2_adc) if ch2_adc is not None else 0
|
||||
if self._frame_count % 20 == 1:
|
||||
print(f" [#{self._frame_count}] CH1={n1}pts CH2={n2}pts tb={tb*1e3:.2f}ms")
|
||||
|
||||
try:
|
||||
self._apply_data(ch1_adc, ch2_adc, tb)
|
||||
except Exception as e:
|
||||
print(f" [UI 错误] {e}")
|
||||
|
||||
# ── 数据应用到曲线 ───────────────────────────────────────
|
||||
|
||||
def _apply_data(self, ch1_adc, ch2_adc, tb: float):
|
||||
# 时域
|
||||
if ch1_adc is not None and len(ch1_adc) > 0:
|
||||
t = build_time_axis(len(ch1_adc), tb)
|
||||
v = adc_to_voltage(ch1_adc, self.params["ch1_vdiv"],
|
||||
self.params["ch1_off"])
|
||||
self._curve1.setData(t, v)
|
||||
if ch2_adc is not None and len(ch2_adc) > 0:
|
||||
t = build_time_axis(len(ch2_adc), tb)
|
||||
v = adc_to_voltage(ch2_adc, self.params["ch2_vdiv"],
|
||||
self.params["ch2_off"])
|
||||
self._curve2.setData(t, v)
|
||||
# XY
|
||||
if (ch1_adc is not None and ch2_adc is not None
|
||||
and len(ch1_adc) > 1 and len(ch2_adc) > 1):
|
||||
n = min(len(ch1_adc), len(ch2_adc))
|
||||
v1 = adc_to_voltage(ch1_adc[:n], self.params["ch1_vdiv"],
|
||||
self.params["ch1_off"])
|
||||
v2 = adc_to_voltage(ch2_adc[:n], self.params["ch2_vdiv"],
|
||||
self.params["ch2_off"])
|
||||
self._curve_xy.setData(v1, v2)
|
||||
|
||||
self._pw_time.autoRange()
|
||||
self._pw_xy.autoRange()
|
||||
|
||||
if self._frame_count % 20 == 1:
|
||||
if ch1_adc is not None and len(ch1_adc) > 10:
|
||||
import hashlib
|
||||
h = hashlib.md5(ch1_adc.tobytes()).hexdigest()[:8]
|
||||
print(f" [#{self._frame_count}] CH1[0:3]={ch1_adc[:3].tolist()}"
|
||||
f" ch1_md5={h}")
|
||||
|
||||
# ── 关闭 ─────────────────────────────────────────────────
|
||||
|
||||
def closeEvent(self, event):
|
||||
self._stop_event.set()
|
||||
self._timer.stop()
|
||||
if self._fetch_thread is not None:
|
||||
self._fetch_thread.join(timeout=2.0)
|
||||
if self.dev:
|
||||
self.dev.disconnect()
|
||||
self.dev = None
|
||||
print(f"已断开,共 {self._frame_count} 帧")
|
||||
event.accept()
|
||||
|
||||
|
||||
# ─── 入口 ────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
def snapshot_view():
|
||||
"""单次快照。"""
|
||||
print("[快照模式] 正在连接示波器...")
|
||||
try:
|
||||
with OscilloscopeData() as dev:
|
||||
snap = dev.snapshot()
|
||||
except RuntimeError as e:
|
||||
print(f"连接失败: {e}")
|
||||
sys.exit(1)
|
||||
|
||||
app = _get_app()
|
||||
win = SnapshotWindow(snap)
|
||||
win.show()
|
||||
app.exec_()
|
||||
|
||||
|
||||
def live_view(interval_ms: int = 300):
|
||||
"""连续实时波形。"""
|
||||
app = _get_app()
|
||||
win = LiveWindow(interval_ms)
|
||||
win.show()
|
||||
win.start()
|
||||
app.exec_()
|
||||
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
parser = argparse.ArgumentParser(description="示波器截图与波形观测工具")
|
||||
sub = parser.add_subparsers(dest="mode")
|
||||
sub.add_parser("snapshot", help="单次快照 (默认)")
|
||||
live_parser = sub.add_parser("live", help="连续实时波形")
|
||||
live_parser.add_argument("--interval", type=int, default=300,
|
||||
help="刷新间隔 (毫秒), 默认 300")
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.mode == "live":
|
||||
live_view(interval_ms=args.interval)
|
||||
else:
|
||||
snapshot_view()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
91
backend/tools/scpi_repl.py
普通文件
91
backend/tools/scpi_repl.py
普通文件
@ -0,0 +1,91 @@
|
||||
#!/usr/bin/env python3
|
||||
"""SCPI REPL — 直接输入 SCPI 命令看设备回复。"""
|
||||
import sys, os, binascii
|
||||
import usb.core, usb.util
|
||||
|
||||
VID, PID = 0x5345, 0x1234
|
||||
|
||||
dev = usb.core.find(idVendor=VID, idProduct=PID)
|
||||
assert dev, "设备未找到: 请确认 USB 已连且 kernel driver 未占用"
|
||||
for cfg in dev:
|
||||
for intf in cfg:
|
||||
if dev.is_kernel_driver_active(intf.bInterfaceNumber):
|
||||
dev.detach_kernel_driver(intf.bInterfaceNumber)
|
||||
dev.set_configuration()
|
||||
intf = dev.get_active_configuration()[(0, 0)]
|
||||
ep_out = ep_in = None
|
||||
for ep in intf:
|
||||
d = usb.util.endpoint_direction(ep.bEndpointAddress)
|
||||
if d == usb.util.ENDPOINT_OUT: ep_out = ep
|
||||
elif d == usb.util.ENDPOINT_IN: ep_in = ep
|
||||
assert ep_out and ep_in
|
||||
MAXPKT = ep_in.wMaxPacketSize
|
||||
|
||||
def send(cmd: str, timeout=5000):
|
||||
b = cmd.encode('ascii')
|
||||
if not b.endswith(b'\n'):
|
||||
b += b'\n'
|
||||
dev.write(ep_out, b, timeout=timeout)
|
||||
resp = b''
|
||||
while True:
|
||||
try:
|
||||
data = dev.read(ep_in, MAXPKT, timeout=timeout)
|
||||
if not data: break
|
||||
resp += data.tobytes()
|
||||
if len(data) < MAXPKT: break
|
||||
except usb.core.USBError as e:
|
||||
if e.errno == 110: break
|
||||
raise
|
||||
return resp
|
||||
|
||||
def reply(cmd: str) -> str:
|
||||
r = send(cmd)
|
||||
if not r:
|
||||
return "(无响应)"
|
||||
# 尝试 ASCII 解码
|
||||
try:
|
||||
text = r.decode('ascii').strip()
|
||||
return f"{text} ({len(r)}B)"
|
||||
except UnicodeDecodeError:
|
||||
return f"HEX[{len(r)}B] {binascii.hexlify(r[:64], ' ').decode()}{'...' if len(r)>64 else ''}"
|
||||
|
||||
print(f"已连接 max_pkt={MAXPKT}")
|
||||
print("直接输入 SCPI 命令 (如 :RUNning? 或 :DATA:WAVE:SCREen:CH1?)")
|
||||
print("/raw cmd 发送原始命令不自动加 ?/\\n")
|
||||
print("/quit 退出\n")
|
||||
|
||||
try:
|
||||
while True:
|
||||
try:
|
||||
line = input(">> ").strip()
|
||||
except (EOFError, KeyboardInterrupt):
|
||||
break
|
||||
if not line:
|
||||
continue
|
||||
if line == '/quit':
|
||||
break
|
||||
if line.startswith('/raw '):
|
||||
b = line[5:].encode('ascii')
|
||||
dev.write(ep_out, b, timeout=5000)
|
||||
# 读响应
|
||||
resp = b''
|
||||
while True:
|
||||
try:
|
||||
d = dev.read(ep_in, MAXPKT, timeout=1000)
|
||||
if not d: break
|
||||
resp += d.tobytes()
|
||||
if len(d) < MAXPKT: break
|
||||
except usb.core.USBError as e:
|
||||
if e.errno == 110: break
|
||||
raise
|
||||
print(f"HEX[{len(resp)}B] {binascii.hexlify(resp[:128], ' ').decode()}{'...' if len(resp)>128 else ''}")
|
||||
continue
|
||||
try:
|
||||
print(reply(line))
|
||||
except Exception as e:
|
||||
print(f"错误: {e}")
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
finally:
|
||||
usb.util.dispose_resources(dev)
|
||||
print("\n已断开")
|
||||
@ -0,0 +1,176 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
声速测定 — 时差法独立工具
|
||||
|
||||
通过原生 PyUSB + SCPI 协议获取 CH1 和 CH2 原始波形数据,
|
||||
使用时差法 (第一个脉冲峰时间差) 计算声波传递时间,
|
||||
并在 GUI 中展示原始波形与标记的峰值位置。
|
||||
|
||||
用法:
|
||||
python -m tools.sound_speed_detector # 默认 VID/PID
|
||||
python -m tools.sound_speed_detector --vid 0x5345 --pid 0x1234
|
||||
python -m tools.sound_speed_detector --height 0.3 --prominence 0.2
|
||||
|
||||
工作流程:
|
||||
1. 连接示波器 (PyUSB)
|
||||
2. 获取设备信息 (IDN)
|
||||
3. 获取 HEAD (时基、电压档位、偏移等)
|
||||
4. 获取 CH1 和 CH2 原始波形
|
||||
5. ADC → 电压转换 + 时间轴构建
|
||||
6. 脉冲峰检测 (scipy.signal.find_peaks)
|
||||
7. GUI 展示
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
import numpy as np
|
||||
|
||||
_SCRIPT_DIR = Path(__file__).resolve().parent
|
||||
|
||||
# 确保可以 import 本包内部的模块
|
||||
if str(_SCRIPT_DIR.parent) not in sys.path:
|
||||
sys.path.insert(0, str(_SCRIPT_DIR.parent))
|
||||
|
||||
from sound_speed_detector.scpi import ScpiDevice, SCPIError
|
||||
from sound_speed_detector.waveform import (
|
||||
fetch_head,
|
||||
fetch_waveform,
|
||||
adc_to_voltage,
|
||||
build_time_axis,
|
||||
HeadInfo,
|
||||
)
|
||||
from sound_speed_detector.peaks import compute_time_difference
|
||||
from sound_speed_detector.gui import run_gui
|
||||
|
||||
|
||||
def parse_args() -> argparse.Namespace:
|
||||
p = argparse.ArgumentParser(
|
||||
description="声速测定 — 时差法 (PyUSB + SCPI 独立工具)"
|
||||
)
|
||||
p.add_argument("--vid", type=str, default="0x5345",
|
||||
help="USB Vendor ID (默认: 0x5345)")
|
||||
p.add_argument("--pid", type=str, default="0x1234",
|
||||
help="USB Product ID (默认: 0x1234)")
|
||||
p.add_argument("--height", type=float, default=0.25,
|
||||
help="峰值检测高度比例 (默认: 0.25)")
|
||||
p.add_argument("--prominence", type=float, default=0.15,
|
||||
help="峰值检测显著度比例 (默认: 0.15)")
|
||||
p.add_argument("--distance", type=int, default=10,
|
||||
help="峰间最小距离/样本数 (默认: 10)")
|
||||
p.add_argument("--no-gui", action="store_true",
|
||||
help="跳过 GUI,仅打印终端结果")
|
||||
return p.parse_args()
|
||||
|
||||
|
||||
def main() -> None:
|
||||
args = parse_args()
|
||||
|
||||
vid = int(args.vid, 16) if args.vid.startswith("0x") else int(args.vid)
|
||||
pid = int(args.pid, 16) if args.pid.startswith("0x") else int(args.pid)
|
||||
|
||||
print("=" * 55)
|
||||
print(" 声速测定 — 时差法")
|
||||
print(" PyUSB + SCPI 独立采集工具")
|
||||
print("=" * 55)
|
||||
|
||||
# ── 1. 连接示波器 ──
|
||||
print(f"\n[1/5] 连接示波器 (VID=0x{vid:04X}, PID=0x{pid:04X}) ...")
|
||||
try:
|
||||
dev = ScpiDevice(vid=vid, pid=pid)
|
||||
dev.open()
|
||||
except SCPIError as e:
|
||||
print(f" 连接失败: {e}", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
|
||||
try:
|
||||
# ── 2. 获取设备信息 ──
|
||||
print("[2/5] 获取设备信息 ...")
|
||||
device_id = dev.idn()
|
||||
print(f" 设备: {device_id}")
|
||||
|
||||
# ── 3. 获取 HEAD (示波器参数) ──
|
||||
print("[3/5] 获取示波器参数 (HEAD) ...")
|
||||
head = fetch_head(dev)
|
||||
print(f" 时基: {head.timebase_scale}")
|
||||
for ch in head.channels:
|
||||
print(f" {ch.name}: {ch.scale} "
|
||||
f"(offset={ch.offset}, coupling={ch.coupling}, probe={ch.probe})")
|
||||
print(f" 数据点数: {head.datalen}")
|
||||
|
||||
# ── 4. 获取波形 ──
|
||||
print("[4/5] 获取 CH1 & CH2 波形 ...")
|
||||
ch1_adc = fetch_waveform(dev, 1)
|
||||
time.sleep(0.05)
|
||||
ch2_adc = fetch_waveform(dev, 2)
|
||||
print(f" CH1: {len(ch1_adc)} 点 (ADC 范围 [{ch1_adc.min():.0f}, {ch1_adc.max():.0f}])")
|
||||
print(f" CH2: {len(ch2_adc)} 点 (ADC 范围 [{ch2_adc.min():.0f}, {ch2_adc.max():.0f}])")
|
||||
|
||||
# ── 转换 ──
|
||||
ch1_param = head.get_channel("ch1")
|
||||
ch2_param = head.get_channel("ch2")
|
||||
|
||||
# 通过 SCPI 单独查询 offset 以获得更精确的偏移电压
|
||||
ch1_off_scpi: Optional[float] = None
|
||||
ch2_off_scpi: Optional[float] = None
|
||||
try:
|
||||
ch1_off_scpi = dev.send_float(":CH1:OFFSET?")
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
ch2_off_scpi = dev.send_float(":CH2:OFFSET?")
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
ch1_vdiv = ch1_param.vdiv if ch1_param else 1.0
|
||||
ch1_off = ch1_off_scpi if ch1_off_scpi is not None else (ch1_param.offset_volts if ch1_param else 0.0)
|
||||
ch2_vdiv = ch2_param.vdiv if ch2_param else 1.0
|
||||
ch2_off = ch2_off_scpi if ch2_off_scpi is not None else (ch2_param.offset_volts if ch2_param else 0.0)
|
||||
|
||||
v_ch1 = adc_to_voltage(ch1_adc, ch1_vdiv, ch1_off)
|
||||
v_ch2 = adc_to_voltage(ch2_adc, ch2_vdiv, ch2_off)
|
||||
tb_sec = head.tb_scale_sec
|
||||
t_ch1 = build_time_axis(len(ch1_adc), tb_sec)
|
||||
t_ch2 = build_time_axis(len(ch2_adc), tb_sec)
|
||||
|
||||
# ── 5. 峰值检测 ──
|
||||
print("[5/5] 峰值检测 & 时间差计算 ...")
|
||||
result = compute_time_difference(
|
||||
t_ch1, v_ch1, t_ch2, v_ch2,
|
||||
height_factor=args.height,
|
||||
prominence_factor=args.prominence,
|
||||
distance=args.distance,
|
||||
)
|
||||
|
||||
if result.get("delta_t") is not None:
|
||||
dt_us = result["delta_t"] * 1e6
|
||||
print(f" CH1 第一脉冲峰: {result['ch1_peak_time']*1000:.4f} ms")
|
||||
print(f" CH2 第一脉冲峰: {result['ch2_peak_time']*1000:.4f} ms")
|
||||
print(f" Δt = {result['delta_t']*1000:.4f} ms = {dt_us:.2f} μs")
|
||||
else:
|
||||
print(f" {result.get('error', '检测失败')}")
|
||||
|
||||
head_info = {
|
||||
"timebase": head.timebase_scale,
|
||||
"ch1_scale": ch1_param.scale if ch1_param else "N/A",
|
||||
"ch2_scale": ch2_param.scale if ch2_param else "N/A",
|
||||
}
|
||||
|
||||
finally:
|
||||
dev.close()
|
||||
print("\n 示波器已断开")
|
||||
|
||||
if args.no_gui:
|
||||
print("\n(已跳过 GUI)")
|
||||
else:
|
||||
print("\n启动 GUI ...")
|
||||
run_gui(t_ch1, v_ch1, t_ch2, v_ch2, result, device_id, head_info)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,462 @@
|
||||
"""
|
||||
示波器波形 GUI — 展示 CH1/CH2 原始波形、脉冲峰标记、时间差结果。
|
||||
|
||||
支持:
|
||||
- 相对模式: (v - baseline) * factor + baseline,放大脉冲偏离
|
||||
- X/Y 独立缩放
|
||||
- 模式/倍数切换即时重绘
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Optional
|
||||
|
||||
import numpy as np
|
||||
from PyQt5 import QtWidgets, QtCore, QtGui
|
||||
import pyqtgraph as pg
|
||||
|
||||
__all__ = ["ResultWindow", "run_gui"]
|
||||
|
||||
CH1_COLOR = (255, 150, 50)
|
||||
CH2_COLOR = (80, 220, 100)
|
||||
CH1_MARKER_COLOR = (255, 70, 30)
|
||||
CH2_MARKER_COLOR = (30, 190, 80)
|
||||
DELTA_COLOR = "#00e5ff"
|
||||
|
||||
BG_COLOR = "#12122a"
|
||||
INFO_BG = "#1a1a3e"
|
||||
TEXT_COLOR = "#e0e0e0"
|
||||
|
||||
WAVEFORM_LINE_WIDTH = 2.5
|
||||
MARKER_SIZE = 22
|
||||
MARKER_PEN_WIDTH = 2.5
|
||||
VLINE_WIDTH = 2.0
|
||||
DEFAULT_FACTOR = 5
|
||||
|
||||
ZOOM_MIN = 10
|
||||
ZOOM_MAX = 5000
|
||||
ZOOM_DEFAULT = 100
|
||||
|
||||
|
||||
def _spin_style(color: str) -> str:
|
||||
return (
|
||||
f"QSpinBox {{ background: #222244; color: {color}; border: 1px solid #444477; "
|
||||
"border-radius: 4px; padding: 2px 6px; font-size: 13px; font-weight: bold; }}"
|
||||
)
|
||||
|
||||
|
||||
class ResultWindow(QtWidgets.QMainWindow):
|
||||
"""声速测定 — 时差法结果展示窗口。"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
t_ch1: np.ndarray,
|
||||
v_ch1: np.ndarray,
|
||||
t_ch2: np.ndarray,
|
||||
v_ch2: np.ndarray,
|
||||
result: dict,
|
||||
device_id: str = "",
|
||||
head_info: Optional[dict] = None,
|
||||
):
|
||||
super().__init__()
|
||||
self._t_ch1 = t_ch1
|
||||
self._t_ch2 = t_ch2
|
||||
self._v_ch1_raw = v_ch1
|
||||
self._v_ch2_raw = v_ch2
|
||||
self._baseline_ch1 = float(np.median(v_ch1))
|
||||
self._baseline_ch2 = float(np.median(v_ch2))
|
||||
self.result = result
|
||||
self.device_id = device_id
|
||||
self.head_info = head_info or {}
|
||||
self._mode = "relative"
|
||||
self._factor = DEFAULT_FACTOR
|
||||
self._x_zoom = ZOOM_DEFAULT
|
||||
self._y_zoom = ZOOM_DEFAULT
|
||||
|
||||
self._added_items: list = [] # 每次 _redraw 添加的所有 plot items
|
||||
self._legend = None
|
||||
|
||||
self._setup()
|
||||
|
||||
# ── 电压变换 ──────────────────────────────────────────────
|
||||
|
||||
def _transform(self, v: np.ndarray, baseline: float) -> np.ndarray:
|
||||
if self._mode == "relative":
|
||||
return (v - baseline) * self._factor + baseline
|
||||
return v
|
||||
|
||||
@property
|
||||
def _v_ch1(self) -> np.ndarray:
|
||||
return self._transform(self._v_ch1_raw, self._baseline_ch1)
|
||||
|
||||
@property
|
||||
def _v_ch2(self) -> np.ndarray:
|
||||
return self._transform(self._v_ch2_raw, self._baseline_ch2)
|
||||
|
||||
def _peak_voltage(self, ch: str) -> Optional[float]:
|
||||
v = self.result.get(f"{ch}_peak_voltage")
|
||||
if v is None:
|
||||
return None
|
||||
base = self._baseline_ch1 if ch == "ch1" else self._baseline_ch2
|
||||
return self._transform(np.array([v]), base)[0] if self._mode == "relative" else v
|
||||
|
||||
# ── UI 搭建 ───────────────────────────────────────────────
|
||||
|
||||
def _setup(self) -> None:
|
||||
self.setWindowTitle("声速测定 — 时差法")
|
||||
self.resize(1400, 900)
|
||||
|
||||
cw = QtWidgets.QWidget()
|
||||
self.setCentralWidget(cw)
|
||||
layout = QtWidgets.QVBoxLayout(cw)
|
||||
layout.setContentsMargins(10, 10, 10, 10)
|
||||
layout.setSpacing(8)
|
||||
|
||||
layout.addWidget(self._make_info_bar())
|
||||
layout.addWidget(self._make_zoom_bar())
|
||||
|
||||
self._plot_widget = pg.PlotWidget()
|
||||
self._plot_widget.setBackground(BG_COLOR)
|
||||
self._plot_widget.showGrid(x=True, y=True, alpha=0.4)
|
||||
self._plot_widget.setLabel("bottom", "时间", units="s")
|
||||
|
||||
axis_font = QtGui.QFont("sans-serif", 11)
|
||||
self._plot_widget.getAxis("bottom").setTickFont(axis_font)
|
||||
self._plot_widget.getAxis("left").setTickFont(axis_font)
|
||||
for ax_name in ("bottom", "left"):
|
||||
self._plot_widget.getAxis(ax_name).label.setFont(
|
||||
QtGui.QFont("sans-serif", 12, QtGui.QFont.Bold))
|
||||
self._plot_widget.getPlotItem().titleLabel.item.setFont(
|
||||
QtGui.QFont("sans-serif", 14, QtGui.QFont.Bold))
|
||||
|
||||
self._legend = self._plot_widget.addLegend(
|
||||
offset=(12, 12),
|
||||
brush=pg.mkBrush("#1a1a2eCC"),
|
||||
pen=pg.mkPen("#444477", width=1),
|
||||
labelTextSize="12pt",
|
||||
)
|
||||
|
||||
self._update_axis_label()
|
||||
self._redraw()
|
||||
layout.addWidget(self._plot_widget, stretch=1)
|
||||
layout.addWidget(self._make_result_bar())
|
||||
|
||||
# ── 信息栏 ────────────────────────────────────────────────
|
||||
|
||||
def _make_info_bar(self) -> QtWidgets.QWidget:
|
||||
bar = QtWidgets.QWidget()
|
||||
bar.setStyleSheet(f"background: {INFO_BG}; border-radius: 6px; padding: 6px;")
|
||||
bar.setFixedHeight(46)
|
||||
hbox = QtWidgets.QHBoxLayout(bar)
|
||||
hbox.setContentsMargins(12, 2, 12, 2)
|
||||
hbox.setSpacing(20)
|
||||
|
||||
for title, value in [
|
||||
("设备", self.device_id or "N/A"),
|
||||
("时基", self.head_info.get("timebase", "N/A")),
|
||||
("CH1", self.head_info.get("ch1_scale", "N/A")),
|
||||
("CH2", self.head_info.get("ch2_scale", "N/A")),
|
||||
]:
|
||||
lbl = QtWidgets.QLabel(f"<b>{title}:</b> {value}")
|
||||
lbl.setStyleSheet(f"color: {TEXT_COLOR}; font-size: 13px;")
|
||||
hbox.addWidget(lbl)
|
||||
|
||||
hbox.addStretch()
|
||||
|
||||
hbox.addWidget(QtWidgets.QLabel(
|
||||
"<b>显示:</b>", styleSheet=f"color:{TEXT_COLOR};font-size:13px;"))
|
||||
|
||||
self._mode_cb = QtWidgets.QComboBox()
|
||||
self._mode_cb.addItems(["相对模式", "绝对模式"])
|
||||
self._mode_cb.setCurrentIndex(0)
|
||||
self._mode_cb.setStyleSheet(
|
||||
"QComboBox { background:#222244; color:#e0e0e0; border:1px solid #444477; "
|
||||
"border-radius:4px; padding:1px 6px; font-size:12px; }"
|
||||
"QComboBox::drop-down { border:none; }"
|
||||
"QComboBox QAbstractItemView { background:#222244; color:#e0e0e0; "
|
||||
"selection-background-color:#444477; }")
|
||||
self._mode_cb.currentIndexChanged.connect(self._on_mode_changed)
|
||||
hbox.addWidget(self._mode_cb)
|
||||
|
||||
self._factor_sb = QtWidgets.QSpinBox()
|
||||
self._factor_sb.setRange(1, 50)
|
||||
self._factor_sb.setValue(DEFAULT_FACTOR)
|
||||
self._factor_sb.setPrefix("×")
|
||||
self._factor_sb.setStyleSheet(_spin_style("#00e5ff"))
|
||||
self._factor_sb.valueChanged.connect(self._on_factor_changed)
|
||||
hbox.addWidget(self._factor_sb)
|
||||
|
||||
return bar
|
||||
|
||||
# ── 缩放栏 ────────────────────────────────────────────────
|
||||
|
||||
def _make_zoom_bar(self) -> QtWidgets.QWidget:
|
||||
bar = QtWidgets.QWidget()
|
||||
bar.setStyleSheet(f"background: {INFO_BG}; border-radius: 6px; padding: 4px;")
|
||||
bar.setFixedHeight(40)
|
||||
hbox = QtWidgets.QHBoxLayout(bar)
|
||||
hbox.setContentsMargins(12, 2, 12, 2)
|
||||
hbox.setSpacing(10)
|
||||
|
||||
for label, attr, color in [
|
||||
("X 缩放", "_x_zoom_sb", "#ff9800"),
|
||||
("Y 缩放", "_y_zoom_sb", "#4fc3f7"),
|
||||
]:
|
||||
lbl = QtWidgets.QLabel(f"<b>{label}:</b>")
|
||||
lbl.setStyleSheet(f"color: {color}; font-size: 13px;")
|
||||
hbox.addWidget(lbl)
|
||||
|
||||
sb = QtWidgets.QSpinBox()
|
||||
sb.setRange(ZOOM_MIN, ZOOM_MAX)
|
||||
sb.setValue(ZOOM_DEFAULT)
|
||||
sb.setSuffix("%")
|
||||
sb.setSingleStep(10)
|
||||
sb.setStyleSheet(_spin_style(color))
|
||||
sb.valueChanged.connect(
|
||||
self._on_x_zoom_changed if "x" in attr else self._on_y_zoom_changed
|
||||
)
|
||||
setattr(self, attr, sb)
|
||||
hbox.addWidget(sb)
|
||||
|
||||
hbox.addStretch()
|
||||
|
||||
reset_btn = QtWidgets.QPushButton("重置缩放")
|
||||
reset_btn.setStyleSheet(
|
||||
"QPushButton { background:#333355; color:#e0e0e0; border:1px solid #555577; "
|
||||
"border-radius:4px; padding:3px 12px; font-size:12px; }"
|
||||
"QPushButton:hover { background:#444477; }")
|
||||
reset_btn.clicked.connect(self._reset_zoom)
|
||||
hbox.addWidget(reset_btn)
|
||||
|
||||
return bar
|
||||
|
||||
# ── 回调 ──────────────────────────────────────────────────
|
||||
|
||||
def _on_mode_changed(self, idx: int) -> None:
|
||||
self._mode = "relative" if idx == 0 else "absolute"
|
||||
self._factor_sb.setEnabled(self._mode == "relative")
|
||||
self._factor_sb.setStyleSheet(
|
||||
_spin_style("#00e5ff") if self._mode == "relative"
|
||||
else _spin_style("#666688"))
|
||||
self._update_axis_label()
|
||||
self._redraw()
|
||||
|
||||
def _on_factor_changed(self, value: int) -> None:
|
||||
if self._mode != "relative":
|
||||
return
|
||||
self._factor = value
|
||||
self._update_axis_label()
|
||||
self._redraw()
|
||||
|
||||
def _on_x_zoom_changed(self, value: int) -> None:
|
||||
self._x_zoom = value
|
||||
self._apply_zoom()
|
||||
|
||||
def _on_y_zoom_changed(self, value: int) -> None:
|
||||
self._y_zoom = value
|
||||
self._apply_zoom()
|
||||
|
||||
def _reset_zoom(self) -> None:
|
||||
self._x_zoom_sb.setValue(ZOOM_DEFAULT)
|
||||
self._y_zoom_sb.setValue(ZOOM_DEFAULT)
|
||||
|
||||
def _update_axis_label(self) -> None:
|
||||
if self._mode == "relative":
|
||||
self._plot_widget.setLabel(
|
||||
"left", f"电压 (×{self._factor} 相对偏离)", units="V")
|
||||
self._plot_widget.setTitle(
|
||||
f"CH1 & CH2 波形 — 相对模式 ×{self._factor}")
|
||||
else:
|
||||
self._plot_widget.setLabel("left", "电压", units="V")
|
||||
self._plot_widget.setTitle("CH1 & CH2 原始波形")
|
||||
|
||||
# ── 缩放应用 ──────────────────────────────────────────────
|
||||
|
||||
def _apply_zoom(self) -> None:
|
||||
vb = self._plot_widget.getPlotItem().getViewBox()
|
||||
# autoRange 后取当前范围, 再按比例缩放
|
||||
full_x_range = [float(self._t_ch1[0]), float(self._t_ch1[-1])]
|
||||
cx = (full_x_range[0] + full_x_range[1]) / 2
|
||||
half_w = (full_x_range[1] - full_x_range[0]) / 2
|
||||
x_factor = ZOOM_DEFAULT / max(self._x_zoom, 1)
|
||||
vb.setXRange(cx - half_w * x_factor, cx + half_w * x_factor, padding=0)
|
||||
|
||||
full_y_range = vb.viewRange()[1]
|
||||
cy = (full_y_range[0] + full_y_range[1]) / 2
|
||||
half_h = (full_y_range[1] - full_y_range[0]) / 2
|
||||
y_factor = ZOOM_DEFAULT / max(self._y_zoom, 1)
|
||||
if half_h > 1e-12:
|
||||
vb.setYRange(cy - half_h * y_factor, cy + half_h * y_factor, padding=0)
|
||||
|
||||
# ── 重绘 ──────────────────────────────────────────────────
|
||||
|
||||
def _redraw(self) -> None:
|
||||
pi = self._plot_widget.getPlotItem()
|
||||
for item in self._added_items:
|
||||
pi.removeItem(item)
|
||||
self._added_items.clear()
|
||||
|
||||
self._plot_curves()
|
||||
self._plot_delta_region()
|
||||
self._plot_peaks()
|
||||
|
||||
self._plot_widget.autoRange(padding=0.08)
|
||||
self._apply_zoom()
|
||||
|
||||
def _add(self, item) -> None:
|
||||
self._plot_widget.addItem(item)
|
||||
self._added_items.append(item)
|
||||
|
||||
def _plot_curves(self) -> None:
|
||||
if len(self._t_ch1) > 0:
|
||||
curve = pg.PlotCurveItem(
|
||||
self._t_ch1, self._v_ch1,
|
||||
pen=pg.mkPen(color=CH1_COLOR, width=WAVEFORM_LINE_WIDTH),
|
||||
name="CH1",
|
||||
)
|
||||
self._add(curve)
|
||||
if len(self._t_ch2) > 0:
|
||||
curve = pg.PlotCurveItem(
|
||||
self._t_ch2, self._v_ch2,
|
||||
pen=pg.mkPen(color=CH2_COLOR, width=WAVEFORM_LINE_WIDTH),
|
||||
name="CH2",
|
||||
)
|
||||
self._add(curve)
|
||||
|
||||
def _plot_delta_region(self) -> None:
|
||||
ch1_time = self.result.get("ch1_peak_time")
|
||||
ch2_time = self.result.get("ch2_peak_time")
|
||||
if None in (ch1_time, ch2_time):
|
||||
return
|
||||
region = pg.LinearRegionItem(
|
||||
values=(min(ch1_time, ch2_time), max(ch1_time, ch2_time)),
|
||||
orientation="vertical",
|
||||
brush=pg.mkBrush(0, 229, 255, 40),
|
||||
pen=pg.mkPen(None),
|
||||
movable=False,
|
||||
)
|
||||
region.setZValue(-10)
|
||||
self._add(region)
|
||||
|
||||
def _plot_peaks(self) -> None:
|
||||
t1 = self.result.get("ch1_peak_time")
|
||||
t2 = self.result.get("ch2_peak_time")
|
||||
dt = self.result.get("delta_t")
|
||||
v1 = self._peak_voltage("ch1")
|
||||
v2 = self._peak_voltage("ch2")
|
||||
pi = self._plot_widget.getPlotItem()
|
||||
label_font = QtGui.QFont("sans-serif", 11, QtGui.QFont.Bold)
|
||||
|
||||
for ch, t, v, clr, anchor, name in [
|
||||
("ch1", t1, v1, CH1_MARKER_COLOR, (0.5, 0), "CH1 峰"),
|
||||
("ch2", t2, v2, CH2_MARKER_COLOR, (0.5, 1), "CH2 峰"),
|
||||
]:
|
||||
if t is None or v is None:
|
||||
continue
|
||||
|
||||
scatter = pg.ScatterPlotItem(
|
||||
[t], [v],
|
||||
symbol="t", size=MARKER_SIZE,
|
||||
brush=pg.mkBrush(clr),
|
||||
pen=pg.mkPen("w", width=MARKER_PEN_WIDTH),
|
||||
name=name,
|
||||
)
|
||||
self._add(scatter)
|
||||
|
||||
vline = pg.InfiniteLine(
|
||||
pos=t, angle=90,
|
||||
pen=pg.mkPen(clr, width=VLINE_WIDTH, style=QtCore.Qt.DashLine),
|
||||
)
|
||||
self._add(vline)
|
||||
|
||||
if self._mode == "relative":
|
||||
label_text = f"{name}\n{t*1000:.3f} ms\n×{self._factor} 放大"
|
||||
else:
|
||||
label_text = f"{name}\n{t*1000:.3f} ms"
|
||||
label = pg.TextItem(label_text, color=clr, anchor=anchor)
|
||||
label.setFont(label_font)
|
||||
label.setPos(t, v)
|
||||
self._add(label)
|
||||
|
||||
if t1 is not None and t2 is not None and dt is not None:
|
||||
mid_t = (t1 + t2) / 2
|
||||
y_r = pi.viewRange()[1]
|
||||
mid_y = (y_r[0] + y_r[1]) / 2
|
||||
|
||||
dt_label = pg.TextItem(
|
||||
f"Δt = {dt*1e6:.1f} μs",
|
||||
color=DELTA_COLOR, anchor=(0.5, 0.5),
|
||||
)
|
||||
dt_label.setFont(QtGui.QFont("sans-serif", 14, QtGui.QFont.Bold))
|
||||
dt_label.setPos(mid_t, mid_y)
|
||||
self._add(dt_label)
|
||||
|
||||
for angle, pos in [(180, t1), (0, t2)]:
|
||||
arrow = pg.ArrowItem(
|
||||
angle=angle, tipAngle=35, headLen=18, tailLen=0,
|
||||
brush=pg.mkBrush(DELTA_COLOR),
|
||||
pen=pg.mkPen(DELTA_COLOR, width=2),
|
||||
)
|
||||
arrow.setPos(pos, mid_y)
|
||||
self._add(arrow)
|
||||
|
||||
conn = pg.PlotCurveItem(
|
||||
[t1, t2], [mid_y, mid_y],
|
||||
pen=pg.mkPen(DELTA_COLOR, width=2.5),
|
||||
)
|
||||
self._add(conn)
|
||||
|
||||
# ── 结果栏 ────────────────────────────────────────────────
|
||||
|
||||
def _make_result_bar(self) -> QtWidgets.QWidget:
|
||||
bar = QtWidgets.QWidget()
|
||||
bar.setStyleSheet(f"background:{INFO_BG}; border-radius:6px; padding:8px;")
|
||||
bar.setFixedHeight(76)
|
||||
hbox = QtWidgets.QHBoxLayout(bar)
|
||||
hbox.setContentsMargins(14, 6, 14, 6)
|
||||
hbox.setSpacing(24)
|
||||
|
||||
dt = self.result.get("delta_t")
|
||||
if dt is not None:
|
||||
main_lbl = QtWidgets.QLabel(
|
||||
f"<span style='font-size:26px;font-weight:bold;color:#00e5ff;'>"
|
||||
f"Δt = {dt*1000:.4f} ms</span>"
|
||||
f"<span style='font-size:20px;font-weight:bold;color:#4fc3f7;'>"
|
||||
f" = {dt*1e6:.2f} μs</span>"
|
||||
)
|
||||
else:
|
||||
main_lbl = QtWidgets.QLabel(
|
||||
f"<span style='font-size:18px;color:#ef5350;'>"
|
||||
f"{self.result.get('error','未知错误')}</span>"
|
||||
)
|
||||
hbox.addWidget(main_lbl)
|
||||
hbox.addStretch()
|
||||
|
||||
parts = []
|
||||
for ch, label in [("ch1", "CH1"), ("ch2", "CH2")]:
|
||||
t = self.result.get(f"{ch}_peak_time")
|
||||
v = self.result.get(f"{ch}_peak_voltage")
|
||||
if t is not None and v is not None:
|
||||
parts.append(f"{label} 峰 @ {t*1000:.4f} ms ({v:.3f} V)")
|
||||
detail = QtWidgets.QLabel(" ".join(parts))
|
||||
detail.setStyleSheet("color:#b0b0cc; font-size:13px;")
|
||||
hbox.addWidget(detail)
|
||||
|
||||
return bar
|
||||
|
||||
|
||||
def run_gui(
|
||||
t_ch1: np.ndarray,
|
||||
v_ch1: np.ndarray,
|
||||
t_ch2: np.ndarray,
|
||||
v_ch2: np.ndarray,
|
||||
result: dict,
|
||||
device_id: str = "",
|
||||
head_info: Optional[dict] = None,
|
||||
) -> None:
|
||||
import sys as _sys
|
||||
|
||||
app = QtWidgets.QApplication(_sys.argv)
|
||||
win = ResultWindow(t_ch1, v_ch1, t_ch2, v_ch2, result, device_id, head_info)
|
||||
win.show()
|
||||
app.exec_()
|
||||
@ -0,0 +1,116 @@
|
||||
"""
|
||||
峰值检测模块 — 使用时差法定位 CH1 和 CH2 第一个脉冲峰。
|
||||
|
||||
使用 scipy.signal.find_peaks 进行峰值检测,选择高度和显著度足够的峰,
|
||||
从各自通道中选出第一个有效峰,计算时间差。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Optional, Tuple
|
||||
|
||||
import numpy as np
|
||||
from scipy.signal import find_peaks
|
||||
|
||||
__all__ = ["find_first_pulse_peak", "compute_time_difference"]
|
||||
|
||||
|
||||
def find_first_pulse_peak(
|
||||
voltage: np.ndarray,
|
||||
time_s: np.ndarray,
|
||||
height_factor: float = 0.25,
|
||||
prominence_factor: float = 0.15,
|
||||
distance: int = 10,
|
||||
) -> Optional[Tuple[int, float]]:
|
||||
"""在信号中查找第一个脉冲峰。
|
||||
|
||||
算法:
|
||||
1. 用绝对偏离 (|V - median(V)|) 作为峰值检测的输入
|
||||
2. 设 height = height_factor * max_abs,确保只检出显著峰
|
||||
3. 设 prominence 过滤毛刺
|
||||
4. 取索引最小的峰作为 "第一个脉冲峰"
|
||||
|
||||
Args:
|
||||
voltage: 电压数组 (V)
|
||||
time_s: 时间数组 (s)
|
||||
height_factor: 峰值高度比例 (相对于最大绝对偏离)
|
||||
prominence_factor: 峰显著度比例
|
||||
distance: 峰间最小距离 (样本数)
|
||||
|
||||
Returns:
|
||||
(峰值索引, 峰值到达时间) 或 None (无信号)
|
||||
"""
|
||||
if len(voltage) < 3:
|
||||
return None
|
||||
|
||||
baseline = np.median(voltage)
|
||||
abs_dev = np.abs(voltage - baseline)
|
||||
max_dev = np.max(abs_dev)
|
||||
|
||||
if max_dev < 1e-6:
|
||||
return None # 无信号
|
||||
|
||||
height = max_dev * height_factor
|
||||
prominence = max_dev * prominence_factor
|
||||
|
||||
peaks, props = find_peaks(
|
||||
abs_dev,
|
||||
height=height,
|
||||
prominence=prominence,
|
||||
distance=distance,
|
||||
)
|
||||
|
||||
if len(peaks) == 0:
|
||||
# 放松条件再试一次
|
||||
peaks, props = find_peaks(abs_dev, height=max_dev * 0.1, distance=distance)
|
||||
if len(peaks) == 0:
|
||||
# 最终回退: 直接用最大偏离点
|
||||
idx = int(np.argmax(abs_dev))
|
||||
return (idx, float(time_s[idx]))
|
||||
|
||||
first_peak = peaks[0]
|
||||
return (int(first_peak), float(time_s[first_peak]))
|
||||
|
||||
|
||||
def compute_time_difference(
|
||||
t_ch1: np.ndarray,
|
||||
v_ch1: np.ndarray,
|
||||
t_ch2: np.ndarray,
|
||||
v_ch2: np.ndarray,
|
||||
**kwargs,
|
||||
) -> dict:
|
||||
"""计算 CH1 和 CH2 第一个脉冲峰之间的时间差 (时差法)。
|
||||
|
||||
Returns:
|
||||
dict with keys:
|
||||
ch1_peak_idx, ch1_peak_time, ch1_peak_voltage
|
||||
ch2_peak_idx, ch2_peak_time, ch2_peak_voltage
|
||||
delta_t (时间差, s)
|
||||
"""
|
||||
result_ch1 = find_first_pulse_peak(v_ch1, t_ch1, **kwargs)
|
||||
result_ch2 = find_first_pulse_peak(v_ch2, t_ch2, **kwargs)
|
||||
|
||||
if result_ch1 is None or result_ch2 is None:
|
||||
return {
|
||||
"ch1_peak_idx": None,
|
||||
"ch1_peak_time": None,
|
||||
"ch1_peak_voltage": None,
|
||||
"ch2_peak_idx": None,
|
||||
"ch2_peak_time": None,
|
||||
"ch2_peak_voltage": None,
|
||||
"delta_t": None,
|
||||
"error": "未能检测到一个或两个通道的脉冲峰",
|
||||
}
|
||||
|
||||
ch1_idx, ch1_time = result_ch1
|
||||
ch2_idx, ch2_time = result_ch2
|
||||
|
||||
return {
|
||||
"ch1_peak_idx": ch1_idx,
|
||||
"ch1_peak_time": ch1_time,
|
||||
"ch1_peak_voltage": float(v_ch1[ch1_idx]),
|
||||
"ch2_peak_idx": ch2_idx,
|
||||
"ch2_peak_time": ch2_time,
|
||||
"ch2_peak_voltage": float(v_ch2[ch2_idx]),
|
||||
"delta_t": ch2_time - ch1_time,
|
||||
}
|
||||
@ -0,0 +1,185 @@
|
||||
"""
|
||||
原生 PyUSB SCPI 设备通信层 — 直接操作 USB 批量端点,
|
||||
不依赖任何上层封装。
|
||||
|
||||
兼容 OWON NDS102U (小写 key HEAD) 和 NDS202E (大写 key HEAD, -> 后缀)。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from typing import Optional
|
||||
|
||||
import usb.core
|
||||
import usb.util
|
||||
|
||||
__all__ = [
|
||||
"ScpiDevice",
|
||||
"parse_scale_str",
|
||||
"parse_probe_ratio",
|
||||
"extract_numeric",
|
||||
"SCPIError",
|
||||
]
|
||||
|
||||
DEFAULT_VID = 0x5345
|
||||
DEFAULT_PID = 0x1234
|
||||
DEFAULT_TIMEOUT_MS = 5000
|
||||
|
||||
_SCALE_RE = re.compile(r"([\d.]+)\s*([numk]?[sv])\s*", re.IGNORECASE)
|
||||
_UNIT_MULTIPLIERS: dict[str, float] = {
|
||||
"nv": 1e-9, "uv": 1e-6, "mv": 1e-3, "v": 1.0, "kv": 1e3,
|
||||
"ns": 1e-9, "us": 1e-6, "ms": 1e-3, "s": 1.0, "ks": 1e3,
|
||||
}
|
||||
_NUMERIC_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
|
||||
_RESP_SUFFIX_RE = re.compile(rb"\s*->\s*$")
|
||||
|
||||
|
||||
class SCPIError(RuntimeError):
|
||||
"""SCPI 通信错误。"""
|
||||
pass
|
||||
|
||||
|
||||
def parse_scale_str(raw: str) -> float:
|
||||
"""解析电压/时基档位字符串,如 '5.00mv' → 0.005, '1v' → 1.0, '200us' → 2e-4。"""
|
||||
m = _SCALE_RE.search(raw.lower().strip())
|
||||
if m:
|
||||
return float(m.group(1)) * _UNIT_MULTIPLIERS.get(m.group(2), 1.0)
|
||||
try:
|
||||
return float(raw)
|
||||
except (ValueError, TypeError):
|
||||
return 1.0
|
||||
|
||||
|
||||
def parse_probe_ratio(raw: str) -> float:
|
||||
"""解析探头比例字符串,如 '10x' → 10.0, '1x' → 1.0。"""
|
||||
try:
|
||||
return float(raw.strip().lower().rstrip("x"))
|
||||
except (ValueError, TypeError):
|
||||
return 1.0
|
||||
|
||||
|
||||
def extract_numeric(text: str) -> Optional[float]:
|
||||
"""从文本中提取第一个数值。"""
|
||||
m = _NUMERIC_RE.search(text)
|
||||
if m is None:
|
||||
return None
|
||||
try:
|
||||
return float(m.group())
|
||||
except (ValueError, OverflowError):
|
||||
return None
|
||||
|
||||
|
||||
def _strip_resp_suffix(data: bytes) -> bytes:
|
||||
"""去除 NDS202E 响应末尾的 '->' 后缀。"""
|
||||
return _RESP_SUFFIX_RE.sub(b"", data)
|
||||
|
||||
|
||||
class ScpiDevice:
|
||||
"""原生 PyUSB SCPI 通信器 — 直接操作 USB 批量端点。"""
|
||||
|
||||
def __init__(self, vid: int = DEFAULT_VID, pid: int = DEFAULT_PID):
|
||||
self._vid = vid
|
||||
self._pid = pid
|
||||
self._dev: Optional[usb.core.Device] = None
|
||||
self._ep_out: Optional[usb.core.Endpoint] = None
|
||||
self._ep_in: Optional[usb.core.Endpoint] = None
|
||||
self._max_pkt: int = 512
|
||||
self._detached: list[int] = []
|
||||
|
||||
def open(self) -> None:
|
||||
dev = usb.core.find(idVendor=self._vid, idProduct=self._pid)
|
||||
if dev is None:
|
||||
raise SCPIError(
|
||||
f"设备未找到 (VID=0x{self._vid:04X}, PID=0x{self._pid:04X}). "
|
||||
"请检查 USB 连接和权限。"
|
||||
)
|
||||
self._dev = dev
|
||||
|
||||
for cfg in self._dev:
|
||||
for intf in cfg:
|
||||
ifn = intf.bInterfaceNumber
|
||||
if self._dev.is_kernel_driver_active(ifn):
|
||||
self._dev.detach_kernel_driver(ifn)
|
||||
self._detached.append(ifn)
|
||||
|
||||
self._dev.set_configuration()
|
||||
|
||||
intf = self._dev.get_active_configuration()[(0, 0)]
|
||||
for ep in intf:
|
||||
dir_ = usb.util.endpoint_direction(ep.bEndpointAddress)
|
||||
if dir_ == usb.util.ENDPOINT_OUT:
|
||||
self._ep_out = ep
|
||||
elif dir_ == usb.util.ENDPOINT_IN:
|
||||
self._ep_in = ep
|
||||
|
||||
if not self._ep_out or not self._ep_in:
|
||||
raise SCPIError("未找到批量 IN/OUT 端点")
|
||||
self._max_pkt = self._ep_in.wMaxPacketSize
|
||||
|
||||
def close(self) -> None:
|
||||
if self._dev is None:
|
||||
return
|
||||
for ifn in self._detached:
|
||||
try:
|
||||
self._dev.attach_kernel_driver(ifn)
|
||||
except usb.core.USBError:
|
||||
pass
|
||||
self._detached.clear()
|
||||
try:
|
||||
usb.util.dispose_resources(self._dev)
|
||||
except Exception:
|
||||
pass
|
||||
self._dev = None
|
||||
self._ep_out = None
|
||||
self._ep_in = None
|
||||
|
||||
def __enter__(self):
|
||||
self.open()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.close()
|
||||
|
||||
@property
|
||||
def is_open(self) -> bool:
|
||||
return self._dev is not None
|
||||
|
||||
def _flush_input(self) -> None:
|
||||
try:
|
||||
while True:
|
||||
self._dev.read(self._ep_in, self._max_pkt, timeout=50)
|
||||
except usb.core.USBError:
|
||||
pass
|
||||
|
||||
def send(self, scpi: str, timeout: int = DEFAULT_TIMEOUT_MS) -> bytes:
|
||||
"""发送 SCPI 命令,返回去除 '->' 后缀的原始响应字节。"""
|
||||
if not scpi.endswith("\n"):
|
||||
scpi += "\n"
|
||||
self._flush_input()
|
||||
self._dev.write(self._ep_out, scpi.encode("ascii"), timeout=timeout)
|
||||
resp = b""
|
||||
while True:
|
||||
try:
|
||||
data = self._dev.read(self._ep_in, self._max_pkt, timeout=timeout)
|
||||
if not data:
|
||||
break
|
||||
resp += data.tobytes()
|
||||
if len(data) < self._max_pkt:
|
||||
break
|
||||
except usb.core.USBError as e:
|
||||
if e.errno == 110:
|
||||
break
|
||||
raise SCPIError(f"读取响应失败: {e}")
|
||||
return _strip_resp_suffix(resp)
|
||||
|
||||
def send_text(self, scpi: str, timeout: int = DEFAULT_TIMEOUT_MS) -> str:
|
||||
"""发送 SCPI 查询命令,返回解码后的文本。"""
|
||||
return self.send(scpi, timeout).decode("ascii", errors="ignore").strip()
|
||||
|
||||
def send_float(self, scpi: str, timeout: int = DEFAULT_TIMEOUT_MS) -> Optional[float]:
|
||||
"""发送 SCPI 查询命令,返回浮点数值。"""
|
||||
text = self.send_text(scpi, timeout)
|
||||
return extract_numeric(text)
|
||||
|
||||
def idn(self) -> str:
|
||||
return self.send_text("*IDN?")
|
||||
@ -0,0 +1,199 @@
|
||||
"""
|
||||
波形数据解析与物理量转换模块。
|
||||
|
||||
负责:
|
||||
- HEAD JSON 解析 → 时基 + 通道参数
|
||||
- 波形数据解析 → 12-bit 有符号 ADC 数组
|
||||
- ADC → 电压转换
|
||||
- 时间轴构建
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import struct
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Optional
|
||||
|
||||
import numpy as np
|
||||
|
||||
from .scpi import (
|
||||
ScpiDevice,
|
||||
parse_scale_str,
|
||||
parse_probe_ratio,
|
||||
SCPIError,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"ChannelParams",
|
||||
"HeadInfo",
|
||||
"fetch_head",
|
||||
"fetch_waveform",
|
||||
"parse_waveform",
|
||||
"adc_to_voltage",
|
||||
"build_time_axis",
|
||||
]
|
||||
|
||||
_SCREEN_DIVS_H = 10
|
||||
_SCREEN_DIVS_V = 8
|
||||
_ADC_MAX = 0x1000 # 12-bit = 4096
|
||||
|
||||
|
||||
@dataclass
|
||||
class ChannelParams:
|
||||
name: str = ""
|
||||
display: bool = True
|
||||
coupling: str = "dc"
|
||||
probe: str = "1x"
|
||||
scale: str = "1v"
|
||||
offset: int = 0
|
||||
inverse: bool = False
|
||||
|
||||
@property
|
||||
def vdiv(self) -> float:
|
||||
return parse_scale_str(self.scale)
|
||||
|
||||
@property
|
||||
def probe_ratio(self) -> float:
|
||||
return parse_probe_ratio(self.probe)
|
||||
|
||||
@property
|
||||
def offset_volts(self) -> float:
|
||||
return self.offset / 100.0 * self.vdiv
|
||||
|
||||
|
||||
def parse_waveform(data: bytes) -> np.ndarray:
|
||||
"""解析 CH<x> 波形数据为 12-bit 有符号 ADC 值。
|
||||
|
||||
兼容两种格式:
|
||||
1) 4 字节 LE 长度前缀 + 2 字节/点 (SCPI DATA 子系统规范)
|
||||
2) 纯 2 字节/点 无前缀 (某些固件版本)
|
||||
|
||||
ADC 值范围: [-2048, 2047]。
|
||||
"""
|
||||
_n = len(data)
|
||||
if _n < 4:
|
||||
raise ValueError(f"数据不足 4 字节 (实际 {_n})")
|
||||
|
||||
payload = data
|
||||
# 尝试格式 1: 有长度前缀
|
||||
hdr_len = struct.unpack("<I", data[:4])[0]
|
||||
if 4 + hdr_len == _n and hdr_len % 2 == 0:
|
||||
payload = data[4:]
|
||||
elif 4 + hdr_len <= _n: # 容许末尾有填零
|
||||
payload = data[4:4 + hdr_len]
|
||||
else:
|
||||
pass # 格式 2: 全部视为载荷
|
||||
|
||||
if len(payload) % 2 != 0:
|
||||
payload = payload[:-1]
|
||||
num_points = len(payload) // 2
|
||||
if num_points == 0:
|
||||
raise ValueError("空载荷")
|
||||
|
||||
raw = np.frombuffer(payload, dtype="<u2", count=num_points) & 0x0FFF
|
||||
signed = np.where(raw >= 0x0800, raw.astype(np.float64) - _ADC_MAX,
|
||||
raw.astype(np.float64))
|
||||
return signed
|
||||
|
||||
|
||||
def adc_to_voltage(adc: np.ndarray, vdiv: float,
|
||||
offset_volts: float = 0.0) -> np.ndarray:
|
||||
"""有符号 12-bit ADC → 电压 (V)。"""
|
||||
return adc * (_SCREEN_DIVS_V * vdiv / _ADC_MAX) - offset_volts
|
||||
|
||||
|
||||
def build_time_axis(num_points: int, tb_scale_sec: float) -> np.ndarray:
|
||||
"""根据数据点数和时基构建时间轴 (s)。"""
|
||||
if num_points <= 0:
|
||||
return np.array([])
|
||||
return np.arange(num_points) * (_SCREEN_DIVS_H * tb_scale_sec / num_points)
|
||||
|
||||
|
||||
# ─── HEAD 解析 ────────────────────────────────────────────────────
|
||||
|
||||
|
||||
def _get_key(obj: dict, *keys: str, default=None):
|
||||
for k in keys:
|
||||
if k in obj:
|
||||
return obj[k]
|
||||
ku = k.upper()
|
||||
if ku in obj:
|
||||
return obj[ku]
|
||||
kl = k.lower()
|
||||
if kl in obj:
|
||||
return obj[kl]
|
||||
return default
|
||||
|
||||
|
||||
@dataclass
|
||||
class HeadInfo:
|
||||
timebase_scale: str = "1.0ms"
|
||||
timebase_hoffset: int = 0
|
||||
samplerate: str = "500ks/s"
|
||||
datalen: int = 1520
|
||||
channels: list[ChannelParams] = field(default_factory=list)
|
||||
runstatus: str = "auto"
|
||||
|
||||
@property
|
||||
def tb_scale_sec(self) -> float:
|
||||
return parse_scale_str(self.timebase_scale)
|
||||
|
||||
def get_channel(self, name: str) -> Optional[ChannelParams]:
|
||||
for ch in self.channels:
|
||||
if ch.name.upper() == name.upper():
|
||||
return ch
|
||||
return None
|
||||
|
||||
|
||||
def fetch_head(dev: ScpiDevice) -> HeadInfo:
|
||||
"""通过 SCPI 获取 HEAD 并解析为 HeadInfo。"""
|
||||
resp = dev.send(":DATA:WAVE:SCREen:HEAD?")
|
||||
if not resp or len(resp) < 4:
|
||||
raise SCPIError("HEAD 响应为空")
|
||||
|
||||
payload_len = struct.unpack("<I", resp[:4])[0]
|
||||
payload = resp[4:]
|
||||
if len(payload) < payload_len:
|
||||
raise SCPIError(f"HEAD 载荷不足: 期望 {payload_len} 字节,实际 {len(payload)}")
|
||||
payload = payload[:payload_len]
|
||||
|
||||
try:
|
||||
raw = json.loads(payload.decode("ascii", errors="ignore").strip())
|
||||
except (json.JSONDecodeError, UnicodeDecodeError) as e:
|
||||
raise SCPIError(f"HEAD JSON 解析失败: {e}")
|
||||
|
||||
tb = _get_key(raw, "timebase", default={})
|
||||
sp = _get_key(raw, "sample", default={})
|
||||
|
||||
channels = []
|
||||
ch_list = _get_key(raw, "channel", default=[])
|
||||
for ch in ch_list:
|
||||
display_raw = _get_key(ch, "display", default="on")
|
||||
inverse_raw = _get_key(ch, "inverse", default="off")
|
||||
channels.append(ChannelParams(
|
||||
name=_get_key(ch, "name", default=""),
|
||||
display=str(display_raw).lower() == "on",
|
||||
coupling=_get_key(ch, "coupling", default="dc"),
|
||||
probe=_get_key(ch, "probe", default="1x"),
|
||||
scale=_get_key(ch, "scale", default="1v"),
|
||||
offset=_get_key(ch, "offset", default=0),
|
||||
inverse=str(inverse_raw).lower() == "on",
|
||||
))
|
||||
|
||||
return HeadInfo(
|
||||
timebase_scale=_get_key(tb, "scale", default="1.0ms"),
|
||||
timebase_hoffset=_get_key(tb, "hoffset", default=0),
|
||||
samplerate=_get_key(sp, "samplerate", default="500ks/s"),
|
||||
datalen=_get_key(sp, "datalen", default=1520),
|
||||
channels=channels,
|
||||
runstatus=_get_key(raw, "runstatus", default="auto"),
|
||||
)
|
||||
|
||||
|
||||
def fetch_waveform(dev: ScpiDevice, channel: int) -> np.ndarray:
|
||||
"""通过 SCPI 获取指定通道波形数据 (ADC 值)。"""
|
||||
resp = dev.send(f":DATA:WAVE:SCREen:CH{channel}?")
|
||||
if not resp:
|
||||
raise SCPIError(f"CH{channel} 响应为空")
|
||||
return parse_waveform(resp)
|
||||
414
backend/tools/survey_osc.py
普通文件
414
backend/tools/survey_osc.py
普通文件
@ -0,0 +1,414 @@
|
||||
#!/usr/bin/env python3
|
||||
"""示波器 SCPI 返回格式调研 — 原生 PyUSB 直接探测"""
|
||||
import hashlib
|
||||
import json
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
import usb.core
|
||||
import usb.util
|
||||
|
||||
VID, PID = 0x5345, 0x1234
|
||||
TIMEOUT = 5000
|
||||
|
||||
# ── 连接 ──
|
||||
dev = usb.core.find(idVendor=VID, idProduct=PID)
|
||||
assert dev, "设备未找到"
|
||||
for cfg in dev:
|
||||
for intf in cfg:
|
||||
ifn = intf.bInterfaceNumber
|
||||
if dev.is_kernel_driver_active(ifn):
|
||||
dev.detach_kernel_driver(ifn)
|
||||
dev.set_configuration()
|
||||
intf = dev.get_active_configuration()[(0, 0)]
|
||||
ep_out = ep_in = None
|
||||
for ep in intf:
|
||||
d = usb.util.endpoint_direction(ep.bEndpointAddress)
|
||||
if d == usb.util.ENDPOINT_OUT: ep_out = ep
|
||||
elif d == usb.util.ENDPOINT_IN: ep_in = ep
|
||||
assert ep_out and ep_in
|
||||
MAXPKT = ep_in.wMaxPacketSize
|
||||
|
||||
def flush():
|
||||
try:
|
||||
while True:
|
||||
dev.read(ep_in, MAXPKT, timeout=50)
|
||||
except usb.core.USBError:
|
||||
pass
|
||||
|
||||
def send(cmd: str, timeout=TIMEOUT) -> bytes:
|
||||
if not cmd.endswith('\n'): cmd += '\n'
|
||||
flush()
|
||||
dev.write(ep_out, cmd.encode('ascii'), timeout=timeout)
|
||||
resp = b''
|
||||
while True:
|
||||
try:
|
||||
data = dev.read(ep_in, MAXPKT, timeout=timeout)
|
||||
if not data: break
|
||||
resp += data.tobytes()
|
||||
if len(data) < MAXPKT: break
|
||||
except usb.core.USBError as e:
|
||||
if e.errno == 110: break
|
||||
raise
|
||||
return resp
|
||||
|
||||
def hex_dump(data: bytes, max_len: int = 128):
|
||||
"""前 max_len 字节的 hex dump"""
|
||||
show = data[:max_len]
|
||||
lines = []
|
||||
for i in range(0, len(show), 16):
|
||||
chunk = show[i:i+16]
|
||||
hex_str = ' '.join(f'{b:02x}' for b in chunk)
|
||||
ascii_str = ''.join(chr(b) if 32 <= b < 127 else '.' for b in chunk)
|
||||
lines.append(f' {i:04x}: {hex_str:<48s} {ascii_str}')
|
||||
if len(data) > max_len:
|
||||
lines.append(f' ... (共 {len(data)} 字节,仅显示前 {max_len})')
|
||||
return '\n'.join(lines)
|
||||
|
||||
def section(title: str):
|
||||
print(f"\n{'='*70}")
|
||||
print(f" {title}")
|
||||
print(f"{'='*70}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 1. *IDN?
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("1. *IDN? — 设备身份")
|
||||
resp = send('*IDN?')
|
||||
print(f" 原始字节长度: {len(resp)}")
|
||||
print(f" 原始 (hex): {resp.hex()}")
|
||||
print(f" 解码: {resp.decode('ascii', 'ignore').strip()!r}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 2. HEAD 完整原始
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("2. :DATA:WAVE:SCREen:HEAD? — 波形文件头")
|
||||
resp = send(':DATA:WAVE:SCREen:HEAD?')
|
||||
print(f" 原始字节总长度: {len(resp)}")
|
||||
print(f" 前 60 字节 hex dump:")
|
||||
print(hex_dump(resp, 60))
|
||||
|
||||
# 解析前 4 字节
|
||||
if len(resp) >= 4:
|
||||
declared_len = struct.unpack('<I', resp[:4])[0]
|
||||
payload = resp[4:]
|
||||
print(f"\n 前 4 字节 (LE uint32) = {declared_len}")
|
||||
print(f" 载荷实际长度 = {len(payload)}")
|
||||
print(f" 长度匹配: {'YES' if declared_len == len(payload) else 'NO (差异: ' + str(len(payload) - declared_len) + ')'}")
|
||||
try:
|
||||
text = payload.decode('ascii', errors='replace')
|
||||
print(f"\n 载荷 (解码后):")
|
||||
print(f" {text[:500]}")
|
||||
# 尝试 JSON 解析
|
||||
try:
|
||||
parsed = json.loads(text.strip())
|
||||
print(f"\n JSON 解析成功。顶层 key: {list(parsed.keys())}")
|
||||
ch_list = parsed.get('CHANNEL', [])
|
||||
print(f" CHANNEL 数量: {len(ch_list)}")
|
||||
for ch in ch_list:
|
||||
print(f" {ch.get('NAME')}: SCALE={ch.get('SCALE')}, OFFSET={ch.get('OFFSET')}, "
|
||||
f"PROBE={ch.get('PROBE')}, COUPLING={ch.get('COUPLING')}, "
|
||||
f"DISPLAY={ch.get('DISPLAY')}")
|
||||
except json.JSONDecodeError as e:
|
||||
print(f" JSON 解析失败: {e}")
|
||||
# 尝试找 JSON 边界
|
||||
i = text.find('{')
|
||||
j = text.rfind('}')
|
||||
if i >= 0 and j > i:
|
||||
print(f" 尝试截取 [{i}:{j+1}] 后解析:")
|
||||
try:
|
||||
parsed = json.loads(text[i:j+1])
|
||||
print(f" 截取后 JSON 解析成功: {json.dumps(parsed, indent=2, ensure_ascii=False)[:500]}")
|
||||
except:
|
||||
print(" 截取后仍失败")
|
||||
except Exception as e:
|
||||
print(f" 解码失败: {e}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 3. CH2 波形数据
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("3. :DATA:WAVE:SCREen:CH2? — CH2 波形数据")
|
||||
resp = send(':DATA:WAVE:SCREen:CH2?')
|
||||
print(f" 原始字节总长度: {len(resp)}")
|
||||
print(f" 前 32 字节 hex dump:")
|
||||
print(hex_dump(resp, 32))
|
||||
|
||||
if len(resp) >= 4:
|
||||
declared_len = struct.unpack('<I', resp[:4])[0]
|
||||
payload = resp[4:]
|
||||
print(f"\n 前 4 字节 (LE uint32) = {declared_len}")
|
||||
print(f" 载荷实际长度 = {len(payload)}")
|
||||
|
||||
# 检查无前缀格式 (直接 12-bit 数据)
|
||||
usable = len(resp) if len(resp) % 2 == 0 else len(resp) - 1
|
||||
raw_noprefix = struct.unpack(f'<{usable//2}H', resp[:usable])
|
||||
raw_noprefix = [v & 0x0FFF for v in raw_noprefix]
|
||||
print(f"\n [无前缀格式] 总共 {usable//2} 个点 (12-bit)")
|
||||
print(f" 前 10 个 ADC 值: {raw_noprefix[:10]}")
|
||||
print(f" 后 10 个 ADC 值: {raw_noprefix[-10:]}")
|
||||
print(f" ADC 范围: [{min(raw_noprefix)}, {max(raw_noprefix)}]")
|
||||
|
||||
if declared_len == len(payload):
|
||||
print(f" [有前缀格式] 载荷 {declared_len} bytes, {declared_len//2} 个点")
|
||||
raw_prefixed = struct.unpack(f'<{len(payload)//2}H', payload)
|
||||
raw_prefixed = [v & 0x0FFF for v in raw_prefixed]
|
||||
print(f" 前 10 个 ADC 值: {raw_prefixed[:10]}")
|
||||
print(f" 后 10 个 ADC 值: {raw_prefixed[-10:]}")
|
||||
print(f" ADC 范围: [{min(raw_prefixed)}, {max(raw_prefixed)}]")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 4. 各种 MEASUrement 查询
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("4. :MEASUrement 查询 (CH2)")
|
||||
|
||||
items = [
|
||||
("MAX", "最大值"),
|
||||
("MIN", "最小值"),
|
||||
("PKPK", "峰峰值"),
|
||||
("VTOP", "顶端值"),
|
||||
("VBASe", "底端值"),
|
||||
("VAMP", "幅度"),
|
||||
("AVERage", "平均值"),
|
||||
("SQUAresum", "均方根值"),
|
||||
("CYCRms", "周期均方根"),
|
||||
("PERiod", "周期"),
|
||||
("FREQuency", "频率"),
|
||||
("RTime", "上升时间"),
|
||||
("FTime", "下降时间"),
|
||||
]
|
||||
|
||||
for item, desc in items:
|
||||
resp = send(f':MEASUrement:CH2:{item}?')
|
||||
text = resp.decode('ascii', 'ignore').strip() if resp else "(无响应)"
|
||||
print(f" CH2:{item:<12s} → {text!r} ({desc})")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 5. :MEASUrement:CH2? — 全部测量项 (JSON)
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("5. :MEASUrement:CH2? — CH2 全部测量项 (JSON)")
|
||||
resp = send(':MEASUrement:CH2?')
|
||||
print(f" 原始字节长度: {len(resp)}")
|
||||
text = resp.decode('ascii', 'ignore') if resp else "(无响应)"
|
||||
# 可能含 4 字节前缀
|
||||
if len(resp) >= 4:
|
||||
pre_len = struct.unpack('<I', resp[:4])[0]
|
||||
if pre_len + 4 == len(resp):
|
||||
print(f" → 检测到 4 字节长度前缀: 声明 {pre_len}, 实际载荷 {len(resp)-4}")
|
||||
text = resp[4:].decode('ascii', 'ignore')
|
||||
else:
|
||||
print(f" → 前 4 字节 = {pre_len}, 总长 = {len(resp)}, 不匹配前缀格式")
|
||||
|
||||
print(f"\n 原始文本:")
|
||||
print(f" {text[:800]}")
|
||||
|
||||
try:
|
||||
parsed = json.loads(text.strip())
|
||||
print(f"\n JSON 解析成功! Keys: {list(parsed.keys())}")
|
||||
for k, v in parsed.items():
|
||||
print(f" {k}: {v}")
|
||||
except json.JSONDecodeError:
|
||||
print(f"\n JSON 解析失败,尝试找 {...}")
|
||||
# 尝试只提取 JSON 部分
|
||||
i = text.find('{')
|
||||
j = text.rfind('}')
|
||||
if i >= 0 and j > i:
|
||||
try:
|
||||
sub = text[i:j+1]
|
||||
parsed = json.loads(sub)
|
||||
print(f" 截取 JSON 成功! [{i}:{j+1}] Keys: {list(parsed.keys())}")
|
||||
for k, v in parsed.items():
|
||||
print(f" {k}: {v}")
|
||||
except Exception as e:
|
||||
print(f" 截取 JSON 也失败: {e}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 6. 运行状态查询
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("6. 运行状态 & 其他查询")
|
||||
for cmd in [':RUNning?', ':TRIGger:STATUS?', ':TRIGger:TYPE?',
|
||||
':ACQuire:MODE?', ':ACQuire:DEPMEM?',
|
||||
':HORIZONTAL:SCALe?', ':CH2:SCALe?', ':CH2:PROBe?',
|
||||
':CH2:COUPling?', ':CH2:OFFSET?']:
|
||||
resp = send(cmd)
|
||||
text = resp.decode('ascii', 'ignore').strip() if resp else "(无响应)"
|
||||
print(f" {cmd:<30s} → {text!r}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 7. BMP 大小检查
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("7. :DATA:WAVE:SCREen:BMP? — BMP 大小")
|
||||
resp = send(':DATA:WAVE:SCREen:BMP?', timeout=15000)
|
||||
print(f" 原始字节总长度: {len(resp)}")
|
||||
if len(resp) >= 4:
|
||||
declared = struct.unpack('<I', resp[:4])[0]
|
||||
print(f" 声明 BMP 大小: {declared} ({declared/1024:.1f} KB)")
|
||||
if len(resp) - 4 == declared:
|
||||
print(f" ✓ 长度匹配")
|
||||
# BMP 头检查
|
||||
bmp = resp[4:]
|
||||
if bmp[:2] == b'BM':
|
||||
bmp_size = struct.unpack('<I', bmp[2:6])[0]
|
||||
print(f" BMP 内部声明大小: {bmp_size}")
|
||||
width = struct.unpack('<i', bmp[18:22])[0]
|
||||
height = struct.unpack('<i', bmp[22:26])[0]
|
||||
print(f" 分辨率: {width} x {height}")
|
||||
else:
|
||||
print(f" ✗ 长度不匹配: +{len(resp)-4} vs {declared}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 8. :DATA:WAVE:DEPMem:All? — 深存储
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("8. :DATA:WAVE:DEPMem:All? — 深存储 (超时可能较长)")
|
||||
resp = send(':DATA:WAVE:DEPMem:All?', timeout=30000)
|
||||
print(f" 原始字节总长度: {len(resp)}")
|
||||
if len(resp) >= 4:
|
||||
declared = struct.unpack('<I', resp[:4])[0]
|
||||
print(f" 声明大小: {declared} ({declared/1024:.1f} KB)")
|
||||
print(f" 实际载荷: {len(resp)-4}, 匹配: {declared == len(resp)-4}")
|
||||
print(f" 原始 hex (前 80): {resp[:80].hex()}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 9. CH1 波形数据对比
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("9. :DATA:WAVE:SCREen:CH1? — CH1 波形 (对比)")
|
||||
resp = send(':DATA:WAVE:SCREen:CH1?')
|
||||
print(f" 原始字节总长度: {len(resp)}")
|
||||
if len(resp) >= 4:
|
||||
declared = struct.unpack('<I', resp[:4])[0]
|
||||
print(f" 前缀声明: {declared}, 载荷: {len(resp)-4}, 匹配: {declared == len(resp)-4}")
|
||||
payload = resp[4:]
|
||||
if len(payload) >= 6:
|
||||
raw = struct.unpack(f'<{len(payload)//2}H', payload)
|
||||
raw = [v & 0x0FFF for v in raw]
|
||||
print(f" 点数: {len(raw)}, ADC 范围: [{min(raw)}, {max(raw)}]")
|
||||
print(f" 前 10: {raw[:10]}")
|
||||
print(f" 后 10: {raw[-10:]}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 10. CH1 各项测量值
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("10. :MEASUrement:CH1 各项")
|
||||
for item, desc in items[:8]: # 只测第一部分
|
||||
resp = send(f':MEASUrement:CH1:{item}?')
|
||||
text = resp.decode('ascii', 'ignore').strip() if resp else "(无响应)"
|
||||
print(f" CH1:{item:<12s} → {text!r}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 11. :MEASUrement:ALL? — 两通道全部测量
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("11. :MEASUrement:ALL? — 全部通道测量")
|
||||
resp = send(':MEASUrement:ALL?')
|
||||
print(f" 原始字节长度: {len(resp)}")
|
||||
if len(resp) >= 4:
|
||||
pre_len = struct.unpack('<I', resp[:4])[0]
|
||||
if pre_len + 4 <= len(resp):
|
||||
payload = resp[4:4+pre_len]
|
||||
text = payload.decode('ascii', 'replace')
|
||||
print(f" 载荷 ({len(payload)} bytes):")
|
||||
print(f" {text[:1000]}")
|
||||
else:
|
||||
print(f" 前缀声明 {pre_len} > 数据长 {len(resp)-4}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 12. 连续读取 CH2 数据 5 次,看 md5 是否变化
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("12. 连续读取 CH2 × 5 — 验证数据刷新")
|
||||
prev = None
|
||||
for i in range(5):
|
||||
resp = send(':DATA:WAVE:SCREen:CH2?')
|
||||
h = hashlib.md5(resp).hexdigest()[:8] if resp else "None"
|
||||
changed = ""
|
||||
if prev is not None:
|
||||
changed = "★ 变化" if h != prev else " (不变)"
|
||||
print(f" [{i+1}] {len(resp)}B md5={h} {changed}")
|
||||
prev = h
|
||||
if i < 4:
|
||||
time.sleep(0.05)
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 13. 测试 :RUNning RUN 后是否刷新数据
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("13. :RUNning RUN 后刷新测试")
|
||||
base = send(':DATA:WAVE:SCREen:CH2?')
|
||||
base_md5 = hashlib.md5(base).hexdigest()[:8] if base else "None"
|
||||
print(f" 基准: {len(base)}B md5={base_md5}")
|
||||
for i in range(3):
|
||||
send(':RUNning STOP')
|
||||
time.sleep(0.2)
|
||||
send(':RUNning RUN')
|
||||
time.sleep(0.5)
|
||||
resp = send(':DATA:WAVE:SCREen:CH2?')
|
||||
h = hashlib.md5(resp).hexdigest()[:8] if resp else "None"
|
||||
changed = "★ 变化" if h != base_md5 else " (不变)"
|
||||
print(f" STOP+RUN [{i+1}]: {len(resp)}B md5={h} {changed}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 14. 强制单次触发后读波形数据
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("14. :TRIGger:SINGLE 强制触发后读波形")
|
||||
print(" 先 STOP,再 SINGLE,然后读数据...")
|
||||
send(':RUNning STOP')
|
||||
time.sleep(0.3)
|
||||
|
||||
for i in range(5):
|
||||
send(':TRIGger:SINGLE')
|
||||
time.sleep(1.5) # 等待触发完成 (时基 10us * 10div = 100us, 但实际需要采集+传输)
|
||||
# 检查触发状态
|
||||
status = send(':TRIGger:STATUS?')
|
||||
resp = send(':DATA:WAVE:SCREen:CH2?')
|
||||
h = hashlib.md5(resp).hexdigest()[:8] if resp else "None"
|
||||
status_text = status.decode('ascii','ignore').strip() if status else "?"
|
||||
print(f" [{i+1}] 状态={status_text} {len(resp)}B md5={h}")
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 15. RUN 模式下读 CH2 + 同时读测量值看是否同步变化
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("15. RUN 模式下对比测量值和波形 md5")
|
||||
send(':RUNning RUN')
|
||||
time.sleep(0.5)
|
||||
prev_wave_md5 = None
|
||||
for i in range(5):
|
||||
wave = send(':DATA:WAVE:SCREen:CH2?')
|
||||
pkpk = send(':MEASUrement:CH2:PKPK?')
|
||||
wave_md5 = hashlib.md5(wave).hexdigest()[:8] if wave else "None"
|
||||
pkpk_text = pkpk.decode('ascii','ignore').strip() if pkpk else "?"
|
||||
wave_changed = ""
|
||||
if prev_wave_md5 is not None:
|
||||
wave_changed = "★波形变化" if wave_md5 != prev_wave_md5 else ""
|
||||
print(f" [{i+1}] PKPK={pkpk_text} 波形 md5={wave_md5} {wave_changed}")
|
||||
prev_wave_md5 = wave_md5
|
||||
time.sleep(0.5)
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
# 16. 测试 :MEASUrement:CH2? JSON 净化解析
|
||||
# ═══════════════════════════════════════════════════════════════════
|
||||
section("16. :MEASUrement:CH2? JSON 净化后解析")
|
||||
resp = send(':MEASUrement:CH2?')
|
||||
if len(resp) >= 4:
|
||||
pre_len = struct.unpack('<I', resp[:4])[0]
|
||||
if pre_len + 4 <= len(resp):
|
||||
raw_text = resp[4:4+pre_len].decode('ascii', errors='replace')
|
||||
# 替换 tab 字符
|
||||
clean = raw_text.replace('\t', '')
|
||||
print(f" 净化后文本前 300 字符:")
|
||||
print(f" {clean[:300]}")
|
||||
try:
|
||||
parsed = json.loads(clean)
|
||||
ch2 = parsed.get("CH2", {})
|
||||
print(f"\n 解析成功! 有效值:")
|
||||
for k, v in ch2.items():
|
||||
v_clean = v.rstrip('?').rstrip(',').rstrip(',OFF').rstrip(',ON')
|
||||
if v_clean and v_clean != '' and v_clean != ' ':
|
||||
print(f" {k}: {v} → clean={v_clean}")
|
||||
except json.JSONDecodeError as e:
|
||||
print(f" 净化后仍失败: {e}")
|
||||
# 尝试更激进净化
|
||||
clean2 = ''.join(c for c in raw_text if c.isprintable() or c in '{}":,.[]')
|
||||
try:
|
||||
parsed = json.loads(clean2)
|
||||
print(f" 激进净化后解析成功!")
|
||||
except:
|
||||
print(f" 激进净化也失败")
|
||||
|
||||
section("调研完成")
|
||||
usb.util.dispose_resources(dev)
|
||||
1059
backend/uv.lock
自动生成的
1059
backend/uv.lock
自动生成的
文件差异内容过多而无法显示
加载差异
在新工单中引用
屏蔽一个用户