Supported boards reference

This page is the reference for every board Revka recognizes: its USB VID/PID, the alias prefix it gets, its LED pin, its chip and memory map, and the Cargo feature flags required to use it. Reach for this page when you need exact addresses for a memory read, want to confirm a board is supported before plugging it in, or are debugging why a device wasn’t auto-discovered.

For first-time setup (auto-discovery, aliases, the [hardware] / [peripherals] config), start with the Hardware quickstart. For flashing, see Flashing firmware; for the GPIO tools, see GPIO tools.

Caution

Everything on this page is gated behind the hardware Cargo feature. Build with cargo build --release --features hardware. Native Raspberry Pi GPIO additionally needs peripheral-rpi; live chip introspection of Nucleo boards needs probe. See Feature flags and Cargo feature flags & ADRs.

Supported boards at a glance

Board name	Family VID	LED pin	Chip / arch	Transport	Required features
raspberry-pi-pico	0x2E8A	25	RP2040, ARM Cortex-M0+ (MicroPython)	serial (USB)	hardware
arduino-uno	0x2341	13	ATmega328P, 8-bit AVR	serial (USB)	hardware
arduino-uno-q	0x2341	13	STM32U585 + Linux (aarch64)	bridge (TCP 9999)	hardware
nucleo-f401re	0x0483	13 (PA5)	STM32F401RET6, ARM Cortex-M4	serial (USB)	hardware (+ probe for live info)
nucleo-f411re	0x0483	13 (PA5)	STM32F411RET6, ARM Cortex-M4	serial (USB)	hardware (+ probe for live info)
arduino-mega	0x2341	13	ATmega2560, 8-bit AVR	serial (USB)	hardware
esp32	0x10C4 / 0x1A86	2	Xtensa LX6, dual-core	serial (USB)	hardware
rpi-gpio	— (native)	none fixed	Raspberry Pi, ARM Linux	native (rppal / sysfs)	hardware + peripheral-rpi
Aardvark adapter	0x2B76	—	Total Phase I2C/SPI/GPIO	USB (libloading)	hardware

The LED pins above are the Revka-protocol pin numbers your agent uses with gpio_write / gpio_read. On Nucleo, pin 13 maps to PA5 (the LD2 user LED); on the Raspberry Pi the onboard ACT LED is model-specific (see Raspberry Pi GPIO).

VID/PID registry

Revka identifies boards two ways. At the family level, a USB Vendor ID maps to a board kind and chooses the alias prefix. At the exact level, a VID/PID pair maps to a specific board name and architecture string used by revka hardware discover and revka hardware introspect.

Vendor IDs (board family → alias prefix)

VID	Board family	Alias prefix
0x2E8A	Raspberry Pi Pico / Pico W	pico
0x2341	Arduino (Uno, Mega, Uno Q)	arduino
0x10C4	ESP32 via CP2102 bridge	esp
0x0483	STMicroelectronics (Nucleo)	nucleo
0x2B76	Total Phase Aardvark	aardvark

Aliases are assigned sequentially per prefix (pico0, pico1, arduino0, esp0, nucleo0, aardvark0). A board with an unrecognized VID that still answers the firmware ping handshake is registered as device0 (the Generic kind). Aliases are stable within a daemon session and reset on restart.

VID/PID pairs (exact board identification)

These pairs are matched by the board registry that discover and introspect consult:

VID:PID	Board name	Architecture
0483:374b	nucleo-f401re	ARM Cortex-M4
0483:3748	nucleo-f411re	ARM Cortex-M4
2341:0043	arduino-uno	AVR ATmega328P
2341:0078	arduino-uno	Arduino Uno Q / ATmega328P
2341:0042	arduino-mega	AVR ATmega2560
10c4:ea60	cp2102	USB-UART bridge
10c4:ea70	cp2102n	USB-UART bridge
1a86:7523	esp32	ESP32 (CH340)
1a86:55d4	esp32	ESP32 (CH340)

Note

