Claude
d3f77d1d96
Decoded the structural framing of the Blastware waveform body — the bytes between the 21-byte STRT record and the 26-byte file footer. The body is a sequence of tagged variable-length blocks, NOT raw int16 LE. Five tag types (10/20/00/30/40 NN) and their lengths are now confirmed against the 4-event May 2026 fixture bundle. Body splits cleanly into ~16 segments (for a 1280-sample event) separated by 40 02 segment headers carrying a monotonically incrementing uint32 LE counter at bytes [8:12]. What's done: - minimateplus/waveform_codec.py — block walker, segment splitter, segment header parser. decode_waveform_v2 is a stub returning None until the byte-to-sample mapping is solved; client.py is unchanged. - tests/test_waveform_codec.py — 31 tests covering block detection, lengths, contiguous-walk, segment splitting, segment-header parsing, and counter monotonicity. All pass. - tests/fixtures/decode-re-5-8-26/ — bundled fixtures (4 events, BW binary + Blastware ASCII export each). - docs/instantel_protocol_reference.md §7.6.1 — replaced retraction box with the verified structural decoding plus an explicit list of what's still open. What's still open: the per-byte mapping inside 10 NN / 20 NN blocks. 96 channel-permutation × nibble-order × sign-convention combinations were brute-force tested; none match BW's ASCII export to within ±1 ADC count. The codec is more elaborate than uniform 4-bit deltas — likely a hybrid variable-bit-width scheme with segment-anchor resync points. Next recommended step: capture an event with a known calibration tone to pin down magnitude scaling. Walker also bails out partway through event-b (open issue documented in both the module and the protocol reference).
51 lines
2.0 KiB
Python
51 lines
2.0 KiB
Python
"""Deterministic chunk walker: each chunk = [10 NN][NN/2 bytes data][2 bytes trailer]."""
|
||
import sys
|
||
sys.path.insert(0, ".")
|
||
from analysis.load_bundle import load_bundle
|
||
|
||
|
||
def walk_chunks(body: bytes, start: int = 7):
|
||
"""Yield (offset, NN, data_bytes, trailer_bytes) tuples."""
|
||
i = start
|
||
while i + 1 < len(body):
|
||
if body[i] != 0x10:
|
||
break
|
||
NN = body[i + 1]
|
||
if NN == 0 or NN > 0x80 or NN % 4 != 0:
|
||
break
|
||
chunk_len = NN // 2 + 4
|
||
if i + chunk_len > len(body):
|
||
break
|
||
data = bytes(body[i + 2 : i + 2 + NN // 2])
|
||
trailer = bytes(body[i + 2 + NN // 2 : i + chunk_len])
|
||
yield (i, NN, data, trailer)
|
||
i += chunk_len
|
||
|
||
|
||
def main():
|
||
for name in ("event-c", "event-d", "event-a", "event-b"):
|
||
b = load_bundle(name)
|
||
body = b.body
|
||
chunks = list(walk_chunks(body))
|
||
print(f"\n=== {name} === body={len(body)} N_samples={len(b.samples['Tran'])}")
|
||
print(f" chunks parsed: {len(chunks)}")
|
||
if chunks:
|
||
last = chunks[-1]
|
||
end_of_walk = last[0] + last[1] // 2 + 4
|
||
print(f" walk ended at offset {end_of_walk} (= {len(body) - end_of_walk} bytes from end)")
|
||
# Stats
|
||
total_data_bytes = sum(len(c[2]) for c in chunks)
|
||
print(f" total data bytes: {total_data_bytes}, total nibbles: {2*total_data_bytes}")
|
||
if name in ("event-c", "event-d"):
|
||
ratio = (2 * total_data_bytes) / (len(b.samples['Tran']) * 4)
|
||
print(f" nibbles per (sample × channel): {ratio:.3f}")
|
||
# Sum of trailer second-byte
|
||
trailer_sums = [c[3][-1] if c[3] else None for c in chunks]
|
||
print(f" first 10 chunks: {[(c[0], c[1], c[3].hex()) for c in chunks[:10]]}")
|
||
# Print last 10 chunks (likely transition to trailer)
|
||
print(f" last 10 chunks: {[(c[0], c[1], c[3].hex()) for c in chunks[-10:]]}")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|