Raspberry Pi Pico2

Raspberry Pi Pico 2 and Debug Probe

This skill covers development with Raspberry Pi Pico 2 (RP2350) boards and the Raspberry Pi Debug Probe. It includes hardware specs, SDK setup, build configuration, debugging workflows, and common pitfalls.

Reference Files

Consult these for detailed technical content. Read only the file relevant to the current task:

• references/pico2-hardware.md - RP2350 specs, RP2040 vs RP2350 comparison, pin layout, wireless variant, security features, chip variants
• references/debug-probe.md - Debug Probe hardware, wiring diagrams, OpenOCD setup, GDB workflow, UART serial, RTT, VS Code integration, rescue mode, troubleshooting
• references/sdk-toolchain.md - pico-sdk setup, CMake configuration, ARM vs RISC-V builds, picotool commands, MicroPython/CircuitPython, project structure

Quick Reference

Board Selection (CMake)

Debug Probe Wiring (SWD)

Debug Probe Wiring (UART)

Note the crossover: probe TX to Pico RX, probe RX to Pico TX.

OpenOCD Target Configs

Typical Debug Session

# Terminal 1: OpenOCD
openocd -f interface/cmsis-dap.cfg -f target/rp2350.cfg -c "adapter speed 5000"

# Terminal 2: GDB
arm-none-eabi-gdb my_app.elf
(gdb) target remote localhost:3333
(gdb) monitor reset init
(gdb) load
(gdb) break main
(gdb) continue

Flash via SWD

openocd -f interface/cmsis-dap.cfg -f target/rp2350.cfg \
  -c "adapter speed 5000" \
  -c "program my_app.elf verify reset exit"

Use the .elf file for SWD flashing, not .uf2.

Gotchas

These are the most common mistakes and non-obvious behaviours. Pay close attention.

1. SDK defaults to Pico 1. You must explicitly pass -DPICO_BOARD=pico2 to target RP2350. Forgetting this builds for RP2040 and the binary will not run on a Pico 2.

2. Use the Raspberry Pi fork of OpenOCD. Upstream OpenOCD (0.12.0) lacks full RP2350 support. Clone from https://github.com/raspberrypi/openocd.git branch rpi-common.

3. Wrong target config = failed connection. Using rp2040.cfg with a Pico 2 silently fails. Always match the target config to the chip.

4. SWD uses .elf, BOOTSEL uses .uf2. These are different formats for different flashing methods. Do not try to flash a .uf2 via OpenOCD/SWD.

5. Debug builds required for meaningful debugging. Always pass -DCMAKE_BUILD_TYPE=Debug to cmake. Release builds optimise away variable state and reorder code, making breakpoints unreliable.

6. RISC-V mode has no FPU. The hardware floating-point unit is only available on Cortex-M33. RISC-V mode uses software float, which is significantly slower for float-heavy code.

7. RISC-V requires a clean build directory. When switching between ARM and RISC-V, delete the build directory and re-run cmake. In-place switching does not work.

8. RISC-V debugging requires pre-selection. The RP2350 boots into Cortex-M33 by default. To debug RISC-V: picotool reboot -u -c riscv, then use OpenOCD with set USE_CORE { rv0 rv1 }.

9. Debug Probe does not power the target. The Pico 2 must be powered via its own USB or VSYS. The SWD connector carries no power.

10. LED pin differs on wireless models. Non-wireless Pico 2 uses GP25 for the onboard LED. Pico 2 W uses WL_GPIO0 through the CYW43439 wireless chip. Code must be conditional.

11. Git submodules are required. The pico-sdk needs git submodule update --init to pull tinyusb, cyw43-driver, lwip, btstack, and mbedtls. Missing submodules cause cryptic build failures.

12. OTP is irreversible. Writing OTP bits is permanent. Misconfiguring secure boot (setting SECURE_BOOT_ENABLE without a boot key and with PICOBOOT disabled) permanently bricks the device.

13. Wireless SPI pin sharing. On Pico 2 W, the VSYS ADC reading and CYW43439 IRQ checking are blocked during SPI transactions to the wireless chip.

14. Connect GND first. When the Pico 2 is powered from a separate source, connect GND between the target and Debug Probe before any signal lines. Voltage differences can damage the probe.

