micropython-stubber 1.17.5__py3-none-any.whl → 1.19.0__py3-none-any.whl

mpflash/mpflash/flash.py

@@ -0,0 +1,69 @@
+import time
+from pathlib import Path
+
+from loguru import logger as log
+
+from mpflash.common import PORT_FWTYPES
+from mpflash.mpremoteboard import MPRemoteBoard
+
+from .flash_esp import flash_esp
+from .flash_stm32 import flash_stm32
+from .flash_uf2 import flash_uf2
+from .worklist import WorkList
+
+# #########################################################################################################
+
+
+def flash_list(
+    todo: WorkList,
+    fw_folder: Path,
+    erase: bool,
+    bootloader: bool,
+):
+    """Flash a list of boards with the specified firmware."""
+    flashed = []
+    for mcu, fw_info in todo:
+        fw_file = fw_folder / fw_info["filename"]  # type: ignore
+        if not fw_file.exists():
+            log.error(f"File {fw_file} does not exist, skipping {mcu.board} on {mcu.serialport}")
+            continue
+        log.info(f"Updating {mcu.board} on {mcu.serialport} to {fw_info['version']}")
+        updated = None
+        # try:
+        if mcu.port in [port for port, exts in PORT_FWTYPES.items() if ".uf2" in exts] and fw_file.suffix == ".uf2":
+            # any .uf2 port ["samd", "rp2", "nrf"]:
+            if bootloader:
+                enter_bootloader(mcu)
+            updated = flash_uf2(mcu, fw_file=fw_file, erase=erase)
+        elif mcu.port in ["stm32"]:
+            if bootloader:
+                enter_bootloader(mcu)
+            updated = flash_stm32(mcu, fw_file, erase=erase)
+        elif mcu.port in ["esp32", "esp8266"]:
+            #  bootloader is handled by esptool for esp32/esp8266
+            updated = flash_esp(mcu, fw_file=fw_file, erase=erase)
+        else:
+            log.error(f"Don't (yet) know how to flash {mcu.port}-{mcu.board} on {mcu.serialport}")
+
+        if updated:
+            flashed.append(updated)
+        else:
+            log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")
+    return flashed
+
+
+def enter_bootloader(mcu: MPRemoteBoard, timeout: int = 10, wait_after: int = 2):
+    """Enter the bootloader mode for the board"""
+    log.info(f"Entering bootloader on {mcu.board} on {mcu.serialport}")
+    mcu.run_command("bootloader", timeout=timeout)
+    time.sleep(wait_after)
+
+
+# TODO:
+# flash from some sort of queue to allow different images to be flashed to the same board
+#  - flash variant 1
+#  - stub variant 1
+#  - flash variant 2
+#  - stub variant 2
+#
+# JIT download / download any missing firmwares based on the detected boards

mpflash/mpflash/flash_esp.py

