Interfacing SSD1306 OLED Display with Raspberry Pi Pico

Overview
In this tutorial we will learn about the
Interfacing of SSD1306 OLED Display
with
Raspberry Pi Pico
. The OLED displays are one of the most attractive displays available for a
microcontroller
. It has a good view angle and pixel density which makes it reliable for displaying small level graphics.
The SSD1306 OLED display is available in both
I2C
&
SPI
Modules. But in this tutorial, we will use the
0.96″ I2C OLED Display
as it requires only 2 wires for Interfacing. The Raspberry Pi Pico that comes with an
RP2040 microcontroller
has two Pairs of
I2C Pins
. You can use any of the I2C Pins of Raspberry Pi Pico for
Interfacing SSD1306 OLED Display
We will use
Micropython code
here to used OLED Display with Pico Board. The MicroPython IDE requires the
SSD1306 Driver
Code. After writing the driver code, we can write anything and display it on OLED Display. We will display the
Analog value voltage
from the Potentiometer on OLED Display. But before that we recommend you to go through Raspberry Pi Pico
Getting Started Guide
and also about the way of using the I2C Pin.
Bill of Materials
You cany purchase the required components for this tutorial from the following Amazon link.
S.N.
Components Name
Quantity
Purchase Links

Raspberry Pi Pico

Amazon
AliExpress

0.96" I2C OLED Display

Amazon
AliExpress

Potentiometer

Amazon
AliExpress

Breadboard

Amazon
AliExpress

Jumper Wires

Amazon
AliExpress
SSD1306 OLED Display
The OLED displays are one of the most attractive displays available for a microcontroller because of their viewing angle and pixel density. This
SSD1306
is a
0.96/1.3
inch blue OLED display module. You can interface this display module with any microcontroller using
SPI/IIC protocols
. It is having a resolution of
128×64
. The package includes a display board, a display,4 pin male header pre-soldered to board.
OLED (
Organic Light-Emitting Diode
)
is a self-light-emitting technology composed of a thin, multi-layered organic film placed between an anode and cathode. In contrast to LCD technology, OLED does not require a backlight. OLED possesses high application potential for virtually all types of displays and is regarded as the ultimate technology for the next generation of flat-panel displays.
Interfacing SSD1306 OLED Display with Raspberry Pi Pico
Now let us learn how we can
interface SSD1306 OLED Display with Raspberry Pi Pico
. The Raspberry Pi Pico Board has two pair of I2C Pins. You can use any of the pair of I2C Pins for interfacing applications. To learn more about the I2C Pins use & Applications you can use our
Raspberry Pi Pico I2C Guide
In this example we will feed the input value of analog voltage from Potentiometer to analog Pin
GP28
of Raspberry Pi Pico. Then we will display the analog voltage on OLED Screen. The schematic is very simple and easy to use.
Connect the
SDA & SCL
Pin of OLED Display to PICO
GP8 & GP9
Pin respectively. Connect the
VCC & GND
pin of OLED Display to 3.3V & GND Pin of Pico. You can use a breadboard to Assemble the entire circuit.
OLED Display Raspberry Pi Pico Code
In order to program the Raspberry Pi Pico Board, we will use
MicroPython
programming language. MicroPython is similar to Python. You can either use
Thonny IDE
or the
uPyCraft IDE
for programming and testing the board.
I prefer uPyCraft IDE for programming. The programming here is divided into two main parts:
1. SSD1306.py
2. Main.py
This is because the OLED Display requires
SSD1306 Driver Code first
. We have to write the code for the SSD1306 Driver first. After uploading the SSD1306 Code, we can then run the main.py code.
SSD1306.py
So in uPyCraft IDE, create a
new file
. Copy the following code & save the file by the name
ssd1306.py

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
from
micropython
import
const
import
framebuf
# register definitions
SET_CONTRAST
=
const
(
0x81
)
SET_ENTIRE_ON
=
const
(
0xA4
)
SET_NORM_INV
=
const
(
0xA6
)
SET_DISP
=
const
(
0xAE
)
SET_MEM_ADDR
=
const
(
0x20
)
SET_COL_ADDR
=
const
(
0x21
)
SET_PAGE_ADDR
=
const
(
0x22
)
SET_DISP_START_LINE
=
const
(
0x40
)
SET_SEG_REMAP
=
const
(
0xA0
)
SET_MUX_RATIO
=
const
(
0xA8
)
SET_COM_OUT_DIR
=
const
(
0xC0
)
SET_DISP_OFFSET
=
const
(
0xD3
)
SET_COM_PIN_CFG
=
const
(
0xDA
)
SET_DISP_CLK_DIV
=
const
(
0xD5
)
SET_PRECHARGE
=
const
(
0xD9
)
SET_VCOM_DESEL
=
const
(
0xDB
)
SET_CHARGE_PUMP
=
const
(
0x8D
)
# Subclassing FrameBuffer provides support for graphics primitives
# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
class
SSD1306
(
framebuf
FrameBuffer
)
:
def
__init__
(
self
width
height
external_vcc
)
:
self
width
=
width
self
height
=
height
self
external_vcc
=
external_vcc
self
pages
=
self
height
// 8
self
buffer
=
bytearray
(
self
pages *
self
width
)
super
(
)
__init__
(
self
buffer
self
width
self
height
framebuf
MONO_VLSB
)
self
init_display
(
)
def
init_display
(
self
)
:
for
cmd
in
(
SET_DISP
0x00
# off
# address setting
SET_MEM_ADDR
0x00
# horizontal
# resolution and layout
SET_DISP_START_LINE
0x00
SET_SEG_REMAP
0x01
# column addr 127 mapped to SEG0
SET_MUX_RATIO
self
height

SET_COM_OUT_DIR
0x08
# scan from COM[N] to COM0
SET_DISP_OFFSET
0x00
SET_COM_PIN_CFG
0x02
if
self
width
>

*
self
height
else
0x12
# timing and driving scheme
SET_DISP_CLK_DIV
0x80
SET_PRECHARGE
0x22
if
self
external_vcc
else
0xF1
SET_VCOM_DESEL
0x30
# 0.83*Vcc
# display
SET_CONTRAST
0xFF
# maximum
SET_ENTIRE_ON
# output follows RAM contents
SET_NORM_INV
# not inverted
# charge pump
SET_CHARGE_PUMP
0x10
if
self
external_vcc
else
0x14
SET_DISP
0x01
)
:
# on
self
write_cmd
(
cmd
)
self
fill
(

)
self
show
(
)
def
poweroff
(
self
)
:
self
write_cmd
(
SET_DISP
0x00
)
def
poweron
(
self
)
:
self
write_cmd
(
SET_DISP
0x01
)
def
contrast
(
self
contrast
)
:
self
write_cmd
(
SET_CONTRAST
)
self
write_cmd
(
contrast
)
def
invert
(
self
invert
)
:
self
write_cmd
(
SET_NORM_INV
(
invert
&

)
)
def
show
(
self
)
:
x0
=

