Compare commits
3
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
97df6e3cbe | ||
|
|
08d7277204 | ||
|
|
495da4e366 |
No files matched your search
+17
-1
@@ -5,6 +5,7 @@ MSG_BEAT = 0x25
|
|||||||
FRAME_LEN = 8 # [4C][25][flags][idx u16][period u16][fire_in]
|
FRAME_LEN = 8 # [4C][25][flags][idx u16][period u16][fire_in]
|
||||||
MIN_GUARD_MS = 30
|
MIN_GUARD_MS = 30
|
||||||
FREERUN_MISS_MAX = 4
|
FREERUN_MISS_MAX = 4
|
||||||
|
RESTART_BEATS = 3 # consecutive beats that all look old mean the controller restarted its counter
|
||||||
|
|
||||||
|
|
||||||
def _diff(a, b):
|
def _diff(a, b):
|
||||||
@@ -27,6 +28,8 @@ class BeatSync:
|
|||||||
self.downbeat = False
|
self.downbeat = False
|
||||||
self.bar = 0
|
self.bar = 0
|
||||||
self.missed = 0
|
self.missed = 0
|
||||||
|
self.stale_idx = None # newest index seen while every frame looked old
|
||||||
|
self.stale_n = 0
|
||||||
self.freerun_fire = False # True when the last fire was invented, not triggered by a frame
|
self.freerun_fire = False # True when the last fire was invented, not triggered by a frame
|
||||||
# fires: beats acted on; dups: second copies dropped; late: too-soon or old frames;
|
# fires: beats acted on; dups: second copies dropped; late: too-soon or old frames;
|
||||||
# freerun: beats the driver made up because no frame arrived
|
# freerun: beats the driver made up because no frame arrived
|
||||||
@@ -42,11 +45,24 @@ class BeatSync:
|
|||||||
self.stats["dups"] += 1
|
self.stats["dups"] += 1
|
||||||
return False # second copy of a beat we already took
|
return False # second copy of a beat we already took
|
||||||
guard = max(MIN_GUARD_MS, self.period // 2)
|
guard = max(MIN_GUARD_MS, self.period // 2)
|
||||||
if _diff(idx, self.last_idx) >= 0x8000 or (
|
if _diff(idx, self.last_idx) >= 0x8000:
|
||||||
|
# Behind us. A late copy is one or two frames; a controller that rebooted and
|
||||||
|
# restarted its counter sends a run of consecutive indices, so follow it.
|
||||||
|
if idx == self.stale_idx:
|
||||||
|
self.stats["late"] += 1
|
||||||
|
return False
|
||||||
|
self.stale_n = self.stale_n + 1 if self.stale_idx is not None and _diff(idx, self.stale_idx) == 1 else 1
|
||||||
|
self.stale_idx = idx
|
||||||
|
if self.stale_n < RESTART_BEATS:
|
||||||
|
self.stats["late"] += 1
|
||||||
|
return False
|
||||||
|
elif (
|
||||||
self.fire_at is None and now - self.last_fire < guard and self.period
|
self.fire_at is None and now - self.last_fire < guard and self.period
|
||||||
):
|
):
|
||||||
self.stats["late"] += 1
|
self.stats["late"] += 1
|
||||||
return False # late copy of an older beat, or too soon after the last one
|
return False # late copy of an older beat, or too soon after the last one
|
||||||
|
self.stale_idx = None
|
||||||
|
self.stale_n = 0
|
||||||
self.last_idx = idx
|
self.last_idx = idx
|
||||||
self.period = period
|
self.period = period
|
||||||
self.downbeat = bool(flags & 1)
|
self.downbeat = bool(flags & 1)
|
||||||
|
|||||||
@@ -178,8 +178,20 @@ def apply_device_config(data, settings, presets):
|
|||||||
settings["reversed"] = flag
|
settings["reversed"] = flag
|
||||||
presets.reversed = flag
|
presets.reversed = flag
|
||||||
meta_changed = True
|
meta_changed = True
|
||||||
|
max_changed = False
|
||||||
|
if "max_brightness" in dc:
|
||||||
|
try:
|
||||||
|
mb = max(0, min(255, int(dc["max_brightness"])))
|
||||||
|
max_changed = presets.max_b != mb
|
||||||
|
settings["max_brightness"] = mb
|
||||||
|
presets.max_b = mb
|
||||||
|
meta_changed = True
|
||||||
|
except (TypeError, ValueError):
|
||||||
|
pass
|
||||||
if not strip_changed and not meta_changed:
|
if not strip_changed and not meta_changed:
|
||||||
return
|
return
|
||||||
|
if max_changed and not strip_changed and presets.selected in presets.presets:
|
||||||
|
presets.select(presets.selected) # redraw static patterns under the new ceiling
|
||||||
if strip_changed:
|
if strip_changed:
|
||||||
prev = presets.selected
|
prev = presets.selected
|
||||||
try:
|
try:
|
||||||
|
|||||||
@@ -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
@@ -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
@@ -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:
|
||||||
|
|||||||
@@ -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
@@ -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
-8
@@ -33,6 +33,7 @@ esp = init_espnow(settings)
|
|||||||
presets = Presets(settings["led_pin"], settings["num_leds"])
|
presets = Presets(settings["led_pin"], settings["num_leds"])
|
||||||
presets.load(settings)
|
presets.load(settings)
|
||||||
presets.b = settings.get("brightness", 255)
|
presets.b = settings.get("brightness", 255)
|
||||||
|
presets.max_b = settings.get("max_brightness", 255)
|
||||||
presets.debug = bool(settings.get("debug", False))
|
presets.debug = bool(settings.get("debug", False))
|
||||||
gc.collect()
|
gc.collect()
|
||||||
|
|
||||||
@@ -77,16 +78,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:
|
while True:
|
||||||
wdt.feed()
|
try:
|
||||||
while esp.any():
|
host, msg = e.irecv(0)
|
||||||
host, msg = esp.recv(0)
|
except OSError:
|
||||||
if not host or not msg:
|
return
|
||||||
continue
|
if not host:
|
||||||
|
return
|
||||||
|
if msg:
|
||||||
try:
|
try:
|
||||||
link.on_packet(host, msg, utime.ticks_ms())
|
link.on_packet(host, msg, utime.ticks_ms())
|
||||||
except Exception as e:
|
except Exception as ex:
|
||||||
print("espnow rx error:", e)
|
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:
|
||||||
|
wdt.feed()
|
||||||
|
if not use_irq:
|
||||||
|
_drain(esp)
|
||||||
now = utime.ticks_ms()
|
now = utime.ticks_ms()
|
||||||
try:
|
try:
|
||||||
link.poll(now)
|
link.poll(now)
|
||||||
@@ -103,7 +121,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])
|
||||||
|
|||||||
+3
-1
@@ -23,6 +23,8 @@ class Presets:
|
|||||||
self.step = 0
|
self.step = 0
|
||||||
# Global brightness (0–255), controlled via ESPNow {"b": <value>}
|
# Global brightness (0–255), controlled via ESPNow {"b": <value>}
|
||||||
self.b = 255
|
self.b = 255
|
||||||
|
# Ceiling for the effective brightness (0–255): neither the global nor a preset's brightness goes above it
|
||||||
|
self.max_b = 255
|
||||||
self.reversed = False
|
self.reversed = False
|
||||||
|
|
||||||
self.generator = None
|
self.generator = None
|
||||||
@@ -265,7 +267,7 @@ class Presets:
|
|||||||
# Combine per-preset brightness (override) with global brightness self.b
|
# Combine per-preset brightness (override) with global brightness self.b
|
||||||
local = brightness_override if brightness_override is not None else 255
|
local = brightness_override if brightness_override is not None else 255
|
||||||
# Scale preset brightness by global brightness
|
# Scale preset brightness by global brightness
|
||||||
effective_brightness = int(local * self.b / 255)
|
effective_brightness = min(int(local * self.b / 255), self.max_b)
|
||||||
return tuple(int(c * effective_brightness / 255) for c in color)
|
return tuple(int(c * effective_brightness / 255) for c in color)
|
||||||
|
|
||||||
def fill(self, color=None):
|
def fill(self, color=None):
|
||||||
|
|||||||
@@ -21,6 +21,7 @@ def initialize_runtime():
|
|||||||
presets = Presets(settings["led_pin"], settings["num_leds"])
|
presets = Presets(settings["led_pin"], settings["num_leds"])
|
||||||
presets.load(settings)
|
presets.load(settings)
|
||||||
presets.b = settings.get("brightness", 255)
|
presets.b = settings.get("brightness", 255)
|
||||||
|
presets.max_b = settings.get("max_brightness", 255)
|
||||||
presets.debug = bool(settings.get("debug", False))
|
presets.debug = bool(settings.get("debug", False))
|
||||||
gc.collect()
|
gc.collect()
|
||||||
|
|
||||||
|
|||||||
@@ -84,6 +84,27 @@ def test_stats_count_dups_and_freerun():
|
|||||||
assert b.stats["freerun"] == 1 and b.stats["fires"] == 2
|
assert b.stats["freerun"] == 1 and b.stats["fires"] == 2
|
||||||
|
|
||||||
|
|
||||||
|
def test_controller_restart_is_followed():
|
||||||
|
b = BeatSync()
|
||||||
|
assert b.on_frame(frame(29000), 0)
|
||||||
|
assert not b.on_frame(frame(1), 500) # looks old
|
||||||
|
assert not b.on_frame(frame(1), 502) # second copy of the same beat
|
||||||
|
assert not b.on_frame(frame(2), 1000)
|
||||||
|
assert b.on_frame(frame(3), 1500) # third consecutive: the counter really restarted
|
||||||
|
assert not b.on_frame(frame(3), 1502)
|
||||||
|
assert b.on_frame(frame(4), 2000)
|
||||||
|
|
||||||
|
|
||||||
|
def test_stray_old_frames_do_not_reset():
|
||||||
|
b = BeatSync()
|
||||||
|
assert b.on_frame(frame(100), 0)
|
||||||
|
assert not b.on_frame(frame(90), 100)
|
||||||
|
assert b.on_frame(frame(101), 500)
|
||||||
|
assert not b.on_frame(frame(99), 600)
|
||||||
|
assert not b.on_frame(frame(98), 700) # not consecutive upward
|
||||||
|
assert b.on_frame(frame(102), 1000)
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
if __name__ == "__main__":
|
||||||
for name, fn in list(globals().items()):
|
for name, fn in list(globals().items()):
|
||||||
if name.startswith("test_"):
|
if name.startswith("test_"):
|
||||||
|
|||||||
@@ -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")
|
||||||
@@ -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
|
||||||
|
|
||||||
|
|||||||
Reference in new issue
Block a user