feat: 加入了一系列调试和分析工具,包括 SCPI REPL、示波器数据查看器、声速检测器等,方便开发和实验调试。

fix: 修复实验页面中实验状态未正确更新的问题,确保实验状态在前端和后端之间保持一致。
docs: 添加了SCPI文档和总程序设计架构
这个提交包含在:
2026-06-25 18:29:31 +08:00
父节点 61b20ca200
当前提交 c742cc7070
共有 24 个文件被更改,包括 9263 次插入 和 5 次删除

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()

查看文件

@ -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 普通文件
查看文件

@ -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)

查看文件

@ -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

查看文件

@ -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 普通文件
查看文件

@ -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 普通文件
查看文件

@ -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)