Activity 2.11: The OLED Display

The Messy Real World — Day 4 of 4

Activity 2.11

The OLED Display

Key Concepts

I²C and Qwiic

Buffered Output

Libraries

Every Reading So Far Went to a Laptop

print() sends text down the USB cable. Unplug the cable and your project goes blind.

A robot on wheels cannot drag a laptop behind it. Before anything can drive away, it needs its own screen.

A Different Kind of Connection

Every part so far got its own pin, wired by hand. The OLED does not. It plugs in with one Qwiic cable that carries power, ground, and two data wires.

Those two data wires are I²C— a shared bus. Many devices can hang off the same pair, each answering to its own address. No breadboard, no resistors, and it only goes in one way.

Somebody Else Wrote the Hard Part

Talking to a screen means sending dozens of specific bytes in a specific order. You are not going to do that by hand, and you do not have to.

SparkFun's library does it. You import it, the same way you imported math and random in Unit 1 — except this one drives hardware.

Ask Before You Assume

if oled.is_connected() == False:
    print("No display found. Check the Qwiic cable.")

A pin is always there. A device on a bus might not be — unplugged cable, wrong port, dead board. Checking first turns a confusing silence into a useful message.

Three Steps, Every Time

oled.clear(oled.PAGE)      # wipe the buffer
oled.print("Hello")        # write into the buffer
oled.display()             # push the buffer to the glass

Nothing appears until display(). The first two lines only change a copy in memory — a buffer — and forgetting the third is the classic way to get a blank screen and no error.

Wrap It Once

def show(oled, line1, line2):
    oled.clear(oled.PAGE)
    oled.print(line1)
    oled.print(line2)
    oled.display()

Four calls, every single frame. Write them once inside a function and the rest of your program just says show(oled, a, b).

Today's Objectives

Connecting a Qwiic device over I²C
Using a library to drive hardware you did not wire yourself
Printing text and numbers to a small screen
Showing a live sensor reading without a laptop attached

Key Terms

I²C: A two-wire bus that lets several devices share the same pair of pins, each with its own address.
Qwiic: SparkFun's solderless connector for I²C — one cable carrying power, ground, and the two data lines.
Buffer: A copy of the screen held in memory. Changes land there first and only appear when pushed to the display.
Library: Someone else's code, imported into yours, handling work you should not have to repeat.

'F' → Fullscreen

Build

Leave the sensors from 2.9 and 2.10 wired. Create a new MicroPython program named 2-11-display.

Task 1: Hello, Screen

Plug the OLED into the QWIIC connector — the small white four-pin socket on the top-left corner of the board. It only fits one way.
Check the display is actually connected before using it.
Clear it, print a word, and push it to the glass.

No breadboard, no resistors, no pins to look up. This is the only part in the whole kit that connects with a single cable.

[PHOTO PLACEHOLDER — Task 1: Qwiic Cable from the Board to the OLED]

1
import qwiic_large_oled
2

3
oled = qwiic_large_oled.QwiicLargeOled()
4
if oled.is_connected() == False:
5
    print("No display found. Check the Qwiic cable.")
6
oled.begin()
7

8
oled.clear(oled.PAGE)
9
oled.print("Hello")
10
oled.display()

Task 2: A Live Number

Bring the temperature sensor and its conversion over from Activity 2.9.
Show the temperature on the screen instead of printing it, and refresh twice a second.
Warm the sensor with your fingers and watch the screen, not the terminal.

oled.print() wants text, and your temperature is a number, so str() has to convert it first — the same casting you met back in Activity 1.8.

1
from machine import Pin, ADC
2
import qwiic_large_oled
3
import time
4

5
temp_sensor = ADC(Pin(41))
6

7
OFFSET = 0.0
8

9
oled = qwiic_large_oled.QwiicLargeOled()
10
if oled.is_connected() == False:
11
    print("No display found. Check the Qwiic cable.")
12
oled.begin()
13

14

15
def read_average(sensor, samples):
16
    total = 0
17
    for i in range(samples):
18
        total = total + sensor.read_u16()
19
        time.sleep(0.01)
20
    return total // samples
21

22

23
def to_celsius(reading):
24
    volts = reading / 65535 * 3.3
25
    return (volts - 0.5) * 100 + OFFSET
26

27

28
while True:
29
    celsius = to_celsius(read_average(temp_sensor, 10))
30
    oled.clear(oled.PAGE)
31
    oled.print(str(round(celsius, 1)) + "C")
32
    oled.display()
33
    time.sleep(0.5)

Task 3: Wrap the Four Calls

Write show(oled, line1, line2) that does clear, print, print, display.
Use it to label the reading, so the screen says what the number means.

1
from machine import Pin, ADC
2
import qwiic_large_oled
3
import time
4

5
temp_sensor = ADC(Pin(41))
6

7
OFFSET = 0.0
8

9
oled = qwiic_large_oled.QwiicLargeOled()
10
if oled.is_connected() == False:
11
    print("No display found. Check the Qwiic cable.")
