Displaying text on OLED in Raspberry Pi - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output on the OLED?

Given the following Python code snippet for a Raspberry Pi OLED display, what text will appear on the screen?

Raspberry Pi

from PIL import Image, ImageDraw, ImageFont
import Adafruit_SSD1306

# Initialize display
disp = Adafruit_SSD1306.SSD1306_128_64(rst=None)
disp.begin()
disp.clear()
disp.display()

# Create blank image for drawing
width = disp.width
height = disp.height
image = Image.new('1', (width, height))
draw = ImageDraw.Draw(image)

# Load default font
font = ImageFont.load_default()

# Draw text
draw.text((0, 0), 'Hello, Pi!', font=font, fill=255)

# Display image
disp.image(image)
disp.display()

A The OLED displays the text 'Hello, Pi!' at the top-left corner.

B The OLED displays an error message because the font is not loaded.

C The OLED displays nothing because the display was not cleared.

D The OLED displays the text 'Hello, Pi!' centered on the screen.

💡 Hint

Look at the coordinates used in draw.text and the font loading method.

The text 'Hello, Pi!' is drawn at coordinates (0, 0) using the default font, so it appears at the top-left corner. The display is cleared before drawing, so the text is visible.

🧠 Conceptual

intermediate

Why do we call disp.display() after drawing?

In Raspberry Pi OLED programming, why is it necessary to call disp.display() after drawing on the image?

A Because disp.display() sends the drawn image buffer to the OLED hardware to update the screen.

B Because disp.display() clears the screen before drawing new content.

C Because disp.display() loads the font used for drawing text.

D Because disp.display() initializes the OLED display hardware.

💡 Hint

Think about what happens after you draw on an image but before you see it on the screen.

Drawing commands modify an image buffer in memory. Calling disp.display() sends this buffer to the OLED hardware so the changes appear on the screen.

🔧 Debug

advanced

Why does this OLED text not show?

This code runs without errors but the OLED screen stays blank. What is the problem?

Raspberry Pi

from PIL import Image, ImageDraw, ImageFont
import Adafruit_SSD1306

disp = Adafruit_SSD1306.SSD1306_128_64(rst=None)
disp.begin()

width = disp.width
height = disp.height
image = Image.new('1', (width, height))
draw = ImageDraw.Draw(image)

font = ImageFont.load_default()

draw.text((10, 10), 'Test', font=font, fill=255)

# Missing disp.image(image) call
# Missing disp.display() call

A The display is not initialized with disp.begin(), causing no output.

B The font is not loaded correctly, so text cannot be drawn.

C The image mode '1' is incorrect; it should be 'RGB'.

D The code does not call disp.image(image) and disp.display(), so the image is never sent to the OLED.

💡 Hint

Check if the image is sent to the display after drawing.

Drawing on the image alone does not update the OLED. You must call disp.image(image) to set the buffer and disp.display() to refresh the screen.

📝 Syntax

advanced

Identify the syntax error in this OLED text code

Which option contains the correct syntax to draw text on the OLED using PIL and Adafruit_SSD1306?

Raspberry Pi

draw.text((0, 0), 'Hello World', font=font, fill=255)

A draw.text((0, 0), 'Hello World', font=font fill=255)

B draw.text[0, 0]('Hello World', font=font, fill=255)

C draw.text((0, 0), 'Hello World', font=font, fill=255)

D draw.text((0, 0), 'Hello World', font=font, fill='255')

💡 Hint

Check the function call syntax and parameter separators.

Option C uses correct function call syntax with parentheses and commas. Option C uses brackets incorrectly. Option C misses a comma. Option C uses fill as a string instead of an integer.

🚀 Application

expert

How many characters fit on a 128x64 OLED with default font?

Using the default PIL font (approximately 6 pixels wide and 8 pixels tall per character), how many characters can fit on a 128x64 OLED screen in a single line?

A 64 characters

B 21 characters

C 16 characters

D 32 characters

💡 Hint

Divide the screen width by the character width to find how many fit horizontally.

128 pixels width divided by 6 pixels per character equals about 21 characters per line. However, the default font is actually 6 pixels wide including spacing, so 21 is correct. But since 6*21=126, 21 fits. Option B says 32 which is too many. So correct answer is A.

Practice

1. What is the main purpose of using the canvas context when displaying text on an OLED with Raspberry Pi?

easy

A. To draw and update text or graphics on the OLED screen

B. To connect the Raspberry Pi to the internet

C. To install the OLED driver software

D. To power the OLED screen

Solution

1. Step 1: Understand the role of canvas in OLED display

   The canvas context is used to draw graphics or text before showing it on the OLED screen.

2. Step 2: Connect canvas to display update

   Drawing on the canvas allows you to prepare the image or text, which then updates the OLED display when done.

