def update_mpy(filename, fs_base, fs_len, fs_type=VFS_FAT, fs_blocksize=0, status_addr=None):
# Check firmware is of .dfu or .dfu.gz type
try:
with open(filename, "rb") as f:
hdr = uzlib.DecompIO(f, 16 + 15).read(6)
except Exception:
with open(filename, "rb") as f:
hdr = f.read(6)
if hdr != b"DfuSe\x01":
print("Firmware must be a .dfu(.gz) file.")
return
if fs_type in (VFS_LFS1, VFS_LFS2) and not fs_blocksize:
raise Exception("littlefs requires fs_blocksize parameter")
mount_point = 1
elems = _create_element(
_ELEM_TYPE_MOUNT,
struct.pack("<BBLLL", mount_point, fs_type, fs_base, fs_len, fs_blocksize),
)
elems += _create_element(
_ELEM_TYPE_FSLOAD, struct.pack("<B", mount_point) + bytes(filename, "ascii")
)
if status_addr is not None:
# mboot will write 0 to status_addr on succes, or a negative number on failure
machine.mem32[status_addr] = 1
elems += _create_element(_ELEM_TYPE_STATUS, struct.pack("<L", status_addr))
elems += _create_element(_ELEM_TYPE_END, b"")
machine.bootloader(elems)
def update_app(filename):
print(f"Updating application firmware from {filename}")
# Create the elements for the mboot filesystem-load operation.
elems = fwupdate.update_app_elements(filename, _FILESYSTEM_ADDR,
_FILESYSTEM_LEN)
if not elems:
return
# Create the update key.
key = struct.pack("<I", _SPIFLASH_UPDATE_KEY_VALUE)
# Create a SPI flash object.
spi = machine.SoftSPI(sck="B13", mosi="C3", miso="C2", baudrate=50_000_000)
cs = machine.Pin("B12", machine.Pin.OUT, value=1)
flash = spiflash.SPIFlash(spi, cs)
# Write the update key and elements to the SPI flash.
flash.erase_block(_SPIFLASH_UPDATE_KEY_ADDR)
flash.write(_SPIFLASH_UPDATE_KEY_ADDR, key + elems)
# Enter mboot with a request to do a filesystem-load update.
# If there is a power failure during the update (eg battery removed) then
# mboot will read the SPI flash update key and elements and retry.
machine.bootloader(elems)
def reset_bootloader():
try:
import machine
machine.bootloader()
except ImportError:
import microcontroller
microcontroller.on_next_reset(microcontroller.RunMode.BOOTLOADER)
microcontroller.reset()
def update_mpy(filename, fs_base, fs_len):
# Check firmware is of .dfu.gz type
try:
with open(filename, 'rb') as f:
hdr = uzlib.DecompIO(f, 16 + 15).read(6)
except Exception:
hdr = None
if hdr != b'DfuSe\x01':
print('Firmware must be a .dfu.gz file.')
return
ELEM_TYPE_END = 1
ELEM_TYPE_MOUNT = 2
ELEM_TYPE_FSLOAD = 3
ELEM_MOUNT_FAT = 1
mount_point = 1
mount = struct.pack('<BBBBLL', ELEM_TYPE_MOUNT, 10, mount_point, ELEM_MOUNT_FAT, fs_base, fs_len)
fsup = struct.pack('<BBB', ELEM_TYPE_FSLOAD, 1 + len(filename), mount_point) + bytes(filename, 'ascii')
end = struct.pack('<BB', ELEM_TYPE_END, 0)
machine.bootloader(mount + fsup + end)
def update_mpy(filename, fs_base, fs_len, fs_type=VFS_FAT):
# Check firmware is of .dfu.gz type
try:
with open(filename, "rb") as f:
hdr = uzlib.DecompIO(f, 16 + 15).read(6)
except Exception:
hdr = None
if hdr != b"DfuSe\x01":
print("Firmware must be a .dfu.gz file.")
return
ELEM_TYPE_END = 1
ELEM_TYPE_MOUNT = 2
ELEM_TYPE_FSLOAD = 3
mount_point = 1
mount = struct.pack("<BBBBLL", ELEM_TYPE_MOUNT, 10, mount_point, fs_type,
fs_base, fs_len)
fsup = struct.pack("<BBB", ELEM_TYPE_FSLOAD, 1 + len(filename),
mount_point) + bytes(filename, "ascii")
end = struct.pack("<BB", ELEM_TYPE_END, 0)
machine.bootloader(mount + fsup + end)
try:
import machine
machine.bootloader()
except ImportError:
import microcontroller
microcontroller.on_next_reset(microcontroller.RunMode.BOOTLOADER)
microcontroller.reset()
def update_mpy(*args, **kwargs):
elems = update_app_elements(*args, **kwargs)
if elems:
machine.bootloader(elems)
