Raspberry Pi Pico Size Guide: Dimensions, Variants, and Compact Sensor Build

The Anatomy of Pico Size: Dimensions and Variant Specs

The term "pico size" in embedded design refers specifically to the mechanical footprint established by the original Raspberry Pi Pico: 51mm × 21mm × 3.9mm (excluding pin headers). This 1,071 mm² footprint has become a de facto industry standard for compact microcontroller modules, dictating enclosure designs, PCB carrier boards, and breadboard layouts. When you design for the pico size, you are designing around a 0.1-inch (2.54mm) pin pitch with an 11.43mm (0.45-inch) gap between the two inner pin rows. This specific inner gap is exactly 0.15 inches wider than a standard solderless breadboard's center trench, allowing the board to straddle the trench perfectly with one row of pins on each side.

As of 2026, the Raspberry Pi foundation has expanded the family while strictly maintaining this mechanical envelope. Below is the definitive spec-sheet comparison of the current pico size lineup.

*Height includes pre-soldered 0.1" male headers. The bare PCB remains 3.9mm thick.

Designing for the 51x21mm Footprint

When routing a custom PCB to accept a pico size module, the physical constraints demand strict attention to keep-out zones and pad geometry. The castellated edge pads on the Pico allow for direct surface-mount soldering (SMT) to a host board, saving the 4.6mm of vertical Z-height that through-hole headers require.

For power delivery, the pico size footprint includes a dedicated VBUS pin (Pin 40) for 5V input and a VSYS pin (Pin 39). When designing a compact battery-powered node, feed your LiPo charge controller output directly to VSYS. The onboard RT6150 buck-boost converter will handle the regulation down to 3.3V, provided your input stays between 1.8V and 5.5V.

Build: Ultra-Compact I2C Environmental Node

To demonstrate the practical application of the pico size footprint, we will build a low-profile environmental logger. This build targets the Raspberry Pi Pico 2 (RP2350), leveraging its new deep-sleep capabilities and hardware I2C peripherals to read a BME280 sensor.

Parts List

• MCU: Raspberry Pi Pico 2 (Bare castellated pads, no headers)
• Sensor: Adafruit BME280 I2C Breakout (Product ID: 2652)
• Power: Adafruit 3.7V 500mAh LiPo Battery (Product ID: 1578)
• Charger: Adafruit Micro Lipo Charger (MCP73831 breakout, Product ID: 1904)
• Substrate: 51x21mm custom 2-layer PCB or 0.1" perfboard cut to size

Pin Mapping Table

Assembly Steps

1. Prep the Substrate: If using perfboard, cut it to exactly 51mm x 21mm using a scoring knife and straight edge. Deburr the edges to prevent shorting against the Pico's castellated pads.
2. Solder the MCU: Apply a thin layer of tacky flux to the perfboard pads. Align the Pico 2 castellated edges with the board. Use a chisel-tip iron at 350°C and 0.5mm 63/37 rosin-core solder to flow solder into each castellated half-moon pad. Verify continuity between adjacent pins to ensure no bridges.
3. Mount the Sensor: Solder the BME280 breakout directly to the opposite end of the perfboard using 4-pin right-angle headers to keep the Z-height under 10mm.
4. Wire the I2C Bus: Route 30 AWG wire-wrap wire from GP2 to SDA, GP3 to SCL, 3V3 to VIN, and GND to GND. The Adafruit BME280 breakout includes onboard 10kΩ pull-ups, so external resistors are optional for short runs (<10cm), but add 4.7kΩ resistors if you experience signal degradation.
5. Power Integration: Solder the LiPo battery JST-PH connector to the MCP73831 charger board. Connect the charger's VOUT to the Pico 2's VSYS pin (Pin 39) and GND to GND.

MicroPython Firmware

Flash the latest MicroPython UF2 for the RP2350. The code below includes robust hardware scanning and error handling to prevent hard crashes during I2C bus faults.

import machine
import utime
import bme280

# Pin definitions for Pico 2 (RP2350)
I2C_SDA = 2
I2C_SCL = 3
LED_PIN = 25  # Pico 2 onboard LED

# Initialize I2C1 at 400kHz
i2c = machine.I2C(1, sda=machine.Pin(I2C_SDA), scl=machine.Pin(I2C_SCL), freq=400000)
led = machine.Pin(LED_PIN, machine.Pin.OUT)

