This guide will show you how to use a Raspberry Pi Pico RP2040 to connect various sensors and breakouts to your PC running Windows, Mac OSX, or Linux. Special firmware gets loaded onto the Pico and turns it into a sort of Swiss army knife providing:

• General Purpose digital Input and Output (GPIO) for things like buttons and LEDs
• Analog to Digital Conversion (ADC) for reading analog signals
• Pulse Width Modulation (PWM) for servos or LED dimming
• I2C and SPI for connecting *lots* of external sensors, displays, etc.
• NeoPixels (WS2812B) for happy rainbow blinky fun!

This is very similar to what the FT232H and MCP2221 already provide.

The approach in this guide is useful if you want to run "regular" Python code on your main computer and have it communicate with external devices connected through the Pico (or other RP2040 board). If you are instead trying to run MicroPython code directly on the Pico and use CircuitPython libraries, then see this other guide: CircuitPython Libraries on MicroPython using the Raspberry Pi Pico.

The Magical u2if Firmware

The key element to enabling this capability on the Raspberry Pi Pico is thanks to the excellent u2if firmware written by execuc. The main repo not only contains the firmware that goes on the Pico itself, but micropython compliant Python code for interfacing to the Pico from your PC. So if you're more used to the micropython interface, then checkout the u2if repo. It has everything you need.

In this guide, we will use firmware from the Adafruit fork of the original u2if project:

Then, on the host PC, we will use the Adafruit Blinka library which has support for interfacing with a Pico, or other RP2040 based boards, running the u2if firmware.

CircuitPython Libraries on Personal Computers

This is essentially the same idea as discussed  in the FT232H Guide and the MCP2221 Guide. How can we directly connect common hardware items like buttons and LEDS (GPIO) or sensor breakouts (I2C/SPI) to a PC?

By loading the u2if firmware onto the Pico, it turns it into sort of a bridge using USB on the main PC. So you end up with something like this:

On the computer, we install Blinka which provides a CircuitPython compliant interface to the Pico with u2if. That way, all the CircuitPython libraries can then be used - on your PC!

Required Hardware

The main requirement is a supported RP2040 based board. The main guide and examples are based on the original Raspberry Pi Pico RP2040:

However, there are many other RP2040 based boards that are supported. See the Other RP2040 Boards section for details.

You'll need a USB cable for programming and interacting with the Pico - but you probably have one of these laying around. Just make sure it's not a charge only cable.

Beyond that, it all depends on what you want to do. There are examples provided later in this guide that show some typical use cases.

Other Hardware

If you're using STEMMA QT breakout boards, these cables can be helpful.

The first step is to install the u2if firmware from the Adafruit fork onto the Raspberry Pi Pico. This is super easy:

1. Download the latest release of u2if_pico.uf2 from the repo: https://github.com/adafruit/u2if/releases
2. Put the Pico in bootloader mode by holding the BOOTSEL button while plugging in the board.
3. Drag the downloaded UF2 file to the RPI-RP2 folder.
4. DONE!

The board will reset after the copy is complete. Note that no folders will show up. So it may seem like nothing happened.

Now the Pico will show up as two USB devices:

• USB HID (Human Interface Device)
• USB CDC (Communication Device Class)

The former provides a generic interface for sending 64 byte "reports" back and forth. The later is essentially a serial interface, aka "com port". How these show up on your PC will depend on OS.

linux dmesg

On linux, the dmesg output will look something like this when connecting the Pico:

Windows Device Manager

On Windows, several new entries should show up in Device Manager:

The main support for the Pico running the u2if firmware in Blinka utilizes the hidapi library. Some of the features rely on sending data via a serial connection. For that, we use the pyserial library. And to allow use of CircuitPython Libraries, we need the Blinka interface layer.

All of these in turn rely on a several other things which vary for different OS's. So before we can actually use the Pico, we need to get everything setup. See the OS specific sections for what we went through to get things working for each.

Additional Information

Just for reference, here are links to more information about the main Python libraries being used. Here's the README from the hidapi source code repo, which has some install information:

Here's the main documentation for pySerial:

The pySerial source code repo is here.

But first try the install instructions on the pages that follow for your OS.

Have Python 3 Installed

We assume you already have Python 3 installed on your computer. Note we do not support Python 2 - it's deprecated and no longer supported!

At your command line prompt of choice, check your Python version with python --version

Install hidapi

From the command line, manually install hidapi with

If the install fails with text that ends with something like:

distutils.errors.DistutilsError: Setup script exited with error: Microsoft Visual C++ 14.0 is required. Get it with "Microsoft Visual C++ Build Tools": https://visualstudio.microsoft.com/downloads/

then you will need to also install the Microsoft Visual C++ Build Tools. Thanks to @jklem for pointing this out in the forums.

Download it from here (same link as in text):

NOTE: You do not need the full Visual Studio IDE. Just the Build Tools.

This downloads a .exe file with a name like vs_BuildTools.exe. Run that to install the build tools and then try the pip install again.

