The web workspace

Each pod has a workspace on your BenchPod page: the AI agent and the capture, drive and simulate tools on the left, and a side pane with the console, captures, pins, power and flashing. This page explains what each part shows. In the workspace, the (i) next to a control links to its section here.

Pins

The Pins pane shows the pod's pin profiles: which board signal is on which of the 14 LA channels, the board's I/O voltage, the power rail, and the pull resistors to switch on. The profiles are stored on the pod (up to 16), and the active one is what powering the board on and every tool that names no profile use. Click a pin to change what it is used for; New starts a profile, empty or as a copy, and Make active switches to another. See the pin-out for the pull resistors and pin directions.

Visualize draws the profile on the pod's own I/O header, the way you see it: the pin headers from above on boards up to v3-r2, the front connector as you face the enclosure on v3r3 and later. Each pin shows what it carries, and a table under the drawing lists what to connect it to on your board. Print gives a page to keep at the bench; Download SVG saves the drawing. The pod tells which header it has; when older firmware cannot, pick it once and the choice is kept for that pod. The AI HIL tab's Pins pane and the desktop app's Pins tab have the same button.

Drive

The Drive tab talks to your board by hand: the pod is the master on I2C and SPI, drives and reads GPIO, and joins a CAN bus. Every call shows in the log below, and selected rows save as a sequence you can run again or export as a pytest test.

  • I2C: a write, a read, or a write then a read (a repeated START); neither probes the address. A real bus runs a bit slower than the set rate, because the rise time adds to each clock.
  • SPI clocks a byte in for every byte out: send 00 for each byte you want to read. CS stays low for one send, and the pod rounds the rate down to one it can run.
  • GPIO: open drain pulls low for 0 and lets go for 1. Read works on any pin, whatever owns it. A pulse is high for its width and low for the same time between pulses.
  • CAN: switch termination on when the pod is at one end of the bus.

Capture it records the transaction on the logic analyzer, starting just before the first edge, and decodes it.

Console

The console is your board's serial port, through the pod. RX is the channel the pod listens on (your board's TX) and TX the one it drives (your board's RX). Both, the baud, the Parity and the Stop bits (8N1 unless set) come from the active pins profile; changing them in the console saves them there. A board's UART is dead until it is powered, so Connect can switch the internal rail on first.

While the AI HIL tab is open, its agent uses the UART: the console pauses and connects again when you leave the tab.

Flash

Flash writes a build to your board over SWD, through the pod. Pick a build uploaded from CI (see Cloud builds) or a local file. The SWD pins, NRST and the target power rail are filled in from the active pins profile, then from the wiring the build recorded; when they differ, the form says so and uses the profile, which describes how the pod is wired now.

The pod runs one serial or flash job at a time, so flashing closes an open console. Connect it again after the flash. When the pod's probe works but the board does not answer, check the board's power, the SWD wiring and reset.

Power

The pod switches two target rails: internal 5 V (eFuse 1), fed from the pod's USB-C supply, and external (eFuse 2), which passes on what you connect to EXT SUPPLY IN. The header's switches turn them on and off; the active pins profile is applied first (its I/O voltage and pull resistors). The Power pane shows the current on the internal rail over time. With the pod's own current monitor (on newer boards) you can also plot the pod's own draw, the total from USB-C and the supply budget as a limit line.

The pane reads the pod about once a second while the workspace is open; Pause stops it. If the readings stop with an error, the pod is unreachable or its firmware is too old for power readings (update it).

USB-C supply budget

A USB-C source tells the pod how much current it can give on its CC lines: the default 500 mA, 1.5 A or 3 A. That budget feeds the pod's own electronics and the internal 5 V rail together. The external rail comes from the screw terminal, not USB-C, and is not counted.

  • No advertisement: a legacy USB-A-to-C cable or a plain 5 V charger says nothing on CC. Power may well be there, but assume the USB default of 500 mA, and use a real USB-C source if your board needs more.
  • Pod draw not measured: boards without the pod's own current monitor only measure the internal rail. The pod's electronics run from the same supply, so the real headroom is lower than shown: treat it as a ceiling.

From pytest or an AI agent, the same readings come from bp.power_status() and the MCP server's power_status.

Calibration

Each pod is calibrated before it ships. The pod's Settings tab has three ways to calibrate it again, each stored on the pod:

  • ADC offset: every analog input goes through the same front end, and each pod reads a few tens of mV off. Calibrate measures that offset on the 4-20 mA input (J8) with nothing connected, where the input is exactly 0 V. With current firmware it corrects every analog input: the front SMA, both loopbacks, the 4-20 mA input, captures and the control loop. Do it first: the gain steps below need it.
  • Bench DMM (4.5 digits or better): the DAC offset and gain per output, measured with the DMM on each output, then the ADC gain per input through an internal loopback. Each step is saved on its own.
  • Voltage reference (a 10 V reference board, say): the ADC input reads the reference, then each output through a cable. The check changes nothing: when the pod is already within the reference's accuracy, calibrating will not make it more accurate.

The DMM and reference calibrations drive up to ±5 V on the DAC outputs: disconnect your board from them, and remove any DAC output limits while you calibrate.

Generator

The Generator drives the pod's DAC outputs: a held level, a waveform, a replay of a capture, or a signal you build from segments. A ramp goes from its start to its end level, a hold stays at its start level and a step jumps to its end level. Chain segments so each one ends where the next one starts for a continuous signal. Levels are clipped to the output's range.

The control loop runs on the pod's FPGA: each tick it takes an input, looks up the transfer curve, damps toward it and clamps, then drives the DAC, until you press Stop. Its closed-loop bandwidth follows from the update rate and the response: keep it well below the bandwidth of what you drive, because a fast loop around a lightly-damped stage oscillates. With an external output stage the loop holds the DAC inside the stage's window; for a true 0 V out, switch the module off with its enable pin.