1 Commits
Author SHA1 Message Date
jimmyandClaude Opus 5.5 495da4e366 feat(espnow): app-file OTA over the reliable link
New espnow_ota module, loaded on the first OTA packet (types 0x07-0x0C,
status reply 0x26). Files are written by chunk index to <path>.new,
checked against their sha256, and moved into place together on commit,
followed by a reset. Unchanged files are skipped, and a repeated commit
after the reset still gets OK.

- receive ESP-NOW frames from esp.irq() so frames are not lost while
  presets.tick() runs; polling remains as a fallback
- raise rxbuf to 2048 and the link inbox to 24 frames
- file_hashes: MicroPython's sha256 has no hexdigest()
- bench stats line includes esp.stats()

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 23:41:17 +13:00
8 changed files with 577 additions and 15 deletions

No files matched your search

+293
View File
@@ -0,0 +1,293 @@
"""App-file OTA over ESP-NOW (driver side). Imported on the first OTA packet only.
Inner packets, carried in reliable-link DATA frames (unicast acked, or broadcast):
0x07 BEGIN [4C][07][sess u16][size u32][sha256 32B][plen][path]
0x08 DATA [4C][08][sess u16][chunk u16] + up to CHUNK bytes at chunk * CHUNK
0x09 END [4C][09][sess u16] hash the staged file
0x0A COMMIT [4C][0A][sess u16] move every staged file into place, then reset
0x0B ABORT [4C][0B][sess u16] delete the staged files
0x0C MISSING [4C][0C][sess u16] report which chunks of the current file are missing
Reply, sent straight back (not through the link):
0x26 STATUS [4C][26][sess u16][op][code] + arg
arg: [cnt u16] + missing bitmap for MISSING, else received bytes u32
Files are written to <path>.new; a new session discards whatever an older one staged.
The committed session is kept in ota_last: the reset can beat a lost reply, and the
controller then asks again.
"""
import struct
import file_hashes
WIRE_MAGIC = 0x4C
OP_BEGIN = 0x07
OP_DATA = 0x08
OP_END = 0x09
OP_COMMIT = 0x0A
OP_ABORT = 0x0B
OP_MISSING = 0x0C
MSG_STATUS = 0x26
OK = 0
READY = 1
SAME = 2
BADHASH = 3
INCOMPLETE = 4
BADPATH = 5
IOERR = 6
NOSESS = 7
TOOBIG = 8
CHUNK = 944 # 4 link fragments of 238 bytes minus this packet's 8-byte header
MAX_SIZE = 65536
STAGED_SUFFIX = ".new"
LAST_FILE = "ota_last" # session last committed, so a repeated COMMIT after the reset still gets OK
try:
import uos as os
except ImportError:
import os
def safe_path(path):
"""Relative path to a root file, patterns/... or lib/..., never the hash manifest."""
if not path or path.startswith("/") or "\\" in path or path == file_hashes.MANIFEST_FILENAME:
return False
parts = path.split("/")
if any(p in ("", ".", "..") for p in parts):
return False
return len(parts) == 1 or parts[0] in ("patterns", "lib")
def _makedirs(path):
parts = path.split("/")[:-1]
for i in range(1, len(parts) + 1):
try:
os.mkdir("/".join(parts[:i]))
except OSError:
pass
def _remove(path):
try:
os.remove(path)
except OSError:
pass
class Ota:
def __init__(self, send, reset=None):
self.send = send # send(mac, frame)
self.reset = reset # called after a commit; defaults to machine.reset
self.sess = 0
self.staged = {} # path -> sha hex of a verified .new file
self.cur = None # [path, size, sha hex, file, have bitmap (bytearray), received bytes]
try:
with open(LAST_FILE) as f:
self.committed = int(f.read())
except (OSError, ValueError):
self.committed = 0
def handle(self, mac, pkt):
if len(pkt) < 4:
return
op = pkt[1]
sess = pkt[2] | (pkt[3] << 8)
if sess == 0:
return
if op == OP_COMMIT and sess == self.committed:
self._reply(mac, sess, op, OK, struct.pack("<I", 0))
elif op == OP_BEGIN:
self._begin(mac, sess, pkt)
elif sess != self.sess:
if op != OP_DATA: # data for a session we never started: stay quiet, it may be broadcast
self._reply(mac, sess, op, NOSESS)
elif op == OP_DATA:
self._data(pkt)
elif op == OP_END:
self._end(mac)
elif op == OP_COMMIT:
self._commit(mac)
elif op == OP_ABORT:
self._abort()
self._reply(mac, sess, op, OK)
elif op == OP_MISSING:
self._missing(mac)
def _reply(self, mac, sess, op, code, arg=None):
if arg is None:
arg = struct.pack("<I", self.cur[5] if self.cur else 0)
self.send(mac, struct.pack("<BBHBB", WIRE_MAGIC, MSG_STATUS, sess, op, code) + arg)
def _close_cur(self, delete):
if self.cur is None:
return
try:
self.cur[3].close()
except OSError:
pass
if delete:
_remove(self.cur[0] + STAGED_SUFFIX)
self.cur = None
def _abort(self):
self._close_cur(True)
for path in self.staged:
_remove(path + STAGED_SUFFIX)
self.staged = {}
def _begin(self, mac, sess, pkt):
if len(pkt) < 43:
return
size = struct.unpack_from("<I", pkt, 4)[0]
sha = "".join("%02x" % b for b in pkt[8:40])
plen = pkt[40]
path = bytes(pkt[41 : 41 + plen]).decode()
if sess != self.sess:
self._abort()
self.sess = sess
if not safe_path(path):
self._reply(mac, sess, OP_BEGIN, BADPATH)
return
if size > MAX_SIZE:
self._reply(mac, sess, OP_BEGIN, TOOBIG)
return
if self.cur is not None:
if self.cur[0] == path and self.cur[2] == sha:
self._reply(mac, sess, OP_BEGIN, READY) # our earlier reply was lost
return
self._close_cur(True)
if self.staged.get(path) == sha:
self._reply(mac, sess, OP_BEGIN, READY)
return
try:
if file_hashes._hash_file(path) == sha:
self._reply(mac, sess, OP_BEGIN, SAME)
return
except OSError:
pass # no such file yet
try:
_makedirs(path)
f = open(path + STAGED_SUFFIX, "w+b")
except OSError:
self._reply(mac, sess, OP_BEGIN, IOERR)
return
cnt = (size + CHUNK - 1) // CHUNK
self.staged.pop(path, None)
self.cur = [path, size, sha, f, bytearray((cnt + 7) // 8), 0]
self._reply(mac, sess, OP_BEGIN, READY)
def _data(self, pkt):
cur = self.cur
if cur is None or len(pkt) < 6:
return
idx = pkt[4] | (pkt[5] << 8)
body = pkt[6:]
off = idx * CHUNK
have = cur[4]
if off >= cur[1] or have[idx >> 3] & (1 << (idx & 7)):
return # past the end, or a copy we already wrote
if len(body) != min(CHUNK, cur[1] - off):
return
f = cur[3]
try:
end = f.seek(0, 2)
if end < off:
f.write(bytes(off - end)) # a chunk before this one is still missing
f.seek(off)
f.write(body)
except OSError:
self._close_cur(True)
return
have[idx >> 3] |= 1 << (idx & 7)
cur[5] += len(body)
def _missing_bitmap(self):
cur = self.cur
cnt = (cur[1] + CHUNK - 1) // CHUNK
miss = bytearray(len(cur[4]))
for i in range(cnt):
if not cur[4][i >> 3] & (1 << (i & 7)):
miss[i >> 3] |= 1 << (i & 7)
return cnt, miss
def _missing(self, mac):
if self.cur is None:
self._reply(mac, self.sess, OP_MISSING, OK, struct.pack("<H", 0))
return
cnt, miss = self._missing_bitmap()
self._reply(mac, self.sess, OP_MISSING, OK, struct.pack("<H", cnt) + miss)
def _end(self, mac):
cur = self.cur
if cur is None:
# already verified: our OK was lost and the controller asks again
self._reply(mac, self.sess, OP_END, OK if self.staged else NOSESS)
return
if cur[5] < cur[1]:
self._reply(mac, self.sess, OP_END, INCOMPLETE)
return
path, sha = cur[0], cur[2]
self._close_cur(False)
try:
ok = file_hashes._hash_file(path + STAGED_SUFFIX) == sha
except OSError:
ok = False
if not ok:
_remove(path + STAGED_SUFFIX)
self._reply(mac, self.sess, OP_END, BADHASH)
return
self.staged[path] = sha
self._reply(mac, self.sess, OP_END, OK)
def _commit(self, mac):
self._close_cur(True)
manifest = file_hashes.load()
failed = False
for path, sha in self.staged.items():
try:
try:
os.rename(path + STAGED_SUFFIX, path)
except OSError:
_remove(path)
os.rename(path + STAGED_SUFFIX, path)
manifest[path] = sha
except OSError:
failed = True
moved = len(self.staged)
self.staged = {}
try:
file_hashes.save(manifest)
with open(LAST_FILE, "w") as f:
f.write(str(self.sess))
except OSError:
failed = True
self.committed = self.sess
self._reply(mac, self.sess, OP_COMMIT, IOERR if failed else OK, struct.pack("<I", moved))
print("ota: committed", moved, "files" + (" with errors" if failed else ""))
if moved:
self._schedule_reset()
def _schedule_reset(self):
if self.reset is not None:
self.reset()
return
import machine
try:
t = machine.Timer(0)
t.init(mode=machine.Timer.ONE_SHOT, period=300, callback=lambda _: machine.reset())
except Exception:
import utime
utime.sleep_ms(300)
machine.reset()
_ota = None
def handle(mac, pkt, send):
global _ota
if _ota is None:
_ota = Ota(send)
_ota.handle(bytes(mac), pkt)
+2 -1
View File
@@ -9,6 +9,7 @@ Extra message types, all inside the existing wire magic 0x4C:
0x23 RESYNC [4C][23][ver u16] driver -> controller 0x23 RESYNC [4C][23][ver u16] driver -> controller
0x24 ECHO [4C][24][beat_idx u16] driver -> controller, bench only 0x24 ECHO [4C][24][beat_idx u16] driver -> controller, bench only
0x25 BEAT [4C][25][flags][idx u16][period u16][fire_in] handled by BeatSync 0x25 BEAT [4C][25][flags][idx u16][period u16][fire_in] handled by BeatSync
0x26 OTA [4C][26][sess u16][op][code] + arg driver -> controller, see espnow_ota.py
Everything else (announce, groups, cmd, group cmd, plain JSON) goes straight to the handler. Everything else (announce, groups, cmd, group cmd, plain JSON) goes straight to the handler.
""" """
import struct import struct
@@ -25,7 +26,7 @@ F_ACK = 1
F_COMMIT = 2 F_COMMIT = 2
HDR = 9 HDR = 9
INBOX_MAX = 16 INBOX_MAX = 24
DONE_MAX = 16 DONE_MAX = 16
ASM_TIMEOUT_MS = 3000 ASM_TIMEOUT_MS = 3000
RESYNC_MIN_GAP_MS = 3000 RESYNC_MIN_GAP_MS = 3000
+18 -1
View File
@@ -14,6 +14,8 @@ from espnow_wire import (
MSG_CMD, MSG_CMD,
MSG_GROUP_CMD, MSG_GROUP_CMD,
MSG_GROUPS, MSG_GROUPS,
MSG_OTA_FIRST,
MSG_OTA_LAST,
MSG_PING_REQ, MSG_PING_REQ,
cmd_envelope, cmd_envelope,
pack_announce, pack_announce,
@@ -31,6 +33,7 @@ _PING_DELAY_MS_MIN = 50
_PING_DELAY_MS_MAX = 500 _PING_DELAY_MS_MAX = 500
_esp = None _esp = None
_ota_send = None
_groups_received = False _groups_received = False
_debug = False _debug = False
@@ -56,6 +59,11 @@ def init_espnow(settings):
except Exception as e: except Exception as e:
print("espnow sta channel set failed:", e) print("espnow sta channel set failed:", e)
_esp = espnow.ESPNow() _esp = espnow.ESPNow()
try:
# The default 526 bytes holds two full frames; an OTA chunk is four
_esp.config(rxbuf=int(settings.get("espnow_rxbuf", 2048)))
except Exception as e:
print("espnow rxbuf set failed:", e)
_esp.active(True) _esp.active(True)
try: try:
_esp.add_peer(BROADCAST_MAC) _esp.add_peer(BROADCAST_MAC)
@@ -125,8 +133,17 @@ def send_boot_announce(settings):
def _handle_packet(host, pkt, settings, presets): def _handle_packet(host, pkt, settings, presets):
global _groups_received global _groups_received, _ota_send
mt = wire_msg_type(pkt) mt = wire_msg_type(pkt)
if mt is not None and MSG_OTA_FIRST <= mt <= MSG_OTA_LAST:
import espnow_ota
if _ota_send is None:
from espnow_rx import make_sender
_ota_send = make_sender(_esp)
espnow_ota.handle(host, pkt, _ota_send)
return
if mt == MSG_GROUPS: if mt == MSG_GROUPS:
ids = parse_groups(pkt) ids = parse_groups(pkt)
if ids is not None: if ids is not None:
+2
View File
@@ -11,6 +11,8 @@ MSG_CMD = 0x03
MSG_GROUP_CMD = 0x04 MSG_GROUP_CMD = 0x04
MSG_PING_REQ = 0x05 MSG_PING_REQ = 0x05
MSG_PING_RSP = 0x06 MSG_PING_RSP = 0x06
MSG_OTA_FIRST = 0x07 # 0x07..0x0C app-file OTA, see espnow_ota.py
MSG_OTA_LAST = 0x0C
BROADCAST_MAC = b"\xff\xff\xff\xff\xff\xff" BROADCAST_MAC = b"\xff\xff\xff\xff\xff\xff"
+3 -2
View File
@@ -47,16 +47,17 @@ def save(files):
def _hash_file(path): def _hash_file(path):
import binascii
import hashlib import hashlib
h = hashlib.sha256() h = hashlib.sha256()
with open(path, "rb") as f: with open(path, "rb") as f:
while True: while True:
chunk = f.read(256) chunk = f.read(1024)
if not chunk: if not chunk:
break break
h.update(chunk) h.update(chunk)
return h.hexdigest() return binascii.hexlify(h.digest()).decode() # MicroPython's sha256 has no hexdigest()
def _walk_dir(base, prefix, out): def _walk_dir(base, prefix, out):
+26 -9
View File
@@ -77,16 +77,33 @@ beat_pin = None
if settings.get("beat_pin") is not None: if settings.get("beat_pin") is not None:
beat_pin = machine.Pin(int(settings["beat_pin"]), machine.Pin.OUT) beat_pin = machine.Pin(int(settings["beat_pin"]), machine.Pin.OUT)
def _drain(e):
# Runs scheduled between bytecodes, so frames are taken while presets.tick() is still busy.
# irecv reuses its buffers: on_packet handles beats in place and copies everything else.
while True:
try:
host, msg = e.irecv(0)
except OSError:
return
if not host:
return
if msg:
try:
link.on_packet(host, msg, utime.ticks_ms())
except Exception as ex:
print("espnow rx error:", ex)
try:
esp.irq(_drain)
use_irq = True
except AttributeError: # firmware built without ESP-NOW irq support: poll as before
use_irq = False
while True: while True:
wdt.feed() wdt.feed()
while esp.any(): if not use_irq:
host, msg = esp.recv(0) _drain(esp)
if not host or not msg:
continue
try:
link.on_packet(host, msg, utime.ticks_ms())
except Exception as e:
print("espnow rx error:", e)
now = utime.ticks_ms() now = utime.ticks_ms()
try: try:
link.poll(now) link.poll(now)
@@ -103,7 +120,7 @@ while True:
link.echo(beat_sync.last_idx) # only real triggers: an invented beat has no send time to compare link.echo(beat_sync.last_idx) # only real triggers: an invented beat has no send time to compare
if bench and utime.ticks_diff(now, last_stat) >= 5000: if bench and utime.ticks_diff(now, last_stat) >= 5000:
last_stat = now last_stat = now
print("beat", beat_sync.stats, "link", link.stats) print("beat", beat_sync.stats, "link", link.stats, "radio", esp.stats()) # radio: tx, tx_resp, tx_fail, rx, rx_dropped
presets.tick() presets.tick()
if fire_log is not None: if fire_log is not None:
print("FIRE", fire_log[0], fire_log[1]) print("FIRE", fire_log[0], fire_log[1])
+231
View File
@@ -0,0 +1,231 @@
#!/usr/bin/env python3
"""Ota: staging, chunk bitmap, hash checks, commit and sessions. Runs in a temp directory."""
import hashlib
import json
import os
import struct
import tempfile
import espnow_ota as o
import file_hashes
M = b"\x01\x02\x03\x04\x05\x06"
def begin(sess, path, body):
p = path.encode()
return struct.pack("<BBHI", 0x4C, o.OP_BEGIN, sess, len(body)) + hashlib.sha256(body).digest() + bytes([len(p)]) + p
def chunk(sess, body, idx):
return struct.pack("<BBHH", 0x4C, o.OP_DATA, sess, idx) + body[idx * o.CHUNK : (idx + 1) * o.CHUNK]
def cmd(op, sess):
return struct.pack("<BBH", 0x4C, op, sess)
def nchunks(body):
return (len(body) + o.CHUNK - 1) // o.CHUNK
class Rig:
def __init__(self):
self.sent, self.resets = [], 0
self.ota = o.Ota(lambda mac, f: self.sent.append(f), self._reset)
def _reset(self):
self.resets += 1
def __call__(self, pkt):
self.ota.handle(M, pkt)
if self.sent:
f = self.sent.pop()
_, t, sess, op, code = struct.unpack_from("<BBHBB", f)
assert t == o.MSG_STATUS
return op, code, f[6:]
return None
def send_file(self, sess, path, body, skip=()):
assert self(begin(sess, path, body))[1] == o.READY
for i in range(nchunks(body)):
if i not in skip:
assert self(chunk(sess, body, i)) is None # data is acked by the link, not here
return self(cmd(o.OP_END, sess))[1]
def in_tmp(fn):
def run():
old = os.getcwd()
with tempfile.TemporaryDirectory() as d:
os.chdir(d)
try:
fn()
finally:
os.chdir(old)
run.__name__ = fn.__name__
return run
BODY = bytes(range(256)) * 10 # 2560 bytes, 3 chunks
@in_tmp
def test_write_commit_and_manifest():
r = Rig()
assert r.send_file(5, "patterns/wave.py", BODY) == o.OK
assert not os.path.exists("patterns/wave.py") # staged only
op, code, arg = r(cmd(o.OP_COMMIT, 5))
assert (op, code, struct.unpack("<I", arg)[0]) == (o.OP_COMMIT, o.OK, 1)
assert open("patterns/wave.py", "rb").read() == BODY and not os.path.exists("patterns/wave.py.new")
assert file_hashes.load()["patterns/wave.py"] == hashlib.sha256(BODY).hexdigest()
assert r.resets == 1
@in_tmp
def test_same_file_is_skipped():
with open("main.py", "wb") as f:
f.write(BODY)
r = Rig()
assert r(begin(1, "main.py", BODY))[1] == o.SAME
op, code, _ = r(cmd(o.OP_COMMIT, 1))
assert code == o.OK and r.resets == 0 # nothing moved, no reset
@in_tmp
def test_out_of_order_and_duplicate_chunks():
r = Rig()
assert r(begin(2, "a.py", BODY))[1] == o.READY
for i in (2, 0, 2, 1, 0):
r(chunk(2, BODY, i))
assert r(cmd(o.OP_END, 2))[1] == o.OK
r(cmd(o.OP_COMMIT, 2))
assert open("a.py", "rb").read() == BODY
@in_tmp
def test_incomplete_then_missing_then_repair():
r = Rig()
assert r.send_file(3, "a.py", BODY, skip=(0, 2)) == o.INCOMPLETE
op, code, arg = r(cmd(o.OP_MISSING, 3))
cnt = struct.unpack_from("<H", arg)[0]
assert (op, cnt, arg[2]) == (o.OP_MISSING, 3, 0b101)
r(chunk(3, BODY, 0))
r(chunk(3, BODY, 2))
assert r(cmd(o.OP_MISSING, 3))[2][2] == 0
assert r(cmd(o.OP_END, 3))[1] == o.OK
@in_tmp
def test_bad_hash_is_not_staged():
r = Rig()
bad = bytearray(begin(4, "a.py", BODY))
bad[8] ^= 0xFF
assert r(bytes(bad))[1] == o.READY
for i in range(nchunks(BODY)):
r(chunk(4, BODY, i))
assert r(cmd(o.OP_END, 4))[1] == o.BADHASH
r(cmd(o.OP_COMMIT, 4))
assert not os.path.exists("a.py") and not os.path.exists("a.py.new") and r.resets == 0
@in_tmp
def test_bad_paths():
r = Rig()
for p in ("../x.py", "/main.py", "a/b.py", "lib//x.py", "file_hashes.json", "patterns\\x.py", "lib/../main.py"):
assert r(begin(6, p, b"x"))[1] == o.BADPATH, p
for p in ("main.py", "patterns/x.py", "lib/microdot/websocket.py"):
assert r(begin(6, p, b"x"))[1] == o.READY, p
@in_tmp
def test_new_session_discards_staged():
r = Rig()
assert r.send_file(7, "a.py", BODY) == o.OK
assert os.path.exists("a.py.new")
assert r(begin(8, "b.py", b"bb"))[1] == o.READY
assert not os.path.exists("a.py.new")
assert r(cmd(o.OP_COMMIT, 7))[1] == o.NOSESS # old session is gone
@in_tmp
def test_repeated_begin_and_end_are_idempotent():
r = Rig()
assert r(begin(9, "a.py", BODY))[1] == o.READY
r(chunk(9, BODY, 0))
assert r(begin(9, "a.py", BODY))[1] == o.READY # reply was lost, controller asks again
r(chunk(9, BODY, 1))
r(chunk(9, BODY, 2))
assert r(cmd(o.OP_END, 9))[1] == o.OK
assert r(cmd(o.OP_END, 9))[1] == o.OK
assert r(begin(9, "a.py", BODY))[1] == o.READY # already staged with that hash
@in_tmp
def test_abort_removes_staged():
r = Rig()
r.send_file(10, "a.py", BODY)
assert r(cmd(o.OP_ABORT, 10))[1] == o.OK
assert not os.path.exists("a.py.new")
assert r(cmd(o.OP_COMMIT, 10))[2] == struct.pack("<I", 0)
@in_tmp
def test_broadcast_with_loss_recovers():
# three drivers share one broadcast; each drops different chunks, then gets repaired by unicast
body = os.urandom(o.CHUNK * 7 + 100)
rigs = [Rig() for _ in range(3)]
for k, r in enumerate(rigs):
os.makedirs(str(k))
old = os.getcwd()
for k, r in enumerate(rigs):
os.chdir(str(k))
assert r(begin(11, "lib/x.py", body))[1] == o.READY
for i in range(nchunks(body)):
if (i + k) % 3:
r(chunk(11, body, i))
assert r(cmd(o.OP_END, 11))[1] == o.INCOMPLETE
arg = r(cmd(o.OP_MISSING, 11))[2]
cnt = struct.unpack_from("<H", arg)[0]
for i in range(cnt):
if arg[2 + (i >> 3)] & (1 << (i & 7)):
r(chunk(11, body, i))
assert r(cmd(o.OP_END, 11))[1] == o.OK
r(cmd(o.OP_COMMIT, 11))
assert open("lib/x.py", "rb").read() == body
os.chdir(old)
@in_tmp
def test_commit_repeated_after_reset():
r = Rig()
r.send_file(14, "a.py", BODY)
assert r(cmd(o.OP_COMMIT, 14))[1] == o.OK
fresh = Rig() # the driver reset before its reply arrived
op, code, arg = fresh(cmd(o.OP_COMMIT, 14))
assert code == o.OK and fresh.resets == 0
assert fresh(cmd(o.OP_COMMIT, 15))[1] == o.NOSESS
@in_tmp
def test_empty_file():
r = Rig()
assert r.send_file(13, "lib/pkg/__init__.py", b"") == o.OK
r(cmd(o.OP_COMMIT, 13))
assert open("lib/pkg/__init__.py", "rb").read() == b""
@in_tmp
def test_too_big_rejected():
r = Rig()
pkt = bytearray(begin(12, "a.py", b"x"))
struct.pack_into("<I", pkt, 4, o.MAX_SIZE + 1)
assert r(bytes(pkt))[1] == o.TOOBIG
if __name__ == "__main__":
for name, fn in list(globals().items()):
if name.startswith("test_"):
fn()
print("ok")
+2 -2
View File
@@ -1,7 +1,7 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
"""LinkRx: reassembly, dedupe, acks, commit and digest resync.""" """LinkRx: reassembly, dedupe, acks, commit and digest resync."""
import struct import struct
from espnow_rx import LinkRx, MSG_DATA, MSG_ACK, MSG_DIGEST, MSG_RESYNC, F_ACK, F_COMMIT from espnow_rx import LinkRx, MSG_DATA, MSG_ACK, MSG_DIGEST, MSG_RESYNC, F_ACK, F_COMMIT, INBOX_MAX
from beat_sync import BeatSync from beat_sync import BeatSync
M = b"\x01\x02\x03\x04\x05\x06" M = b"\x01\x02\x03\x04\x05\x06"
@@ -124,7 +124,7 @@ def test_legacy_and_beat_frames():
def test_inbox_overflow_counted(): def test_inbox_overflow_counted():
link, _, _ = make() link, _, _ = make()
for i in range(20): for i in range(INBOX_MAX + 4):
link.on_packet(M, data(i, b"x"), 0) link.on_packet(M, data(i, b"x"), 0)
assert link.stats["dropped"] == 4 assert link.stats["dropped"] == 4