@@ -4,47 +4,42 @@
 # #########################################################################################################
 """
 
-import time
 from pathlib import Path
 from typing import List, Optional
 
 import esptool
 from loguru import logger as log
 
-from stubber.bulk.mpremoteboard import MPRemoteBoard
+from mpflash.mpboard_id import find_stored_board
+from mpflash.mpremoteboard import MPRemoteBoard
 
 
-def flash_esp(
-    mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True
-) -> Optional[MPRemoteBoard]:
+def flash_esp(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optional[MPRemoteBoard]:
     if mcu.port not in ["esp32", "esp8266"] or mcu.board in ["ARDUINO_NANO_ESP32"]:
-        log.error(
-            f"esptool not supported for {mcu.port} {mcu.board} on {mcu.serialport}"
-        )
+        log.error(f"esptool not supported for {mcu.port} {mcu.board} on {mcu.serialport}")
         return None
 
     log.info(f"Flashing {fw_file} on {mcu.board} on {mcu.serialport}")
-    if mcu.port == "esp8266":
-        baud_rate = str(460_800)
-    else:
-        baud_rate = str(512_000)
-        # baud_rate = str(115_200)
+    if not mcu.cpu:
+        # Lookup CPU based on the board name
+        mcu.cpu = find_stored_board(mcu.board)["cpu"]
+
     cmds: List[List[str]] = []
     if erase:
-        cmds.append(
-            f"esptool --chip {mcu.cpu} --port {mcu.serialport} erase_flash".split()
-        )
+        cmds.append(f"esptool --chip {mcu.cpu} --port {mcu.serialport} erase_flash".split())
 
-    if mcu.cpu.upper() in ("ESP32", "ESP32S2"):
-        start_addr = "0x1000"
-    elif mcu.cpu.upper() in ("ESP32S3", "ESP32C3"):
-        start_addr = "0x0"
     if mcu.cpu.upper().startswith("ESP32"):
+        baud_rate = str(921_600)
+        if mcu.cpu.upper() in ("ESP32", "ESP32S2"):
+            start_addr = "0x1000"
+        elif mcu.cpu.upper() in ("ESP32S3", "ESP32C3"):
+            start_addr = "0x0"
         cmds.append(
             f"esptool --chip {mcu.cpu} --port {mcu.serialport} -b {baud_rate} write_flash --compress {start_addr}".split()
             + [str(fw_file)]
         )
     elif mcu.cpu.upper() == "ESP8266":
+        baud_rate = str(460_800)
         start_addr = "0x0"
         cmds.append(
             f"esptool --chip {mcu.cpu} --port {mcu.serialport} -b {baud_rate} write_flash --flash_size=detect {start_addr}".split()
@@ -59,7 +54,6 @@ def flash_esp(
         return None
 
     log.info("Done flashing, resetting the board and wait for it to restart")
-    time.sleep(5)
-    mcu.get_mcu_info()
-    log.success(f"Flashed {mcu.version} to {mcu.board} on {mcu.serialport} done")
+    mcu.wait_for_restart()
+    log.success(f"Flashed {mcu.serialport} to {mcu.board} {mcu.version}")
     return mcu

mpflash/mpflash/flash_stm32.py

@@ -1,121 +1,24 @@
-"""
-Flash STM32 using STM32CubeProgrammer
-needs to be installed independenty from https://www.st.com/en/development-tools/stm32cubeprog.html
+"""Flash STM32 boards using either STM32CubeProgrammer CLI or dfu-util"""
 
-On Linux needs to be run with sudo - because ?
-"""
-
-import subprocess
-import sys
-import time
 from pathlib import Path
-from typing import Optional
 
-import bincopy
 from loguru import logger as log
-from strip_ansi import strip_ansi
-
-from stubber.bulk.mpremoteboard import MPRemoteBoard
-
-STM32_CLI_WIN = "C:\\Program Files\\STMicroelectronics\\STM32Cube\\STM32CubeProgrammer\\bin\\STM32_Programmer_CLI.exe"
-STM32_CLI_LINUX = "/home/jos/STMicroelectronics/STM32Cube/STM32CubeProgrammer/bin/STM32_Programmer_CLI"
-
-
-def get_stm32_start_address(fw_file: Path):
-    """
-    Get the start address of the firmware file, to allow automatic restart from that address after flashing
-    """
-    try:
-        fw_hex = bincopy.BinFile(str(fw_file))
-        return f"0x{fw_hex.execution_start_address:08X}"
-    except Exception:
-
-        return ""
-
-
-def flash_stm32(
-    mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True
-) -> Optional[MPRemoteBoard]:
-    """
-    Flash STM32 devices using STM32CubeProgrammer CLI
-    - Enter bootloader mode
-    - wait 2s for the device to be detected
-    - list the connected DFU devices
 