def scan_and_init():
    """Scan I2C bus and initialize BME280 with error handling."""
    devices = i2c.scan()
    if not devices:
        print("FATAL: No I2C devices found. Check wiring.")
        return None
    
    # BME280 default I2C address is 0x76 or 0x77
    bme_addr = 0x76 if 0x76 in devices else (0x77 if 0x77 in devices else None)
    
    if bme_addr is None:
        print(f"FATAL: BME280 not found. Detected addresses: {[hex(d) for d in devices]}")
        return None
        
    return bme280.BME280(i2c=i2c, address=bme_addr)

sensor = scan_and_init()

if sensor:
    print("BME280 initialized successfully.")
    while True:
        try:
            # Read sensor data
            temp_c = float(sensor.temperature[:-1])  # Strip 'C' character
            humidity = float(sensor.humidity[:-1])   # Strip '%' character
            pressure = float(sensor.pressure[:-3])   # Strip 'hPa' characters
            
            print(f"Temp: {temp_c:.2f}C | Hum: {humidity:.1f}% | Press: {pressure:.1f}hPa")
            
            # Blink LED to indicate successful read
            led.value(1)
            utime.sleep(0.1)
            led.value(0)
            
        except OSError as e:
            # Catch I2C bus errors without crashing the loop
            print(f"I2C Read Error: {e}. Retrying in 5s...")
            led.value(0)
            
        utime.sleep(5)
else:
    # Blink LED rapidly if sensor fails to init
    while True:
        led.toggle()
        utime.sleep(0.2)

Debugging: Resolving I2C Bus Errors on Compact Layouts

When packing components into the pico size footprint, physical wiring is compressed, leading to a higher incidence of bus communication faults. The most common error you will encounter in the Thonny REPL when running the script above is:

OSError: [Errno 121] Remote I/O error

This exact error string indicates that the RP2350's I2C peripheral sent a clock pulse and address byte, but received a NACK (No Acknowledge) from the target device, or the bus was pulled low by a fault.

First Three Things to Check

1. Castellated Pad Continuity: Compact builds often suffer from "cold" solder joints on the edge pads. Set your multimeter to continuity mode. Place one probe on the Pico 2's GP2 test point (or the physical pin leg) and the other on the BME280 SDA pad. You must read < 1 ohm. If it reads open or >5 ohms, reflow the joint with fresh flux.
2. I2C Address Jumper State: The BME280 breakout has an address selection pad. If the default 0x76 address is NACKing, check if the trace on the back of the sensor board was accidentally cut or bridged during your perfboard soldering. Use i2c.scan() to verify if it shifted to 0x77.
3. Pull-Up Resistor Weakness: The 3V3 rail on the Pico can experience micro-brownouts when the WiFi radio (if using a W variant) or the sensor wakes up. If your 10kΩ onboard pull-ups are too weak to pull the line high before the next clock edge, the bus fails. Add external 4.7kΩ pull-up resistors to SDA and SCL to stiffen the bus.

Extending and Simplifying the Node

The beauty of the 51x21mm footprint is its modularity. Depending on your deployment environment, you can easily scale this build up or down.

How to Simplify (Bench Testing Mode)

If you are strictly prototyping and don't need battery operation, strip out the LiPo and MCP73831 charger. Power the board directly via the micro-USB connector. In your MicroPython code, remove the sleep functions and increase the I2C polling rate to 10Hz to stress-test the thermal characteristics of the BME280 in a confined enclosure.

How to Extend (Deep Sleep Field Deployment)

For long-term field logging, the RP2350 in the Pico 2 offers vastly improved sleep states compared to the original RP2040. To extend battery life from days to months:

• Hardware: Add a DS3231 RTC module wired to the Pico's RUN pin (Pin 1) via an N-channel MOSFET. The RTC can pull the RUN pin low to completely cut power to the RP2350, dropping quiescent current to < 5µA.
• Firmware: Utilize the machine.deepsleep() function in MicroPython. Before sleeping, ensure you explicitly de-initialize the I2C bus (i2c.deinit()) and set all unused GPIO pins to machine.Pin.IN with pull-downs to prevent leakage current through the sensor's protection diodes.
• Enclosure: Design a 3D-printed PETG enclosure with internal dimensions of 53mm x 23mm x 12mm. Include a louvered vent section directly over the BME280 humidity sensor to allow ambient air exchange while blocking direct sunlight and rain.

By strictly adhering to the mechanical realities of the pico size footprint, you eliminate the guesswork from embedded hardware design, ensuring your carrier boards, enclosures, and firmware map perfectly to the silicon.