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).
45 lines
1.7 KiB
Python
45 lines
1.7 KiB
Python
"""Walk the body assuming chunks delimited by 0x10 NN tags. Print each chunk's structure."""
|
|
import sys
|
|
sys.path.insert(0, ".")
|
|
from analysis.load_bundle import load_bundle
|
|
|
|
|
|
def walk(body: bytes, start_offset: int = 7, max_chunks: int = 30):
|
|
"""Find all positions where byte = 0x10 followed by a multiple-of-4 byte. Print chunks."""
|
|
chunks = []
|
|
i = start_offset
|
|
while i < len(body) - 1:
|
|
# Find next `10 NN` where NN is multiple of 4 (and not preceded by another 0x10 immediately, which would be data).
|
|
if body[i] == 0x10 and (body[i+1] % 4 == 0):
|
|
chunks.append(i)
|
|
i += 1
|
|
return chunks
|
|
|
|
|
|
def main():
|
|
for name in ("event-c", "event-d"):
|
|
b = load_bundle(name)
|
|
body = b.body
|
|
positions = []
|
|
i = 7 # skip 7-byte preamble
|
|
while i < len(body) - 1:
|
|
if body[i] == 0x10 and body[i+1] % 4 == 0 and body[i+1] > 0:
|
|
positions.append(i)
|
|
i += 2 # skip past tag
|
|
else:
|
|
i += 1
|
|
print(f"\n=== {name} === body={len(body)}, total `10 NN` (NN%4==0, NN>0) tags: {len(positions)}")
|
|
# Print first 20 chunks: show position, NN, gap to next tag
|
|
for k in range(min(30, len(positions))):
|
|
pos = positions[k]
|
|
NN = body[pos + 1]
|
|
next_pos = positions[k+1] if k+1 < len(positions) else len(body)
|
|
gap = next_pos - pos
|
|
data_bytes = body[pos+2 : next_pos]
|
|
print(f" chunk[{k:>3}] @ {pos:>5} NN=0x{NN:02x} ({NN:>3}, NN/2={NN//2}) gap={gap:>3} "
|
|
f"data={data_bytes[:24].hex(' ')}{'...' if len(data_bytes) > 24 else ''}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|