Install Blinka

To install Blinka and its dependencies, run:

Set Environment Variable

You must do this every time before running circuitpython code, you can set it permanently in windows if you like, for now just type into the same cmd window you're using with Python

set BLINKA_U2IF=1

If you are using Windows Powershell, the syntax is a little different. In that case do:

$env:BLINKA_U2IF=1

Run the sanity checks.

Now move on to the Post Install Checks section and run the commands there to make sure everything is installed correctly.

We assume you already have Python 3 and brew available on your Mac. Thankfully, setup on MacOS X is not so bad!

Note: If you are running VMWare Fusion on MacOS, then you can also try the Windows install process.

Install libusb

Start by installing libusb with

brew install libusb

Install PySerial

Type pip3 install pyserial

Install hidapi

Type pip3 install hidapi

Install Blinka

Then pip3 install adafruit-blinka

Set Environment Variable 

You'll need to set this variable every time before running CircuitPython code. To do this, we set the environment variable BLINKA_U2IF.

You can set the variable by running:

Run the sanity checks.

Now move on to the Post Install Checks section and run the commands there to make sure everything is installed correctly.

The following shows a typical run through installing and setting things up on Linux.

Install libusb and libudev

Run the following:

and answer Y to the prompt. This should install libusb and libudev.

Setup udev rules

For this, we just follow recommended setup from the firmware. Use a text editor to create and edit a file named /etc/udev/rules.d/55-u2if.rules and add the following contents:

Install hidapi

To install hidapi, run:

Install pySerial

To install pySerial, run:

Install Blinka

To install Blinka and its dependencies, run:

Set environment variable

We need to manually signal to Blinka that we have a Pico running the u2if firmware. To do this we set the environment variable BLINKA_U2IF. The value doesn't matter, just use 1:

Run the sanity checks.

Now move on to the Post Install Checks section and run the commands there to make sure everything is installed correctly.

After going through all the install steps for your OS, run these checks as simple tests to make sure everything is installed correctly. Go ahead and plug in your Pico to a USB port on your PC.

Most of these tests are done via the Python REPL, at the >>> prompt. To get there, simply launch Python:

Check that hidapi is installed correctly

At the Python REPL, type:

The enumerate() command should dump a listing of everything attached to your USB ports. The last command is a test of the actual hid module imported and should return True.

Check that pySerial is installed correctly

At the Python REPL, type:

You should get a list of available COM ports.

Check that Pico can be found

At the Python REPL, type:

It should run without any errors:

If for some reason the Pico can not be found, you might see something like this:

Check your USB cable connection and double check that the u2if firmware is loaded.

If you want to continue testing in the same Python session, then make a quick call to close() to free up the device.

Or, just exit the Python session.

Check environment variable within Python

At the Python REPL, type:

If you get a KeyError it means you did not set the environment variable right:

If you have set it correctly, you'll get a value back:

Check Blinka is setup correctly

If all of the above checks pass, go ahead and try this as a quick sanity check that basic Blinka functionality is in place. At the Python REPL, type:

You should not get any errors and the various pins available on the Pico should be shown.

While the Raspberry Pi Pico allows the I2C and SPI pins to appear in multiple locations, the u2if firmware fixes these locations to specific pins.

Power Pins

• VBUS - micro-USB input voltage
• VSYS - main system input voltage
• 3V3 - regulated 3.3V output, 300mA max
• GND - main ground reference
• AGND - ground reference for GP26-29 and ADC0 and ADC1

GPIO Pins

• GP0 to GP28 - General Purpose Input Output (GPIO) as well as Pulse Width Modulation (PWM)

I2C Pins

• SCL0 - I2C port 0 clock
• SDA0 - I2C port 0 data
• SCL1 - I2C port 1 clock
• SDA1 - IC2 port 1 data

SPI Pins

• SCLK0 - SPI port 0 clock
• MOSI0 - SPI port 0 data out
• MISO0 - SPI port 0 data in
• SCLK1 - SPI port 1 clock
• MOSI1 - SPI port 1 data out
• MISO1 - SPI port 1 data in

ADC Pins

• ADC0 - Analog to Digital Converter (ADC) 0
• ADC1 - Analog to Digital Converter (ADC) 1

All right, now that all that annoying install stuff is done, let's have some fun.

The following sections will provide some basic examples for the main use cases - GPIO, ADC, PWM, I2C, SPI, and NeoPixel.

Installing Libraries for Breakouts

The general process for installing the CircuitPython library you are interested in will be the same as shown in the Python section of the Learn guide for your sensor. Just use pip3.

Digital Output

Let's blink a LED!

Here's the bread board layout. The resistor can be something around 1kOhm. We don't need to make the LED super bright.

And here's a complete blink program you can run to make the LED blink forever.

Digital Input

Let's read a button!

The cool thing here is that the Pico has internal pull up resistors. Therefore we don't need to add any additional external resistors, which you might see in some other wiring diagrams. The equivalent resistor is inside the Pico!