-    Windows only for now
-    """
-    if sys.platform == "linux":
-        STM32_CLI = STM32_CLI_LINUX
-    elif sys.platform == "win32":
-        STM32_CLI = STM32_CLI_WIN
-    else:
-        log.error(f"OS {sys.platform} not supported")
-        return None
+# from .flash_stm32_cube import flash_stm32_cubecli
+from .flash_stm32_dfu import dfu_init, flash_stm32_dfu
+from mpflash.mpremoteboard import MPRemoteBoard
 
-    if not Path(STM32_CLI).exists():
-        log.error(
-            f"STM32CubeProgrammer not found at {STM32_CLI}\nPlease install it from https://www.st.com/en/development-tools/stm32cubeprog.html"
-        )
-        return None
 
-    log.info(f"Entering STM bootloader on {mcu.board} on {mcu.serialport}")
-    mcu.run_command("bootloader")
-    time.sleep(2)
-    # run STM32_Programmer_CLI.exe --list
-    cmd = [
-        STM32_CLI,
-        "--list",
-    ]
-    results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
-    results = [strip_ansi(line) for line in results]
-    if not any(["Product ID             : STM32  BOOTLOADER" in l for l in results]):
-        log.error("No STM32 BOOTLOADER detected")
-        return None
-    echo = False
-    for line in results:
-        if line.startswith("=====  DFU Interface"):
-            echo = True
-        if line.startswith("===== STLink"):
-            echo = False
-        if echo:
-            print(line)
-    # Try to connect - no action
-    cmd = [
-        STM32_CLI,
-        "--connect",
-        "port=USB1",
-    ]
-    results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
-    if erase:
-        log.info("Erasing flash")
-        cmd = [
-            STM32_CLI,
-            "--connect",
-            "port=USB1",
-            "--erase",
-            "all",
-        ]
-        results = subprocess.run(
-            cmd, capture_output=True, text=True
-        ).stdout.splitlines()
-        results = [strip_ansi(line) for line in results]
-    log.info("Flashing")
-    start_address = get_stm32_start_address(fw_file)
+def flash_stm32(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool, stm32_dfu: bool = True):
+    # sourcery skip: lift-return-into-if
+    log.info("Using dfu-util")
+    dfu_init()
+    updated = flash_stm32_dfu(mcu, fw_file=fw_file, erase=erase)
+    # if stm32_dfu:
+    # else:
+    #     log.info("Using STM32CubeProgrammer CLI")
+    #     updated = flash_stm32_cubecli(mcu, fw_file=fw_file, erase=erase)
 
-    log.trace(
-        f"STM32_Programmer_CLI --connect port=USB1 --write {str(fw_file)} --go {start_address}"
-    )
-    cmd = [
-        STM32_CLI,
-        "--connect",
-        "port=USB1",
-        "--write",
-        str(fw_file),
-        "--go",
-        start_address,
-    ]
-    results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
-    log.success("Done flashing, resetting the board and wait for it to restart")
-    time.sleep(5)
-    mcu.get_mcu_info()
-    return mcu
+    mcu.wait_for_restart()
+    log.success(f"Flashed {mcu.version} to {mcu.board}")
+    return updated

mpflash/mpflash/flash_stm32_cube.py

@@ -0,0 +1,111 @@
+# """
+# Flash STM32 using STM32CubeProgrammer
+# needs to be installed independenty from https://www.st.com/en/development-tools/stm32cubeprog.html
+
+# On Linux needs to be run with sudo - unless udev rules are set to allow access to the device as a regular user
+# """
+
+# import subprocess
+# import sys
+# import time
+# from pathlib import Path
+# from typing import Optional
+
+# import bincopy
+# from loguru import logger as log
+# from rich.progress import track
+# from strip_ansi import strip_ansi
+
+# from .mpremoteboard.mpremoteboard import MPRemoteBoard
+
+# STM32_CLI_WIN = "C:\\Program Files\\STMicroelectronics\\STM32Cube\\STM32CubeProgrammer\\bin\\STM32_Programmer_CLI.exe"
+# STM32_CLI_LINUX = "~/STMicroelectronics/STM32Cube/STM32CubeProgrammer/bin/STM32_Programmer_CLI"
+
+
+# def get_stm32_start_address(fw_file: Path):
+#     """
+#     Get the start address of the firmware file, to allow automatic restart from that address after flashing
+#     """
+#     try:
+#         fw_hex = bincopy.BinFile(str(fw_file))
+#         return f"0x{fw_hex.execution_start_address:08X}"
+#     except Exception:
+
+#         return ""
+
+
+# def flash_stm32_cubecli(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optional[MPRemoteBoard]:
+#     """
+#     Flash STM32 devices using STM32CubeProgrammer CLI
+#     - Enter bootloader mode
+#     - wait 2s for the device to be detected
+#     - list the connected DFU devices
+
+#     On Linux: requires udev rules to allow access to the device as a regular user
+#     """
+#     if sys.platform == "linux":
+#         STM32_CLI = Path(STM32_CLI_LINUX).expanduser().as_posix()
+#     elif sys.platform == "win32":
+#         STM32_CLI = str(Path(STM32_CLI_WIN).expanduser())
+#     else:
+#         log.error(f"OS {sys.platform} not supported")
+#         return None
+
+#     if not Path(STM32_CLI).exists():
+#         log.error(
+#             f"STM32CubeProgrammer not found at {STM32_CLI}\nPlease install it from https://www.st.com/en/development-tools/stm32cubeprog.html"
+#         )
+#         return None
+
+#     # run STM32_Programmer_CLI.exe --list
+#     cmd = [
+#         STM32_CLI,
+#         "--list",
+#     ]
+#     results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
+#     results = [strip_ansi(line) for line in results]
+#     if not any(["Product ID             : STM32  BOOTLOADER" in l for l in results]):
+#         log.error("No STM32 BOOTLOADER detected")
+#         return None
+#     echo = False
+#     for line in results:
+#         if line.startswith("=====  DFU Interface"):
+#             echo = True
+#         if line.startswith("===== STLink"):
+#             echo = False
+#         if echo:
+#             print(line)
+#     # Try to connect - no action
+#     cmd = [
+#         STM32_CLI,
+#         "--connect",
+#         "port=USB1",
+#     ]
+#     results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
+#     if erase:
+#         log.info("Erasing flash")
+#         cmd = [
+#             STM32_CLI,
+#             "--connect",
+#             "port=USB1",
+#             "--erase",
+#             "all",
+#         ]
+#         results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
+#         results = [strip_ansi(line) for line in results]
+#     log.info(f"Flashing {fw_file.name} using STM32CubeProgrammer CLI")
+#     start_address = get_stm32_start_address(fw_file)
+
+#     log.trace(f"STM32_Programmer_CLI --connect port=USB1 --write {str(fw_file)} --go {start_address}")
+#     cmd = [
+#         STM32_CLI,
+#         "--connect",
+#         "port=USB1",
+#         "--write",
+#         str(fw_file),
+#         "--go",
+#         start_address,
+#     ]
+#     results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
+#     log.success("Done flashing, resetting the board and wait for it to restart")
+#     return mcu

