pyflashgui 0.2.0__tar.gz → 0.2.2__tar.gz

{pyflashgui-0.2.0/pyflashgui.egg-info → pyflashgui-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyflashgui
-Version: 0.2.0
+Version: 0.2.2
 Summary: Graphical flash programming tool: Arm Cortex-M with any probe pyOCD supports, and more through J-Link Commander
 Author: davhodg
 License-Expression: Apache-2.0
@@ -29,12 +29,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: PySide6-Essentials>=6.8
-Requires-Dist: pyocd>=0.45
+Requires-Dist: pyocd>=0.46
 Requires-Dist: bincopy>=20.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-xdist; extra == "dev"
-Requires-Dist: ruff==0.16.*; extra == "dev"
+Requires-Dist: ruff==0.17.*; extra == "dev"
 Requires-Dist: trove-classifiers; extra == "dev"
 Dynamic: license-file
 
@@ -97,6 +97,7 @@ A probe is usable without root on Linux once a udev rule allows it; pyOCD publis
 - **Workspaces**: one for each board or project, holding its probe, target, files and layout.
 - **A Python console** with the probe and the target as `flash`: read, write RAM, erase, program, verify and reset from a prompt or a script, each call waiting for its answer. *File > Run script...* runs one, and keeps the last five a click away.
 - **A simulated probe and target**, to try all of it with no hardware.
+- **Help > Diagnostics**: how the connection was made, the last operations in order and what pyOCD reported, ready to paste into a bug report.
 
 The [manual](https://github.com/davhodg/pyflashgui/blob/master/pyflashgui/help/manual.md) covers each of these, and is also under **Help > Documentation** in the application.
 

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/PYPI.md

@@ -57,6 +57,7 @@ A probe is usable without root on Linux once a udev rule allows it; pyOCD publis
 - **Workspaces**: one for each board or project, holding its probe, target, files and layout.
 - **A Python console** with the probe and the target as `flash`: read, write RAM, erase, program, verify and reset from a prompt or a script, each call waiting for its answer. *File > Run script...* runs one, and keeps the last five a click away.
 - **A simulated probe and target**, to try all of it with no hardware.
+- **Help > Diagnostics**: how the connection was made, the last operations in order and what pyOCD reported, ready to paste into a bug report.
 
 The [manual](https://github.com/davhodg/pyflashgui/blob/master/pyflashgui/help/manual.md) covers each of these, and is also under **Help > Documentation** in the application.
 

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/README.md

@@ -126,6 +126,10 @@ pyflashgui can instead drive a J-Link through SEGGER's own J-Link Commander, whi
 
 On Linux a probe is usable without root once a udev rule allows it; pyOCD publishes [a set of them](https://github.com/pyocd/pyOCD/tree/main/udev). Vendor software is never bundled with pyflashgui: install the vendor's own, and pyflashgui finds it.
 
+### Isolating the probe
+
+A USB isolator between the PC and the probe breaks a ground loop between them. [usb2-480mbps-isolator](https://github.com/davhodg/usb2-480mbps-isolator) is an open-source, hand-solderable one in the works, for USB 2.0 at every speed up to 480 Mbit/s, that limits the current it takes to what the PC's port can supply. **Available soon:** it is still being designed, and is for functional isolation only, not certified for safety isolation.
+
 ## Built with
 
 | Package | For | Licence |
@@ -151,6 +155,8 @@ and no way of uninstalling touches them; delete that folder to remove them too.
 
 See [CONTRIBUTING.md](CONTRIBUTING.md): the policy for changes, setting up to work on pyflashgui, running the tests, and building the Windows installer. Everyone taking part is asked to follow the [code of conduct](CODE_OF_CONDUCT.md). Security problems go through [SECURITY.md](SECURITY.md).
 
+What is aimed for with a keyboard, a screen reader, large text and high contrast, what has been checked, and how to report a barrier, is in [ACCESSIBILITY.md](ACCESSIBILITY.md).
+
 ## Safety notice
 
 pyflashgui talks to real equipment. It is intended only for people trained and experienced in working with microcontrollers, debug probes and the equipment they are part of. It is a tool for development and the bench, and is not meant for production programming.

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/pyflashgui/__init__.py

@@ -2,5 +2,5 @@
 # SPDX-FileCopyrightText: 2026 davhodg
 """pyflashgui — a graphical flash programming tool."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 APP_NAME = "pyflashgui"  # single place to change the display name

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/pyflashgui/__main__.py

@@ -89,7 +89,7 @@ def selftest() -> int:
 
     # libusb is a native library carried inside a Python package, which is
     # the kind of file a build leaves behind. Without it pyOCD lists no
-    # CMSIS-DAP v2 probe and no ST-Link, and says nothing about why.
+    # CMSIS-DAP v2 probe and no ST-Link, so the self-test checks for it.
     try:
         import libusb_package
 
@@ -160,7 +160,8 @@ def set_icon(app) -> None:
 
 #: The libraries Qt's X11 plugin needs that Debian, Ubuntu and Linux Mint can
 #: leave out, each with the package it comes in. Without one, Qt stops with
-#: "could not load the Qt platform plugin xcb" and does not say which.
+#: "could not load the Qt platform plugin xcb", so they are looked for first
+#: and the package to install is named.
 XCB_LIBRARIES = (
     ("libxcb-cursor.so.0", "libxcb-cursor0"),
     ("libxcb-icccm.so.4", "libxcb-icccm4"),

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/pyflashgui/backends/base.py

@@ -197,6 +197,16 @@ class Connection(ABC):
     def close(self) -> None:
         """Let go of the probe. Safe to call twice."""
 
+    def details(self) -> list[str]:
+        """What Help > Diagnostics says of this connection, a line each.
+
+        How the backend was asked to connect and what it found there, beyond
+        the probe and the target the window already knows. Read on the
+        window's thread while the worker may be using the connection, so
+        only what is already known is said: nothing here asks the probe.
+        """
+        return []
+
     def read_range(
         self,
         address: int,

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/pyflashgui/backends/jlink_backend.py

@@ -72,13 +72,14 @@ NOT_FOUND = (
 )
 
 #: Said by Commander when the probe is there and the device does not answer.
-#: Looked for as well as its exit code, which has been seen to be 0 with it.
+#: Looked for as well as its exit code, which can be 0 with it.
 NO_TARGET = "Cannot connect to target"
 
-#: A J-Link script that does nothing where SEGGER's software would set the
+#: A J-Link script that does nothing where J-Link's software would set the
 #: device up after connecting to it. On some parts that set-up writes to
 #: the device -- an S32K3's RAM is filled, for its error correction -- and
-#: a read made to see what a running program left there finds it gone.
+#: a read made to see what a running program left there finds the set-up's
+#: bytes instead.
 NO_SETUP_SCRIPT = "int SetupTarget(void) {\n  return 0;\n}\n"
 
 #: Where Commander is, when it has been said. None to go and look.
@@ -146,6 +147,20 @@ def find_commander() -> list[str] | None:
     return None
 
 
+def report() -> list[str]:
+    """For Help > Diagnostics: the Commander used, how it was found, and every
+    J-Link software folder there is, newest first."""
+    found = find_commander()
+    if found is None:
+        lines = ["not found"]
+    else:
+        how = "chosen in Tools > Settings" if _chosen is not None else "found"
+        lines = [f"{' '.join(found)} ({how})"]
+    folders = _installed()
+    lines += [f"installed: {folder}" for folder in folders] or ["no J-Link software folder found"]
+    return lines
+
+
 def _is_seggers(program: Path) -> bool:
     """Whether a program of Commander's name is Commander, and not Java's jlink.
 
@@ -407,6 +422,11 @@ class JLinkConnection(Connection):
     def regions(self) -> list[Region]:
         return list(self._regions)
 
+    def details(self) -> list[str]:
+        if self._arguments is None:
+            return ["closed"]
+        return [f"device: {self._device}", f"Commander run with: {' '.join(self._arguments)}"]
+
     def erase_chip(self) -> None:
         self._run(["H", "Erase"], WORK_S, f"Erasing {self._device}")
 
@@ -535,7 +555,10 @@ class JLinkConnection(Connection):
 
     def reset(self, halt: bool = False, kind: str = RESET_DEFAULT) -> None:
         if kind != RESET_DEFAULT:
-            raise BackendError("J-Link Commander resets each device its own way, and no other.")
+            raise BackendError(
+                "Through J-Link Commander, a device is reset the usual way only. The other "
+                "ways are offered through pyOCD."
+            )
         # R restarts the device and leaves it stopped; G sets it going.
         self._run(["R"] if halt else ["R", "G"], QUICK_S, f"Resetting {self._device}")
 
@@ -581,8 +604,8 @@ class JLinkBackend(Backend):
                 # it that is not, and latin-1 reads any byte there is.
                 text = path.read_text(encoding="latin-1")
             except (BackendError, OSError):
-                # A Commander that will not write the list still programs a
-                # device whose name is typed in.
+                # Without the list, a device whose name is typed in is still
+                # programmed.
                 text = ""
         self._devices = {device.name.upper(): device for device in parse_devices(text)}
         return self._devices

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/pyflashgui/backends/pyocd_backend.py

@@ -7,7 +7,7 @@ exception said again in pyflashgui's words. Anything worth testing without a
 probe plugged in is in ``core`` or in the base class, and what is left here
 can only be tried on hardware.
 
-pyOCD is imported inside the methods that use it. It is the slowest thing
+pyOCD is imported inside the methods that use it. It is the largest thing
 pyflashgui loads, and a window should not wait for it to say which probes
 are plugged in before it can be drawn.
 """
@@ -17,6 +17,7 @@ from __future__ import annotations
 import contextlib
 import time
 from collections.abc import Sequence
+from pathlib import Path
 
 from pyflashgui.backends import pyocd_packs
 from pyflashgui.backends.base import (
@@ -90,9 +91,8 @@ def regions_of(memory_map, generic: bool = False) -> list[Region]:
 def needs_one_packet_at_a_time(*names: str | None) -> bool:
     """Whether a probe called this must be sent one command and then waited for.
 
-    pyOCD's own advice for the TI XDS110, whose firmware loses track when
-    several commands are outstanding. Set for every one of them, since it
-    is not known which versions are free of it, and the cost is only speed.
+    pyOCD's own advice for the TI XDS110: one command at a time. Set for
+    every one of them, as pyOCD advises, and the cost is only speed.
     """
     return any("xds110" in (name or "").lower() for name in names)
 
@@ -144,11 +144,11 @@ def _stages(progress: Progress) -> Progress:
 def _let_go(session) -> Exception | None:
     """Close a pyOCD session, and its probe even where closing the session fails.
 
-    pyOCD's close lets go of the target before the probe, and when the
-    first fails -- the board's power was turned off -- never closes the
-    probe. A J-Link left open that way stays open: Find probes lists it, and
-    every connect says "No emulator with serial number".
-    Returns what went wrong, if anything did.
+    Closing a session lets go of the target, then of the probe. With the
+    board's power turned off, letting go of the target raises, and the probe
+    is still open: a J-Link still open is listed by Find probes, and every
+    connect says "No emulator with serial number". So the probe is closed
+    here as well. Returns what went wrong, if anything did.
     """
     try:
         session.close()
@@ -202,6 +202,44 @@ class PyocdConnection(Connection):
         #: Makes a new session on the same probe and target, attaching to it
         #: as it is, for when a reset has taken the old one with it.
         self._reopen = reopen
+        #: The options pyOCD was given, for Help > Diagnostics.
+        self.options: dict = {}
+        #: How many times a reset took the connection with it and it was made again.
+        self.reattached = 0
+
+    def details(self) -> list[str]:
+        packs = self.options.get("pack") or []
+        given = ", ".join(f"{k}={v}" for k, v in sorted(self.options.items()) if k != "pack")
+        lines = [f"pyOCD options: {given or 'none'}"]
+        if packs:
+            lines.append(f"packs handed to pyOCD: {', '.join(Path(p).name for p in packs)}")
+        if self.reattached:
+            lines.append(f"connected again after a reset: {self.reattached} time(s)")
+        session = self._session
+        if session is None:
+            return [*lines, "session: closed"]
+        target, probe = getattr(session, "target", None), getattr(session, "probe", None)
+        if target is not None:
+            if is_generic(target):
+                where = "no device in particular: the generic Cortex-M"
+            elif "_pack_device" in vars(type(target)):
+                where = "from a pack"
+            else:
+                where = "built in"
+            lines.append(f"target class: {type(target).__name__}, {where}")
+            for core in getattr(target, "cores", {}).values():
+                architecture = getattr(getattr(core, "architecture", None), "name", "")
+                lines.append(
+                    f"core {getattr(core, 'core_number', '?')}: {getattr(core, 'name', '?')}"
+                    + (f" ({architecture})" if architecture else "")
+                )
+        if probe is not None:
+            wire = getattr(getattr(probe, "wire_protocol", None), "name", "") or "not known"
+            lines.append(
+                f"probe: {probe.description}; {type(probe).__name__}; "
+                f"{probe.vendor_name or '?'} {probe.product_name or '?'}; wire protocol {wire}"
+            )
+        return lines
 
     def _target(self):
         if self._session is None:
@@ -277,13 +315,12 @@ class PyocdConnection(Connection):
         """Reset the target and stop it at its first instruction, before a flash
         routine is run on it.
 
-        pyOCD stops the processor wherever it happens to be and runs its
-        routine there. Reported on an XMC4500 attached to its firmware as it
-        ran: stopped amid the firmware, with its interrupts and the rest of
-        what it had set up still on, the erase routine ended in a HardFault
-        (IPSR=3). Reset first, the routine runs on a device as it starts,
-        which is what flash routines are written for, and what SEGGER's own
-        download does.
+        A flash routine runs on the processor as it is when stopped.
+        Reported on an XMC4500 attached to its firmware as it ran: stopped
+        amid the firmware, with its interrupts and the rest of what it had set
+        up still on, the erase routine ended in a HardFault (IPSR=3). Reset
+        first, the routine runs on a device as it starts, which is what flash
+        routines are written for.
         """
         try:
             self._target().reset_and_halt()
@@ -328,9 +365,8 @@ class PyocdConnection(Connection):
                     progress((before + fraction * size) / total)
 
                 # keep_unwritten: the rest of a page written to is read and
-                # written back as it is. Filled instead with what pyOCD takes
-                # erased flash to read as, it would be written to: pyOCD
-                # says FF for an XMC4500, whose erased flash reads 00.
+                # written back as it is, so it holds what it held, whatever
+                # erased flash reads as on this device.
                 builder.program(progress_cb=report, smart_flash=False, keep_unwritten=True)
                 written += size
         except BackendError:
@@ -416,6 +452,7 @@ class PyocdConnection(Connection):
             time.sleep(wait)
             try:
                 self._session = self._reopen()
+                self.reattached += 1
                 break
             except BackendError as exc:
                 failed = exc
@@ -444,7 +481,7 @@ class PyocdConnection(Connection):
 
 class PyocdBackend(Backend):
     # pyOCD's own, whatever the probe could do: 1 MHz, chosen to work with
-    # a long or untidy cable, and slow for anything else.
+    # a long or untidy cable. A faster one can be chosen in the bar.
     default_speed = "Default (1 MHz)"
     can_skip_erase = True
     can_attach = True
@@ -587,6 +624,7 @@ class PyocdBackend(Backend):
         connection = PyocdConnection(session, lambda: self._open(chosen, again, target))
         connection.speed = speed_text(session.options.get("frequency"))
         connection.notes = tuple(notes)
+        connection.options = dict(options)
         return connection
 
     @staticmethod

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/pyflashgui/backends/pyocd_packs.py

@@ -93,7 +93,15 @@ class Device:
     installed: bool
 
 
-def open_cache(tick: Tick | None = None) -> Any:
+#: Called once, when fetching the list moves on from downloading to what
+#: comes after: the library reads every description -- over fifteen hundred --
+#: and writes the list of devices from them, twenty megabytes, which takes
+#: half a minute or so with no count of its own to show.
+Stage = Callable[[str], None]
+PROCESSING = "Processing what was downloaded"
+
+
+def open_cache(tick: Tick | None = None, stage: Stage | None = None) -> Any:
     """pyOCD's own store of packs. Replaced in the tests, which have no network."""
     import cmsis_pack_manager
 
@@ -103,6 +111,14 @@ def open_cache(tick: Tick | None = None) -> Any:
             if tick is not None:
                 tick(current, total or None)
 
+        # The first thing the library does after the last download. Should a
+        # later version of it name this otherwise, it is not called and the
+        # step is not said: nothing else changes.
+        def _call_rust_parse(self, pdsc_index):
+            if stage is not None:
+                stage(PROCESSING)
+            return super()._call_rust_parse(pdsc_index)
+
     return Cache(tick is None, False)
 
 
@@ -158,14 +174,20 @@ def list_fetched() -> datetime | None:
         return None
 
 
-def fetch_list(tick: Tick | None = None) -> int:
-    """Download the index of every pack. Returns how many devices it has."""
-    cache = open_cache(tick)
+def fetch_list(tick: Tick | None = None, stage: Stage | None = None) -> int:
+    """Download the index of every pack. Returns how many devices it has.
+
+    ``stage`` is told when the downloads have ended and what they brought is
+    processed, which is as long again.
+    """
+    cache = open_cache(tick, stage)
     try:
         cache.cache_descriptors()
     except Exception as exc:
         raise _said("Fetching the list of devices", exc) from exc
-    count = len(open_cache().index)
+    # Through the copy kept of it, which the list of packs and the search
+    # that follow then use rather than reading twenty megabytes again.
+    count = len(_index(open_cache()))
     if not count:
         raise PackError(
             "Fetching the list of devices brought nothing back. It comes from the internet: "
@@ -248,9 +270,8 @@ def read_pack(path: Path) -> tuple[Pack, tuple[tuple[str, str], ...]]:
     from xml.etree import ElementTree
 
     # By the way in pyOCD's own modules take, before the part of it wanted
-    # here. Started part way in, pyOCD can import itself in a circle, which
-    # it does not survive; and the backend may be importing it on another
-    # thread at the same moment.
+    # here: its modules are written to be imported from the top, and the
+    # backend may be importing it on another thread at the same moment.
     import pyocd.target  # noqa: F401
     from pyocd.target.pack.cmsis_pack import CmsisPack
 
@@ -263,8 +284,8 @@ def read_pack(path: Path) -> tuple[Pack, tuple[tuple[str, str], ...]]:
                     f"{path.name} is not a CMSIS-Pack: there is no description (.pdsc) in it."
                 )
             root = ElementTree.fromstring(archive.read(min(described, key=lambda n: n.count("/"))))
-            # Read through this archive, which is closed after: one pyOCD opened
-            # itself would stay open, and Windows will not delete an open file.
+            # Read through this archive, which is closed after, so the file can
+            # be removed again: Windows will not delete an open file.
             found = {
                 (d.part_number, (d.vendor or "").split(":")[0]) for d in CmsisPack(archive).devices
             }
@@ -314,6 +335,22 @@ def file_devices() -> list[Device]:
     return out
 
 
+def report() -> list[str]:
+    """For Help > Diagnostics: where the packs are, which there are, and how
+    old the list of devices is. Found from the files, without reading the
+    list itself, which is twenty megabytes."""
+    where = folder()
+    fetched = list_fetched()
+    lines = [
+        f"folder: {where}",
+        f"list of devices fetched {fetched:%Y-%m-%d %H:%M}" if fetched else "list never fetched",
+    ]
+    downloaded = sorted(p.relative_to(where).as_posix() for p in where.rglob("*.pack"))
+    lines += [f"installed: {name}" for name in downloaded] or ["none installed"]
+    lines += [f"added from a file: {p.name}" for p in sorted(files_folder().glob("*.pack"))]
+    return lines
+
+
 def same_name(part: str) -> str:
     """A device's name as pyOCD files it, whichever way it is spelt.
 

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/pyflashgui/core/events.py

@@ -22,6 +22,8 @@ plain text, and nothing has to be imported to name one.
 
 from __future__ import annotations
 
+from datetime import datetime
+
 from PySide6.QtCore import QObject, Signal
 
 INFORMATION = "information"
@@ -43,6 +45,16 @@ LEVELS = (INFORMATION, GOOD, WARNING, ERROR)
 PROBLEMS = (WARNING, ERROR)
 
 
+def with_time(line: str, at: datetime) -> str:
+    """A line with the time of day it was written in front, to the second.
+
+    To the second and no finer: a line is written a moment after it was said,
+    and the time is for reading a log back against a clock, not for timing
+    anything -- erasing, programming and reading say how long they took.
+    """
+    return f"{at:%H:%M:%S} {line}"
+
+
 class EventLog(QObject):
     """The one way in. What listens is somebody else's business."""
 

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/pyflashgui/core/excepthook.py

@@ -3,9 +3,9 @@
 """Put unhandled exceptions in the Event Log instead of nowhere.
 
 pyflashgui is started with ``pythonw.exe``, which has no console. An exception
-raised inside a Qt slot does not propagate anywhere useful: PySide prints the
-traceback to a standard error stream that does not exist, the slot simply
-does not finish, and the window carries on looking perfectly healthy.
+raised inside a Qt slot is printed by PySide to standard error, which pythonw
+does not have: the slot does not finish, and the window carries on looking
+perfectly healthy.
 
 A stale call to a widget method -- ``.text()`` on what had become a combo box
 -- is enough: nothing is logged, no dialog appears, and whatever the slot was
@@ -27,10 +27,9 @@ from PySide6.QtCore import QObject, Qt, QtMsgType, Signal, Slot, qInstallMessage
 
 from pyflashgui.core.events import ERROR, INFORMATION
 
-#: Said of a Python traceback and of nothing else. Qt complains through the
-#: same handler about things that are often not pyflashgui's doing at all -- a
-#: platform plugin, a window manager -- and telling somebody those are bugs in
-#: this application is both wrong and unhelpful.
+#: Said of a Python traceback and of nothing else. Qt reports through the
+#: same handler what other parts of the system say -- a platform plugin, a
+#: window manager -- and those are not faults in this application.
 BUG = "Unhandled error (this is a bug in pyflashgui; the action it interrupted did not finish):"
 
 

{pyflashgui-0.2.0 → pyflashgui-0.2.2}/pyflashgui/core/flasher.py

@@ -16,7 +16,10 @@ from __future__ import annotations
 
 import threading
 import time
+from collections import deque
 from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from datetime import datetime
 from typing import Any
 
 from PySide6.QtCore import QObject, Signal
@@ -47,7 +50,7 @@ RESET_SAID = {
     RESET_CORE: "by restarting its processor only",
 }
 #: How long letting go of the probe is waited for when the window closes, in
-#: seconds: a library that never comes back must not keep the window frozen.
+#: seconds: a probe that does not answer must not keep the window waiting.
 CLOSE_S = 5.0
 
 
@@ -59,6 +62,30 @@ def _close_quietly(connection) -> None:
         pass
 
 
+#: How many operations are remembered for Help > Diagnostics.
+REMEMBERED = 20
+
+
+@dataclass(frozen=True)
+class Operation:
+    """One thing done, or asked for, for Help > Diagnostics to list in order."""
+
+    #: When it was asked for, as a time of day.
+    when: str
+    name: str
+    #: done, failed, cancelled, or not done as asked -- a verify that found
+    #: differences, which is not a failure of the probe.
+    outcome: str
+    #: How long it took, in seconds.
+    took: float
+    #: What it failed with, where it did, as the Event Log said it.
+    said: str = ""
+
+    def line(self) -> str:
+        why = f": {self.said.splitlines()[0]}" if self.said else ""
+        return f"{self.when} {self.name}: {self.outcome}{why}, {self.took:.1f} s"
+
+
 #: Progress is passed on when it has moved this far, and not otherwise: a
 #: library reporting every page would otherwise queue a thousand signals to
 #: move a bar a thousand times by less than a pixel.
@@ -128,6 +155,13 @@ class Flasher(QObject):
         self.regions: list[Region] = []
         self._regions_for = ""
         self.busy = False
+        #: What is being done while busy: "Programming". Empty otherwise.
+        self.doing = ""
+        #: The last few operations, oldest first, for Help > Diagnostics: the
+        #: order things happened in is most of what a fault report needs.
+        self.history: deque[Operation] = deque(maxlen=REMEMBERED)
+        #: The probes found when they were last looked for.
+        self.probes_found: list = []
         self._cancel = threading.Event()
         self._worker = Worker(self)
         self._last_progress = -1.0
@@ -156,14 +190,19 @@ class Flasher(QObject):
             if self.busy:
                 self.events.warning(f"{name} was not started: something else is still running.")
                 return False
+            self.doing = name
             self._set_busy(True)
             self._cancel.clear()
             self._last_progress = -1.0
+        asked, started = f"{datetime.now():%H:%M:%S}", time.monotonic()
+
+        def remember(outcome: str, said: str = "") -> None:
+            took = time.monotonic() - started
+            self.history.append(Operation(asked, name, outcome, took, said))
 
         def job() -> tuple[Any, str | None, bool]:
             # A backend's own error is a sentence already and is passed on as
-            # one. Anything else is a fault in pyflashgui or in a library,
-            # and says what kind it was.
+            # one. Anything else was not expected, and says what kind it was.
             try:
                 return work(), None, False
             except CancelledError as exc:
@@ -176,13 +215,16 @@ class Flasher(QObject):
             if error is None:
                 result, error, cancelled = result
             if not quiet:
+                self.doing = ""
                 self._set_busy(False)
             if error is not None:
+                remember("cancelled" if cancelled else "failed", error)
                 (self.events.warning if cancelled else self.events.error)(error)
                 if not quiet:
                     self.finished.emit(name, False)
                 return
             ok = done(result)
+            remember("done" if ok is not False else "not done as asked")
             if not quiet:
                 self.finished.emit(name, ok is not False)
 
@@ -243,6 +285,7 @@ class Flasher(QObject):
 
         def done(result: tuple[list, str]) -> None:
             probes, error = result
+            self.probes_found = list(probes)
             if error:
                 self.events.warning(error)
             self.probes_changed.emit(probes)