12
oled.begin()
13

14

15
def read_average(sensor, samples):
16
    total = 0
17
    for i in range(samples):
18
        total = total + sensor.read_u16()
19
        time.sleep(0.01)
20
    return total // samples
21

22

23
def to_celsius(reading):
24
    volts = reading / 65535 * 3.3
25
    return (volts - 0.5) * 100 + OFFSET
26

27

28
def show(oled, line1, line2):
29
    oled.clear(oled.PAGE)
30
    oled.print(line1)
31
    oled.print(line2)
32
    oled.display()
33

34

35
while True:
36
    celsius = to_celsius(read_average(temp_sensor, 10))
37
    show(oled, "Temperature", str(round(celsius, 1)) + "C")
38
    time.sleep(0.5)

Task 4: Two Sensors at Once

Add the light sensor from 2.10.
Show temperature on one line and the light reading on the other.

1
from machine import Pin, ADC
2
import qwiic_large_oled
3
import time
4

5
temp_sensor = ADC(Pin(41))
6
light_sensor = ADC(Pin(42))
7

8
OFFSET = 0.0
9

10
oled = qwiic_large_oled.QwiicLargeOled()
11
if oled.is_connected() == False:
12
    print("No display found. Check the Qwiic cable.")
13
oled.begin()
14

15

16
def read_average(sensor, samples):
17
    total = 0
18
    for i in range(samples):
19
        total = total + sensor.read_u16()
20
        time.sleep(0.01)
21
    return total // samples
22

23

24
def to_celsius(reading):
25
    volts = reading / 65535 * 3.3
26
    return (volts - 0.5) * 100 + OFFSET
27

28

29
def show(oled, line1, line2):
30
    oled.clear(oled.PAGE)
31
    oled.print(line1)
32
    oled.print(line2)
33
    oled.display()
34

35

36
while True:
37
    celsius = to_celsius(read_average(temp_sensor, 10))
38
    light = read_average(light_sensor, 10)
39
    show(oled, str(round(celsius, 1)) + "C", "light " + str(light))
40
    time.sleep(0.5)

Task 5: Status Without a Laptop

Bring back the latching alarm logic from Activity 2.10.
Put ARMED or TRIGGERED on the top line and the temperature underneath.
Close your editor. The board keeps running, and now you can still read it.

That last step is the point of the whole session. Everything you have built so far has needed a laptop to be useful. This does not.

1
from machine import Pin, ADC
2
import qwiic_large_oled
3
import time
4

5
temp_sensor = ADC(Pin(41))
6
light_sensor = ADC(Pin(42))
7

8
OFFSET = 0.0
9
DARK = 12000
10

11
oled = qwiic_large_oled.QwiicLargeOled()
12
if oled.is_connected() == False:
13
    print("No display found. Check the Qwiic cable.")
14
oled.begin()
15

16

17
def read_average(sensor, samples):
18
    total = 0
19
    for i in range(samples):
20
        total = total + sensor.read_u16()
21
        time.sleep(0.01)
22
    return total // samples
23

24

25
def to_celsius(reading):
26
    volts = reading / 65535 * 3.3
27
    return (volts - 0.5) * 100 + OFFSET
28

29

30
def show(oled, line1, line2):
31
    oled.clear(oled.PAGE)
32
    oled.print(line1)
33
    oled.print(line2)
34
    oled.display()
35

36

37
armed = True
38

39
while True:
40
    celsius = to_celsius(read_average(temp_sensor, 10))
41
    light = read_average(light_sensor, 10)
42
    if armed and light < DARK:
43
        armed = False
44
    if armed:
45
        status = "ARMED"
46
    else:
47
        status = "TRIGGERED"
48
    show(oled, status, str(round(celsius, 1)) + "C")
49
    time.sleep(0.5)

[PHOTO PLACEHOLDER — Task 5: OLED Showing ARMED and a Temperature, No Laptop Attached]

Challenge (Optional): Three Lines

Fit a third value on the screen — the potentiometer from 2.8, or a running highest-temperature.
You may need to look up how to position the cursor rather than relying on each print() to fall on the next line.

Checkpoint

The screen lights up and shows text within a second of the script starting
The temperature on the glass matches what the terminal printed in Activity 2.9
Warming the sensor changes the number on screen within a few seconds
Covering the light sensor flips the top line to TRIGGERED, and it stays there
Closing the editor does not stop the display updating

Reflection

Answer the following questions before submitting your work.

Every other component in this unit needed its own pin and its own wiring. The OLED needed one cable. Explain what I²C does that makes that possible.
Leaving out display() gives you a blank screen and no error message at all. Explain what a buffer is and why that mistake is silent rather than noisy.
You wrote show() to wrap four library calls. Compare that to blink_all() in Activity 2.6, which wrapped two functions you wrote yourself. What is the same about why both were worth writing?

Submit

Submit the required files to the appropriate dropbox.