x1
=
self
width

if
self
width
==

:
# displays with width of 64 pixels are shifted by 32
x0
+=

x1
+=

self
write_cmd
(
SET_COL_ADDR
)
self
write_cmd
(
x0
)
self
write_cmd
(
x1
)
self
write_cmd
(
SET_PAGE_ADDR
)
self
write_cmd
(

)
self
write_cmd
(
self
pages

)
self
write_data
(
self
buffer
)
class
SSD1306_I2C
(
SSD1306
)
:
def
__init__
(
self
width
height
i2c
addr
=
0x3C
external_vcc
=
False
)
:
self
i2c
=
i2c
self
addr
=
addr
self
temp
=
bytearray
(

)
self
write_list
=
[
b
"\x40"
None
]
# Co=0, D/C#=1
super
(
)
__init__
(
width
height
external_vcc
)
def
write_cmd
(
self
cmd
)
:
self
temp
[

]
=
0x80
# Co=1, D/C#=0
self
temp
[

]
=
cmd
self
i2c
writeto
(
self
addr
self
temp
)
def
write_data
(
self
buf
)
:
self
write_list
[

]
=
buf
self
i2c
writevto
(
self
addr
self
write_list
)
class
SSD1306_SPI
(
SSD1306
)
:
def
__init__
(
self
width
height
spi
dc
res
cs
external_vcc
=
False
)
:
self
rate
=

*
1024
*
1024
dc
init
(
dc
OUT
value
=

)
res
init
(
res
OUT
value
=

)
cs
init
(
cs
OUT
value
=

)
self
spi
=
spi
self
dc
=
dc
self
res
=
res
self
cs
=
cs
import
time
self
res
(

)
time
sleep_ms
(

)
self
res
(

)
time
sleep_ms
(

)
self
res
(

)
super
(
)
_