micropython-stubber 1.17.6__py3-none-any.whl → 1.20.0__py3-none-any.whl

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), description="Waiting for the board to restart", transient=True):
+        time.sleep(1)  # 5 secs to short on linux
     return mcu

mpflash/mpflash/flash_uf2_linux.py

@@ -1,3 +1,6 @@
+""" Flashing UF2 based MCU on Linux"""
+
+# sourcery skip: snake-case-functions
 from __future__ import annotations
 
 import subprocess
@@ -7,8 +10,9 @@ from pathlib import Path
 from typing import List
 
 from loguru import logger as log
+from rich.progress import track
 
-from .uf2_boardid import get_board_id
+from .flash_uf2_boardid import get_board_id
 
 glb_dismount_me: List[UF2Disk] = []
 
@@ -76,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):
@@ -104,12 +108,13 @@ 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)
@@ -122,6 +127,8 @@ def wait_for_UF2_linux():
             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

mpflash/mpflash/list.py

@@ -1,71 +1,88 @@
-import json
 from typing import List
 
-import rich_click as click
 from rich import print
-from rich.progress import track
-from rich.table import Table
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn, track
+from rich.table import Column, Table
 
-# TODO: - refactor so that we do not need the entire stubber package
-from stubber.bulk.mpremoteboard import MPRemoteBoard
+from mpflash.mpremoteboard import MPRemoteBoard
 
-from .cli_group import cli
 from .config import config
+from .logger import console
 
+rp_spinner = SpinnerColumn(finished_text="✅")
+rp_text = TextColumn("{task.description} {task.fields[device]}", table_column=Column())
+rp_bar = BarColumn(bar_width=None, table_column=Column())
 
-@cli.command("list", help="List the connected boards.")
-@click.option(
-    "--json",
-    "-j",
-    "as_json",
-    is_flag=True,
-    default=False,
-    show_default=True,
-    help="""Output in json format""",
-)
-def list_boards(as_json: bool):
-    conn_boards = [MPRemoteBoard(sp) for sp in MPRemoteBoard.connected_boards() if sp not in config.ignore_ports]
 
-    for mcu in track(conn_boards, description="Getting board info"):
+def list_mcus(bluetooth: bool = False):
+    """
+    Retrieves information about connected microcontroller boards.
+
+    Returns:
+        List[MPRemoteBoard]: A list of MPRemoteBoard instances with board information.
+    Raises:
+        ConnectionError: If there is an error connecting to a board.
+    """
+    conn_mcus = [MPRemoteBoard(sp) for sp in MPRemoteBoard.connected_boards(bluetooth) if sp not in config.ignore_ports]
+
+    # a lot of boilerplate to show a progress bar with the comport currenlty scanned
+    with Progress(rp_spinner, rp_text, rp_bar, TimeElapsedColumn()) 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
+        progress.start_task(tsk_scan)
         try:
-            mcu.get_mcu_info()
-        except ConnectionError as e:
-            print(f"Error: {e}")
-            continue
-    if as_json:
-        print(json.dumps([mcu.__dict__ for mcu in conn_boards], indent=4))
-    else:
-        show_boards(conn_boards, refresh=False)
+            for mcu in conn_mcus:
+                progress.update(tsk_scan, device=mcu.serialport.replace("/dev/", ""))
+                try:
+                    mcu.get_mcu_info()
+                except ConnectionError as e:
+                    print(f"Error: {e}")
+                    continue
+        finally:
+            # transient
+            progress.stop_task(tsk_scan)
+            progress.tasks[tsk_scan].visible = False
+    return conn_mcus
 
 
-def show_boards(
-    conn_boards: List[MPRemoteBoard],
+def show_mcus(
+    conn_mcus: List[MPRemoteBoard],
     title: str = "Connected boards",
     refresh: bool = True,
-):
+):  # sourcery skip: extract-duplicate-method
     """Show the list of connected boards in a nice table"""
-    table = Table(title=title)
-    table.add_column("Serial")
+    table = Table(
+        title=title,
+        title_style="magenta",
+        header_style="bold magenta",
+        collapse_padding=True,
+        width=110,
+    )
+    table.add_column("Serial", overflow="fold")
     table.add_column("Family")
     table.add_column("Port")
-    table.add_column("Board")
+    table.add_column("Board", overflow="fold")
+    # table.add_column("Variant") # TODO: add variant
     table.add_column("CPU")
     table.add_column("Version")
-    table.add_column("build")
+    table.add_column("build", justify="right")
 
-    for mcu in track(conn_boards, transient=True, description="Updating board info"):
+    for mcu in track(conn_mcus, description="Updating board info", transient=True, update_period=0.1):
         if refresh:
             try:
                 mcu.get_mcu_info()
             except ConnectionError:
                 continue
+        description = f"[italic bright_cyan]{mcu.description}" if mcu.description else ""
         table.add_row(
-            mcu.serialport,
+            mcu.serialport.replace("/dev/", ""),
             mcu.family,
             mcu.port,
-            mcu.board,
+            f"{mcu.board}\n{description}".strip(),
+            # mcu.variant,
             mcu.cpu,
             mcu.version,
             mcu.build,
         )
-    print(table)
+    console.print(table)

mpflash/mpflash/logger.py

@@ -1,13 +1,15 @@
-import sys
+"""Logging."""
 
 from loguru import logger as log
 from rich.console import Console
 
+from .config import config
+
 console = Console()
 
 
 def _log_formatter(record: dict) -> str:
-    """Log message formatter"""
+    """Log message formatter to combine loguru and rich formatting."""
     color_map = {
         "TRACE": "dim blue",
         "DEBUG": "cyan",
@@ -19,8 +21,7 @@ def _log_formatter(record: dict) -> str:
     }
     lvl_color = color_map.get(record["level"].name, "cyan")
     return (
-        "[not bold green]{time:HH:mm:ss}[/not bold green] | {level.icon}"
-        + f"  - [{lvl_color}]{{message}}[/{lvl_color}]"
+        "[not bold green]{time:HH:mm:ss}[/not bold green] | {level.icon} " + f"[{lvl_color}]{{message}}[/{lvl_color}]"
     )
 
 
@@ -30,13 +31,11 @@ def set_loglevel(loglevel: str):
         log.remove()
     except ValueError:
         pass
-    log.add(
-        console.print, level=loglevel.upper(), colorize=False, format=_log_formatter
-    )
+    log.add(console.print, level=loglevel.upper(), colorize=False, format=_log_formatter)  # type: ignore
+
 
-    # log.add(
-    #     console.print,
-    #     level=loglevel.upper(),
-    #     format=_log_formatter,
-    #     colorize=True,
-    # )
+def make_quiet():
+    """Make the logger quiet"""
+    config.quiet = True
+    console.quiet = True
+    set_loglevel("CRITICAL")