CircuitPython Libraries on Linux and

Orange Pi
Created by lady ada

https://learn.adafruit.com/circuitpython-on-orangepi-linux

Last updated on 2023-04-27 10:50:27 AM EDT

©Adafruit Industries Page 1 of 57

 Table of Contents

Overview 5
• Why CircuitPython?
• CircuitPython on Microcontrollers
• CircuitPython Libraries on Desktop Linux

CircuitPython & OrangePi 7

• CircuitPython on Linux & Orange Pi
• Wait, isn't there already something that does this - WiringOP?
• What about other Linux SBCs or other Orange Pi's?

Orange Pi PC Setup 8
• Install ARMbian on your Orange Pi
• Logging in
• Install Python and set Python 3 to Default
• Install libgpiod
• Update Your Board and Python
• Enable UART, I2C and SPI
• Install Python libraries

Orange Pi R1 Setup 15
• Install ARMbian on your Orange Pi
• Connecting the GPIO/Debug Header
• Prepare the header strip:
• Place the header:
• And Solder!
• You're done!
• Logging in using Serial
• Connecting using DHCP and SSH
• MacOS/Linux
• Windows
• Set your Python install to Python 3 Default
• Install libgpiod
• Install Required pip3 Modules
• Update Your Board and Python
• Enable UART, I2C and SPI
• Install Python libraries

Digital I/O 26
• Parts Used
• Wiring
• Blinky Time!
• Button It Up

I2C Sensors & Devices 31

• Parts Used
• Wiring
• Install the CircuitPython BME280 Library
• Run that code!

SPI Sensors & Devices 37

• Parts Used
• Wiring

©Adafruit Industries Page 2 of 57

 • Install the CircuitPython MAX31855 Library
• Run that code!

UART / Serial 43
• The Easy Way - An External USB-Serial Converter
• The Hard Way - Using Built-in UART
• Install the CircuitPython GPS Library
• Run that code!

More To Come! 50

FAQ & Troubleshooting 50

• Update Blinka/Platform Libraries

©Adafruit Industries Page 3 of 57

©Adafruit Industries Page 4 of 57
 Overview
This guide describes using CircuitPython -libraries- on small Linux computers,
running under regular Python. It is not about running the CircuitPython firmware
itself on those boards.

Here at Adafruit we're always looking for ways to make making easier - whether that's
making breakout boards for hard-to-solder sensors or writing libraries to simplify
motor control. Our new favorite way to program is CircuitPython.

Why CircuitPython?

CircuitPython is a variant of MicroPython, a very small version of Python that can fit on
a microcontroller. Python is the fastest-growing programming language. It's taught in
schools, used in coding bootcamps, popular with scientists and of course
programmers at companies use it a lot!

CircuitPython adds the Circuit part to the Python part. It lets you program in Python
and talk to Circuitry like sensors, motors, and LEDs!

CircuitPython on Microcontrollers

CircuitPython runs on microcontroller boards, such as our Feather, Metro, QT Py, and
ItsyBitsy boards, using a variety of chips, such as the MicroChip SAMD21 SAMD51, the

©Adafruit Industries Page 5 of 57

 Raspberry Pi RP2040, the Nordic nRF52840, and the Espressif ESP32-S2 and ESP32-
S3.

All of these chips have something in common - they are microcontrollers with
hardware peripherals like SPI, I2C, ADCs etc. We squeeze Python into 'em and can
then make the project portable.

But...sometimes you want to do more than a microcontroller can do. Like HDMI video
output, or camera capture, or serving up a website, or just something that takes more
memory and computing than a microcontroller board can do...

CircuitPython Libraries on Desktop Linux

By adding a software layer, you can use CircuitPython hardware control capabilities wi
th "regular Python", as found on your desktop or single-board Linux computer/ There
are tons of projects, libraries and example code for CircuitPython on microcontrollers,
and thanks to the flexibility and power of Python its' pretty easy to get that code
working on micro-computers like the Raspberry Pi or other single-board Linux
computers with GPIO pins available.

You'll use a special library called adafruit_blinka () (named after Blinka, the

CircuitPython mascot ()) that provides a layer that translates the CircuitPython
hardware API to whatever library the Linux board provides. For example, on
Raspberry Pi we use the python RPi.GPIO () library. For any I2C interfacing we'll use
ioctl messages to the  /dev/i2c  device. For SPI we'll use the  spidev  python library,
etc. These details don't matter so much because they all happen underneath the adaf
ruit_blinka layer.

The upshot is that most code we write for CircuitPython will be instantly and easily
runnable on Linux computers like Raspberry Pi.

In particular, you'll be able to use all of our device drivers - the sensors, led
controllers, motor drivers, HATs, bonnets, etc. And nearly all of these use I2C or SPI!

The rest of this guide describes how to install and set up Blinka, and then how to use
it to run CircuitPython code to control hardware.

©Adafruit Industries Page 6 of 57

 CircuitPython & OrangePi

CircuitPython on Linux & Orange Pi

The next obvious step is to bring CircuitPython back to 'desktop Python'. We've got
tons of projects, libraries and example code for CircuitPython on microcontrollers, and
thanks to the flexibility and power of Python its pretty easy to get it working with
micro-computers like Orange Pi or other 'Linux with GPIO pins available' single board
computers.

We'll use a special library called adafruit_blinka () (named after Blinka, the
CircuitPython mascot ()) to provide the layer that translates the CircuitPython
hardware API to whatever library the Linux board provides. For example, on Orange Pi
we use the python libgpiod bindings. For any I2C interfacing we'll use ioctl messages
to the /dev/i2c device. For SPI we'll use the spidev python library, etc. These
details don't matter so much because they all happen underneath the adafruit_blinka
layer.

The upshot is that any code we have for CircuitPython will be instantly and easily
runnable on Linux computers like Orange Pi.

In particular, we'll be able to use all of our device drivers - the sensors, led controllers,
motor drivers, HATs, bonnets, etc. And nearly all of these use I2C or SPI!

©Adafruit Industries Page 7 of 57

 Wait, isn't there already something that does this -
WiringOP?

WiringOP, a modification of WiringPi, is for GPIO usage only, it doesn't work well for
various I2C or SPI devices.

By letting you use CircuitPython on Raspberry Pi via adafruit_blinka, you can unlock
all of the drivers and example code we wrote! And you can keep using WiringOP for
pins, buttons and LEDs. We save time and effort so we can focus on getting code that
works in one place, and you get to reuse all the code we've written already.