15. macOS: OpenOCD needs hidapi and libusb. Install via brew install hidapi libusb. If OpenOCD cannot find the probe, check no other process (VS Code, another OpenOCD instance) holds the USB device.

16. Multiple debug probes. If multiple CMSIS-DAP devices are connected, specify the serial number: adapter serial <serial_number> in your OpenOCD config.

Raspberry Pi Debug Probe Reference

Table of Contents

• Hardware Overview
• Wiring to Pico 2
• Software Installation
• OpenOCD Configuration
• GDB Debugging Workflow
• Flashing via SWD
• UART Serial Console
• RTT (Real-Time Transfer)
• VS Code Integration
• Debug Probe Firmware
• Using a Pico as Debug Probe
• Rescue Mode
• Troubleshooting

Hardware Overview

The Debug Probe is a USB device (built on RP2040) providing:

• USB to SWD (CMSIS-DAP compatible)
• USB to UART bridge (CDC serial)

Operates at 3.3V nominal I/O voltage.

Connectors

Cable Colour Coding

Included Cables

1. JST-SH to JST-SH (for boards with JST connector) 2. JST-SH to 0.1-inch female header (for soldered pin headers) 3. JST-SH to 0.1-inch male header (for breadboard use)

Wiring to Pico 2

SWD Connection (Port "D")

The Pico 2 must be powered separately (USB or VSYS). The SWD connector carries no power.

Boards with JST connector (Pico 2 with headers): Connect Debug Probe "D" port directly to Pico 2 SWD JST-SH with the JST-to-JST cable.

Boards with castellated pads (standard Pico 2): Solder headers to the three SWD pads, then use the JST-SH to 0.1-inch female cable:

UART Connection (Port "U")

Crossover: probe TX to Pico RX, probe RX to Pico TX.

Safety

When the Pico 2 is powered from a separate source, connect GND between target and probe first before any signal lines. Voltage differences can damage the probe.

Software Installation

Option A: VS Code Extension (Recommended)

Install raspberry-pi.raspberry-pi-pico from the VS Code marketplace. It bundles OpenOCD, ARM toolchain, GDB, and Cortex-Debug integration.

Option B: Manual Installation

OpenOCD (Raspberry Pi Fork)

The RPi fork is required for full RP2350 support. Upstream OpenOCD 0.12.0 is insufficient.

macOS:

brew install libusb hidapi libftdi capstone pkgconf
git clone https://github.com/raspberrypi/openocd.git --branch rpi-common --depth=1
cd openocd
./bootstrap
./configure --enable-cmsis-dap
make -j$(sysctl -n hw.logicalcpu)
sudo make install

Linux (Debian/Ubuntu):

sudo apt install automake autoconf build-essential texinfo libtool \
  libftdi-dev libusb-1.0-0-dev libhidapi-dev pkg-config
git clone https://github.com/raspberrypi/openocd.git --branch rpi-common --depth=1
cd openocd
./bootstrap
./configure --enable-cmsis-dap
make -j$(nproc)
sudo make install

GDB

• ARM builds: arm-none-eabi-gdb (from Arm GNU Toolchain)
• RISC-V builds: riscv32-unknown-elf-gdb or gdb-multiarch
• Linux alternative: sudo apt install gdb-multiarch

picotool

macOS: brew install picotool Linux: Build from source at https://github.com/raspberrypi/picotool

OpenOCD Configuration

Target Config Files

RP2040 vs RP2350 in OpenOCD

USE_CORE Options (RP2350)

Controls which cores OpenOCD connects to:

For RISC-V debugging, pre-select RISC-V mode first:

picotool reboot -u -c riscv

OpenOCD Ports

GDB Debugging Workflow

Step 1: Build with Debug Symbols

mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Debug -DPICO_BOARD=pico2 ..
make -j$(nproc)

-DCMAKE_BUILD_TYPE=Debug is critical. Without it, optimisations make breakpoints unreliable.

Step 2: Start OpenOCD

openocd -f interface/cmsis-dap.cfg -f target/rp2350.cfg -c "adapter speed 5000"

Step 3: Connect GDB

arm-none-eabi-gdb my_app.elf

(gdb) target remote localhost:3333
(gdb) monitor reset init
(gdb) load
(gdb) break main
(gdb) continue