mpflash/mpflash/flash_stm32_dfu.py

@@ -0,0 +1,101 @@
+import platform
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger as log
+
+from mpflash.mpremoteboard import MPRemoteBoard
+
+
+def init_libusb_windows() -> bool:
+    """
+    Initializes the libusb backend on Windows.
+
+    Returns:
+        bool: True if the initialization is successful, False otherwise.
+    """
+    import libusb  # type: ignore
+    import usb.backend.libusb1 as libusb1
+
+    arch = "x64" if platform.architecture()[0] == "64bit" else "x86"
+    libusb1_dll = Path(libusb.__file__).parent / f"_platform\\_windows\\{arch}\\libusb-1.0.dll"
+    if not libusb1_dll.exists():
+        raise FileNotFoundError(f"libusb1.dll not found at {libusb1_dll}")
+    backend = libusb1.get_backend(find_library=lambda x: libusb1_dll.as_posix())
+    return backend is not None
+
+
+try:
+    from .vendor import pydfu as pydfu
+except ImportError:
+    pydfu = None
+
+
+def dfu_init():
+    """
+    Initializes the DFU (Device Firmware Upgrade) process.
+    """
+    if not pydfu:
+        log.error("pydfu not found")
+        return None
+    if platform.system() == "Windows":
+        init_libusb_windows()
+
+
+def flash_stm32_dfu(
+    mcu: MPRemoteBoard,
+    fw_file: Path,
+    *,
+    erase: bool = True,
+) -> Optional[MPRemoteBoard]:
+    """
+    Flashes the STM32 microcontroller using DFU (Device Firmware Upgrade).
+
+    Args:
+        mcu (MPRemoteBoard): The remote board to flash.
+        fw_file (Path): The path to the firmware file (.dfu).
+        erase (bool, optional): Whether to erase the memory before flashing. Defaults to True.
+
+    Returns:
+        Optional[MPRemoteBoard]: The flashed remote board if successful, None otherwise.
+    """
+    if not pydfu:
+        log.error("pydfu not found, please install it with 'pip install pydfu' if supported")
+        return None
+
+    if not fw_file.exists():
+        log.error(f"File {fw_file} not found")
+        return None
+
+    if fw_file.suffix != ".dfu":
+        log.error(f"File {fw_file} is not a .dfu file")
+        return None
+
+    kwargs = {"idVendor": 0x0483, "idProduct": 0xDF11}
+    log.debug("List SPECIFIED DFU devices...")
+    try:
+        pydfu.list_dfu_devices(**kwargs)
+    except ValueError as e:
+        log.error(f"Insuffient permissions to access usb DFU devices: {e}")
+        return None
+
+    # Needs to be a list of serial ports
+    log.debug("Inititialize pydfu...")
+    pydfu.init(**kwargs)
+
+    if erase:
+        log.info("Mass erase...")
+        pydfu.mass_erase()
+
+    log.debug("Read DFU file...")
+    elements = pydfu.read_dfu_file(fw_file)
+    if not elements:
+        print("No data in dfu file")
+        return
+    log.info("Writing memory...")
+    pydfu.write_elements(elements, False, progress=pydfu.cli_progress)
+
+    log.debug("Exiting DFU...")
+    pydfu.exit_dfu()
+    log.success("Done flashing, resetting the board and wait for it to restart")
+    return mcu

