It's easy to use OLEDs with Python and the Adafruit CircuitPython DisplayIO SSD1306 module. This module allows you to easily write Python code to control the display.
To demonstrate the usage, we'll initialize the library and use Python code to control the OLED from the board's Python REPL.
I2C Initialization
If your display is connected to the board using I2C (like if using a Feather and the FeatherWing OLED) you'll first need to initialize the I2C bus. First import the necessary modules:
import board
Now for either board run this command to create the I2C instance using the default SCL and SDA pins (which will be marked on the boards pins if using a Feather or similar Adafruit board):
i2c = board.I2C()
After initializing the I2C interface for your firmware as described above, you can create an instance of the I2CDisplay bus:
import displayio import i2cdisplaybus import adafruit_displayio_ssd1306 # Release any previously allocated resources displayio.release_displays() display_bus = i2cdisplaybus.I2CDisplay(i2c, device_address=0x3c)
Finally, you can pass the display_bus in and create an instance of the SSD1306 I2C driver by running:
display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)
Now you should be seeing an image of the REPL. Note that the last two parameters to the SSD1306 class initializer are the width and height of the display in pixels. Be sure to use the right values for the display you're using!
Initializing with CircuitPython 9
Because displayio has grown so much since it was first written, it has been split up into separate modules to make better use of space on boards with limited storage. Due to splitting things up, the initialization has changed slightly in CircuitPython 9.
import displayio import i2cdisplaybus import adafruit_displayio_ssd1306 # Release any previously allocated resources displayio.release_displays() display_bus = i2cdisplaybus.I2CDisplayBus(i2c, device_address=0x3c) display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)
128 x 64 size OLEDs (or changing the I2C address)
If you are using a 128x64 display, the I2C address is probably different (0x3d), unless you've changed it by soldering some jumpers:
display_bus = i2cdisplaybus.I2CDisplay(i2c, device_address=0x3d) display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=64)
Adding hardware reset pin
If you have a reset pin (which may be required if your OLED does not have an auto-reset chip like the FeatherWing) also pass in a reset pin like so:
display_bus = i2cdisplaybus.I2CDisplay(i2c, device_address=0x3c, reset=board.D9)
At this point the I2C bus and display are initialized. Skip down to the example code section.
SPI Initialization
If your display is connected to the board using SPI you'll first need to initialize the SPI bus.
If you're using a microcontroller board, run the following commands:
import board
import displayio
import fourwire
import adafruit_displayio_ssd1306
# Release any previously allocated resources
displayio.release_displays()
spi = board.SPI()
tft_cs = board.D5
tft_dc = board.D6
tft_reset = board.D9
display_bus = fourwire.FourWire(spi, command=tft_dc, chip_select=tft_cs,
reset=tft_reset, baudrate=1000000)
display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=64)
The parameters to the FourWire initializer are the pins connected to the display's DC, CS, and reset. Because we are using keyword arguments, they can be in any position. Again make sure to use the right pin names as you have wired up to your board!
Note that the last two parameters to the SSD1306 class initializer are the width and height of the display in pixels. Be sure to use the right values for the display you're using!
# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT
"""
This test will initialize the display using displayio and draw a solid white
background, a smaller black rectangle, and some white text.
"""
import board
import displayio
# from fourwire import FourWire
import terminalio
from adafruit_display_text import label
from i2cdisplaybus import I2CDisplayBus
import adafruit_displayio_ssd1306
displayio.release_displays()
oled_reset = board.D9
# Use for I2C
i2c = board.I2C() # uses board.SCL and board.SDA
# i2c = board.STEMMA_I2C() # For using the built-in STEMMA QT connector on a microcontroller
display_bus = I2CDisplayBus(i2c, device_address=0x3C, reset=oled_reset)
# Use for SPI
# spi = board.SPI()
# oled_cs = board.D5
# oled_dc = board.D6
# display_bus = FourWire(spi, command=oled_dc, chip_select=oled_cs,
# reset=oled_reset, baudrate=1000000)
WIDTH = 128
HEIGHT = 32 # Change to 64 if needed
BORDER = 5
display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=WIDTH, height=HEIGHT)
# Make the display context
splash = displayio.Group()
display.root_group = splash
color_bitmap = displayio.Bitmap(WIDTH, HEIGHT, 1)
color_palette = displayio.Palette(1)
color_palette[0] = 0xFFFFFF # White
bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0)
splash.append(bg_sprite)
# Draw a smaller inner rectangle
inner_bitmap = displayio.Bitmap(WIDTH - BORDER * 2, HEIGHT - BORDER * 2, 1)
inner_palette = displayio.Palette(1)
inner_palette[0] = 0x000000 # Black
inner_sprite = displayio.TileGrid(inner_bitmap, pixel_shader=inner_palette, x=BORDER, y=BORDER)
splash.append(inner_sprite)
# Draw a label
text = "Hello World!"
text_area = label.Label(terminalio.FONT, text=text, color=0xFFFFFF, x=28, y=HEIGHT // 2 - 1)
splash.append(text_area)
while True:
pass
Let's take a look at the sections of code one by one. We start by importing the board so that we can initialize SPI, displayio,(FourWire or I2CDisplayBus depending on your display),terminalio for the font, a label, and the adafruit_displayio_ssd1306 driver.
import board import displayio # from fourwire import FourWire import terminalio from adafruit_display_text import label from i2cdisplaybus import I2CDisplayBus import adafruit_displayio_ssd1306
Next we release any previously used displays. This is important because if the microprocessor is reset, the display pins are not automatically released and this makes them available for use again.
displayio.release_displays()
Next we define the reset line, which will be used for either SPI or I2C.
oled_reset = board.D9
If you're using I2C, you would use this section of code. We set the I2C object to the board's I2C with the easy shortcut function board.I2C(). By using this function, it finds the SPI module and initializes using the default SPI parameters. We also set the display bus to I2CDisplay which makes use of the I2C bus.
# Use for I2C i2c = board.I2C() display_bus = I2CDisplay(i2c, device_address=0x3c, reset=oled_reset)
If you're using SPI, you would use this section of code. Don't forget to update the import section accordingly. We set the SPI object to the board's SPI with the easy shortcut function board.SPI(). By using this function, it finds the SPI module and initializes using the default SPI parameters. We set the OLED's CS (Chip Select), and DC (Data/Command) pins. We also set the display bus to FourWire which makes use of the SPI bus. The SSD1306 needs to be slowed down to 1MHz, so we pass in the additional baudrate parameter.
spi = board.SPI()
oled_cs = board.D5
oled_dc = board.D6
display_bus = FourWire(spi, command=oled_dc, chip_select=oled_cs,
reset=oled_reset, baudrate=1000000)
In order to make it easy to change display sizes, we'll define a few variables in one spot here. We have the display width, the display height and the border size, which we will explain a little further below. If your display is something different than these numbers, change them to the correct setting.
WIDTH = 128 HEIGHT = 32 # Change to 64 if needed BORDER = 5
Finally, we initialize the driver with a width of the WIDTH variable and a height of the HEIGHT variable. If we stopped at this point and ran the code, we would have a terminal that we could type at and have the screen update.
display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=WIDTH, height=HEIGHT)
Next we create a background splash image. We do this by creating a group that we can add elements to and adding that group to the display. In this example, we are limiting the maximum number of elements to 10, but this can be increased if you would like. The display will automatically handle updating the group.
splash = displayio.Group() display.root_group = splash
Next we create a Bitmap that is the full width and height of the display. The Bitmap is like a canvas that we can draw on. In this case we are creating the Bitmap to be the same size as the screen, but only have one color. Although the Bitmaps can handle up to 256 different colors, the display is monochrome so we only need one. We create a Palette with one color and set that color to 0xFFFFFF which happens to be white. If were to place a different color here, displayio handles color conversion automatically, so it may end up black or white depending on the calculation.
color_bitmap = displayio.Bitmap(WIDTH, HEIGHT, 1) color_palette = displayio.Palette(1) color_palette[0] = 0xFFFFFF # White
With all those pieces in place, we create a TileGrid by passing the bitmap and palette and draw it at (0, 0) which represents the display's upper left.
bg_sprite = displayio.TileGrid(color_bitmap,
pixel_shader=color_palette,
x=0, y=0)
splash.append(bg_sprite)
Next we will create a smaller black rectangle. The easiest way to do this is to create a new bitmap that is a little smaller than the full screen with a single color of 0x000000, which is black, and place it in a specific location. In this case, we will create a bitmap that is 5 pixels smaller on each side. This is where the BORDER variable comes into use. It makes calculating the size of the second rectangle much easier. The screen we're using here is 128x64 and we have the BORDER set to 5 , so we'll want to subtract 10 from each of those numbers.
We'll also want to place it at the position (5, 5) so that it ends up centered.
# Draw a smaller inner rectangle
inner_bitmap = displayio.Bitmap(WIDTH-BORDER*2, HEIGHT-BORDER*2, 1)
inner_palette = displayio.Palette(1)
inner_palette[0] = 0x000000 # Black
inner_sprite = displayio.TileGrid(inner_bitmap,
pixel_shader=inner_palette,
x=BORDER, y=BORDER)
splash.append(inner_sprite)
Since we are adding this after the first square, it's automatically drawn on top. Here's what it looks like now.
Next add a label that says "Hello World!" on top of that. We're going to use the built-in Terminal Font. In this example, we won't be doing any scaling because of the small resolution, so we'll add the label directly the main group. If we were scaling, we would have used a subgroup.
Labels are centered vertically, so we'll place it at half the HEIGHT for the Y coordinate and subtract one so it looks good. We use the // operator to divide because we want a whole number returned and it's an easy way to round it. We'll set the width to around 28 pixels make it appear to be centered horizontally, but if you want to change the text, change this to whatever looks good to you. Let's go with some white text, so we'll pass it a value of 0xFFFFFF.
# Draw a label text = "Hello World!" text_area = label.Label(terminalio.FONT, text=text, color=0xFFFFFF, x=28, y=HEIGHT//2-1) splash.append(text_area)
Finally, we place an infinite loop at the end so that the graphics screen remains in place and isn't replaced by a terminal.
while True:
pass
If you've been following along with a FeatherWing or 128x32 OLED, this is what it should look like:
Where to go from here
Be sure to check out this excellent guide to CircuitPython Display Support Using displayio
Page last edited October 21, 2025
Text editor powered by tinymce.
