344 lines
11 KiB
Python
344 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""
|
||
ble_log_pull.py — 通过 BLE 拉取 K1 设备现场日志分区 (LOG.BIN)
|
||
|
||
协议 (SysEx, App->设备 F0 60 ... F7):
|
||
07 00 查询 meta
|
||
07 01 按 offset 读取分片 (每片最多 20 原始字节, nibble 编码)
|
||
07 02 清空 (需确认码 55 2A)
|
||
|
||
注意: 本模组上 UART GATT 裸写容易导致断连；默认优先 BLE-MIDI。
|
||
|
||
依赖: bleak
|
||
用法:
|
||
python ble_log_pull.py --out LOG.BIN --decode crash.log -v
|
||
python ble_log_pull.py --transport midi --address CB:4E:FD:F1:C0:79 --out LOG.BIN
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import os
|
||
import sys
|
||
import time
|
||
|
||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||
from test_protocol_ble import BleMidiSim, DEFAULT_NAME # noqa: E402
|
||
from test_protocol_app_sim import HEAD, APP_ID, build, hexs # noqa: E402
|
||
|
||
CHUNK = 20
|
||
|
||
|
||
def u32_to_7bit(v: int) -> bytes:
|
||
v &= 0xFFFFFFFF
|
||
return bytes(
|
||
[
|
||
(v >> 28) & 0x7F,
|
||
(v >> 21) & 0x7F,
|
||
(v >> 14) & 0x7F,
|
||
(v >> 7) & 0x7F,
|
||
v & 0x7F,
|
||
]
|
||
)
|
||
|
||
|
||
def u32_from_7bit(b: bytes, i: int = 0) -> int:
|
||
return (
|
||
((b[i] & 0x7F) << 28)
|
||
| ((b[i + 1] & 0x7F) << 21)
|
||
| ((b[i + 2] & 0x7F) << 14)
|
||
| ((b[i + 3] & 0x7F) << 7)
|
||
| (b[i + 4] & 0x7F)
|
||
)
|
||
|
||
|
||
def nibbles_to_bytes(nibs: bytes) -> bytes:
|
||
out = bytearray()
|
||
for i in range(0, len(nibs) - 1, 2):
|
||
out.append(((nibs[i] & 0x0F) << 4) | (nibs[i + 1] & 0x0F))
|
||
return bytes(out)
|
||
|
||
|
||
def parse_meta(frame: bytes) -> dict:
|
||
if len(frame) < 36 or frame[2] != 0x07 or frame[3] != 0x00:
|
||
raise ValueError(f"bad meta frame len={len(frame)}: {hexs(frame)}")
|
||
i = 4
|
||
valid = frame[i]
|
||
i += 1
|
||
ver = frame[i]
|
||
i += 1
|
||
size = u32_from_7bit(frame, i)
|
||
i += 5
|
||
data_size = u32_from_7bit(frame, i)
|
||
i += 5
|
||
write_off = u32_from_7bit(frame, i)
|
||
i += 5
|
||
wrap = u32_from_7bit(frame, i)
|
||
i += 5
|
||
boot = u32_from_7bit(frame, i)
|
||
i += 5
|
||
lines = u32_from_7bit(frame, i)
|
||
return {
|
||
"valid": valid,
|
||
"ver": ver,
|
||
"partition_size": size,
|
||
"data_size": data_size,
|
||
"write_off": write_off,
|
||
"wrap_count": wrap,
|
||
"boot_count": boot,
|
||
"line_count": lines,
|
||
}
|
||
|
||
|
||
def parse_chunk(frame: bytes) -> tuple[int, bytes]:
|
||
if len(frame) < 11 or frame[2] != 0x07 or frame[3] != 0x01:
|
||
raise ValueError(f"bad chunk frame: {hexs(frame)}")
|
||
off = u32_from_7bit(frame, 4)
|
||
n = frame[9]
|
||
nibs = frame[10 : 10 + n]
|
||
if len(nibs) < n:
|
||
raise ValueError("truncated chunk")
|
||
return off, nibbles_to_bytes(nibs)
|
||
|
||
|
||
def safe_send(sim: BleMidiSim, frame: bytes) -> None:
|
||
if not sim.is_connected():
|
||
raise RuntimeError("Not connected")
|
||
sim.send(frame)
|
||
|
||
|
||
def wait_cmd(sim: BleMidiSim, cmd1: int, cmd2: int, timeout: float, verbose: bool):
|
||
t0 = time.monotonic()
|
||
others = []
|
||
while time.monotonic() - t0 < timeout:
|
||
if not sim.is_connected():
|
||
if verbose:
|
||
print(" (wait) link dropped")
|
||
return None
|
||
sim._pump()
|
||
i = 0
|
||
while i < len(sim.pending):
|
||
fr = sim.pending[i]
|
||
if (
|
||
len(fr) >= 4
|
||
and fr[0] == HEAD
|
||
and fr[1] == APP_ID
|
||
and fr[2] == cmd1
|
||
and fr[3] == cmd2
|
||
):
|
||
sim.pending.pop(i)
|
||
return fr
|
||
others.append(sim.pending.pop(i))
|
||
continue
|
||
time.sleep(0.01)
|
||
if verbose and others:
|
||
print(f" (timeout) saw {len(others)} other frame(s), last={hexs(others[-1][:32])}")
|
||
elif verbose:
|
||
print(" (timeout) no frames received at all")
|
||
return None
|
||
|
||
|
||
def query_cmd(
|
||
sim: BleMidiSim,
|
||
frame: bytes,
|
||
cmd1: int,
|
||
cmd2: int,
|
||
timeout: float,
|
||
verbose: bool,
|
||
retries: int = 2,
|
||
):
|
||
# 轻量 drain，避免 read_frame 清空 pending 时误伤
|
||
t_drain = time.monotonic() + 0.15
|
||
while time.monotonic() < t_drain:
|
||
sim._pump()
|
||
sim.pending.clear()
|
||
time.sleep(0.02)
|
||
|
||
for attempt in range(retries + 1):
|
||
if verbose:
|
||
print(f" TX[{attempt}]: {hexs(frame)}")
|
||
try:
|
||
safe_send(sim, frame)
|
||
except Exception as e:
|
||
if verbose:
|
||
print(f" TX fail: {e}")
|
||
return None
|
||
fr = wait_cmd(sim, cmd1, cmd2, timeout=timeout, verbose=verbose)
|
||
if fr is not None:
|
||
if verbose:
|
||
print(f" RX: {hexs(fr[:48])}{'...' if len(fr) > 48 else ''}")
|
||
return fr
|
||
time.sleep(0.25)
|
||
return None
|
||
|
||
|
||
def soft_probe(sim: BleMidiSim, verbose: bool = False) -> bool:
|
||
"""只用 01 01 探活，失败时不立刻 unpair（Windows 上 unpair 易把模组打哑巴）。"""
|
||
time.sleep(0.6) # 连接后给模组 settle
|
||
r = query_cmd(sim, build(0x01, 0x01), 0x01, 0x01, timeout=3.0, verbose=verbose, retries=2)
|
||
if r is not None and len(r) >= 5 and r[0] == HEAD and r[1] == APP_ID:
|
||
return True
|
||
if verbose:
|
||
print(" soft probe failed; try probe_or_rebind once")
|
||
try:
|
||
return bool(
|
||
sim.probe_or_rebind(
|
||
name=sim.info.get("name") or DEFAULT_NAME,
|
||
address=sim.info.get("address"),
|
||
)
|
||
)
|
||
except Exception as e:
|
||
if verbose:
|
||
print(f" probe_or_rebind exception: {e}")
|
||
return False
|
||
|
||
|
||
def pull(sim: BleMidiSim, out_path: str, timeout: float = 4.0, verbose: bool = False) -> dict:
|
||
if not soft_probe(sim, verbose=verbose):
|
||
raise RuntimeError(
|
||
"BLE 协议无应答(01 01)。请确认琴已开机、蓝牙开关为开；"
|
||
"若刚用过 --transport uart 导致断连，请断电复位后再用 --transport midi。"
|
||
)
|
||
|
||
meta_frame = query_cmd(
|
||
sim, build(0x07, 0x00), 0x07, 0x00, timeout=timeout, verbose=verbose, retries=3
|
||
)
|
||
if meta_frame is None:
|
||
ver = query_cmd(
|
||
sim, build(0x01, 0x03), 0x01, 0x03, timeout=2.0, verbose=verbose, retries=1
|
||
)
|
||
tip = ""
|
||
if ver is not None:
|
||
tip = (
|
||
" 普通指令(01 03)正常，但 07 00 无应答 → 固件可能未含日志协议，请重新烧录。"
|
||
)
|
||
elif not sim.is_connected():
|
||
tip = " 链路已断开（uart 传输常见）。请改用: python ble_log_pull.py --transport midi ..."
|
||
raise RuntimeError("timeout waiting log meta (07 00)." + tip)
|
||
|
||
meta = parse_meta(meta_frame)
|
||
print(
|
||
f"meta valid={meta['valid']} ver={meta['ver']} size={meta['partition_size']} "
|
||
f"write={meta['write_off']} wrap={meta['wrap_count']} "
|
||
f"boot={meta['boot_count']} lines={meta['line_count']}"
|
||
)
|
||
if not meta["valid"] or meta["partition_size"] == 0:
|
||
raise RuntimeError("device log partition invalid")
|
||
|
||
total = meta["partition_size"]
|
||
buf = bytearray(b"\xff" * total)
|
||
got = 0
|
||
off = 0
|
||
while off < total:
|
||
want = min(CHUNK, total - off)
|
||
req = bytes([HEAD, APP_ID, 0x07, 0x01]) + u32_to_7bit(off) + bytes([want, 0xF7])
|
||
chunk = None
|
||
for attempt in range(4):
|
||
if not sim.is_connected():
|
||
raise RuntimeError(f"link dropped at offset 0x{off:X}")
|
||
try:
|
||
safe_send(sim, req)
|
||
except Exception as e:
|
||
time.sleep(0.1 * (attempt + 1))
|
||
if verbose:
|
||
print(f" chunk TX fail @0x{off:X}: {e}")
|
||
continue
|
||
fr = wait_cmd(sim, 0x07, 0x01, timeout=timeout, verbose=False)
|
||
if fr is None:
|
||
time.sleep(0.05 * (attempt + 1))
|
||
continue
|
||
try:
|
||
roff, data = parse_chunk(fr)
|
||
except ValueError:
|
||
continue
|
||
if roff == off and data:
|
||
chunk = data
|
||
break
|
||
if chunk is None:
|
||
raise RuntimeError(f"timeout at offset 0x{off:X} (after retries)")
|
||
buf[off : off + len(chunk)] = chunk
|
||
got += len(chunk)
|
||
off += len(chunk)
|
||
if off % 4096 == 0 or off >= total:
|
||
print(f" {off}/{total} ({100.0 * off / total:.1f}%)")
|
||
|
||
with open(out_path, "wb") as f:
|
||
f.write(buf)
|
||
print(f"wrote {out_path} ({got} bytes)")
|
||
return meta
|
||
|
||
|
||
def main():
|
||
ap = argparse.ArgumentParser(description="Pull K1 field log over BLE")
|
||
ap.add_argument("--out", default="LOG.BIN")
|
||
ap.add_argument("--name", default=DEFAULT_NAME)
|
||
ap.add_argument("--address", default=None)
|
||
ap.add_argument(
|
||
"--transport",
|
||
choices=("midi", "uart", "auto"),
|
||
default="midi",
|
||
help="默认 midi（uart 裸写在本模组上容易 Not connected）",
|
||
)
|
||
ap.add_argument("--decode", default=None, help="also decode to this text path")
|
||
ap.add_argument("--clear", action="store_true", help="clear flash log after pull")
|
||
ap.add_argument("-v", "--verbose", action="store_true")
|
||
ap.add_argument("--timeout", type=float, default=4.0)
|
||
args = ap.parse_args()
|
||
|
||
transports = [args.transport]
|
||
if args.transport == "auto":
|
||
# midi 优先：uart GATT 写可能导致模组断连
|
||
transports = ["midi", "uart"]
|
||
elif args.transport == "uart":
|
||
print(
|
||
"警告: --transport uart 在本机模组上常导致 Not connected；"
|
||
"若失败请改用 --transport midi"
|
||
)
|
||
|
||
last_err = None
|
||
for tr in transports:
|
||
print(f"=== transport={tr} ===")
|
||
sim = None
|
||
try:
|
||
sim = BleMidiSim(name=args.name, address=args.address, transport=tr)
|
||
print(f"connected: {sim.info}")
|
||
time.sleep(0.8)
|
||
if not sim.is_connected():
|
||
raise RuntimeError("connected then immediately dropped")
|
||
meta = pull(sim, args.out, timeout=args.timeout, verbose=args.verbose)
|
||
if args.decode:
|
||
from log_decode import decode_file
|
||
|
||
decode_file(
|
||
args.out,
|
||
args.decode,
|
||
meta.get("write_off", 0),
|
||
meta.get("wrap_count", 0),
|
||
)
|
||
if args.clear:
|
||
req = build(0x07, 0x02, 0x55, 0x2A)
|
||
safe_send(sim, req)
|
||
time.sleep(0.3)
|
||
sim._pump()
|
||
print("clear requested")
|
||
return
|
||
except Exception as e:
|
||
last_err = e
|
||
print(f"FAILED ({tr}): {e}")
|
||
finally:
|
||
if sim is not None:
|
||
try:
|
||
sim.close()
|
||
except Exception:
|
||
pass
|
||
time.sleep(1.0)
|
||
|
||
raise SystemExit(
|
||
f"all transports failed: {last_err}\n"
|
||
"建议: 1) 断电复位吉他 2) python ble_log_pull.py --transport midi -v --out LOG.BIN --decode crash.log\n"
|
||
"若有 J-Link: python rtt_flash_log_dump.py --out crash.log --scan"
|
||
)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|