Raspberry Pi Pico with Arduino IDE: Complete Setup Guide

The Raspberry Pi Pico has become a game-changer in the embedded systems world since its release. With a dual-core ARM processor, generous memory, and a price tag under $5, it’s hard to beat for prototyping and production work. But here’s what many engineers don’t realize initially: you can program the Raspberry Pi Pico Arduino-style using the familiar Arduino IDE, giving you access to thousands of existing libraries and sketches.

Having worked with dozens of microcontroller platforms over the years, I can say that combining the Pico Arduino IDE workflow offers an excellent balance of performance, cost-effectiveness, and development speed. This guide walks you through the complete setup process and gets you writing code within minutes.

Why Use Arduino IDE with Raspberry Pi Pico?

Before diving into the setup, let’s address the obvious question: why use Arduino IDE when the Pico has official support for MicroPython and the Pico C/C++ SDK?

The answer comes down to practicality. If you’ve spent years building Arduino projects, you have libraries you trust, code patterns you’ve refined, and a development workflow that works. The Pico Arduino IDE integration lets you leverage all that experience on superior hardware without starting from scratch.

Key Advantages of Raspberry Pi Pico Arduino Development

Advantage	Description
Familiar syntax	Standard Arduino functions (digitalWrite, analogRead, Serial) work identically
Library compatibility	Most Arduino libraries work directly or with minor modifications
Dual-core support	Run separate tasks on each core using Arduino’s multicore functions
Performance boost	133 MHz dual-core vs 16 MHz single-core on classic Arduino boards
Cost savings	Pico costs $4-6 vs $25+ for genuine Arduino boards
USB flexibility	Native USB support for HID devices, MIDI, and serial communication

The Pico’s RP2040 chip brings serious hardware to the Arduino ecosystem. We’re talking 264KB of SRAM compared to the Uno’s 2KB, and 2MB of flash versus 32KB. That’s not an incremental improvement—it’s a completely different class of capability.

Understanding the RP2040 Microcontroller

For engineers evaluating the Pico for Arduino projects, understanding the underlying hardware matters. The RP2040 isn’t just a faster ATmega328P; it’s architecturally different and that affects how your code runs.

RP2040 Technical Specifications

Specification	RP2040 (Pico)	ATmega328P (Arduino Uno)
Architecture	Dual-core ARM Cortex-M0+	Single-core 8-bit AVR
Clock Speed	133 MHz (overclockable to 250 MHz)	16 MHz
SRAM	264 KB	2 KB
Flash Storage	2 MB (external QSPI)	32 KB
GPIO Pins	26 multi-function	14 digital + 6 analog
ADC Resolution	12-bit	10-bit
PWM Channels	16	6
Operating Voltage	3.3V	5V
Price	~$4	~$25 (genuine)

The Programmable I/O (PIO) subsystem deserves special mention. These are essentially two small state machines that can handle precise timing-critical tasks independently of the main cores. For driving NeoPixels, implementing custom protocols, or handling encoder inputs, PIO offloads work that would otherwise consume CPU cycles.

Arduino IDE Installation Requirements

Getting the Pico Arduino IDE environment running requires the Arduino IDE itself plus board support packages. Here’s what you need before starting.

System Requirements

Platform	Minimum Requirements
Windows	Windows 10 or later, USB drivers (installed automatically)
macOS	macOS 10.14 or later
Linux	Any modern distribution with libusb support

Software Downloads

You’ll need to download the Arduino IDE from the official Arduino website. Both version 1.8.x (legacy) and version 2.x work with the Pico, though I recommend version 2.x for its improved editor and debugging features.

Critical Note for Windows Users: Do not install Arduino IDE from the Microsoft Store. The Store version has sandbox restrictions that prevent proper detection of Pico boards during upload. Download the standard Windows installer (.exe) or ZIP version directly from arduino.cc instead.

Step 1: Installing Arduino IDE

Download Arduino IDE 2.x from arduino.cc/en/software. Run the installer and accept defaults—nothing unusual here. On Windows, let it install any USB drivers it prompts for; these are necessary for board communication.

Launch Arduino IDE after installation. You’ll see the familiar interface, but we need to add Pico support since it’s not included by default.