ESP32 dev boards ship with several USB-UART bridges. Boards using the Silicon Labs CP2102/CP2102N appear under VID 0x10C4; boards using the WCH CH340 appear under 0x1A86. Both resolve to the esp32 board name.

Per-board details

Raspberry Pi Pico

A MicroPython board flashed over UF2. The Pico GPIO and code tools (gpio_write, gpio_read, pico_flash, device_read_code, device_write_code, device_exec) are always loaded when the hardware feature is compiled, even with no Pico attached — they report “no device found” gracefully.

• Onboard LED: pin 25.
• Runtime: MicroPython (uses mpremote for code read/write/exec; install with pip install mpremote).
• Flashing: hold BOOTSEL while plugging in to mount the RPI-RP2 drive, then call pico_flash(confirm=true). See Flashing firmware.

Arduino Uno

An 8-bit AVR board flashed with arduino-cli.

Board:  arduino-uno
Chip:   ATmega328P
Arch:   8-bit AVR, 16 MHz
Memory: Flash 16 KB · SRAM 2 KB · EEPROM 1 KB
LED:    pin 13 (also aliased red_led / builtin_led / user_led)

Digital pins 0–13 are usable; pins 0–1 double as the serial RX/TX, so avoid them while the serial link is in use. Revka firmware runs at 115200 baud and exposes capabilities, gpio_read, and gpio_write. The arduino_upload tool (added when a board named exactly arduino-uno is configured) lets the agent compile and upload a full sketch.

Arduino Uno Q

A dual-brain board: an STM32U585 MCU paired with a Qualcomm Linux side (aarch64). GPIO is reached through a Bridge app (a Python + MCU socket server) listening on TCP port 9999, not a serial port.

Board:  arduino-uno-q
Chip:   STM32U585 + Qualcomm
Arch:   Dual-core: STM32 (MCU) + Linux (aarch64)
GPIO:   via Bridge app on port 9999

Deploy the Bridge with revka peripheral setup-uno-q [--host IP], then configure it with transport = "bridge". The standard gpio_read / gpio_write tools are transparently backed by the Bridge socket (127.0.0.1:9999) — the agent uses the same tool names. Connection timeout is 5 s; response timeout is 3 s.

[[peripherals.boards]]
board = "arduino-uno-q"
transport = "bridge"

Nucleo (F401RE / F411RE)

STM32 Cortex-M4 boards with a built-in ST-Link debug probe, so they can be flashed and introspected over USB with no external hardware. Firmware (Embassy/Rust) talks the Revka serial JSON protocol over USART2.

nucleo-f401re

Chip:   STM32F401RET6
Arch:   ARM Cortex-M4, 84 MHz
Flash:  0x0800_0000 - 0x0807_FFFF (512 KB)
RAM:    0x2000_0000 - 0x2001_FFFF (128 KB)
LED:    pin 13 → PA5 (LD2), active high

nucleo-f411re

Chip:   STM32F411RET6
Arch:   ARM Cortex-M4, 100 MHz
Flash:  0x0800_0000 - 0x0807_FFFF (512 KB)
RAM:    0x2000_0000 - 0x2001_FFFF (128 KB)
LED:    pin 13 → PA5 (LD2), active high

With the probe feature built, both boards report live chip info, memory map, and register values via probe-rs over SWD — no firmware needs to be on the target. Without probe, Revka returns the static datasheet values shown above. Flash with revka peripheral flash-nucleo; see Flashing firmware.

ESP32

A dual-core Xtensa LX6 board reached over a USB-UART bridge at 115200 baud.

Board:  esp32
Chip:   ESP32 (Xtensa LX6, 240 MHz, dual-core)
Flash:  0x3F40_0000 - 0x3F7F_FFFF (4 MB typical)
IRAM:   0x4000_0000 - 0x4005_FFFF
DRAM:   0x3FFB_0000 - 0x3FFF_FFFF
LED:    GPIO 2 (builtin_led / red_led)