Common GDB Commands

Flashing via SWD

Using OpenOCD

# Pico 2
openocd -f interface/cmsis-dap.cfg -f target/rp2350.cfg \
  -c "adapter speed 5000" \
  -c "program my_app.elf verify reset exit"

# Pico 1
openocd -f interface/cmsis-dap.cfg -f target/rp2040.cfg \
  -c "adapter speed 5000" \
  -c "program my_app.elf verify reset exit"

Use the .elf file for SWD. The .uf2 format is only for BOOTSEL drag-and-drop.

Using picotool

picotool load my_app.elf
picotool reboot

UART Serial Console

The Debug Probe "U" port exposes a CDC serial device on the host.

Device Paths

Connecting

# Linux
minicom -b 115200 -o -D /dev/ttyACM0

# macOS
ls /dev/cu.usbmodem*
screen /dev/cu.usbmodemXXXX 115200
# or
minicom -b 115200 -o -D /dev/cu.usbmodemXXXX

Default baud rate for SDK examples: 115200. Debug Probe firmware v2.3.0 supports opt-in autobaud.

Exit minicom: CTRL-A then X. Exit screen: CTRL-A then K, then Y.

RTT (Real-Time Transfer)

RTT uses the SWD debug channel for printf-style output. Faster than UART, no extra wiring needed.

VS Code (Cortex-Debug)

Add to launch.json:

"rttConfig": {
    "enabled": true,
    "address": "auto",
    "decoders": [
        {
            "label": "",
            "port": 0,
            "type": "console"
        }
    ]
}

Output appears in the TERMINAL tab under RTT Ch:0 console.

Standalone GDB

(gdb) target remote localhost:3333
(gdb) monitor reset init
(gdb) monitor rtt setup 0x20000000 2048 "SEGGER RTT"
(gdb) monitor rtt start
(gdb) monitor rtt server start 60000 0
(gdb) continue

Then in another terminal: nc localhost 60000

SDK Setup

Enable pico_stdio_rtt as the stdio driver in CMakeLists.txt instead of (or alongside) UART/USB.

VS Code Integration

Raspberry Pi Pico Extension

Extension ID: raspberry-pi.raspberry-pi-pico

Provides: project scaffolding, CMake build integration, bundled OpenOCD/GCC/GDB, one-click debug, register viewer, RTT support.

Cortex-Debug Extension

Extension ID: marus25.cortex-debug

For manual configuration, a launch.json entry uses:

• "servertype": "openocd"
• "configFiles": ["interface/cmsis-dap.cfg", "target/rp2350.cfg"]
• "device": "RP2350" (or "RP2040")
• The ELF file as "executable"

Debug Probe Firmware

Current version: 2.3.0 (released 2025-02-11). Source: https://github.com/raspberrypi/debugprobe

Check Version (Linux)

lsusb -v -d 2e8a:000c | grep bcdDevice
# Reports bcdDevice 2.30 for v2.3.0

The Info : CMSIS-DAP: FW Version = 2.0.0 from OpenOCD is the CMSIS-DAP protocol version, not the firmware version.

Update Procedure

1. Download debugprobe.uf2 from https://github.com/raspberrypi/debugprobe/releases/latest 2. Remove the Debug Probe enclosure top (pinch to open) 3. Hold BOOTSEL while plugging into USB. "RPI-RP2" volume mounts. 4. Copy debugprobe.uf2 onto the volume. 5. Probe reboots with new firmware.

Using a Pico as Debug Probe

The debugprobe firmware can run on a regular Pico or Pico 2.

Pico 1: Download debugprobe_on_pico.uf2 from releases, or build with cmake -DDEBUG_ON_PICO=ON ..

Pico 2:

git clone https://github.com/raspberrypi/debugprobe
cd debugprobe
git submodule update --init --recursive
mkdir build-pico2 && cd build-pico2
export PICO_SDK_PATH=/path/to/pico-sdk  # SDK v2.0.0+
cmake -DDEBUG_ON_PICO=1 -DPICO_BOARD=pico2 ../
make

Download debugprobe_on_pico2.uf2 from releases page.

Rescue Mode

Recover bricked Pico 2 devices (bad firmware causes crash loop):

