Annealage
Annealage Pod PN-02 / HITL

The debugger runs on the pod. No wired host, no separate probe.

Annealage Pod is a Wi-Fi hardware-in-the-loop test rig: flash, debug, and exercise a device-under-test over the network. The debugger runs on the pod itself. The pod speaks SWD over a PIO state machine, drives an ADIv5 DP/AP/MEM-AP stack and a Cortex-M control layer, and exposes flash, debug, reset and capture to an agent over MCP.

[ ok ] Available now · off-the-shelf Raspberry Pi Pico 2 W · open source, AGPL-3.0

agent@pod MCP · POD
01 pod discover # mdns _annealage-pod._tcp passed
02 pod register bench-a # ipv6-first passed
03 pod dut flash bench-a fw.bin # swd, verified passed
04 pod dut gdb bench-a # arm-none-eabi-gdb passed
05 pod bench la bench-a --pins 16-19 # → cap.vcd passed
06 agent: assert, re-run
loop discover → flash → debug → exercise → assert
FIG. 1: the architecture

The pod is the debugger, not a probe a host drives.

Most rigs are a USB debug probe that a host PC drives. Annealage Pod inverts that: the debugger runs in MicroPython on the pod, with PIO-driven SWD at 9.375 MHz, an ADIv5 DP/AP/MEM-AP stack, a Cortex-M control layer, a flash loader, and a GDB server. The host talks IP.

One off-the-shelf board is both the debug probe and the test rig. A rack of pods is a set of hostnames, each announcing itself over mDNS, each flashing and debugging its own DUT over Wi-Fi.

  • debugger SWD + ADIv5 + Cortex-M + GDB server, all on the pod. No external probe.
  • link Wi-Fi to the host instead of a wired USB tether.
  • board One off-the-shelf Pico 2 W is the whole rig: probe, instruments, and network link.

What the pod does over the network.

SHEET 02 / VALIDATED

The core debug-and-test workflow is validated on hardware against an nRF52840 DUT, with flash also validated on an i.MX RT1052. The on-pod debugger targets SWD and Cortex-M only. STM32 and RP2350-as-DUT are pending; the DUT compatibility matrix in the docs tracks each family. An agent drives every subsystem with the same MCP calls, whether the pod is on the bench or in a rack.

swd debug ON-POD

On-pod SWD debugger: an ADIv5 DP/AP/MEM-AP stack and a Cortex-M layer drive halt, resume, reset-and-halt, single-step, register and memory access, FPB hardware breakpoints, and DWT data watchpoints, with no external probe in the loop.

flash OVER WI-FI

A DUT image streams straight into pod RAM over TCP and is programmed over SWD with verify, never touching a filesystem. A generic CMSIS-FLM runner runs the flash algorithm from a CMSIS pack. Validated on nRF52840 and i.MX RT1052.

gdb THROUGH POD

A stock arm-none-eabi-gdb connects over Wi-Fi: reset-halt, register and memory read/write, hardware breakpoint and data-watchpoint hits, backtrace, single-step, continue, and clean detach.

logic analyser PIO → VCD

A PIO state machine samples up to 32 contiguous DUT GPIOs into a DMA ring with optional trigger, streams the capture to the host, and decodes to VCD. It coexists with SWD and Wi-Fi simultaneously.

peripherals I2C · SPI · GPIO · ADC

The pod presents a hardware I2C target and a PIO SPI target (stream or register-file, modes 0–3, up to 8 MHz) and drives or reads GPIO and ADC, so a DUT-as-controller talks to a stand-in the test controls.

discovery mDNS · IPv6

The pod advertises a browsable _annealage-pod._tcp service. The host resolves it IPv6-first (self-authenticating) and refuses to act on a fingerprint mismatch, so it cannot flash the wrong board after a DHCP change.

Plus a Wi-Fi socket REPL with a persistent, auto-reconnecting session. All of it runs through the 28 MCP tools. Full reference in the docs.

USB/IP: DUT export

Attach a DUT's USB to your host over Wi-Fi.

