mpflash 0.9.0__py3-none-any.whl → 0.9.1.post1__py3-none-any.whl

mpflash/add_firmware.py

@@ -11,7 +11,7 @@ from mpremote.mip import _rewrite_url as rewrite_url  # type: ignore
 
 from mpflash.common import FWInfo
 from mpflash.config import config
-from mpflash.vendor.versions import get_preview_mp_version, get_stable_mp_version
+from mpflash.versions import get_preview_mp_version, get_stable_mp_version
 
 
 def add_firmware(

mpflash/ask_input.py

@@ -14,7 +14,7 @@ from .config import config
 from .mpboard_id import (get_known_boards_for_port, get_known_ports,
                          known_stored_boards)
 from .mpremoteboard import MPRemoteBoard
-from .vendor.versions import micropython_versions
+from .versions import micropython_versions
 
 
 def ask_missing_params(

mpflash/{vendor/basicgit.py → basicgit.py}

@@ -14,13 +14,11 @@ from github import Auth, Github
 from loguru import logger as log
 from packaging.version import parse
 
-# from stubber.utils.versions import SET_PREVIEW
+# from mpflash.versions import SET_PREVIEW
 
 # Token with no permissions to avoid throttling
 # https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api?apiVersion=2022-11-28#getting-a-higher-rate-limit
-PAT_NO_ACCESS = (
-    "github_pat" + "_11AAHPVFQ0qAkDnSUaMKSp" + "_ZkDl5NRRwBsUN6EYg9ahp1Dvj4FDDONnXVgimxC2EtpY7Q7BUKBoQ0Jq72X"
-)
+PAT_NO_ACCESS = "github_pat" + "_11AAHPVFQ0qAkDnSUaMKSp" + "_ZkDl5NRRwBsUN6EYg9ahp1Dvj4FDDONnXVgimxC2EtpY7Q7BUKBoQ0Jq72X"
 PAT = os.environ.get("GITHUB_TOKEN") or PAT_NO_ACCESS
 GH_CLIENT = Github(auth=Auth.Token(PAT))
 
@@ -37,9 +35,7 @@ def _run_local_git(
         if repo:
             if isinstance(repo, str):
                 repo = Path(repo)
-            result = subprocess.run(
-                cmd, capture_output=capture_output, check=True, cwd=repo.absolute().as_posix(), encoding="utf-8"
-            )
+            result = subprocess.run(cmd, capture_output=capture_output, check=True, cwd=repo.absolute().as_posix(), encoding="utf-8")
         else:
             result = subprocess.run(cmd, capture_output=capture_output, check=True, encoding="utf-8")
     except (NotADirectoryError, FileNotFoundError) as e:  # pragma: no cover

mpflash/bootloader/__init__.py

@@ -1,37 +1,2 @@
-import time
-
-from mpflash.common import BootloaderMethod
-from mpflash.errors import MPFlashError
-from mpflash.logger import log
-from mpflash.mpremoteboard import MPRemoteBoard
-
-from .manual import enter_bootloader_manual
-from .micropython import enter_bootloader_mpy
-from .touch1200 import enter_bootloader_cdc_1200bps
-
-
-def enter_bootloader(
-    mcu: MPRemoteBoard,
-    method: BootloaderMethod = BootloaderMethod.MPY,
-    timeout: int = 10,
-    wait_after: int = 2,
-):
-    """Enter the bootloader mode for the board"""
-    if method == BootloaderMethod.NONE:
-        # NO bootloader requested, so must be OK to flash
-        return True
-
-    log.info(f"Entering bootloader on {mcu.board} on {mcu.serialport} using method: {method.value}")
-    if method == BootloaderMethod.MPY:
-        result = enter_bootloader_mpy(mcu, timeout=timeout)
-    elif method == BootloaderMethod.MANUAL:
-        result = enter_bootloader_manual(mcu, timeout=timeout)
-    elif method == BootloaderMethod.TOUCH_1200:
-        result = enter_bootloader_cdc_1200bps(mcu, timeout=timeout)
-    else:
-        raise MPFlashError(f"Unknown bootloader method {method}")
-    if result:
-        time.sleep(wait_after)
-    else:
-        log.error(f"Failed to enter bootloader on {mcu.serialport}")
-    return result
+from .activate import enter_bootloader  # type: ignore
+from .detect import in_bootloader  # type: ignore

mpflash/bootloader/activate.py

@@ -0,0 +1,60 @@
+import time
+
+from mpflash.bootloader.detect import in_bootloader
+from mpflash.common import BootloaderMethod
+from mpflash.errors import MPFlashError
+from mpflash.logger import log
+from mpflash.mpremoteboard import MPRemoteBoard
+
+from .manual import enter_bootloader_manual
+from .micropython import enter_bootloader_mpy
+from .touch1200 import enter_bootloader_touch_1200bps
+
+BL_OPTIONS = {
+    "stm32": [BootloaderMethod.TOUCH_1200, BootloaderMethod.MPY, BootloaderMethod.MANUAL],
+    "rp2": [BootloaderMethod.TOUCH_1200, BootloaderMethod.MPY, BootloaderMethod.MANUAL],
+    "samd": [BootloaderMethod.TOUCH_1200, BootloaderMethod.MPY, BootloaderMethod.MANUAL],
+    "esp32": [BootloaderMethod.NONE],
+    "esp8266": [BootloaderMethod.NONE],
+}
+
+
+def enter_bootloader(
+    mcu: MPRemoteBoard,
+    method: BootloaderMethod = BootloaderMethod.MPY,
+    timeout: int = 10,
+    wait_after: int = 2,
+):
+    """Enter the bootloader mode for the board"""
+    if method == BootloaderMethod.NONE:
+        # NO bootloader requested, so must be OK to flash
+        return True
+    elif method == BootloaderMethod.AUTO:
+        # build a list of options to try for this board
+        bl_list = BL_OPTIONS.get(mcu.port, [BootloaderMethod.MPY, BootloaderMethod.MANUAL])
+    else:
+        bl_list = [method, BootloaderMethod.MANUAL]
+    log.info(f"Entering bootloader on {mcu.serialport} using methods {[bl.value for bl in bl_list]}")
+    for method in bl_list:
+        try:
+            if method == BootloaderMethod.MPY:
+                result = enter_bootloader_mpy(mcu, timeout=timeout)
+            elif method == BootloaderMethod.MANUAL:
+                result = enter_bootloader_manual(mcu, timeout=timeout)
+            elif method == BootloaderMethod.TOUCH_1200:
+                result = enter_bootloader_touch_1200bps(mcu, timeout=timeout)
+        except MPFlashError as e:
+            log.warning(f"Failed to enter bootloader on {mcu.serialport} using {method.value}")
+            log.exception(e)
+            result = False
+        if not result:
+            # try a next method
+            continue
+
+        # todo - check every second or so for up to max wait time
+        time.sleep(wait_after)
+        # check if bootloader was entered
+        if in_bootloader(mcu):
+            return True
+
+    return result

mpflash/bootloader/detect.py

@@ -0,0 +1,82 @@
+""" Detect if a board is in bootloader mode 
+"""
+
+import os
+
+from mpflash.common import PORT_FWTYPES
+from mpflash.flash.uf2 import waitfor_uf2
+from mpflash.logger import log
+from mpflash.mpremoteboard import MPRemoteBoard
+
+
+def in_bootloader(mcu: MPRemoteBoard) -> bool:
+    """Check if the board is in bootloader mode"""
+    if ".uf2" in PORT_FWTYPES[mcu.port]:
+        return in_uf2_bootloader(mcu.port.upper())
+    elif mcu.port in ["stm32"]:
+        return in_stm32_bootloader()
+    elif mcu.port in ["esp32", "esp8266"]:
+        log.debug("esp32/esp8266 does not have a bootloader mode, Assume OK to flash")
+        return True
+
+    log.error(f"Bootloader mode not supported on {mcu.board} on {mcu.serialport}")
+    return False
+
+
+def in_uf2_bootloader(board_id: str) -> bool:
+    """
+    Check if the board is in UF2 bootloader mode.
+
+    :param board_id: The board ID to check for (SAMD or RP2)
+    """
+    return bool(waitfor_uf2(board_id=board_id))
+
+
+def in_stm32_bootloader() -> bool:
+    """Check if the board is in STM32 bootloader mode"""
+    if os.name == "nt":
+        driver_installed, status = check_for_stm32_bootloader_device()
+        if not driver_installed:
+            log.warning("STM32  BOOTLOADER device not found.")
+            return False
+        print()
+        if status != "OK":
+            log.warning(f"STM32 BOOTLOADER device found, Device status: {status}")
+            log.error("Please use Zadig to install a WinUSB (libusb)  driver.\nhttps://github.com/pbatard/libwdi/wiki/Zadig")
+            return False
+    return check_dfu_devices()
+
+
+def check_dfu_devices():
+    """Check if there are any DFU devices connected"""
+    # JIT import
+    from mpflash.flash.stm32_dfu import dfu_init
+    from mpflash.vendor.pydfu import get_dfu_devices
+
+    # need to init on windows to get the right usb backend
+    dfu_init()
+    devices = get_dfu_devices()
+    return len(devices) > 0
+
+
+def check_for_stm32_bootloader_device():
+    import win32com.client
+
+    # Windows only
+    # Create a WMI interface object
+    wmi = win32com.client.GetObject("winmgmts:")
+
+    # Query for USB devices
+    for usb_device in wmi.InstancesOf("Win32_PnPEntity"):
+        try:
+            # Check if device name or description contains "STM32 BOOTLOADER"
+            if str(usb_device.Name).strip() in {
+                "STM32  BOOTLOADER",
+                "STM BOOTLOADER",
+            }:
+                # Just the first match is enough
+                return True, usb_device.Status
+        except Exception:
+            pass
+    # If no matching device was found
+    return False, "Not found."

mpflash/bootloader/manual.py

@@ -12,13 +12,14 @@ from mpflash.mpremoteboard import MPRemoteBoard
 
 
 class MCUHighlighter(RegexHighlighter):
-    """Apply style to anything that looks like an email."""
+    """Apply style to things that should stand out."""
 
     base_style = "mcu."
     highlights = [
         r"(?P<bold>Method[\s\d\:]*)",
         r"(?P<bold> \d.)",  # numbered items
         r"(?P<bold> - )",  # bullets
+        # mcu things
         r"(?P<pad>GPIO[\d]*)",
         r"(?P<pad>GPI[\d]*)",
         r"(?P<pad>IO[\d]*)",
@@ -33,21 +34,19 @@ class MCUHighlighter(RegexHighlighter):
         r"(?P<button>reset)",
         # other
         r"(?P<cable>USB)",
-        # r"(?P<mcu>SAMD[\d]*)",
-        # r"(?P<mcu>ESP[\d]*)",
-        # r"(?P<mcu>rp2)",
-        # r"(?P<mcu>rp2040)",
+        r"(?P<cable>USB-C)",
+        r"(?P<cable>Serial)",
     ]
 
 
 # https://rich.readthedocs.io/en/stable/appendix/colors.html?highlight=colors#standard-colors
+# use 3 colors to keep things simple but clear
 mcu_theme = Theme(
     {
-        "mcu.bold": "orange3",
-        "mcu.mcu": "orange3",
-        "mcu.button": "bold green",
-        "mcu.pad": "dodger_blue2",
-        "mcu.cable": "dodger_blue2",
+        "mcu.bold": "orange3",  # readers guidance
+        "mcu.button": "bold green",  # things to press
+        "mcu.pad": "dodger_blue2",  # things to connect
+        "mcu.cable": "dodger_blue2",  # things to connect
     }
 )
 
@@ -84,7 +83,7 @@ Please put your {mcu.port.upper()} device into bootloader mode by:
 """
 
     # todo: would be nice to re-use the console instance from logger
-    console = Console(highlighter=MCUHighlighter(), theme=mcu_theme)
+    console = Console(highlighter=MCUHighlighter(), theme=mcu_theme)  # type: ignore
     message += "\nIf you are unsure how to enter bootloader mode, please refer to the device documentation."
     console.print(
         Panel(

mpflash/bootloader/micropython.py

@@ -1,10 +1,12 @@
 """Module for handling the bootloader mode for micropython boards"""
 
+from mpflash.logger import log
 from mpflash.mpremoteboard import MPRemoteBoard
 
 
 def enter_bootloader_mpy(mcu: MPRemoteBoard, timeout: int = 10):
     """Enter the bootloader mode for the board using mpremote and micropython on the board"""
+    log.info(f"Attempting bootloader on {mcu.serialport} using 'mpremote bootloader'")
     mcu.run_command("bootloader", timeout=timeout)
     # todo: check if mpremote command was successful
     return True

mpflash/bootloader/touch1200.py

@@ -1,4 +1,8 @@
-import sys
+"""
+Enter bootloader using Touch 1200Bd for boards with bootloaders that support this.
+
+"""
+
 import time
 
 import serial
@@ -7,32 +11,19 @@ from mpflash.errors import MPFlashError
 from mpflash.logger import log
 from mpflash.mpremoteboard import MPRemoteBoard
 
-from .manual import enter_bootloader_manual
-
 
-def enter_bootloader_cdc_1200bps(mcu: MPRemoteBoard, timeout: int = 10):
-    if sys.platform == "win32":
-        log.warning("Touch 1200bps method is currently not supported on Windows, switching to manual")
-        return enter_bootloader_manual(mcu, timeout=timeout)
-
-    log.info(f"Entering bootloader on {mcu.board} on {mcu.serialport} using CDC 1200bps")
-    # if port argument is present perform soft reset
+def enter_bootloader_touch_1200bps(mcu: MPRemoteBoard, timeout: int = 10):
     if not mcu.serialport:
         raise MPFlashError("No serial port specified")
+    log.info(f"Attempting bootloader on {mcu.serialport} using 'Touch 1200Bd'")
+    # if port argument is present perform soft reset
     # try to initiate serial port connection on PORT with 1200 baudrate
     try:
-        with serial.Serial(
-            port=mcu.serialport,
-            baudrate=1200,
-            parity=serial.PARITY_NONE,
-            stopbits=serial.STOPBITS_ONE,
-            bytesize=serial.EIGHTBITS,
-            rtscts=True,
-        ) as connection:
-            print("Connection established")
-            connection.rts = True
-            connection.dtr = False
-            time.sleep(0.4)
+        com = serial.Serial(mcu.serialport, 1200, dsrdtr=True)
+        com.rts = False  # required
+        com.dtr = False  # might as well
+        time.sleep(0.2)
+        com.close()
 
     except serial.SerialException as e:
         log.exception(e)

mpflash/cli_download.py

@@ -8,7 +8,7 @@ from loguru import logger as log
 from mpflash.connected import connected_ports_boards
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id import find_known_board
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 from .ask_input import ask_missing_params
 from .cli_group import cli

mpflash/cli_flash.py

@@ -8,7 +8,7 @@ from mpflash.common import BootloaderMethod
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id import find_known_board
 from mpflash.mpremoteboard import MPRemoteBoard
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 from .ask_input import ask_missing_params
 from .cli_download import connected_ports_boards
@@ -17,7 +17,7 @@ from .cli_list import show_mcus
 from .common import FlashParams
 from .config import config
 from .flash import flash_list
-from .worklist import (WorkList, full_auto_worklist, manual_worklist,
+from .flash.worklist import (WorkList, full_auto_worklist, manual_worklist,
                        single_auto_worklist)
 
 # #########################################################################################################
@@ -106,7 +106,7 @@ from .worklist import (WorkList, full_auto_worklist, manual_worklist,
     "-bl",
     "bootloader",
     type=click.Choice([e.value for e in BootloaderMethod]),
-    default="mpy",
+    default="auto",
     show_default=True,
     help="""How to enter the (MicroPython) bootloader before flashing.""",
 )

mpflash/cli_group.py

@@ -27,7 +27,7 @@ def cb_verbose(ctx, param, value):
     return value
 
 
-def cb_interactive(ctx, param, value:bool):
+def cb_interactive(ctx, param, value: bool):
     log.trace(f"Setting interactive mode to {value}")
     config.interactive = value
     return value
@@ -39,6 +39,10 @@ def cb_test(ctx, param, value):
         config.tests = value
     return value
 
+def cb_usb(ctx, param, value: bool):
+    config.usb = bool(value)
+    return value
+
 
 def cb_quiet(ctx, param, value):
     log.trace(f"Setting quiet mode to {value}")
@@ -78,19 +82,28 @@ def cb_quiet(ctx, param, value):
     help="Enables verbose mode.",
     callback=cb_verbose,
 )
+@click.option(
+    "--usb",
+    "-u",
+    is_eager=True,
+    is_flag=True,
+    default=False,
+    help="Shows USB location of the connected boards.",
+    callback=cb_usb,
+    show_default=True,
+)
 @click.option(
     "--test",
     is_eager=True,
-    help="test a specific feature",
+    help="Test a specific feature.",
     callback=cb_test,
     multiple=True,
     default=[],
     envvar="MPFLASH_TEST",
-    show_default=True,
-    metavar="TEST",
+    metavar="FLAG",
 )
 def cli(**kwargs):
-    """mpflash - MicroPython Tool.
+    """mpflash - MicroPython flashing tool.
 
     A CLI to download and flash MicroPython firmware to different ports and boards.
     """

mpflash/cli_main.py

@@ -1,10 +1,8 @@
 """mpflash is a CLI to download and flash MicroPython firmware to various boards."""
 
-# import rich_click as click
-
 import os
 
-import click
+import click.exceptions as click_exceptions
 from loguru import logger as log
 
 from .cli_download import cli_download
@@ -29,10 +27,10 @@ def mpflash():
         except AttributeError as e:
             log.error(f"Error: {e}")
             exit(-1)
-        except click.exceptions.ClickException as e:
+        except click_exceptions.ClickException as e:
             log.error(f"Error: {e}")
             exit(-2)
-        except click.exceptions.Abort as e:
+        except click_exceptions.Abort as e:
             # Aborted - Ctrl-C
             exit(-3)
 

mpflash/common.py

@@ -92,6 +92,7 @@ class DownloadParams(Params):
 
 
 class BootloaderMethod(Enum):
+    AUTO = "auto"
     MANUAL = "manual"
     MPY = "mpy"
     TOUCH_1200 = "touch1200"

mpflash/config.py

@@ -1,11 +1,11 @@
 """centralized configuration for mpflash"""
 
 import os
+from importlib.metadata import version
 from pathlib import Path
 from typing import List
 
 import platformdirs
-from importlib.metadata import version
 
 from mpflash.logger import log
 
@@ -20,6 +20,7 @@ class MPtoolConfig:
 
     quiet: bool = False
     verbose: bool = False
+    usb: bool = False
     ignore_ports: List[str] = []
     firmware_folder: Path = platformdirs.user_downloads_path() / "firmware"
     # test options specified on the commandline

mpflash/connected.py

@@ -9,9 +9,7 @@ from mpflash.mpremoteboard import MPRemoteBoard
 from .common import filtered_comports
 
 
-def connected_ports_boards(
-    *, include: List[str], ignore: List[str]
-) -> Tuple[List[str], List[str], List[MPRemoteBoard]]:
+def connected_ports_boards(*, include: List[str], ignore: List[str]) -> Tuple[List[str], List[str], List[MPRemoteBoard]]:
     """
     Returns a tuple containing lists of unique ports and boards from the connected MCUs.
     Boards that are physically connected, but give no tangible response are ignored.
@@ -50,11 +48,17 @@ def list_mcus(*, ignore: List[str], include: List[str], bluetooth: bool = False)
         include=include,
         bluetooth=bluetooth,
     )
-    conn_mcus = [MPRemoteBoard(c.device) for c in comports]
+    conn_mcus = [MPRemoteBoard(c.device, location=c.location or "?") for c in comports]
 
     # a lot of boilerplate to show a progress bar with the comport currently scanned
     # low update rate to facilitate screen readers/narration
-    with Progress(rp_spinner, rp_text, rp_bar, TimeElapsedColumn(), refresh_per_second=2) as progress:
+    with Progress(
+        rp_spinner,
+        rp_text,
+        rp_bar,
+        TimeElapsedColumn(),
+        refresh_per_second=1,
+    ) as progress:
         tsk_scan = progress.add_task("[green]Scanning", visible=False, total=None)
         progress.tasks[tsk_scan].fields["device"] = "..."
         progress.tasks[tsk_scan].visible = True

mpflash/download.py

@@ -21,7 +21,7 @@ from rich.progress import track
 from mpflash.common import PORT_FWTYPES, FWInfo
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id import get_known_ports
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 # avoid conflict with the ujson used by MicroPython
 jsonlines.ujson = None  # type: ignore
@@ -134,7 +134,13 @@ def get_boards(ports: List[str], boards: List[str], clean: bool) -> List[FWInfo]
         for board in urls:
             board["port"] = port
 
-        for board in track(urls, description=f"Checking {port} download pages", transient=True, refresh_per_second=2):
+        for board in track(
+            urls,
+            description=f"Checking {port} download pages",
+            transient=True,
+            refresh_per_second=1,
+            show_speed=False,
+        ):
             # add a board to the list for each firmware found
             firmware_urls: List[str] = []
             for ext in PORT_FWTYPES[port]:
@@ -273,9 +279,7 @@ def get_firmware_list(ports: List[str], boards: List[str], versions: List[str],
     log.debug(f"Total {len(board_urls)} firmwares")
 
     relevant = [
-        board
-        for board in board_urls
-        if board.version in versions and board.build == "0" and board.board in boards and not board.preview
+        board for board in board_urls if board.version in versions and board.build == "0" and board.board in boards and not board.preview
     ]
 
     if preview:

mpflash/downloaded.py

@@ -5,7 +5,7 @@ import jsonlines
 from loguru import logger as log
 
 from mpflash.common import PORT_FWTYPES, FWInfo
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 from .config import config
 

mpflash/{flash.py → flash/__init__.py}

@@ -5,9 +5,9 @@ from loguru import logger as log
 from mpflash.bootloader import enter_bootloader
 from mpflash.common import PORT_FWTYPES, BootloaderMethod
 
-from .flash_esp import flash_esp
-from .flash_stm32 import flash_stm32
-from .flash_uf2 import flash_uf2
+from .esp import flash_esp
+from .stm32 import flash_stm32
+from .uf2 import flash_uf2
 from .worklist import WorkList
 
 # #########################################################################################################

mpflash/{flash_esp.py → flash/esp.py}

@@ -53,7 +53,7 @@ def flash_esp(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optio
         log.error(f"Failed to flash {mcu.board} on {mcu.serialport} : {e}")
         return None
 
-    log.info("Done flashing, resetting the board and wait for it to restart")
+    log.info("Done flashing, resetting the board...")
     mcu.wait_for_restart()
     log.success(f"Flashed {mcu.serialport} to {mcu.board} {mcu.version}")
     return mcu

mpflash/{flash_stm32.py → flash/stm32.py}

@@ -4,12 +4,13 @@ from pathlib import Path
 
 from loguru import logger as log
 
-# from .flash_stm32_cube import flash_stm32_cubecli
-from .flash_stm32_dfu import dfu_init, flash_stm32_dfu
 from mpflash.mpremoteboard import MPRemoteBoard
 
+# from .flash_stm32_cube import flash_stm32_cubecli
+from .stm32_dfu import dfu_init, flash_stm32_dfu
+
 
-def flash_stm32(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool, stm32_dfu: bool = True):
+def flash_stm32(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool):
     # sourcery skip: lift-return-into-if
     dfu_init()
     if updated := flash_stm32_dfu(mcu, fw_file=fw_file, erase=erase):

mpflash/{flash_stm32_dfu.py → flash/stm32_dfu.py}

@@ -26,7 +26,7 @@ def init_libusb_windows() -> bool:
 
 
 try:
-    from .vendor import pydfu as pydfu
+    from ..vendor import pydfu as pydfu
 except ImportError:
     pydfu = None