LCD display (16x2) with I2C backpack in Raspberry Pi - Step-by-Step Execution

Concept Flow - LCD display (16x2) with I2C backpack

Start Raspberry Pi

↓

Initialize I2C bus

↓

Create LCD object

↓

Send init commands to LCD

↓

Write text to LCD

↓

Display text on 16x2 screen

↓

End or update display

The Raspberry Pi starts and sets up the I2C bus, then creates an LCD object to send commands and text to the 16x2 LCD screen with an I2C backpack, displaying the desired message.

Execution Sample

Raspberry Pi

import board
import busio
from adafruit_character_lcd.character_lcd_i2c import Character_LCD_I2C

i2c = busio.I2C(board.SCL, board.SDA)
lcd = Character_LCD_I2C(i2c, 16, 2)
lcd.message = "Hello, Pi!"

This code initializes the I2C bus, creates a 16x2 LCD object, and displays the message 'Hello, Pi!' on the screen.

Execution Table

Step	Action	Evaluation	Result
1	Import libraries	Success	Libraries ready for use
2	Initialize I2C bus	busio.I2C(board.SCL, board.SDA)	I2C bus object created
3	Create LCD object	Character_LCD_I2C(i2c, 16, 2)	LCD object ready to send commands
4	Send init commands	lcd initializes display	LCD ready to receive text
5	Set lcd.message	lcd.message = "Hello, Pi!"	Text sent to LCD buffer
6	Display text	LCD shows 'Hello, Pi!'	Message visible on 16x2 screen
7	End	Program ends or waits	Display remains until changed or powered off

💡 Program ends after displaying message; LCD keeps showing text until updated or powered off.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
i2c	None	I2C bus object	I2C bus object	I2C bus object	I2C bus object
lcd	None	None	LCD object created	LCD object with message set	LCD object with message displayed

Key Moments - 3 Insights

Why do we need to initialize the I2C bus before creating the LCD object?

The LCD object uses the I2C bus to communicate with the hardware. Without initializing the I2C bus first (see Step 2 in execution_table), the LCD object cannot send commands or text.

What happens when we set lcd.message to a string?

Setting lcd.message sends the text to the LCD's internal buffer and updates the display (see Step 5 and 6). The text appears on the screen immediately after this assignment.

Does the LCD clear the message automatically when the program ends?

No, the LCD keeps showing the last message until it is changed or the device is powered off (see Step 7). The program ending does not clear the display.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of the lcd variable after Step 3?

A I2C bus object

B None, lcd not created yet

C LCD object created and ready

D Message displayed on LCD

💡 Hint

Check the 'Result' column for Step 3 in the execution_table.

At which step does the text 'Hello, Pi!' actually appear on the LCD screen?

A Step 6

B Step 4

C Step 5

D Step 7

💡 Hint

Look at the 'Action' and 'Result' columns in the execution_table for when the display updates.

If the I2C bus was not initialized, what would happen when creating the LCD object?

A LCD object would still be created successfully

B Program would raise an error or fail to communicate

C Message would display but be blank

D LCD would show default text

💡 Hint

Refer to the importance of Step 2 in the execution_table and key_moments about I2C initialization.

Concept Snapshot

import busio and board to set up I2C
Create I2C bus with busio.I2C(board.SCL, board.SDA)
Create LCD object with Character_LCD_I2C(i2c, 16, 2)
Set lcd.message to display text on 16x2 LCD
LCD keeps message until changed or powered off

Full Transcript

This visual execution shows how a Raspberry Pi communicates with a 16x2 LCD display using an I2C backpack. First, the program imports necessary libraries, then initializes the I2C bus on the Pi's SCL and SDA pins. Next, it creates an LCD object that uses this I2C bus to send commands. The LCD is initialized and ready to receive text. When the program sets lcd.message to a string, the text is sent to the LCD's buffer and appears on the screen. The display remains showing the message even after the program ends until it is changed or the device powers off. Key points include the need to initialize I2C before creating the LCD object and understanding that setting lcd.message updates the display immediately.

Practice

1. What is the main advantage of using an I2C backpack with a 16x2 LCD on a Raspberry Pi?

easy

A. It powers the Raspberry Pi without an external source

B. It reduces the number of GPIO pins needed to control the LCD

C. It allows the LCD to display colors

D. It increases the LCD resolution beyond 16x2

Solution

1. Step 1: Understand I2C backpack purpose

   The I2C backpack simplifies wiring by using only two data lines (SDA and SCL) instead of many GPIO pins.