Here's the breadboard layout.

Here's the code to run. It will continuously print the button state.

• True = not pressed
• False = pressed

Digital Input and Output

Ok, let's put those two together and make the button turn on the LED. So we'll use two digital pins - one will be an input (button) and one will be an output (LED).

Here's the bread board layout.

And here's the code. Note how the code uses not to invert the button logic.

Let's read an analog signal!

For this, we'll use a small 10k trim pot to set up a voltage divider. Here's the wiring diagram:

And here's the code:

Spin the knob and the values should change.

Note that even though the Pico's ADC is 12 bits, the value is scaled to 16 bits to comply with the CircuitPython API.

Let's dim an LED!

To do this we will use Pulse Width Modulation (PWM) output. The duty_cycle of the PWM output will control the LED brightness. We'll combine this with the previous ADC example so we can use the knob to control the LED brightness. Here's the breadboard layout:

And here's the code to run:

Turn the knob and the LED should get dimmer and brighter.

Let's talk to an I2C sensor!

The Pico has two I2C ports. Remember that you can attach multiple sensors to a single port as long as each has a unique I2C address. So you don't need to use two just because you have two sensors.

We'll use the MSA301 sensor which can read acceleration. Here we show wiring via the header pins. But if you wanted to use the STEMMA QT connector, you could by using one of the pigtail breakout cables.

Install MSA301 Library

To install the MSA301 library, run the following:

Note that this step is the same as shown in the main MSA301 guide. You would do the same general process for any other sensor with a CircuitPython library.

Example Code

And then we can run the example from the library. Download it from here:

save it as msa301_simpletest.py and run it with:

Pick up the board and spin it around. You should see the values change:

Live Plot Example

This one is a little fancier and requires matplotlib to be installed on the host PC as well. This is the example shown running in the guide thumbnail image.

Here's the code:

Let's talk to a SPI sensor.

The Pico has two SPI ports. Remember that you can attach multiple sensors to a single port as long as each has a separate chip select (CS) pin.

Here we use a BME280 sensor on the secondary SPI port.

Install the BME280 Library

To install the BME280 library, run the following:

Note that this step is the same as shown in the main BME280 guide. You would do the same thing for any other sensor.

Run Example

Here's is the example code to run:

Save this as something like bme280_test.py and run it with:

and you should see it print out sensor readings over and over:

Let's light up some NeoPixels!

We could use the SPI port to do this, using the hack provided by the neopixel_spi library. But the u2if firmware supports the real deal. No need for the hack. Just wire NeoPixels to any available GP pin and use the normal neopixel library.

Here's an example wiring:

This example uses a 12 ring RGB NeoPixel. For any other setup, just change the number of pixels and possibly the pixel order.

Install NeoPixel Library

To install the NeoPixel library, run the following:

These are the same install instructions as found in the main NeoPixel guide.

Run Example

And here is the example code to drive the 12 NeoPixel ring. To keep things simple, we simply fill the ring with various colors.

Save that as something like neopixel_ring.py and then run with the following:

And the ring should light up!

Since the u2if firmware uses standard HID and CDC interfaces for communicating with the host PC, it can potentially run on any Raspberry Pi RP2040 based board, not just the Pico. The main code changes needed are:

• Provide appropriate USB PID and VID.
• Change pin mappings to specific RP2040 based board.

We've done that for several Adafruit RP2040 based boards. Details for each are provided below. For each, install the provided UF2 firmware, set the environment variable:

and then launch Python. The board will be auto detected based on USB PID and VID.

Feather RP2040

Use the firmware file u2if_feather.uf2 from the latest release.

Pico Firmware USB IDs:

• USB_VID = 0x239A
• USB_PID = 0x00F1

Example check-if-found test code:

Here is what you should see if you list the board pins:

Here is an example that scans for connected I2C devices. Make sure something is actually connected to the SCL/SDA pins or the STEMMA QT connector.

ItsyBitsy RP2040

Use the firmware file u2if_itsybitsy.uf2 from the latest release.

Pico Firmware USB IDs:

• USB_VID = 0x239A
• USB_PID = 0x00FD

Example check-if-found test code:

Here is what you should see if you list the board pins:

Here is a simple example program that reads the state of the BOOT button.

QT Py RP2040

Use the firmware file u2if_qtpy.uf2 from the latest release.

Pico Firmware USB IDs:

• USB_VID = 0x239A
• USB_PID = 0x00F7

Example check-if-found test code:

Here is what you should see if you list the board pins:

And here is a simple example to light the onboard NeoPixel:

Trinkey QT2040

Use the firmware file u2if_trinkey.uf2 from the latest release.

Pico Firmware USB IDs:

• USB_VID = 0x239A
• USB_PID = 0x0109

Example check-if-found test code:

Here is what you should see if you list the board pins:

Here is a simple example program that reads the state of the BOOT button.