You will need a board capable of running CircuitPython such as the Metro M0 Express or the Metro M4 Express. You can also use boards such as the Feather M0 Express or the Feather M4 Express. We recommend either the Metro M4 or the Feather M4 Express because it's much faster and works better for driving a display. For this guide, we will be using a Feather M4 Express. The steps should be about the same for the Feather M0 Express or either of the Metros. If you haven't already, be sure to check out our Feather M4 Express guide.
Preparing the Breakout
Before using the TFT Breakout, you will need to solder the headers or some wires to it. Be sure to check out the Adafruit Guide To Excellent Soldering. After that the breakout should be ready to go.
Required CircuitPython Libraries
To use this display with displayio
, there is only one required library.
First, make sure you are running the latest version of Adafruit CircuitPython for your board.
Next, you'll need to install the necessary libraries to use the hardware--carefully follow the steps to find and install these libraries from Adafruit's CircuitPython library bundle. Our introduction guide has a great page on how to install the library bundle for both express and non-express boards.
Remember for non-express boards, you'll need to manually install the necessary libraries from the bundle:
- adafruit_ssd1351
Before continuing make sure your board's lib folder or root filesystem has the adafruit_ssd1351 file copied over.
Code Example Additional Libraries
For the Code Example, you will need an additional library. We decided to make use of a library so the code didn't get overly complicated.
Go ahead and install this in the same manner as the driver library by copying the adafruit_display_text folder over to the lib folder on your CircuitPython device.
# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries # SPDX-License-Identifier: MIT """ This test will initialize the display using displayio and draw a solid green background, a smaller purple rectangle, and some yellow text. """ import board import terminalio import displayio from adafruit_display_text import label from adafruit_ssd1351 import SSD1351 # Release any resources currently in use for the displays displayio.release_displays() spi = board.SPI() tft_cs = board.D5 tft_dc = board.D6 display_bus = displayio.FourWire( spi, command=tft_dc, chip_select=tft_cs, reset=board.D9, baudrate=16000000 ) display = SSD1351(display_bus, width=128, height=128) # Make the display context splash = displayio.Group() display.root_group = splash color_bitmap = displayio.Bitmap(128, 128, 1) color_palette = displayio.Palette(1) color_palette[0] = 0x00FF00 # Bright Green 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(108, 108, 1) inner_palette = displayio.Palette(1) inner_palette[0] = 0xAA0088 # Purple inner_sprite = displayio.TileGrid(inner_bitmap, pixel_shader=inner_palette, x=10, y=10) splash.append(inner_sprite) # Draw a label text = "Hello World!" text_area = label.Label(terminalio.FONT, text=text, color=0xFFFF00, x=30, y=64) splash.append(text_area) while True: pass
Let's take a look at the sections of code one by one. We're going to take a look at the code for the 1.5" display, but there is also an example available for the 128x96 1.27" display. The example is the same as we are covering in here but with the numbers adjusted for the different height.
We start by importing the board so that we can initialize SPI
, displayio
,terminalio
for the font, a label
, and the adafruit_ssd1351
driver.
import board import displayio import terminalio from adafruit_display_text import label from adafruit_ssd1351 import SSD1351
Next we release any previously used displays. This is important because if the Feather is reset, the display pins are not automatically released and this makes them available for use again.
displayio.release_displays()
Next, 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.
spi = board.SPI() tft_cs = board.D5 tft_dc = board.D6
In the next line, we set the display bus to FourWire which makes use of the SPI bus. Additionally, we need to set the baudrate to 16MHz since that is the maximum speed that the SSD1351 chip will run at. Anything higher creates strange artifacts on the screen.
display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D9, baudrate=16000000)
Finally, we initialize the driver with a width of 128 and a height of 128. 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 = SSD1351(display_bus, width=128, height=128)
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(max_size=10) display.show(splash)
Next we create a Bitmap which 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. The Bitmaps can currently handle up to 256 different colors. We create a Palette with one color and set that color to 0x00FF00 which happens to be green. Colors are Hexadecimal values in the format of RRGGBB. Even though the Bitmaps can only handle 256 colors at a time, you get to define what those 256 different colors are.
color_bitmap = displayio.Bitmap(128, 128, 1) color_palette = displayio.Palette(1) color_palette[0] = 0x00FF00 # Bright Green
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 purple square. The easiest way to do this is the create a new bitmap that is a little smaller than the full screen with a single color and place it in a specific location. In this case, we will create a bitmap that is 10 pixels smaller on each side. The screen is 128x128, so we'll want to subtract 20 from each of those numbers.
We'll also want to place it at the position (10, 10)
so that it ends up centered.
inner_bitmap = displayio.Bitmap(108, 108, 1) inner_palette = displayio.Palette(1) inner_palette[0] = 0xAA0088 # Purple inner_sprite = displayio.TileGrid(inner_bitmap, pixel_shader=inner_palette, x=10, y=10) 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 let's 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 compared to some of the other displays, 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 64 for the Y coordinate, and around 30 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 yellow text, so we'll pass it a value of 0xFFFF00
.
text = "Hello World!" text_area = label.Label(terminalio.FONT, text=text, color=0xFFFF00, x=30, y=64) 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
Where to go from here
Be sure to check out this excellent guide to CircuitPython Display Support Using displayio
Text editor powered by tinymce.