3. Final Answer:

   To draw and update text or graphics on the OLED screen -> Option A

4. Quick Check:

   Canvas draws text/graphics = A [OK]

Hint: Canvas is where you draw before showing on OLED [OK]

Common Mistakes:

• Thinking canvas connects to internet
• Confusing canvas with hardware power
• Assuming canvas installs drivers

2. Which of the following is the correct way to import the OLED device class from the luma.oled.device module in Python?

easy

A. import ssd1306 from luma.oled.device

B. import luma.oled.device.ssd1306

C. from luma.oled import device.ssd1306

D. from luma.oled.device import ssd1306

Solution

1. Step 1: Recall Python import syntax

   Correct import uses 'from module import class' format.

2. Step 2: Match correct module and class names

   The device class for OLED is 'ssd1306' inside 'luma.oled.device'. So 'from luma.oled.device import ssd1306' is correct.

3. Final Answer:

   from luma.oled.device import ssd1306 -> Option D

4. Quick Check:

   Correct Python import = A [OK]

Hint: Use 'from module import class' for specific imports [OK]

Common Mistakes:

• Using dot notation inside import incorrectly
• Trying to import with 'import class from module'
• Importing whole module instead of class

3. What will be the output on the OLED screen after running this code snippet?

from luma.core.interface.serial import i2c
from luma.oled.device import ssd1306
from luma.core.render import canvas

serial = i2c(port=1, address=0x3C)
device = ssd1306(serial)

with canvas(device) as draw:
    draw.text((10, 10), "Hi OLED", fill="white")

medium

A. The text appears but in black color, invisible on screen

B. The screen stays blank with no text

C. The text 'Hi OLED' appears at position (10, 10) in white color

D. An error occurs because 'canvas' is not imported

Solution

1. Step 1: Analyze the code setup

   The code initializes the OLED device and opens a canvas context to draw text at (10, 10) with white color.

2. Step 2: Understand canvas drawing effect

   Text 'Hi OLED' is drawn on the canvas and shown on the OLED screen at the specified position.

3. Final Answer:

   The text 'Hi OLED' appears at position (10, 10) in white color -> Option C

4. Quick Check:

   Text 'Hi OLED' at (10,10) white = D [OK]

Hint: Text inside canvas with fill='white' shows on OLED [OK]

Common Mistakes:

• Forgetting to use 'with canvas' context
• Using wrong fill color making text invisible
• Not initializing device before drawing

4. Identify the error in this code that tries to display 'Hello' on the OLED:

from luma.oled.device import ssd1306
from luma.core.render import canvas

device = ssd1306()

with canvas(device) as draw:
    draw.text((0, 0), "Hello", fill=1)

medium

A. Canvas context is not used properly

B. Missing serial interface initialization for ssd1306 device

C. Incorrect fill color value; should be a string

D. Text coordinates (0, 0) are invalid

Solution

1. Step 1: Check device initialization

   The ssd1306 device requires a serial interface (like i2c) passed during initialization, which is missing here.

2. Step 2: Verify other parts

   Fill value '1' is valid for monochrome, canvas usage is correct, and (0,0) is valid coordinate.

3. Final Answer:

   Missing serial interface initialization for ssd1306 device -> Option B

4. Quick Check:

   Device needs serial interface = C [OK]

Hint: Always initialize ssd1306 with serial interface first [OK]

Common Mistakes:

• Not passing serial interface to device
• Confusing fill color types
• Misusing canvas context syntax

5. You want to display multiple lines of text on an OLED screen using luma.oled. Which approach correctly updates the display with two lines: 'Line 1' at (0,0) and 'Line 2' at (0,15)?

hard

A. Use one canvas context and call draw.text((0,0), 'Line 1') and draw.text((0,15), 'Line 2') inside it

B. Call canvas(device) twice, each time drawing one line separately

C. Draw 'Line 1' outside canvas context and 'Line 2' inside canvas

D. Use draw.text((0,0), 'Line 1\nLine 2') to print both lines at once

Solution

1. Step 1: Understand canvas context usage

   All drawing commands must be inside one canvas context to update the display at once.

2. Step 2: Draw multiple lines with separate coordinates

   Calling draw.text twice inside the same canvas with different y-coordinates correctly places two lines.

3. Final Answer:

   Use one canvas context and call draw.text((0,0), 'Line 1') and draw.text((0,15), 'Line 2') inside it -> Option A

4. Quick Check:

   Multiple texts inside one canvas = B [OK]

Hint: Draw all text lines inside one canvas context [OK]

Common Mistakes:

• Opening multiple canvas contexts causing flicker
• Trying to print multiline string with \n directly
• Drawing outside canvas context