Right now, Blinka only supports the Orange Pi PC (because that's the only board
we've got for testing).

What about other Linux SBCs or other Orange Pi's?

Yep! Blinka can easily be updated to add other boards. We've started with the one
we've got, so we could test it thoroughly. If you have an OrangePi or other SBC board
you'd like to adapt check out the adafruit_blinka code on github (), pull requests are
welcome as there's a ton of different Linux boards out there!

Orange Pi PC Setup
This page is for the Orange Pi PC only!

Once armbian is installed, its easy to tell what board you have, simply cat /etc/
armbian-release and look for BOARD_NAME

©Adafruit Industries Page 8 of 57

 Install ARMbian on your Orange Pi
We're only going to be using armbian, other distros could be made to work but you'd
probably need to figure out how to detect the platform since we rely on /etc/
armbian-release existing.

Download and install the latest armbian, for example we're using https://
www.armbian.com/orange-pi-pc-plus/ ()

There's some documentation to get started at https://docs.armbian.com/User-

Guide_Getting-Started/ ()

Blinka only supports ARMbian because that's the most stable OS we could find
and it's easy to detect which board you have

We've found the easiest way to connect is

through a console cable, wired to the
debug port, and then on your computer,
use a serial monitor at 115200 baud.

Logging in
USB to TTL Serial Cable - Debug /
Console Cable for Raspberry Pi
The cable is easiest way ever to connect
to your microcontroller/Raspberry Pi/WiFi
router serial console port. Inside the big
USB plug is a USB<->Serial conversion
chip and at...
https://www.adafruit.com/product/954

©Adafruit Industries Page 9 of 57

 Once powered correctly and with the right
SD card you should get a login prompt

After logging in you may be asked to

create a new username, we recommend pi
- if our instructions end up adding gpio
access for the pi user, you can copy and
paste em

Once installed, you may want to enable mdns so you can ssh pi@orangepipc
instead of needing to know the IP address:

• sudo apt-get install avahi-daemon

then reboot

©Adafruit Industries Page 10 of 57

 Install Python and set Python 3 to Default
There's a few ways to do this, we recommend something like this

sudo apt-get install -y python3 git python3-pip

sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.5 2
sudo update-alternatives --config python

Of course change the version numbers if newer Python is distributed

Install libgpiod
libgpiod is what we use for gpio toggling. To install run this command:

sudo apt-get install libgpiod2 python3-libgpiod

pip3 install gpiod

After installation you should be able to import gpiod from within Python3

Update Your Board and Python

Run the standard updates:

sudo apt-get update

sudo apt-get upgrade

and

sudo pip3 install --upgrade setuptools

Update all your python 3 packages with

©Adafruit Industries Page 11 of 57

 pip3 freeze - local | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip3
install -U

and

sudo bash

pip3 freeze - local | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip3

install -U

Enable UART, I2C and SPI

A vast number of our CircuitPython drivers use UART, I2C and SPI for interfacing so
you'll want to get those enabled.

You only have to do this once per board but by default all three interfaces are
disabled!

Install the support software with

sudo apt-get install -y python-

smbus python-dev i2c-tools
sudo adduser pi i2c

Read /etc/armbian-release to figure out

your board family, in this case its a sun8i

©Adafruit Industries Page 12 of 57

 Edit /boot/armbianEnv.txt and add these lines at the end, adjusting the
overlay_prefix for your particular board

overlay_prefix=sun8i-h3
overlays=uart3 i2c0 spi-spidev
param_spidev_spi_bus=0

Once you're done with both and have rebooted, verify you have the I2C and SPI
devices with the command ls /dev/i2c* /dev/spi*

You should see at least one i2c device and one spi device

You can test to see what I2C addresses

are connected by running sudo
i2cdetect -y 0 (on PA11/PA12) or sudo
i2cdetect -y 1 (on PA18/PA19)

In this case I do have a sensor on the

'standard' i2c port i2c-0 under address
0x77

You can also install WiringOP and then run gpio readall to see the MUX status. If
you see ALT3 next to a pin, its a plain GPIO. If you see ALT4 or ALT5, its an SPI/I2C/
UART peripheral

©Adafruit Industries Page 13 of 57

 Install Python libraries
Now you're ready to install all the python support

Run the following command to install adafruit_blinka

pip3 install adafruit-blinka

The computer will install a few different libraries such as adafruit-pureio (our
ioctl-only i2c library), spidev (for SPI interfacing), Adafruit-GPIO (for detecting
your board) and of course adafruit-blinka

That's pretty much it! You're now ready to test.

Create a new file called blinkatest.py with nano or your favorite text editor and put the
following in:

©Adafruit Industries Page 14 of 57

 import board
import digitalio
import busio

print("Hello blinka!")

# Try to great a Digital input

pin = digitalio.DigitalInOut(board.PA6)
print("Digital IO ok!")

# Try to create an I2C device

i2c = busio.I2C(board.SCL, board.SDA)
print("I2C ok!")

# Try to create an SPI device

spi = busio.SPI(board.SCLK, board.MOSI, board.MISO)
print("SPI ok!")

print("done!")

Save it and run at the command line with

sudo python3 blinkatest.py

You should see the following, indicating digital i/o, I2C and SPI all worked

Orange Pi R1 Setup
This page is for the Orange Pi R1 only!

Once armbian is installed, its easy to tell what board you have, simply cat /etc/
armbian-release and look for BOARD_NAME

©Adafruit Industries Page 15 of 57

 Install ARMbian on your Orange Pi
We're only going to be using armbian, other distros could be made to work but you'd
probably need to figure out how to detect the platform since we rely on /etc/
armbian-release existing.

Download and install the latest armbian, for example we're using https://
www.armbian.com/orange-pi-r1/ ()

There's some documentation to get started at https://docs.armbian.com/User-

Guide_Getting-Started/ ()

Blinka only supports ARMbian because that's the most stable OS we could find
and it's easy to detect which board you have

We've found the easiest way to connect is

through a console cable, wired to the
debug port, and then on your computer,
use a serial monitor at 115200 baud. For
the Orange Pi R1, you will also need to
solder a header for debugging and GPIO
access to the Orange Pi R1.

©Adafruit Industries Page 16 of 57

 Color Coded Header for Raspberry Pi
Here's a snazzy accessory for your
Raspberry Pi Zero or Zero W, a color-
coded 2x20 header! This Color Coded
Header takes the mystery out of your
Raspberry...
https://www.adafruit.com/product/3907

Connecting the GPIO/Debug Header

Because the Orange Pi R1 does not come with any GPIO headers, you will need to
solder one in order to connect breakout boards.

Prepare the header strip:

Cut the strip to length. You will want to
make a cut to the side of the blue strip that
is closer to the center. After cutting, you
should have one piece that is 2x13 pins
and another that is 2x7 pins.

©Adafruit Industries Page 17 of 57

 Place the header:
Because the ethernet ports are on the tall
side, we found that placing a small object
under the header such as a small piece of
foam works well.

And Solder!
Be sure to solder all pins for reliable
electrical contact.

(For tips on soldering, be sure to check out

our Guide to Excellent Soldering ()).

Check your solder joints visually and

continue onto the next steps

©Adafruit Industries Page 18 of 57

 You're done!
Continue on to the next steps.

Logging in using Serial

To log in through serial, you will need to connect a USB to TTL Serial cable up to the
Orange Pi. You may also need to install some software. Be sure to check out our Adaf
ruit's Raspberry Pi Lesson 5. Using a Console Cable () guide. Although it is written for
a Raspberry Pi, the drivers and cable connection should be the same.

USB to TTL Serial Cable - Debug /

Console Cable for Raspberry Pi
The cable is easiest way ever to connect
to your microcontroller/Raspberry Pi/WiFi
router serial console port. Inside the big
USB plug is a USB<->Serial conversion
chip and at...
https://www.adafruit.com/product/954

Connect the serial cable's TX (White), RX

(Green), and Ground (Black) wires to the 3
pins next to the ethernet ports as shown in
the photo and start your terminal program.

©Adafruit Industries Page 19 of 57

 Once powered correctly and with the right
SD card you should get a login prompt

After logging in you may be asked to

create a new username, we recommend pi
- if our instructions end up adding gpio
access for the pi user, you can copy and
paste em

Once installed, you may want to enable mDNS so you can ssh [email protected]
instead of needing to know the IP address:

• sudo apt-get install avahi-daemon

©Adafruit Industries Page 20 of 57

 then reboot

Connecting using DHCP and SSH

Another option that you may be available to you is to connect using SSH, or Secure
Shell. To connect, you will need to have DHCP, or Dynamic Host Configuration
Protocol, enabled and configured on your network and look up the IP address
assigned to the Orange Pi R1.

By default, most routers have DHCP enabled and some routers will display all of the
hosts connected to them through the web configuration panel. If you are able to
retrieve the IP address, then you can connect through SSH.

MacOS/Linux

Mac and Linux should have SSH installed by default and you can access it by going to
the command line and typing ssh [email protected] if the IP address of your
Orange Pi is 192.168.0.25.

Windows

The easiest way to connect with windows is to use a Terminal program called PuTTY
from https://www.putty.org ().

You can read more about connecting through SSH in our Adafruit's Raspberry Pi
Lesson 6. Using SSH () guide. Although this is written for Raspberry Pi, the steps
should be the same.

Set your Python install to Python 3 Default

There's a few ways to do this, we recommend something like this

sudo apt-get install -y python3 git python3-pip

sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.5 2
sudo update-alternatives --config python

Of course change the version numbers if newer Python is distributed

©Adafruit Industries Page 21 of 57

 Install libgpiod
libgpiod is what we use for gpio toggling. To install run this command:

sudo apt-get install libgpiod2 python3-libgpiod

pip3 install gpiod

After installation you should be able to  import gpiod  from within Python3

Install Required pip3 Modules

For the Orange Pi R1, a couple of pip modules are required to smooth out the
installation.

Run the following command.

sudo pip3 install wheel flask

Update Your Board and Python

Run the standard updates:

sudo apt-get update

sudo apt-get upgrade

and

sudo pip3 install --upgrade setuptools

Update all your python 3 packages with

pip3 freeze - local | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip3

install -U

©Adafruit Industries Page 22 of 57

 and

sudo bash

pip3 freeze - local | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip3

install -U

Enable UART, I2C and SPI

A vast number of our CircuitPython drivers use UART, I2C and SPI for interfacing so
you'll want to get those enabled.

You only have to do this once per board but by default all three interfaces are
disabled!

Install the support software with

sudo apt-get install -y python-

smbus python-dev i2c-tools
sudo adduser pi i2c

Read /etc/armbian-release to figure out

your board family, in this case its a sun8i

Edit /boot/armbianEnv.txt and add these lines at the end, adjusting

the  overlay_prefix  for your particular board

©Adafruit Industries Page 23 of 57

 overlay_prefix=sun8i-h3
overlays=uart1 i2c0 spi-spidev usbhost2 usbhost3
param_spidev_spi_bus=1

Once you're done with both and have rebooted, verify you have the I2C and SPI
devices with the command  ls /dev/i2c* /dev/spi*

You should see at least one i2c device and one spi device

You can test to see what I2C addresses

are connected by running  sudo
i2cdetect -y 0 (on PA11/PA12)

In this case I do have a sensor on the

'standard' i2c port i2c-0 under address
0x77

You can also install WiringOP-Zero and then run  gpio readall  to see the MUX
status. If you see ALT3 next to a pin, it's a plain GPIO. If you see ALT4 or ALT5, its an
SPI/I2C/UART peripheral

©Adafruit Industries Page 24 of 57

 Install Python libraries
Now you're ready to install all the python support

Run the following command to install adafruit_blinka

sudo pip3 install adafruit-blinka

The computer will install a few different libraries such as  adafruit-pureio  (our
ioctl-only i2c library),  spidev  (for SPI interfacing),  Adafruit-GPIO  (for detecting
your board) and of course  adafruit-blinka

That's pretty much it! You're now ready to test.

Create a new file called blinkatest.py with nano or your favorite text editor and put the
following in:

©Adafruit Industries Page 25 of 57

 import board
import digitalio
import busio

print("Hello blinka!")

# Try to great a Digital input

pin = digitalio.DigitalInOut(board.PA6)
print("Digital IO ok!")

# Try to create an I2C device

i2c = busio.I2C(board.SCL, board.SDA)
print("I2C ok!")

# Try to create an SPI device

spi = busio.SPI(board.SCLK, board.MOSI, board.MISO)
print("SPI ok!")

print("done!")

Save it and run at the command line with

sudo python3 blinkatest.py

You should see the following, indicating digital i/o, I2C and SPI all worked

Digital I/O
The first step with any new hardware is the 'hello world' of electronics - blinking an
LED. This is very easy with CircuitPython and Orange Pi. We'll extend the example to
also show how to wire up a button/switch.

Orange Pi (Allwinner) boards don't have any way to set the pullup/pulldown
resistors, so you'll need to use external resistors instead of built-in pullups,
whenever it makes sense!

©Adafruit Industries Page 26 of 57

 Parts Used
Any old LED will work just fine as long as its not an IR LED (you can't see those) and a
470 to 2.2K resistor

Diffused Blue 10mm LED (25 pack)

Need some big indicators? We are big
fans of these huge diffused blue LEDs.
They are really bright so they can be seen
in daytime, and from any angle. They go
easily into a breadboard...
https://www.adafruit.com/product/847

©Adafruit Industries Page 27 of 57

 Through-Hole Resistors - 470 ohm 5%
1/4W - Pack of 25
ΩMG! You're not going to be able to resist
these handy resistor packs! Well, axially,
they do all of the resisting for you!This is a
25 Pack of...
https://www.adafruit.com/product/2781

Some tactile buttons or switches

Tactile Switch Buttons (12mm square,

6mm tall) x 10 pack
Medium-sized clicky momentary switches
are standard input "buttons" on electronic
projects. These work best in a PCB but
https://www.adafruit.com/product/1119

We recommend using a breadboard and some female-male wires.

Premium Female/Male 'Extension' Jumper

Wires - 40 x 6" (150mm)
Handy for making wire harnesses or
jumpering between headers on PCB's.
These premium jumper wires are 6"
(150mm) long and come in a 'strip' of 40 (4
pieces of each of...
https://www.adafruit.com/product/826

You can use a Cobbler to make this a little easier, the pins will be labeled according to
Raspberry Pi names so just check the Orange Pi name!

©Adafruit Industries Page 28 of 57

 Adafruit Pi Cobbler + Kit- Breakout Cable
for Pi B+/A+/Pi 2/Pi 3
The Raspberry Pi B+ has landed on the
Maker World like a 40-GPIO pinned, quad-
USB ported, credit card sized bomb of
DIY joy. And while you can use most of
our great Model B accessories...
https://www.adafruit.com/product/1990

Assembled Pi T-Cobbler Plus - GPIO

Breakout
This is the assembled version of the Pi T-
Cobbler Plus.  It only works with the
Raspberry Pi Model Zero, A+, B+, Pi 2, Pi 3
& Pi 4! (Any Pi with 2x20...
https://www.adafruit.com/product/2028

Wiring
Connect the Orange Pi Ground pin to the blue ground rail on the breadboard.

• Connect one side of the tactile switch to Orange Pi GPIO PA6

• Connect a ~10K pull up resistor from PA6 to 3.3V
• Connect the other side of the tactile switch to the ground rail
• Connect the longer/positive pin of the LED to Orange Pi GPIO PD14
• Connect the shorter/negative pin of the LED to a 470ohm  to 2.2K resistor, the
other side of the resistor goes to ground rail

There's no Orange Pi PC Fritzing object, so we sub'd a Raspberry Pi in

©Adafruit Industries Page 29 of 57

 orangepigpio.fzz

Double-check you have the right wires connected to the right location, it can be
tough to keep track of Pi pins as there are forty of them!

No additional libraries are needed so we can go straight on to the example code

However, we recommend running a pip3 update!

pip3 install --upgrade adafruit_blinka

Blinky Time!
The finish line is right up ahead, lets start with an example that blinks the LED on and
off once a second (half a second on, half a second off):

import time
import board
import digitalio

print("hello blinky!")

led = digitalio.DigitalInOut(board.PD14)
led.direction = digitalio.Direction.OUTPUT

while True:
led.value = True
time.sleep(0.5)

©Adafruit Industries Page 30 of 57

 led.value = False
time.sleep(0.5)

Verify the LED is blinking. If not, check that it's wired to GPIO PD14, the resistor is
installed correctly, and you have a Ground wire to the Orange Pi.

Type Control-C to quit

Button It Up
Now that you have the LED working, lets add code so the LED turns on whenever the
button is pressed

import time
import board
import digitalio

print("press the button!")

led = digitalio.DigitalInOut(board.PD14)
led.direction = digitalio.Direction.OUTPUT

button = digitalio.DigitalInOut(board.PA6)
button.direction = digitalio.Direction.INPUT
# use an external pullup since we don't have internal PU's
#button.pull = digitalio.Pull.UP

while True:
led.value = not button.value # light when button is pressed!

Press the button - see that the LED lights up!

Type Control-C to quit

I2C Sensors & Devices

The most popular electronic sensors use I2C to communicate. This is a 'shared bus' 2
wire protocol, you can have multiple sensors connected to the two SDA and SCL pins
as long as they have unique addresses (check this guide for a list of many popular
devices and their addresses ())

Lets show how to wire up a popular BME280. This sensor provides temperature,
barometric pressure and humidity data over I2C

We're going to do this in a lot more depth than our guide pages for each sensor, but
the overall technique is basically identical for any and all I2C sensors.

©Adafruit Industries Page 31 of 57

 Honestly, the hardest part of using I2C devices is figuring out the I2C address () and
which pin is SDA and which pin is SCL!

Don't forget you have to enable I2C overlay

Parts Used
Adafruit BME280 I2C or SPI Temperature
Humidity Pressure Sensor
Bosch has stepped up their game with
their new BME280 sensor, an
environmental sensor with temperature,
barometric pressure and humidity! This
sensor is great for all sorts...
https://www.adafruit.com/product/2652

We recommend using a breadboard and some female-male wires.

Premium Female/Male 'Extension' Jumper

Wires - 40 x 6" (150mm)
Handy for making wire harnesses or
jumpering between headers on PCB's.
These premium jumper wires are 6"
(150mm) long and come in a 'strip' of 40 (4
pieces of each of...
https://www.adafruit.com/product/826

You can use a Cobbler to make this a little easier, the pins are then labeled!

©Adafruit Industries Page 32 of 57

 Adafruit Pi Cobbler + Kit- Breakout Cable
for Pi B+/A+/Pi 2/Pi 3
The Raspberry Pi B+ has landed on the
Maker World like a 40-GPIO pinned, quad-
USB ported, credit card sized bomb of
DIY joy. And while you can use most of
our great Model B accessories...
https://www.adafruit.com/product/1990

Assembled Pi T-Cobbler Plus - GPIO

Breakout
This is the assembled version of the Pi T-
Cobbler Plus.  It only works with the
Raspberry Pi Model Zero, A+, B+, Pi 2, Pi 3
& Pi 4! (Any Pi with 2x20...
https://www.adafruit.com/product/2028

Wiring
• Connect the Orange Pi 3.3V power pin to Vin
• Connect the Orange Pi GND pin to GND
• Connect the Pi SDA pin to the BME280 SDI
• Connect the Pi SCL pin to to the BME280 SCK

There's no Orange Pi PC Fritzing object so we're showing Raspberry Pi which has

the same pinout

©Adafruit Industries Page 33 of 57

 Double-check you have the right wires connected to the right location, it can be
tough to keep track of Pi pins as there are forty of them!

After wiring, we recommend running I2C detection with sudo i2cdetect -y 0 to

verify that you see the device, in this case its address 77

Install the CircuitPython BME280 Library

OK onto the good stuff, you can now install the Adafruit BME280 CircuitPython library.

As of this writing, not all libraries are up on PyPI so you may want to search before
trying to install. Look for circuitpython and then the driver you want.

©Adafruit Industries Page 34 of 57

 (If you don't see it you can open up a github issue on circuitpython to remind us ()!)

Once you know the name, install it with

pip3 install adafruit-circuitpython-bme280

You'll notice we also installed a dependancy called adafruit-circuitpython-busdevice.

This is a great thing about pip, if you have other required libraries they'll get installed
too!

We also recommend an adafruit-blinka update in case we've fixed bugs:

pip3 install --upgrade adafruit_blinka

Run that code!

The finish line is right up ahead. You can now run one of the (many in some cases)
example scripts we've written for you.

©Adafruit Industries Page 35 of 57

 Check out the examples for your library by visiting the repository for the library and
looking in the example folder. In this case, it would be https://github.com/adafruit/
Adafruit_CircuitPython_BME280/tree/master/examples ()

As of this writing there's only one example. But that's cool, here it is:

# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries

# SPDX-License-Identifier: MIT

import time
import board
from adafruit_bme280 import basic as adafruit_bme280

# Create sensor object, using the board's default I2C bus.

i2c = board.I2C() # uses board.SCL and board.SDA
# i2c = board.STEMMA_I2C() # For using the built-in STEMMA QT connector on a
microcontroller
bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)

# OR create sensor object, using the board's default SPI bus.

# spi = board.SPI()
# bme_cs = digitalio.DigitalInOut(board.D10)
# bme280 = adafruit_bme280.Adafruit_BME280_SPI(spi, bme_cs)

# change this to match the location's pressure (hPa) at sea level

bme280.sea_level_pressure = 1013.25

while True:
print("\nTemperature: %0.1f C" % bme280.temperature)
print("Humidity: %0.1f %%" % bme280.relative_humidity)
print("Pressure: %0.1f hPa" % bme280.pressure)
print("Altitude = %0.2f meters" % bme280.altitude)
time.sleep(2)

Save this code to your Pi by copying and pasting it into a text file, downloading it
directly from the Pi, etc.

Then in your command line run

python3 bme280_simpletest.py

The code will loop with the sensor data until you quit with a Control-C

©Adafruit Industries Page 36 of 57

 That's it! Now if you want to read the documentation on the library, what each function
does in depth, visit our readthedocs documentation at

https://circuitpython.readthedocs.io/projects/bme280/en/latest/ ()

SPI Sensors & Devices

SPI is less popular than I2C but still you'll see lots of sensors and chips use it. Unlike
I2C, you don't have everything share two wires. Instead, there's three shared wires (cl
ock, data in, data out) and then a unique 'chip select' line for each chip.

The nice thing about SPI is you can have as many chips as you like, even the same
kind, all share the three SPI wires, as long as each one has a unique chip select pin.

The formal/technical names for the 4 pins used are:

• SPI clock - called SCLK, SCK or CLK

• SPI data out - called MOSI for Microcontroller Out Serial In. This is the wire that
takes data from the Linux computer to the sensor/chip. Sometimes marked SDI
or DI on chips
• SPI data in - called MISO for Microcontroller In Serial Out. This is the wire that
takes data to the Linux computer from the sensor/chip. Sometimes marked SDO
or DO on chips
• SPI chip select - called CS or CE

Remember, connect all SCK, MOSI and MISO pins together (unless there's some
specific reason/instruction not to) and a unique CS pin for each device.

WARNING! SPI on Linux/Orange PI WARNING!

SPI on microcontrollers is fairly simple, you have an SPI peripheral and you can
transfer data on it with some low level command. Its 'your job' as a programmer to
control the CS lines with a GPIO. That's how CircuitPython is structured as well. busi
o does just the SPI transmit/receive part and busdevice handles the chip select pin
as well.

Linux, on the other hand, doesn't let you send data to SPI without a CS line, and the
CS lines are fixed in hardware as well. For example on the Orange Pi PC, there's only
one CS pins available for the hardware SPI pins - SPI_CS known as PC3 - and you hav

©Adafruit Industries Page 37 of 57

 e to use it. (In theory there's an ioctl option called no_cs but this does not actually
work)

The upshot here is - to let you use more than 1 peripheral on SPI, we decided to let
you use any CS pins you like, CircuitPython will toggle it the way you expect. But
when we transfer SPI data we always tell the kernel to use SPI_CS. SPI_CS will toggle
like a CS pin, but if we leave it disconnected, its no big deal

The upshot here is basically never connect anything to SPI_CS. Use whatever chip
select pin you define in CircuitPython and just leave the CS pin alone, it will toggle as
if it is the chip select line, completely on its own, so you shouldn't try to use it as a
digital input/output/whatever.

Don't forget you have to enable SPI with an overlay!

Parts Used
OK now that we've gone thru the warning, lets wire up an SPI MAX31855
thermocouple sensor, this particular device doesn't have a MOSI pin so we'll not
connect it.

Thermocouple Amplifier MAX31855

breakout board (MAX6675 upgrade)
Thermocouples are very sensitive,
requiring a good amplifier with a cold-
compensation reference. The MAX31855K
does everything for you, and can be
easily interfaced with any...
https://www.adafruit.com/product/269

©Adafruit Industries Page 38 of 57

 Thermocouple Type-K Glass Braid
Insulated
Thermocouples are best used for
measuring temperatures that can go
above 100 °C. This is a bare wires bead-
probe which can measure air or surface
temperatures. Most inexpensive...
https://www.adafruit.com/product/270

We recommend using a breadboard and some female-male wires.

Premium Female/Male 'Extension' Jumper

Wires - 40 x 6" (150mm)
Handy for making wire harnesses or
jumpering between headers on PCB's.
These premium jumper wires are 6"
(150mm) long and come in a 'strip' of 40 (4
pieces of each of...
https://www.adafruit.com/product/826

You can use a Cobbler to make this a little easier, the pins are then labeled!

Adafruit Pi Cobbler + Kit- Breakout Cable

for Pi B+/A+/Pi 2/Pi 3
The Raspberry Pi B+ has landed on the
Maker World like a 40-GPIO pinned, quad-
USB ported, credit card sized bomb of
DIY joy. And while you can use most of
our great Model B accessories...
https://www.adafruit.com/product/1990

©Adafruit Industries Page 39 of 57

 Assembled Pi T-Cobbler Plus - GPIO
Breakout
This is the assembled version of the Pi T-
Cobbler Plus.  It only works with the
Raspberry Pi Model Zero, A+, B+, Pi 2, Pi 3
& Pi 4! (Any Pi with 2x20...
https://www.adafruit.com/product/2028

Wiring
• Connect the Orange Pi 3.3V power pin to Vin
• Connect the Orange Pi GND pin to GND
• Connect the Pi SCLK pin to the MAX31855 CLK
• Connect the Pi MISO pin to to the MAX31855 DO
• Connect the Pi GPIO PA7 pin to to the MAX31855 CS

There's no Orange Pi PC Fritzing object, so we'll show using a Raspberry Pi

which has the same pinout

Double-check you have the right wires connected to the right location, it can be
tough to keep track of Pi pins as there are forty of them!

©Adafruit Industries Page 40 of 57

 Install the CircuitPython MAX31855 Library
OK onto the good stuff, you can now install the Adafruit MAX31855 CircuitPython
library.

As of this writing, not all libraries are up on PyPI so you may want to search before
trying to install. Look for circuitpython and then the driver you want.

(If you don't see it you can open up a github issue on circuitpython to remind us ()!)

Once you know the name, install it with

pip3 install adafruit-circuitpython-max31855

©Adafruit Industries Page 41 of 57

 You'll notice we also installed a few other dependancies called spidev, adafruit-
pureio, adafruit-circuitpython-busdevice and more. This is a great thing about pip, if
you have other required libraries they'll get installed too!

We also recommend an adafruit-blinka update in case we've fixed bugs:

pip3 install --upgrade adafruit_blinka

Run that code!

The finish line is right up ahead. You can now run one of the (many in some cases)
example scripts we've written for you.

Check out the examples for your library by visiting the repository for the library and
looking in the example folder. In this case, it would be https://github.com/adafruit/
Adafruit_CircuitPython_MAX31855/tree/master/examples ()

As of this writing there's only one example. But that's cool, here it is:

# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries

# SPDX-License-Identifier: MIT

import time
import board
import digitalio
import adafruit_max31855

spi = board.SPI()
cs = digitalio.DigitalInOut(board.D5)

max31855 = adafruit_max31855.MAX31855(spi, cs)

while True:
tempC = max31855.temperature
tempF = tempC * 9 / 5 + 32
print("Temperature: {} C {} F ".format(tempC, tempF))
time.sleep(2.0)

Save this code to your Pi by copying and pasting it into a text file, downloading it
directly from the Pi, etc.

Change the line that says

cs = digitalio.DigitalInOut(board.D5)

to

©Adafruit Industries Page 42 of 57

 cs = digitalio.DigitalInOut(board.PA7)

Then in your command line run

python3 max31855_simpletest.py

The code will loop with the sensor data until you quit with a Control-C

Make sure you have a K-type thermocouple installed into the sensor breakout or
you will get an error like the one below!

That's it! Now if you want to read the documentation on the library, what each function
does in depth, visit our readthedocs documentation at

https://circuitpython.readthedocs.io/projects/max31855/en/latest/ ()

UART / Serial
After I2C and SPI, the third most popular "bus" protocol used is serial (also sometimes
referred to as 'UART'). This is a non-shared two-wire protocol with an RX line, a TX
line and a fixed baudrate. The most common devices that use UART are GPS units,
MIDI interfaces, fingerprint sensors, thermal printers, and a scattering of sensors.

One thing you'll notice fast is that most linux computers have minimal UARTs, often
only 1 hardware port. And that hardware port may be shared with a console.

©Adafruit Industries Page 43 of 57

 There are two ways to connect UART / Serial devices to your Orange Pi. The easy
way, and the hard way.

We'll demonstrate wiring up & using an Ultimate GPS with both methods

Adafruit Ultimate GPS Breakout - 66

channel w/10 Hz updates
We carry a few different GPS modules
here in the Adafruit shop, but none that
satisfied our every desire - that's why we
designed this little GPS breakout board.
We believe this is...
https://www.adafruit.com/product/746

The Easy Way - An External USB-Serial

Converter
By far the easiest way to add a serial port is to use a USB to serial converter cable or
breakout. They're not expensive, and you simply plug it into the USB port. On the
other end are wires or pins that provide power, ground, RX, TX and maybe some
other control pads or extras.

Here are some options, they have varying chipsets and physical designs but all will do
the job. We'll list them in order of recommendation.

The first cable is easy to use and even has little plugs that you can arrange however
you like, it contains a CP2102

USB to TTL Serial Cable - Debug /

Console Cable for Raspberry Pi
The cable is easiest way ever to connect
to your microcontroller/Raspberry Pi/WiFi
router serial console port. Inside the big
USB plug is a USB<->Serial conversion
chip and at...
https://www.adafruit.com/product/954

©Adafruit Industries Page 44 of 57

 The CP2104 Friend is low cost, easy to use, but requires a little soldering, it has an '6-
pin FTDI compatible' connector on the end, but all pins are broken out the sides

Adafruit CP2104 Friend - USB to Serial

Converter
Discontinued - you can grab Adafruit
CP2102N Friend - USB to Serial
Converter instead! Long gone are...
https://www.adafruit.com/product/3309

Both the FTDI friend and cable use classic FTDI chips, these are more expensive than
the CP2104 or PL2303 but sometimes people like them!

FTDI Friend + extras

Long gone are the days of parallel ports
and serial ports. Now the USB port reigns
supreme! But USB is hard, and you just
want to transfer your every-day serial data
from a...
https://www.adafruit.com/product/284

FTDI Serial TTL-232 USB Cable

Just about all electronics use TTL serial
for debugging, bootloading,
programming, serial output, etc. But it's
rare for a computer to have a serial port
anymore. This is a USB to...
https://www.adafruit.com/product/70

You can wire up the GPS by connecting the following

• GPS Vin  to USB 5V or 3V (red wire on USB console cable)

©Adafruit Industries Page 45 of 57

 • GPS Ground to USB Ground (black wire)
• GPS RX to USB TX (green wire)
• GPS TX to USB RX (white wire)

Once the USB adapter is plugged in, you'll need to figure out what the serial port
name is. You can figure it out by unplugging-replugging in the USB and then typing
dmesg | tail -10 (or just dmesg ) and looking for text like this:

At the bottom, you'll see the 'name' of the attached device, in this case its ttyUSB0 ,
that means our serial port device is available at /dev/ttyUSB0

The Hard Way - Using Built-in UART

If you don't want to plug in external hardware to the Pi you can use the built in UART
on the RX/TX pins. Unlike the Raspberry Pi, the Orange Pi isn't using the RX/TX pins
for a console, those are on a different UART peripheral, so as long as you've activated
UART3 (see the Install page) you should be good to go!

You can use the built in UART via /dev/ttyS3

Wire the GPS as follows:

There's no Orange Pi Fritzing object, but the Raspberry Pi has the same pinout so
we're using that instead

©Adafruit Industries Page 46 of 57

 Install the CircuitPython GPS Library
OK onto the good stuff, you can now install the Adafruit GPS CircuitPython library.

As of this writing, not all libraries are up on PyPI so you may want to search before
trying to install. Look for circuitpython and then the driver you want.

(If you don't see it you can open up a github issue on circuitpython to remind us ()!)

Once you know the name, install it with

pip3 install pyserial adafruit-circuitpython-gps

You'll notice we also installed a dependancy called pyserial. This is a great thing
about pip, if you have other required libraries they'll get installed too!

We also recommend an adafruit-blinka update in case we've fixed bugs:

©Adafruit Industries Page 47 of 57

 pip3 install --upgrade adafruit_blinka

Run that code!

The finish line is right up ahead. You can now run one of the (many in some cases)
example scripts we've written for you.

Check out the examples for your library by visiting the repository for the library and
looking in the example folder. In this case, it would be https://github.com/adafruit/
Adafruit_CircuitPython_GPS/tree/master/examples ()

Lets start with the simplest, the echo example

# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries

# SPDX-License-Identifier: MIT

# Simple GPS module demonstration.

# Will print NMEA sentences received from the GPS, great for testing connection
# Uses the GPS to send some commands, then reads directly from the GPS
import time
import board
import busio

import adafruit_gps

# Create a serial connection for the GPS connection using default speed and
# a slightly higher timeout (GPS modules typically update once a second).
# These are the defaults you should use for the GPS FeatherWing.
# For other boards set RX = GPS module TX, and TX = GPS module RX pins.
uart = busio.UART(board.TX, board.RX, baudrate=9600, timeout=10)

# for a computer, use the pyserial library for uart access

# import serial
# uart = serial.Serial("/dev/ttyUSB0", baudrate=9600, timeout=10)

# If using I2C, we'll create an I2C interface to talk to using default pins
# i2c = board.I2C() # uses board.SCL and board.SDA
# i2c = board.STEMMA_I2C() # For using the built-in STEMMA QT connector on a
microcontroller

# Create a GPS module instance.

gps = adafruit_gps.GPS(uart) # Use UART/pyserial
# gps = adafruit_gps.GPS_GtopI2C(i2c) # Use I2C interface

# Initialize the GPS module by changing what data it sends and at what rate.
# These are NMEA extensions for PMTK_314_SET_NMEA_OUTPUT and
# PMTK_220_SET_NMEA_UPDATERATE but you can send anything from here to adjust
# the GPS module behavior:
# https://cdn-shop.adafruit.com/datasheets/PMTK_A11.pdf

# Turn on the basic GGA and RMC info (what you typically want)
gps.send_command(b"PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0")
# Turn on just minimum info (RMC only, location):
# gps.send_command(b'PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
# Turn off everything:
# gps.send_command(b'PMTK314,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
# Tuen on everything (not all of it is parsed!)
# gps.send_command(b'PMTK314,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0')

©Adafruit Industries Page 48 of 57

 # Set update rate to once a second (1hz) which is what you typically want.
gps.send_command(b"PMTK220,1000")
# Or decrease to once every two seconds by doubling the millisecond value.
# Be sure to also increase your UART timeout above!
# gps.send_command(b'PMTK220,2000')
# You can also speed up the rate, but don't go too fast or else you can lose
# data during parsing. This would be twice a second (2hz, 500ms delay):
# gps.send_command(b'PMTK220,500')

# Main loop runs forever printing data as it comes in

timestamp = time.monotonic()
while True:
data = gps.read(32) # read up to 32 bytes
# print(data) # this is a bytearray type

if data is not None:

# convert bytearray to string
data_string = "".join([chr(b) for b in data])
print(data_string, end="")

if time.monotonic() - timestamp > 5:

# every 5 seconds...
gps.send_command(b"PMTK605") # request firmware version
timestamp = time.monotonic()

We'll need to configure this code to work with our UART port name.

• If you're using a USB-to-serial converter, the device name is probably /dev/

ttyUSB0 - but check dmesg to make sure
• If you're using the built-in UART on the Orange Pi PC, the device name is /dev/
ttyS3

Comment out the lines that reference board.TX , board.RX and busio.uart and
uncomment the lines that import serial and define the serial device, like so:

# Define RX and TX pins for the board's serial port connected to the GPS.
# These are the defaults you should use for the GPS FeatherWing.
# For other boards set RX = GPS module TX, and TX = GPS module RX pins.
#RX = board.RX
#TX = board.TX

# Create a serial connection for the GPS connection using default speed and
# a slightly higher timeout (GPS modules typically update once a second).
#uart = busio.UART(TX, RX, baudrate=9600, timeout=3000)

# for a computer, use the pyserial library for uart access

import serial
uart = serial.Serial("/dev/ttyUSB0", baudrate=9600, timeout=3000)

And update the "/dev/ttyUSB0" device name if necessary to match your USB
interface

Whichever method you use, you should see output like this, with $GP "NMEA
sentences" - there probably wont be actual location data because you haven't gotten

©Adafruit Industries Page 49 of 57

 a GPS fix. As long as you see those $GP strings sorta like the below, you've got it
working!

More To Come!
That's just a taste of what we've got working so far

We're adding more support constantly, so please hold tight and visit the
adafruit_blinka github repo () to share your feedback and perhaps even submit some
improvements!

If you'd like to contribute, but aren't sure where to start, check out the following
guides:

• Adding a Single Board Computer to PlatformDetect for Blinka ()

• Adding a Single Board Computer to Blinka ()

FAQ & Troubleshooting

There's a few oddities when running Blinka/CircuitPython on linux. Here's a list of stuff
to watch for that we know of!

This FAQ covers all the various platforms and hardware setups you can run Blinka on.
Therefore, some of the information may not apply to your specific setup.

Update Blinka/Platform Libraries

Most issues can be solved by forcing Python to upgrade to the latest blinka /
platform-detect libraries. Try running

sudo python3 -m pip install --upgrade --force-reinstall adafruit-

blinka Adafruit-PlatformDetect

©Adafruit Industries Page 50 of 57

 Getting an error message about "board" not found or
"board" has no attribute
Somehow you have ended up with either the wrong board module or no board
module at all.

DO NOT try to fix this by manually installing a library named board . There is one
out there () and it has nothing to do with Blinka. You will break things if you install
that library!

The easiest way to recover is to simply force a reinstall of Blinka with:

python3 -m pip install --upgrade --force-reinstall adafruit-blinka

Mixed SPI mode devices

Due to the way we share an SPI peripheral, you cannot have two SPI devices with
different 'mode/polarity' on the same SPI bus - you'll get weird data

95% of SPI devices are mode 0, check the driver to see mode or polarity settings.
For example:

• LSM9DS1 is mode 1 (), please use in I2C mode instead of SPI

• MAX31865 is phase 1 (), try using this on a separate SPI device, or read data
twice.

Why am I getting AttributeError: 'SpiDev' object has no

attribute 'writebytes2'?
This is due to having an older version of spidev (). You need at least version 3.4.
This should have been taken care of () when you installed Blinka, but in some
cases it does not seem to happen.

To check what version of spidev Python is using:

$ python3
Python 3.6.8 (default, Oct 7 2019, 12:59:55)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more
information.
>>> import spidev
>>> spidev.__version__

©Adafruit Industries Page 51 of 57

 '3.4'
>>>

If you see a version lower then 3.4 reported, then try a force upgrade of spidev
with (back at command line):

sudo python3 -m pip install --upgrade --force-reinstall spidev

No Pullup/Pulldown support on some linux boards or

MCP2221
Some linux boards, for example, AllWinner-based, do not have support to set pull
up or pull down on their GPIO. Use an external resistor instead!

Getting OSError: read error with MCP2221

If you are getting a stack trace that ends with something like:

return self._hid.read(64)
File "hid.pyx", line 122, in hid.device.read
OSError: read error

Try setting an environment variable named BLINKA_MCP2221_RESET_DELAY to a

value of 0.5 or higher.

Windows:

set BLINKA_MCP2221_RESET_DELAY=0.5

Linux:

export BLINKA_MCP2221_RESET_DELAY=0.5

This is a value in seconds to wait between resetting the MCP2221 and the attempt
to reopen it. The reset is seen by the operating system as a hardware disconnect/
reconnect. Different operating systems can need different amounts of time to wait
after the reconnect before the attempt to reopen. Setting the above environment

©Adafruit Industries Page 52 of 57

 variable will override the default reset delay time, allowing it to be increased as
needed for different setups.

Using FT232H with other FTDI devices.

Blinka uses the libusbk driver to talk to the FT232H directly. If you have other FTDI
devices installed that are using the FTDI VCP drivers, you may run into issues. See
here for a possible workaround:

https://forums.adafruit.com/viewtopic.php?f=19&t=166999 ()

Getting "no backend available" with pyusb on Windows

This is probably only an issue for older versions of Windows. If you run into
something like this, see this issue thread:

https://github.com/pyusb/pyusb/issues/120 ()

which describes copying the 32bit and 64bit DLLs into specific folders. (example
for Win7 ())

I can't get neopixel, analogio, audioio, rotaryio, displayio

or pulseio to work!
Some CircuitPython modules like may not be supported.

• Most SBCs do not have analog inputs so there is no analogio

• Few SBCs have neopixel support so that is only available on Raspberry Pi
(and any others that have low level neopixel protocol writing
• Rotary encoders ( rotaryio ) is handled by interrupts on microcontrollers,
and is not supported on SBCs at this time
• Likewise pulseio PWM support is not supported on many SBCs, and if it is,
it will not support a carrier wave (Infrared transmission)
• For display usage, we suggest using python Pillow library or Pygame , we
do not have displayio support

We aim to have, at a minimum, digitalio and busio (I2C/SPI). This lets you use
the vast number of driver libraries

For analog inputs, the MCP3xxx library () will give you AnalogIn objects. For PWM
outputs, try the PCA9685 (). For audio, use pygame or other Python3 libraries to
play audio.

©Adafruit Industries Page 53 of 57

 Some libraries, like Adafruit_CircuitPython_DHT () will try to bit-bang if pulsein isn't
available. Slow linux boards (<700MHz) may not be able to read the pins fast
enough), you'll just have to try!

Help, I'm getting the message "error while loading shared

libraries: libgpiod.so.2: cannot open shared object file: No
such file or directory"
It looks like libgpiod may not be installed on your board.

Try running the command: sudo apt-get install libgpiod2

= v5.5.0""> When running the libgpiod script, I see the

message: configure: error: "libgpiod needs linux headers
version >= v5.5.0"
Be sure you have the latest libgpiod.py script and run it with the -l or --legacy
flag:

sudo python3 libgpiod.py --legacy

All Raspberry Pi Computers Have:

1 x I2C port with busio (but clock stretching

is not supported in hardware, so you must
set the I2C bus speed to 10KHz to 'fix it')
2 x SPI ports with busio
1 x UART port with serial - note this is
shared with the hardware console
pulseio.pulseIn using gpiod
neopixel support on a few pins
No AnalogIn support (Use an MCP3008 or
similar to add ADC)
No PWM support (Use a PCA9685 or
similar to add PWM)

©Adafruit Industries Page 54 of 57

 Google Coral TPU Dev Boards Have:

1 x I2C port with busio

1 x SPI ports with busio
1 x UART port with serial - note this is
shared with the hardware console
3 x PWMOut support
No NeoPixel support
No AnalogIn support (Use an MCP3008 or
similar to add ADC)

Orange Pi PC Plus Boards Have:

1 x I2C port with busio

1 x SPI ports with busio
1 x UART port with serial
No NeoPixel support
No AnalogIn support (Use an MCP3008 or
similar to add ADC)
No PWM support (Use a PCA9685 or
similar to add PWM)

Orange Pi R1 Boards Have:

1 x I2C port with busio

1 x SPI port with busio
1 x UART port with serial
No NeoPixel support
No AnalogIn support (Use an MCP3008 or
similar to add ADC)
No PWM support (Use a PCA9685 or
similar to add PWM)

©Adafruit Industries Page 55 of 57

 Odroid C2 Boards Have:

1 x I2C port with busio

No SPI support
1 x UART port with serial - note this is
shared with the hardware console
No NeoPixel support
No AnalogIn support (Use an MCP3008 or
similar to add ADC)
No PWM support (Use a PCA9685 or
similar to add PWM)

DragonBoard 410c Boards Have:

2 x I2C port with busio

1 x SPI port with busio
1 x UART port with serial
No NeoPixel support
No AnalogIn support (Use an MCP3008 or
similar to add ADC)
No PWM support (Use a PCA9685 or
similar to add PWM)

NVIDIA Jetson Nano Boards Have:

2 x I2C port with busio

2 x SPI ports with busio
2 x UART port with serial - note one of
these is shared with the hardware console
No NeoPixel support
No AnalogIn support (Use an MCP3008 or
similar to add ADC)
No PWM support (Use a PCA9685 or
similar to add PWM)

©Adafruit Industries Page 56 of 57

 FT232H Breakouts Have:

1x I2C port OR SPI port with busio

12x GPIO pins with digitalio
No UART
No AnalogIn support
No AnalogOut support
No PWM support
If you are using Blinka in FT232H mode (),
then keep in mind these basic limitations.

SPI and I2C can not be used at the same

time since they share the same pins.
GPIO speed is not super fast, so trying to
do arbitrary bit bang like things may run
into speed issues.
There are no ADCs.
There are no DACs.
UART is not available (its a different FTDI
mode)

MCP2221 Breakouts Have:

1x I2C port with busio

4x GPIO pins with digitalio
3x AnalogIn with analogio
1x AnalogOut with analogio
1x UART with pyserial
No PWM support
No hardware SPI support
If you are using Blinka in MCP2221 mode,
then keep in mind these basic limitations.

GPIO speed is not super fast, so trying to

do arbitrary bit bang like things may run
into speed issues.
UART is available via pyserial , the serial
COM port shows up as a second USB
device during enumeration

©Adafruit Industries Page 57 of 57