mpflash/mpflash/flash_uf2.py

@@ -9,8 +9,9 @@ from pathlib import Path
 from typing import Optional
 
 from loguru import logger as log
+from rich.progress import track
 
-from stubber.bulk.mpremoteboard import MPRemoteBoard
+from mpflash.mpremoteboard import MPRemoteBoard
 
 from .common import PORT_FWTYPES
 from .flash_uf2_linux import dismount_uf2, wait_for_UF2_linux
@@ -30,21 +31,19 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
     pmount and pumount are used to mount and unmount the drive
     as this is not done automatically by the OS in headless mode.
     """
-    if PORT_FWTYPES[mcu.port] not in [".uf2"]:
+    if ".uf2" not in PORT_FWTYPES[mcu.port]:
         log.error(f"UF2 not supported on {mcu.board} on {mcu.serialport}")
         return None
     if erase:
         log.info("Erasing not yet implemented for UF2 flashing.")
 
-    log.info(f"Entering UF2 bootloader on {mcu.board} on {mcu.serialport}")
-    mcu.run_command("bootloader", timeout=10)
-
     if sys.platform == "linux":
         destination = wait_for_UF2_linux()
     elif sys.platform == "win32":
         destination = wait_for_UF2_windows()
     else:
-        log.error(f"OS {sys.platform} not supported")
+        log.warning(f"OS {sys.platform} not tested/supported")
+        destination = wait_for_UF2_linux()
         return None
 
     if not destination or not destination.exists() or not (destination / "INFO_UF2.TXT").exists():
@@ -55,7 +54,8 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
     log.info(f"Copying {fw_file} to {destination}.")
     shutil.copy(fw_file, destination)
     log.success("Done copying, resetting the board and wait for it to restart")
-    if sys.platform == "linux":
+    if sys.platform in ["linux", "darwin"]:
         dismount_uf2()
-    time.sleep(5 * 2)  # 5 secs to short on linux
+    for _ in track(range(5 + 2)):
+        time.sleep(1)  # 5 secs to short on linux
     return mcu

mpflash/mpflash/flash_uf2_linux.py

@@ -1,12 +1,18 @@
+""" Flashing UF2 based MCU on Linux"""
+
+# sourcery skip: snake-case-functions
 from __future__ import annotations
-from pathlib import Path
+
 import subprocess
 import sys
 import time
+from pathlib import Path
+from typing import List
+
 from loguru import logger as log
+from rich.progress import track
 
-from typing import List
-from .uf2_boardid import get_board_id
+from .flash_uf2_boardid import get_board_id
 
 glb_dismount_me: List[UF2Disk] = []
 
@@ -74,10 +80,10 @@ def pmount(disk: UF2Disk):
         except FileNotFoundError:
             log.error("pmount not found, please install it using 'sudo apt install pmount'")
             return
-        log.info(f"Mounted {disk.label} at {disk.mountpoint}")
+        log.debug(f"Mounted {disk.label} at {disk.mountpoint}")
         glb_dismount_me.append(disk)
     else:
-        log.warning(f"{disk.label} already mounted at {disk.mountpoint}")
+        log.debug(f"\n{disk.label} already mounted at {disk.mountpoint}")
 
 
 def pumount(disk: UF2Disk):
@@ -102,20 +108,27 @@ def dismount_uf2():
     glb_dismount_me = []
 
 
-def wait_for_UF2_linux():
+def wait_for_UF2_linux(s_max: int = 10):
     destination = ""
     wait = 10
     uf2_drives = []
-    while not destination and wait > 0:
-        log.info(f"Waiting for mcu to mount as a drive : {wait} seconds left")
+    # while not destination and wait > 0:
+    for _ in track(range(s_max), description="Waiting for mcu to mount as a drive", transient=True):
+        # log.info(f"Waiting for mcu to mount as a drive : {wait} seconds left")
         uf2_drives += list(get_uf2_drives())
         for drive in get_uf2_drives():
             pmount(drive)
             time.sleep(1)
-            if Path(drive.mountpoint, "INFO_UF2.TXT").exists():
-                board_id = get_board_id(Path(drive.mountpoint))  # type: ignore
-                destination = Path(drive.mountpoint)
-                break
+            try:
+                if Path(drive.mountpoint, "INFO_UF2.TXT").exists():
+                    board_id = get_board_id(Path(drive.mountpoint))  # type: ignore
+                    destination = Path(drive.mountpoint)
+                    break
+            except PermissionError:
+                log.debug(f"Permission error on {drive.mountpoint}")
+                continue
+        if destination:
+            break
         time.sleep(1)
         wait -= 1
     return destination

mpflash/mpflash/flash_uf2_windows.py

@@ -1,22 +1,34 @@
+# sourcery skip: snake-case-functions
+"""Flash a MCU with a UF2 bootloader on Windows"""
+
 from __future__ import annotations
-from pathlib import Path
+
 import time
+from pathlib import Path
+
 import psutil
-from loguru import logger as log
-from .uf2_boardid import get_board_id
+from rich.progress import track
+
+from .flash_uf2_boardid import get_board_id
 
 
-def wait_for_UF2_windows():
+def wait_for_UF2_windows(s_max: int = 10):
+    """Wait for the MCU to mount as a drive"""
+    if s_max < 1:
+        s_max = 10
     destination = ""
-    wait = 10
-    while not destination and wait > 0:
-        log.info(f"Waiting for mcu to mount as a drive : {wait} seconds left")
+    for _ in track(range(s_max), description="Waiting for mcu to mount as a drive", transient=True):
+        # log.info(f"Waiting for mcu to mount as a drive : {n} seconds left")
         drives = [drive.device for drive in psutil.disk_partitions()]
         for drive in drives:
-            if Path(drive, "INFO_UF2.TXT").exists():
-                board_id = get_board_id(Path(drive))  # type: ignore
-                destination = Path(drive)
-                break
+            try:
+                if Path(drive, "INFO_UF2.TXT").exists():
+                    board_id = get_board_id(Path(drive))  # type: ignore
+                    destination = Path(drive)
+                    break
+            except OSError:
+                pass
+        if destination:
+            break
         time.sleep(1)
-        wait -= 1
     return destination