# RP2350 rescue
openocd -f interface/cmsis-dap.cfg -f target/rp2350.cfg -c "set RESCUE 1"

# RP2040 rescue
openocd -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "set RESCUE 1"

RP2350 uses the RP_AP CTRL register RESCUE_RESTART bit. Both cores stop in the bootrom after rescue. Restart OpenOCD without the RESCUE flag and load fresh code.

Troubleshooting

Linux Permissions (udev rules)

# Debug Probe (VID:PID 2e8a:000c)
echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="2e8a", ATTR{idProduct}=="000c", MODE="0666"' | \
  sudo tee /etc/udev/rules.d/99-debug-probe.rules

# Pico in BOOTSEL mode
# RP2040: 2e8a:0003, RP2350: 2e8a:000f
echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="2e8a", ATTR{idProduct}=="0003", MODE="0666"' | \
  sudo tee -a /etc/udev/rules.d/99-debug-probe.rules
echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="2e8a", ATTR{idProduct}=="000f", MODE="0666"' | \
  sudo tee -a /etc/udev/rules.d/99-debug-probe.rules

sudo udevadm control --reload-rules
sudo udevadm trigger

USB VID:PID Reference

macOS

• Install hidapi and libusb via Homebrew
• No special driver needed for CMSIS-DAP
• If probe not found: check no other process holds the USB device

Common Issues

Pico 2 (RP2350) Hardware Reference

Table of Contents

• RP2350 Specifications
• Chip Variants
• RP2040 vs RP2350 Comparison
• Pin Compatibility
• Architecture Switching
• Pico 2 W Wireless
• Security Features
• Board Layout

RP2350 Specifications

Chip Variants

The Pico 2 board uses the RP2350A variant.

RP2040 vs RP2350 Comparison

Performance: M33 core is roughly 2x faster than M0+ at comparable tasks.

Migration Notes

• Pico 2 is a drop-in hardware replacement for Pico 1 (same 40-pin form factor, same pin layout).
• Code targeting RP2040 needs recompilation with -DPICO_BOARD=pico2 but most SDK code is portable.
• Code using the RP2040 dedicated hardware integer divider directly (not via SDK) needs adjustment; RP2350 uses in-CPU division.
• For DVI/video output, prefer the HSTX peripheral on RP2350 instead of pushing PIO to its limits.

Pin Compatibility

Pico 2 maintains full pin compatibility with Pico 1:

• Same 40-pin form factor and castellated pads
• Same 26 user GPIO pins at the same positions
• Same pin numbering
• Same power pin positions: 3V3, VSYS, VBUS, 3V3_EN, ADC_VREF, AGND, RUN
• Same peripheral pin mapping (SPI, I2C, UART, ADC on the same GPIOs)
• LED on GP25 (non-wireless) or WL_GPIO0 (wireless models)

No breaking pin changes between generations.

Architecture Switching (ARM vs RISC-V)

RP2350 contains both dual Cortex-M33 and dual Hazard3 RISC-V cores. One architecture is selected at build time; they cannot run simultaneously.

The boot ROM auto-detects ARM vs RISC-V from the binary and switches automatically.

Build for ARM (default)

cmake -DPICO_BOARD=pico2 ..

Build for RISC-V

export PICO_TOOLCHAIN_PATH=/opt/riscv/riscv-toolchain-14/
export PICO_PLATFORM=rp2350-riscv
cmake -DPICO_BOARD=pico2 ..

Prebuilt RISC-V toolchains: https://github.com/raspberrypi/pico-sdk-tools/releases

RISC-V Limitations

• No double-precision FPU (software float only)
• Some security features unavailable (TrustZone is ARM-specific)
• Must delete build directory and re-run cmake when switching architectures

Pico 2 W Wireless

SDK Libraries for Wireless

• pico_cyw43_driver / pico_cyw43_arch - Wi-Fi driver
• pico_lwip - TCP/IP networking
• pico_btstack - Bluetooth (BlueKitchen BTStack)
• pico_mbedtls - TLS/crypto

Wireless Pin Sharing

The SPI CLK to CYW43439 is shared with the VSYS voltage monitor. You can only read VSYS via ADC when no SPI transaction to the wireless chip is in progress. Similarly, CYW43439 DIN/OUT and IRQ share a pin.