The pod's native USB port hosts the DUT, and an in-tree C USB/IP server exports it over Wi-Fi so a host can usbip attach the device and bind it with a normal class driver. Device enumeration and attach are validated on hardware.

The forwarded DUT REPL works: usbip attach then mpremote connect reaches the DUT's own REPL over the forward, validated on an nRF52840 across repeated attach / round-trip / detach cycles, including sustained churn (100 attach → round-trip → detach cycles at 0% Wi-Fi packet loss). The pod is a raw URB forwarder and runs no USB class drivers of its own.

  • enumerate A DUT enumerates and attaches over Wi-Fi, validated on an nRF52840. validated
  • repl Forwarded DUT CDC REPL, across repeated attach/detach cycles. validated
  • churn Sustained churn: 100 attach, round-trip and detach cycles at 0% Wi-Fi packet loss. validated
  • host os usbip attach needs Linux (vhci_hcd). Every other pod capability is host-OS-agnostic.
Local benches: no pod

Dev board with its own programmer? Same verbs.

A board with a built-in programmer, such as an ST-LINK on a Nucleo or a CMSIS-DAP probe, is driven through the same pod dut verbs and dut_* MCP tools, with pyOCD on the host and flash algorithms from the shared CMSIS pack cache. Validated on a NUCLEO-H563ZI.

Each channel has its own route. A bench can run dut_exec over its own USB serial port and borrow a registered pod's GPIO and ADC. The agent's calls don't change.

  • debug pyOCD on the host drives the board's own probe. validated
  • usb serial Board USB serial route validated.
  • instruments Borrow a registered pod's GPIO and ADC.
  • limits Pack-default flash algorithms only. An ST-LINK halt holds across MCP calls, not across CLI runs. Borrowed logic capture is not hardware-validated.
The stack

MicroPython on the rp2 port, USB/IP in-tree.

The firmware is MicroPython on the rp2 port. The whole debug stack is pure MicroPython: PIO SWD, the ADIv5 and Cortex-M layers, a generic CMSIS-FLM flash runner, and a binary DAP RPC server with a host-side GDB RSP translator.

The USB/IP server is an in-tree C module: an lwIP-RAW callback state machine with static buffer pools that forwards raw URBs, with a TinyUSB host backend running DUT enumeration. The host pod CLI, client, and pod-mcp server talk to it over an async ampremote fork.

  • board Raspberry Pi Pico 2 W (RP2350, CYW43 Wi-Fi).
  • firmware MicroPython rp2 port, composed with mbm.
  • usb/ip In-tree C module over lwIP-RAW; TinyUSB host backend.
  • discovery Native lwIP mDNS responder; annealage-pod.local.

Flash a pod, wire the DUT, then drive it.

SHEET 03 / SETUP
01 / flash

Flash the pod, wire the DUT

First install: hold BOOTSEL, plug in the Pico 2 W, drag firmware.uf2 onto the RPI-RP2 drive. No probe needed. To reflash a live pod, use make flash (OpenOCD, both cores halted). Wire SWD: GP14 to SWDIO, GP15 to SWCLK, common ground.

# first install: drag firmware.uf2 → RPI-RP2
make flash   # reflash a live pod (probe)
02 / register

Install tooling, register

Install the annealage-pod-host tooling, browse mDNS for the pod, and store its handles and identity fingerprint under a label.

uv tool install --editable ./src/host
pod discover
pod register bench-a --address <ip>
03 / drive

Drive the DUT

Flash, reset, debug with a stock gdb, capture logic, or open a live REPL, all over Wi-Fi.

pod dut flash bench-a fw.bin
pod dut gdb bench-a
pod bench la bench-a --pins 16-19

The full subsystem reference, the 28-tool MCP surface, the port list, and the Pico 2 W pinout live in the Pod docs.

Carrier board Not available on the bare Pico product.

Per-rail INA228 power telemetry, opto-isolated relays and DUT power switching belong to a purpose-built carrier board, which also wires the DUT interfaces. The bare Pico 2 W uses jumper wires and does not include these features.