2. Step 2: Compare options

   Options A, B, and C are unrelated to I2C backpacks; only It reduces the number of GPIO pins needed to control the LCD correctly states the advantage.

3. Final Answer:

   It reduces the number of GPIO pins needed to control the LCD -> Option B

4. Quick Check:

   I2C reduces wiring = D [OK]

Hint: I2C means fewer wires needed for LCD control [OK]

Common Mistakes:

• Thinking I2C changes LCD resolution
• Assuming I2C adds color support
• Confusing power supply with data interface

2. Which Python library is commonly used to control a 16x2 LCD with an I2C backpack on Raspberry Pi?

easy

A. NumPy

B. PIL

C. RPLCD

D. Matplotlib

Solution

1. Step 1: Identify libraries purpose

   RPLCD is designed for controlling LCD displays, including those with I2C backpacks.

2. Step 2: Eliminate unrelated libraries

   PIL is for images, NumPy for math arrays, Matplotlib for plotting; none control LCDs.

3. Final Answer:

   RPLCD -> Option C

4. Quick Check:

   LCD control library = RPLCD [OK]

Hint: RPLCD is the go-to library for LCDs on Raspberry Pi [OK]

Common Mistakes:

• Confusing image or math libraries with LCD control
• Using libraries without I2C support
• Misspelling library names

3. What will be the output on the LCD after running this Python code snippet?

from RPLCD.i2c import CharLCD
lcd = CharLCD('PCF8574', 0x27)
lcd.write_string('Hello\nWorld!')

medium

A. Hello on first line, World! on second line

B. HelloWorld! on first line only

C. SyntaxError due to newline character

D. Nothing displayed because address is wrong

Solution

1. Step 1: Understand write_string with newline

   The '\n' moves the cursor to the second line on the LCD.

2. Step 2: Check address and syntax

   Address 0x27 is a common default; no syntax error in code.

3. Final Answer:

   Hello on first line, World! on second line -> Option A

4. Quick Check:

   Newline moves text to line 2 = C [OK]

Hint: Use '\n' to move to second line on LCD [OK]

Common Mistakes:

• Thinking '\n' causes syntax error
• Assuming text stays on one line
• Using wrong I2C address without checking

4. Identify the error in this code snippet for initializing the LCD with I2C backpack:

from RPLCD.i2c import CharLCD
lcd = CharLCD(i2c_expander='PCF8574', address=0x3F)
lcd.write_string('Test')

medium

A. Missing 'port' parameter for CharLCD initialization

B. The parameter name should be 'address' not 'i2c_expander'

C. The I2C address 0x3F is invalid for this device

D. The parameter 'i2c_expander' should be 'i2c_expander' but is correct here

Solution

1. Step 1: Check CharLCD parameters

   CharLCD requires 'i2c_expander', 'address', and 'port' parameters for I2C setup.

2. Step 2: Identify missing parameter

   The code misses the 'port' parameter, which is needed to specify the I2C bus number.

3. Final Answer:

   Missing 'port' parameter for CharLCD initialization -> Option A

4. Quick Check:

   Missing required 'port' parameter = A [OK]

Hint: Always include 'port' when initializing CharLCD with I2C [OK]

Common Mistakes:

• Assuming address 0x3F is always wrong
• Confusing parameter names
• Omitting required parameters

5. You want to display a scrolling message on a 16x2 LCD with I2C backpack using Python. Which approach is best?

hard

A. Write the full message once and rely on LCD auto-scroll

B. Change the I2C address dynamically during scrolling

C. Clear the LCD and write the full message repeatedly without delay

D. Use a loop to write substrings shifting one character at a time with delays

Solution

1. Step 1: Understand scrolling on 16x2 LCD

   The LCD does not auto-scroll long messages; you must manually shift text.

2. Step 2: Choose method to scroll

   Using a loop to write substrings with delays simulates scrolling smoothly.

3. Step 3: Eliminate wrong options

   Write the full message once and rely on LCD auto-scroll is incorrect because LCD won't auto-scroll; C causes flicker; D is unrelated.

4. Final Answer:

   Use a loop to write substrings shifting one character at a time with delays -> Option D

5. Quick Check:

   Manual substring loop scrolls text = B [OK]

Hint: Scroll by shifting substrings in a timed loop [OK]

Common Mistakes:

• Expecting LCD to auto-scroll long text
• Clearing display too often causing flicker
• Trying to change I2C address during scrolling