Antenna Placement

Keep the antenna area free of metal. Grounded metal along the sides can improve bandwidth, but metal near or under the antenna degrades gain.

Security Features (RP2350 Only)

RP2040 has no security features. RP2350 adds:

Secure Boot with picotool

# Sign a binary
picotool seal --sign app.elf app.signed.elf private.pem otp.json

# Encrypt a binary (self-decrypting)
picotool encrypt --embed --sign app.elf app.enc.elf aes_key.bin iv_salt.bin private.pem otp.json

# Program OTP
picotool otp load otp.json

OTP Warnings

• OTP bits go from 0 to 1 and cannot be reversed. Permanent.
• Setting SECURE_BOOT_ENABLE without a boot key and with PICOBOOT disabled permanently bricks the device.
• Errata RP2350-E15: OTP permissions require running a small binary on-device. If secure boot is active, that binary must be signed. picotool handles this automatically.

Board Layout

SWD Debug Connector Location

Power Pins (40-pin edges)

• Pin 36: 3V3(OUT)
• Pin 37: 3V3_EN (pull to GND to turn off board)
• Pin 39: VSYS
• Pin 40: VBUS
• Pin 35: ADC_VREF
• Pin 33: AGND (analogue ground)
• Pin 30: RUN (active low reset)

Pico SDK and Toolchain Reference

Table of Contents

• Current Versions
• SDK Setup
• CMake Configuration
• Project Structure
• Toolchain Requirements
• picotool
• SDK Libraries
• stdio Configuration
• MicroPython
• CircuitPython
• BOOTSEL and UF2 Flashing
• Key References

Current Versions

SDK Setup

Clone and Configure

git clone https://github.com/raspberrypi/pico-sdk.git
cd pico-sdk
git submodule update --init
export PICO_SDK_PATH=$(pwd)

Submodules pull: tinyusb, cyw43-driver, lwip, btstack, mbedtls. Missing submodules cause build failures for USB and wireless features.

System Dependencies

Debian/Ubuntu:

sudo apt install cmake python3 build-essential gcc-arm-none-eabi \
  libnewlib-arm-none-eabi libstdc++-arm-none-eabi-newlib

macOS (Homebrew):

brew install cmake python arm-none-eabi-gcc

SDK Integration Methods

1. Cloned locally (most common): Copy external/pico_sdk_import.cmake into your project. Set PICO_SDK_PATH env var or pass -DPICO_SDK_PATH=... to cmake. 2. Git submodule: Include pico-sdk/pico_sdk_init.cmake directly. 3. Auto-download: Set PICO_SDK_FETCH_FROM_GIT=on before including pico_sdk_import.cmake.

CMake Configuration

Key Variables

Setting PICO_BOARD=pico2 automatically sets PICO_PLATFORM=rp2350-arm-s. Only set PICO_PLATFORM explicitly for RISC-V override.

Board definitions live in pico-sdk/src/boards/include/boards/ as header files.

Minimal CMakeLists.txt

cmake_minimum_required(VERSION 3.13...3.27)

include(pico_sdk_import.cmake)

project(my_project C CXX ASM)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

pico_sdk_init()

add_executable(my_app src/main.c)
target_link_libraries(my_app pico_stdlib)
pico_add_extra_outputs(my_app)  # generates .uf2, .bin, .hex, .map

Build Commands

# Pico 2 (ARM, default)
mkdir build && cd build
cmake -DPICO_BOARD=pico2 ..
make -j$(nproc)

# Pico 2 (RISC-V)
export PICO_TOOLCHAIN_PATH=/opt/riscv/riscv-toolchain-14/
mkdir build-riscv && cd build-riscv
cmake -DPICO_BOARD=pico2 -DPICO_PLATFORM=rp2350-riscv ..
make -j$(nproc)

# Pico 2 W
cmake -DPICO_BOARD=pico2_w ..

# Pico 1 (default if PICO_BOARD not set)
cmake ..
# or explicitly:
cmake -DPICO_BOARD=pico ..

# Debug build (for GDB debugging)
cmake -DPICO_BOARD=pico2 -DCMAKE_BUILD_TYPE=Debug ..

Project Structure