Step 2: Adding the Pico Board Manager URL

The Arduino IDE uses Board Manager URLs to fetch support packages for non-standard boards. For the Raspberry Pi Pico, we’ll use the excellent arduino-pico core developed by Earle Philhower, which provides better compatibility than Arduino’s official mbed-based package.

Adding the Board Manager URL

Open Arduino IDE and navigate to:

• Windows/Linux: File → Preferences
• macOS: Arduino IDE → Settings

In the Preferences window, locate the “Additional boards manager URLs” field. Add this URL:

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

If you already have other board URLs (like for ESP32 or ESP8266), separate them with commas. The field accepts multiple URLs.

Click OK to save and close the Preferences dialog.

Step 3: Installing the Pico Board Package

With the board URL configured, you can now install the actual support package.

Navigate to Tools → Board → Boards Manager. In the search field, type “pico” or “RP2040”.

You’ll see “Raspberry Pi Pico/RP2040/RP2350 by Earle F. Philhower, III” in the results. Click the Install button.

Important: The installation downloads several hundred megabytes of toolchain files including the ARM GCC compiler. This process takes 5-15 minutes depending on your internet connection. Don’t interrupt it or click Cancel—let it complete fully.

Once installation finishes, close the Boards Manager. You now have Pico support in your Arduino IDE.

Step 4: Selecting Your Pico Board

With the board package installed, you need to tell Arduino IDE which specific board you’re using.

Go to Tools → Board → Raspberry Pi RP2040 Boards and select your board:

Board Model	Selection
Raspberry Pi Pico	Raspberry Pi Pico
Raspberry Pi Pico W	Raspberry Pi Pico W
Raspberry Pi Pico 2	Raspberry Pi Pico 2
Raspberry Pi Pico 2 W	Raspberry Pi Pico 2 W

The distinction matters—selecting the wrong variant can cause wireless functions to fail or the LED pin mapping to be incorrect.

Board Configuration Options

After selecting your board, the Tools menu shows several configuration options:

Option	Recommended Setting	Notes
CPU Speed	133 MHz	Default; increase for compute-heavy applications
USB Stack	Pico SDK	Default; switch to TinyUSB for HID projects
IP/Bluetooth Stack	IPv4 + IPv6	For Pico W wireless features
Flash Size	2MB (Sketch + FS)	Allocates space for LittleFS if needed
Debug Port	Disabled	Enable Serial for debugging output

For most projects, the defaults work fine. Adjust these as your specific requirements demand.

Step 5: Uploading Your First Sketch

Now comes the moment of truth: getting code onto your Pico. The upload process for the Pico differs slightly from traditional Arduino boards because the RP2040 uses a UF2 bootloader rather than a serial bootloader.

First-Time Upload Procedure

For the very first upload (or if your Pico is running MicroPython/CircuitPython), you need to manually enter bootloader mode:

1. Disconnect your Pico from USB if connected
2. Hold down the BOOTSEL button on the Pico board
3. While holding BOOTSEL, connect the USB cable to your computer
4. Release BOOTSEL after connecting

Your Pico now appears as a USB mass storage device (like a flash drive) named “RPI-RP2”. This indicates it’s in bootloader mode and ready to receive firmware.

Loading the Blink Example

Let’s start with the classic blink sketch to verify everything works.

Go to File → Examples → 01.Basics → Blink

The standard Blink example loads:

void setup() {

  pinMode(LED_BUILTIN, OUTPUT);

}

void loop() {

  digitalWrite(LED_BUILTIN, HIGH);

  delay(1000);

  digitalWrite(LED_BUILTIN, LOW);

  delay(1000);

}

This code works identically on the Pico as it does on any Arduino board. The LED_BUILTIN constant automatically maps to the correct GPIO pin for your selected board (GPIO 25 for Pico, GPIO 0 for Pico W).

Selecting the Port and Uploading

Before clicking Upload, check the port selection:

• Go to Tools → Port
• If your Pico is in bootloader mode, select “UF2 Board” or similar
• If the port doesn’t appear, enable “Show all ports” option

Click the Upload button (right arrow icon). The IDE compiles your sketch and uploads it to the Pico. First compilation takes longer as it builds the core libraries; subsequent compilations are much faster.

