Raspberry Pi: Python Libraries for I2C, SPI, UART
Tags: raspberrypi, python, i2c, uart
Published: 2021-09-06 06:04:02

The Raspberry Pi is one of the most popular single board computers for hobbyists. Its 40 Pins support the protocols I2C, SPI, and UART. If you followed the series, you are familiar with those protocols. But how can you use them with your Raspberry Pi?

This article shows you how to work with these protocols using Python. For each protocol, I will list the libraries, and show you a simple example so you can start easily.

_This article originally appeared at [my blog](https://admantium.com/blog/micro09_raspberry_pi_i2c_spi_uart_python_libraries/)_.

## I2C

You have several choices when working with I2C devices. The ubiquitous and universal library luma offers a [generic serial object](https://luma-core.readthedocs.io/en/latest/interface.html) which supports I2C connection. Usage is simple: Import the library, define the IC2 registers, then start to send and read data. Here is an example how to make an I2C connection

```python
from  luma.core.interface.serial.i2c import i2c

i2c_connection = i2c(port=0, address=0x3c)

i2c_connection.data('Hello')
```

However, the library is intended to create connection objects that are used to instantiate concrete screens, so it might not be suitable if you use other I2C based sensors.

Another option is the Python [smbus2 library](https://pypi.org/project/smbus2/). It supports the i2C protocol and several low-level read and write access methods. It accesses its host built-in smbus kernel module, from which it can get an I2C instance.

```python
from smbus2 import SMBus, i2c_msg

i2c = SMBus(1)

msg = i2c_msg.write(80, 'Hello'.encode())
bus.i2c_rdwr(msg)
```

## SPI

The first step in connecting an SPI device is to figure out to which SPI bus you connect a device. On the Raspberry Pi, [different SPI bus systems](https://www.raspberrypi.org/documentation/computers/raspberry-pi.html#serial-peripheral-interface-spi) exist: 3 SPI bus systems for Raspberry Pi up to version 3, and 7 SPI bus systems for the Raspberry Pi 4. Take a note of the concrete bus, because it will map to a device file in your system which you need to use for configuration.

The SPI protocol is supported by [spidev](https://pypi.org/project/spidev/), an actively maintained library. It makes it easy to connect any attached SPI device, configure this connection with the required specifications (speed in HZ, clock polarity and more), and then reading and writing data to it. Assuming you want to connect an SPI device on bus 5, the following example connects and writes data to the device.

```python
from spidev import SpiDev

spi = SpiDev()
spi.open(5,1)

spi.max_speed_hz = 4000

msg = [0x01, 0x02, 0x03]
spi.xfer(msg)

answer = spi.readbytes(100)
print(answer)

spi.close()
```

Another option is the [Adafruit_Blinka library](https://github.com/adafruit/Adafruit_Blinka), an universal library that wraps the CircuitPython API for devices running MicroPython or CPython. Since the Raspberry Pi works with CPython, you can use this library and its many functions. It provides abstractions to interface the SPI specific GPIO pins of the Pi, and an SPI class to create connections. However, you need to install this library following [additional configuration](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/spi-sensors-devices), and then use the SPI bus 1. Once done, you can work with SPI devices as shown:

```python
import time
import busio

spi = busio.SPI(board.SCK_1, MOSI=board.MOSI_1, MISO=board.MISO_1)

spi.configure(baudrate=400000)

spi.write(b'\x01')
spi.write(b'\x02')
spi.write(b'\x03')

time.sleep(0.120)

answer = spi.read(f)
print(answer)

spi.deinit()
```

## UART

For making UART connections, several options exists. The Python library [pyserial](https://pypi.org/project/pyserial/) provides a simple, configurable object for making serial connection. You can configure the device file, the baud rate, and other communication aspects like the bitesize, parity, timeout and more. It implements Pythons context manager protocols and therefore automatically closes the connection at the end of its program block. Here is an example:

```python
from serial import Serial


with Serial('/dev/ttyUSB0', 9600) as serial:
  serial.send('Hello to Arduino')
  answer = serial.readline()
  print(answer)
```

The second option is again [Adafruit_Blinka library](https://github.com/adafruit/Adafruit_Blinka), specifically the [busio UART API](https://circuitpython.readthedocs.io/projects/blinka/en/latest/api.html#busio.UART). Very similar to PySerial, you can create a connection with the default configuration, and then start to read and write data to it. However, it does not work with device files, but directly with pins.

```python
from busio import UART

serial = UART(14,15,baudrate=9600)

serial.write('Hello to Arduino')
answer = serial.readline()
print(answer)

serial.deinit()
```

## Conclusion

On the Raspberry Pi, several options for working with the protocols I2C, SPI and UART exists. This article is a not-exhaustive list of these libraries. On the one hand, there are very specific libraries, such as `pyserial` for UART, or `spidev` for I2C. On the other hand, universal libraries such as `luma` and `busio` support two or all three protocols. Considering this, I recommend to choose a universal library especially if you intend to connect to a sensor that these libraries already support.