my_project/
  CMakeLists.txt
  pico_sdk_import.cmake      # copied from pico-sdk/external/
  src/
    main.c
  include/
    config.h

Full Example CMakeLists.txt (Pico 2 with USB stdio)

cmake_minimum_required(VERSION 3.13...3.27)

include(pico_sdk_import.cmake)

project(my_project C CXX ASM)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

pico_sdk_init()

add_executable(my_app
    src/main.c
)

target_include_directories(my_app PRIVATE include)

target_link_libraries(my_app
    pico_stdlib
    hardware_gpio
    hardware_i2c
    hardware_pio
    hardware_adc
)

# Enable USB output, disable UART output
pico_enable_stdio_usb(my_app 1)
pico_enable_stdio_uart(my_app 0)

pico_add_extra_outputs(my_app)

Toolchain Requirements

Also requires: CMake >= 3.13, Python 3, native C compiler (for SDK build tools).

RISC-V Toolchain Setup

# Download (example for aarch64 Linux)
wget https://github.com/raspberrypi/pico-sdk-tools/releases/download/v2.0.0-5/riscv-toolchain-14-aarch64-lin.tar.gz
sudo mkdir -p /opt/riscv/riscv-toolchain-14
tar xvf riscv-toolchain-14-aarch64-lin.tar.gz -C /opt/riscv/riscv-toolchain-14
export PICO_TOOLCHAIN_PATH=/opt/riscv/riscv-toolchain-14/

picotool

CLI tool for working with RP2040/RP2350 devices and binaries.

Installation

macOS: brew install picotool

Linux (from source):

git clone https://github.com/raspberrypi/picotool.git
cd picotool && mkdir build && cd build
cmake ..
make -j$(nproc)
sudo make install

Prebuilt: Download from https://github.com/raspberrypi/pico-sdk-tools/releases. Set picotool_DIR env var to the extracted path.

Commands

SDK Libraries

stdio Configuration

The SDK supports three stdio backends, selectable per-target in CMakeLists.txt:

# USB CDC (appears as serial port on host)
pico_enable_stdio_usb(my_app 1)
pico_enable_stdio_uart(my_app 0)

# UART (default UART0 on GP0/GP1)
pico_enable_stdio_usb(my_app 0)
pico_enable_stdio_uart(my_app 1)

# Both simultaneously
pico_enable_stdio_usb(my_app 1)
pico_enable_stdio_uart(my_app 1)

# RTT (via SWD debug channel, needs pico_stdio_rtt linked)

UART stdio is useful with the Debug Probe's UART bridge. USB stdio is convenient for standalone development without a Debug Probe.

MicroPython

UF2 Downloads

• Pico 2: https://micropython.org/download/RPI_PICO2/RPI_PICO2-latest.uf2
• Pico 2 W: https://micropython.org/download/RPI_PICO2_W/RPI_PICO2_W-latest.uf2

Differences from Pico 1

• Separate firmware builds (RPI_PICO2 vs rp2-pico)
• 520 kB SRAM available (vs 264 kB)
• Third PIO block (PIO2) accessible
• Cortex-M33 FPU for floating-point
• Wi-Fi/BT on Pico 2 W (CYW43439)

Workflow

Hold BOOTSEL, plug USB, device mounts as "RP2350", drag UF2 onto it. Use Thonny IDE or mpremote for interactive development.

CircuitPython

Fully supported on Pico 2. Current stable: 10.1.4. Download: https://circuitpython.org/board/raspberry_pi_pico2/

Benefits from Pico 2's 4 MB flash (larger filesystem), extra SRAM, and third PIO block.

BOOTSEL and UF2 Flashing

1. Hold BOOTSEL button while connecting Pico to USB 2. Device mounts as USB mass storage "RPI-RP2" 3. Drag and drop .uf2 file onto the drive 4. Pico reboots and runs new firmware

BOOTSEL is in read-only ROM and cannot be overwritten. It always works regardless of firmware state.

Flash Erase

Copy nuke.uf2 onto the device while in BOOTSEL to wipe external flash. Source: pico-examples/flash/nuke/nuke.c.

Partition Tables (RP2350)

RP2350 supports A/B partition tables in flash. picotool partition info shows the layout. UF2 family IDs: rp2350-arm-s (ARM) and rp2350-riscv (RISC-V).

Key References