GPIO 2 is the built-in LED on many dev boards; GPIO 21/20 are often UART0 TX/RX — avoid them while serial is active. Revka drives the ESP32 with the same serial JSON gpio_read / gpio_write protocol used by the Pico and Arduino.

Raspberry Pi GPIO

When Revka runs natively on a Raspberry Pi (Linux), it drives GPIO directly rather than over a serial link. This is auto-registered when the peripheral-rpi feature is active and /proc/device-tree/model identifies a Pi — no config entry required.

Board:  rpi-gpio
Chip:   Raspberry Pi (ARM Linux)
GPIO:   native via rppal (/dev/gpiomem); onboard LED via sysfs
Pins:   BCM numbering throughout

Use the native tools — gpio_rpi_write, gpio_rpi_read, gpio_rpi_blink — not the serial gpio_write. The onboard ACT LED GPIO differs by model:

Model	ACT LED (BCM GPIO)
RPi 3B / 3B+	47
RPi 4B	42
RPi 5	9
Zero 2W	29

Register it manually if needed with revka peripheral add rpi-gpio native. See Raspberry Pi (self-hosted) and GPIO tools.

Aardvark I2C/SPI/GPIO adapter

The Total Phase Aardvark is a USB host adapter (VID 0x2B76) for I2C, SPI, and 8-pin GPIO. Its tools (i2c_scan, i2c_read, i2c_write, spi_transfer, gpio_aardvark, plus the datasheet helper) are only registered when an adapter is detected at startup. It is reached through the aardvark.so library, loaded dynamically. See Aardvark I2C/SPI/GPIO & datasheets for the full tool set and library setup.

Board capabilities

Each registered device carries a capability set that tools check before acting. The fields are gpio, i2c, spi, swd, uart, adc, and pwm. For serial boards, you can ask the firmware which pins it exposes with the hardware_capabilities tool (registered only when serial boards are configured):

arduino0: gpio [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], led_pin 13

hardware_capabilities takes an optional board argument to filter to one board; omit it to query all. The firmware must implement the capabilities command in its serial JSON handler. This is the reliable way for an agent to discover available pins before calling gpio_write.

Board introspection tools

These four LLM-callable tools answer “what board do I have?” and “what’s its memory map?”. They read static datasheet data, and — for Nucleo with the probe feature — live data over SWD. All require [peripherals] to be configured, or they return an error directing you to add boards.

hardware_board_info

Returns chip name, architecture, and memory map for a configured board.

• Parameters: board (string, optional) — board name; defaults to the first configured board.
• Coverage (static): nucleo-f401re, nucleo-f411re, arduino-uno, arduino-uno-q, esp32, rpi-gpio.
• With probe: Nucleo boards return live chip info via USB/SWD (no firmware on target).

**Board:** nucleo-f401re
**Chip:** STM32F401RET6
**Description:** ARM Cortex-M4, 84 MHz. Flash: 512 KB, RAM: 128 KB. User LED on PA5 (pin 13).

**Memory map:**
Flash: 0x0800_0000 - 0x0807_FFFF (512 KB)
RAM: 0x2000_0000 - 0x2001_FFFF (128 KB)

hardware_memory_map

Returns just the flash and RAM address ranges for a configured board.

• Parameters: board (string, optional) — defaults to the first configured board.
• Coverage (static): nucleo-f401re, nucleo-f411re, arduino-uno, arduino-mega, esp32.
• With probe: Nucleo maps are read live from probe-rs. If the requested board isn’t found, the tool lists the known board names.

**nucleo-f401re** (from datasheet):
Flash: 0x0800_0000 - 0x0807_FFFF (512 KB)
RAM: 0x2000_0000 - 0x2001_FFFF (128 KB)
STM32F401RET6, ARM Cortex-M4

hardware_memory_read

Reads actual memory/register values from a Nucleo over USB/SWD and returns a hex dump. This requires the probe feature; without it the tool returns a clear build instruction.

