cart_firmware_added
This commit is contained in:
Ayzen
@@ -0,0 +1,34 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Analyze a captured frame: extract pulse timing structure.
|
||||
|
||||
Usage: .venv/bin/python tools/analyze.py captures/<name>.npz
|
||||
"""
|
||||
import sys
|
||||
|
||||
import numpy as np
|
||||
|
||||
path = sys.argv[1]
|
||||
d = np.load(path)
|
||||
volts = d["volts"]
|
||||
srate = float(d["srate"])
|
||||
dt_us = 1e6 / srate
|
||||
|
||||
# threshold midway between the two dominant plateaus
|
||||
hi_level = np.median(volts) # idle dominates the frame -> median = idle (high)
|
||||
lo_level = np.percentile(volts, 10)
|
||||
thr = (hi_level + lo_level) / 2
|
||||
bits = (volts > thr).astype(np.int8)
|
||||
print(f"levels: high~{hi_level:.2f} low~{lo_level:.2f} thr={thr:.2f} (raw units)")
|
||||
|
||||
# run-length encode
|
||||
edges = np.flatnonzero(np.diff(bits)) + 1
|
||||
starts = np.concatenate(([0], edges))
|
||||
ends = np.concatenate((edges, [len(bits)]))
|
||||
levels = bits[starts]
|
||||
dur_us = (ends - starts) * dt_us
|
||||
|
||||
print(f"{len(levels)} runs total")
|
||||
print("\nidx level dur_us (first/last runs are idle padding)")
|
||||
for i, (lv, du) in enumerate(zip(levels, dur_us)):
|
||||
tag = "H" if lv else "L"
|
||||
print(f"{i:4d} {tag} {du:10.2f}")
|
||||
@@ -0,0 +1,116 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Capture one single-shot CH3 frame from Hantek DPO7204C, save raw + PNG.
|
||||
|
||||
Flow: query settings -> :SINGle -> poll :TRIGger:STATus? until STOP ->
|
||||
WAVeform:DATA:ALL? CHANnel3 (drained completely, multi-packet aware).
|
||||
Scope is left in STOP so the on-screen frame matches the saved data.
|
||||
|
||||
Usage: .venv/bin/python tools/capture.py <name> [device]
|
||||
Saves captures/<name>.bin, captures/<name>.npz, captures/<name>.png
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
|
||||
DEV = sys.argv[2] if len(sys.argv) > 2 else "/dev/usbtmc2"
|
||||
NAME = sys.argv[1] if len(sys.argv) > 1 else "capture"
|
||||
OUTDIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "captures")
|
||||
os.makedirs(OUTDIR, exist_ok=True)
|
||||
|
||||
FIRST_HDR = 11 + 117 # '#9'+9-digit len, then 18 bytes counters + 99 bytes info
|
||||
NEXT_HDR = 11 + 18 # follow-up packets: counters only
|
||||
|
||||
|
||||
def read_exact(fd, n):
|
||||
buf = b""
|
||||
while len(buf) < n:
|
||||
chunk = os.read(fd, min(1 << 20, n - len(buf)))
|
||||
if not chunk:
|
||||
raise IOError("short read from scope")
|
||||
buf += chunk
|
||||
return buf
|
||||
|
||||
|
||||
def read_packet(fd):
|
||||
head = read_exact(fd, 11)
|
||||
assert head[:2] == b"#9", f"bad packet start: {head!r}"
|
||||
pkt_len = int(head[2:11])
|
||||
body = read_exact(fd, pkt_len)
|
||||
return head + body
|
||||
|
||||
|
||||
def query(fd, cmd):
|
||||
os.write(fd, cmd.encode() + b"\n")
|
||||
return os.read(fd, 256).decode(errors="replace").strip()
|
||||
|
||||
|
||||
fd = os.open(DEV, os.O_RDWR)
|
||||
print("IDN:", query(fd, "*IDN?"))
|
||||
|
||||
tdiv = float(query(fd, ":TIMebase:SCALe?"))
|
||||
vdiv = float(query(fd, ":CHANnel3:SCALe?"))
|
||||
voff = float(query(fd, ":CHANnel3:OFFSet?"))
|
||||
print(f"tdiv={tdiv} s/div vdiv={vdiv} V/div offset={voff} V")
|
||||
|
||||
os.write(fd, b":SINGle\n")
|
||||
for _ in range(100):
|
||||
time.sleep(0.1)
|
||||
st = query(fd, ":TRIGger:STATus?")
|
||||
if st == "STOP":
|
||||
break
|
||||
else:
|
||||
sys.exit(f"scope did not reach STOP (last status: {st})")
|
||||
print("status: STOP (frame captured)")
|
||||
|
||||
srate = float(query(fd, ":ACQuire:SRATe?"))
|
||||
print(f"srate={srate:.3e} Sa/s")
|
||||
|
||||
os.write(fd, b"WAVeform:DATA:ALL? CHANnel3\n")
|
||||
pkt = read_packet(fd)
|
||||
total_len = int(pkt[11:20])
|
||||
info_hdr = pkt[29:FIRST_HDR]
|
||||
data = pkt[FIRST_HDR:]
|
||||
raw_all = pkt
|
||||
while len(data) < total_len:
|
||||
os.write(fd, b"WAVeform:DATA:ALL? CHANnel3\n")
|
||||
p = read_packet(fd)
|
||||
raw_all += p
|
||||
data += p[NEXT_HDR:]
|
||||
print(f"received {len(data)} samples (declared {total_len})")
|
||||
print("info header hex:", info_hdr.hex(" "))
|
||||
os.close(fd)
|
||||
|
||||
raw = np.frombuffer(data[:total_len], dtype=np.uint8).astype(np.float32)
|
||||
# unsigned 8-bit, 25.6 levels/div, mid-screen = code 128, offset shifts zero
|
||||
volts = (raw - 128.0) / 25.6 * vdiv - voff
|
||||
t = np.arange(len(volts)) / srate * 1e3 # ms
|
||||
|
||||
base = os.path.join(OUTDIR, NAME)
|
||||
with open(base + ".bin", "wb") as f:
|
||||
f.write(raw_all)
|
||||
np.savez(base + ".npz", volts=volts, srate=srate, vdiv=vdiv, voff=voff, tdiv=tdiv)
|
||||
|
||||
fig, axes = plt.subplots(2, 1, figsize=(16, 8))
|
||||
axes[0].plot(t, volts, lw=0.5)
|
||||
axes[0].set_title(f"{NAME} — full frame ({srate:.0e} Sa/s, {vdiv} V/div, off {voff} V)")
|
||||
# zoom on activity: region where signal deviates from its median
|
||||
dev_idx = np.where(np.abs(volts - np.median(volts)) > 0.5)[0]
|
||||
if len(dev_idx):
|
||||
lo = max(0, dev_idx[0] - int(0.05 * (dev_idx[-1] - dev_idx[0] + 1)) - 100)
|
||||
hi = min(len(volts), dev_idx[-1] + int(0.05 * (dev_idx[-1] - dev_idx[0] + 1)) + 100)
|
||||
axes[1].plot(t[lo:hi], volts[lo:hi], lw=0.7)
|
||||
axes[1].set_title("zoom on activity")
|
||||
for ax in axes:
|
||||
ax.set_xlabel("t, ms")
|
||||
ax.set_ylabel("U, V")
|
||||
ax.grid(True, alpha=0.3)
|
||||
fig.tight_layout()
|
||||
fig.savefig(base + ".png", dpi=110)
|
||||
print("saved:", base + ".png")
|
||||
print(f"range: min={volts.min():.3f} V max={volts.max():.3f} V median={np.median(volts):.3f} V")
|
||||
@@ -0,0 +1,91 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Rigorous comparison of two SBUS captures (old remote vs our firmware).
|
||||
|
||||
Usage: .venv/bin/python tools/compare.py captures/a.npz captures/b.npz
|
||||
"""
|
||||
import sys
|
||||
|
||||
import numpy as np
|
||||
|
||||
|
||||
def extract(path):
|
||||
d = np.load(path)
|
||||
v = d["volts"]
|
||||
srate = float(d["srate"])
|
||||
idle = np.median(v)
|
||||
p10, p90 = np.percentile(v, [10, 90])
|
||||
active = p10 if abs(p10 - idle) > abs(p90 - idle) else p90
|
||||
thr = (idle + active) / 2
|
||||
phys_hi = v > thr # physical high (pulse)
|
||||
# plateau levels: median of samples well inside each state
|
||||
lvl_hi = np.median(v[phys_hi])
|
||||
lvl_lo = np.median(v[~phys_hi])
|
||||
# runs
|
||||
sig = phys_hi.astype(np.int8)
|
||||
edges = np.flatnonzero(np.diff(sig)) + 1
|
||||
starts = np.concatenate(([0], edges))
|
||||
ends = np.concatenate((edges, [len(sig)]))
|
||||
levels = sig[starts]
|
||||
dur_us = (ends - starts) * 1e6 / srate
|
||||
# burst envelope: first to last physical-high sample
|
||||
hi_idx = np.flatnonzero(phys_hi)
|
||||
envelope_us = (hi_idx[-1] - hi_idx[0] + 1) * 1e6 / srate
|
||||
# inner runs (drop leading/trailing idle)
|
||||
runs = [(int(l), float(du)) for l, du in zip(levels[1:-1], dur_us[1:-1])]
|
||||
# UART logic: logic1 == idle state; idle here is physical low
|
||||
stream = []
|
||||
for l, du in runs:
|
||||
n = max(1, round(du / 10.0))
|
||||
stream.extend([1 - l] * n) # physical high -> logic 0
|
||||
stream.extend([1] * 24)
|
||||
frames = []
|
||||
i = 0
|
||||
while i + 12 <= len(stream):
|
||||
if stream[i] == 1:
|
||||
i += 1
|
||||
continue
|
||||
byte = sum(b << k for k, b in enumerate(stream[i + 1 : i + 9]))
|
||||
frames.append(byte)
|
||||
i += 12
|
||||
# bit clock estimate: envelope should be 299 bits (last stop bits merge w/ idle)
|
||||
n_units = round(envelope_us / 10.0)
|
||||
bit_us = envelope_us / n_units
|
||||
return {
|
||||
"lvl_hi": lvl_hi,
|
||||
"lvl_lo": lvl_lo,
|
||||
"runs": runs,
|
||||
"frames": frames,
|
||||
"envelope_us": envelope_us,
|
||||
"bit_us": bit_us,
|
||||
"vmin": float(v.min()),
|
||||
"vmax": float(v.max()),
|
||||
}
|
||||
|
||||
|
||||
a_path, b_path = sys.argv[1], sys.argv[2]
|
||||
A, B = extract(a_path), extract(b_path)
|
||||
|
||||
print(f"{'':24s} {'A: ' + a_path:>28s} {'B: ' + b_path:>28s}")
|
||||
print(f"{'bytes decoded':24s} {len(A['frames']):>28d} {len(B['frames']):>28d}")
|
||||
ha = " ".join(f"{x:02X}" for x in A["frames"])
|
||||
hb = " ".join(f"{x:02X}" for x in B["frames"])
|
||||
print(f"frames identical: {A['frames'] == B['frames']}")
|
||||
print(" A:", ha)
|
||||
print(" B:", hb)
|
||||
print(f"{'run count':24s} {len(A['runs']):>28d} {len(B['runs']):>28d}")
|
||||
qa = [round(du / 10) for _, du in A["runs"]]
|
||||
qb = [round(du / 10) for _, du in B["runs"]]
|
||||
la = [l for l, _ in A["runs"]]
|
||||
lb = [l for l, _ in B["runs"]]
|
||||
print(f"quantized run pattern identical: {qa == qb and la == lb}")
|
||||
print(f"{'envelope, us':24s} {A['envelope_us']:>28.2f} {B['envelope_us']:>28.2f}")
|
||||
print(f"{'bit time, us':24s} {A['bit_us']:>28.4f} {B['bit_us']:>28.4f}")
|
||||
print(f"{'-> baud':24s} {1e6/A['bit_us']:>28.1f} {1e6/B['bit_us']:>28.1f}")
|
||||
print(f"{'high plateau, V':24s} {A['lvl_hi']:>28.3f} {B['lvl_hi']:>28.3f}")
|
||||
print(f"{'low plateau, V':24s} {A['lvl_lo']:>28.3f} {B['lvl_lo']:>28.3f}")
|
||||
print(f"{'abs min/max, V':24s} {A['vmin']:>14.2f}/{A['vmax']:>12.2f} {B['vmin']:>14.2f}/{B['vmax']:>12.2f}")
|
||||
|
||||
# worst run deviation from ideal 10us grid
|
||||
da = max(abs(du - 10 * round(du / 10)) for _, du in A["runs"])
|
||||
db = max(abs(du - 10 * round(du / 10)) for _, du in B["runs"])
|
||||
print(f"{'worst grid dev, us':24s} {da:>28.2f} {db:>28.2f}")
|
||||
@@ -0,0 +1,76 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Decode a captured frame as SBUS: UART 100 kbit/s 8E2, 25-byte frame,
|
||||
16 channels x 11 bits.
|
||||
|
||||
Usage: .venv/bin/python tools/decode.py captures/<name>.npz
|
||||
"""
|
||||
import sys
|
||||
|
||||
import numpy as np
|
||||
|
||||
BIT_US = 10.0
|
||||
|
||||
path = sys.argv[1]
|
||||
d = np.load(path)
|
||||
volts = d["volts"]
|
||||
srate = float(d["srate"])
|
||||
dt_us = 1e6 / srate
|
||||
|
||||
# idle level dominates the record; UART logic 1 == idle regardless of
|
||||
# physical polarity (this line is standard inverted SBUS: idle low)
|
||||
idle = np.median(volts)
|
||||
p10, p90 = np.percentile(volts, [10, 90])
|
||||
active = p10 if abs(p10 - idle) > abs(p90 - idle) else p90
|
||||
thr = (idle + active) / 2
|
||||
if active > idle:
|
||||
sig = (volts < thr).astype(np.int8) # pulses up -> logic 0
|
||||
else:
|
||||
sig = (volts > thr).astype(np.int8)
|
||||
|
||||
edges = np.flatnonzero(np.diff(sig)) + 1
|
||||
starts = np.concatenate(([0], edges))
|
||||
ends = np.concatenate((edges, [len(sig)]))
|
||||
levels = sig[starts]
|
||||
dur_us = (ends - starts) * dt_us
|
||||
|
||||
stream = []
|
||||
for lv, du in zip(levels[1:-1], dur_us[1:-1]):
|
||||
stream.extend([int(lv)] * max(1, round(du / BIT_US)))
|
||||
# trailing idle of last stop bits is trimmed by run cut; pad with idle-high
|
||||
stream.extend([1] * 24)
|
||||
|
||||
# deframe 8E2: start=0, 8 data LSB-first, even parity, 2 stop=1
|
||||
i = 0
|
||||
frames = []
|
||||
errors = []
|
||||
while i + 12 <= len(stream):
|
||||
if stream[i] == 1:
|
||||
i += 1
|
||||
continue
|
||||
data = stream[i + 1 : i + 9]
|
||||
par = stream[i + 9]
|
||||
stops = stream[i + 10 : i + 12]
|
||||
byte = sum(b << k for k, b in enumerate(data))
|
||||
if par != (sum(data) & 1):
|
||||
errors.append((len(frames), "parity"))
|
||||
if stops != [1, 1]:
|
||||
errors.append((len(frames), f"stop={stops}"))
|
||||
frames.append(byte)
|
||||
i += 12
|
||||
|
||||
print(f"decoded {len(frames)} bytes, errors: {errors if errors else 'none'}")
|
||||
print("hex:", " ".join(f"{b:02X}" for b in frames))
|
||||
|
||||
if len(frames) >= 25 and frames[0] == 0x0F:
|
||||
payload = frames[1:23]
|
||||
flags = frames[23]
|
||||
footer = frames[24]
|
||||
bits = 0
|
||||
for k, b in enumerate(payload):
|
||||
bits |= b << (8 * k)
|
||||
ch = [(bits >> (11 * n)) & 0x7FF for n in range(16)]
|
||||
print("\nSBUS frame OK" if footer == 0x00 else f"\nfooter unexpected: {footer:02X}")
|
||||
print("channels:", ch)
|
||||
print(f"flags: 0x{flags:02X} (bit0=ch17 bit1=ch18 bit2=frame_lost bit3=failsafe)")
|
||||
else:
|
||||
print("not a valid SBUS frame (no 0x0F header)")
|
||||
@@ -0,0 +1,51 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Minimal SCPI helper for Hantek DPO7204C over /dev/usbtmc2."""
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
|
||||
DEV = "/dev/usbtmc2"
|
||||
|
||||
|
||||
class Scope:
|
||||
def __init__(self, dev=DEV):
|
||||
self.fd = os.open(dev, os.O_RDWR)
|
||||
|
||||
def write(self, cmd: str):
|
||||
os.write(self.fd, cmd.encode() + b"\n")
|
||||
|
||||
def read(self, n=1 << 20, timeout=3.0) -> bytes:
|
||||
# usbtmc read returns one transfer chunk; loop until short read
|
||||
chunks = []
|
||||
end = time.time() + timeout
|
||||
while time.time() < end:
|
||||
try:
|
||||
data = os.read(self.fd, n)
|
||||
except OSError:
|
||||
break
|
||||
chunks.append(data)
|
||||
if not data or len(data) < n:
|
||||
break
|
||||
return b"".join(chunks)
|
||||
|
||||
def query(self, cmd: str, timeout=3.0) -> str:
|
||||
self.write(cmd)
|
||||
return self.read(timeout=timeout).decode(errors="replace").strip()
|
||||
|
||||
def query_raw(self, cmd: str, timeout=5.0) -> bytes:
|
||||
self.write(cmd)
|
||||
return self.read(timeout=timeout)
|
||||
|
||||
def close(self):
|
||||
os.close(self.fd)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
s = Scope()
|
||||
for cmd in sys.argv[1:]:
|
||||
if cmd.endswith("?"):
|
||||
print(f"{cmd:40s} -> {s.query(cmd)}")
|
||||
else:
|
||||
s.write(cmd)
|
||||
print(f"{cmd:40s} [sent]")
|
||||
s.close()
|
||||
Reference in New Issue
Block a user