Success indicators:

• Upload progress shows in the console
• “Done uploading” message appears
• The onboard LED starts blinking

Subsequent Uploads

Here’s the good part: after your first successful Arduino upload, you don’t need to hold BOOTSEL anymore. The arduino-pico core includes auto-reset functionality that puts the Pico into bootloader mode automatically when you click Upload.

Just select the COM port that appears after the first upload (it will have a proper serial port number now), and upload as you would with any Arduino.

Working with Serial Communication

Serial debugging works exactly as expected on the Pico, but with some nuances worth understanding.

USB Serial Setup

The Pico’s USB serial port is virtual—it’s implemented in software rather than using a dedicated UART-to-USB chip. This means:

void setup() {

  Serial.begin(115200);

  while (!Serial) {

    ; // Wait for serial port to connect

  }

  Serial.println(“Pico is ready!”);

}

The while (!Serial) line is more important on the Pico than on boards with hardware USB-serial converters. Without it, your program might start running before the USB connection establishes, and you’ll miss early debug output.

Hardware UART

The Pico has two hardware UARTs in addition to USB serial:

Serial Object	Pins	Notes
Serial	USB	Virtual CDC serial over USB
Serial1	GPIO 0 (TX), GPIO 1 (RX)	First hardware UART
Serial2	GPIO 4 (TX), GPIO 5 (RX)	Second hardware UART

For communicating with external devices like GPS modules or other microcontrollers, use Serial1 or Serial2 to keep USB available for debugging.

Using Pico W Wireless Features

If you have a Pico W board, the arduino-pico core provides full WiFi support through familiar Arduino-style APIs.

Basic WiFi Connection

#include <WiFi.h>

const char* ssid = “YourNetworkName”;

const char* password = “YourPassword”;

void setup() {

  Serial.begin(115200);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {

    delay(500);

    Serial.print(“.”);

  }

  Serial.println(“\nConnected!”);

  Serial.println(WiFi.localIP());

}

The WiFi library syntax mirrors ESP32 and ESP8266 implementations, so existing code often works with minimal modification.

Bluetooth Support

The Pico W also supports Bluetooth Classic and BLE. The arduino-pico core includes libraries for:

• HID devices (keyboards, mice, gamepads)
• Serial Port Profile (SPP)
• BLE peripherals and centrals

Dual-Core Programming

One of the Pico’s major advantages is its dual-core processor. The arduino-pico core makes using both cores straightforward.

Running Code on Core 1

void setup() {

  Serial.begin(115200);

}

void setup1() {

  // This runs on core 1

}

void loop() {

  // This runs on core 0

  Serial.println(“Core 0 running”);

  delay(1000);

}

void loop1() {

  // This runs on core 1

  // Handle time-critical tasks here

}

The setup1() and loop1() functions execute on the second core automatically. This is incredibly useful for separating real-time tasks (motor control, sensor reading) from slower tasks (network communication, display updates).

Common Troubleshooting Issues

Even with careful setup, you might encounter issues. Here are the most common problems and their solutions.

Upload Fails: “No drive to deploy”

Cause: The Pico isn’t in bootloader mode or the IDE can’t detect it.

Solution:

1. Manually enter bootloader mode (hold BOOTSEL while connecting)
2. Check if RPI-RP2 drive appears in your file manager
3. On Linux with flatpak Arduino, run: flatpak override –user –filesystem=host:ro cc.arduino.IDE2

Upload Fails After First Successful Upload

Cause: The serial port changed or the auto-reset isn’t working.

Solution:

1. Select the correct COM port in Tools → Port
2. If no port appears, manually enter bootloader mode again
3. Check USB cable—some cables are power-only without data lines

Compilation Errors with Libraries

Cause: Library incompatibility with RP2040 architecture.

Solution:

• Check if the library supports ARM Cortex-M0+
• Look for RP2040-specific forks of popular libraries
• The arduino-pico documentation lists compatible libraries

Windows Store Version Issues

Cause: Sandbox restrictions prevent proper USB device access.

Solution: Uninstall the Store version and install Arduino IDE from the direct download at arduino.cc.

Useful Resources and Downloads

Here are essential links for Raspberry Pi Pico Arduino development:

Software Downloads:

• Arduino IDE: https://www.arduino.cc/en/software
• arduino-pico Core Documentation: https://arduino-pico.readthedocs.io/

Board Manager URL:

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

Official Documentation:

• Raspberry Pi Pico Datasheet: https://datasheets.raspberrypi.com/pico/pico-datasheet.pdf
• RP2040 Datasheet: https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf
• Pico Pinout Diagram: https://datasheets.raspberrypi.com/pico/Pico-R3-A4-Pinout.pdf

GitHub Repositories:

• arduino-pico Core: https://github.com/earlephilhower/arduino-pico
• LittleFS Plugin (IDE 2.x): https://github.com/earlephilhower/arduino-littlefs-upload

Utility Files:

• flash_nuke.uf2 (erases Pico flash): Available from Raspberry Pi documentation

Raspberry Pi Pico Board Variants Comparison

When selecting a Pico for your Arduino projects, consider which variant best fits your needs:

Board	Wireless	Price	Best For
Pico	No	~$4	Standalone projects, cost-sensitive designs
Pico H	No	~$5	Same as Pico, pre-soldered headers
Pico W	WiFi + Bluetooth	~$6	IoT projects, wireless connectivity
Pico WH	WiFi + Bluetooth	~$7	Pico W with pre-soldered headers
Pico 2	No	~$5	Performance-critical applications (RP2350)
Pico 2 W	WiFi + Bluetooth	~$7	Latest processor with wireless

All variants work with the arduino-pico core—just select the matching board in the IDE.

FAQs About Raspberry Pi Pico Arduino Setup

Can I use existing Arduino code on the Raspberry Pi Pico?

Yes, most Arduino sketches work on the Pico with little or no modification. Standard functions like digitalWrite(), analogRead(), Serial.print(), and delay() work identically. Libraries that don’t rely on AVR-specific hardware registers typically port directly. The main considerations are pin numbering differences and voltage levels (3.3V on Pico vs 5V on Uno).

Why choose the Earle Philhower core over Arduino’s official mbed core?

The Philhower core provides better bare-metal performance, more complete peripheral support (including PIO), easier multicore programming, and broader library compatibility. Arduino’s official mbed-based core adds an RTOS layer that increases complexity and memory usage. For most projects, the Philhower core is the recommended choice within the Pico community.

Does the Raspberry Pi Pico support 5V sensors and peripherals?

The Pico’s GPIO pins are strictly 3.3V and are not 5V tolerant. Connecting 5V signals directly will damage the RP2040. Use level shifters or voltage dividers when interfacing with 5V devices. However, the VBUS pin provides 5V from USB for powering external 5V components—just don’t feed that back into the GPIO pins.

How do I reset my Pico if it becomes unresponsive?

If your Pico hangs or won’t accept uploads, enter bootloader mode manually by holding BOOTSEL while connecting USB. For a complete reset, upload the flash_nuke.uf2 file to erase all flash contents, then reprogram. If the Pico previously ran MicroPython, this bootloader method is required for the first Arduino upload.

Can I use the Arduino IDE debugger with Raspberry Pi Pico?

Yes, but it requires additional hardware. The Pico supports SWD debugging through its debug pins. You’ll need a debug probe (another Pico can work as a “Picoprobe”) and OpenOCD configuration. The arduino-pico documentation covers this setup in detail. For most development, Serial.print() debugging is simpler and sufficient.

Final Thoughts

Setting up the Raspberry Pi Pico Arduino environment takes about 15 minutes and opens up a powerful development platform at a fraction of typical Arduino board costs. The combination of familiar Arduino syntax with the RP2040’s dual-core performance and extensive peripheral set creates an incredibly capable platform for embedded projects.

Whether you’re migrating existing Arduino projects to more capable hardware or starting fresh, the Pico Arduino IDE workflow delivers the best of both worlds: Arduino’s ecosystem accessibility and the RP2040’s raw performance. The extensive community support from both the Raspberry Pi and Arduino communities means you’ll find help for virtually any challenge you encounter.

Start with the Blink example, verify your setup works, then explore the more advanced features like dual-core processing, PIO state machines, and wireless connectivity. The Pico has depth that rewards exploration, and the Arduino IDE makes that exploration accessible.