• Parameters:
  • address (string, default "0x20000000") — hex address; 0x20000000 is the Nucleo RAM base.
  • length (integer, default 128, max 256) — bytes to read.
  • board (string, optional) — nucleo-f401re or nucleo-f411re only.
• Requires: cargo build --features hardware,probe and a Nucleo on USB. No firmware on target is needed.

Memory read from 0x20000000 (128 bytes):

0x20000000  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x20000010  01 00 00 00 ff ff ff ff 00 10 00 20 00 00 00 00  ........... ....

Hardware CLI: introspect & info

Two CLI commands surface board identity without an agent. Both need the hardware feature and run on Linux, macOS, and Windows.

revka hardware introspect

Reads detailed USB info for a device path and correlates it with the board registry to name the board and architecture.

revka hardware introspect /dev/ttyACM0

Device at /dev/ttyACM0:

  VID:PID     0483:374b
  Board       nucleo-f401re
  Architecture ARM Cortex-M4
  Memory map  512 KB Flash, 128 KB RAM

Argument	Type	Meaning
path	string (required)	Device path to introspect (e.g. /dev/ttyACM0)

revka hardware info

Reads chip info from a Nucleo over USB/SWD using probe-rs — no firmware on target required.

cargo build --features hardware,probe
revka hardware info --chip nucleo-f401re

Connecting to nucleo-f401re via USB (ST-Link)...

Chip: STM32F401RETx
Architecture: Armv7em

Memory map:
  RAM:   0x20000000 - 0x2001FFFF (128 KB)
  Flash: 0x08000000 - 0x0807FFFF (512 KB)

Info read via USB (SWD) — no firmware on target needed.

Flag	Type	Meaning
--chip	string	Chip target identifier (e.g. nucleo-f401re)

Without the probe feature, info prints build instructions instead of attaching. For the companion discovery command (revka hardware discover) and per-board flashing commands, see the Hardware quickstart and revka hardware & peripheral.

Boards & datasheets

Revka ships static datasheet notes for the boards above — pin aliases, GPIO usage, and the serial protocol. These notes back the introspection tools and can be extended with your own files under ~/.revka/hardware/:

• ~/.revka/hardware/HARDWARE.md — global hardware notes injected into the system prompt.
• ~/.revka/hardware/devices/<alias>.md — per-device profiles (e.g. pico0.md).
• ~/.revka/hardware/datasheets/<device>.pdf — component datasheets fetched by the datasheet tool.

The datasheet tool (available when an Aardvark is connected) follows the workflow: identify a device with i2c_scan → search and download its datasheet → save a device profile with the key registers. See Aardvark I2C/SPI/GPIO & datasheets.

Feature flags

The board surface is split across Cargo features. Build only what your deployment needs.

Feature	Enables	Build command
hardware	USB discovery, serial GPIO tools, Pico/Arduino/ESP32/Nucleo support, board-info tools, Aardvark	cargo build --release --features hardware
probe	Live Nucleo chip info, memory map, and hardware_memory_read via probe-rs (SWD)	cargo build --release --features hardware,probe
peripheral-rpi	Native Raspberry Pi GPIO tools (gpio_rpi_write / gpio_rpi_read / gpio_rpi_blink), rpi_system_info, RPi self-discovery	cargo build --release --features hardware,peripheral-rpi

Note

probe uses the probe-rs-tools crate for the CLI side of Nucleo flashing — install it with cargo install probe-rs-tools --locked (the crate is probe-rs-tools, not probe-rs).

For the complete flag matrix (including rag-pdf for datasheet text extraction and safety for the Robot Kit), see Cargo feature flags & ADRs.

Related pages

Hardware quickstart Auto-discovery, aliases, and the boot subsystem.

Flashing firmware Pico UF2, Arduino, and Nucleo flashing.

GPIO tools gpio_write/read, device_exec, and native RPi tools.

Raspberry Pi (self-hosted) Running Revka directly on a Pi with native GPIO.

Aardvark I2C/SPI/GPIO I2C/SPI tools, library setup, and datasheets.

revka hardware & peripheral The full hardware and peripheral CLI.